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

--  version      = 1.0                             --

--  last update  = 31/5/01                        --

--  author       = Jose Nunez                      --

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

-- FUNCTION

-- Control unit that controls the input buffer

--  PIN LIST

--  START : enable the buffer

--  STOP : The whole file has access the internal buffers

--  FINISHED : the block has been processed in the compressor engine 

--  BUS_ACKNOWLEDGE : the uncompressed bus in is granted

--  CODING_READ_ADDRESS : input buffer location that it is being read

--  CODING_WRITE_ADDRESS : input buffer location that it is being written

--  CLK : clock

--  CLEAR : clear

--  BUS_REQUEST : the input buffer is being requested

--  READY : buffer ready with data to be processed in the compression engine

--  FULL : Data cannot be written to the buffer

--  CLEAR_COUNTERS : counters are reset. Counters generate the addresses to the buffers

--  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 INPUT_BUFFER_CU is

port

(

                OVERFLOW_CONTROL : in bit; -- to control possible overflows in the decoding input buffer

    FORCE_STOP : in bit;

          START : in bit;

          STOP  : in bit;

          WAITN : in bit;

          BUS_ACKNOWLEDGE : in bit;

          CODING_READ_ADDRESS : in bit_vector(7 downto 0);

          CODING_WRITE_ADDRESS : in bit_vector(7 downto 0);

          CLK : in bit;

          CLEAR : in bit;

          BUS_REQUEST : out bit;

    CLEAR_COUNTERS : out bit;

          RESET_TOTAL_COUNTER : out bit;

          ENABLE_PARSER : out bit;

          ENABLE_READ : out bit;

          ENABLE_WRITE : out bit

);

end INPUT_BUFFER_CU;

architecture STRUCTURAL of INPUT_BUFFER_CU is

signal CURRENT_STATE : bit_vector(3 downto 0);

signal NEXT_STATE : bit_vector(3 downto 0);

signal FINISHED_AUX : bit;

signal ENABLE_READ_INT : bit;

signal ENABLE_WRITE_INT : bit;

begin

STATES : process (START, STOP, CURRENT_STATE, FINISHED_AUX, CODING_READ_ADDRESS, CODING_WRITE_ADDRESS, BUS_ACKNOWLEDGE, WAITN, OVERFLOW_CONTROL)

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_INT <= '0';

                ENABLE_WRITE_INT <= '0';

                BUS_REQUEST <= '1';

            CLEAR_COUNTERS <= '1';

                RESET_TOTAL_COUNTER <='1';

         when "0001" =>  -- state 1 request the bus

                if (BUS_ACKNOWLEDGE = '0') then -- bus ready with data

                        NEXT_STATE <= "0010";

                else

                        NEXT_STATE <= CURRENT_STATE;

                end if;

                ENABLE_READ_INT <= '0';

                ENABLE_WRITE_INT <= '0';

                BUS_REQUEST <= '0';

        CLEAR_COUNTERS <= '1';

            RESET_TOTAL_COUNTER <= '0';

         when "0010" =>    -- start writting data to the input buffer. only writting

                if (WAITN = '1') then

                        NEXT_STATE <= "0011";  -- only start reading when wait is inactive

                else

                        NEXT_STATE <= CURRENT_STATE;

                end if;

                 ENABLE_READ_INT <= '0';

                 ENABLE_WRITE_INT <= '1';

                 BUS_REQUEST <= '0';

         CLEAR_COUNTERS <= '0';

             RESET_TOTAL_COUNTER <= '0';

         when "0011" => -- now writting and reading

                 if (STOP = '1' and BUS_ACKNOWLEDGE = '0' and WAITN = '1') then -- the whole file has accessed the internal buffer

                        NEXT_STATE <= "0101";

                 elsif (FINISHED_AUX = '1') then -- this can happen under wait states

                        NEXT_STATE <= "0010"; -- to write only

          -- elsif (CODING_WRITE_ADDRESS + "00000001" = CODING_READ_ADDRESS) then -- we have fill the buffer wait. About to overflow do not write more data

                 elsif ((CODING_WRITE_ADDRESS >= "10000000" or OVERFLOW_CONTROL = '1') and BUS_ACKNOWLEDGE = '0' and WAITN = '1') then -- we have fill the buffer wait. About to overflow do not write more data

                                NEXT_STATE <= "0100";

                 else

                        NEXT_STATE <= CURRENT_STATE;

                 end if;

      ENABLE_WRITE_INT <= '1';

                 ENABLE_READ_INT  <= '1';

                 BUS_REQUEST <= '0';

     CLEAR_COUNTERS <= '0';

           RESET_TOTAL_COUNTER <= '0';

         when "0100" => -- waiting for engine to finish the block

      if(STOP = '1') then

                                NEXT_STATE <= "0101";

                 elsif (FINISHED_AUX = '1' and OVERFLOW_CONTROL = '0') then

                          NEXT_STATE <= "0001"; --write new data to the bus 

                 else

                      NEXT_STATE <= CURRENT_STATE;

                 end if;

         ENABLE_WRITE_INT <= '0';

                 ENABLE_READ_INT  <= '1';

                 BUS_REQUEST <= '1';

      CLEAR_COUNTERS <= '0';

            RESET_TOTAL_COUNTER <= '0';

         when "0101" => -- the whole file has acessed the buffers

                 if (FINISHED_AUX = '1') then  -- when the last block finishes it is over

                        NEXT_STATE <= "0000"; --go to first state 

                 else

                        NEXT_STATE <= CURRENT_STATE;

                 end if;

                 ENABLE_WRITE_INT <= '0';

                 ENABLE_READ_INT  <= '1';

                 BUS_REQUEST <= '1';

         CLEAR_COUNTERS <= '0';

                 RESET_TOTAL_COUNTER <= '0';

         when others =>

        NEXT_STATE <= "0000";

                ENABLE_READ_INT <= '0';

                ENABLE_WRITE_INT <= '0';

                BUS_REQUEST <= '1';

        CLEAR_COUNTERS <= '0';

            RESET_TOTAL_COUNTER <= '0';

end  case;

end process STATES;

FINISHED_AUX <= '1' when (CODING_WRITE_ADDRESS = CODING_READ_ADDRESS) else '0'; -- detect when all data has accessed the engine

ENABLE_READ <= ENABLE_READ_INT and not(FINISHED_AUX);

ENABLE_WRITE <= ENABLE_WRITE_INT and not(STOP);

PARSER_FF: process(CLK,CLEAR)

begin

if (CLEAR = '0') then

        ENABLE_PARSER <= '0'; --state 0

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

         if (FINISHED_AUX = '1') then

                ENABLE_PARSER <= '0';

         else

                ENABLE_PARSER <= ENABLE_READ_INT; -- parser follows the memory read enable

         end if;

end if;

end process PARSER_FF;

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"; --state 0

     else

                        CURRENT_STATE <= NEXT_STATE;

     end if;

end if;

end process FLIP_FLOPS;

end STRUCTURAL;