【黑金原創教程】【FPGA那些事兒-驅動篇I 】實驗十八：SDRAM模組① — 單字讀寫
實驗十八：SDRAM模組① — 單字讀寫
筆者與SDRAM有段不短的孽緣，它作為冤魂日夜不斷糾纏筆者。筆者嘗試過許多方法將其退散，不過屢試屢敗的筆者，最終心情像橘子一樣橙。《整合篇》之際，筆者曾經大戰幾回兒，不過內容都是點到即止。最近它破蠱而出，日夜不停：“好~痛苦！好~痛苦！”地呻吟著，嚇得筆者不敢半夜如廁。瘋狂之下，誓要歪它不可 ... 可惡的東西，筆者要它血債血還！
圖18.1 資料讀取（理想時序左，物理時序右）。
首先，讓我們來了解一下，什麼才是資料讀取的最佳狀態？如圖18.1所示，紅色箭頭是上升沿，綠色箭頭是鎖存沿。左圖是理想時序讀取資料的最佳狀態，即T0傳送資料，T1鎖存資料。右圖則是物理時序讀取資料的最佳狀態，即T0傳送資料，然後資料經由 TDATA延遲，然後T1鎖存資料。理想狀態下，讀取資料不用考慮任何物理因數，凡是過去值都會讀取成功。
圖18.2 讀取資料（物理時序）。
然而物理狀態下，讀取資料則必須考慮物理因數，但是物理時序也有所謂的理想狀態，即資料被TDATA推擠，然後恰好停留在鎖存沿的正中間。該狀態之所以稱為理想，那是因為建立時間TSETUP與保持時間THOLD都被滿足。
如圖18.2所示，TSETUP從資料中間向左邊覆蓋，THOLD從資料中間向右邊覆蓋，如果兩者不完全覆蓋資料，那麼資料的有效性就能得到保證。簡言之，資料是否讀取成功，建立時間還有保持時間都必須得到滿足。但是我們也知道，Verilog不能描述理想以外的東西，即Verilog無力描述TDATA。話雖如此，我們可以改變時鐘位移來達到同樣的效果。
圖18.3 CLOCK1位移 -180°（左圖），沒有位移（中圖），CLOCK2 位移 +180°（右圖），以及修正結果。
常見的理想時序，最多適用在FPGA的內部而已。當描述功活動涉及FPGA的外部，那麼理想時序必須考慮對外的情況。如圖18.3所示，中間的理想時序圖可以經由 CLOCK1 位移 -180°，又或者 CLOCK2 位移 +180° 來得到同樣的效果。雖說180° 的位移是理想效果，但是我們還要考慮物理路徑所帶來的影響。根據Alinix 301這隻開發板，我們必須追加 -30° 位移才能達到修正的效果。（注意：追加-30° 的修正時序僅僅為適用Alinix 301這隻板子而已）。理解完畢以後，我們便可進入正題。
驅動SDRAM而言，簡單可以分為以下四項操作：
（一）初始化
（二）重新整理操作
（三）讀操作
（四）寫操作
初始化令SDRAM就緒，重新整理操作就是不失掉內容（資料），讀操作就是從SDRAM哪裡讀取資料，寫操作就是向SDRAM寫資料。其中，讀寫操作又有單字讀寫，多字讀寫還有頁讀寫。
首先，讓我們來分析一下Alinx 開發板上HY57V2562GTR 這隻SDRAM。根據手冊，這隻SDRAM有256Mb的容量，4個BANK（即一個BANK為64Mb)，頻率極限為200Mhz，資料保留週期為 8192 / 64ms。至於引腳定義如表18.1所示：
表18.1 SDRAM的引腳定義
|
分類 |
標示 |
訊號 |
說明 |
|
時鐘訊號 |
CLK |
S_CLK |
時鐘源 |
|
地址訊號 |
BA0~1 |
S_BA[1:0] |
BANK地址 |
|
A0~A12 |
S_A[12:0] |
讀寫地址，行列共用，A0~A12為行地址，CA0~CA8為列地址 |
|
|
命令訊號 |
CKE |
S_CKE, |
時鐘選，拉高有效 |
|
CS |
S_NCS, |
片選，拉低有效 |
|
|
RAS |
S_NRAS, |
命令選，拉低有效 |
|
|
CAS |
S_NCAS, |
命令選，拉低有效 |
|
|
WE |
S_NWE |
命令選，拉低有效 |
|
|
資料訊號 |
DQ0~DQ15 |
S_DQ[15:0] |
讀寫資料的IO |
|
LDQM，UDQM |
S_DQM[1:0] |
遮蓋資料，一般拉低無視 |
如表18.1所示，CLK為SDRAM的時鐘源。CKE，CS，RAS，CAS還有WE皆為命令訊號，五者相互組合形成以下幾個常用命令，結果如表18.2所示：
表18.2 常用命令。
|
命令 |
CKE |
CS |
RAS |
CAS |
WE |
說明 |
|
NOP |
1 |
0 |
1 |
1 |
1 |
空命令 |
|
ACT |
1 |
0 |
0 |
1 |
1 |
啟用命令，選擇Bank地址與行地址 |
|
WR |
1 |
0 |
1 |
0 |
0 |
寫命令，開始寫資料 |
|
RD |
1 |
0 |
1 |
0 |
1 |
讀命令，開始讀資料 |
|
BSTP |
1 |
0 |
1 |
1 |
0 |
停止命令，停止讀寫 |
|
PR |
1 |
0 |
0 |
1 |
0 |
預充命令，釋放選擇 |
|
AR |
1 |
0 |
0 |
0 |
1 |
重新整理命令，重新整理內容 |
|
LMR |
1 |
0 |
0 |
0 |
0 |
設定命令，設定SDRAM |
l NOP為No Operation，即空命令，除了給空時間以外沒有任何意義。
l ACT為Active，即啟用命令，用來選擇某Bank某行。
l WR為Write，即寫命令，通知裝置開始寫資料。
l RD為Read，即讀命令，通知裝置開始讀資料。
l BSTP為Burst Stop，即停止命令，禁止裝置繼續讀寫。
l PR為 Precharge，即預充命令，用來釋放某Bank與某行的選擇。
l AR為Auto Refresh，即重新整理命令，用來重新整理或者更新資料內容。
l LMR為Load Mode Register，即設定命令，用來配置裝置引數。
Verilog則可以這樣描述這些命令，結果如程式碼18.1所示：
parameter _INIT = 5'b01111, _NOP = 5'b10111, _ACT = 5'b10011, _RD = 5'b10101, _WR = 5'b10100,
_BSTP = 5'b10110, _PR = 5'b10010, _AR = 5'b10001, _LMR = 5'b10000;
程式碼18.1
DQ0~DQ15為資料訊號。BA0~1與A0~A12皆為地址訊號，其中A0~A12行列共用，，然而地址訊號可以指向的範圍，如下計算：
2（2 Bank ＋ 13 Row ＋ 9 Column） × 16 bit = 224 × 16 bit
= 1.6777216e7 × 16 bit // 16M × 16 bit
= 2.68435456e8 bit
= 262144 kbit
= 256 Mbits
初始化：
初始化除了就緒SDRAM以外，我們還要設定SDRAM內部的 Mode Register，設定內容內容如表18.3所示：
表18.3 Mode Register的內容。
|
Mode Register |
||||||||||||
|
A12 |
A11 |
A10 |
A9 |
A8 |
A7 |
A6 |
A5 |
A4 |
A3 |
A2 |
A1 |
A0 |
|
0 |
0 |
OP Code |
0 |
0 |
CAS Latency |
BT |
Burst Length |
|
|
|||||||||||||||||||||||||||||||||||||
|
|
如表18.3所示，設定內容必須經由地址訊號A12~A0。其中A2~A0表示字讀寫的長度，實驗十八為單字讀寫，所以A2~A0設定為3’b000。A3表示讀寫次序，1’b0表示順序讀寫。A6~A4表示 CAS 延遲（也可以視為讀出延遲），設為 3’b011是為讀出更穩定。A9表示讀寫模式，一般都是設定為1’b0。
圖18.4 初始化的理想時序圖。
圖18.4是初始化的理想時序圖，其中CLOCK1為 -210°的系統時鐘，CLOCK2為SDRAM的時鐘。rCMD為CKE，CS，RAS，CAS還有WE等命令。rA為A0~A12，rBA為BA0~BA1等地址訊號。初始化過程如下所示：
l T0，滿足100us；
l T1，傳送PR命令，拉高所有rA與rBA。
l T1半週期，SDRAM讀取。
l T2，滿足TRP；
l T3，傳送AR命令。
l T3半週期，SDRAM讀取。
l T4，滿足TRRC，
l T5，傳送AR命令。
l T5半週期，SDRAM讀取。
l T6，滿足TRRC，
l T7，傳送LMR命令與相關Code（設定內容）。
l T7半週期，SDRAM讀取。
l T8，滿足TMRD。
怎麼樣？讀者是不是覺得很單純呢？事後，Verilog則可以這樣描述，結果如程式碼18.2所示：
1. case( i )
2.
3. 0: // delay 100us
4. if( C1 == T100US -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
5. else begin C1 <= C1 + 1'b1; end
6.
7. 1: // Send Precharge Command
8. begin rCMD <= _PR; { rBA, rA } <= 15'h3fff; i <= i + 1'b1; end
9.
10. 2: // wait TRP 20ns
11. if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
12. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
13.
14. 3: // Send Auto Refresh Command
15. begin rCMD <= _AR; i <= i + 1'b1; end
16.
17. 4: // wait TRRC 63ns
18. if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
19. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
20.
21. 5: // Send Auto Refresh Command
22. begin rCMD <= _AR; i <= i + 1'b1; end
23.
24. 6: // wait TRRC 63ns
25. if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
26. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
27.
28. 7: // Send LMR Cmd. Burst Read & Write, 3'b011 mean CAS latecy = 3, Sequential, 1 burst length
29. begin rCMD <= _LMR; rBA <= 2'b11; rA <= {3'd0,1'b0,2'd0,3'b011,1'b0, 3'b000}; i <= i + 1'b1; end
30.
31. 8: // Send 2 nop CLK for tMRD
32. if( C1 == TMRD -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
33. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
34.
35. 9: // Generate done signal
36. begin isDone <= 1'b1; i <= i + 1'b1; end
37.
38. 10:
39. begin isDone <= 1'b0; i <= 4'd0; end
40.
41. endcase
程式碼18.2
程式碼18.2完全按照圖18.4去驅動，讀者只要將i看為T就萬事大吉，其中步驟7傳送LMR命令還有設定Code內容。至於步驟8~9則用來產生完成訊號。
重新整理操作：
圖18.5 重新整理操作的理想時序圖。
所謂定期重新整理就是被宮掉的初始化，如圖18.5所示，時序過程如下：
l T0，傳送PR命令（拉高所有rA與rBA視喜好而定）；
l T0半週期，SDRAM讀取。
l T1，滿足TRP；
l T2，傳送AR命令。
l T2半週期，SDRAM讀取。
l T3，滿足TRRC，
l T4，傳送AR命令。
l T4半週期，SDRAM讀取。
l T5，滿足TRRC，
Verilog 則可以這樣表示，結果如表18.3所示：
1. case( i )
2.
3. 0: // Send Precharge Command
4. begin rCMD <= _PR; i <= i + 1'b1; end
5.
6. 1: // wait TRP 20ns
7. if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
8. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
9.
10. 2: // Send Auto Refresh Command
11. begin rCMD <= _AR; i <= i + 1'b1; end
12.
13. 3: // wait TRRC 63ns
14. if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
15. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
16.
17. 4: // Send Auto Refresh Command
18. begin rCMD <= _AR; i <= i + 1'b1; end
19.
20. 5: // wait TRRC 63ns
21. if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
22. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
23.
24. 6: // Generate done signal
25. begin isDone <= 1'b1; i <= i + 1'b1; end
26.
27. 7:
28. begin isDone <= 1'b0; i <= 4'd0; end
29.
30. endcase
程式碼18.3
除了步驟6~7用來產生完成訊號以外，程式碼18.3都是據圖18.5描述。SDRAM儲存的內容是非常脆弱的，如果我們不定期重新整理內容，該內容有可能會蒸發掉。根據 HY57V2562GTR這隻 SDRAM，它的內容儲存週期為 8192 / 64ms，然而定期重新整理的計算如下：
64ms / 8192 = 7.8125us
換言之，每隔7.8125微妙就要重新整理一次所有內容。
寫操作：
圖18.6 寫操作的理想時序圖。
圖18.6是寫操作的理想時序圖，過程如下：
l T1，傳送ACT命令，BANK地址與行地址；
l T1半週期，SDRAM讀取；
l T2，滿足TRCD；
l T3，傳送WR命令，BANK地址與列地址，還有寫資料；
l T3半週期，SDRAM讀取
l T4，滿足TWR；
l T5，滿足TRP。
正如前面說過，ACT命令式用來選擇BANK地址與行地址，然而關鍵就在T3。T3除了傳送WR命令，列地址，還有些資料以外，A10拉高是為了執行預充電。所謂預充電就是釋放BANK地址，行地址與列地址等的選擇。因此，滿足TWR以後，我們還要滿足TRP的釋放時間，好讓SDRAM有足夠的時間自行釋放選擇。
Verilog則可以這樣描述，結果如程式碼18.4所示：
1. case( i )
2.
3. 0: // Set IO to output State
4. begin isOut <= 1'b1; i <= i + 1'b1; end
5.
6. 1: // Send Active Command with Bank and Row address
7. begin rCMD <= _ACT; rBA <= iAddr[23:22]; rA <= iAddr[21:9]; i <= i + 1'b1; end
8.
9. 2: // wait TRCD 20ns
10. if( C1 == TRCD -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
11. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
12.
13. 3: // Send Write cmd with row address, pull up A10 1 clk to PR
14. begin rCMD <= _WR; rBA <= iAddr[23:22]; rA <= { 4'b0010, iAddr[8:0] }; i <= i + 1'b1; end
15.
16. 4: // wait TWR 2 clock
17. if( C1 == TWR -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
18. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
19.
20. 5: // wait TRP 20ns
21. if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
22. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
23.
24. 6: // Generate done signal
25. begin isDone <= 1'b1; i <= i + 1'b1; end
26.
27. 7:
28. begin isDone <= 1'b0; i <= 4'd0; end
29.
30. endcase
程式碼18.4
根據前面的計算，BA1~BA0再加上 RA12~A0與 CA8~A0以後，一共有24位寬，詳細的位分配如表18.4所示：
表18.4 Addr的位分配。
|
位分配 |
地址內容 |
|
Addr[23:22] |
BANK地址 |
|
Addr[21：9] |
行地址 |
|
Addr[8:0] |
列地址 |
如程式碼18.4所示，步驟用來設定IO口為輸出。步驟1為rA賦值行地址，步驟3則為rA賦值列地址，並且拉高A10以示自行預充電。步驟6~7用來產生完成訊號。
讀操作：
圖18.7 讀操作的理想時序。
圖18.7為讀操作的理想時序，大致過程如下：
l T1，傳送ACT命令，BANK地址與行地址；
l T1半週期，SDRAM讀取；
l T2，滿足TRCD；
l T3，傳送RD命令，BANK地址與列地址；
l T3半週期，SDRAM讀取命令。
l T4，滿足 CAS Latency。
l T5，讀取資料。
l T6，滿足TRP。
讀操作與寫操作的過程大同小異，除了WR命令變成RD命令以外，A10為1同樣表示自行預充電，餘下就是滿足CAS Latency。好奇的同學一定會覺得疑惑，為何CL 為3呢？其實沒什麼，只是直感上覺得3這個數字比較順眼一點。注意CL的計算方式是讀取RD命令以後開始計算。
Verilog可以這樣描述，結果如程式碼18.5所示：
1. case( i )
2.
3. 0:
4. begin isOut <= 1'b0; D1 <= 16'd0; i <= i + 1'b1; end
5.
6. 1: // Send Active command with Bank and Row address
7. begin rCMD <= _ACT; rBA <= iAddr[23:22]; rA <= iAddr[21:9]; i <= i + 1'b1; end
8.
9. 2: // wait TRCD 20ns
10. if( C1 == TRCD -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
11. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
12.
13. 3: // Send Read command and column address, pull up A10 to PR.
14. begin rCMD <= _RD; rBA <= iAddr[23:22]; rA <= { 4'b0010, iAddr[8:0]}; i <= i + 1'b1; end
15.
16. 4: // wait CL 3 clock
17. if( C1 == CL -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
18. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
19.
20. 5: // Read Data
21. begin D1 <= S_DQ; i <= i + 1'b1; end
22.
23. 6: // wait TRP 20ns
24. if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
25. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
26.
27. 7: // Generate done signal
28. begin isDone <= 1'b1; i <= i + 1'b1; end
29.
30. 8:
31. begin isDone <= 1'b0; i <= 4'd0; end
32.
33. endcase
程式碼18.5
程式碼18.5完全根據圖18.7描述，除了步驟7~8用於產生完成訊號以外。SDRAM的基本操作大致上就是這樣而已，完後我們便可以開始建模了。
圖18.8 SDRAM基礎模組的建模圖。
圖18.8是SDRAM基礎模組的建模圖，SDRAM基礎模組的內容包括SDRAM控制模組，還有SDRAM功能模組。外圍的PLL模組應用頻率為133Mhz向左位移210°的CLOCK1，還有133Mhz的CLOCK2。CLOCK1用作系統時鐘，CLOCK用作SDRAM時鐘。如果PLL模組硬要分類的話，它應該屬於特殊性質的即時類吧！？
SDRAM控制模組主要負責一些操作的排程，左邊2位Call/Done由外部呼叫，其中 [1]為寫操作 [0]為讀操作；右邊4位Call/Done為呼叫SDRAM功能模組，其中 [3]為寫操作 [2]為讀操作 [1]為重新整理 [0]為初始化。SDRAM功能模組的右邊是驅動SDRAM硬體資源的頂層訊號，左邊的問答訊號被控制模組呼叫以外，地址訊號還有資料訊號都直接連線外部。
sdram_funcmod.v
圖18.9 SDRAM功能模組的建模圖。
該說的東西筆者都已經說了，具體內容我們還是來看程式碼吧。
1. module sdram_funcmod
2. (
3. input CLOCK,
4. input RESET,
5.
6. output S_CKE, S_NCS, S_NRAS, S_NCAS, S_NWE,
7. output [1:0]S_BA,
8. output [12:0]S_A,
9. output [1:0]S_DQM,
10. inout [15:0]S_DQ,
11.
12. input [3:0]iCall,
13. output oDone,
14. input [23:0]iAddr, // [23:22]BA,[21:9]Row,[8:0]Column
15. input [15:0]iData,
16. output [15:0]oData
17. );
以上內容為相關的出入端宣告。
18. parameter T100US = 14'd13300;
19. // tRP 20ns, tRRC 63ns, tRCD 20ns, tMRD 2CLK, tWR/tDPL 2CLK, CAS Latency 3CLK
20. parameter TRP = 14'd3, TRRC = 14'd9, TMRD = 14'd2, TRCD = 14'd3, TWR = 14'd2, CL = 14'd3;
21. parameter _INIT = 5'b01111, _NOP = 5'b10111, _ACT = 5'b10011, _RD = 5'b10101, _WR = 5'b10100,
22. _BSTP = 5'b10110, _PR = 5'b10010, _AR = 5'b10001, _LMR = 5'b10000;
23.
以上內容為相關的常量宣告，其中第18~20行的是將常量都是經由133Mhz量化。
24. reg [4:0]i;
25. reg [13:0]C1;
26. reg [15:0]D1;
27. reg [4:0]rCMD;
28. reg [1:0]rBA;
29. reg [12:0]rA;
30. reg [1:0]rDQM;
31. reg isOut;
32. reg isDone;
33.
34. always @ ( posedge CLOCK or negedge RESET )
35. if( !RESET )
36. begin
37. i <= 4'd0;
38. C1 <= 14'd0;
39. D1 <= 16'd0;
40. rCMD <= _NOP;
41. rBA <= 2'b11;
42. rA <= 13'h1fff;
43. rDQM <= 2'b00;
44. isOut <= 1'b1;
45. isDone <= 1'b0;
46. end
以上內容為相關的暫存器宣告以及復位操作。
47. else if( iCall[3] )
48. case( i )
49.
50. 0: // Set IO to output State
51. begin isOut <= 1'b1; i <= i + 1'b1; end
52.
53. 1: // Send Active Command with Bank and Row address
54. begin rCMD <= _ACT; rBA <= iAddr[23:22]; rA <= iAddr[21:9]; i <= i + 1'b1; end
55.
56. 2: // wait TRCD 20ns
57. if( C1 == TRCD -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
58. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
59.
60. /*********************************************/
61.
62. 3: // Send Write command with row address, pull up A10 1 clk to PR
63. begin rCMD <= _WR; rBA <= iAddr[23:22]; rA <= { 4'b0010, iAddr[8:0] }; i <= i + 1'b1; end
64.
65. 4: // wait TWR 2 clock
66. if( C1 == TWR -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
67. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
68.
69. 5: // wait TRP 20ns
70. if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
71. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
72.
73. /**********************************************/
74.
75. 6: // Generate done signal
76. begin isDone <= 1'b1; i <= i + 1'b1; end
77.
78. 7:
79. begin isDone <= 1'b0; i <= 4'd0; end
80.
81. endcase
以上內容為部分核心操作。第47行的if( iCall[3] ) 表示餘下內容為寫操作。
82. else if( iCall[2] )
83. case( i )
84.
85. 0:
86. begin isOut <= 1'b0; D1 <= 16'd0; i <= i + 1'b1; end
87.
88. 1: // Send Active command with Bank and Row address
89. begin rCMD <= _ACT; rBA <= iAddr[23:22]; rA <= iAddr[21:9]; i <= i + 1'b1; end
90.
91. 2: // wait TRCD 20ns
92. if( C1 == TRCD -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
93. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
94.
95. /********************/
96.
97. 3: // Send Read command and column address, pull up A10 to PR
98. begin rCMD <= _RD; rBA <= iAddr[23:22]; rA <= { 4'b0010, iAddr[8:0]}; i <= i + 1'b1; end
99.
100. 4: // wait CL 3 clock
101. if( C1 == CL -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
102. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
103.
104. /********************/
105.
106. 5: // Read Data
107. begin D1 <= S_DQ; i <= i + 1'b1; end
108.
109. /********************/
110.
111. 6: // wait TRP 20ns
112. if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
113. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
114.
115. /********************/
116.
117. 7: // Generate done signal
118. begin isDone <= 1'b1; i <= i + 1'b1; end
119.
120. 8:
121. begin isDone <= 1'b0; i <= 4'd0; end
122.
123. endcase
以上內容為部分核心操作。第82行的if( iCall[2] ) 表示餘下內容為讀操作。
124. else if( iCall[1] )
125. case( i )
126.
127. 0: // Send Precharge Command
128. begin rCMD <= _PR; i <= i + 1'b1; end
129.
130. 1: // wait TRP 20ns
131. if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
132. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
133.
134. 2: // Send Auto Refresh Command
135. begin rCMD <= _AR; i <= i + 1'b1; end
136.
137. 3: // wait TRRC 63ns
138. if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
139. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
140.
141. 4: // Send Auto Refresh Command
142. begin rCMD <= _AR; i <= i + 1'b1; end
143.
144. 5: // wait TRRC 63ns
145. if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
146. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
147.
148. /********************/
149.
150. 6: // Generate done signal
151. begin isDone <= 1'b1; i <= i + 1'b1; end
152.
153. 7:
154. begin isDone <= 1'b0; i <= 4'd0; end
155.
156. endcase
以上內容為部分核心操作。第124行的if( iCall[1] ) 表示餘下內容為重新整理操作。
157. else if( iCall[0] )
158. case( i )
159.
160. 0: // delay 100us
161. if( C1 == T100US -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
162. else begin C1 <= C1 + 1'b1; end
163.
164. /********************/
165.
166. 1: // Send Precharge Command
167. begin rCMD <= _PR; { rBA, rA } <= 15'h3fff; i <= i + 1'b1; end
168.
169. 2: // wait TRP 20ns
170. if( C1 == TRP -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
171. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
172.
173. 3: // Send Auto Refresh Command
174. begin rCMD <= _AR; i <= i + 1'b1; end
175.
176. 4: // wait TRRC 63ns
177. if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
178. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
179.
180. 5: // Send Auto Refresh Command
181. begin rCMD <= _AR; i <= i + 1'b1; end
182.
183. 6: // wait TRRC 63ns
184. if( C1 == TRRC -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
185. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
186.
187. /********************/
188.
189. 7: // Send LMR Cmd. Burst Read & Write, 3'b010 mean CAS latecy = 3, Sequential, 1 burst length
190. begin rCMD <= _LMR; rBA <= 2'b11; rA <= { 3'd0, 1'b0, 2'd0, 3'b011, 1'b0, 3'b000 }; i <= i + 1'b1; end
191.
192. 8: // Send 2 nop CLK for tMRD
193. if( C1 == TMRD -1 ) begin C1 <= 14'd0; i <= i + 1'b1; end
194. else begin rCMD <= _NOP; C1 <= C1 + 1'b1; end
195.
196. /********************/
197.
198. 9: // Generate done signal
199. begin isDone <= 1'b1; i <= i + 1'b1; end
200.
201. 10:
202. begin isDone <= 1'b0; i <= 4'd0; end
203.
204. endcase
205.
以上內容為部分核心操作。第157行的if( iCall[0] ) 表示餘下內容為初始化。
206. assign { S_CKE, S_NCS, S_NRAS, S_NCAS, S_NWE } = rCMD;
207. assign { S_BA, S_A } = { rBA, rA };
208. assign S_DQM = rDQM;
209. assign S_DQ = isOut ? iData : 16'hzzzz;
210. assign oDone = isDone;
211. assign oData = D1;
212.
213. endmodule
以上內容為相關的輸出驅動宣告，注意 iData直接驅動 S_DQ。
sdram_ctrlmod.v
圖18.10 SDRAM控制模組的建模圖。
前面說過該模組負責一些功能呼叫，此外該模組也負責定時重新整理的計算，具體內容我們還是來看程式碼吧。
1. module sdram_ctrlmod
2. (
3. input CLOCK,
4. input RESET,
5. input [1:0]iCall, // [1]Write, [0]Read
6. output [1:0]oDone,
7. output [3:0]oCall,
8. input iDone
9. );
10. parameter WRITE = 4'd1, READ = 4'd4, REFRESH = 4'd7, INITIAL = 4'd8;
11. parameter TREF = 11'd1040;
12.
以上內容為相關的出入端宣告。第10行是各個入口地址的常量宣告，第11行則是定時重新整理的週期——7.8125us。
13. reg [3:0]i;
14. reg [10:0]C1;
15. reg [3:0]isCall; //[3]Write [2]Read [1]A.Refresh [0]Initial
16. reg [1:0]isDone;
17.
18. always @ ( posedge CLOCK or negedge RESET )
19. if( !RESET )
20. begin
21. i <= INITIAL; // Initial SDRam at first
22. C1 <= 11'd0;
23. isCall <= 4'b0000;
24. isDone <= 2'b00;
25. end
以上內容為相關的暫存器宣告以及復位操作。第21行表示i首先會指向初始化。
26. else
27. case( i )
28.
29. 0: // IDLE
30. if( C1 >= TREF ) begin C1 <= 11'd0; i <= REFRESH; end
31. else if( iCall[1] ) begin C1 <= C1 + 1'b1; i <= WRITE; end
32. else if( iCall[0] ) begin C1 <= C1 + 1'b1; i <= READ; end
33. else begin C1 <= C1 + 1'b1; end
34.
35. /***********************/
36.
以上內容為部分核心操作。步驟0為待機狀態，期間第33行的C1會一直遞增，如果期間沒有任何讀寫操作，而且C1的計數內容也超過 TREF，那麼C1會清零，i指向REFRESH（第30行）。反之，如果讀寫操作被使能，i指向相關的步驟入口，期間C1也會遞增以示步驟翻轉所用掉的時鐘。
37. 1: //Write
38. if( iDone ) begin isCall[3] <= 1'b0; C1 <= C1 + 1'b1; i <= i + 1'b1; end
39. else begin isCall[3] <= 1'b1; C1 <= C1 + 1'b1; end
40.
41. 2:
42. begin isDone[1] <= 1'b1; C1 <= C1 + 1'b1; i <= i + 1'b1; end
43.
44. 3:
45. begin isDone[1] <= 1'b0; C1 <= C1 + 1'b1; i <= 4’d0; end
46.
47. /***********************/
48.
以上內容為部分核心操作。步驟1~3是寫操作。步驟1表示，功能模組反饋完成訊號之前，C1會不停遞增。當完成訊號接收到手，isCall[3]拉低，C1遞增，i也遞增。步驟2~3則是用來反饋寫操作的完成訊號，期間C1也會遞增。
49. 4: // Read
50. if( iDone ) begin isCall[2] <= 1'b0; C1 <= C1 + 1'b1; i <= i + 1'b1; end
51. else begin isCall[2] <= 1'b1; C1 <= C1 + 1'b1; end
52.
53. 5:
54. begin isDone[0] <= 1'b1; C1 <= C1 + 1'b1; i <= i + 1'b1; end
55.
56. 6:
57. begin isDone[0] <= 1'b0; C1 <= C1 + 1'b1; i <= 4'd0; end
58.
59. /***********************/
60.
以上內容為部分核心操作。步驟4~6是讀操作。步驟4表示接收完成訊號之前，isCall[2]會不停拉高，C1也會不停遞增 ... 直至接收完成訊號，isCall[2]才會拉低，然而C1也會遞增。步驟5~6用反饋讀操作的完成訊號。
61. 7: // Auto Refresh
62. if( iDone ) begin isCall[1] <= 1'b0; i <= 4'd0; end
63. else begin isCall[1] <= 1'b1; end
64.
65. /***********************/
66.
以上內容為部分核心操作。步驟7是重新整理操作，接收完成訊號之前 isCall[1] 會不停拉高，直至接收完成訊號為止，isCall[1]才會拉低，然後i指向步驟0。
67. 8: // Initial
68. if( iDone ) begin isCall[0] <= 1'b0; i <= 4'd0; end
69. else begin isCall[0] <= 1'b1; end
70.
71. endcase
72.
73. assign oDone = isDone;
74. assign oCall = isCall;
75.
76. endmodule
以上內容為部分核心操作。步驟8用來執行初始化，接收完成訊號之前，isCall[0]會不停拉高，直至接收完成訊號為止，isCall[0]才會拉低，然後i指向步驟0。第73~74行則是相關的輸出驅動。整體而言，除了讀寫操作必須反饋完成訊號給上層以外，其餘的定期重新整理還有初始化都是該內部操作，所以不用反饋完成訊號。
sdram_basemod.v
內容的連線部署完全依照圖18.8。
1. module sdram_basemod
2. (
3. input CLOCK,
4. input RESET,
5.
6. output S_CKE, S_NCS, S_NRAS, S_NCAS, S_NWE,
7. output [1:0]S_BA,
8. output [12:0]S_A,
9. output [1:0]S_DQM,
10. inout [15:0]S_DQ,
11.
12. input [1:0]iCall,
13. output [1:0]oDone,
14. input [23:0]iAddr,
15. input [15:0]iData,
16. output [15:0]oData
17. );
以上內容為相關的出入端宣告，第5~10行是頂層訊號，第12~16行是模組左右兩邊的訊號。
18. wire [3:0]CallU1; // [3]Refresh, [2]Read, [1]Write, [0]Initial
19.
20. sdram_ctrlmod U1
21. (
22. .CLOCK( CLOCK ),
23. .RESET( RESET ),
24. .iCall( iCall ), // < top ,[1]Write [0]Read
25. .oDone( oDone ), // > top ,[1]Write [0]Read
26. .oCall( CallU1 ), // > U2
27. .iDone( DoneU2 ) // < U2
28. );
29.
以上內容為控制模組的例項化。
30. wire DoneU2;
31.
32. sdram_funcmod U