Subversion Repositories ddr2_sdram

---------------------------------------------------------------------
-- File :			DDR2_Control_VHDL.vhd
-- Projekt :		Prj_12_DDR2
-- Zweck :			DDR2-Verwaltung (Init,Read,Write)
-- 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 :
	--
	-- das DDR2-RAM hat 512 MBit (64MByte) Speicherplatz
	-- organisiert in 16Bit Woertern
	--
	-- es werden immer Datenworte von 64Bit ausgelesen
	-- oder geschrieben (weil der Burst-Mode auf 4 steht)
	-- aus dem Grund ist der Daten-Vektor für Read/Write
	-- 64Bit breit
	--
	-- das RAM ist ein 4 Blöcke unterteilt (zu je 16Mbyte)
	-- Bank "00" bis Bank "11" : 2Bit
	--
	-- jeder Block ist in 8192 Reihen zu je 1024 Spalten organisiert
	-- ROW "0000000000000" bis "1111111111111" : 13Bit
	-- COL "0000000000" bis "1111111111" : 10Bit
	--
	-- die übergebene Adresse an die FIFO Komponente
	-- mit 25 Bit setzt sich dann so zusammen
	--
	-- input_adress =  ROW & COL & BANK
	--    (25Bit)     13Bit 10Bit  2Bit
	-- pro Adresse stehen 16bit Daten
	-- 
	-- in diesem Demo-Programm wird nur Bank=0
	-- COL=0 und ROW= 0 bis 15 benutzt
	---------------------------------------------
	--
	-- das CONTROL steuert die READ und WRITE funktion
	-- je nachdem welcher Button gedrückt wurde
	--
	--------------------------------------------
	-- Vorsicht !! zur Adressierung :
	-- Der Burst-Mode steht FIX auf "4"
	-- damit werden IMMER 4 (16bit) Zellen gelesen
	-- und beschrieben (also imer 64Bit)
	--
	-- wenn also das 64bit Wort "123456789ABCDEF0" in Adr 0
	-- geschrieben wird, sieht der Speicher danach so aus :
	-- Row 0 Col 0 = "1234"
	-- Row 0 Col 1 = "5678"
	-- Row 0 Col 2 = "9ABC"
	-- Row 0 Col 3 = "DEF0"
	--
	-- Der Col-Counter muss also immer um 4 Adressen
	-- incrementiert / decrementiert werden
	--
	-- in der Demo hier wird nur der ROW-Counter verändert
	-- 
	--------------------------------------------
 
 
 
entity DDR2_Control_VHDL is
 
	--------------------------------------------
	-- Port Deklerationen
	--------------------------------------------
	port (
		reset_in : in std_logic;
		clk_in : in std_logic;
		clk90_in : in std_logic;		
		init_done : in std_logic;
		command_register : out std_logic_vector(2 downto 0);
		input_adress : out std_logic_vector(24 downto 0);
		input_data : out std_logic_vector(31 downto 0);
		output_data : in std_logic_vector(31 downto 0);
		cmd_ack : in std_logic;
		data_valid : in std_logic;
		burst_done : out std_logic;
		auto_ref_req : in std_logic;
		debounce_in : in std_logic_vector(7 downto 0);
		risingedge_in : in std_logic_vector(3 downto 0);
		data_out : out std_logic_vector(7 downto 0)
	);
 
end DDR2_Control_VHDL;
 
