Subversion Repositories rio

-------------------------------------------------------------------------------
-- 
-- RapidIO IP Library Core
-- 
-- This file is part of the RapidIO IP library project
-- http://www.opencores.org/cores/rio/
-- 
-- Description
-- This file contains a PCS (Physical Control Sublayer) that can transfer
-- RapidIO symbols accross a 2Mbit 8-bit UART transmission channel.
-- The coding is similar to the coding used by PPP and uses flags (0x7e)
-- and escape-sequences (0x7d) to encode special characters.
-- 
-- To Do:
-- -
-- 
-- 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 
-- 
-------------------------------------------------------------------------------
 
-------------------------------------------------------------------------------
-- RioPcsUart
-------------------------------------------------------------------------------
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use work.rio_common.all;
 
 
-------------------------------------------------------------------------------
-- Entity for RioPcsUart.
-------------------------------------------------------------------------------
entity RioPcsUart is
  generic(
    DIVISOR_WIDTH : natural);
  port(
    clk : in std_logic;
    areset_n : in std_logic;
 
    divisor_i : in std_logic_vector(DIVISOR_WIDTH-1 downto 0);
 
    portInitialized_o : out std_logic;
    outboundSymbolEmpty_i : in std_logic;
    outboundSymbolRead_o : out std_logic;
    outboundSymbol_i : in std_logic_vector(33 downto 0);
    inboundSymbolFull_i : in std_logic;
    inboundSymbolWrite_o : out std_logic;
    inboundSymbol_o : out std_logic_vector(33 downto 0);
 
    serial_o : out std_logic;
    serial_i : in std_logic);
end entity;
 
 
-------------------------------------------------------------------------------
-- Architecture for RioPcsUart.
-------------------------------------------------------------------------------
architecture RioPcsUartImpl of RioPcsUart is
 
  component RioSymbolConverter is
    port(
      clk : in std_logic;
      areset_n : in std_logic;
 
      portInitialized_o : out std_logic;
      outboundSymbolEmpty_i : in std_logic;
      outboundSymbolRead_o : out std_logic;
      outboundSymbol_i : in std_logic_vector(33 downto 0);
      inboundSymbolFull_i : in std_logic;
      inboundSymbolWrite_o : out std_logic;
      inboundSymbol_o : out std_logic_vector(33 downto 0);
 
      uartEmpty_i : in std_logic;
      uartRead_o : out std_logic;
      uartData_i : in std_logic_vector(7 downto 0);
      uartFull_i : in std_logic;
      uartWrite_o : out std_logic;
      uartData_o : out std_logic_vector(7 downto 0));
  end component;
 
  component Uart is
    generic(
      DIVISOR_WIDTH : natural;
      DATA_WIDTH : natural);
    port(
      clk : in std_logic;
      areset_n : in std_logic;
 
      divisor_i : in std_logic_vector(DIVISOR_WIDTH-1 downto 0);
 
      serial_i : in std_logic;
      serial_o : out std_logic;
 
      empty_o : out std_logic;
      read_i : in std_logic;
      data_o : out std_logic_vector(DATA_WIDTH-1 downto 0);
 
      full_o : out std_logic;
      write_i : in std_logic;
      data_i : in std_logic_vector(DATA_WIDTH-1 downto 0));
  end component;
 
  signal uartEmpty : std_logic;
  signal uartRead : std_logic;
  signal uartReadData : std_logic_vector(7 downto 0);
  signal uartFull : std_logic;
  signal uartWrite : std_logic;
  signal uartWriteData : std_logic_vector(7 downto 0);
 
begin
 
  SymbolConverter: RioSymbolConverter
    port map(
      clk=>clk, areset_n=>areset_n, 
      portInitialized_o=>portInitialized_o,
      outboundSymbolEmpty_i=>outboundSymbolEmpty_i,
      outboundSymbolRead_o=>outboundSymbolRead_o, outboundSymbol_i=>outboundSymbol_i, 
      inboundSymbolFull_i=>inboundSymbolFull_i,
      inboundSymbolWrite_o=>inboundSymbolWrite_o, inboundSymbol_o=>inboundSymbol_o, 
      uartEmpty_i=>uartEmpty, uartRead_o=>uartRead, uartData_i=>uartReadData, 
      uartFull_i=>uartFull, uartWrite_o=>uartWrite, uartData_o=>uartWriteData);
 
  UartInst: Uart
    generic map(DIVISOR_WIDTH=>DIVISOR_WIDTH, DATA_WIDTH=>8)
    port map(
      clk=>clk, areset_n=>areset_n,
      divisor_i=>divisor_i,
      serial_i=>serial_i, serial_o=>serial_o,
      empty_o=>uartEmpty, read_i=>uartRead, data_o=>uartReadData,
      full_o=>uartFull, write_i=>uartWrite, data_i=>uartWriteData);
 
