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

Subversion Repositories sdr_ctrl

[/] [sdr_ctrl/] [trunk/] [rtl/] [core/] [sdrc_bs_convert.v] - Blame information for rev 16

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

Line No. Rev Author Line
1 3 dinesha
/*********************************************************************
2
 
3
  SDRAM Controller buswidth converter
4
 
5
  This file is part of the sdram controller project
6
  http://www.opencores.org/cores/sdr_ctrl/
7
 
8
  Description: SDRAM Controller Buswidth converter
9
 
10
  This module does write/read data transalation between
11
     application data to SDRAM bus width
12
 
13
  To Do:
14
    nothing
15
 
16
  Author(s):
17
      - Dinesh Annayya, dinesha@opencores.org
18
  Version  :  1.0  - 8th Jan 2012
19
 
20
 
21
 
22
 Copyright (C) 2000 Authors and OPENCORES.ORG
23
 
24
 This source file may be used and distributed without
25
 restriction provided that this copyright statement is not
26
 removed from the file and that any derivative work contains
27
 the original copyright notice and the associated disclaimer.
28
 
29
 This source file is free software; you can redistribute it
30
 and/or modify it under the terms of the GNU Lesser General
31
 Public License as published by the Free Software Foundation;
32
 either version 2.1 of the License, or (at your option) any
33
later version.
34
 
35
 This source is distributed in the hope that it will be
36
 useful, but WITHOUT ANY WARRANTY; without even the implied
37
 warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
38
 PURPOSE.  See the GNU Lesser General Public License for more
39
 details.
40
 
41
 You should have received a copy of the GNU Lesser General
42
 Public License along with this source; if not, download it
43
 from http://www.opencores.org/lgpl.shtml
44
 
45
*******************************************************************/
46
 
