Subversion Repositories rio

/*******************************************************************************

 *

 * RapidIO IP Library Core

 *

 * This file is part of the RapidIO IP library project

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

 *

 * Description:

 * This file contains code that can serialize and deserialize rio symbols onto

 * and from an 8-bit UART transmission channel.

 *

 * To Do:

 * -

 *

 * Author(s):

 * - Magnus Rosenius, magro732@opencores.org

 *

 *******************************************************************************

 *

 * Copyright (C) 2013 Authors and OPENCORES.ORG

 *

 * This source file may be used and distributed without

 * restriction provided that this copyright statement is not

 * removed from the file and that any derivative work contains

 * the original copyright notice and the associated disclaimer.

 *

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

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

 * Public License as published by the Free Software Foundation;

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

 * later version.

 *

 * This source is distributed in the hope that it will be

 * useful, but WITHOUT ANY WARRANTY; without even the implied

 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

 * PURPOSE. See the GNU Lesser General Public License for more

 * details.

 *

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

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

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

 *

 *******************************************************************************/

#include <stdint.h>

typedef enum

{

  RIO_SYMBOL_TYPE_IDLE, RIO_SYMBOL_TYPE_CONTROL,

  RIO_SYMBOL_TYPE_DATA, RIO_SYMBOL_TYPE_ERROR

} RioSymbolType;

typedef struct

{

  RioSymbolType type;

  uint32_t data;

} RioSymbol;

typedef struct

{

} RioStack_t;

void RIO_portAddSymbol( RioStack_t *stack, const RioSymbol s );

RioSymbol RIO_portGetSymbol( RioStack_t *stack );

void receiveByte(RioStack_t *stack, uint8_t incoming)

{

  static RioSymbol rxSymbol;

  static uint8_t flagFound = 0;

  static uint8_t symbolCounter = 0;

  if(incoming != 0x7e)

  {

    if(incoming != 0x7d)

    {

      if(flagFound)

      {

        incoming ^= 0x20;

      }

      else

      {

        /* Dont do anything. */

      }

      switch(symbolCounter)

      {

        case 0:

          rxSymbol.type = RIO_SYMBOL_TYPE_ERROR;

          rxSymbol.data = incoming;

          symbolCounter++;

          break;

        case 1:

          rxSymbol.type = RIO_SYMBOL_TYPE_ERROR;

          rxSymbol.data <<= 8;

          rxSymbol.data |= incoming;

          symbolCounter++;

          break;

        case 2:

          rxSymbol.type = RIO_SYMBOL_TYPE_CONTROL;

          rxSymbol.data <<= 8;

          rxSymbol.data |= incoming;

          symbolCounter++;

          break;

        case 3:

          rxSymbol.type = RIO_SYMBOL_TYPE_DATA;

          rxSymbol.data <<= 8;

          rxSymbol.data |= incoming;

          RIO_portAddSymbol(stack, rxSymbol);

          rxSymbol.data = 0x00000000;

          symbolCounter = 0;

          break;

      }

      flagFound = 0;

    }

    else

    {

      flagFound = 1;

    }

  }

  else

  {

    if(symbolCounter == 0)

    {

      rxSymbol.type = RIO_SYMBOL_TYPE_IDLE;

      RIO_portAddSymbol(stack, rxSymbol);

    }

    else

    {

      RIO_portAddSymbol(stack, rxSymbol);

    }

    symbolCounter = 0;

  }

}

uint8_t transmitByte(RioStack_t *stack)