end architecture;
 
 
 
-------------------------------------------------------------------------------
-- This module encodes and decodes RapidIO symbols for transmission on a 8-bit
-- UART using HDLC-like framing (see PPP).
-- When an idle-symbol is received it will be preceeded by an idle link for a
-- few micro seconds. This idle link time is used to synchronize the receiver
-- in the link partner that needs to know when a character is starting and not.
-------------------------------------------------------------------------------
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use work.rio_common.all;
 
 
-------------------------------------------------------------------------------
-- Entity for RioSymbolConverter.
-------------------------------------------------------------------------------
entity RioSymbolConverter is
  port(
    clk : in std_logic;
    areset_n : in std_logic;
 
    portInitialized_o : out std_logic;
    outboundSymbolEmpty_i : in std_logic;
    outboundSymbolRead_o : out std_logic;
    outboundSymbol_i : in std_logic_vector(33 downto 0);
    inboundSymbolFull_i : in std_logic;
    inboundSymbolWrite_o : out std_logic;
    inboundSymbol_o : out std_logic_vector(33 downto 0);
 
    uartEmpty_i : in std_logic;
    uartRead_o : out std_logic;
    uartData_i : in std_logic_vector(7 downto 0);
    uartFull_i : in std_logic;
    uartWrite_o : out std_logic;
    uartData_o : out std_logic_vector(7 downto 0));
end entity;
 
 
-------------------------------------------------------------------------------
-- Architecture for RioSymbolConverter.
-------------------------------------------------------------------------------
architecture RioSymbolConverterImpl of RioSymbolConverter is
 
  -- Define the flag sequence and the control escape sequence.
  constant FLAG_SEQUENCE : std_logic_vector(7 downto 0) := x"7e";
  constant CONTROL_ESCAPE : std_logic_vector(7 downto 0) := x"7d";
  constant SILENCE_TIME : natural := 4095;
  constant IDLE_SYMBOL_TIME : natural := 256;
  constant LINK_LOST_TIME : natural := 4095;
 
  type TxStateType is (STATE_SILENCE, STATE_IDLE_0, STATE_IDLE_1,
                       STATE_BUSY_1, STATE_BUSY_2, STATE_SEND_FLAG);
  signal txState : TxStateType;
  signal txStateCounter : unsigned(1 downto 0);
  signal outboundSymbolData : std_logic_vector(7 downto 0);
 
  type RxStateType is (STATE_INIT, STATE_NORMAL);
  signal rxState : RxStateType;
  signal rxStateCounter : unsigned(1 downto 0);
  signal escapeFound : std_logic;
 
  signal txTimerReset : std_logic;
  signal txTimerEnable : std_logic;
  signal txTimerCounter : unsigned(11 downto 0);
  signal silenceTxTimerDone : std_logic;
  signal idleTxTimerDone : std_logic;
 
  signal rxTimerReset : std_logic;
  signal rxTimerEnable : std_logic;
  signal rxTimerCounter : unsigned(11 downto 0);
  signal lostRxTimerDone : std_logic;
 
  signal uartWrite : std_logic;
  signal uartRead : std_logic;
 
