URL https://opencores.org/ocsvn/sdram_controller/sdram_controller/trunk

Subversion Repositories sdram_controller

[/] [sdram_controller/] [trunk/] [sdram.vhd] - Blame information for rev 17

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


----------------------------------------------------------------------------------
-- Company: OPL Aerospatiale AG
-- Engineer: Owen Lynn <lynn0p@hotmail.com>
-- 
-- Create Date:    14:25:41 08/20/2009 
-- Design Name:    DDR SDRAM Controller
-- Module Name:    sdram_controller - impl 
-- Project Name: 
-- Target Devices: Spartan3e Starter Board
-- Tool versions:  ISE 11.2
-- Description: This is the main controller module. This is where the signals 
--  to/from the DDR SDRAM chip happen.
--  
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
--  Copyright (c) 2009 Owen Lynn <lynn0p@hotmail.com>
--  Released under the GNU Lesser General Public License, Version 3
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
 
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
 
-- This is not meant to be a high performance controller. No fancy command
--  scheduling, does the bare minimum to work without screwing up timing.
-- Do NOT put this controller in something mission critical! This is the creation
--  of a guy in his bedroom, learning digital circuits.
-- Intended to be used exclusively with the Spartan3e Starter Board and targets
--  the mt46v32m16 chip. Dunno if it will work anywhere else.
-- Uses the ODDR2 and DCM Xilinx primitives, for other FPGAs, you'll need to
--  patch in equivalents. See sdram_support for the details.
-- I'd strongly recommend running it through a post-PAR simulation if you're
--  porting to any other FPGA, as the timings will probably change on you.
-- Consumes one DCM, needs a 100mhz clock or an external DCM to supply it.
-- Has an 8bit wide datapath, moderate changes could support 16bits, 32 bits
--  you'll have to work some. You want more than that, you'll be doing brain
--  surgery on the FSMs - good luck.
 
-- This design has now been tested with a t80 soft cpu, however, it hasn't been
--  exhaustively tested with the rest of the system. Glitches may still exist.
-- Did I mention that you shouldn't put this in anything mission critical? 
 
-- Be careful with the synthesizer settings too. Do not let the FSM extractor
--  choose something other than one-hot. Be careful with equivalent register
--  removal. I've rolled all synthesizer settings back to default and things
--  seem to be OK, but pay attention to the synthesizer reports!
 
-- TODO: implement reset signal
entity sdram_controller is
        port(      -- user facing signals 
                 clk100mhz : in  std_logic;
                 en : in  std_logic;
                     reset : in  std_logic;
                        op : in  std_logic_vector(1 downto 0);        -- 00/11: NOP, 01: READ, 10: write
                      addr : in  std_logic_vector(25 downto 0);       -- address to read/write 
                    op_ack : out std_logic;                           -- op, addr and data_i should be captured when this goes high
                    busy_n : out std_logic;                           -- busy when LOW, ops will be ignored until busy goes high again
                    data_o : out std_logic_vector(7 downto 0);        -- data from read shows up here
                    data_i : in  std_logic_vector(7 downto 0);        -- data to write needs to be here
 
                -- SDRAM facing signals 
                          dram_clkp : out   std_logic;                         -- 0 deg phase 100mhz clock going out to SDRAM chip
                          dram_clkn : out   std_logic;                         -- 180 deg phase version of dram_clkp
                dram_clke : out   std_logic;                         -- clock enable, owned by the init module
                            dram_cs : out   std_logic;                         -- tied low upon powerup
                 dram_cmd : out   std_logic_vector(2 downto 0);      -- this is the command vector <we_n,cas_n,ras_n>
           dram_bank : out   std_logic_vector(1 downto 0);      -- bank address
                          dram_addr : out   std_logic_vector(12 downto 0);     -- row/col/mode register
                            dram_dm : out   std_logic_vector(1 downto 0);      -- masks used for writing
                           dram_dqs : inout std_logic_vector(1 downto 0);      -- strobes used for writing
                            dram_dq : inout std_logic_vector(15 downto 0);     -- data lines
 
                          -- debug signals (possibly could be repurposed later for wider data)
                          debug_reg : out   std_logic_vector(7 downto 0)
                                 );
end sdram_controller;
 
