Subversion Repositories astron_r2sdf_fft

--------------------------------------------------------------------------------
--   Author: Raj Thilak Rajan : rajan at astron.nl: Nov 2009
--   Copyright (C) 2009-2010
--   ASTRON (Netherlands Institute for Radio Astronomy)
--   P.O.Box 2, 7990 AA Dwingeloo, The Netherlands
--
--   This file is part of the UniBoard software suite.
--   The file 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/>.
--------------------------------------------------------------------------------
 
library ieee, common_pkg_lib, common_components_lib;
use IEEE.std_logic_1164.all;
use common_pkg_lib.common_pkg.all;
 
entity rTwoBFStage is
  generic (
    -- generics for this stage
    g_nof_chan      : natural := 0;   -- Exponent of nr of subbands (0 means 1 subband)
    g_stage         : natural;        -- The stage indices are ..., 3, 2, 1. The input stage has the highest index, the output stage has index 1.
    g_bf_lat        : natural := 1;   -- Digital pipelining latency
    -- generics for rTwoBF
    g_bf_use_zdly   : natural := 1;   -- >= 1. Stage high downto g_bf_use_zdly will will use g_bf_in_a_zdly and g_bf_out_zdly
    g_bf_in_a_zdly  : natural := 0;   -- g_bf_in_a_zdly+g_bf_out_d_zdly must be <= the stage z^(-1) delay, note that stage 1 has only one z^(-1) delay
    g_bf_out_d_zdly : natural := 0    -- The stage z^(-1) delays are ..., 4, 2, 1.
  );
  port (
    clk      : in  std_logic;
    rst      : in  std_logic;
    in_re    : in  std_logic_vector;
    in_im    : in  std_logic_vector;
    in_val   : in  std_logic;
    in_sel   : in  std_logic;
    out_re   : out std_logic_vector;
    out_im   : out std_logic_vector;
    out_val  : out std_logic;
    out_sel  : out std_logic
  );
end entity rTwoBFStage;
 
