【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验二十二：SDRAM模块⑤ — FIFO读写

 

经过漫长的战斗以后，我们终于来到最后。对于普通人而言，页读写就是一名战士的墓碑（最终战役） ... 然而，怕死的笔者想透过这个实验告诉读者，旅程的终点就是旅程的起点。一直以来，笔者都在烦恼“SDRAM是否应该成为储存类？”SDRAM作为一介储存资源（储存器），它的好处就是大容量空间，坏处则就是麻烦的控制规则，还有中规中矩的沟通速率。

相比之下，片上内存无论是控制的难度，还是沟通的速率，它都远远领先SDRAM。俗语常说，愈是强力的资源愈是珍贵 ... 对此，片上内容的容量可谓是稀罕的程度。实验二十二的要求非常单纯：

”请问如何建立基于SDRAM储存资源的FIFO存储模块呢？“，笔者问道。

图22.1 SDRAM基础模块。

图22.1是基于实验十八修改而成的SDRAM基础模块，修改对象除了SDRAM控制模块以外，SDRAM功能模块保持实验十八的状态，即单字读写。SDRAM控制模块，除了多出Tag以外，Addr的驱动也由该模块负责。具体的内容，让我们来看代码吧：

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.        output [23:0]oAddr,
10.        output [1:0]oTag
11.    );
12.        parameter WRITE = 4'd1, READ = 4'd4, REFRESH = 4'd7, INITIAL = 4'd8;
13.        parameter TREF = 11'd1040;
14.

以上内容为相关的出入端声明以及常量。其中多了24位宽的oAddr与2位宽的oTag。

15.         reg [1:0]C7;
16.         reg [1:0]isDo;
17.
18.         always @ ( posedge CLOCK or negedge RESET ) // sub
19.             if( !RESET )
20.                  begin
21.                         C7 <= 2'b10;
22.                         isDo <= 2'b00;
23.                    end
24.              else
25.                  begin
26.
27.                        if( iCall[1] & C7[1] ) isDo[1] <= 1'b1;
28.                        else if( iCall[0] & C7[0] ) isDo[0] <= 1'b1;
29.
30.                        if( isDo[1] & isDone[1] ) isDo[1] <= 1'b0;
31.                        else if( isDo[0] & isDone[0] ) isDo[0] <= 1'b0;
32.
33.                        if( isDone ) C7 <= {isDo[0],isDo[1]};
34.                        else if( iCall ) C7 <= { C7[0], C7[1] };
35.
36.                    end
37.

以上内容为轮流协调的周边操作。具体内容与实验十七一样。

38.        reg [3:0]i;
39.        reg [10:0]C1;
40.        reg [3:0]isCall; //[3]Write [2]Read [1]A.Refresh [0]Initial
41.        reg [1:0]isDone;
42.        reg [23:0]D1;
43.        reg [24:0]C2,C3;  // N + 1
44.
45.        always @ ( posedge CLOCK or negedge RESET ) // core
46.            if( !RESET )
47.                 begin
48.                         i <= INITIAL;          // Initial SDRam at first
49.                         C1 <= 11'd0;
50.                        isCall <= 4'b0000;
51.                        isDone <= 2'b00;
52.                        D1 <= 24'd0;
53.                        C2 <= 25'd0;
54.                        C3 <= 25'd0;
55.                  end

以上内容为相关的寄存器声明与复位操作。其中C2是写指针，C3是读指针，位宽为oAddr + 1。D用来驱动oAddr。

56.             else
57.                 case( i )
58.
59.                        0: // IDLE
60.                        if( C1 >= TREF ) begin C1 <= 11'd0;  i <= REFRESH; end
61.                        else if( isDo[1] ) begin C1 <= C1 + 1'b1; i <= WRITE; end
62.                        else if( isDo[0] ) begin C1 <= C1 + 1'b1; i <= READ; end
63.                         else begin C1 <= C1 + 1'b1; end
64.
65.                        /***********************/
66.

以上内容为部分核心内容。步骤0是待机状态，其中61~62行改为 isDo[1] 与 isDo[2]。

67.                        1: //Write
68.                        if( iDone ) begin isCall[3] <= 1'b0; C1 <= C1 + 1'b1; i <= i + 1'b1; end
69.                        else begin isCall[3] <= 1'b1; D1 <= C2[23:0]; C1 <= C1 + 1'b1; end
70.
71.                        2:
72.                        begin C2 <= C2 + 1'b1; isDone[1] <= 1'b1; C1 <= C1 + 1'b1; i <= i + 1'b1; end
73.
74.                        3:
75.                        begin isDone[1] <= 1'b0; C1 <= C1 + 1'b1; i <= 4'd0; end
76.
77.                        /***********************/
78.

以上内容为部分核心内容。步骤1~3是写操作，步骤1将C2[23:0]的内容赋值D。步骤2~3产生完成信号之余也递增C2.

