URL https://opencores.org/ocsvn/pci/pci/trunk

Subversion Repositories pci

[/] [pci/] [tags/] [rel_6/] [rtl/] [verilog/] [pci_master32_sm_if.v] - Blame information for rev 77

Go to most recent revision | Details | Compare with Previous | View Log


//////////////////////////////////////////////////////////////////////
////                                                              ////
////  File name "pci_master32_sm_if.v"                            ////
////                                                              ////
////  This file is part of the "PCI bridge" project               ////
////  http://www.opencores.org/cores/pci/                         ////
////                                                              ////
////  Author(s):                                                  ////
////      - Miha Dolenc (mihad@opencores.org)                     ////
////                                                              ////
////  All additional information is avaliable in the README       ////
////  file.                                                       ////
////                                                              ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
////                                                              ////
//// Copyright (C) 2001 Miha Dolenc, mihad@opencores.org          ////
////                                                              ////
//// 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: not supported by cvs2svn $
// Revision 1.3  2002/02/01 15:25:12  mihad
// Repaired a few bugs, updated specification, added test bench files and design document
//
// Revision 1.2  2001/10/05 08:14:29  mihad
// Updated all files with inclusion of timescale file for simulation purposes.
//
// Revision 1.1.1.1  2001/10/02 15:33:46  mihad
// New project directory structure
//
//
 
`include "pci_constants.v"
`include "bus_commands.v"
 
// synopsys translate_off
`include "timescale.v"
// synopsys translate_on
 
/*====================================================================
Module provides interface between PCI bridge internals and PCI master
state machine
====================================================================*/
module pci_master32_sm_if
(
    clk_in,
    reset_in,
 
    // interconnect to pci master state machine
    address_out,
    bc_out,
    data_out,
    data_in,
    be_out,
    req_out,
    rdy_out,
    last_out,
 
    next_data_out,
    next_be_out,
    next_last_out,
 
    // status inputs from master SM
    wait_in,
    wtransfer_in,
    rtransfer_in,
    retry_in,
    rerror_in,
    first_in ,
    mabort_in,
 
 
    // WISHBONE WRITE fifo inputs and outputs
    wbw_renable_out,
    wbw_fifo_addr_data_in,
    wbw_fifo_cbe_in,
    wbw_fifo_control_in,
    wbw_fifo_empty_in,
    wbw_fifo_transaction_ready_in,
 
    // WISHBONE READ fifo inputs and outputs
    wbr_fifo_wenable_out,
    wbr_fifo_data_out,
    wbr_fifo_be_out,
    wbr_fifo_control_out,
 
    // delayed transaction control logic inputs and outputs
    del_wdata_in,
    del_complete_out,
    del_req_in,
    del_addr_in,
    del_bc_in,
    del_be_in,
    del_burst_in,
    del_error_out,
    del_rty_exp_out,
    del_we_in,
 
    // configuration space interconnect
    // error reporting
    err_addr_out,
    err_bc_out,
    err_signal_out,
    err_source_out,
    err_rty_exp_out,
 
    cache_line_size_in,
 
    // two signals for pci control and status
    mabort_received_out,
    tabort_received_out,
 
    posted_write_not_present_out
);
 
// system inputs
input clk_in ;
input reset_in ;
 
// PCI master state machine interconnect
output  [31:0]  address_out ;   // address output
 
output  [3:0]   bc_out ;        // bus command output
reg     [3:0]   bc_out ;
 
output  [31:0]  data_out ;      // data output for writes
reg     [31:0]  data_out ;
 
input   [31:0]  data_in ;       // data input for reads
output  [3:0]   be_out  ;       // byte enable output
reg     [3:0]   be_out  ;
 
output          req_out ;       // request output
 
output          rdy_out ;       // ready output
reg             rdy_out ;
 
output          last_out ;      // last data indicator output
 
output  [31:0]  next_data_out ; // next data output
output  [3:0]   next_be_out ;   // next byte enable output
output          next_last_out ; // next transfer last indicator
 
input           wait_in,
                wtransfer_in,
                rtransfer_in,
                retry_in,
                rerror_in,
                first_in ,
                mabort_in ;
 
// WISHBONE write fifo interconnect
output          wbw_renable_out ;          // WBW_FIFO read enable signal
 
input   [31:0]  wbw_fifo_addr_data_in ;         // WBW_FIFO address/data bus
input   [3:0]   wbw_fifo_cbe_in ;               // WBW_FIFO command/byte enable bus
input   [3:0]   wbw_fifo_control_in ;           // WBW_FIFO control bus
input           wbw_fifo_empty_in ;             // WBW_FIFO's empty status indicator
input           wbw_fifo_transaction_ready_in ; // WBW_FIFO transaction ready indicator
 
// WISHBONE read FIFO interconnect
output          wbr_fifo_wenable_out ;          // write enable for WBR_FIFO
 
output  [31:0]  wbr_fifo_data_out ;             // data output to WBR_FIFO
 
output  [3:0]   wbr_fifo_be_out ;               // byte enable output for WBR_FIFO
 
output  [3:0]   wbr_fifo_control_out ;          // WBR_FIFO control output
 
// delayed transaction control logic inputs and outputs
input   [31:0]  del_wdata_in ;                  // delayed write data input
output          del_complete_out ;              // delayed transaction completed output
 
input           del_req_in ;                    // delayed transaction request
input   [31:0]  del_addr_in ;                   // delayed transaction address
input   [3:0]   del_bc_in ;                     // delayed transaction bus command input
input   [3:0]   del_be_in ;                     // delayed transaction byte enables input
input           del_burst_in ;                  // delayed transaction burst req. indicator
output          del_error_out ;                 // delayed transation error termination signal
 
output          del_rty_exp_out ;               // retry expired output for delayed transactions
 
input           del_we_in ;                     // delayed write request indicator
 
output  [31:0]  err_addr_out ;                  // erroneous address output
output  [3:0]   err_bc_out ;                    // erroneous bus command output
 
output          err_signal_out ;                // error signalization
 
output          err_source_out ;                // error source indicator
 
input   [7:0]   cache_line_size_in ;            // cache line size value input
 
output          err_rty_exp_out ;               // retry expired error output
 
output          mabort_received_out ;           // master abort signaled to status register
output          tabort_received_out ;           // target abort signaled to status register
 
output          posted_write_not_present_out ;  // used in target state machine - must deny read completions when this signal is 0
 
 
assign err_bc_out   = bc_out ;
 
// assign read outputs
/*==================================================================================================================
WISHBONE read FIFO data outputs - just link them to SM data outputs and delayed BE input
==================================================================================================================*/
assign wbr_fifo_data_out = data_in ;
assign wbr_fifo_be_out   = del_be_in ;
 
// decode if current bus command is configuration command
wire conf_cyc_bc = ( bc_out[3:1] == `BC_CONF_RW ) ;
 
