pci_tb.v

好东西啊,PCI的IP核.大家快下吧.@可以用来参考.FPGA设计的

//////////////////////////////////////////////////////////////////////
////                                                              ////
////  File name "pci_tb.v"                                        ////
////                                                              ////
////  This file is part of the "PCI bridge" project               ////
////  http://www.opencores.org/cores/pci/                         ////
////                                                              ////
////  Author(s):                                                  ////
////      - [e-mail]                                   ////
////      - Miha Dolenc                                           ////
////                                                              ////
////  All additional information is avaliable in the README.txt   ////
////  file.                                                       ////
////                                                              ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
////                                                              ////
//// Copyright (C) 2000 Miha Dolenc, [e-mail]          ////
////                                                              ////
//// This source file may be used and distributed without         ////
//// restriction provided that this copyright statement is not    ////
//// removed from the file and that any derivative work contains  ////
//// the original copyright notice and the associated disclaimer. ////
////                                                              ////
//// This source file is free software; you can redistribute it   ////
//// and/or modify it under the terms of the GNU Lesser General   ////
//// Public License as published by the Free Software Foundation; ////
//// either version 2.1 of the License, or (at your option) any   ////
//// later version.                                               ////
////                                                              ////
//// This source is distributed in the hope that it will be       ////
//// useful, but WITHOUT ANY WARRANTY; without even the implied   ////
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      ////
//// PURPOSE.  See the GNU Lesser General Public License for more ////
//// details.                                                     ////
////                                                              ////
//// You should have received a copy of the GNU Lesser General    ////
//// Public License along with this source; if not, download it   ////
//// from http://www.opencores.org/lgpl.shtml                     ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
//
// CVS Revision History
//
// $Log: pci_tb.v,v $
// Revision 1.3  2001/06/12 11:15:11  mihad
// Changed module parameters
//
//

`include "constants.v"
`include "pciw_pcir_fifos.v"

// Common definitions for simulation purposes
`define Tpci 75 // Tp/2 = 7.5ns => Tp = 15ns => Fpci = 66MHz
`define Twb 25  // Tp/2 = 2.5ns =>   Tp = 5ns  => Fwb  = 200MHz

module PCI_TB() ;

reg [31:0] pciw_data_in ;
wire [31:0] pciw_data_out;
reg [3:0]  pciw_cbe_in ;
wire [3:0] pciw_cbe_out ;
reg [3:0] pciw_control_in ;
wire [3:0] pciw_control_out ;

wire [31:0] pcir_data_out;
reg [31:0] pcir_data_in;
wire [3:0] pcir_be_out ;
reg [3:0] pcir_be_in ;
reg [3:0] pcir_control_in ;
wire [3:0] pcir_control_out ;

wire pciw_full;
wire pciw_empty ;
wire pciw_almost_full ;
wire pciw_almost_empty ;
reg pciw_wenable ;
reg pciw_renable ;
wire pciw_transaction_ready ;

wire pcir_full;
wire pcir_empty ;
wire pcir_almost_full ;
wire pcir_almost_empty ;
reg pcir_wenable ;
reg pcir_renable ;
wire pcir_transaction_ready ;

reg reset ;
reg pci_clock ;
reg wb_clock ;

reg pcir_flush ;
reg pciw_flush ;

`ifdef FPGA
    assign glbl.GSR = reset ;
`endif

// initial values
initial
begin
    reset <= 1'b1 ;

    pci_clock <= 1'b1 ;
    wb_clock <= 1'b0 ;
    pciw_data_in <= 32'h00000001 ;
    pciw_cbe_in  <= 4'h0 ;
    pcir_be_in  <= 4'h0 ;
    pciw_control_in <= 4'h1 ;
    pciw_wenable <= 1'b0;
    pciw_renable <= 1'b0 ;
    pcir_control_in <= 4'h1 ;
    pcir_wenable <= 1'b0;
    pcir_renable <= 1'b0 ;
    pcir_data_in <= 32'h00000001 ;
    pcir_flush <= 1'b0 ;

    #10 reset = 1'b0 ;
    run_tests ;
end 

// clock generation
always 
begin
   #`Tpci pci_clock = ~pci_clock ;
end

always 
begin
   #`Twb wb_clock = ~wb_clock ;
end

task run_tests;
begin
    pciw_empty_nempty_transition ;
    $display("Empty/not empty transition test for PCIW completed") ;
    pciw_full_empty ;
    $display("Full/empty status generation test for PCIW completed") ;
    
    pcir_empty_nempty_transition ;
    $display("Empty/not empty transition test for PCIR completed") ;
    pcir_full_empty ;
    $display("Full/empty status generation test for PCIR completed") ;

    simultaneous_operation ;
    $stop ;
end
endtask

task pciw_empty_nempty_transition ;
    integer index ;
    integer read_data ;
begin
    read_data = 1 ;
    fork
    begin:write_pciw_once
        // repeat the test several times, so clock to clock transition time changes
        for(index = 2; index <= 101; index = index + 1)
        begin
            // wait for PCIW to become empty
            wait(pciw_empty);
            // sample empty on posedge of clock
            @(posedge pci_clock)
                pciw_wenable <= #`FF_DELAY 1'b1;
                
            // data gets written at clock edge following the one empty was asserted
            @(posedge pci_clock)
            begin
                // prepare data for next write
                pciw_wenable <= #`FF_DELAY 1'b0 ;
                pciw_data_in <= #`FF_DELAY index ;
                pciw_control_in <= #`FF_DELAY index[3:0] ;
                pciw_cbe_in <= #`FF_DELAY index[7:4] ;
                // wait for PCIW to be empty again
                wait(~pciw_empty) ;
            end
        end
    end

    begin:read_pciw
        // repeat test several times
        while(read_data <= 100)
        begin
            wait (~pciw_empty) ;
            @(posedge wb_clock)
                // at first clock edge empty is deasserted assert read enable, so read will be performed on the next clk edge
                pciw_renable <= #`FF_DELAY 1'b1 ;
            @(posedge wb_clock)
            begin
                // sample read data
                if ((pciw_data_out != read_data) || (read_data[3:0] != pciw_control_out) || (read_data[7:4] != pciw_cbe_out))
                begin
                    $display("Empty/not empty transition test failed for PCIW fifo! On read number %d !", index) ;
                    $stop ;
                end
                // prepare data for next read sampling
                read_data <= read_data + 32'd1 ;
                pciw_renable <= #`FF_DELAY 1'b0 ;
                @(posedge wb_clock) ;
            end
        end
    end
    join
