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

Subversion Repositories mem_ctrl

[/] [mem_ctrl/] [trunk/] [rtl/] [verilog/] [mc_timing.v] - Blame information for rev 16

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


/////////////////////////////////////////////////////////////////////
////                                                             ////
////  WISHBONE Memory Controller Main Timing Block               ////
////                                                             ////
////                                                             ////
////  Author: Rudolf Usselmann                                   ////
////          rudi@asics.ws                                      ////
////                                                             ////
////                                                             ////
////  Downloaded from: http://www.opencores.org/cores/mem_ctrl/  ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
////                                                             ////
//// Copyright (C) 2000 Rudolf Usselmann                         ////
////                    rudi@asics.ws                            ////
////                                                             ////
//// 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 SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY     ////
//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   ////
//// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS   ////
//// FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR      ////
//// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,         ////
//// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    ////
//// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE   ////
//// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR        ////
//// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF  ////
//// LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT  ////
//// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT  ////
//// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE         ////
//// POSSIBILITY OF SUCH DAMAGE.                                 ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
 
//  CVS Log
//
//  $Id: mc_timing.v,v 1.5 2001-11-29 02:16:28 rudi Exp $
//
//  $Date: 2001-11-29 02:16:28 $
//  $Revision: 1.5 $
//  $Author: rudi $
//  $Locker:  $
//  $State: Exp $
//
// Change History:
//               $Log: not supported by cvs2svn $
//               Revision 1.4  2001/09/24 00:38:21  rudi
//
//               Changed Reset to be active high and async.
//
//               Revision 1.3  2001/09/02 02:28:28  rudi
//
//               Many fixes for minor bugs that showed up in gate level simulations.
//
//               Revision 1.2  2001/08/10 08:16:21  rudi
//
//               - Changed IO names to be more clear.
//               - Uniquifyed define names to be core specific.
//               - Removed "Refresh Early" configuration
//
//               Revision 1.1  2001/07/29 07:34:41  rudi
//
//
//               1) Changed Directory Structure
//               2) Fixed several minor bugs
//
//               Revision 1.4  2001/06/14 01:57:37  rudi
//
//
//               Fixed a potential bug in a corner case situation where the TMS register
//               does not propegate properly during initialisation.
//
//               Revision 1.3  2001/06/12 15:19:49  rudi
//
//
//               Minor changes after running lint, and a small bug fix reading csr and ba_mask registers.
//
//               Revision 1.2  2001/06/03 11:37:17  rudi
//
//
//               1) Fixed Chip Select Mask Register
//                      - Power On Value is now all ones
//                      - Comparison Logic is now correct
//
//               2) All resets are now asynchronous
//
//               3) Converted Power On Delay to an configurable item
//
//               4) Added reset to Chip Select Output Registers
//
//               5) Forcing all outputs to Hi-Z state during reset
//
//               Revision 1.1.1.1  2001/05/13 09:39:44  rudi
//               Created Directory Structure
//
//
//
//
 
