Subversion Repositories xulalx25soc

///////////////////////////////////////////////////////////////////////////

//

// Filename:    wbsdram.v

//

// Project:     XuLA2 board

//

// Purpose:     Provide 32-bit wishbone access to the SDRAM memory on a XuLA2

//              LX-25 board.  Specifically, on each access, the controller will

//      activate an appropriate bank of RAM (the SDRAM has four banks), and

//      then issue the read/write command.  In the case of walking off the

//      bank, the controller will activate the next bank before you get to it.

//      Upon concluding any wishbone access, all banks will be precharged and

//      returned to idle.

//

//      This particular implementation represents a second generation version

//      because my first version was too complex.  To speed things up, this

//      version includes an extra wait state where the wishbone inputs are

//      clocked into a flip flop before any action is taken on them.

//

// Creator:     Dan Gisselquist, Ph.D.

//              Gisselquist Technology, LLC

//

///////////////////////////////////////////////////////////////////////////

//

// Copyright (C) 2015, Gisselquist Technology, LLC

//

// This program is free software (firmware): you can redistribute it and/or

// modify it under the terms of  the GNU General Public License as published

// by the Free Software Foundation, either version 3 of the License, or (at

// your option) any later version.

//

// This program is distributed in the hope that it will be useful, but WITHOUT

// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for more details.

//

// You should have received a copy of the GNU General Public License along

// with this program.  (It's in the $(ROOT)/doc directory, run make with no

// target there if the PDF file isn't present.)  If not, see

// <http://www.gnu.org/licenses/> for a copy.

//

// License:     GPL, v3, as defined and found on www.gnu.org,

//              http://www.gnu.org/licenses/gpl.html

//

//

/////////////////////////////////////////////////////////////////////////////

//

`define DMOD_GETINPUT   1'b0

`define DMOD_PUTOUTPUT  1'b1

`define RAM_OPERATIONAL 2'b00

`define RAM_POWER_UP    2'b01

`define RAM_SET_MODE    2'b10

`define RAM_INITIAL_REFRESH     2'b11