// register for indicating that current data is also last in transfer
reg current_last ;
 
// register indicating that last data was transfered OK
reg last_transfered ;
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        last_transfered <= #`FF_DELAY 1'b0 ;
    else
        last_transfered <= #`FF_DELAY ~wait_in && last_out && wtransfer_in ;
end
 
// status signals output assignement
assign mabort_received_out = mabort_in ;
 
wire tabort_ff_in = ~wait_in && rerror_in ;
 
reg    tabort_received_out ;
always@(posedge reset_in or posedge clk_in)
begin
    if ( reset_in )
        tabort_received_out <= #`FF_DELAY 1'b0 ;
    else
        tabort_received_out <= #`FF_DELAY tabort_ff_in ;
end
 
// error recovery indicator
reg err_recovery ;
 
// operation is locked until error recovery is in progress or error bit is not cleared in configuration space
wire err_lock = err_recovery ;
 
// three requests are possible - posted write, delayed write and delayed read
reg del_write_req ;
reg posted_write_req ;
reg del_read_req ;
 
// assign request output
assign req_out = del_write_req || posted_write_req || del_read_req ;
 
// posted write is not present, when WB Write Fifo is empty and posted write transaction is not beeing requested at present time
assign posted_write_not_present_out = !posted_write_req && wbw_fifo_empty_in ;
 
// write requests are staged, so data is read from source into current data register and next data register
reg write_req_int ;
always@(posedge reset_in or posedge clk_in)
begin
    if ( reset_in )
        write_req_int <= #`FF_DELAY 1'b0 ;
    else
        write_req_int <= #`FF_DELAY posted_write_req || del_write_req ;
 
end
 
// ready output is generated one clock after request for reads and two after for writes
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        rdy_out <= #`FF_DELAY 1'b0 ;
    else
        rdy_out <= #`FF_DELAY del_read_req || ( (posted_write_req || del_write_req) && write_req_int) ;
end
 
// wires with logic used as inputs to request FFs
wire do_posted_write = ( wbw_fifo_transaction_ready_in && ~wbw_fifo_empty_in && ~err_lock ) ;
wire do_del          = ( del_req_in && ~err_lock && wbw_fifo_empty_in ) ;
wire do_del_write    = do_del &&  del_we_in ;
wire do_del_read     = do_del && ~del_we_in ;
 
// register for indicating current operation's data source
parameter DELAYED_WRITE = 1'b1 ;
parameter POSTED_WRITE  = 1'b0 ;
 
// new data source - depending on which transaction will be processed next - delayed read is here because source of byte enables must
// be specified for delayed reads also - data source is not relevant for delayed reads, so value is don't care anyway
wire new_data_source = (do_del_write || do_del_read) ? DELAYED_WRITE : POSTED_WRITE ; // input to data source register
wire data_source_change = ~req_out ;    // change (enable) for data source register - when no requests are in progress
 
reg data_source ;           // data source value
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        // default value is posted write source - wbw_fifo
        data_source <= #`FF_DELAY POSTED_WRITE ;
    else
    if (data_source_change)
        // change data source on rising clock edge
        data_source <= #`FF_DELAY new_data_source ;
end
 
// multiplexer for data output to PCI MASTER state machine
reg [31:0] source_data ;
reg [3:0]  source_be ;
always@(data_source or wbw_fifo_addr_data_in or wbw_fifo_cbe_in or del_wdata_in or del_be_in or del_burst_in)
begin
    case (data_source)
        POSTED_WRITE:   begin
                            source_data = wbw_fifo_addr_data_in ;
                            source_be   = wbw_fifo_cbe_in ;
                        end
        DELAYED_WRITE:  begin
                            source_data = del_wdata_in ;
                            // read all bytes during delayed burst read!
                            source_be   = ~( del_be_in | {4{del_burst_in}} ) ;
                        end
    endcase
end
 
