/* 
+------------------------------------------------------------------------------
|  File:       tr.c
+------------------------------------------------------------------------------
|  Copyright 2004 Texas Instruments Deutschland, AG 
|                 All rights reserved. 
| 
|                 This file is confidential and a trade secret of Texas 
|                 Instruments Berlin, AG 
|                 The receipt of or possession of this file does not convey 
|                 any rights to reproduce or disclose its contents or to 
|                 manufacture, use, or sell anything it may describe, in 
|                 whole, or in part, without the specific written consent of 
|                 Texas Instruments Deutschland, AG. 
+----------------------------------------------------------------------------- 
|  Purpose :  This Modul contains the TR driver
+----------------------------------------------------------------------------- 
*/ 

#ifndef __TR_C__
#define __TR_C__
#endif

#include "string.h"
#include "typedefs.h"
#include "gdi.h"
#include "vsi.h"
#include "os.h"
#ifdef _TOOLS_
  #include <stdio.h>
  #include "glob_defs.h"
  #include "tstdriver.h"
  #include "frame.h"
  #include "frame_const.h"
  #include "printtofile.h"
#endif /* _TOOLS_ */
#include "tstheader.h"
#include "tst_mux.h"


/*==== TYPES ======================================================*/

typedef struct
{
  T_VOID_STRUCT *RcvBuffer;
  USHORT Handle;
  USHORT EnabledSignalType;
  T_DRV_CB_FUNC Callback;
  USHORT config;
  UBYTE rcv_state;
  UBYTE idle_state;
} T_TR_DATA;


/*==== CONSTANTS ==================================================*/

#define ALLOWED_TR_SIGNALS   (DRV_SIGTYPE_READ|DRV_SIGTYPE_CONNECT|DRV_SIGTYPE_DISCONNECT) 

#define STX                 0x02
#define TI_RIV_ID           0x11
#define TI_L1_ID            0x12
#define TI_L23_ID           0x13
#define TI_STX              0x02
#define TI_ESC              0x10
#define CHAR_ABORT          'A'

#define DATA_SEGMENT_SIZE   223

#define WAIT_FOR_STX        0
#define WAIT_FOR_IDENT      1
#define WAIT_FOR_TIMESTAMP  2
#define WAIT_FOR_LENGTH     3
#define WAIT_FOR_SND        4
#define WAIT_FOR_RCV        5
#define WAIT_FOR_DATA       6
#define WAIT_FOR_CR         7
#define WAIT_FOR_TI_ID      8
#define WAIT_FOR_TI_LEN_0   9
#define WAIT_FOR_TI_LEN_1  10
#define WAIT_FOR_TI_LEN_2  11
#define WAIT_FOR_LENGTH1   12
#define WAIT_FOR_LENGTH2   13
#define WAIT_FOR_RAW_TI_S  14
#define WAIT_FOR_RAW_TI_ID 15
#define WAIT_FOR_RAW_TI_E  16

#define WAIT_FOR_MUX_START_STX  1
#define WAIT_FOR_MUX_CHAN_ID    2
#define WAIT_FOR_MUX_END_STX    3

#define STX_LF_MODE       0x0001
#define TI_TRC_MODE       0x0002
#define TI_RAW_TRC_MODE   0x0004

/*==== EXTERNALS ==================================================*/

extern ULONG TR_RcvBufferSize;
extern ULONG TR_MaxInd;
extern USHORT ext_data_pool_handle;
extern T_TST_MUX_CHANNEL tst_mux_chan_struct[];

/*==== VARIABLES ==================================================*/

#ifndef RUN_INT_RAM
#ifndef _TARGET_
long int accessNum = 0;
#endif
T_TR_DATA TR_Data;
static char *TR_RcvBuffer;
static ULONG TR_EndInd;
static ULONG TR_WrInd;
static ULONG TR_RdInd;
static ULONG MessageLength;
static union {
    unsigned short int val;
    char part[2];
}tst_trailer_size;
#else
extern T_TR_DATA TR_Data;
#endif

#ifdef _TOOLS_
static int ti_id_not_found;
static int ti_esc_skipped;
extern int tst_message_received;
#else
extern ULONG MaxPrimPartSize;
#endif

/*==== FUNCTIONS ==================================================*/

#ifndef RUN_INT_RAM
USHORT TR_Write ( void *Buffer, ULONG *BytesToWrite ); 
#endif

