一、MIG IP核读写时序
如下图是7系列的MIG IP核结构框图。左侧是用户接口，即用户（FPGA）同MIG交互的接口，用户就必须掌握这些接口才可以使用该IP核。
将用户侧的信号分类如下图。
其中的输入输出是相对于MIG IP核的，即对用户侧来说是相反的。
写命令操作时序如下，其中，写操作app_cmd的值等于0，读操作app_cmd的值等于1。首先检查app_rdy，为高则表明此时IP核可以接受用户命令，在当前时钟拉高app_en，同时发送命令app_cmd和地址app_addr，此时命令和地址写入。
写数据的时序图如下。
个人认为一般native接口最好设置为4:1模式，这样app_wdf_wren与app_wdf_end是同步的。解释见后文。
由图可知，写数据有3种情况，即写数据与写命令发生在同一周期，写数据先于写命令，写数据落后与写命令发生（但不能超过两个时钟周期）。
所以写数据时序为：先检查app_wdf_rdy，为高则表明此时IP核可以接收数据，在当前时钟拉高写使能app_wdf_wren，给出写数据app_wdf_data。
读数据的时序图如下。
发出读命令后，用户等待数据有效信号app_rd_data_valid拉高，表明此时读数据有效。
二、MIG IP核配置
这里说明两点。
1.clock period：ddr芯片的时钟频率，双沿采样，2:1,4:1决定了用户时钟ui_clk。若选择2:1，就需要2个周期的写使能有效才能完成一次突发，app_wdf_end将落后app_wdf_end一个时钟周期。若选择4:1，app_wdf_wren与app_wdf_end是同步的。
2.data_width：ddr芯片的数据位宽，看可以选什么，决定了用户接口的输入数据位宽和输出数据位宽。需要满足带宽一致，即ddr芯片时钟* 2 * data_width==用户接口的输入数据位宽 * ui_clk。
input clock period：给MIG IP的系统时钟，与用户无关，一般设置为200mhz。MIG IP内部有个锁相环，利用这个系统时钟产生各种所需的时钟。
system clock： 这里的系统200M时钟由FPGA内部提供，不由管脚输入，根据管脚时钟用IP核生成。选择 No Buffer，如果实际硬件管脚有提供 200MHz 时钟，也可以选择 Differential（差分输入）或 Signal-Ended（单端输入）。
reference clock：该时钟需要频率为200MHz时钟，若在前面配置中将系统时钟设置为200MHz，所以可以选择Use System Clock，这样就可以将两个输入时钟合并一个共用的 200MH 输入。这里我们还是选择No Buffer。
这里选择第二个。其他未出现的信号默认即可。然后绑DDR引脚，生成IP核。
三、模块框图
该ddr3读写控制框图如下。具体流程为：用户将需要存储的数据存入写fifo，fifo_ctrl模块根据写fifo的状态产生写突发信号控制ddr3_wr模块，完成写操作；用户给出读请求，fifo_ctrl模块根据读fifo的状态产生读突发信号控制ddr3_rd模块，完成读操作。
1.ddr3_wr模块
module ddr3_wr
#( parameter integer DATA_WIDTH = 128 , //数据位宽，根据MIG例化而来parameter integer ADDR_WIDTH = 28 //地址位宽
)(
//时钟与复位------------------------------------------------- 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) beginif(ui_clk_sync_rst)wr_burst_start_r <= 0;else wr_burst_start_r <= wr_burst_start;
end//锁存突发长度
always @(posedge ui_clk) beginif(ui_clk_sync_rst)wr_burst_len_r <= 1'b0;else if(wr_burst_start)wr_burst_len_r <= wr_burst_len;
end//锁存突发地址
always @(posedge ui_clk) beginif(ui_clk_sync_rst)wr_burst_addr_r <= 1'b0;else if(wr_burst_start)wr_burst_addr_r <= wr_burst_addr;
end//app_en控制：突发开始时一直拉高，直到突发结束
always @(posedge ui_clk) beginif(ui_clk_sync_rst)app_en <= 0;else if(wr_burst_start_r)app_en <= 1;else if(wr_burst_last)app_en <= 0;else app_en <= app_en;
end//突发写忙状态，拉高表示其处于突发写状态
always @(posedge ui_clk) beginif(ui_clk_sync_rst)wr_burst_busy <= 0;else if(wr_burst_start)wr_burst_busy <= 1; //进入写忙状态else if(wr_burst_done)wr_burst_busy <= 0; //突发写完成，拉低写忙状态else wr_burst_busy <= wr_burst_busy;
end//写入地址
always @(posedge ui_clk) beginif(ui_clk_sync_rst)app_addr <= 0;else if(wr_burst_start_r) app_addr <= wr_burst_addr_r; //将突发写的初始地址赋值给MIGelse if(app_wdf_wren) //app_addr <= app_addr + 8; //else app_addr <= app_addr;
end//突发写完成信号
always @(posedge ui_clk) beginif(ui_clk_sync_rst)wr_burst_done <= 0;else if(wr_burst_last)wr_burst_done <= 1; else wr_burst_done <= 0;
end//写入数据个数（突发长度计数器）
always @(posedge ui_clk) beginif(ui_clk_sync_rst)wr_burst_cnt <= 0;else if(app_wdf_wren)beginif(wr_burst_cnt == wr_burst_len_r - 1) wr_burst_cnt <= 0; //进入写忙状态elsewr_burst_cnt <= wr_burst_cnt + 1;endelse wr_burst_cnt <= wr_burst_cnt;
endendmodule
对于MIG端的控制信号，根据时序图编写代码即可。用户端信号，实际是与fifo_ctrl模块进行交互所需的信号，这里将突发开始信号，突发长度，突发首地址以及突发数据均传入，也需要将该模块的目前状态反馈给前一级模块。
2.ddr3_rd模块
module ddr3_rd
#( parameter integer DATA_WIDTH = 128 , //数据位宽，根据MIG例化而来parameter integer ADDR_WIDTH = 28 //地址位宽
)
(
//时钟与复位------------------------------------------------- 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) beginif(ui_clk_sync_rst)rd_burst_start_r <= 0;else rd_burst_start_r <= rd_burst_start;
end//锁存突发长度
always @(posedge ui_clk) beginif(ui_clk_sync_rst)rd_burst_len_r <= 1'b0;else if(rd_burst_start)rd_burst_len_r <= rd_burst_len;
end//锁存突发地址
always @(posedge ui_clk) beginif(ui_clk_sync_rst)rd_burst_addr_r <= 1'b0;else if(rd_burst_start)rd_burst_addr_r <= rd_burst_addr;
end//app_en控制：突发开始时一直拉高，直到突发结束
always @(posedge ui_clk) beginif(ui_clk_sync_rst)app_en <= 0;else if(rd_burst_start_r)app_en <= 1;else if(rd_addr_last)app_en <= 0;else app_en <= app_en;
end//突发读忙状态，拉高表示其处于突发读状态
always @(posedge ui_clk) beginif(ui_clk_sync_rst)rd_burst_busy <= 0;else if(rd_burst_start)rd_burst_busy <= 1; //进入写忙状态else if(rd_burst_done)rd_burst_busy <= 0; //突发传输完成，拉低写忙状态else rd_burst_busy <= rd_burst_busy;
end//读取地址
always @(posedge ui_clk) beginif(ui_clk_sync_rst)app_addr <= 0;else if(rd_burst_start_r) app_addr <= rd_burst_addr_r; //将突发写的初始地址赋值给MIGelse if(app_en && app_rdy) app_addr <= app_addr + 8; //else app_addr <= app_addr;
end//突发读完成信号
always @(posedge ui_clk) beginif(ui_clk_sync_rst)rd_burst_done <= 0;else if(rd_data_last)rd_burst_done <= 1; else rd_burst_done <= 0;
end
//读出地址个数计数（读取突发长度计数器）
always @(posedge ui_clk) beginif(ui_clk_sync_rst)rd_addr_cnt <= 0;else if(rd_addr_last)rd_addr_cnt <= 0;else if(app_en && app_rdy)beginrd_addr_cnt <= rd_addr_cnt + 1;endelse rd_addr_cnt <= rd_addr_cnt;
end//读出数据个数计数
always @(posedge ui_clk) beginif(ui_clk_sync_rst)rd_data_cnt <= 0;else if(rd_data_last)rd_data_cnt <= 0;else if(app_rd_data_valid)beginrd_data_cnt <= rd_data_cnt + 1;endelse rd_data_cnt <= rd_data_cnt;
endendmodule
3.fifo_ctrl模块
module fifo_ctrl
#(parameter integer FIFO_DATA_WIDTH = 16 , //根据ddr数据位宽而来parameter integer FIFO_ADDR_WIDTH = 28 , parameter integer MIG_DATA_WIDTH = 128 , //数据位宽，根据MIG例化而来parameter integer MIG_ADDR_WIDTH = 28 //地址位宽
)(
//时钟和复位 -----------------------------------------------------input ui_clk , //用户时钟input ui_clk_sync_rst , //复位,高有效input init_calib_complete , //MIG初始化完成标志
//用户操作信号 -------------------------------------------- //写fifo信号-------------------------------------------------input wr_fifo_wr_clk , //写FIFO写时钟input wr_fifo_wr_req , //写FIFO写请求input [FIFO_DATA_WIDTH - 1:0] wr_fifo_wr_data , //写FIFO写数据 input wr_fifo_rst , //写FIFO复位信号 input [FIFO_ADDR_WIDTH - 1:0] wr_b_addr , //写DDR3首地址input [FIFO_ADDR_WIDTH - 1:0] wr_e_addr , //写DDR3末地址input [FIFO_ADDR_WIDTH - 1:0] wr_len , //写DDR3突发长度output [8:0] wr_fifo_num , //写fifo中的数据量，实际是可以读出的数据量//读fifo信号------------------------------------------------- input rd_fifo_rd_clk , //读FIFO读时钟input rd_fifo_rd_req , //读FIFO读请求output [FIFO_DATA_WIDTH - 1:0] rd_fifo_rd_data , //读FIFO读数据 input [FIFO_ADDR_WIDTH - 1:0] rd_b_addr , //读DDR3首地址input [FIFO_ADDR_WIDTH - 1:0] rd_e_addr , //读DDR3末地址input [FIFO_ADDR_WIDTH - 1:0] rd_len , //读DDR3数据突发长度input rd_fifo_rst , //读FIFO复位信号output [8:0] rd_fifo_num , //读fifo中的数据量，实际是已经写进去的数据量//控制信号---------------------------------------------------- input read_valid , //DDR3读使能
//突发读、写模块信号 --------------------------------------------//突发写模块 ------------------------------------------------input wr_burst_busy , //高电平表示正在进行突发写操作input wr_burst_done , //高电平表示完成了一次突发写操作input wr_burst_ack , //突发写模块要写入的数据有效output [MIG_DATA_WIDTH - 1:0] wr_burst_data , //突发写模块要写入的数据 output [FIFO_ADDR_WIDTH - 1:0] wr_burst_len , //突发写长度 output reg wr_burst_req , //请求进行突发写，驱动突发写模块output reg [FIFO_ADDR_WIDTH - 1:0] wr_burst_addr , //突发写入的首地址//突发读模块 ------------------------------------------------input rd_burst_busy , //高电平表示正在进行突发读操作input rd_burst_done , //高电平表示完成了一次突发读操作input rd_burst_ack , //突发读模块读出的数据有效output [FIFO_ADDR_WIDTH - 1:0] rd_burst_len , //突发读长度 output [MIG_DATA_WIDTH - 1:0] rd_burst_data , //突发读模块读出的数据output reg rd_burst_req , //请求进行突发读output reg [FIFO_ADDR_WIDTH - 1:0] rd_burst_addr //突发读的首地址
);
//*********************************************************************************************
//** main code
//**********************************************************************************************assign wr_burst_len = wr_len;
assign rd_burst_len = rd_len;//wr_burst_req,rd_burst_req:读写请求信号
always@(posedge ui_clk)beginif(ui_clk_sync_rst)beginwr_burst_req <= 1'b0;rd_burst_req <= 1'b0;end//初始化完成后响应读写请求,优先执行写操作，防止写入ddr3中的数据丢失else if(init_calib_complete) beginif(~wr_burst_busy && ~rd_burst_busy)begin //写FIFO中的数据量达到写突发长度if(wr_fifo_num >= wr_len && ~wr_burst_req)begin wr_burst_req <= 1'b1; //写请求有效rd_burst_req <= 1'b0;end//读FIFO中的数据量小于读突发长度,且读使能信号有效else if((rd_fifo_num < rd_len) && read_valid && ~rd_burst_req)begin wr_burst_req <= 1'b0;rd_burst_req <= 1'b1; //读请求有效endelse beginwr_burst_req <= 1'b0;rd_burst_req <= 1'b0;endendelse begin //非空闲状态wr_burst_req <= 1'b0;rd_burst_req <= 1'b0; endendelse begin //MIG初始化未完成wr_burst_req <= 1'b0;rd_burst_req <= 1'b0;end
end//wr_burst_addr:ddr3写地址
always@(posedge ui_clk)beginif(ui_clk_sync_rst)wr_burst_addr <= wr_b_addr;else if(wr_fifo_rst)wr_burst_addr <= wr_b_addr; //复位fifo则地址为初始地址else if(wr_burst_done) //一次突发写结束,更改写地址beginif(wr_burst_addr < (wr_e_addr - wr_len * 8)) wr_burst_addr <= wr_burst_addr + wr_len * 8; //未达到末地址,写地址累加else wr_burst_addr <= wr_b_addr; //到达末地址,回到写起始地址end
end //rd_burst_addr:ddr3读地址
always@(posedge ui_clk)beginif(ui_clk_sync_rst)rd_burst_addr <= rd_b_addr;else if(rd_fifo_rst)rd_burst_addr <= rd_b_addr;else if(rd_burst_done) //一次突发读结束,更改读地址beginif(rd_burst_addr < (rd_e_addr - rd_len * 8)) rd_burst_addr <= rd_burst_addr + rd_len * 8; //读地址未达到末地址,读地址累加else rd_burst_addr <= rd_b_addr; //到达末地址,回到首地址end
end//例化写FIFO-----------------------------------------
wr_fifo_16_128 wr_fifo_16_128_inst (//写数据接口 ----------------------------------------------.wr_clk (wr_fifo_wr_clk ), .wr_rst (wr_fifo_rst ), .wr_en (wr_fifo_wr_req ), .din (wr_fifo_wr_data ), //读数据接口 ---------------------------------------------- .rd_clk (ui_clk ), .rd_rst (ui_clk_sync_rst ), .rd_en (wr_burst_ack ), .dout (wr_burst_data ), //指示接口 ---------------------------------------------- .full ( ), .empty ( ), .rd_data_count (wr_fifo_num ) // output wire [8 : 0] rd_data_count
);//例化读FIFO-----------------------------------------
rd_fifo_128_16 rd_fifo_128_16_inst (//写数据接口 ----------------------------------------------.wr_clk (ui_clk ), .wr_rst (ui_clk_sync_rst ), .din (rd_burst_data ), .wr_en (rd_burst_ack ), //读数据接口 ---------------------------------------------- .rd_clk (rd_fifo_rd_clk ), .rd_rst (rd_fifo_rst ), .rd_en (rd_fifo_rd_req ), .dout (rd_fifo_rd_data ), //指示接口 ---------------------------------------------- .full ( ), .empty ( ), .wr_data_count (rd_fifo_num ) // output wire [8 : 0] wr_data_count
);endmodule
该模块中例化了两个fifo。写fifo，写位宽16位（根据我们设置的ddr数据位宽），读位宽128位（根据带宽一致，理解不了直接看例化的位宽是多少），将rd_data_count引出，该信号代表写fifo中具有的128位宽数据的个数，根据这个个数，产生写突发请求。读fifo，读写位宽与写fifo相反，将wr_data_count引出，代表写进读fifo中的128位宽数据的个数。在产生读突发请求的过程中，首先需要读ddr3使能read_valid有效，其次，若读fifo中写进去的数据个数不足读突发长度，就产生一次读突发。
对于突发地址，在fifo_ctrl模块，每当接收当读或写模块的burst_done信号，就代表一次突发完成，此时，fifo_ctrl模块需要更新突发地址，即burst_addr+8，当然前提是地址不会超过读写结束地址。这里的一次突发很容易混淆。在读写控制模块中，一次固定突发8个地址。在fifo_ctrl模块中，我们设置的突发长度为len，就代表fifo_ctrl模块中的一次突发，在读写模块中需要完成len次读写突发。
4.native_ddr3_ctrl模块
module native_ddr3_ctrl
#(parameter integer FIFO_DATA_WIDTH = 16 , //写fifo写位宽parameter integer FIFO_ADDR_WIDTH = 28 , parameter integer MIG_DATA_WIDTH = 128 , //数据位宽，根据MIG例化而来parameter integer MIG_ADDR_WIDTH = 28 //地址位宽
)(
//时钟和复位 ------------------------------------------------------input ui_clk , //用户时钟input ui_clk_sync_rst , //复位,高有效input init_calib_complete , //MIG初始化完成标志
//用户操作信号 -------------------------------------------------//写fifo信号---------------------------------------------------input wr_fifo_wr_clk , //写FIFO写时钟input wr_fifo_wr_req , //写FIFO写请求input [FIFO_DATA_WIDTH - 1:0] wr_fifo_wr_data , //写FIFO写数据 input wr_fifo_rst , //写FIFO复位信号 input [FIFO_ADDR_WIDTH - 1:0] wr_b_addr , //写DDR3首地址input [FIFO_ADDR_WIDTH - 1:0] wr_e_addr , //写DDR3末地址input [FIFO_ADDR_WIDTH - 1:0] wr_len , //写DDR3突发长度output [8:0] wr_fifo_num , //写fifo中的数据量//读fifo信号---------------------------------------------- input rd_fifo_rd_clk , //读FIFO读时钟input rd_fifo_rd_req , //读FIFO读请求output [FIFO_DATA_WIDTH - 1:0] rd_fifo_rd_data , //读FIFO读数据 input [FIFO_ADDR_WIDTH - 1:0] rd_b_addr , //读DDR3首地址input [FIFO_ADDR_WIDTH - 1:0] rd_e_addr , //读DDR3末地址input [FIFO_ADDR_WIDTH - 1:0] rd_len , //读DDR3数据突发长度input rd_fifo_rst , //读FIFO复位信号output [8:0] rd_fifo_num , //读fifo中的数据量//其他---------------------------------------------- input read_valid , //DDR3读使能
//MIG接口 --------------------------------------------------------------------------------------//命令接口 ----------------------------------------------input app_rdy , //MIG 命令接收准备好标 output app_en , //MIG IP发送命令使能 output [2:0] app_cmd , //MIG IP核操作命令，读或者写output [MIG_ADDR_WIDTH - 1:0] app_addr , //DDR3地址 //读接口 ---------------------------------------------- input [MIG_DATA_WIDTH - 1:0] app_rd_data , //从MIG中读出的数据input app_rd_data_end , //从MIG中读出的最后一个数据input app_rd_data_valid , //从MIG中读出的数据有效//写接口 ---------------------------------------------- input app_wdf_rdy , //MIG数据接收准备好output app_wdf_wren , //用户写数据使能output app_wdf_end , //突发写当前时钟最后一个数据output [(MIG_DATA_WIDTH/8) - 1:0] app_wdf_mask ,output [MIG_DATA_WIDTH - 1:0] app_wdf_data //用户写数据
);wire wr_burst_req ; //请求对DDR3写入数据
wire [FIFO_ADDR_WIDTH - 1:0] wr_burst_addr ; //当前写入DDR3的地址
wire wr_burst_busy ; //高电平表示正在进行突发写操作
wire wr_burst_done ; //高电平表示完成了一次突发写操作
wire [MIG_DATA_WIDTH - 1:0] wr_burst_data ; //突发写模块要写入的数据
wire wr_burst_ack ; //突发写模块要写入的数据有效
wire [FIFO_ADDR_WIDTH - 1:0] wr_burst_len ; //突发写长度
wire rd_burst_req ; //请求从DDR3读出数据
wire [FIFO_ADDR_WIDTH - 1:0] rd_burst_addr ; //当前读出DDR3的地址
wire rd_burst_busy ; //高电平表示正在进行突发读操作
wire rd_burst_done ; //高电平表示完成了一次突发读操作
wire [MIG_DATA_WIDTH - 1:0] rd_burst_data ; //突发读模块读出的数据
wire rd_burst_ack ; //突发读模块读出的数据有效
wire [FIFO_ADDR_WIDTH - 1:0] rd_burst_len ; //突发读长度//MIG接口 -----------------------------------------------------
wire app_en_wr ;
wire [2:0] app_cmd_wr ;
wire [MIG_ADDR_WIDTH - 1:0] app_addr_wr ;
wire app_en_rd ;
wire [2:0] app_cmd_rd ;
wire [MIG_ADDR_WIDTH - 1:0] app_addr_rd ;//*********************************************************************************************
//** main code
//**********************************************************************************************//突发读写模块共用MIG的控制信号，所以需要分时复用
assign app_en = wr_burst_busy ? app_en_wr : app_en_rd ;
assign app_cmd = wr_burst_busy ? app_cmd_wr : app_cmd_rd ;
assign app_addr = wr_burst_busy ? app_addr_wr : app_addr_rd ; fifo_ctrl
#(.FIFO_DATA_WIDTH (FIFO_DATA_WIDTH ), .FIFO_ADDR_WIDTH (FIFO_ADDR_WIDTH ), .MIG_DATA_WIDTH (MIG_DATA_WIDTH ), //数据位宽，根据MIG例化而来.MIG_ADDR_WIDTH (MIG_ADDR_WIDTH ) //
)
fifo_ctrl_inst(
//时钟和复位 -----------------------------------------------------.ui_clk (ui_clk ), //用户时钟.ui_clk_sync_rst (ui_clk_sync_rst ), //复位,高有效.init_calib_complete (init_calib_complete), //MIG初始化完成标志
//用户操作信号 ---------------------------------------------------- //写fifo信号-------------------------------------------------.wr_fifo_wr_clk (wr_fifo_wr_clk ), //写FIFO写时钟.wr_fifo_wr_req (wr_fifo_wr_req ), //写FIFO写请求.wr_fifo_wr_data (wr_fifo_wr_data ), //写FIFO写数据 .wr_fifo_rst (wr_fifo_rst ), //写FIFO复位信号 .wr_b_addr (wr_b_addr ), //写DDR3首地址.wr_e_addr (wr_e_addr ), //写DDR3末地址.wr_len (wr_len ), //写DDR3突发长度.wr_fifo_num (wr_fifo_num ), //写fifo中的数据量//读fifo信号------------------------------------------------- .rd_fifo_rd_clk (rd_fifo_rd_clk ), //读FIFO读时钟.rd_fifo_rd_req (rd_fifo_rd_req ), //读FIFO读请求.rd_fifo_rd_data (rd_fifo_rd_data ), //读FIFO读数据 .rd_b_addr (rd_b_addr ), //读DDR3首地址.rd_e_addr (rd_e_addr ), //读DDR3末地址.rd_len (rd_len ), //读DDR3数据突发长度.rd_fifo_rst (rd_fifo_rst ), //读FIFO复位信号.rd_fifo_num (rd_fifo_num ), //读fifo中的数据量//控制信号---------------------------------------------------- .read_valid (read_valid ), //DDR3读使能
//突发读、写模块信号 --------------------------------------------//突发写模块 ------------------------------------------------.wr_burst_busy (wr_burst_busy ), //高电平表示正在进行突发写操作.wr_burst_done (wr_burst_done ), //高电平表示完成了一次突发写操作.wr_burst_ack (wr_burst_ack ), //突发写模块要写入的数据有效.wr_burst_data (wr_burst_data ), //突发写模块要写入的数据 .wr_burst_req (wr_burst_req ), //请求进行突发写.wr_burst_addr (wr_burst_addr ), //突发写入的首地址.wr_burst_len (wr_burst_len ), //突发写长度//突发读模块 ------------------------------------------------.rd_burst_busy (rd_burst_busy ), //高电平表示正在进行突发读操作.rd_burst_done (rd_burst_done ), //高电平表示完成了一次突发读操作.rd_burst_ack (rd_burst_ack ), //突发读模块读出的数据有效.rd_burst_data (rd_burst_data ), //突发读模块读出的数据.rd_burst_req (rd_burst_req ), //请求进行突发读.rd_burst_addr (rd_burst_addr ), //突发读的首地址.rd_burst_len (rd_burst_len ) //突发读长度
);ddr3_wr
#( .DATA_WIDTH (MIG_DATA_WIDTH ), //数据位宽，根据MIG例化而来.ADDR_WIDTH (MIG_ADDR_WIDTH ) //
)
ddr3_wr_inst( .ui_clk (ui_clk ), //用户时钟.ui_clk_sync_rst (ui_clk_sync_rst ), //复位,高有效
//突发写相关信号 .wr_burst_start (wr_burst_req ), .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 用户端控制接口 .app_en (app_en_wr ), .app_cmd (app_cmd_wr ), .app_addr (app_addr_wr ), .app_rdy (app_rdy ), //MIG 命令接收准备好标致.app_wdf_rdy (app_wdf_rdy ), //MIG数据接收准备好.app_wdf_wren (app_wdf_wren ), //用户写数据使能.app_wdf_end (app_wdf_end ), //突发写当前时钟最后一个数据.app_wdf_mask (app_wdf_mask ),.app_wdf_data (app_wdf_data ) //用户写数据
); ddr3_rd #( .DATA_WIDTH (MIG_DATA_WIDTH ), //数据位宽，根据MIG例化而来.ADDR_WIDTH (MIG_ADDR_WIDTH ) //
)
ddr3_rd_inst( .ui_clk (ui_clk ), //用户时钟.ui_clk_sync_rst (ui_clk_sync_rst ), //复位,高有效
//突发读相关信号 .rd_burst_start (rd_burst_req ), .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 ), //突发写忙状态
//MIG 用户端控制接口 .app_en (app_en_rd ), .app_cmd (app_cmd_rd ), .app_addr (app_addr_rd ), .app_rdy (app_rdy ), //MIG 命令接收准备好标致 .app_rd_data (app_rd_data ), //从MIG中读出的数据.app_rd_data_end (app_rd_data_end ), //从MIG中读出的最后一个数据.app_rd_data_valid (app_rd_data_valid ) //从MIG中读出的数据有效
);endmodule
5.native_ddr3_top模块
module native_ddr3_top
#(parameter integer FIFO_DATA_WIDTH = 16 , parameter integer FIFO_ADDR_WIDTH = 28 , parameter integer MIG_DATA_WIDTH = 128 , //数据位宽，突发长度为8，16bit，共128bitparameter integer MIG_ADDR_WIDTH = 28 //根据MIG例化而来
)(
//时钟和复位 ------------------------------------------------------input clk_200 , //input sys_rst_n , //复位,低有效
//用户操作信号 -------------------------------------------------//写fifo信号---------------------------------------------------input wr_fifo_wr_clk , //写FIFO写时钟input wr_fifo_wr_req , //写FIFO写请求input [FIFO_DATA_WIDTH - 1:0] wr_fifo_wr_data , //写FIFO写数据 input wr_fifo_rst , //写FIFO复位信号 input [FIFO_ADDR_WIDTH - 1:0] wr_b_addr , //写DDR3首地址input [FIFO_ADDR_WIDTH - 1:0] wr_e_addr , //写DDR3末地址input [FIFO_ADDR_WIDTH - 1:0] wr_len , //写DDR3突发长度output [8:0] wr_fifo_num , //写fifo中的数据量//读fifo信号---------------------------------------------- input rd_fifo_rd_clk , //读FIFO读时钟input rd_fifo_rd_req , //读FIFO读请求output [FIFO_DATA_WIDTH - 1:0] rd_fifo_rd_data , //读FIFO读数据 input [FIFO_ADDR_WIDTH - 1:0] rd_b_addr , //读DDR3首地址input [FIFO_ADDR_WIDTH - 1:0] rd_e_addr , //读DDR3末地址input [FIFO_ADDR_WIDTH - 1:0] rd_len , //读DDR3数据突发长度input rd_fifo_rst , //读FIFO复位信号output [8:0] rd_fifo_num , //读fifo中的数据量//其他---------------------------------------------------------- input read_valid , //DDR3读使能
//DDR3相关 -----------------------------------------------------inout [15:0] ddr3_dq , //DDR3 数据inout [1:0] ddr3_dqs_n , //DDR3 dqs负inout [1:0] ddr3_dqs_p , //DDR3 dqs正 output [13:0] ddr3_addr , //DDR3 地址output [2:0] ddr3_ba , //DDR3 banck 选择output ddr3_ras_n , //DDR3 行选择output ddr3_cas_n , //DDR3 列选择output ddr3_we_n , //DDR3 读写选择output ddr3_reset_n , //DDR3 复位output [0:0] ddr3_ck_p , //DDR3 时钟正output [0:0] ddr3_ck_n , //DDR3 时钟负output [0:0] ddr3_cke , //DDR3 时钟使能output [0:0] ddr3_cs_n , //DDR3 片选output [1:0] ddr3_dm , //DDR3_dmoutput [0:0] ddr3_odt //DDR3_odt
);
//mig_ctrl相关 -----------------------------------------------------
wire ui_clk ; //用户时钟
wire ui_clk_sync_rst ; //用户复位信号
wire init_calib_complete ; //校准完成信号
wire app_rdy ; //MIG 命令接收准备好标
wire app_en ; //MIG IP发送命令使能
wire [2:0] app_cmd ; //MIG IP核操作命令，读或者写
wire [MIG_ADDR_WIDTH - 1:0] app_addr ; //DDR3地址
wire [MIG_DATA_WIDTH - 1:0] app_rd_data ; //从MIG中读出的数据
wire app_rd_data_end ; //从MIG中读出的最后一个数据
wire app_rd_data_valid ; //从MIG中读出的数据有效
wire app_wdf_rdy ; //MIG数据接收准备好
wire app_wdf_wren ; //用户写数据使能
wire app_wdf_end ; //突发写当前时钟最后一个数据
wire [(MIG_DATA_WIDTH/8) - 1:0] app_wdf_mask ;
wire [MIG_DATA_WIDTH - 1:0] app_wdf_data ; //用户写数据//*********************************************************************************************
//** main code
//**********************************************************************************************//============================< 例化native_ddr3_ctrl模块 >===============================================
native_ddr3_ctrl
#(.FIFO_DATA_WIDTH (FIFO_DATA_WIDTH ), .FIFO_ADDR_WIDTH (FIFO_ADDR_WIDTH ), .MIG_DATA_WIDTH (MIG_DATA_WIDTH ), //数据位宽，根据MIG例化而来.MIG_ADDR_WIDTH (MIG_ADDR_WIDTH ) //
)
native_ddr3_ctrl_inst( .ui_clk (ui_clk ), //用户时钟.ui_clk_sync_rst (ui_clk_sync_rst ), //复位,高有效.init_calib_complete (init_calib_complete), //MIG初始化完成标志.wr_fifo_wr_clk (wr_fifo_wr_clk ), //写FIFO写时钟.wr_fifo_wr_req (wr_fifo_wr_req ), //写FIFO写请求.wr_fifo_wr_data (wr_fifo_wr_data ), //写FIFO写数据.wr_fifo_rst (~sys_rst_n ), //写FIFO复位信号 .wr_b_addr (wr_b_addr ), //写DDR3首地址.wr_e_addr (wr_e_addr ), //写DDR3末地址.wr_len (wr_len ), //写DDR3突发长度.wr_fifo_num (wr_fifo_num ), //写fifo中的数据量.rd_fifo_rd_clk (rd_fifo_rd_clk ), //读FIFO读时钟.rd_fifo_rd_req (rd_fifo_rd_req ), //读FIFO读请求.rd_fifo_rd_data (rd_fifo_rd_data ), //读FIFO读数据.rd_b_addr (rd_b_addr ), //读DDR3首地址.rd_e_addr (rd_e_addr ), //读DDR3末地址.rd_len (rd_len ), //读DDR3数据突发长度.rd_fifo_rst (~sys_rst_n ), //读FIFO复位信号.rd_fifo_num (rd_fifo_num ), //读fifo中的数据量.read_valid (read_valid ), //DDR3读使能.app_en (app_en ), //MIG IP发送命令使能 .app_cmd (app_cmd ), //MIG IP核操作命令，读或者写.app_addr (app_addr ), //DDR3地址.app_rdy (app_rdy ), //MIG 命令接收准备好标 .app_rd_data (app_rd_data ), //从MIG中读出的数据.app_rd_data_end (app_rd_data_end ), //从MIG中读出的最后一个数据.app_rd_data_valid (app_rd_data_valid ), //从MIG中读出的数据有效.app_wdf_rdy (app_wdf_rdy ), //MIG数据接收准备好.app_wdf_wren (app_wdf_wren ), //用户写数据使能.app_wdf_end (app_wdf_end ), //突发写当前时钟最后一个数据.app_wdf_mask (app_wdf_mask ),.app_wdf_data (app_wdf_data ) //用户写数据
);
//============================< 例化MIG IP核模块 >===============================================
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 (clk_200 ),.clk_ref_i (clk_200 ),.sys_rst (sys_rst_n )
);endmodule
本文主要参考文章：> https://blog.csdn.net/wuzhikaidetb/article/details/121841813
本人水平不高，如有问题，欢迎各位批评指正。
