view src/aci2/aci/cmh_smf.c @ 701:35e7f9d0379f

targets: add TARGET_HAS_BUZZER to c11x, c139 and dsample This new target config preprocessor symbol was introduced in Tourmaline in connection with the new approach to playing buzzer melodies via PWT, properly omitting the responsible code on targets where BU output controls the vibrator instead. That code is not present in Magnetite and we have no plans to backport it here, but target header files should be kept consistent between the two trees, especially given that we plan to support FC Venus target in Magnetite.
author Mychaela Falconia <falcon@freecalypso.org>
date Sat, 26 Mar 2022 19:51:34 +0000
parents 93999a60b835
children
line wrap: on
line source

/* 
+----------------------------------------------------------------------------- 
|  Project :  
|  Modul   :  
+----------------------------------------------------------------------------- 
|  Copyright 2002 Texas Instruments Berlin, AG 
|                 All rights reserved. 
| 
|                 This file is confidential and a trade secret of Texas 
|                 Instruments Berlin, AG 
|                 The receipt of or possession of this file does not convey 
|                 any rights to reproduce or disclose its contents or to 
|                 manufacture, use, or sell anything it may describe, in 
|                 whole, or in part, without the specific written consent of 
|                 Texas Instruments Berlin, AG. 
+----------------------------------------------------------------------------- 
|  Purpose :  This module defines the functions used by the command
|             handler for GPRS session management ( SM ).
+----------------------------------------------------------------------------- 
*/ 

#if defined (GPRS) && defined (DTI)

#ifndef CMH_SMF_C
#define CMH_SMF_C
#endif

#include "aci_all.h"
/*==== INCLUDES ===================================================*/
#include "gprs.h"

#include "dti.h"      /* functionality of the dti library */
#include "aci_cmh.h"
#include "ati_cmd.h"
#include "aci_cmd.h"
#include "aci_lst.h"
#include "aci.h"

#include "dti_conn_mng.h"
#include "dti_cntrl_mng.h"

#include "gaci.h"
#include "gaci_cmh.h"
#include "psa.h"
#include "psa_gmm.h"
#include "psa_sm.h"
#include "psa_gppp.h"

#include "phb.h"
#include "cmh.h"
#include "cmh_gmm.h"

#include "cmh_sm.h"
#include "cmh_gppp.h"
#include "gaci_srcc.h"
#include "psa_cc.h"

#if defined (CO_UDP_IP) || defined (FF_GPF_TCPIP)
#include "wap_aci.h"
#include "psa_tcpip.h"
#include "cmh_ipa.h"
#endif /* WAP  || FF_GPF_TCPIP OR SAT E */

#ifdef SIM_TOOLKIT
#include "psa_sat.h"
#include "cmh_sat.h"
#endif

#include "psa_sim.h"
#include "cmh_sim.h"

#include "cmh_snd.h"

/* temp needed because of use of ATI functions here: should eventually disappear */
#include "ati_int.h"

#ifdef FF_GPF_TCPIP
#include "dcm_utils.h"
#include "dcm_state.h"
#include "dcm_env.h"
#endif
#include "dcm_f.h"
#include "psa_uart.h"


/*==== CONSTANTS ==================================================*/

/*==== TYPES ======================================================*/
typedef struct
{
  T_CGEREP_EVENT            event;
  T_CGEREP_EVENT_REP_PARAM  parm;

} T_CGERP_EVENT_BUFFER;

typedef enum
{
  T_CDS_IDLE,
  T_CDS_RUNNING

} T_CONTEXTS_DEACTIVATION_STATUS;

typedef struct
{
  T_CONTEXTS_DEACTIVATION_STATUS state;
  USHORT         nsapi_set;
  T_ACI_CMD_SRC  srcId;
  USHORT         cid_set;

} T_CONTEXTS_DEACTIVATION_INFORMATION;


/*==== EXPORT =====================================================*/

/*==== VARIABLES ==================================================*/
GLOBAL SHORT                nsapi_to_cid[SMH_NSAPI_MAX];
static T_CGSMS_SERVICE      m_service;
static T_CGERP_EVENT_BUFFER gprs_event_buffer[GPRS_EVENT_REPORTING_BUFFER_SIZE];
static SHORT                gprs_eb_current_p, gprs_eb_oldest_p;
static BOOL                 m_mt_te_link;
static BOOL                 call_waits_in_table;
static T_CONTEXTS_DEACTIVATION_INFORMATION  working_cgact_actions;
/*==== FUNCTIONS ==================================================*/

/*
 *  functions for ATA and ATH
 */
/* GLOBAL  BOOL    cmhSM_sAT_H               ( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret ); */
/* GLOBAL  BOOL    cmhSM_sAT_A               ( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret ); */
static  BOOL    cmhSM_sAT_A_H_intern      ( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret, SHORT mode);

/*
 *    functions for DTI
 */
/* GLOBAL ULONG cmhSM_get_link_id_SNDCP_peer ( SHORT cid, T_SNDCP_PEER which ); */
/* GLOBAL BOOL  cmhSM_context_deactivated    ( USHORT nsapi_set ); */

/* GLOBAL T_ACI_RETURN cmhSNDCP_Disable( UBYTE dti_id ); */



/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_Init               |
+--------------------------------------------------------------------+

  PURPOSE : Fill variables for the own use with default values.
*/
GLOBAL void cmhSM_Init (void)
{
  SHORT i = 0;

  /* SM CMH global parameter */
  smEntStat.curCmd = AT_CMD_NONE;
  smEntStat.entOwn = OWN_NONE;

  /* GPRS event reporting */
  memset(gprs_event_buffer,     0, sizeof(T_CGERP_EVENT_BUFFER) * GPRS_EVENT_REPORTING_BUFFER_SIZE);
  gprs_eb_current_p = 0;
  gprs_eb_oldest_p  = 0;


  cmhSM_empty_call_table();

  /* used for network requested context reactivation */
  call_waits_in_table = FALSE;

  working_cgact_actions.state     = T_CDS_IDLE;
  working_cgact_actions.nsapi_set = 0;
  working_cgact_actions.srcId     = CMD_SRC_NONE;
  working_cgact_actions.cid_set   = 0;


  /*
   *    The following command has to be in the init and the reset function!!!
   *
   *    Set all to zero in init. In the reset function is a contion action to
   *    not equeal zero.
   */
  memset(pdp_context,0 , sizeof(T_GPRS_CONT_CLASS) * MAX_CID);

  for (i = 0; i < MAX_CID; i++)
  {
    pdp_context[i].link_id_uart = DTI_LINK_ID_NOTPRESENT;
    pdp_context[i].link_id_new  = DTI_LINK_ID_NOTPRESENT;
    pdp_context[i].link_id_sn   = DTI_LINK_ID_NOTPRESENT;
  }

  m_mt_te_link = FALSE;
}

GLOBAL void cmhSM_ResetNonWorkingContexts( void )
{
  SHORT i = 0, j = 0;
  UBYTE srcId = srcId_cb;
  UBYTE gprs_default_pco[] = {
                                0x80,0x80,0x21,0x10,0x01,0x01,0x00,0x10,0x81,0x06,
                                0x00,0x00,0x00,0x00,0x83,0x06,0x00,0x00,0x00,0x00
                             };
  for (i = 0; i < MAX_CID; i++)
  {
    if ( (pdp_context[i].state EQ CS_UNDEFINED) OR (pdp_context[i].state EQ CS_DEFINED) )
    {
     
      for (j = 0; j < SMH_NSAPI_MAX; j++)
      {
        if ( nsapi_to_cid[j] EQ i + 1 )
        {
          nsapi_to_cid[j] = INVALID_CID;
        }
      }

      memset(&pdp_context[i], 0, sizeof(T_GPRS_CONT_CLASS));

      pdp_context[i].state        = CS_UNDEFINED;
      pdp_context[i].smreg_ti     = UNDEFINED_TI;
      pdp_context[i].link_id_uart = DTI_LINK_ID_NOTPRESENT;
      pdp_context[i].link_id_new  = DTI_LINK_ID_NOTPRESENT;
      pdp_context[i].link_id_sn   = DTI_LINK_ID_NOTPRESENT;

      pdp_context[i].user_pco.len = sizeof (gprs_default_pco);
      memcpy (pdp_context[i].user_pco.pco, gprs_default_pco, sizeof (gprs_default_pco));
    }
  }

  memset(work_cids, 0, sizeof(SHORT)  * MAX_CID_PLUS_EINS);
  cid_pointer = 0;

  /* set default context parameter */
  memset(&defaultCtx,   0, sizeof(T_GPRS_CONT_REC));
  strcpy(defaultCtx.pdp_type,"IP" );

  /* mode of CGAUTO*/
  automatic_response_mode = 3;

  m_service = CGSMS_SERVICE_CS_PREFERRED;

  /* GPRS event reporting */
  ati_user_output_cfg[srcId].CGEREP_mode    = CGEREP_MODE_BUFFER;
  ati_user_output_cfg[srcId].CGEREP_bfr     = CGEREP_BFR_CLEAR;
  sm_cgsms_service  = CGSMS_SERVICE_CS_PREFERRED;    
}