begin
 
  -- Set the port initialized once the receiver enters its normal state.
  portInitialized_o <= '1' when (rxState = STATE_NORMAL) else '0';
 
  -----------------------------------------------------------------------------
  -- Timer functionallity.
  -----------------------------------------------------------------------------
 
  silenceTxTimerDone <= '1' when (txTimerCounter = SILENCE_TIME) else '0';
  idleTxTimerDone <= '1' when (txTimerCounter = IDLE_SYMBOL_TIME) else '0';
 
  process(areset_n, clk)
  begin
    if (areset_n = '0') then
      txTimerCounter <= (others => '0');
    elsif (clk'event and clk = '1') then
      if (txTimerReset = '1') then
        txTimerCounter <= (others => '0');
      elsif (txTimerEnable = '1') then
        txTimerCounter <= txTimerCounter + 1;
      end if;
    end if;
  end process;
 
  lostRxTimerDone <= '1' when (rxTimerCounter = LINK_LOST_TIME) else '0';
 
  process(areset_n, clk)
  begin
    if (areset_n = '0') then
      rxTimerCounter <= (others => '0');
    elsif (clk'event and clk = '1') then
      if (rxTimerReset = '1') then
        rxTimerCounter <= (others => '0');
      elsif (rxTimerEnable = '1') then
        rxTimerCounter <= rxTimerCounter + 1;
      end if;
    end if;
  end process;
 
  -----------------------------------------------------------------------------
  -- Link symbol encoder process.
  -----------------------------------------------------------------------------
  outboundSymbolData <= outboundSymbol_i(31 downto 24) when txStateCounter = 0 else
                        outboundSymbol_i(23 downto 16) when txStateCounter = 1 else
                        outboundSymbol_i(15 downto 8) when txStateCounter = 2 else
                        outboundSymbol_i(7 downto 0);
 
  uartWrite_o <= uartWrite;
  Outbound: process(areset_n, clk)
  begin
    if (areset_n = '0') then
      txState <= STATE_SILENCE;
      txStateCounter <= (others => '0');
 
      txTimerReset <= '0';
      txTimerEnable <= '0';
 
      outboundSymbolRead_o <= '0';
 
      uartWrite <= '0';
      uartData_o <= (others => '0');
    elsif (clk'event and clk = '1') then
      txTimerReset <= '0';
      outboundSymbolRead_o <= '0';
      uartWrite <= '0';
 
      -- Check if the UART is ready for new data.
      if (uartFull_i = '0') and (uartWrite = '0') then
        -- The UART want new data to transmitt.
 
        -- Check the transmission state.
        case txState is
 
          when STATE_SILENCE =>
            -------------------------------------------------------------------
            -- Wait for a while to let the linkpartner detect a link break.
            -------------------------------------------------------------------
            -- Check if the silence timer has expired.
            if (silenceTxTimerDone = '1') then
              -- Silence timer expired.
              -- Reset the timer and proceed to transmitting symbols.
              txTimerReset <= '1';
              txTimerEnable <= '0';
              txState <= STATE_IDLE_0;
            else
              txTimerEnable <= '1';
            end if;
 
          when STATE_IDLE_0 =>
            -----------------------------------------------------------------
            -- Wait for a new symbol to be received. An idle symbol is followed
            -- by a small inter-character idle time to let the receiver in the
            -- link partner synchronize itself to the link.
            -----------------------------------------------------------------
 
            -- Reset the state counter for the symbol generation.
            txStateCounter <= "00";
 
            -- Check if a new symbol is available.
            if (outboundSymbolEmpty_i = '0') then
              -- A new symbol is available.
 
              -- Check if the new symbol is idle, control or data.
              if (outboundSymbol_i(33 downto 32) /= SYMBOL_IDLE) then
                -- Control or data symbol.
                txState <= STATE_BUSY_1;
              else
                -- Send idle sequence.
                txState <= STATE_IDLE_1;
              end if;
            else
              -- No new symbols are ready.
              -- Dont do anything.
            end if;
 
          when STATE_IDLE_1 =>
            -------------------------------------------------------------------
            -- Wait until the idle timer has expired to let the link be idle in
            -- between idle symbols.
            -------------------------------------------------------------------
 
            -- Check if the idle timer has expired.
            if (idleTxTimerDone = '1') then
              -- Idle timer has expired.
              -- Reset the timer and disable it.
              txTimerReset <= '1';
              txTimerEnable <= '0';
 
              -- Write a flag to indicate idle link.
              uartWrite <= '1';
              uartData_o <= FLAG_SEQUENCE;
 
              -- Get a new symbol.
              outboundSymbolRead_o <= '1';
              txState <= STATE_IDLE_0;
            else
              -- Idle timer has not expired yet.
              txTimerEnable <= '1';
            end if;
 
          when STATE_BUSY_1 =>
            -----------------------------------------------------------------
            -- Encode a control or data symbol. If stuffing is needed the next
            -- busy state is called.
            -----------------------------------------------------------------
 
            -- Check if the octet is a flag or escape character.
            if ((outboundSymbolData = FLAG_SEQUENCE) or
                (outboundSymbolData = CONTROL_ESCAPE)) then
              -- Flag or escape octet.
              uartWrite <= '1';
              uartData_o <= CONTROL_ESCAPE;
              txState <= STATE_BUSY_2;
            else
              -- Ordinary octet.
 
              -- Write the octet to the uart.
              uartWrite <= '1';
              uartData_o <= outboundSymbolData;
 
              -- Update to the next octet in the symbol.
              txStateCounter <= txStateCounter + 1;
 
              -- Check if the symbol has been sent.
              if (txStateCounter = 3) then
                -- Data symbol sent.
                outboundSymbolRead_o <= '1';
                txState <= STATE_IDLE_0;
              elsif ((txStateCounter = 2) and
                     (outboundSymbol_i(33 downto 32) /= SYMBOL_DATA)) then
                -- Control symbol sent.
                txState <= STATE_SEND_FLAG;
              else
                -- Symbol not completly sent.
                txState <= STATE_BUSY_1;
              end if;
            end if;
 
          when STATE_BUSY_2 =>
            -----------------------------------------------------------------
            -- Byte stuff a flag or escape sequence found in the symbol data
            -- content.
            -----------------------------------------------------------------
 
            -- Byte stuff the control character.
            uartWrite <= '1';
            uartData_o <= outboundSymbolData xor x"20";
 
            -- Update to the next symbol.
            txStateCounter <= txStateCounter + 1;
 
            -- Check if the symbol has been sent.
            if (txStateCounter = 3) then
              -- Data symbol sent.
              outboundSymbolRead_o <= '1';
              txState <= STATE_IDLE_0;
            elsif ((txStateCounter = 2) and
                   (outboundSymbol_i(33 downto 32) /= SYMBOL_DATA)) then
              -- Control symbol sent.
              txState <= STATE_SEND_FLAG;
            else
              -- Symbol not completly sent.
              txState <= STATE_BUSY_1;
            end if;
 
          when STATE_SEND_FLAG =>
            -----------------------------------------------------------------
            -- Force a flag to be written to the link.
            -----------------------------------------------------------------
 
            uartWrite <= '1';
            uartData_o <= FLAG_SEQUENCE;
            outboundSymbolRead_o <= '1';
            txState <= STATE_IDLE_0;
 
          when others =>
            -----------------------------------------------------------------
            -- Unknown state.
            -----------------------------------------------------------------
            txState <= STATE_IDLE_0;
 
        end case;
      else
        -- The UART is busy transmitting.
        -- Wait for the UART to complete.
      end if;
    end if;
  end process;
 
 
  -----------------------------------------------------------------------------
  -- Link symbol decoder process.
  -----------------------------------------------------------------------------
  uartRead_o <= uartRead;
  Inbound: process(areset_n, clk)
  begin
    if (areset_n = '0') then
      rxState <= STATE_INIT;
      rxStateCounter <= (others => '0');
      escapeFound <= '0';
 
      rxTimerReset <= '0';
      rxTimerEnable <= '0';
 
      inboundSymbolWrite_o <= '0';
      inboundSymbol_o <= (others => '0');
 
      uartRead <= '0';
    elsif (clk'event and clk = '1') then
      rxTimerReset <= '0';
      inboundSymbolWrite_o <= '0';
      uartRead <= '0';
 
      case rxState is
 
        when STATE_INIT =>
          -------------------------------------------------------------------
          -- Wait for a flag to be received.
          -------------------------------------------------------------------
          -- Check if any new data is ready.
          if (uartRead = '0') and (uartEmpty_i = '0') then
            -- New data is ready from the uart.
 
            -- Check if a flag has been received.
            if (uartData_i = FLAG_SEQUENCE) then
              -- A flag has been received.
              -- Considder the port to be initialized.
              rxState <= STATE_NORMAL;
              rxStateCounter <= (others => '0');
              escapeFound <= '0';
              rxTimerReset <= '1';
              rxTimerEnable <= '1';
              uartRead <= '1';
            else
              -- Something that is not a flag has been received.
              -- Discard the data and wait for a flag.
              uartRead <= '1';
            end if;
          else
            -- Waiting for inbound data.
            -- Dont do anything.
          end if;
 
        when STATE_NORMAL =>
          -------------------------------------------------------------------
          -- Parse the incoming stream and create symbols.
          -------------------------------------------------------------------
 
          -- Check if the link lost timer has expired.
          if (lostRxTimerDone = '1') then
            -- The link lost timer has expired.
            -- Reset the timer, disable it and go back to the initial state.
            rxTimerReset <= '1';
            rxTimerEnable <= '0';
            rxState <= STATE_INIT;
          else
            -- The link lost timer has not expired.
 
            -- Check if any new data is ready.
            if (uartRead = '0') and (uartEmpty_i = '0') then
              -- New data is ready from the uart.
 
              -- Reset the link lost timer.
              rxTimerReset <= '1';
 
              -- Check if a flag has been received.
              if (uartData_i /= FLAG_SEQUENCE) then
                -- The received octet was not a flag.
 
                -- Check if the octet was a contol character.
                if (uartData_i /= CONTROL_ESCAPE) then
                  -- The octet was not a control character.
 
                  -- Check where in a symbol the reception is.
                  case rxStateCounter is
 
                    when "00" =>
                      inboundSymbol_o(33 downto 32) <= SYMBOL_IDLE;
                      if (escapeFound = '0') then
                        inboundSymbol_o(31 downto 24) <= uartData_i;
                      else
                        inboundSymbol_o(31 downto 24) <= uartData_i xor x"20";
                      end if;
                      rxStateCounter <= rxStateCounter + 1;
 
                    when "01" =>
                      inboundSymbol_o(33 downto 32) <= SYMBOL_IDLE;
                      if (escapeFound = '0') then
                        inboundSymbol_o(23 downto 16) <= uartData_i;
                      else
                        inboundSymbol_o(23 downto 16) <= uartData_i xor x"20";
                      end if;
                      rxStateCounter <= rxStateCounter + 1;
 
                    when "10" =>
                      inboundSymbol_o(33 downto 32) <= SYMBOL_CONTROL;
                      if (escapeFound = '0') then
                        inboundSymbol_o(15 downto 8) <= uartData_i;
                      else
                        inboundSymbol_o(15 downto 8) <= uartData_i xor x"20";
                      end if;
                      rxStateCounter <= rxStateCounter + 1;
 
                    when "11" =>
                      inboundSymbol_o(33 downto 32) <= SYMBOL_DATA;
                      if (escapeFound = '0') then
                        inboundSymbol_o(7 downto 0) <= uartData_i;
                      else
                        inboundSymbol_o(7 downto 0) <= uartData_i xor x"20";
                      end if;
                      rxStateCounter <= rxStateCounter + 1;
                      inboundSymbolWrite_o <= '1';
 
                    when others =>
                      rxStateCounter <= "00";
 
                  end case;
 
                  -- Read the octet from the uart.
                  uartRead <= '1';
                  escapeFound <= '0';
                else
                  -- Control escape received.
 
                  -- Read the octet and indicate that an escape character has been received.
                  uartRead <= '1';
                  escapeFound <= '1';
                end if;
              else
                -- Flag received.
 
                -- Check if there are any unsent symbols pending.
                if (rxStateCounter = 0) then
                  -- No pending symbol.
                  -- Send an idle symbol.
                  inboundSymbolWrite_o <= '1';
                  inboundSymbol_o(33 downto 32) <= SYMBOL_IDLE;
                else
                  -- Pending symbol.
                  -- Send the pending symbol.
                  inboundSymbolWrite_o <= '1';
                end if;
 
                -- Read and discard the octet.
                uartRead <= '1';
                rxStateCounter <= "00";
              end if;
            else
              -- Waiting for inbound data.
              -- Dont do anything.
            end if;
          end if;
 
        when others =>
          -------------------------------------------------------------------
          -- Unknown state.
          -------------------------------------------------------------------
          null;
 
      end case;
    end if;
  end process;
 
end architecture;