fc-selenite: src/g23m-aci/aci/cmh

comparison src/g23m-aci/aci/cmh_ccs.c @ 1:d393cd9bb723

src/g23m-*: initial import from Magnetite

author	Mychaela Falconia <falcon@freecalypso.org>
date	Sun, 15 Jul 2018 04:40:46 +0000
parents
children

comparison

equal deleted inserted replaced

-:b6a5e36de839
+:d393cd9bb723
+/*
++-----------------------------------------------------------------------------
+|  Project :  GSM-PS (6147)
+|  Modul   :  CMH_CCS
++-----------------------------------------------------------------------------
+|  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 provides the set functions related to the
+|             protocol stack adapter for call control.
++-----------------------------------------------------------------------------
+*/
+#ifndef CMH_CCS_C
+#define CMH_CCS_C
+#endif
+#include "aci_all.h"
+#include "aci_cmh.h"
+#include "ksd.h"
+/*==== INCLUDES ===================================================*/
+/* for CCD */
+#include "ccdapi.h"
+#include "aci.h" /*  for CCD_END... */
+/***********/
+#include "ati_cmd.h"
+#include "aci_cmd.h"
+#ifdef DTI
+#include "dti.h"      /* functionality of the dti library */
+#include "dti_conn_mng.h"
+#include "dti_cntrl_mng.h"
+#endif
+#ifdef FAX_AND_DATA
+#include "aci_fd.h"
+#endif    /* of #ifdef FAX_AND_DATA */
+#ifdef FF_TTY
+#include "audio.h"
+#endif
+#include "aci_mem.h"
+#include "l4_tim.h"
+#include "phb.h"
+#include "psa.h"
+#include "psa_cc.h"
+#include "psa_sim.h"
+#include "psa_mm.h"
+#include "psa_ss.h"
+#include "psa_util.h"
+#include "cmh.h"
+#include "cmh_cc.h"
+#include "cmh_mm.h"
+#include "cmh_sim.h"
+#include "cmh_phb.h"
+#ifdef FF_ATI
+#include "aci_io.h"
+#endif /* of #ifdef FF_ATI */
+#ifdef FAX_AND_DATA
+#include "psa_ra.h"
+#include "cmh_ra.h"
+#include "psa_l2r.h"
+#include "cmh_l2r.h"
+#include "psa_tra.h"
+#ifdef FF_FAX
+#include "psa_t30.h"
+#include "cmh_t30.h"
+#endif /* FF_FAX */
+#endif /* FAX_AND_DATA */
+#ifdef SIM_TOOLKIT
+#include "psa_sat.h"
+#include "cmh_sat.h"
+#endif
+#ifdef DTI
+#if defined (FF_WAP) || defined (FF_GPF_TCPIP) || defined (FF_SAT_E)
+#include "wap_aci.h"
+#include "psa_ppp_w.h"
+#include "cmh_ppp.h"
+#endif  /* FF_WAP || FF_GPF_TCPIP || FF_SAT_E */
+#endif /* DTI */
+#ifdef GPRS
+#include "gaci.h"
+#include "gaci_cmh.h"
+#include "psa_sm.h"
+#include "cmh_sm.h"
+#endif  /* GPRS */
+#include "aoc.h"
+#include "ksd.h"
+#ifdef ACI
+#include "cmh_mmi.h"
+#endif
+#ifdef FF_PSI
+#include "psa_psi.h"
+#include "cmh_psi.h"
+#include "cmh_uart.h"
+#include "ati_src_psi.h"
+#endif /* FF_PSI */
+/*==== CONSTANTS ==================================================*/
+#ifdef TI_PS_FF_AT_CMD_P_ECC
+//LOCAL char additional_ecc_numbers[ADDITIONAL_ECC_NUMBER_MAX][ADDITIONAL_ECC_NUMBER_LENGTH];
+LOCAL char additional_ecc_numbers[ADDITIONAL_ECC_NUMBER_MAX][ADDITIONAL_ECC_NUMBER_LENGTH+1]; //OMAPS00117704/OMAPS00117705
+#endif /* TI_PS_FF_AT_CMD_P_ECC */
+#ifdef TI_PS_FF_AT_P_CMD_RDLB
+GLOBAL T_ACI_CC_REDIAL_BLACKL * cc_blacklist_ptr = NULL;
+#endif /* TI_PS_FF_AT_P_CMD_RDLB */
+/*==== EXPORT =====================================================*/
+#if defined (GPRS) AND defined (DTI)
+EXTERN T_ATI_RSLT atGD (char *cl, UBYTE srcId, BOOL *gprs_command);
+#endif  /* GPRS */
+/*==== VARIABLES ==================================================*/
+/* Implements Measure#32: Row 89, 90, 116, 117, 1241 & 1242 */
+const char * const ksd_supp_clir_str = "*31#";
+const char * const ksd_inv_clir_str = "#31#";
+EXTERN T_PCEER causeMod;
+EXTERN SHORT causeCeer;
+/* parameter block for delayed cmhCC_Dial call */
+LOCAL struct cmhCC_Dial_buffer {
+T_ACI_CMD_SRC srcId;
+} cmhCC_Dial_buffer;
+#ifdef TI_PS_FF_AT_P_CMD_CUSCFG
+EXTERN T_ACI_CUSCFG_PARAMS cuscfgParams;
+#endif /* TI_PS_FF_AT_P_CMD_CUSCFG */
+/*==== PROTOTYPES =================================================*/
+LOCAL UCHAR cmhCC_Dial_delayed (void *arg);
+LOCAL T_ACI_RETURN chld_RelHldOrUdub(T_ACI_CMD_SRC srcId);
+LOCAL T_ACI_RETURN chld_RelActAndAcpt(T_ACI_CMD_SRC srcId);
+LOCAL T_ACI_RETURN chld_RelActSpec(T_ACI_CMD_SRC srcId, CHAR *call);
+LOCAL T_ACI_RETURN chld_HldActAndAcpt(T_ACI_CMD_SRC srcId);
+LOCAL T_ACI_RETURN chld_HldActExc(T_ACI_CMD_SRC srcId, CHAR *call);
+LOCAL T_ACI_RETURN chld_AddHld(T_ACI_CMD_SRC srcId);
+LOCAL T_ACI_RETURN chld_Ect(T_ACI_CMD_SRC srcId);
+LOCAL T_ACI_RETURN chld_Ccbs(T_ACI_CMD_SRC srcId);
+LOCAL T_ACI_RETURN chld_OnlyHold(T_ACI_CMD_SRC srcId);
+LOCAL T_ACI_RETURN chld_RelDialCall(T_ACI_CMD_SRC srcId);
+LOCAL T_ACI_RETURN chld_RetrieveHoldCall(T_ACI_CMD_SRC srcId);
+LOCAL T_ACI_RETURN chld_RetrieveHoldCallSpec(T_ACI_CMD_SRC srcId, CHAR *call);
+LOCAL T_ACI_RETURN chld_RelAnySpec(T_ACI_CMD_SRC srcId, CHAR *call);
+LOCAL BOOL cmhCC_check_RedialCall         ( T_ACI_AT_CMD at_cmd_id );
+LOCAL BOOL cmhCC_check_pending_satCall();
+LOCAL BOOL chld_HoldActiveCalls           ( T_ACI_CMD_SRC srcId,
+BOOL *mptyHldFlg,
+BOOL *hldCalFlg,
+SHORT *cId );
+LOCAL T_ACI_RETURN chld_Rel_MultipartySpec( T_ACI_CMD_SRC srcId,
+SHORT *spcId,
+T_ACI_CHLD_MOD chld_mode,
+CHAR *call );
+LOCAL void cmhCC_disconnect_waiting_call  ( T_ACI_CMD_SRC srcId,
+SHORT waitId,
+T_ACI_AT_CMD at_cmd_id,
+USHORT *mltyDscFlg );
+/*==== FUNCTIONS ==================================================*/
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_Dm                   |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the D> AT command
+which is responsible to originate a call using the phone-
+book. The searched number can be declared either by the
+name or by giving the index of a specified phonebook. If
+an entry could be found, the ordinary AT D command is
+called.
+<str>     : name string to search.
+<mem>     : type of phonebook.
+<index>   : phonebook index.
+<clirOvrd>: CLIR override
+<cugCtrl> : CUG control
+<callType>: call type
+*/
+#define RETURN(x) { retVal = x; goto cleanup_exit; }
+/*lint -e{801} Use of goto*/
+#ifdef NO_ASCIIZ
+GLOBAL T_ACI_RETURN sAT_Dm        ( T_ACI_CMD_SRC     srcId,
+T_ACI_PB_TEXT     *str,
+T_ACI_PB_STOR     mem,
+SHORT             index,
+T_ACI_D_CLIR_OVRD clirOvrd,
+T_ACI_D_CUG_CTRL  cugCtrl,
+T_ACI_D_TOC       callType )
+#else  /* ifdef NO_ASCIIZ */
+GLOBAL T_ACI_RETURN sAT_Dm        ( T_ACI_CMD_SRC     srcId,
+CHAR              *str,
+T_ACI_PB_STOR     mem,
+SHORT             index,
+T_ACI_D_CLIR_OVRD clirOvrd,
+T_ACI_D_CUG_CTRL  cugCtrl,
+T_ACI_D_TOC       callType )
+#endif /* ifdef NO_ASCIIZ */
+{
+T_CLPTY_PRM *cldPty;        /* holds calling party parameter */
+T_ACI_RETURN retVal;        /* holds function return value */
+T_PHB_RECORD phbNtry;       /* holds phonebook entry */
+T_PHB_TYPE slctPHB;         /* holds selected phonebook */
+T_ACI_PB_TEXT *dial_name;
+#ifndef NO_ASCIIZ
+T_ACI_PB_TEXT dialname;
+#endif /* #ifndef NO_ASCIIZ */
+ACI_MALLOC (cldPty, sizeof (T_CLPTY_PRM));
+TRACE_FUNCTION ("sAT_Dm()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+RETURN( AT_FAIL )
+}
+/* init cldPty */
+cmhCC_init_cldPty( cldPty );
+#ifdef NO_ASCIIZ
+dial_name = str;
+#else  /* #ifdef NO_ASCIIZ */
+dial_name = &dialname;
+if ( str NEQ NULL )
+{
+USHORT len = (USHORT)strlen( str );
+cmh_cvtToDefGsm ( str, (CHAR*)dial_name->data, &len );
+dial_name->cs = CS_Sim;
+dial_name->len = (UBYTE)len;
+}
+else
+{
+dial_name->cs = CS_NotPresent;
+dial_name->len = 0;
+}
+#endif /* #ifdef NO_ASCIIZ */
+/*
+*-------------------------------------------------------------------
+* check for name search
+*-------------------------------------------------------------------
+*/
+if( dial_name->len NEQ 0 )
+{
+if( psaCC_phbSrchName( srcId, dial_name, cldPty ) )
+RETURN( cmhCC_Dial( srcId, cldPty, clirOvrd, cugCtrl, callType ))
+else
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_NotFound );
+RETURN( AT_FAIL )
+}
+}
+/*
+*-------------------------------------------------------------------
+* check for index read
+*-------------------------------------------------------------------
+*/
+#ifdef NO_ASCIIZ
+if( ( !str OR !str->len ) AND index NEQ ACI_NumParmNotPresent )
+#else  /* #ifdef NO_ASCIIZ */
+if( !str AND index NEQ ACI_NumParmNotPresent )
+#endif /* #ifdef NO_ASCIIZ */
+{
+if( !cmhPHB_cvtPhbType ((( mem EQ PB_STOR_NotPresent )?
+cmhPrm[srcId].phbCmdPrm.cmhStor : mem), &slctPHB ))
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+RETURN( AT_FAIL )
+}
+#ifdef TI_PS_FFS_PHB
+if (pb_read_record (slctPHB, index, &phbNtry) EQ PHB_OK)
+#else
+if( pb_read_phys_record( slctPHB, index, &phbNtry ) EQ PHB_OK )
+#endif
+{
+cmhPHB_getAdrStr( cldPty->num, sizeof (cldPty->num) - 1,
+phbNtry.number, phbNtry.len );
+cmh_demergeTOA ( phbNtry.ton_npi, &cldPty->ton, &cldPty->npi );
+RETURN( cmhCC_Dial( srcId, cldPty, clirOvrd, cugCtrl, callType ))
+}
+else
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_InvIdx );
+RETURN( AT_FAIL )
+}
+}
+RETURN( AT_FAIL )
+/* The one and only exit out of this function to avoid memory leaks */
+cleanup_exit:
+ACI_MFREE (cldPty);
+return retVal;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_Dn                   |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the D AT command
+which is responsible to originate a call to a given phone
+number. The D command starts to establish a new call if no
+call is currently active. Otherwise if a call is in active
+state the D command starts to modify the active call. If the
+call mode set by the +CMOD command indicates a single call
+no modification takes place and the D command returns with
+a fail.
+<number>  : phone number.
+<clirOvrd>: CLIR override
+<cugCtrl> : CUG control
+<callType>: call type
+*/
+GLOBAL T_ACI_RETURN sAT_Dn       ( T_ACI_CMD_SRC srcId,
+CHAR * number,
+T_ACI_D_CLIR_OVRD clirOvrd,
+T_ACI_D_CUG_CTRL  cugCtrl,
+T_ACI_D_TOC       callType )
+{
+/* Implements Measure#32: Row 88  */
+CHAR trace_number_buffer[59];
+T_CLPTY_PRM *cldPty = NULL; /* holds calling party parameter */
+T_ACI_RETURN retVal;        /* holds function return value */
+#if defined (GPRS) AND defined (DTI)
+BOOL              gprs_command;
+T_ATI_RSLT        r_value;
+#endif  /* GPRS */
+TRACE_FUNCTION ("sAT_Dn()");
+if (number NEQ NULL)
+{
+/* char trcBuf[80]; */
+/* Implements Measure#32: Row 88  */
+strncpy (&trace_number_buffer[0], number, 58);
+trace_number_buffer[58] = '\0';
+if (trace_number_buffer[55])
+{
+trace_number_buffer[55] = trace_number_buffer[56] = trace_number_buffer[57] = '.';  /* add trailing "..." if string is >=76 */
+}
+TRACE_EVENT_P1 ("sAT_Dn(): dialled nb=%s",trace_number_buffer);
+}
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+#if defined (GPRS) AND defined (DTI)
+r_value = atGD( number, (UBYTE) srcId, &gprs_command );
+if ( gprs_command EQ TRUE)
+{
+/* SPR#1983 - SH */
+switch (r_value)
+{
+case ATI_CMPL:
+return AT_CMPL;
+case ATI_EXCT:
+return AT_EXCT;
+default:
+return AT_FAIL;
+}
+/* end SPR#1983 */
+}
+#endif  /* GPRS */
+ACI_MALLOC (cldPty, sizeof (T_CLPTY_PRM));
+/* initialize called party parameter */
+if(number NEQ NULL)
+{
+cmhCC_init_cldPty( cldPty );
+cmh_bldCalPrms ( number, cldPty );
+}
+/*
+*-------------------------------------------------------------------
+* start dialling
+*-------------------------------------------------------------------
+*/
+retVal = cmhCC_Dial( srcId,
+(number NEQ NULL) ? cldPty : NULL,
+clirOvrd,
+cugCtrl,
+callType );
+ACI_MFREE (cldPty);
+return retVal;
+}
+/* initialize cldPty structure */
+GLOBAL void cmhCC_init_cldPty( /*lint -e(578) */T_CLPTY_PRM *cldPty )
+{
+cldPty->num[0] = 0;
+cldPty->ton = MNCC_TON_NOT_PRES;
+cldPty->npi = MNCC_NPI_NOT_PRES;
+cldPty->sub[0] = 0;
+cldPty->tos = MNCC_TOS_NOT_PRES;
+cldPty->oe  = MNCC_OE_EVEN;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : cmhCC_CHLD_Serv          |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the %CHLD AT command
+which is responsible to handle the supplementary services
+witin a call. This function is resonsible for the +CHLD
+and %CHLD command both.
+*/
+LOCAL T_ACI_RETURN cmhCC_CHLD_Serv(T_ACI_CMD_SRC    srcId,
+T_ACI_CHLD_MOD   mode,
+CHAR            *call)
+{
+/* check command source */
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+switch( mode )
+{
+/* release all held calls, or UDUB for CWA */
+case( CHLD_MOD_RelHldOrUdub ):
+return(chld_RelHldOrUdub(srcId));
+/* release all active calls, and accept held or waiting call */
+case( CHLD_MOD_RelActAndAcpt ):
+return(chld_RelActAndAcpt(srcId));
+/* release a specific active call */
+case( CHLD_MOD_RelActSpec ):
+return(chld_RelActSpec(srcId, call));
+/* place all active calls on hold, and accept held or waiting call */
+case( CHLD_MOD_HldActAndAcpt ):
+return(chld_HldActAndAcpt(srcId));
+/* place all active calls on hold except the specified call */
+case( CHLD_MOD_HldActExc ):
+return(chld_HldActExc(srcId, call));
+/* add a held call to the conversation */
+case( CHLD_MOD_AddHld ):
+return(chld_AddHld(srcId));
+/* explicit call transfer */
+case( CHLD_MOD_Ect ):
+return(chld_Ect(srcId));
+/* activate call completion to busy subscriber */
+case( CHLD_MOD_Ccbs ):
+return(chld_Ccbs(srcId));
+/* place a call on hold */
+case(CHLD_MOD_OnlyHold):
+return(chld_OnlyHold(srcId));
+/* release currently dialling call only */
+case(CHLD_MOD_RelDialCall):
+return(chld_RelDialCall(srcId));
+/* retrive first held call on the list */
+case(CHLD_MOD_RetrieveHoldCall):
+return(chld_RetrieveHoldCall(srcId));
+/* retrieve specific held call */
+case(CHLD_MOD_RetrieveHoldCallSpec):
+return(chld_RetrieveHoldCallSpec(srcId, call));
+/* releases specific call */
+case(CHLD_MOD_RelAnySpec):
+return(chld_RelAnySpec(srcId, call));
+}
+/* for unexpected conditions */
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+return( AT_FAIL );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : cmhCC_Dial               |
++--------------------------------------------------------------------+
+PURPOSE : Start dialling.
+*/
+/* helper function for delivering delayed rAT_PlusCPMS callback */
+LOCAL UCHAR cmhCC_Dial_delayed (void* arg)
+{
+struct cmhCC_Dial_buffer* p = (struct cmhCC_Dial_buffer*) arg;
+TRACE_EVENT("delayed delivery of RAT_NO_CARRIER after cmhCC_Dial");
+R_AT( RAT_NO_CARRIER, p->srcId ) ( AT_CMD_D, 0 );
+return FALSE; /* single-shot */
+}
+GLOBAL T_ACI_RETURN cmhCC_Dial   ( T_ACI_CMD_SRC     srcId,
+/*lint -e(578) */ T_CLPTY_PRM      *cldPty,
+T_ACI_D_CLIR_OVRD clirOvrd,
+T_ACI_D_CUG_CTRL  cugCtrl,
+T_ACI_D_TOC       callType )
+{
+SHORT cId, newId;           /* holds call id */
+T_CC_CMD_PRM * pCCCmdPrm;   /* points to CC command parameters */
+T_ACI_RETURN   retVal;      /* holds return value */
+UBYTE          prio;        /* holds priority of the call */
+USHORT         dummy=0;
+UBYTE idx;
+#if defined SMI OR defined MFW  OR defined FF_MMI_RIV
+T_ACI_CLOG     cmdLog;      /* holds logging info */
+#endif
+TRACE_FUNCTION ("cmhCC_Dial()");
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+causeMod  = P_CEER_mod;      /* Clear module which was set for ceer */
+causeCeer = CEER_NotPresent; /* Clear proprietary cause when at point of dialling. */
+/*
+*-------------------------------------------------------------------
+* check for an active call
+*-------------------------------------------------------------------
+*/
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_ACT, NO_VLD_CT );
+#ifdef FAX_AND_DATA
+if( cId NEQ NO_ENTRY )
+{
+/*
+*-----------------------------------------------------------------
+* check call mode to modify the call
+*-----------------------------------------------------------------
+*/
+if( cmhCC_ChckInCallMdfy( cId, AT_CMD_D ) )
+{
+cmhCC_flagCall( cId, &(pCCCmdPrm->mltyCncFlg));
+psaCC_ctb(cId)->curCmd = AT_CMD_D;
+psaCC_ctb(cId)->curSrc = srcId;
+psaCC_ModifyCall(cId);
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+/* log command */
+cmdLog.atCmd                = AT_CMD_D;
+cmdLog.cmdType              = CLOG_TYPE_Set;
+cmdLog.retCode              = AT_EXCT;
+cmdLog.cId                  = cId+1;
+cmdLog.sId                  = ACI_NumParmNotPresent;
+cmdLog.cmdPrm.sD.srcId      = srcId;
+cmdLog.cmdPrm.sD.number     = NULL;
+cmdLog.cmdPrm.sD.clirOvrd   = clirOvrd;
+cmdLog.cmdPrm.sD.cugCtrl    = cugCtrl;
+cmdLog.cmdPrm.sD.callType   = callType;
+#ifdef SIM_TOOLKIT
+cmdLog.cmdPrm.sD.simCallCtrl= D_SIMCC_NOT_ACTIVE;
+#endif /* SIM_TOOLKIT */
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( AT_EXCT );
+}
+}
+#endif  /* of #ifdef FAX AND_DATA */
+if( cldPty EQ NULL )
+{
+TRACE_EVENT("ERROR: cldPty is NULL");
+if (callType EQ D_TOC_Voice)
+return(AT_CMPL);
+else
+{
+if (!cmh_set_delayed_call (cmhCC_Dial_delayed, &cmhCC_Dial_buffer))
+return AT_BUSY;
+cmhCC_Dial_buffer.srcId = srcId;
+TRACE_EVENT("delayed return requested: 100 ms");
+cmh_start_delayed_call (100);
+return(AT_EXCT);
+}
+}
+/*
+*-------------------------------------------------------------------
+* determine call priority
+*-------------------------------------------------------------------
+*/
+if (cmhMM_ChkIgnoreECC(cldPty->num))
+{
+prio = MNCC_PRIO_NORM_CALL;
+TRACE_EVENT("cmhCC_Dial(): ECC check is ignored");
+}
+else
+{
+TRACE_EVENT("cmhCC_Dial(): ECC check is coninued");
+prio = psaCC_phbSrchECC ( cldPty->num, TRUE );
+}
+/*
+*-------------------------------------------------------------------
+* check fixed dialing phonebook if enabled
+*-------------------------------------------------------------------
+*/
+if( prio EQ MNCC_PRIO_NORM_CALL  AND
+(simShrdPrm.crdFun EQ SIM_FDN_ENABLED OR
+simShrdPrm.crdFun EQ SIM_FDN_BDN_ENABLED) )
+{
+if( ksd_isFDNCheckSeq ( cldPty->num ) )
+{
+if(!psaCC_phbNtryFnd( FDN, cldPty ))
+{
+TRACE_EVENT ( "FDN check failed" );
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_FdnCheck );
+return( AT_FAIL );
+}
+}
+}
+/*
+*-------------------------------------------------------------------
+* Add Number or Sequence to LDN phonebook
+* This has to be done prior keystrokes to allow adding some special
+* sequences for dialing purpose with prepaid SIMs when roaming (USSD callback)
+*-------------------------------------------------------------------
+*/
+if (prio NEQ MNCC_PRIO_EMERG_CALL) /* only normal calls are added to the LDN PB */
+{
+if(ksd_isLDNWriteCheckSeq(cldPty->num)) /* check whether the string needs to be written to LDN?*/
+{
+/* A call table entry does not exist here yet */
+psaCC_phbAddNtry( LDN, NO_ENTRY, CT_MOC, cldPty );  /* add call to LDN PB */
+}
+}
+/*
+*-------------------------------------------------------------------
+* check for a keystroke sequence
+*-------------------------------------------------------------------
+*/
+if(prio NEQ MNCC_PRIO_EMERG_CALL)
+{
+retVal = cmhCC_chkKeySeq ( srcId,
+cldPty,
+&callType,
+&clirOvrd,
+CC_SIM_YES );
+if( retVal NEQ AT_CONT )
+return( retVal );
+}
+else if (strlen(cldPty->num) > 4)
+{
+/* decode clirOvrd in case of ECC
+since cmhCC_chkKeySeq is not aware of ECC */
+/* Implements Measure#32: Row 89 & 90 */
+if ( !strncmp(cldPty->num,(char*)ksd_supp_clir_str,4) OR /* KSD_SUPPRESS_CLIR */
+!strncmp(cldPty->num,(char*)ksd_inv_clir_str,4) )   /* KSD_INVOKE_CLIR */
+{
+CHAR *p1, *p2;
+if (*cldPty->num EQ '*')
+clirOvrd = D_CLIR_OVRD_Supp;
+else
+clirOvrd = D_CLIR_OVRD_Invoc;
+/* and remove clirOvrd from dial num */
+for (p1=cldPty->num, p2=cldPty->num+4; /*lint -e720 */ *p1++ = *p2++; )
+;
+}
+}
+/*
+*-------------------------------------------------------------------
+* check for a short string sequence: should also be USSD (see 02.30 chptr 4.5.3.2)
+*-------------------------------------------------------------------
+*/
+if( ( prio EQ MNCC_PRIO_NORM_CALL ) AND ( !ksd_isBCDForUSBand(cldPty->num) ) )
+{
+retVal = cmhCC_chkShortString (srcId, cId, cldPty);
+if (retVal NEQ AT_EXCT)
+{
+return (retVal);
+}
+}
+/*
+*-------------------------------------------------------------------
+* check redialing
+*-------------------------------------------------------------------
+*/
+/* Implements Measure 64 */
+cmhCC_CheckRedialTimer( FALSE );
+/*
+*-------------------------------------------------------------------
+* continue dialing
+*-------------------------------------------------------------------
+*/
+newId = psaCC_ctbNewEntry();
+if( newId EQ NO_ENTRY )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_CallTabFull );
+return( AT_FAIL );        /* call table full */
+}
+if( cId NEQ NO_ENTRY )
+{
+/*
+*-----------------------------------------------------------------
+* check if there is already a call on hold
+*-----------------------------------------------------------------
+*/
+if( psaCC_ctbFindCall( OWN_SRC_INV, CS_HLD, NO_VLD_CT ) NEQ NO_ENTRY )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_OneCallOnHold );
+psaCC_FreeCtbNtry (newId);
+return( AT_FAIL );
+}
+/*
+*-----------------------------------------------------------------
+* check to put active call on hold, if it is no data call and not
+* an emergency call
+*-----------------------------------------------------------------
+*/
+if( psaCC_ctb(cId)->prio EQ MNCC_PRIO_NORM_CALL AND
+cmhCC_getcalltype(cId)  EQ VOICE_CALL )
+{
+if( pCCCmdPrm->mltyCncFlg NEQ 0 )
+{
+psaCC_FreeCtbNtry (newId);
+return( AT_BUSY );
+}
+}
+else
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_CallTypeNoHold );
+psaCC_FreeCtbNtry (newId);
+return( AT_FAIL );
+}
+}
+/*
+*-------------------------------------------------------------------
+* setup call parameters
+*-------------------------------------------------------------------
+*/
+cmhCC_chkDTMFDig ( cldPty->num, newId, dummy, TRUE );
+retVal = cmhCC_fillSetupPrm ( newId, srcId, cldPty, NULL, prio,
+clirOvrd, cugCtrl, callType );
+if( retVal NEQ AT_CMPL  )
+{
+psaCC_FreeCtbNtry (newId);
+return( retVal );
+}
+#ifdef TI_PS_FF_AT_P_CMD_RDLB
+/*
+*-------------------------------------------------------------------
+* check number against black list entries
+*-------------------------------------------------------------------
+*/
+if(rdlPrm.rdlMod EQ AUTOM_REPEAT_ON)
+{
+if(cmhCC_redialChkBlackl(newId) NEQ AT_CMPL)
+{
+psaCC_FreeCtbNtry (newId);
+return( AT_FAIL);
+}
+}
+#endif /* TI_PS_FF_AT_P_CMD_RDLB */
+/*
+*-----------------------------------------------------------------
+* declare call table entry as used and the owner of the call
+*-----------------------------------------------------------------
+*/
+psaCC_ctb(newId)->calType    = CT_MOC;
+psaCC_ctb(newId)->calOwn     = (T_OWN)srcId;
+psaCC_ctb(newId)->curCmd     = AT_CMD_D;
+psaCC_ctb(newId)->curSrc     = srcId;
+/*
+*-------------------------------------------------------------------
+* check for call control by SIM toolkit
+*-------------------------------------------------------------------
+*/
+#ifdef SIM_TOOLKIT
+if ( prio NEQ MNCC_PRIO_EMERG_CALL ) /* don't send emergency calls to */
+{                               /* SIM toolkit                   */
+if ( !ksd_isFDNCheckSeq ( cldPty-> num ) )
+;    /* bypass *#06# from CntrlBySIM */
+else
+{
+if( psaSIM_ChkSIMSrvSup( SRV_CalCntrl ) AND satShrdPrm.SIMCCParm.busy NEQ TRUE )
+{
+/*  get bearer capability parameter */
+ccShrdPrm.BC0_send_flag =  ccShrdPrm.ctb[newId]->BC[0].bearer_serv NEQ MNCC_BEARER_SERV_NOT_PRES   AND
+ccShrdPrm.ctb[newId]->BC[0].bearer_serv NEQ MNCC_BEARER_SERV_SPEECH      AND
+ccShrdPrm.ctb[newId]->BC[0].bearer_serv NEQ MNCC_BEARER_SERV_AUX_SPEECH;
+ccShrdPrm.BC1_send_flag =  ccShrdPrm.ctb[newId]->BC[1].bearer_serv NEQ MNCC_BEARER_SERV_NOT_PRES   AND
+ccShrdPrm.ctb[newId]->BC[1].bearer_serv NEQ MNCC_BEARER_SERV_SPEECH      AND
+ccShrdPrm.ctb[newId]->BC[1].bearer_serv NEQ MNCC_BEARER_SERV_AUX_SPEECH;
+if ( (callType EQ D_TOC_Data) AND ( ccShrdPrm.BC0_send_flag OR ccShrdPrm.BC1_send_flag) )
+{
+satShrdPrm.capParm.cId = newId;
+psaCC_BCapCode( BCRI_SAT, newId );
+return (AT_EXCT);
+}
+else
+{
+retVal = cmhSAT_CalCntrlBySIM( newId );
+}
+if( retVal NEQ AT_CMPL )
+{
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.atCmd                = AT_CMD_D;
+cmdLog.cmdType              = CLOG_TYPE_Set;
+cmdLog.retCode              = AT_EXCT;
+cmdLog.cId                  = newId+1;
+cmdLog.sId                  = ACI_NumParmNotPresent;
+cmdLog.cmdPrm.sD.srcId      = srcId;
+cmdLog.cmdPrm.sD.number     = cldPty->num;
+cmdLog.cmdPrm.sD.clirOvrd   = clirOvrd;
+cmdLog.cmdPrm.sD.cugCtrl    = cugCtrl;
+cmdLog.cmdPrm.sD.callType   = callType;
+cmdLog.cmdPrm.sD.simCallCtrl= D_SIMCC_ACTIVE_CHECK;
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( retVal );
+}
+}
+}
+}
+#endif
+if( cId NEQ NO_ENTRY )
+{
+/* put an active call on hold prior to set up the new call */
+CHLDaddInfo = CHLD_ADD_INFO_DIAL_CAL;
+pCCCmdPrm -> CHLDmode = CHLD_MOD_HldActDial;
+cmhCC_HoldCall(cId, srcId, AT_CMD_D);
+/* flag newId to start the call once active call has been held */
+cmhCC_flagCall( newId, &(pCCCmdPrm->mltyCncFlg));
+}
+else
+{
+/* start a new call */
+cmhCC_flagCall( newId, &(pCCCmdPrm->mltyCncFlg));
+psaCC_NewCall(newId);
+/* call progress information */
+for(idx = 0; idx < CMD_SRC_MAX; idx++ )
+{
+R_AT(RAT_CPI, (T_ACI_CMD_SRC)idx)( newId+1,
+CPI_MSG_MO_Setup,
+(psaCC_ctb(newId)->inBndTns)? CPI_IBT_True: CPI_IBT_False,
+(ccShrdPrm.TCHasg)? CPI_TCH_True: CPI_TCH_False,
+psaCC_ctb(newId)->curCs);
+}
+}
+/* log command */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.atCmd                = AT_CMD_D;
+cmdLog.cmdType              = CLOG_TYPE_Set;
+cmdLog.retCode              = AT_EXCT;
+cmdLog.cId                  = newId+1;
+cmdLog.sId                  = ACI_NumParmNotPresent;
+cmdLog.cmdPrm.sD.srcId      = srcId;
+cmdLog.cmdPrm.sD.number     = cldPty->num;
+cmdLog.cmdPrm.sD.clirOvrd   = clirOvrd;
+cmdLog.cmdPrm.sD.cugCtrl    = cugCtrl;
+cmdLog.cmdPrm.sD.callType   = callType;
+#ifdef SIM_TOOLKIT
+cmdLog.cmdPrm.sD.simCallCtrl= D_SIMCC_NOT_ACTIVE;
+#endif /* SIM_TOOLKIT */
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( AT_EXCT );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_H                    |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the H AT command
+which is responsible to terminate or modify a call.
+1. The function searches for an active call. If this
+call is modifiable, it will be modified and the function
+returns.
+2. Then the function searches for a call that is in the
+disconnect request state and indicates CCBS possibility,
+this call will be finally released.
+3. If enabled the next search looks for a pending SAT call.
+If such a call is found the call is rejected and the SIM card
+will be informed.
+4. The next step is to clear all calls of the call table
+exept a waiting call. The function returns if at least one
+call could be found.
+5. If no call was found, the function searches for a waiting
+call. If a waiting call was found, the call will be
+terminated declaring the user as busy.
+6. If none of the above situations match, the function
+returns with a fail.
+*/
+GLOBAL T_ACI_RETURN sAT_H ( T_ACI_CMD_SRC srcId )
+{
+SHORT cId;                  /* holds call id */
+SHORT waitId = NO_ENTRY;    /* holds call waiting id */
+T_CC_CMD_PRM * pCCCmdPrm;   /* points to CC command parameters */
+#if defined (GPRS) AND defined (DTI)
+T_ACI_RETURN  ret_value;
+#endif  /* GPRS */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+T_ACI_CLOG     cmdLog;      /* holds logging info */
+#endif
+TRACE_FUNCTION ("sAT_H()");
+/* check command source */
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+#if defined (GPRS) AND defined (DTI)
+/*  handle command for GPRS */
+if ( TRUE EQ cmhSM_sAT_H( srcId, &ret_value ) )
+return ret_value;
+#endif  /* GPRS */
+/*  prepare log command */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.atCmd                = AT_CMD_H;
+cmdLog.cmdType              = CLOG_TYPE_Set;
+cmdLog.retCode              = AT_EXCT;
+cmdLog.sId                  = ACI_NumParmNotPresent;
+cmdLog.cmdPrm.sH.srcId      = srcId;
+#endif
+#ifdef ACI /* for ATI only version */
+cmhMMI_handleAudioTone ( AT_CMD_H, RAT_OK, CPI_MSG_NotPresent );
+#endif
+/*
+*-------------------------------------------------------------------
+* find an active call and check call mode in case of
+* in-call modification
+*-------------------------------------------------------------------
+*/
+#if defined (FAX_AND_DATA) AND defined (DTI)
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_ACT, NO_VLD_CT );
+if( cId NEQ NO_ENTRY AND
+cmhCC_ChckInCallMdfy( cId, AT_CMD_H ) )
+{
+switch( cmhCC_getcalltype(cId) )
+{
+case( TRANS_CALL ):
+ccShrdPrm.datStat = DS_MDF_REQ;
+cmhTRA_Deactivate();
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( AT_EXCT );
+case( NON_TRANS_CALL ):
+ccShrdPrm.datStat = DS_MDF_REQ;
+cmhL2R_Deactivate();
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( AT_EXCT );
+#ifdef FF_FAX
+case( FAX_CALL ):
+ccShrdPrm.datStat = DS_MDF_REQ;
+cmhT30_Deactivate ();
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( AT_EXCT );
+#endif /* FF_FAX */
+}
+}
+#endif /* FAX_AND_DATA */
+/*
+* 3GPP standard 27007
+* (+CVHU)
+*
+* FreeCalypso note: +CVHU support was not present in the TCS211 version
+* of ACI, but it appears in the version we got from the LoCosto source.
+* The following stanza is a new addition with this LoCosto version,
+* and it was broken for our sans-PSI configuration: the reference to
+* to psiShrdPrm only works when PSI is there, and it is a compilation
+* failure otherwise.  The conditional on FF_PSI and the #else version
+* have been added by Space Falcon; the correctness of the latter is
+* not yet known.
+*/
+#ifdef FF_PSI
+if( ccShrdPrm.cvhu EQ CVHU_DropDTR_ATH_IGNORED OR
+((psiShrdPrm.dtr_clearcall EQ TRUE) AND
+(ccShrdPrm.cvhu EQ CVHU_DropDTR_IGNORED)) )
+{
+psiShrdPrm.dtr_clearcall = FALSE;
+return (AT_CMPL);
+}
+#else
+if( ccShrdPrm.cvhu EQ CVHU_DropDTR_ATH_IGNORED )
+return (AT_CMPL);
+#endif
+/*
+*-------------------------------------------------------------------
+* check for a call with CCBS possible
+*-------------------------------------------------------------------
+*/
+if( pCCCmdPrm -> mltyDscFlg NEQ 0 )
+return( AT_BUSY );
+/*
+*-------------------------------------------------------------------
+* check for a redial call
+*-------------------------------------------------------------------
+*/
+/* Implements Measure 80 */
+if (cmhCC_check_RedialCall(AT_CMD_H) EQ TRUE )
+{
+return( AT_CMPL );
+}
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_ACT_REQ, CT_MOC );
+if (cId EQ NO_ENTRY)
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_DSC_REQ, CT_MOC );    /* also search for calls in disconnect state */
+if( cId NEQ NO_ENTRY )
+{
+if( psaCC_ctb(cId)->CCBSstat EQ CCBSS_PSSBL )
+{
+pCCCmdPrm -> mltyDscFlg = 0;
+cmhCC_flagCall( cId, &(pCCCmdPrm -> mltyDscFlg));
+psaCC_ctb(cId)->nrmCs  = MNCC_CAUSE_CALL_CLEAR;
+psaCC_ctb(cId)->curCmd = AT_CMD_H;
+psaCC_ctb(cId)->curSrc = srcId;
+psaCC_ClearCall (cId);
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( AT_EXCT );
+}
+}
+/*
+*-------------------------------------------------------------------
+* check for a CCBS recall
+*-------------------------------------------------------------------
+*/
+cId = psaCC_ctbFindCall( (T_OWN)CMD_SRC_NONE, CS_ACT_REQ, CT_NI_MOC );
+if( cId NEQ NO_ENTRY )
+{
+psaCC_ctb(cId)->nrmCs  = MNCC_CAUSE_CALL_REJECT;
+psaCC_ClearCall (cId);
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+cmdLog.retCode = AT_CMPL;
+rAT_PercentCLOG( &cmdLog );
+#endif
+psaCC_FreeCtbNtry (cId);
+return( AT_CMPL );
+}
+/*
+*-------------------------------------------------------------------
+* check for a pending SAT call
+*-------------------------------------------------------------------
+*/
+#ifdef SIM_TOOLKIT
+if (cmhCC_check_pending_satCall() EQ TRUE )
+{
+return( AT_CMPL );
+}
+#endif /* SIM_TOOLKIT */
+/*
+*-------------------------------------------------------------------
+* clear all calls except a waiting call
+*-------------------------------------------------------------------
+*/
+pCCCmdPrm -> mltyDscFlg = 0;
+for( cId = 0; cId < MAX_CALL_NR; cId++ )
+{
+cmhCC_ClearCall( cId, MNCC_CAUSE_CALL_CLEAR, srcId, AT_CMD_H, &waitId );
+}
+if( pCCCmdPrm -> mltyDscFlg )
+{
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( AT_EXCT );
+}
+/*
+*-------------------------------------------------------------------
+* disconnect a waiting call with user determined user busy
+*-------------------------------------------------------------------
+*/
+/* Implements Measure 164 */
+if ( waitId NEQ NO_ENTRY )
+{
+cmhCC_disconnect_waiting_call ( srcId, waitId, AT_CMD_H,
+&(pCCCmdPrm -> mltyDscFlg) );
+return( AT_EXCT );
+}
+/*
+*-------------------------------------------------------------------
+* nothing to act on
+*-------------------------------------------------------------------
+*/
+return( AT_CMPL );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PlusCHUP             |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the +CHUP AT command
+which is responsible to terminate a call.
+1. The next step is to clear all calls of the call table
+exept a waiting call. The function returns if at least one
+call could be found.
+2. If no call was found, the function searches for a waiting
+call. If a waiting call was found, the call will be
+terminated declaring the user as busy.
+3. If none of the above situations match, the function
+returns with a fail.
+*/
+GLOBAL T_ACI_RETURN sAT_PlusCHUP ( T_ACI_CMD_SRC srcId )
+{
+SHORT cId;                  /* holds call id */
+SHORT waitId = NO_ENTRY;    /* holds call waiting id */
+T_CC_CMD_PRM * pCCCmdPrm;   /* points to CC command parameters */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+T_ACI_CLOG     cmdLog;      /* holds logging info */
+#endif
+TRACE_FUNCTION ("sAT_CHUP()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/*
+*-------------------------------------------------------------------
+* prepare log command
+*-------------------------------------------------------------------
+*/
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.atCmd                = AT_CMD_CHUP;
+cmdLog.cmdType              = CLOG_TYPE_Set;
+cmdLog.retCode              = AT_EXCT;
+cmdLog.sId                  = ACI_NumParmNotPresent;
+cmdLog.cmdPrm.sCHUP.srcId   = srcId;
+#endif
+/*
+*-------------------------------------------------------------------
+* check for a redial call
+*-------------------------------------------------------------------
+*/
+/* Implements Measure 80 */
+if (cmhCC_check_RedialCall(AT_CMD_CHUP) EQ TRUE )
+{
+return( AT_CMPL );
+}
+/*
+*-------------------------------------------------------------------
+* check for a pending SAT call
+*-------------------------------------------------------------------
+*/
+#ifdef SIM_TOOLKIT
+if (cmhCC_check_pending_satCall() EQ TRUE )
+{
+return( AT_CMPL );
+}
+#endif /* SIM_TOOLKIT */
+/*
+*-------------------------------------------------------------------
+* clear only active call
+*-------------------------------------------------------------------
+*/
+if( pCCCmdPrm -> mltyDscFlg NEQ 0 )
+return( AT_BUSY );
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_ACT, NO_VLD_CT);
+if( cId NEQ NO_ENTRY )
+{
+cmhCC_ClearCall(cId, MNCC_CAUSE_CALL_CLEAR, srcId, AT_CMD_CHUP, &waitId );
+}
+if( pCCCmdPrm -> mltyDscFlg )
+{
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( AT_EXCT );
+}
+/*
+*-------------------------------------------------------------------
+* disconnect a waiting call with user determined user busy
+*-------------------------------------------------------------------
+*/
+/* Implements Measure 164 */
+if ( waitId NEQ NO_ENTRY )
+{
+cmhCC_disconnect_waiting_call ( srcId, waitId, AT_CMD_CHUP,
+&(pCCCmdPrm -> mltyDscFlg) );
+return( AT_EXCT );
+}
+/*
+*-------------------------------------------------------------------
+* nothing to act on
+*-------------------------------------------------------------------
+*/
+return( AT_CMPL );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_A                    |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the A AT command
+which is responsible to accept an incoming call. The A
+command accepts an incoming call if no call is currently
+active. Otherwise if a call is in active state the A command
+starts to modify the active call. If the call mode set by
+the +CMOD command indicates a single call no modification
+takes place and the A command returns with a fail.
+*/
+GLOBAL T_ACI_RETURN sAT_A ( T_ACI_CMD_SRC srcId )
+{
+SHORT cId;                /* holds call id */
+T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
+#if defined (GPRS) AND defined (DTI)
+T_ACI_RETURN  ret_value;
+#endif  /* GPRS */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+T_ACI_CLOG     cmdLog;      /* holds logging info */
+#endif
+TRACE_FUNCTION ("sAT_A()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/*
+*-------------------------------------------------------------------
+* handle command for GPRS
+*-------------------------------------------------------------------
+*/
+#if defined (GPRS) AND defined (DTI)
+if ( TRUE EQ cmhSM_sAT_A( srcId, &ret_value ) )
+return ret_value;
+#endif  /* GPRS */
+/*
+*-------------------------------------------------------------------
+* prepare log command
+*-------------------------------------------------------------------
+*/
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.atCmd                = AT_CMD_A;
+cmdLog.cmdType              = CLOG_TYPE_Set;
+cmdLog.retCode              = AT_EXCT;
+cmdLog.sId                  = ACI_NumParmNotPresent;
+cmdLog.cmdPrm.sA.srcId      = srcId;
+#endif
+/*
+*-------------------------------------------------------------------
+* check for an active call
+*-------------------------------------------------------------------
+*/
+#ifdef FAX_AND_DATA
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_ACT, NO_VLD_CT );
+if( cId NEQ NO_ENTRY )
+{
+/*
+*-----------------------------------------------------------------
+* check call mode to modify the call
+*-----------------------------------------------------------------
+*/
+if( cmhCC_ChckInCallMdfy( cId, AT_CMD_A ) )
+{
+cmhCC_flagCall( cId, &(pCCCmdPrm->mltyCncFlg));
+psaCC_ctb(cId)->curCmd = AT_CMD_A;
+psaCC_ctb(cId)->curSrc = srcId;
+psaCC_ModifyCall(cId);
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( AT_EXCT );
+}
+/*
+*----------------------------------------------------------------------------------
+* ATA can be used to answer the second SAT call when the first call is active
+*----------------------------------------------------------------------------------
+*/
+#ifdef SIM_TOOLKIT
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_SAT_REQ, NO_VLD_CT );
+#ifdef FF_SAT_E
+if( cId EQ NO_ENTRY )
+{
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_SAT_CSD_REQ, NO_VLD_CT );
+}
+#endif /* FF_SAT_E */
+if( cId EQ NO_ENTRY )
+{
+TRACE_FUNCTION ("Already a call is active !!!");
+return( AT_FAIL);
+}
+#else
+/* Added Below Two lines to fix ACI-SPR-22325*/
+TRACE_FUNCTION ("Already a call is active !!!");
+return( AT_FAIL );
+#endif
+}
+#endif    /* of #ifdef FAX_AND_DATA */
+/*
+*-------------------------------------------------------------------
+* check for an incoming call to accept
+*-------------------------------------------------------------------
+*/
+if( pCCCmdPrm -> mltyCncFlg NEQ 0 )
+return( AT_BUSY );
+cId = psaCC_ctbFindCall( (T_OWN)CMD_SRC_NONE, CS_ACT_REQ, CT_MTC );
+if( cId NEQ NO_ENTRY )
+{
+/* accept the call */
+cmhCC_flagCall( cId, &(pCCCmdPrm->mltyCncFlg));
+cmhCC_AcceptCall(cId, srcId, AT_CMD_A);
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( AT_EXCT );
+}
+/*
+*-------------------------------------------------------------------
+* check for a CCBS recall condition
+*-------------------------------------------------------------------
+*/
+cId = psaCC_ctbFindCall( (T_OWN)CMD_SRC_NONE, CS_ACT_REQ, CT_NI_MOC );
+if( cId NEQ NO_ENTRY )
+{
+/* accept the call */
+{
+cmhCC_flagCall( cId, &(pCCCmdPrm->mltyCncFlg));
+cmhCC_NewCall(cId, srcId, AT_CMD_A);
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( AT_EXCT );
+}
+}
+/*
+*-------------------------------------------------------------------
+* check for a pending SAT call
+*-------------------------------------------------------------------
+*/
+#ifdef SIM_TOOLKIT
+/* triggered by SETUP CALL command */
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_SAT_REQ, NO_VLD_CT );
+#ifdef FF_SAT_E
+if( cId EQ NO_ENTRY )
+/* triggered by OPEN CHANNEL command */
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_SAT_CSD_REQ, NO_VLD_CT );
+#endif /* FF_SAT_E */
+if( cId NEQ NO_ENTRY )
+{
+if( psaCC_ctb(cId)->SATinv )
+{
+if( !cmhSAT_UserAcptCall( cId, (UBYTE)srcId ) )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_CmdDetailsSAT );
+return( AT_FAIL );
+}
+}
+else
+{
+cmhCC_flagCall( cId, &(pCCCmdPrm->mltyCncFlg));
+cmhCC_NewCall(cId, srcId, AT_CMD_A);
+}
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( AT_EXCT );
+}
+#if defined (GPRS) AND defined (FF_SAT_E) AND defined (DTI)
+else
+{
+/* check for a pending SAT GPRS channel */
+if( cmhSAT_OpChnGPRSPend(PDP_CONTEXT_CID_INVALID, OPCH_WAIT_CNF))
+{
+if( !cmhSAT_UserAcptCntxt( (UBYTE)srcId ) )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_CmdDetailsSAT );
+return( AT_FAIL );
+}
+return( AT_EXCT );
+}
+}
+#endif  /* GPRS AND FF_SAT_E */
+#endif  /* SIM_TOOLKIT */
+/*
+*-------------------------------------------------------------------
+* call not found
+*-------------------------------------------------------------------
+*/
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_CallNotFound );
+return( AT_FAIL );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PlusCLIR             |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the +CLIR AT command
+which is responsible to enable or disable the presentation
+of the own calling id for mobile originated calls.
+*/
+GLOBAL T_ACI_RETURN sAT_PlusCLIR ( T_ACI_CMD_SRC srcId,
+T_ACI_CLIR_MOD mode )
+{
+T_CC_CMD_PRM * pCCCmdPrm;   /* points to CC command parameters */
+TRACE_FUNCTION ("sAT_PlusCLIR()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/*
+*-------------------------------------------------------------------
+* process the mode parameter
+*-------------------------------------------------------------------
+*/
+switch( mode )
+{
+case( CLIR_MOD_NotPresent ):
+break;
+case( CLIR_MOD_Subscript ):
+case( CLIR_MOD_Invoc     ):
+case( CLIR_MOD_Supp      ):
+pCCCmdPrm -> CLIRmode = mode;
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+return( AT_CMPL );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PlusCMOD             |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the +CMOD AT command
+which is responsible to set the mode for mobile originated
+calls.
+*/
+GLOBAL T_ACI_RETURN sAT_PlusCMOD ( T_ACI_CMD_SRC srcId,
+T_ACI_CMOD_MOD mode )
+{
+TRACE_FUNCTION ("sAT_PlusCMOD()");
+/* check command source */
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+/* process the mode parameter */
+switch( mode )
+{
+case( CMOD_MOD_NotPresent ):
+break;
+case( CMOD_MOD_Single       ):
+#ifdef FAX_AND_DATA
+case( CMOD_MOD_VoiceFax     ):
+case( CMOD_MOD_VoiceDat     ):
+case( CMOD_MOD_VoiceFlwdDat ):
+#endif    /* of #ifdef FAX_AND_DATA */
+ccShrdPrm.CMODmode = mode;
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+return( AT_CMPL );
+}
+#ifdef FAX_AND_DATA
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PlusCBST             |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the +CBST AT command
+which is responsible to set the bearer service parameters
+for following mobile originated calls.
+*/
+GLOBAL T_ACI_RETURN sAT_PlusCBST ( T_ACI_CMD_SRC srcId,
+T_ACI_BS_SPEED speed,
+T_ACI_CBST_NAM name,
+T_ACI_CBST_CE ce)
+{
+TRACE_FUNCTION ("sAT_PlusCBST()");
+/* check command source */
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+/* process the speed parameter */
+switch( speed )
+{
+case( BS_SPEED_NotPresent ):
+speed = ccShrdPrm.CBSTspeed;
+break;
+case( BS_SPEED_AUTO         ):
+case( BS_SPEED_300_V21      ):
+case( BS_SPEED_1200_V22     ):
+case( BS_SPEED_1200_75_V23  ):
+case( BS_SPEED_2400_V22bis  ):
+case( BS_SPEED_2400_V26ter  ):
+case( BS_SPEED_4800_V32     ):
+case( BS_SPEED_9600_V32     ):
+case( BS_SPEED_9600_V34     ):
+case( BS_SPEED_14400_V34    ):
+/*  case( BS_SPEED_1200_V120    ): This layer 1 protocol is not supported
+case( BS_SPEED_2400_V120    ):
+case( BS_SPEED_4800_V120    ):
+case( BS_SPEED_9600_V120    ):
+case( BS_SPEED_14400_V120   ): */
+case( BS_SPEED_300_V110     ):
+case( BS_SPEED_1200_V110    ):
+case( BS_SPEED_2400_V110    ):
+case( BS_SPEED_4800_V110    ):
+case( BS_SPEED_9600_V110    ):
+case( BS_SPEED_14400_V110   ):
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+/* process the name parameter */
+switch( name )
+{
+case( CBST_NAM_NotPresent ):
+name = ccShrdPrm.CBSTname;
+break;
+case( CBST_NAM_Asynch ):
+case( CBST_NAM_Synch  ):
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+/* process the ce parameter */
+switch( ce )
+{
+case( CBST_CE_NotPresent ):
+ce = ccShrdPrm.CBSTce;
+break;
+case( CBST_CE_Transparent      ):
+case( CBST_CE_NonTransparent   ):
+case( CBST_CE_BothTransPref    ):
+case( CBST_CE_BothNonTransPref ):
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+/* assign the parameters */
+ccShrdPrm.CBSTspeed = speed;
+ccShrdPrm.CBSTname  = name;
+ccShrdPrm.CBSTce    = ce;
+/* update CC setting for MTC */
+psaCC_Config();
+return( AT_CMPL );
+}
+#endif /* FAX_AND_DATA */
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PlusCSTA             |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the +CSTA AT command
+which is responsible to set the type of address for further
+dialing commands.
+*/
+GLOBAL T_ACI_RETURN sAT_PlusCSTA ( T_ACI_CMD_SRC srcId,
+T_ACI_TOA * toa )
+{
+T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
+TRACE_FUNCTION ("sAT_PlusCSTA()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/*
+*-------------------------------------------------------------------
+* process the toa parameter
+*-------------------------------------------------------------------
+*/
+if( ! toa ) return( AT_CMPL );
+switch( toa -> ton )
+{
+case( TON_Unknown       ):
+case( TON_International ):
+case( TON_National      ):
+case( TON_NetSpecific   ):
+case( TON_DedAccess     ):
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+switch( toa -> npi )
+{
+case( NPI_Unknown       ):
+case( NPI_IsdnTelephony ):
+case( NPI_Data          ):
+case( NPI_Telex         ):
+case( NPI_National      ):
+case( NPI_Private       ):
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+pCCCmdPrm -> CSTAtoa.ton = toa -> ton;
+pCCCmdPrm -> CSTAtoa.npi = toa -> npi;
+pCCCmdPrm -> CSTAdef     = FALSE;
+return( AT_CMPL );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_DMY                  |
+| STATE   : code                  ROUTINE : sAT_PlusCTFR             |
++--------------------------------------------------------------------+
+PURPOSE : This refers to a service that causes an incoming alerting
+call to be forwarded to a specified number. Action command
+does this.
+*/
+GLOBAL T_ACI_RETURN sAT_PlusCTFR  ( T_ACI_CMD_SRC    srcId,
+CHAR            *number,
+T_ACI_TOA       *type,
+CHAR            *subaddr,
+T_ACI_TOS       *satype)
+{
+T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+T_ACI_CLOG     cmdLog;      /* holds logging info */
+#endif /* #if defined SMI OR defined MFW OR defined FF_MMI_RIV */
+SHORT cId;                /* holds call id */
+SHORT dscId;              /* holds call disconnect id */
+UBYTE idx;                /* holds index value */
+TRACE_FUNCTION ("sAT_PlusCTFR()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+/*
+* Check that number contains a valid dial string.
+* A dial string is valid if it contains at least one valid dial
+* character, garbage within the dial string is ignored (also spaces).
+*/
+if (strpbrk (number, "0123456789*#AaBbCc") EQ NULL)
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/*
+*-------------------------------------------------------------------
+* prepare log command
+*-------------------------------------------------------------------
+*/
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.atCmd                = AT_CMD_CTFR;
+cmdLog.cmdType              = CLOG_TYPE_Set;
+cmdLog.retCode              = AT_EXCT;
+cmdLog.sId                  = ACI_NumParmNotPresent;
+cmdLog.cId                  = NOT_PRESENT_8BIT;
+cmdLog.cmdPrm.sCTFR.srcId   = srcId;
+cmdLog.cmdPrm.sCTFR.number  = number;
+cmdLog.cmdPrm.sCTFR.type    = type;
+cmdLog.cmdPrm.sCTFR.subaddr = subaddr;
+cmdLog.cmdPrm.sCTFR.satype  = satype;
+#endif /* #if defined SMI OR defined MFW OR defined FF_MMI_RIV */
+/*
+*-------------------------------------------------------------------
+* find the call for which Call Deflection shall be invoked
+*-------------------------------------------------------------------
+*/
+dscId = -1;
+for (cId = 0; cId < MAX_CALL_NR; cId++)
+{
+if ((ccShrdPrm.ctb[cId] NEQ NULL) AND
+(psaCC_ctb(cId)->calStat    EQ CS_ACT_REQ) AND
+(psaCC_ctb(cId)->calType    EQ CT_MTC))
+{
+dscId = cId;
+break;
+}
+}
+if ((dscId >= 0) AND
+(psaCC_ctb(dscId)->curCmd NEQ AT_CMD_NONE))
+{
+return( AT_BUSY );
+}
+/*
+* There is no check here whether CD is applicable for the specific
+* telecommunication service (22.004 Normative Annex A), as CD is
+* applicable for all CC telecommunication services.
+* GSM 07.07 says CD was only applicable for teleservice 11, but this
+* seems to be wrong.
+*/
+/*
+*-------------------------------------------------------------------
+* Clear the incoming call with facility invoke component for CD
+*-------------------------------------------------------------------
+*/
+/*lint -e{661} cId causes out of bounds access, it does not! */
+if( dscId >= 0 ) /* Implies cId also >= 0 */
+{
+cmhCC_flagCall( dscId, &(pCCCmdPrm -> mltyDscFlg));
+psaCC_ctb(cId)->nrmCs    = MNCC_CAUSE_CALL_CLEAR;
+psaCC_ctb(cId)->curCmd   = AT_CMD_CTFR;
+psaCC_ctb(cId)->curSrc   = srcId;
+#ifdef FF_ATI
+io_setRngInd (IO_RING_OFF, CRING_SERV_TYP_NotPresent, CRING_SERV_TYP_NotPresent ); /* V.24 Ring Indicator Line */
+#endif
+for (idx = 0; idx < CMD_SRC_MAX; idx++)
+{
+R_AT (RAT_CRING_OFF, (T_ACI_CMD_SRC)idx)(dscId + 1);
+}
+CCD_START;
+{
+psaCC_asmCDReq (number, type, subaddr, satype);
+psaCC_asmComponent (dscId);
+psaCC_ClearCall (dscId);
+}
+CCD_END;
+psaCC_ctb(cId)->CDStat   = CD_Requested;
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = dscId + 1;
+rAT_PercentCLOG( &cmdLog );
+#endif /* #if defined SMI OR defined MFW OR defined FF_MMI_RIV */
+return( AT_EXCT );
+}
+/*
+* No call with matching criteria has been found in the call table.
+*/
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+return AT_FAIL;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : find_waiting_held_call   |
++--------------------------------------------------------------------+
+PURPOSE : find waiting held calls
+*/
+LOCAL T_ACI_RETURN find_waiting_held_call(SHORT *cwaId,
+SHORT *hldId,
+SHORT *rclId)
+{
+SHORT cId;
+/* reinitialize */
+*cwaId = -1;
+*hldId = -1;
+*rclId = -1;
+for( cId = 0; cId < MAX_CALL_NR; cId++ )
+{
+if (ccShrdPrm.ctb[cId] NEQ NULL)
+{
+if( psaCC_ctb(cId)->calStat  EQ CS_ACT_REQ     AND
+psaCC_ctb(cId)->calOwn   EQ ((T_OWN)CMD_SRC_NONE)   AND
+psaCC_ctb(cId)->calType  EQ CT_MTC         )
+{
+*cwaId = cId;
+}
+if( psaCC_ctb(cId)->calStat EQ CS_HLD )
+{
+if(*hldId EQ -1)
+{
+/* take only first found call on hold (ex: in case of multiparty) */
+*hldId = cId;
+}
+}
+if( psaCC_ctb(cId)->calStat  EQ CS_ACT_REQ     AND
+psaCC_ctb(cId)->calOwn   EQ ((T_OWN)CMD_SRC_NONE)   AND
+psaCC_ctb(cId)->calType  EQ CT_NI_MOC      )
+{
+*rclId = cId;
+}
+}
+}
+if((*cwaId >= 0 AND psaCC_ctb(*cwaId)->curCmd NEQ AT_CMD_NONE) OR
+(*hldId >= 0 AND psaCC_ctb(*hldId)->curCmd NEQ AT_CMD_NONE) OR
+(*rclId >= 0 AND psaCC_ctb(*rclId)->curCmd NEQ AT_CMD_NONE) )
+{
+return( AT_BUSY );
+}
+return(AT_CMPL);
+}
+/* SEND LOG info to MFW */
+LOCAL void chld_ratlog( T_ACI_CMD_SRC  srcId,
+T_ACI_CHLD_MOD mode,
+CHAR           *call,
+T_ACI_CHLD_ACT act,
+SHORT          cId,
+T_ACI_RETURN   acireturn )
+{
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+T_ACI_CLOG     cmdLog;      /* holds logging info */
+/* prepare log command */
+cmdLog.atCmd                = AT_CMD_CHLD;
+cmdLog.cmdType              = CLOG_TYPE_Set;
+cmdLog.sId                  = ACI_NumParmNotPresent;
+cmdLog.cmdPrm.sCHLD.srcId   = srcId;
+cmdLog.cmdPrm.sCHLD.mode    = mode;
+cmdLog.cmdPrm.sCHLD.call    = call;
+cmdLog.cmdPrm.sCHLD.act = act;
+cmdLog.cId              = cId+1;
+cmdLog.retCode          = acireturn;
+rAT_PercentCLOG( &cmdLog );
+#endif  /* SMI OR defined MFW */
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : chld_RelHldOrUdub        |
++--------------------------------------------------------------------+
+PURPOSE : ???
+*/
+LOCAL T_ACI_RETURN chld_RelHldOrUdub(T_ACI_CMD_SRC srcId)
+{
+T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
+SHORT        cId;
+UBYTE        idx;        /* holds index value */
+SHORT        dscId;      /* holds call disconnect id */
+TRACE_FUNCTION("chld_RelHldOrUdub");
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/*
+*---------------------------------------------------------------
+* clear a waiting call
+*---------------------------------------------------------------
+*/
+pCCCmdPrm -> mltyCncFlg = 0;
+pCCCmdPrm -> mltyDscFlg = 0;
+cId = psaCC_ctbFindCall( (T_OWN)CMD_SRC_NONE, CS_ACT_REQ, CT_MTC );
+if( cId >= 0 )
+{
+if( psaCC_ctb(cId)->curCmd NEQ AT_CMD_NONE )
+return( AT_BUSY );
+pCCCmdPrm -> CHLDmode = CHLD_MOD_RelHldOrUdub;
+CHLDaddInfo           = NO_CHLD_ADD_INFO;
+cmhCC_ClearCall(cId, MNCC_CAUSE_USER_BUSY, srcId, AT_CMD_CHLD, NULL);
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm -> CHLDmode, NULL, CHLD_ACT_Release, cId, AT_EXCT );
+#ifdef FF_ATI
+io_setRngInd (IO_RING_OFF, CRING_SERV_TYP_NotPresent, CRING_SERV_TYP_NotPresent ); /* V.24 Ring Indicator Line */
+#endif
+for( idx = 0; idx < CMD_SRC_MAX; idx++ )
+{
+R_AT( RAT_CRING_OFF, (T_ACI_CMD_SRC)idx )( cId+1 );
+}
+return( AT_EXCT );
+}
+/*
+*---------------------------------------------------------------
+* clear a CCBS recall
+*---------------------------------------------------------------
+*/
+cId = psaCC_ctbFindCall( (T_OWN)CMD_SRC_NONE, CS_ACT_REQ, CT_NI_MOC );
+if( cId >= 0 )
+{
+if( psaCC_ctb(cId)->curCmd NEQ AT_CMD_NONE )
+return( AT_BUSY );
+psaCC_ctb(cId)->nrmCs  = MNCC_CAUSE_USER_BUSY;
+psaCC_ClearCall (cId);
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm -> CHLDmode, NULL, CHLD_ACT_Release, cId, AT_CMPL );
+psaCC_FreeCtbNtry (cId);
+return( AT_CMPL );
+}
+/*
+*---------------------------------------------------------------
+* or clear all held calls
+*---------------------------------------------------------------
+*/
+dscId = -1;
+for( cId = 0; cId < MAX_CALL_NR; cId++ )
+{
+if (ccShrdPrm.ctb[cId] NEQ NULL AND
+psaCC_ctb(cId)->calStat    EQ CS_HLD AND
+psaCC_ctb(cId)->curCmd     EQ AT_CMD_NONE)
+{
+cmhCC_ClearCall( cId, MNCC_CAUSE_CALL_CLEAR, srcId, AT_CMD_CHLD, NULL);
+dscId = cId;
+}
+}
+if( ! pCCCmdPrm -> mltyDscFlg )
+{
+return( AT_BUSY );
+}
+else if (dscId >= 0)
+{
+pCCCmdPrm -> CHLDmode = CHLD_MOD_RelHldOrUdub;
+CHLDaddInfo           = NO_CHLD_ADD_INFO;
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, NULL, CHLD_ACT_Release, dscId, AT_EXCT );
+return( AT_EXCT );
+}
+else
+{
+return( AT_FAIL );
+}
+}
+/*-----------------------------------------------------------------
+* release all active calls, and accept held or waiting call
+*-----------------------------------------------------------------*/
+LOCAL T_ACI_RETURN chld_RelActAndAcpt(T_ACI_CMD_SRC srcId)
+{
+SHORT        cwaId;      /* holds call waiting id */
+SHORT        hldId;      /* holds call hold id */
+SHORT        rclId;      /* holds recall id */
+SHORT        dscId = -1; /* will be set if a call is disconnected (with its cId) */
+SHORT        cId;
+T_ACI_RETURN ret;
+T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
+TRACE_FUNCTION("chld_RelActAndAcpt");
+/* find the waiting or held call */
+ret = find_waiting_held_call(&cwaId, &hldId, &rclId);
+TRACE_EVENT_P1("cwaId = %d", cwaId);
+if(ret EQ AT_BUSY)
+return(AT_BUSY);
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/*
+*---------------------------------------------------------------
+* clear all active calls
+*---------------------------------------------------------------
+*/
+pCCCmdPrm -> mltyCncFlg = 0;
+pCCCmdPrm -> mltyDscFlg = 0;
+for( cId = 0; cId < MAX_CALL_NR; cId++ )
+{
+if (ccShrdPrm.ctb[cId] NEQ NULL AND
+psaCC_ctb(cId)->calStat    EQ CS_ACT     AND
+psaCC_ctb(cId)->curCmd     EQ AT_CMD_NONE)
+{
+psaCC_StopDTMF (cId); /* HM 27.07.00 */
+dscId = cId;
+cmhCC_ClearCall( cId, MNCC_CAUSE_CALL_CLEAR, srcId, AT_CMD_CHLD, NULL );
+}
+}
+/*
+*---------------------------------------------------------------
+* accept the waiting call
+*---------------------------------------------------------------
+*/
+if( cwaId >= 0 )
+{
+cmhCC_flagCall( cwaId, &(pCCCmdPrm -> mltyCncFlg));
+pCCCmdPrm -> CHLDmode = CHLD_MOD_RelActAndAcpt;
+if( dscId NEQ -1 )
+{
+CHLDaddInfo = CHLD_ADD_INFO_ACC_CAL;
+}
+else
+{
+cmhCC_AcceptCall(cwaId, srcId, AT_CMD_CHLD);
+}
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, NULL, CHLD_ACT_Accept, cwaId, AT_EXCT );
+return( AT_EXCT );
+}
+/*
+*---------------------------------------------------------------
+* accept the CCBS recall
+*---------------------------------------------------------------
+*/
+if( rclId >= 0 )
+{
+cmhCC_flagCall( rclId, &(pCCCmdPrm -> mltyCncFlg));
+pCCCmdPrm -> CHLDmode = CHLD_MOD_RelActAndAcpt;
+/*
+* The MSC in GSM 04.93, figure 4.3.2 says the SETUP for the CCBS
+* call is sent immediately after the DISCONNECT for the existing
+* call was sent into the network, they do not wait for a RELEASE
+* from the network. This seems to be different for the call waiting
+* case, compare this with the MSC in GSM 11.10 clause 31.3.1.2.
+*/
+cmhCC_NewCall(rclId, srcId, AT_CMD_D);
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, NULL, CHLD_ACT_Accept, rclId, AT_EXCT );
+return( AT_EXCT );
+}
+/*
+*---------------------------------------------------------------
+* retrieve the held call
+*---------------------------------------------------------------
+*/
+if( hldId >= 0 )
+{
+cmhCC_flagCall( hldId, &(pCCCmdPrm -> mltyCncFlg));
+pCCCmdPrm -> CHLDmode = CHLD_MOD_RelActAndAcpt;
+if( dscId NEQ -1 )
+{
+CHLDaddInfo = CHLD_ADD_INFO_RTV_CAL;
+}
+else
+{
+cmhCC_RetrieveCall(hldId, srcId);
+}
+/* inform MFW */
+chld_ratlog( srcId,
+pCCCmdPrm->CHLDmode,
+NULL,
+(psaCC_ctb(hldId)->mptyStat EQ CS_ACT)? CHLD_ACT_RetrieveMpty:CHLD_ACT_Retrieve,
+hldId,
+AT_EXCT );
+return( AT_EXCT );
+}
+/*
+*---------------------------------------------------------------
+* at least one call was disconnected
+*---------------------------------------------------------------
+*/
+if( dscId NEQ -1 )
+{
+pCCCmdPrm -> CHLDmode = CHLD_MOD_RelActAndAcpt;
+CHLDaddInfo           = NO_CHLD_ADD_INFO;
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, NULL, CHLD_ACT_Release, dscId, AT_EXCT );
+return( AT_EXCT );
+}
+return (AT_FAIL);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : chld_RelActSpec          |
++--------------------------------------------------------------------+
+PURPOSE : release a specific active call
+*/
+LOCAL T_ACI_RETURN chld_RelActSpec(T_ACI_CMD_SRC srcId, CHAR *call)
+{
+T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
+SHORT        spcId;      /* holds specified call id */
+T_ACI_RETURN retCode;
+TRACE_FUNCTION("chld_RelActSpec");
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/* Implements Measure 117 */
+retCode = chld_Rel_MultipartySpec( srcId, &spcId,
+CHLD_MOD_RelActSpec, call );
+if ( retCode NEQ AT_CMPL )
+{
+return retCode;
+}
+/*
+*---------------------------------------------------------------
+* clear the specific active call if possible
+*---------------------------------------------------------------
+*/
+if (ccShrdPrm.ctb[spcId] EQ NULL OR psaCC_ctb(spcId)->calStat NEQ CS_ACT)
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+return( AT_FAIL );        /* specific call does not match condition */
+}
+cmhCC_ClearCall ( spcId, MNCC_CAUSE_CALL_CLEAR, srcId, AT_CMD_CHLD, NULL );
+pCCCmdPrm -> CHLDmode = CHLD_MOD_RelActSpec;
+CHLDaddInfo           = NO_CHLD_ADD_INFO;
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, call, CHLD_ACT_Release, spcId, AT_EXCT );
+return( AT_EXCT );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : chld_RelAnySpec          |
++--------------------------------------------------------------------+
+PURPOSE : release a specific  call
+*/
+LOCAL T_ACI_RETURN chld_RelAnySpec(T_ACI_CMD_SRC srcId, CHAR *call)
+{
+T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
+SHORT        spcId;      /* holds specified call id */
+SHORT        waitId = NO_ENTRY; /* holds call waiting id */
+UBYTE        idx    = 0; /* temporary counter */
+T_ACI_RETURN retCode;
+TRACE_FUNCTION("chld_RelAnySpec");
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/* Implements Measure 117 */
+retCode = chld_Rel_MultipartySpec( srcId, &spcId,
+CHLD_MOD_RelAnySpec, call );
+if ( retCode NEQ AT_CMPL )
+{
+return retCode;
+}
+/*
+*---------------------------------------------------------------
+* clear the specific call if possible
+*---------------------------------------------------------------
+*/
+if (ccShrdPrm.ctb[spcId] EQ NULL)
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+return( AT_FAIL );        /* specific call does not match condition */
+}
+cmhCC_ClearCall ( spcId, MNCC_CAUSE_CALL_CLEAR, srcId, AT_CMD_CHLD, &waitId );
+/* The call that shall be released is a waiting call (stop ringing) */
+if( waitId NEQ NO_ENTRY )
+{
+cmhCC_flagCall( waitId, &(pCCCmdPrm -> mltyDscFlg));
+psaCC_ctb(waitId)->nrmCs  = MNCC_CAUSE_USER_BUSY;
+psaCC_ctb(waitId)->curCmd = AT_CMD_CHLD;
+psaCC_ctb(waitId)->curSrc = srcId;
+psaCC_ClearCall (waitId);
+#ifdef AT_INTERPRETER
+io_setRngInd (IO_RING_OFF, CRING_SERV_TYP_NotPresent, CRING_SERV_TYP_NotPresent ); /* V.24 Ring Indicator Line */
+#endif
+for( idx = 0; idx < CMD_SRC_MAX; idx++ )
+{
+R_AT( RAT_CRING_OFF, (T_ACI_CMD_SRC)idx )( waitId+1 );
+}
+}
+pCCCmdPrm->CHLDmode   = CHLD_MOD_RelAnySpec;
+CHLDaddInfo           = NO_CHLD_ADD_INFO;
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, call, CHLD_ACT_Release, spcId, AT_EXCT );
+return( AT_EXCT );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : chld_HldActAndAcpt       |
++--------------------------------------------------------------------+
+PURPOSE : place all active calls on hold, and accept held or waiting
+call
+*/
+LOCAL T_ACI_RETURN chld_HldActAndAcpt(T_ACI_CMD_SRC srcId)
+{
+T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
+SHORT        cId;                /* holds call id */
+T_ACI_RETURN ret;
+SHORT        cwaId;              /* holds call waiting id */
+SHORT        hldId;              /* holds call hold id */
+SHORT        rclId;              /* holds recall id */
+BOOL         hldCalFlg  = FALSE; /* flags a held call */
+BOOL         mptyHldFlg = FALSE; /* flags a multiparty held call */
+T_ACI_CHLD_ACT chldact;          /* contains the type of CHLD activity when informing MFW */
+TRACE_FUNCTION("chld_HldActAndAcpt");
+/* find the waiting or held call */
+ret = find_waiting_held_call(&cwaId, &hldId, &rclId);
+if(ret EQ AT_BUSY)
+return(AT_BUSY);
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+//Spec 3GPP TS 22.083 Sec 1.6.83.2 which says - Although the call is offered to the subscriber, she cannot accept the call as long as she has one active call and one call on hold.
+#if 0
+if( cwaId >=0 AND hldId >=0 )
+{
+/* check for Active Call if already Held Call and Waiting Call */
+for( cId = 0; cId < MAX_CALL_NR; cId++ )
+{
+if (ccShrdPrm.ctb[cId] NEQ NULL AND
+psaCC_ctb(cId)->calStat    EQ CS_ACT AND
+psaCC_ctb(cId)->curCmd     EQ AT_CMD_NONE )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_OneCallOnHold );
+return( AT_FAIL );    /* only one call could be on hold,
+no chance for the waiting call */
+}
+}
+}
+#endif
+/*
+*---------------------------------------------------------------
+* put all active calls on hold
+*---------------------------------------------------------------
+*/
+/* Implements Measure 181 and 182 */
+if ( chld_HoldActiveCalls( srcId, &mptyHldFlg, &hldCalFlg, &cId ) EQ FALSE )
+{
+return( AT_FAIL ); /* no data calls supported */
+}
+/*
+*-------------------------------------------------------------------------
+* retrieve the held call first, if there is a active call and a hold call
+*-------------------------------------------------------------------------
+*/
+if( hldCalFlg AND hldId >= 0 )
+{
+cmhCC_flagCall( hldId, &(pCCCmdPrm -> mltyCncFlg));
+pCCCmdPrm -> CHLDmode = CHLD_MOD_HldActAndAcpt;
+cmhCC_RetrieveCall(hldId, srcId);
+/* inform MFW */
+if( hldCalFlg )
+{
+chldact = (mptyHldFlg)? CHLD_ACT_SwapMpty:CHLD_ACT_Swap;
+}
+else
+{
+chldact = (psaCC_ctb(hldId)->mptyStat EQ CS_ACT)? CHLD_ACT_RetrieveMpty :CHLD_ACT_Retrieve;
+}
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, NULL, chldact, hldId, AT_EXCT );
+return( AT_EXCT );
+}
+/*
+*---------------------------------------------------------------
+* accept the waiting call
+*---------------------------------------------------------------
+*/
+if( cwaId >= 0 )
+{
+cmhCC_flagCall( cwaId, &(pCCCmdPrm -> mltyCncFlg));
+pCCCmdPrm -> CHLDmode = CHLD_MOD_HldActAndAcpt;
+if( hldCalFlg )
+{
+CHLDaddInfo = CHLD_ADD_INFO_ACC_CAL;
+}
+else
+{
+cmhCC_AcceptCall(cwaId, srcId, AT_CMD_CHLD);
+}
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, NULL, CHLD_ACT_Accept, cwaId, AT_EXCT );
+return( AT_EXCT );
+}
+/*
+*---------------------------------------------------------------
+* accept the CCBS recall
+*---------------------------------------------------------------
+*/
+if( rclId >= 0 )
+{
+cmhCC_flagCall( rclId, &(pCCCmdPrm -> mltyCncFlg));
+pCCCmdPrm -> CHLDmode = CHLD_MOD_HldActAndAcpt;
+if( hldCalFlg )
+{
+CHLDaddInfo = CHLD_ADD_INFO_DIAL_CAL;
+}
+else
+{
+cmhCC_NewCall(rclId, srcId, AT_CMD_CHLD);
+}
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, NULL, CHLD_ACT_Accept, rclId, AT_EXCT );
+return( AT_EXCT );
+}
+/*
+*---------------------------------------------------------------
+* retrieve the held call
+*---------------------------------------------------------------
+*/
+if( hldId >= 0 )
+{
+cmhCC_flagCall( hldId, &(pCCCmdPrm -> mltyCncFlg));
+pCCCmdPrm -> CHLDmode = CHLD_MOD_HldActAndAcpt;
+cmhCC_RetrieveCall(hldId, srcId);
+/* inform MFW */
+if( hldCalFlg )
+{
+chldact = (mptyHldFlg)? CHLD_ACT_SwapMpty:CHLD_ACT_Swap;
+}
+else
+{
+chldact = (psaCC_ctb(hldId)->mptyStat EQ CS_ACT)? CHLD_ACT_RetrieveMpty :CHLD_ACT_Retrieve;
+}
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, NULL, chldact, hldId, AT_EXCT );
+return( AT_EXCT );
+}
+/*
+*---------------------------------------------------------------
+* at least one call was put on hold
+*---------------------------------------------------------------
+*/
+if( hldCalFlg )
+{
+pCCCmdPrm -> CHLDmode = CHLD_MOD_HldActAndAcpt;
+CHLDaddInfo           = NO_CHLD_ADD_INFO;
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode,
+NULL,
+(mptyHldFlg)? CHLD_ACT_HoldMpty:CHLD_ACT_Hold,
+cId, AT_EXCT );
+return( AT_EXCT );
+}
+return( AT_FAIL );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : chld_HldActExc           |
++--------------------------------------------------------------------+
+PURPOSE : put all active calls on hold except the specified call
+*/
+LOCAL T_ACI_RETURN chld_HldActExc(T_ACI_CMD_SRC srcId, CHAR *call)
+{
+T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
+SHORT        spcId;      /* holds specified call id */
+SHORT        cId;        /* holds call id */
+BOOL         hldCalFlg  = FALSE; /* flags a held call */
+BOOL         mptyHldFlg = FALSE; /* flags a multiparty held call */
+T_ACI_CHLD_ACT chld_act;
+TRACE_FUNCTION("chld_HldActExc");
+if( call EQ NULL )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );  /* no call specified */
+}
+spcId = atoi( call );
+if( spcId EQ 0 OR spcId > MAX_CALL_NR )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+spcId--;                        /* adapt to call table index */
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+pCCCmdPrm -> mltyCncFlg = 0;
+pCCCmdPrm -> mltyDscFlg = 0;
+/*
+*-------------------------------------------------------------
+* if specified call is active and no multiparty
+*-------------------------------------------------------------
+*/
+/* no action needed */
+/*
+*-------------------------------------------------------------
+* if specified call is active and member of multiparty
+*-------------------------------------------------------------
+*/
+if (ccShrdPrm.ctb[spcId] NEQ NULL AND
+psaCC_ctb(spcId)->calStat    EQ CS_ACT AND
+psaCC_ctb(spcId)->mptyStat   EQ CS_ACT AND
+psaCC_ctb(spcId)->curCmd     EQ AT_CMD_NONE)
+{
+/* If this is a multiparty with only one call left then we must not split! */
+if (psaCC_CountMPTY() > 1)
+{
+cmhCC_flagCall( spcId, &(pCCCmdPrm -> mltyCncFlg));
+psaCC_ctb(spcId)->curCmd = AT_CMD_CHLD;
+psaCC_ctb(spcId)->curSrc = srcId;
+psaCC_SplitMPTY(spcId);
+chld_act = CHLD_ACT_SplitMpty;
+}
+else
+{
+/* call is already active, so command has no effect */
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Unknown );
+return( AT_FAIL );
+}
+}
+/*
+*-------------------------------------------------------------
+* if specified call is on hold and no multiparty
+*-------------------------------------------------------------
+*/
+else if (ccShrdPrm.ctb[spcId] NEQ NULL AND
+psaCC_ctb(spcId)->calStat    EQ CS_HLD AND
+psaCC_ctb(spcId)->mptyStat   EQ CS_IDL AND
+psaCC_ctb(spcId)->curCmd     EQ AT_CMD_NONE)
+{
+for( cId = 0; cId < MAX_CALL_NR; cId++ )
+{
+if (ccShrdPrm.ctb[cId] NEQ NULL AND
+psaCC_ctb(cId)->calStat    EQ CS_ACT AND
+psaCC_ctb(cId)->curCmd     EQ AT_CMD_NONE)
+{
+if( cmhCC_getcalltype(cId) NEQ VOICE_CALL )
+{
+pCCCmdPrm -> mltyCncFlg = 0;
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_CallTypeNoHold );
+return( AT_FAIL );    /* no data calls supported */
+}
+hldCalFlg = TRUE;
+if( psaCC_ctb(cId)->mptyStat EQ CS_ACT )
+{
+mptyHldFlg = TRUE;
+}
+cmhCC_HoldCall(cId, srcId, AT_CMD_CHLD);
+}
+}
+cmhCC_flagCall( spcId, &(pCCCmdPrm -> mltyCncFlg));
+pCCCmdPrm -> CHLDmode = CHLD_MOD_HldActExc;
+cmhCC_RetrieveCall(spcId, srcId);
+if( hldCalFlg )
+{
+chld_act = (mptyHldFlg)?
+CHLD_ACT_SwapMpty:CHLD_ACT_Swap;
+}
+else
+chld_act = (mptyHldFlg)?
+CHLD_ACT_RetrieveMpty:CHLD_ACT_Retrieve;
+}
+/*
+*-------------------------------------------------------------
+* if specified call is on hold and member of multiparty
+*-------------------------------------------------------------
+*/
+else if (ccShrdPrm.ctb[spcId] NEQ NULL AND
+psaCC_ctb(spcId)->calStat    EQ CS_HLD AND
+psaCC_ctb(spcId)->mptyStat   EQ CS_ACT AND
+psaCC_ctb(spcId)->curCmd     EQ AT_CMD_NONE)
+{
+for( cId = 0; cId < MAX_CALL_NR; cId++ )
+{
+if (ccShrdPrm.ctb[cId] NEQ NULL AND
+psaCC_ctb(cId)->calStat    EQ CS_ACT AND
+psaCC_ctb(cId)->curCmd     EQ AT_CMD_NONE)
+{
+if( cmhCC_getcalltype(cId) NEQ VOICE_CALL )
+{
+pCCCmdPrm -> mltyCncFlg = 0;
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_CallTypeNoHold );
+return( AT_FAIL );    /* no data calls supported */
+}
+hldCalFlg = TRUE;
+cmhCC_HoldCall(cId, srcId, AT_CMD_CHLD);
+}
+}
+cmhCC_flagCall( spcId, &(pCCCmdPrm -> mltyCncFlg));
+pCCCmdPrm -> CHLDmode = CHLD_MOD_HldActExc;
+CHLDaddInfo           = NO_CHLD_ADD_INFO;
+psaCC_ctb(spcId)->curCmd = AT_CMD_CHLD;
+psaCC_ctb(spcId)->curSrc = srcId;
+/* If this is a multiparty with only one call left then we must not split! */
+if (psaCC_CountMPTY() > 1)
+{
+psaCC_SplitMPTY(spcId);
+chld_act = CHLD_ACT_SplitMpty;
+}
+else
+{
+cmhCC_RetrieveCall(spcId, srcId);
+chld_act = CHLD_ACT_Retrieve;
+}
+}
+/*
+*-------------------------------------------------------------
+* if other command is running on specified call
+*-------------------------------------------------------------
+*/
+else if (ccShrdPrm.ctb[spcId] NEQ NULL AND
+psaCC_ctb(spcId)->curCmd NEQ AT_CMD_NONE)
+{
+return( AT_BUSY );
+}
+/*
+*-------------------------------------------------------------
+* unknown condition
+*-------------------------------------------------------------
+*/
+else
+{
+TRACE_ERROR ("Unknown condition");
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Unknown );
+return( AT_FAIL );
+}
+/*
+*-------------------------------------------------------------
+* send return code
+*-------------------------------------------------------------
+*/
+if( pCCCmdPrm -> mltyCncFlg NEQ 0 )
+{
+pCCCmdPrm -> CHLDmode = CHLD_MOD_HldActExc;
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, call, chld_act, spcId, AT_EXCT );
+return( AT_EXCT );
+}
+else
+{
+return( AT_CMPL );
+}
+}
+/*-----------------------------------------------------------------
+* add a held call to the conversation
+*-----------------------------------------------------------------*/
+LOCAL T_ACI_RETURN chld_AddHld(T_ACI_CMD_SRC srcId)
+{
+SHORT        actId;              /* holds call active id */
+T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
+TRACE_FUNCTION("chld_AddHld( )");
+/* search a held call */
+if( psaCC_ctbFindCall( OWN_SRC_INV, CS_HLD, NO_VLD_CT ) EQ NO_ENTRY )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+return( AT_FAIL );
+}
+actId = psaCC_ctbFindCall( OWN_SRC_INV, CS_ACT, NO_VLD_CT );
+if( actId EQ NO_ENTRY )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+return( AT_FAIL );
+}
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+cmhCC_flagCall( actId, &(pCCCmdPrm -> mltyCncFlg));
+psaCC_ctb(actId)->curCmd = AT_CMD_CHLD;
+psaCC_ctb(actId)->curSrc = srcId;
+psaCC_BuildMPTY(actId);
+pCCCmdPrm -> CHLDmode = CHLD_MOD_AddHld;
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, NULL, CHLD_ACT_BuildMpty, actId, AT_EXCT );
+return( AT_EXCT );
+}
+/*-----------------------------------------------------------------
+* explicit call transfer
+*-----------------------------------------------------------------*/
+LOCAL T_ACI_RETURN chld_Ect(T_ACI_CMD_SRC srcId)
+{
+SHORT cId;                /* holds call id */
+SHORT actId;              /* holds call active id */
+SHORT hldId;              /* holds call hold id */
+T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
+TRACE_FUNCTION("chld_Ect");
+/*
+*---------------------------------------------------------------
+* find the active(req) or held call
+*---------------------------------------------------------------
+*/
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+actId = hldId = -1;
+for( cId = 0; cId < MAX_CALL_NR; cId++ )
+{
+if (ccShrdPrm.ctb[cId] NEQ NULL)
+{
+if( cmhCC_getcalltype(cId) NEQ VOICE_CALL )
+{
+/* not a valid id for ECT */
+}
+else if (psaCC_ctb(cId)->calStat  EQ CS_ACT OR
+(psaCC_ctb(cId)->calStat EQ CS_ACT_REQ AND
+psaCC_ctb(cId)->calType EQ CT_MOC))
+{
+if( actId EQ -1 ) actId = cId;
+}
+else if( psaCC_ctb(cId)->calStat EQ CS_HLD )
+{
+if( hldId EQ -1 ) hldId = cId;
+}
+}
+}
+/* curCmd of actId will be updated only if hldId is valid. */
+if( hldId >= 0 AND
+psaCC_ctb(hldId)->curCmd NEQ AT_CMD_NONE )
+{
+TRACE_EVENT_P1("CHLD ECT: hldId busy with %d", psaCC_ctb(hldId)->curCmd);
+return( AT_BUSY );
+}
+/*
+* if command state is not idle and update the curCmd only if it is NONE
+*/
+if(actId >= 0 AND hldId >= 0)
+{
+switch(psaCC_ctb(actId)->curCmd)
+{
+case(AT_CMD_NONE):
+psaCC_ctb(actId)->curCmd = AT_CMD_CHLD;
+psaCC_ctb(actId)->curSrc = srcId;
+break;
+case(AT_CMD_D):
+/* command state where actId might find itself */
+break;
+default:
+TRACE_EVENT_P1("CHLD ECT: actId busy with %d", psaCC_ctb(actId)->curCmd);
+return( AT_BUSY );
+}
+}
+if( actId >= 0 AND hldId >= 0 )
+{
+if( psaCC_ECT(hldId) NEQ 0 )
+{
+return(AT_FAIL);
+}
+/* Update params only if the facility message is successfully
+sent to the network */
+cmhCC_flagCall( actId, &(pCCCmdPrm -> mltyDscFlg));
+cmhCC_flagCall( hldId, &(pCCCmdPrm -> mltyDscFlg));
+psaCC_ctb(hldId)->curCmd = AT_CMD_CHLD;
+psaCC_ctb(hldId)->curSrc = srcId;
+ccShrdPrm.cIdMPTY        = actId;
+pCCCmdPrm -> CHLDmode = CHLD_MOD_Ect;
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, NULL, CHLD_ACT_ECT, actId, AT_EXCT );
+return( AT_EXCT );
+}
+TRACE_EVENT("CHLD: ECT: could not find interesting call ids");
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+return( AT_FAIL );
+}
+/*-----------------------------------------------------------------
+* activate call completion to busy subscriber
+*-----------------------------------------------------------------*/
+LOCAL T_ACI_RETURN chld_Ccbs(T_ACI_CMD_SRC srcId)
+{
+T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
+SHORT        dscId = -1; /* will be set if a call is disconnected (with its cId) */
+SHORT cId;               /* holds call id */
+TRACE_FUNCTION("chld_Ccbs");
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/*
+*---------------------------------------------------------------
+* find the call with CCBS possible
+*---------------------------------------------------------------
+*/
+for( cId = 0; cId < MAX_CALL_NR; cId++ )
+{
+if (ccShrdPrm.ctb[cId] NEQ NULL AND
+psaCC_ctb(cId)->calStat  EQ CS_DSC_REQ AND
+psaCC_ctb(cId)->calType  EQ CT_MOC     AND
+psaCC_ctb(cId)->CCBSstat EQ CCBSS_PSSBL)
+{
+dscId = cId;
+break;
+}
+}
+if( dscId >= 0 AND
+psaCC_ctb(dscId)->curCmd NEQ AT_CMD_NONE )
+return( AT_BUSY );
+/*
+*---------------------------------------------------------------
+* clear a call with CCBS possible
+*---------------------------------------------------------------
+*/
+/*lint -e{661} cId causes out of bounds access, it does not! */
+if( dscId >= 0 )
+{
+pCCCmdPrm -> CHLDmode = CHLD_MOD_Ccbs;
+CHLDaddInfo           = NO_CHLD_ADD_INFO;
+psaCC_ctb(cId)->CCBSstat = CCBSS_REQ;
+cmhCC_ClearCall ( dscId, MNCC_CAUSE_CALL_CLEAR, srcId, AT_CMD_CHLD, NULL );
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, NULL, CHLD_ACT_CCBS, dscId, AT_EXCT );
+return( AT_EXCT );
+}
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+return( AT_FAIL );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : chld_OnlyHold            |
++--------------------------------------------------------------------+
+PURPOSE : Put a call on hold (and nothing else ==> do not accept
+any other call)
+*/
+LOCAL T_ACI_RETURN chld_OnlyHold(T_ACI_CMD_SRC srcId)
+{
+SHORT hldId;              /* holds call hold id */
+SHORT cId;                /* holds call id */
+T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
+BOOL  hldCalFlg  = FALSE; /* flags a held call */
+BOOL  mptyHldFlg = FALSE; /* flags a multiparty held call */
+TRACE_FUNCTION("chld_OnlyHold");
+/* find held call */
+hldId = -1;
+for( cId = 0; cId < MAX_CALL_NR; cId++ )
+{
+if (ccShrdPrm.ctb[cId] NEQ NULL)
+{
+if( psaCC_ctb(cId)->calStat EQ CS_HLD )
+{
+if( hldId EQ -1 ) hldId = cId;
+}
+}
+}
+if( hldId >=0 )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_OneCallOnHold );
+return( AT_FAIL );    /* only one call could be on hold */
+}
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/* put all active calls on hold */
+/* Implements Measure 181 and 182 */
+if ( chld_HoldActiveCalls( srcId, &mptyHldFlg, &hldCalFlg, &cId ) EQ FALSE )
+{
+return( AT_FAIL ); /* no data calls supported */
+}
+/* at least one call was put on hold */
+if( hldCalFlg )
+{
+pCCCmdPrm -> CHLDmode = CHLD_MOD_OnlyHold;
+CHLDaddInfo           = NO_CHLD_ADD_INFO;
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode,
+NULL,
+(mptyHldFlg)? CHLD_ACT_HoldMpty:CHLD_ACT_Hold,
+cId, AT_EXCT );
+return( AT_EXCT );
+}
+return( AT_FAIL );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : chld_RelDialCall         |
++--------------------------------------------------------------------+
+PURPOSE : release diealling call (special function for FAE's
+*/
+LOCAL T_ACI_RETURN chld_RelDialCall(T_ACI_CMD_SRC srcId)
+{
+T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
+SHORT        cId;
+TRACE_FUNCTION("chld_RelDialCall");
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/*
+*---------------------------------------------------------------
+* clear the dialling call
+*---------------------------------------------------------------
+*/
+pCCCmdPrm -> mltyCncFlg = 0;
+pCCCmdPrm -> mltyDscFlg = 0;
+cId = psaCC_ctbFindCall( (T_OWN)srcId, CS_ACT_REQ, CT_MOC );
+TRACE_EVENT_P1("Call Id of dialling call = %d",cId);
+if( cId >= 0 )
+{
+pCCCmdPrm -> CHLDmode = CHLD_MOD_RelDialCall;
+CHLDaddInfo           = NO_CHLD_ADD_INFO;
+cmhCC_ClearCall(cId, MNCC_CAUSE_CALL_CLEAR, srcId, AT_CMD_CHLD, NULL);
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm -> CHLDmode, NULL, CHLD_ACT_Release, cId, AT_EXCT );
+return( AT_EXCT );
+}
+/* Unable to find call */
+return( AT_FAIL);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : chld_RetrieveHoldCall    |
++--------------------------------------------------------------------+
+PURPOSE : retrieve an held call (and nothing else)
+- waiting call's still knocked on
+- will hold active call
+*/
+LOCAL T_ACI_RETURN chld_RetrieveHoldCall(T_ACI_CMD_SRC srcId)
+{
+T_CC_CMD_PRM  *pCCCmdPrm;          /* points to CC command parameters */
+SHORT          cId;                /* call id */
+SHORT          cwaId      = -1;    /* holds call waiting id */
+SHORT          hldId      = -1;    /* holds call hold id */
+SHORT          rclId      = -1;    /* holds recall id */
+BOOL           mptyHldFlg = FALSE; /* flags a multiparty held call */
+BOOL           hldCalFlg  = FALSE; /* flags a held call */
+T_ACI_CHLD_ACT chldact;            /* contains the type of CHLD activity when informing MFW */
+TRACE_FUNCTION("chld_RetrieveHoldCall");
+/* find the waiting or held call */
+if( find_waiting_held_call(&cwaId, &hldId, &rclId) EQ AT_BUSY)
+{
+return(AT_BUSY);
+}
+if( hldId < 0 )
+{ /* no held call found */
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_CallNotFound );
+return( AT_FAIL );
+}
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm; /* temp copy */
+/*
+*---------------------------------------------------------------
+* put all active calls on hold
+*---------------------------------------------------------------
+*/
+/* Implements Measure 181 and 182 */
+if ( chld_HoldActiveCalls( srcId, &mptyHldFlg, &hldCalFlg, &cId ) EQ FALSE )
+{
+return( AT_FAIL ); /* no data calls supported */
+}
+/* maybe, one or more calls were put on hold */
+if( hldCalFlg )
+{
+pCCCmdPrm -> CHLDmode = CHLD_MOD_HldActAndAcpt;
+CHLDaddInfo           = NO_CHLD_ADD_INFO;
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode,
+NULL,
+(mptyHldFlg)? CHLD_ACT_HoldMpty:CHLD_ACT_Hold,
+cId, AT_EXCT );
+}
+/*
+*---------------------------------------------------------------
+* retrieve the held call
+*---------------------------------------------------------------
+*/
+cmhCC_flagCall(hldId, &(pCCCmdPrm -> mltyCncFlg));
+pCCCmdPrm -> CHLDmode = CHLD_MOD_RetrieveHoldCall;
+cmhCC_RetrieveCall(hldId, srcId);
+/* inform MFW */
+chldact = (psaCC_ctb(hldId)->mptyStat EQ CS_ACT)? CHLD_ACT_RetrieveMpty :CHLD_ACT_Retrieve;
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, NULL, chldact, hldId, AT_EXCT );
+return( AT_EXCT );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : chld_RetrieveHoldCallSpec|
++--------------------------------------------------------------------+
+PURPOSE : retrieve specific held call (and nothing else)
+- release waiting call
+- will hold active call
+*/
+LOCAL T_ACI_RETURN chld_RetrieveHoldCallSpec(T_ACI_CMD_SRC srcId, CHAR *call)
+{
+T_CC_CMD_PRM  *pCCCmdPrm;          /* points to CC command parameters */
+SHORT          cId;                /* call id */
+SHORT          temp_cId;
+BOOL           mptyHldFlg = FALSE; /* flags a multiparty held call */
+BOOL           hldCalFlg  = FALSE; /* flags a held call */
+T_ACI_CHLD_ACT chldact;            /* contains the type of CHLD activity when informing MFW */
+TRACE_FUNCTION("chld_RetrieveHoldCallSpec");
+if( call EQ NULL )
+{
+TRACE_ERROR("CALL parameter is needed !!!");
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );  /* no call specified */
+}
+cId = atoi( call ); /* char --> int */
+if( (cId EQ 0) OR (cId > MAX_CALL_NR) )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+cId--; /* adapt to call table index */
+pCCCmdPrm  = &cmhPrm[srcId].ccCmdPrm;
+/* test whether specified call is a held call */
+if ((ccShrdPrm.ctb[cId] EQ NULL)                  OR
+(psaCC_ctb(cId)->calStat NEQ CS_HLD)      OR
+(psaCC_ctb(cId)->curCmd  NEQ AT_CMD_NONE) OR
+(cmhCC_getcalltype(cId) NEQ VOICE_CALL))
+{ /* no held call or no voice call --> error */
+pCCCmdPrm -> mltyCncFlg = 0;
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_CallTypeNoHold );
+return( AT_FAIL );    /* no data calls supported */
+}
+/*
+*---------------------------------------------------------------
+* put all active calls on hold
+*---------------------------------------------------------------
+*/
+pCCCmdPrm -> mltyCncFlg = 0;
+pCCCmdPrm -> mltyDscFlg = 0;
+for( temp_cId = 0; temp_cId < MAX_CALL_NR; temp_cId++ )
+{
+T_CC_CALL_TBL *pCallTable = ccShrdPrm.ctb[temp_cId];
+if( pCallTable NEQ NULL              AND
+pCallTable->calStat    EQ CS_ACT AND
+pCallTable->curCmd     EQ AT_CMD_NONE )
+{
+if( cmhCC_getcalltype(temp_cId) NEQ VOICE_CALL )
+{
+pCCCmdPrm -> mltyCncFlg = 0;
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_CallTypeNoHold );
+return( AT_FAIL );    /* no data calls supported */
+}
+if( (pCallTable->mptyStat EQ CS_IDL) OR
+((pCallTable->mptyStat EQ CS_ACT) AND (mptyHldFlg EQ FALSE)) )
+{
+hldCalFlg = TRUE;
+}
+/* if active call is a multiparty call */
+if( pCallTable->mptyStat EQ CS_ACT )
+{
+mptyHldFlg = TRUE;
+}
+cmhCC_HoldCall(temp_cId, srcId, AT_CMD_CHLD);
+}
+}
+/* maybe, one or more calls were put on hold */
+if( hldCalFlg )
+{
+pCCCmdPrm->CHLDmode = CHLD_MOD_HldActAndAcpt;
+CHLDaddInfo = NO_CHLD_ADD_INFO;
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode,
+NULL,
+(mptyHldFlg)? CHLD_ACT_HoldMpty:CHLD_ACT_Hold,
+cId, AT_EXCT );
+}
+/*
+*---------------------------------------------------------------
+* retrieve the held call
+*---------------------------------------------------------------
+*/
+cmhCC_flagCall(cId, &(pCCCmdPrm -> mltyCncFlg));
+pCCCmdPrm -> CHLDmode = CHLD_MOD_RetrieveHoldCallSpec;
+cmhCC_RetrieveCall(cId, srcId);
+/* inform MFW */
+if (psaCC_ctb(cId)->mptyStat EQ CS_ACT)
+chldact = CHLD_ACT_RetrieveMpty;
+else
+chldact = CHLD_ACT_Retrieve;
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, NULL, chldact, cId, AT_EXCT );
+return( AT_EXCT );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PlusCHLD             |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the +CHLD AT command
+which is responsible to handle the supplementary services
+witin a call
+*/
+GLOBAL T_ACI_RETURN sAT_PlusCHLD  ( T_ACI_CMD_SRC    srcId,
+T_ACI_CHLD_MOD   mode,
+CHAR            *call)
+{
+TRACE_FUNCTION ("sAT_PlusCHLD()");
+if( mode > CHLD_MOD_RelDialCall )
+{ /* not allowed modes inside '+'-command */
+TRACE_EVENT("this mode is not allowed for sAT_PlusCHLD()");
+return( AT_FAIL );
+}
+else
+{
+return( cmhCC_CHLD_Serv(srcId, mode, call) );
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PercentCHLD          |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the %CHLD AT command
+which is responsible to handle the supplementary services
+witin a call
+*/
+GLOBAL T_ACI_RETURN sAT_PercentCHLD  ( T_ACI_CMD_SRC    srcId,
+T_ACI_CHLD_MOD   mode,
+CHAR            *call)
+{
+TRACE_FUNCTION ("sAT_PercentCHLD()");
+return( cmhCC_CHLD_Serv(srcId, mode, call) );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PlusCCUG             |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the +CCUG AT command
+which is responsible to set the parameters for closed user
+group supplementary services.
+<mode>   : CUG mode.
+<index>  : CUG index.
+<info>   : CUG info.
+*/
+GLOBAL T_ACI_RETURN sAT_PlusCCUG  ( T_ACI_CMD_SRC   srcId,
+T_ACI_CCUG_MOD  mode,
+T_ACI_CCUG_IDX  index,
+T_ACI_CCUG_INFO info)
+{
+T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
+TRACE_FUNCTION ("sAT_PlusCCUG()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/*
+*-------------------------------------------------------------------
+* process the mode parameter
+*-------------------------------------------------------------------
+*/
+switch( mode )
+{
+case( CCUG_MOD_NotPresent ):
+mode = pCCCmdPrm -> CCUGmode;
+break;
+case( CCUG_MOD_DisableTmp ):
+case( CCUG_MOD_EnableTmp  ):
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+/*
+*-------------------------------------------------------------------
+* process the index parameter
+*-------------------------------------------------------------------
+*/
+switch( index )
+{
+case( CCUG_IDX_NotPresent ):
+index = pCCCmdPrm -> CCUGidx;
+break;
+case( CCUG_IDX_0  ):
+case( CCUG_IDX_1  ):
+case( CCUG_IDX_2  ):
+case( CCUG_IDX_3  ):
+case( CCUG_IDX_4  ):
+case( CCUG_IDX_5  ):
+case( CCUG_IDX_6  ):
+case( CCUG_IDX_7  ):
+case( CCUG_IDX_8  ):
+case( CCUG_IDX_9  ):
+case( CCUG_IDX_No ):
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+/*
+*-------------------------------------------------------------------
+* process the info parameter
+*-------------------------------------------------------------------
+*/
+switch( info )
+{
+case( CCUG_INFO_NotPresent ):
+info = pCCCmdPrm -> CCUGinfo;
+break;
+case( CCUG_INFO_No          ):
+case( CCUG_INFO_SuppOa      ):
+case( CCUG_INFO_SuppPrefCug ):
+case( CCUG_INFO_SuppBoth    ):
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+/*
+*-------------------------------------------------------------------
+* assign the parameters
+*-------------------------------------------------------------------
+*/
+pCCCmdPrm -> CCUGmode = mode;
+pCCCmdPrm -> CCUGidx  = index;
+pCCCmdPrm -> CCUGinfo = info;
+return( AT_CMPL );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PlusVTS              |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the +VTS AT command
+which is responsible to send DTMF tones.
+*/
+GLOBAL T_ACI_RETURN sAT_PlusVTS   ( T_ACI_CMD_SRC    srcId,
+CHAR             dtmf,
+T_ACI_VTS_MOD    mode )
+{
+SHORT        cId;                 /* holds call id */
+BOOL         param_ok;
+TRACE_FUNCTION ("sAT_PlusVTS()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+cId = cmhCC_find_call_for_DTMF( );
+if (cId EQ NO_ENTRY)
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+return( AT_FAIL );
+}
+/* allow to send DTMF tone one after another quickly
+if( psaCC_ctb(cId)->dtmfCmd NEQ AT_CMD_NONE )
+return( AT_BUSY );*/
+/* if DTMF are already being sent */
+if (( ccShrdPrm.dtmf.cnt AND mode NEQ VTS_MOD_ManStop ) OR
+( ccShrdPrm.dtmf.cur AND (mode NEQ VTS_MOD_ManStop)))
+{
+TRACE_EVENT("DTMF are already being sent !");
+return( AT_BUSY );
+}
+else if ( !ccShrdPrm.dtmf.cur AND mode EQ VTS_MOD_ManStop )
+{
+TRACE_EVENT("Cannot stop a DTMF tone that hasn't been started!");
+return( AT_FAIL );
+}
+else if ( ccShrdPrm.dtmf.cur AND (ccShrdPrm.dtmf.cur NEQ dtmf ))
+{
+TRACE_EVENT("Cannot stop a different DTMF tone than the one that is started!");
+return( AT_FAIL );
+}
+/* process mode parameter */
+switch( mode )
+{
+case( VTS_MOD_Auto ):
+psaCC_ctb(cId)->dtmfMode = MNCC_DTMF_MOD_AUTO;
+break;
+case( VTS_MOD_ManStart ):
+psaCC_ctb(cId)->dtmfMode = MNCC_DTMF_MOD_MAN_START;
+ccShrdPrm.dtmf.cur = dtmf;
+break;
+case( VTS_MOD_ManStop ):
+psaCC_ctb(cId)->dtmfMode = MNCC_DTMF_MOD_MAN_STOP;
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+return( AT_FAIL );
+}
+psaCC_ctb(cId)->dtmfCmd = AT_CMD_VTS; /* wait for confirmation */
+psaCC_ctb(cId)->dtmfSrc = (T_OWN)srcId;
+/* has to remember tone sent in case of an abort */
+ccShrdPrm.dtmf.cnt = 1;
+ccShrdPrm.dtmf.dig[0] = dtmf;
+ccShrdPrm.dtmf.cId = cId;
+param_ok = cmhCC_SendDTMFdig ( AT_CMD_VTS, cId, dtmf, psaCC_ctb(cId)->dtmfMode);
+if( param_ok )
+{
+return( AT_EXCT );
+}
+else
+{
+ccShrdPrm.dtmf.cnt = 0;
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PlusCSNS             |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the +CSNS AT command
+which is responsible to set the parameters for single
+numbering scheme.
+*/
+GLOBAL T_ACI_RETURN sAT_PlusCSNS  ( T_ACI_CMD_SRC    srcId,
+T_ACI_CSNS_MOD   mode)
+{
+TRACE_FUNCTION ("sAT_PlusCSNS()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+/*
+*-------------------------------------------------------------------
+* check parameter mode
+*-------------------------------------------------------------------
+*/
+switch( mode )
+{
+case( CSNS_MOD_NotPresent ):
+mode = CSNS_MOD_Voice;
+break;
+case( CSNS_MOD_Voice ):
+#ifdef FAX_AND_DATA
+case( CSNS_MOD_VAFVoice ):
+case( CSNS_MOD_Fax ):
+case( CSNS_MOD_VADVoice ):
+case( CSNS_MOD_Data ):
+case( CSNS_MOD_VAFFax ):
+case( CSNS_MOD_VADData ):
+case( CSNS_MOD_VFD ):
+#endif /* FAX_AND_DATA */
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+ccShrdPrm.snsMode = mode;
+psaCC_Config( );
+return( AT_CMPL );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_AndF                 |
++--------------------------------------------------------------------+
+PURPOSE : Reset all values to defaults.
+*/
+GLOBAL T_ACI_RETURN sAT_AndF      ( T_ACI_CMD_SRC srcId,
+SHORT         value)
+{
+TRACE_FUNCTION ("sAT_AndF()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+/*
+*-------------------------------------------------------------------
+* check parameter value
+*-------------------------------------------------------------------
+*/
+if( value NEQ 0 AND value NEQ ACI_NumParmNotPresent )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+/*
+*-------------------------------------------------------------------
+* reset value to defaults
+*-------------------------------------------------------------------
+*/
+cmh_Reset ( srcId, TRUE );
+return( AT_CMPL );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sGsmAT_Z                 |
++--------------------------------------------------------------------+
+PURPOSE : Reset all values to factory defaults in the GSM part of ACI.
+*/
+GLOBAL T_ACI_RETURN sGsmAT_Z ( T_ACI_CMD_SRC srcId )
+{
+SHORT cId;                  /* holds call id */
+SHORT waitId = NO_ENTRY;    /* holds call waiting id */
+T_CC_CMD_PRM * pCCCmdPrm;   /* points to CC command parameters */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+T_ACI_CLOG     cmdLog;      /* holds logging info */
+#endif
+TRACE_FUNCTION ("sGsmAT_Z()");
+/*
+*-------------------------------------------------------------------
+* command source is checked
+*-------------------------------------------------------------------
+*/
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/*
+*-------------------------------------------------------------------
+* prepare log command
+*-------------------------------------------------------------------
+*/
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.atCmd                = AT_CMD_Z;
+cmdLog.cmdType              = CLOG_TYPE_Set;
+cmdLog.retCode              = AT_EXCT;
+cmdLog.sId                  = ACI_NumParmNotPresent;
+cmdLog.cmdPrm.sH.srcId      = srcId;
+#endif  /* End of SMI Or defined MFW*/
+/*
+*-------------------------------------------------------------------
+* clear all calls except a waiting call
+*-------------------------------------------------------------------
+*/
+pCCCmdPrm -> mltyDscFlg = 0;
+for( cId = 0; cId < MAX_CALL_NR; cId++ )
+{
+/* Clear only calls in use ! */
+if (ccShrdPrm.ctb[cId] NEQ NULL)
+{
+cmhCC_ClearCall(cId,MNCC_CAUSE_CALL_CLEAR, srcId, AT_CMD_Z, &waitId);
+}
+}
+if( pCCCmdPrm -> mltyDscFlg )
+{
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( AT_EXCT );
+}
+/*
+*-------------------------------------------------------------------
+* disconnect a waiting call with user determined user busy
+*-------------------------------------------------------------------
+*/
+/* Implements Measure 165 */
+if ( waitId NEQ NO_ENTRY )
+{
+cmhCC_disconnect_waiting_call ( srcId, waitId, AT_CMD_Z,
+&(pCCCmdPrm -> mltyDscFlg) );
+return( AT_EXCT );
+}
+/*
+*-------------------------------------------------------------------
+*   reset value to default if no call is active
+*-------------------------------------------------------------------
+*/
+cmh_Reset ( srcId, TRUE );
+R_AT(RAT_Z, srcId)();
+return( AT_CMPL );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_Z                    |
++--------------------------------------------------------------------+
+PURPOSE : Reset all values to factory defaults.
+*/
+GLOBAL T_ACI_RETURN sAT_Z ( T_ACI_CMD_SRC srcId,
+SHORT         value)
+{
+TRACE_FUNCTION ("sAT_Z()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+/*
+*-------------------------------------------------------------------
+* check parameter value
+*-------------------------------------------------------------------
+*/
+if( value NEQ 0 AND value NEQ ACI_NumParmNotPresent )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+/*
+*-------------------------------------------------------------------
+*   clear all calls and reset all value to default
+*-------------------------------------------------------------------
+*/
+#if defined (GPRS) AND defined (DTI)
+return sGprsAT_Z ( srcId );
+#else
+return sGsmAT_Z ( srcId );
+#endif  /* GPRS */
+}
+#if defined (FAX_AND_DATA) AND defined (DTI)
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_O                    |
++--------------------------------------------------------------------+
+PURPOSE : Return to online mode
+*/
+GLOBAL T_ACI_RETURN sAT_O ( T_ACI_CMD_SRC srcId )
+{
+SHORT           cId;           /* holds call id */
+T_DTI_CONN_CB  *dti_conn_cb;
+T_DTI_ENTITY_ID entity_list[2];
+#ifdef FF_PSI
+T_ACI_DTI_PRC_PSI *src_infos_psi = NULL;
+#endif /* FF_PSI */
+TRACE_FUNCTION("sAT_O()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+/*
+*-------------------------------------------------------------------
+* find active call
+*-------------------------------------------------------------------
+*/
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_ACT, NO_VLD_CT );
+if( cId EQ NO_ENTRY )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_CallNotFound );
+return( AT_FAIL );
+}
+switch( cmhCC_getcalltype(cId) )
+{
+case( TRANS_CALL ):
+entity_list[0] = DTI_ENTITY_TRA;
+dti_conn_cb = TRA_connect_dti_cb;
+break;
+case( NON_TRANS_CALL ):
+entity_list[0] = DTI_ENTITY_L2R;
+dti_conn_cb = L2R_connect_dti_cb;
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+return( AT_FAIL );
+}
+if( psaCC_ctb(cId)->curCmd NEQ AT_CMD_NONE )
+return( AT_BUSY );
+R_AT( RAT_CONNECT, srcId )
+( AT_CMD_O, cmhCC_GetDataRate(&psaCC_ctb(cId)->
+BC[psaCC_ctb(cId)->curBC]),
+cId+1, FALSE );
+psaCC_ctb(cId)->curCmd = AT_CMD_O;
+psaCC_ctb(cId)->curSrc = srcId;
+if (IS_SRC_BT(srcId))
+{
+entity_list[1] = DTI_ENTITY_BLUETOOTH;
+dti_cntrl_est_dpath((UBYTE)srcId, entity_list, 2, SPLIT, dti_conn_cb);
+}
+else
+{
+#ifdef FF_PSI
+src_infos_psi = find_element(psi_src_params,(UBYTE) srcId, cmhPSItest_srcId);
+memset(&psi_ato,0,sizeof(T_ACI_PSI_CALL_TYPE));
+if (src_infos_psi NEQ NULL)
+{
+psi_ato.src_id = (UBYTE)srcId;
+psi_ato.entity_to_conn = entity_list[0];
+psi_ato.num_entities = 1;
+psi_ato.mode = SPLIT;
+psi_ato.cb = dti_conn_cb;
+psi_ato.capability = DTI_CPBLTY_SER;
+psi_ato.cid = DTI_CID_NOTPRESENT;
+psi_ato.last_cmd = AT_CMD_O;
+}
+else
+{
+#endif /* FF_PSI */
+dti_cntrl_est_dpath_indirect ( (UBYTE)srcId,
+entity_list,
+1,
+SPLIT,
+dti_conn_cb,
+DTI_CPBLTY_SER,
+DTI_CID_NOTPRESENT);
+#ifdef FF_PSI
+}
+#endif /* FF_PSI */
+}
+return( AT_EXCT );
+}
+#endif
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                 |
+|                                 ROUTINE : sAT_PercentALS          |
++-------------------------------------------------------------------+
+PURPOSE : set the ALS mode for outgoing calls (voice)
+ALS_MOD_SPEECH:
+indicates bearer capability => BEARER_SERV_SPEECH
+ALS_MOD_AUX_SPEECH:
+indicates bearer capability => BEARER_SERV_AUX_SPEECH
+*/
+GLOBAL T_ACI_RETURN sAT_PercentALS( T_ACI_CMD_SRC srcId,
+T_ACI_ALS_MOD mode   )
+{
+TRACE_FUNCTION("sAT_PercentALS()");
+if( !cmh_IsVldCmdSrc( srcId ) )
+{
+return( AT_FAIL );
+}
+/* line will really change? */
+if (mode EQ cmhPrm[srcId].ccCmdPrm.ALSmode)
+{
+return (AT_CMPL);
+}
+if ( ALSlock NEQ ALS_MOD_NOTPRESENT )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+return( AT_FAIL );
+}
+if ( mode EQ ALS_MOD_SPEECH )
+{
+cmhPrm[srcId].ccCmdPrm.ALSmode = ALS_MOD_SPEECH;
+return( AT_CMPL );
+}
+else if ( mode EQ ALS_MOD_AUX_SPEECH )
+{
+/* E-Plus SIM-Card inserted (mcc=0x262, mnc=0x03) ? */
+if (cmhSIM_plmn_is_hplmn(0x262, 0x03F))
+{
+cmhPrm[srcId].ccCmdPrm.ALSmode = ALS_MOD_AUX_SPEECH;
+return( AT_CMPL );
+}
+else
+{
+simEntStat.curCmd = AT_CMD_ALS;
+simShrdPrm.owner = (T_OWN)srcId;
+simEntStat.entOwn = srcId;
+ccShrdPrm.als_cmd = ALS_CMD_SET;
+cmhCC_checkALS_Support();
+return (AT_EXCT);
+}
+}
+else
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+}
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                 |
+|                                 ROUTINE : sAT_PercentCTTY         |
++-------------------------------------------------------------------+
+PURPOSE : Handling TTY
+*/
+GLOBAL T_ACI_RETURN sAT_PercentCTTY (T_ACI_CMD_SRC srcId,
+T_ACI_CTTY_MOD mode,
+T_ACI_CTTY_REQ req)
+{
+#ifdef FF_TTY
+SHORT       cId;             /* holds call id */
+T_TTY_CMD   ttyAction = TTY_OFF;
+T_MNCC_bcpara   *bc;
+TRACE_FUNCTION("sAT_PercentCTTY()");
+if (!cmh_IsVldCmdSrc( srcId ))
+{
+return AT_FAIL;
+}
+/*
+* find if any call is active
+*/
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_ACT, NO_VLD_CT);
+if(cId NEQ NO_ENTRY )
+{
+T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
+TRACE_EVENT ("sAT_PercentCTTY() Active call found ");
+/*
+* if command state is not idle
+*/
+switch(ctb->curCmd)
+{
+case(AT_CMD_NONE):
+break;
+default:
+TRACE_EVENT_P1("CTTY: cId busy with %d", ctb->curCmd);
+return( AT_BUSY );
+}
+/*
+* Check if the active call is a TTY call
+*/
+bc = &ctb->BC[ctb->curBC];
+if (bc->bearer_serv EQ MNCC_BEARER_SERV_SPEECH_CTM OR
+bc->bearer_serv EQ MNCC_BEARER_SERV_AUX_SPEECH_CTM)
+{
+if ((mode EQ CTTY_MOD_Disable) OR (mode EQ CTTY_MOD_Enable))
+{
+cmhPrm[srcId].ccCmdPrm.CTTYmode = mode;
+}
+switch (req)
+{
+case CTTY_REQ_Off:
+/*
+* stop the running TTY, a normal voice call
+*/
+ccShrdPrm.ctmReq = MNCC_CTM_DISABLED;
+ccShrdPrm.ttyCmd = (UBYTE)TTY_OFF;
+cmhCC_TTY_Control (cId, TTY_STOP);
+return( AT_CMPL );
+case CTTY_REQ_On:
+ccShrdPrm.ctmReq = MNCC_CTM_ENABLED;
+ccShrdPrm.ttyCmd = (UBYTE)TTY_ALL;
+break;
+case CTTY_REQ_HCO:
+ccShrdPrm.ctmReq = MNCC_CTM_ENABLED;
+ccShrdPrm.ttyCmd = (UBYTE)TTY_HCO;
+break;
+case CTTY_REQ_VCO:
+ccShrdPrm.ctmReq = MNCC_CTM_ENABLED;
+ccShrdPrm.ttyCmd = (UBYTE)TTY_VCO;
+break;
+default:
+ACI_ERR_DESC (ACI_ERR_CLASS_Ext, EXT_ERR_Parameter);
+return AT_FAIL;
+}
+audio_dyn_set_tty (ttyAction = (T_TTY_CMD)ccShrdPrm.ttyCmd);
+/*
+* This is for the case when mode is changed from Voice to any other
+*/
+ccShrdPrm.ctmState = TTY_STATE_ACTIVE;
+cmhCC_notifyTTY (CTTY_NEG_Grant, cmhCC_getTTYtrx_state (ttyAction));
+return AT_CMPL;
+}
+else
+{
+/*
+* If the active call is a normal GSM call then its a wrong bearer cap
+*/
+TRACE_EVENT_P1 ("TTY wrong BCAP: %d", (int)bc->bearer_serv);
+return (AT_FAIL);
+}
+}
+else
+{
+/*
+* If no active call then its a static switching set the bearer cap
+*  for next and subsequent calls
+*/
+TRACE_EVENT ("sAT_PercentCTTY() No active call found ");
+if ((mode EQ CTTY_MOD_Disable) OR (mode EQ CTTY_MOD_Enable))
+{
+cmhPrm[srcId].ccCmdPrm.CTTYmode = mode;
+}
+switch (req)
+{
+case CTTY_REQ_Off:
+ccShrdPrm.ctmReq = MNCC_CTM_DISABLED;
+ccShrdPrm.ttyCmd = (UBYTE)TTY_OFF;
+psaCC_Config ();
+break;
+case CTTY_REQ_On:
+ccShrdPrm.ctmReq = MNCC_CTM_ENABLED;
+ccShrdPrm.ttyCmd = (UBYTE)TTY_ALL;
+psaCC_Config ();
+break;
+case CTTY_REQ_HCO:
+ccShrdPrm.ctmReq = MNCC_CTM_ENABLED;
+ccShrdPrm.ttyCmd = (UBYTE)TTY_HCO;
+psaCC_Config ();
+break;
+case CTTY_REQ_VCO:
+ccShrdPrm.ctmReq = MNCC_CTM_ENABLED;
+ccShrdPrm.ttyCmd = (UBYTE)TTY_VCO;
+psaCC_Config ();
+break;
+default:
+ACI_ERR_DESC (ACI_ERR_CLASS_Ext, EXT_ERR_Parameter);
+return AT_FAIL;
+}
+if (req EQ CTTY_REQ_Off)
+{
+if (ccShrdPrm.ctmState EQ TTY_STATE_IDLE)
+{
+ccShrdPrm.ctmState = TTY_STATE_NONE;
+}
+}
+else
+{
+if (ccShrdPrm.ctmState EQ TTY_STATE_NONE)
+{
+ccShrdPrm.ctmState = TTY_STATE_IDLE;
+}
+}
+return AT_CMPL;
+}
+#else
+ACI_ERR_DESC (ACI_ERR_CLASS_Cme, CME_ERR_OpNotSupp);
+return AT_FAIL;
+#endif  /* FF_TTY */
+}
+#ifdef DTI
+#if defined (FF_WAP) || defined (FF_GPF_TCPIP) || defined (FF_SAT_E)
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PercentWAP           |
++--------------------------------------------------------------------+
+PURPOSE : set next call as a WAP call / unsent WAP call
+*/
+GLOBAL T_ACI_RETURN sAT_PercentWAP ( T_ACI_CMD_SRC srcId , SHORT setflag )
+{
+TRACE_FUNCTION("sAT_PercentWAP()");
+switch (setflag)
+{
+case (0): /* unsent WAP call */
+/* End of processing of WAP entities              */
+/* WAP-dedicated variables shall be reinitialized */
+wapId     = NO_ENTRY;
+Wap_Call  = FALSE;
+wap_state = Wap_Not_Init;
+if ( wap_dti_id NEQ DTI_DTI_ID_NOTPRESENT )
+{
+dti_cntrl_erase_entry (wap_dti_id);
+wap_dti_id = DTI_DTI_ID_NOTPRESENT;
+}
+break;
+case (1): /* next call will be a WAP call */
+if (!Wap_Call)
+{
+Wap_Call = TRUE;
+#ifdef FF_PPP
+/* FST: not possible in the moment -> see #ifdef before function definition */
+/* reset is_PPP_CALL */
+pppShrdPrm.is_PPP_CALL = FALSE;
+#endif /* FF_PPP */
+}
+else
+{
+TRACE_EVENT("ERROR: a WAP Call is currently in progress");
+return AT_FAIL;
+}
+break;
+}
+return AT_CMPL;
+}
+#endif /* of WAP || FF_GPF_TCPIP || SAT E */
+#endif /* DTI */
+#if defined MFW AND defined TI_PS_FF_AT_P_CMD_MMITEST
+/* MMI TEST AT COMMAND */
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PercentMMITEST       |
++--------------------------------------------------------------------+
+PURPOSE : This command has been introduced in order to use the AT command interface for some MMI
+specific testing. It shoudnt be compiled without MMI.
+*/
+GLOBAL T_ACI_RETURN sAT_PercentMMITEST(T_ACI_CMD_SRC srcId, char *param)
+{
+TRACE_FUNCTION ("sAT_PercentMMITEST ()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+rAT_PercentMMITEST(param);
+return AT_CMPL;
+}  /* sAT_PercentMMITEST */
+#endif
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)               MODULE  : CMH_CCS            |
+| STATE   : code                        ROUTINE : rdlPrm_init        |
++--------------------------------------------------------------------+
+PURPOSE : initializing of redial parameter
+*/
+GLOBAL void rdlPrm_init(void)
+{
+TRACE_FUNCTION ("rdlPrm_init ()");
+#ifdef TI_PS_FF_AT_P_CMD_RDLB
+rdlPrm.rdlBlN =   NO_NOTIF_USER;
+#endif /* TI_PS_FF_AT_P_CMD_RDLB */
+rdlPrm.rdlcId =   NO_ENTRY;
+rdlPrm.rdlMod =   AUTOM_REPEAT_OFF;
+rdlPrm.rdlModN =  NO_NOTIF_USER;
+rdlPrm.rdlBlMod = BLMODE_NO_PRESENT;
+#if defined(_TARGET_)
+cmhCC_rd_mode_FFS(AUTOM_REP_NOT_PRESENT,READ_RDLmode); /* read redial mode from FFS */
+if(rdlPrm.rdlMod EQ AUTOM_REPEAT_ON)
+{
+#ifdef TI_PS_FF_AT_P_CMD_RDLB
+if(cc_blacklist_ptr EQ NULL)
+{
+ACI_MALLOC(cc_blacklist_ptr,sizeof(T_ACI_CC_REDIAL_BLACKL));
+memset(cc_blacklist_ptr, 0 , sizeof(T_ACI_CC_REDIAL_BLACKL));
+}
+#endif /* TI_PS_FF_AT_P_CMD_RDLB */
+}
+#endif /* _TARGET_ */
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)               MODULE  : CMH_CCS            |
+| STATE   : code                        ROUTINE : rdlPrm_exit        |
++--------------------------------------------------------------------+
+PURPOSE :
+*/
+GLOBAL void rdlPrm_exit(void)
+{
+TRACE_FUNCTION ("rdlPrm_exit ()");
+#ifdef TI_PS_FF_AT_P_CMD_RDLB
+rdlPrm.rdlBlN =   NO_NOTIF_USER;
+#endif /* TI_PS_FF_AT_P_CMD_RDLB */
+rdlPrm.rdlcId =   NO_ENTRY;
+rdlPrm.rdlMod =   AUTOM_REP_NOT_PRESENT;
+rdlPrm.rdlModN =  NO_NOTIF_USER;
+rdlPrm.rdlBlMod = BLMODE_NO_PRESENT;
+#ifdef TI_PS_FF_AT_P_CMD_RDLB
+if(cc_blacklist_ptr NEQ NULL)
+{
+ACI_MFREE(cc_blacklist_ptr);
+}
+#endif /* TI_PS_FF_AT_P_CMD_RDLB */
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)               MODULE  : CMH_CCS            |
+| STATE   : code                        ROUTINE : sAT_PercentRDL  |
++--------------------------------------------------------------------+
+PURPOSE : This command has been introduced in order to set the
+redial mode and notification state referring to outgoing
+calls on ON/OFF
+*/
+GLOBAL T_ACI_RETURN sAT_PercentRDL(T_ACI_CMD_SRC srcId,
+T_ACI_CC_REDIAL_MODE redial_mode,
+T_ACI_CC_REDIAL_NOTIF notification)
+{
+int i;
+TRACE_FUNCTION ("sAT_PercentRDL ()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+if(redial_mode EQ AUTOM_REP_NOT_PRESENT)
+{
+redial_mode = rdlPrm.rdlMod;
+}
+switch(notification)
+{
+case NOTIF_NO_PRESENT:
+notification = rdlPrm.rdlModN;
+break;
+case NOTIF_USER:
+case NO_NOTIF_USER:
+rdlPrm.rdlModN = notification;
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+switch(redial_mode)
+{
+case AUTOM_REPEAT_OFF:
+#if defined(_TARGET_)
+/* store redial mode in FFS */
+cmhCC_rd_mode_FFS(redial_mode,WRITE_RDLmode);
+#endif /* _TARGET_ */
+/* stop redialling timer if necessary */
+if (rdlPrm.rdlcId NEQ NO_ENTRY)
+{
+TIMERSTOP(ACI_REPEAT_HND);
+#ifdef SIM_TOOLKIT
+if( ( ccShrdPrm.ctb[rdlPrm.rdlcId]->SATinv & SAT_REDIAL ) )
+{ /* This is the call invoked by SAT */
+T_ACI_SAT_TERM_RESP resp_data;
+psaSAT_InitTrmResp( &resp_data );
+psaSAT_SendTrmResp( RSLT_USR_CLR_DWN, &resp_data );
+}
+if(satShrdPrm.dur)
+{
+TIMERSTOP(ACI_SAT_MAX_DUR_HND);
+satShrdPrm.dur  = -1;
+}
+#endif /* SIM_TOOLKIT */
+if(rdlPrm.rdlcId NEQ -1)
+{/* clear call id entry in call table if marked as used */
+psaCC_FreeCtbNtry (rdlPrm.rdlcId);
+for(i = 0; i < CMD_SRC_MAX; i++)
+{
+R_AT(RAT_RDL, (T_ACI_CMD_SRC)i)(REDIAL_STOP);
+}
+}
+}
+/* reset redial parameter */
+rdlPrm_init();
+return AT_CMPL;
+case AUTOM_REPEAT_ON:
+rdlPrm.rdlMod = redial_mode;
+#if defined(_TARGET_)
+/* store redial mode in FFS */
+cmhCC_rd_mode_FFS(redial_mode,WRITE_RDLmode);
+#endif /* _TARGET_ */
+#ifdef TI_PS_FF_AT_P_CMD_RDLB
+/* allocate blacklist for phone numbers forbidden to call */
+if(cc_blacklist_ptr EQ NULL)
+{
+/* Check if we have enough RAM for the following ACI_MALLOC */
+USHORT free, alloc;
+int ret;
+ret = vsi_m_status ( hCommACI,
+sizeof(T_ACI_CC_REDIAL_BLACKL),
+PRIM_POOL_PARTITION,
+&free,
+&alloc );
+if (ret EQ VSI_ERROR || free EQ 0)
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_MemFull);
+return (AT_FAIL);
+}
+ACI_MALLOC(cc_blacklist_ptr,sizeof(T_ACI_CC_REDIAL_BLACKL));
+memset(cc_blacklist_ptr, 0 , sizeof(T_ACI_CC_REDIAL_BLACKL));
+}
+#endif /* TI_PS_FF_AT_P_CMD_RDLB */
+return AT_CMPL;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+}
+#ifdef TI_PS_FF_AT_P_CMD_RDLB
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)             MODULE  : CMH_CCS              |
+| STATE   : code                      ROUTINE : sAT_PercentRDLB  |
++--------------------------------------------------------------------+
+PURPOSE : This command has been introduced in order to delete the
+black list entries  (forbidden outgoing phone numbers)
+*/
+GLOBAL T_ACI_RETURN sAT_PercentRDLB(T_ACI_CMD_SRC srcId,
+T_ACI_CC_REDIAL_BLMODE blacklist_mode,
+T_ACI_CC_REDIAL_NOTIF notification)
+{
+TRACE_FUNCTION ("sAT_PercentRDLB ()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+if(rdlPrm.rdlMod EQ AUTOM_REPEAT_ON)
+{
+switch(blacklist_mode)
+{
+case BLMODE_NO_PRESENT:
+rdlPrm.rdlBlMod = BL_NO_DELETE; /* if no parameter is given the black list is not deleted */
+break;
+case BL_NO_DELETE:
+case BL_DELETE:
+/* store black list mode */
+rdlPrm.rdlBlMod = blacklist_mode;
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+/* store black list notification mode */
+switch(notification)
+{
+case NOTIF_NO_PRESENT:
+notification = rdlPrm.rdlBlN;
+break;
+case NOTIF_USER:
+case NO_NOTIF_USER:
+rdlPrm.rdlBlN = notification;
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+/* reset black list entries */
+if(rdlPrm.rdlBlMod EQ BL_DELETE)
+{
+cc_blacklist_ptr->blCount = 0;
+}
+return AT_CMPL;
+}
+else
+{/* redial mode switched OFF */
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+}
+#endif /* TI_PS_FF_AT_P_CMD_RDLB */
+#ifdef TI_PS_FF_AT_P_CMD_CUSCFG
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCQ                  |
+| STATE   : code                  ROUTINE : sAT_PercentCUSCFG          |
++--------------------------------------------------------------------+
+PURPOSE : This is the functional counterpart to the AT%CUSCFG set command
+which sets the customization state of the facility specified.
+*/
+GLOBAL T_ACI_RETURN sAT_PercentCUSCFG(T_ACI_CMD_SRC srcId,
+T_ACI_CUSCFG_FAC facility,
+T_ACI_CUSCFG_MOD mode,
+CHAR  *        value)
+{
+TRACE_FUNCTION ("sAT_PercentCUSCFG ()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+return( AT_FAIL );
+}
+switch(facility)
+{
+case CUSCFG_FAC_MO_SM_Control:
+cuscfgParams.MO_SM_Control_SIM = mode;
+break;
+case CUSCFG_FAC_MO_Call_Control:
+cuscfgParams.MO_Call_Control_SIM = mode;
+break;
+case CUSCFG_FAC_MO_SS_Control:
+cuscfgParams.MO_SS_Control_SIM = mode;
+break;
+case CUSCFG_FAC_MO_USSD_Control:
+cuscfgParams.MO_USSD_Control_SIM = mode;
+break;
+case CUSCFG_FAC_2_Digit_Call:
+cuscfgParams.Two_digit_MO_Call = mode;
+break;
+case CUSCFG_FAC_Ext_USSD_Res:
+cuscfgParams.Ext_USSD_Response = mode;
+break;
+case CUSCFG_FAC_T_MOBILE_Eons:
+cuscfgParams.T_MOBILE_Eons  = mode;
+break;
+case CUSCFG_FAC_USSD_As_MO_Call:
+cuscfgParams.USSD_As_MO_Call = mode;
+break;
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+return(AT_CMPL);
+}
+#endif /* TI_PS_FF_AT_P_CMD_CUSCFG */
+/* Implements Measure 80 */
+/*
++------------------------------------------------------------------------------
+|  Function    : cmhCC_check_RedialCall
++------------------------------------------------------------------------------
+|  Purpose     : Checks for a Redial Call.
+|
+|  Parameters  : at_cmd_id - AT Command Identifier.
+|                            (AT_CMD_H OR AT_CMD_CHUP)
+|
+|  Return      : BOOL
++------------------------------------------------------------------------------
+*/
+LOCAL BOOL cmhCC_check_RedialCall( T_ACI_AT_CMD at_cmd_id )
+{
+SHORT cId;
+int i;
+TRACE_FUNCTION ("cmhCC_check_RedialCall()");
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_ACT_REQ, CT_MOC_RDL);
+if( cId NEQ NO_ENTRY )
+{
+#ifdef SIM_TOOLKIT
+if( ( ccShrdPrm.ctb[cId]->SATinv & SAT_REDIAL ) )
+{ /* This is the call invoked by SAT */
+T_ACI_SAT_TERM_RESP resp_data;
+psaSAT_InitTrmResp( &resp_data );
+psaSAT_SendTrmResp( RSLT_USR_CLR_DWN, &resp_data );
+}
+#endif /* SIM_TOOLKIT */
+ccShrdPrm.ctb[cId]->calType = CT_MOC;
+if(rdlPrm.rdlMod EQ AUTOM_REPEAT_ON)
+{
+for(i = 0; i < CMD_SRC_MAX; i++)
+{
+R_AT(RAT_RDL, (T_ACI_CMD_SRC)i)(REDIAL_STOP);
+}
+rdlPrm.rdlcId = NO_ENTRY;
+}
+if (at_cmd_id EQ AT_CMD_H)
+{
+ccShrdPrm.ctb[cId]->nrmCs  = MNCC_CAUSE_CALL_CLEAR;
+psaCC_ClearCall (cId);
+psaCC_FreeCtbNtry (cId);
+return( TRUE );
+}
+}
+else
+{/* redial timer is running */
+if ((rdlPrm.rdlMod EQ AUTOM_REPEAT_ON) AND (rdlPrm.rdlcId NEQ NO_ENTRY))
+{
+#ifdef SIM_TOOLKIT
+if( ( ccShrdPrm.ctb[rdlPrm.rdlcId]->SATinv & SAT_REDIAL ) )
+{ /* This is the call invoked by SAT */
+T_ACI_SAT_TERM_RESP resp_data;
+psaSAT_InitTrmResp( &resp_data );
+psaSAT_SendTrmResp( RSLT_USR_CLR_DWN, &resp_data );
+}
+/* Stop the SAT maximum duration timer */
+if(satShrdPrm.dur)
+{
+TIMERSTOP(ACI_SAT_MAX_DUR_HND);
+satShrdPrm.dur  = -1;
+}
+#endif /* SIM_TOOLKIT */
+/* clear call id entry in call table if marked as used */
+psaCC_FreeCtbNtry (rdlPrm.rdlcId);
+for(i = 0; i < CMD_SRC_MAX; i++)
+{
+R_AT(RAT_RDL, (T_ACI_CMD_SRC)i)(REDIAL_STOP);
+}
+/* reset some redial parameter */
+rdlPrm.rdlcId =   NO_ENTRY;
+return( TRUE );
+}
+}
+return( FALSE );
+}
+/*
++------------------------------------------------------------------------------
+|  Function    : cmhCC_check_pending_satCall()
++------------------------------------------------------------------------------
+|  Purpose     : Checks for a Redial Call.
+|
+|  Parameters  : None
+|
+|  Return      : BOOL
++------------------------------------------------------------------------------
+*/
+LOCAL BOOL cmhCC_check_pending_satCall( )
+{
+SHORT cId;                  /* holds call id */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+T_ACI_CLOG     cmdLog;      /* holds logging info */
+#endif
+/* triggered by SETUP CALL command */
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_SAT_REQ, NO_VLD_CT );
+#ifdef FF_SAT_E
+if( cId EQ NO_ENTRY )
+{
+/* triggered by OPEN CHANNEL command */
+cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_SAT_CSD_REQ, NO_VLD_CT );
+}
+#endif
+if( cId NEQ NO_ENTRY )
+{
+if( ( ccShrdPrm.ctb[cId]->SATinv & SAT_REDIAL ) )
+{ /* This is the call invoked by SAT */
+T_ACI_SAT_TERM_RESP resp_data;
+psaSAT_InitTrmResp( &resp_data );
+psaSAT_SendTrmResp( RSLT_USR_CLR_DWN, &resp_data );
+}
+if( psaCC_ctb(cId)->SATinv )
+cmhSAT_UserRejCall(psaCC_ctb(cId)->calStat);
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+cmdLog.retCode = AT_CMPL;
+rAT_PercentCLOG( &cmdLog );
+#endif
+psaCC_FreeCtbNtry (cId);
+return( TRUE );
+}
+#if defined (GPRS) AND defined (FF_SAT_E) AND defined (DTI)
+/* check for pending SAT GPRS context */
+else
+{
+if( cmhSAT_OpChnGPRSPend(PDP_CONTEXT_CID_INVALID, OPCH_WAIT_CNF))
+{
+cmhSAT_UserRejCntxt();
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = cId+1;
+cmdLog.retCode = AT_CMPL;
+rAT_PercentCLOG( &cmdLog );
+#endif
+return( TRUE );
+}
+}
+#endif  /* GPRS AND FF_SAT_E */
+psaCC_FreeCtbNtry (cId);
+return( FALSE );
+}
+/* Implements Measure 181 and 182 */
+/*
++------------------------------------------------------------------------------
+|  Function    : chld_HoldActiveCalls
++------------------------------------------------------------------------------
+|  Purpose     : Puts All Active Calls on Hold.
+|
+|  Parameters  : srcId - AT command source identifier.
+|                mptyHldFlg - Points to a Flag that Helds a Call
+|                hldCalFlg  - Points to a Flag that Helds a MultiParty Call
+|                cId       - context Id
+|
+|  Return      : BOOL
++------------------------------------------------------------------------------
+*/
+LOCAL BOOL chld_HoldActiveCalls( T_ACI_CMD_SRC srcId,
+BOOL *mptyHldFlg, BOOL *hldCalFlg, SHORT *cId)
+{
+T_CC_CMD_PRM *pCCCmdPrm;
+TRACE_FUNCTION("chld_HoldActiveCalls()");
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+pCCCmdPrm -> mltyCncFlg = 0;
+pCCCmdPrm -> mltyDscFlg = 0;
+for( *cId = 0; *cId < MAX_CALL_NR; (*cId)++ )
+{
+if (ccShrdPrm.ctb[*cId] NEQ NULL AND
+ccShrdPrm.ctb[*cId]->calStat    EQ CS_ACT AND
+ccShrdPrm.ctb[*cId]->curCmd     EQ AT_CMD_NONE)
+{
+if( cmhCC_getcalltype(*cId) NEQ VOICE_CALL )
+{
+pCCCmdPrm -> mltyCncFlg = 0;
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_CallTypeNoHold );
+return( FALSE ); /* no data calls supported */
+}
+if( (ccShrdPrm.ctb[*cId]->mptyStat EQ CS_IDL) OR
+((ccShrdPrm.ctb[*cId]->mptyStat EQ CS_ACT) AND ((*mptyHldFlg) EQ FALSE)))
+{
+*hldCalFlg = TRUE;
+}
+/* if active call is a multiparty call */
+if( ccShrdPrm.ctb[*cId]->mptyStat EQ CS_ACT )
+{
+*mptyHldFlg = TRUE;
+}
+cmhCC_HoldCall(*cId, srcId, AT_CMD_CHLD);
+}
+}
+return( TRUE );
+}
+/* Implements Measure 117 */
+/*
++------------------------------------------------------------------------------
+|  Function    : chld_Rel_MultipartySpec
++------------------------------------------------------------------------------
+|  Purpose     : Releases a Specific Multi Party Calls
+|
+|  Parameters  : srcId - AT command source identifier.
+|                spcId - Holds specified call id.
+|                chld_mode - CHLD Command Mode.
+|                            (CHLD_MOD_RelAnySpec OR CHLD_MOD_RelActSpec)
+|                call
+|
+|  Return      : T_ACI_RETURN (ACI Functional Return Codes)
++------------------------------------------------------------------------------
+*/
+LOCAL T_ACI_RETURN chld_Rel_MultipartySpec( T_ACI_CMD_SRC srcId, SHORT *spcId,
+T_ACI_CHLD_MOD chld_mode,
+CHAR *call )
+{
+T_CC_CMD_PRM *pCCCmdPrm;
+SHORT cId;
+SHORT dscId = -1;
+TRACE_FUNCTION( "chld_Rel_MultypartySpec()" );
+pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
+/* get specific call id */
+if( call EQ NULL )
+{
+TRACE_ERROR("CALL parameter is needed !!!");
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );  /* no call specified */
+}
+*spcId = atoi( call );
+if( (*spcId) EQ 0 OR (*spcId) > MAX_CALL_NR )
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+(*spcId)--;  /* adapt to call table index */
+pCCCmdPrm -> mltyCncFlg = 0;
+pCCCmdPrm -> mltyDscFlg = 0;
+if( (*spcId) EQ -1 )
+{
+for( cId = 0; cId < MAX_CALL_NR; cId++ )
+{
+if (ccShrdPrm.ctb[cId] NEQ NULL AND
+psaCC_ctb(cId)->mptyStat   EQ CS_ACT AND
+psaCC_ctb(cId)->curCmd     EQ AT_CMD_NONE)
+{
+psaCC_StopDTMF (cId);
+cmhCC_ClearCall ( cId, MNCC_CAUSE_CALL_CLEAR, srcId, AT_CMD_CHLD, NULL );
+dscId = cId;
+}
+}
+if( dscId NEQ -1 )
+{
+pCCCmdPrm -> CHLDmode = chld_mode;
+CHLDaddInfo           = NO_CHLD_ADD_INFO;
+/* inform MFW */
+chld_ratlog( srcId, pCCCmdPrm->CHLDmode, call, CHLD_ACT_ReleaseMpty, dscId, AT_EXCT );
+return( AT_EXCT );
+}
+ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+return(AT_FAIL);
+}
+return(AT_CMPL);
+}
+/* Implements Measure 164 and 165 */
+/*
++------------------------------------------------------------------------------
+|  Function    : cmhCC_disconnect_waiting_call
++------------------------------------------------------------------------------
+|  Purpose     : Disconnect a waiting call with user determined user busy
+|
+|  Parameters  : waitId     - Holds call waiting id.
+|                at_cmd_id  - AT Command Identifier.
+|                             (AT_CMD_H/AT_CMD_CHUP/AT_CMD_Z)
+|                mltyDscFlg - Flag for MultiCall Operation
+|
+|  Return      : void
++------------------------------------------------------------------------------
+*/
+LOCAL void cmhCC_disconnect_waiting_call( T_ACI_CMD_SRC srcId,
+SHORT waitId,
+T_ACI_AT_CMD at_cmd_id,
+USHORT *mltyDscFlg )
+{
+UBYTE          idx;
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+T_ACI_CLOG     cmdLog;
+#endif
+TRACE_FUNCTION ("cmhCC_disconnect_waiting_call()");
+cmhCC_flagCall( waitId, mltyDscFlg );
+ccShrdPrm.ctb[waitId]->nrmCs  = MNCC_CAUSE_USER_BUSY;
+ccShrdPrm.ctb[waitId]->curCmd = at_cmd_id;
+ccShrdPrm.ctb[waitId]->curSrc = srcId;
+psaCC_ClearCall (waitId);
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+cmdLog.cId = waitId+1;
+rAT_PercentCLOG( &cmdLog );
+#endif
+#ifdef FF_ATI
+io_setRngInd (IO_RING_OFF, CRING_SERV_TYP_NotPresent, CRING_SERV_TYP_NotPresent ); /* V.24 Ring Indicator Line */
+#endif
+for( idx = 0; idx < CMD_SRC_MAX; idx++ )
+{
+R_AT( RAT_CRING_OFF, (T_ACI_CMD_SRC)idx )( waitId+1 );
+}
+}
+/* Implements Measure 64 */
+/*
++------------------------------------------------------------------------------
+|  Function    : cmhCC_CheckRedialTimer
++------------------------------------------------------------------------------
+|  Purpose     : Checks the Redial Timer and Stops it, if neccessary
+|
+|  Parameters  : sim_toolkit_enable
+|
+|  Return      : void
++------------------------------------------------------------------------------
+*/
+GLOBAL void cmhCC_CheckRedialTimer( BOOL sim_toolkit_enable )
+{
+int i;
+TRACE_FUNCTION ( "cmhCC_CheckRedialTimer()" );
+/* stop redialling timer if necessary */
+if (rdlPrm.rdlcId NEQ NO_ENTRY)
+{
+TIMERSTOP(ACI_REPEAT_HND);
+#ifdef SIM_TOOLKIT
+if( sim_toolkit_enable )
+{
+if( ( ccShrdPrm.ctb[rdlPrm.rdlcId]->SATinv & SAT_REDIAL ) )
+{ /* This is the call invoked by SAT */
+T_ACI_SAT_TERM_RESP resp_data;
+psaSAT_InitTrmResp( &resp_data );
+psaSAT_SendTrmResp( RSLT_USR_CLR_DWN, &resp_data );
+}
+/* Stop SAT maximum redial duration timer */
+if(satShrdPrm.dur)
+{
+TIMERSTOP(ACI_SAT_MAX_DUR_HND);
+satShrdPrm.dur  = -1;
+}
+}
+#endif /* SIM_TOOLKIT */
+psaCC_FreeCtbNtry (rdlPrm.rdlcId);
+for(i = 0; i < CMD_SRC_MAX; i++)
+{
+R_AT(RAT_RDL, (T_ACI_CMD_SRC)i)(REDIAL_STOP);
+}
+/* reset some redial parameter */
+rdlPrm.rdlcId =   NO_ENTRY;
+}
+}
+#ifdef TI_PS_FF_AT_CMD_P_ECC
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PercentECC           |
++--------------------------------------------------------------------+
+|  Description  : This is the functional counterpart to the AT%ECC
+|                 set command which sets additional ECC to local array
+|                  in ACI
+|  Parameters   : <srcId>     : Source Id
+|                 <index>     : Index
+|                 <ecc_numer> : ECC number to be stored
+|
+|  Return       : T_ACI_RETURN
++---------------------------------------------------------------------
+*/
+GLOBAL T_ACI_RETURN sAT_PercentECC( T_ACI_CMD_SRC srcId,
+U8 index,
+char *ecc_number)
+{
+TRACE_FUNCTION ("sAT_PercentECC ()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+/*
+*-------------------------------------------------------------------
+* check for valid index
+*-------------------------------------------------------------------
+*/
+if (index >= ADDITIONAL_ECC_NUMBER_MAX)
+{
+ACI_ERR_DESC(ACI_ERR_CLASS_Cme, CME_ERR_InvIdx);
+return( AT_FAIL );
+}
+/*
+*-------------------------------------------------------------------
+* check for valid length of ECC number
+*-------------------------------------------------------------------
+*/
+if ((!strlen(ecc_number)) OR (strlen(ecc_number) > ADDITIONAL_ECC_NUMBER_LENGTH))
+{
+ACI_ERR_DESC(ACI_ERR_CLASS_Cme, CME_ERR_TxtToLong);
+return( AT_FAIL );
+}
+strncpy(additional_ecc_numbers[index], ecc_number, strlen(ecc_number));
+return(AT_CMPL);
+}
+/*
++-----------------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                                 |
+| STATE   : code                  ROUTINE : cmhCC_additional_ecc_numbers_initialize |
++-----------------------------------------------------------------------------------+
+|  Description  : Initializes array which stores ECC numbers to default values
+|
+|  Parameters   : void
+|  Return       : void
++------------------------------------------------------------------------------------
+*/
+GLOBAL void cmhCC_additional_ecc_numbers_initialize(void)
+{
+TRACE_FUNCTION("cmhCC_additional_ecc_numbers_initialize()");
+//memset(additional_ecc_numbers, 0x00, ADDITIONAL_ECC_NUMBER_MAX*(ADDITIONAL_ECC_NUMBER_LENGTH));
+memset(additional_ecc_numbers, 0x00, ADDITIONAL_ECC_NUMBER_MAX*(ADDITIONAL_ECC_NUMBER_LENGTH+1)); //OMAPS00117704/OMAPS00117705
+}
+/*
++---------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                         |
+| STATE   : code                  ROUTINE : cmhCC_isNrInAdditionalECC       |
++---------------------------------------------------------------------------+
+|  Description  : Checks the passed number with additional ECC numbers
+|
+|  Parameters   : <number> : Dialed number
+|  Return       : BOOL
++----------------------------------------------------------------------------
+*/
+GLOBAL BOOL cmhCC_isNrInAdditionalECC(char *number)
+{
+U8 idx;
+TRACE_FUNCTION("cmhCC_isNrInAdditionalECC()");
+for (idx=0; idx < ADDITIONAL_ECC_NUMBER_MAX; idx++)
+{
+if (!strcmp(number, additional_ecc_numbers[idx]))
+{
+return (TRUE);
+}
+}
+return (FALSE);
+}
+#endif /* TI_PS_FF_AT_CMD_P_ECC */
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_CCS                  |
+| STATE   : code                  ROUTINE : sAT_PlusCVHU             |
++--------------------------------------------------------------------+
+PURPOSE : This is a set call for +CVHU for the control of the voice
+hangup
+*/
+GLOBAL T_ACI_RETURN sAT_PlusCVHU ( T_ACI_CMD_SRC srcId, T_ACI_CVHU_MODE mode)
+{
+TRACE_FUNCTION("sAT_PlusCVHU()");
+/*
+*-------------------------------------------------------------------
+* check command source
+*-------------------------------------------------------------------
+*/
+if(!cmh_IsVldCmdSrc (srcId))
+{
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+switch(mode)
+{
+case CVHU_DropDTR_IGNORED:
+case CVHU_DropDTR_ATH_IGNORED:
+case CVHU_DropDTR_Same_AndD:
+ccShrdPrm.cvhu = mode;
+return(AT_CMPL);
+default:
+ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+return( AT_FAIL );
+}
+}
+/*==== EOF ========================================================*/

FreeCalypso > hg > fc-selenite

comparison src/g23m-aci/aci/cmh_ccs.c @ 1:d393cd9bb723