Subversion Repositories ddr2_sdram

---------------------------------------------------------------------

-- File :                       DDR2_Read_VHDL.vhd

-- Projekt :            Prj_12_DDR2

-- Zweck :                      DDR2-Read-Funktion

-- Datum :        19.08.2011

-- Version :      2.0

-- Plattform :    XILINX Spartan-3A

-- FPGA :         XC3S700A-FGG484

-- Sprache :      VHDL

-- ISE :                                ISE-Design-Suite V:13.1

-- Autor :        UB

-- Mail :         Becker_U(at)gmx.de

---------------------------------------------------------------------

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.STD_LOGIC_ARITH.ALL;

use IEEE.STD_LOGIC_UNSIGNED.ALL;

        --------------------------------------------

        -- Beschreibung :

        --

        -- Die State-Machine liest

        -- einen 64Bit Wert aus dem RAM

        -- von 4 aufeinander folgenden 16bit-Zellen

        --

        -- die Adresse wird

        -- von der übergeordneten CONTROL-Unit

        -- gehandelt

        -- 

        -- solange die Read-Funktion läuft,

        -- ist READ_BUSY=1

        --------------------------------------------

entity DDR2_Read_VHDL is

        --------------------------------------------

        -- Port Deklerationen

        --------------------------------------------

        port (

                reset_in : in std_logic;

                clk_in : in std_logic;

                clk90_in : in std_logic;

                r_command_register : out std_logic_vector(2 downto 0);

                r_cmd_ack : in std_logic;

                r_burst_done : out std_logic;

                r_data_valid : in std_logic;

                read_en : in std_logic;

                read_busy : out std_logic;

                output_data : in std_logic_vector(31 downto 0);

                read_data : out std_logic_vector(63 downto 0)

        );

end DDR2_Read_VHDL;

architecture Verhalten of DDR2_Read_VHDL is

        --------------------------------------------

        -- Interne Signale

        --------------------------------------------

        signal v_data_lsb : std_logic_vector(31 downto 0):=(others => '0');

        signal v_data_msb : std_logic_vector(31 downto 0):=(others => '0');

        constant CLK_ANZ : integer := 1;   -- warte 2 Clockzyklen (1 bis 0 = 2)

        signal v_counter :  natural range 0 to CLK_ANZ := CLK_ANZ;

        type STATE_RA_TYPE is (

                RA_1_NOP,

                RA_2_WAIT_4_ACK1,

                RA_3_WAIT_CLK,

                RA_4_SET_BURST,

                RA_5_SET_NOP,

                RA_6_WAIT_4_ACK0

        );

        signal STATE_RA : STATE_RA_TYPE := RA_1_NOP;

        type STATE_RB_TYPE is (

                RB_1_NOP,

                RB_2_WAIT_4_VALID1,

                RB_3_DATA_MSB,

                RB_4_WAIT_4_ACK0

        );

        signal STATE_RB : STATE_RB_TYPE := RB_1_NOP;

