URL https://opencores.org/ocsvn/rio/rio/trunk

Subversion Repositories rio

[/] [rio/] [trunk/] [sw/] [stack/] [riostack.c] - Blame information for rev 49

Details | Compare with Previous | View Log


/*******************************************************************************
 *
 * 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 software implementation of a RapidIO stack according to
 * the 2.2 version, part 6, of the standard. Only short control symbols are
 * supported.
 *
 * Symbols are in four flavors, idle, control, data and error. They are abstract
 * and should be serialized by any implementation to be sent on a transmission
 * channel. Error symbols are never generated by the stack and are used if the
 * symbol decoder encounters an error that the stack should be notified of.
 *
 * Symbols are inserted into the stack from the lower-half by calling
 * RIOSTACK_portAddSymbol() and symbols to transmit are fetched from the stack
 * using RIOSTACK_portGetSymbol(). These two functions are the low-level interface
 * towards a physical transmission channel.
 * The function RIOSTACK_portSetStatus() is used to indicate to the stack that initial
 * training of the symbol codec has been completed and that the transmission port
 * is ready to accept other symbols than idle. The procedure is to set the port
 * status to initialized once idle symbols are successfully received.
 *
 * On the upper-half interface are the RIOSTACK_setOutboundPacket() function used to
 * insert packets into the outbound transmission queue and RIOSTACK_getInboundPacket()
 * is used to get packet from the inbound reception queue. The
 * RIOSTACK_getInboundQueueLength() function is used to check if any packet is available
 * for reading in the inbound reception queue.
 *
 * -----------------
 * |  OS dependent |
 * |  (your code)  |
 * -----------------
 *        |
 * -----------------
 * |   RioStack    |
 * -----------------
 *        |
 * -----------------
 * | Symbol Codec  |
 * |  (your code)  |
 * -----------------
 *        |
 * -----------------
 * |  Port driver  |
 * -----------------
 *        |
 * -----------------
 * | Physical port |
 * -----------------
 *
 * The symbol codec maps a RapidIO symbol to the physical transmission media.
 *
 * Some typical patterns to handle this stack are:
 * Initialization:
 *   RIOSTACK_open(...);
 *   RIOSTACK_portSetTimeout(...);
 *   ...
 *   <Symbol transcoder is successfully decoding symbols from the link>
 *   RIOSTACK_portSetStatus(1);
 *
 * Bottom-half traffic handling:
 *   RIOSTACK_portSetTime(...);
 *   <get symbol from decoder>
 *   RIOSTACK_portAddSymbol(...);
 *   s = RIOSTACK_portGetSymbol(...);
 *   <send symbol to encoder>
 *
 * Receiving packets:
 *   if(RIOSTACK_getInboundQueueLength(...) > 0)
 *   {
 *     RIOSTACK_getInboundPacket(...);
 *     <process the new packet>
 *   }
 *
 * Transmitting packets:
 *   <create a new packet>
 *   if(RIOSTACK_getOutboundQueueAvailable(...) > 0)
 *   {
 *     RIOSTACK_setOutboundPacket(...);
 *   }
 *
 * More details about the usage can be found in the module tests in test_riostack.c.
 *
 * To Do:
 * - Optimize the packing of stype0 and stype1 into control symbols.
 *
 * Author(s):
 * - Magnus Rosenius, magro732@opencores.org
 *
 *******************************************************************************
 *
 * Copyright (C) 2015 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
 *
 *******************************************************************************/
 
 
/**
 * \file riostack.c
 */
 
/*******************************************************************************
 * Includes
 *******************************************************************************/
 
#include "riostack.h"
 
 
/*lint -e961 Allow function like macros. */
/*lint -e621 Long identifier names allowed to increase readability. */
/*lint -w2 */
 
 
/*lint --estring(960,17.4) It is not possible to implement a rio stack without some
 * pointer arithmetic */
 
 
/*******************************************************************************
 * Local macro definitions
 *******************************************************************************/
 
/* Macro to update 5-bit ackId counters. */
#define ACKID_INC(ackId) (((ackId)+1)&0x1f)
 
/* Macros to get entries from a control symbol. */
#define STYPE0_GET(data) ((uint8_t) (((data) >> 21) & 0x00000007u))
#define PARAMETER0_GET(data) ((uint8_t) (((data) >> 16) & 0x00000001fu))
#define PARAMETER1_GET(data) ((uint8_t) (((data) >> 11) & 0x00000001fu))
#define STYPE1_GET(data) ((uint8_t) (((data) >> 8) & 0x00000007u))
#define CMD_GET(data) ((uint8_t) (((data) >> 5) & 0x00000007u))
#define CRC5_GET(data) ((uint8_t) (((data) >> 0) & 0x0000001fu))
 
/* Macros to get entries from a packet in a buffer. */
#define FTYPE_GET(p) (((p)[0] >> 16) & 0xf)
#define DESTID_GET(p) ((p)[0] & 0xffff)
#define SRCID_GET(p) (((p)[1] >> 16) & 0xffff)
#define TRANSACTION_GET(p) (((p)[1] >> 12) & 0xf)
#define MSGLEN_GET(p) TRANSACTION_GET(p)
#define SSIZE_GET(p) (((p)[1] >> 8) & 0xf)
#define LETTER_GET(p) (((p)[1] >> 6) & 0x3)
#define MBOX_GET(p) (((p)[1] >> 4) & 0x3)
#define MSGSEG_GET(p) ((p)[1] & 0xf)
#define XMBOX_GET(p) MSGSEG_GET(p)
#define RDSIZE_GET(p) SSIZE_GET(p)
#define WRSIZE_GET(p) SSIZE_GET(p)
#define TID_GET(p) ((p)[1] & 0xff)
#define HOP_GET(p) (((p)[2] >> 24) & 0xff)
#define CONFIG_OFFSET_GET(p) ((p)[2] & 0x00fffffcul)
#define INFO_GET(p) (((p)[2] >> 16) & 0xffff)
#define ADDRESS_GET(p) ((p)[2] & 0xfffffff8ul)
#define WDPTR_GET(p) (((p)[2] >> 2) & 0x1)
#define XAMBS_GET(p) ((p)[2] & 0x3)
#define DOUBLE_WORD_MSB_GET(p, i) (p)[3+(2*i+0)]
#define DOUBLE_WORD_LSB_GET(p, i) (p)[3+(2*i+1)]
 
/* Transmitter frame states. */
#define TX_FRAME_START                  ((uint8_t)0u)
#define TX_FRAME_BODY                   ((uint8_t)1u)
 
/* Control symbol constants. */
#define STYPE0_PACKET_ACCEPTED          ((uint8_t)0x00u)
#define STYPE0_PACKET_RETRY             ((uint8_t)0x01u)
#define STYPE0_PACKET_NOT_ACCEPTED      ((uint8_t)0x02u)
#define STYPE0_RESERVED                 ((uint8_t)0x03u)
#define STYPE0_STATUS                   ((uint8_t)0x04u)
#define STYPE0_VC_STATUS                ((uint8_t)0x05u)
#define STYPE0_LINK_RESPONSE            ((uint8_t)0x06u)
#define STYPE0_IMPLEMENTATION_DEFINED   ((uint8_t)0x07u)
#define STYPE1_START_OF_PACKET          ((uint8_t)0x00u)
#define STYPE1_STOMP                    ((uint8_t)0x01u)
#define STYPE1_END_OF_PACKET            ((uint8_t)0x02u)
#define STYPE1_RESTART_FROM_RETRY       ((uint8_t)0x03u)
#define STYPE1_LINK_REQUEST             ((uint8_t)0x04u)
#define STYPE1_MULTICAST_EVENT          ((uint8_t)0x05u)
#define STYPE1_RESERVED                 ((uint8_t)0x06u)
#define STYPE1_NOP                      ((uint8_t)0x07u)
 
/* Packet ftype constants. */
#define FTYPE_REQUEST 0x2
#define FTYPE_WRITE 0x5
#define FTYPE_MAINTENANCE 0x8
#define FTYPE_DOORBELL 0xa
#define FTYPE_MESSAGE 0xb
#define FTYPE_RESPONSE 0xd
 
/* Transaction constants. */
#define TRANSACTION_MAINT_READ_REQUEST 0
#define TRANSACTION_MAINT_WRITE_REQUEST 1
#define TRANSACTION_MAINT_READ_RESPONSE 2
#define TRANSACTION_MAINT_WRITE_RESPONSE 3
#define TRANSACTION_WRITE_NWRITE 4
#define TRANSACTION_WRITE_NWRITER 5
#define TRANSACTION_REQUEST_NREAD 4
#define TRANSACTION_RESPONSE_NO_PAYLOAD 0
#define TRANSACTION_RESPONSE_MESSAGE_RESPONSE 1
#define TRANSACTION_RESPONSE_WITH_PAYLOAD 8
 
/* Maintenance transaction lengths. */
#define MAINTENANCE_TRANSACTION_READ_REQUEST_SIZE ((uint32_t) 4ul)
#define MAINTENANCE_TRANSACTION_WRITE_REQUEST_SIZE ((uint32_t) 6ul)
#define MAINTENANCE_TRANSACTION_READ_RESPONSE_SIZE ((uint32_t) 6ul)
#define MAINTENANCE_TRANSACTION_WRITE_RESPONSE_SIZE ((uint32_t) 4ul)
 
/* Constants used to forward different errors to the link partner. */
#define PACKET_NOT_ACCEPTED_CAUSE_RESERVED 0u
#define PACKET_NOT_ACCEPTED_CAUSE_UNEXPECTED_ACKID 1u
#define PACKET_NOT_ACCEPTED_CAUSE_CONTROL_CRC 2u
#define PACKET_NOT_ACCEPTED_CAUSE_NON_MAINTENANCE 3u
#define PACKET_NOT_ACCEPTED_CAUSE_PACKET_CRC 4u
#define PACKET_NOT_ACCEPTED_CAUSE_ILLEGAL_CHARACTER 5u
#define PACKET_NOT_ACCEPTED_CAUSE_NO_RESOURCE 6u
#define PACKET_NOT_ACCEPTED_CAUSE_DESCRAMBLER 7u
#define PACKET_NOT_ACCEPTED_CAUSE_GENERAL 31u
 
/* Constants used to request link-responses. */
#define LINK_REQUEST_RESET_DEVICE 3u
#define LINK_REQUEST_INPUT_STATUS 4u
 
/* Constants used to forward a port status in a link-resonse. */
#define LINK_RESPONSE_PORT_STATUS_ERROR 2u
#define LINK_RESPONSE_PORT_STATUS_RETRY_STOPPED 4u
#define LINK_RESPONSE_PORT_STATUS_ERROR_STOPPED 5u
#define LINK_RESPONSE_PORT_STATUS_OK 16u
 
 
 
/*******************************************************************************
 * Local typedefs
 *******************************************************************************/
 
 
 
/*******************************************************************************
 * Global declarations
 *******************************************************************************/
 
 
 
/*******************************************************************************
 * Local declarations
 *******************************************************************************/
 
 
 
/*******************************************************************************
 * Local function prototypes
 *******************************************************************************/
 
/* Helper functions for protocol events. */
static void handleStatus(RioStack_t *stack, const uint8_t ackId, const uint8_t bufferStatus);
static void handlePacketAccepted(RioStack_t *stack, const uint8_t ackId, const uint8_t bufferStatus);
static void handlePacketRetry(RioStack_t *stack, const uint8_t ackId, const uint8_t bufferStatus);
static void handlePacketNotAccepted(RioStack_t *stack, const uint8_t arbitrary, const uint8_t cause);
static void handleLinkResponse(RioStack_t *stack, const uint8_t ackId, const uint8_t portStatus);
static void handleStartOfPacket(RioStack_t *stack);
static void handleEndOfPacket(RioStack_t *stack);
static void handleLinkRequest(RioStack_t *stack, uint8_t cmd);
static void handleNewPacketStart(RioStack_t *stack);
static void handleNewPacketEnd(RioStack_t *stack);
 
/**
 * \brief Create a control symbol.
 *
 * \param[in] stype0 The stype0 value.
 * \param[in] parameter0 The parameter0 value.
 * \param[in] parameter1 The parameter1 value.
 * \param[in] stype1 The stype1 value.
 * \param[in] cmd The cmd value.
 * \return The control symbol that were created from the input parameters.
 *
 * This function creates a control symbol with the specified arguments and
 * calculates a CRC-5 checksum according to the standard specification.
 */