#ifndef RUN_INT_RAM
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415)           MODULE  : TR                  |
| STATE   : code                       ROUTINE : TR_Exit             |
+--------------------------------------------------------------------+

  PURPOSE : exit a driver

*/
LOCAL void TR_Exit ( void )
{
  os_DeallocateMemory ( 0, TR_Data.RcvBuffer );
}
#endif

#ifndef RUN_INT_RAM
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415)           MODULE  : TR                  |
| STATE   : code                       ROUTINE : TR_Read             |
+--------------------------------------------------------------------+

  PURPOSE : read data from driver

*/
LOCAL USHORT TR_Read ( void *Buffer, ULONG *BytesToRead )
{
ULONG Space = TR_EndInd - (TR_RdInd & TR_MaxInd);
static ULONG bytes_read;

  if ( *BytesToRead == 0 )
  {
    *BytesToRead = MessageLength;
    bytes_read = 0;
  }
  else
  {
    if ( Space > *BytesToRead ) 
    {
      memcpy ( Buffer, &TR_RcvBuffer[TR_RdInd&TR_MaxInd], *BytesToRead );
      bytes_read += *BytesToRead;
    }
    else
    {
      memcpy ( Buffer, &TR_RcvBuffer[TR_RdInd&TR_MaxInd], (unsigned int)Space );
      *BytesToRead = Space;
      bytes_read += Space;
    }
    TR_RdInd += *BytesToRead;
    if ( TR_Data.config & STX_LF_MODE )
      if ( bytes_read == MessageLength )
        TR_RdInd++;  /* skip th LF, its not read by the TIF driver */
  }
  return DRV_OK;
}
#endif

#ifndef RUN_INT_RAM
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415)           MODULE  : TR                  |
| STATE   : code                       ROUTINE : TR_Write            |
+--------------------------------------------------------------------+

  PURPOSE : write data to driver

*/
USHORT TR_Write ( void *Buffer, ULONG *BytesToWrite )
{
char *snd_ptr = (char*)Buffer;
ULONG btw;
char ti_mode_header[2];

ti_mode_header[0] = TI_STX;
ti_mode_header[1] = TI_L23_ID;

#ifdef _TOOLS_
btw=(*BytesToWrite) & ~PRIM_FLAG_MASK;
#else
btw=(*BytesToWrite);
#endif

#ifdef _TOOLS_
  if (TR_Data.config & TI_RAW_TRC_MODE)
  {
    ULONG full_btw, segment_size;
    /*lint -e813, suppress Info 813: auto variable 'osver' has size '148' */ 
    char segment[DATA_SEGMENT_SIZE*2+3];
    /*lint +e813 */
    ULONG q;

    full_btw=btw;
    while (full_btw)
    {
      btw= (full_btw>DATA_SEGMENT_SIZE) ? DATA_SEGMENT_SIZE : full_btw;

      /* fill in leading bytes */
      segment_size=0;
      segment[segment_size++]=TI_STX;
      segment[segment_size++]=TI_L23_ID;

      /* fill in payload bytes */
      for (q=0; q<btw; q++)
      {
        /* evtl insert TI_ESC characters */
        if (snd_ptr[q]==TI_STX || snd_ptr[q]==TI_ESC)
        {
          segment[segment_size++]=TI_ESC;
        }
        segment[segment_size++]=snd_ptr[q];
      }

      /* fill in trailing bytes */
      segment[segment_size++]=TI_STX;

      /* write segment */
      if ( vsi_d_write ( TR_Data.Handle, 0, (void*)segment, segment_size) != VSI_OK )
      {
        return DRV_INTERNAL_ERROR;
      }

      full_btw=full_btw-btw;
      if (full_btw)
      {
        snd_ptr=snd_ptr+btw;

        /* let the ti driver on target handle the byte-block */
        vsi_t_sleep ( 0, 100 );
      }
    }

    return DRV_OK;
  }
#endif /* _TOOLS_ */

  /*
   * To avoid reallocation and memcpy() the STX is written in front of the passed 
   * data. This works as long as the sizeof(T_SYST_HEADER) is bigger than the header
   * sent via the test interface.
   */
  if ( TR_Data.config & STX_LF_MODE )
  {
    btw=(*BytesToWrite) & ~PRIM_FLAG_MASK;          /* not really generic, but we need to mask here */
                                                    /* we assume that the TITRC driver is not below */
    if ( *BytesToWrite & PRIM_DATA_FLAG )           /* primitive data -> LF at the end */
    {
      *(snd_ptr+btw) = '\n';
      btw = btw + 1;
    }
    else if ( *BytesToWrite & PRIM_HEADER_FLAG )    /* primitive header -> add STX in front */
    {
      snd_ptr--;                                    /* it is posible to add STX because the first */
      *snd_ptr = STX;                               /* byte of TST_SMALL_HEADER/TST_BIG_HEADER in unused */
      btw = btw + 1;
    }
    else                                            /* trace -> STX in front, LF at the end */
    {
      *(snd_ptr+btw) = '\n';
      snd_ptr--;
      *snd_ptr = STX;
      btw = btw + 2;
    }
  }

  /* Add mux STX and channel id if not already in */
  if (TR_Data.config & TI_RAW_TRC_MODE && *snd_ptr != TI_STX )
  {
    if ( vsi_d_write ( TR_Data.Handle, 0, (void*)ti_mode_header, 2) != VSI_OK )
    {
      return DRV_INTERNAL_ERROR;
    }
  }

  if ( vsi_d_write ( TR_Data.Handle, 0, (void*)snd_ptr, btw) != VSI_OK )
  {
    return DRV_INTERNAL_ERROR;
  }
 
  return DRV_OK;
}
#endif

