--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/g23m-aci/uart/uart_rxp.c	Tue Oct 11 02:02:43 2016 +0000
@@ -0,0 +1,649 @@
+/*
++-----------------------------------------------------------------------------
+|  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 primitives as described in
+|             the SDL-documentation (RX-statemachine)
++-----------------------------------------------------------------------------
+*/
+
+#ifndef UART_RXP_C
+#define UART_RXP_C
+#endif /* !UART_RXP_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 */
+#include "dti.h"        /* to get dti lib */
+#include "pei.h"        /* to get PEI interfac */
+#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 <stdio.h>      /* to get sprintf */
+#include "uart_rxp.h"   /* to get rx_readdata */
+#endif /* _SIMULATION_ */
+/*==== CONST ================================================================*/
+
+/*==== LOCAL VARS ===========================================================*/
+
+/*==== PRIVATE FUNCTIONS ====================================================*/
+
+/*==== PUBLIC FUNCTIONS =====================================================*/
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : rx_uart_driver_received_ind
++------------------------------------------------------------------------------
+| Description : Handles the primitive UART_DRIVER_RECEIVED_IND
+|
+| Parameters  : *uart_device - affected device database
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void rx_uart_driver_received_ind ( T_UART_DATA* uart_device )
+{
+  USHORT    i;
+  BOOL      continuous;
+  T_DLC*    dlc;
+  T_desc2*  temp_desc = NULL;
+  ULONG     line_states;
+
+  TRACE_EVENT( "rx_uart_driver_received_ind()" );
+
+  /*
+   * set affected instance
+   */
+  uart_data = uart_device;
+
+  /*
+   * inform about new line states
+   */
+  if(uart_data->rx.lines NEQ uart_data->rx.prev_lines)
+  {
+    /*
+     * convert line states and send it
+     */
+    line_states = 0;
+    if(uart_data->rx.lines & X_MASK)
+    {
+      line_states|= UART_X_RX_MASK;
+      if(!(uart_data->rx.prev_lines & X_MASK))
+      {
+        TRACE_EVENT("RX Flow Control: stop");
+      }
+    }
+    else if(uart_data->rx.prev_lines & X_MASK)
+    {
+      TRACE_EVENT("RX Flow Control: start");
+    }
+
+    if(uart_data->rx.lines & SA_MASK)
+    {
+      line_states|= UART_SA_RX_MASK;
+      if(!(uart_data->rx.prev_lines & SA_MASK))
+      {
+        TRACE_EVENT("DTR: drop");
+      }
+    }
+    else if(uart_data->rx.prev_lines & SA_MASK)
+    {
+      TRACE_EVENT("DTR: on");
+    }
+
+    if(uart_data->rx.lines & SB_MASK)
+    {
+      line_states|= UART_SB_RX_MASK;
+      if(!(uart_data->rx.prev_lines & SB_MASK))
+      {
+        TRACE_EVENT("RTS: off");
+      }
+    }
+    else if(uart_data->rx.prev_lines & SB_MASK)
+    {
+      TRACE_EVENT("RTS: on");
+    }
+
+    if(uart_data->rx.lines & ESC_MASK)
+    {
+      line_states|= UART_ESC_RX_MASK;
+      TRACE_EVENT("Escape Sequence detected");
+    }
+
+    if(uart_data->rx.lines & BRK_MASK)
+    {
+      line_states|= UART_BRK_RX_MASK;
+      line_states|= (((uart_data->rx.lines & BRK_LEN_MASK)
+                     >> BRKLEN) << UART_BRKLEN_RX_POS);
+      TRACE_EVENT("Break detected");
+    }
+    /*
+     * store new line states
+     */
+    uart_data->rx.lines&= ~(ESC_MASK |
+                            BRK_MASK |
+                            BRK_LEN_MASK);
+    uart_data->rx.prev_lines = uart_data->rx.lines;
+    /*
+     * inform MMI
+     */
+    sig_rx_ker_line_states_ind(line_states);
+  }
+
+  switch( GET_STATE( UART_SERVICE_RX ) )
+  {
+    case RX_READY:
+      dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE];
+      if(uart_data->rx.dlc_instance NEQ UART_EMPTY_INSTANCE)
+      {
+        uart_data->rx.dlc_instance  = UART_EMPTY_INSTANCE;
+        uart_data->rx.analyze_state = UART_RX_ERROR;
+        /*
+         * if ISR has read out some data
+         * inform all channels about data reception
+         */
+        if(uart_data->rx.read_permission)
+        {
+          for(i = 0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++)
+          {
+            switch(uart_data->dlc_table[i].receive_process)
+            {
+              case UART_RX_PROCESS_READY:
+              case UART_RX_PROCESS_COMPLETE:
+                /*
+                 * inform all channels about data reception
+                 */
+                uart_data->dlc_table[i].receive_process = UART_RX_PROCESS_STOP;
+                temp_desc = uart_data->dlc_table[i].receive_data;
+                uart_data->dlc_table[i].receive_data = NULL;
+                if(i EQ UART_CONTROL_INSTANCE)
+                {
+                  /*
+                   * Control channel
+                   */
+                  sig_rx_ker_data_received_ind(
+                    temp_desc,
+                    uart_data->dlc_table[i].receive_pos);
+                }
+                else
+                {
+                  /*
+                   * Data channel
+                   */
+                  uart_data->dtx = uart_data->dlc_table[i].dtx;
+                  sig_rx_dtx_data_received_ind(
+                    temp_desc,
+                    uart_data->dlc_table[i].receive_pos);
+                }
+                /* fall through */
+              case UART_RX_PROCESS_STOP:
+                /*
+                 * add new channels which want to receive
+                 */
+                if(uart_data->dlc_table[i].receive_data)
+                  uart_data->dlc_table[i].receive_process = UART_RX_PROCESS_READY;
+                break;
+
+              default:
+                TRACE_EVENT_P2("Unexpected DLC process state: %d | uart_rxp.c(%d)",
+                               dlc->receive_process, __LINE__);
+                break;
+            }
+          }
+        }
+      }
+      else
+      {
+        switch(dlc->receive_process)
+        {
+          case UART_RX_PROCESS_READY:
+          case UART_RX_PROCESS_COMPLETE:
+            /*
+             * if ISR has read out some data
+             * inform channel about data reception
+             */
+            if(uart_data->rx.read_permission)
+            {
+              /*
+               * inform channel about data reception
+               */
+              dlc->receive_process = UART_RX_PROCESS_STOP;
+              temp_desc            = dlc->receive_data;
+              dlc->receive_data    = NULL;
+              uart_data->dtx       = dlc->dtx;
+              sig_rx_dtx_data_received_ind(temp_desc, dlc->receive_pos);
+            }
+            /* fall through */
+          case UART_RX_PROCESS_STOP:
+            /*
+             * add new channel which want to receive
+             */
+            if(dlc->receive_data)
+              dlc->receive_process = UART_RX_PROCESS_READY;
+            break;
+
+          default:
+            TRACE_EVENT_P2("Unexpected DLC process state: %d | uart_rxp.c(%d)",
+                                               dlc->receive_process, __LINE__);
+            break;
+        }
+      }
+      if(dlc->receive_process EQ UART_RX_PROCESS_STOP)
+      {
+        uart_data->rx.receive_state = UART_RX_NOT_RECEIVING;
+        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
+         */
+        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");
+      }
+      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;
+      }
+      continuous = FALSE;
+      for(i = 0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++)
+      {
+        dlc = &uart_data->dlc_table[i];
+        switch(dlc->receive_process)
+        {
+          case UART_RX_PROCESS_READY:
+          case UART_RX_PROCESS_COMPLETE:
+            /*
+             * if ISR has read out some data
+             * inform all channels about data reception
+             */
+            if(uart_data->rx.read_permission)
+            {
+              dlc->receive_process = UART_RX_PROCESS_STOP;
+              temp_desc            = dlc->receive_data;
+              dlc->receive_data    = NULL;
+              if(i EQ UART_CONTROL_INSTANCE)
+              {
+                /*
+                 * Control channel
+                 */
+                sig_rx_ker_data_received_ind(temp_desc, dlc->receive_pos);
+              }
+              else
+              {
+                /*
+                 * Data channel
+                 */
+                uart_data->dtx = dlc->dtx;
+                sig_rx_dtx_data_received_ind(temp_desc, dlc->receive_pos);
+              }
+            }
+            /* fall through */
+          case UART_RX_PROCESS_STOP:
+            /*
+             * add new channels which want to receive
+             */
+            if(dlc->receive_data)
+              dlc->receive_process = UART_RX_PROCESS_READY;
+            break;
+
+          default:
+            TRACE_EVENT_P2("Unexpected DLC process state: %d, uart_rxp.c(%d)",
+                                              dlc->receive_process, __LINE__);
+            break;
+}
+        if(dlc->receive_process NEQ UART_RX_PROCESS_STOP)
+          continuous = TRUE;
+      }
+      /*
+       * check whether there is a channel to receive
+       */
+      if(continuous NEQ TRUE)
+      {
+        uart_data->rx.receive_state = UART_RX_NOT_RECEIVING;
+        break;
+      }
+#ifdef _SIMULATION_
+      if(rx_inpavail(uart_data->device) > 0)
+#else /* _SIMULATION_ */
+      if(UF_InpAvail (uart_data->device) > 0)
+#endif /* _SIMULATION_ */
+      {
+        /*
+         * inform each channel about reading
+         */
+        uart_data->rx.read_permission = TRUE;
+        for(i = 0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++)
+        {
+          if(uart_data->dlc_table[i].receive_process EQ UART_RX_PROCESS_READY)
+          {
+            if(i EQ UART_CONTROL_INSTANCE)
+            {
+              /*
+               * Control channel
+               */
+              sig_rx_ker_receiving_ind();
+            }
+            else
+            {
+              /*
+               * Data channel
+               */
+              uart_data->dtx = uart_data->dlc_table[i].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");
+      }
+      break;
+
+    default:
+      TRACE_ERROR( "UART_DRIVER_RECEIVED_IND unexpected" );
+      break;
+  }
+} /* rx_uart_driver_received_ind() */
+
+
+
+#ifdef _SIMULATION_
+/*
++------------------------------------------------------------------------------
+| Function    : rx_dti_data_test_ind
++------------------------------------------------------------------------------
+| Description : Handles the primitive DTI_DATA_TEST_IND
+|
+| Parameters  : *dti_data_test_ind - Ptr to primitive payload
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void rx_dti_data_test_ind ( T_DTI2_DATA_TEST_IND *dti_data_test_ind )
+{
+  char          buf[100];
+  T_reInstMode  reInstall;
+  USHORT        size[2];
+  USHORT        pos;
+  USHORT        i;
+  T_UART_DATA*  uart_device;
+
+  TRACE_FUNCTION( "rx_dti_data_test_ind" );
+
+  /*
+   * set UART instance
+   */
+  uart_device = &(uart_data_base[UART_TEST_C_ID_1]);
+  /*
+   * copy data to simulation buffer
+   */
+  MFREE_DESC2(uart_device->rx.sim_buffer);
+  MALLOC(uart_device->rx.sim_buffer, (USHORT)(sizeof(T_desc2) - 1 +
+                                     (dti_data_test_ind->sdu.l_buf >> 3)));
+  memcpy(uart_device->rx.sim_buffer->buffer,
+         &dti_data_test_ind->sdu.buf[dti_data_test_ind->sdu.o_buf >> 3],
+         dti_data_test_ind->sdu.l_buf >> 3);
+  uart_device->rx.sim_buffer->len  = dti_data_test_ind->sdu.l_buf >> 3;
+  uart_device->rx.sim_buffer->next = (ULONG)NULL;
+  uart_device->rx.sim_pos          = 0;
+  /*
+   * trace output
+   */
+  sprintf(buf, "UART device %d:", dti_data_test_ind->link_id);
+  TRACE_FUNCTION( buf );
+  i   = 0;
+  pos = uart_device->rx.sim_pos;
+  while(pos < uart_device->rx.sim_buffer->len)
+  {
+    i+= sprintf(&buf[i], "0x%02x, ", uart_device->rx.sim_buffer->buffer[pos]);
+    pos++;
+    if(i > 80)
+    {
+      TRACE_FUNCTION( buf );
+      i = 0;
+    }
+    else if(pos >= uart_device->rx.sim_buffer->len)
+    {
+      TRACE_FUNCTION( buf );
+    }
+  }
+  /*
+   * set values for ISR
+   */
+  uart_device->rx.source[0] = &uart_device->rx.sim_buffer->buffer[
+                              uart_device->rx.sim_pos];
+  uart_device->rx.source[1] = NULL;
+  size[0]                   = uart_device->rx.sim_buffer->len -
+                              uart_device->rx.sim_pos;
+  size[1]                   = 0;
+
+  /*
+   * call actual function
+   */
+  rx_readOutFunc_0 (FALSE, &reInstall, 1, uart_device->rx.source, size, 0);
+
+  /*
+   * store return values
+   */
+  if(size[0] EQ 0)
+  {
+    MFREE_DESC2(uart_device->rx.sim_buffer);
+    uart_device->rx.sim_buffer = NULL;
+  }
+  else
+    uart_device->rx.sim_pos = uart_device->rx.sim_buffer->len - size[0];
+
+  /*
+   * free the primitive
+   */
+  PFREE(dti_data_test_ind);
+} /* rx_dti_data_test_ind() */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : rx_readdata
++------------------------------------------------------------------------------
+| Description : Simulates a UF_ReadData() call.
+|
+| Parameters  : caller - calling UART instance
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void rx_readdata (UBYTE caller)
+{
+  T_reInstMode  reInstall;
+  USHORT        size[2];
+  T_UART_DATA*  uart_device;
+
+  TRACE_FUNCTION( "rx_readdata" );
+
+  /*
+   * set UART instance
+   */
+  uart_device = &(uart_data_base[caller]);
+
+  if(uart_device->rx.sim_buffer EQ NULL)
+  {
+    /*
+     * send DTI_GETDATA_REQ
+     */
+    PALLOC (dti_getdata_req, DTI2_GETDATA_REQ);
+    dti_getdata_req->link_id = LINK_READDATA_PORT_1; /* for usual read_data */
+    PSEND (hCommMMI, dti_getdata_req);
+  }
+  else
+  {
+    /*
+     * set values for ISR
+     */
+    uart_device->rx.source[0] = NULL;
+    uart_device->rx.source[1] = &uart_device->rx.sim_buffer->buffer[
+                                 uart_device->rx.sim_pos];
+    size[0]                   = 0;
+    size[1]                   = uart_device->rx.sim_buffer->len -
+                                uart_device->rx.sim_pos;
+
+    /*
+     * call actual function
+     */
+    if(caller EQ 0)
+    {
+      rx_readOutFunc_0 (FALSE, &reInstall, 2, uart_device->rx.source, size, 0);
+    }
+#ifdef FF_TWO_UART_PORTS
+    else if(caller EQ 1)
+    {
+      rx_readOutFunc_1 (FALSE, &reInstall, 2, uart_device->rx.source, size, 0);
+    }
+#endif /* FF_TWO_UART_PORTS */
+    else
+    {
+      TRACE_ERROR("wrong caller value");
+    }
+
+    /*
+     * store return values
+     */
+    if(size[1] EQ 0)
+    {
+      MFREE_DESC2(uart_device->rx.sim_buffer);
+      uart_device->rx.sim_buffer = NULL;
+    }
+    else
+      uart_device->rx.sim_pos = uart_device->rx.sim_buffer->len - size[1];
+  }
+} /* rx_readdata() */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : rx_inpavail
++------------------------------------------------------------------------------
+| Description : Simulates a UF_InpAvail() call.
+|
+| Parameters  : caller - calling UART instance
+|
+| Return      : number of octets in Input Queue
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL USHORT rx_inpavail (UBYTE caller)
+{
+  T_UART_DATA*  uart_device;
+
+  TRACE_FUNCTION( "rx_inpavail" );
+
+  /*
+   * set UART instance
+   */
+  uart_device = &(uart_data_base[caller]);
+
+  if(uart_device->rx.sim_buffer)
+    return uart_device->rx.sim_buffer->len - uart_device->rx.sim_pos;
+  else
+    return 0;
+} /* rx_inpavail() */
+#endif /* _SIMULATION_ */
+#endif /* !FF_MULTI_PORT */