architecture impl of sdram_controller is
 
        -- component decls begin here
        component sdram_dcm is
                port(
                        reset      : in  std_logic;
                        clk100mhz  : in  std_logic;
                        locked     : out std_logic;
                        dram_clkp  : out std_logic;
                        dram_clkn  : out std_logic;
                        clk_000    : out std_logic;
                        clk_090    : out std_logic;
                        clk_180    : out std_logic;
                        clk_270    : out std_logic
                );
        end component;
 
        component oddr2_2 is
                port(
                        Q  : out std_logic_vector(1 downto 0);
                        C0 : in  std_logic;
                        C1 : in  std_logic;
                        CE : in  std_logic;
                        D0 : in  std_logic_vector(1 downto 0);
                        D1 : in  std_logic_vector(1 downto 0);
                        R  : in  std_logic;
                        S  : in  std_logic );
        end component;
 
        component oddr2_3 is
                port(
                        Q  : out std_logic_vector(2 downto 0);
                        C0 : in  std_logic;
                        C1 : in  std_logic;
                        CE : in  std_logic;
                        D0 : in  std_logic_vector(2 downto 0);
                        D1 : in  std_logic_vector(2 downto 0);
                        R  : in  std_logic;
                        S  : in  std_logic );
        end component;
 
        component oddr2_13 is
                port(
                        Q  : out std_logic_vector(12 downto 0);
                        C0 : in  std_logic;
                        C1 : in  std_logic;
                        CE : in  std_logic;
                        D0 : in  std_logic_vector(12 downto 0);
                        D1 : in  std_logic_vector(12 downto 0);
                        R  : in  std_logic;
                        S  : in  std_logic );
        end component;
 
        component inout_switch_2 is
                port (
                        ioport : inout std_logic_vector(1 downto 0);
                                dir : in    std_logic;
                        data_i : in    std_logic_vector(1 downto 0)
                );
        end component;
 
        component inout_switch_16 is
                port (
                        ioport : inout std_logic_vector(15 downto 0);
                                dir : in    std_logic;
                        data_o : out   std_logic_vector(15 downto 0);
                        data_i : in    std_logic_vector(15 downto 0)
                );
        end component;
 
        component sdram_reader is
                port(
                        clk270 : in  std_logic;
                        rst    : in  std_logic;
                        dq     : in  std_logic_vector(15 downto 0);
                        data0  : out std_logic_vector(7 downto 0);
                        data1  : out std_logic_vector(7 downto 0)
                );
        end component;
 
        component sdram_writer is
                port(
                        clk    : in  std_logic;
                        clk090 : in  std_logic;
                        clk180 : in  std_logic;
                        clk270 : in  std_logic;
                        rst    : in  std_logic;
                        addr   : in  std_logic;
                        data_o : in  std_logic_vector(7 downto 0);
                        dqs    : out std_logic_vector(1 downto 0);
                        dm     : out std_logic_vector(1 downto 0);
                        dq     : out std_logic_vector(15 downto 0)
                );
        end component;
 
        component wait_counter is
                generic(
                        BITS : integer;
                        CLKS : integer
                );
                port(
                         clk : in std_logic;
                         rst : in std_logic;
                        done : out std_logic
                );
        end component;
 
        component sdram_init
                port(
                        clk_000 : in std_logic;
                        reset   : in std_logic;
 
                        clke  : out std_logic;
                        cmd   : out std_logic_vector(2 downto 0);
                        bank  : out std_logic_vector(1 downto 0);
                        addr  : out std_logic_vector(12 downto 0);
                        done  : out std_logic
                );
        end component;
 
        component cmd_bank_addr_switch is
                port(
                        sel      : in std_logic;
                        cmd0_in  : in std_logic_vector(2 downto 0);
                        bank0_in : in std_logic_vector(1 downto 0);
                        addr0_in : in std_logic_vector(12 downto 0);
                        cmd1_in  : in std_logic_vector(2 downto 0);
                        bank1_in : in std_logic_vector(1 downto 0);
                        addr1_in : in std_logic_vector(12 downto 0);
                        cmd_out  : out std_logic_vector(2 downto 0);
                        bank_out : out std_logic_vector(1 downto 0);
                        addr_out : out std_logic_vector(12 downto 0)
                );
        end component;
        -- component decls end here
 
        -- DRAM commands - <we_n,cas_n,ras_n>
        constant CMD_NOP        : std_logic_vector(2 downto 0)  := "111";
        constant CMD_ACTIVE     : std_logic_vector(2 downto 0)  := "110"; -- opens a row within a bank
        constant CMD_READ       : std_logic_vector(2 downto 0)  := "101";
        constant CMD_WRITE      : std_logic_vector(2 downto 0)  := "001";
        constant CMD_BURST_TERM : std_logic_vector(2 downto 0)  := "011";
        constant CMD_PRECHARGE  : std_logic_vector(2 downto 0)  := "010"; -- closes a row within a bank
        constant CMD_AUTO_REFR  : std_logic_vector(2 downto 0)  := "100";
        constant CMD_LOAD_MR    : std_logic_vector(2 downto 0)  := "000";
 
        -- various wait counter values
        constant AUTO_REFRESH_CLKS  : integer := 700; -- spec says 7.8us, which is 780 clocks @ 100Mhz, I'm setting it to 700
        constant WRITE_RECOVER_CLKS : integer := 5;   -- these are fudged a bit, you *might* be able to shave a clock or two off
        constant READ_DONE_CLKS     : integer := 4;   --  or shave a clock or two off if your board timing is a bit wedgy
 
        type CMD_STATES is ( STATE_START, STATE_INIT, STATE_WAIT_INIT, STATE_IDLE, STATE_IDLE_AUTO_REFRESH,
                             STATE_IDLE_CHECK_OP_PENDING, STATE_IDLE_WAIT_AR_CTR, STATE_IDLE_WAIT_AUTO_REFRESH,
                                                                STATE_WRITE_ROW_OPEN, STATE_WRITE_WAIT_ROW_OPEN, STATE_WRITE_ISSUE_CMD, STATE_WRITE_WAIT_RECOVER,
                                                                STATE_READ_ROW_OPEN, STATE_READ_WAIT_ROW_OPEN, STATE_READ_ISSUE_CMD, STATE_READ_WAIT_CAPTURE );
 
        signal cmd_state : CMD_STATES := STATE_START;
 
        signal cmd_oddr2_rising   : std_logic_vector(2 downto 0) := CMD_NOP;
        signal bank_oddr2_rising  : std_logic_vector(1 downto 0) := "00";
        signal addr_oddr2_rising  : std_logic_vector(12 downto 0) := "0000000000000";
 
        signal dqs_out : std_logic_vector(1 downto 0);
        signal dqs_dir : std_logic;
 
        signal dq_in : std_logic_vector(15 downto 0);
        signal dq_out : std_logic_vector(15 downto 0);
        signal dq_dir : std_logic;
 
        signal reader_rst : std_logic := '1';
        signal writer_rst : std_logic := '1';
 
        signal dcm_locked   : std_logic;
        signal clk_000      : std_logic;
        signal clk_090      : std_logic;
        signal clk_180      : std_logic;
        signal clk_270      : std_logic;
 
        -- init module stuff
        signal init_reset : std_logic;
        signal init_cmd   : std_logic_vector(2 downto 0);
        signal init_bank  : std_logic_vector(1 downto 0);
        signal init_addr  : std_logic_vector(12 downto 0);
        signal init_done  : std_logic;
 
        -- main module stuff
        signal main_sel  : std_logic;
        signal main_cmd  : std_logic_vector(2 downto 0);
        signal main_bank : std_logic_vector(1 downto 0);
        signal main_addr : std_logic_vector(12 downto 0);
 
        -- wait counter stuff
        signal need_ar_rst : std_logic;
        signal need_ar     : std_logic;
 
        signal wait_ar_rst  : std_logic;
        signal wait_ar_done : std_logic;
 
        signal write_reco_rst  : std_logic;
        signal write_reco_done : std_logic;
 
        signal read_wait_rst : std_logic;
        signal read_wait_done : std_logic;
 
        signal data0_o : std_logic_vector(7 downto 0);
        signal data1_o : std_logic_vector(7 downto 0);
 
        -- capture signals
        signal cap_en     : std_logic;
        signal op_save    : std_logic_vector(1 downto 0);
        signal addr_save  : std_logic_vector(25 downto 0);
        signal datai_save : std_logic_vector(7 downto 0);
 
