view src/g23m-aci/uart/uart_kers.c @ 1:fa8dc04885d8

src/g23m-*: import from Magnetite
author Mychaela Falconia <falcon@freecalypso.org>
date Fri, 16 Oct 2020 06:25:50 +0000
parents
children
line wrap: on
line source

/*
+-----------------------------------------------------------------------------
|  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 (KER-statemachine)
+-----------------------------------------------------------------------------
*/

#ifndef UART_KERS_C
#define UART_KERS_C
#endif /* !UART_KERS_C */

#define ENTITY_UART

/*
 * Turn off spurious LINT warnings
 */
 /*lint -e415 access of out-of-bounds pointer */

/*==== INCLUDES =============================================================*/

#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 */

#ifdef FF_MULTI_PORT
#include "uart_ptxs.h"  /* to get signal definitions for service TX */
#include "uart_prxs.h"  /* to get rx signals */
#else /* FF_MULTI_PORT */
#include "uart_txs.h"   /* to get signal definitions of service TX */
#include "uart_rxs.h"   /* to get signal definitions of service RX */
#endif /* FF_MULTI_PORT */
#include "uart_dtxs.h"  /* to get signal definitions of service DTX */
#include "uart_drxs.h"  /* to get signal definitions of service DRX */
#include "uart_kerf.h"  /* to get function definitions of service KER */
#include "uart_rts.h"   /* to get signal definitions of service RT */

#ifndef _TARGET_
#include <stdio.h>      /* to get sprintf */
#endif /* !_TARGET_ */
#include <string.h>      /* JK, delete warnings: to get memcpy */

/*==== CONST ================================================================*/

/*==== LOCAL VARS ===========================================================*/

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

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