#ifndef RUN_INT_RAM
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415)           MODULE  : TR                  |
| STATE   : code                       ROUTINE : TR_SetSignal        |
+--------------------------------------------------------------------+

  PURPOSE : enable signal for the driver

*/
LOCAL USHORT TR_SetSignal ( USHORT SignalType )
{
  if ( !(SignalType & ALLOWED_TR_SIGNALS) )
    return DRV_INVALID_PARAMS;
  else
    TR_Data.EnabledSignalType |= SignalType;
  
  return DRV_OK;
}
#endif

#ifndef RUN_INT_RAM
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415)           MODULE  : TR                  |
| STATE   : code                       ROUTINE : TR_ResetSignal      |
+--------------------------------------------------------------------+

  PURPOSE : disable signal for the driver

*/
LOCAL USHORT TR_ResetSignal ( USHORT SignalType )
{
  if ( !(SignalType & ALLOWED_TR_SIGNALS) )
    return DRV_INVALID_PARAMS;
  else
    TR_Data.EnabledSignalType &= ~SignalType;
  
  return DRV_OK;
}
#endif

#ifndef RUN_INT_RAM
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415)           MODULE  : TR                  |
| STATE   : code                       ROUTINE : TR_SetConfig        |
+--------------------------------------------------------------------+

  PURPOSE : set configuration for the driver

*/
LOCAL USHORT TR_SetConfig ( char *Buffer )
{
  if ( !strcmp ( TR_STX_LF, Buffer ) )
  {
    TR_Data.config = STX_LF_MODE;
    TR_Data.rcv_state = WAIT_FOR_STX;
    TR_Data.idle_state = WAIT_FOR_STX;
#ifdef _TOOLS_
    printf ("TR: STX mode enabled\n");
#endif /* _TOOLS_ */
    return DRV_OK;
  }
#ifdef _TOOLS_
  else if ( !strcmp ( DRV_TI_MODE, Buffer ) )
  {
    TR_Data.config = TI_TRC_MODE;
    TR_Data.rcv_state = WAIT_FOR_TI_ID;
    TR_Data.idle_state = WAIT_FOR_TI_ID;
    printf ("TR: TI mode enabled\n");
    return DRV_OK;
  }
#endif /* _TOOLS_ */
  else if ( !strcmp ( DRV_RAW_TI_MODE, Buffer ) )
  {
    TR_Data.config = TI_RAW_TRC_MODE;
    TR_Data.rcv_state = WAIT_FOR_RAW_TI_S;
    TR_Data.idle_state = WAIT_FOR_RAW_TI_S;
#ifdef _TOOLS_
    printf ("TR: raw TI mode enabled\n");
#endif
    return DRV_OK;
  }
  else if ( !strcmp ( DRV_DEFAULT, Buffer ) )
  {
    TR_Data.config = 0;
    TR_Data.rcv_state = WAIT_FOR_IDENT;
    TR_Data.idle_state = WAIT_FOR_IDENT;
#ifdef _TOOLS_
    accessNum++;
    PrintToFile("TR: default mode selected __________________________ (%d)\n", accessNum);
#endif /* _TOOLS_ */
    return DRV_OK;
  }
  else
    return DRV_INVALID_PARAMS;
}
#endif