begin
 
        -- component instantiations begin here
        DRAM_DCM: sdram_dcm
        port map(
                reset           => reset,
                clk100mhz       => clk100mhz,
                locked          => dcm_locked,
                dram_clkp       => dram_clkp,
                dram_clkn       => dram_clkn,
                clk_000         => clk_000,
                clk_090         => clk_090,
                clk_180         => clk_180,
                clk_270         => clk_270
        );
 
        DRAM_INIT: sdram_init
        port map(
                clk_000 => clk_000,
                reset   => init_reset,
                clke    => dram_clke,
                cmd     => init_cmd,
                bank    => init_bank,
                addr    => init_addr,
                done    => init_done
        );
 
        CMD_BANK_ADDR_SEL: cmd_bank_addr_switch
        port map(
                sel      => main_sel,
                cmd0_in  => init_cmd,
                bank0_in => init_bank,
                addr0_in => init_addr,
                cmd1_in  => main_cmd,
                bank1_in => main_bank,
                addr1_in => main_addr,
                cmd_out  => cmd_oddr2_rising,
                bank_out => bank_oddr2_rising,
                addr_out => addr_oddr2_rising
        );
 
        DRAM_BANK_ODDR2: oddr2_2
        port map(
                Q  => dram_bank,
                C0 => clk_270,
                C1 => clk_090,
                CE => '1',
                D0 => bank_oddr2_rising,
                D1 => "00",
                R  => '0',
                S  => '0' );
 
        DRAM_CMD_ODDR2: oddr2_3
        port map(
                Q  => dram_cmd,
                C0 => clk_270,
                C1 => clk_090,
                CE => '1',
                D0 => cmd_oddr2_rising,
                D1 => CMD_NOP,
                R  => '0',
                S  => '0' );
 
        DRAM_ADDR_ODDR2: oddr2_13
        port map(
                Q  => dram_addr,
                C0 => clk_270,
                C1 => clk_090,
                CE => '1',
                D0 => addr_oddr2_rising,
                D1 => "0000000000000",
                R  => '0',
                S  => '0' );
 
        DQS_SWITCH: inout_switch_2
        port map(
                ioport => dram_dqs,
                dir    => dqs_dir,
                data_i => dqs_out
        );
 
        DQ_SWITCH: inout_switch_16
        port map(
                ioport => dram_dq,
                dir    => dq_dir,
                data_o => dq_in,
                data_i => dq_out
        );
 
        AR_NEEDED_CTR: wait_counter
        generic map(
                BITS => 10,
                CLKS => AUTO_REFRESH_CLKS
        )
        port map (
          clk => clk_000,
          rst => need_ar_rst,
         done => need_ar
        );
 
        WAIT_AR_CTR: wait_counter
        generic map(
                BITS => 4,
                CLKS => 11
        )
        port map(
                clk => clk_000,
                rst => wait_ar_rst,
                done => wait_ar_done
        );
 
        WRITE_RECOVER_CTR: wait_counter
        generic map(
                BITS => 2,
                CLKS => WRITE_RECOVER_CLKS
        )
        port map(
          clk => clk_000,
          rst => write_reco_rst,
         done => write_reco_done
        );
 
        READ_DONE_CTR: wait_counter
        generic map(
                BITS => 2,
                CLKS => READ_DONE_CLKS
        )
        port map(
          clk => clk_000,
          rst => read_wait_rst,
         done => read_wait_done
        );
 
        READER: sdram_reader
        port map(
      clk270 => clk_270,
      rst    => reader_rst,
      dq     => dq_in,
                data0  => data0_o,
                data1  => data1_o
        );
 
        WRITER: sdram_writer
        port map(
                clk    => clk_000,
                clk090 => clk_090,
                clk180 => clk_180,
                clk270 => clk_270,
                rst    => writer_rst,
                addr   => addr_save(0),
                data_o => datai_save,
                dqs    => dqs_out,
                dm     => dram_dm,
                dq     => dq_out
        );
        -- end component allocs
 
        debug_reg <= x"00";
        dram_cs <= '0';
        data_o <= data1_o when addr_save(0) = '1' else data0_o;
 