79.                        4: // Read
80.                        if( iDone ) begin isCall[2] <= 1'b0; C1 <= C1 + 1'b1; i <= i + 1'b1; end
81.                        else begin isCall[2] <= 1'b1; D1 <= C3[23:0]; C1 <= C1 + 1'b1; end
82.
83.                        5:
84.                        begin C3 <= C3 + 1'b1; isDone[0] <= 1'b1; C1 <= C1 + 1'b1; i <= i + 1'b1; end
85.
86.                        6:
87.                        begin isDone[0] <= 1'b0; C1 <= C1 + 1'b1; i <= 4'd0; end
88.
89.                        /***********************/
90.

以上内容为部分核心内容。步骤4~6是写操作，步骤4将C3[23:0]的内容赋值D。步骤5~7产生完成信号之余也递增C3.

91.                        7: // Auto Refresh
92.                        if( iDone ) begin isCall[1] <= 1'b0; i <= 4'd0; end
93.                        else begin isCall[1] <= 1'b1; end
94.
95.                        /***********************/
96.
97.                        8: // Initial
98.                        if( iDone ) begin isCall[0] <= 1'b0; i <= 4'd0; end
99.                        else begin isCall[0] <= 1'b1; end
100.
101.                  endcase
102.

以上内容为部分核心内容。步骤7~8保持不变。

103.        assign oDone = isDone;
104.        assign oCall = isCall;
105.        assign oAddr = D1;
106.        assign oTag[1] = ( C2[24]^C3[24] & C2[23:0] == C3[23:0] );
107.         assign oTag[0] = ( C2 == C3 );
108.
109.    endmodule

以上内容为相关的输出驱动。D1驱动oAddr，第106~107行是写满状态与读空状态的声明。

sdram_funcmod.v

该功能模块与实验十八的内容一模一样。

sdram_demo.v

该组合模块的连线部署完全参照图22.1。

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.         output [1:0]oTag,
15.         input [15:0]iData,
16.         output [15:0]oData
17.    );
18.         wire [3:0]CallU1; // [3]Refresh, [2]Read, [1]Write, [0]Initial
19.         wire [23:0]AddrU2;
20.
21.        sdram_ctrlmod U1
22.         (
23.              .CLOCK( CLOCK ),
24.              .RESET( RESET ),
25.              .iCall( iCall ),       // < top ,[1]Write [0]Read
26.              .oDone( oDone ),     // > top ,[1]Write [0]Read
27.              .oAddr( AddrU2 ),    // > U2
28.              .oTag( oTag ),        // > top
29.              .oCall( CallU1 ),      // > U2
30.              .iDone( DoneU2 )           // < U2
31.         );
32.
33.         wire DoneU2;
34.
35.         sdram_funcmod U2
36.         (
37.              .CLOCK( CLOCK ),
38.              .RESET( RESET ),
39.              .S_CKE( S_CKE ),           // > top
40.              .S_NCS( S_NCS ),           // > top
41.              .S_NRAS( S_NRAS ),         // > top
42.              .S_NCAS( S_NCAS ),         // > top
43.              .S_NWE( S_NWE ),         // > top
44.              .S_BA( S_BA ),           // > top
45.              .S_A( S_A ),             // > top
46.              .S_DQM( S_DQM ),         // > top
47.              .S_DQ( S_DQ ),           // <> top
48.              .iCall( CallU1 ),            // < U1
49.              .oDone( DoneU2 ),          // > U1
50.              .iAddr( AddrU2 ),          // < U1
51.              .iData( iData ),               // < top
52.              .oData( oData )           // > top
53.         );
54.
55.    endmodule

连线内容请自己看着办吧。

sdram_demo.v

图22.3 实验二十二的建模图。

图22.3是实验二十二的建模图，左边的周边操作负责写入数据，右边的核心操作负责读取数据并且经由TXD发送出去。具体内容我们还是来看代码吧。

1.    module sdram_demo
2.    (
3.        input CLOCK,
4.        input RESET,
5.        output S_CLK,
6.        output S_CKE, S_NCS, S_NRAS, S_NCAS, S_NWE,
7.        output [12:0]S_A,
8.        output [1:0]S_BA,
9.        output [1:0]S_DQM,
10.        inout [15:0]S_DQ,
11.        output TXD
12.    );

以上内容为相关的出入端声明。

13.         wire CLOCK1,CLOCK2;
14.
15.         pll_module U1
16.         (
17.                 .inclk0 ( CLOCK ), // 50Mhz
18.                .c0 ( CLOCK1 ),  // 133Mhz -210 degree phase
19.                .c1 ( CLOCK2 )   // 133Mhz
20.         );
21.

以上内容为PLL模块的实例化。

22.         wire [1:0]DoneU2;
23.         wire [15:0]DataU2;
24.         wire [1:0]TagU2;
25.
26.         sdram_basemod U2
27.         (
28.             .CLOCK( CLOCK1 ),
29.             .RESET( RESET ),
30.              .S_CKE( S_CKE ),
31.              .S_NCS( S_NCS ),
32.              .S_NRAS( S_NRAS ),
33.              .S_NCAS( S_NCAS ),
34.              .S_NWE( S_NWE ),
35.              .S_A( S_A ),
36.              .S_BA( S_BA ),
37.              .S_DQM( S_DQM ),
38.              .S_DQ( S_DQ ),
39.              .iCall( {isWR,isRD} ),
40.              .oDone( DoneU2 ),
41.              .iData( D2 ),
42.              .oData( DataU2 ),
43.              .oTag( TagU2 )
44.         );