static RioSymbol_t CreateControlSymbol(const uint8_t stype0,
                                       const uint8_t parameter0, const uint8_t parameter1,
                                       const uint8_t stype1, const uint8_t cmd);
 
/**
 * \brief Function to calculate ITU-CRC5, polynom=0x15.
 *
 * \param[in] data The data of a control symbol.
 * \param[in] crc The crc to initiate the result with.
 * \return A new CRC-5 value.
 */
static uint8_t Crc5(const uint32_t data, const uint8_t crc);
 
/**
 * \brief Create a queue with a specified size and a buffer attached to it.
 *
 * \param[in] size The number of entries in the queue.
 * \param[in] buffer A pointer to the buffer to store the content in.
 * \return A queue with the specified size and where new data will be stored
 * to the specified buffer.
 */
static Queue_t QueueCreate(const uint8_t size, uint32_t *buffer);
 
/**
 * \brief Get number of available elements.
 *
 * \param[in] q The queue to operate on.
 * \return The number of free packet buffers in the queue.
 */
static uint8_t QueueAvailable(const Queue_t q );
 
/**
 * \brief Get if the queue is empty or not.
 *
 * \param[in] q The queue to operate on.
 * \return Non-zero if the queue is empty.
 */
static int QueueEmpty(const Queue_t q);
 
/**
 * \brief Get the length of a queue.
 *
 * \param[in] q The queue to operate on.
 * \return The number of elements in the queue.
 */
static uint8_t QueueLength(const Queue_t q);
 
/**
 * \brief Add a new element to the queue.
 *
 * \param[in] q The queue to operate on.
 * \return A queue with one added element.
 */
static Queue_t QueueEnqueue(Queue_t q);
 
/**
 * \brief Remove an element from the queue.
 *
 * \param[in] q The queue to operate on.
 * \return A queue with on removed element.
 */
static Queue_t QueueDequeue(Queue_t q);
 
/**
 * \brief Check if the readout window is empty.
 *
 * \param[in] q The queue to operate on.
 * \return If the readout window is empty.
 */
static int QueueWindowEmpty(const Queue_t q);
 
/**
 * \brief Reset the window to none.
 *
 * \param[in] q The queue to operate on.
 * \return The updated Queue_t structure.
 */
static Queue_t QueueWindowReset(Queue_t q);
 
/**
 * \brief Increase the window to the next pending element.
 *
 * \param[in] q The queue to operate on.
 * \return The updated Queue_t structure.
 */
static Queue_t QueueWindowNext(Queue_t q);
 
/**
 * \brief Set actual size of the newest element.
 *
 * \param[in] q The queue to operate on.
 * \param[in] size The size to set the newest content size to.
 */
static void QueueSetSize(Queue_t q, const uint32_t size);
 
/**
 * \brief Set content at a specified index in the newest element.
 *
 * \param[in] q The queue to operate on.
 * \param[in] index posititon into the element
 * \param[in] content The content to set at the specified index in the newest queue element.
 */
static void QueueSetContent(Queue_t q, const uint32_t index, const uint32_t content);
 
/**
 * \brief Get a pointer to the buffer of the newest element.
 *
 * \param[in] q The queue to operate on.
 * \return A pointer to the content.
 */
static uint32_t *QueueGetBackBuffer(Queue_t q );
 
/**
 * \brief Get the size of the oldest element.
 * \param[in] q The queue to operate on.
 * \return The size of the element.
 */
static uint32_t QueueGetSize(Queue_t q );
 
/**
 * \brief Get the content of the oldest element at specified index.
 * \param[in] q The queue to operate on.
 * \param[in] index The index into the element to get the content from.
 * \return content of element at index position.
 */
static uint32_t QueueGetFrontContent(Queue_t q, const uint32_t index);
 
/**
 * \brief Get a pointer to the buffer of the oldest element.
 *
 * \param[in] q The queue to operate on.
 * \return A pointer to the content.
 */
static uint32_t *QueueGetFrontBuffer(Queue_t q );
 
 
 
/*******************************************************************************
 * Global functions
 *******************************************************************************/
 
void RIOSTACK_open(RioStack_t *stack, void *private,
                   const uint32_t rxPacketBufferSize, uint32_t *rxPacketBuffer,
                   const uint32_t txPacketBufferSize, uint32_t *txPacketBuffer)
{
  /* Port time and timeout limit. */
  stack->portTime = 0u;
  stack->portTimeout = 1000u;
 
  /* Setup the receiver. */
  stack->rxState = RX_STATE_UNINITIALIZED;
  stack->rxCounter = 0u;
  stack->rxCrc = 0xffffu;
  stack->rxStatusReceived = 0u;
  stack->rxAckId = 0u;
  stack->rxAckIdAcked = 0u;
  stack->rxErrorCause = PACKET_NOT_ACCEPTED_CAUSE_RESERVED;
  stack->rxQueue = QueueCreate((uint8_t) (rxPacketBufferSize/RIOSTACK_BUFFER_SIZE), rxPacketBuffer);
 
  /* Setup the transmitter. */
  stack->txState = TX_STATE_UNINITIALIZED;
  stack->txCounter = 0u;
  stack->txStatusCounter = 0u;
  stack->txFrameState = TX_FRAME_START;
  stack->txAckId = 0u;
  stack->txAckIdWindow = 0u;
  stack->txQueue = QueueCreate((uint8_t) (txPacketBufferSize/RIOSTACK_BUFFER_SIZE), txPacketBuffer);
 
  /* Setup status counters for inbound direction. */
  stack->statusInboundPacketComplete = 0ul;
  stack->statusInboundPacketRetry = 0ul;
  stack->statusInboundErrorControlCrc = 0ul;
  stack->statusInboundErrorPacketAckId = 0ul;
  stack->statusInboundErrorPacketCrc = 0ul;
  stack->statusInboundErrorIllegalCharacter = 0ul;
  stack->statusInboundErrorGeneral = 0ul;
  stack->statusInboundErrorPacketUnsupported = 0ul;
 
  /* Setup status counters for outbound direction. */
  stack->statusOutboundPacketComplete = 0ul;
  stack->statusOutboundLinkLatencyMax = 0ul;
  stack->statusOutboundPacketRetry = 0ul;
  stack->statusOutboundErrorTimeout = 0ul;
  stack->statusOutboundErrorPacketAccepted = 0ul;
  stack->statusOutboundErrorPacketRetry = 0ul;
 
  /* Setup status counters for potential problems on the link-partner. */
  stack->statusPartnerLinkRequest = 0ul;
  stack->statusPartnerErrorControlCrc = 0ul;
  stack->statusPartnerErrorPacketAckId = 0ul;
  stack->statusPartnerErrorPacketCrc = 0ul;
  stack->statusPartnerErrorIllegalCharacter = 0ul;
  stack->statusPartnerErrorGeneral = 0ul;
 
  /* Set pointer to user private data. */
  stack->private = private;
}
 
 
 
/*******************************************************************************************
 * Stack status and queue access functions.
 * Note that status counters are accessed directly in the stack-structure.
 *******************************************************************************************/
 
int RIOSTACK_getStatus(RioStack_t *stack)
{
  return !(((stack->rxState == RX_STATE_UNINITIALIZED) || (stack->rxState == RX_STATE_PORT_INITIALIZED)) &&
           ((stack->txState == TX_STATE_UNINITIALIZED) || (stack->txState == TX_STATE_PORT_INITIALIZED)));
}
 
 
 
void RIOSTACK_clearOutboundQueue(RioStack_t *stack)
{
  while(!QueueEmpty(stack->txQueue))
  {
    stack->txQueue = QueueDequeue(stack->txQueue);
  }
}
 
 
 
uint8_t RIOSTACK_getOutboundQueueLength(RioStack_t *stack)
{
  return QueueLength(stack->txQueue);
}
 
 
 
uint8_t RIOSTACK_getOutboundQueueAvailable(RioStack_t *stack)
{
  return QueueAvailable(stack->txQueue);
}
 
 
 
void RIOSTACK_setOutboundPacket(RioStack_t *stack, RioPacket_t *packet)
{
  uint32_t *src, *dst;
  uint32_t size;
  uint32_t i;
 
 
  ASSERT((QueueAvailable(stack->txQueue) > 0u),
         "Transmission queue packet overflow.");
 
  src = &packet->payload[0];
  dst = QueueGetBackBuffer(stack->txQueue);
  size = packet->size;
  for(i = 0; i < size; i++)
  {
    dst[i] = src[i];
  }
 
  QueueSetSize(stack->txQueue, size);
  stack->txQueue = QueueEnqueue(stack->txQueue);
}
 
 
 
void RIOSTACK_clearInboundQueue(RioStack_t *stack)
{
  while(!QueueEmpty(stack->rxQueue))
  {
    stack->rxQueue = QueueDequeue(stack->rxQueue);
  }
}
 
 
 
uint8_t RIOSTACK_getInboundQueueLength(RioStack_t *stack)
{
  return QueueLength(stack->rxQueue);
}
 
 
 
uint8_t RIOSTACK_getInboundQueueAvailable(RioStack_t *stack)
{
  return QueueAvailable(stack->rxQueue);
}
 
 
 
void RIOSTACK_getInboundPacket(RioStack_t *stack, RioPacket_t *packet)
{
  uint32_t *src, *dst;
  uint32_t size;
  uint32_t i;
 
 
  ASSERT(!QueueEmpty(stack->rxQueue), "Reading from empty reception queue.");
 
  src = QueueGetFrontBuffer(stack->rxQueue);
  dst = &packet->payload[0];
  size = QueueGetSize(stack->rxQueue);
  for(i = 0; i < size; i++)
  {
    dst[i] = src[i];
  }
 
  packet->size = size;
  stack->rxQueue = QueueDequeue(stack->rxQueue);
}
 
 
 
/*******************************************************************************************
 * Packet port functions.
 *******************************************************************************************/
 
void RIOSTACK_portSetTime(RioStack_t *stack, const uint32_t time)
{
  stack->portTime = time;
}
 
 
 
void RIOSTACK_portSetTimeout(RioStack_t *stack, const uint32_t time)
{
  stack->portTimeout = time;
}
 
 
 
void RIOSTACK_portSetStatus(RioStack_t *stack, const uint8_t initialized)
{
  /* REMARK: Clean the queues here as well??? */
  if (initialized)
  {
    stack->rxState = RX_STATE_PORT_INITIALIZED;
    stack->rxCounter = 0u;
    stack->rxCrc = 0xffffu;
    stack->rxStatusReceived = 0;
    stack->rxAckId = 0u;
    stack->rxAckIdAcked = 0u;
    stack->rxErrorCause = PACKET_NOT_ACCEPTED_CAUSE_RESERVED;
 
    stack->txState = TX_STATE_PORT_INITIALIZED;
    stack->txCounter = 0u;
    stack->txStatusCounter = 0u;
    stack->txFrameState = TX_FRAME_START;
    stack->txAckId = 0u;
    stack->txAckIdWindow = 0u;
  }
  else
  {
    stack->rxState = RX_STATE_UNINITIALIZED;
    stack->txState = TX_STATE_UNINITIALIZED;
  }
}
 
 
 