#ifndef RUN_INT_RAM
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415)           MODULE  : TR                  |
| STATE   : code                       ROUTINE : Callback            |
+--------------------------------------------------------------------+

  PURPOSE : callback function of the driver

*/
/*lint -esym(644,infoByteAddr) suppress warning -- Symbol 'infoByteAddr' may not have been initialized */
LOCAL void TR_Callback ( T_DRV_SIGNAL *Signal )
{
static T_DRV_SIGNAL TR_Signal;
static USHORT  counter   = 0;
static char* infoByteAddr;
int tr_abort_discard;
int tr_abort;
unsigned char           c;
ULONG          i;
ULONG BytesToRead;
ULONG BytesRead = 0;
ULONG TR_WorkInd;
ULONG Bytes = 0;
USHORT continue_read;
//#ifdef _TOOLS_
static unsigned int ti_len = 0;
static char ti_id = 0;
static int sigtype = 0;
static int lf_found;
static int crlf_found;
static U8 mux_chan_id;
static U8 mux_chan = 0;
static U8 mux_status = WAIT_FOR_MUX_CHAN_ID;
static int stuffed_byte;
//#endif
  
  tr_abort_discard = 0;
  tr_abort = 0;
  TR_Signal.SignalType = 0;
  switch ( Signal->SignalType )
  {
    case DRV_SIGTYPE_READ:
      BytesToRead = TR_EndInd - TR_WrInd;
      TR_WorkInd = TR_WrInd;

      do
      {
        Bytes = 0;
        do 
        {
          continue_read = 0;
          /*
           * write counter must not overtake the read counter. If more bytes to be read
           * than space available, then process the bytes in the buffer first and then
           * continue to store new data in the TR_RcvBuffer.
           */
          if ( TR_WrInd >= (TR_RdInd&TR_MaxInd) )
            BytesToRead = TR_EndInd - TR_WrInd;
          else
            BytesToRead = (TR_RdInd&TR_MaxInd) - TR_WrInd; 
          BytesRead = BytesToRead;
          vsi_d_read ( TR_Data.Handle, 0, (void*)&TR_RcvBuffer[TR_WrInd], &BytesRead ); 
          Bytes += BytesRead;
          if ( BytesRead < BytesToRead )
          {
            TR_WrInd += BytesRead;
          }
          else 
          {
            if ( TR_WrInd >= (TR_RdInd&TR_MaxInd) )
              TR_WrInd = 0;
            else
            {
              TR_WrInd += BytesRead;
              continue_read = 1;
              break;
            }
          }
        } while ( BytesRead != TR_RcvBufferSize && BytesRead == BytesToRead );

        if ( Bytes )
        {
          UBYTE cMasked;

          i=0;

          while (i++ < Bytes)
          {
            c = TR_RcvBuffer[(TR_WorkInd++) & TR_MaxInd];

#ifdef _TOOLS_
            if (TR_Data.config & TI_RAW_TRC_MODE) /* we are receiving rawly in TI mode */
            {
              if (!ti_esc_skipped && c==TI_ESC)
              {
                /* the TI driver has inserted an TI_ESC -> skip it */
                ULONG q;
                for (q=TR_WorkInd-1; q>TR_RdInd; q--)
                {
                  TR_RcvBuffer[q & TR_MaxInd]=TR_RcvBuffer[(q-1) & TR_MaxInd];
                }
                TR_RdInd++;
                ti_esc_skipped=1;
                continue;
              }
              ti_esc_skipped=0;
            }
#endif /* _TOOLS_ */

            if ( tr_abort_discard == 1 )
            {
              TR_RdInd++;
              continue;
            }
            switch (TR_Data.rcv_state)
            {
              case WAIT_FOR_STX:
                if (c == STX)
                {
#ifdef _TOOLS_ 
                  ti_len=0;
#endif 
                  TR_Data.rcv_state = WAIT_FOR_IDENT;
                  TR_RdInd = TR_WorkInd;                   /* do not pass the STX to TIF */
                }
                else
                  TR_RdInd++;
                break;
//#ifdef _TOOLS_
              case WAIT_FOR_RAW_TI_S:
                if (c==TI_STX)
                {
                  TR_Data.rcv_state=WAIT_FOR_RAW_TI_ID;
                  TR_RdInd = TR_WorkInd;  /* do not read TI_STX */
                }
                break;
              case WAIT_FOR_RAW_TI_ID:
                if (c==TI_STX)
                {
                  // last TI_STX was end ID -> ignore this start ID
                }
                else if (c==TI_L23_ID)
                {
                  ti_len = 0;
                  ti_id = c;
                  TR_Data.rcv_state=WAIT_FOR_IDENT;
                }
                else if (c == TI_L1_ID || c == TI_RIV_ID)
                {
                  ti_len = 0;
                  ti_id = c;

                  if (ti_id == TI_L1_ID)
                    sigtype = DRV_SIGTYPE_READ_L1;
                  if (ti_id == TI_RIV_ID)
                    sigtype = DRV_SIGTYPE_READ_RIV;

                  counter = 0;
                  TR_RdInd = TR_WorkInd;  /* do not read ti_id */
                  crlf_found = 0;
                  lf_found = 0;
                  TR_Data.rcv_state=WAIT_FOR_RAW_TI_E;
                }
                else
                {
                  mux_chan_id = c;
                  if ( mux_status == WAIT_FOR_MUX_CHAN_ID )
                  {
                    for ( mux_chan = 0; mux_chan < MAX_TST_CHANNEL; mux_chan++ )
                    {
                      if ( tst_mux_chan_struct[mux_chan].channel_id == c )
                      {
                        mux_status = WAIT_FOR_MUX_END_STX;
                        tst_mux_chan_struct[mux_chan].rcv_data_ptr  = &TR_RcvBuffer[(TR_WorkInd) & TR_MaxInd];
                        tst_mux_chan_struct[mux_chan].rcv_data_size = 0;
                        stuffed_byte = 0;
                        TR_RdInd = TR_WorkInd;  /* do not read id */
                        TR_Data.rcv_state=WAIT_FOR_RAW_TI_E;
                        break;
                      }
                    }
                  }
                }
                break;
#ifdef _TOOLS_
              case WAIT_FOR_TI_ID:
                                      /* skip TI ID byte */
                if (c == TI_L23_ID || c == TI_L1_ID || c == TI_RIV_ID)
                {
                  ti_len = 0;
                  ti_id = c;
                  TR_Data.rcv_state = WAIT_FOR_TI_LEN_0;
                }
                else
                {
                  ti_id_not_found = 1;
                }
                break;
              case WAIT_FOR_TI_LEN_0:
                                      /* 
                 * skip length
                 * if length byte == 0 then the next 2 bytes are the length
                 * (patch to handle messages longer than 255 bytes)
                 */
                if ( c != 0 )
                {
                  if (ti_id == TI_L23_ID)
                    TR_Data.rcv_state = WAIT_FOR_IDENT;

                  if (ti_id == TI_L1_ID || ti_id == TI_RIV_ID)
                  {
                    if (ti_id == TI_L1_ID)
                      sigtype = DRV_SIGTYPE_READ_L1;
                    if (ti_id == TI_RIV_ID)
                      sigtype = DRV_SIGTYPE_READ_RIV;

                    TR_Data.rcv_state = WAIT_FOR_DATA;
                    counter = 0;
                    TR_RdInd += 2;  /* do not read ti_id and length */
                    crlf_found = 0;
                    lf_found = 0;
                  }
                  ti_len = c & 0xff;
                }
                else
                  TR_Data.rcv_state = WAIT_FOR_TI_LEN_1;

                break;
              case WAIT_FOR_TI_LEN_1:
                ti_len = c ;
                TR_Data.rcv_state = WAIT_FOR_TI_LEN_2;
                break;
              case WAIT_FOR_TI_LEN_2:
                ti_len |= c << 8;
                TR_Data.rcv_state = WAIT_FOR_IDENT;
                break;
#endif /* ifdef _TOOLS_ */

              case WAIT_FOR_IDENT:
                infoByteAddr = &TR_RcvBuffer[(TR_WorkInd - 1) & TR_MaxInd];
                /* analyze INFO  Byte */
                cMasked = (c &  HDR_VERSION_MASK);
#ifdef _TOOLS_
                if (cMasked == HDR_VALID_VERSION_0) 
                {
                  i--; TR_WorkInd--;
                  printf ("TR: changed to OLD header format automatically\n");
//                    tst_drv_write ( NO_TASK, SYS_MASK, FRM_TST_NAME, (char*)SYSPRIM_GET_STACK_TIME );
                  break;
                }
                /* check for lost bytes on interface */
                if (TR_Data.config & TI_TRC_MODE ||
                    TR_Data.config & TI_RAW_TRC_MODE) /* we are receiving from a arm 7 TARGET */
                { /* TR_WorkInd refs position of first size byte now */
                  if (ti_id_not_found) 
                  {
                    *infoByteAddr = (( *infoByteAddr & ~HDR_IDENT_MASK) | IDENT_ABORT); /* mark as bad */
                  }
                }
#endif /* ifdef _TOOLS_ */
                cMasked = (c &  HDR_IDENT_MASK);
                if (((cMasked == IDENT_PS_PRIM) || (cMasked == IDENT_SYS_PRIM) ||
                    (cMasked == IDENT_ABORT)   || (cMasked == IDENT_TRACE))
                    &&
                    ((c != PROT_PRIM_ID) && (c != PROT_PRIM_ID_32BIT) &&
                     (c != SYS_PRIM_ID) && (c != TRACE_ID))
                    )
                {
                  /* Hey fine, everything went OK! */
                  TR_Data.rcv_state = WAIT_FOR_LENGTH1;
                }
                else
                { /* we have to fake a length for abort trace */
                  tst_trailer_size.part[0] = TST_HEADER_LEADING_FIELDS;
                  tst_trailer_size.part[1] = 0; 
                  MessageLength = tst_trailer_size.val + TST_HEADER_TRAILING_FIELDS;

                  *infoByteAddr = (( *infoByteAddr & ~HDR_IDENT_MASK) | IDENT_ABORT); /* mark as bad */
                  counter = tst_trailer_size.val; /* don't let us read all the following bytes before let TIF tracing ABORT */
                  TR_Data.rcv_state = WAIT_FOR_DATA;
                  tr_abort = 1;
                }
                TR_RdInd = TR_WorkInd - 1; /* skip all preceeding interface sync bytes before triggering TIF */
                break;
              case WAIT_FOR_LENGTH1:       
                  /* the use of the union does rely on identical byte sex! */
#ifdef _SOLARIS_
                  /* temporary hack */
                  tst_trailer_size.part[1] = c;
#else
                  tst_trailer_size.part[0] = c;
#endif
                  TR_Data.rcv_state = WAIT_FOR_LENGTH2;
                  break;
              case WAIT_FOR_LENGTH2:       
#ifdef _SOLARIS_
                  /* temporary hack */
                  tst_trailer_size.part[0] = c;
#else
                  tst_trailer_size.part[1] = c;
#endif
                  /* Bytes after size + bytes till size (inclusive) */
                  MessageLength = tst_trailer_size.val + TST_HEADER_LEADING_FIELDS;
#ifdef _TOOLS_
                  /* In case of a lost character the two length information elements mismatch. */
                  if ( (ti_len != 0) && (tst_trailer_size.val != (ti_len - 3)) )
                  {
                    tst_trailer_size.val = ti_len - 3;
                  }
                  ti_len = 0;
                  if ((tst_trailer_size.val - TST_HEADER_TRAILING_FIELDS) > (unsigned short int)(MAX_PRIM_PARTITION_SIZE - sizeof(T_PRIM_HEADER) - sizeof(T_S_HEADER)))
                  {
                    *infoByteAddr = (( *infoByteAddr & ~HDR_IDENT_MASK) | IDENT_ABORT); /* mark as bad */
                    tst_trailer_size.val = (MAX_PRIM_PARTITION_SIZE - sizeof(T_PRIM_HEADER) - sizeof(T_S_HEADER) -TST_HEADER_TRAILING_FIELDS);
                    counter = tst_trailer_size.val; /* don't let us read all the following bytes before let TIF tracing ABORT */
                    tr_abort = 1;
                  }
#else
                  if ((tst_trailer_size.val - TST_HEADER_TRAILING_FIELDS) > (unsigned short int)(MaxPrimPartSize - sizeof(T_PRIM_HEADER) - sizeof(T_S_HEADER)))
                  {
                    *infoByteAddr = (( *infoByteAddr & ~HDR_IDENT_MASK) | IDENT_ABORT); /* mark as bad */
                    tst_trailer_size.val = (USHORT)(MaxPrimPartSize - sizeof(T_PRIM_HEADER) - sizeof(T_S_HEADER) -TST_HEADER_TRAILING_FIELDS);
                    counter = tst_trailer_size.val; /* don't let us read all the following bytes before let TIF tracing ABORT */
                    tr_abort = 1;
                  }
#endif
                  TR_Data.rcv_state = WAIT_FOR_DATA;
                  counter = 0;
                  break;
              case WAIT_FOR_RAW_TI_E:
                if ( mux_status == WAIT_FOR_MUX_END_STX )
                {
                  if ( stuffed_byte )
                  {
                    stuffed_byte = 0;
                    tst_mux_chan_struct[mux_chan].rcv_data_size++;
                  }
                  else
                  {
                    if ( c != TI_STX )
                    {
                      if ( c == 0x10 )
                      {
                        stuffed_byte = 1;
                      }
                      tst_mux_chan_struct[mux_chan].rcv_data_size++;
                    }
                    else
                    {
                      tst_mux_callback (mux_chan,tst_mux_chan_struct[mux_chan].rcv_data_ptr, tst_mux_chan_struct[mux_chan].rcv_data_size);
                      mux_status = WAIT_FOR_MUX_CHAN_ID;
                      MessageLength = tst_mux_chan_struct[mux_chan].rcv_data_size;
                      TR_Data.rcv_state = WAIT_FOR_RAW_TI_S;
                    }
                  }
                }
#ifdef _TOOLS_
                if (c!=TI_STX)
                {
                  if ( counter == 0 && c == 0x0a )
                  {
                    lf_found = 1;
                  }
                  if ( lf_found && counter == 1 && c == 0x0d)
                  {
                    crlf_found = 1;
                  }
                  counter++;
                }
                else
                {
                  if ( TR_Data.EnabledSignalType & DRV_SIGTYPE_READ )
                  {
                    ti_len=counter;
                    if ( crlf_found == 1 )
                    {
                      ti_len -= 2;
                      TR_RdInd += 2;  /* do not read CR and LF at the beginning */
                    }
                    MessageLength = ti_len;
                    TR_Signal.SignalType = sigtype;
                    TR_Signal.DrvHandle = TR_Data.Handle;
                    (TR_Data.Callback)( &TR_Signal );
                  }
                  TR_Data.rcv_state = TR_Data.idle_state;
                }
#endif
                break;
              case WAIT_FOR_DATA:       
#ifdef _TOOLS_
                if ( ti_len )
                { 
                  if ( counter == 0 && c == 0x0a )
                  {
                    lf_found = 1;
                  }
                  if ( lf_found && counter == 1 && c == 0x0d)
                  {
                    crlf_found = 1;
                  }
                  if ( ++counter >= ti_len )
                  {
                    if ( TR_Data.EnabledSignalType & DRV_SIGTYPE_READ )
                    {
                      if ( crlf_found == 1 )
                      {
                        ti_len -= 2;
                        TR_RdInd += 2;  /* do not read CR and LF at the beginning */
                      }
                      MessageLength = ti_len;
                      TR_Signal.SignalType = sigtype;
                      TR_Signal.DrvHandle = TR_Data.Handle;
                      (TR_Data.Callback)( &TR_Signal );
                    }
                    TR_Data.rcv_state = TR_Data.idle_state;
                  }
                  break;
                }
#endif                  
                if (++counter >= tst_trailer_size.val) /* If all went OK up to now we have to read all remaining bytes from the buffer each for each */
                {
                  if (TR_Data.config & STX_LF_MODE )
                  {
                    TR_Data.rcv_state = WAIT_FOR_CR;
                    break;
                  }
                  else
                  {
                    if ( TR_Data.EnabledSignalType & DRV_SIGTYPE_READ )
                    {
#ifdef _TOOLS_
                      tst_message_received = 1;
#endif
                      TR_Signal.SignalType = DRV_SIGTYPE_READ;
                      TR_Signal.DrvHandle = TR_Data.Handle;
                      (TR_Data.Callback)( &TR_Signal );
                    }
                    TR_Data.rcv_state = TR_Data.idle_state;
                    tst_trailer_size.val = 0;
                    if ( tr_abort == 1 ) /* marked as bad */
                      tr_abort_discard = 1;
#ifdef _TOOLS_
                    ti_id_not_found = 0;
#endif
                  }
                }
                break;
              case WAIT_FOR_CR:
#ifdef _TOOLS_     /* check for lost bytes on interface */
                if (TR_Data.config & STX_LF_MODE )  /* we are receiving from a arm 9 TARGET or Windows stack configured stx */
                {
                  if (c != '\n') 
                  {
                    *infoByteAddr = (( *infoByteAddr & ~HDR_IDENT_MASK) | IDENT_ABORT); /* mark as bad */
                  }
                }
#endif /* _TOOLS_ check for lost bytes on interface */
                if ( TR_Data.EnabledSignalType & DRV_SIGTYPE_READ )
                {
#ifdef _TOOLS_
                  tst_message_received = 1;
#endif
                  TR_Signal.SignalType = DRV_SIGTYPE_READ;
                  TR_Signal.DrvHandle = TR_Data.Handle;
                  (TR_Data.Callback)( &TR_Signal );
                }
                TR_Data.rcv_state = TR_Data.idle_state;
                tst_trailer_size.val = 0;
                if ( tr_abort == 1 ) /* marked as bad */
                  tr_abort_discard = 1;
                break;
              default:
                break; 
            }
          } /*  while (i++ < Bytes) */
        } /* if Bytes loop */
      } while ( continue_read == 1 );
    break;
    case DRV_SIGTYPE_CONNECT:
    case DRV_SIGTYPE_DISCONNECT:
      if ( TR_Data.EnabledSignalType & Signal->SignalType )
      {
        TR_Signal.SignalType = Signal->SignalType;
        TR_Signal.DrvHandle = TR_Data.Handle;
        (TR_Data.Callback)( &TR_Signal );
      }
    break;
    default: 
    break;
  }
}
#endif