{

  uint8_t returnValue;

  static uint8_t symbolCounter = 3;

  static uint8_t stuffing = 0;

  static RioSymbol txSymbol;

  uint8_t outbound;

  /* Check if the previous symbol has been sent. */

  if((symbolCounter == 3) && (stuffing == 0))

  {

    /* Symbol sent. */

    /* Get a new symbol. */

    txSymbol = RIO_portGetSymbol(stack);

    if(txSymbol.type == RIO_SYMBOL_TYPE_CONTROL)

    {

      txSymbol.data <<= 8;

    }

  }

  else

  {

    /* Symbol not sent. */

    /* Continue to send the old symbol. */

  }

  /* Check if a flag should be sent. */

  if ((txSymbol.type == RIO_SYMBOL_TYPE_IDLE) ||

      ((stuffing == 0) && (symbolCounter == 0) && (txSymbol.type == RIO_SYMBOL_TYPE_CONTROL)))

  {

    /* A flag needs to be sent. */

    /* An idle symbol should be sent as a flag and a control symbol should always be

       terminated by a flag. */

    returnValue = 0x7e;

    symbolCounter = 3;

    stuffing = 0;

  }

  else

  {

    /* A flag does not need to be sent. */

    /* Get the current byte in the symbol. */

    outbound = txSymbol.data >> (8*symbolCounter);

    /* Check if stuffing is active. */

    if(!stuffing)

    {

      /* No stuffing active. */

      /* Check if the current byte needs to be stuffed. */

      if((outbound != 0x7e) && (outbound != 0x7d))

      {

        /* The current byte does not need to be stuffed. */

        returnValue = outbound;

        symbolCounter = (symbolCounter - 1) & 0x3;

      }

      else

      {

        /* The current byte needs to be stuffed. */

        returnValue = 0x7d;

        stuffing = 1;

      }

    }

    else

    {

      /* Stuffing is active. */

      /* An escape sequence has been sent, transmit the original data but change it to not being a flag. */

      returnValue = outbound ^ 0x20;

      stuffing = 0;

      symbolCounter = (symbolCounter - 1) & 0x3;

    }

  }

  return returnValue;

}

/*******************************************************************************

 * Module test code.

 *******************************************************************************/