begin

        -----------------------------------------

        -- State-Machine RA : (Clock-0 Lo-Flanke)

        --   1. wartet auf das READ_EN=1 von der DDR2_Control

        --   2. sendet das READ-Kommando an das RAM

        --   3. wartet auf das ACK=1 vom RAM

        --   4. wartet 2 Clockzyklen

        --      (solange dauert das lesen von 64Bit)

        --   5. legt das BURST_DONE-Signal für 2 Clockzyklen an

        --   6. wartet auf das ACK=0 vom RAM

        --   7. Sprung zu Punkt 1

        -----------------------------------------       

        P_Read_RA : process(clk_in,reset_in)

        begin

                if reset_in = '1' then

                        r_burst_done <= '0';

                        r_command_register <= "000";

                        STATE_RA <= RA_1_NOP;

                elsif falling_edge(clk_in) then

                        -- Default Stellungen

                        r_burst_done <= '0';

                        r_command_register <= "000";

                        -- State-Machine

                        case STATE_RA is

                                when RA_1_NOP =>

                                        -- warten auf read enable signal                                        

                                        v_counter <= CLK_ANZ;

                                        if read_en = '1' then

                                                -- read enable wurde erkannt

                                                STATE_RA <= RA_2_WAIT_4_ACK1;

                                        end if;

                                when RA_2_WAIT_4_ACK1 =>

                                        -- READ-CMD anlegen

                                        -- warten auf ACK=1 signal      

                                        r_command_register <= "110";

                                        if r_cmd_ack = '1' then

                                                -- ack-signal wurde erkannt

                                                STATE_RA <= RA_3_WAIT_CLK;

                                        end if;

                                when RA_3_WAIT_CLK =>

                                        -- warte ein paar Clockzyklen

                                        r_command_register <= "110";

                                        if v_counter = 0 then

                                                STATE_RA <= RA_4_SET_BURST;

                                        else

                                                v_counter <= v_counter - 1;

                                        end if;

                                when RA_4_SET_BURST =>

                                        r_command_register <= "110";

                                        r_burst_done <= '1';

                                        STATE_RA <= RA_5_SET_NOP;

                                when RA_5_SET_NOP =>

                                        -- NOP-CMD anlegen      

                                        -- bei Burst_Done=Hi

                                        r_burst_done <= '1';

                                        STATE_RA <= RA_6_WAIT_4_ACK0;

                                when RA_6_WAIT_4_ACK0 =>

                                        -- burst_done auf Lo

                                        -- warten auf ACK=0 signal                                                                      

                                        if r_cmd_ack = '0' then

                                                -- ack-signal wurde erkannt

                                                STATE_RA <= RA_1_NOP;

                                        end if;

                                when others =>

                                        NULL;

                        end case;

                end if;

        end process P_Read_RA;

        -----------------------------------------

        -- State-Machine RB : (Clock-90 Hi-Flanke)

        --   1. wartet bis State-Machine-RA das

        --      READ-Kommando gesendet hat

        --   2. warte auf das DATA_VALID=1 vom RAM

        --   3. liest die LSB-Daten (32Bit) vom RAM

        --   4. wartet einen Clockzyklus

        --   5. liest die MSB-Daten (32Bit) vom RAM

        --   6. wartet auf das ACK=0 vom RAM

        --   7. Sprung zu Punkt 1

        -----------------------------------------       

        P_Read_RB : process(clk90_in,reset_in)

        begin

                if reset_in = '1' then

                        -- reset button ist gedrueckt

                        v_data_lsb <=  (others => '0');

                        v_data_msb <=  (others => '0');

                        STATE_RB <= RB_1_NOP;

                elsif rising_edge(clk90_in) then

                        case STATE_RB is

                                when RB_1_NOP =>

                                        -- warten bis Read enable                                                               

                                        if STATE_RA = RA_2_WAIT_4_ACK1 then

                                                -- ack-signal wurde erkannt

                                                STATE_RB <= RB_2_WAIT_4_VALID1;

                                        end if;

                                when RB_2_WAIT_4_VALID1 =>

                                        -- warte bis Daten Valid sind                                   

                                        if r_data_valid = '1' then

                                                -- LSB Daten sind ok

                                                v_data_lsb <= output_data;

                                                STATE_RB <= RB_3_DATA_MSB;

                                        else

                                                v_data_lsb <= v_data_lsb;

                                        end if;

                                when RB_3_DATA_MSB =>

                                        -- MSB Daten lesen

                                        if r_data_valid = '1' then

                                                -- MSB Daten sind ok    

                                                v_data_msb <= output_data;

                                        else

                                                v_data_msb <= v_data_msb;

                                        end if;

                                        STATE_RB <= RB_4_WAIT_4_ACK0;

                                when RB_4_WAIT_4_ACK0 =>

                                        -- warten auf ACK=0 vom RAM

                                        if r_cmd_ack = '0' then

                                                -- ack-signal wurde erkannt

                                                STATE_RB <= RB_1_NOP;

                                        end if;

                                when others =>

                                        NULL;

                        end case;

                end if;

        end process P_Read_RB;

        -----------------------------------------

        -- Read-Busy erzeugen :

        -- solange der Read-Prozess im Gange

        -- ist READ_BUSY = 1    

        -----------------------------------------               

        read_busy <= '0' when STATE_RA=RA_1_NOP else '1';

        -----------------------------------------

        -- Read-Data uebergeben :

        -- 64Bit zusammengesetzt aus MSB & LSB

        -----------------------------------------               

        read_data <= v_data_msb & v_data_lsb;

end Verhalten;