DDR3 APP接口代码

用了两个FIFO,和我AXI的写法差不多其实。

其他放在Github了。

TOP

module dma_app_topv2 (
    input   wire    I_Rst_n,//SYS RST
    input   wire    I_Clk  ,//SYS CLK

    output wire   [13:0]	ddr3_addr           ,
    output wire   [2:0]	    ddr3_ba             ,
    output wire   		    ddr3_cas_n          ,
    output wire   [0:0]	    ddr3_ck_n           ,
    output wire   [0:0]	    ddr3_ck_p           ,
    output wire   [0:0]	    ddr3_cke            ,
    output wire 			ddr3_ras_n          ,
    output wire 			ddr3_reset_n        ,
    output wire 			ddr3_we_n           ,
    inout         [31:0]	ddr3_dq             ,
    inout         [3:0]		ddr3_dqs_n          ,
    inout         [3:0]		ddr3_dqs_p          ,
    output wire   [0:0]	    ddr3_cs_n           ,
    output wire   [3:0]	    ddr3_dm             ,
    output wire   [0:0]	    ddr3_odt            ,
    input  wire             uart_rx             ,
    //hdmi
    output  wire            HDMI_CLK_P          ,
    output  wire            HDMI_CLK_N          ,
    output  wire    [2:0]   HDMI_TX_P           ,
    output  wire    [2:0]   HDMI_TX_N           
);
//------------------------------------------------------------------------------//
    //PLL
    wire                    O_CLK_200MHZ        ;
    wire                    O_CLK_50MHZ         ;
    wire                    O_CLK_100MHZ        ;
    wire                    PLL0_LOCK           ;
    wire                    PLL1_LOCK           ;
    wire                    CLK_PIXEL_BASE      ;
    wire                    CLK_PIXEL_5X        ;
    //DDR3
    wire                    ui_clk              ;
    wire          [31:0]    app_wdf_mask        ;
    //app
    wire          [27:0]	app_addr            ;        
    wire          [2:0]		app_cmd             ;    
    wire         			app_en              ;                
    wire          [255:0]	app_wdf_data        ;                
    wire         			app_wdf_end         ;                
    wire         			app_wdf_wren        ;                
    wire          [255:0]	app_rd_data         ;        
    wire    			    app_rd_data_end     ;                
    wire    			    app_rd_data_valid   ;                
    wire    			    app_rdy             ;    
    wire    			    app_wdf_rdy         ;        
    wire    			    app_sr_req          ;        
    wire    			    app_ref_req         ;        
    wire    			    app_zq_req          ;        
    wire    			    app_sr_active       ;                
    wire    			    app_ref_ack         ;                
    wire    			    app_zq_ack          ; 
    //wr ctrl
    wire                    ex_wr_start         ;
    wire          [27:0]    ex_wr_addr          ;
    wire          [2:0]     ex_wr_cmd           ;
    wire          [7:0]     ex_wr_burst_len     ;
    wire          [255:0]   ex_wr_data          ;
    wire          [31:0]    ex_wr_wdf_mask      ;

    wire          [27:0]	wr_app_addr         ;        
    wire          [2:0]		wr_app_cmd          ;    
    wire         			wr_app_en           ;  
    //wr aribe
    wire                    ex_wr_burst_start   ;
    wire                    ex_wr_burst_end     ;
    //wr fifo
    wire                    ex_wr_rd_en         ;
    //rd ctrl
    wire                    ex_rd_start         ;
    wire          [27:0]    ex_rd_addr          ;
    wire          [2:0]     ex_rd_cmd           ;
    wire          [7:0]     ex_rd_burst_len     ;
    wire          [255:0]   ex_rd_data          ;
    //rd fifo
    wire                    ex_rd_wr_en         ;
    //rd aribe
    wire                    ex_rd_burst_start   ;
    wire                    ex_rd_burst_end     ;

    wire          [27:0]	rd_app_addr         ;        
    wire          [2:0]		rd_app_cmd          ;    
    wire         			rd_app_en           ; 

    //uart
    wire          [7:0]     uart_rx_data        ;
    wire                    uart_rx_vaild       ;
    //hdmi
    wire                    O_Pre_De            ;
    wire                    O_Pre_Vsync         ;
    wire                    O_Pre_Hsync         ;
    wire                    I_Post_De           ;
    wire                    I_Post_Vsync        ;
    wire                    I_Post_Hsync        ;
    wire          [15:0]    hdmi_rd_data        ;

