Subversion Repositories dp_components

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

--

-- Copyright (C) 2011

-- ASTRON (Netherlands Institute for Radio Astronomy) <http://www.astron.nl/>

-- P.O.Box 2, 7990 AA Dwingeloo, The Netherlands

--

-- This program is free software: you can redistribute it and/or modify

-- it under the terms of the GNU General Public License as published by

-- the Free Software Foundation, either version 3 of the License, or

-- (at your option) any later version.

--

-- This program 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 General Public License for more details.

--

-- You should have received a copy of the GNU General Public License

-- along with this program.  If not, see <http://www.gnu.org/licenses/>.

--

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

-- Purpose : Generate the sosi control for a block of data under flow control

-- Description:

--   When enabled a block of g_nof_data words is output via src_out under flow

--   control by the ready. The ready depends on g_use_src_in:

--

--   . If g_use_src_in=TRUE then the src_in.ready is used and snk_in is

--     ignored. This can be used as a block reference input parallel to a

--     group of user inputs.

--     The g_preserve_* generics do not apply, because the snk_in is ignored.

--

--   . If g_use_src_in=FALSE then the src_in is not used and the snk_in data,

--     re, im are passed on and the snk_in.valid is used as ready. This can

--     be used as a BSN source that creates sync, bsn, sop and eop from

--     snk_in.valid for snk_in.data that has data not valid gaps. The

--     dp_bsn_source is similar but only supports data that is always valid.

--     The g_preserve_* generics can be used to preserve the corresponding

--     snk_in fields or to use the local generated values for this fields.

--

--   The first active ready starts the dp_block_gen. The first output block

--   will have a src_out.sync and every g_nof_blk_per_sync another

--   src_out.sync. Each block is marked by src_out.sop and src_out.eop. The

--   sop also marks the BSN. The BSN is the block sequence number that

--   increments for every block.

--

--   The snk_in.sop and snk_in.eop are always ignored, because g_nof_data

--   will set the src_out.sop/eop blocks.

--   

--   If g_preserve_sync=TRUE then src_out.sync = snk_in.sync, else the

--   src_out.sync is depends on the first ready and on g_nof_blk_per_sync.

--   

--   If g_preserve_bsn=TRUE then src_out.bsn = snk_in.bsn, else the

--   src_out.bsn is depends on the first ready and the initial g_bsn. If

--   g_preserve_bsn=TRUE then g_nof_data needs to match the snk_in.sop/eop

--   blocks.

--

--   If g_preserve_channel=TRUE then src_out.channel = snk_in.channel, else

--   the src_out.channel = g_channel.

--

-- Remarks:

-- . Ready latency (RL) = 1

-- . Alternatively consider using dp_block_gen_valid_arr.vhd or

--   dp_block_reshape.vhd.

LIBRARY IEEE, common_pkg_lib, dp_pkg_lib;

USE IEEE.STD_LOGIC_1164.ALL;

USE IEEE.NUMERIC_STD.ALL;

USE common_pkg_lib.common_pkg.ALL;

USE dp_pkg_lib.dp_stream_pkg.ALL;

ENTITY dp_block_gen IS

  GENERIC (

    g_use_src_in         : BOOLEAN := TRUE;  -- when true use src_in.ready else use snk_in.valid for flow control

    g_nof_data           : POSITIVE := 1;    -- nof data per block

    g_nof_blk_per_sync   : POSITIVE := 8;

    g_empty              : NATURAL := 0;

    g_channel            : NATURAL := 0;

    g_error              : NATURAL := 0;

    g_bsn                : NATURAL := 0;

    g_preserve_sync      : BOOLEAN := FALSE;

    g_preserve_bsn       : BOOLEAN := FALSE;

    g_preserve_channel   : BOOLEAN := FALSE

  );

  PORT (

    rst        : IN  STD_LOGIC;

    clk        : IN  STD_LOGIC;

    -- Streaming sink

    snk_out    : OUT t_dp_siso;                   -- pass on src_in.xon, pass on or force snk_out.ready dependend on g_use_src_in

    snk_in     : IN  t_dp_sosi := c_dp_sosi_rst;

    -- Streaming source

    src_in     : IN  t_dp_siso := c_dp_siso_rdy;

    src_out    : OUT t_dp_sosi;

    -- MM control

    en         : IN  STD_LOGIC := '1'

  );

END dp_block_gen;

ARCHITECTURE rtl OF dp_block_gen IS

  TYPE t_state IS (s_sop, s_data, s_eop);

  TYPE t_reg IS RECORD  -- local registers

    state     : t_state;

    data_cnt  : NATURAL RANGE 0 TO g_nof_data;

    blk_cnt   : NATURAL RANGE 0 TO g_nof_blk_per_sync;

    bsn       : STD_LOGIC_VECTOR(c_dp_stream_bsn_w-1 DOWNTO 0);

    src_out   : t_dp_sosi;

  END RECORD;

  CONSTANT c_reg_rst  : t_reg := (s_sop, 0, 0, TO_DP_BSN(g_bsn), c_dp_sosi_rst);

  SIGNAL ready     : STD_LOGIC;

  -- Define the local registers in t_reg record

  SIGNAL r         : t_reg;

  SIGNAL nxt_r     : t_reg;

