Subversion Repositories xmatchpro

--This library is free software; you can redistribute it and/or
--modify it under the terms of the GNU Lesser General Public
--License as published by the Free Software Foundation; either
--version 2.1 of the License, or (at your option) any later version.
 
--This library is distributed in the hope that it will be useful,
--but WITHOUT ANY WARRANTY; without even the implied warranty of
--MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
--Lesser General Public License for more details.
 
--You should have received a copy of the GNU Lesser General Public
--License along with this library; if not, write to the Free Software
--Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-- e_mail : j.l.nunez-yanez@byacom.co.uk
 
-----------------------------------------------------
--  ENTITY       = RLI_CCU (RLI Coding Control Unit)   --
--  version      = 1.0                             --
--  last update  = 6/6/01                        --
--  author       = Jose Nunez                      --
-----------------------------------------------------
 
 
-- FUNCTION
-- State machine to control the RLI coding process
 
 
--  PIN LIST
--  CODE_IN : 35 bits of normal compressed code
--  LENGTH_IN : 6 bits indicating how many bits valid in CODE_IN
--  COUNT : number of repetitions in a run length
--  RL_DETECTED : run length detection
--  CLEAR : asyncronus clear
--  CLK : master clk
--  CODE_OUT : code output 35 bits
--  LENGTH_OUT : length output 
 
library ieee;
use ieee.std_logic_1164.all;
library dzx;
use dzx.bit_arith.all;
 
entity RLI_CCU is
port
(
      CODE_IN : in bit_vector(34 downto 0) ;
	  MOVE_ENABLE_IN : in bit;
	  FLUSH_IN : in bit;
	  LENGTH_IN : in bit_vector (5 downto 0);
	  CODE_RLI : in bit_vector(4 downto 0);
	  CODE_RLI_LENGTH : in bit_vector(2 downto 0);
	  COUNT : in bit_vector(7 downto 0);
	  RL_DETECTED : in bit;
      CLEAR : in bit ;
	  RESET: in bit;
      CLK : in bit ;
      CODE_OUT : out bit_vector(34 downto 0);
 	  LENGTH_OUT : out bit_vector(5 downto 0)
);
end RLI_CCU;
 
 
architecture STRUCTURAL of RLI_CCU is
 
signal CURRENT_STATE : bit_vector(1 downto 0);
signal NEXT_STATE : bit_vector(1 downto 0);
signal COUNT_AUX: bit_vector(7 downto 0);
signal LENGTH_AUX: bit_vector(5 downto 0);
signal TOTAL_LENGTH: bit_vector(5 downto 0);
signal CODE_RLI_INT : bit_vector(34 downto 0);
signal CODE_RLI_STORED : bit_vector(4 downto 0);
signal CODE_RLI_LENGTH_STORED : bit_vector(2 downto 0);
signal CODE_OUT_AUX : bit_vector(34 downto 0);
signal LENGTH_OUT_AUX : bit_vector(5 downto 0);
 
begin
 
STATES : process (MOVE_ENABLE_IN, FLUSH_IN,RL_DETECTED,CURRENT_STATE,CODE_IN,LENGTH_IN, TOTAL_LENGTH,CODE_RLI_INT)
begin
 
case CURRENT_STATE is
		when "00" =>  -- state 0 normal output
			if (RL_DETECTED = '1') then 
				NEXT_STATE <= "01";
			else
				NEXT_STATE <= CURRENT_STATE;
			end if;
       if (MOVE_ENABLE_IN = '1' and FLUSH_IN = '1') then
 					CODE_OUT_AUX <= "00000000000000000000000000000000000";
					LENGTH_OUT_AUX <= "000000"; 
			else
					CODE_OUT_AUX <= CODE_IN;
					LENGTH_OUT_AUX <= LENGTH_IN;
  			end if;
 
		 when "01" =>  -- state 1 length set to zero
  		 	if (RL_DETECTED = '0' or FLUSH_IN = '0') then -- flush indicates terminate by flushing
		   		NEXT_STATE <= "11";
			else
				NEXT_STATE <= "10";
			end if;
			CODE_OUT_AUX <= "00000000000000000000000000000000000";
			LENGTH_OUT_AUX <= "000000";
 
		 when "10" =>  -- state 1 length set to zero
		 	if (RL_DETECTED = '0' or FLUSH_IN = '0') then
		   		NEXT_STATE <= "11";
			else
				NEXT_STATE <= CURRENT_STATE;
			end if;
				CODE_OUT_AUX <= "00000000000000000000000000000000000";
				LENGTH_OUT_AUX <= "000000";
		 when "11" =>    -- state 2 output RL code 
	 		if (RL_DETECTED = '0') then
	   			NEXT_STATE <= "00";
			else
				NEXT_STATE <= "01";
			end if;
			CODE_OUT_AUX <= CODE_RLI_INT; -- take the match loc from input add the special match type for RL and the count
			LENGTH_OUT_AUX <= TOTAL_LENGTH; -- length out 16 or 10 one bit for the match
		 when others =>
			NEXT_STATE <= "00";
			CODE_OUT_AUX <= "00000000000000000000000000000000000";
			LENGTH_OUT_AUX <= "000000";