//------------------------------------------------------------------------------//
//tmp
    // wr data fifo
    wire                    wr_fifo_wclk        ;
    wire          [255:0]   wr_fifo_wdata       ;
    wire                    wr_fifo_wren        ;
    // rd data fifo
    wire                    rd_fifo_rclk        ;
    wire                    rd_fifo_rden        ;
    wire          [255:0]   rd_fifo_rdata       ;
//pre
    wire                    Pre_wren            ;
    wire          [255:0]   Pre_wdata           ;
    wire                    rd_start_rl         ;

//------------------------------------------------------------------------------//
    wire                    rd_fifo_req         ;
    wire                    wr_fifo_req         ;
    wire                    display_start       ;

    assign  app_sr_req   = 1'b0;
    assign  app_ref_req  = 1'b0;
    assign  app_zq_req   = 1'b0;
    assign  ex_wr_wdf_mask = 32'b0;

    assign  app_addr = rd_app_addr|wr_app_addr;
    assign  app_en   = rd_app_en|wr_app_en;
    assign  app_cmd  = (wr_app_en)?(wr_app_cmd):(rd_app_cmd);

    assign  rd_fifo_rclk = CLK_PIXEL_BASE;
    assign  wr_fifo_wclk = O_CLK_50MHZ   ;

//------------------------------------------------------------------------------//

  PLL_0_APP PLL_0_APP
   (
    // Clock out ports
    .O_CLK_200MHZ( O_CLK_200MHZ ),     // output O_CLK_200MHZ
    .O_CLK_50MHZ ( O_CLK_50MHZ  ),     // output O_CLK_50MHZ 
    .O_CLK_100MHZ( O_CLK_100MHZ ),
    // Status and control signals
    .resetn     ( I_Rst_n       ),     // input resetn
    .locked     ( PLL0_LOCK     ),     // output locked
   // Clock in ports
    .I_CLK_50MHZ( I_Clk         )      // input I_CLK_50MHZ
);
  PLL_1 PLL_1
   (
    // Clock out ports
    .CLK_PIXEL_BASE ( CLK_PIXEL_BASE  ), // output CLK_PIXEL_BASE
    .CLK_PIXEL_5X   ( CLK_PIXEL_5X    ), // output CLK_PIXEL_5X
    // Status and control signals
    .resetn         ( PLL0_LOCK       ), // input resetn
    .locked         ( PLL1_LOCK       ), // output locked
   // Clock in ports
    .clk_in1        ( O_CLK_100MHZ    )  // input clk_in1
);

rx_teach Uart_Rx(
    .Sys_clk                 ( O_CLK_50MHZ         ),
    .Rst_n                   ( PLL0_LOCK           ),
    .data_in                 ( uart_rx             ),
    .data_receive            ( uart_rx_data        ),
    .rx_done                 ( uart_rx_vaild       )
);

uart_buff #(
    .IW ( 8    ),
    .OW ( 256  ))
 u_uart_buff (
    .sys_clk                 ( O_CLK_50MHZ       ),
    .rst_n                   ( PLL0_LOCK         ),
    .uart_rx_vaild           ( uart_rx_vaild     ),
    .uart_rx_data            ( uart_rx_data      ),

    .uart_8to256_data        ( wr_fifo_wdata     ),
    .uart_8to256_vaild       ( wr_fifo_wren      )
);