#ifndef RUN_INT_RAM
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415)           MODULE  : TR                  |
| STATE   : code                       ROUTINE : TR_Init             |
+--------------------------------------------------------------------+

  PURPOSE : initialize driver

*/
USHORT TR_Init ( USHORT DrvHandle, T_DRV_CB_FUNC CallbackFunc, T_DRV_EXPORT const **DrvInfo )
{                
USHORT j;
ULONG size = 0;
static const T_DRV_EXPORT TR_Info =
{
  "TR",
  0,
  {
#ifdef _TOOLS_
    TR_Init,
#endif
    TR_Exit,
    TR_Read,
    TR_Write,
    NULL,
    NULL,
    NULL,
    TR_SetSignal,
    TR_ResetSignal,
    TR_SetConfig,
    NULL,
    TR_Callback,
  }
};

  TR_Data.Handle = DrvHandle;

  TR_Data.EnabledSignalType = 0;

  TR_Data.config = 0;

  TR_Data.rcv_state = WAIT_FOR_IDENT;

  TR_Data.idle_state = WAIT_FOR_IDENT;

  TR_Data.Callback = CallbackFunc;

  *DrvInfo = &TR_Info;

  /* 
   * TR_RcvBufferSize must be a power of 2 for proper wrap-around
   */
#ifndef _TOOLS_
  TR_RcvBufferSize = MaxPrimPartSize;
#endif
  j = 0;
  do
  {
    if ( (ULONG)(1 << j) >= TR_RcvBufferSize )  /* Size must be a power of 2 */
    {
      size = 1 << j;
      break;
    }
    else
      j++;
  } while ( size < 0xffff );

  TR_RcvBufferSize = size;
  TR_MaxInd = TR_RcvBufferSize - 1;

  if ( os_AllocateMemory ( NO_TASK, &TR_Data.RcvBuffer, (ULONG)TR_RcvBufferSize,
                           OS_NO_SUSPEND, ext_data_pool_handle ) != OS_OK )
  {
      vsi_o_assert ( NO_TASK, OS_SYST_ERR_NO_MEMORY, __FILE__, __LINE__,
                     "No memory available in TR driver, TR_RcvBufferSize = %d",
                     TR_RcvBufferSize );
    return DRV_INITFAILURE;
  }

  TR_RcvBuffer = (char*)TR_Data.RcvBuffer;
  TR_EndInd = TR_RcvBufferSize;
  TR_WrInd = 0;
  TR_RdInd = 0;
  tst_trailer_size.val = 0;
#ifdef _TOOLS_
  ti_id_not_found = 0;
  ti_esc_skipped = 0;
#endif

  return DRV_OK;           
}
#endif