/*
+------------------------------------------------------------------------------
| Function    : sig_drx_ker_line_states_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_DRX_KER_LINE_STATES_IND
|
| Parameters  : dlc_instance - dlc instance wich belongs to calling DRX
|               st_flow      - flow control state (X bit)
|               st_line_sa   - line state SA
|               st_line_sa   - line state SB
|               st_break_len - break state
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_drx_ker_line_states_ind(UBYTE  dlc_instance,
                                        UBYTE  st_flow,
                                        UBYTE  st_line_sa,
                                        UBYTE  st_line_sb,
                                        USHORT st_break_len)
{
  T_DLC*  dlc;
  ULONG   old_lines;
  ULONG   new_lines;

  TRACE_ISIG( "sig_drx_ker_line_states_ind" );

  /*
   * set DLC
   */
  dlc = &uart_data->dlc_table[dlc_instance];

  switch( GET_STATE( UART_SERVICE_KER ) )
  {
    case KER_READY:
      /*
       * check for changed line states
       */
      old_lines = dlc->lines & (UART_SA_TX_MASK |
                                UART_SB_TX_MASK |
                                UART_X_TX_MASK  |
                                UART_BRK_TX_MASK);
      new_lines = ((ULONG)st_line_sa << UART_SA_TX_POS) |
                   ((ULONG)st_line_sb << UART_SB_TX_POS) |
                   ((ULONG)st_flow    << UART_X_TX_POS);
      if(st_break_len NEQ DTI_BREAK_OFF)
      {
        TRACE_EVENT("send Break");
        new_lines|= UART_BRK_TX_MASK;
      }

      if(old_lines NEQ new_lines)
      {
        /*
         * trace changes
         */
        if(new_lines & UART_X_TX_MASK)
        {
          if(!(old_lines & UART_X_TX_MASK))
          {
            TRACE_EVENT("TX Flow Control: stop");
          }
        }
        else if(old_lines & UART_X_TX_MASK)
        {
          TRACE_EVENT("TX Flow Control: start");
        }

        if(new_lines & UART_SA_TX_MASK)
        {
          if(!(old_lines & UART_SA_TX_MASK))
          {
            TRACE_EVENT("DSR: off");
          }
        }
        else if(old_lines & UART_SA_TX_MASK)
        {
          TRACE_EVENT("DSR: on");
        }

        if(new_lines & UART_SB_TX_MASK)
        {
          if(!(old_lines & UART_SB_TX_MASK))
          {
            TRACE_EVENT("DCD: off");
          }
        }
        else if(old_lines & UART_SB_TX_MASK)
        {
          TRACE_EVENT("DCD: on");
        }

        /*
         * send new line states
         * but flush UART before
         */
        dlc->lines&= ~(UART_SA_TX_MASK  |
                       UART_SB_TX_MASK  |
                       UART_X_TX_MASK   |
                       UART_BRK_TX_MASK |
                       UART_BRKLEN_TX_MASK);

        if(st_break_len NEQ DTI_BREAK_OFF)
          new_lines|= ((ULONG)st_break_len << UART_BRKLEN_TX_POS);

        dlc->lines|= new_lines;

        dlc->received_prim|= UART_DTI_DATA_REQ_MASK;

        if(uart_data->ker.flush_state EQ UART_KER_NOT_FLUSHING)
        {
          uart_data->ker.flush_state = UART_KER_TX_FLUSH;
          sig_ker_tx_flush_req();
        }
      }
      break;

    case KER_MUX:
      /*
       * check for changed line states
       */
      old_lines = dlc->lines & (UART_CTS_MASK |
                                UART_DSR_MASK |
                                UART_DCD_MASK |
                                UART_BRK_TX_MASK);
      new_lines = ((ULONG)st_flow << UART_CTS_POS)    |
                  ((ULONG)st_line_sa << UART_DSR_POS) |
                  ((ULONG)st_line_sb << UART_DCD_POS);

      if(st_break_len NEQ DTI_BREAK_OFF)
      {
        TRACE_EVENT_P1("send Break - DLCI=%d", dlc->dlci);
        new_lines|= UART_BRK_TX_MASK;
      }

      if(old_lines NEQ new_lines)
      {
        /*
         * trace changes
         */
        if(new_lines & UART_CTS_MASK)
        {
          if(!(old_lines & UART_CTS_MASK))
          {
            TRACE_EVENT_P1("TX Flow Control: stop - DLCI=%d", dlc->dlci);
          }
        }
        else if(old_lines & UART_CTS_MASK)
        {
          TRACE_EVENT_P1("TX Flow Control: start - DLCI=%d", dlc->dlci);
        }

        if(new_lines & UART_DSR_MASK)
        {
          if(!(old_lines & UART_DSR_MASK))
          {
            TRACE_EVENT_P1("DSR: off - DLCI=%d", dlc->dlci);
          }
        }
        else if(old_lines & UART_DSR_MASK)
        {
          TRACE_EVENT_P1("DSR: on - DLCI=%d", dlc->dlci);
        }

        if(new_lines & UART_DCD_MASK)
        {
          if(!(old_lines & UART_DCD_MASK))
          {
            TRACE_EVENT_P1("DCD: off - DLCI=%d", dlc->dlci);
          }
        }
        else if(old_lines & UART_DCD_MASK)
        {
          TRACE_EVENT_P1("DCD: on - DLCI=%d", dlc->dlci);
        }
        /*
         * build and send MSC command
         */
        dlc->lines&= ~(UART_CTS_MASK    |
                       UART_DSR_MASK    |
                       UART_DCD_MASK    |
                       UART_BRK_TX_MASK |
                       UART_BRKLEN_TX_MASK);

        if(st_break_len NEQ DTI_BREAK_OFF)
          new_lines|= ((ULONG)st_break_len << UART_BRKLEN_TX_POS);

        dlc->lines|= new_lines;
        ker_mux_send_line_states(dlc_instance);
      }
      break;

    default:
      TRACE_ERROR( "SIG_DRX_KER_LINE_STATES_IND unexpected" );
      break;
  }
} /* sig_drx_ker_line_states_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_dtx_ker_enable_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_DTX_KER_ENABLE_IND
|
| Parameters  : dlc_instance - dlc instance wich belongs to calling DTX
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_dtx_ker_enable_ind (UBYTE dlc_instance)
{
  TRACE_ISIG( "sig_dtx_ker_enable_ind" );

  switch( GET_STATE( UART_SERVICE_KER ) )
  {
    case KER_MUX:
      /*
       * build and send MSC command
       * enable flow control in line states
       */
      uart_data->dlc_table[dlc_instance].lines&= ~UART_FC_TX_MASK;
      /*
       * send new line states
       */
      ker_mux_send_line_states(dlc_instance);
      break;

    case KER_READY:
      break;

    default:
      TRACE_ERROR( "SIG_DTX_KER_ENABLE_IND unexpected" );
      break;
  }
} /* sig_dtx_ker_enable_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_dtx_ker_disable_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_DTX_KER_DISABLE_IND
|
| Parameters  : dlc_instance - dlc instance wich belongs to calling DTX
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_dtx_ker_disable_ind (UBYTE dlc_instance)
{
  TRACE_ISIG( "sig_dtx_ker_disable_ind" );

  switch( GET_STATE( UART_SERVICE_KER ) )
  {
    case KER_MUX:
      /*
       * build and send MSC command
       * disable flow control in line states
       */
      uart_data->dlc_table[dlc_instance].lines|= UART_FC_TX_MASK;
      /*
       * send new line states
       */
      ker_mux_send_line_states(dlc_instance);
      break;

    case KER_READY:
      break;

    default:
      TRACE_ERROR( "SIG_DTX_KER_DISABLE_IND unexpected" );
      break;
  }
} /* sig_dtx_ker_disable_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_dtx_ker_escape_detected_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_DTX_KER_ESCAPE_DETECTED_IND
|
| Parameters  : dlc_instance - dlc instance wich belongs to calling DTX
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_dtx_ker_escape_detected_ind (U8 dlc_instance)
{
  T_DLC *dlc;

  TRACE_FUNCTION( "sig_dtx_ker_escape_detected_ind" );

  /*
   * set DLC
   */
  dlc = &uart_data->dlc_table[dlc_instance];
  {
    PALLOC (uart_detected_ind, UART_DETECTED_IND);
    uart_detected_ind->device = uart_data->device;
    uart_detected_ind->dlci   = dlc->dlci;
    uart_detected_ind->cause  = UART_DETECT_ESC;
    PSEND (hCommMMI, uart_detected_ind);
  }
} /* sig_dtx_ker_escape_detected_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_any_ker_flushed_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_ANY_KER_FLUSHED_IND
|
| Parameters  : dlc_instance - dlc instance wich belongs to this signal
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_any_ker_flushed_ind (UBYTE dlc_instance)
{
  T_DLC*  dlc;
  UBYTE   i;

  TRACE_ISIG( "sig_any_ker_flushed_ind" );

  /*
   * reset flush indicator
   */
  dlc          = &uart_data->dlc_table[dlc_instance];
  dlc->flushed = TRUE;
  /*
   * if the primitive which has triggered the flush belongs to the whole port
   * we will check each DLC for flush, if it only belongs to this DLC we start
   * TX flushing immediately
   */
  if(uart_data->ker.received_prim)
  {
    /*
     * check each DLC
     */
    for(i = 0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++)
    {
      dlc = &uart_data->dlc_table[i];
      if(dlc->flushed NEQ TRUE)
        return;
    }
  }
  /*
   * start TX flushing
   */
  uart_data->ker.flush_state = UART_KER_TX_FLUSH;
  sig_ker_tx_flush_req();
} /* sig_any_ker_flushed_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_tx_ker_flushed_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_TX_KER_FLUSHED_IND
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_tx_ker_flushed_ind ()
{
  T_DLC*  dlc;
  UBYTE   i;
#ifndef  _SIMULATION_
  USHORT  error_code;
#endif
  TRACE_ISIG( "sig_tx_ker_flushed_ind" );

  if(uart_data->ker.flush_state EQ UART_KER_TX_FLUSH)
  {
    /*
     * primitives of the port
     */
    /*
     * UART_PARAMETERS_REQ
     */
    if(uart_data->ker.received_prim & UART_PARAMETERS_REQ_MASK)
    {
      /*
       * disable UART while set new communication parameters
       */
#ifdef _SIMULATION_
      {
        /*
         * send DTI_GETDATA_REQ
         */
        PALLOC (dti_getdata_req, DTI2_GETDATA_REQ);
        dti_getdata_req->link_id = LINK_DISABLE_PORT_1; /* for disable */
        PSEND (hCommMMI, dti_getdata_req);
      }
#else /* _SIMULATION_ */
#ifndef FF_MULTI_PORT
      if((error_code = UF_Enable (uart_data->device, FALSE)) NEQ UF_OK)
      {
          TRACE_ERROR_P2("UF Driver: Can't disable UART, [%d], uart_kerp.c(%d)",
                                                           error_code,__LINE__);
      }
#endif /* !FF_MULTI_PORT */
#endif /* _SIMULATION */
      /*
       * set new parameters
       */
      ker_setupUart();
#ifdef _SIMULATION_
      {
        /*
         * send DTI_GETDATA_REQ
         */
        PALLOC (dti_getdata_req, DTI2_GETDATA_REQ);
        dti_getdata_req->link_id = LINK_ENABLE_PORT_1; /* for enable */
        PSEND (hCommMMI, dti_getdata_req);
      }
#else /* _SIMULATION_ */
#ifndef FF_MULTI_PORT
      if((error_code = UF_Enable (uart_data->device, TRUE)) NEQ UF_OK)
      {
          TRACE_ERROR_P2("UF Driver: Can't enable UART, [%d], uart_kerp.c(%d)",
                                                          error_code,__LINE__);
      }
#endif /* !FF_MULTI_PORT */
#endif /* _SIMULATION */
      /*
       * restart suspended read and write procedures
       */
      sig_ker_tx_restart_write_req();
      sig_ker_rx_restart_read_req();
      /*
       * send confirm primitive
       */
      {
        PALLOC (uart_parameters_cnf, UART_PARAMETERS_CNF);
        uart_parameters_cnf->device = uart_data->device;
        PSEND (hCommMMI, uart_parameters_cnf);
      }
    }

    /*
     * UART_DISABLE_REQ
     */
    if(uart_data->ker.received_prim & UART_DISABLE_REQ_MASK)
    {
      switch( GET_STATE( UART_SERVICE_KER ) )
      {
        case KER_MUX:
        case KER_MUX_ESTABLISH:
        case KER_MUX_DLC_CLOSING:
        case KER_MUX_CLOSING:
        case KER_MUX_CLOSED:
          /*
           * stop timers and
           * remove all DLC instances
           */
          ker_mux_close_down();
          break;

        case KER_READY:
          /*
           * close dlc channel
           */
          ker_mux_dlc_release(UART_CONTROL_INSTANCE);
          break;

        case KER_DEAD:
          break;

        default:
          TRACE_ERROR( "SIG_TX_KER_FLUSHED_IND unexpected" );
          break;
      }

      SET_STATE( UART_SERVICE_KER, KER_DEAD );

      /*
       * disable UART
       */
#ifdef _SIMULATION_
      {
        /*
         * send DTI_GETDATA_REQ
         */
        PALLOC (dti_getdata_req, DTI2_GETDATA_REQ);
        dti_getdata_req->link_id = LINK_DISABLE_PORT_1; /* for disable */
        PSEND (hCommMMI, dti_getdata_req);
      }
#else /* _SIMULATION_ */
#ifndef FF_MULTI_PORT
      if((error_code = UF_Enable (uart_data->device, FALSE)) NEQ UF_OK)
      {
          TRACE_ERROR_P2("UF Driver: Can't disable UART, [%d], uart_kerp.c(%d)",
                                                           error_code,__LINE__);
      }
#endif /* !FF_MULTI_PORT */
#endif /* _SIMULATION */
      sig_ker_rx_dead_mode_req();
      sig_ker_tx_dead_mode_req();
      /*
       * send confirm primitive
       */
      {
        PALLOC (uart_disable_cnf, UART_DISABLE_CNF);
        uart_disable_cnf->device = uart_data->device;
        PSEND (hCommMMI, uart_disable_cnf);
      }
    }

    /*
     * UART_MUX_START_REQ
     */
    if(uart_data->ker.received_prim & UART_MUX_START_REQ_MASK)
    {
      switch( GET_STATE( UART_SERVICE_KER ) )
      {
        case KER_READY:
          /*
           * close dlc channel
           */
          ker_mux_dlc_release(UART_CONTROL_INSTANCE);
          break;

        default:
          TRACE_ERROR( "SIG_TX_KER_FLUSHED_IND unexpected" );
          break;
      }

      SET_STATE( UART_SERVICE_KER, KER_MUX_ESTABLISH );

      /*
       * set RX and TX service in mux mode
       */
      sig_ker_rx_mux_mode_req();
      sig_ker_tx_mux_mode_req();
      /*
       * start reception
       */
      MALLOC(uart_data->ker.rx_data_desc, (USHORT)(sizeof(T_desc2) -
                                           1 +
                                           uart_data->n1 +
                                           2));
      uart_data->ker.rx_data_desc->next = (ULONG)NULL;
      uart_data->ker.rx_data_desc->len  = 0;
      sig_ker_rx_ready_to_receive_req(uart_data->ker.rx_data_desc,
                                      0,
                                      (USHORT)(uart_data->n1 + 2));
      /*
       * start timer
       */
      sig_ker_rt_start_t3_req();

      /*
       * send confirm primitive
       */
      {
        PALLOC (uart_mux_start_cnf, UART_MUX_START_CNF);
        uart_mux_start_cnf->device = uart_data->device;
        PSEND (hCommMMI, uart_mux_start_cnf);
      }
    }

    /*
     * UART_MUX_CLOSE_REQ
     */
    if(uart_data->ker.received_prim & UART_MUX_CLOSE_REQ_MASK)
    {
      switch( GET_STATE( UART_SERVICE_KER ) )
      {
        case KER_MUX_CLOSED:
          if(uart_data->ker.receiving_state NEQ UART_KER_RECEIVING)
          {
            PALLOC(uart_mux_close_ind, UART_MUX_CLOSE_IND);
            SET_STATE( UART_SERVICE_KER, KER_READY );
            /*
             * stop receiving
             */
            sig_ker_rx_not_ready_to_receive_req();
            MFREE_DESC2(uart_data->ker.rx_data_desc);
            uart_data->ker.rx_data_desc = NULL;
            /*
             * set dlc values
             */
            dlc           = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
            dlc->drx      = &uart_data->drx_base[0];
            dlc->dtx      = &uart_data->dtx_base[0];
            dlc->dlci     = 0;
            dlc->priority = 0;
            /*
             * set RX and TX in ready mode
             */
            sig_ker_rx_ready_mode_req();
            sig_ker_tx_ready_mode_req();
            /*
             * set frame size for ready mode
             */
            uart_data->n1 = UART_N1_READY_MODE;
            /*
             * set DRX and DTX in ready mode
             */
            uart_data->dtx = dlc->dtx;
            uart_data->drx = dlc->drx;
            sig_ker_drx_ready_mode_req(UART_CONTROL_INSTANCE);
            sig_ker_dtx_ready_mode_req(UART_CONTROL_INSTANCE);
            /*
             * inform ACI about entering ready mode
             */
            uart_mux_close_ind->device = uart_data->device;
            PSEND(hCommMMI, uart_mux_close_ind);
          }
          break;

        default:
          TRACE_ERROR( "SIG_TX_KER_FLUSHED_IND unexpected" );
          break;
      }
    }

    /*
     * no more UART port related primitives
     * so clear all flags
     */
    uart_data->ker.received_prim = 0;

    /*
     * primitives of the DLC
     */
    for(i = 0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++)
    {
      dlc = &uart_data->dlc_table[i];
      if(dlc->received_prim)
      {
        /*
         * UART_RING_REQ
         * UART_DCD_REQ
         * DTI_DATA_REQ (line states)
         */
        if((dlc->received_prim & UART_RING_REQ_MASK)  ||
           (dlc->received_prim & UART_DCD_REQ_MASK)   ||
           (dlc->received_prim & UART_DTI_DATA_REQ_MASK))
        {
          /*
           * send new line states
           */
          switch( GET_STATE( UART_SERVICE_KER ) )
          {
            case KER_READY:
              sig_ker_tx_line_states_req(UART_CONTROL_INSTANCE);
              break;

            case KER_MUX:
              /*
               * send MSC frame to peer
               */
              ker_mux_send_line_states (uart_data->dlc_instance[dlc->dlci]);
              break;

            default:
              if(dlc->received_prim & UART_RING_REQ_MASK)
              {
                TRACE_ERROR( "UART_RING_REQ unexpected" );
              }
              if(dlc->received_prim & UART_DCD_REQ_MASK)
              {
                TRACE_ERROR( "UART_DCD_REQ unexpected" );
              }
              break;
          }
          /*
           * send confirm primitives
           */
          if(dlc->received_prim & UART_RING_REQ_MASK)
          {
            PALLOC (uart_ring_cnf, UART_RING_CNF);
            uart_ring_cnf->device = uart_data->device;
            uart_ring_cnf->dlci   = dlc->dlci;
            PSEND (hCommMMI, uart_ring_cnf);
          }
          if(dlc->received_prim & UART_DCD_REQ_MASK)
          {
            PALLOC (uart_dcd_cnf, UART_DCD_CNF);
            uart_dcd_cnf->device = uart_data->device;
            uart_dcd_cnf->dlci   = dlc->dlci;
            PSEND (hCommMMI, uart_dcd_cnf);
          }
        }
        /*
         * no more DLC related primitives
         * so clear all flags
         */
        dlc->received_prim = 0;
      }
    }
    uart_data->ker.flush_state = UART_KER_NOT_FLUSHING;
  }
} /* sig_tx_ker_flushed_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_tx_ker_sending_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_TX_KER_SENDING_IND
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_tx_ker_sending_ind ()
{
  TRACE_ISIG( "sig_tx_ker_sending_ind" );

  switch( GET_STATE( UART_SERVICE_KER ) )
  {
    case KER_MUX_ESTABLISH:
    case KER_MUX:
    case KER_MUX_DLC_CLOSING:
    case KER_MUX_CLOSING:
    case KER_MUX_CLOSED:
      uart_data->ker.sending_state = UART_KER_SENDING;
      break;

    default:
      TRACE_ERROR( "SIG_TX_KER_SENDING_IND unexpected" );
      break;
  }
} /* sig_tx_ker_sending_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_tx_ker_data_sent_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_TX_KER_DATA_SENT_IND
|
| Parameters  : rest_data - not yet sent data
|               write_pos - position where the not yet sent data starts
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_tx_ker_data_sent_ind (T_desc2* rest_data, USHORT read_pos)
{
  TRACE_ISIG( "sig_tx_ker_data_sent_ind" );

  /*
   * free sent data descriptor
   */
  MFREE_DESC2(uart_data->ker.tx_data_desc);
  uart_data->ker.tx_data_desc  = NULL;
  uart_data->ker.sending_state = UART_KER_NOT_SENDING;
  if(uart_data->ker.tx_data_waiting)
  {
    /*
     * send next descriptor in waiting queue
     */
    uart_data->ker.tx_data_desc    = uart_data->ker.tx_data_waiting;
    uart_data->ker.tx_data_waiting =
      (T_desc2*)uart_data->ker.tx_data_waiting->next;
    /*
     * only one descriptor is sent at a time
     */
    uart_data->ker.tx_data_desc->next = (ULONG)NULL;
    sig_ker_tx_data_available_req( uart_data->ker.tx_data_desc, 0);
  }
  else
  {
    switch( GET_STATE( UART_SERVICE_KER ) )
    {
      case KER_MUX_ESTABLISH:
      case KER_MUX:
      case KER_MUX_DLC_CLOSING:
      case KER_MUX_CLOSING:
        break;

      case KER_MUX_CLOSED:
        /*
         * flush UART before enter ready mode
         */
        uart_data->ker.received_prim|= UART_MUX_CLOSE_REQ_MASK;

        if(uart_data->ker.flush_state EQ UART_KER_NOT_FLUSHING)
        {
          uart_data->ker.flush_state = UART_KER_TX_FLUSH;
          sig_ker_tx_flush_req();
        }
        break;

      default:
        TRACE_ERROR( "SIG_TX_KER_DATA_SENT_IND unexpected" );
        break;
    }
  }
} /* sig_tx_ker_data_sent_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_rx_ker_receiving_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_RX_KER_RECEIVING_IND
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_rx_ker_receiving_ind ()
{
  TRACE_ISIG( "sig_rx_ker_receiving_ind" );

  switch( GET_STATE( UART_SERVICE_KER ) )
  {
    case KER_MUX_ESTABLISH:
    case KER_MUX:
    case KER_MUX_DLC_CLOSING:
    case KER_MUX_CLOSING:
    case KER_MUX_CLOSED:
      uart_data->ker.receiving_state = UART_KER_RECEIVING;
      break;
    default:
      TRACE_ERROR( "SIG_RX_KER_RECEIVING_IND unexpected" );
      break;
  }
} /* sig_rx_ker_receiving_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_rx_ker_data_received_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_RX_KER_DATA_RECEIVED_IND
|               which is used to process a received frame.
|
|               Precondition is that the frame has a length >2 without flags.
|
| Parameters  : received_data - received data
|               write_pos     - write position for the next reception
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_rx_ker_data_received_ind (T_desc2* received_data,
                                          USHORT write_pos)
{
  UBYTE   i;
  UBYTE   dlci;
  T_DLC*  dlc;
  ULONG   forward;
  BOOL    continuous;

  TRACE_ISIG( "sig_rx_ker_data_received_ind" );

#ifndef _TARGET_
  if(received_data->len)
  {
    USHORT  pos;
    char    buf[90];
    /*
     * trace output
     */
    TRACE_EVENT("======= IN");
    i   = 0;
    pos = 0;
    while(pos < received_data->len)
    {
      i+= sprintf(&buf[i], "0x%02x, ", received_data->buffer[pos]);
      pos++;
      if(i > 80)
      {
        TRACE_EVENT( buf );
        i = 0;
      }
      else if(pos >= received_data->len)
      {
        TRACE_EVENT( buf );
      }
    }
  }
