Subversion Repositories funbase_ip_library

-------------------------------------------------------------------------------
-- Title      : tb_agent
-- Project    : 
-------------------------------------------------------------------------------
-- File       : tb_agent.vhd
-- Author     : 
-- Company    : 
-- Created    : 2006-10-03
-- Last update: 2006-10-24
-- Platform   : 
-- Standard   : VHDL'87
-------------------------------------------------------------------------------
-- Description: Agent that sends request to sdram2hibi
-------------------------------------------------------------------------------
-- Copyright (c) 2006 
-------------------------------------------------------------------------------
-- Revisions  :
-- Date        Version  Author  Description
-- 2006-10-03  1.0      penttin5        Created
-------------------------------------------------------------------------------
 
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use work.txt_util.all;
 
entity tb_agent is
 
  generic (
    own_addr_g    : integer;
    check_rd_data : integer := 0;
    data_width_g  : integer;
    addr_width_g  : integer
    );
  port (
    clk          : in  std_logic;
    rst_n        : in  std_logic;
    req_out      : out std_logic;
    hold_out     : out std_logic;
    grant_in     : in  std_logic;
    comm_out     : out std_logic_vector(2 downto 0);
    data_out     : out std_logic_vector(data_width_g - 1 downto 0);
    addr_out     : out std_logic_vector(addr_width_g - 1 downto 0);
    re_out       : out std_logic;
    we_out       : out std_logic;
    full_in      : in  std_logic;
    one_p_in     : in  std_logic;
    data_in      : in  std_logic_vector(data_width_g - 1 downto 0);
    addr_in      : in  std_logic_vector(data_width_g - 1 downto 0);
    empty_in     : in  std_logic;
    one_d_in     : in  std_logic;
    msg_req_out  : out std_logic;
    msg_hold_out : out std_logic;
    msg_grant_in : in  std_logic;
    msg_full_in  : in  std_logic;
    msg_one_p_in : in  std_logic;
    msg_data_in  : in  std_logic_vector(data_width_g - 1 downto 0);
    msg_addr_in  : in  std_logic_vector(data_width_g - 1 downto 0);
    msg_empty_in : in  std_logic;
    msg_one_d_in : in  std_logic;
    msg_data_out : out std_logic_vector(data_width_g - 1 downto 0);
    msg_addr_out : out std_logic_vector(addr_width_g - 1 downto 0);
    msg_re_out   : out std_logic;
    msg_we_out   : out std_logic
    );
end tb_agent;
 
architecture behavioral of tb_agent is
 
  type state_vec_type is (idle,
                          req_write_port, req_read_port,
                          wait_write_port, wait_read_port,
                          conf_write_port, conf_read_port,
                          send_write_data);
  signal state_r : state_vec_type;
 
  type conf_state_type is (conf_dst_addr, conf_src_addr,
                           conf_amount, conf_height_offset,
                           conf_ret_addr);
  signal wr_conf_state : conf_state_type;
  signal rd_conf_state : conf_state_type;
  signal rd_port_addr  : std_logic_vector(data_width_g - 1 downto 0);
  signal wr_port_addr  : std_logic_vector(data_width_g - 1 downto 0);
 
  type chk_state_vec is (run_test, test_finished);
  signal chk_state_r : chk_state_vec;
  signal msg_we_r    : std_logic;
  signal we_r        : std_logic;
 
  signal dst_addr_r  : std_logic_vector(addr_width_g - 1 downto 0);
  signal src_addr_r  : std_logic_vector(addr_width_g - 1 downto 0);
  signal wr_amount_r : std_logic_vector(data_width_g - 1 downto 0);
  signal rd_amount_r : std_logic_vector(data_width_g - 1 downto 0);
  signal wr_count_r  : std_logic_vector(data_width_g - 1 downto 0);
  signal rd_count_r  : std_logic_vector(data_width_g - 1 downto 0);
 
  signal wr_data_r : std_logic_vector(data_width_g - 1 downto 0);
 
  signal chk_count_r  : std_logic_vector(data_width_g - 1 downto 0);
  signal chk_amount_r : std_logic_vector(data_width_g - 1 downto 0);
 
