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       = CODING_BUFFER_CU                --

--  version      = 1.0                             --

--  last update  = 1/5/00                        --

--  author       = Jose Nunez                      --

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

-- FUNCTION

-- Control unit that controls the coding buffer

--  PIN LIST

--  START : enable writting to the buffer

--  FINISHED : the block has been process output the data that it is left in the buffer

--  OVERFLOW = 64 bit of compressed data available.

--  THRESHOLD : start reading from the buffer

--  CODING_READ_ADDRESS : buffer location that it is being read

--  CODING_WRITE_ADDRESS : buffer location that it is being written

--  CLK : clock

--  CLEAR : clear

--  CODING_OVERFLOW : the CU detects a coding overflow stop inputting uncompressed data 

--  CODING_UNDERFLOW : the CU detects a coding underflow stop outputting compressed data

--  ENABLE_WRITE : enable writting to the buffer

--  ENABLE_READ : enable reading from the buffer

library ieee;

use ieee.std_logic_1164.all;

library dzx;

use dzx.bit_arith.all;

use dzx.bit_utils.all;

entity CODING_BUFFER_CU is

port

(

    FORCE_STOP : in bit;

    WAITN : in bit;

          START : in bit;

          FINISHED : in bit;

          BUS_ACKNOWLEDGE : in bit;

          THRESHOLD_LEVEL : in bit_vector(8 downto 0);

          CODING_READ_ADDRESS : in bit_vector(8 downto 0);

          CODING_WRITE_ADDRESS : in bit_vector(8 downto 0);

          CLK : in bit;

          CLEAR : in bit;

          BUS_REQUEST : out bit;

          FLUSHING : out bit;

          CODING_OVERFLOW : out bit;

          CODING_UNDERFLOW : out bit;

          ENABLE_WRITE : out bit;

          FINISH : out bit; -- the buffer process

      CLEAR_COUNTERS : out bit;

          ENABLE_READ : out bit

);

end CODING_BUFFER_CU;

architecture STRUCTURAL of CODING_BUFFER_CU is

signal CURRENT_STATE : bit_vector(3 downto 0);

signal NEXT_STATE : bit_vector(3 downto 0);

signal CODING_OVERFLOW_AUX : bit;

signal CODING_UNDERFLOW_AUX : bit;

signal FLUSHING_AUX : bit;

signal FINISH_OP : bit; -- data valid control next state is finish

signal ENABLE_WRITE_AUX : bit;

begin

STATES : process (FINISH_OP, START, THRESHOLD_LEVEL, CURRENT_STATE, FINISHED, CODING_UNDERFLOW_AUX, CODING_OVERFLOW_AUX, CODING_READ_ADDRESS, CODING_WRITE_ADDRESS, BUS_ACKNOWLEDGE)

begin

