Subversion Repositories ahb_system_generator

library ieee;

use ieee.std_logic_1164.all;

use ieee.std_logic_unsigned.all;

use ieee.std_logic_misc.all;

use ieee.std_logic_arith.all;

use std.textio.all;

use work.ahb_package.all;

entity mst_wrap is

generic (

--synopsys translate_off

dump_file: in string:= "mst_wrap.log";

dump_type: in integer:= dump_no;

--synopsys translate_on

ahb_max_addr: in integer:= 4;

--***************************************************************

--parameters for master access

--***************************************************************

m_const_lat_write: in integer:= 0;--0 latency states in write

m_const_lat_read: in integer:= 2;--2 cycles to get first data

m_write_burst: in integer := burst_support;--master accepts bursts in write!!!

m_read_burst: in integer := burst_support--master accepts bursts in read!!!

);

port (

  hresetn: in std_logic;

  clk: in std_logic;

  conf: in conf_type_t;

  dma_start: out start_type_t;

  m_wrap_in: in wrap_out_t;

  m_wrap_out: out wrap_in_t);

end mst_wrap;

architecture rtl of mst_wrap is

--synopsys translate_off

--***************************************************************

--**** DUMP OF MEMORY *******************************************

--***************************************************************

file file_descriptor : TEXT open WRITE_MODE is dump_file;

constant msg1: string(1 to 4):= "MEM ";

constant msg3: string(1 to 5):= "DATA ";

procedure Write_Message(msg1:string; addr:in integer; msg2:string; value:in integer) is