void RIOSTACK_portAddSymbol(RioStack_t *stack, const RioSymbol_t s)
{
  uint8_t stype0;
  uint8_t parameter0;
  uint8_t parameter1;
  uint8_t stype1;
 
 
  switch(stack->rxState)
  {
    case RX_STATE_PORT_INITIALIZED:
      /******************************************************************************
       * PORT_INITIALIZED
       * This state is entered to initialize the link. Only status-control-symbols
       * are accepted in this state. When 7 error-free, i.e. with CRC5 correct, status
       * control symbols has been received, change state to linkInitialized.
       ******************************************************************************/
 
      /* Check the type of symbol. */
      if(s.type == RIOSTACK_SYMBOL_TYPE_CONTROL)
      {
        /* This is a control symbol. */
 
        /* Check that the control symbol contains no errors. */
        if(Crc5(s.data, 0x1fu) == (s.data & 0x1ful))
        {
          /* Error-free control symbol. */
 
          /* Check if the symbol is a status symbol. */
          stype0 = STYPE0_GET(s.data);
          if(stype0 == STYPE0_STATUS)
          {
            /* Status symbol received. */
 
            /* Indicate an error-free status has been received. */
            stack->rxStatusReceived = 1;
 
            /* Check if enough status control symbols has been received. */
            if(stack->rxCounter == 7u)
            {
              /* Enough correct status control symbols has been received without
                 errors in between. */
 
              /* Setup the transmitter with the content of the symbol. */
              stack->txAckId = PARAMETER0_GET(s.data);
              stack->txAckIdWindow = stack->txAckId;
              stack->txBufferStatus = PARAMETER1_GET(s.data);
 
              /* Set the transmitter in its normal operational mode. */
              stack->rxState = RX_STATE_LINK_INITIALIZED;
              stack->rxCounter = 0u;
            }
            else
            {
              /* Count the number of consequitive error-free status control symbols
                 that has been received. */
              stack->rxCounter++;
            }
          }
          else
          {
            /* The received symbol is not a status symbol. */
            /* Discard it. */
          }
        }
        else
        {
          /* CRC error in control symbol. */
          /* Restart counting error-free status-control-symbols. */
          stack->rxCounter = 0u;
        }
      }
      else
      {
        /* Not a control symbol. */
        /* Discard the symbol. */
      }
 
      break;
 
    case RX_STATE_LINK_INITIALIZED:
      /******************************************************************************
       * LINK_INITIALIZED
       * The normal state. Accept packets and forward them.
       ******************************************************************************/
 
      /* Check the type of symbol. */
      switch(s.type)
      {
        case RIOSTACK_SYMBOL_TYPE_CONTROL:
          /**************************************************************************
           * This is a control symbol.
           **************************************************************************/
 
          /* Check if the CRC is correct. */
          if(Crc5(s.data, 0x1fu) == (s.data & (uint8_t)0x1ful))
          {
            /* The CRC is correct. */
 
            /* Get the content of the control symbol. */
            stype0 = STYPE0_GET(s.data);
            parameter0 = PARAMETER0_GET(s.data);
            parameter1 = PARAMETER1_GET(s.data);
            stype1 = STYPE1_GET(s.data);
 
            /**********************************************************************************
             * Check the stype0 part of the symbol.
             * Note that errors in this should trigger OUTPUT_ERROR_STOPPED.
             **********************************************************************************/
            switch(stype0)
            {
              case STYPE0_STATUS:
                /* A status containing the current ackId and the buffer status has been
                   received. */
                handleStatus(stack, parameter0, parameter1);
                break;
 
              case STYPE0_PACKET_ACCEPTED:
                /* A packet has been accepted by the link partner. */
                handlePacketAccepted(stack, parameter0, parameter1);
                break;
 
              case STYPE0_PACKET_RETRY:
                /* The link partner wants us to initiate a restart of the received ackId. */
                handlePacketRetry(stack, parameter0, parameter1);
                break;
 
              case STYPE0_PACKET_NOT_ACCEPTED:
                /* The link partner indicates that a packet has been rejected. */
                handlePacketNotAccepted(stack, parameter0, parameter1);
                break;
 
              case STYPE0_LINK_RESPONSE:
                /* The link partner has sent a response to a link-request. */
                handleLinkResponse(stack, parameter0, parameter1);
                break;
 
              case STYPE0_VC_STATUS:
              case STYPE0_RESERVED:
              case STYPE0_IMPLEMENTATION_DEFINED:
              default:
                /* Unsupported symbol received. */
                /* Discard them. */
                break;
            }
 
            /**********************************************************************************
             * Check the stype1 part of the symbol.
             * Note that errors in this should trigger INPUT_ERROR_STOPPED.
             **********************************************************************************/
            switch(stype1)
            {
              case STYPE1_START_OF_PACKET:
                /* Start of a new packet. */
                handleStartOfPacket(stack);
                break;
 
              case STYPE1_END_OF_PACKET:
                /* Ending a packet. */
                handleEndOfPacket(stack);
                break;
 
              case STYPE1_STOMP:
                /* Cancel the currently received frame. */
                stack->rxCounter = 0;
                break;
 
              case STYPE1_RESTART_FROM_RETRY:
                /* Cancel the currently received frame when in this state. */
                stack->rxCounter = 0;
                break;
 
              case STYPE1_LINK_REQUEST:
                /* A link-request has been received. */
                handleLinkRequest(stack, CMD_GET(s.data));
                break;
 
              case STYPE1_NOP:
                /* No operation symbol. */
                /* Discard these. */
                break;
 
              case STYPE1_MULTICAST_EVENT:
              case STYPE1_RESERVED:
              default:
                /* Unsupported symbol received. */
                /* Discard them. */
                break;
            }
          }
          else
          {
            /* The control symbol CRC is incorrect. */
            /* Corrupted control symbol. Discard the symbol and enter the input-error-stopped state. */
            stack->txState = TX_STATE_SEND_PACKET_NOT_ACCEPTED;
            stack->rxState = RX_STATE_INPUT_ERROR_STOPPED;
            stack->rxErrorCause = PACKET_NOT_ACCEPTED_CAUSE_CONTROL_CRC;
            stack->statusInboundErrorControlCrc++;
          }
          break;
 
        case RIOSTACK_SYMBOL_TYPE_DATA:
          /**************************************************************************
           * This is a data symbol.
           **************************************************************************/
 
          /* Check if a packet has been started and that it is not too long. */
          if ((stack->rxCounter >= 1u) && (stack->rxCounter <= RIOPACKET_SIZE_MAX))
          {
            /* A packet has been started. */
 
            /* Check if the ackId is correct on the first part of the packet. */
            if ((stack->rxCounter > 1u) ||
                ((stack->rxCounter == 1u) && (((uint8_t)(s.data >> 27)) == stack->rxAckId)))
            {
              /* The ackId is the expected one. */
 
              /* Check if this is the first symbol of a packet. */
              if (stack->rxCounter == 1u)
              {
                /* This is the first symbol of the packet. */
                /* Start to calculate the CRC of the packet. */
                /* Note that the ackId should not be included in the CRC calculation. */
                stack->rxCrc = RIOPACKET_Crc32(s.data & (uint32_t)0x03fffffful, 0xffffu);
              }
              else
              {
                /* This is not the first symbol. */
                /* Continue to calculate the CRC of the packet. */
                stack->rxCrc = RIOPACKET_Crc32(s.data, stack->rxCrc);
              }
 
              /* Save the new data in the packet queue and update the reception counter. */
              QueueSetContent(stack->rxQueue, (uint32_t)stack->rxCounter - (uint32_t)1ul, s.data);
              stack->rxCounter++;
            }
            else
            {
              /* The ackId is not correct. */
              /* Packet error. Enter input-error-stopped state. */
              stack->txState = TX_STATE_SEND_PACKET_NOT_ACCEPTED;
              stack->rxState = RX_STATE_INPUT_ERROR_STOPPED;
              stack->rxErrorCause = PACKET_NOT_ACCEPTED_CAUSE_UNEXPECTED_ACKID;
              stack->statusInboundErrorPacketAckId++;
            }
          }
          else
          {
            /* No packet has been started or the packet is too long. */
            /* Packet error. Enter input-error-stopped state. */
            stack->txState = TX_STATE_SEND_PACKET_NOT_ACCEPTED;
            stack->rxState = RX_STATE_INPUT_ERROR_STOPPED;
            stack->rxErrorCause = PACKET_NOT_ACCEPTED_CAUSE_GENERAL;
            stack->statusInboundErrorGeneral++;
          }
          break;
 
        case RIOSTACK_SYMBOL_TYPE_ERROR:
          /**************************************************************************
           * The decoder has received a erronous symbol.
           **************************************************************************/
 
          /* Idle symbol error. Place the receiver in input-error-stopped state. */
          stack->txState = TX_STATE_SEND_PACKET_NOT_ACCEPTED;
          stack->rxState = RX_STATE_INPUT_ERROR_STOPPED;
          stack->rxErrorCause = PACKET_NOT_ACCEPTED_CAUSE_ILLEGAL_CHARACTER;
          stack->statusInboundErrorIllegalCharacter++;
          break;
 
        case RIOSTACK_SYMBOL_TYPE_IDLE:
        default:
          /**************************************************************************
           * Idle symbol or unsupported symbol.
           **************************************************************************/
 
          /* Discard these for now. */
          break;
      }
      break;
 
    case RX_STATE_INPUT_RETRY_STOPPED:
      /******************************************************************************
       * INPUT_RETRY_STOPPED
       * This state is entered when no more buffers was available and a packet was
       * received. When in this state, all packets should be discarded until a
       * RESTART-FROM-RETRY symbol is received. See section 5.9.1.4 of the standard.
       * Note that it is only the input side of the port that are affected, not the
       * output side. Packets may still be transmitted and acknowledges should be
       * accepted.
       ******************************************************************************/
 
      /* Check the type of symbol. */
      switch(s.type)
      {
        case RIOSTACK_SYMBOL_TYPE_CONTROL:
          /* This is a control symbol. */
 
          /* Check if the CRC is correct. */
          if(Crc5(s.data, 0x1fu) == (s.data & (uint8_t)0x1ful))
          {
            /* The CRC is correct. */
 
            /* Get the content of the control symbol. */
            stype0 = STYPE0_GET(s.data);
            parameter0 = PARAMETER0_GET(s.data);
            parameter1 = PARAMETER1_GET(s.data);
            stype1 = STYPE1_GET(s.data);
 
            /* Check the stype0 part of the symbol. */
            switch(stype0)
            {
              case STYPE0_STATUS:
                /* A status containing the current ackId and the buffer status has been
                   received. */
                handleStatus(stack, parameter0, parameter1);
                break;
 
              case STYPE0_PACKET_ACCEPTED:
                /* A packet has been accepted by the link partner. */
                handlePacketAccepted(stack, parameter0, parameter1);
                break;
 
              case STYPE0_PACKET_RETRY:
                /* The link partner wants us to initiate a restart of the received ackId. */
                handlePacketRetry(stack, parameter0, parameter1);
                break;
 
              case STYPE0_PACKET_NOT_ACCEPTED:
                /* The link partner indicates that a packet has been rejected. */
                handlePacketNotAccepted(stack, parameter0, parameter1);
                break;
 
              case STYPE0_LINK_RESPONSE:
                /* The link partner has sent a response to a link-request. */
                handleLinkResponse(stack, parameter0, parameter1);
                break;
 
              case STYPE0_VC_STATUS:
              case STYPE0_RESERVED:
              case STYPE0_IMPLEMENTATION_DEFINED:
              default:
                /* Unsupported symbol received. */
                /* Discard them. */
                break;
            }
 
            /* Check the stype1 part of the symbol. */
            switch(stype1)
            {
              case STYPE1_START_OF_PACKET:
                /* Starting new frames are ignored in this state. */
                break;
 
              case STYPE1_END_OF_PACKET:
                /* Ending new frames are ignored in this state. */
                break;
 
              case STYPE1_STOMP:
                /* Restarting frames are ignored in this state. */
                break;
 
              case STYPE1_RESTART_FROM_RETRY:
                /* The link partner has confirmed our packet-retry-symbol. */
                /* Go back to the normal state and reset the frame reception. */
                stack->rxState = RX_STATE_LINK_INITIALIZED;
                stack->rxCounter = 0u;
                break;
 
              case STYPE1_LINK_REQUEST:
                /* A link-request has been received. */
                handleLinkRequest(stack, CMD_GET(s.data));
                stack->rxState = RX_STATE_LINK_INITIALIZED;
                break;
 
              case STYPE1_NOP:
                /* No operation symbol. */
                /* Discard these. */
                break;
 
              case STYPE1_MULTICAST_EVENT:
              case STYPE1_RESERVED:
              default:
                /* Unsupported symbol received. */
                /* Discard them. */
                break;
            }
          }
          else
          {
            /* The control symbol CRC is incorrect. */
            /* Corrupted control symbol. Discard the symbol and enter the input-error-stopped state. */
            stack->txState = TX_STATE_SEND_PACKET_NOT_ACCEPTED;
            stack->rxState = RX_STATE_INPUT_ERROR_STOPPED;
            stack->rxErrorCause = PACKET_NOT_ACCEPTED_CAUSE_CONTROL_CRC;
            stack->statusInboundErrorControlCrc++;
          }
          break;
 
        case RIOSTACK_SYMBOL_TYPE_ERROR:
          /* Idle symbol error. Place the receiver in input-error-stopped state. */
          stack->txState = TX_STATE_SEND_PACKET_NOT_ACCEPTED;
          stack->rxState = RX_STATE_INPUT_ERROR_STOPPED;
          stack->rxErrorCause = PACKET_NOT_ACCEPTED_CAUSE_ILLEGAL_CHARACTER;
          stack->statusInboundErrorIllegalCharacter++;
          break;
 
        case RIOSTACK_SYMBOL_TYPE_DATA:
        case RIOSTACK_SYMBOL_TYPE_IDLE:
        default:
          /* Data or idle symbol. */
          /* Discard these in this state. */
          break;
      }
      break;
 
    case RX_STATE_INPUT_ERROR_STOPPED:
      /******************************************************************************
       * INPUT_ERROR_STOPPED
       * This state is entered when an error situation has occurred. When in this
       * state, all symbols should be discarded until a link-request-symbols has
       * been received. See section 5.13.2.6 in part 6 of the standard.
       * Note that it is only the input side of the port that are affected, not the
       * output side. Packets may still be transmitted and acknowledges should be
       * accepted.
       ******************************************************************************/
 
      /* Check the type of symbol. */
      switch(s.type)
      {
        case RIOSTACK_SYMBOL_TYPE_CONTROL:
          /* This is a control symbol. */
 
          /* Check if the CRC is correct. */
          if(Crc5(s.data, 0x1fu) == (s.data & (uint8_t)0x1ful))
          {
            /* The CRC is correct. */
 
            /* Get the content of the control symbol. */
            stype0 = STYPE0_GET(s.data);
            parameter0 = PARAMETER0_GET(s.data);
            parameter1 = PARAMETER1_GET(s.data);
            stype1 = STYPE1_GET(s.data);
 
            /* Check the stype0 part of the symbol. */
            switch(stype0)
            {
              case STYPE0_STATUS:
                /* A status containing the current ackId and the buffer status has been
                   received. */
                handleStatus(stack, parameter0, parameter1);
                break;
 
              case STYPE0_PACKET_ACCEPTED:
                /* A packet has been accepted by the link partner. */
                handlePacketAccepted(stack, parameter0, parameter1);
                break;
 
              case STYPE0_PACKET_RETRY:
                /* The link partner wants us to initiate a restart of the received ackId. */
                handlePacketRetry(stack, parameter0, parameter1);
                break;
 
              case STYPE0_PACKET_NOT_ACCEPTED:
                /* The link partner indicates that a packet has been rejected. */
                handlePacketNotAccepted(stack, parameter0, parameter1);
                break;
 
              case STYPE0_LINK_RESPONSE:
                /* The link partner has sent a response to a link-request. */
                handleLinkResponse(stack, parameter0, parameter1);
                break;
 
              case STYPE0_VC_STATUS:
              case STYPE0_RESERVED:
              case STYPE0_IMPLEMENTATION_DEFINED:
              default:
                /* Unsupported symbol received. */
                /* Discard them. */
                break;
            }
 
            /* Check the stype1 part of the symbol. */
            switch(stype1)
            {
              case STYPE1_START_OF_PACKET:
                /* Starting new frames are ignored in this state. */
                break;
 
              case STYPE1_END_OF_PACKET:
                /* Ending new frames are ignored in this state. */
                break;
 
              case STYPE1_STOMP:
                /* Restarting frames are ignored in this state. */
                break;
 
              case STYPE1_RESTART_FROM_RETRY:
                /* Restart-from-retry are ignored in this state.  */
                break;
 
              case STYPE1_LINK_REQUEST:
                /* This is the symbol we have been waiting for. */
                /* Force the transmitter to send a link-response and go back into the normal
                   operational state. */
                /* The transmitter will always send a status as the first symbol after this. */
                handleLinkRequest(stack, CMD_GET(s.data));
                stack->rxState = RX_STATE_LINK_INITIALIZED;
                break;
 
              case STYPE1_NOP:
                /* No operation symbol. */
                /* Discard these. */
                break;
 
              case STYPE1_MULTICAST_EVENT:
              case STYPE1_RESERVED:
              default:
                /* Unsupported symbol received. */
                /* Discard them. */
                break;
            }
          }
          else
          {
            /* The CRC is incorrect. */
            /* Discard these in this state. */
          }
          break;
 
        case RIOSTACK_SYMBOL_TYPE_DATA:
        case RIOSTACK_SYMBOL_TYPE_IDLE:
        case RIOSTACK_SYMBOL_TYPE_ERROR:
        default:
          /* Data, idle or error symbol. */
          /* Discard these in this state. */
          break;
      }
      break;
 
    case RX_STATE_UNINITIALIZED:
    default:
      /******************************************************************************
       * Wait for the port to be initialized.
       ******************************************************************************/
 
      /* Discard all incoming symbols. */
      break;
  }
}
 
 
 
