IPCores/lm32_cpu / files

     1.1 diff -r 000000000000 -r cd0b58aa6f83 JTAGB.v
     1.2 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.3 +++ b/JTAGB.v	Sun Apr 04 20:40:03 2010 +0100
     1.4 @@ -0,0 +1,42 @@
     1.5 +// =============================================================================
     1.6 +//                           COPYRIGHT NOTICE
     1.7 +// Copyright 2006 (c) Lattice Semiconductor Corporation
     1.8 +// ALL RIGHTS RESERVED
     1.9 +// This confidential and proprietary software may be used only as authorised by
    1.10 +// a licensing agreement from Lattice Semiconductor Corporation.
    1.11 +// The entire notice above must be reproduced on all authorized copies and
    1.12 +// copies may only be made to the extent permitted by a licensing agreement from
    1.13 +// Lattice Semiconductor Corporation.
    1.14 +//
    1.15 +// Lattice Semiconductor Corporation        TEL : 1-800-Lattice (USA and Canada)
    1.16 +// 5555 NE Moore Court                            408-826-6000 (other locations)
    1.17 +// Hillsboro, OR 97124                     web  : http://www.latticesemi.com/
    1.18 +// U.S.A                                   email: techsupport@latticesemi.com
    1.19 +// =============================================================================/
    1.20 +//                         FILE DETAILS
    1.21 +// Project          : LatticeMico32
    1.22 +// File             : JTAGB.v
    1.23 +// Title            : JTAGB Black Box
    1.24 +// Dependencies     : None
    1.25 +// Version          : 6.0.14
    1.26 +//                  : Initial Release
    1.27 +// Version          : 7.0SP2, 3.0
    1.28 +//                  : No Change
    1.29 +// Version          : 3.1
    1.30 +//                  : No Change
    1.31 +// =============================================================================
    1.32 +module JTAGB (
    1.33 +         output JTCK,
    1.34 +         output JRTI1,
    1.35 +         output JRTI2,
    1.36 +         output JTDI,
    1.37 +         output JSHIFT,
    1.38 +         output JUPDATE,
    1.39 +         output JRSTN,
    1.40 +         output JCE1,
    1.41 +         output JCE2,
    1.42 +         input JTDO1,
    1.43 +         input JTDO2
    1.44 +      ) /*synthesis syn_black_box */; 
    1.45 +      
    1.46 +endmodule

     2.1 diff -r 000000000000 -r cd0b58aa6f83 er1.v
     2.2 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.3 +++ b/er1.v	Sun Apr 04 20:40:03 2010 +0100
     2.4 @@ -0,0 +1,230 @@
     2.5 +// =============================================================================
     2.6 +//                           COPYRIGHT NOTICE
     2.7 +// Copyright 2006 (c) Lattice Semiconductor Corporation
     2.8 +// ALL RIGHTS RESERVED
     2.9 +// This confidential and proprietary software may be used only as authorised by
    2.10 +// a licensing agreement from Lattice Semiconductor Corporation.
    2.11 +// The entire notice above must be reproduced on all authorized copies and
    2.12 +// copies may only be made to the extent permitted by a licensing agreement from
    2.13 +// Lattice Semiconductor Corporation.
    2.14 +//
    2.15 +// Lattice Semiconductor Corporation        TEL : 1-800-Lattice (USA and Canada)
    2.16 +// 5555 NE Moore Court                            408-826-6000 (other locations)
    2.17 +// Hillsboro, OR 97124                     web  : http://www.latticesemi.com/
    2.18 +// U.S.A                                   email: techsupport@latticesemi.com
    2.19 +// =============================================================================/
    2.20 +//                         FILE DETAILS
    2.21 +// Project          : LatticeMico32
    2.22 +// File             : er1.v
    2.23 +// Description:
    2.24 +//    This module is where the ER1 register implemented. ER1 and ER2 registers
    2.25 +//    can be registers implemented in Lattice FPGAs using normal FPGA's
    2.26 +//    programmable logic resources.  Once they are implemented, they can be
    2.27 +//    accessed as if they are JTAG data registers through the FPGA JTAG port.
    2.28 +//    In order to accessing these registers, JTAG instructions ER1(0x32) or
    2.29 +//    ER2(0x38) needs to be written to the JTAG IR register for enabling the
    2.30 +//    ER1/ER2 accessing logic.  The ER1 or ER2 accessing logic can only be
    2.31 +//    enabled one at a time.  Once they are enabled, they will be disabled if
    2.32 +//    another JTAG instruction is written into the JTAG instruction register.
    2.33 +//    The registers allow dynamically accessing the FPGA internal information
    2.34 +//    even when the device is running.  Therefore, they are very useful for some
    2.35 +//    of the IP cores.  In order to let ER1/ER2 registers shared by multiple IP
    2.36 +//    cores or other designs, there is a ER1/ER2 structure patterned by Lattice.
    2.37 +//    The ER1/ER2 structure allows only one ER1 register but more than one ER2
    2.38 +//    registers in an FPGA device.  Please refer to the related document for
    2.39 +//    this patterned ER1/ER2 structure.
    2.40 +// Dependencies     : None
    2.41 +// Version          : 6.0.14
    2.42 +//                  : Initial Version
    2.43 +// Version          : 7.0SP2, 3.0
    2.44 +//                  : No Change
    2.45 +// Version          : 3.1
    2.46 +//                  : No Change
    2.47 +// =============================================================================
    2.48 +module ER1 (input  JTCK,
    2.49 +	    input  JTDI,
    2.50 +	    output JTDO1,
    2.51 +	    output reg JTDO2,
    2.52 +	    input  JSHIFT,
    2.53 +	    input  JUPDATE,
    2.54 +	    input  JRSTN,
    2.55 +	    input  JCE1,
    2.56 +	    input [14:0] ER2_TDO,
    2.57 +	    output reg [14:0] IP_ENABLE,
    2.58 +	    input  ISPTRACY_ER2_TDO,
    2.59 +	    output ISPTRACY_ENABLE,
    2.60 +	    output CONTROL_DATAN)/* synthesis syn_hier = hard */;
    2.61 +
    2.62 +
    2.63 +   wire 	   controlDataNBit;
    2.64 +   wire 	   ispTracyEnableBit;
    2.65 +   wire [3:0] 	   encodedIpEnableBits;
    2.66 +   wire [9:0] 	   er1TdiBit;
    2.67 +   wire 	   captureDrER1;
    2.68 +   
    2.69 +
    2.70 +   assign 	   JTDO1 = er1TdiBit[0];
    2.71 +   
    2.72 +   TYPEB BIT0 (.CLK(JTCK),
    2.73 +	       .RESET_N(JRSTN),
    2.74 +	       .CLKEN(JCE1),
    2.75 +	       .TDI(er1TdiBit[1]),
    2.76 +	       .TDO(er1TdiBit[0]),
    2.77 +	       .DATA_IN(1'b0),
    2.78 +	       .CAPTURE_DR(captureDrER1));
    2.79 +
    2.80 +   TYPEB BIT1 (.CLK(JTCK),
    2.81 +	       .RESET_N(JRSTN),
    2.82 +	       .CLKEN(JCE1),
    2.83 +	       .TDI(er1TdiBit[2]),
    2.84 +	       .TDO(er1TdiBit[1]),
    2.85 +	       .DATA_IN(1'b0),
    2.86 +	       .CAPTURE_DR(captureDrER1));
    2.87 +
    2.88 +   TYPEB BIT2 (.CLK(JTCK),
    2.89 +	       .RESET_N(JRSTN),
    2.90 +	       .CLKEN(JCE1),
    2.91 +	       .TDI(er1TdiBit[3]),
    2.92 +	       .TDO(er1TdiBit[2]),
    2.93 +	       .DATA_IN(1'b1),
    2.94 +	       .CAPTURE_DR(captureDrER1));
    2.95 +   
    2.96 +   TYPEA BIT3 (.CLK(JTCK),
    2.97 +	       .RESET_N(JRSTN),
    2.98 +	       .CLKEN(JCE1),
    2.99 +	       .TDI(er1TdiBit[4]),
   2.100 +	       .TDO(er1TdiBit[3]),
   2.101 +	       .DATA_OUT(controlDataNBit),
   2.102 +	       .DATA_IN(controlDataNBit),
   2.103 +	       .CAPTURE_DR(captureDrER1),
   2.104 +	       .UPDATE_DR(JUPDATE));
   2.105 +
   2.106 +   assign CONTROL_DATAN = controlDataNBit;
   2.107 +
   2.108 +   TYPEA BIT4 (.CLK(JTCK),
   2.109 +	       .RESET_N(JRSTN),
   2.110 +	       .CLKEN(JCE1),
   2.111 +	       .TDI(er1TdiBit[5]),
   2.112 +	       .TDO(er1TdiBit[4]),
   2.113 +	       .DATA_OUT(ispTracyEnableBit),
   2.114 +	       .DATA_IN(ispTracyEnableBit),
   2.115 +	       .CAPTURE_DR(captureDrER1),
   2.116 +	       .UPDATE_DR(JUPDATE)
   2.117 +	       );
   2.118 +
   2.119 +   assign ISPTRACY_ENABLE = ispTracyEnableBit;
   2.120 +
   2.121 +   TYPEA BIT5 (.CLK(JTCK),
   2.122 +	       .RESET_N(JRSTN),
   2.123 +	       .CLKEN(JCE1),
   2.124 +	       .TDI(er1TdiBit[6]),
   2.125 +	       .TDO(er1TdiBit[5]),
   2.126 +	       .DATA_OUT(encodedIpEnableBits[0]),
   2.127 +	       .DATA_IN(encodedIpEnableBits[0]),
   2.128 +	       .CAPTURE_DR(captureDrER1),
   2.129 +	       .UPDATE_DR(JUPDATE));
   2.130 +   
   2.131 +   TYPEA BIT6 (.CLK(JTCK),
   2.132 +	       .RESET_N(JRSTN),
   2.133 +	       .CLKEN(JCE1),
   2.134 +	       .TDI(er1TdiBit[7]),
   2.135 +	       .TDO(er1TdiBit[6]),
   2.136 +	       .DATA_OUT(encodedIpEnableBits[1]),
   2.137 +	       .DATA_IN(encodedIpEnableBits[1]),
   2.138 +	       .CAPTURE_DR(captureDrER1),
   2.139 +	       .UPDATE_DR(JUPDATE));
   2.140 +   
   2.141 +   TYPEA BIT7 (.CLK(JTCK),
   2.142 +	       .RESET_N(JRSTN),
   2.143 +	       .CLKEN(JCE1),
   2.144 +	       .TDI(er1TdiBit[8]),
   2.145 +	       .TDO(er1TdiBit[7]),
   2.146 +	       .DATA_OUT(encodedIpEnableBits[2]),
   2.147 +	       .DATA_IN(encodedIpEnableBits[2]),
   2.148 +	       .CAPTURE_DR(captureDrER1),
   2.149 +	       .UPDATE_DR(JUPDATE));
   2.150 +   
   2.151 +   TYPEA BIT8 (.CLK(JTCK),
   2.152 +	       .RESET_N(JRSTN),
   2.153 +	       .CLKEN(JCE1),
   2.154 +	       .TDI(er1TdiBit[9]),
   2.155 +	       .TDO(er1TdiBit[8]),
   2.156 +	       .DATA_OUT(encodedIpEnableBits[3]),
   2.157 +	       .DATA_IN(encodedIpEnableBits[3]),
   2.158 +	       .CAPTURE_DR(captureDrER1),
   2.159 +	       .UPDATE_DR(JUPDATE)
   2.160 +	       );
   2.161 +   
   2.162 +   assign er1TdiBit[9] = JTDI;
   2.163 +   assign captureDrER1  = !JSHIFT & JCE1;
   2.164 +   
   2.165 +   always @ (encodedIpEnableBits,ISPTRACY_ER2_TDO, ER2_TDO)
   2.166 +   begin
   2.167 +    case (encodedIpEnableBits)
   2.168 +      4'h0: begin 
   2.169 +      		IP_ENABLE <= 15'b000000000000000;
   2.170 +      		JTDO2 <= ISPTRACY_ER2_TDO;
   2.171 +      	    end
   2.172 +      4'h1: begin
   2.173 +      		IP_ENABLE <= 15'b000000000000001;
   2.174 +      		JTDO2 <= ER2_TDO[0];
   2.175 +      	    end	
   2.176 +      4'h2: begin
   2.177 +      		IP_ENABLE <= 15'b000000000000010;
   2.178 +      		JTDO2 <= ER2_TDO[1];
   2.179 +      	    end
   2.180 +      4'h3: begin
   2.181 +      		IP_ENABLE <= 15'b000000000000100;
   2.182 +      		JTDO2 <= ER2_TDO[2];
   2.183 +      	    end
   2.184 +      4'h4: begin
   2.185 +      		IP_ENABLE <= 15'b000000000001000;
   2.186 +      		JTDO2 <= ER2_TDO[3];
   2.187 +      	    end
   2.188 +      4'h5: begin
   2.189 +      		IP_ENABLE <= 15'b000000000010000;
   2.190 +      		JTDO2 <= ER2_TDO[4];
   2.191 +      	    end
   2.192 +      4'h6: begin
   2.193 +      		IP_ENABLE <= 15'b000000000100000;
   2.194 +      		JTDO2 <= ER2_TDO[5];
   2.195 +      	    end
   2.196 +      4'h7: begin
   2.197 +      		IP_ENABLE <= 15'b000000001000000;
   2.198 +      		JTDO2 <= ER2_TDO[6];
   2.199 +      	    end
   2.200 +      4'h8: begin
   2.201 +      		IP_ENABLE <= 15'b000000010000000;
   2.202 +      		JTDO2 <= ER2_TDO[7];
   2.203 +      	    end
   2.204 +      4'h9: begin
   2.205 +      		IP_ENABLE <= 15'b000000100000000;
   2.206 +      		JTDO2 <= ER2_TDO[8];
   2.207 +      	    end
   2.208 +      4'hA: begin
   2.209 +      		IP_ENABLE <= 15'b000001000000000;
   2.210 +      		JTDO2 <= ER2_TDO[9];
   2.211 +      	    end
   2.212 +      4'hB: begin
   2.213 +      		IP_ENABLE <= 15'b000010000000000;
   2.214 +      		JTDO2 <= ER2_TDO[10];
   2.215 +      	    end
   2.216 +      4'hC: begin
   2.217 +      		IP_ENABLE <= 15'b000100000000000;
   2.218 +      		JTDO2 <= ER2_TDO[11];
   2.219 +      	    end
   2.220 +      4'hD: begin
   2.221 +      		IP_ENABLE <= 15'b001000000000000;
   2.222 +      		JTDO2 <= ER2_TDO[12];
   2.223 +      	    end
   2.224 +      4'hE: begin
   2.225 +      		IP_ENABLE <= 15'b010000000000000;
   2.226 +      		JTDO2 <= ER2_TDO[13];
   2.227 +      	    end
   2.228 +      4'hF: begin
   2.229 +      		IP_ENABLE <= 15'b100000000000000;
   2.230 +      		JTDO2 <= ER2_TDO[14];
   2.231 +      	    end
   2.232 +    endcase
   2.233 +  end
   2.234 +endmodule

     3.1 diff -r 000000000000 -r cd0b58aa6f83 jtag_cores.v
     3.2 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.3 +++ b/jtag_cores.v	Sun Apr 04 20:40:03 2010 +0100
     3.4 @@ -0,0 +1,125 @@
     3.5 +// ============================================================================
     3.6 +//                           COPYRIGHT NOTICE
     3.7 +// Copyright 2006 (c) Lattice Semiconductor Corporation
     3.8 +// ALL RIGHTS RESERVED
     3.9 +// This confidential and proprietary software may be used only as authorised by
    3.10 +// a licensing agreement from Lattice Semiconductor Corporation.
    3.11 +// The entire notice above must be reproduced on all authorized copies and
    3.12 +// copies may only be made to the extent permitted by a licensing agreement from
    3.13 +// Lattice Semiconductor Corporation.
    3.14 +//
    3.15 +// Lattice Semiconductor Corporation        TEL : 1-800-Lattice (USA and Canada)
    3.16 +// 5555 NE Moore Court                            408-826-6000 (other locations)
    3.17 +// Hillsboro, OR 97124                     web  : http://www.latticesemi.com/
    3.18 +// U.S.A                                   email: techsupport@latticesemi.com
    3.19 +// ============================================================================/
    3.20 +//                         FILE DETAILS
    3.21 +// Project          : LatticeMico32
    3.22 +// File             : jtag_cores.v
    3.23 +// Title            : Instantiates all IP cores on JTAG chain.
    3.24 +// Dependencies     : system_conf.v
    3.25 +// Version          : 6.0.14
    3.26 +//                  : modified to use jtagconn for LM32,
    3.27 +//                  : all technologies 7/10/07
    3.28 +// Version          : 7.0SP2, 3.0
    3.29 +//                  : No Change
    3.30 +// Version          : 3.1
    3.31 +//                  : No Change
    3.32 +// ============================================================================
    3.33 +
    3.34 +`include "system_conf.v"
    3.35 +
    3.36 +/////////////////////////////////////////////////////
    3.37 +// jtagconn16 Module Definition
    3.38 +/////////////////////////////////////////////////////
    3.39 +
    3.40 +module jtagconn16 (er2_tdo, jtck, jtdi, jshift, jupdate, jrstn, jce2, ip_enable) ;
    3.41 +    input  er2_tdo ; 
    3.42 +    output jtck ; 
    3.43 +    output jtdi ; 
    3.44 +    output jshift ; 
    3.45 +    output jupdate ; 
    3.46 +    output jrstn ; 
    3.47 +    output jce2 ; 
    3.48 +    output ip_enable ; 
    3.49 +endmodule
    3.50 +
    3.51 +/////////////////////////////////////////////////////
    3.52 +// Module interface
    3.53 +/////////////////////////////////////////////////////
    3.54 +
    3.55 +(* syn_hier="hard" *) module jtag_cores (
    3.56 +    // ----- Inputs -------
    3.57 +    reg_d,
    3.58 +    reg_addr_d,
    3.59 +    // ----- Outputs -------    
    3.60 +    reg_update,
    3.61 +    reg_q,
    3.62 +    reg_addr_q,
    3.63 +    jtck,
    3.64 +    jrstn
    3.65 +    );
    3.66 +    
    3.67 +/////////////////////////////////////////////////////
    3.68 +// Inputs
    3.69 +/////////////////////////////////////////////////////
    3.70 +
    3.71 +input [7:0] reg_d;
    3.72 +input [2:0] reg_addr_d;
    3.73 +
    3.74 +/////////////////////////////////////////////////////
    3.75 +// Outputs
    3.76 +/////////////////////////////////////////////////////
    3.77 +   
    3.78 +output reg_update;
    3.79 +wire   reg_update;
    3.80 +output [7:0] reg_q;
    3.81 +wire   [7:0] reg_q;
    3.82 +output [2:0] reg_addr_q;
    3.83 +wire   [2:0] reg_addr_q;
    3.84 +
    3.85 +output jtck;
    3.86 +wire   jtck; 	/* synthesis syn_keep=1 */
    3.87 +output jrstn;
    3.88 +wire   jrstn;  /* synthesis syn_keep=1 */	
    3.89 +
    3.90 +/////////////////////////////////////////////////////
    3.91 +// Instantiations
    3.92 +/////////////////////////////////////////////////////
    3.93 +
    3.94 +wire jtdi;          /* synthesis syn_keep=1 */
    3.95 +wire er2_tdo2;      /* synthesis syn_keep=1 */
    3.96 +wire jshift;        /* synthesis syn_keep=1 */
    3.97 +wire jupdate;       /* synthesis syn_keep=1 */
    3.98 +wire jce2;          /* synthesis syn_keep=1 */
    3.99 +wire ip_enable;     /* synthesis syn_keep=1 */
   3.100 +    
   3.101 +(* JTAG_IP="LM32", IP_ID="0", HUB_ID="0", syn_noprune=1 *) jtagconn16 jtagconn16_lm32_inst (
   3.102 +    .er2_tdo        (er2_tdo2),
   3.103 +    .jtck           (jtck),
   3.104 +    .jtdi           (jtdi),
   3.105 +    .jshift         (jshift),
   3.106 +    .jupdate        (jupdate),
   3.107 +    .jrstn          (jrstn),
   3.108 +    .jce2           (jce2),
   3.109 +    .ip_enable      (ip_enable)
   3.110 +);
   3.111 +    
   3.112 +(* syn_noprune=1 *) jtag_lm32 jtag_lm32_inst (
   3.113 +    .JTCK           (jtck),
   3.114 +    .JTDI           (jtdi),
   3.115 +    .JTDO2          (er2_tdo2),
   3.116 +    .JSHIFT         (jshift),
   3.117 +    .JUPDATE        (jupdate),
   3.118 +    .JRSTN          (jrstn),
   3.119 +    .JCE2           (jce2),
   3.120 +    .JTAGREG_ENABLE (ip_enable),
   3.121 +    .CONTROL_DATAN  (),
   3.122 +    .REG_UPDATE     (reg_update),
   3.123 +    .REG_D          (reg_d),
   3.124 +    .REG_ADDR_D     (reg_addr_d),
   3.125 +    .REG_Q          (reg_q),
   3.126 +    .REG_ADDR_Q     (reg_addr_q)
   3.127 +    );
   3.128 +    
   3.129 +endmodule

     4.1 diff -r 000000000000 -r cd0b58aa6f83 jtag_lm32.v
     4.2 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.3 +++ b/jtag_lm32.v	Sun Apr 04 20:40:03 2010 +0100
     4.4 @@ -0,0 +1,200 @@
     4.5 +// =============================================================================
     4.6 +//                           COPYRIGHT NOTICE
     4.7 +// Copyright 2006 (c) Lattice Semiconductor Corporation
     4.8 +// ALL RIGHTS RESERVED
     4.9 +// This confidential and proprietary software may be used only as authorised by
    4.10 +// a licensing agreement from Lattice Semiconductor Corporation.
    4.11 +// The entire notice above must be reproduced on all authorized copies and
    4.12 +// copies may only be made to the extent permitted by a licensing agreement from
    4.13 +// Lattice Semiconductor Corporation.
    4.14 +//
    4.15 +// Lattice Semiconductor Corporation        TEL : 1-800-Lattice (USA and Canada)
    4.16 +// 5555 NE Moore Court                            408-826-6000 (other locations)
    4.17 +// Hillsboro, OR 97124                     web  : http://www.latticesemi.com/
    4.18 +// U.S.A                                   email: techsupport@latticesemi.com
    4.19 +// =============================================================================/
    4.20 +//                         FILE DETAILS
    4.21 +// Project          : LatticeMico32
    4.22 +// File             : jtag_lm32.v
    4.23 +// Title            : JTAG data register for LM32 CPU debug interface
    4.24 +// Version          : 6.0.13
    4.25 +//                  : Initial Release
    4.26 +// Version          : 7.0SP2, 3.0
    4.27 +//                  : No Change
    4.28 +// Version          : 3.1
    4.29 +//                  : No Change
    4.30 +// =============================================================================
    4.31 +
    4.32 +/////////////////////////////////////////////////////
    4.33 +// Module interface
    4.34 +/////////////////////////////////////////////////////
    4.35 +
    4.36 +module jtag_lm32 (
    4.37 +	input JTCK,
    4.38 +	input JTDI,
    4.39 +	output JTDO2,
    4.40 +	input JSHIFT,
    4.41 +	input JUPDATE,
    4.42 +	input JRSTN,
    4.43 +	input JCE2,
    4.44 +	input JTAGREG_ENABLE,
    4.45 +	input CONTROL_DATAN,
    4.46 +	output REG_UPDATE,
    4.47 +	input [7:0] REG_D,
    4.48 +	input [2:0] REG_ADDR_D,
    4.49 +	output [7:0] REG_Q,
    4.50 +	output [2:0] REG_ADDR_Q
    4.51 +	);
    4.52 +
    4.53 +/////////////////////////////////////////////////////
    4.54 +// Internal nets and registers 
    4.55 +/////////////////////////////////////////////////////
    4.56 +
    4.57 +wire [9:0] tdibus;
    4.58 +
    4.59 +/////////////////////////////////////////////////////
    4.60 +// Instantiations
    4.61 +/////////////////////////////////////////////////////
    4.62 +   
    4.63 +TYPEA DATA_BIT0 (
    4.64 +    .CLK(JTCK),
    4.65 +    .RESET_N(JRSTN),
    4.66 +    .CLKEN(clk_enable),
    4.67 +    .TDI(JTDI),
    4.68 +    .TDO(tdibus[0]),
    4.69 +    .DATA_OUT(REG_Q[0]),
    4.70 +    .DATA_IN(REG_D[0]),
    4.71 +    .CAPTURE_DR(captureDr),
    4.72 +    .UPDATE_DR(JUPDATE)
    4.73 +    );
    4.74 +
    4.75 +TYPEA DATA_BIT1 (
    4.76 +    .CLK(JTCK),
    4.77 +    .RESET_N(JRSTN),
    4.78 +    .CLKEN(clk_enable),
    4.79 +    .TDI(tdibus[0]),
    4.80 +    .TDO(tdibus[1]),
    4.81 +    .DATA_OUT(REG_Q[1]),
    4.82 +    .DATA_IN(REG_D[1]),
    4.83 +    .CAPTURE_DR(captureDr),
    4.84 +    .UPDATE_DR(JUPDATE)
    4.85 +    );
    4.86 +
    4.87 +TYPEA DATA_BIT2 (
    4.88 +    .CLK(JTCK),
    4.89 +    .RESET_N(JRSTN),
    4.90 +    .CLKEN(clk_enable),
    4.91 +    .TDI(tdibus[1]),
    4.92 +    .TDO(tdibus[2]),
    4.93 +    .DATA_OUT(REG_Q[2]),
    4.94 +    .DATA_IN(REG_D[2]),
    4.95 +    .CAPTURE_DR(captureDr),
    4.96 +    .UPDATE_DR(JUPDATE)
    4.97 +    );
    4.98 +
    4.99 +TYPEA DATA_BIT3 (
   4.100 +    .CLK(JTCK),
   4.101 +    .RESET_N(JRSTN),
   4.102 +    .CLKEN(clk_enable),
   4.103 +    .TDI(tdibus[2]),
   4.104 +    .TDO(tdibus[3]),
   4.105 +    .DATA_OUT(REG_Q[3]),
   4.106 +    .DATA_IN(REG_D[3]),
   4.107 +    .CAPTURE_DR(captureDr),
   4.108 +    .UPDATE_DR(JUPDATE)
   4.109 +    );
   4.110 +
   4.111 +TYPEA DATA_BIT4 (
   4.112 +    .CLK(JTCK),
   4.113 +    .RESET_N(JRSTN),
   4.114 +    .CLKEN(clk_enable),
   4.115 +    .TDI(tdibus[3]),
   4.116 +    .TDO(tdibus[4]),
   4.117 +    .DATA_OUT(REG_Q[4]),
   4.118 +    .DATA_IN(REG_D[4]),
   4.119 +    .CAPTURE_DR(captureDr),
   4.120 +    .UPDATE_DR(JUPDATE)
   4.121 +    );
   4.122 +
   4.123 +TYPEA DATA_BIT5 (
   4.124 +    .CLK(JTCK),
   4.125 +    .RESET_N(JRSTN),
   4.126 +    .CLKEN(clk_enable),
   4.127 +    .TDI(tdibus[4]),
   4.128 +    .TDO(tdibus[5]),
   4.129 +    .DATA_OUT(REG_Q[5]),
   4.130 +    .DATA_IN(REG_D[5]),
   4.131 +    .CAPTURE_DR(captureDr),
   4.132 +    .UPDATE_DR(JUPDATE)
   4.133 +    );
   4.134 +
   4.135 +TYPEA DATA_BIT6 (
   4.136 +    .CLK(JTCK),
   4.137 +    .RESET_N(JRSTN),
   4.138 +    .CLKEN(clk_enable),
   4.139 +    .TDI(tdibus[5]),
   4.140 +    .TDO(tdibus[6]),
   4.141 +    .DATA_OUT(REG_Q[6]),
   4.142 +    .DATA_IN(REG_D[6]),
   4.143 +    .CAPTURE_DR(captureDr),
   4.144 +    .UPDATE_DR(JUPDATE)
   4.145 +    );
   4.146 +
   4.147 +TYPEA DATA_BIT7 (
   4.148 +    .CLK(JTCK),
   4.149 +    .RESET_N(JRSTN),
   4.150 +    .CLKEN(clk_enable),
   4.151 +    .TDI(tdibus[6]),
   4.152 +    .TDO(tdibus[7]),
   4.153 +    .DATA_OUT(REG_Q[7]),
   4.154 +    .DATA_IN(REG_D[7]),
   4.155 +    .CAPTURE_DR(captureDr),
   4.156 +    .UPDATE_DR(JUPDATE)
   4.157 +    );
   4.158 +
   4.159 +TYPEA ADDR_BIT0 (
   4.160 +    .CLK(JTCK),
   4.161 +    .RESET_N(JRSTN),
   4.162 +    .CLKEN(clk_enable),
   4.163 +    .TDI(tdibus[7]),
   4.164 +    .TDO(tdibus[8]),
   4.165 +    .DATA_OUT(REG_ADDR_Q[0]),
   4.166 +    .DATA_IN(REG_ADDR_D[0]),
   4.167 +    .CAPTURE_DR(captureDr),
   4.168 +    .UPDATE_DR(JUPDATE)
   4.169 +    );
   4.170 +
   4.171 +TYPEA ADDR_BIT1 (
   4.172 +    .CLK(JTCK),
   4.173 +    .RESET_N(JRSTN),
   4.174 +    .CLKEN(clk_enable),
   4.175 +    .TDI(tdibus[8]),
   4.176 +    .TDO(tdibus[9]),
   4.177 +    .DATA_OUT(REG_ADDR_Q[1]),
   4.178 +    .DATA_IN(REG_ADDR_D[1]),
   4.179 +    .CAPTURE_DR(captureDr),
   4.180 +    .UPDATE_DR(JUPDATE)
   4.181 +    );
   4.182 +
   4.183 +TYPEA ADDR_BIT2 (
   4.184 +    .CLK(JTCK),
   4.185 +    .RESET_N(JRSTN),
   4.186 +    .CLKEN(clk_enable),
   4.187 +    .TDI(tdibus[9]),
   4.188 +    .TDO(JTDO2),
   4.189 +    .DATA_OUT(REG_ADDR_Q[2]),
   4.190 +    .DATA_IN(REG_ADDR_D[2]),
   4.191 +    .CAPTURE_DR(captureDr),
   4.192 +    .UPDATE_DR(JUPDATE)
   4.193 +    );
   4.194 +
   4.195 +/////////////////////////////////////////////////////
   4.196 +// Combinational logic
   4.197 +/////////////////////////////////////////////////////
   4.198 +
   4.199 +assign clk_enable = JTAGREG_ENABLE & JCE2;
   4.200 +assign captureDr = !JSHIFT & JCE2;
   4.201 +// JCE2 is only active during shift
   4.202 +assign REG_UPDATE = JTAGREG_ENABLE & JUPDATE;
   4.203 + 
   4.204 +endmodule

     5.1 diff -r 000000000000 -r cd0b58aa6f83 lm32_adder.v
     5.2 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.3 +++ b/lm32_adder.v	Sun Apr 04 20:40:03 2010 +0100
     5.4 @@ -0,0 +1,115 @@
     5.5 +// =============================================================================
     5.6 +//                           COPYRIGHT NOTICE
     5.7 +// Copyright 2006 (c) Lattice Semiconductor Corporation
     5.8 +// ALL RIGHTS RESERVED
     5.9 +// This confidential and proprietary software may be used only as authorised by
    5.10 +// a licensing agreement from Lattice Semiconductor Corporation.
    5.11 +// The entire notice above must be reproduced on all authorized copies and
    5.12 +// copies may only be made to the extent permitted by a licensing agreement from
    5.13 +// Lattice Semiconductor Corporation.
    5.14 +//
    5.15 +// Lattice Semiconductor Corporation        TEL : 1-800-Lattice (USA and Canada)
    5.16 +// 5555 NE Moore Court                            408-826-6000 (other locations)
    5.17 +// Hillsboro, OR 97124                     web  : http://www.latticesemi.com/
    5.18 +// U.S.A                                   email: techsupport@latticesemi.com
    5.19 +// ============================================================================/
    5.20 +//                         FILE DETAILS
    5.21 +// Project          : LatticeMico32
    5.22 +// File             : lm32_adder.v
    5.23 +// Title            : Integer adder / subtractor with comparison flag generation 
    5.24 +// Dependencies     : lm32_include.v
    5.25 +// Version          : 6.1.17
    5.26 +//                  : Initial Release
    5.27 +// Version          : 7.0SP2, 3.0
    5.28 +//                  : No Change
    5.29 +// Version          : 3.1
    5.30 +//                  : No Change
    5.31 +// =============================================================================
    5.32 +
    5.33 +`include "lm32_include.v"
    5.34 +
    5.35 +/////////////////////////////////////////////////////
    5.36 +// Module interface
    5.37 +/////////////////////////////////////////////////////
    5.38 +
    5.39 +module lm32_adder (
    5.40 +    // ----- Inputs -------
    5.41 +    adder_op_x,
    5.42 +    adder_op_x_n,
    5.43 +    operand_0_x,
    5.44 +    operand_1_x,
    5.45 +    // ----- Outputs -------
    5.46 +    adder_result_x,
    5.47 +    adder_carry_n_x,
    5.48 +    adder_overflow_x
    5.49 +    );
    5.50 +
    5.51 +/////////////////////////////////////////////////////
    5.52 +// Inputs
    5.53 +/////////////////////////////////////////////////////
    5.54 +
    5.55 +input adder_op_x;                                       // Operating to perform, 0 for addition, 1 for subtraction
    5.56 +input adder_op_x_n;                                     // Inverted version of adder_op_x
    5.57 +input [`LM32_WORD_RNG] operand_0_x;                     // Operand to add, or subtract from
    5.58 +input [`LM32_WORD_RNG] operand_1_x;                     // Opearnd to add, or subtract by
    5.59 +
    5.60 +/////////////////////////////////////////////////////
    5.61 +// Outputs
    5.62 +/////////////////////////////////////////////////////
    5.63 +
    5.64 +output [`LM32_WORD_RNG] adder_result_x;                 // Result of addition or subtraction
    5.65 +wire   [`LM32_WORD_RNG] adder_result_x;
    5.66 +output adder_carry_n_x;                                 // Inverted carry
    5.67 +wire   adder_carry_n_x;
    5.68 +output adder_overflow_x;                                // Indicates if overflow occured, only valid for subtractions
    5.69 +reg    adder_overflow_x;
    5.70 +    
    5.71 +/////////////////////////////////////////////////////
    5.72 +// Internal nets and registers 
    5.73 +/////////////////////////////////////////////////////
    5.74 +
    5.75 +wire a_sign;                                            // Sign (i.e. positive or negative) of operand 0
    5.76 +wire b_sign;                                            // Sign of operand 1
    5.77 +wire result_sign;                                       // Sign of result
    5.78 +
    5.79 +/////////////////////////////////////////////////////
    5.80 +// Instantiations 
    5.81 +/////////////////////////////////////////////////////
    5.82 +
    5.83 +lm32_addsub addsub (
    5.84 +    // ----- Inputs -----
    5.85 +    .DataA          (operand_0_x), 
    5.86 +    .DataB          (operand_1_x), 
    5.87 +    .Cin            (adder_op_x), 
    5.88 +    .Add_Sub        (adder_op_x_n), 
    5.89 +    // ----- Ouputs -----
    5.90 +    .Result         (adder_result_x), 
    5.91 +    .Cout           (adder_carry_n_x)
    5.92 +    );
    5.93 +
    5.94 +/////////////////////////////////////////////////////
    5.95 +// Combinational Logic
    5.96 +/////////////////////////////////////////////////////
    5.97 +
    5.98 +// Extract signs of operands and result
    5.99 +
   5.100 +assign a_sign = operand_0_x[`LM32_WORD_WIDTH-1];
   5.101 +assign b_sign = operand_1_x[`LM32_WORD_WIDTH-1];
   5.102 +assign result_sign = adder_result_x[`LM32_WORD_WIDTH-1];
   5.103 +
   5.104 +// Determine whether an overflow occured when performing a subtraction
   5.105 +
   5.106 +always @(*)
   5.107 +begin    
   5.108 +    //  +ve - -ve = -ve -> overflow
   5.109 +    //  -ve - +ve = +ve -> overflow
   5.110 +    if  (   (!a_sign & b_sign & result_sign)
   5.111 +         || (a_sign & !b_sign & !result_sign)
   5.112 +        )
   5.113 +        adder_overflow_x = `TRUE;
   5.114 +    else
   5.115 +        adder_overflow_x = `FALSE;
   5.116 +end
   5.117 +    
   5.118 +endmodule
   5.119 +

     6.1 diff -r 000000000000 -r cd0b58aa6f83 lm32_addsub.v
     6.2 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.3 +++ b/lm32_addsub.v	Sun Apr 04 20:40:03 2010 +0100
     6.4 @@ -0,0 +1,93 @@
     6.5 +// =============================================================================
     6.6 +//                           COPYRIGHT NOTICE
     6.7 +// Copyright 2006 (c) Lattice Semiconductor Corporation
     6.8 +// ALL RIGHTS RESERVED
     6.9 +// This confidential and proprietary software may be used only as authorised by
    6.10 +// a licensing agreement from Lattice Semiconductor Corporation.
    6.11 +// The entire notice above must be reproduced on all authorized copies and
    6.12 +// copies may only be made to the extent permitted by a licensing agreement from
    6.13 +// Lattice Semiconductor Corporation.
    6.14 +//
    6.15 +// Lattice Semiconductor Corporation        TEL : 1-800-Lattice (USA and Canada)
    6.16 +// 5555 NE Moore Court                            408-826-6000 (other locations)
    6.17 +// Hillsboro, OR 97124                     web  : http://www.latticesemi.com/
    6.18 +// U.S.A                                   email: techsupport@latticesemi.com
    6.19 +// =============================================================================/
    6.20 +//                         FILE DETAILS
    6.21 +// Project          : LatticeMico32
    6.22 +// File             : lm32_addsub.v
    6.23 +// Title            : PMI adder/subtractor.
    6.24 +// Version          : 6.1.17
    6.25 +//                  : Initial Release
    6.26 +// Version          : 7.0SP2, 3.0
    6.27 +//                  : No Change
    6.28 +// Version          : 3.1
    6.29 +//                  : No Change
    6.30 +// =============================================================================
    6.31 +
    6.32 +`include "lm32_include.v"
    6.33 +
    6.34 +/////////////////////////////////////////////////////
    6.35 +// Module interface
    6.36 +/////////////////////////////////////////////////////
    6.37 +
    6.38 +module lm32_addsub (
    6.39 +    // ----- Inputs -------
    6.40 +    DataA, 
    6.41 +    DataB, 
    6.42 +    Cin, 
    6.43 +    Add_Sub, 
    6.44 +    // ----- Outputs -------
    6.45 +    Result, 
    6.46 +    Cout
    6.47 +    );
    6.48 +
    6.49 +/////////////////////////////////////////////////////
    6.50 +// Inputs
    6.51 +/////////////////////////////////////////////////////
    6.52 +
    6.53 +input [31:0] DataA;
    6.54 +input [31:0] DataB;
    6.55 +input Cin;
    6.56 +input Add_Sub;
    6.57 +
    6.58 +/////////////////////////////////////////////////////
    6.59 +// Outputs
    6.60 +/////////////////////////////////////////////////////
    6.61 +
    6.62 +output [31:0] Result;
    6.63 +wire   [31:0] Result;
    6.64 +output Cout;
    6.65 +wire   Cout;
    6.66 +
    6.67 +/////////////////////////////////////////////////////
    6.68 +// Instantiations
    6.69 +///////////////////////////////////////////////////// 
    6.70 +
    6.71 +       generate
    6.72 +	  if (`LATTICE_FAMILY == "SC" || `LATTICE_FAMILY == "SCM") begin
    6.73 +	     wire [32:0] tmp_addResult = DataA + DataB + Cin;
    6.74 +	     wire [32:0] tmp_subResult = DataA - DataB - !Cin;   
    6.75 +   
    6.76 +	     assign  Result = (Add_Sub == 1) ? tmp_addResult[31:0] : tmp_subResult[31:0];
    6.77 +	     assign  Cout = (Add_Sub == 1) ? tmp_addResult[32] : !tmp_subResult[32];
    6.78 +	  end else begin
    6.79 +	    pmi_addsub #(// ----- Parameters -------
    6.80 +			 .pmi_data_width     (32),
    6.81 +			 .pmi_result_width   (32),
    6.82 +			 .pmi_sign           ("off"),
    6.83 +			 .pmi_family         (`LATTICE_FAMILY),
    6.84 +			 .module_type        ("pmi_addsub")) 
    6.85 +	      addsub    (// ----- Inputs -------
    6.86 +			 .DataA              (DataA),
    6.87 +			 .DataB              (DataB),
    6.88 +			 .Cin                (Cin),
    6.89 +			 .Add_Sub            (Add_Sub),
    6.90 +			 // ----- Outputs -------
    6.91 +			 .Result             (Result),
    6.92 +			 .Cout               (Cout),
    6.93 +			 .Overflow           ());
    6.94 +	  end
    6.95 +       endgenerate 
    6.96 +
    6.97 +endmodule

     7.1 diff -r 000000000000 -r cd0b58aa6f83 lm32_cpu.v
     7.2 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.3 +++ b/lm32_cpu.v	Sun Apr 04 20:40:03 2010 +0100
     7.4 @@ -0,0 +1,2732 @@
     7.5 +// =============================================================================
     7.6 +//                           COPYRIGHT NOTICE
     7.7 +// Copyright 2006 (c) Lattice Semiconductor Corporation
     7.8 +// ALL RIGHTS RESERVED
     7.9 +// This confidential and proprietary software may be used only as authorised by
    7.10 +// a licensing agreement from Lattice Semiconductor Corporation.
    7.11 +// The entire notice above must be reproduced on all authorized copies and
    7.12 +// copies may only be made to the extent permitted by a licensing agreement from
    7.13 +// Lattice Semiconductor Corporation.
    7.14 +//
    7.15 +// Lattice Semiconductor Corporation        TEL : 1-800-Lattice (USA and Canada)
    7.16 +// 5555 NE Moore Court                            408-826-6000 (other locations)
    7.17 +// Hillsboro, OR 97124                     web  : http://www.latticesemi.com/
    7.18 +// U.S.A                                   email: techsupport@latticesemi.com
    7.19 +// =============================================================================/
    7.20 +//                         FILE DETAILS
    7.21 +// Project          : LatticeMico32
    7.22 +// File             : lm32_cpu.v
    7.23 +// Title            : Top-level of CPU.
    7.24 +// Dependencies     : lm32_include.v
    7.25 +//
    7.26 +// Version 3.4
    7.27 +// 1. Bug Fix: In a tight infinite loop (add, sw, bi) incoming interrupts were 
    7.28 +//    never serviced.
    7.29 +//    
    7.30 +// Version 3.3
    7.31 +// 1. Feature: Support for memory that is tightly coupled to processor core, and 
    7.32 +//    has a single-cycle access latency (same as caches). Instruction port has
    7.33 +//    access to a dedicated physically-mapped memory. Data port has access to
    7.34 +//    a dedicated physically-mapped memory. In order to be able to manipulate
    7.35 +//    values in both these memories via the debugger, these memories also
    7.36 +//    interface with the data port of LM32.
    7.37 +// 2. Feature: Extended Configuration Register
    7.38 +// 3. Bug Fix: Removed port names that conflict with keywords reserved in System-
    7.39 +//    Verilog.
    7.40 +//
    7.41 +// Version 3.2
    7.42 +// 1. Bug Fix: Single-stepping a load/store to invalid address causes debugger to
    7.43 +//    hang. At the same time CPU fails to register data bus error exception. Bug
    7.44 +//    is caused because (a) data bus error exception occurs after load/store has
    7.45 +//    passed X stage and next sequential instruction (e.g., brk) is already in X
    7.46 +//    stage, and (b) data bus error exception had lower priority than, say, brk
    7.47 +//    exception.
    7.48 +// 2. Bug Fix: If a brk (or scall/eret/bret) sequentially follows a load/store to
    7.49 +//    invalid location, CPU will fail to register data bus error exception. The
    7.50 +//    solution is to stall scall/eret/bret/brk instructions in D pipeline stage
    7.51 +//    until load/store has completed.
    7.52 +// 3. Feature: Enable precise identification of load/store that causes seg fault.
    7.53 +// 4. SYNC resets used for register file when implemented in EBRs.
    7.54 +//
    7.55 +// Version 3.1
    7.56 +// 1. Feature: LM32 Register File can now be mapped in to on-chip block RAM (EBR)
    7.57 +//    instead of distributed memory by enabling the option in LM32 GUI. 
    7.58 +// 2. Feature: LM32 also adds a static branch predictor to improve branch 
    7.59 +//    performance. All immediate-based forward-pointing branches are predicted 
    7.60 +//    not-taken. All immediate-based backward-pointing branches are predicted taken.
    7.61 +// 
    7.62 +// Version 7.0SP2, 3.0
    7.63 +// No Change
    7.64 +//
    7.65 +// Version 6.1.17
    7.66 +// Initial Release
    7.67 +// =============================================================================
    7.68 +
    7.69 +`include "lm32_include.v"
    7.70 +
    7.71 +/////////////////////////////////////////////////////
    7.72 +// Module interface
    7.73 +/////////////////////////////////////////////////////
    7.74 +
    7.75 +module lm32_cpu (
    7.76 +    // ----- Inputs -------
    7.77 +    clk_i,
    7.78 +`ifdef CFG_EBR_NEGEDGE_REGISTER_FILE
    7.79 +    clk_n_i,
    7.80 +`endif    
    7.81 +    rst_i,
    7.82 +    // From external devices
    7.83 +`ifdef CFG_INTERRUPTS_ENABLED
    7.84 +    interrupt_n,
    7.85 +`endif
    7.86 +    // From user logic
    7.87 +`ifdef CFG_USER_ENABLED
    7.88 +    user_result,
    7.89 +    user_complete,
    7.90 +`endif     
    7.91 +`ifdef CFG_JTAG_ENABLED
    7.92 +    // From JTAG
    7.93 +    jtag_clk,
    7.94 +    jtag_update, 
    7.95 +    jtag_reg_q,
    7.96 +    jtag_reg_addr_q,
    7.97 +`endif
    7.98 +`ifdef CFG_IWB_ENABLED
    7.99 +    // Instruction Wishbone master
   7.100 +    I_DAT_I,
   7.101 +    I_ACK_I,
   7.102 +    I_ERR_I,
   7.103 +    I_RTY_I,
   7.104 +`endif
   7.105 +    // Data Wishbone master
   7.106 +    D_DAT_I,
   7.107 +    D_ACK_I,
   7.108 +    D_ERR_I,
   7.109 +    D_RTY_I,
   7.110 +    // ----- Outputs -------
   7.111 +`ifdef CFG_TRACE_ENABLED
   7.112 +    trace_pc,
   7.113 +    trace_pc_valid,
   7.114 +    trace_exception,
   7.115 +    trace_eid,
   7.116 +    trace_eret,
   7.117 +`ifdef CFG_DEBUG_ENABLED
   7.118 +    trace_bret,
   7.119 +`endif
   7.120 +`endif
   7.121 +`ifdef CFG_JTAG_ENABLED
   7.122 +    jtag_reg_d,
   7.123 +    jtag_reg_addr_d,
   7.124 +`endif
   7.125 +`ifdef CFG_USER_ENABLED    
   7.126 +    user_valid,
   7.127 +    user_opcode,
   7.128 +    user_operand_0,
   7.129 +    user_operand_1,
   7.130 +`endif    
   7.131 +`ifdef CFG_IWB_ENABLED
   7.132 +    // Instruction Wishbone master
   7.133 +    I_DAT_O,
   7.134 +    I_ADR_O,
   7.135 +    I_CYC_O,
   7.136 +    I_SEL_O,
   7.137 +    I_STB_O,
   7.138 +    I_WE_O,
   7.139 +    I_CTI_O,
   7.140 +    I_LOCK_O,
   7.141 +    I_BTE_O,
   7.142 +`endif
   7.143 +    // Data Wishbone master
   7.144 +    D_DAT_O,
   7.145 +    D_ADR_O,
   7.146 +    D_CYC_O,
   7.147 +    D_SEL_O,
   7.148 +    D_STB_O,
   7.149 +    D_WE_O,
   7.150 +    D_CTI_O,
   7.151 +    D_LOCK_O,
   7.152 +    D_BTE_O
   7.153 +    );
   7.154 +
   7.155 +/////////////////////////////////////////////////////
   7.156 +// Parameters
   7.157 +/////////////////////////////////////////////////////
   7.158 +
   7.159 +parameter eba_reset = `CFG_EBA_RESET;                           // Reset value for EBA CSR
   7.160 +`ifdef CFG_DEBUG_ENABLED
   7.161 +parameter deba_reset = `CFG_DEBA_RESET;                         // Reset value for DEBA CSR
   7.162 +`endif
   7.163 +
   7.164 +`ifdef CFG_ICACHE_ENABLED
   7.165 +parameter icache_associativity = `CFG_ICACHE_ASSOCIATIVITY;     // Associativity of the cache (Number of ways)
   7.166 +parameter icache_sets = `CFG_ICACHE_SETS;                       // Number of sets
   7.167 +parameter icache_bytes_per_line = `CFG_ICACHE_BYTES_PER_LINE;   // Number of bytes per cache line
   7.168 +parameter icache_base_address = `CFG_ICACHE_BASE_ADDRESS;       // Base address of cachable memory
   7.169 +parameter icache_limit = `CFG_ICACHE_LIMIT;                     // Limit (highest address) of cachable memory
   7.170 +`else
   7.171 +parameter icache_associativity = 1;    
   7.172 +parameter icache_sets = 512;                      
   7.173 +parameter icache_bytes_per_line = 16;  
   7.174 +parameter icache_base_address = 0;      
   7.175 +parameter icache_limit = 0;                    
   7.176 +`endif
   7.177 +
   7.178 +`ifdef CFG_DCACHE_ENABLED
   7.179 +parameter dcache_associativity = `CFG_DCACHE_ASSOCIATIVITY;     // Associativity of the cache (Number of ways)
   7.180 +parameter dcache_sets = `CFG_DCACHE_SETS;                       // Number of sets
   7.181 +parameter dcache_bytes_per_line = `CFG_DCACHE_BYTES_PER_LINE;   // Number of bytes per cache line
   7.182 +parameter dcache_base_address = `CFG_DCACHE_BASE_ADDRESS;       // Base address of cachable memory
   7.183 +parameter dcache_limit = `CFG_DCACHE_LIMIT;                     // Limit (highest address) of cachable memory
   7.184 +`else
   7.185 +parameter dcache_associativity = 1;    
   7.186 +parameter dcache_sets = 512;                      
   7.187 +parameter dcache_bytes_per_line = 16;  
   7.188 +parameter dcache_base_address = 0;      
   7.189 +parameter dcache_limit = 0;                    
   7.190 +`endif
   7.191 +
   7.192 +`ifdef CFG_DEBUG_ENABLED
   7.193 +parameter watchpoints = `CFG_WATCHPOINTS;                       // Number of h/w watchpoint CSRs
   7.194 +`else
   7.195 +parameter watchpoints = 0;
   7.196 +`endif
   7.197 +`ifdef CFG_ROM_DEBUG_ENABLED
   7.198 +parameter breakpoints = `CFG_BREAKPOINTS;                       // Number of h/w breakpoint CSRs
   7.199 +`else
   7.200 +parameter breakpoints = 0;
   7.201 +`endif
   7.202 +
   7.203 +`ifdef CFG_INTERRUPTS_ENABLED
   7.204 +parameter interrupts = `CFG_INTERRUPTS;                         // Number of interrupts
   7.205 +`else
   7.206 +parameter interrupts = 0;
   7.207 +`endif
   7.208 +
   7.209 +/////////////////////////////////////////////////////
   7.210 +// Inputs
   7.211 +/////////////////////////////////////////////////////
   7.212 +
   7.213 +input clk_i;                                    // Clock
   7.214 +`ifdef CFG_EBR_NEGEDGE_REGISTER_FILE
   7.215 +input clk_n_i;                                  // Inverted clock
   7.216 +`endif    
   7.217 +input rst_i;                                    // Reset
   7.218 +
   7.219 +`ifdef CFG_INTERRUPTS_ENABLED
   7.220 +input [`LM32_INTERRUPT_RNG] interrupt_n;        // Interrupt pins, active-low
   7.221 +`endif
   7.222 +
   7.223 +`ifdef CFG_USER_ENABLED
   7.224 +input [`LM32_WORD_RNG] user_result;             // User-defined instruction result
   7.225 +input user_complete;                            // User-defined instruction execution is complete
   7.226 +`endif    
   7.227 +
   7.228 +`ifdef CFG_JTAG_ENABLED
   7.229 +input jtag_clk;                                 // JTAG clock
   7.230 +input jtag_update;                              // JTAG state machine is in data register update state
   7.231 +input [`LM32_BYTE_RNG] jtag_reg_q;              
   7.232 +input [2:0] jtag_reg_addr_q;
   7.233 +`endif
   7.234 +
   7.235 +`ifdef CFG_IWB_ENABLED
   7.236 +input [`LM32_WORD_RNG] I_DAT_I;                 // Instruction Wishbone interface read data
   7.237 +input I_ACK_I;                                  // Instruction Wishbone interface acknowledgement
   7.238 +input I_ERR_I;                                  // Instruction Wishbone interface error
   7.239 +input I_RTY_I;                                  // Instruction Wishbone interface retry
   7.240 +`endif
   7.241 +
   7.242 +input [`LM32_WORD_RNG] D_DAT_I;                 // Data Wishbone interface read data
   7.243 +input D_ACK_I;                                  // Data Wishbone interface acknowledgement
   7.244 +input D_ERR_I;                                  // Data Wishbone interface error
   7.245 +input D_RTY_I;                                  // Data Wishbone interface retry
   7.246 +
   7.247 +/////////////////////////////////////////////////////
   7.248 +// Outputs
   7.249 +/////////////////////////////////////////////////////
   7.250 +
   7.251 +`ifdef CFG_TRACE_ENABLED
   7.252 +output [`LM32_PC_RNG] trace_pc;                 // PC to trace
   7.253 +reg    [`LM32_PC_RNG] trace_pc;
   7.254 +output trace_pc_valid;                          // Indicates that a new trace PC is valid
   7.255 +reg    trace_pc_valid;
   7.256 +output trace_exception;                         // Indicates an exception has occured
   7.257 +reg    trace_exception;
   7.258 +output [`LM32_EID_RNG] trace_eid;               // Indicates what type of exception has occured
   7.259 +reg    [`LM32_EID_RNG] trace_eid;
   7.260 +output trace_eret;                              // Indicates an eret instruction has been executed
   7.261 +reg    trace_eret;
   7.262 +`ifdef CFG_DEBUG_ENABLED
   7.263 +output trace_bret;                              // Indicates a bret instruction has been executed
   7.264 +reg    trace_bret;
   7.265 +`endif
   7.266 +`endif
   7.267 +
   7.268 +`ifdef CFG_JTAG_ENABLED
   7.269 +output [`LM32_BYTE_RNG] jtag_reg_d;
   7.270 +wire   [`LM32_BYTE_RNG] jtag_reg_d;
   7.271 +output [2:0] jtag_reg_addr_d;
   7.272 +wire   [2:0] jtag_reg_addr_d;
   7.273 +`endif
   7.274 +
   7.275 +`ifdef CFG_USER_ENABLED
   7.276 +output user_valid;                              // Indicates if user_opcode is valid
   7.277 +wire   user_valid;
   7.278 +output [`LM32_USER_OPCODE_RNG] user_opcode;     // User-defined instruction opcode
   7.279 +reg    [`LM32_USER_OPCODE_RNG] user_opcode;
   7.280 +output [`LM32_WORD_RNG] user_operand_0;         // First operand for user-defined instruction
   7.281 +wire   [`LM32_WORD_RNG] user_operand_0;
   7.282 +output [`LM32_WORD_RNG] user_operand_1;         // Second operand for user-defined instruction
   7.283 +wire   [`LM32_WORD_RNG] user_operand_1;
   7.284 +`endif
   7.285 +
   7.286 +`ifdef CFG_IWB_ENABLED
   7.287 +output [`LM32_WORD_RNG] I_DAT_O;                // Instruction Wishbone interface write data
   7.288 +wire   [`LM32_WORD_RNG] I_DAT_O;
   7.289 +output [`LM32_WORD_RNG] I_ADR_O;                // Instruction Wishbone interface address
   7.290 +wire   [`LM32_WORD_RNG] I_ADR_O;
   7.291 +output I_CYC_O;                                 // Instruction Wishbone interface cycle
   7.292 +wire   I_CYC_O;
   7.293 +output [`LM32_BYTE_SELECT_RNG] I_SEL_O;         // Instruction Wishbone interface byte select
   7.294 +wire   [`LM32_BYTE_SELECT_RNG] I_SEL_O;
   7.295 +output I_STB_O;                                 // Instruction Wishbone interface strobe
   7.296 +wire   I_STB_O;
   7.297 +output I_WE_O;                                  // Instruction Wishbone interface write enable
   7.298 +wire   I_WE_O;
   7.299 +output [`LM32_CTYPE_RNG] I_CTI_O;               // Instruction Wishbone interface cycle type 
   7.300 +wire   [`LM32_CTYPE_RNG] I_CTI_O;
   7.301 +output I_LOCK_O;                                // Instruction Wishbone interface lock bus
   7.302 +wire   I_LOCK_O;
   7.303 +output [`LM32_BTYPE_RNG] I_BTE_O;               // Instruction Wishbone interface burst type 
   7.304 +wire   [`LM32_BTYPE_RNG] I_BTE_O;
   7.305 +`endif
   7.306 +
   7.307 +output [`LM32_WORD_RNG] D_DAT_O;                // Data Wishbone interface write data
   7.308 +wire   [`LM32_WORD_RNG] D_DAT_O;
   7.309 +output [`LM32_WORD_RNG] D_ADR_O;                // Data Wishbone interface address
   7.310 +wire   [`LM32_WORD_RNG] D_ADR_O;
   7.311 +output D_CYC_O;                                 // Data Wishbone interface cycle
   7.312 +wire   D_CYC_O;
   7.313 +output [`LM32_BYTE_SELECT_RNG] D_SEL_O;         // Data Wishbone interface byte select
   7.314 +wire   [`LM32_BYTE_SELECT_RNG] D_SEL_O;
   7.315 +output D_STB_O;                                 // Data Wishbone interface strobe
   7.316 +wire   D_STB_O;
   7.317 +output D_WE_O;                                  // Data Wishbone interface write enable
   7.318 +wire   D_WE_O;
   7.319 +output [`LM32_CTYPE_RNG] D_CTI_O;               // Data Wishbone interface cycle type 
   7.320 +wire   [`LM32_CTYPE_RNG] D_CTI_O;
   7.321 +output D_LOCK_O;                                // Date Wishbone interface lock bus
   7.322 +wire   D_LOCK_O;
   7.323 +output [`LM32_BTYPE_RNG] D_BTE_O;               // Data Wishbone interface burst type 
   7.324 +wire   [`LM32_BTYPE_RNG] D_BTE_O;
   7.325 +
   7.326 +/////////////////////////////////////////////////////
   7.327 +// Internal nets and registers 
   7.328 +/////////////////////////////////////////////////////
   7.329 +
   7.330 +// Pipeline registers
   7.331 +
   7.332 +`ifdef LM32_CACHE_ENABLED
   7.333 +reg valid_a;                                    // Instruction in A stage is valid
   7.334 +`endif
   7.335 +reg valid_f;                                    // Instruction in F stage is valid
   7.336 +reg valid_d;                                    // Instruction in D stage is valid
   7.337 +reg valid_x;                                    // Instruction in X stage is valid
   7.338 +reg valid_m;                                    // Instruction in M stage is valid
   7.339 +reg valid_w;                                    // Instruction in W stage is valid
   7.340 +   
   7.341 +wire q_x;
   7.342 +wire [`LM32_WORD_RNG] immediate_d;              // Immediate operand
   7.343 +wire load_d;                                    // Indicates a load instruction
   7.344 +reg load_x;                                     
   7.345 +reg load_m;
   7.346 +wire load_q_x;
   7.347 +wire store_q_x;
   7.348 +wire store_d;                                   // Indicates a store instruction
   7.349 +reg store_x;
   7.350 +reg store_m;
   7.351 +wire [`LM32_SIZE_RNG] size_d;                   // Size of load/store (byte, hword, word)
   7.352 +reg [`LM32_SIZE_RNG] size_x;
   7.353 +wire branch_d;                                  // Indicates a branch instruction
   7.354 +wire branch_predict_d;                          // Indicates a branch is predicted
   7.355 +wire branch_predict_taken_d;                    // Indicates a branch is predicted taken
   7.356 +wire [`LM32_PC_RNG] branch_predict_address_d;   // Address to which predicted branch jumps
   7.357 +wire [`LM32_PC_RNG] branch_target_d;
   7.358 +wire bi_unconditional;
   7.359 +wire bi_conditional;
   7.360 +reg branch_x;                                   
   7.361 +reg branch_predict_x;
   7.362 +reg branch_predict_taken_x;
   7.363 +reg branch_m;
   7.364 +reg branch_predict_m;
   7.365 +reg branch_predict_taken_m;
   7.366 +wire branch_mispredict_taken_m;                 // Indicates a branch was mispredicted as taken
   7.367 +wire branch_flushX_m;                           // Indicates that instruction in X stage must be squashed
   7.368 +wire branch_reg_d;                              // Branch to register or immediate
   7.369 +wire [`LM32_PC_RNG] branch_offset_d;            // Branch offset for immediate branches
   7.370 +reg [`LM32_PC_RNG] branch_target_x;             // Address to branch to
   7.371 +reg [`LM32_PC_RNG] branch_target_m;
   7.372 +wire [`LM32_D_RESULT_SEL_0_RNG] d_result_sel_0_d; // Which result should be selected in D stage for operand 0
   7.373 +wire [`LM32_D_RESULT_SEL_1_RNG] d_result_sel_1_d; // Which result should be selected in D stage for operand 1
   7.374 +
   7.375 +wire x_result_sel_csr_d;                        // Select X stage result from CSRs
   7.376 +reg x_result_sel_csr_x;
   7.377 +`ifdef LM32_MC_ARITHMETIC_ENABLED
   7.378 +wire x_result_sel_mc_arith_d;                   // Select X stage result from multi-cycle arithmetic unit
   7.379 +reg x_result_sel_mc_arith_x;
   7.380 +`endif
   7.381 +`ifdef LM32_NO_BARREL_SHIFT    
   7.382 +wire x_result_sel_shift_d;                      // Select X stage result from shifter
   7.383 +reg x_result_sel_shift_x;
   7.384 +`endif
   7.385 +`ifdef CFG_SIGN_EXTEND_ENABLED
   7.386 +wire x_result_sel_sext_d;                       // Select X stage result from sign-extend logic
   7.387 +reg x_result_sel_sext_x;
   7.388 +`endif
   7.389 +wire x_result_sel_logic_d;                      // Select X stage result from logic op unit
   7.390 +reg x_result_sel_logic_x;
   7.391 +`ifdef CFG_USER_ENABLED
   7.392 +wire x_result_sel_user_d;                       // Select X stage result from user-defined logic
   7.393 +reg x_result_sel_user_x;
   7.394 +`endif
   7.395 +wire x_result_sel_add_d;                        // Select X stage result from adder
   7.396 +reg x_result_sel_add_x;
   7.397 +wire m_result_sel_compare_d;                    // Select M stage result from comparison logic
   7.398 +reg m_result_sel_compare_x;
   7.399 +reg m_result_sel_compare_m;
   7.400 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
   7.401 +wire m_result_sel_shift_d;                      // Select M stage result from shifter
   7.402 +reg m_result_sel_shift_x;
   7.403 +reg m_result_sel_shift_m;
   7.404 +`endif
   7.405 +wire w_result_sel_load_d;                       // Select W stage result from load/store unit
   7.406 +reg w_result_sel_load_x;
   7.407 +reg w_result_sel_load_m;
   7.408 +reg w_result_sel_load_w;
   7.409 +`ifdef CFG_PL_MULTIPLY_ENABLED
   7.410 +wire w_result_sel_mul_d;                        // Select W stage result from multiplier
   7.411 +reg w_result_sel_mul_x;
   7.412 +reg w_result_sel_mul_m;
   7.413 +reg w_result_sel_mul_w;
   7.414 +`endif
   7.415 +wire x_bypass_enable_d;                         // Whether result is bypassable in X stage
   7.416 +reg x_bypass_enable_x;                          
   7.417 +wire m_bypass_enable_d;                         // Whether result is bypassable in M stage
   7.418 +reg m_bypass_enable_x;                          
   7.419 +reg m_bypass_enable_m;
   7.420 +wire sign_extend_d;                             // Whether to sign-extend or zero-extend
   7.421 +reg sign_extend_x;
   7.422 +wire write_enable_d;                            // Register file write enable
   7.423 +reg write_enable_x;
   7.424 +wire write_enable_q_x;
   7.425 +reg write_enable_m;
   7.426 +wire write_enable_q_m;
   7.427 +reg write_enable_w;
   7.428 +wire write_enable_q_w;
   7.429 +wire read_enable_0_d;                           // Register file read enable 0
   7.430 +wire [`LM32_REG_IDX_RNG] read_idx_0_d;          // Register file read index 0
   7.431 +wire read_enable_1_d;                           // Register file read enable 1
   7.432 +wire [`LM32_REG_IDX_RNG] read_idx_1_d;          // Register file read index 1
   7.433 +wire [`LM32_REG_IDX_RNG] write_idx_d;           // Register file write index
   7.434 +reg [`LM32_REG_IDX_RNG] write_idx_x;            
   7.435 +reg [`LM32_REG_IDX_RNG] write_idx_m;
   7.436 +reg [`LM32_REG_IDX_RNG] write_idx_w;
   7.437 +wire [`LM32_CSR_RNG] csr_d;                     // CSR read/write index
   7.438 +reg  [`LM32_CSR_RNG] csr_x;                  
   7.439 +wire [`LM32_CONDITION_RNG] condition_d;         // Branch condition
   7.440 +reg [`LM32_CONDITION_RNG] condition_x;          
   7.441 +`ifdef CFG_DEBUG_ENABLED
   7.442 +wire break_d;                                   // Indicates a break instruction
   7.443 +reg break_x;                                    
   7.444 +`endif
   7.445 +wire scall_d;                                   // Indicates a scall instruction
   7.446 +reg scall_x;    
   7.447 +wire eret_d;                                    // Indicates an eret instruction
   7.448 +reg eret_x;
   7.449 +wire eret_q_x;
   7.450 +reg eret_m;
   7.451 +`ifdef CFG_TRACE_ENABLED
   7.452 +reg eret_w;
   7.453 +`endif
   7.454 +`ifdef CFG_DEBUG_ENABLED
   7.455 +wire bret_d;                                    // Indicates a bret instruction
   7.456 +reg bret_x;
   7.457 +wire bret_q_x;
   7.458 +reg bret_m;
   7.459 +`ifdef CFG_TRACE_ENABLED
   7.460 +reg bret_w;
   7.461 +`endif
   7.462 +`endif
   7.463 +wire csr_write_enable_d;                        // CSR write enable
   7.464 +reg csr_write_enable_x;
   7.465 +wire csr_write_enable_q_x;
   7.466 +`ifdef CFG_USER_ENABLED
   7.467 +wire [`LM32_USER_OPCODE_RNG] user_opcode_d;     // User-defined instruction opcode
   7.468 +`endif
   7.469 +
   7.470 +`ifdef CFG_BUS_ERRORS_ENABLED
   7.471 +wire bus_error_d;                               // Indicates an bus error occured while fetching the instruction in this pipeline stage
   7.472 +reg bus_error_x;
   7.473 +reg data_bus_error_exception_m;
   7.474 +reg [`LM32_PC_RNG] memop_pc_w;
   7.475 +`endif
   7.476 +
   7.477 +reg [`LM32_WORD_RNG] d_result_0;                // Result of instruction in D stage (operand 0)
   7.478 +reg [`LM32_WORD_RNG] d_result_1;                // Result of instruction in D stage (operand 1)
   7.479 +reg [`LM32_WORD_RNG] x_result;                  // Result of instruction in X stage
   7.480 +reg [`LM32_WORD_RNG] m_result;                  // Result of instruction in M stage
   7.481 +reg [`LM32_WORD_RNG] w_result;                  // Result of instruction in W stage
   7.482 +
   7.483 +reg [`LM32_WORD_RNG] operand_0_x;               // Operand 0 for X stage instruction
   7.484 +reg [`LM32_WORD_RNG] operand_1_x;               // Operand 1 for X stage instruction
   7.485 +reg [`LM32_WORD_RNG] store_operand_x;           // Data read from register to store
   7.486 +reg [`LM32_WORD_RNG] operand_m;                 // Operand for M stage instruction
   7.487 +reg [`LM32_WORD_RNG] operand_w;                 // Operand for W stage instruction
   7.488 +
   7.489 +// To/from register file
   7.490 +`ifdef CFG_EBR_POSEDGE_REGISTER_FILE
   7.491 +reg [`LM32_WORD_RNG] reg_data_live_0;          
   7.492 +reg [`LM32_WORD_RNG] reg_data_live_1;  
   7.493 +reg use_buf;                                    // Whether to use reg_data_live or reg_data_buf
   7.494 +reg [`LM32_WORD_RNG] reg_data_buf_0;
   7.495 +reg [`LM32_WORD_RNG] reg_data_buf_1;
   7.496 +`endif
   7.497 +`ifdef LM32_EBR_REGISTER_FILE
   7.498 +`else
   7.499 +reg [`LM32_WORD_RNG] registers[0:(1<<`LM32_REG_IDX_WIDTH)-1];   // Register file
   7.500 +`endif
   7.501 +wire [`LM32_WORD_RNG] reg_data_0;               // Register file read port 0 data         
   7.502 +wire [`LM32_WORD_RNG] reg_data_1;               // Register file read port 1 data
   7.503 +reg [`LM32_WORD_RNG] bypass_data_0;             // Register value 0 after bypassing
   7.504 +reg [`LM32_WORD_RNG] bypass_data_1;             // Register value 1 after bypassing
   7.505 +wire reg_write_enable_q_w;
   7.506 +
   7.507 +reg interlock;                                  // Indicates pipeline should be stalled because of a read-after-write hazzard
   7.508 +
   7.509 +wire stall_a;                                   // Stall instruction in A pipeline stage
   7.510 +wire stall_f;                                   // Stall instruction in F pipeline stage
   7.511 +wire stall_d;                                   // Stall instruction in D pipeline stage
   7.512 +wire stall_x;                                   // Stall instruction in X pipeline stage
   7.513 +wire stall_m;                                   // Stall instruction in M pipeline stage
   7.514 +
   7.515 +// To/from adder
   7.516 +wire adder_op_d;                                // Whether to add or subtract
   7.517 +reg adder_op_x;                                 
   7.518 +reg adder_op_x_n;                               // Inverted version of adder_op_x
   7.519 +wire [`LM32_WORD_RNG] adder_result_x;           // Result from adder
   7.520 +wire adder_overflow_x;                          // Whether a signed overflow occured
   7.521 +wire adder_carry_n_x;                           // Whether a carry was generated
   7.522 +
   7.523 +// To/from logical operations unit
   7.524 +wire [`LM32_LOGIC_OP_RNG] logic_op_d;           // Which operation to perform
   7.525 +reg [`LM32_LOGIC_OP_RNG] logic_op_x;            
   7.526 +wire [`LM32_WORD_RNG] logic_result_x;           // Result of logical operation
   7.527 +
   7.528 +`ifdef CFG_SIGN_EXTEND_ENABLED
   7.529 +// From sign-extension unit
   7.530 +wire [`LM32_WORD_RNG] sextb_result_x;           // Result of byte sign-extension
   7.531 +wire [`LM32_WORD_RNG] sexth_result_x;           // Result of half-word sign-extenstion
   7.532 +wire [`LM32_WORD_RNG] sext_result_x;            // Result of sign-extension specified by instruction
   7.533 +`endif
   7.534 +
   7.535 +// To/from shifter
   7.536 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
   7.537 +`ifdef CFG_ROTATE_ENABLED
   7.538 +wire rotate_d;                                  // Whether we should rotate or shift
   7.539 +reg rotate_x;                                    
   7.540 +`endif
   7.541 +wire direction_d;                               // Which direction to shift in
   7.542 +reg direction_x;                                        
   7.543 +reg direction_m;
   7.544 +wire [`LM32_WORD_RNG] shifter_result_m;         // Result of shifter
   7.545 +`endif
   7.546 +`ifdef CFG_MC_BARREL_SHIFT_ENABLED
   7.547 +wire shift_left_d;                              // Indicates whether to perform a left shift or not
   7.548 +wire shift_left_q_d;
   7.549 +wire shift_right_d;                             // Indicates whether to perform a right shift or not
   7.550 +wire shift_right_q_d;
   7.551 +`endif
   7.552 +`ifdef LM32_NO_BARREL_SHIFT
   7.553 +wire [`LM32_WORD_RNG] shifter_result_x;         // Result of single-bit right shifter
   7.554 +`endif
   7.555 +
   7.556 +// To/from multiplier
   7.557 +`ifdef LM32_MULTIPLY_ENABLED
   7.558 +wire [`LM32_WORD_RNG] multiplier_result_w;      // Result from multiplier
   7.559 +`endif
   7.560 +`ifdef CFG_MC_MULTIPLY_ENABLED
   7.561 +wire multiply_d;                                // Indicates whether to perform a multiply or not
   7.562 +wire multiply_q_d;
   7.563 +`endif
   7.564 +
   7.565 +// To/from divider
   7.566 +`ifdef CFG_MC_DIVIDE_ENABLED
   7.567 +wire divide_d;                                  // Indicates whether to perform a divider or not
   7.568 +wire divide_q_d;
   7.569 +wire modulus_d;
   7.570 +wire modulus_q_d;
   7.571 +wire divide_by_zero_x;                          // Indicates an attempt was made to divide by zero
   7.572 +`endif
   7.573 +
   7.574 +// To from multi-cycle arithmetic unit
   7.575 +`ifdef LM32_MC_ARITHMETIC_ENABLED
   7.576 +wire mc_stall_request_x;                        // Multi-cycle arithmetic unit stall request
   7.577 +wire [`LM32_WORD_RNG] mc_result_x;
   7.578 +`endif
   7.579 +
   7.580 +// From CSRs
   7.581 +`ifdef CFG_INTERRUPTS_ENABLED
   7.582 +wire [`LM32_WORD_RNG] interrupt_csr_read_data_x;// Data read from interrupt CSRs
   7.583 +`endif
   7.584 +wire [`LM32_WORD_RNG] cfg;                      // Configuration CSR
   7.585 +wire [`LM32_WORD_RNG] cfg2;                     // Extended Configuration CSR
   7.586 +`ifdef CFG_CYCLE_COUNTER_ENABLED
   7.587 +reg [`LM32_WORD_RNG] cc;                        // Cycle counter CSR
   7.588 +`endif
   7.589 +reg [`LM32_WORD_RNG] csr_read_data_x;           // Data read from CSRs
   7.590 +
   7.591 +// To/from instruction unit
   7.592 +wire [`LM32_PC_RNG] pc_f;                       // PC of instruction in F stage
   7.593 +wire [`LM32_PC_RNG] pc_d;                       // PC of instruction in D stage
   7.594 +wire [`LM32_PC_RNG] pc_x;                       // PC of instruction in X stage
   7.595 +wire [`LM32_PC_RNG] pc_m;                       // PC of instruction in M stage
   7.596 +wire [`LM32_PC_RNG] pc_w;                       // PC of instruction in W stage
   7.597 +`ifdef CFG_TRACE_ENABLED
   7.598 +reg [`LM32_PC_RNG] pc_c;                        // PC of last commited instruction
   7.599 +`endif
   7.600 +`ifdef CFG_EBR_POSEDGE_REGISTER_FILE
   7.601 +wire [`LM32_INSTRUCTION_RNG] instruction_f;     // Instruction in F stage
   7.602 +`endif
   7.603 +//pragma attribute instruction_d preserve_signal true
   7.604 +//pragma attribute instruction_d preserve_driver true
   7.605 +wire [`LM32_INSTRUCTION_RNG] instruction_d;     // Instruction in D stage
   7.606 +`ifdef CFG_ICACHE_ENABLED
   7.607 +wire iflush;                                    // Flush instruction cache
   7.608 +wire icache_stall_request;                      // Stall pipeline because instruction cache is busy
   7.609 +wire icache_restart_request;                    // Restart instruction that caused an instruction cache miss
   7.610 +wire icache_refill_request;                     // Request to refill instruction cache
   7.611 +wire icache_refilling;                          // Indicates the instruction cache is being refilled
   7.612 +`endif
   7.613 +`ifdef CFG_IROM_ENABLED
   7.614 +wire [`LM32_WORD_RNG] irom_store_data_m;        // Store data to instruction ROM
   7.615 +wire [`LM32_WORD_RNG] irom_address_xm;          // Address to instruction ROM from load-store unit
   7.616 +wire [`LM32_WORD_RNG] irom_data_m;              // Load data from instruction ROM
   7.617 +wire irom_we_xm;                                // Indicates data needs to be written to instruction ROM
   7.618 +wire irom_stall_request_x;                      // Indicates D stage needs to be stalled on a store to instruction ROM
   7.619 +`endif
   7.620 +
   7.621 +// To/from load/store unit
   7.622 +`ifdef CFG_DCACHE_ENABLED
   7.623 +wire dflush_x;                                  // Flush data cache    
   7.624 +reg dflush_m;                                    
   7.625 +wire dcache_stall_request;                      // Stall pipeline because data cache is busy
   7.626 +wire dcache_restart_request;                    // Restart instruction that caused a data cache miss
   7.627 +wire dcache_refill_request;                     // Request to refill data cache
   7.628 +wire dcache_refilling;                          // Indicates the data cache is being refilled
   7.629 +`endif
   7.630 +wire [`LM32_WORD_RNG] load_data_w;              // Result of a load instruction
   7.631 +wire stall_wb_load;                             // Stall pipeline because of a load via the data Wishbone interface
   7.632 +
   7.633 +// To/from JTAG interface
   7.634 +`ifdef CFG_JTAG_ENABLED
   7.635 +`ifdef CFG_JTAG_UART_ENABLED
   7.636 +wire [`LM32_WORD_RNG] jtx_csr_read_data;        // Read data for JTX CSR
   7.637 +wire [`LM32_WORD_RNG] jrx_csr_read_data;        // Read data for JRX CSR
   7.638 +`endif
   7.639 +`ifdef CFG_HW_DEBUG_ENABLED
   7.640 +wire jtag_csr_write_enable;                     // Debugger CSR write enable
   7.641 +wire [`LM32_WORD_RNG] jtag_csr_write_data;      // Data to write to specified CSR
   7.642 +wire [`LM32_CSR_RNG] jtag_csr;                  // Which CSR to write
   7.643 +wire jtag_read_enable;                          
   7.644 +wire [`LM32_BYTE_RNG] jtag_read_data;
   7.645 +wire jtag_write_enable;
   7.646 +wire [`LM32_BYTE_RNG] jtag_write_data;
   7.647 +wire [`LM32_WORD_RNG] jtag_address;
   7.648 +wire jtag_access_complete;
   7.649 +`endif
   7.650 +`ifdef CFG_DEBUG_ENABLED
   7.651 +wire jtag_break;                                // Request from debugger to raise a breakpoint
   7.652 +`endif
   7.653 +`endif
   7.654 +
   7.655 +// Hazzard detection
   7.656 +wire raw_x_0;                                   // RAW hazzard between instruction in X stage and read port 0
   7.657 +wire raw_x_1;                                   // RAW hazzard between instruction in X stage and read port 1
   7.658 +wire raw_m_0;                                   // RAW hazzard between instruction in M stage and read port 0
   7.659 +wire raw_m_1;                                   // RAW hazzard between instruction in M stage and read port 1
   7.660 +wire raw_w_0;                                   // RAW hazzard between instruction in W stage and read port 0
   7.661 +wire raw_w_1;                                   // RAW hazzard between instruction in W stage and read port 1
   7.662 +
   7.663 +// Control flow
   7.664 +wire cmp_zero;                                  // Result of comparison is zero
   7.665 +wire cmp_negative;                              // Result of comparison is negative
   7.666 +wire cmp_overflow;                              // Comparison produced an overflow
   7.667 +wire cmp_carry_n;                               // Comparison produced a carry, inverted
   7.668 +reg condition_met_x;                            // Condition of branch instruction is met
   7.669 +reg condition_met_m;
   7.670 +`ifdef CFG_FAST_UNCONDITIONAL_BRANCH    
   7.671 +wire branch_taken_x;                            // Branch is taken in X stage
   7.672 +`endif
   7.673 +wire branch_taken_m;                            // Branch is taken in M stage
   7.674 +
   7.675 +wire kill_f;                                    // Kill instruction in F stage
   7.676 +wire kill_d;                                    // Kill instruction in D stage
   7.677 +wire kill_x;                                    // Kill instruction in X stage
   7.678 +wire kill_m;                                    // Kill instruction in M stage
   7.679 +wire kill_w;                                    // Kill instruction in W stage
   7.680 +
   7.681 +reg [`LM32_PC_WIDTH+2-1:8] eba;                 // Exception Base Address (EBA) CSR
   7.682 +`ifdef CFG_DEBUG_ENABLED
   7.683 +reg [`LM32_PC_WIDTH+2-1:8] deba;                // Debug Exception Base Address (DEBA) CSR
   7.684 +`endif
   7.685 +reg [`LM32_EID_RNG] eid_x;                      // Exception ID in X stage
   7.686 +`ifdef CFG_TRACE_ENABLED
   7.687 +reg [`LM32_EID_RNG] eid_m;                      // Exception ID in M stage
   7.688 +reg [`LM32_EID_RNG] eid_w;                      // Exception ID in W stage
   7.689 +`endif
   7.690 +
   7.691 +`ifdef CFG_DEBUG_ENABLED
   7.692 +`ifdef LM32_SINGLE_STEP_ENABLED
   7.693 +wire dc_ss;                                     // Is single-step enabled
   7.694 +`endif
   7.695 +wire dc_re;                                     // Remap all exceptions
   7.696 +wire exception_x;                               // An exception occured in the X stage
   7.697 +reg exception_m;                                // An instruction that caused an exception is in the M stage
   7.698 +wire debug_exception_x;                         // Indicates if a debug exception has occured
   7.699 +reg debug_exception_m;
   7.700 +reg debug_exception_w;
   7.701 +wire debug_exception_q_w;
   7.702 +wire non_debug_exception_x;                     // Indicates if a non debug exception has occured
   7.703 +reg non_debug_exception_m;
   7.704 +reg non_debug_exception_w;
   7.705 +wire non_debug_exception_q_w;
   7.706 +`else
   7.707 +wire exception_x;                               // Indicates if a debug exception has occured
   7.708 +reg exception_m;
   7.709 +reg exception_w;
   7.710 +wire exception_q_w;
   7.711 +`endif
   7.712 +
   7.713 +`ifdef CFG_DEBUG_ENABLED
   7.714 +`ifdef CFG_JTAG_ENABLED
   7.715 +wire reset_exception;                           // Indicates if a reset exception has occured
   7.716 +`endif
   7.717 +`endif
   7.718 +`ifdef CFG_INTERRUPTS_ENABLED
   7.719 +wire interrupt_exception;                       // Indicates if an interrupt exception has occured
   7.720 +`endif
   7.721 +`ifdef CFG_DEBUG_ENABLED
   7.722 +wire breakpoint_exception;                      // Indicates if a breakpoint exception has occured
   7.723 +wire watchpoint_exception;                      // Indicates if a watchpoint exception has occured
   7.724 +`endif
   7.725 +`ifdef CFG_BUS_ERRORS_ENABLED
   7.726 +wire instruction_bus_error_exception;           // Indicates if an instruction bus error exception has occured
   7.727 +wire data_bus_error_exception;                  // Indicates if a data bus error exception has occured
   7.728 +`endif
   7.729 +`ifdef CFG_MC_DIVIDE_ENABLED
   7.730 +wire divide_by_zero_exception;                  // Indicates if a divide by zero exception has occured
   7.731 +`endif
   7.732 +wire system_call_exception;                     // Indicates if a system call exception has occured
   7.733 +
   7.734 +`ifdef CFG_BUS_ERRORS_ENABLED
   7.735 +reg data_bus_error_seen;                        // Indicates if a data bus error was seen
   7.736 +`endif
   7.737 +
   7.738 +/////////////////////////////////////////////////////
   7.739 +// Functions
   7.740 +/////////////////////////////////////////////////////
   7.741 +
   7.742 +`include "lm32_functions.v"
   7.743 +
   7.744 +/////////////////////////////////////////////////////
   7.745 +// Instantiations
   7.746 +///////////////////////////////////////////////////// 
   7.747 +
   7.748 +// Instruction unit
   7.749 +lm32_instruction_unit #(
   7.750 +    .associativity          (icache_associativity),
   7.751 +    .sets                   (icache_sets),
   7.752 +    .bytes_per_line         (icache_bytes_per_line),
   7.753 +    .base_address           (icache_base_address),
   7.754 +    .limit                  (icache_limit)
   7.755 +  ) instruction_unit (
   7.756 +    // ----- Inputs -------
   7.757 +    .clk_i                  (clk_i),
   7.758 +    .rst_i                  (rst_i),
   7.759 +    // From pipeline
   7.760 +    .stall_a                (stall_a),
   7.761 +    .stall_f                (stall_f),
   7.762 +    .stall_d                (stall_d),
   7.763 +    .stall_x                (stall_x),
   7.764 +    .stall_m                (stall_m),
   7.765 +    .valid_f                (valid_f),
   7.766 +    .valid_d                (valid_d),
   7.767 +    .kill_f                 (kill_f),
   7.768 +    .branch_predict_taken_d (branch_predict_taken_d),
   7.769 +    .branch_predict_address_d (branch_predict_address_d),
   7.770 +`ifdef CFG_FAST_UNCONDITIONAL_BRANCH    
   7.771 +    .branch_taken_x         (branch_taken_x),
   7.772 +    .branch_target_x        (branch_target_x),
   7.773 +`endif
   7.774 +    .exception_m            (exception_m),
   7.775 +    .branch_taken_m         (branch_taken_m),
   7.776 +    .branch_mispredict_taken_m (branch_mispredict_taken_m),
   7.777 +    .branch_target_m        (branch_target_m),
   7.778 +`ifdef CFG_ICACHE_ENABLED
   7.779 +    .iflush                 (iflush),
   7.780 +`endif
   7.781 +`ifdef CFG_IROM_ENABLED
   7.782 +    .irom_store_data_m      (irom_store_data_m),
   7.783 +    .irom_address_xm        (irom_address_xm),
   7.784 +    .irom_we_xm             (irom_we_xm),
   7.785 +`endif
   7.786 +`ifdef CFG_DCACHE_ENABLED
   7.787 +    .dcache_restart_request (dcache_restart_request),
   7.788 +    .dcache_refill_request  (dcache_refill_request),
   7.789 +    .dcache_refilling       (dcache_refilling),
   7.790 +`endif        
   7.791 +`ifdef CFG_IWB_ENABLED
   7.792 +    // From Wishbone
   7.793 +    .i_dat_i                (I_DAT_I),
   7.794 +    .i_ack_i                (I_ACK_I),
   7.795 +    .i_err_i                (I_ERR_I),
   7.796 +    .i_rty_i                (I_RTY_I),
   7.797 +`endif
   7.798 +`ifdef CFG_HW_DEBUG_ENABLED
   7.799 +    .jtag_read_enable       (jtag_read_enable),
   7.800 +    .jtag_write_enable      (jtag_write_enable),
   7.801 +    .jtag_write_data        (jtag_write_data),
   7.802 +    .jtag_address           (jtag_address),
   7.803 +`endif
   7.804 +    // ----- Outputs -------
   7.805 +    // To pipeline
   7.806 +    .pc_f                   (pc_f),
   7.807 +    .pc_d                   (pc_d),
   7.808 +    .pc_x                   (pc_x),
   7.809 +    .pc_m                   (pc_m),
   7.810 +    .pc_w                   (pc_w),
   7.811 +`ifdef CFG_ICACHE_ENABLED
   7.812 +    .icache_stall_request   (icache_stall_request),
   7.813 +    .icache_restart_request (icache_restart_request),
   7.814 +    .icache_refill_request  (icache_refill_request),
   7.815 +    .icache_refilling       (icache_refilling),
   7.816 +`endif
   7.817 +`ifdef CFG_IROM_ENABLED
   7.818 +    .irom_data_m            (irom_data_m),
   7.819 +`endif
   7.820 +`ifdef CFG_IWB_ENABLED
   7.821 +    // To Wishbone
   7.822 +    .i_dat_o                (I_DAT_O),
   7.823 +    .i_adr_o                (I_ADR_O),
   7.824 +    .i_cyc_o                (I_CYC_O),
   7.825 +    .i_sel_o                (I_SEL_O),
   7.826 +    .i_stb_o                (I_STB_O),
   7.827 +    .i_we_o                 (I_WE_O),
   7.828 +    .i_cti_o                (I_CTI_O),
   7.829 +    .i_lock_o               (I_LOCK_O),
   7.830 +    .i_bte_o                (I_BTE_O),
   7.831 +`endif
   7.832 +`ifdef CFG_HW_DEBUG_ENABLED
   7.833 +    .jtag_read_data         (jtag_read_data),
   7.834 +    .jtag_access_complete   (jtag_access_complete),
   7.835 +`endif
   7.836 +`ifdef CFG_BUS_ERRORS_ENABLED
   7.837 +    .bus_error_d            (bus_error_d),
   7.838 +`endif
   7.839 +`ifdef CFG_EBR_POSEDGE_REGISTER_FILE
   7.840 +    .instruction_f          (instruction_f),
   7.841 +`endif
   7.842 +    .instruction_d          (instruction_d)
   7.843 +    );
   7.844 +
   7.845 +// Instruction decoder
   7.846 +lm32_decoder decoder (
   7.847 +    // ----- Inputs -------
   7.848 +    .instruction            (instruction_d),
   7.849 +    // ----- Outputs -------
   7.850 +    .d_result_sel_0         (d_result_sel_0_d),
   7.851 +    .d_result_sel_1         (d_result_sel_1_d),
   7.852 +    .x_result_sel_csr       (x_result_sel_csr_d),
   7.853 +`ifdef LM32_MC_ARITHMETIC_ENABLED
   7.854 +    .x_result_sel_mc_arith  (x_result_sel_mc_arith_d),
   7.855 +`endif
   7.856 +`ifdef LM32_NO_BARREL_SHIFT    
   7.857 +    .x_result_sel_shift     (x_result_sel_shift_d),
   7.858 +`endif
   7.859 +`ifdef CFG_SIGN_EXTEND_ENABLED
   7.860 +    .x_result_sel_sext      (x_result_sel_sext_d),
   7.861 +`endif    
   7.862 +    .x_result_sel_logic     (x_result_sel_logic_d),
   7.863 +`ifdef CFG_USER_ENABLED
   7.864 +    .x_result_sel_user      (x_result_sel_user_d),
   7.865 +`endif
   7.866 +    .x_result_sel_add       (x_result_sel_add_d),
   7.867 +    .m_result_sel_compare   (m_result_sel_compare_d),
   7.868 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
   7.869 +    .m_result_sel_shift     (m_result_sel_shift_d),  
   7.870 +`endif    
   7.871 +    .w_result_sel_load      (w_result_sel_load_d),
   7.872 +`ifdef CFG_PL_MULTIPLY_ENABLED
   7.873 +    .w_result_sel_mul       (w_result_sel_mul_d),
   7.874 +`endif
   7.875 +    .x_bypass_enable        (x_bypass_enable_d),
   7.876 +    .m_bypass_enable        (m_bypass_enable_d),
   7.877 +    .read_enable_0          (read_enable_0_d),
   7.878 +    .read_idx_0             (read_idx_0_d),
   7.879 +    .read_enable_1          (read_enable_1_d),
   7.880 +    .read_idx_1             (read_idx_1_d),
   7.881 +    .write_enable           (write_enable_d),
   7.882 +    .write_idx              (write_idx_d),
   7.883 +    .immediate              (immediate_d),
   7.884 +    .branch_offset          (branch_offset_d),
   7.885 +    .load                   (load_d),
   7.886 +    .store                  (store_d),
   7.887 +    .size                   (size_d),
   7.888 +    .sign_extend            (sign_extend_d),
   7.889 +    .adder_op               (adder_op_d),
   7.890 +    .logic_op               (logic_op_d),
   7.891 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
   7.892 +    .direction              (direction_d),
   7.893 +`endif
   7.894 +`ifdef CFG_MC_BARREL_SHIFT_ENABLED
   7.895 +    .shift_left             (shift_left_d),
   7.896 +    .shift_right            (shift_right_d),
   7.897 +`endif
   7.898 +`ifdef CFG_MC_MULTIPLY_ENABLED
   7.899 +    .multiply               (multiply_d),
   7.900 +`endif
   7.901 +`ifdef CFG_MC_DIVIDE_ENABLED
   7.902 +    .divide                 (divide_d),
   7.903 +    .modulus                (modulus_d),
   7.904 +`endif
   7.905 +    .branch                 (branch_d),
   7.906 +    .bi_unconditional       (bi_unconditional),
   7.907 +    .bi_conditional         (bi_conditional),
   7.908 +    .branch_reg             (branch_reg_d),
   7.909 +    .condition              (condition_d),
   7.910 +`ifdef CFG_DEBUG_ENABLED
   7.911 +    .break_opcode           (break_d),
   7.912 +`endif
   7.913 +    .scall                  (scall_d),
   7.914 +    .eret                   (eret_d),
   7.915 +`ifdef CFG_DEBUG_ENABLED
   7.916 +    .bret                   (bret_d),
   7.917 +`endif
   7.918 +`ifdef CFG_USER_ENABLED
   7.919 +    .user_opcode            (user_opcode_d),
   7.920 +`endif
   7.921 +    .csr_write_enable       (csr_write_enable_d)
   7.922 +    ); 
   7.923 +
   7.924 +// Load/store unit       
   7.925 +lm32_load_store_unit #(
   7.926 +    .associativity          (dcache_associativity),
   7.927 +    .sets                   (dcache_sets),
   7.928 +    .bytes_per_line         (dcache_bytes_per_line),
   7.929 +    .base_address           (dcache_base_address),
   7.930 +    .limit                  (dcache_limit)
   7.931 +  ) load_store_unit (
   7.932 +    // ----- Inputs -------
   7.933 +    .clk_i                  (clk_i),
   7.934 +    .rst_i                  (rst_i),
   7.935 +    // From pipeline
   7.936 +    .stall_a                (stall_a),
   7.937 +    .stall_x                (stall_x),
   7.938 +    .stall_m                (stall_m),
   7.939 +    .kill_x                 (kill_x),
   7.940 +    .kill_m                 (kill_m),
   7.941 +    .exception_m            (exception_m),
   7.942 +    .store_operand_x        (store_operand_x),
   7.943 +    .load_store_address_x   (adder_result_x),
   7.944 +    .load_store_address_m   (operand_m),
   7.945 +    .load_store_address_w   (operand_w[1:0]),
   7.946 +    .load_x                 (load_x),
   7.947 +    .store_x                (store_x),
   7.948 +    .load_q_x               (load_q_x),
   7.949 +    .store_q_x              (store_q_x),
   7.950 +    .load_q_m               (load_q_m),
   7.951 +    .store_q_m              (store_q_m),
   7.952 +    .sign_extend_x          (sign_extend_x),
   7.953 +    .size_x                 (size_x),
   7.954 +`ifdef CFG_DCACHE_ENABLED
   7.955 +    .dflush                 (dflush_m),
   7.956 +`endif
   7.957 +`ifdef CFG_IROM_ENABLED
   7.958 +    .irom_data_m            (irom_data_m),
   7.959 +`endif
   7.960 +    // From Wishbone
   7.961 +    .d_dat_i                (D_DAT_I),
   7.962 +    .d_ack_i                (D_ACK_I),
   7.963 +    .d_err_i                (D_ERR_I),
   7.964 +    .d_rty_i                (D_RTY_I),
   7.965 +    // ----- Outputs -------
   7.966 +    // To pipeline
   7.967 +`ifdef CFG_DCACHE_ENABLED
   7.968 +    .dcache_refill_request  (dcache_refill_request),
   7.969 +    .dcache_restart_request (dcache_restart_request),
   7.970 +    .dcache_stall_request   (dcache_stall_request),
   7.971 +    .dcache_refilling       (dcache_refilling),
   7.972 +`endif    
   7.973 +`ifdef CFG_IROM_ENABLED
   7.974 +    .irom_store_data_m      (irom_store_data_m),
   7.975 +    .irom_address_xm        (irom_address_xm),
   7.976 +    .irom_we_xm             (irom_we_xm),
   7.977 +    .irom_stall_request_x   (irom_stall_request_x),
   7.978 +`endif
   7.979 +    .load_data_w            (load_data_w),
   7.980 +    .stall_wb_load          (stall_wb_load),
   7.981 +    // To Wishbone
   7.982 +    .d_dat_o                (D_DAT_O),
   7.983 +    .d_adr_o                (D_ADR_O),
   7.984 +    .d_cyc_o                (D_CYC_O),
   7.985 +    .d_sel_o                (D_SEL_O),
   7.986 +    .d_stb_o                (D_STB_O),
   7.987 +    .d_we_o                 (D_WE_O),
   7.988 +    .d_cti_o                (D_CTI_O),
   7.989 +    .d_lock_o               (D_LOCK_O),
   7.990 +    .d_bte_o                (D_BTE_O)
   7.991 +    );      
   7.992 +       
   7.993 +// Adder       
   7.994 +lm32_adder adder (
   7.995 +    // ----- Inputs -------
   7.996 +    .adder_op_x             (adder_op_x),
   7.997 +    .adder_op_x_n           (adder_op_x_n),
   7.998 +    .operand_0_x            (operand_0_x),
   7.999 +    .operand_1_x            (operand_1_x),
  7.1000 +    // ----- Outputs -------
  7.1001 +    .adder_result_x         (adder_result_x),
  7.1002 +    .adder_carry_n_x        (adder_carry_n_x),
  7.1003 +    .adder_overflow_x       (adder_overflow_x)
  7.1004 +    );
  7.1005 +
  7.1006 +// Logic operations
  7.1007 +lm32_logic_op logic_op (
  7.1008 +    // ----- Inputs -------
  7.1009 +    .logic_op_x             (logic_op_x),
  7.1010 +    .operand_0_x            (operand_0_x),
  7.1011 +
  7.1012 +    .operand_1_x            (operand_1_x),
  7.1013 +    // ----- Outputs -------
  7.1014 +    .logic_result_x         (logic_result_x)
  7.1015 +    );
  7.1016 +              
  7.1017 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
  7.1018 +// Pipelined barrel-shifter
  7.1019 +lm32_shifter shifter (
  7.1020 +    // ----- Inputs -------
  7.1021 +    .clk_i                  (clk_i),
  7.1022 +    .rst_i                  (rst_i),
  7.1023 +    .stall_x                (stall_x),
  7.1024 +    .direction_x            (direction_x),
  7.1025 +    .sign_extend_x          (sign_extend_x),
  7.1026 +    .operand_0_x            (operand_0_x),
  7.1027 +    .operand_1_x            (operand_1_x),
  7.1028 +    // ----- Outputs -------
  7.1029 +    .shifter_result_m       (shifter_result_m)
  7.1030 +    );
  7.1031 +`endif
  7.1032 +
  7.1033 +`ifdef CFG_PL_MULTIPLY_ENABLED
  7.1034 +// Pipeline fixed-point multiplier
  7.1035 +lm32_multiplier multiplier (
  7.1036 +    // ----- Inputs -------
  7.1037 +    .clk_i                  (clk_i),
  7.1038 +    .rst_i                  (rst_i),
  7.1039 +    .stall_x                (stall_x),
  7.1040 +    .stall_m                (stall_m),
  7.1041 +    .operand_0              (d_result_0),
  7.1042 +    .operand_1              (d_result_1),
  7.1043 +    // ----- Outputs -------
  7.1044 +    .result                 (multiplier_result_w)    
  7.1045 +    );
  7.1046 +`endif
  7.1047 +
  7.1048 +`ifdef LM32_MC_ARITHMETIC_ENABLED
  7.1049 +// Multi-cycle arithmetic
  7.1050 +lm32_mc_arithmetic mc_arithmetic (
  7.1051 +    // ----- Inputs -------
  7.1052 +    .clk_i                  (clk_i),
  7.1053 +    .rst_i                  (rst_i),
  7.1054 +    .stall_d                (stall_d),
  7.1055 +    .kill_x                 (kill_x),
  7.1056 +`ifdef CFG_MC_DIVIDE_ENABLED                  
  7.1057 +    .divide_d               (divide_q_d),
  7.1058 +    .modulus_d              (modulus_q_d),
  7.1059 +`endif
  7.1060 +`ifdef CFG_MC_MULTIPLY_ENABLED        
  7.1061 +    .multiply_d             (multiply_q_d),
  7.1062 +`endif
  7.1063 +`ifdef CFG_MC_BARREL_SHIFT_ENABLED
  7.1064 +    .shift_left_d           (shift_left_q_d),
  7.1065 +    .shift_right_d          (shift_right_q_d),
  7.1066 +    .sign_extend_d          (sign_extend_d),
  7.1067 +`endif    
  7.1068 +    .operand_0_d            (d_result_0),
  7.1069 +    .operand_1_d            (d_result_1),
  7.1070 +    // ----- Outputs -------
  7.1071 +    .result_x               (mc_result_x),
  7.1072 +`ifdef CFG_MC_DIVIDE_ENABLED                  
  7.1073 +    .divide_by_zero_x       (divide_by_zero_x),
  7.1074 +`endif
  7.1075 +    .stall_request_x        (mc_stall_request_x)
  7.1076 +    );
  7.1077 +`endif
  7.1078 +              
  7.1079 +`ifdef CFG_INTERRUPTS_ENABLED
  7.1080 +// Interrupt unit
  7.1081 +lm32_interrupt interrupt (
  7.1082 +    // ----- Inputs -------
  7.1083 +    .clk_i                  (clk_i), 
  7.1084 +    .rst_i                  (rst_i),
  7.1085 +    // From external devices
  7.1086 +    .interrupt_n            (interrupt_n),
  7.1087 +    // From pipeline
  7.1088 +    .stall_x                (stall_x),
  7.1089 +`ifdef CFG_DEBUG_ENABLED
  7.1090 +    .non_debug_exception    (non_debug_exception_q_w), 
  7.1091 +    .debug_exception        (debug_exception_q_w),
  7.1092 +`else
  7.1093 +    .exception              (exception_q_w), 
  7.1094 +`endif
  7.1095 +    .eret_q_x               (eret_q_x),
  7.1096 +`ifdef CFG_DEBUG_ENABLED
  7.1097 +    .bret_q_x               (bret_q_x),
  7.1098 +`endif
  7.1099 +    .csr                    (csr_x),
  7.1100 +    .csr_write_data         (operand_1_x),
  7.1101 +    .csr_write_enable       (csr_write_enable_q_x),
  7.1102 +    // ----- Outputs -------
  7.1103 +    .interrupt_exception    (interrupt_exception),
  7.1104 +    // To pipeline
  7.1105 +    .csr_read_data          (interrupt_csr_read_data_x)
  7.1106 +    );
  7.1107 +`endif
  7.1108 +
  7.1109 +`ifdef CFG_JTAG_ENABLED
  7.1110 +// JTAG interface
  7.1111 +lm32_jtag jtag (
  7.1112 +    // ----- Inputs -------
  7.1113 +    .clk_i                  (clk_i),
  7.1114 +    .rst_i                  (rst_i),
  7.1115 +    // From JTAG
  7.1116 +    .jtag_clk               (jtag_clk),
  7.1117 +    .jtag_update            (jtag_update),
  7.1118 +    .jtag_reg_q             (jtag_reg_q),
  7.1119 +    .jtag_reg_addr_q        (jtag_reg_addr_q),
  7.1120 +    // From pipeline
  7.1121 +`ifdef CFG_JTAG_UART_ENABLED
  7.1122 +    .csr                    (csr_x),
  7.1123 +    .csr_write_data         (operand_1_x),
  7.1124 +    .csr_write_enable       (csr_write_enable_q_x),
  7.1125 +    .stall_x                (stall_x),
  7.1126 +`endif
  7.1127 +`ifdef CFG_HW_DEBUG_ENABLED
  7.1128 +    .jtag_read_data         (jtag_read_data),
  7.1129 +    .jtag_access_complete   (jtag_access_complete),
  7.1130 +`endif
  7.1131 +`ifdef CFG_DEBUG_ENABLED
  7.1132 +    .exception_q_w          (debug_exception_q_w || non_debug_exception_q_w),
  7.1133 +`endif    
  7.1134 +    // ----- Outputs -------
  7.1135 +    // To pipeline
  7.1136 +`ifdef CFG_JTAG_UART_ENABLED
  7.1137 +    .jtx_csr_read_data      (jtx_csr_read_data),
  7.1138 +    .jrx_csr_read_data      (jrx_csr_read_data),
  7.1139 +`endif
  7.1140 +`ifdef CFG_HW_DEBUG_ENABLED
  7.1141 +    .jtag_csr_write_enable  (jtag_csr_write_enable),
  7.1142 +    .jtag_csr_write_data    (jtag_csr_write_data),
  7.1143 +    .jtag_csr               (jtag_csr),
  7.1144 +    .jtag_read_enable       (jtag_read_enable),
  7.1145 +    .jtag_write_enable      (jtag_write_enable),
  7.1146 +    .jtag_write_data        (jtag_write_data),
  7.1147 +    .jtag_address           (jtag_address),
  7.1148 +`endif
  7.1149 +`ifdef CFG_DEBUG_ENABLED
  7.1150 +    .jtag_break             (jtag_break),
  7.1151 +    .jtag_reset             (reset_exception),
  7.1152 +`endif
  7.1153 +    // To JTAG 
  7.1154 +    .jtag_reg_d             (jtag_reg_d),
  7.1155 +    .jtag_reg_addr_d        (jtag_reg_addr_d)
  7.1156 +    );
  7.1157 +`endif
  7.1158 +
  7.1159 +`ifdef CFG_DEBUG_ENABLED
  7.1160 +// Debug unit
  7.1161 +lm32_debug #(
  7.1162 +    .breakpoints            (breakpoints),
  7.1163 +    .watchpoints            (watchpoints)
  7.1164 +  ) hw_debug (
  7.1165 +    // ----- Inputs -------
  7.1166 +    .clk_i                  (clk_i), 
  7.1167 +    .rst_i                  (rst_i),
  7.1168 +    .pc_x                   (pc_x),
  7.1169 +    .load_x                 (load_x),
  7.1170 +    .store_x                (store_x),
  7.1171 +    .load_store_address_x   (adder_result_x),
  7.1172 +    .csr_write_enable_x     (csr_write_enable_q_x),
  7.1173 +    .csr_write_data         (operand_1_x),
  7.1174 +    .csr_x                  (csr_x),
  7.1175 +`ifdef CFG_HW_DEBUG_ENABLED
  7.1176 +    .jtag_csr_write_enable  (jtag_csr_write_enable),
  7.1177 +    .jtag_csr_write_data    (jtag_csr_write_data),
  7.1178 +    .jtag_csr               (jtag_csr),
  7.1179 +`endif
  7.1180 +`ifdef LM32_SINGLE_STEP_ENABLED
  7.1181 +    .eret_q_x               (eret_q_x),
  7.1182 +    .bret_q_x               (bret_q_x),
  7.1183 +    .stall_x                (stall_x),
  7.1184 +    .exception_x            (exception_x),
  7.1185 +    .q_x                    (q_x),
  7.1186 +`ifdef CFG_DCACHE_ENABLED
  7.1187 +    .dcache_refill_request  (dcache_refill_request),
  7.1188 +`endif
  7.1189 +`endif
  7.1190 +    // ----- Outputs -------
  7.1191 +`ifdef LM32_SINGLE_STEP_ENABLED
  7.1192 +    .dc_ss                  (dc_ss),
  7.1193 +`endif
  7.1194 +    .dc_re                  (dc_re),
  7.1195 +    .bp_match               (bp_match),
  7.1196 +    .wp_match               (wp_match)
  7.1197 +    );
  7.1198 +`endif
  7.1199 +
  7.1200 +// Register file
  7.1201 +
  7.1202 +`ifdef CFG_EBR_POSEDGE_REGISTER_FILE
  7.1203 +   /*----------------------------------------------------------------------
  7.1204 +    Register File is implemented using EBRs. There can be three accesses to
  7.1205 +    the register file in each cycle: two reads and one write. On-chip block
  7.1206 +    RAM has two read/write ports. To accomodate three accesses, two on-chip
  7.1207 +    block RAMs are used (each register file "write" is made to both block
  7.1208 +    RAMs).
  7.1209 +    
  7.1210 +    One limitation of the on-chip block RAMs is that one cannot perform a 
  7.1211 +    read and write to same location in a cycle (if this is done, then the
  7.1212 +    data read out is indeterminate).
  7.1213 +    ----------------------------------------------------------------------*/
  7.1214 +   wire [31:0] regfile_data_0, regfile_data_1;
  7.1215 +   reg [31:0]  w_result_d;
  7.1216 +   reg 	       regfile_raw_0, regfile_raw_0_nxt;
  7.1217 +   reg 	       regfile_raw_1, regfile_raw_1_nxt;
  7.1218 +   
  7.1219 +   /*----------------------------------------------------------------------
  7.1220 +    Check if read and write is being performed to same register in current 
  7.1221 +    cycle? This is done by comparing the read and write IDXs.
  7.1222 +    ----------------------------------------------------------------------*/
  7.1223 +   always @(reg_write_enable_q_w or write_idx_w or instruction_f)
  7.1224 +     begin
  7.1225 +	if (reg_write_enable_q_w
  7.1226 +	    && (write_idx_w == instruction_f[25:21]))
  7.1227 +	  regfile_raw_0_nxt = 1'b1;
  7.1228 +	else
  7.1229 +	  regfile_raw_0_nxt = 1'b0;
  7.1230 +	
  7.1231 +	if (reg_write_enable_q_w
  7.1232 +	    && (write_idx_w == instruction_f[20:16]))
  7.1233 +	  regfile_raw_1_nxt = 1'b1;
  7.1234 +	else
  7.1235 +	  regfile_raw_1_nxt = 1'b0;
  7.1236 +     end
  7.1237 +   
  7.1238 +   /*----------------------------------------------------------------------
  7.1239 +    Select latched (delayed) write value or data from register file. If 
  7.1240 +    read in previous cycle was performed to register written to in same
  7.1241 +    cycle, then latched (delayed) write value is selected.
  7.1242 +    ----------------------------------------------------------------------*/
  7.1243 +   always @(regfile_raw_0 or w_result_d or regfile_data_0)
  7.1244 +     if (regfile_raw_0)
  7.1245 +       reg_data_live_0 = w_result_d;
  7.1246 +     else
  7.1247 +       reg_data_live_0 = regfile_data_0;
  7.1248 +   
  7.1249 +   /*----------------------------------------------------------------------
  7.1250 +    Select latched (delayed) write value or data from register file. If 
  7.1251 +    read in previous cycle was performed to register written to in same
  7.1252 +    cycle, then latched (delayed) write value is selected.
  7.1253 +    ----------------------------------------------------------------------*/
  7.1254 +   always @(regfile_raw_1 or w_result_d or regfile_data_1)
  7.1255 +     if (regfile_raw_1)
  7.1256 +       reg_data_live_1 = w_result_d;
  7.1257 +     else
  7.1258 +       reg_data_live_1 = regfile_data_1;
  7.1259 +   
  7.1260 +   /*----------------------------------------------------------------------
  7.1261 +    Latch value written to register file
  7.1262 +    ----------------------------------------------------------------------*/
  7.1263 +   always @(posedge clk_i `CFG_RESET_SENSITIVITY)
  7.1264 +     if (rst_i == `TRUE)
  7.1265 +       begin
  7.1266 +	  regfile_raw_0 <= 1'b0;
  7.1267 +	  regfile_raw_1 <= 1'b0;
  7.1268 +	  w_result_d <= 32'b0;
  7.1269 +       end
  7.1270 +     else
  7.1271 +       begin
  7.1272 +	  regfile_raw_0 <= regfile_raw_0_nxt;
  7.1273 +	  regfile_raw_1 <= regfile_raw_1_nxt;
  7.1274 +	  w_result_d <= w_result;
  7.1275 +       end
  7.1276 +   
  7.1277 +   /*----------------------------------------------------------------------
  7.1278 +    Register file instantiation as Pseudo-Dual Port EBRs.
  7.1279 +    ----------------------------------------------------------------------*/
  7.1280 +   pmi_ram_dp
  7.1281 +     #(
  7.1282 +       // ----- Parameters -----
  7.1283 +       .pmi_wr_addr_depth(1<<5),
  7.1284 +       .pmi_wr_addr_width(5),
  7.1285 +       .pmi_wr_data_width(32),
  7.1286 +       .pmi_rd_addr_depth(1<<5),
  7.1287 +       .pmi_rd_addr_width(5),
  7.1288 +       .pmi_rd_data_width(32),
  7.1289 +       .pmi_regmode("noreg"),
  7.1290 +       .pmi_gsr("enable"),
  7.1291 +       .pmi_resetmode("sync"),
  7.1292 +       .pmi_init_file("none"),
  7.1293 +       .pmi_init_file_format("binary"),
  7.1294 +       .pmi_family(`LATTICE_FAMILY),
  7.1295 +       .module_type("pmi_ram_dp")
  7.1296 +       )
  7.1297 +   reg_0
  7.1298 +     (
  7.1299 +      // ----- Inputs -----
  7.1300 +      .Data(w_result),
  7.1301 +      .WrAddress(write_idx_w),
  7.1302 +      .RdAddress(instruction_f[25:21]),
  7.1303 +      .WrClock(clk_i),
  7.1304 +      .RdClock(clk_i),
  7.1305 +      .WrClockEn(`TRUE),
  7.1306 +      .RdClockEn(`TRUE),
  7.1307 +      .WE(reg_write_enable_q_w),
  7.1308 +      .Reset(rst_i), 
  7.1309 +      // ----- Outputs -----
  7.1310 +      .Q(regfile_data_0)
  7.1311 +      );
  7.1312 +
  7.1313 +   pmi_ram_dp
  7.1314 +     #(
  7.1315 +       // ----- Parameters -----
  7.1316 +       .pmi_wr_addr_depth(1<<5),
  7.1317 +       .pmi_wr_addr_width(5),
  7.1318 +       .pmi_wr_data_width(32),
  7.1319 +       .pmi_rd_addr_depth(1<<5),
  7.1320 +       .pmi_rd_addr_width(5),
  7.1321 +       .pmi_rd_data_width(32),
  7.1322 +       .pmi_regmode("noreg"),
  7.1323 +       .pmi_gsr("enable"),
  7.1324 +       .pmi_resetmode("sync"),
  7.1325 +       .pmi_init_file("none"),
  7.1326 +       .pmi_init_file_format("binary"),
  7.1327 +       .pmi_family(`LATTICE_FAMILY),
  7.1328 +       .module_type("pmi_ram_dp")
  7.1329 +       )
  7.1330 +   reg_1
  7.1331 +     (
  7.1332 +      // ----- Inputs -----
  7.1333 +      .Data(w_result),
  7.1334 +      .WrAddress(write_idx_w),
  7.1335 +      .RdAddress(instruction_f[20:16]),
  7.1336 +      .WrClock(clk_i),
  7.1337 +      .RdClock(clk_i),
  7.1338 +      .WrClockEn(`TRUE),
  7.1339 +      .RdClockEn(`TRUE),
  7.1340 +      .WE(reg_write_enable_q_w),
  7.1341 +      .Reset(rst_i), 
  7.1342 +      // ----- Outputs -----
  7.1343 +      .Q(regfile_data_1)
  7.1344 +      );
  7.1345 +`endif
  7.1346 +
  7.1347 +`ifdef CFG_EBR_NEGEDGE_REGISTER_FILE
  7.1348 +   pmi_ram_dp
  7.1349 +     #(
  7.1350 +       // ----- Parameters -----
  7.1351 +       .pmi_wr_addr_depth(1<<5),
  7.1352 +       .pmi_wr_addr_width(5),
  7.1353 +       .pmi_wr_data_width(32),
  7.1354 +       .pmi_rd_addr_depth(1<<5),
  7.1355 +       .pmi_rd_addr_width(5),
  7.1356 +       .pmi_rd_data_width(32),
  7.1357 +       .pmi_regmode("noreg"),
  7.1358 +       .pmi_gsr("enable"),
  7.1359 +       .pmi_resetmode("sync"),
  7.1360 +       .pmi_init_file("none"),
  7.1361 +       .pmi_init_file_format("binary"),
  7.1362 +       .pmi_family(`LATTICE_FAMILY),
  7.1363 +       .module_type("pmi_ram_dp")
  7.1364 +       )
  7.1365 +   reg_0
  7.1366 +     (
  7.1367 +      // ----- Inputs -----
  7.1368 +      .Data(w_result),
  7.1369 +      .WrAddress(write_idx_w),
  7.1370 +      .RdAddress(read_idx_0_d),
  7.1371 +      .WrClock(clk_i),
  7.1372 +      .RdClock(clk_n_i),
  7.1373 +      .WrClockEn(`TRUE),
  7.1374 +      .RdClockEn(stall_f == `FALSE),
  7.1375 +      .WE(reg_write_enable_q_w),
  7.1376 +      .Reset(rst_i), 
  7.1377 +      // ----- Outputs -----
  7.1378 +      .Q(reg_data_0)
  7.1379 +      );
  7.1380 +   
  7.1381 +   pmi_ram_dp
  7.1382 +     #(
  7.1383 +       // ----- Parameters -----
  7.1384 +       .pmi_wr_addr_depth(1<<5),
  7.1385 +       .pmi_wr_addr_width(5),
  7.1386 +       .pmi_wr_data_width(32),
  7.1387 +       .pmi_rd_addr_depth(1<<5),
  7.1388 +       .pmi_rd_addr_width(5),
  7.1389 +       .pmi_rd_data_width(32),
  7.1390 +       .pmi_regmode("noreg"),
  7.1391 +       .pmi_gsr("enable"),
  7.1392 +       .pmi_resetmode("sync"),
  7.1393 +       .pmi_init_file("none"),
  7.1394 +       .pmi_init_file_format("binary"),
  7.1395 +       .pmi_family(`LATTICE_FAMILY),
  7.1396 +       .module_type("pmi_ram_dp")
  7.1397 +       )
  7.1398 +   reg_1
  7.1399 +     (
  7.1400 +      // ----- Inputs -----
  7.1401 +      .Data(w_result),
  7.1402 +      .WrAddress(write_idx_w),
  7.1403 +      .RdAddress(read_idx_1_d),
  7.1404 +      .WrClock(clk_i),
  7.1405 +      .RdClock(clk_n_i),
  7.1406 +      .WrClockEn(`TRUE),
  7.1407 +      .RdClockEn(stall_f == `FALSE),
  7.1408 +      .WE(reg_write_enable_q_w),
  7.1409 +      .Reset(rst_i), 
  7.1410 +      // ----- Outputs -----
  7.1411 +      .Q(reg_data_1)
  7.1412 +      );
  7.1413 +`endif
  7.1414 +
  7.1415 +
  7.1416 +/////////////////////////////////////////////////////
  7.1417 +// Combinational Logic
  7.1418 +/////////////////////////////////////////////////////
  7.1419 +
  7.1420 +`ifdef CFG_EBR_POSEDGE_REGISTER_FILE
  7.1421 +// Select between buffered and live data from register file
  7.1422 +assign reg_data_0 = use_buf ? reg_data_buf_0 : reg_data_live_0;
  7.1423 +assign reg_data_1 = use_buf ? reg_data_buf_1 : reg_data_live_1;
  7.1424 +`endif
  7.1425 +`ifdef LM32_EBR_REGISTER_FILE
  7.1426 +`else
  7.1427 +// Register file read ports
  7.1428 +assign reg_data_0 = registers[read_idx_0_d];
  7.1429 +assign reg_data_1 = registers[read_idx_1_d];
  7.1430 +`endif
  7.1431 +
  7.1432 +// Detect read-after-write hazzards
  7.1433 +assign raw_x_0 = (write_idx_x == read_idx_0_d) && (write_enable_q_x == `TRUE);
  7.1434 +assign raw_m_0 = (write_idx_m == read_idx_0_d) && (write_enable_q_m == `TRUE);
  7.1435 +assign raw_w_0 = (write_idx_w == read_idx_0_d) && (write_enable_q_w == `TRUE);
  7.1436 +assign raw_x_1 = (write_idx_x == read_idx_1_d) && (write_enable_q_x == `TRUE);
  7.1437 +assign raw_m_1 = (write_idx_m == read_idx_1_d) && (write_enable_q_m == `TRUE);
  7.1438 +assign raw_w_1 = (write_idx_w == read_idx_1_d) && (write_enable_q_w == `TRUE);
  7.1439 +
  7.1440 +// Interlock detection - Raise an interlock for RAW hazzards 
  7.1441 +always @(*)
  7.1442 +begin
  7.1443 +    if (   (   (x_bypass_enable_x == `FALSE)
  7.1444 +            && (   ((read_enable_0_d == `TRUE) && (raw_x_0 == `TRUE))
  7.1445 +                || ((read_enable_1_d == `TRUE) && (raw_x_1 == `TRUE))
  7.1446 +               )
  7.1447 +           )
  7.1448 +        || (   (m_bypass_enable_m == `FALSE)
  7.1449 +            && (   ((read_enable_0_d == `TRUE) && (raw_m_0 == `TRUE))
  7.1450 +                || ((read_enable_1_d == `TRUE) && (raw_m_1 == `TRUE))
  7.1451 +               )
  7.1452 +           )
  7.1453 +       )
  7.1454 +        interlock = `TRUE;
  7.1455 +    else
  7.1456 +        interlock = `FALSE;
  7.1457 +end
  7.1458 +
  7.1459 +// Bypass for reg port 0
  7.1460 +always @(*)
  7.1461 +begin
  7.1462 +    if (raw_x_0 == `TRUE)        
  7.1463 +        bypass_data_0 = x_result;
  7.1464 +    else if (raw_m_0 == `TRUE)
  7.1465 +        bypass_data_0 = m_result;
  7.1466 +    else if (raw_w_0 == `TRUE)
  7.1467 +        bypass_data_0 = w_result;
  7.1468 +    else
  7.1469 +        bypass_data_0 = reg_data_0;
  7.1470 +end
  7.1471 +
  7.1472 +// Bypass for reg port 1
  7.1473 +always @(*)
  7.1474 +begin
  7.1475 +    if (raw_x_1 == `TRUE)
  7.1476 +        bypass_data_1 = x_result;
  7.1477 +    else if (raw_m_1 == `TRUE)
  7.1478 +        bypass_data_1 = m_result;
  7.1479 +    else if (raw_w_1 == `TRUE)
  7.1480 +        bypass_data_1 = w_result;
  7.1481 +    else
  7.1482 +        bypass_data_1 = reg_data_1;
  7.1483 +end
  7.1484 +
  7.1485 +   /*----------------------------------------------------------------------
  7.1486 +    Branch prediction is performed in D stage of pipeline. Only PC-relative
  7.1487 +    branches are predicted: forward-pointing conditional branches are not-
  7.1488 +    taken, while backward-pointing conditional branches are taken. 
  7.1489 +    Unconditional branches are always predicted taken!
  7.1490 +    ----------------------------------------------------------------------*/
  7.1491 +   assign branch_predict_d = bi_unconditional | bi_conditional;
  7.1492 +   assign branch_predict_taken_d = bi_unconditional ? 1'b1 : (bi_conditional ? instruction_d[15] : 1'b0);
  7.1493 +   
  7.1494 +   // Compute branch target address: Branch PC PLUS Offset
  7.1495 +   assign branch_target_d = pc_d + branch_offset_d;
  7.1496 +
  7.1497 +   // Compute fetch address. Address of instruction sequentially after the
  7.1498 +   // branch if branch is not taken. Target address of branch is branch is
  7.1499 +   // taken
  7.1500 +   assign branch_predict_address_d = branch_predict_taken_d ? branch_target_d : pc_f;
  7.1501 +
  7.1502 +// D stage result selection
  7.1503 +always @(*)
  7.1504 +begin
  7.1505 +    d_result_0 = d_result_sel_0_d[0] ? {pc_f, 2'b00} : bypass_data_0; 
  7.1506 +    case (d_result_sel_1_d)
  7.1507 +    `LM32_D_RESULT_SEL_1_ZERO:      d_result_1 = {`LM32_WORD_WIDTH{1'b0}};
  7.1508 +    `LM32_D_RESULT_SEL_1_REG_1:     d_result_1 = bypass_data_1;
  7.1509 +    `LM32_D_RESULT_SEL_1_IMMEDIATE: d_result_1 = immediate_d;
  7.1510 +    default:                        d_result_1 = {`LM32_WORD_WIDTH{1'bx}};
  7.1511 +    endcase
  7.1512 +end
  7.1513 +
  7.1514 +`ifdef CFG_USER_ENABLED    
  7.1515 +// Operands for user-defined instructions
  7.1516 +assign user_operand_0 = operand_0_x;
  7.1517 +assign user_operand_1 = operand_1_x;
  7.1518 +`endif
  7.1519 +
  7.1520 +`ifdef CFG_SIGN_EXTEND_ENABLED
  7.1521 +// Sign-extension
  7.1522 +assign sextb_result_x = {{24{operand_0_x[7]}}, operand_0_x[7:0]};
  7.1523 +assign sexth_result_x = {{16{operand_0_x[15]}}, operand_0_x[15:0]};
  7.1524 +assign sext_result_x = size_x == `LM32_SIZE_BYTE ? sextb_result_x : sexth_result_x;
  7.1525 +`endif
  7.1526 +
  7.1527 +`ifdef LM32_NO_BARREL_SHIFT
  7.1528 +// Only single bit shift operations are supported when barrel-shifter isn't implemented
  7.1529 +assign shifter_result_x = {operand_0_x[`LM32_WORD_WIDTH-1] & sign_extend_x, operand_0_x[`LM32_WORD_WIDTH-1:1]};
  7.1530 +`endif
  7.1531 +
  7.1532 +// Condition evaluation
  7.1533 +assign cmp_zero = operand_0_x == operand_1_x;
  7.1534 +assign cmp_negative = adder_result_x[`LM32_WORD_WIDTH-1];
  7.1535 +assign cmp_overflow = adder_overflow_x;
  7.1536 +assign cmp_carry_n = adder_carry_n_x;
  7.1537 +always @(*)
  7.1538 +begin
  7.1539 +    case (condition_x)
  7.1540 +    `LM32_CONDITION_U1:   condition_met_x = `TRUE;
  7.1541 +    `LM32_CONDITION_U2:   condition_met_x = `TRUE;
  7.1542 +    `LM32_CONDITION_E:    condition_met_x = cmp_zero;
  7.1543 +    `LM32_CONDITION_NE:   condition_met_x = !cmp_zero;
  7.1544 +    `LM32_CONDITION_G:    condition_met_x = !cmp_zero && (cmp_negative == cmp_overflow);
  7.1545 +    `LM32_CONDITION_GU:   condition_met_x = cmp_carry_n && !cmp_zero;
  7.1546 +    `LM32_CONDITION_GE:   condition_met_x = cmp_negative == cmp_overflow;
  7.1547 +    `LM32_CONDITION_GEU:  condition_met_x = cmp_carry_n;
  7.1548 +    default:              condition_met_x = 1'bx;
  7.1549 +    endcase 
  7.1550 +end
  7.1551 +
  7.1552 +// X stage result selection
  7.1553 +always @(*)
  7.1554 +begin
  7.1555 +    x_result =   x_result_sel_add_x ? adder_result_x 
  7.1556 +               : x_result_sel_csr_x ? csr_read_data_x
  7.1557 +`ifdef CFG_SIGN_EXTEND_ENABLED
  7.1558 +               : x_result_sel_sext_x ? sext_result_x
  7.1559 +`endif
  7.1560 +`ifdef CFG_USER_ENABLED
  7.1561 +               : x_result_sel_user_x ? user_result
  7.1562 +`endif
  7.1563 +`ifdef LM32_NO_BARREL_SHIFT
  7.1564 +               : x_result_sel_shift_x ? shifter_result_x
  7.1565 +`endif
  7.1566 +`ifdef LM32_MC_ARITHMETIC_ENABLED
  7.1567 +               : x_result_sel_mc_arith_x ? mc_result_x
  7.1568 +`endif
  7.1569 +               : logic_result_x;
  7.1570 +end
  7.1571 +
  7.1572 +// M stage result selection
  7.1573 +always @(*)
  7.1574 +begin
  7.1575 +    m_result =   m_result_sel_compare_m ? {{`LM32_WORD_WIDTH-1{1'b0}}, condition_met_m}
  7.1576 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
  7.1577 +               : m_result_sel_shift_m ? shifter_result_m
  7.1578 +`endif
  7.1579 +               : operand_m; 
  7.1580 +end
  7.1581 +
  7.1582 +// W stage result selection
  7.1583 +always @(*)
  7.1584 +begin
  7.1585 +    w_result =    w_result_sel_load_w ? load_data_w
  7.1586 +`ifdef CFG_PL_MULTIPLY_ENABLED
  7.1587 +                : w_result_sel_mul_w ? multiplier_result_w
  7.1588 +`endif
  7.1589 +                : operand_w;
  7.1590 +end
  7.1591 +
  7.1592 +`ifdef CFG_FAST_UNCONDITIONAL_BRANCH    
  7.1593 +// Indicate when a branch should be taken in X stage
  7.1594 +assign branch_taken_x =      (stall_x == `FALSE)
  7.1595 +                          && (   (branch_x == `TRUE)
  7.1596 +                              && ((condition_x == `LM32_CONDITION_U1) || (condition_x == `LM32_CONDITION_U2))
  7.1597 +                              && (valid_x == `TRUE)
  7.1598 +                              && (branch_predict_x == `FALSE)
  7.1599 +                             ); 
  7.1600 +`endif
  7.1601 +
  7.1602 +// Indicate when a branch should be taken in M stage (exceptions are a type of branch)
  7.1603 +assign branch_taken_m =      (stall_m == `FALSE) 
  7.1604 +                          && (   (   (branch_m == `TRUE) 
  7.1605 +                                  && (valid_m == `TRUE)
  7.1606 +                                  && (   (   (condition_met_m == `TRUE)
  7.1607 +					  && (branch_predict_taken_m == `FALSE)
  7.1608 +					 )
  7.1609 +				      || (   (condition_met_m == `FALSE)
  7.1610 +					  && (branch_predict_m == `TRUE)
  7.1611 +					  && (branch_predict_taken_m == `TRUE)
  7.1612 +					 )
  7.1613 +				     )
  7.1614 +                                 ) 
  7.1615 +                              || (exception_m == `TRUE)
  7.1616 +                             );
  7.1617 +
  7.1618 +// Indicate when a branch in M stage is mispredicted as being taken
  7.1619 +assign branch_mispredict_taken_m =    (condition_met_m == `FALSE)
  7.1620 +                                   && (branch_predict_m == `TRUE)
  7.1621 +	   			   && (branch_predict_taken_m == `TRUE);
  7.1622 +   
  7.1623 +// Indicate when a branch in M stage will cause flush in X stage
  7.1624 +assign branch_flushX_m =    (stall_m == `FALSE)
  7.1625 +                         && (   (   (branch_m == `TRUE) 
  7.1626 +                                 && (valid_m == `TRUE)
  7.1627 +			         && (   (condition_met_m == `TRUE)
  7.1628 +				     || (   (condition_met_m == `FALSE)
  7.1629 +					 && (branch_predict_m == `TRUE)
  7.1630 +					 && (branch_predict_taken_m == `TRUE)
  7.1631 +					)
  7.1632 +				    )
  7.1633 +			        )
  7.1634 +			     || (exception_m == `TRUE)
  7.1635 +			    );
  7.1636 +
  7.1637 +// Generate signal that will kill instructions in each pipeline stage when necessary
  7.1638 +assign kill_f =    (   (valid_d == `TRUE)
  7.1639 +                    && (branch_predict_taken_d == `TRUE)
  7.1640 +		   )
  7.1641 +                || (branch_taken_m == `TRUE) 
  7.1642 +`ifdef CFG_FAST_UNCONDITIONAL_BRANCH    
  7.1643 +                || (branch_taken_x == `TRUE)
  7.1644 +`endif
  7.1645 +`ifdef CFG_ICACHE_ENABLED
  7.1646 +                || (icache_refill_request == `TRUE) 
  7.1647 +`endif
  7.1648 +`ifdef CFG_DCACHE_ENABLED                
  7.1649 +                || (dcache_refill_request == `TRUE)
  7.1650 +`endif
  7.1651 +                ;
  7.1652 +assign kill_d =    (branch_taken_m == `TRUE) 
  7.1653 +`ifdef CFG_FAST_UNCONDITIONAL_BRANCH    
  7.1654 +                || (branch_taken_x == `TRUE)
  7.1655 +`endif
  7.1656 +`ifdef CFG_ICACHE_ENABLED
  7.1657 +                || (icache_refill_request == `TRUE)     
  7.1658 +`endif                
  7.1659 +`ifdef CFG_DCACHE_ENABLED                
  7.1660 +                || (dcache_refill_request == `TRUE)
  7.1661 +`endif
  7.1662 +                ;
  7.1663 +assign kill_x =    (branch_flushX_m == `TRUE) 
  7.1664 +`ifdef CFG_DCACHE_ENABLED                
  7.1665 +                || (dcache_refill_request == `TRUE)
  7.1666 +`endif
  7.1667 +                ;
  7.1668 +assign kill_m =    `FALSE
  7.1669 +`ifdef CFG_DCACHE_ENABLED                
  7.1670 +                || (dcache_refill_request == `TRUE)
  7.1671 +`endif
  7.1672 +                ;                
  7.1673 +assign kill_w =    `FALSE
  7.1674 +`ifdef CFG_DCACHE_ENABLED                
  7.1675 +                || (dcache_refill_request == `TRUE)
  7.1676 +`endif                
  7.1677 +                ;
  7.1678 +
  7.1679 +// Exceptions
  7.1680 +
  7.1681 +`ifdef CFG_DEBUG_ENABLED
  7.1682 +assign breakpoint_exception =    (   (   (break_x == `TRUE)
  7.1683 +				      || (bp_match == `TRUE)
  7.1684 +				     )
  7.1685 +				  && (valid_x == `TRUE)
  7.1686 +				 )
  7.1687 +`ifdef CFG_JTAG_ENABLED
  7.1688 +                              || (jtag_break == `TRUE)
  7.1689 +`endif
  7.1690 +                              ;
  7.1691 +`endif
  7.1692 +
  7.1693 +`ifdef CFG_DEBUG_ENABLED
  7.1694 +assign watchpoint_exception = wp_match == `TRUE;
  7.1695 +`endif
  7.1696 +
  7.1697 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.1698 +assign instruction_bus_error_exception = (   (bus_error_x == `TRUE)
  7.1699 +                                          && (valid_x == `TRUE)
  7.1700 +                                         );
  7.1701 +assign data_bus_error_exception = data_bus_error_seen == `TRUE;
  7.1702 +`endif
  7.1703 +
  7.1704 +`ifdef CFG_MC_DIVIDE_ENABLED
  7.1705 +assign divide_by_zero_exception = divide_by_zero_x == `TRUE;
  7.1706 +`endif
  7.1707 +
  7.1708 +assign system_call_exception = (   (scall_x == `TRUE)
  7.1709 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.1710 +                                && (valid_x == `TRUE)
  7.1711 +`endif
  7.1712 +			       );
  7.1713 +
  7.1714 +`ifdef CFG_DEBUG_ENABLED
  7.1715 +assign debug_exception_x =  (breakpoint_exception == `TRUE)
  7.1716 +                         || (watchpoint_exception == `TRUE)
  7.1717 +                         ;
  7.1718 +
  7.1719 +assign non_debug_exception_x = (system_call_exception == `TRUE)
  7.1720 +`ifdef CFG_JTAG_ENABLED
  7.1721 +                            || (reset_exception == `TRUE)
  7.1722 +`endif
  7.1723 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.1724 +                            || (instruction_bus_error_exception == `TRUE)
  7.1725 +                            || (data_bus_error_exception == `TRUE)
  7.1726 +`endif
  7.1727 +`ifdef CFG_MC_DIVIDE_ENABLED
  7.1728 +                            || (divide_by_zero_exception == `TRUE)
  7.1729 +`endif
  7.1730 +`ifdef CFG_INTERRUPTS_ENABLED
  7.1731 +                            || (   (interrupt_exception == `TRUE)
  7.1732 +`ifdef LM32_SINGLE_STEP_ENABLED
  7.1733 +                                && (dc_ss == `FALSE)
  7.1734 +`endif                            
  7.1735 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.1736 + 				&& (store_q_m == `FALSE)
  7.1737 +				&& (D_CYC_O == `FALSE)
  7.1738 +`endif
  7.1739 +                               )
  7.1740 +`endif
  7.1741 +                            ;
  7.1742 +
  7.1743 +assign exception_x = (debug_exception_x == `TRUE) || (non_debug_exception_x == `TRUE);
  7.1744 +`else
  7.1745 +assign exception_x =           (system_call_exception == `TRUE)
  7.1746 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.1747 +                            || (instruction_bus_error_exception == `TRUE)
  7.1748 +                            || (data_bus_error_exception == `TRUE)
  7.1749 +`endif
  7.1750 +`ifdef CFG_MC_DIVIDE_ENABLED
  7.1751 +                            || (divide_by_zero_exception == `TRUE)
  7.1752 +`endif
  7.1753 +`ifdef CFG_INTERRUPTS_ENABLED
  7.1754 +                            || (   (interrupt_exception == `TRUE)
  7.1755 +`ifdef LM32_SINGLE_STEP_ENABLED
  7.1756 +                                && (dc_ss == `FALSE)
  7.1757 +`endif                            
  7.1758 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.1759 + 				&& (store_q_m == `FALSE)
  7.1760 +				&& (D_CYC_O == `FALSE)
  7.1761 +`endif
  7.1762 +                               )
  7.1763 +`endif
  7.1764 +                            ;
  7.1765 +`endif
  7.1766 +
  7.1767 +// Exception ID
  7.1768 +always @(*)
  7.1769 +begin
  7.1770 +`ifdef CFG_DEBUG_ENABLED
  7.1771 +`ifdef CFG_JTAG_ENABLED
  7.1772 +    if (reset_exception == `TRUE)
  7.1773 +        eid_x = `LM32_EID_RESET;
  7.1774 +    else
  7.1775 +`endif     
  7.1776 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.1777 +         if (data_bus_error_exception == `TRUE)
  7.1778 +        eid_x = `LM32_EID_DATA_BUS_ERROR;
  7.1779 +    else
  7.1780 +`endif
  7.1781 +         if (breakpoint_exception == `TRUE)
  7.1782 +        eid_x = `LM32_EID_BREAKPOINT;
  7.1783 +    else
  7.1784 +`endif
  7.1785 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.1786 +         if (data_bus_error_exception == `TRUE)
  7.1787 +        eid_x = `LM32_EID_DATA_BUS_ERROR;
  7.1788 +    else
  7.1789 +         if (instruction_bus_error_exception == `TRUE)
  7.1790 +        eid_x = `LM32_EID_INST_BUS_ERROR;
  7.1791 +    else
  7.1792 +`endif
  7.1793 +`ifdef CFG_DEBUG_ENABLED
  7.1794 +         if (watchpoint_exception == `TRUE)
  7.1795 +        eid_x = `LM32_EID_WATCHPOINT;
  7.1796 +    else 
  7.1797 +`endif
  7.1798 +`ifdef CFG_MC_DIVIDE_ENABLED
  7.1799 +         if (divide_by_zero_exception == `TRUE)
  7.1800 +        eid_x = `LM32_EID_DIVIDE_BY_ZERO;
  7.1801 +    else
  7.1802 +`endif
  7.1803 +`ifdef CFG_INTERRUPTS_ENABLED
  7.1804 +         if (   (interrupt_exception == `TRUE)
  7.1805 +`ifdef LM32_SINGLE_STEP_ENABLED
  7.1806 +             && (dc_ss == `FALSE)
  7.1807 +`endif                            
  7.1808 +            )
  7.1809 +        eid_x = `LM32_EID_INTERRUPT;
  7.1810 +    else
  7.1811 +`endif
  7.1812 +        eid_x = `LM32_EID_SCALL;
  7.1813 +end
  7.1814 +
  7.1815 +// Stall generation
  7.1816 +
  7.1817 +assign stall_a = (stall_f == `TRUE);
  7.1818 +                
  7.1819 +assign stall_f = (stall_d == `TRUE);
  7.1820 +                
  7.1821 +assign stall_d =   (stall_x == `TRUE) 
  7.1822 +                || (   (interlock == `TRUE)
  7.1823 +                    && (kill_d == `FALSE)
  7.1824 +                   ) 
  7.1825 +		|| (   (   (eret_d == `TRUE)
  7.1826 +			|| (scall_d == `TRUE)
  7.1827 +			|| (bus_error_d == `TRUE)
  7.1828 +		       )
  7.1829 +		    && (   (load_q_x == `TRUE)
  7.1830 +			|| (load_q_m == `TRUE)
  7.1831 +			|| (store_q_x == `TRUE)
  7.1832 +			|| (store_q_m == `TRUE)
  7.1833 +			|| (D_CYC_O == `TRUE)
  7.1834 +		       )
  7.1835 +                    && (kill_d == `FALSE)
  7.1836 +		   )
  7.1837 +`ifdef CFG_DEBUG_ENABLED
  7.1838 +		|| (   (   (break_d == `TRUE)
  7.1839 +			|| (bret_d == `TRUE)
  7.1840 +		       )
  7.1841 +		    && (   (load_q_x == `TRUE)
  7.1842 +			|| (store_q_x == `TRUE)
  7.1843 +			|| (load_q_m == `TRUE)
  7.1844 +			|| (store_q_m == `TRUE)
  7.1845 +			|| (D_CYC_O == `TRUE)
  7.1846 +		       )
  7.1847 +                    && (kill_d == `FALSE)
  7.1848 +		   )
  7.1849 +`endif                   
  7.1850 +                || (   (csr_write_enable_d == `TRUE)
  7.1851 +                    && (load_q_x == `TRUE)
  7.1852 +                   )                      
  7.1853 +                ;
  7.1854 +                
  7.1855 +assign stall_x =    (stall_m == `TRUE)
  7.1856 +`ifdef LM32_MC_ARITHMETIC_ENABLED
  7.1857 +                 || (   (mc_stall_request_x == `TRUE)
  7.1858 +                     && (kill_x == `FALSE)
  7.1859 +                    ) 
  7.1860 +`endif
  7.1861 +`ifdef CFG_IROM_ENABLED
  7.1862 +                 // Stall load/store instruction in D stage if there is an ongoing store
  7.1863 +                 // operation to instruction ROM in M stage
  7.1864 +                 || (   (irom_stall_request_x == `TRUE)
  7.1865 +		     && (   (load_d == `TRUE)
  7.1866 +			 || (store_d == `TRUE)
  7.1867 +			)
  7.1868 +		    )
  7.1869 +`endif
  7.1870 +                 ;
  7.1871 +
  7.1872 +assign stall_m =    (stall_wb_load == `TRUE)
  7.1873 +`ifdef CFG_SIZE_OVER_SPEED
  7.1874 +                 || (D_CYC_O == `TRUE)
  7.1875 +`else
  7.1876 +                 || (   (D_CYC_O == `TRUE)
  7.1877 +                     && (   (store_m == `TRUE)
  7.1878 +		         /*
  7.1879 +			  Bug: Following loop does not allow interrupts to be services since
  7.1880 +			  either D_CYC_O or store_m is always high during entire duration of
  7.1881 +			  loop.
  7.1882 +		          L1:	addi	r1, r1, 1
  7.1883 +			  	sw	(r2,0), r1
  7.1884 +			  	bi	L1
  7.1885 +			  
  7.1886 +			  Introduce a single-cycle stall when a wishbone cycle is in progress
  7.1887 +			  and a new store instruction is in Execute stage and a interrupt
  7.1888 +			  exception has occured. This stall will ensure that D_CYC_O and 
  7.1889 +			  store_m will both be low for one cycle.
  7.1890 +			  */
  7.1891 +		         || ((store_x == `TRUE) && (interrupt_exception == `TRUE))
  7.1892 +                         || (load_m == `TRUE)
  7.1893 +                         || (load_x == `TRUE)
  7.1894 +                        ) 
  7.1895 +                    ) 
  7.1896 +`endif                 
  7.1897 +`ifdef CFG_DCACHE_ENABLED
  7.1898 +                 || (dcache_stall_request == `TRUE)     // Need to stall in case a taken branch is in M stage and data cache is only being flush, so wont be restarted
  7.1899 +`endif                                    
  7.1900 +`ifdef CFG_ICACHE_ENABLED
  7.1901 +                 || (icache_stall_request == `TRUE)     // Pipeline needs to be stalled otherwise branches may be lost
  7.1902 +                 || ((I_CYC_O == `TRUE) && ((branch_m == `TRUE) || (exception_m == `TRUE))) 
  7.1903 +`else
  7.1904 +`ifdef CFG_IWB_ENABLED
  7.1905 +                 || (I_CYC_O == `TRUE)            
  7.1906 +`endif
  7.1907 +`endif                               
  7.1908 +`ifdef CFG_USER_ENABLED
  7.1909 +                 || (   (user_valid == `TRUE)           // Stall whole pipeline, rather than just X stage, where the instruction is, so we don't have to worry about exceptions (maybe)
  7.1910 +                     && (user_complete == `FALSE)
  7.1911 +                    )
  7.1912 +`endif
  7.1913 +                 ;      
  7.1914 +
  7.1915 +// Qualify state changing control signals
  7.1916 +`ifdef LM32_MC_ARITHMETIC_ENABLED
  7.1917 +assign q_d = (valid_d == `TRUE) && (kill_d == `FALSE);
  7.1918 +`endif
  7.1919 +`ifdef CFG_MC_BARREL_SHIFT_ENABLED
  7.1920 +assign shift_left_q_d = (shift_left_d == `TRUE) && (q_d == `TRUE);
  7.1921 +assign shift_right_q_d = (shift_right_d == `TRUE) && (q_d == `TRUE);
  7.1922 +`endif
  7.1923 +`ifdef CFG_MC_MULTIPLY_ENABLED
  7.1924 +assign multiply_q_d = (multiply_d == `TRUE) && (q_d == `TRUE);
  7.1925 +`endif
  7.1926 +`ifdef CFG_MC_DIVIDE_ENABLED
  7.1927 +assign divide_q_d = (divide_d == `TRUE) && (q_d == `TRUE);
  7.1928 +assign modulus_q_d = (modulus_d == `TRUE) && (q_d == `TRUE);
  7.1929 +`endif
  7.1930 +assign q_x = (valid_x == `TRUE) && (kill_x == `FALSE);
  7.1931 +assign csr_write_enable_q_x = (csr_write_enable_x == `TRUE) && (q_x == `TRUE);
  7.1932 +assign eret_q_x = (eret_x == `TRUE) && (q_x == `TRUE);
  7.1933 +`ifdef CFG_DEBUG_ENABLED
  7.1934 +assign bret_q_x = (bret_x == `TRUE) && (q_x == `TRUE);
  7.1935 +`endif
  7.1936 +assign load_q_x = (load_x == `TRUE) 
  7.1937 +               && (q_x == `TRUE)
  7.1938 +`ifdef CFG_DEBUG_ENABLED
  7.1939 +               && (bp_match == `FALSE)
  7.1940 +`endif
  7.1941 +                  ;
  7.1942 +assign store_q_x = (store_x == `TRUE) 
  7.1943 +               && (q_x == `TRUE)
  7.1944 +`ifdef CFG_DEBUG_ENABLED
  7.1945 +               && (bp_match == `FALSE)
  7.1946 +`endif
  7.1947 +                  ;
  7.1948 +`ifdef CFG_USER_ENABLED
  7.1949 +assign user_valid = (x_result_sel_user_x == `TRUE) && (q_x == `TRUE);
  7.1950 +`endif                              
  7.1951 +assign q_m = (valid_m == `TRUE) && (kill_m == `FALSE) && (exception_m == `FALSE);
  7.1952 +assign load_q_m = (load_m == `TRUE) && (q_m == `TRUE);
  7.1953 +assign store_q_m = (store_m == `TRUE) && (q_m == `TRUE);
  7.1954 +`ifdef CFG_DEBUG_ENABLED
  7.1955 +assign debug_exception_q_w = ((debug_exception_w == `TRUE) && (valid_w == `TRUE));
  7.1956 +assign non_debug_exception_q_w = ((non_debug_exception_w == `TRUE) && (valid_w == `TRUE));        
  7.1957 +`else
  7.1958 +assign exception_q_w = ((exception_w == `TRUE) && (valid_w == `TRUE));        
  7.1959 +`endif
  7.1960 +// Don't qualify register write enables with kill, as the signal is needed early, and it doesn't matter if the instruction is killed (except for the actual write - but that is handled separately)
  7.1961 +assign write_enable_q_x = (write_enable_x == `TRUE) && (valid_x == `TRUE) && (branch_flushX_m == `FALSE);
  7.1962 +assign write_enable_q_m = (write_enable_m == `TRUE) && (valid_m == `TRUE);
  7.1963 +assign write_enable_q_w = (write_enable_w == `TRUE) && (valid_w == `TRUE);
  7.1964 +// The enable that actually does write the registers needs to be qualified with kill
  7.1965 +assign reg_write_enable_q_w = (write_enable_w == `TRUE) && (kill_w == `FALSE) && (valid_w == `TRUE);
  7.1966 +
  7.1967 +// Configuration (CFG) CSR
  7.1968 +assign cfg = {
  7.1969 +              `LM32_REVISION,
  7.1970 +              watchpoints[3:0],
  7.1971 +              breakpoints[3:0],
  7.1972 +              interrupts[5:0],
  7.1973 +`ifdef CFG_JTAG_UART_ENABLED
  7.1974 +              `TRUE,
  7.1975 +`else
  7.1976 +              `FALSE,
  7.1977 +`endif
  7.1978 +`ifdef CFG_ROM_DEBUG_ENABLED
  7.1979 +              `TRUE,
  7.1980 +`else
  7.1981 +              `FALSE,
  7.1982 +`endif
  7.1983 +`ifdef CFG_HW_DEBUG_ENABLED
  7.1984 +              `TRUE,
  7.1985 +`else
  7.1986 +              `FALSE,
  7.1987 +`endif
  7.1988 +`ifdef CFG_DEBUG_ENABLED
  7.1989 +              `TRUE,
  7.1990 +`else
  7.1991 +              `FALSE,
  7.1992 +`endif
  7.1993 +`ifdef CFG_ICACHE_ENABLED
  7.1994 +              `TRUE,
  7.1995 +`else
  7.1996 +              `FALSE,
  7.1997 +`endif
  7.1998 +`ifdef CFG_DCACHE_ENABLED
  7.1999 +              `TRUE,
  7.2000 +`else
  7.2001 +              `FALSE,
  7.2002 +`endif
  7.2003 +`ifdef CFG_CYCLE_COUNTER_ENABLED
  7.2004 +              `TRUE,
  7.2005 +`else
  7.2006 +              `FALSE,
  7.2007 +`endif
  7.2008 +`ifdef CFG_USER_ENABLED
  7.2009 +              `TRUE,
  7.2010 +`else
  7.2011 +              `FALSE,
  7.2012 +`endif
  7.2013 +`ifdef CFG_SIGN_EXTEND_ENABLED
  7.2014 +              `TRUE,
  7.2015 +`else
  7.2016 +              `FALSE,
  7.2017 +`endif
  7.2018 +`ifdef LM32_BARREL_SHIFT_ENABLED
  7.2019 +              `TRUE,
  7.2020 +`else
  7.2021 +              `FALSE,
  7.2022 +`endif
  7.2023 +`ifdef CFG_MC_DIVIDE_ENABLED
  7.2024 +              `TRUE,
  7.2025 +`else
  7.2026 +              `FALSE,
  7.2027 +`endif
  7.2028 +`ifdef LM32_MULTIPLY_ENABLED 
  7.2029 +              `TRUE
  7.2030 +`else
  7.2031 +              `FALSE
  7.2032 +`endif
  7.2033 +              };
  7.2034 +
  7.2035 +assign cfg2 = {
  7.2036 +		     30'b0,
  7.2037 +`ifdef CFG_IROM_ENABLED
  7.2038 +		     `TRUE,
  7.2039 +`else
  7.2040 +		     `FALSE,
  7.2041 +`endif
  7.2042 +`ifdef CFG_DRAM_ENABLED
  7.2043 +		     `TRUE
  7.2044 +`else
  7.2045 +		     `FALSE
  7.2046 +`endif
  7.2047 +		     };
  7.2048 +   
  7.2049 +// Cache flush
  7.2050 +`ifdef CFG_ICACHE_ENABLED
  7.2051 +assign iflush =    (csr_write_enable_d == `TRUE) 
  7.2052 +                && (csr_d == `LM32_CSR_ICC)
  7.2053 +                && (stall_d == `FALSE)
  7.2054 +                && (kill_d == `FALSE)
  7.2055 +                && (valid_d == `TRUE);
  7.2056 +`endif 
  7.2057 +`ifdef CFG_DCACHE_ENABLED
  7.2058 +assign dflush_x =  (csr_write_enable_q_x == `TRUE) 
  7.2059 +                && (csr_x == `LM32_CSR_DCC);
  7.2060 +`endif 
  7.2061 +
  7.2062 +// Extract CSR index
  7.2063 +assign csr_d = read_idx_0_d[`LM32_CSR_RNG];
  7.2064 +
  7.2065 +// CSR reads
  7.2066 +always @(*)
  7.2067 +begin
  7.2068 +    case (csr_x)
  7.2069 +`ifdef CFG_INTERRUPTS_ENABLED
  7.2070 +    `LM32_CSR_IE,
  7.2071 +    `LM32_CSR_IM,
  7.2072 +    `LM32_CSR_IP:   csr_read_data_x = interrupt_csr_read_data_x;  
  7.2073 +`endif
  7.2074 +`ifdef CFG_CYCLE_COUNTER_ENABLED
  7.2075 +    `LM32_CSR_CC:   csr_read_data_x = cc;
  7.2076 +`endif
  7.2077 +    `LM32_CSR_CFG:  csr_read_data_x = cfg;
  7.2078 +    `LM32_CSR_EBA:  csr_read_data_x = {eba, 8'h00};
  7.2079 +`ifdef CFG_DEBUG_ENABLED
  7.2080 +    `LM32_CSR_DEBA: csr_read_data_x = {deba, 8'h00};
  7.2081 +`endif
  7.2082 +`ifdef CFG_JTAG_UART_ENABLED
  7.2083 +    `LM32_CSR_JTX:  csr_read_data_x = jtx_csr_read_data;  
  7.2084 +    `LM32_CSR_JRX:  csr_read_data_x = jrx_csr_read_data;
  7.2085 +`endif
  7.2086 +    `LM32_CSR_CFG2: csr_read_data_x = cfg2;
  7.2087 +      
  7.2088 +    default:        csr_read_data_x = {`LM32_WORD_WIDTH{1'bx}};
  7.2089 +    endcase
  7.2090 +end
  7.2091 +
  7.2092 +/////////////////////////////////////////////////////
  7.2093 +// Sequential Logic
  7.2094 +/////////////////////////////////////////////////////
  7.2095 +
  7.2096 +// Exception Base Address (EBA) CSR
  7.2097 +always @(posedge clk_i `CFG_RESET_SENSITIVITY)
  7.2098 +begin
  7.2099 +    if (rst_i == `TRUE)
  7.2100 +        eba <= eba_reset[`LM32_PC_WIDTH+2-1:8];
  7.2101 +    else
  7.2102 +    begin
  7.2103 +        if ((csr_write_enable_q_x == `TRUE) && (csr_x == `LM32_CSR_EBA) && (stall_x == `FALSE))
  7.2104 +            eba <= operand_1_x[`LM32_PC_WIDTH+2-1:8];
  7.2105 +`ifdef CFG_HW_DEBUG_ENABLED
  7.2106 +        if ((jtag_csr_write_enable == `TRUE) && (jtag_csr == `LM32_CSR_EBA))
  7.2107 +            eba <= jtag_csr_write_data[`LM32_PC_WIDTH+2-1:8];
  7.2108 +`endif
  7.2109 +    end
  7.2110 +end
  7.2111 +
  7.2112 +`ifdef CFG_DEBUG_ENABLED
  7.2113 +// Debug Exception Base Address (DEBA) CSR
  7.2114 +always @(posedge clk_i `CFG_RESET_SENSITIVITY)
  7.2115 +begin
  7.2116 +    if (rst_i == `TRUE)
  7.2117 +        deba <= deba_reset[`LM32_PC_WIDTH+2-1:8];
  7.2118 +    else
  7.2119 +    begin
  7.2120 +        if ((csr_write_enable_q_x == `TRUE) && (csr_x == `LM32_CSR_DEBA) && (stall_x == `FALSE))
  7.2121 +            deba <= operand_1_x[`LM32_PC_WIDTH+2-1:8];
  7.2122 +`ifdef CFG_HW_DEBUG_ENABLED
  7.2123 +        if ((jtag_csr_write_enable == `TRUE) && (jtag_csr == `LM32_CSR_DEBA))
  7.2124 +            deba <= jtag_csr_write_data[`LM32_PC_WIDTH+2-1:8];
  7.2125 +`endif
  7.2126 +    end
  7.2127 +end
  7.2128 +`endif
  7.2129 +
  7.2130 +// Cycle Counter (CC) CSR
  7.2131 +`ifdef CFG_CYCLE_COUNTER_ENABLED
  7.2132 +always @(posedge clk_i `CFG_RESET_SENSITIVITY)
  7.2133 +begin
  7.2134 +    if (rst_i == `TRUE)
  7.2135 +        cc <= {`LM32_WORD_WIDTH{1'b0}};
  7.2136 +    else
  7.2137 +        cc <= cc + 1'b1;
  7.2138 +end
  7.2139 +`endif
  7.2140 +
  7.2141 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.2142 +// Watch for data bus errors
  7.2143 +always @(posedge clk_i `CFG_RESET_SENSITIVITY)
  7.2144 +begin
  7.2145 +    if (rst_i == `TRUE)
  7.2146 +        data_bus_error_seen <= `FALSE;
  7.2147 +    else
  7.2148 +    begin
  7.2149 +        // Set flag when bus error is detected
  7.2150 +        if ((D_ERR_I == `TRUE) && (D_CYC_O == `TRUE))
  7.2151 +            data_bus_error_seen <= `TRUE;
  7.2152 +        // Clear flag when exception is taken
  7.2153 +        if ((exception_m == `TRUE) && (kill_m == `FALSE))
  7.2154 +            data_bus_error_seen <= `FALSE;
  7.2155 +    end
  7.2156 +end
  7.2157 +`endif
  7.2158 + 
  7.2159 +// Valid bits to indicate whether an instruction in a partcular pipeline stage is valid or not  
  7.2160 +
  7.2161 +`ifdef CFG_ICACHE_ENABLED
  7.2162 +`ifdef CFG_DCACHE_ENABLED
  7.2163 +always @(*)
  7.2164 +begin
  7.2165 +    if (   (icache_refill_request == `TRUE) 
  7.2166 +        || (dcache_refill_request == `TRUE)
  7.2167 +       )
  7.2168 +        valid_a = `FALSE;
  7.2169 +    else if (   (icache_restart_request == `TRUE) 
  7.2170 +             || (dcache_restart_request == `TRUE) 
  7.2171 +            ) 
  7.2172 +        valid_a = `TRUE;
  7.2173 +    else 
  7.2174 +        valid_a = !icache_refilling && !dcache_refilling;
  7.2175 +end 
  7.2176 +`else
  7.2177 +always @(*)
  7.2178 +begin
  7.2179 +    if (icache_refill_request == `TRUE) 
  7.2180 +        valid_a = `FALSE;
  7.2181 +    else if (icache_restart_request == `TRUE) 
  7.2182 +        valid_a = `TRUE;
  7.2183 +    else 
  7.2184 +        valid_a = !icache_refilling;
  7.2185 +end 
  7.2186 +`endif
  7.2187 +`else
  7.2188 +`ifdef CFG_DCACHE_ENABLED
  7.2189 +always @(*)
  7.2190 +begin
  7.2191 +    if (dcache_refill_request == `TRUE) 
  7.2192 +        valid_a = `FALSE;
  7.2193 +    else if (dcache_restart_request == `TRUE) 
  7.2194 +        valid_a = `TRUE;
  7.2195 +    else 
  7.2196 +        valid_a = !dcache_refilling;
  7.2197 +end 
  7.2198 +`endif
  7.2199 +`endif
  7.2200 +
  7.2201 +always @(posedge clk_i `CFG_RESET_SENSITIVITY)
  7.2202 +begin
  7.2203 +    if (rst_i == `TRUE)
  7.2204 +    begin
  7.2205 +        valid_f <= `FALSE;
  7.2206 +        valid_d <= `FALSE;
  7.2207 +        valid_x <= `FALSE;
  7.2208 +        valid_m <= `FALSE;
  7.2209 +        valid_w <= `FALSE;
  7.2210 +    end
  7.2211 +    else
  7.2212 +    begin    
  7.2213 +        if ((kill_f == `TRUE) || (stall_a == `FALSE))
  7.2214 +`ifdef LM32_CACHE_ENABLED
  7.2215 +            valid_f <= valid_a;    
  7.2216 +`else
  7.2217 +            valid_f <= `TRUE;
  7.2218 +`endif            
  7.2219 +        else if (stall_f == `FALSE)
  7.2220 +            valid_f <= `FALSE;            
  7.2221 +
  7.2222 +        if (kill_d == `TRUE)
  7.2223 +            valid_d <= `FALSE;
  7.2224 +        else if (stall_f == `FALSE)
  7.2225 +            valid_d <= valid_f & !kill_f;
  7.2226 +        else if (stall_d == `FALSE)
  7.2227 +            valid_d <= `FALSE;
  7.2228 +       
  7.2229 +        if (stall_d == `FALSE)
  7.2230 +            valid_x <= valid_d & !kill_d;
  7.2231 +        else if (kill_x == `TRUE)
  7.2232 +            valid_x <= `FALSE;
  7.2233 +        else if (stall_x == `FALSE)
  7.2234 +            valid_x <= `FALSE;
  7.2235 +
  7.2236 +        if (kill_m == `TRUE)
  7.2237 +            valid_m <= `FALSE;
  7.2238 +        else if (stall_x == `FALSE)
  7.2239 +            valid_m <= valid_x & !kill_x;
  7.2240 +        else if (stall_m == `FALSE)
  7.2241 +            valid_m <= `FALSE;
  7.2242 +
  7.2243 +        if (stall_m == `FALSE)
  7.2244 +            valid_w <= valid_m & !kill_m;
  7.2245 +        else 
  7.2246 +            valid_w <= `FALSE;        
  7.2247 +    end
  7.2248 +end
  7.2249 +
  7.2250 +// Microcode pipeline registers
  7.2251 +always @(posedge clk_i `CFG_RESET_SENSITIVITY)
  7.2252 +begin
  7.2253 +    if (rst_i == `TRUE)
  7.2254 +    begin
  7.2255 +`ifdef CFG_USER_ENABLED
  7.2256 +        user_opcode <= {`LM32_USER_OPCODE_WIDTH{1'b0}};       
  7.2257 +`endif        
  7.2258 +        operand_0_x <= {`LM32_WORD_WIDTH{1'b0}};
  7.2259 +        operand_1_x <= {`LM32_WORD_WIDTH{1'b0}};
  7.2260 +        store_operand_x <= {`LM32_WORD_WIDTH{1'b0}};
  7.2261 +        branch_target_x <= {`LM32_WORD_WIDTH{1'b0}};        
  7.2262 +        x_result_sel_csr_x <= `FALSE;
  7.2263 +`ifdef LM32_MC_ARITHMETIC_ENABLED
  7.2264 +        x_result_sel_mc_arith_x <= `FALSE;
  7.2265 +`endif
  7.2266 +`ifdef LM32_NO_BARREL_SHIFT    
  7.2267 +        x_result_sel_shift_x <= `FALSE;
  7.2268 +`endif
  7.2269 +`ifdef CFG_SIGN_EXTEND_ENABLED
  7.2270 +        x_result_sel_sext_x <= `FALSE;
  7.2271 +`endif    
  7.2272 +        x_result_sel_logic_x <= `FALSE;
  7.2273 +`ifdef CFG_USER_ENABLED
  7.2274 +        x_result_sel_user_x <= `FALSE;
  7.2275 +`endif
  7.2276 +        x_result_sel_add_x <= `FALSE;
  7.2277 +        m_result_sel_compare_x <= `FALSE;
  7.2278 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
  7.2279 +        m_result_sel_shift_x <= `FALSE;
  7.2280 +`endif    
  7.2281 +        w_result_sel_load_x <= `FALSE;
  7.2282 +`ifdef CFG_PL_MULTIPLY_ENABLED
  7.2283 +        w_result_sel_mul_x <= `FALSE;
  7.2284 +`endif
  7.2285 +        x_bypass_enable_x <= `FALSE;
  7.2286 +        m_bypass_enable_x <= `FALSE;
  7.2287 +        write_enable_x <= `FALSE;
  7.2288 +        write_idx_x <= {`LM32_REG_IDX_WIDTH{1'b0}};
  7.2289 +        csr_x <= {`LM32_CSR_WIDTH{1'b0}};
  7.2290 +        load_x <= `FALSE;
  7.2291 +        store_x <= `FALSE;
  7.2292 +        size_x <= {`LM32_SIZE_WIDTH{1'b0}};
  7.2293 +        sign_extend_x <= `FALSE;
  7.2294 +        adder_op_x <= `FALSE;
  7.2295 +        adder_op_x_n <= `FALSE;
  7.2296 +        logic_op_x <= 4'h0;
  7.2297 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
  7.2298 +        direction_x <= `FALSE;
  7.2299 +`endif
  7.2300 +`ifdef CFG_ROTATE_ENABLED
  7.2301 +        rotate_x <= `FALSE;
  7.2302 +
  7.2303 +`endif
  7.2304 +        branch_x <= `FALSE;
  7.2305 +        branch_predict_x <= `FALSE;
  7.2306 +        branch_predict_taken_x <= `FALSE;
  7.2307 +        condition_x <= `LM32_CONDITION_U1;
  7.2308 +`ifdef CFG_DEBUG_ENABLED
  7.2309 +        break_x <= `FALSE;
  7.2310 +`endif
  7.2311 +        scall_x <= `FALSE;
  7.2312 +        eret_x <= `FALSE;
  7.2313 +`ifdef CFG_DEBUG_ENABLED
  7.2314 +        bret_x <= `FALSE;
  7.2315 +`endif
  7.2316 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.2317 +        bus_error_x <= `FALSE;
  7.2318 +        data_bus_error_exception_m <= `FALSE;
  7.2319 +`endif
  7.2320 +        csr_write_enable_x <= `FALSE;
  7.2321 +        operand_m <= {`LM32_WORD_WIDTH{1'b0}};
  7.2322 +        branch_target_m <= {`LM32_WORD_WIDTH{1'b0}};
  7.2323 +        m_result_sel_compare_m <= `FALSE;
  7.2324 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
  7.2325 +        m_result_sel_shift_m <= `FALSE;
  7.2326 +`endif    
  7.2327 +        w_result_sel_load_m <= `FALSE;
  7.2328 +`ifdef CFG_PL_MULTIPLY_ENABLED
  7.2329 +        w_result_sel_mul_m <= `FALSE;
  7.2330 +`endif
  7.2331 +        m_bypass_enable_m <= `FALSE;
  7.2332 +        branch_m <= `FALSE;
  7.2333 +        branch_predict_m <= `FALSE;
  7.2334 +	branch_predict_taken_m <= `FALSE;
  7.2335 +        exception_m <= `FALSE;
  7.2336 +        load_m <= `FALSE;
  7.2337 +        store_m <= `FALSE;
  7.2338 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
  7.2339 +        direction_m <= `FALSE;
  7.2340 +`endif
  7.2341 +        write_enable_m <= `FALSE;            
  7.2342 +        write_idx_m <= {`LM32_REG_IDX_WIDTH{1'b0}};
  7.2343 +        condition_met_m <= `FALSE;
  7.2344 +`ifdef CFG_DCACHE_ENABLED
  7.2345 +        dflush_m <= `FALSE;
  7.2346 +`endif
  7.2347 +`ifdef CFG_DEBUG_ENABLED
  7.2348 +        debug_exception_m <= `FALSE;
  7.2349 +        non_debug_exception_m <= `FALSE;        
  7.2350 +`endif
  7.2351 +        operand_w <= {`LM32_WORD_WIDTH{1'b0}};        
  7.2352 +        w_result_sel_load_w <= `FALSE;
  7.2353 +`ifdef CFG_PL_MULTIPLY_ENABLED
  7.2354 +        w_result_sel_mul_w <= `FALSE;
  7.2355 +`endif
  7.2356 +        write_idx_w <= {`LM32_REG_IDX_WIDTH{1'b0}};        
  7.2357 +        write_enable_w <= `FALSE;
  7.2358 +`ifdef CFG_DEBUG_ENABLED
  7.2359 +        debug_exception_w <= `FALSE;
  7.2360 +        non_debug_exception_w <= `FALSE;        
  7.2361 +`else
  7.2362 +        exception_w <= `FALSE;
  7.2363 +`endif
  7.2364 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.2365 +        memop_pc_w <= {`LM32_PC_WIDTH{1'b0}};
  7.2366 +`endif
  7.2367 +    end
  7.2368 +    else
  7.2369 +    begin
  7.2370 +        // D/X stage registers
  7.2371 +       
  7.2372 +        if (stall_x == `FALSE)
  7.2373 +        begin
  7.2374 +`ifdef CFG_USER_ENABLED
  7.2375 +            user_opcode <= user_opcode_d;       
  7.2376 +`endif        
  7.2377 +            operand_0_x <= d_result_0;
  7.2378 +            operand_1_x <= d_result_1;
  7.2379 +            store_operand_x <= bypass_data_1;
  7.2380 +            branch_target_x <= branch_reg_d == `TRUE ? bypass_data_0[`LM32_PC_RNG] : branch_target_d;            
  7.2381 +            x_result_sel_csr_x <= x_result_sel_csr_d;
  7.2382 +`ifdef LM32_MC_ARITHMETIC_ENABLED
  7.2383 +            x_result_sel_mc_arith_x <= x_result_sel_mc_arith_d;
  7.2384 +`endif
  7.2385 +`ifdef LM32_NO_BARREL_SHIFT    
  7.2386 +            x_result_sel_shift_x <= x_result_sel_shift_d;
  7.2387 +`endif
  7.2388 +`ifdef CFG_SIGN_EXTEND_ENABLED
  7.2389 +            x_result_sel_sext_x <= x_result_sel_sext_d;
  7.2390 +`endif    
  7.2391 +            x_result_sel_logic_x <= x_result_sel_logic_d;
  7.2392 +`ifdef CFG_USER_ENABLED
  7.2393 +            x_result_sel_user_x <= x_result_sel_user_d;
  7.2394 +`endif
  7.2395 +            x_result_sel_add_x <= x_result_sel_add_d;
  7.2396 +            m_result_sel_compare_x <= m_result_sel_compare_d;
  7.2397 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
  7.2398 +            m_result_sel_shift_x <= m_result_sel_shift_d;
  7.2399 +`endif    
  7.2400 +            w_result_sel_load_x <= w_result_sel_load_d;
  7.2401 +`ifdef CFG_PL_MULTIPLY_ENABLED
  7.2402 +            w_result_sel_mul_x <= w_result_sel_mul_d;
  7.2403 +`endif
  7.2404 +            x_bypass_enable_x <= x_bypass_enable_d;
  7.2405 +            m_bypass_enable_x <= m_bypass_enable_d;
  7.2406 +            load_x <= load_d;
  7.2407 +            store_x <= store_d;
  7.2408 +            branch_x <= branch_d;
  7.2409 +	    branch_predict_x <= branch_predict_d;
  7.2410 +	    branch_predict_taken_x <= branch_predict_taken_d;
  7.2411 +	    write_idx_x <= write_idx_d;
  7.2412 +            csr_x <= csr_d;
  7.2413 +            size_x <= size_d;
  7.2414 +            sign_extend_x <= sign_extend_d;
  7.2415 +            adder_op_x <= adder_op_d;
  7.2416 +            adder_op_x_n <= ~adder_op_d;
  7.2417 +            logic_op_x <= logic_op_d;
  7.2418 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
  7.2419 +            direction_x <= direction_d;
  7.2420 +`endif
  7.2421 +`ifdef CFG_ROTATE_ENABLED
  7.2422 +            rotate_x <= rotate_d;
  7.2423 +`endif
  7.2424 +            condition_x <= condition_d;
  7.2425 +            csr_write_enable_x <= csr_write_enable_d;
  7.2426 +`ifdef CFG_DEBUG_ENABLED
  7.2427 +            break_x <= break_d;
  7.2428 +`endif
  7.2429 +            scall_x <= scall_d;
  7.2430 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.2431 +            bus_error_x <= bus_error_d;
  7.2432 +`endif
  7.2433 +            eret_x <= eret_d;
  7.2434 +`ifdef CFG_DEBUG_ENABLED
  7.2435 +            bret_x <= bret_d; 
  7.2436 +`endif
  7.2437 +            write_enable_x <= write_enable_d;
  7.2438 +        end
  7.2439 +        
  7.2440 +        // X/M stage registers
  7.2441 +
  7.2442 +        if (stall_m == `FALSE)
  7.2443 +        begin
  7.2444 +            operand_m <= x_result;
  7.2445 +            m_result_sel_compare_m <= m_result_sel_compare_x;
  7.2446 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
  7.2447 +            m_result_sel_shift_m <= m_result_sel_shift_x;
  7.2448 +`endif    
  7.2449 +            if (exception_x == `TRUE)
  7.2450 +            begin
  7.2451 +                w_result_sel_load_m <= `FALSE;
  7.2452 +`ifdef CFG_PL_MULTIPLY_ENABLED
  7.2453 +                w_result_sel_mul_m <= `FALSE;
  7.2454 +`endif
  7.2455 +            end
  7.2456 +            else
  7.2457 +            begin
  7.2458 +                w_result_sel_load_m <= w_result_sel_load_x;
  7.2459 +`ifdef CFG_PL_MULTIPLY_ENABLED
  7.2460 +                w_result_sel_mul_m <= w_result_sel_mul_x;
  7.2461 +`endif
  7.2462 +            end
  7.2463 +            m_bypass_enable_m <= m_bypass_enable_x;
  7.2464 +`ifdef CFG_PL_BARREL_SHIFT_ENABLED
  7.2465 +            direction_m <= direction_x;
  7.2466 +`endif
  7.2467 +            load_m <= load_x;
  7.2468 +            store_m <= store_x;
  7.2469 +`ifdef CFG_FAST_UNCONDITIONAL_BRANCH    
  7.2470 +            branch_m <= branch_x && !branch_taken_x;
  7.2471 +`else
  7.2472 +            branch_m <= branch_x;
  7.2473 +	    branch_predict_m <= branch_predict_x;
  7.2474 +	    branch_predict_taken_m <= branch_predict_taken_x;
  7.2475 +`endif
  7.2476 +`ifdef CFG_DEBUG_ENABLED
  7.2477 +	   // Data bus errors are generated by the wishbone and are
  7.2478 +	   // made known to the processor only in next cycle (as a
  7.2479 +	   // non-debug exception). A break instruction can be seen
  7.2480 +	   // in same cycle (causing a debug exception). Handle non
  7.2481 +	   // -debug exception first!
  7.2482 +            if (non_debug_exception_x == `TRUE) 
  7.2483 +                write_idx_m <= `LM32_EA_REG;
  7.2484 +            else if (debug_exception_x == `TRUE)
  7.2485 +                write_idx_m <= `LM32_BA_REG;
  7.2486 +            else 
  7.2487 +                write_idx_m <= write_idx_x;
  7.2488 +`else
  7.2489 +            if (exception_x == `TRUE)
  7.2490 +                write_idx_m <= `LM32_EA_REG;
  7.2491 +            else 
  7.2492 +                write_idx_m <= write_idx_x;
  7.2493 +`endif
  7.2494 +            condition_met_m <= condition_met_x;
  7.2495 +`ifdef CFG_DEBUG_ENABLED
  7.2496 +	   if (exception_x == `TRUE)
  7.2497 +	     if ((dc_re == `TRUE)
  7.2498 +		 || ((debug_exception_x == `TRUE) 
  7.2499 +		     && (non_debug_exception_x == `FALSE)))
  7.2500 +	       branch_target_m <= {deba, eid_x, {3{1'b0}}};
  7.2501 +	     else
  7.2502 +	       branch_target_m <= {eba, eid_x, {3{1'b0}}};
  7.2503 +	   else
  7.2504 +	     branch_target_m <= branch_target_x;
  7.2505 +`else
  7.2506 +            branch_target_m <= exception_x == `TRUE ? {eba, eid_x, {3{1'b0}}} : branch_target_x;
  7.2507 +`endif
  7.2508 +`ifdef CFG_TRACE_ENABLED
  7.2509 +            eid_m <= eid_x;
  7.2510 +`endif
  7.2511 +`ifdef CFG_DCACHE_ENABLED
  7.2512 +            dflush_m <= dflush_x;
  7.2513 +`endif
  7.2514 +            eret_m <= eret_q_x;
  7.2515 +`ifdef CFG_DEBUG_ENABLED
  7.2516 +            bret_m <= bret_q_x; 
  7.2517 +`endif
  7.2518 +            write_enable_m <= exception_x == `TRUE ? `TRUE : write_enable_x;            
  7.2519 +`ifdef CFG_DEBUG_ENABLED
  7.2520 +            debug_exception_m <= debug_exception_x;
  7.2521 +            non_debug_exception_m <= non_debug_exception_x;        
  7.2522 +`endif
  7.2523 +        end
  7.2524 +        
  7.2525 +        // State changing regs
  7.2526 +        if (stall_m == `FALSE)
  7.2527 +        begin
  7.2528 +            if ((exception_x == `TRUE) && (q_x == `TRUE) && (stall_x == `FALSE))
  7.2529 +                exception_m <= `TRUE;
  7.2530 +            else 
  7.2531 +                exception_m <= `FALSE;
  7.2532 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.2533 +	   data_bus_error_exception_m <=    (data_bus_error_exception == `TRUE) 
  7.2534 +`ifdef CFG_DEBUG_ENABLED
  7.2535 +					 && (reset_exception == `FALSE)
  7.2536 +`endif
  7.2537 +					 ;
  7.2538 +`endif
  7.2539 +	end
  7.2540 +                
  7.2541 +        // M/W stage registers
  7.2542 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.2543 +        operand_w <= exception_m == `TRUE ? (data_bus_error_exception_m ? {memop_pc_w, 2'b00} : {pc_m, 2'b00}) : m_result;
  7.2544 +`else
  7.2545 +        operand_w <= exception_m == `TRUE ? {pc_m, 2'b00} : m_result;
  7.2546 +`endif
  7.2547 +        w_result_sel_load_w <= w_result_sel_load_m;
  7.2548 +`ifdef CFG_PL_MULTIPLY_ENABLED
  7.2549 +        w_result_sel_mul_w <= w_result_sel_mul_m;
  7.2550 +`endif
  7.2551 +        write_idx_w <= write_idx_m;
  7.2552 +`ifdef CFG_TRACE_ENABLED
  7.2553 +        eid_w <= eid_m;
  7.2554 +        eret_w <= eret_m;
  7.2555 +`ifdef CFG_DEBUG_ENABLED
  7.2556 +        bret_w <= bret_m; 
  7.2557 +`endif
  7.2558 +`endif
  7.2559 +        write_enable_w <= write_enable_m;
  7.2560 +`ifdef CFG_DEBUG_ENABLED
  7.2561 +        debug_exception_w <= debug_exception_m;
  7.2562 +        non_debug_exception_w <= non_debug_exception_m;
  7.2563 +`else
  7.2564 +        exception_w <= exception_m;
  7.2565 +`endif
  7.2566 +`ifdef CFG_BUS_ERRORS_ENABLED
  7.2567 +        if (   (stall_m == `FALSE)
  7.2568 +            && (   (load_q_m == `TRUE) 
  7.2569 +                || (store_q_m == `TRUE)
  7.2570 +               )
  7.2571 +	   )
  7.2572 +          memop_pc_w <= pc_m;
  7.2573 +`endif
  7.2574 +    end
  7.2575 +end
  7.2576 +
  7.2577 +`ifdef CFG_EBR_POSEDGE_REGISTER_FILE
  7.2578 +// Buffer data read from register file, in case a stall occurs, and watch for
  7.2579 +// any writes to the modified registers
  7.2580 +always @(posedge clk_i `CFG_RESET_SENSITIVITY)
  7.2581 +begin
  7.2582 +    if (rst_i == `TRUE)
  7.2583 +    begin
  7.2584 +        use_buf <= `FALSE;
  7.2585 +        reg_data_buf_0 <= {`LM32_WORD_WIDTH{1'b0}};
  7.2586 +        reg_data_buf_1 <= {`LM32_WORD_WIDTH{1'b0}};
  7.2587 +    end
  7.2588 +    else
  7.2589 +    begin
  7.2590 +        if (stall_d == `FALSE)
  7.2591 +            use_buf <= `FALSE;
  7.2592 +        else if (use_buf == `FALSE)
  7.2593 +        begin        
  7.2594 +            reg_data_buf_0 <= reg_data_live_0;
  7.2595 +            reg_data_buf_1 <= reg_data_live_1;
  7.2596 +            use_buf <= `TRUE;
  7.2597 +        end        
  7.2598 +        if (reg_write_enable_q_w == `TRUE)
  7.2599 +        begin
  7.2600 +            if (write_idx_w == read_idx_0_d)
  7.2601 +                reg_data_buf_0 <= w_result;
  7.2602 +            if (write_idx_w == read_idx_1_d)
  7.2603 +                reg_data_buf_1 <= w_result;
  7.2604 +        end
  7.2605 +    end
  7.2606 +end
  7.2607 +`endif
  7.2608 +
  7.2609 +`ifdef LM32_EBR_REGISTER_FILE
  7.2610 +`else
  7.2611 +// Register file write port
  7.2612 +always @(posedge clk_i `CFG_RESET_SENSITIVITY)
  7.2613 +begin
  7.2614 +    if (rst_i == `TRUE) begin
  7.2615 +        registers[0] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2616 +        registers[1] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2617 +        registers[2] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2618 +        registers[3] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2619 +        registers[4] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2620 +        registers[5] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2621 +        registers[6] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2622 +        registers[7] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2623 +        registers[8] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2624 +        registers[9] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2625 +        registers[10] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2626 +        registers[11] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2627 +        registers[12] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2628 +        registers[13] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2629 +        registers[14] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2630 +        registers[15] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2631 +        registers[16] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2632 +        registers[17] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2633 +        registers[18] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2634 +        registers[19] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2635 +        registers[20] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2636 +        registers[21] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2637 +        registers[22] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2638 +        registers[23] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2639 +        registers[24] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2640 +        registers[25] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2641 +        registers[26] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2642 +        registers[27] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2643 +        registers[28] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2644 +        registers[29] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2645 +        registers[30] <= {`LM32_WORD_WIDTH{1'b0}};
  7.2646 +        registers[31] <= {`LM32_WORD_WIDTH{1'b0}}; 
  7.2647 +        end
  7.2648 +    else begin
  7.2649 +        if (reg_write_enable_q_w == `TRUE)
  7.2650 +          registers[write_idx_w] <= w_result;
  7.2651 +        end
  7.2652 +end
  7.2653 +`endif
  7.2654 +
  7.2655 +`ifdef CFG_TRACE_ENABLED
  7.2656 +// PC tracing logic
  7.2657 +always @(posedge clk_i `CFG_RESET_SENSITIVITY)
  7.2658 +begin
  7.2659 +    if (rst_i == `TRUE)
  7.2660 +    begin
  7.2661 +        trace_pc_valid <= `FALSE;
  7.2662 +        trace_pc <= {`LM32_PC_WIDTH{1'b0}};
  7.2663 +        trace_exception <= `FALSE;
  7.2664 +        trace_eid <= `LM32_EID_RESET;
  7.2665 +        trace_eret <= `FALSE;
  7.2666 +`ifdef CFG_DEBUG_ENABLED
  7.2667 +        trace_bret <= `FALSE;
  7.2668 +`endif
  7.2669 +        pc_c <= `CFG_EBA_RESET/4;
  7.2670 +    end
  7.2671 +    else
  7.2672 +    begin
  7.2673 +        trace_pc_valid <= `FALSE;
  7.2674 +        // Has an exception occured
  7.2675 +`ifdef CFG_DEBUG_ENABLED
  7.2676 +        if ((debug_exception_q_w == `TRUE) || (non_debug_exception_q_w == `TRUE))
  7.2677 +`else
  7.2678 +        if (exception_q_w == `TRUE)
  7.2679 +`endif
  7.2680 +        begin        
  7.2681 +            trace_exception <= `TRUE;
  7.2682 +            trace_pc_valid <= `TRUE;
  7.2683 +            trace_pc <= pc_w;
  7.2684 +            trace_eid <= eid_w;
  7.2685 +        end
  7.2686 +        else
  7.2687 +            trace_exception <= `FALSE;
  7.2688 +        
  7.2689 +        if ((valid_w == `TRUE) && (!kill_w))
  7.2690 +        begin
  7.2691 +            // An instruction is commiting. Determine if it is non-sequential
  7.2692 +            if (pc_c + 1'b1 != pc_w)
  7.2693 +            begin
  7.2694 +                // Non-sequential instruction
  7.2695 +                trace_pc_valid <= `TRUE;
  7.2696 +                trace_pc <= pc_w;
  7.2697 +            end
  7.2698 +            // Record PC so we can determine if next instruction is sequential or not
  7.2699 +            pc_c <= pc_w;
  7.2700 +            // Indicate if it was an eret/bret instruction
  7.2701 +            trace_eret <= eret_w;
  7.2702 +`ifdef CFG_DEBUG_ENABLED
  7.2703 +            trace_bret <= bret_w;
  7.2704 +`endif
  7.2705 +        end
  7.2706 +        else
  7.2707 +        begin
  7.2708 +            trace_eret <= `FALSE;
  7.2709 +`ifdef CFG_DEBUG_ENABLED
  7.2710 +            trace_bret <= `FALSE;
  7.2711 +`endif
  7.2712 +        end
  7.2713 +    end
  7.2714 +end
  7.2715 +`endif
  7.2716 +      
  7.2717 +/////////////////////////////////////////////////////
  7.2718 +// Behavioural Logic
  7.2719 +/////////////////////////////////////////////////////
  7.2720 +
  7.2721 +// synthesis translate_off            
  7.2722 +
  7.2723 +// Reset register 0. Only needed for simulation. 
  7.2724 +initial
  7.2725 +begin
  7.2726 +`ifdef LM32_EBR_REGISTER_FILE
  7.2727 +    reg_0.mem[0] = {`LM32_WORD_WIDTH{1'b0}};
  7.2728 +    reg_1.mem[0] = {`LM32_WORD_WIDTH{1'b0}};
  7.2729 +`else
  7.2730 +    registers[0] = {`LM32_WORD_WIDTH{1'b0}};
  7.2731 +`endif
  7.2732 +end
  7.2733 +
  7.2734 +// synthesis translate_on
  7.2735 +        
  7.2736 +endmodule 

     8.1 diff -r 000000000000 -r cd0b58aa6f83 lm32_dcache.v
     8.2 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.3 +++ b/lm32_dcache.v	Sun Apr 04 20:40:03 2010 +0100
     8.4 @@ -0,0 +1,533 @@
     8.5 +// =============================================================================
     8.6 +//                           COPYRIGHT NOTICE
     8.7 +// Copyright 2006 (c) Lattice Semiconductor Corporation
     8.8 +// ALL RIGHTS RESERVED
     8.9 +// This confidential and proprietary software may be used only as authorised by
    8.10 +// a licensing agreement from Lattice Semiconductor Corporation.
    8.11 +// The entire notice above must be reproduced on all authorized copies and
    8.12 +// copies may only be made to the extent permitted by a licensing agreement from
    8.13 +// Lattice Semiconductor Corporation.
    8.14 +//
    8.15 +// Lattice Semiconductor Corporation        TEL : 1-800-Lattice (USA and Canada)
    8.16 +// 5555 NE Moore Court                            408-826-6000 (other locations)
    8.17 +// Hillsboro, OR 97124                     web  : http://www.latticesemi.com/
    8.18 +// U.S.A                                   email: techsupport@latticesemi.com
    8.19 +// =============================================================================/
    8.20 +//                         FILE DETAILS
    8.21 +// Project          : LatticeMico32
    8.22 +// File             : lm32_dcache.v
    8.23 +// Title            : Data cache
    8.24 +// Dependencies     : lm32_include.v
    8.25 +// Version          : 6.1.17
    8.26 +//                  : Initial Release
    8.27 +// Version          : 7.0SP2, 3.0
    8.28 +//                  : No Change
    8.29 +// Version	    : 3.1
    8.30 +//                  : Support for user-selected resource usage when implementing
    8.31 +//                  : cache memory. Additional parameters must be defined when
    8.32 +//                  : invoking lm32_ram.v
    8.33 +// =============================================================================
    8.34 +								 
    8.35 +`include "lm32_include.v"
    8.36 +
    8.37 +`ifdef CFG_DCACHE_ENABLED
    8.38 +
    8.39 +`define LM32_DC_ADDR_OFFSET_RNG          addr_offset_msb:addr_offset_lsb
    8.40 +`define LM32_DC_ADDR_SET_RNG             addr_set_msb:addr_set_lsb
    8.41 +`define LM32_DC_ADDR_TAG_RNG             addr_tag_msb:addr_tag_lsb
    8.42 +`define LM32_DC_ADDR_IDX_RNG             addr_set_msb:addr_offset_lsb
    8.43 +
    8.44 +`define LM32_DC_TMEM_ADDR_WIDTH          addr_set_width
    8.45 +`define LM32_DC_TMEM_ADDR_RNG            (`LM32_DC_TMEM_ADDR_WIDTH-1):0
    8.46 +`define LM32_DC_DMEM_ADDR_WIDTH          (addr_offset_width+addr_set_width)
    8.47 +`define LM32_DC_DMEM_ADDR_RNG            (`LM32_DC_DMEM_ADDR_WIDTH-1):0
    8.48 +
    8.49 +`define LM32_DC_TAGS_WIDTH               (addr_tag_width+1)
    8.50 +`define LM32_DC_TAGS_RNG                 (`LM32_DC_TAGS_WIDTH-1):0
    8.51 +`define LM32_DC_TAGS_TAG_RNG             (`LM32_DC_TAGS_WIDTH-1):1
    8.52 +`define LM32_DC_TAGS_VALID_RNG           0
    8.53 +
    8.54 +`define LM32_DC_STATE_RNG                2:0
    8.55 +`define LM32_DC_STATE_FLUSH              3'b001
    8.56 +`define LM32_DC_STATE_CHECK              3'b010
    8.57 +`define LM32_DC_STATE_REFILL             3'b100
    8.58 +
    8.59 +/////////////////////////////////////////////////////
    8.60 +// Module interface
    8.61 +/////////////////////////////////////////////////////
    8.62 +
    8.63 +module lm32_dcache ( 
    8.64 +    // ----- Inputs -----
    8.65 +    clk_i,
    8.66 +    rst_i,    
    8.67 +    stall_a,
    8.68 +    stall_x,
    8.69 +    stall_m,
    8.70 +    address_x,
    8.71 +    address_m,
    8.72 +    load_q_m,
    8.73 +    store_q_m,
    8.74 +    store_data,
    8.75 +    store_byte_select,
    8.76 +    refill_ready,
    8.77 +    refill_data,
    8.78 +    dflush,
    8.79 +    // ----- Outputs -----
    8.80 +    stall_request,
    8.81 +    restart_request,
    8.82 +    refill_request,
    8.83 +    refill_address,
    8.84 +    refilling,
    8.85 +    load_data
    8.86 +    );
    8.87 +
    8.88 +/////////////////////////////////////////////////////
    8.89 +// Parameters
    8.90 +/////////////////////////////////////////////////////
    8.91 +
    8.92 +parameter associativity = 1;                            // Associativity of the cache (Number of ways)
    8.93 +parameter sets = 512;                                   // Number of sets
    8.94 +parameter bytes_per_line = 16;                          // Number of bytes per cache line
    8.95 +parameter base_address = 0;                             // Base address of cachable memory
    8.96 +parameter limit = 0;                                    // Limit (highest address) of cachable memory
    8.97 +
    8.98 +localparam addr_offset_width = clogb2(bytes_per_line)-1-2;
    8.99 +localparam addr_set_width = clogb2(sets)-1;
   8.100 +localparam addr_offset_lsb = 2;
   8.101 +localparam addr_offset_msb = (addr_offset_lsb+addr_offset_width-1);
   8.102 +localparam addr_set_lsb = (addr_offset_msb+1);
   8.103 +localparam addr_set_msb = (addr_set_lsb+addr_set_width-1);
   8.104 +localparam addr_tag_lsb = (addr_set_msb+1);
   8.105 +localparam addr_tag_msb = clogb2(`CFG_DCACHE_LIMIT-`CFG_DCACHE_BASE_ADDRESS)-1;
   8.106 +localparam addr_tag_width = (addr_tag_msb-addr_tag_lsb+1);
   8.107 +
   8.108 +/////////////////////////////////////////////////////
   8.109 +// Inputs
   8.110 +/////////////////////////////////////////////////////
   8.111 +
   8.112 +input clk_i;                                            // Clock
   8.113 +input rst_i;                                            // Reset
   8.114 +
   8.115 +input stall_a;                                          // Stall A stage
   8.116 +input stall_x;                                          // Stall X stage
   8.117 +input stall_m;                                          // Stall M stage
   8.118 +
   8.119 +input [`LM32_WORD_RNG] address_x;                       // X stage load/store address
   8.120 +input [`LM32_WORD_RNG] address_m;                       // M stage load/store address
   8.121 +input load_q_m;                                         // Load instruction in M stage
   8.122 +input store_q_m;                                        // Store instruction in M stage
   8.123 +input [`LM32_WORD_RNG] store_data;                      // Data to store
   8.124 +input [`LM32_BYTE_SELECT_RNG] store_byte_select;        // Which bytes in store data should be modified
   8.125 +
   8.126 +input refill_ready;                                     // Indicates next word of refill data is ready
   8.127 +input [`LM32_WORD_RNG] refill_data;                     // Refill data
   8.128 +
   8.129 +input dflush;                                           // Indicates cache should be flushed
   8.130 +
   8.131 +/////////////////////////////////////////////////////
   8.132 +// Outputs
   8.133 +/////////////////////////////////////////////////////
   8.134 +
   8.135 +output stall_request;                                   // Request pipeline be stalled because cache is busy
   8.136 +wire   stall_request;
   8.137 +output restart_request;                                 // Request to restart instruction that caused the cache miss
   8.138 +reg    restart_request;
   8.139 +output refill_request;                                  // Request a refill 
   8.140 +reg    refill_request;
   8.141 +output [`LM32_WORD_RNG] refill_address;                 // Address to refill from
   8.142 +reg    [`LM32_WORD_RNG] refill_address;
   8.143 +output refilling;                                       // Indicates if the cache is currently refilling
   8.144 +reg    refilling;
   8.145 +output [`LM32_WORD_RNG] load_data;                      // Data read from cache
   8.146 +wire   [`LM32_WORD_RNG] load_data;
   8.147 +
   8.148 +/////////////////////////////////////////////////////
   8.149 +// Internal nets and registers 
   8.150 +/////////////////////////////////////////////////////
   8.151 +
   8.152 +wire read_port_enable;                                  // Cache memory read port clock enable
   8.153 +wire write_port_enable;                                 // Cache memory write port clock enable
   8.154 +wire [0:associativity-1] way_tmem_we;                   // Tag memory write enable
   8.155 +wire [0:associativity-1] way_dmem_we;                   // Data memory write enable
   8.156 +wire [`LM32_WORD_RNG] way_data[0:associativity-1];      // Data read from data memory
   8.157 +wire [`LM32_DC_TAGS_TAG_RNG] way_tag[0:associativity-1];// Tag read from tag memory
   8.158 +wire [0:associativity-1] way_valid;                     // Indicates which ways are valid
   8.159 +wire [0:associativity-1] way_match;                     // Indicates which ways matched
   8.160 +wire miss;                                              // Indicates no ways matched
   8.161 +
   8.162 +wire [`LM32_DC_TMEM_ADDR_RNG] tmem_read_address;        // Tag memory read address
   8.163 +wire [`LM32_DC_TMEM_ADDR_RNG] tmem_write_address;       // Tag memory write address
   8.164 +wire [`LM32_DC_DMEM_ADDR_RNG] dmem_read_address;        // Data memory read address
   8.165 +wire [`LM32_DC_DMEM_ADDR_RNG] dmem_write_address;       // Data memory write address
   8.166 +wire [`LM32_DC_TAGS_RNG] tmem_write_data;               // Tag memory write data        
   8.167 +reg [`LM32_WORD_RNG] dmem_write_data;                   // Data memory write data
   8.168 +
   8.169 +reg [`LM32_DC_STATE_RNG] state;                         // Current state of FSM
   8.170 +wire flushing;                                          // Indicates if cache is currently flushing
   8.171 +wire check;                                             // Indicates if cache is currently checking for hits/misses
   8.172 +wire refill;                                            // Indicates if cache is currently refilling
   8.173 +
   8.174 +wire valid_store;                                       // Indicates if there is a valid store instruction
   8.175 +reg [associativity-1:0] refill_way_select;              // Which way should be refilled
   8.176 +reg [`LM32_DC_ADDR_OFFSET_RNG] refill_offset;           // Which word in cache line should be refilled
   8.177 +wire last_refill;                                       // Indicates when on last cycle of cache refill
   8.178 +reg [`LM32_DC_TMEM_ADDR_RNG] flush_set;                 // Which set is currently being flushed
   8.179 +
   8.180 +genvar i, j;
   8.181 +
   8.182 +/////////////////////////////////////////////////////
   8.183 +// Functions
   8.184 +/////////////////////////////////////////////////////
   8.185 +
   8.186 +`include "lm32_functions.v"
   8.187 +
   8.188 +/////////////////////////////////////////////////////
   8.189 +// Instantiations
   8.190 +/////////////////////////////////////////////////////
   8.191 +
   8.192 +   generate
   8.193 +      for (i = 0; i < associativity; i = i + 1)    
   8.194 +	begin : memories
   8.195 +	   // Way data
   8.196 +           if (`LM32_DC_DMEM_ADDR_WIDTH < 11)
   8.197 +             begin : data_memories
   8.198 +		lm32_ram 
   8.199 +		  #(
   8.200 +		    // ----- Parameters -------
   8.201 +		    .data_width (32),
   8.202 +		    .address_width (`LM32_DC_DMEM_ADDR_WIDTH),
   8.203 +`ifdef CFG_DCACHE_DAT_USE_DP_TRUE
   8.204 +		    .RAM_IMPLEMENTATION ("EBR"),
   8.205 +		    .RAM_TYPE ("RAM_DP_TRUE")
   8.206 +`else
   8.207 + `ifdef CFG_DCACHE_DAT_USE_SLICE
   8.208 +		    .RAM_IMPLEMENTATION ("SLICE")
   8.209 + `else
   8.210 +		    .RAM_IMPLEMENTATION ("AUTO")
   8.211 + `endif
   8.212 +`endif
   8.213 +		    ) way_0_data_ram 
   8.214 +		    (
   8.215 +		     // ----- Inputs -------
   8.216 +		     .read_clk (clk_i),
   8.217 +		     .write_clk (clk_i),
   8.218 +		     .reset (rst_i),
   8.219 +		     .read_address (dmem_read_address),
   8.220 +		     .enable_read (read_port_enable),
   8.221 +		     .write_address (dmem_write_address),
   8.222 +		     .enable_write (write_port_enable),
   8.223 +		     .write_enable (way_dmem_we[i]),
   8.224 +		     .write_data (dmem_write_data),    
   8.225 +		     // ----- Outputs -------
   8.226 +		     .read_data (way_data[i])
   8.227 +		     );    
   8.228 +             end
   8.229 +           else
   8.230 +             begin
   8.231 +		for (j = 0; j < 4; j = j + 1)    
   8.232 +		  begin : byte_memories
   8.233 +		     lm32_ram 
   8.234 +		       #(
   8.235 +			 // ----- Parameters -------
   8.236 +			 .data_width (8),
   8.237 +			 .address_width (`LM32_DC_DMEM_ADDR_WIDTH),
   8.238 +`ifdef CFG_DCACHE_DAT_USE_DP_TRUE
   8.239 +			 .RAM_IMPLEMENTATION ("EBR"),
   8.240 +			 .RAM_TYPE ("RAM_DP_TRUE")
   8.241 +`else
   8.242 + `ifdef CFG_DCACHE_DAT_USE_SLICE
   8.243 +			 .RAM_IMPLEMENTATION ("SLICE")
   8.244 + `else
   8.245 +			 .RAM_IMPLEMENTATION ("AUTO")
   8.246 + `endif
   8.247 +`endif
   8.248 +			 ) way_0_data_ram 
   8.249 +			 (
   8.250 +			  // ----- Inputs -------
   8.251 +			  .read_clk (clk_i),
   8.252 +			  .write_clk (clk_i),
   8.253 +			  .reset (rst_i),
   8.254 +			  .read_address (dmem_read_address),
   8.255 +			  .enable_read (read_port_enable),
   8.256 +			  .write_address (dmem_write_address),
   8.257 +			  .enable_write (write_port_enable),
   8.258 +			  .write_enable (way_dmem_we[i] & (store_byte_select[j] | refill)),
   8.259 +			  .write_data (dmem_write_data[(j+1)*8-1:j*8]),    
   8.260 +			  // ----- Outputs -------
   8.261 +			  .read_data (way_data[i][(j+1)*8-1:j*8])
   8.262 +			  );
   8.263 +		  end
   8.264 +             end
   8.265 +	   
   8.266 +	   // Way tags
   8.267 +	   lm32_ram 
   8.268 +	     #(
   8.269 +	       // ----- Parameters -------
   8.270 +	       .data_width (`LM32_DC_TAGS_WIDTH),
   8.271 +	       .address_width (`LM32_DC_TMEM_ADDR_WIDTH),
   8.272 +`ifdef CFG_DCACHE_DAT_USE_DP_TRUE
   8.273 +	       .RAM_IMPLEMENTATION ("EBR"),
   8.274 +	       .RAM_TYPE ("RAM_DP_TRUE")
   8.275 +`else
   8.276 + `ifdef CFG_DCACHE_DAT_USE_SLICE
   8.277 +	       .RAM_IMPLEMENTATION ("SLICE")
   8.278 + `else
   8.279 +	       .RAM_IMPLEMENTATION ("AUTO")
   8.280 + `endif
   8.281 +`endif
   8.282 +	       ) way_0_tag_ram 
   8.283 +	       (
   8.284 +		// ----- Inputs -------
   8.285 +		.read_clk (clk_i),
   8.286 +		.write_clk (clk_i),
   8.287 +		.reset (rst_i),
   8.288 +		.read_address (tmem_read_address),
   8.289 +		.enable_read (read_port_enable),
   8.290 +		.write_address (tmem_write_address),
   8.291 +		.enable_write (`TRUE),
   8.292 +		.write_enable (way_tmem_we[i]),
   8.293 +		.write_data (tmem_write_data),
   8.294 +		// ----- Outputs -------
   8.295 +		.read_data ({way_tag[i], way_valid[i]})
   8.296 +		);
   8.297 +	end
   8.298 +      
   8.299 +   endgenerate
   8.300 +
   8.301 +/////////////////////////////////////////////////////
   8.302 +// Combinational logic
   8.303 +/////////////////////////////////////////////////////
   8.304 +
   8.305 +// Compute which ways in the cache match the address being read
   8.306 +generate
   8.307 +    for (i = 0; i < associativity; i = i + 1)
   8.308 +    begin : match
   8.309 +assign way_match[i] = ({way_tag[i], way_valid[i]} == {address_m[`LM32_DC_ADDR_TAG_RNG], `TRUE});
   8.310 +    end
   8.311 +endgenerate
   8.312 +
   8.313 +// Select data from way that matched the address being read     
   8.314 +generate
   8.315 +    if (associativity == 1)    
   8.316 +	 begin : data_1
   8.317 +assign load_data = way_data[0];
   8.318 +    end
   8.319 +    else if (associativity == 2)
   8.320 +	 begin : data_2
   8.321 +assign load_data = way_match[0] ? way_data[0] : way_data[1]; 
   8.322 +    end
   8.323 +endgenerate
   8.324 +
   8.325 +generate
   8.326 +    if (`LM32_DC_DMEM_ADDR_WIDTH < 11)
   8.327 +    begin
   8.328 +// Select data to write to data memories
   8.329 +always @(*)
   8.330 +begin
   8.331 +    if (refill == `TRUE)
   8.332 +        dmem_write_data = refill_data;
   8.333 +    else
   8.334 +    begin
   8.335 +        dmem_write_data[`LM32_BYTE_0_RNG] = store_byte_select[0] ? store_data[`LM32_BYTE_0_RNG] : load_data[`LM32_BYTE_0_RNG];
   8.336 +        dmem_write_data[`LM32_BYTE_1_RNG] = store_byte_select[1] ? store_data[`LM32_BYTE_1_RNG] : load_data[`LM32_BYTE_1_RNG];
   8.337 +        dmem_write_data[`LM32_BYTE_2_RNG] = store_byte_select[2] ? store_data[`LM32_BYTE_2_RNG] : load_data[`LM32_BYTE_2_RNG];
   8.338 +        dmem_write_data[`LM32_BYTE_3_RNG] = store_byte_select[3] ? store_data[`LM32_BYTE_3_RNG] : load_data[`LM32_BYTE_3_RNG];
   8.339 +    end
   8.340 +end
   8.341 +    end
   8.342 +    else
   8.343 +    begin
   8.344 +// Select data to write to data memories - FIXME: Should use different write ports on dual port RAMs, but they don't work
   8.345 +always @(*)
   8.346 +begin
   8.347 +    if (refill == `TRUE)
   8.348 +        dmem_write_data = refill_data;
   8.349 +    else
   8.350 +        dmem_write_data = store_data;
   8.351 +end
   8.352 +    end
   8.353 +endgenerate
   8.354 +
   8.355 +// Compute address to use to index into the data memories
   8.356 +generate 
   8.357 +     if (bytes_per_line > 4)
   8.358 +assign dmem_write_address = (refill == `TRUE) 
   8.359 +                            ? {refill_address[`LM32_DC_ADDR_SET_RNG], refill_offset}
   8.360 +                            : address_m[`LM32_DC_ADDR_IDX_RNG];
   8.361 +    else
   8.362 +assign dmem_write_address = (refill == `TRUE) 
   8.363 +                            ? refill_address[`LM32_DC_ADDR_SET_RNG]
   8.364 +                            : address_m[`LM32_DC_ADDR_IDX_RNG];
   8.365 +endgenerate
   8.366 +assign dmem_read_address = address_x[`LM32_DC_ADDR_IDX_RNG];
   8.367 +// Compute address to use to index into the tag memories   
   8.368 +assign tmem_write_address = (flushing == `TRUE)
   8.369 +                            ? flush_set
   8.370 +                            : refill_address[`LM32_DC_ADDR_SET_RNG];
   8.371 +assign tmem_read_address = address_x[`LM32_DC_ADDR_SET_RNG];
   8.372 +
   8.373 +// Compute signal to indicate when we are on the last refill accesses
   8.374 +generate 
   8.375 +    if (bytes_per_line > 4)                            
   8.376 +assign last_refill = refill_offset == {addr_offset_width{1'b1}};
   8.377 +    else
   8.378 +assign last_refill = `TRUE;
   8.379 +endgenerate
   8.380 +
   8.381 +// Compute data and tag memory access enable
   8.382 +assign read_port_enable = (stall_x == `FALSE);
   8.383 +assign write_port_enable = (refill_ready == `TRUE) || !stall_m;
   8.384 +
   8.385 +// Determine when we have a valid store
   8.386 +assign valid_store = (store_q_m == `TRUE) && (check == `TRUE);
   8.387 +
   8.388 +// Compute data and tag memory write enables
   8.389 +generate
   8.390 +    if (associativity == 1) 
   8.391 +    begin : we_1     
   8.392 +assign way_dmem_we[0] = (refill_ready == `TRUE) || ((valid_store == `TRUE) && (way_match[0] == `TRUE));
   8.393 +assign way_tmem_we[0] = (refill_ready == `TRUE) || (flushing == `TRUE);
   8.394 +    end 
   8.395 +    else 
   8.396 +    begin : we_2
   8.397 +assign way_dmem_we[0] = ((refill_ready == `TRUE) && (refill_way_select[0] == `TRUE)) || ((valid_store == `TRUE) && (way_match[0] == `TRUE));
   8.398 +assign way_dmem_we[1] = ((refill_ready == `TRUE) && (refill_way_select[1] == `TRUE)) || ((valid_store == `TRUE) && (way_match[1] == `TRUE));
   8.399 +assign way_tmem_we[0] = ((refill_ready == `TRUE) && (refill_way_select[0] == `TRUE)) || (flushing == `TRUE);
   8.400 +assign way_tmem_we[1] = ((refill_ready == `TRUE) && (refill_way_select[1] == `TRUE)) || (flushing == `TRUE);
   8.401 +    end
   8.402 +endgenerate
   8.403 +
   8.404 +// On the last refill cycle set the valid bit, for all other writes it should be cleared
   8.405 +assign tmem_write_data[`LM32_DC_TAGS_VALID_RNG] = ((last_refill == `TRUE) || (valid_store == `TRUE)) && (flushing == `FALSE);
   8.406 +assign tmem_write_data[`LM32_DC_TAGS_TAG_RNG] = refill_address[`LM32_DC_ADDR_TAG_RNG];
   8.407 +
   8.408 +// Signals that indicate which state we are in
   8.409 +assign flushing = state[0];
   8.410 +assign check = state[1];
   8.411 +assign refill = state[2];
   8.412 +
   8.413 +assign miss = (~(|way_match)) && (load_q_m == `TRUE) && (stall_m == `FALSE);
   8.414 +assign stall_request = (check == `FALSE);
   8.415 +                      
   8.416 +/////////////////////////////////////////////////////
   8.417 +// Sequential logic
   8.418 +/////////////////////////////////////////////////////
   8.419 +
   8.420 +// Record way selected for replacement on a cache miss
   8.421 +generate
   8.422 +    if (associativity >= 2) 
   8.423 +    begin : way_select      
   8.424 +always @(posedge clk_i `CFG_RESET_SENSITIVITY)
   8.425 +begin
   8.426 +    if (rst_i == `TRUE)
   8.427 +        refill_way_select <= {{associativity-1{1'b0}}, 1'b1};
   8.428 +    else
   8.429 +    begin        
   8.430 +        if (refill_request == `TRUE)
   8.431 +            refill_way_select <= {refill_way_select[0], refill_way_select[1]};
   8.432 +    end
   8.433 +end
   8.434 +    end 
   8.435 +endgenerate   
   8.436 +
   8.437 +// Record whether we are currently refilling
   8.438 +always @(posedge clk_i `CFG_RESET_SENSITIVITY)
   8.439 +begin
   8.440 +    if (rst_i == `TRUE)
   8.441 +        refilling <= `FALSE;
   8.442 +    else 
   8.443 +        refilling <= refill;
   8.444 +end
   8.445 +
   8.446 +// Instruction cache control FSM
   8.447 +always @(posedge clk_i `CFG_RESET_SENSITIVITY)
   8.448 +begin
   8.449 +    if (rst_i == `TRUE)
   8.450 +    begin
   8.451 +        state <= `LM32_DC_STATE_FLUSH;
   8.452 +        flush_set <= {`LM32_DC_TMEM_ADDR_WIDTH{1'b1}};
   8.453 +        refill_request <= `FALSE;
   8.454 +        refill_address <= {`LM32_WORD_WIDTH{1'bx}};
   8.455 +        restart_request <= `FALSE;
   8.456 +    end
   8.457 +    else 
   8.458 +    begin
   8.459 +        case (state)
   8.460 +
   8.461 +        // Flush the cache 
   8.462 +        `LM32_DC_STATE_FLUSH:
   8.463 +        begin
   8.464 +            if (flush_set == {`LM32_DC_TMEM_ADDR_WIDTH{1'b0}})
   8.465 +                state <= `LM32_DC_STATE_CHECK;
   8.466 +            flush_set <= flush_set - 1'b1;
   8.467 +        end
   8.468 +        
   8.469 +        // Check for cache misses
   8.470 +        `LM32_DC_STATE_CHECK:
   8.471 +        begin
   8.472 +            if (stall_a == `FALSE)
   8.473 +                restart_request <= `FALSE;
   8.474 +            if (miss == `TRUE)
   8.475 +            begin
   8.476 +                refill_request <= `TRUE;
   8.477 +                refill_address <= address_m;
   8.478 +                state <= `LM32_DC_STATE_REFILL;
   8.479 +            end
   8.480 +            else if (dflush == `TRUE)
   8.481 +                state <= `LM32_DC_STATE_FLUSH;
   8.482 +        end
   8.483 +
   8.484 +        // Refill a cache line
   8.485 +        `LM32_DC_STATE_REFILL:
   8.486 +        begin
   8.487 +            refill_request <= `FALSE;
   8.488 +            if (refill_ready == `TRUE)
   8.489 +            begin
   8.490 +                if (last_refill == `TRUE)
   8.491 +                begin
   8.492 +                    restart_request <= `TRUE;
   8.493 +                    state <= `LM32_DC_STATE_CHECK;
   8.494 +                end
   8.495 +            end
   8.496 +        end
   8.497 +        
   8.498 +        endcase        
   8.499 +    end
   8.500 +end
   8.501 +
   8.502 +generate
   8.503 +    if (bytes_per_line > 4)
   8.504 +    begin
   8.505 +// Refill offset
   8.506 +always @(posedge clk_i `CFG_RESET_SENSITIVITY)
   8.507 +begin
   8.508 +    if (rst_i == `TRUE)
   8.509 +        refill_offset <= {addr_offset_width{1'b0}};
   8.510 +    else 
   8.511 +    begin
   8.512 +        case (state)
   8.513 +        
   8.514 +        // Check for cache misses
   8.515 +        `LM32_DC_STATE_CHECK:
   8.516 +        begin
   8.517 +            if (miss == `TRUE)
   8.518 +                refill_offset <= {addr_offset_width{1'b0}};
   8.519 +        end
   8.520 +
   8.521 +        // Refill a cache line
   8.522 +        `LM32_DC_STATE_REFILL:
   8.523 +        begin
   8.524 +            if (refill_ready == `TRUE)
   8.525 +                refill_offset <= refill_offset + 1'b1;
   8.526 +        end
   8.527 +        
   8.528 +        endcase        
   8.529 +    end
   8.530 +end
   8.531 +    end
   8.532 +endgenerate
   8.533 +
   8.534 +endmodule
   8.535 +
   8.536 +`endif
   8.537 +