快速上手Xilinx DDR3 IP核(3)——把MIG IP核封装成一个FIFO(上)(Native接口)

作者:孤独的单刀,文章来源:CSDN博客

写在前面
本文将把Xilinx的MIG IP核DDR3的Native接口进行二次封装,将其封装成一个类似FIFO的接口,使其应用起来更加方便简单。

1、框架
这个类FIFO模块主要由以下几个部分组成:

mig_ctrl:顶层模块,使用该模块通过控制MIG IP核间接实现对DDR3芯片的突发写、突发读。分为用户接口与DDR3控制接口,用于只需要控制用户接口即可实现对DDR3芯片的突发写、突发读。用户接口的应用类似FIFO接口,用户只需要提供写使能信号与写入的数据即可实现突发写操作(实际上还需要提供其他信息:如突发长度、起止地址等信息);用户只需要提供读使能信号即可实现突发读操作(实际上还需要提供其他信息:如突发长度、起止地址等信息)。

------fifo_ctrl:分别例化写FIFO与读FIFO,用来缓存用户要写入DDR3的数据与从DDR3中读取的数据,实现DDR3端与用户端的跨时钟域处理。同时生成MIG读写的地址、读写请求信号。每当写FIFO中的数据量超过设置阈值时,即生成ddr3写请求信号,同时更新写入地址,使ddr3_wr生成控制MIG IP的时序来将数据写入DDR3;每当读FIFO中的数据量不足设置阈值时,即生成ddr3读请求信号,同时更新读取地址,使ddr3_rd生成控制MIG IP的时序来从DDR3中读取数据;

-------------写FIFO:写位宽16bit,写端口与用户端相连,写入数据来自用户端;读位宽128bit(DDR3固定突发长度8,位宽16bit),读端口与ddr3_wr模块相连,从FIFO读取数据写入DDR3。

-------------读FIFO:写位宽128bit(DDR3固定突发长度8,位宽16bit),写端口与ddr3_rd模块相连,写入数据来自DDR3;读位宽16bit,读端口与用户端相连,用户从FIFO读取数据即为从DDR3中的缓存数据。

------ddr3_wr:突发写入模块,驱动MIG IP将数据以突发写的方式写入DDR3芯片。

------ddr3_rd:突发读取模块,驱动MIG IP以突发读的方式将数据从DDR3芯片中读出。

MIG IP:Xilinx提供的DDR3 P核,将DDR3读写的复杂时序封装成非常简单的接口供用户使用。

该模块的使用流程:

写端口:

1. 提供写使能信号、写入数据就可实现DDR3的突发写操作,类似FIFO。之所以说类FIFO,是因为还需要提供其他必要信息:突发写的突发长度、DDR3写入的起始地址与结束地址;

2. 用户写入的数据先是被缓存到写FIFO,当写FIFO中的数据量满足设定的阈值(该阈值默认为突发长度)时,生成突发写请求信号,与DDR3突发写的首地址(每一次新的突发写请求都会生成新的首地址(累加));

3. ddr3_wr模块根据突发写信息驱动MIG IP核对DDR3芯片操作,实现一次突发写操作;

4. 此时写FIFO中的数据被读出,写入到DDR3中,FIFO中的数据数量减少,等待用户继续写入数据直到再次超过设定阈值,从而开始新的一次突发写操作。

读端口:

1. 提供读使能信号就可实现DDR3的突发读操作,类似FIFO。之所以说类FIFO,是因为还需要提供其他必要信息:突发读的突发长度、DDR3读取的起始地址与结束地址;
2. 每当读FIFO中的数据量不足设定的阈值(该阈值默认为突发长度)时,生成突发读请求信号,与DDR3突发读的首地址(每一次新的突发读请求都会生成新的首地址(累加));
3. ddr3_rd模块根据突发读信息驱动MIG IP核对DDR3芯片操作,实现一次突发读操作;
4. 此时DDR3中的数据被读出,写入到读FIFO中,FIFO中的数据数量增加,等待用户将数据读出,直到数据量不足设定阈值,从而开始新的一次突发读操作。

2、ddr3_wr突发写模块
2.1、端口
MIG IP核提供了Native接口给用户使用,ddr3_wr模块实际上就是对MIG的Native接口的突发写驱动模块,该模块的输入、输出端口如下:

端口主要分为2个部分:

用户端:输入突发写的相关信号;MIG端:自带的Native接口。

