+
−/*
+
−+-----------------------------------------------------------------------------
+
−|  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 module implements the process body interface
+
−|             for the entity Universal Asynchronous Receiver Transmitter(UART)
+
−|
+
−|             Exported functions:
+
−|
+
−|             pei_create    - Create the Protocol Stack Entity
+
−|             pei_init      - Initialize Protocol Stack Entity
+
−|             pei_primitive - Process Primitive
+
−|             pei_timeout   - Process Timeout
+
−|             pei_exit      - Close resources and terminate
+
−|             pei_run       - Process Primitive
+
−|             pei_config    - Dynamic Configuration
+
−|             pei_monitor   - Monitoring of physical Parameters
+
−+-----------------------------------------------------------------------------
+
−*/
+
−
+
−#define UART_PEI_C
+
−
+
−#include "config.h"
+
−#include "fixedconf.h"
+
−#include "condat-features.h"
+
−
+
−#define ENTITY_UART
+
−
+
−/*==== INCLUDES =============================================================*/
+
−
+
−#ifdef _SIMULATION_
+
−#include <stdio.h>
+
−#endif /* _SIMULATION_ */
+
−#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 */
+
−#ifdef DTILIB
+
−#ifdef _SIMULATION_
+
−/* #define UART_DTI_CONFIG  -- presently not needed -- */
+
−#include "tok.h"        /* string management for pei_config() */
+
−#endif /* _SIMULATION_ */
+
−#include "dti.h"        /* to get dti lib */
+
−#endif /* DTILIB */
+
−#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 "../../serial/serialswitch.h"
+
−#include "../../serial/traceswitch.h"
+
−#else /* _TARGET_ */
+
−#include "serial_dat.h" /* to get definitions of serial driver */
+
−#endif /* _TARGET_ */
+
−#endif /* FF_MULTI_PORT */
+
−#include "uart.h"       /* to get the global entity definitions */
+
−
+
−#include "uart_kerf.h"  /* to get ker functions */
+
−#include "uart_kerp.h"  /* to get ker primitives */
+
−#include "uart_kers.h"  /* to get ker signals */
+
−
+
−#ifndef FF_MULTI_PORT
+
−#include "uart_rxf.h"   /* to get rx functions */
+
−#include "uart_rxp.h"   /* to get rx primitives */
+
−#include "uart_rxs.h"   /* to get rx signals */
+
−
+
−#include "uart_txf.h"   /* to get tx functions */
+
−#include "uart_txp.h"   /* to get tx primitives */
+
−#include "uart_txs.h"   /* to get tx signals */
+
−#else
+
−#include "uart_prxf.h"  /* to get rx functions */
+
−#include "uart_prxp.h"  /* to get rx primitives */
+
−#include "uart_prxs.h"  /* to get rx signals */
+
−
+
−#include "uart_ptxf.h"  /* to get tx functions */
+
−#include "uart_ptxp.h"  /* to get tx primitives */
+
−#include "uart_ptxs.h"  /* to get tx signals */
+
−#endif /* FF_MULTI_PORT */
+
−
+
−#include "uart_drxf.h"  /* to get drx functions */
+
−#include "uart_drxp.h"  /* to get drx primitives */
+
−#include "uart_drxs.h"  /* to get drx signals */
+
−
+
−#include "uart_dtxf.h"  /* to get dtx functions */
+
−#include "uart_dtxp.h"  /* to get dtx primitives */
+
−#include "uart_dtxs.h"  /* to get dtx signals */
+
−
+
−#include "uart_rtf.h"   /* to get dtx functions */
+
−#include "uart_rtp.h"   /* to get dtx primitives */
+
−#include "uart_rts.h"   /* to get dtx signals */
+
−
+
−
+
−/*==== DEFINITIONS ==========================================================*/
+
−
+
−/*
+
− * Prototypes for DTILIB wrap functions
+
− */
+
−LOCAL void pei_dti_dti_connect_req (T_DTI2_CONNECT_REQ* dti_connect_req);
+
−LOCAL void pei_dti_dti_connect_res (T_DTI2_CONNECT_RES* dti_connect_res);
+
−LOCAL void pei_dti_dti_disconnect_req (T_DTI2_DISCONNECT_REQ*
+
−                                          dti_disconnect_req);
+
−LOCAL void pei_dti_dti_getdata_req (T_DTI2_GETDATA_REQ* dti_getdata_req);
+
−LOCAL void pei_dti_dti_data_req (T_DTI2_DATA_REQ* dti_data_req);
+
−LOCAL void pei_dti_dti_connect_ind (T_DTI2_CONNECT_IND* dti_connect_ind);
+
−LOCAL void pei_dti_dti_connect_cnf (T_DTI2_CONNECT_CNF* dti_connect_cnf);
+
−LOCAL void pei_dti_dti_disconnect_ind (T_DTI2_DISCONNECT_IND*
+
−                                          dti_disconnect_ind);
+
−LOCAL void pei_sig_callback(U8 instance,
+
−                            U8 interfac,
+
−                            U8 channel,
+
−                            U8 reason,
+
−                            T_DTI2_DATA_IND *dti_data2_ind);
+
−#ifdef _SIMULATION_
+
−LOCAL void pei_dti_dti_data_test_req (T_DTI2_DATA_TEST_REQ* dti_data_test_req);
+
−LOCAL void pei_dti_dti_ready_ind (T_DTI2_READY_IND* dti_ready_ind);
+
−LOCAL void pei_dti_dti_data_ind (T_DTI2_DATA_IND* dti_data_ind);
+
−#endif /* _SIMULATION_ */
+
−
+
−/*==== TYPES ================================================================*/
+
−
+
−/*
+
− * global table which maps a timer index to an UART instancen and timer number
+
− */
+
−typedef struct /* T_UART_TIMER_TABLE */
+
−{
+
−  T_UART_DATA*  uart_data;      /* pointer to UART data of the instance */
+
−  UBYTE         timer_number;   /* number of timer within the instance */
+
−} T_UART_TIMER_TABLE;
+
−
+
−/*==== GLOBAL VARS ==========================================================*/
+
−
+
−/*
+
− * global table which maps a timer index to an UART instancen and timer number
+
− */
+
−T_UART_TIMER_TABLE        uart_timer_table[ UART_TIMER_MAX ];
+
−
+
−#ifdef DTILIB
+
−  DTI_HANDLE uart_hDTI = D_NO_DATA_BASE;
+
−#endif /* DTILIB */
+
−#ifdef UART_DTI_CONFIG
+
−  ULONG      drv_link_id = -1;
+
−#endif /* UART_DTI_CONFIG */
+
−/*==== LOCAL VARS ===========================================================*/
+
−
+
−static  BOOL          first_access  = TRUE;
+
−static  T_MONITOR     uart_mon;
+
−
+
−/*
+
− * Jumptables to primitive handler functions. One table per SAP.
+
− *
+
− * Use MAK_FUNC_0 for primitives which contains no SDU.
+
− * Use MAK_FUNC_S for primitives which contains a SDU.
+
− */
+
−
+
−/*
+
− * Function is needed for developing. This declaration can be removed
+
− * as soon as this function is no more called (i.e. all primitives are
+
− * handled).
+
− */
+
−LOCAL void primitive_not_supported (void *data);
+
−
+
−/*qqq hier reinkommende, mit SAP vergleichen, S: mit sdu*/
+
−static const T_FUNC uart_table[] =
+
−{
+
−  MAK_FUNC_0(ker_uart_parameters_req,     UART_PARAMETERS_REQ),     /* 0x7400 */
+
−  MAK_FUNC_0(ker_uart_dti_req,            UART_DTI_REQ),            /* 0x7401 */
+
−  MAK_FUNC_0(ker_uart_disable_req,        UART_DISABLE_REQ),        /* 0x7402 */
+
−  MAK_FUNC_0(ker_uart_ring_req,           UART_RING_REQ),           /* 0x7403 */
+
−  MAK_FUNC_0(ker_uart_dcd_req,            UART_DCD_REQ),            /* 0x7404 */
+
−  MAK_FUNC_0(ker_uart_escape_req,         UART_ESCAPE_REQ),         /* 0x7405 */
+
−  MAK_FUNC_0(ker_uart_mux_start_req,      UART_MUX_START_REQ),      /* 0x7406 */
+
−  MAK_FUNC_0(ker_uart_mux_dlc_establish_res,
+
−                                       UART_MUX_DLC_ESTABLISH_RES), /* 0x7408 */
+
−  MAK_FUNC_0(ker_uart_mux_dlc_release_req,UART_MUX_DLC_RELEASE_REQ),/* 0x7409 */
+
−  MAK_FUNC_0(ker_uart_mux_sleep_req,      UART_MUX_SLEEP_REQ),      /* 0x740a */
+
−  MAK_FUNC_0(ker_uart_mux_wakeup_req,     UART_MUX_WAKEUP_REQ),     /* 0x740b */
+
−  MAK_FUNC_0(ker_uart_mux_close_req,      UART_MUX_CLOSE_REQ),      /* 0x740c */
+
−/*
+
−  UART_DRIVER_SENT_IND           0x740d
+
−  UART_DRIVER_RECEIVED_IND       0x740e
+
−  UART_DRIVER_FLUSHED_IND        0x740f
+
−*/
+
−};
+
−
+
−/*
+
− * Jumptable for the DTI service access point for uplink data transmission.
+
− * Contains the processing-function addresses and opcodes of
+
− * request and response primitives. Use of DTILIB can be selected.
+
− *
+
− */
+
−static const T_FUNC dti_dti_ul_table[] = {
+
−  MAK_FUNC_0( pei_dti_dti_connect_req       ,   DTI2_CONNECT_REQ   ),
+
−  MAK_FUNC_0( pei_dti_dti_connect_res       ,   DTI2_CONNECT_RES   ),
+
−  MAK_FUNC_0( pei_dti_dti_disconnect_req,       DTI2_DISCONNECT_REQ),
+
−  MAK_FUNC_0( pei_dti_dti_getdata_req       ,   DTI2_GETDATA_REQ   ),
+
−  MAK_FUNC_0( pei_dti_dti_data_req          ,   DTI2_DATA_REQ      ),
+
−#if defined (_SIMULATION_)
+
−  MAK_FUNC_S( pei_dti_dti_data_test_req     ,   DTI2_DATA_TEST_REQ )
+
−#else /* _SIMULATION_ */
+
−  MAK_FUNC_S( primitive_not_supported       ,   DTI2_DATA_TEST_REQ )
+
−#endif  /* _SIMULATION_ */
+
−};
+
−#if defined (DTILIB) && defined (_SIMULATION_)
+
−static const T_FUNC dti_dti_dl_table[] = {
+
−  MAK_FUNC_0( pei_dti_dti_connect_ind    ,   DTI2_CONNECT_IND   ),
+
−  MAK_FUNC_0( pei_dti_dti_connect_cnf    ,   DTI2_CONNECT_CNF   ),
+
−  MAK_FUNC_0( pei_dti_dti_disconnect_ind ,   DTI2_DISCONNECT_IND),
+
−  MAK_FUNC_0( tx_dti_ready_ind           ,   DTI2_READY_IND     ),
+
−  MAK_FUNC_0( primitive_not_supported    ,   DTI2_DATA_IND      ),
+
−  MAK_FUNC_S( rx_dti_data_test_ind       ,   DTI2_DATA_TEST_IND ),
+
−  MAK_FUNC_0( pei_dti_dti_ready_ind      ,   DTI2_READY_IND     ),
+
−  MAK_FUNC_0( pei_dti_dti_data_ind       ,   DTI2_DATA_IND      ),
+
−  MAK_FUNC_S( primitive_not_supported    ,   DTI2_DATA_TEST_IND )
+
−};
+
−#endif /*defined (DTILIB) && defined (_SIMULATION_)*/
+
−
+
−/*==== DIAGNOSTICS ==========================================================*/
+
−#ifdef _DEBUG
+
−#endif /* _DEBUG */
+
−
+
−/*==== END DIAGNOSTICS ======================================================*/
+
−
+
−/*==== PRIVATE FUNCTIONS ====================================================*/
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : primitive_not_supported
+
−+------------------------------------------------------------------------------
+
−| Description :  This function handles unsupported primitives.
+
−|
+
−| Parameters  : -
+
−|
+
−| Return      : -
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL void primitive_not_supported (void *data)
+
−{
+
−  TRACE_FUNCTION ("primitive_not_supported");
+
−
+
−  PFREE (data);
+
−}
+
−
+
−
+
−/*==== PUBLIC FUNCTIONS =====================================================*/
+
−
+
−/* qqq hier malen
+
−+------------------------------------------------------------------------------
+
−|       Function        : pei_primitive
+
−+------------------------------------------------------------------------------
+
−|       Description     : This function is called by the frame when a primitive
+
−|                         is received and needs to be processed.
+
−|
+
−|                            |        |
+
−|                           ACI      DTI                 UPLINK
+
−|                            |        |
+
−|                   +--------v--------v--------+
+
−|                   |                          |
+
−|                   |           UART           |
+
−|                   |                          |
+
−|                   +--------------------------+
+
−|
+
−|
+
−|       Parameters      :       prim      - Pointer to the received primitive
+
−|
+
−|       Return          :       PEI_OK    - function succeeded
+
−|                               PEI_ERROR - function failed
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−/*qqq hier kucken*/
+
−LOCAL SHORT pei_primitive (void * primptr)
+
−{
+
−  TRACE_FUNCTION ("pei_primitive");
+
−
+
−  if (primptr NEQ NULL)
+
−  {
+
−    T_PRIM* prim = (T_PRIM*)primptr;
+
−    USHORT  opc  = (USHORT)prim->custom.opc;
+
−    USHORT  n;
+
−    const T_FUNC    *table;
+
−
+
−    /*
+
−     * This must be called for Partition Pool supervision. Will be replaced
+
−     * by another macro some time.
+
−     */
+
−    VSI_PPM_REC (&prim->custom, __FILE__, __LINE__);
+
−    PTRACE_IN (opc);
+
−
+
−    switch (opc & OPC_MASK)
+
−    {
+
−      case UART_DL:
+
−        table = uart_table;
+
−        n = TAB_SIZE (uart_table);
+
−        break;
+
−      case DTI2_UL:
+
−#ifdef DTILIB
+
−        table = dti_dti_ul_table;
+
−        n = TAB_SIZE (dti_dti_ul_table);
+
−#ifdef DTI2
+
−        /*
+
−         * to be able to distinguish DTI1/DTI2 opcodes,
+
−         * the ones for DTI2 start at 0x50
+
−         */
+
−        opc -= 0x50;
+
−#endif /* DTI2*/
+
−#else  /* DTILIB */
+
−        table = dti_ul_table;
+
−        n = TAB_SIZE (dti_ul_table);
+
−#endif /* DTILIB */
+
−        break;
+
−#ifdef _SIMULATION_
+
−      case DTI2_DL:
+
−#ifdef DTILIB
+
−        table = dti_dti_dl_table;
+
−        n = TAB_SIZE (dti_dti_dl_table);
+
−#ifdef DTI2
+
−        /*
+
−         * to be able to distinguish DTI1/DTI2 opcodes,
+
−         * the ones for DTI2 start at 0x50
+
−         */
+
−        opc -= 0x50;
+
−#endif /* DTI2*/
+
−#else  /* DTILIB */
+
−        table = dti_dl_table;
+
−        n = TAB_SIZE (dti_dl_table);
+
−#endif /* DTILIB */
+
−        break;
+
−#endif /* _SIMULATION_ */
+
−      default:
+
−        table = NULL;
+
−        n = 0;
+
−        break;
+
−    }
+
−
+
−    if (table != NULL)
+
−    {
+
−      if ((opc & PRM_MASK) < n)
+
−      {
+
−        table += opc & PRM_MASK;
+
−#ifdef PALLOC_TRANSITION
+
−        P_SDU(prim) = table->soff ? (T_sdu*) (((char*)&prim->data)
+
−                                                     + table->soff) : 0;
+
−#ifndef NO_COPY_ROUTING
+
−        P_LEN(prim) = table->size + sizeof (T_PRIM_HEADER);
+
−#endif /* NO_COPY_ROUTING */
+
−#endif /* PALLOC_TRANSITION */
+
−        JUMP (table->func) (P2D(prim));
+
−      }
+
−      else
+
−      {
+
−        primitive_not_supported (P2D(prim));
+
−      }
+
−      return PEI_OK;
+
−    }
+
−
+
−    /*
+
−     * primitive is not a GSM primitive - forward it to the environment
+
−     */
+
−    if (opc & SYS_MASK)
+
−    {
+
−      if(vsi_c_primitive (VSI_CALLER prim) NEQ VSI_OK)
+
−      {
+
−        TRACE_ERROR_P1("VSI entity: Can't forward a primitive, uart_pei.c(%d)",
+
−                                                                     __LINE__);
+
−      }
+
−    }
+
−    else
+
−    {
+
−      PFREE (P2D(prim));
+
−      return PEI_ERROR;
+
−    }
+
−  }
+
−  return PEI_OK;
+
−}
+
−
+
−
+
−
+
−#ifdef FF_MULTI_PORT
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : pei_uart_driver_signal
+
−+------------------------------------------------------------------------------
+
−| Description : The function pei_uart_driver_signal() is the callback function
+
−|               of the UART driver to indicate events of the driver. This
+
−|               function is called in interrupt context. It converts the given
+
−|               opcode to a signal.
+
−|
+
−| Parameters  : usartNo - affected UART port
+
−|               opcode  - opcode of the event
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void pei_uart_driver_signal (T_DRV_SIGNAL *SigPtr)
+
−{
+
−  T_UART_DATA*  uart_device;
+
−
+
−  TRACE_FUNCTION( "pei_uart_driver_signal" );
+
−
+
−  /*
+
−   * set UART instance
+
−   */
+
−  uart_device = &uart_data_base[SigPtr->DrvHandle];
+
−  /*
+
−   * activate signal
+
−   */
+
−  switch (SigPtr->SignalType)
+
−  {
+
−    case DRV_SIGTYPE_READ:
+
−      PSIGNAL(hCommUART, UART_DRIVER_RECEIVED_IND, uart_device);
+
−      break;
+
−
+
−    case DRV_SIGTYPE_WRITE:
+
−      PSIGNAL(hCommUART, UART_DRIVER_SENT_IND, uart_device);
+
−      break;
+
−
+
−    case DRV_SIGTYPE_FLUSH:
+
−      PSIGNAL(hCommUART, UART_DRIVER_FLUSHED_IND, uart_device);
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "pei_uart_driver_signal: unknown signal" );
+
−      break;
+
−  }
+
−} /* pei_uart_driver_signal() */
+
−#endif /* FF_MULTI_PORT */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|       Function        : pei_init
+
−+------------------------------------------------------------------------------
+
−|       Description     : This function is called by the frame. It is used to
+
−|                         initialise the entitiy.
+
−|
+
−|       Parameters      : handle    - task handle
+
−|
+
−|       Return          : PEI_OK    - entity initialised
+
−|                         PEI_ERROR - entity not (yet) initialised
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−/*qqq hier Kommunikationskanaele eintragen*/
+
−LOCAL SHORT pei_init (T_HANDLE handle)
+
−{
+
−  USHORT  i;
+
−  UBYTE   instance;
+
−
+
−  /*
+
−   * Initialize task handle
+
−   */
+
−   UART_handle = handle;
+
−
+
−   TRACE_FUNCTION ("pei_init");
+
−  /*
+
−   * Open communication channel
+
−   */
+
−  if (hCommMMI < VSI_OK)
+
−  {
+
−    if ((hCommMMI = vsi_c_open (VSI_CALLER ACI_NAME)) < VSI_OK)
+
−      return PEI_ERROR;
+
−  }
+
−
+
−  if (hCommUART < VSI_OK)
+
−  {
+
−    if ((hCommUART = vsi_c_open (VSI_CALLER UART_NAME)) < VSI_OK)
+
−      return PEI_ERROR;
+
−  }
+
−
+
−#ifdef DTILIB
+
−  /*
+
−   * initialize dtilib for this entity
+
−   */
+
−  uart_hDTI = dti_init (UART_INSTANCES * UART_MAX_NUMBER_OF_CHANNELS,
+
−                        handle,
+
−                        DTI_DEFAULT_OPTIONS,
+
−                        pei_sig_callback);
+
−  if(!uart_hDTI)
+
−    return PEI_ERROR;
+
−
+
−#else  /* DTILIB */
+
−  /*
+
−   * Initialize table with channel ids
+
−   */
+
−  for( i = 0; i < (UART_INSTANCES * UART_MAX_NUMBER_OF_CHANNELS); i++)
+
−  {
+
−    uart_cid_table[i].c_id      = 0;
+
−    uart_cid_table[i].uart_data = NULL;
+
−    uart_cid_table[i].dtx       = NULL;
+
−    uart_cid_table[i].drx       = NULL;
+
−  }
+
−#endif /* DTILIB */
+
−
+
−  /*
+
−   * send parameters primitive
+
−   */
+
−  {
+
−    PALLOC (uart_parameters_ind, UART_PARAMETERS_IND);
+
−    uart_parameters_ind->uart_instances = UART_INSTANCES;
+
−    PSEND (hCommMMI, uart_parameters_ind);
+
−  }
+
−
+
−  /*
+
−   * Initialize timer table
+
−   */
+
−  for( i = 0; i < UART_TIMER_MAX; i++)
+
−  {
+
−    uart_timer_table[i].uart_data    = &(uart_data_base
+
−                                         [(UBYTE)(i /
+
−                                           UART_TIMER_PER_INSTANCE)]);
+
−    uart_timer_table[i].timer_number = (UBYTE)(i % UART_TIMER_PER_INSTANCE);
+
−  }
+
−
+
−  for( instance = 0; instance < UART_INSTANCES; instance++ )
+
−  {
+
−    /*
+
−     * Initialize global pointer uart_data. This is required to access all
+
−     * entity data.
+
−     */
+
−    uart_data = &(uart_data_base[instance]);
+
−
+
−    /*
+
−     * Initialize DLC table
+
−     */
+
−    for( i = 0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++)
+
−    {
+
−      uart_data->dlc_table[i].dlci              = UART_DLCI_INVALID;
+
−      uart_data->dlc_table[i].priority          = 0;
+
−#ifdef DTILIB
+
−      uart_data->dlc_table[i].dti_state = DTI_CLOSED;
+
−#else  /* DTILIB */
+
−      uart_data->dlc_table[i].hCommUPLINK       = VSI_ERROR;
+
−#endif /* DTILIB */
+
−      uart_data->dlc_table[i].connection_state  = UART_CONNECTION_DEAD;
+
−      if(i EQ UART_CONTROL_INSTANCE)
+
−      {
+
−        uart_data->dlc_table[i].drx = &uart_data->drx_base[0];
+
−        uart_data->dlc_table[i].dtx = &uart_data->dtx_base[0];
+
−      }
+
−      else
+
−      {
+
−        uart_data->dlc_table[i].drx = &uart_data->drx_base[i];
+
−        uart_data->dlc_table[i].dtx = &uart_data->dtx_base[i];
+
−      }
+
−
+
−      uart_data->dlc_table[i].transmit_data = NULL;
+
−      uart_data->dlc_table[i].transmit_pos  = 0;
+
−      uart_data->dlc_table[i].p_counter     = 0;
+
−
+
−      uart_data->dlc_table[i].receive_data    = NULL;
+
−      uart_data->dlc_table[i].receive_pos     = 0;
+
−      uart_data->dlc_table[i].receive_size    = 0;
+
−      uart_data->dlc_table[i].receive_process = UART_RX_PROCESS_STOP;
+
−
+
−      uart_data->dlc_table[i].last_command    = NULL;
+
−      uart_data->dlc_table[i].next_command    = NULL;
+
−      uart_data->dlc_table[i].retransmissions = 0;
+
−      uart_data->dlc_table[i].lines           = 0;
+
−      uart_data->dlc_table[i].service         = 0;
+
−      uart_data->dlc_table[i].codec           = 0;
+
−      uart_data->dlc_table[i].received_prim   = 0;
+
−      uart_data->dlc_table[i].flushed         = TRUE;
+
−    }
+
−
+
−    /*
+
−     * Initialize DLCI instance table
+
−     */
+
−    for( i = 0; i < 64; i++ )
+
−    {
+
−      uart_data->dlc_instance[i] = UART_EMPTY_INSTANCE;
+
−    }
+
−
+
−    /*
+
−     * timer values for this instance
+
−     */
+
−    uart_data->timer_t1_index = (USHORT)(instance * UART_TIMER_PER_INSTANCE)
+
−                                + UART_RT_INDEX_T1;
+
−    uart_data->timer_t2_index = (USHORT)(instance * UART_TIMER_PER_INSTANCE)
+
−                                + UART_RT_INDEX_T2;
+
−    uart_data->timer_t3_index = (USHORT)(instance * UART_TIMER_PER_INSTANCE)
+
−                                + UART_RT_INDEX_T3;
+
−    uart_data->timer_tesd_index = (USHORT)(instance * UART_TIMER_PER_INSTANCE)
+
−                                + UART_RT_INDEX_TESD;
+
−    /*
+
−     * set device for this instance
+
−     */
+
−    uart_data->device   = instance;
+
−    uart_data->fcstab   = uart_fcstable_base;
+
−
+
−    /*
+
−     * set device specific values
+
−     */
+
−    uart_data->xon  = UART_IO_XON_DEFAULT;
+
−    uart_data->xoff = UART_IO_XOFF_DEFAULT;
+
−    uart_data->n1   = UART_N1_READY_MODE;
+
−    /*
+
−     * set initial DTX/DRX services
+
−     */
+
−    uart_data->dtx = &(uart_data->dtx_base[0]);
+
−    uart_data->drx = &(uart_data->drx_base[0]);
+
−    /*
+
−     * escape sequence detection
+
−     */
+
−    uart_data->act_ec    = 0x2b;         /* Escape Character '+' */
+
−    uart_data->act_gp    = 1000;         /* Guard Period */
+
−  }
+
−
+
−  /*
+
−   * qqq Initialize entity data (call init function of every service)
+
−   * the order of function calls is important
+
−   */
+
−  for( i = 0; i < UART_INSTANCES; i++ )
+
−  {
+
−    uart_data = &(uart_data_base[i]);
+
−    rt_init();
+
−    ker_init();
+
−    rx_init();
+
−    tx_init();
+
−    drx_init();
+
−    dtx_init();
+
−  }
+
−  uart_data = &(uart_data_base[0]);
+
−
+
−  return (PEI_OK);
+
−}
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|       Function        : pei_timeout
+
−+------------------------------------------------------------------------------
+
−|       Description     : This function is called by the frame when a timer
+
−|                         has expired.
+
−|
+
−|       Parameters      : index             - timer index
+
−|
+
−|       Return          : PEI_OK            - timeout processed
+
−|                         PEI_ERROR         - timeout not processed
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL SHORT pei_timeout (USHORT index)
+
−{
+
−  TRACE_FUNCTION ("pei_timeout");
+
−
+
−  /*
+
−   * set UART instance
+
−   */
+
−  uart_data = uart_timer_table[index].uart_data;
+
−
+
−  /*
+
−   * Process timeout
+
−   */
+
−  switch (uart_timer_table[index].timer_number)
+
−  {
+
−    case UART_RT_INDEX_T1:
+
−      /*
+
−       * timer T1 expired.
+
−       */
+
−      rt_t1_expired();
+
−      break;
+
−    case UART_RT_INDEX_T2:
+
−      /*
+
−       * timer T2 expired.
+
−       */
+
−      rt_t2_expired();
+
−      break;
+
−    case UART_RT_INDEX_T3:
+
−      /*
+
−       * timer T3 expired.
+
−       */
+
−      rt_t3_expired();
+
−      break;
+
−    case UART_RT_INDEX_TESD:
+
−      /*
+
−       * Escape Sequence Detection timer expired.
+
−       */
+
−      rt_tesd_expired();
+
−      break;
+
−    default:
+
−      TRACE_ERROR("pei_timeout: Unknown Timeout");
+
−      break;
+
−  }
+
−
+
−  return PEI_OK;
+
−}
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|       Function        : pei_signal
+
−+------------------------------------------------------------------------------
+
−|       Description     : This function is called by the frame when a signal
+
−|                         has been received.
+
−|
+
−|       Parameters      : opc               - signal operation code
+
−|                         *data             - pointer to primitive
+
−|
+
−|       Return          : PEI_OK            - signal processed
+
−|                         PEI_ERROR         - signal not processed
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL SHORT pei_signal (ULONG opc, void *data)
+
−{
+
−  TRACE_FUNCTION ("pei_signal");
+
−
+
−#ifdef FF_MULTI_PORT
+
−  /*
+
−   * Process signal
+
−   */
+
−  switch (opc)
+
−  {
+
−    case UART_DRIVER_SENT_IND:
+
−      tx_uart_driver_sent_ind(data);
+
−      break;
+
−
+
−    case UART_DRIVER_RECEIVED_IND:
+
−      rx_uart_driver_received_ind(data);
+
−      break;
+
−
+
−    case UART_DRIVER_FLUSHED_IND:
+
−      tx_uart_driver_flushed_ind(data);
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR("Unknown Signal OPC");
+
−      return PEI_ERROR;
+
−  }
+
−#else /* FF_MULTI_PORT */
+
−  /*
+
−   * Process signal
+
−   */
+
−  switch (opc)
+
−  {
+
−    case UART_DRIVER_SENT_IND:
+
−      tx_uart_driver_sent_ind(data);
+
−      break;
+
−
+
−    case UART_DRIVER_RECEIVED_IND:
+
−      rx_uart_driver_received_ind(data);
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR("Unknown Signal OPC");
+
−      break;
+
−  }
+
−#endif /* FF_MULTI_PORT */
+
−
+
−  return PEI_OK;
+
−}
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|       Function        : pei_exit
+
−+------------------------------------------------------------------------------
+
−|       Description     : This function is called by the frame when the entity
+
−|                         is terminated. All open resources are freed.
+
−|
+
−|       Parameters      : -
+
−|
+
−|       Return          : PEI_OK            - exit sucessful
+
−|                         PEI_ERROR         - exit not sueccessful
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL SHORT pei_exit (void)
+
−{
+
−  TRACE_FUNCTION ("pei_exit");
+
−
+
−#ifdef DTILIB
+
−#ifdef _SIMULATION_
+
−
+
−  /*
+
−   * close test channel
+
−   */
+
−#endif /* _SIMULATION_ */
+
−
+
−  /*
+
−   * Shut down dtilib communication
+
−   */
+
−  dti_deinit(uart_hDTI);
+
−#endif /* DTILIB */
+
−  /*
+
−   * Close communication channel to MMI
+
−   */
+
−  if(vsi_c_close (VSI_CALLER hCommMMI) NEQ VSI_OK)
+
−  {
+
−    TRACE_ERROR_P1("VSI entity: CloseComChannel to MMI failed, uart_pei.c(%d)",
+
−                                                                     __LINE__);
+
−    return PEI_ERROR;
+
−  }
+
−  hCommMMI = VSI_ERROR;
+
−
+
−
+
−  /*
+
−   * Free all resources
+
−   */
+
−  drx_free_resources();
+
−  dtx_exit();
+
−
+
−  return PEI_OK;
+
−}
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|       Function        : pei_run
+
−+------------------------------------------------------------------------------
+
−|       Description     : This function is called by the frame when entering
+
−|                         the main loop. This function is only required in the
+
−|                         active variant.
+
−|
+
−|               This function is not used.
+
−|
+
−|       Parameters      : handle            - Communication handle
+
−|
+
−|       Return          : PEI_OK            - sucessful
+
−|                         PEI_ERROR         - not successful
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL SHORT pei_run (T_HANDLE TaskHandle, T_HANDLE ComHandle )
+
−{
+
−  return PEI_OK;
+
−} /* pei_run() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|       Function        : pei_monitor
+
−+------------------------------------------------------------------------------
+
−|       Description     : This function is called by the frame in case sudden
+
−|                         entity specific data is requested
+
−|                         (e.g. entity Version).
+
−|
+
−|       Parameters      : out_monitor - return the address of the data to be
+
−|                                       monitoredCommunication handle
+
−|
+
−|       Return          : PEI_OK      - sucessful
+
−|                                       (address in out_monitor is valid)
+
−|                         PEI_ERROR   - not successful
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL SHORT pei_monitor (void ** out_monitor)
+
−{
+
−  TRACE_FUNCTION ("pei_monitor");
+
−
+
−  /*
+
−   * Version = "0.S" (S = Step).
+
−   */
+
−  uart_mon.version = VERSION_UART;
+
−  *out_monitor = &uart_mon;
+
−
+
−  return PEI_OK;
+
−}
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|       Function        : pei_config
+
−+------------------------------------------------------------------------------
+
−|       Description     : This function is called by the frame when a primitive
+
−|                         is received indicating dynamic configuration.
+
−|
+
−|               This function is not used in this entity.
+
−|
+
−|       Parameters      : handle            - Communication handle
+
−|
+
−|       Return          : PEI_OK            - sucessful
+
−|                         PEI_ERROR         - not successful
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL SHORT pei_config (T_PEI_CONFIG inString)
+
−{
+
−  TRACE_FUNCTION ("pei_config");
+
−  TRACE_FUNCTION (inString);
+
−
+
−  return PEI_OK;
+
−}
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|       Function        : pei_create
+
−+------------------------------------------------------------------------------
+
−|       Description     : This function is called by the frame when the process
+
−|                         is created.
+
−|
+
−|       Parameters      : out_name          - Pointer to the buffer in which to
+
−|                                             locate the name of this entity
+
−|
+
−|       Return          : PEI_OK            - entity created successfuly
+
−|                         PEI_ERROR         - entity could not be created
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL SHORT pei_create (T_PEI_INFO **info)
+
−{
+
−static T_PEI_INFO pei_info =
+
−              {
+
−               "UART",         /* name */
+
−               {              /* pei-table */
+
−                 pei_init,
+
−#ifdef _SIMULATION_
+
−                 pei_exit,
+
−#else
+
−                 NULL,
+
−#endif
+
−                 pei_primitive,
+
−                 pei_timeout,
+
−                 pei_signal,
+
−                 pei_run,
+
−                 pei_config,
+
−                 pei_monitor
+
−               },
+
−               1024,            /* stack size */
+
−               10,              /* queue entries */
+
−               200,             /* priority (1->low, 255->high) */
+
−               UART_TIMER_MAX,  /* number of timers */
+
−               0x03|PRIM_NO_SUSPEND /* flags: bit 0   active(0) body/passive(1) */
+
−              };                /*        bit 1   com by copy(0)/reference(1) */
+
−
+
−
+
−  TRACE_FUNCTION ("pei_create");
+
−
+
−  /*
+
−   * Close Resources if open
+
−   */
+
−#ifdef _SIMULATION_
+
−  if (first_access)
+
−  {
+
−    first_access = FALSE;
+
−  }
+
−  else
+
−  {
+
−    if(pei_exit() NEQ PEI_OK)
+
−    {
+
−      TRACE_ERROR_P1("UART PEI: Can't free open recources, uart_pei.c(%d)",
+
−                                                                 __LINE__);
+
−    }
+
−  }
+
−#endif
+
−
+
−  /*
+
−   * Export startup configuration data
+
−   */
+
−  *info = &pei_info;
+
−
+
−  return PEI_OK;
+
−}
+
−
+
−
+
−#ifndef DTILIB
+
−/*
+
−+------------------------------------------------------------------------------
+
−|    Function    : pei_select_instances
+
−+------------------------------------------------------------------------------
+
−|    Description : This function selects the correct UART and DTX/DRX services
+
−|                 for an incoming DTI interface primitive. This is done by a
+
−|                 lookup in the UART channel id table in order to determine
+
−|                 the correct UART, DTX and DRX data structures.
+
−|
+
−|    Parameters  :   c_id  - channel id of incoming primitive
+
−|
+
−|    Return      :   TRUE  - successful
+
−|                   FALSE - not successful
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL UBYTE pei_select_instances( UBYTE incoming_c_id )
+
−{
+
−  USHORT i;
+
−  UBYTE found = FALSE;
+
−
+
−  TRACE_FUNCTION ("pei_select_instances");
+
−
+
−  /*
+
−   * locate the channel id in the global cid table
+
−   */
+
−  for( i = 0; i < UART_INSTANCES * UART_MAX_NUMBER_OF_CHANNELS; i++ )
+
−    if( uart_cid_table[i].c_id EQ incoming_c_id )
+
−      if( ( uart_cid_table[i].dtx NEQ NULL ) &&
+
−          ( uart_cid_table[i].drx NEQ NULL ) &&
+
−          ( uart_cid_table[i].uart_data NEQ NULL ) )
+
−      {
+
−        /*
+
−         *  channel id found. select service structures
+
−         */
+
−        uart_data       = uart_cid_table[i].uart_data;
+
−        uart_data->dtx  = uart_cid_table[i].dtx;
+
−        uart_data->drx  = uart_cid_table[i].drx;
+
−
+
−        found = TRUE;
+
−        break;
+
−      }
+
−
+
−  if( found EQ FALSE )
+
−  {
+
−    TRACE_EVENT(" pei_select_instances: unknown c_id ");
+
−  }
+
−#ifdef _SIMULATION_
+
−  {
+
−    char buf[64];
+
−    sprintf(buf,"found incoming_c_id: 0x%02X in uart_cid_table[%d]",incoming_c_id, i);
+
−    TRACE_EVENT(buf);
+
−  }
+
−#endif
+
−  return( found );
+
−} /* pei_select_instances */
+
−#endif /* DTILIB */
+
−
+
−
+
−/*
+
− * maps for DTILIB functions
+
− */
+
−
+
−#ifdef DTILIB
+
−/*
+
−+------------------------------------------------------------------------------
+
−|    Function    : pei_dti_dti_connect_req
+
−+------------------------------------------------------------------------------
+
−|    PURPOSE : Call the process function dti_dti_connect_req
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL void pei_dti_dti_connect_req (T_DTI2_CONNECT_REQ* dti_connect_req)
+
−{
+
−  dti_dti_connect_req (uart_hDTI, dti_connect_req);
+
−} /* pei_dti_dti_connect_req() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|    Function    : pei_dti_dti_connect_res
+
−+------------------------------------------------------------------------------
+
−|    PURPOSE : Call the process function dti_dti_connect_res
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL void pei_dti_dti_connect_res (T_DTI2_CONNECT_RES* dti_connect_res)
+
−{
+
−  dti_dti_connect_res(uart_hDTI, dti_connect_res);
+
−} /* pei_dti_dti_connect_res() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|    Function    : pei_dti_dti_disconnect_req
+
−+------------------------------------------------------------------------------
+
−|    PURPOSE : Call the process function dti_dti_disconnect_req
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL void pei_dti_dti_disconnect_req (T_DTI2_DISCONNECT_REQ*
+
−                                          dti_disconnect_req)
+
−{
+
−  dti_dti_disconnect_req (uart_hDTI, dti_disconnect_req);
+
−} /* pei_dti_dti_disconnect_req() */
+
−
+
−
+
−#ifdef _SIMULATION_
+
−/*
+
−+------------------------------------------------------------------------------
+
−|    Function    : pei_dti_dti_connect_ind
+
−+------------------------------------------------------------------------------
+
−|    PURPOSE : Call the process function dti_dti_connect_ind
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL void pei_dti_dti_connect_ind (T_DTI2_CONNECT_IND* dti_connect_ind)
+
−{
+
−  dti_dti_connect_ind (uart_hDTI, dti_connect_ind);
+
−} /* pei_dti_dti_connect_ind() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|    Function    : pei_dti_dti_connect_cnf
+
−+------------------------------------------------------------------------------
+
−|    PURPOSE : Call the process function dti_dti_connect_cnf
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL void pei_dti_dti_connect_cnf (T_DTI2_CONNECT_CNF* dti_connect_cnf)
+
−{
+
−  dti_dti_connect_cnf(uart_hDTI, dti_connect_cnf);
+
−} /* pei_dti_dti_connect_cnf() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|    Function    : pei_dti_dti_disconnect_ind
+
−+------------------------------------------------------------------------------
+
−|    PURPOSE : Call the process function dti_dti_disconnect_ind
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL void pei_dti_dti_disconnect_ind (T_DTI2_DISCONNECT_IND*
+
−                                          dti_disconnect_ind)
+
−{
+
−  dti_dti_disconnect_ind (uart_hDTI, dti_disconnect_ind);
+
−} /* pei_dti_dti_disconnect_ind() */
+
−
+
−#endif /*_SIMULATION_*/
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|    Function    : pei_dti_dti_data_req
+
−+------------------------------------------------------------------------------
+
−|    PURPOSE : Call the process function dti_dti_data_req
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL void pei_dti_dti_data_req (T_DTI2_DATA_REQ* dti_data_req)
+
−{
+
−  dti_dti_data_req (uart_hDTI, dti_data_req);
+
−} /* pei_dti_dti_data_req() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|    Function    : pei_dti_dti_getdata_req
+
−+------------------------------------------------------------------------------
+
−|    PURPOSE : Call the process function dti_dti_getdata_req
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL void pei_dti_dti_getdata_req (T_DTI2_GETDATA_REQ* dti_getdata_req)
+
−{
+
−  dti_dti_getdata_req (uart_hDTI, dti_getdata_req);
+
−} /* pei_dti_dti_getdata_req() */
+
−
+
−
+
−/*==== Start functions only use with Windows ===============================*/
+
−
+
−#ifdef _SIMULATION_
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|    Function    : pei_dti_dti_data_test_req
+
−+------------------------------------------------------------------------------
+
−|    PURPOSE : Call the process function dti_dti_data_test_req
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL void pei_dti_dti_data_test_req (T_DTI2_DATA_TEST_REQ* dti_data_test_req)
+
−{
+
−  dti_dti_data_test_req (uart_hDTI, dti_data_test_req);
+
−} /* pei_dti_dti_data_test_req() */
+
−
+
−/*==== End functions only used with testing from WIN32 =====================*/
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|    Function    : pei_dti_dti_ready_ind
+
−+------------------------------------------------------------------------------
+
−|    PURPOSE : Call the process function dti_dti_ready_ind
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL void pei_dti_dti_ready_ind (T_DTI2_READY_IND* dti_ready_ind)
+
−{
+
−  dti_dti_ready_ind (uart_hDTI, dti_ready_ind);
+
−} /* pei_dti_dti_ready_ind() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|    Function    : pei_dti_dti_data_ind
+
−+------------------------------------------------------------------------------
+
−|    PURPOSE : Call the process function dti_dti_data_ind
+
−+------------------------------------------------------------------------------
+
−*/
+
−LOCAL void pei_dti_dti_data_ind (T_DTI2_DATA_IND* dti_data_ind)
+
−{
+
−  dti_dti_data_ind (uart_hDTI, dti_data_ind);
+
−} /* pei_dti_dti_data_ind() */
+
−#endif /* _SIMULATION_ */
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−|    Function    : pei_sig_callback
+
−+------------------------------------------------------------------------------
+
−|    PURPOSE : Callback function for DTILIB
+
−+------------------------------------------------------------------------------
+
−*/
+
−
+
−LOCAL void pei_sig_callback(U8 instance,
+
−                            U8 interfac,
+
−                            U8 channel,
+
−                            U8 reason,
+
−                            T_DTI2_DATA_IND *dti_data2_ind)
+
−{
+
−  T_DLC *dlc;
+
−
+
−  TRACE_FUNCTION("pei_sig_callback");
+
−
+
−  if(interfac NEQ UART_DTI_UP_INTERFACE)
+
−  {
+
−    TRACE_ERROR("[PEI_SIG_CALLBACK] interface not valid!");
+
−    return; /* error, not found */
+
−  }
+
−
+
−  uart_data = &uart_data_base[instance];
+
−
+
−  if (uart_hDTI NEQ D_NO_DATA_BASE)
+
−  {
+
−    switch (reason)
+
−    {
+
−      case DTI_REASON_CONNECTION_OPENED:
+
−        dlc = &uart_data->dlc_table[channel]; /* channel is dlci */
+
−        uart_data->drx   = dlc->drx;
+
−        uart_data->dtx   = dlc->dtx;
+
−
+
−        sig_dti_ker_connection_opened_ind(channel);
+
−        break;
+
−
+
−      case DTI_REASON_CONNECTION_CLOSED:
+
−        dlc = &uart_data->dlc_table[channel]; /* channel is dlci */
+
−        uart_data->drx   = dlc->drx;
+
−        uart_data->dtx   = dlc->dtx;
+
−
+
−        sig_dti_ker_connection_closed_ind(channel);
+
−        break;
+
−
+
−      case DTI_REASON_DATA_RECEIVED:
+
−        if(!uart_data)
+
−        {
+
−          /*
+
−           * instance not found, primitive was invalid, discard it
+
−           */
+
−          PFREE_DESC2( dti_data2_ind );
+
−        }
+
−        else
+
−        {
+
−          dlc = &uart_data->dlc_table[channel]; /* channel is dlci */
+
−          uart_data->drx   = dlc->drx;
+
−          uart_data->dtx   = dlc->dtx;
+
−
+
−          sig_dti_drx_data_received_ind(dti_data2_ind);
+
−        }
+
−        break;
+
−
+
−      case DTI_REASON_TX_BUFFER_FULL:
+
−        if(!uart_data)
+
−        {
+
−          TRACE_ERROR("[PEI_SIG_CALLBACK] instance not valid!");
+
−          return; /* error, not found */
+
−        }
+
−        dlc = &uart_data->dlc_table[channel]; /* channel is dlci */
+
−        uart_data->drx   = dlc->drx;
+
−        uart_data->dtx   = dlc->dtx;
+
−
+
−        sig_dti_dtx_tx_buffer_full_ind();
+
−        break;
+
−
+
−      case DTI_REASON_TX_BUFFER_READY:
+
−        if(!uart_data)
+
−        {
+
−          TRACE_ERROR("[PEI_SIG_CALLBACK] instance not valid!");
+
−          return; /* error, not found */
+
−        }
+
−        dlc = &uart_data->dlc_table[channel]; /* channel is dlci */
+
−        uart_data->drx   = dlc->drx;
+
−        uart_data->dtx   = dlc->dtx;
+
−
+
−        sig_dti_dtx_tx_buffer_ready_ind();
+
−        break;
+
−      default:
+
−        TRACE_ERROR("unknown DTILIB reason parameter");
+
−        break;
+
−    } /* end switch */
+
−  } /* end if */
+
−  else
+
−  {
+
−    TRACE_ERROR("Pointer to DTILIB database not existing");
+
−  }
+
−} /* pei_sig_callback() */
+
−
+
−/*==== End of functions only used with DTILIB =================================*/
+
−
+
−#endif /* DTILIB */
+
−
+
−/*==== END OF FILE ==========================================================*/