+
−/*
+
−+-----------------------------------------------------------------------------
+
−|  Project :
+
−|  Modul   :
+
−+-----------------------------------------------------------------------------
+
−|  Copyright 2002 Texas Instruments Berlin, 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 Berlin, AG.
+
−+-----------------------------------------------------------------------------
+
−|  Purpose :  This modul is part of the entity UART and implements all
+
−|             functions to handles the incoming process internal signals as
+
−|             described in the SDL-documentation (DTX-statemachine)
+
−+-----------------------------------------------------------------------------
+
−*/
+
−
+
−#ifndef UART_DTXS_C
+
−#define UART_DTXS_C
+
−#endif /* !UART_DTXS_C */
+
−
+
−#define ENTITY_UART
+
−
+
−/*==== INCLUDES =============================================================*/
+
−
+
−#ifdef _SIMULATION_
+
−#include <stdio.h>
+
−#endif
+
−#ifdef WIN32
+
−#include "nucleus.h"
+
−#endif /* WIN32 */
+
−#include "typedefs.h"   /* to get Condat data types */
+
−#include "vsi.h"        /* to get a lot of macros */
+
−#include "macdef.h"     /* to get a lot of macros */
+
−#include "custom.h"
+
−#include "gsm.h"        /* to get a lot of macros */
+
−#include "cnf_uart.h"   /* to get cnf-definitions */
+
−#include "mon_uart.h"   /* to get mon-definitions */
+
−#include "prim.h"       /* to get the definitions of used SAP and directions */
+
−#include "dti.h"        /* to get dti lib */
+
−#include "pei.h"        /* to get PEI interface */
+
−#ifdef FF_MULTI_PORT
+
−#include "gsi.h"        /* to get definitions of serial driver */
+
−#else /* FF_MULTI_PORT */
+
−#ifdef _TARGET_
+
−#include "uart/serialswitch.h"
+
−#include "uart/traceswitch.h"
+
−#else /* _TARGET_ */
+
−#include "serial_dat.h" /* to get definitions of serial driver */
+
−#endif /* _TARGET_ */
+
−#endif /* FF_MULTI_PORT */
+
−#include "uart.h"       /* to get the global entity definitions */
+
−
+
−#include "uart_dtxf.h"  /* to get DTX function definitions */
+
−#include "uart_dtxp.h"  /* to get DTX primitive definitions */
+
−#include "uart_kers.h"  /* to get KER signal definitions */
+
−#include "uart_rts.h"   /* to get RT  signal definitions */
+
−#ifdef FF_MULTI_PORT
+
−#include "uart_prxs.h"  /* to get signal definitions for service TX */
+
−#else /* FF_MULTI_PORT */
+
−#include "uart_rxs.h"   /* to get TX signal definitions */
+
−#endif /* FF_MULTI_PORT */
+
−#include <string.h>    /* JK, delete warnings: to get memmove, memcpy */
+
−
+
−/*==== CONST ================================================================*/
+
−
+
−/*==== LOCAL VARS ===========================================================*/
+
−
+
−/*==== PRIVATE FUNCTIONS ====================================================*/
+
−
+
−/*==== PUBLIC FUNCTIONS =====================================================*/
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_ker_dtx_ready_mode_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_KER_DTX_READY_MODE_REQ
+
−|
+
−| Parameters  : dlc_instance - dlc instance wich belongs to this DTX instance
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_ker_dtx_ready_mode_req (UBYTE dlc_instance)
+
−{
+
−  TRACE_ISIG( "sig_ker_dtx_ready_mode_req" );
+
−
+
−  uart_data->dtx->dlc_instance = dlc_instance;
+
−
+
−  switch( GET_STATE( UART_SERVICE_DTX ) )
+
−  {
+
−    case DTX_DEAD:
+
−      SET_STATE( UART_SERVICE_DTX, DTX_NOT_READY );
+
−
+
−      /*
+
−     * reset line states
+
−     */
+
−    uart_data->dtx->st_flow       = DTI_FLOW_ON;
+
−    uart_data->dtx->st_line_sa    = DTI_SA_ON;
+
−    uart_data->dtx->st_line_sb    = DTI_SB_ON;
+
−    uart_data->dtx->st_break_len  = DTI_BREAK_OFF;
+
−    uart_data->dtx->detect_escape = TRUE;
+
−
+
−      uart_data->dtx->data_flow = UART_FLOW_ENABLED;
+
−      if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING)
+
−      {
+
−        /*
+
−         * reset escape sequence detection
+
−         */
+
−        dtx_set_esd_state( UART_ESD_NULL );
+
−        uart_data->dtx->detect_escape = TRUE;
+
−        if(vsi_t_time (VSI_CALLER &(uart_data->dtx->esd_guard_time))
+
−                                                         NEQ VSI_OK)
+
−        {
+
−          TRACE_ERROR_P1("VSI entity: Can't restart timer, uart_dtxs.c(%d)",
+
−                                                                  __LINE__);
+
−        }
+
−        uart_data->dtx->esd_pos = 0;
+
−        /*
+
−         * start reception
+
−         */
+
−        dtx_allocate_resources();
+
−        sig_dtx_rx_ready_to_receive_req( uart_data->dtx->dlc_instance,
+
−                                         uart_data->dtx->to_send_data,
+
−                                         uart_data->dtx->write_pos,
+
−                                         uart_data->dtx->cur_desc_size );
+
−      }
+
−      break;
+
−
+
−    case DTX_READY:
+
−    case DTX_NOT_READY:
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "SIG_KER_DTX_READY_MODE_REQ unexpected" );
+
−      break;
+
−  }
+
−} /* sig_ker_dtx_ready_mode_req() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_ker_dtx_dead_mode_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_KER_DTX_DEAD_MODE_REQ
+
−|
+
−| Parameters  : none
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_ker_dtx_dead_mode_req ()
+
−{
+
−  TRACE_ISIG( "sig_ker_dtx_dead_mode_req" );
+
−
+
−  switch( GET_STATE( UART_SERVICE_DTX ) )
+
−  {
+
−    case DTX_READY:
+
−    case DTX_NOT_READY:
+
−      SET_STATE( UART_SERVICE_DTX, DTX_DEAD );
+
−      /*
+
−       * reset hComm_DTX_UPLINK and size_multiplier
+
−       */
+
−      uart_data->dtx->dti_dtx_state   = DTI_CLOSED;
+
−      uart_data->dtx->size_multiplier = 3;
+
−
+
−      if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING)
+
−      {
+
−        /*
+
−         * free recources and stop receiving
+
−         */
+
−        sig_dtx_rx_not_ready_to_receive_req(uart_data->dtx->dlc_instance);
+
−        dtx_free_resources();
+
−      }
+
−      else
+
−        uart_data->dtx->receiving_state = UART_DTX_INVALID;
+
−      break;
+
−
+
−    case DTX_DEAD:
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "SIG_KER_DTX_DEAD_MODE_REQ unexpected" );
+
−      break;
+
−  }
+
−} /* sig_ker_dtx_dead_mode_req() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_rx_dtx_receiving_ind
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_RX_DTX_RECEIVING_IND
+
−|
+
−| Parameters  : none
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_rx_dtx_receiving_ind ()
+
−{
+
−  TRACE_ISIG( "sig_rx_dtx_receiving_ind" );
+
−
+
−  uart_data->dtx->receiving_state = UART_DTX_RECEIVING;
+
−
+
−  switch( GET_STATE( UART_SERVICE_DTX ) )
+
−  {
+
−    case DTX_READY:
+
−    case DTX_NOT_READY:
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "SIG_RX_DTX_RECEIVING_IND unexpected" );
+
−      break;
+
−  }
+
−} /* sig_ker_dtx_receiving_ind() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_rx_dtx_data_received_ind
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_RX_DTX_DATA_RECEIVED_IND
+
−|
+
−| Parameters  : none
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_rx_dtx_data_received_ind (T_desc2* received_data,
+
−                                          USHORT  write_pos)
+
−{
+
−  T_DATA_FLOW_STATE old_data_flow;
+
−  T_desc2*          temp_desc;
+
−  USHORT            esd_pos;
+
−  T_TIME            cur_time;
+
−
+
−  TRACE_ISIG( "sig_rx_dtx_data_received_ind" );
+
−
+
−#ifdef UART_RANGE_CHECK
+
−  if(received_data EQ NULL)
+
−  {
+
−    TRACE_EVENT("ERROR: received_data is NULL");
+
−  }
+
−  else if((*((ULONG*)((UBYTE*)received_data - 8))) NEQ 0)
+
−  {
+
−    TRACE_EVENT_P1("ERROR: received_data=%08x is not allocated",
+
−                    received_data);
+
−  }
+
−  if(uart_data->dtx->to_send_data NEQ received_data)
+
−  {
+
−    TRACE_EVENT_P2("ERROR: to_send_data=%08x NEQ received_data=%08x",
+
−                    uart_data->dtx->to_send_data,
+
−                    received_data);
+
−  }
+
−  if(uart_data->dtx->to_send_data->len > uart_data->dtx->cur_desc_size)
+
−  {
+
−    TRACE_EVENT_P2("ERROR: to_send_data->len=%d > cur_desc_size=%d",
+
−                    uart_data->dtx->to_send_data->len,
+
−                    uart_data->dtx->cur_desc_size);
+
−  }
+
−  if(write_pos > uart_data->dtx->cur_desc_size)
+
−  {
+
−    TRACE_EVENT_P2("ERROR: write_pos=%d > cur_desc_size=%d",
+
−                    write_pos,
+
−                    uart_data->dtx->cur_desc_size);
+
−  }
+
−  if(uart_data->dtx->to_send_data->len > write_pos)
+
−  {
+
−    TRACE_EVENT_P2("ERROR: to_send_data->len=%d > write_pos=%d",
+
−                    uart_data->dtx->to_send_data->len,
+
−                    write_pos);
+
−  }
+
−  if(uart_data->dtx->esd_pos > write_pos)
+
−  {
+
−    TRACE_EVENT_P2("ERROR: esd_pos=%d > write_pos=%d",
+
−                    uart_data->dtx->esd_pos,
+
−                    write_pos);
+
−  }
+
−  switch(dtx_get_esd_state())
+
−  {
+
−    case UART_ESD_DETECTED:
+
−      if(uart_data->dtx->esd_pos < 3)
+
−      {
+
−        TRACE_EVENT_P1("ERROR: esd_pos=%d < 3 in UART_ESD_DETECTED state",
+
−                        uart_data->dtx->esd_pos);
+
−      }
+
−      break;
+
−    case UART_ESD_CHAR_1:
+
−      if(uart_data->dtx->esd_pos < 1)
+
−      {
+
−        TRACE_EVENT_P1("ERROR: esd_pos=%d < 1 in UART_ESD_CHAR_1 state",
+
−                        uart_data->dtx->esd_pos);
+
−      }
+
−      break;
+
−    case UART_ESD_CHAR_2:
+
−      if(uart_data->dtx->esd_pos < 2)
+
−      {
+
−        TRACE_EVENT_P1("ERROR: esd_pos=%d < 2 in UART_ESD_CHAR_2 state",
+
−                        uart_data->dtx->esd_pos);
+
−      }
+
−      break;
+
−    case UART_ESD_CHAR_3:
+
−      if(uart_data->dtx->esd_pos < 3)
+
−      {
+
−        TRACE_EVENT_P1("ERROR: esd_pos=%d < 3 in UART_ESD_CHAR_3 state",
+
−                        uart_data->dtx->esd_pos);
+
−      }
+
−      break;
+
−  }
+
−#endif /* UART_RANGE_CHECK */
+
−
+
−  /*
+
−   * store new write position,
+
−   * current data_flow state and
+
−   * current data descriptor
+
−   */
+
−  uart_data->dtx->write_pos = write_pos;
+
−  old_data_flow             = uart_data->dtx->data_flow;
+
−  temp_desc                 = received_data;
+
−
+
−  /*
+
−   * Introduce local variable here in order to prevent
+
−   * the target compiler from doing wrong calculations ...
+
−   */
+
−  esd_pos = uart_data->dtx->esd_pos;
+
−
+
−  /*
+
−   * escape sequence detection
+
−   */
+
−  if(uart_data->dtx->receiving_state EQ UART_DTX_RECEIVING &&
+
−     uart_data->dtx->detect_escape EQ TRUE)
+
−  {
+
−    if (vsi_t_time (VSI_CALLER &cur_time) EQ VSI_OK)
+
−    {
+
−      switch(dtx_get_esd_state())
+
−      {
+
−        case UART_ESD_DETECTED:
+
−          /*
+
−           * remove escape characters because escape sequence was detected
+
−           */
+
−          if(uart_data->dtx->write_pos > esd_pos)
+
−          {
+
−            memmove(&temp_desc->buffer[esd_pos - 3],
+
−                    &temp_desc->buffer[esd_pos],
+
−                    uart_data->dtx->write_pos - esd_pos);
+
−          }
+
−          uart_data->dtx->write_pos-= 3;
+
−          esd_pos -= 3;
+
−          uart_data->dtx->esd_pos = esd_pos;
+
−          dtx_set_esd_state( UART_ESD_NULL );
+
−          /* fall through */
+
−        case UART_ESD_NULL:
+
−#ifdef _SIMULATION_
+
−          TRACE_EVENT_P2("uart_data->act_gp: %d, silence: %d",
+
−                          uart_data->act_gp,
+
−                          (cur_time - uart_data->dtx->esd_guard_time));
+
−#endif /* _SIMULATION_ */
+
−          if(esd_pos >= temp_desc->len)
+
−            break;
+
−
+
−          if(((cur_time -
+
−               uart_data->dtx->esd_guard_time) < uart_data->act_gp) ||
+
−             (temp_desc->
+
−              buffer[esd_pos] NEQ uart_data->act_ec))
+
−          {
+
−            /*
+
−             * set new reference time and
+
−             * update esd_pos
+
−             */
+
−            esd_pos                        = temp_desc->len;
+
−            uart_data->dtx->esd_pos        = esd_pos;
+
−            uart_data->dtx->esd_guard_time = cur_time;
+
−            break;
+
−          }
+
−          /*
+
−           * first guard period complete and
+
−           * first escape character detected
+
−           */
+
−#ifdef _SIMULATION_
+
−          TRACE_EVENT("+ + + first guard period complete + + +");
+
−#endif /* _SIMULATION_ */
+
−          dtx_set_esd_state( UART_ESD_CHAR_1 );
+
−          esd_pos++;
+
−          uart_data->dtx->esd_pos        = esd_pos;
+
−          uart_data->dtx->esd_guard_time = cur_time;
+
−          sig_dtx_rt_start_tesd_req (uart_data->act_gp);
+
−          /* fall trough */
+
−        case UART_ESD_CHAR_1:
+
−          if(esd_pos >= temp_desc->len)
+
−          {
+
−            /*
+
−             * hide 1 character
+
−             */
+
−            temp_desc->len  = esd_pos - 1;
+
−            temp_desc->size = temp_desc->len;
+
−            break;
+
−          }
+
−
+
−          if(temp_desc->
+
−             buffer[esd_pos] NEQ uart_data->act_ec)
+
−          {
+
−            /*
+
−             * second character is not an escape character
+
−             */
+
−            dtx_set_esd_state( UART_ESD_NULL );
+
−            esd_pos                        = temp_desc->len;
+
−            uart_data->dtx->esd_pos        = esd_pos;
+
−            uart_data->dtx->esd_guard_time = cur_time;
+
−            break;
+
−          }
+
−          /*
+
−           * second escape character received
+
−           */
+
−          dtx_set_esd_state( UART_ESD_CHAR_2 );
+
−          esd_pos++;
+
−          uart_data->dtx->esd_pos = esd_pos;
+
−          /* fall trough */
+
−        case UART_ESD_CHAR_2:
+
−          if(esd_pos >= temp_desc->len)
+
−          {
+
−            /*
+
−             * hide 2 characters
+
−             */
+
−            temp_desc->len  = esd_pos - 2;
+
−            temp_desc->size = temp_desc->len;
+
−            break;
+
−          }
+
−          /*
+
−           * set new reference time
+
−           */
+
−          uart_data->dtx->esd_guard_time = cur_time;
+
−
+
−          if(temp_desc->
+
−             buffer[esd_pos] NEQ uart_data->act_ec)
+
−          {
+
−            /*
+
−             * third character is not an escape character
+
−             */
+
−            dtx_set_esd_state( UART_ESD_NULL );
+
−            esd_pos                 = temp_desc->len;
+
−            uart_data->dtx->esd_pos = esd_pos;
+
−            break;
+
−          }
+
−          /*
+
−           * third escape character received
+
−           */
+
−          dtx_set_esd_state( UART_ESD_CHAR_3 );
+
−          esd_pos++;
+
−          uart_data->dtx->esd_pos = esd_pos;
+
−          sig_dtx_rt_start_tesd_req (uart_data->act_gp);
+
−          /* fall trough */
+
−        case UART_ESD_CHAR_3:
+
−          if(esd_pos >= temp_desc->len)
+
−          {
+
−            /*
+
−             * hide 3 characters
+
−             */
+
−            temp_desc->len  = esd_pos - 3;
+
−            temp_desc->size = temp_desc->len;
+
−            break;
+
−          }
+
−          /*
+
−           * fourth character received
+
−           */
+
−          dtx_set_esd_state( UART_ESD_NULL );
+
−          esd_pos                        = temp_desc->len;
+
−          uart_data->dtx->esd_pos        = esd_pos;
+
−          uart_data->dtx->esd_guard_time = cur_time;
+
−          break;
+
−
+
−        default:
+
−          TRACE_ERROR("wrong esd state");
+
−          break;
+
−      }
+
−    }
+
−    else
+
−    {
+
−      TRACE_ERROR_P1("VSI entity: Can't restart timer, uart_dtxs.c(%d)",
+
−                                                              __LINE__);
+
−    }
+
−  }
+
−
+
−  switch( GET_STATE( UART_SERVICE_DTX ) )
+
−  {
+
−    case DTX_DEAD:
+
−      dtx_free_resources();
+
−      uart_data->dtx->receiving_state = UART_DTX_NOT_RECEIVING;
+
−      break;
+
−
+
−    case DTX_READY:
+
−      /*
+
−       * enable data flow if necessary
+
−       */
+
−      if(old_data_flow NEQ UART_FLOW_ENABLED)
+
−      {
+
−        uart_data->dtx->data_flow = UART_FLOW_ENABLED;
+
−        sig_dtx_ker_enable_ind(uart_data->dtx->dlc_instance);
+
−      }
+
−
+
−      if(uart_data->dtx->receiving_state EQ UART_DTX_RECEIVING)
+
−      {
+
−        /*
+
−         * if data to send available or
+
−         * line states changed
+
−         */
+
−        if((temp_desc->len) ||
+
−           (uart_data->dtx->lines_changed))
+
−        {
+
−          PALLOC_DESC2 (dti_data_ind, DTI2_DATA_IND);
+
−          SET_STATE( UART_SERVICE_DTX, DTX_NOT_READY );
+
−
+
−          if(temp_desc->len)
+
−          {
+
−            /*
+
−             * mark entity descriptor as invalid, since data will be forwarded
+
−             */
+
−            uart_data->dtx->to_send_data = NULL;
+
−
+
−            dti_data_ind->desc_list2.first    = (ULONG)temp_desc;
+
−            dti_data_ind->desc_list2.list_len = temp_desc->len;
+
−
+
−            /*
+
−             * calculate new size multiplier according to fillrate of buffer
+
−             */
+
−            dtx_calculate_size_multiplier (temp_desc, old_data_flow);
+
−            /*
+
−             * allocate a new descriptor with size according to new size_multiplier
+
−             */
+
−            dtx_allocate_resources();
+
−            /*
+
−             * Check for data which has not yet been validated, i.e. because
+
−             * the frame containing the data has not yet been received completely.
+
−             * In this case, the not yet validated data is copied to the newly
+
−             * allocated descriptor.
+
−             */
+
−            if(uart_data->dtx->write_pos > temp_desc->len)
+
−            {
+
−              memcpy(uart_data->dtx->to_send_data->buffer,
+
−                     &temp_desc->buffer[temp_desc->len],
+
−                     uart_data->dtx->write_pos - temp_desc->len);
+
−              uart_data->dtx->write_pos-= temp_desc->len;
+
−            }
+
−            esd_pos-= temp_desc->len;
+
−            uart_data->dtx->esd_pos = esd_pos;
+
−          }
+
−          else
+
−          {
+
−            /*
+
−             * just line states has been changed
+
−             */
+
−            dti_data_ind->desc_list2.first    = (ULONG)NULL;
+
−            dti_data_ind->desc_list2.list_len = 0;
+
−          }
+
−
+
−          /*
+
−           * set line states and
+
−           * mark line states as unchanged;
+
−           */
+
−          dti_data_ind->parameters.st_lines.st_flow      = uart_data->dtx->st_flow;
+
−          dti_data_ind->parameters.st_lines.st_line_sa   = uart_data->dtx->st_line_sa;
+
−          dti_data_ind->parameters.st_lines.st_line_sb   = uart_data->dtx->st_line_sb;
+
−          dti_data_ind->parameters.st_lines.st_break_len = uart_data->dtx->st_break_len;
+
−
+
−          uart_data->dtx->lines_changed = FALSE;
+
−          uart_data->dtx->st_break_len  = DTI_BREAK_OFF;
+
−
+
−          dti_send_data(
+
−            uart_hDTI,
+
−            uart_data->device,
+
−            UART_DTI_UP_INTERFACE,
+
−            uart_data->dtx->dlc_instance,
+
−            dti_data_ind
+
−            );
+
−        }
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * invalid data
+
−         * free recources and allocate a new descriptor because
+
−         * size_multiplier may have changed
+
−         */
+
−        dtx_free_resources();
+
−        dtx_allocate_resources();
+
−        /*
+
−         * reset escape sequence detection
+
−         */
+
−        dtx_set_esd_state( UART_ESD_NULL );
+
−        if(vsi_t_time (VSI_CALLER &(uart_data->dtx->esd_guard_time)) NEQ VSI_OK)
+
−        {
+
−          TRACE_ERROR_P1("VSI entity: Can't restart timer, uart_dtxs.c(%d)",
+
−                                                                  __LINE__);
+
−        }
+
−
+
−        esd_pos = 0;
+
−        uart_data->dtx->esd_pos = esd_pos;
+
−      }
+
−
+
−      /*
+
−       * signal availability to receive to RX service
+
−       */
+
−      uart_data->dtx->receiving_state = UART_DTX_NOT_RECEIVING;
+
−      sig_dtx_rx_ready_to_receive_req( uart_data->dtx->dlc_instance,
+
−                                       uart_data->dtx->to_send_data,
+
−                                       uart_data->dtx->write_pos,
+
−                                       uart_data->dtx->cur_desc_size );
+
−      break;
+
−
+
−    case DTX_NOT_READY:
+
−      if(uart_data->dtx->receiving_state EQ UART_DTX_RECEIVING)
+
−      {
+
−        uart_data->dtx->receiving_state = UART_DTX_NOT_RECEIVING;
+
−        if((old_data_flow NEQ UART_FLOW_DISABLED) &&
+
−           ((uart_data->dtx->cur_desc_size - temp_desc->len) <
+
−            ((USHORT)uart_data->n1 << 1)))
+
−        {
+
−          /*
+
−           * the service DTX is receiving but there is not enough space left
+
−           * therefore it is necessary to disable the data flow
+
−           */
+
−          uart_data->dtx->data_flow = UART_FLOW_DISABLED;
+
−          sig_dtx_ker_disable_ind(uart_data->dtx->dlc_instance);
+
−        }
+
−        if((uart_data->dtx->cur_desc_size -
+
−            esd_pos) >= uart_data->n1)
+
−        {
+
−          /*
+
−           * there is still enough space left to continue reception
+
−           */
+
−          sig_dtx_rx_ready_to_receive_req(uart_data->dtx->dlc_instance,
+
−                                          uart_data->dtx->to_send_data,
+
−                                          uart_data->dtx->write_pos,
+
−                                          uart_data->dtx->cur_desc_size);
+
−        }
+
−      }
+
−      else
+
−      {
+
−        /*
+
−         * invalid data
+
−         * free recources and allocate a new descriptor
+
−         * because size_multiplier may have changed
+
−         */
+
−        dtx_free_resources();
+
−        dtx_allocate_resources();
+
−        /*
+
−         * reset escape sequence detection
+
−         */
+
−        dtx_set_esd_state( UART_ESD_NULL );
+
−        if(vsi_t_time (VSI_CALLER &(uart_data->dtx->esd_guard_time)) NEQ VSI_OK)
+
−        {
+
−          TRACE_ERROR_P1("VSI entity: Can't restart timer, uart_dtxs.c(%d)",
+
−                                                                  __LINE__);
+
−        }
+
−
+
−        esd_pos = 0;
+
−        uart_data->dtx->esd_pos = esd_pos;
+
−        /*
+
−         * enable flow control if necessary
+
−         */
+
−        if(old_data_flow NEQ UART_FLOW_ENABLED)
+
−        {
+
−          uart_data->dtx->data_flow = UART_FLOW_ENABLED;
+
−          sig_dtx_ker_enable_ind(uart_data->dtx->dlc_instance);
+
−        }
+
−        /*
+
−         * signal availability to receive to RX service
+
−         */
+
−        uart_data->dtx->receiving_state = UART_DTX_NOT_RECEIVING;
+
−        sig_dtx_rx_ready_to_receive_req( uart_data->dtx->dlc_instance,
+
−                                         uart_data->dtx->to_send_data,
+
−                                         uart_data->dtx->write_pos,
+
−                                         uart_data->dtx->cur_desc_size );
+
−      }
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "SIG_RX_DTX_DATA_RECEIVED_IND unexpected" );
+
−      break;
+
−
+
−  }
+
−} /* sig_rx_dtx_data_received_ind() */
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_ker_dtx_line_states_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_KER_DTX_LINE_STATES_REQ
+
−|               which indicates that one or more line status signals have
+
−|               changed
+
−|
+
−| Parameters  : st_flow      - flow control state (X bit)
+
−|               st_line_sa   - line state SA
+
−|               st_line_sa   - line state SB
+
−|               st_break_len - break length
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_ker_dtx_line_states_req(UBYTE st_flow,
+
−                                        UBYTE st_line_sa,
+
−                                        UBYTE st_line_sb,
+
−                                        UBYTE st_break_len)
+
−{
+
−  TRACE_ISIG( "sig_ker_dtx_line_states_req" );
+
−
+
−  switch( GET_STATE( UART_SERVICE_DTX ) )
+
−  {
+
−    case DTX_READY:
+
−      if((st_flow      NEQ uart_data->dtx->st_flow)    ||
+
−         (st_line_sa   NEQ uart_data->dtx->st_line_sa) ||
+
−         (st_line_sb   NEQ uart_data->dtx->st_line_sb) ||
+
−         (st_break_len NEQ uart_data->dtx->st_break_len))
+
−      {
+
−        /*
+
−         * send line states to DTI peer
+
−         */
+
−        PALLOC_DESC2 (dti_data_ind, DTI2_DATA_IND);
+
−        SET_STATE( UART_SERVICE_DTX, DTX_NOT_READY );
+
−
+
−        /*
+
−         * store new line states
+
−         */
+
−        uart_data->dtx->st_flow       = st_flow;
+
−        uart_data->dtx->st_line_sa    = st_line_sa;
+
−        uart_data->dtx->st_line_sb    = st_line_sb;
+
−        uart_data->dtx->st_break_len  = st_break_len;
+
−
+
−        /*
+
−         * just line states has been changed
+
−         */
+
−        dti_data_ind->desc_list2.first    = (ULONG)NULL;
+
−        dti_data_ind->desc_list2.list_len = 0;
+
−        /*
+
−         * set line states and
+
−         * mark line states as unchanged;
+
−         */
+
−        dti_data_ind->parameters.st_lines.st_flow      = uart_data->dtx->st_flow;
+
−        dti_data_ind->parameters.st_lines.st_line_sa   = uart_data->dtx->st_line_sa;
+
−        dti_data_ind->parameters.st_lines.st_line_sb   = uart_data->dtx->st_line_sb;
+
−        dti_data_ind->parameters.st_lines.st_line_sb   = uart_data->dtx->st_line_sb;
+
−        dti_data_ind->parameters.st_lines.st_break_len = uart_data->dtx->st_break_len;
+
−
+
−        uart_data->dtx->lines_changed = FALSE;
+
−        uart_data->dtx->st_break_len  = DTI_BREAK_OFF;
+
−
+
−        dti_send_data(
+
−          uart_hDTI,
+
−          uart_data->device,
+
−          UART_DTI_UP_INTERFACE,
+
−          uart_data->dtx->dlc_instance,
+
−          dti_data_ind
+
−          );
+
−      }
+
−      break;
+
−
+
−    case DTX_NOT_READY:
+
−      if((st_flow      NEQ uart_data->dtx->st_flow)    ||
+
−         (st_line_sa   NEQ uart_data->dtx->st_line_sa) ||
+
−         (st_line_sb   NEQ uart_data->dtx->st_line_sb) ||
+
−         (st_break_len NEQ uart_data->dtx->st_break_len))
+
−      {
+
−        /*
+
−         * If previously break detected keep information in
+
−         * uart_data->dtx->st_break_len
+
−         */
+
−        if(uart_data->dtx->st_break_len EQ DTI_BREAK_OFF)
+
−          uart_data->dtx->st_break_len = st_break_len;
+
−        /*
+
−         * store new line states
+
−         */
+
−        uart_data->dtx->st_flow    = st_flow;
+
−        uart_data->dtx->st_line_sa = st_line_sa;
+
−        uart_data->dtx->st_line_sb = st_line_sb;
+
−        /*
+
−         * mark line states as changed
+
−         */
+
−        uart_data->dtx->lines_changed = TRUE;
+
−      }
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "SIG_KER_DTX_LINE_STATES_REQ unexpected" );
+
−      break;
+
−  }
+
−} /* sig_ker_dtx_line_states_req */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_ker_dtx_detect_escape_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_KER_DTX_DETECT_ESCAPE_REQ
+
−|               which enables escape sequence detection
+
−|
+
−| Parameters  : detect_escape - TRUE/FALSE
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_ker_dtx_detect_escape_req (UBYTE detect_escape)
+
−{
+
−  TRACE_ISIG( "sig_ker_dtx_detect_req" );
+
−
+
−  uart_data->dtx->detect_escape = detect_escape;
+
−} /* sig_ker_dtx_detect_req() */
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_ker_dtx_disconnected_mode_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_KER_DTX_DISCONNECTED_MODE_REQ
+
−|
+
−| Parameters  : none
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_ker_dtx_disconnected_mode_req ()
+
−{
+
−  TRACE_ISIG( "sig_ker_dtx_disconnected_mode_req" );
+
−
+
−  uart_data->dtx->dti_dtx_state = DTI_CLOSED;
+
−
+
−  switch(GET_STATE( UART_SERVICE_DTX) )
+
−  {
+
−    case DTX_READY:
+
−      SET_STATE( UART_SERVICE_DTX, DTX_NOT_READY );
+
−      break;
+
−    case DTX_NOT_READY:
+
−      break;
+
−    default:
+
−      TRACE_ERROR( "SIG_KER_DTX_DISCONNECTED_MODE_REQ unexpected" );
+
−      break;
+
−  }
+
−
+
−} /* sig_ker_dtx_disconnected_mode_req() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_ker_dtx_set_dtilib_peer_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_KER_DTX_SET_DTI_PEER_REQ
+
−|               which is used to inform the service DTX that from now on it
+
−|               needs to communicate with a (new) peer
+
−|
+
−| Parameters  : -
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_ker_dtx_set_dtilib_peer_req ()
+
−
+
−{
+
−  TRACE_ISIG( "sig_ker_dtx_set_dtilib_peer_req" );
+
−
+
−  /*
+
−   * set dtilib parameters
+
−   */
+
−  uart_data->dtx->dti_dtx_state = DTI_IDLE;
+
−
+
−  /*
+
−   * reset size_multiplier
+
−   */
+
−  uart_data->dtx->size_multiplier = 3;
+
−
+
−  /*
+
−   * switch to new DTX state depending on current state
+
−   */
+
−  switch( GET_STATE( UART_SERVICE_DTX ) )
+
−  {
+
−    case DTX_READY:
+
−      SET_STATE( UART_SERVICE_DTX, DTX_NOT_READY );
+
−      /* fall through */
+
−    case DTX_NOT_READY:
+
−      {
+
−        if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING)
+
−        {
+
−          /*
+
−           * reset received data
+
−           */
+
−          dtx_free_resources();
+
−          dtx_allocate_resources();
+
−          /*
+
−           * reset escape sequence detection
+
−           */
+
−          dtx_set_esd_state( UART_ESD_NULL );
+
−          if(vsi_t_time (VSI_CALLER &(uart_data->dtx->esd_guard_time)) NEQ VSI_OK)
+
−          {
+
−          TRACE_ERROR_P1("VSI entity: Can't restart timer, uart_dtxs.c(%d)",
+
−                                                                  __LINE__);
+
−          }
+
−
+
−          uart_data->dtx->esd_pos = 0;
+
−          /*
+
−           * enable flow control if necessary
+
−           */
+
−          if(uart_data->dtx->data_flow NEQ UART_FLOW_ENABLED)
+
−          {
+
−            uart_data->dtx->data_flow = UART_FLOW_ENABLED;
+
−            sig_dtx_ker_enable_ind(uart_data->dtx->dlc_instance);
+
−          }
+
−          /*
+
−           * signal availability to receive to RX service
+
−           */
+
−          sig_dtx_rx_ready_to_receive_req( uart_data->dtx->dlc_instance,
+
−                                           uart_data->dtx->to_send_data,
+
−                                           uart_data->dtx->write_pos,
+
−                                           uart_data->dtx->cur_desc_size );
+
−        }
+
−        else
+
−          uart_data->dtx->receiving_state = UART_DTX_INVALID;
+
−      }
+
−      break;
+
−
+
−    case DTX_DEAD:
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "SIG_KER_DTX_SET_DTI_PEER_REQ unexpected" );
+
−      break;
+
−  }
+
−} /* sig_ker_dtx_set_dtilib_peer_req() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_ker_dtx_timeout_tesd_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_KER_DTX_TIMEOUT_TESD_REQ
+
−|               which is used to inform the service DTX that the Escape
+
−|               Sequence Guard Period timer has expired.
+
−|
+
−| Parameters  : none
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_ker_dtx_timeout_tesd_req()
+
−{
+
−  T_DATA_FLOW_STATE old_data_flow;
+
−  T_TIME            cur_time;
+
−  T_TIME            elapsed;
+
−  T_desc2*          temp_desc;
+
−
+
−  TRACE_ISIG( "sig_ker_dtx_timeout_tesd_req" );
+
−
+
−  switch( GET_STATE( UART_SERVICE_DTX ) )
+
−  {
+
−    case DTX_READY:
+
−      if (vsi_t_time (VSI_CALLER &cur_time) EQ VSI_OK)
+
−      {
+
−        elapsed = cur_time - uart_data->dtx->esd_guard_time;
+
−        switch (dtx_get_esd_state())
+
−        {
+
−          case UART_ESD_DETECTED:
+
−          case UART_ESD_NULL:
+
−            break;
+
−
+
−          case UART_ESD_CHAR_1:
+
−          case UART_ESD_CHAR_2:
+
−            if(elapsed < uart_data->act_gp)
+
−            {
+
−              /*
+
−               * escape sequence guard period not complete: start timer
+
−               * with remaining time value
+
−               */
+
−              sig_dtx_rt_start_tesd_req (uart_data->act_gp - elapsed);
+
−            }
+
−            else
+
−            {
+
−              /*
+
−               * Guard Period complete
+
−               * reset detection because detected characters do not belong to
+
−               * an escape sequence
+
−               */
+
−              dtx_set_esd_state( UART_ESD_NULL );
+
−
+
−              /*
+
−               * if possible send the escape character
+
−               */
+
−              if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING)
+
−              {
+
−                /*
+
−                 * Guard Period complete
+
−                 * send one escape character to DTI peer and reset detection
+
−                 */
+
−                PALLOC_DESC2 (dti_data_ind, DTI2_DATA_IND);
+
−                SET_STATE( UART_SERVICE_DTX, DTX_NOT_READY );
+
−
+
−                /*
+
−                 * enable data flow if necessary
+
−                 */
+
−                old_data_flow = uart_data->dtx->data_flow;
+
−                if(uart_data->dtx->data_flow NEQ UART_FLOW_ENABLED)
+
−                {
+
−                  uart_data->dtx->data_flow = UART_FLOW_ENABLED;
+
−                  sig_dtx_ker_enable_ind(uart_data->dtx->dlc_instance);
+
−                }
+
−                /*
+
−                 * mark entity descriptor as invalid, since data will be
+
−                 * forwarded
+
−                 */
+
−                temp_desc                    = uart_data->dtx->to_send_data;
+
−                uart_data->dtx->to_send_data = NULL;
+
−
+
−                /*
+
−                 * make escape character valid to send and insert values in
+
−                 * primitive
+
−                 */
+
−                temp_desc->len  = uart_data->dtx->esd_pos;
+
−                temp_desc->size = temp_desc->len;
+
−
+
−                dti_data_ind->desc_list2.first    = (ULONG)temp_desc;
+
−                dti_data_ind->desc_list2.list_len = temp_desc->len;
+
−
+
−                /*
+
−                 * calculate new size multiplier according to fillrate of buffer
+
−                 */
+
−                dtx_calculate_size_multiplier (temp_desc, old_data_flow);
+
−                /*
+
−                 * allocate a new descriptor with size according to new size_multiplier
+
−                 */
+
−                dtx_allocate_resources();
+
−                /*
+
−                 * Check for data which has not yet been validated, i.e. because
+
−                 * the frame containing the data has not yet been received completely.
+
−                 * In this case, the not yet validated data is copied to the newly
+
−                 * allocated descriptor.
+
−                 */
+
−                if(uart_data->dtx->write_pos > temp_desc->len)
+
−                {
+
−                  memcpy(uart_data->dtx->to_send_data->buffer,
+
−                         &temp_desc->buffer[temp_desc->len],
+
−                         uart_data->dtx->write_pos - temp_desc->len);
+
−                  uart_data->dtx->write_pos-= temp_desc->len;
+
−                }
+
−                uart_data->dtx->esd_pos = 0;
+
−                sig_dtx_rx_ready_to_receive_req(uart_data->dtx->dlc_instance,
+
−                                                uart_data->dtx->to_send_data,
+
−                                                uart_data->dtx->write_pos,
+
−                                                uart_data->dtx->cur_desc_size);
+
−
+
−                /*
+
−                 * set line states
+
−                 */
+
−                dti_data_ind->parameters.st_lines.st_flow      = uart_data->dtx->st_flow;
+
−                dti_data_ind->parameters.st_lines.st_line_sa   = uart_data->dtx->st_line_sa;
+
−                dti_data_ind->parameters.st_lines.st_line_sb   = uart_data->dtx->st_line_sb;
+
−                dti_data_ind->parameters.st_lines.st_break_len = uart_data->dtx->st_break_len;
+
−
+
−                uart_data->dtx->lines_changed = FALSE;
+
−                uart_data->dtx->st_break_len  = DTI_BREAK_OFF;
+
−
+
−#ifdef _SIMULATION_
+
−                dti_data_ind->parameters.p_id = DTI_PID_UOS;
+
−#endif /* _SIMULATION_ */
+
−                dti_send_data(
+
−                  uart_hDTI,
+
−                  uart_data->device,
+
−                  UART_DTI_UP_INTERFACE,
+
−                  uart_data->dtx->dlc_instance,
+
−                  dti_data_ind
+
−                  );
+
−              }
+
−            }
+
−            break;
+
−
+
−          case UART_ESD_CHAR_3:
+
−            if(elapsed < uart_data->act_gp)
+
−            {
+
−              /*
+
−               * escape sequence guard period not complete: start timer
+
−               * with remaining time value
+
−               */
+
−              sig_dtx_rt_start_tesd_req (uart_data->act_gp - elapsed);
+
−            }
+
−            else
+
−            {
+
−              /*
+
−               * Guard Period complete
+
−               * Escape Sequence detected
+
−               */
+
−              /*
+
−               * remove escape characters from data stream
+
−               */
+
−              if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING)
+
−              {
+
−                if(uart_data->dtx->write_pos > 3)
+
−                {
+
−                  memmove(uart_data->dtx->to_send_data->buffer,
+
−                          &uart_data->dtx->to_send_data->buffer[3],
+
−                          uart_data->dtx->write_pos - 3)
+
−                  ; /*lint !e416 creation of out-of-bounds pointer */
+
−                  uart_data->dtx->write_pos-= 3;
+
−                }
+
−                else
+
−                  uart_data->dtx->write_pos = 0;
+
−                uart_data->dtx->esd_pos = 0;
+
−                sig_dtx_rx_ready_to_receive_req(uart_data->dtx->dlc_instance,
+
−                                                uart_data->dtx->to_send_data,
+
−                                                uart_data->dtx->write_pos,
+
−                                                uart_data->dtx->cur_desc_size);
+
−                /*
+
−                 * Reset the state of the Escape Sequence Detection
+
−                 */
+
−                dtx_set_esd_state( UART_ESD_NULL );
+
−              }
+
−              else
+
−              {
+
−                /*
+
−                 * escape characters are not removeable
+
−                 * so we will do this later
+
−                 */
+
−#ifdef _SIMULATION_
+
−                TRACE_EVENT("ESD: escape characters are not removeable");
+
−#endif /* _SIMULATION_ */
+
−                dtx_set_esd_state( UART_ESD_DETECTED );
+
−              }
+
−#ifdef _SIMULATION_
+
−              TRACE_EVENT_P3("+ + + dlc_instance: %d, silence %d \
+
−                             (from %d) Escape Sequence Detected + + + ",
+
−                             uart_data->dtx->dlc_instance,
+
−                             elapsed,
+
−                             uart_data->dtx->esd_guard_time);
+
−#endif /* _SIMULATION_ */
+
−
+
−              /*
+
−               * send detected escape sequence to MMI
+
−               */
+
−              sig_dtx_ker_escape_detected_ind(uart_data->dtx->dlc_instance);
+
−            }
+
−            break;
+
−
+
−          default:
+
−            {
+
−              TRACE_ERROR_P1("Error: wrong ESD state, uart_dtxs.c(%d)", __LINE__);
+
−            }
+
−            break;
+
−        }
+
−      }
+
−      else
+
−      {
+
−          TRACE_ERROR_P1("VSI entity: Cannot restart timer, uart_dtxs.c(%d)",
+
−                                                                   __LINE__);
+
−      }
+
−      break;
+
−
+
−    case DTX_NOT_READY:
+
−      if (vsi_t_time (VSI_CALLER &cur_time) EQ VSI_OK)
+
−      {
+
−        elapsed = cur_time - uart_data->dtx->esd_guard_time;
+
−        switch (dtx_get_esd_state())
+
−        {
+
−          case UART_ESD_DETECTED:
+
−          case UART_ESD_NULL:
+
−            break;
+
−
+
−          case UART_ESD_CHAR_1:
+
−          case UART_ESD_CHAR_2:
+
−            if(elapsed < uart_data->act_gp)
+
−            {
+
−              /*
+
−               * escape sequence guard period not complete: start timer
+
−               * with remaining time value
+
−               */
+
−              sig_dtx_rt_start_tesd_req (uart_data->act_gp - elapsed);
+
−            }
+
−            else
+
−            {
+
−              /*
+
−               * Guard Period complete
+
−               * reset detection because detected characters do not belong to
+
−               * an escape sequence
+
−               */
+
−              dtx_set_esd_state( UART_ESD_NULL );
+
−
+
−              /*
+
−               * if possible insert escape characters to usual data stream
+
−               */
+
−              if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING)
+
−              {
+
−                /*
+
−                 * make escape character valid to send and insert values in
+
−                 * primitive
+
−                 */
+
−                uart_data->dtx->to_send_data->len    = uart_data->dtx->esd_pos;
+
−                uart_data->dtx->to_send_data->size   = uart_data->dtx->esd_pos;
+
−                uart_data->dtx->to_send_data->offset = 0;
+
−
+
−                if((uart_data->dtx->cur_desc_size -
+
−                    uart_data->dtx->esd_pos) >= uart_data->n1)
+
−                {
+
−                  /*
+
−                   * there is still enough space left to continue reception
+
−                   */
+
−                  sig_dtx_rx_ready_to_receive_req(
+
−                    uart_data->dtx->dlc_instance,
+
−                    uart_data->dtx->to_send_data,
+
−                    uart_data->dtx->write_pos,
+
−                    uart_data->dtx->cur_desc_size);
+
−                }
+
−
+
−              }
+
−            }
+
−            break;
+
−
+
−          case UART_ESD_CHAR_3:
+
−            if(elapsed < uart_data->act_gp)
+
−            {
+
−              /*
+
−               * escape sequence guard period not complete: start timer
+
−               * with remaining time value
+
−               */
+
−              sig_dtx_rt_start_tesd_req (uart_data->act_gp - elapsed);
+
−            }
+
−            else
+
−            {
+
−              /*
+
−               * Guard Period complete
+
−               * Escape Sequence detected
+
−               * store the occurence of the Escape Sequence
+
−               */
+
−#ifdef _SIMULATION_
+
−              TRACE_EVENT_P3("+ + + dlc_instance: %d, silence %d \
+
−                             (from %d) Escape Sequence Detected + + + ",
+
−                             uart_data->dtx->dlc_instance,
+
−                             elapsed,
+
−                             uart_data->dtx->esd_guard_time);
+
−#endif /* _SIMULATION_ */
+
−              /*
+
−               * remove escape characters from data stream
+
−               */
+
−              if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING)
+
−              {
+
−                if(uart_data->dtx->write_pos > uart_data->dtx->esd_pos)
+
−                {
+
−                  memmove(
+
−                    &uart_data->dtx->to_send_data->buffer[
+
−                      uart_data->dtx->esd_pos - 3],
+
−                    &uart_data->dtx->to_send_data->buffer[
+
−                      uart_data->dtx->esd_pos],
+
−                    uart_data->dtx->write_pos - uart_data->dtx->esd_pos);
+
−                }
+
−                uart_data->dtx->write_pos-= 3;
+
−                uart_data->dtx->esd_pos  -= 3;
+
−                /*
+
−                 * Reset the state of the Escape Sequence Detection
+
−                 */
+
−                dtx_set_esd_state( UART_ESD_NULL );
+
−
+
−                if((uart_data->dtx->cur_desc_size -
+
−                    uart_data->dtx->esd_pos) >= uart_data->n1)
+
−                {
+
−                  /*
+
−                   * there is still enough space left to continue reception
+
−                   */
+
−                  sig_dtx_rx_ready_to_receive_req(
+
−                    uart_data->dtx->dlc_instance,
+
−                    uart_data->dtx->to_send_data,
+
−                    uart_data->dtx->write_pos,
+
−                    uart_data->dtx->cur_desc_size);
+
−                }
+
−              }
+
−              else
+
−              {
+
−                /*
+
−                 * escape characters are not removeable
+
−                 * so we will do this later
+
−                 */
+
−#ifdef _SIMULATION_
+
−                TRACE_EVENT("ESD: escape characters are not removeable");
+
−#endif /* _SIMULATION_ */
+
−                dtx_set_esd_state( UART_ESD_DETECTED );
+
−              }
+
−
+
−              /*
+
−               * send detected escape sequence to MMI
+
−               */
+
−              sig_dtx_ker_escape_detected_ind(uart_data->dtx->dlc_instance);
+
−            }
+
−            break;
+
−
+
−          default:
+
−            TRACE_ERROR("wrong esd state");
+
−            break;
+
−        }
+
−      }
+
−      break;
+
−
+
−    case DTX_DEAD:
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "SIG_KER_DTX_TIMEOUT_TESD_REQ unexpected" );
+
−      break;
+
−  }
+
−} /* sig_ker_dtx_timeout_tesd_req() */