用户写操作的顺序如下(待MIG初始化完成后):

拉高wr_burst_start一个时钟,表示要对DDR3进行一次突发写操作,同时输入突发长度与突发的首地址,拉高wr_burst_busy表示此时正在进行突发写操作

根据MIG Native接口的时序,生成突发写响应信号,该响应信号被连接到上层的写FIFO模块的读端口,这样就把用户写入缓存在写FIFO的数据读出,从而写入DDR3芯片

待写入数据个数满足突发长度后,拉高wr_burst_done信号一个周期,表示一次突发写操作完成

2.2、Verilog代码
完整的Verilog代码如下(代码不复杂,只要实现native接口的时序就可以了,其他请参考注释):

//**************************************************************************
// *** 名称 : ddr3_rw
// *** 作者 : 孤独的单刀
// *** 博客 : https://blog.csdn.net/wuzhikaidetb
// *** 日期 : 2021.12
// *** 描述 : 对DDR3进行循环读写
//**************************************************************************
module ddr3_wr #
(
parameter integer DATA_WIDTH = 128 , //数据位宽,突发长度为8,16bit,共128bit
parameter integer ADDR_WIDTH = 28 //根据MIG例化而来
)(
//时钟与复位-------------------------------------------------
input ui_clk , //用户时钟
input ui_clk_sync_rst , //复位,高有效
//用户端信号-------------------------------------------------
input wr_burst_start , //一次突发写开始
input [ADDR_WIDTH - 1:0] wr_burst_len , //突发写入的长度
input [ADDR_WIDTH - 1:0] wr_burst_addr , //突发写入的首地址
input [DATA_WIDTH - 1:0] wr_burst_data , //需要突发写入的数据。来源写FIFO
output wr_burst_ack , //突发写响应,高电平表示正在进行突发写操作
output reg wr_burst_done , //一次突发写完成
output reg wr_burst_busy , //突发写忙状态,高电平有效
//MIG端控制信号----------------------------------------------
output reg app_en , //MIG IP发送命令使能
input app_rdy , //MIG IP命令接收准备好标致
output [2:0] app_cmd , //MIG IP操作命令,读或者写
output reg [ADDR_WIDTH - 1:0] app_addr , //MIG IP操作地址
input app_wdf_rdy , //MIG IP数据接收准备好
output app_wdf_wren , //MIG IP写数据使能
output app_wdf_end , //MIG IP突发写当前时钟最后一个数据
output [(DATA_WIDTH/8) - 1:0] app_wdf_mask , //MIG IP数据掩码
output [DATA_WIDTH - 1:0] app_wdf_data //MIG IP写数据
);

//parameter define
localparam WRITE = 3'b000; //MIG写命令
//reg define
reg [ADDR_WIDTH - 1:0] wr_burst_cnt ; //写入数据个数计数器计数
reg [ADDR_WIDTH - 1:0] wr_burst_len_r ; //锁存突发长度
reg [ADDR_WIDTH - 1:0] wr_burst_addr_r ; //锁存突发地址
reg wr_burst_start_r ; //突发开始打一拍,用于锁存突发地址、突发长度
//wire define
wire wr_burst_last ; //拉高表示写入最后一个数据

//*********************************************************************************************
//** main code
//**********************************************************************************************

//不使用掩码
assign app_wdf_mask = 0 ;
//固定为写状态
assign app_cmd = WRITE;
//写指令,命令接收和数据接收都准备好,此时拉高写使能
assign app_wdf_wren = wr_burst_ack;
//从用户端输入的数据直接赋值给MIG IP核
assign app_wdf_data = wr_burst_data;
//由于DDR3芯片时钟和用户时钟的分频选择4:1,突发长度为8,故两个信号相同
assign app_wdf_end = app_wdf_wren;
//处于写使能且是最后一个数据
assign wr_burst_last = app_wdf_wren && (wr_burst_cnt == wr_burst_len_r - 1) ;
//写响应信号,用于从前级获取数据
assign wr_burst_ack = app_en && app_wdf_rdy && app_rdy;

//wr_burst_start打一拍,锁存突发地址、突发长度
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
wr_burst_start_r else
wr_burst_start_r end

//锁存突发长度
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
wr_burst_len_r else if(wr_burst_start)
wr_burst_len_r end

