/*
+--------------------------------------------------------------------+
| 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