architecture str of rTwoBFStage is
 
  -- Optionally move some z-1 delay into this BF stage, default 0
  constant c_bf_in_a_zdly   : natural := sel_a_b(g_stage >= g_bf_use_zdly, g_bf_in_a_zdly, 0);
  constant c_bf_out_b_zdly  : natural := sel_a_b(g_stage >= g_bf_use_zdly, g_bf_out_d_zdly, 0);
 
  constant c_bf_zdly        : natural := c_bf_in_a_zdly+c_bf_out_b_zdly;
  constant c_feedback_zdly  : natural := pow2(g_stage-1);
 
  -- The BF adds, subtracts or passes the data on, so typically c_out_dat_w = c_in_dat_w + 1
  constant c_in_dat_w       : natural := in_re'length;   -- re and im have same width
  constant c_out_dat_w      : natural := out_re'length;  -- re and im have same width
 
  -- Concatenate im & re into complex data to potentially ease synthesis to make more efficient use of block RAM memory for z-1 data feedback line
  signal bf_complex        : std_logic_vector(c_nof_complex*c_in_dat_w-1 downto 0);
  signal bf_complex_dly    : std_logic_vector(bf_complex'range);
  signal bf_re             : std_logic_vector(in_re'range);
  signal bf_re_dly         : std_logic_vector(in_re'range);
  signal bf_im             : std_logic_vector(in_im'range);
  signal bf_im_dly         : std_logic_vector(in_im'range);
  signal bf_sel            : std_logic;
  signal bf_val            : std_logic;
  signal bf_val_dly        : std_logic;
 
  signal stage_complex     : std_logic_vector(c_nof_complex*c_out_dat_w-1 downto 0);
  signal stage_complex_dly : std_logic_vector(stage_complex'range);
  signal stage_re          : std_logic_vector(out_re'range);
  signal stage_im          : std_logic_vector(out_im'range);
  signal stage_sel         : std_logic;
  signal stage_val         : std_logic;
 
begin
 
  ------------------------------------------------------------------------------
  -- butterfly
  ------------------------------------------------------------------------------
 
  u_bf_re : entity work.rTwoBF
  generic map (
    g_in_a_zdly  => c_bf_in_a_zdly,
    g_out_d_zdly => c_bf_out_b_zdly
  )
  port map (
    clk     => clk,
    in_a    => bf_re_dly,
    in_b    => in_re,
    in_sel  => in_sel,
    in_val  => in_val,
    out_c   => stage_re,
    out_d   => bf_re
  );
 
  u_bf_im : entity work.rTwoBF
  generic map (
    g_in_a_zdly  => c_bf_in_a_zdly,
    g_out_d_zdly => c_bf_out_b_zdly
  )
  port map (
    clk     => clk,
    in_a    => bf_im_dly,
    in_b    => in_im,
    in_sel  => in_sel,
    in_val  => in_val,
    out_c   => stage_im,
    out_d   => bf_im
  );
 
 
  ------------------------------------------------------------------------------
  -- feedback fifo
  ------------------------------------------------------------------------------
 
  bf_sel <= in_sel;
  bf_val <= in_val;
 
  bf_complex <= bf_im & bf_re;
  bf_re_dly  <= bf_complex_dly(  c_in_dat_w-1 downto 0);
  bf_im_dly  <= bf_complex_dly(2*c_in_dat_w-1 downto c_in_dat_w);
 
  -- share FIFO for Im & Re
  u_feedback : entity common_components_lib.common_delay
  generic map (
    g_dat_w  => bf_complex'length,
    g_depth  => c_feedback_zdly*(2**g_nof_chan)-c_bf_zdly
  )
  port map (
    clk     => clk,
    in_dat  => bf_complex,
    in_val  => bf_val,
    out_dat => bf_complex_dly
  );
 
  -- compensate for feedback fifo
  u_stage_sel : entity common_components_lib.common_bit_delay
  generic map (
    g_depth => c_feedback_zdly*(2**g_nof_chan)
  )
  port map (
    clk     => clk,
    rst     => rst,
    in_clr  => '0',
    in_val  => bf_val,
    in_bit  => bf_sel,
    out_bit => stage_sel
  );
 
  -- compensate for feedback fifo
  u_stage_val : entity common_components_lib.common_bit_delay
  generic map (
    g_depth => c_feedback_zdly*(2**g_nof_chan)
  )
  port map (
    clk     => clk,
    rst     => rst,
    in_clr  => '0',
    in_val  => bf_val,
    in_bit  => bf_val,
    out_bit => bf_val_dly
  );
 
  -- after the z^(-1) stage delay the bf_val_dly goes high and remains high and acts as an enable for in_val to out_val
  stage_val <= in_val and bf_val_dly;
 
 
  ------------------------------------------------------------------------------
  -- stage output pipelining
  ------------------------------------------------------------------------------
 
  stage_complex <= stage_im & stage_re;
 
  u_pipeline_out : entity common_components_lib.common_pipeline
  generic map (
    g_pipeline  => g_bf_lat,
    g_in_dat_w  => stage_complex'length,
    g_out_dat_w => stage_complex'length
  )
  port map (
    clk     => clk,
    in_dat  => stage_complex,
    out_dat => stage_complex_dly
  );
 
  out_re <= stage_complex_dly(  c_out_dat_w-1 downto 0);
  out_im <= stage_complex_dly(2*c_out_dat_w-1 downto c_out_dat_w);
 
  u_out_sel : entity common_components_lib.common_pipeline_sl
  generic map (
    g_pipeline => g_bf_lat
  )
  port map (
    clk     => clk,
    in_dat  => stage_sel,
    out_dat => out_sel
  );
 
  u_out_val : entity common_components_lib.common_pipeline_sl
  generic map (
    g_pipeline => g_bf_lat
  )
  port map (
    clk     => clk,
    in_dat  => stage_val,
    out_dat => out_val
  );
 
end str;