FreeCalypso > hg > fc-magnetite

view src/ui3/mfw/mfw_nm.c @ 624:012028896cfb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
FFS dev.c, Leonardo target: Fujitsu MB84VF5F5F4J2 #if 0'ed out The FFS code we got from TI/Openmoko had a stanza for "Fujitsu MB84VF5F5F4J2 stacked device", using a fake device ID code that would need to be patched manually into cfgffs.c (suppressing and overriding autodetection) and using an FFS base address in the nCS2 bank, indicating that this FFS config was probably meant for the MCP version of Leonardo which allows for 16 MiB flash with a second bank on nCS2. We previously had this FFS config stanza conditionalized under CONFIG_TARGET_LEONARDO because the base address contained therein is invalid for other targets, but now that we actually have a Leonardo build target in FC Magnetite, I realize that the better approach is to #if 0 out this stanza altogether: it is already non-functional because it uses a fake device ID code, thus it is does not add support for more Leonardo board variants, instead it is just noise.
author Mychaela Falconia <falcon@freecalypso.org>
date Sun, 22 Dec 2019 21:24:29 +0000
parents e8ddbb0837ed
children
line wrap: on
line source

/*
+--------------------------------------------------------------------+
| PROJECT: MMI-Framework (8417)         $Workfile:: mfw_nm.c        $|
| $Author:: Es                          $Revision::  1              $|
| CREATED: 07.10.98                     $Modtime:: 2.03.00 16:28    $|
| STATE  : code                                                      |
+--------------------------------------------------------------------+

   MODULE  : MFW_NM

   PURPOSE : This modul contains the functions for network management.


   $History:: mfw_nm.c

   Aug 07, 2007 DR:OMAPS00137726 x0066814(Geetha)
   Description:HPLMN Manual Selection at power on -
            unable to perform manual selection at power ON
   Solution: Added a new function nm_get_plmn_list_during_bootup() 
            to get the PLMN list during boot up.
  

   Apr 13, 2007 DRT:OMAPS00122739 x0066814(Geetha)
   Description: With Orange SIM card, once attached (at+cgatt=1), "5201" is displayed instead of "Orange"
   Solution: In nm_nitz_info_ind(), commented the code to copy mnc, mcc, long name and short anme 
   to net_ind from mmr_info_ind.
   May 31, 2007 DR: OMAPS00133201 x0pleela
   Description: MS keeps searching networks and doesn't list available PLMNs after 
   			performing manual selection
   Solution : Modified the function nm_error_cops() to check for 
   			CME_ERR_AbortedByNetwork error and send event 
   			E_NM_ABORT_NETWORK to BMI to destroy the n/w searching dialog

   Mar 12 2007 ,x0061088 (Prachi)
   Removed function nm_restrict_bands()as function pl_pei_config() is no 
   more avalilable in g23m.


   Oct 30 2006, OMAPS00098881 x0039928(sumanth)
   Removal of power variant
      
   Sep 18,2006    DRT: OMAPS0090268 x0061088(Prachi)
   Description : To check for Forbidden network (for denied services),it takes long time.
   Solution : Function rAT_PercentCREG() has now be implemented to handle CREG_STAT_Denied,
   which sends nm_signal(NETWORK_FORBIDDEN_NETWORK) to Bmi .   

   June 02, 2006    DR: OMAPS00078005 x0021334
   Descripton: Test for NITZ (Network Identity and Timezone) support - No New time was displayed
   Solution: New Time/Date received from network is sent to MFW by lower layer by invoking 'rAT_PercentCTZV'
   function. This function has now been implemented to pass on the received values to MMI
   for user confirmation and RTC updation.   

	Jun 23, 2006    DR: OMAPS00082374 x0pleela
   	Description: EONS Failures - unexpected output from the MMI: 2 carriers; on the top always T-Mobile 
   	Solution:	a) Removed the usage of globals gEons_alloc_active and opn_sel_done
			b) Removed the check if( plmn_ident->opn_read_from EQ NM_EONS ) in function nm_update_plmn_data
			c) Updating the long name and short name lengths in function nm_update_plmn_data
			d) Removed the code where plmn_ident was updated with new MNC and MCC after qat_%COPN in function nm_update_plmn_data
			e) Updated function nm_get_opername() by calling only sat_%CNIV()
			f) Removed the function definitions of set_opn_sel_done and get_opn_sel_done
   	
    May 15, 2006   OMAPS00075777  a0393213 (R.Prabakar)
    Description :  It is supposed that the sample register itself automatically (in Manual Mode) 
                   to the last manual selected HPLMN cell before the power cycle, and this does not happen; 
                   instead this, the sample shows up the available networks list
    Fix         :  call to nm_avail_plmn_list() is changed to call to sAT_PercentNRG() 

	Feb 15, 2006    ER: OMAPS00065203 x0pleela
   	Description: Cingular Operator Name Prioritization implementation required
   	Solution: Incorporated review comments
   			- Changed from NEQ NM_CPHS to EQ NM_ROM as we know %CNIV will 
   				be called only if source id is ROM or CPHS and not roaming in nm_get_opername()
   			- set_opn_sel_done(): sets opn_sel_done flag to TRUE or FALSE. 
   			- get_opn_sel_done(): returns the current value of flag opn_sel_done.

	Feb 09, 2006    ER: OMAPS00065203 x0pleela
   	Description: Cingular Operator Name Prioritization implementation required
   	Solution: Handling E_NM_OPN for operator name display
			Query for COPN in rAT_PlusCREG and update plmn data
			Defined following new functions:
				nm_decodeSourceId:to convert the source id used by ACI to the source id used by MFW
				nm_update_plmn_data: update plmn data after querying COPN
				nm_get_COPN: query COPN
				nm_get_opername: updates operator name based on cingular's prioritization requirement. 
							 Priority would be in order ONS->NITZ->ROM
				nm_get_network_data: gets operator name from network

	Nov 24, 2005 DR: OMAPS00045909 - Shashi Shekar B.S.
	Description: Improve IMEI control mechanism
	Solution : When MMI calls sAT_PLUSCFUN, if an IMEI invalid error is returned,
		we will block on that screen & will not allow the user to browse menus further,
		since the PS will not be booted at all!!!

	July 14, 2005  REF: CRR 31916  x0021334
    	Description: rCI_PercentCOPS() and rAT_PercentCOPS() is not implemented
    	Solution: rAT_PercentCOPS() is implemented. 

	Mar 01, 2005    REF: ENH 29327   xdeepadh
	Bug:Locosto MMI Optimization
	Fix:The changes done for the Golite optimization have been utilised for color build.
	This is done by removing the functions under #ifndef MMI_LITE.
	The static vaiable T_MFW_PLMN_LIST plmn_list has been made local variable.
	It has been dynamically allocated and deallocated.
	
	Aug 16, 2004    REF: CRR 24293   Deepa M.D
	Bug:Go-lite optimisation dynamic allocation of variable 'plmn_list'
	Fix:The static vaiable T_MFW_PLMN_LIST plmn_list has been made local variable.
	It has been 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                                         $
 
    Sep 23, 2004        REF: CRR 24562  xvilliva
    Bug:	Enable/disable the manual network selection option depending
			on ENS.
    Fix:	If the manual network selection is disabled we check if an 
			error is returned and set the global g_ensErr.


  May 22, 2006   X0047685
  Removed pref_plmn for if not defined FF_2TO1_PS

   
 *
 * *****************  Version 39  *****************
 * User: Es           Date: 2.03.00    Time: 16:31
 * Updated in $/GSM/Condat/MS/SRC/MFW
 * use 'aci_delete()' to clear the primitive routing for mfw_nm.
 *
 * *****************  Version 38  *****************
 * User: Vo           Date: 16.02.00   Time: 14:22
 * Updated in $/GSM/Condat/MS/SRC/MFW
 *
 * *****************  Version 37  *****************
 * User: Vo           Date: 11.02.00   Time: 12:57
 * Updated in $/GSM/Condat/MS/SRC/MFW
 * Bug fix: limited service
 *
 * *****************  Version 36  *****************
 * User: Vo           Date: 11.02.00   Time: 11:01
 * Updated in $/GSM/Condat/MS/SRC/MFW
 * add limited service indication
 *
 * *****************  Version 35  *****************
 * User: Vo           Date: 28.01.00   Time: 12:48
 * Updated in $/GSM/Condat/MS/SRC/MFW
 * Limited service
 *
 * *****************  Version 34  *****************
 * User: Vo           Date: 20.01.00   Time: 13:17
 * Updated in $/GSM/Condat/MS/SRC/MFW
 * Add new methodes to save preferred PLMN entry (change interface
 * function nm_change_pref_plmn())
 *
 * *****************  Version 33  *****************
 * User: Vo           Date: 22.12.99   Time: 15:59
 * Updated in $/GSM/Condat/MS/SRC/MFW
 * New: Request of preferred PLMN memory of SIM card
 *
 * *****************  Version 32  *****************
 * User: Vo           Date: 3.12.99    Time: 12:16
 * Updated in $/GSM/Condat/MS/SRC/MFW
 * remove the request of maximum/used preferred PLMN list
 *
 * *****************  Version 31  *****************
 * User: Vo           Date: 2.12.99    Time: 13:28
 * Updated in $/GSM/Condat/MS/SRC/MFW
 *
 * *****************  Version 30  *****************
 * User: Vo           Date: 2.12.99    Time: 13:25
 * Updated in $/GSM/Condat/MS/SRC/MFW
 * New: request of max/used perferred PLMN list
 *
 * *****************  Version 29  *****************
 * User: Vo           Date: 21.10.99   Time: 13:24
 * Updated in $/GSM/Condat/MS/SRC/MFW
 * changed of read/change perferred PLMN list
 * add event for successful de-registration
|
| *****************  Version 28  *****************
| User: Le           Date: 8.10.99    Time: 13:38
| Updated in $/GSM/Condat/MS/SRC/MFW
 *
 * *****************  Version 27  *****************
 * User: Es           Date: 16.09.99   Time: 16:56
 * Updated in $/GSM/DEV/MS/SRC/MFW
 * reordered include statements due to addons in mfw_phb.h
 *
 * *****************  Version 26  *****************
 * User: Vo           Date: 13.09.99   Time: 11:39
 * Updated in $/GSM/DEV/MS/SRC/MFW
 * Bug fix: registration with numeric network format
 *
 * *****************  Version 25  *****************
 * User: Vo           Date: 30.08.99   Time: 14:03
 * Updated in $/GSM/DEV/MS/SRC/MFW
 * bug fix
 * new function
 *
 * *****************  Version 24  *****************
 * User: Vo           Date: 2.07.99    Time: 18:16
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 23  *****************
 * User: Vo           Date: 20.05.99   Time: 17:39
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 22  *****************
 * User: Vo           Date: 28.04.99   Time: 16:11
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 21  *****************
 * User: Vo           Date: 31.03.99   Time: 14:09
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 20  *****************
 * User: Es           Date: 15.03.99   Time: 18:21
 * Updated in $/GSM/DEV/MS/SRC/MFW
 * recode
 *
 * *****************  Version 19  *****************
 * User: Vo           Date: 17.02.99   Time: 19:03
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 18  *****************
 * User: Vo           Date: 12.02.99   Time: 18:59
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 17  *****************
 * User: Vo           Date: 9.02.99    Time: 14:54
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 16  *****************
 * User: Vo           Date: 12.01.99   Time: 14:55
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 15  *****************
 * User: Es           Date: 23.12.98   Time: 15:47
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 14  *****************
 * User: Es           Date: 18.12.98   Time: 13:04
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 13  *****************
 * User: Es           Date: 8.12.98    Time: 16:53
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 11  *****************
 * User: Vo           Date: 1.12.98    Time: 15:43
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 10  *****************
 * User: Vo           Date: 30.11.98   Time: 17:49
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 9  *****************
 * User: Vo           Date: 24.11.98   Time: 21:40
 * Updated in $/GSM/DEV/MS/SRC/MFW
 * first successful compilation of MFW
 *
 * *****************  Version 8  *****************
 * User: Vo           Date: 13.11.98   Time: 16:21
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 7  *****************
 * User: Es           Date: 12.11.98   Time: 13:50
 * Updated in $/GSM/DEV/MS/SRC/MFW
|
| *****************  Version 6  *****************
| User: Le           Date: 11.11.98   Time: 13:35
| Updated in $/GSM/DEV/MS/SRC/MFW
|
| *****************  Version 5  *****************
| User: Le           Date: 10.11.98   Time: 16:07
| Updated in $/GSM/DEV/MS/SRC/MFW
|
| *****************  Version 4  *****************
| User: Le           Date: 10.11.98   Time: 11:08
| Updated in $/GSM/DEV/MS/SRC/MFW
|
| *****************  Version 3  *****************
| User: Le           Date: 27.10.98   Time: 15:59
| Updated in $/GSM/DEV/MS/SRC/MFW
|
| *****************  Version 2  *****************
| User: Le           Date: 21.10.98   Time: 16:20
| Updated in $/GSM/DEV/MS/SRC/MFW
|
| *****************  Version 1  *****************
| User: Le           Date: 21.10.98   Time: 10:33
| 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 "pei.h"
#include "custom.h"
#include "gsm.h"

#else

#include "STDDEFS.H"
#include "custom.h"
#include "gsm.h"
#include "vsi.h"

#endif

#include "prim.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_acie.h"
#include "mfw_phb.h"
#include "mfw_cm.h"
#include "mfw_sms.h"
#include "mfw_win.h"

// June 02, 2006    DR: OMAPS00078005 x0021334
#ifdef FF_TIMEZONE
#include "mfw_td.h"
#endif

#include "ksd.h"
#include "psa.h"

#include "mfw_ss.h"
#include "mfw_ssi.h"

#if defined (FAX_AND_DATA)
#include "aci_fd.h"
#endif

#include "mfw_ffs.h"

#include "message.h"
#include "prim.h"
#include "aci_cmh.h"	//GW 22-11-01 - Added

#ifdef SIM_TOOLKIT
#include "mfw_sat.h"
#endif

#ifndef NEPTUNE_BOARD

#ifdef TI_PS_OP_OPN_TAB_ROMBASED
/* Changes for ROM data */ 
/* Operator List size in ROM. Should go to where the decompression algo is present*/
#define PLMN_OPER_LST_SIZE_ROM 628
/* Changes for ROM data 
extern const T_OPER_NTRY_FIXED operListFixed[]; 
 Side access into cus_aci.h 
 Above decl no more required */
