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

Subversion Repositories wdsp

[/] [wdsp/] [trunk/] [rtl/] [verilog/] [minsoc/] [mc/] [mc_adr_sel.v] - Blame information for rev 5

Details | Compare with Previous | View Log


/////////////////////////////////////////////////////////////////////
////                                                             ////
////  WISHBONE Memory Controller Address Select Block            ////
////                                                             ////
////                                                             ////
////  Author: Rudolf Usselmann                                   ////
////          rudi@asics.ws                                      ////
////                                                             ////
////                                                             ////
////  Downloaded from: http://www.opencores.org/cores/mem_ctrl/  ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
////                                                             ////
//// Copyright (C) 2000-2002 Rudolf Usselmann                    ////
////                         www.asics.ws                        ////
////                         rudi@asics.ws                       ////
////                                                             ////
//// This source file may be used and distributed without        ////
//// restriction provided that this copyright statement is not   ////
//// removed from the file and that any derivative work contains ////
//// the original copyright notice and the associated disclaimer.////
////                                                             ////
////     THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY     ////
//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   ////
//// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS   ////
//// FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR      ////
//// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,         ////
//// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    ////
//// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE   ////
//// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR        ////
//// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF  ////
//// LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT  ////
//// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT  ////
//// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE         ////
//// POSSIBILITY OF SUCH DAMAGE.                                 ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
 
//  CVS Log
//
//  $Id: mc_adr_sel.v,v 1.4 2002/01/21 13:08:52 rudi Exp $
//
//  $Date: 2002/01/21 13:08:52 $
//  $Revision: 1.4 $
//  $Author: rudi $
//  $Locker:  $
//  $State: Exp $
//
// Change History:
//               $Log: mc_adr_sel.v,v $
//               Revision 1.4  2002/01/21 13:08:52  rudi
//
//               Fixed several minor bugs, cleaned up the code further ...
//
//               Revision 1.3  2001/11/29 02:16:28  rudi
//
//
//               - More Synthesis cleanup, mostly for speed
//               - Several bug fixes
//               - Changed code to avoid auto-precharge and
//                 burst-terminate combinations (apparently illegal ?)
//                 Now we will do a manual precharge ...
//
//               Revision 1.2  2001/08/10 08:16:21  rudi
//
//               - Changed IO names to be more clear.
//               - Uniquifyed define names to be core specific.
//               - Removed "Refresh Early" configuration
//
//               Revision 1.1  2001/07/29 07:34:41  rudi
//
//
//               1) Changed Directory Structure
//               2) Fixed several minor bugs
//
//               Revision 1.2  2001/06/12 15:19:49  rudi
//
//
//               Minor changes after running lint, and a small bug fix reading csr and ba_mask registers.
//
//               Revision 1.1.1.1  2001/05/13 09:39:40  rudi
//               Created Directory Structure
//
//
//
//
 
`include "mc_defines.v"
 
module mc_adr_sel(clk, csc, tms, wb_ack_o, wb_stb_i, wb_addr_i, wb_we_i,
                wb_write_go, wr_hold, cas_,
                mc_addr, row_adr, bank_adr, rfr_ack,
                cs_le, cmd_a10, row_sel, lmr_sel, next_adr, wr_cycle,
                page_size);
 
input           clk;
input   [31:0]   csc;
input   [31:0]   tms;
input           wb_ack_o, wb_stb_i;
input   [31:0]   wb_addr_i;
input           wb_we_i;
input           wb_write_go;
input           wr_hold;
input           cas_;
output  [23:0]   mc_addr;
output  [12:0]   row_adr;
output  [1:0]    bank_adr;
input           rfr_ack;
input           cs_le;
input           cmd_a10;
input           row_sel;
input           lmr_sel;
input           next_adr;
input           wr_cycle;
output  [10:0]   page_size;
 
////////////////////////////////////////////////////////////////////
//
// Local Registers & Wires
//
 
reg     [23:0]   mc_addr_d;
reg     [23:0]   acs_addr;
wire    [23:0]   acs_addr_pl1;
reg     [23:0]   sram_addr;
wire    [14:0]   sdram_adr;
reg     [12:0]   row_adr;
reg     [9:0]    col_adr;
reg     [1:0]    bank_adr;
reg     [10:0]   page_size;
 
wire    [2:0]    mem_type;
wire    [1:0]    bus_width;
wire    [1:0]    mem_size;
wire            bas;
 
// Aliases
assign mem_type  = csc[3:1];
assign bus_width = csc[5:4];
assign mem_size  = csc[7:6];
assign bas       = csc[9];
 
////////////////////////////////////////////////////////////////////
//
// Misc Logic
//
 
always @(mem_type or wr_hold or sdram_adr or acs_addr or sram_addr or wb_addr_i)
        if(mem_type == `MC_MEM_TYPE_SDRAM)              mc_addr_d = {9'h0, sdram_adr};
        else
        if(mem_type == `MC_MEM_TYPE_ACS)                mc_addr_d = acs_addr;
        else
        if((mem_type == `MC_MEM_TYPE_SRAM) & wr_hold)   mc_addr_d = sram_addr;
        else                                            mc_addr_d = wb_addr_i[25:2];
 