end  case;    	
 
end process STATES;
 
-- CODE_OUT <= CODE_OUT_AUX when MOVE_ENABLE_IN = '0' else "00000000000000000000000000000000000";
-- LENGTH_OUT <= LENGTH_OUT_AUX when MOVE_ENABLE_IN = '0' else "000000"; 
 
CODE_OUT <= CODE_OUT_AUX;
LENGTH_OUT <= LENGTH_OUT_AUX;
 
-- store RLI code inmediatly after RL is detected before NFL is incremented
 
STORED_RLI : process(CLK, CLEAR)
begin 
 
if (CLEAR = '0') then
	CODE_RLI_STORED <= "00000";
	CODE_RLI_LENGTH_STORED <= "000";
elsif ((CLK'event) and (CLK='1')) then
	if (RESET = '0') then
		CODE_RLI_STORED <= "00000";
		CODE_RLI_LENGTH_STORED <= "000";	
	elsif (CURRENT_STATE = "01") then -- save the first RLI code
		CODE_RLI_STORED <= CODE_RLI;
		CODE_RLI_LENGTH_STORED <= CODE_RLI_LENGTH;
	else
		CODE_RLI_STORED <= CODE_RLI_STORED;
		CODE_RLI_LENGTH_STORED <= CODE_RLI_LENGTH_STORED;
	end if;
end if;
 
end process STORED_RLI;
 
 
 
-- use 8 bits or 2 bits if the run length position is higher than zero
 
COUNT_AUX <= COUNT when CODE_RLI_STORED(3 downto 0)="0000" else COUNT(1 downto 0)&"000000";
LENGTH_AUX <= "001011" when CODE_RLI_STORED(3 downto 0)="0000" else "000101"; -- run length plus RLI type length (3)
TOTAL_LENGTH <= ("00" & CODE_RLI_LENGTH_STORED) + LENGTH_AUX; 
 
BUILD_RLI_CODE : process(CODE_RLI_STORED, CODE_RLI_LENGTH_STORED, COUNT_AUX)
begin
case CODE_RLI_LENGTH_STORED is
	when "001" => CODE_RLI_INT <= CODE_RLI_STORED(4) & "011" & COUNT_AUX & "00000000000000000000000";
	when "010" => CODE_RLI_INT <= CODE_RLI_STORED(4 downto 3) & "011" & COUNT_AUX & "0000000000000000000000";
	when "011" => CODE_RLI_INT <= CODE_RLI_STORED(4 downto 2) & "011" & COUNT_AUX & "000000000000000000000";
	when "100" => CODE_RLI_INT <= CODE_RLI_STORED(4 downto 1) & "011" & COUNT_AUX & "00000000000000000000";
	when "101" => CODE_RLI_INT <= CODE_RLI_STORED(4 downto 0) & "011" & COUNT_AUX & "0000000000000000000";
	when others => CODE_RLI_INT <= "00000000000000000000000000000000000";
end case;
 
 
end process BUILD_RLI_CODE;
 
 
FLIP_FLOPS : process(CLK, CLEAR)
begin 
 
if (CLEAR = '0') then
	CURRENT_STATE <= "00"; --state 0
elsif ((CLK'event) and (CLK='1')) then
	if (RESET = '0') then
		CURRENT_STATE <= "00"; --state 0
	else
		CURRENT_STATE <= NEXT_STATE;
	end if;
end if;
 
end process FLIP_FLOPS;
 
 
 
end STRUCTURAL;