Subversion Repositories funbase_ip_library

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

-- file:        ring.vhd

-- Designer:    Jussi Nieminen, 11.02.2009,

--              modification of Erno Salminen's Octagon

--              Antti Alhonen, 01.07.2009,

--              added monitoring

-- Description: An n-node Ring network

-- 

-- 

-- Modified :

-- 01.07.2009   Added monitoring.

-- 11.02.2009   Forked from the Octacon ver. 04 

-- 

--

-- 

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

library ieee;

use ieee.std_logic_1164.all;

use ieee.std_logic_arith.all;

use work.mon_pkg.all;

entity ring_with_monitor is

  generic (

    nbr_of_routers_g   :     integer := 8;

    diag_en_g          :     integer := 0;

    data_width_g       :     integer := 32;

    stfwd_en_g         :     integer;

    pkt_len_g          :     integer;

    len_flit_en_g      :     integer := 0;

    oaddr_flit_en_g    :     integer := 0;

    fifo_depth_g       :     integer;

    net_freq_g         :     integer;

    ip_freq_g          :     integer

    );

  port (

    clk_net            : in  std_logic;

    clk_ip             : in  std_logic;

    rst_n              : in  std_logic;

    tx_data_in         : in  std_logic_vector( nbr_of_routers_g * data_width_g-1 downto 0 );

    tx_we_in           : in  std_logic_vector ( nbr_of_routers_g - 1 downto 0 );

    tx_empty_out       : out std_logic_vector ( nbr_of_routers_g - 1 downto 0 );

    tx_full_out        : out std_logic_vector ( nbr_of_routers_g - 1 downto 0 );

    rx_data_out  : out  std_logic_vector( nbr_of_routers_g*data_width_g-1 downto 0 );

    rx_re_in     : in  std_logic_vector (nbr_of_routers_g-1 downto 0);

    rx_empty_out : out std_logic_vector (nbr_of_routers_g-1 downto 0);

    rx_full_out  : out std_logic_vector (nbr_of_routers_g-1 downto 0);

    -- MONITOR SIGNALS (AA)

    mon_UART_rx_in  : in  std_logic;

    mon_UART_tx_out : out std_logic;

    mon_command_in  : in  std_logic_vector(mon_command_width_c-1 downto 0)

    );

end ring_with_monitor;

architecture structural of ring_with_monitor is

  type data_arr_type is array (nbr_of_routers_g-1 downto 0) of std_logic_vector (data_width_g-1 downto 0);

  signal fwd_data  : data_arr_type;

  signal fwd_re    : std_logic_vector (nbr_of_routers_g-1 downto 0);

  signal fwd_empty : std_logic_vector (nbr_of_routers_g-1 downto 0);

  signal fwd_full  : std_logic_vector (nbr_of_routers_g-1 downto 0);

  signal diag_data  : data_arr_type;

  signal diag_re    : std_logic_vector (nbr_of_routers_g-1 downto 0);

  signal diag_empty : std_logic_vector (nbr_of_routers_g-1 downto 0);

  signal diag_full  : std_logic_vector (nbr_of_routers_g-1 downto 0);

  signal rev_data  : data_arr_type;

  signal rev_re    : std_logic_vector (nbr_of_routers_g-1 downto 0);

  signal rev_empty : std_logic_vector (nbr_of_routers_g-1 downto 0);

  signal rev_full  : std_logic_vector (nbr_of_routers_g-1 downto 0);

  signal tx_data_dbg        : data_arr_type;

  signal rx_data_arr        : data_arr_type;

  component  ring_router

    generic (

      nbr_of_routers_g   :    integer := 8;

      data_width_g       :    integer := 0;

      dateline_en_g      :    integer := 0;

      stfwd_en_g         :    integer;

      pkt_len_g          :    integer;

      len_flit_en_g      :    integer := 0;

      oaddr_flit_en_g    :    integer := 0;

      fifo_depth_g       :    integer;

      router_id_g        :    integer := 0;

      diag_en_g          :    integer := 1;

      net_freq_g         :    integer;

      ip_freq_g          :    integer

      );

    port (

      clk_net            : in std_logic;

      clk_ip             : in std_logic;

      rst_n              : in std_logic;

      data_fwd_in  : in  std_logic_vector ( data_width_g-1 downto 0);

      re_fwd_out   : out std_logic;

      empty_fwd_in : in  std_logic;

      full_fwd_in  : in  std_logic;

      data_rev_in  : in  std_logic_vector ( data_width_g-1 downto 0);

      re_rev_out   : out std_logic;

      empty_rev_in : in  std_logic;

      full_rev_in  : in  std_logic;

      data_diag_in  : in  std_logic_vector ( data_width_g-1 downto 0);

      re_diag_out   : out std_logic;

      empty_diag_in : in  std_logic;

      full_diag_in  : in  std_logic;

      data_ip_tx_in   : in  std_logic_vector ( data_width_g-1 downto 0);

      we_ip_tx_in     : in  std_logic;

      empty_ip_tx_out : out std_logic;

      full_ip_tx_out  : out std_logic;

      data_fwd_out  : out std_logic_vector ( data_width_g-1 downto 0);

      re_fwd_in     : in  std_logic;

      empty_fwd_out : out std_logic;

      full_fwd_out  : out std_logic;

      data_rev_out  : out std_logic_vector ( data_width_g-1 downto 0);

      re_rev_in     : in  std_logic;

      empty_rev_out : out std_logic;

      full_rev_out  : out std_logic;

      data_diag_out  : out std_logic_vector ( data_width_g-1 downto 0);

      re_diag_in     : in  std_logic;

      empty_diag_out : out std_logic;

      full_diag_out  : out std_logic;

      data_ip_rx_out  : out std_logic_vector ( data_width_g-1 downto 0);

      re_ip_rx_in     : in  std_logic;

      full_ip_rx_out  : out std_logic;

      empty_ip_rx_out : out std_logic

      );

  end component; --ring_router;

  component monitor_top

    generic (

      num_of_links_g : integer);

    port (

      emptys_in      : in  std_logic_vector(num_of_links_g-1 downto 0);

      res_in         : in  std_logic_vector(num_of_links_g-1 downto 0);

      uart_rx_in     : in  std_logic;

      uart_tx_out    : out std_logic;

      clk            : in  std_logic;

      rst_n          : in  std_logic;

      mon_command_in : in  std_logic_vector(mon_command_width_c-1 downto 0));

  end component;

  constant num_of_links_c : integer := (diag_en_g + 2) * nbr_of_routers_g;

  signal emptys_to_mon : std_logic_vector(num_of_links_c-1 downto 0);

  signal res_to_mon    : std_logic_vector(num_of_links_c-1 downto 0);

