line source
/*
+-----------------------------------------------------------------------------
| Project : GSM-PS (6147)
| Modul : CMH_CCQ
+-----------------------------------------------------------------------------
| 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 query functions related to the
| protocol stack adapter for mobility management.
+-----------------------------------------------------------------------------
*/
#ifndef CMH_CCQ_C
#define CMH_CCQ_C
#endif
#include "config.h"
#include "fixedconf.h"
#include "condat-features.h"
#include "aci_conf.h"
/*==== INCLUDES ===================================================*/
#include "aci_all.h"
#include "aci_cmh.h"
#ifdef FAX_AND_DATA
#include "aci_fd.h"
#endif /* of #ifdef FAX_AND_DATA */
#include "psa.h"
#include "psa_cc.h"
#include "cmh.h"
#include "cmh_cc.h"
#include "aoc.h"
#include "audio.h"
#include "dti_conn_mng.h"
#include "psa_sim.h"
#include "cmh_sim.h"
#include "psa_mm.h"
/*==== CONSTANTS ==================================================*/
#ifdef TI_PS_FF_AT_P_CMD_RDLB
EXTERN T_ACI_CC_REDIAL_BLACKL * cc_blacklist_ptr;
#endif /* TI_PS_FF_AT_P_CMD_RDLB */
const UBYTE aci_clcc_dir [5][2] = {
{ NO_VLD_CT, NO_VLD_CT },
{ CLCC_DIR_MOC, CLCC_DIR_MOC },
{ CLCC_DIR_MTC, CLCC_DIR_MTC },
{ CLCC_DIR_MOC, CLCC_DIR_MOC_NI },
{ CLCC_DIR_MOC, CLCC_DIR_MOC_RDL }
};
/*==== EXPORT =====================================================*/
/*==== VARIABLES ==================================================*/
#ifdef TI_PS_FF_AT_P_CMD_CUSCFG
EXTERN T_ACI_CUSCFG_PARAMS cuscfgParams;
#endif /* TI_PS_FF_AT_P_CMD_CUSCFG */
GLOBAL T_PCEER causeMod = P_CEER_mod; /* Hold which module caused the extended error */
GLOBAL SHORT causeCeer; /* Hold extended error for sim, mm and ss */
EXTERN UBYTE std;
/*==== FUNCTIONS ==================================================*/
LOCAL T_ACI_RETURN qAT_plus_percent_CLCC( T_ACI_CMD_SRC srcId,
T_ACI_CLCC_CALDESC *calLst,
T_ACI_AT_CMD at_cmd_id,
SHORT rdlcId );
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_PlusCSTA |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the +CSTA? AT command
which returns the current setting for type of address.
<toa>: type of address.
*/
GLOBAL T_ACI_RETURN qAT_PlusCSTA ( T_ACI_CMD_SRC srcId,
T_ACI_TOA * toa )
{
T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
TRACE_FUNCTION ("qAT_PlusCSTA()");
/*
*-------------------------------------------------------------------
* check command source
*-------------------------------------------------------------------
*/
if(!cmh_IsVldCmdSrc (srcId))
{
return( AT_FAIL );
}
pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
/*
*-------------------------------------------------------------------
* fill in parameters
*-------------------------------------------------------------------
*/
*toa = pCCCmdPrm -> CSTAtoa;
return( AT_CMPL );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_PlusCMOD |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the +CMOD? AT command
which returns the current setting for call mode.
<mode>: call mode.
*/
GLOBAL T_ACI_RETURN qAT_PlusCMOD ( T_ACI_CMD_SRC srcId,
T_ACI_CMOD_MOD* mode )
{
TRACE_FUNCTION ("qAT_PlusCMOD()");
/* check command source */
if(!cmh_IsVldCmdSrc (srcId))
{
return( AT_FAIL );
}
/* fill in parameters */
*mode = ccShrdPrm.CMODmode;
return( AT_CMPL );
}
#ifdef FAX_AND_DATA
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_PlusCBST |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the +CBST? AT command
which returns the current setting for bearer service type.
*/
GLOBAL T_ACI_RETURN qAT_PlusCBST ( T_ACI_CMD_SRC srcId,
T_ACI_BS_SPEED* speed,
T_ACI_CBST_NAM* name,
T_ACI_CBST_CE* ce)
{
TRACE_FUNCTION ("qAT_PlusCBST()");
/*
*-------------------------------------------------------------------
* check command source
*-------------------------------------------------------------------
*/
if(!cmh_IsVldCmdSrc (srcId))
{
return( AT_FAIL );
}
/*
*-------------------------------------------------------------------
* fill in parameters
*-------------------------------------------------------------------
*/
*speed = ccShrdPrm.CBSTspeed;
*name = ccShrdPrm.CBSTname;
*ce = ccShrdPrm.CBSTce;
return( AT_CMPL );
}
#endif /* FAX_AND_DATA */
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_PlusCCUG |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the +CCUG AT command
which is responsible to query the parameters for closed user
group supplementary services.
<mode> : CUG mode.
<index> : CUG index.
<info> : CUG info.
*/
GLOBAL T_ACI_RETURN qAT_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 SS command parameters */
TRACE_FUNCTION ("qAT_PlusCCUG()");
/*
*-------------------------------------------------------------------
* check command source
*-------------------------------------------------------------------
*/
if(!cmh_IsVldCmdSrc (srcId))
{
return( AT_FAIL );
}
pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
/*
*-------------------------------------------------------------------
* fill in parameters
*-------------------------------------------------------------------
*/
*mode = pCCCmdPrm -> CCUGmode;
*index = pCCCmdPrm -> CCUGidx;
*info = pCCCmdPrm -> CCUGinfo;
return( AT_CMPL );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_PlusCLCC |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the +CLCC? AT command
which returns the current call status.
*/
GLOBAL T_ACI_RETURN qAT_PlusCLCC ( T_ACI_CMD_SRC srcId,
T_ACI_CLCC_CALDESC *calLst)
{
/* Implements Measure 47 and 216 */
return ( qAT_plus_percent_CLCC(srcId, calLst, AT_CMD_CLCC, rdlPrm.rdlcId) );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_PercentCLCC |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the %CLCC? AT command
which returns the current call status.
*/
GLOBAL T_ACI_RETURN qAT_PercentCLCC ( T_ACI_CMD_SRC srcId,
T_ACI_CLCC_CALDESC *calLst)
{
/* Implements Measure 47 and 216 */
return ( qAT_plus_percent_CLCC(srcId, calLst, AT_CMD_P_CLCC, NO_ENTRY) );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_PlusCEER |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the +CEER AT command
which returns an extended error report.
*/
GLOBAL T_ACI_RETURN qAT_PlusCEER ( T_ACI_CMD_SRC srcId,
USHORT *cause)
{
T_CC_CALL_TBL *ctbFail = ccShrdPrm.ctb[ccShrdPrm.cIdFail];
TRACE_FUNCTION ("qAT_PlusCEER()");
/*
*-------------------------------------------------------------------
* check command source
*-------------------------------------------------------------------
*/
if(!cmh_IsVldCmdSrc (srcId))
{
return( AT_FAIL );
}
/*
*-------------------------------------------------------------------
* get error report
*-------------------------------------------------------------------
*/
/* Extended error report to indicate attach related problems */
if ((causeCeer NEQ CEER_NotPresent) AND (causeMod EQ P_CEER_mm))
{
*cause = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_NET, MM_ORIGINATING_ENTITY, causeCeer);
return( AT_CMPL );
}
if ((causeCeer NEQ CEER_NotPresent) AND (causeMod EQ P_CEER_ss))
{
*cause = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_NET, SS_ORIGINATING_ENTITY, causeCeer);
return( AT_CMPL );
}
if ((causeCeer EQ P_CEER_ACMMaxReachedOrExceeded) AND (causeMod EQ P_CEER_sim)) /* ACI cause check */
{
*cause = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_ACI_ORIGINATING_ENTITY, P_CEER_ACMMaxReachedOrExceeded);
return( AT_CMPL );
}
if ((causeCeer EQ P_CEER_InvalidFDN) AND (causeMod EQ P_CEER_sim)) /* ACI cause check */
{
*cause = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_ACI_ORIGINATING_ENTITY, P_CEER_InvalidFDN );
return( AT_CMPL );
}
if( ccShrdPrm.cIdFail < 0 OR ccShrdPrm.cIdFail > MAX_CALL_NR )
{
*cause = CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS, MNCC_ACI_ORIGINATING_ENTITY, NOT_PRESENT_8BIT);
return( AT_CMPL );
}
/*
* This code has to become better understood, probably it can be simplified
* Be sure to use ctbFail here because TI compiler 1.22e may have a problem
* otherwise.
*/
if (ctbFail NEQ NULL)
{
/* Call table entry still existant */
if (GET_CAUSE_VALUE(ctbFail->rejCs) NEQ NOT_PRESENT_8BIT)
{
*cause = ctbFail->rejCs;
}
else if (GET_CAUSE_VALUE(ctbFail->nrmCs) NEQ NOT_PRESENT_8BIT)
{
*cause = ctbFail->nrmCs;
}
else if (GET_CAUSE_VALUE(ctbFail->rslt) NEQ NOT_PRESENT_8BIT)
{
*cause = ctbFail->rslt;
}
else
{
/* in case network has sent no extended report */
*cause = CAUSE_MAKE(DEFBY_STD, ORIGSIDE_MS, MNCC_ACI_ORIGINATING_ENTITY, NOT_PRESENT_8BIT);
}
}
else
{
/* Call table entry already freed */
*cause = ccShrdPrm.ccCs[ccShrdPrm.cIdFail];
}
return AT_CMPL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCS |
| STATE : code ROUTINE : sAT_PlusPAS |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the +CPAS AT command
which returns the phone activity status.
*/
GLOBAL T_ACI_RETURN qAT_PlusCPAS ( T_ACI_CMD_SRC srcId,
T_ACI_CPAS_PAS *pas)
{
SHORT cId; /* holds call id */
T_ACI_CFUN_FUN cfun_stat;
TRACE_FUNCTION ("qAT_PlusCPAS()");
/*
*-------------------------------------------------------------------
* check command source
*-------------------------------------------------------------------
*/
if(!cmh_IsVldCmdSrc (srcId))
{
return( AT_FAIL );
}
/*
*-------------------------------------------------------------------
* get phone activity status
*-------------------------------------------------------------------
*/
/* check if power is off (+CFUN=0) */
if ( qAT_PlusCFUN(srcId, &cfun_stat) EQ AT_FAIL )
{
return( AT_FAIL );
}
if ( cfun_stat EQ CFUN_FUN_Minimum )
{
*pas = CPAS_PAS_Asleep;
return( AT_CMPL );
}
/* search for active call */
cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_ACT, NO_VLD_CT );
if( cId NEQ NO_ENTRY )
{
*pas = CPAS_PAS_CallProg;
return( AT_CMPL );
}
/* search for call on hold */
cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_HLD, NO_VLD_CT );
if( cId NEQ NO_ENTRY )
{
*pas = CPAS_PAS_CallProg;
return( AT_CMPL );
}
/* search for an incoming call */
cId = psaCC_ctbFindCall( (T_OWN)CMD_SRC_NONE, CS_ACT_REQ, CT_MTC );
if( cId NEQ NO_ENTRY )
{
*pas = CPAS_PAS_Ring;
return( AT_CMPL );
}
/* ready to accept commands */
*pas = CPAS_PAS_Ready;
return( AT_CMPL );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCS |
| STATE : code ROUTINE : sAT_PlusCSNS |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the +CSNS AT command
which returns the single numbering scheme mode.
*/
GLOBAL T_ACI_RETURN qAT_PlusCSNS ( T_ACI_CMD_SRC srcId,
T_ACI_CSNS_MOD *mode)
{
TRACE_FUNCTION ("qAT_PlusCSNS()");
/*
*-------------------------------------------------------------------
* check command source
*-------------------------------------------------------------------
*/
if(!cmh_IsVldCmdSrc (srcId))
{
return( AT_FAIL );
}
/*
*-------------------------------------------------------------------
* get SNS mode
*-------------------------------------------------------------------
*/
*mode = (T_ACI_CSNS_MOD)ccShrdPrm.snsMode;
return( AT_CMPL );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_PercentCAL |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the %CAL? AT command
which returns the current call status.
03.06.03 SKA: This function is called by MFW only. It uses
this function to get the called number for emitting on display.
But there is a protocoll between ACI and MFW which says, that
the RAT_COLP signal sent by ACI to MFW at receiving of MNCC_SETUP_CNF
to tell MFW/BMI whether it can emit the called number caused by the
content of mncc_setup_cnf->connected_number.present sent by the network or not.
If present = PRES_PRES_REST, ACI does not send RAT_COLP to MFW, but in this
function ACI did copy the number to the MFW callTable structure!
Now, ACI does not copy the called number in case of PRES_PRES_REST and
MFW/BMI will emit an empty string on display. Therefore we could save
a lot of memory and internal traffic between ACI and MFW, if we keep
all the logic within ACI!
*/
GLOBAL T_ACI_RETURN qAT_PercentCAL( T_ACI_CMD_SRC srcId,
T_ACI_CAL_ENTR* callTable )
{
SHORT ctbIdx; /* holds call table index */
SHORT lstIdx; /* holds call list index */
TRACE_FUNCTION ("qAT_PercentCAL()");
/*
*-------------------------------------------------------------------
* for every call of the call table
*-------------------------------------------------------------------
*/
for( ctbIdx = 0, lstIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
{
if (ccShrdPrm.ctb[ctbIdx] NEQ NULL)
{
/*
*---------------------------------------------------------------
* fill in call type
*---------------------------------------------------------------
*/
switch( psaCC_ctb(ctbIdx)->calType )
{
case( CT_MOC ):
case( CT_MOC_RDL ):
case( CT_NI_MOC ):
callTable[lstIdx].calType = CAL_TYPE_MOC;
break;
case( CT_MTC ):
callTable[lstIdx].calType = CAL_TYPE_MTC;
break;
default:
callTable[lstIdx].calType = CAL_TYPE_NotPresent;
}
/*
*---------------------------------------------------------------
* fill in call status
*---------------------------------------------------------------
*/
switch( psaCC_ctb(ctbIdx)->calStat )
{
case( CS_ACT_REQ ):
switch( psaCC_ctb(ctbIdx)->calType )
{
case( CT_MOC ):
case( CT_MOC_RDL ):
case( CT_NI_MOC ):
if( psaCC_ctb(ctbIdx)->alrtStat EQ AS_SND )
{
callTable[lstIdx].status = CAL_STAT_Alerting;
}
else
{
callTable[lstIdx].status = CAL_STAT_Dial;
}
break;
case( CT_MTC ):
if( psaCC_ctbFindCall ( (T_OWN)CMD_SRC_NONE, CS_ACT_REQ, NO_VLD_CT )
NEQ -1 )
{
callTable[lstIdx].status = CAL_STAT_Wait;
}
else
{
callTable[lstIdx].status = CAL_STAT_Incomming;
}
break;
default:
callTable[lstIdx].status = CAL_STAT_NotPresent;
}
break;
case( CS_ACT ):
case( CS_MDF_REQ ):
case( CS_HLD_REQ ):
callTable[lstIdx].status = CAL_STAT_Active;
break;
case( CS_HLD ):
callTable[lstIdx].status = CAL_STAT_Held;
break;
case( CS_IDL ):
case( CS_DSC_REQ ):
callTable[lstIdx].status = CAL_STAT_DeactiveReq;
/*
* reset of all other values
*/
callTable[lstIdx].mpty = CAL_MPTY_NotPresent;
callTable[lstIdx].type.ton = TON_NotPresent;
callTable[lstIdx].type.npi = NPI_NotPresent;
callTable[lstIdx].number[0] = '\0';
#ifdef NO_ASCIIZ
callTable[lstIdx].alpha.cs = CS_NotPresent;
callTable[lstIdx].alpha.len = 0;
#else /* #ifdef NO_ASCIIZ */
callTable[lstIdx].alpha[0] = '\0';
#endif /* #ifdef NO_ASCIIZ */
callTable[lstIdx].calType = CAL_TYPE_NotPresent;
callTable[lstIdx].calMode = CAL_MODE_NotPresent;
callTable[lstIdx].calOwner = CAL_OWN_NotPresent;
/*
* indes and next entry, because of the continue statement
*/
callTable[lstIdx].index = ctbIdx+1;
lstIdx++;
continue;
case( CS_CPL_REQ ):
continue;
}
/*
*---------------------------------------------------------------
* fill in number of connected party
*---------------------------------------------------------------
*/
switch( psaCC_ctb(ctbIdx)->calType )
{
case( CT_MOC ):
case( CT_MOC_RDL ):
case( CT_NI_MOC ):
/* presentation restricted FTA 31.1.4.2 procedure 1 */
/* number not available due to interworking FTA 31.1.4.2 procedure 2 */
if ((psaCC_ctb(ctbIdx)->clgPty.present NEQ MNCC_PRES_NOT_PRES) /* any .present indicator received from MSC? */
AND (psaCC_ctb(ctbIdx)->clgPty.c_num EQ 0) ) /* but no number available? */
{
/*
* this prevents MFW/BMI to emit the called number, but it
* ignores the NOT received COLP signal. Without a COLP signal
* MFW/BMI should not emit the called number. (FTA 31.1.4.2)
*/
callTable[lstIdx].number[0] = '\0';
callTable[lstIdx].type.ton = TON_NotPresent;
callTable[lstIdx].type.npi = NPI_NotPresent;
}
else
{
psaCC_ctbCldAdr2Num (ctbIdx, callTable[lstIdx].number,
MAX_CC_ORIG_NUM_LEN);
callTable[lstIdx].type.ton = (T_ACI_TOA_TON)psaCC_ctb(ctbIdx)->cldPty.ton;
callTable[lstIdx].type.npi = (T_ACI_TOA_NPI)psaCC_ctb(ctbIdx)->cldPty.npi;
}
break;
case( CT_MTC ):
psaCC_ctbClrAdr2Num (ctbIdx, callTable[lstIdx].number,
MAX_CC_ORIG_NUM_LEN);
callTable[lstIdx].type.ton = (T_ACI_TOA_TON)psaCC_ctb(ctbIdx)->clgPty.ton;
callTable[lstIdx].type.npi = (T_ACI_TOA_NPI)psaCC_ctb(ctbIdx)->clgPty.npi;
break;
case( NO_VLD_CT ):
default:
callTable[lstIdx].number[0] = '\0';
callTable[lstIdx].type.ton = TON_NotPresent;
callTable[lstIdx].type.npi = NPI_NotPresent;
break;
}
#ifdef NO_ASCIIZ
memcpy( ( UBYTE* ) &callTable[lstIdx].alpha,
( UBYTE* ) &psaCC_ctb(ctbIdx)->alphIdUni,
sizeof( T_ACI_PB_TEXT ) );
#else /* NO_ASCIIZ */
memcpy( callTable[lstIdx].alpha,
psaCC_ctb(ctbIdx)->alphIdUni.data,
psaCC_ctb(ctbIdx)->alphIdUni.len );
cmh_cvtFromDefGsm ( ( CHAR* ) psaCC_ctb(ctbIdx)->alphIdUni.data,
( USHORT ) psaCC_ctb(ctbIdx)->alphIdUni.len,
callTable[lstIdx].alpha );
#endif /* NO_ASCIIZ */
/*
*---------------------------------------------------------------
* fill in in-band tones setting
*---------------------------------------------------------------
*/
switch( psaCC_ctb(ctbIdx)->inBndTns )
{
case( TRUE ):
callTable[lstIdx].ibtUse = CAL_IBT_TRUE;
break;
case( FALSE ):
callTable[lstIdx].ibtUse = CAL_IBT_FALSE;
break;
}
/*
*---------------------------------------------------------------
* fill in call mode
*---------------------------------------------------------------
*/
switch( cmhCC_getcalltype(ctbIdx) )
{
case( VOICE_CALL ):
switch( psaCC_ctb(ctbIdx)->BC
[(psaCC_ctb(ctbIdx)->curBC EQ 0)?1:0].
bearer_serv)
{
case( MNCC_BEARER_SERV_ASYNC ):
if( psaCC_ctb(ctbIdx)->rptInd EQ MNCC_RI_CIRCULAR )
callTable[lstIdx].calMode = CAL_MODE_VAD_Voice;
else
callTable[lstIdx].calMode = CAL_MODE_VFD_Voice;
break;
case( MNCC_BEARER_SERV_FAX ):
callTable[lstIdx].calMode = CAL_MODE_VAF_Voice;
break;
case( MNCC_BEARER_SERV_NOT_PRES ):
callTable[lstIdx].calMode = CAL_MODE_Voice;
break;
default:
callTable[lstIdx].calMode = CAL_MODE_Unknown;
}
break;
#ifdef FAX_AND_DATA
case( TRANS_CALL ):
case( NON_TRANS_CALL ):
switch( psaCC_ctb(ctbIdx)->BC
[(psaCC_ctb(ctbIdx)->curBC EQ 0)?1:0].
bearer_serv)
{
case( MNCC_BEARER_SERV_SPEECH ):
if( psaCC_ctb(ctbIdx)->rptInd EQ MNCC_RI_CIRCULAR )
callTable[lstIdx].calMode = CAL_MODE_VAD_Data;
else
callTable[lstIdx].calMode = CAL_MODE_VFD_Data;
break;
case( MNCC_BEARER_SERV_NOT_PRES ):
callTable[lstIdx].calMode = CAL_MODE_Data;
break;
default:
callTable[lstIdx].calMode = CAL_MODE_Unknown;
}
break;
case( FAX_CALL ):
switch( psaCC_ctb(ctbIdx)->BC
[(psaCC_ctb(ctbIdx)->curBC EQ 0)?1:0].
bearer_serv)
{
case( MNCC_BEARER_SERV_SPEECH ):
callTable[lstIdx].calMode = CAL_MODE_VAF_Fax;
break;
case( MNCC_BEARER_SERV_NOT_PRES ):
callTable[lstIdx].calMode = CAL_MODE_Fax;
break;
default:
callTable[lstIdx].calMode = CAL_MODE_Unknown;
}
break;
#endif /* #ifdef FAX_AND_DATA */
#if defined CO_UDP_IP || defined(FF_GPF_TCPIP)
/* SPR#1983 - SH - Identify WAP call */
#ifdef CO_UDP_IP
case( UDPIP_CALL ):
/*fallthrough if both defined*/
#endif
#if defined(FF_GPF_TCPIP)
case (TCPIP_CALL):
#endif /* FF_GPF_TCPIP */
switch( psaCC_ctb(ctbIdx)->BC
[(psaCC_ctb(ctbIdx)->curBC EQ 0)?1:0].
bearer_serv)
{
case( MNCC_BEARER_SERV_SPEECH ):
if( psaCC_ctb(ctbIdx)->rptInd EQ MNCC_RI_CIRCULAR )
callTable[lstIdx].calMode = CAL_MODE_VAD_Data;
else
callTable[lstIdx].calMode = CAL_MODE_VFD_Data;
break;
case( MNCC_BEARER_SERV_NOT_PRES ):
callTable[lstIdx].calMode = CAL_MODE_Data;
break;
default:
callTable[lstIdx].calMode = CAL_MODE_Unknown;
break;
}
break;
#endif /* (CO_UDP_IP) || defined(FF_GPF_TCPIP) */
default:
callTable[lstIdx].calMode = CAL_MODE_Unknown;
}
/*
*---------------------------------------------------------------
* fill in call owner
*---------------------------------------------------------------
*/
switch( (T_ACI_CMD_SRC)psaCC_ctb(ctbIdx)->calOwn )
{
case( CMD_SRC_LCL ):
callTable[lstIdx].calOwner = CAL_OWN_LCL;
break;
#ifdef FF_ATI
case(CMD_SRC_ATI_1):
case(CMD_SRC_ATI_2):
case(CMD_SRC_ATI_3):
case(CMD_SRC_ATI_4):
callTable[lstIdx].calOwner = CAL_OWN_RMT;
break;
#endif /* FF_ATI */
default:
callTable[lstIdx].calOwner = CAL_OWN_NONE;
}
/*
*---------------------------------------------------------------
* fill in multiparty status
*---------------------------------------------------------------
*/
callTable[lstIdx].mpty = (psaCC_ctb(ctbIdx)->mptyStat EQ CS_ACT)?
CAL_MPTY_IsMember : CAL_MPTY_NoMember;
/*
*---------------------------------------------------------------
* fill in call index
*---------------------------------------------------------------
*/
callTable[lstIdx].index = ctbIdx+1;
lstIdx++;
}
}
/*
*-------------------------------------------------------------------
* terminate list of calls
*-------------------------------------------------------------------
*/
if( lstIdx < ctbIdx )
{
callTable[lstIdx].index = -1;
}
return( AT_CMPL );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_CallActive |
+--------------------------------------------------------------------+
PURPOSE : The function checks whether at least one call is in an
active state. This is not an official AT command !
*/
GLOBAL UBYTE qAT_CallActive ( void )
{
SHORT ctbIdx; /* holds call table index */
TRACE_FUNCTION ("qAT_CallActive()");
/*
*-------------------------------------------------------------------
* for every call of the call table
*-------------------------------------------------------------------
*/
for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
{
if (ccShrdPrm.ctb[ctbIdx] NEQ NULL)
{
/*
*---------------------------------------------------------------
* check call status
*---------------------------------------------------------------
*/
switch( psaCC_ctb(ctbIdx)->calStat )
{
case CS_ACT:
case CS_HLD_REQ:
case CS_HLD:
case CS_MDF_REQ:
return TRUE;
default:
break;
}
}
}
return FALSE;
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : PSA_CCF |
| ROUTINE : qAT_PercentALS |
+-------------------------------------------------------------------+
PURPOSE : get the ALS mode for outgoing calls (voice)
0: indicates bearer capability => BEARER_SERV_SPEECH
1: indicates bearer capability => BEARER_SERV_AUX_SPEECH
*/
GLOBAL void cmhCC_get_active_als_mode( T_ACI_CMD_SRC srcId, T_ACI_ALS_MOD *mode )
{
T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
*mode = pCCCmdPrm->ALSmode;
}
GLOBAL T_ACI_RETURN qAT_PercentALS( T_ACI_CMD_SRC srcId, T_ACI_ALS_MOD *mode )
{
TRACE_FUNCTION("qAT_PercentALS()");
if( !cmh_IsVldCmdSrc( srcId ) )
{
return( AT_FAIL );
}
cmhCC_get_active_als_mode( srcId, mode );
return( AT_CMPL );
}
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : PSA_CCF |
| ROUTINE : qAT_PercentCTTY |
+-------------------------------------------------------------------+
PURPOSE : Query the state of the TTY Service
*/
GLOBAL T_ACI_RETURN qAT_PercentCTTY (T_ACI_CMD_SRC srcId,
T_ACI_CTTY_MOD *mode,
T_ACI_CTTY_REQ *req,
T_ACI_CTTY_STAT *stat,
T_ACI_CTTY_TRX *trx)
{
SHORT ctNr;
BOOL fnd_act = FALSE;;
if( !cmh_IsVldCmdSrc( srcId ) )
{
return( AT_FAIL );
}
*mode = cmhPrm[srcId].ccCmdPrm.CTTYmode;
#ifdef FF_TTY
if (ccShrdPrm.ctmReq EQ MNCC_CTM_DISABLED)
{
*req = CTTY_REQ_Off;
}
else switch (ccShrdPrm.ttyCmd)
{
case TTY_ALL:
*req = CTTY_REQ_On;
break;
case TTY_HCO:
*req = CTTY_REQ_HCO;
break;
case TTY_VCO:
*req = CTTY_REQ_VCO;
break;
default:
*req = CTTY_REQ_Off;
break;
}
for (ctNr = 0; !fnd_act AND ctNr < MAX_CALL_NR; ctNr++)
{
if (ccShrdPrm.ctb[ctNr] NEQ NULL)
{
switch (psaCC_ctb(ctNr)->calStat)
{
case CS_ACT_REQ:
case CS_ACT:
case CS_HLD_REQ:
case CS_HLD:
case CS_MDF_REQ:
*stat = (ccShrdPrm.ctmState EQ TTY_STATE_ACTIVE)?
CTTY_STAT_On: CTTY_STAT_Off;
if (*stat EQ CTTY_STAT_On)
{
*trx = cmhCC_getTTYtrx_state ((int)ccShrdPrm.ttyCmd);
}
else
{
*trx = CTTY_TRX_Unknown;
}
fnd_act = TRUE;
break;
default:
break;
}
}
}
if (!fnd_act)
#else
*req = CTTY_REQ_Off;
#endif /* FF_TTY */
{
*stat = CTTY_STAT_Unknown;
*trx = CTTY_TRX_Unknown;
}
return( AT_CMPL );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_PercentRDL |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the %RDL? AT command
which returns the current setting for redial mode.
*/
GLOBAL T_ACI_RETURN qAT_PercentRDL ( T_ACI_CMD_SRC srcId,
T_ACI_CC_REDIAL_MODE* redial_mode,
T_ACI_CC_REDIAL_NOTIF* notification)
{
TRACE_FUNCTION ("qAT_PercentRDL()");
/* check command source */
if(!cmh_IsVldCmdSrc (srcId))
{
return( AT_FAIL );
}
/* fill in parameter */
switch(rdlPrm.rdlMod)
{
case AUTOM_REPEAT_OFF:
case AUTOM_REPEAT_ON:
*redial_mode = rdlPrm.rdlMod;
break;
default:
ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
return( AT_FAIL );
}
switch(rdlPrm.rdlModN)
{
case NO_NOTIF_USER:
case NOTIF_USER:
*notification = rdlPrm.rdlModN;
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_CCQ |
| STATE : code ROUTINE : qAT_PercentRDLB |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the %RDLB? AT command
which returns the current black list.
*/
GLOBAL T_ACI_RETURN qAT_PercentRDLB ( T_ACI_CMD_SRC srcId,
T_ACI_CC_REDIAL_BLACKL *blackl,
T_ACI_CC_REDIAL_NOTIF* notification)
{
TRACE_FUNCTION ("qAT_PercentRDLB()");
/* check command source */
if(!cmh_IsVldCmdSrc (srcId))
{
return( AT_FAIL );
}
if (rdlPrm.rdlMod EQ AUTOM_REPEAT_ON)
{
if((cc_blacklist_ptr NEQ NULL) AND (cc_blacklist_ptr->blCount NEQ 0))
{/* fill in parameter */
memcpy(blackl,cc_blacklist_ptr,sizeof(T_ACI_CC_REDIAL_BLACKL));
}
*notification = rdlPrm.rdlBlN;
return( AT_CMPL );
}
else
{
ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
return( AT_FAIL );
}
}
#endif /* TI_PS_FF_AT_P_CMD_RDLB */
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_PercentCSSD |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the AT%CSSD command
which returns an extended error report.
*/
GLOBAL T_ACI_RETURN qAT_PercentCSSD ( T_ACI_CMD_SRC srcId,
UBYTE *ss_diag)
{
T_CC_CALL_TBL *ctbFail = ccShrdPrm.ctb[ccShrdPrm.cIdFail];
TRACE_FUNCTION ("qAT_PercentCSSD()");
/*
*-------------------------------------------------------------------
* check command source
*-------------------------------------------------------------------
*/
if(!cmh_IsVldCmdSrc (srcId))
{
return( AT_FAIL );
}
/*
*-------------------------------------------------------------------
* get ss diagnostic
*-------------------------------------------------------------------
*/
/*
* check whether this diagnostic is within the specified parameters
* cross-check also MNCC SAP: VAL_ss_diag
* (This implementation follows version V3.19.0 (2004-06))
*/
if( (ctbFail->ssDiag >= MNCC_SS_DIAG_MOC_BAR_CUG) AND
(ctbFail->ssDiag <= MNCC_SS_DIAG_CCBS_NOT_POSSIBLE ))
{
*ss_diag = ctbFail->ssDiag;
return( AT_CMPL );
}
/* not yet initialized or not defined, return no information available */
else
{
/*reset ccShrdPrm.ctb[ccShrdPrm.cIdFail].ssDiag */
*ss_diag = ctbFail->ssDiag = MNCC_SS_DIAG_NOT_PROVIDED;
return( AT_CMPL );
}
}
#ifdef TI_PS_FF_AT_P_CMD_CUSCFG
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_PercentCUSCFG |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the AT%CUSCFG query command
which returns the customization status of the facility requested.
*/
GLOBAL T_ACI_RETURN qAT_PercentCUSCFG ( T_ACI_CMD_SRC srcId,
T_ACI_CUSCFG_FAC facility,
T_ACI_CUSCFG_STAT *status)
{
TRACE_FUNCTION ("qAT_PercentCUSCFG()");
/*
*-------------------------------------------------------------------
* check command source
*-------------------------------------------------------------------
*/
if(!cmh_IsVldCmdSrc (srcId))
{
return( AT_FAIL );
}
switch(facility)
{
case CUSCFG_FAC_MO_SM_Control:
*status = (T_ACI_CUSCFG_STAT)cuscfgParams.MO_SM_Control_SIM;
break;
case CUSCFG_FAC_MO_Call_Control:
*status = (T_ACI_CUSCFG_STAT)cuscfgParams.MO_Call_Control_SIM;
break;
case CUSCFG_FAC_MO_SS_Control:
*status = (T_ACI_CUSCFG_STAT)cuscfgParams.MO_SS_Control_SIM;
break;
case CUSCFG_FAC_MO_USSD_Control:
*status = (T_ACI_CUSCFG_STAT)cuscfgParams.MO_USSD_Control_SIM;
break;
case CUSCFG_FAC_2_Digit_Call:
*status = (T_ACI_CUSCFG_STAT)cuscfgParams.Two_digit_MO_Call;
break;
case CUSCFG_FAC_Ext_USSD_Res:
*status = (T_ACI_CUSCFG_STAT)cuscfgParams.Ext_USSD_Response;
break;
case CUSCFG_FAC_T_MOBILE_Eons:
*status = (T_ACI_CUSCFG_STAT)cuscfgParams.T_MOBILE_Eons;
break;
case CUSCFG_FAC_USSD_As_MO_Call:
*status = (T_ACI_CUSCFG_STAT)cuscfgParams.USSD_As_MO_Call;
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 */
#ifdef TI_PS_FF_AT_P_CMD_STDR
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_PercentSTDR |
+--------------------------------------------------------------------+
PURPOSE : This is the functional counterpart to the AT%STDR command
which returns the value of global variable <std>.
*/
GLOBAL T_ACI_RETURN qAT_PercentSTDR ( T_ACI_CMD_SRC srcId,
UBYTE *rvstd)
{
TRACE_FUNCTION ("qAT_PercentSTDR()");
/*
*-------------------------------------------------------------------
* check command source
*-------------------------------------------------------------------
*/
if(!cmh_IsVldCmdSrc (srcId))
{
return( AT_FAIL );
}
/*
*-------------------------------------------------------------------
* Read <std>
*-------------------------------------------------------------------
*/
*rvstd = std;
return( AT_CMPL );
}
#endif /* TI_PS_FF_AT_P_CMD_STDR */
/* Implements Measure 47 and 216 */
/*
+------------------------------------------------------------------------------
| Function : qAT_plus_percent_CLCC
+------------------------------------------------------------------------------
| Purpose : This is common functional counterpart to the %CLCC? and +CLCC?
|
| Parameters : srcId - AT command source identifier
| calLst - Points to CLCC current call
| list element.
| at_cmd_id - AT Command Identifier
| ( AT_CMD_CLCC or AT_CMD_P_CLCC )
|
| rdlcId - Redial Call Identifier , NO_ENTRY if no redial
|
| Return : ACI functional return codes
+------------------------------------------------------------------------------
*/
LOCAL T_ACI_RETURN qAT_plus_percent_CLCC( T_ACI_CMD_SRC srcId,
T_ACI_CLCC_CALDESC *calLst,
T_ACI_AT_CMD at_cmd_id,
SHORT rdlcId )
{
SHORT ctbIdx;
SHORT lstIdx;
int index;
TRACE_FUNCTION ("qAT_plus_percent_CLCC()");
index = ( at_cmd_id EQ AT_CMD_P_CLCC )?1:0;
/*
*-------------------------------------------------------------------
* for every call of the call table
*-------------------------------------------------------------------
*/
for( ctbIdx = 0, lstIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
{
if ( (ccShrdPrm.ctb[ctbIdx] NEQ NULL) AND (rdlcId EQ NO_ENTRY) )
{
/*
*---------------------------------------------------------------
* fill in call type
*---------------------------------------------------------------
*/
if ( ( psaCC_ctb(ctbIdx)->calType >= CT_MOC ) AND
( psaCC_ctb(ctbIdx)->calType <= CT_MOC_RDL ))
{
calLst[lstIdx].dir =
(T_ACI_CLCC_DIR) aci_clcc_dir[psaCC_ctb(ctbIdx)->calType][index];
}
/*
*---------------------------------------------------------------
* fill in call status
*---------------------------------------------------------------
*/
switch( psaCC_ctb(ctbIdx)->calStat )
{
case( CS_ACT_REQ ):
switch( psaCC_ctb(ctbIdx)->calType )
{
case( CT_MOC ):
case( CT_MOC_RDL ):
if( psaCC_ctb(ctbIdx)->alrtStat EQ AS_SND )
{
calLst[lstIdx].stat = CLCC_STAT_Alerting;
}
else
{
calLst[lstIdx].stat = CLCC_STAT_Dialing;
}
break;
case( CT_MTC ):
if ( psaCC_ctbCallInUse ( ) )
{
calLst[lstIdx].stat = CLCC_STAT_Waiting;
}
else
{
calLst[lstIdx].stat = CLCC_STAT_Incoming;
}
break;
}
break;
case( CS_ACT ):
case( CS_DSC_REQ ):
/*
* Also show calls in disconnecting state since in 4.08/5.4.4.2.1.1 ii)
* the user is still connected to the network.
* This call is then either terminated from the network side.
* (after the operator announcement) or user initiated by ATH
*/
case( CS_MDF_REQ ):
case( CS_HLD_REQ ):
calLst[lstIdx].stat = CLCC_STAT_Active;
break;
case( CS_HLD ):
calLst[lstIdx].stat = CLCC_STAT_Held;
break;
case( CS_IDL ):
case( CS_CPL_REQ ):
continue;
}
/*
*---------------------------------------------------------------
* fill in number of connected party
*---------------------------------------------------------------
*/
switch( psaCC_ctb(ctbIdx)->calType )
{
case( CT_MOC ):
case( CT_MOC_RDL ):
psaCC_ctbCldAdr2Num (ctbIdx, calLst[lstIdx].number,
MAX_CC_ORIG_NUM_LEN);
calLst[lstIdx].type.ton = (T_ACI_TOA_TON)psaCC_ctb(ctbIdx)->cldPty.ton;
calLst[lstIdx].type.npi = (T_ACI_TOA_NPI)psaCC_ctb(ctbIdx)->cldPty.npi;
break;
case( CT_MTC ):
psaCC_ctbClrAdr2Num (ctbIdx, calLst[lstIdx].number,
MAX_CC_ORIG_NUM_LEN);
calLst[lstIdx].type.ton = (T_ACI_TOA_TON)psaCC_ctb(ctbIdx)->clgPty.ton;
calLst[lstIdx].type.npi = (T_ACI_TOA_NPI)psaCC_ctb(ctbIdx)->clgPty.npi;
break;
}
#ifdef NO_ASCIIZ
memcpy( ( UBYTE* ) &calLst[lstIdx].alpha,
( UBYTE* ) &psaCC_ctb(ctbIdx)->alphIdUni,
sizeof( T_ACI_PB_TEXT ) );
#else /* NO_ASCIIZ */
memcpy( calLst[lstIdx].alpha,
ccShrdPrm.ctb[ctbIdx].alphIdUni.data,
ccShrdPrm.ctb[ctbIdx].alphIdUni.len );
cmh_cvtFromDefGsm ( ( CHAR* ) ccShrdPrm.ctb[ctbIdx].alphIdUni.data,
( USHORT ) ccShrdPrm.ctb[ctbIdx].alphIdUni.len,
calLst[lstIdx].alpha );
#endif /* NO_ASCIIZ */
/*
*---------------------------------------------------------------
* fill in call mode
*---------------------------------------------------------------
*/
switch( cmhCC_getcalltype(ctbIdx) )
{
case( VOICE_CALL ):
switch( psaCC_ctb(ctbIdx)->BC
[(psaCC_ctb(ctbIdx)->curBC EQ 0)?1:0].
bearer_serv)
{
case( MNCC_BEARER_SERV_ASYNC ):
if( psaCC_ctb(ctbIdx)->rptInd EQ MNCC_RI_CIRCULAR )
calLst[lstIdx].mode = CLCC_MODE_Voice;
else
calLst[lstIdx].mode = CLCC_MODE_VFDVoice;
break;
case( MNCC_BEARER_SERV_FAX ):
calLst[lstIdx].mode = CLCC_MODE_VAFVoice;
break;
case( MNCC_BEARER_SERV_NOT_PRES ):
calLst[lstIdx].mode = CLCC_MODE_Voice;
break;
default:
calLst[lstIdx].mode = CLCC_MODE_Unknown;
}
break;
#ifdef FAX_AND_DATA
case( TRANS_CALL ):
case( NON_TRANS_CALL ):
switch( psaCC_ctb(ctbIdx)->BC
[(psaCC_ctb(ctbIdx)->curBC EQ 0)?1:0].
bearer_serv)
{
case( MNCC_BEARER_SERV_SPEECH ):
if( psaCC_ctb(ctbIdx)->rptInd EQ MNCC_RI_CIRCULAR )
calLst[lstIdx].mode = CLCC_MODE_VADData;
else
calLst[lstIdx].mode = CLCC_MODE_VFDData;
break;
case( MNCC_BEARER_SERV_NOT_PRES ):
calLst[lstIdx].mode = CLCC_MODE_Data;
break;
default:
calLst[lstIdx].mode = CLCC_MODE_Unknown;
}
break;
case( FAX_CALL ):
switch( psaCC_ctb(ctbIdx)->BC
[(psaCC_ctb(ctbIdx)->curBC EQ 0)?1:0].
bearer_serv)
{
case( MNCC_BEARER_SERV_SPEECH ):
calLst[lstIdx].mode = CLCC_MODE_VAFFax;
break;
case( MNCC_BEARER_SERV_NOT_PRES ):
calLst[lstIdx].mode = CLCC_MODE_Fax;
break;
default:
calLst[lstIdx].mode = CLCC_MODE_Unknown;
}
break;
#endif /* #ifdef FAX_AND_DATA */
default:
calLst[lstIdx].mode = CLCC_MODE_Unknown;
}
/*
*---------------------------------------------------------------
* fill in multiparty status
*---------------------------------------------------------------
*/
calLst[lstIdx].mpty = (psaCC_ctb(ctbIdx)->mptyStat EQ CS_ACT)?
CLCC_MPTY_IsMember : CLCC_MPTY_NoMember;
/*
*---------------------------------------------------------------
* fill in line1 or line2
*---------------------------------------------------------------
*/
switch (cmhCC_GetCallType_from_bearer( &psaCC_ctb(ctbIdx)->BC[psaCC_ctb(ctbIdx)->curBC] ))
{
case ( CRING_SERV_TYP_Voice):
calLst[lstIdx].class_type = CLCC_CLASS_Line1;
break;
case ( CRING_SERV_TYP_AuxVoice):
calLst[lstIdx].class_type = CLCC_CLASS_Line2;
break;
default:
calLst[lstIdx].class_type = CLCC_CLASS_NotPresent;
break;
}
/*
*---------------------------------------------------------------
* fill in progress description if using BAT interface
*---------------------------------------------------------------
*/
#ifdef FF_BAT
if ( at_cmd_id EQ AT_CMD_P_CLCC )
{
calLst[lstIdx].prog_desc = psaCC_ctb(ctbIdx)->prgDesc;
}
#endif
/*
*---------------------------------------------------------------
* fill in call index
*---------------------------------------------------------------
*/
calLst[lstIdx].idx = ctbIdx+1;
lstIdx++;
}
}
/*
*-------------------------------------------------------------------
* terminate list of calls
*-------------------------------------------------------------------
*/
if( lstIdx < ctbIdx )
{
calLst[lstIdx].idx = ACI_NumParmNotPresent;
calLst[lstIdx].dir = CLCC_DIR_NotPresent;
calLst[lstIdx].stat = CLCC_STAT_NotPresent;
calLst[lstIdx].mode = CLCC_MODE_NotPresent;
calLst[lstIdx].mpty = CLCC_MPTY_NotPresent;
calLst[lstIdx].type.ton = TON_NotPresent;
calLst[lstIdx].number[0] = 0x0;
if( at_cmd_id EQ AT_CMD_P_CLCC )
{
calLst[lstIdx].class_type = CLCC_CLASS_NotPresent;
#ifdef FF_BAT
calLst[lstIdx].prog_desc = NOT_PRESENT_8BIT;
#endif
}
#ifdef NO_ASCIIZ
calLst[lstIdx].alpha.cs = CS_NotPresent;
calLst[lstIdx].alpha.len = 0;
#else /* #ifdef NO_ASCIIZ */
calLst[lstIdx].alpha[0] = 0x0;
#endif /* #ifdef NO_ASCIIZ */
}
return( AT_CMPL );
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147) MODULE : CMH_CCQ |
| STATE : code ROUTINE : qAT_PlusCVHU |
+--------------------------------------------------------------------+
PURPOSE : This is query call for +CVHU for the control of the voice
hangup
*/
GLOBAL T_ACI_RETURN qAT_PlusCVHU ( T_ACI_CMD_SRC srcId, T_ACI_CVHU_MODE *mode)
{
TRACE_FUNCTION("qAT_PlusCVHU()");
if(!cmh_IsVldCmdSrc (srcId))
{
ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
return( AT_FAIL );
}
*mode = ccShrdPrm.cvhu;
return( AT_CMPL );
}
/*==== EOF ========================================================*/
