+
−/* 
+
−+----------------------------------------------------------------------------- 
+
−|  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 (RX-statemachine)
+
−+----------------------------------------------------------------------------- 
+
−*/ 
+
−
+
−#ifndef UART_RXS_C
+
−#define UART_RXS_C
+
−#endif /* !UART_RXS_C */
+
−
+
−#define ENTITY_UART
+
−
+
−#ifndef FF_MULTI_PORT
+
−/*==== 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 */
+
−#ifdef DTILIB
+
−#include "dti.h"        /* to get dti lib */
+
−#endif /* DTILIB */
+
−#include "pei.h"        /* to get PEI interface */
+
−#ifdef _TARGET_
+
−#include "uart/serialswitch.h"
+
−#include "uart/traceswitch.h"
+
−#else /* _TARGET_ */
+
−#include "serial_dat.h" /* to get definitions of serial driver */
+
−#endif /* _TARGET_ */
+
−#include "uart.h"       /* to get the global entity definitions */
+
−
+
−#include "uart_rxf.h"   /* to get rx functions */
+
−
+
−#include "uart_kers.h"   /* to get ker signals */
+
−#include "uart_dtxs.h"   /* to get dtx signals */
+
−
+
−#ifdef _SIMULATION_
+
−#include "uart_rxp.h"   /* to get rx_readdata */
+
−#endif /* _SIMULATION_ */
+
−/*==== CONST ================================================================*/
+
−
+
−/*==== LOCAL VARS ===========================================================*/
+
−
+
−/*==== PRIVATE FUNCTIONS ====================================================*/
+
−
+
−/*==== PUBLIC FUNCTIONS =====================================================*/
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_ker_rx_dead_mode_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_KER_RX_DEAD_MODE_REQ. If this
+
−|               signal is called the service expectes an disabled UART to work
+
−|               correctly.
+
−|
+
−| Parameters  : no parameters
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_ker_rx_dead_mode_req () 
+
−{
+
−  TRACE_ISIG( "sig_ker_rx_dead_mode_req" );
+
−
+
−  uart_data->rx.read_permission = FALSE;
+
−  uart_data->rx.prev_lines      = 0;
+
−  uart_data->rx.dlc_instance    = UART_EMPTY_INSTANCE;
+
−  uart_data->rx.escape          = FALSE;
+
−  uart_data->rx.receive_state   = UART_RX_NOT_RECEIVING;
+
−  uart_data->rx.analyze_state   = UART_RX_ERROR;
+
−  uart_data->rx.fcs             = UART_INITFCS;
+
−  uart_data->rx.address_field   = 0;
+
−  uart_data->rx.stored_len      = 0;
+
−
+
−  switch( GET_STATE( UART_SERVICE_RX ) )
+
−  {
+
−    case RX_READY:
+
−    case RX_MUX:
+
−      SET_STATE( UART_SERVICE_RX, RX_DEAD );
+
−      break;
+
−
+
−    case RX_DEAD:
+
−      break;
+
−    default:
+
−      TRACE_ERROR( "SIG_KER_RX_DEAD_MODE_REQ unexpected" );
+
−      break;
+
−  }
+
−} /* sig_ker_rx_dead_mode_req() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_ker_rx_ready_mode_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_KER_RX_READY_MODE_REQ.
+
−|
+
−| Parameters  : no parameters
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_ker_rx_ready_mode_req () 
+
−{
+
−  TRACE_ISIG( "sig_ker_rx_ready_mode_req" );
+
−
+
−  switch( GET_STATE( UART_SERVICE_RX ) )
+
−  {
+
−    case RX_DEAD:
+
−      SET_STATE( UART_SERVICE_RX, RX_READY );
+
−      uart_data->rx.read_permission = FALSE;
+
−      uart_data->rx.dlc_instance    = UART_EMPTY_INSTANCE;
+
−      uart_data->rx.receive_state   = UART_RX_NOT_RECEIVING;
+
−      uart_data->rx.analyze_state   = UART_RX_ERROR;
+
−      break;
+
−
+
−    case RX_MUX:
+
−      SET_STATE( UART_SERVICE_RX, RX_READY );
+
−      if(uart_data->rx.read_permission EQ FALSE)
+
−      {
+
−        uart_data->rx.dlc_instance  = UART_EMPTY_INSTANCE;
+
−        uart_data->rx.analyze_state = UART_RX_ERROR;
+
−      }
+
−      break;
+
−
+
−    case RX_READY:
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "SIG_KER_RX_READY_MODE_REQ unexpected" );
+
−      break;
+
−  }
+
−} /* sig_ker_rx_ready_mode_req() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_ker_rx_mux_mode_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_KER_RX_MUX_MODE_REQ.
+
−|
+
−| Parameters  : no parameters
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_ker_rx_mux_mode_req () 
+
−{
+
−  TRACE_ISIG( "sig_ker_rx_mux_mode_req" );
+
−
+
−  switch( GET_STATE( UART_SERVICE_RX ) )
+
−  {
+
−    case RX_DEAD:
+
−      SET_STATE( UART_SERVICE_RX, RX_MUX );
+
−      uart_data->rx.read_permission = FALSE;
+
−      uart_data->rx.dlc_instance    = UART_CONTROL_INSTANCE;
+
−      uart_data->rx.receive_state   = UART_RX_NOT_RECEIVING;
+
−      uart_data->rx.analyze_state   = UART_RX_ERROR;
+
−      break;
+
−
+
−    case RX_READY:
+
−      SET_STATE( UART_SERVICE_RX, RX_MUX );
+
−      if(uart_data->rx.read_permission EQ FALSE)
+
−      {
+
−        uart_data->rx.dlc_instance  = UART_CONTROL_INSTANCE;
+
−        uart_data->rx.analyze_state = UART_RX_ERROR;
+
−      }
+
−      break;
+
−
+
−    case RX_MUX:
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "SIG_KER_RX_MUX_MODE_REQ unexpected" );
+
−      break;
+
−  }
+
−} /* sig_ker_rx_mux_mode_req() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_dtx_rx_ready_to_receive_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_DTX_RX_READY_TO_RECEIVE_REQ.
+
−|
+
−| Parameters  : dlc_instance - dlc instance wich belongs to calling DTX
+
−|               receive_data - descriptor to write
+
−|               receive_pos  - position to start write
+
−|               receive_size - size of descriptor to write
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_dtx_rx_ready_to_receive_req (UBYTE   dlc_instance,
+
−                                             T_desc2* receive_data, 
+
−                                             USHORT  receive_pos,
+
−                                             USHORT  receive_size) 
+
−{
+
−  T_DLC*  dlc;
+
−
+
−  TRACE_ISIG( "sig_dtx_rx_ready_to_receive_req" );
+
−
+
−  dlc = &uart_data->dlc_table[dlc_instance];
+
−  dlc->receive_pos  = receive_pos;
+
−  dlc->receive_size = receive_size;
+
−  dlc->receive_data = receive_data;
+
−
+
−  /*
+
−   * start receiving
+
−   */
+
−  if(uart_data->rx.receive_state EQ UART_RX_RECEIVING)
+
−  {
+
−    if(uart_data->rx.read_permission EQ FALSE)
+
−      dlc->receive_process = UART_RX_PROCESS_READY;
+
−  }
+
−  else
+
−  {
+
−    dlc->receive_process = UART_RX_PROCESS_READY;
+
−    uart_data->rx.receive_state = UART_RX_RECEIVING;
+
−    switch( GET_STATE( UART_SERVICE_RX ) )
+
−    {
+
−      case RX_READY:
+
−        uart_data->rx.dlc_instance  = UART_EMPTY_INSTANCE;
+
−        uart_data->rx.analyze_state = UART_RX_ERROR;
+
−        break;
+
−
+
−      case RX_MUX:
+
−        if(uart_data->rx.dlc_instance EQ UART_EMPTY_INSTANCE)
+
−        {
+
−          uart_data->rx.dlc_instance  = UART_CONTROL_INSTANCE;
+
−          uart_data->rx.analyze_state = UART_RX_ERROR;
+
−        }
+
−        break;
+
−
+
−      default:
+
−        TRACE_ERROR( "SIG_DTX_RX_READY_TO_RECEIVE_REQ unexpected" );
+
−        break;
+
−    }
+
−#ifdef _SIMULATION_
+
−    if(rx_inpavail(uart_data->device) > 0)
+
−#else /* _SIMULATION_ */
+
−    if(UF_InpAvail (uart_data->device) > 0)
+
−#endif /* _SIMULATION_ */
+
−    {
+
−      /*
+
−       * inform channel about reading
+
−       * because previous receive_state was NOT_READING
+
−       * there is only one channel which must be informed
+
−       */
+
−      uart_data->rx.read_permission = TRUE;
+
−      uart_data->dtx                = dlc->dtx;
+
−      sig_rx_dtx_receiving_ind();
+
−    }
+
−    else
+
−      uart_data->rx.read_permission = FALSE;
+
−
+
−    if(uart_data EQ (&(uart_data_base[0])))
+
−    {
+
−      TRACE_EVENT("UF_ReadData()");
+
−#ifdef _SIMULATION_
+
−      rx_readdata(0);
+
−#else /* _SIMULATION_ */
+
−      UF_ReadData (uart_data->device, sm_suspend, rx_readOutFunc_0);
+
−#endif /* else _SIMULATION_ */
+
−    }
+
−#ifdef FF_TWO_UART_PORTS
+
−    else if(uart_data EQ (&(uart_data_base[1])))
+
−    {
+
−      TRACE_EVENT("UF_ReadData()");
+
−#ifdef _SIMULATION_
+
−      rx_readdata(1);
+
−#else /* _SIMULATION_ */
+
−      UF_ReadData (uart_data->device, sm_suspend, rx_readOutFunc_1);
+
−#endif /* else _SIMULATION_ */
+
−    }
+
−#endif /* FF_TWO_UART_PORTS */
+
−    else
+
−    {
+
−      TRACE_ERROR("wrong value of uart_data");
+
−    }
+
−  }
+
−} /* sig_dtx_rx_ready_to_receive_req() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_ker_rx_ready_to_receive_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_KER_RX_READY_TO_RECEIVE_REQ.
+
−|
+
−| Parameters  : receive_data - descriptor to write
+
−|               receive_pos  - position to start write
+
−|               receive_size - size of descriptor to write
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_ker_rx_ready_to_receive_req (T_desc2* receive_data, 
+
−                                             USHORT  receive_pos,
+
−                                             USHORT  receive_size) 
+
−{
+
−  T_DLC*  dlc;
+
−
+
−  TRACE_ISIG( "sig_ker_rx_ready_to_receive_req" );
+
−
+
−  dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
+
−  switch( GET_STATE( UART_SERVICE_RX ) )
+
−  {
+
−    case RX_MUX:
+
−      /*
+
−       * store data in control instance
+
−       */
+
−      dlc->receive_pos  = receive_pos;
+
−      dlc->receive_size = receive_size;
+
−      dlc->receive_data = receive_data;
+
−      /*
+
−       * start receiving
+
−       */
+
−      if(uart_data->rx.receive_state EQ UART_RX_RECEIVING)
+
−      {
+
−        if(uart_data->rx.read_permission EQ FALSE)
+
−          dlc->receive_process = UART_RX_PROCESS_READY;
+
−      }
+
−      else
+
−      {
+
−        dlc->receive_process = UART_RX_PROCESS_READY;
+
−        /*
+
−         * start receiving
+
−         */
+
−        uart_data->rx.receive_state = UART_RX_RECEIVING;
+
−        if(uart_data->rx.dlc_instance EQ UART_EMPTY_INSTANCE)
+
−        {
+
−          uart_data->rx.dlc_instance  = UART_CONTROL_INSTANCE;
+
−          uart_data->rx.analyze_state = UART_RX_ERROR;
+
−        }
+
−#ifdef _SIMULATION_
+
−        if(rx_inpavail(uart_data->device) > 0)
+
−#else /* _SIMULATION_ */
+
−        if(UF_InpAvail (uart_data->device) > 0)
+
−#endif /* _SIMULATION_ */
+
−        {
+
−          /*
+
−           * inform channel about reading
+
−           */
+
−          uart_data->rx.read_permission = TRUE;
+
−          sig_rx_ker_receiving_ind();
+
−        }
+
−        else
+
−          uart_data->rx.read_permission = FALSE;
+
−
+
−        if(uart_data EQ (&(uart_data_base[0])))
+
−        {
+
−          TRACE_EVENT("UF_ReadData()");
+
−#ifdef _SIMULATION_
+
−          rx_readdata(0);
+
−#else /* _SIMULATION_ */
+
−          UF_ReadData (uart_data->device, sm_suspend, rx_readOutFunc_0);
+
−#endif /* else _SIMULATION_ */
+
−        }
+
−#ifdef FF_TWO_UART_PORTS
+
−        else if(uart_data EQ (&(uart_data_base[1])))
+
−        {
+
−          TRACE_EVENT("UF_ReadData()");
+
−#ifdef _SIMULATION_
+
−          rx_readdata(1);
+
−#else /* _SIMULATION_ */
+
−          UF_ReadData (uart_data->device, sm_suspend, rx_readOutFunc_1);
+
−#endif /* else _SIMULATION_ */
+
−        }
+
−#endif /* FF_TWO_UART_PORTS */
+
−        else
+
−        {
+
−          TRACE_ERROR("wrong value of uart_data");
+
−        }
+
−      }
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "SIG_KER_RX_READY_TO_RECEIVE_REQ unexpected" );
+
−      break;
+
−  }
+
−} /* sig_ker_rx_ready_to_receive_req() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_dtx_rx_not_ready_to_receive_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal 
+
−|               SIG_DTX_RX_NOT_READY_TO_RECEIVE_REQ.
+
−|
+
−| Parameters  : dlc_instance - dlc instance wich belongs to calling DTX
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_dtx_rx_not_ready_to_receive_req (UBYTE dlc_instance)
+
−{
+
−  T_DLC*  dlc;
+
−
+
−  TRACE_ISIG( "sig_dtx_rx_not_ready_to_receive_req" );
+
−
+
−  dlc = &uart_data->dlc_table[dlc_instance];
+
−  switch( GET_STATE( UART_SERVICE_RX ) )
+
−  {
+
−    case RX_READY:
+
−    case RX_MUX:
+
−      dlc->receive_data    = NULL;
+
−      dlc->receive_process = UART_RX_PROCESS_STOP;
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "SIG_DTX_RX_NOT_READY_TO_RECEIVE_REQ unexpected" );
+
−      break;
+
−  }
+
−} /* sig_dtx_rx_not_ready_to_receive_req() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_ker_rx_not_ready_to_receive_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal 
+
−|               SIG_KER_RX_NOT_READY_TO_RECEIVE_REQ.
+
−|
+
−| Parameters  : no parameters
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_ker_rx_not_ready_to_receive_req () 
+
−{
+
−  T_DLC*  dlc;
+
−
+
−  TRACE_ISIG( "sig_ker_rx_not_ready_to_receive_req" );
+
−
+
−  dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
+
−  switch( GET_STATE( UART_SERVICE_RX ) )
+
−  {
+
−    case RX_MUX:
+
−      dlc->receive_data    = NULL;
+
−      dlc->receive_process = UART_RX_PROCESS_STOP;
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "SIG_KER_RX_NOT_READY_TO_RECEIVE_REQ unexpected" );
+
−      break;
+
−  }
+
−} /* sig_ker_rx_not_ready_to_receive_req() */
+
−
+
−
+
−
+
−/*
+
−+------------------------------------------------------------------------------
+
−| Function    : sig_ker_rx_restart_read_req
+
−+------------------------------------------------------------------------------
+
−| Description : Handles the internal signal SIG_KER_RX_RESTART_READ_REQ
+
−|
+
−| Parameters  : no parameters
+
−|
+
−+------------------------------------------------------------------------------
+
−*/
+
−GLOBAL void sig_ker_rx_restart_read_req () 
+
−{
+
−  TRACE_ISIG( "sig_ker_rx_restart_read_req" );
+
−
+
−  switch( GET_STATE( UART_SERVICE_RX ) )
+
−  {
+
−    case RX_READY:
+
−    case RX_MUX:
+
−      if(uart_data->rx.receive_state EQ UART_RX_RECEIVING)
+
−      {
+
−        /*
+
−         * restart readOutFunc
+
−         */
+
−        if(uart_data EQ (&(uart_data_base[0])))
+
−        {
+
−          TRACE_EVENT("UF_ReadData()");
+
−#ifdef _SIMULATION_
+
−          rx_readdata(0);
+
−#else /* _SIMULATION_ */
+
−          UF_ReadData (uart_data->device, sm_suspend, rx_readOutFunc_0);
+
−#endif /* else _SIMULATION_ */
+
−        }
+
−#ifdef FF_TWO_UART_PORTS
+
−        else if(uart_data EQ (&(uart_data_base[1])))
+
−        {
+
−          TRACE_EVENT("UF_ReadData()");
+
−#ifdef _SIMULATION_
+
−          rx_readdata(1);
+
−#else /* _SIMULATION_ */
+
−          UF_ReadData (uart_data->device, sm_suspend, rx_readOutFunc_1);
+
−#endif /* else _SIMULATION_ */
+
−        }
+
−#endif /* FF_TWO_UART_PORTS */
+
−        else
+
−        {
+
−          TRACE_ERROR("wrong value of uart_data");
+
−        }
+
−      }
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR( "SIG_KER_RX_RESTART_READ_REQ unexpected" );
+
−      break;
+
−  }
+
−} /* sig_ker_rx_restart_read_req() */
+
−#endif /* !FF_MULTI_PORT */