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