#endif /* !_TARGET_ */

  uart_data->ker.receiving_state = UART_KER_NOT_RECEIVING;

  switch( GET_STATE( UART_SERVICE_KER ) )
  {
    case KER_MUX_ESTABLISH:
      if(received_data->len EQ 0)
      {
        /*
         * prepare next reception
         */
        sig_ker_rx_ready_to_receive_req(received_data,
                                        write_pos,
                                        (USHORT)(uart_data->n1 + 2));
        break;
      }
      dlci = received_data->buffer[UART_OFFSET_ADDRESS] >> UART_DLCI_POS;
      if((dlci EQ UART_DLCI_CONTROL) &&
         (received_data->buffer[UART_OFFSET_CONTROL] EQ UART_SABM_FRAME))
      {
        /*
         * analyze SABM frame
         */
        forward = 0;
        ker_receive_sabm_frame(&forward, received_data);
        /*
         * set dlc value
         */
        dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
        if((forward & UART_FORWARD_SABM) &&
           (dlc->connection_state EQ UART_CONNECTION_SABM_RCVD) &&
           (uart_data->dlc_instance[dlci] NEQ UART_CONTROL_INSTANCE))
        {
          SET_STATE( UART_SERVICE_KER, KER_MUX );
          /*
           * stop timer
           */
          sig_ker_rt_stop_t3_req();
          /*
           * setup dlc parameter
           */
          uart_data->dlc_instance[dlci] = UART_CONTROL_INSTANCE;
          dlc->connection_state         = UART_CONNECTION_OPEN;
          /*
           * set priority
           */
          dlc->priority = 0;
          /*
           * send response frame
           */
          if(forward & UART_FORWARD_RESPONSE)
          {
            ker_mux_send_frame(received_data);
            /*
             * prepare next reception
             */
            MALLOC(received_data, (USHORT)(sizeof(T_desc2) - 1
                                                          + uart_data->n1
                                                          + 2));
            received_data->next = (ULONG)NULL;
          }
        }
      }
      /*
       * prepare next reception
       */
      received_data->len = 0;
      uart_data->ker.rx_data_desc = received_data;
      sig_ker_rx_ready_to_receive_req(received_data,
                                      0,
                                      (USHORT)(uart_data->n1 + 2));
      break;

    case KER_MUX:
      if(received_data->len EQ 0)
      {
        /*
         * prepare next reception
         */
        sig_ker_rx_ready_to_receive_req(received_data,
                                        write_pos,
                                        (USHORT)(uart_data->n1 + 2));
        break;
      }
      /*
       * analyze frame and messages
       */
      forward = 0;
      switch(received_data->buffer[UART_OFFSET_CONTROL])
      {
        case UART_SABM_FRAME:
          ker_receive_sabm_frame(&forward, received_data);
          break;

        case UART_UA_FRAME:
          ker_receive_ua_frame(&forward, received_data);
          break;

        case UART_DM_CONTROL_FRAME:
        case UART_DM_DATA_FRAME:
          ker_receive_dm_frame(&forward, received_data);
          break;

        case UART_DISC_FRAME:
          ker_receive_disc_frame(&forward, received_data);
          break;

        case UART_UIH_CONTROL_FRAME:
          ker_receive_uih_control_frame(&forward, received_data);
          break;

        case UART_UIH_DATA_FRAME:
          ker_receive_uih_data_frame(&forward, received_data);
          break;

        default:
        {
          TRACE_EVENT_P2("Warning: Unexpected HDLC value: %d, uart_kers.c(%d)",
                         received_data->buffer[UART_OFFSET_CONTROL], __LINE__);
          break;
        }
      }
      /*
       * remove resonded frames and send next frames in command queue
       */
      for(i=0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++)
      {
        dlc = &uart_data->dlc_table[i];
        switch(dlc->connection_state)
        {
          case UART_CONNECTION_OPEN:
          case UART_CONNECTION_DISC_SENT:
            if((dlc->last_command NEQ NULL) &&
               (dlc->last_command->buffer[UART_OFFSET_CONTROL] EQ
                UART_UIH_CONTROL_FRAME) &&
               (dlc->last_command->len EQ UART_OFFSET_INFO))
            {
              /*
               * remove responded UIH frame
               */
              MFREE_DESC2(dlc->last_command);
              dlc->last_command = NULL;
              uart_data->ker.nr_t2--;
              if( uart_data->ker.nr_t2 EQ 0 )
                sig_ker_rt_stop_t2_req();
            }
            if((dlc->last_command  EQ NULL) &&
               (dlc->next_command NEQ NULL))
            {
              T_desc2* temp_desc;
              /*
               * transmit next command frame
               */
              dlc->last_command       = dlc->next_command;
              dlc->next_command       = (T_desc2*)dlc->next_command->next;
              dlc->last_command->next = (ULONG)NULL;

              MALLOC(temp_desc, (USHORT)(sizeof( T_desc2 ) - 1 +
                                dlc->last_command->len));
              temp_desc->next = (ULONG)NULL;
              temp_desc->len  = dlc->last_command->len;
              memcpy(temp_desc->buffer,
                     dlc->last_command->buffer,
                     dlc->last_command->len);

              dlc->retransmissions = 0;
              ker_mux_send_frame(temp_desc);

              if(dlc->last_command->buffer[UART_OFFSET_CONTROL] EQ
                 UART_UIH_CONTROL_FRAME)
              {
                uart_data->ker.nr_t2++;
                sig_ker_rt_start_t2_req();
              }
              else
              {
                uart_data->ker.nr_t1++;
                sig_ker_rt_start_t1_req();
              }
            }
            break;

          case UART_CONNECTION_DEAD:
            break;

          default:
          {
            TRACE_EVENT_P2("Unexpected DLC connection state: %d, uart_kers.c(%d)",
                                                 dlc->connection_state, __LINE__);
            break;
          }
        }
      }
      /*
       * process results of analysis
       */
      if(forward)
      {
        for(i=0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++)
        {
          if(i NEQ UART_CONTROL_INSTANCE)
          {
            /*
             * set dlc values
             */
            dlc  = &uart_data->dlc_table[i];
            dlci = dlc->dlci;
            /*
             * channel to open
             */
            if((forward & UART_FORWARD_SABM) &&
               (dlc->connection_state EQ UART_CONNECTION_SABM_RCVD) &&
               (uart_data->dlc_instance[dlci] NEQ i))
            {
              PALLOC(uart_mux_dlc_establish_ind, UART_MUX_DLC_ESTABLISH_IND);
              /*
               * setup dlc parameter
               */
              uart_data->dlc_instance[dlci] = i;
              dlc->drx = &uart_data->drx_base[i];
              dlc->dtx = &uart_data->dtx_base[i];
              /*
               * set priority
               */
              if(dlci < 8)
                dlc->priority = 7;
              else if(dlci < 16)
                dlc->priority = 15;
              else if(dlci < 24)
                dlc->priority = 23;
              else if(dlci < 32)
                dlc->priority = 31;
              else if(dlci < 40)
                dlc->priority = 39;
              else if(dlci < 48)
                dlc->priority = 47;
              else if(dlci < 56)
                dlc->priority = 55;
              else
                dlc->priority = 61;
              /*
               * store response frame and
               * clear appropriate bit in forward mask
               */
              dlc->next_command = received_data;
              forward          &= ~UART_FORWARD_RESPONSE;
              /*
               * create new reception frame
               */
              MALLOC(received_data, (USHORT)(sizeof(T_desc2) - 1
                                                            + uart_data->n1
                                                            + 2));
              received_data->next = (ULONG)NULL;
              /*
               * inform ACI about new DLC
               */
              uart_mux_dlc_establish_ind->device = uart_data->device;
              uart_mux_dlc_establish_ind->dlci   = dlci;
              uart_mux_dlc_establish_ind->
                                     convergence = UART_MUX_CONVERGENCE_UOS;
              uart_mux_dlc_establish_ind->n1     = uart_data->n1;
              uart_mux_dlc_establish_ind->
                                         service = UART_MUX_SERVICE_AT;
              PSEND (hCommMMI, uart_mux_dlc_establish_ind);
            }
            /*
             * channel to close
             */
            if((forward & UART_FORWARD_DLC_RELEASE) &&
               (dlc->connection_state EQ UART_CONNECTION_DEAD) &&
               (dlci NEQ UART_DLCI_INVALID))
            {
              PALLOC(uart_mux_dlc_release_ind, UART_MUX_DLC_RELEASE_IND);
              /*
               * release channel
               */
              ker_mux_dlc_release(i);
              /*
               * inform ACI about DLC release
               */
              uart_mux_dlc_release_ind->device = uart_data->device;
              uart_mux_dlc_release_ind->dlci   = dlci;
              PSEND(hCommMMI, uart_mux_dlc_release_ind);
            }
            /*
             * set Flow Control ON
             */
            if((forward & UART_FORWARD_FCON) &&
               (dlc->connection_state EQ UART_CONNECTION_OPEN) &&
               (!(dlc->lines & UART_FC_RX_MASK)))
            {
              uart_data->drx = dlc->drx;
              sig_ker_drx_enable_req();
            }
            /*
             * set Flow Control OFF
             */
            if((forward & UART_FORWARD_FCOFF) &&
               (dlc->connection_state EQ UART_CONNECTION_OPEN) &&
               (!(dlc->lines & UART_FC_RX_MASK)))
            {
              uart_data->drx = dlc->drx;
              sig_ker_drx_disable_req();
            }
            /*
             * send status lines
             */
            if((forward & UART_FORWARD_MSC) &&
               (dlc->connection_state EQ UART_CONNECTION_OPEN))
            {
              UBYTE st_flow;
              UBYTE st_line_sa;
              UBYTE st_break_len;
              /*
               * send primitive if DTR drop is detected
               */
              if(dlc->lines & UART_DTR_MASK)
              {
                PALLOC (uart_detected_ind, UART_DETECTED_IND);
                uart_detected_ind->device = uart_data->device;
                uart_detected_ind->dlci   = dlc->dlci;
                uart_detected_ind->cause  = UART_DETECT_DTR;
                PSEND (hCommMMI, uart_detected_ind);
              }
              /*
               * set line states
               */
              if(dlc->lines & UART_RTS_MASK)
                st_flow = DTI_FLOW_OFF;
              else
                st_flow = DTI_FLOW_ON;
              if(dlc->lines & UART_DTR_MASK)
                st_line_sa = DTI_SA_OFF;
              else
                st_line_sa = DTI_SA_ON;
              /*
               * set break
               */
              if(dlc->lines & UART_BRK_RX_MASK)
                st_break_len = (UBYTE)((dlc->lines & UART_BRKLEN_RX_MASK) >>
                                                     UART_BRKLEN_RX_POS);
              else
                st_break_len = DTI_BREAK_OFF;
              /*
               * send flow control signals
               */
              if(uart_data->ker.data_flow_tx EQ UART_FLOW_ENABLED)
              {
                uart_data->drx = dlc->drx;
                if(dlc->lines & UART_FC_RX_MASK)
                  sig_ker_drx_disable_req();
                else
                  sig_ker_drx_enable_req();
              }
              /*
               * send line states
               */
              uart_data->dtx = dlc->dtx;
              sig_ker_dtx_line_states_req(st_flow,
                                          st_line_sa,
                                          DTI_SB_ON,
                                          st_break_len);
            }
          }
        }
        /*
         * send response frame
         */
        if(forward & UART_FORWARD_RESPONSE)
        {
          ker_mux_send_frame(received_data);
          uart_data->ker.rx_data_desc = NULL;
        }
        /*
         * Close-Down multiplexer
         */
        if(forward & UART_FORWARD_CLD)
        {
          SET_STATE( UART_SERVICE_KER, KER_MUX_CLOSED );
          /*
           * stop timers and
           * remove all DLC instances
           */
          ker_mux_close_down();
          /*
           * flush UART before change the state
           */
          if(uart_data->ker.tx_data_desc EQ NULL)
          {
            uart_data->ker.received_prim|= UART_MUX_CLOSE_REQ_MASK;

            if(uart_data->ker.flush_state EQ UART_KER_NOT_FLUSHING)
            {
              uart_data->ker.flush_state = UART_KER_TX_FLUSH;
              sig_ker_tx_flush_req();
            }
          }
        }
      }
      /*
       * prepare next reception
       */
      if(forward & UART_FORWARD_RESPONSE)
      {
        MALLOC(received_data, (USHORT)(sizeof(T_desc2) - 1
                                                      + uart_data->n1
                                                      + 2));
        received_data->next = (ULONG)NULL;
      }
      received_data->len = 0;
      uart_data->ker.rx_data_desc = received_data;
      sig_ker_rx_ready_to_receive_req(received_data,
                                      0,
                                      (USHORT)(uart_data->n1 + 2));
      break;

    case KER_MUX_DLC_CLOSING:
      if(received_data->len EQ 0)
      {
        /*
         * prepare next reception
         */
        sig_ker_rx_ready_to_receive_req(received_data,
                                        write_pos,
                                        (USHORT)(uart_data->n1 + 2));
        break;
      }
      /*
       * analyze frame and messages
       */
      forward = 0;
      switch(received_data->buffer[UART_OFFSET_CONTROL])
      {
        case UART_SABM_FRAME:
          ker_receive_sabm_frame(&forward, received_data);
          break;

        case UART_UA_FRAME:
          ker_receive_ua_frame(&forward, received_data);
          break;

        case UART_DM_CONTROL_FRAME:
        case UART_DM_DATA_FRAME:
          ker_receive_dm_frame(&forward, received_data);
          break;

        case UART_DISC_FRAME:
          ker_receive_disc_frame(&forward, received_data);
          break;

        case UART_UIH_CONTROL_FRAME:
          ker_receive_uih_control_frame(&forward, received_data);
          break;

        case UART_UIH_DATA_FRAME:
          ker_receive_uih_data_frame(&forward, received_data);
          break;

        default:
        {
          TRACE_EVENT_P2("Warning: Unexpected HDLC value: %d, uart_kers.c(%d)",
                         received_data->buffer[UART_OFFSET_CONTROL], __LINE__);
          break;
        }
      }
      /*
       * remove resonded frames and send next frames in command queue
       */
      for(i=0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++)
      {
        dlc = &uart_data->dlc_table[i];
        switch(dlc->connection_state)
        {
          case UART_CONNECTION_OPEN:
          case UART_CONNECTION_DISC_SENT:
            if((dlc->last_command NEQ NULL) &&
               (dlc->last_command->buffer[UART_OFFSET_CONTROL] EQ
                UART_UIH_CONTROL_FRAME) &&
               (dlc->last_command->len EQ UART_OFFSET_INFO))
            {
              /*
               * remove responded UIH frame
               */
              MFREE_DESC2(dlc->last_command);
              dlc->last_command = NULL;
              uart_data->ker.nr_t2--;
              if( uart_data->ker.nr_t2 EQ 0 )
                sig_ker_rt_stop_t2_req();
            }
            if((dlc->last_command  EQ NULL) &&
               (dlc->next_command NEQ NULL))
            {
              T_desc2* temp_desc;
              /*
               * transmit next command frame
               */
              dlc->last_command       = dlc->next_command;
              dlc->next_command       = (T_desc2*)dlc->next_command->next;
              dlc->last_command->next = (ULONG)NULL;

              MALLOC(temp_desc, (USHORT)(sizeof( T_desc2 ) - 1 +
                                dlc->last_command->len));
              temp_desc->next = (ULONG)NULL;
              temp_desc->len  = dlc->last_command->len;
              memcpy(temp_desc->buffer,
                     dlc->last_command->buffer,
                     dlc->last_command->len);

              dlc->retransmissions = 0;
              ker_mux_send_frame(temp_desc);

              if(dlc->last_command->buffer[UART_OFFSET_CONTROL] EQ
                 UART_UIH_CONTROL_FRAME)
              {
                uart_data->ker.nr_t2++;
                sig_ker_rt_start_t2_req();
              }
              else
              {
                uart_data->ker.nr_t1++;
                sig_ker_rt_start_t1_req();
              }
            }
            break;

          case UART_CONNECTION_DEAD:
            break;

          default:
          {
            TRACE_EVENT_P2("Unexpected DLC connection state: %d, uart_kers.c(%d)",
                                                 dlc->connection_state, __LINE__);
            break;
          }
        }
      }
      /*
       * process results of analysis
       */
      if(forward)
      {
        continuous = FALSE;
        for(i=0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++)
        {
          if(i NEQ UART_CONTROL_INSTANCE)
          {
            /*
             * set dlc values
             */
            dlc  = &uart_data->dlc_table[i];
            dlci = dlc->dlci;
            /*
             * channel to open
             */
            if((forward & UART_FORWARD_SABM) &&
               (dlc->connection_state EQ UART_CONNECTION_SABM_RCVD))
            {
              /*
               * reject all attempts to open a channel
               */
              received_data->buffer[UART_OFFSET_CONTROL] =
                UART_DM_CONTROL_FRAME;
              /*
               * release channel
               */
              ker_mux_dlc_release(i);
            }
            /*
             * channel to close
             */
            if((forward & UART_FORWARD_DLC_RELEASE) &&
               (dlc->connection_state EQ UART_CONNECTION_DEAD) &&
               (dlci NEQ UART_DLCI_INVALID))
            {
              /*
               * release channel
               */
              ker_mux_dlc_release(i);
            }
            if(dlc->connection_state NEQ UART_CONNECTION_DEAD)
              continuous = TRUE;
          }
        }
        /*
         * send response frame
         */
        if(forward & UART_FORWARD_RESPONSE)
        {
          ker_mux_send_frame(received_data);
          uart_data->ker.rx_data_desc = NULL;
        }
        /*
         * Close-Down multiplexer
         */
        if(forward & UART_FORWARD_CLD)
        {
          SET_STATE( UART_SERVICE_KER, KER_MUX_CLOSED );
          /*
           * stop timers and
           * remove all DLC instances
           */
          ker_mux_close_down();
          /*
           * flush UART before change the state
           */
          if(uart_data->ker.tx_data_desc EQ NULL)
          {
            uart_data->ker.received_prim|= UART_MUX_CLOSE_REQ_MASK;

            if(uart_data->ker.flush_state EQ UART_KER_NOT_FLUSHING)
            {
              uart_data->ker.flush_state = UART_KER_TX_FLUSH;
              sig_ker_tx_flush_req();
            }
          }
        }
        /*
         * change state if all channels are closed
         */
        else if(continuous EQ FALSE)
        {
          SET_STATE( UART_SERVICE_KER, KER_MUX_CLOSING );
          /*
           * build and send CLD command frame:
           */
          ker_mux_send_close_down();
          /*
           * start timer
           */
          sig_ker_rt_start_t3_req();
        }
      }
      /*
       * prepare next reception
       */
      if(forward & UART_FORWARD_RESPONSE)
      {
        MALLOC(received_data, (USHORT)(sizeof(T_desc2) - 1
                                                      + uart_data->n1
                                                      + 2));
        received_data->next = (ULONG)NULL;
      }
      received_data->len = 0;
      uart_data->ker.rx_data_desc = received_data;
      sig_ker_rx_ready_to_receive_req(received_data,
                                      0,
                                      (USHORT)(uart_data->n1 + 2));
      break;

    case KER_MUX_CLOSING:
      if(received_data->len EQ 0)
      {
        /*
         * prepare next reception
         */
        sig_ker_rx_ready_to_receive_req(received_data,
                                        write_pos,
                                        (USHORT)(uart_data->n1 + 2));
        break;
      }
      /*
       * analyze frame and messages
       */
      forward = 0;
      switch(received_data->buffer[UART_OFFSET_CONTROL])
      {
        case UART_SABM_FRAME:
          ker_receive_sabm_frame(&forward, received_data);
          break;

        case UART_UA_FRAME:
          ker_receive_ua_frame(&forward, received_data);
          break;

        case UART_DM_CONTROL_FRAME:
        case UART_DM_DATA_FRAME:
          ker_receive_dm_frame(&forward, received_data);
          break;

        case UART_DISC_FRAME:
          ker_receive_disc_frame(&forward, received_data);
          break;

        case UART_UIH_CONTROL_FRAME:
          ker_receive_uih_control_frame(&forward, received_data);
          break;

        case UART_UIH_DATA_FRAME:
          ker_receive_uih_data_frame(&forward, received_data);
          break;

        default:
        {
          TRACE_EVENT_P2("Warning: Unexpected HDLC value: %d, uart_kers.c(%d)",
                         received_data->buffer[UART_OFFSET_CONTROL], __LINE__);
          break;
        }
      }
      /*
       * remove resonded frames and send next frames in command queue
       */
      for(i=0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++)
      {
        dlc = &uart_data->dlc_table[i];
        switch(dlc->connection_state)
        {
          case UART_CONNECTION_OPEN:
          case UART_CONNECTION_DISC_SENT:
            if((dlc->last_command NEQ NULL) &&
               (dlc->last_command->buffer[UART_OFFSET_CONTROL] EQ
                UART_UIH_CONTROL_FRAME) &&
               (dlc->last_command->len EQ UART_OFFSET_INFO))
            {
              /*
               * remove responded UIH frame
               */
              MFREE_DESC2(dlc->last_command);
              dlc->last_command = NULL;
              uart_data->ker.nr_t2--;
              if( uart_data->ker.nr_t2 EQ 0 )
                sig_ker_rt_stop_t2_req();
            }
            if((dlc->last_command  EQ NULL) &&
               (dlc->next_command NEQ NULL))
            {
              T_desc2* temp_desc;
              /*
               * transmit next command frame
               */
              dlc->last_command       = dlc->next_command;
              dlc->next_command       = (T_desc2*)dlc->next_command->next;
              dlc->last_command->next = (ULONG)NULL;

              MALLOC(temp_desc, (USHORT)(sizeof( T_desc2 ) - 1 +
                                dlc->last_command->len));
              temp_desc->next = (ULONG)NULL;
              temp_desc->len  = dlc->last_command->len;
              memcpy(temp_desc->buffer,
                     dlc->last_command->buffer,
                     dlc->last_command->len);

              dlc->retransmissions = 0;
              ker_mux_send_frame(temp_desc);

              if(dlc->last_command->buffer[UART_OFFSET_CONTROL] EQ
                 UART_UIH_CONTROL_FRAME)
              {
                uart_data->ker.nr_t2++;
                sig_ker_rt_start_t2_req();
              }
              else
              {
                uart_data->ker.nr_t1++;
                sig_ker_rt_start_t1_req();
              }
            }
            break;

          case UART_CONNECTION_DEAD:
            break;

          default:
          {
            TRACE_EVENT_P2("Unexpected DLC connection state: %d, uart_kers.c(%d)",
                                                  dlc->connection_state,__LINE__);
            break;
          }
        }
      }
      /*
       * process results of analysis
       */
      if(forward)
      {
        for(i=0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++)
        {
          if(i NEQ UART_CONTROL_INSTANCE)
          {
            /*
             * set dlc values
             */
            dlc  = &uart_data->dlc_table[i];
            dlci = dlc->dlci;
            /*
             * channel to open
             */
            if((forward & UART_FORWARD_SABM) &&
               (dlc->connection_state EQ UART_CONNECTION_SABM_RCVD))
            {
              /*
               * reject all attempts to open a channel
               */
              received_data->buffer[UART_OFFSET_CONTROL] =
                UART_DM_CONTROL_FRAME;
              /*
               * release channel
               */
              ker_mux_dlc_release(i);
            }
            /*
             * channel to close
             */
            if((forward & UART_FORWARD_DLC_RELEASE) &&
               (dlc->connection_state EQ UART_CONNECTION_DEAD) &&
               (dlci NEQ UART_DLCI_INVALID))
            {
              /*
               * release channel
               */
              ker_mux_dlc_release(i);
            }
          }
        }
        /*
         * send response frame
         */
        if(forward & UART_FORWARD_RESPONSE)
        {
          ker_mux_send_frame(received_data);
          uart_data->ker.rx_data_desc = NULL;
        }
        /*
         * Close-Down multiplexer
         */
        if(forward & UART_FORWARD_CLD)
        {
          SET_STATE( UART_SERVICE_KER, KER_MUX_CLOSED );
          /*
           * stop timers and
           * remove all DLC instances
           */
          ker_mux_close_down();
          /*
           * flush UART before change the state
           */
          if(uart_data->ker.tx_data_desc EQ NULL)
          {
            uart_data->ker.received_prim|= UART_MUX_CLOSE_REQ_MASK;

            if(uart_data->ker.flush_state EQ UART_KER_NOT_FLUSHING)
            {
              uart_data->ker.flush_state = UART_KER_TX_FLUSH;
              sig_ker_tx_flush_req();
            }
          }
        }
      }
      /*
       * prepare next reception
       */
      if(forward & UART_FORWARD_RESPONSE)
      {
        MALLOC(received_data, (USHORT)(sizeof(T_desc2) - 1
                                                      + uart_data->n1
                                                      + 2));
        received_data->next = (ULONG)NULL;
      }
      received_data->len = 0;
      uart_data->ker.rx_data_desc = received_data;
      sig_ker_rx_ready_to_receive_req(received_data,
                                      0,
                                      (USHORT)(uart_data->n1 + 2));
      break;

    case KER_MUX_CLOSED:
      if((uart_data->ker.tx_data_desc EQ NULL) &&
         (uart_data->ker.flush_state EQ UART_KER_NOT_FLUSHING))
      {
        PALLOC(uart_mux_close_ind, UART_MUX_CLOSE_IND);
        SET_STATE( UART_SERVICE_KER, KER_READY );
        /*
         * free receiving buffer
         */
        MFREE_DESC2(uart_data->ker.rx_data_desc);
        uart_data->ker.rx_data_desc = NULL;
        /*
         * set dlc values
         */
        dlc            = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
        dlc->drx       = &uart_data->drx_base[0];
        dlc->dtx       = &uart_data->dtx_base[0];
        dlc->dlci      = 0;
        dlc->priority  = 0;
        /*
         * set RX and TX in ready mode
         */
        sig_ker_rx_ready_mode_req();
        sig_ker_tx_ready_mode_req();
        /*
         * set frame size for ready mode
         */
        uart_data->n1 = UART_N1_READY_MODE;
        /*
         * set DRX and DTX in ready mode
         */
        uart_data->dtx = dlc->dtx;
        uart_data->drx = dlc->drx;
        sig_ker_drx_ready_mode_req(UART_CONTROL_INSTANCE);
        sig_ker_dtx_ready_mode_req(UART_CONTROL_INSTANCE);
        /*
         * inform ACI about entering ready mode
         */
        uart_mux_close_ind->device = uart_data->device;
        PSEND(hCommMMI, uart_mux_close_ind);
      }
      else if(received_data->len EQ 0)
      {
        /*
         * prepare next reception
         */
        sig_ker_rx_ready_to_receive_req(received_data,
                                        write_pos,
                                        (USHORT)(uart_data->n1 + 2));
      }
      else
      {
        /*
         * prepare next reception
         */
        received_data->len = 0;
        sig_ker_rx_ready_to_receive_req(received_data,
                                        0,
                                        (USHORT)(uart_data->n1 + 2));
      }
      break;

    default:
      TRACE_ERROR( "SIG_RX_KER_DATA_RECEIVED_IND unexpected" );
      break;
  }
} /* sig_rx_ker_data_received_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_rx_ker_line_states_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_RX_KER_LINE_STATES_IND
|
| Parameters  : line_states - new line states
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_rx_ker_line_states_ind (ULONG line_states)
{
  T_DLC*  dlc;
  UBYTE   st_flow;
  UBYTE   st_line_sa;
  UBYTE   st_line_sb;
  UBYTE   st_break_len;

  TRACE_ISIG( "sig_rx_ker_line_states_ind" );

  /*
   * set DLC
   */
  dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
  /*
   * send primitive if escape sequence or DTR drop is detected
   */
  if(line_states & UART_ESC_RX_MASK)
  {
    PALLOC (uart_detected_ind, UART_DETECTED_IND);
    uart_detected_ind->device = uart_data->device;
    uart_detected_ind->dlci   = dlc->dlci;
    uart_detected_ind->cause  = UART_DETECT_ESC;
    PSEND (hCommMMI, uart_detected_ind);
  }
  if((line_states & UART_DTR_MASK) AND
     (!(dlc->lines & UART_DTR_MASK)))
  {
    PALLOC (uart_detected_ind, UART_DETECTED_IND);
    uart_detected_ind->device = uart_data->device;
    uart_detected_ind->dlci   = dlc->dlci;
    uart_detected_ind->cause  = UART_DETECT_DTR;
    PSEND (hCommMMI, uart_detected_ind);
  }

  switch( GET_STATE( UART_SERVICE_KER ) )
  {
    case KER_READY:
      /*
       * set line states
       */
      if(line_states & UART_X_RX_MASK)
        st_flow = DTI_FLOW_OFF;
      else
        st_flow = DTI_FLOW_ON;

      if(line_states & UART_SA_RX_MASK)
        st_line_sa = DTI_SA_OFF;
      else
        st_line_sa = DTI_SA_ON;

      if(line_states & UART_SB_RX_MASK)
        st_line_sb = DTI_SB_OFF;
      else
        st_line_sb = DTI_SB_ON;

      if(line_states & UART_BRK_RX_MASK)
        st_break_len = (UBYTE)((line_states & UART_BRKLEN_RX_MASK)
                               >> UART_BRKLEN_RX_POS);
      else
        st_break_len = DTI_BREAK_OFF;

      uart_data->dtx = dlc->dtx;
      sig_ker_dtx_line_states_req(st_flow,
                                  st_line_sa,
                                  st_line_sb,
                                  st_break_len);
      break;

    case KER_MUX_ESTABLISH:
    case KER_MUX:
    case KER_MUX_DLC_CLOSING:
    case KER_MUX_CLOSING:
    case KER_MUX_CLOSED:
      break;

    default:
      TRACE_ERROR( "SIG_RX_KER_LINE_STATES_IND unexpected" );
      break;
  }
  /*
   * store new line states
   */
  dlc->lines &= ~(UART_X_RX_MASK   |
                  UART_SA_RX_MASK  |
                  UART_SB_RX_MASK  |
                  UART_ESC_RX_MASK |
                  UART_BRK_RX_MASK |
                  UART_BRKLEN_RX_MASK);
  line_states&= ~(UART_ESC_RX_MASK |
                  UART_BRK_RX_MASK |
                  UART_BRKLEN_RX_MASK);
  dlc->lines |= line_states;
} /* sig_rx_ker_line_states_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_rt_ker_timeout_t1_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_RT_KER_TIMEOUT_T1_IND
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_rt_ker_timeout_t1_ind ()
{
  UBYTE   i;
  T_desc2* temp_desc;
  T_DLC*  dlc;
  UBYTE   j;
  UBYTE   dlci;
  ULONG   forward;
  BOOL    continuous;

  TRACE_ISIG( "sig_rt_ker_timeout_t1_ind" );

  for( i = 0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++ )
  {
    /*
     * set dlc value
     */
    dlc = &uart_data->dlc_table[i];
    switch(dlc->connection_state)
    {
      case UART_CONNECTION_OPEN:
      case UART_CONNECTION_DISC_SENT:
        /*
         * T1 is used for non UIH Control frames
         */
        if((dlc->last_command NEQ NULL) &&
           (dlc->last_command->buffer[UART_OFFSET_CONTROL] NEQ
             UART_UIH_CONTROL_FRAME))
        {
          if(dlc->retransmissions < uart_data->ker.n2)
          {
            /*
             * retransmission of Control frame
             */
            dlc->retransmissions++;
            MALLOC(temp_desc, (USHORT)(sizeof( T_desc2 ) - 1
              + dlc->last_command->len));

            temp_desc->next = (ULONG)NULL;
            temp_desc->len  = dlc->last_command->len;
            memcpy(temp_desc->buffer,
                   dlc->last_command->buffer,
                   dlc->last_command->len);

            ker_mux_send_frame( temp_desc );
          }
          else
          {
            /*
             * maximum number of retransmissions reached
             */
            switch( GET_STATE( UART_SERVICE_KER ) )
            {
              case KER_MUX:
                /*
                 * act as on reception of a DM frame
                 */
                /*
                 * create DM frame
                 */
                MALLOC(temp_desc, (USHORT)(sizeof( T_desc2 ) - 1 + 2));
                temp_desc->next = (ULONG)NULL;
                temp_desc->len  = 2;
                memcpy(temp_desc->buffer, dlc->last_command->buffer, 2)
                ;/*lint !e419 !e420 apparent data overrun and access beyond array*/
                temp_desc->buffer[UART_OFFSET_CONTROL] = UART_DM_CONTROL_FRAME;
                /*
                 * act as on reception of a DM frame
                 */
                forward = 0;
                ker_receive_dm_frame(&forward, temp_desc);
                /*
                 * process results of analysis
                 */
                if(forward)
                {
                  for(j=0; j <= UART_MAX_NUMBER_OF_CHANNELS; j++)
                  {
                    if(j NEQ UART_CONTROL_INSTANCE)
                    {
                      /*
                       * set dlc values
                       */
                      dlc  = &uart_data->dlc_table[j];
                      dlci = dlc->dlci;
                      /*
                       * channel to close
                       */
                      if((forward & UART_FORWARD_DLC_RELEASE) &&
                         (dlc->connection_state EQ UART_CONNECTION_DEAD) &&
                         (dlci NEQ UART_DLCI_INVALID))
                      {
                        PALLOC(uart_mux_dlc_release_ind,
                               UART_MUX_DLC_RELEASE_IND);
                        /*
                         * release channel
                         */
                        ker_mux_dlc_release(j);
                        /*
                         * inform ACI about DLC release
                         */
                        uart_mux_dlc_release_ind->device = uart_data->device;
                        uart_mux_dlc_release_ind->dlci   = dlci;
                        PSEND(hCommMMI, uart_mux_dlc_release_ind);
                      }
                    }
                  }
                }
                break;

              case KER_MUX_DLC_CLOSING:
                /*
                 * act as on reception of a DM frame
                 */
                /*
                 * create DM frame
                 */
                MALLOC(temp_desc, (USHORT)(sizeof( T_desc2 ) - 1 + 2));
                temp_desc->next = (ULONG)NULL;
                temp_desc->len  = 2;
                memcpy(temp_desc->buffer, dlc->last_command->buffer, 2)
                ;/*lint !e419 !e420 apparent data overrun and access beyond array*/
                temp_desc->buffer[UART_OFFSET_CONTROL] = UART_DM_CONTROL_FRAME;
                /*
                 * act as on reception of a DM frame
                 */
                forward = 0;
                ker_receive_dm_frame(&forward, temp_desc);
                /*
                 * process results of analysis
                 */
                if(forward)
                {
                  continuous = FALSE;
                  for(j=0; j <= UART_MAX_NUMBER_OF_CHANNELS; j++)
                  {
                    if(j NEQ UART_CONTROL_INSTANCE)
                    {
                      /*
                       * set dlc values
                       */
                      dlc  = &uart_data->dlc_table[j];
                      dlci = dlc->dlci;
                      /*
                       * channel to close
                       */
                      if((forward & UART_FORWARD_DLC_RELEASE) &&
                         (dlc->connection_state EQ UART_CONNECTION_DEAD) &&
                         (dlci NEQ UART_DLCI_INVALID))
                      {
                        /*
                         * release channel
                         */
                        ker_mux_dlc_release(j);
                      }
                      if(dlc->connection_state NEQ UART_CONNECTION_DEAD)
                        continuous = TRUE;
                    }
                  }
                  /*
                   * change state if all channels are closed
                   */
                  if(continuous EQ FALSE)
                  {
                    SET_STATE( UART_SERVICE_KER, KER_MUX_CLOSING );
                    /*
                     * build and send CLD command frame:
                     */
                    ker_mux_send_close_down();
                    /*
                     * start timer
                     */
                    sig_ker_rt_start_t3_req();
                  }
                }
                break;

              case KER_MUX_CLOSING:
                /*
                 * do not care about retransmission couter
                 * retransmission stops if T3 expires
                 */
                dlc->retransmissions++;
                MALLOC(temp_desc, (USHORT)(sizeof( T_desc2 ) - 1
                  + dlc->last_command->len));

                temp_desc->next = (ULONG)NULL;
                temp_desc->len  = dlc->last_command->len;
                memcpy(temp_desc->buffer,
                       dlc->last_command->buffer,
                       dlc->last_command->len);

                ker_mux_send_frame( temp_desc );
                break;

              default:
                TRACE_ERROR( "SIG_RT_KER_TIMEOUT_T1_IND unexpected" );
                break;
            }
          }
        }
        break;

      case UART_CONNECTION_DEAD:
        break;

      default:
      {
        TRACE_EVENT_P2("Unexpected DLC connection state: %d, uart_kers.c(%d)",
                                             dlc->connection_state, __LINE__);
        break;
      }
    }
  }
  if(uart_data->ker.nr_t1)
  {
    /*
     * restart timer t1
     */
    sig_ker_rt_start_t1_req();
  }
} /* sig_rt_ker_timeout_t1_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_rt_ker_timeout_t2_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_RT_KER_TIMEOUT_T2_IND
|
|               This signal means that no response to a sent command frame
|               was received within the allowed time. It is assumed that
|               the frame has been lost and a retransmission is done if the
|               maximum number of retransmissions is not reached yet.
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_rt_ker_timeout_t2_ind ()
{
  UBYTE   i;
  T_desc2* temp_desc;
  T_DLC*  dlc;

  TRACE_ISIG( "sig_rt_ker_timeout_t2_ind" );

  for( i = 0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++ )
  {
    /*
     * set dlc value
     */
    dlc = &uart_data->dlc_table[i];
    switch(dlc->connection_state)
    {
      case UART_CONNECTION_OPEN:
      case UART_CONNECTION_DISC_SENT:
        /*
         * T2 is only used for UIH Control frames
         */
        if((dlc->last_command NEQ NULL) &&
           (dlc->last_command->buffer[UART_OFFSET_CONTROL] EQ
             UART_UIH_CONTROL_FRAME))
        {
          if(dlc->retransmissions < uart_data->ker.n2)
          {
            /*
             * retransmission of Control frame
             */
            dlc->retransmissions++;
            MALLOC(temp_desc, (USHORT)(sizeof( T_desc2 ) - 1
              + dlc->last_command->len));

            temp_desc->next = (ULONG)NULL;
            temp_desc->len  = dlc->last_command->len;
            memcpy(temp_desc->buffer,
                   dlc->last_command->buffer,
                   dlc->last_command->len);

            ker_mux_send_frame( temp_desc );
          }
          else
          {
            /*
             * maximum number of retransmissions reached
             */
            switch( GET_STATE( UART_SERVICE_KER ) )
            {
              case KER_MUX:
              case KER_MUX_DLC_CLOSING:
                /*
                 * skip this frame and send next frame
                 */
                /*
                 * remove current UIH frame
                 */
                MFREE_DESC2(dlc->last_command);
                dlc->last_command = NULL;
                uart_data->ker.nr_t2--;
                if(dlc->next_command)
                {
                  /*
                   * transmit next command frame
                   */
                  dlc->last_command       = dlc->next_command;
                  dlc->next_command       = (T_desc2*)dlc->next_command->next;
                  dlc->last_command->next = (ULONG)NULL;

                  MALLOC(temp_desc, (USHORT)(sizeof( T_desc2 ) - 1 +
                                    dlc->last_command->len));
                  temp_desc->next = (ULONG)NULL;
                  temp_desc->len  = dlc->last_command->len;
                  memcpy(temp_desc->buffer,
                         dlc->last_command->buffer,
                         dlc->last_command->len);

                  dlc->retransmissions = 0;
                  ker_mux_send_frame(temp_desc);
                  uart_data->ker.nr_t2++;
                }
                break;

              case KER_MUX_CLOSING:
                /*
                 * do not care about retransmission couter
                 * retransmission stops if T3 expires
                 */
                dlc->retransmissions++;
                MALLOC(temp_desc, (USHORT)(sizeof( T_desc2 ) - 1
                  + dlc->last_command->len));

                temp_desc->next = (ULONG)NULL;
                temp_desc->len  = dlc->last_command->len;
                memcpy(temp_desc->buffer,
                       dlc->last_command->buffer,
                       dlc->last_command->len);

                ker_mux_send_frame( temp_desc );
                break;

              default:
                TRACE_ERROR( "SIG_RT_KER_TIMEOUT_T2_IND unexpected" );
                break;
            }
          }
        }
        break;

      case UART_CONNECTION_DEAD:
        break;

      default:
      {
        TRACE_EVENT_P2("Unexpected DLC connection state: %d, uart_kers.c(%d)",
                                             dlc->connection_state, __LINE__);
        break;
      }
    }
  }
  if(uart_data->ker.nr_t2)
  {
    /*
     * restart timer t2
     */
    sig_ker_rt_start_t2_req();
  }
} /* sig_rt_ker_timeout_t2_ind() */