architecture Verhalten of DDR2_Control_VHDL is
 
	--------------------------------------------
	-- Einbinden einer Componente
	-- zum schreiben eines 64Bit Wertes
	--------------------------------------------
	COMPONENT DDR2_Write_VHDL
	PORT (
		reset_in : in std_logic;
		clk_in : in std_logic;
		clk90_in : in std_logic;	
		w_command_register : out std_logic_vector(2 downto 0);
		w_cmd_ack : in std_logic;
		w_burst_done : out std_logic;
		write_en : in std_logic;
		write_busy : out std_logic;
		input_data : out std_logic_vector(31 downto 0);
		write_data : in std_logic_vector(63 downto 0)
	);
	END COMPONENT DDR2_Write_VHDL;
 
	--------------------------------------------
	-- Einbinden einer Componente
	-- zum lesen eines 64Bit Wertes
	--------------------------------------------
	COMPONENT DDR2_Read_VHDL
	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 COMPONENT DDR2_Read_VHDL;	
 
	--------------------------------------------
	-- Interne Signale
	--------------------------------------------
 
	constant INIT_PAUSE : integer := 133000; -- pause 1ms (Wichtig !!)
	signal v_counter :  natural range 0 to INIT_PAUSE := INIT_PAUSE;	
 
	--------------------------------------------
	-- 16 Konstante Werte erzeugen, die beim INIT
	-- (Auto-Write) ins RAM geschrieben werden
	-- ein Wert ist 64Bit = 8 Byte breit
	--------------------------------------------
	constant MAX_ADR : integer := 15; -- 0 bis 15 = 16 Werte
	type RAM_DATA_TYP is array (0 to MAX_ADR) of std_logic_vector(63 downto 0);
	constant RAM_DATA : RAM_DATA_TYP :=
	(
		x"0123456789ABCDEF", x"123456789ABCDEF0", x"23456789ABCDEF01", x"3456789ABCDEF012",
		x"456789ABCDEF0123", x"56789ABCDEF01234", others => (x"639CC6398C7318E7")
	);
	signal v_array_pos :  natural range 0 to MAX_ADR+1 := 0;	
 
	--------------------------------------------
	-- Definition der ROW,COL,BANK adressen
	--------------------------------------------
	signal v_ROW : std_logic_vector(12 downto 0):= (others => '0'); -- 13Bit
	signal v_COL : std_logic_vector(9 downto 0):= (others => '0');  -- 10Bit
	signal v_BANK : std_logic_vector(1 downto 0):= (others => '0'); -- 2Bit
 
	-- zwischenspeicher fuer daten
	signal v_write_data : std_logic_vector(63 downto 0):= (others => '0');	
	signal v_read_data : std_logic_vector(63 downto 0):= (others => '0');		
 
	--------------------------------------------
	-- Ein Konstanter Wert, der mit WRITE-Button
	-- ins RAM geschrieben wird
	--------------------------------------------	
	constant CONST_DATA : std_logic_vector(63 downto 0):= x"31CE629DC43B8877";
 
	--------------------------------------------
	-- State-Machine-Typen
	--------------------------------------------	
	type STATE_M_TYPE is (
		M1_START_UP,
		M2_WAIT_4_DONE,
		M3_AUTO_WRITE_START,
		M4_AUTO_WRITE_INIT,
		M5_AUTO_WRITING,
		M6_AUTO_READ_INIT,
		M7_AUTO_READING,
		M8_NOP,
		M9_WRITE_INIT,
		M10_WRITING,
		M11_READ_INIT,
		M12_READING
	);
	signal STATE_M : STATE_M_TYPE := M1_START_UP;	
 
	--------------------------------------------
	-- sonstige Signale
	--------------------------------------------		
	signal v_write_en : std_logic:='0'; -- '1'=chip-select
	signal v_read_en : std_logic:='0'; -- '1'=chip-select
	signal v_write_busy : std_logic; -- '1'=belegt, '0'=frei
	signal v_read_busy : std_logic; -- '1'=belegt, '0'=frei
	signal v_main_command_register : std_logic_vector(2 downto 0):= (others => '0');
	signal v_write_command_register : std_logic_vector(2 downto 0):= (others => '0');
	signal v_read_command_register : std_logic_vector(2 downto 0):= (others => '0');
	signal v_write_burst_done : std_logic;
	signal v_read_burst_done : std_logic;	
 