--      process (clk_000)
--      begin
--              if (cap_en = '1') then
--                      if (rising_edge(clk_000)) then
--                              addr_save <= addr;
--                              datai_save <= data_i;
--                              op_save <= op;
--                      end if;
--              end if;
--      end process;
 
        -- this will probably make the synthesizer scream bloody murder
        -- over either a transparent latch or gated clock or both
        -- but i've got it working again with my SoC and I'll see about
        -- changing it back to something less icky later
        -- capture addr, data_i and op for the cmd fsm
        -- op needs to be captured during AR or it might get dropped
        addr_save  <= addr   when cap_en = '1' else addr_save;
        datai_save <= data_i when cap_en = '1' else datai_save;
        op_save    <= op     when cap_en = '1' else op_save;
 
        -- command state machine
        process (clk_000)
        begin
                if (rising_edge(clk_000)) then
                        if (dcm_locked = '1') then
                                case cmd_state is
                                        when STATE_START =>
                                                busy_n <= '0';
                                                op_ack <= '0';
                                                init_reset <= '1';
                                                cap_en <= '0';
                                                main_sel <= '0';
                                                main_cmd <= CMD_NOP;
                                                main_bank <= "00";
                                                main_addr <= "0000000000000";
                                                cmd_state <= STATE_INIT;
 
                                        when STATE_INIT =>
                                                init_reset <= '0';
                                                cmd_state <= STATE_WAIT_INIT;
 
                                        when STATE_WAIT_INIT =>
                                                need_ar_rst <= '1';
                                                if (init_done = '1') then
                                                        cmd_state <= STATE_IDLE;
                                                else
                                                        cmd_state <= cmd_state;
                                                end if;
 
                                        when STATE_IDLE =>
                                                -- this is the main hub state
                                                -- this is where reads and writes return to after being completed
                                                busy_n <= '1';
                                                op_ack <= '0';
                                                need_ar_rst <= '0';
                                                main_sel <= '1';
                                                writer_rst <= '1';
                                                reader_rst <= '1';
                                                cap_en <= '1';
                                                if (need_ar = '1') then
                                                        busy_n <= '0';
                                                        cmd_state <= STATE_IDLE_AUTO_REFRESH;
                                                elsif (op = "01") then
                                                        busy_n <= '0';
                                                        op_ack <= '1';
                                                        cap_en <= '0';
                                                        cmd_state <= STATE_READ_ROW_OPEN;
                                                elsif (op = "10") then
                                                        busy_n <= '0';
                                                        op_ack <= '1';
                                                        cap_en <= '0';
                                                        cmd_state <= STATE_WRITE_ROW_OPEN;
                                                else
                                                        cmd_state <= cmd_state;
                                                end if;
 
                                        when STATE_IDLE_AUTO_REFRESH =>
                                                if (op = "01" or op = "10") then
                                                        cap_en <= '0';
                                                end if;
                                                need_ar_rst <= '1';
                                                wait_ar_rst <= '1';
                                                main_cmd <= CMD_AUTO_REFR;
                                                main_bank <= "00";
                                                main_addr <= "0000000000000";
                                                cmd_state <= STATE_IDLE_WAIT_AR_CTR;
 
                                        when STATE_IDLE_WAIT_AR_CTR =>
                                                if (op = "01" or op = "10") then
                                                        cap_en <= '0';
                                                end if;
                                                wait_ar_rst <= '0';
                                                main_cmd <= CMD_NOP;
                                                main_bank <= "00";
                                                main_addr <= "0000000000000";
                                                cmd_state <= STATE_IDLE_WAIT_AUTO_REFRESH;
 
                                        when STATE_IDLE_WAIT_AUTO_REFRESH =>
                                                if (op = "01" or op = "10") then
                                                        cap_en <= '0';
                                                end if;
                                                main_cmd <= CMD_NOP;
                                                main_bank <= "00";
                                                main_addr <= "0000000000000";
                                                if (wait_ar_done = '1') then
                                                        cmd_state <= STATE_IDLE_CHECK_OP_PENDING;
                                                else
                                                        cmd_state <= cmd_state;
                                                end if;
 
                                        when STATE_IDLE_CHECK_OP_PENDING =>
                                                if ( cap_en = '0') then
                                                        if    (op_save = "01") then
                                                                op_ack <= '1';
                                                                cmd_state <= STATE_READ_ROW_OPEN;
                                                        elsif (op_save = "10") then
                                                                op_ack <= '1';
                                                                cmd_state <= STATE_WRITE_ROW_OPEN;
                                                        else
                                                                cmd_state <= STATE_IDLE;
                                                        end if;
                                                else
                                                        cmd_state <= STATE_IDLE;
                                                end if;
 
                                        when STATE_WRITE_ROW_OPEN =>
                                                dqs_dir <= '1';
                                                dq_dir <= '1';
                                                main_cmd <= CMD_ACTIVE;
                                                main_bank <= addr_save(25 downto 24);
                                                main_addr <= addr_save(23 downto 11);
                                                cmd_state <= STATE_WRITE_WAIT_ROW_OPEN;
 
                                        when STATE_WRITE_WAIT_ROW_OPEN =>
                                                main_cmd <= CMD_NOP;
                                                main_bank <= addr_save(25 downto 24); -- timing kludge
                                                main_addr <= "001" & addr_save(10 downto 1); -- last bit determines upper/lower byte in word
                                                cmd_state <= STATE_WRITE_ISSUE_CMD;
 
                                        when STATE_WRITE_ISSUE_CMD =>
                                                writer_rst <= '0';
                                                write_reco_rst <= '1';
                                                main_cmd <= CMD_WRITE;
                                                main_bank <= addr_save(25 downto 24);
                                                main_addr <= "001" & addr_save(10 downto 1); -- last bit determines upper/lower byte in word
                                                cmd_state <= STATE_WRITE_WAIT_RECOVER;
 
                                        when STATE_WRITE_WAIT_RECOVER =>
                                                write_reco_rst <= '0';
                                                main_cmd <= CMD_NOP;
                                                main_bank <= "00";
                                                main_addr <= "0000000000000";
                                                if (write_reco_done = '1') then
                                                        cmd_state <= STATE_IDLE;
                                                else
                                                        cmd_state <= cmd_state;
                                                end if;
 
                                        when STATE_READ_ROW_OPEN =>
                                                dqs_dir <= '0';
                                                dq_dir <= '0';
                                                main_cmd <= CMD_ACTIVE;
                                                main_bank <= addr_save(25 downto 24);
                                                main_addr <= addr_save(23 downto 11);
                                                cmd_state <= STATE_READ_WAIT_ROW_OPEN;
 
                                        when STATE_READ_WAIT_ROW_OPEN =>
                                                main_cmd <= CMD_NOP;
                                                main_bank <= addr_save(25 downto 24); -- timing kludge
                                                main_addr <= "001" & addr_save(10 downto 1); -- last bit determines upper/lower byte
                                                cmd_state <= STATE_READ_ISSUE_CMD;
 
                                        when STATE_READ_ISSUE_CMD =>
                                                read_wait_rst <= '1';
                                                main_cmd <= CMD_READ;
                                                main_bank <= addr_save(25 downto 24);
                                                main_addr <= "001" & addr_save(10 downto 1); -- last bit determines upper/lower byte
                                                cmd_state <= STATE_READ_WAIT_CAPTURE;
 
                                        when STATE_READ_WAIT_CAPTURE =>
                                                read_wait_rst <= '0';
                                                reader_rst <= '0';
                                                main_cmd <= CMD_NOP;
                                                main_bank <= "00";
                                                main_addr <= "0000000000000";
                                                if (read_wait_done = '1') then
                                                        cmd_state <= STATE_IDLE;
                                                else
                                                        cmd_state <= cmd_state;
                                                end if;
                                end case;
                        end if;
                end if;
        end process;
 
