// ========== 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 // have any questions. // // ========== Copyright Header End ============================================ module niu_smx_sm_resp_cmdlaunch( /*AUTOARG*/ // Outputs 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_cmd_status, smx_dmc_ack_xid, smx_dmc_ack_dma, 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, cmdl_tohdl_ack, cmdl_cs, // Inputs 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 ); input clk; input reset_l; // dmc if output smx_dmc_rdy; 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; // ack if output smx_dmc_ack_rdy; 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; // cmdproc if input procflag; 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 input procflag_xcomp; input procflag_sop; input procflag_eop; output rst_procflag; // output cmdlaunch_idle; // in case need save 1 cycle at start // input early_procflag; // input [150:0] early_procflag_data; // not use for now // dv if output dvflag; 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 rst_dvflag; input dv_idle; // dv in idle state output early_dvflag; // dv needs to be in idle to catch this pulse // and dvflag not set 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; // TO handler if input tohdl_cmdl_req; 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; output cmdl_tohdl_ack; output [2:0] cmdl_cs; // status i/f input [63:0] tid_dirty_rdata_bus; function [15:0] decode_eop_16b_byte_en_little; // B15,B14..,B1,B0 input [3:0] offset; reg [15:0] byte_en; begin case(offset) 4'h0: byte_en= 16'hffff; 4'h1: byte_en= 16'h1; 4'h2: byte_en= 16'h3; 4'h3: byte_en= 16'h7; 4'h4: byte_en= 16'hf; 4'h5: byte_en= 16'h1f; 4'h6: byte_en= 16'h3f; 4'h7: byte_en= 16'h7f; 4'h8: byte_en= 16'hff; 4'h9: byte_en= 16'h1ff; 4'ha: byte_en= 16'h3ff; 4'hb: byte_en= 16'h7ff; 4'hc: byte_en= 16'hfff; 4'hd: byte_en= 16'h1fff; 4'he: byte_en= 16'h3fff; 4'hf: byte_en= 16'h7fff; endcase decode_eop_16b_byte_en_little= byte_en; end endfunction function [15:0] decode_sop_16b_byte_en_little; // B15,B14..,B1,B0 input [3:0] offset; reg [15:0] byte_en; begin case(offset) 4'h0: byte_en= 16'hffff; 4'h1: byte_en= 16'hfffe; 4'h2: byte_en= 16'hfffc; 4'h3: byte_en= 16'hfff8; 4'h4: byte_en= 16'hfff0; 4'h5: byte_en= 16'hffe0; 4'h6: byte_en= 16'hffc0; 4'h7: byte_en= 16'hff80; 4'h8: byte_en= 16'hff00; 4'h9: byte_en= 16'hfe00; 4'ha: byte_en= 16'hfc00; 4'hb: byte_en= 16'hf800; 4'hc: byte_en= 16'hf000; 4'hd: byte_en= 16'he000; 4'he: byte_en= 16'hc000; 4'hf: byte_en= 16'h8000; endcase decode_sop_16b_byte_en_little= byte_en; end endfunction /* function [15:0] decode_eop_16b_byte_en_big; // B0,B1...,B14,B15 input [3:0] offset; reg [15:0] byte_en; begin case(offset) 4'h0: byte_en= 16'hffff; 4'h1: byte_en= 16'h8000; 4'h2: byte_en= 16'hc000; 4'h3: byte_en= 16'he000; 4'h4: byte_en= 16'hf000; 4'h5: byte_en= 16'hf800; 4'h6: byte_en= 16'hfc00; 4'h7: byte_en= 16'hfe00; 4'h8: byte_en= 16'hff00; 4'h9: byte_en= 16'hff80; 4'ha: byte_en= 16'hffc0; 4'hb: byte_en= 16'hffe0; 4'hc: byte_en= 16'hfff0; 4'hd: byte_en= 16'hfff8; 4'he: byte_en= 16'hfffc; 4'hf: byte_en= 16'hfffe; endcase decode_eop_16b_byte_en_big= byte_en; end endfunction function [15:0] decode_sop_16b_byte_en_big; // B0,B1...,B14,B15 input [3:0] offset; reg [15:0] byte_en; begin case(offset) 4'h0: byte_en= 16'hffff; 4'h1: byte_en= 16'h7fff; 4'h2: byte_en= 16'h3fff; 4'h3: byte_en= 16'h1fff; 4'h4: byte_en= 16'h0fff; 4'h5: byte_en= 16'h07ff; 4'h6: byte_en= 16'h03ff; 4'h7: byte_en= 16'h01ff; 4'h8: byte_en= 16'h00ff; 4'h9: byte_en= 16'h007f; 4'ha: byte_en= 16'h003f; 4'hb: byte_en= 16'h001f; 4'hc: byte_en= 16'h000f; 4'hd: byte_en= 16'h0007; 4'he: byte_en= 16'h0003; 4'hf: byte_en= 16'h0001; endcase decode_sop_16b_byte_en_big= byte_en; end endfunction */ parameter cmdl_s0= 3'h0, cmdl_s1= 3'h1, cmdl_s2= 3'h2, cmdl_s3= 3'h3, cmdl_s4= 3'h4; wire client_accept_n= (|(dmc_smx_accept & smx_dmc_client)) | (|(dmc_smx_ack_accept & smx_dmc_ack_client)); reg early_dvflag_n; wire early_dvflag= early_dvflag_n; reg rst_procflag_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 ld_dmc_n; reg set_dvflag_n; reg dvflag; reg [2:0] cmdl_ns, cmdl_cs; wire cmdl_req_n= procflag && !dvflag; reg rst_serve_tohdl_n; reg cmdl_tohdl_ack_n; wire cmdl_tohdl_ack= cmdl_tohdl_ack_n; reg serve_tohdl; 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 early_dvflag_n= 1'b0; rst_procflag_n= 1'b0; rst_serve_tohdl_n= 1'b0; cmdl_tohdl_ack_n= 1'b0; cmdl_ns= cmdl_cs; case(cmdl_cs) cmdl_s0: begin // wait procflag & !dvflag // gen early_dvflag_xx using procflag_xx // err ??? time share this with // err handle; // 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; end else begin if(procflag && !dvflag) begin // flop in procflag_xx (->early_dvflag_xx) rst_procflag_n= 1'b1; if(procflag_err[0] | proc_tid_is_dirty) begin // pkterr; drop pkt cmdl_ns= cmdl_s2; end else begin // launch cmd if(procflag_rd) // rd smx_dmc_rdy_n= 1'b1; else // wr smx_dmc_ack_rdy_n= 1'b1; ld_dmc_n= 1'b1; // flop out dmc cmd bus cmdl_ns= cmdl_s1; end end end end 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 else set_dvflag_n= 1'b1; smx_dmc_rdy_n= 1'b0; // put all rdy to 0 smx_dmc_ack_rdy_n= 1'b0; cmdl_ns= cmdl_s0; end end cmdl_s2: begin // pkterr; drop pkt set_dvflag_n= 1'b1; cmdl_ns= cmdl_s0; end cmdl_s3: begin // TO hdlr rst_serve_tohdl_n= 1'b1; ld_dmc_n= 1'b1; if(tohdl_cmdl_xid[5]) // wr smx_dmc_ack_rdy_n= 1'b1; else smx_dmc_rdy_n= 1'b1; cmdl_ns= cmdl_s4; end cmdl_s4: begin if(client_accept_n) begin set_dvflag_n= 1'b1; smx_dmc_rdy_n= 1'b0; // put all rdy to 0 smx_dmc_ack_rdy_n= 1'b0; cmdl_tohdl_ack_n= 1'b1; cmdl_ns= cmdl_s0; end end endcase end always @(posedge clk) begin if(!reset_l) begin cmdl_cs<= `SMX_PD cmdl_s0; smx_dmc_rdy<= `SMX_PD 1'b0; smx_dmc_ack_rdy<= `SMX_PD 1'b0; dvflag<= `SMX_PD 1'b0; serve_tohdl<= `SMX_PD 1'b0; end else begin 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; end end // 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_rd_r; // reg procflag_with_data_r; // reg procflag_xcomp_r; // reg procflag_sop_r; // reg procflag_eop_r; reg [7:0] smx_dmc_cmd; reg [3:0] smx_dmc_cmd_status; reg [63:0] smx_dmc_addr; reg [13:0] smx_dmc_len; reg [5:0] smx_dmc_xid; reg [1:0] smx_dmc_port; reg [4:0] smx_dmc_dma; 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 [6:0] resp_len_n; 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; end end 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; end end 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 endcase end reg [3:0] dvflag_sop_pos_n; always @ (/*AUTOSENSE*/procflag_sop_line_en) begin dvflag_sop_pos_n= 4'h0; 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; endcase end reg [3:0] dvflag_eop_pos_n; always @ (/*AUTOSENSE*/procflag_eop_line_en) begin dvflag_eop_pos_n= 4'h0; 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; endcase end 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 [7:0] dvflag_client; reg [3:0] dvflag_xcomp; reg [3:0] dvflag_status; 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; end if(set_dvflag_n) begin dvflag_with_data<= `SMX_PD (cmdl_tohdl_ack_n)? {~tohdl_cmdl_xid[5], 1'b0} : early_dvflag_with_data; 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; end /* ??? note if need to have bubble between accept and dv, need to put this back; right now, dv assert immediate after accpet ??? or simply hard code dv_idle to 0; if(set_dvflag_n) begin // right hand side all xx_r; gen dvflag_xx late // important!! // remember to chg dvflag_xx_n above to use _r if wanna use this // line_en_n, eop/sop_pos_n.... // important!! 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; end */ end // 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 case(sum_line_en_n) 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; endcase end //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; endcase end endmodule