Verilog tutorial for cell based design

Report
Verilog Tutorial
Speaker : T.A. Chung-Yuan Lin
Traditional approach
 Gate level design
 Schematic design
Advancements over the years
 © Intel 4004
Processor
 Introduced in
1971
 2300 Transistors
 108 KHz Clock
 © Intel P4
Processor
 Introduced in 2000
 40 Million
Transistors
 1.5GHz Clock
System Design Pyramid
History:
Need: a simple, intuitive and effective way
of describing digital circuits for modeling,
simulation and analysis.
Developed in 1984-85 by Philip Moorby
In 1990 Cadence opened the language to
the public
Standardization of language by IEEE in
1995
Top-Down Design Approach
Definition of Module
Interface: port and
parameter declaration
Body: Internal part of
module
Add-ons (optional)
Some points to remember
The name of Module
Comments in Verilog
One line comment (// ………….)
Block Comment (/*…………….*/)
Description of Module (optional but
suggested)
Description of Module
The Module Interface
Port List
Port Declaration
Specifications of Ports
Registered Output
Parameter
Test Bench
module main;
reg a, b, c;
wire sum, carry;
fulladder add(a,b,c,sum,carry);
initial
begin
a = 0; b = 0; c = 0;
#5
a = 0; b = 1; c = 0;
#5
a = 1; b = 0; c = 1;
#5
a = 1; b = 1; c = 1;
#5
end
endmodule
Different Levels of Abstraction
Algorithmic
the function of the system
RTL
the data flow
the control signals
the storage element and clock
Gate
gate-level net-list
Switch
transistor-level net-list
Verilog for Digital System Design
Structural description
net-list using primitive gates and switches
continuous assignment using Verilog operators
RTL
functional description
timing controls and concurrency specification
procedural blocks (always and initial)
registers and latches
C + timing controls + concurrency
An HDL to specify your design
One language, Many Coding Style
One language, Many Coding Style (contd.)
One language, Many Coding Style (contd.)
Structural style: Verilog Code
Dataflow style: Verilog Code
Behavioral style: Verilog Code
Hierarchical structure
Represent the hierarchy of a design
modules
the basic building blocks
ports
the I/O pins in hardware
 input, output or inout
Examples
4-bit adder
module add4 (s,c3,ci,a,b)
input [3:0] a,b ;
// port declarations
input ci ;
output [3:0] s :
// vector
output c3 ;
wire [2:0] co ;
add a0 (co[0], s[0], a[0], b[0], ci) ;
add a1 (co[1], s[1], a[1], b[1], co[0]) ;
add a2 (co[2], s[2], a[2], b[2], co[1]) ;
add a3 (c3, s[3], a[3], c3
b[3],a3co[2])a2
;
endmodule
a1
a0
ci
A full-adder
module add (co, s, a, b, c)
input a, b ,c ;
output co, s ;
xor (n1, a, b) ;
xor (s, n1, c) ;
nand (n2, a, b) ;
nand (n3,n1, c) ;
nand (co, n3,n2) ;
endmodule
Data types
 Net
physical wire between devices
the default data type
used in structural modeling and continuous assignment
types of nets
 wire, tri
 wor, trior
 wand, triand
 trireg
 tri1
 tri0
 supply1
 supply0
: default
: wire-ORed
: wire-ANDed
: with capacitive storage
: pull high
; pull low
; power
; ground
Reg
variables used in RTL description
a wire, a storage device or a temporary variable
reg
: unsigned integer variables of varying bit width
integer : 32-bit signed integer
real : signed floating-point
time : 64-bit unsigned integer
Parameters
run-time constants
Modeling Structures
 Net-list
structural description for the top level
 Continuous assignments (combination circuits)
data flow specification for simple combinational
Verilog operators
 Procedural blocks (RTL)
always and initial blocks
 allow timing control and concurrency
C-like procedure statements
 primitives (=truth table, state transition table)
 function and task (function and subroutine)
Gate-Level Modeling
Net-list description
built-in primitives gates
A full-adder
module add (co, s, a, b, c)
input a, b ,c ;
output co, s ;
xor (n1, a, b) ;
xor (s, n1, c) ;
nand (n2, a, b) ;
nand (n3,n1, c) ;
nand (co, n3,n2) ;
endmodule
Verilog Primitives
Basic logic gates only
and
or
not
buf
xor
nand
nor
xnor
bufif1, bufif0
notif1, notif0
Primitive Pins Are Expandable
 One output and variable number of inputs
nand (y, in1, in2) ;
nand (y, in1, in2, in3) ;
nand (y, in1, in2, in3, in4) ;
 not and buf
variable number of outputs but only one input
Continuous Assignments
Describe combinational logic
Operands + operators
Drive values to a net
assign out = a&b ; // and gate
assign eq = (a==b) ;
// comparator
wire #10 inv = ~in ;// inverter with delay
wire [7:0] c = a+b ; // 8-bit adder
Avoid logic loops
assign a = b + a ;
asynchronous design
Operators
{}
concatenation
+ - * /
arithmetic
%
modulus
> >= < <=
relational
!
logical NOT
&&
logical AND
||
logical OR
==
logical equality
!=
logical inequality
?:
conditional
~
bit-wise NOT
&
bit-wise AND
|
bit-wise OR
^
bit-wise XOR
^~ ~^ bit-wise XNOR
&
reduction AND
|
reduction OR
~&
reduction NAND
~|
reduction NOR
^
reduction XOR
~^ ^~ reduction XNOR
<<
shift left
>>
shift right
 Logical, bit-wise and unary operators
a = 1011; b = 0010
logical
bit-wise
a || b = 1
a | b = 1011
a && b = 1
a &b = 0010
 Conditional operator
assign z = ({s1,s0} == 2'b00) ? IA :
({s1,s0} == 2'b01) ? IB :
({s1,s0} == 2'b10) ? IC :
({s1,s0} == 2'b11) ? ID :
1'bx ;
assign s = (op == ADD) ? a+b : a-b ;
unary
|a = 1
&a = 0
Operator Precedence
[ ]
( )
!, ~
bit-select or part-select
parentheses
logical and bit-wise
negation
&, |, ~&, ~|, ^, ~^, ^~
reduction operators
+, unary arithmetic
{ } concatenation
*, /, % arithmetic
+, arithmetic
<<, >> shift
>, >=, <, <=
relational
==, != logical equality
&
bit-wise AND
^, ^~, ~^
bit-wise XOR and XNOR
|
bit-wise OR
&&logical AND
||
logical OR
?:
conditional
RTL Modeling
 Describe the system at a high level of
abstraction
 Specify a set of concurrently active procedural
blocks
procedural blocks = digital circuits
 Procedural blocks
initial blocks
test-fixtures to generate test vectors
initial conditions
always blocks
can be combinational circuits
can imply latches or flip-flops
Procedural blocks have the following
components
procedural assignment statements
timing controls
high-level programming language constructs
initial
c
c
statement
c
…
c
…
c
…
c
…
c
…
always
c
c
statement
c
…
c
…
c
…
c
…
c
…
RTL Statements
Procedural and RTL assignments
reg & integer
out = a + b ;
begin . . . end block statements
group statements
if. . . else statements
case statements
for loops
while loops
forever loops
Combinational Always Blocks
A complete sensitivity list (inputs)
always @(a or b or c)
f = a&~c | b&c ;
Simulation results
always @(a or b)
f = a&~c | b&c ;
Parentheses
always @(a or b or c or d)
z=a+b+c+d;
// z = (a+b) + (c+d) ;
Sequential Always Blocks
Inferred latches (Incomplete branch
specifications)
module infer_latch(D, enable, Q);
input D, enable;
output Q;
reg Q;
always @ (D or enable) begin
if (enable)
Q <= D;
end
endmodule
the Q is not specified in a branch
a latch like 74373
Combinational Circuit Design
Outputs are functions of inputs
inputs
comb.
circuits
Examples
MUX
decoder
priority encoder
adder
Outputs
Multiplexor
Net-list (gate-level)
module mux2_1 (out,a,b,sel) ;
output out ;
input a,b,sel ;
not (sel_, sel) ;
and (a1, a, sel_) ;
and (b1, b, sel) ;
or (out, a1, b1) ;
endmodule
Multiplexor
Continuous assignment
module mux2_1 (out,a,b,sel) ;
output out ;
input a,b,sel ;
assign out = (a&~sel)|(b&sel) ;
endmodule
RTL modeling
always @(a or b or sel)
if(sel)
out = b;
else
out = a;
Multiplexor
4-to-1 multiplexor
module mux4_1 (out, in0, in1, in2, in3, sel) ;
output out ;
input in0,in1,in2,in3 ;
input [1:0] sel ;
assign out = (sel == 2'b00) ? in0 :
(sel == 2'b01) ? in1 :
(sel == 2'b10) ? in2 :
(sel == 2'b11) ? in3 :
1'bx ;
endmodule
module mux4_1 (out, in, sel) ;
output out ;
input [3:0] in ;
input [1:0] sel ;
reg out ;
always @(sel or in) begin
case(sel)
2’d0: out = in[0] ;
2’d1: out = in[1] ;
2’d2: out = in[2] ;
2’d3: out = in[3] ;
default: 1’bx ;
endcase
end
endmodule
Decoder
 3-to 8 decoder with an enable
control
module decoder(o,enb_,sel) ;
output [7:0] o ;
input enb_ ;
input [2:0] sel ;
reg [7:0] o ;
always @ (enb_ or sel)
if(enb_)
o = 8'b1111_1111 ;
else
case(sel)
3'b000 : o = 8'b1111_1110 ;
3'b001 : o = 8'b1111_1101 ;
3'b010 : o = 8'b1111_1011 ;
3'b011 : o = 8'b1111_0111 ;
3'b100 : o = 8'b1110_1111 ;
3'b101 : o = 8'b1101_1111 ;
3'b110 : o = 8'b1011_1111 ;
3'b111 : o = 8'b0111_1111 ;
default : o = 8'bx ;
endcase
endmodule
Adder
RTL modeling
module adder(c,s,a,b) ;
output c ;
output [7:0] s ;
input [7:0] a,b ;
assign {c,s} = a + b ;
endmodule
Logic synthesis
CLA adder for speed optimization
ripple adder for area optimization
Tri-State
The value z
always @ (sela or a)
if (sela)
out = a ;
else
out = 1’bz ;
Another block
always @(selb or b)
if(selb)
out =b ;
else
out = 1’bz ;
assign out = (sela)? a: 1’bz ;
Registers (Flip-flops) are implied
@(posedge clk) or @(negedge clk)
a positive edge-triggered D flip-flop
always @ (posedge clk)
q=d;
Procedural Assignments
Blocking assignments
always @(posedge clk) begin
rega = data ;
regb = rega ;
end
Non-blocking assignments
always @(posedge clk) begin
regc <= data ;
regd <= regc ;
end
Sequential Circuit Design
Inputs
Combinational
circuit
Outputs
Memory
elements
– a feedback path
– the state of the sequential circuits
– the state transition


synchronous circuits
asynchronous circuits
Examples
D flip-flop
D latch
register
shifter
counter
pipeline
FSM
Flip-Flop
Synchronous clear
module d_ff (q,d,clk,clr_) ;
output q ;
input d,clk,clr_ ;
reg q ;
always @ (posedge clk)
if (~clr_)
q=0;
else
q=d;
endmodule
Asynchronous clear
always @ (posedge clk or negedge clr_)
if (~clr_)
q=0;
else
q=d;
Register
module register (q,d,clk,clr_, set_) ;
output [7:0] q ;
input [7:0] d ;
input clk,clr_, set_ ;
reg [7:0] q ;
always @ (posedge clk or negedge clr_ or negedge set_)
if (~clr_)
q=0;
else if (~set_)
q = 8’b1111_1111 ;
else
q=d;
endmodule
D Latches
D latch
always @ (enable or data)
if (enable)
q = data ;
D latch with gated asynchronous data
always @ (enable or data or gate)
if (enable)
q = data & gate ;
D latch with gated ‘enable’
always @ (enable or d or gate)
if (enable & gate)
q=d;
D latch with asynchronous reset
always @ (reset or data or gate)
if (reset)
q = 1’b0
else if(enable)
q = data ;
Shifter
module shifter (so,si,d,clk,ld_,clr_) ;
output so ;
input [7:0] d ;
input si,clk,ld_,clr_ ; // asynchronous clear and synchronous load
reg [7:0] q ;
assign so = q[7] ;
always @ (posedge clk or negedge clr_)
if (~clr_)
ld_ d
q=0;
else if (~ld_)
si
so
q=d;
shifter
clk
else
q[7:0] = {q[6:0],si} ;
endmodule
Counter
module bcd_counter(count,ripple_out,clr,clk) ;
output [3:0] count ;
output ripple_out ;
reg [3:0] count ;
input clr,clk ;
wire ripple_out = (count == 4'b1001) ? 0:1 ; // combinational
always @ (posedge clk or posedge clr) // combinational +
sequential
if (clr) ;
count = 0 ;
else if (count == 4'b1001)
count = 0 ;
else
count = count + 1 ;
endmodule
Memory
module memory (data, addr, read, write);
input read, write;
input [4:0] addr;
inout [7:0] data;
reg [7:0] data_reg;
reg [7:0] memory [0:8'hff];
parameter load_file = "cput1.txt";
assign data = (read) ? memory [addr] : 8'hz;
always @ (posedge write)
memory[addr] = data;
initial
$readmemb (load_file, memory);
endmodule
Finite State Machine
Moore model
inputs comb. next memory current comb.
outputs
state
state
circuit
elements
circuit
Mealy model
inputs comb. next memory current comb.
outputs
state
state
circuit
elements
circuit
Inefficient Description
module count (clock, reset, and_bits, or_bits, xor_bits);
input clock, reset;
output and_bits, or_bits, xor_bits;
reg and_bits, or_bits, xor_bits;
reg [2:0] count;
always @(posedge clock) begin
if (reset)
count = 0;
else
count = count + 1;
and_bits = & count;
or_bits = | count;
xor_bits = ^ count;
end
endmodule
Six implied registers
Efficient Description

Separate combinational and sequential circuits
module count (clock, reset,
and_bits, or_bits, xor_bits);
input clock, reset;
output and_bits, or_bits, xor_bits;
reg and_bits, or_bits, xor_bits;
reg [2:0] count;
always @(posedge clock) begin
if (reset)
count = 0;
else
count = count + 1;
end
// combinational circuits
always @(count) begin
and_bits = & count;
or_bits = | count;
xor_bits = ^ count;
end
endmodule
Three registers are used
Mealy Machine Example
module mealy (in1, in2, clk,
reset,out);
0: begin
input in1, in2, clk, reset;
next_state = 1;
output out;
out = 1'b0;
reg current_state, next_state, out;
end
// state flip-flops
1: if (in1) begin
always @(posedge clk or negedge
next_state = 1'b0;
reset)
out = in2;
if (!reset)
end
current_state = 0;
else begin
else
next_state = 1'b1;
current_state = next_state;
out = !in2;
// combinational: next-state and
end
outputs
endcase
always @(in1 or in2 or current_state)
endmodule
case (current_state)
Pipelines
comb.
circuits
flipflops
comb.
circuits
flipflops
comb.
circuits
An example
a
n-sum
Dff
b
c
sum
p
Dff
assign n_sum = a+b
assign p = sum * d_c
// plus D flip-flops
always @ (posedge clk)
sum = n_sum ;
d_c
Dff
out
flipflops
A FSM Example
Traffic Light Controller
Picture of Highway/Farmroad Intersection:
Farmroad
C
HL
FL
Highway
Highway
HL
FL
C
Farmroad
Specifications
Traffic Light Controller
? Tabulation of Inputs and Outputs:
Input Signal
reset
C
TS
TL
Description
place FSM in initial state
detect vehicle on farmroad
short time interval expired
long time interval expired
Output Signal
HG, HY, HR
FG, FY, FR
ST
Description
assert green/yellow/red highway lights
assert green/yellow/red farmroad lights
start timing a short or long interval
? Tabulation of Unique States: Some light configuration imply others
State
S0
S1
S2
S3
Description
Highway green (farmroad red)
Highway yellow (farmroad red)
Farmroad green (highway red)
Farmroad yellow (highway red)
The
block diagram
C
TS
TL
Comb.
circuits
n_state
state
FF’s
Comb.
circuits
HR
HG
HY
FR
FG
FY
State transition diagram
TL + C
Reset
S0: HG
S0
TL•C/ST
S1: HY
TS/ST
TS
S1
S2: FG
S3
TS
TS/ST
TL + C/ST
S2
TL • C
S3: FY
Verilog Description
module traffic_light(HG, HY, HR, FG, FY, FR,ST_o,
tl, ts, clk, reset, c) ;
output HG, HY, HR, FG, FY, FR, ST_o;
input tl, ts, clk, reset, c ;
reg ST_o, ST ;
reg[0:1] state, next_state ;
parameter EVEN= 0, ODD=1 ;
parameter S0= 2'b00, S1=2'b01, S2=2'b10, S3=2'b11;
assign HG = (state == S0) ;
assign HY = (state == S1) ;
assign HR = ((state == S2)||(state == S3)) ;
assign FG = (state == S2) ;
assign FY = (state == S3) ;
assign FR = ((state == S0)||(state == S1)) ;
// flip-flops
[email protected] (posedge clk or posedge reset)
if(reset) // an asynchronous reset
begin
state = S0 ;
ST_o = 0 ;
end
else
begin
state = next_state ;
ST_o = ST ;
end
[email protected] (state or c or tl or ts)
case(state)
// state transition
S0:
if(tl & c)
begin
next_state = S1 ;
TL•C/ST
ST = 1 ;
TS
end
S1
else
TS/ST
begin
next_state = S0 ;
ST = 0 ;
end
TL + C
Reset
S0
TS/ST
S3
TS
TL + C/ST
S2
TL • C
S1:
if (ts) begin
next_state = S2 ;
ST = 1 ;
end
else begin
next_state = S1 ;
ST = 0 ;
end
S2:
if(tl | !c) begin
next_state = S3 ;
ST = 1 ;
end
else begin
next_state = S2 ;
ST = 0 ;
end
TL + C
Reset
S0
TL•C/ST
TS/ST
TS
S1
S3
TS
TS/ST
TL + C/ST
S2
TL • C
S3:
if(ts)
begin
next_state = S0 ;
ST = 1 ;
end
else
begin
next_state = S3 ;
ST = 0 ;
end
endcase
endmodule
TL + C
Reset
S0
TL•C/ST
TS/ST
TS
S1
S3
TS
TS/ST
TL + C/ST
S2
TL • C
Efficient Modeling Techniques
Separate combinational and sequential
circuits
always know your target circuits
Separate structured circuits and random
logic
structured: data path, XORs, MUXs
random logic: control logic, decoder, encoder
Use parentheses control complex
structure
.....
Some main points to remember
Verilog is concurrent
Think while writing your program.
Blocking and Non-blocking Code
Conclusions
Verilog modeling
structured modeling
continuous assignment
RTL modeling
Design digital systems
separate combinational and sequential
description
always keep your target circuits in mind
Reference
Verilog-XL Training Manual, CIC
Logic Synthesis Design Kit, CIC
HDL Compiler for Verilog Reference
Manual, Synopsys
Synthesis Application Notes, Synopsys
Online Documentation
Digital System Design Using Verilog,
Ming-Feng Chang, CSIE, NUTU

similar documents