end
endtask

task pciw_full_empty;
    integer windex ;
    integer rindex ;
begin
    // task fills FIFO until it is full and monitors status outputs if they are asserted correctly
    windex = 1 ;
    pciw_data_in <= #`FF_DELAY 32'h00000001 ;
    pciw_control_in <= #`FF_DELAY 4'h1 ;
    pciw_cbe_in <= #`FF_DELAY 4'h0 ;
    begin:fill_FIFO
        @(posedge pci_clock)
            pciw_wenable <= #`FF_DELAY 1'b1 ;
        while (windex < `PCIW_DEPTH)
        begin
            @(posedge pci_clock)
            begin
                windex = windex + 1 ;
                pciw_data_in <= #`FF_DELAY windex ;
                pciw_control_in <= #`FF_DELAY windex[3:0] ;
                pciw_cbe_in <= #`FF_DELAY windex[7:4] ;
                
                if (windex == (`PCIW_DEPTH))
                begin
                    if (~pciw_almost_full)
                    begin
                        $display("Almost full status generation test for PCIW failed") ;
                        $stop ;
                    end
                end
            end
        end
        
        pciw_wenable <= #`FF_DELAY 1'b0 ;
        @(posedge pci_clock)
        begin
            if (~pciw_full)
            begin
                $display("Full status generation test for PCIW failed") ;
                $stop ;
            end
        end
    end
    
    // statements read from FIFO, monitor data output and status outputs on proper clock edge
    begin:empty_FIFO
        rindex = 0 ;
        wait (pciw_full) ;
        @(posedge wb_clock)
            pciw_renable <= #`FF_DELAY 1'b1 ;
        while(rindex < (`PCIW_DEPTH - 1))
        begin
            rindex = rindex + 1 ;
            @(posedge wb_clock)
            begin
                if ((pciw_data_out != rindex) || (rindex[3:0] != pciw_control_out) || (rindex[7:4] != pciw_cbe_out))
                begin
                    $display("Full/Empty status generation test failed for PCIW fifo!");
                    $stop ;
                end
                if (rindex == `PCIW_DEPTH - 1)
                begin
                    if (~pciw_almost_empty)
                    begin
                        $display("Almost empty status generation test for PCIW failed") ;
                        $stop ;
                    end
                end
            end
        end

        pciw_renable <= #`FF_DELAY 1'b0 ;
        @(posedge wb_clock)
        begin
            if (~pciw_empty)
            begin
                $display("Empty status generation test for PCIW failed") ;
                $stop ;
            end
        end
    end    
end
endtask


task pcir_empty_nempty_transition ;
    integer index ;
    integer read_data ;
begin
    read_data = 1 ;
    fork
    begin:write_pcir_once
        for(index = 2; index <= 101; index = index + 1)
        begin
            wait(pcir_empty);
            @(posedge wb_clock)
                pcir_wenable <= #`FF_DELAY 1'b1;
                
            // data gets written at next rising clock edge
            @(posedge wb_clock)
            begin
                pcir_wenable <= #`FF_DELAY 1'b0 ;
                pcir_data_in <= #`FF_DELAY index ;
                pcir_control_in <= #`FF_DELAY index[3:0] ;
                pcir_be_in <= #`FF_DELAY index[7:4] ;
                wait(~pcir_empty) ;
            end
        end
    end

    begin:read_pcir
        while(read_data <= 100)
        begin
            wait (~pcir_empty) ;
            @(posedge pci_clock)
                pcir_renable <= #`FF_DELAY 1'b1 ;
            @(posedge pci_clock)
            begin
                if ((pcir_data_out != read_data) || (read_data[3:0] != pcir_control_out) || (read_data[7:4] != pcir_be_out))
                begin
                    $display("Empty/not empty transition test failed for PCIR fifo! On read number %d !", index) ;
                    $stop ;
                end
                read_data <= read_data + 32'd1 ;
                pcir_renable <= #`FF_DELAY 1'b0 ;
                @(posedge pci_clock) ;
            end
        end
    end
    join
end
endtask

task pcir_full_empty;
    integer windex ;
    integer rindex ;
begin
    windex = 1 ;
    pcir_data_in <= #`FF_DELAY 32'h00000001 ;
    pcir_control_in <= #`FF_DELAY 4'h1 ;
    pcir_be_in <= #`FF_DELAY 4'h0 ;
    begin:fill_FIFO
        @(posedge wb_clock)
            pcir_wenable <= #`FF_DELAY 1'b1 ;
        while (windex < `PCIR_DEPTH)
        begin
            @(posedge wb_clock)
            begin
                windex = windex + 1 ;
                pcir_data_in <= #`FF_DELAY windex ;
                pcir_control_in <= #`FF_DELAY windex[3:0] ;
                pcir_be_in <= #`FF_DELAY windex[7:4] ;