// hdmi_top
hdmi_top #(
    .H_ActiveSize ( 1024                   ),
    .H_SyncStart  ( 1024 + 24              ),
    .H_SyncEnd    ( 1024 + 24 + 136        ),
    .H_FrameSize  ( 1024 + 24 + 136 + 160  ),
    .V_ActiveSize ( 768                    ),
    .V_SyncStart  ( 768 + 3                ),
    .V_SyncEnd    ( 768 + 3 + 6            ),
    .V_FrameSize  ( 768 + 3 + 6 + 29       ))
 HDMI_TOP (
    .Pixl_CLK                ( CLK_PIXEL_BASE   ),
    .Pixl_5xCLK              ( CLK_PIXEL_5X     ),
    .Rst_n                   ( PLL1_LOCK && init_calib_complete && display_start),
    .I_Pixel_Data            ( hdmi_rd_data     ),
    .I_PLL_LOCK              ( PLL1_LOCK        ),

    .HDMI_CLK_P              ( HDMI_CLK_P       ),
    .HDMI_CLK_N              ( HDMI_CLK_N       ),
    .HDMI_TX_P               ( HDMI_TX_P        ),
    .HDMI_TX_N               ( HDMI_TX_N        ),
    .O_Pre_De                ( O_Pre_De         ),
    .O_Pre_Vsync             ( O_Pre_Vsync      ),
    .O_Pre_Hsync             ( O_Pre_Hsync      ),
    .I_Post_De               ( I_Post_De        ),
    .I_Post_Vsync            ( I_Post_Vsync     ),
    .I_Post_Hsync            ( I_Post_Hsync     )
);

hdmi_buff #(
    .Iw ( 256 ),
    .Ow ( 16  ))
 HDMI_Buff (
    .rst_n                   ( PLL1_LOCK && init_calib_complete && display_start),
    .hdmi_clk                ( CLK_PIXEL_BASE           ),
    .hdmi_Pre_de             ( O_Pre_De                 ),
    .hdmi_Pre_hsync          ( O_Pre_Hsync              ),
    .hdmi_Pre_vsync          ( O_Pre_Vsync              ),
    .fifo_rd_data            ( rd_fifo_rdata            ),// rd fifo rd data

    .hdmi_Post_en            ( I_Post_De                ),
    .hdmi_Post_hsync         ( I_Post_Hsync             ),
    .hdmi_Post_vsync         ( I_Post_Vsync             ),
    .hdmi_rd_data            ( hdmi_rd_data             ),
    .fifo_rd_en              ( rd_fifo_rden             )// rd fifo rd en
);

app_arbit  app_arbit_inst0 (
    .I_clk                   ( ui_clk              ),
    .I_Rst_n                 ( init_calib_complete ),
    //rd
    .I_ch0_req               ( rd_fifo_req         ),
    .I_ch0_start             ( ex_rd_burst_start   ),
    .I_ch0_end               ( ex_rd_burst_end     ),
    //wr
    .I_ch1_req               ( wr_fifo_req         ),
    .I_ch1_start             ( ex_wr_burst_start   ),
    .I_ch1_end               ( ex_wr_burst_end     ),
    //vaild
    .O_ch0_vaild             ( ex_rd_start         ),
    .O_ch1_vaild             ( ex_wr_start         )
);

 app_dma_wr  app_dma_wr_inst0 (
     .I_sys_clk               ( ui_clk              ),
     .I_Rst_n                 ( init_calib_complete ),
     .ex_wr_start             ( ex_wr_start         ),
     .ex_wr_addr              ( ex_wr_addr          ),
     .ex_wr_cmd               ( ex_wr_cmd           ),
     .ex_wr_burst_len         ( ex_wr_burst_len     ),
     .ex_wr_data              ( ex_wr_data          ),
     .ex_wr_wdf_mask          ( ex_wr_wdf_mask      ),
     .app_rdy                 ( app_rdy             ),
     .app_wdf_rdy             ( app_wdf_rdy         ),
  
     .ex_wr_burst_start       ( ex_wr_burst_start   ),
     .ex_wr_burst_end         ( ex_wr_burst_end     ),
     .ex_wr_rd_en             ( ex_wr_rd_en         ),
     .app_addr                ( wr_app_addr         ),
     .app_cmd                 ( wr_app_cmd          ),
     .app_en                  ( wr_app_en           ),
     .app_wdf_data            ( app_wdf_data        ),
     .app_wdf_end             ( app_wdf_end         ),
     .app_wdf_wren            ( app_wdf_wren        ),
     .app_wdf_mask            ( app_wdf_mask        )
 );