wire            waddr =  wbw_fifo_control_in[`ADDR_CTRL_BIT] ;
 
// address change indicator - address is allowed to be loaded only when no transaction is in progress!
wire            address_change = ~req_out ; // address change - whenever there is no request in progress
 
// new address - input to register storing address of current request - if posted write request will be next,
// load address and bus command from wbw_fifo, else load data from delayed transaction logic
wire     [31:0] new_address = ( ~req_out && do_posted_write ) ? wbw_fifo_addr_data_in[31:0] : del_addr_in[31:0] ;
wire     [3:0]  new_bc      = ( ~req_out && do_posted_write ) ? wbw_fifo_cbe_in : del_bc_in ;
 
// address counter enable - only for posted writes when data is actually transfered
wire addr_count_en = ~wait_in && posted_write_req && rtransfer_in ;
 
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        bc_out <= #`FF_DELAY `BC_RESERVED0 ;
    else
    if (address_change)
        bc_out <= #`FF_DELAY new_bc ;
end
 
reg [29:0] current_dword_address ;
 
// DWORD address counter with load
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        current_dword_address <= #`FF_DELAY 30'h0000_0000 ;
    else
    if (address_change)
        current_dword_address <= #`FF_DELAY new_address[31:2] ;
    else
    if (addr_count_en)
        current_dword_address <= #`FF_DELAY current_dword_address + 1'b1 ;
end
 
reg [1:0] current_byte_address ;
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        current_byte_address <= #`FF_DELAY 2'b00 ;
    else
    if (address_change)
        current_byte_address <= #`FF_DELAY new_address[1:0] ;
end
 
// address output to PCI master state machine assignement
assign address_out  = { current_dword_address, current_byte_address } ;
 
// the same for erroneous address assignement
assign err_addr_out = { current_dword_address, current_byte_address } ;
 
// cacheline size counter - for read transaction length control
// cache line count is enabled during burst reads when data is actually transfered
wire read_count_enable = ~wait_in && del_read_req && del_burst_in && wtransfer_in  ;
 
// cache line counter is loaded when del read request is not in progress
wire read_count_load   = ~del_read_req ;
 
reg [(`WBR_ADDR_LENGTH - 1):0] max_read_count ;
always@(cache_line_size_in or del_bc_in)
begin
    if ( (cache_line_size_in >= `WBR_DEPTH) || (~del_bc_in[1] && ~del_bc_in[0]) )
        max_read_count = `WBR_DEPTH - 1'b1;
    else
        max_read_count = cache_line_size_in ;
end
 
reg [(`WBR_ADDR_LENGTH - 1):0] read_count ;
 