begin  -- behavioral
 
  msg_we_out <= msg_we_r;
  we_out     <= we_r;
 
  check_results : process (clk, rst_n)
  begin  -- process check_results
 
    if rst_n = '0' then                 -- asynchronous reset (active low)
      re_out       <= '1';
      msg_re_out   <= '1';
      rd_count_r   <= (others => '0');
      chk_amount_r <= std_logic_vector(to_unsigned(1, data_width_g));
      chk_count_r  <= std_logic_vector(to_unsigned(1, data_width_g));
 
      chk_state_r <= run_test;
 
    elsif clk'event and clk = '1' then  -- rising clock edge
 
      re_out     <= '1';
      msg_re_out <= '1';
 
      case chk_state_r is
        when run_test =>
          if empty_in = '0' then
            -- check incoming addr
            assert to_integer(unsigned(addr_in)) = own_addr_g
              report "ERROR: tb_ag(lo) 0x" &
              str(own_addr_g, 16) &
              " got addr: 0x" & str(to_integer(unsigned(addr_in)), 16) severity failure;
            -- check incoming data
            assert std_logic_vector(to_unsigned(own_addr_g, data_width_g) + unsigned(rd_count_r)) = data_in
              report "ERROR: data corrupted exp: 0x" &
              str(to_integer(unsigned(rd_count_r)) + own_addr_g, 16) & " got: 0x" &
              str(to_integer(unsigned(data_in)), 16) severity failure;
 
            assert std_logic_vector(to_unsigned(own_addr_g, data_width_g) + unsigned(rd_count_r)) /= data_in
              report "data ok got: 0x" &
              str(to_integer(unsigned(data_in)), 16) severity note;
 
            rd_count_r <= std_logic_vector(unsigned(rd_count_r) + 1);
 
            if chk_count_r = chk_amount_r then
              assert false report "ag: 0x" & str(own_addr_g, 16) &
                " read OK (length=" & str(to_integer(unsigned(chk_amount_r)), 16) & ")"
                severity note;
              chk_amount_r <= std_logic_vector(unsigned(chk_amount_r) + 1);
              chk_count_r  <= std_logic_vector(to_unsigned(1, data_width_g));
 
              if unsigned(chk_amount_r) >= 255 then
 
                assert unsigned(chk_amount_r) < 255 report "++++++++ ag: 0x" & str(own_addr_g, 16) &
                  " TEST SUCCESFUL ++++++++++++++++++++"
                  severity failure;
                chk_state_r <= test_finished;
              end if;
            else
              chk_amount_r <= chk_amount_r;
              chk_count_r  <= std_logic_vector(unsigned(chk_count_r) + 1);
            end if;
 
          end if;
          -- check incoming msg addr
          if msg_empty_in = '0' then
            assert to_integer(unsigned(msg_addr_in)) = own_addr_g
              report "ERROR: tb_ag(msg) 0x" &
              str(own_addr_g, 16) &
              " got addr: 0x" & str(to_integer(unsigned(msg_addr_in)), 16) severity failure;
          end if;
        when test_finished =>
          null;
        when others =>
          assert false report "Illegal test state" severity failure;
      end case;
    end if;
  end process check_results;
 
  data_out <= wr_data_r;
 
  update_wr_data : process (clk, rst_n)
  begin  -- process update_wr_count
    if rst_n = '0' then
      wr_data_r <= std_logic_vector(to_unsigned(own_addr_g, data_width_g));  --(others => '0');
    elsif clk = '1' and clk'event then
      if we_r = '1' and full_in = '0' then
        wr_data_r <= std_logic_vector(unsigned(wr_data_r) + 1);
      end if;
    end if;
  end process update_wr_data;
 
  process (clk, rst_n)
  begin  -- process
 
    if rst_n = '0' then                 -- asynchronous reset (active low)
 
      req_out      <= '0';
      hold_out     <= '0';
      msg_req_out  <= '0';
      msg_hold_out <= '0';
      comm_out     <= "010";
      addr_out     <= (others => '0');
      msg_data_out <= (others => '0');
      msg_addr_out <= (others => '0');
      we_r         <= '0';
      msg_we_r     <= '0';
      rd_port_addr <= (others => '0');
      wr_port_addr <= (others => '0');
      src_addr_r   <= std_logic_vector(to_unsigned(own_addr_g, addr_width_g));
      dst_addr_r   <= std_logic_vector(to_unsigned(own_addr_g, addr_width_g));
      rd_amount_r  <= std_logic_vector(to_unsigned(1, data_width_g));
      wr_amount_r  <= std_logic_vector(to_unsigned(1, data_width_g));
      wr_count_r   <= std_logic_vector(to_unsigned(1, data_width_g));  --(others => '0');
      state_r      <= idle;
 
    elsif clk'event and clk = '1' then  -- rising clock edge
 
      if chk_state_r = test_finished then
        msg_req_out  <= '0';
        msg_hold_out <= '0';
        req_out      <= '0';
        hold_out     <= '0';
      else
        case state_r is
 
          when idle =>
            req_out       <= '0';
            hold_out      <= '0';
            msg_req_out   <= '0';
            msg_hold_out  <= '0';
            wr_conf_state <= conf_dst_addr;
            rd_conf_state <= conf_src_addr;
            state_r       <= req_write_port;
 
          when req_write_port =>
            msg_req_out  <= '1';
            msg_hold_out <= '1';
            msg_addr_out <= std_logic_vector(to_unsigned(1, addr_width_g));
            msg_data_out <= std_logic_vector(to_unsigned(own_addr_g, data_width_g));
            if msg_grant_in = '1' and msg_full_in = '0' then
              msg_we_r <= '1';
              state_r  <= wait_write_port;
            else
              msg_we_r <= '0';
              state_r  <= req_write_port;
            end if;
 
          when wait_write_port =>
 
            if msg_we_r = '1' and msg_full_in = '1' then
              state_r <= wait_write_port;
            else
              msg_we_r     <= '0';
              msg_req_out  <= '0';
              msg_hold_out <= '0';
              msg_addr_out <= (others => '0');
              msg_data_out <= (others => '0');
 
              if msg_empty_in = '0'
                and msg_data_in = std_logic_vector(to_unsigned(0, data_width_g)) then
                state_r <= req_write_port;
 
              elsif msg_empty_in = '0'
                and msg_data_in /= std_logic_vector(to_unsigned(0, data_width_g)) then
                wr_port_addr <= msg_data_in;
                state_r      <= conf_write_port;
              else
                wr_port_addr <= (others => '0');
                state_r      <= wait_write_port;
              end if;
 
            end if;
 
          when conf_write_port =>
 
            msg_req_out  <= '1';
            msg_hold_out <= '1';
 
            if msg_grant_in = '1' and msg_full_in = '0' then
 
              if msg_we_r = '1' and msg_full_in = '1' then
                wr_conf_state <= wr_conf_state;
                state_r       <= state_r;
 
              else
 
                msg_we_r <= '1';
 
                case wr_conf_state is
 
                  when conf_dst_addr =>
                    msg_addr_out <= wr_port_addr;
                    msg_data_out <= dst_addr_r;
                    dst_addr_r <= std_logic_vector(unsigned(dst_addr_r) +
                                                   unsigned(wr_amount_r));
                    wr_conf_state <= conf_amount;
 
                  when conf_amount =>
                    msg_addr_out  <= std_logic_vector(unsigned(wr_port_addr) + 1);
                    msg_data_out  <= wr_amount_r;
                    wr_conf_state <= conf_height_offset;
 
                  when conf_height_offset =>
                    msg_req_out  <= '1';
                    msg_hold_out <= '1';
                    msg_we_r     <= '1';
                    msg_addr_out <= std_logic_vector(unsigned(wr_port_addr) + 2);
                    msg_data_out <= std_logic_vector(to_unsigned(1, data_width_g/2)) &
                                    std_logic_vector(to_unsigned(1, data_width_g/2));
                    wr_conf_state <= conf_dst_addr;
                    state_r       <= send_write_data;
 
                  when others =>
                    assert false report "tb_agent: 0x" & str(own_addr_g, 16) &
                      " illegal rd_conf_state" severity failure;
                end case;
 
              end if;
 
            end if;
 
          when send_write_data =>
 
            if msg_we_r = '1' and msg_full_in = '1' then
              state_r <= send_write_data;
            else
              msg_we_r     <= '0';
              msg_req_out  <= '0';
              msg_hold_out <= '0';
 
              req_out  <= '1';
              hold_out <= '1';
 
              addr_out <= std_logic_vector(unsigned(wr_port_addr) + 3);
              we_r     <= '1';
 
              if grant_in = '1' and full_in = '0' then
                if wr_count_r = std_logic_vector(unsigned(wr_amount_r)) then
                  req_out    <= '0';
                  hold_out   <= '0';
                  we_r       <= '0';
                  wr_count_r <= std_logic_vector(to_unsigned(1, data_width_g));  --(others => '0');
 
                  if to_integer(unsigned(wr_amount_r)) = 255 then
                    wr_amount_r <= std_logic_vector(to_unsigned(1, data_width_g));
                  else
                    wr_amount_r <= std_logic_vector(unsigned(wr_amount_r) + 1);
                  end if;
                  state_r <= req_read_port;
                else
                  wr_count_r <= std_logic_vector(unsigned(wr_count_r) + 1);
                  state_r    <= send_write_data;
                end if;
              end if;
 
            end if;
 
          when req_read_port =>
            req_out      <= '0';
            hold_out     <= '0';
            we_r         <= '0';
            msg_req_out  <= '1';
            msg_hold_out <= '1';
            msg_addr_out <= (others => '0');
            msg_data_out <= std_logic_vector(to_unsigned(own_addr_g, data_width_g));
            if msg_grant_in = '1' and msg_full_in = '0' then
              msg_we_r <= '1';
              state_r  <= wait_read_port;
            else
              msg_we_r <= '0';
              state_r  <= req_read_port;
            end if;
 
 
          when wait_read_port =>
            msg_we_r     <= '0';
            msg_req_out  <= '0';
            msg_hold_out <= '0';
            msg_addr_out <= (others => '0');
            msg_data_out <= (others => '0');
 
            if msg_empty_in = '0'
              and msg_data_in = std_logic_vector(to_unsigned(0, data_width_g)) then
              state_r <= req_read_port;
            elsif msg_empty_in = '0'
              and msg_data_in /= std_logic_vector(to_unsigned(0, data_width_g)) then
              rd_port_addr <= msg_data_in;
              state_r      <= conf_read_port;
            else
              rd_port_addr <= (others => '0');
              state_r      <= wait_read_port;
            end if;
 
          when conf_read_port =>
 
            if msg_we_r = '1' then
 
              -- this is here to allow other agents get grants and use
              -- msg fifo during configuring
              msg_req_out  <= '0';
              msg_hold_out <= '0';
              msg_we_r     <= '0';
            else
 
              msg_req_out  <= '1';
              msg_hold_out <= '1';
 
              if msg_grant_in = '1' and msg_full_in = '0' then
 
                msg_we_r <= '1';
 
                case rd_conf_state is
 
                  when conf_src_addr =>
                    msg_addr_out <= rd_port_addr;
                    msg_data_out <= src_addr_r;
                    src_addr_r <= std_logic_vector(unsigned(src_addr_r) +
                                                   unsigned(rd_amount_r));
                    rd_conf_state <= conf_amount;
 
                  when conf_amount =>
                    msg_addr_out <= std_logic_vector(unsigned(rd_port_addr) + 1);
                    msg_data_out <= rd_amount_r;
                    if to_integer(unsigned(rd_amount_r)) = 255 then
                      rd_amount_r <= std_logic_vector(to_unsigned(1, data_width_g));
                    else
                      rd_amount_r <= std_logic_vector(unsigned(rd_amount_r) + 1);
                    end if;
                    rd_conf_state <= conf_ret_addr;
 
                  when conf_ret_addr =>
                    msg_addr_out  <= std_logic_vector(unsigned(rd_port_addr) + 3);
                    msg_data_out  <= std_logic_vector(to_unsigned(own_addr_g, data_width_g));
                    rd_conf_state <= conf_height_offset;
 
                  when conf_height_offset =>
                    msg_addr_out <= std_logic_vector(unsigned(rd_port_addr) + 2);
                    msg_data_out <= std_logic_vector(to_unsigned(1, data_width_g/2)) &
                                    std_logic_vector(to_unsigned(1, data_width_g/2));
                    rd_conf_state <= conf_src_addr;
                    state_r       <= req_write_port;
 
                  when others =>
                    assert false report "tb_agent: 0x" & str(own_addr_g, 16) &
                      " illegal rd_conf_state" severity failure;
                end case;
              else
                msg_we_r <= '0';
              end if;
            end if;
 
          when others =>
            assert false report "tb_agent: 0x" & str(own_addr_g, 16) &
              " illegal state" severity failure;
        end case;
 
      end if;
    end if;
  end process;
 
end behavioral;