app_dma_rd  app_dma_rd_inst0 (
    .I_sys_clk               ( ui_clk              ),
    .I_Rst_n                 ( init_calib_complete ),
    .ex_rd_start             ( ex_rd_start         ),
    .ex_rd_addr              ( ex_rd_addr          ),
    .ex_rd_cmd               ( ex_rd_cmd           ),
    .ex_rd_burst_len         ( ex_rd_burst_len     ),
    .app_rd_data             ( app_rd_data         ),
    .app_rd_data_end         ( app_rd_data_end     ),
    .app_rd_data_valid       ( app_rd_data_valid   ),
    .app_rdy                 ( app_rdy             ),

    .ex_rd_data              ( ex_rd_data          ),
    .ex_rd_wr_en             ( ex_rd_wr_en         ),
    .ex_rd_burst_start       ( ex_rd_burst_start   ),
    .ex_rd_burst_end         ( ex_rd_burst_end     ),
    .app_addr                ( rd_app_addr         ),
    .app_cmd                 ( rd_app_cmd          ),
    .app_en                  ( rd_app_en           )
);


fifo_ctrl #(
    .wr_base_addr    ( 0               ),
    .rd_base_addr    ( 0               ),
    .wr_burst_length ( 'd64            ),
    .rd_burst_length ( 'd64            ),
    .IW              ( 'd1024          ),
    .IH              ( 'd768           ),
    .Pixel_wd        ( 'd2             ))
 u_fifo_ctrl (
    .rst_n                   ( init_calib_complete          ),
    .rd_start                ( display_start                ),
    //wr data wr
    .wr_fifo_rst_n           ( init_calib_complete          ),
    .wr_fifo_wclk            ( wr_fifo_wclk                 ),
    .wr_fifo_wdata           ( wr_fifo_wdata                ),
    .wr_fifo_wren            ( wr_fifo_wren                 ),
    //wr data rd                
    .wr_fifo_rclk            ( ui_clk                       ),
    .wr_fifo_rden            ( ex_wr_rd_en                  ),
    .wr_cmd_rden             ( ex_wr_burst_start            ),
    //rd data wr
    .rd_fifo_rst_n           ( init_calib_complete          ),
    .rd_fifo_wclk            ( ui_clk                       ),
    .rd_fifo_wdata           ( ex_rd_data                   ),
    .rd_fifo_wren            ( ex_rd_wr_en                  ),
    //rd data rd
    .rd_fifo_rclk            ( rd_fifo_rclk                 ),
    .rd_fifo_rden            ( rd_fifo_rden                 ),
    .rd_cmd_rden             ( ex_rd_burst_start            ),
    //output
    //wr data rd
    .wr_fifo_rdata           ( ex_wr_data                   ),
    .wr_data_req             ( wr_fifo_req                  ),//req 
    //wr cmd rd
    .wr_cmd_rdcmd            ( ex_wr_cmd                    ),
    .wr_cmd_rdbl             ( ex_wr_burst_len              ),
    .wr_cmd_rdaddr           ( ex_wr_addr                   ),
    //rd data rd
    .rd_fifo_rdata           ( rd_fifo_rdata                ),
    .rd_data_req             ( rd_fifo_req                  ),//req
    //rd cmd rd
    .rd_cmd_rdcmd            ( ex_rd_cmd                    ),
    .rd_cmd_rdbl             ( ex_rd_burst_len              ),
    .rd_cmd_rdaddr           ( ex_rd_addr                   )
);

  mig_7series_0 MIG_APP (
    // Memory interface ports
    .ddr3_addr                      ( ddr3_addr),            // output [13:0]	ddr3_addr
    .ddr3_ba                        ( ddr3_ba),              // output [2:0]	ddr3_ba
    .ddr3_cas_n                     ( ddr3_cas_n),           // output			ddr3_cas_n
    .ddr3_ck_n                      ( ddr3_ck_n),            // output [0:0]	ddr3_ck_n
    .ddr3_ck_p                      ( ddr3_ck_p),            // output [0:0]	ddr3_ck_p
    .ddr3_cke                       ( ddr3_cke),             // output [0:0]	ddr3_cke
    .ddr3_ras_n                     ( ddr3_ras_n),           // output			ddr3_ras_n
    .ddr3_reset_n                   ( ddr3_reset_n),         // output			ddr3_reset_n
    .ddr3_we_n                      ( ddr3_we_n),            // output			ddr3_we_n
    .ddr3_dq                        ( ddr3_dq),              // inout [31:0]	ddr3_dq
    .ddr3_dqs_n                     ( ddr3_dqs_n),           // inout [3:0]		ddr3_dqs_n
    .ddr3_dqs_p                     ( ddr3_dqs_p),           // inout [3:0]		ddr3_dqs_p
    .init_calib_complete            ( init_calib_complete),  // output			init_calib_complete
	.ddr3_cs_n                      ( ddr3_cs_n),            // output [0:0]	ddr3_cs_n
    .ddr3_dm                        ( ddr3_dm),              // output [3:0]	ddr3_dm
    .ddr3_odt                       ( ddr3_odt),             // output [0:0]	ddr3_odt
    // Application interface ports 
    .app_addr                       ( app_addr           ),  // input [27:0]	app_addr
    .app_cmd                        ( app_cmd            ),  // input [2:0]		app_cmd
    .app_en                         ( app_en             ),  // input			app_en            
    .app_wdf_data                   ( app_wdf_data       ),  // input [255:0]	app_wdf_data      
    .app_wdf_end                    ( app_wdf_end        ),  // input			app_wdf_end       
    .app_wdf_wren                   ( app_wdf_wren       ),  // input			app_wdf_wren      
    .app_rd_data                    ( app_rd_data        ),  // output [255:0]	app_rd_data
    .app_rd_data_end                ( app_rd_data_end    ),  // output			app_rd_data_end   
    .app_rd_data_valid              ( app_rd_data_valid  ),  // output			app_rd_data_valid
    .app_rdy                        ( app_rdy            ),  // output			app_rdy
    .app_wdf_rdy                    ( app_wdf_rdy        ),  // output			app_wdf_rdy
    
    .app_sr_req                     ( app_sr_req         ),  // input			app_sr_req
    .app_ref_req                    ( app_ref_req        ),  // input			app_ref_req
    .app_zq_req                     ( app_zq_req         ),  // input			app_zq_req
    .app_sr_active                  ( app_sr_active      ),  // output			app_sr_active     
    .app_ref_ack                    ( app_ref_ack        ),  // output			app_ref_ack       
    .app_zq_ack                     ( app_zq_ack         ),  // output			app_zq_ack        
    //Ui 
    .ui_clk                         ( ui_clk             ),  // output			ui_clk
    .ui_clk_sync_rst                (                    ),  // output			ui_clk_sync_rst
    .app_wdf_mask                   ( app_wdf_mask       ),  // input [31:0]	app_wdf_mask      
    // System Clock Ports
    .sys_clk_i                      ( O_CLK_200MHZ      ),
    .sys_rst                        ( PLL0_LOCK         ) // input sys_rst
    );
endmodule

  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: DDR App接口控制代码是用于控制DDR(双数据率)应用程序接口代码。DDR是一种内存技术,可以提高计算机的存储和数据传输速度。DDR App接口控制代码可以用于实现对DDR的读取、写入和操作等功能。以下是一个简单的示例代码: ``` #include <stdio.h> // 定义DDR地址 #define DDR_BASE_ADDRESS 0x80000000 // 定义DDR大小 #define DDR_SIZE 0x10000000 // 读取DDR数据 unsigned int read_ddr(unsigned int address) { unsigned int *ddr = (unsigned int*)DDR_BASE_ADDRESS; return ddr[(address - DDR_BASE_ADDRESS) / sizeof(unsigned int)]; } // 写入DDR数据 void write_ddr(unsigned int address, unsigned int data) { unsigned int *ddr = (unsigned int*)DDR_BASE_ADDRESS; ddr[(address - DDR_BASE_ADDRESS) / sizeof(unsigned int)] = data; } int main() { // 读取DDR数据 unsigned int data = read_ddr(0x80000004); // 打印读取到的数据 printf("DDR data: %d\n", data); // 写入DDR数据 write_ddr(0x80000008, 123); // 读取刚刚写入的数据 data = read_ddr(0x80000008); // 打印读取到的数据 printf("DDR data: %d\n", data); return 0; } ``` 上面的代码展示了如何使用DDR App接口控制代码进行读取和写入DDR数据。首先,我们定义了DDR的基地址和大小。然后,我们实现了read_ddr函数用于读取DDR数据,以及write_ddr函数用于写入DDR数据。在main函数中,我们使用read_ddr函数来读取DDR的数据,并使用write_ddr函数来写入数据。最后,我们打印读取到的数据。通过这些代码,我们可以控制DDR接口,并对DDR内存进行读写操作。 ### 回答2: DDR App接口控制代码是用于控制DDR(动态外部存储器)应用程序接口代码。DDR是一种用于储存和读取大量数据的存储器,通常用于计算机和其他电子设备中。 DDR App接口控制代码的主要作用是通过与DDR主控芯片的通信,实现对DDR存储器的读写操作。这包括初始化DDR存储器、配置存储器参数、发出读写指令以及处理读写数据等功能。 在编写DDR App接口控制代码时,首先需要了解DDR存储器的技术规格和通信协议。根据DDR存储器的类型和规格,我们可以确定代码中使用的命令和控制信号,以及他们的相应编码和通信方式。 代码中的主要功能包括设置存储器的读写模式和时序参数、进行读写地址和数据的传输、处理存储器返回的数据等。为了确保数据的正确性和有效性,我们还需要处理存储器传输过程中可能出现的错误和异常情况。 在实际的应用中,DDR App接口控制代码通常会与其他的应用程序和操作系统进行集成,以满足应用程序的需求。例如,将DDR存储器用于图像处理应用时,DDR App接口控制代码可以与图像处理算法和界面代码进行协同工作,实现高效的图像存储和处理。 总之,DDR App接口控制代码是一种用于控制DDR存储器的应用程序接口代码,通过与DDR主控芯片的通信,实现对DDR存储器的读写操作和数据传输。它在嵌入式系统和其他电子设备中具有重要的作用,可以应用于各种数据存储和处理的场景。 ### 回答3: DDr App接口控制代码是指通过编程语言编写的一组代码,用于实现与DDR App接口的交互和控制。DDR App接口是指一种可以与DDR(Double Data Rate)应用程序进行通信的接口。DDR是一种高速内存技术,用于在计算机系统中提高数据传输速度。 控制DDR App接口代码主要包括以下几个方面: 1. 初始化设置:通过调用适当的函数或方法,将DDR App接口初始化为适合当前系统的模式。这包括设置数据传输速率、字节顺序等参数。 2. 写入数据:利用提供的接口函数,在DDR App接口上写入需要处理的数据。这些数据可以是从外部设备输入的、计算得出的或从其他程序中读取的。编写代码时,需要注意数据的格式和长度,以确保正确传输和处理。 3. 读取数据:通过调用相关函数,从DDR App接口中读取已处理的数据。读取的数据可以用于输出到外部设备、保存到文件或进行其他操作。 4. 错误处理:编写代码时,需要考虑到可能发生的错误情况,并相应地处理。这可能包括连接失败、数据传输错误等。结合异常处理机制或错误代码检查,以确保代码的稳定性和可靠性。 在编写DDR App接口控制代码时,需要根据具体的编程语言和DDR App接口的文档进行操作。了解接口的功能、参数和返回值,熟悉相关函数的使用方法,能够合理地组织代码结构和处理逻辑,是编写高效、可靠的DDR App接口控制代码的关键。同时,根据实际需求对代码进行调试和优化,以确保代码的正确性和性能。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值