end impl;
 
 

Line No.	Rev	Author	Line
1	2	lynn0p	`----------------------------------------------------------------------------------`
2			`-- Company: OPL Aerospatiale AG`
3			`-- Engineer: Owen Lynn <lynn0p@hotmail.com>`
4			`--`
5			`-- Create Date: 14:25:41 08/20/2009`
6			`-- Design Name: DDR SDRAM Controller`
7			`-- Module Name: sdram_controller - impl`
8			`-- Project Name:`
9			`-- Target Devices: Spartan3e Starter Board`
10			`-- Tool versions: ISE 11.2`
11	7	lynn0p	`-- Description: This is the main controller module. This is where the signals`
12			`-- to/from the DDR SDRAM chip happen.`
13	2	lynn0p	`--`
14			`-- Dependencies:`
15			`--`
16			`-- Revision:`
17			`-- Revision 0.01 - File Created`
18			`-- Additional Comments:`
19			`-- Copyright (c) 2009 Owen Lynn <lynn0p@hotmail.com>`
20			`-- Released under the GNU Lesser General Public License, Version 3`
21			`--`
22			`----------------------------------------------------------------------------------`
23			`library IEEE;`
24			`use IEEE.STD_LOGIC_1164.ALL;`
25			`use IEEE.STD_LOGIC_ARITH.ALL;`
26			`use IEEE.STD_LOGIC_UNSIGNED.ALL;`
27
28			`---- Uncomment the following library declaration if instantiating`
29			`---- any Xilinx primitives in this code.`
30	7	lynn0p	`--library UNISIM;`
31			`--use UNISIM.VComponents.all;`
32	2	lynn0p
33	7	lynn0p	`-- This is not meant to be a high performance controller. No fancy command`
34			`-- scheduling, does the bare minimum to work without screwing up timing.`
35			`-- Do NOT put this controller in something mission critical! This is the creation`
36			`-- of a guy in his bedroom, learning digital circuits.`
37			`-- Intended to be used exclusively with the Spartan3e Starter Board and targets`
38			`-- the mt46v32m16 chip. Dunno if it will work anywhere else.`
39			`-- Uses the ODDR2 and DCM Xilinx primitives, for other FPGAs, you'll need to`
40			`-- patch in equivalents. See sdram_support for the details.`
41			`-- I'd strongly recommend running it through a post-PAR simulation if you're`
42			`-- porting to any other FPGA, as the timings will probably change on you.`
43	10	lynn0p	`-- Consumes one DCM, needs a 100mhz clock or an external DCM to supply it.`
44	7	lynn0p	`-- Has an 8bit wide datapath, moderate changes could support 16bits, 32 bits`
45			`-- you'll have to work some. You want more than that, you'll be doing brain`
46			`-- surgery on the FSMs - good luck.`
47	2	lynn0p
48	10	lynn0p	`-- This design has now been tested with a t80 soft cpu, however, it hasn't been`
49			`-- exhaustively tested with the rest of the system. Glitches may still exist.`
50	2	lynn0p	`-- Did I mention that you shouldn't put this in anything mission critical?`
51
52	7	lynn0p	`-- Be careful with the synthesizer settings too. Do not let the FSM extractor`
53			`-- choose something other than one-hot. Be careful with equivalent register`
54			`-- removal. I've rolled all synthesizer settings back to default and things`
55			`-- seem to be OK, but pay attention to the synthesizer reports!`
56	2	lynn0p
57			`-- TODO: implement reset signal`
58			`entity sdram_controller is`
59			`port( -- user facing signals`
60	8	lynn0p	`clk100mhz : in std_logic;`
61			`en : in std_logic;`
62			`reset : in std_logic;`
63			`op : in std_logic_vector(1 downto 0); -- 00/11: NOP, 01: READ, 10: write`
64			`addr : in std_logic_vector(25 downto 0); -- address to read/write`
65			`op_ack : out std_logic; -- op, addr and data_i should be captured when this goes high`
66			`busy_n : out std_logic; -- busy when LOW, ops will be ignored until busy goes high again`
67			`data_o : out std_logic_vector(7 downto 0); -- data from read shows up here`
68			`data_i : in std_logic_vector(7 downto 0); -- data to write needs to be here`
69	2	lynn0p
70			`-- SDRAM facing signals`
71			`dram_clkp : out std_logic; -- 0 deg phase 100mhz clock going out to SDRAM chip`
72			`dram_clkn : out std_logic; -- 180 deg phase version of dram_clkp`
73			`dram_clke : out std_logic; -- clock enable, owned by the init module`
74			`dram_cs : out std_logic; -- tied low upon powerup`
75			`dram_cmd : out std_logic_vector(2 downto 0); -- this is the command vector <we_n,cas_n,ras_n>`
76			`dram_bank : out std_logic_vector(1 downto 0); -- bank address`
77			`dram_addr : out std_logic_vector(12 downto 0); -- row/col/mode register`
78			`dram_dm : out std_logic_vector(1 downto 0); -- masks used for writing`
79			`dram_dqs : inout std_logic_vector(1 downto 0); -- strobes used for writing`
80			`dram_dq : inout std_logic_vector(15 downto 0); -- data lines`
81
82			`-- debug signals (possibly could be repurposed later for wider data)`
83			`debug_reg : out std_logic_vector(7 downto 0)`
84			`);`
85			`end sdram_controller;`
86
87			`architecture impl of sdram_controller is`
88
89			`-- component decls begin here`
90			`component sdram_dcm is`
91			`port(`
92			`reset : in std_logic;`
93	8	lynn0p	`clk100mhz : in std_logic;`
94	2	lynn0p	`locked : out std_logic;`
95			`dram_clkp : out std_logic;`
96			`dram_clkn : out std_logic;`
97			`clk_000 : out std_logic;`
98			`clk_090 : out std_logic;`
99			`clk_180 : out std_logic;`
100			`clk_270 : out std_logic`
101			`);`
102			`end component;`
103
104			`component oddr2_2 is`
105			`port(`
106			`Q : out std_logic_vector(1 downto 0);`
107			`C0 : in std_logic;`
108			`C1 : in std_logic;`
109			`CE : in std_logic;`
110			`D0 : in std_logic_vector(1 downto 0);`
111			`D1 : in std_logic_vector(1 downto 0);`
112			`R : in std_logic;`
113			`S : in std_logic );`
114			`end component;`
115
116			`component oddr2_3 is`
117			`port(`
118			`Q : out std_logic_vector(2 downto 0);`
119			`C0 : in std_logic;`
120			`C1 : in std_logic;`
121			`CE : in std_logic;`
122			`D0 : in std_logic_vector(2 downto 0);`
123			`D1 : in std_logic_vector(2 downto 0);`
124			`R : in std_logic;`
125			`S : in std_logic );`
126			`end component;`
127
128			`component oddr2_13 is`
129			`port(`
130			`Q : out std_logic_vector(12 downto 0);`
131			`C0 : in std_logic;`
132			`C1 : in std_logic;`
133			`CE : in std_logic;`
134			`D0 : in std_logic_vector(12 downto 0);`
135			`D1 : in std_logic_vector(12 downto 0);`
136			`R : in std_logic;`
137			`S : in std_logic );`
138			`end component;`
139
140			`component inout_switch_2 is`
141			`port (`
142			`ioport : inout std_logic_vector(1 downto 0);`
143			`dir : in std_logic;`
144			`data_i : in std_logic_vector(1 downto 0)`
145			`);`
146			`end component;`
147
148			`component inout_switch_16 is`
149			`port (`
150			`ioport : inout std_logic_vector(15 downto 0);`
151			`dir : in std_logic;`
152			`data_o : out std_logic_vector(15 downto 0);`
153			`data_i : in std_logic_vector(15 downto 0)`
154			`);`
155			`end component;`
156
157			`component sdram_reader is`
158			`port(`
159			`clk270 : in std_logic;`
160			`rst : in std_logic;`
161			`dq : in std_logic_vector(15 downto 0);`
162			`data0 : out std_logic_vector(7 downto 0);`
163			`data1 : out std_logic_vector(7 downto 0)`
164			`);`
165			`end component;`
166
167			`component sdram_writer is`
168			`port(`
169			`clk : in std_logic;`
170			`clk090 : in std_logic;`
171			`clk180 : in std_logic;`
172			`clk270 : in std_logic;`
173			`rst : in std_logic;`
174			`addr : in std_logic;`
175			`data_o : in std_logic_vector(7 downto 0);`
176			`dqs : out std_logic_vector(1 downto 0);`
177			`dm : out std_logic_vector(1 downto 0);`
178	6	lynn0p	`dq : out std_logic_vector(15 downto 0)`
179	2	lynn0p	`);`
180			`end component;`
181
182			`component wait_counter is`
183			`generic(`
184			`BITS : integer;`
185			`CLKS : integer`
186			`);`
187			`port(`
188			`clk : in std_logic;`
189			`rst : in std_logic;`
190			`done : out std_logic`
191			`);`
192			`end component;`
193
194			`component sdram_init`
195			`port(`
196			`clk_000 : in std_logic;`
197			`reset : in std_logic;`
198
199			`clke : out std_logic;`
200			`cmd : out std_logic_vector(2 downto 0);`
201			`bank : out std_logic_vector(1 downto 0);`
202			`addr : out std_logic_vector(12 downto 0);`
203			`done : out std_logic`
204			`);`
205			`end component;`
206
207			`component cmd_bank_addr_switch is`
208			`port(`
209			`sel : in std_logic;`
210			`cmd0_in : in std_logic_vector(2 downto 0);`
211			`bank0_in : in std_logic_vector(1 downto 0);`
212			`addr0_in : in std_logic_vector(12 downto 0);`
213			`cmd1_in : in std_logic_vector(2 downto 0);`
214			`bank1_in : in std_logic_vector(1 downto 0);`
215			`addr1_in : in std_logic_vector(12 downto 0);`
216			`cmd_out : out std_logic_vector(2 downto 0);`
217			`bank_out : out std_logic_vector(1 downto 0);`
218			`addr_out : out std_logic_vector(12 downto 0)`
219			`);`
220			`end component;`
221			`-- component decls end here`
222
223	10	lynn0p	`-- DRAM commands - <we_n,cas_n,ras_n>`
224	2	lynn0p	`constant CMD_NOP : std_logic_vector(2 downto 0) := "111";`
225			`constant CMD_ACTIVE : std_logic_vector(2 downto 0) := "110"; -- opens a row within a bank`
226			`constant CMD_READ : std_logic_vector(2 downto 0) := "101";`
227			`constant CMD_WRITE : std_logic_vector(2 downto 0) := "001";`
228			`constant CMD_BURST_TERM : std_logic_vector(2 downto 0) := "011";`
229			`constant CMD_PRECHARGE : std_logic_vector(2 downto 0) := "010"; -- closes a row within a bank`
230			`constant CMD_AUTO_REFR : std_logic_vector(2 downto 0) := "100";`
231			`constant CMD_LOAD_MR : std_logic_vector(2 downto 0) := "000";`
232
233			`-- various wait counter values`
234			`constant AUTO_REFRESH_CLKS : integer := 700; -- spec says 7.8us, which is 780 clocks @ 100Mhz, I'm setting it to 700`
235	12	lynn0p	`constant WRITE_RECOVER_CLKS : integer := 5; -- these are fudged a bit, you might be able to shave a clock or two off`
236	17	lynn0p	`constant READ_DONE_CLKS : integer := 4; -- or shave a clock or two off if your board timing is a bit wedgy`
237	2	lynn0p
238	10	lynn0p	`type CMD_STATES is ( STATE_START, STATE_INIT, STATE_WAIT_INIT, STATE_IDLE, STATE_IDLE_AUTO_REFRESH,`
239			`STATE_IDLE_CHECK_OP_PENDING, STATE_IDLE_WAIT_AR_CTR, STATE_IDLE_WAIT_AUTO_REFRESH,`
240			`STATE_WRITE_ROW_OPEN, STATE_WRITE_WAIT_ROW_OPEN, STATE_WRITE_ISSUE_CMD, STATE_WRITE_WAIT_RECOVER,`
241			`STATE_READ_ROW_OPEN, STATE_READ_WAIT_ROW_OPEN, STATE_READ_ISSUE_CMD, STATE_READ_WAIT_CAPTURE );`
242	2	lynn0p
243			`signal cmd_state : CMD_STATES := STATE_START;`
244
245			`signal cmd_oddr2_rising : std_logic_vector(2 downto 0) := CMD_NOP;`
246			`signal bank_oddr2_rising : std_logic_vector(1 downto 0) := "00";`
247			`signal addr_oddr2_rising : std_logic_vector(12 downto 0) := "0000000000000";`
248
249			`signal dqs_out : std_logic_vector(1 downto 0);`
250			`signal dqs_dir : std_logic;`
251
252			`signal dq_in : std_logic_vector(15 downto 0);`
253			`signal dq_out : std_logic_vector(15 downto 0);`
254			`signal dq_dir : std_logic;`
255
256			`signal reader_rst : std_logic := '1';`
257			`signal writer_rst : std_logic := '1';`
258
259			`signal dcm_locked : std_logic;`
260			`signal clk_000 : std_logic;`
261			`signal clk_090 : std_logic;`
262			`signal clk_180 : std_logic;`
263			`signal clk_270 : std_logic;`
264
265			`-- init module stuff`
266			`signal init_reset : std_logic;`
267			`signal init_cmd : std_logic_vector(2 downto 0);`
268			`signal init_bank : std_logic_vector(1 downto 0);`
269			`signal init_addr : std_logic_vector(12 downto 0);`
270			`signal init_done : std_logic;`
271
272			`-- main module stuff`
273			`signal main_sel : std_logic;`
274			`signal main_cmd : std_logic_vector(2 downto 0);`
275			`signal main_bank : std_logic_vector(1 downto 0);`
276			`signal main_addr : std_logic_vector(12 downto 0);`
277
278			`-- wait counter stuff`
279			`signal need_ar_rst : std_logic;`
280			`signal need_ar : std_logic;`
281
282			`signal wait_ar_rst : std_logic;`
283			`signal wait_ar_done : std_logic;`
284
285			`signal write_reco_rst : std_logic;`
286			`signal write_reco_done : std_logic;`
287
288			`signal read_wait_rst : std_logic;`
289			`signal read_wait_done : std_logic;`
290
291			`signal data0_o : std_logic_vector(7 downto 0);`
292			`signal data1_o : std_logic_vector(7 downto 0);`
293	8	lynn0p
294	10	lynn0p	`-- capture signals`
295	8	lynn0p	`signal cap_en : std_logic;`
296	10	lynn0p	`signal op_save : std_logic_vector(1 downto 0);`
297	8	lynn0p	`signal addr_save : std_logic_vector(25 downto 0);`
298			`signal datai_save : std_logic_vector(7 downto 0);`
299	2	lynn0p
300			`begin`
301
302			`-- component instantiations begin here`
303			`DRAM_DCM: sdram_dcm`
304			`port map(`
305			`reset => reset,`
306	8	lynn0p	`clk100mhz => clk100mhz,`
307	2	lynn0p	`locked => dcm_locked,`
308			`dram_clkp => dram_clkp,`
309			`dram_clkn => dram_clkn,`
310			`clk_000 => clk_000,`
311			`clk_090 => clk_090,`
312			`clk_180 => clk_180,`
313			`clk_270 => clk_270`
314			`);`
315
316			`DRAM_INIT: sdram_init`
317			`port map(`
318			`clk_000 => clk_000,`
319			`reset => init_reset,`
320			`clke => dram_clke,`
321			`cmd => init_cmd,`
322			`bank => init_bank,`
323			`addr => init_addr,`
324			`done => init_done`
325			`);`
326
327			`CMD_BANK_ADDR_SEL: cmd_bank_addr_switch`
328			`port map(`
329			`sel => main_sel,`
330			`cmd0_in => init_cmd,`
331			`bank0_in => init_bank,`
332			`addr0_in => init_addr,`
333			`cmd1_in => main_cmd,`
334			`bank1_in => main_bank,`
335			`addr1_in => main_addr,`
336			`cmd_out => cmd_oddr2_rising,`
337			`bank_out => bank_oddr2_rising,`
338			`addr_out => addr_oddr2_rising`
339			`);`
340
341			`DRAM_BANK_ODDR2: oddr2_2`
342			`port map(`
343			`Q => dram_bank,`
344			`C0 => clk_270,`
345			`C1 => clk_090,`
346			`CE => '1',`
347			`D0 => bank_oddr2_rising,`
348			`D1 => "00",`
349			`R => '0',`
350			`S => '0' );`
351
352			`DRAM_CMD_ODDR2: oddr2_3`
353			`port map(`
354			`Q => dram_cmd,`
355			`C0 => clk_270,`
356			`C1 => clk_090,`
357			`CE => '1',`
358			`D0 => cmd_oddr2_rising,`
359			`D1 => CMD_NOP,`
360			`R => '0',`
361			`S => '0' );`
362
363			`DRAM_ADDR_ODDR2: oddr2_13`
364			`port map(`
365			`Q => dram_addr,`
366			`C0 => clk_270,`
367			`C1 => clk_090,`
368			`CE => '1',`
369			`D0 => addr_oddr2_rising,`
370			`D1 => "0000000000000",`
371			`R => '0',`
372			`S => '0' );`
373
374			`DQS_SWITCH: inout_switch_2`
375			`port map(`
376			`ioport => dram_dqs,`
377			`dir => dqs_dir,`
378			`data_i => dqs_out`
379			`);`
380
381			`DQ_SWITCH: inout_switch_16`
382			`port map(`
383			`ioport => dram_dq,`
384			`dir => dq_dir,`
385			`data_o => dq_in,`
386			`data_i => dq_out`
387			`);`
388
389			`AR_NEEDED_CTR: wait_counter`
390			`generic map(`
391			`BITS => 10,`
392			`CLKS => AUTO_REFRESH_CLKS`
393			`)`
394			`port map (`
395			`clk => clk_000,`
396			`rst => need_ar_rst,`
397			`done => need_ar`
398			`);`
399
400			`WAIT_AR_CTR: wait_counter`
401			`generic map(`
402			`BITS => 4,`
403			`CLKS => 11`
404			`)`
405			`port map(`
406			`clk => clk_000,`
407			`rst => wait_ar_rst,`
408			`done => wait_ar_done`
409			`);`
410
411			`WRITE_RECOVER_CTR: wait_counter`
412			`generic map(`
413			`BITS => 2,`
414			`CLKS => WRITE_RECOVER_CLKS`
415			`)`
416			`port map(`
417			`clk => clk_000,`
418			`rst => write_reco_rst,`
419			`done => write_reco_done`
420			`);`
421
422			`READ_DONE_CTR: wait_counter`
423			`generic map(`
424			`BITS => 2,`
425			`CLKS => READ_DONE_CLKS`
426			`)`
427			`port map(`
428			`clk => clk_000,`
429			`rst => read_wait_rst,`
430			`done => read_wait_done`
431			`);`
432
433			`READER: sdram_reader`
434			`port map(`
435			`clk270 => clk_270,`
436			`rst => reader_rst,`
437			`dq => dq_in,`
438			`data0 => data0_o,`
439			`data1 => data1_o`
440			`);`
441
442			`WRITER: sdram_writer`
443			`port map(`
444			`clk => clk_000,`
445			`clk090 => clk_090,`
446			`clk180 => clk_180,`
447			`clk270 => clk_270,`
448			`rst => writer_rst,`
449	8	lynn0p	`addr => addr_save(0),`
450			`data_o => datai_save,`
451	2	lynn0p	`dqs => dqs_out,`
452			`dm => dram_dm,`
453	6	lynn0p	`dq => dq_out`
454	2	lynn0p	`);`
455			`-- end component allocs`
456	6	lynn0p
457			`debug_reg <= x"00";`
458	2	lynn0p	`dram_cs <= '0';`
459	8	lynn0p	`data_o <= data1_o when addr_save(0) = '1' else data0_o;`
460
461	17	lynn0p	`-- process (clk_000)`
462			`-- begin`
463			`-- if (cap_en = '1') then`
464			`-- if (rising_edge(clk_000)) then`
465			`-- addr_save <= addr;`
466			`-- datai_save <= data_i;`
467			`-- op_save <= op;`
468			`-- end if;`
469			`-- end if;`
470			`-- end process;`
471
472			`-- this will probably make the synthesizer scream bloody murder`
473			`-- over either a transparent latch or gated clock or both`
474			`-- but i've got it working again with my SoC and I'll see about`
475			`-- changing it back to something less icky later`
476	11	lynn0p	`-- capture addr, data_i and op for the cmd fsm`
477	12	lynn0p	`-- op needs to be captured during AR or it might get dropped`
478	17	lynn0p	`addr_save <= addr when cap_en = '1' else addr_save;`
479			`datai_save <= data_i when cap_en = '1' else datai_save;`
480			`op_save <= op when cap_en = '1' else op_save;`
481	10	lynn0p
482	2	lynn0p	`-- command state machine`
483			`process (clk_000)`
484			`begin`
485			`if (rising_edge(clk_000)) then`
486			`if (dcm_locked = '1') then`
487			`case cmd_state is`
488			`when STATE_START =>`
489			`busy_n <= '0';`
490			`op_ack <= '0';`
491	8	lynn0p	`init_reset <= '1';`
492			`cap_en <= '0';`
493	2	lynn0p	`main_sel <= '0';`
494			`main_cmd <= CMD_NOP;`
495			`main_bank <= "00";`
496			`main_addr <= "0000000000000";`
497			`cmd_state <= STATE_INIT;`
498
499			`when STATE_INIT =>`
500			`init_reset <= '0';`

Browse

Tools

Subversion Repositories sdram_controller

[/] [sdram_controller/] [trunk/] [sdram.vhd] - Blame information for rev 17