begin
 
	--------------------------------------------------
	-- Instantz einer Componente erzeugen und verbinden
	-- zum schreiben eines 64Bit Wertes
	--------------------------------------------------
	INST_DDR2_Write_VHDL : DDR2_Write_VHDL
	PORT MAP (
		reset_in => reset_in,
		clk_in => clk_in,
		clk90_in => clk90_in,
		w_command_register => v_write_command_register,
		w_cmd_ack => cmd_ack,
		w_burst_done => v_write_burst_done,
		write_en => v_write_en,
		write_busy => v_write_busy,
		input_data => input_data,
		write_data => v_write_data
	);
 
	--------------------------------------------------
	-- Instantz einer Componente erzeugen und verbinden
	-- zum lesen eines 64Bit Wertes
	--------------------------------------------------
	INST_DDR2_Read_VHDL : DDR2_Read_VHDL
	PORT MAP (
		reset_in => reset_in,
		clk_in => clk_in,
		clk90_in => clk90_in,
		r_command_register => v_read_command_register,
		r_cmd_ack => cmd_ack,
		r_burst_done => v_read_burst_done,	
		r_data_valid => data_valid,	
		read_en => v_read_en,
		read_busy => v_read_busy,
		output_data => output_data,
		read_data => v_read_data
	);		
 
	-----------------------------------------
	-- State-Machine :
	--   1. wartet nach Reset 1ms
	--   2. sendet das INIT-Kommando an das RAM
	--   3. Wartet auf das INIT_DONE vom RAM
	--   4. Schreiben von 16 Datenwerten ins RAM
	--   5. Auslesen von Adr0
	--   6. Warte auf Tastendrück
	--
	--     7a. North/South = ändern der Adresse (ROW)
	--     7b. East = auslesen eines Wertes
	--     7c. West = schreiben eines Wertes
	--   8. Sprung zu Punkt 6
	-----------------------------------------	
	P_State_Main : process(clk_in,reset_in)
	begin
		if reset_in = '1' then
			-- reset button ist gedrueckt
			STATE_M <= M1_START_UP;
			v_write_en <= '0';
			v_read_en <= '0';
			v_main_command_register <= "000"; -- NOP
			v_counter <= INIT_PAUSE;			
			v_ROW <= (others => '0');	
			v_COL <= (others => '0');
			v_BANK <= (others => '0');
			v_array_pos	<= 0;
		elsif falling_edge(clk_in) then
			case STATE_M is
			   -----------------------------------------------------
				-- INITIALISIERUNG vom RAM : WICHTIG !! :
				-- nach dem Reset wird 1ms gewartet und danach
				-- wird das INIT-Kommando an das RAM gesendet
				-- und auf das Init-Done-Signal vom RAM gewartet
				-----------------------------------------------------
				when M1_START_UP =>
					-- warte 1ms nach Reset bis RAM bereit
					-- WICHTIG !! das steht so im Datasheet
					if v_counter = 0 then					
						-- nach 1ms INIT-Kommando (für einen Clock) anlegen
						STATE_M <= M2_WAIT_4_DONE;
						v_main_command_register <= "010";	-- INIT-CMD	
					else 
						v_main_command_register <= "000"; -- NOP
						v_counter <= v_counter - 1;
					end if;	
				when M2_WAIT_4_DONE =>
					-- warte auf Init-Done-Signal vom RAM
					v_main_command_register <= "000"; -- NOP
					if (init_done = '1') then
						-- das RAM ist jetzt bereit
						STATE_M <= M3_AUTO_WRITE_START;	
					end if;
			   -----------------------------------------------------
				-- automatisches schreiben von ein paar Werten :
				-- es werden 16 feste Datenwerte in die Adressen 0-15
				-- ins RAM geschrieben
				-----------------------------------------------------					
				when M3_AUTO_WRITE_START =>
					-- automatisches schreiben von daten ins RAM
					if v_array_pos > MAX_ADR then
						-- wenn alle adressen geschrieben sind
						STATE_M <= M6_AUTO_READ_INIT;
						v_ROW <= (others => '0');
					else
						if v_write_busy = '0' and auto_ref_req = '0' then
							-- wenn RAM nicht beschäftigt ist, starte das schreiben
							STATE_M <= M4_AUTO_WRITE_INIT;
						end if;
					end if;
				when M4_AUTO_WRITE_INIT =>					
					-- warten bis zum schreiben bereit
					if v_write_busy = '0' and v_write_en='0' then
						-- daten zum schreiben freigeben
						v_write_en <= '1';
					elsif v_write_busy = '1' and v_write_en='1' then
						-- daten werden geschrieben
						v_write_en <= '0';
						STATE_M <= M5_AUTO_WRITING;
					end if;
				when M5_AUTO_WRITING =>								
					-- warte bis schreiben fertig
					if v_write_busy = '0' then
						-- naechste adresse beschreiben						
						v_array_pos <= v_array_pos +1;
						v_ROW <= v_ROW +1;
						STATE_M <= M3_AUTO_WRITE_START;
					end if;	
			   -----------------------------------------------------
				-- automatisches lesen von einem Wert :
				-- es wird der Inhalt von Adr 0 vom RAM ausgelesen
				-----------------------------------------------------					
				when M6_AUTO_READ_INIT =>
					-- automatisches lesen vom RAM  (ein wert)
					-- warten bis zum lesen bereit
					if v_read_busy = '0' and v_read_en='0' and auto_ref_req = '0' then 
						-- daten zum lesen freigeben
						v_read_en <= '1';						
					elsif v_read_busy = '1' and v_read_en='1' then
						-- daten werden gelesen
						v_read_en <= '0';						
						STATE_M <= M7_AUTO_READING;
					end if;
				when M7_AUTO_READING =>
					-- warte bis lesen fertig
					if v_read_busy = '0' then						
						STATE_M <= M8_NOP;
					end if;					
			   -----------------------------------------------------
				-- Dauerloop : warten auf User-Eingabe :
				-- hier wird gewartet, bis einer der 4 Buttons
				-- gedrückt wurde
				-----------------------------------------------------						
				when M8_NOP =>
					-- warte auf Taste fuer READ oder WRITE
					v_write_en <= '0';
					v_read_en <= '0';					
					if risingedge_in(3) = '1' and v_write_busy = '0' and auto_ref_req = '0' then
						-- button = west
						-- write starten (nur wenn nicht busy und kein refresh-zyklus)
						STATE_M <= M9_WRITE_INIT;
					elsif risingedge_in(0) = '1' and v_read_busy = '0' and auto_ref_req = '0' then
					   -- button = east
						-- read starten (nur wenn nicht busy und kein refresh-zyklus)
						STATE_M <= M11_READ_INIT;
					end if;					
					-- warte auf Taste fuer Adr-Up oder Adr-Down								
					if risingedge_in(1)='1' and v_ROW < 255 then
						-- button = north
						v_ROW <= v_ROW + 1;
					elsif risingedge_in(2)='1' and v_ROW > 0 then
						-- button = south
						v_ROW <= v_ROW - 1;
					end if;
			   -----------------------------------------------------
				-- WRITE : schreiben eines Wertes ins RAM :
				-- ein fester Datenwert wird in die aktuelle Adresse
				-- ins RAM geschrieben
				-----------------------------------------------------						
				when M9_WRITE_INIT =>					
					-- warten bis zum schreiben bereit
					if v_write_busy = '0' and v_write_en='0' then
						-- daten zum schreiben freigeben
						v_write_en <= '1';
					elsif v_write_busy = '1' and v_write_en='1' then
						-- daten werden geschrieben
						v_write_en <= '0';
						STATE_M <= M10_WRITING;
					end if;
				when M10_WRITING =>								
					-- warte bis schreiben fertig
					if v_write_busy = '0' then
						STATE_M <= M8_NOP;
					end if;
			   -----------------------------------------------------
				-- READ : lesen eines Wertes vom RAM :
				-- die aktuelle Adresse vom RAM wird ausgelesen
				-----------------------------------------------------						
				when M11_READ_INIT =>					
					-- warten bis zum lesen bereit
					if v_read_busy = '0' and v_read_en='0' then 
						-- daten zum lesen freigeben
						v_read_en <= '1';
					elsif v_read_busy = '1' and v_read_en='1' then
						-- daten werden gelesen
						v_read_en <= '0';						
						STATE_M <= M12_READING;
					end if;
				when M12_READING =>
					-- warte bis lesen fertig
					if v_read_busy = '0' then						
						STATE_M <= M8_NOP;
					end if;									
				when others =>
					NULL;
			end case;
		end if;
	end process P_State_Main;	
 
	-----------------------------------------
	-- Weiterleitung von Signalen
	-- in Abhängigkeit von Read oder Write :
	-----------------------------------------	
	P_SIGNAL : process(clk_in)
	begin
		if falling_edge(clk_in) then
			if STATE_M=M4_AUTO_WRITE_INIT or STATE_M=M5_AUTO_WRITING then
			   -----------------------------------------------------
				-- automatisches schreiben von ein paar Werten
				-----------------------------------------------------	
				v_write_data <= RAM_DATA(v_array_pos);							
				input_adress <= v_ROW & v_COL & v_BANK;
				command_register <= v_write_command_register;
				burst_done <= v_write_burst_done;					
			elsif STATE_M=M6_AUTO_READ_INIT or STATE_M=M7_AUTO_READING then
			   -----------------------------------------------------
				-- automatisches lesen von einem Wert
				-----------------------------------------------------
				v_write_data <= (others => '0'); 				
				input_adress <= v_ROW & v_COL & v_BANK;
				command_register <= v_read_command_register;
				burst_done <= v_read_burst_done;				
			elsif STATE_M=M9_WRITE_INIT or STATE_M=M10_WRITING then
			   -----------------------------------------------------
				-- WRITE : schreiben eines Wertes ins RAM
				-----------------------------------------------------	
				v_write_data <= CONST_DATA;				
				input_adress <= v_ROW & v_COL & v_BANK;
				command_register <= v_write_command_register;
				burst_done <= v_write_burst_done;				
			elsif STATE_M=M11_READ_INIT or STATE_M=M12_READING then
			   -----------------------------------------------------
				-- READ : lesen eines Wertes vom RAM
				-----------------------------------------------------
				v_write_data <= (others => '0'); 				
				input_adress <= v_ROW & v_COL & v_BANK;
				command_register <= v_read_command_register;
				burst_done <= v_read_burst_done;				
			else
			   -----------------------------------------------------
				-- Dauerloop oder INIT
				-----------------------------------------------------	
				v_write_data <= (others => '0');				
				input_adress <= (others => '0');				
				command_register <= v_main_command_register;
				burst_done <= '0';				
			end if;
		end if;
	end process P_SIGNAL;
 
	-----------------------------------------
	-- Ausgabe der gelesenen Daten
	-- je nach Schalterstellung
	-----------------------------------------	
	P_DataOut : process(clk_in,reset_in)
	begin
		if reset_in = '1' then
			-- reset button ist gedrueckt
			data_out <= (others => '0');
		elsif falling_edge(clk_in) then
			if debounce_in(7 downto 5)="000" then data_out <= v_read_data(7 downto 0);
			elsif debounce_in(7 downto 5)="001" then data_out <= v_read_data(15 downto 8);
			elsif debounce_in(7 downto 5)="010" then data_out <= v_read_data(23 downto 16);
			elsif debounce_in(7 downto 5)="011" then data_out <= v_read_data(31 downto 24);
			elsif debounce_in(7 downto 5)="100" then data_out <= v_read_data(39 downto 32);
			elsif debounce_in(7 downto 5)="101" then data_out <= v_read_data(47 downto 40);
			elsif debounce_in(7 downto 5)="110" then data_out <= v_read_data(55 downto 48);
			elsif debounce_in(7 downto 5)="111" then data_out <= v_read_data(63 downto 56);
			end if;
			-------------------------------------------			
		end if;
	end process P_DataOut;
 
end Verhalten;