//锁存突发地址
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
wr_burst_addr_r else if(wr_burst_start)
wr_burst_addr_r end

//app_en控制:突发开始时一直拉高,直到突发结束
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
app_en else if(wr_burst_start_r)
app_en else if(wr_burst_last)
app_en else
app_en end

//突发写忙状态,拉高表示其处于突发写状态
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
wr_burst_busy else if(wr_burst_start)
wr_burst_busy else if(wr_burst_done)
wr_burst_busy else
wr_burst_busy end

//写入地址
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
app_addr else if(wr_burst_start_r)
app_addr else if(app_wdf_wren) //
app_addr else
app_addr end

//突发写完成信号
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
wr_burst_done else if(wr_burst_last)
wr_burst_done else
wr_burst_done end

//写入数据个数(突发长度计数器)
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
wr_burst_cnt else if(app_wdf_wren)begin
if(wr_burst_cnt == wr_burst_len_r - 1)
wr_burst_cnt else
wr_burst_cnt end
else
wr_burst_cnt end

endmodule

3、ddr3_rd突发读模块
3.1、端口
MIG IP核提供了Native接口给用户使用,ddr3_rd模块实际上就是对MIG的Native接口的突发读驱动模块,该模块的输入、输出端口如下:

端口主要分为2个部分:

用户端:输入突发读的相关信号;MIG端:自带的Native接口。

用户读操作的顺序如下(待MIG初始化完成后):

拉高rd_burst_start一个时钟,表示要对DDR3进行一次突发读操作,同时输入突发长度与突发的首地址,拉高rd_burst_busy表示此时正在进行突发读操作

根据MIG Native接口的时序,生成突发读响应信号,该响应信号被连接到下层的读FIFO模块的写端口,这样就把MIG 从DDR3芯片读出的数据写入读FIFO

待读出的数据个数满足突发长度后,拉高rd_burst_done信号一个周期,表示一次突发读操作完成

3.2、Verilog代码
完整的Verilog代码如下(代码不复杂,只要实现native接口的时序就可以了,其他请参考注释):

//**************************************************************************
// *** 名称 : ddr3_rd
// *** 作者 : 孤独的单刀
// *** 博客 : https://blog.csdn.net/wuzhikaidetb
// *** 日期 : 2021.12
// *** 描述 : 对DDR3进行循环读写
//**************************************************************************
module ddr3_rd #
(
parameter integer DATA_WIDTH = 128 , //数据位宽,突发长度为8,16bit,共128bit
parameter integer ADDR_WIDTH = 28 //根据MIG例化而来
)
(
//时钟与复位-------------------------------------------------
input ui_clk , //用户时钟
input ui_clk_sync_rst , //复位,高有效
//用户端信号-------------------------------------------------
input rd_burst_start , //一次突发读开始
input [ADDR_WIDTH - 1:0] rd_burst_len , //突发读取的长度
input [ADDR_WIDTH - 1:0] rd_burst_addr , //突发读取的首地址
output [DATA_WIDTH - 1:0] rd_burst_data , //突发读取的数据。存入读FIFO
output rd_burst_ack , //突发读响应,高电平表示正在进行突发读操作
output reg rd_burst_done , //一次突发读完成
output reg rd_burst_busy , //突发读忙状态,高电平有效
//MIG端控制信号----------------------------------------------
output reg app_en , //MIG发送命令使能
input app_rdy , //MIG命令接收准备好标致
output [2:0] app_cmd , //MIG操作命令,读或者写
output reg [ADDR_WIDTH - 1:0] app_addr , //MIG读取DDR3地址
input [DATA_WIDTH - 1:0] app_rd_data , //MIG读出的数据
input app_rd_data_end , //MIG读出的最后一个数据
input app_rd_data_valid //MIG读出的数据有效
);

//parameter define
localparam READ = 3'b001; //MIG读命令
//reg define
reg [ADDR_WIDTH - 1:0] rd_addr_cnt ; //读取地址个数计数
reg [ADDR_WIDTH - 1:0] rd_data_cnt ; //读取数据个数计数
reg [ADDR_WIDTH - 1:0] rd_burst_len_r ; //锁存突发长度
reg [ADDR_WIDTH - 1:0] rd_burst_addr_r ; //锁存突发地址
reg rd_burst_start_r ; //突发开始打一拍,用于锁存突发地址、突发长度
//wire define
wire rd_addr_last ; //拉高
wire rd_data_last ; //拉高读出最后一个数据