BEGIN

  snk_out.ready <= src_in.ready WHEN g_use_src_in=TRUE ELSE '1';  -- force snk_out.ready = '1' when src_in.ready is not used

  snk_out.xon   <= src_in.xon;                                    -- always pass on siso.xon

  src_out <= r.src_out;

  p_clk : PROCESS(rst, clk)

  BEGIN

    IF rst='1' THEN

      r <= c_reg_rst;

    ELSIF rising_edge(clk) THEN

      r <= nxt_r;

    END IF;

  END PROCESS;

  ready <= src_in.ready WHEN g_use_src_in=TRUE ELSE snk_in.valid;

  p_state : PROCESS(r, en, ready, snk_in)

  BEGIN

    nxt_r <= r;

    IF g_use_src_in=FALSE THEN

      nxt_r.src_out.data  <= snk_in.data;

      nxt_r.src_out.re    <= snk_in.re;

      nxt_r.src_out.im    <= snk_in.im;

    END IF;

    IF g_preserve_sync = FALSE THEN

      nxt_r.src_out.sync  <= '0';

    ELSE

      nxt_r.src_out.sync  <= snk_in.sync;

    END IF;

    nxt_r.src_out.valid <= '0';

    nxt_r.src_out.sop   <= '0';

    nxt_r.src_out.eop   <= '0';

    IF g_preserve_bsn=TRUE THEN

      nxt_r.src_out.bsn <= snk_in.bsn;

    END IF;

    IF g_preserve_channel=TRUE THEN

      nxt_r.src_out.channel <= snk_in.channel;

    END IF;

    CASE r.state IS

      WHEN s_sop =>

        nxt_r.data_cnt <= 0;            -- for clarity init data count to 0 (because it will become 1 anyway at sop)

        IF en='0' THEN                  -- if disabled then reset block generator and remain in this state

          nxt_r.blk_cnt <= 0;

          nxt_r.bsn     <= TO_DP_BSN(g_bsn);

        ELSE                            -- enabled block generator

          IF ready='1' THEN             -- once enabled the complete block will be output dependent on the flow control

            -- use input sync or create local sync

            IF g_preserve_sync = FALSE THEN

              IF r.blk_cnt=0 THEN

                nxt_r.src_out.sync  <= '1';              -- use local sync for this block, local sync starts at first ready

              END IF;

              IF r.blk_cnt>=g_nof_blk_per_sync-1 THEN    -- maintain local sync interval

                nxt_r.blk_cnt <= 0;

              ELSE

                nxt_r.blk_cnt <= r.blk_cnt+1;

              END IF;

            END IF;

            nxt_r.src_out.valid   <= '1';

            nxt_r.src_out.sop     <= '1';

            -- use input bsn or create local bsn

            IF g_preserve_bsn=FALSE THEN

              nxt_r.bsn             <= INCR_UVEC(r.bsn, 1);  -- increment local bsn for next block

              nxt_r.src_out.bsn     <= r.bsn;                -- use local bsn for this block

            END IF;

            -- use input channel or create fixed local channel

            IF g_preserve_channel=FALSE THEN

              nxt_r.src_out.channel <= TO_DP_CHANNEL(g_channel);

            END IF;

            IF g_nof_data=1 THEN

              nxt_r.src_out.eop   <= '1';  -- single word block

              nxt_r.src_out.empty <= TO_DP_EMPTY(g_empty);

              nxt_r.src_out.err   <= TO_DP_ERROR(g_error);

            ELSIF g_nof_data=2 THEN

              nxt_r.data_cnt <= 1;      -- start of two word block

              nxt_r.state <= s_eop;

            ELSE

              nxt_r.data_cnt <= 1;      -- start of multi word block

              nxt_r.state <= s_data;

            END IF;

          END IF;

        END IF;

      WHEN s_data =>

        IF ready='1' THEN

          nxt_r.data_cnt <= r.data_cnt+1;

          nxt_r.src_out.valid <= '1';

          IF r.data_cnt=g_nof_data-2 THEN

            nxt_r.state <= s_eop;

          END IF;

        END IF;

      WHEN OTHERS =>  -- s_eop

        IF ready='1' THEN

          nxt_r.src_out.valid <= '1';

          nxt_r.src_out.eop   <= '1';

          nxt_r.src_out.empty <= TO_DP_EMPTY(g_empty);

          nxt_r.src_out.err   <= TO_DP_ERROR(g_error);

          nxt_r.state <= s_sop;

        END IF;

    END CASE;

  END PROCESS;

END rtl;