47
`include "sdrc.def"
48
module sdrc_bs_convert (
49
                    clk,
50
                    reset_n,
51
                    sdr_width,
52
 
53
                    app_req_addr,
54
                    app_req_addr_int,
55
                    app_req_len,
56
                    app_req_len_int,
57 4 dinesha
                    app_sdr_req,
58
                    app_sdr_req_int,
59 3 dinesha
                    app_req_dma_last,
60
                    app_req_dma_last_int,
61
                    app_req_wr_n,
62
                    app_req_ack,
63
                    app_req_ack_int,
64
 
65
                    app_wr_data,
66
                    app_wr_data_int,
67
                    app_wr_en_n,
68
                    app_wr_en_n_int,
69
                    app_wr_next_int,
70
                    app_wr_next,
71
 
72
                    app_rd_data_int,
73
                    app_rd_data,
74
                    app_rd_valid_int,
75
                    app_rd_valid
76
                );
77
parameter  APP_AW   = 30;  // Application Address Width
78
parameter  APP_DW   = 32;  // Application Data Width 
79
parameter  APP_BW   = 4;   // Application Byte Width
80
parameter  APP_RW   = 9;   // Application Request Width
81
 
82
parameter  SDR_DW   = 16;  // SDR Data Width 
83
parameter  SDR_BW   = 2;   // SDR Byte Width
84
 
85
input                    clk;
86
input                    reset_n ;
87 16 dinesha
input [1:0]             sdr_width           ; // 2'b00 - 32 Bit SDR, 2'b01 - 16 Bit SDR, 2'b1x - 8 Bit
88 3 dinesha
 
89
input [APP_AW-1:0]       app_req_addr;
90
output [APP_AW:0]        app_req_addr_int;
91
input  [APP_RW-1:0]      app_req_len ;
92
output [APP_RW-1:0]      app_req_len_int;
93
input                    app_req_wr_n;
94 4 dinesha
input                    app_sdr_req;
95
output                   app_sdr_req_int;
96 3 dinesha
input                    app_req_dma_last;
97
output                   app_req_dma_last_int;
98
input                    app_req_ack_int;
99
output                   app_req_ack;
100
 
101
input  [APP_DW-1:0]      app_wr_data;
102
output [SDR_DW-1:0]      app_wr_data_int;
103
input  [APP_BW-1:0]      app_wr_en_n;
104
output [SDR_BW-1:0]      app_wr_en_n_int;
105
input                    app_wr_next_int;
106
output                   app_wr_next;
107
 
108
input [SDR_DW-1:0]       app_rd_data_int;
109
output [APP_DW-1:0]      app_rd_data;
110
input                    app_rd_valid_int;
111
output                   app_rd_valid;
112
 
113
reg [APP_AW:0]           app_req_addr_int;
114
reg [APP_RW-1:0]         app_req_len_int;
115
 
116
reg                      app_req_dma_last_int;
117 4 dinesha
reg                      app_sdr_req_int;
118 3 dinesha
reg                      app_req_ack;
119
 
120
reg [APP_DW-1:0]         app_rd_data;
121
reg                      app_rd_valid;
122
reg [SDR_DW-1:0]         app_wr_data_int;
123
reg [SDR_BW-1:0]         app_wr_en_n_int;
124
reg                      app_wr_next;
125
 
126 16 dinesha
reg [23:0]               saved_rd_data;
127 3 dinesha
reg [7:0]                rd_xfr_count;
128
reg [7:0]                wr_xfr_count;
129
 
130
 
131
wire                  ok_to_req;
132
 
133 16 dinesha
assign ok_to_req = ((wr_xfr_count == 0) && (rd_xfr_count == 0));
134 3 dinesha
 
135
always @(*) begin
136 16 dinesha
        if(sdr_width == 2'b00) // 32 Bit SDR Mode
137 3 dinesha
          begin
138
            app_req_addr_int = {1'b0,app_req_addr};
139
            app_req_len_int = app_req_len;
140
            app_wr_data_int = app_wr_data;
141
            app_wr_en_n_int = app_wr_en_n;
142
            app_req_dma_last_int = app_req_dma_last;
143 4 dinesha
            app_sdr_req_int = app_sdr_req;
144 3 dinesha
            app_wr_next = app_wr_next_int;
145
            app_rd_data = app_rd_data_int;
146
            app_rd_valid = app_rd_valid_int;
147
            app_req_ack = app_req_ack_int;
148
          end
149 16 dinesha
        else if(sdr_width == 2'b01) // 16 Bit SDR Mode
150
        begin
151 3 dinesha
           // Changed the address and length to match the 16 bit SDR Mode
152
            app_req_addr_int = {app_req_addr,1'b0};
153
            app_req_len_int = {app_req_len,1'b0};
154
            app_req_dma_last_int = app_req_dma_last;
155 4 dinesha
            app_sdr_req_int = app_sdr_req && ok_to_req;
156 3 dinesha
            app_req_ack = app_req_ack_int;
157 16 dinesha
            app_wr_next = (app_wr_next_int & wr_xfr_count[0]);
158
            app_rd_valid = (rd_xfr_count & rd_xfr_count[0]);
159
            if(wr_xfr_count[0] == 1'b1)
160 3 dinesha
              begin
161
                app_wr_en_n_int = app_wr_en_n[3:2];
162
                app_wr_data_int = app_wr_data[31:16];
163
              end
164
            else
165
              begin
166
                app_wr_en_n_int = app_wr_en_n[1:0];
167
                app_wr_data_int = app_wr_data[15:0];
168
              end
169
 
170 16 dinesha
            app_rd_data = {app_rd_data_int,saved_rd_data[15:0]};
171
        end else  // 8 Bit SDR Mode
172
        begin
173
           // Changed the address and length to match the 16 bit SDR Mode
174
            app_req_addr_int = {app_req_addr,2'b0};
175
            app_req_len_int = {app_req_len,2'b0};
176
            app_req_dma_last_int = app_req_dma_last;
177
            app_sdr_req_int = app_sdr_req && ok_to_req;
178
            app_req_ack = app_req_ack_int;
179
            app_wr_next = (app_wr_next_int & (wr_xfr_count[1:0]== 2'b01));
180
            app_rd_valid = (rd_xfr_count &   (rd_xfr_count[1:0]== 2'b01));
181
            // Note: counter is down counter from 00 -> 11 -> 10 -> 01 --> 00
182
            if(wr_xfr_count[1:0] == 2'b01)
183 3 dinesha
            begin
184 16 dinesha
                app_wr_en_n_int = app_wr_en_n[3];
185
                app_wr_data_int = app_wr_data[31:24];
186 3 dinesha
            end
187 16 dinesha
            else if(wr_xfr_count[1:0] == 2'b10)
188 3 dinesha
            begin
189 16 dinesha
                app_wr_en_n_int = app_wr_en_n[2];
190
                app_wr_data_int = app_wr_data[23:16];
191 3 dinesha
            end
192 16 dinesha
            else if(wr_xfr_count[1:0] == 2'b11)
193 3 dinesha
            begin
194 16 dinesha
                app_wr_en_n_int = app_wr_en_n[1];
195
                app_wr_data_int = app_wr_data[15:8];
196 3 dinesha
            end
197 16 dinesha
            else begin
198
                app_wr_en_n_int = app_wr_en_n[0];
199
                app_wr_data_int = app_wr_data[7:0];
200
            end
201
 
202
            app_rd_data = {app_rd_data_int,saved_rd_data[23:0]};
203
          end
204
     end
205 3 dinesha
 
206
 
207
reg lcl_mc_req_wr_n;
208
 
209
always @(posedge clk)
210
  begin
211
    if(!reset_n)
212
      begin
213 16 dinesha
        rd_xfr_count    <= 8'b0;
214
        wr_xfr_count    <= 8'b0;
215 3 dinesha
        lcl_mc_req_wr_n <= 1'b1;
216 16 dinesha
        saved_rd_data   <= 24'h0;
217 3 dinesha
      end
218 16 dinesha
    else begin
219
        lcl_mc_req_wr_n <= app_req_wr_n;
220
 
221
        // During Write Phase
222
        if(app_req_ack && (app_req_wr_n == 0)) begin
223
           wr_xfr_count    <= app_req_len_int;
224 3 dinesha
        end
225 16 dinesha
        else if(app_wr_next_int & !lcl_mc_req_wr_n) begin
226 3 dinesha
           wr_xfr_count <= wr_xfr_count - 1'b1;
227
        end
228 16 dinesha
 
229
        // During Read Phase
230
        if(app_req_ack && app_req_wr_n) begin
231
           rd_xfr_count    <= app_req_len_int;
232
        end
233
        else if(app_rd_valid_int & lcl_mc_req_wr_n) begin
234
           rd_xfr_count   <= rd_xfr_count - 1'b1;
235
           if(sdr_width == 2'b01) // 16 Bit SDR Mode
236
              saved_rd_data[15:0]  <= app_rd_data_int;
237
            else begin// 8 bit SDR Mode - 
238
                      // Note: counter is down counter from 00 -> 11 -> 10 -> 01 --> 00
239
               if(rd_xfr_count[1:0] == 2'b00)      saved_rd_data[7:0]   <= app_rd_data_int[7:0];
240
               else if(rd_xfr_count[1:0] == 2'b11) saved_rd_data[15:8]  <= app_rd_data_int[7:0];
241
               else if(rd_xfr_count[1:0] == 2'b10) saved_rd_data[23:16] <= app_rd_data_int[7:0];
242
            end
243
        end
244
    end
245
end
246
 
247 3 dinesha
endmodule // sdr_bs_convert

powered by: WebSVN 2.1.0

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