RioSymbol_t RIOSTACK_portGetSymbol(RioStack_t *stack )
{
  RioSymbol_t s;
 
 
  switch(stack->txState)
  {
    case TX_STATE_PORT_INITIALIZED:
      /******************************************************************************
       * PORT_INITIALIZED
       * This state is entered to initialize the link. Send status-control-symbols
       * once in a while until the receiver has received enough error-free status-
       * control-symbols and we have transmitted enough status-control-symbols. Once
       * an error-free status-control-symbol has been received, the statuses are
       * transmitted more frequently to decrease the time for the link to be
       * initialized.
       ******************************************************************************/
 
      /* Check if an idle symbol or a status control symbol should be sent. */
      if(((stack->rxStatusReceived == 0) && (stack->txCounter == 255u)) ||
         ((stack->rxStatusReceived == 1) && (stack->txCounter >= 15u)))
      {
        /* A control symbol should be sent. */
 
        /* Create a new status symbol and reset the transmission counter. */
        stack->txCounter = 0u;
        s = CreateControlSymbol(STYPE0_STATUS, stack->rxAckId, QueueAvailable(stack->rxQueue),
                                STYPE1_NOP, 0u);
 
        /* Check if the receiver has received any error-free status and that we
           have sent at least 15 status control symbols. */
        if((stack->rxStatusReceived == 1) && (stack->txStatusCounter < 15u))
        {
          /* Has not sent enough status control symbols. */
          stack->txStatusCounter++;
        }
        else
        {
          /* Has sent enough status control symbols. */
          /* Dont do anything. */
        }
      }
      else
      {
        /* Idle symbol should be sent. */
        s.type = RIOSTACK_SYMBOL_TYPE_IDLE;
        stack->txCounter++;
      }
 
      /* Check if we are ready to set the transmitter in a link initialized state. */
      if ((stack->rxState == RX_STATE_LINK_INITIALIZED) && (stack->txStatusCounter == 15u))
      {
        /* Ready to go to link initialized. */
        stack->txState = TX_STATE_LINK_INITIALIZED;
        stack->txFrameState = TX_FRAME_START;
        stack->txStatusCounter = 0u;
      }
      else
      {
        /* Not ready to go to link initialized. */
        /* Dont do anything. */
      }
 
      break;
 
    case TX_STATE_LINK_INITIALIZED:
      /******************************************************************************
       * LINK_INITIALIZED
       * The normal state. Accept packets and forward them. Send acknowledges when
       * the receiver has received complete packets.
       ******************************************************************************/
 
      /* Check if the receiver wants to acknowledge a packet. */
      if(stack->rxAckId == stack->rxAckIdAcked)
      {
        /* The receiver does not want to acknowledge a packet. */
 
        /* Check if there are any outstanding packets and if it has timed out. */
        if((stack->txAckId == stack->txAckIdWindow) ||
           ((stack->portTime - stack->txFrameTimeout[stack->txAckId]) < stack->portTimeout))
        {
          /* There are no outstanding packets or there has been no timeout. */
 
          /* Check if a packet is ongoing. */
          if(stack->txFrameState == TX_FRAME_BODY)
          {
            /* A packet transmission is ongoing. */
 
            /* Check if the packet has been completly sent. */
            if(stack->txCounter != QueueGetSize(stack->txQueue))
            {
              /* The packet has not been completly sent. */
 
              /* Create a new data symbol to transmit. */
              s.type = RIOSTACK_SYMBOL_TYPE_DATA;
              s.data = QueueGetFrontContent(stack->txQueue, (uint32_t)stack->txCounter);
 
              /* Check if this is the first symbol in a packet. */
              if (stack->txCounter == 0u)
              {
                /* Place the correct ackId in the right place. */
                s.data |= (uint32_t)stack->txAckIdWindow << 27;
              }
              else
              {
                /* Dont do anything. */
              }
 
              /* Update the transmission counter. */
              stack->txCounter++;
 
              /* A status control symbol was not sent. Update the status counter. */
              stack->txStatusCounter++;
            }
            else
            {
              /* The packet has been sent. */
 
              /* Save the timeout time and update to the next ackId. */
              stack->txFrameTimeout[stack->txAckIdWindow] = stack->portTime;
              stack->txAckIdWindow = ACKID_INC(stack->txAckIdWindow);
              stack->txQueue = QueueWindowNext(stack->txQueue);
 
              /* Check if there are more packets pending to be sent. */
              /* Also check that there are buffer available at the receiver and that not too many
                 packets are outstanding. */
              if(!QueueWindowEmpty(stack->txQueue) && (stack->txBufferStatus > 0) &&
                 (((stack->txAckIdWindow - stack->txAckId) & 0x1f) != 31))
              {
                /* More pending packets. */
                /* Create a control symbol to signal that the new packet has started. */
                s = CreateControlSymbol(STYPE0_STATUS, stack->rxAckId, QueueAvailable(stack->rxQueue),
                                        STYPE1_START_OF_PACKET, 0u);
 
                /* Restart transmission counter. */
                stack->txCounter = 0;
              }
              else
              {
                /* No more pending packets. */
                /* Create a control symbol to signal that the packet has ended. */
                s = CreateControlSymbol(STYPE0_STATUS, stack->rxAckId, QueueAvailable(stack->rxQueue),
                                        STYPE1_END_OF_PACKET, 0u);
 
                /* Go back to wait for a new frame. */
                stack->txFrameState = TX_FRAME_START;
              }
 
              /* A status control symbol has been sent. Reset the status counter. */
              stack->txStatusCounter = 0u;
            }
          }
          else
          {
            /* No packet is being sent. */
 
            /* Check if there are any pending packets to start sending. */
            /* Also check that there are buffer available at the receiver and that not too many
               packets are outstanding. */
            if(!QueueWindowEmpty(stack->txQueue) && (stack->txBufferStatus > 0) &&
               (((stack->txAckIdWindow - stack->txAckId) & 0x1f) != 31))
            {
              /* There is a pending packet to send. */
              /* Send a start-of-packet control symbol to start to send the packet. */
              s = CreateControlSymbol(STYPE0_STATUS, stack->rxAckId, QueueAvailable(stack->rxQueue),
                                      STYPE1_START_OF_PACKET, 0u);
              stack->txFrameState = TX_FRAME_BODY;
              stack->txCounter = 0u;
 
              /* A status control symbol has been sent. Reset the status counter. */
              stack->txStatusCounter = 0u;
            }
            else
            {
              /* There are no pending packets to send. */
 
              /* Check if a status control symbol must be transmitted. */
              if(stack->txStatusCounter < 255u)
              {
                /* Not required to send a status control symbol. */
 
                /* Send an idle-symbol. */
                s.type = RIOSTACK_SYMBOL_TYPE_IDLE;
                stack->txStatusCounter++;
              }
              else
              {
                /* Must send a status control symbol. */
 
                /* Create a status control symbol. */
                s = CreateControlSymbol(STYPE0_STATUS, stack->rxAckId, QueueAvailable(stack->rxQueue),
                                        STYPE1_NOP, 0u);
 
                /* A status control symbol has been sent. Reset the status counter. */
                stack->txStatusCounter = 0u;
              }
            }
          }
        }
        else
        {
          /* There has been a timeout. */
          /* A packet has been sent but no packet-accepted has been received. */
          /* Send link-request-symbol (input-status). */
          s = CreateControlSymbol(STYPE0_STATUS, stack->rxAckId, QueueAvailable(stack->rxQueue),
                                  STYPE1_LINK_REQUEST, LINK_REQUEST_INPUT_STATUS);
 
          /* Save the time when this was transmitted. */
          stack->txFrameTimeout[stack->txAckId] = stack->portTime;
 
          /* Remember that this symbol has been transmitted. */
          stack->txCounter = 1;
 
          /* Go into the output error stopped state. */
          stack->txState = TX_STATE_OUTPUT_ERROR_STOPPED;
          stack->statusOutboundErrorTimeout++;
        }
      }
      else
      {
        /* The receiver wants us to send an acknowledgement. */
        s = CreateControlSymbol(STYPE0_PACKET_ACCEPTED, stack->rxAckIdAcked, QueueAvailable(stack->rxQueue),
                                STYPE1_NOP, 0u);
        stack->rxAckIdAcked = ACKID_INC(stack->rxAckIdAcked);
 
        /* A status control symbol was not sent. Update the status counter. */
        stack->txStatusCounter++;
      }
      break;
 
    case TX_STATE_SEND_PACKET_RETRY:
      /******************************************************************************
       * SEND_PACKET_RETRY
       * This state is set by the receiver to force a packet-retry-symbol to be
       * transmitted.
       ******************************************************************************/
 
      /* Check if the receiver wants to acknowledge a packet. */
      /* This must be done first or we will get an error for a missmatching
         ackId in the link-partner. */
      if(stack->rxAckId == stack->rxAckIdAcked)
      {
        /* No pending acknowledge. */
 
        /* Send a packet-retry symbol to tell the link partner to retry the last frame. */
        s = CreateControlSymbol(STYPE0_PACKET_RETRY, stack->rxAckId, QueueAvailable(stack->rxQueue),
                                STYPE1_NOP, 0u);
 
        /* Proceed with normal transmission. */
        stack->txState = TX_STATE_LINK_INITIALIZED;
 
        /* A status control symbol was not sent. Update the status counter. */
        stack->txStatusCounter++;
      }
      else
      {
 
        /* The receiver wants us to send an acknowledgement. */
        s = CreateControlSymbol(STYPE0_PACKET_ACCEPTED, stack->rxAckIdAcked, QueueAvailable(stack->rxQueue),
                                STYPE1_NOP, 0u);
        stack->rxAckIdAcked = ACKID_INC(stack->rxAckIdAcked);
 
        /* A status control symbol was not sent. Update the status counter. */
        stack->txStatusCounter++;
      }
      break;
 
    case TX_STATE_SEND_PACKET_NOT_ACCEPTED:
      /******************************************************************************
       * SEND_PACKET_NOT_ACCEPTED
       * This state is set by the receiver to force a packet-not-accepted-symbol to be
       * transmitted.
       ******************************************************************************/
 
      /* Send a packet-not-accepted symbol to indicate an error on the link. */
      s = CreateControlSymbol(STYPE0_PACKET_NOT_ACCEPTED, 0, stack->rxErrorCause,
                              STYPE1_NOP, 0u);
 
      /* Proceed with normal transmission. */
      stack->txState = TX_STATE_LINK_INITIALIZED;
 
      /* A status control symbol was not sent. Update the status counter. */
      stack->txStatusCounter++;
      break;
 
    case TX_STATE_SEND_LINK_RESPONSE:
      /******************************************************************************
       * SEND_LINK_RESPONSE
       * This state is set by the receiver to force a link-response-symbol to be
       * transmitted.
       ******************************************************************************/
 
      /* Check the state of the receiver. */
      /* REMARK: If a link-request gives this response and a link-request also makes the receiver
         enter the normal operational state, none of these states except the normal state will ever
         be used... */
      if((stack->rxState == RX_STATE_LINK_INITIALIZED) || (stack->rxState == RX_STATE_PORT_INITIALIZED))
      {
        /* Normal state. */
        s = CreateControlSymbol(STYPE0_LINK_RESPONSE, stack->rxAckId, LINK_RESPONSE_PORT_STATUS_OK,
                                STYPE1_NOP, 0u);
      }
      else if(stack->rxState == RX_STATE_INPUT_RETRY_STOPPED)
      {
        /* Input-retry-stopped state. */
        s = CreateControlSymbol(STYPE0_LINK_RESPONSE, stack->rxAckId, LINK_RESPONSE_PORT_STATUS_RETRY_STOPPED,
                                STYPE1_NOP, 0u);
      }
      else if(stack->rxState == RX_STATE_INPUT_ERROR_STOPPED)
      {
        /* Input-error-stopped state. */
        s = CreateControlSymbol(STYPE0_LINK_RESPONSE, stack->rxAckId, LINK_RESPONSE_PORT_STATUS_ERROR_STOPPED,
                                STYPE1_NOP, 0u);
      }
      else
      {
        /* Not in the defined states. */
        s = CreateControlSymbol(STYPE0_LINK_RESPONSE, stack->rxAckId, LINK_RESPONSE_PORT_STATUS_ERROR,
                                STYPE1_NOP, 0u);
      }
 
      /* Proceed with normal transmission. */
      stack->txState = TX_STATE_LINK_INITIALIZED;
 
      /* Force a status to be transmitted the next time to comply to the input-error-stopped
         state rules. */
      stack->txStatusCounter = 255;
      break;
 
    case TX_STATE_OUTPUT_RETRY_STOPPED:
      /******************************************************************************
       * OUTPUT_RETRY_STOPPED
       * This state is entered when the link-partner has transmitted a
       * packet-retry-symbol. The packet-retry-symbol is acknowledged by sending a
       * restart-from-retry-symbol.
       * This state follows 5.9.1.5 in part 6.
       ******************************************************************************/
 
      /* Send a restart-from-retry symbol to acknowledge. */
      s = CreateControlSymbol(STYPE0_STATUS, stack->rxAckId, QueueAvailable(stack->rxQueue),
                              STYPE1_RESTART_FROM_RETRY, 0u);
 
      /* Restart the current frame and proceed with normal operation. */
      stack->txFrameState = TX_FRAME_START;
      stack->txState = TX_STATE_LINK_INITIALIZED;
      stack->txCounter = 0;
 
      /* Discard all packets that has not received a matching packet-accepted. */
      stack->txAckIdWindow = stack->txAckId;
      stack->txQueue = QueueWindowReset(stack->txQueue);
 
      /* A status control symbol was sent. Reset the status counter. */
      stack->txStatusCounter = 0;
      break;
 
    case TX_STATE_OUTPUT_ERROR_STOPPED:
      /******************************************************************************
       * OUTPUT_ERROR_STOPPED
       * This state is entered when the link partner has encountered any problem
       * which is indicated by sending a packet-not-accepted symbol or if a packet
       * timeout has expired. The error condition is acknowledged by sending a
       * link-request-symbol and then wait for a link-response reply.
       * This state follows 5.13.2.7 in part 6.
       ******************************************************************************/
 
      /* Check if a link-request-symbol has been transmitted. */
      if(stack->txCounter == 0)
      {
        /* A link-request-symbol has not been transmitted. */
 
        /* Send link-request-symbol (input-status). */
        s = CreateControlSymbol(STYPE0_STATUS, stack->rxAckId, QueueAvailable(stack->rxQueue),
                                STYPE1_LINK_REQUEST, LINK_REQUEST_INPUT_STATUS);
 
        /* Save the time when this was transmitted. */
        stack->txFrameTimeout[stack->txAckId] = stack->portTime;
 
        /* Remember that this symbol has been transmitted. */
        stack->txCounter = 1;
      }
      else
      {
        /* A link-request-symbol has been transmitted. */
 
        /* Check if the link partner reply has timed out. */
        if((stack->portTime - stack->txFrameTimeout[stack->txAckId]) < stack->portTimeout)
        {
          /* No timeout. */
 
          /* A link-request-symbol has been transmitted. */
          /* Send only idle-symbols until the link-response is received. */
          s.type = RIOSTACK_SYMBOL_TYPE_IDLE;
        }
        else
        {
          /* Link response timeout. */
 
          /* Check if the link-partner has not responded for too many times. */
          if(stack->txCounter < 5)
          {
            /* Not too many timeouts. */
            /* Retry and send a new link-request. */
 
            /* Send link-request-symbol (input-status). */
            s = CreateControlSymbol(STYPE0_STATUS, stack->rxAckId, QueueAvailable(stack->rxQueue),
                                    STYPE1_LINK_REQUEST, LINK_REQUEST_INPUT_STATUS);
 
            /* Save the time when this was transmitted. */
            stack->txFrameTimeout[stack->txAckId] = stack->portTime;
 
            /* Increment the number of times we have retransmitted the link-request. */
            stack->txCounter++;
          }
          else
          {
            /* The link partner has not answered for too many times. */
            /* Give up and set the state to uninitialized. */
            stack->txState = TX_STATE_UNINITIALIZED;
            s.type = RIOSTACK_SYMBOL_TYPE_IDLE;
            ASSERT0("No link-response received, giving up.");
          }
        }
      }
      break;
 
    case TX_STATE_UNINITIALIZED:
    default:
      /******************************************************************************
       * Wait for the port to be initialized.
       ******************************************************************************/
 
      /* Send only idle symbols. */
      s.type = RIOSTACK_SYMBOL_TYPE_IDLE;
      break;
  }
 
  /* Return the created symbol. */
  return s;
}
 
 
 
