Subversion Repositories funbase_ip_library

-------------------------------------------------------------------------------
-- Title      : rd_port.vhd
-- Project    : 
-------------------------------------------------------------------------------
-- File       : rd_port.vhd
-- Author     : 
-- Company    : 
-- Created    : 2007-05-22
-- Last update: 2012-01-26
-- Platform   : 
-- Standard   : VHDL'87
-------------------------------------------------------------------------------
-- Description: Read port for sdram2hibi
-------------------------------------------------------------------------------
-- Copyright (c) 2007 
-------------------------------------------------------------------------------
-- Revisions  :
-- Date        Version  Author  Description
-- 2007-05-22  1.0      penttin5	Created
-- 2012-01-22  1.001    alhonen fixed names
-------------------------------------------------------------------------------
 
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
 
entity sdram_rd_port is
 
  generic (
    amountw_g       : integer;
    hibi_dataw_g    : integer;
    block_overlap_g : integer := 0;
    offsetw_g       : integer;
    mem_dataw_g     : integer;
    mem_addrw_g     : integer);
 
  port (
    clk            : in  std_logic;
    rst_n          : in  std_logic;
    conf_we_in     : in  std_logic;
    conf_data_in   : in  std_logic_vector(hibi_dataw_g - 1 downto 0);
    read_in        : in  std_logic;
    reserve_in     : in  std_logic;
    valid_out      : out std_logic;
    reserved_out   : out std_logic;
    end_addr_out   : out std_logic_vector(mem_addrw_g - 1 downto 0);
    src_addr_out   : out std_logic_vector(mem_addrw_g - 1 downto 0);
    amount_out     : out std_logic_vector(amountw_g - 1 downto 0);
    ret_addr_out   : out std_logic_vector(hibi_dataw_g - 1 downto 0);
    finish_out     : out std_logic;
    error_out      : out std_logic);
 
end sdram_rd_port;
 
architecture rtl of sdram_rd_port is
 
  -- parameter numbers
  constant src_addr_param_c : integer := 0;
  constant amount_param_c   : integer := 1;
  constant width_param_c    : integer := 1;
  constant ret_addr_param_c : integer := 2;
  constant height_param_c   : integer := 3;
  constant offset_param_c   : integer := 3;
  constant last_param_c     : integer := 3;
 
  signal reserved_r : std_logic;
  signal valid_r    : std_logic;
  signal src_addr_r : std_logic_vector(mem_addrw_g - 1 downto 0);
  signal amount_r   : std_logic_vector(amountw_g - 1 downto 0);
  signal width_r    : std_logic_vector(amountw_g - 1 downto 0);
  signal height_r   : std_logic_vector(hibi_dataw_g - offsetw_g - 1 downto 0);
  signal offset_r   : std_logic_vector(offsetw_g - 1 downto 0);
  signal end_addr_r : std_logic_vector(mem_addrw_g - 1 downto 0);
  signal ret_addr_r : std_logic_vector(hibi_dataw_g - 1 downto 0);
 
  signal finish          : std_logic;
  signal param_cnt_r     : integer range last_param_c downto 0;
  signal end_addr_rdy_r  : std_logic;
  signal calc_end_addr_r : std_logic;
  signal h_times_o_r     : std_logic_vector(hibi_dataw_g - 1 downto 0);
 