begin  -- structural

  map_dbg_arr : for i in 0 to nbr_of_routers_g-1 generate

    tx_data_dbg (i)        <= tx_data_in ((i+1)*data_width_g-1 downto i*data_width_g);

    rx_data_out ((i+1)*data_width_g-1 downto i*data_width_g)        <= rx_data_arr (i);

  end generate map_dbg_arr;

  -- data defines which index is used

  -- r  port         signal

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

  -- 0: data_out  => data(0)

  -- 0: re_in     => re(0)

  -- 0: empty_out => empty(0)

  -- 1: data_in   => data(0)

  -- 1: re_out    => re(0)

  -- 1: empty_in  => empty(0)

  map_routers : for r in 1 to nbr_of_routers_g-1 generate

    router    : ring_router

      generic map (

        nbr_of_routers_g   => nbr_of_routers_g,

        data_width_g       => data_width_g,

        dateline_en_g      => 0,

        stfwd_en_g         => stfwd_en_g,

        pkt_len_g          => pkt_len_g,

        len_flit_en_g      => len_flit_en_g,

        oaddr_flit_en_g    => oaddr_flit_en_g,

        fifo_depth_g       => fifo_depth_g,

        router_id_g        => r,

        diag_en_g          => diag_en_g,

        net_freq_g         => net_freq_g,

        ip_freq_g          => ip_freq_g

        )

      port map (

        clk_net            => clk_net,

        clk_ip             => clk_ip,

        rst_n              => rst_n,

        data_ip_tx_in   => tx_data_in   ( (r+1)*data_width_g-1 downto r*data_width_g ),

        we_ip_tx_in     => tx_we_in     (r),

        full_ip_tx_out  => tx_full_out  (r),

        empty_ip_tx_out => tx_empty_out (r),

        data_fwd_in  => fwd_data  (r-1),

        re_fwd_out   => fwd_re    (r-1),

        empty_fwd_in => fwd_empty (r-1),

        full_fwd_in  => fwd_full  (r-1),

        data_fwd_out  => fwd_data  (r),

        re_fwd_in     => fwd_re    (r),

        empty_fwd_out => fwd_empty (r),

        full_fwd_out  => fwd_full  (r),

        data_rev_in  => rev_data  ( (r+1) mod nbr_of_routers_g ),

        re_rev_out   => rev_re    ( (r+1) mod nbr_of_routers_g ),

        empty_rev_in => rev_empty ( (r+1) mod nbr_of_routers_g ),

        full_rev_in  => rev_full  ( (r+1) mod nbr_of_routers_g ),

        data_rev_out  => rev_data  (r),

        re_rev_in     => rev_re    (r),

        empty_rev_out => rev_empty (r),

        full_rev_out  => rev_full  (r),

        --FIXME, this only works with rings of size 2*k, k E N

        data_diag_in  => diag_data  (( r - nbr_of_routers_g / 2 ) mod nbr_of_routers_g),

        re_diag_out   => diag_re    (( r - nbr_of_routers_g / 2 ) mod nbr_of_routers_g),

        empty_diag_in => diag_empty (( r - nbr_of_routers_g / 2 ) mod nbr_of_routers_g),

        full_diag_in  => diag_full  (( r - nbr_of_routers_g / 2 ) mod nbr_of_routers_g),

        data_diag_out  => diag_data  (r),

        re_diag_in     => diag_re    (r),

        empty_diag_out => diag_empty (r),

        full_diag_out  => diag_full  (r),

        data_ip_rx_out  => rx_data_arr (r),

        re_ip_rx_in     => rx_re_in     (r),

        full_ip_rx_out  => rx_full_out  (r),

        empty_ip_rx_out => rx_empty_out (r)

        );

  end generate map_routers;

  first_router : ring_router

      generic map (

        nbr_of_routers_g   => nbr_of_routers_g,

        data_width_g       => data_width_g,

        dateline_en_g      => 1,

        pkt_len_g          => pkt_len_g,

        len_flit_en_g      => len_flit_en_g,

        oaddr_flit_en_g    => oaddr_flit_en_g,

        stfwd_en_g         => stfwd_en_g,

        fifo_depth_g       => fifo_depth_g,

        router_id_g        => 0,

        diag_en_g          => diag_en_g,

        net_freq_g         => net_freq_g,

        ip_freq_g          => ip_freq_g

        )

      port map (

        clk_net            => clk_net,

        clk_ip             => clk_ip,

        rst_n              => rst_n,

        data_ip_tx_in   => tx_data_in   ( data_width_g-1 downto 0 ),

        we_ip_tx_in     => tx_we_in     (0),

        full_ip_tx_out  => tx_full_out  (0),

        empty_ip_tx_out => tx_empty_out (0),

        data_fwd_in  => fwd_data  ( nbr_of_routers_g - 1 ),

        re_fwd_out   => fwd_re    ( nbr_of_routers_g - 1 ),

        empty_fwd_in => fwd_empty ( nbr_of_routers_g - 1 ),

        full_fwd_in  => fwd_full  ( nbr_of_routers_g - 1 ),

        data_fwd_out  => fwd_data  (0),

        re_fwd_in     => fwd_re    (0),

        empty_fwd_out => fwd_empty (0),

        full_fwd_out  => fwd_full  (0),

        data_rev_in  => rev_data  (1),

        re_rev_out   => rev_re    (1),

        empty_rev_in => rev_empty (1),

        full_rev_in  => rev_full  (1),

        data_rev_out  => rev_data  (0),

        re_rev_in     => rev_re    (0),

        empty_rev_out => rev_empty (0),

        full_rev_out  => rev_full  (0),

        data_diag_in  => diag_data  ( nbr_of_routers_g / 2 ),

        re_diag_out   => diag_re    ( nbr_of_routers_g / 2 ),

        empty_diag_in => diag_empty ( nbr_of_routers_g / 2 ),

        full_diag_in  => diag_full  ( nbr_of_routers_g / 2 ),

        data_diag_out  => diag_data  (0),

        re_diag_in     => diag_re    (0),

        empty_diag_out => diag_empty (0),

        full_diag_out  => diag_full  (0),

        data_ip_rx_out  => rx_data_arr (0),

        re_ip_rx_in     => rx_re_in     (0),

        full_ip_rx_out  => rx_full_out  (0),

        empty_ip_rx_out => rx_empty_out (0)

        );

  -- First forwards, then backwards, last diagonals.

  emptys_to_mon(nbr_of_routers_g-1 downto

                0) <= fwd_empty;

  emptys_to_mon(nbr_of_routers_g*2-1 downto

                nbr_of_routers_g) <= rev_empty;

  res_to_mon(nbr_of_routers_g-1 downto

             0) <= fwd_re;

  res_to_mon(nbr_of_routers_g*2-1 downto

             nbr_of_routers_g) <= rev_re;

  diagonals: if diag_en_g = 1 generate

    emptys_to_mon(nbr_of_routers_g*3-1 downto nbr_of_routers_g*2) <= diag_empty;

    res_to_mon(nbr_of_routers_g*3-1 downto nbr_of_routers_g*2) <= diag_re;

  end generate diagonals;

  ring_monitor: monitor_top

    generic map (

        num_of_links_g => num_of_links_c)

    port map (

        emptys_in      => emptys_to_mon,

        res_in         => res_to_mon,

        uart_rx_in     => mon_UART_rx_in,

        uart_tx_out    => mon_UART_tx_out,

        clk            => clk_net,

        rst_n          => rst_n,

        mon_command_in => mon_command_in);

end structural;