// ========== Copyright Header Begin ==========================================
// OpenSPARC T2 Processor File: niu_smx_sm_resp_cmdlaunch.v
// Copyright (C) 1995-2007 Sun Microsystems, Inc. All Rights Reserved
// 4150 Network Circle, Santa Clara, California 95054, U.S.A.
// * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; version 2 of the License.
// This program 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 General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
// For the avoidance of doubt, and except that if any non-GPL license
// choice is available it will apply instead, Sun elects to use only
// the General Public License version 2 (GPLv2) at this time for any
// software where a choice of GPL license versions is made
// available with the language indicating that GPLv2 or any later version
// may be used, or where a choice of which version of the GPL is applied is
// otherwise unspecified.
// Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
// CA 95054 USA or visit www.sun.com if you need additional information or
// ========== Copyright Header End ============================================
module niu_smx_sm_resp_cmdlaunch(
smx_dmc_rdy, smx_dmc_cmd, smx_dmc_cmd_status, smx_dmc_addr,
smx_dmc_len, smx_dmc_xid, smx_dmc_port, smx_dmc_dma,
smx_dmc_client, smx_dmc_ack_rdy, smx_dmc_ack_cmd,
smx_dmc_ack_client, rst_procflag, dvflag,
dvflag_with_data, dvflag_line_en, dvflag_sop_pos, dvflag_eop_pos,
dvflag_sop_byte_en, dvflag_eop_byte_en, dvflag_client,
dvflag_xcomp, dvflag_status, early_dvflag, early_dvflag_with_data,
early_dvflag_line_en, early_dvflag_sop_pos, early_dvflag_eop_pos,
early_dvflag_sop_byte_en, early_dvflag_eop_byte_en,
early_dvflag_client, early_dvflag_xcomp, early_dvflag_status,
clk, reset_l, dmc_smx_accept, dmc_smx_ack_accept, procflag,
procflag_cmd, procflag_addr, procflag_xid,
procflag_port, procflag_dma, procflag_client,
procflag_sop_line_en, procflag_eop_line_en, procflag_sop_byte_en,
procflag_eop_byte_en, procflag_err, procflag_rd,
procflag_with_data, procflag_xcomp, procflag_sop, procflag_eop,
rst_dvflag, dv_idle, tohdl_cmdl_req, tohdl_cmdl_cmd,
tohdl_cmdl_addr, tohdl_cmdl_len, tohdl_cmdl_xid, tohdl_cmdl_port,
tohdl_cmdl_dma, tohdl_cmdl_client, tid_dirty_rdata_bus
output [7:0] smx_dmc_cmd;
output [3:0] smx_dmc_cmd_status;
output [63:0] smx_dmc_addr;
output [13:0] smx_dmc_len;
output [5:0] smx_dmc_xid;
output [1:0] smx_dmc_port;
output [4:0] smx_dmc_dma;
output [7:0] smx_dmc_client;
input [7:0] dmc_smx_accept;
output [7:0] smx_dmc_ack_cmd;
output [3:0] smx_dmc_ack_cmd_status;
// output [63:0] smx_dmc_ack_addr;
// output [13:0] smx_dmc_ack_len;
output [5:0] smx_dmc_ack_xid;
// output [1:0] smx_dmc_ack_port;
output [4:0] smx_dmc_ack_dma;
output [7:0] smx_dmc_ack_client;
input [7:0] dmc_smx_ack_accept;
input [7:0] procflag_cmd;
input [63:0] procflag_addr;
input [5:0] procflag_xid;
input [1:0] procflag_port;
input [4:0] procflag_dma;
input [7:0] procflag_client;
input [3:0] procflag_sop_line_en;
input [3:0] procflag_eop_line_en;
input [3:0] procflag_sop_byte_en;
input [3:0] procflag_eop_byte_en;
input [2:0] procflag_err;
input procflag_rd; // rd= 1, wr= 0
input procflag_with_data; //1- data, 0- no data
// output cmdlaunch_idle; // in case need save 1 cycle at start
// input [150:0] early_procflag_data; // not use for now
output [1:0] dvflag_with_data; // 1= rd (data,dv also sio dq) ,
// 0= wr/rderr (sio dq only)
output [3:0] dvflag_line_en;
output [3:0] dvflag_sop_pos; // indicate first data line position
output [3:0] dvflag_eop_pos; // indicate last data line position
output [15:0] dvflag_sop_byte_en; // use this for 'first' data line
output [15:0] dvflag_eop_byte_en; // use this for 'last' data line
output [7:0] dvflag_client;
output [3:0] dvflag_xcomp;
output [3:0] dvflag_status;
input dv_idle; // dv in idle state
output early_dvflag; // dv needs to be in idle to catch this pulse
output [1:0] early_dvflag_with_data; // 1= rd (data,dv also sio dq) ,
// 0= wr/rderr (sio dq only)
output [3:0] early_dvflag_line_en;
output [3:0] early_dvflag_sop_pos; // indicate first data line position
output [3:0] early_dvflag_eop_pos; // indicate last data line position
output [15:0] early_dvflag_sop_byte_en; // use this for 'first' data line
output [15:0] early_dvflag_eop_byte_en; // use this for 'last' data line
output [7:0] early_dvflag_client;
output [3:0] early_dvflag_xcomp;
output [3:0] early_dvflag_status;
input [7:0] tohdl_cmdl_cmd;
input [63:0] tohdl_cmdl_addr;
input [13:0] tohdl_cmdl_len;
input [5:0] tohdl_cmdl_xid;
input [1:0] tohdl_cmdl_port;
input [4:0] tohdl_cmdl_dma;
input [7:0] tohdl_cmdl_client;
input [63:0] tid_dirty_rdata_bus;
function [15:0] decode_eop_16b_byte_en_little; // B15,B14..,B1,B0
decode_eop_16b_byte_en_little= byte_en;
function [15:0] decode_sop_16b_byte_en_little; // B15,B14..,B1,B0
decode_sop_16b_byte_en_little= byte_en;
function [15:0] decode_eop_16b_byte_en_big; // B0,B1...,B14,B15
decode_eop_16b_byte_en_big= byte_en;
function [15:0] decode_sop_16b_byte_en_big; // B0,B1...,B14,B15
decode_sop_16b_byte_en_big= byte_en;
wire client_accept_n= (|(dmc_smx_accept & smx_dmc_client)) |
(|(dmc_smx_ack_accept & smx_dmc_ack_client));
wire early_dvflag= early_dvflag_n;
wire rst_procflag= rst_procflag_n;
reg smx_dmc_rdy_n, smx_dmc_rdy ;
reg smx_dmc_ack_rdy_n, smx_dmc_ack_rdy ;
reg [2:0] cmdl_ns, cmdl_cs;
wire cmdl_req_n= procflag && !dvflag;
wire cmdl_tohdl_ack= cmdl_tohdl_ack_n;
wire proc_tid_is_dirty= tid_dirty_rdata_bus[procflag_xid];
always @(/*AUTOSENSE*/client_accept_n or cmdl_cs or cmdl_req_n
or dv_idle or dvflag or procflag or procflag_err
or procflag_rd or serve_tohdl or smx_dmc_ack_rdy
or smx_dmc_rdy or tohdl_cmdl_req or tohdl_cmdl_xid
or proc_tid_is_dirty) begin
smx_dmc_rdy_n= smx_dmc_rdy;
smx_dmc_ack_rdy_n= smx_dmc_ack_rdy;
ld_dmc_n= 1'b0; // pulse to flop out smx_dmc cmd bus
set_dvflag_n= 1'b0; // also set dvflag_data
cmdl_s0: begin // wait procflag & !dvflag
// gen early_dvflag_xx using procflag_xx
// err ??? time share this with
// if both arb: serve_errhdl_first & lauch_err, cmdl_s3 (errhdl state)
// set served errhdl_first= each regular served
// rst each errhdl served
if(tohdl_cmdl_req & (serve_tohdl | (~serve_tohdl & ~cmdl_req_n))) begin
if(!dvflag) cmdl_ns= cmdl_s3;
if(procflag && !dvflag) begin
// flop in procflag_xx (->early_dvflag_xx)
if(procflag_err[0] | proc_tid_is_dirty) begin // pkterr; drop pkt
ld_dmc_n= 1'b1; // flop out dmc cmd bus
cmdl_s1: begin // wait dmc client accept
// use procflag_xx_r to derive dvflag_xx_n
if(client_accept_n) begin
if(dv_idle) // kick dv earlier; save one cycle at start
early_dvflag_n= 1'b1; // early_dvflag_xx available
smx_dmc_rdy_n= 1'b0; // put all rdy to 0
cmdl_s2: begin // pkterr; drop pkt
cmdl_s3: begin // TO hdlr
if(tohdl_cmdl_xid[5]) // wr
if(client_accept_n) begin
smx_dmc_rdy_n= 1'b0; // put all rdy to 0
always @(posedge clk) begin
cmdl_cs<= `SMX_PD cmdl_s0;
smx_dmc_rdy<= `SMX_PD 1'b0;
smx_dmc_ack_rdy<= `SMX_PD 1'b0;
serve_tohdl<= `SMX_PD 1'b0;
cmdl_cs<= `SMX_PD cmdl_ns;
smx_dmc_rdy<= `SMX_PD smx_dmc_rdy_n;
smx_dmc_ack_rdy<= `SMX_PD smx_dmc_ack_rdy_n;
if(set_dvflag_n) dvflag<= `SMX_PD 1'b1;
else if(rst_dvflag) dvflag<= `SMX_PD 1'b0;
if(rst_procflag_n) serve_tohdl<= `SMX_PD 1'b1;
else if(rst_serve_tohdl_n) serve_tohdl<= `SMX_PD 1'b0;
// wire cmdlaunch_idle= (cmdl_cs==cmdl_s0);
// reg [3:0] procflag_sop_line_en_r;
// reg [3:0] procflag_eop_line_en_r;
// reg [3:0] procflag_sop_byte_en_r;
// reg [3:0] procflag_eop_byte_en_r;
// reg [2:0] procflag_err_r;
// reg procflag_with_data_r;
reg [3:0] smx_dmc_cmd_status;
reg [7:0] smx_dmc_client;
// wire [63:0] smx_dmc_ack_addr= smx_dmc_addr;
// wire [13:0] smx_dmc_ack_len= smx_dmc_len;
// wire [1:0] smx_dmc_ack_port= smx_dmc_port;
// cc registered to prevent ghosting effect with response bus 062905
// wire [7:0] smx_dmc_ack_cmd= smx_dmc_cmd;
// wire [3:0] smx_dmc_ack_cmd_status= smx_dmc_cmd_status;
// wire [5:0] smx_dmc_ack_xid= smx_dmc_xid;
// wire [4:0] smx_dmc_ack_dma= smx_dmc_dma;
// wire [7:0] smx_dmc_ack_client= smx_dmc_client;
reg [7:0] smx_dmc_ack_cmd;
reg [3:0] smx_dmc_ack_cmd_status;
reg [5:0] smx_dmc_ack_xid;
reg [4:0] smx_dmc_ack_dma;
reg [7:0] smx_dmc_ack_client;
always @(posedge clk) begin
if(ld_dmc_n & smx_dmc_ack_rdy_n) begin // cc qualify to smx_dmc_ack_rdy_n 062905
smx_dmc_ack_cmd <= `SMX_PD (rst_serve_tohdl_n)? tohdl_cmdl_cmd : procflag_cmd;
smx_dmc_ack_cmd_status <= `SMX_PD (rst_serve_tohdl_n)? 4'hf : 4'h0;
smx_dmc_ack_xid <= `SMX_PD (rst_serve_tohdl_n)? tohdl_cmdl_xid : procflag_xid;
smx_dmc_ack_dma <= `SMX_PD (rst_serve_tohdl_n)? tohdl_cmdl_dma : procflag_dma;
smx_dmc_ack_client <= `SMX_PD (rst_serve_tohdl_n)? tohdl_cmdl_client : procflag_client;
always @(posedge clk) begin
if(ld_dmc_n & smx_dmc_rdy_n) begin // cc qualify to smx_dmc_rdy_n 062905
smx_dmc_cmd <= `SMX_PD (rst_serve_tohdl_n)? tohdl_cmdl_cmd : procflag_cmd;
smx_dmc_cmd_status <= `SMX_PD (rst_serve_tohdl_n)? 4'hf : 4'h0;
smx_dmc_addr <= `SMX_PD (rst_serve_tohdl_n)? tohdl_cmdl_addr : procflag_addr;
smx_dmc_len <= `SMX_PD (rst_serve_tohdl_n)? tohdl_cmdl_len : {7'h0, resp_len_n};
smx_dmc_xid <= `SMX_PD (rst_serve_tohdl_n)? tohdl_cmdl_xid : procflag_xid;
smx_dmc_port <= `SMX_PD (rst_serve_tohdl_n)? tohdl_cmdl_port : procflag_port;
smx_dmc_dma <= `SMX_PD (rst_serve_tohdl_n)? tohdl_cmdl_dma : procflag_dma;
smx_dmc_client <= `SMX_PD (rst_serve_tohdl_n)? tohdl_cmdl_client : procflag_client;
// also make own copy of non dmc
// make not need this copy ???
// procflag_sop_line_en_r<= `SMX_PD procflag_sop_line_en;
// procflag_eop_line_en_r<= `SMX_PD procflag_eop_line_en;
// procflag_sop_byte_en_r<= `SMX_PD procflag_sop_byte_en;
// procflag_eop_byte_en_r<= `SMX_PD procflag_eop_byte_en;
// procflag_err_r<= `SMX_PD procflag_err;
// procflag_rd_r<= `SMX_PD procflag_rd;
// procflag_with_data_r<= `SMX_PD procflag_with_data;
// procflag_xcomp_r<= `SMX_PD procflag_xcomp;
// procflag_sop_r<= `SMX_PD procflag_sop;
// procflag_eop_r<= `SMX_PD procflag_eop;
reg [3:0] dvflag_line_en_n;
always @ (/*AUTOSENSE*/procflag_eop or procflag_eop_line_en
or procflag_sop or procflag_sop_line_en) begin
case({procflag_sop, procflag_eop})
2'b00: dvflag_line_en_n= 4'hf; // mid of pkt
2'b01: dvflag_line_en_n= procflag_eop_line_en; // rcving eop
2'b10: dvflag_line_en_n= procflag_sop_line_en; // rcving sop
2'b11: dvflag_line_en_n= (procflag_sop_line_en & procflag_eop_line_en); // single 64B
reg [3:0] dvflag_sop_pos_n;
always @ (/*AUTOSENSE*/procflag_sop_line_en) begin
case(procflag_sop_line_en)
4'b1111: dvflag_sop_pos_n= 4'b0001;
4'b1110: dvflag_sop_pos_n= 4'b0010;
4'b1100: dvflag_sop_pos_n= 4'b0100;
4'b1000: dvflag_sop_pos_n= 4'b1000;
default: dvflag_sop_pos_n= 4'b0000;
reg [3:0] dvflag_eop_pos_n;
always @ (/*AUTOSENSE*/procflag_eop_line_en) begin
case(procflag_eop_line_en)
4'b1111: dvflag_eop_pos_n= 4'b1000;
4'b0111: dvflag_eop_pos_n= 4'b0100;
4'b0011: dvflag_eop_pos_n= 4'b0010;
4'b0001: dvflag_eop_pos_n= 4'b0001;
default: dvflag_eop_pos_n= 4'b0000;
wire [3:0] dvflag_xcomp_n;
assign dvflag_xcomp_n[3]= procflag_xcomp & dvflag_line_en_n[3];
assign dvflag_xcomp_n[2]= procflag_xcomp && (dvflag_line_en_n[3:2]==2'b01);
assign dvflag_xcomp_n[1]= procflag_xcomp && (dvflag_line_en_n[3:1]==3'b001);
assign dvflag_xcomp_n[0]= (procflag_xcomp && (dvflag_line_en_n[3:0]==4'b0001)) || // rd
(~procflag_rd && procflag_xcomp); // wr
reg [1:0] dvflag_with_data;
reg [3:0] dvflag_line_en;
reg [3:0] dvflag_sop_pos; // indicate first data line position
reg [3:0] dvflag_eop_pos; // indicate last data line position
reg [15:0] dvflag_sop_byte_en; // use this for 'first' data line
reg [15:0] dvflag_eop_byte_en; // use this for 'last' data line
reg [1:0] early_dvflag_with_data; // 1= rd (data,dv also sio dq) ,
// 0= wr/rderr (sio dq only)
reg [3:0] early_dvflag_line_en;
reg [3:0] early_dvflag_sop_pos; // indicate first data line position
reg [3:0] early_dvflag_eop_pos; // indicate last data line position
reg [15:0] early_dvflag_sop_byte_en; // use this for 'first' data line
reg [15:0] early_dvflag_eop_byte_en; // use this for 'last' data line
reg [7:0] early_dvflag_client;
reg [3:0] early_dvflag_xcomp;
reg [3:0] early_dvflag_status;
wire procflag_err_0_cond= proc_tid_is_dirty? 1'b1 : procflag_err[0];
always @(posedge clk) begin
if(rst_procflag_n) begin // make early dvflag_xxx
early_dvflag_with_data<= `SMX_PD {procflag_rd, procflag_with_data};
early_dvflag_line_en<= `SMX_PD dvflag_line_en_n;
// if rcving sop, sop at line X, else 0
early_dvflag_sop_pos<= `SMX_PD (procflag_sop)? dvflag_sop_pos_n : 4'h0;
// if rcving eop, eop at line X, else 0
early_dvflag_eop_pos<= `SMX_PD (procflag_eop)? dvflag_eop_pos_n : 4'h0;
// if 1 in sop/eop_pos , use sop/eop_byte_en
early_dvflag_sop_byte_en<= `SMX_PD decode_sop_16b_byte_en_little(procflag_sop_byte_en);
early_dvflag_eop_byte_en<= `SMX_PD decode_eop_16b_byte_en_little(procflag_eop_byte_en);
early_dvflag_xcomp<= `SMX_PD dvflag_xcomp_n;
early_dvflag_status<= `SMX_PD {1'b0, procflag_err[2:1],procflag_err_0_cond}; // extract from procflag_err
early_dvflag_client<= `SMX_PD procflag_client;
dvflag_with_data<= `SMX_PD (cmdl_tohdl_ack_n)? {~tohdl_cmdl_xid[5], 1'b0} :
dvflag_line_en<= `SMX_PD (cmdl_tohdl_ack_n)? 4'h0 : early_dvflag_line_en;
dvflag_sop_pos<= `SMX_PD (cmdl_tohdl_ack_n)? 4'h0: early_dvflag_sop_pos;
dvflag_eop_pos<= `SMX_PD (cmdl_tohdl_ack_n)? 4'h0: early_dvflag_eop_pos;
dvflag_sop_byte_en<= `SMX_PD (cmdl_tohdl_ack_n)? 16'h0: early_dvflag_sop_byte_en;
dvflag_eop_byte_en<= `SMX_PD (cmdl_tohdl_ack_n)? 16'h0: early_dvflag_eop_byte_en;
dvflag_xcomp<= `SMX_PD (cmdl_tohdl_ack_n)? 4'h1 : early_dvflag_xcomp;
dvflag_status<= `SMX_PD (cmdl_tohdl_ack_n)? 4'h0 : early_dvflag_status;
dvflag_client<= `SMX_PD (cmdl_tohdl_ack_n)? tohdl_cmdl_client : early_dvflag_client;
??? note if need to have bubble between accept and dv,
need to put this back; right now, dv assert immediate
or simply hard code dv_idle to 0;
if(set_dvflag_n) begin // right hand side all xx_r; gen dvflag_xx late
// remember to chg dvflag_xx_n above to use _r if wanna use this
// line_en_n, eop/sop_pos_n....
dvflag_with_data<= `SMX_PD procflag_with_data_r;
dvflag_line_en<= `SMX_PD dvflag_line_en_n;
dvflag_sop_pos<= `SMX_PD (procflag_sop_r)? dvflag_sop_pos_n : 4'h0;
dvflag_eop_pos<= `SMX_PD (procflag_eop_r)? dvflag_eop_pos_n : 4'h0;
dvflag_sop_byte_en<= `SMX_PD decode_sop_16b_byte_en_big(procflag_sop_byte_en_r);
dvflag_eop_byte_en<= `SMX_PD decode_eop_16b_byte_en_big(procflag_eop_byte_en_r);
dvflag_xcomp<= `SMX_PD procflag_xcomp_r;
dvflag_status<= `SMX_PD 4'h0; // extract from procflag_err ???;
dvflag_client<= `SMX_PD smx_dmc_client;
// adj resp_len to be actual len
// not sure if timing can be a problem ??
wire [1:0] sum_line_en_n= {1'b0, dvflag_line_en_n[0]} +
{1'b0, dvflag_line_en_n[1]} +
{1'b0, dvflag_line_en_n[2]} +
{1'b0, dvflag_line_en_n[3]};
reg [6:0] sum_line_en_in_byte_n; // line_en in bytes
always @(/*AUTOSENSE*/sum_line_en_n) begin
2'h0: sum_line_en_in_byte_n= 7'd64;
2'h1: sum_line_en_in_byte_n= 7'd16;
2'h2: sum_line_en_in_byte_n= 7'd32;
2'h3: sum_line_en_in_byte_n= 7'd48;
default: sum_line_en_in_byte_n= 7'd64;
//wire [4:0] sop_firstline_in_byte_n= 5'd16 - {1'b0, procflag_sop_byte_en};
wire [4:0] sop_firstline_notuse_in_byte_n= {1'b0, procflag_sop_byte_en};
wire [4:0] eop_lastline_in_byte_n= (|procflag_eop_byte_en)?
{1'b0, procflag_eop_byte_en} : 5'd16;
wire [4:0] eop_lastline_notuse_in_byte_n= 5'd16 - eop_lastline_in_byte_n;
always @(/*AUTOSENSE*/eop_lastline_notuse_in_byte_n or procflag_eop
or procflag_sop or sop_firstline_notuse_in_byte_n
or sum_line_en_in_byte_n) begin
case({procflag_sop, procflag_eop})
2'h0: resp_len_n= sum_line_en_in_byte_n; // mid resp
2'h1: resp_len_n= sum_line_en_in_byte_n - {2'h0, eop_lastline_notuse_in_byte_n}; // eop
2'h2: resp_len_n= sum_line_en_in_byte_n - {2'h0, sop_firstline_notuse_in_byte_n}; // sop
2'h3: resp_len_n= sum_line_en_in_byte_n - {2'h0, sop_firstline_notuse_in_byte_n}
- {2'h0, eop_lastline_notuse_in_byte_n};
// sop/eop in this resp chunk
default: resp_len_n= 7'd64;
projects / OpenSPARC-T2-DV / blob