Subversion Repositories gecko3

--  GECKO3COM IP Core
--
--  Copyright (C) 2009 by
--   ___    ___   _   _
--  (  _ \ (  __)( ) ( )
--  | (_) )| (   | |_| |   Bern University of Applied Sciences
--  |  _ < |  _) |  _  |   School of Engineering and
--  | (_) )| |   | | | |   Information Technology
--  (____/ (_)   (_) (_)
--
--  This program 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/>.
--
--  URL to the project description: 
--    http://labs.ti.bfh.ch/gecko/wiki/systems/gecko3com/start
--------------------------------------------------------------------------------
--
--  Author:  Christoph Zimmermann
--  Date of creation:  16:52:52 01/28/2010 
--  Description:
--      This is the top module for the GECKO3com simple IP core.
--      Not the one for Xilinx EDK (with PLB bus), for processor less designs.
--
--      This core provides a simple FIFO and register interface to the
--      USB data transfer capabilities of the GECKO3COM/GECKO3main system.
--
--      Look at GECKO3COM_simple_test.vhd for an example how to use it.
--
--  Target Devices:     general
--  Tool versions:      11.1
--  Dependencies:       Xilinx FPGA's Spartan3 and up or Virtex4 and up.
--
--------------------------------------------------------------------------------
 
library IEEE;
use IEEE.STD_LOGIC_1164.all;
use IEEE.STD_LOGIC_ARITH.all;
use IEEE.STD_LOGIC_UNSIGNED.all;
 
library work;
use work.GECKO3COM_defines.all;
 
 
entity GECKO3COM_simple_datapath is
 
  generic (
    BUSWIDTH : integer := 16);
 
  port (
    i_nReset  : in  std_logic;
    i_sysclk  : in  std_logic;
    i_rx_data : in  std_logic_vector(SIZE_DBUS_GPIF-1 downto 0);
    o_tx_data : out std_logic_vector(SIZE_DBUS_GPIF-1 downto 0);
 
    i_receive_fifo_rd_en       : in  std_logic;
    i_receive_fifo_wr_en       : in  std_logic;
    o_receive_fifo_empty       : out std_logic;
    o_receive_fifo_full        : out std_logic;
    o_receive_fifo_data        : out std_logic_vector(BUSWIDTH-1 downto 0);
    i_receive_fifo_reset       : in  std_logic;
    o_receive_transfersize     : out std_logic_vector(31 downto 0);
    i_receive_transfersize_en  : in  std_logic_vector((32/SIZE_DBUS_GPIF)-1 downto 0);
    o_receive_transfersize_lsb : out std_logic;
    i_receive_counter_load     : in  std_logic;
    i_receive_counter_en       : in  std_logic;
    o_receive_counter_zero     : out std_logic;
    o_dev_dep_msg_out          : out std_logic;
    o_request_dev_dep_msg_in   : out std_logic;
    i_btag_reg_en              : in  std_logic;
    i_nbtag_reg_en             : in  std_logic;
    o_btag_correct             : out std_logic;
    o_eom_bit_detected         : out std_logic;
 
    i_send_fifo_rd_en      : in  std_logic;
    i_send_fifo_wr_en      : in  std_logic;
    o_send_fifo_empty      : out std_logic;
    o_send_fifo_full       : out std_logic;
    i_send_fifo_data       : in  std_logic_vector(BUSWIDTH-1 downto 0);
    i_send_fifo_reset      : in  std_logic;
    i_send_transfersize    : in  std_logic_vector(31 downto 0);
    i_send_transfersize_en : in  std_logic;
    i_send_have_more_data  : in  std_logic;
    i_send_counter_load    : in  std_logic;
    i_send_counter_en      : in  std_logic;
    o_send_counter_zero    : out std_logic;
    i_send_mux_sel         : in  std_logic_vector(2 downto 0);
 
    i_receive_newdata_set        : in  std_logic;
    o_receive_newdata            : out std_logic;
    i_receive_end_of_message_set : in  std_logic;
    o_receive_end_of_message     : out std_logic;
    i_send_data_request_set      : in  std_logic;
    o_send_data_request          : out std_logic);
 
end GECKO3COM_simple_datapath;
 
architecture behaviour of GECKO3COM_simple_datapath is
 
  -----------------------------------------------------------------------------
  -- COMPONENTS
  -----------------------------------------------------------------------------
 
  component receive_fifo
    generic (
      BUSWIDTH : integer);
    port (
      i_din   : in  std_logic_vector(SIZE_DBUS_GPIF-1 downto 0);
      i_clk   : in  std_logic;
      i_rd_en : in  std_logic;
      i_rst   : in  std_logic;
      i_wr_en : in  std_logic;
      o_dout  : out std_logic_vector(BUSWIDTH-1 downto 0);
      o_empty : out std_logic;
      o_full  : out std_logic);
  end component;
 
  component send_fifo
    generic (
      BUSWIDTH : integer);
    port (
      i_din   : in  std_logic_vector(BUSWIDTH-1 downto 0);
      i_clk   : in  std_logic;
      i_rd_en : in  std_logic;
      i_rst   : in  std_logic;
      i_wr_en : in  std_logic;
      o_dout  : out std_logic_vector(SIZE_DBUS_GPIF-1 downto 0);
      o_empty : out std_logic;
      o_full  : out std_logic);
  end component;
 
 
  -----------------------------------------------------------------------------
  -- interconection signals
  -----------------------------------------------------------------------------
 
  signal s_receive_transfersize  : std_logic_vector(31 downto 0);
  signal s_send_transfersize_reg : std_logic_vector(31 downto 0);
 
  signal s_receive_transfersize_count : std_logic_vector(30 downto 0);
  signal s_send_transfersize_count    : std_logic_vector(30 downto 0);
 
  signal s_receive_fifo_empty : std_logic;
 
  signal s_send_fifo_data     : std_logic_vector(SIZE_DBUS_GPIF-1 downto 0);
  signal s_btag, s_nbtag, s_msg_id : std_logic_vector(7 downto 0);
 
begin  -- behaviour
 
  receive_fifo_1 : receive_fifo
    generic map (
      BUSWIDTH => BUSWIDTH)
    port map (
      i_din   => i_rx_data,
      i_clk   => i_sysclk,
      i_rd_en => i_receive_fifo_rd_en,
      i_rst   => i_receive_fifo_reset,
      i_wr_en => i_receive_fifo_wr_en,
      o_dout  => o_receive_fifo_data,
      o_empty => s_receive_fifo_empty,
      o_full  => o_receive_fifo_full);
 
  send_fifo_1 : send_fifo
    generic map (
      BUSWIDTH => BUSWIDTH)
    port map (
      i_din   => i_send_fifo_data,
      i_clk   => i_sysclk,
      i_rd_en => i_send_fifo_rd_en,
      i_rst   => i_send_fifo_reset,
      i_wr_en => i_send_fifo_wr_en,
      o_dout  => s_send_fifo_data,
      o_empty => o_send_fifo_empty,
      o_full  => o_send_fifo_full);
 
 
  o_receive_fifo_empty <= s_receive_fifo_empty;
 
  -- purpose: process to fill the 32 bit receive_transfersize register with 8
  --          or 16 bit wide input data.
  -- type   : sequential
  -- inputs : i_sysclk, i_nReset, i_rx_data, i_receive_transfersize_en
  receive_transfersize : process (i_sysclk, i_nReset)
  begin  -- process registers
    if i_nReset = '0' then              -- asynchronous reset (active low)
      s_receive_transfersize <= (others => '0');
    elsif i_sysclk'event and i_sysclk = '1' then  -- rising clock edge
      if i_receive_transfersize_en(0) = '1' then
        s_receive_transfersize(15 downto 0) <= i_rx_data;
      end if;
      if i_receive_transfersize_en(1) = '1' then
        s_receive_transfersize(31 downto 16) <= i_rx_data;
      end if;
    end if;
  end process receive_transfersize;
 
  o_receive_transfersize <= s_receive_transfersize;
  o_receive_transfersize_lsb <= s_receive_transfersize(0);
 
 
  -- purpose: 32 bit send_transfersize register
  -- type   : sequential
  -- inputs : i_sysclk, i_nReset, i_send_transfersize, i_receive_transfersize_en
  send_transfersize : process (i_sysclk, i_nReset)
  begin  -- process registers
    if i_nReset = '0' then              -- asynchronous reset (active low)
      s_send_transfersize_reg <= (others => '0');
    elsif i_sysclk'event and i_sysclk = '1' then  -- rising clock edge
      if i_send_transfersize_en = '1' then
        s_send_transfersize_reg <= i_send_transfersize;
      end if;
    end if;
  end process send_transfersize;
 
 
  -- purpose: down counter for the receive transfer size
  -- type   : sequential
  -- inputs : i_sysclk, i_nReset, s_reveive_transfersize,
  --          i_receive_transfersize_en
  -- outputs: s_receive_transfersize_count
  receive_counter : process (i_sysclk, i_nReset)
  begin  -- process receive_counter
    if i_nReset = '0' then              -- asynchronous reset (active low)
      s_receive_transfersize_count <= (others => '0');
    elsif i_sysclk'event and i_sysclk = '1' then  -- rising clock edge
      if i_receive_counter_load = '1' then
        s_receive_transfersize_count <= s_receive_transfersize(31 downto 1);
      elsif i_receive_counter_en = '1' then
        s_receive_transfersize_count <= s_receive_transfersize_count - 1;
      else
        s_receive_transfersize_count <= s_receive_transfersize_count;
      end if;
    end if;
  end process receive_counter;
 
  o_receive_counter_zero <=
    '1' when s_receive_transfersize_count = "000000000000000000000000000000"
    else '0';
 
 
  -- purpose: down counter for the send transfer size
  -- type   : sequential
  -- inputs : i_sysclk, i_nReset, s_send_transfersize_reg,
  --          i_send_transfersize_en
  -- outputs: s_send_transfersize_count
  send_counter : process (i_sysclk, i_nReset)
  begin  -- process send_counter
    if i_nReset = '0' then              -- asynchronous reset (active low)
      s_send_transfersize_count <= (others => '0');
    elsif i_sysclk'event and i_sysclk = '1' then  -- rising clock edge
      if i_send_counter_load = '1' then
        s_send_transfersize_count <= s_send_transfersize_reg(31 downto 1);
      elsif i_send_counter_en = '1' then
        s_send_transfersize_count <= s_send_transfersize_count - 1;
      else
        s_send_transfersize_count <= s_send_transfersize_count;
      end if;
    end if;
  end process send_counter;
 
  o_send_counter_zero <=
    '1' when s_send_transfersize_count = "000000000000000000000000000000"
    else '0';
 
 
  -- purpose: registers to store the btag and inverse btag
  -- type   : sequential
  -- inputs : i_sysclk, i_nReset, i_btag_reg_en, i_nbtag_reg_en
  --          i_rx_data
  -- outputs: s_btag, s_nbtag
  btag_register : process (i_sysclk, i_nReset)
  begin  -- process btag_register
    if i_nReset = '0' then              -- asynchronous reset (active low)
      s_btag   <= (others => '0');
      s_msg_id <= (others => '0');
      s_nbtag  <= (others => '0');
    elsif i_sysclk'event and i_sysclk = '1' then  -- rising clock edge
      if i_btag_reg_en = '1' then
        s_btag   <= i_rx_data(15 downto 8);
        s_msg_id <= i_rx_data(7 downto 0);
      end if;
      if i_nbtag_reg_en = '1' then
        s_nbtag <= i_rx_data(7 downto 0);
      end if;
    end if;
  end process btag_register;
 
  o_btag_correct <=
    '1' when s_btag = not s_nbtag else
    '0';
 
 
  o_dev_dep_msg_out <=
    '1' when s_msg_id(7 downto 0) = x"01" else
    '0';
 
  o_request_dev_dep_msg_in <=
    '1' when s_msg_id(7 downto 0) = x"02" else
    '0';
 
  o_eom_bit_detected <=
    '1' when i_rx_data(7 downto 0) = b"00000001" else
    '0';
 
 
  -- purpose: mulitiplexer to construct the tmc header structure
  -- type   : combinational
  -- inputs : i_send_mux_sel, i_send_have_more_data, s_btag, s_nbtag,
  --          s_send_fifo_data, s_send_transfersize_reg
  -- outputs: o_tx_data
  tx_data_mux : process (i_send_mux_sel, i_send_have_more_data, s_btag,
                         s_msg_id, s_nbtag, s_send_fifo_data,
                         s_send_transfersize_reg)
  begin  -- process tx_data_mux
    case i_send_mux_sel is
      when "000"  => o_tx_data <= s_btag & s_msg_id; -- MsgID and stored bTag
      when "001"  => o_tx_data <= x"00" & s_nbtag; -- inverted bTag and Reserved
      when "010"  => o_tx_data <= s_send_transfersize_reg(15 downto 0);
      when "011"  => o_tx_data <= s_send_transfersize_reg(31 downto 16);
                    --TransferAttributes EOM bit:
      when "100"  => o_tx_data <= b"000000000000000" & not i_send_have_more_data;
      when "101"  => o_tx_data <= x"0000";  -- Header byte 10 and 11, Reserved
      when "110"  => o_tx_data <= s_send_fifo_data;  -- message data
      when others => o_tx_data <= s_btag & s_msg_id; -- MsgID and stored bTag
    end case;
  end process tx_data_mux;
 
 
  -- purpose: set and reset behavour for the status flags
  -- type   : sequential
  -- inputs : i_sysclk, i_nReset, i_receive_newdata_set,
  --          i_receive_end_of_message_set, s_send_data_request_set,
  --          i_receive_fifo_rd_en, s_receive_fifo_empty, i_send_fifo_wr_en
  -- outputs: o_receive_newdata, o_receive_end_of_message, o_send_data_request
  gecko3com_simple_flags : process (i_sysclk, i_nReset)
    variable v_receive_fifo_empty_old : std_logic;
  begin  -- process gecko3com_simple_flags
    if i_nReset = '0' then              -- asynchronous reset (active low)
      o_receive_newdata        <= '0';
      o_receive_end_of_message <= '0';
      o_send_data_request      <= '0';
      v_receive_fifo_empty_old := '0';
    elsif i_sysclk'event and i_sysclk = '1' then  -- rising clock edge
      if i_receive_newdata_set = '1' then
        o_receive_newdata <= '1';
      end if;
      if i_receive_fifo_rd_en = '1' then
        o_receive_newdata <= '0';
      end if;
 
      if i_receive_end_of_message_set = '1' then
        o_receive_end_of_message <= '1';
      end if;
      if s_receive_fifo_empty = '1' and v_receive_fifo_empty_old = '0' then
        o_receive_end_of_message <= '0';
      end if;
      v_receive_fifo_empty_old := s_receive_fifo_empty;
 
      if i_send_data_request_set = '1' then
        o_send_data_request <= '1';
      end if;
      if i_send_fifo_wr_en = '1' then
        o_send_data_request <= '0';
      end if;
    end if;
  end process gecko3com_simple_flags;
 
 
end behaviour;