/*
+------------------------------------------------------------------------------
| Function    : sig_rt_ker_timeout_t3_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_RT_KER_TIMEOUT_T3_IND
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_rt_ker_timeout_t3_ind ()
{
  TRACE_ISIG( "sig_rt_ker_timeout_t3_ind" );

  switch( GET_STATE( UART_SERVICE_KER ) )
  {
    case KER_MUX_ESTABLISH:
    case KER_MUX_CLOSING:
      SET_STATE( UART_SERVICE_KER, KER_MUX_CLOSED );
      /*
       * stop timers and
       * remove all DLC instances
       */
      ker_mux_close_down();
      if(uart_data->ker.tx_data_desc EQ NULL)
      {
        uart_data->ker.received_prim|= UART_MUX_CLOSE_REQ_MASK;

        if(uart_data->ker.flush_state EQ UART_KER_NOT_FLUSHING)
        {
          uart_data->ker.flush_state = UART_KER_TX_FLUSH;
          sig_ker_tx_flush_req();
        }
      }
      break;

    default:
      TRACE_ERROR( "SIG_RT_KER_TIMEOUT_T3_IND unexpected" );
      break;
  }
} /* sig_rt_ker_timeout_t3_ind() */


/*
+------------------------------------------------------------------------------
| Function    : sig_rt_ker_timeout_tesd_ind
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_RT_KER_TIMEOUT_TESD_IND
|
|               This signal means that the trailing guard period has completed.
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_rt_ker_timeout_tesd_ind ()
{
  UBYTE   i;

  TRACE_ISIG( "sig_rt_ker_timeout_tesd_ind" );

  switch( GET_STATE( UART_SERVICE_KER ) )
  {
    case KER_READY:
    case KER_MUX:
      for( i = 0; i < UART_MAX_NUMBER_OF_CHANNELS; i++ )
      { /*
         * set current dtx
         */
        uart_data->dtx = &uart_data->dtx_base[i];
        sig_ker_dtx_timeout_tesd_req();
      }
      break;

    default:
      TRACE_ERROR( "SIG_RT_KER_TIMEOUT_TESD_IND unexpected" );
      break;
  }
} /* sig_rt_ker_timeout_tesd_ind() */