variable STR : line;

  begin

    write(STR,now);

    write(STR,STRING'(" "));

    write (STR, msg1);

    write (STR, addr);

    write(STR,STRING'(" "));

    write (STR, msg2);

    write (STR, value);

    writeLine(file_descriptor, STR);

    writeLine(OUTPUT, STR);

  end Write_Message;

--***************************************************************

--***************************************************************

--synopsys translate_on

--***************************************************************

--configuration registers 

--***************************************************************

signal hsize_reg: std_logic_Vector(2 downto 0);

signal priority_reg: std_logic;

signal hburst_reg: std_logic_Vector(2 downto 0);

signal hprot_reg: std_logic_Vector(3 downto 0);

signal trx_dir_reg: std_logic;

signal hlock_reg: std_logic;

signal extaddr: std_logic_Vector(31 downto 0);

signal intaddr: std_logic_Vector(15 downto 0);

signal intmod: std_logic_Vector(15 downto 0);

signal count_reg: std_logic_Vector(15 downto 0);

signal dma_go: std_logic;

--***************************************************************

--***************************************************************

type vect_32 is array (2**ahb_max_addr-1 downto 0) of std_logic_vector (31 downto 0);

signal mem : vect_32;

signal m_lat_write_ok, m_lat_read_ok: std_logic;

signal m_lat_write: integer range 0 to m_const_lat_write;

signal m_lat_read: integer range 0 to m_const_lat_read;

--***************************************************************

--***************************************************************

begin

--***************************************************************

--***************************************************************

--***************** master part *********************************

--***************************************************************

process(clk, hresetn)

begin

  if hresetn='0' then

    m_lat_write <= m_const_lat_write;

  elsif clk'event and clk='1' then

    if (m_wrap_in.take='1') then

      if (m_lat_write_ok='0') then

        m_lat_write <= m_lat_write-1 after 1 ns;

      elsif (m_write_burst=1) then--accepts bursts .....

        m_lat_write <= 0 after 1 ns;

      else

        m_lat_write <= m_const_lat_write after 1 ns;

      end if;

    else

      m_lat_write <= m_const_lat_write after 1 ns;

    end if;

  end if;

end process;

m_lat_write_ok <= '1' when (m_lat_write=0) else '0';

m_wrap_out.take_ok <= '1' when (m_wrap_in.take='1' and m_lat_write_ok='1') else '0';

process(clk, hresetn)

begin

  if hresetn='0' then

    for i in 0 to 2**ahb_max_addr-1 loop

      mem(i) <= conv_std_logic_vector(i, 32);

    end loop;--i

  elsif clk'event and clk='1' then

    if (m_wrap_in.take='1' and m_lat_write_ok='1') then

      mem(conv_integer(m_wrap_in.addr(2+ahb_max_addr-1 downto 2))) <= m_wrap_in.wdata after 1 ns;

--synopsys translate_off

if dump_type/=dump_no then Write_Message(msg1, conv_integer(m_wrap_in.addr(2+ahb_max_addr-1 downto 2)), msg3, conv_integer(m_wrap_in.wdata)); end if;

--synopsys translate_on

    end if;

  end if;

end process;

m_wrap_out.rdata <= mem(conv_integer(m_wrap_in.addr(2+ahb_max_addr-1 downto 2))) when (m_wrap_in.ask='1' and m_lat_read_ok='1') else (others => '-');

process(clk, hresetn)

begin

  if hresetn='0' then

    m_lat_read <= m_const_lat_read;

  elsif clk'event and clk='1' then

    if (m_wrap_in.ask='1') then

      if (m_lat_read_ok='0') then

            m_lat_read <= m_lat_read-1  after 1 ns;

      elsif (m_read_burst=1) then--accepts bursts .....

            m_lat_read <= 0  after 1 ns;

      else

            m_lat_read <= m_const_lat_read  after 1 ns;

      end if;

    else

      m_lat_read <= m_const_lat_read after 1 ns;

    end if;

  end if;

end process;

m_lat_read_ok <= '1' when (m_lat_read=0) else '0';

m_wrap_out.ask_ok <= '1' when (m_wrap_in.ask='1' and m_lat_read_ok='1') else '0';

--**************************************************************************

-- configuration registers write

--**************************************************************************

conf_reg_pr:process(hresetn, clk)

variable addr: std_logic_Vector(3 downto 0);

begin

if hresetn='0' then

  hsize_reg <= bits32;

  priority_reg <= slave;

  hburst_reg <= incr;

  hprot_reg <= "0011";

  trx_dir_reg <= '0';

  hlock_reg <= locked;

  extaddr <= zeroes;

  intaddr <= zeroes(15 downto 0);

  intmod <= conv_std_logic_vector(4, intmod'length);--mod=+4(+1 word32)

  count_reg <= zeroes(15 downto 0);

  dma_go <= '0';

elsif clk'event and clk='1' then

  if (conf.write='1') then

    case conf.addr is

      when dma_extadd_addr =>

        extaddr <= conf.wdata;

      when dma_intadd_addr =>

        intaddr <= conf.wdata(15 downto 0);

      when dma_intmod_addr =>

        intmod <= conf.wdata(15 downto 0);

      when dma_type_addr =>

        priority_reg <= conf.wdata(12);

        hsize_reg <= conf.wdata(11 downto 9);

        hburst_reg <= conf.wdata(8 downto 6);

        hprot_reg <= conf.wdata(5 downto 2);

        trx_dir_reg <= conf.wdata(1);

        hlock_reg <= conf.wdata(0);

      when dma_count_addr =>

        count_reg <= conf.wdata(15 downto 0);

      when others => null;

    end case;

  end if;

  if (conf.write='1' and conf.addr=dma_count_addr) then

    dma_go <= '1';

  else

    dma_go <= '0';

  end if;

 end if;

end process;

--**************************************************************************

--**************************************************************************

--**************************************************************************

--**************************************************************************

  dma_start.extaddr <= extaddr;

  dma_start.intaddr <= intaddr;

  dma_start.intmod <= intmod;

  dma_start.hparams <= "000"&priority_reg&hsize_reg&hburst_reg&hprot_reg&trx_dir_reg&hlock_reg;

  dma_start.count <= count_reg;

  dma_start.start <= dma_go;

end rtl;