--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gpf/tst/DRV/tr2.c	Mon Jun 01 03:24:05 2015 +0000
@@ -0,0 +1,1005 @@
+/* 
++------------------------------------------------------------------------------
+|  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