case CURRENT_STATE is

        when "0000" =>  -- state 0 buffer inactive

                if (START = '0') then

                        NEXT_STATE <= "0001";

                else

                        NEXT_STATE <= CURRENT_STATE;

                end if;

                ENABLE_READ <= '0';

                ENABLE_WRITE_AUX <= '0';

                BUS_REQUEST <= '1';

                FLUSHING_AUX <= '1';

                FINISH <= '1';

            CLEAR_COUNTERS <= '1';

         when "0001" =>  -- state 1 start adding data to the buffer

                if (FINISHED = '0') then

                        NEXT_STATE <= "1001"; -- request the bus but do not write

                elsif (CODING_WRITE_ADDRESS - CODING_READ_ADDRESS > THRESHOLD_LEVEL) then

                        NEXT_STATE <= "0110"; -- request the bus

                else

                        NEXT_STATE <= CURRENT_STATE;

                end if;

                ENABLE_READ <= '0';

                ENABLE_WRITE_AUX <= '1';

                BUS_REQUEST <= '1';

                FLUSHING_AUX <= '1';

                FINISH <= '1';

            CLEAR_COUNTERS <= '0';

         when "0010" =>    -- state 2 writting and reading data

             if (FINISHED = '0') then -- finished active low

                    NEXT_STATE <= "0101"; -- empty the buffer

                 elsif (CODING_OVERFLOW_AUX = '0') then

                        NEXT_STATE <= "0011"; -- stop writting data

                 elsif (CODING_UNDERFLOW_AUX = '1') then

                        NEXT_STATE <= "0100"; -- stop reading data

                 else

                        NEXT_STATE <= CURRENT_STATE;

                 end if;

                 ENABLE_READ <= '1';

                 ENABLE_WRITE_AUX <= '1';

                 BUS_REQUEST <= '0';

                 FLUSHING_AUX <= '1';

             FINISH <= '1';

             CLEAR_COUNTERS <= '0';

         when "0011" => -- only reading

                 if (CODING_OVERFLOW_AUX = '1') then

                        NEXT_STATE <= "0010";

                 else

                NEXT_STATE <= CURRENT_STATE;

                 end if;

                 ENABLE_WRITE_AUX <= '0';

                 ENABLE_READ  <= '1';

                 BUS_REQUEST <= '0';

             FLUSHING_AUX <= '1';

                 FINISH <= '1';

             CLEAR_COUNTERS <= '0';

         when "0100" => -- only writting

           if (FINISHED = '0') then

                                NEXT_STATE <= "1001"; -- request the bus but do not write

                 elsif (CODING_WRITE_ADDRESS - CODING_READ_ADDRESS > THRESHOLD_LEVEL) then

                                NEXT_STATE <= "0110"; --request the bus 

                 else

                                NEXT_STATE <= CURRENT_STATE;

                 end if;

                 ENABLE_WRITE_AUX <= '1';

                 ENABLE_READ  <= '0';

                 BUS_REQUEST <= '1';

             FLUSHING_AUX <= '1';

             FINISH <= '1';

             CLEAR_COUNTERS <= '0';

        when "1001" => -- continue to request but do not write or read

                  if (BUS_ACKNOWLEDGE = '0') then

                        NEXT_STATE <= "0101";  -- only read ( from memory empty the buffer)

                  else

                    NEXT_STATE <= CURRENT_STATE;

                  end if;

                 ENABLE_WRITE_AUX <= '0';

                 ENABLE_READ  <= '0';

                 BUS_REQUEST <= '0';

                 FLUSHING_AUX <= '0';

                 FINISH <= '1';

                CLEAR_COUNTERS <= '0';

         when "0101" => -- emptying the buffer only reading

                 if (FINISH_OP = '1') then

                        NEXT_STATE <= "1000";  -- end 

                 else

                NEXT_STATE <= CURRENT_STATE;

                 end if;

                 ENABLE_WRITE_AUX <= '0';

                 ENABLE_READ  <= '1';

                 BUS_REQUEST <= '0';

             FLUSHING_AUX <= '0';

             FINISH <= '1';

             CLEAR_COUNTERS <= '0';

         when "0110" => -- request the bus

                 if (FINISHED = '0') then

                          NEXT_STATE <= "1001"; -- request the bus but do not write. nothing else to write

           elsif(CODING_OVERFLOW_AUX = '0') then

                    NEXT_STATE <="0111"; -- stop writting continue request

                 elsif (BUS_ACKNOWLEDGE = '0') then

                          NEXT_STATE <= "0010";  -- read and write  

                 else

               NEXT_STATE <= CURRENT_STATE;

                 end if;

                 ENABLE_WRITE_AUX <= '1';

                 ENABLE_READ  <= '0';

                 BUS_REQUEST <= '0';

                 FLUSHING_AUX <= '1';

                 FINISH <= '1';

                 CLEAR_COUNTERS <= '0';

         when "0111" => -- request the bus

                 if (BUS_ACKNOWLEDGE = '0') then

                        NEXT_STATE <= "0010";  -- read and write  

                 else

                NEXT_STATE <= CURRENT_STATE;

                 end if;

                 ENABLE_WRITE_AUX <= '0';

                 ENABLE_READ  <= '0';

                 BUS_REQUEST <= '0';

      FLUSHING_AUX <= '1';

      FINISH <= '1';

      CLEAR_COUNTERS <= '0';

         when "1000" =>

                 NEXT_STATE <= "0000";

                 ENABLE_WRITE_AUX <= '0';

                 ENABLE_READ  <= '0';

                 BUS_REQUEST <= '1';

         FLUSHING_AUX <= '1';

         FINISH <= '0';

         CLEAR_COUNTERS <= '0';

         when others =>

        NEXT_STATE <= "0000";

                ENABLE_READ <= '0';

                ENABLE_WRITE_AUX <= '0';

                BUS_REQUEST <= '1';

                FLUSHING_AUX <= '1';

                FINISH <= '1';

        CLEAR_COUNTERS <= '0';

end  case;

end process STATES;

CODING_OVERFLOW_AUX <= '0' when ((CODING_READ_ADDRESS(8 downto 1) = CODING_WRITE_ADDRESS(8 downto 1) + "00000001") and ENABLE_WRITE_AUX = '1') else '1'; -- direct output error condition

CODING_UNDERFLOW_AUX <= '1' when (CODING_WRITE_ADDRESS(8 downto 1) = CODING_READ_ADDRESS(8 downto 1) + "00000001") else '0';

-- coding undeflow active when read address > write address

CODING_OVERFLOW <= CODING_OVERFLOW_AUX;

-- only coding underflow if not in flusing state

-- coding underflow if coding_write_address = coding_read address => about to finish

-- data valid control

FINISH_OP <= '1' when (CODING_WRITE_ADDRESS = CODING_READ_ADDRESS and WAITN = '1') else '0'; -- only finish when WAITN is inactive

CODING_UNDERFLOW <= (CODING_UNDERFLOW_AUX and FLUSHING_AUX) or FINISH_OP;

FLUSHING <= FLUSHING_AUX;

ENABLE_WRITE <= ENABLE_WRITE_AUX;

FLIP_FLOPS : process(CLK, CLEAR)

begin

if (CLEAR = '0') then

        CURRENT_STATE <= "0000"; --state 0

elsif ((CLK'event) and (CLK='1')) then

     if (FORCE_STOP = '0') then

                                CURRENT_STATE <= "0000";

     else

                                CURRENT_STATE <= NEXT_STATE;

     end if;

end if;

end process FLIP_FLOPS;

end STRUCTURAL;