Subversion Repositories rio

-------------------------------------------------------------------------------

-- 

-- RapidIO IP Library Core

-- 

-- This file is part of the RapidIO IP library project

-- http://www.opencores.org/cores/rio/

-- 

-- Description

-- Contains a converter of RapidIO maintenance packets into a Wishbone similar

-- access. It relies on the Maintenance-packet modules from

-- RioLogicalPackets.vhd to function.

-- 

-- To Do:

-- - Clean up the code for reading. Works but it is messy.

-- 

-- Author(s): 

-- - Magnus Rosenius, magro732@opencores.org 

-- 

-------------------------------------------------------------------------------

-- 

-- Copyright (C) 2013 Authors and OPENCORES.ORG 

-- 

-- This source file may be used and distributed without 

-- restriction provided that this copyright statement is not 

-- removed from the file and that any derivative work contains 

-- the original copyright notice and the associated disclaimer. 

-- 

-- This source file is free software; you can redistribute it 

-- and/or modify it under the terms of the GNU Lesser General 

-- Public License as published by the Free Software Foundation; 

-- either version 2.1 of the License, or (at your option) any 

-- later version. 

-- 

-- This source 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 Lesser General Public License for more 

-- details. 

-- 

-- You should have received a copy of the GNU Lesser General 

-- Public License along with this source; if not, download it 

-- from http://www.opencores.org/lgpl.shtml 

-- 

-------------------------------------------------------------------------------

-------------------------------------------------------------------------------

-- RioLogicalMaintenance

-- This logical layer module handles ingress maintenance requests and converts

-- them into accesses on a Wishbone similar bus accessing the configuration

-- space.

-------------------------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

use ieee.numeric_std.all;

use work.rio_common.all;

-------------------------------------------------------------------------------

-- Entity for RioLogicalMaintenance.

-------------------------------------------------------------------------------

entity RioLogicalMaintenance is

  port(

    clk : in std_logic;

    areset_n : in std_logic;

    enable : in std_logic;

    readRequestReady_i : in std_logic;

    writeRequestReady_i : in std_logic;

    size_i : in std_logic_vector(3 downto 0);

    offset_i : in std_logic_vector(20 downto 0);

    wdptr_i : in std_logic;

    payloadLength_i : in std_logic_vector(2 downto 0);

    payloadIndex_o : out std_logic_vector(2 downto 0);

    payload_i : in std_logic_vector(63 downto 0);

    done_o : out std_logic;

    readResponseReady_o : out std_logic;

    writeResponseReady_o : out std_logic;

    status_o : out std_logic_vector(3 downto 0);

    payloadLength_o : out std_logic_vector(2 downto 0);

    payloadIndex_i : in std_logic_vector(2 downto 0);

    payload_o : out std_logic_vector(63 downto 0);

    done_i : in std_logic;

    configStb_o : out std_logic;

    configWe_o : out std_logic;

    configAdr_o : out std_logic_vector(21 downto 0);

    configDat_o : out std_logic_vector(31 downto 0);

    configDat_i : in std_logic_vector(31 downto 0);

    configAck_i : in std_logic);

end entity;

-------------------------------------------------------------------------------

-- 

-------------------------------------------------------------------------------

architecture RioLogicalMaintenance of RioLogicalMaintenance is

  type StateType is (IDLE,

                     CONFIG_READ_START, CONFIG_READ, CONFIG_READ_NEXT, CONFIG_READ_RESPONSE,

                     CONFIG_WRITE_START, CONFIG_WRITE, CONFIG_WRITE_NEXT, CONFIG_WRITE_RESPONSE,

                     WAIT_REQUEST);

  signal state : StateType;

  signal payloadLength : std_logic_vector(3 downto 0);

  signal payloadIndex : std_logic_vector(3 downto 0);

  signal payloadWrite : std_logic;

  signal payloadAddress : std_logic_vector(2 downto 0);

  signal payload : std_logic_vector(63 downto 0);

  signal configAdr : std_logic_vector(21 downto 0);

  signal configDat : std_logic_vector(31 downto 0);

