--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/aci2/mfw/mfw_cm.c	Mon Sep 26 00:29:36 2016 +0000
@@ -0,0 +1,6648 @@
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	$Workfile:: mfw_cm.c	    $|
+| $Author:: Ak				$Revision::  1		    $|
+| CREATED: 3.11.98		       $Modtime:: 10.04.00 14:58    $|
+| STATE  : code 						     |
++--------------------------------------------------------------------+
+
+   MODULE  : MFW_CM
+
+   PURPOSE : This modul contains call management functions.
+
+   HISTORY:
+
+    Mar 28, 2006    REF:DR OMAPS00072407  x0039928
+    Description:   Phone hangs when tried to make an outgoing call
+    Solution: Reverting back the changes of issue OMAPS00048894 to stop from stack overflow.
+
+    Feb 27, 2006    REF:DR OMAPS00067884  x0039928
+    Description:   Held call released at locosto phone does not release the call at other end
+    Solution: if the mode is greater than CHLD_MOD_RelDialCall then sAT_PercentCHLD() is called 
+    instead of sAT_PlusCHLD()
+
+    Jan 27, 2006    REF:DR OMAPS00048894  x0039928
+    Description:   Outgoing Call: The called number is not displayed while an outgoing call is made
+    Solution: The called number is extracted from the parameter of callCmEvent() for event E_CM_MO_RES and is displayed.
+	
+   Sep 12, 2005   REF: MMI-SMR-34085 x0021334
+   Description: RE: Add +CDIP command - MMI Additions
+   Solution: Dummy implementation of function "rAT_PlusCDIP()" is done to enable successful compilation.
+	Nov 02, 2005    DR OMAPS00052132   xdeepadh
+	Bug:Not able to access the SMS inbox and also not able to send SMS in Locosto Lite build
+	Fix: The ATI Enums usage has been put under the FF_ATI flag.
+
+   Aug 10, 2005   REF: MMI-SPR-30099 x0018858
+   Description: During a held communication, if the user presses 4 and send then there is no response from network.
+   Solution: Modified the return value and also added a case statement to handle the response received.
+
+   	Apr 07 2005		REF: CRR 29989	xpradipg
+	Description:	Optimisation 3: replace the static global data with dynamic
+					allocation / deallocation
+	Solution:		The static global variables are dynamically allocated and
+					deallocated
+
+   Apr 03, 2005 REF: CRR 29988 - xpradipg
+   Description: Optimisation 2: Reduce the keyboard buffer and the dtmf buffer
+   size
+   Solution : The dtmf buffer is reduced to 20 from 50
+
+	Apr 14, 2005	REF: CRR 29991   xpradipg
+	Description:	Optimisation 5: Remove the static allocation and use dynamic 
+					allocation/ deallocation for pb_list and black_list
+	Solution:	The static definition is removed and replaced with the dynamic
+					allocation
+
+   Feb 03, 200   REF: CRR 25960   x0012850
+   Description: Call Hold: While one call in Active and other in Held by swapping either of phone is not audible
+   Solution: swapping action results in one of the calls getting muted. We attach user connection again.
+	
+   Aug 23, 2004 REF: CRR 22222  xkundadu
+   Bug:  Runaway Call Waiting Tone.
+		 Call Waiting tone doesnot stop after ansering waiting call.
+
+   Fix: Handle the AT-Command source id CMD_SRC_ATI_2 also for call control 
+    	callback functions.
+
+   Jun 05, 2004	REF: CRR 18262  NISHIKANT KULKARNI 
+   Description: The sample sends a STOP DTMF message without release of the key by the user
+   Solution: Instead of sending DTMF commands in "VTS_MOD_Auto" mode, on key press DTMF tone is started
+  		   using VTS_MOD_ManStart and on key release DTMF tone is stopped using VTS_MOD_ManStop mode.
+
+	//  Apr 26, 2004 REF: CRR 16545 Ajith K P and Side effect of CRR 16545.
+	//  Issue description: When the user enters 11SEND and if the first call is 
+	//  HELD call,the held call disconnects. This should not happen.
+	//  Problem was, though sAT_PlusCHLD(..) is expected to disconnect an ACTIVE
+	//  call only, it was disconnecting HELD call rather than returning AT_FAIL.
+	//  If sAT_PlusCHLD() Fails, Send the user entered string as USSD to network using sAT-Dn().
+	//  So now if the user wants to release a HELD call, in cm_disconect() we are calling the 
+	//  sAT_PlusCHLD(..) function with C
+
+*/
+
+#define ENTITY_MFW
+ 
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined (NEW_FRAME)
+
+#include "typedefs.h"
+#include "vsi.h"
+#include "pei.h"
+#include "custom.h"
+#include "gsm.h"
+
+#else
+
+#include "STDDEFS.H"
+#include "custom.h"
+#include "gsm.h"
+#include "vsi.h"
+
+#endif
+
+
+#include "mfw_mfw.h"
+#include "mfw_phb.h"
+#include "mfw_phbi.h"
+#include "mfw_cm.h"
+#include "mfw_cmi.h"
+#include "mfw_nm.h"
+#include "mfw_sim.h"
+#include "mfw_sima.h"
+#include "mfw_nmi.h"
+#include "mfw_simi.h"
+#include "mfw_win.h"
+
+#include "mfw_tim.h"
+#include "mfw_utils.h"
+
+#include "ksd.h"
+#include "psa.h"
+
+#if defined (FAX_AND_DATA)
+#include "aci_fd.h"
+#endif
+
+#include "cmh.h"
+#include "phb.h"
+#include "cmh_phb.h"
+
+#include "mfw_ss.h"
+#include "mfw_ssi.h"
+#include "mfw_win.h"
+#include "mfw_ffs.h"
+
+#include "prim.h"
+#ifndef PCM_2_FFS
+#include "pcm.h"
+#endif
+
+
+/*
+ * Conditional compilation flag for CCBS testing.
+ * When defined, the cm_ccbs_... functions do not call ACI functions but
+ * simply set the return value variable to indicate success. Also the body
+ * of the rAT_PercentMMITEST function is defined for parsing AT%MMITEST
+ * commands and calling ACI/MFW functions as if CCBS events had occured.
+ */
+// #define CCBS_TEST
+
+/********* current define *******************************************/
+//	Apr 14, 2005	REF: CRR 29991   xpradipg
+//	remove the static definition
+#ifndef FF_MMI_OPTIM
+static	 T_MFW_CM_BLACKLIST_LIST    black_list;
+#endif
+
+//  Apr 06 2005		REF: CRR 29989	xpradipg
+//	The definition of global is removed since it is locally used
+#ifndef FF_MMI_OPTIM
+static	 T_ACI_CAL_ENTR 	    call_tab[MAX_CALL_NR];
+#endif
+static	 T_MFW_PHB_LIST 	    entries;
+static	 T_MFW_CM_CC_STAT	    cc_stat;	   /* current outgoing call status	    */
+static	 T_MFW_CM_COMMAND	    cmd;
+static	 T_MFW_CM_NOTIFY	    notify;
+
+static	 UBYTE			    call_type;	   /* indicate an ECC call or normal call   */
+static	 UBYTE			    call_stat;	   /* indicate an MO call or MT call	    */
+static	 SHORT			    cc_id;	   /* current call index		    */
+static	 UBYTE			    redial_stat;
+static	 UBYTE			    redial_count;
+static	 UBYTE			    cmd_hold;
+
+static	 T_MFW_CM_CW_INFO	    in_call;
+static	 T_MFW_CM_MO_INFO	    out_call;
+static	 T_MFW_CM_DISCONNECT	    dis_connect;
+static	 T_MFW_CM_REDIAL	    rdl;
+static	 T_MFW_CM_CPI		    cm_cpi;
+/* Marcus: CCBS: 14/11/2002: Start */
+static	 T_MFW_CM_CCBS_INFO	    ccbs_info;              // E_CM_CCBS data
+static   T_MFW_CM_CCBS_OP       ccbs_op = CM_CCBS_NONE; // Current CCBS operation
+/* Marcus: CCBS: 14/11/2002: End */
+
+static	 T_CM_CLI		    cli_prefix;
+/*CONQUEST 5998-MC 30/04/02 -initialised timers to zero (prevents corruption) */
+static	 MfwHnd 		    redialTim1= NULL;	/* the 1th redialing			 */
+static	 MfwHnd 		    redialTim24 = NULL;  /* the 2th to 4st redialing		  */
+static	 MfwHnd 		    redialTim5 = NULL;	 /* the 5th or over redialing		  */
+
+static int cmCommand (U32 cmd, void *h); /* handle window commands  */
+static int cm_redial_timeout(MfwEvt e, MfwTim *t);
+static char currAccepting = 0; /* ES!! 210999 */
+static char currConnecting = 0; /* ES!! 290999 */
+static T_ACI_AT_CMD currCmd;
+
+void cm_force_disconnect(void); // RAVI
+
+//APR 03 2005 - REF CRR: 29988  xpradipg
+//The DTMF buffer is reduced from 50 to 20
+#ifdef FF_MMI_REDUCED_KBD_BUFFER
+#define MAX_DTMF_Q_ENTRIES 20
+#else
+#define MAX_DTMF_Q_ENTRIES 50
+#endif
+#define CPI_CAUSE_MASK 0xFF    /* cq11676 cause mask 17-02-04 MZ */
+static UBYTE dtmf_q[MAX_DTMF_Q_ENTRIES];
+static SHORT mfw_cm_dtmf_q_id;
+//xnkulkar 18262 This BOOL variable is used to determine whether we have received an 
+//acknowledegment for command sAT_PlusVTS() to start/stop the previous DTMF tone.
+static BOOL expectRatOk = FALSE; 
+
+// MMI-SPR 13873 xkundadu.
+// Added this boolean variable to check whether a particular call is in 
+// multiparty or not
+BOOL bIsMultpty = FALSE;
+
+EXTERN MfwHdr * current_mfw_elem;
+
+LOCAL T_MFW_CM_CALL_STAT cm_cvt_call_status( T_ACI_CAL_STAT stat );
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_init	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :   initialize for call management
+
+*/
+
+void cm_init(void)
+{
+//	Apr 14, 2005	REF: CRR 29991   xpradipg
+//	local variable definition
+#ifdef FF_MMI_OPTIM
+	T_MFW_CM_BLACKLIST_LIST black_list;
+	int8 file;
+#endif	
+  TRACE_FUNCTION ("cm_init()");
+  memset(&black_list, 0, sizeof(T_MFW_CM_BLACKLIST_LIST));
+//	Apr 14, 2005	REF: CRR 29991   xpradipg  
+//	Since the blacklist is not persistent across powercycles we reset the file
+//	contents
+#ifdef FF_MMI_OPTIM
+	if(	flash_MMI_blackList_write((U8 *)&black_list, sizeof(T_MFW_CM_BLACKLIST_LIST),0) < 0)
+		TRACE_EVENT("Error opening the black list file");
+#endif  
+
+    currAccepting = 0; /* ES!! 210999 */
+    currConnecting = 0; /* ES!! 290999 */
+
+  call_type    = MFW_CALL_FREE;
+  call_stat    = MFW_CALL_FREE;
+  cc_stat.type = MFW_CALL_FREE;
+  cc_id        = 0;
+
+  cmd_hold = 0;
+  currCmd = AT_CMD_NONE;
+
+// get prefix from EEPROM
+  cli_prefix = 0;
+
+  /* create time event for redialing */
+  redialTim1  = timCreate (0, MIN_DURATION_1, (MfwCb)cm_redial_timeout);
+  redialTim24 = timCreate (0, MIN_DURATION_2_4, (MfwCb)cm_redial_timeout);
+  redialTim5  = timCreate (0, MIN_DURATION_5, (MfwCb)cm_redial_timeout);
+
+	redial_stat = (UBYTE)FFS_flashData.redial_mode;
+
+  mfwCommand[MfwTypCm] = (MfwCb) cmCommand;
+
+/*
+** Create a static circular buffer to hold the dtmf tones
+*/
+  mfw_cm_dtmf_q_id = mfw_cbuf_create(	MAX_DTMF_Q_ENTRIES,
+  										sizeof(UBYTE),
+  				   						0,
+  				   						0xFF,
+  										TRUE,
+  										(void *)&dtmf_q[0]);
+
+  if (mfw_cm_dtmf_q_id < 0)
+  	TRACE_EVENT_P1("ERROR : mfw_cbuf_create failed with error value %d", mfw_cm_dtmf_q_id);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_exit	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :
+
+*/
+
+void cm_exit(void)
+{
+  TRACE_FUNCTION ("cm_exit()");
+
+  /* delete time event for redialing */
+  timDelete (redialTim5);
+  timDelete (redialTim24);
+  timDelete (redialTim1);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_create	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  create event for call management
+
+*/
+
+T_MFW_HND cm_create(T_MFW_HND hWin, T_MFW_EVENT event, T_MFW_CB cbfunc)
+{
+  T_MFW_HDR *hdr;
+  T_MFW_CM  *cm_para;
+
+  TRACE_FUNCTION ("cm_create()");
+
+  hdr	   = (T_MFW_HDR *) mfwAlloc(sizeof (T_MFW_HDR));
+  cm_para  = (T_MFW_CM *) mfwAlloc(sizeof (T_MFW_CM));
+
+  if (!hdr OR !cm_para)
+    return FALSE;
+
+  /*
+   * initialisation of the handler
+   */
+  cm_para->emask   = event;
+  cm_para->handler = cbfunc;
+
+  hdr->data = cm_para;				 /* store parameter in node	*/
+  hdr->type = MFW_TYP_CM;		    /* store type of event handler */
+
+  /*
+   * installation of the handler
+   */
+  return mfwInsert((T_MFW_HDR *)hWin, hdr);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_delete	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :   delete a event for call management
+
+*/
+
+T_MFW_RES cm_delete(T_MFW_HND h)
+{
+  TRACE_FUNCTION ("cm_delete()");
+
+  if (!h OR !((T_MFW_HDR *)h)->data)
+    return MFW_RES_ILL_HND;
+
+  if (!mfwRemove((T_MFW_HDR *)h))
+    return MFW_RES_ILL_HND;
+
+  mfwFree((U8 *)(((T_MFW_HDR *) h)->data),sizeof(T_MFW_CM));
+  mfwFree((U8 *)h,sizeof(T_MFW_HDR));
+
+  return MFW_RES_OK;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_signal	     |
++--------------------------------------------------------------------+
+
+   PURPOSE : send a event signal.
+
+*/
+
+void cm_signal(T_MFW_EVENT event, void * para)
+{
+	UBYTE temp;
+
+
+
+  temp = dspl_Enable(0);
+
+
+if (mfwSignallingMethod EQ 0)
+  {
+  /*
+   * focus is on a window
+   */
+  if (mfwFocus)
+    /*
+     * send event to sim management
+     * handler if available
+     */
+    if (cm_sign_exec (mfwFocus, event, para))
+		{
+			dspl_Enable(temp);
+			return;
+		}
+
+  /*
+   * acutal focussed window is not available
+   * or has no network management registration
+   * handler, then search all nodes from the root.
+   */
+   if (mfwRoot)
+     cm_sign_exec (mfwRoot, event, para);
+	}
+   else
+	 {
+	   MfwHdr * h = 0;
+
+	   /*
+		* Focus set, then start here
+		*/
+	   if (mfwFocus)
+		 h = mfwFocus;
+	   /*
+		* Focus not set, then start root
+		*/
+	   if (!h)
+		 h = mfwRoot;
+
+	   /*
+		* No elements available, return
+		*/
+
+	   while (h)
+
+
+	   {
+		 /*
+		  * Signal consumed, then return
+		  */
+		 if (cm_sign_exec (h, event, para))
+		{
+			dspl_Enable(temp);
+			return;
+		}
+
+		 /*
+		  * All windows tried inclusive root
+		  */
+		 if (h == mfwRoot)
+		{
+			dspl_Enable(temp);
+			return;
+		}
+
+		 /*
+		  * get parent window
+		  */
+		 h = mfwParent(mfwParent(h));
+		if(h)
+			h = ((MfwWin * )(h->data))->elems;
+	   }
+	   cm_sign_exec (mfwRoot, event, para);
+	}
+	dspl_Enable(temp);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_sign_exec	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Send a signal if CM management handler.
+
+*/
+
+BOOL cm_sign_exec (T_MFW_HDR * cur_elem, T_MFW_EVENT event, T_MFW_CM_PARA * para)
+{
+  TRACE_FUNCTION ("cm_sign_exec()");
+
+  while (cur_elem)
+  {
+    /*
+     * event handler is available
+     */
+    if (cur_elem->type EQ MFW_TYP_CM)
+    {
+      T_MFW_CM * cm_data;
+      /*
+       * handler is CM management handler
+       */
+      cm_data = (T_MFW_CM *)cur_elem->data;
+      if (cm_data->emask & event)
+      {
+	/*
+	 * event is expected by the call back function
+	 */
+	cm_data->event = event;
+	switch (event)
+	{
+	  case E_CM_COLP:
+	    memcpy (&cm_data->para.mo_data, para, sizeof (T_MFW_CM_MO_INFO));
+	    break;
+
+	  case E_CM_DISCONNECT:
+	    memcpy (&cm_data->para.disconnect, para, sizeof (T_MFW_CM_DISCONNECT));
+	    break;
+	  case E_CM_DISCONNECT_ALL:
+	    memcpy (&cm_data->para.disconnect_all, para, sizeof (T_MFW_CM_DISCONNECT_ALL));
+	    break;
+
+	  case E_CM_CW:
+	    memcpy (&cm_data->para.cw_info, para, sizeof (T_MFW_CM_CW_INFO));
+	    break;
+
+	  case E_CM_COMMAND:
+	    memcpy (&cm_data->para.command, para, sizeof (T_MFW_CM_COMMAND));
+	    break;
+
+	  case E_CM_AOC:
+	    memcpy (&cm_data->para.aoc_info, para, sizeof (T_MFW_CM_AOC_INFO));
+	    break;
+
+	  case E_CM_REDIAL:
+	    memcpy (&cm_data->para.rdl, para, sizeof (T_MFW_CM_REDIAL));
+	    break;
+
+	  case E_CM_CONNECT_ACK:
+	    memcpy (&cm_data->para.call_id, para, sizeof (SHORT));
+	    break;
+
+	  case E_CM_MO_RES:
+	    memcpy (&cm_data->para.call_id, para, sizeof (SHORT));
+	    break;
+
+	  case E_CM_CPI:
+	    memcpy (&cm_data->para.cm_cpi, para, sizeof (T_MFW_CM_CPI));
+	    break;
+
+	  case E_CM_RING_OFF:
+	    break;
+
+	  case E_CM_AOC_CNF:
+	    memcpy (&cm_data->para.aoc_cnf, para, sizeof (T_MFW_CM_AOC_CNF));
+	    break;
+
+	  case E_CM_DTMF:
+	    memcpy (&cm_data->para.dtmf_tone, para, sizeof (UBYTE));
+	    break;
+
+	  case E_CM_NOTIFY:
+	    memcpy (&cm_data->para.notify, para, sizeof (T_MFW_CM_NOTIFY));
+	    break;
+	  /*MC SPR 1392*/
+	  case E_CM_CALL_DEFLECT_STATUS:
+	  	 memcpy (&cm_data->para.call_deflect_status, para, sizeof (BOOL));
+	  break;
+      /* Marcus: CCBS: 14/11/2002: Start */
+	  case E_CM_CCBS:
+	    TRACE_EVENT("E_CM_CCBS");
+	    memcpy (&cm_data->para.ccbs, para, sizeof (T_MFW_CM_CCBS_INFO));
+	    break;
+      /* Marcus: CCBS: 14/11/2002: End */
+
+	   case E_CM_CTYI:
+	  	memcpy (&cm_data->para.ctyi, para, sizeof (T_MFW_CM_CTYI));
+	  	break;
+
+	}
+
+	/*
+	 * if call back defined, call it
+	 */
+	if (cm_data->handler)
+	{
+	  // PATCH LE 06.06.00
+	  // store current mfw elem
+	  current_mfw_elem = cur_elem;
+	  // END PATCH LE 06.06.00
+	  if ((*(cm_data->handler)) (cm_data->event, (void *)&cm_data->para))
+	    return TRUE;
+	}
+      }
+    }
+    cur_elem = cur_elem->next;
+  }
+  return FALSE;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	     |
+| STATE   : code			 ROUTINE : cm_callTyp_cvt    |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : This function is used to convert the type of call class
+	     used by MFW to the type of call class used by ACI.
+
+*/
+
+LOCAL T_MFW_CM_CALL_TYPE cm_callTyp_cvt(T_ACI_CLASS cls)
+{
+    switch ( cls )
+    {
+	case ( CLASS_Vce ) :	  return VOICE_CALL;
+	case ( CLASS_AuxVce):	  return AuxVOICE_CALL;
+	case ( CLASS_Dat ) :	  return DATA_CALL;
+	case ( CLASS_Fax ) :	  return FAX_CALL;
+	case ( CLASS_VceDat ) :
+	case ( CLASS_VceFax ) :
+	case ( CLASS_DatFax ) :
+	case ( CLASS_VceDatFax ): return (T_MFW_CM_CALL_TYPE)cls;
+	case ( CLASS_None )	: return NONE_TYPE;
+	case (CLASS_NotPresent):	return NONE_TYPE;
+
+	default:		  return NONE_TYPE;
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_search_callId    |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : find call index from call table
+
+*/
+
+int cm_search_callId(T_ACI_CAL_STAT type, SHORT *id)
+{
+    int i;
+//  Apr 06 2005		REF: CRR 29989	xpradipg    
+//	Local definition and allocation
+#ifdef FF_MMI_OPTIM
+	T_ACI_CAL_ENTR 	    *call_tab;
+	*id = 0;
+	call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+	if(NULL == call_tab)
+		return CM_ERROR;
+#else
+	*id = 0;
+#endif	
+    TRACE_FUNCTION("cm_search_callId()");
+    
+
+    if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) != AT_CMPL)
+	{
+//   	Apr 06 2005		REF: CRR 29989	xpradipg
+//		deallocation of memory allocated
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif
+		return CM_ERROR;
+	}		
+
+    for (i=0; i<MAX_CALL_NR; i++)
+    {
+	if (call_tab[i].index == -1)
+	    break;
+
+	if (call_tab[i].status == type)
+	{
+	    *id = call_tab[i].index;
+//   	Apr 06 2005		REF: CRR 29989	xpradipg
+//		deallocation of memory
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif	    
+	     return CM_OK;
+	}
+
+    }
+//   	Apr 06 2005		REF: CRR 29989	xpradipg
+//		deallocation of memory
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif    
+    return CM_ERROR;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_search_callMode  |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : find call type from call table
+
+*/
+
+T_ACI_CAL_MODE cm_search_callMode(SHORT id)
+{
+    int i;
+//  Apr 06 2005		REF: CRR 29989	xpradipg
+//	allocation of memory, if the memory allocation fails then we return the 
+//	error value same as when the qAT_PercentCAL() fails
+#ifdef FF_MMI_OPTIM
+	T_ACI_CAL_ENTR 	    *call_tab;//[MAX_CALL_NR];
+	T_ACI_CAL_MODE		calMode;
+	call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+	if(NULL == call_tab)
+		return CAL_MODE_Unknown;
+#endif	
+
+    TRACE_FUNCTION("cm_search_callMode()");
+
+    if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) != AT_CMPL)
+	{
+//   	Apr 06 2005		REF: CRR 29989	xpradipg	
+//		deallocate memory
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif	
+		return CAL_MODE_Unknown;
+	}
+    for (i=0; i<MAX_CALL_NR; i++)
+    {
+	if (call_tab[i].index == -1)
+	    break;
+
+		if (call_tab[i].index == id)
+		{	
+//   	Apr 06 2005		REF: CRR 29989	xpradipg
+//		deallocate memory
+#ifdef FF_MMI_OPTIM
+			calMode = call_tab[i].calMode;
+		    if(call_tab)
+		        mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+		    return calMode;
+#else		
+		    return call_tab[i].calMode;
+#endif		    
+		}	    
+    }
+// 	Apr 06 2005		REF: CRR 29989	xpradipg    
+//	deallocate memory
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif
+    return CAL_MODE_Unknown;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_search_mptyId    |
+
+
+   PURPOSE : find multiparty call index from call table
+
+*/
+
+int cm_search_mptyId(T_ACI_CAL_MPTY type, SHORT *id)
+{
+    int i;
+// 	Apr 06 2005		REF: CRR 29989	xpradipg    
+//	allocate memory
+#ifdef FF_MMI_OPTIM
+	T_ACI_CAL_ENTR 	    *call_tab;//[MAX_CALL_NR];
+	call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+	if( NULL == call_tab)
+		return CM_ERROR;
+#endif	
+
+    TRACE_FUNCTION("cm_search_mptyId()");
+    *id = 0;
+
+    if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) != AT_CMPL)
+	{
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	deallocate memory
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif
+		return CM_ERROR;
+	}
+    for (i=0; i<MAX_CALL_NR; i++)
+    {
+	if (call_tab[i].index == -1)
+	    break;
+
+	if (call_tab[i].mpty == type)
+	{
+	    *id = call_tab[i].index;
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	deallocate memory
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif	    
+	    return CM_OK;
+	}
+    }
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	deallocate memory
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif    
+    return CM_ERROR;
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		    |
+| STATE  : code 			ROUTINE: cm_search_numId    |
++-------------------------------------------------------------------+
+
+
+   PURPOSE : find call index from call table
+
+*/
+
+LOCAL SHORT cm_search_numId(UBYTE *number)
+{
+	int i;
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	allocate memory
+#ifdef FF_MMI_OPTIM
+	SHORT	index;
+	T_ACI_CAL_ENTR 	    *call_tab;//[MAX_CALL_NR];
+	call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+	if(NULL == call_tab)
+		return 0;
+#endif	
+
+    TRACE_FUNCTION("cm_search_numId()");
+
+    if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) != AT_CMPL)
+	{
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	deallocate memory
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif	
+		return 0;
+	}		
+
+    for (i=0; i<MAX_CALL_NR; i++)
+    {
+		if (call_tab[i].index == -1)
+		    break;
+
+		if (!strcmp(call_tab[i].number, (char *)number))
+		{
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	deallocate memory
+#ifdef FF_MMI_OPTIM
+			index = call_tab[i].index;
+		    if(call_tab)
+		    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+		    return index;
+#else	
+		    return call_tab[i].index;
+#endif		    
+		}	    
+    }
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	deallocate memory
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif    
+    return 0;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_search_callStat  |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Search the information from call table.
+
+*/
+
+T_MFW cm_search_callStat(SHORT call_number,
+			 T_MFW_CM_CALL_STAT *stat,
+			 UBYTE *ton,
+			 UBYTE *mode)
+{
+    int i;
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	allocat memory
+#ifdef FF_MMI_OPTIM
+	T_ACI_CAL_ENTR 	    *call_tab;//[MAX_CALL_NR];
+	call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+	if( NULL == call_tab)
+		return CM_ERROR;
+#endif	
+
+    if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) EQ AT_CMPL)
+    {
+	for (i=0; i<MAX_CALL_NR; i++)
+	{
+	    if (call_tab[i].index == -1)
+	    break;
+
+	    if (call_tab[i].index == call_number)
+	    {
+		*stat = cm_cvt_call_status(call_tab[i].status);
+		*ton = phb_cvtTon(call_tab[i].type.ton);
+		*mode = cm_cvt_call_mode(call_tab[i].calMode);
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	deallocate memory
+#ifdef FF_MMI_OPTIM
+			    if(call_tab)
+			    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif
+
+		return CM_OK;
+	    }
+	}
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	this will be returned once we get out of the if statement
+#ifndef FF_MMI_OPTIM
+	return CM_ERROR;
+#endif		
+    }
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	    
+//  deallocate memory  
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif    
+    return CM_ERROR;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_check_emergency  |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Check emergency call number
+
+*/
+
+T_MFW cm_check_emergency(UBYTE *number)
+{
+  //UBYTE 	    index; // RAVI
+ // T_MFW_PHB_TEXT    findText;  // RAVI
+ // T_MFW_PHB_ENTRY   entry;  // RAVI
+
+  TRACE_FUNCTION ("cm_check_emergency()");
+  TRACE_EVENT_P1("String being passed = %s", (char*)number);
+
+  if (strlen((char *)number) <= 0 OR strlen((char *)number) > 3)
+    return FALSE;
+
+  if(psaCC_phbSrchECC((char*)number, FALSE))
+  	{
+  		TRACE_EVENT("psaCC_phbSrchECC - returned - TRUE");
+  		return TRUE;
+	}
+  else
+  	{
+  	  	TRACE_EVENT("psaCC_phbSrchECC - returned - FALSE");
+	 	return FALSE;
+  	}
+
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_mo_prefix	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : set/get CLIP, CLIR, COLP and COLR tempstatus
+
+*/
+
+T_CM_CLI cm_mo_prefix(T_CM_CLI prefix)
+{
+	UBYTE bits;
+
+  if ((bits = (prefix & 0x0c)) != 0)
+    cli_prefix = (cli_prefix & 0xf3) | bits;
+  if ((bits = (prefix & 0xc0)) != 0)
+    cli_prefix = (cli_prefix & 0x3f) | bits;
+	return cli_prefix;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_set_cmd_status   |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :
+
+*/
+
+void cm_set_cmd_status(T_ACI_CHLD_MOD mode, CHAR* call)
+{
+    SHORT id;
+    // Added xkundadu MMI-SPR 13873
+    // Stores the status of a particular call.
+    T_MFW_CM_STATUS status;
+
+    TRACE_FUNCTION("cm_set_cmd_status()");  // Marcus: CCBS: 14/11/2002
+
+    memset(&dis_connect, 0, sizeof(T_MFW_CM_DISCONNECT));
+    memset(&cmd, 0, sizeof(T_MFW_CM_COMMAND));
+    switch (mode)
+    {
+	case CHLD_MOD_RelHldOrUdub:
+        TRACE_EVENT("CHLD_MOD_RelHldOrUdub");       // Marcus: CCBS: 14/11/2002
+	     /*SPR#1965 - DS - Changed from MFW_CM_MT_REJECT to MFW_CM_TERMINATED because
+             * the E_CM_DISCONNECT signal is not sent in cm_ok_disconnect() if cmd_hold = MFW_CM_MT_REJECT.
+             * Port of 1962.
+             */
+            cmd_hold = MFW_CM_TERMINATED;
+
+	    if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)
+	    {
+            TRACE_EVENT("cm_search_callId(CAL_STAT_Wait, &id) == CM_OK");       // Marcus: CCBS: 14/11/2002
+		    dis_connect.call_number = id;
+	    }
+	    else
+	    {
+            	   TRACE_EVENT("cm_search_callId(CAL_STAT_Wait, &id) != CM_OK");       // Marcus: CCBS: 14/11/2002
+		    dis_connect.call_number = -1;	// call id?
+	    }
+				
+	    break;
+	case CHLD_MOD_RelActAndAcpt:
+
+		TRACE_EVENT("CHLD_MOD_RelActAndAcpt");       // Marcus: CCBS: 14/11/2002
+	        cmd_hold = MFW_CM_1_SEND;
+	
+		// Added xkundadu MMI-SPR 13873
+		// Querying if there are any active calls, storing the index of the 
+		// call and setting a flag if found to be multiparty.
+		if (cm_search_callId(CAL_STAT_Active, &id) == CM_OK)
+		{
+			// Active call is present.
+			dis_connect.call_number = id;	// call id ?
+			cm_status(id, &status, 1);
+			if (status.mtpy EQ MFW_MTPY_MEMBER)
+			{
+				bIsMultpty = TRUE;
+			}
+			else
+			{
+				bIsMultpty = FALSE;
+			}
+		
+		}
+		else
+		{
+			dis_connect.call_number = -1;	
+		}
+		// Added xkundadu MMI-SPR 13873
+		// Querying if there are any held calls, storing the index of the call
+		// to change the status to active call. 
+		if (cm_search_callId(CAL_STAT_Held, &id) == CM_OK)
+		{
+			cmd.command     = CM_RETRIEVE;
+			cmd.call_number = id;
+		}
+		// Added xkundadu MMI-SPR 13873
+		// Checking is there any waiting call exists or not.
+		if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)
+		{
+			// This variable determines whether to accept/reject the call
+			// in the cm_result_cmd().
+			cmd.call_number=0;
+		}
+		else
+		{
+			cmd.call_number=-1;
+		}
+		
+	    break;
+		
+	case CHLD_MOD_RelActSpec:
+        TRACE_EVENT("CHLD_MOD_RelActSpec");       // Marcus: CCBS: 14/11/2002
+	    dis_connect.call_number = (SHORT)atoi(call);
+	    if (dis_connect.call_number)
+	    {
+            TRACE_EVENT("dis_connect.call_number");       // Marcus: CCBS: 14/11/2002
+            cmd_hold = MFW_CM_TERMINATED;
+	    }
+		else
+		{
+            TRACE_EVENT("!dis_connect.call_number");       // Marcus: CCBS: 14/11/2002
+		    cmd_hold = MFW_CM_MPTY_TERMINATED;
+		}
+	    break;
+	case CHLD_MOD_HldActAndAcpt:
+        TRACE_EVENT("CHLD_MOD_HldActAndAcpt");       // Marcus: CCBS: 14/11/2002
+	    if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)
+	    {
+            TRACE_EVENT("cm_search_callId(CAL_STAT_Wait, &id) == CM_OK");       // Marcus: CCBS: 14/11/2002
+    		cmd_hold    = MFW_CM_MT_ACCEPT;
+    		/*
+    		 * initialize for result event
+    		 */
+    		cmd.command = CM_HOLD;
+    		cc_id	    = id;
+	    }
+	    else
+	    {
+            TRACE_EVENT("cm_search_callId(CAL_STAT_Wait, &id) != CM_OK");       // Marcus: CCBS: 14/11/2002
+    		if ((cm_search_callId(CAL_STAT_Active, &id) == CM_OK)
+    		    AND (cm_search_callId(CAL_STAT_Held, &id) == CM_OK))
+    		{
+                TRACE_EVENT("cmd.command = CM_SWAP");       // Marcus: CCBS: 14/11/2002
+    		    cmd.command = CM_SWAP;
+    		}
+    		if ((cm_search_callId(CAL_STAT_Active, &id) != CM_OK)
+    		    AND (cm_search_callId(CAL_STAT_Held, &id) == CM_OK))
+    		{
+                TRACE_EVENT("cmd.command = CM_RETRIEVE");       // Marcus: CCBS: 14/11/2002
+    		    cmd.command = CM_RETRIEVE;
+    		}
+    		if ((cm_search_callId(CAL_STAT_Active, &id) == CM_OK)
+    		    AND (cm_search_callId(CAL_STAT_Held, &id) != CM_OK))
+    		{
+                TRACE_EVENT("cmd.command = CM_HOLD");       // Marcus: CCBS: 14/11/2002
+    		    cmd.command = CM_HOLD;
+    		}
+    		cmd.call_number = 0;
+	    }
+	    break;
+	case CHLD_MOD_HldActExc:
+        TRACE_EVENT("CHLD_MOD_HldActExc");       // Marcus: CCBS: 14/11/2002
+	    cmd.command = CM_SPLIT_MULTIPARTY;
+	    cmd.call_number = 0;
+	    break;
+	case CHLD_MOD_AddHld:
+        TRACE_EVENT("CHLD_MOD_AddHld");       // Marcus: CCBS: 14/11/2002
+	    cmd.command = CM_BUILD_MULTIPARTY;
+	    cmd.call_number = 0;
+	    break;
+	case CHLD_MOD_Ect:
+        TRACE_EVENT("CHLD_MOD_Ect");       // Marcus: CCBS: 14/11/2002
+	    cmd.command = CM_ETC;
+	    cmd.call_number = 0;
+	    break;
+	case CHLD_MOD_Ccbs:
+        TRACE_EVENT("CHLD_MOD_Ccbs");       // Marcus: CCBS: 14/11/2002
+	    cmd.command = CM_CCBS;
+	    cmd.call_number = 0;
+	    break;
+	case CHLD_MOD_HldActDial:
+        TRACE_EVENT("CHLD_MOD_HldActDial");       // Marcus: CCBS: 14/11/2002
+	    cmd_hold = MFW_CM_HOLD_AND_DIAL;
+	    /*
+	     * initialize for result event
+	     */
+	    cmd.command = CM_HOLD;
+	    cc_id	= id;
+	    break;
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_check_mo_number  |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : start mobile originated call
+
+*/
+
+T_MFW cm_check_mo_number(UBYTE *number)
+{
+  UBYTE i;
+//	Apr 14, 2005	REF: CRR 29991   xpradipg
+//	local definition
+  #ifdef FF_MMI_OPTIM
+  UBYTE count = 0;
+  UBYTE blackListNum[MFW_NUM_LEN];
+  int8 file;
+  #endif
+
+  /* check whether a redialing exists */
+  if (call_stat EQ REDIALING_CALL)
+  {
+    cm_stop_redialTim();
+    rdl.redial_mode = CM_REDIAL_OUTGOING;
+    cm_signal(E_CM_REDIAL, &rdl);
+  }
+
+
+  if (!number)
+    return CM_OK;
+//	Apr 14, 2005	REF: CRR 29991   xpradipg
+//	the list is read from the file
+#ifdef FF_MMI_OPTIM
+	if((	file = flash_MMI_blackList_open()) > 0)
+	{
+		if(flash_MMI_blackList_read(file,(U8*)&count,1,0) > 0)
+		{
+			for(i=0; i < (int)count; i++)
+			{
+				if(flash_MMI_blackList_read(file,(U8*)blackListNum,MFW_NUM_LEN,(i*MFW_NUM_LEN)+1) > 0)
+				{
+					if(!strcmp((char*)blackListNum, (char*)number))
+					{
+						flash_MMI_blackList_close(file);
+						return CM_BLACKLIST;
+					}
+				}
+			}
+		}
+		flash_MMI_blackList_close(file);
+	}
+#else	
+	  /* check whether this number is in blacklist */
+	  for (i=0; i<black_list.count; i++)
+	  {
+	    if (!strcmp((char *)black_list.number[i], (char *)number))
+	      return CM_BLACKLIST;
+	  }
+#endif	
+
+  /* check the type of this number */
+  if (cm_check_emergency(number) EQ TRUE)
+    call_type = MFW_ECC_CALL;
+  else
+    call_type = MFW_NORMAL_CALL;
+
+  return CM_OK;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_set_call_mode    |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : set call mode
+
+*/
+
+void cm_set_call_mode(T_MFW_CM_CALL_TYPE mode)
+{
+  switch (mode)
+  {
+    case VOICE_CALL:
+    case AuxVOICE_CALL: /*MC, SPR 1026, assume line 2 is handled like line 1*/
+    case DATA_CALL:
+    case FAX_CALL:
+      sAT_PlusCMOD(CMD_SRC_LCL, CMOD_MOD_Single);
+      break;
+    case VFD_VOICE:
+    case VFD_DATA:
+      sAT_PlusCMOD(CMD_SRC_LCL, CMOD_MOD_VoiceFlwdDat);
+      break;
+    case VAD_VOICE:
+    case VAD_DATA:
+      sAT_PlusCMOD(CMD_SRC_LCL, CMOD_MOD_VoiceDat);
+      break;
+    case VAF_VOICE:
+    case VAF_FAX:
+      sAT_PlusCMOD(CMD_SRC_LCL, CMOD_MOD_VoiceFax);
+      break;
+    default:
+      break;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_mo_idx	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : start mobile originated call
+
+*/
+
+T_MFW cm_mo_idx(T_KSD_SEQPARAM *para, T_MFW_CM_CALL_TYPE mode)
+{
+  T_MFW_PHB_LIST entries;
+  T_MFW_PHB_ENTRY   entry;
+  UBYTE 	    res;
+
+//RM 19_09_2000
+#ifdef NO_ASCIIZ
+  T_ACI_PB_TEXT mfwpbText;
+#endif
+//RM
+
+  entries.entry = &entry;
+
+  /* search this number from phonebook */
+  if ((phb_read_entries(PHB_ADN, (UBYTE)para->dialIdx.index,
+			MFW_PHB_INDEX, 1,
+			&entries) EQ MFW_PHB_OK)
+      AND ((int)entries.num_entries > 0))
+  {
+    res = cm_check_mo_number(entries.entry->number);
+    if (res NEQ CM_OK)
+      return res;
+  }
+  else
+  {
+    res = cm_check_mo_number(0);
+    if (res NEQ CM_OK)
+      return res;
+  }
+
+  /* set the outgoing call status */
+  call_stat	 = OUTGOING_CALL;
+  redial_count	 = 0;
+  cc_stat.type	 = OUTGOING_CALL;
+
+  cm_set_call_mode(mode);
+
+//RM 19_09_2000 instead change in ksd structure T_KSD_SEQPARAM etc., later to change !!!!
+#ifdef NO_ASCIIZ
+	if(para->dialIdx.str NEQ NULL)
+	{
+		mfwpbText.cs = CS_GsmDef;
+		mfwpbText.len = strlen(para->dialIdx.str);
+		memcpy(mfwpbText.data,para->dialIdx.str,mfwpbText.len);
+	}
+	else
+	{
+		mfwpbText.cs = CS_NotPresent;
+		mfwpbText.len = 0;
+	}
+	res = sAT_Dm(CMD_SRC_LCL, &mfwpbText,
+			   para->dialIdx.mem, para->dialIdx.index,
+			   para->dialIdx.clirOvrd, para->dialIdx.cugCtrl,
+			   para->dialIdx.callType);
+#else
+	res = sAT_Dm(CMD_SRC_LCL, para->dialIdx.str,
+			   para->dialIdx.mem, para->dialIdx.index,
+			   para->dialIdx.clirOvrd, para->dialIdx.cugCtrl,
+			   para->dialIdx.callType);
+#endif
+
+  if ((res == AT_FAIL) OR (res == AT_BUSY))
+  {
+    call_stat	 = MFW_CALL_FREE;
+	  return cm_error_code(AT_CMD_D);
+  }
+
+  return CM_OK;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_mo_call	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : start mobile originated call
+
+*/
+
+T_MFW cm_mo_call(UBYTE *number, T_MFW_CM_CALL_TYPE type)
+{
+  CHAR			   * rest;
+  T_KSD_SEQPARAM	     para;
+  T_MFW_SS_RETURN	     typ;
+  T_MFW_SS_RETURN	     new_typ;
+  CHAR			   * string;
+  UBYTE 		     cm_grp = 0;  // RAVI
+  UBYTE 		     clir_status;
+  UBYTE 		     colr_status;
+  UBYTE 		     prefix;
+  char			     buf[80];
+  UBYTE 		     phone[MFW_NUM_LEN];
+  UBYTE 		     num_save[MFW_STRING_LEN];
+  SHORT 		     id;
+  T_ACI_RETURN		     res,aci_result;//aci_result was added to fix the bug MMI-SPR 16545
+
+  TRACE_FUNCTION ("cm_mo_call()");
+
+  strncpy((char *)num_save, (char *)number, MFW_STRING_LEN-1);
+  num_save[MFW_STRING_LEN-1] = 0;
+
+  /* check the type of number (key sequence), current no function */
+  typ = ss_decode(number, &rest, &para);
+  TRACE_EVENT_P1("Type: %d", typ);
+  if (typ == MFW_SS_DIAL)
+	{
+	mfwStrncpy((char *)phone, para.dial.number, MFW_NUM_LEN);
+
+	}
+
+  if (typ == MFW_SS_HOLD)
+  {
+    cm_set_cmd_status(para.chld.mode, para.chld.call);
+
+    // Feb 27, 2006    REF:DR OMAPS00067884  x0039928	
+    // Fix :  sAT_PercentCHLD() is called if the mode > CHLD_MOD_RelDialCall
+    if(para.chld.mode > CHLD_MOD_RelDialCall)
+	aci_result = sAT_PercentCHLD(CMD_SRC_LCL, para.chld.mode, para.chld.call);
+    else
+	aci_result = sAT_PlusCHLD(CMD_SRC_LCL, para.chld.mode, para.chld.call);
+	
+	//  Apr 26, 2004 REF: CRR 16545 Ajith K P
+	//  If sAT_PlusCHLD() Fails, Send the user entered string as USSD to network using sAT-Dn().
+	//  So if its not failed just return CM_CTRL_STR, otherwise call sAT_Dn().	
+    if ( (aci_result  EQ AT_CMPL ) OR (aci_result  EQ AT_EXCT ) OR (aci_result  EQ AT_BUSY ))
+    {
+		return CM_CTRL_STR;
+	}
+  }
+  //MC 11.04.02
+  if (typ == MFW_SS_ECT)
+  {
+	cm_set_cmd_status(para.chld.mode, para.chld.call);
+	if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_Ect, 0) != AT_EXCT)
+	{
+		//Aug 10, 2005   REF: MMI-SPR-30099 x0018858
+		//commented this return value.
+		//	return CM_ERROR;
+	}
+	else
+		return CM_CTRL_STR;
+  }
+  //MC
+
+  if (typ == MFW_SS_DIAL_IDX)
+  {
+      return cm_mo_idx(&para, type);
+  }
+
+  switch (typ)
+  {
+
+//NM
+    case MFW_SS_CLIR: //jgg wrong not CM_OK should be CM_SS, however cm_grp not used after funtion callnumber called
+
+    case MFW_SS_DIAL:
+      cm_grp = CM_OK;
+      break;
+
+    case MFW_SS_DTMF:
+    case MFW_SS_CF:
+    case MFW_SS_CB:
+    case MFW_SS_CLIP:
+    case MFW_SS_COLR:
+    case MFW_SS_COLP:
+    case MFW_SS_WAIT:
+    case MFW_SS_HOLD:
+    case MFW_SS_CCBS:
+    case MFW_SS_REG_PW:
+//Aug 10, 2005   REF: MMI-SPR-30099 x0018858
+//Added this case statement.
+    case MFW_SS_ECT:
+      cm_grp = CM_SS;
+      break;
+
+    case MFW_SS_USSD:
+      cm_grp = CM_USSD;
+      break;
+
+    case MFW_SS_SIM_LOCK:
+    case MFW_SS_SIM_REG_PW:
+    case MFW_SS_SIM_UNBLCK_PIN:
+      cm_grp = CM_SIM;
+      break;
+
+    case MFW_SS_MMI:
+      cm_grp = CM_MMI;
+      break;
+
+/* SPR#1352 - SH - TTY
+ * If an SS string has been entered, temporarily enable or disable
+ * TTY for this call only. */
+
+	case MFW_SS_TTY_NEXTCALL_ON:
+	case MFW_SS_TTY_NEXTCALL_OFF:
+		{
+			if (typ==MFW_SS_TTY_NEXTCALL_ON)
+			{
+				cm_tty_enable(TRUE);
+			}
+			else
+			{
+				cm_tty_enable(FALSE);
+			}
+
+	      	strcpy((char *)num_save, (char *)&num_save[4]); /* Ignore SS string when dialling */
+			rest = (char *)&number[4];	/* Look at number following SS string */
+		}
+		break;
+/* SH end */
+
+    default:
+      return CM_ERROR;
+  }
+
+  string = rest;
+  clir_status = 0;
+  colr_status = 0;
+  buf[0] = '\0';
+  cc_stat.prefix[0] = '\0';
+  while(strlen(string))
+  {
+  	TRACE_EVENT("In the while");
+    new_typ = ss_decode((UBYTE *)string, &rest, &para);
+// /*
+    if (new_typ == MFW_SS_CLIR)
+    {
+      clir_status = 1;
+      if (para.Clir.mode == CLIR_MOD_Supp)
+	  {
+	    strcat((char *)cc_stat.prefix, "*31#");
+	    TRACE_EVENT ("CLIR_MOD_Supp");
+	  }
+      if (para.Clir.mode == CLIR_MOD_Invoc)
+	  {
+	    strcat((char *)cc_stat.prefix, "#31#");
+		TRACE_EVENT ("CLIR_MOD_Invoc");
+      }
+    }
+    if (new_typ == MFW_SS_COLR)
+      colr_status = 1;
+    if (new_typ == MFW_SS_DIAL)
+    {
+    	TRACE_EVENT("It's a dial");
+	  /* SPR#1352 - SH - only copy string to dial, not whole string */
+      if (typ==MFW_SS_TTY_NEXTCALL_ON || typ==MFW_SS_TTY_NEXTCALL_OFF)
+      {
+      	typ = new_typ;
+      	TRACE_EVENT_P1("phone now holds: %s", phone);
+      }
+      else
+      /* end SH */
+      {
+      	typ = new_typ;
+      	mfwStrncpy((char *)phone, para.dial.number, MFW_NUM_LEN);
+      }
+    }
+    string = rest;
+  }
+
+  if (!colr_status AND (typ == MFW_SS_DIAL))
+  {
+    prefix = cli_prefix & 0xc0;
+    if (prefix == 0x80)
+    {
+      strcat(buf, "*77#");
+      strcat((char *)cc_stat.prefix, "*77#");
+    }
+    if (prefix == 0xc0)
+    {
+      strcat(buf, "#77#");
+      strcat((char *)cc_stat.prefix, "#77#");
+    }
+  }
+
+  if (typ == MFW_SS_DIAL)
+  {
+    res = (T_ACI_RETURN)cm_check_mo_number(phone);
+    if ( res != CM_OK)
+	return res;
+
+    /* set the outgoing call status */
+    call_stat	   = OUTGOING_CALL;
+    redial_count   = 0;
+    cc_stat.type   = OUTGOING_CALL;
+    cm_grp = CM_OK;
+    currConnecting = 1;
+    cm_set_call_mode(type);
+  }
+
+  strcat(buf, (char *)num_save);
+  if (cm_search_callId(CAL_STAT_Active, &id) EQ CM_OK)
+  {
+    /*
+     * at least one active, this must be put on hold
+     * by ACI first, then dial
+     */
+    cm_set_cmd_status(CHLD_MOD_HldActDial, "");
+    cc_id = id;
+  }
+  if (type == DATA_CALL)
+	para.dial.callType = D_TOC_Data;
+
+//  Apr 22, 2004        REF: CRR MMI-SPR-16873  Rashmi C N(Sasken) 
+//		Using the CLIR status maintained in the flash, while making a call
+	if (!FFS_flashData.CLIR)
+	{
+		res = sAT_Dn(CMD_SRC_LCL, buf, D_CLIR_OVRD_Supp, -1, para.dial.callType);
+	}
+	else 
+	{
+		res = sAT_Dn(CMD_SRC_LCL, buf, D_CLIR_OVRD_Invoc, -1, para.dial.callType);
+	}
+	
+  if ((res == AT_FAIL) OR (res == AT_BUSY))
+  {
+    if (typ == MFW_SS_CLIP)
+      return CM_CLI;
+
+    call_stat	 = MFW_CALL_FREE;
+	  return cm_error_code(AT_CMD_D);
+  }
+  if (res == AT_CMPL)
+  {
+	switch (typ)
+	{
+	  case MFW_SS_CLIR:
+      case MFW_SS_CLIP:
+      case MFW_SS_COLR:
+      case MFW_SS_COLP:
+	return CM_CLI;
+      default:
+	break;
+    }
+  }
+  return cm_grp;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: GSM-MFW (8417)		MODULE:  MFW_CB 	     |
+| STATE  : code 			ROUTINE: rAT_PlusCRING_OFF   |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :   Alert Off indication from ACI
+
+*/
+
+#ifdef FF_2TO1_PS
+GLOBAL void rAT_PlusCRING_OFF ( SHORT cId )
+{
+    T_MFW_CM_CALL_STAT stat;
+    UBYTE	       ton;
+    T_CAUSE_ps_cause report;  /* Marcus: Extended error reporting: 12/11/2002 */
+    UBYTE	       mode;
+
+    TRACE_FUNCTION ("rAT_PlusCRING_OFF()");
+
+    if (cm_search_callStat(cId, &stat, &ton, &mode) == CM_OK)
+    {
+	call_stat = MFW_CALL_FREE;
+	call_type = MFW_CALL_FREE;
+
+	if (stat == CALL_DEACTIVE)
+	{
+	    dis_connect.call_number = cId;
+
+	    qAT_PlusCEER( CMD_SRC_LCL, &report);
+        /* Marcus: Extended error reporting: 12/11/2002: Start */
+
+//        TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report);
+        if (report.ctrl_value != CAUSE_is_from_nwcc)
+        {
+            /* Treat Condat defined cause values as if no cause given */
+            dis_connect.cause = NOT_PRESENT_8BIT;
+        }
+        else
+        {
+            /* Standards defined cause value is given */
+            dis_connect.cause = report.value.nwcc_cause;
+        }
+        TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
+        /* Marcus: Extended error reporting: 12/11/2002: End */
+	    cm_signal(E_CM_DISCONNECT, &dis_connect);
+	    return;
+	}
+	cm_signal(E_CM_RING_OFF, 0);
+    }
+}
+#else
+GLOBAL void rAT_PlusCRING_OFF ( SHORT cId )
+{
+    T_MFW_CM_CALL_STAT stat;
+    UBYTE	       ton;
+    USHORT	       report;  /* Marcus: Extended error reporting: 12/11/2002 */
+    UBYTE	       mode;
+
+    TRACE_FUNCTION ("rAT_PlusCRING_OFF()");
+
+    if (cm_search_callStat(cId, &stat, &ton, &mode) == CM_OK)
+    {
+	call_stat = MFW_CALL_FREE;
+	call_type = MFW_CALL_FREE;
+
+	if (stat == CALL_DEACTIVE)
+	{
+	    dis_connect.call_number = cId;
+
+	    qAT_PlusCEER( CMD_SRC_LCL, &report);
+        /* Marcus: Extended error reporting: 12/11/2002: Start */
+        TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report);
+        if (GET_CAUSE_DEFBY(report) == DEFBY_CONDAT)
+        {
+            /* Treat Condat defined cause values as if no cause given */
+            dis_connect.cause = NOT_PRESENT_8BIT;
+        }
+        else
+        {
+            /* Standards defined cause value is given */
+            dis_connect.cause = GET_CAUSE_VALUE(report);
+        }
+        TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
+        /* Marcus: Extended error reporting: 12/11/2002: End */
+	    cm_signal(E_CM_DISCONNECT, &dis_connect);
+	    return;
+	}
+	cm_signal(E_CM_RING_OFF, 0);
+    }
+}
+#endif
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	     |
+| STATE   : code			 ROUTINE : rAT_PlusCRING     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Alert indication from ACI
+
+*/
+
+void rAT_PlusCRING(T_ACI_CRING_MOD mode,
+		   T_ACI_CRING_TYP type1,
+		   T_ACI_CRING_TYP type2)
+{
+  SHORT call_number;
+
+  TRACE_FUNCTION ("rAT_PlusCRING()");
+
+  in_call.result = Present;
+
+  /* search the call identifier */
+  if (cm_search_callId(CAL_STAT_Wait, &call_number) == CM_OK)
+    in_call.call_number = call_number;
+  else
+    in_call.call_number = 0;
+
+  /* If redial is active, it must be stoped. */
+  if (call_stat == REDIALING_CALL)
+  {
+    cm_stop_redialTim();
+    rdl.redial_mode = CM_REDIAL_INCOMING;
+    cm_signal(E_CM_REDIAL, &rdl);
+  }
+
+  if (mode EQ CRING_MOD_Direct)
+  {
+    switch (type1)
+    {
+	    /* Voice call */
+      case CRING_TYP_Voice:
+	if (type2 EQ CRING_TYP_NotPresent)
+	{
+	  in_call.type = VOICE_CALL;
+	  cm_set_call_mode(VOICE_CALL);
+	}
+	else
+	{
+	  switch (type2)
+	  {
+	    case CRING_TYP_Sync:
+	    case CRING_TYP_Async:
+	    case CRING_TYP_RelSync:
+	    case CRING_TYP_RelAsync:
+	      in_call.type = VFD_VOICE;
+	      cm_bc_parameter(type2);
+	      cm_set_call_mode(VFD_VOICE);
+	      break;
+	      /*MC, SPR 1026, check for line1 and line2*/
+	    case CRING_TYP_Voice:
+	      in_call.type = VOICE_CALL;
+	      cm_set_call_mode(VOICE_CALL);
+	      break;
+	    case CRING_TYP_AuxVoice:
+	      cm_set_call_mode(AuxVOICE_CALL);
+	      in_call.type = AuxVOICE_CALL;
+	      break;
+	      /*MC, end*/
+	    default:
+	      in_call.type = VOICE_CALL;
+	      cm_set_call_mode(VOICE_CALL);
+	      break;
+	  }
+	}
+	break;
+	/*MC, SPR 1026, Added case of Type1=CRING_TYP_AuxVoice*/
+	/*assuming  line 2 is handled like line 1*/
+      case CRING_TYP_AuxVoice:
+	if (type2 EQ CRING_TYP_NotPresent)
+	{
+	  in_call.type = AuxVOICE_CALL;
+	  cm_set_call_mode(AuxVOICE_CALL);
+	}
+	else
+	{
+	  switch (type2)
+	  {
+	    case CRING_TYP_Sync:
+	    case CRING_TYP_Async:
+	    case CRING_TYP_RelSync:
+	    case CRING_TYP_RelAsync:
+	      in_call.type = VFD_VOICE;
+	      cm_bc_parameter(type2);
+	      cm_set_call_mode(VFD_VOICE);
+	      break;
+	    case CRING_TYP_Voice:
+	      in_call.type = VOICE_CALL;
+	      cm_set_call_mode(VOICE_CALL);
+	      break;
+	    case CRING_TYP_AuxVoice:
+	      cm_set_call_mode(AuxVOICE_CALL);
+	      in_call.type = AuxVOICE_CALL;
+	      break;
+	    default:
+	      in_call.type = VOICE_CALL;
+	      cm_set_call_mode(VOICE_CALL);
+	      break;
+	  }
+	}
+	break;
+	/*MC, end*/
+	    /* Data call */
+	    case CRING_TYP_Sync:
+      case CRING_TYP_Async:
+      case CRING_TYP_RelSync:
+      case CRING_TYP_RelAsync:
+		    in_call.type = DATA_CALL;
+	cm_bc_parameter(type1);
+	cm_set_call_mode(DATA_CALL);
+		    break;
+
+      case CRING_TYP_Fax:
+		    in_call.type = FAX_CALL;
+	in_call.bc1.conn_elem	= Transparent;
+	cm_set_call_mode(FAX_CALL);
+		  break;
+
+      default:
+		    in_call.result = NotPresent;
+	break;
+    }
+    call_stat = INCOMING_CALL;
+  }
+
+  if (mode EQ CRING_MOD_Alternate)
+  {
+	  cm_build_callType(type1, type2);
+    cm_bc_parameter(type1);
+    cm_bc_parameter(type2);
+    cm_set_call_mode(in_call.type);
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: rAT_PlusCLIP	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : The calling line identification for an incomming call.
+
+*/
+
+#ifdef NO_ASCIIZ
+void rAT_PlusCLIP(T_ACI_CLIP_STAT   stat,
+		  CHAR		  * number,
+		  T_ACI_TOA	  * type,
+		  U8		    validity,
+		  CHAR		  * subaddr,
+		  T_ACI_TOS	  * satype,
+		  T_ACI_PB_TEXT   * alpha)
+{
+  int flag;
+
+  TRACE_FUNCTION ("rAT_PlusCLIP()");
+
+  flag = 0;
+
+  if (number != NULL)
+  {
+    mfwStrncpy((char *)in_call.number,  (char *)number, MFW_NUM_LEN);
+    in_call.ton = phb_cvtTon(type->ton);
+    flag = 1;
+  }
+  else
+    memset(in_call.number, '\0', MFW_NUM_LEN);
+
+  if (alpha != NULL)
+  {
+    in_call.name.len = alpha->len;
+	if (alpha->len)
+    {
+     memcpy(in_call.name.data,
+	    alpha->data,
+	    alpha->len);
+     flag = 1;
+    }
+  }
+  else
+    in_call.name.len = 0;
+
+
+  if (subaddr != NULL)
+  {
+    mfwStrncpy((char *)in_call.subaddr, (char *)subaddr, MFW_SUBADR_LEN);
+    flag = 1;
+  }
+  else
+    memset(in_call.subaddr, '\0', MFW_SUBADR_LEN);
+
+  if (flag == 1)
+    in_call.result = Present;
+  else
+    in_call.result = 0;
+
+  cm_signal(E_CM_CW, &in_call);
+}
+
+#else
+
+void rAT_PlusCLIP(T_ACI_CLIP_STAT   stat,
+		  CHAR		  * number,
+		  T_ACI_TOA	  * type,
+		  U8		    validity,
+		  CHAR		  * subaddr,
+		  T_ACI_TOS	  * satype,
+		  CHAR		  * alpha)
+{
+  int flag;
+
+  TRACE_FUNCTION ("rAT_PlusCLIP()");
+
+  flag = 0;
+//  in_call.result = 0;
+
+  if (number != NULL)
+  {
+    mfwStrncpy((char *)in_call.number,  (char *)number, MFW_NUM_LEN);
+    in_call.ton = phb_cvtTon(type->ton);
+    flag = 1;
+  }
+  else
+    memset(in_call.number, '\0', MFW_NUM_LEN);
+
+  if (alpha != NULL)
+  {
+    mfwStrncpy((char *)in_call.name,    (char *)alpha, MFW_TAG_LEN);
+    flag = 1;
+  }
+  else
+    memset(in_call.name, '\0', MFW_TAG_LEN);
+
+  if (subaddr != NULL)
+  {
+    mfwStrncpy((char *)in_call.subaddr, (char *)subaddr, MFW_SUBADR_LEN);
+    flag = 1;
+  }
+  else
+    memset(in_call.subaddr, '\0', MFW_SUBADR_LEN);
+
+  if (flag == 1)
+    in_call.result = Present;
+  else
+    in_call.result = 0;
+
+  cm_signal(E_CM_CW, &in_call);
+}
+#endif
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-MFW (8417)		 MODULE  :  MFW_CM	     |
+| STATE   : code			 ROUTINE : rAT_PlusCOLP      |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :   Connected line presentation indication from ACI
+
+*/
+
+#ifdef NO_ASCIIZ
+GLOBAL void rAT_PlusCOLP  ( T_ACI_COLP_STAT stat,
+			    CHAR* number,
+			    T_ACI_TOA* type,
+			    CHAR* subaddr,
+			    T_ACI_TOS* satype,
+			    T_ACI_PB_TEXT* alpha)
+{
+
+  TRACE_FUNCTION ("rAT_PlusCOLP()");
+
+  if (number != NULL)
+  {
+    mfwStrncpy((char *)out_call.number, (char *)number, MFW_NUM_LEN);
+    out_call.ton = phb_cvtTon(type->ton);
+  }
+  else
+    memset(out_call.number, '\0', MFW_NUM_LEN);
+
+  /*NM, p001  */
+  if(alpha != NULL)
+  /*NM, p001 end */
+  {
+  out_call.name.len = MINIMUM(alpha->len, MFW_TAG_LEN);
+  if (alpha->len)
+    memcpy(out_call.name.data,
+	   alpha->data,
+	   alpha->len);
+  }
+
+  if (subaddr != NULL)
+    mfwStrncpy((char *)out_call.subaddr, (char *)subaddr, MFW_SUBADR_LEN);
+  else
+    memset(out_call.subaddr, '\0', MFW_SUBADR_LEN);
+
+  if (number != NULL)
+    cm_signal(E_CM_COLP, &out_call);
+}
+
+#else
+
+GLOBAL void rAT_PlusCOLP  ( T_ACI_COLP_STAT stat,
+			    CHAR* number,
+			    T_ACI_TOA* type,
+			    CHAR* subaddr,
+			    T_ACI_TOS* satype,
+			    CHAR* alpha)
+{
+  TRACE_FUNCTION ("rAT_PlusCOLP()");
+
+// patch PMA 15 06 99 from Andreas
+//  if (stat == -1)
+//    return;
+
+  if (number != NULL)
+  {
+    mfwStrncpy((char *)out_call.number, (char *)number, MFW_NUM_LEN);
+    out_call.ton = phb_cvtTon(type->ton);
+  }
+  else
+    memset(out_call.number, '\0', MFW_NUM_LEN);
+
+  if (alpha != NULL)
+    mfwStrncpy((char *)out_call.name, (char *)alpha, MFW_TAG_LEN);
+  else
+    memset(out_call.name, '\0', MFW_TAG_LEN);
+
+  if (subaddr != NULL)
+    mfwStrncpy((char *)out_call.subaddr, (char *)subaddr, MFW_SUBADR_LEN);
+  else
+    memset(out_call.subaddr, '\0', MFW_SUBADR_LEN);
+
+// patch PMA 15 06 99 from Andreas
+  if (number != NULL)
+	  cm_signal(E_CM_COLP, &out_call);
+}
+#endif
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-MFW (8417)		 MODULE  : MFW_CM	     |
+| STATE   : code			 ROUTINE : rAT_PlusCCWA      |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :   Connected line presentation indication from ACI
+
+*/
+
+#ifdef NO_ASCIIZ
+
+GLOBAL void rAT_PlusCCWA ( T_ACI_CLSSTAT * clsStatLst,
+			   CHAR 	 * number,
+			   T_ACI_TOA	 * type,
+			   U8		   validity,
+			   T_ACI_CLASS	   call_class,
+			   T_ACI_PB_TEXT * alpha)
+{
+    SHORT call_number;
+
+    TRACE_FUNCTION("rAT_PlusCCWA()");
+
+    in_call.result = NotPresent;
+    if (clsStatLst == 0)
+    {
+	if (number != NULL)
+	{
+	    mfwStrncpy((char *)in_call.number, (char *)number, MFW_NUM_LEN);
+	    in_call.ton = phb_cvtTon(type->ton);
+	}
+	else
+	    memset(in_call.number, '\0', MFW_NUM_LEN);
+
+	if (alpha != NULL)
+	  in_call.name.len = alpha->len;
+	else
+	  in_call.name.len = 0;
+
+	if (in_call.name.len)
+	{
+	    memcpy(in_call.name.data,
+		   alpha->data,
+		   alpha->len);
+	}
+
+	in_call.type = cm_callTyp_cvt(call_class);
+
+	if (number != 0 || in_call.name.len != 0 || in_call.type != NONE_TYPE)
+	    in_call.result = Present;
+
+	cm_search_callId(CAL_STAT_Wait, &call_number);
+	in_call.call_number = call_number;
+
+	cm_signal(E_CM_CW, &in_call);
+    }
+}
+
+#else
+
+GLOBAL void rAT_PlusCCWA ( T_ACI_CLSSTAT * clsStatLst,
+			   CHAR 	 * number,
+			   T_ACI_TOA	 * type,
+			   U8		   validity,
+			   T_ACI_CLASS	   call_class,
+			   CHAR 	 * alpha)
+{
+    SHORT call_number;
+
+    in_call.result = NotPresent;
+    if (clsStatLst == 0)
+    {
+	if (number != NULL)
+	{
+	    mfwStrncpy((char *)in_call.number, (char *)number, MFW_NUM_LEN);
+	    in_call.ton = phb_cvtTon(type->ton);
+	}
+	else
+	    memset(in_call.number, '\0', MFW_NUM_LEN);
+
+	if (alpha != NULL)
+	    mfwStrncpy((char *)in_call.name, (char *)alpha, MFW_TAG_LEN);
+	else
+	    memset(in_call.name, '\0', MFW_TAG_LEN);
+
+	in_call.type = cm_callTyp_cvt(call_class);
+
+	if (number != 0 || alpha != 0 || in_call.type != NONE_TYPE)
+	    in_call.result = Present;
+
+	cm_search_callId(CAL_STAT_Wait, &call_number);
+	in_call.call_number = call_number;
+
+	cm_signal(E_CM_CW, &in_call);
+    }
+}
+#endif
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	     |
+| STATE   : code			 ROUTINE : cm_mt_reject      |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Reject the incoming call.
+
+*/
+
+void cm_mt_reject()
+{
+    TRACE_FUNCTION ("cm_mt_reject()");
+
+    if (currAccepting)
+    {
+	currAccepting = 0; /* ES!! 210999 */
+	sAT_Abort(CMD_SRC_LCL, AT_CMD_A);
+	return;
+    }
+
+    cmd_hold = MFW_CM_MT_REJECT;
+    cm_search_callId(CAL_STAT_Wait, &dis_connect.call_number);
+    sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelHldOrUdub, 0);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_mt_accept	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Accept the incoming call. If the active call exists,
+	     place this active call on hold and accepts the
+	     waiting call.
+
+*/
+
+void cm_mt_accept()
+{
+    SHORT call_number;
+    T_MFW_CM_CALL_STAT	stat;	/* SPR#1983 - SH */
+    UBYTE		ton;
+    UBYTE		mode;
+
+    TRACE_FUNCTION ("cm_mt_accept()");
+
+    if (cm_search_callId(CAL_STAT_Active, &call_number) != CM_OK)
+    {
+		if (sAT_A(CMD_SRC_LCL) NEQ AT_EXCT)
+		{
+			TRACE_ERROR("sAT_A error");
+		}
+		else
+		{
+		    currAccepting = 1; /* ES!! 210999 */
+		}
+    }
+    else
+    {
+		cmd_hold = MFW_CM_MT_ACCEPT;
+
+		/* SPR#1983 - SH - Get status of active call */
+
+        cm_search_callStat(call_number, &stat, &ton, &mode);
+
+		if (cm_search_callId(CAL_STAT_Wait, &call_number) EQ CM_OK)
+		  cc_id = call_number;
+
+		/* SPR#1983 - SH - If data call is active, end it and accept other call */
+
+		if (mode==DATA_CALL)
+		{
+			/*
+             * Accepting a call when there is an active data call,
+             * so drop the active call and accept the waiting call by the
+             * equivalent of the AT+CHLD=1 command.
+             */
+            cm_set_cmd_status(CHLD_MOD_RelActAndAcpt, "");
+            if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActAndAcpt, 0) NEQ AT_EXCT)
+            {
+                TRACE_ERROR("sAT_PlusCHLD(CHLD_MOD_RelActAndAcpt) error");
+            }
+		}
+
+		else	/* SPR#1983 - SH - Important! Acts on next 'if' */
+
+        /* Marcus: issue 1049: 03/09/2002: Start */
+        if (cm_search_callId(CAL_STAT_Held, &call_number) EQ CM_OK)
+        {
+            /*
+             * Accepting a call when there is already an active call and a held
+             * call, so drop the active call and accept the waiting call by the
+             * equivalent of the AT+CHLD=1 command.
+             */
+            cm_set_cmd_status(CHLD_MOD_RelActAndAcpt, "");
+            if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActAndAcpt, 0) NEQ AT_EXCT)
+            {
+                TRACE_ERROR("sAT_PlusCHLD(CHLD_MOD_RelActAndAcpt) error");
+            }
+        }
+        else
+        {
+            /*
+             * Accepting a call when there is already an active call but no held
+             * call, so hold the active call and accept the waiting call by the
+             * equivalent of the AT+CHLD=2 command.
+             */
+            cm_set_cmd_status(CHLD_MOD_HldActAndAcpt, "");
+            if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_HldActAndAcpt, 0) NEQ AT_EXCT)
+            {
+                TRACE_ERROR("sAT_PlusCHLD(CHLD_MOD_HldActAndAcpt) error");
+            }
+        }
+        /* Marcus: issue 1049: 03/09/2002: End */
+	}
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)		MODULE  : MFW_CM			 |
+| STATE   : code						ROUTINE : cm_end_all		 |
++--------------------------------------------------------------------+
+
+
+	PURPOSE :  End all calls (Held and Active)
+
+*/
+
+void cm_end_all(void)
+{
+    T_ACI_RETURN    aci_res;        // The value returned by sAT_H
+
+    TRACE_EVENT("cm_end_all()");
+
+        aci_res = sAT_H(CMD_SRC_LCL);
+
+        if (aci_res == AT_EXCT)
+        {
+            TRACE_EVENT("sAT_H returned AT_EXCT");
+            cmd_hold = MFW_CM_DISCONNECT_ALL;
+        }
+        else
+        {
+            TRACE_EVENT_P1("sAT_H returned %d", aci_res);
+        }
+	return;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)		MODULE  : MFW_CM			 |
+| STATE   : code						ROUTINE : cm_ok_connect		 |
++--------------------------------------------------------------------+
+
+
+	PURPOSE :  The connect is successful.
+
+*/
+
+void cm_ok_connect(void)
+{
+    SHORT call_number;
+
+    TRACE_FUNCTION ("cm_ok_connect()");
+
+    currAccepting = 0; /* ES!! 210999 */
+    currConnecting = 0; /* ES!! 290999 */
+
+    if (cc_stat.type == REDIALING_CALL)
+    {
+	rdl.redial_mode = CM_REDIAL_SUCCESS;
+	cm_signal(E_CM_REDIAL, &rdl);
+    }
+
+    cm_search_callId(CAL_STAT_Active, &call_number);
+
+    /* allow a new outgoing */
+    call_stat = MFW_CALL_FREE;
+    call_type = MFW_CALL_FREE;
+    cmd_hold = MFW_CM_NO_FLAG;
+
+    cm_signal(E_CM_CONNECT_ACK, &call_number);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	     |
+| STATE   : code			 ROUTINE : cm_rmt_ok_connect |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  The connect is successful.
+
+*/
+
+void cm_rmt_ok_connect()
+{
+    SHORT call_number;
+
+    TRACE_FUNCTION ("cm_rmt_ok_connect()");
+
+    cm_search_callId(CAL_STAT_Active, &call_number);
+
+    cm_signal(E_CM_CONNECT_ACK, &call_number);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	     |
+| STATE   : code			 ROUTINE : cm_error_connect  |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : The connection is not successful
+
+*/
+
+#ifdef FF_2TO1_PS
+void cm_error_connect(SHORT call_number)
+{
+    int i;
+    T_CAUSE_ps_cause report; /* Marcus: Extended error reporting: 12/11/2002 */
+    USHORT extend_report; /* API - 1564 - 16-01-03 - add this variable to store the new error code */
+
+    TRACE_FUNCTION ("cm_error_connect()");
+
+    currAccepting = 0; /* ES!! 210999 */
+    currConnecting = 0; /* ES!! 290999 */
+
+    /* send event */
+    dis_connect.call_number = call_number;
+
+    qAT_PlusCEER( CMD_SRC_LCL, &report);
+    /* Marcus: Extended error reporting: 12/11/2002: Start */
+//    TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report);
+
+	/* API - 1564 - 16-01-03 - store the error value to the new variable & throughout this function replace 'report' with 'extend_report */
+    extend_report = report.value.nwcc_cause;
+
+    if (report.ctrl_value != CAUSE_is_from_nwcc)
+    {
+        /* Treat Condat defined cause values as if no cause given */
+        dis_connect.cause = NOT_PRESENT_8BIT;
+    }
+    else
+    {
+        /* Standards defined cause value is given */
+        dis_connect.cause = report.value.nwcc_cause;
+    }
+    TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
+    /* Marcus: Extended error reporting: 12/11/2002: End */
+    cm_signal(E_CM_DISCONNECT, &dis_connect);
+    TRACE_EVENT("passed the E_CM_DISCONNECT point");
+
+    if ((call_stat EQ OUTGOING_CALL)
+	AND (call_type NEQ MFW_ECC_CALL)
+	AND ((redial_stat EQ CM_REDIAL_AUTO) OR (redial_stat EQ CM_REDIAL_MANU)))
+    {
+	/* If this call is 2nd outgoing call, redial is not started */
+	if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) EQ AT_CMPL)
+	{
+	    for (i=0; i<MAX_CALL_NR; i++)
+	    {
+		if (call_tab[i].index == -1)
+		    break;
+
+		if ((call_tab[i].status == CAL_STAT_NotPresent)
+		    OR (call_tab[i].status == CAL_STAT_DeactiveReq))
+		    continue;
+
+		if (call_tab[i].calType == CAL_TYPE_MOC)
+		{
+		    call_stat = MFW_CALL_FREE;
+		    call_type = MFW_CALL_FREE;
+		    cmd_hold = MFW_CM_NO_FLAG;
+		    return;
+		}
+	    }
+	}
+
+	/* check blacklist whether it is full */
+	if (black_list.count == MAX_BLACKLIST_NUM)
+	{
+			TRACE_EVENT ("blacklist is now full");
+
+			/* Blacklist is now full and
+			   MT shall prohibit further automatic call attempts
+			*/
+		redial_stat = CM_REDIAL_OFF;
+
+
+	    /* allow a new outgoing */
+	    call_stat	 = MFW_CALL_FREE;
+	    call_type	 = MFW_CALL_FREE;
+	    cc_stat.type = MFW_CALL_FREE;
+
+	    rdl.redial_mode = CM_REDIAL_BLACKLIST;
+	    cm_signal(E_CM_REDIAL, &rdl);
+	    return;
+	}
+
+	/* check the registration staus */
+	if (nm_reg_status() == MFW_NO_SERVICE)
+	{
+	    call_stat	 = MFW_CALL_FREE;
+	    call_type	 = MFW_CALL_FREE;
+	    cc_stat.type = MFW_CALL_FREE;
+
+	    rdl.redial_mode = CM_REDIAL_NO_SERVICE;
+	    cm_signal(E_CM_REDIAL, &rdl);
+	    return;
+	}
+
+	TRACE_EVENT_P1("report = %d", extend_report);
+	switch (extend_report)
+	{
+		case 28:
+        // API - 1480 - Added this code to stop redial on an incorrect number
+        if(!redial_count)
+        {
+			call_stat    = MFW_CALL_FREE;
+			call_type    = MFW_CALL_FREE;
+			cc_stat.type = MFW_CALL_FREE;
+
+			rdl.redial_mode = CM_REDIAL_ABORTED;
+			cm_signal(E_CM_REDIAL, &rdl);
+			return;
+		}
+	    case 1: /* check whether the reason is in category 3 (GSM 02.07) */
+	    case 3:
+	    case 22:
+	    case 38:
+		TRACE_EVENT ("category 3");
+		if (!redial_count)
+		{
+			/* redial_count == 0;
+			   this is for the first outgoing call and
+			   now it is going to start the Auto-redial procedure
+			 */
+		    cc_stat.type = REDIALING_CALL;
+		    cc_stat.call_number = 0;
+
+		    call_stat = REDIALING_CALL;
+		    rdl.redial_mode = CM_REDIAL_STARTED;
+		    mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
+
+#ifdef NO_ASCIIZ
+		    rdl.name.len = cc_stat.name.len;
+		    memcpy(rdl.name.data,
+			   cc_stat.name.data,
+			   cc_stat.name.len);
+#else
+		    mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
+//		      strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
+#endif
+		    rdl.ton = cc_stat.ton;
+		    rdl.type = cc_stat.mode;
+
+		    /* reasons in the category 3 have
+		       a call repeat attempts of max. 1 !
+		     */
+		    redial_count = MAX_REDIAL_ATTEMPT-1;
+		    cm_signal(E_CM_REDIAL, &rdl);
+		    return;
+		}
+		else
+		    redial_count = MAX_REDIAL_ATTEMPT;
+		break;
+
+	    case 17: /* check whether the reason is in category 1 and 2 (GSM 02.07) */
+	    case 18:
+	    case 19:
+	    case 27:
+	    case 34:
+	    case 41:
+	    case 42:
+	    case 44:
+	    case 47:
+		TRACE_EVENT ("category 1 & 2");
+		if (!redial_count)
+		{
+			/* redial_count == 0
+			   this is for the first outgoing call and
+			   now it is going to start the Auto-redial procedure
+			 */
+		    cc_stat.type = REDIALING_CALL;
+		    cc_stat.call_number = 0;
+
+		    call_stat = REDIALING_CALL;
+		    rdl.redial_mode = CM_REDIAL_STARTED;
+		    mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
+#ifdef NO_ASCIIZ
+		    rdl.name.len = cc_stat.name.len;
+		    memcpy(rdl.name.data,
+			   cc_stat.name.data,
+			   cc_stat.name.len);
+#else
+		    mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
+//		      strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
+#endif
+		    rdl.ton = cc_stat.ton;
+		    rdl.type = cc_stat.mode;
+
+		    /* reasons in the category 1 and 2 have
+		       a call repeat attempts of max. 10 !
+		     */
+
+		    cm_signal(E_CM_REDIAL, &rdl);
+		    return;
+		}
+
+		if (redial_count >= 1 AND redial_count <= 3)
+		{
+		    timStart(redialTim24);
+		    call_stat = REDIALING_CALL;
+		    cc_stat.call_number = 0;
+		    return;
+		}
+
+		if (redial_count >= 4 AND redial_count < MAX_REDIAL_ATTEMPT)
+		{
+		    timStart(redialTim5);
+		    call_stat = REDIALING_CALL;
+		    cc_stat.call_number = 0;
+		    return;
+		}
+#ifdef CUSTOMER_6366
+				// JP PATCH The MMI needs to know if the 'error disconnect' has
+				// resulted in redial starting irrespective of whether this was a redial attempt or not
+				rdl.redial_mode = CM_REDIAL_STARTED;
+				cm_signal(E_CM_REDIAL, &rdl);
+				// END JP PATCH
+#endif /* CUSTOMER_6366 */
+		break;
+
+	    default:
+		if (redial_count)
+		{
+		  rdl.redial_mode = CM_REDIAL_STOP;
+		  mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
+#ifdef NO_ASCIIZ
+		  rdl.name.len = cc_stat.name.len;
+		  memcpy(rdl.name.data,
+			 cc_stat.name.data,
+			 cc_stat.name.len);
+#else
+		  mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);//???
+//		    strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
+#endif
+		  rdl.ton = cc_stat.ton;
+		  rdl.type = cc_stat.mode;
+		  cm_signal(E_CM_REDIAL, &rdl);
+		}
+		/* allow a new outgoing */
+		call_stat    = MFW_CALL_FREE;
+		call_type    = MFW_CALL_FREE;
+		cc_stat.type = MFW_CALL_FREE;
+		return;
+	}
+
+	if (redial_count >= MAX_REDIAL_ATTEMPT
+	    AND black_list.count < MAX_BLACKLIST_NUM)
+	{
+		  mfwStrncpy((char *)black_list.number[black_list.count],
+		   (char *)cc_stat.number, MFW_NUM_LEN);
+	    black_list.count++;
+
+	    rdl.redial_mode   = CM_REDIAL_BLACKLISTED;
+	    mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
+#ifdef NO_ASCIIZ
+	    rdl.name.len = cc_stat.name.len;
+	    memcpy(rdl.name.data,
+		   cc_stat.name.data,
+		   cc_stat.name.len);
+#else
+	    mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
+//		strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
+#endif
+	    rdl.ton = cc_stat.ton;
+	    rdl.type = cc_stat.mode;
+	    rdl.left_attempts	= 0;
+	    cc_stat.call_number = 0;
+	    cm_signal(E_CM_REDIAL, &rdl);
+	}
+    }
+
+    /* allow a new outgoing */
+    call_stat	 = MFW_CALL_FREE;
+    call_type	 = MFW_CALL_FREE;
+    cc_stat.type = MFW_CALL_FREE;
+}
+#else
+void cm_error_connect(SHORT call_number)
+{
+
+    int i;
+    USHORT report;  /* Marcus: Extended error reporting: 12/11/2002 */
+    USHORT extend_report; /* API - 1564 - 16-01-03 - add this variable to store the new error code */
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	local definition
+#ifdef FF_MMI_OPTIM
+	T_ACI_CAL_ENTR 	    *call_tab;//[MAX_CALL_NR];
+#endif	
+//	Apr 14, 2005	REF: CRR 29991   xpradipg
+//	local definition
+#ifdef FF_MMI_OPTIM
+	UBYTE count;
+	UBYTE blackListNum[MFW_NUM_LEN];
+	int32 file = 0;
+#endif	
+    TRACE_FUNCTION ("cm_error_connect()");
+
+    currAccepting = 0; /* ES!! 210999 */
+    currConnecting = 0; /* ES!! 290999 */
+
+    /* send event */
+    dis_connect.call_number = call_number;
+
+    qAT_PlusCEER( CMD_SRC_LCL, &report);
+    /* Marcus: Extended error reporting: 12/11/2002: Start */
+    TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report);
+
+	/* API - 1564 - 16-01-03 - store the error value to the new variable & throughout this function replace 'report' with 'extend_report */
+    extend_report = GET_CAUSE_VALUE(report);
+
+    if (GET_CAUSE_DEFBY(extend_report) == DEFBY_CONDAT)
+    {
+        /* Treat Condat defined cause values as if no cause given */
+        dis_connect.cause = NOT_PRESENT_8BIT;
+    }
+    else
+    {
+        /* Standards defined cause value is given */
+        dis_connect.cause = GET_CAUSE_VALUE(extend_report);
+    }
+    TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
+    /* Marcus: Extended error reporting: 12/11/2002: End */
+    cm_signal(E_CM_DISCONNECT, &dis_connect);
+    TRACE_EVENT("passed the E_CM_DISCONNECT point");
+
+    if ((call_stat EQ OUTGOING_CALL)
+	AND (call_type NEQ MFW_ECC_CALL)
+	AND ((redial_stat EQ CM_REDIAL_AUTO) OR (redial_stat EQ CM_REDIAL_MANU)))
+    {
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	allocate memory
+#ifdef FF_MMI_OPTIM
+		call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+		if( NULL == call_tab)
+			return; 
+#endif		
+	/* If this call is 2nd outgoing call, redial is not started */
+	if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) EQ AT_CMPL)
+	{
+	    for (i=0; i<MAX_CALL_NR; i++)
+	    {
+		if (call_tab[i].index == -1)
+		    break;
+
+		if ((call_tab[i].status == CAL_STAT_NotPresent)
+		    OR (call_tab[i].status == CAL_STAT_DeactiveReq))
+		    continue;
+
+		if (call_tab[i].calType == CAL_TYPE_MOC)
+		{
+		    call_stat = MFW_CALL_FREE;
+		    call_type = MFW_CALL_FREE;
+		    cmd_hold = MFW_CM_NO_FLAG;
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	deallocate memory
+#ifdef FF_MMI_OPTIM
+			    if(call_tab)
+			    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif			    
+			    return;
+		}
+	    }
+	}
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	deallocate memory
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif
+//	Apr 14, 2005	REF: CRR 29991   xpradipg
+//	read the list into the variable
+#ifdef FF_MMI_OPTIM
+	if((file = flash_MMI_blackList_open()) >= 0 )
+	{	
+		if(flash_MMI_blackList_read(file,(U8*)&count, 1,0) > 0)
+		{
+			if(count == MAX_BLACKLIST_NUM)		
+#else
+	/* check blacklist whether it is full */
+	if (black_list.count == MAX_BLACKLIST_NUM)
+#endif	
+	{
+			TRACE_EVENT ("blacklist is now full");
+
+			/* Blacklist is now full and
+			   MT shall prohibit further automatic call attempts
+			*/
+		redial_stat = CM_REDIAL_ABORTED;
+
+
+	    /* allow a new outgoing */
+	    call_stat	 = MFW_CALL_FREE;
+	    call_type	 = MFW_CALL_FREE;
+	    cc_stat.type = MFW_CALL_FREE;
+
+	    rdl.redial_mode = CM_REDIAL_BLACKLIST;
+	    cm_signal(E_CM_REDIAL, &rdl);
+#ifdef FF_MMI_OPTIM
+		flash_MMI_blackList_close(file);
+#endif
+    	return;
+	}
+#ifdef FF_MMI_OPTIM
+		}
+		flash_MMI_blackList_close(file);
+	}
+#endif	
+
+	/* check the registration staus */
+	if (nm_reg_status() == MFW_NO_SERVICE)
+	{
+	    call_stat	 = MFW_CALL_FREE;
+	    call_type	 = MFW_CALL_FREE;
+	    cc_stat.type = MFW_CALL_FREE;
+
+	    rdl.redial_mode = CM_REDIAL_NO_SERVICE;
+	    cm_signal(E_CM_REDIAL, &rdl);
+	    return;
+	}
+
+	TRACE_EVENT_P1("report = %d", extend_report);
+	switch (extend_report)
+	{
+		case 28:
+        // API - 1480 - Added this code to stop redial on an incorrect number
+        if(!redial_count)
+        {
+			call_stat    = MFW_CALL_FREE;
+			call_type    = MFW_CALL_FREE;
+			cc_stat.type = MFW_CALL_FREE;
+
+			rdl.redial_mode = CM_REDIAL_ABORTED;
+			cm_signal(E_CM_REDIAL, &rdl);
+			return;
+		}
+	    case 1: /* check whether the reason is in category 3 (GSM 02.07) */
+	    case 3:
+	    case 22:
+	    case 38:
+		TRACE_EVENT ("category 3");
+		if (!redial_count)
+		{
+			/* redial_count == 0;
+			   this is for the first outgoing call and
+			   now it is going to start the Auto-redial procedure
+			 */
+		    cc_stat.type = REDIALING_CALL;
+		    cc_stat.call_number = 0;
+
+		    call_stat = REDIALING_CALL;
+		    rdl.redial_mode = CM_REDIAL_STARTED;
+		    mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
+
+#ifdef NO_ASCIIZ
+		    rdl.name.len = cc_stat.name.len;
+		    memcpy(rdl.name.data,
+			   cc_stat.name.data,
+			   cc_stat.name.len);
+#else
+		    mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
+//		      strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
+#endif
+		    rdl.ton = cc_stat.ton;
+		    rdl.type = cc_stat.mode;
+
+		    /* reasons in the category 3 have
+		       a call repeat attempts of max. 1 !
+		     */
+		    redial_count = MAX_REDIAL_ATTEMPT-1;
+		    cm_signal(E_CM_REDIAL, &rdl);
+		    return;
+		}
+		else
+		    redial_count = MAX_REDIAL_ATTEMPT;
+		break;
+
+	    case 17: /* check whether the reason is in category 1 and 2 (GSM 02.07) */
+	    case 18:
+	    case 19:
+	    case 27:
+	    case 34:
+	    case 41:
+	    case 42:
+	    case 44:
+	    case 47:
+		TRACE_EVENT ("category 1 & 2");
+		if (!redial_count)
+		{
+			/* redial_count == 0
+			   this is for the first outgoing call and
+			   now it is going to start the Auto-redial procedure
+			 */
+		    cc_stat.type = REDIALING_CALL;
+		    cc_stat.call_number = 0;
+
+		    call_stat = REDIALING_CALL;
+		    rdl.redial_mode = CM_REDIAL_STARTED;
+		    mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
+#ifdef NO_ASCIIZ
+		    rdl.name.len = cc_stat.name.len;
+		    memcpy(rdl.name.data,
+			   cc_stat.name.data,
+			   cc_stat.name.len);
+#else
+		    mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
+//		      strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
+#endif
+		    rdl.ton = cc_stat.ton;
+		    rdl.type = cc_stat.mode;
+
+		    /* reasons in the category 1 and 2 have
+		       a call repeat attempts of max. 10 !
+		     */
+
+		    cm_signal(E_CM_REDIAL, &rdl);
+		    return;
+		}
+
+		if (redial_count >= 1 AND redial_count <= 3)
+		{
+		    timStart(redialTim24);
+		    call_stat = REDIALING_CALL;
+		    cc_stat.call_number = 0;
+		    return;
+		}
+
+		if (redial_count >= 4 AND redial_count < MAX_REDIAL_ATTEMPT)
+		{
+		    timStart(redialTim5);
+		    call_stat = REDIALING_CALL;
+		    cc_stat.call_number = 0;
+		    return;
+		}
+#ifdef CUSTOMER_6366
+				// JP PATCH The MMI needs to know if the 'error disconnect' has
+				// resulted in redial starting irrespective of whether this was a redial attempt or not
+				rdl.redial_mode = CM_REDIAL_STARTED;
+				cm_signal(E_CM_REDIAL, &rdl);
+				// END JP PATCH
+#endif /* CUSTOMER_6366 */
+		break;
+
+	    default:
+		if (redial_count)
+		{
+		  rdl.redial_mode = CM_REDIAL_STOP;
+		  mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
+#ifdef NO_ASCIIZ
+		  rdl.name.len = cc_stat.name.len;
+		  memcpy(rdl.name.data,
+			 cc_stat.name.data,
+			 cc_stat.name.len);
+#else
+		  mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);//???
+//		    strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
+#endif
+		  rdl.ton = cc_stat.ton;
+		  rdl.type = cc_stat.mode;
+		  cm_signal(E_CM_REDIAL, &rdl);
+		}
+		/* allow a new outgoing */
+		call_stat    = MFW_CALL_FREE;
+		call_type    = MFW_CALL_FREE;
+		cc_stat.type = MFW_CALL_FREE;
+		return;
+	}
+#ifdef FF_MMI_OPTIM
+	if (redial_count >= MAX_REDIAL_ATTEMPT
+	    AND count < MAX_BLACKLIST_NUM)
+	{
+		  mfwStrncpy((char *)blackListNum,(char *)cc_stat.number, MFW_NUM_LEN);
+//	Apr 14, 2005	REF: CRR 29991   xpradipg
+//	once there is new addition update it onto the file
+		if(flash_MMI_blackList_write((U8*)blackListNum, MFW_NUM_LEN, (count*MFW_NUM_LEN)+1) < 0)
+			TRACE_FUNCTION("ERROR OPENING the blacklist file");
+		count++;
+		if(flash_MMI_blackList_write((U8*)&count,1,0) < 0)
+			TRACE_FUNCTION("ERROR OPENING the blacklist file");
+#else
+	if (redial_count >= MAX_REDIAL_ATTEMPT
+	    AND black_list.count < MAX_BLACKLIST_NUM)
+	{
+		  mfwStrncpy((char *)black_list.number[black_list.count],
+		   (char *)cc_stat.number, MFW_NUM_LEN);
+	    black_list.count++;
+#endif
+		rdl.redial_mode   = CM_REDIAL_BLACKLISTED;
+	    mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
+#ifdef NO_ASCIIZ
+	    rdl.name.len = cc_stat.name.len;
+	    memcpy(rdl.name.data,
+		   cc_stat.name.data,
+		   cc_stat.name.len);
+#else
+	    mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
+//		strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
+#endif
+	    rdl.ton = cc_stat.ton;
+	    rdl.type = cc_stat.mode;
+	    rdl.left_attempts	= 0;
+	    cc_stat.call_number = 0;
+	    cm_signal(E_CM_REDIAL, &rdl);
+	}
+    }
+
+    /* allow a new outgoing */
+    call_stat	 = MFW_CALL_FREE;
+    call_type	 = MFW_CALL_FREE;
+    cc_stat.type = MFW_CALL_FREE;
+}
+#endif
+
+
+/*
++-----------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM		|
+| STATE   : code			 ROUTINE : cm_rmt_error_connect |
++-----------------------------------------------------------------------+
+
+
+   PURPOSE : The connection is not successful
+
+*/
+
+#ifdef FF_2TO1_PS
+void cm_rmt_error_connect(SHORT call_number)
+{
+    T_CAUSE_ps_cause report;  /* Marcus: Extended error reporting: 12/11/2002 */
+
+    TRACE_FUNCTION ("cm_error_connect()");
+
+    /* send event */
+    dis_connect.call_number = call_number;
+
+    qAT_PlusCEER( CMD_SRC_LCL, &report);
+    /* Marcus: Extended error reporting: 12/11/2002: Start */
+//    TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report);
+
+    if (report.ctrl_value != CAUSE_is_from_nwcc)
+    {
+        /* Treat Condat defined cause values as if no cause given */
+        dis_connect.cause = NOT_PRESENT_8BIT;
+    }
+    else
+    {
+       /* Standards defined cause value is given */
+       dis_connect.cause = report.value.nwcc_cause;
+    }
+
+    TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
+    /* Marcus: Extended error reporting: 12/11/2002: End */
+
+    cm_signal(E_CM_DISCONNECT, &dis_connect);
+}
+#else
+void cm_rmt_error_connect(SHORT call_number)
+{
+    USHORT report;  /* Marcus: Extended error reporting: 12/11/2002 */
+
+    TRACE_FUNCTION ("cm_error_connect()");
+
+    /* send event */
+    dis_connect.call_number = call_number;
+
+    qAT_PlusCEER( CMD_SRC_LCL, &report);
+    /* Marcus: Extended error reporting: 12/11/2002: Start */
+    TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report);
+    if (GET_CAUSE_DEFBY(report) == DEFBY_CONDAT)
+    {
+        /* Treat Condat defined cause values as if no cause given */
+        dis_connect.cause = NOT_PRESENT_8BIT;
+    }
+    else
+    {
+        /* Standards defined cause value is given */
+        dis_connect.cause = GET_CAUSE_VALUE(report);
+    }
+    TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
+    /* Marcus: Extended error reporting: 12/11/2002: End */
+
+    cm_signal(E_CM_DISCONNECT, &dis_connect);
+}
+#endif
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_disconnect	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Disconnection for outgoing call or active call
+
+*/
+
+T_MFW cm_disconnect(SHORT call_number)
+{
+    CHAR		callId[5];
+    T_MFW_CM_CALL_STAT	stat;
+    UBYTE		ton;
+    UBYTE		mode;
+
+    TRACE_FUNCTION ("cm_disconnect()");
+
+    dis_connect.call_number = call_number;
+
+    if (!call_number)
+    {
+	cmd_hold = MFW_CM_MPTY_TERMINATED;
+	sprintf(callId, "%d", 0);
+	if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActSpec, callId) != AT_EXCT)
+	    return CM_ERROR;
+	return CM_OK;
+    }
+
+    cm_search_callStat(call_number, &stat, &ton, &mode);
+
+	TRACE_EVENT_P3("Status %d Ton %d Mode %d",stat,ton,mode);
+
+	/* HANG UP DATA CALL (WAP)
+	 * SPR#1983 - SH - Use sAT_Abort() when call has not yet connected,
+	 * rather than sAT_H */
+
+    if (mode == DATA_CALL)
+	{
+		T_ACI_RETURN retval;
+
+		TRACE_EVENT_P1("***Disconnect data call, stat=%d", stat);
+
+		if ((stat == CALL_DIAL) OR (stat == CALL_ALERT))
+	    {
+			if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) NEQ AT_CMPL)
+				return CM_ERROR;
+			return CM_OK;
+	    }
+
+	    if (stat == CALL_DEACTIVE && currConnecting)  /* ES/AK 290999 */
+	    {
+			currConnecting = 0;
+			if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) NEQ AT_CMPL)
+				return CM_ERROR;
+			return CM_OK;
+	    }
+
+		retval = sAT_H(CMD_SRC_LCL);
+
+		TRACE_EVENT_P1("Result of sAT_H = %d", retval);
+		if (retval)
+		    return CM_ERROR;
+		return CM_OK;
+	}
+
+
+    if ((stat == CALL_DIAL) OR (stat == CALL_ALERT))
+    {
+	if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) NEQ AT_CMPL)
+		return CM_ERROR;
+	return CM_OK;
+    }
+
+    if (stat == CALL_DEACTIVE && currConnecting)  /* ES/AK 290999 */
+    {
+	currConnecting = 0;
+	if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) NEQ AT_CMPL)
+		return CM_ERROR;
+	return CM_OK;
+    }
+
+    if ((stat == CALL_ACTIVE) OR (stat == CALL_DEACTIVE))
+    {
+		cmd_hold = MFW_CM_TERMINATED;
+		sprintf(callId, "%d", call_number);
+		if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActSpec, callId) != AT_EXCT)
+			return CM_ERROR;
+		return CM_OK;
+    }
+    else if (stat == CALL_HELD) 
+   {
+   
+
+                //  Apr 26, 2004 REF: CRR 16545 Ajith K P Side effect of CRR 16545.
+                //  CHLD_MOD_RelActSpec no longer releases held calls.
+                //  So now if the user wants to release a HELD call, now we are calling the 
+                //  sAT_PlusCHLD(..) function with CHLD_MOD_RelAnySpec as the parameter.
+
+
+
+		cmd_hold = MFW_CM_TERMINATED;
+		sprintf(callId, "%d", call_number);
+               // Feb 27, 2006    REF:DR OMAPS00067884  x0039928	 
+               // Fix :  sAT_PercentCHLD() is called if the mode > CHLD_MOD_RelDialCall
+		if (sAT_PercentCHLD(CMD_SRC_LCL, CHLD_MOD_RelAnySpec, callId) != AT_EXCT)
+		    return CM_ERROR;
+		return CM_OK;
+   	}
+	return CM_ERROR;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_force_disconnect |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Disconnection of any call existent needed for Multiparty and some structured procedures
+	     call termination in state U9
+
+*/
+
+void cm_force_disconnect(void)
+{
+  T_ACI_RETURN res;
+
+  TRACE_FUNCTION("cm_force_disconnect()");
+
+  res = sAT_H(CMD_SRC_LCL);
+  if (res != AT_EXCT && res != AT_CMPL)
+      TRACE_ERROR("satReject() error");
+
+  return;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_ok_disconnect    |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : indicates disconnection from called party;
+		sends E_CM_DISCONNECT to mmi
+
+*/
+
+#ifdef FF_2TO1_PS
+void cm_ok_disconnect(T_ACI_CMD_SRC src, SHORT call_id)
+{
+    T_CAUSE_ps_cause cause;  /* Marcus: Extended error reporting: 12/11/2002 */
+    T_MFW_CM_DISCONNECT_ALL disconnect_all;
+
+    TRACE_FUNCTION("cm_ok_disconnect()");
+
+    TRACE_EVENT_P4("dis_connect.call_number %d, cmd_hold %d, src %d, call_id %d",
+                              dis_connect.call_number, cmd_hold, src, call_id);
+
+
+
+
+    /* Marcus: CCBS: 14/11/2002: Start */
+    if (cmd_hold == MFW_CM_CCBS_REGISTER)
+    {
+        /* Rejecting the offered CCBS registration */
+        TRACE_EVENT("cmd_hold == MFW_CM_CCBS_REGISTER");
+        cmd_hold = 0;
+        cm_ccbs_ok();
+        return;
+    }
+    /* Marcus: CCBS: 14/11/2002: End */
+
+    if (cmd_hold == MFW_CM_MPTY_TERMINATED)
+	       dis_connect.call_number = 0;
+	//Nov 02, 2005    DR OMAPS00052132   xdeepadh	
+	//The usage of ATI enum is put under the flag FF_ATI
+#if  defined (FF_ATI) || defined (NEPTUNE_BOARD)
+        else if (src EQ CMD_SRC_ATI_1) /* NM Berlin/UK integration 21.09.01 */
+        {
+               dis_connect.call_number = call_id;
+        }
+#endif 
+       
+
+    /* send event */
+    qAT_PlusCEER( CMD_SRC_LCL, &cause);
+    /* Marcus: Extended error reporting: 12/11/2002: Start */
+//    TRACE_EVENT_P1("qAT_PlusCEER(%04X)", cause);
+
+    if (cause.ctrl_value != CAUSE_is_from_nwcc)
+    {
+        /* Treat Condat defined cause values as if no cause given */
+        dis_connect.cause = NOT_PRESENT_8BIT;
+    }
+    else
+    {
+        /* Standards defined cause value is given */
+        dis_connect.cause = cause.value.nwcc_cause;
+    }
+
+    TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
+    /* Marcus: Extended error reporting: 12/11/2002: End */
+
+    /* allow a new outgoing */
+    call_stat = MFW_CALL_FREE;
+    call_type = MFW_CALL_FREE;
+
+    if (cmd_hold EQ MFW_CM_DISCONNECT_ALL)
+    {
+        disconnect_all.result = CM_DISCONNECT_ALL_RESULT_OK;
+        if (cause.ctrl_value != CAUSE_is_from_nwcc)
+        {
+            /* Treat Condat defined cause values as if no cause given */
+            disconnect_all.cause = NOT_PRESENT_8BIT;
+        }
+        else
+        {
+            /* Standards defined cause value is given */
+            disconnect_all.cause = cause.value.nwcc_cause;
+        }
+        cm_signal(E_CM_DISCONNECT_ALL,&disconnect_all);
+    }
+    else
+        cm_signal(E_CM_DISCONNECT, &dis_connect);
+
+    cmd_hold = 0;
+
+}
+#else
+void cm_ok_disconnect(T_ACI_CMD_SRC src, SHORT call_id)
+{
+    USHORT cause;  /* Marcus: Extended error reporting: 12/11/2002 */
+    T_MFW_CM_DISCONNECT_ALL disconnect_all;
+
+    TRACE_FUNCTION("cm_ok_disconnect()");
+
+    TRACE_EVENT_P4("dis_connect.call_number %d, cmd_hold %d, src %d, call_id %d",
+                              dis_connect.call_number, cmd_hold, src, call_id);
+
+
+
+
+    /* Marcus: CCBS: 14/11/2002: Start */
+    if (cmd_hold == MFW_CM_CCBS_REGISTER)
+    {
+        /* Rejecting the offered CCBS registration */
+        TRACE_EVENT("cmd_hold == MFW_CM_CCBS_REGISTER");
+        cmd_hold = 0;
+        cm_ccbs_ok();
+        return;
+    }
+    /* Marcus: CCBS: 14/11/2002: End */
+
+    if (cmd_hold == MFW_CM_MPTY_TERMINATED)
+	       dis_connect.call_number = 0;
+	//Nov 02, 2005    DR OMAPS00052132   xdeepadh	
+	//The usage of ATI enum is put under the flag FF_ATI
+#ifdef FF_ATI	
+	else if (src EQ CMD_SRC_ATI_1) //NM Berlin/UK integration 21.09.01
+	{
+		dis_connect.call_number = call_id;
+	}
+#endif	//FF_ATI  
+
+    /* send event */
+    qAT_PlusCEER( CMD_SRC_LCL, &cause);
+    /* Marcus: Extended error reporting: 12/11/2002: Start */
+    TRACE_EVENT_P1("qAT_PlusCEER(%04X)", cause);
+    if (GET_CAUSE_DEFBY(cause) == DEFBY_CONDAT)
+    {
+        /* Treat Condat defined cause values as if no cause given */
+        dis_connect.cause = NOT_PRESENT_8BIT;
+    }
+    else
+    {
+        /* Standards defined cause value is given */
+        dis_connect.cause = GET_CAUSE_VALUE(cause);
+    }
+    TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
+    /* Marcus: Extended error reporting: 12/11/2002: End */
+
+    /* allow a new outgoing */
+    call_stat = MFW_CALL_FREE;
+    call_type = MFW_CALL_FREE;
+
+    if (cmd_hold EQ MFW_CM_DISCONNECT_ALL)
+    {
+        disconnect_all.result = CM_DISCONNECT_ALL_RESULT_OK;
+        if (GET_CAUSE_DEFBY(cause) == DEFBY_CONDAT)
+        {
+            /* Treat Condat defined cause values as if no cause given */
+            disconnect_all.cause = NOT_PRESENT_8BIT;
+        }
+        else
+        {
+            /* Standards defined cause value is given */
+            disconnect_all.cause = GET_CAUSE_VALUE(cause);
+        }
+        cm_signal(E_CM_DISCONNECT_ALL,&disconnect_all);
+    }
+    else
+        cm_signal(E_CM_DISCONNECT, &dis_connect);
+
+    cmd_hold = 0;
+
+}
+#endif
+
+/* Marcus: CCBS: 14/11/2002: Start */
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM	        	     |
+| STATE  : code 			ROUTINE: cm_error_disconnect             |
++--------------------------------------------------------------------+
+
+   PURPOSE : indicates failed disconnection
+
+*/
+void cm_error_disconnect(void)
+{
+    TRACE_FUNCTION ("cm_error_disconnect()");
+    if (cmd_hold == MFW_CM_DISCONNECT_ALL)
+    {
+        TRACE_EVENT("cmd_hold == MFW_CM_DISCONNECT_ALL");
+        cmd_hold = 0;
+    }
+
+    /* Marcus: CCBS: 14/11/2002: Start */
+    if (cmd_hold == MFW_CM_CCBS_REGISTER)
+    {
+        TRACE_EVENT("cmd_hold == MFW_CM_CCBS_REGISTER");
+        /* Rejecting the offered CCBS registration */
+        cmd_hold = 0;
+        cm_ccbs_error();
+    }
+}
+/* Marcus: CCBS: 14/11/2002: End */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_command	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :
+
+*/
+
+T_MFW cm_command(SHORT call_number, UBYTE command, UBYTE crss_string)
+{
+  CHAR		      callId[5];
+  UBYTE 	      res;
+  SHORT retVal, modeRetVal; // xnkulkar SPR-18262: Added "modeRetVal"  to store the return value of "mfw_cbuf_put_mode ()"
+
+  TRACE_FUNCTION ("cm_command()");
+
+// JP PATCH
+	cmd_hold = 0;
+// END PATCH
+
+  cmd.call_number = call_number;
+  cmd.command	  = command;
+
+  switch (command)
+  {
+    case CM_HOLD:
+    case CM_SWAP:
+    case CM_RETRIEVE:
+    case CM_SWAP_MULTIPARTY:
+    case CM_HOLD_MULTIPARTY:
+    case CM_RETRIEVE_MULTIPARTY:
+      /* place all active calls on held and accept held or waiting call */
+      if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_HldActAndAcpt, 0) != AT_EXCT)
+	return FALSE;
+      break;
+
+    case CM_BUILD_MULTIPARTY:
+      if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_AddHld, 0)!= AT_EXCT)
+	return FALSE;
+      break;
+
+    case CM_SPLIT_MULTIPARTY:
+      if (call_number <= 0)
+	return FALSE;
+      sprintf(callId, "%d", call_number);
+      if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_HldActExc, callId)!= AT_EXCT)
+	return FALSE;
+      break;
+
+    case CM_ETC:
+      /* connects two calls and disconnects the subsrciber from both calls */
+      if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_Ect, 0) != AT_EXCT)
+	return FALSE;
+      break;
+
+    case CM_CALL_DEFLECTION:
+      break;
+
+    case CM_CCBS:
+        TRACE_EVENT("CM_CCBS");
+      sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_Ccbs, 0);
+      break;
+
+    case CM_MODIFY:
+      break;
+
+    case CM_DTMF_ACTIVE:
+	// xnkulkar SPR-18262
+	// If there is a DTMF tone command already in the queue, add the current tone also
+	// in the queue (with start mode). While attempting to send a tone,  if the request is not successful,
+	// add the DTMF request to the queue.  Also, start adding to the queue if we are expecting an acknowledgement 
+	// (rAT_OK) for the previous DTMF tone request sent. 
+	if (mfw_cbuf_num_elements(mfw_cm_dtmf_q_id) != 0)
+    	{
+    		/*
+    		** There are already DTMF tones queued to be sent, so queue this request too along with the mode (Start).
+    		*/
+		modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_ManStart);
+    		retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string);
+		// If the return values are negative, attempt to Queue the DTMF request failed
+    		if (retVal < 0 || modeRetVal < 0)
+    		{
+    			TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal);
+    			TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal);
+    			/*
+    			** Failed to Queue the DTMF request.
+    			*/
+    			return(FALSE);
+    		}
+    	}
+    	else
+	{
+		//xnkulkar 18262
+		// While attempting to send a tone,  if the command is not successfully completed, add 
+		// the request to the queue. After sending a DTMF tone comand, set the variable expectRatOk to true.
+		// This will be reset only when all the DTMF tones in queue are sent.
+	    	if ( expectRatOk == TRUE || sAT_PlusVTS(CMD_SRC_LCL, (CHAR)crss_string, VTS_MOD_ManStart) != AT_EXCT)
+	      	{
+	      		/*
+	      		** The attempt to send an immediate DTMF failed.
+	      		** Add the failed attempt onto the DTMF queue and wait.
+	      		*/
+	      		// xnkulkar 18262
+	      		// Also store the "mode"(Start), in which the DTMF tone has to be sent.
+	      		// This is stored in the queue in an array.
+			modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_ManStart);
+	      		retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string);
+	    		if (retVal < 0 || modeRetVal < 0 )
+	    		{
+	    			TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal);
+	    			TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal);
+	    			/*
+	    			** Failed to Queue the DTMF request.
+	    			*/
+	    			return(FALSE);
+	    		}
+	      	}
+		expectRatOk = TRUE; // xnkulkar SPR-18262: Set this flag to TRUE
+	}			
+      currCmd = AT_CMD_VTS;
+      break;
+
+    case CM_DTMF_INACTIVE:
+	// xnkulkar SPR-18262
+	// If there is a DTMF tone command already in the queue, add the current tone also
+	// in the queue (with stop mode). While attempting to send a tone,  if the request is not successful,
+	// add the DTMF request to the queue.  Also, start adding to the queue if we are expecting an acknowledgement 
+	// (rAT_OK) for the previous DTMF tone request sent. 
+    	if (mfw_cbuf_num_elements(mfw_cm_dtmf_q_id) != 0)
+    	{
+    		/*
+    		** There are already DTMF tones queued to be sent, so queue this request too along with the mode (Stop).
+    		*/
+		modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_ManStop);
+    		retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string);
+    		if (retVal < 0 || modeRetVal < 0)
+    		{
+    			TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal);
+    			TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal);
+    			/*
+    			** Failed to Queue the DTMF request.
+    			*/
+    			return(FALSE);
+    		}
+    	}
+    	else
+	{
+	    	if (expectRatOk  == TRUE || sAT_PlusVTS(CMD_SRC_LCL, (CHAR)crss_string, VTS_MOD_ManStop) != AT_EXCT)
+	      	{
+	      		/*
+	      		** The attempt to send an immediate DTMF failed.
+	      		** Add the failed attempt onto the DTMF queue and wait.
+	      		*/
+			modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_ManStop);
+	      		retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string);
+	    		if (retVal < 0 || modeRetVal < 0)
+	    		{
+	    			TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal);
+	    			TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal);
+	    			/*
+	    			** Failed to Queue the DTMF request.
+	    			*/
+	    			return(FALSE);
+	    		}
+	      	}
+		expectRatOk = TRUE; //xnkulkar SPR-18262: set this flag to TRUE
+      }
+      res = TRUE;
+      cm_signal(E_CM_DTMF, &res);
+      break;
+
+    case CM_DTMF_AUTO:
+    	if (mfw_cbuf_num_elements(mfw_cm_dtmf_q_id) != 0)
+    	{
+    		/*
+    		** There are already DTMF tones queued to be sent, so queue this request to.
+    		*/
+		modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_Auto);
+    		retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string);
+    		if (retVal < 0  || modeRetVal < 0)
+    		{
+    			TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal);
+	    		TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal);
+    			/*
+    			** Failed to Queue the DTMF request.
+    			*/
+    			return(FALSE);
+    		}
+    	}
+    	else
+		{
+	    	if (sAT_PlusVTS(CMD_SRC_LCL, (CHAR)crss_string, VTS_MOD_Auto) != AT_EXCT)
+	      	{
+	      		/*
+	      		** The attempt to send an immediate DTMF failed.
+	      		** Add the failed attempt onto the DTMF queue and wait.
+	      		*/
+			modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_Auto);
+	      		retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string);
+	    		if (retVal < 0 || modeRetVal < 0)
+	    		{
+	    			TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal);
+	    			TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal);
+	    			/*
+	    			** Failed to Queue the DTMF request.
+	    			*/
+	    			return(FALSE);
+	    		}
+	      	}
+		}
+      break;
+
+    default:
+      break;
+  }
+  return TRUE;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	     |
+| STATE   : code			 ROUTINE : send_queued_dtmf_tone	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Check the DTMF Queue and if required send the next DTMF Tone Request.
+
+*/
+static void send_queued_dtmf_tone(void)
+{
+	SHORT retVal;
+    UBYTE qdtmf;
+	//xnkulkar SPR-18262: Added these variables to store the Mode
+	T_ACI_VTS_MOD  vts_mode = VTS_MOD_NotPresent; 
+
+    	TRACE_FUNCTION("send_queued_dtmf_tone()");
+
+    // If there are DTMF tones to be sent in the queue
+    if (mfw_cbuf_num_elements(mfw_cm_dtmf_q_id) > 0)
+    {
+    		// Get the mode (Start / Stop) corresponding to the DTMF tone
+    		vts_mode = (T_ACI_VTS_MOD)mfw_cbuf_get_mode(mfw_cm_dtmf_q_id);
+		// Get the DTMF key for which the tone is to be sent from the queue
+	    	retVal = mfw_cbuf_get(mfw_cm_dtmf_q_id, &qdtmf);
+	    	if (retVal > 0)
+		{
+	    		if (sAT_PlusVTS(CMD_SRC_LCL, (CHAR)qdtmf, vts_mode) != AT_EXCT)
+		      	{
+		      		/*
+		      		** The attempt to send an immediate DTMF failed
+		      		*/
+		      		TRACE_EVENT("ERROR : Attempt to send a queued DTMF tone failed!!!!");
+		      	}
+		}
+    		else
+		{
+			TRACE_EVENT_P1("ERROR : mfw_cbuf_get failed with error value %d", retVal);
+		}
+   	}
+    	 else
+    	 {
+	  	// xnkulkar SPR-18262: if number of elements in queue is zero, we can start sending 
+	  	// DTMF so reset this variable. 
+	 	expectRatOk = FALSE;
+    	 }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	     |
+| STATE   : code			 ROUTINE : cm_ok_dtmf	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : DTMF activation is successful.
+
+*/
+
+void cm_ok_dtmf(void)
+{
+    UBYTE res;
+
+    currCmd = AT_CMD_NONE;
+    res = TRUE;
+    cm_signal(E_CM_DTMF, &res);
+
+	send_queued_dtmf_tone();
+
+	return;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	     |
+| STATE   : code			 ROUTINE : cm_error_tdmf     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : DTMF activation is failed.
+
+*/
+
+void cm_error_dtmf(void)
+{
+    UBYTE res;
+
+    currCmd = AT_CMD_NONE;
+    res = FALSE;
+    cm_signal(E_CM_DTMF, &res);
+
+	send_queued_dtmf_tone();
+
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	     |
+| STATE   : code			 ROUTINE : cm_result_cmd     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Acknowledgement for the requested ss command.
+
+*/
+
+void cm_result_cmd(T_ACI_CMD_SRC src, UBYTE result)
+{
+    SHORT call_number;
+
+	TRACE_EVENT_P1("cm_result_cmd(), cmd_hold = %d", cmd_hold);
+
+	/* MC changed all the "if"s to a switch to allow default 11/04/02*/
+    switch (cmd_hold)
+    {
+	case MFW_CM_MT_REJECT:
+		break; /* CONQUEST 6040- MC-  put a break in the case so no action taken*/
+	case MFW_CM_MPTY_TERMINATED:
+	case MFW_CM_TERMINATED:
+
+    {
+      if (result EQ Present)
+	cm_ok_disconnect(CMD_SRC_LCL, 0);
+      return;
+    }
+//	break;  // RAVI
+
+    case MFW_CM_MT_ACCEPT:
+    {
+      /*
+       * active call on hold, accept new incoming call
+       */
+      cmd_hold = 0;
+      if (result EQ Present)
+	/*
+	 * Call on hold was successful
+	 */
+	cm_ok_connect();
+
+      else
+      {
+	if (cm_search_callId(CAL_STAT_Active, &call_number) != CM_OK)
+	  return;
+	cmd.call_number = call_number;
+	cc_id = 0; // ???
+      }
+    }
+	break;
+
+
+	case MFW_CM_HOLD_AND_DIAL:
+    {
+      /*
+       * active call on hold, accept new incoming call
+       */
+      cmd_hold = 0;
+      if (result EQ Present)
+	/*
+	 * Call on hold was successful
+	 */
+	 cm_ok_connect();
+
+      else
+      {
+	if (cm_search_callId(CAL_STAT_Active, &call_number) != CM_OK)
+	  return;
+	cmd.call_number = call_number;
+	cc_id = 0; // ???
+      }
+    }
+	break;
+
+	case MFW_CM_1_SEND:
+	{
+			
+		cmd_hold = 0;
+		if (result == Present)
+		{
+			// MMI-SPR 13873 xkundadu
+			// Handling of 1SEND 
+			// If the user presses 1SEND, release active calls and accept 
+			// the WAITING call
+		       if (dis_connect.call_number NEQ -1)
+		    	{
+		    		// If there is an active call, disconnect it.
+				cm_ok_disconnect(CMD_SRC_LCL, 0);
+		    	}
+	      
+	    		if (!cmd.call_number)
+		       {
+				// If there is waiting call, accept the call
+			 	cm_ok_connect();
+		       }
+		    	cmd.call_number = -1;
+		}
+		
+  	}
+	   break;
+
+        /* Marcus: CCBS: 14/11/2002: Start */
+        case MFW_CM_CCBS_REGISTER:
+
+            TRACE_EVENT("MFW_CM_CCBS_REGISTER");
+
+            cmd_hold = 0;
+
+            if (result == Present)
+            {
+                TRACE_EVENT("result == Present");
+                cm_ccbs_ok();
+            }
+            else    /* result is NotPresent */
+            {
+                TRACE_EVENT("result != Present");
+                cm_ccbs_error();
+            }
+            return;
+
+        case MFW_CM_CCBS_RECALL:
+
+            TRACE_EVENT("MFW_CM_CCBS_RECALL");
+
+            cmd_hold = 0;
+
+            if (result == Present)
+            {
+                TRACE_EVENT("result == Present");
+                cm_ccbs_ok();
+            }
+            else    /* result is NotPresent */
+            {
+                TRACE_EVENT("result != Present");
+                cm_ccbs_error();
+            }
+            return;
+        /* Marcus: CCBS: 14/11/2002: Start */
+
+	default:/*For other command types ensure correct result is passed up to BMI*/
+	{
+	    cmd.result = result;
+	}
+	break;
+  }
+
+
+#if defined (WIN32)
+    {
+      char buf[40];
+      sprintf (buf, "Event CM_COMMAND for %d", cmd.call_number);
+      TRACE_EVENT (buf);
+      sprintf (buf, "Result %d Command %d",cmd.result, cmd.command);
+      TRACE_EVENT (buf);
+    }
+#endif
+    cmd.result = result;
+    cm_signal(E_CM_COMMAND, &cmd);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_cvt_speed_type   |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  This function is used to convert the type of data rate
+	      used by MFW to the type of data rate used by ACI.
+
+*/
+
+LOCAL T_ACI_BS_SPEED cm_cvt_speed_type ( T_MFW_CM_DATA_SPEED speed )
+{
+  switch ( speed )
+  {
+    case ( SPEED_300 ):   return BS_SPEED_300_V110;
+    case ( SPEED_1200 ):  return BS_SPEED_1200_V110;
+    case ( SPEED_2400 ):  return BS_SPEED_2400_V110;
+    case ( SPEED_4800 ):  return BS_SPEED_4800_V110;
+    case ( SPEED_9600 ):  return BS_SPEED_9600_V110;
+    case ( SPEED_14400 ): return BS_SPEED_14400_V110;
+    default:	      return BS_SPEED_NotPresent;
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_cvt_bs_type      |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  This function is used to convert the type of bearer service
+	      used by MFW to the type of bearer service used by ACI.
+
+*/
+
+LOCAL T_ACI_CBST_NAM cm_cvt_bs_type ( T_MFW_CM_BS bs )
+{
+  switch ( bs )
+  {
+    case ( Asynch ): return CBST_NAM_Asynch;
+    case ( Synch ):  return CBST_NAM_Synch;
+    default:	     return CBST_NAM_NotPresent;
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_cvt_ce_type      |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  This function is used to convert the  data mode
+	      used by MFW to the data mode used by ACI.
+
+*/
+
+LOCAL T_ACI_CBST_CE cm_cvt_ce_type ( T_MFW_CM_CE ce )
+{
+  switch ( ce )
+  {
+    case ( Transparent ):     return CBST_CE_Transparent;
+    case ( NonTransparent ):  return CBST_CE_NonTransparent;
+    default:	      return CBST_CE_NotPresent;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_set_bc_para      |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Set bearer parameter for mobile originated calls.
+
+*/
+
+void cm_set_bc_para(T_MFW_CM_BC_PARA * bc, UBYTE ti)
+{
+  TRACE_FUNCTION ("cm_set_bc_para()");
+
+  sAT_PlusCBST(CMD_SRC_LCL,
+	       cm_cvt_speed_type ((T_MFW_CM_DATA_SPEED)bc->rate),
+	       cm_cvt_bs_type ((T_MFW_CM_BS)bc->bearer_serv),
+	       cm_cvt_ce_type ((T_MFW_CM_CE)bc->conn_elem));
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_notify	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Change of SS status from call party.
+
+*/
+void cm_notify(T_ACI_CSSU_CODE code,
+			   SHORT	   index,
+			   UBYTE	  *number)
+{	char debug[50];
+	sprintf(debug,"cm_notify(), code:%d, index:%d" , code, index);
+	TRACE_EVENT(debug);
+	if (number)
+		notify.call_number = index;
+
+	if (code == CSSU_CODE_OnHold)
+		notify.notification = MFW_CM_HOLD;
+	if (code == CSSU_CODE_Retrieved)
+		notify.notification = MFW_CM_RETRIEVED;
+
+	cm_signal(E_CM_NOTIFY, &notify);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	     |
+| STATE   : code			 ROUTINE : cm_get_aoc_value  |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Getting AoC (advice of charge) value.
+
+*/
+
+T_MFW cm_get_aoc_value(UBYTE request_type, T_MFW_CM_AOC_INFO *aoc_info)
+{
+    T_ACI_RPCT_VAL  rpuct;
+
+    TRACE_FUNCTION ("cm_get_aoc_value()");
+
+    switch (request_type)
+    {
+	/* Price pro unit and currency table */
+	case CM_AOC_PUCT:
+	    if (qAT_PlusCPUC(CMD_SRC_LCL,
+		(CHAR *)aoc_info->cur,
+		(CHAR *)aoc_info->ppu) == AT_CMPL)
+	    {
+		aoc_info->requested_type = CM_AOC_PUCT;
+		return CM_OK;
+	    }
+	    else
+		return CM_NO_AOC;
+//	    break;  // RAVI
+
+	/* maximum value of accumulated Call Meter */
+	case CM_AOC_ACMMAX:
+	    if (qAT_PlusCAMM(CMD_SRC_LCL, &aoc_info->acm_max) == AT_CMPL)
+	    {
+		aoc_info->requested_type = CM_AOC_ACMMAX;
+		return CM_OK;
+	    }
+	    else
+		return CM_NO_AOC;
+//	    break;  // RAVI
+
+	/* Accumulated Call Meter */
+	case CM_AOC_ACM:
+	    if (qAT_PlusCACM(CMD_SRC_LCL, &aoc_info->acm) == AT_CMPL)
+	    {
+		aoc_info->requested_type = CM_AOC_ACM;
+		return CM_OK;
+	    }
+	    else
+		return CM_NO_AOC;
+	//     break;  // RAVI
+
+	case CM_AOC_CCM:
+	    if (qAT_PlusCAOC(CMD_SRC_LCL, &aoc_info->ccm) == AT_CMPL)
+	    {
+		aoc_info->requested_type = CM_AOC_CCM;
+		return CM_OK;
+	    }
+	    else
+		return CM_NO_AOC;
+//	    break;   // RAVI
+
+    case CM_AOC_TIMERS:
+	if (qAT_PercentCTV(CMD_SRC_LCL, &aoc_info->actual_call_timer) == AT_CMPL)
+	{
+	    aoc_info->requested_type = CM_AOC_TIMERS;
+	    return CM_OK;
+	}
+	else
+	    return CM_NO_AOC;
+//	break;  // RAVI
+
+    case CM_AOC_CCM_PUCT:
+	if (qAT_PercentCAOC(CMD_SRC_LCL, (CHAR *)aoc_info->cur, (CHAR *)aoc_info->ccm_puct) == AT_CMPL)
+	{
+	    aoc_info->requested_type = CM_AOC_CCM_PUCT;
+	    return CM_OK;
+	}
+	else
+	    return CM_NO_AOC;
+//	break;  // RAVI
+
+    case CM_AOC_ACM_PUCT:
+	if (qAT_PercentCACM(CMD_SRC_LCL, (CHAR *)aoc_info->cur, (CHAR *)aoc_info->acm_puct) == AT_CMPL)
+	{
+	    aoc_info->requested_type = CM_AOC_ACM_PUCT;
+	    return CM_OK;
+	}
+	else
+	    return CM_NO_AOC;
+    case CM_AOC_RAW_PUCT:
+	if (qAT_PercentRPCT(CMD_SRC_LCL, &rpuct) == AT_CMPL)
+	{
+	    aoc_info->requested_type = CM_AOC_RAW_PUCT;
+	    strncpy((char *)aoc_info->cur, (char *)rpuct.currency, MAX_CUR_LEN);
+	    aoc_info->eppu = rpuct.eppu;
+	    aoc_info->exp  = rpuct.exp;
+	    aoc_info->sexp = rpuct.sexp;
+	    return CM_OK;
+	}
+	else
+	    return CM_NO_AOC;
+//	break;  // RAVI
+
+    default:
+	return CM_NO_AOC;
+  }
+}
+
+
+
+/*
++----------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	       |
+| STATE   : code			 ROUTINE : cm_reset_aoc_value  |
++----------------------------------------------------------------------+
+
+
+   PURPOSE :  Setting AoC (advice of charge) value.
+
+*/
+
+T_MFW cm_set_aoc_value(UBYTE request_type,
+		       T_MFW_CM_AOC_INFO *aoc_info,
+		       UBYTE *pwd)
+{
+    TRACE_FUNCTION ("cm_reset_aoc_value()");
+
+    switch (request_type)
+    {
+	case CM_AOC_PUCT:
+	    if (sAT_PlusCPUC(CMD_SRC_LCL, (CHAR *)aoc_info->cur,
+			     (CHAR *)aoc_info->ppu, (CHAR *)pwd) != AT_EXCT)
+		return CM_ERROR;
+	    break;
+
+	case CM_AOC_ACMMAX:
+	    if (sAT_PlusCAMM(CMD_SRC_LCL, aoc_info->acm_max,
+			     (CHAR *)pwd) != AT_EXCT)
+		return CM_ERROR;
+	    break;
+
+	case CM_AOC_ACM:
+	    if (sAT_PlusCACM(CMD_SRC_LCL, (CHAR *)pwd) != AT_EXCT)
+		return CM_ERROR;
+	    break;
+
+	default:
+	    return CM_ERROR;
+    }
+
+    return CM_OK;
+}
+
+
+/*
++----------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	       |
+| STATE   : code			 ROUTINE : cm_cvt_cmd	       |
++----------------------------------------------------------------------+
+
+
+   PURPOSE :  Convert AoC command
+
+*/
+
+UBYTE cm_cvt_cmd(T_ACI_AT_CMD cmdId)
+{
+    switch (cmdId)
+    {
+	case AT_CMD_CACM:   return CM_AOC_ACM;
+	case AT_CMD_CAMM:   return CM_AOC_ACMMAX;
+	case AT_CMD_CPUC:   return CM_AOC_PUCT;
+	default:	    return CM_AOC_UNKNOWN;
+    }
+}
+
+
+/*
++----------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	       |
+| STATE   : code			 ROUTINE : cm_ok_aoc	       |
++----------------------------------------------------------------------+
+
+
+   PURPOSE :  Setting AoC is successful.
+
+*/
+
+void cm_ok_aoc(T_ACI_AT_CMD cmdId)
+{
+    T_MFW_CM_AOC_CNF aoc_cnf;
+
+    aoc_cnf.requested_type = cm_cvt_cmd(cmdId);
+    aoc_cnf.result = CM_AOC_CONF_OK;
+    cm_signal(E_CM_AOC_CNF, &aoc_cnf);
+}
+
+
+/*
++----------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	       |
+| STATE   : code			 ROUTINE : cm_error_aoc        |
++----------------------------------------------------------------------+
+
+
+   PURPOSE :  Setting AoC is failure.
+
+*/
+
+void cm_error_aoc(T_ACI_AT_CMD cmdId, T_ACI_CME_ERR reason)
+{
+    T_MFW_CM_AOC_CNF aoc_cnf;
+
+    aoc_cnf.requested_type = cm_cvt_cmd(cmdId);
+    aoc_cnf.result = CM_AOC_CONF_UNKNOWN;
+
+    if (reason EQ CME_ERR_SimPin2Req)
+	aoc_cnf.result = CM_AOC_CONF_SIMPIN2REQ;
+
+    if (reason EQ CME_ERR_WrongPasswd)
+	aoc_cnf.result = CM_AOC_CONF_WRONGPASSWD;
+
+    if (reason EQ CME_ERR_OpNotAllow)
+	aoc_cnf.result = CM_AOC_CONF_OPNOTALLOW;
+
+    if (reason EQ CME_ERR_AcmResetNeeded)
+	aoc_cnf.result = CM_AOC_CONF_ACMRESETNEEDED;
+
+    cm_signal(E_CM_AOC_CNF, &aoc_cnf);
+}
+
+
+/*
++-----------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	  |
+| STATE   : code			 ROUTINE : rAT_PercentCTV |
++-----------------------------------------------------------------+
+
+
+   PURPOSE : manage timer in every second
+
+*/
+
+void rAT_PercentCTV()
+{
+    TRACE_FUNCTION("rAT_PercentCTV()");
+    cm_signal(E_CM_TIMER_EVERY_SECOND, 0);
+}
+
+
+/*
++-----------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	  |
+| STATE   : code			 ROUTINE : rAT_PlusCCCM   |
++-----------------------------------------------------------------+
+
+
+   PURPOSE :
+
+*/
+
+void rAT_PlusCCCM(LONG *ccm)
+{
+    T_MFW_CM_AOC_INFO aoc_info;
+    T_ACI_RPCT_VAL    rpuct;
+
+    TRACE_FUNCTION("rAT_PlusCCCM()");
+
+    memset(&aoc_info, 0, sizeof(T_MFW_CM_AOC_INFO));
+
+    qAT_PlusCAMM(CMD_SRC_LCL, &aoc_info.acm_max);
+    qAT_PlusCACM(CMD_SRC_LCL, &aoc_info.acm);
+    aoc_info.ccm = *ccm;
+    qAT_PercentCTV(CMD_SRC_LCL, &aoc_info.actual_call_timer);
+    qAT_PercentRPCT(CMD_SRC_LCL, &rpuct);
+    strncpy((char *)aoc_info.cur, (char *)rpuct.currency, MAX_CUR_LEN);
+    aoc_info.requested_type = CM_AOC_CCM;
+    aoc_info.eppu = rpuct.eppu;
+    aoc_info.exp  = rpuct.exp;
+    aoc_info.sexp = rpuct.sexp;
+
+    cm_signal(E_CM_AOC, &aoc_info);
+}
+
+
+/*
++----------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	 |
+| STATE   : code			 ROUTINE : cm_set_redial |
++----------------------------------------------------------------+
+
+
+   PURPOSE :  Set redial mode (automatic/manual).
+
+*/
+
+void cm_set_redial(UBYTE redial_mode)
+{
+ // U8 version;  // RAVI
+//	Apr 14, 2005	REF: CRR 29991   xpradipg
+//	local definition
+#ifdef FF_MMI_OPTIM
+	T_MFW_CM_BLACKLIST_LIST black_list;
+#endif	
+
+  TRACE_FUNCTION ("cm_set_redial()");
+
+  if (redial_mode == CM_REDIAL_BLACKLIST)
+  {
+	memset(&black_list, 0, sizeof(T_MFW_CM_BLACKLIST_LIST));
+//	Apr 14, 2005	REF: CRR 29991   xpradipg
+//	reset the file contents
+#ifdef FF_MMI_OPTIM
+  	if(flash_MMI_blackList_write((U8 *)&black_list, sizeof(T_MFW_CM_BLACKLIST_LIST),0) < 0)
+		TRACE_FUNCTION(" Error writing into file");
+#endif	
+	return;
+  }
+
+  if (redial_mode == CM_REDIAL_OFF
+	  || redial_mode == CM_REDIAL_AUTO
+	  || redial_mode == CM_REDIAL_MANU)
+  {
+    redial_stat = redial_mode;
+
+    /* write redialing mode to EEPROM */
+
+	FFS_flashData.redial_mode =redial_mode;
+	flash_write();
+
+  }
+}
+
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	      |
+| STATE   : code			 ROUTINE : cm_get_redial_mode |
++---------------------------------------------------------------------+
+
+
+   PURPOSE :  Request the setting of redial mode (automatic/manual).
+
+*/
+
+T_MFW cm_get_redial_mode(void)
+{
+    return redial_stat;
+}
+
+
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_stop_redialTim   |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Stop redialing time.
+
+*/
+
+void cm_stop_redialTim(void)
+{
+    if (!redial_count)
+	timStop(redialTim1);
+
+    if (redial_count >= 1 AND redial_count <= 3)
+	timStop(redialTim24);
+
+    if (redial_count >= 4 AND redial_count < MAX_REDIAL_ATTEMPT)
+	timStop(redialTim5);
+	redial_count = 0;
+	rdl.left_attempts = 0;
+
+	/*
+		reset the counter
+	*/
+
+    call_stat	 = MFW_CALL_FREE;
+    call_type	 = MFW_CALL_FREE;
+    cc_stat.type = MFW_CALL_FREE;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_redial_abort     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Stop redialing from MMI.
+
+*/
+
+void cm_redial_abort(void)
+{
+
+	TRACE_FUNCTION ("cm_redial_abort()");
+
+    if (call_stat == REDIALING_CALL OR	call_stat  == OUTGOING_CALL)
+	cm_stop_redialTim();
+
+    rdl.redial_mode = CM_REDIAL_ABORTED;
+    cm_signal(E_CM_REDIAL, &rdl);
+}
+
+
+/*
++---------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		      |
+| STATE  : code 			ROUTINE: cm_autoredial_start  |
++---------------------------------------------------------------------+
+
+
+   PURPOSE :  start autoredial.
+
+*/
+
+void cm_autoredial_start(void)
+{
+	timStart(redialTim1);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_redial_timeout   |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Call back from system clock for redialing time interval.
+
+*/
+
+static int cm_redial_timeout(MfwEvt e, MfwTim *t)
+{
+  CHAR number[MFW_NUM_LEN+MAX_LEN+1];
+  int max_num_size = MFW_NUM_LEN+MAX_LEN+1;
+
+  TRACE_FUNCTION ("cm_redial_timeout()");
+
+  memset(number, 0, sizeof(number));
+  mfwStrncpy(number, (CHAR *)cc_stat.prefix, max_num_size);
+  max_num_size -= strlen((char *)cc_stat.prefix);
+  
+  if ((cc_stat.ton EQ MFW_TON_INTERNATIONAL) AND (cc_stat.number[0] != '+'))
+  {
+    strcat(number, "+");
+    max_num_size--;
+  }
+  
+  strncat(number, (CHAR *)cc_stat.number, max_num_size);
+
+  switch (redial_stat)
+  {
+    case CM_REDIAL_AUTO:
+      if (sAT_Dn(CMD_SRC_LCL,
+			     (CHAR *)number,
+			      D_CLIR_OVRD_Default,
+			      D_CUG_CTRL_NotPresent,
+			      D_TOC_Voice) NEQ AT_EXCT)
+      {
+	    TRACE_ERROR("sAT_Dn error");
+	return 0;
+      }
+
+      call_stat    = OUTGOING_CALL;
+
+      cm_search_callId(CAL_STAT_Dial, &cc_stat.call_number);
+      cc_stat.type = REDIALING_CALL;
+
+      rdl.redial_mode	= CM_REDIAL_ATTEMPT;
+      rdl.call_id	= cc_stat.call_number;
+      mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
+#ifdef NO_ASCIIZ
+      rdl.name.len = cc_stat.name.len;
+      memcpy(rdl.name.data,
+	     cc_stat.name.data,
+	     cc_stat.name.len);
+#else
+      mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
+//	strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
+#endif
+      rdl.ton = cc_stat.ton;
+      rdl.type = cc_stat.mode;
+      redial_count++;
+      rdl.left_attempts = MAX_REDIAL_ATTEMPT - redial_count;
+      cm_signal(E_CM_REDIAL, &rdl);
+      return 1;
+
+    case CM_REDIAL_MANU:
+      rdl.redial_mode	= CM_REDIAL_MANU;
+      mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
+#ifdef NO_ASCIIZ
+      rdl.name.len = cc_stat.name.len;
+      memcpy(rdl.name.data,
+	     cc_stat.name.data,
+	     cc_stat.name.len);
+#else
+      mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
+#endif
+      rdl.ton = cc_stat.ton;
+      rdl.type = cc_stat.mode;
+      rdl.left_attempts = MAX_REDIAL_ATTEMPT - redial_count;
+
+      cm_signal(E_CM_REDIAL, &rdl);
+      return 1;
+
+    default:
+      return 0;
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_redial	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Start the manual redialing.
+
+*/
+
+void cm_redial()
+{
+  char buf[80];
+
+  int max_buf_size = sizeof(buf);
+
+  TRACE_FUNCTION ("cm_redial()");
+
+  buf[0] = '\0';
+
+  mfwStrncpy(buf, (char *)cc_stat.prefix, max_buf_size);
+  max_buf_size -= strlen((char *)cc_stat.prefix);
+  
+  if ((cc_stat.ton EQ MFW_TON_INTERNATIONAL) AND (cc_stat.number[0] != '+'))
+  {
+      strcat(buf, "+");
+      max_buf_size--;
+  }
+
+  strncat(buf, (char *)cc_stat.number, max_buf_size);
+
+  if (sAT_Dn(CMD_SRC_LCL, buf, -1, -1, D_TOC_Voice) NEQ AT_EXCT)
+  {
+	TRACE_ERROR("sAT_Dn error");
+  }
+
+  call_stat = OUTGOING_CALL;
+  cc_stat.type = REDIALING_CALL;
+  redial_count++;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_redial_get_count	 |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  returns the counter of call attempt
+
+*/
+UBYTE	cm_redial_get_count(void)
+{
+	return redial_count;
+}
+
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_cvt_call_status  |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Convert the call status.
+
+*/
+
+LOCAL T_MFW_CM_CALL_STAT cm_cvt_call_status( T_ACI_CAL_STAT stat )
+{
+  switch ( stat )
+  {
+    case ( CAL_STAT_Held ):    return CALL_HELD;
+    case ( CAL_STAT_Active ):  return CALL_ACTIVE;
+    case ( CAL_STAT_Wait ):    return CALL_WAIT;
+    case ( CAL_STAT_Dial ):    return CALL_DIAL;
+    case (CAL_STAT_Alerting):  return CALL_ALERT;
+    case (CAL_STAT_DeactiveReq): return CALL_DEACTIVE;
+    default:		       return NOT_PRESENT;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_cvt_call_status  |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Request the call status.
+
+*/
+
+T_MFW_CM_CALL_TYPE cm_cvt_call_mode( T_ACI_CAL_MODE type )
+{
+TRACE_EVENT_P1("cm_cnt_call_mode %d", type);
+  switch ( type )
+  {
+    case ( CAL_MODE_Voice ):	return VOICE_CALL;
+    case ( CAL_MODE_Data ):	return DATA_CALL;
+    case ( CAL_MODE_Fax ):	return FAX_CALL;
+    case (CAL_MODE_VFD_Voice):	return VFD_VOICE;
+    case (CAL_MODE_VAD_Voice):	return VAD_VOICE;
+    case (CAL_MODE_VAF_Voice):	return VAF_VOICE;
+    case (CAL_MODE_VFD_Data):	return VFD_DATA;
+    case (CAL_MODE_VAD_Data):	return VAD_DATA;
+    case (CAL_MODE_VAF_Fax):	return VAF_FAX;
+    default:			return NONE_TYPE;
+  }
+}
+
+T_MFW_CM_CALL_DIR cm_cvt_call_direction( T_ACI_CAL_TYPE type )
+{
+TRACE_EVENT_P1("cm_cvt_call_direction %d", type);
+  switch ( type )
+  {
+    case ( CAL_TYPE_NotPresent):	return MFW_CM_INV_DIR;
+    case ( CAL_TYPE_MOC):			return MFW_CM_MOC;
+    case ( CAL_TYPE_MTC):			return MFW_CM_MTC;
+    default:			return MFW_CM_INV_DIR;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_status	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Request the call status.
+
+*/
+
+int cm_status(SHORT call_number, T_MFW_CM_STATUS *status, UBYTE num)
+{
+    UBYTE cnt;
+    int   i;
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	define and allocate memory
+#ifdef FF_MMI_OPTIM
+	T_ACI_CAL_ENTR 	    *call_tab;//[MAX_CALL_NR];
+	call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+	if( NULL == call_tab)
+		return 0;
+#endif
+
+
+    cnt = 0;
+    qAT_PercentCAL(CMD_SRC_LCL, call_tab);
+
+    if (call_number > 0)
+    {
+      for (i=0; i<MAX_CALL_NR; i++)
+      {
+	if (call_tab[i].index == call_number)
+	{
+	  status[0].call_number = call_tab[i].index;
+	  status[0].stat =  cm_cvt_call_status(call_tab[i].status);
+	  status[0].type = cm_cvt_call_mode(call_tab[i].calMode);
+	  status[0].mtpy = (T_MFW_MTPY_MEMBER)call_tab[i].mpty;
+	  status[0].call_direction = cm_cvt_call_direction(call_tab[i].calType);
+
+	  if (call_tab[i].number != NULL)
+	  {
+	    mfwStrncpy((char *)status[0].number, call_tab[i].number, MFW_NUM_LEN);
+	    status[0].ton = phb_cvtTon(call_tab[i].type.ton);
+	  }
+	  else
+	    memset(status[0].number, '\0', MFW_NUM_LEN);
+
+#ifdef NO_ASCIIZ
+	  status[0].name.len = call_tab[i].alpha.len;
+	  if (call_tab[i].alpha.len)
+	    memcpy(status[0].name.data,
+		   call_tab[i].alpha.data,
+		   call_tab[i].alpha.len);
+	  else //We'll also zero the string.
+	    memset(status[0].name.data, '\0', PHB_MAX_LEN);
+#else
+	  if (call_tab[i].alpha != NULL)
+	    mfwStrncpy((char *)status[0].name, call_tab[i].alpha, MFW_TAG_LEN);
+	  else
+	    memset(status[0].name, '\0', MFW_TAG_LEN);
+#endif
+	  cnt = 1;
+	  break;
+	}
+      }
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	deallocate memory
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif      
+      return cnt;
+    }
+
+    if (!call_number)
+    {
+      for (i=0; i<MAX_CALL_NR; i++)
+      {
+	if ((call_tab[i].index EQ -1) OR cnt > num)
+	    break;
+
+	if (call_tab[i].status != CAL_STAT_NotPresent)
+	{
+	  status[cnt].call_number = call_tab[i].index;
+	  status[cnt].stat = cm_cvt_call_status(call_tab[i].status);
+	  status[cnt].type = cm_cvt_call_mode(call_tab[i].calMode);
+	  status[cnt].mtpy = (T_MFW_MTPY_MEMBER)call_tab[i].mpty;
+	  if (call_tab[i].number != NULL)
+	  {
+	    mfwStrncpy((char *)status[cnt].number, call_tab[i].number, MFW_NUM_LEN);
+	    status[cnt].ton = phb_cvtTon(call_tab[i].type.ton);
+	  }
+	  else
+	    memset(status[cnt].number, '\0', MFW_NUM_LEN);
+
+#ifdef NO_ASCIIZ
+	  status[cnt].name.len = call_tab[i].alpha.len;
+	  if (call_tab[i].alpha.len != 0)
+	    memcpy(status[cnt].name.data,
+		   call_tab[i].alpha.data,
+		   call_tab[i].alpha.len);
+	  else //We'll also zero the string.
+	    memset(status[cnt].name.data, '\0', PHB_MAX_LEN);
+#else
+	  if (call_tab[i].alpha != NULL)
+	    mfwStrncpy((char *)status[cnt].name, call_tab[i].alpha, MFW_TAG_LEN);
+	  else
+	    memset(status[cnt].name, '\0', MFW_TAG_LEN);
+#endif
+	  cnt++;
+	}
+      }
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+//	deallocate memory
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif      
+      return cnt;
+    }
+// 	Apr 06 2005		REF: CRR 29989	xpradipg	
+// deallocate memory
+#ifdef FF_MMI_OPTIM
+	    if(call_tab)
+	    mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
+#endif    
+    return 0;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_AT_CHLD	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Notify the CHLD command
+
+*/
+
+void cm_AT_CHLD(T_ACI_CLOG *clog_cmd)
+{
+    SHORT id;
+    T_ACI_CAL_MODE call_mode;
+    T_MFW_CM_STATUS status;
+    char buf[80];
+
+    TRACE_EVENT("cm_AT_CHLD()");
+
+    /*SPR#1965 - DS - Removed setting of call_number to zero. Port of 1962
+     *dis_connect.call_number = 0;
+     */
+    sprintf(buf, "dis_connect.call_number %d, cmd_hold %d, cId %d, srcId %d, mode %d, act %d",
+            dis_connect.call_number, cmd_hold, clog_cmd->cId, clog_cmd->cmdPrm.sCHLD.srcId,
+            clog_cmd->cmdPrm.sCHLD.mode, clog_cmd->cmdPrm.sCHLD.act);
+    TRACE_EVENT(buf);
+
+    if ((clog_cmd->cmdPrm.sCHLD.act != CHLD_ACT_Retrieve) &&
+         (clog_cmd->cmdPrm.sCHLD.act != CHLD_ACT_RetrieveMpty))
+    {
+         /*SPR#1962 - DS - Set call_number to call Id returned from ACI */
+        TRACE_EVENT("Set dis_connect.call_number to clog_cmd->cId");
+        dis_connect.call_number = clog_cmd->cId;
+    }
+    else
+    {
+        dis_connect.call_number = -1;
+    }
+    if (clog_cmd->cmdPrm.sCHLD.srcId == CMD_SRC_LCL)
+    {
+	switch(clog_cmd->cmdPrm.sCHLD.mode)
+	{
+	    case CHLD_MOD_RelHldOrUdub:
+
+		if (cm_search_callId(CAL_STAT_DeactiveReq, &id) == CM_OK)
+		{
+		   TRACE_FUNCTION("CAL_STAT_DeactiveReq - 0SEND");
+		    if ( cmd_hold EQ MFW_CM_1_SEND )
+		    {
+		    	TRACE_FUNCTION("cmd_hold EQ MFW_CM_1_SEND");
+			cm_status(id, &status, 1);
+			if (status.mtpy EQ MFW_MTPY_MEMBER)
+			  dis_connect.call_number = 0;
+			else
+			  dis_connect.call_number = id;
+		    }
+		}
+			
+		break;
+					
+	case CHLD_MOD_RelActAndAcpt:
+
+		// MMI-SPR 13873 xkundadu
+		// Handling of 1+SEND - Releases all active calls (if any exist) and 
+		// accepts the other (held or waiting) call.
+
+		if( (cm_search_callId(CAL_STAT_DeactiveReq, &id) == CM_OK) OR
+		(cm_search_callId(CAL_STAT_Active, &id) == CM_OK))
+		{
+			// If there is an active call/active call whose disconnection
+			// is initiated, store the index of that call.
+			dis_connect.call_number = id;
+			if(bIsMultpty == TRUE)
+			{
+				//  Call is in multiparty
+				//  1SEND for multiparty will disconnect all the active calls
+				//  To clear all calls assign the dis_connect.call_number to 
+				//  zero
+				dis_connect.call_number = 0;	
+				bIsMultpty = FALSE;
+			}
+		}
+		else
+		{
+			// There is no active calls/active calls whose disconnection is 
+			// iniated existing
+			dis_connect.call_number = -1;	
+		}
+		if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)
+		{
+			// Waiting call is existing.
+			// In the function cm_result_cmd(), value of cmd.call_number
+			// is used to determine whether to call cm_connect() or not
+			cmd.call_number=0;
+		}
+		cmd_hold = MFW_CM_1_SEND; 
+		break;
+	
+	case CHLD_MOD_HldActAndAcpt:
+		
+		// MMI -SPR 13873 xkundadu
+		// Handling of 2+SEND - Places all active calls (if any exist) on hold
+		// and accepts the other (held or waiting) call.
+		
+		switch (clog_cmd->cmdPrm.sCHLD.act)
+		{
+		
+		  case CHLD_ACT_Accept:
+		  	   // Accept the incoming call
+			    cmd_hold = MFW_CM_MT_ACCEPT;
+			    break;
+				
+		  case CHLD_ACT_Hold:
+		  	    // Getting the id of the call which has been put on hold by ACI
+			    cmd.command = CM_HOLD;
+			    if (cm_search_callId(CAL_STAT_Held, &id) == CM_OK)
+			    {
+			     	   cmd.call_number = id;
+			    }
+			    else
+			    {
+			      	   cmd.call_number = -1;
+			    }
+			    break;
+				
+		  case CHLD_ACT_Swap:
+		  	   // Swap the call
+			    cmd.command = CM_SWAP;
+			    break;
+				
+		  case CHLD_ACT_Retrieve:
+		  	    // Getting the id of the call which has been made active by ACI
+			    cmd.command = CM_RETRIEVE;
+			    if (cm_search_callId(CAL_STAT_Active, &id) == CM_OK)
+			    {
+			      	   cmd.call_number = id;
+			    }
+			    else
+			    {
+			          cmd.call_number = -1;
+			    }
+			    break;
+		  case CHLD_ACT_HoldMpty:
+		  	    // Put the calls on HOLD
+			    cmd.command = CM_HOLD_MULTIPARTY;
+			    break;
+				
+		  case CHLD_ACT_RetrieveMpty:
+		  	    // Retrieve the held calls to active
+			    cmd.command = CM_RETRIEVE_MULTIPARTY;
+			    break;
+				
+		   case CHLD_ACT_SwapMpty:
+		  	    // Swap muliparty calls
+			    cmd.command = CM_SWAP_MULTIPARTY;
+			    break;
+				
+		  default:
+			    cmd.command = CM_COMMAND_UNKNOWN;
+			    break;
+				
+		}
+		break;
+	   case CHLD_MOD_RelActSpec:
+		dis_connect.call_number = (SHORT)atoi(clog_cmd->cmdPrm.sCHLD.call);
+		break;			
+		
+	    default:
+		break;
+	}
+    }
+
+//	Aug 23, 2004 REF: CRR 22222  xkundadu
+//  Bug:  Runaway Call Waiting Tone.
+//  Fix: Handle the AT-Command source id CMD_SRC_ATI_2 also for call control
+//  callback functions.Include source Id CMD_SRC_ATI_2 also for checking.
+
+//Nov 02, 2005    DR OMAPS00052132   xdeepadh
+//The usage of ATI enum is put under the flag FF_ATI
+#ifdef FF_ATI  
+    if ((clog_cmd->cmdPrm.sCHLD.srcId == CMD_SRC_ATI_1) //NM Berlin UK integration
+		OR (clog_cmd->cmdPrm.sCHLD.srcId == CMD_SRC_ATI_2)) // Added for MMI-SPR 22222 FIX
+    {
+	switch(clog_cmd->cmdPrm.sCHLD.mode)
+	{
+	    case CHLD_MOD_RelHldOrUdub:
+		if (clog_cmd->cmdPrm.sCHLD.act == CHLD_ACT_Release)
+		    dis_connect.call_number = clog_cmd->cId;
+		cmd_hold = MFW_CM_TERMINATED;
+		break;
+	    case CHLD_MOD_RelActAndAcpt:
+		switch (clog_cmd->cmdPrm.sCHLD.act)
+		{
+		    case CHLD_ACT_Release:
+			dis_connect.call_number = clog_cmd->cId;
+			break;
+		    case CHLD_ACT_Accept:
+			if (cm_search_callId(CAL_STAT_DeactiveReq, &id) == CM_OK)
+			    dis_connect.call_number = id;
+			else if (cm_search_callId(CAL_STAT_Active, &id) == CM_OK)
+			{
+			    call_mode = cm_search_callMode(id);
+			    if (call_mode EQ CAL_MODE_Data
+				OR call_mode EQ CAL_MODE_Fax)
+				dis_connect.call_number = id;
+			}
+			if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)
+			    cc_id = id;
+			break;
+		    case CHLD_ACT_Retrieve:
+			if (cm_search_callId(CAL_STAT_Held, &id) == CM_OK)
+			{
+			    cmd.command     = CM_RETRIEVE;
+			    cmd.call_number = id;
+			}
+			if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)
+			    cc_id = id;
+			break;
+		}
+		cmd_hold = MFW_CM_1_SEND;
+		break;
+	    case CHLD_MOD_RelActSpec:
+		dis_connect.call_number = clog_cmd->cId;
+		if (dis_connect.call_number)
+	       cmd_hold = MFW_CM_TERMINATED;
+	    else
+	       cmd_hold = MFW_CM_MPTY_TERMINATED;
+		break;
+	    case   CHLD_MOD_HldActAndAcpt:
+		switch (clog_cmd->cmdPrm.sCHLD.act)
+		{
+		  case CHLD_ACT_Accept:
+		    cmd_hold = MFW_CM_MT_ACCEPT;
+		    break;
+		  case CHLD_ACT_Hold:
+		    cmd.command = CM_HOLD;
+		    if (cm_search_callId(CAL_STAT_Held, &id) == CM_OK)
+		      cmd.call_number = id;
+		    else
+		      cmd.call_number = -1;
+		    break;
+		  case CHLD_ACT_Swap:
+		    cmd.command = CM_SWAP;
+		    break;
+		  case CHLD_ACT_Retrieve:
+		    cmd.command = CM_RETRIEVE;
+		    if (cm_search_callId(CAL_STAT_Active, &id) == CM_OK)
+		      cmd.call_number = id;
+		    else
+		      cmd.call_number = -1;
+		    break;
+		  case CHLD_ACT_SwapMpty:
+		    cmd.command = CM_SWAP_MULTIPARTY;
+		    break;
+		  case CHLD_ACT_HoldMpty:
+		    cmd.command = CM_HOLD_MULTIPARTY;
+		    break;
+		  case CHLD_ACT_RetrieveMpty:
+		    cmd.command = CM_RETRIEVE_MULTIPARTY;
+		    break;
+		  default:
+		    cmd.command = CM_COMMAND_UNKNOWN;
+		    break;
+		}
+		break;
+	    case CHLD_MOD_HldActExc:
+		 if (clog_cmd->cmdPrm.sCHLD.act == CHLD_ACT_SplitMpty)
+		  cmd.command = CM_SPLIT_MULTIPARTY;
+		else
+		  cmd.command = CM_COMMAND_UNKNOWN;
+		break;
+	    case CHLD_MOD_AddHld:
+		if (clog_cmd->cmdPrm.sCHLD.act == CHLD_ACT_BuildMpty)
+		  cmd.command = CM_RETRIEVE_MULTIPARTY;
+		else
+		  cmd.command = CM_COMMAND_UNKNOWN;
+		break;
+	    case CHLD_MOD_Ect:
+		cmd.command = CM_ETC;
+		break;
+	    case CHLD_MOD_Ccbs:
+	        TRACE_EVENT("CHLD_MOD_Ccbs");
+		cmd.command = CM_CCBS;
+		break;
+	    case CHLD_MOD_HldActDial:
+		cmd_hold = MFW_CM_HOLD_AND_DIAL;
+		cmd.command = CM_HOLD;
+		break;
+	    default:
+		break;
+	}
+   }
+#endif		//FF_ATI  
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_AT_D	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Notify the outgoing call command.
+
+*/
+
+void cm_AT_D(T_ACI_CLOG *cmd)
+{
+    SHORT	       index;
+    T_MFW_PHB_ENTRY    entry;
+    T_MFW_CM_CALL_STAT stat;
+    UBYTE	       ton;
+    UBYTE	       mode;
+    T_MFW_PHB_TEXT     findText;
+
+    TRACE_FUNCTION("cm_at_d()");
+#ifdef NO_ASCIIZ
+    entry.name.len = 0;
+#else
+    memset (entry.name, '\0', MAX_LEN);
+#endif
+    memset (entry.number, '\0', MAX_LEN);
+    entry.index = 0;
+    entry.npi = 0;
+    entry.ton = 0;
+    entries.entry = &entry;
+
+    if (cmd->cmdPrm.sD.srcId == CMD_SRC_LCL)
+    {
+	out_call.call_id = cmd->cId;
+	mfwStrncpy((char *)out_call.number, cmd->cmdPrm.sD.number, MFW_NUM_LEN);
+	if (cc_stat.type == OUTGOING_CALL)
+	{
+	    mfwStrncpy((char *)cc_stat.number, cmd->cmdPrm.sD.number, MFW_NUM_LEN);
+#ifdef NO_ASCIIZ
+	    cc_stat.name.len = 0;
+	    out_call.name.len = 0;
+#else
+	    cc_stat.name[0] = '\0';
+	    out_call.name[0] = '\0';
+#endif
+	    if (cm_search_callStat(cmd->cId, &stat, &ton, &mode) == CM_OK)
+	    {
+		out_call.ton = ton;
+		out_call.type = mode;
+		cc_stat.ton  = ton;
+		cc_stat.mode = (T_MFW_CM_CALL_TYPE)mode;
+	    }
+
+#ifdef NO_ASCIIZ
+	    mfwStrncpy((char *)findText.data, cmd->cmdPrm.sD.number, PHB_MAX_LEN);
+	    findText.len = strlen(cmd->cmdPrm.sD.number);
+	    if (phb_find_entries (PHB_ADN,
+				  &index,
+				  MFW_PHB_NUMBER,
+				  1,
+				  &findText,
+				  &entries) EQ MFW_PHB_OK)
+	    {
+		if (entries.num_entries)
+		{
+		    cc_stat.name.len = entries.entry[0].name.len;
+		    memcpy(cc_stat.name.data,
+			   entries.entry[0].name.data,
+			   entries.entry[0].name.len);
+
+		    out_call.name.len = entries.entry[0].name.len;
+		    memcpy(out_call.name.data,
+			   entries.entry[0].name.data,
+			   entries.entry[0].name.len);
+		}
+	    }
+#else
+	    if (phb_find_entries (PHB_ADN,
+				  &index,
+				  MFW_PHB_NUMBER,
+				  1,
+				  cmd->cmdPrm.sD.number,
+				  (T_MFW_PHB_LIST *)&entries) EQ MFW_PHB_OK)
+	    {
+		if (entries.num_entries)
+		{
+		    mfwStrncpy((char *)cc_stat.name, (char *)entries.entry[0].name, MFW_TAG_LEN);
+		    mfwStrncpy((char *)out_call.name, (char *)entries.entry[0].name, PHB_MAX_LEN);
+		}
+	    }
+#endif
+	}
+
+	if (cc_stat.type == REDIALING_CALL)
+	{
+#ifdef NO_ASCIIZ
+	    out_call.name.len = cc_stat.name.len;
+	    memcpy(out_call.name.data,
+		   cc_stat.name.data,
+		   cc_stat.name.len);
+#else
+	    mfwStrncpy((char *)out_call.name, (char *)cc_stat.name, MFW_TAG_LEN);
+#endif
+	    out_call.ton = cc_stat.ton;
+	    out_call.type = cc_stat.mode;
+	}
+	cm_signal(E_CM_MO_RES, &out_call);
+    }
+    else if (cmd->cmdPrm.sD.srcId < CMD_SRC_MAX)
+    {
+	out_call.call_id = cmd->cId;
+	mfwStrncpy((char *)out_call.number, (char *)cmd->cmdPrm.sD.number, MFW_NUM_LEN);
+#ifdef NO_ASCIIZ
+	out_call.name.len = 0;
+#else
+	out_call.name[0] = '\0';
+#endif
+	if (cm_search_callStat(cmd->cId, &stat, &ton, &mode) == CM_OK)
+	{
+	    out_call.ton = ton;
+	    out_call.type = mode;
+	}
+
+#ifdef NO_ASCIIZ
+	mfwStrncpy((char *)findText.data, cmd->cmdPrm.sD.number, PHB_MAX_LEN);
+	findText.len = strlen(cmd->cmdPrm.sD.number);
+	if (phb_find_entries (PHB_ADN,
+			      &index,
+			      MFW_PHB_NUMBER,
+			      1,
+			      &findText,
+			      &entries) EQ MFW_PHB_OK)
+	{
+	    if (entries.num_entries)
+	    {
+		out_call.name.len = entries.entry[0].name.len;
+		memcpy(out_call.name.data,
+		       entries.entry[0].name.data,
+		       entries.entry[0].name.len);
+	    }
+	}
+#else
+	if (phb_find_entries (PHB_ADN,
+			      &index,
+			      MFW_PHB_NUMBER,
+			      1,
+			      cmd->cmdPrm.sD.number,
+			      (T_MFW_PHB_LIST *)&entries) EQ MFW_PHB_OK)
+	{
+	    if (entries.num_entries)
+	    {
+		mfwStrncpy((char *)out_call.name, (char *)entries.entry[0].name, MFW_TAG_LEN);
+	    }
+	}
+#endif
+	cm_signal(E_CM_MO_RES, &out_call);
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_cvtCPItype	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Convert the type of
+
+*/
+
+T_MFW_CPI_TYPE cm_cvtCPItype(T_ACI_CPI_MSG msg)
+{
+    switch (msg)
+	{
+		case CPI_MSG_Setup: return CPI_TYPE_SETUP;
+		case CPI_MSG_Disc:  return CPI_TYPE_DISC;
+	case CPI_MSG_Alert: return CPI_TYPE_ALERT;
+		case CPI_MSG_Proc:  return CPI_TYPE_PROC;
+	case CPI_MSG_Sync:  return CPI_TYPE_SYNC;
+	 case CPI_MSG_Conn: return CPI_TYPE_CONN;
+	 /* CQ11676 Added new messages types in CPi indication. 17-02-04 MZ */
+    #ifndef FF_2TO1_PS                      
+		case CPI_MSG_Rls:  return CPI_TYPE_RELEASE;
+	case CPI_MSG_Rjct:  return CPI_TYPE_REJECT;
+    #endif                     
+		default:		    return CPI_TYPE_UNKNOWN;
+	}
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_cvtIBT	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Convert in-band tones indication
+
+*/
+
+T_MFW_CPI_IBT cm_cvtIBT(T_ACI_CPI_IBT ibt)
+{
+    switch (ibt)
+	{
+		case CPI_IBT_False: return CPI_IBT_FALSE;
+		case CPI_IBT_True:  return CPI_IBT_TRUE;
+		default:		    return CPI_IBT_UNKNOWN;
+	}
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_cvtTCH	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Convert traffic channel indication
+
+*/
+
+T_MFW_CPI_TCH cm_cvtTCH(T_ACI_CPI_TCH tch)
+{
+    switch (tch)
+	{
+		case CPI_TCH_False: return CPI_TCH_FALSE;
+		case CPI_TCH_True:  return CPI_TCH_TRUE;
+		default:		    return CPI_TCH_UNKNOWN;
+	}
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: rAT_PercentCPI      |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Call Progress Information
+
+*/
+// ADDED BY RAVI - FOR ACI CHANGES - 5-10-2005
+#if (defined(FF_2TO1_PS)  &&  BOARD != 61)
+void rAT_PercentCPI(SHORT cId,
+		    T_ACI_CPI_MSG msgType,
+		    T_ACI_CPI_IBT ibt,
+		    T_ACI_CPI_TCH tch)
+
+{
+    cm_cpi.call_number = cId;
+    cm_cpi.type        = cm_cvtCPItype(msgType);
+    cm_cpi.inband      = cm_cvtIBT(ibt);
+    cm_cpi.tch	       = cm_cvtTCH(tch);
+//    cm_cpi.cause = CPI_CAUSE_MASK & cause; /* cq11676 Add cause information to the CPI indication 17-02-04 MZ */
+    cm_signal(E_CM_CPI, &cm_cpi);
+}
+#else
+void rAT_PercentCPI(SHORT cId,
+		    T_ACI_CPI_MSG msgType,
+		    T_ACI_CPI_IBT ibt,
+		    T_ACI_CPI_TCH tch,
+        	    USHORT        cause )        /*cq11676 Add cause parameter for cpi indication 17-02-04 MZ */
+{
+    cm_cpi.call_number = cId;
+    cm_cpi.type        = cm_cvtCPItype(msgType);
+    cm_cpi.inband      = cm_cvtIBT(ibt);
+    cm_cpi.tch	       = cm_cvtTCH(tch);
+    cm_cpi.cause = CPI_CAUSE_MASK & cause; /* cq11676 Add cause information to the CPI indication 17-02-04 MZ */
+    cm_signal(E_CM_CPI, &cm_cpi);
+}
+#endif
+// END OF ADDITION - RAVI - 5-10-2005.
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_error_code	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :
+
+*/
+
+UBYTE cm_error_code(T_ACI_AT_CMD cmd)
+{
+    ULONG err;
+
+    err = qAT_ErrDesc();
+    switch (ACI_ERR_DESC_CLASS( err ))
+    {
+	case ACI_ERR_CLASS_Cme:
+	    break;
+	case ACI_ERR_CLASS_Cms:
+	    break;
+	case ACI_ERR_CLASS_Ceer:
+	    switch (ACI_ERR_DESC_NR( err ))
+	    {
+		case CEER_ACM_Max:	return CM_ACM_MAX;
+		default:		return CM_ERROR;
+	    }
+//	    break;  // RAVI
+	case ACI_ERR_CLASS_Ext:
+	    switch (ACI_ERR_DESC_NR( err ))
+	    {
+		case EXT_ERR_FdnCheck:	return CM_CFDN_ERR;
+		case EXT_ERR_BdnCheck:	return CM_CBDN_ERR;
+		case EXT_ERR_OneCallOnHold:	return CM_2CALLS_ALREADY_ERR;
+		//xvilliva 21421 - Handling err code returned by ACI.
+#ifndef FF_2TO1_PS
+	    case EXT_ERR_AlsLock:	return CM_ALS_ERR;
+#endif
+		default:		return CM_ERROR;
+	    }
+	  //  break;  // RAVI
+	default:
+	    break;
+    }
+    return CM_ERROR;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	     |
+| STATE   : code			 ROUTINE : cm_bc_parameter   |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Notice bearer service parameter
+
+*/
+
+void cm_bc_parameter(T_ACI_CRING_TYP type)
+{
+  TRACE_FUNCTION("cm_cvt_cringType()");
+
+  switch (type)
+  {
+    case CRING_TYP_Voice:
+      break;
+    case CRING_TYP_Fax:
+      in_call.bc1.conn_elem   = Transparent;
+      break;
+    case CRING_TYP_Sync:
+      in_call.bc1.bearer_serv = Synch;
+      in_call.bc1.conn_elem   = Transparent;
+      break;
+    case CRING_TYP_Async:
+      in_call.bc1.bearer_serv = Asynch;
+      in_call.bc1.conn_elem   = Transparent;
+      break;
+    case CRING_TYP_RelSync:
+      in_call.bc1.bearer_serv = Synch;
+      in_call.bc1.conn_elem   = NonTransparent;
+      break;
+    case CRING_TYP_RelAsync:
+      in_call.bc1.bearer_serv = Asynch;
+      in_call.bc1.conn_elem   = NonTransparent;
+      break;
+    default:
+      break;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	 MODULE  : MFW_CM	     |
+| STATE   : code			 ROUTINE : cm_build_callType |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :
+
+*/
+
+void cm_build_callType(T_ACI_CRING_TYP type1, T_ACI_CRING_TYP type2)
+{
+  if (type1 EQ CRING_TYP_Voice)
+  {
+    switch (type2)
+    {
+      case CRING_TYP_Sync:
+      case CRING_TYP_Async:
+      case CRING_TYP_RelSync:
+      case CRING_TYP_RelAsync:
+	in_call.type = VAD_VOICE;
+	return;
+      case CRING_TYP_Fax:
+	in_call.type = VAF_VOICE;
+	return;
+      default:
+	break;
+    }
+  }
+  if (type2 EQ CRING_TYP_Voice)
+  {
+    switch (type1)
+    {
+      case CRING_TYP_Sync:
+      case CRING_TYP_Async:
+      case CRING_TYP_RelSync:
+      case CRING_TYP_RelAsync:
+	in_call.type = VAD_DATA;
+	return;
+      case CRING_TYP_Fax:
+	in_call.type = VAF_FAX;
+	return;
+      default:
+	break;
+    }
+  }
+  in_call.type = NONE_TYPE;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)	MODULE	: MFW_CM	     |
+| STATE   : code			ROUTINE : cmCommand	     |
++--------------------------------------------------------------------+
+
+  PURPOSE : handle mfw windows command
+
+*/
+
+static int cmCommand (U32 cmd, void *h)
+{
+    switch (cmd)
+    {
+	case MfwCmdDelete:		/* delete me		    */
+	    if (!h)
+		return 0;
+	    cm_delete(h);
+	    return 1;
+	default:
+	    break;
+    }
+
+    return 0;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_command_abort    |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :
+
+*/
+
+T_MFW cm_command_abort(UBYTE command)
+{
+  TRACE_FUNCTION ("cm_command()");
+
+  switch (command)
+  {
+    case CM_HOLD:
+    case CM_SWAP:
+    case CM_RETRIEVE:
+    case CM_SWAP_MULTIPARTY:
+    case CM_HOLD_MULTIPARTY:
+    case CM_RETRIEVE_MULTIPARTY:
+    case CM_BUILD_MULTIPARTY:
+    case CM_SPLIT_MULTIPARTY:
+    case CM_ETC:
+    case CM_CCBS:
+      sAT_Abort(CMD_SRC_LCL, AT_CMD_CHLD);
+      break;
+
+    case CM_DTMF_ACTIVE:
+    case CM_DTMF_INACTIVE:
+    case CM_DTMF_AUTO:
+      sAT_Abort(CMD_SRC_LCL, AT_CMD_VTS);
+      break;
+
+    default:
+      return FALSE;
+  }
+  return TRUE;
+}
+
+/* Marcus: CCBS: 13/11/2002: Start */
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)     MODULE: MFW_CM                   |
+| STATE  : code     ROUTINE: cm_ccbs_delete_all                      |
++--------------------------------------------------------------------+
+
+   PURPOSE :    Delete all registered CCBS
+
+   Returns:		T_MFW: CM_OK if successful, CM_ERROR if not
+
+   Arguments:   None
+*/
+T_MFW    cm_ccbs_delete_all(void)
+{
+    T_MFW           res = CM_ERROR;     // The value to be returned by this function
+    T_ACI_RETURN    aci_res;            // The value returned by sAT_PercentCCBS
+
+    TRACE_FUNCTION("cm_ccbs_delete_all()");
+
+    if (ccbs_op == CM_CCBS_NONE)
+    {
+        TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
+        /* No CCBS operation currently in progress */
+#ifndef CCBS_TEST
+        aci_res = sAT_PercentCCBS(CMD_SRC_LCL, 0);
+#else
+        aci_res = AT_EXCT;
+#endif
+        if (aci_res == AT_EXCT)
+        {
+            TRACE_EVENT("sAT_PercentCCBS returned AT_EXCT");
+            ccbs_op = CM_CCBS_DELETE_ALL;
+            res = CM_OK;
+        }
+        else
+        {
+            TRACE_EVENT_P1("sAT_PercentCCBS returned %d", aci_res);
+        }
+    }
+    else
+    {
+        TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
+    }
+
+    return res;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)     MODULE: MFW_CM                   |
+| STATE  : code     ROUTINE: cm_ccbs_delete                          |
++--------------------------------------------------------------------+
+
+   PURPOSE :    Delete a specific registered CCBS
+
+   Returns:		T_MFW: CM_OK if successful, CM_ERROR if not
+
+   Arguments:   SHORT idx: the index to the specific CCBS to be deleted
+*/
+T_MFW    cm_ccbs_delete(SHORT idx)
+{
+    T_MFW           res = CM_ERROR; // The value to be returned by this function
+    T_ACI_RETURN    aci_res;        // The value returned by sAT_PercentCCBS
+
+    TRACE_FUNCTION("cm_ccbs_delete()");
+    TRACE_EVENT_P1("deleting CCBS %d", idx);
+
+    if (ccbs_op == CM_CCBS_NONE)
+    {
+        TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
+        /* No CCBS operation currently in progress */
+#ifndef CCBS_TEST
+        aci_res = sAT_PercentCCBS(CMD_SRC_LCL, idx);
+#else
+        aci_res = AT_EXCT;
+#endif
+        if (aci_res == AT_EXCT)
+        {
+            TRACE_EVENT("sAT_PercentCCBS returned AT_EXCT");
+            ccbs_op = CM_CCBS_DELETE;
+            res = CM_OK;
+        }
+        else
+        {
+            TRACE_EVENT_P1("sAT_PercentCCBS returned %d", aci_res);
+        }
+    }
+    else
+    {
+        TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
+    }
+
+    return res;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)     MODULE: MFW_CM                   |
+| STATE  : code     ROUTINE: cm_ccbs_list                            |
++--------------------------------------------------------------------+
+
+   PURPOSE :    Delete all registered CCBS
+
+   Returns:		T_MFW: CM_OK if successful, CM_ERROR if not
+
+   Arguments:   None
+*/
+T_MFW    cm_ccbs_list(void)
+{
+    T_MFW           res = CM_ERROR; // The value to be returned by this function
+    T_ACI_RETURN    aci_res;        // The value returned by qAT_PercentCCBS
+
+    TRACE_FUNCTION("cm_ccbs_list()");
+
+    if (ccbs_op == CM_CCBS_NONE)
+    {
+        /* No CCBS operation currently in progress */
+        TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
+#ifndef CCBS_TEST
+        aci_res = qAT_PercentCCBS(CMD_SRC_LCL);
+#else
+        aci_res = AT_EXCT;
+#endif
+        if (aci_res == AT_EXCT)
+        {
+            TRACE_EVENT("qAT_PercentCCBS returned AT_EXCT");
+            ccbs_op = CM_CCBS_LIST;
+            res = CM_OK;
+        }
+        else
+        {
+            TRACE_EVENT_P1("qAT_PercentCCBS returned %d", aci_res);
+        }
+    }
+    else
+    {
+        TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
+    }
+
+    return res;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)     MODULE: MFW_CM                   |
+| STATE  : code     ROUTINE: cm_ccbs_accept_registration             |
++--------------------------------------------------------------------+
+
+   PURPOSE :    Accepts the CCBS registration being offered
+
+   Returns:		T_MFW: CM_OK if successful, CM_ERROR if not
+
+   Arguments:   None
+*/
+T_MFW    cm_ccbs_accept_registration(void)
+{
+    T_MFW           res = CM_ERROR; // The value to be returned by this function
+    T_ACI_RETURN    aci_res;        // The value returned by sAT_PlusCHLD
+
+    TRACE_FUNCTION("cm_ccbs_accept_registration()");
+
+    if (ccbs_op == CM_CCBS_NONE)
+    {
+        /* No CCBS operation currently in progress */
+        TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
+        cm_set_cmd_status(CHLD_MOD_Ccbs, "");
+	    cmd_hold = MFW_CM_CCBS_REGISTER;
+#ifndef CCBS_TEST
+	    aci_res = sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_Ccbs, NULL);
+#else
+	    aci_res = AT_EXCT;
+#endif
+        if (aci_res == AT_EXCT)
+        {
+            TRACE_EVENT("sAT_PlusCHLD returned AT_EXCT");
+            ccbs_op = CM_CCBS_ACCEPT_REGISTRATION;
+            res = CM_OK;
+        }
+        else
+        {
+            TRACE_EVENT_P1("sAT_PlusCHLD returned %d", aci_res);
+        }
+    }
+    else
+    {
+        TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
+    }
+
+    return res;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)     MODULE: MFW_CM                   |
+| STATE  : code     ROUTINE: cm_ccbs_reject_registration             |
++--------------------------------------------------------------------+
+
+   PURPOSE :    Rejects the CCBS registration being offered
+
+   Returns:		T_MFW: CM_OK if successful, CM_ERROR if not
+
+   Arguments:   None
+*/
+T_MFW    cm_ccbs_reject_registration(void)
+{
+    T_MFW           res = CM_ERROR; // The value to be returned by this function
+    T_ACI_RETURN    aci_res;        // The value returned by sAT_H
+
+    TRACE_FUNCTION("cm_ccbs_reject_registration()");
+
+    if (ccbs_op == CM_CCBS_NONE)
+    {
+        /* No CCBS operation currently in progress */
+        TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
+        cmd_hold = MFW_CM_CCBS_REGISTER;
+#ifndef CCBS_TEST
+        aci_res = sAT_H(CMD_SRC_LCL);
+#else
+        aci_res = AT_EXCT;
+#endif
+        if (aci_res == AT_EXCT)
+        {
+            TRACE_EVENT("sAT_H returned AT_EXCT");
+            ccbs_op = CM_CCBS_REJECT_REGISTRATION;
+            res = CM_OK;
+        }
+        else
+        {
+            TRACE_EVENT_P1("sAT_H returned %d", aci_res);
+        }
+    }
+    else
+    {
+        TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
+    }
+
+    return res;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)     MODULE: MFW_CM                   |
+| STATE  : code     ROUTINE: cm_ccbs_accept_recall                   |
++--------------------------------------------------------------------+
+
+   PURPOSE :    Accepts the CCBS recall being offered
+
+   Returns:		T_MFW: CM_OK if successful, CM_BLACKIST or CM_ERROR if not
+
+   Arguments:   UBYTE *number           - the number of the phone to call
+                T_MFW_CM_CALL_TYPE type - the type of the call to be made
+*/
+T_MFW    cm_ccbs_accept_recall(UBYTE *number, T_MFW_CM_CALL_TYPE type)
+{
+    T_MFW           res = CM_ERROR; // The value to be returned by this function
+    int             search_res; // The value returned by cm_search_callId
+    T_ACI_RETURN    aci_res;    // The value returned by sAT_PlusCHLD
+    SHORT           call_number;// The call identity of any held call
+    UBYTE           phone[MFW_NUM_LEN];   // Working copy of phone number
+  //  CHAR			*rest;      // Parameter for ss_decode  // RAVI
+//    T_KSD_SEQPARAM	para;       // Parameter for ss_decode  // RAVI
+//    T_MFW_SS_RETURN	ss_res;     // The value returned by ss_decode  // RAVI
+
+    TRACE_FUNCTION("cm_ccbs_accept_recall()");
+
+    if (ccbs_op == CM_CCBS_NONE)
+    {
+        /* No CCBS operation currently in progress */
+        TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
+        /* Ensure the number given is an ASCIIZ string thet is not too long */
+        mfwStrncpy((char *)phone, (char *)number, MFW_NUM_LEN);
+        TRACE_EVENT_P1("ccbs nr: %s", phone);
+
+        /* Make sure that it is OK to call this number */
+        if ((res = cm_check_mo_number(phone)) == CM_OK)
+        {
+            TRACE_EVENT("cm_check_mo_number returned CM_OK");
+            /* Set up data as for mobile originated call */
+            cm_set_call_mode(type);
+            call_stat	   = OUTGOING_CALL;
+            redial_count   = 0;
+            cc_stat.type   = OUTGOING_CALL;
+            currConnecting = 1;
+
+            if ((search_res = cm_search_callId(CAL_STAT_Held, &call_number)) == CM_OK)
+            {
+                TRACE_EVENT("Held call: CHLD_MOD_RelActAndAcpt");
+                /* There is a held call: release active call and accept callback */
+                cm_set_cmd_status(CHLD_MOD_RelActAndAcpt, "");
+#ifndef CCBS_TEST
+                aci_res = sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActAndAcpt, NULL);
+#else
+                aci_res = AT_EXCT;
+#endif
+            }
+            else
+            {
+                TRACE_EVENT("No held call: CHLD_MOD_HldActAndAcpt");
+                /* There is no held call: hold any active call and accept callback */
+                cm_set_cmd_status(CHLD_MOD_HldActAndAcpt, "");
+#ifndef CCBS_TEST
+                aci_res = sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_HldActAndAcpt, NULL);
+#else
+                aci_res = AT_EXCT;
+#endif
+            }
+
+            cmd_hold = MFW_CM_CCBS_RECALL;
+
+            if (aci_res == AT_EXCT)
+            {
+                TRACE_EVENT("sAT_PlusCHLD returned AT_EXCT");
+                ccbs_op = CM_CCBS_ACCEPT_RECALL;
+                res = CM_OK;
+            }
+            else
+            {
+                /* The attempt to accept the callback failed */
+                TRACE_EVENT_P1("sAT_PlusCHLD returned %d", aci_res);
+                call_stat = MFW_CALL_FREE;
+            }
+        }
+        else
+        {
+            /* It is not OK to call this number for some reason */
+            TRACE_EVENT_P1("cm_check_mo_number returned %d", res);
+        }
+    }
+    else
+    {
+        TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
+    }
+
+    return res;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)     MODULE: MFW_CM                   |
+| STATE  : code     ROUTINE: cm_ccbs_reject_recall                   |
++--------------------------------------------------------------------+
+
+   PURPOSE :    Rejects the CCBS recall being offered
+
+   Returns:		T_MFW: CM_OK if successful, CM_ERROR if not
+
+   Arguments:   None
+*/
+T_MFW    cm_ccbs_reject_recall(void)
+{
+    T_MFW           res = CM_ERROR; // The value to be returned by this function
+    T_ACI_RETURN    aci_res;        // The value returned by sAT_PlusCHLD
+
+    TRACE_FUNCTION("cm_ccbs_reject_recall()");
+
+    if (ccbs_op == CM_CCBS_NONE)
+    {
+        /* No CCBS operation currently in progress */
+        TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
+        cm_set_cmd_status(CHLD_MOD_RelHldOrUdub, "");
+        cmd_hold = MFW_CM_CCBS_RECALL;
+
+#ifndef CCBS_TEST
+        aci_res = sAT_H(CMD_SRC_LCL);
+#else
+        aci_res = AT_CMPL;
+#endif
+        if (aci_res == AT_CMPL)
+        {
+            TRACE_EVENT("sAT_H returned AT_CMPL");
+            ccbs_op = CM_CCBS_REJECT_RECALL;
+            res = CM_OK;
+        }
+        else
+        {
+            TRACE_EVENT_P1("sAT_H returned %d", aci_res);
+        }
+    }
+    else
+    {
+        TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
+    }
+
+    return res;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)     MODULE: MFW_CM                   |
+| STATE  : code     ROUTINE: cm_ccbs_ok                              |
++--------------------------------------------------------------------+
+
+   PURPOSE :    Called by rAT_OK for "OK" result code for %CCBS command
+
+   Returns:		Nothing
+
+   Arguments:   None
+*/
+void cm_ccbs_ok(void)
+{
+    TRACE_FUNCTION("cm_ccbs_ok()");
+
+    memset((void *)&ccbs_info, 0, sizeof(ccbs_info));
+
+    ccbs_info.operation = ccbs_op;
+    ccbs_op             = CM_CCBS_NONE;
+    ccbs_info.type      = CM_CCBS_OK;
+
+    TRACE_EVENT_P2("E_CM_CCBS: op = %d: type = %d",
+        ccbs_info.operation, ccbs_info.type);
+
+    cm_signal(E_CM_CCBS, &ccbs_info);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)     MODULE: MFW_CM                   |
+| STATE  : code     ROUTINE: cm_ccbs_error                           |
++--------------------------------------------------------------------+
+
+   PURPOSE :    Called by rAT_PlusCME for "+CME error" result code for %CCBS command
+
+   Returns:		Nothing
+
+   Arguments:   None
+*/
+void cm_ccbs_error(void)
+{
+    TRACE_FUNCTION("cm_ccbs_error()");
+
+    memset((void *)&ccbs_info, 0, sizeof(ccbs_info));
+
+    ccbs_info.operation = ccbs_op;
+    ccbs_op             = CM_CCBS_NONE;
+    ccbs_info.type      = CM_CCBS_ERROR;
+
+    TRACE_EVENT_P2("E_CM_CCBS: op = %d: type = %d",
+        ccbs_info.operation, ccbs_info.type);
+
+    cm_signal(E_CM_CCBS, &ccbs_info);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)     MODULE: MFW_CM                   |
+| STATE  : code     ROUTINE: rAT_PercentCCBS                         |
++--------------------------------------------------------------------+
+
+   PURPOSE :    Called by ACI for "%CCBS:" result code
+
+   Returns:		Nothing
+
+   Arguments:   T_ACI_CCBS_IND  indct   - type of %CCBS indication
+                T_ACI_CCBS_STAT status  - status of %CCBS indication
+                T_ACI_CCBS_SET *setting - optiona parameters of %CCBS indication
+*/
+void rAT_PercentCCBS( T_ACI_CCBS_IND  indct,
+                        T_ACI_CCBS_STAT status,
+                        T_ACI_CCBS_SET *setting )
+{
+    TRACE_FUNCTION("rAT_PercentCCBS()");
+    TRACE_EVENT_P3("indct = %d: status = %d: setting = %p", indct, status, setting);
+
+    memset((void *)&ccbs_info, 0, sizeof(ccbs_info));
+
+    /* Fill in the fields of the E_CM_CCBS event structure */
+    switch (indct)
+    {
+        case CCBS_IND_Possible:
+        case CCBS_IND_Recall:
+        case CCBS_IND_PossibilityTimedOut:
+        case CCBS_IND_RecallTimedOut:
+
+            /* An asynchronous %CCBS, not in response to a %CCBS command */
+            TRACE_EVENT("Unsolicited event");
+            ccbs_info.operation = CM_CCBS_ASYNC;
+            break;
+
+        default:
+            TRACE_EVENT("Solicited event");
+            ccbs_info.operation = ccbs_op;
+            break;
+    }
+
+    ccbs_info.type      = CM_CCBS_INFO;
+    ccbs_info.indct     = indct;
+    ccbs_info.status    = status;
+
+    TRACE_EVENT_P2("E_CM_CCBS: op = %d: type = %d",
+        ccbs_info.operation, ccbs_info.type);
+    TRACE_EVENT_P2(" indct = %d: status = %d",
+        ccbs_info.indct, ccbs_info.status);
+
+    if (setting == (T_ACI_CCBS_SET *) NULL)
+    {
+        /* No T_ACI_CCBS_SET structure given. Indicate in the idx field of ccbs_info */
+        TRACE_EVENT("setting == NULL");
+        ccbs_info.idx = 0;
+    }
+    else
+    {
+        /* T_ACI_CCBS_SET structure given. Fill in the remaining field of ccbs_info */
+        TRACE_EVENT("setting != NULL");
+        ccbs_info.idx = setting->idx;
+        strncpy((char *) ccbs_info.number, (char *) setting->number, sizeof(ccbs_info.number)-1);
+        ccbs_info.number[sizeof(ccbs_info.number)-1] = '\0';
+        ccbs_info.ton = phb_cvtTon(setting->type.ton);
+        ccbs_info.call_type = cm_callTyp_cvt(setting->class_type);
+        strncpy((char *) ccbs_info.subaddr, (char *) setting->subaddr, sizeof(ccbs_info.subaddr)-1);
+        ccbs_info.subaddr[sizeof(ccbs_info.subaddr)-1] = '\0';
+        ccbs_info.alrtPtn = setting->alrtPtn;
+        TRACE_EVENT_P3(" idx = %d: number = %s: ton = %d",
+            ccbs_info.idx, ccbs_info.number, ccbs_info.ton);
+        TRACE_EVENT_P3(" call_type = %d: subaddr = %s: alrtPtn = %d",
+            ccbs_info.call_type, ccbs_info.subaddr, ccbs_info.alrtPtn);
+    }
+
+    cm_signal(E_CM_CCBS, &ccbs_info);
+}
+
+/* Marcus: CCBS: 13/11/2002: End */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_error_dial	     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : The call setup is not successful
+
+*/
+
+void cm_error_dial(T_ACI_CME_ERR err)
+{
+    TRACE_FUNCTION("cm_error_dial()");
+
+    switch (err)
+    {
+        case CME_ERR_OpNotAllow: /* the active call can not be hold */
+            /* allow a new outgoing */
+            call_stat = MFW_CALL_FREE;
+            call_type = MFW_CALL_FREE;
+            cmd.command = CM_HOLD;
+            if (cm_search_callId(CAL_STAT_Active, &cmd.call_number) NEQ CM_OK)
+              cmd.call_number = -1;
+            cmd.result = NotPresent;
+            cm_signal(E_CM_COMMAND, &cmd);
+            break;
+
+        /*SPR#2235 - DS - If handset is powered-up without a SIM and an emergency
+         *call is attempted, the UK networks will reject the call attempt. Send a signal to
+         *the BMI to enable it to destroy the call and show an appropriate error message.
+         *
+         *The ACI calls rAT_PlusCME() - then rAT_PlusCME() calls this funct - for this SIM
+         *failure but the ACI doesn't supply the callId. Without the callId, the MFW/BMI
+         *cannot close down the call properly. The ACI interface will need to be changed
+         *so that it supplies the callId (if there is an active call) when this failure occurs.
+         */
+        case CME_ERR_SimFail:
+            /* allow a new outgoing */
+            call_stat = MFW_CALL_FREE;
+            call_type = MFW_CALL_FREE;
+
+            /*SPR#2235 - DS - Fake the callId. Workaround needed until the ACI interface is changed */
+            cm_error_connect(1);
+            break;
+
+        default:
+            TRACE_EVENT_P1("Error code: %d. No signal sent.", err);
+            break;
+    }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_data_connect     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Fax/Data connect
+
+*/
+
+void cm_data_connect(SHORT callId)
+{
+  SHORT call_number;
+
+  TRACE_FUNCTION("cm_data_connect()");
+
+  call_number = callId;
+  cm_signal(E_CM_CONNECT, &call_number);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_data_connect     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Fax/Data connect
+
+*/
+
+void cm_wap_data_connected(void)
+{
+ // SHORT call_number;  // RAVI
+
+  TRACE_FUNCTION("cm_wap_data_connected()");
+
+  cm_signal(E_CM_WAP_CALL_CONNECTED, NULL);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_deflect_incoming_call     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : try to deflect a call using AT command CTFR
+
+*/
+T_MFW cm_deflect_incoming_call(char* number)
+{	T_ACI_RETURN result;
+	T_ACI_TOA type;
+	T_ACI_TOS subaddr_type;
+
+	type.ton = TON_Unknown;
+	type.npi = NPI_Unknown;
+
+	subaddr_type.tos = TOS_NotPresent;
+	subaddr_type.oe = OE_NotPresent;
+
+	result = sAT_PlusCTFR(CMD_SRC_LCL, number, &type, NULL, &subaddr_type);
+
+	if ((result == AT_BUSY) || (result == AT_FAIL))
+		return FALSE;
+	return TRUE;
+
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_ok_CTFR     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : sends call deflect OK event to MMI
+
+*/
+void cm_ok_CTFR(void)
+{	BOOL status = TRUE;
+
+	cm_signal(E_CM_CALL_DEFLECT_STATUS, &status);
+
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_error_CTFR     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Sends call deflect failed event to MMI
+
+*/
+void cm_error_CTFR(void)
+{
+	BOOL status = FALSE;
+
+	cm_signal(E_CM_CALL_DEFLECT_STATUS, &status);
+}
+#ifdef CCBS_TEST
+/* Marcus: CCBS testing: 20/11/2002: Start */
+static void strlower(char *string)
+{
+    while(*string)
+    {
+        *string = (char)tolower((int) *string);
+        string++;
+    }
+}
+
+static BOOL getCmdId(char *token, T_ACI_AT_CMD *cmdId)
+{
+    BOOL cmdIdOk = FALSE;
+    TRACE_FUNCTION("getCmdId()");
+    if (token)
+    {
+        strlower(token);
+        TRACE_EVENT_P1("token: %s", token);
+        if (strstr(token, "ccbs"))
+        {
+            *cmdId = AT_CMD_CCBS;
+            cmdIdOk = TRUE;
+        }
+        else if (strstr(token, "chld"))
+        {
+            *cmdId = AT_CMD_CHLD;
+            cmdIdOk = TRUE;
+        }
+        else if (strcmp("h", token) == 0)
+        {
+            *cmdId = AT_CMD_H;
+            cmdIdOk = TRUE;
+        }
+        else if ((*cmdId = atoi(token)))
+        {
+            cmdIdOk = TRUE;
+        }
+    }
+    else
+    {
+        TRACE_EVENT("No token");
+    }
+
+    return cmdIdOk;
+}
+#endif
+
+void rAT_PercentMMITEST(char *param)
+{
+    char work[80];
+    char *token;    // Current token obtained from strtok
+    TRACE_FUNCTION("rAT_PercentMMITEST()");
+
+    strncpy(work, param, sizeof(work)-1);
+    work[sizeof(work)-1] = '\0';
+
+    if ((token = strtok(work, ",()")) != NULL)
+    {
+#ifdef CCBS_TEST
+        T_ACI_AT_CMD cmdId;
+        strlower(token);
+        TRACE_EVENT_P1("token: %s", token);
+
+        if (strcmp("ok", token) == 0)
+        {
+            TRACE_EVENT("OK");
+            if ((token = strtok(NULL, ",()")) != NULL)
+            {
+                if (getCmdId(token, &cmdId) == TRUE)
+                {
+                    TRACE_EVENT_P1("rAT_OK(cmdId = %d", cmdId);
+                    rAT_OK(cmdId);
+                }
+                else
+                {
+                    TRACE_EVENT("Unknown cmdId");
+                }
+            }
+            else
+            {
+                TRACE_EVENT("No cmdId token");
+            }
+        }
+        else if (strcmp("error", token) == 0)
+        {
+            TRACE_EVENT("ERROR");
+            if ((token = strtok(NULL, ",()")) != NULL)
+            {
+                if (getCmdId(token, &cmdId) == TRUE)
+                {
+                    T_ACI_CME_ERR err;
+                    if ((token = strtok(NULL, ",()")) != NULL)
+                    {
+                        err = atoi(token);
+                        rAT_PlusCME(cmdId, err);
+                    }
+                    else
+                    {
+                        TRACE_EVENT("No err token");
+                    }
+                }
+            }
+            else
+            {
+                TRACE_EVENT("No cmdId token");
+            }
+        }
+        else if (strcmp("info", token) == 0)
+        {
+            T_ACI_CCBS_IND  indct = CCBS_IND_NotPresent;
+            T_ACI_CCBS_STAT status = CCBS_STAT_NotPresent;
+            T_ACI_CCBS_SET  setting, *pSetting = NULL;
+            TRACE_EVENT("INFO");
+            if ((token = strtok(NULL, ",()")) != NULL)
+            {
+                strlower(token);
+                TRACE_EVENT_P1("token: %s", token);
+                if (strstr(token, "notpresent"))
+                    indct = CCBS_IND_NotPresent;
+                else if (strstr(token, "possibility"))
+                    indct = CCBS_IND_PossibilityTimedOut;
+                else if (strstr(token, "possible"))
+                    indct = CCBS_IND_Possible;
+                else if (strstr(token, "registered"))
+                    indct = CCBS_IND_Registered;
+                else if (strstr(token, "recallt"))
+                    indct = CCBS_IND_RecallTimedOut;
+                else if (strstr(token, "recall"))
+                    indct = CCBS_IND_Recall;
+                else if (strstr(token, "irgt"))
+                    indct = CCBS_IND_IrgtResult;
+            }
+
+            if ((token = strtok(NULL, ",()")) != NULL)
+            {
+                strlower(token);
+                TRACE_EVENT_P1("token: %s", token);
+                if (strstr(token, "notpresent"))
+                    status = CCBS_STAT_NotPresent;
+                else if (strstr(token, "notprov"))
+                    status = CCBS_STAT_NotProvisioned;
+                else if (strstr(token, "prov"))
+                    status = CCBS_STAT_Provisioned;
+                else if (strstr(token, "active"))
+                    status = CCBS_STAT_Active;
+            }
+
+            setting.idx = 0;
+            if ((token = strtok(NULL, ",()")) != NULL)
+            {
+                TRACE_EVENT_P1("token: %s", token);
+                setting.idx = atoi(token);
+            }
+
+            if (setting.idx != 0)
+            {
+                pSetting = &setting;
+                strcpy(setting.number, "01317180538");
+                setting.type.ton = TON_National;
+                setting.type.npi = NPI_IsdnTelephony;
+                setting.subaddr[0] = '\0';
+                setting.satype.tos = TOS_NotPresent;
+                setting.satype.oe = OE_NotPresent;
+                setting.class_type = CLASS_Vce;
+                setting.alrtPtn = ALPT_Level_0;
+
+                if ((token = strtok(NULL, ",()")) != NULL)
+                {
+                    TRACE_EVENT_P1("token: %s", token);
+                    strncpy(setting.number, token, sizeof(setting.number)-1);
+                    setting.number[sizeof(setting.number)-1] = '\0';
+                }
+
+                if ((token = strtok(NULL, ",()")) != NULL)
+                {
+                    TRACE_EVENT_P1("token: %s", token);
+                    setting.type.ton = TON_International;
+                }
+            }
+
+            TRACE_EVENT_P3("rAT_PercentCCBS(%d, %d, %p)", indct, status, pSetting);
+            if (pSetting != NULL)
+            {
+                TRACE_EVENT_P3("idx = %d: number = %s: ton = %d",
+                    setting.idx, setting.number, setting.type.ton);
+            }
+            rAT_PercentCCBS(indct, status, pSetting);
+        }
+        else
+        {
+            TRACE_EVENT("Unrecognised token");
+        }
+#endif
+    }
+    else
+    {
+        TRACE_EVENT("No token");
+    }
+}
+/* Marcus: CCBS testing: 20/11/2002: End */
+
+
+/* SPR#1985 - SH - Added this function */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_tty_enable    |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Receipt of unsolicited TTY information
+
+*/
+
+void rAT_PercentCTYI(T_ACI_CTTY_NEG neg, T_ACI_CTTY_TRX trx)
+{
+	T_MFW_CM_CTYI res;
+
+	TRACE_FUNCTION("rAT_PercentCTYI()");
+
+	currCmd = AT_CMD_NONE;
+	switch(neg)
+	{
+		case CTTY_NEG_None:
+			res.neg =  CTYI_NONE;
+			break;
+		case CTTY_NEG_Request:
+			res.neg = CTYI_REQUEST;
+			break;
+		case CTTY_NEG_Reject:
+			res.neg = CTYI_REJECT;
+			break;
+		case CTTY_NEG_Grant:
+			res.neg = CTYI_GRANT;
+			break;
+	}
+
+	cm_signal(E_CM_CTYI, &res);
+
+	return;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_tty_enable    |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Request ACI to switch TTY on or off
+
+*/
+
+void cm_tty_enable(UBYTE enable)
+{
+	T_ACI_RETURN ret;
+
+	TRACE_FUNCTION("cm_tty_enable()");
+
+	/* SPR#1985 - SH - Now use proper ACI functions.  */
+
+	if (enable)
+		ret = sAT_PercentCTTY(CMD_SRC_LCL, CTTY_MOD_Enable, CTTY_REQ_On);
+	else
+		ret = sAT_PercentCTTY(CMD_SRC_LCL, CTTY_MOD_Enable, CTTY_REQ_Off);
+
+	/* SPR#1985 - SH - Check that TTY status has changed and inform MMI  */
+
+	cm_tty_query();
+
+	return;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417) 	MODULE: MFW_CM		     |
+| STATE  : code 			ROUTINE: cm_tty_query    |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Query status of TTY, inform MMI. */
+   /*SPR#1985 - SH - Added this function  */
+
+void cm_tty_query(void)
+{
+	T_MFW_CM_CTYI res;
+//	T_ACI_RETURN ret;  // RAVI
+	T_ACI_CTTY_MOD mode;
+	T_ACI_CTTY_REQ req;
+	T_ACI_CTTY_STAT stat;
+	T_ACI_CTTY_TRX trx;
+
+	TRACE_FUNCTION("cm_tty_query()");
+
+	qAT_PercentCTTY(CMD_SRC_LCL, &mode, &req, &stat, &trx);
+
+	res.neg = CTYI_REJECT;
+
+	if (req==CTTY_REQ_On)
+	{
+		if (req)
+			res.neg = CTYI_GRANT;
+	}
+
+	cm_signal(E_CM_CTYI, &res);
+
+	return;
+}
+
+// Feb 03, 2005	REF: CRR 25960   x0012850
+// Description: Call Hold: While one call in Active and other in Held by swapping either of phone is not audible
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework        	MODULE: MFW_CM		                               |
+| STATE  : code 			              ROUTINE: cm_setSpeechMode                       |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : MFW function to call psaCC_setSpeechMode() to attach user connection.
+
+*/
+void cm_setSpeechMode(void)
+{
+	TRACE_FUNCTION("cm_setSpeechMode()");
+	psaCC_setSpeechMode();
+	return;
+}
+
+
+//   Sep 12, 2005   REF: MMI-SMR-34085 x0021334
+//   Description: RE: Add +CDIP command - MMI Additions
+//   Solution: Dummy implementation of function "rAT_PlusCDIP()" is done to enable successful compilation.
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework        	MODULE: MFW_CM		                               |
+| STATE   : code                                ROUTINE : rAT_PlusCDIP                              |
++--------------------------------------------------------------------+
+
+  PURPOSE : Stub implementation
+*/
+
+GLOBAL void rAT_PlusCDIP( CHAR   * number,
+                             T_ACI_TOA       * type,
+                             CHAR            * subaddr,
+                             T_ACI_TOS       * satype)
+{
+	TRACE_FUNCTION ("rAT_PlusCDIP()");
+}