begin  -- rtl
 
  -- drive outputs
  reserved_out <= reserved_r;
  valid_out    <= valid_r;
  src_addr_out <= src_addr_r;
  amount_out   <= amount_r;
  end_addr_out <= end_addr_r;
  ret_addr_out <= ret_addr_r;
 
  -- purpose: Detect finished operation
  -- type   : combinational
  -- inputs : read_in, amount_r, height_r
  -- outputs: finish
  port_finishes : process (read_in, amount_r, height_r)
  begin  -- process port_finishes
    if read_in = '1'
      and to_integer(unsigned(amount_r)) = 1
      and (to_integer(unsigned(height_r)) = 1 or
           to_integer(unsigned(height_r)) = 0) then
      finish <= '1';
    else
      finish <= '0';
    end if;
  end process port_finishes;
 
  finish_output: process (clk, rst_n)
  begin  -- process finish_output
    if rst_n = '0' then                 -- asynchronous reset (active low)
      finish_out <= '0';
    elsif clk'event and clk = '1' then  -- rising clock edge
      finish_out <= finish;
    end if;
  end process finish_output;
 
  param_counter: process (clk, rst_n)
  begin  -- process param_counter
    if rst_n = '0' then                 -- asynchronous reset (active low)
      param_cnt_r <= 0;
    elsif clk'event and clk = '1' then  -- rising clock edge
 
      if conf_we_in = '1' and param_cnt_r = last_param_c then
        param_cnt_r <= 0;
      elsif conf_we_in = '1' then
        param_cnt_r <= param_cnt_r + 1;
      else
        param_cnt_r <= param_cnt_r;
      end if;
    end if;
  end process param_counter;
 
  reserved_proc : process (clk, rst_n)
  begin  -- process reserved_proc
    if rst_n = '0' then                 -- asynchronous reset (active low)
      reserved_r <= '0';
    elsif clk'event and clk = '1' then  -- rising clock edge
 
      if finish = '1' then
        -- operation finishes
        reserved_r <= '0';
      elsif reserve_in = '1' then
        -- reserve from sdram2hibi
        reserved_r <= '1';
      else
        reserved_r <= reserved_r;
      end if;
    end if;
  end process reserved_proc;
 
  valid_proc : process (clk, rst_n)
  begin  -- process valid_proc
    if rst_n = '0' then                 -- asynchronous reset (active low)
      valid_r <= '0';
    elsif clk'event and clk = '1' then  -- rising clock edge
 
      if finish = '1' then
        -- operation finishes
        valid_r <= '0';
      elsif block_overlap_g = 0
        and conf_we_in = '1' and param_cnt_r = last_param_c then
        -- without block overlap, configuration finishes on
        -- third paramater write
        valid_r <= '1';
      elsif block_overlap_g = 1 and end_addr_rdy_r = '1' then
        -- with block overlap, configuration finishes on
        -- end address calculation
        valid_r <= '1';
      else
        valid_r <= valid_r;
      end if;
    end if;
 
  end process valid_proc;
 
  src_addr_proc : process (clk, rst_n)
  begin  -- process src_addr_proc
    if rst_n = '0' then                 -- asynchronous reset (active low)
      src_addr_r <= (others => '0');
    elsif clk'event and clk = '1' then  -- rising clock edge
 
      if read_in = '1' and to_integer(unsigned(amount_r)) = 1 then
        -- line finishes, jump to next line
        src_addr_r <= std_logic_vector(unsigned(src_addr_r) +
                                       unsigned(offset_r) + 1);
      elsif read_in = '1' then
        -- line continues, increase src_addr
        src_addr_r <= std_logic_vector(unsigned(src_addr_r) + 1);
 
      elsif conf_we_in = '1' and param_cnt_r = src_addr_param_c then
        -- configure from sdram2hibi
        src_addr_r <= conf_data_in(mem_addrw_g - 1 downto 0);
      else
        src_addr_r <= src_addr_r;
      end if;
    end if;
  end process src_addr_proc;
 
  width_proc : process (clk, rst_n)
  begin  -- process width_proc
    if rst_n = '0' then                 -- asynchronous reset (active low)
      width_r <= (others => '0');
    elsif clk'event and clk = '1' then  -- rising clock edge
 
      if conf_we_in = '1' and param_cnt_r = width_param_c then
        width_r <= conf_data_in(amountw_g - 1 downto 0);
      else
        width_r <= width_r;
      end if;
    end if;
  end process width_proc;
 
  height_proc : process (clk, rst_n)
  begin  -- process height_proc
    if rst_n = '0' then                 -- asynchronous reset (active low)
      height_r <= (others => '0');
    elsif clk'event and clk = '1' then  -- rising clock edge
      if read_in = '1' and to_integer(unsigned(amount_r)) = 1
        and to_integer(unsigned(height_r)) /= 0 then
        height_r <= std_logic_vector(unsigned(height_r) - 1);
      elsif conf_we_in = '1' and param_cnt_r = height_param_c then
        height_r <= conf_data_in(conf_data_in'length - 1 downto offsetw_g);
      else
        height_r <= height_r;
      end if;
    end if;
  end process height_proc;
 
  offset_proc : process (clk, rst_n)
  begin  -- process offset_proc
    if rst_n = '0' then                 -- asynchronous reset (active low)
      offset_r <= (others => '0');
    elsif clk'event and clk = '1' then  -- rising clock edge
      if conf_we_in = '1' and param_cnt_r = offset_param_c then
        offset_r <= conf_data_in(offsetw_g - 1 downto 0);
      else
        offset_r <= offset_r;
      end if;
    end if;
  end process offset_proc;
 
  end_addr_proc : process (clk, rst_n)
    variable h_times_o_v : integer;
  begin  -- process end_addr_proc
    if rst_n = '0' then                 -- asynchronous reset (active low)
      end_addr_r      <= (others => '0');
      end_addr_rdy_r  <= '0';
      calc_end_addr_r <= '0';
      h_times_o_r     <= (others => '0');
    elsif clk'event and clk = '1' then  -- rising clock edge
 
      h_times_o_r <= h_times_o_r;
 
      if finish = '1' then
        -- opertation finishes
        end_addr_rdy_r  <= '0';
        calc_end_addr_r <= '0';
 
      elsif conf_we_in = '1' and param_cnt_r = src_addr_param_c then
        -- calculate end address in seperate steps
        -- if block_overlap_g = 0:
        --    final end_addr_r = dst_addr_r + width_r
        -- if block_overlap_g = 1:
        --    final end_addr_r = dst_addr_r + width_r + (height_r-1)*offset_r
 
        -- 1) end_addr_r = dst_addr
        end_addr_r      <= conf_data_in(mem_addrw_g - 1 downto 0);
        end_addr_rdy_r  <= '0';
        calc_end_addr_r <= '0';
 
      elsif conf_we_in = '1' and param_cnt_r = width_param_c then
 
        -- 2) end_addr_r = dst_addr + width
        end_addr_r <= std_logic_vector(unsigned(end_addr_r) +
                                       unsigned(conf_data_in(mem_addrw_g - 1
                                                             downto 0)));
        if block_overlap_g = 0 then
          -- If no block overlap, this is the final result
          end_addr_rdy_r  <= '1';
        else
          -- Otherwise we have to calculate more
          end_addr_rdy_r  <= '0';
        end if;
        calc_end_addr_r <= '0';
 
      elsif block_overlap_g = 1 and
        conf_we_in = '1' and param_cnt_r = height_param_c then
 
        -- 3) end_addr_r = dst_addr + width
        --    h_times_o_r = height * offset
 
        h_times_o_v :=
          to_integer(unsigned(conf_data_in(conf_data_in'length - 1
                                           downto offsetw_g))) *
          to_integer(unsigned(conf_data_in(offsetw_g - 1
                                           downto 0)));
 
        h_times_o_r <= std_logic_vector(to_unsigned(h_times_o_v, hibi_dataw_g));
 
        end_addr_rdy_r  <= '0';
        calc_end_addr_r <= '1';
 
      elsif calc_end_addr_r = '1' then
        -- 4) end_addr_r = dst_addr_r + width_r + height_r*offset_r - height_r
        --               = dst_addr_r + amount_r + (height_r-1)*offset_r
        end_addr_r      <= std_logic_vector(
          unsigned(end_addr_r) + unsigned(h_times_o_r(end_addr_r'length - 1 downto 0))
          - unsigned(height_r));
 
        end_addr_rdy_r  <= '1';
        calc_end_addr_r <= '0';
      else
        calc_end_addr_r <= calc_end_addr_r;
        end_addr_rdy_r  <= end_addr_rdy_r;
      end if;
 
    end if;
  end process end_addr_proc;
 
  amount_proc : process (clk, rst_n)
  begin  -- process amount_proc
    if rst_n = '0' then                 -- asynchronous reset (active low)
      amount_r <= (others => '0');
    elsif clk'event and clk = '1' then  -- rising clock edge
 
      if read_in = '1' and to_integer(unsigned(amount_r)) = 1 then
        -- next line on block transfer or transfer finishes
        amount_r <= width_r;
      elsif read_in = '1' then
        -- transfer continues on the same line
        amount_r <= std_logic_vector(unsigned(amount_r) - 1);
      elsif conf_we_in = '1' and param_cnt_r = amount_param_c then
        -- param write from sdram2hibi
        amount_r <= conf_data_in(amountw_g - 1 downto 0);
      end if;
    end if;
  end process amount_proc;
 
  ret_addr_proc: process (clk, rst_n)
  begin  -- process ret_addr_proc
    if rst_n = '0' then                 -- asynchronous reset (active low)
      ret_addr_r <= (others => '0');
    elsif clk'event and clk = '1' then  -- rising clock edge
 
      if conf_we_in = '1' and param_cnt_r = ret_addr_param_c then
        ret_addr_r <= conf_data_in;
      else
        ret_addr_r <= ret_addr_r;
      end if;
    end if;
  end process ret_addr_proc;
end rtl;