Subversion Repositories pentevo

Rev

Rev 255 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed | ?url?

  1. /*
  2.   read sequence
  3.  
  4. clk   ``\____/````\____/` ..... _/````\____/````\____/` ..... _/````\____/````\____/`
  5.              |         |         |         |         |         |         |
  6. start XXXX```````````\__ ....... ____________________________________________________
  7.              |         |         |         |         |         |         |
  8. rnw   XXXXXX```XXXXXXXXX ....... XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  9.              |         | some    |         |         |         |         |
  10. ready XXXXXXX\__________ clocks __/``````````````````  ....... ```````````\__________
  11.                          before                                |         |
  12. rdat  ------------------ ready  -< cell 0  | cell 1  | ....... |last cell>-----------
  13.              |         |         |         |         |         |         |
  14. stop  XXXXXXX\__________ ....... _____________________ ....... ___________/``````````
  15.                                                                             ^all operations stopped until next start strobe
  16.  
  17.  
  18.  
  19.   write sequence
  20.  
  21. clk   ``\____/````\____/` ..... _/````\____/````\____/````\____/````\____/````\____/````\____/````\____/
  22.              |         | some    |         | some    |         |         |         |         |         |
  23. start XXXX```````````\__ ....... _____________ .... ______________ .... ________________________________
  24.              |         | clocks  |         | clocks  |         |         |         |         |         |
  25. rnw   XXXXXX___XXXXXXXXX ....... XXXXXXXXXXXXX .... XXXXXXXXXXXXXX .... XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  26.              |         | before  |         | before  |         |         |         |         |         |
  27. ready XXXXXXX\__________ ....... _/`````````\_ .... __/`````````\_ .... __/`````````\___________________
  28.              |         | first   |         | next    |         |         |         |         |         |
  29. wdat  XXXXXXXXXXXXXXXXXXXXXXXXXXXX< cell 0  >X .... XX< cell 1  >X .... XX<last cell>XXXXXXXXXXXXXXXXXXX
  30.              |         | ready   |         | ready   |         |         |         |         |         |
  31. stop  XXXXXXX\__________ ....... _____________ .... ______________ .... ____________/```````````````````
  32.              |         | strobe  |         | strobe  |         |         |         |         |         |
  33.  
  34.  
  35.  
  36.  
  37. clk   ``\____/````\____/````\____/````\____/````\____/````\____/````\____/````\____/````\____/````\____/````\____/````\____/``
  38.              |         |         |         |         |         |         |         |         |         |         |         |
  39. ready __________________/`````````\___________________/`````````\___________________/`````````\___________________/`````````\_
  40.              |         |         |         |         |         |         |         |         |         |         |         |
  41. wdat           cell 0             | cell 1                      | cell 2                      | cell 3                      |
  42.              |         |         |         |         |         |         |         |         |         |         |         |
  43. sram_adr XXXXXXXXXXXXXXXXXXXXXXXXX| 0                           | 1                           | 2                           |
  44.              |         |         |         |         |         |         |         |         |         |         |         |
  45. sram_dat XXXXXXXXXXXXXXXXXXXXXXXXX| cell 0                      | cell 1                      | cell 2                      |
  46.              |         |         |         |         |         |         |         |         |         |         |         |
  47. sram_we_n```````````````````````````````````\_________/```````````````````\_________/```````````````````\_________/``````````
  48.              | BEG     | PRE1    | PRE2    |         |         |         |         |         |         |         |         |
  49.              |         |         | CYC1    | CYC2    | CYC3    | CYC1    | CYC2    | CYC3    | CYC1    | CYC2    | CYC3    |
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56. */
  57.  
  58.  
  59. module dram_control(
  60.  
  61.         clk,
  62.  
  63.         start, // initializing input, address=0
  64.  
  65.         stop, // when all addresses are done, nothing will happen after stop is set, need another start signal
  66.  
  67.         rnw, // 1 - read, 0 - write sequence (latched when start=1)
  68.  
  69.         ready, // strobe. when writing, one mean that data from wdat written to the memory (2^SRAM_ADDR_SIZE strobes total)
  70.                // when reading, one mean that data read from memory is on rdat output (2^SRAM_ADDR_SIZE strobes total)
  71.  
  72.  
  73.         wdat, // input, data to be written to memory
  74.         rdat, // output, data last read from memory
  75.  
  76.  
  77.  
  78.         DRAM_DQ,
  79.  
  80.         DRAM_MA,
  81.  
  82.         DRAM_RAS0_N,
  83.         DRAM_RAS1_N,
  84.         DRAM_LCAS_N,
  85.         DRAM_UCAS_N,
  86.         DRAM_WE_N
  87. );
  88.  
  89. localparam DRAM_DATA_SIZE = 16;
  90. localparam DRAM_MA_SIZE = 10;
  91.  
  92. localparam DRAM_ADDR_SIZE = 21;//21;
  93.  
  94.  
  95.         input clk;
  96.  
  97.         input start,rnw;
  98.  
  99.         output stop;
  100.         reg    stop;
  101.  
  102.         output ready;
  103.         reg    ready;
  104.  
  105.         input [DRAM_DATA_SIZE-1:0] wdat;
  106.         output [DRAM_DATA_SIZE-1:0] rdat;
  107.  
  108.  
  109.         inout [DRAM_DATA_SIZE-1:0] DRAM_DQ;
  110.         output [DRAM_MA_SIZE-1:0] DRAM_MA;
  111.         output DRAM_RAS0_N,DRAM_RAS1_N,DRAM_LCAS_N,DRAM_UCAS_N,DRAM_WE_N;
  112.  
  113.  
  114.         reg  [DRAM_ADDR_SIZE:0] dram_addr_pre; // one bit bigger to have stop flag
  115.         reg  [DRAM_ADDR_SIZE:0] dram_addr_out;
  116.         wire [DRAM_ADDR_SIZE:0] dram_addr_nxt;
  117.  
  118.         assign dram_addr_nxt = dram_addr_pre + 1;
  119.         always @(posedge clk) dram_addr_out <= dram_addr_pre;
  120.  
  121.  
  122.  
  123.         reg dram_req,dram_rnw;
  124.         wire dram_cbeg,dram_rrdy;
  125.  
  126.         dram dramko( .clk(clk), .rst_n(1'b1), .ra(DRAM_MA), .rd(DRAM_DQ),
  127.                      .rwe_n(DRAM_WE_N), .rucas_n(DRAM_UCAS_N), .rlcas_n(DRAM_LCAS_N),
  128.                      .rras0_n(DRAM_RAS0_N), .rras1_n(DRAM_RAS1_N), .addr(dram_addr_out[DRAM_ADDR_SIZE-1:0]),
  129.                      .rddata(rdat), .wrdata(wdat), .bsel(2'b11), .req(dram_req), .rnw(dram_rnw),
  130.                      .cbeg(dram_cbeg), .rrdy(dram_rrdy) );
  131.  
  132.  
  133.  
  134.  
  135.         reg [1:0] dram_ready_gen; // 0x - no ready strobes, 10 - strobes on rrdy (read), 11 - on cbeg (write)
  136.         localparam NO_READY = 2'b00;
  137.         localparam RD_READY = 2'b10;
  138.         localparam WR_READY = 2'b11;
  139.  
  140.         always @*
  141.         begin
  142.                 if( !dram_ready_gen[1] )
  143.                 begin
  144.                         ready = 1'b0;
  145.                 end
  146.                 else
  147.                 begin
  148.                         if( dram_ready_gen[0] ) //write
  149.                         begin
  150.                                 ready = dram_cbeg;
  151.                         end
  152.                         else // read
  153.                         begin
  154.                                 ready = dram_rrdy;
  155.                         end
  156.                 end
  157.         end
  158.  
  159.  
  160.  
  161.         reg [3:0] curr_state,next_state;
  162.  
  163.         parameter START_STATE = 4'd00; // reset state
  164.         parameter INIT_STATE  = 4'd01; // initialization state
  165.  
  166.         parameter READ_BEG1 = 4'd02;
  167.         parameter READ_BEG2 = 4'd03;
  168.         parameter READ_CYC  = 4'd04;
  169.         parameter READ_END1 = 4'd05;
  170.         parameter READ_END2 = 4'd06;
  171.  
  172.         parameter WRITE_BEG = 4'd07;
  173.         parameter WRITE_CYC = 4'd08;
  174.         parameter WRITE_END = 4'd09;
  175.  
  176.  
  177.         parameter STOP_STATE  = 4'd10; // full stop state
  178.  
  179.  
  180.  
  181.         // FSM states
  182.         always @*
  183.         begin
  184.                 case( curr_state )
  185.  
  186. ////////////////////////////////////////////////////////////////////////
  187.                 START_STATE:
  188.                         next_state = INIT_STATE;
  189.  
  190.  
  191. ////////////////////////////////////////////////////////////////////////
  192.                 INIT_STATE:
  193.                 begin
  194.                         if( rnw ) // read
  195.                                 next_state = READ_BEG1;
  196.                         else // !rnw - write
  197.                                 next_state = WRITE_BEG;
  198.                 end
  199.  
  200.  
  201.  
  202.  
  203. ////////////////////////////////////////////////////////////////////////
  204.                 READ_BEG1:
  205.                         next_state = READ_BEG2;
  206.  
  207.                 READ_BEG2:
  208.                         next_state = READ_CYC;
  209.  
  210.                 READ_CYC:
  211.                         if( !dram_addr_nxt[DRAM_ADDR_SIZE] )
  212.                                 next_state = READ_CYC;
  213.                         else
  214.                                 next_state = READ_END1;
  215.  
  216.                 READ_END1:
  217.                         next_state = READ_END2;
  218.  
  219.                 READ_END2:
  220.                         next_state = STOP_STATE;
  221.  
  222.  
  223.  
  224. ////////////////////////////////////////////////////////////////////////
  225.                 WRITE_BEG:
  226.                         next_state = WRITE_CYC;
  227.  
  228.                 WRITE_CYC:
  229.                         if( !dram_addr_nxt[DRAM_ADDR_SIZE] )
  230.                                 next_state = WRITE_CYC;
  231.                         else
  232.                                 next_state = WRITE_END;
  233.  
  234.                 WRITE_END:
  235.                         next_state = STOP_STATE;
  236.  
  237.  
  238.  
  239. ////////////////////////////////////////////////////////////////////////
  240.                 STOP_STATE:
  241.                         next_state = STOP_STATE;
  242.  
  243.  
  244.  
  245.  
  246. ////////////////////////////////////////////////////////////////////////
  247.                 default:
  248.                         next_state = STOP_STATE;
  249.  
  250.                 endcase
  251.  
  252.         end
  253.  
  254.  
  255.  
  256.         // FSM flip-flops
  257.         always @(posedge clk)
  258.         begin
  259.                 if( start )
  260.                         curr_state <= START_STATE;
  261.                 else if( dram_cbeg )
  262.                         curr_state <= next_state;
  263.         end
  264.  
  265.  
  266.         // FSM outputs
  267.         always @(posedge clk) if( dram_cbeg )
  268.         begin
  269.                 if( curr_state == INIT_STATE )
  270.                         dram_addr_pre <= 0;
  271.                 else
  272.                         dram_addr_pre <= dram_addr_nxt;
  273.         end
  274.  
  275.  
  276.  
  277.         always @(posedge clk) if( dram_cbeg )
  278.         begin
  279.                 case( curr_state )
  280.  
  281. ////////////////////////////////////////////////////////////////////////
  282.                 INIT_STATE:
  283.                 begin
  284.                         stop <= 1'b0;
  285.  
  286.                         dram_req <= 1'b0;
  287.  
  288.                         dram_ready_gen <= NO_READY;
  289.                 end
  290.  
  291.  
  292.  
  293. ////////////////////////////////////////////////////////////////////////
  294.                 READ_BEG1:
  295.                 begin
  296.                         dram_req <= 1'b1;
  297.                         dram_rnw <= 1'b1;
  298.                 end
  299.  
  300.                 READ_BEG2:
  301.                 begin
  302.                         dram_ready_gen <= RD_READY;
  303.                 end
  304.  
  305.                 READ_END1:
  306.                 begin
  307.                         dram_req <= 1'b0;
  308.                 end
  309.  
  310.                 READ_END2:
  311.                 begin
  312.                         dram_ready_gen <= NO_READY;
  313.                 end
  314.  
  315.  
  316.  
  317.  
  318. ////////////////////////////////////////////////////////////////////////
  319.                 WRITE_BEG:
  320.                 begin
  321.                         dram_req <= 1'b1;
  322.                         dram_rnw <= 1'b0;
  323.  
  324.                         dram_ready_gen <= WR_READY;
  325.                 end
  326.  
  327.                 WRITE_END:
  328.                 begin
  329.                         dram_req <= 1'b0;
  330.  
  331.                         dram_ready_gen <= NO_READY;
  332.                 end
  333.  
  334.  
  335. ////////////////////////////////////////////////////////////////////////
  336.                 STOP_STATE:
  337.                 begin
  338.                         stop <= 1'b1;
  339.                 end
  340.  
  341.                 endcase
  342.         end
  343.  
  344.  
  345. endmodule
  346.  
  347.