EXTERN const UBYTE *ptr_plmn_compressed;
EXTERN SHORT cmhMM_decodePlmn (T_OPER_ENTRY *oper, const UBYTE *plmn_comp_entry);
EXTERN USHORT cmhMM_PlmnEntryLength (const UBYTE *plmn_comp_entry);
#else
extern const T_OPER_NTRY_FIXED operListFixed[]; /* Side access into cus_aci.h */
#endif

#else
extern const T_OPER_NTRY operList[];
#endif
EXTERN MfwHdr * current_mfw_elem;

U8 mfw_IMSI [LONG_NAME];            /* expanded IMSI (ASCIIZ)              */

static U8 last_selected_mode = NOT_PRESENT_8BIT;
static U8 reg_stat;
static U8 reg_flag;
#ifdef NO_ASCIIZ
static T_MFW_SP_NAME service_provider_name;
#else
static U8 service_provider_name [LONG_NAME];
#endif
static U8 display_condition;
static T_MFW_PREF_PLMN_LIST pplmn_list;
static T_MFW_NET_IND net_ind;
static T_MFW_TIME_IND tim_ind;
static UBYTE mfwPplmnReq;
static BOOL   sat_update = FALSE;
//    Sep 23, 2004        REF: CRR 24562  xvilliva
int g_ensErr = 0;

/*SPR#2122 - DS - Commented out. Now operator list is dynamically allocated in nm_avail_plmn_list()
  *static T_ACI_COPS_OPDESC oper_list [MAX_OPER];
  */

static int nmCommand (U32 cmd, void *h); /* handle window commands  */
static void nm_search_reg_status(void);

U8 pplmnCnt;
U8 pplmnCmd;

static int pSlot;                       /* primitive handler slot   */

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_init            |
+--------------------------------------------------------------------+

  PURPOSE : Initialize network manager