//*********************************************************************************************
//** main code
//**********************************************************************************************

//固定为读状态
assign app_cmd = READ;
//将从MIG中读出的数据直接赋值给上级模块
assign rd_burst_data = app_rd_data;
//读出的最后一个地址
assign rd_addr_last = app_en && app_rdy && (rd_addr_cnt == rd_burst_len_r - 1) ;
//读出的最后一个数据
assign rd_data_last = app_rd_data_valid && (rd_data_cnt == rd_burst_len_r - 1) ;
//读响应信号,用于将MIG中的数据输出给上级模块(读出)
assign rd_burst_ack = app_rd_data_valid;

//rd_burst_start打一拍,锁存突发地址、突发长度
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
rd_burst_start_r else
rd_burst_start_r end

//锁存突发长度
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
rd_burst_len_r else if(rd_burst_start)
rd_burst_len_r end

//锁存突发地址
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
rd_burst_addr_r else if(rd_burst_start)
rd_burst_addr_r end

//app_en控制:突发开始时一直拉高,直到突发结束
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
app_en else if(rd_burst_start_r)
app_en else if(rd_addr_last)
app_en else
app_en end

//突发读忙状态,拉高表示其处于突发读状态
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
rd_burst_busy else if(rd_burst_start)
rd_burst_busy else if(rd_burst_done)
rd_burst_busy else
rd_burst_busy end

//读取地址
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
app_addr else if(rd_burst_start_r)
app_addr else if(app_en && app_rdy)
app_addr else
app_addr end

//突发读完成信号
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
rd_burst_done else if(rd_data_last)
rd_burst_done else
rd_burst_done end
//读出地址个数计数(读取突发长度计数器)
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
rd_addr_cnt else if(rd_addr_last)
rd_addr_cnt else if(app_en && app_rdy)begin
rd_addr_cnt end
else
rd_addr_cnt end

//读出数据个数计数
always @(posedge ui_clk) begin
if(ui_clk_sync_rst)
rd_data_cnt else if(rd_data_last)
rd_data_cnt else if(app_rd_data_valid)begin
rd_data_cnt end
else
rd_data_cnt end

endmodule

4、Testbench与仿真结果
4.1、Testbench
Testbench我们把突发写模块与突发读模块一起例化来测试。预期实现功能:1、从地址0开始,突发写入512个数据,写入的数据从0累加到511;2、从地址0开始突发读取512个数据。根据读出的数据与写入数据是否一致来判断突发写、读模块是否设计成功。

需要生成MIG IP核与DDR3的仿真模型,具体方法不讲了,可以参考:

 快速上手Xilinx DDR3 IP核(1)----MIG IP核的介绍及配置(Native接口)

快速上手Xilinx DDR3 IP核(2)----MIG IP核的官方例程与读写测试模块(Native接口)

完整的testbench如下:

//**************************************************************************
// *** 名称 : tb_ddr3_wr_rd
// *** 作者 : 孤独的单刀
// *** 博客 : https://blog.csdn.net/wuzhikaidetb
// *** 日期 : 2021.12
// *** 描述 : 对DDR3写模块、读模块进行测试
//**************************************************************************
`timescale 1ns/100ps

module tb_ddr3_wr_rd();
//==================================================================
//parameter define-----------------------------------
parameter integer DATA_WIDTH = 128 ; //数据位宽,突发长度为8,16bit,共128bit
parameter integer ADDR_WIDTH = 28 ; //根据MIG例化而来
parameter integer TEST_BURST_LEN = 512 ; //测试单次突发长度
//时钟和复位 ------------------------------------
reg sys_clk ; //系统时钟
reg sys_rst_n ; //系统复位
wire ui_clk ; //用户时钟
wire locked ; //锁相环频率稳定标志
wire clk_ref_i ; //DDR3参考时钟
wire sys_clk_i ; //MIG IP核输入时钟
wire clk_200 ; //200M时钟
wire ui_clk_sync_rst ; //用户复位信号
wire init_calib_complete ; //校准完成信号
//DDR3相关 --------------------------------------
wire [15:0] ddr3_dq ; //DDR3 数据
wire [1:0] ddr3_dqs_n ; //DDR3 dqs负
wire [1:0] ddr3_dqs_p ; //DDR3 dqs正
wire [13:0] ddr3_addr ; //DDR3 地址
wire [2:0] ddr3_ba ; //DDR3 banck 选择
wire ddr3_ras_n ; //DDR3 行选择
wire ddr3_cas_n ; //DDR3 列选择
wire ddr3_we_n ; //DDR3 读写选择
wire ddr3_reset_n ; //DDR3 复位
wire [0:0] ddr3_ck_p ; //DDR3 时钟正
wire [0:0] ddr3_ck_n ; //DDR3 时钟负
wire [0:0] ddr3_cke ; //DDR3 时钟使能
wire [0:0] ddr3_cs_n ; //DDR3 片选
wire [1:0] ddr3_dm ; //DDR3_dm
wire [0:0] ddr3_odt ; //DDR3_odt
//用户端信号 -----------------------------------
wire rd_burst_ack ; //突发读响应
wire rd_burst_done ; //突发读完成
wire rd_burst_busy ; //突发忙状态
wire [DATA_WIDTH - 1:0] rd_burst_data ; //突发读出的数据
wire wr_burst_ack ; //突发写响应
wire wr_burst_done ; //突发写完成
wire wr_burst_busy ; //突发写忙状态
reg rd_burst_start ; //突发读开始
reg [ADDR_WIDTH - 1:0] rd_burst_len ; //突发长度
reg [ADDR_WIDTH - 1:0] rd_burst_addr ; //突发读首地址
reg wr_burst_start ; //突发写开始
reg [ADDR_WIDTH - 1:0] wr_burst_len ; //突发写长度
reg [ADDR_WIDTH - 1:0] wr_burst_addr ; //突发首地址
reg [DATA_WIDTH - 1:0] wr_burst_data ; //突发数据
//MIG端信号--------------------------------------
wire [ADDR_WIDTH - 1:0] app_addr ; //DDR3 地址
wire [ADDR_WIDTH - 1:0] app_addr_wr ; //DDR3 地址
wire [ADDR_WIDTH - 1:0] app_addr_rd ; //DDR3 地址
wire [2:0] app_cmd ; //用户读写命令
wire [2:0] app_cmd_wr ; //用户读写命令
wire [2:0] app_cmd_rd ; //用户读写命令
wire app_en ; //MIG IP核使能
wire app_en_wr ; //MIG IP核使能
wire app_en_rd ; //MIG IP核使能
wire app_rdy ; //MIG IP核空闲
wire [DATA_WIDTH - 1:0] app_wdf_data ; //用户写数据
wire app_wdf_end ; //突发写当前时钟最后一个数据
wire [15:0] app_wdf_mask ; //写数据屏蔽
wire app_wdf_rdy ; //写空闲
wire app_wdf_wren ; //DDR3 写使能
wire [DATA_WIDTH - 1:0] app_rd_data ; //MIG读出的数据
wire app_rd_data_end ; //MIG读出的最后一个数据
wire app_rd_data_valid ; //MIG读出的数据有效

integer i;
//MIG 时钟赋值,200M-----------------------------
assign clk_ref_i = clk_200 ; //DDR3参考时钟,200M
assign sys_clk_i = clk_200 ; //MIG IP核输入时钟,200M
//分时复用写、读模块
assign app_addr = (rd_burst_busy) ? app_addr_rd : app_addr_wr;
assign app_cmd = (rd_burst_busy) ? app_cmd_rd : app_cmd_wr;
assign app_en = (rd_burst_busy) ? app_en_rd : app_en_wr;
//===========================================================
//设置初始测试条件--------------------------------------------------------
initial begin
sys_clk = 0 ; //初始时钟为0
sys_rst_n rd_burst_start rd_burst_len rd_burst_addr wr_burst_start wr_burst_len wr_burst_addr wr_burst_data #50 //50个时钟周期后
sys_rst_n //写数据---------------------------------------------------------------
@(posedge init_calib_complete) //MIG初始化完成
wr_burst_start wr_burst_len wr_burst_addr @(posedge ui_clk)
wr_burst_start for(i = 0; i @(posedge ui_clk)
if(wr_burst_ack)
wr_burst_data else
i = i - 1;
end

//读数据---------------------------------------------------------------
@(posedge wr_burst_done) //突发写完成
rd_burst_start rd_burst_len rd_burst_addr @(posedge ui_clk)
rd_burst_start end

//设置时钟----------------------------------------------------------------
always #10 sys_clk = ~sys_clk; //系统时钟周期20ns

//===========================================================================
ddr3_rd #(
.DATA_WIDTH (DATA_WIDTH ),
.ADDR_WIDTH (ADDR_WIDTH )
)
u_ddr3_rd(
.ui_clk (ui_clk ),
.ui_clk_sync_rst (ui_clk_sync_rst ),
//MIG端信号
.app_rdy (app_rdy ),
.app_addr (app_addr_rd ),
.app_en (app_en_rd ),
.app_cmd (app_cmd_rd ),
.app_rd_data (app_rd_data ),
.app_rd_data_end (app_rd_data_end ),
.app_rd_data_valid (app_rd_data_valid ),
//用户端信号
.rd_burst_start (rd_burst_start ),
.rd_burst_len (rd_burst_len ),
.rd_burst_addr (rd_burst_addr ),
.rd_burst_data (rd_burst_data ),
.rd_burst_ack (rd_burst_ack ),
.rd_burst_done (rd_burst_done ),
.rd_burst_busy (rd_burst_busy )
);
//===========================================================================
ddr3_wr #(
.DATA_WIDTH (DATA_WIDTH ),
.ADDR_WIDTH (ADDR_WIDTH )
)
u_ddr3_wr(
.ui_clk (ui_clk ),
.ui_clk_sync_rst (ui_clk_sync_rst ),
//MIG端信号------------------------------------------
.app_rdy (app_rdy ),
.app_addr (app_addr_wr ),
.app_en (app_en_wr ),
.app_cmd (app_cmd_wr ),
.app_wdf_wren (app_wdf_wren ),
.app_wdf_end (app_wdf_end ),
.app_wdf_data (app_wdf_data ),
.app_wdf_rdy (app_wdf_rdy ),
.app_wdf_mask (app_wdf_mask ),
//用户端信号-----------------------------------------
.wr_burst_start (wr_burst_start ),
.wr_burst_len (wr_burst_len ),
.wr_burst_addr (wr_burst_addr ),
.wr_burst_data (wr_burst_data ),
.wr_burst_ack (wr_burst_ack ),
.wr_burst_done (wr_burst_done ),
.wr_burst_busy (wr_burst_busy )
);
//===========================================================================
mig_7series_0 u_mig_7series_0 (
//DDR3接口-------------------------------------------
.ddr3_addr (ddr3_addr ),
.ddr3_ba (ddr3_ba ),
.ddr3_cas_n (ddr3_cas_n ),
.ddr3_ck_n (ddr3_ck_n ),
.ddr3_ck_p (ddr3_ck_p ),
.ddr3_cke (ddr3_cke ),
.ddr3_ras_n (ddr3_ras_n ),
.ddr3_reset_n (ddr3_reset_n ),
.ddr3_we_n (ddr3_we_n ),
.ddr3_dq (ddr3_dq ),
.ddr3_dqs_n (ddr3_dqs_n ),
.ddr3_dqs_p (ddr3_dqs_p ),
.ddr3_cs_n (ddr3_cs_n ),
.ddr3_dm (ddr3_dm ),
.ddr3_odt (ddr3_odt ),
//用户接口-------------------------------------------
.app_addr (app_addr ),
.app_cmd (app_cmd ),
.app_en (app_en ),
.app_rdy (app_rdy ),
.app_wdf_mask (app_wdf_mask ),
.app_wdf_rdy (app_wdf_rdy ),
.app_wdf_data (app_wdf_data ),
.app_wdf_end (app_wdf_end ),
.app_wdf_wren (app_wdf_wren ),
.app_rd_data (app_rd_data ),
.app_rd_data_end (app_rd_data_end ),
.app_rd_data_valid (app_rd_data_valid ),
.app_sr_req (1'b0 ),
.app_ref_req (1'b0 ),
.app_zq_req (1'b0 ),
.app_sr_active ( ),
.app_ref_ack ( ),
.app_zq_ack ( ),
//全局信号-------------------------------------------
.ui_clk (ui_clk ),
.ui_clk_sync_rst (ui_clk_sync_rst ),
.init_calib_complete (init_calib_complete),
.sys_clk_i (sys_clk_i ),
.clk_ref_i (clk_ref_i ),
.sys_rst (sys_rst_n )
);
//===========================================================================
clk_wiz_0 u_clk_wiz_0
(
.clk_out1 (clk_200 ), // output clk_out1
.reset (1'b0 ), // input resetn
.locked (locked ), // output locked
.clk_in1 (sys_clk ) // input clk_in1
);
//===========================================================================
ddr3_model ddr3_model_inst
(
.rst_n (sys_rst_n ),
.ck (ddr3_ck_p ),
.ck_n (ddr3_ck_n ),
.cke (ddr3_cke ),
.cs_n (ddr3_cs_n ),
.ras_n (ddr3_ras_n ),
.cas_n (ddr3_cas_n ),
.we_n (ddr3_we_n ),
.dm_tdqs (ddr3_dm ),
.ba (ddr3_ba ),
.addr (ddr3_addr ),
.dq (ddr3_dq ),
.dqs (ddr3_dqs_p ),
.dqs_n (ddr3_dqs_n ),
.tdqs_n ( ), //NULL
.odt (ddr3_odt )
);

endmodule

4.2、仿真结果
接下来我们分别观看各个子模块的仿真结果来验证设计功能。

4.2.1、MIG IP模块
在本次设计中,MIG IP模块是最直接对DDR3芯片操作的模块,我们先来观察MIG IP的仿真结果如何:

从上图中可以看到:在MIG初始化完成后,开始了一轮突发写数据的过程,然后突发写停止,开始一轮突发读数据的过程。虽然数据的具体大小从上图无法看到,但至少整个流程是符合我们的预先设计的。再分别截取局部图。

上图中:MIG初始化完成后开始突发写数据,写入的地址从0开始,往后每写入一个数据,地址累加8----DDR3固定突发长度为8,写入的数据从0开始累加1.目前是符合设计要求的。

上图中:是突发写的结束阶段。写入的最后一个地址是4088,写入的最后一个数据是511,说明一共写入了512个数据(0-511)。最后阶段已经开始进行了突发读操作。目前也是符合设计要求的。

看完了突发写操作,再看看突发读操作相关截图。

上图中:是突发读的开始阶段。MIG从地址0开始进行读取操作,其后读取的地址累加8。从发出第一条读指令到第一个读取的数据(伴随读取有效信号)出现需要几个周期的时间,可以看到读出的数据也是从0开始累加1,与写入的数据一致。证明我们的读写操作无误。

上图中:是突发读的结束阶段。最后一个读取的地址是4088,读出的最后一个数据是511,同样与写入的数据一致。

从这里可以看到整个仿真是符合我们预期设计的。但是我们还需要看一下设计的突发写模块ddr3_wr以及突发读模块ddr3_rd的仿真波形。

4.2.2、突发写模块ddr3_wr
老规矩,先看下整体过程,了解下大概:

上图中:拉高了突发写开始信号,标志开始一轮突发写操作(突发长度512、突发首地址0),然后突发写忙信号被拉高,表示此时正在进行突发写操作(可用于后续写、读仲裁的判断),接着不停地写入数据,待写入最后一个数据后,拉高突发写完成标志,表示一次突发写操作完成,同时拉低突发写忙信号,表示此时没有进行突发写操作。

上图中:突发写操作的首地址为0,其后地址累加8,写入的数据从0开始累加1。

上图中:突发写操作的地址累加8,累加1直到511。完成最后一个突发写操作后(写入数据511),拉高突发写完成标志,表示一次突发写操作完成,同时拉低突发写忙信号,表示此时没有进行突发写操作。

4.2.3、突发读模块ddr3_rd
老规矩,先看下整体过程,了解下大概:

上图中:拉高了突发读开始信号,标志开始一轮突发读操作(突发长度512、突发首地址0),然后突发读忙信号被拉高,表示此时正在进行突发读操作(可用于后续写、读仲裁的判断),一段时间后不停地读出数据,待读出最后一个数据后,拉高突发读完成标志,表示一次突发读操作完成,同时拉低突发读忙信号,表示此时没有进行突发读操作。

上图中:从地址0开始读取数据,其后地址累加8,发出读指令后需要一定的时间才能读到对应地址的数据。读出的数据与写入的数据一致。

上图中:对最后一个地址进行读取后,一段时间读到最后一个数据511。然后拉高突发读完成标志,表示一次突发读操作完成,同时拉低突发读忙信号,表示此时没有进行突发读操作。

5、其他
我们下一篇再来讲讲FIFO控制模块,以及将整个类FIFO模块仿真和下板验证。

最新文章