/*******************************************************************************
 * Local RapidIO stack helper functions.
 *******************************************************************************/
 
static void handleStatus(RioStack_t *stack, const uint8_t ackId, const uint8_t bufferStatus)
{
  /* Update the buffer status of the link partner. */
  (void) ackId;
  stack->txBufferStatus = bufferStatus;
}
 
 
 
static void handlePacketAccepted(RioStack_t *stack, const uint8_t ackId, const uint8_t bufferStatus)
{
  uint32_t linkLatency;
 
 
  /* Check if an acknowledge is expected and that it is for a transmitted packet. */
  if((stack->txAckId != stack->txAckIdWindow) && (ackId == stack->txAckId))
  {
    /* Acknowledge for a recently transmitted packet received. */
 
    /* Check if the latency of this packet is larger than the largest encountered so far. */
    linkLatency = stack->portTime - stack->txFrameTimeout[ackId];
    if(linkLatency > stack->statusOutboundLinkLatencyMax)
    {
      stack->statusOutboundLinkLatencyMax = linkLatency;
    }
 
    /* Remove the packet from the outbound queue and restart the transmission for
       a new packet. */
    stack->txQueue = QueueDequeue(stack->txQueue);
    stack->txAckId = ACKID_INC(stack->txAckId);
    stack->statusOutboundPacketComplete++;
  }
  else
  {
    /* Acknowledge for an unexpected ackId or not waiting for an acknowledge. */
    /* Link protocol violation. Discard the symbol and enter the output-error-stopped state. */
    stack->txState = TX_STATE_OUTPUT_ERROR_STOPPED;
    stack->txCounter = 0u;
    stack->statusOutboundErrorPacketAccepted++;
  }
 
  /* Update the buffer status of the link partner. */
  stack->txBufferStatus = bufferStatus;
}
 
 
 
static void handlePacketRetry(RioStack_t *stack, const uint8_t ackId, const uint8_t bufferStatus)
{
  /* Check if the retried packet ackId is acceptable. */
  if(ackId == stack->txAckId)
  {
    /* The request for retry is for the current packet. */
    /* Force the transmitter to send a RESTART-FROM-RETRY symbol. */
    stack->txState = TX_STATE_OUTPUT_RETRY_STOPPED;
    stack->statusOutboundPacketRetry++;
  }
  else
  {
    /* Link protocol violation. Discard the symbol and enter the output-error-stopped state. */
    stack->txState = TX_STATE_OUTPUT_ERROR_STOPPED;
    stack->txCounter = 0u;
    stack->statusOutboundErrorPacketRetry++;
  }
 
  /* Update the buffer status of the link partner. */
  stack->txBufferStatus = bufferStatus;
}
 
 
 
static void handlePacketNotAccepted(RioStack_t *stack, const uint8_t arbitrary, const uint8_t cause)
{
  (void) arbitrary;
 
  /* Force the transmitter to enter output-error-stopped state. */
  stack->txState = TX_STATE_OUTPUT_ERROR_STOPPED;
  stack->txCounter = 0u;
 
  /* Record the type of error that caused the packet to not being accepted. */
  switch(cause)
  {
    case PACKET_NOT_ACCEPTED_CAUSE_UNEXPECTED_ACKID:
      stack->statusPartnerErrorPacketAckId++;
      break;
    case PACKET_NOT_ACCEPTED_CAUSE_CONTROL_CRC:
      stack->statusPartnerErrorControlCrc++;
      break;
    case PACKET_NOT_ACCEPTED_CAUSE_PACKET_CRC:
      stack->statusPartnerErrorPacketCrc++;
      break;
    case PACKET_NOT_ACCEPTED_CAUSE_ILLEGAL_CHARACTER:
      stack->statusPartnerErrorIllegalCharacter++;
      break;
    default:
      stack->statusPartnerErrorGeneral++;
      break;
  }
}
 
 
 
