diff g23m/condat/ms/src/aci/cmh_simf.c @ 0:509db1a7b7b8

initial import: leo2moko-r1
author Space Falcon <falcon@ivan.Harhan.ORG>
date Mon, 01 Jun 2015 03:24:05 +0000
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/g23m/condat/ms/src/aci/cmh_simf.c	Mon Jun 01 03:24:05 2015 +0000
@@ -0,0 +1,2871 @@
+/*  
++-----------------------------------------------------------------------------
+|  Project :  GSM-PS (6147)
+|  Modul   :  CMH_SIMF
++-----------------------------------------------------------------------------
+|  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 module defines the functions used by the commad
+|             handler for the subscriber identity module.
++-----------------------------------------------------------------------------
+*/
+
+#ifndef CMH_SIMF_C
+#define CMH_SIMF_C
+#endif
+
+#include "aci_all.h"
+/*==== INCLUDES ===================================================*/
+#include "aci_cmh.h"
+#include "ati_cmd.h"
+#include "aci_cmd.h"
+#include "pcm.h"
+
+#ifdef DTI
+#include "dti.h"
+#include "dti_conn_mng.h"
+#endif
+
+#ifdef FAX_AND_DATA
+#include "aci_fd.h"
+#endif    /* of #ifdef FAX_AND_DATA */
+
+#include "aci.h"
+#include "psa.h"
+#include "psa_sim.h"
+#include "psa_cc.h"
+#include "psa_sat.h"
+#include "psa_mm.h"
+#include "psa_util.h"
+#include "cmh.h"
+#include "cmh_sim.h"
+#include "cmh_mm.h"
+#include "phb.h"
+#ifdef SIM_PERS
+#include "aci_ext_pers.h"
+#include "aci_slock.h"
+#include "general.h"  // inluded for UINT8 compilation error in sec_drv.h
+#include "sec_drv.h"
+
+ EXTERN  T_ACI_SIM_CONFIG aci_slock_sim_config;
+ EXTERN T_SEC_DRV_CONFIGURATION *cfg_data;
+#endif
+
+EXTERN T_SIM_MMI_INSERT_IND *last_sim_mmi_insert_ind;
+/* #include "m_cc.h" */
+
+/*==== CONSTANTS ==================================================*/
+
+/*==== TYPES ======================================================*/
+
+/*==== EXPORT =====================================================*/
+
+/*==== VARIABLES ==================================================*/
+const UBYTE PLMNselEmpty[] = { 0xFF, 0xFF, 0xFF };
+#ifdef SIM_PERS_OTA
+UBYTE nw_ctrl_key[9], nw_subset_ctrl_key[9], sp_ctrl_key[9], corp_ctrl_key[9];
+#define MAX_DCK_LEN 16 
+#endif
+
+/*==== FUNCTIONS ==================================================*/
+void cmhSIM_Read_AD_cb(SHORT table_id);
+void cmhSIM_Get_CSP_cb(SHORT table_id);
+void cmhSIM_Read_CSP_cb(SHORT table_id);
+#ifdef SIM_PERS_OTA
+void cmhSIM_Read_DCK_cb(SHORT table_id);
+void cmhSIM_Read_DCK_init_cb(SHORT table_id);
+void cmhSIM_WriteDefaultValue_DCK_cb(SHORT table_id);
+#endif
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SIM                 |
+|                                 ROUTINE : cmhSIM_FillInPIN        |
++-------------------------------------------------------------------+
+
+  PURPOSE : fill in the PIN into the PIN field of size length and
+            stuff unused chars with 0xFF.
+
+*/
+
+GLOBAL void cmhSIM_FillInPIN ( CHAR * PINStr, CHAR * PINFld, UBYTE len )
+{
+  UBYTE idx;
+
+  strncpy( PINFld, PINStr, len );
+
+  for( idx = strlen( PINStr ); idx < len; idx++ )
+  {
+    PINFld[idx] = NOT_PRESENT_CHAR;
+  }
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SIM                 |
+|                                 ROUTINE : cmhSIM_GetHomePLMN      |
++-------------------------------------------------------------------+
+
+  PURPOSE : Extract home PLMN out of the IMSI.
+
+*/
+
+GLOBAL void cmhSIM_GetHomePLMN ( SHORT * mccBuf, SHORT * mncBuf )
+{
+  UBYTE digit;        /* holds 4bit digit */
+  UBYTE i;            /* holds counter */
+
+  if( simShrdPrm.imsi.c_field EQ 0 )
+  {
+    /*
+     * No SIM present
+     */
+    *mccBuf = *mncBuf = -1;
+  }
+  else
+  {
+    /*
+     * SIM present
+     */
+    *mccBuf = *mncBuf = 0;
+
+    /* Convert MCC and MNC. */
+    for (i = 0; i < SIZE_MCC + SIZE_MNC; i++)
+    {
+      digit = (i & 1) ?
+        (simShrdPrm.imsi.field[(i + 1)/2] & 0x0f) :
+        (simShrdPrm.imsi.field[(i + 1)/2] & 0xf0) >> 4;
+      if (i < SIZE_MCC)
+        *mccBuf = (*mccBuf << 4) | digit;
+      else
+        *mncBuf = (*mncBuf << 4) | digit;
+    }
+    /* The only 3 digit mnc codes that are valid are the values between 310 and 316 */
+    if ((*mccBuf >= 0x310) AND (*mccBuf <= 0x316)
+        OR  simShrdPrm.mnc_len EQ 3)
+    {
+      /* used in the US - mcc = 0x310 */
+    }
+    /* Set the third digit of the MNC to 'F' if the SIM indicates a 2-digit MNC country */
+    else /* if (simShrdPrm.mnc_len EQ 2) */
+    {
+      /* The MS digit of the mnc is not valid, so replace the LSB it with 0xF. */
+      *mncBuf |= 0x00F;
+    }
+  }
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_MM                  |
+|                                 ROUTINE : cmhSIM_plmn_equal_sim   |
++-------------------------------------------------------------------+
+
+  PURPOSE : Return TRUE if the PLMN received equals the PLMN 
+            stored on the SIM.
+            This is not exactly the algorithm as shown for HPLMN 
+            matching as shown in 03.22 Normative Annex A, this version
+            here is more universal.            
+
+*/
+
+GLOBAL BOOL cmhSIM_plmn_equal_sim (SHORT bcch_mcc, SHORT bcch_mnc, 
+                                   SHORT  sim_mcc, SHORT  sim_mnc)
+{
+  /*TRACE_FUNCTION ("cmhSIM_plmn_equal_sim()");*/
+
+  /* Check MCC */
+  if (sim_mcc NEQ bcch_mcc)
+    return FALSE;
+
+  /* Check first 2 MNC digits */
+  if ((sim_mnc & 0xff0) NEQ (bcch_mnc & 0xff0))
+    return FALSE;
+
+  /* Check for full match */
+  if ((sim_mnc & 0xf) EQ (bcch_mnc & 0xf))
+    return TRUE;
+
+  /* The 3rd digit of the MNC differs */
+  if ((bcch_mcc >= 0x310) AND (bcch_mcc <= 0x316)
+      OR simShrdPrm.mnc_len EQ 3)
+  {
+    /* 
+     * The MCC is in the range 310..316, this means North America.
+     * The zero suffix rule applies.
+     */
+    return ((((sim_mnc & 0xf) EQ 0xf) AND ((bcch_mnc & 0xf) EQ 0x0)) OR
+            (((sim_mnc & 0xf) EQ 0x0) AND ((bcch_mnc & 0xf) EQ 0xf)));
+  }
+  return ((bcch_mnc & 0xf) EQ 0xf);
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_MM                  |
+|                                 ROUTINE : cmhSIM_plmn_is_hplmn    |
++-------------------------------------------------------------------+
+
+  PURPOSE : Return TRUE if the PLMN received is the HPLMN, otherwise
+            return FALSE.
+
+*/
+
+GLOBAL BOOL cmhSIM_plmn_is_hplmn (SHORT bcch_mcc, SHORT bcch_mnc)
+{
+  SHORT sim_mcc;              /* Holds the MCC of the HPLMN from the SIM */
+  SHORT sim_mnc;              /* Holds the MNC of the HPLMN from the SIM */
+
+  TRACE_FUNCTION ("cmhSIM_plmn_is_hplmn()");
+
+  if(!cmhMM_GetActingHPLMN(&sim_mcc, &sim_mnc))/*Enhancement Acting HPLMN*/
+  {
+    /* Extract the HPLMN identification out of the IMSI digits. */
+    cmhSIM_GetHomePLMN (&sim_mcc, &sim_mnc);
+  }
+
+  return cmhSIM_plmn_equal_sim (bcch_mcc, bcch_mnc, sim_mcc, sim_mnc);
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SIM                 |
+|                                 ROUTINE : cmhSIM_GetCmeFromSim    |
++-------------------------------------------------------------------+
+
+  PURPOSE : Mapping of SIM error code to ACI error code.
+
+*/
+GLOBAL T_ACI_CME_ERR cmhSIM_GetCmeFromSim ( USHORT errCode )
+{
+  switch ( errCode )
+  {
+    case SIM_NO_ERROR:
+      return CME_ERR_NotPresent;
+
+    case SIM_CAUSE_PIN1_EXPECT:
+      return CME_ERR_SimPinReq;
+
+    case SIM_CAUSE_PIN2_EXPECT:
+      return CME_ERR_SimPin2Req;
+
+    case SIM_CAUSE_PUK1_EXPECT:
+      return CME_ERR_WrongPasswd;
+    case SIM_CAUSE_PIN1_BLOCKED:
+      return CME_ERR_SimPukReq;
+
+    case SIM_CAUSE_PUK2_EXPECT:
+      return CME_ERR_WrongPasswd;
+    case SIM_CAUSE_PIN2_BLOCKED:
+      return CME_ERR_SimPuk2Req;
+
+    case SIM_CAUSE_PUK1_BLOCKED:
+    case SIM_CAUSE_PUK2_BLOCKED:
+      return CME_ERR_SimWrong;
+
+    case SIM_CAUSE_NO_SELECT:
+    case SIM_CAUSE_UNKN_FILE_ID:
+      return CME_ERR_NotFound;
+
+    case SIM_CAUSE_EF_INVALID:
+      return CME_ERR_OpNotSupp;
+
+    case SIM_CAUSE_ADDR_WRONG:
+      return CME_ERR_InvIdx;
+
+    case SIM_CAUSE_CMD_INCONSIST:
+    case SIM_CAUSE_MAX_INCREASE:
+    case SIM_CAUSE_CHV_NOTSET:
+    case SIM_CAUSE_CHV_VALIDATED:
+      return CME_ERR_OpNotAllow;
+
+    case SIM_CAUSE_ACCESS_PROHIBIT:
+      return CME_ERR_WrongPasswd;
+
+    case SIM_CAUSE_CARD_REMOVED:
+    case SIM_CAUSE_DRV_NOCARD:
+      return CME_ERR_SimNotIns;
+
+    case SIM_CAUSE_CLA_WRONG:
+    case SIM_CAUSE_INS_WRONG:
+    case SIM_CAUSE_P1P2_WRONG:
+    case SIM_CAUSE_P3_WRONG:
+    case SIM_CAUSE_PARAM_WRONG:
+      return CME_ERR_PhoneFail;
+
+    case SIM_CAUSE_SAT_BUSY:
+      return CME_ERR_SimBusy;
+
+    case SIM_CAUSE_DNL_ERROR:
+      return CME_ERR_Unknown;
+
+    case SIM_CAUSE_DRV_TEMPFAIL:
+      return CME_ERR_SimFail;
+
+    default:
+      if (GET_CAUSE_DEFBY(errCode) EQ DEFBY_CONDAT AND
+          GET_CAUSE_ORIGSIDE(errCode) EQ ORIGSIDE_MS)
+      {
+        return CME_ERR_Unknown;
+      }
+      return CME_ERR_Unknown;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SIMF           |
+| STATE   : code                        ROUTINE : cmhSIM_getUserRate |
++--------------------------------------------------------------------+
+
+  PURPOSE :
+*/
+GLOBAL T_ACI_BS_SPEED cmhSIM_GetUserRate ( UBYTE userRate )
+{
+  switch( userRate )
+  {
+    case ( UR_0_3_KBIT        ): return BS_SPEED_300_V110;
+    case ( UR_1_2_KBIT        ): return BS_SPEED_1200_V110;
+    case ( UR_2_4_KBIT        ): return BS_SPEED_2400_V110;
+    case ( UR_4_8_KBIT        ): return BS_SPEED_4800_V110;
+    case ( UR_9_6_KBIT        ): return BS_SPEED_9600_V110;
+    case ( UR_1_2_KBIT_V23    ): return BS_SPEED_1200_75_V23;
+    case ( UR_12_0_KBIT_TRANS ):
+    default:                     return BS_SPEED_NotPresent;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)           MODULE  : CMH_SIMF              |
+| STATE   : code                     ROUTINE : cmhSIM_getSrvFromSync |
++--------------------------------------------------------------------+
+
+  PURPOSE :
+*/
+GLOBAL T_ACI_CNUM_SERV cmhSIM_GetSrvFromSync ( UBYTE sync )
+{
+  switch( sync )
+  {
+    case ( ASYNCHRONOUS ): return CNUM_SERV_Asynch;
+    case ( SYNCHRONOUS  ): return CNUM_SERV_Synch;
+    default:               return CNUM_SERV_NotPresent;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_getSrvFromItc |
++--------------------------------------------------------------------+
+
+  PURPOSE :
+*/
+GLOBAL T_ACI_CNUM_SERV cmhSIM_GetSrvFromItc ( UBYTE itc )
+{
+  switch( itc )
+  {
+    case ( ITC_SPEECH      ): return CNUM_SERV_Voice;
+    case ( ITC_FAX_GROUP_3 ): return CNUM_SERV_Fax;
+    default:                  return CNUM_SERV_NotPresent;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SIMF           |
+| STATE   : code                        ROUTINE : cmhSIM_getUserRate |
++--------------------------------------------------------------------+
+
+  PURPOSE :
+*/
+GLOBAL T_ACI_CNUM_ITC cmhSIM_GetItc ( UBYTE itc )
+{
+  switch( itc )
+  {
+    case ( ITC_DIGITAL_UNRESTRICTED ): return CNUM_ITC_Udi;
+    case ( ITC_AUDIO                ): return CNUM_ITC_3_1_kHz;
+    default:                           return CNUM_ITC_NotPresent;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)          MODULE  : CMH_SIMF               |
+| STATE   : code                    ROUTINE : cmhSIM_getMncMccFrmPLMNsel |
++--------------------------------------------------------------------+
+
+  PURPOSE : get MNC and MCC out of EF PLMNsel entry
+*/
+
+GLOBAL void cmhSIM_getMncMccFrmPLMNsel(const UBYTE *ntry,
+                                             SHORT *mcc,
+                                             SHORT *mnc )
+{
+  if (memcmp (ntry, PLMNselEmpty, sizeof(PLMNselEmpty)) EQ 0)
+  {
+    *mcc = *mnc = -1;
+  }
+  else
+  {
+    *mcc  = ( ntry[0]       & 0x0f) << 8;
+    *mcc |= ((ntry[0] >> 4) & 0x0f) << 4;
+    *mcc |= ( ntry[1]       & 0x0f);
+    *mnc  = ( ntry[2]       & 0x0f) << 8;
+    *mnc |= ((ntry[2] >> 4) & 0x0f) << 4;
+    *mnc |= ((ntry[1] >> 4) & 0x0f);
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)          MODULE  : CMH_SIMF               |
+| STATE   : code                    ROUTINE : cmhSIM_GetCodedPLMN    |
++--------------------------------------------------------------------+
+
+  PURPOSE : Code MNC and MCC according a EF PLMNsel entry
+*/
+
+GLOBAL BOOL cmhSIM_GetCodedPLMN( const CHAR *oper, T_ACI_CPOL_FRMT format,
+                                 UBYTE *sim_plmn )
+{
+  T_OPER_ENTRY operDesc;     /* operator description */
+  BOOL found;
+
+  /* get MNC and MCC */
+  switch( format )
+  {
+    case( CPOL_FRMT_Long ):
+      found = cmhMM_FindName( &operDesc, oper, COPS_FRMT_Long );
+      break;
+    case( CPOL_FRMT_Short ):
+      found = cmhMM_FindName( &operDesc, oper, COPS_FRMT_Short );
+      break;
+    case( CPOL_FRMT_Numeric ):
+      found = cmhMM_FindNumeric( &operDesc, oper );
+      break;
+    default:
+      return( FALSE );
+  }
+
+  if( !found )
+    return( FALSE );
+
+  /* code MCC and MNC */
+  sim_plmn[0]  = (operDesc.mcc & 0xf00) >> 8;
+  sim_plmn[0] |= (operDesc.mcc & 0x0f0)     ;
+  sim_plmn[1]  = (operDesc.mcc & 0x00f)     ;
+  sim_plmn[1] |= (operDesc.mnc & 0x00f) << 4;
+  sim_plmn[2]  = (operDesc.mnc & 0xf00) >> 8;
+  sim_plmn[2] |= (operDesc.mnc & 0x0f0)     ;
+
+  return( TRUE );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)          MODULE  : CMH_SIMF               |
+| STATE   : code                    ROUTINE : cmhSIM_FillPlmnSelList |
++--------------------------------------------------------------------+
+
+  PURPOSE : Fills in the CPOL list out of EF PLMNsel and returns the
+            last written index.
+*/
+GLOBAL SHORT cmhSIM_FillPlmnSelList ( UBYTE              index,
+                                      T_ACI_CPOL_FRMT    frmt,
+                                      T_ACI_CPOL_OPDESC* operLst,
+                                      UBYTE              length,
+                                      UBYTE*             pData   )
+{
+  BOOL  found;            /* cmhMM_FindXXX found an entry */
+  UBYTE idx;              /* holds list index */
+  SHORT off;              /* holds PLMNsel offset */
+  SHORT lastIdx;          /* holds last index written to list */
+  SHORT mcc;              /* holds mcc value */
+  SHORT mnc;              /* holds mnc value */
+  T_OPER_ENTRY OpDsc;     /* operator description */
+
+/*
+ *-----------------------------------------------------------------
+ * calculate PLMNsel offset
+ *-----------------------------------------------------------------
+ */
+  off = (index-1) * ACI_LEN_PLMN_SEL_NTRY;
+
+/*
+ *-----------------------------------------------------------------
+ * fill the preferred operator list
+ *-----------------------------------------------------------------
+ */
+  idx = 0;
+  lastIdx = ACI_NumParmNotPresent;
+
+  do
+  {
+    /* get mnc and mcc out of PLMNsel field */
+    cmhSIM_getMncMccFrmPLMNsel( (pData+off), &mcc, & mnc );
+
+    /* end of PLMNsel field */
+    if( off >= length )
+    {
+      operLst[idx].index   = ACI_NumParmNotPresent;
+      operLst[idx].format  = CPOL_FRMT_NotPresent;
+      operLst[idx].oper[0] = 0x0;
+      break;
+    }
+
+    /* valid entry */
+    if( !(mcc < 0 AND mnc < 0) )
+    {
+      operLst[idx].index  = index;
+      operLst[idx].format = frmt;
+
+      found = cmhMM_FindPLMN( &OpDsc, mcc, mnc, NOT_PRESENT_16BIT, FALSE);
+
+      switch( frmt )
+      {
+        case( CPOL_FRMT_Long ):
+          if (OpDsc.pnn)
+          {
+            if (OpDsc.long_len)
+            {
+              switch (OpDsc.long_ext_dcs>>4 & 0x07)
+              {
+                case 0x00:
+                  utl_cvtPnn7To8((UBYTE *)OpDsc.longName,
+                                          OpDsc.long_len,
+                                          OpDsc.long_ext_dcs,
+                                 (UBYTE *)operLst[idx].oper);
+                  break;
+                case 0x01:
+                  TRACE_ERROR ("ERROR: Unhandled UCS2");
+                  break;
+                default:
+                  TRACE_ERROR ("ERROR: Unknown DCS");
+                  break;
+              }
+            }
+            else
+            {
+              operLst[idx].oper[0] = '\0';
+            }
+          }
+          else
+          {
+            /* MAX_LONG_OPER_LEN <= MAX_ALPHA_OPER_LEN, no length check needed */
+            strcpy( operLst[idx].oper, OpDsc.longName );
+          } 
+          break;
+
+        case( CPOL_FRMT_Short ):
+          if (OpDsc.pnn)
+          {
+            if (OpDsc.shrt_len)
+            {
+              switch (OpDsc.shrt_ext_dcs>>4 & 0x07)
+              {
+                case 0x00:
+                  utl_cvtPnn7To8((UBYTE *)OpDsc.shrtName,
+                                          OpDsc.shrt_len,
+                                          OpDsc.shrt_ext_dcs,
+                                 (UBYTE *)operLst[idx].oper);
+                  break;
+                case 0x01:
+                  TRACE_ERROR ("ERROR: Unhandled UCS2");
+                  break;
+                default:
+                  TRACE_ERROR ("ERROR: Unknown DCS");
+                  break;
+              }
+            }
+            else
+            {
+              operLst[idx].oper[0] = '\0';
+            }
+          }
+          else
+          {
+            /* MAX_SHRT_OPER_LEN <= MAX_ALPHA_OPER_LEN, no length check needed */
+            strcpy( operLst[idx].oper, OpDsc.shrtName );
+          }
+          break;
+
+        case( CPOL_FRMT_Numeric ):
+          if ((mnc & 0x00F) EQ 0xF)
+            sprintf (operLst[idx].oper, "%03X%02X", mcc, (mnc & 0xff0) >> 4);
+          else
+            sprintf (operLst[idx].oper, "%03X%03X", mcc, mnc);
+          break;
+      }
+      idx++;
+      lastIdx = index;
+    }
+
+    off += ACI_LEN_PLMN_SEL_NTRY;
+    index++;
+
+  } while( idx < MAX_OPER );
+
+  return( lastIdx );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)          MODULE  : CMH_SIMF               |
+| STATE   : code                    ROUTINE : cmhSIM_UsdPlmnSelNtry  |
++--------------------------------------------------------------------+
+
+  PURPOSE : Counts the used entries of the preferred PLMN list and
+            returns the number of used entries.
+*/
+GLOBAL SHORT cmhSIM_UsdPlmnSelNtry ( UBYTE              length,
+                                     UBYTE*             pData   )
+{
+  UBYTE idx;              /* holds list index */
+  SHORT off;              /* holds PLMNsel offset */
+  UBYTE maxNtry;          /* holds the maximum number of entries */
+  SHORT used;             /* holds number of used entries */
+  SHORT mcc;              /* holds mcc value */
+  SHORT mnc;              /* holds mnc value */
+
+/*
+ *-----------------------------------------------------------------
+ * count the used entries
+ *-----------------------------------------------------------------
+ */
+  maxNtry = length / ACI_LEN_PLMN_SEL_NTRY;
+
+  for( idx = 0, used = 0, off = 0;
+       idx < maxNtry;
+       idx++, off += ACI_LEN_PLMN_SEL_NTRY )
+  {
+    /* get mnc and mcc out of PLMNsel field */
+    cmhSIM_getMncMccFrmPLMNsel( (pData+off), &mcc, & mnc );
+
+    /* valid entry */
+    if( !(mcc < 0 AND mnc < 0) )
+    {
+      used++;
+    }
+  }
+
+  return( used );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)          MODULE  : CMH_SIMF               |
+| STATE   : code                    ROUTINE : cmhSIM_CmpctPlmnSel    |
++--------------------------------------------------------------------+
+
+  PURPOSE : Shoves entries of preferred PLMN list to remove empty
+            entries of the list.
+*/
+GLOBAL void cmhSIM_CmpctPlmnSel ( UBYTE length, UBYTE* pData )
+{
+  UBYTE  maxNtry;          /* holds the maximum number of entries */
+  UBYTE  lstIdx;           /* holds list index */
+  UBYTE* dstNtry;          /* points to destination entry index */
+
+/*
+ *-----------------------------------------------------------------
+ * compact the list
+ *-----------------------------------------------------------------
+ */
+  lstIdx  = 0;
+  dstNtry = pData;
+
+  maxNtry = length / ACI_LEN_PLMN_SEL_NTRY;
+
+  while( lstIdx < maxNtry )
+  {
+    if(memcmp( pData, PLMNselEmpty, sizeof(PLMNselEmpty)))
+    {
+      if( pData NEQ dstNtry )
+      {
+        memcpy( dstNtry, pData, ACI_LEN_PLMN_SEL_NTRY );
+        memcpy( pData, PLMNselEmpty, ACI_LEN_PLMN_SEL_NTRY);
+      }
+      dstNtry += ACI_LEN_PLMN_SEL_NTRY;
+    }
+    lstIdx++;
+    pData += ACI_LEN_PLMN_SEL_NTRY;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SIMS           |
+| STATE   : code                        ROUTINE : cmhSIM_ReqPlmnSel  |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function starts reading of EF PLMN SEL from SIM.
+*/
+GLOBAL T_ACI_RETURN cmhSIM_ReqPlmnSel ( T_ACI_CMD_SRC srcId )
+{
+  T_ACI_RETURN ret       = AT_FAIL;
+  SHORT        table_id;
+
+  TRACE_FUNCTION ("cmhSIM_ReqPlmnSel()");
+
+/*
+ *-----------------------------------------------------------------
+ * request table id for SIM SAP access
+ *-----------------------------------------------------------------
+ */
+  table_id = psaSIM_atbNewEntry();
+
+  if(table_id NEQ NO_ENTRY)
+  {
+    simShrdPrm.atb[table_id].accType      = ACT_RD_DAT;
+    simShrdPrm.atb[table_id].reqDataFld   = SIM_PLMNSEL;
+    simShrdPrm.atb[table_id].dataOff      = 0;
+    /* length is variable */
+    simShrdPrm.atb[table_id].dataLen      = NOT_PRESENT_8BIT;
+    simShrdPrm.atb[table_id].recMax       = ACI_LEN_PLMN_SEL_FLD;
+    simShrdPrm.atb[table_id].ntryUsdFlg   = TRUE;
+    simShrdPrm.atb[table_id].exchData     = CPOLSimEfData;
+    simShrdPrm.atb[table_id].rplyCB       = cmhSIM_RdCnfPlmnSel;
+
+    simShrdPrm.aId = table_id;
+
+    simEntStat.curCmd = AT_CMD_CPOL;
+    simEntStat.entOwn = simShrdPrm.owner = srcId;
+
+    if(psaSIM_AccessSIMData() < 0)
+    {
+      TRACE_EVENT("FATAL ERROR psaSIM in +CPOL");
+      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
+    }
+    else
+    {
+      ret = AT_EXCT;
+    }
+  }
+
+  return ( ret );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SIMS           |
+| STATE   : code                        ROUTINE : cmhSIM_UpdPlmnSel  |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function updates the indexed EF PLMN SEL entry and
+            writes the field to the SIM.
+*/
+GLOBAL T_ACI_RETURN cmhSIM_UpdPlmnSel ( T_ACI_CMD_SRC srcId,
+                                        SHORT index,
+                                        UBYTE *plmn,
+                                        T_ACI_CPOL_MOD mode )
+{
+  SHORT off;      /* holds EF offset */
+  SHORT cpyOff;   /* holds offset for copy operation */
+  UBYTE maxIdx;   /* holds maximum number of index */
+
+  TRACE_FUNCTION ("cmhSIM_UpdPlmnSel()");
+
+/*
+ *-----------------------------------------------------------------
+ * update EF PLMNsel RAM copy
+ *-----------------------------------------------------------------
+ */
+  maxIdx = CPOLSimEfDataLen / ACI_LEN_PLMN_SEL_NTRY;
+
+  off = (index-1) * ACI_LEN_PLMN_SEL_NTRY;
+
+  if( mode EQ CPOL_MOD_Insert AND index < maxIdx )
+  {
+    cmhSIM_CmpctPlmnSel ( CPOLSimEfDataLen, CPOLSimEfData );
+
+    cpyOff = (maxIdx-1) * ACI_LEN_PLMN_SEL_NTRY;
+
+    cpyOff -= ACI_LEN_PLMN_SEL_NTRY;  /* need not copy since last index will fall out of list! */
+
+    while( cpyOff >= off AND cpyOff >= 0 )
+    {
+      memcpy( CPOLSimEfData+cpyOff+ACI_LEN_PLMN_SEL_NTRY,
+              CPOLSimEfData+cpyOff, ACI_LEN_PLMN_SEL_NTRY );
+
+      cpyOff -= ACI_LEN_PLMN_SEL_NTRY;
+    }
+  }
+
+  memcpy( CPOLSimEfData+off, plmn, ACI_LEN_PLMN_SEL_NTRY );
+
+  return ( cmhSIM_WritePlmnSel( srcId ));
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SIMS           |
+| STATE   : code                        ROUTINE : cmhSIM_FndEmptyPlmnSel  |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function searches for an empty entry in EF PLMN SEL,
+            fills it and writes the field to the SIM.
+*/
+GLOBAL T_ACI_RETURN cmhSIM_FndEmptyPlmnSel ( T_ACI_CMD_SRC srcId,
+                                             UBYTE *plmn )
+{
+  UBYTE maxNtry;  /* holds maximum number of entries */
+  SHORT off;      /* holds EF offset */
+
+  TRACE_FUNCTION ("cmhSIM_FndEmptyPlmnSel()");
+
+/*
+ *-----------------------------------------------------------------
+ * search for an empty entry, and update
+ *-----------------------------------------------------------------
+ */
+  maxNtry = CPOLSimEfDataLen / ACI_LEN_PLMN_SEL_NTRY;
+
+  for( off = 0; maxNtry > 0; off += ACI_LEN_PLMN_SEL_NTRY, maxNtry-- )
+  {
+    if( !memcmp( CPOLSimEfData+off, PLMNselEmpty,
+                 ACI_LEN_PLMN_SEL_NTRY ))
+    {
+      memcpy( CPOLSimEfData+off, plmn, ACI_LEN_PLMN_SEL_NTRY );
+
+      return ( cmhSIM_WritePlmnSel( srcId ));
+    }
+  }
+
+  ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_MemFull );
+  return( AT_FAIL );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SIMS           |
+| STATE   : code                        ROUTINE : cmhSIM_DelPlmnSel  |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function updates the indexed EF PLMN SEL entry and
+            writes the field to the SIM.
+*/
+GLOBAL T_ACI_RETURN cmhSIM_DelPlmnSel ( T_ACI_CMD_SRC srcId,
+                                        SHORT index,
+                                        T_ACI_CPOL_MOD mode )
+{
+  SHORT off;      /* holds EF offset */
+
+  TRACE_FUNCTION ("cmhSIM_DelPlmnSel()");
+
+/*
+ *-----------------------------------------------------------------
+ * delete entry in EF PLMNsel RAM copy
+ *-----------------------------------------------------------------
+ */
+
+  off = (index-1) * ACI_LEN_PLMN_SEL_NTRY;
+
+  memcpy( CPOLSimEfData+off, PLMNselEmpty, ACI_LEN_PLMN_SEL_NTRY );
+
+  if( mode EQ CPOL_MOD_CompactList )
+
+    cmhSIM_CmpctPlmnSel ( CPOLSimEfDataLen, CPOLSimEfData );
+
+  return ( cmhSIM_WritePlmnSel( srcId ));
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SIMS           |
+| STATE   : code                        ROUTINE : cmhSIM_ChgPlmnSel  |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function exchanges the indexed EF PLMN SEL entries and
+            writes the field to the SIM.
+*/
+GLOBAL T_ACI_RETURN cmhSIM_ChgPlmnSel ( T_ACI_CMD_SRC srcId,
+                                        SHORT index,
+                                        SHORT index2 )
+{
+  SHORT off1, off2;                   /* holds EF offset */
+  UBYTE plmn1[ACI_LEN_PLMN_SEL_NTRY]; /* buffers PLMN 1 */
+  UBYTE plmn2[ACI_LEN_PLMN_SEL_NTRY]; /* buffers PLMN 2 */
+
+  TRACE_FUNCTION ("cmhSIM_ChgPlmnSel()");
+
+/*
+ *-----------------------------------------------------------------
+ * change entries in EF PLMNsel RAM copy
+ *-----------------------------------------------------------------
+ */
+
+  off1 = (index-1)  * ACI_LEN_PLMN_SEL_NTRY;
+  off2 = (index2-1) * ACI_LEN_PLMN_SEL_NTRY;
+
+  memcpy( plmn1, CPOLSimEfData+off1, ACI_LEN_PLMN_SEL_NTRY );
+  memcpy( plmn2, CPOLSimEfData+off2, ACI_LEN_PLMN_SEL_NTRY );
+
+  memcpy( CPOLSimEfData+off1, plmn2, ACI_LEN_PLMN_SEL_NTRY );
+  memcpy( CPOLSimEfData+off2, plmn1, ACI_LEN_PLMN_SEL_NTRY );
+
+  return ( cmhSIM_WritePlmnSel( srcId ));
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SIMF           |
+| STATE   : code                        ROUTINE : cmhSIM_WritePlmnSel|
++--------------------------------------------------------------------+
+
+  PURPOSE : This function starts writing of EF PLMN SEL to SIM.
+*/
+GLOBAL T_ACI_RETURN cmhSIM_WritePlmnSel ( T_ACI_CMD_SRC srcId )
+{
+  T_ACI_RETURN ret = AT_FAIL;
+  SHORT        table_id;
+
+  TRACE_FUNCTION ("cmhSIM_WritePlmnSel()");
+
+/*
+ *-----------------------------------------------------------------
+ * request table id for SIM SAP access
+ *-----------------------------------------------------------------
+ */
+  table_id = psaSIM_atbNewEntry();
+
+  if(table_id NEQ NO_ENTRY)
+  {
+    simShrdPrm.atb[table_id].accType      = ACT_WR_DAT;
+    simShrdPrm.atb[table_id].reqDataFld   = SIM_PLMNSEL;
+    simShrdPrm.atb[table_id].dataOff      = 0;
+    /* length is variable */
+    simShrdPrm.atb[table_id].dataLen      = CPOLSimEfDataLen;
+    simShrdPrm.atb[table_id].recMax       = NOT_PRESENT_8BIT;
+    simShrdPrm.atb[table_id].ntryUsdFlg   = TRUE;
+    simShrdPrm.atb[table_id].exchData     = CPOLSimEfData;
+    simShrdPrm.atb[table_id].rplyCB       = cmhSIM_WrCnfPlmnSel;
+
+    simShrdPrm.aId = table_id;
+
+    simEntStat.curCmd = AT_CMD_CPOL;
+    simEntStat.entOwn = simShrdPrm.owner = srcId;
+
+    if(psaSIM_AccessSIMData() < 0)
+    {
+      TRACE_EVENT("FATAL ERROR psaSIM in +CPOL");
+      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
+    }
+    else
+    {
+      ret = AT_EXCT;
+    }
+  }
+
+  return ( ret );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_WriteTranspEF |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function starts writing of a transparent EF to SIM.
+            (SIM only busy with valid 'srcId')
+*/
+GLOBAL T_ACI_RETURN cmhSIM_WriteTranspEF (T_ACI_CMD_SRC srcId,
+                                          T_ACI_AT_CMD  cmd,
+                                          USHORT        datafield,
+                                          USHORT        offset,
+                                          UBYTE         datalen,
+                                          UBYTE       * exchData,
+                                          void      (*rplyCB)(SHORT))
+{
+  T_ACI_RETURN ret = AT_FAIL;
+  SHORT        table_id;
+
+  TRACE_FUNCTION ("cmhSIM_WriteTranspEF()");
+
+/*
+ *-----------------------------------------------------------------
+ * request table id for SIM SAP access
+ *-----------------------------------------------------------------
+ */
+  table_id = psaSIM_atbNewEntry();
+
+  if(table_id NEQ NO_ENTRY)
+  {
+    simShrdPrm.atb[table_id].accType      = ACT_WR_DAT;
+    simShrdPrm.atb[table_id].reqDataFld   = datafield;
+    simShrdPrm.atb[table_id].dataOff      = offset;
+    simShrdPrm.atb[table_id].recNr        = 0;
+    simShrdPrm.atb[table_id].dataLen      = datalen;
+    simShrdPrm.atb[table_id].recMax       = NOT_PRESENT_8BIT;
+    simShrdPrm.atb[table_id].ntryUsdFlg   = TRUE;
+    simShrdPrm.atb[table_id].exchData     = exchData;
+    simShrdPrm.atb[table_id].rplyCB       = rplyCB;
+
+    simShrdPrm.aId = table_id;
+
+    if (srcId NEQ CMD_SRC_NONE)
+    {
+      simEntStat.curCmd = cmd;
+      simEntStat.entOwn = simShrdPrm.owner = srcId;
+    }
+    if(psaSIM_AccessSIMData() < 0)
+    {
+      TRACE_EVENT("FATAL ERROR psaSIM");
+      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
+    }
+    else
+    {
+      ret = AT_EXCT;
+    }
+  }
+
+  return ( ret );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)             MODULE  : CMH_SIMF            |
+| STATE   : code                       ROUTINE : cmhSIM_ReadTranspEF |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function starts reading of EF PLMN SEL from SIM.
+            (SIM only busy with valid 'srcId')
+*/
+GLOBAL T_ACI_RETURN cmhSIM_ReadTranspEF ( T_ACI_CMD_SRC srcId,
+                                          T_ACI_AT_CMD  cmd,
+                                          USHORT        datafield,
+                                          USHORT        offset,
+                                          UBYTE         explen,
+                                          UBYTE       * exchData,
+                                          void      (*rplyCB)(SHORT))
+{
+  T_ACI_RETURN ret       = AT_FAIL;
+  SHORT        table_id;
+
+  TRACE_FUNCTION ("cmhSIM_ReadTranspEF()");
+
+/*
+ *-----------------------------------------------------------------
+ * request table id for SIM SAP access
+ *-----------------------------------------------------------------
+ */
+  table_id = psaSIM_atbNewEntry();
+
+  if(table_id NEQ NO_ENTRY)
+  {
+    simShrdPrm.atb[table_id].accType      = ACT_RD_DAT;
+    simShrdPrm.atb[table_id].reqDataFld   = datafield;
+    simShrdPrm.atb[table_id].dataOff      = offset;
+    simShrdPrm.atb[table_id].recNr        = 0;
+    simShrdPrm.atb[table_id].dataLen      = NOT_PRESENT_8BIT;
+    simShrdPrm.atb[table_id].recMax       = explen;
+    simShrdPrm.atb[table_id].ntryUsdFlg   = TRUE;
+    simShrdPrm.atb[table_id].exchData     = exchData;
+    simShrdPrm.atb[table_id].rplyCB       = rplyCB;
+
+    simShrdPrm.aId = table_id;
+
+    if (srcId NEQ CMD_SRC_NONE)
+    {
+      simEntStat.curCmd = cmd;
+      simEntStat.entOwn = simShrdPrm.owner = srcId;
+    }
+    if(psaSIM_AccessSIMData() < 0)
+    {
+      TRACE_EVENT("FATAL ERROR psaSIM");
+      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
+    }
+    else
+    {
+      ret = AT_EXCT;
+    }
+  }
+
+  return ( ret );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_WriteRecordEF |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function starts writing of a transparent EF to SIM.
+            (SIM only busy with valid 'srcId')
+*/
+GLOBAL T_ACI_RETURN cmhSIM_WriteRecordEF (T_ACI_CMD_SRC srcId,
+                                          T_ACI_AT_CMD  cmd,
+                                          USHORT        datafield,
+                                          UBYTE         record,
+                                          UBYTE         datalen,
+                                          UBYTE       * exchData,
+                                          void      (*rplyCB)(SHORT))
+{
+  T_ACI_RETURN ret = AT_FAIL;
+  SHORT        table_id;
+
+  TRACE_FUNCTION ("cmhSIM_WriteRecordEF()");
+
+/*
+ *-----------------------------------------------------------------
+ * request table id for SIM SAP access
+ *-----------------------------------------------------------------
+ */
+  table_id = psaSIM_atbNewEntry();
+
+  if(table_id NEQ NO_ENTRY)
+  {
+    simShrdPrm.atb[table_id].accType      = ACT_WR_REC;
+    simShrdPrm.atb[table_id].reqDataFld   = datafield;
+    simShrdPrm.atb[table_id].dataOff      = 0;
+    simShrdPrm.atb[table_id].dataLen      = datalen;
+    simShrdPrm.atb[table_id].recNr        = record;
+    simShrdPrm.atb[table_id].recMax       = NOT_PRESENT_8BIT;
+    simShrdPrm.atb[table_id].ntryUsdFlg   = TRUE;
+    simShrdPrm.atb[table_id].exchData     = exchData;
+    simShrdPrm.atb[table_id].rplyCB       = rplyCB;
+
+    simShrdPrm.aId = table_id;
+
+    if (srcId NEQ CMD_SRC_NONE)
+    {
+      simEntStat.curCmd = cmd;
+      simEntStat.entOwn = simShrdPrm.owner = srcId;
+    }
+    if(psaSIM_AccessSIMData() < 0)
+    {
+      TRACE_EVENT("FATAL ERROR psaSIM");
+      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
+    }
+    else
+    {
+      ret = AT_EXCT;
+    }
+  }
+
+  return ( ret );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)             MODULE  : CMH_SIMF            |
+| STATE   : code                       ROUTINE : cmhSIM_ReadRecordEF |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function starts reading of EF PLMN SEL from SIM.
+            (SIM only busy with valid 'srcId')
+*/
+GLOBAL T_ACI_RETURN cmhSIM_ReadRecordEF ( T_ACI_CMD_SRC srcId,
+                                          T_ACI_AT_CMD  cmd,
+                                          USHORT        datafield,
+                                          UBYTE         record,
+                                          UBYTE         explen,
+                                          UBYTE       * exchData,
+                                          void      (*rplyCB)(SHORT))
+{
+  T_ACI_RETURN ret       = AT_FAIL;
+  SHORT        table_id;
+
+  TRACE_FUNCTION ("cmhSIM_ReadRecordEF()");
+
+/*
+ *-----------------------------------------------------------------
+ * request table id for SIM SAP access
+ *-----------------------------------------------------------------
+ */
+  table_id = psaSIM_atbNewEntry();
+
+  if(table_id NEQ NO_ENTRY)
+  {
+    simShrdPrm.atb[table_id].accType      = ACT_RD_REC;
+    simShrdPrm.atb[table_id].reqDataFld   = datafield;
+    simShrdPrm.atb[table_id].dataOff      = 0;
+    simShrdPrm.atb[table_id].recNr        = record;
+    /* for CPHS (and this shall probably be extended to other SIM
+    access operations) dataLen passed in SIM_READ_RECORD_REQ should
+    be NOT_PRESENT_8BIT (to let the SIM entity handling this length:
+    ACI does not know it anyway...). Yet size of received data should
+    be checked when conf is received (to avoid crashes with exotic SIM cards */
+#ifdef FF_CPHS
+    if(cmd EQ AT_CMD_CPHS)
+    {
+      simShrdPrm.atb[table_id].check_dataLen = TRUE;
+    }
+#endif /* FF_CPHS */
+    simShrdPrm.atb[table_id].dataLen      = explen;
+    simShrdPrm.atb[table_id].recMax       = NOT_PRESENT_8BIT;
+    simShrdPrm.atb[table_id].ntryUsdFlg   = TRUE;
+    simShrdPrm.atb[table_id].exchData     = exchData;
+    simShrdPrm.atb[table_id].rplyCB       = rplyCB;
+
+    simShrdPrm.aId = table_id;
+
+    if (srcId NEQ CMD_SRC_NONE)
+    {
+      simEntStat.curCmd = cmd;
+      simEntStat.entOwn = simShrdPrm.owner = srcId;
+    }
+    if(psaSIM_AccessSIMData() < 0)
+    {
+      TRACE_EVENT("FATAL ERROR psaSIM");
+      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
+    }
+    else
+    {
+      ret = AT_EXCT;
+    }
+  }
+
+  return ( ret );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : SimStatusError       |
++--------------------------------------------------------------------+
+
+  PURPOSE : sync_notification: TRUE if notification through asynchrone callback
+                               FALSE if notif. whithin synchrone context.
+
+*/
+#define GetSIMError (1)
+#define CheckSimStatus (0)
+
+LOCAL T_ACI_RETURN SimStatusError ( T_ACI_CMD_SRC srcBuf,
+                                    T_ACI_AT_CMD  cmdBuf,
+                                    UBYTE         sync_notification)
+{
+  T_ACI_CPIN_RSLT code = CPIN_RSLT_NotPresent;
+  T_ACI_CME_ERR   err  = CME_ERR_NotPresent;
+
+  /* trace if needed... TRACE_EVENT_P1("simShrdPrm.SIMStat: %d", simShrdPrm.SIMStat); */
+
+  switch( simShrdPrm.SIMStat )
+  {
+    case( SS_OK ):
+      if ( qAT_PlusCPIN(CMD_SRC_LCL, &code) EQ AT_CMPL )
+      {
+        switch ( code )
+        {
+          case CPIN_RSLT_PhSimPinReq:
+            err = CME_ERR_PhSimPinReq;
+            break;
+          case CPIN_RSLT_SimPinReq:
+            err = CME_ERR_SimPinReq;
+            break;
+          case CPIN_RSLT_SimPin2Req:
+            err = CME_ERR_SimPin2Req;
+            break;
+          case(CPIN_RSLT_PhFSimPinReq): 
+            err = CME_ERR_PhFSimPinReq;
+            break;
+          case(CPIN_RSLT_PhFSimPukReq): 
+            err = CME_ERR_PhFSimPukReq;
+            break;
+          case(CPIN_RSLT_PhNetPinReq): 
+            err = CME_ERR_NetworkPersPinReq;
+            break;
+          case(CPIN_RSLT_PhNetPukReq): 
+            err = CME_ERR_NetworkPersPukReq;
+            break;
+          case(CPIN_RSLT_PhNetSubPinReq): 
+            err = CME_ERR_NetworkSubsetPersPinReq;
+            break;
+          case(CPIN_RSLT_PhNetSubPukReq):
+            err = CME_ERR_NetworkSubsetPersPukReq;
+            break;
+          case(CPIN_RSLT_PhSPPinReq): 
+            err = CME_ERR_ProviderPersPinReq;
+            break;
+          case(CPIN_RSLT_PhSPPukReq): 
+            err = CME_ERR_ProviderPersPukReq;
+            break;
+          case(CPIN_RSLT_PhCorpPinReq):
+            err = CME_ERR_CorporatePersPinReq;
+            break;
+          case(CPIN_RSLT_PhCorpPukReq):
+            err = CME_ERR_CorporatePersPukReq;
+            break;
+
+        }
+      }
+      break;
+
+    case( SS_BLKD ):
+      if ( qAT_PlusCPIN(CMD_SRC_LCL, &code) EQ AT_CMPL )
+      {
+        switch ( code )
+        {
+          case CPIN_RSLT_SimPukReq:
+            err = CME_ERR_SimPukReq;
+            break;
+          case CPIN_RSLT_SimPuk2Req:
+            err = CME_ERR_SimPuk2Req;
+            break;
+        }
+      }
+      break;
+
+    case( SS_INV ):
+      err = CME_ERR_SimWrong;
+      break;
+
+    case( SS_URCHB ):
+      err = CME_ERR_SimFail;
+      break;
+
+    default:            /* unexpected result */
+      break;
+  }
+
+  if( err EQ CME_ERR_NotPresent )
+  {
+    return ( AT_FAIL );
+  }
+  else
+  {
+    TRACE_EVENT_P1("err: %d", err);
+  }
+
+  switch( sync_notification )
+  {
+  case( GetSIMError ):
+    R_AT( RAT_CME, srcBuf ) ( cmdBuf, err );
+    break;
+
+  case( CheckSimStatus ):
+    ACI_ERR_DESC( ACI_ERR_CLASS_Cme, err );
+    break;
+  }
+  return( AT_CMPL );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_GetSIMError   |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function is used to request the SIM error status.
+
+*/
+GLOBAL T_ACI_RETURN cmhSIM_GetSIMError ( T_ACI_CMD_SRC srcBuf,
+                                         T_ACI_AT_CMD cmdBuf )
+{
+  TRACE_FUNCTION("cmhSIM_GetSIMError");
+
+  return(SimStatusError( srcBuf, cmdBuf,  GetSIMError ));
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_GetSIMError   |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function is used to check the SIM pin status.
+
+*/
+GLOBAL T_ACI_RETURN cmhSIM_CheckSimPinStatus ( T_ACI_CMD_SRC srcBuf,
+                                               T_ACI_AT_CMD cmdBuf )
+{
+  TRACE_FUNCTION("cmhSIM_CheckSimPinStatus");
+
+  return(SimStatusError( srcBuf, cmdBuf,  CheckSimStatus ));
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SIMS           |
+| STATE   : code                        ROUTINE : cmhSIM_ReqLanguage |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function starts reading of ELP field from SIM.
+*/
+GLOBAL T_ACI_RETURN cmhSIM_ReqLanguage  ( T_ACI_CMD_SRC srcId)
+
+{
+  T_ACI_RETURN ret = AT_FAIL;
+  SHORT        table_id;
+
+  TRACE_FUNCTION ("cmhSIM_ReqLanguage()");
+
+/*
+ *-----------------------------------------------------------------
+ * request table id for SIM SAP access
+ *-----------------------------------------------------------------
+ */
+  table_id = psaSIM_atbNewEntry();
+
+  if(table_id NEQ NO_ENTRY)
+  {
+    simShrdPrm.atb[table_id].accType      = ACT_RD_DAT;
+    simShrdPrm.atb[table_id].reqDataFld   = SIM_ELP;
+    simShrdPrm.atb[table_id].dataOff      = 0;
+    /* length is variable */
+    simShrdPrm.atb[table_id].dataLen      = NOT_PRESENT_8BIT;
+    simShrdPrm.atb[table_id].recMax       = ACI_LEN_LAN_FLD;
+    simShrdPrm.atb[table_id].ntryUsdFlg   = TRUE;
+    simShrdPrm.atb[table_id].exchData     = CLANSimEfData;
+    simShrdPrm.atb[table_id].rplyCB       = cmhSIM_RdCnfLangELP;
+
+
+    simShrdPrm.aId = table_id;
+
+    simEntStat.curCmd = AT_CMD_CLAN;
+    simEntStat.entOwn = simShrdPrm.owner = srcId;
+
+    if(psaSIM_AccessSIMData() < 0)
+    {
+      TRACE_EVENT("FATAL ERROR psaSIM in +CLAN");
+      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
+    }
+    else
+    {
+      ret = AT_EXCT;
+    }
+  }
+
+  return ( ret );
+}
+
+
+/*
++-----------------------------------------------------------------------+
+| PROJECT :                             MODULE  : SAT                   |
+| STATE   : code                        ROUTINE : cmhSIM_ReqLanguagePrf |
++-----------------------------------------------------------------------+
+
+  PURPOSE : This function starts reading of ELP field from SIM for SAT feature LS.
+*/
+GLOBAL BOOL cmhSIM_ReqLanguagePrf(void)
+
+{
+  BOOL         ret = FALSE;
+  SHORT        table_id;
+
+  TRACE_FUNCTION ("cmhSIM_ReqLanguagePrf()");
+
+/*
+ *-----------------------------------------------------------------
+ * request table id for SIM SAP access
+ *-----------------------------------------------------------------
+ */
+  table_id = psaSIM_atbNewEntry();
+
+  if(table_id NEQ NO_ENTRY)
+  {
+    simShrdPrm.atb[table_id].accType      = ACT_RD_DAT;
+    simShrdPrm.atb[table_id].reqDataFld   = SIM_ELP;
+    simShrdPrm.atb[table_id].dataOff      = 0;
+    // length is variable
+    simShrdPrm.atb[table_id].dataLen      = NOT_PRESENT_8BIT;
+    simShrdPrm.atb[table_id].recMax       = ACI_LEN_LAN_FLD;
+    simShrdPrm.atb[table_id].ntryUsdFlg   = TRUE;
+    simShrdPrm.atb[table_id].exchData     = CLANSimEfData;
+    simShrdPrm.atb[table_id].rplyCB       = cmhSIM_RdCnfLangPrfELP;
+
+
+    simShrdPrm.aId = table_id;
+
+    
+    if(psaSIM_AccessSIMData() < 0)
+    {
+      return ( ret );      
+    }
+    else
+    {
+      ret = TRUE;
+    }
+  }
+
+  return ( ret );
+}
+
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)          MODULE  : CMH_SIMF               |
+| STATE   : code                    ROUTINE : getSupLangFromPCM      |
++--------------------------------------------------------------------+
+
+  PURPOSE : get Supported Language from PCM and compare it
+            with Language table.
+*/
+GLOBAL T_ACI_RETURN getSupLangFromPCM ( T_ACI_LAN_SUP *lanlst, SHORT *lastIdx)
+
+{
+  CHAR              *ef = EF_MSSUP_ID;
+  pcm_FileInfo_Type fileInfo;
+  EF_MSSUP          mssup;
+  LONG              value;
+  SHORT             i, idx=0;
+  LONG              bitmask = 0x01;
+
+  TRACE_FUNCTION ("getSupLangFromPCM()");
+
+/*
+ *-------------------------------------------------------------------
+ *   read supported language from ME
+ *-------------------------------------------------------------------
+ */if (pcm_GetFileInfo ( (UBYTE*)ef, &fileInfo) NEQ PCM_OK)
+   {
+     TRACE_EVENT("Error getting datas from PCM");
+     ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_MemFail );
+     return( AT_FAIL );
+   }
+   else
+   {
+     if ( pcm_ReadFile ( ( UBYTE* )ef,fileInfo.FileSize,
+                         ( UBYTE*) &mssup,
+                         &fileInfo.Version) EQ PCM_OK )
+     {
+       value =mssup.lng1;
+       value |=mssup.lng2 <<8;
+       value |=mssup.lng3 <<16;
+
+       for(i=0;i<MAX_LAN;i++)
+       {
+         if (bitmask & value)
+         {
+           lanlst[idx].lng =i;
+           idx++;
+         }
+
+         bitmask= bitmask<< 1;
+       }
+
+     }
+     else
+     {
+       ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_MemFail );
+       return( AT_FAIL );
+     }
+   }
+
+/*
+ *-------------------------------------------------------------------
+ * terminate list and set last index
+ *-------------------------------------------------------------------
+ */
+  if( idx < MAX_LAN )
+  {
+    lanlst[idx].str = 0x0;
+    lanlst[idx].lng = 0x0;
+
+  }
+  *lastIdx = idx;
+
+/*
+ *-------------------------------------------------------------------
+ *   compare the code of supported language in PCM with
+ *   Language table to get the char code
+ *-------------------------------------------------------------------
+ */
+  for(i=0;i < *lastIdx;i++)
+  {
+    idx=0;
+    while (lngs[idx].str NEQ NULL AND
+           lngs[idx].lng NEQ lanlst[i].lng)
+      idx++;
+
+    if (lngs[idx].lng EQ lanlst[i].lng)
+      lanlst[i].str=lngs[idx].str;
+  }
+
+  return( AT_CMPL );
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)          MODULE  : CMH_SIMF               |
+| STATE   : code                    ROUTINE : checkSuppLangInELP     |
++--------------------------------------------------------------------+
+
+  PURPOSE : check if the language to be read from the EF ELP
+            is supported in PCM
+
+            SupLng: is true if the language is supprted else False
+*/
+
+GLOBAL BOOL checkSuppLang     (T_ACI_LAN_SUP   *lanlst,
+                               SHORT           lastIdx,
+                               T_ACI_LAN_SUP   *clng)
+{
+  USHORT i;
+  BOOL   SupLng=FALSE;
+
+/*
+ *-----------------------------------------------------------------
+ *  check if the Language from EF ELP is supported in PCM
+ *-----------------------------------------------------------------
+ */
+  for(i=0;i < lastIdx;i++)
+  {
+    if (!strcmp(lanlst[i].str,clng->str) )
+    {
+      clng->lng=lanlst[i].lng;
+      SupLng= TRUE;
+      break;
+    }
+  }
+
+  return( SupLng );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)          MODULE  : CMH_SIMF               |
+| STATE   : code                    ROUTINE : checkSuppLangInLP      |
++--------------------------------------------------------------------+
+
+  PURPOSE : check if the language to be read from the EF LP
+            is supported in PCM
+
+            SupLng: is true if the language is supprted else False
+*/
+
+GLOBAL BOOL checkSuppLangInLP(T_ACI_LAN_SUP *lanlst,SHORT lastIdx,
+                              T_ACI_LAN_SUP *clng)
+{
+  USHORT i;
+  BOOL   SupLng=FALSE;
+
+/*
+ *-----------------------------------------------------------------
+ *  check if the Language from EF LP is supported in PCM
+ *-----------------------------------------------------------------
+ */
+  for(i=0;i < lastIdx;i++)
+  {
+    if (lanlst[i].lng EQ clng->lng )
+    {
+      clng->str=lanlst[i].str;
+      SupLng= TRUE;
+      break;
+    }
+  }
+
+  return( SupLng );
+}
+
+#if 0
+/*
++------------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)             MODULE  : CMH_SIMS                |
+| STATE   : code                       ROUTINE : cmhSIM_LanguageLP_Update|
++------------------------------------------------------------------------+
+
+  PURPOSE :
+*/
+GLOBAL BOOL cmhSIM_LanguageLP_Update  ( int ref, T_SIM_FILE_UPDATE_IND *fu)
+{
+  T_ACI_CMD_SRC ownBuf;     /* buffers current owner */
+  UBYTE i;
+  BOOL found = FALSE;
+
+  char *auptr="au";
+  CHAR *ef = EF_CLNG_ID;
+  pcm_FileInfo_Type fileInfo;
+  EF_CLNG lng;
+
+
+  TRACE_FUNCTION ("cmhSIM_LanguageLP_Update()");
+
+  ownBuf     = simEntStat.entOwn;
+
+  for (i = 0; i < (int)fu->val_nr; i++)
+  {
+    if (!found AND
+        (fu->file_id[i] EQ SIM_LP))
+    {
+      found = TRUE;
+    }
+  }
+
+  if (found)
+  {
+    /*
+     *-------------------------------------------------------------------
+     *   read supported language from ME
+     *-------------------------------------------------------------------
+     */
+     if (pcm_GetFileInfo ( ( UBYTE* ) ef, &fileInfo) NEQ PCM_OK)
+     {
+       TRACE_EVENT("cmhSIM_LanguageLP_Update: error returned by pcm_GetFileInfo()" );
+       return TRUE;
+     }
+     else
+     {
+
+       if ( pcm_ReadFile ( (UBYTE*)ef,
+                           fileInfo.FileSize,
+                           (UBYTE*) &lng,
+                           &fileInfo.Version) EQ PCM_OK )
+       {
+       }
+       else
+       {
+         TRACE_EVENT("cmhSIM_LanguageLP_Update: error returned by pcm_ReadFile()" );
+         return TRUE;
+       }
+     }
+
+    /*
+     *-------------------------------------------------------------------
+     *  Read EF LP from the sim if Automatic language is selected
+     *-------------------------------------------------------------------
+     */
+    if (!strncmp((char*)&lng.data[0], auptr, 2))
+    {
+      cmhSIM_ReqLanguageLP(ownBuf);  /* reading files */
+      simShrdPrm.fuRef = (UBYTE)ref;
+      return FALSE;
+    }
+    else
+    {
+      return TRUE;
+    }
+  }
+  else
+  {
+    return TRUE;  /* nothing to do */
+  }
+}
+#endif
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)             MODULE  : CMH_SIMS            |
+| STATE   : code                       ROUTINE : cmhSIM_ReqLanguageLP|
++--------------------------------------------------------------------+
+
+  PURPOSE : This function starts reading of ELP OR LP field from SIM.
+*/
+GLOBAL T_ACI_RETURN cmhSIM_ReqLanguageLP  ( T_ACI_CMD_SRC srcId )
+{
+  T_ACI_RETURN ret       = AT_FAIL;
+  SHORT                  table_id;
+
+  TRACE_FUNCTION ("cmhSIM_ReqLanguageLP()");
+
+/*
+ *-----------------------------------------------------------------
+ * request table id for SIM SAP access
+ *-----------------------------------------------------------------
+ */
+  table_id = psaSIM_atbNewEntry();
+
+  if(table_id NEQ NO_ENTRY)
+  {
+    simShrdPrm.atb[table_id].accType      = ACT_RD_DAT;
+    simShrdPrm.atb[table_id].reqDataFld   = SIM_LP;
+    simShrdPrm.atb[table_id].dataOff      = 0;
+    /* length is variable */
+    simShrdPrm.atb[table_id].dataLen      = NOT_PRESENT_8BIT;
+    simShrdPrm.atb[table_id].recMax       = ACI_MAX_LAN_LP_NTRY;
+    simShrdPrm.atb[table_id].ntryUsdFlg   = TRUE;
+    simShrdPrm.atb[table_id].exchData     = CLANSimEfDataLP;
+    simShrdPrm.atb[table_id].rplyCB       = cmhSIM_RdCnfLangLP;
+
+
+    simShrdPrm.aId = table_id;
+
+    simEntStat.curCmd = AT_CMD_CLAN;
+    simEntStat.entOwn = simShrdPrm.owner = srcId;
+
+    if(psaSIM_AccessSIMData() < 0)
+    {
+      TRACE_EVENT("FATAL ERROR psaSIM in +CLAN");
+      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
+    }
+    else
+    {
+      ret = AT_EXCT;
+    }
+  }
+
+  return ( ret );
+}
+
+
+/*
++-----------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)             MODULE  : CMH_SIMS               |
+| STATE   : code                       ROUTINE : cmhSIM_ReqLanguagePrfLP|
++-----------------------------------------------------------------------+
+
+  PURPOSE : This function starts reading of LP field from SIM for SAT
+  fetaure LS.
+*/
+GLOBAL BOOL cmhSIM_ReqLanguagePrfLP  (void)
+{
+  BOOL     ret  = FALSE;
+  SHORT        table_id;
+
+  TRACE_FUNCTION ("cmhSIM_ReqLanguagePrfLP()");
+
+/*
+ *-----------------------------------------------------------------
+ * request table id for SIM SAP access
+ *-----------------------------------------------------------------
+ */
+  table_id = psaSIM_atbNewEntry();
+
+  if(table_id NEQ NO_ENTRY)
+  {
+    simShrdPrm.atb[table_id].accType      = ACT_RD_DAT;
+    simShrdPrm.atb[table_id].reqDataFld   = SIM_LP;
+    simShrdPrm.atb[table_id].dataOff      = 0;
+    // length is variable
+    simShrdPrm.atb[table_id].dataLen      = NOT_PRESENT_8BIT;
+    simShrdPrm.atb[table_id].recMax       = ACI_MAX_LAN_LP_NTRY;
+    simShrdPrm.atb[table_id].ntryUsdFlg   = TRUE;
+    simShrdPrm.atb[table_id].exchData     = CLANSimEfDataLP;
+    simShrdPrm.atb[table_id].rplyCB       = cmhSIM_RdCnfLangPrfLP;
+
+    simShrdPrm.aId = table_id;
+
+       
+    if(psaSIM_AccessSIMData() < 0)
+    {
+      return ( ret );      
+    }
+    else
+    {
+      ret = TRUE;
+    }
+  }
+
+  return ( ret );
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_AD_Update     |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function is used to request the SIM Administrative
+            Data (EF_AD).
+
+*/
+GLOBAL BOOL cmhSIM_AD_Update (int ref, T_SIM_FILE_UPDATE_IND *fu)
+{
+  BOOL found = FALSE;
+  UBYTE i;
+  TRACE_FUNCTION ("cmhSIM_AD_Update()");
+
+  for (i = 0; i < (int)fu->val_nr; i++)
+  {
+    if (!found AND (fu->file_id[i] EQ SIM_AD))
+    {
+      found = TRUE;
+    }
+  }
+  if (found)
+  {
+    cmhSIM_Read_AD();
+    simShrdPrm.fuRef = (UBYTE)ref;
+    return FALSE; /* reading files */
+   }
+  else
+  {
+    return TRUE;  /* nothing to do */
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_Read_AD       |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function is used to request the SIM Administrative
+            Data (EF_AD).
+
+*/
+GLOBAL T_ACI_RETURN cmhSIM_Read_AD()
+{
+  SHORT table_id;
+
+  TRACE_FUNCTION ("cmhSIM_Read_AD()");
+
+  table_id = psaSIM_atbNewEntry();
+
+  if(table_id NEQ NO_ENTRY)
+  {
+    simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
+    simShrdPrm.atb[table_id].accType    = ACT_RD_DAT;
+    simShrdPrm.atb[table_id].reqDataFld = SIM_AD;
+    simShrdPrm.atb[table_id].dataOff    = 0;
+    simShrdPrm.atb[table_id].dataLen    = NOT_PRESENT_8BIT;
+    simShrdPrm.atb[table_id].recMax     = 0;
+    simShrdPrm.atb[table_id].exchData   = NULL;
+    simShrdPrm.atb[table_id].rplyCB     = cmhSIM_Read_AD_cb;
+
+    simShrdPrm.aId = table_id;
+
+    if(psaSIM_AccessSIMData() < 0)
+    {
+      TRACE_EVENT("FATAL ERROR");
+      return ( AT_FAIL );
+    }
+
+    return ( AT_CMPL );
+  }
+  return ( AT_FAIL );
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT :                  MODULE  : CMH_SIMF                     |
+| STATE   : code             ROUTINE : cmhSIM_EvalMNCLength         |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function evaluates the MNC length by extracting MNC 
+            from IMSI and comparing it with the MNC in operListFixed.
+*/
+GLOBAL  UBYTE cmhSIM_EvalMNCLength(void)
+{
+  UBYTE digit;        /* holds 4bit digit */
+  USHORT i;           /* holds counter */
+  SHORT sim_mcc;      /* holds mcc from operListFixed */
+  SHORT sim_mnc;      /* holds mnc from operListFixed */
+  SHORT mcc;          /* holds mcc extracted from IMSI */
+  SHORT mnc;          /* holds mnc extracted from IMSI */
+
+  mcc = mnc = 0;      /* Initialize mcc, mnc */
+  
+  for (i = 0; i < SIZE_MCC + SIZE_MNC; i++)   /* Extract MCC and MNC. */
+  {
+    digit = (i & 1) ?
+      (simShrdPrm.imsi.field[(i + 1)/2] & 0x0f) :
+      (simShrdPrm.imsi.field[(i + 1)/2] & 0xf0) >> 4;
+    if (i < SIZE_MCC)
+       mcc = (mcc << 4) | digit;
+    else
+       mnc = (mnc << 4) | digit;
+  }
+  
+  for( i = 0; operListFixed[i].mcc NEQ -1 AND operListFixed[i].mnc NEQ -1; i++ ) /* Evaluate mnc length */
+  {
+    sim_mcc = operListFixed[i].mcc;
+    sim_mnc = operListFixed[i].mnc;
+
+    if ( sim_mcc EQ mcc )
+    {
+      if ( (sim_mnc & 0xff0) EQ (mnc & 0xff0) )
+      {
+        if ( (sim_mnc & 0x0f) EQ 0x0f )
+        {
+          return 2;
+        }
+        else 
+        {
+          return 3;
+        }
+      }
+    }
+  }
+  return NOT_PRESENT_8BIT;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_Read_AD_cb    |
++--------------------------------------------------------------------+
+
+  PURPOSE :   Call back for SIM read (EF_AD).
+
+*/
+void cmhSIM_Read_AD_cb(SHORT table_id)
+{
+#ifdef SIM_PERS
+T_SIMLOCK_STATUS sl_status;
+ #endif
+
+
+  TRACE_FUNCTION ("cmhSIM_Read_AD_cb()");
+
+  if ( simShrdPrm.atb[table_id].reqDataFld EQ SIM_AD )
+  {
+    if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR )
+    {
+      /* 
+       * byte 2 and byte 3 of EF AD have only a meaning 
+       * if the bit1 of byte 1 is set 
+       */
+      if (simShrdPrm.atb[table_id].exchData[0] & 0x01)
+      {
+        if (simShrdPrm.atb[table_id].exchData[2] & 0x01)
+        {
+          /* ci enabled on SIM */
+          simShrdPrm.ciSIMEnabled = TRUE;
+        }
+        else
+        {
+          /* ci disabled on SIM, don't show indications */
+          simShrdPrm.ciSIMEnabled = FALSE;
+        }
+      }
+      /* byte 4 is optional */
+      if (simShrdPrm.atb[table_id].dataLen >= 4)
+      {
+        switch (simShrdPrm.atb[table_id].exchData[3] & 0x0F)
+        {
+          case 2:  simShrdPrm.mnc_len = 2; break;
+          case 3:  simShrdPrm.mnc_len = 3; break;
+          default: simShrdPrm.mnc_len =NOT_PRESENT_8BIT;
+        }
+      }
+      else
+      {
+        simShrdPrm.mnc_len = NOT_PRESENT_8BIT;
+      }
+      if (simShrdPrm.mnc_len NEQ 3)        /* Update MNC length */
+      {
+        simShrdPrm.mnc_len = cmhSIM_EvalMNCLength();
+      }
+
+    }
+#ifdef SIM_TOOLKIT
+    if (simShrdPrm.fuRef >= 0)
+    {
+      psaSAT_FUConfirm (simShrdPrm.fuRef,
+                        (USHORT)((simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR)?
+                        SIM_FU_SUCCESS: SIM_FU_ERROR));
+    }
+#endif
+  }
+  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
+if(last_sim_mmi_insert_ind NEQ NULL)
+{
+ #ifdef SIM_PERS
+   aci_slock_sim_config.sim_read_ad_first_byte = simShrdPrm.atb[table_id].exchData[0] ; 
+   aci_slock_sim_init(last_sim_mmi_insert_ind);
+  /* To set the global variable config data */
+   aci_slock_set_CFG();
+  
+   if(cfg_data EQ NULL)
+   {
+     AciSLockShrd.blocked = TRUE;
+     cmhSIM_SIMInserted();
+     PFREE (last_sim_mmi_insert_ind); /* 11_Apr_05 */
+     last_sim_mmi_insert_ind= NULL;
+     return;     
+   }
+   aci_slock_init();
+   sl_status = SIMLOCK_ENABLED;
+   AciSLockShrd.pb_load = FALSE; 
+   AciSLockShrd.check_lock = SIMLOCK_CHECK_PERS;
+   sl_status = aci_slock_checkpersonalisation(SIMLOCK_NETWORK);
+
+   #else
+    /*
+      * Start to build phonebook
+      */
+      pb_reset();
+
+#ifdef TI_PS_FFS_PHB
+      pb_inserted_sim (MAX_SRV_TBL,
+                       last_sim_mmi_insert_ind->sim_serv,
+                       &last_sim_mmi_insert_ind->imsi_field,
+                       last_sim_mmi_insert_ind->func,
+                       last_sim_mmi_insert_ind->phase);
+#else
+      pb_build_req(last_sim_mmi_insert_ind);
+#endif
+
+     /* Request the Customer Service Profile  from the SIM (EF_CPHS_CSP) */
+      cmhSIM_Get_CSP();
+
+      #ifdef SIM_TOOLKIT
+      cmhSMS_ReadCbDtaDwnl (last_sim_mmi_insert_ind);
+      #endif
+
+      #ifdef FF_MMI_RIV
+       rAT_PlusCFUNP (last_sim_mmi_insert_ind);
+      #endif /* FF_MMI_RIV */
+      PFREE (last_sim_mmi_insert_ind); /* 11_Apr_05 */
+      last_sim_mmi_insert_ind= NULL;
+    
+      cmhSIM_SIMInserted();
+    #endif  
+}
+  
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : EONS        MODULE  : CMH_SIMF                           |
+| STATE   : code        ROUTINE : cmhSIM_OpUpdate                    |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function will be used to process the update of EFopl and EFpnn.
+         
+*/
+GLOBAL BOOL cmhSIM_OpUpdate (int ref, T_SIM_FILE_UPDATE_IND *fu)
+{
+  UBYTE i;
+  BOOL  ps_is_not_reading_files_1 = FALSE, 
+        ps_is_not_reading_files_2 = FALSE;
+  
+  TRACE_FUNCTION ("cmhSIM_OpUpdate()");
+
+  for (i = 0; i < (int)fu->val_nr; i++)
+  {
+    switch(fu->file_id[i])
+    {
+      case SIM_OPL:
+        TRACE_EVENT("EF_OPL has been updated ");
+        ps_is_not_reading_files_1 = cmhSIM_UpdateOperatorName(SIM_OPL);
+        /*lint -fallthrough */
+
+      case SIM_PNN:
+        if(fu->file_id[i] NEQ SIM_OPL)
+        {
+          TRACE_EVENT("EF_PNN has been updated ");
+        }
+        ps_is_not_reading_files_2 = !cmhMM_OpUpdateName();
+        cmhMM_Registered();
+        simShrdPrm.fuRef = (UBYTE)ref;
+        if(ps_is_not_reading_files_1 OR
+           ps_is_not_reading_files_2)
+          return(TRUE);
+        
+        return(FALSE); /* reading files ? */
+
+      default:
+        break;
+    }
+  }
+  return(TRUE);  /* nothing to do */
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : EONS             MODULE  : CMH_SIMF                     |
+| STATE   : code             ROUTINE : cmhSIM_OpReadOplRcd          |
++-------------------------------------------------------------------+
+
+  PURPOSE : Sends a SIM read request
+*/
+
+GLOBAL BOOL cmhSIM_OpReadOplRcd(UBYTE rcd)
+{
+  SHORT table_id;
+
+  TRACE_FUNCTION ("cmhSIM_OpReadOplRcd()");
+
+  table_id = psaSIM_atbNewEntry();
+
+  if(table_id NEQ NO_ENTRY)
+  {
+    simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
+    simShrdPrm.atb[table_id].accType    = ACT_RD_REC;
+    simShrdPrm.atb[table_id].reqDataFld = SIM_OPL;
+    simShrdPrm.atb[table_id].dataOff    = 0;
+    simShrdPrm.atb[table_id].recNr      = rcd;
+    simShrdPrm.atb[table_id].recMax     = 0;
+    simShrdPrm.atb[table_id].exchData   = NULL;
+    simShrdPrm.atb[table_id].dataLen    = NOT_PRESENT_8BIT;
+    simShrdPrm.atb[table_id].rplyCB     = cmhSIM_OpReadOplRcdCb;
+
+    simShrdPrm.aId = table_id;
+
+    if(psaSIM_AccessSIMData() < 0)
+    {
+      TRACE_EVENT("FATAL ERROR");
+      return FALSE;
+    }
+    
+    return TRUE;
+  }
+  return TRUE;
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : EONS             MODULE  : CMH_SIMF                     |
+| STATE   : code             ROUTINE : cmhSIM_OpReadPnnRcd          |
++-------------------------------------------------------------------+
+
+  PURPOSE : Sends a SIM read request
+*/
+GLOBAL BOOL cmhSIM_OpReadPnnRcd(UBYTE rcd)
+{
+  SHORT table_id;
+
+  TRACE_FUNCTION ("cmhSIM_OpReadPnnRcd()");
+
+  table_id = psaSIM_atbNewEntry();
+
+  if(table_id NEQ NO_ENTRY)
+  {
+    simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
+    simShrdPrm.atb[table_id].accType    = ACT_RD_REC;
+    simShrdPrm.atb[table_id].reqDataFld = SIM_PNN;
+    simShrdPrm.atb[table_id].dataOff    = 0;
+    simShrdPrm.atb[table_id].recNr      = rcd;
+    simShrdPrm.atb[table_id].recMax     = 0;
+    simShrdPrm.atb[table_id].exchData   = NULL;
+    simShrdPrm.atb[table_id].dataLen    = NOT_PRESENT_8BIT;
+    simShrdPrm.atb[table_id].rplyCB     = cmhSIM_OpReadPnnRcdCb;
+
+    simShrdPrm.aId = table_id;
+
+    if(psaSIM_AccessSIMData() < 0)
+    {
+      TRACE_EVENT("FATAL ERROR");
+      return FALSE;
+    }
+    
+    return TRUE;
+  }
+  return TRUE;
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : EONS             MODULE  : CMH_SIMF                     |
+| STATE   : code             ROUTINE : cmhSIM_BuildOPLList          |
++-------------------------------------------------------------------+
+
+  PURPOSE : 
+*/
+LOCAL void cmhSIM_BuildOPLList(SHORT table_id)
+{
+  UBYTE *data = simShrdPrm.atb[table_id].exchData;
+  T_opl *opl_entry = &simShrdPrm.opl_list.opl_rcd[simShrdPrm.opl_list.num_rcd];
+
+  /* Test if record is valid */
+/*  opl_entry->plmn.v_plmn = (data[0] EQ 0xFF) ? INVLD_PLMN : VLD_PLMN; */
+
+  /* Copy MCC and MNC from SIM data to OPL list */
+  memcpy (opl_entry->plmn, data, UBYTES_PER_PLMN);
+
+  /* Extract LAC from SIM data and copy to OPL list*/
+  opl_entry->lac1        = data[3] << 8 | data[4];
+  opl_entry->lac2        = data[5] << 8 | data[6];
+
+  /* Extract PNN record number from SIM data and copy to OPL list*/
+  opl_entry->pnn_rec_num = data[7];
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : EONS             MODULE  : CMH_SIMF                     |
+| STATE   : code             ROUTINE : cmhSIM_OpReadOplRcdCb        |
++-------------------------------------------------------------------+
+
+  PURPOSE : Call back for SIM retrieval of EF_OPL.
+*/
+GLOBAL void cmhSIM_OpReadOplRcdCb(SHORT table_id)
+{
+  TRACE_FUNCTION("cmhSIM_OpReadOplRcdCb");
+
+  /* Decode and copy OPL record data to OPL list*/
+ /*------------------------------------------*/
+  if(simShrdPrm.atb[table_id].dataLen AND simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR)
+  {
+    cmhSIM_BuildOPLList(table_id);
+
+    simShrdPrm.opl_list.opl_status = TRUE;
+    /*
+    if ((memcmp (simShrdPrm.opl_list.opl_rcd[simShrdPrm.opl_list.num_rcd].plmn, 
+                PLMNselEmpty,
+                UBYTES_PER_PLMN) NEQ 0))
+    {
+      cmhSIM_OpReadPnnRcd(simShrdPrm.opl_list.opl_rcd[simShrdPrm.opl_list.num_rcd].pnn_rec_num);
+    }
+    */
+  }
+  else
+  {
+    TRACE_EVENT("Empty OPL record");
+  }
+
+  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
+
+  
+ /* If not last EF_OPL reoord retrieve next record*/
+ /*------------------------------------------*/
+  simShrdPrm.atb[table_id].recNr++;
+  simShrdPrm.opl_list.num_rcd++;
+
+  if(simShrdPrm.opl_list.num_rcd > OPL_MAX_RECORDS)
+  {
+    TRACE_EVENT("Max OPL records reached");
+  }
+  else if(simShrdPrm.atb[table_id].recNr <= simShrdPrm.atb[table_id].recMax )
+  {
+    TRACE_EVENT_P1("Read next OPL record: %d",simShrdPrm.atb[table_id].recNr);
+    cmhSIM_OpReadOplRcd(simShrdPrm.atb[table_id].recNr);
+    return;
+  }
+  
+  TRACE_EVENT("Retrieval of OPL records finished");
+  /* continue with next one */
+  cmhSIM_StartOperatorName();
+}
+
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : EONS             MODULE  : CMH_SIMF                     |
+| STATE   : code             ROUTINE : cmhSIM_BuildPnnList          |
++-------------------------------------------------------------------+
+
+  PURPOSE : decodes EF_PNN record read from SIM
+*/
+LOCAL void cmhSIM_BuildPnnList(SHORT table_id)
+{
+  UBYTE *data = simShrdPrm.atb[table_id].exchData;
+  T_pnn *pnn_entry = &simShrdPrm.pnn_list.pnn_rcd[simShrdPrm.pnn_list.num_rcd];
+
+  if (*data++ EQ PNN_LONG_NAME_IEI)
+  {
+    pnn_entry->v_plmn = TRUE;
+
+    pnn_entry->long_len = (*data++)-1;  /* adjust dcs */
+    pnn_entry->long_ext_dcs = *data++;
+    memcpy(pnn_entry->long_name,
+           data,
+           MINIMUM(pnn_entry->long_len, sizeof(pnn_entry->long_name)));
+    data += pnn_entry->long_len;
+  
+     /*----- IEI PNN short name ------*/
+    if (*data++ EQ PNN_SHORT_NAME_IEI)
+    {
+      pnn_entry->shrt_len = (*data++)-1; /* adjust dcs */
+      pnn_entry->shrt_ext_dcs = *data++;
+      memcpy(pnn_entry->shrt_name,
+             data, 
+             MINIMUM(pnn_entry->shrt_len, sizeof(pnn_entry->shrt_name)));
+    } 
+    else
+    {
+      pnn_entry->shrt_len = 0;
+    }
+  }
+  else
+  {
+    /* marc record as unused */
+    pnn_entry->v_plmn = FALSE;
+    pnn_entry->long_len = pnn_entry->shrt_len = 0;
+  }
+
+  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : EONS             MODULE  : CMH_SIMF                     |
+| STATE   : code             ROUTINE : cmhSIM_OpReadPnnRcdCb        |
++-------------------------------------------------------------------+
+
+  PURPOSE : Call back for SIM retrieval of EF_PNN.
+*/
+GLOBAL void cmhSIM_OpReadPnnRcdCb(SHORT table_id)
+{
+
+  TRACE_FUNCTION("cmhSIM_OpReadPnnRcdCb");
+
+  /* Decode and copy PNN record data to PNN list*/
+ /*------------------------------------------*/
+  if(simShrdPrm.atb[table_id].dataLen AND simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR )
+  {
+    cmhSIM_BuildPnnList(table_id);
+    simShrdPrm.pnn_list.pnn_status = TRUE;
+  }
+  else
+  {
+    TRACE_EVENT("Empty PNN record");
+  }
+
+  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
+
+  
+ /* If not last EF_PNN reoord retrieve next record*/
+ /*------------------------------------------*/
+  simShrdPrm.atb[table_id].recNr++;
+  simShrdPrm.pnn_list.num_rcd++;
+
+  if(simShrdPrm.pnn_list.num_rcd > PNN_MAX_RECORDS)
+  {
+    TRACE_EVENT("Max OPL records reached");
+  }
+  else if(simShrdPrm.atb[table_id].recNr <= simShrdPrm.atb[table_id].recMax )
+  {
+    TRACE_EVENT_P1("Read next PNN record: %d",simShrdPrm.atb[table_id].recNr);
+    cmhSIM_OpReadPnnRcd(simShrdPrm.atb[table_id].recNr);
+    return;
+  }
+
+  TRACE_EVENT("Retrieval of PNN records finished");
+
+  /* continue with next one */
+  cmhSIM_StartOperatorName();
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : EONS             MODULE  : CMH_SIMF                     |
+| STATE   : code             ROUTINE : cmhSIM_StartOperatorName     |
++-------------------------------------------------------------------+
+
+  PURPOSE : Start retireval of EF_OPL from SIM
+*/
+GLOBAL BOOL cmhSIM_StartOperatorName()
+{
+  TRACE_FUNCTION ("cmhSIM_StartOperatorName()");
+
+  /* If EF_PNN and/or EF_OPL are allocated then start retrieval of from EF_OPL */
+  if (simShrdPrm.opl_list.num_rcd EQ 0 AND psaSIM_ChkSIMSrvSup(SRV_PNN) AND psaSIM_ChkSIMSrvSup(SRV_OPL))
+  {
+    TRACE_EVENT (" start reading SIM_OPL");
+    return(!cmhSIM_OpReadOplRcd(1));
+  }
+
+  if (simShrdPrm.pnn_list.num_rcd EQ 0 AND psaSIM_ChkSIMSrvSup(SRV_PNN))
+  {
+    TRACE_EVENT (" start reading SIM_PNN");
+    return(!cmhSIM_OpReadPnnRcd(1));
+  }
+
+  TRACE_EVENT (" reading finished!");
+
+  if(psaSIM_ChkSIMSrvSup(SRV_PNN))
+  {
+    if (simShrdPrm.pnn_list.pnn_status EQ TRUE)
+    {
+      percentCSTAT_indication(STATE_MSG_EONS, ENTITY_STATUS_Ready);
+    }
+    else if (psaSIM_ChkSIMSrvSup(SRV_OPL) AND simShrdPrm.opl_list.opl_status EQ TRUE)
+    {
+      percentCSTAT_indication(STATE_MSG_EONS, ENTITY_STATUS_Ready);
+    }
+    else
+    {
+      percentCSTAT_indication(STATE_MSG_EONS, ENTITY_STATUS_NotReady);
+    }
+  }
+  else
+  {
+    percentCSTAT_indication(STATE_MSG_EONS, ENTITY_STATUS_NotReady);
+  }
+
+
+  
+  if (mmShrdPrm.regStat EQ RS_FULL_SRV)
+  {
+    cmhMM_Registered();
+  }
+
+  return(TRUE);
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : EONS             MODULE  : CMH_SIMF                     |
+| STATE   : code             ROUTINE : cmhSIM_UpdateOperatorName    |
++-------------------------------------------------------------------+
+
+  PURPOSE : Start File Update of EF_OPL from SIM
+*/
+GLOBAL BOOL cmhSIM_UpdateOperatorName(USHORT reqDataFld)
+{
+  int i;
+  TRACE_FUNCTION ("cmhSIM_UpdateOperatorName()");
+
+  if (reqDataFld EQ SIM_OPL OR reqDataFld EQ NOT_PRESENT_16BIT)
+  {
+    simShrdPrm.opl_list.num_rcd = 0;
+    for (i=0; i<OPL_MAX_RECORDS; i++)
+    {
+      memcpy (simShrdPrm.opl_list.opl_rcd[i].plmn, 
+              PLMNselEmpty,
+              UBYTES_PER_PLMN);
+    }
+  }
+
+  if (reqDataFld EQ SIM_PNN OR reqDataFld EQ NOT_PRESENT_16BIT)
+  {
+    simShrdPrm.pnn_list.num_rcd = 0;
+    for (i=0; i<PNN_MAX_RECORDS; i++)
+    {
+      simShrdPrm.pnn_list.pnn_rcd[i].v_plmn=FALSE;
+    }
+  }
+
+  return (!cmhSIM_StartOperatorName());
+}
+
+
+GLOBAL T_opl_field* cmhSIM_GetOPL()
+{
+  return &simShrdPrm.opl_list;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_Read_AD       |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function returns the current PLMN mode bit value
+
+*/
+GLOBAL UBYTE cmhSIM_isplmnmodebit_set()
+{
+  return simShrdPrm.PLMN_Mode_Bit;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_ONS_Update    |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function is used to Read the CPHS ONS file EF_ONS.
+
+*/
+
+GLOBAL BOOL cmhSIM_ONS_Update (int ref, T_SIM_FILE_UPDATE_IND *fu)
+{
+  BOOL found = FALSE;
+  UBYTE i;
+  TRACE_FUNCTION ("cmhSIM_ONS_Update()");
+
+  for (i = 0; i < (int)fu->val_nr; i++)
+  {
+    if (fu->file_id[i] EQ SIM_CPHS_ONSTR)
+    {
+      found = TRUE;
+      break;
+    }
+  }
+  if (found)
+  {
+    cmhMM_ONSReadName();
+    simShrdPrm.fuRef = (UBYTE)ref;
+    return FALSE; /* reading files */
+  }
+  else
+  {
+    return TRUE;  /* nothing to do */
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_Get_CSP       |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function is used to request the SIM CPHS file
+
+*/
+GLOBAL void cmhSIM_Get_CSP()
+{
+  
+  TRACE_FUNCTION ("cmhSIM_Get_CSP()");
+
+  cmhSIM_ReadTranspEF( CMD_SRC_NONE,
+                       AT_CMD_NONE,
+                       SIM_CPHS_CINF,
+                       0,
+                       ACI_CPHS_INFO_SIZE,
+                       NULL,
+                       cmhSIM_Get_CSP_cb );
+
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_Get_CSP_cb    |
++--------------------------------------------------------------------+
+
+  PURPOSE :   Call back for SIM read for CPHS.
+
+*/
+void cmhSIM_Get_CSP_cb(SHORT table_id)
+{
+  
+  TRACE_FUNCTION ("cmhSIM_Get_CSP_cb()");
+
+  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
+
+  /* Step #1: Reading of CPHS Info */
+  if (simShrdPrm.atb[table_id].errCode NEQ SIM_NO_ERROR OR
+      simShrdPrm.atb[table_id].exchData EQ NULL         OR
+      simShrdPrm.atb[table_id].dataLen < ACI_CPHS_INFO_SIZE )
+  {
+    ;  /* CPHS info not supported or invalid */
+  }
+  else if ((simShrdPrm.atb[table_id].exchData[1] & 0x03) EQ ALLOCATED_AND_ACTIVATED)
+  {
+    /* continue with reading of CSP file */
+    cmhSIM_Read_CSP();
+    return;
+  }
+
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_AD_Update     |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function is used to request the SIM Customer Service Profile (EF_CPHS_CSP).
+
+*/
+GLOBAL BOOL cmhSIM_CSP_Update (int ref, T_SIM_FILE_UPDATE_IND *fu)
+{
+  BOOL found = FALSE;
+  UBYTE i;
+  TRACE_FUNCTION ("cmhSIM_CSP_Update()");
+
+  for (i = 0; i < (int)fu->val_nr; i++)
+  {
+    if (!found AND (fu->file_id[i] EQ SIM_CPHS_CSP))
+    {
+      found = TRUE;
+    }
+  }
+  if (found)
+  {
+    cmhSIM_Read_CSP();
+    simShrdPrm.fuRef = (UBYTE)ref;
+    return FALSE; /* reading files */
+  }
+  else
+  {
+    return TRUE;  /* nothing to do */
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_Read_CSP       |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function is used to request the SIM Customer Service Profile
+            (EF_CSP).
+
+*/
+GLOBAL void cmhSIM_Read_CSP()
+{
+  
+  TRACE_FUNCTION ("cmhSIM_Read_CSP()");
+
+  cmhSIM_ReadTranspEF( CMD_SRC_NONE,
+                       AT_CMD_NONE,
+                       SIM_CPHS_CSP,
+                       0,
+                       0,
+                       NULL,
+                       cmhSIM_Read_CSP_cb );
+
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : CMH_SIMF             |
+| STATE   : code                      ROUTINE : cmhSIM_Read_CSP_cb    |
++--------------------------------------------------------------------+
+
+  PURPOSE :   Call back for SIM read (EF_CSP).
+
+*/
+void cmhSIM_Read_CSP_cb(SHORT table_id)
+{
+  
+  TRACE_FUNCTION ("cmhSIM_Read_CSP_cb()");
+
+  if ( simShrdPrm.atb[table_id].reqDataFld EQ SIM_CPHS_CSP )
+  {
+    if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR )
+    {
+      if(simShrdPrm.atb[table_id].dataLen >= ACI_CPHS_CSP_SIZE)
+      {
+        USHORT idx;
+        for(idx=0; idx < simShrdPrm.atb[table_id].dataLen; idx = idx+2)
+        {
+         if(simShrdPrm.atb[table_id].exchData[idx] EQ VAS_SERVICE_GROUP_CODE)
+         {
+           if(simShrdPrm.atb[table_id].exchData[idx+1] & PLMN_MODE_BIT_ON)
+           {
+             simShrdPrm.PLMN_Mode_Bit = CPHS_CSP_PLMN_MODE_BIT_ON;
+           }
+           else
+           {
+             simShrdPrm.PLMN_Mode_Bit = CPHS_CSP_PLMN_MODE_BIT_OFF;
+           }
+           break;
+         }
+        }
+      }
+    }
+    
+#ifdef SIM_TOOLKIT
+    if (simShrdPrm.fuRef >= 0)
+    {
+      psaSAT_FUConfirm (simShrdPrm.fuRef,
+                        (USHORT)((simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR)?
+                        SIM_FU_SUCCESS: SIM_FU_ERROR));
+    }
+#endif
+  }
+  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
+}
+
+
+#ifdef SIM_PERS_OTA
+
+/*
++------------------------------------------------------------------------------
+|  Function    : cmhSIM_Register_Read_DCK
++------------------------------------------------------------------------------
+|  Description : This function is used to request the SIM De-personalization Control Keys
+|            (EF_DCK)
+|  Parameters  : ref      - Reference for file update
+|                       *fu     - Pointer to T_SIM_FILE_UPDATE_IND
+|                
+|  Return      : TRUE if no files left to read, 
+|                    FALSE if some files are there to read
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL BOOL cmhSIM_Register_Read_DCK (int ref, T_SIM_FILE_UPDATE_IND *fu)
+{
+  BOOL found = FALSE;
+  UBYTE i;
+
+  TRACE_FUNCTION ("cmhSIM_Register_Read_DCK()");
+
+  for (i = 0; i < (int)fu->val_nr AND (fu->file_id[i] NEQ SIM_DCK); i++)
+  {
+  }
+
+  if (i NEQ (int)fu->val_nr )
+  {
+  
+   if (psaSIM_ChkSIMSrvSup(SRV_DePersCK))
+  {
+    TRACE_FUNCTION("SRV_DePersCK supported.");
+    cmhSIM_ReadTranspEF( CMD_SRC_NONE,
+             AT_CMD_NONE,
+             SIM_DCK,
+             0,
+             16,
+             NULL,
+             cmhSIM_Read_DCK_cb );
+  }
+  
+    simShrdPrm.fuRef = (UBYTE)ref;
+    return FALSE; /* reading files */
+  }
+  else
+  {
+    return TRUE;  /* nothing to do */
+  }
+}
+
+
+
+
+/*
++------------------------------------------------------------------------------
+|  Function    : cmhSIM_Read_DCK_cb
++------------------------------------------------------------------------------
+|  Description : Call back for SIM read (EF_DCK).
+|  Parameters  : SHORT table_id
+|                
+|  Return      : void
+|
++------------------------------------------------------------------------------
+*/
+void cmhSIM_Read_DCK_cb(SHORT table_id)
+{
+  TRACE_FUNCTION ("cmhSIM_Read_DCK_cb()");
+
+  if ( simShrdPrm.atb[table_id].reqDataFld EQ SIM_DCK )
+  {
+    if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR )
+    {
+      aci_slock_psaSIM_decodeIMSI_without_parity (&simShrdPrm.atb[table_id].exchData[0], 8, (char *) nw_ctrl_key);
+      aci_slock_psaSIM_decodeIMSI_without_parity (&simShrdPrm.atb[table_id].exchData[4], 8, (char *) nw_subset_ctrl_key);
+      aci_slock_psaSIM_decodeIMSI_without_parity (&simShrdPrm.atb[table_id].exchData[8], 8, (char *) sp_ctrl_key);
+      aci_slock_psaSIM_decodeIMSI_without_parity (&simShrdPrm.atb[table_id].exchData[12], 8, (char *) corp_ctrl_key);
+
+      aci_slock_unlock(SIMLOCK_NETWORK, (char *) nw_ctrl_key);
+  aci_slock_unlock(SIMLOCK_NETWORK_SUBSET, (char *) nw_subset_ctrl_key);
+  aci_slock_unlock(SIMLOCK_SERVICE_PROVIDER, (char *) sp_ctrl_key);
+  aci_slock_unlock(SIMLOCK_CORPORATE, (char *) corp_ctrl_key);
+      cmhSIM_WriteDefaultValue_DCK();
+    }
+  }
+}
+
+
+/*
++------------------------------------------------------------------------------
+|  Function    : cmhSIM_WriteDefaultValue_DCK
++------------------------------------------------------------------------------
+|  Description : This function is used to write back the SIM De-personalization Control Keys
+|            (EF_DCK) read during init after depersonalizing the ME
+|
+|  Parameters  : none
+|                
+|  Return      : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cmhSIM_WriteDefaultValue_DCK()
+{
+  UBYTE all_keys[MAX_DCK_LEN];
+
+  TRACE_FUNCTION ("cmhSIM_WriteDefaultValue_DCK()");
+  memset(all_keys,NOT_PRESENT_8BIT,MAX_DCK_LEN);
+  cmhSIM_WriteTranspEF( CMD_SRC_NONE,
+             AT_CMD_NONE,
+        SIM_DCK,
+        0,
+        MAX_DCK_LEN,
+        all_keys  ,             
+        NULL );
+}
+
+
+#endif //SIM_PERS_OTA
+/*==== EOF ========================================================*/
+