ping.v

来自「xilinx官方PCIcore 有详细说明文档」· Verilog 代码 · 共 563 行 · 第 1/2 页

/***********************************************************************

  File:   ping.v
  Rev:    3.0.0

  This is an example user application for use with the Xilinx PCI
  initiator.  The design has been tested with the Synopsys design
  flow.

  Copyright (c) 2003 Xilinx, Inc.  All rights reserved.

***********************************************************************/


module ping64 (
                FRAMEQ_N,
                REQ64Q_N,
                TRDYQ_N,
                IRDYQ_N,
                STOPQ_N,
                DEVSELQ_N,
                ACK64Q_N,
                ADDR,
                ADIO,
                CFG_VLD,
                CFG_HIT,
                C_TERM,
                C_READY,
                ADDR_VLD,
                BASE_HIT,
                S_CYCLE64,
                S_TERM,
                S_READY,
                S_ABORT,
                S_WRDN,
                S_SRC_EN,
                S_DATA_VLD,
                S_CBE,
                PCI_CMD,
                REQUEST,
                REQUEST64,
                REQUESTHOLD,
                COMPLETE,
                M_WRDN,
                M_READY,
                M_SRC_EN,
                M_DATA_VLD,
                M_CBE,
                TIME_OUT,
                M_FAIL64,
                CFG_SELF,
                M_DATA,
                DR_BUS,
                I_IDLE,
                M_ADDR_N,
                IDLE,
                B_BUSY,
                S_DATA,
                BACKOFF,
                SLOT64,
                INTR_N,
                PERRQ_N,
                SERRQ_N,
                KEEPOUT,
                CSR,
                SUB_DATA,
                CFG,
                RST,
                CLK,
                PING_DONE,
                PING_REQUEST32,
                PING_REQUEST64
                );
                // synthesis syn_edif_bit_format = "%u<%i>"
                // synthesis syn_edif_scalar_format = "%u"
                // synthesis syn_noclockbuf = 1
                // synthesis syn_hier = "hard"


  // Declare the port directions.

  input         FRAMEQ_N;
  input         REQ64Q_N;
  input         TRDYQ_N;
  input         IRDYQ_N;
  input         STOPQ_N;
  input         DEVSELQ_N;
  input         ACK64Q_N;
  input  [31:0] ADDR;
  inout  [63:0] ADIO;
  input         CFG_VLD;
  input         CFG_HIT;
  output        C_TERM;
  output        C_READY;
  input         ADDR_VLD;
  input   [7:0] BASE_HIT;
  input         S_CYCLE64;
  output        S_TERM;
  output        S_READY;
  output        S_ABORT;
  input         S_WRDN;
  input         S_SRC_EN;
  input         S_DATA_VLD;
  input   [7:0] S_CBE;
  input  [15:0] PCI_CMD;
  output        REQUEST;
  output        REQUEST64;
  output        REQUESTHOLD;
  output        COMPLETE;
  output        M_WRDN;
  output        M_READY;
  input         M_SRC_EN;
  input         M_DATA_VLD;
  output  [7:0] M_CBE;
  input         TIME_OUT;
  input         M_FAIL64;
  output        CFG_SELF;
  input         M_DATA;
  input         DR_BUS;
  input         I_IDLE;
  input         M_ADDR_N;
  input         IDLE;
  input         B_BUSY;
  input         S_DATA;
  input         BACKOFF;
  output        SLOT64;
  output        INTR_N;
  input         PERRQ_N;
  input         SERRQ_N;
  output        KEEPOUT;
  input  [39:0] CSR;
  output [31:0] SUB_DATA;
  input [255:0] CFG;
  input         RST;
  input         CLK;
  output        PING_DONE;
  input         PING_REQUEST32;
  input         PING_REQUEST64;

  parameter TDLY = 1;


  //******************************************************************//
  // This section contains the PCI interface decode.                  //
  //******************************************************************//

  reg           cfg_rd, bar0_rd, bar1_rd, bar2_rd;
  reg           cfg_wr, bar0_wr, bar1_wr, bar2_wr;
  wire          cfg_rd_cs, bar0_rd_cs, bar1_rd_cs, bar2_rd_cs;
  wire          cfg_wr_cs, bar0_wr_cs, bar1_wr_cs, bar2_wr_cs;

  always @(posedge CLK or posedge RST)
  begin : identify
    if (RST)
    begin
      cfg_rd  <= 1'b0;
      cfg_wr  <= 1'b0;
      bar0_rd <= 1'b0;
      bar0_wr <= 1'b0;
      bar1_rd <= 1'b0;
      bar1_wr <= 1'b0;
      bar2_rd <= 1'b0;
      bar2_wr <= 1'b0;
    end
    else
    begin
      if (CFG_HIT)
      begin
        cfg_rd <= !S_WRDN;
        cfg_wr <= S_WRDN;
      end
      else if (!S_DATA)
      begin
        cfg_rd <= 1'b0;
        cfg_wr <= 1'b0;
      end
      if (BASE_HIT[0])
      begin
        bar0_rd <= !S_WRDN;
        bar0_wr <= S_WRDN;
      end
      else if (!S_DATA)
      begin
        bar0_rd <= 1'b0;
        bar0_wr <= 1'b0;
      end
      if (BASE_HIT[1])
      begin
        bar1_rd <= !S_WRDN;
        bar1_wr <= S_WRDN;
      end
      else if (!S_DATA)
      begin
        bar1_rd <= 1'b0;
        bar1_wr <= 1'b0;
      end
      if (BASE_HIT[2])
      begin
        bar2_rd <= !S_WRDN;
        bar2_wr <= S_WRDN;
      end
      else if (!S_DATA)
      begin
        bar2_rd <= 1'b0;
        bar2_wr <= 1'b0;
      end
    end
  end

  assign #TDLY cfg_rd_cs  = cfg_rd;
  assign #TDLY cfg_wr_cs  = cfg_wr;
  assign #TDLY bar0_rd_cs = bar0_rd;
  assign #TDLY bar0_wr_cs = bar0_wr;
  assign #TDLY bar1_rd_cs = bar1_rd;
  assign #TDLY bar1_wr_cs = bar1_wr;
  assign #TDLY bar2_rd_cs = bar2_rd;
  assign #TDLY bar2_wr_cs = bar2_wr;


  //******************************************************************//
  // This section contains the CFG32 implementation.                  //
  //******************************************************************//

  reg    [31:0] my_cfg_reg;
  wire          oe_cfg_reg;
  wire          en_cfg_reg;

  always @(posedge CLK or posedge RST)
  begin : write_my_cfg_reg
    if (RST) my_cfg_reg <= 32'h00000000;
    else if (S_DATA_VLD & cfg_wr_cs & en_cfg_reg)
    begin
      if (!S_CBE[0]) my_cfg_reg[ 7: 0] <= ADIO[ 7: 0];
      if (!S_CBE[1]) my_cfg_reg[15: 8] <= ADIO[15: 8];
      if (!S_CBE[2]) my_cfg_reg[23:16] <= ADIO[23:16];
      if (!S_CBE[3]) my_cfg_reg[31:24] <= ADIO[31:24];
    end
  end  

  assign #TDLY en_cfg_reg = ADDR[7] | ADDR[6];
  assign #TDLY oe_cfg_reg = en_cfg_reg & cfg_rd_cs & S_DATA & CFG[118];
  assign #TDLY ADIO[31:0] = oe_cfg_reg ? my_cfg_reg : 32'bz;
  

  //******************************************************************//
  // This section contains the IO32 implementation.                   //
  //******************************************************************//

  reg    [31:0] my_io_reg;
  wire          oe_io_reg;

  always @(posedge CLK or posedge RST)
  begin : write_my_io_reg
    if (RST) my_io_reg <= 32'h10101010;
    else if (S_DATA_VLD & bar0_wr_cs)
    begin
      if (!S_CBE[0]) my_io_reg[ 7: 0] <= ADIO[ 7: 0];
      if (!S_CBE[1]) my_io_reg[15: 8] <= ADIO[15: 8];
      if (!S_CBE[2]) my_io_reg[23:16] <= ADIO[23:16];
      if (!S_CBE[3]) my_io_reg[31:24] <= ADIO[31:24];
    end
  end    

  assign #TDLY oe_io_reg = bar0_rd_cs & S_DATA;
  assign #TDLY ADIO[31:0] = oe_io_reg ? my_io_reg : 32'bz;


  //******************************************************************//
  // This section contains the MEM32 implementation.                  //
  //******************************************************************//
 
  reg    [31:0] my_mem_reg;
  wire          oe_mem_reg;
 
  always @(posedge CLK or posedge RST)
  begin : write_my_mem_reg
    if (RST) my_mem_reg <= 32'h32323232;
    else if (S_DATA_VLD & bar1_wr_cs)
    begin
      if (!S_CBE[0]) my_mem_reg[ 7: 0] <= ADIO[ 7: 0];
      if (!S_CBE[1]) my_mem_reg[15: 8] <= ADIO[15: 8];
      if (!S_CBE[2]) my_mem_reg[23:16] <= ADIO[23:16];