#define TESTEXPR(got, expected)                                         \

  if ((got)!=(expected))                                                \

  {                                                                     \

    printf("ERROR at line %u:%s=%u (0x%08x) expected=%u (0x%08x)\n",    \

           __LINE__, #got, (got), (got), (expected), (expected));       \

    exit(1);                                                            \

  }

static RioSymbol txSymbol;

static uint8_t txNewSymbol;

static RioSymbol rxSymbol;

static uint8_t rxNewSymbol;

void RIO_portAddSymbol( RioStack_t *stack, const RioSymbol s )

{

  rxNewSymbol = 1;

  rxSymbol = s;

}

RioSymbol RIO_portGetSymbol( RioStack_t *stack )

{

  if(txNewSymbol)

  {

    txNewSymbol = 0;

    return txSymbol;

  }

  else

  {

    RioSymbol s;

    s.type = RIO_SYMBOL_TYPE_ERROR;

    return s;

  }

}

int main(int argc, char *argv[])

{

  RioStack_t *stack;

  /***************************************************************

   * Test receiver.

   ***************************************************************/

  /* Receive a flag. */

  rxNewSymbol = 0;

  receiveByte(stack, 0x7e);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_IDLE);

  /* Receive not a flag followed by flag. */

  rxNewSymbol = 0;

  receiveByte(stack, 0xaa);

  receiveByte(stack, 0x7e);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_ERROR);

  /* Receive not a flag twice followed by flag. */

  rxNewSymbol = 0;

  receiveByte(stack, 0xaa);

  receiveByte(stack, 0x55);

  receiveByte(stack, 0x7e);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_ERROR);

  /* Receive a control symbol followed by flag. */

  rxNewSymbol = 0;

  receiveByte(stack, 0x11);

  receiveByte(stack, 0x22);

  receiveByte(stack, 0x33);

  receiveByte(stack, 0x7e);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_CONTROL);

  TESTEXPR(rxSymbol.data, 0x00112233);

  /* Receive a data symbol. */

  rxNewSymbol = 0;

  receiveByte(stack, 0x44);

  receiveByte(stack, 0x55);

  receiveByte(stack, 0x66);

  receiveByte(stack, 0x77);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_DATA);

  TESTEXPR(rxSymbol.data, 0x44556677);

  /* Receive a back-to-back data symbol. */

  rxNewSymbol = 0;

  receiveByte(stack, 0x88);

  receiveByte(stack, 0x99);

  receiveByte(stack, 0xaa);

  receiveByte(stack, 0xbb);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_DATA);

  TESTEXPR(rxSymbol.data, 0x8899aabb);

  /* Receive a back-to-back control symbol. */

  rxNewSymbol = 0;

  receiveByte(stack, 0xcc);

  receiveByte(stack, 0xdd);

  receiveByte(stack, 0xee);

  receiveByte(stack, 0x7e);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_CONTROL);

  TESTEXPR(rxSymbol.data, 0x00ccddee);

  /* Test control symbol with one stuffed byte. */

  rxNewSymbol = 0;

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5e);

  receiveByte(stack, 0xff);

  receiveByte(stack, 0x01);

  receiveByte(stack, 0x7e);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_CONTROL);

  TESTEXPR(rxSymbol.data, 0x007eff01);

  /* Test control symbol with two stuffed bytes. */

  rxNewSymbol = 0;

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5e);

  receiveByte(stack, 0xff);

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5d);

  receiveByte(stack, 0x7e);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_CONTROL);

  TESTEXPR(rxSymbol.data, 0x007eff7d);

  /* Test control symbol with three stuffed bytes. */

  rxNewSymbol = 0;

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5d);

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5e);

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5d);

  receiveByte(stack, 0x7e);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_CONTROL);

  TESTEXPR(rxSymbol.data, 0x007d7e7d);

  /* Test data symbol with one stuffed byte. */

  rxNewSymbol = 0;

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5e);

  receiveByte(stack, 0x00);

  receiveByte(stack, 0x01);

  receiveByte(stack, 0x02);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_DATA);

  TESTEXPR(rxSymbol.data, 0x7e000102);

  /* Test data symbol with two stuffed bytes. */

  rxNewSymbol = 0;

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5e);

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5d);

  receiveByte(stack, 0x03);

  receiveByte(stack, 0x04);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_DATA);

  TESTEXPR(rxSymbol.data, 0x7e7d0304);

  /* Test data symbol with three stuffed bytes. */

  rxNewSymbol = 0;

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5e);

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5d);

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5e);

  receiveByte(stack, 0x05);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_DATA);

  TESTEXPR(rxSymbol.data, 0x7e7d7e05);

  /* Test data symbol with four stuffed bytes. */

  rxNewSymbol = 0;

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5e);

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5d);

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5e);

  receiveByte(stack, 0x7d);

  receiveByte(stack, 0x5d);

  TESTEXPR(rxNewSymbol, 1);

  TESTEXPR(rxSymbol.type, RIO_SYMBOL_TYPE_DATA);

  TESTEXPR(rxSymbol.data, 0x7e7d7e7d);

  /***************************************************************

   * Test transmitter.

   ***************************************************************/

  /* Test transmission of idle symbol. */

  txNewSymbol = 1;

  txSymbol.type = RIO_SYMBOL_TYPE_IDLE;

  TESTEXPR(transmitByte(stack), 0x7e);

  /* Test transmission of control symbol. */

  txNewSymbol = 1;

  txSymbol.type = RIO_SYMBOL_TYPE_CONTROL;

  txSymbol.data = 0x00112233;

  TESTEXPR(transmitByte(stack), 0x11);

  TESTEXPR(transmitByte(stack), 0x22);

  TESTEXPR(transmitByte(stack), 0x33);

  TESTEXPR(transmitByte(stack), 0x7e);

  /* Test transmission of data symbol. */

  txNewSymbol = 1;

  txSymbol.type = RIO_SYMBOL_TYPE_DATA;

  txSymbol.data = 0x44556677;

  TESTEXPR(transmitByte(stack), 0x44);

  TESTEXPR(transmitByte(stack), 0x55);

  TESTEXPR(transmitByte(stack), 0x66);

  TESTEXPR(transmitByte(stack), 0x77);

  /* Test transmission of back-to-back data symbol. */

  txNewSymbol = 1;

  txSymbol.type = RIO_SYMBOL_TYPE_DATA;

  txSymbol.data = 0x8899aabb;

  TESTEXPR(transmitByte(stack), 0x88);

  TESTEXPR(transmitByte(stack), 0x99);

  TESTEXPR(transmitByte(stack), 0xaa);

  TESTEXPR(transmitByte(stack), 0xbb);

  /* Test transmission of back-to-back control symbol. */

  txNewSymbol = 1;

  txSymbol.type = RIO_SYMBOL_TYPE_CONTROL;

  txSymbol.data = 0xffccddee;

  TESTEXPR(transmitByte(stack), 0xcc);

  TESTEXPR(transmitByte(stack), 0xdd);

  TESTEXPR(transmitByte(stack), 0xee);

  TESTEXPR(transmitByte(stack), 0x7e);

  /* Test transmission of back-to-back control symbol. */

  txNewSymbol = 1;

  txSymbol.type = RIO_SYMBOL_TYPE_CONTROL;

  txSymbol.data = 0xff010203;

  TESTEXPR(transmitByte(stack), 0x01);

  TESTEXPR(transmitByte(stack), 0x02);

  TESTEXPR(transmitByte(stack), 0x03);

  TESTEXPR(transmitByte(stack), 0x7e);

  /* Test transmission of control symbol with one stuffed byte. */

  txNewSymbol = 1;

  txSymbol.type = RIO_SYMBOL_TYPE_CONTROL;

  txSymbol.data = 0xff7e0102;

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5e);

  TESTEXPR(transmitByte(stack), 0x01);

  TESTEXPR(transmitByte(stack), 0x02);

  TESTEXPR(transmitByte(stack), 0x7e);

  /* Test transmission of stuffed control symbol with two stuffed bytes. */

  txNewSymbol = 1;

  txSymbol.type = RIO_SYMBOL_TYPE_CONTROL;

  txSymbol.data = 0xff7e7d01;

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5e);

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5d);

  TESTEXPR(transmitByte(stack), 0x01);

  TESTEXPR(transmitByte(stack), 0x7e);

  /* Test transmission of stuffed control symbol with three stuffed bytes. */

  txNewSymbol = 1;

  txSymbol.type = RIO_SYMBOL_TYPE_CONTROL;

  txSymbol.data = 0xff7e7d7e;

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5e);

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5d);

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5e);

  TESTEXPR(transmitByte(stack), 0x7e);

  /* Test transmission of data symbol with one stuffed byte. */

  txNewSymbol = 1;

  txSymbol.type = RIO_SYMBOL_TYPE_DATA;

  txSymbol.data = 0x7e010203;

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5e);

  TESTEXPR(transmitByte(stack), 0x01);

  TESTEXPR(transmitByte(stack), 0x02);

  TESTEXPR(transmitByte(stack), 0x03);

  /* Test transmission of data symbol with two stuffed byte. */

  txNewSymbol = 1;

  txSymbol.type = RIO_SYMBOL_TYPE_DATA;

  txSymbol.data = 0x7e7d0102;

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5e);

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5d);

  TESTEXPR(transmitByte(stack), 0x01);

  TESTEXPR(transmitByte(stack), 0x02);

  /* Test transmission of data symbol with three stuffed byte. */

  txNewSymbol = 1;

  txSymbol.type = RIO_SYMBOL_TYPE_DATA;

  txSymbol.data = 0x7e7d7e01;

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5e);

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5d);

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5e);

  TESTEXPR(transmitByte(stack), 0x01);

  /* Test transmission of data symbol with four stuffed byte. */

  txNewSymbol = 1;

  txSymbol.type = RIO_SYMBOL_TYPE_DATA;

  txSymbol.data = 0x7e7d7e7d;

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5e);

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5d);

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5e);

  TESTEXPR(transmitByte(stack), 0x7d);

  TESTEXPR(transmitByte(stack), 0x5d);

  /***************************************************************

   * Test complete.

   ***************************************************************/

  printf("Test complete.\n");

}