`include "mc_defines.v"
 
module mc_timing(clk, rst,
 
                // Wishbone Interface
                wb_cyc_i, wb_stb_i, wb_we_i,
                wb_read_go, wb_write_go, wb_first, wb_wait, mem_ack,
                err,
 
                // Suspend/Resume Interface
                susp_req, resume_req, suspended, susp_sel,
 
                // Memory Interface
                mc_clk, data_oe, oe_, we_, cas_, ras_, cke_,
                cs_en, wb_cycle, wr_cycle,
                mc_br, mc_bg, mc_adsc, mc_adv,
                mc_c_oe, mc_ack,
 
                // Register File Interface
                csc, tms, cs, lmr_req, lmr_ack, cs_le,
 
                // Address Select Signals
                cmd_a10, row_sel, next_adr, page_size,
 
                // OBCT Signals
                bank_set, bank_clr, bank_clr_all, bank_open, any_bank_open, row_same,
 
                // Data path Controller Signals
                dv, pack_le0, pack_le1, pack_le2, par_err,
 
                // Refresh Counter Signals
                rfr_req, rfr_ack,
 
                // Initialize Request & Ack
                init_req, init_ack
                );
 
input           clk;
input           rst;
 
// Wishbone Interface
input           wb_cyc_i, wb_stb_i, wb_we_i;
input           wb_read_go;
input           wb_write_go;
input           wb_first;
input           wb_wait;
output          mem_ack;
output          err;
 
// Suspend/Resume Interface
input           susp_req;
input           resume_req;
output          suspended;
output          susp_sel;
 
// Memory Interface
input           mc_clk;
output          data_oe;
output          oe_;
output          we_;
output          cas_;
output          ras_;
output          cke_;
output          cs_en;
output          wb_cycle;
output          wr_cycle;
input           mc_br;
output          mc_bg;
output          mc_adsc;
output          mc_adv;
output          mc_c_oe;
input           mc_ack;
 
// Register File Interface
input   [31:0]   csc;
input   [31:0]   tms;
input   [7:0]    cs;
input           lmr_req;
output          lmr_ack;
output          cs_le;
 
// Address Select Signals
input   [10:0]   page_size;
output          cmd_a10;
output          row_sel;
output          next_adr;
 
// OBCT Signals
output          bank_set;
output          bank_clr;
output          bank_clr_all;
input           bank_open;
input           any_bank_open;
input           row_same;
 
// Data path Controller Signals
output          dv;
output          pack_le0, pack_le1, pack_le2;   // Pack Latch Enable
input           par_err;
 
// Refresh Counter Signals
input           rfr_req;
output          rfr_ack;
 
// Initialize Request & Ack
input           init_req;
output          init_ack;
 
////////////////////////////////////////////////////////////////////
//
// Defines & Parameters
//
 
// Number of states: 66
parameter       [65:0]   // synopsys enum state
//                   6666666555555555544444444443333333333222222222211111111110000000000
//                   6543210987654321098765432109876543210987654321098765432109876543210
POR             = 66'b000000000000000000000000000000000000000000000000000000000000000001,
IDLE            = 66'b000000000000000000000000000000000000000000000000000000000000000010,
IDLE_T          = 66'b000000000000000000000000000000000000000000000000000000000000000100,
IDLE_T2         = 66'b000000000000000000000000000000000000000000000000000000000000001000,
PRECHARGE       = 66'b000000000000000000000000000000000000000000000000000000000000010000,
PRECHARGE_W     = 66'b000000000000000000000000000000000000000000000000000000000000100000,
ACTIVATE        = 66'b000000000000000000000000000000000000000000000000000000000001000000,
ACTIVATE_W      = 66'b000000000000000000000000000000000000000000000000000000000010000000,
SD_RD_WR        = 66'b000000000000000000000000000000000000000000000000000000000100000000,
SD_RD           = 66'b000000000000000000000000000000000000000000000000000000001000000000,
SD_RD_W         = 66'b000000000000000000000000000000000000000000000000000000010000000000,
SD_RD_LOOP      = 66'b000000000000000000000000000000000000000000000000000000100000000000,
SD_RD_W2        = 66'b000000000000000000000000000000000000000000000000000001000000000000,
SD_WR           = 66'b000000000000000000000000000000000000000000000000000010000000000000,
SD_WR_W         = 66'b000000000000000000000000000000000000000000000000000100000000000000,
BT              = 66'b000000000000000000000000000000000000000000000000001000000000000000,
BT_W            = 66'b000000000000000000000000000000000000000000000000010000000000000000,
REFR            = 66'b000000000000000000000000000000000000000000000000100000000000000000,
LMR0            = 66'b000000000000000000000000000000000000000000000001000000000000000000,
LMR1            = 66'b000000000000000000000000000000000000000000000010000000000000000000,
LMR2            = 66'b000000000000000000000000000000000000000000000100000000000000000000,
INIT0           = 66'b000000000000000000000000000000000000000000001000000000000000000000,
INIT            = 66'b000000000000000000000000000000000000000000010000000000000000000000,
INIT_W          = 66'b000000000000000000000000000000000000000000100000000000000000000000,
INIT_REFR1      = 66'b000000000000000000000000000000000000000001000000000000000000000000,
INIT_REFR1_W    = 66'b000000000000000000000000000000000000000010000000000000000000000000,
INIT_LMR        = 66'b000000000000000000000000000000000000000100000000000000000000000000,
SUSP1           = 66'b000000000000000000000000000000000000001000000000000000000000000000,
SUSP2           = 66'b000000000000000000000000000000000000010000000000000000000000000000,
SUSP3           = 66'b000000000000000000000000000000000000100000000000000000000000000000,
SUSP4           = 66'b000000000000000000000000000000000001000000000000000000000000000000,
RESUME1         = 66'b000000000000000000000000000000000010000000000000000000000000000000,
RESUME2         = 66'b000000000000000000000000000000000100000000000000000000000000000000,
BG0             = 66'b000000000000000000000000000000001000000000000000000000000000000000,
BG1             = 66'b000000000000000000000000000000010000000000000000000000000000000000,
BG2             = 66'b000000000000000000000000000000100000000000000000000000000000000000,
ACS_RD          = 66'b000000000000000000000000000001000000000000000000000000000000000000,
ACS_RD1         = 66'b000000000000000000000000000010000000000000000000000000000000000000,
ACS_RD2A        = 66'b000000000000000000000000000100000000000000000000000000000000000000,
ACS_RD2         = 66'b000000000000000000000000001000000000000000000000000000000000000000,
ACS_RD3         = 66'b000000000000000000000000010000000000000000000000000000000000000000,
ACS_RD_8_1      = 66'b000000000000000000000000100000000000000000000000000000000000000000,
ACS_RD_8_2      = 66'b000000000000000000000001000000000000000000000000000000000000000000,
ACS_RD_8_3      = 66'b000000000000000000000010000000000000000000000000000000000000000000,
ACS_RD_8_4      = 66'b000000000000000000000100000000000000000000000000000000000000000000,
ACS_RD_8_5      = 66'b000000000000000000001000000000000000000000000000000000000000000000,
ACS_RD_8_6      = 66'b000000000000000000010000000000000000000000000000000000000000000000,
ACS_WR          = 66'b000000000000000000100000000000000000000000000000000000000000000000,
ACS_WR1         = 66'b000000000000000001000000000000000000000000000000000000000000000000,
ACS_WR2         = 66'b000000000000000010000000000000000000000000000000000000000000000000,
ACS_WR3         = 66'b000000000000000100000000000000000000000000000000000000000000000000,
ACS_WR4         = 66'b000000000000001000000000000000000000000000000000000000000000000000,
SRAM_RD         = 66'b000000000000010000000000000000000000000000000000000000000000000000,
SRAM_RD0        = 66'b000000000000100000000000000000000000000000000000000000000000000000,
SRAM_RD1        = 66'b000000000001000000000000000000000000000000000000000000000000000000,
SRAM_RD2        = 66'b000000000010000000000000000000000000000000000000000000000000000000,
SRAM_RD3        = 66'b000000000100000000000000000000000000000000000000000000000000000000,
SRAM_RD4        = 66'b000000001000000000000000000000000000000000000000000000000000000000,
SRAM_WR         = 66'b000000010000000000000000000000000000000000000000000000000000000000,
SRAM_WR0        = 66'b000000100000000000000000000000000000000000000000000000000000000000,
SCS_RD          = 66'b000001000000000000000000000000000000000000000000000000000000000000,
SCS_RD1         = 66'b000010000000000000000000000000000000000000000000000000000000000000,
SCS_RD2         = 66'b000100000000000000000000000000000000000000000000000000000000000000,
SCS_WR          = 66'b001000000000000000000000000000000000000000000000000000000000000000,
SCS_WR1         = 66'b010000000000000000000000000000000000000000000000000000000000000000,
SCS_ERR         = 66'b100000000000000000000000000000000000000000000000000000000000000000;
 
////////////////////////////////////////////////////////////////////
//
// Local Registers & Wires
//
 
reg     [65:0]   /* synopsys enum state */ state, next_state;
// synopsys state_vector state
 
reg             mc_bg;
 
wire    [2:0]    mem_type;
wire    [1:0]    bus_width;
wire            kro;
 
wire            cs_a;
reg     [3:0]    cmd;
 
wire            mem_ack;
wire            mem_ack_s;
reg             mem_ack_d;
reg             err_d;
wire            err;
reg             cmd_a10;
reg             lmr_ack;
reg             row_sel;
reg             oe_;
reg             oe_d;
reg             data_oe;
reg             data_oe_d;
reg             cke_d;
reg             cke_;
reg             init_ack;
reg             dv;
reg             rfr_ack;
reg             mc_adsc;
reg             mc_adv;
 
reg             bank_set;
reg             bank_clr;
reg             bank_clr_all;
 
reg             wr_set, wr_clr;
reg             wr_cycle;
 
reg             cmd_asserted;
reg             cmd_asserted2;
 
reg     [10:0]   burst_val;
reg     [10:0]   burst_cnt;
wire            burst_act;
reg             burst_act_rd;
wire            single_write;
 
reg             cs_le_d;
reg             cs_le;
reg             cs_le_r;
 
reg             susp_req_r;
reg             resume_req_r;
reg             suspended;
reg             suspended_d;
reg             susp_sel_set, susp_sel_clr, susp_sel_r;
 
reg     [3:0]    cmd_del;
reg     [3:0]    cmd_r;
reg             data_oe_r;
reg             data_oe_r2;
reg             cke_r;
reg             cke_rd;
reg             cke_o_del;
reg             cke_o_r1;
reg             cke_o_r2;
reg             wb_cycle_set, wb_cycle;
reg     [3:0]    ack_cnt;
wire            ack_cnt_is_0;
reg             cnt, cnt_next;
reg     [7:0]    timer;
reg             tmr_ld_trp, tmr_ld_trcd, tmr_ld_tcl, tmr_ld_trfc;
reg             tmr_ld_twr, tmr_ld_txsr;
reg             tmr2_ld_tscsto;
reg             tmr_ld_trdv;
reg             tmr_ld_trdz;
reg             tmr_ld_twr2;
wire            timer_is_zero;
reg             tmr_done;
reg             tmr2_ld_trdv, tmr2_ld_trdz;
reg             tmr2_ld_twpw, tmr2_ld_twd, tmr2_ld_twwd;
reg             tmr2_ld_tsrdv;
reg     [8:0]    timer2;
reg             tmr2_done;
wire            timer2_is_zero;
reg     [3:0]    ir_cnt;
reg             ir_cnt_ld;
reg             ir_cnt_dec;
reg             ir_cnt_done;
reg             rfr_ack_r;
reg             burst_cnt_ld;
reg             burst_fp;
reg             wb_wait_r, wb_wait_r2;
reg             lookup_ready1, lookup_ready2;
reg             burst_cnt_ld_4;
reg             dv_r;
reg             mc_adv_r1, mc_adv_r;
 
reg             next_adr;
reg             pack_le0, pack_le1, pack_le2;
reg             pack_le0_d, pack_le1_d, pack_le2_d;
wire            bw8, bw16;
 
reg             mc_c_oe_d;
reg             mc_c_oe;
 
reg             mc_le;
reg             mem_ack_r;
 
reg             rsts, rsts1;
reg             no_wb_cycle;
 
wire            bc_dec;
reg             ap_en;  // Auto Precharge Enable
reg             cmd_a10_r;
reg             wb_stb_first;
reg             tmr_ld_tavav;
 
////////////////////////////////////////////////////////////////////
//
// Aliases
//
assign mem_type  = csc[3:1];
assign bus_width = csc[5:4];
assign kro       = csc[10];
assign single_write = tms[9] | (tms[2:0] == 3'h0);
 
////////////////////////////////////////////////////////////////////
//
// Misc Logic
//
reg             cs_le_r1;
 
always @(posedge clk)
        cs_le_r <= #1 cs_le_r1;
 
always @(posedge clk)
        cs_le_r1 <= #1 cs_le;
 
always @(posedge clk)
        cs_le <= #1 cs_le_d;
 
always @(posedge mc_clk)
        rsts1 <= #1 rst;
 
always @(posedge clk)
        rsts <= #1 rsts1;
 
// Control Signals Output Enable
always @(posedge clk or posedge rst)
        if(rst)         mc_c_oe <= #1 1'b0;
        else            mc_c_oe <= #1 mc_c_oe_d;
 
always @(posedge clk or posedge rsts)
        if(rsts)        mc_le <= #1 1'b0;
        else            mc_le <= #1 ~mc_le;
 
always @(posedge clk)
        pack_le0 <= #1 pack_le0_d;
 
always @(posedge clk)
        pack_le1 <= #1 pack_le1_d;
 
always @(posedge clk)
        pack_le2 <= #1 pack_le2_d;
 
always @(posedge clk)
        if(!mc_le)      mc_adv_r1 <= #1 mc_adv;
 
always @(posedge clk)
        if(!mc_le)      mc_adv_r <= #1 mc_adv_r1;
 
// Bus Width decoder
assign bw8  = (bus_width == `MC_BW_8);
assign bw16 = (bus_width == `MC_BW_16);
 
// Any Chip Select
assign cs_a = |cs;
 
// Memory to Wishbone Ack
assign  mem_ack = (mem_ack_d | mem_ack_s) & (wb_read_go | wb_write_go);
 
always @(posedge clk)
        mem_ack_r <= #1 mem_ack;
 
assign  err = err_d;
 
// SDRAM Command, either delayed (for writes) or straight through
always @(posedge clk)
        cmd_r <= #1 cmd;
 
always @(posedge clk)
        cmd_del <= #1 cmd_r;
 
assign {cs_en, ras_, cas_, we_} = wr_cycle ? cmd_del : cmd;
 
// Track Timing of Asserting a command
always @(posedge clk)
        if(!mc_le)      cmd_asserted <= #1 cmd[3];
 
always @(posedge clk)
        if(!mc_le)      cmd_asserted2 <= #1 cmd_asserted;
 
// Output Enable
always @(posedge clk)
        oe_ <= #1 ~oe_d;
 
// Memory Bus Data lines Output Enable
always @(posedge clk)
        data_oe_r <= #1 data_oe_d;
 
always @(posedge clk)
        data_oe_r2 <= #1 data_oe_r;
 
always @(posedge clk)
        data_oe <= #1 wr_cycle ? data_oe_r2 : data_oe_d;
 
// Clock Enable
always @(posedge clk)
        cke_r <= #1 cke_d;
 
always @(posedge clk)
        cke_ <= #1 cke_r & cke_rd;
 
// CKE output delay line to time DV for reads
always @(posedge clk)
        cke_o_r1 <= #1 cke_;
 
always @(posedge clk)
        cke_o_r2 <= #1 cke_o_r1;
 
always @(posedge clk)
        cke_o_del <= #1 cke_o_r2;
 
// Delayed version of the wb_wait input
always @(posedge clk)
        wb_wait_r2 <= #1 wb_wait;
 
always @(posedge clk)
        wb_wait_r <= #1 wb_wait_r2;
 
// Indicates when the row_same and bank_open lookups are done
always @(posedge clk)
        lookup_ready1 <= #1 cs_le & wb_stb_i;
 
always @(posedge clk)
        lookup_ready2 <= #1 lookup_ready1 & wb_stb_i;
 
// Keep Track if it is a SDRAM write cycle
always @(posedge clk or posedge rst)
        if(rst)         wr_cycle <= #1 1'b0;
        else
        if(wr_set)      wr_cycle <= #1 1'b1;
        else
        if(wr_clr)      wr_cycle <= #1 1'b0;
 
// Track when a cycle is *still* active
always @(posedge clk or posedge rst)
        if(rst)                         wb_cycle <= #1 1'b0;
        else
        if(wb_cycle_set)                wb_cycle <= #1 1'b1;
        else
        if(!wb_cyc_i)                   wb_cycle <= #1 1'b0;
 
// Thses two signals are used to signal that no wishbone cycle is in
// progress. Need to register them to avoid a very long combinatorial
// path ....
always @(posedge clk)
        no_wb_cycle <= #1 !wb_read_go & !wb_write_go;
 
// Track ack's for read cycles 
always @(posedge clk or posedge rst)
        if(rst)                                 ack_cnt <= #1 4'h0;
        else
        if(no_wb_cycle)                         ack_cnt <= #1 4'h0;
        else
        if(dv & !mem_ack_s)                     ack_cnt <= #1 ack_cnt + 4'h1;
        else
        if(!dv & mem_ack_s)                     ack_cnt <= #1 ack_cnt - 4'h1;
 
assign ack_cnt_is_0 = (ack_cnt==4'h0);
 
assign mem_ack_s = (ack_cnt != 4'h0) & !wb_wait & !mem_ack_r & wb_read_go & !(wb_we_i & wb_stb_i);
 
// Internal Cycle Tracker
always @(posedge clk)
        cnt <= #1 cnt_next;
 
// Suspend/resume Logic
always @(posedge clk)
        susp_req_r <= #1 susp_req;
 
always @(posedge clk)
        resume_req_r <= #1 resume_req;
 
always @(posedge clk)
        suspended <= #1 suspended_d;
 
always @(posedge clk)
        rfr_ack_r <= #1 rfr_ack;
 
// Suspend Select Logic
assign susp_sel = susp_sel_r | susp_sel_set;
 
always @(posedge clk or posedge rst)
        if(rst)                 susp_sel_r <= #1 0;
        else
        if(susp_sel_set)        susp_sel_r <= #1 1'b1;
        else
        if(susp_sel_clr)        susp_sel_r <= #1 1'b0;
 
////////////////////////////////////////////////////////////////////
//
// Timing Logic
//
wire    [3:0]    twrp;
wire            twd_is_zero;
wire    [31:0]   tms_x;
 
// FIX_ME
// Hard wire worst case or make it programmable ???
assign tms_x = (rfr_ack | rfr_ack_r | susp_sel | !mc_c_oe) ? 32'hffff_ffff : tms;
 
always @(posedge clk)
        if(tmr2_ld_tscsto)      timer2 <= #1 tms_x[24:16];
        else
        if(tmr2_ld_tsrdv)       timer2 <= #1 9'd4;      // SSRAM RD->1st DATA VALID
        else
        if(tmr2_ld_twpw)        timer2 <= #1 { 5'h0, tms_x[15:12]};
        else
        if(tmr2_ld_twd)         timer2 <= #1 { 4'h0, tms_x[19:16],1'b0};
        else
        if(tmr2_ld_twwd)        timer2 <= #1 { 3'h0, tms_x[25:20]};
        else
        if(tmr2_ld_trdz)        timer2 <= #1 { 4'h0, tms_x[11:8], 1'b1};
        else
        if(tmr2_ld_trdv)        timer2 <= #1 { tms_x[7:0], 1'b1};
        else
        if(!timer2_is_zero)     timer2 <= #1 timer2 - 9'b1;
 
assign twd_is_zero =  (tms_x[19:16] == 4'h0);
 
assign timer2_is_zero = (timer2 == 9'h0);
 
always @(posedge clk)
        tmr2_done <= #1 timer2_is_zero & !tmr2_ld_trdv & !tmr2_ld_trdz &
                        !tmr2_ld_twpw & !tmr2_ld_twd & !tmr2_ld_twwd & !tmr2_ld_tscsto;
 
assign twrp = {2'h0,tms_x[16:15]} + tms_x[23:20];
 
// SDRAM Memories timing tracker
always @(posedge clk or posedge rst)
`ifdef MC_POR_DELAY
        if(rst)                 timer <= #1 `MC_POR_DELAY_VAL ;
        else
`endif
        if(tmr_ld_twr2)         timer <= #1 { 4'h0, tms_x[15:12] };
        else
        if(tmr_ld_trdz)         timer <= #1 { 4'h0, tms_x[11:8] };
        else
        if(tmr_ld_trdv)         timer <= #1 tms_x[7:0];
        else
        if(tmr_ld_twr)          timer <= #1 { 4'h0, twrp};
        else
        if(tmr_ld_trp)          timer <= #1 { 4'h0, tms_x[23:20]};
        else
        if(tmr_ld_trcd)         timer <= #1 { 5'h0, tms_x[19:17]};
        else
        if(tmr_ld_tcl)          timer <= #1 { 6'h0, tms_x[05:04]};
        else
        if(tmr_ld_trfc)         timer <= #1 { 4'h0, tms_x[27:24]};
        else
        if(tmr_ld_tavav)        timer <= #1 8'h3;
        else
        if(tmr_ld_txsr)         timer <= #1 8'h7;
        else
        if(!timer_is_zero & !mc_le)     timer <= #1 timer - 8'b1;
 
assign timer_is_zero = (timer == 8'h0);
 
always @(posedge clk)
        tmr_done <= #1 timer_is_zero;
 
// Init Refresh Cycles Counter
always @(posedge clk)
        if(ir_cnt_ld)   ir_cnt <= #1 `MC_INIT_RFRC_CNT;
        else
        if(ir_cnt_dec)  ir_cnt <= #1 ir_cnt - 4'b1;
 
always @(posedge clk)
        ir_cnt_done <= #1 (ir_cnt == 4'h0);
 
// Burst Counter
always @(tms_x or page_size)
        case(tms_x[2:0])         // synopsys full_case parallel_case
           3'h0: burst_val = 11'h1;
           3'h1: burst_val = 11'h2;
           3'h2: burst_val = 11'h4;
           3'h3: burst_val = 11'h8;
           3'h7: burst_val = page_size;
        endcase
 
assign bc_dec = wr_cycle ? mem_ack_d : dv;
 
always @(posedge clk)
        if(burst_cnt_ld_4)      burst_cnt <= #1 11'h4; // for SSRAM only
        else
        if(burst_cnt_ld)        burst_cnt <= #1 burst_val;
        else
        if(bc_dec)              burst_cnt <= #1 burst_cnt - 11'h1;
 
always @(posedge clk)
        if(burst_cnt_ld)        burst_fp <= #1 (tms_x[2:0] == 3'h7);
 
// Auto Precharge Enable
always @(posedge clk)
        if(burst_cnt_ld)        ap_en <= #1 (tms_x[2:0] == 3'h0) & !kro;
 
assign burst_act = |burst_cnt & ( |tms_x[2:0] );
 
always @(posedge clk)
        burst_act_rd <= #1 |burst_cnt;
 
always @(posedge clk)
        dv_r <= #1 dv;
 
always @(posedge clk)   // Auto Precharge Holding Register
        cmd_a10_r <= #1 cmd_a10;
 
////////////////////////////////////////////////////////////////////
//
// Main State Machine
//
reg             wb_write_go_r;
 
always @(posedge clk)
        wb_write_go_r <= #1 wb_write_go;
 
 
always @(posedge clk or posedge rst)
        if(rst)                 wb_stb_first <= #1 1'b0;
        else
        if(mem_ack)             wb_stb_first <= #1 1'b0;
        else
        if(wb_first & wb_stb_i) wb_stb_first <= #1 1'b1;
 
always @(posedge clk or posedge rst)
`ifdef MC_POR_DELAY
        if(rst)         state <= #1 POR;
`else
        if(rst)         state <= #1 IDLE;
`endif
        else            state <= #1 next_state;
 
always @(state or cs_a or cs_le or cs_le_r or
        twd_is_zero or wb_stb_i or wb_write_go_r or
        wb_first or wb_read_go or wb_write_go or wb_wait or mem_ack_r or wb_we_i or
        ack_cnt_is_0 or wb_wait_r or cnt or wb_cycle or wr_cycle or
        mem_type or kro or lookup_ready2 or row_same or cmd_a10_r or
        bank_open or single_write or
        cmd_asserted or tmr_done or tmr2_done or ir_cnt_done or cmd_asserted2 or
        burst_act or burst_act_rd or burst_fp or cke_ or cke_r or cke_o_del or
        rfr_req or lmr_req or init_req or rfr_ack_r or susp_req_r or resume_req_r or
        mc_br or bw8 or bw16 or dv_r or mc_adv_r or mc_ack or wb_stb_first or ap_en
        )
   begin
        next_state = state;     // Default keep current state
        cnt_next = 1'b0;
 
        cmd = `MC_CMD_NOP;
        cmd_a10 = ap_en;
        oe_d = 1'b0;
        data_oe_d = 1'b0;
        cke_d = 1'b1;
        cke_rd = 1'b1;
        mc_adsc = 1'b0;
        mc_adv = 1'b0;
 
        bank_set = 1'b0;
        bank_clr = 1'b0;
        bank_clr_all = 1'b0;
 
        burst_cnt_ld = 1'b0;
        burst_cnt_ld_4 = 1'b0;
        tmr_ld_trp = 1'b0;
        tmr_ld_trcd = 1'b0;
        tmr_ld_tcl = 1'b0;
        tmr_ld_trfc = 1'b0;
        tmr_ld_twr = 1'b0;
        tmr_ld_txsr = 1'b0;
        tmr_ld_trdv = 1'b0;
        tmr_ld_trdz = 1'b0;
        tmr_ld_twr2 = 1'b0;
        tmr_ld_tavav = 1'b0;
 
        tmr2_ld_trdv = 1'b0;
        tmr2_ld_trdz = 1'b0;
 
        tmr2_ld_twpw = 1'b0;
        tmr2_ld_twd = 1'b0;
        tmr2_ld_twwd = 1'b0;
        tmr2_ld_tsrdv = 1'b0;
        tmr2_ld_tscsto = 1'b0;
 
        mem_ack_d = 1'b0;
        err_d = 1'b0;
        rfr_ack = 1'b0;
        lmr_ack = 1'b0;
        init_ack = 1'b0;
 
        ir_cnt_dec = 1'b0;
        ir_cnt_ld = 1'b0;
 
        row_sel = 1'b0;
        cs_le_d = 1'b0;
        wr_clr = 1'b0;
        wr_set = 1'b0;
        wb_cycle_set = 1'b0;
        dv = 1'b0;
 
        suspended_d = 1'b0;
        susp_sel_set = 1'b0;
        susp_sel_clr = 1'b0;
        mc_bg = 1'b0;
 
        next_adr = 1'b0;
        pack_le0_d = 1'b0;
        pack_le1_d = 1'b0;
        pack_le2_d = 1'b0;
 
        mc_c_oe_d = 1'b1;
 
        case(state)             // synopsys full_case parallel_case
`ifdef MC_POR_DELAY
           POR:
              begin
                if(tmr_done)    next_state = IDLE;
              end
`endif
           IDLE:
              begin
                cs_le_d = wb_stb_first | lmr_req;
                burst_cnt_ld = 1'b1;
                wr_clr = 1'b1;
 
                if(mem_type == `MC_MEM_TYPE_SCS)        tmr2_ld_tscsto = 1'b1;
                if(mem_type == `MC_MEM_TYPE_SRAM)       tmr2_ld_tsrdv = 1'b1;
 
 
                if(rfr_req)
                   begin
                        rfr_ack = 1'b1;
                        next_state = PRECHARGE;
                   end
                else
                if(init_req)
                   begin
                        cs_le_d = 1'b1;
                        next_state = INIT0;
                   end
                else
                if(lmr_req & lookup_ready2)
                   begin
                        lmr_ack = 1'b1;
                        cs_le_d = 1'b1;
                        next_state = LMR0;
                   end
                else
                if(susp_req_r & !wb_cycle)
                   begin
                        cs_le_d = 1'b1;
                        susp_sel_set = 1'b1;
                        next_state = SUSP1;
                   end
                else
                if(cs_a & (wb_read_go | wb_write_go) & lookup_ready2)
                  begin
                   wb_cycle_set = 1'b1;
                   case(mem_type)               // synopsys full_case parallel_case
                     `MC_MEM_TYPE_SDRAM:                // SDRAM
                        if((lookup_ready2) & !wb_wait)
                           begin
                                if(wb_write_go | (wb_we_i & wb_stb_i))  wr_set = 1'b1;
                                if(kro & bank_open & row_same)  next_state = SD_RD_WR;
                                else
                                if(kro & bank_open)             next_state = PRECHARGE;
                                else                            next_state = ACTIVATE;
                           end
                     `MC_MEM_TYPE_ACS:
                        begin                           // Async Chip Select
                                if(!wb_wait)
                                   begin
                                        cs_le_d = 1'b1;
                                        if(wb_write_go)
                                           begin
                                                        data_oe_d = 1'b1;
                                                        next_state = ACS_WR;
                                           end
                                        else            next_state = ACS_RD;
                                   end
                        end
                     `MC_MEM_TYPE_SCS:
                        begin                           // Sync Chip Select
                                if(!wb_wait)
                                   begin
                                        cs_le_d = 1'b1;
                                        if(wb_write_go)
                                           begin
                                                cmd = `MC_CMD_XWR;
                                                data_oe_d = 1'b1;
                                                tmr_ld_twr2 = 1'b1;
                                                next_state = SCS_WR;
                                           end
                                        else
                                           begin
                                                cmd = `MC_CMD_XRD;
                                                oe_d = 1'b1;
                                                tmr_ld_trdv = 1'b1;
                                                next_state = SCS_RD;
                                           end
                                   end
                        end
                     `MC_MEM_TYPE_SRAM:
                        begin           // SRAM
                                if(!wb_wait)
                                   begin
                                        cs_le_d = 1'b1;
                                        if(wb_write_go)
                                           begin
                                                data_oe_d = 1'b1;
                                                mem_ack_d = 1'b1;
                                                next_state = SRAM_WR;
                                           end
                                        else
                                           begin
                                                cmd = `MC_CMD_XRD;
                                                oe_d = 1'b1;
                                                mc_adsc = 1'b1;
                                                next_state = SRAM_RD;
                                           end
                                   end
                        end
                   endcase
                  end
                else
                if(mc_br)
                   begin
                        if(!cmd_asserted2)
                           begin
                                next_state = BG0;
                                mc_c_oe_d = 1'b0;
                           end
                   end
              end
 
           IDLE_T:
              begin
                cmd_a10 = cmd_a10_r;    // Hold Auto Precharge 'til cycle finishes
                if(tmr_done & wb_cycle & !wb_wait)      cs_le_d = 1'b1;
                if(tmr_done)    next_state = IDLE;
              end
 
           IDLE_T2:
              begin
                if(tmr2_done & (!wb_wait | !wb_cycle) )
                   begin
                        cs_le_d = 1'b1;
                        if(cs_le_r)     next_state = IDLE;
                   end
              end
 
                /////////////////////////////////////////
                // SCS STATES ....
                /////////////////////////////////////////
           SCS_RD:
              begin
                cmd = `MC_CMD_XRD;
                oe_d = 1'b1;
                tmr_ld_trdv = 1'b1;
                if(mc_ack)      next_state = SCS_RD1;
                else
                if(tmr2_done)   next_state = SCS_ERR;
              end
 
           SCS_RD1:
              begin
                cmd = `MC_CMD_XRD;
                oe_d = 1'b1;
                if(tmr_done)
                   begin
                        mem_ack_d = 1'b1;
                        tmr_ld_trdz = 1'b1;
                        next_state = SCS_RD2;
                   end
              end
 
           SCS_RD2:
              begin
                tmr_ld_trdz = 1'b1;
                next_state = IDLE_T;
              end
 
           SCS_WR:
              begin
                tmr_ld_twr2 = 1'b1;
                cmd = `MC_CMD_XWR;
                data_oe_d = 1'b1;
                if(mc_ack)      next_state = SCS_WR1;
                else
                if(tmr2_done)   next_state = SCS_ERR;
              end
 
           SCS_WR1:
              begin
                data_oe_d = 1'b1;
                if(tmr_done)
                   begin
                        mem_ack_d = 1'b1;
                        next_state = IDLE_T;
                   end
                else    cmd = `MC_CMD_XWR;
              end
 
           SCS_ERR:
              begin
                mem_ack_d = 1'b1;
                err_d = 1'b1;
                next_state = IDLE_T2;
              end
 
                /////////////////////////////////////////
                // SSRAM STATES ....
                /////////////////////////////////////////
           SRAM_RD:
              begin
                cmd = `MC_CMD_XRD;
                oe_d = 1'b1;
                mc_adsc = 1'b1;
                tmr2_ld_tsrdv = 1'b1;
                burst_cnt_ld_4 = 1'b1;
                if(cmd_asserted)        next_state = SRAM_RD0;
              end
 
           SRAM_RD0:
              begin
                mc_adv = 1'b1;
                oe_d = 1'b1;
                if(tmr2_done)
                   begin
                        mc_adv = !wb_wait;
                        next_state = SRAM_RD1;
                   end
              end
 
           SRAM_RD1:
              begin
                if(mc_adv_r)    dv = ~dv_r;
                mc_adv = !wb_wait;
 
                if(!burst_act | !wb_read_go)    next_state = SRAM_RD2;
                else            oe_d = 1'b1;
              end
 
           SRAM_RD2:
              begin
                if(ack_cnt_is_0 & wb_read_go)   next_state = SRAM_RD3;
                else
                if(!wb_read_go)
                   begin
                        mc_adsc = 1'b1;
                        next_state = SRAM_RD4;
                   end
              end
 
           SRAM_RD3:
              begin
                if(!wb_read_go)
                   begin
                        mc_adsc = 1'b1;
                        next_state = SRAM_RD4;
                   end
                else
                if(!wb_wait)
                   begin
                        cs_le_d = 1'b1;
                        next_state = SRAM_RD;
                   end
              end
 
           SRAM_RD4:    // DESELECT
              begin
                mc_adsc = 1'b1;
                next_state = IDLE;
              end
 
           SRAM_WR:
              begin
                cmd = `MC_CMD_XWR;
                mc_adsc = 1'b1;
                data_oe_d = 1'b1;
                if(cmd_asserted)
                   begin
                        if(wb_wait)             next_state = SRAM_WR0;
                        else
                        if(!wb_write_go)
                           begin
                                mc_adsc = 1'b1;
                                next_state = SRAM_RD4;
                           end
                        else
                           begin
                                data_oe_d = 1'b1;
                                mem_ack_d = ~mem_ack_r;
                           end
                   end
              end
 
           SRAM_WR0:
              begin
                if(wb_wait)             next_state = SRAM_WR0;
                else
                if(!wb_write_go)
                   begin
                        mc_adsc = 1'b1;
                        next_state = SRAM_RD4;
                   end
                else
                   begin
                        data_oe_d = 1'b1;
                        next_state = SRAM_WR;
                   end
              end
 
                /////////////////////////////////////////
                // Async Devices STATES ....
                /////////////////////////////////////////
           ACS_RD:
              begin
                cmd = `MC_CMD_XRD;
                oe_d = 1'b1;
                tmr2_ld_trdv = 1'b1;
                next_state = ACS_RD1;
              end
 
           ACS_RD1:
              begin     // 32 bit, 8 bit - first; 16 bit - first
                cmd = `MC_CMD_XRD;
                oe_d = 1'b1;
                if(tmr2_done)
                   begin
                        if(bw8 | bw16)          next_adr = 1'b1;
                        if(bw8)                 next_state = ACS_RD_8_1;
                        else
                        if(bw16)                next_state = ACS_RD_8_5;
                        else                    next_state = ACS_RD2A;
                   end
              end
 
           ACS_RD_8_1:
              begin     // 8 bit 2nd byte
                pack_le0_d = 1'b1;
                cmd = `MC_CMD_XRD;
                oe_d = 1'b1;
                tmr2_ld_trdv = 1'b1;
                next_state = ACS_RD_8_2;
              end
 
           ACS_RD_8_2:
              begin
                cmd = `MC_CMD_XRD;
                oe_d = 1'b1;
                if(tmr2_done)
                   begin
                        next_adr = 1'b1;
                        next_state = ACS_RD_8_3;
                   end
              end
 
           ACS_RD_8_3:
              begin     // 8 bit 3rd byte
                pack_le1_d = 1'b1;
                cmd = `MC_CMD_XRD;
                oe_d = 1'b1;
                tmr2_ld_trdv = 1'b1;
                next_state = ACS_RD_8_4;
              end
 
           ACS_RD_8_4:
              begin
                cmd = `MC_CMD_XRD;
                oe_d = 1'b1;
                if(tmr2_done)
                   begin
                        next_adr = 1'b1;
                        next_state = ACS_RD_8_5;
                   end
              end
 
           ACS_RD_8_5:
              begin     // 8 bit 4th byte; 16 bit 2nd word
                if(bw8)                 pack_le2_d = 1'b1;
                if(bw16)                pack_le0_d = 1'b1;
                cmd = `MC_CMD_XRD;
                oe_d = 1'b1;
                tmr2_ld_trdv = 1'b1;
                next_state = ACS_RD_8_6;
              end
 
           ACS_RD_8_6:
              begin
                cmd = `MC_CMD_XRD;
                oe_d = 1'b1;
                if(tmr2_done)
                   begin
                        next_state = ACS_RD2;
                   end
              end
 
           ACS_RD2A:
              begin
                oe_d = 1'b1;
                cmd = `MC_CMD_XRD;
                next_state = ACS_RD2;
              end
 
           ACS_RD2:
              begin
                cmd = `MC_CMD_XRD;
                next_state = ACS_RD3;
              end
 
           ACS_RD3:
              begin
                mem_ack_d = 1'b1;
                tmr2_ld_trdz = 1'b1;
                next_state = IDLE_T2;
              end
 
           ACS_WR:
              begin
                tmr2_ld_twpw = 1'b1;
                cmd = `MC_CMD_XWR;
                data_oe_d = 1'b1;
                next_state = ACS_WR1;
              end
 
           ACS_WR1:
              begin
                if(!cmd_asserted)       tmr2_ld_twpw = 1'b1;
                cmd = `MC_CMD_XWR;
                data_oe_d = 1'b1;
                if(tmr2_done)
                   begin
                        tmr2_ld_twd = 1'b1;
                        next_state = ACS_WR2;
                   end
              end
 
           ACS_WR2:
              begin
                if(twd_is_zero) next_state = ACS_WR3;
                else
                   begin
                        cmd = `MC_CMD_XRD;
                        data_oe_d = 1'b1;
                        next_state = ACS_WR3;
                   end
              end
 
           ACS_WR3:
              begin
                if(tmr2_done)   next_state = ACS_WR4;
                else            cmd = `MC_CMD_XRD;
              end
 
           ACS_WR4:
              begin
                tmr2_ld_twwd = 1'b1;
                mem_ack_d = 1'b1;
                next_state = IDLE_T2;
              end
 
                /////////////////////////////////////////
                // SDRAM STATES ....
                /////////////////////////////////////////
 
           PRECHARGE:
              begin
                cmd = `MC_CMD_PC;
                if(rfr_ack_r)
                   begin
                        rfr_ack = 1'b1;
                        cmd_a10 = `MC_ALL_BANKS;
                        bank_clr_all = 1'b1;
                   end
                else
                   begin
                        bank_clr = 1'b1;
                        cmd_a10 = `MC_SINGLE_BANK;
                   end
                tmr_ld_trp = 1'b1;
                if(cmd_asserted)        next_state = PRECHARGE_W;
              end
 
           PRECHARGE_W:
              begin
                rfr_ack = rfr_ack_r;
                if(tmr_done)
                   begin
                        if(rfr_ack_r)   next_state = REFR;
                        else            next_state = ACTIVATE;
                   end
              end
 
           ACTIVATE:
              begin
                if(!wb_wait_r)
                   begin
                        row_sel = 1'b1;
                        tmr_ld_trcd = 1'b1;
                        cmd = `MC_CMD_ACT;
                   end
                if(cmd_asserted)        next_state = ACTIVATE_W;
              end
 
           ACTIVATE_W:
              begin
                row_sel = 1'b1;
                if(wb_write_go | (wb_we_i & wb_stb_i))  wr_set = 1'b1;
 
                if(kro)         bank_set = 1'b1;
 
                if(tmr_done)
                   begin
                        if(wb_write_go)
                           begin
                                mem_ack_d = ~mem_ack_r;
                                cmd_a10 = ap_en | (single_write & !kro);
                                next_state = SD_WR;
                           end
                        else
                        if(!wb_wait_r)  next_state = SD_RD;
                   end
              end
 
           SD_RD_WR:
              begin
                if(wb_write_go | (wb_we_i & wb_stb_i))  wr_set = 1'b1;
 
                if(wb_write_go & !wb_wait)
                   begin        // Write
                        data_oe_d = 1'b1;
                        mem_ack_d = ~mem_ack_r;
                        cmd_a10 = ap_en | (single_write & !kro);
                        next_state = SD_WR;
                   end
                else
                if(!wb_wait)
                   begin        // Read
                        if(kro)
                           begin
                                if(!wb_wait_r)  next_state = SD_RD;
                           end
                        else    next_state = SD_RD;
                   end
              end
 
           SD_WR:       // Write Command
              begin     // Does the first single write
                data_oe_d = 1'b1;
                tmr_ld_twr = 1'b1;
                cnt_next = ~cnt;
                cmd = `MC_CMD_WR;
 
                cmd_a10 = ap_en | (single_write & !kro);
 
                if(!cnt & wb_cycle & burst_act) cke_d = ~wb_wait;
                else                            cke_d = cke_r;
 
                if(cmd_asserted)
                   begin
                        mem_ack_d = !mem_ack_r & wb_write_go & !wb_wait & wb_cycle & burst_act;
 
                        if(wb_cycle & !burst_act)       next_state = IDLE_T;
                        else
                        if(wb_write_go)                 next_state = SD_WR_W;
                        else
                        if(burst_act & !single_write)   next_state = BT;
                        else
                        if(!ap_en)                      next_state = BT_W;
                        else                            next_state = IDLE_T;
                   end
 
              end
 
           SD_WR_W:
              begin     // Does additional Writes or Times them
                tmr_ld_twr = 1'b1;
                cnt_next = ~cnt;
 
                if(single_write & wb_cycle)
                   begin
                        cmd = `MC_CMD_WR;
                   end
                cmd_a10 = ap_en | (single_write & !kro);
 
                data_oe_d = 1'b1;
                mem_ack_d = !mem_ack_r & wb_write_go & !wb_wait & wr_cycle & burst_act;
 
                if(!cnt)        cke_d = ~wb_wait;
                else            cke_d = cke_r;
 
                if( (single_write & cke_r) | (!single_write & !cnt & !wb_wait) | (!single_write & cnt & cke_r) )
                   begin
                        if(single_write & !wb_cycle)            next_state = IDLE_T;
                        else
                        if(burst_act & !single_write & !wb_write_go_r)
                           begin
                                cmd = `MC_CMD_BT;
                                next_state = BT;
                           end
                        else
                        if(!burst_act & !ap_en)                 next_state = BT_W;
                        else
                        if(!burst_act)                          next_state = IDLE_T;
                        else
                        if(!wb_write_go_r & wb_read_go)         next_state = IDLE_T;    // Added for WMR
                   end
              end
 
           SD_RD:       // Read Command
              begin
                cmd = `MC_CMD_RD;
                cmd_a10 = ap_en;
                tmr_ld_tcl = 1'b1;
                if(cmd_asserted)                        next_state = SD_RD_W;
              end
 
           SD_RD_W:
              begin
                if(tmr_done)                            next_state = SD_RD_LOOP;
              end
 
           SD_RD_LOOP:
              begin
                cnt_next = ~cnt;
 
                if(cnt & !(burst_act & !wb_cycle) & burst_act )         cke_rd = !wb_wait;
                else                                                    cke_rd = cke_;
 
                if(wb_cycle & !cnt & burst_act_rd & cke_o_del)          dv = 1'b1;
 
                if(wb_cycle & wb_write_go)              next_state = BT;
                else
                if(burst_act & !wb_cycle)               next_state = BT;
                else
                if(!burst_act)                          next_state = SD_RD_W2;
              end
 
           SD_RD_W2:
              begin
                if(wb_write_go | ack_cnt_is_0)
                   begin
                        if(!ap_en & !kro)               next_state = BT_W;
                        else
                        if(!wb_wait & !mem_ack_r)       next_state = IDLE_T;
                   end
              end
 
           BT:
              begin
                cmd = `MC_CMD_BT;
                tmr_ld_trp = 1'b1;
                if(cmd_asserted)                        next_state = BT_W;
              end
 
           BT_W:
              begin
                cmd_a10 = cmd_a10_r;    // Hold Auto Precharge 'til cycle finishes
 
                if(kro & tmr_done)
                   begin
                        if(kro & !wb_wait & (wb_read_go | wb_write_go) )        cs_le_d = 1'b1;
                        next_state = IDLE;
                   end
                else
                if(!kro & tmr_done)             // Must do a PRECHARGE after Burst Terminate
                   begin
                        bank_clr = 1'b1;
                        cmd = `MC_CMD_PC;
                        cmd_a10 = `MC_SINGLE_BANK;
                        tmr_ld_trp = 1'b1;
                        if(cmd_asserted)        next_state = IDLE_T;
                   end
              end
 
           REFR:        // Refresh Cycle
              begin
                cs_le_d = 1'b1;
                cmd = `MC_CMD_ARFR;
                tmr_ld_trfc = 1'b1;
                rfr_ack = 1'b1;
                if(cmd_asserted)
                   begin
                        susp_sel_clr = 1'b1;
                        next_state = IDLE_T;
                   end
              end
 
           LMR0:
              begin
                lmr_ack = 1'b1;
                cmd = `MC_CMD_PC;
                cmd_a10 = `MC_ALL_BANKS;
                bank_clr_all = 1'b1;
                tmr_ld_trp = 1'b1;
                if(cmd_asserted)                next_state = LMR1;
              end
 
           LMR1:
              begin
                lmr_ack = 1'b1;
                if(tmr_done)                    next_state = LMR2;
              end
 
           LMR2:
              begin
                bank_clr_all = 1'b1;
                cmd = `MC_CMD_LMR;
                tmr_ld_trfc = 1'b1;
                lmr_ack = 1'b1;
                if(cmd_asserted)                next_state = IDLE_T;
              end
 
           INIT0:
              begin
                cs_le_d = 1'b1;
                next_state = INIT;
              end
 
           INIT:        // Initialize SDRAMS
              begin     // PRECHARGE
                init_ack = 1'b1;
                cmd = `MC_CMD_PC;
                cmd_a10 = `MC_ALL_BANKS;
                bank_clr_all = 1'b1;
                tmr_ld_trp = 1'b1;
                ir_cnt_ld = 1'b1;
                if(cmd_asserted)                next_state = INIT_W;
              end
 
           INIT_W:
              begin
                init_ack = 1'b1;
                if(tmr_done)                    next_state = INIT_REFR1;
              end
 
           INIT_REFR1:  // Init Refresh Cycle 1
              begin
                init_ack = 1'b1;
                cmd = `MC_CMD_ARFR;
                tmr_ld_trfc = 1'b1;
                if(cmd_asserted)
                   begin
                        ir_cnt_dec = 1'b1;
                        next_state = INIT_REFR1_W;
                   end
              end
 
           INIT_REFR1_W:
              begin
                init_ack = 1'b1;
                if(tmr_done)
                   begin
                        if(ir_cnt_done)         next_state = INIT_LMR;
                        else                    next_state = INIT_REFR1;
                   end
              end
 
           INIT_LMR:
              begin
                init_ack = 1'b1;
                cmd = `MC_CMD_LMR;
                bank_clr_all = 1'b1;
                tmr_ld_trfc = 1'b1;
                if(cmd_asserted)                next_state = IDLE_T;
              end
 
                /////////////////////////////////////////
                // Bus Arbitration STATES ....
                /////////////////////////////////////////
           BG0:
              begin     // Bus Grant
                mc_bg = 1'b1;
                mc_c_oe_d = 1'b0;
                next_state = BG1;
              end
           BG1:
              begin     // Bus Grant
                mc_bg = 1'b1;
                cs_le_d = 1'b1;
                mc_c_oe_d = 1'b0;
                next_state = BG2;
              end
           BG2:
              begin     // Bus Grant
                cs_le_d = 1'b1;
                mc_bg = !wb_read_go & !wb_write_go &
                        !rfr_req & !init_req & !lmr_req &
                        !susp_req_r;
                tmr_ld_tavav = 1'b1;
                mc_c_oe_d = mc_br;
                if(!mc_br)      next_state = IDLE_T;
              end
 
                /////////////////////////////////////////
                // SUSPEND/RESUME STATES ....
                /////////////////////////////////////////
           SUSP1:
              begin             // Precharge All
                cmd = `MC_CMD_PC;
                cmd_a10 = `MC_ALL_BANKS;
                bank_clr_all = 1'b1;
                tmr_ld_trp = 1'b1;
                if(cmd_asserted)        next_state = SUSP2;
              end
 
           SUSP2:
              begin
                if(tmr_done)    next_state = SUSP3;
              end
 
           SUSP3:
              begin             // Enter Self refresh Mode
                cke_d = 1'b0;
                cmd = `MC_CMD_ARFR;
                rfr_ack = 1'b1;
                if(cmd_asserted)
                   begin
                        next_state = SUSP4;
                   end
              end
 
           SUSP4:
              begin             // Now we are suspended
                cke_rd = 1'b0;
                suspended_d = 1'b1;
                tmr_ld_txsr = 1'b1;
                if(resume_req_r)        next_state = RESUME1;
              end
 
           RESUME1:
              begin
                suspended_d = 1'b1;
                tmr_ld_txsr = 1'b1;
                next_state = RESUME2;
              end
 
           RESUME2:
              begin
                suspended_d = 1'b1;
                if(tmr_done)    next_state = REFR;
              end
 
// synopsys translate_off
           default:
                $display("MC_TIMING SM: Entered non existing state ... (%t)",$time);
// synopsys translate_on
 
        endcase
   end
 
endmodule

Line No.	Rev	Author	Line
1	4	rudi	`/////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// WISHBONE Memory Controller Main Timing Block ////`
4			`//// ////`
5			`//// ////`
6			`//// Author: Rudolf Usselmann ////`
7			`//// rudi@asics.ws ////`
8			`//// ////`
9			`//// ////`
10			`//// Downloaded from: http://www.opencores.org/cores/mem_ctrl/ ////`
11			`//// ////`
12			`/////////////////////////////////////////////////////////////////////`
13			`//// ////`
14			`//// Copyright (C) 2000 Rudolf Usselmann ////`
15			`//// rudi@asics.ws ////`
16			`//// ////`
17			`//// This source file may be used and distributed without ////`
18			`//// restriction provided that this copyright statement is not ////`
19			`//// removed from the file and that any derivative work contains ////`
20			`//// the original copyright notice and the associated disclaimer.////`
21			`//// ////`
22			//// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY ////
23			`//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED ////`
24			`//// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ////`
25			`//// FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR ////`
26			`//// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ////`
27			`//// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ////`
28			`//// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE ////`
29			`//// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR ////`
30			`//// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF ////`
31			`//// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ////`
32			`//// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT ////`
33			`//// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ////`
34			`//// POSSIBILITY OF SUCH DAMAGE. ////`
35			`//// ////`
36			`/////////////////////////////////////////////////////////////////////`
37
38			`// CVS Log`
39			`//`
40	16	rudi	`// $Id: mc_timing.v,v 1.5 2001-11-29 02:16:28 rudi Exp $`
41	4	rudi	`//`
42	16	rudi	`// $Date: 2001-11-29 02:16:28 $`
43			`// $Revision: 1.5 $`
44	4	rudi	`// $Author: rudi $`
45			`// $Locker: $`
46			`// $State: Exp $`
47			`//`
48			`// Change History:`
49			`// $Log: not supported by cvs2svn $`
50	16	rudi	`// Revision 1.4 2001/09/24 00:38:21 rudi`
51			`//`
52			`// Changed Reset to be active high and async.`
53			`//`
54	12	rudi	`// Revision 1.3 2001/09/02 02:28:28 rudi`
55			`//`
56			`// Many fixes for minor bugs that showed up in gate level simulations.`
57			`//`
58	9	rudi	`// Revision 1.2 2001/08/10 08:16:21 rudi`
59			`//`
60			`// - Changed IO names to be more clear.`
61			`// - Uniquifyed define names to be core specific.`
62			`// - Removed "Refresh Early" configuration`
63			`//`
64	8	rudi	`// Revision 1.1 2001/07/29 07:34:41 rudi`
65			`//`
66			`//`
67			`// 1) Changed Directory Structure`
68			`// 2) Fixed several minor bugs`
69			`//`
70	4	rudi	`// Revision 1.4 2001/06/14 01:57:37 rudi`
71			`//`
72			`//`
73			`// Fixed a potential bug in a corner case situation where the TMS register`
74			`// does not propegate properly during initialisation.`
75			`//`
76			`// Revision 1.3 2001/06/12 15:19:49 rudi`
77			`//`
78			`//`
79			`// Minor changes after running lint, and a small bug fix reading csr and ba_mask registers.`
80			`//`
81			`// Revision 1.2 2001/06/03 11:37:17 rudi`
82			`//`
83			`//`
84			`// 1) Fixed Chip Select Mask Register`
85			`// - Power On Value is now all ones`
86			`// - Comparison Logic is now correct`
87			`//`
88			`// 2) All resets are now asynchronous`
89			`//`
90			`// 3) Converted Power On Delay to an configurable item`
91			`//`
92			`// 4) Added reset to Chip Select Output Registers`
93			`//`
94			`// 5) Forcing all outputs to Hi-Z state during reset`
95			`//`
96			`// Revision 1.1.1.1 2001/05/13 09:39:44 rudi`
97			`// Created Directory Structure`
98			`//`
99			`//`
100			`//`
101			`//`
102
103			`include "mc_defines.v"
104
105			`module mc_timing(clk, rst,`
106
107			`// Wishbone Interface`
108	9	rudi	`wb_cyc_i, wb_stb_i, wb_we_i,`
109	4	rudi	`wb_read_go, wb_write_go, wb_first, wb_wait, mem_ack,`
110	16	rudi	`err,`
111	4	rudi
112			`// Suspend/Resume Interface`
113			`susp_req, resume_req, suspended, susp_sel,`
114
115			`// Memory Interface`
116	9	rudi	`mc_clk, data_oe, oe_, we_, cas_, ras_, cke_,`
117	4	rudi	`cs_en, wb_cycle, wr_cycle,`
118			`mc_br, mc_bg, mc_adsc, mc_adv,`
119			`mc_c_oe, mc_ack,`
120
121			`// Register File Interface`
122			`csc, tms, cs, lmr_req, lmr_ack, cs_le,`
123
124			`// Address Select Signals`
125			`cmd_a10, row_sel, next_adr, page_size,`
126
127			`// OBCT Signals`
128			`bank_set, bank_clr, bank_clr_all, bank_open, any_bank_open, row_same,`
129
130			`// Data path Controller Signals`
131			`dv, pack_le0, pack_le1, pack_le2, par_err,`
132
133			`// Refresh Counter Signals`
134			`rfr_req, rfr_ack,`
135
136			`// Initialize Request & Ack`
137			`init_req, init_ack`
138			`);`
139
140			`input clk;`
141			`input rst;`
142
143			`// Wishbone Interface`
144	9	rudi	`input wb_cyc_i, wb_stb_i, wb_we_i;`
145	4	rudi	`input wb_read_go;`
146			`input wb_write_go;`
147			`input wb_first;`
148			`input wb_wait;`
149			`output mem_ack;`
150			`output err;`
151
152			`// Suspend/Resume Interface`
153			`input susp_req;`
154			`input resume_req;`
155			`output suspended;`
156			`output susp_sel;`
157
158			`// Memory Interface`
159	9	rudi	`input mc_clk;`
160	4	rudi	`output data_oe;`
161			`output oe_;`
162			`output we_;`
163			`output cas_;`
164			`output ras_;`
165			`output cke_;`
166			`output cs_en;`
167			`output wb_cycle;`
168			`output wr_cycle;`
169			`input mc_br;`
170			`output mc_bg;`
171			`output mc_adsc;`
172			`output mc_adv;`
173			`output mc_c_oe;`
174			`input mc_ack;`
175
176			`// Register File Interface`
177			`input [31:0] csc;`
178			`input [31:0] tms;`
179			`input [7:0] cs;`
180			`input lmr_req;`
181			`output lmr_ack;`
182			`output cs_le;`
183
184			`// Address Select Signals`
185			`input [10:0] page_size;`
186			`output cmd_a10;`
187			`output row_sel;`
188			`output next_adr;`
189
190			`// OBCT Signals`
191			`output bank_set;`
192			`output bank_clr;`
193			`output bank_clr_all;`
194			`input bank_open;`
195			`input any_bank_open;`
196			`input row_same;`
197
198			`// Data path Controller Signals`
199			`output dv;`
200			`output pack_le0, pack_le1, pack_le2; // Pack Latch Enable`
201			`input par_err;`
202
203			`// Refresh Counter Signals`
204			`input rfr_req;`
205			`output rfr_ack;`
206
207			`// Initialize Request & Ack`
208			`input init_req;`
209			`output init_ack;`
210
211			`////////////////////////////////////////////////////////////////////`
212			`//`
213			`// Defines & Parameters`
214			`//`
215
216			`// Number of states: 66`
217			`parameter [65:0] // synopsys enum state`
218	16	rudi	`// 6666666555555555544444444443333333333222222222211111111110000000000`
219			`// 6543210987654321098765432109876543210987654321098765432109876543210`
220	4	rudi	`POR = 66'b000000000000000000000000000000000000000000000000000000000000000001,`
221			`IDLE = 66'b000000000000000000000000000000000000000000000000000000000000000010,`
222			`IDLE_T = 66'b000000000000000000000000000000000000000000000000000000000000000100,`
223			`IDLE_T2 = 66'b000000000000000000000000000000000000000000000000000000000000001000,`
224			`PRECHARGE = 66'b000000000000000000000000000000000000000000000000000000000000010000,`
225			`PRECHARGE_W = 66'b000000000000000000000000000000000000000000000000000000000000100000,`
226			`ACTIVATE = 66'b000000000000000000000000000000000000000000000000000000000001000000,`
227			`ACTIVATE_W = 66'b000000000000000000000000000000000000000000000000000000000010000000,`
228			`SD_RD_WR = 66'b000000000000000000000000000000000000000000000000000000000100000000,`
229			`SD_RD = 66'b000000000000000000000000000000000000000000000000000000001000000000,`
230			`SD_RD_W = 66'b000000000000000000000000000000000000000000000000000000010000000000,`
231			`SD_RD_LOOP = 66'b000000000000000000000000000000000000000000000000000000100000000000,`
232			`SD_RD_W2 = 66'b000000000000000000000000000000000000000000000000000001000000000000,`
233			`SD_WR = 66'b000000000000000000000000000000000000000000000000000010000000000000,`
234			`SD_WR_W = 66'b000000000000000000000000000000000000000000000000000100000000000000,`
235			`BT = 66'b000000000000000000000000000000000000000000000000001000000000000000,`
236			`BT_W = 66'b000000000000000000000000000000000000000000000000010000000000000000,`
237			`REFR = 66'b000000000000000000000000000000000000000000000000100000000000000000,`
238			`LMR0 = 66'b000000000000000000000000000000000000000000000001000000000000000000,`
239			`LMR1 = 66'b000000000000000000000000000000000000000000000010000000000000000000,`
240			`LMR2 = 66'b000000000000000000000000000000000000000000000100000000000000000000,`
241			`INIT0 = 66'b000000000000000000000000000000000000000000001000000000000000000000,`
242			`INIT = 66'b000000000000000000000000000000000000000000010000000000000000000000,`
243			`INIT_W = 66'b000000000000000000000000000000000000000000100000000000000000000000,`
244			`INIT_REFR1 = 66'b000000000000000000000000000000000000000001000000000000000000000000,`
245			`INIT_REFR1_W = 66'b000000000000000000000000000000000000000010000000000000000000000000,`
246			`INIT_LMR = 66'b000000000000000000000000000000000000000100000000000000000000000000,`
247			`SUSP1 = 66'b000000000000000000000000000000000000001000000000000000000000000000,`
248			`SUSP2 = 66'b000000000000000000000000000000000000010000000000000000000000000000,`
249			`SUSP3 = 66'b000000000000000000000000000000000000100000000000000000000000000000,`
250			`SUSP4 = 66'b000000000000000000000000000000000001000000000000000000000000000000,`
251			`RESUME1 = 66'b000000000000000000000000000000000010000000000000000000000000000000,`
252			`RESUME2 = 66'b000000000000000000000000000000000100000000000000000000000000000000,`
253			`BG0 = 66'b000000000000000000000000000000001000000000000000000000000000000000,`
254			`BG1 = 66'b000000000000000000000000000000010000000000000000000000000000000000,`
255			`BG2 = 66'b000000000000000000000000000000100000000000000000000000000000000000,`
256			`ACS_RD = 66'b000000000000000000000000000001000000000000000000000000000000000000,`
257			`ACS_RD1 = 66'b000000000000000000000000000010000000000000000000000000000000000000,`
258			`ACS_RD2A = 66'b000000000000000000000000000100000000000000000000000000000000000000,`
259			`ACS_RD2 = 66'b000000000000000000000000001000000000000000000000000000000000000000,`
260			`ACS_RD3 = 66'b000000000000000000000000010000000000000000000000000000000000000000,`
261			`ACS_RD_8_1 = 66'b000000000000000000000000100000000000000000000000000000000000000000,`
262			`ACS_RD_8_2 = 66'b000000000000000000000001000000000000000000000000000000000000000000,`
263			`ACS_RD_8_3 = 66'b000000000000000000000010000000000000000000000000000000000000000000,`
264			`ACS_RD_8_4 = 66'b000000000000000000000100000000000000000000000000000000000000000000,`
265			`ACS_RD_8_5 = 66'b000000000000000000001000000000000000000000000000000000000000000000,`
266			`ACS_RD_8_6 = 66'b000000000000000000010000000000000000000000000000000000000000000000,`
267			`ACS_WR = 66'b000000000000000000100000000000000000000000000000000000000000000000,`
268			`ACS_WR1 = 66'b000000000000000001000000000000000000000000000000000000000000000000,`
269			`ACS_WR2 = 66'b000000000000000010000000000000000000000000000000000000000000000000,`
270			`ACS_WR3 = 66'b000000000000000100000000000000000000000000000000000000000000000000,`
271			`ACS_WR4 = 66'b000000000000001000000000000000000000000000000000000000000000000000,`
272			`SRAM_RD = 66'b000000000000010000000000000000000000000000000000000000000000000000,`
273			`SRAM_RD0 = 66'b000000000000100000000000000000000000000000000000000000000000000000,`
274			`SRAM_RD1 = 66'b000000000001000000000000000000000000000000000000000000000000000000,`
275			`SRAM_RD2 = 66'b000000000010000000000000000000000000000000000000000000000000000000,`
276			`SRAM_RD3 = 66'b000000000100000000000000000000000000000000000000000000000000000000,`
277			`SRAM_RD4 = 66'b000000001000000000000000000000000000000000000000000000000000000000,`
278			`SRAM_WR = 66'b000000010000000000000000000000000000000000000000000000000000000000,`
279			`SRAM_WR0 = 66'b000000100000000000000000000000000000000000000000000000000000000000,`
280			`SCS_RD = 66'b000001000000000000000000000000000000000000000000000000000000000000,`
281			`SCS_RD1 = 66'b000010000000000000000000000000000000000000000000000000000000000000,`
282			`SCS_RD2 = 66'b000100000000000000000000000000000000000000000000000000000000000000,`
283			`SCS_WR = 66'b001000000000000000000000000000000000000000000000000000000000000000,`
284			`SCS_WR1 = 66'b010000000000000000000000000000000000000000000000000000000000000000,`
285			`SCS_ERR = 66'b100000000000000000000000000000000000000000000000000000000000000000;`
286
287			`////////////////////////////////////////////////////////////////////`
288			`//`
289			`// Local Registers & Wires`
290			`//`
291
292			`reg [65:0] /* synopsys enum state */ state, next_state;`
293			`// synopsys state_vector state`
294
295			`reg mc_bg;`
296
297			`wire [2:0] mem_type;`
298			`wire [1:0] bus_width;`
299			`wire kro;`
300
301			`wire cs_a;`
302			`reg [3:0] cmd;`
303
304	16	rudi	`wire mem_ack;`
305	4	rudi	`wire mem_ack_s;`
306			`reg mem_ack_d;`
307			`reg err_d;`
308	16	rudi	`wire err;`
309	4	rudi	`reg cmd_a10;`
310			`reg lmr_ack;`
311			`reg row_sel;`
312			`reg oe_;`
313			`reg oe_d;`
314			`reg data_oe;`
315			`reg data_oe_d;`
316			`reg cke_d;`
317			`reg cke_;`
318			`reg init_ack;`
319			`reg dv;`
320			`reg rfr_ack;`
321			`reg mc_adsc;`
322			`reg mc_adv;`
323
324			`reg bank_set;`
325			`reg bank_clr;`
326			`reg bank_clr_all;`
327
328			`reg wr_set, wr_clr;`
329			`reg wr_cycle;`
330
331			`reg cmd_asserted;`
332			`reg cmd_asserted2;`
333
334			`reg [10:0] burst_val;`
335			`reg [10:0] burst_cnt;`
336			`wire burst_act;`
337			`reg burst_act_rd;`
338			`wire single_write;`
339
340	16	rudi	`reg cs_le_d;`
341	4	rudi	`reg cs_le;`
342	16	rudi	`reg cs_le_r;`
343	4	rudi
344			`reg susp_req_r;`
345			`reg resume_req_r;`
346			`reg suspended;`
347			`reg suspended_d;`
348	9	rudi	`reg susp_sel_set, susp_sel_clr, susp_sel_r;`
349	4	rudi
350			`reg [3:0] cmd_del;`
351			`reg [3:0] cmd_r;`
352			`reg data_oe_r;`
353			`reg data_oe_r2;`
354			`reg cke_r;`
355			`reg cke_rd;`
356			`reg cke_o_del;`
357			`reg cke_o_r1;`
358			`reg cke_o_r2;`
359			`reg wb_cycle_set, wb_cycle;`
360			`reg [3:0] ack_cnt;`
361			`wire ack_cnt_is_0;`
362			`reg cnt, cnt_next;`
363			`reg [7:0] timer;`
364			`reg tmr_ld_trp, tmr_ld_trcd, tmr_ld_tcl, tmr_ld_trfc;`
365			`reg tmr_ld_twr, tmr_ld_txsr;`
366			`reg tmr2_ld_tscsto;`
367			`reg tmr_ld_trdv;`
368			`reg tmr_ld_trdz;`
369			`reg tmr_ld_twr2;`
370			`wire timer_is_zero;`
371			`reg tmr_done;`
372			`reg tmr2_ld_trdv, tmr2_ld_trdz;`
373			`reg tmr2_ld_twpw, tmr2_ld_twd, tmr2_ld_twwd;`
374			`reg tmr2_ld_tsrdv;`
375			`reg [8:0] timer2;`
376			`reg tmr2_done;`
377			`wire timer2_is_zero;`
378			`reg [3:0] ir_cnt;`
379			`reg ir_cnt_ld;`
380			`reg ir_cnt_dec;`
381			`reg ir_cnt_done;`
382			`reg rfr_ack_r;`
383			`reg burst_cnt_ld;`
384			`reg burst_fp;`
385			`reg wb_wait_r, wb_wait_r2;`
386			`reg lookup_ready1, lookup_ready2;`
387			`reg burst_cnt_ld_4;`
388			`reg dv_r;`
389			`reg mc_adv_r1, mc_adv_r;`
390
391			`reg next_adr;`
392			`reg pack_le0, pack_le1, pack_le2;`
393			`reg pack_le0_d, pack_le1_d, pack_le2_d;`
394			`wire bw8, bw16;`
395
396			`reg mc_c_oe_d;`
397			`reg mc_c_oe;`
398
399	8	rudi	`reg mc_le;`
400	16	rudi	`reg mem_ack_r;`
401	8	rudi
402	16	rudi	`reg rsts, rsts1;`
403			`reg no_wb_cycle;`
404
405			`wire bc_dec;`
406			`reg ap_en; // Auto Precharge Enable`
407			`reg cmd_a10_r;`
408			`reg wb_stb_first;`
409			`reg tmr_ld_tavav;`
410
411	4	rudi	`////////////////////////////////////////////////////////////////////`
412			`//`
413			`// Aliases`
414			`//`
415			`assign mem_type = csc[3:1];`
416			`assign bus_width = csc[5:4];`
417			`assign kro = csc[10];`
418	16	rudi	`assign single_write = tms[9] \| (tms[2:0] == 3'h0);`
419	4	rudi
420			`////////////////////////////////////////////////////////////////////`
421			`//`
422			`// Misc Logic`
423			`//`
424	16	rudi	`reg cs_le_r1;`
425	4	rudi
426	16	rudi	`always @(posedge clk)`
427			`cs_le_r <= #1 cs_le_r1;`
428
429			`always @(posedge clk)`
430			`cs_le_r1 <= #1 cs_le;`
431
432			`always @(posedge clk)`
433			`cs_le <= #1 cs_le_d;`
434
435	9	rudi	`always @(posedge mc_clk)`
436			`rsts1 <= #1 rst;`
437
438			`always @(posedge clk)`
439			`rsts <= #1 rsts1;`
440
441	4	rudi	`// Control Signals Output Enable`
442	12	rudi	`always @(posedge clk or posedge rst)`
443			`if(rst) mc_c_oe <= #1 1'b0;`
444	9	rudi	`else mc_c_oe <= #1 mc_c_oe_d;`
445	4	rudi
446	12	rudi	`always @(posedge clk or posedge rsts)`
447			`if(rsts) mc_le <= #1 1'b0;`
448	8	rudi	`else mc_le <= #1 ~mc_le;`
449
450	4	rudi	`always @(posedge clk)`
451			`pack_le0 <= #1 pack_le0_d;`
452
453			`always @(posedge clk)`
454			`pack_le1 <= #1 pack_le1_d;`
455
456			`always @(posedge clk)`
457			`pack_le2 <= #1 pack_le2_d;`
458
459	8	rudi	`always @(posedge clk)`
460			`if(!mc_le) mc_adv_r1 <= #1 mc_adv;`
461	4	rudi
462	8	rudi	`always @(posedge clk)`
463			`if(!mc_le) mc_adv_r <= #1 mc_adv_r1;`
464	4	rudi
465			`// Bus Width decoder`
466	8	rudi	assign bw8 = (bus_width == `MC_BW_8);
467			assign bw16 = (bus_width == `MC_BW_16);
468	4	rudi
469	9	rudi	`// Any Chip Select`
470			`assign cs_a = \|cs;`
471	4	rudi
472			`// Memory to Wishbone Ack`
473	16	rudi	`assign mem_ack = (mem_ack_d \| mem_ack_s) & (wb_read_go \| wb_write_go);`
474	4	rudi
475			`always @(posedge clk)`
476	16	rudi	`mem_ack_r <= #1 mem_ack;`
477	4	rudi
478	16	rudi	`assign err = err_d;`
479
480	4	rudi	`// SDRAM Command, either delayed (for writes) or straight through`
481			`always @(posedge clk)`
482			`cmd_r <= #1 cmd;`
483
484			`always @(posedge clk)`
485			`cmd_del <= #1 cmd_r;`
486
487			`assign {cs_en, ras_, cas_, we_} = wr_cycle ? cmd_del : cmd;`
488
489			`// Track Timing of Asserting a command`
490	8	rudi	`always @(posedge clk)`
491			`if(!mc_le) cmd_asserted <= #1 cmd[3];`
492	4	rudi
493	8	rudi	`always @(posedge clk)`
494	9	rudi	`if(!mc_le) cmd_asserted2 <= #1 cmd_asserted;`
495	4	rudi
496			`// Output Enable`
497			`always @(posedge clk)`
498			`oe_ <= #1 ~oe_d;`
499
500			`// Memory Bus Data lines Output Enable`

Browse

Tools

Subversion Repositories mem_ctrl

[/] [mem_ctrl/] [trunk/] [rtl/] [verilog/] [mc_timing.v] - Blame information for rev 16