diff g23m/condat/ms/src/mfw/mfw_ss.c @ 0:509db1a7b7b8

initial import: leo2moko-r1
author Space Falcon <falcon@ivan.Harhan.ORG>
date Mon, 01 Jun 2015 03:24:05 +0000
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/g23m/condat/ms/src/mfw/mfw_ss.c	Mon Jun 01 03:24:05 2015 +0000
@@ -0,0 +1,2434 @@
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         $Workfile:: mfw_ss.c        $|
+| $Author:: Vo                          $Revision::  1              $|
+| CREATED: 25.1.99                      $Modtime:: 24.03.00 9:48    $|
+| STATE  : code                                                      |
++--------------------------------------------------------------------+
+
+   MODULE  : MFW_SS
+
+   PURPOSE : This modul contains the functions for supplementary management.
+
+
+   $History:: mfw_ss.c                                              $
+
+	Dec 16, 2005	REF: OMAPS00053316	x0018858
+	Description: E-Sample 2.58 compiler code crashes when accessing the Voicemail service in the Messages
+	Solution: Added a NULL Check for the USSD pointer that is being received.
+	
+	Jul 05, 2005	REF: CRR 22565	a0876501
+	Description: IMEI display on handset through atd*#06# was swapped.
+	Solution: Byte swapping corrected for IMEI decoding. 
+
+	Mar 30, 2005	REF: CRR 29986	xpradipg
+	Description: Optimisation 1: Removal of unused variables and dynamically
+	allocate/ deallocate mbndata
+	Solution: unused variables are removed 
+
+	Apr 06 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
+	
+	Aug 16, 2004    REF: CRR 24323   Deepa M.D
+	Bug:Clenup of sprintf used for tracing
+	Fix:Replace the char buf[]; sprintf (buf, "...", ...); TRACE_EVENT (buf); statements by TRACE_EVENT_PX
+
+	Jul 15, 2004 REF: CRR 13873 xkundadu
+	Description: Make an incoming call, the end user pressing 0+send will 
+			    pick up the call. Instead, 0+send should reject the incoming 
+			    call. 
+	Solution:     Added the handling of 0/1/2 SEND for a waiting call.
+			    Modified the ss_decode() function in the 
+			    mfw_ss.c file to search the sequential table in the case of 
+			    waiting call also. Made changes in mfw_cm.c file also
+ *
+ * *****************  Version 24  *****************
+ * User: Vo           Date: 24.03.00   Time: 10:18
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * Bug fix: result of IMEI
+ * New: notice PIN type of SS string for PIN change/PIN unblock
+ *
+ * *****************  Version 23  *****************
+ * User: Vo           Date: 10.01.00   Time: 16:09
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * new function ss_exit()
+ *
+ * *****************  Version 22  *****************
+ * User: Vo           Date: 10.01.00   Time: 13:32
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ *
+ * *****************  Version 21  *****************
+ * User: Ak           Date: 10.01.00   Time: 13:14
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ *
+ * *****************  Version 20  *****************
+ * User: Ak           Date: 21.10.99   Time: 11:56
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * Why: Improvement
+ * What: Passing of network basic service codes instead of GSM 2.30
+ * codes for SS control string results and invocations
+ *
+ * *****************  Version 19  *****************
+ * User: Ak           Date: 29.09.99   Time: 8:37
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * Why: bug fix
+ * What: strcpy do not check a NULL pointer argument, corrected
+ *
+ * *****************  Version 18  *****************
+ * User: Ak           Date: 28.09.99   Time: 14:16
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * Why: bug fix
+ * What: strcpy do not check a NULL pointer argument, corrected
+ *
+ * *****************  Version 17  *****************
+ * User: Es           Date: 16.09.99   Time: 17:25
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * include SENSEI patch 13/09/99
+ * two minor fixes
+ *
+ * *****************  Version 16  *****************
+ * User: Vo           Date: 12.09.99   Time: 14:16
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * New: USSD handle
+ *
+ * *****************  Version 15  *****************
+ * User: Vo           Date: 30.08.99   Time: 12:08
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * SS string for PIN unblock
+ *
+ * *****************  Version 14  *****************
+ * User: Vo           Date: 9.08.99    Time: 16:53
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * SS result from network
+ * present IMEI
+ * different handling of network password and PIN1/PIN2 password
+ *
+ * *****************  Version 13  *****************
+ * User: Vo           Date: 21.07.99   Time: 14:44
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 12  *****************
+ * User: Vo           Date: 16.07.99   Time: 10:39
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 11  *****************
+ * User: Vo           Date: 9.07.99    Time: 14:56
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 1  *****************
+ * User: Vo           Date: 10.02.99   Time: 12:41
+ * Created in $/GSM/DEV/MS/SRC/MFW
+
+*/
+#define ENTITY_MFW
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined (NEW_FRAME)
+
+#include "typedefs.h"
+#include "vsi.h"
+#include "custom.h"
+#include "gsm.h"
+
+#else
+
+#include "STDDEFS.H"
+#include "custom.h"
+#include "gsm.h"
+#include "vsi.h"
+
+#endif
+
+#include "message.h"
+#include "prim.h"
+#include "aci_cmh.h"
+
+#include "cus_aci.h"
+#include "ksd.h"
+#include "prim.h"
+#ifndef PCM_2_FFS
+#include "pcm.h"
+#else
+#include "prim.h"
+#include "Gsm.h"
+#endif
+
+
+#include "psa.h"
+#include "psa_sim.h"
+
+#include "mfw_mfw.h"
+#include "mfw_nm.h"
+#include "mfw_sim.h"
+#include "mfw_sima.h"
+#include "mfw_nmi.h"
+#include "mfw_simi.h"
+#include "mfw_nma.h"
+#include "mfw_phb.h"
+#include "mfw_cm.h"
+#include "mfw_cmi.h"
+#include "mfw_ss.h"
+#include "mfw_ssi.h"
+#include "mfw_win.h"
+#include "mfw_phbi.h"
+
+#include <string.h>
+
+
+/*************** Variables ******************************************/
+// 	Mar 30, 2005	REF: CRR 29986	xpradipg
+//	remove unused variables
+#ifndef FF_MMI_OPTIM
+static T_MFW_SS_SUPORT    ss_suport;
+#endif
+//	Apr 06 2005		REF: CRR 29989	xpradipg
+//	This scope of the variable lies within a function hence it is made as local
+#ifndef FF_MMI_OPTIM
+static T_MFW_SS_NOTIFY    notify;
+#endif
+
+//	Apr 06 2005		REF: CRR 29989	xpradipg
+//	The below static globals are dynamically allocated in rAT_PercentKSIR where
+//	the data is populated for the supplementary services response and 
+//	deallocated once the ss_signal function is executed where in the contents
+//	are copied onto another variable
+#ifdef FF_MMI_OPTIM
+T_MFW_SS_CF_CNF    *cf_cnf = NULL;
+T_MFW_SS_CB_CNF    *cb_cnf = NULL;
+T_MFW_SS_CLI_CNF   *cli_cnf = NULL;
+T_MFW_SS_CW_CNF    *cw_cnf = NULL;
+T_MFW_SS_PW_CNF    *pw_cnf = NULL;
+T_MFW_IMEI		  *imei_info = NULL;
+#else
+static T_MFW_SS_CF_CNF    cf_cnf;
+static T_MFW_SS_CB_CNF    cb_cnf;
+static T_MFW_SS_CLI_CNF   cli_cnf;
+static T_MFW_SS_CW_CNF    cw_cnf;
+static T_MFW_SS_PW_CNF    pw_cnf;
+static T_MFW_SS_RES       ss_res;
+static T_MFW_IMEI		  imei_info;
+#endif
+static T_MFW_SS_USSD      ussd_info;
+// 	Mar 30, 2005	REF: CRR 29986	xpradipg
+//	remove unused variables
+#ifndef FF_MMI_OPTIM
+static U8                 clip_status;
+static U8                 colp_status;
+static U8                 clir_status;
+static U8                 clir_prefix;
+static U8                 colr_status;
+#endif
+static U8                 clck_flag;
+static U8				  pwd_flag;   /* 1 for change PIN */
+
+
+
+#define CF_LST_SIZE (sizeof(T_MFW_FEATURE)  *MFW_MAX_FEAT_NR)
+#define CB_LST_SIZE (sizeof(T_MFW_TELECOM)  *MFW_MAX_TELE_NR)
+#define CW_LST_SIZE (sizeof(T_MFW_SRV_GROUP)*MFW_MAX_SRV_NR)
+
+#define MAX_LST_BUF (MAXIMUM(MAXIMUM(CF_LST_SIZE,\
+                                     CB_LST_SIZE),\
+                             CW_LST_SIZE))
+
+#define LANG_RESET "*#0" /*mc, SPR 1111 beginning of language reset pseudo-SS string*/
+#define TTY_NEXTCALL_ON "*55#" /* SPR#1352 - SH - Pseudo-SS string to switch on TTY on next call */
+#define TTY_NEXTCALL_OFF "#55#" /* SPR#1352 - SH - Pseudo-SS string to switch off TTY on next call */
+
+static ULONG ssLstBuf[MAX_LST_BUF/sizeof(ULONG)];
+EXTERN MfwHdr * current_mfw_elem;
+
+//	July 09, 2005   REF : MMI-22565 - a0876501
+extern UBYTE cmhSS_getCdFromImei (T_ACI_IMEI* imei);
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_mfw_init         |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :
+
+*/
+
+void ss_mfw_init(void)
+{
+// 	Mar 30, 2005	REF: CRR 29986	xpradipg
+//	remove reundant code since the values assigned here are never referenced
+
+#ifndef PCM_2_FFS
+
+ #ifndef FF_MMI_OPTIM 
+  EF_MSCAP mscap;
+  EF_MSSUP mssup;
+  EF_MSSET msset;
+  UBYTE    version;
+
+  /* Read the Mobile Capabilities from EEPROM */
+
+  if (pcm_ReadFile((UBYTE *)EF_MSCAP_ID,
+	               SIZE_EF_MSCAP,
+				   (UBYTE *)&mscap,
+				   &version) EQ PCM_OK)
+  {
+    ss_suport.speech = (UBYTE)FldGet(mscap.chnMode,spchSupV1);
+    ss_suport.data   = (UBYTE)FldGet(mscap.datCap1,datSup);
+    ss_suport.asyn   = (UBYTE)FldGet(mscap.datCap1,AsySup);
+    ss_suport.syn    = (UBYTE)FldGet(mscap.datCap1,NTSynSup);
+  }
+
+  if (pcm_ReadFile((UBYTE *)EF_MSSUP_ID,
+	               SIZE_EF_MSSUP,
+				   (UBYTE *)&mssup,
+				   &version) EQ PCM_OK)
+  {
+    ss_suport.aoc    = (UBYTE)FldGet(mssup.feat1,AoC);
+    ss_suport.dtmf   = (UBYTE)FldGet(mssup.feat1,DTMF);
+    ss_suport.cf     = (UBYTE)FldGet(mssup.feat1,CF);
+    ss_suport.cb     = (UBYTE)FldGet(mssup.feat1,CB);
+    ss_suport.ussd   = (UBYTE)FldGet(mssup.feat1,USSD);
+    ss_suport.etc    = (UBYTE)FldGet(mssup.feat1,ETC);
+  }
+
+  if (pcm_ReadFile((UBYTE *)EF_MSSET_ID,
+	               SIZE_EF_MSSET,
+				   (UBYTE *)&msset,
+				   &version) EQ PCM_OK)
+  {
+    ss_suport.clire   = (UBYTE)FldGet(msset.misc,clir);
+    ss_suport.clipr   = (UBYTE)FldGet(msset.misc,clip);
+  }
+#endif
+#endif
+  pwd_flag = 0;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_exit             |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :
+
+*/
+
+void ss_exit(void)
+{
+  TRACE_FUNCTION("ss_exit()");
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_create           |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  create event for supplementary management
+
+*/
+
+T_MFW_HND ss_create(T_MFW_HND hWin, T_MFW_EVENT event, T_MFW_CB cbfunc)
+{
+  T_MFW_HDR *hdr;
+  T_MFW_SS  *ss_para;
+  MfwHdr * insert_status =0;
+  
+  TRACE_FUNCTION("ss_create()");
+
+  hdr      = (T_MFW_HDR *) mfwAlloc(sizeof (T_MFW_HDR));
+  ss_para  = (T_MFW_SS *) mfwAlloc(sizeof (T_MFW_SS));
+
+  if (!hdr OR !ss_para)
+  	{
+    	TRACE_ERROR("ERROR: ss_create() Mem Alloc Failed.");
+			
+	   	if(hdr)
+   			mfwFree((U8*)hdr,sizeof(MfwHdr));
+
+   		if(ss_para)
+   			mfwFree((U8*)ss_para,sizeof(T_MFW_SS));
+   		
+	   	return FALSE;
+    }
+  
+  /*
+   * initialisation of the handler
+   */
+  ss_para->emask   = event;
+  ss_para->handler = cbfunc;
+
+  hdr->data = ss_para;                           /* store parameter in node     */
+  hdr->type = MFW_TYP_SS;                   /* store type of event handler */
+
+  /*
+   * installation of the handler
+   */
+  insert_status = mfwInsert((T_MFW_HDR *)hWin, hdr);
+  
+  if(!insert_status)
+  	{
+  		TRACE_ERROR("ERROR: ss_create() Failed to Install Handler. ");
+   		mfwFree((U8*)hdr,sizeof(MfwHdr));
+   		mfwFree((U8*)ss_para,sizeof(T_MFW_SS)); 	
+		return 0;
+  	}
+    return insert_status;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_delete           |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :   delete a event for supplementary management
+
+*/
+
+T_MFW_RES ss_delete(T_MFW_HND h)
+{
+  TRACE_FUNCTION("ss_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_SS));
+  mfwFree((U8 *)h,sizeof(T_MFW_HDR));
+
+  return MFW_RES_OK;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_sign_exec        |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : Send a signal if SS management handler.
+
+*/
+
+BOOL ss_sign_exec (T_MFW_HDR * cur_elem, T_MFW_EVENT event, T_MFW_SS_PARA * para)
+{
+  TRACE_FUNCTION ("ss_sign_exec()");
+
+  while (cur_elem)
+  {
+    /*
+     * event handler is available
+     */
+    if (cur_elem->type EQ MFW_TYP_SS)
+    {
+      T_MFW_SS * ss_data;
+      /*
+       * handler is SS management handler
+       */
+      ss_data = (T_MFW_SS *)cur_elem->data;
+      if (ss_data->emask & event)
+      {
+        /*
+         * event is expected by the call back function
+         */
+        ss_data->event = event;
+        switch (event)
+        {
+          case E_SS_NOTIFY:
+            memcpy (&ss_data->para.notify, para, sizeof (T_MFW_SS_NOTIFY));
+            break;
+
+          case E_SS_CF_CNF:
+          case E_SS_CF_ICN_UPD:
+            memcpy (&ss_data->para.cf_cnf, para, sizeof (T_MFW_SS_CF_CNF));
+            break;
+
+          case E_SS_CB_CNF:
+            memcpy (&ss_data->para.cb_cnf, para, sizeof (T_MFW_SS_CB_CNF));
+            break;
+
+          case E_SS_CW_CNF:
+            memcpy (&ss_data->para.cw_cnf, para, sizeof (T_MFW_SS_CW_CNF));
+            break;
+
+          case E_SS_CLI_CNF:
+            memcpy (&ss_data->para.cli_cnf, para, sizeof (T_MFW_SS_CLI_CNF));
+            break;
+
+          case E_SS_RES:
+            memcpy (&ss_data->para.ss_res, para, sizeof (T_MFW_SS_RES));
+            break;
+
+          case E_SS_GET_PW:
+            memcpy (&ss_data->para.pw_cnf, para, sizeof (T_MFW_SS_PW_CNF));
+            break;
+
+		  case E_SS_IMEI:
+            memcpy (&ss_data->para.imei_info, para, sizeof (T_MFW_IMEI));
+            break;
+
+          case E_SS_USSD_REQ:
+            memcpy (&ss_data->para.ussd_info, para, sizeof (T_MFW_SS_USSD));
+            break;
+
+          case E_SS_USSD_CNF:
+            memcpy (&ss_data->para.ussd_info, para, sizeof (T_MFW_SS_USSD));
+            break;
+        }
+
+        /*
+         * if call back defined, call it
+         */
+        if (ss_data->handler)
+        {
+          // PATCH LE 06.06.00
+          // store current mfw elem
+          current_mfw_elem = cur_elem;
+          // END PATCH LE 06.06.00
+
+          if ((*(ss_data->handler)) (ss_data->event, (void *)&ss_data->para))
+            return TRUE;
+        }
+      }
+    }
+    cur_elem = cur_elem->next;
+  }
+  return FALSE;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_signal           |
++--------------------------------------------------------------------+
+
+   PURPOSE : send a event signal.
+
+*/
+
+void ss_signal(T_MFW_EVENT event, void * para)
+{
+	UBYTE temp;
+  TRACE_FUNCTION ("ss_signal()");
+	
+temp = dspl_Enable(0);
+if (mfwSignallingMethod EQ 0)
+  {
+  /*
+   * focus is on a window
+   */
+  if (mfwFocus)
+    /*
+     * send event to sim management
+     * handler if available
+     */
+    if (ss_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)
+     ss_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 (ss_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;
+      }
+      ss_sign_exec (mfwRoot, event, para);
+    }
+  dspl_Enable(temp);
+}
+
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_check_ss_string  |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Check SS string
+
+*/
+
+T_MFW_SS_RETURN ss_check_ss_string(UBYTE *string)
+{
+  T_MFW_SS_RETURN  ss_group;
+  T_KSD_SEQGRP     grp;
+  CHAR            *rest;
+  T_KSD_SEQPARAM   para;
+  SHORT            id;
+  int                string_length;
+  UBYTE            call_active=FALSE;
+
+  TRACE_FUNCTION("ss_check_ss_string");
+
+  #define MFW_MAX_DIAL_SHORT_STRING_LEN 2
+
+  /* check the type of destination address */
+  if ((cm_search_callId(CAL_STAT_Held, &id) == CM_OK)
+      OR (cm_search_callId(CAL_STAT_Active, &id) == CM_OK))
+   {
+     call_active = TRUE;   
+    ksd_decode((CHAR *)string, TRUE, &grp, &rest, &para);
+   }
+  else
+    ksd_decode((CHAR *)string, FALSE, &grp, &rest, &para);
+
+  /* check short string */
+
+  string_length = strlen((char*)string);
+
+ TRACE_EVENT_P2("ksd_decode(""%s"") returns -> %d",(char*)string,grp);
+
+
+  switch (grp)
+  {
+  case (SEQGRP_DIAL): /*JVJ CQ 6242 */
+    if (string_length<=MFW_MAX_DIAL_SHORT_STRING_LEN)
+    {
+    /* If the call is active, the short string will be USSD in all the cases not described in ETSI 2.30*/
+      if (call_active)                
+        grp = SEQGRP_USSD;
+        /* If the call is not active, the short strings 1x will be DIAL, the rest USSD*/
+      else if ((string_length EQ 1)||(*(string) NEQ '1'))
+        grp = SEQGRP_USSD;	
+    }
+  break;
+  case (SEQGRP_SUP_CLIR):   /* JGG/JVJ - CQ 6537 */
+  case (SEQGRP_INV_CLIR):
+    if (strlen(rest)!=0)
+    {
+      T_MFW_SS_RETURN  rest_ss_group;
+
+    /*check to make sure that the number is a real dial string */
+      rest_ss_group = ss_check_ss_string((UBYTE*)rest);
+      if (rest_ss_group EQ MFW_SS_DIAL) /*If rest is a dial string, then the whole string is dial */
+        ss_group = MFW_SS_DIAL;
+      else 
+        ss_group = MFW_SS_UNKNOWN;   
+
+      TRACE_EVENT_P2("ss_check_ss_string(""%s"") returns -> %d",(char*)string,ss_group);
+      return ss_group;
+    }
+  break;
+  default:
+  break;
+ }
+
+  ss_group = ss_check_group(grp, para);
+
+ TRACE_EVENT_P2("ss_check_ss_string(""%s"") returns -> %d",(char*)string,ss_group);
+
+ return ss_group;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_decode           |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Decode SS string
+
+*/
+
+T_MFW_SS_RETURN ss_decode(UBYTE *string, CHAR **rt, T_KSD_SEQPARAM *p)
+{
+  T_KSD_SEQGRP     grp;
+  CHAR            *rest;
+  T_KSD_SEQPARAM   para;
+  SHORT            id;
+  BOOL	bRetVal;
+
+  TRACE_FUNCTION("ss_decode()");
+
+// Added the checking of wait call to solve the bug MMI-SPR 13873.
+// If the call is a waiting also pass TRUE as the second parameter to the 
+// function ksd_decode() to decode the entered number. In ksd_decode only if   
+// the second parameter is TRUE the sequential table is searched to find out 
+// the group where the user entered string belongs to.
+  if ((cm_search_callId(CAL_STAT_Held, &id) == CM_OK)
+      OR (cm_search_callId(CAL_STAT_Active, &id) == CM_OK)
+        OR (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)) 
+  {
+    	bRetVal = ksd_decode((CHAR *)string, TRUE, &grp, &rest, &para);
+    	if (!bRetVal)
+      		*rest = 0;
+  }
+  else
+  {
+    bRetVal = ksd_decode((CHAR *)string, FALSE, &grp, &rest, &para);
+    if (!bRetVal)
+      *rest = 0;
+  }
+
+  if (!bRetVal)
+    return MFW_SS_FAIL;
+
+  *rt = rest;
+
+  if (grp == SEQGRP_UNKNOWN)
+    return MFW_SS_UNKNOWN;
+
+  memcpy(p, &para, sizeof(T_KSD_SEQPARAM));
+  return(ss_check_group(grp, para));
+}
+
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_check_group      |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  returns the group of SS string
+
+*/
+
+T_MFW_SS_RETURN ss_check_group(T_KSD_SEQGRP grp, T_KSD_SEQPARAM   para)
+{
+	TRACE_EVENT_P1("ss_check_group: grp=%d", grp);
+	
+  switch (grp)
+  {
+    case SEQGRP_DIAL:
+      /*SPR#1352 - SH - Check for TTY On Next Call psuedo-ss strings*/
+      if (!strncmp((char*)para.ussd.ussd, TTY_NEXTCALL_ON, strlen(TTY_NEXTCALL_ON)))
+        return MFW_SS_TTY_NEXTCALL_ON;
+      if (!strncmp((char*)para.ussd.ussd, TTY_NEXTCALL_OFF, strlen(TTY_NEXTCALL_OFF)))
+        return MFW_SS_TTY_NEXTCALL_OFF;
+	   /*SH end*/
+      return MFW_SS_DIAL;
+
+    case SEQGRP_DIAL_IDX:
+      return MFW_SS_DIAL_IDX;
+
+    case SEQGRP_DTMF:
+      return MFW_SS_DTMF;
+
+    case SEQGRP_USSD:
+    /*MC, SPR 1111 check for LANGUAGE reset code*/
+    
+    if (!strncmp((char*)para.ussd.ussd, LANG_RESET, strlen(LANG_RESET)) && para.ussd.ussd[6]=='#')
+    	return MFW_SS_LANG_RESET;
+   /*MC end*/
+     return MFW_SS_USSD;
+
+    case SEQGRP_ACT_SIM_LOCK:       /* lock SIM card   */
+    case SEQGRP_DEACT_SIM_LOCK:     /* unlock SIM card */
+    case SEQGRP_INTRGT_SIM_LOCK:
+      return MFW_SS_SIM_LOCK;
+
+    case SEQGRP_CHANGE_REGISTER:
+    case SEQGRP_SET_REGISTER:
+    case SEQGRP_START_REGISTER:
+      return MFW_SS_REG_PW;
+
+    case SEQGRP_CF:
+      return MFW_SS_CF;
+
+    case SEQGRP_CB:                     /* barring services                     */
+      return MFW_SS_CB;
+
+    case SEQGRP_SUP_CLIR:
+    case SEQGRP_INV_CLIR:
+      return MFW_SS_CLIR;
+
+    case SEQGRP_SUP_CLIP:
+    case SEQGRP_INV_CLIP:
+        return MFW_SS_CLIP;
+
+    case SEQGRP_SUP_COLR:
+    case SEQGRP_INV_COLR:
+        return MFW_SS_COLR;
+
+    case SEQGRP_SUP_COLP:
+    case SEQGRP_INV_COLP:
+        return MFW_SS_COLP;
+
+    case SEQGRP_CL:
+      switch (para.cl.ssCd)
+      {
+          case KSD_SS_CLIP:
+              return MFW_SS_CLIP;
+          case KSD_SS_CLIR:
+              return MFW_SS_CLIR;
+          case KSD_SS_COLP:
+              return MFW_SS_COLP;
+          case KSD_SS_COLR:
+              return MFW_SS_COLR;
+      }
+      return MFW_SS_UNKNOWN;
+
+    case SEQGRP_PWD:
+	  switch(para.pwd.ssCd)
+	  {
+/*    case KSD_SS_CCBS:      CCBS has nothing to do with PWD! */
+	    case KSD_SS_ALL_CBSS:
+        case KSD_SS_BOC:
+		case KSD_SS_BAOC:
+		case KSD_SS_BOIC:
+        case KSD_SS_BOICXH:
+		case KSD_SS_BIC:
+		case KSD_SS_BAIC:
+		case KSD_SS_BICRM:
+
+		/*NM 190602*/
+		case KSD_SS_ALL_SERV:
+		
+		  return MFW_SS_REG_PW;
+
+		case KSD_SS_PIN1:
+		case KSD_SS_PIN2:
+		  return MFW_SS_SIM_REG_PW;
+	  }
+	  return MFW_SS_UNKNOWN;
+
+    case SEQGRP_UBLK:
+      return MFW_SS_SIM_UNBLCK_PIN;
+
+    case SEQGRP_CW:
+      return MFW_SS_WAIT;
+
+    case SEQGRP_CCBS:
+      return MFW_SS_CCBS;
+
+    case SEQGRP_PRSNT_IMEI:
+      return MFW_SS_MMI;
+
+    case SEQGRP_CHLD:
+    /*MC 11.04.02 */
+    	if (para.chld.mode == CHLD_MOD_Ect)
+    		return MFW_SS_ECT;
+      else if (para.chld.mode == CHLD_MOD_Ccbs)
+        return MFW_SS_CCBS;
+    	else
+    /*MC*/
+      		return MFW_SS_HOLD;
+
+    case SEQGRP_UNKNOWN:
+      return MFW_SS_UNKNOWN;
+
+    default:
+      return MFW_SS_UNKNOWN;
+  }
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)   MODULE  : MFW_SS                 |
+| STATE   : code                   ROUTINE : ss_execute_transaction |
++-------------------------------------------------------------------+
+
+   PURPOSE :  Start a SS transaction
+
+*/
+
+T_MFW_SS_RETURN ss_execute_transaction(UBYTE *ss_string,
+									   UBYTE ussd_mand)
+{
+    T_ACI_RETURN res;
+
+    TRACE_FUNCTION("ss_execute_transaction()");
+
+    res = sAT_Dn(CMD_SRC_LCL, (CHAR *)ss_string, -1, -1, -1);
+    if( (res != AT_EXCT) AND (res != AT_CMPL))
+    {
+        TRACE_EVENT("sAT_D error");
+        return MFW_SS_FAIL;
+    }
+
+    return ss_check_ss_string(ss_string);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_cvtCssuCodes     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  This function is used to convert the CSSU mode
+              used by ACI to the CSSU mode used by MFW.
+
+*/
+
+T_MFW_SS_NOTIFY_CODES ss_cvtCssuCodes(T_ACI_CSSU_CODE code)
+{
+	switch (code)
+	{
+		case CSSU_CODE_ForwardedCall:  return MFW_SS_MT_FORWARDED;
+		case CSSU_CODE_CUGCall:        return MFW_SS_MT_CUG_CALL;
+		case CSSU_CODE_Multiparty:     return MFW_SS_NOTIFY_MULTIPARTY;
+		case CSSU_CODE_HeldCallRel:    return MFW_SS_NOTIFY_holdRELEASED;
+		case CSSU_CODE_FwrdCheckSS:    return MFW_SS_NOTIFY_checkSS;
+		case CSSU_CODE_ECTAlert:       return MFW_SS_NOTIFY_ectALERT;
+		case CSSU_CODE_ECTConnect:     return MFW_SS_NOTIFY_ectCONNECT;
+		case CSSU_CODE_DeflectedCall:  return MFW_SS_MT_DEFLECTED;
+		default:					   return MFW_SS_NOTIFY_UNKNOWN;
+	}
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_cvtCssiCodes     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  This function is used to convert the CSSI mode
+              used by ACI to the CSSI mode used by MFW.
+
+*/
+
+T_MFW_SS_NOTIFY_CODES ss_cvtCssiCodes(T_ACI_CSSI_CODE code)
+{
+	switch (code)
+	{
+		case CSSI_CODE_CFUActive:      return MFW_SS_MO_unconFORWARD;
+		case CSSI_CODE_SomeCCFActive:  return MFW_SS_MO_conFORWARD;
+		case CSSI_CODE_ForwardedCall:  return MFW_SS_MO_FORWARDED;
+		case CSSI_CODE_CallWaiting:    return MFW_SS_MO_WAITING;
+		case CSSI_CODE_CUGCall:        return MFW_SS_MO_CUG_CALL;
+		case CSSI_CODE_OutCallsBarred: return MFW_SS_MO_moBARRED;
+		case CSSI_CODE_IncCallsBarred: return MFW_SS_MO_mtBARRED;
+		case CSSI_CODE_CLIRSupRej:     return MFW_SS_MO_CLIR;
+		case CSSI_CODE_DeflectedCall:  return MFW_SS_MO_DEFLECTED;
+		default:					   return MFW_SS_NOTIFY_UNKNOWN;
+	}
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_notify           |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Change of SS status from the network.
+
+*/
+
+void ss_notify(T_MFW_SS_NOTIFY_CODES code,
+			   SHORT                 index,
+			   UBYTE                *number,
+			   UBYTE                *subaddr)
+{
+//	Apr 06 2005		REF: CRR 29989	xpradipg
+//	defined the variable locally since the scope lies within this function
+#ifdef FF_MMI_OPTIM
+	T_MFW_SS_NOTIFY    notify;
+#endif
+	memset(&notify, 0, sizeof(T_MFW_SS_NOTIFY));
+
+	notify.code = code;
+
+	if(number)
+		strcpy((char *)notify.number, (char *)number);
+	if (subaddr)
+		strcpy((char *)notify.subaddr, (char *)subaddr);
+
+	//PATCH TB 1309: Wrong codes tested
+	if ((code == MFW_SS_MO_CUG_CALL) OR 
+		(code == MFW_SS_MT_CUG_CALL))
+		notify.index = (UBYTE)index;
+	/* END PATCH TB	*/
+		
+    {
+		/***************************Go-lite Optimization changes Start***********************/
+		//Aug 16, 2004    REF: CRR 24323   Deepa M.D
+		TRACE_EVENT_P1 ("SS notify code = %d", notify.code);
+		/***************************Go-lite Optimization changes end***********************/
+    }
+
+	ss_signal(E_SS_NOTIFY, &notify);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE  : MFW_SS             |
+| STATE  : code                         ROUTINE : ss_cvtOCode        |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Convert operation codes
+
+*/
+
+T_MFW ss_cvtOCode(T_ACI_KSD_OP code)
+{
+    switch (code)
+	{
+		case KSD_OP_IRGT:           return SS_INTERROGATION;
+		case KSD_OP_REG:            return SS_REGISTRATION;
+		case KSD_OP_ERS:            return SS_ERASURE;
+		case KSD_OP_ACT:            return SS_ACTIVATION;
+		case KSD_OP_DEACT:          return SS_DEACTIVATION;
+		default:					return SS_CODES_UNKNOWN;
+	}
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE  : MFW_SS             |
+| STATE  : code                         ROUTINE : ss_cvtSCodes       |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  This function is used to convert the SS code
+              used by ACI to the SS code used by MFW.
+
+*/
+
+T_MFW ss_cvtSCode(T_ACI_KSD_SS code)
+{
+	switch (code)
+	{
+		case KSD_SS_CLIP:           return SS_CLIP;
+		case KSD_SS_CLIR:           return SS_CLIR;
+		case KSD_SS_COLP:           return SS_COLP;
+		case KSD_SS_COLR:           return SS_COLR;
+		case KSD_SS_CW:             return SS_CW;
+		case KSD_SS_BAIC:           return SS_CB_BAIC;
+		case KSD_SS_BAOC:           return SS_CB_BAOC;
+		case KSD_SS_ALL_CBSS:       return SS_CB_ALL;
+		case KSD_SS_BICRM:          return SS_CB_BAICroam;
+   		case KSD_SS_BIC:            return SS_CB_ALL_BAIC;
+   		case KSD_SS_BOICXH:         return SS_CB_BAOICexH;
+   		case KSD_SS_BOIC:           return SS_CB_BAOIC;
+   		case KSD_SS_BOC:            return SS_CB_ALL_BAOC;
+        case KSD_SS_CFB:            return SS_CF_CFB;
+        case KSD_SS_CFNRC:          return SS_CF_CFNR;
+        case KSD_SS_CFNRY:          return SS_CF_CFNRy;
+        case KSD_SS_CFU:            return SS_CF_CFU;
+        case KSD_SS_ALL_CFWSS:      return SS_CF_ALL_COND;
+        case KSD_SS_ALL_FWSS:       return SS_CF_ALL;
+        case KSD_SS_CCBS:           return SS_CCBS;
+        case KSD_SS_PIN1:           return SS_PIN1;
+        case KSD_SS_PIN2:           return SS_PIN2;
+		default:					return SS_CODES_UNKNOWN;
+	}
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE  : MFW_SS             |
+| STATE  : code                         ROUTINE : ss_cvtCLStatus     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  This function is used to convert the CL status
+              used by ACI to the CL status used by MFW.
+
+*/
+
+T_MFW ss_cvtCLStatus(T_ACI_KSD_CLIR_OP stat)
+{
+	switch (stat)
+	{
+		case KSD_CO_PERMANENT:            return MFW_CL_PERM;
+        case KSD_CO_TEMPORARY:            return MFW_CL_TEMP_DEF_REST;
+        case KSD_CO_ALLOWED:              return MFW_CL_TEMP_DEF_ALLOWED;
+		default:		                  return MFW_CL_UNKNOWN;
+	}
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE  : MFW_SS             |
+| STATE  : code                         ROUTINE : ss_cvtCLOvrd       |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  This function is used to convert the override status of
+              CLIR used by ACI to the override status of CLIR used by
+              MFW.
+
+*/
+
+T_MFW ss_cvtCLOvrd(T_ACI_KSD_OVRD_CTG ovrd)
+{
+	switch (ovrd)
+	{
+		case KSD_OVR_CAT_ENABLED:     return MFW_OV_ENABLED;
+        case KSD_OVR_CAT_DISABLED:    return MFW_OV_DISABLED;
+		default:		                  return MFW_OV_UNKNOWN;
+	}
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE  : MFW_SS             |
+| STATE  : code                         ROUTINE : ss_cvtErrCode      |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  This function is used to convert the error code used
+              by ACI to the error code used by MFW.
+
+*/
+
+T_MFW ss_cvtErrCode(T_ACI_KSD_ERR err)
+{
+	switch (err)
+	{
+		case KSD_NO_ERROR:                  return MFW_SS_NO_ERROR;
+    case KSD_ERR_UNKNOWN_SUBSCRIBER:    return MFW_SS_ERR_UNKNOWN_SUBSCRIBER;
+    case KSD_ERR_ILLEGAL_SUBSCRIBER:    return MFW_SS_ERR_ILLEGAL_SUBSCRIBER;
+    case KSD_ERR_BEARER_SVC_NOT_PROV:   return MFW_SS_ERR_BEARER_SVC_NOT_PROV;
+    case KSD_ERR_TELE_SVC_NOT_PROV:     return MFW_SS_ERR_TELE_SVC_NOT_PROV;
+    case KSD_ERR_ILLEGAL_EQUIPMENT:     return MFW_SS_ERR_ILLEGAL_EQUIPMENT;
+    case KSD_ERR_CALL_BARRED:           return MFW_SS_ERR_CALL_BARRED;
+    case KSD_ERR_ILLEGAL_SS_OPERATION:  return MFW_SS_ERR_ILLEGAL_SS_OPERATION;
+    case KSD_ERR_SS_ERR_STATUS:         return MFW_SS_ERR_SS_ERR_STATUS;
+    case KSD_ERR_SS_NOT_AVAIL:          return MFW_SS_ERR_SS_NOT_AVAIL;
+    case KSD_ERR_SS_SUBS_VIOLATION:     return MFW_SS_ERR_SS_SUBS_VIOLATION;
+    case KSD_ERR_SS_INCOMP:             return MFW_SS_ERR_SS_INCOMP;
+    case KSD_ERR_FAC_NOT_SUPPORTED:     return MFW_SS_ERR_FAC_NOT_SUPPORTED;
+    case KSD_ERR_ABSENT_SUBS:           return MFW_SS_ERR_ABSENT_SUBS;
+    case KSD_ERR_SYSTEM_FAIL:           return MFW_SS_ERR_SYSTEM_FAIL;
+    case KSD_ERR_DATA_MISSING:          return MFW_SS_ERR_DATA_MISSING;
+    case KSD_ERR_UNEXPECT_DATA:         return MFW_SS_ERR_UNEXPECT_DATA;
+    case KSD_ERR_PWD_REG_FAIL:          return MFW_SS_ERR_PWD_REG_FAIL;
+    case KSD_ERR_NEG_PWD_CHECK:         return MFW_SS_ERR_NEG_PWD_CHECK;
+    case KSD_ERR_NUM_PWD_VIOLATION:     return MFW_SS_ERR_NUM_PWD_VIOLATION;
+    case KSD_ERR_UNKNOWN_ALPHA:         return MFW_SS_ERR_UNKNOWN_ALPHA;
+    case KSD_ERR_USSD_BUSY:             return MFW_SS_ERR_USSD_BUSY;
+    case KSD_ERR_MAX_NUM_MPTY_EXCEED:   return MFW_SS_ERR_MAX_NUM_MPTY_EXCEED;
+    case KSD_ERR_RESOURCE_NOT_AVAIL:    return MFW_SS_ERR_RESOURCE_NOT_AVAIL;
+    case KSD_GEN_PROB_UNRECOG_CMP:      return MFW_SS_GEN_PROB_UNRECOG_CMP;
+    case KSD_GEN_PROB_MISTYPED_CMP:     return MFW_SS_GEN_PROB_MISTYPED_CMP;
+    case KSD_GEN_PROB_BAD_STRUCT_CMP:   return MFW_SS_GEN_PROB_BAD_STRUCT_CMP;
+    case KSD_INV_PROB_DUPL_INV_ID:      return MFW_SS_INV_PROB_DUPL_INV_ID;
+    case KSD_INV_PROB_UNRECOG_OP:       return MFW_SS_INV_PROB_UNRECOG_OP;
+    case KSD_INV_PROB_MISTYPED_PAR:     return MFW_SS_INV_PROB_MISTYPED_PAR;
+    case KSD_INV_PROB_RESOURCE_LIM:     return MFW_SS_INV_PROB_RESOURCE_LIM;
+    case KSD_INV_PROB_INIT_RELEASE:     return MFW_SS_INV_PROB_INIT_RELEASE;
+    case KSD_INV_PROB_UNRECOG_LNK_ID:   return MFW_SS_INV_PROB_UNRECOG_LNK_ID;
+    case KSD_INV_PROB_LNK_RES_UNEXP:    return MFW_SS_INV_PROB_LNK_RES_UNEXP;
+    case KSD_INV_PROB_UNEXP_LNK_OP:     return MFW_SS_INV_PROB_UNEXP_LNK_OP;
+    case KSD_RES_PROB_UNRECOG_INV_ID:   return MFW_SS_RES_PROB_UNRECOG_INV_ID;
+    case KSD_RES_PROB_RET_RES_UNEXP:    return MFW_SS_RES_PROB_RET_RES_UNEXP;
+    case KSD_RES_PROB_MISTYPED_PAR:     return MFW_SS_RES_PROB_MISTYPED_PAR;
+    case KSD_ERR_PROB_UNRECOG_INV_ID:   return MFW_SS_ERR_PROB_UNRECOG_INV_ID;
+    case KSD_ERR_PROB_RET_ERR_UNEXP:    return MFW_SS_ERR_PROB_RET_ERR_UNEXP;
+    case KSD_ERR_PROB_UNRECOG_ERR:      return MFW_SS_ERR_PROB_UNRECOG_ERR;
+    case KSD_ERR_PROB_UNEXP_ERR:        return MFW_SS_ERR_PROB_UNEXP_ERR;
+    case KSD_ERR_PROB_MISTYPED_PAR:     return MFW_SS_ERR_PROB_MISTYPED_PAR;
+    case KSD_ERR_FATAL_INV_RESULT:      return MFW_SS_ERR_FATAL_INV_RESULT;
+    case KSD_ERR_FATAL_CCD_DEC:         return MFW_SS_ERR_FATAL_CCD_DEC;
+    case KSD_ERR_FATAL_SS_ENT:          return MFW_SS_ERR_FATAL_SS_ENT;
+    default:                            return MFW_SS_ERR_UNKNOWN;
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE  : MFW_SS             |
+| STATE  : code                         ROUTINE : ss_decode_imei     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  convert imei (packed bcd to ASCII)
+
+*/
+
+void ss_decode_imei(T_ACI_KSIR *ksStat)
+{
+//	Apr 06 2005		REF: CRR 29989	xpradipg
+#ifdef FF_MMI_OPTIM
+	memset(imei_info, 0, sizeof(T_MFW_IMEI));
+
+    imei_info->imei_number[0] = ( ksStat->ir.rKSIMEI.tac1 & 0xF0 )   >> 4 | 0x30;
+    imei_info->imei_number[1] = ( ksStat->ir.rKSIMEI.tac1 )   & 0x0F | 0x30;
+    imei_info->imei_number[2] = ( ksStat->ir.rKSIMEI.tac2 & 0xF0 )   >> 4 | 0x30;
+	imei_info->imei_number[3] = ( ksStat->ir.rKSIMEI.tac2 )   & 0x0F | 0x30;
+    imei_info->imei_number[4] = ( ksStat->ir.rKSIMEI.tac3 & 0xF0 )   >> 4 | 0x30;
+	imei_info->imei_number[5] = ( ksStat->ir.rKSIMEI.tac3 )   & 0x0F | 0x30;
+    imei_info->imei_number[6] = ( ksStat->ir.rKSIMEI.fac  & 0xF0 )   >> 4 | 0x30;
+	imei_info->imei_number[7] = ( ksStat->ir.rKSIMEI.fac  )    & 0x0F | 0x30;
+    imei_info->imei_number[8] = ( ksStat->ir.rKSIMEI.snr1 & 0xF0 )   >> 4 | 0x30;
+	imei_info->imei_number[9] = ( ksStat->ir.rKSIMEI.snr1 )   & 0x0F | 0x30;
+    imei_info->imei_number[10] = ( ksStat->ir.rKSIMEI.snr2 & 0xF0 )  >> 4 | 0x30;
+	imei_info->imei_number[11] = ( ksStat->ir.rKSIMEI.snr2 )  & 0x0F | 0x30;
+    imei_info->imei_number[12] = ( ksStat->ir.rKSIMEI.snr3 & 0xF0 ) >> 4 | 0x30;
+	imei_info->imei_number[13] = ( ksStat->ir.rKSIMEI.snr3 )  & 0x0F | 0x30;
+//a0876501 - Check byte comes before the Software version during display.
+	imei_info->imei_number[14] = ( ksStat->ir.rKSIMEI.cd & 0x0F ) | 0x30;
+    imei_info->imei_number[15] = ( ksStat->ir.rKSIMEI.svn  & 0xF0 ) >> 4 | 0x30;
+	imei_info->imei_number[16] = ( ksStat->ir.rKSIMEI.svn )  & 0x0F | 0x30;
+	imei_info->imei_number[17] = '\0';
+#else
+    memset(&imei_info, 0, sizeof(imei_info));
+//	Jul 05 2005		REF: CRR 22565	a0876501
+//	Fixed the issue of byte swapping.
+
+    imei_info.imei_number[0] = ( ksStat->ir.rKSIMEI.tac1 & 0xF0 )   >> 4 | 0x30;
+    imei_info.imei_number[1] = ( ksStat->ir.rKSIMEI.tac1 )   & 0x0F | 0x30;
+    imei_info.imei_number[2] = ( ksStat->ir.rKSIMEI.tac2 & 0xF0 )   >> 4 | 0x30;
+	imei_info.imei_number[3] = ( ksStat->ir.rKSIMEI.tac2 )   & 0x0F | 0x30;
+    imei_info.imei_number[4] = ( ksStat->ir.rKSIMEI.tac3 & 0xF0 )   >> 4 | 0x30;
+	imei_info.imei_number[5] = ( ksStat->ir.rKSIMEI.tac3 )   & 0x0F | 0x30;
+    imei_info.imei_number[6] = ( ksStat->ir.rKSIMEI.fac  & 0xF0 )   >> 4 | 0x30;
+	imei_info.imei_number[7] = ( ksStat->ir.rKSIMEI.fac  )    & 0x0F | 0x30;
+    imei_info.imei_number[8] = ( ksStat->ir.rKSIMEI.snr1 & 0xF0 )   >> 4 | 0x30;
+	imei_info.imei_number[9] = ( ksStat->ir.rKSIMEI.snr1 )   & 0x0F | 0x30;
+    imei_info.imei_number[10] = ( ksStat->ir.rKSIMEI.snr2 & 0xF0 )  >> 4 | 0x30;
+	imei_info.imei_number[11] = ( ksStat->ir.rKSIMEI.snr2 )  & 0x0F | 0x30;
+    imei_info.imei_number[12] = ( ksStat->ir.rKSIMEI.snr3 & 0xF0 ) >> 4 | 0x30;
+	imei_info.imei_number[13] = ( ksStat->ir.rKSIMEI.snr3 )  & 0x0F | 0x30;
+//a0876501 - Check byte comes before the Software version during display.
+	imei_info.imei_number[14] = ( ksStat->ir.rKSIMEI.cd & 0x0F ) | 0x30;
+    imei_info.imei_number[15] = ( ksStat->ir.rKSIMEI.svn  & 0xF0 ) >> 4 | 0x30;
+	imei_info.imei_number[16] = ( ksStat->ir.rKSIMEI.svn )  & 0x0F | 0x30;
+	imei_info.imei_number[17] = '\0';
+
+  TRACE_EVENT_P8("ss_decode_imei IMEI: TAC %1c%1c%1c%1c%1c%1c%1c%1c",
+                  imei_info.imei_number[0], imei_info.imei_number[1], imei_info.imei_number[2], imei_info.imei_number[3],
+                  imei_info.imei_number[4], imei_info.imei_number[5], imei_info.imei_number[6], imei_info.imei_number[7]);
+  TRACE_EVENT_P6("ss_decode_imei IMEI: SNR %1c%1c%1c%1c%1c%1c",
+                  imei_info.imei_number[8],  imei_info.imei_number[9], imei_info.imei_number[10], imei_info.imei_number[11],
+                  imei_info.imei_number[12], imei_info.imei_number[13]);
+  TRACE_EVENT_P4("ss_decode_imei IMEI: SV CD %1c%1c%1c%1c", 
+				  imei_info.imei_number[14], imei_info.imei_number[15], imei_info.imei_number[16],imei_info.imei_number[17]);
+
+#endif	
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE  : MFW_SS             |
+| STATE  : code                         ROUTINE : getCdByteFromImei  |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Get CD byte from IMEI.  
+//	July 23, 2005   REF : MMI-22565 - a0876501
+*/
+
+UBYTE getCdByteFromImei(UBYTE *imei)
+{
+	T_ACI_IMEI aci_imei;
+
+//	July 23, 2005   REF : MMI-22565 - a0876501
+//	For calculating the Cd byte, copy the buffer contents.
+  aci_imei.tac1 = imei[0];
+  aci_imei.tac2 = imei[1];
+  aci_imei.tac3 = imei[2];
+  aci_imei.fac  = imei[3];
+  aci_imei.snr1 = imei[4];
+  aci_imei.snr2 = imei[5];
+  aci_imei.snr3 = imei[6];
+  aci_imei.svn  = imei[7];
+#ifndef NEPTUNE_BOARD
+
+  return(cmhSS_getCdFromImei(&aci_imei));
+
+#endif
+
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: rAT_PercentKSIR     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Network response for key sequences
+
+*/
+
+void rAT_PercentKSIR ( T_ACI_KSIR *ksStat)
+{
+    UBYTE idx;
+    T_MFW_TELECOM   *p_tele;
+    T_MFW_FEATURE   *p_feat;
+    T_MFW_SRV_GROUP *p_srv;
+
+    TRACE_FUNCTION("rAT_PercentKSIR()");
+    TRACE_EVENT_P1("ksStat->ksdCmd %d", ksStat->ksdCmd);
+
+    switch (ksStat->ksdCmd)
+    {
+        case KSD_CMD_CB:
+          TRACE_EVENT("KSD_CMD_CB");
+          TRACE_EVENT_P1("ksStat->ir.rKSCB.ssCd %d", ksStat->ir.rKSCB.ssCd);
+          TRACE_EVENT_P1("ksStat->ir.rKSCB.opCd %d", ksStat->ir.rKSCB.opCd);
+          TRACE_EVENT_P1("ksStat->ir.rKSCB.ssErr %d", ksStat->ir.rKSCB.ssErr);
+          TRACE_EVENT_P1("ksStat->ir.rKSCB.c_cbInfoLst %d", ksStat->ir.rKSCB.c_cbInfoLst);
+          if (ksStat->ir.rKSCB.c_cbInfoLst)
+          {
+            int i;
+            for (i = 0; i < ksStat->ir.rKSCB.c_cbInfoLst; i++)
+            {
+              TRACE_EVENT_P2("ksStat->ir.rKSCB.cbInfoLst[%d].bsTp %d", i, ksStat->ir.rKSCB.cbInfoLst[i].bsTp);
+              TRACE_EVENT_P2("ksStat->ir.rKSCB.cbInfoLst[%d].bsCd %d", i, ksStat->ir.rKSCB.cbInfoLst[i].bsCd);
+              TRACE_EVENT_P2("ksStat->ir.rKSCB.cbInfoLst[%d].ssSt %d", i, ksStat->ir.rKSCB.cbInfoLst[i].ssSt);
+            }
+          }
+          p_tele = (T_MFW_TELECOM *) ssLstBuf;
+//     	Apr 06 2005		REF: CRR 29989	xpradipg
+#ifdef FF_MMI_OPTIM
+			cb_cnf = (T_MFW_SS_CB_CNF*)mfwAlloc(sizeof(T_MFW_SS_CB_CNF));
+			if(NULL != cb_cnf)
+		{
+		  TRACE_EVENT_P2("Mem Aloc for cb_cnf = %x Size = %d",cb_cnf,sizeof(T_MFW_SS_CB_CNF));
+		  cb_cnf->ss_code = ss_cvtSCode(ksStat->ir.rKSCB.ssCd);
+          cb_cnf->ss_category = ss_cvtOCode(ksStat->ir.rKSCB.opCd);
+          cb_cnf->ss_error    = ss_cvtErrCode(ksStat->ir.rKSCB.ssErr);
+          cb_cnf->ss_telecom_list = p_tele;
+         }
+         else
+         	return;
+#else
+	   	  cb_cnf.ss_code = (T_MFW_SS_CODES) ss_cvtSCode((T_ACI_KSD_SS)ksStat->ir.rKSCB.ssCd);
+          cb_cnf.ss_category = (T_MFW_SS_CATEGORY)ss_cvtOCode((T_ACI_KSD_OP)ksStat->ir.rKSCB.opCd);
+          cb_cnf.ss_error    = (T_MFW_SS_ERROR)ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSCB.ssErr);
+          cb_cnf.ss_telecom_list = p_tele;
+#endif          
+
+          for( idx = 0;
+               idx < ksStat->ir.rKSCB.c_cbInfoLst AND
+               idx < MFW_MAX_TELE_NR;
+               idx++, p_tele++ )
+          {
+            p_tele->ss_telecom_type    = ksStat->ir.rKSCB.
+                                                     cbInfoLst[idx].bsTp;
+            p_tele->ss_telecom_service = ksStat->ir.rKSCB.
+                                                     cbInfoLst[idx].bsCd;
+            p_tele->ss_status = ksStat->ir.rKSCB.
+                                            cbInfoLst[idx].ssSt;
+          }
+//	Apr 06 2005		REF: CRR 29989	xpradipg          
+#ifdef FF_MMI_OPTIM
+		if(NULL != cb_cnf)	
+          cb_cnf->ss_telecom_count = idx;
+#else
+          cb_cnf.ss_telecom_count = idx;
+#endif          
+          break;
+
+        case KSD_CMD_CF:
+          TRACE_EVENT("KSD_CMD_CF");
+          TRACE_EVENT_P1("ksStat->ir.rKSCF.ssCd %d", ksStat->ir.rKSCF.ssCd);
+          TRACE_EVENT_P1("ksStat->ir.rKSCF.opCd %d", ksStat->ir.rKSCF.opCd);
+          TRACE_EVENT_P1("ksStat->ir.rKSCF.ssErr %d", ksStat->ir.rKSCF.ssErr);
+          TRACE_EVENT_P1("ksStat->ir.rKSCF.c_cfFeatLst %d", ksStat->ir.rKSCF.c_cfFeatLst);
+          if (ksStat->ir.rKSCF.c_cfFeatLst)
+          {
+            int i;
+            for (i = 0; i < ksStat->ir.rKSCF.c_cfFeatLst; i++)
+            {
+              TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].bsTp %d", i, ksStat->ir.rKSCF.cfFeatLst[i].bsTp);
+              TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].bsCd %d", i, ksStat->ir.rKSCF.cfFeatLst[i].bsCd);
+              TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].ssSt %d", i, ksStat->ir.rKSCF.cfFeatLst[i].ssSt);
+              TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].num %s", i, ksStat->ir.rKSCF.cfFeatLst[i].num);
+              TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].ton 0x%02X", i, ksStat->ir.rKSCF.cfFeatLst[i].ton);
+              TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].npi 0x%02X", i, ksStat->ir.rKSCF.cfFeatLst[i].npi);
+              TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].sub %s", i, ksStat->ir.rKSCF.cfFeatLst[i].sub);
+              TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].tos 0x%02X", i, ksStat->ir.rKSCF.cfFeatLst[i].tos);
+              TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].oe 0x%02X", i, ksStat->ir.rKSCF.cfFeatLst[i].oe);
+              TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].time 0x%02X", i, ksStat->ir.rKSCF.cfFeatLst[i].time);
+            }
+          }
+          p_feat = (T_MFW_FEATURE *) ssLstBuf;
+//	Apr 06 2005		REF: CRR 29989	xpradipg
+#ifdef FF_MMI_OPTIM
+		  cf_cnf = (T_MFW_SS_CF_CNF*)mfwAlloc(sizeof(T_MFW_SS_CF_CNF));
+		  if(NULL != cf_cnf)
+	      {
+      		TRACE_EVENT_P2("Mem Loc = %x, allocates size = %d",cf_cnf,sizeof(T_MFW_SS_CF_CNF));
+		      cf_cnf->ss_code = (T_MFW_SS_CODES)ss_cvtSCode((T_ACI_KSD_SS)ksStat->ir.rKSCF.ssCd);
+	          cf_cnf->ss_category = (T_MFW_SS_CATEGORY)ss_cvtOCode((T_ACI_KSD_OP)ksStat->ir.rKSCF.opCd);
+	          cf_cnf->ss_error    = (T_MFW_SS_ERROR)ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSCF.ssErr);
+	          cf_cnf->ss_feature_list = p_feat;
+	      }
+#else
+		      cf_cnf.ss_code = (T_MFW_SS_CODES)ss_cvtSCode((T_ACI_KSD_SS)ksStat->ir.rKSCF.ssCd);
+          cf_cnf.ss_category = (T_MFW_SS_CATEGORY)ss_cvtOCode((T_ACI_KSD_OP)ksStat->ir.rKSCF.opCd);
+          cf_cnf.ss_error    = (T_MFW_SS_ERROR)ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSCF.ssErr);
+
+          cf_cnf.ss_feature_list = p_feat;
+#endif	
+          for( idx = 0;
+               idx < ksStat->ir.rKSCF.c_cfFeatLst AND
+               idx < MFW_MAX_FEAT_NR;
+               idx++, p_feat++ )
+          {
+            p_feat->ss_telecom_type    = ksStat->ir.rKSCF.
+                                                      cfFeatLst[idx].bsTp;
+            p_feat->ss_telecom_service = ksStat->ir.rKSCF.
+                                                      cfFeatLst[idx].bsCd;
+            p_feat->ss_status = ksStat->ir.rKSCF.cfFeatLst[idx].ssSt;
+            p_feat->ss_numbering_type = phb_cvtTon(ksStat->ir.rKSCF.
+                                                                cfFeatLst[idx].ton);
+            p_feat->ss_numbering_plan = (UBYTE)phb_cvtNpi(ksStat->ir.rKSCF.
+                                                                cfFeatLst[idx].npi);
+            strncpy((char *)p_feat->ss_forwarded_to_number,
+                    (char *)ksStat->ir.rKSCF.cfFeatLst[idx].num,
+                    MFW_SS_NUM_LEN);
+            strncpy((char *)p_feat->ss_forwarded_to_subaddress,
+                    (char *)ksStat->ir.rKSCF.cfFeatLst[idx].sub,
+                    MFW_SS_SUBADR_LEN);
+            p_feat->ss_no_reply_condition_time = ksStat->ir.rKSCF.
+                                                              cfFeatLst[idx].time;
+          }
+//	Apr 06 2005		REF: CRR 29989	xpradipg          
+#ifdef FF_MMI_OPTIM
+		if(NULL != cf_cnf)
+          cf_cnf->ss_feature_count = idx;
+#else
+          cf_cnf.ss_feature_count = idx;
+#endif          
+	TRACE_EVENT("rat_percentksir->KSD_CMD_CF");
+          if (ksStat->srcId != CMD_SRC_LCL)
+//	Apr 06 2005		REF: CRR 29989	xpradipg          
+#ifdef FF_MMI_OPTIM
+			{	
+				
+				ss_signal(E_SS_CF_ICN_UPD,cf_cnf);
+			}				
+#else
+ 	            ss_signal(E_SS_CF_ICN_UPD, &cf_cnf);
+#endif
+
+          break;
+
+        case KSD_CMD_CL:
+          TRACE_EVENT("KSD_CMD_CL");
+          TRACE_EVENT_P1("ksStat->ir.rKSCL.ssCd %d", ksStat->ir.rKSCL.ssCd);
+          TRACE_EVENT_P1("ksStat->ir.rKSCL.opCd %d", ksStat->ir.rKSCL.opCd);
+          TRACE_EVENT_P1("ksStat->ir.rKSCL.ssErr %d", ksStat->ir.rKSCL.ssErr);
+          TRACE_EVENT_P1("ksStat->ir.rKSCL.ssSt %d", ksStat->ir.rKSCL.ssSt);
+          TRACE_EVENT_P1("ksStat->ir.rKSCL.mode %d", ksStat->ir.rKSCL.mode);
+          TRACE_EVENT_P1("ksStat->ir.rKSCL.clirOpt %d", ksStat->ir.rKSCL.clirOpt);
+          TRACE_EVENT_P1("ksStat->ir.rKSCL.ovrdCtg %d", ksStat->ir.rKSCL.ovrdCtg);
+//	Apr 06 2005		REF: CRR 29989	xpradipg          
+#ifdef FF_MMI_OPTIM
+		  cli_cnf = (T_MFW_SS_CLI_CNF*)mfwAlloc(sizeof(T_MFW_SS_CLI_CNF));
+		  if(NULL != cli_cnf)
+		  {
+	      	cli_cnf->ss_code = ss_cvtSCode(ksStat->ir.rKSCL.ssCd);
+          	cli_cnf->ss_category = ss_cvtOCode(ksStat->ir.rKSCL.opCd);
+          	cli_cnf->ss_error     = ss_cvtErrCode(ksStat->ir.rKSCL.ssErr);
+          	cli_cnf->ss_status      = ksStat->ir.rKSCL.ssSt;
+          	cli_cnf->ss_clir_option = ss_cvtCLStatus(ksStat->ir.rKSCL.clirOpt);
+          	cli_cnf->ss_ovrd_ctgry  = ss_cvtCLOvrd(ksStat->ir.rKSCL.ovrdCtg);
+		  }
+#else
+	      cli_cnf.ss_code = (T_MFW_SS_CODES)ss_cvtSCode((T_ACI_KSD_SS)ksStat->ir.rKSCL.ssCd);
+          cli_cnf.ss_category = (T_MFW_SS_CATEGORY)ss_cvtOCode((T_ACI_KSD_OP)ksStat->ir.rKSCL.opCd);
+          cli_cnf.ss_error     = (T_MFW_SS_ERROR)ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSCL.ssErr);
+
+          cli_cnf.ss_status      = ksStat->ir.rKSCL.ssSt;
+          cli_cnf.ss_clir_option = (T_MFW_SS_ERROR)ss_cvtCLStatus((T_ACI_KSD_CLIR_OP)ksStat->ir.rKSCL.clirOpt);
+          cli_cnf.ss_ovrd_ctgry  = (T_MFW_OV_CTGRY)ss_cvtCLOvrd((T_ACI_KSD_OVRD_CTG)ksStat->ir.rKSCL.ovrdCtg);
+#endif          
+          break;
+
+        case KSD_CMD_CW:
+          TRACE_EVENT("KSD_CMD_CW");
+          TRACE_EVENT_P1("ksStat->ir.rKSCW.ssCd %d", ksStat->ir.rKSCW.ssCd);
+          TRACE_EVENT_P1("ksStat->ir.rKSCW.opCd %d", ksStat->ir.rKSCW.opCd);
+          TRACE_EVENT_P1("ksStat->ir.rKSCW.ssErr %d", ksStat->ir.rKSCW.ssErr);
+          TRACE_EVENT_P1("ksStat->ir.rKSCW.ssSt %d", ksStat->ir.rKSCW.ssSt);
+          TRACE_EVENT_P1("ksStat->ir.rKSCW.c_cwBSGLst %d", ksStat->ir.rKSCW.c_cwBSGLst);
+          if (ksStat->ir.rKSCW.c_cwBSGLst)
+          {
+            int i;
+            for (i = 0; i < ksStat->ir.rKSCW.c_cwBSGLst; i++)
+            {
+              TRACE_EVENT_P2("ksStat->ir.rKSCW.cwBSGLst[%d].bsTp %d", i, ksStat->ir.rKSCW.cwBSGLst[i].bsTp);
+              TRACE_EVENT_P2("ksStat->ir.rKSCW.cwBSGLst[%d].bsCd %d", i, ksStat->ir.rKSCW.cwBSGLst[i].bsCd);
+            }
+          }
+          p_srv = (T_MFW_SRV_GROUP *) ssLstBuf;
+//		Apr 06 2005		REF: CRR 29989	xpradipg          
+#ifdef FF_MMI_OPTIM
+		  cw_cnf = (T_MFW_SS_CW_CNF*)mfwAlloc(sizeof(T_MFW_SS_CW_CNF));
+		  if(cw_cnf != NULL)
+		  {
+	      	cw_cnf->ss_code = ss_cvtSCode(ksStat->ir.rKSCW.ssCd);
+	        cw_cnf->ss_category = ss_cvtOCode(ksStat->ir.rKSCW.opCd);
+   	    	cw_cnf->ss_error    = ss_cvtErrCode(ksStat->ir.rKSCW.ssErr);
+    	    cw_cnf->ss_status   = ksStat->ir.rKSCW.ssSt;
+            cw_cnf->ss_service_list = p_srv;
+          }
+        
+#else	
+	      cw_cnf.ss_code = (T_MFW_SS_CODES)ss_cvtSCode((T_ACI_KSD_SS)ksStat->ir.rKSCW.ssCd);
+          cw_cnf.ss_category = (T_MFW_SS_CATEGORY)ss_cvtOCode((T_ACI_KSD_OP)ksStat->ir.rKSCW.opCd);
+          cw_cnf.ss_error    = (T_MFW_SS_ERROR)ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSCW.ssErr);
+          cw_cnf.ss_status   = ksStat->ir.rKSCW.ssSt;
+
+          cw_cnf.ss_service_list = p_srv;
+#endif
+          for( idx = 0;
+               idx < ksStat->ir.rKSCW.c_cwBSGLst AND
+               idx < MFW_MAX_SRV_NR;
+               idx++, p_srv++ )
+          {
+            p_srv->ss_telecom_type    = ksStat->ir.rKSCW.
+                                                       cwBSGLst[idx].bsTp;
+            p_srv->ss_telecom_service = ksStat->ir.rKSCW.
+                                                       cwBSGLst[idx].bsCd;
+          }
+//	Apr 06 2005		REF: CRR 29989	xpradipg          
+#ifdef FF_MMI_OPTIM
+		if(NULL != cw_cnf)
+		  cw_cnf->ss_service_count = idx;
+#else
+          cw_cnf.ss_service_count = idx;
+#endif          
+          break;
+
+      case KSD_CMD_PWD:
+          TRACE_EVENT("KSD_CMD_PWD");
+          TRACE_EVENT_P1("ksStat->ir.rKSPW.ssCd %d", ksStat->ir.rKSPW.ssCd);
+          TRACE_EVENT_P1("ksStat->ir.rKSPW.opCd %d", ksStat->ir.rKSPW.opCd);
+          TRACE_EVENT_P1("ksStat->ir.rKSPW.ssErr %d", ksStat->ir.rKSPW.ssErr);
+          TRACE_EVENT_P1("ksStat->ir.rKSPW.newPwd %s", ksStat->ir.rKSPW.newPwd);
+//		Apr 06 2005		REF: CRR 29989	xpradipg          
+#ifdef FF_MMI_OPTIM
+		  pw_cnf = (T_MFW_SS_PW_CNF*)mfwAlloc(sizeof(T_MFW_SS_PW_CNF));
+		  if( NULL != pw_cnf)		
+		  {
+            pw_cnf->ss_code      = ss_cvtSCode(ksStat->ir.rKSPW.ssCd);
+          	pw_cnf->ss_category  = ss_cvtOCode(ksStat->ir.rKSPW.opCd);
+          	pw_cnf->ss_error     = ss_cvtErrCode(ksStat->ir.rKSPW.ssErr);
+
+          	strncpy( (char *)pw_cnf->ss_new_pwd, (char *)ksStat->ir.rKSPW.newPwd,
+                   MFW_SS_PWD_LEN);
+		  }	                   
+#else
+          pw_cnf.ss_code      = (T_MFW_SS_CODES)ss_cvtSCode((T_ACI_KSD_SS)ksStat->ir.rKSPW.ssCd);
+          pw_cnf.ss_category  = (T_MFW_SS_CATEGORY)ss_cvtOCode((T_ACI_KSD_OP)ksStat->ir.rKSPW.opCd);
+          pw_cnf.ss_error     = (T_MFW_SS_ERROR)ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSPW.ssErr);
+
+          strncpy( (char *)pw_cnf.ss_new_pwd, (char *)ksStat->ir.rKSPW.newPwd,
+                   MFW_SS_PWD_LEN);
+#endif                   
+          break;
+
+	  case KSD_CMD_IMEI:
+          TRACE_EVENT("KSD_CMD_IMEI");
+          TRACE_EVENT_P1("ksStat->ir.rKSIMEI.tac1 %d", ksStat->ir.rKSIMEI.tac1);
+          TRACE_EVENT_P1("ksStat->ir.rKSIMEI.tac2 %d", ksStat->ir.rKSIMEI.tac2);
+          TRACE_EVENT_P1("ksStat->ir.rKSIMEI.tac3 %d", ksStat->ir.rKSIMEI.tac3);
+          TRACE_EVENT_P1("ksStat->ir.rKSIMEI.fac %d", ksStat->ir.rKSIMEI.fac);
+          TRACE_EVENT_P1("ksStat->ir.rKSIMEI.snr1 %d", ksStat->ir.rKSIMEI.snr1);
+          TRACE_EVENT_P1("ksStat->ir.rKSIMEI.snr2 %d", ksStat->ir.rKSIMEI.snr2);
+          TRACE_EVENT_P1("ksStat->ir.rKSIMEI.snr3 %d", ksStat->ir.rKSIMEI.snr3);
+          TRACE_EVENT_P1("ksStat->ir.rKSIMEI.svn %d", ksStat->ir.rKSIMEI.svn);
+          TRACE_EVENT_P1("ksStat->ir.rKSIMEI.cd %d", ksStat->ir.rKSIMEI.cd);
+//	Apr 06 2005		REF: CRR 29989	xpradipg          
+#ifdef FF_MMI_OPTIM
+		  imei_info = (T_MFW_IMEI*)mfwAlloc(sizeof(T_MFW_IMEI));
+		  if( NULL != imei_info)
+		  {
+#endif
+          ss_decode_imei(ksStat);
+//	Apr 06 2005		REF: CRR 29989	xpradipg          
+#ifdef FF_MMI_OPTIM
+		  imei_info->error = MFW_SS_NO_ERROR;
+		  ss_signal(E_SS_IMEI, imei_info);
+		  }
+#else		  
+          imei_info.error = MFW_SS_NO_ERROR;
+			    ss_signal(E_SS_IMEI, &imei_info);
+#endif
+		      break;
+
+      case KSD_CMD_USSD:
+          TRACE_EVENT("KSD_CMD_USSD");
+          TRACE_EVENT_P1("ksStat->ir.rKSUS.ussd %s", ksStat->ir.rKSUS.ussd);
+          TRACE_EVENT_P1("ksStat->ir.rKSUS.dcs 0x%02X", ksStat->ir.rKSUS.dcs);
+          TRACE_EVENT_P1("ksStat->ir.rKSUS.mode %d", ksStat->ir.rKSUS.mode);
+          TRACE_EVENT_P1("ksStat->ir.rKSUS.ssErr %d", ksStat->ir.rKSUS.ssErr);
+          memset(&ussd_info, 0, sizeof(ussd_info));
+          ussd_info.len = strlen((char *)ksStat->ir.rKSUS.ussd);
+          strcpy((char*)ussd_info.ussd, (char *)ksStat->ir.rKSUS.ussd);
+          ussd_info.dcs = MFW_ASCII;
+          ussd_info.error    = ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSUS.ssErr);
+          break;
+
+        default:
+          TRACE_EVENT("default");
+          break;
+    }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_command_info     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Notify for send a SS string from ACI
+
+*/
+
+void ss_command_info(T_ACI_CLOG* cmd)
+{
+//	Apr 06 2005		REF: CRR 29989	xpradipg
+//	the variable is made local since the scope lies within this function
+#ifdef FF_MMI_OPTIM
+	    T_MFW_SS_RES       ss_res;
+#endif	    
+    TRACE_FUNCTION("ss_command_info()");
+
+    if (cmd->cmdPrm.sCFUN.srcId != CMD_SRC_LCL)
+		return;
+
+    switch (cmd->atCmd)
+    {
+        case KSD_CMD_CB:
+            ss_res.type     = ss_cvtSCode((T_ACI_KSD_SS)cmd->cmdPrm.sKSCB.ssCd);
+            ss_res.category = ss_cvtOCode((T_ACI_KSD_OP)cmd->cmdPrm.sKSCB.opCd);
+            if( cmd->cmdPrm.sKSCB.pwd )
+              strncpy(ss_res.ppn, (char *)cmd->cmdPrm.sKSCB.pwd,
+                     MAX_PWD_LEN);
+            else
+              ss_res.ppn[0] = 0;
+            ss_res.pwd[0] = 0;
+            ss_res.bs = cmd->cmdPrm.sKSCB.bsCd;
+            ss_res.time = 0;
+            ss_signal(E_SS_RES, &ss_res);
+        		break;
+
+        case KSD_CMD_CF:
+            ss_res.type = ss_cvtSCode((T_ACI_KSD_SS)cmd->cmdPrm.sKSCF.ssCd);
+            ss_res.category = ss_cvtOCode((T_ACI_KSD_OP)cmd->cmdPrm.sKSCF.opCd);
+            ss_res.ppn[0] = 0;
+            ss_res.pwd[0] = 0;
+            ss_res.bs = cmd->cmdPrm.sKSCF.bsCd;
+            ss_res.time = cmd->cmdPrm.sKSCF.time;
+            ss_signal(E_SS_RES, &ss_res);
+        		break;
+
+        case KSD_CMD_CW:
+            ss_res.type = SS_CW;
+            ss_res.category = ss_cvtOCode((T_ACI_KSD_OP)cmd->cmdPrm.sKSCW.opCd);
+            ss_res.ppn[0] = 0;
+            ss_res.pwd[0] = 0;
+            ss_res.bs = cmd->cmdPrm.sKSCW.bsCd;
+            ss_res.time = 0;
+            ss_signal(E_SS_RES, &ss_res);
+        		break;
+
+        case KSD_CMD_PWD:
+			      switch(cmd->cmdPrm.sKSPW.ssCd)
+			      {
+				        case KSD_SS_CCBS:
+				        case KSD_SS_ALL_CBSS:
+				        case KSD_SS_BOC:
+				        case KSD_SS_BAOC:
+				        case KSD_SS_BOIC:
+				        case KSD_SS_BOICXH:
+				        case KSD_SS_BIC:
+				        case KSD_SS_BAIC:
+				        case KSD_SS_BICRM:
+
+
+						/*NM 190602*/
+						case KSD_SS_ALL_SERV :
+
+						
+					          ss_res.type = ss_cvtSCode((T_ACI_KSD_SS)cmd->cmdPrm.sKSPW.ssCd);
+					          ss_res.category = SS_REGISTRATION;
+                    if( cmd->cmdPrm.sKSPW.oldPwd )
+					              strncpy(ss_res.ppn, (char *)cmd->cmdPrm.sKSPW.oldPwd,
+                                MAX_PWD_LEN);
+                    else
+                        ss_res.ppn[0] = 0;
+                    if( cmd->cmdPrm.sKSPW.newPwd )
+					              strncpy(ss_res.pwd, (char *)cmd->cmdPrm.sKSPW.newPwd,
+                                MAX_PWD_LEN);
+                    else
+                        ss_res.pwd[0] = 0;
+					          ss_res.bs = 0;
+					          ss_res.time = 0;
+					          ss_signal(E_SS_RES, &ss_res);
+        			      break;
+
+				        case KSD_SS_PIN1:
+                    pwd_flag = 1;
+                    sim_pin_ident(MFW_SIM_PIN1);
+					          break;
+				        case KSD_SS_PIN2:
+					          pwd_flag = 1;
+                    sim_pin_ident(MFW_SIM_PIN2);
+					          break;
+	          }
+            break;
+
+        case KSD_CMD_UBLK:
+            switch(cmd->cmdPrm.sKSPW.ssCd)
+			      {
+                case KSD_SS_PIN1:
+                    pwd_flag = 1;
+                    sim_pin_ident(MFW_SIM_PUK1);
+					          break;
+				        case KSD_SS_PIN2:
+					          pwd_flag = 1;
+                    sim_pin_ident(MFW_SIM_PUK2);
+					          break;
+            }
+            break;
+
+        case KSD_CMD_CL:
+            ss_res.type = ss_cvtSCode((T_ACI_KSD_SS)cmd->cmdPrm.sKSCL.ssCd);
+            ss_res.category = ss_cvtOCode((T_ACI_KSD_OP)cmd->cmdPrm.sKSCL.opCd);
+            ss_res.ppn[0] = 0;
+            ss_res.pwd[0] = 0;
+            ss_res.bs = 0;
+            ss_res.time = 0;
+            ss_signal(E_SS_RES, &ss_res);
+        		break;
+
+        case KSD_CMD_USSD:
+            memset(&ussd_info, 0, sizeof(ussd_info));
+            if( cmd->cmdPrm.sKSUS.ussd )
+            {
+              ussd_info.len = strlen((char *)cmd->cmdPrm.sKSUS.ussd);
+              strcpy((char*)ussd_info.ussd, (char *)cmd->cmdPrm.sKSUS.ussd);
+            }
+            else
+              ussd_info.ussd[0] = 0;
+            ussd_info.dcs = MFW_ASCII;
+            //PATCH TB 1509
+            ss_res.type = SS_USSD;
+            ss_res.category = SS_CTG_UNKNOWN;
+            ss_res.ppn[0] = 0;
+            ss_res.pwd[0] = 0;
+            ss_res.bs = 0;
+            ss_res.time = 0;
+            ss_signal(E_SS_RES, &ss_res);
+            //END PATCH TB
+            break;
+
+        case AT_CMD_CUSD:
+            memset(&ussd_info, 0, sizeof(ussd_info));
+            ussd_info.len = cmd->cmdPrm.sCUSD.str->len;
+            memcpy((char*)ussd_info.ussd, cmd->cmdPrm.sCUSD.str->data, cmd->cmdPrm.sCUSD.str->len);
+            ussd_info.dcs = (T_MFW_DCS)cmd->cmdPrm.sCUSD.dcs;
+/* SPR#CQ3204 -JVJ - USSD call back sent to MMI */
+            ss_res.type = SS_USSD;
+            ss_res.category = SS_CTG_UNKNOWN;
+            ss_res.ppn[0] = 0;
+            ss_res.pwd[0] = 0;
+            ss_res.bs = 0;
+            ss_res.time = 0;
+            ss_signal(E_SS_RES, &ss_res);
+/* SPR#CQ3204 -JVJ */
+            break;
+        default:
+		    break;
+    }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_ok_string        |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Send of SS string is successful.
+
+*/
+
+void ss_ok_string(T_ACI_AT_CMD cmdId)
+{
+    TRACE_FUNCTION("ss_ok_string()");
+
+    switch (cmdId)
+    {
+        case KSD_CMD_CB:
+//	Apr 06 2005		REF: CRR 29989	xpradipg
+//	free the allocated memory once the ss_signal() execution is done
+#ifdef FF_MMI_OPTIM
+			TRACE_EVENT("KSD_CMD_CB");
+			if(cb_cnf)
+			{
+				ss_signal(E_SS_CB_CNF, cb_cnf);
+				mfwFree((U8*)cb_cnf, sizeof(T_MFW_SS_CB_CNF));
+			}
+#else        
+            ss_signal(E_SS_CB_CNF, &cb_cnf);
+#endif         
+            break;
+        case KSD_CMD_CF:
+//	Apr 06 2005		REF: CRR 29989	xpradipg        
+#ifdef FF_MMI_OPTIM
+			TRACE_EVENT("KSD_CMD_CF");
+			if(cf_cnf)
+			{
+				ss_signal(E_SS_CF_CNF, cf_cnf);
+				mfwFree((U8*)cf_cnf, sizeof(T_MFW_SS_CF_CNF));
+			}
+#else        
+            ss_signal(E_SS_CF_CNF, &cf_cnf);
+#endif            
+            
+            break;
+        case KSD_CMD_CW:
+//	Apr 06 2005		REF: CRR 29989	xpradipg        
+#ifdef FF_MMI_OPTIM
+			TRACE_EVENT("KSD_CMD_CW");
+			if(cw_cnf)
+			{
+				ss_signal(E_SS_CW_CNF, cw_cnf);
+				mfwFree((U8*)cw_cnf, sizeof(T_MFW_SS_CW_CNF));
+			}
+#else        
+            ss_signal(E_SS_CW_CNF, &cw_cnf);
+#endif           
+            break;
+        case KSD_CMD_PWD:
+//	Apr 06 2005		REF: CRR 29989	xpradipg        
+#ifdef FF_MMI_OPTIM
+			TRACE_EVENT("KSD_CMD_PW");
+			if(pw_cnf)
+			{
+				if (!pwd_flag)
+					ss_signal(E_SS_GET_PW, pw_cnf);
+				mfwFree((U8*)pw_cnf,sizeof(T_MFW_SS_PW_CNF));
+			}
+#else        
+            if (!pwd_flag)
+				ss_signal(E_SS_GET_PW, &pw_cnf);
+#endif           
+			
+			if (pwd_flag == 1)
+			{
+				pwd_flag = 0;
+				sim_ok_cpinc();
+			}
+        	break;
+        case KSD_CMD_UBLK:
+            sim_ss_unblock(SIM_UBLK_OK, CME_ERR_NotPresent);
+            break;
+        case KSD_CMD_CL:
+//	Apr 06 2005		REF: CRR 29989	xpradipg        
+#ifdef FF_MMI_OPTIM
+			TRACE_EVENT("KSD_CMD_CLI");
+			if(cli_cnf)
+			{
+				ss_signal(E_SS_CLI_CNF,(void*) cli_cnf);
+				mfwFree((U8*)cli_cnf, sizeof(T_MFW_SS_CLI_CNF));
+			}
+#else
+			ss_signal(E_SS_CLI_CNF,&cli_cnf);
+#endif			
+            break;
+		case KSD_CMD_IMEI:
+//	Apr 06 2005		REF: CRR 29989	xpradipg		
+#ifdef FF_MMI_OPTIM
+			if( imei_info)
+			{
+				imei_info->error = MFW_SS_NO_ERROR;
+				ss_signal(E_SS_IMEI, imei_info);
+				mfwFree((U8*)imei_info,sizeof(T_MFW_IMEI));
+			}
+#else
+			imei_info.error = MFW_SS_NO_ERROR;
+			ss_signal(E_SS_IMEI, &imei_info);
+#endif			
+			break;
+        default:
+            break;
+    	}
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_error_string     |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :   Send of SS string is failed.
+
+*/
+
+void ss_error_string(T_ACI_AT_CMD cmdId, T_ACI_CME_ERR reason)
+{
+    TRACE_FUNCTION("ss_error_string()");
+
+    switch (cmdId)
+    {
+        case KSD_CMD_CB:
+//	Apr 06 2005		REF: CRR 29989	xpradipg
+//	deallocation occurs either in ok/ error since the response is always is
+//	either one of them
+ #ifdef FF_MMI_OPTIM
+ 			TRACE_EVENT("KSD_CMD_CB");
+ 			if(cb_cnf)
+ 			{
+				ss_signal(E_SS_CB_CNF, cb_cnf);
+				mfwFree((U8*)cb_cnf,sizeof(T_MFW_SS_CB_CNF));
+			}
+#else        
+            ss_signal(E_SS_CB_CNF, &cb_cnf);
+#endif         
+            break;
+        case KSD_CMD_CF:
+//	Apr 06 2005		REF: CRR 29989	xpradipg        
+#ifdef FF_MMI_OPTIM
+			TRACE_EVENT("KSD_CMD_CF");
+			if(cf_cnf)
+			{
+				ss_signal(E_SS_CF_CNF, cf_cnf);
+				mfwFree((U8*)cf_cnf,sizeof(T_MFW_SS_CF_CNF));
+				TRACE_FUNCTION("memory freed for cf_cnf");
+			}
+#else        
+            ss_signal(E_SS_CF_CNF, &cf_cnf);
+#endif            
+            break;
+        case KSD_CMD_CW:
+//	Apr 06 2005		REF: CRR 29989	xpradipg        
+#ifdef FF_MMI_OPTIM       
+			TRACE_EVENT("KSD_CMD_CW");
+			if(cw_cnf)
+			{
+            	ss_signal(E_SS_CW_CNF, cw_cnf);
+               	mfwFree((U8*)E_SS_CW_CNF,sizeof(T_MFW_SS_CW_CNF));
+            }
+#else            
+            ss_signal(E_SS_CW_CNF, &cw_cnf);
+#endif            
+            break;
+       case KSD_CMD_PWD:
+//	Apr 06 2005		REF: CRR 29989	xpradipg       
+#ifdef FF_MMI_OPTIM       
+			TRACE_EVENT("KSD_CMD_PW");
+			if(pw_cnf)
+			{
+		    	if (!pwd_flag)
+					ss_signal(E_SS_GET_PW, pw_cnf);
+				mfwFree((U8*)pw_cnf,sizeof(T_MFW_SS_PW_CNF));
+			}
+#else
+		    if (!pwd_flag)
+				ss_signal(E_SS_GET_PW, &pw_cnf);
+#endif				
+			if (pwd_flag == 1)
+			{
+				pwd_flag = 0;
+				sim_error_cpinc();
+			}
+      		break;
+        case KSD_CMD_UBLK:
+            sim_ss_unblock(SIM_UBLK_ERROR, reason);
+            break;
+        case KSD_CMD_CL:
+//	Apr 06 2005		REF: CRR 29989	xpradipg        
+#ifdef FF_MMI_OPTIM
+			TRACE_EVENT("KSD_CMD_CLI");
+			if(cli_cnf)
+			{
+				ss_signal(E_SS_CLI_CNF, cli_cnf);
+				mfwFree((U8*)cli_cnf,sizeof(T_MFW_SS_CLI_CNF));
+			}
+#else
+			ss_signal(E_SS_CLI_CNF,&cli_cnf);
+#endif	
+		case KSD_CMD_IMEI:
+//	Apr 06 2005		REF: CRR 29989	xpradipg		
+#ifdef FF_MMI_OPTIM
+			if( imei_info)
+			{
+				imei_info->error = MFW_SS_ERROR;
+				ss_signal(E_SS_IMEI, imei_info);
+				mfwFree((U8*)imei_info,sizeof(T_MFW_IMEI));
+			}
+#else
+			imei_info.error = MFW_SS_ERROR;
+			ss_signal(E_SS_IMEI, &imei_info);
+#endif				
+              break;
+        default:
+            break;
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_set_clck         |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :   This function execute the facility lock command.
+
+*/
+
+T_MFW ss_set_clck(T_ACI_CLCK_FAC fac,
+                  T_ACI_CLCK_MOD mode,
+                  CHAR *passwd,
+                  T_ACI_CLASS class_type,
+                  UBYTE modul)
+{
+    TRACE_EVENT("ss_set_clck()");
+
+    clck_flag = modul;
+
+    if (sAT_PlusCLCK(CMD_SRC_LCL, fac,mode, passwd, class_type) != AT_EXCT)
+        return MFW_SS_FAIL;
+    return MFW_SS_OK;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SS             |
+| STATE   : code                        ROUTINE : ss_ok_clck         |
++--------------------------------------------------------------------+
+
+  PURPOSE : The executing of the facility lock command is successful.
+
+*/
+
+void ss_ok_clck()
+{
+    TRACE_FUNCTION("ss_ok_clck()");
+
+    switch (clck_flag)
+    {
+        case MFW_PHB:
+            phb_ok_clck();
+            break;
+        case MFW_SIM_CPIND:
+            sim_ok_cpind();
+            break;
+        case MFW_SIM_CPINE:
+            sim_ok_cpine();
+            break;
+    }
+    clck_flag = MFW_MODUL_UNKNOWN;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SS             |
+| STATE   : code                        ROUTINE : ss_error_clck      |
++--------------------------------------------------------------------+
+
+  PURPOSE : The executing of the facility lock command is failed.
+
+*/
+
+void ss_error_clck()
+{
+    TRACE_FUNCTION("ss_error_clck()");
+
+    switch (clck_flag)
+    {
+        case MFW_PHB:
+            phb_error_clck();
+            break;
+        case MFW_SIM_CPIND:
+            sim_error_cpind();
+            break;
+        case MFW_SIM_CPINE:
+            sim_error_cpine();
+            break;
+    }
+    clck_flag = MFW_MODUL_UNKNOWN;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_DMY              |
+| STATE  : code                         ROUTINE: ss_send_ussd        |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Send USSD string.
+              Note: ASCII is not allowed to use.
+
+*/
+
+T_MFW ss_send_ussd(T_MFW_SS_USSD *ussd_info)
+{
+    T_ACI_USSD_DATA str;
+    T_ACI_RETURN    res;
+
+    TRACE_FUNCTION("ss_send_ussd()");
+
+    if (!ussd_info->len OR !ussd_info->ussd)
+        return MFW_SS_FAIL;
+
+    if (ussd_info->dcs == MFW_ASCII)
+        return MFW_SS_FAIL;
+
+    if (ussd_info->len > MAX_USSD_LEN)
+    {
+        str.len = MAX_USSD_LEN;
+        memcpy(str.data, ussd_info->ussd, MAX_USSD_LEN);
+    }
+    else
+    {
+        str.len = ussd_info->len;
+        memcpy(str.data, ussd_info->ussd, ussd_info->len);
+    }
+
+    res = sAT_PlusCUSD(CMD_SRC_LCL, &str, (SHORT)ussd_info->dcs);
+    if ((res != AT_EXCT) AND (res != AT_CMPL))
+        return MFW_SS_FAIL;
+
+    return MFW_SS_OK;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_DMY              |
+| STATE  : code                         ROUTINE: rAT_PlusCUSD        |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  Notify or response for USSD from ACI
+
+*/
+
+void rAT_PlusCUSD(T_ACI_CUSD_MOD m, T_ACI_USSD_DATA *ussd, SHORT dcs)
+{
+    TRACE_FUNCTION("rAT_PlusCUSD()");
+//Dec 16, 2005 OMAPS00053316	x0018858
+//Added the NullCheck to ensure that we dont access the elements when the pointer is NULL.
+//Begin OMAPS00053316
+if(ussd != NULL)
+{
+    ussd_info.len = ussd->len;
+    memcpy(ussd_info.ussd, ussd->data, sizeof(ussd_info.ussd));	
+	
+}
+else
+{
+    ussd_info.len = 0;
+    memset(ussd_info.ussd, 0x00, sizeof(ussd_info.ussd));	
+}
+//End OMAPS00053316
+    ussd_info.dcs = (T_MFW_DCS)dcs;
+    ussd_info.error = MFW_SS_NO_ERROR;
+
+    if (m == CUSD_MOD_YesActReq)
+        ss_signal(E_SS_USSD_REQ, &ussd_info);
+    if (m == CUSD_MOD_NoActReq)
+        ss_signal(E_SS_USSD_CNF, &ussd_info);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_DMY              |
+| STATE  : code                         ROUTINE: ss_ok_ussd          |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :  USSD process is successful.
+
+*/
+
+void ss_ok_ussd(T_ACI_AT_CMD cmdId)
+{
+    TRACE_FUNCTION("ss_ok_ussd()");
+
+    if (cmdId == KSD_CMD_USSD)
+    {
+        ussd_info.error = MFW_SS_NO_ERROR;
+        ss_signal(E_SS_USSD_CNF, &ussd_info);
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_error_ussd       |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :   USSD process is failed.
+
+*/
+
+void ss_error_ussd(T_ACI_AT_CMD cmdId, T_ACI_CME_ERR reason)
+{
+    TRACE_FUNCTION("ss_error_ussd()");
+
+//    ussd_info.error = ss_cvtErrCode(reason);
+    ss_signal(E_SS_USSD_CNF, &ussd_info);
+}
+
+/*
++---------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS                |
+| STATE  : code                         ROUTINE: ss_abort_transaction |
++---------------------------------------------------------------------+
+
+
+   PURPOSE :   Abort executing of SS transaction
+
+*/
+
+T_MFW ss_abort_transaction(void)
+{
+  TRACE_FUNCTION("ss_abort_transaction()");
+  
+  if (sAT_Abort(CMD_SRC_LCL, AT_CMD_CUSD) EQ AT_CMPL)
+    return TRUE;
+  else
+  {
+    if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) EQ AT_CMPL)
+      return TRUE;
+  }
+  return FALSE;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_set_cug          |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : set parameter of close user group
+
+*/
+T_MFW_SS_RETURN ss_set_cug (T_MFW_SS_CUG_PARA *cug_param)
+{
+	T_ACI_CCUG_MOD  cug_mode  = CCUG_MOD_NotPresent;
+    T_ACI_CCUG_IDX  cug_index = CCUG_IDX_NotPresent;
+    T_ACI_CCUG_INFO cug_info  = CCUG_INFO_NotPresent;
+
+	TRACE_FUNCTION("ss_set_cug()");
+
+/* check cug mode  */
+	switch(cug_param->mode)
+	{
+		case MFW_SS_CUG_TMP_DISABLE: 
+			cug_mode = CCUG_MOD_DisableTmp;
+			break;
+		case MFW_SS_CUG_TMP_ENABLE:
+			cug_mode = CCUG_MOD_EnableTmp; /* enable to control cug info   */
+			break;
+		default:                           /* ACI keep last valid value    */
+			break;
+	}
+/* check cug index  */
+	switch(cug_param->index)
+	{
+		case MFW_SS_CUG_INDEX0:
+			cug_index = CCUG_IDX_0;
+			break;
+		case MFW_SS_CUG_INDEX1:
+			cug_index = CCUG_IDX_1;
+			break;
+		case MFW_SS_CUG_INDEX2:
+			cug_index = CCUG_IDX_2;
+			break;
+		case MFW_SS_CUG_INDEX3:
+			cug_index = CCUG_IDX_3;
+			break;
+		case MFW_SS_CUG_INDEX4:
+			cug_index = CCUG_IDX_4;
+			break;
+		case MFW_SS_CUG_INDEX5:
+			cug_index = CCUG_IDX_5;
+			break;
+		case MFW_SS_CUG_INDEX6:
+			cug_index = CCUG_IDX_6;
+			break;
+		case MFW_SS_CUG_INDEX7:
+			cug_index = CCUG_IDX_7;
+			break;
+		case MFW_SS_CUG_INDEX8:
+			cug_index = CCUG_IDX_8;
+			break;
+		case MFW_SS_CUG_INDEX9:		
+			cug_index = CCUG_IDX_9;
+			break;
+		case MFW_SS_CUG_NO_INDEX:
+			cug_index = CCUG_IDX_No;  /* preferred CUG taken from subscriber data */
+			break;
+		default:                      /* ACI keep last valid value      */
+			break;
+	}
+
+/* check cug info  */
+	switch(cug_param->info)
+	{
+		case MFW_SS_CUG_SUPP_OA:
+			cug_info = CCUG_INFO_SuppOa;      /* suppress outgoing access  */
+			break;
+		case MFW_SS_CUG_SUPP_PREF:
+			cug_info = CCUG_INFO_SuppPrefCug; /* suppress preferential closed user group */
+			break;
+		case MFW_SS_CUG_SUPP_BOTH:
+			cug_info = CCUG_INFO_SuppBoth;    /* suppress outgoing access and preferential cug */
+			break;
+		case MFW_SS_CUG_INFO_NO:              /* no cug info */
+			cug_info = CCUG_INFO_No;
+			break;
+		default:                              /* ACI keep last valid value      */
+			break;
+	}
+	if(sAT_PlusCCUG(CMD_SRC_LCL,cug_mode,cug_index,cug_info) EQ AT_CMPL) /* set in ACI cug parameters */
+		return MFW_SS_OK;
+	else
+		return MFW_SS_FAIL;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_get_cug          |
++--------------------------------------------------------------------+
+
+
+   PURPOSE : get parameter of close user group
+
+*/
+
+T_MFW_SS_RETURN ss_get_cug(T_MFW_SS_CUG_PARA *cug_param)
+{
+	T_ACI_CCUG_MOD  cug_mode;
+    T_ACI_CCUG_IDX  cug_index;
+    T_ACI_CCUG_INFO cug_info; 
+
+	cug_param->mode =  MFW_SS_CUG_MODE_Not_Present;
+	cug_param->index = MFW_SS_CUG_INDEX_Not_Present;
+	cug_param->info =  MFW_SS_CUG_INFO_Not_Present;
+
+    TRACE_FUNCTION("ss_get_cug()");
+
+	if(qAT_PlusCCUG(CMD_SRC_LCL,&cug_mode,&cug_index,&cug_info) NEQ AT_CMPL) /* get cug parameters of ACI */
+		return MFW_SS_FAIL;
+	else
+	{
+		cug_param->mode = (T_MFW_SS_CUG_MODE)cug_mode;
+		cug_param->index = (T_MFW_SS_CUG_INDEX)cug_index;
+		cug_param->info = (T_MFW_SS_CUG_INFO)cug_info;
+		return MFW_SS_OK;
+	}
+}
+//PATCH TB 1309
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         MODULE: MFW_SS               |
+| STATE  : code                         ROUTINE: ss_command_abort    |
++--------------------------------------------------------------------+
+
+
+   PURPOSE :
+
+*/
+T_MFW ss_command_abort(void)
+{
+  TRACE_FUNCTION ("ss_command_abort()");
+
+	// Abort SS transaction.
+	// Any SS AT_CMD will clear all SS (any) transaction(s)
+  if (sAT_Abort(CMD_SRC_LCL, AT_CMD_CUSD) == AT_CMPL)
+		return TRUE;
+	else
+		return FALSE;
+}
+//END PATCH TB
+//CQ-16432 start
+void ss_sat_passwdReqd(T_ACI_AT_CMD cmdId, T_ACI_CME_ERR err)
+{
+	TRACE_FUNCTION("ss_sat_passwdReqd");
+	ss_signal(E_SS_SAT_CPWD,&cmdId);
+	return;
+}
+//CQ-16432 end