// cache line bound indicator - it signals when data for one complete cacheline was read
wire read_bound_comb = ~|(read_count[(`WBR_ADDR_LENGTH - 1):2]) ;
reg  read_bound ;
always@(posedge clk_in or posedge reset_in)
begin
    if ( reset_in )
        read_bound <= #`FF_DELAY 1'b0 ;
    else if (read_count_load)
        read_bound <= #`FF_DELAY 1'b0 ;
    else if ( read_count_enable )
        read_bound <= #`FF_DELAY read_bound_comb ;
end
 
// down counter with load
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        read_count <= #`FF_DELAY 0 ;
    else
    if (read_count_load)
        read_count <= #`FF_DELAY max_read_count ;
    else
    if (read_count_enable)
        read_count <= #`FF_DELAY read_count - 1'b1 ;
 
end
 
// flip flop indicating error recovery is in progress
reg err_recovery_in ;
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        err_recovery <= #`FF_DELAY 1'b0 ;
    else
        err_recovery <= #`FF_DELAY err_recovery_in ;
end
 
/*// retry counter implementation
reg [7:0] retry_count ;
 
wire retry_expired = ~|(retry_count[7:1]) ;
 
// loading of retry counter - whenever no request is present or other termination than retry or wait is signalled
wire retry_load = ~req_out || (~wait_in && rtransfer_in) ;
 
// retry DOWN counter with load
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        retry_count <= #`FF_DELAY 8'hFF ;
    else
    if ( retry_load )
        retry_count <= #`FF_DELAY `PCI_RTY_CNT_MAX ;
    else
    if (retry_in)
        retry_count <= #`FF_DELAY retry_count - 1'b1 ;
end*/
 
/*==================================================================================================================
Delayed write requests are always single transfers!
Delayed write request starts, when no request is currently beeing processed and it is signaled from other side
of the bridge.
==================================================================================================================*/
// delayed write request FF input control
reg del_write_req_input ;
 
always@(
    do_del_write or
    del_write_req or
    posted_write_req or
    del_read_req or
    wait_in or
    //retry_in or
    //retry_expired or
    rtransfer_in or
    rerror_in or
    mabort_in
)
begin
    if (~del_write_req)
    begin
        // delayed write is not in progress and is requested
        // delayed write can be requested when no other request is in progress
        del_write_req_input = ~posted_write_req && ~del_read_req && do_del_write ;
    end
    else
    begin
        // delayed write request is in progress - assign input
        del_write_req_input = wait_in ||
                              ( /*~( retry_in && retry_expired) &&*/
                                ~rtransfer_in && ~rerror_in && ~mabort_in
                              );
    end
end
 
// delayed write request FLIP-FLOP
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        del_write_req <= #`FF_DELAY 1'b0 ;
    else
        del_write_req <= #`FF_DELAY del_write_req_input ;
end
 
/*================================================================================================
Posted write request indicator.
Posted write starts whenever no request is in progress and one whole posted write is
stored in WBW_FIFO. It ends on error terminations ( master, target abort, retry expired) or
data transfer terminations if last data is on top of FIFO.
Continues on wait, retry, and disconnect without data.
================================================================================================*/
// posted write request FF input control
reg posted_write_req_input ;
always@(
    do_posted_write or
    del_write_req or
    posted_write_req or
    del_read_req or
    wait_in or
    //retry_in or
    rerror_in or
    mabort_in or
    //retry_expired or
    rtransfer_in or
    last_transfered
)
begin
    if (~posted_write_req)
    begin
        // posted write is not in progress
        posted_write_req_input = ~del_write_req && ~del_read_req && do_posted_write ;
    end
    else
    begin
        posted_write_req_input = wait_in ||
                                 (/*~(retry_in && retry_expired && ~rtransfer_in) &&*/
                                  ~rerror_in && ~mabort_in &&
                                  ~(last_transfered)
                                 ) ;
 
    end
end
 
// posted write request flip flop
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        posted_write_req <= #`FF_DELAY 1'b0 ;
    else
        posted_write_req <= #`FF_DELAY posted_write_req_input ;
 
end
 
/*================================================================================================
Delayed read request indicator.
Delayed read starts whenever no request is in progress and delayed read request is signaled from
other side of bridge. It ends on error terminations ( master, target abort, retry expired) or
data transfer terminations if it is not burst transfer or on cache line bounds on burst transfer.
It also ends on disconnects.
Continues on wait and retry.
================================================================================================*/
// delayed read FF input control
reg del_read_req_input ;
always@(
    do_del_read or
    del_write_req or
    posted_write_req or
    del_read_req or
    last_transfered or
    wait_in or
    retry_in or
    //retry_expired or
    mabort_in or
    rtransfer_in or
    rerror_in or
    first_in or
    del_complete_out
)
begin
    if (~del_read_req)
    begin
        del_read_req_input = ~del_write_req && ~posted_write_req && ~del_complete_out && do_del_read ;
    end
    else
    begin
        del_read_req_input = wait_in ||
                             ( ~(retry_in && (~first_in /*|| retry_expired */)) &&
                               ~mabort_in && ~rerror_in &&
                               ~(last_transfered)
                             ) ;
    end
end
 
// delayed read request FF
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        del_read_req <= #`FF_DELAY 1'b0 ;
    else
        del_read_req <= #`FF_DELAY del_read_req_input ;
end
 
// wire indicating last entry of transaction on top of fifo
wire wlast = wbw_fifo_control_in[`LAST_CTRL_BIT] ;
 
wire last_int = posted_write_req && wlast || del_write_req ;
 
// intermidiate data, byte enable and last registers
reg [31:0] intermediate_data ;
reg  [3:0] intermediate_be ;
reg        intermediate_last ;
 
wire intermediate_enable = ( posted_write_req || del_write_req ) && ( ~write_req_int || (( ~rdy_out || ~wait_in && rtransfer_in ) && ~intermediate_last)) ;
 
always@(posedge reset_in or posedge clk_in)
begin
    if ( reset_in )
    begin
        intermediate_data <= #`FF_DELAY 32'h0000_0000 ;
        intermediate_be   <= #`FF_DELAY 4'h0 ;
        intermediate_last <= #`FF_DELAY 1'b0 ;
    end
    else
    if ( intermediate_enable )
    begin
        intermediate_data <= #`FF_DELAY source_data ;
        intermediate_be   <= #`FF_DELAY source_be ;
        intermediate_last <= #`FF_DELAY last_int ;
    end
end
 
// multiplexer for next data
reg [31:0] next_data_out ;
reg [3:0] next_be_out   ;
reg write_next_last ;
reg [3:0] write_next_be ;
 
always@(rtransfer_in or intermediate_data or intermediate_be or intermediate_last or wbw_fifo_addr_data_in or wbw_fifo_cbe_in or wlast)
begin
    if( rtransfer_in )
    begin
        next_data_out   = wbw_fifo_addr_data_in ;
        write_next_last = wlast ;
        write_next_be   = wbw_fifo_cbe_in ;
    end
    else
    begin
        next_data_out   = intermediate_data ;
        write_next_last = intermediate_last ;
        write_next_be   = intermediate_be ;
    end
end
 
always@(del_read_req or source_be or write_next_be)
begin
    if (del_read_req)
        next_be_out = source_be ;
    else
        next_be_out = write_next_be ;
end
/*================================================================================================
WBW_FIFO read enable - read from WBW_FIFO is performed on posted writes, when data transfer
termination is received - transfer or disconnect with data. Reads are enabled during error
recovery also, since erroneous transaction must be pulled out of FIFO!
================================================================================================*/
// wbw_fifo read enable input control
 
assign wbw_renable_out = ~req_out && (do_posted_write || err_recovery) ||
                              posted_write_req && ( ~write_req_int || (~rdy_out && ~intermediate_last) || (~wait_in && rtransfer_in && ~intermediate_last)) ;
 
/*================================================================================================
WBR_FIFO write enable control -
writes to FIFO are possible only when delayed read request is in progress and data transfer
or error termination is signalled. It is not enabled on retry or disconnect without data.
================================================================================================*/
// wbr_fifo write enable control - enabled when transfer is in progress and data is transfered or error is signalled
assign wbr_fifo_wenable_out = del_read_req && ~wait_in && ( rtransfer_in || mabort_in || rerror_in ) ;
 
/*================================================================================================
WBR_FIFO control output for identifying data entries.
This is necesary because of prefetched reads, which partially succeed. On error, error entry
gets in to signal it on WISHBONE bus if WISHBONE master reads up to this entry.
================================================================================================*/
assign wbr_fifo_control_out[`ADDR_CTRL_BIT]       = 1'b0 ;
assign wbr_fifo_control_out[`LAST_CTRL_BIT]       = last_transfered ;
assign wbr_fifo_control_out[`DATA_ERROR_CTRL_BIT] = rerror_in || (mabort_in && ~conf_cyc_bc) ;
assign wbr_fifo_control_out[`UNUSED_CTRL_BIT]     = 1'b0 ;
 
// retry expired error for posted writes control
//assign err_rty_exp_out = posted_write_req && ~wait_in && retry_in && retry_expired && ~rtransfer_in;
assign err_rty_exp_out = 1'b0 ;
 
// error source and error signal output control logic - only for posted writes
assign err_source_out = mabort_in /*|| err_rty_exp_out*/ ;
 
assign err_signal_out = /*err_rty_exp_out || */ posted_write_req && ~wait_in && (mabort_in || rerror_in) ;
 
//assign del_rty_exp_out = (~wait_in && (del_read_req || del_write_req)) && (retry_in && retry_expired && ~rtransfer_in) ;
assign del_rty_exp_out = 1'b0 ;
 
assign del_error_out   = ~wait_in && (del_write_req || del_read_req) && ( (mabort_in && ~conf_cyc_bc) || rerror_in ) ;
 
wire   del_write_complete = del_write_req && ( rtransfer_in || rerror_in || mabort_in ) ;
wire   del_read_complete  = del_read_req  && ( rerror_in || mabort_in || ( last_transfered ) || ( retry_in && ~first_in ) ) ;
 
assign del_complete_out = ~wait_in && ( del_write_complete || del_read_complete ) ;
 
// next last output generation
assign next_last_out = del_write_req || del_read_req && ( ~del_burst_in || read_bound ) || posted_write_req && ( write_next_last ) ;
/*==================================================================================================================
Error recovery FF gets a value of one, when during posted write error occurs. It is cleared when all the data provided
for erroneous transaction is pulled out of WBW_FIFO
==================================================================================================================*/
 
// error recovery flip flop input - used when posted write is terminated with an error
always@(
    err_recovery or
    last_out or
    wlast or
    err_signal_out or
    intermediate_last
)
begin
    // when error recovery is not set - drive its input so it gets set
    if ( ~err_recovery )
        err_recovery_in = ~last_out && ~intermediate_last && err_signal_out ;
    else
        // when error recovery is set, wbw_fifo is enabled - clear err_recovery when last data entry of erroneous transaction is pulled out of fifo
        err_recovery_in = ~wlast ;
end
 
wire data_out_load = (posted_write_req || del_write_req) && ( !rdy_out || ( !wait_in && rtransfer_in ) ) ;
 
wire be_out_load  = (req_out && !rdy_out) || ( posted_write_req && !wait_in && rtransfer_in ) ;
 
wire last_load  = req_out && ( ~rdy_out || ~wait_in && wtransfer_in ) ;
 
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        data_out <= #`FF_DELAY 32'h0000_0000 ;
    else
    if ( data_out_load )
        data_out <= #`FF_DELAY intermediate_data ;
end
 
always@(posedge clk_in or posedge reset_in)
begin
    if ( reset_in )
        be_out <= #`FF_DELAY 4'hF ;
    else
    if ( be_out_load )
        be_out <= #`FF_DELAY posted_write_req ? intermediate_be : source_be ;
end
 
always@(posedge reset_in or posedge clk_in)
begin
    if (reset_in)
        current_last <= #`FF_DELAY 1'b0 ;
    else
    if ( last_load )
        current_last <= #`FF_DELAY next_last_out ;
end
 
assign last_out = current_last ;
endmodule

Line No.	Rev	Author	Line
1	2	mihad	`//////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// File name "pci_master32_sm_if.v" ////`
4			`//// ////`
5			`//// This file is part of the "PCI bridge" project ////`
6			`//// http://www.opencores.org/cores/pci/ ////`
7			`//// ////`
8			`//// Author(s): ////`
9			`//// - Miha Dolenc (mihad@opencores.org) ////`
10			`//// ////`
11			`//// All additional information is avaliable in the README ////`
12			`//// file. ////`
13			`//// ////`
14			`//// ////`
15			`//////////////////////////////////////////////////////////////////////`
16			`//// ////`
17			`//// Copyright (C) 2001 Miha Dolenc, mihad@opencores.org ////`
18			`//// ////`
19			`//// This source file may be used and distributed without ////`
20			`//// restriction provided that this copyright statement is not ////`
21			`//// removed from the file and that any derivative work contains ////`
22			`//// the original copyright notice and the associated disclaimer. ////`
23			`//// ////`
24			`//// This source file is free software; you can redistribute it ////`
25			`//// and/or modify it under the terms of the GNU Lesser General ////`
26			`//// Public License as published by the Free Software Foundation; ////`
27			`//// either version 2.1 of the License, or (at your option) any ////`
28			`//// later version. ////`
29			`//// ////`
30			`//// This source is distributed in the hope that it will be ////`
31			`//// useful, but WITHOUT ANY WARRANTY; without even the implied ////`
32			`//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ////`
33			`//// PURPOSE. See the GNU Lesser General Public License for more ////`
34			`//// details. ////`
35			`//// ////`
36			`//// You should have received a copy of the GNU Lesser General ////`
37			`//// Public License along with this source; if not, download it ////`
38			`//// from http://www.opencores.org/lgpl.shtml ////`
39			`//// ////`
40			`//////////////////////////////////////////////////////////////////////`
41			`//`
42			`// CVS Revision History`
43			`//`
44			`// $Log: not supported by cvs2svn $`
45	77	mihad	`// Revision 1.3 2002/02/01 15:25:12 mihad`
46			`// Repaired a few bugs, updated specification, added test bench files and design document`
47			`//`
48	21	mihad	`// Revision 1.2 2001/10/05 08:14:29 mihad`
49			`// Updated all files with inclusion of timescale file for simulation purposes.`
50			`//`
51	6	mihad	`// Revision 1.1.1.1 2001/10/02 15:33:46 mihad`
52			`// New project directory structure`
53	2	mihad	`//`
54	6	mihad	`//`
55	2	mihad
56	21	mihad	`include "pci_constants.v"
57	2	mihad	`include "bus_commands.v"
58	21	mihad
59			`// synopsys translate_off`
60	6	mihad	`include "timescale.v"
61	21	mihad	`// synopsys translate_on`
62	2	mihad
63			`/*====================================================================`
64			`Module provides interface between PCI bridge internals and PCI master`
65			`state machine`
66			`====================================================================*/`
67	77	mihad	`module pci_master32_sm_if`
68	2	mihad	`(`
69			`clk_in,`
70			`reset_in,`
71	21	mihad
72	2	mihad	`// interconnect to pci master state machine`
73			`address_out,`
74			`bc_out,`
75			`data_out,`
76			`data_in,`
77			`be_out,`
78			`req_out,`
79			`rdy_out,`
80			`last_out,`
81	21	mihad
82	2	mihad	`next_data_out,`
83			`next_be_out,`
84			`next_last_out,`
85
86			`// status inputs from master SM`
87			`wait_in,`
88			`wtransfer_in,`
89			`rtransfer_in,`
90			`retry_in,`
91			`rerror_in,`
92			`first_in ,`
93			`mabort_in,`
94
95
96			`// WISHBONE WRITE fifo inputs and outputs`
97			`wbw_renable_out,`
98			`wbw_fifo_addr_data_in,`
99			`wbw_fifo_cbe_in,`
100			`wbw_fifo_control_in,`
101			`wbw_fifo_empty_in,`
102			`wbw_fifo_transaction_ready_in,`
103	21	mihad
104	2	mihad	`// WISHBONE READ fifo inputs and outputs`
105			`wbr_fifo_wenable_out,`
106			`wbr_fifo_data_out,`
107			`wbr_fifo_be_out,`
108			`wbr_fifo_control_out,`
109
110			`// delayed transaction control logic inputs and outputs`
111			`del_wdata_in,`
112			`del_complete_out,`
113			`del_req_in,`
114			`del_addr_in,`
115			`del_bc_in,`
116			`del_be_in,`
117			`del_burst_in,`
118			`del_error_out,`
119			`del_rty_exp_out,`
120			`del_we_in,`
121
122			`// configuration space interconnect`
123			`// error reporting`
124			`err_addr_out,`
125			`err_bc_out,`
126			`err_signal_out,`
127			`err_source_out,`
128			`err_rty_exp_out,`
129
130			`cache_line_size_in,`
131	21	mihad
132			`// two signals for pci control and status`
133	2	mihad	`mabort_received_out,`
134	21	mihad	`tabort_received_out,`
135
136			`posted_write_not_present_out`
137	2	mihad	`);`
138
139			`// system inputs`
140			`input clk_in ;`
141			`input reset_in ;`
142
143			`// PCI master state machine interconnect`
144			`output [31:0] address_out ; // address output`
145
146			`output [3:0] bc_out ; // bus command output`
147	21	mihad	`reg [3:0] bc_out ;`
148	2	mihad
149			`output [31:0] data_out ; // data output for writes`
150			`reg [31:0] data_out ;`
151
152			`input [31:0] data_in ; // data input for reads`
153			`output [3:0] be_out ; // byte enable output`
154	21	mihad	`reg [3:0] be_out ;`
155	2	mihad
156			`output req_out ; // request output`
157
158			`output rdy_out ; // ready output`
159			`reg rdy_out ;`
160
161			`output last_out ; // last data indicator output`
162
163			`output [31:0] next_data_out ; // next data output`
164			`output [3:0] next_be_out ; // next byte enable output`
165			`output next_last_out ; // next transfer last indicator`
166
167			`input wait_in,`
168			`wtransfer_in,`
169			`rtransfer_in,`
170			`retry_in,`
171			`rerror_in,`
172			`first_in ,`
173			`mabort_in ;`
174
175			`// WISHBONE write fifo interconnect`
176			`output wbw_renable_out ; // WBW_FIFO read enable signal`
177
178			`input [31:0] wbw_fifo_addr_data_in ; // WBW_FIFO address/data bus`
179			`input [3:0] wbw_fifo_cbe_in ; // WBW_FIFO command/byte enable bus`
180			`input [3:0] wbw_fifo_control_in ; // WBW_FIFO control bus`
181			`input wbw_fifo_empty_in ; // WBW_FIFO's empty status indicator`
182			`input wbw_fifo_transaction_ready_in ; // WBW_FIFO transaction ready indicator`
183
184			`// WISHBONE read FIFO interconnect`
185			`output wbr_fifo_wenable_out ; // write enable for WBR_FIFO`
186
187			`output [31:0] wbr_fifo_data_out ; // data output to WBR_FIFO`
188
189			`output [3:0] wbr_fifo_be_out ; // byte enable output for WBR_FIFO`
190
191			`output [3:0] wbr_fifo_control_out ; // WBR_FIFO control output`
192
193			`// delayed transaction control logic inputs and outputs`
194			`input [31:0] del_wdata_in ; // delayed write data input`
195			`output del_complete_out ; // delayed transaction completed output`
196
197			`input del_req_in ; // delayed transaction request`
198			`input [31:0] del_addr_in ; // delayed transaction address`
199			`input [3:0] del_bc_in ; // delayed transaction bus command input`
200			`input [3:0] del_be_in ; // delayed transaction byte enables input`
201			`input del_burst_in ; // delayed transaction burst req. indicator`
202			`output del_error_out ; // delayed transation error termination signal`
203
204			`output del_rty_exp_out ; // retry expired output for delayed transactions`
205
206			`input del_we_in ; // delayed write request indicator`
207
208			`output [31:0] err_addr_out ; // erroneous address output`
209			`output [3:0] err_bc_out ; // erroneous bus command output`
210
211			`output err_signal_out ; // error signalization`
212
213			`output err_source_out ; // error source indicator`
214
215			`input [7:0] cache_line_size_in ; // cache line size value input`
216
217			`output err_rty_exp_out ; // retry expired error output`
218
219			`output mabort_received_out ; // master abort signaled to status register`
220			`output tabort_received_out ; // target abort signaled to status register`
221
222	21	mihad	`output posted_write_not_present_out ; // used in target state machine - must deny read completions when this signal is 0`
223	2	mihad
224	21	mihad
225	2	mihad	`assign err_bc_out = bc_out ;`
226
227			`// assign read outputs`
228			`/*==================================================================================================================`
229			`WISHBONE read FIFO data outputs - just link them to SM data outputs and delayed BE input`
230			`==================================================================================================================*/`
231			`assign wbr_fifo_data_out = data_in ;`
232			`assign wbr_fifo_be_out = del_be_in ;`
233
234			`// decode if current bus command is configuration command`
235			wire conf_cyc_bc = ( bc_out[3:1] == `BC_CONF_RW ) ;
236
237			`// register for indicating that current data is also last in transfer`
238			`reg current_last ;`
239
240			`// register indicating that last data was transfered OK`
241			`reg last_transfered ;`
242			`always@(posedge reset_in or posedge clk_in)`
243			`begin`
244			`if (reset_in)`
245			last_transfered <= #`FF_DELAY 1'b0 ;
246			`else`
247			last_transfered <= #`FF_DELAY ~wait_in && last_out && wtransfer_in ;
248			`end`
249
250			`// status signals output assignement`
251			`assign mabort_received_out = mabort_in ;`
252
253			`wire tabort_ff_in = ~wait_in && rerror_in ;`
254
255			`reg tabort_received_out ;`
256			`always@(posedge reset_in or posedge clk_in)`
257			`begin`
258			`if ( reset_in )`
259			tabort_received_out <= #`FF_DELAY 1'b0 ;
260			`else`
261			tabort_received_out <= #`FF_DELAY tabort_ff_in ;
262			`end`
263
264			`// error recovery indicator`
265			`reg err_recovery ;`
266
267			`// operation is locked until error recovery is in progress or error bit is not cleared in configuration space`
268	21	mihad	`wire err_lock = err_recovery ;`
269	2	mihad
270			`// three requests are possible - posted write, delayed write and delayed read`
271			`reg del_write_req ;`
272			`reg posted_write_req ;`
273			`reg del_read_req ;`
274
275			`// assign request output`
276			`assign req_out = del_write_req \|\| posted_write_req \|\| del_read_req ;`
277
278	21	mihad	`// posted write is not present, when WB Write Fifo is empty and posted write transaction is not beeing requested at present time`
279			`assign posted_write_not_present_out = !posted_write_req && wbw_fifo_empty_in ;`
280
281	2	mihad	`// write requests are staged, so data is read from source into current data register and next data register`
282			`reg write_req_int ;`
283			`always@(posedge reset_in or posedge clk_in)`
284			`begin`
285			`if ( reset_in )`
286			write_req_int <= #`FF_DELAY 1'b0 ;
287			`else`
288			write_req_int <= #`FF_DELAY posted_write_req \|\| del_write_req ;
289
290			`end`
291
292			`// ready output is generated one clock after request for reads and two after for writes`
293			`always@(posedge reset_in or posedge clk_in)`
294			`begin`
295			`if (reset_in)`
296			rdy_out <= #`FF_DELAY 1'b0 ;
297			`else`
298			rdy_out <= #`FF_DELAY del_read_req \|\| ( (posted_write_req \|\| del_write_req) && write_req_int) ;
299			`end`
300
301			`// wires with logic used as inputs to request FFs`
302			`wire do_posted_write = ( wbw_fifo_transaction_ready_in && ~wbw_fifo_empty_in && ~err_lock ) ;`
303			`wire do_del = ( del_req_in && ~err_lock && wbw_fifo_empty_in ) ;`
304			`wire do_del_write = do_del && del_we_in ;`
305			`wire do_del_read = do_del && ~del_we_in ;`
306
307			`// register for indicating current operation's data source`
308			`parameter DELAYED_WRITE = 1'b1 ;`
309			`parameter POSTED_WRITE = 1'b0 ;`
310
311			`// new data source - depending on which transaction will be processed next - delayed read is here because source of byte enables must`
312			`// be specified for delayed reads also - data source is not relevant for delayed reads, so value is don't care anyway`
313			`wire new_data_source = (do_del_write \|\| do_del_read) ? DELAYED_WRITE : POSTED_WRITE ; // input to data source register`
314			`wire data_source_change = ~req_out ; // change (enable) for data source register - when no requests are in progress`
315
316			`reg data_source ; // data source value`
317			`always@(posedge reset_in or posedge clk_in)`
318			`begin`
319			`if (reset_in)`
320			`// default value is posted write source - wbw_fifo`
321			data_source <= #`FF_DELAY POSTED_WRITE ;
322			`else`
323			`if (data_source_change)`
324			`// change data source on rising clock edge`
325			data_source <= #`FF_DELAY new_data_source ;
326			`end`
327
328			`// multiplexer for data output to PCI MASTER state machine`
329			`reg [31:0] source_data ;`
330			`reg [3:0] source_be ;`
331	21	mihad	`always@(data_source or wbw_fifo_addr_data_in or wbw_fifo_cbe_in or del_wdata_in or del_be_in or del_burst_in)`
332	2	mihad	`begin`
333			`case (data_source)`
334			`POSTED_WRITE: begin`
335			`source_data = wbw_fifo_addr_data_in ;`
336			`source_be = wbw_fifo_cbe_in ;`
337			`end`
338			`DELAYED_WRITE: begin`
339			`source_data = del_wdata_in ;`
340	21	mihad	`// read all bytes during delayed burst read!`
341			`source_be = ~( del_be_in \| {4{del_burst_in}} ) ;`
342	2	mihad	`end`
343			`endcase`
344			`end`
345
346			wire waddr = wbw_fifo_control_in[`ADDR_CTRL_BIT] ;
347
348			`// address change indicator - address is allowed to be loaded only when no transaction is in progress!`
349			`wire address_change = ~req_out ; // address change - whenever there is no request in progress`
350
351			`// new address - input to register storing address of current request - if posted write request will be next,`
352			`// load address and bus command from wbw_fifo, else load data from delayed transaction logic`
353			`wire [31:0] new_address = ( ~req_out && do_posted_write ) ? wbw_fifo_addr_data_in[31:0] : del_addr_in[31:0] ;`
354			`wire [3:0] new_bc = ( ~req_out && do_posted_write ) ? wbw_fifo_cbe_in : del_bc_in ;`
355
356			`// address counter enable - only for posted writes when data is actually transfered`
357	21	mihad	`wire addr_count_en = ~wait_in && posted_write_req && rtransfer_in ;`
358	2	mihad
359			`always@(posedge reset_in or posedge clk_in)`
360			`begin`
361			`if (reset_in)`
362			bc_out <= #`FF_DELAY `BC_RESERVED0 ;
363			`else`
364			`if (address_change)`
365			bc_out <= #`FF_DELAY new_bc ;
366	21	mihad	`end`
367	2	mihad
368	21	mihad	`reg [29:0] current_dword_address ;`
369	2	mihad
370			`// DWORD address counter with load`
371			`always@(posedge reset_in or posedge clk_in)`
372			`begin`
373			`if (reset_in)`
374			current_dword_address <= #`FF_DELAY 30'h0000_0000 ;
375			`else`
376			`if (address_change)`
377			current_dword_address <= #`FF_DELAY new_address[31:2] ;
378			`else`
379			`if (addr_count_en)`
380			current_dword_address <= #`FF_DELAY current_dword_address + 1'b1 ;
381	21	mihad	`end`
382	2	mihad
383			`reg [1:0] current_byte_address ;`
384			`always@(posedge reset_in or posedge clk_in)`
385			`begin`
386			`if (reset_in)`
387			current_byte_address <= #`FF_DELAY 2'b00 ;
388			`else`
389			`if (address_change)`
390			current_byte_address <= #`FF_DELAY new_address[1:0] ;
391	21	mihad	`end`
392	2	mihad
393			`// address output to PCI master state machine assignement`
394			`assign address_out = { current_dword_address, current_byte_address } ;`
395
396			`// the same for erroneous address assignement`
397			`assign err_addr_out = { current_dword_address, current_byte_address } ;`
398
399			`// cacheline size counter - for read transaction length control`
400			`// cache line count is enabled during burst reads when data is actually transfered`
401			`wire read_count_enable = ~wait_in && del_read_req && del_burst_in && wtransfer_in ;`
402
403			`// cache line counter is loaded when del read request is not in progress`
404	21	mihad	`wire read_count_load = ~del_read_req ;`
405	2	mihad
406	21	mihad	reg [(`WBR_ADDR_LENGTH - 1):0] max_read_count ;
407	2	mihad	`always@(cache_line_size_in or del_bc_in)`
408			`begin`
409			if ( (cache_line_size_in >= `WBR_DEPTH) \|\| (~del_bc_in[1] && ~del_bc_in[0]) )
410			max_read_count = `WBR_DEPTH - 1'b1;
411			`else`
412			`max_read_count = cache_line_size_in ;`
413			`end`
414
415	21	mihad	reg [(`WBR_ADDR_LENGTH - 1):0] read_count ;
416	2	mihad
417			`// cache line bound indicator - it signals when data for one complete cacheline was read`
418	21	mihad	wire read_bound_comb = ~\|(read_count[(`WBR_ADDR_LENGTH - 1):2]) ;
419	2	mihad	`reg read_bound ;`
420	21	mihad	`always@(posedge clk_in or posedge reset_in)`
421	2	mihad	`begin`
422	21	mihad	`if ( reset_in )`
423	2	mihad	read_bound <= #`FF_DELAY 1'b0 ;
424	21	mihad	`else if (read_count_load)`
425			read_bound <= #`FF_DELAY 1'b0 ;
426	2	mihad	`else if ( read_count_enable )`
427			read_bound <= #`FF_DELAY read_bound_comb ;
428			`end`
429
430			`// down counter with load`
431			`always@(posedge reset_in or posedge clk_in)`
432			`begin`
433			`if (reset_in)`
434	21	mihad	read_count <= #`FF_DELAY 0 ;
435	2	mihad	`else`
436			`if (read_count_load)`
437			read_count <= #`FF_DELAY max_read_count ;
438			`else`
439			`if (read_count_enable)`
440			read_count <= #`FF_DELAY read_count - 1'b1 ;
441	21	mihad
442	2	mihad	`end`
443
444			`// flip flop indicating error recovery is in progress`
445			`reg err_recovery_in ;`
446			`always@(posedge reset_in or posedge clk_in)`
447			`begin`
448			`if (reset_in)`
449			err_recovery <= #`FF_DELAY 1'b0 ;
450			`else`
451			err_recovery <= #`FF_DELAY err_recovery_in ;
452			`end`
453
454			`/*// retry counter implementation`
455			`reg [7:0] retry_count ;`
456
457			`wire retry_expired = ~\|(retry_count[7:1]) ;`
458
459			`// loading of retry counter - whenever no request is present or other termination than retry or wait is signalled`
460			`wire retry_load = ~req_out \|\| (~wait_in && rtransfer_in) ;`
461
462			`// retry DOWN counter with load`
463			`always@(posedge reset_in or posedge clk_in)`
464			`begin`
465			`if (reset_in)`
466			retry_count <= #`FF_DELAY 8'hFF ;
467			`else`
468			`if ( retry_load )`
469			retry_count <= #`FF_DELAY `PCI_RTY_CNT_MAX ;
470			`else`
471			`if (retry_in)`
472			retry_count <= #`FF_DELAY retry_count - 1'b1 ;
473			`end*/`
474
475			`/*==================================================================================================================`
476			`Delayed write requests are always single transfers!`
477			`Delayed write request starts, when no request is currently beeing processed and it is signaled from other side`
478			`of the bridge.`
479			`==================================================================================================================*/`
480			`// delayed write request FF input control`
481			`reg del_write_req_input ;`
482
483			`always@(`
484	21	mihad	`do_del_write or`
485			`del_write_req or`
486			`posted_write_req or`
487			`del_read_req or`
488			`wait_in or`
489			`//retry_in or`
490	2	mihad	`//retry_expired or`
491			`rtransfer_in or`
492			`rerror_in or`
493			`mabort_in`
494			`)`
495			`begin`
496			`if (~del_write_req)`
497	21	mihad	`begin`
498	2	mihad	`// delayed write is not in progress and is requested`
499			`// delayed write can be requested when no other request is in progress`
500			`del_write_req_input = ~posted_write_req && ~del_read_req && do_del_write ;`

Browse

Tools

Subversion Repositories pci

[/] [pci/] [tags/] [rel_6/] [rtl/] [verilog/] [pci_master32_sm_if.v] - Blame information for rev 77