Subversion Repositories core_arm

-- $(lic)
-- $(help_generic)
-- $(help_local)
 
library ieee;
use ieee.std_logic_1164.all;
use work.config.all;
use work.iface.all;
use work.target.all;
use work.kecs_config.all;
use work.kecs_libiface.all;
use work.kecs_libwb.all;
use work.kehl_libint.all;
use work.tech_map.all;
 
entity kecs_wbfifo is
  generic (
    WBBUF_SZ : integer := 2
  );
  port ( 
    rst : in  std_logic; 
    clk : in  clk_type;
    wbfifoi : in  kcif_ketyp_wbfifo_in;
    wbfifoo : out kcif_ketyp_wbfifo_out
  );
end kecs_wbfifo;
 
architecture rtl of kecs_wbfifo is
 
  type kecswbfifo_tmp_type is record
     wbfifoo : kcif_ketyp_wbfifo_out;
     readint, writeint : std_logic;
 
  end record;
  type kecswbfifo_reg_type is record
     buf : kclw_ketyp_entry_a((WBBUF_SZ)-1 downto 0);
     cur, set : std_logic_vector((log2(WBBUF_SZ))-1 downto 0);
     empty : std_logic;
  end record;
  type kecswbfifo_dbg_type is record
     dummy : std_logic;
     -- pragma translate_off
     wbaddr : std_logic_vector(31 downto 0);
     dbg : kecswbfifo_tmp_type;
     -- pragma translate_on
  end record;
  signal r, c       : kecswbfifo_reg_type;
  signal rdbg, cdbg : kecswbfifo_dbg_type;
 
 
begin  
 
  p0: process (clk, rst, r, wbfifoi )
    variable v    : kecswbfifo_reg_type;
    variable t    : kecswbfifo_tmp_type;
    variable vdbg : kecswbfifo_dbg_type;
  begin 
 
    -- $(init(t:kecswb_tmp_type))
    v := r;
 
 
    --$(del)             wbfifoo.entry_r  
    --       +-------+ <-cur   /\
    --       | xxxxx |  -------+ 
    --       +-------+
    --       | xxxxx |
    --       +-------+ <-set
    --       |       |
    --       .       .
    --       .       .
    --       +-------+
    --       |       |
    --       +-------+
    --$(/del)
 
    t.wbfifoo.fifo_entry := r.buf(khin_convint(r.cur));
    t.wbfifoo.fifo_empty_r := r.empty;
 
    t.readint := wbfifoi.fifo_read;
    t.writeint := wbfifoi.fifo_write;
    t.wbfifoo.fifo_stored_v := wbfifoi.fifo_write;
 
    if t.writeint = '1' then
      if r.cur = r.set then
        if (r.empty = '0') then
          if (wbfifoi.fifo_read = '0') then
            t.writeint := '0';
            t.wbfifoo.fifo_stored_v := '0';
          end if;
        end if;
      end if;
      if t.writeint = '1' then
        v.buf(khin_convint(r.set)) := wbfifoi.fifo_entry;
        khin_incdec(r.set,v.set,'1','1');
        v.empty := '0';
      end if;
    end if;
 
    if t.readint = '1' then
      khin_incdec(r.cur,v.cur,'1','1');
      if v.cur = v.set then
        if t.wbfifoo.fifo_stored_v = '0' then
          v.empty := '1';
        end if;
      end if;
    end if;
 
 
    -- reset
    if ( rst = '0' ) then
      v.empty := '1';
      v.cur := (others => '0');
      v.set := (others => '0');
    end if;
 
    c <= v;
 
    wbfifoo <= t.wbfifoo;
 
    -- pragma translate_off
    vdbg := rdbg;
    vdbg.dbg := t;
    cdbg <= vdbg;
    -- pragma translate_on  end process p0;
 
  end process p0;
 
  pregs : process (clk, c)
  begin
    if rising_edge(clk) then
      r <= c;
      -- pragma translate_off
      rdbg <= cdbg;
      -- pragma translate_on
    end if;
  end process;
 
  -- pragma translate_off
  check0 : process (clk)
  begin
    if falling_edge(clk) then
      if wbfifoi.fifo_read = '1' then
        assert (r.empty = '0') report "Read on empty fifo" severity failure;
      end if;
    end if;
  end process;
  -- pragma translate_on  end process p0;
 
end rtl;