*/
int nm_init (void)
{

    TRACE_FUNCTION("nm_init()");

    if (last_selected_mode == NOT_PRESENT_8BIT)
    {
            last_selected_mode = FFS_flashData.PLMN_selection_mode;
    }
                                        /* install prim handler     */
    pSlot = aci_create(nma_response_cb,NULL);

    reg_flag = 0;
    mfwPplmnReq = 0;
    reg_stat = NOT_PRESENT_8BIT;
    sat_update  = FALSE;
    mfwCommand[MfwTypNm] = (MfwCb) nmCommand;

    return last_selected_mode;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_exit            |
+--------------------------------------------------------------------+

  PURPOSE : Finalize network manager

*/

void nm_exit (void)
{
                                        /* remove prim handler      */
    aci_delete(pSlot);
    last_selected_mode = NOT_PRESENT_8BIT;
    reg_stat = NOT_PRESENT_8BIT;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_create          |
+--------------------------------------------------------------------+

  PURPOSE : Create network manager

*/

MfwHnd nm_create (MfwHnd hWin, MfwEvt event, MfwCb cbfunc)
{
    MfwHdr *hdr;
    T_MFW_NM *nm_para;
	MfwHdr *insert_status =0;
	
    TRACE_FUNCTION("nm_create()");

    hdr = (MfwHdr *) mfwAlloc(sizeof(MfwHdr));
    nm_para = (T_MFW_NM *) mfwAlloc(sizeof(T_MFW_NM));

    if (!hdr || !nm_para)
    {
    	TRACE_ERROR("ERROR: nm_create() Mem Alloc Failed.");
			
	   	if(hdr)
   			mfwFree((U8*)hdr,sizeof(MfwHdr));
   		if(nm_para)
   			mfwFree((U8*)nm_para,sizeof(T_MFW_NM));	
   		
	   	return FALSE;
  	}

    nm_para->emask = event;
    nm_para->handler = cbfunc;

    hdr->data = nm_para;                /* store parameter in node  */
    hdr->type = MfwTypNm;               /* type of event handler    */

    insert_status = mfwInsert((MfwHdr *) hWin,hdr);
    if(!insert_status)
	{
  		TRACE_ERROR("ERROR: nm_create() Failed to Install Handler. ");
   		mfwFree((U8*)hdr,sizeof(MfwHdr));
   		mfwFree((U8*)nm_para ,sizeof(T_MFW_NM));
		return 0;
  	}
    return insert_status;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_delete          |
+--------------------------------------------------------------------+

  PURPOSE : delete network manager

*/

MfwRes nm_delete (MfwHnd h)
{
    TRACE_FUNCTION("nm_delete()");

    if (!h || !((MfwHdr *) h)->data)
        return MfwResIllHnd;

    if (!mfwRemove((MfwHdr *) h))
        return MfwResIllHnd;

    mfwFree(((MfwHdr *) h)->data,sizeof(T_MFW_NM));
    mfwFree(h,sizeof(MfwHdr));

    return MfwResOk;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_sign_exec       |
+--------------------------------------------------------------------+

  PURPOSE : dispatch network management signal

*/

static int nm_sign_exec (MfwHdr *cur_elem, MfwEvt event,
                                        T_MFW_NM_PARA * para)
{
    TRACE_FUNCTION("nm_sign_exec()");

    while (cur_elem)
    {
        if (cur_elem->type == MfwTypNm)
        {
            T_MFW_NM *nm_data;

            nm_data = (T_MFW_NM *) cur_elem->data;
            if (nm_data->emask & event)
            {
                nm_data->event = event;
                switch (event)
                {
                    case E_NM_FULL_SERVICE:
		//x0pleela 9 Feb, 2006  ER:OMAPS00065203
		//Handling E_NM_OPN for operator name display
                    case E_NM_OPN:
                        memcpy(&nm_data->para.ident,para,
                                    sizeof(T_MFW_NETWORK_STRUCT));
                        break;
                    case E_NM_PLMN_LIST:
                        memcpy(&nm_data->para.plmns,para,
                                    sizeof(T_MFW_PLMN_LIST));
                        break;
                    case E_NM_PREF_PLMN_LIST:
                        memcpy(&nm_data->para.pplmns,para,
                                    sizeof(T_MFW_PREF_PLMN_LIST));
                        break;
                    case E_NM_PPLMN_MEM:
                        memcpy(&nm_data->para.pplmn_mem,para,
                                    sizeof(T_MFW_PPLMN_MEM));
                        break;
                    case E_NM_CELL_SELECT:
                    	memcpy(&nm_data->para.cell_info,para,
                                    sizeof(T_MFW_CELL_STRUCT));
                    	break;
                    case E_MFW_NET_IND:
                        memcpy(&nm_data->para.net_info,para,
                                    sizeof(T_MFW_NET_IND));
                        break;
                    case E_MFW_TIME_IND:
                        memcpy(&nm_data->para.tim_info,para,
                                    sizeof(T_MFW_TIME_IND));
                        break;
                 }
                if (nm_data->handler)
                {
                  // PATCH LE 06.06.00
                  // store current mfw elem
                  current_mfw_elem = cur_elem;
                  // END PATCH LE 06.06.00
                  if ((*(nm_data->handler)) (nm_data->event,
                                            (void *) &nm_data->para))
                    return TRUE;
                }
            }
        }
        cur_elem = cur_elem->next;
    }

    return FALSE;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_signal          |
+--------------------------------------------------------------------+

  PURPOSE : Send a signal

*/

static void nm_signal (MfwEvt event, void *para)
{
  UBYTE temp=0;
    TRACE_FUNCTION("nm_signal()");

#ifndef FF_POWER_MANAGEMENT
  temp = dspl_Enable(0);
#else
  /*OMAPS00098881 (removing power variant) a0393213(Prabakar)
  display is enabled only when lcd refresh is needed*/
  if(FFS_flashData.refresh == 1)
	temp = dspl_Enable(0);
#endif
  if (mfwSignallingMethod EQ 0)
  {
    if (mfwFocus)
        if (nm_sign_exec(mfwFocus,event,para))
    {
	#ifndef FF_POWER_MANAGEMENT
		dspl_Enable(temp);            
	#else
	       /*OMAPS00098881 (removing power variant) a0393213(Prabakar)
               display is enabled only when lcd refresh is needed*/
	      if(FFS_flashData.refresh == 1)
			dspl_Enable(temp);
	#endif
      return;
    }
    if (mfwRoot)
        nm_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 (nm_sign_exec (h, event, para))
    {
	#ifndef FF_POWER_MANAGEMENT
		dspl_Enable(temp);            
	#else
	       /*OMAPS00098881 (removing power variant) a0393213(Prabakar)
               display is enabled only when lcd refresh is needed*/
	      if(FFS_flashData.refresh == 1)
			dspl_Enable(temp);
	#endif
      return;
    }

        /*
         * All windows tried inclusive root
         */
        if (h == mfwRoot)
    {
	#ifndef FF_POWER_MANAGEMENT
		dspl_Enable(temp);            
	#else
	       /*OMAPS00098881 (removing power variant) a0393213(Prabakar)
               display is enabled only when lcd refresh is needed*/
	      if(FFS_flashData.refresh == 1)
			dspl_Enable(temp);
	#endif
      return;
    }

        /*
         * get parent window
         */
        h = mfwParent(mfwParent(h));
    if(h)
      h = ((MfwWin * )(h->data))->elems;
      }
      nm_sign_exec (mfwRoot, event, para);
    }
   #ifndef FF_POWER_MANAGEMENT
   	dspl_Enable(temp);            
   #else
          /*OMAPS00098881 (removing power variant) a0393213(Prabakar)
              display is enabled only when lcd refresh is needed*/
         if(FFS_flashData.refresh == 1)
   		dspl_Enable(temp);
   #endif
}



/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_set_mode        |
+--------------------------------------------------------------------+

  PURPOSE : Change registration mode

*/

void nm_set_mode (U8 mode)
{

    TRACE_FUNCTION("nm_set_mode()");

    if (mode != NM_AUTOMATIC && mode != NM_MANUAL)
        return;

    if (mode != last_selected_mode)
    {
        last_selected_mode = mode;
        {
            FFS_flashData.PLMN_selection_mode = mode;
            flash_write();
        }
    }
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_get_mode        |
+--------------------------------------------------------------------+

  PURPOSE : Get registration mode

*/

T_MFW nm_get_mode ()
{
    return last_selected_mode;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_activate        |
+--------------------------------------------------------------------+

  PURPOSE : Notify about SIM card activation

*/

void nm_activate (U8 result)
{
  //TRACE_FUNCTION("nm_activate()");

}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_reg_flag_req    |
+--------------------------------------------------------------------+

  PURPOSE : Notify about SIM card activation

*/

T_MFW nm_reg_flag_req()
{
  return reg_flag;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_mmi_parameters  |
+--------------------------------------------------------------------+

  PURPOSE : Notify about relevant parameters

*/

#ifdef FF_2TO1_PS
void nm_mmi_parameters (T_SIM_imsi_field *imsi, T_SIM_pref_plmn *plmn)
{
    void simDecodeIMSI (U8 *ci, U8 li, U8 *di);

    TRACE_FUNCTION("nm_mmi_parameters()");

    simDecodeIMSI(imsi->field,imsi->c_field,mfw_IMSI);
}
#else
void nm_mmi_parameters (T_imsi_field *imsi)
{
    void simDecodeIMSI (U8 *ci, U8 li, U8 *di);

    TRACE_FUNCTION("nm_mmi_parameters()");

    simDecodeIMSI(imsi->field,imsi->c_field,mfw_IMSI);
}
#endif


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_pref_plmn_list  |
+--------------------------------------------------------------------+

  PURPOSE : Request preferred PLMN list

*/

void nm_pref_plmn_list(T_MFW_NETWORK_STRUCT *pplmn, UBYTE count, SHORT start)
{
  SHORT lastIdx;
  T_ACI_CPOL_OPDESC operLst[MAX_OPER];
  T_ACI_RETURN res;
  UBYTE i, j;

  TRACE_FUNCTION("nm_pref_plmn_list()");

  pplmn_list.count = 0;
  pplmn_list.plmn = pplmn;
  pplmnCnt = count;

  j = 0;
  while (1)
  {
    res = qAT_PlusCPOL(CMD_SRC_LCL,
                       start,
                       &lastIdx,
                       operLst,
                       CPOL_MOD_CompactList);
    if (res == AT_EXCT)
      return;

    if (res == AT_CMPL)
    {
      for (i=0; i<MAX_OPER; i++)
      {
        if (operLst[i].index == -1 OR pplmn_list.count >= pplmnCnt)
          break;

        pplmn_list.plmn[j].index = operLst[i].index;
#ifdef NO_ASCIIZ
        sAT_PlusCOPSE((UBYTE *)operLst[i].oper,
                      (UBYTE)operLst[i].format,
                      &pplmn_list.plmn[j].network_long,
                      &pplmn_list.plmn[j].network_short,
                      pplmn_list.plmn[j].network_numeric);
#else
        sAT_PlusCOPSE((UBYTE *)operLst[i].oper,
                      (UBYTE)operLst[i].format,
                      pplmn_list.plmn[j].network_long,
                      pplmn_list.plmn[j].network_short,
                      pplmn_list.plmn[j].network_numeric);
#endif
        pplmn_list.count++;
        j++;
      }
      if (i < MAX_OPER OR (j EQ pplmnCnt))
      {
        nm_signal(E_NM_PREF_PLMN_LIST, &pplmn_list);
        return;
      }
      start = lastIdx + 1;
    }
    else
    {
      nm_signal(E_NM_PREF_PLMN_LIST, &pplmn_list);
      return;
    }
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : rAT_PlusCPOL       |
+--------------------------------------------------------------------+

  PURPOSE :  callback of preferred PLMN list

*/

void rAT_PlusCPOL(SHORT startIdx, SHORT lastIdx,
                  T_ACI_CPOL_OPDESC *operLst,
                  SHORT              usdNtry)
{
  UBYTE i, j;
  SHORT endIdx;
  T_MFW_PPLMN_MEM pplmn_mem;

  TRACE_FUNCTION("nm_pref_plmn_list()");

  if (mfwPplmnReq)
  {
    mfwPplmnReq = 0;
    pplmn_mem.maxRcd = (UBYTE)lastIdx;
    pplmn_mem.usedRcd = (UBYTE)usdNtry;
    nm_signal(E_NM_PPLMN_MEM, &pplmn_mem);
    return;
  }

  endIdx = lastIdx;
  j = 0;
  while (1)
  {
    for (i=0; i<MAX_OPER; i++)
    {
      if (operLst[i].index == -1 OR pplmn_list.count >= pplmnCnt)
          break;

        pplmn_list.plmn[j].index = operLst[i].index;
#ifdef NO_ASCIIZ
        sAT_PlusCOPSE((UBYTE *)operLst[i].oper,
                      (UBYTE)operLst[i].format,
                      &pplmn_list.plmn[j].network_long,
                      &pplmn_list.plmn[j].network_short,
                      pplmn_list.plmn[j].network_numeric);
#else
        sAT_PlusCOPSE((UBYTE *)operLst[i].oper,
                      (UBYTE)operLst[i].format,
                      pplmn_list.plmn[j].network_long,
                      pplmn_list.plmn[j].network_short,
                      pplmn_list.plmn[j].network_numeric);
#endif
        pplmn_list.count++;
        j++;
    }
    if ((i<MAX_OPER) OR (j EQ pplmnCnt))
    {
      nm_signal(E_NM_PREF_PLMN_LIST, &pplmn_list);
      return;
    }
    startIdx = endIdx + 1;
    if (qAT_PlusCPOL(CMD_SRC_LCL, startIdx, &endIdx,
                     operLst, CPOL_MOD_CompactList) != AT_CMPL)
    {
      nm_signal(E_NM_PREF_PLMN_LIST, &pplmn_list);
      return;
    }
  }
}


/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)       MODULE  : MFW_NM                |
| STATE   : code                       ROUTINE : nm_change_pref_plmn   |
+----------------------------------------------------------------------+

  PURPOSE : Save/Change/Delete a preferred PLMN

*/

T_MFW_NM_RETURN nm_change_pref_plmn(T_MFW_PPLMN_MODE mode,
                                    SHORT index, SHORT index2,
                                    UBYTE *network_numeric)
{
    SHORT           idx;
    T_ACI_CPOL_FRMT format;
    CHAR          * oper;
    SHORT           idx2;
    T_ACI_CPOL_MOD  md;

    TRACE_FUNCTION("nm_change_pref_plmn()");

    switch (mode)
    {
        case NEW_PREF_PLMN:
            idx = -1;
            idx2 = -1;
            format = CPOL_FRMT_Numeric;
            oper = (CHAR *)network_numeric;
            md = CPOL_MOD_CompactList;
            break;
        case REPLACE_PREF_PLMN:
            idx = index;
            idx2 = -1;
            format = CPOL_FRMT_Numeric;
            oper = (CHAR *)network_numeric;
            md = CPOL_MOD_CompactList;
            break;
        case DELETE_PREF_PLMN:
            idx = index;
            idx2 = -1;
            format = CPOL_FRMT_NotPresent;
            oper = NULL;
            md = CPOL_MOD_CompactList;
            break;
        case INSERT_PREF_PLMN:
            idx = index;
            idx2 = -1;
            format = CPOL_FRMT_Numeric;
            oper = (CHAR *)network_numeric;
            md = CPOL_MOD_Insert;
            break;
        case CHANGE_PREF_PLMN:
            idx = index;
            idx2 = index2;
            format = CPOL_FRMT_Numeric;
            oper = (CHAR *)network_numeric;
            md = CPOL_MOD_CompactList;
            break;
        default:
            return NM_ERR;
    }

    if (sAT_PlusCPOL(CMD_SRC_LCL, idx, format,
                     oper, idx2, md) != AT_EXCT)
        return NM_ERR;
    pplmnCmd = CHANGE_PREF_PLMN;
    return NM_OK;
}


/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)       MODULE  : MFW_NM                |
| STATE   : code                       ROUTINE : nm_change_pref_plmn_longname   |
+----------------------------------------------------------------------+

  PURPOSE : Change a preferred PLMN using longname. added for SPR 2635.

*/

T_MFW_NM_RETURN nm_change_pref_plmn_longname(T_MFW_PPLMN_MODE mode,
                                    SHORT index, SHORT index2,
                                    char *network_long)
{
    SHORT           idx;
    T_ACI_CPOL_FRMT format;
    CHAR          * oper;
    SHORT           idx2;
    T_ACI_CPOL_MOD  md;

    TRACE_FUNCTION("nm_change_pref_plmn()");

    switch (mode)
    {
     
        case REPLACE_PREF_PLMN:
            idx = index;
            idx2 = -1;
            format = CPOL_FRMT_Long;
            oper = (CHAR *)network_long;
            md = CPOL_MOD_CompactList;
            break;

        default:
            return NM_ERR;
    }

    if (sAT_PlusCPOL(CMD_SRC_LCL, idx, format,
                     oper, idx2, md) != AT_EXCT)
        return NM_ERR;
    pplmnCmd = CHANGE_PREF_PLMN;
    return NM_OK;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_ok_pref_plmn    |
+--------------------------------------------------------------------+


  PURPOSE : The change of preferred PLMN is successful.

*/

void nm_ok_pref_plmn(void)
{
    TRACE_FUNCTION("nm_ok_pref_plmn()");

    if (pplmnCmd == CHANGE_PREF_PLMN)
    {
        pplmnCmd = CMD_NOT_PRESENT;
        nm_signal(E_NM_CHANGE_PPLMN_OK, 0);
    }
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_error_pref_plmn |
+--------------------------------------------------------------------+


  PURPOSE : The change of preferred PLMN is failed.

*/

void nm_error_pref_plmn(void)
{
    TRACE_FUNCTION("nm_error_pref_plmn()");

    if (pplmnCmd == CHANGE_PREF_PLMN)
    {
        pplmnCmd = CMD_NOT_PRESENT;
        nm_signal(E_NM_CHANGE_PPLMN_ERR, 0);
        return;
    }
    if (mfwPplmnReq)
      mfwPplmnReq = 0;
    pplmn_list.count = 0;
    nm_signal(E_NM_PREF_PLMN_LIST, &pplmn_list);
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_copy_plmn_list  |
+--------------------------------------------------------------------+


  PURPOSE : Write the PLMN information in PLMN list

*/

void nm_copy_plmn_list (T_MFW_NETWORK_STRUCT *plmn, T_ACI_COPS_OPDESC *operLst)
{
    U8 *forbidden_id;
    U8 *fieldstrength;

    TRACE_FUNCTION("nm_copy_plmn_list()");
#ifdef NO_ASCIIZ
    plmn->network_long.len = 0;
    plmn->network_short.len = 0;
    memset(plmn->network_numeric, 0, NUMERIC_LENGTH);

    if (operLst->longOper)
    {
 	  USHORT length=strlen((const char *)operLst->longOper);
        plmn->network_long.len = MINIMUM(LONG_NAME-1, length);        
        memcpy (plmn->network_long.data, operLst->longOper, plmn->network_long.len);
        plmn->network_long.data[plmn->network_long.len] = '\0';
        plmn->network_long.dcs = MFW_ASCII;
    }

    if (operLst->shortOper)
    {
     	  USHORT length=strlen((const char *)operLst->shortOper);
        plmn->network_short.len = MINIMUM(SHORT_NAME-1, length);            
        memcpy (plmn->network_short.data, operLst->shortOper, plmn->network_short.len);
        plmn->network_short.data[plmn->network_short.len] = '\0';
        plmn->network_short.dcs = MFW_ASCII;
    }
#else
    memset(plmn->network_long, 0, LONG_NAME);
    memset(plmn->network_short, 0, SHORT_NAME);
    memset(plmn->network_numeric, 0, NUMERIC_LENGTH);

    if (operLst->longOper)
        strncpy((char *)plmn->network_long, (char *)operLst->longOper, LONG_NAME-1);

    if (operLst->shortOper)
        strncpy((char *)plmn->network_short, (char *)operLst->shortOper, SHORT_NAME-1);
#endif
    if (operLst->numOper)
        strncpy((char *)plmn->network_numeric, (char *)operLst->numOper, NUMERIC_LENGTH-1);

    if (operLst->status == COPS_STAT_Available
        || operLst->status == COPS_STAT_Current)
        plmn->forbidden_indicator = MFW_PLMN_AVAILABLE;
    else
        plmn->forbidden_indicator = MFW_PLMN_FORBIDDEN;

    if (!strncmp((char *) mfw_IMSI,(char *) plmn->network_numeric,5))
        plmn->roaming_indicator = 0;
    else
        plmn->roaming_indicator = 1;

    sAT_PlusCOPSF(&forbidden_id,&fieldstrength);
    plmn->fieldstrength = fieldstrength;
}


/*
+---------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM              |
| STATE   : code                        ROUTINE : nm_pplmn_mem_req    |
+---------------------------------------------------------------------+

  PURPOSE : Request the maximum number of preferred PLMN records
            in SIM card

*/

T_MFW_NM_RETURN nm_pplmn_mem_req(void)
{
  T_ACI_RETURN res;
  SHORT maxRcd, usedRcd;
  T_MFW_PPLMN_MEM pplmn_mem;

  TRACE_FUNCTION("nm_pplmn_mem_req()");

  res = tAT_PlusCPOL(CMD_SRC_LCL, &maxRcd, &usedRcd);
  if (res == AT_EXCT)
  {
    mfwPplmnReq = 1;
    return NM_OK;
  }
  if (res == AT_CMPL)
  {
    pplmn_mem.maxRcd = (UBYTE)maxRcd;
    pplmn_mem.usedRcd = (UBYTE)usedRcd;
    nm_signal(E_NM_PPLMN_MEM, &pplmn_mem);
    return NM_OK;
  }

  return NM_ERR;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_registration    |
+--------------------------------------------------------------------+

  PURPOSE : Start registration

*/

T_MFW nm_registration (U8 mode, U8 freq_bands, U8 limited)
{
    U8 sim_stat;

    TRACE_FUNCTION("nm_registration()");

    sAT_Abort(CMD_SRC_LCL, AT_CMD_NRG);

    sim_stat = sim_status_check();
    reg_flag = 1;

    if (limited)
    {
        if (sAT_PercentNRG(CMD_SRC_LCL,
                           NRG_RGMD_Auto,
                           NRG_SVMD_Limited,
                           NRG_FRMT_Numeric,
                           NULL) != AT_EXCT)
            TRACE_EVENT("Limited Service error: SAT_PercentNRG");
        return sim_stat;
    }

// Nov 24, 2005, a0876501, DR: OMAPS00045909
    if (!limited && sim_stat == IMEI_NOT_VALID)
      return IMEI_NOT_VALID;

    if (!limited && sim_stat != SIM_ACTIVE)
      return SIM_NOT_ACTIVE;


    if (mode == NM_MANUAL)
    {
 /*  
 Apr 13, 2004	REF: CRR 16303	JuanVi Jativa-Villoldo      
  sim_spn_req();     Moved to the function  rAT_PlusCFUNP           
*/
        /* May 15, 2006,  a0393213 (R.Prabakar),  OMAPS00075777  
           Description :  It is supposed that the sample register itself automatically (in Manual Mode) 
                          to the last manual selected HPLMN cell before the power cycle, and this does not happen; 
                          instead this, the sample shows up the available networks list
           Fix         :  call to nm_avail_plmn_list() is changed to call to sAT_PercentNRG() */        
     	if (sAT_PercentNRG(CMD_SRC_LCL,
                           NRG_RGMD_Manual,
                           NRG_SVMD_Full,
                           NRG_FRMT_Numeric,
                           NULL) != AT_EXCT)
        {
            TRACE_ERROR("sAT_PercentNRG error");
        }
    }
    else
    {
    	if (sAT_PercentNRG(CMD_SRC_LCL,
                           NRG_RGMD_Auto,
                           NRG_SVMD_Full,
                           NRG_FRMT_Numeric,
                           NULL) != AT_EXCT)
        {
            TRACE_ERROR("sAT_PercentNRG error");
        }
 /*  
 Apr 13, 2004	REF: CRR 16303	JuanVi Jativa-Villoldo      
  sim_spn_req();     Moved to the function  rAT_PlusCFUNP           
*/   }
    return SIM_ACTIVE;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_avail_plmn_list |
+--------------------------------------------------------------------+

  PURPOSE : Request the available PLMN list

  SPR#2122 - DS - Restructured to make oper_list dynamically allocated
*/



void nm_avail_plmn_list ()
{
    T_ACI_RETURN result;
    int i;
    SHORT last_ind = 0;
    T_ACI_COPS_OPDESC* oper_list = NULL;
	//Mar 01, 2005    REF: ENH 29327   xdeepadh
	//Dynamically allocate the plmn_list.
    T_MFW_PLMN_LIST* plmn_list;
	plmn_list = (T_MFW_PLMN_LIST*)mfwAlloc(sizeof(T_MFW_PLMN_LIST));
	if(plmn_list == NULL)
	{
		TRACE_EVENT("plmn_list malloc failed");
		return ;
	}	

    TRACE_FUNCTION("nm_avail_plmn_list()");

    /* Dynamically allocate operator list buffer */
    oper_list = (T_ACI_COPS_OPDESC*)mfwAlloc(sizeof(T_ACI_COPS_OPDESC)*MAX_OPER);

    if (oper_list == NULL)
    {
        TRACE_ERROR("ERROR: Failed to allocate oper list buffer");
	//Mar 01, 2005    REF: ENH 29327   xdeepadh
	//Deallocate the plmn_list
	if(plmn_list !=NULL)
	{
		mfwFree((U8*)plmn_list,sizeof(T_MFW_PLMN_LIST));
		plmn_list=NULL;
	}
        return;
    }
	

// PATCH JVU - PLMN selection during registration
    sAT_Abort(CMD_SRC_LCL, AT_CMD_NRG);
// END PATCH JVU - PLMN selection during registration

    plmn_list->count = 0;
    result = tAT_PlusCOPS(CMD_SRC_LCL,0,&last_ind,oper_list);
    if (result == AT_FAIL || result == AT_BUSY)
    {
        TRACE_ERROR("ERROR: tAT_PlusCOPS error");
		 //Sep 23, 2004        REF: CRR 24562  xvilliva
		 //If AT_FAIL is returned, we query for the exact error
		 //and set a variable accordingly. 
		 if(result == AT_FAIL)
		 {
				ULONG err;

				err = qAT_ErrDesc();
				switch (ACI_ERR_DESC_CLASS( err ))
				{
				case ACI_ERR_CLASS_Cme:
						if (ACI_ERR_DESC_NR( err ) == CME_ERR_OpNotAllow)
						{
							g_ensErr = 1;						
						}
					break;
				}
		 }
		
		/* Deallocate operator list buffer */
        if (oper_list != NULL)
        {
            mfwFree((U8*)oper_list, sizeof(T_ACI_COPS_OPDESC)*MAX_OPER);
            oper_list = NULL;
        }
		
        nm_signal(E_NM_PLMN_LIST,plmn_list);
		//Mar 01, 2005    REF: ENH 29327   xdeepadh
		//Deallocate the plmn_list
		if(plmn_list !=NULL)
		{
			mfwFree((U8*)plmn_list,sizeof(T_MFW_PLMN_LIST));
			plmn_list=NULL;
		}
        return;
    }
    if (result == AT_EXCT)
    {
         /* Deallocate operator list buffer */
        if (oper_list != NULL)
        {
            mfwFree((U8*)oper_list, sizeof(T_ACI_COPS_OPDESC)*MAX_OPER);
            oper_list = NULL;
        }
	//Mar 01, 2005    REF: ENH 29327   xdeepadh
	//Deallocate the plmn_list
	if(plmn_list !=NULL)
	{
		mfwFree((U8*)plmn_list,sizeof(T_MFW_PLMN_LIST));
		plmn_list=NULL;
	}
        return;                     /* wait for rAT_PlusCOPS()  */
    }

    if (last_ind > MAX_OPER)
        last_ind = MAX_OPER;

    for (i = 0; i <= last_ind; i++)
        nm_copy_plmn_list(&plmn_list->plmn[i], &oper_list[i]);

    /* Deallocate operator list buffer */
    if (oper_list != NULL)
    {
        mfwFree((U8*)oper_list, sizeof(T_ACI_COPS_OPDESC)*MAX_OPER);
        oper_list = NULL;
    }

	plmn_list->count = i;
	nm_signal(E_NM_PLMN_LIST,plmn_list);
	//Mar 01, 2005    REF: ENH 29327   xdeepadh
	//Deallocate the plmn_list
	if(plmn_list !=NULL)
	{
		mfwFree((U8*)plmn_list,sizeof(T_MFW_PLMN_LIST));
		plmn_list=NULL;
	}
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_home_plmn       |
+--------------------------------------------------------------------+

  PURPOSE : Get the home PLMN name

*/

void nm_home_plmn (T_MFW_NETWORK_STRUCT *hplmn)
{
    U8 oper[6];

    /* get network operator */
    strncpy((char *)oper, (char *)mfw_IMSI, 5);
    oper[5] = 0;

#ifdef NO_ASCIIZ
    sAT_PlusCOPSE(oper,
                  COPS_FRMT_Numeric,
                  &hplmn->network_long,
                  &hplmn->network_short,
                  hplmn->network_numeric);

#else
    sAT_PlusCOPSE(oper,
                  COPS_FRMT_Numeric,
                  hplmn->network_long,
                  hplmn->network_short,
                  hplmn->network_numeric);
#endif
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_plmn_list       |
+--------------------------------------------------------------------+

  PURPOSE : Request existing network list
  
*/
#ifndef NEPTUNE_BOARD
#ifdef TI_PS_OP_OPN_TAB_ROMBASED
int nm_plnm_list(T_MFW_NETWORK_STRUCT *plmn_list, int start, int count)
{
    int  i;

    /* Changes for ROM data */ 
    const UBYTE *plmn_comp_entry; /* get a local pointer holder */
    T_OPER_ENTRY oper;


    TRACE_FUNCTION("nm_plnm_list()");

    /* 
    PLMN_OPER_LST_SIZE_ROM is size of the PLMN operlist
    */

    if (start >= PLMN_OPER_LST_SIZE_ROM)
        return 0;


    /* Changes for ROM data */ 
    plmn_comp_entry = ptr_plmn_compressed;


    /* skip the first (start-1) number of plmn entries. */
    i=0;
    while (i < start) {
        plmn_comp_entry += cmhMM_PlmnEntryLength (plmn_comp_entry);
        i+=1;
    }

    /* for each pointer in the list plmn_list */
    i=0;
    do 
    {
        /* Get first compressed PLMN entry */
        cmhMM_decodePlmn (&oper, plmn_comp_entry);

        if (oper.longName NEQ NULL)
        {
             plmn_list[i].index = start+1;
#ifdef NO_ASCIIZ
             sAT_PlusCOPSE((UBYTE *)oper.longName,
                          COPS_FRMT_Long,
                          &plmn_list[i].network_long,
                          &plmn_list[i].network_short,
                          plmn_list[i].network_numeric);
#else
             sAT_PlusCOPSE((UBYTE *)oper.longName,
                          COPS_FRMT_Long,
                          plmn_list[i].network_long,
                          plmn_list[i].network_short,
                          plmn_list[i].network_numeric);
#endif
             start++;
        }
        else
        {
#ifdef NO_ASCIIZ
             plmn_list[i].network_long.len = 0;
             plmn_list[i].network_short.len = 0;
             plmn_list[i].network_numeric[0] = 0;
#else
             plmn_list[i].network_long[0] = 0;
             plmn_list[i].network_short[0] = 0;
             plmn_list[i].network_numeric[0] = 0;
#endif
             break;
        }

        /* Next compressed PLMN entry */
        plmn_comp_entry += cmhMM_PlmnEntryLength (plmn_comp_entry);
    
        i+=1;
    } while (i < count);

    return PLMN_OPER_LST_SIZE_ROM;
}

#else

int nm_plnm_list(T_MFW_NETWORK_STRUCT *plmn_list, int start, int count)
{
    int  i;
    int  sum;

    TRACE_FUNCTION("nm_plnm_list()");
    sum = 0;
    while (operListFixed[sum].longName != NULL)
        sum++;

    if (start >= sum)
        return 0;
    for (i=0; i<count; i++)
    {
        if (operListFixed[start].longName != NULL)
        {
          plmn_list[i].index = start+1;
#ifdef NO_ASCIIZ
          sAT_PlusCOPSE((UBYTE *)operListFixed[start].longName,
                          COPS_FRMT_Long,
                          &plmn_list[i].network_long,
                          &plmn_list[i].network_short,
                          plmn_list[i].network_numeric);
#else
           sAT_PlusCOPSE((UBYTE *)operListFixed[start].longName,
                          COPS_FRMT_Long,
                          plmn_list[i].network_long,
                          plmn_list[i].network_short,
                          plmn_list[i].network_numeric);
#endif
            start++;
        }
        else
        {
#ifdef NO_ASCIIZ
            plmn_list[i].network_long.len = 0;
            plmn_list[i].network_short.len = 0;
            plmn_list[i].network_numeric[0] = 0;
#else
            plmn_list[i].network_long[0] = 0;
            plmn_list[i].network_short[0] = 0;
            plmn_list[i].network_numeric[0] = 0;
#endif
            break;
        }
    }
    return sum;
}

#endif

#else
int nm_plnm_list(T_MFW_NETWORK_STRUCT *plmn_list, int start, int count)
{
    int  i;
    int  sum;

    TRACE_FUNCTION("nm_plnm_list()");
    sum = 0;
    while (operList[sum].longName != NULL)
        sum++;

    if (start >= sum)
        return 0;

    for (i=0; i<count; i++)
    {
        if (operList[start].longName != NULL)
        {
          plmn_list[i].index = start+1;
#ifdef NO_ASCIIZ
          sAT_PlusCOPSE((UBYTE *)operList[start].longName,
                          COPS_FRMT_Long,
                          &plmn_list[i].network_long,
                          &plmn_list[i].network_short,
                          plmn_list[i].network_numeric);
#else
           sAT_PlusCOPSE((UBYTE *)operList[start].longName,
                          COPS_FRMT_Long,
                          plmn_list[i].network_long,
                          plmn_list[i].network_short,
                          plmn_list[i].network_numeric);
#endif
            start++;
        }
        else
        {
#ifdef NO_ASCIIZ
            plmn_list[i].network_long.len = 0;
            plmn_list[i].network_short.len = 0;
            plmn_list[i].network_numeric[0] = 0;
#else
            plmn_list[i].network_long[0] = 0;
            plmn_list[i].network_short[0] = 0;
            plmn_list[i].network_numeric[0] = 0;
#endif
            break;
        }
    }
    return sum;
}
#endif
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_plmn_list_longnames       |
+--------------------------------------------------------------------+

  PURPOSE : Request existing network list longnames.  added for SPR 2635.
  
*/

#ifndef NEPTUNE_BOARD
#ifdef TI_PS_OP_OPN_TAB_ROMBASED
int nm_plnm_list_longnames(char**plmn_ln_list, int start, int count)
{
    int  i;
    /* Changes for ROM data */ 
    const UBYTE *plmn_comp_entry; /* get a local pointer holder */
    T_OPER_ENTRY oper;

	
    TRACE_FUNCTION("nm_plnm_list_longnames()");
    
    /* 
    PLMN_OPER_LST_SIZE_ROM is size of the PLMN operlist
    */

    if (start >= PLMN_OPER_LST_SIZE_ROM)
        return 0;

    /* skip the first (start-1) number of plmn entries. */
    i=0;
    while (i < start) {
        plmn_comp_entry += cmhMM_PlmnEntryLength (plmn_comp_entry);
        i+=1;
    }

    /* for each pointer in the list plmn_list */
    i=0;
    do 
    {
        /* Get first compressed PLMN entry */
        cmhMM_decodePlmn (&oper, plmn_comp_entry);

        if (oper.longName NEQ NULL)
        {
             /*just set pointer to point at longname in ROM in ACI*/
             plmn_ln_list[i] = (char*)oper.longName;
		
             start++;
        }
        else
        {
            plmn_ln_list[i] = NULL;
            break;
        }

        /* Next compressed PLMN entry */
        plmn_comp_entry += cmhMM_PlmnEntryLength (plmn_comp_entry);
    
        i+=1;
    } while (i < count);

    return PLMN_OPER_LST_SIZE_ROM;
}

#else

int nm_plnm_list_longnames(char**plmn_ln_list, int start, int count)
{
    int  i;
    int  sum;
	
    TRACE_FUNCTION("nm_plnm_list_longnames()");
    
    sum = 0;

    /*count the number of longnames*/
    while (operListFixed[sum].longName != NULL)
        sum++;
	/*if we attempt read past the end of the list*/
    if (start >= sum)
        return 0;

	/*for each pointer in the list*/
    for (i=0; i<count; i++)
    {
        if (operListFixed[start].longName != NULL)
        {
          	/*just set pointer to point at longname in ROM in ACI*/
            plmn_ln_list[i] = (char*)operListFixed[start].longName;
		
            start++;
        }
        else
        {
			plmn_ln_list[i] = NULL;
            break;
        }
    }
    return sum;
}
#endif

#else
int nm_plnm_list_longnames(char**plmn_ln_list, int start, int count)
{
    int  i;
    int  sum;
	
    TRACE_FUNCTION("nm_plnm_list_longnames()");
    
    sum = 0;

    /*count the number of longnames*/
    while (operList[sum].longName != NULL)
        sum++;
	/*if we attempt read past the end of the list*/
    if (start >= sum)
        return 0;

	/*for each pointer in the list*/
    for (i=0; i<count; i++)
    {
        if (operList[start].longName != NULL)
        {
          	/*just set pointer to point at longname in ROM in ACI*/
			plmn_ln_list[i] = (char*)operList[start].longName;
		
            start++;
        }
        else
        {
			plmn_ln_list[i] = NULL;
            break;
        }
    }
    return sum;
}
#endif

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_select_plmn     |
+--------------------------------------------------------------------+

  PURPOSE : Select PLMN for registration

*/

void nm_select_plmn (U8 *network)
{
    T_ACI_RETURN result;
    TRACE_FUNCTION("nm_select_plmn()");

   result = sAT_PercentNRG(CMD_SRC_LCL,
                       NRG_RGMD_Manual,
                       NRG_SVMD_Full,
                       NRG_FRMT_Numeric,
                       (char *) network);
   result = AT_FAIL;
    if (result != AT_EXCT)
    {
        TRACE_ERROR("sAT_PercentNRG error");
		 //Sep 23, 2004        REF: CRR 24562  xvilliva
		 //If AT_FAIL is returned, we query for the exact error
		 //and set a variable accordingly. 
		 if(result == AT_FAIL)	
		 {
				ULONG err;

				err = qAT_ErrDesc();
				switch (ACI_ERR_DESC_CLASS( err ))
				{
				case ACI_ERR_CLASS_Cme:
						if (ACI_ERR_DESC_NR( err ) == CME_ERR_OpNotAllow)
						{
							g_ensErr = 1;						
						}
					break;
				}
		 }
    }
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_spn_cnf         |
+--------------------------------------------------------------------+

  PURPOSE : Notify about service provider name

*/
/*a0393213 lint warnings removal - type of error changed from SHORT to USHORT*/
void nm_spn_cnf (USHORT error, T_EF_SPN *efspn)
{
    U8 i;

    USHORT simErr;
    TRACE_FUNCTION("nm_spn_cnf()");


#ifdef FF_2TO1_PS
    simErr = CAUSE_SIM_NO_ERROR;
#else
    simErr = SIM_NO_ERROR;
#endif

#ifdef NO_ASCIIZ
    memset (service_provider_name.data, 0, sizeof(service_provider_name.data));
    service_provider_name.len = 0;
    
    if (error EQ simErr)
    {
        for (i=0; (efspn->service_provider[i] != 0xFF) && (i < SP_NAME); i++)
            service_provider_name.data[i] = efspn->service_provider[i];

        service_provider_name.len = i;
    }
#else
    memset (service_provider_name, 0, sizeof(service_provider_name));

    if (error EQ simErr)
    {
        for (i=0; (efspn->service_provider[i] != 0xFF) && (i < SP_NAME-1); i++)
            service_provider_name[i] = efspn->service_provider[i];
    }
#endif
    display_condition = efspn->display_condition & 0x01;

#ifdef SIM_TOOLKIT
  if (sat_update)
  {
    sat_update = FALSE;
    satUpdateFiles ( TRUE, SIM_SPN );
  }
#endif
}

#ifdef SIM_TOOLKIT
/*
+---------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)   MODULE  : MFW_SIM                  |
| STATE   : code                   ROUTINE : nm_sat_file_update       |
+---------------------------------------------------------------------+

  PURPOSE : SIM file change indication

*/

void nm_sat_file_update(USHORT dataId)
{
  /*a0393213 compiler warnings removal - removed serv_stat*/

  TRACE_FUNCTION("nm_sat_file_update()");

  switch (dataId)
  {
    case SIM_SPN:
      if (sim_serv_table_check(17) NEQ NO_ALLOCATED)
      {
        sat_update = TRUE;
        sim_read_sim(SIM_SPN, NOT_PRESENT_8BIT, 17);
      }
      else
        satUpdateFiles ( TRUE, SIM_SPN );
      break;
    default:
      break;
  }
}
#endif


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_deregistration  |
+--------------------------------------------------------------------+

  PURPOSE : Delete registration

*/

void nm_deregistration (void)
{
    TRACE_FUNCTION ("nm_deregistration()");

    if (sAT_PlusCFUN(CMD_SRC_LCL,CFUN_FUN_Minimum,CFUN_RST_NotPresent)
        != AT_EXCT)
    {
        TRACE_ERROR("sAT_PlusCFUN error");
    }
}


/*
+-----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM                |
| STATE   : code                        ROUTINE : nm_ok_deregistration  |
+-----------------------------------------------------------------------+

  PURPOSE : de-registration successful

*/

void nm_ok_deregistration (void)
{
    TRACE_FUNCTION ("nm_ok_deregistration()");
    nm_signal(E_NM_DEREGISTRATION, 0);
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_ok_cops         |
+--------------------------------------------------------------------+

  PURPOSE : Successful end of operator selection

*/

void nm_ok_cops (void)
{
  TRACE_FUNCTION("nm_ok_cops()");

  nm_search_reg_status();
  reg_flag = 0;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_ok_cops         |
+--------------------------------------------------------------------+

  PURPOSE : Successful selection of band
  SPR919 - SH - added this function.
*/

void nm_ok_band (void)
{
  TRACE_FUNCTION("nm_ok_band()");
  
  nm_signal(E_NM_BAND, 0);
}



/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_error_cops      |
+--------------------------------------------------------------------+

  PURPOSE : error end of operator selection

*/
//x0pleela 30 May, 2007  DR: OMAPS00133201
//Passing T_ACI_CME_ERR as parameter
void nm_error_cops ( T_ACI_CME_ERR err)
{
    TRACE_FUNCTION("nm_error_cops()");

    //x0pleela 30 May, 2007  DR: OMAPS00133201
    if( err == CME_ERR_AbortedByNetwork )
	nm_signal(E_NM_ABORT_NETWORK, 0);
    else
    nm_search_reg_status();
    reg_flag = 0;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_reg_status      |
+--------------------------------------------------------------------+

  PURPOSE : Check the registration status

*/

T_MFW nm_reg_status (void)
{
    TRACE_FUNCTION("nm_reg_status()");

    return reg_stat;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : rAT_PlusCOPS       |
+--------------------------------------------------------------------+

  PURPOSE : Notify about available PLMN list
  NOTE    : oper_list defines as char *
            Every operator (PLMN) uses 3 bytes
            
// July 14, 2005  REF: CRR 31916  x0021334
// The functionality in rAT_PlusCOPS has been moved to new function 'nm_Plus_Percent_COPS()'
     which is common for rAT_PercentCOPS as well.
            
//SPR#0777 - DS - Added check to make sure last_ind is valid. If invalid set to 0.
//			       - Changed check to make last_ind equal to MAX_OPER-1 if last_ind is greater than MAX_OPER.
//				- Changed <= to < in nm_copy_plmn_list for loop.

*/

void rAT_PlusCOPS (S16 last_ind, T_ACI_COPS_OPDESC *operLst)
{
	TRACE_FUNCTION ("rAT_PlusCOPS()");

	nm_Plus_Percent_COPS(last_ind, operLst);
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM                                |
| STATE   : code                                     ROUTINE : rAT_PercentCOPS                   |
+--------------------------------------------------------------------+

  PURPOSE : Notify about available PLMN list. Call is made to nm_Plus_Percent_COPS().

// July 14, 2005  REF: CRR 31916  x0021334
// New function 'rAT_PercentCOPS()' implemented.
                  
*/

void rAT_PercentCOPS (S16 last_ind, T_ACI_COPS_OPDESC *operLst)
{
	TRACE_FUNCTION ("rAT_PercentCOPS()");

	nm_Plus_Percent_COPS(last_ind, operLst);
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM                                |
| STATE   : code                                     ROUTINE : nm_Plus_Percent_COPS          |
+--------------------------------------------------------------------+

  PURPOSE : Notify about available PLMN list. Common function called from rAT_PlusCOPS
  		     and rAT_PercentCOPS

// July 14, 2005  REF: CRR 31916  x0021334
// New function 'nm_Plus_Percent_COPS()' implemented.

*/

void nm_Plus_Percent_COPS (S16 last_ind, T_ACI_COPS_OPDESC *operLst)
{
    	int i;
	//Mar 01, 2005    REF: ENH 29327   xdeepadh
	//Dynamically allocate the plmn_list
    	T_MFW_PLMN_LIST *plmn_list;
	/* Aug 09, 2007 REF: OMAPS00140507 x0045876 
	   Added patch given by Dong Feng */	   
	char longName[MAX_ALPHA_OPER_LEN] = { '\0' };
  	char shrtName[MAX_ALPHA_OPER_LEN] = { '\0' };
	plmn_list=(T_MFW_PLMN_LIST*)mfwAlloc(sizeof(T_MFW_PLMN_LIST));
	if(plmn_list==NULL)
	{
		TRACE_EVENT("plmn_list malloc failed");
		return;
	}
	TRACE_FUNCTION ("nm_Plus_Percent_COPS()");

    memset(plmn_list, 0, sizeof(T_MFW_PLMN_LIST));

    if (operLst[0].status == COPS_STAT_Unknown)
    {
		nm_signal(E_NM_PLMN_LIST,plmn_list);
		//Mar 01, 2005    REF: ENH 29327   xdeepadh
		//Deallocate the plmn_list
		if(plmn_list !=NULL)
		{
			mfwFree((U8*)plmn_list,sizeof(T_MFW_PLMN_LIST));
			plmn_list = NULL;
		}
        return;
    }
	/***************************Go-lite Optimization changes Start***********************/
	//	Aug 16, 2004    REF: CRR 24323   Deepa M.D
	TRACE_EVENT_P1("rAT_PlusCOPS: last_ind: %d",last_ind);
	/***************************Go-lite Optimization changes END***********************/	
    if (last_ind > 128) //Invalid index passed in.
    {
	  last_ind = -1;
    }
    else
    {
    	  if (last_ind >= MAX_OPER) //Index is larger than max number of operators.
    	  {
        	last_ind = MAX_OPER-1;
    	  }
    }
    	

    //DS 27/5/2002 - changed <= to <
    for (i = 0; i <= last_ind; i++)      /* operLst == oper_list !!  */
    {
        nm_copy_plmn_list(&plmn_list->plmn[i], &operLst[i]);
    }

	
	/* BEGIN: Aug 09, 2007 REF: OMAPS00140507 x0045876 
	   Added patch given by Dong Feng */	  
	for(i=0; i < MAX_OPER; i++)
	{
		if (operLst[i].status < 0)
		{
			break;
		}
		if (operLst[i].pnn)
		{
			if (operLst[i].long_len)
			{
				switch (operLst[i].long_ext_dcs>>4 & 0x07)
				{
					case 0x00:  /* GSM default alphabet */
						utl_cvtPnn7To8((UBYTE *)operLst[i].longOper,
												operLst[i].long_len,
												operLst[i].long_ext_dcs,
												(UBYTE *)longName);
#ifdef NO_ASCIIZ
						plmn_list->plmn[i].network_long.len = 0;
						plmn_list->plmn[i].network_short.len = 0;
	
						if (operLst->longOper)
						{
							plmn_list->plmn[i].network_long.len = MINIMUM(LONG_NAME-1, strlen((char *)longName));
							memcpy (plmn_list->plmn[i].network_long.data, longName, plmn_list->plmn[i].network_long.len);
							plmn_list->plmn[i].network_long.data[plmn_list->plmn[i].network_long.len] = '\0';
							plmn_list->plmn[i].network_long.dcs = MFW_ASCII;
						}
#else
						memset(plmn_list->plmn[i].network_long, 0, LONG_NAME);
	
						if (operLst->longOper)
							strncpy((char *)plmn_list->plmn[i].network_long, (char *)longName, LONG_NAME-1);
#endif
						break;
				  	case 0x01:  /* UCS2 */
						TRACE_ERROR ("Unhandled UCS2 in PNN entry");
						break;
				  	default:
						TRACE_ERROR ("Unknown DCS in PNN entry");
						break;
				}
			 }
			 if (operLst[i].shrt_len)
			 {
			 	switch (operLst[i].shrt_ext_dcs>>4 & 0x07)
				{
					case 0x00:  /* GSM default alphabet */
						utl_cvtPnn7To8((UBYTE *)operLst[i].shortOper,
												operLst[i].shrt_len,
												operLst[i].shrt_ext_dcs,
								   				(UBYTE *)shrtName);
	
#ifdef NO_ASCIIZ
						plmn_list->plmn[i].network_short.len = 0;
	
						if (operLst->shortOper)
						{
							plmn_list->plmn[i].network_short.len = MINIMUM(SHORT_NAME-1, strlen((char *)shrtName));
							memcpy (plmn_list->plmn[i].network_short.data, shrtName, plmn_list->plmn[i].network_short.len);
							plmn_list->plmn[i].network_short.data[plmn_list->plmn[i].network_short.len] = '\0';
							plmn_list->plmn[i].network_short.dcs = MFW_ASCII;
						}
#else
						memset(plmn_list->plmn[i].network_short, 0, SHORT_NAME);
	
						if (operLst->shortOper)
							strncpy((char *)plmn_list->plmn[i].network_short, (char *)shrtName, SHORT_NAME-1);
#endif
						break;
				  	case 0x01:  /* UCS2 */
						TRACE_ERROR ("ERROR: Unhandled UCS2");
						break;
				  	default:
						TRACE_ERROR ("ERROR: Unknown DCS");
						break;
				}
			 }
		 }
	 }
	/* END: Aug 09, 2007 REF: OMAPS00140507 x0045876 
	   Added patch given by Dong Feng */	  
	/***************************Go-lite Optimization changes Start***********************/
	//	Aug 16, 2004    REF: CRR 24323   Deepa M.D
    TRACE_EVENT_P1("rAT_PlusCOPS: Loop i val is %d",i);
	/***************************Go-lite Optimization changes END***********************/
    plmn_list->count = i;
    
    nm_signal(E_NM_PLMN_LIST,plmn_list);
	//Mar 01, 2005    REF: ENH 29327   xdeepadh
	//Deallocate the plmn_list
	if(plmn_list !=NULL)
	{
		mfwFree((U8*)plmn_list,sizeof(T_MFW_PLMN_LIST));
		plmn_list =NULL;
	}
}




/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM               |
| STATE   : code                        ROUTINE : nm_search_reg_status |
+----------------------------------------------------------------------+

  PURPOSE : Change registration status

*/

void nm_search_reg_status(void)
{
  T_ACI_NRG_RGMD regMode;
  T_ACI_NRG_SVMD srvMode;
  T_ACI_NRG_FRMT oprFrmt;
  T_ACI_NRG_SVMD srvStat;
  U8 oper[LONG_NAME];

  qAT_PercentNRG(CMD_SRC_LCL,
                 &regMode,
                 &srvMode,
                 &oprFrmt,
                 &srvStat,
                 (char *)oper);

  if (srvStat == NRG_SVMD_Limited)
  {
    reg_stat = MFW_LIMITED_SERVICE;
    nm_signal(E_NM_LIMITED_SERVICE,NULL);
  }
  if (srvStat == NRG_SVMD_NoSrv)
  {
    reg_stat = MFW_NO_SERVICE;
    nm_signal(E_NM_NO_SERVICE,NULL);
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : rAT_PlusCREG       |
+--------------------------------------------------------------------+

  PURPOSE : Change registration status

*/

void rAT_PlusCREG (T_ACI_CREG_STAT stat,
                   USHORT          lac,
                   USHORT          cid)
{
    T_MFW_NETWORK_STRUCT plmn_ident;
    T_MFW_CELL_STRUCT cell;
    T_ACI_NRG_RGMD regMode;
    T_ACI_NRG_SVMD srvMode;
    T_ACI_NRG_FRMT oprFrmt;
    T_ACI_NRG_SVMD srvStat;
	USHORT cause;     //Added for OMAPS00134509/ASTec32515
    U8 oper[LONG_NAME];

   TRACE_FUNCTION("rAT_PlusCREG()");

    switch (stat)
    {
        case CREG_STAT_Reg:
        case CREG_STAT_Roam:
            reg_stat = MFW_FULL_SERVICE;
            qAT_PercentNRG(CMD_SRC_LCL,
                           &regMode,
                           &srvMode,
                           &oprFrmt,
                           &srvStat,
                           (char *)oper);
#ifdef NO_ASCIIZ
            sAT_PlusCOPSE(oper,(U8) oprFrmt,&plmn_ident.network_long,
                                      &plmn_ident.network_short,
                                      plmn_ident.network_numeric);
            memcpy(plmn_ident.service_provider.data,
                   service_provider_name.data,
                   service_provider_name.len);
            plmn_ident.service_provider.len = service_provider_name.len;
#else
            sAT_PlusCOPSE(oper,(U8) oprFrmt,plmn_ident.network_long,
                                      plmn_ident.network_short,
                                      plmn_ident.network_numeric);
            strcpy((char *) plmn_ident.service_provider,
                   (char *) service_provider_name);
#endif
            plmn_ident.display_condition = display_condition & 0x01;
            if (stat == CREG_STAT_Reg)
                plmn_ident.roaming_indicator = 0;
            if (stat == CREG_STAT_Roam)
                plmn_ident.roaming_indicator = 1;
            
             //x0pleela 08 Feb, 2006 ER: OMAPS00065203
             nm_get_COPN( &plmn_ident );      

              nm_signal(E_NM_FULL_SERVICE,&plmn_ident);

  		/* Cell ReSelection Code */
            	cell.ci = cid;
            	cell.lid = lac;
            	nm_signal(E_NM_CELL_SELECT,&cell);         
            break;
            
        case CREG_STAT_NoSearch:
        case CREG_STAT_NotPresent:
            if (!reg_flag)
                nm_search_reg_status();
            break;
        case CREG_STAT_Search:
            if (reg_flag)
            {
                reg_stat = MFW_SEARCH_NETWORK;
                nm_signal(E_NM_SEARCH_NETWORK,NULL);
            }
            else
                nm_search_reg_status();
            break;
               //Sep 18,2006    DRT: OMAPS0090268 x0061088(Prachi)
		//Description : added case for Denied services,which send nm_signal.
           case CREG_STAT_Denied:
//TISH, patch for ASTec32515/OMAPS00134509
//start
					qAT_PlusCEER( CMD_SRC_LCL, &cause);
					if (cause EQ 0x8488)     // If SIM is rejected in authentification
						sim_invalid_ind();
					else
//end
              	  nm_signal(E_NM_FORBIDDEN_NETWORK, NULL);
            break;
        default:
            nm_search_reg_status();
            break;
    }
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_abort_avail_plmn|
+--------------------------------------------------------------------+

  PURPOSE : Change registration status

*/

void nm_abort_avail_plmn(void)
{
    sAT_Abort(CMD_SRC_LCL, AT_CMD_COPS);
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_nitz_info_ind   |
+--------------------------------------------------------------------+

  PURPOSE : NITZ information indication

*/

#ifdef FF_2TO1_PS
void  nm_nitz_info_ind(T_MMREG_INFO_IND * mmr_info_ind)


{
  UBYTE flag;

  TRACE_FUNCTION("nm_nitz_info_ind() ");

  flag = 0;

 /* BEGIN ADD: SUMIT: REQ : aligning to 5.x SAP definitions */
#ifdef NEPTUNE_BOARD

  /* copy country code and network code */
  memset (net_ind.mcc, 0, PS_SIZE_MCC);
  memset (net_ind.mnc, 0, PS_SIZE_MNC_MAX);
  if (mmr_info_ind->v_plmn_id EQ TRUE)
  {
    flag = 1;
    memcpy (net_ind.mcc, mmr_info_ind->plmn_id.mcc, PS_SIZE_MCC);
    memcpy (net_ind.mnc, mmr_info_ind->plmn_id.mnc, PS_SIZE_MNC_MAX);
  }

  /* copy long name */
  memset(&net_ind.long_name, 0, sizeof(T_MFW_NET_NAME));

  if (mmr_info_ind->v_full_net_name EQ TRUE)
  {
    flag = 1;
    net_ind.long_name.dcs       = mmr_info_ind->full_net_name.cs;
    net_ind.long_name.add_ci    = mmr_info_ind->full_net_name.add_ci;
    net_ind.long_name.num_spare = mmr_info_ind->full_net_name.num_spare;
    net_ind.long_name.len = MINIMUM (MMREG_MAX_TEXT_LEN, mmr_info_ind->full_net_name.c_text);
    memcpy (net_ind.long_name.data,
            mmr_info_ind->full_net_name.text,
            net_ind.long_name.len);
  }

  /* copy short name */
  memset(&net_ind.short_name, 0, sizeof(T_MFW_NET_NAME));
  if (mmr_info_ind->v_short_net_name EQ TRUE)
  {
    flag = 1;
    net_ind.short_name.dcs       = mmr_info_ind->short_net_name.cs;
    net_ind.short_name.add_ci    = mmr_info_ind->short_net_name.add_ci;
    net_ind.short_name.num_spare = mmr_info_ind->short_net_name.num_spare;
    net_ind.short_name.len = MINIMUM (MMREG_MAX_TEXT_LEN, mmr_info_ind->short_net_name.c_text);
    memcpy (net_ind.short_name.data,
            mmr_info_ind->short_net_name.text,
            net_ind.short_name.len);
  }

  if (flag)
    nm_signal(E_MFW_NET_IND, &net_ind);

  flag = 0;
  memset(&tim_ind, 0, sizeof(T_MFW_TIME_IND));
  /* copy time */
  if (mmr_info_ind->v_universal_time EQ TRUE AND
      mmr_info_ind->v_local_time_zone EQ TRUE )
  {
    flag = 1;
    tim_ind.timezone = mmr_info_ind->local_time_zone.time_zone;
    tim_ind.year     = (mmr_info_ind->universal_time.year);
    tim_ind.month    = (mmr_info_ind->universal_time.month);
    tim_ind.day      = (mmr_info_ind->universal_time.day);
    tim_ind.hour     = (mmr_info_ind->universal_time.hour);
    tim_ind.minute   =(mmr_info_ind->universal_time.minute);
    tim_ind.second   = (mmr_info_ind->universal_time.second );
  }
  else if (mmr_info_ind->v_local_time_zone EQ TRUE AND
           mmr_info_ind->v_universal_time NEQ TRUE )
  {
    flag = 1;
    tim_ind.timezone = mmr_info_ind->local_time_zone.time_zone;
  }

#else
  /* END ADD: Sumit */
 
//Apr 13, 2007 DRT:OMAPS00122739 x0066814(Geetha)
#if(0)
  /* copy country code and network code */
  memset (net_ind.mcc, 0, PS_SIZE_MCC);
  memset (net_ind.mnc, 0, PS_SIZE_MNC_MAX);
  if (mmr_info_ind->plmn.plmn_presence EQ TRUE)
  {
    flag = 1;
    memcpy (net_ind.mcc, mmr_info_ind->plmn.plmn_id.mcc, PS_SIZE_MCC);
    memcpy (net_ind.mnc, mmr_info_ind->plmn.plmn_id.mnc, PS_SIZE_MNC_MAX);
  }

  /* copy long name */
  memset(&net_ind.long_name, 0, sizeof(T_MFW_NET_NAME));
  if (mmr_info_ind->full_net_name.v_name EQ TRUE)
  {
    flag = 1;
    net_ind.long_name.dcs       = mmr_info_ind->full_net_name.cs;
    net_ind.long_name.add_ci    = mmr_info_ind->full_net_name.add_ci;
    net_ind.long_name.num_spare = mmr_info_ind->full_net_name.num_spare;
    net_ind.long_name.len = MINIMUM (MMREG_MAX_TEXT_LEN, mmr_info_ind->full_net_name.c_text);
    memcpy (net_ind.long_name.data,
            mmr_info_ind->full_net_name.text,
            net_ind.long_name.len);
  }

  /* copy short name */
  memset(&net_ind.short_name, 0, sizeof(T_MFW_NET_NAME));
  if (mmr_info_ind->short_net_name.v_name EQ TRUE)
  {
    flag = 1;
    net_ind.short_name.dcs       = mmr_info_ind->short_net_name.cs;
    net_ind.short_name.add_ci    = mmr_info_ind->short_net_name.add_ci;
    net_ind.short_name.num_spare = mmr_info_ind->short_net_name.num_spare;
    net_ind.short_name.len = MINIMUM (MMREG_MAX_TEXT_LEN, mmr_info_ind->short_net_name.c_text);
    memcpy (net_ind.short_name.data,
            mmr_info_ind->short_net_name.text,
            net_ind.short_name.len);
  }

  if (flag)
    nm_signal(E_MFW_NET_IND, &net_ind);
#endif
  flag = 0;
  memset(&tim_ind, 0, sizeof(T_MFW_TIME_IND));
  /* copy time */
  if (mmr_info_ind->net_time_zone.v_time_zone EQ TRUE AND
      mmr_info_ind->net_time.v_time EQ TRUE )
  {
    flag = 1;
    tim_ind.timezone = mmr_info_ind->net_time_zone.time_zone;
    tim_ind.year     = ((mmr_info_ind->net_time.year[0]-'0')   * 10 + (mmr_info_ind->net_time.year[1]-'0') );
    tim_ind.month    = ((mmr_info_ind->net_time.month[0]-'0')  * 10 + (mmr_info_ind->net_time.month[1]-'0') );
    tim_ind.day      = ((mmr_info_ind->net_time.day[0]-'0')    * 10 + (mmr_info_ind->net_time.day[1]-'0') );
    tim_ind.hour     = ((mmr_info_ind->net_time.hour[0]-'0')   * 10 + (mmr_info_ind->net_time.hour[1]-'0') );
    tim_ind.minute   = ((mmr_info_ind->net_time.minute[0]-'0') * 10 + (mmr_info_ind->net_time.minute[1]-'0') );
    tim_ind.second   = ((mmr_info_ind->net_time.second[0]-'0') * 10 + (mmr_info_ind->net_time.second[1]-'0') );
  }
  else if (mmr_info_ind->net_time_zone.v_time_zone EQ TRUE AND
           mmr_info_ind->net_time.v_time NEQ TRUE )
  {
    flag = 1;
    tim_ind.timezone = mmr_info_ind->net_time_zone.time_zone;
  }
/*BEGIN ADD: Neptune */
#endif
/*END ADD: Neptune */
  if (flag)
    nm_signal(E_MFW_TIME_IND, &tim_ind);
}
#else
void  nm_nitz_info_ind(T_MMR_INFO_IND * mmr_info_ind)
{
  UBYTE flag;

  TRACE_FUNCTION("nm_nitz_info_ind() ");
//Apr 13, 2007 DRT:OMAPS00122739 x0066814(Geetha)  
#if(0)
  flag = 0;
  /* copy country code and network code */
  memset (net_ind.mcc, 0, SIZE_MCC);
  memset (net_ind.mnc, 0, SIZE_MNC);
  if (mmr_info_ind->plmn.v_plmn EQ TRUE)
  {
    flag = 1;
    memcpy (net_ind.mcc, mmr_info_ind->plmn.mcc, SIZE_MCC);
    memcpy (net_ind.mnc, mmr_info_ind->plmn.mnc, SIZE_MNC);
  }

  /* copy long name */
  memset(&net_ind.long_name, 0, sizeof(T_MFW_NET_NAME));
  if (mmr_info_ind->full_name.v_name EQ TRUE)
  {
    flag = 1;
    net_ind.long_name.dcs       = mmr_info_ind->full_name.dcs;
    net_ind.long_name.add_ci    = mmr_info_ind->full_name.add_ci;
    net_ind.long_name.num_spare = mmr_info_ind->full_name.num_spare;
    net_ind.long_name.len = MINIMUM (MMR_MAX_TEXT_LEN, mmr_info_ind->full_name.c_text);
    memcpy (net_ind.long_name.data,
            mmr_info_ind->full_name.text,
            net_ind.long_name.len);
  }

  /* copy short name */
  memset(&net_ind.short_name, 0, sizeof(T_MFW_NET_NAME));
  if (mmr_info_ind->short_name.v_name EQ TRUE)
  {
    flag = 1;
    net_ind.short_name.dcs       = mmr_info_ind->short_name.dcs;
    net_ind.short_name.add_ci    = mmr_info_ind->short_name.add_ci;
    net_ind.short_name.num_spare = mmr_info_ind->short_name.num_spare;
    net_ind.short_name.len = MINIMUM (MMR_MAX_TEXT_LEN, mmr_info_ind->short_name.c_text);
    memcpy (net_ind.short_name.data,
            mmr_info_ind->short_name.text,
            net_ind.short_name.len);
  }

  if (flag)
    nm_signal(E_MFW_NET_IND, &net_ind);
#endif

  flag = 0;
  memset(&tim_ind, 0, sizeof(T_MFW_TIME_IND));
  /* copy time */
  if (mmr_info_ind->ntz.v_tz EQ TRUE AND
      mmr_info_ind->time.v_time EQ TRUE )
  {
    flag = 1;
    tim_ind.timezone = mmr_info_ind->ntz.tz;
    tim_ind.year     = mmr_info_ind->time.year;
    tim_ind.month    = mmr_info_ind->time.month;
    tim_ind.day      = mmr_info_ind->time.day;
    tim_ind.hour     = mmr_info_ind->time.hour;
    tim_ind.minute   = mmr_info_ind->time.minute;
    tim_ind.second   = mmr_info_ind->time.second;
  }
  else if (mmr_info_ind->ntz.v_tz EQ TRUE AND
           mmr_info_ind->time.v_time NEQ TRUE )
  {
    flag = 1;
    tim_ind.timezone = mmr_info_ind->ntz.tz;
  }

  if (flag)
    nm_signal(E_MFW_TIME_IND, &tim_ind);
}
#endif

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nmCommand          |
+--------------------------------------------------------------------+

  PURPOSE : handle mfw windows command

*/

static int nmCommand (U32 cmd, void *h)
{
    switch (cmd)
    {
        case MfwCmdDelete:              /* delete me                */
            if (!h)
                return 0;
            nm_delete(h);
            return 1;
        default:
            break;
    }

    return 0;
}



#ifdef NO_ASCIIZ
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_get_spn         |
+--------------------------------------------------------------------+

  PURPOSE : Function to give access to the service provider string

  Parameters  : None

  Return: Service provider string

*/

void nm_get_spn (T_MFW_SP_NAME *name)
{
    if (name NEQ NULL)
        memcpy(name, &service_provider_name, sizeof(T_MFW_SP_NAME));
}

#else
/* PATCH PMC 000804 */
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_get_spn         |
+--------------------------------------------------------------------+

  PURPOSE : Function to give access to the service provider string

  Parameters  : None

  Return: Service provider string

*/

void nm_get_spn (char *name)
{
    if (name NEQ NULL)
        strncpy (name, service_provider_name, LONG_NAME);
}
/* END PATCH PMC */
#endif

/*
+---------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM              |
| STATE   : code                        ROUTINE : nm_abort_registraion|
+---------------------------------------------------------------------+

  PURPOSE : abort current registration

  Parameters  : None

*/
void nm_abort_registraion(void)
{
    sAT_Abort(CMD_SRC_LCL, AT_CMD_NRG);
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)  MODULE  : MFW_NM                  |
| STATE   : code                  ROUTINE : nm_decodeSourceId         |
+--------------------------------------------------------------------+

  PURPOSE : This function is used to convert the source id
            used by ACI to the source id used by MFW.
*/

//x0pleela 09 Feb, 2006  ER: OMAPS00065203
int nm_decodeSourceId( UBYTE sourceId)
{
   TRACE_FUNCTION("nm_decodeSourceId()");
#ifndef NEPTUNE_BOARD
    switch (sourceId)
    {	
        case Read_ROM_TABLE:        	return NM_ROM;
        case Read_EONS:          		return NM_EONS;
        case Read_CPHS:        		return NM_CPHS;
        case Read_INVALID:	        	
        default:                        		return NM_NONE;
    }
#endif
/* to remove warning Aug -11 */
#ifdef NEPTUNE_BOARD
   return NM_NONE;
#endif
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)  MODULE  : MFW_NM                  |
| STATE   : code                  ROUTINE : nm_update_plmn_data         |
+--------------------------------------------------------------------+

  PURPOSE : This function is used to update plmn data after querying COPN
*/
//x0pleela 09 Feb, 2006  ER: OMAPS00065203
void nm_update_plmn_data( T_MFW_NETWORK_STRUCT *plmn_ident, 
							    T_ACI_OPER_NTRY oper_ntry)
{
  TRACE_FUNCTION("nm_update_plmn_data()");
 
#ifndef NEPTUNE_BOARD
  plmn_ident->opn_read_from = (T_MFW_NM_OPN)nm_decodeSourceId(oper_ntry.source); /*a0393213 compiler warnings removal - explicit typecast done*/
#endif


      //update plmn_ident with EONS
#ifdef NO_ASCIIZ
      memset(plmn_ident->network_long.data, 0, LONG_NAME);
      memset(plmn_ident->network_short.data, 0, SHORT_NAME);
      memcpy( plmn_ident->network_long.data, 
                      oper_ntry.longName, 
                      strlen(oper_ntry.longName) );
    
      memcpy( plmn_ident->network_short.data, 
                      oper_ntry.shrtName, 
                    strlen(oper_ntry.shrtName));

      plmn_ident->network_long.len = strlen((const char*)(plmn_ident->network_long.data)); /*a0393213 warnings removal - explicit typecasting done*/
      plmn_ident->network_short.len = strlen((const char*)(plmn_ident->network_short.data)); 

#else
      memset(plmn_ident->network_long, 0, LONG_NAME);
      memset(plmn_ident->network_short, 0, SHORT_NAME);
      strcpy( plmn_ident->network_long, 
      		      oper_ntry.longName);
      strcpy( plmn_ident->network_short, 
      		      oper_ntry.shrtName);
#endif	       
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)  MODULE  : MFW_NM                  |
| STATE   : code                  ROUTINE : nm_get_COPN         |
+--------------------------------------------------------------------+

  PURPOSE : This function is used to query for COPS and COPN which will indicate from 
  		    where the operator name was read
*/
//x0pleela 09 Feb, 2006  ER: OMAPS00065203
void nm_get_COPN( T_MFW_NETWORK_STRUCT *plmn_ident )
{
  T_ACI_COPS_MOD mode;
  T_ACI_COPS_FRMT format;
  T_ACI_OPER_NTRY oper_ntry;
  char opername[LONG_NAME];

  TRACE_FUNCTION("nm_get_COPN()");

  memset (&oper_ntry, 0, sizeof( T_ACI_OPER_NTRY ));
  //Check where MS is registered
  if( qAT_PlusCOPS ( CMD_SRC_LCL, &mode,
                                  	&format, (char *)opername ) EQ AT_CMPL )
  {
    //Request info about operator name
    if(qAT_PercentCOPN(CMD_SRC_LCL, 
    		format, 
    		(char *)opername, 
    		&oper_ntry) EQ AT_CMPL )
    {	  
        nm_update_plmn_data(plmn_ident, oper_ntry);       
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)  MODULE  : MFW_NM                  |
| STATE   : code                  ROUTINE : nm_get_opername         |
+--------------------------------------------------------------------+

  PURPOSE : This function updates operator name based on cingular's prioritization requirement. 
       Priority would be in order ONS->NITZ->ROM

*/
//x0pleela 09 Feb, 2006  ER: OMAPS00065203
void nm_get_opername(T_MFW_NETWORK_STRUCT  * plmn_ident)
{
  TRACE_FUNCTION("nm_get_opername()");
     sAT_PercentCNIV(CMD_SRC_LCL, CNIV_MODE_ON);
 
  return;
}


// June 02, 2006    DR: OMAPS00078005 x0021334
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)  MODULE  : MFW_NM                   |
| STATE   : code                  ROUTINE : nm_get_network_time           |
+--------------------------------------------------------------------+

  PURPOSE : This function sets the PCTZV mode on.

*/
#ifdef FF_TIMEZONE
void nm_get_network_time(void)
{
	TRACE_FUNCTION("nm_get_network_time()");

    // Put PCTZV mode on to get time and date updates
    //x0066814(Geetha), OMAPS00098351, Timezone information is update through nm_nitz_info_ind() function
    //sAT_PercentCTZV(CMD_SRC_LCL, PCTZV_MODE_ON);
}
#endif


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)  MODULE  : MFW_NM                  |
| STATE   : code                  ROUTINE : nm_get_opername         |
+--------------------------------------------------------------------+

  PURPOSE : This function gets operator name from network. 
*/
//x0pleela 09 Feb, 2006  ER: OMAPS00065203

void nm_get_network_data(T_MFW_NETWORK_STRUCT *plmn_netw_data)
{
	TRACE_FUNCTION("nm_get_network_data()");
	
	//send E_NM_OPN event 
	nm_signal(E_NM_OPN, plmn_netw_data); 
}


// June 02, 2006    DR: OMAPS00078005 x0021334
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)  MODULE  : MFW_NM                   |
| STATE   : code                  ROUTINE : nm_set_network_time      |
+--------------------------------------------------------------------+

  PURPOSE : This function sets time and date info received from network. 
*/
#ifdef FF_TIMEZONE
void nm_set_network_time(T_MFW_TIME_IND *currclock)
{
	TRACE_FUNCTION("nm_set_network_time()");

  	//send E_MFW_TIME_IND event 
    nm_signal(E_MFW_TIME_IND, currclock); 
}
#endif

/* Aug 07, 2007 DR:OMAPS00137726 x0066814(Geetha)*/
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)  MODULE  : MFW_NM                   |
| STATE   : code                  ROUTINE : nm_get_plmn_list_during_bootup      |
+--------------------------------------------------------------------+

  PURPOSE : This function gets the  plmn list during bootup
*/
void nm_get_plmn_list_during_bootup(void)
{
  	TRACE_FUNCTION ("nm_get_plmn_list_during_bootup()");
     nm_signal(E_NM_PLMN_LIST_BOOTUP,0);
	
}