1 |
3 |
dinesha |
/*********************************************************************
|
2 |
|
|
|
3 |
|
|
SDRAM Controller Request Generation
|
4 |
|
|
|
5 |
|
|
This file is part of the sdram controller project
|
6 |
|
|
http://www.opencores.org/cores/sdr_ctrl/
|
7 |
|
|
|
8 |
|
|
Description: SDRAM Controller Reguest Generation
|
9 |
|
|
The 2Mx32 SDRAM is addressed by a 21 bit address,
|
10 |
|
|
each loation is 32 bits wide.
|
11 |
|
|
This 21 bit address is mapped as follows:
|
12 |
|
|
ADDR [7:0] : Column Address (256 columns)
|
13 |
|
|
ADDR [18:8] : Row Address (2K Rows)
|
14 |
|
|
ADDR [20:19] : Bank Address (2 banks)
|
15 |
|
|
|
16 |
|
|
The 4Mx16 SDRAM is addressed by a 22 bit address,
|
17 |
|
|
each loation is 16 bits wide.
|
18 |
|
|
This 22 bit address is mapped as follows:
|
19 |
|
|
ADDR [7:0] : Column Address (256 columns)
|
20 |
|
|
ADDR [21:10] : Row Address (4K Rows)
|
21 |
|
|
ADDR [21:20] : Bank Address (4 banks)
|
22 |
|
|
|
23 |
|
|
The 8Mx16 SDRAM is addressed by a 23 bit address,
|
24 |
|
|
each loation is 16 bits wide.
|
25 |
|
|
This 23 bit address is mapped as follows:
|
26 |
|
|
ADDR [8:0] : Column Address (512 columns)
|
27 |
|
|
ADDR [20:9] : Row Address (4K Rows)
|
28 |
|
|
ADDR [22:21] : Bank Address (4 banks)
|
29 |
|
|
|
30 |
|
|
The SDRAMs are operated in 4 beat burst mode.
|
31 |
|
|
This module takes requests from the mc,
|
32 |
|
|
chops them to page boundaries if wrap=0,
|
33 |
|
|
and passes the request to bank_ctl
|
34 |
|
|
|
35 |
|
|
To Do:
|
36 |
|
|
nothing
|
37 |
|
|
|
38 |
|
|
Author(s):
|
39 |
|
|
- Dinesh Annayya, dinesha@opencores.org
|
40 |
|
|
Version : 1.0 - 8th Jan 2012
|
41 |
|
|
|
42 |
|
|
|
43 |
|
|
|
44 |
|
|
Copyright (C) 2000 Authors and OPENCORES.ORG
|
45 |
|
|
|
46 |
|
|
This source file may be used and distributed without
|
47 |
|
|
restriction provided that this copyright statement is not
|
48 |
|
|
removed from the file and that any derivative work contains
|
49 |
|
|
the original copyright notice and the associated disclaimer.
|
50 |
|
|
|
51 |
|
|
This source file is free software; you can redistribute it
|
52 |
|
|
and/or modify it under the terms of the GNU Lesser General
|
53 |
|
|
Public License as published by the Free Software Foundation;
|
54 |
|
|
either version 2.1 of the License, or (at your option) any
|
55 |
|
|
later version.
|
56 |
|
|
|
57 |
|
|
This source is distributed in the hope that it will be
|
58 |
|
|
useful, but WITHOUT ANY WARRANTY; without even the implied
|
59 |
|
|
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
60 |
|
|
PURPOSE. See the GNU Lesser General Public License for more
|
61 |
|
|
details.
|
62 |
|
|
|
63 |
|
|
You should have received a copy of the GNU Lesser General
|
64 |
|
|
Public License along with this source; if not, download it
|
65 |
|
|
from http://www.opencores.org/lgpl.shtml
|
66 |
|
|
|
67 |
|
|
*******************************************************************/
|
68 |
|
|
|
69 |
|
|
`include "sdrc.def"
|
70 |
|
|
|
71 |
|
|
module sdrc_req_gen (clk,
|
72 |
|
|
reset_n,
|
73 |
|
|
|
74 |
|
|
/* Request from app */
|
75 |
|
|
req, // Transfer Request
|
76 |
|
|
req_id, // ID for this transfer
|
77 |
|
|
req_addr, // SDRAM Address
|
78 |
|
|
req_addr_mask,
|
79 |
|
|
req_len, // Burst Length (in 32 bit words)
|
80 |
|
|
req_wrap, // Wrap mode request (xfr_len = 4)
|
81 |
|
|
req_wr_n, // 0 => Write request, 1 => read req
|
82 |
|
|
req_ack, // Request has been accepted
|
83 |
|
|
sdr_core_busy_n, // SDRAM Core Busy Indication
|
84 |
13 |
dinesha |
cfg_colbits,
|
85 |
3 |
dinesha |
|
86 |
|
|
/* Req to bank_ctl */
|
87 |
|
|
r2x_idle,
|
88 |
|
|
r2b_req, // request
|
89 |
|
|
r2b_req_id, // ID
|
90 |
|
|
r2b_start, // First chunk of burst
|
91 |
|
|
r2b_last, // Last chunk of burst
|
92 |
|
|
r2b_wrap, // Wrap Mode
|
93 |
|
|
r2b_ba, // bank address
|
94 |
|
|
r2b_raddr, // row address
|
95 |
|
|
r2b_caddr, // col address
|
96 |
|
|
r2b_len, // length
|
97 |
|
|
r2b_write, // write request
|
98 |
|
|
b2r_ack,
|
99 |
|
|
b2r_arb_ok,
|
100 |
|
|
sdr_width,
|
101 |
|
|
sdr_init_done);
|
102 |
|
|
|
103 |
|
|
parameter APP_AW = 30; // Application Address Width
|
104 |
|
|
parameter APP_DW = 32; // Application Data Width
|
105 |
|
|
parameter APP_BW = 4; // Application Byte Width
|
106 |
|
|
parameter APP_RW = 9; // Application Request Width
|
107 |
|
|
|
108 |
|
|
parameter SDR_DW = 16; // SDR Data Width
|
109 |
|
|
parameter SDR_BW = 2; // SDR Byte Width
|
110 |
|
|
|
111 |
|
|
input clk, reset_n;
|
112 |
13 |
dinesha |
input [1:0] cfg_colbits; // 2'b00 - 8 Bit column address, 2'b01 - 9 Bit, 10 - 10 bit, 11 - 11Bits
|
113 |
3 |
dinesha |
|
114 |
|
|
/* Request from app */
|
115 |
|
|
input req;
|
116 |
|
|
input [`SDR_REQ_ID_W-1:0] req_id;
|
117 |
|
|
input [APP_AW:0] req_addr;
|
118 |
|
|
input [APP_AW-2:0] req_addr_mask;
|
119 |
|
|
input [APP_RW-1:0] req_len;
|
120 |
|
|
input req_wr_n, req_wrap;
|
121 |
|
|
output req_ack, sdr_core_busy_n;
|
122 |
|
|
|
123 |
|
|
/* Req to bank_ctl */
|
124 |
|
|
output r2x_idle, r2b_req, r2b_start, r2b_last,
|
125 |
|
|
r2b_write, r2b_wrap;
|
126 |
|
|
output [`SDR_REQ_ID_W-1:0] r2b_req_id;
|
127 |
|
|
output [1:0] r2b_ba;
|
128 |
|
|
output [11:0] r2b_raddr;
|
129 |
|
|
output [11:0] r2b_caddr;
|
130 |
|
|
output [APP_RW-1:0] r2b_len;
|
131 |
|
|
input b2r_ack, b2r_arb_ok, sdr_init_done;
|
132 |
|
|
//
|
133 |
16 |
dinesha |
input [1:0] sdr_width; // 2'b00 - 32 Bit, 2'b01 - 16 Bit, 2'b1x - 8Bit
|
134 |
|
|
|
135 |
3 |
dinesha |
|
136 |
|
|
/****************************************************************************/
|
137 |
|
|
// Internal Nets
|
138 |
|
|
|
139 |
|
|
`define REQ_IDLE 1'b0
|
140 |
|
|
`define REQ_ACTIVE 1'b1
|
141 |
|
|
|
142 |
|
|
reg req_st, next_req_st;
|
143 |
|
|
reg r2x_idle, req_ack, r2b_req, r2b_start,
|
144 |
|
|
r2b_write, req_idle, req_ld, lcl_wrap;
|
145 |
|
|
reg [`SDR_REQ_ID_W-1:0] r2b_req_id;
|
146 |
|
|
reg [APP_RW-1:0] lcl_req_len;
|
147 |
|
|
|
148 |
|
|
wire r2b_last, page_ovflw;
|
149 |
|
|
wire [APP_RW-1:0] r2b_len, next_req_len;
|
150 |
|
|
wire [APP_RW:0] max_r2b_len;
|
151 |
|
|
|
152 |
|
|
wire [1:0] r2b_ba;
|
153 |
|
|
wire [11:0] r2b_raddr;
|
154 |
|
|
wire [11:0] r2b_caddr;
|
155 |
|
|
|
156 |
|
|
reg [APP_AW-1:0] curr_sdr_addr, sdr_addrs_mask;
|
157 |
|
|
wire [APP_AW-1:0] next_sdr_addr, next_sdr_addr1;
|
158 |
|
|
|
159 |
|
|
//
|
160 |
|
|
// The maximum length for no page overflow is 200h/100h - caddr. Split a request
|
161 |
|
|
// into 2 or more requests if it crosses a page boundary.
|
162 |
|
|
// For non-queue accesses req_addr_mask is set to all 1 and the accesses
|
163 |
|
|
// proceed linearly.
|
164 |
|
|
// All queues end on a 512 byte boundary (actually a 1K boundary). For Q
|
165 |
|
|
// accesses req_addr_mask is set to LSB of 1 and MSB of 0 to constrain the
|
166 |
|
|
// accesses within the space for a Q. When splitting and calculating the next
|
167 |
|
|
// address only the LSBs are incremented, the MSBs remain = req_addr.
|
168 |
|
|
//
|
169 |
13 |
dinesha |
assign max_r2b_len = (cfg_colbits == 2'b00) ? (12'h100 - r2b_caddr) :
|
170 |
|
|
(cfg_colbits == 2'b01) ? (12'h200 - r2b_caddr) :
|
171 |
|
|
(cfg_colbits == 2'b10) ? (12'h400 - r2b_caddr) : (12'h800 - r2b_caddr);
|
172 |
3 |
dinesha |
|
173 |
|
|
assign page_ovflw = ({1'b0, lcl_req_len} > max_r2b_len) ? ~lcl_wrap : 1'b0;
|
174 |
|
|
|
175 |
|
|
assign r2b_len = (page_ovflw) ? max_r2b_len : lcl_req_len;
|
176 |
|
|
|
177 |
|
|
assign next_req_len = lcl_req_len - r2b_len;
|
178 |
|
|
|
179 |
|
|
assign next_sdr_addr1 = curr_sdr_addr + r2b_len;
|
180 |
|
|
|
181 |
|
|
// Wrap back based on the mask
|
182 |
|
|
assign next_sdr_addr = (sdr_addrs_mask & next_sdr_addr1) |
|
183 |
|
|
(~sdr_addrs_mask & curr_sdr_addr);
|
184 |
|
|
|
185 |
|
|
assign sdr_core_busy_n = req_idle & b2r_arb_ok & sdr_init_done;
|
186 |
|
|
|
187 |
|
|
assign r2b_wrap = lcl_wrap;
|
188 |
|
|
|
189 |
|
|
assign r2b_last = ~page_ovflw;
|
190 |
|
|
//
|
191 |
|
|
//
|
192 |
|
|
//
|
193 |
|
|
always @ (posedge clk) begin
|
194 |
|
|
|
195 |
|
|
r2b_start <= (req_ack) ? 1'b1 :
|
196 |
|
|
(b2r_ack) ? 1'b0 : r2b_start;
|
197 |
|
|
|
198 |
|
|
r2b_write <= (req_ack) ? ~req_wr_n : r2b_write;
|
199 |
|
|
|
200 |
|
|
r2b_req_id <= (req_ack) ? req_id : r2b_req_id;
|
201 |
|
|
|
202 |
|
|
lcl_wrap <= (req_ack) ? req_wrap : lcl_wrap;
|
203 |
|
|
|
204 |
|
|
lcl_req_len <= (req_ack) ? req_len :
|
205 |
|
|
(req_ld) ? next_req_len : lcl_req_len;
|
206 |
|
|
|
207 |
|
|
curr_sdr_addr <= (req_ack) ? req_addr :
|
208 |
|
|
(req_ld) ? next_sdr_addr : curr_sdr_addr;
|
209 |
|
|
|
210 |
16 |
dinesha |
sdr_addrs_mask <= (req_ack) ?((sdr_width == 2'b00) ? req_addr_mask :
|
211 |
|
|
(sdr_width == 2'b01) ? {req_addr_mask,req_addr_mask[0]} :
|
212 |
|
|
{req_addr_mask,req_addr_mask[1:0]}) : sdr_addrs_mask;
|
213 |
3 |
dinesha |
|
214 |
|
|
end // always @ (posedge clk)
|
215 |
|
|
|
216 |
|
|
always @ (*) begin
|
217 |
|
|
|
218 |
|
|
case (req_st) // synopsys full_case parallel_case
|
219 |
|
|
|
220 |
|
|
`REQ_IDLE : begin
|
221 |
|
|
r2x_idle = ~req;
|
222 |
|
|
req_idle = 1'b1;
|
223 |
|
|
req_ack = req & b2r_arb_ok;
|
224 |
|
|
req_ld = 1'b0;
|
225 |
|
|
r2b_req = 1'b0;
|
226 |
|
|
next_req_st = (req & b2r_arb_ok) ? `REQ_ACTIVE : `REQ_IDLE;
|
227 |
|
|
end // case: `REQ_IDLE
|
228 |
|
|
|
229 |
|
|
`REQ_ACTIVE : begin
|
230 |
|
|
r2x_idle = 1'b0;
|
231 |
|
|
req_idle = 1'b0;
|
232 |
|
|
req_ack = 1'b0;
|
233 |
|
|
req_ld = b2r_ack;
|
234 |
|
|
r2b_req = 1'b1; // req_gen to bank_req
|
235 |
|
|
next_req_st = (b2r_ack & r2b_last) ? `REQ_IDLE : `REQ_ACTIVE;
|
236 |
|
|
end // case: `REQ_ACTIVE
|
237 |
|
|
|
238 |
|
|
endcase // case(req_st)
|
239 |
|
|
|
240 |
|
|
end // always @ (req_st or ....)
|
241 |
|
|
|
242 |
|
|
always @ (posedge clk)
|
243 |
|
|
if (~reset_n) begin
|
244 |
|
|
req_st <= `REQ_IDLE;
|
245 |
|
|
end // if (~reset_n)
|
246 |
|
|
else begin
|
247 |
|
|
req_st <= next_req_st;
|
248 |
|
|
end // else: !if(~reset_n)
|
249 |
|
|
//
|
250 |
|
|
// addrs bits for the bank, row and column
|
251 |
|
|
//
|
252 |
|
|
|
253 |
13 |
dinesha |
// Bank Bits are always - 2 Bits
|
254 |
|
|
assign r2b_ba = (cfg_colbits == 2'b00) ? {curr_sdr_addr[9:8]} :
|
255 |
|
|
(cfg_colbits == 2'b01) ? {curr_sdr_addr[10:9]} :
|
256 |
|
|
(cfg_colbits == 2'b10) ? {curr_sdr_addr[11:10]} : curr_sdr_addr[12:11];
|
257 |
3 |
dinesha |
|
258 |
13 |
dinesha |
/********************
|
259 |
|
|
* Colbits Mapping:
|
260 |
|
|
* 2'b00 - 8 Bit
|
261 |
|
|
* 2'b01 - 16 Bit
|
262 |
|
|
* 2'b10 - 10 Bit
|
263 |
|
|
* 2'b11 - 11 Bits
|
264 |
|
|
************************/
|
265 |
|
|
assign r2b_caddr = (cfg_colbits == 2'b00) ? {4'b0, curr_sdr_addr[7:0]} :
|
266 |
|
|
(cfg_colbits == 2'b01) ? {3'b0, curr_sdr_addr[8:0]} :
|
267 |
|
|
(cfg_colbits == 2'b10) ? {2'b0, curr_sdr_addr[9:0]} : {1'b0, curr_sdr_addr[10:0]};
|
268 |
3 |
dinesha |
|
269 |
13 |
dinesha |
assign r2b_raddr = (cfg_colbits == 2'b00) ? curr_sdr_addr[21:10] :
|
270 |
|
|
(cfg_colbits == 2'b01) ? curr_sdr_addr[22:11] :
|
271 |
|
|
(cfg_colbits == 2'b10) ? curr_sdr_addr[23:12] : curr_sdr_addr[24:13];
|
272 |
|
|
|
273 |
3 |
dinesha |
|
274 |
|
|
endmodule // sdr_req_gen
|