module  wbsdram(i_clk,

                i_wb_cyc, i_wb_stb, i_wb_we, i_wb_addr, i_wb_data,

                        o_wb_ack, o_wb_stall, o_wb_data,

                o_ram_cs_n, o_ram_cke, o_ram_ras_n, o_ram_cas_n, o_ram_we_n,

                        o_ram_bs, o_ram_addr,

                        o_ram_dmod, i_ram_data, o_ram_data, o_ram_dqm,

                o_debug);

        parameter       RDLY = 6;

        input                   i_clk;

        // Wishbone

        //      inputs

        input                   i_wb_cyc, i_wb_stb, i_wb_we;

        input           [22:0]   i_wb_addr;

        input           [31:0]   i_wb_data;

        //      outputs

        output  wire            o_wb_ack;

        output  reg             o_wb_stall;

        output  wire [31:0]      o_wb_data;

        // SDRAM control

        output  wire            o_ram_cke;

        output  reg             o_ram_cs_n,

                                o_ram_ras_n, o_ram_cas_n, o_ram_we_n;

        output  reg     [1:0]    o_ram_bs;

        output  reg     [12:0]   o_ram_addr;

        output  reg             o_ram_dmod;

        input           [15:0]   i_ram_data;

        output  reg     [15:0]   o_ram_data;

        output  reg     [1:0]    o_ram_dqm;

        output  wire    [31:0]   o_debug;

        // Calculate some metrics

        //

        // First, do we *need* a refresh now --- i.e., must we break out of

        // whatever we are doing to issue a refresh command?

        //

        // The step size here must be such that 8192 charges may be done in

        // 64 ms.  Thus for a clock of:

        //      ClkRate(MHz)    (64ms/1000(ms/s)*ClkRate)/8192

        //      100 MHz         781

        //       96 MHz         750

        //       92 MHz         718

        //       88 MHz         687

        //       84 MHz         656

        //       80 MHz         625

        //

        // However, since we do two refresh cycles everytime we need a refresh,

        // this standard is close to overkill--but we'll use it anyway.  At

        // some later time we should address this, once we are entirely

        // convinced that the memory is otherwise working without failure.  Of

        // course, at that time, it may no longer be a priority ...

        //

        reg             need_refresh;

        reg     [9:0]    refresh_clk;

        wire    refresh_cmd;

        assign  refresh_cmd = (~o_ram_cs_n)&&(~o_ram_ras_n)&&(~o_ram_cas_n)&&(o_ram_we_n);

        initial refresh_clk = 0;

        always @(posedge i_clk)

        begin

                if (refresh_cmd)

                        refresh_clk <= 10'd625; // Make suitable for 80 MHz clk

                else if (|refresh_clk)

                        refresh_clk <= refresh_clk - 10'h1;

        end

        initial need_refresh = 1'b0;

        always @(posedge i_clk)

                need_refresh <= (refresh_clk == 10'h00)&&(~refresh_cmd);

        reg     in_refresh;

        reg     [2:0]    in_refresh_clk;

        initial in_refresh_clk = 3'h0;

        always @(posedge i_clk)

                if (refresh_cmd)

                        in_refresh_clk <= 3'h6;

                else if (|in_refresh_clk)

                        in_refresh_clk <= in_refresh_clk - 3'h1;

        always @(posedge i_clk)

                in_refresh <= (in_refresh_clk != 3'h0)||(refresh_cmd);

        reg     [2:0]    bank_active     [0:3];

        reg     [(RDLY-1):0]     r_barrell_ack;

        reg             r_pending;

        reg             r_we;

        reg     [22:0]   r_addr;

        reg     [31:0]   r_data;

        reg     [12:0]   bank_row        [0:3];

        //

        // Second, do we *need* a precharge now --- must be break out of 

        // whatever we are doing to issue a precharge command?

        //

        // Keep in mind, the number of clocks to wait has to be reduced by

        // the amount of time it may take us to go into a precharge state.

        // You may also notice that the precharge requirement is tighter

        // than this one, so ... perhaps this isn't as required?

        //

`ifdef  PRECHARGE_COUNTERS

        /*

         *

         * I'm commenting this out.  As long as we are doing one refresh

         * cycle every 625 (or even 1250) clocks, and as long as that refresh

         * cycle requires that all banks be precharged, then we will never run

         * out of the maximum active to precharge command period.

         *

         * If the logic isn't needed, then, let's get rid of it.

         *

         */

        reg     [3:0]    need_precharge;

        genvar  k;

        generate

        for(k=0; k<4; k=k+1)

        begin : precharge_genvar_loop

                wire    precharge_cmd;

                assign  precharge_cmd = ((~o_ram_cs_n)&&(~o_ram_ras_n)&&(o_ram_cas_n)&&(~o_ram_we_n)

                                &&((o_ram_addr[10])||(o_ram_bs == k[1:0])))

                        // Also on read or write with precharge

                        ||(~o_ram_cs_n)&&(o_ram_ras_n)&&(~o_ram_cas_n)&&(o_ram_addr[10]);

                reg     [9:0]    precharge_clk;

                initial precharge_clk = 0;

                always @(posedge i_clk)

                begin

                        if ((precharge_cmd)||(bank_active[k] == 0))

                                // This needs to be 100_000 ns, or 10_000

                                // clocks.  A value of 1000 is *highly*

                                // conservative.

                                precharge_clk <= 10'd1000;

                        else if (|precharge_clk)

                                precharge_clk <= precharge_clk - 10'h1;

                end

                initial need_precharge[k] = 1'b0;

                always @(posedge i_clk)

                        need_precharge[k] <= ~(|precharge_clk);

        end // precharge_genvar_loop

        endgenerate

`else

        wire    [3:0]    need_precharge;

        assign  need_precharge = 4'h0;

`endif

        reg     [15:0]   clocks_til_idle;

        reg     [1:0]    r_state;

        wire            bus_cyc;

        assign  bus_cyc  = ((i_wb_cyc)&&(i_wb_stb)&&(~o_wb_stall));

        reg     nxt_dmod;

        // Pre-process pending operations

        wire    pending;

        initial r_pending = 1'b0;

        reg     [22:5]  fwd_addr;

        always @(posedge i_clk)

                if (bus_cyc)

                begin

                        r_pending <= 1'b1;

                        r_we      <= i_wb_we;

                        r_addr    <= i_wb_addr;

                        r_data    <= i_wb_data;

                        fwd_addr  <= i_wb_addr[22:5] + 18'h01;

                end else if ((~o_ram_cs_n)&&(o_ram_ras_n)&&(~o_ram_cas_n))

                        r_pending <= 1'b0;

                else if (~i_wb_cyc)

                        r_pending <= 1'b0;

        reg     r_bank_valid;

        initial r_bank_valid = 1'b0;

        always @(posedge i_clk)

                if (bus_cyc)

                        r_bank_valid <=((bank_active[i_wb_addr[9:8]][2])

                                        &&(bank_row[i_wb_addr[9:8]]==r_addr[22:10]));

                else

                        r_bank_valid <= ((bank_active[r_addr[9:8]][2])

                                        &&(bank_row[r_addr[9:8]]==r_addr[22:10]));

        reg     fwd_bank_valid;

        initial fwd_bank_valid = 0;

        always @(posedge i_clk)

                fwd_bank_valid <= ((bank_active[fwd_addr[9:8]][2])

                                        &&(bank_row[fwd_addr[9:8]]==fwd_addr[22:10]));

        assign  pending = (r_pending)&&(o_wb_stall);

        // Address MAP:

        //      23-bits bits in, 24-bits out

        //

        //      222 1111 1111 1100 0000 0000

        //      210 9876 5432 1098 7654 3210

        //      rrr rrrr rrrr rrBB cccc cccc 0

        //                         8765 4321 0

        //

        initial r_barrell_ack = 0;

        initial r_state = `RAM_POWER_UP;

        initial clocks_til_idle = 16'd20500;

        initial o_wb_stall = 1'b1;

        initial o_ram_dmod = `DMOD_GETINPUT;

        initial nxt_dmod = `DMOD_GETINPUT;

        initial o_ram_cs_n  = 1'b0;

        initial o_ram_ras_n = 1'b1;

        initial o_ram_cas_n = 1'b1;

        initial o_ram_we_n  = 1'b1;

        initial o_ram_dqm   = 2'b11;

        assign  o_ram_cke   = 1'b1;

        initial bank_active[0] = 3'b000;

        initial bank_active[1] = 3'b000;

        initial bank_active[2] = 3'b000;

        initial bank_active[3] = 3'b000;

        always @(posedge i_clk)

        if (r_state == `RAM_OPERATIONAL)

        begin

                o_wb_stall <= (r_pending)||(bus_cyc);

                r_barrell_ack <= r_barrell_ack >> 1;

                nxt_dmod <= `DMOD_GETINPUT;

                o_ram_dmod <= nxt_dmod;

                //

                // We assume that, whatever state the bank is in, that it

                // continues in that state and set up a series of shift

                // registers to contain that information.  If it will not

                // continue in that state, all that therefore needs to be 

                // done is to set bank_active[?][2] below.

                //

                bank_active[0] <= { bank_active[0][2], bank_active[0][2:1] };

                bank_active[1] <= { bank_active[1][2], bank_active[1][2:1] };

                bank_active[2] <= { bank_active[2][2], bank_active[2][2:1] };

                bank_active[3] <= { bank_active[3][2], bank_active[3][2:1] };

                //

                o_ram_cs_n <= (~i_wb_cyc);

                // o_ram_cke  <= 1'b1;

                o_ram_dqm  <= 2'b0;

                if (|clocks_til_idle[2:0])

                        clocks_til_idle[2:0] <= clocks_til_idle[2:0] - 3'h1;

                // Default command is a

                //      NOOP if (i_wb_cyc)

                //      Device deselect if (~i_wb_cyc)

                // o_ram_cs_n  <= (~i_wb_cyc) above, NOOP

                o_ram_ras_n <= 1'b1;

                o_ram_cas_n <= 1'b1;

                o_ram_we_n  <= 1'b1;

                // o_ram_data <= r_data[15:0];

                if (nxt_dmod)

                        ;

                else

                if ((~i_wb_cyc)||(|need_precharge)||(need_refresh))

                begin // Issue a precharge all command (if any banks are open),

                // otherwise an autorefresh command

                        if ((bank_active[0][2:1]==2'b10)

                                        ||(bank_active[1][2:1]==2'b10)

                                        ||(bank_active[2][2:1]==2'b10)

                                        ||(bank_active[3][2:1]==2'b10)

                                ||(|clocks_til_idle[2:0]))

                        begin

                                // Do nothing this clock

                                // Can't precharge a bank immediately after

                                // activating it

                        end else if (bank_active[0][2]

                                ||(bank_active[1][2])

                                ||(bank_active[2][2])

                                ||(bank_active[3][2]))

                        begin  // Close all active banks

                                o_ram_cs_n  <= 1'b0;

                                o_ram_ras_n <= 1'b0;

                                o_ram_cas_n <= 1'b1;

                                o_ram_we_n  <= 1'b0;

                                o_ram_addr[10] <= 1'b1;

                                bank_active[0][2] <= 1'b0;

                                bank_active[1][2] <= 1'b0;

                                bank_active[2][2] <= 1'b0;

                                bank_active[3][2] <= 1'b0;

                        end else if ((|bank_active[0])

                                        ||(|bank_active[1])

                                        ||(|bank_active[2])

                                        ||(|bank_active[3]))

                                // Can't precharge yet, the bus is still busy

                        begin end else if ((~in_refresh)&&((refresh_clk[9:8]==2'b00)||(need_refresh)))

                        begin // Send autorefresh command

                                o_ram_cs_n  <= 1'b0;

                                o_ram_ras_n <= 1'b0;

                                o_ram_cas_n <= 1'b0;

                                o_ram_we_n  <= 1'b1;

                        end // Else just send NOOP's, the default command

                // end else if (nxt_dmod)

                // begin

                        // Last half of a two cycle write

                        // o_ram_data <= r_data[15:0];

                        //

                        // While this does need to take precedence over all

                        // other commands, it doesn't need to take precedence

                        // over the the deactivate/precharge commands from

                        // above.

                        //

                        // We could probably even speed ourselves up a touch

                        // by moving this condition down below activating

                        // and closing active banks. ... only problem is when I

                        // last tried that I broke everything so ... that's not

                        // my problem.

                end else if (in_refresh)

                begin

                        // NOOPS only here, until we are out of refresh

                end else if ((pending)&&(~r_bank_valid)&&(bank_active[r_addr[9:8]]==3'h0))

                begin // Need to activate the requested bank

                        o_ram_cs_n  <= 1'b0;

                        o_ram_ras_n <= 1'b0;

                        o_ram_cas_n <= 1'b1;

                        o_ram_we_n  <= 1'b1;

                        o_ram_addr  <= r_addr[22:10];

                        o_ram_bs    <= r_addr[9:8];

                        // clocks_til_idle[2:0] <= 1;

                        bank_active[r_addr[9:8]][2] <= 1'b1;

                        bank_row[r_addr[9:8]] <= r_addr[22:10];

                        //

                end else if ((pending)&&(~r_bank_valid)

                                &&(bank_active[r_addr[9:8]]==3'b111))

                begin // Need to close an active bank

                        o_ram_cs_n  <= 1'b0;

                        o_ram_ras_n <= 1'b0;

                        o_ram_cas_n <= 1'b1;

                        o_ram_we_n  <= 1'b0;

                        // o_ram_addr  <= r_addr[22:10];

                        o_ram_addr[10]<= 1'b0;

                        o_ram_bs    <= r_addr[9:8];

                        // clocks_til_idle[2:0] <= 1;

                        bank_active[r_addr[9:8]][2] <= 1'b0;

                        // bank_row[r_addr[9:8]] <= r_addr[22:10];

                end else if ((pending)&&(~r_we)

                                &&(bank_active[r_addr[9:8]][2])

                                &&(r_bank_valid)

                                &&(clocks_til_idle[2:0] < 4))

                begin // Issue the read command

                        o_ram_cs_n  <= 1'b0;

                        o_ram_ras_n <= 1'b1;

                        o_ram_cas_n <= 1'b0;

                        o_ram_we_n  <= 1'b1;

                        o_ram_addr  <= { 4'h0, r_addr[7:0], 1'b0 };

                        o_ram_bs    <= r_addr[9:8];

                        clocks_til_idle[2:0] <= 4;

                        o_wb_stall <= 1'b0;

                        r_barrell_ack[(RDLY-1)] <= 1'b1;

                end else if ((pending)&&(r_we)

                        &&(bank_active[r_addr[9:8]][2])

                        &&(r_bank_valid)

                        &&(clocks_til_idle[2:0] == 0))

                begin // Issue the write command

                        o_ram_cs_n  <= 1'b0;

                        o_ram_ras_n <= 1'b1;

                        o_ram_cas_n <= 1'b0;

                        o_ram_we_n  <= 1'b0;

                        o_ram_addr  <= { 4'h0, r_addr[7:0], 1'b0 };

                        o_ram_bs    <= r_addr[9:8];

                        clocks_til_idle[2:0] <= 3'h1;

                        o_wb_stall <= 1'b0;

                        r_barrell_ack[1] <= 1'b1;

                        // o_ram_data <= r_data[31:16];

                        //

                        o_ram_dmod <= `DMOD_PUTOUTPUT;

                        nxt_dmod <= `DMOD_PUTOUTPUT;

                end else if ((r_pending)&&(r_addr[7:0] >= 8'hf0)

                                &&(~fwd_bank_valid))

                begin

                        // Do I need to close the next bank I'll need?

                        if (bank_active[fwd_addr[9:8]][2:1]==2'b11)

                        begin // Need to close the bank first

                                o_ram_cs_n <= 1'b0;

                                o_ram_ras_n <= 1'b0;

                                o_ram_cas_n <= 1'b1;

                                o_ram_we_n  <= 1'b0;

                                o_ram_addr[10] <= 1'b0;

                                o_ram_bs       <= fwd_addr[9:8];

                                bank_active[fwd_addr[9:8]][2] <= 1'b0;

                        end else if (bank_active[fwd_addr[9:8]]==3'b000)

                        begin

                                // Need to (pre-)activate the next bank

                                o_ram_cs_n  <= 1'b0;

                                o_ram_ras_n <= 1'b0;

                                o_ram_cas_n <= 1'b1;

                                o_ram_we_n  <= 1'b1;

                                o_ram_addr  <= fwd_addr[22:10];

                                o_ram_bs    <= fwd_addr[9:8];

                                // clocks_til_idle[3:0] <= 1;

                                bank_active[fwd_addr[9:8]] <= 3'h4;

                                bank_row[fwd_addr[9:8]] <= fwd_addr[22:10];

                        end

                end

        end else if (r_state == `RAM_POWER_UP)

        begin

                // All signals must be held in NOOP state during powerup

                o_ram_dqm <= 2'b11;

                // o_ram_cke <= 1'b1;

                o_ram_cs_n  <= 1'b0;

                o_ram_ras_n <= 1'b1;

                o_ram_cas_n <= 1'b1;

                o_ram_we_n  <= 1'b1;

                o_ram_dmod  <= `DMOD_GETINPUT;

                if (clocks_til_idle == 0)

                begin

                        r_state <= `RAM_INITIAL_REFRESH;

                        clocks_til_idle[3:0] <= 4'ha;

                        o_ram_cs_n  <= 1'b0;

                        o_ram_ras_n <= 1'b0;

                        o_ram_cas_n <= 1'b1;

                        o_ram_we_n  <= 1'b0;

                        o_ram_addr[10] <= 1'b1;

                end else

                        clocks_til_idle <= clocks_til_idle - 16'h01;

                o_wb_stall  <= 1'b1;

                r_barrell_ack[(RDLY-1):0] <= 0;

        end else if (r_state == `RAM_INITIAL_REFRESH)

        begin

                //

                o_ram_cs_n  <= 1'b0;

                o_ram_ras_n <= 1'b0;

                o_ram_cas_n <= 1'b0;

                o_ram_we_n  <= 1'b1;

                o_ram_dmod  <= `DMOD_GETINPUT;

                o_ram_addr  <= { 3'b000, 1'b0, 2'b00, 3'b010, 1'b0, 3'b001 };

                if (clocks_til_idle[3:0] == 4'h0)

                begin

                        r_state <= `RAM_SET_MODE;

                        o_ram_we_n <= 1'b0;

                        clocks_til_idle[3:0] <= 4'h2;

                end else

                        clocks_til_idle[3:0] <= clocks_til_idle[3:0] - 4'h1;

                o_wb_stall  <= 1'b1;

                r_barrell_ack[(RDLY-1):0] <= 0;

        end else if (r_state == `RAM_SET_MODE)

        begin

                // Set mode cycle

                o_ram_cs_n  <= 1'b1;

                o_ram_ras_n <= 1'b0;

                o_ram_cas_n <= 1'b0;

                o_ram_we_n  <= 1'b0;

                o_ram_dmod  <= `DMOD_GETINPUT;

                if (clocks_til_idle[3:0] == 4'h0)

                        r_state <= `RAM_OPERATIONAL;

                else

                        clocks_til_idle[3:0] <= clocks_til_idle[3:0]-4'h1;

                o_wb_stall  <= 1'b1;

                r_barrell_ack[(RDLY-1):0] <= 0;

        end

        always @(posedge i_clk)

                if (nxt_dmod)

                        o_ram_data <= r_data[15:0];

                else

                        o_ram_data <= r_data[31:16];

`ifdef  VERILATOR

        // While I hate to build something that works one way under Verilator

        // and another way in practice, this really isn't that.  The problem

        // \/erilator is having is resolved in toplevel.v---one file that

        // \/erilator doesn't implement.  In toplevel.v, there's not only a

        // single clocked latch but two taking place.  Here, we replicate one

        // of those.  The second takes place (somehow) within the sdramsim.cpp

        // file.

        reg     [15:0]   ram_data, last_ram_data;

        always @(posedge i_clk)

                ram_data <= i_ram_data;

        always @(posedge i_clk)

                last_ram_data <= ram_data;

`else

        reg     [15:0]   last_ram_data;

        always @(posedge i_clk)

                last_ram_data <= i_ram_data;

`endif

        assign  o_wb_ack  = r_barrell_ack[0];

        assign  o_wb_data = { last_ram_data, i_ram_data };

        //

        // The following outputs are not necessary for the functionality of

        // the SDRAM, but they can be used to feed an external "scope" to

        // get an idea of what the internals of this SDRAM are doing.

        //

        // Just be aware of the r_we: it is set based upon the currently pending

        // transaction, or (if none is pending) based upon the last transaction.

        // If you want to capture the first value "written" to the device,

        // you'll need to write a nothing value to the device to set r_we.

        // The first value "written" to the device can be caught in the next

        // interaction after that.

        //

        reg     trigger;

        always @(posedge i_clk)

                trigger <= ((o_wb_data[15:0]==o_wb_data[31:16])

                        &&(o_wb_ack)&&(~i_wb_we));

        assign  o_debug = { i_wb_cyc, i_wb_stb, i_wb_we, o_wb_ack, o_wb_stall, // 5

                o_ram_cs_n, o_ram_ras_n, o_ram_cas_n, o_ram_we_n, o_ram_bs,//6

                        o_ram_dmod, r_pending,                          //  2

                        trigger,                                        //  1

                        o_ram_addr[9:0],                         // 10 more

                        (r_we) ? { o_ram_data[7:0] }                     //  8 values

                                : { o_wb_data[23:20], o_wb_data[3:0] }

                        // i_ram_data[7:0]

                         };

endmodule