begin

  configAdr_o <= configAdr;

  configDat_o <= configDat;

  payloadLength_o <= payloadLength(3 downto 1);

  payloadIndex_o <= payloadIndex(3 downto 1);

  -----------------------------------------------------------------------------

  -- 

  -----------------------------------------------------------------------------

  Maintenance: process(clk, areset_n)

  begin

    if (areset_n = '0') then

      state <= IDLE;

      readResponseReady_o <= '0';

      writeResponseReady_o <= '0';

      done_o <= '0';

      configStb_o <= '0';

      configWe_o <= '0';

      configAdr <= (others=>'0');

      configDat <= (others=>'0');

      payloadWrite <= '0';

      payloadIndex <= (others=>'0');

      payload <= (others=>'0');

    elsif (clk'event and clk = '1') then

      payloadWrite <= '0';

      case state is

        when IDLE =>

          ---------------------------------------------------------------------

          -- 

          ---------------------------------------------------------------------

          payloadIndex <= (others=>'0');

          done_o <= '0';

          if (readRequestReady_i = '1') then

            state <= CONFIG_READ_START;

          elsif (writeRequestReady_i = '1') then

            state <= CONFIG_WRITE_START;

          end if;

        when CONFIG_READ_START =>

          ---------------------------------------------------------------------

          -- 

          ---------------------------------------------------------------------

          configStb_o <= '1';

          configWe_o <= '0';

          if (size_i = "1000") then

            configAdr <= offset_i & wdptr_i;

          else

            configAdr <= offset_i & '0';

          end if;

          payloadIndex <= "0000";

          payload <= (others=>'0');

          state <= CONFIG_READ;

        when CONFIG_READ =>

          ---------------------------------------------------------------------

          -- 

          ---------------------------------------------------------------------

          if (configAck_i = '1') then

            configStb_o <= '0';

            configAdr <= std_logic_vector(unsigned(configAdr) + 1);

            state <= CONFIG_READ_NEXT;

          end if;

          if (size_i = "1000") and (wdptr_i = '0') then

            payload(63 downto 32) <= configDat_i;

          elsif (size_i = "1000") and (wdptr_i = '1') then

            payload(31 downto 0) <= configDat_i;

          else

            if (payloadIndex(0) = '0') then

              payload(63 downto 32) <= configDat_i;

            else

              payload(31 downto 0) <= configDat_i;

            end if;

          end if;

        when CONFIG_READ_NEXT =>

          ---------------------------------------------------------------------

          -- 

          ---------------------------------------------------------------------

          if (size_i = "1000") and (wdptr_i = '0') then

            -- 1 word.

            status_o <= "0000";

            payloadLength <= "0010";

            payloadWrite <= '1';

            state <= CONFIG_READ_RESPONSE;

          elsif (size_i = "1000") and (wdptr_i = '1') then

            -- 1 word.

            status_o <= "0000";

            payloadLength <= "0010";

            payloadWrite <= '1';

            state <= CONFIG_READ_RESPONSE;

          elsif (size_i = "1011") and (wdptr_i = '0') then

            -- 2 words.

            status_o <= "0000";

            payloadLength <= "0010";

            payloadWrite <= payloadIndex(0);

            if (payloadIndex = "0001") then

              state <= CONFIG_READ_RESPONSE;

            else

              configStb_o <= '1';

              state <= CONFIG_READ;

            end if;

          elsif (size_i = "1011") and (wdptr_i = '1') then

            -- 4 words.

            status_o <= "0000";

            payloadLength <= "0100";

            payloadWrite <= payloadIndex(0);

            if (payloadIndex = "0011") then

              state <= CONFIG_READ_RESPONSE;

            else

              configStb_o <= '1';

              state <= CONFIG_READ;

            end if;

          elsif (size_i = "1100") and (wdptr_i = '0') then

            -- 8 words.

            status_o <= "0000";

            payloadLength <= "1000";

            payloadWrite <= payloadIndex(0);

            if (payloadIndex = "0111") then

              state <= CONFIG_READ_RESPONSE;

            else

              configStb_o <= '1';

              state <= CONFIG_READ;

            end if;

          elsif (size_i = "1100") and (wdptr_i = '1') then

            -- 16 words.

            status_o <= "0000";

            payloadLength <= "0000";

            payloadWrite <= payloadIndex(0);

            if (payloadIndex = "1111") then

              state <= CONFIG_READ_RESPONSE;

            else

              configStb_o <= '1';

              state <= CONFIG_READ;

            end if;

          else

            -- Unallowed packet.

            -- Send write-response with status indicating error.

            status_o <= "0111";

            state <= CONFIG_READ_RESPONSE;

          end if;

          payloadAddress <= payloadIndex(3 downto 1);

          payloadIndex <= std_logic_vector(unsigned(payloadIndex) + 1);

        when CONFIG_READ_RESPONSE =>

          ---------------------------------------------------------------------

          -- 

          ---------------------------------------------------------------------

          if (done_i = '1') then

            readResponseReady_o <= '0';

            state <= WAIT_REQUEST;

          else

            readResponseReady_o <= '1';

          end if;

        when CONFIG_WRITE_START =>

          ---------------------------------------------------------------------

          -- 

          ---------------------------------------------------------------------

          configWe_o <= '1';

          if (size_i = "1000") then

            configAdr <= offset_i & wdptr_i;

          else

            configAdr <= offset_i & '0';

          end if;

          if (size_i = "1000") and (wdptr_i = '0') then

            -- 1 word.

            configStb_o <= '1';

            configDat <= payload_i(63 downto 32);

            payloadLength <= "0001";

            status_o <= "0000";

            state <= CONFIG_WRITE;

          elsif (size_i = "1000") and (wdptr_i = '1') then

            -- 1 word.

            configStb_o <= '1';

            configDat <= payload_i(31 downto 0);

            payloadLength <= "0001";

            status_o <= "0000";

            state <= CONFIG_WRITE;

          elsif (size_i = "1011") and (wdptr_i = '0') then

            -- 2 words.

            configStb_o <= '1';

            configDat <= payload_i(63 downto 32);

            payloadLength <= "0010";

            status_o <= "0000";

            state <= CONFIG_WRITE;

          elsif (size_i = "1011") and (wdptr_i = '1') then

            -- maximum 4 words.

            configStb_o <= '1';

            configDat <= payload_i(63 downto 32);

            payloadLength <= payloadLength_i & '0';

            status_o <= "0000";

            state <= CONFIG_WRITE;

          elsif (size_i = "1100") and (wdptr_i = '0') then

            -- maximum 8 words.

            configStb_o <= '1';

            configDat <= payload_i(63 downto 32);

            payloadLength <= payloadLength_i & '0';

            status_o <= "0000";

            state <= CONFIG_WRITE;

          elsif (size_i = "1100") and (wdptr_i = '1') then

            -- maximum 16 words.

            configStb_o <= '1';

            configDat <= payload_i(63 downto 32);

            payloadLength <= payloadLength_i & '0';

            status_o <= "0000";

            state <= CONFIG_WRITE;

          else

            -- Unallowed packet.

            -- Send write-response with status indicating error.

            status_o <= "0111";

            state <= CONFIG_WRITE_RESPONSE;

          end if;

          payloadIndex <= std_logic_vector(unsigned(payloadIndex) + 1);

        when CONFIG_WRITE =>

          ---------------------------------------------------------------------

          -- 

          ---------------------------------------------------------------------

          if (configAck_i = '1') then

            configStb_o <= '0';

            configAdr <= std_logic_vector(unsigned(configAdr) + 1);

            state <= CONFIG_WRITE_NEXT;

          end if;

        when CONFIG_WRITE_NEXT =>

          ---------------------------------------------------------------------

          -- 

          ---------------------------------------------------------------------

          if (payloadIndex(0) = '0') then

            configDat <= payload_i(63 downto 32);

          else

            configDat <= payload_i(31 downto 0);

          end if;

          payloadIndex <= std_logic_vector(unsigned(payloadIndex) + 1);

          if (payloadIndex /= payloadLength) then

            configStb_o <= '1';

            state <= CONFIG_WRITE;

          else

            state <= CONFIG_WRITE_RESPONSE;

          end if;

        when CONFIG_WRITE_RESPONSE =>

          ---------------------------------------------------------------------

          -- 

          ---------------------------------------------------------------------

          if (done_i = '1') then

            writeResponseReady_o <= '0';

            state <= WAIT_REQUEST;

          else

            writeResponseReady_o <= '1';

          end if;

        when WAIT_REQUEST =>

          ---------------------------------------------------------------------

          -- 

          ---------------------------------------------------------------------

          done_o <= '1';

          if (readRequestReady_i = '0') and (writeRequestReady_i = '0') then

            state <= IDLE;

          end if;

        when others =>

      end case;

    end if;

  end process;

  -----------------------------------------------------------------------------

  -- Payload content memory.

  -----------------------------------------------------------------------------

  PayloadMemory: MemorySimpleDualPort

    generic map(ADDRESS_WIDTH=>3, DATA_WIDTH=>64)

    port map(clkA_i=>clk,

             enableA_i=>payloadWrite,

             addressA_i=>payloadAddress,

             dataA_i=>payload,

             clkB_i=>clk,

             enableB_i=>'1',

             addressB_i=>payloadIndex_i,

             dataB_o=>payload_o);

end architecture;