assign mc_addr = rfr_ack ? {mc_addr_d[23:11], 1'b1, mc_addr_d[9:0]} : mc_addr_d;
 
////////////////////////////////////////////////////////////////////
//
// Async Devices Address Latch & Counter
//
 
mc_incn_r #(24) u0(     .clk(           clk             ),
                        .inc_in(        acs_addr        ),
                        .inc_out(       acs_addr_pl1    ) );
 
always @(posedge clk)
        if(wb_stb_i)    sram_addr <= #1 wb_addr_i[25:2];
 
always @(posedge clk)
        if(cs_le | wb_we_i)
                case(bus_width)         // synopsys full_case parallel_case
                   `MC_BW_8:    acs_addr <= #1 wb_addr_i[23:0];
                   `MC_BW_16:   acs_addr <= #1 wb_addr_i[24:1];
                   `MC_BW_32:   acs_addr <= #1 wb_addr_i[25:2];
                endcase
        else
        if(next_adr)            acs_addr <= #1 acs_addr_pl1;
 
////////////////////////////////////////////////////////////////////
//
// SDRAM Address Mux
//
 
assign sdram_adr[12:0] = (lmr_sel & !cas_) ? tms[12:0] :
                                row_sel ? row_adr :
                                {2'h0, cmd_a10, col_adr};
 
assign sdram_adr[14:13] = bank_adr;
 
always @(posedge clk)
   if(wr_cycle ? wb_ack_o : wb_stb_i)
        casex({bus_width, mem_size})            // synopsys full_case parallel_case
           {`MC_BW_8, `MC_MEM_SIZE_64}:         col_adr <= #1 {1'h0, wb_addr_i[10:2]};
           {`MC_BW_8, `MC_MEM_SIZE_128}:        col_adr <= #1        wb_addr_i[11:2];
           {`MC_BW_8, `MC_MEM_SIZE_256}:        col_adr <= #1        wb_addr_i[11:2];
 
           {`MC_BW_16, `MC_MEM_SIZE_64}:        col_adr <= #1 {2'h0, wb_addr_i[09:2]};
           {`MC_BW_16, `MC_MEM_SIZE_128}:       col_adr <= #1 {1'h0, wb_addr_i[10:2]};
           {`MC_BW_16, `MC_MEM_SIZE_256}:       col_adr <= #1 {1'h0, wb_addr_i[10:2]};
 
           {`MC_BW_32, `MC_MEM_SIZE_64}:        col_adr <= #1 {2'h0, wb_addr_i[09:2]};
           {`MC_BW_32, `MC_MEM_SIZE_128}:       col_adr <= #1 {2'h0, wb_addr_i[09:2]};
           {`MC_BW_32, `MC_MEM_SIZE_256}:       col_adr <= #1 {2'h0, wb_addr_i[09:2]};
        endcase
 
always @(posedge clk)
   if(cs_le)
     begin
        if(!bas)
                casex({bus_width, mem_size})            // synopsys full_case parallel_case
                   {`MC_BW_8, `MC_MEM_SIZE_64}:         row_adr <= #1 {1'h0, wb_addr_i[24:13]};
                   {`MC_BW_8, `MC_MEM_SIZE_128}:        row_adr <= #1 {1'h0, wb_addr_i[25:14]};
                   {`MC_BW_8, `MC_MEM_SIZE_256}:        row_adr <= #1        wb_addr_i[26:14];
 
                   {`MC_BW_16, `MC_MEM_SIZE_64}:        row_adr <= #1 {1'h0, wb_addr_i[23:12]};
                   {`MC_BW_16, `MC_MEM_SIZE_128}:       row_adr <= #1 {1'h0, wb_addr_i[24:13]};
                   {`MC_BW_16, `MC_MEM_SIZE_256}:       row_adr <= #1        wb_addr_i[25:13];
 
                   {`MC_BW_32, `MC_MEM_SIZE_64}:        row_adr <= #1 {2'h0, wb_addr_i[22:12]};
                   {`MC_BW_32, `MC_MEM_SIZE_128}:       row_adr <= #1 {1'h0, wb_addr_i[23:12]};
                   {`MC_BW_32, `MC_MEM_SIZE_256}:       row_adr <= #1        wb_addr_i[24:12];
                endcase
        else
                casex({bus_width, mem_size})            // synopsys full_case parallel_case
                   {`MC_BW_8, `MC_MEM_SIZE_64}:         row_adr <= #1 {1'h0, wb_addr_i[22:11]};
                   {`MC_BW_8, `MC_MEM_SIZE_128}:        row_adr <= #1 {1'h0, wb_addr_i[23:12]};
                   {`MC_BW_8, `MC_MEM_SIZE_256}:        row_adr <= #1        wb_addr_i[24:12];
 
                   {`MC_BW_16, `MC_MEM_SIZE_64}:        row_adr <= #1 {1'h0, wb_addr_i[21:10]};
                   {`MC_BW_16, `MC_MEM_SIZE_128}:       row_adr <= #1 {1'h0, wb_addr_i[22:11]};
                   {`MC_BW_16, `MC_MEM_SIZE_256}:       row_adr <= #1        wb_addr_i[23:11];
 
                   {`MC_BW_32, `MC_MEM_SIZE_64}:        row_adr <= #1 {2'h0, wb_addr_i[20:10]};
                   {`MC_BW_32, `MC_MEM_SIZE_128}:       row_adr <= #1 {1'h0, wb_addr_i[21:10]};
                   {`MC_BW_32, `MC_MEM_SIZE_256}:       row_adr <= #1        wb_addr_i[22:10];
                endcase
     end
 
 
always @(posedge clk)
   if(cs_le)
     begin
        if(!bas)
                casex({bus_width, mem_size})            // synopsys full_case parallel_case
                   {`MC_BW_8, `MC_MEM_SIZE_64}:         bank_adr <= #1 wb_addr_i[12:11];
                   {`MC_BW_8, `MC_MEM_SIZE_128}:        bank_adr <= #1 wb_addr_i[13:12];
                   {`MC_BW_8, `MC_MEM_SIZE_256}:        bank_adr <= #1 wb_addr_i[13:12];
 
                   {`MC_BW_16, `MC_MEM_SIZE_64}:        bank_adr <= #1 wb_addr_i[11:10];
                   {`MC_BW_16, `MC_MEM_SIZE_128}:       bank_adr <= #1 wb_addr_i[12:11];
                   {`MC_BW_16, `MC_MEM_SIZE_256}:       bank_adr <= #1 wb_addr_i[12:11];
 
                   {`MC_BW_32, `MC_MEM_SIZE_64}:        bank_adr <= #1 wb_addr_i[11:10];
                   {`MC_BW_32, `MC_MEM_SIZE_128}:       bank_adr <= #1 wb_addr_i[11:10];
                   {`MC_BW_32, `MC_MEM_SIZE_256}:       bank_adr <= #1 wb_addr_i[11:10];
                endcase
        else
                casex({bus_width, mem_size})            // synopsys full_case parallel_case
                   {`MC_BW_8, `MC_MEM_SIZE_64}:         bank_adr <= #1 wb_addr_i[24:23];
                   {`MC_BW_8, `MC_MEM_SIZE_128}:        bank_adr <= #1 wb_addr_i[25:24];
                   {`MC_BW_8, `MC_MEM_SIZE_256}:        bank_adr <= #1 wb_addr_i[26:25];
 
                   {`MC_BW_16, `MC_MEM_SIZE_64}:        bank_adr <= #1 wb_addr_i[23:22];
                   {`MC_BW_16, `MC_MEM_SIZE_128}:       bank_adr <= #1 wb_addr_i[24:23];
                   {`MC_BW_16, `MC_MEM_SIZE_256}:       bank_adr <= #1 wb_addr_i[25:24];
 
                   {`MC_BW_32, `MC_MEM_SIZE_64}:        bank_adr <= #1 wb_addr_i[22:21];
                   {`MC_BW_32, `MC_MEM_SIZE_128}:       bank_adr <= #1 wb_addr_i[23:22];
                   {`MC_BW_32, `MC_MEM_SIZE_256}:       bank_adr <= #1 wb_addr_i[24:23];
                endcase
     end
 
always @(bus_width or mem_size)
        casex({bus_width, mem_size})            // synopsys full_case parallel_case
           {`MC_BW_8, `MC_MEM_SIZE_64}:         page_size = 11'd512;
           {`MC_BW_8, `MC_MEM_SIZE_128}:        page_size = 11'd1024;
           {`MC_BW_8, `MC_MEM_SIZE_256}:        page_size = 11'd1024;
 
           {`MC_BW_16, `MC_MEM_SIZE_64}:        page_size = 11'd256;
           {`MC_BW_16, `MC_MEM_SIZE_128}:       page_size = 11'd512;
           {`MC_BW_16, `MC_MEM_SIZE_256}:       page_size = 11'd512;
 
           {`MC_BW_32, `MC_MEM_SIZE_64}:        page_size = 11'd256;
           {`MC_BW_32, `MC_MEM_SIZE_128}:       page_size = 11'd256;
           {`MC_BW_32, `MC_MEM_SIZE_256}:       page_size = 11'd256;
        endcase
 
endmodule
 

Browse

Tools

Subversion Repositories wdsp

[/] [wdsp/] [trunk/] [rtl/] [verilog/] [minsoc/] [mc/] [mc_adr_sel.v] - Blame information for rev 5

Line No.	Rev	Author	Line
1	5	parrado	`/////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// WISHBONE Memory Controller Address Select Block ////`
4			`//// ////`
5			`//// ////`
6			`//// Author: Rudolf Usselmann ////`
7			`//// rudi@asics.ws ////`
8			`//// ////`
9			`//// ////`
10			`//// Downloaded from: http://www.opencores.org/cores/mem_ctrl/ ////`
11			`//// ////`
12			`/////////////////////////////////////////////////////////////////////`
13			`//// ////`
14			`//// Copyright (C) 2000-2002 Rudolf Usselmann ////`
15			`//// www.asics.ws ////`
16			`//// rudi@asics.ws ////`
17			`//// ////`
18			`//// This source file may be used and distributed without ////`
19			`//// restriction provided that this copyright statement is not ////`
20			`//// removed from the file and that any derivative work contains ////`
21			`//// the original copyright notice and the associated disclaimer.////`
22			`//// ////`
23			//// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY ////
24			`//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED ////`
25			`//// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ////`
26			`//// FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR ////`
27			`//// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ////`
28			`//// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ////`
29			`//// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE ////`
30			`//// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR ////`
31			`//// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF ////`
32			`//// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ////`
33			`//// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT ////`
34			`//// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ////`
35			`//// POSSIBILITY OF SUCH DAMAGE. ////`
36			`//// ////`
37			`/////////////////////////////////////////////////////////////////////`
38
39			`// CVS Log`
40			`//`
41			`// $Id: mc_adr_sel.v,v 1.4 2002/01/21 13:08:52 rudi Exp $`
42			`//`
43			`// $Date: 2002/01/21 13:08:52 $`
44			`// $Revision: 1.4 $`
45			`// $Author: rudi $`
46			`// $Locker: $`
47			`// $State: Exp $`
48			`//`
49			`// Change History:`
50			`// $Log: mc_adr_sel.v,v $`
51			`// Revision 1.4 2002/01/21 13:08:52 rudi`
52			`//`
53			`// Fixed several minor bugs, cleaned up the code further ...`
54			`//`
55			`// Revision 1.3 2001/11/29 02:16:28 rudi`
56			`//`
57			`//`
58			`// - More Synthesis cleanup, mostly for speed`
59			`// - Several bug fixes`
60			`// - Changed code to avoid auto-precharge and`
61			`// burst-terminate combinations (apparently illegal ?)`
62			`// Now we will do a manual precharge ...`
63			`//`
64			`// Revision 1.2 2001/08/10 08:16:21 rudi`
65			`//`
66			`// - Changed IO names to be more clear.`
67			`// - Uniquifyed define names to be core specific.`
68			`// - Removed "Refresh Early" configuration`
69			`//`
70			`// Revision 1.1 2001/07/29 07:34:41 rudi`
71			`//`
72			`//`
73			`// 1) Changed Directory Structure`
74			`// 2) Fixed several minor bugs`
75			`//`
76			`// Revision 1.2 2001/06/12 15:19:49 rudi`
77			`//`
78			`//`
79			`// Minor changes after running lint, and a small bug fix reading csr and ba_mask registers.`
80			`//`
81			`// Revision 1.1.1.1 2001/05/13 09:39:40 rudi`
82			`// Created Directory Structure`
83			`//`
84			`//`
85			`//`
86			`//`
87
88			`include "mc_defines.v"
89
90			`module mc_adr_sel(clk, csc, tms, wb_ack_o, wb_stb_i, wb_addr_i, wb_we_i,`
91			`wb_write_go, wr_hold, cas_,`
92			`mc_addr, row_adr, bank_adr, rfr_ack,`
93			`cs_le, cmd_a10, row_sel, lmr_sel, next_adr, wr_cycle,`
94			`page_size);`
95
96			`input clk;`
97			`input [31:0] csc;`
98			`input [31:0] tms;`
99			`input wb_ack_o, wb_stb_i;`
100			`input [31:0] wb_addr_i;`
101			`input wb_we_i;`
102			`input wb_write_go;`
103			`input wr_hold;`
104			`input cas_;`
105			`output [23:0] mc_addr;`
106			`output [12:0] row_adr;`
107			`output [1:0] bank_adr;`
108			`input rfr_ack;`
109			`input cs_le;`
110			`input cmd_a10;`
111			`input row_sel;`
112			`input lmr_sel;`
113			`input next_adr;`
114			`input wr_cycle;`
115			`output [10:0] page_size;`
116
117			`////////////////////////////////////////////////////////////////////`
118			`//`
119			`// Local Registers & Wires`
120			`//`
121
122			`reg [23:0] mc_addr_d;`
123			`reg [23:0] acs_addr;`
124			`wire [23:0] acs_addr_pl1;`
125			`reg [23:0] sram_addr;`
126			`wire [14:0] sdram_adr;`
127			`reg [12:0] row_adr;`
128			`reg [9:0] col_adr;`
129			`reg [1:0] bank_adr;`
130			`reg [10:0] page_size;`
131
132			`wire [2:0] mem_type;`
133			`wire [1:0] bus_width;`
134			`wire [1:0] mem_size;`
135			`wire bas;`
136
137			`// Aliases`
138			`assign mem_type = csc[3:1];`
139			`assign bus_width = csc[5:4];`
140			`assign mem_size = csc[7:6];`
141			`assign bas = csc[9];`
142
143			`////////////////////////////////////////////////////////////////////`
144			`//`
145			`// Misc Logic`
146			`//`
147
148			`always @(mem_type or wr_hold or sdram_adr or acs_addr or sram_addr or wb_addr_i)`
149			if(mem_type == `MC_MEM_TYPE_SDRAM) mc_addr_d = {9'h0, sdram_adr};
150			`else`
151			if(mem_type == `MC_MEM_TYPE_ACS) mc_addr_d = acs_addr;
152			`else`
153			if((mem_type == `MC_MEM_TYPE_SRAM) & wr_hold) mc_addr_d = sram_addr;
154			`else mc_addr_d = wb_addr_i[25:2];`
155
156			`assign mc_addr = rfr_ack ? {mc_addr_d[23:11], 1'b1, mc_addr_d[9:0]} : mc_addr_d;`
157
158			`////////////////////////////////////////////////////////////////////`
159			`//`
160			`// Async Devices Address Latch & Counter`
161			`//`
162
163			`mc_incn_r #(24) u0( .clk( clk ),`
164			`.inc_in( acs_addr ),`
165			`.inc_out( acs_addr_pl1 ) );`
166
167			`always @(posedge clk)`
168			`if(wb_stb_i) sram_addr <= #1 wb_addr_i[25:2];`
169
170			`always @(posedge clk)`
171			`if(cs_le \| wb_we_i)`
172			`case(bus_width) // synopsys full_case parallel_case`
173			`MC_BW_8: acs_addr <= #1 wb_addr_i[23:0];
174			`MC_BW_16: acs_addr <= #1 wb_addr_i[24:1];
175			`MC_BW_32: acs_addr <= #1 wb_addr_i[25:2];
176			`endcase`
177			`else`
178			`if(next_adr) acs_addr <= #1 acs_addr_pl1;`
179
180			`////////////////////////////////////////////////////////////////////`
181			`//`
182			`// SDRAM Address Mux`
183			`//`
184
185			`assign sdram_adr[12:0] = (lmr_sel & !cas_) ? tms[12:0] :`
186			`row_sel ? row_adr :`
187			`{2'h0, cmd_a10, col_adr};`
188
189			`assign sdram_adr[14:13] = bank_adr;`
190
191			`always @(posedge clk)`
192			`if(wr_cycle ? wb_ack_o : wb_stb_i)`
193			`casex({bus_width, mem_size}) // synopsys full_case parallel_case`
194			{`MC_BW_8, `MC_MEM_SIZE_64}: col_adr <= #1 {1'h0, wb_addr_i[10:2]};
195			{`MC_BW_8, `MC_MEM_SIZE_128}: col_adr <= #1 wb_addr_i[11:2];
196			{`MC_BW_8, `MC_MEM_SIZE_256}: col_adr <= #1 wb_addr_i[11:2];
197
198			{`MC_BW_16, `MC_MEM_SIZE_64}: col_adr <= #1 {2'h0, wb_addr_i[09:2]};
199			{`MC_BW_16, `MC_MEM_SIZE_128}: col_adr <= #1 {1'h0, wb_addr_i[10:2]};
200			{`MC_BW_16, `MC_MEM_SIZE_256}: col_adr <= #1 {1'h0, wb_addr_i[10:2]};
201
202			{`MC_BW_32, `MC_MEM_SIZE_64}: col_adr <= #1 {2'h0, wb_addr_i[09:2]};
203			{`MC_BW_32, `MC_MEM_SIZE_128}: col_adr <= #1 {2'h0, wb_addr_i[09:2]};
204			{`MC_BW_32, `MC_MEM_SIZE_256}: col_adr <= #1 {2'h0, wb_addr_i[09:2]};
205			`endcase`
206
207			`always @(posedge clk)`
208			`if(cs_le)`
209			`begin`
210			`if(!bas)`
211			`casex({bus_width, mem_size}) // synopsys full_case parallel_case`
212			{`MC_BW_8, `MC_MEM_SIZE_64}: row_adr <= #1 {1'h0, wb_addr_i[24:13]};
213			{`MC_BW_8, `MC_MEM_SIZE_128}: row_adr <= #1 {1'h0, wb_addr_i[25:14]};
214			{`MC_BW_8, `MC_MEM_SIZE_256}: row_adr <= #1 wb_addr_i[26:14];
215
216			{`MC_BW_16, `MC_MEM_SIZE_64}: row_adr <= #1 {1'h0, wb_addr_i[23:12]};
217			{`MC_BW_16, `MC_MEM_SIZE_128}: row_adr <= #1 {1'h0, wb_addr_i[24:13]};
218			{`MC_BW_16, `MC_MEM_SIZE_256}: row_adr <= #1 wb_addr_i[25:13];
219
220			{`MC_BW_32, `MC_MEM_SIZE_64}: row_adr <= #1 {2'h0, wb_addr_i[22:12]};
221			{`MC_BW_32, `MC_MEM_SIZE_128}: row_adr <= #1 {1'h0, wb_addr_i[23:12]};
222			{`MC_BW_32, `MC_MEM_SIZE_256}: row_adr <= #1 wb_addr_i[24:12];
223			`endcase`
224			`else`
225			`casex({bus_width, mem_size}) // synopsys full_case parallel_case`
226			{`MC_BW_8, `MC_MEM_SIZE_64}: row_adr <= #1 {1'h0, wb_addr_i[22:11]};
227			{`MC_BW_8, `MC_MEM_SIZE_128}: row_adr <= #1 {1'h0, wb_addr_i[23:12]};
228			{`MC_BW_8, `MC_MEM_SIZE_256}: row_adr <= #1 wb_addr_i[24:12];
229
230			{`MC_BW_16, `MC_MEM_SIZE_64}: row_adr <= #1 {1'h0, wb_addr_i[21:10]};
231			{`MC_BW_16, `MC_MEM_SIZE_128}: row_adr <= #1 {1'h0, wb_addr_i[22:11]};
232			{`MC_BW_16, `MC_MEM_SIZE_256}: row_adr <= #1 wb_addr_i[23:11];
233
234			{`MC_BW_32, `MC_MEM_SIZE_64}: row_adr <= #1 {2'h0, wb_addr_i[20:10]};
235			{`MC_BW_32, `MC_MEM_SIZE_128}: row_adr <= #1 {1'h0, wb_addr_i[21:10]};
236			{`MC_BW_32, `MC_MEM_SIZE_256}: row_adr <= #1 wb_addr_i[22:10];
237			`endcase`
238			`end`
239
240
241			`always @(posedge clk)`
242			`if(cs_le)`
243			`begin`
244			`if(!bas)`
245			`casex({bus_width, mem_size}) // synopsys full_case parallel_case`
246			{`MC_BW_8, `MC_MEM_SIZE_64}: bank_adr <= #1 wb_addr_i[12:11];
247			{`MC_BW_8, `MC_MEM_SIZE_128}: bank_adr <= #1 wb_addr_i[13:12];
248			{`MC_BW_8, `MC_MEM_SIZE_256}: bank_adr <= #1 wb_addr_i[13:12];
249
250			{`MC_BW_16, `MC_MEM_SIZE_64}: bank_adr <= #1 wb_addr_i[11:10];
251			{`MC_BW_16, `MC_MEM_SIZE_128}: bank_adr <= #1 wb_addr_i[12:11];
252			{`MC_BW_16, `MC_MEM_SIZE_256}: bank_adr <= #1 wb_addr_i[12:11];
253
254			{`MC_BW_32, `MC_MEM_SIZE_64}: bank_adr <= #1 wb_addr_i[11:10];
255			{`MC_BW_32, `MC_MEM_SIZE_128}: bank_adr <= #1 wb_addr_i[11:10];
256			{`MC_BW_32, `MC_MEM_SIZE_256}: bank_adr <= #1 wb_addr_i[11:10];
257			`endcase`
258			`else`
259			`casex({bus_width, mem_size}) // synopsys full_case parallel_case`
260			{`MC_BW_8, `MC_MEM_SIZE_64}: bank_adr <= #1 wb_addr_i[24:23];
261			{`MC_BW_8, `MC_MEM_SIZE_128}: bank_adr <= #1 wb_addr_i[25:24];
262			{`MC_BW_8, `MC_MEM_SIZE_256}: bank_adr <= #1 wb_addr_i[26:25];
263
264			{`MC_BW_16, `MC_MEM_SIZE_64}: bank_adr <= #1 wb_addr_i[23:22];
265			{`MC_BW_16, `MC_MEM_SIZE_128}: bank_adr <= #1 wb_addr_i[24:23];
266			{`MC_BW_16, `MC_MEM_SIZE_256}: bank_adr <= #1 wb_addr_i[25:24];
267
268			{`MC_BW_32, `MC_MEM_SIZE_64}: bank_adr <= #1 wb_addr_i[22:21];
269			{`MC_BW_32, `MC_MEM_SIZE_128}: bank_adr <= #1 wb_addr_i[23:22];
270			{`MC_BW_32, `MC_MEM_SIZE_256}: bank_adr <= #1 wb_addr_i[24:23];
271			`endcase`
272			`end`
273
274			`always @(bus_width or mem_size)`
275			`casex({bus_width, mem_size}) // synopsys full_case parallel_case`
276			{`MC_BW_8, `MC_MEM_SIZE_64}: page_size = 11'd512;
277			{`MC_BW_8, `MC_MEM_SIZE_128}: page_size = 11'd1024;
278			{`MC_BW_8, `MC_MEM_SIZE_256}: page_size = 11'd1024;
279
280			{`MC_BW_16, `MC_MEM_SIZE_64}: page_size = 11'd256;
281			{`MC_BW_16, `MC_MEM_SIZE_128}: page_size = 11'd512;
282			{`MC_BW_16, `MC_MEM_SIZE_256}: page_size = 11'd512;
283
284			{`MC_BW_32, `MC_MEM_SIZE_64}: page_size = 11'd256;
285			{`MC_BW_32, `MC_MEM_SIZE_128}: page_size = 11'd256;
286			{`MC_BW_32, `MC_MEM_SIZE_256}: page_size = 11'd256;
287			`endcase`
288
289			`endmodule`
290