static void handleLinkResponse(RioStack_t *stack, const uint8_t ackId, const uint8_t portStatus)
{
  uint8_t window;
  uint8_t windowReceived;
 
 
  (void) portStatus;
 
  /* Check if this symbols is expected. */
  if(stack->txState == TX_STATE_OUTPUT_ERROR_STOPPED)
  {
    /* Calculate the number of packets that has not received an acknowledge on our side and
       on the link-partner side. */
    window = (stack->txAckIdWindow - stack->txAckId) & 0x1f;
    windowReceived = (ackId - stack->txAckId) & 0x1f;
 
    /* Check if the link-partners response is acceptable. */
    if(windowReceived <= window)
    {
      /* A link-response is expected. */
 
      /* Remove entries in the queue that the link-partner has sent acknowledges for that has been lost. */
      while(stack->txAckId != ackId)
      {
        stack->txQueue = QueueDequeue(stack->txQueue);
        stack->txAckId = ACKID_INC(stack->txAckId);
        stack->statusOutboundPacketComplete++;
      }
 
      /* Set the transmission window to the resend packets that has not been received. */
      stack->txQueue = QueueWindowReset(stack->txQueue);
      stack->txAckIdWindow = ackId;
      stack->txFrameState = TX_FRAME_START;
 
      /* Set the transmitter back into normal operation. */
      stack->txState = TX_STATE_LINK_INITIALIZED;
    }
    else
    {
      /* The link-partner response is unacceptable. */
      /* Recovery is not possible. */
      stack->txState = TX_STATE_UNINITIALIZED;
      ASSERT0("Unrecoverable protocol error.");
    }
  }
  else
  {
    /* Not expecting a link-response. */
    /* Just discard this symbol. */
    /* REMARK: Add status counter here??? */
  }
}
 
 
 
static void handleStartOfPacket(RioStack_t *stack)
{
  /* Check if a packet is already started. */
  if(stack->rxCounter != 0u)
  {
    /* Packet has already started. */
    /* This indicates an implicit end-of-packet symbol and signals the previous packet as ready. */
 
    /* Check the packet crc. */
    if(stack->rxCrc == 0x0000u)
    {
      /* The packet has a correct CRC. */
 
      /* Check if the packet is long enough to contain a complete packet. */
      if(stack->rxCounter > 3u)
      {
        /* Packet long enough to process. */
 
        /* Process the newly received packet and start a new one. */
        handleNewPacketEnd(stack);
        handleNewPacketStart(stack);
      }
      else
      {
        /* The packet has a valid CRC but is too short. */
        /* Packet error. Enter input-error-stopped state. */
        stack->txState = TX_STATE_SEND_PACKET_NOT_ACCEPTED;
        stack->rxState = RX_STATE_INPUT_ERROR_STOPPED;
        stack->rxErrorCause = PACKET_NOT_ACCEPTED_CAUSE_GENERAL;
        stack->statusInboundErrorGeneral++;
      }
    }
    else
    {
      /* The packet has an invalid CRC. */
      /* Packet error. Enter input-error-stopped state. */
      stack->txState = TX_STATE_SEND_PACKET_NOT_ACCEPTED;
      stack->rxState = RX_STATE_INPUT_ERROR_STOPPED;
      stack->rxErrorCause = PACKET_NOT_ACCEPTED_CAUSE_PACKET_CRC;
      stack->statusInboundErrorPacketCrc++;
    }
  }
  else
  {
    /* Packet has not already started. */
    handleNewPacketStart(stack);
  }
}
 
 
 
static void handleEndOfPacket(RioStack_t *stack)
{
  /* Check if the CRC is correct. */
  if(stack->rxCrc == 0x0000u)
  {
    /* The packet has a correct CRC. */
 
    /* Check if the packet is long enough to contain a complete packet. */
    if(stack->rxCounter > 3u)
    {
      /* Packet long enough to process. */
 
      /* Process the newly received packet. */
      handleNewPacketEnd(stack);
    }
    else
    {
      /* The packet has a valid CRC but is too short. */
      /* Packet error. Enter input-error-stopped state. */
      stack->txState = TX_STATE_SEND_PACKET_NOT_ACCEPTED;
      stack->rxState = RX_STATE_INPUT_ERROR_STOPPED;
      stack->rxErrorCause = PACKET_NOT_ACCEPTED_CAUSE_GENERAL;
      stack->statusInboundErrorGeneral++;
    }
  }
  else
  {
    /* The packet has an invalid CRC. */
    /* Packet error. Enter input-error-stopped state. */
    stack->txState = TX_STATE_SEND_PACKET_NOT_ACCEPTED;
    stack->rxState = RX_STATE_INPUT_ERROR_STOPPED;
    stack->rxErrorCause = PACKET_NOT_ACCEPTED_CAUSE_PACKET_CRC;
    stack->statusInboundErrorPacketCrc++;
  }
}
 
 
 
static void handleNewPacketStart(RioStack_t *stack)
{
  /* Check if there are buffers available to store the new frame. */
  if (QueueAvailable(stack->rxQueue) > 0u)
  {
    /* There are buffers available to accept the new packet. */
 
    /* Update the reception counter to indicate the frame has started. */
    stack->rxCounter = 1;
  }
  else
  {
    /* There are no buffers available. */
    /* Go to input retry stopped state. */
    stack->statusInboundPacketRetry++;
    stack->txState = TX_STATE_SEND_PACKET_RETRY;
    stack->rxState = RX_STATE_INPUT_RETRY_STOPPED;
  }
}
 
 
 
static void handleNewPacketEnd(RioStack_t *stack)
{
  /* Save the size of the packet. */
  QueueSetSize(stack->rxQueue, (uint32_t)stack->rxCounter - (uint32_t)1ul);
 
  /* Always forward the packet to the top of the stack. */
  stack->rxQueue = QueueEnqueue(stack->rxQueue);
 
  /* Make sure the CRC is reset to an invalid value to avoid a packet
     accidentally being accepted. */
  stack->rxCrc = 0xffff;
 
  /* Reset the reception counter. */
  stack->rxCounter = 0u;
 
  /* Update the ackId for the receiver. */
  stack->rxAckId = ACKID_INC(stack->rxAckId);
 
  /* Update status counter. */
  stack->statusInboundPacketComplete++;
}
 
 
 
static void handleLinkRequest(RioStack_t *stack, uint8_t cmd)
{
  /* Check the command of the link-request. */
  if(cmd == LINK_REQUEST_INPUT_STATUS)
  {
    /* Input-status requested. */
    /* Return input port status. */
 
    /* Force the transmitter to send a link-response-symbol. */
    stack->txState = TX_STATE_SEND_LINK_RESPONSE;
  }
  else if(cmd == LINK_REQUEST_RESET_DEVICE)
  {
    /* Reset-device requested. */
    /* REMARK: Support this??? */
  }
  else
  {
    /* Unrecognized command. */
    /* Dont do anything. */
  }
 
  /* Always cancel an ongoing frame when a link-request has been received. */
  stack->rxCounter = 0;
 
  /* Receiving this indicates the link partner having encountered a potential problem. */
  /* Count the number of times this happens. */
  stack->statusPartnerLinkRequest++;
}
 
 
 
static RioSymbol_t CreateControlSymbol(const uint8_t stype0,
                                       const uint8_t parameter0, const uint8_t parameter1,
                                       const uint8_t stype1, const uint8_t cmd)
{
  RioSymbol_t s;
 
  s.type = RIOSTACK_SYMBOL_TYPE_CONTROL;
 
  s.data = ((uint32_t)stype0 & (uint32_t)0x07ul) << 21;
  s.data |= ((uint32_t)parameter0 & (uint32_t)0x1ful) << 16;
  s.data |= ((uint32_t)parameter1 & (uint32_t)0x1ful) << 11;
  s.data |= ((uint32_t)stype1 & (uint32_t)0x07ul) << 8;
  s.data |= ((uint32_t)cmd & (uint32_t)0x7ul) << 5;
  s.data |= Crc5(s.data, 0x1fu);
 
  return s;
}
 
 
 
static uint8_t Crc5(const uint32_t data, const uint8_t crc)
{
  static const uint8_t crcTable[] = {
    0x00u, 0x15u, 0x1fu, 0x0au, 0x0bu, 0x1eu, 0x14u, 0x01u,
    0x16u, 0x03u, 0x09u, 0x1cu, 0x1du, 0x08u, 0x02u, 0x17u,
    0x19u, 0x0cu, 0x06u, 0x13u, 0x12u, 0x07u, 0x0du, 0x18u,
    0x0fu, 0x1au, 0x10u, 0x05u, 0x04u, 0x11u, 0x1bu, 0x0eu
  };
 
  uint8_t result;
  uint8_t index;
 
  result = crc;
  index  = (uint8_t)((data >> 19) & (uint32_t)0x1ful) ^ result;
  result = crcTable[index];
  index  = (uint8_t)((data >> 14) & (uint32_t)0x1ful) ^ result;
  result = crcTable[index];
  index  = (uint8_t)((data >> 9) & (uint32_t)0x1ful) ^ result;
  result = crcTable[index];
  index  = (uint8_t)((data >> 4) & (uint32_t)0x1eul) ^ result;
  result = crcTable[index];
 
  return result;
}
 
 
/*******************************************************************************************
 * Internal queue functions.
 *******************************************************************************************/
 
static Queue_t QueueCreate(const uint8_t size, uint32_t *buffer)
{
  Queue_t q;
 
  q.size = size;
  q.available = size;
  q.windowSize = 0u;
  q.windowIndex = 0u;
  q.frontIndex = 0u;
  q.backIndex = 0u;
  q.buffer_p = buffer;
 
  return q;
}
 
 
 
static uint8_t QueueAvailable(const Queue_t q)
{
  return q.available;
}
 
 
 
static int QueueEmpty(const Queue_t q)
{
  return (q.available == q.size);
}
 
 
 
static uint8_t QueueLength(const Queue_t q)
{
  return q.size - q.available;
}
 
 
 
static Queue_t QueueEnqueue(Queue_t q)
{
  q.backIndex++;
  if(q.backIndex == q.size)
  {
    q.backIndex = 0;
  }
  q.available--;
  return q;
}
 
 
 
static Queue_t QueueDequeue(Queue_t q)
{
  q.frontIndex++;
  if(q.frontIndex == q.size)
  {
    q.frontIndex = 0;
  }
  q.available++;
  if(q.windowSize == 0)
  {
    q.windowIndex = q.frontIndex;
  }
  else
  {
    q.windowSize--;
  }
  return q;
}
 
 
 
static int QueueWindowEmpty(const Queue_t q)
{
  return ((q.available + q.windowSize) == q.size);
}
 
 
 
static Queue_t QueueWindowReset(Queue_t q)
{
  q.windowIndex = q.frontIndex;
  q.windowSize = 0;
  return q;
}
 
 
 
static Queue_t QueueWindowNext(Queue_t q)
{
  q.windowIndex++;
  if(q.windowIndex == q.size)
  {
    q.windowIndex = 0;
  }
  q.windowSize++;
  return q;
}
 
 
 
static void QueueSetSize(Queue_t q, const uint32_t size)
{
  (q.buffer_p+(RIOSTACK_BUFFER_SIZE*q.backIndex))[0] = size;
}
 
 
 
static void QueueSetContent(Queue_t q, const uint32_t index, const uint32_t content)
{
  (q.buffer_p+(RIOSTACK_BUFFER_SIZE*q.backIndex))[index+1ul] = content;
}
 
 
 
static uint32_t QueueGetSize(Queue_t q)
{
  return (q.buffer_p+(RIOSTACK_BUFFER_SIZE*q.windowIndex))[0];
}
 
 
 
static uint32_t QueueGetFrontContent(const Queue_t q, const uint32_t index)
{
  return (q.buffer_p+(RIOSTACK_BUFFER_SIZE*q.windowIndex))[index+1ul];
}
 
 
 
static uint32_t *QueueGetFrontBuffer(const Queue_t q )
{
  return &((q.buffer_p+(RIOSTACK_BUFFER_SIZE*q.windowIndex))[1]);
}
 
 
 
static uint32_t *QueueGetBackBuffer(const Queue_t q )
{
  return &((q.buffer_p+(RIOSTACK_BUFFER_SIZE*q.backIndex))[1]);
}
 
/*************************** end of file **************************************/