GLOBAL void cmhSM_Reset( void )
{
  SHORT i = 0;
  UBYTE gprs_default_pco[] = {
                                0x80,0x80,0x21,0x10,0x01,0x01,0x00,0x10,0x81,0x06,
                                0x00,0x00,0x00,0x00,0x83,0x06,0x00,0x00,0x00,0x00
                             };

  /* SMF CMH local parameter */

  memset(pdp_context,           0, sizeof(T_GPRS_CONT_CLASS) * MAX_CID);

  for (i = 0; i < MAX_CID; i++)
  {
    pdp_context[i].state    = CS_UNDEFINED;
    pdp_context[i].smreg_ti = UNDEFINED_TI;
    pdp_context[i].link_id_uart = DTI_LINK_ID_NOTPRESENT;
    pdp_context[i].link_id_new  = DTI_LINK_ID_NOTPRESENT;
    pdp_context[i].link_id_sn   = DTI_LINK_ID_NOTPRESENT;

    pdp_context[i].user_pco.len = sizeof (gprs_default_pco);
    memcpy (pdp_context[i].user_pco.pco, gprs_default_pco, sizeof (gprs_default_pco));
  }

  memset(work_cids,             0, sizeof(SHORT)  * MAX_CID_PLUS_EINS);

  for (i = 0; i < SMH_NSAPI_MAX; i++)
    nsapi_to_cid[i] = INVALID_CID;

  cid_pointer               = 0;

  /* set default context parameter */
  memset(&defaultCtx,   0, sizeof(T_GPRS_CONT_REC));
  strcpy(defaultCtx.pdp_type,"IP" );

  /* mode of CGAUTO*/
  automatic_response_mode = 3;

  m_service = CGSMS_SERVICE_CS_PREFERRED;

  /* GPRS event reporting */
  ati_user_output_cfg[CMD_SRC_ATI].CGEREP_mode = CGEREP_MODE_BUFFER;
  ati_user_output_cfg[CMD_SRC_ATI].CGEREP_bfr  = CGEREP_BFR_CLEAR;
  sm_cgsms_service  = CGSMS_SERVICE_CS_PREFERRED;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_empty_call_table   |
+--------------------------------------------------------------------+

  PURPOSE : Fill variables for the own use with default values.
*/
GLOBAL void cmhSM_empty_call_table (void)
{
  memset (gprs_call_table, 0, sizeof(T_GPRS_CALL_TABLE) *MAX_GPRS_CALL_TABLE_ENTRIES);
  current_gprs_ct_index = 0;
  gprs_ct_index = 0;
  gprs_call_table[0].sm_ind.smreg_ti = UNDEFINED_TI;
}

/*
+-------------------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                                  |
| STATE   : code             ROUTINE : cmhSM_getSrcIdOfRunningCGACTDeactivation |
+-------------------------------------------------------------------------------+

  PURPOSE : Returns a source ID if the given cid is requested to deactivate
            by +CGACT. The source ID indicates where the +CGACT was started.
*/
GLOBAL T_ACI_CMD_SRC cmhSM_getSrcIdOfRunningCGACTDeactivation(SHORT cid)
{
  switch( working_cgact_actions.state )
  {
    case T_CDS_RUNNING:
      if( (1 << (cid - 1) & working_cgact_actions.cid_set)               OR
           INVALID_NSAPI NEQ pdp_context[cid - 1].nsapi                  AND
          (pdp_context[cid - 1].nsapi & working_cgact_actions.nsapi_set)     )
      {
        return working_cgact_actions.srcId;
      }
      break;
    case T_CDS_IDLE:
      break;
  }
  return CMD_SRC_NONE;
}


/*
+-------------------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                                  |
| STATE   : code             ROUTINE : cmhSM_getSrcIdOfRunningCGACTDeactivation |
+-------------------------------------------------------------------------------+

  PURPOSE : Returns TRUE if +CGACT is running on the given cid -> NO_CARRIER
                    FASE if no CGACT was running on this cid   -> CME_ERROR
*/
GLOBAL BOOL isContextDeactivationRequestedByCGACT(SHORT cid)
{
  TRACE_FUNCTION("***isContextDeactivationRequestedByCGACT");

  switch( working_cgact_actions.state )
  {
    case T_CDS_RUNNING:
      if  ( (1 << (cid - 1)) & working_cgact_actions.cid_set )
      {
        return TRUE;
      }
  }
  return FALSE;
}



/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                         |
| STATE   : code             ROUTINE : cmhSM_connection_down           |
+----------------------------------------------------------------------+

  PURPOSE : Control the answer of context deactivations 
            started by an AT command.
*/
GLOBAL void cmhSM_connection_down( UBYTE dti_id ) 
{
  SHORT cid = gaci_get_cid_over_dti_id( dti_id );

  TRACE_FUNCTION("cmhSM_connection_down");

  switch( working_cgact_actions.state )
  {
    case T_CDS_RUNNING:
      TRACE_EVENT_P1("T_CDS_RUNNING, cid:%d", cid);
      if  ( (1 << (cid - 1)) & working_cgact_actions.cid_set )
      { /* nsapi deactivation is requested */
        working_cgact_actions.cid_set &= (USHORT) ~(1U << (cid - 1));
        TRACE_EVENT_P1("new set: %d",working_cgact_actions.cid_set);

        if ( ! (working_cgact_actions.cid_set  OR
                working_cgact_actions.nsapi_set  ) )
        { 
            R_AT( RAT_OK, working_cgact_actions.srcId ) ( AT_CMD_CGACT );
            working_cgact_actions.state = T_CDS_IDLE;
        }
        else
        {
          TRACE_EVENT_P2("NO OK: cid_set:%d, nsapi_set:%d",working_cgact_actions.cid_set,working_cgact_actions.nsapi_set);
        }
      }
      else
      {      
        TRACE_EVENT_P1("meets not the set: %d",working_cgact_actions.cid_set);
      }
      break;
    case T_CDS_IDLE:
      TRACE_EVENT("T_CDS_IDLE");
      break;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_GetNewNSapi        |
+--------------------------------------------------------------------+

  PURPOSE : Give a free NSapi no. or invalid if all NSapi's are in use.
*/
LOCAL UBYTE cmhSM_GetNewNSapi ( void )
{
  BYTE i = SMH_FIRST_FREE_NSAPIS;

  TRACE_FUNCTION("cmhSM_GetNewNSapi");

  while ( i <= SMH_LAST_FREE_NSAPIS AND nsapi_to_cid[i] NEQ INVALID_CID )
    i++;

  if ( i <= SMH_LAST_FREE_NSAPIS)
  {
    pdp_context[work_cids[cid_pointer] - 1].nsapi = i;
    nsapi_to_cid[i] = work_cids[cid_pointer];

    TRACE_EVENT_P1("new NSAPI: %d", i);

    return i;
  }

  return INVALID_NSAPI;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_GiveNSapiFree      |
+--------------------------------------------------------------------+

  PURPOSE : Give a NSapi free after use.
*/
GLOBAL void cmhSM_GiveNSapiFree ( USHORT cid )
{
  UBYTE *nsapi = &pdp_context[cid - 1].nsapi;
  
  if ( *nsapi <= SMH_LAST_FREE_NSAPIS )
  {
    nsapi_to_cid[*nsapi] = INVALID_CID;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_contextDeactivated |
+--------------------------------------------------------------------+

  PURPOSE : Detach mobile if necessary?
*/
GLOBAL void cmhSM_contextDeactivated ( void )
{

  if  ( ! cmhSM_isContextActive() )
  {
    cmhGMM_allContextsDeactivated();
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_Get_pdp_type       |
+--------------------------------------------------------------------+

  PURPOSE : Give the PDP type of the current PDP context that will build.
*/
GLOBAL  UBYTE cmhSM_Get_pdp_type ( void )
{
  if (!strcmp(pdp_context[work_cids[cid_pointer] - 1].con.pdp_type, "IP"))
    return IP_V_4;

  return 0;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_Get_pdp_address    |
+--------------------------------------------------------------------+

  PURPOSE : Give the PDP address of the current PDP context that will build.
*/
GLOBAL  void  cmhSM_Get_pdp_address ( T_pdp_address *pdp_address )
{

  pdp_address->c_buff =
          (UBYTE) cmhSM_pdp_address_to_ip(&pdp_context[work_cids[cid_pointer] - 1].con.pdp_addr, (UBYTE*) pdp_address->buff);

#ifdef _SIMULATION_
memset (pdp_address->buff + pdp_address->c_buff, 0, sizeof(pdp_address->buff) - pdp_address->c_buff);
#endif
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_pdp_address_to_ip  |
+--------------------------------------------------------------------+

  PURPOSE : Transform a PDP address to 4 BYTE IP form.
*/
GLOBAL  SHORT  cmhSM_pdp_address_to_ip ( T_PDP_ADDRESS *pdp_address, UBYTE *ip )
{
  SHORT i = 0;
  BOOL  isDynamicIP = TRUE;
  char  *start = *pdp_address,
        *end;

  if ( **pdp_address )
  {
    for (i = 0; i < 4; i++)
    {
      ip[i] = (UBYTE) strtol(start, &end, 10);
      start = end + 1;
     /*
      *   dynamic ip patch
      *   12.02.02 brz
      *
      *   if it is a dynamic IP Address than the SM entity need the length set to zero
      */
      if ( ip[i]  )
      {
        isDynamicIP = FALSE;
      }
    }

    if ( isDynamicIP EQ TRUE )
    {
      return 0;
    }
    else
    {
      return 4;
    }
  }
  else
  {
  *ip = 0;
  }

  return 0;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_ip_to_pdp_address  |
+--------------------------------------------------------------------+

  PURPOSE : Transform a 4 BYTE IP form to the PDP address.
*/
GLOBAL  void  cmhSM_ip_to_pdp_address ( UBYTE *ip, T_PDP_ADDRESS pdp_address )
{

  sprintf(pdp_address, "%03hd.%03hd.%03hd.%03hd", ip[0], ip[1], ip[2], ip[3] );

}

/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                 |
| STATE   : finished              ROUTINE : convert_netaddr_to_apn  |
+-------------------------------------------------------------------+

  PURPOSE : converts a domain name into an APN

  Technical Information:

            The APN contains out of labels separated by dots.
            (e.g. xxx.yyy.zzz)

            This string representation must be translated to a network
            representation.

            The APN network representation contains out of a sequence of
            a length field (not ASCII) followed by a ASCII string.

            xxx.yyy.zzz => 3xxx3yyy3zzz
*/
LOCAL void convert_netaddr_to_apn ( T_smreg_apn *apn )
{
  UBYTE counter  = 0, 
        buffer   = apn->buffer[0],
        *pdest   = apn->buffer + apn->c_buffer,
        *psource = pdest - 1;

  if(apn->c_buffer EQ 0)
  {
    return;
  }

  if(apn->c_buffer >= sizeof apn->buffer)
  {
    apn->c_buffer = 0;
    TRACE_EVENT_P2 ("convert_netaddr_to_apn: array out of bounds exeption (%d >= %d)", apn->c_buffer, sizeof apn->buffer);
    return;
  }

  /* The network representation is 1 byte longer. */
  apn->c_buffer++;

  /* A sentinel */
  apn->buffer[0] = '.';
  
  /* Algorithm: copy from back to front! */
  while(pdest > apn->buffer )
  {
    counter = 0;
    while(*psource NEQ '.')
    {
      *(pdest--) = *(psource--);
      counter++;
    }
    *(pdest--) = counter;
    psource--;
  }

  /* Correction according to the sentinel */
  apn->buffer[1] = buffer;
  apn->buffer[0] = ++counter;

  /* Modify special empty APN to the need of SMREG_SAP */
  if ((apn->c_buffer EQ 2) AND (apn->buffer[0] EQ 1) AND (apn->buffer[1] EQ 255))
  {
    apn->c_buffer = 1; /* Special SMREG_SAP indicating that there is an APN present but empty */
    apn->buffer[0]= 0;
  }
}
/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_Get_smreg_apn      |
+--------------------------------------------------------------------+

  PURPOSE : Give the APN of the current PDP context that will build.
*/
GLOBAL  void  cmhSM_Get_smreg_apn ( T_smreg_apn *smreg_apn )
{

  smreg_apn->c_buffer = strlen(pdp_context[work_cids[cid_pointer] - 1].con.apn);
  strncpy((char *)smreg_apn->buffer, (const char *)pdp_context[work_cids[cid_pointer] - 1].con.apn, smreg_apn->c_buffer);
  convert_netaddr_to_apn(smreg_apn);

#ifdef _SIMULATION_
memset (smreg_apn->buffer + smreg_apn->c_buffer, 0, sizeof(smreg_apn->buffer) - smreg_apn->c_buffer);
#endif
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_Get_h_comp         |
+--------------------------------------------------------------------+

  PURPOSE : Give the h_comp of the current PDP context that will build.
*/
GLOBAL  UBYTE cmhSM_Get_h_comp ( void )
{

  return (UBYTE) pdp_context[work_cids[cid_pointer] - 1].con.h_comp;

}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_Get_d_comp         |
+--------------------------------------------------------------------+

  PURPOSE : Give the d_comp of the current PDP context that will build.
*/
GLOBAL  UBYTE cmhSM_Get_d_comp ( void )
{

  return (UBYTE) pdp_context[work_cids[cid_pointer] - 1].con.d_comp;

}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_change_def_QOS     |
+--------------------------------------------------------------------+

  PURPOSE : Set the quality of service (requested) of default context.

*/
GLOBAL  void    cmhSM_change_def_QOS      ( T_QOS *qos )
{

  memcpy(&defaultCtx.qos, qos, sizeof(T_QOS));

}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_change_def_QOS_min |
+--------------------------------------------------------------------+

  PURPOSE : Set the quality of service (min.) of default context.

*/
GLOBAL  void    cmhSM_change_def_QOS_min  ( T_QOS *qos )
{

  memcpy(&defaultCtx.min_qos, qos, sizeof(T_QOS));

}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_Set_default_QOS    |
+--------------------------------------------------------------------+

  PURPOSE : Set the quality of service of the spezified PDP context
            to default.
*/
GLOBAL  void  cmhSM_Set_default_QOS ( SHORT cid )
{

  memcpy(&pdp_context[cid - 1].con.qos, &defaultCtx.qos, sizeof(T_QOS));

}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_Set_default_QOS    |
+--------------------------------------------------------------------+

  PURPOSE : Set the quality of service of the spezified PDP context
            to default.
*/
GLOBAL  void  cmhSM_Set_default_QOS_min ( SHORT cid )
{

  memcpy(&pdp_context[cid - 1].con.min_qos, &defaultCtx.min_qos, sizeof(T_QOS));

}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_Get_QOS            |
+--------------------------------------------------------------------+

  PURPOSE : Give the requested quality of service of the current
            PDP context that will build.
*/
GLOBAL  void  cmhSM_Get_QOS ( T_smreg_qos *dest_qos )
{
  T_QOS *source_qos = &pdp_context[work_cids[cid_pointer] - 1].con.qos;

  dest_qos->preced   = source_qos->preced;
  dest_qos->delay    = source_qos->delay;
  dest_qos->relclass = source_qos->relclass;
  dest_qos->peak     = source_qos->peak;
  dest_qos->mean     = source_qos->mean;

}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_Get_QOS_min        |
+--------------------------------------------------------------------+

  PURPOSE : Give the minimum acceptable quality of service of the
            current PDP context that will build.
*/
GLOBAL  void  cmhSM_Get_QOS_min ( T_smreg_min_qos *dest_qos_min )
{
  T_QOS *source_qos = &pdp_context[work_cids[cid_pointer] - 1].con.min_qos;

  dest_qos_min->preced   = source_qos->preced;
  dest_qos_min->delay    = source_qos->delay;
  dest_qos_min->relclass = source_qos->relclass;
  dest_qos_min->peak     = source_qos->peak;
  dest_qos_min->mean     = source_qos->mean;

}

GLOBAL  USHORT cmhSM_pdp_typ_to_string ( UBYTE pdp_typ_no, char* string )
{
  switch ( pdp_typ_no )
  {
    case 0:
      strcpy (string, "X_121");
      return 5;
    case 33:
      strcpy (string, "IP_V_4");
      return 6;
    case 87:
      strcpy (string, "IP_V_6");
      return 6;
    default:
      strcpy (string, "");
      return 0;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_ring_gprs_par      |
+--------------------------------------------------------------------+

  PURPOSE : Return the information for CRING.
*/
GLOBAL  char* cmhSM_ring_gprs_par ( void )
{
  static char string[MAX_CRING_INFORMATION_LENGTH] = "\"";
  unsigned int i = 1;

  i += cmhSM_pdp_typ_to_string(gprs_call_table[current_gprs_ct_index].sm_ind.pdp_type, string + i);
  string[i++] = '\"';

  string[i++] = ',';

  string[i++] = '\"';
  memcpy (string + i, gprs_call_table[current_gprs_ct_index].sm_ind.pdp_address.buff,
                      gprs_call_table[current_gprs_ct_index].sm_ind.pdp_address.c_buff);

  i += gprs_call_table[current_gprs_ct_index].sm_ind.pdp_address.c_buff + 1;
  string[i++] = '\"';

  if ( *gprs_call_table[current_gprs_ct_index].L2P )
  {
  string[i++] = ',';

  string[i++] = '\"';
  strcpy (string + i, gprs_call_table[current_gprs_ct_index].L2P);
  i += strlen (gprs_call_table[current_gprs_ct_index].L2P);
  string[i++] = '\"';
  }

  string[i] = 0;

  return string;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_call_answer        |
+--------------------------------------------------------------------+

  PURPOSE : Return TRUE in this case, if an auto answer is needed.
*/
GLOBAL  BOOL  cmhSM_call_answer ( UBYTE ring_counter, T_ACI_CRING_MOD mode )
{

  switch(automatic_response_mode)
  {
    case 0: /* GPRS off, GSM controlled by S0 */
      if ( mode NEQ CRING_MOD_Gprs   AND
           at.S[0] AND at.S[0] <= ring_counter )
           return TRUE;
      break;
    case 1: /* GPRS on, GSM controlled by S0 */
      if ( mode EQ CRING_MOD_Gprs )
        return TRUE;
      if (at.S[0] AND at.S[0] <= ring_counter)
        return TRUE;
      break;
    case 2: /* modem copatibility mode, GPRS on, GSM off */
      if ( mode NEQ CRING_MOD_Gprs )
        break;
      /*lint -fallthrough*/
    case 3: /* modem copatibility mode, GPRS on, GSM on */
      if (at.S[0] AND ring_counter >= at.S[0])
        return TRUE;
  }

  return FALSE;
}


/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_call_reject        |
+--------------------------------------------------------------------+

  PURPOSE : Return TRUE in this case, if an auto reject is needed.
*/
GLOBAL  BOOL  cmhSM_call_reject ( UBYTE ring_counter, T_ACI_CRING_MOD mode )
{
  switch(automatic_response_mode)
  {
    case 0: /* GPRS off, GSM controlled by S0 */
      return FALSE;
    case 1: /* GPRS on, GSM controlled by S0 */
      if (at.S99 AND mode EQ CRING_MOD_Gprs )
        return TRUE;
      break;
    case 2: /* modem copatibility mode, GPRS on, GSM off */
    case 3: /* modem copatibility mode, GPRS on, GSM on */
      if ( mode NEQ CRING_MOD_Gprs )
        break;
      if (at.S99 AND ring_counter >= at.S99)
        return TRUE;
  }

  return FALSE;
}




LOCAL BOOL is_GSM_call_active (void)
{
  SHORT ctbIdx;               /* holds call table index */

  for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
  {
    if (ccShrdPrm.ctb[ctbIdx] NEQ NULL)
    {
      return (TRUE);
    }
  }

  return (FALSE);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_sAT_H              |
+--------------------------------------------------------------------+

  PURPOSE : handle GPRS calls and return FALSE if a circuit switched
            call need a handle.
*/
GLOBAL  BOOL  cmhSM_sAT_H ( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret )
{

  SHORT cid_array[1] = { INVALID_CID };
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, (UBYTE)srcId, search_ati_src_id);

  if ( ( at.rngPrms.isRng EQ TRUE ) AND ( at.rngPrms.mode EQ CRING_MOD_Gprs) )
  {
   /*
    *   brz patch: In the case of context reactivation over SMREG_PDP_ACTIVATE_IND with an used ti
    *              the GPRS ATH command doesn't do anything!
    *
    *   Why?       Because the Windows Dial-Up Networking client send every time an ATH after termination
    *              of the connection and with this a context reactivation was impossible. 
    */
    if ( gprs_call_table[current_gprs_ct_index].reactivation EQ GCTT_NORMAL )
    {
      return cmhSM_sAT_A_H_intern(srcId, aci_ret, 0);
    }
    return TRUE;
  }
  else
  {
    if (is_GSM_call_active())
    {
      return (FALSE);
    }
   /* if AT_H has been called and no RING is active, then disconnect the active
       context */
#ifdef FF_GPF_TCPIP
    if(is_gpf_tcpip_call())
    {
      T_DCM_STATUS_IND_MSG err_ind_msg;
      err_ind_msg.hdr.msg_id = DCM_ERROR_IND_MSG;
      err_ind_msg.result = DCM_PS_CONN_BROKEN;
      dcm_send_message(err_ind_msg, DCM_SUB_NO_ACTION);
    }
#endif
    *aci_ret = sAT_PlusCGACT ( srcId, CGACT_STATE_DEACTIVATED, cid_array );

    switch (*aci_ret)
    {
      case (AT_CMPL):                         /*operation completed*/
        return FALSE; /* return false, so that GSM calls will be canceled */
      case (AT_EXCT):
        src_params->curAtCmd    = AT_CMD_CGACT;
        return TRUE;
      default:
        cmdCmeError(CME_ERR_Unknown);         /*Command failed*/
        return FALSE;
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_sAT_A              |
+--------------------------------------------------------------------+

  PURPOSE : handle GPRS calls and return FALSE if a circuit switched
            call need a handle.
*/
GLOBAL  BOOL  cmhSM_sAT_A ( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret )
{
  BOOL b;

  b = cmhSM_sAT_A_H_intern(srcId, aci_ret, 1);

  if ( *aci_ret EQ AT_EXCT )
    cmdErrStr   = NULL;

  return b;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_sAT_A_H_intern     |
+--------------------------------------------------------------------+

  PURPOSE : handle sAT_A and cAT_H for GPRS
*/
static BOOL cmhSM_sAT_A_H_intern ( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret, SHORT mode)
{
  if ( at.rngPrms.isRng EQ TRUE )
  {
    if ( at.rngPrms.mode EQ CRING_MOD_Gprs)
    {
      *aci_ret =  automatic_response_mode > 1 ? /* modem copatibility mode possible */
                  sAT_PlusCGANS(srcId, mode, NULL, GPRS_CID_OMITTED): AT_FAIL;
    }
    else  /* circuit switched call */
    {
      return FALSE;
    }
  }
  else
  {
     return FALSE;
  }
  return TRUE;
}

/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                    |
| STATE   : finished              ROUTINE : cmhSM_pdp_addr_well_formed |
+----------------------------------------------------------------------+

  PURPOSE : check pdp address of well formed
*/
GLOBAL  BOOL cmhSM_pdp_addr_well_formed( USHORT type, T_PDP_ADDRESS pdp_addr )
{
  SHORT i = 0, state = 1;
  char *start = pdp_addr, *end;
  long temp;

  switch ( type )
  {
    case PDP_T_IP:  /* 255.255.255.255 */
      if ( *pdp_addr )
      {
        while ( state AND i < 3)
        {
          temp = strtol(start, &end, 10);
          if ( temp < 0 OR temp > 255 )
            state = 0;
          if ( *end NEQ '.' )
            state = 0;

          start = end + 1;
          i++;
        }
        temp = strtol(start, &end, 10);
        if ( temp < 0 OR temp > 255 )
          state = 0;
      }

      if(state)
        return TRUE;
      break;
    case PDP_T_X25:
      return FALSE;
    default:
      break;
  }
  return FALSE;
}

/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                    |
| STATE   : finished              ROUTINE : cmhSM_apn_well_formed      |
+----------------------------------------------------------------------+

  PURPOSE : check APN of well formed
*/
GLOBAL  BOOL cmhSM_apn_well_formed( T_APN APN )
{
  SHORT i = 0, state = 1, length = strlen (APN);
  char *no_start_labels[] = {"rac","lac","sgsn"}, *start, *end, *mark;
  T_APN apn;

  strcpy(apn, APN);
  start = apn;

  /* change charcter of string to lower cases */
  for (i = 0; i < length; i++)
    apn[i] = tolower(apn[i]);

  /* The Network Identifier shall not start with this labels */
  for (i = 0; i < 3; i++)
  {
    if ( apn EQ strstr(apn, no_start_labels[i]) )
      return FALSE;
  }

  /* the Wild Card APN */
  if ( length EQ 1 AND *start EQ '*' )
    return TRUE;

  /* the APN with no name */
  if ( length EQ 1 AND *start EQ /*lint -e(743)*/ '\x0ff' )
    return TRUE;

  /* Oporater Identifer is optional and the Network Identifer */
  mark = strrchr(apn, '.');
  if ( mark )
    if ( strstr(mark + 1, "gprs") )
    {
      /* APN Operator Identifier contained (optional) */
      if ( length < 18 )
        return FALSE;
      mark = start + length - 18; /* start of the APN Operator Identifier */
      /* check APN Operator Identifier: "mncXXX.mccXXX.gprs" */
      if ( mark NEQ strstr(mark, "mnc") )
        return FALSE;
      if ( mark + 6 NEQ strstr(mark, ".mcc") )
        return FALSE;
      strtol(mark + 3, &end, 10);
      if ( end NEQ mark + 6 )
        return FALSE;
      strtol(mark + 10, &end, 10);
      if ( end NEQ mark + 13 )
        return FALSE;
      /* check character between APN Network Identifier and the Operator Identifer */
      mark--;
      if ( *mark NEQ '.' )
        return FALSE;
      /* set stop mark */
      *mark = 0;
    }
    else
      mark = 0;

  /* check APN Network Identifier */

  /* shall not end in ".gprs" */
  end = strrchr(apn, '.');
  if ( end )
    if ( strstr(end + 1, "gprs") )
      return FALSE;

  /* parse all labels */
  while ( *start )
  {
    /* in first at least one Label */
    while ( (*start >= 'a' AND *start <= 'z') OR (*start >= '0' AND *start <= '9') OR *start EQ '-' )
      start ++;

    /* next Label or nothing */
    if ( *start EQ '.' )
      start ++;
    else
      if ( *start NEQ 0)
        return FALSE;
  }

  /* The APN Network Identifier shall have a maximum length of 63 octets. */
  if ( start - apn > 63 )
    return FALSE;

  /* clear stop mark */
  if ( mark )
    *mark = '.';

  return TRUE;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : CMH_SMF                  |
| STATE   : finished              ROUTINE : cmhSM_transform_pdp_type |
+--------------------------------------------------------------------+

  PURPOSE : transform pdp_type
*/
GLOBAL  USHORT cmhSM_transform_pdp_type      ( char *pdp_type )
{

  if ( !strcmp(pdp_type, "IP") )
    return PDP_T_IP;

  if ( !strcmp(pdp_type, "X25") )
    return PDP_T_X25;

  return PDP_T_NONE;
}


GLOBAL  T_CONTEXT_STATE get_state_over_cid ( SHORT cid )
{
  TRACE_FUNCTION("get_state_over_cid()");
  if ( (cid < 1) OR (cid > MAX_CID) )
  {
    TRACE_EVENT("invalid cid detected!");
    return CS_INVALID_STATE;
  }
  return pdp_context[cid - 1].state;

}

GLOBAL  void set_state_over_cid ( SHORT cid, T_CONTEXT_STATE c_state )
{
  TRACE_EVENT_P3("set_state_over_cid: %d -> %d for cid %d", pdp_context[cid - 1].state, c_state, cid) ;
  if (cid > 0 AND cid <= MAX_CID)
    pdp_context[cid - 1].state = c_state;
}

GLOBAL  T_CONTEXT_STATE   get_state_working_cid ( void )
{

  if ( work_cids[cid_pointer] EQ INVALID_CID )
  {
    TRACE_EVENT("working_cid is invalid!");
    return CS_INVALID_STATE;
  }

  return pdp_context[work_cids[cid_pointer] - 1].state;

}

GLOBAL  void  set_conn_param_on_all_working_cids ( UBYTE owner, T_DTI_ENTITY_ID entity_id )
{
  SHORT *pcid = &(work_cids[cid_pointer]);

  TRACE_FUNCTION("set_conn_param_on_all_working_cids()");

  while(INVALID_CID NEQ *pcid) {
    pdp_context[*pcid - 1].owner     = owner;
    pdp_context[*pcid - 1].entity_id = entity_id;
    pcid ++;
  }
}

GLOBAL  void  set_conn_param_on_working_cid ( UBYTE owner, T_DTI_ENTITY_ID entity_id )
{
  TRACE_FUNCTION("set_conn_param_on_working_cid()");
  
  pdp_context[work_cids[cid_pointer] - 1].owner     = owner;
  pdp_context[work_cids[cid_pointer] - 1].entity_id = entity_id;
}

GLOBAL  void  set_state_working_cid ( T_CONTEXT_STATE c_state )
{
  TRACE_FUNCTION("set_state_working_cid()");

  if ( work_cids[cid_pointer] NEQ INVALID_CID )
  {
    pdp_context[work_cids[cid_pointer] - 1].state = c_state;
  }
  else
  {
    TRACE_EVENT("working cid is invalid!");
  }

}

GLOBAL  T_CONTEXT_STATE   get_state_over_nsapi_set ( USHORT *nsapi_set, SHORT *cid )
{
  USHORT nsapi = 0;

  TRACE_FUNCTION("get_state_over_nsapi_set()");
  while( nsapi < SMH_LAST_FREE_NSAPIS AND !((*nsapi_set >> nsapi) & 1) )
    nsapi++;

  if ( !(*nsapi_set & ( 1 << nsapi )) )
  {
    return CS_INVALID_STATE;
  }

  TRACE_EVENT_P1("NSAPI: %4d", nsapi);

  *nsapi_set &= ~( 1U << nsapi );

  return get_state_over_cid( *cid = nsapi_to_cid[nsapi] );

}

GLOBAL  T_CONTEXT_STATE   get_state_over_nsapi ( USHORT nsapi )
{

  return get_state_over_cid( nsapi_to_cid[nsapi] );

}

GLOBAL  USHORT  cmhSM_Give_nsapi_set ( SHORT cid )
{

  if ( (cid < 1) OR (cid > MAX_CID) )
    return 0;

  return  1 << pdp_context[cid - 1].nsapi;

}

GLOBAL  T_ACI_CAL_OWN  get_owner_over_cid ( SHORT cid )
{

  if ( (cid < 1) OR (cid > MAX_CID) )
    return CAL_OWN_NONE;

  return pdp_context[cid - 1].owner;

}

GLOBAL void cmhGPPP_send_establish_request ( UBYTE peer )
{
  T_PPP_ESTABLISH_REQ est_req;

  memset(&est_req, 0, sizeof( T_PPP_ESTABLISH_REQ ));

  est_req.mode       = PPP_SERVER;
  est_req.mru        = PPP_MRU_DEFAULT;
  est_req.ap         = gpppShrdPrm.ppp_authentication_protocol;
  est_req.accm       = gpppShrdPrm.accm;
  est_req.rt         = gpppShrdPrm.restart_timer;
  est_req.mc         = gpppShrdPrm.max_configure;
  est_req.mt         = gpppShrdPrm.max_terminate;
  est_req.mf         = gpppShrdPrm.max_failure;

  est_req.peer_direction = DTI_CHANNEL_TO_LOWER_LAYER;
  est_req.prot_direction = DTI_CHANNEL_TO_HIGHER_LAYER;

  est_req.peer_link_id = pdp_context[work_cids[0] - 1].link_id_uart;
  est_req.prot_link_id = pdp_context[work_cids[0] - 1].link_id_new;

#ifdef _SIMULATION_
  memset (est_req.peer_channel.peer_entity,         0, CHANNEL_NAME_LENGTH);
  memset (est_req.protocol_channel.protocol_entity, 0, CHANNEL_NAME_LENGTH);
#endif  /* _SIMULATION_ */

  strcpy ( (char *) est_req.protocol_channel.protocol_entity, SNDCP_NAME);

  switch (peer)
  {
#ifdef BT_ADAPTER
    case DTI_ENTITY_BLUETOOTH:
      strcpy ( (char *) est_req.peer_channel.peer_entity, BTI_NAME);
      break;
#endif
    case DTI_ENTITY_UART:
      strcpy ( (char *) est_req.peer_channel.peer_entity, UART_NAME);
      break;
#ifdef FF_PSI      
    case DTI_ENTITY_PSI:
      strcpy ( (char *) est_req.peer_channel.peer_entity, PSI_NAME);
      break;
#endif /*FF_PSI*/
    case DTI_ENTITY_AAA:
      strcpy ( (char *) est_req.peer_channel.peer_entity, RIV_NAME);
      break;

    default:
      TRACE_ERROR ("[cmhGPPP_send_establish_request()] Unexpected peer!");
      return;
  }

  psaGPPP_Establish ( &est_req );

  set_state_working_cid( CS_ESTABLISH_1 );
}

GLOBAL void cmhSM_cgerep_buffer ( void )
{
  UBYTE srcId = srcId_cb;

  switch (ati_user_output_cfg[srcId].CGEREP_bfr)
  {
    case CGEREP_BFR_CLEAR:
      memset(gprs_event_buffer, 0, sizeof(T_CGERP_EVENT_BUFFER) * GPRS_EVENT_REPORTING_BUFFER_SIZE);
     break;
    case CGEREP_BFR_FLUSH:
      if ( uart_is_mt_te_link EQ FALSE)
      {
        while ( gprs_eb_oldest_p NEQ gprs_eb_current_p )
        {
          R_AT( RAT_CGEREP, srcId )
              ( gprs_event_buffer[gprs_eb_oldest_p].event, gprs_event_buffer[gprs_eb_oldest_p].parm );

          gprs_eb_oldest_p++;
        }
      }
      break;
    case CGEREP_BFR_OMITTED:
    case CGEREP_BFR_INVALID:
    default:
      break;
  }
}

GLOBAL void cmhSM_save_event( T_CGEREP_EVENT event, T_CGEREP_EVENT_REP_PARAM *param )
{

  /* save event */
  gprs_event_buffer[gprs_eb_current_p].event = event;
  if (param)
    memcpy (&gprs_event_buffer[gprs_eb_current_p].parm, param, sizeof(T_CGEREP_EVENT_REP_PARAM));

  /* is buffer full */
  if ( gprs_eb_oldest_p EQ gprs_eb_current_p )
    gprs_eb_oldest_p = -1;

  /* new current pointer */
  gprs_eb_current_p++;
  if ( gprs_eb_current_p EQ GPRS_EVENT_REPORTING_BUFFER_SIZE )
    gprs_eb_current_p = 0;

  /* if buffer full correct pointer to oldest event */
  if ( gprs_eb_oldest_p EQ -1 )
    gprs_eb_oldest_p = gprs_eb_current_p;

}

GLOBAL void cmhSM_set_sms_service     ( T_CGSMS_SERVICE service )
{

  {
    PALLOC (mnsms_mo_serv_req, MNSMS_MO_SERV_REQ);

    /* fill in primitive parameter: command request */
    mnsms_mo_serv_req -> mo_sms_serv = (UBYTE) service;

    PSENDX (SMS, mnsms_mo_serv_req);
  }

  m_service = service;
}

/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                      |
| STATE   : finnished        ROUTINE : cmhSM_sms_service_changed    |
+-------------------------------------------------------------------+

  PURPOSE : indicates a network initiated PDP context modification

*/
GLOBAL void cmhSM_sms_service_changed ( UBYTE service )
{

  TRACE_FUNCTION ("cmhSM_sms_service_changed()");

/*
 *-------------------------------------------------------------------
 * check for command context
 *-------------------------------------------------------------------
 */
  if ( smEntStat.curCmd EQ AT_CMD_CGSMS )
  {
    if ( m_service EQ service )
    {
      sm_cgsms_service = m_service;
      R_AT( RAT_OK, smEntStat.entOwn ) ( smEntStat.curCmd );
    }
    else
    {
      R_AT( RAT_CME, smEntStat.entOwn ) ( smEntStat.curCmd, CME_ERR_Unknown );
      /* log result */
      cmh_logRslt ( smEntStat.entOwn, RAT_CME, smEntStat.curCmd, -1, -1, CME_ERR_Unknown );
    }

    smEntStat.curCmd = AT_CMD_NONE;
  }
}

GLOBAL T_ACI_RETURN cmhSM_GprsAttached( SHORT state )
{
  SHORT i = 1;

  TRACE_FUNCTION ("cmhSM_GprsAttached()");

  if ( state )
  { /* mobile is attached */
    switch ( get_state_working_cid( ) )
    {
    case CS_ATTACHING_AFTER_DEF:
    case CS_ATTACHING_AFTER_UNDEF:
      cmhSM_data_link_context();
      return AT_EXCT;
    case CS_WAITS_FOR_ACTIVATING:
      if (cmhSM_activate_context() NEQ AT_FAIL)
      {
          return AT_EXCT;
      }
      else /*GPRS is not allowed by FDN */
      {
          return AT_FAIL;
      }      
    default:
      return AT_FAIL;
    }
  }
  else
  { /* attach failed */
    if (  smEntStat.curCmd  EQ AT_CMD_NONE AND
          gpppEntStat.curCmd EQ AT_CMD_NONE    )
      return AT_FAIL;

    /*
     *  it is enough to check only the working cid, 
     *  because only one context can be in work 
     */
    switch ( get_state_working_cid( ) )
    {
    case CS_ATTACHING_AFTER_DEF:
    case CS_ATTACHING_AFTER_UNDEF:
        pdp_context[work_cids[cid_pointer] - 1].owner = gpppEntStat.entOwn;
        gaci_RAT_caller ( RAT_NO_CARRIER, work_cids[cid_pointer], AT_CMD_CGDATA, 0 );
        break;    
    case CS_WAITS_FOR_ACTIVATING:
      pdp_context[work_cids[cid_pointer] - 1].owner = smEntStat.entOwn;
      gaci_RAT_caller ( RAT_CME, work_cids[cid_pointer], AT_CMD_CGACT, CME_ERR_GPRSUnspec );
      break;
    default:
      /*
       *  do nothing, because SM informs ACI over context deactivation
       */
      return AT_FAIL;
    }
    return cmhSM_deactivateAContext( smEntStat.entOwn, work_cids[cid_pointer] );
  }
}

GLOBAL T_ACI_RETURN cmhSM_activate_context(void)
{
  TRACE_FUNCTION ("cmhSM_activate_context()");

  if (pb_get_fdn_mode () EQ FDN_ENABLE)
  {
    if (pb_check_fdn (0, (const UBYTE *)"*99#") NEQ PHB_OK)
    {
      TRACE_EVENT("Activate Context: Entry not found in FDN, GPRS not allowed.");
      ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow);
      return (AT_FAIL);
    }
    TRACE_EVENT("Activate Context: Entry found in FDN, GPRS allowed.");
  }
  
  if( AT_CMPL EQ cmhGMM_contextActivation(smEntStat.entOwn, AT_CMD_CGACT) )
  {
    cmhSM_connect_working_cid();
    set_state_working_cid( CS_ACTIVATING );
  }
  else  /* AT_EXCT -> class BX class change requested (NOMIII) */
  {
    set_state_working_cid( CS_WAITS_FOR_ACTIVATING );  
  }
  return (AT_EXCT);
}


#if defined (CO_UDP_IP) || defined (FF_GPF_TCPIP)
/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)                 MODULE  : cmh_smf              |
| STATE   : initial                     ROUTINE : cmhSM_IP_activate_cb |
+----------------------------------------------------------------------+

  PURPOSE : callback function for WAP over GPRS.
            While handling the command ATD*98# in function atGD()
            the function psaTCPIP_Activate() is called for WAP handling.
            psaTCPIP_Activate() has this function as parameter for
            call backs.
*/
void cmhSM_IP_activate_cb(T_ACI_RETURN result)
{
  SHORT cid = gaci_get_cid_over_dti_id(wap_dti_id);
  
  TRACE_FUNCTION("cmhSM_IP_activate_cb");
  TRACE_EVENT_P1("wap_state: %s",wap_state_to_string(wap_state));
#ifndef FF_SAT_E
  ACI_ASSERT(DTI_DTI_ID_NOTPRESENT NEQ wap_dti_id);
  ACI_ASSERT(cid >= GPRS_CID_1 AND cid < GPRS_CID_INVALID);
  ACI_ASSERT(result NEQ AT_FAIL);
#endif /* not FF_SAT_E */

  if ( result EQ AT_FAIL )
  {
    /* IP activation failed. */
    TRACE_EVENT("UDP/TCP/IP activation/configuration returned AT_FAIL");
    
    if (DTI_LINK_ID_NOTPRESENT NEQ wap_dti_id)
    {
      dti_cntrl_close_dpath_from_dti_id (wap_dti_id);
      cmhSM_disconnect_cid(cid, GC_TYPE_WAP );
    }

    /* reset work_cids */
    set_state_over_cid(cid, CS_DEFINED);
    sAT_PercentWAP(smShrdPrm.owner, 0);
    smEntStat.curCmd = AT_CMD_NONE;
    dti_cntrl_erase_entry(wap_dti_id);
    cmdCmeError(CME_ERR_Unknown);

#if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
    if( cmhSAT_OpChnGPRSPend( INVALID_CID, OPCH_EST_REQ ))
    {
      cmhSAT_OpChnUDPDeactGprs();
    }
#endif  /* SIM_TOOLKIT */
    return;
  }

  switch(wap_state)
  {
    /* in case CO_UDP_IP and FF_GPF_TCPIP is defined this is a fall through case */
    UDPIP_STATEMENT(case IPA_Activated:)
    GPF_TCPIP_STATEMENT(case TCPIP_Activation:)

      if(is_gpf_tcpip_call()) {
        GPF_TCPIP_STATEMENT(set_conn_param_on_working_cid( 
                            (UBYTE)smEntStat.entOwn, DTI_ENTITY_TCPIP));
      }
      else {
        UDPIP_STATEMENT(set_conn_param_on_working_cid( 
                        (UBYTE)smEntStat.entOwn, DTI_ENTITY_IP));
      }
      cmhSM_activate_context();
      return;

    UDPIP_STATEMENT(case UDPA_Configurated:)
    GPF_TCPIP_STATEMENT(case TCPIP_Configurated:)

      /* smEntStat.curCmd = AT_CMD_NONE; */
#if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
      if( cmhSAT_OpChnGPRSPend( INVALID_CID, OPCH_EST_REQ ))
      {
        cmhSAT_OpChnUDPConfGprs();
      }
      else
#endif  /* SIM_TOOLKIT */
      {
        R_AT ( RAT_CONNECT, smEntStat.entOwn )( AT_CMD_CGACT, -1, wapId, FALSE );
      }
      smEntStat.curCmd = AT_CMD_NONE;
      smEntStat.entOwn = OWN_NONE;
#ifdef FF_GPF_TCPIP
      if(is_gpf_tcpip_call())
      {
        T_DCM_STATUS_IND_MSG msg;
        msg.hdr.msg_id = DCM_NEXT_CMD_READY_MSG;
        dcm_send_message(msg, DCM_SUB_WAIT_CGACT_CNF);
      }
#endif
      break;

    UDPIP_STATEMENT(case IPA_Deactivated:)
    GPF_TCPIP_STATEMENT(case TCPIP_Deactivated:)

      TRACE_EVENT_P1("cmhSM_IP_activate_cb, no connection, dti_id = %d", wap_dti_id);
#if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
      if( cmhSAT_OpChnGPRSPend( INVALID_CID, OPCH_NONE ))
      {
        cmhSAT_OpChnUDPDeactGprs();
      }
      else
#endif  /* SIM_TOOLKIT */
      {
        R_AT( RAT_NO_CARRIER,  pdp_context[cid - 1].owner) ( AT_CMD_CGDATA, 0 );
      }
      dti_cntrl_close_dpath_from_dti_id (wap_dti_id);
      cmhSM_connection_down(wap_dti_id);
      cmhSM_disconnect_cid(cid, GC_TYPE_WAP );
      sAT_PercentWAP(smShrdPrm.owner, 0);
      if(work_cids[cid_pointer] EQ cid)
      {
        smEntStat.curCmd = AT_CMD_NONE;
        *work_cids = 0;
        cid_pointer = 0;
      }
#ifdef FF_GPF_TCPIP
      if(is_gpf_tcpip_call())
      {
        T_DCM_STATUS_IND_MSG msg;
        msg.hdr.msg_id = DCM_NEXT_CMD_READY_MSG;
        dcm_send_message(msg, DCM_SUB_WAIT_CGDEACT_CNF);
      }
#endif
      break;

    default:
      TRACE_EVENT("Unexpected wap state in cmhSM_IP_activate_cb()");
      if(is_gpf_tcpip_call()) {
        GPF_TCPIP_STATEMENT(srcc_delete_count(SRCC_TCPIP_SNDCP_LINK ));
      }
      else {
        UDPIP_STATEMENT(srcc_delete_count(SRCC_IP_SNDCP_LINK ));
      }
      dti_cntrl_erase_entry(wap_dti_id);
      sAT_PercentWAP(smShrdPrm.owner, 0);
      smEntStat.curCmd = AT_CMD_NONE;

#if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
      if( cmhSAT_OpChnGPRSPend( INVALID_CID, OPCH_NONE ))
      {
        cmhSAT_OpChnUDPDeactGprs();
      }
      else
#endif  /* SIM_TOOLKIT */
      {
        cmdCmeError(CME_ERR_Unknown);
      }
      break;
  }
  return;
}


/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)                 MODULE  : cmh_smf              |
| STATE   : initial                     ROUTINE : cmhSM_IP_Enable      |
+----------------------------------------------------------------------+

  PURPOSE : enables IP dti connection.
*/
GLOBAL void cmhSM_IP_Enable ( T_DTI_CONN_LINK_ID link_id)
{
  TRACE_FUNCTION("cmhSM_IP_Enable");

#ifdef _SIMULATION_
  cmhSM_connect_context ( gaci_get_cid_over_link_id( link_id ),
                          DTI_ENTITY_IP, 0, 100 );
#else  /* _SIMULATION_ */
  cmhSM_connect_context ( gaci_get_cid_over_link_id( link_id ),
                          DTI_ENTITY_IP, 0, 0 );
#endif /* _SIMULATION_ */
}


/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)                 MODULE  : cmh_smf              |
| STATE   : initial                     ROUTINE : cmhSM_IP_Disable     |
+----------------------------------------------------------------------+

  PURPOSE : disables IP dti connection.
*/
GLOBAL void cmhSM_IP_Disable ()
{
  TRACE_FUNCTION("cmhSM_IP_Disable");
}

#endif /* WAP || FF_GPF_TCPIP || SAT E */

/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                      |
| STATE   : finnished        ROUTINE : cmhSM_data_link_context      |
+-------------------------------------------------------------------+
*/

GLOBAL void cmhSM_data_link_context(void)
{

  TRACE_FUNCTION ("cmhSM_data_link_context()");

  R_AT( RAT_CONNECT, pdp_context[work_cids[cid_pointer] - 1].owner )
    ( AT_CMD_CGDATA, 0, 0, FALSE );

  /* log result */
  cmh_logRslt ( pdp_context[work_cids[cid_pointer] - 1].owner,
                RAT_CONNECT, AT_CMD_CGDATA, -1, -1, -1 );

  cmhSM_connect_working_cid();

}
/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                      |
| STATE   : finnished        ROUTINE : cmhSM_get_cid                |
+-------------------------------------------------------------------+

*/

GLOBAL  SHORT   cmhSM_get_cid ( USHORT nsapi )
{

  return nsapi_to_cid[nsapi];
}

/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                      |
| STATE   : finnished        ROUTINE : cmhSM_next_work_cid          |
+-------------------------------------------------------------------+

  PURPOSE : start the next context activation if requested

*/
GLOBAL  BOOL    cmhSM_next_work_cid ( T_ACI_AT_CMD curCmd )
{

  TRACE_EVENT_P1("cmhSM_next_work_cid, cid_pointer: %d", cid_pointer);

  cid_pointer ++;

  if ( work_cids[cid_pointer] EQ INVALID_CID )
  {
    smEntStat.curCmd = AT_CMD_NONE;
    gpppEntStat.curCmd = AT_CMD_NONE;

    cid_pointer  = 0;
    *work_cids = 0;
    return FALSE;
  }

  switch ( curCmd )
  {
    case AT_CMD_CGDATA:
      cmhSM_data_link_context();
      break;
    case AT_CMD_CGACT:
      if(AT_FAIL EQ cmhSM_activate_context())
      {
         smEntStat.curCmd = AT_CMD_NONE;
         gpppEntStat.curCmd = AT_CMD_NONE;
         cid_pointer  = 0;
         *work_cids = 0;
         /*R_AT (RAT_CME, smEntStat.entOwn)( AT_CMD_CGACT, CME_ERR_Unknown );*/
         return FALSE;
      }      
      break;
    default:
      cid_pointer  = 0;
      *work_cids = 0;
      return FALSE;
  }
  return TRUE;
}

/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                      |
| STATE   : finnished        ROUTINE : cmhSM_define_cid_list        |
+-------------------------------------------------------------------+

  PURPOSE : define all cid's in the list, if necessary

*/
GLOBAL SHORT cmhSM_define_cid_list( T_ACI_CMD_SRC srcId, SHORT *cids )
{
  int i = 1;
  
  TRACE_FUNCTION("cmhSM_define_cid_list");  
 
  if(INVALID_CID != *work_cids)
  {
    return 0;  
  }

  if ( *cids EQ GPRS_CID_OMITTED) /* if no cid given */
  {
    while ( i <= MAX_CID AND get_state_over_cid( (SHORT)i ) NEQ CS_DEFINED )
      i++;

    if ( i > MAX_CID )
    {
      i = 1;
      while ( i <= MAX_CID AND get_state_over_cid( (SHORT)i ) NEQ CS_UNDEFINED )
        i++;

      if ( i <= MAX_CID )
      {
       /*
        *  reset of context parameter if cid undefined
        */
        sAT_PlusCGDCONT_exec (srcId, (SHORT)i, &defaultCtx);
        set_state_over_cid((SHORT)i, CS_UNDEFINED);
      }
      else
        return 0;
    }

    *cids = work_cids[0] = i;
    work_cids[1] = INVALID_CID;
    i = 1; /* no. of cids */
  }
  else  /* if cid(s) is/are given */
  {
    SHORT j = 0;
    i = 0;

    /*
     *  checks given cid parameter
     */
    while ( i < MAX_CID AND cids[i] NEQ INVALID_CID )
    {
      /* check cid */
      if ( cids[i] < GPRS_CID_1 OR cids[i] >= GPRS_CID_INVALID )
        return 0;
      /* count cids */
      i++;
    }

    if ( MAX_CID < i )
      return 0;

    memcpy (work_cids, cids, sizeof( *work_cids ) * (i + 1) );

    /*
     *  reset of context parameter if cid undefined
     */
    for (j = 0; work_cids[j] NEQ INVALID_CID; j++)
    {
      switch(get_state_over_cid(work_cids[j]))
      {
        case CS_UNDEFINED:
          sAT_PlusCGDCONT_exec (srcId, work_cids[j], &defaultCtx);
          set_state_over_cid(work_cids[j], CS_UNDEFINED);
          /*lint -fallthrough*/
        case CS_DEFINED:
        case CS_ACTIVATED:
          break;
        default:
          memset (work_cids, 0, sizeof( *work_cids ) * (i + 1) );
          return 0;
      }
    }
  }
  
  return i;
}

/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                         |
| STATE   : finnished        ROUTINE : cmhSM_get_pdp_addr_for_CGPADDR  |
+----------------------------------------------------------------------+

  PURPOSE : return the PDP_address to one cid for the GPRS CGPADDR AT command

*/
GLOBAL SHORT cmhSM_get_pdp_addr_for_CGPADDR ( SHORT cid, T_PDP_ADDRESS pdp_adress )
{
  T_CONTEXT_STATE c_state;      /* state of context */

  c_state = get_state_over_cid( cid );

  if ( c_state EQ CS_UNDEFINED OR c_state EQ CS_INVALID_STATE )
  {
    *pdp_adress = 0;
    return INVALID_CID;
  }

  if ( c_state EQ CS_ACTIVATED OR c_state EQ CS_DATA_LINK )
    strcpy( pdp_adress, pdp_context[cid - 1].allocated_pdp_addr );
  else
    strcpy( pdp_adress, pdp_context[cid - 1].con.pdp_addr );

  return cid;
}

/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                         |
| STATE   : finnished        ROUTINE : cmhSM_is_smreg_ti_used          |
+----------------------------------------------------------------------+

  PURPOSE : handle for used smreg_ti

*/
GLOBAL BOOL cmhSM_is_smreg_ti_used ( UBYTE smreg_ti, SHORT *cid )
{
  SHORT i = 0;

  while ( i < MAX_CID )
  {
    if ( pdp_context[i].smreg_ti EQ smreg_ti)
    {
      psaSM_PDP_Deactivate ( (USHORT) (1 << pdp_context[i].nsapi), SMREG_LOCAL);
      psaGPPP_Terminate( PPP_LOWER_LAYER_UP );

      call_waits_in_table = TRUE;
      *cid = i + 1;
      set_state_over_cid(*cid, CS_CONTEXT_REACTIVATION_1);
      return TRUE;
    }

    i++;
  }

  return FALSE;
}

/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                         |
| STATE   : finnished        ROUTINE : cmhSM_context_reactivation      |
+----------------------------------------------------------------------+

  PURPOSE :

*/
GLOBAL void cmhSM_context_reactivation ( void )
{
  T_CGEREP_EVENT_REP_PARAM  event;
  T_SMREG_PDP_ACTIVATE_IND *sm_ind;
  SHORT i = 0;

  if ( call_waits_in_table EQ TRUE )
  {
    call_waits_in_table = FALSE;
   /*
    *   GPRS event reporting
    */
    sm_ind = &gprs_call_table[current_gprs_ct_index].sm_ind;

    cmhSM_pdp_typ_to_string(sm_ind->pdp_type, (char*) &event.act.pdp_type);
    memcpy(&event.act.pdp_addr, &sm_ind->pdp_address.buff, sm_ind->pdp_address.c_buff);
    event.act.cid      = gprs_call_table[current_gprs_ct_index].cid;
    for( i = 0 ; i < CMD_SRC_MAX; i++ )
    {
      R_AT( RAT_CRING, i )  ( CRING_MOD_Gprs, CRING_TYP_GPRS, CRING_TYP_NotPresent );
      R_AT( RAT_CGEREP, i ) ( CGEREP_EVENT_NW_REACT, &event );
      R_AT( RAT_P_CGEV, i ) ( CGEREP_EVENT_NW_REACT, &event );
    }
  }
  else
  {
    cmhSM_next_call_table_entry();
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                         |
| STATE   : finnished        ROUTINE : cmhSM_stop_context_reactivation |
+----------------------------------------------------------------------+

  PURPOSE :

*/
GLOBAL void cmhSM_stop_context_reactivation ( void )
{

  call_waits_in_table = FALSE;
}

GLOBAL void cmhSM_next_call_table_entry( void )
{
  current_gprs_ct_index++;

  if ( current_gprs_ct_index >= gprs_ct_index )
  {
    cmhSM_empty_call_table();
  }
  else
  {
    cmhSM_context_reactivation();
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                         |
| STATE   : finnished        ROUTINE : cmhSM_init_GPRS_DTI_list        |
+----------------------------------------------------------------------+

  PURPOSE : Init all DTI identifier for GPRS.
*/
GLOBAL SHORT cmhSM_connect_working_cid ( void )
{
  T_GPRS_CONT_CLASS *context_info = &pdp_context[work_cids[cid_pointer] - 1];

  switch ( context_info->entity_id )
  {
    case DTI_ENTITY_PPPS:
      srcc_new_count(SRCC_PPPS_SNDCP_LINK);

      if (IS_SRC_BT(context_info->owner))
      {
        T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_BLUETOOTH, DTI_ENTITY_PPPS, DTI_ENTITY_SNDCP};
        UBYTE dti_id = dti_cntrl_new_dti(DTI_DTI_ID_NOTPRESENT);
        dti_cntrl_est_dpath ( dti_id,
                              entity_list,
                              3,
                              SPLIT,
                              PPP_UART_connect_dti_cb);
      }
      else
      {
        T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_PPPS, DTI_ENTITY_SNDCP};
        dti_cntrl_est_dpath_indirect ((UBYTE)context_info->owner, 
                                       entity_list, 
                                       2, 
                                       SPLIT, 
                                       PPP_UART_connect_dti_cb, 
                                       DTI_CPBLTY_SER, 
                                       (UBYTE)work_cids[cid_pointer]);
      }

      m_mt_te_link = TRUE;
      break;
      
    case DTI_ENTITY_IP:
#ifdef CO_UDP_IP
      {
        T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_IP, DTI_ENTITY_SNDCP};
        UBYTE dti_id;
#ifdef FF_SAT_E
        if ( satShrdPrm.opchStat EQ OPCH_EST_REQ )
          dti_id = simShrdPrm.sat_class_e_dti_id;
        else
#endif /* FF_SAT_E */          
          dti_id = wap_dti_id;

        /* link_id should be created in atGD already, so just connect: */
        if (!dti_cntrl_est_dpath( dti_id,
                                  entity_list,
                                  2,
                                  APPEND,
                                  IP_UDP_connect_dti_cb))
        {
          TRACE_EVENT("cmhSM_connect_working_cid: dti_cntrl_est_dpath returned FALSE");
          return 0;
        }
      }
#endif /* CO_UDP_IP */
      break;

#ifdef FF_SAT_E      
    case DTI_ENTITY_SIM:
    {
      T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_SIM, DTI_ENTITY_SNDCP};
      /* create a SAT class E DTI ID if not present */
      if ( simShrdPrm.sat_class_e_dti_id EQ DTI_DTI_ID_NOTPRESENT )
      {
        simShrdPrm.sat_class_e_dti_id = dti_cntrl_new_dti(DTI_DTI_ID_NOTPRESENT);
        TRACE_EVENT_P1("sat_class_e_dti_id = %d", simShrdPrm.sat_class_e_dti_id);
      }
      srcc_new_count(SRCC_SIM_SNDCP_LINK);
      TRACE_FUNCTION("cmhSM_connect_working_cid:GC_TYPE_SIM");
      context_info->link_id_new = 
        dti_conn_compose_link_id (0, 0, simShrdPrm.sat_class_e_dti_id, DTI_TUPLE_NO_NOTPRESENT);
      dti_cntrl_est_dpath( simShrdPrm.sat_class_e_dti_id,
                           entity_list,
                           2,
                           SPLIT,
                           SIM_SNDCP_connect_dti_cb);
      break;
    }
#endif /* FF_SAT_E */

    case DTI_ENTITY_NULL:
      {
        T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_NULL, DTI_ENTITY_SNDCP};
        UBYTE dti_id = dti_cntrl_new_dti(DTI_DTI_ID_NOTPRESENT);
        srcc_new_count(SRCC_NULL_SNDCP_LINK);
        context_info->link_id_new   = dti_conn_compose_link_id (0, 0, dti_id, DTI_TUPLE_NO_NOTPRESENT );
      
        dti_cntrl_est_dpath( dti_id,
                             entity_list,
                             2,
                             SPLIT,
                             NULL_SNDCP_connect_dti_cb);
        break;
      }
#if defined (FF_GPF_TCPIP)
    case DTI_ENTITY_TCPIP:
    {
      T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_TCPIP, DTI_ENTITY_SNDCP};
      UBYTE dti_id;
      dti_id = wap_dti_id;
      /* link_id should be created in atGD already, so just connect: */
      if (!dti_cntrl_est_dpath( dti_id,
                                entity_list,
                                2,
                                SPLIT,
                                TCPIP_connect_dti_cb))
      {
        TRACE_EVENT("cmhSM_connect_working_cid: dti_cntrl_est_dpath returned FALSE");
        return 0;
      }
    }
    break;
#endif /* FF_GPF_TCPIP */

#if defined(FF_PKTIO) OR defined(FF_TCP_IP) OR defined (FF_PSI)
    case DTI_ENTITY_INVALID:
      {
        T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_SNDCP};
        srcc_new_count(SRCC_PKTIO_SNDCP_LINK);
              
        dti_cntrl_est_dpath_indirect((UBYTE)context_info->owner,
                                      entity_list,
                                      1, SPLIT,
                                      PKTIO_SNDCP_connect_dti_cb,
                                      DTI_CPBLTY_PKT,
                                      (UBYTE)work_cids[cid_pointer]);
        set_state_working_cid( CS_ACTIVATING );
        break;
      }
#endif /* FF_PKTIO OR FF_TCP_IP OR FF_PSI */
    default:
      return 0;

  }

  return 1;
}


GLOBAL void cmhSM_disconnect_cid ( SHORT cid, T_GPRS_CONNECT_TYPE type )
{
  T_DTI_CONN_LINK_ID link_id = cmhSM_get_link_id_SNDCP_peer( cid, SNDCP_PEER_NORMAL );

  TRACE_FUNCTION("cmhSM_disconnect_cid");
  TRACE_EVENT_P1("link_id %d",link_id);
  if ( DTI_LINK_ID_NOTPRESENT NEQ link_id)
  {
    switch ( type )
    {
      case GC_TYPE_DATA_LINK:
        srcc_delete_count( SRCC_PPPS_SNDCP_LINK );
        pdp_context[cid - 1].link_id_sn = DTI_LINK_ID_NOTPRESENT;
        pdp_context[cid - 1].link_id_new = DTI_LINK_ID_NOTPRESENT;
        pdp_context[cid - 1].link_id_uart = DTI_LINK_ID_NOTPRESENT;
        pdp_context[cid - 1].entity_id = DTI_ENTITY_INVALID;
        m_mt_te_link = FALSE;
        break;
        
      case GC_TYPE_WAP:
        if(is_gpf_tcpip_call())
        {
          GPF_TCPIP_STATEMENT(srcc_delete_count( SRCC_TCPIP_SNDCP_LINK ));
        }
        else
        {
          srcc_delete_count( SRCC_IP_SNDCP_LINK );
        }
        pdp_context[cid - 1].link_id_sn = DTI_LINK_ID_NOTPRESENT;
        pdp_context[cid - 1].link_id_new = DTI_LINK_ID_NOTPRESENT;
        pdp_context[cid - 1].link_id_uart = DTI_LINK_ID_NOTPRESENT;
        pdp_context[cid - 1].entity_id = DTI_ENTITY_INVALID;
        break;

      case GC_TYPE_NULL:
      case GC_TYPE_EMAIL:
        switch ( pdp_context[cid - 1].entity_id )
        {
          case DTI_ENTITY_IP:
          GPF_TCPIP_STATEMENT(case DTI_ENTITY_TCPIP:)
            if(is_gpf_tcpip_call())
            {
              GPF_TCPIP_STATEMENT(srcc_delete_count( SRCC_TCPIP_SNDCP_LINK ));
            }
            else
            {
              srcc_delete_count( SRCC_IP_SNDCP_LINK );
            }
            dti_cntrl_erase_entry(EXTRACT_DTI_ID(link_id));
            break;

          case DTI_ENTITY_NULL:
            dti_cntrl_entity_disconnected( link_id, DTI_ENTITY_NULL );
            srcc_delete_count( SRCC_NULL_SNDCP_LINK );
            dti_cntrl_erase_entry(EXTRACT_DTI_ID(link_id));
            break;

#if defined(FF_PKTIO) OR defined(FF_TCP_IP) || defined(FF_GPF_TCPIP) OR defined (FF_PSI)
          case DTI_ENTITY_PKTIO:
          case DTI_ENTITY_PSI:
          case DTI_ENTITY_AAA:
            srcc_delete_count( SRCC_PKTIO_SNDCP_LINK );
            break;
#endif /* FF_PKTIO OR FF_TCP_IP || FF_GPF_TCPIP OR FF_PSI */
        }
        pdp_context[cid - 1].link_id_sn = DTI_LINK_ID_NOTPRESENT;
        pdp_context[cid - 1].link_id_new = DTI_LINK_ID_NOTPRESENT;
        pdp_context[cid - 1].link_id_uart = DTI_LINK_ID_NOTPRESENT;
        pdp_context[cid - 1].entity_id = DTI_ENTITY_INVALID;
        break;
        
    }
  }
}

GLOBAL BOOL uart_is_mt_te_link( void )
{

  return m_mt_te_link;
}

GLOBAL void cmhSNDCP_Disable( T_DTI_CONN_LINK_ID link_id )
{
  SHORT cid = gaci_get_cid_over_link_id( link_id );
  
 /*
   *  disconnects the context if the link_id is the current link_id of this context
   *
   *  the other case: 
   *      the context is switching to an other peer and the old link_id is requested 
   *      to be disconnected, NOT the context itself
   */
  if (cmhSM_get_link_id_SNDCP_peer(cid, SNDCP_PEER_NORMAL) EQ link_id)
  {
    cmhSM_deactivateAContext(CMD_SRC_NONE, cid);
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                         |
| STATE   : finnished        ROUTINE : cmhSM_connect_context           |
+----------------------------------------------------------------------+

  PURPOSE : Connect an activated or deactivated PDP context with an entity.
*/
GLOBAL SHORT cmhSM_connect_context ( SHORT cid, T_DTI_ENTITY_ID peer, UBYTE ppp_hc, UBYTE msid )
{
  ULONG dti_neighbor;
  UBYTE dti_direction, hcomp = cmhSM_Get_h_comp() ? SMREG_COMP_BOTH_DIRECT: SMREG_COMP_NEITHER_DIRECT;

  TRACE_FUNCTION("cmhSM_connect_context()");

  switch ( peer )
  {
    case DTI_ENTITY_PPPS:
      dti_neighbor  = (ULONG) PPP_NAME;
      dti_direction = SMREG_HOME;
      break;
    case DTI_ENTITY_NULL:
      dti_neighbor  = (ULONG) NULL_NAME;
      dti_direction = SMREG_NEIGHBOR;
      smShrdPrm.direc = DIREC_MO;
      break;
    case DTI_ENTITY_IP:
      dti_neighbor  = (ULONG) IP_NAME;
      dti_direction = SMREG_NEIGHBOR;
      smShrdPrm.direc = DIREC_MO;
#ifdef FF_WAP
      if (Wap_Call)   
        rAT_WAP_start_gprs_login();
#endif /* FF_WAP */
      break;
#ifdef FF_SAT_E      
    case DTI_ENTITY_SIM:
      dti_neighbor  = (ULONG) SIM_NAME;
      dti_direction = SMREG_NEIGHBOR;
      smShrdPrm.direc = DIREC_MO;
      break;
#endif /* FF_SAT_E */      
#if defined(FF_PKTIO) OR defined(FF_TCP_IP) OR defined(FF_PSI)
    case DTI_ENTITY_PKTIO:
      dti_neighbor  = (ULONG) PKTIO_NAME;
      dti_direction = SMREG_HOME;
      smShrdPrm.direc = DIREC_MO;
      break;
    case DTI_ENTITY_PSI:
      dti_neighbor  = (ULONG) PSI_NAME;
      dti_direction = SMREG_HOME;
      smShrdPrm.direc = DIREC_MO;
      break;
    case DTI_ENTITY_AAA:
      dti_neighbor  = (ULONG) RIV_NAME;
      dti_direction = SMREG_NEIGHBOR;
      smShrdPrm.direc = DIREC_MO;
      break;
#endif /* FF_PKTIO OR FF_TCP_IP OR FF_PSI */
#ifdef FF_GPF_TCPIP
    case DTI_ENTITY_TCPIP:
      dti_neighbor  = (ULONG) TCPIP_NAME;
      dti_direction = SMREG_NEIGHBOR;
      smShrdPrm.direc = DIREC_MO;
      break;
#endif /* FF_GPF_TCPIP */
    default:
      return 0;
  }

  pdp_context[cid - 1].entity_id = peer;

#ifdef _SIMULATION_
  dti_neighbor                   = 0xfe1234ef;
#endif

  if ( DTI_LINK_ID_NOTPRESENT EQ pdp_context[cid - 1].link_id_sn )
  { /* context is deactivated */
    cmhSM_GetNewNSapi();

    psaSM_ActivateReq ( cid,
                        (UBYTE) (hcomp? ppp_hc: 0),
                        msid,
                        hcomp,
                        pdp_context[cid - 1].link_id_new,
                        dti_neighbor,
                        dti_direction );

  }
  else
  { /* context is activated */
EXTERN void psaSN_SwitchReq ( UBYTE nsapi,
                              ULONG dti_linkid,
                              ULONG dti_neighbor,
                              UBYTE dti_direction );

    psaSN_SwitchReq ( pdp_context[cid - 1].nsapi,
                      pdp_context[cid - 1].link_id_new,
                      dti_neighbor, dti_direction);

  dti_cntrl_close_dpath_from_dti_id (EXTRACT_DTI_ID(pdp_context[cid - 1].link_id_sn));
  dti_cntrl_entity_disconnected( pdp_context[cid - 1].link_id_sn, DTI_ENTITY_SNDCP );
  dti_cntrl_erase_entry( EXTRACT_DTI_ID(pdp_context[cid - 1].link_id_sn) );
  }

  return 1;
}

GLOBAL void cp_pdp_primitive(T_SMREG_PDP_ACTIVATE_CNF * pdp_activate_cnf,
                       T_PPP_PDP_ACTIVATE_RES *activate_result)
{
 
  activate_result->ppp_hc = pdp_activate_cnf->ppp_hc;
  activate_result->msid = pdp_activate_cnf->msid;

  /*
   * copy IP address
   */
  activate_result->ip = pdp_activate_cnf->pdp_address.buff[0];
  activate_result->ip = activate_result->ip << 8;
  activate_result->ip+= pdp_activate_cnf->pdp_address.buff[1];
  activate_result->ip = activate_result->ip << 8;
  activate_result->ip+= pdp_activate_cnf->pdp_address.buff[2];
  activate_result->ip = activate_result->ip << 8;
  activate_result->ip+= pdp_activate_cnf->pdp_address.buff[3];


  activate_result->sdu.l_buf = pdp_activate_cnf->sdu.l_buf;
  activate_result->sdu.o_buf = 0;

  if (pdp_activate_cnf->sdu.l_buf > 0) {
    memcpy(activate_result->sdu.buf,
           &pdp_activate_cnf->sdu.buf[pdp_activate_cnf->sdu.o_buf >> 3],
           pdp_activate_cnf->sdu.l_buf >> 3);
  }
}
  

GLOBAL SHORT cmhSM_context_connected( USHORT nsapi )
{
  T_GPRS_CONT_CLASS *context_info = &pdp_context[nsapi_to_cid[nsapi] - 1];
  UBYTE ip[4];

  TRACE_FUNCTION("cmhSM_context_connected");

  context_info->link_id_sn = context_info->link_id_new;
  context_info->link_id_new = DTI_LINK_ID_NOTPRESENT;

  switch (context_info->entity_id)
  {
    case DTI_ENTITY_PPPS:
      cmhSM_pdp_address_to_ip(&context_info->allocated_pdp_addr, ip);
      psaGPPP_PDP_Activate(0, 0, ip, 
                           context_info->network_pco.pco, context_info->network_pco.len);
      set_state_working_cid( CS_ESTABLISH_3 );
      break;

#ifdef FF_PKTIO
    case DTI_ENTITY_PKTIO:
#endif /* FF_PKTIO */
#ifdef FF_PSI
    case DTI_ENTITY_PSI:
#endif /* FF_PSI */
#ifdef FF_SAT_E 
    case DTI_ENTITY_SIM:
#endif /* FF_SAT_E */
#ifdef FF_TCP_IP
    case DTI_ENTITY_AAA:
#endif /* FF_TCP_IP */
#if defined (FF_SAT_E) OR defined (FF_TCP_IP) OR defined (FF_PKTIO) OR defined (FF_PSI)
      dti_cntrl_entity_connected( context_info->link_id_sn, DTI_ENTITY_SNDCP, DTI_OK);
      set_state_working_cid( CS_ACTIVATED );      
#if defined(FF_PKTIO) OR defined (FF_PSI)
      cmhSM_next_work_cid(smEntStat.curCmd);      
#endif /* FF_PKTIO OR FF_PSI */        
      break;
#endif /* #if defined (FF_SAT_E) OR defined (FF_TCP_IP) OR defined (FF_PKTIO) OR FF_PSI */
  } /* switch (context_info->entity_id) */
  return 1;
} /* GLOBAL SHORT cmhSM_context_connected( USHORT nsapi ) */
   

/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                         |
| STATE   : finnished        ROUTINE : cmhSM_set_PCO                   |
+----------------------------------------------------------------------+

  PURPOSE : Set a PCO in the context of the cid.
*/
GLOBAL void cmhSM_set_PCO( SHORT cid, T_PCO_TYPE pco_type, UBYTE* buf_addr, UBYTE length)
{
  T_GPRS_CONT_PCO* dest;

  switch ( pco_type )
  {
    case PCO_USER:
      dest = &pdp_context[cid - 1].user_pco;
      break;
    case PCO_NETWORK:
      dest = &pdp_context[cid - 1].network_pco;
      break;
  }
  /*lint -e(644) */ /* all possible types defined */
  memcpy(dest->pco, buf_addr, length);
  dest->len = length;
}

/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                         |
| STATE   : finnished        ROUTINE : cmhSM_get_dti_SNDCP_pper        |
+----------------------------------------------------------------------+

  PURPOSE : Give back the right DTI-ID for the SNDCP - peer connection.
*/
GLOBAL ULONG cmhSM_get_link_id_SNDCP_peer( SHORT cid, T_SNDCP_PEER which )
{

  switch ( which )
  {
    case SNDCP_PEER_NORMAL:
      return pdp_context[cid - 1].link_id_new NEQ DTI_LINK_ID_NOTPRESENT ? 
             pdp_context[cid - 1].link_id_new: pdp_context[cid - 1].link_id_sn;
    case SNDCP_PEER_SWITCHED:
      return pdp_context[cid - 1].link_id_sn;
  }

  return DTI_LINK_ID_NOTPRESENT;
}

/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                         |
| STATE   : code             ROUTINE : cmhSM_context_deactivated       |
+----------------------------------------------------------------------+

  PURPOSE : Control the answer of context deactivations 
            started by an AT command. 
*/
GLOBAL void cmhSM_context_deactivated( USHORT nsapi_set )
{

  switch( working_cgact_actions.state  )
  {
    case T_CDS_RUNNING:
      if  ( nsapi_set & working_cgact_actions.nsapi_set )
      { /* nsapi deactivation is requested */
        working_cgact_actions.nsapi_set &= ~nsapi_set;
        if ( ! (working_cgact_actions.cid_set  OR
                working_cgact_actions.nsapi_set  ) )
        { 
            R_AT( RAT_OK, working_cgact_actions.srcId ) ( AT_CMD_CGACT );
            working_cgact_actions.state = T_CDS_IDLE;
        }
      }
      break;
    case T_CDS_IDLE:
      break;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : GSM-PS (8441)         MODULE  : CMH_SMF                    |
| STATE   : finnished             ROUTINE : deactivateAContextForCGACT |
+----------------------------------------------------------------------+

PURPOSE       : deactivate a context for CGACT

RETURN VALUE  : TRUE  - AT_EXCT have to be returned for this context
                FALSE - AT_CMPL have to be reported for this context

*/
static T_ACI_RETURN deactivateAContextForCGACT(SHORT cid)
{
  T_CONTEXT_STATE ctx_state = get_state_over_cid( cid );
    
  SRCC_LINK_NO    srcc_link_no= SRCC_INVALID_LINK;
  T_DTI_ENTITY_ID dti_entity_id= DTI_ENTITY_INVALID;
  

  
  TRACE_FUNCTION("deactivateAContextForCGACT()");

#if defined (CO_UDP_IP) || defined (FF_GPF_TCPIP)



  /*
   *  additinal behaviour for WAP
   *  abort ATD*98# before context activation requested
   *  2003.05.06 brz
   */
  if(is_gpf_tcpip_call()) {
    GPF_TCPIP_STATEMENT(srcc_link_no  = SRCC_TCPIP_SNDCP_LINK);
    GPF_TCPIP_STATEMENT(dti_entity_id = DTI_ENTITY_TCPIP);
  }
  else {
    srcc_link_no   = SRCC_IP_SNDCP_LINK;
    dti_entity_id = DTI_ENTITY_IP;
  }
     
  if( TRUE NEQ srcc_reserve_sources( srcc_link_no, 1 )            AND
      DTI_LINK_ID_NOTPRESENT NEQ pdp_context[cid - 1].link_id_new AND
      cid  EQ work_cids[cid_pointer]                              OR
      pdp_context[cid - 1].entity_id EQ dti_entity_id)
  {
      psaTCPIP_Deactivate(cmhSM_IP_activate_cb);

      if(CS_UNDEFINED EQ ctx_state OR
         CS_DEFINED   EQ ctx_state   )
      {
        if(is_gpf_tcpip_call()) {
          GPF_TCPIP_STATEMENT(wap_state = TCPIP_Deactivation);
        }
        else {
          wap_state = UDPA_Deactivation;
        }
        dti_cntrl_close_dpath_from_dti_id(
          EXTRACT_DTI_ID(cmhSM_get_link_id_SNDCP_peer(cid , SNDCP_PEER_NORMAL)));
      }

      if( CS_ATTACHING_AFTER_UNDEF EQ ctx_state OR
          CS_ATTACHING_AFTER_DEF   EQ ctx_state OR
          CS_WAITS_FOR_ACTIVATING  EQ ctx_state     )
      {
        srcc_delete_count(srcc_link_no);
        return cmhSM_deactivateAContext(CMD_SRC_NONE, cid);
      }
      
      return AT_EXCT;
  }
  else
#endif  /* CO_UDP_IP || FF_GPF_TCPIP */
  {
    if( CS_DEFINED NEQ ctx_state AND CS_UNDEFINED NEQ ctx_state )
    {
      if( CS_ATTACHING_AFTER_UNDEF EQ ctx_state OR
          CS_ATTACHING_AFTER_DEF   EQ ctx_state OR
          CS_WAITS_FOR_ACTIVATING  EQ ctx_state     )
      {
        return cmhSM_deactivateAContext(CMD_SRC_NONE, cid);
      }
      else
      {
        dti_cntrl_close_dpath_from_dti_id(
        EXTRACT_DTI_ID(cmhSM_get_link_id_SNDCP_peer(cid , SNDCP_PEER_NORMAL)));
        return AT_EXCT;
      }
    }
  }
  return AT_CMPL;
}

/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                         |
| STATE   : finnished        ROUTINE : cmhSM_deactivateAContext        |
+----------------------------------------------------------------------+

  PURPOSE : deactivate some contexts (able for serial multiplexer mode).
*/
GLOBAL T_ACI_RETURN cmhSM_deactivateContexts( T_ACI_CMD_SRC srcId, SHORT *cids)
{
  T_ACI_RETURN ret_value = AT_CMPL;
  T_CONTEXT_STATE state;       
  USHORT nsapi_set = 0, 
         cid_set   = 0;
  SHORT i,
        all_cids[MAX_CID + 1] = {1, 2, INVALID_CID};

  TRACE_FUNCTION("cmhSM_deactivateContexts");

  if( T_CDS_RUNNING EQ working_cgact_actions.state) {
    TRACE_EVENT("cgact_ation is running: bussy returned");
    return AT_FAIL; /* AT_BUSY */
  }

  if(INVALID_CID EQ *cids)
  {
    cids = all_cids;
  }

  for(i = 0; cids[i] NEQ INVALID_CID; i++)
  {
    state = pdp_context[cids[i] - 1].state;
#if defined (CO_UDP_IP) || defined (FF_GPF_TCPIP)
#ifndef _SIMULATION_ 
    pdp_context[cids[i] - 1].owner = srcId;
#endif
#else
    pdp_context[cids[i] - 1].owner = srcId;
#endif
    if(AT_EXCT EQ deactivateAContextForCGACT( cids[i] ))
    {
      ret_value = AT_EXCT;
      if(0 NEQ pdp_context[cids[i] - 1].nsapi)
      {
        nsapi_set |= (1 << pdp_context[cids[i] - 1].nsapi);
        
        if(state EQ CS_DATA_LINK OR
           state EQ CS_ACTIVATED OR
           state EQ CS_CONTEXT_REACTIVATION_1)
        {
          cid_set   = 1 << (cids[i] - 1);
        }
      }
      else
      {
        cid_set   = 1 << (cids[i] - 1);
      }
    }
  }

  if(cid_set OR nsapi_set) {
    working_cgact_actions.state     = T_CDS_RUNNING;
    working_cgact_actions.nsapi_set = nsapi_set;
    working_cgact_actions.cid_set   = cid_set;
    working_cgact_actions.srcId     = srcId;
  }

  cmhSM_stop_context_reactivation();

  return ret_value;
}


/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                         |
| STATE   : finnished        ROUTINE : cmhSM_getCurQOS                 |
+----------------------------------------------------------------------+

  PURPOSE : This function returns the current QOS settings.
*/
#ifdef FF_SAT_E
GLOBAL T_QOS* cmhSM_getCurQOS( SHORT cid )
{

  return &pdp_context[cid - 1].qos;

}
#endif /* FF_SAT_E */

/*
+----------------------------------------------------------------------+
| PROJECT : GPRS (8441)      MODULE  : CMH_SMF                         |
| STATE   : finnished        ROUTINE : cmhSM_deactivateAContext        |
+----------------------------------------------------------------------+

  PURPOSE : deactivate all contexts (able for serial multiplexer mode).
*/
GLOBAL T_ACI_RETURN cmhSM_deactivateAContext( T_ACI_CMD_SRC srcId, SHORT cid )
{
  TRACE_FUNCTION("cmhSM_deactivateAContext()") ;

  switch( get_state_over_cid( cid ) )
  {
    case CS_UNDEFINED:
    case CS_DEFINED:
      /* 
       *    context ís deactivated -> not action necessary
       */
      break;
    case CS_ATTACHING_AFTER_UNDEF:
      /* 
       *    CGDATA has started the attach procedure 
       *    before establish data link
       *    CGDATA has to be stoped
       */
      set_state_over_cid( cid, CS_UNDEFINED );
      psaGMM_Detach( GMMREG_DT_GPRS );
      gpppEntStat.curCmd = AT_CMD_NONE;
      cid_pointer  = 0;
      *work_cids = 0;
      if(CMD_SRC_NONE EQ srcId)
      {
        pdp_context[cid - 1].owner = gpppEntStat.entOwn;
        gaci_RAT_caller ( RAT_NO_CARRIER, cid, AT_CMD_CGDATA, 0 );
      }
      return AT_CMPL;

    case CS_ATTACHING_AFTER_DEF:
      /* 
       *    CGDATA has started the attach procedure 
       *    before establish data link
       *    CGDATA has to be stoped
       */
      set_state_over_cid( cid, CS_DEFINED );
      psaGMM_Detach( GMMREG_DT_GPRS );
      gpppEntStat.curCmd = AT_CMD_NONE;
      cid_pointer  = 0;
      *work_cids = 0;
      if(CMD_SRC_NONE EQ srcId)
      {
        pdp_context[cid - 1].owner = gpppEntStat.entOwn;
        gaci_RAT_caller ( RAT_NO_CARRIER, cid, AT_CMD_CGDATA, 0 );
      }
return AT_CMPL;
    
    case CS_ESTABLISH_1:
      /*
       *   context not activated, but PPP has to be terminated
       */
      set_state_over_cid( cid, CS_ABORT_ESTABLISH );
      dti_cntrl_entity_disconnected( pdp_context[cid - 1].link_id_new, DTI_ENTITY_SNDCP );
      if (uartShrdPrm.escape_seq EQ UART_DETECT_ESC)
      {
        psaGPPP_Terminate( PPP_LOWER_LAYER_DOWN );
      }
      else
      {
        psaGPPP_Terminate( PPP_LOWER_LAYER_UP );
      }
      uartShrdPrm.escape_seq = UART_DETECT_DTR;

      return AT_EXCT;
    
    case CS_DATA_LINK:
      /*lint -fallthrough*/
    case CS_ESTABLISH_2:
    case CS_ESTABLISH_3:
      /* 
       *    context has to be deactivated and PPP has to be terminated
       */
      set_state_over_cid( cid, CS_CONTEXT_REACTIVATION_1 );
      psaSM_PDP_Deactivate( (USHORT) (1 << pdp_context[cid - 1].nsapi), SMREG_NONLOCAL);
      psaGPPP_Terminate( PPP_LOWER_LAYER_UP );
      return AT_EXCT;

    case CS_ACTIVATED:
      /*
       *  special handling for context switching
       */
      if(DTI_LINK_ID_NOTPRESENT NEQ pdp_context[cid - 1].link_id_sn  AND
         DTI_LINK_ID_NOTPRESENT NEQ pdp_context[cid - 1].link_id_new     )
      {
        return AT_CMPL;
      }
      /*lint -fallthrough*/
    case CS_ACTIVATING:
      /*
       *    +CGACT aborted
       */
      set_state_over_cid( cid, CS_DEACTIVATE_NORMAL );
      psaSM_PDP_Deactivate( (USHORT) (1 << pdp_context[cid - 1].nsapi), SMREG_NONLOCAL);
      return AT_EXCT;
    case CS_WAITS_FOR_ACTIVATING:
      /*
       *    reset command state it is enough
       */
      set_state_working_cid( CS_DEFINED );
      gpppEntStat.curCmd = AT_CMD_NONE;
      smEntStat.curCmd   = AT_CMD_NONE;
      *work_cids = 0;
      cid_pointer = 0;
      return AT_CMPL;

    case CS_ABORT_ESTABLISH:
    case CS_DEACTIVATE_NORMAL:
    case CS_BREAKDOWN_LINK_ERROR:
    case CS_BREAKDOWN_LINK_NORMAL:
      /*
       *    context is during deactivation procedure -> not action necessary
       */
      return AT_EXCT;
    case CS_CONTEXT_REACTIVATION_1:
    case CS_CONTEXT_REACTIVATION_2:
      /* 
       *  context is during deactivation procedure 
       *  -> not action for context deactivation or PPP termination necessary
       */
      return AT_EXCT;
  }

  return AT_FAIL;
}

GLOBAL BOOL cmhSM_isContextActive( void )
{
  int i = SMH_FIRST_FREE_NSAPIS;

  while ( i <= SMH_LAST_FREE_NSAPIS AND ( nsapi_to_cid[i] EQ INVALID_CID))
    i++;

  if  ( i >  SMH_LAST_FREE_NSAPIS)
    return FALSE;

  return TRUE;
}

#endif  /* GPRS */
/*==== EOF ========================================================*/