PedFetchQueue.vhd

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
use IEEE.STD_LOGIC_MISC.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
Library work;
use work.klm_scint_pkg.all;



entity PedFetchQueue is
    Port (
        clk                : in  STD_logic;
        rst                : in  STD_logic;
        ena                : in  std_logic := '0';
        busy               : out std_logic := '0';

        -- event info
        ch_mask            : in slv15(4 downto 0) := (others=> (others=>'0'));
        new_mask           : in slv15(4 downto 0) := (others=> (others=>'0'));
        thr_chk_busy       : in  std_logic := '0';

        -- wires to PedestalFetcher
        fetch_ena          : out std_logic := '0';
        fetch_ack          : in  std_logic := '0';
        asic_addr          : out  std_logic_vector(2 downto 0) := (others => '0');
        chan_addr          : out  std_logic_vector(3 downto 0) := (others => '0')--;
        -- ped_win_samp_start : out std_logic_vector(13 downto 0)
    );
end PedFetchQueue;

architecture Behavioral of PedFetchQueue is


    type pedestal_queue_state_machine is (
        IDLE,
        CHECK_UPDATE,
        ASIC_LOOP,
        CHAN_LOOP,
        WAIT_ACKNOWLEDGE,
        WAIT_DONE
    );
    signal ped_queue_state : pedestal_queue_state_machine := IDLE;

    signal ena_i            : std_logic_vector(1 downto 0) := "00";
    signal thr_chk_busy_i   : std_logic_vector(1 downto 0) := "00";
    -- signal asic_mask_i      : std_logic_vector(4 downto 0) := (others => '0');
    signal not_done             : std_logic := '0';
    signal not_done_v       : std_logic_vector(4 downto 0) := (others=>'0');
    signal ch_mask_i        : slv15(4 downto 0) := (others=> (others=>'0'));
    signal new_mask_rdy     : std_logic := '0';

begin

    process(clk, ch_mask_i, ena_i)
    begin
        if rising_edge(clk) then
            for asic in 0 to 4 loop
                not_done_v(asic) <= or_reduce(ch_mask_i(asic));
            end loop;
            not_done <= or_reduce(not_done_v) or or_reduce(ena_i);
        end if;
    end process;


    edge_det: process(clk, ena, thr_chk_busy)
    begin
        if rising_edge(clk) then
            ena_i <= ena_i(0) & ena;
            thr_chk_busy_i <= thr_chk_busy_i(0) & thr_chk_busy;
        end if;
    end process edge_det;


    process(clk, thr_chk_busy_i, ch_mask, new_mask, ped_queue_state)
    begin
        if rising_edge(clk) then
            if thr_chk_busy_i = "10" then
                new_mask_rdy <= '1';
            elsif ped_queue_state = IDLE then
                new_mask_rdy <= '0';
            else
                new_mask_rdy <= new_mask_rdy;
            end if;
        end if;
    end process;


    pedestal_fetching_queue : process(clk, ena_i, ch_mask_i, not_done, ch_mask, new_mask)
        variable int_asic : integer range 0 to 4;
        variable int_chan : integer range 0 to 14;
    begin
        if (rising_edge(clk)) then
            if rst = '1' then
                ped_queue_state <= IDLE;
            else
                case ped_queue_state is

                   when IDLE =>
                        ch_mask_i <= ch_mask;
                        if (ena_i = "01") then
                            busy <= '1';
                            ped_queue_state <= ASIC_LOOP;
                        else
                            busy <= '0';
                            ped_queue_state <= IDLE;
                        end if;

                    when CHECK_UPDATE =>
                        if new_mask_rdy = '1' then
                            update_ch_mask : for i in 0 to 4 loop
                                ch_mask_i(i) <= ch_mask_i(i) and new_mask(i);
                            end loop;
                        end if;
                        ped_queue_state <= ASIC_LOOP;

                    when ASIC_LOOP =>
                        if not_done = '1' then
                            for i in 0 to 4 loop
                                if or_reduce(ch_mask_i(i)) = '1' then
                                    asic_addr <= std_logic_vector(to_unsigned(i, 3));
                                    int_asic := i;
                                    exit;
                                end if;
                            end loop;
                            ped_queue_state <= CHAN_LOOP;
                        else
                            busy <= '0';
                            ped_queue_state <= IDLE;
                        end if;


                    when CHAN_LOOP =>
                        if not_done = '1' then
                            for j in 0 to 14 loop
                                if ch_mask_i(int_asic)(j) = '1' then
                                    chan_addr <= std_logic_vector(to_unsigned(j, 4));
                                    int_chan := j;
                                    exit;
                                end if;
                            end loop;
                            ped_queue_state <= WAIT_ACKNOWLEDGE;
                        else
                            busy <= '0';
                            ped_queue_state <= IDLE;
                        end if;


                    when WAIT_ACKNOWLEDGE =>
                        if not_done = '1' then
                            fetch_ena <= '1';
                            if fetch_ack = '1' then
                                fetch_ena <= '0';
                                ped_queue_state <= WAIT_DONE;
                            else
                                ped_queue_state <= WAIT_ACKNOWLEDGE;
                            end if;
                        else
                            busy <= '0';
                            ped_queue_state <= IDLE;
                        end if;


                    when WAIT_DONE =>
                        if not_done = '1' then
                            if fetch_ack = '1' then
                                ped_queue_state <= WAIT_DONE;
                            else
                                ch_mask_i(int_asic)(int_chan) <= '0';
                                ped_queue_state <= CHECK_UPDATE;
                            end if;
                        else
                            busy <= '0';
                            ped_queue_state <= IDLE;
                        end if;


                end case;
            end if;
        end if;
    end process;





end Behavioral;