Line No.	Rev	Author	Line
1	20	magro732	`/*******************************************************************************`
2			`*`
3			`* RapidIO IP Library Core`
4			`*`
5			`* This file is part of the RapidIO IP library project`
6			`* http://www.opencores.org/cores/rio/`
7			`*`
8			`* Description:`
9			`* This file contains a software implementation of a RapidIO stack according to`
10			`* the 2.2 version, part 6, of the standard. Only short control symbols are`
11			`* supported.`
12			`*`
13			`* Symbols are in four flavors, idle, control, data and error. They are abstract`
14			`* and should be serialized by any implementation to be sent on a transmission`
15			`* channel. Error symbols are never generated by the stack and are used if the`
16			`* symbol decoder encounters an error that the stack should be notified of.`
17			`*`
18	49	magro732	`* Symbols are inserted into the stack from the lower-half by calling`
19			`* RIOSTACK_portAddSymbol() and symbols to transmit are fetched from the stack`
20			`* using RIOSTACK_portGetSymbol(). These two functions are the low-level interface`
21			`* towards a physical transmission channel.`
22			`* The function RIOSTACK_portSetStatus() is used to indicate to the stack that initial`
23	20	magro732	`* training of the symbol codec has been completed and that the transmission port`
24			`* is ready to accept other symbols than idle. The procedure is to set the port`
25			`* status to initialized once idle symbols are successfully received.`
26			`*`
27	49	magro732	`* On the upper-half interface are the RIOSTACK_setOutboundPacket() function used to`
28			`* insert packets into the outbound transmission queue and RIOSTACK_getInboundPacket()`
29			`* is used to get packet from the inbound reception queue. The`
30			`* RIOSTACK_getInboundQueueLength() function is used to check if any packet is available`
31			`* for reading in the inbound reception queue.`
32	20	magro732	`*`
33			`* -----------------`
34			`* \| OS dependent \|`
35			`* \| (your code) \|`
36			`* -----------------`
37			`* \|`
38			`* -----------------`
39			`* \| RioStack \|`
40			`* -----------------`
41			`* \|`
42			`* -----------------`
43			`* \| Symbol Codec \|`
44			`* \| (your code) \|`
45			`* -----------------`
46			`* \|`
47			`* -----------------`
48			`* \| Port driver \|`
49			`* -----------------`
50			`* \|`
51			`* -----------------`
52			`* \| Physical port \|`
53			`* -----------------`
54			`*`
55			`* The symbol codec maps a RapidIO symbol to the physical transmission media.`
56			`*`
57			`* Some typical patterns to handle this stack are:`
58			`* Initialization:`
59	49	magro732	`* RIOSTACK_open(...);`
60			`* RIOSTACK_portSetTimeout(...);`
61	20	magro732	`* ...`
62			`* <Symbol transcoder is successfully decoding symbols from the link>`
63	49	magro732	`* RIOSTACK_portSetStatus(1);`
64	20	magro732	`*`
65			`* Bottom-half traffic handling:`
66	49	magro732	`* RIOSTACK_portSetTime(...);`
67	20	magro732	`* <get symbol from decoder>`
68	49	magro732	`* RIOSTACK_portAddSymbol(...);`
69			`* s = RIOSTACK_portGetSymbol(...);`
70	20	magro732	`* <send symbol to encoder>`
71			`*`
72			`* Receiving packets:`
73	49	magro732	`* if(RIOSTACK_getInboundQueueLength(...) > 0)`
74	20	magro732	`* {`
75	49	magro732	`* RIOSTACK_getInboundPacket(...);`
76			`* <process the new packet>`
77	20	magro732	`* }`
78			`*`
79			`* Transmitting packets:`
80	49	magro732	`* <create a new packet>`
81			`* if(RIOSTACK_getOutboundQueueAvailable(...) > 0)`
82	20	magro732	`* {`
83	49	magro732	`* RIOSTACK_setOutboundPacket(...);`
84	20	magro732	`* }`
85			`*`
86	49	magro732	`* More details about the usage can be found in the module tests in test_riostack.c.`
87	20	magro732	`*`
88			`* To Do:`
89	49	magro732	`* - Optimize the packing of stype0 and stype1 into control symbols.`
90	20	magro732	`*`
91			`* Author(s):`
92			`* - Magnus Rosenius, magro732@opencores.org`
93			`*`
94			`*******************************************************************************`
95			`*`
96	49	magro732	`* Copyright (C) 2015 Authors and OPENCORES.ORG`
97	20	magro732	`*`
98			`* This source file may be used and distributed without`
99			`* restriction provided that this copyright statement is not`
100			`* removed from the file and that any derivative work contains`
101			`* the original copyright notice and the associated disclaimer.`
102			`*`
103			`* This source file is free software; you can redistribute it`
104			`* and/or modify it under the terms of the GNU Lesser General`
105			`* Public License as published by the Free Software Foundation;`
106			`* either version 2.1 of the License, or (at your option) any`
107			`* later version.`
108			`*`
109			`* This source is distributed in the hope that it will be`
110			`* useful, but WITHOUT ANY WARRANTY; without even the implied`
111			`* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR`
112			`* PURPOSE. See the GNU Lesser General Public License for more`
113			`* details.`
114			`*`
115			`* You should have received a copy of the GNU Lesser General`
116			`* Public License along with this source; if not, download it`
117			`* from http://www.opencores.org/lgpl.shtml`
118			`*`
119			`*******************************************************************************/`
120
121	49	magro732
122	20	magro732	`/**`
123			`* \file riostack.c`
124			`*/`
125
126			`/*******************************************************************************`
127			`* Includes`
128			`*******************************************************************************/`
129
130			`#include "riostack.h"`
131
132
133			`/lint -e961 Allow function like macros. /`
134			`/lint -e621 Long identifier names allowed to increase readability. /`
135			`/lint -w2 /`
136
137
138	49	magro732	`/*lint --estring(960,17.4) It is not possible to implement a rio stack without some`
139	20	magro732	`* pointer arithmetic */`
140
141	49	magro732
142	20	magro732	`/*******************************************************************************`
143			`* Local macro definitions`
144			`*******************************************************************************/`
145
146			`/* Macro to update 5-bit ackId counters. */`
147			`#define ACKID_INC(ackId) (((ackId)+1)&0x1f)`
148
149			`/* Macros to get entries from a control symbol. */`
150			`#define STYPE0_GET(data) ((uint8_t) (((data) >> 21) & 0x00000007u))`
151			`#define PARAMETER0_GET(data) ((uint8_t) (((data) >> 16) & 0x00000001fu))`
152			`#define PARAMETER1_GET(data) ((uint8_t) (((data) >> 11) & 0x00000001fu))`
153			`#define STYPE1_GET(data) ((uint8_t) (((data) >> 8) & 0x00000007u))`
154			`#define CMD_GET(data) ((uint8_t) (((data) >> 5) & 0x00000007u))`
155			`#define CRC5_GET(data) ((uint8_t) (((data) >> 0) & 0x0000001fu))`
156
157			`/* Macros to get entries from a packet in a buffer. */`
158			`#define FTYPE_GET(p) (((p)[0] >> 16) & 0xf)`
159			`#define DESTID_GET(p) ((p)[0] & 0xffff)`
160			`#define SRCID_GET(p) (((p)[1] >> 16) & 0xffff)`
161			`#define TRANSACTION_GET(p) (((p)[1] >> 12) & 0xf)`
162			`#define MSGLEN_GET(p) TRANSACTION_GET(p)`
163			`#define SSIZE_GET(p) (((p)[1] >> 8) & 0xf)`
164			`#define LETTER_GET(p) (((p)[1] >> 6) & 0x3)`
165			`#define MBOX_GET(p) (((p)[1] >> 4) & 0x3)`
166			`#define MSGSEG_GET(p) ((p)[1] & 0xf)`
167			`#define XMBOX_GET(p) MSGSEG_GET(p)`
168			`#define RDSIZE_GET(p) SSIZE_GET(p)`
169			`#define WRSIZE_GET(p) SSIZE_GET(p)`
170			`#define TID_GET(p) ((p)[1] & 0xff)`
171			`#define HOP_GET(p) (((p)[2] >> 24) & 0xff)`
172			`#define CONFIG_OFFSET_GET(p) ((p)[2] & 0x00fffffcul)`
173			`#define INFO_GET(p) (((p)[2] >> 16) & 0xffff)`
174			`#define ADDRESS_GET(p) ((p)[2] & 0xfffffff8ul)`
175			`#define WDPTR_GET(p) (((p)[2] >> 2) & 0x1)`
176			`#define XAMBS_GET(p) ((p)[2] & 0x3)`
177			`#define DOUBLE_WORD_MSB_GET(p, i) (p)[3+(2*i+0)]`
178			`#define DOUBLE_WORD_LSB_GET(p, i) (p)[3+(2*i+1)]`
179
180			`/* Transmitter frame states. */`
181			`#define TX_FRAME_START ((uint8_t)0u)`
182			`#define TX_FRAME_BODY ((uint8_t)1u)`
183
184			`/* Control symbol constants. */`
185			`#define STYPE0_PACKET_ACCEPTED ((uint8_t)0x00u)`
186			`#define STYPE0_PACKET_RETRY ((uint8_t)0x01u)`
187			`#define STYPE0_PACKET_NOT_ACCEPTED ((uint8_t)0x02u)`
188			`#define STYPE0_RESERVED ((uint8_t)0x03u)`
189			`#define STYPE0_STATUS ((uint8_t)0x04u)`
190			`#define STYPE0_VC_STATUS ((uint8_t)0x05u)`
191			`#define STYPE0_LINK_RESPONSE ((uint8_t)0x06u)`
192			`#define STYPE0_IMPLEMENTATION_DEFINED ((uint8_t)0x07u)`
193			`#define STYPE1_START_OF_PACKET ((uint8_t)0x00u)`
194			`#define STYPE1_STOMP ((uint8_t)0x01u)`
195			`#define STYPE1_END_OF_PACKET ((uint8_t)0x02u)`
196			`#define STYPE1_RESTART_FROM_RETRY ((uint8_t)0x03u)`
197			`#define STYPE1_LINK_REQUEST ((uint8_t)0x04u)`
198			`#define STYPE1_MULTICAST_EVENT ((uint8_t)0x05u)`
199			`#define STYPE1_RESERVED ((uint8_t)0x06u)`
200			`#define STYPE1_NOP ((uint8_t)0x07u)`
201
202			`/* Packet ftype constants. */`
203			`#define FTYPE_REQUEST 0x2`
204			`#define FTYPE_WRITE 0x5`
205			`#define FTYPE_MAINTENANCE 0x8`
206			`#define FTYPE_DOORBELL 0xa`
207			`#define FTYPE_MESSAGE 0xb`
208			`#define FTYPE_RESPONSE 0xd`
209
210			`/* Transaction constants. */`
211			`#define TRANSACTION_MAINT_READ_REQUEST 0`
212			`#define TRANSACTION_MAINT_WRITE_REQUEST 1`
213			`#define TRANSACTION_MAINT_READ_RESPONSE 2`
214			`#define TRANSACTION_MAINT_WRITE_RESPONSE 3`
215			`#define TRANSACTION_WRITE_NWRITE 4`
216			`#define TRANSACTION_WRITE_NWRITER 5`
217			`#define TRANSACTION_REQUEST_NREAD 4`
218			`#define TRANSACTION_RESPONSE_NO_PAYLOAD 0`
219			`#define TRANSACTION_RESPONSE_MESSAGE_RESPONSE 1`
220			`#define TRANSACTION_RESPONSE_WITH_PAYLOAD 8`
221
222			`/* Maintenance transaction lengths. */`
223			`#define MAINTENANCE_TRANSACTION_READ_REQUEST_SIZE ((uint32_t) 4ul)`
224			`#define MAINTENANCE_TRANSACTION_WRITE_REQUEST_SIZE ((uint32_t) 6ul)`
225			`#define MAINTENANCE_TRANSACTION_READ_RESPONSE_SIZE ((uint32_t) 6ul)`
226			`#define MAINTENANCE_TRANSACTION_WRITE_RESPONSE_SIZE ((uint32_t) 4ul)`
227
228			`/* Constants used to forward different errors to the link partner. */`
229			`#define PACKET_NOT_ACCEPTED_CAUSE_RESERVED 0u`
230			`#define PACKET_NOT_ACCEPTED_CAUSE_UNEXPECTED_ACKID 1u`
231			`#define PACKET_NOT_ACCEPTED_CAUSE_CONTROL_CRC 2u`
232			`#define PACKET_NOT_ACCEPTED_CAUSE_NON_MAINTENANCE 3u`
233			`#define PACKET_NOT_ACCEPTED_CAUSE_PACKET_CRC 4u`
234			`#define PACKET_NOT_ACCEPTED_CAUSE_ILLEGAL_CHARACTER 5u`
235			`#define PACKET_NOT_ACCEPTED_CAUSE_NO_RESOURCE 6u`
236			`#define PACKET_NOT_ACCEPTED_CAUSE_DESCRAMBLER 7u`
237			`#define PACKET_NOT_ACCEPTED_CAUSE_GENERAL 31u`
238
239			`/* Constants used to request link-responses. */`
240			`#define LINK_REQUEST_RESET_DEVICE 3u`
241			`#define LINK_REQUEST_INPUT_STATUS 4u`
242
243			`/* Constants used to forward a port status in a link-resonse. */`
244			`#define LINK_RESPONSE_PORT_STATUS_ERROR 2u`
245			`#define LINK_RESPONSE_PORT_STATUS_RETRY_STOPPED 4u`
246			`#define LINK_RESPONSE_PORT_STATUS_ERROR_STOPPED 5u`
247			`#define LINK_RESPONSE_PORT_STATUS_OK 16u`
248
249	49	magro732
250
251	20	magro732	`/*******************************************************************************`
252			`* Local typedefs`
253			`*******************************************************************************/`
254
255	49	magro732
256
257	20	magro732	`/*******************************************************************************`
258			`* Global declarations`
259			`*******************************************************************************/`
260
261	49	magro732
262
263	20	magro732	`/*******************************************************************************`
264			`* Local declarations`
265			`*******************************************************************************/`
266
267	49	magro732
268
269	20	magro732	`/*******************************************************************************`
270			`* Local function prototypes`
271			`*******************************************************************************/`
272
273			`/* Helper functions for protocol events. */`
274			`static void handleStatus(RioStack_t *stack, const uint8_t ackId, const uint8_t bufferStatus);`
275			`static void handlePacketAccepted(RioStack_t *stack, const uint8_t ackId, const uint8_t bufferStatus);`
276			`static void handlePacketRetry(RioStack_t *stack, const uint8_t ackId, const uint8_t bufferStatus);`
277			`static void handlePacketNotAccepted(RioStack_t *stack, const uint8_t arbitrary, const uint8_t cause);`
278			`static void handleLinkResponse(RioStack_t *stack, const uint8_t ackId, const uint8_t portStatus);`
279			`static void handleStartOfPacket(RioStack_t *stack);`
280			`static void handleEndOfPacket(RioStack_t *stack);`
281			`static void handleLinkRequest(RioStack_t *stack, uint8_t cmd);`
282			`static void handleNewPacketStart(RioStack_t *stack);`
283			`static void handleNewPacketEnd(RioStack_t *stack);`
284
285			`/**`
286			`* \brief Create a control symbol.`
287			`*`
288			`* \param[in] stype0 The stype0 value.`
289			`* \param[in] parameter0 The parameter0 value.`
290			`* \param[in] parameter1 The parameter1 value.`
291			`* \param[in] stype1 The stype1 value.`
292			`* \param[in] cmd The cmd value.`
293			`* \return The control symbol that were created from the input parameters.`
294			`*`
295			`* This function creates a control symbol with the specified arguments and`
296			`* calculates a CRC-5 checksum according to the standard specification.`
297			`*/`
298	49	magro732	`static RioSymbol_t CreateControlSymbol(const uint8_t stype0,`
299			`const uint8_t parameter0, const uint8_t parameter1,`
300			`const uint8_t stype1, const uint8_t cmd);`
301	20	magro732
302			`/**`
303			`* \brief Function to calculate ITU-CRC5, polynom=0x15.`
304			`*`
305			`* \param[in] data The data of a control symbol.`
306			`* \param[in] crc The crc to initiate the result with.`
307			`* \return A new CRC-5 value.`
308			`*/`
309	49	magro732	`static uint8_t Crc5(const uint32_t data, const uint8_t crc);`
310	20	magro732
311			`/**`
312			`* \brief Create a queue with a specified size and a buffer attached to it.`
313			`*`
314	49	magro732	`* \param[in] size The number of entries in the queue.`
315			`* \param[in] buffer A pointer to the buffer to store the content in.`
316	20	magro732	`* \return A queue with the specified size and where new data will be stored`
317			`* to the specified buffer.`
318			`*/`
319	49	magro732	`static Queue_t QueueCreate(const uint8_t size, uint32_t *buffer);`
320	20	magro732
321			`/**`
322			`* \brief Get number of available elements.`
323			`*`
324			`* \param[in] q The queue to operate on.`
325			`* \return The number of free packet buffers in the queue.`
326			`*/`
327	49	magro732	`static uint8_t QueueAvailable(const Queue_t q );`
328	20	magro732
329			`/**`
330			`* \brief Get if the queue is empty or not.`
331			`*`
332			`* \param[in] q The queue to operate on.`
333			`* \return Non-zero if the queue is empty.`
334			`*/`
335	49	magro732	`static int QueueEmpty(const Queue_t q);`
336	20	magro732
337			`/**`
338			`* \brief Get the length of a queue.`
339			`*`
340			`* \param[in] q The queue to operate on.`
341			`* \return The number of elements in the queue.`
342			`*/`
343	49	magro732	`static uint8_t QueueLength(const Queue_t q);`
344	20	magro732
345			`/**`
346			`* \brief Add a new element to the queue.`
347			`*`
348			`* \param[in] q The queue to operate on.`
349			`* \return A queue with one added element.`
350			`*/`
351	49	magro732	`static Queue_t QueueEnqueue(Queue_t q);`
352	20	magro732
353			`/**`
354			`* \brief Remove an element from the queue.`
355			`*`
356			`* \param[in] q The queue to operate on.`
357			`* \return A queue with on removed element.`
358			`*/`
359	49	magro732	`static Queue_t QueueDequeue(Queue_t q);`
360	20	magro732
361			`/**`
362			`* \brief Check if the readout window is empty.`
363			`*`
364			`* \param[in] q The queue to operate on.`
365			`* \return If the readout window is empty.`
366			`*/`
367	49	magro732	`static int QueueWindowEmpty(const Queue_t q);`
368	20	magro732
369			`/**`
370			`* \brief Reset the window to none.`
371			`*`
372			`* \param[in] q The queue to operate on.`
373			`* \return The updated Queue_t structure.`
374			`*/`
375			`static Queue_t QueueWindowReset(Queue_t q);`
376
377			`/**`
378			`* \brief Increase the window to the next pending element.`
379			`*`
380			`* \param[in] q The queue to operate on.`
381			`* \return The updated Queue_t structure.`
382			`*/`
383			`static Queue_t QueueWindowNext(Queue_t q);`
384
385			`/**`
386			`* \brief Set actual size of the newest element.`
387			`*`
388			`* \param[in] q The queue to operate on.`
389			`* \param[in] size The size to set the newest content size to.`
390			`*/`
391	49	magro732	`static void QueueSetSize(Queue_t q, const uint32_t size);`
392	20	magro732
393			`/**`
394			`* \brief Set content at a specified index in the newest element.`
395			`*`
396			`* \param[in] q The queue to operate on.`
397			`* \param[in] index posititon into the element`
398			`* \param[in] content The content to set at the specified index in the newest queue element.`
399			`*/`
400	49	magro732	`static void QueueSetContent(Queue_t q, const uint32_t index, const uint32_t content);`
401	20	magro732
402			`/**`
403			`* \brief Get a pointer to the buffer of the newest element.`
404			`*`
405			`* \param[in] q The queue to operate on.`
406			`* \return A pointer to the content.`
407			`*/`
408	49	magro732	`static uint32_t *QueueGetBackBuffer(Queue_t q );`
409	20	magro732
410			`/**`
411			`* \brief Get the size of the oldest element.`
412			`* \param[in] q The queue to operate on.`
413			`* \return The size of the element.`
414			`*/`
415	49	magro732	`static uint32_t QueueGetSize(Queue_t q );`
416	20	magro732
417			`/**`
418			`* \brief Get the content of the oldest element at specified index.`
419			`* \param[in] q The queue to operate on.`
420			`* \param[in] index The index into the element to get the content from.`
421			`* \return content of element at index position.`
422			`*/`
423	49	magro732	`static uint32_t QueueGetFrontContent(Queue_t q, const uint32_t index);`
424	20	magro732
425			`/**`
426			`* \brief Get a pointer to the buffer of the oldest element.`
427			`*`
428			`* \param[in] q The queue to operate on.`
429			`* \return A pointer to the content.`
430			`*/`
431	49	magro732	`static uint32_t *QueueGetFrontBuffer(Queue_t q );`
432	20	magro732
433
434
435			`/*******************************************************************************`
436			`* Global functions`
437			`*******************************************************************************/`
438
439	49	magro732	`void RIOSTACK_open(RioStack_t stack, void private,`
440			`const uint32_t rxPacketBufferSize, uint32_t *rxPacketBuffer,`
441			`const uint32_t txPacketBufferSize, uint32_t *txPacketBuffer)`
442	20	magro732	`{`
443			`/* Port time and timeout limit. */`
444			`stack->portTime = 0u;`
445			`stack->portTimeout = 1000u;`
446
447			`/* Setup the receiver. */`
448			`stack->rxState = RX_STATE_UNINITIALIZED;`
449			`stack->rxCounter = 0u;`
450			`stack->rxCrc = 0xffffu;`
451			`stack->rxStatusReceived = 0u;`
452			`stack->rxAckId = 0u;`
453			`stack->rxAckIdAcked = 0u;`
454			`stack->rxErrorCause = PACKET_NOT_ACCEPTED_CAUSE_RESERVED;`
455	49	magro732	`stack->rxQueue = QueueCreate((uint8_t) (rxPacketBufferSize/RIOSTACK_BUFFER_SIZE), rxPacketBuffer);`
456	20	magro732
457			`/* Setup the transmitter. */`
458			`stack->txState = TX_STATE_UNINITIALIZED;`
459			`stack->txCounter = 0u;`
460			`stack->txStatusCounter = 0u;`
461			`stack->txFrameState = TX_FRAME_START;`
462			`stack->txAckId = 0u;`
463			`stack->txAckIdWindow = 0u;`
464	49	magro732	`stack->txQueue = QueueCreate((uint8_t) (txPacketBufferSize/RIOSTACK_BUFFER_SIZE), txPacketBuffer);`
465	20	magro732
466			`/* Setup status counters for inbound direction. */`
467			`stack->statusInboundPacketComplete = 0ul;`
468			`stack->statusInboundPacketRetry = 0ul;`
469			`stack->statusInboundErrorControlCrc = 0ul;`
470			`stack->statusInboundErrorPacketAckId = 0ul;`
471			`stack->statusInboundErrorPacketCrc = 0ul;`
472			`stack->statusInboundErrorIllegalCharacter = 0ul;`
473			`stack->statusInboundErrorGeneral = 0ul;`
474			`stack->statusInboundErrorPacketUnsupported = 0ul;`
475
476			`/* Setup status counters for outbound direction. */`
477			`stack->statusOutboundPacketComplete = 0ul;`
478	49	magro732	`stack->statusOutboundLinkLatencyMax = 0ul;`
479	20	magro732	`stack->statusOutboundPacketRetry = 0ul;`
480			`stack->statusOutboundErrorTimeout = 0ul;`
481			`stack->statusOutboundErrorPacketAccepted = 0ul;`
482			`stack->statusOutboundErrorPacketRetry = 0ul;`
483
484			`/* Setup status counters for potential problems on the link-partner. */`
485			`stack->statusPartnerLinkRequest = 0ul;`
486			`stack->statusPartnerErrorControlCrc = 0ul;`
487			`stack->statusPartnerErrorPacketAckId = 0ul;`
488			`stack->statusPartnerErrorPacketCrc = 0ul;`
489			`stack->statusPartnerErrorIllegalCharacter = 0ul;`
490			`stack->statusPartnerErrorGeneral = 0ul;`
491
492			`/* Set pointer to user private data. */`
493			`stack->private = private;`
494			`}`
495
496
497	49	magro732
498	20	magro732	`/*******************************************************************************************`
499	49	magro732	`* Stack status and queue access functions.`
500			`* Note that status counters are accessed directly in the stack-structure.`

Browse

Tools

Subversion Repositories rio

[/] [rio/] [trunk/] [sw/] [stack/] [riostack.c] - Blame information for rev 49