diff g23m/condat/ms/src/aci/cmh_f.c @ 0:509db1a7b7b8

initial import: leo2moko-r1
author Space Falcon <falcon@ivan.Harhan.ORG>
date Mon, 01 Jun 2015 03:24:05 +0000
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/g23m/condat/ms/src/aci/cmh_f.c	Mon Jun 01 03:24:05 2015 +0000
@@ -0,0 +1,2019 @@
+/*
++-----------------------------------------------------------------------------
+|  Project :  GSM-PS (6147)
+|  Modul   :  CMH_F
++-----------------------------------------------------------------------------
+|  Copyright 2002 Texas Instruments Berlin, AG
+|                 All rights reserved.
+|
+|                 This file is confidential and a trade secret of Texas
+|                 Instruments Berlin, AG
+|                 The receipt of or possession of this file does not convey
+|                 any rights to reproduce or disclose its contents or to
+|                 manufacture, use, or sell anything it may describe, in
+|                 whole, or in part, without the specific written consent of
+|                 Texas Instruments Berlin, AG.
++-----------------------------------------------------------------------------
+|  Purpose :  This module defines global functions of the command
+|             handler.
++-----------------------------------------------------------------------------
+*/
+
+#ifndef CMH_F_C
+#define CMH_F_C
+#endif
+
+#include "aci_all.h"
+
+/*==== INCLUDES ===================================================*/
+
+#include "aci_cmh.h"
+#include "cphs.h"
+#include "aci_cphs.h"
+#include "ati_cmd.h"
+#include "aci_cmd.h"
+#include "ksd.h"
+#include "l4_tim.h"
+
+#include "aci_io.h"
+
+#ifdef FAX_AND_DATA
+#include "aci_fd.h"
+#endif
+
+#ifdef DTI
+#include "dti.h"      /* functionality of the dti library */
+#include "dti_conn_mng.h"
+#endif
+#include "psa.h"
+#include "psa_mm.h"
+#include "psa_sim.h"
+#include "psa_cc.h"
+#include "psa_sms.h"
+#include "psa_ss.h"
+#include "cmh.h"
+#include "cmh_mm.h"
+#include "cmh_sim.h"
+#include "cmh_cc.h"
+#include "cmh_sms.h"
+#include "cmh_ss.h"
+
+#include "aci.h"
+#include "phb.h"
+#include "aci_lst.h"
+#include "conc_sms.h"
+
+
+#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 GPRS
+#include "gaci.h"
+#include "gaci_cmh.h"
+#include "pcm.h"
+#include "psa_gmm.h"
+#include "cmh_gmm.h"
+#include "psa_sm.h"
+#include "cmh_sm.h"
+#include "psa_gppp.h"
+#include "cmh_gppp.h"
+
+#endif /* GPRS */
+
+#ifdef _CONC_TESTING_
+#include "aci_mfw.h"
+#endif
+
+#ifdef UART
+#include "psa_uart.h"
+#include "cmh_uart.h"
+#endif
+
+#ifdef FF_PSI
+#include "psa_psi.h"
+#include "cmh_psi.h"
+#endif /*FF_PSI*/
+
+
+#include "rx.h"
+
+#ifndef _SIMULATION_
+#include "ffs/ffs.h"
+#include "ffs_coat.h"
+#endif
+
+/*==== CONSTANTS ==================================================*/
+
+/*==== GLOBALS ====================================================*/
+#ifdef FF_ATI
+EXTERN T_CIEV_SIGNAL_BUFFER  asCievSignalBuf;
+EXTERN T_CIEV_SMSFULL_BUFFER asCievSmsFullBuf;
+#endif /* FF_ATI */
+
+/*==== TYPES ======================================================*/
+
+
+/*==== EXPORT =====================================================*/
+/* MACRO CB_VC() for call-backs used by the voice stack */
+#ifdef FF_BAT
+
+#ifdef FF_ATI
+  #if defined SMI OR defined MFW OR defined FF_MMI_RIV
+    #define CB_VC( cbNam ){rAT_##cbNam,rCI_##cbNam,rBAT_##cbNam}
+    #define CB_VC_EXT( cbNam ){rAT_##cbNam##_Ext,rCI_##cbNam,rBAT_##cbNam}
+  #else
+    #define CB_VC( cbNam ){0,rCI_##cbNam,rBAT_##cbNam} /* ACI only */
+    #ifdef _CONC_TESTING_   /* for _CONC_TESTING for ACI-only */
+       #define CB_VC_EXT( cbNam ){rAT_##cbNam##_Ext,rCI_##cbNam,rBAT_##cbNam}
+    #else
+       #define CB_VC_EXT( cbNam ){0,rCI_##cbNam,rBAT_##cbNam}
+    #endif
+  #endif
+#else
+  #if defined SMI OR defined MFW OR defined FF_MMI_RIV
+    #define CB_VC( cbNam ){rAT_##cbNam,0,rBAT_##cbNam}
+    #define CB_VC_EXT( cbNam ){rAT_##cbNam##_Ext,0,rBAT_##cbNam}
+  #else
+    #define CB_VC( cbNam ){0,0,0}
+    #define CB_EXT( cbNam ){0,0,0}
+  #endif
+#endif
+
+/* MACRO CB_FD() for call-backs used by the F&D stack */
+#ifdef FAX_AND_DATA
+  #define CB_FD( cbNam ){0,rCI_##cbNam,rBAT_##cbNam}
+#else
+  #define CB_FD( cbNam ){0,0,0}
+#endif
+
+/* MACRO CB_ST() for call-backs used by SIM toolkit */
+#ifdef SIM_TOOLKIT
+  #ifdef FF_ATI
+    #if defined SMI OR defined MFW OR defined FF_MMI_RIV
+      #define CB_ST( cbNam ){rAT_##cbNam,rCI_##cbNam,rBAT_##cbNam}
+    #else
+      #define CB_ST( cbNam ){0,rCI_##cbNam,rBAT_##cbNam}
+    #endif
+  #else
+    #if defined SMI OR defined MFW OR defined FF_MMI_RIV
+      #define CB_ST( cbNam ){rAT_##cbNam,0,rBAT_##cbNam}
+    #else
+      #define CB_ST( cbNam ){0,0,0}
+    #endif
+  #endif
+#else
+  #define CB_ST( cbNam ){0,0,0}
+#endif
+
+/* MACRO CB_GP() for call-backs used by GPRS */
+#ifdef GPRS
+  #ifdef FF_ATI
+    #if defined SMI OR defined MFW OR defined FF_MMI_RIV
+      #define CB_GP( cbNam ){rAT_##cbNam,rCI_##cbNam,rBAT_##cbNam}
+    #else
+      #define CB_GP( cbNam ){0,rCI_##cbNam,rBAT_##cbNam}
+    #endif
+  #else
+    #if defined SMI OR defined MFW OR defined FF_MMI_RIV
+      #define CB_GP( cbNam ){rAT_##cbNam,0,rBAT_##cbNam}
+    #else
+      #define CB_GP( cbNam ){0,0,0}
+    #endif
+  #endif
+#else
+  #define CB_GP( cbNam ){0,0,0}
+#endif  /* GPRS */
+
+#else
+
+#ifdef FF_ATI
+  #if defined SMI OR defined MFW OR defined FF_MMI_RIV
+    #define CB_VC( cbNam ){rAT_##cbNam,rCI_##cbNam}
+    #define CB_VC_EXT( cbNam ){rAT_##cbNam##_Ext,rCI_##cbNam}
+  #else
+    #define CB_VC( cbNam ){0,rCI_##cbNam}
+    #ifdef _CONC_TESTING_   /* for _CONC_TESTING for ACI-only */
+       #define CB_VC_EXT( cbNam ){rAT_##cbNam##_Ext,rCI_##cbNam}
+    #else
+       #define CB_VC_EXT( cbNam ){0,rCI_##cbNam}
+    #endif
+  #endif
+#else
+  #if defined SMI OR defined MFW OR defined FF_MMI_RIV
+    #define CB_VC( cbNam ){rAT_##cbNam,0}
+    #define CB_VC_EXT( cbNam ){rAT_##cbNam##_Ext,0}
+  #else
+    #define CB_VC( cbNam ){0,0}
+    #define CB_EXT( cbNam ){0,0}
+  #endif
+#endif
+
+/* MACRO CB_FD() for call-backs used by the F&D stack */
+#ifdef FAX_AND_DATA
+  #define CB_FD( cbNam ){0,rCI_##cbNam}
+#else
+  #define CB_FD( cbNam ){0,0}
+#endif
+
+/* MACRO CB_ST() for call-backs used by SIM toolkit */
+#ifdef SIM_TOOLKIT
+  #ifdef FF_ATI
+    #if defined SMI OR defined MFW OR defined FF_MMI_RIV
+      #define CB_ST( cbNam ){rAT_##cbNam,rCI_##cbNam}
+    #else
+      #define CB_ST( cbNam ){0,rCI_##cbNam}
+    #endif
+  #else
+    #if defined SMI OR defined MFW OR defined FF_MMI_RIV
+      #define CB_ST( cbNam ){rAT_##cbNam,0}
+    #else
+      #define CB_ST( cbNam ){0,0}
+    #endif
+  #endif
+#else
+  #define CB_ST( cbNam ){0,0}
+#endif
+
+/* MACRO CB_GP() for call-backs used by GPRS */
+#ifdef GPRS
+  #ifdef FF_ATI
+    #if defined SMI OR defined MFW OR defined FF_MMI_RIV
+      #define CB_GP( cbNam ){rAT_##cbNam,rCI_##cbNam}
+    #else
+      #define CB_GP( cbNam ){0,rCI_##cbNam}
+    #endif
+  #else
+    #if defined SMI OR defined MFW OR defined FF_MMI_RIV
+      #define CB_GP( cbNam ){rAT_##cbNam,0}
+    #else
+      #define CB_GP( cbNam ){0,0}
+    #endif
+  #endif
+#else
+  #define CB_GP( cbNam )
+#endif  /* GPRS */
+
+#endif /* FF_BAT */
+
+/* call back jump table */
+GLOBAL const T_VOID_FUNC RATJmpTbl[RAT_MAX][CMD_MODE_MAX] =
+{
+  CB_VC( OK ),            /* RAT_OK */
+  CB_VC( CONNECT ),       /* RAT_CONNECT */
+  CB_VC( PlusCME ),       /* RAT_CME */
+  CB_VC( NO_CARRIER ),    /* RAT_NO_CARRIER */
+  CB_VC( PlusCRING ),     /* RAT_CRING */
+  CB_FD( PlusDR ),        /* RAT_DR */
+  CB_FD( PlusCR ),        /* RAT_CR */
+  CB_VC( PlusCPIN ),      /* RAT_CPIN */
+  CB_VC( PlusCOPS ),      /* RAT_COPS */
+  CB_VC( PlusCREG ),      /* RAT_CREG */
+  CB_VC( PlusCCWA ),      /* RAT_CCWA */
+  CB_VC( PlusCLIP ),      /* RAT_CLIP */
+  CB_VC( PlusCDIP ),      /* RAT_CDIP */  
+  CB_VC( PlusCOLP ),      /* RAT_COLP */
+  CB_VC( PlusCRING_OFF ), /* RAT_CRING_OFF */
+
+#if defined (FF_FAX) AND defined (DTI)
+  CB_FD( PlusFCO ),       /* RAT_FCO */
+  CB_FD( PlusFIS ),       /* RAT_FIS */
+  CB_FD( PlusFTI ),       /* RAT_FTI */
+  CB_FD( PlusFCS ),       /* RAT_FCS */
+  CB_FD( PlusFCI ),       /* RAT_FCI */
+#endif /* FF_FAX */
+
+  CB_VC( PlusCMS  ),      /* RAT_CMS */
+  CB_VC( PlusCSMS ),      /* RAT_CSMS */
+  CB_VC( PlusCMGS ),      /* RAT_CMGS */
+  CB_VC( PlusCMSS ),      /* RAT_CMSS */
+  CB_VC( PlusCMGW ),      /* RAT_CMGW */
+  CB_VC( PlusCDS  ),      /* RAT_CDS */
+  CB_VC( PlusCMGC ),      /* RAT_CMGC */
+  CB_VC( PlusCMGD ),      /* RAT_CMGD */
+  CB_VC( PlusCMGR ),      /* RAT_CMGR */
+  CB_VC( PlusCMGL ),      /* RAT_CMGL */
+#ifdef _CONC_TESTING_
+  CB_VC_EXT( PlusCMTI ),  /* RAT_CMTI */
+  CB_VC_EXT( PlusCMT  ),  /* RAT_CMT */
+#else
+  CB_VC( PlusCMTI ),      /* RAT_CMTI */
+  CB_VC( PlusCMT  ),      /* RAT_CMT */
+#endif
+  CB_VC( PlusCBM  ),      /* RAT_CBM */
+  CB_VC( PlusCPMS ),      /* RAT_CPMS */
+
+#if defined (FF_FAX) AND defined (DTI)
+  
+  CB_FD( PlusFHT ),       /* RAT_FHT */
+  CB_FD( PlusFHR ),       /* RAT_FHR */
+  CB_FD( PlusFSA ),       /* RAT_FSA */
+  CB_FD( PlusFPA ),       /* RAT_FPA */
+  CB_FD( PlusFPW ),       /* RAT_FPW */
+  CB_FD( PlusFET ),       /* RAT_FET */
+  CB_FD( PlusFVO ),       /* RAT_FVO */
+  CB_FD( PlusFPO ),       /* RAT_FPO */
+  CB_FD( PlusFPI ),       /* RAT_FPI */
+  CB_FD( PlusFNF ),       /* RAT_FNF */
+  CB_FD( PlusFNS ),       /* RAT_FNS */
+  CB_FD( PlusFNC ),       /* RAT_FNC */
+  CB_FD( PlusFHS ),       /* RAT_FHS */
+  CB_FD( PlusFPS ),       /* RAT_FPS */
+  CB_FD( PlusFTC ),       /* RAT_FTC */
+#endif /* FF_FAX */
+  
+  CB_FD( PlusILRR ),      /* RAT_ILRR */
+  CB_VC( BUSY ),          /* RAT_BUSY */
+  CB_VC( NO_ANSWER ),     /* RAT_NO_ANSWER */
+  CB_VC( PercentSIMREM ), /* RAT_SIMREM */
+  CB_VC( PlusCLIR ),      /* RAT_CLIR */
+  CB_VC( PercentCOLR ),   /* RAT_COLR */
+  CB_VC( PlusCSSI ),      /* RAT_CSSI */
+  CB_VC( PlusCSSU ),      /* RAT_CSSU */
+  CB_VC( PlusCUSD ),      /* RAT_CUSD */
+  CB_VC( PlusCCFC ),      /* RAT_CCFC */
+  CB_VC( PlusCLCK ),      /* RAT_CLCK */
+  CB_VC( PlusCIMI ),      /* RAT_CIMI */
+  CB_ST( PercentSATI ),   /* RAT_SATI */
+  CB_ST( PercentSATE ),   /* RAT_SATE */
+  CB_VC( PercentKSIR ),   /* RAT_KSIR */
+  CB_VC( PercentCPI  ),   /* RAT_CPI  */
+  CB_VC( PercentCTYI ),   /* RAT_CTYI */
+  CB_VC( PlusCNUM ),      /* RAT_CNUM */
+  CB_VC( PlusCPOL ),      /* RAT_CPOL */
+  CB_VC( PlusCCCM ),      /* RAT_CCCM */
+  CB_VC( PercentCTV ),    /* RAT_CTV  */
+  CB_ST( PercentSATN ),   /* RAT_SATN */
+  CB_ST( PercentSATA ),   /* RAT_SATA */
+  CB_VC( sms_ready),      /* RAT_SMS_READY */
+  CB_VC( phb_status),     /* RAT_PHB_STATUS */
+  CB_VC( PercentSIMINS ), /* RAT_SIMINS */
+  CB_VC( PlusCRSM ),      /* RAT_CRSM */
+  CB_VC( PlusCSIM ),      /* RAT_CSIM */
+  CB_VC( PercentCCBS ),   /* RAT_CCBS */
+  CB_VC( PlusCCWV ),      /* RAT_CCWV */
+  CB_VC( PercentCNAP ),   /* RAT_CNAP */
+  CB_VC( SignalSMS ),     /* RAT_SIG_SMS */
+  CB_VC( PlusCLAN ),      /* RAT_CLAN */
+  CB_VC( PlusCLAE ),      /* RAT_CLAE */
+  CB_VC( PercentCSQ ),    /* RAT_CSQ */
+  CB_VC( PercentALS ),    /* RAT_ALS */
+
+  CB_VC( PlusCTZV ),      /* RAT_CTZR */
+  CB_VC( PercentCREG ),   /* RAT_P_CREG */
+
+
+#ifdef GPRS
+  
+  CB_GP( PlusCGACT ),     /* RAT_CGACT */
+  CB_GP( PlusCGDATA ),    /* RAT_CGDATA */
+  CB_GP( PlusCGANS ),     /* RAT_CGANS */
+  CB_GP( PlusCGEREP ),    /* RAT_CGEREP */
+  CB_GP( PlusCGREG ),     /* RAT_CGREG */
+  CB_GP( changedQOS ),    /* RAT_QOS_MOD */
+  CB_GP( PercentSNCNT ),  /* RAT_SNCNT */
+  CB_GP( PercentCGREG ),  /* RAT_P_CGREG */
+  CB_GP( PercentCGEV ),    /* RAT_P_CGEV */
+#endif  /* GPRS */
+
+#ifdef FF_EM_MODE
+  CB_VC( PercentEM ),     /* RAT_EM */
+  CB_VC( PercentEMET ),   /* RAT_EMET */
+  CB_VC( PercentEMETS ),  /* RAT_EMETS */
+#endif /* FF_EM_MODE */
+
+#ifdef FF_CPHS
+  CB_VC( PercentCPNUMS ),  /* RAT_CPNUMS */
+  CB_VC( PercentCPVWI ),   /* RAT_CPVWI */
+  CB_VC( PercentCPROAM ),  /* RAT_CPROAM */
+#endif /* FF_CPHS */
+  CB_VC( PlusCIEV ),      /* RAT_CIEV */
+  CB_VC( PercentRDL ),    /* RAT_RDL */
+  CB_VC( PercentRDLB ),   /* RAT_RDLB */
+  CB_VC( PercentCCCN ),   /* RAT_CCCN */
+  CB_VC( PercentCSSN ),   /* RAT_CSSN */
+
+
+  CB_VC( PercentCSTAT ),  /* RAT_CSTAT */
+
+
+
+  CB_VC( Z ),             /* RAT_Z */
+
+
+  CB_VC( PercentCPRSM ),  /* RAT_CPRSM */
+
+  CB_VC( PercentCTZV ),   /*RAT_P_CTZV*/
+  CB_VC( PercentCPRI ),    /*RAT_P_CPRI*/
+  CB_VC( PercentSIMEF ),   /*RAT_P_SIMEF*/
+
+  CB_VC( PercentCNIV ),    /*RAT_P_CNIV*/
+
+  CB_VC( PercentCOPS ),   /* RAT_P_COPS */
+  CB_VC( PercentCMGR ),   /* RAT_P_CMGR */
+  CB_VC( PercentCMGL )    /* RAT_P_CMGL */
+
+};
+
+/*==== VARIABLES ==================================================*/
+/* needed for function percentCSTAT_indication() */
+static UBYTE percentCSTAT_stateField;
+
+LOCAL T_ACI_CMD_MODE aci_cmd_src_mode[CMD_SRC_MAX];
+
+/*==== FUNCTIONS ==================================================*/
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH                     |
+|                                 ROUTINE : cmh_Init                |
++-------------------------------------------------------------------+
+
+  PURPOSE : initialize the command handler.
+
+*/
+
+
+GLOBAL void cmh_Init ( void )
+{
+  T_ACI_CMD_SRC index;
+
+  TRACE_FUNCTION ("cmh_Init()");
+
+  mmEntStat.curCmd  = AT_CMD_NONE;
+  mmEntStat.entOwn  = OWN_NONE;
+  simEntStat.curCmd = AT_CMD_NONE;
+  simEntStat.entOwn = OWN_NONE;
+  smsShrdPrm.smsEntStat.curCmd  = AT_CMD_NONE;
+  smsShrdPrm.smsEntStat.entOwn  = OWN_NONE;
+
+#ifdef UART
+  for (index=CMD_SRC_LCL; index<CMD_SRC_MAX; index++)
+  {
+    uartEntcurCmd[index]        = AT_CMD_NONE;
+  }
+
+  uartShrdPrm.dtr_behaviour     = DTR_BEHAVIOUR_Ignore;
+  uartShrdPrm.dtr_clearcall     = FALSE;
+  cmhUART_init_ipr_params();
+#endif
+
+#ifdef FF_PSI
+    psiShrdPrm.dtr_behaviour     = DTR_BEHAVIOUR_Ignore;
+    psiShrdPrm.dtr_clearcall     = FALSE;
+#endif /*FF_PSI*/
+
+
+#ifdef FAX_AND_DATA
+#ifdef FF_FAX
+  t30EntStat.curCmd = AT_CMD_NONE;
+  t30EntStat.entOwn = OWN_NONE;
+#endif
+
+  l2rEntStat.curCmd = AT_CMD_NONE;
+  l2rEntStat.entOwn = OWN_NONE;
+  raEntStat.curCmd  = AT_CMD_NONE;
+  raEntStat.entOwn  = OWN_NONE;
+#endif
+
+#ifndef _SIMULATION_
+  /* Read status of ALSlock */
+  if (FFS_fread ("/gsm/com/ALSlock",&ALSlock,sizeof(ALSlock)) NEQ sizeof(ALSlock))
+    /* if failed, reset to default */
+    ALSlock = ALS_MOD_NOTPRESENT;
+  else if (ALSlock NEQ ALS_MOD_SPEECH AND ALSlock NEQ ALS_MOD_AUX_SPEECH)
+    /* if unknown value was stored */
+    ALSlock = ALS_MOD_NOTPRESENT;
+#else
+  ALSlock = ALS_MOD_NOTPRESENT;
+#endif
+
+#ifdef GPRS
+  gaci_init();
+#endif
+
+#ifdef FF_ATI
+  for( index=0; index < CIEV_BUF_SIZE; index++ )
+  {
+
+    asCievSignalBuf.asBufferValues[index]  = CIND_SIGNAL_INDICATOR_INVALID;
+    asCievSmsFullBuf.asBufferValues[index] = CIND_SMSFULL_INDICATOR_INVALID;
+
+  }
+
+  asCievSignalBuf.uiLastIndex  = 0;
+  asCievSmsFullBuf.uiLastIndex = 0;
+#endif /* FF_ATI */
+
+  rx_Init(NULL); /* reset the signal strength callback */
+
+  for(percentCSTAT_stateField = 0,index = 0;
+      index < STATE_MSG_MAX_ENTITIES; index++)
+  {
+    percentCSTAT_stateField |= 1U << index;
+  }
+
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH                     |
+|                                 ROUTINE : cmh_Reset               |
++-------------------------------------------------------------------+
+
+  PURPOSE : Reset the command handler to defaults.
+*/
+
+/* MACRO: initializer for command parameter */
+#define INIT_PARM( entity, dest, def )\
+    {cmhPrm[srcId].entity##CmdPrm.dest = def;}
+
+#ifdef FAX_AND_DATA
+#define INIT_PARM_FND( entity, dest, def )\
+    {fnd_cmhPrm[srcId].entity##CmdPrm.dest = def;}
+#endif /* FAX_AND_DATA */
+
+GLOBAL void cmh_Reset ( T_ACI_CMD_SRC srcId, BOOL atz )
+{
+  UINT uiCount;
+
+  TRACE_EVENT_P1("Parameters reset for source: %d", srcId);
+
+  /* set default parms for command parameters */
+
+  INIT_PARM( cc,  CLIRmode,     CLIR_MOD_Subscript      );
+  INIT_PARM( cc,  DCDmode,      DCD_DISABLE_AFTER_CALL  );
+  INIT_PARM( cc,  CSTAtoa.ton,  TON_Unknown             );
+  INIT_PARM( cc,  CSTAtoa.npi,  NPI_IsdnTelephony       ); /* according to GSM 07.07 description of AT+CSTA */
+  INIT_PARM( cc,  CSTAdef,      TRUE                    );
+  INIT_PARM( cc,  CHLDmode,     CHLD_MOD_NotPresent     );
+  INIT_PARM( cc,  CCUGidx,      CCUG_IDX_0              );
+  INIT_PARM( cc,  CCUGinfo,     CCUG_INFO_No            );
+  INIT_PARM( cc,  CCUGmode,     CCUG_MOD_DisableTmp     );
+  INIT_PARM( cc,  mltyCncFlg,   0                       );
+  INIT_PARM( cc,  mltyDscFlg,   0                       );
+
+  /* Check if ALS is locked to a line */
+  if (ALSlock EQ ALS_MOD_NOTPRESENT)
+  {
+    INIT_PARM( cc,  ALSmode,      ALS_MOD_SPEECH          ); /* Use Default line */
+  }
+  else
+  {
+    INIT_PARM( cc,  ALSmode,      ALSlock                 ); /* Lock to specific line */
+  }
+
+  INIT_PARM( cc,  CTTYmode,     CTTY_MOD_Disable        );
+
+  INIT_PARM( cc,  CSCNcc_mode.CcCSCNModeState,     CC_CSCN_MOD_STATE_INVALID ); /* initialize the shared params for %CSCN */
+  INIT_PARM( cc,  CSCNcc_mode.CcCSCNModeDirection, CC_CSCN_MOD_DIR_INVALID   );
+
+
+  INIT_PARM( mm,  COPSfrmt,     COPS_FRMT_Long          );
+  INIT_PARM( mm,  NRGsrvMode,   NRG_SVMD_Full           );
+  INIT_PARM( mm,  NRGregMode,   NRG_RGMD_Auto           );
+  INIT_PARM( mm,  NRGoprFrmt,   NRG_FRMT_Long           );
+  INIT_PARM( mm,  CTZRMode,     CTZR_MODE_OFF           );
+  INIT_PARM( mm,  CSQworkStat,  CSQ_Disable             );
+
+  INIT_PARM( mm,  sIndicationParam.sMmCINDSettings.sCindSignalParam,  CIND_SIGNAL_INDICATOR_INVALID  ); /* initialize the shared params for %CIND */
+  INIT_PARM( mm,  sIndicationParam.sMmCINDSettings.sCindSmsFullParam, CIND_SMSFULL_INDICATOR_INVALID );
+  INIT_PARM( mm,  sIndicationParam.sMmCMERSettings.sCmerModeParam,    CMER_MODE_INVALID              );
+  INIT_PARM( mm,  sIndicationParam.sMmCMERSettings.sCmerIndParam,     CMER_INDICATOR_INVALID         );
+  INIT_PARM( mm,  sIndicationParam.sMmCMERSettings.sCmerBfrParam,     CMER_BFR_INVALID               );
+
+
+
+  /* initalize SS password */
+/* INIT_PARM( ss,  CXXXpwd[0],   0x0                     );  */
+  strcpy((CHAR *)cmhPrm[srcId].ssCmdPrm.CXXXpwd,"FFFF");
+  INIT_PARM( ss,  CXXXnewPwd[0],0x0                     );
+  INIT_PARM( ss,  mltyTrnFlg,   0                       );
+
+  INIT_PARM( ss,  CSCNss_mode.SsCSCNModeState,     SS_CSCN_MOD_STATE_INVALID );   /* initialize the shared params for %CSCN */
+  INIT_PARM( ss,  CSCNss_mode.SsCSCNModeDirection, SS_CSCN_MOD_DIR_INVALID   );
+
+  if (!atz)
+    INIT_PARM( sim, CNUMActRec,     1                     );
+
+  INIT_PARM( sim, CPOLfrmt,       CPOL_FRMT_Numeric     );
+  INIT_PARM( sim, CPOLact,        CPOL_ACT_None         );
+  INIT_PARM( sim, CPOLidx,        NOT_PRESENT_8BIT      );
+  INIT_PARM( sim, CPOLidx2,       NOT_PRESENT_8BIT      );
+  INIT_PARM( sim, CPOLmode,       CPOL_MOD_NotPresent   );
+
+  INIT_PARM( phb, cmhStor,      PB_STOR_Ad              );
+  INIT_PARM( phb, phbStor,      ADN                     );
+  INIT_PARM( phb, fndRec,       0                       );
+  INIT_PARM( phb, wrtRec,       0                       );
+  INIT_PARM( phb, curCmd,       AT_CMD_NONE             );
+
+#ifdef FAX_AND_DATA
+  INIT_PARM_FND( l2r, CRLPiws,      L2R_K_IWF_MS_DEF        );
+  INIT_PARM_FND( l2r, CRLPmws,      L2R_K_MS_IWF_DEF        );
+  INIT_PARM_FND( l2r, CRLPt1,       L2R_T1_DEF              );
+  INIT_PARM_FND( l2r, CRLPn2,       L2R_N2_DEF              );
+  INIT_PARM_FND( l2r, DSdir,        L2R_P0_DEF              );
+  INIT_PARM_FND( l2r, DScomp,       DS_COMP_DoNotDisc       );
+  INIT_PARM_FND( l2r, DSmaxDict,    L2R_P1_DEF              );
+  INIT_PARM_FND( l2r, DSmaxStr,     L2R_P2_DEF              );
+
+#ifdef FF_FAX
+  cmhT30_InitFAXPrms( srcId );
+  cmhT30_RstNgtPrms();
+#endif /* FF_FAX */
+#endif /* FAX_AND_DATA */
+
+  /* only if ATZ */
+  if(atz)
+  {
+    psaCC_init_mtcbearer();
+  }
+
+#ifdef FF_ATI
+  for( uiCount=0; uiCount < CIEV_BUF_SIZE; uiCount++ )
+  {
+    asCievSignalBuf.asBufferValues[uiCount]  = CIND_SIGNAL_INDICATOR_INVALID;
+    asCievSmsFullBuf.asBufferValues[uiCount] = CIND_SMSFULL_INDICATOR_INVALID;
+  }
+  asCievSignalBuf.uiLastIndex  = 0;
+  asCievSmsFullBuf.uiLastIndex = 0;
+#endif /* FF_ATI */
+  rx_Init(NULL); /* reset the signal strength callback */
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH                     |
+|                                 ROUTINE : cmh_IsVldCmdSrc         |
++-------------------------------------------------------------------+
+
+  PURPOSE : check for a valid command source.
+
+*/
+
+GLOBAL BOOL cmh_IsVldCmdSrc ( T_ACI_CMD_SRC srcId )
+{
+  if( srcId > CMD_SRC_NONE AND srcId < CMD_SRC_MAX )
+
+    return TRUE;
+
+  return( FALSE );
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH                     |
+|                                 ROUTINE : qAT_ErrDesc             |
++-------------------------------------------------------------------+
+
+  PURPOSE : query error description of last error.
+
+*/
+
+GLOBAL T_ACI_ERR_DESC qAT_ErrDesc ( void )
+{
+  return( aciErrDesc );
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH                     |
+|                                 ROUTINE : sAT_end_ussd            |
++-------------------------------------------------------------------+
+
+  PURPOSE : Give the user the opportunity to end at any time a USSD transaction.
+*/
+
+GLOBAL T_ACI_RETURN sAT_end_ussd ( T_ACI_CMD_SRC srcId )
+{
+  UBYTE srcBuf;             /* buffers current source of command */
+  SHORT sId;
+
+  TRACE_FUNCTION("sAT_end_ussd( )");
+
+  sId = psaSS_stbFindActSrv( NO_ENTRY );
+
+  if( sId NEQ NO_ENTRY )
+  {
+    if(ssShrdPrm.stb[sId].ussd_operation)
+    {
+      psaSS_EndTrns(sId);
+      ssShrdPrm.stb[sId].ntryUsdFlg = FALSE;
+      ssShrdPrm.stb[sId].ussd_operation = FALSE; /* probably not really necessary  */
+      return(AT_CMPL);
+    }
+    if(ssShrdPrm.stb[sId].curCmd EQ KSD_CMD_USSD OR
+       ssShrdPrm.stb[sId].curCmd EQ AT_CMD_CUSD)
+    {
+      srcBuf = ssShrdPrm.stb[sId].srvOwn;
+      psaSS_EndTrns(sId);
+      ssShrdPrm.stb[sId].ntryUsdFlg = FALSE;
+      ssShrdPrm.stb[sId].ussd_operation = FALSE; /*  probably not really necessary  */
+      ssShrdPrm.stb[sId].curCmd     = AT_CMD_NONE;
+      if( srcBuf NEQ srcId )
+      {
+        R_AT( RAT_CME, srcBuf )
+           ( ssShrdPrm.stb[sId].curCmd, CME_ERR_Unknown );
+      }
+      return( AT_CMPL );
+    }
+  }
+  return( AT_FAIL );
+
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH                     |
+|                                 ROUTINE : sAT_Abort               |
++-------------------------------------------------------------------+
+
+  PURPOSE : abort command execution for passed command.
+
+*/
+
+GLOBAL T_ACI_RETURN sAT_Abort ( T_ACI_CMD_SRC srcId,
+                                T_ACI_AT_CMD cmd )
+{
+  UBYTE idx;                /* holds call table index */
+  UBYTE srcBuf;             /* buffers current source of command */
+  BOOL  doneFlg = FALSE;    /* flags that an action was done */
+  USHORT nsapi_set = 0;     /* for deactivation of context if activation
+                               command is aborted */
+  SHORT ret_val = -1;       /* Return value used when AT+COPS is aborted */  
+  TRACE_FUNCTION ("sAT_Abort()");
+/*
+ *-------------------------------------------------------------------
+ * determine if command is abortable
+ *-------------------------------------------------------------------
+ */
+  switch( cmd )
+  {
+    /*
+     *---------------------------------------------------------------
+     * for SIM related commands
+     *---------------------------------------------------------------
+     */
+    case( AT_CMD_CFUN ):          /* +CFUN command id */
+    case( AT_CMD_BAND ):          /* %BAND command id */
+    case( AT_CMD_CPIN ):          /* +CPIN command id */
+      if( simEntStat.curCmd EQ cmd )
+      {
+        TRACE_EVENT("Command abortion for CFUN/CPIN");
+        if( simEntStat.entOwn NEQ srcId )
+        {
+          R_AT( RAT_CME, simEntStat.entOwn )
+            ( cmd, CME_ERR_Unknown );
+        }
+        simEntStat.entOwn = OWN_NONE;
+        simEntStat.curCmd = AT_CMD_NONE;
+        return( AT_CMPL );
+      }
+      else if( mmEntStat.curCmd EQ cmd ) /* can happen with AT%band */
+      {
+        TRACE_EVENT("Command abortion for %%BAND");
+        if( mmEntStat.entOwn NEQ srcId )
+        {
+          R_AT( RAT_CME, simEntStat.entOwn )
+            ( cmd, CME_ERR_Unknown );
+        }
+        mmEntStat.entOwn = OWN_NONE;
+        mmEntStat.curCmd = AT_CMD_NONE;
+        return( AT_CMPL );
+      }
+      break;
+
+    /*
+     *---------------------------------------------------------------
+     * for phone book related commands
+     *---------------------------------------------------------------
+     */
+    case( AT_CMD_CPBW ):
+      if (cmhPrm[srcId].phbCmdPrm.curCmd EQ AT_CMD_CPBW)
+      {
+        cmhPrm[srcId].phbCmdPrm.curCmd = AT_CMD_NONE;
+        return (AT_CMPL);
+      }
+      break;
+
+    /*
+     *---------------------------------------------------------------
+     * for MM related commands
+     *---------------------------------------------------------------
+     */
+    case( AT_CMD_COPS ):          /* +COPS command id */
+    case( AT_CMD_P_COPS ):          /* %COPS command id */
+    case( AT_CMD_NRG  ):          /* %NRG  command id */
+      if( mmEntStat.curCmd EQ cmd )
+      {
+        TRACE_EVENT("Command abortion for COPS/NRG");
+        if( mmEntStat.entOwn NEQ srcId )
+        {
+          R_AT( RAT_CME, mmEntStat.entOwn )
+            ( cmd, CME_ERR_Unknown );
+        }
+        if( (cmd EQ AT_CMD_COPS) OR (cmd EQ AT_CMD_P_COPS) )
+        {
+          mmShrdPrm.regMode = mmShrdPrm.regModeBeforeAbort; /* AT_CMD_COPS aborted, restore regMode and COPSmode */
+          mmShrdPrm.COPSmode = mmShrdPrm.COPSmodeBeforeAbort;
+        
+          switch (mmShrdPrm.COPSmode)
+          {
+            case COPS_MOD_Dereg:
+#if defined (GPRS) AND defined (DTI)
+              mmShrdPrm.nrgCs   = GMMREG_DT_COMB;
+              ret_val = psaG_MM_CMD_DEREG ( mmShrdPrm.nrgCs );      
+#else
+              mmShrdPrm.nrgCs   = CS_SIM_REM;
+              ret_val = psaMM_DeRegistrate();
+#endif
+            break;
+
+            case COPS_MOD_Auto:
+#if defined (GPRS) AND defined (DTI)
+              ret_val = psaG_MM_CMD_REG ();  /* register to network */
+#else
+              ret_val = psaMM_Registrate();   /* register to network */
+#endif
+            break; 
+
+            case COPS_MOD_Man:
+              if( mmShrdPrm.usedPLMN.v_plmn EQ VLD_PLMN )
+              {
+                mmShrdPrm.slctPLMN = mmShrdPrm.usedPLMN;
+              }
+              else
+              {
+                mmShrdPrm.slctPLMN.v_plmn = VLD_PLMN;
+                cmhMM_CnvrtINT2PLMN( 0xFFF,
+                                     0xFFF,
+                                     mmShrdPrm.slctPLMN.mcc,
+                                     mmShrdPrm.slctPLMN.mnc );
+              }
+
+#if defined (GPRS) AND defined (DTI)
+                ret_val = psaG_MM_CMD_NET_SEL();   /* register to network */
+#else
+                ret_val = psaMM_NetSel();          /* register to network */
+#endif
+            break;
+
+            case COPS_MOD_Both:
+              if (mmShrdPrm.regMode EQ MODE_AUTO)
+              {
+                mmShrdPrm.regModeAutoBack = FALSE;
+#if defined (GPRS) AND defined (DTI)
+                ret_val = psaG_MM_CMD_REG ();  /* register to network */
+#else
+                ret_val = psaMM_Registrate();  /* register to network */
+#endif
+              }
+              else
+              {
+                mmShrdPrm.regModeAutoBack = TRUE;
+                if( mmShrdPrm.usedPLMN.v_plmn EQ VLD_PLMN )
+                {
+                  mmShrdPrm.slctPLMN = mmShrdPrm.usedPLMN;
+                }
+                else
+                {
+                  mmShrdPrm.slctPLMN.v_plmn = VLD_PLMN;
+                  cmhMM_CnvrtINT2PLMN( 0xFFF,
+                                       0xFFF,
+                                       mmShrdPrm.slctPLMN.mcc,
+                                       mmShrdPrm.slctPLMN.mnc );
+                }
+              }
+#if defined (GPRS) AND defined (DTI)
+                  ret_val = psaG_MM_CMD_NET_SEL();   /* register to network */
+#else
+                  ret_val = psaMM_NetSel();          /* register to network */
+#endif
+            break;
+          } /* end of switch case */
+
+          if (ret_val < 0)
+          {
+            TRACE_EVENT( "FATAL RETURN in sAT_Abort()" );
+            ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
+          }
+        } /* end of AT_CMD_COPS */
+
+        mmEntStat.entOwn = OWN_NONE;
+        mmEntStat.curCmd = AT_CMD_NONE;
+        return( AT_CMPL );
+      }
+    break;
+
+    /*
+     *---------------------------------------------------------------
+     * for CC related commands
+     *---------------------------------------------------------------
+     */
+    case( AT_CMD_D    ):          /* D     command id */
+
+      for (idx = 0; idx < MAX_CALL_NR; idx++)
+      {
+        if (ccShrdPrm.ctb[idx] NEQ NULL)
+        {
+          if ((psaCC_ctb(idx)->curCmd EQ cmd AND
+              (psaCC_ctb(idx)->calStat EQ CS_ACT_REQ OR
+               psaCC_ctb(idx)->calStat EQ CS_DSC_REQ))
+           OR
+              (psaCC_ctb(idx)->calStat EQ CS_ACT AND
+              (cmhCC_getcalltype(idx) NEQ VOICE_CALL)))
+          {
+            doneFlg = TRUE;
+            srcBuf = psaCC_ctb(idx)->curSrc;
+
+            cmhCC_tstAndUnflagCall( idx, &cmhPrm[srcBuf].ccCmdPrm.mltyCncFlg );
+            cmhCC_flagCall        ( idx, &cmhPrm[srcId ].ccCmdPrm.mltyDscFlg );
+
+            psaCC_ctb(idx)->curCmd = AT_CMD_ABRT;
+            psaCC_ctb(idx)->curSrc = srcId;
+            psaCC_ctb(idx)->nrmCs  = MNCC_CAUSE_CALL_CLEAR;
+
+            psaCC_ClearCall (idx);
+
+            if( srcBuf NEQ srcId )
+            {
+              R_AT( RAT_NO_CARRIER, srcBuf ) ( AT_CMD_D, idx+1 );
+            }
+          }
+        }
+      }
+      if( doneFlg EQ TRUE)
+        return( AT_EXCT );
+
+      for( idx = 0; idx < MAX_CALL_NR; idx++ )
+      {
+        if (ccShrdPrm.ctb[idx] NEQ NULL AND 
+            psaCC_ctb(idx)->curCmd EQ cmd AND
+            psaCC_ctb(idx)->calStat EQ CS_MDF_REQ)
+        {
+          srcBuf = psaCC_ctb(idx)->curSrc;
+
+          cmhCC_tstAndUnflagCall( idx, &cmhPrm[srcBuf].ccCmdPrm.mltyCncFlg );
+
+          psaCC_ctb(idx)->curCmd = AT_CMD_NONE;
+          psaCC_ctb(idx)->curSrc = CMD_SRC_NONE;
+          doneFlg = TRUE;
+        }
+      }
+      if( doneFlg )
+      {
+        if( /*lint -e(644)*/srcBuf NEQ srcId )
+        {
+          R_AT( RAT_CME, srcBuf )
+            ( AT_CMD_D, CME_ERR_Unknown );
+        }
+        return( AT_CMPL );
+      }
+
+      for( idx = 0; idx < MAX_SS_NR; idx++ )
+      {
+        if( (ssShrdPrm.stb[idx].curCmd EQ KSD_CMD_CB  OR
+             ssShrdPrm.stb[idx].curCmd EQ KSD_CMD_CF  OR
+             ssShrdPrm.stb[idx].curCmd EQ KSD_CMD_CW  OR
+             ssShrdPrm.stb[idx].curCmd EQ KSD_CMD_CL  OR
+             ssShrdPrm.stb[idx].curCmd EQ KSD_CMD_PWD OR
+             ssShrdPrm.stb[idx].curCmd EQ KSD_CMD_USSD    ))
+        {
+          srcBuf = ssShrdPrm.stb[idx].srvOwn;
+          /* PATCH LE 26.06.00  */
+          /* End transaction in SS */
+          psaSS_EndTrns(idx);
+          /* END PATCH LE 26.06.00 */
+          ssShrdPrm.stb[idx].ntryUsdFlg = FALSE;
+          ssShrdPrm.stb[idx].curCmd     = AT_CMD_NONE;
+          doneFlg = TRUE;
+        }
+      }
+      if( doneFlg )
+      {
+        if( srcBuf NEQ srcId )
+        {
+          R_AT( RAT_CME, srcBuf )
+            ( AT_CMD_D, CME_ERR_Unknown );
+        }
+        return( AT_CMPL );
+      }
+      break;
+
+    case( AT_CMD_A    ):          /* A     command id */
+
+      for( idx = 0; idx < MAX_CALL_NR; idx++ )
+      {
+        if (ccShrdPrm.ctb[idx] NEQ NULL)
+        {
+          if (psaCC_ctb(idx)->curCmd EQ cmd AND
+              (psaCC_ctb(idx)->calStat EQ CS_ACT_REQ OR
+               psaCC_ctb(idx)->calStat EQ CS_CPL_REQ OR
+               psaCC_ctb(idx)->calStat EQ CS_DSC_REQ))
+          {
+            doneFlg = TRUE;
+            srcBuf = psaCC_ctb(idx)->curSrc;
+
+            cmhCC_tstAndUnflagCall( idx, &cmhPrm[srcBuf].ccCmdPrm.mltyCncFlg );
+            cmhCC_flagCall        ( idx, &cmhPrm[srcId ].ccCmdPrm.mltyDscFlg );
+
+            psaCC_ctb(idx)->curCmd = AT_CMD_ABRT;
+            psaCC_ctb(idx)->curSrc = srcId;
+            psaCC_ctb(idx)->nrmCs  = MNCC_CAUSE_CALL_CLEAR;
+
+            psaCC_ClearCall (idx);
+
+            if( srcBuf NEQ srcId )
+            {
+              R_AT( RAT_NO_CARRIER, srcBuf ) ( AT_CMD_A, idx+1 );
+            }
+          }
+        }
+      }
+      if( doneFlg )
+        return( AT_EXCT );
+
+      for( idx = 0; idx < MAX_CALL_NR; idx++ )
+      {
+        if (ccShrdPrm.ctb[idx] NEQ NULL AND
+            psaCC_ctb(idx)->curCmd EQ cmd AND
+            psaCC_ctb(idx)->calStat EQ CS_MDF_REQ)
+        {
+          srcBuf = psaCC_ctb(idx)->curSrc;
+
+          cmhCC_tstAndUnflagCall( idx, &cmhPrm[srcBuf].ccCmdPrm.mltyCncFlg );
+
+          psaCC_ctb(idx)->curCmd = AT_CMD_NONE;
+          psaCC_ctb(idx)->curSrc = CMD_SRC_NONE;
+          doneFlg = TRUE;
+        }
+      }
+      if( doneFlg )
+      {
+        if( srcBuf NEQ srcId )
+        {
+          R_AT( RAT_CME, srcBuf )
+            ( AT_CMD_A, CME_ERR_Unknown );
+        }
+        return( AT_CMPL );
+      }
+      break;
+
+    case( AT_CMD_Z    ):          /* Z     command id */
+    case( AT_CMD_CHUP ):          /* +CHUP command id */
+    case( AT_CMD_CHLD ):          /* +CHLD command id */
+    case( AT_CMD_CTFR ):          /* +CTFR command id */
+
+      for( idx = 0; idx < MAX_CALL_NR; idx++ )
+      {
+        if (ccShrdPrm.ctb[idx] NEQ NULL AND
+            psaCC_ctb(idx)->curCmd EQ cmd)
+        {
+          srcBuf = psaCC_ctb(idx)->curSrc;
+
+          cmhCC_tstAndUnflagCall( idx, &cmhPrm[srcBuf].ccCmdPrm.mltyCncFlg );
+          cmhCC_tstAndUnflagCall( idx, &cmhPrm[srcBuf].ccCmdPrm.mltyDscFlg );
+
+          psaCC_ctb(idx)->curCmd = AT_CMD_NONE;
+          psaCC_ctb(idx)->curSrc = CMD_SRC_NONE;
+          doneFlg = TRUE;
+        }
+      }
+      if( doneFlg )
+      {
+        if( srcBuf NEQ srcId )
+        {
+          R_AT( RAT_CME, srcBuf )
+            ( cmd, CME_ERR_Unknown );
+        }
+        return( AT_CMPL );
+      }
+      break;
+
+    case( AT_CMD_VTS ):          /* +VTS command id */
+
+      for( idx = 0; idx < MAX_CALL_NR; idx++ )
+      {
+        if (ccShrdPrm.ctb[idx] NEQ NULL AND
+            psaCC_ctb(idx)->dtmfCmd EQ cmd)
+        {
+          if (psaCC_ctb(idx)->dtmfMode NEQ DTMF_MOD_AUTO) /* DTMF in Auto Mode is not abortable
+                                                                 since the tone is always immediately stopped
+                                                                 after the network confirmed the tone to CC. So
+                                                                 it makes absolut no sense to abort the VTS nor
+                                                                 does this have any effect on the length of the tone. */
+          {
+            srcBuf = psaCC_ctb(idx)->dtmfSrc;
+            psaCC_ctb(idx)->dtmfCmd = AT_CMD_NONE;
+            psaCC_ctb(idx)->dtmfSrc = CMD_SRC_NONE;
+            sAT_PlusVTS( srcId, ccShrdPrm.dtmf.dig[0], VTS_MOD_ManStop );
+            doneFlg = TRUE;
+          }
+        }
+      }
+      if( doneFlg )
+      {
+        if( srcBuf NEQ srcId )
+        {
+          R_AT( RAT_CME, srcBuf )
+            ( AT_CMD_VTS, CME_ERR_Unknown );
+        }
+        return( AT_CMPL );
+      }
+
+      break;
+
+    /*
+     *---------------------------------------------------------------
+     * for SS related commands
+     *---------------------------------------------------------------
+     */
+    case( AT_CMD_CLIR ):          /* +CLIR command id */
+    case( AT_CMD_CLIP ):          /* +CLIP command id */
+    case( AT_CMD_COLP ):          /* +COLP command id */
+    case( AT_CMD_CCFC ):          /* +CCFC command id */
+    case( AT_CMD_CLCK ):          /* +CLCK command id */
+    case( AT_CMD_CCWA ):          /* +CCWA command id */
+    case( AT_CMD_CPWD ):          /* +CPWD command id */
+    case( AT_CMD_CUSD ):          /* +CUSD command id */
+
+      for( idx = 0; idx < MAX_SS_NR; idx++ )
+      {
+        if( ssShrdPrm.stb[idx].curCmd EQ cmd )
+        {
+          srcBuf = ssShrdPrm.stb[idx].srvOwn;
+          psaSS_EndTrns(idx);
+          cmhPrm[srcId].ssCmdPrm.mltyTrnFlg = 0;
+          ssShrdPrm.stb[idx].ntryUsdFlg = FALSE;
+          ssShrdPrm.stb[idx].curCmd     = AT_CMD_NONE;
+          doneFlg = TRUE;
+        }
+      }
+      if( simEntStat.curCmd EQ AT_CMD_CLCK )
+      {
+        simEntStat.curCmd = AT_CMD_NONE;
+        doneFlg = TRUE;
+      }
+      if( doneFlg )
+      {
+        if( srcBuf NEQ srcId )
+        {
+          R_AT( RAT_CME, srcBuf )
+            ( cmd, CME_ERR_Unknown );
+        }
+        return( AT_CMPL );
+      }
+      break;                      /* SS not implemented */
+
+    /*
+     *---------------------------------------------------------------
+     * for SMS related commands
+     *---------------------------------------------------------------
+     */
+    case( AT_CMD_CMGD ):          /* +CMGD command id */
+    case( AT_CMD_CMGW ):          /* +CMGW command id */
+    case( AT_CMD_CMGS ):          /* +CMGS command id */
+    case( AT_CMD_CMSS ):          /* +CMSS command id */
+    case( AT_CMD_CSMP ):          /* +CSMP command id */
+    case( AT_CMD_CSCA ):          /* +CSCA command id */
+
+      if( smsShrdPrm.smsEntStat.curCmd EQ cmd )
+      {
+        if( smsShrdPrm.smsEntStat.entOwn NEQ srcId )
+        {
+          R_AT( RAT_CMS, smsShrdPrm.smsEntStat.entOwn )
+            ( cmd, CMS_ERR_UnknownErr, NULL );
+        }
+
+        smsShrdPrm.smsEntStat.entOwn = OWN_NONE;
+        smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+        return( AT_CMPL );
+      }
+
+      break;
+
+#ifdef GPRS
+    /* brz:to check
+    /*
+     *---------------------------------------------------------------
+     * for GMM related commands
+     *---------------------------------------------------------------
+     */
+    case( AT_CMD_CGATT ):         /* +CGATT command id */
+    case( AT_CMD_CGCLASS ):       /* +CGCLASS command id */
+      if( gmmEntStat.curCmd EQ cmd )
+      {
+        TRACE_EVENT("Command abortion for CGATT/CGCLASS/CGAUTO");
+        if( gmmEntStat.entOwn NEQ srcId )
+        {
+          R_AT( RAT_CME, gmmEntStat.entOwn )
+            ( cmd, CME_ERR_Unknown );
+        }
+        gmmEntStat.entOwn = OWN_NONE;
+        gmmEntStat.curCmd = AT_CMD_NONE;
+        return( AT_CMPL );
+      }
+
+      break;
+    /*
+     *---------------------------------------------------------------
+     * for SM related commands
+     *---------------------------------------------------------------
+     */
+    case( AT_CMD_CGACT ):         /* +CGACT command id */
+      if( smEntStat.curCmd EQ cmd )
+      {
+        TRACE_EVENT("Command abortion for CGACT");
+        if( smEntStat.entOwn NEQ srcId )
+        {
+          R_AT( RAT_CME, smEntStat.entOwn )
+            ( cmd, CME_ERR_Unknown );
+        }
+        switch(get_state_working_cid())
+        {
+          case CS_WAITS_FOR_ACTIVATING:
+          case CS_ACTIVATING:
+          case CS_ACTIVATED:
+            smEntStat.entOwn = OWN_NONE;
+            smEntStat.curCmd = AT_CMD_NONE;
+            nsapi_set  = cmhSM_Give_nsapi_set( work_cids[cid_pointer] );
+            if ( nsapi_set )
+            {
+              set_state_working_cid( CS_DEACTIVATE_NORMAL );
+              psaSM_PDP_Deactivate( nsapi_set, SMREG_NONLOCAL);
+            }
+            else
+            {
+              set_state_working_cid( CS_DEFINED );
+              *work_cids = 0;
+              cid_pointer = 0;
+            }
+            break;
+        }
+        return( AT_CMPL );
+      }
+      break; /* LINT warning */
+    case( AT_CMD_CGDATA ):        /* +CGDATA command id */
+      if( gpppEntStat.curCmd EQ cmd ||
+            smEntStat.curCmd EQ cmd    )
+      {
+        TRACE_EVENT("Command abortion for CGDATA");
+        if( gpppEntStat.entOwn NEQ srcId  &&
+              smEntStat.entOwn NEQ srcId     )
+        {
+          R_AT( RAT_CME, gpppEntStat.entOwn )
+            ( cmd, CME_ERR_Unknown );
+        }
+
+        return cmhSM_deactivateAContext(srcId, work_cids[cid_pointer] );
+      }
+      break;
+
+    case( AT_CMD_CGANS ):         /* +CGANS command id */
+
+      if( smEntStat.curCmd EQ cmd )
+      {
+        TRACE_EVENT("Command abortion for CGANS");
+        if( smEntStat.entOwn NEQ srcId )
+        {
+          R_AT( RAT_CME, smEntStat.entOwn )
+            ( cmd, CME_ERR_Unknown );
+        }
+        smEntStat.entOwn = OWN_NONE;
+        smEntStat.curCmd = AT_CMD_NONE;
+        doneFlg = TRUE;
+      }
+
+      if( gpppEntStat.curCmd EQ cmd )
+      {
+        if( gpppEntStat.entOwn NEQ srcId )
+        {
+          R_AT( RAT_CME, gpppEntStat.entOwn )
+            ( cmd, CME_ERR_Unknown );
+        }
+        gpppEntStat.entOwn = OWN_NONE;
+        gpppEntStat.curCmd = AT_CMD_NONE;
+        return( AT_EXCT );
+      }
+
+      if( doneFlg == TRUE )
+        return( AT_EXCT );
+      break;
+
+    case( AT_CMD_CGSMS ):         /* +CGSMS command id */
+      if( smEntStat.curCmd EQ cmd )
+      {
+        TRACE_EVENT("Command abortion for CGSMS");
+        if( smEntStat.entOwn NEQ srcId )
+        {
+          R_AT( RAT_CME, smEntStat.entOwn )
+            ( cmd, CME_ERR_Unknown );
+        }
+        smEntStat.entOwn = OWN_NONE;
+        smEntStat.curCmd = AT_CMD_NONE;
+      }
+      return AT_CMPL;
+
+#endif /*GPRS*/
+
+  }
+
+  return( AT_FAIL );
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : cmh_mergeTOA            |
++-------------------------------------------------------------------+
+
+  PURPOSE : this function converts the type of number (TON) and the
+            numbering plan identification into the octet representation
+            according to GSM 04.08 ( 10.5.4.7 ).
+*/
+
+GLOBAL UBYTE cmh_mergeTOA ( UBYTE ton, UBYTE npi )
+{
+
+/*
+ *-------------------------------------------------------------------
+ * convert TON and NPI
+ *-------------------------------------------------------------------
+ */
+  return( ((ton & 0x07)<<4)+
+          ((npi & 0x0F)<<0)+0x80 );
+
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : cmh_mergeTOS            |
++-------------------------------------------------------------------+
+
+  PURPOSE : this function converts the type of subaddress (TOS) and the
+            odd/even indicator into the octet representation
+            according to GSM 04.08 ( 10.5.4.8 ).
+
+*/
+
+GLOBAL UBYTE cmh_mergeTOS ( UBYTE tos, UBYTE oe )
+{
+
+/*
+ *-------------------------------------------------------------------
+ * convert TOS and odd/even
+ *-------------------------------------------------------------------
+ */
+  return( ((tos & 0x07)<<4)+
+          ((oe & 0x01)<<3)+0x80 );
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : cmh_demergeTOA          |
++-------------------------------------------------------------------+
+
+  PURPOSE : this function converts the the octet representation
+            according to GSM 04.08 ( 10.5.4.7 ) into type of number
+            (TON) and the numbering plan identification.
+*/
+
+GLOBAL void cmh_demergeTOA ( UBYTE toa, UBYTE* ton, UBYTE* npi )
+{
+
+/*
+ *-------------------------------------------------------------------
+ * convert TON and NPI
+ *-------------------------------------------------------------------
+ */
+  *ton = (toa>>4) & 0x07;
+  *npi = (toa>>0) & 0x0F;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : cmh_demergeTOS          |
++-------------------------------------------------------------------+
+
+  PURPOSE : this function converts the octet representation
+            according to GSM 04.08 ( 10.5.4.8 ) into the type of
+            subaddress (TOS) and the odd/even indicator.
+
+*/
+
+GLOBAL void cmh_demergeTOS ( UBYTE tosa, UBYTE* tos, UBYTE* oe )
+{
+
+/*
+ *-------------------------------------------------------------------
+ * convert TOS and odd/even
+ *-------------------------------------------------------------------
+ */
+  *tos = (tosa>>4) & 0x07;
+  *oe  = (tosa>>3) & 0x01;
+}
+
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : CMH_F                      |
+| STATE   : code                ROUTINE : cmh_setToaDef              |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function sets the type of address to default values
+            (when the first character of address is '+' or the first
+            two characters are '0' default is 145 otherwise default
+            is 129)
+*/
+GLOBAL CHAR* cmh_setToaDef ( CHAR* number, T_ACI_TOA *toa )
+{
+  toa->npi = NPI_IsdnTelephony;
+
+  if ( *number EQ '+' )
+  {
+    toa->ton = TON_International;
+    return number+1;
+  }
+  else
+  {
+    toa->ton = TON_Unknown;
+    return number;
+  }
+}
+
+
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : cmh_packBCD             |
++-------------------------------------------------------------------+
+
+  PURPOSE : packing two BCD values in one octet
+            <bcd_out>   resulting packed BCD numbers
+            <char_in>   BCD values input per character
+            <len_in>    number of BCD values to be packed
+            RETURN :    number of packed octets
+*/
+
+GLOBAL USHORT cmh_packBCD (UBYTE *bcd_out, const UBYTE *char_in,
+                           USHORT len_in)
+{
+  USHORT no_oct = 0, i;
+
+  if (len_in > MAX_SMS_ADDR_DIG)            /* check length */
+    len_in = MAX_SMS_ADDR_DIG;
+
+  for (i = 0; i < len_in; i++)
+  {
+    if ((i & 1) EQ 0)                     /* pack high nibble */
+    {
+      no_oct++;
+      *bcd_out = *char_in++ | 0xF0;       /* in case of odd length */
+    }
+    else                                  /* pack low nibble */
+      *bcd_out++ &= (*char_in++ << 4) | 0xF;
+  }
+  return no_oct;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : cmh_unpackBCD           |
++-------------------------------------------------------------------+
+
+  PURPOSE : unpacking one octet in two BCD values
+            <char_out>  resulting unpacked BCD values
+            <bcd_in>    BCD numbers input
+            <len_in>    number of octets to be unpacked
+            RETURN :    number of unpacked BCD values
+*/
+
+GLOBAL USHORT cmh_unpackBCD (UBYTE *char_out, const UBYTE *bcd_in,
+                             USHORT len_in)
+{
+  USHORT no_bcd = 0, i;
+
+  if (len_in > MAX_SMS_ADDR_DIG/2)          /* check length */
+    len_in = MAX_SMS_ADDR_DIG/2;
+
+  for (i = 0; i < len_in; i++)
+  {
+    if ((*bcd_in & 0xF) NEQ 0xF)          /* in case of wrong length */
+    {
+      *char_out++ = *bcd_in & 0xF;        /* unpack low nibble */
+      no_bcd++;
+    }
+    else
+      break;
+    if ((*bcd_in & 0xF0) NEQ 0xF0)        /* in case of odd length */
+    {
+      *char_out++ = *bcd_in++ >> 4;       /* unpack high nibble */
+      no_bcd++;
+    }
+    else
+      break;
+  }
+  return no_bcd;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : cmh_unpackSCTS          |
++-------------------------------------------------------------------+
+
+  PURPOSE : unpacking SCTS (or validity period absolute) to the
+            T_ACI_VP_ABS structure
+*/
+GLOBAL void cmh_unpackSCTS (T_ACI_VP_ABS *scts, const UBYTE *buf_in)
+{
+
+  UBYTE lsb, msb, sign;
+
+  cmh_unpackBCD ((UBYTE*)scts, buf_in, 6);
+
+  /* get the time zone octet */
+  buf_in += 6;
+
+  lsb = *buf_in >> 4;
+  msb = *buf_in & 0x07;
+  scts->timezone = (msb *10) + lsb;  /* BCD */
+  sign = *buf_in & 0x08;
+  if (sign)
+    scts->timezone = -scts->timezone; /* ~scts->timezone + 1; */
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : cmh_logRslt             |
++-------------------------------------------------------------------+
+
+  PURPOSE : log result code.
+
+*/
+
+GLOBAL void cmh_logRslt ( T_ACI_CMD_SRC dest, RAT_ID rat,
+                          T_ACI_AT_CMD cmd,   SHORT cId,
+                          T_ACI_BS_SPEED spd, T_ACI_CME_ERR err )
+{
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+  T_ACI_RLOG rslt;          /* holds result pararmeter */
+
+  rslt.dest = dest;
+
+  switch( rat )
+  {
+    case( RAT_OK ):
+
+      rslt.atRslt = RLOG_RSLT_OK;
+      rslt.rsltPrm.rOK.cmdId = cmd;
+      rslt.rsltPrm.rOK.cId   = cId;
+      break;
+
+    case( RAT_NO_CARRIER ):
+
+      rslt.atRslt = RLOG_RSLT_NoCarrier;
+      rslt.rsltPrm.rNO_CARRIER.cmdId = cmd;
+      rslt.rsltPrm.rNO_CARRIER.cId   = cId;
+      break;
+
+    case( RAT_CONNECT ):
+
+      rslt.atRslt = RLOG_RSLT_Connect;
+      rslt.rsltPrm.rCONNECT.cmdId = cmd;
+      rslt.rsltPrm.rCONNECT.cId   = cId;
+      rslt.rsltPrm.rCONNECT.speed = spd;
+      break;
+
+    case( RAT_BUSY ):
+
+      rslt.atRslt = RLOG_RSLT_Busy;
+      rslt.rsltPrm.rBUSY.cmdId = cmd;
+      rslt.rsltPrm.rBUSY.cId   = cId;
+      break;
+
+    case( RAT_NO_ANSWER ):
+
+      rslt.atRslt = RLOG_RSLT_NoAnswer;
+      rslt.rsltPrm.rNO_ANSWER.cmdId = cmd;
+      rslt.rsltPrm.rNO_ANSWER.cId   = cId;
+      break;
+
+    case( RAT_CME ):
+
+      rslt.atRslt = RLOG_RSLT_CME;
+      rslt.rsltPrm.rCME.cmdId = cmd;
+      rslt.rsltPrm.rCME.err   = err;
+      rslt.rsltPrm.rCME.cId   = cId;
+      break;
+
+    default:
+
+      return;
+  }
+
+  rAT_PercentRLOG( &rslt );
+#endif
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : cmh_cvtToDefGsm         |
++-------------------------------------------------------------------+
+
+  PURPOSE : converts from internal GSM to default GSM alphabet.
+
+*/
+GLOBAL void cmh_cvtToDefGsm ( CHAR* in, CHAR* out, USHORT* len )
+{
+  USHORT i; /* used for counting */
+
+  *len = ( USHORT ) strlen ( in );
+
+  for ( i = 0; i < *len; i++ )
+    out[i] = in[i] & 0x7F;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : cmh_cvtFromDefGsm       |
++-------------------------------------------------------------------+
+
+  PURPOSE : converts from default GSM to internal GSM alphabet.
+
+*/
+GLOBAL void cmh_cvtFromDefGsm ( CHAR* in, USHORT len, CHAR* out )
+{
+  USHORT i; /* used for counting */
+
+  for ( i = 0; i < len; i++ )
+    out[i] = in[i] | 0x80;
+
+  out[len] = '\0';
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: GSM-PS (6147)                MODULE:  ACI_CMD             |
+| STATE  : code                         ROUTINE: cmh_set_delayed_call|
++--------------------------------------------------------------------+
+
+  PURPOSE : Set function pointer for general-purpose timer routine.
+            TRUE, if delayed call timer slot is available
+            FALSE otherwise
+            setting call=NULL always succeeds.
+*/
+static UCHAR (*cmh_timeout_delayed_call) (void*) = NULL;
+static void* cmh_timeout_delayed_arg = NULL;
+
+GLOBAL UBYTE cmh_set_delayed_call (UCHAR (*call) (void*), void* arg)
+{
+  UCHAR ret;
+  if (cmh_timeout_delayed_call EQ NULL
+   OR cmh_timeout_delayed_call EQ call
+   OR call EQ NULL)
+  {
+    cmh_timeout_delayed_call = call;
+    cmh_timeout_delayed_arg = arg;
+    ret = TRUE;
+  }
+  else ret = FALSE;
+  return ret;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: GSM-PS (6147)                MODULE:  ACI_CMD             |
+| STATE  : code                         ROUTINE: cmh_set_delayed_call|
++--------------------------------------------------------------------+
+
+  PURPOSE : start timer for general-purpose timer routine.
+            TRUE, if delayed call timer slot has been set before
+*/
+
+GLOBAL UBYTE cmh_start_delayed_call (ULONG ms)
+{
+  UBYTE ret;
+  if (cmh_timeout_delayed_call NEQ NULL) {
+    TRACE_FUNCTION ("cmh_start_delayed_call()");
+    vsi_t_start (hCommACI, ACI_TDELAY, ms);
+    ret = TRUE;
+  } else ret = FALSE;
+  return ret;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: GSM-PS (6147)                MODULE:  ACI_CMD             |
+| STATE  : code                         ROUTINE: cmh_timeout         |
++--------------------------------------------------------------------+
+
+  PURPOSE : A timeout has occured for a timer. The function returns
+            TRUE, if it is a timer which is handled by CMH, else FALSE
+            is returned to indicate that the timer has not been
+            processed.
+
+*/
+
+GLOBAL UBYTE cmh_timeout (USHORT index)
+{
+  TRACE_FUNCTION ("cmh_timeout()");
+
+  if (index EQ ACI_TMPTY)
+  {
+    /*
+     * timeout multiparty timer
+     */
+    cmhCC_MPTYTimeout();
+    return TRUE;
+  }
+
+  if (index EQ ACI_TECT)
+  {
+    /*
+     * timeout multiparty timer
+     */
+    cmhCC_ECTTimeout();
+    return TRUE;
+  }
+
+#ifdef FF_FAX
+  if (index EQ ACI_TFIT)
+  {
+    /*
+     * timeout FAX inactivity timer
+     */
+    cmhT30_FITTimeout();
+    return TRUE;
+  }
+#endif /* FF_FAX */
+
+  if (index EQ ACI_TDELAY)
+  {
+    /*
+     * timeout delayed call timer
+     */
+    if (cmh_timeout_delayed_call EQ NULL)
+    {
+      vsi_t_stop (hCommACI, ACI_TDELAY);
+    }
+    else if (!cmh_timeout_delayed_call (cmh_timeout_delayed_arg))
+      {
+        cmh_timeout_delayed_call = NULL;
+        vsi_t_stop (hCommACI, ACI_TDELAY);
+      }
+    return TRUE;
+  }
+
+  if (index EQ ACI_REPEAT_HND)
+  {
+    /* redial timer is elapsed */
+    cmhCC_redialTimeout();
+  }
+  /*
+   * the timeout is not for CMH
+   */
+  return FALSE;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : cmh_bldCalPrms          |
++-------------------------------------------------------------------+
+
+  PURPOSE : this function converts a dial string into the settings
+            for the called address parameters.
+*/
+
+/*******************************************
+This function is intended only to be called ONCE
+for a given number...
+Otherwise, TOA info might be corrupted
+********************************************/
+GLOBAL SHORT cmh_bldCalPrms ( char * pDialStr, T_CLPTY_PRM * calPrm )
+{
+  char * pSubAdr;           /* points to subaddress */
+  int   i;
+  int   len = strlen(pDialStr);
+
+  TRACE_FUNCTION("cmh_bldCalPrms()");
+
+/* seach for subaddress */
+  pSubAdr = strchr( pDialStr, '-' );
+  if ( pSubAdr NEQ NULL )    /* subaddress found */
+  {
+    *pSubAdr = 0x0; /* cut off subaddress */
+    pSubAdr++;
+
+    /*
+     * fill in subaddress information
+     */
+    calPrm -> tos = TOS_NSAP;
+    strncpy( calPrm->sub, pSubAdr, MAX_SUBADDR_LEN-1 );
+    calPrm->sub[MAX_SUBADDR_LEN-1] = 0x0;
+    calPrm -> oe  = (strlen(calPrm->sub) & 1)? OE_ODD : OE_EVEN;
+  }
+  else            /* subaddress not found */
+  {
+    calPrm -> tos = TOS_NOT_PRES;
+    calPrm -> oe  = OE_EVEN;
+    calPrm->sub[0]    = 0x0;
+  }
+
+/* fill in address information */
+
+  /* Sign "+" could be found anywhere in the string:
+  for instance in a Key Stroke Sequence */
+
+  /* Copy character until '+' digit */
+  for (i = 0; (i < len) && (pDialStr[i] != '+'); i++)
+    calPrm->num[i] = pDialStr[i];
+
+  if (i != len)
+  {
+    calPrm->ton = TON_INT_NUMB;
+
+    /* Skip '+' digit and copy next characters */
+    for (i++; i < len; i++)
+      calPrm->num[i-1] = pDialStr[i];
+    i--;
+  }
+  else
+    calPrm->ton = TON_UNKNOWN;
+
+  /* Copy EOS */
+  calPrm->num[i] = '\0';
+
+  calPrm -> npi = NPI_ISDN_TEL_NUMB_PLAN;
+
+  return 0;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : percentCSTAT_stateField |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function calls the %CSTAT callback and
+            handels the occurance of %CSTAT and
+            %CSTAT: RDY indication.
+*/
+GLOBAL void percentCSTAT_indication(T_ACI_ENTITY_ID_MSG     entityId,
+                                    T_ACI_ENTITY_STATE_MSG  entityState)
+{
+  T_ACI_STATE_MSG msgType;
+  int i = 0;
+  msgType.entityId    = entityId;
+  msgType.entityState = entityState;
+
+  for(; i < CMD_SRC_MAX; i++)
+  {
+    R_AT( RAT_CSTAT, i)(msgType);
+  }
+  if( (percentCSTAT_stateField >> entityId & 1U) EQ (unsigned) entityState )
+  {
+    percentCSTAT_stateField ^= 1U << entityId;
+  }
+
+  if(!percentCSTAT_stateField)
+  {
+    msgType.entityId = STATE_MSG_RDY;
+    for(i = 0; i < CMD_SRC_MAX; i++)
+    {
+      R_AT( RAT_CSTAT, i)(msgType);
+    }
+  }
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT :                       MODULE  : CMH_F                   |
+|                                 ROUTINE : aci_rat_cmd_mode        |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used by the R_AT macro and determines
+            the command mode that should be used to send the response.
+
+*/
+GLOBAL T_ACI_CMD_MODE aci_rat_cmd_mode(
+  RAT_ID cmd,
+  T_ACI_CMD_SRC src)
+{
+  T_ACI_CMD_MODE mode;
+
+  if (src!=CMD_SRC_NONE)
+  {
+    if (src<CMD_SRC_MAX)
+    {
+      if (IS_SRC_USED(src))
+      {
+        
+        /*
+        *   Get the command mode for the specified source.
+        */
+        mode = aci_cmd_src_mode_get(src);
+
+        /*
+        *   If RATJmpTbl is populated for the specified command mode
+        *   and command, indicate this by returning the command mode.
+        *   The nature of the R_AT macro is such that it is not possible
+        *   to simply call the function in the table from here.
+        */
+        if (mode NEQ CMD_MODE_NONE) 
+        {
+          if (RATJmpTbl[cmd][mode])
+          {
+            return(mode);
+          }
+          TRACE_EVENT_P2("RATJmpTbl[cmd=%d][mode=%d]", cmd, mode); /* in case of problems */
+        }
+      }
+    }
+  }
+
+  /*
+  *   A return value of CMD_MODE_NONE is meant to indicate that the
+  *   response should not be sent at all.
+  */
+  TRACE_EVENT_P1("aci_rat_cmd_mode(): CMD_MODE_NONE for src %d", src);
+  return(CMD_MODE_NONE);
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT :                       MODULE  : CMH_F                   |
+|                                 ROUTINE : aci_cmd_src_mode_get    |
++-------------------------------------------------------------------+
+
+  PURPOSE : Access function for reading aci_cmd_src_mode[] which
+            stores the command mode of each command source.
+
+*/
+GLOBAL T_ACI_CMD_MODE aci_cmd_src_mode_get(
+  T_ACI_CMD_SRC src_id)
+{
+  T_ACI_CMD_MODE mode;
+
+
+  if (src_id<CMD_SRC_MAX)
+  {
+    mode = aci_cmd_src_mode[src_id];
+    TRACE_EVENT_P2("aci_cmd_src_mode_get(): aci_cmd_src_mode[%d] = %d", src_id, mode);
+    return(mode);
+  }
+  else
+  {
+    TRACE_EVENT("aci_cmd_src_mode_get(): CMD_MODE_NONE");
+    return(CMD_MODE_NONE);
+  }
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT :                       MODULE  : CMH_F                   |
+|                                 ROUTINE : aci_cmd_src_mode_set    |
++-------------------------------------------------------------------+
+
+  PURPOSE : Access function for writing to aci_cmd_src_mode[] which
+            stores the command mode of each command source.
+
+*/
+GLOBAL void aci_cmd_src_mode_set(
+  UBYTE src_id,
+  T_ACI_CMD_MODE mode)
+{
+  if (src_id<CMD_SRC_MAX)
+  {
+    aci_cmd_src_mode[src_id]=mode;
+    TRACE_EVENT_P2("aci_cmd_src_mode_set(): aci_cmd_src_mode[%d] = %d", src_id, mode);
+  }
+}
+
+
+/*==== EOF ========================================================*/