OpenCores
URL https://opencores.org/ocsvn/sdr_ctrl/sdr_ctrl/trunk

Subversion Repositories sdr_ctrl

[/] [sdr_ctrl/] [trunk/] [rtl/] [core/] [sdrc_req_gen.v] - Blame information for rev 19

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.