freecalypso-citrine: g23m-gsm/mm/mm

comparison g23m-gsm/mm/mm_regf.c @ 0:75a11d740a02

initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7

author	Mychaela Falconia <falcon@freecalypso.org>
date	Thu, 09 Jun 2016 00:02:41 +0000
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:75a11d740a02
+/*
++-----------------------------------------------------------------------------
+|  Project :  GSM-PS (8410)
+|  Modul   :  MM_REGF
++-----------------------------------------------------------------------------
+|  Copyright 2002 Texas Instruments Berlin, AG
+|                 All rights reserved.
+|
+|                 This file is confidential and a trade secret of Texas
+|                 Instruments Berlin, AG
+|                 The receipt of or possession of this file does not convey
+|                 any rights to reproduce or disclose its contents or to
+|                 manufacture, use, or sell anything it may describe, in
+|                 whole, or in part, without the specific written consent of
+|                 Texas Instruments Berlin, AG.
++-----------------------------------------------------------------------------
+|  Purpose :  This Modul defines the functions for the registration
+|             capability of the module Mobility Management.
++-----------------------------------------------------------------------------
+*/
+#include "config.h"
+#include "fixedconf.h"
+#include "condat-features.h"
+#define MM_REGF_C
+#define ENTITY_MM
+/*==== INCLUDES ===================================================*/
+#if defined (NEW_FRAME)
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include "typedefs.h"
+#include "pcm.h"
+#include "pconst.cdg"
+#include "mconst.cdg"
+#include "message.h"
+#include "ccdapi.h"
+#include "vsi.h"
+#include "custom.h"
+#include "gsm.h"
+#include "prim.h"
+#include "cnf_mm.h"
+#include "mon_mm.h"
+#include "pei.h"
+#include "tok.h"
+#include "mm.h"
+#else
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include "stddefs.h"
+#include "pcm.h"
+#include "pconst.cdg"
+#include "mconst.cdg"
+#include "message.h"
+#include "ccdapi.h"
+#include "custom.h"
+#include "gsm.h"
+#include "prim.h"
+#include "cnf_mm.h"
+#include "mon_mm.h"
+#include "vsi.h"
+#include "pei.h"
+#include "tok.h"
+#include "mm.h"
+#endif
+/*==== EXPORT =====================================================*/
+/*==== PRIVAT =====================================================*/
+/*==== VARIABLES ==================================================*/
+/* added by TISH 0418 to write simloci to FFS */
+extern T_loc_info                loc_info_ffs;
+extern T_imsi_struct      imsi_in_ffs;
+/* added by TISH 0418 to write simloci to FFS */
+/*==== TEST =====================================================*/
+/*==== FUNCTIONS ==================================================*/
+LOCAL void reg_pack_plmn_fn            (USHORT                i,
+const T_RR_ABORT_IND *rr_abort_ind);
+/*==== LOCALS ==================================================*/
+/* first and last colums are dummies to staisf T_plmn structure*/
+LOCAL const T_plmn cingular_plmn_list[]=
+{
+{ 0x1, {0x00, 0x00 ,0x00},  {0x01, 0x08 ,0x00}, 0x1},
+{ 0x1, {0x03, 0x01 ,0x00},  {0x01, 0x05 ,0x00}, 0x1},
+{ 0x1, {0x03, 0x01 ,0x00},  {0x01, 0x07 ,0x00}, 0x1},
+{ 0x1, {0x03, 0x01 ,0x00},  {0x03, 0x08 ,0x00}, 0x1},
+{ 0x1, {0x03, 0x01 ,0x00},  {0x04, 0x01 ,0x00}, 0x1},
+{ 0x1, {0x03, 0x01 ,0x00},  {0x09, 0x08 ,0x00}, 0x1},
+{ 0x1, {0x03, 0x04 ,0x02},  {0x08, 0x01 ,0x00}, 0x1},
+{ 0x1, {0x03, 0x04 ,0x04},  {0x09, 0x03 ,0x00}, 0x1},
+{ 0x1, {0x03, 0x05 ,0x00},  {0x01, 0x00 ,0x0F}, 0x1},
+{ 0x1, {0x03, 0x05 ,0x02},  {0x03, 0x00 ,0x0F}, 0x1},
+{ 0x1, {0x03, 0x05 ,0x08},  {0x03, 0x00 ,0x0F}, 0x1},
+{ 0x1, {0x03, 0x06 ,0x00},  {0x01, 0x00 ,0x0F}, 0x1},
+{ 0x1, {0x03, 0x06 ,0x06},  {0x02, 0x00 ,0x0F}, 0x1}
+};
+#if !defined(GPRS)
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_send_mmr_reg_cnf              |
++----------------------------------------------------------------------------+
+PURPOSE : This function builds and sends a MMR_REG_CNF primitive to
+	    the MMR SAP.
+This is only done if G23 is compiled as a GSM only protocol stack
+without GPRS. Otherwise this function is deactivated.
+*/
+GLOBAL void reg_send_mmr_reg_cnf (UBYTE bootup_cause)
+{
+GET_INSTANCE_DATA;
+PALLOC (mmr_reg_cnf, MMR_REG_CNF); /* T_MMR_REG_CNF */
+TRACE_FUNCTION ("reg_send_mmr_reg_cnf()");
+if (bootup_cause NEQ PWR_SCAN_START)
+{
+mmr_reg_cnf->plmn.v_plmn = V_PLMN_PRES;
+memcpy (mmr_reg_cnf->plmn.mcc, mm_data->mm.lai.mcc, SIZE_MCC);
+memcpy (mmr_reg_cnf->plmn.mnc, mm_data->mm.lai.mnc, SIZE_MNC);
+}
+else
+{
+mmr_reg_cnf->plmn.v_plmn = V_PLMN_NOT_PRES;
+}
+mmr_reg_cnf->lac = mm_data->mm.lai.lac;
+mmr_reg_cnf->cid = mm_data->mm.cid;
+mmr_reg_cnf->bootup_cause = bootup_cause;
+PSENDX (MMI, mmr_reg_cnf);
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_build_mmr_reg_cnf              |
++----------------------------------------------------------------------------+
+PURPOSE : This function indicates change in service or change in PLMN to
+	    the MMR SAP.
+This is only done if G23 is compiled as a GSM only protocol stack
+without GPRS. Otherwise this function is deactivated.
+*/
+GLOBAL void reg_build_mmr_reg_cnf (void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_build_mmr_reg_cnf()");
+if ((mm_data->reg.full_service_indicated EQ FALSE) OR
+(mm_data->reg.new_cell_ind EQ TRUE))
+{
+/*
+* Either no full service was indicated to the MMI,
+* or the PLMN has changed from that what was indicated before.
+*/
+reg_send_mmr_reg_cnf (REG_END);
+mm_data->reg.full_service_indicated = TRUE;
+mm_data->reg.new_cell_ind = FALSE;
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_build_mmr_nreg_ind     |
++--------------------------------------------------------------------+
+PURPOSE : This functions sends an MMR_NREG_IND to the MMR SAP.
+This is only done if G23 is compiled as a GSM only protocol stack
+without GPRS. Otherwise this function is deactivated.
+*/
+GLOBAL void reg_build_mmr_nreg_ind (UBYTE service,
+UBYTE search_running,
+UBYTE forb_ind)
+{
+GET_INSTANCE_DATA;
+PALLOC (mmr_nreg_ind, MMR_NREG_IND); /* T_MMR_NREG_IND */
+TRACE_FUNCTION ("reg_build_mmr_nreg_ind");
+mmr_nreg_ind->service = service;
+mmr_nreg_ind->search_running = search_running;
+if (forb_ind EQ FORB_PLMN_INCLUDED)
+{
+mmr_nreg_ind->new_forb_plmn.v_plmn = V_PLMN_PRES;
+memcpy (mmr_nreg_ind->new_forb_plmn.mcc, mm_data->mm.lai.mcc, SIZE_MCC);
+memcpy (mmr_nreg_ind->new_forb_plmn.mnc, mm_data->mm.lai.mnc, SIZE_MNC);
+}
+else
+{
+mmr_nreg_ind->new_forb_plmn.v_plmn = V_PLMN_NOT_PRES;
+memset (mmr_nreg_ind->new_forb_plmn.mcc, 0x0f, SIZE_MCC);
+memset (mmr_nreg_ind->new_forb_plmn.mnc, 0x0f, SIZE_MNC);
+}
+mmr_nreg_ind->cause = mm_data->limited_cause;
+PSENDX (MMI, mmr_nreg_ind);
+/*
+* Delete the limited cause if it was not fatal, as
+* on the next cell selection the reason may be another than
+* the one now indicated.
+*/
+if (mm_data->reg.op.sim_ins EQ SIM_INSRT)
+mm_data->limited_cause = MMCS_INT_NOT_PRESENT;
+mm_data->reg.full_service_indicated = FALSE;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_build_mmr_nreg_cnf     |
++--------------------------------------------------------------------+
+PURPOSE : This functions sends an MMR_NREG_CNF to the MMR SAP.
+This is only done if G23 is compiled as a GSM only protocol stack
+without GPRS. Otherwise this function is deactivated.
+*/
+GLOBAL void reg_build_mmr_nreg_cnf (UBYTE cause)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_build_mmr_nreg_cnf()");
+if (mm_data->nreg_request)
+{
+PALLOC (mmr_nreg_cnf, MMR_NREG_CNF); /* T_MMR_NREG_CNF */
+mmr_nreg_cnf->detach_cause = cause;
+PSENDX (MMI, mmr_nreg_cnf);
+mm_data->nreg_request = FALSE;
+}
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_build_mmr_plmn_ind             |
++----------------------------------------------------------------------------+
+PURPOSE : This function send a MMR_PLMN_IND primitive to the MMR SAP.
+This is only done if G23 is compiled as a GSM only protocol stack
+without GPRS. Otherwise this function is deactivated.
+*/
+GLOBAL void reg_build_mmr_plmn_ind (USHORT cause,
+const T_RR_ABORT_IND *rr_abort_ind)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_build_mmr_plmn_ind()");
+if (mm_data->plmn_scan_mmi)
+{
+USHORT i;
+PALLOC (mmr_plmn_ind, MMR_PLMN_IND); /* T_MMR_PLMN_IND */
+mmr_plmn_ind->cause = cause;
+// This memset() sets all plmn.v_plmn fields to 0xff.
+// For ACI, file PSA_MMF.C, function psaMM_CpyPLMNLst()
+// this indicates that the PLMN is *not* valid.
+// This convention is used at some places in MM,
+// but it is against all usual conventions for G23.
+// By RR SAP definition 0xff is not a possible value in this field.
+// RR SAP definition says:
+//   plmn.v_plmn = V_PLMN_PRES (0x01) PLMN valid
+//   plmn.v_plmn = V_PLMN_NOT_PRES (0x00) PLMN not valid
+memset (&mmr_plmn_ind->plmn, NOT_PRESENT_8BIT,
+sizeof (mmr_plmn_ind->plmn));
+if (cause EQ MMCS_SUCCESS)
+{
+/* Create the PLMN list for the MMI and send it */
+reg_create_plmn_list (rr_abort_ind, WITH_ALL_PLMNS);
+for (i = 0 ; i < mm_data->reg.plmn_cnt; i++)
+{
+reg_unpack_plmn (&mmr_plmn_ind->plmn[i], mm_data->reg.plmn, i);
+mmr_plmn_ind->forb_ind[i] =
+reg_plmn_in_list (mm_data->reg.forb_plmn,
+MAX_FORB_PLMN_ID,
+&mmr_plmn_ind->plmn[i]);
+mmr_plmn_ind->rxlevel[i]  = mm_data->reg.plmn_rx [i];
+mmr_plmn_ind->lac_list[i]  = mm_data->reg.plmn_lac [i];
+}
+/* Do not consider the forbidden PLMNs for MM's internal operation */
+reg_create_plmn_list (rr_abort_ind, WITH_OTHER_PLMNS);
+}
+PSENDX (MMI, mmr_plmn_ind);
+}
+reg_check_plmn_search (cause, rr_abort_ind);
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_build_mmr_ahplmn_ind             |
++----------------------------------------------------------------------------+
+PURPOSE : This function sends a MMR_AHPLMN_IND primitive to the MMR SAP.
+At poweron if valid AHPLMN or if MM receives valid AHPLMN request
+from SIM, MM should inform ACI of the changed AHPLMN.
+This is only done if G23 is compiled as a GSM only protocol stack
+without GPRS. Otherwise this function is deactivated.
+*/
+GLOBAL void reg_build_mmr_ahplmn_ind (T_plmn   *acting_hplmn)
+{
+TRACE_FUNCTION ("reg_build_mmr_ahplmn_ind()");
+{
+PALLOC(mmr_ahplmn_ind, MMR_AHPLMN_IND);  /* T_MMR_AHPLMN_IND */
+mmr_ahplmn_ind->ahplmn.v_plmn = acting_hplmn->v_plmn;
+memcpy (mmr_ahplmn_ind->ahplmn.mcc, acting_hplmn->mcc, SIZE_MCC);
+memcpy (mmr_ahplmn_ind->ahplmn.mnc, acting_hplmn->mnc, SIZE_MNC);
+PSENDX(MMI, mmr_ahplmn_ind);
+}
+}
+#endif /* !defined(GPRS) */
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_build_sim_update               |
++----------------------------------------------------------------------------+
+PURPOSE :
+*/
+GLOBAL void reg_build_sim_update (void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_build_sim_update()");
+if (mm_data->reg.op.sim_ins EQ SIM_INSRT)
+{
+PALLOC (sim_mm_update_req, SIM_MM_UPDATE_REQ);
+mm_write_eplmn_to_ffs();
+reg_set_loc_info   (sim_mm_update_req);
+reg_set_bcch_info  (sim_mm_update_req);
+reg_set_forb_plmns (sim_mm_update_req);
+reg_set_kc         (sim_mm_update_req);
+/* Sending the final EF indicator Bit pattern to SIM */
+sim_mm_update_req->ef_indicator = mm_data->ef_indicator;
+PSENDX (SIM, sim_mm_update_req);
+/* Resetting to 0 after its info is conveyed to SIM */
+mm_data->ef_indicator = 0;
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_copy_sim_data          |
++--------------------------------------------------------------------+
+PURPOSE : This function copies the registration data from the SIM
+provided by the SIM_MM_INSERT_IND primitive into the
+registration data structures. A consistency check is
+made, if data is not consistent (e.g. TMSI present,
+but update state is different from U1 updated), this is
+corrected.
+*/
+GLOBAL void reg_copy_sim_data (const T_SIM_MM_INSERT_IND *sim_mm_insert_ind)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_copy_sim_data()");
+mm_data->reg.op.ts          = TS_NO_AVAIL;
+mm_data->reg.op.sim_ins     = SIM_INSRT;
+/* Clear limited service cause for MMI information */
+mm_data->limited_cause = MMCS_INT_NOT_PRESENT;
+#ifdef TM_SPECIAL
+mm_data->reg.op.ts = TS_AVAIL;
+#else
+if (sim_mm_insert_ind->ad[0] >= 0x80)
+mm_data->reg.op.ts = TS_AVAIL;
+if (sim_mm_insert_ind->ad[0] EQ 4)
+mm_data->reg.cell_test = CELL_TEST_ENABLE;
+else
+mm_data->reg.cell_test = CELL_TEST_DISABLE;
+#endif
+/* EF_AD in SIM has length of MNC as optional field. If the field
+* is present then Length of MNC is present and hence read it.
+*/
+if (sim_mm_insert_ind->c_ad EQ 4)
+{
+mm_data->reg.length_mnc = sim_mm_insert_ind->ad[3] &0x0f;
+}
+TRACE_EVENT_P1("Length of MNC = %x",
+sim_mm_insert_ind->c_ad);
+/*
+* Copy the information of SIM_MM_INSERT_IND into the
+* data fields of the registration
+*/
+reg_read_imsi     (&mm_data->reg.imsi_struct, &sim_mm_insert_ind->imsi_field);
+reg_read_loc_info (&sim_mm_insert_ind->loc_info);
+/*add by TISH 0418 to write imsi to FFS*/
+mm_read_ffs_imsi();
+if (reg_imsi_equal(&imsi_in_ffs, &mm_data->reg.imsi_struct))
+{
+/* added by TISH 0418 to write simloci to FFS */
+if( mm_data->reg.update_stat NEQ MS_UPDATED)
+{	//only use value in FFS in this case
+TRACE_EVENT("MS NOT UPDATED, readsimloci from FFS");
+if(mm_read_ffs_simloci())
+{
+/*Successful read*/
+TRACE_EVENT_P7("readlocinfo:%d,%d,%d,%d,%d,%d,%d", loc_info_ffs.loc[4],
+			loc_info_ffs.loc[5], loc_info_ffs.loc[6],
+			loc_info_ffs.loc[7], loc_info_ffs.loc[8],
+			loc_info_ffs.loc[9], loc_info_ffs.loc[10]);
+reg_read_loc_info (&loc_info_ffs);
+}
+}
+}
+mm_data->reg.acc_class = sim_mm_insert_ind->acc_ctrl.acc[0] * 256 +
+sim_mm_insert_ind->acc_ctrl.acc[1];
+reg_read_bcch_info (sim_mm_insert_ind);
+reg_read_kc_cksn   (sim_mm_insert_ind);
+reg_read_forb_plmn (&sim_mm_insert_ind->forb_plmn);
+reg_copy_sim_ahplmn (sim_mm_insert_ind);
+/* Delete the AHPLMN entry from the Forbidden list, if present*/
+if ( mm_data->reg.acting_hplmn.v_plmn)
+{
+/* Remove from forbidden PLMN list if stored */
+reg_plmn_bad_del (mm_data->reg.forb_plmn,
+MAX_FORB_PLMN_ID,
+&mm_data->reg.acting_hplmn);
+}
+#ifdef GPRS
+reg_clear_plmn_list (mm_data->reg.gprs_forb_plmn, MAX_GPRS_FORB_PLMN_ID);
+#endif /* #ifdef GPRS */
+// sim_mm_insert_ind->phase is not needed by MM
+mm_data->reg.thplmn = sim_mm_insert_ind->hplmn;
+if (mm_data->reg.thplmn > HPLMN_MAX_SEARCH_PERIOD)
+{
+/* 3GPP 22.011 subclause 3.2.2.5 requires to use the default value
+* if the value delivered by the SIM exceeds the allowed limit. */
+mm_data->reg.thplmn = HPLMN_DEF_SEARCH_PERIOD;
+}
+/*
+* If file size is indicated in SIM MM insert indication,
+* MM shall read files from SIM.
+*/
+if(reg_sim_files_to_be_read(sim_mm_insert_ind))
+{
+/*
+* Read indicated EFs in SIM_MM_INSERT_IND from SIM.
+*/
+reg_read_next_sim_file();
+}
+/*Re-read any valid EPLMNs..*/
+mm_read_ffs_init();
+if (mm_data->reg.update_stat NEQ MS_UPDATED)
+{
+/*
+* According to GSM 04.08 subclause 4.1.2.2 the SIM does not contain
+* any valid LAI, TMSI, ciphering key or ciphering key sequence number if
+* the update status on the SIM not equals to U1.
+*/
+/* Delete TMSI */
+mm_data->reg.tmsi = TMSI_INVALID_VALUE;
+/* Inform GMM about the TMSI change */
+mm_mmgmm_tmsi_ind (TMSI_INVALID_VALUE);
+/* Delete LAI */
+mm_data->reg.lai.lac = LAC_INVALID_VALUE;
+/* EF Indicator for EF LOCI - bit 1 */
+mm_data->ef_indicator|=0x01;
+/* Delete CKSN */
+mm_data->reg.cksn    = CKSN_RES;
+/* Delete also KC */
+memset (mm_data->reg.kc, 0xff, MAX_KC);
+/* Set bit 4 in ef_indicator to indicate kc change to SIM for next SIM_MM_UPDATE_REQ */
+mm_data->ef_indicator|=(0x01 << 3);
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_create_plmn_list       |
++--------------------------------------------------------------------+
+PURPOSE : This functions creates the list of available PLMNs from
+the information given by the RR_ABORT_IND primitive.
+The HPLMN is sorted to the top of the PLMN list,
+than the PLMNs follow in th order defined in the
+preferred PLMN list, than the PLMNs follow in the
+order as delivered by the RR_ABORT_IND primitive.
+The parameter hplmn_flag controls whether the forbidden
+PLMNs are deleted from the list, this will be the case
+for MM's internal operation or wheter all PLMNs found shall
+be present in the resulting list, this will be the case
+if the list was requested by the MMI for informational
+purposes.
+hplmn_flag may also indicate whether the HPLMN shall be
+present in the list, this functionality may become
+obsolete in the future.
+In case MM received a location updating reject #13,
+we remember the PLMN where we received this cause. This
+PLMN is in this case a low priority PLMN and sorted to the
+end of the list.
+*/
+GLOBAL void reg_create_plmn_list (const T_RR_ABORT_IND *rr_abort_ind,
+UBYTE           include_flag)
+{
+GET_INSTANCE_DATA;
+USHORT i;
+USHORT j;
+USHORT low_prio_index;
+BOOL copy_plmn[MAX_PLMN_ID];
+UBYTE plmn_avail;
+TRACE_FUNCTION ("reg_create_plmn_list()");
+reg_clear_plmn_list (mm_data->reg.plmn, MAX_PLMN_ID);
+mm_data->reg.plmn_cnt   = 0;
+mm_data->reg.plmn_index = 0;
+plmn_avail = rr_abort_ind->plmn_avail;
+if (plmn_avail > MAX_PLMN_ID)
+plmn_avail = MAX_PLMN_ID; /* Garbage protection, not expected to catch */
+for (i = 0; i < MAX_PLMN_ID; i++)
+copy_plmn[i] = TRUE;
+if (include_flag NEQ WITH_ALL_PLMNS)
+{
+/*
+* MS is in automatic mode and the list which shall be created is
+* not for a PLMN available request,then remove the forbidden PLMNs.
+*/
+for (i = 0; i < rr_abort_ind->plmn_avail; i++)
+{
+if (reg_plmn_in_list (mm_data->reg.forb_plmn,
+MAX_FORB_PLMN_ID,
+&rr_abort_ind->plmn[i]))
+{
+copy_plmn[i] = FALSE;
+}
+#ifdef GPRS
+/*
+* Consider also the "forbidden PLMNs for GPRS services" list,
+* if GPRS is active.
+*/
+if (!mm_gsm_alone () AND
+(mm_data->gprs.mobile_class EQ MMGMM_CLASS_CG) AND
+reg_plmn_in_list (mm_data->reg.gprs_forb_plmn,
+MAX_GPRS_FORB_PLMN_ID,
+&rr_abort_ind->plmn[i]))
+{
+copy_plmn[i] = FALSE;
+}
+#endif /* #ifdef GPRS */
+}
+}
+/*
+* In case RR delivered the PLMN where we recently received a location
+* updating reject with cause #13, this PLMN has low priority now only.
+* This is a different handling than described in GSM 03.22 clause 4.4.3,
+* but needed in the field.
+*/
+low_prio_index = NOT_PRESENT_16BIT;
+if ((include_flag NEQ WITH_ALL_PLMNS) AND
+(include_flag NEQ WITH_RPLMN) AND
+!reg_plmn_empty (&mm_data->reg.low_prio_plmn))
+{
+for (i = 0; i < plmn_avail; i++)
+{
+if (copy_plmn[i] AND
+reg_plmn_equal_sim (&rr_abort_ind->plmn[i],
+&mm_data->reg.low_prio_plmn))
+{
+low_prio_index = i;
+copy_plmn[i] = FALSE;
+}
+}
+/* Clear the low priority PLMN */
+reg_clear_plmn (&mm_data->reg.low_prio_plmn);
+}
+/*
+* In case RR delivered the actual PLMN, requested by FUNC_PLMN_SRCH,
+* as a member of the list, we filter it out, as in this case no cell
+* of the PLMN has been recognized by RR as suitable for full service.
+*/
+if ((include_flag NEQ WITH_ALL_PLMNS) AND
+(include_flag NEQ WITH_RPLMN))
+{
+for (i = 0; i < plmn_avail; i++)
+{
+if (reg_plmn_equal_sim (&rr_abort_ind->plmn[i],
+&mm_data->reg.actual_plmn))
+{
+/*
+* In case of cause #12 - Location Area Not Allowed, MS shall be able
+* to select the same PLMN if suitable cell with other LAI is avaiable.
+* Hence while preparing PLMN list MM shall not discard that PLMN.
+*/
+if (((mm_data->rej_cause EQ MMCS_LA_NOT_ALLOWED)
+#ifdef GPRS
+OR (mm_data->rej_cause EQ GMMCS_LA_NOT_ALLOWED)
+#endif
+)
+AND (GET_STATE(STATE_MM) EQ MM_IDLE_LIMITED_SERVICE))
+{
+TRACE_EVENT ("Don't ignore actual PLMN for cause #12");
+}
+else
+{
+TRACE_EVENT ("Ignore actual PLMN");
+copy_plmn[i] = FALSE;
+}
+}
+}
+}
+/*
+* GSM 03.22 subclause 4.4.3 gives some rules in which way the PLMN list
+* has to be sorted. These rules apply for manual and for automatic mode.
+* For further details, see the mentioned recommendation.
+*/
+/*
+* Find HPLMN in the list of found PLMNs. If present, set it on top
+*/
+for (i = 0; i < plmn_avail; i++)
+{
+if (copy_plmn[i] AND
+reg_plmn_equal_hplmn (&rr_abort_ind->plmn[i]))
+{
+reg_pack_plmn_fn (i, rr_abort_ind);
+copy_plmn[i] = FALSE;
+break;
+}
+}
+/*
+* Add the found PLMNS into MMR_PLMN_IND according to their position in the
+* preferred PLMN list
+*/
+for (j = 0; j < MAX_PREF_PLMN_ID; j++)
+{
+T_plmn pref_plmn;
+reg_unpack_plmn (&pref_plmn, mm_data->reg.pref_plmn, j);
+if (! reg_plmn_empty (&pref_plmn))
+{
+for (i = 0; i < plmn_avail; i++)
+{
+/*
+* Use the comparison routines from GSM 03.22 Annex A (normative)
+* Reason: Even if it is not the HPLMN, we were not able to
+* recognize a 3-digit NA MNC network as preferred if it would still
+* broadcast only 2-digit MNC.
+*/
+if (copy_plmn[i] AND
+reg_plmn_equal_sim (&rr_abort_ind->plmn[i], &pref_plmn))
+{
+reg_pack_plmn_fn (i, rr_abort_ind);
+copy_plmn[i] = FALSE;
+break;
+}
+}
+}
+}
+/*
+* Add the remaining PLMNS to MMR_PLMN_IND
+*/
+for (i = 0; i < plmn_avail; i++)
+{
+if (copy_plmn[i] AND
+! reg_plmn_empty (&rr_abort_ind->plmn[i]))
+{
+reg_pack_plmn_fn (i, rr_abort_ind);
+copy_plmn[i] = FALSE;
+}
+}
+/*
+* Add the low priority PLMN where we previously received LUP reject #13,
+* if present, at the end of the list.
+*/
+if (low_prio_index NEQ NOT_PRESENT_16BIT)
+{
+reg_pack_plmn_fn (low_prio_index, rr_abort_ind);
+copy_plmn[i] = FALSE;
+}
+#ifndef NTRACE
+TRACE_EVENT ("PLMN list");
+for (i = 0; i < mm_data->reg.plmn_cnt; i++)
+{
+T_plmn plmn;
+reg_unpack_plmn (&plmn, mm_data->reg.plmn, i);
+TRACE_EVENT_P6 ("MCC=%x%x%x MNC=%x%x%x",
+plmn.mcc[0],
+plmn.mcc[1],
+plmn.mcc[2],
+plmn.mnc[0],
+plmn.mnc[1],
+plmn.mnc[2]);
+}
+#endif /* #ifndef NTRACE */
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_extract_hplmn          |
++--------------------------------------------------------------------+
+PURPOSE : Extracts the HPLMN out of the registration data.
+If valid AHPLMN is present then HPLMN should be
+read from the file, else it should be read from IMSI.
+*/
+GLOBAL void reg_extract_hplmn (T_plmn *plmn)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_extract_hplmn()");
+if (mm_data->reg.acting_hplmn.v_plmn)
+{
+plmn->v_plmn = V_PLMN_PRES;
+memcpy(plmn->mcc,mm_data->reg.acting_hplmn.mcc,SIZE_MCC);
+memcpy(plmn->mnc,mm_data->reg.acting_hplmn.mnc,SIZE_MNC);
+}
+else
+{
+plmn->v_plmn = V_PLMN_PRES;
+plmn->mcc[0] = mm_data->reg.imsi_struct.id[0];
+plmn->mcc[1] = mm_data->reg.imsi_struct.id[1];
+plmn->mcc[2] = mm_data->reg.imsi_struct.id[2];
+plmn->mnc[0] = mm_data->reg.imsi_struct.id[3];
+plmn->mnc[1] = mm_data->reg.imsi_struct.id[4];
+/*
+* We cannot be sure that plmn->mnc[2] really belongs to the MNC,
+* but the comparison routines for the HPLMN are done in a way that
+* this doesn't matter anyway. See GSM 03.03 subclause 2.2,
+* which is far away from being clear and GSM 03.22 version 7.1.0
+* Release 1998 Annex A (normative). Figure A.2 in this annex makes
+* it obvious that 3-digit-MNC isn't only a NA issue!
+*/
+plmn->mnc[2] = mm_data->reg.imsi_struct.id[5];
+}/* end of mm_data->reg.acting_hplmn.v_plmn */
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_init                   |
++--------------------------------------------------------------------+
+PURPOSE : This function initializes the registration data structures.
+*/
+GLOBAL void reg_init (void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_init()");
+memset (&mm_data->reg, 0, sizeof (T_REG));
+mm_data->reg.update_stat = MS_NOT_UPDATED;
+mm_data->reg.cksn        = CKSN_RES;
+mm_data->reg.full_service_indicated = FALSE;
+mm_data->reg.sim_insert_info = NULL;
+mm_data->reg.sim_sync_req_pending = FALSE;
+mm_data->reg.quick_hplmn_search = TRUE;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_plmn_add_bad           |
++--------------------------------------------------------------------+
+PURPOSE : This function adds the given PLMN to the given list of
+forbidden PLMNs.
+In case the PLMN is already stored in this list, no action
+will be taken, otherwise the PLMN will be stored at the
+first free entry of the list. If there is no free entry,
+the first entry in the list will be deleted and the list
+will be shifted so that the PLMN can be added at the end
+of the list.
+*/
+GLOBAL void reg_plmn_add_bad (UBYTE *forb_plmn_list,
+USHORT list_size,
+const T_plmn *plmn)
+{
+T_plmn forb_plmn;
+USHORT i;
+TRACE_FUNCTION ("reg_plmn_add_bad()");
+/* First look whether the PLMN is already stored */
+for (i = 0; i < list_size; i++)
+{
+reg_unpack_plmn (&forb_plmn, forb_plmn_list, i);
+if (reg_plmn_equal_sim (plmn, &forb_plmn))
+return;
+}
+/* Else look for an empty location and store the PLMN */
+for (i = 0; i < list_size; i++)
+{
+reg_unpack_plmn (&forb_plmn, forb_plmn_list, i);
+if (reg_plmn_empty (&forb_plmn))
+{
+reg_pack_plmn (forb_plmn_list, i, plmn);
+return;
+}
+}
+/* Else shift the entries down add the PLMN at the end of the list */
+memmove (&forb_plmn_list[0],
+&forb_plmn_list[UBYTES_PER_PLMN],
+UBYTES_PER_PLMN * (list_size - 1)); /*lint !e807 This function is always called with constant 'list_size'*/
+reg_pack_plmn (forb_plmn_list, (USHORT)(list_size - 1), plmn);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_plmn_in_list           |
++--------------------------------------------------------------------+
+PURPOSE : This function checks whether the PLMN in question is a
+member of the PLMN list provided. The function returns
+TRUE if the PLMN can be found in the PLMN list, otherwise
+the function returns FALSE.
+*/
+GLOBAL BOOL reg_plmn_in_list(const UBYTE *plmn_list,
+USHORT list_size,
+const T_plmn *plmn)
+{
+T_plmn member_plmn;
+USHORT i;
+TRACE_FUNCTION ("reg_in_forb_plmn()");
+for (i = 0; i < list_size; i++)
+{
+reg_unpack_plmn (&member_plmn, plmn_list, i);
+if (reg_plmn_equal_sim (plmn, &member_plmn))
+return TRUE;
+}
+return FALSE;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_plmn_bad_del           |
++--------------------------------------------------------------------+
+PURPOSE : Remove the specified PLMN from the given list of forbidden
+PLMNs. In case the specified PLMN is found in the list,
+it will be deleted from the list.
+*/
+GLOBAL void reg_plmn_bad_del (UBYTE *forb_plmn_list,
+USHORT list_size,
+const T_plmn *plmn)
+{
+GET_INSTANCE_DATA;
+T_plmn forb_plmn;
+USHORT i;
+USHORT j;
+TRACE_FUNCTION ("reg_plmn_bad_del()");
+for (i = 0; i < list_size; i++)
+{
+reg_unpack_plmn (&forb_plmn, forb_plmn_list, i);
+if (reg_plmn_equal_sim (&forb_plmn, plmn)) /* Argument order matters */
+{
+for (j = i; j < list_size - 1; j++)
+{
+memcpy (&forb_plmn_list[j * UBYTES_PER_PLMN],
+&forb_plmn_list[(j + 1) * UBYTES_PER_PLMN],
+UBYTES_PER_PLMN);
+}
+memset (&forb_plmn_list[(list_size - 1) * UBYTES_PER_PLMN],
+0xff, UBYTES_PER_PLMN);
+/* Set bit 3 in ef_indicator to indicate forb_plmn change to SIM */
+mm_data->ef_indicator|=(0x01 << 2);
+}
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_plmn_empty             |
++--------------------------------------------------------------------+
+PURPOSE : This function tests whether plmn points to an empty PLMN.
+TRUE will be returned if plmn points to an empty PLMN,
+otherwise FALSE.
+*/
+GLOBAL BOOL reg_plmn_empty (const T_plmn *plmn)
+{
+/* TRACE_FUNCTION ("reg_plmn_empty ()"); */ /* Avoid too much output */
+return ((plmn->mcc[0] & 0x0F) EQ 0x0F);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_sim_ef_plmn_field_empty|
++--------------------------------------------------------------------+
+PURPOSE : This function tests whether plmn in EF points to an empty PLMN.
+TRUE will be returned if plmn points to an empty PLMN,
+otherwise FALSE.
+*/
+GLOBAL BOOL reg_sim_ef_plmn_field_empty (UBYTE*     plmn)
+{
+/*check if 1th digit of MCC is not present*/
+return ((plmn[0] & 0x0F) EQ 0x0F);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_plmn_is_NA_plmn        |
++--------------------------------------------------------------------+
+PURPOSE : This function tests whether the PLMN is a NA (North America)
+PLMN. The MCC code is checked to meet this decision.
+*/
+GLOBAL BOOL reg_plmn_is_NA_plmn (const T_plmn *plmn)
+{
+/* TRACE_FUNCTION ("reg_plmn_is_NA_plmn()"); */ /* Avoid too much output */
+/* return ((plmn->mcc[0] EQ 3) AND
+(plmn->mcc[1] EQ 1) AND
+(plmn->mcc[2] >= 0) AND (plmn->mcc[2] <= 6)); lint !e568 never
+less than zero*/
+return ((plmn->mcc[0] EQ 3) AND
+(plmn->mcc[1] EQ 1) AND
+(plmn->mcc[2] <= 6)); /*lint !e568 never
+less than zero*/
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_plmn_equal_sim         |
++--------------------------------------------------------------------+
+PURPOSE : This function tests whether two PLMNs are contained in
+Equivalent PLMN list or not
+*/
+GLOBAL BOOL reg_plmn_equal_eqv (const T_plmn        *bcch_plmn,
+const T_plmn        *req_plmn)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_plmn_equal_eqv()");
+if (reg_plmn_equal_sim (bcch_plmn, req_plmn))
+return TRUE; /* Equal without equivalent PLMN */
+if (reg_plmn_in_list (mm_data->reg.eqv_plmns.eqv_plmn_list, EPLMNLIST_SIZE, bcch_plmn) &&
+reg_plmn_in_list (mm_data->reg.eqv_plmns.eqv_plmn_list, EPLMNLIST_SIZE, req_plmn))
+{
+return TRUE;
+}
+return FALSE;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_plmn_equal_sim         |
++--------------------------------------------------------------------+
+PURPOSE : This function tests whether two PLMNs are equal.
+*/
+GLOBAL BOOL reg_plmn_equal_sim (const T_plmn        *bcch_plmn,
+const T_plmn        *sim_plmn)
+{
+/* TRACE_FUNCTION ("reg_plmn_equal_sim()"); */ /* Avoid too much output */
+/* Check MCC */
+if (memcmp (sim_plmn->mcc, bcch_plmn->mcc, SIZE_MCC) NEQ 0)
+return FALSE;
+/* Check first 2 MNC digits */
+if (memcmp (sim_plmn->mnc, bcch_plmn->mnc, 2) NEQ 0)
+return FALSE;
+/* Check for full match */
+if (sim_plmn->mnc[2] EQ bcch_plmn->mnc[2])
+return TRUE;
+/* The 3rd digit of the MNC differs. */
+if (reg_plmn_is_NA_plmn (bcch_plmn))
+{
+return (((sim_plmn->mnc[2] EQ 0xf) AND (bcch_plmn->mnc[2] EQ 0x0)) OR
+((sim_plmn->mnc[2] EQ 0x0) AND (bcch_plmn->mnc[2] EQ 0xf)));
+}
+return (bcch_plmn->mnc[2] EQ 0xf) OR (sim_plmn->mnc[2] EQ 0xf);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_plmn_equal_hplmn       |
++--------------------------------------------------------------------+
+PURPOSE : This function tests whether the PLMN received on the
+BCCH equals the HPLMN. TRUE will be returned if bcch_plmn
+points to a PLMN description which describes the HPLMN,
+otherwise FALSE will be returned.
+*/
+GLOBAL BOOL reg_plmn_equal_hplmn (const T_plmn *bcch_plmn)
+{
+T_plmn hplmn;
+TRACE_FUNCTION ("reg_plmn_equal_hplmn()");
+reg_extract_hplmn (&hplmn);
+return (reg_plmn_equal_sim (bcch_plmn, &hplmn));
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_plmn_equal_rplmn       |
++--------------------------------------------------------------------+
+PURPOSE : This function tests whether the PLMN equals the RPLMN.
+TRUE will be returned if PLMN points to a PLMN description
+which describes the RPLMN,otherwise FALSE will be returned.
+*/
+GLOBAL BOOL reg_plmn_equal_rplmn (T_plmn    *plmn)
+{
+GET_INSTANCE_DATA;
+T_plmn last_plmn;
+TRACE_FUNCTION ("reg_plmn_equal_rplmn()");
+last_plmn.v_plmn = V_PLMN_PRES;
+memcpy (last_plmn.mcc, mm_data->reg.lai.mcc, SIZE_MCC);
+memcpy (last_plmn.mnc, mm_data->reg.lai.mnc, SIZE_MNC);
+return (reg_plmn_equal_sim (plmn, &last_plmn));
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_imsi_equal             |
++--------------------------------------------------------------------+
+PURPOSE : Checks whether two given IMSIs are identical
+*/
+GLOBAL BOOL reg_imsi_equal (const T_imsi_struct *imsi_struct1, const T_imsi_struct *imsi_struct2)
+{
+USHORT length;
+TRACE_FUNCTION ("reg_imsi_equal()");
+if (imsi_struct1->v_mid NEQ imsi_struct2->v_mid)
+return FALSE;
+if (imsi_struct1->id_type NEQ imsi_struct2->id_type)
+return FALSE;
+switch (imsi_struct1->id_type)
+{
+case TYPE_IMSI:
+length = mm_calculate_digits (imsi_struct1->id);
+if (length NEQ mm_calculate_digits (imsi_struct2->id))
+return FALSE;
+return (memcmp (imsi_struct1->id, imsi_struct2->id, length) EQ 0);
+case TYPE_TMSI:
+return (imsi_struct1->tmsi_dig EQ imsi_struct2->tmsi_dig);
+default:
+return TRUE;
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_plmn_select            |
++--------------------------------------------------------------------+
+PURPOSE : This function is called if there was either a RR failure
+or a MM failure (e.g. LOCATION UPDATING reject).
+MM is in state LIMITED_SERVICE.
+*/
+GLOBAL void reg_plmn_select (UBYTE forb_ind)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_plmn_select ()");
+if (mm_data->reg.plmn_cnt > mm_data->reg.plmn_index AND
+mm_data->reg.op.m EQ MODE_AUTO AND
+mm_data->reg.op.sim_ins EQ SIM_INSRT)
+{
+/*
+* Another PLMN available, automatic mode and SIM considered as valid
+*/
+mm_mmgmm_nreg_ind (NREG_LIMITED_SERVICE,
+SEARCH_RUNNING,
+forb_ind);
+reg_unpack_plmn (&mm_data->reg.actual_plmn,
+mm_data->reg.plmn, mm_data->reg.plmn_index++);
+mm_data->attempt_cnt = 0;
+mm_mmr_reg_req (FUNC_PLMN_SRCH);
+}
+else
+{
+mm_mmgmm_nreg_ind (NREG_LIMITED_SERVICE,
+SEARCH_NOT_RUNNING,
+forb_ind);
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_read_bcch_info         |
++--------------------------------------------------------------------+
+PURPOSE : Read the BCCH information delivered by the SIM into the
+registration data structures.
+*/
+GLOBAL void reg_read_bcch_info (const T_SIM_MM_INSERT_IND *sim_mm_insert_ind)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_read_bcch_info ()");
+if(memcmp(mm_data->reg.bcch, sim_mm_insert_ind->bcch_inf.bcch, SIZE_BCCH))
+{
+/* Set bit 2 in ef_indicator to indicate bcch_info change to SIM */
+mm_data->ef_indicator|=(0x01 << 1);
+}
+memcpy (mm_data->reg.bcch, sim_mm_insert_ind->bcch_inf.bcch, SIZE_BCCH);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS              MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_sim_files_to_be_read   |
++--------------------------------------------------------------------+
+PURPOSE : Read the EFs size (EFu=EFPLMNwAcT, EFo=EFOPLMNwAcT, EFs=EFPLMNSEL)
+	    information delivered
+by the SIM into the registration data structures.
+*/
+GLOBAL BOOL reg_sim_files_to_be_read (const T_SIM_MM_INSERT_IND *sim_mm_insert_ind)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_sim_files_to_be_read ()");
+mm_data->reg.sim_read_in_progress = FALSE;
+#ifdef REL99
+/*
+* If the SIM insert indication and file size is indicated, it MM shall read files from SIM.
+*/
+if (sim_mm_insert_ind->u_ctl_plmn_sel_actech_list_sz >0)
+{
+mm_data->reg.upd_sim_ucps_at = SAT_READ_FILE;
+/*Set indicatort sim reading is in progress to true*/
+mm_data->reg.sim_read_in_progress = TRUE;
+/*
+* MM cant decide here how many PLMNs are supported GSM access Technology so
+* MM should read maximum number of plmn as much it can read.
+* At present there is a limitation in SIM read req. It cant read more than
+* 256 bytes in one request. May be PLMN reading can be extended using more
+* than one sim read req for the same EF in future.
+*/
+if (sim_mm_insert_ind->u_ctl_plmn_sel_actech_list_sz > 0xFF)
+{
+/*
+* In SIM_READ_REQ FF represents length not present. SIM will read actual EF length
+* and send it to MM. At present limitaion is SIM READ CNF can sent max 256 bytes data.
+*/
+mm_data->reg.sim_ucps_at_len = 0xFF;
+}
+else
+{
+mm_data->reg.sim_ucps_at_len = sim_mm_insert_ind->u_ctl_plmn_sel_actech_list_sz;
+}
+}
+if(sim_mm_insert_ind->o_ctl_plmn_sel_actech_list_sz > 0)
+{
+mm_data->reg.upd_sim_ocps_at = SAT_READ_FILE;
+/*Set indicatort sim reading is in progress to true*/
+mm_data->reg.sim_read_in_progress = TRUE;
+/*
+* MM cant decide here how many PLMNs are supported GSM access Technology so
+* MM should read maximum number of plmn as much it can read.
+* At present there is a limitation in SIM read req. It cant read more than
+* 256 bytes in one request. May be PLMN reading can be extended using more
+* than one sim read req for the same EF in future.
+*/
+if (sim_mm_insert_ind->o_ctl_plmn_sel_actech_list_sz > 0xFF)
+{
+/*
+* In SIM_READ_REQ FF represents length not present. SIM will read actual EF length
+* and send it to MM. At present limitaion is SIM READ CNF can sent max 256 bytes data.
+*/
+mm_data->reg.sim_ocps_at_len = 0xFF;
+}
+else
+{
+mm_data->reg.sim_ocps_at_len = sim_mm_insert_ind->o_ctl_plmn_sel_actech_list_sz;
+}
+}
+#endif
+if (sim_mm_insert_ind->pref_plmn_list_sz >0)
+{
+mm_data->reg.upd_sim_plmnsel = SAT_READ_FILE;
+/*Set indicatort sim reading is in progress to true*/
+mm_data->reg.sim_read_in_progress = TRUE;
+/* MM should read MAX PREF PLMNs because this EF does not contain any Access Technology info.*/
+if (sim_mm_insert_ind->pref_plmn_list_sz > MAX_PREF_PLMN)
+{
+mm_data->reg.sim_plmnsel_len = MAX_PREF_PLMN; /* Garbage protection */
+}
+else
+{
+mm_data->reg.sim_plmnsel_len = sim_mm_insert_ind->pref_plmn_list_sz;
+}
+}
+return mm_data->reg.sim_read_in_progress;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_read_forb_plmn         |
++--------------------------------------------------------------------+
+PURPOSE : Read the forbidden PLMN into registration data
+*/
+GLOBAL void reg_read_forb_plmn (const T_forb_plmn *forb_plmn)
+{
+GET_INSTANCE_DATA;
+T_plmn plmn;
+TRACE_FUNCTION ("reg_read_forb_plmn ()");
+reg_clear_plmn_list (mm_data->reg.forb_plmn, MAX_FORB_PLMN_ID);
+memcpy (mm_data->reg.forb_plmn, forb_plmn->forb,
+MAX_SIM_FORB_PLMN_ID * UBYTES_PER_PLMN);
+/*
+* If the HPLMN is a member of the forbidden list, delete it from the list.
+*/
+reg_extract_hplmn (&plmn);
+TRACE_EVENT_P6 ("HPLMN = %x%x%x %x%x%x",
+plmn.mcc[0],
+plmn.mcc[1],
+plmn.mcc[2],
+plmn.mnc[0],
+plmn.mnc[1],
+plmn.mnc[2]);
+reg_plmn_bad_del (mm_data->reg.forb_plmn, MAX_SIM_FORB_PLMN_ID, &plmn);
+#ifndef NTRACE
+{
+USHORT i;
+for (i = 0; i < MAX_SIM_FORB_PLMN_ID; i++)
+{
+reg_unpack_plmn (&plmn, mm_data->reg.forb_plmn, i);
+TRACE_EVENT_P6 ("FORB = %x%x%x %x%x%x",
+plmn.mcc[0],
+plmn.mcc[1],
+plmn.mcc[2],
+plmn.mnc[0],
+plmn.mnc[1],
+plmn.mnc[2]);
+}
+}
+#endif /* #ifndef NTRACE */
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_copy_sim_ahplmn         |
++--------------------------------------------------------------------+
+PURPOSE : Read the AHPLMN information delivered by the SIM at poweron
+into the registration data structures.
+*/
+GLOBAL void reg_copy_sim_ahplmn (const T_SIM_MM_INSERT_IND *sim_mm_insert_ind)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_copy_sim_ahplmn ()");
+TRACE_EVENT_P1("v_act_hplmn = %x",
+sim_mm_insert_ind->v_act_hplmn);
+if (!sim_mm_insert_ind->v_act_hplmn)
+{
+/*Do Nothing. AHPLMN Feature not supported by SIM. Hence, ignore*/
+}
+else
+{
+reg_read_acting_hplmn(sim_mm_insert_ind->act_hplmn);
+/* Inform ACI & RR of the AHPLMN present in SIM */
+valid_acting_hplmn(&mm_data->reg.acting_hplmn);
+mm_build_rr_sync_hplmn_req();
+mm_mmgmm_ahplmn_ind(&mm_data->reg.acting_hplmn);
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_read_imsi              |
++--------------------------------------------------------------------+
+PURPOSE : Reads IMSI delivered by SIM into T_imsi data structure
+*/
+GLOBAL void reg_read_imsi (T_imsi_struct *imsi_struct, const T_imsi_field *imsi_field)
+{
+USHORT i;
+UBYTE  digit;
+UBYTE  length;
+TRACE_FUNCTION ("reg_read_imsi ()");
+imsi_struct->v_mid    = V_MID_PRES;
+imsi_struct->id_type  = TYPE_IMSI;
+imsi_struct->tmsi_dig = 0;
+length = (imsi_field->c_field - 1) * 2;
+if ((imsi_field->field[0] & 0x08) NEQ 0)
+length++;
+for (i = 0; i < length; i++)
+{
+digit = ((i & 1) NEQ 0) ?
+imsi_field->field[(i + 1) / 2] & 0x0f :
+(imsi_field->field[(i + 1) / 2] & 0xf0) >> 4;
+imsi_struct->id[i] = digit;
+}
+imsi_struct->id[i] = 0xff;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_read_kc_cksn           |
++--------------------------------------------------------------------+
+PURPOSE :
+*/
+GLOBAL void reg_read_kc_cksn (const T_SIM_MM_INSERT_IND *sim_mm_insert_ind)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_read_kc_cksn ()");
+if (mm_data->reg.update_stat EQ MS_NOT_UPDATED)
+{
+/*
+* clear cipher key, Kc and location area code
+*/
+mm_data->reg.cksn = CKSN_RES;
+// mm_data->reg.lac  = 0xfffe; // Write-only variable, deleted HM 20.07.00
+memset (mm_data->reg.kc, 0xFF, 8);
+/* Set bit 4 in ef_indicator to indicate kc change to SIM for next SIM_MM_UPDATE_REQ */
+mm_data->ef_indicator|=(0x01 << 3);
+}
+else
+{
+/*
+* copy parameter from SIM card
+*/
+if(memcmp(mm_data->reg.kc, sim_mm_insert_ind->kc_n.kc, MAX_KC))
+{
+/* Set bit 4 in ef_indicator to indicate kc change to SIM for next SIM_MM_UPDATE_REQ */
+mm_data->ef_indicator|=(0x01 << 3);
+}
+memcpy (mm_data->reg.kc, sim_mm_insert_ind->kc_n.kc, MAX_KC);
+mm_data->reg.cksn = sim_mm_insert_ind->kc_n.kc[8];
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_read_loc_info          |
++--------------------------------------------------------------------+
+PURPOSE : Reads the location information delivered by the SIM card
+into the registration memory structures.
+*/
+GLOBAL void reg_read_loc_info (const T_loc_info *loc_info)
+{
+GET_INSTANCE_DATA;
+ULONG tmsi_binary;
+TRACE_FUNCTION ("reg_read_loc_info ()");
+tmsi_binary = (((ULONG)loc_info->loc[0]) << 24) +
+(((ULONG)loc_info->loc[1]) << 16) +
+(((ULONG)loc_info->loc[2]) <<  8) +
+(ULONG)loc_info->loc[3];
+#ifdef GPRS
+mm_data->reg.indicated_tmsi = tmsi_binary;
+#endif /* #ifdef GPRS */
+mm_data->reg.tmsi = tmsi_binary;
+mm_data->reg.lai.mcc[0] = loc_info->loc[4] & 0x0f;
+mm_data->reg.lai.mcc[1] = loc_info->loc[4] >> 4;
+mm_data->reg.lai.mcc[2] = loc_info->loc[5] & 0x0f;
+mm_data->reg.lai.mnc[2] = loc_info->loc[5] >> 4;
+mm_data->reg.lai.mnc[0] = loc_info->loc[6] & 0x0f;
+mm_data->reg.lai.mnc[1] = loc_info->loc[6] >> 4;
+mm_data->reg.lai.lac    = loc_info->loc[7] * 256 +
+loc_info->loc[8];
+if (mm_data->reg.lai.mnc[2] EQ 0xF)
+mm_data->reg.lai.c_mnc = 2; /* 2-digit-MNC */
+else
+mm_data->reg.lai.c_mnc = 3; /* 3-digit-MNC */
+if (mm_data->reg.lai.lac EQ 0xffffL)
+{
+mm_data->reg.lai.lac = 0;
+}
+mm_data->reg.update_stat     = loc_info->loc[10];
+if (mm_data->reg.update_stat >= 0x07)
+{
+mm_data->reg.update_stat = MS_NOT_UPDATED;
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_read_pref_plmn         |
++--------------------------------------------------------------------+
+PURPOSE : Reads the preferred PLMN list delivered by the SIM card
+into the registration memory structures.
+*/
+GLOBAL void reg_read_pref_plmn (UBYTE* data, USHORT length)
+{
+GET_INSTANCE_DATA;
+USHORT index;
+USHORT plmnsel_plmn_count;
+USHORT plmn_count = 0;
+TRACE_FUNCTION ("reg_read_pref_plmn ()");
+/*
+* If any additional which does not give complete
+* PLMN id(length MOD UBYTES_PER_PLMN > 0),
+* ignore these additional bytes at the end
+*/
+mm_data->reg.sim_plmnsel_len = length-length%UBYTES_PER_PLMN;
+if (mm_data->reg.sim_plmnsel_len > MAX_PREF_PLMN_ID * UBYTES_PER_PLMN)
+{
+mm_data->reg.sim_plmnsel_len = MAX_PREF_PLMN_ID * UBYTES_PER_PLMN; /* Garbage protection */
+}
+plmnsel_plmn_count = mm_data->reg.sim_plmnsel_len/UBYTES_PER_PLMN;
+reg_clear_plmn_list (mm_data->reg.pref_plmn, MAX_PREF_PLMN_ID);
+/*Dont copy PLMN entry is empty in the EF*/
+for (index =0; index < plmnsel_plmn_count; index++)
+{
+/*Check if PLMN entry is empty in the EF*/
+if(!reg_sim_ef_plmn_field_empty(&data[index*UBYTES_PER_PLMN]))
+{
+memcpy (&mm_data->reg.pref_plmn[plmn_count*UBYTES_PER_PLMN],
+&data[index*UBYTES_PER_PLMN], UBYTES_PER_PLMN);
+plmn_count++;
+}
+}
+}
+#ifdef REL99
+/*
++-------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                          |
+| STATE   : code                ROUTINE : reg_read_ucps_acctec            |
++-------------------------------------------------------------------------+
+PURPOSE : Reads the user controlled PLMN selector with access technology
+list delivered by the SIM card. PLMN does not support GSM access
+are ignored in the pref_plmn list.
+*/
+GLOBAL void reg_read_ucps_acctec(UBYTE* data, USHORT length)
+{
+GET_INSTANCE_DATA;
+USHORT index;
+USHORT plmn_count=0;
+USHORT ucps_acctech_plmn_count;
+TRACE_FUNCTION ("reg_read_ucps_acctec ()");
+/*
+* If any additional bytes at the end which does not give a complete PLMN id(length
+* MOD UBYTES_PER_PLMN_WITH_ACC_TECH > 0), ignore these additional bytes at the end
+*/
+mm_data->reg.sim_ucps_at_len = length-length%UBYTES_PER_PLMN_WITH_ACC_TECH;
+ucps_acctech_plmn_count = mm_data->reg.sim_ucps_at_len/UBYTES_PER_PLMN_WITH_ACC_TECH;
+reg_clear_plmn_list (mm_data->reg.pref_plmn, MAX_PREF_PLMN_ID);
+for( index=0; index < ucps_acctech_plmn_count; index++)
+{
+if(reg_read_plmn_support_acctec(&data[index*UBYTES_PER_PLMN_WITH_ACC_TECH]))
+{
+/*Check if PLMN entry is empty in the EF*/
+if(!reg_sim_ef_plmn_field_empty(&data[index*UBYTES_PER_PLMN_WITH_ACC_TECH]))
+{
+memcpy(&mm_data->reg.pref_plmn[plmn_count*UBYTES_PER_PLMN],
+&data[index*UBYTES_PER_PLMN_WITH_ACC_TECH], UBYTES_PER_PLMN);
+plmn_count++;
+}
+}
+if(plmn_count >= MAX_PREF_PLMN_ID)
+{
+/*MAX_PREF_PLMN_ID PLMN in pref_plmn list will be copied*/
+break;
+}
+}
+/*
+* Number of plmn copied in the pref_plmn list from the user
+* controlled PLMN selector with access technology list
+* delivered by the SIM card. This informaiont will be used during copy of
+* PLMN from Operator controlled PLMN selector with access technology list
+* delivered by the SIM card.
+*/
+mm_data->reg.sim_ucps_at_len = plmn_count*UBYTES_PER_PLMN;
+}
+/*
++--------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                           |
+| STATE   : code                ROUTINE : reg_read_plmn_support_acctec    |
++--------------------------------------------------------------------------+
+PURPOSE : This function tests whether plmn points to an access technology
+which is supported by the MS. Return TRUE if GSM access technology
+is supported else FALSE.
+*/
+GLOBAL BOOL reg_read_plmn_support_acctec (UBYTE* plmn_bytes)
+{
+/*
+* Check if GSM access technology is supported by the PLMN. Return TRUE
+* if supported else FALSE
+* Spec 11.11 v8.9.1 For each User/Operator controlled PLMN Selector with Access Technology
+* Byte 5th: 8th bit = 1: GSM access technology selected;
+* Byte 5th: 8th bit = 0: GSM access technology selected;
+*/
+return ((plmn_bytes[4] & 0x80) EQ 0x80);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_read_plmn_present    |
++--------------------------------------------------------------------+
+PURPOSE : This function tests whether plmn points to an PLMN already
+exists in the pref_plmn list. TRUE will be returned if plmn
+already exists in the pref_plmn list, otherwise FALSE.
+*/
+GLOBAL BOOL reg_read_plmn_present (UBYTE* plmn_bytes)
+{
+GET_INSTANCE_DATA;
+USHORT index;
+USHORT pref_plmn_count;
+pref_plmn_count = mm_data->reg.sim_ucps_at_len/UBYTES_PER_PLMN;
+for(index=0; index < pref_plmn_count; index++)
+{
+if(((mm_data->reg.pref_plmn[index*UBYTES_PER_PLMN] EQ plmn_bytes[0]) AND
+(mm_data->reg.pref_plmn[index*UBYTES_PER_PLMN+1] EQ plmn_bytes[1]) AND
+(mm_data->reg.pref_plmn[index*UBYTES_PER_PLMN+2] EQ plmn_bytes[2])))
+{
+return TRUE;
+}
+}
+return FALSE;
+}
+/*
++------------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                               |
+| STATE   : code                ROUTINE : reg_read_ocps_acctec                 |
++------------------------------------------------------------------------------+
+PURPOSE : Read Operator controlled PLMN selector with access technology list
+	    delivered by the SIM card. This can happens only after SIM insert
+	    indication indicates to read file from SIM.
+*/
+GLOBAL void reg_read_ocps_acctec(UBYTE* data, USHORT length)
+{
+GET_INSTANCE_DATA;
+USHORT index;
+USHORT plmn_count;
+USHORT ocps_acctech_plmn_count;
+TRACE_FUNCTION ("reg_read_ocps_acctec ()");
+/*
+* If any additional bytes at the end which does not give a complete PLMN id(length
+* MOD UBYTES_PER_PLMN_WITH_ACC_TECH > 0), ignore these additional bytes at the end
+*/
+mm_data->reg.sim_ocps_at_len = length-length%UBYTES_PER_PLMN_WITH_ACC_TECH;
+/*
+* Remember Number of plmn already copied in the pref_plmn list from the user
+* controlled PLMN selector with access technology list.
+*/
+plmn_count = mm_data->reg.sim_ucps_at_len/UBYTES_PER_PLMN;
+ocps_acctech_plmn_count = mm_data->reg.sim_ocps_at_len/UBYTES_PER_PLMN_WITH_ACC_TECH;
+for( index=0; index < ocps_acctech_plmn_count; index++)
+{
+/*Check if the PLMN supports GSM access technology*/
+if (reg_read_plmn_support_acctec(&data[index*UBYTES_PER_PLMN_WITH_ACC_TECH]))
+{
+/*Check if PLMN entry is empty in the EF*/
+if(!reg_sim_ef_plmn_field_empty(&data[index*UBYTES_PER_PLMN_WITH_ACC_TECH]))
+{
+/*Check if the PLMN is already present in the pref_plmn list*/
+if(!reg_read_plmn_present(&data[index*UBYTES_PER_PLMN_WITH_ACC_TECH]))
+{
+memcpy(&mm_data->reg.pref_plmn[plmn_count*UBYTES_PER_PLMN],
+&data[index*UBYTES_PER_PLMN_WITH_ACC_TECH], UBYTES_PER_PLMN);
+plmn_count++;
+}
+}
+if(plmn_count >= MAX_PREF_PLMN_ID)
+{
+/*MAX_PREF_PLMN_ID PLMN in pref_plmn list will be copied*/
+break;
+}
+}
+}
+}
+#endif
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_clear_plmn             |
++--------------------------------------------------------------------+
+PURPOSE : Clears a given PLMN.
+*/
+GLOBAL void reg_clear_plmn (T_plmn *plmn)
+{
+TRACE_FUNCTION ("reg_clear_plmn()");
+memset (plmn, 0x0F, sizeof (T_plmn));
+plmn->v_plmn = FALSE;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_clear_plmn_list        |
++--------------------------------------------------------------------+
+PURPOSE : Clears a given PLMN list. Returns TRUE if the function
+actually had to change data.
+*/
+GLOBAL BOOL reg_clear_plmn_list (UBYTE *plmn_list, USHORT list_size)
+{
+USHORT i;
+USHORT byte_count;
+TRACE_FUNCTION ("reg_clear_plmn_list()");
+byte_count = UBYTES_PER_PLMN * list_size;
+for (i = 0; i < byte_count; i++)
+{
+if (plmn_list[i] NEQ NOT_PRESENT_8BIT)
+{
+memset (plmn_list, NOT_PRESENT_8BIT, UBYTES_PER_PLMN * list_size);
+TRACE_EVENT ("list actually deleted");
+return TRUE; /* List has been changed */
+}
+}
+return FALSE; /* Nothing changed */
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_unpack_plmn            |
++--------------------------------------------------------------------+
+PURPOSE : Unpacks a PLMN from compressed form to uncompressed form.
+*/
+GLOBAL void reg_unpack_plmn (T_plmn *plmn, const UBYTE *packed, USHORT index)
+{
+/* TRACE_FUNCTION ("reg_unpack_plmn()"); */ /* Avoid too much traces */
+index *= UBYTES_PER_PLMN;
+plmn->mcc[0] = packed[index] & 0x0f;
+plmn->mcc[1] = packed[index] >> 4;
+index++;
+plmn->mcc[2] = packed[index] & 0x0f;
+plmn->mnc[2] = packed[index] >> 4;
+index++;
+plmn->mnc[0] = packed[index] & 0x0f;
+plmn->mnc[1] = packed[index] >> 4;
+index++;
+if ((plmn->mcc[0] & 0x0F) EQ 0x0F)
+plmn->v_plmn = V_PLMN_NOT_PRES;
+else
+plmn->v_plmn = V_PLMN_PRES;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_pack_plmn              |
++--------------------------------------------------------------------+
+PURPOSE : Packs a PLMN from uncompressed form to compressed form.
+*/
+GLOBAL void reg_pack_plmn (UBYTE *packed, USHORT index, const T_plmn *plmn)
+{
+/* TRACE_FUNCTION ("reg_pack_plmn()"); */ /* Avoid too much traces */
+index *= UBYTES_PER_PLMN;
+packed[index]  = plmn->mcc[1] << 4;
+packed[index] += plmn->mcc[0];
+index++;
+packed[index]  = plmn->mnc[2] << 4;
+packed[index] += plmn->mcc[2];
+index++;
+packed[index]  = plmn->mnc[1] << 4;
+packed[index] += plmn->mnc[0];
+index++;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_set_bcch_info          |
++--------------------------------------------------------------------+
+PURPOSE : Fill in the BCCH information in SIM_MM_UPDATE_REQ using
+the new data in the registration data structures.
+*/
+GLOBAL void reg_set_bcch_info (T_SIM_MM_UPDATE_REQ *sim_mm_update_req)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_set_bcch_info ()");
+if (!mm_normal_upd_needed())
+{
+if(memcmp(mm_data->reg.bcch, mm_data->mm.bcch, SIZE_BCCH))
+{
+/* Set bit 2 in ef_indicator to indicate bcch_info change to SIM */
+mm_data->ef_indicator|=(0x01 << 1);
+}
+memcpy (mm_data->reg.bcch, mm_data->mm.bcch, SIZE_BCCH);
+}
+sim_mm_update_req->bcch_inf.c_bcch = SIZE_BCCH;
+memcpy (sim_mm_update_req->bcch_inf.bcch, mm_data->reg.bcch, SIZE_BCCH);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_set_forb_plmns         |
++--------------------------------------------------------------------+
+PURPOSE : Fill the forbidden PLMN field in the SIM_MM_UPDATE_REQ
+primitive with the actual values in the MM data structures.
+*/
+GLOBAL void reg_set_forb_plmns (T_SIM_MM_UPDATE_REQ *sim_mm_update_req)
+{
+GET_INSTANCE_DATA;
+T_plmn forb_plmn;
+UBYTE sim_forb_plmn_list[MAX_SIM_FORB_PLMN_ID * UBYTES_PER_PLMN];
+USHORT i;
+TRACE_FUNCTION ("reg_set_forb_plmns ()");
+memcpy (sim_forb_plmn_list,
+mm_data->reg.forb_plmn,
+MAX_SIM_FORB_PLMN_ID * UBYTES_PER_PLMN);
+for (i = MAX_SIM_FORB_PLMN_ID; i < MAX_FORB_PLMN_ID; i++)
+{
+reg_unpack_plmn (&forb_plmn, mm_data->reg.forb_plmn, i);
+if (!reg_plmn_empty (&forb_plmn))
+{
+reg_plmn_add_bad (sim_forb_plmn_list,
+MAX_SIM_FORB_PLMN_ID,
+&forb_plmn);
+}
+}
+sim_mm_update_req->forb_plmn.c_forb = MAX_SIM_FORB_PLMN_ID * UBYTES_PER_PLMN;
+memcpy (sim_mm_update_req->forb_plmn.forb,
+sim_forb_plmn_list,
+MAX_SIM_FORB_PLMN_ID * UBYTES_PER_PLMN);
+#ifndef NTRACE
+for (i = 0; i < MAX_SIM_FORB_PLMN_ID; i++)
+{
+reg_unpack_plmn (&forb_plmn, sim_mm_update_req->forb_plmn.forb, i);
+TRACE_EVENT_P6 ("FORB = %x%x%x %x%x%x",
+forb_plmn.mcc[0],
+forb_plmn.mcc[1],
+forb_plmn.mcc[2],
+forb_plmn.mnc[0],
+forb_plmn.mnc[1],
+forb_plmn.mnc[2]);
+}
+#endif /* #ifndef NTRACE */
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_set_kc                 |
++--------------------------------------------------------------------+
+PURPOSE :
+*/
+GLOBAL void reg_set_kc (T_SIM_MM_UPDATE_REQ *sim_mm_update_req)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_set_kc ()");
+sim_mm_update_req->cksn = mm_data->reg.cksn;
+memcpy (sim_mm_update_req->kc, mm_data->reg.kc, MAX_KC);
+TRACE_EVENT_P1 ("CKSN = %d", mm_data->reg.cksn);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_set_loc_info           |
++--------------------------------------------------------------------+
+PURPOSE : Set the location information in the SIM_MM_UPDATE_REQ
+primitive to the actual values of the MM data structures.
+*/
+GLOBAL void reg_set_loc_info (T_SIM_MM_UPDATE_REQ *sim_mm_update_req)
+{
+GET_INSTANCE_DATA;
+ULONG tmsi_binary;
+TRACE_FUNCTION ("reg_set_loc_info ()");
+sim_mm_update_req->loc_info.c_loc = SIZE_LOC_INFO;
+tmsi_binary = mm_data->reg.tmsi;
+mm_mmgmm_tmsi_ind (tmsi_binary);
+sim_mm_update_req->loc_info.loc[0]  = (UBYTE)(tmsi_binary >> 24);
+sim_mm_update_req->loc_info.loc[1]  = (UBYTE)(tmsi_binary >> 16);
+sim_mm_update_req->loc_info.loc[2]  = (UBYTE)(tmsi_binary >> 8);
+sim_mm_update_req->loc_info.loc[3]  = (UBYTE)tmsi_binary;
+sim_mm_update_req->loc_info.loc[4]  = mm_data->reg.lai.mcc[1] << 4;
+sim_mm_update_req->loc_info.loc[4] += mm_data->reg.lai.mcc[0];
+sim_mm_update_req->loc_info.loc[5]  = mm_data->reg.lai.mnc[2] << 4;
+sim_mm_update_req->loc_info.loc[5] += mm_data->reg.lai.mcc[2];
+sim_mm_update_req->loc_info.loc[6]  = mm_data->reg.lai.mnc[1] << 4;
+sim_mm_update_req->loc_info.loc[6] += mm_data->reg.lai.mnc[0];
+sim_mm_update_req->loc_info.loc[7]  = mm_data->reg.lai.lac >> 8;
+sim_mm_update_req->loc_info.loc[8]  = mm_data->reg.lai.lac & 0xff;
+sim_mm_update_req->loc_info.loc[9]  = 0;
+sim_mm_update_req->loc_info.loc[10] = mm_data->reg.update_stat;
+sim_mm_update_req->cell_identity    = mm_data->mm.cid;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_send_sim_read_req      |
++--------------------------------------------------------------------+
+PURPOSE : This functions sends SIM_READ_REQ for the requested field
+Currently only used by function reg_read_next_sim_file
+*/
+LOCAL void reg_send_sim_read_req ( USHORT datafield,
+T_path_info *path_info_ptr,
+UBYTE act_length,
+UBYTE max_length )
+{
+GET_INSTANCE_DATA;
+PALLOC (read_req, SIM_READ_REQ);
+TRACE_FUNCTION ("mm_send_sim_read_req()");
+read_req->source = SRC_MM;
+/* req_id can be set to 0 as MM sends a SIM_READ_REQ only
+* when it gets the SIM_READ_CNF to the previous request */
+read_req->req_id = 0;
+read_req->offset = 0;
+if(path_info_ptr NEQ NULL)
+{
+read_req->v_path_info = TRUE;
+read_req->path_info = *path_info_ptr;
+}
+else
+{
+read_req->v_path_info = FALSE;
+}
+mm_data->sim_read_req_data_field = read_req->datafield = datafield;
+read_req->length = act_length;
+read_req->max_length = max_length;
+PSENDX (SIM, read_req);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_read_next_sim_file     |
++--------------------------------------------------------------------+
+PURPOSE : This functions requests the next changed, unread SIM file
+RETURN: TRUE if function call caused a pending SIM_READ_CNF
+FALSE otherwise
+*/
+GLOBAL BOOL reg_read_next_sim_file (void)
+{
+GET_INSTANCE_DATA;
+/* Definition used to determine sizeof() */
+T_SIM_MM_INSERT_IND *insert_ind;
+TRACE_FUNCTION ("reg_read_next_sim_file()");
+if (mm_data->reg.upd_sim_fplmn EQ SAT_READ_FILE)
+{
+/* Change of forbidden PLMN indicated */
+reg_send_sim_read_req (SIM_FPLMN, NULL, NOT_PRESENT_8BIT, sizeof (insert_ind->forb_plmn.forb));
+mm_data->reg.upd_sim_fplmn = SAT_PEND_CNF;
+return TRUE;
+}
+if (mm_data->reg.upd_sim_hplmn EQ SAT_READ_FILE)
+{
+/* Change of HPLMN search timer indicated */
+reg_send_sim_read_req (SIM_HPLMN, NULL, NOT_PRESENT_8BIT, sizeof (insert_ind->hplmn));
+mm_data->reg.upd_sim_hplmn = SAT_PEND_CNF;
+return TRUE;
+}
+#ifdef REL99
+/*updating status user controlled & operator controlled PLMN selection*/
+if (mm_data->reg.upd_sim_ucps_at EQ SAT_READ_FILE)
+{
+/*
+* Change of user controlled PLMN selector with access technology list indicated.
+* Max length in SIM READ REQ is sent to FF(255 which is a limitation in SIM READ REQ)instead
+* of MAX_PREF_PLMN because MM does not know how many PLMN in the EF are supported GSM access
+* technology.So MM will try to read as many as possible.
+* In future if MM want to read more than 255 byte for the same EF, MM implementation can
+* be extented to send more than one SIM READ REQ for same EF.
+*/
+reg_send_sim_read_req (SIM_UCPS_ACTEC, NULL, (UBYTE)mm_data->reg.sim_ucps_at_len, 0xFF);
+mm_data->reg.upd_sim_ucps_at = SAT_PEND_CNF;
+return TRUE;
+}
+if (mm_data->reg.upd_sim_ocps_at EQ SAT_READ_FILE)
+{
+/*
+* Read Operator controlled PLMN selector with access technology list.
+* Max length in SIM READ REQ is sent to FF(255 which is a limitation in SIM READ REQ)instead
+* of MAX_PREF_PLMN because MM does not know how many PLMN in the EF are supported GSM access
+* technology.So MM will try to read as much as possible.
+* In future if MM want to read more than 255 byte for the same EF, MM implementation can
+* be extented to send more than one SIM READ REQ for same EF.
+*/
+reg_send_sim_read_req (SIM_OCPS_ACTEC, NULL, (UBYTE)mm_data->reg.sim_ocps_at_len, 0xFF);
+mm_data->reg.upd_sim_ocps_at = SAT_PEND_CNF;
+return TRUE;
+}
+#endif
+if (mm_data->reg.upd_sim_acc EQ SAT_READ_FILE)
+{
+/* Change of access class indicated */
+reg_send_sim_read_req (SIM_ACC,NULL, NOT_PRESENT_8BIT, sizeof (insert_ind->acc_ctrl.acc));
+mm_data->reg.upd_sim_acc = SAT_PEND_CNF;
+return TRUE;
+}
+if (mm_data->reg.upd_sim_act_hplmn EQ SAT_READ_FILE)
+{
+/* Change of AHPLMN indicated */
+reg_send_sim_read_req (SIM_CING_AHPLMN,NULL,NOT_PRESENT_8BIT, sizeof (insert_ind->act_hplmn));
+mm_data->reg.upd_sim_act_hplmn = SAT_PEND_CNF;
+return TRUE;
+}
+if (mm_data->reg.upd_sim_plmnsel EQ SAT_READ_FILE)
+{
+/* Change of preferred PLMN list indicated */
+/*
+* EF PLMNsel will only be used if EFs EFPLMNwAcT & EFOPLMNwAcT are not used.
+* mm_data->reg.sim_uocps_at_used will only be true after successful sim read
+* cnf for EFs EFPLMNwAcT or EFOPLMNwAcT.
+*/
+#ifdef REL99
+if(mm_data->reg.sim_uocps_at_used EQ FALSE)
+{
+reg_send_sim_read_req (SIM_PLMNSEL,NULL, (UBYTE)mm_data->reg.sim_plmnsel_len, MAX_PREF_PLMN);
+mm_data->reg.upd_sim_plmnsel = SAT_PEND_CNF;
+return TRUE;
+}
+else
+{
+/*
+* No need to read EF PLMNsel because EFs EFPLMNwAcT and(or) EFOPLMNwAcT are being used.
+*/
+mm_data->reg.upd_sim_plmnsel = SAT_UNCHANGED;
+}
+#else
+reg_send_sim_read_req (SIM_PLMNSEL, NULL,(UBYTE)mm_data->reg.sim_plmnsel_len, MAX_PREF_PLMN);
+mm_data->reg.upd_sim_plmnsel = SAT_PEND_CNF;
+return TRUE;
+#endif
+}
+return FALSE;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                      |
+| STATE   : code                ROUTINE : reg_end_of_deregistration  |
++--------------------------------------------------------------------+
+PURPOSE : Indicate or confirm negative registration to MMI/GMM.
+The MM restart procedure may be performed.
+*/
+GLOBAL void reg_end_of_deregistration (UBYTE nreg_cause, UBYTE service)
+{
+GET_INSTANCE_DATA;
+BOOL mm_restart;
+TRACE_FUNCTION ("reg_end_of_deregistration()");
+/* Remember the MM restart condition */
+mm_restart = ((mm_data->reg.sim_insert_info NEQ NULL) AND
+(mm_data->nreg_cause EQ CS_SIM_REM));
+if (mm_data->reg.sim_insert_info NEQ NULL)
+{
+/* Insert the new SIM data and free primive */
+mm_clear_reg_data ();
+reg_copy_sim_data (mm_data->reg.sim_insert_info);
+PFREE (mm_data->reg.sim_insert_info);
+mm_data->reg.sim_insert_info = NULL;
+}
+if (mm_restart)
+{
+/*
+* End of MM restart procedure, re-register
+*/
+if (mm_data->reg.op.m EQ MODE_AUTO)
+{
+/*
+* Register in automatic mode
+*/
+mm_auto_net_reg ();
+}
+else
+{
+/*
+* Register in manual mode
+*/
+mm_data->reg.plmn_cnt = 0; /* Delete list of available PLMNs */
+mm_data->attempt_cnt = 0;
+mm_mmr_reg_req (FUNC_PLMN_SRCH);
+}
+}
+else
+{
+/*
+* This was no MM RESTART
+*/
+if (mm_data->nreg_request)
+{
+/*
+* The deregistration was requested by the MMI
+*/
+if (nreg_cause EQ CS_POW_OFF)
+{
+/* Hard switch off (AT+CFUN=0), delete SIM data physically */
+reg_init ();
+mm_data->limited_cause = MMCS_SIM_REMOVED; /* MMCS_SIM_INVAL_NOSIM */
+}
+mm_mmgmm_nreg_cnf (nreg_cause);
+}
+else
+{
+/*
+* This was a real SIM remove, the SIM has been pulled
+*/
+if (service EQ NO_SERVICE)
+{
+mm_mmgmm_nreg_ind (NREG_NO_SERVICE,
+SEARCH_NOT_RUNNING,
+FORB_PLMN_NOT_INCLUDED);
+}
+else
+{
+mm_mmgmm_nreg_ind (NREG_LIMITED_SERVICE,
+SEARCH_NOT_RUNNING,
+FORB_PLMN_NOT_INCLUDED);
+}
+}
+}
+#ifdef GPRS
+if (mm_data->gprs.sim_physically_removed)
+{
+mm_data->gprs.sim_physically_removed = FALSE;
+/* Delete registration data */
+reg_init ();
+}
+#endif /* GPRS */
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : reg_invalidate_upd_state   |
++--------------------------------------------------------------------+
+PURPOSE : This function invalidates the update state.
+*/
+#ifdef REL99
+GLOBAL void reg_invalidate_upd_state (UBYTE new_update_state, BOOL tmsi_cksn_kc_not_deleted)
+#else
+GLOBAL void reg_invalidate_upd_state (UBYTE new_update_state)
+#endif
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_invalidate_update_state()");
+/* No IMSI ATTACH neccessary anymore */
+if (mm_data->first_attach)
+{
+mm_data->first_attach_mem = mm_data->first_attach;
+mm_data->first_attach = FALSE;
+}
+/* No periodic update needed anymore, needing normal update now */
+mm_data->t3212_timeout = FALSE;
+/* Set new update state */
+mm_data->reg.update_stat = new_update_state;
+#ifdef REL99
+if(tmsi_cksn_kc_not_deleted EQ TRUE)
+{
+/*Dont delete LAI CKSN CKSN KC*/
+}
+else
+#endif
+{
+/* Delete TMSI */
+mm_data->reg.tmsi = TMSI_INVALID_VALUE;
+/* Delete LAI */
+mm_data->reg.lai.lac = LAC_INVALID_VALUE;
+/* Delete CKSN */
+mm_data->reg.cksn    = CKSN_RES;
+/* Delete also KC */
+memset (mm_data->reg.kc, 0xff, MAX_KC);
+}
+/* Delete BCCH information */
+memset (mm_data->reg.bcch, 0, SIZE_BCCH);
+/* Update all EFs on SIM */
+mm_data->ef_indicator = 0xFF;
+/* Write changed data to SIM */
+reg_build_sim_update ();
+/* added by TISH 0418 to write simloci to FFS */
+mm_write_simloci_to_ffs();
+mm_write_imsi_to_ffs();
+/* Check HPLMN timer state */
+reg_check_hplmn_tim (mm_data->reg.thplmn);
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_MM                              |
+| STATE   : code                ROUTINE : reg_select_network                 |
++----------------------------------------------------------------------------+
+PURPOSE : This function starts the network registration for the given PLMN.
+*/
+GLOBAL void reg_select_network (const T_plmn *plmn)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_select_network()");
+mm_data->reg.actual_plmn = *plmn; /* Struct copy */
+if (reg_plmn_empty(plmn))
+{
+if (mm_data->reg.update_stat EQ MS_UPDATED)
+{
+mm_data->reg.actual_plmn.v_plmn = TRUE;
+memcpy(mm_data->reg.actual_plmn.mcc, mm_data->reg.lai.mcc, SIZE_MCC);
+memcpy(mm_data->reg.actual_plmn.mnc, mm_data->reg.lai.mnc, SIZE_MNC);
+}
+else
+{
+/* If PLMN sent is 0xFF (PLMN not present in FFS) and MM Update Status
+* is MS_NOT_UPDATED, We send a error message to ACI */
+mm_mmgmm_nreg_ind(NREG_LIMITED_SERVICE,
+SEARCH_NOT_RUNNING,
+FORB_PLMN_NOT_INCLUDED);
+return;
+}
+}
+mm_data->attempt_cnt = 0;
+mm_mmr_reg_req (FUNC_PLMN_SRCH);
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_best_plmn_in_country           |
++----------------------------------------------------------------------------+
+PURPOSE : This function checks whether the given PLMN is the best PLMN
+in the country where the mobile is roaming.
+*/
+GLOBAL BOOL reg_best_plmn_in_country (const T_plmn *bcch_plmn)
+{
+GET_INSTANCE_DATA;
+T_plmn hplmn;
+USHORT i;
+TRACE_FUNCTION ("reg_best_plmn_in_country()");
+reg_extract_hplmn (&hplmn);
+/* fix for CT PTCRB- TC_26_7_4_5_4_6. HPLMN timer is not started only if
+bcch PLMN and HPLMN belong to same country and both are in equivalent PLMN list.
+Detailed analysis present in OMAPS00150594*/
+if (reg_same_country_plmn (bcch_plmn, &hplmn))
+{
+if (reg_plmn_equal_eqv (bcch_plmn, &hplmn))
+return TRUE; /* The PLMN is the HPLMN */
+else
+return FALSE; /* National roaming */
+}
+/* International roaming: Check the preferred PLMN list */
+for (i = 0; i < MAX_PREF_PLMN_ID; i++)
+{
+T_plmn pref_plmn;
+reg_unpack_plmn (&pref_plmn, mm_data->reg.pref_plmn, i);
+if (reg_same_country_plmn (bcch_plmn, &pref_plmn))
+return reg_plmn_equal_eqv (bcch_plmn, &pref_plmn);
+}
+return TRUE; /* For this country no entry exists */
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_check_hplmn_tim                |
++----------------------------------------------------------------------------+
+PURPOSE : This function checks whether:
+- the HPLMN timer has to be started (if not running)
+	      with the duration given as input parameter or
+- stopped.
+Time unit is decihour.
+*/
+GLOBAL void reg_check_hplmn_tim (UBYTE decihours)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_check_hplmn_tim()");
+/*
+* The HPLMN timer has to be started if all the conditions below are
+* fulfilled and is not running already. Otherwise, it has to be
+* stopped.
+* - Registration state is updated
+* - MS is roaming on a VPLMN
+* - Registration mode is automatic
+* - THPLMN Elementary File is not equal to zero
+*/
+if (mm_full_service_pplmn_scan())
+{
+if (mm_data->reg.op.m EQ M_AUTO AND
+mm_data->reg.thplmn NEQ 0 AND
+mm_data->reg.update_stat NEQ MS_LA_NOT_ALLOWED AND
+!reg_best_plmn_in_country (&mm_data->reg.actual_plmn))
+{
+/*
+* Period of HPLMN is controlled by EF_HPLMN file of the SIM.
+* According to TS 11.11 chapter 10.3.5 :
+*  0- no search attempt
+*  N- search attempts every N*6 min intervals (6 min to 8 hours)
+* For phase 1 SIM wehereby this EF is not available, a default
+* value of 1 hour shall be used according to TS 22.011
+* chapter 3.2.2.5. In G23 this is managed by SIM entity that
+* will force this default value within SIM_INSERT_IND.
+*/
+if (!TIMERACTIVE(T_HPLMN))
+{
+if (mm_data->first_attach_mem)
+{
+TRACE_EVENT_P1 ("Start initial HPLMN timer: %d min", 2);
+TIMERSTART(T_HPLMN, HPLMN_INITIAL_DELAY);
+}
+else
+{
+TRACE_EVENT_P1 ("Start HPLMN timer: %d", decihours);
+TIMERSTART(T_HPLMN, decihours * 360000);
+}
+}/* if timeractive*/
+}/*end if mm_data->reg.op.m eq*/
+else
+{
+reg_stop_hplmn_tim ();
+mm_data->first_attach_mem = FALSE;
+}
+}/* end if mm_full_service_pplmn,,,*/
+else
+{
+reg_stop_hplmn_tim();
+}
+/* Issue 31179  This timer is started for foreign mcc only for cingular */
+if( mm_data->reg.is_cingular_sim AND !mm_data->first_attach)
+{
+T_plmn   hplmn;
+reg_extract_hplmn (&hplmn);
+if(!TIMERACTIVE(T_HPLMN))
+{
+if(memcmp(&(mm_data->reg.actual_plmn.mcc[0]), &(hplmn.mcc[0]), SIZE_MCC) NEQ 0)
+{
+TRACE_EVENT_P1 ("Start HPLMN timer: %d", decihours);
+TIMERSTART(T_HPLMN, decihours * 360000);
+}
+}
+}
+return;
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_stop_hplmn_tim                 |
++----------------------------------------------------------------------------+
+PURPOSE : This function stops the HPLMN timer.
+*/
+GLOBAL void reg_stop_hplmn_tim (void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_stop_hplmn_tim()");
+TRACE_EVENT("Stop HPLMN timer");
+TIMERSTOP(T_HPLMN);
+mm_data->plmn_scan_mm = FALSE;
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_plmn_in_pref_list              |
++----------------------------------------------------------------------------+
+PURPOSE : This function returns TRUE if the PLMN belongs to the
+preferred list.
+*/
+GLOBAL BOOL reg_plmn_in_pref_list (const T_plmn *plmn)
+{
+GET_INSTANCE_DATA;
+USHORT i;
+TRACE_FUNCTION ("reg_plmn_in_pref_list()");
+for (i = 0; i < MAX_PREF_PLMN_ID; i++)
+{
+T_plmn pref_plmn;
+reg_unpack_plmn (&pref_plmn, mm_data->reg.pref_plmn, i);
+if (!reg_plmn_empty (&pref_plmn))
+{
+if (reg_plmn_equal_sim (plmn, &pref_plmn))
+return TRUE;
+}
+}
+return FALSE;
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_same_country_plmn              |
++----------------------------------------------------------------------------+
+PURPOSE : This function returns TRUE if both PLMN belongs to the
+same country, handling the special case of NA (several
+MCC).
+*/
+GLOBAL BOOL reg_same_country_plmn (const T_plmn *plmn1,
+const T_plmn *plmn2)
+{
+/* TRACE_FUNCTION ("reg_same_country_plmn()"); */ /* Avoid too much traces */
+if (reg_plmn_is_NA_plmn(plmn1))
+return (reg_plmn_is_NA_plmn(plmn2));
+else
+return (memcmp(&(plmn1->mcc[0]), &(plmn2->mcc[0]), SIZE_MCC) EQ 0);
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_check_plmn_search              |
++----------------------------------------------------------------------------+
+PURPOSE : This function checks whether a better PLMN has been found and,
+if so, starts automatic registration on this PLMN.
+In case the search has to be aborted for some reason (eg.
+MM is not in IDLE mode), the HPLMN search timer is started
+using a small value.
+*/
+GLOBAL void reg_check_plmn_search (USHORT cause,
+const T_RR_ABORT_IND *rr_abort_ind)
+{
+GET_INSTANCE_DATA;
+T_plmn plmn;
+BOOL success;
+TRACE_FUNCTION ("reg_check_plmn_search()");
+if (mm_data->plmn_scan_mm)
+{
+/*
+* A MM search was ongoing
+*/
+switch (cause)
+{
+case MMCS_PLMN_NOT_IDLE_MODE:
+TRACE_EVENT ("PLMN scan aborted");
+/*
+* PLMN scan has been aborted because not compatible with the
+* current activity of the MS. Restart timer with a small duration.
+* Bufferize / postpone this in a later implementation (Maybe).
+*/
+reg_check_hplmn_tim (HPLMN_REARM_DELAY);
+break;
+case MMCS_SUCCESS:
+/*
+* First we need to create the list of available PLMNs. We
+* are not interested in the ones belonging to a forbidden list
+* but we are still interested in the current RPLMN.
+* Criteria to start the PLMN selection will be:
+* 1) First PLMN in the list (higher priority) is not the RPLMN
+* 2) Either it is the HPLMN,
+*    Or it is an other PLMN, which belongs to the same country
+*    than the current VPLMN, and it belongs to the preferred
+*    list ie it has not been inserted here to the randomization
+*    of the PLMNs whose fieldstrength is higher than -85 dBm.
+*/
+reg_create_plmn_list (rr_abort_ind, WITH_RPLMN);
+success = FALSE;
+while (mm_data->reg.plmn_index < mm_data->reg.plmn_cnt)
+{
+reg_unpack_plmn (&plmn, mm_data->reg.plmn, mm_data->reg.plmn_index);
+if (reg_plmn_equal_sim (&plmn, &mm_data->reg.actual_plmn))
+{
+TRACE_EVENT ("VPLMN hit - cancel");
+break;
+}
+else if (reg_plmn_equal_hplmn (&plmn))
+{
+/* fix for TC 26.7.4.5.4.4. Select a PLMN of Same country
+and not HPLMN if in International roaming only for Test sim.*/
+if((mm_data->reg.op.ts EQ TS_NO_AVAIL) OR
+reg_same_country_plmn (&plmn, &mm_data->reg.actual_plmn))
+{
+TRACE_EVENT ("HPLMN found - success");
+success = TRUE;
+break;
+}
+else
+{
+mm_data->reg.plmn_index++;
+continue;
+}
+}
+else if (!reg_plmn_in_pref_list (&plmn))
+{
+TRACE_EVENT ("PPLMN list end - cancel");
+break;
+}
+else if(mm_data->reg.is_cingular_sim)
+{
+TRACE_EVENT ("better PLMN from HPLMN list in Cingular - success");
+success = TRUE;
+break;
+}
+else if (reg_same_country_plmn (&plmn, &mm_data->reg.actual_plmn))
+{
+TRACE_EVENT ("better PLMN same country - success");
+success = TRUE;
+break;
+}
+else
+mm_data->reg.plmn_index++;
+}
+if (success)
+{
+TRACE_EVENT ("PPLMN rescan pass");
+/*
+* An alternate network candidate has been found, so try to camp
+* on it. It the registration procedure fails, then the normal
+	   * automatic network selection procedure will apply.
+*/
+reg_select_network (&plmn); /*lint !e772 conceivably not initialized */
+}
+else
+{
+TRACE_EVENT ("PPLMN rescan failed");
+/*
+* PLMN rescan did not provide any interesting results,
+* so restart timer.
+*/
+reg_check_hplmn_tim (mm_data->reg.thplmn);
+}
+/*
+* Do not consider the forbidden PLMNs for MM's internal operation
+*/
+reg_create_plmn_list (rr_abort_ind, WITH_OTHER_PLMNS);
+break;
+case MMCS_SIM_REMOVED:
+/*
+* Not relevant for MM initiated search.
+*/
+break;
+default:
+TRACE_ERROR (UNEXPECTED_DEFAULT);
+break;
+}
+}
+mm_data->plmn_scan_mm  = FALSE;
+mm_data->plmn_scan_mmi = FALSE;
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_store_eqv_plmns                |
++----------------------------------------------------------------------------+
+PURPOSE : This function checks whether a received equivalent PLMN list
+matches an already stored list. If no match then the new
+equivalent PLMN list overwrites the currently stored list.
+*/
+BOOL reg_store_eqv_plmns(T_eqv_plmn_list *rx_eplmn_list, T_plmn *plmn)
+{
+GET_INSTANCE_DATA;
+U8 i=0, j=0;
+T_plmn local_plmn;
+UBYTE local_store[EPLMNLIST_SIZE*UBYTES_PER_PLMN];
+TRACE_FUNCTION ("reg_store_eqv_plmns()");
+if (rx_eplmn_list->c_eqv_plmn > EPLMNLIST_SIZE)
+{
+rx_eplmn_list->c_eqv_plmn = 0;
+TRACE_ERROR ("count out of range");
+return FALSE;
+}
+for (i=0; i < EPLMNLIST_SIZE - 1; i++)
+{
+/* Use 0xf as filler for 2 digit MNCs */
+if (rx_eplmn_list->eqv_plmn[i].c_mnc EQ (SIZE_MNC-1))
+rx_eplmn_list->eqv_plmn[i].mnc[SIZE_MNC-1] = 0xf;
+}
+/*Convert the new list into a MM-friendly format*/
+reg_pack_plmn(local_store, 0, plmn);
+for(i=0;i<EPLMNLIST_SIZE-1;i++)
+{
+memcpy(&local_plmn.mcc, &rx_eplmn_list->eqv_plmn[i].mcc, SIZE_MCC);
+memcpy(&local_plmn.mnc, &rx_eplmn_list->eqv_plmn[i].mnc, SIZE_MNC);
+reg_pack_plmn(local_store, i+1, &local_plmn);
+}
+if(memcmp(local_store, mm_data->reg.eqv_plmns.eqv_plmn_list, EPLMNLIST_SIZE*UBYTES_PER_PLMN))
+{
+/* The Equivalent PLMN list has changed */
+/*Initialise EPLMN storage*/
+memset (&mm_data->reg.eqv_plmns.eqv_plmn_list, 0xFF, EPLMNLIST_SIZE*UBYTES_PER_PLMN);
+/* Store Equivalent PLMNs */
+for(i=0,j=0;i<EPLMNLIST_SIZE;i++)
+{
+T_plmn new_plmn;
+reg_unpack_plmn(&new_plmn, local_store, i);
+/* Remove any forbidden PLMNs from the new EPLMN list */
+if(!reg_plmn_in_list(mm_data->reg.forb_plmn, MAX_FORB_PLMN_ID, &new_plmn))
+reg_pack_plmn(mm_data->reg.eqv_plmns.eqv_plmn_list, j++, &new_plmn);
+}
+return(TRUE);
+}
+return(FALSE);
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_read_acting_hplmn                 |
++----------------------------------------------------------------------------+
+PURPOSE : This function copies the AHPLMN value read from the SIM at poweron
+or after REFRESH command from network.
+*/
+GLOBAL void reg_read_acting_hplmn (const U8  acting_hplmn[])
+{
+GET_INSTANCE_DATA;
+mm_data->reg.acting_hplmn.mcc[0] = acting_hplmn[0] &0x0f;
+mm_data->reg.acting_hplmn.mcc[1] = acting_hplmn[0] >> 4;
+mm_data->reg.acting_hplmn.mcc[2] = acting_hplmn[1] &0x0f;
+mm_data->reg.acting_hplmn.mnc[2] = acting_hplmn[1] >>4;
+mm_data->reg.acting_hplmn.mnc[0] = acting_hplmn[2] &0x0f;
+mm_data->reg.acting_hplmn.mnc[1] = acting_hplmn[2] >>4;
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : valid_acting_hplmn                 |
++----------------------------------------------------------------------------+
+PURPOSE : This function checks whether a received AHPLMN has the
+same MCC as the True-HPLMN and if yes then checks the
+validity of the MNC digits. Thus it checks the validity
+of AHPLMN received.
+*/
+BOOL valid_acting_hplmn(T_plmn   *acting_hplmn)
+{
+GET_INSTANCE_DATA;
+T_plmn   hplmn;
+UINT  temp1=0x0F0F0F;
+/*This will be set to TRUE if AHPLMN is FFFFFF*/
+mm_data->reg.acting_hplmn_invalid = FALSE;
+TRACE_FUNCTION ("valid_acting_hplmn()");
+/* Extract HPLMN from IMSI and compare MCC of HPLMN and AHPLMN */
+reg_extract_hplmn(&hplmn);
+/* Check If the AHPLMN contains FFFFFF */
+if (!(memcmp(acting_hplmn->mcc,&temp1,SIZE_MCC) AND
+memcmp(acting_hplmn->mnc,&temp1,SIZE_MNC)))
+{
+mm_data->reg.acting_hplmn.v_plmn = V_PLMN_NOT_PRES;
+mm_data->reg.acting_hplmn_invalid = TRUE;
+return FALSE;
+}
+/* If MCC of HPLMN and AHPLMN differs invalidate AHPLMN */
+if ( memcmp(acting_hplmn->mcc,mm_data->reg.imsi_struct.id,3) )
+{
+mm_data->reg.acting_hplmn.v_plmn = V_PLMN_NOT_PRES;
+return FALSE;
+}
+if (acting_hplmn->mnc[0] EQ 0x0f OR
+acting_hplmn->mnc[1] EQ 0x0f )
+{
+mm_data->reg.acting_hplmn.v_plmn = V_PLMN_NOT_PRES;
+return FALSE;
+}
+else
+{
+/* 1. If True HPLMN has only 2 mnc digits ignore 3rd digit of mnc in AHPLMN
+even if exists
+2. If True HPLMN has mnc as 3 digits but AHPLMN has only 2 OR if any
+of the mnc digits are 0xff,invalidate the AHPLMN
+*/
+if (mm_data->reg.length_mnc EQ 2 )
+{
+acting_hplmn->mnc[2] = 0x0F;
+}
+else if(acting_hplmn->mnc[2] EQ 0xFF)
+{
+mm_data->reg.acting_hplmn.v_plmn = V_PLMN_NOT_PRES;
+return FALSE;
+}
+}/* else acting_hplmn->mnc */
+mm_data->reg.acting_hplmn.v_plmn = V_PLMN_PRES;
+return TRUE;
+}/* end of valid_acting_hplmn */
+/*
++----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                             |
+| STATE   : code                ROUTINE : reg_pack_plmn_fn.....              |
++----------------------------------------------------------------------------+
+PURPOSE : This function packs a PLMN.
+*/
+LOCAL void reg_pack_plmn_fn (USHORT               i,
+const T_RR_ABORT_IND *rr_abort_ind)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("reg_pack_plmn_fn()");
+reg_pack_plmn (mm_data->reg.plmn, mm_data->reg.plmn_cnt,
+&rr_abort_ind->plmn[i]);
+mm_data->reg.plmn_rx[mm_data->reg.plmn_cnt] = rr_abort_ind->rxlevel[i];
+mm_data->reg.plmn_lac[mm_data->reg.plmn_cnt] = rr_abort_ind->lac_list[i]; /* LOL 02.01.2003: added for EONS support */
+mm_data->reg.plmn_cnt++;
+}/*reg_pack_plmn_fn*/
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : MM_REG                     |
+| STATE   : code                ROUTINE : check_if_cingular_sim      |
++--------------------------------------------------------------------+
+PURPOSE : This function checks whether inserted sim belong to
+Cingular Network.cingular_plmn_list contains the entire mcc and mnc of
+Cingular Network. Issue 31179
+*/
+GLOBAL void check_if_cingular_sim(void)
+{
+GET_INSTANCE_DATA;
+USHORT plmn_index;
+T_plmn   hplmn;
+reg_extract_hplmn (&hplmn);
+for(plmn_index = 0; plmn_index < MAX_CINGULAR_PLMN; plmn_index++)
+{
+if(reg_plmn_equal_sim (&hplmn, &cingular_plmn_list[plmn_index]))
+{
+mm_data->reg.is_cingular_sim = TRUE;
+break;
+}
+}
+}

FreeCalypso > hg > freecalypso-citrine

comparison g23m-gsm/mm/mm_regf.c @ 0:75a11d740a02