以上内容为SDRAM基础模块的实例化，注意第39行的iCall是由 isWR与isRD联合驱动。此外，第43行也多了oTag。

46.         reg [5:0]i;
47.         reg [15:0]D2;
48.         reg isWR;
49.
50.         always @ ( posedge CLOCK1 or negedge RESET )
51.             if( !RESET )
52.                 begin
53.                           i <= 6'd0;
54.                          D2 <= 16'hA000;
55.                          isWR <= 1'b0;
56.                 end
57.             else
58.                 case( i )
59.
60.                          0:
61.                         if( !TagU2[1] ) i <= i + 1'b1;
62.
63.                         1:
64.                         if( DoneU2[1] ) begin isWR <= 1'b0; i <= i + 1'b1; end
65.                         else begin isWR <= 1'b1; end
66.
67.                         2:
68.                         if( D2 == 16'hA1FF ) i <= i + 1'b1;
69.                         else begin D2[11:0] <= D2[11:0] +  1'b1; i <= 6'd0; end
70.
71.                         3:
72.                         i <= i;
73.
74.                endcase
75.

以上内容为写作用的周边操作。步骤0检测是否写满，步骤1写入数据，步骤2判断是否写满512次，不是的话就递增内容。步骤3是写完发呆。

76.         reg [5:0]j,Go;
77.         reg [10:0]C1;
78.         reg [15:0]D3;
79.         reg [10:0]T;
80.         reg isRD;
81.         reg rTXD;
82.
83.         parameter B115K2 = 11'd1157, TXFUNC = 6'd16;
84.
85.        always @ ( posedge CLOCK1 or negedge RESET )
86.             if( !RESET )
87.                 begin
88.                     j <= 6'd0;
89.                          Go <= 6'd0;
90.                          C1 <= 11'd0;
91.                          D3 <= 16'd0;
92.                          T <= 11'd0;
93.                          isRD <= 1'b0;
94.                          rTXD <= 1'b1;
95.                 end
96.             else
97.                 case( j )
98.
99.                         0:
100.                         if( !TagU2[0] ) j <= j + 1'b1;
101.
102.                         1:
103.                         if( DoneU2[0] ) begin D3 <= DataU2; isRD <= 1'b0; j <= j + 1'b1; end
104.                         else begin isRD <= 1'b1; end
105.
106.                         2:
107.                         begin T <= { 2'b11, D3[15:8], 1'b0 }; j <= TXFUNC; Go <= j + 1'b1; end
108.
109.                         3:
110.                         begin T <= { 2'b11, D3[7:0], 1'b0 }; j <= TXFUNC; Go <= j + 1'b1; end
111.
112.                         4:
113.                         if( D3 == 16'hA1FF ) j <= j + 1'b1;
114.                         else j <= 6'd0;
115.
116.                        5:
117.                         j <= j;
118.
119.                        /******************************/
120.

以上内容为部分核心操作。步骤0检测是否读空，步骤1读出数据，步骤2~3将数据发送数据，步骤4判断是否执行512次？如果不是的话就返回步骤0，是的话就递增i进入发呆的步骤5。

121.                          16,17,18,19,20,21,22,23,24,25,26:
122.                         if( C1 == B115K2 -1 ) begin C1 <= 11'd0; j <= j + 1'b1; end
123.                         else begin rTXD <= T[j - 16]; C1 <= C1 + 1'b1; end
124.
125.                         27:
126.                         j <= Go;
127.
128.                endcase
129.
130.         assign S_CLK = CLOCK2;
131.         assign TXD = rTXD;
132.
133.    endmodule

以上内容为核心操作以及输出驱动·。综合完毕便下载程序，如果串口调试软件出现 A000~A1FF，表示实验成功。

细节一：完整的个体模块

本实验的SDRAM基础模块已经准备就绪。

细节二：小谈储存类

FIFO机制的SDRAM很可能实用性不强。相对低级建模II而言，SDRAM已经脱离死板的印象，任何畸形的储存方式，都有可能实现在任何储存资源之上。举例而言，片上内存储存资源可以实现FIFO功能，IIC储存资源也可以实现FIFO功能，SDRAM储存资源也可以实现FIFO功能。

如果按照这条思路逆向思考的话，如果SDRAM储存资源可以实现功能C，那么IIC储存资源还有片上内存储存资源同样也可以实现功能C。如此一来，建模的自由度会大大增高，喜爱建模的孩子也会开心至极。如果读者是变态，那么一块小小的SDRAM储存资源实现多功能读写如：单字读写，多字读写，页读写，甚至FIFO读写，集于一身是有可能的。不管怎么样，实验二十二所要表达的信息已经非常清晰，即储存类的伸缩性与可塑性。