--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/g23m-gprs/gmm/gmm_kernf.c	Sun Jul 15 04:40:46 2018 +0000
@@ -0,0 +1,3803 @@
+/* 
++----------------------------------------------------------------------------- 
+|  Project :  GPRS (8441)
+|  Modul   :  gmm_kernf.c
++----------------------------------------------------------------------------- 
+|  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 is part of the entity GMM and implements all 
+|             procedures and functions as described in the 
+|             SDL-documentation (KERN-statemachine)
++----------------------------------------------------------------------------- 
+*/ 
+
+
+#ifndef GMM_KERNF_C
+#define GMM_KERNF_C
+#endif
+
+#define ENTITY_GMM
+
+/*==== INCLUDES =============================================================*/
+
+#include "typedefs.h"    /* to get Condat data types */
+#include "vsi.h"        /* to get a lot of macros */
+#include "macdef.h"
+#include "gprs.h"
+#include "gsm.h"        /* to get a lot of macros */
+#include "ccdapi.h"     /* to get CCD API */
+#include "cnf_gmm.h"    /* to get cnf-definitions */
+#include "mon_gmm.h"    /* to get mon-definitions */
+#include "prim.h"       /* to get the definitions of used SAP and directions */
+#include "gmm.h"        /* to get the global entity definitions */
+
+#include "gmm_kernf.h"  /* to get some local definitions */
+#include "gmm_kernl.h"  /* to get some local definitions */
+#include "gmm_f.h"
+#include <string.h>     /* to get memset */
+#include "pcm.h"
+#include "gmm_rxf.h"
+#include "gmm_rxs.h"
+#include "gmm_txf.h"
+#include "gmm_rdyf.h"
+#include "gmm_syncs.h"
+#include "gmm_kernp.h"
+#include "gmm_rdys.h"
+#include "gmm_syncf.h"
+#include "gmm_em.h"     /* To get Engineering Mode functions */
+
+#ifdef _TARGET_
+#include "ffs/ffs.h"
+#endif
+
+#include "cl_imei.h"  /* IMEI common library */
+
+#include <stdlib.h>
+
+#include <stdio.h>      /* for sprintf */
+
+/*==== CONST ================================================================*/
+
+/*==== LOCAL VARS ===========================================================*/
+
+/*==== PRIVATE FUNCTIONS ====================================================*/
+
+/*==== PUBLIC FUNCTIONS =====================================================*/
+/*
++------------------------------------------------------------------------------
+| Function    : kern_gmmreg_info_ind
++------------------------------------------------------------------------------
+| Description : The function kern_gmmreg_info_ind forwards the info comming
+|               from the net to the MMI entity
+|       
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_gmmreg_info_ind ( void)
+{ 
+  GMM_TRACE_FUNCTION( "kern_gmmreg_info_ind" );
+  {
+	  MCAST(gmm_information, GMM_INFORMATION);
+    /* Agilent Issue OMAPS00148436 WA */
+    if (!gmm_information->v_full_network_name && !gmm_information->v_short_network_name 
+        && !gmm_information->v_time_zone && !gmm_information->v_time_zone_and_time)
+    { 
+      TRACE_EVENT ("GMM_INFORMATION message doesn't contain valid information"); 
+      GMM_RETURN; 
+    } 
+    {
+
+    PALLOC (gmmreg_info_ind, GMMREG_INFO_IND); /* T_GMMREG_INFO_IND */
+  
+    /* 
+     * Set PLMN, this will be used if network name is given
+     */
+    gmmreg_info_ind->plmn.v_plmn = TRUE;       
+    memcpy (gmmreg_info_ind->plmn.mcc, gmm_data->kern.attach_cap.rai_accepted.mcc, SIZE_MCC);
+    memcpy (gmmreg_info_ind->plmn.mnc, gmm_data->kern.attach_cap.rai_accepted.mnc, SIZE_MNC);
+
+    /*
+     * Set full network name, if present
+     */
+
+      if (gmm_information->v_full_network_name) 
+      {
+        gmmreg_info_ind->full_net_name_gmm.v_name     = TRUE;
+        gmmreg_info_ind->full_net_name_gmm.dcs /* TCS 2.1 */
+            = gmm_information->full_network_name.code;
+        gmmreg_info_ind->full_net_name_gmm.add_ci    
+         = gmm_information->full_network_name.add_ci;
+        gmmreg_info_ind->full_net_name_gmm.num_spare  = 
+          gmm_information->full_network_name.nr_sparebits;
+        memset(gmmreg_info_ind->full_net_name_gmm.text, 0, MMR_MAX_TEXT_LEN);
+        gmmreg_info_ind->full_net_name_gmm.c_text = 
+          MINIMUM (MMR_MAX_TEXT_LEN, gmm_information->full_network_name.c_text_string);
+        memcpy (gmmreg_info_ind->full_net_name_gmm.text,
+            gmm_information->full_network_name.text_string,
+            gmmreg_info_ind->full_net_name_gmm.c_text);
+      }
+      else
+      {
+        gmmreg_info_ind->full_net_name_gmm.v_name = FALSE;
+      }
+      /* Set short network name, if present */
+      if (gmm_information->v_short_network_name) 
+      {
+        gmmreg_info_ind->short_net_name_gmm.v_name    = TRUE;
+        gmmreg_info_ind->short_net_name_gmm.dcs       = gmm_information->short_network_name.code;  /* TCS 2.1 */
+        gmmreg_info_ind->short_net_name_gmm.add_ci    = gmm_information->short_network_name.add_ci;
+        gmmreg_info_ind->short_net_name_gmm.num_spare = 
+        gmm_information->short_network_name.nr_sparebits;
+        memset(gmmreg_info_ind->short_net_name_gmm.text, 0, MMR_MAX_TEXT_LEN);
+        gmmreg_info_ind->short_net_name_gmm.c_text = 
+        MINIMUM (MMR_MAX_TEXT_LEN, gmm_information->short_network_name.c_text_string);
+        memcpy (gmmreg_info_ind->short_net_name_gmm.text,
+          gmm_information->short_network_name.text_string,
+          gmmreg_info_ind->short_net_name_gmm.c_text);
+      }
+      else
+      {
+        gmmreg_info_ind->short_net_name_gmm.v_name = FALSE;
+      }
+      /* Set network time zone, if present */
+      if (gmm_information->v_time_zone)
+      {
+        gmmreg_info_ind->net_time_zone.v_time_zone = TRUE;
+        gmmreg_info_ind->net_time_zone.time_zone 
+            = gmm_information->time_zone.time_zone_value;
+      }
+      else
+      {
+        gmmreg_info_ind->net_time_zone.v_time_zone = FALSE;
+      }
+      /* Set network time zone and time, if present */
+      if (gmm_information->v_time_zone_and_time)
+      {
+        gmmreg_info_ind->net_time_zone.v_time_zone = TRUE;
+        gmmreg_info_ind->net_time_zone.time_zone   
+            = gmm_information->time_zone_and_time.time_zone_value;
+        gmmreg_info_ind->net_time.v_time = TRUE;
+
+        gmmreg_info_ind->net_time.year = 
+          10 * gmm_information->time_zone_and_time.year[0] + 
+               gmm_information->time_zone_and_time.year[1];
+        gmmreg_info_ind->net_time.month = 
+          10 * gmm_information->time_zone_and_time.month[0] + 
+               gmm_information->time_zone_and_time.month[1];
+        gmmreg_info_ind->net_time.day = 
+          10 * gmm_information->time_zone_and_time.day[0] +
+               gmm_information->time_zone_and_time.day[1];
+        gmmreg_info_ind->net_time.hour = 
+          10 * gmm_information->time_zone_and_time.hour[0] + 
+               gmm_information->time_zone_and_time.hour[1];
+        gmmreg_info_ind->net_time.minute =
+          10 * gmm_information->time_zone_and_time.minute[0] +
+               gmm_information->time_zone_and_time.minute[1];
+        gmmreg_info_ind->net_time.second = 
+          10 * gmm_information->time_zone_and_time.second[0] +
+               gmm_information->time_zone_and_time.second[1];
+      }
+      else
+      {
+        gmmreg_info_ind->net_time.v_time = FALSE;
+      }
+
+#ifdef REL99
+      if (gmm_information->v_daylight_save_time) /* TCS 4.0 */
+      { /* TCS 4.0 */
+        gmmreg_info_ind->net_daylight_save_time =  /* TCS 4.0 */
+          gmm_information->daylight_save_time.save_time_value; /* TCS 4.0 */
+      } /* TCS 4.0 */
+      else /* TCS 4.0 */
+      { /* TCS 4.0 */
+        gmmreg_info_ind->net_daylight_save_time = GMMREG_ADJ_NO; /* TCS 4.0 */
+      } /* TCS 4.0 */
+#endif
+
+    PSEND ( hCommMMI, gmmreg_info_ind);
+	}
+  }
+  GMM_RETURN;
+} /* kern_gmmreg_info_ind() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_calculate_digits
++------------------------------------------------------------------------------
+| Description : Derives tm mobile identiti for the AIR
+|
+| COPIED FROM : MM    mm_mmf.c : mm_calculate_digits
+|               
+| Parameters  : mobile_identity   - used in the AIR message
+|
++------------------------------------------------------------------------------
+*/
+LOCAL UBYTE kern_calculate_digits (UBYTE *digits)
+{
+  UBYTE i = 0;
+
+  GMM_TRACE_FUNCTION ("kern_calculate_digits()");
+
+  while (digits[i] < 0x0A AND i < 16)
+    i++;
+
+  GMM_RETURN_ (i);
+}
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mmgmmreg_attach_cnf
++------------------------------------------------------------------------------
+| Description : This procedure sends the gmmreg_attach_cnf primitiv to ACI
+|
+| Parameters  : attach_type - attach type
+|               mmgmm_reg_req - the primitiv
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mmgmmreg_attach_cnf ( UBYTE attach_type, UBYTE search_running,
+                                      T_MMGMM_REG_CNF * mmgmm_reg_cnf )
+{ 
+  GMM_TRACE_FUNCTION( "kern_mmgmmreg_attach_cnf" );
+
+    TRACE_1_INFO ("Info: MM  lac: %x", mmgmm_reg_cnf->lac);
+
+  switch (gmm_data->kern.sig_cell_info.gmm_status)
+  {
+    case GMMRR_SERVICE_LIMITED:
+    case GMMRR_SERVICE_NONE:
+      search_running=SEARCH_NOT_RUNNING;
+      break;
+    default:
+    case GMMRR_SERVICE_FULL:
+      break;
+  }
+
+
+  gmm_data->kern.mm_cell_env.cid = mmgmm_reg_cnf->cid;
+  gmm_data->kern.mm_cell_env.rai.lac = mmgmm_reg_cnf->lac;
+  gmm_data->kern.mm_cell_env.rai.plmn = mmgmm_reg_cnf->plmn;
+
+  GMM_TRACE_GMM_DATA(GMM_DEBUG_PRINT_MASK_CID);
+
+  {
+    PALLOC ( gmmreg_attach_cnf, GMMREG_ATTACH_CNF );
+      gmmreg_attach_cnf->attach_type = attach_type;
+      /*
+       * gmmreg_attach_cnf->plmn = gmm_data->mm_plmn= mmgmm_reg_cnf->plmn;
+       */
+      gmmreg_attach_cnf->plmn = mmgmm_reg_cnf->plmn;
+      gmmreg_attach_cnf->search_running = search_running;
+      gmmreg_attach_cnf->lac = mmgmm_reg_cnf->lac;
+      gmmreg_attach_cnf->rac =  gmm_data->kern.sig_cell_info.env.rai.rac;
+      //gmmreg_attach_cnf->cid = gmm_data->kern.sig_cell_info.env.cid; // #HM#
+      gmmreg_attach_cnf->cid = mmgmm_reg_cnf->cid; // #HM#
+      gmmreg_attach_cnf->gprs_indicator = gmm_data->kern.sig_cell_info.gmm_status;
+      gmmreg_attach_cnf->bootup_cause = REG_END;
+#ifdef GMM_TCS4
+      gmmreg_attach_cnf->rt = gmm_data->kern.sig_cell_info.rt; // TCS 4.0
+#endif
+#ifdef TRACE_EVE
+      {
+        switch (attach_type)
+        {
+          case GMMREG_AT_COMB:
+            TRACE_EVENT ("MS is combined attached.");
+            break;
+          case GMMREG_AT_IMSI:
+            TRACE_EVENT ("MS is GSM-only attached.");
+            break;
+          case GMMREG_AT_GPRS:
+            TRACE_EVENT ("MS is GPRS-only attached.");
+            break;
+          default:
+            TRACE_ERROR ("MS is attached with wrong attach type.");
+            break;
+        }
+      TRACE_7_PARA("%x%x%x, %x%x%x, lac %x", 
+          gmmreg_attach_cnf->plmn.mcc[0],
+          gmmreg_attach_cnf->plmn.mcc[1],
+          gmmreg_attach_cnf->plmn.mcc[2],
+          gmmreg_attach_cnf->plmn.mnc[0],
+          gmmreg_attach_cnf->plmn.mnc[1],
+          gmmreg_attach_cnf->plmn.mnc[2],
+          gmmreg_attach_cnf->lac);
+     }
+#endif
+   
+    PSEND ( hCommMMI, gmmreg_attach_cnf );
+    
+    gmm_data->kern.attach_cap.gmmreg = FALSE;
+  }
+  GMM_RETURN;
+} /* kern_mmgmmreg_attach_cnf () */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_gmmreg_attach_cnf
++------------------------------------------------------------------------------
+| Description : This procedure sends the gmmreg_attach_cnf primitiv to ACI
+|
+| Parameters  : attach_type - attach type
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_gmmreg_attach_cnf ( UBYTE attach_type)
+{ 
+  GMM_TRACE_FUNCTION( "kern_gmmreg_attach_cnf" );
+  kern_gmmreg_attach_cnf_sr(attach_type,SEARCH_NOT_RUNNING);
+  GMM_RETURN;
+} /* kern_gmmreg_attach_cnf () */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_gmmreg_attach_cnf_sr
++------------------------------------------------------------------------------
+| Description : This procedure sends the gmmreg_attach_cnf primitiv to ACI
+|
+| Parameters  : attach_type - attach type
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_gmmreg_attach_cnf_sr ( UBYTE attach_type, UBYTE search_running)
+{ 
+  GMM_TRACE_FUNCTION( "kern_gmmreg_attach_cnf_sr" );
+  TRACE_2_OUT_PARA("%s, %s",
+      search_running==SEARCH_RUNNING? "searching":"finished",
+      attach_type==GMMREG_AT_COMB?    "comb":
+      attach_type==GMMREG_AT_GPRS?"gprs":
+      attach_type==GMMREG_AT_IMSI?"gsm":
+                                   "unknown tpe"
+     );
+
+  {
+    PALLOC ( gmmreg_attach_cnf, GMMREG_ATTACH_CNF );
+      gmmreg_attach_cnf->attach_type = attach_type;
+      gmmreg_attach_cnf->plmn.v_plmn = TRUE;
+      gmmreg_attach_cnf->search_running= search_running;
+      memcpy ( gmmreg_attach_cnf->plmn.mcc, gmm_data->kern.sig_cell_info.env.rai.plmn.mcc, SIZE_MCC);
+      memcpy ( gmmreg_attach_cnf->plmn.mnc, gmm_data->kern.sig_cell_info.env.rai.plmn.mnc, SIZE_MNC);
+      gmmreg_attach_cnf->lac = gmm_data->kern.sig_cell_info.env.rai.lac;
+      gmmreg_attach_cnf->rac = gmm_data->kern.sig_cell_info.env.rai.rac;
+      gmmreg_attach_cnf->cid = gmm_data->kern.sig_cell_info.env.cid;
+      gmmreg_attach_cnf->gprs_indicator = gmm_data->kern.sig_cell_info.gmm_status;      
+      gmmreg_attach_cnf->bootup_cause = REG_END;
+#ifdef GMM_TCS4
+      gmmreg_attach_cnf->rt = gmm_data->kern.sig_cell_info.rt; /* TCS 4.0 */
+#endif
+    PSEND ( hCommMMI, gmmreg_attach_cnf );
+    
+    gmm_data->kern.attach_cap.gmmreg = FALSE;
+
+    /* 
+     * ACI does not realize GSM detach if search running has been set
+     * in kern_mmgmm_nreg_cnf 
+     */
+    if (GMMRR_NET_MODE_III==gmm_data->kern.sig_cell_info.net_mode
+    && GMMREG_CLASS_BG==  gmm_data->kern.attach_cap.mobile_class
+    && GMMREG_AT_GPRS==attach_type)
+    {
+      kern_gmmreg_detach (GMMREG_DT_IMSI,
+                        GMMCS_LIMITED_SERVICE,  /* TCS 2.1 */
+                        SEARCH_NOT_RUNNING,
+                        GMMCS_LIMITED_SERVICE);
+    }
+  }
+  GMM_RETURN;
+} /* kern_gmmreg_attach_cnf_sr () */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_gmmreg_detach
++------------------------------------------------------------------------------
+| Description : This procedure sends the gmmreg_detach primitiv to ACI
+|
+| Parameters  : detach_type    - detach type
+|                cause           - error cause
+|               search_running - cell search still running or not
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_gmmreg_detach ( UBYTE detach_type, 
+                                 USHORT service,
+                                 UBYTE search_running,
+                                 USHORT cause)
+{
+  UBYTE mm_state;
+
+  GMM_TRACE_FUNCTION( "kern_gmmreg_detach" );
+
+  mm_state = GET_STATE(MM);
+
+  if (GMMREG_DT_GPRS==detach_type
+  &&  (  GMM_MM_DEREG==mm_state
+      || GMM_MM_REG_NO_CELL_AVAILABLE==mm_state
+      || GMM_MM_REG_INITATED_VIA_GPRS==mm_state
+      || MMGMM_LIMITED_SERVICE==gmm_data->kern.sig_cell_info.mm_status )
+  )
+  {
+    detach_type = GMMREG_DT_COMB;
+  }
+
+  TRACE_3_OUT_PARA("%s, cause: 0x%x, %s",
+        detach_type==GMMREG_DT_COMB?    "comb":
+        detach_type==GMMREG_DT_IMSI?    "gsm":
+        detach_type==GMMREG_DT_GPRS?"gprs":
+        detach_type==GMMREG_DT_POWER_OFF?"power off":
+        detach_type==GMMREG_DT_SIM_REMOVED?"sim removed":
+        detach_type==GMMREG_DT_LIMITED_SERVICE?"limited":
+        detach_type==GMMREG_DT_SOFT_OFF?"soft off":
+                                            "unknown type"
+          , cause,
+       (search_running==GMMREG_SEARCH_RUNNING?"searching":"finished"));
+
+  if ( gmm_data->kern.detach_cap.gmmreg )
+  {
+    PALLOC ( gmmreg_detach_cnf, GMMREG_DETACH_CNF );
+      gmmreg_detach_cnf->detach_type = gmm_data->kern.detach_cap.detach_type;
+    PSEND ( hCommMMI, gmmreg_detach_cnf );
+  }
+  else
+  {
+    if ( gmm_data->kern.attach_cap.gmmreg )
+    {
+      if (GMMREG_CLASS_CG==gmm_data->kern.attach_cap.mobile_class
+      && GMMREG_DT_IMSI==detach_type)
+      {
+        kern_gmmreg_attach_cnf_sr(GMMREG_AT_GPRS, search_running);
+      }
+      else
+      {
+        PALLOC ( gmmreg_attach_rej, GMMREG_ATTACH_REJ );
+          gmmreg_attach_rej->detach_type = detach_type;
+          gmmreg_attach_rej->cause = cause;
+          gmmreg_attach_rej->search_running = search_running;
+          gmmreg_attach_rej->service = service;
+        PSEND ( hCommMMI, gmmreg_attach_rej );
+      }
+      if (GMMREG_SEARCH_NOT_RUNNING==search_running)
+      {
+        gmm_data->kern.attach_cap.gmmreg=FALSE;
+      }
+
+    }
+    else /* if ! gmmreg */
+    {
+      /* 
+       * If gmmsm == TRUE means, we are in GMM_REGISTERED_INITIATED state.
+       * That means, if ACI did not send an attach request ACI need not
+       * to be informed, otherwise we are attached in ACI has to be informed
+       */
+#ifndef GMM_TCS4
+      if ( !gmm_data->kern.attach_cap.gmmsm )
+#endif 
+      {
+        PALLOC ( gmmreg_detach_ind, GMMREG_DETACH_IND );
+          gmmreg_detach_ind->detach_type = detach_type;
+          gmmreg_detach_ind->cause = cause;
+          gmmreg_detach_ind->search_running = search_running;
+          gmmreg_detach_ind->service = service;
+        PSEND ( hCommMMI, gmmreg_detach_ind );
+      }
+    }
+  }
+  gmm_data->kern.detach_cap.gmmreg=FALSE;
+  /*
+   * Clear data before Power Off
+   */
+  if (GMMREG_DT_POWER_OFF==detach_type)
+  {
+    /*
+     * every servce i reinitilized that the test sysem may run
+     * with out real power off
+     */
+    kern_init();
+    rxgmm_init();
+    txgmm_init();
+    rdy_init();
+    sync_gmm_init();
+
+    /*
+     * In kern_init the deep is set to 0 for MACRO GMM_RETURN
+     */
+    return;
+  }
+  GMM_RETURN;
+} /* kern_gmmreg_detach () */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_llgmm_assign_tlli
++------------------------------------------------------------------------------
+| Description : This procedure assigned the given TLLI parameter to LLC 
+|
+| Parameters  : new_tlli_type - type of new TLLI (random, local ,..)
+|               old_tlli_type - type of old TLLI
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_llgmm_assign_tlli ( T_TLLI_TYPE new_tlli_type,
+                                     T_TLLI_TYPE old_tlli_type )
+{ 
+  GMM_TRACE_FUNCTION( "kern_llgmm_assign_tlli" );
+
+  if( GMM_LLC_STATE_UNASSIGNED EQ gmm_data->kern.attach_cap.llc_state )
+  {
+    gmm_data->kern.attach_cap.llc_state = GMM_LLC_STATE_ASSIGNED;
+  }
+  {
+    PALLOC ( llgmm_assign_req, LLGMM_ASSIGN_REQ );
+      llgmm_assign_req->old_tlli = gmm_get_tlli ( old_tlli_type );
+      if ( GMMRR_TMSI_INVALID == gmm_data->ptmsi.current )
+      {
+        /*
+         * <R.GMM.TLLIUSE.M.005>
+         */
+        llgmm_assign_req->new_tlli = gmm_get_tlli (  RANDOM_TLLI );
+      }
+      else
+      {
+        llgmm_assign_req->new_tlli = gmm_get_tlli ( new_tlli_type );
+      }
+      if (NO_KEY== gmm_data->kern.auth_cap.cksn)
+      {
+        memset (llgmm_assign_req->llgmm_kc.key, 0x0, MAX_KC);
+      }
+      else
+      {
+        memcpy ( llgmm_assign_req->llgmm_kc.key, gmm_data->kern.auth_cap.kc, MAX_KC );
+      }
+      llgmm_assign_req->ciphering_algorithm = LLGMM_CIPHER_NA;
+ 
+      TRACE_2_OUT_PARA("TLLI old: 0x%X, new: 0x%X",  llgmm_assign_req->old_tlli,llgmm_assign_req->new_tlli);
+
+    PSEND ( hCommLLC, llgmm_assign_req );
+  }
+  GMM_RETURN;
+} /* kern_llgmm_assign_tlli() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_llgmm_assign
++------------------------------------------------------------------------------
+| Description : This procedure assigned the current TLLI parameter to LLC 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_llgmm_assign ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_llgmm_assign" );
+  kern_llgmm_assign_tlli ( CURRENT_TLLI, OLD_TLLI );
+  GMM_RETURN;
+} /* kern_llgmm_assign() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_gmmsm_establish_rej
++------------------------------------------------------------------------------
+| Description : This procedure informs SM that gprs is off. 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_gmmsm_establich_rej ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_gmmsm_stablich_rej" );
+
+#ifdef GMM_TCS4 
+
+  {
+     PALLOC (mmpm_detach_ind, MMPM_DETACH_IND);
+     mmpm_detach_ind->ps_cause = kern_make_new_cause();
+     /*For reattach, overwrite the cause from kern_make_new_cause()*/
+     if (GMM_DT_RE_ATTACH == gmm_data->kern.detach_cap.detach_type) {
+       mmpm_detach_ind->ps_cause.ctrl_value = CAUSE_is_from_mm;
+       mmpm_detach_ind->ps_cause.value.mm_cause = 
+                                 (U16)CAUSE_MM_DETACH_WITH_REATTACH;
+     }
+     PSEND ( hCommSM, mmpm_detach_ind);
+  }
+  
+#else  /*New TI DK primitive should be sent*/
+ if ( gmm_data->kern.attach_cap.gmmsm )
+  {
+    PALLOC ( gmmsm_establish_rej, GMMSM_ESTABLISH_REJ );
+      gmmsm_establish_rej->sm_cause = gmm_data->kern.detach_cap.error_cause; 
+    PSEND ( hCommSM, gmmsm_establish_rej );
+  }
+  else // if !gmmsm 
+  {
+    
+    //  <R.GMM.PRELIND.M.001>
+    
+    PALLOC ( gmmsm_release_ind, GMMSM_RELEASE_IND);
+    PSEND ( hCommSM, gmmsm_release_ind );
+  } 
+
+#endif
+
+
+
+  GMM_RETURN;
+} /* kern_gmmsm_establish_rej() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_llgmm_unassign
++------------------------------------------------------------------------------
+| Description : This procedure unassigned all TLLIs in LLC 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_llgmm_unassign ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_llgmm_unassign" );
+
+  switch (gmm_data->kern.attach_cap.llc_state)
+  {
+    case GMM_LLC_STATE_UNASSIGNED:
+      GMM_RETURN;
+    default:
+    case GMM_LLC_STATE_ASSIGNED:
+    case GMM_LLC_STATE_SUSPENED:
+    case GMM_LLC_STATE_SUSPENED_RAU:
+      gmm_data->kern.attach_cap.llc_state = GMM_LLC_STATE_UNASSIGNED;
+      break;
+  }
+
+
+
+  /*
+   * PTMSI is still valid for next attach
+   * gmm_data->ptmsi.current = GMMRR_TMSI_INVALID;
+   */
+  gmm_data->ptmsi.new_grr = GMMRR_TMSI_INVALID;
+
+  gmm_data->tlli.old=gmm_data->tlli.current;
+  gmm_data->tlli.current_type = INVALID_TLLI;
+  gmm_data->tlli.current=GMMRR_TMSI_INVALID;
+
+  TRACE_0_OUT_PARA("Unassign");
+  {
+    PALLOC ( gmmrr_assign_req, GMMRR_ASSIGN_REQ );
+      gmmrr_assign_req->old_tlli  = GMMRR_TLLI_INVALID;
+      gmmrr_assign_req->new_tlli  = GMMRR_TLLI_INVALID;
+      gmmrr_assign_req->old_ptmsi = GMMRR_TMSI_INVALID;
+      gmmrr_assign_req->new_ptmsi = GMMRR_TMSI_INVALID;
+      gmmrr_assign_req->imsi  = gmm_data->imsi;
+      gmmrr_assign_req->rai.plmn.v_plmn=TRUE;
+      memcpy (gmmrr_assign_req->rai.plmn.mcc, gmm_data->kern.attach_cap.rai_accepted.mcc, SIZE_MCC);
+      memcpy (gmmrr_assign_req->rai.plmn.mnc, gmm_data->kern.attach_cap.rai_accepted.mnc, SIZE_MNC);
+      gmmrr_assign_req->rai.lac = gmm_data->kern.attach_cap.rai_accepted.lac;
+      gmmrr_assign_req->rai.rac = gmm_data->kern.attach_cap.rai_accepted.rac;
+    PSEND ( hCommGRR, gmmrr_assign_req );
+  }
+  {
+    PALLOC (llgmm_assign_req, LLGMM_ASSIGN_REQ);
+
+    /* gmm_data->tlli.current_type=INVALID_TLLI; */
+    
+    llgmm_assign_req->old_tlli = LLGMM_TLLI_INVALID;
+    llgmm_assign_req->new_tlli = LLGMM_TLLI_INVALID;
+
+    memset (llgmm_assign_req->llgmm_kc.key,0, sizeof (llgmm_assign_req->llgmm_kc.key));
+   
+    llgmm_assign_req->ciphering_algorithm = LLGMM_CIPHER_NO_ALGORITHM;    
+    kern_reset_cipher ();
+    
+    PSEND ( hCommLLC, llgmm_assign_req );
+  }
+ 
+  GMM_RETURN;     
+} /* kern_llgmm_unassign() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_llgmm_suspend
++------------------------------------------------------------------------------
+| Description : This procedure suspends  LLC 
+|
+| Parameters  : susp_cause - cause off suspension
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_llgmm_suspend ( UBYTE susp_cause)
+{ 
+  U8 cell_state=GMMREG_CS_CALL;
+#ifdef GMM_TCS4 
+  U8 mm_cause = CAUSE_MM_DEDICATED_MODE;      
+#endif
+
+  GMM_TRACE_FUNCTION( "kern_llgmm_suspend" );
+  /*
+   * if LLC is in suspended RAU it means that GRR has opned the GMM queue
+   * so we have to remember.
+   */
+  switch (gmm_data->kern.attach_cap.llc_state)
+  {
+    case GMM_LLC_STATE_SUSPENED_RAU:
+      GMM_RETURN;
+    case GMM_LLC_STATE_UNASSIGNED:
+      TRACE_ERROR ("suspending of LLC in state unassigned ignored");
+      GMM_RETURN;
+    default:
+    case GMM_LLC_STATE_ASSIGNED:
+    case GMM_LLC_STATE_SUSPENED:
+      break;
+  }
+
+  switch (susp_cause)
+  {
+    case LLGMM_CALL:
+      TRACE_0_OUT_PARA("call");
+      
+      cell_state=GMMREG_CS_CALL;
+#ifdef GMM_TCS4
+      mm_cause = CAUSE_MM_DEDICATED_MODE;      
+#endif
+      break;
+
+    case LLGMM_LIMITED:      
+      TRACE_0_OUT_PARA("limited");      
+      cell_state=GMMREG_LIMITED_SERVICE;
+#ifdef GMM_TCS4
+      mm_cause = CAUSE_MM_LIMITED_SERVICE;      
+#endif
+      break;
+      
+    case LLGMM_NO_GPRS_SERVICE:
+      TRACE_0_OUT_PARA("no_service");
+      cell_state=GMMREG_GPRS_NOT_SUPPORTED;
+#ifdef GMM_TCS4
+      mm_cause = CAUSE_MM_NO_SERVICE;      
+#endif
+      break;
+
+    case LLGMM_RAU:
+      cell_state=GMMREG_TRY_TO_UPDATE;
+#ifdef GMM_TCS4
+      mm_cause = CAUSE_MM_TRY_TO_UPDATE;      
+#endif
+
+      if(GET_STATE(CU) EQ CU_CELL_RES_SENT
+      || GET_STATE(CU) EQ CU_REQUESTED_CELL_RES_SENT)
+      {
+        susp_cause= LLGMM_PERIODIC_RAU;
+        /* NO break; */
+      }
+      else
+      {
+        gmm_data->kern.attach_cap.llc_state=GMM_LLC_STATE_SUSPENED_RAU;
+        TRACE_0_OUT_PARA("rau");          
+        break;
+      }
+      /* GS, how would you solve it with V8?*/ 
+    case LLGMM_PERIODIC_RAU:
+      if (GMM_LLC_STATE_SUSPENED==gmm_data->kern.attach_cap.llc_state)
+      {
+        GMM_RETURN;
+      }
+      else
+      {
+        TRACE_0_OUT_PARA("periodic rau");
+        cell_state=GMMREG_TRY_TO_UPDATE;
+#ifdef GMM_TCS4
+        mm_cause = CAUSE_MM_TRY_TO_UPDATE;      
+#endif
+      }
+      break;
+    default:
+      TRACE_ERROR("llc_susp unexpected");
+      break;
+  }
+  
+  if (GMM_LLC_STATE_SUSPENED_RAU!=gmm_data->kern.attach_cap.llc_state)
+  {
+    gmm_data->kern.attach_cap.llc_state= GMM_LLC_STATE_SUSPENED;
+  }
+  
+  {
+    PALLOC (llgmm_suspend_req, LLGMM_SUSPEND_REQ);
+      llgmm_suspend_req->susp_cause = susp_cause;
+    PSEND  ( hCommLLC, llgmm_suspend_req );
+  }
+
+  {
+    PALLOC(gmmreg_suspend_ind, GMMREG_SUSPEND_IND);
+      gmmreg_suspend_ind->cell_state= cell_state;
+    PSEND(hCommMMI,gmmreg_suspend_ind);
+  }
+#ifdef GMM_TCS4 
+  {
+    PALLOC(mmpm_suspend_ind, MMPM_SUSPEND_IND);
+      mmpm_suspend_ind->ps_cause.ctrl_value = CAUSE_is_from_mm;      
+      mmpm_suspend_ind->ps_cause.value.mm_cause = mm_cause;      
+    PSEND(hCommSM,mmpm_suspend_ind);
+  }
+#endif 
+  GMM_RETURN;     
+} /* kern_llgmm_suspend() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_llgmm_resume
++------------------------------------------------------------------------------
+| Description : This procedure resumes  LLC 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_llgmm_resume ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_llgmm_resume" );
+ 
+  switch(gmm_data->kern.attach_cap.llc_state)
+  {
+    case GMM_LLC_STATE_SUSPENED_RAU:
+    case GMM_LLC_STATE_SUSPENED:
+      {
+        PALLOC (llgmm_resume_req, LLGMM_RESUME_REQ);
+          gmm_data->kern.attach_cap.llc_state=GMM_LLC_STATE_ASSIGNED;
+        PSEND  ( hCommLLC, llgmm_resume_req );
+      }
+      {
+        PALLOC (gmmreg_resume_ind, GMMREG_RESUME_IND);
+        PSEND  ( hCommMMI, gmmreg_resume_ind );
+      }
+    
+#ifdef GMM_TCS4
+      {
+        PALLOC(mmpm_resume_ind, MMPM_RESUME_IND);
+        PSEND(hCommSM,mmpm_resume_ind);
+      }
+#endif
+      break;
+    case GMM_LLC_STATE_ASSIGNED:
+    default:
+      break;
+    case GMM_LLC_STATE_UNASSIGNED:
+      TRACE_ERROR("resuming LLC in state unassigned");
+      kern_llgmm_assign();
+      break;
+  }
+  kern_gmmrr_stop_waiting_for_transmission();
+  GMM_RETURN;     
+} /* kern_llgmm_suspend() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_gmmrr_enable
++------------------------------------------------------------------------------
+| Description : The function kern_enable() 
+|               disables GRR and activates MM to act as a class CC mobile.
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_gmmrr_enable ( void )
+{
+  GMM_TRACE_FUNCTION ("kern_gmmrr_enable()");
+  gmm_data->kern.attach_cap.mobile_class_changed = FALSE;
+  {
+    PALLOC ( gmmrr_enable_req, GMMRR_ENABLE_REQ );
+      TRACE_EVENT ("GRR is on");
+      gmm_data->kern.attach_cap.grr_state = GMM_GRR_STATE_ON;
+      gmmrr_enable_req->mobile_class = gmm_data->kern.attach_cap.mobile_class;
+      gmmrr_enable_req->acc_contr_class = gmm_data->acc_contr_class;
+      if (DRX_NOT_USED==gmm_data->drx_parameter.split_pg_cycle_code)
+      {
+         gmmrr_enable_req->split_pg_cycle = 704/* GMMREG_NO_DRX*/; 
+      }
+      else if (gmm_data->drx_parameter.split_pg_cycle_code<65)
+      {
+        gmmrr_enable_req->split_pg_cycle 
+          = gmm_data->drx_parameter.split_pg_cycle_code; 
+      } 
+      else if (gmm_data->drx_parameter.split_pg_cycle_code<=98)
+      {
+        const USHORT cycle_array[] = 
+        {
+          71, 72, 74, 75, 77, 79, 80, 83, 86, 88, 90, 92, 96, 101, 103, 107,
+          112,116, 118, 128, 141, 144, 150, 160, 171, 176, 192, 214, 224, 235, 
+          256, 288, 320, 352 
+        };
+        
+        gmmrr_enable_req->split_pg_cycle
+           = cycle_array[gmm_data->drx_parameter.split_pg_cycle_code-65];
+      }
+      else
+      {
+        gmmrr_enable_req->split_pg_cycle = 1;
+      } 
+
+      if( gmm_data->drx_parameter.split_on_ccch EQ SPLIT_NO )
+      {
+        gmmrr_enable_req->spgc_ccch_supp = GMMRR_SPGC_CCCH_SUPP_NO;
+      }
+      else
+      {
+        gmmrr_enable_req->spgc_ccch_supp = GMMRR_SPGC_CCCH_SUPP_YES;
+      }
+
+      gmmrr_enable_req->gmmrr_non_drx_timer = gmm_data->drx_parameter.non_drx_timer;
+
+    PSEND ( hCommGRR, gmmrr_enable_req );
+  }
+  GMM_RETURN;
+} /* kern_gmmrr_ensable () */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_gmmrr_disable
++------------------------------------------------------------------------------
+| Description : The function kern_gmmrr_disable switches off GRR
+|
+| Parameters  : cm_estasblish_res - OK or NOT to establish the CM
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_gmmrr_disable ( void )
+{
+  GMM_TRACE_FUNCTION ("kern_gmmrr_disable()");
+  TRACE_EVENT ("GRR is off");
+
+  /*gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC;*/
+  gmm_data->kern.attach_cap.attach_type &= ~GMMREG_AT_GPRS;
+
+  gmm_data->kern.attach_cap.grr_state = GMM_GRR_STATE_OFF;
+  gmm_data->kern.suspension_type &= ~GMM_SUSP_LOCAL_DETACH;
+
+  /* This code is applicable only for Release 99 */
+#ifdef REL99
+  gmm_data->ptmsi_signature.available = FALSE;
+  gmm_data->ptmsi_signature.value     = INVALID_PTMSI_SIGNATURE;
+#endif
+
+  kern_llgmm_unassign();
+
+
+  {
+    PALLOC ( gmmrr_disable_req, GMMRR_DISABLE_REQ );
+    PSEND ( hCommGRR, gmmrr_disable_req );
+  }
+  /* kern_mm_activate_mm (); */
+  GMM_RETURN;
+} /* kern_gmmrr_disable () */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_cm_establish_res
++------------------------------------------------------------------------------
+| Description : The function mm_cm_establish_res is a response whether a CS call
+|                is possible or not
+|
+| Parameters  : cm_estasblish_res - OK or NOT to establish the CM
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_cm_establish_res ( UBYTE cm_establish_res  )
+{
+  GMM_TRACE_FUNCTION ("kern_mm_cm_establish_res ()");
+  {
+    PALLOC ( mmgmm_cm_establish_res, MMGMM_CM_ESTABLISH_RES);
+      mmgmm_cm_establish_res->cm_establish_res = cm_establish_res;
+      gmm_data->kern.suspension_type &= ~GMM_SUSP_CALL;
+    PSEND ( hCommMM, mmgmm_cm_establish_res );
+  }
+  GMM_RETURN;
+} /* kern_mm_establish_res () */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_cm_emergency_res
++------------------------------------------------------------------------------
+| Description : The function mm_cm_emrgency_res is a response whether a
+|               emergnecy call is possible or not
+|
+| Parameters  : cm_estasblish_res - OK or NOT to establish the CM
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_cm_emergency_res ( UBYTE cm_establish_res  )
+{
+  GMM_TRACE_FUNCTION ("kern_mm_cm_emergency_res ()");
+  {
+    PALLOC ( mmgmm_cm_emergency_res, MMGMM_CM_EMERGENCY_RES);
+      mmgmm_cm_emergency_res->cm_establish_res = cm_establish_res;
+    PSEND ( hCommMM, mmgmm_cm_emergency_res );
+    gmm_data->kern.suspension_type &= ~GMM_SUSP_EM_CALL;
+  }
+  GMM_RETURN;
+} /* kern_mm_emergency_res () */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_net_req
++------------------------------------------------------------------------------
+| Description : The function kern_mm_net_req sends the promitve to MM
+|       
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_net_req ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_mm_net_req" );
+  {
+    PALLOC ( mmgmm_net_req, MMGMM_NET_REQ );
+    PSEND ( hCommMM, mmgmm_net_req);
+  }
+  GMM_RETURN;
+} /* kern_mm_net_req() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_start_t3212
++------------------------------------------------------------------------------
+| Description : This procedure is called: "If the detach type information
+|               element value indicates "GPRS detach without switching off ?and
+|               the MS is attached for GPRS and non-GPRS services and the 
+|               network operates in network operation mode I, then if in the MS
+|               the timer T3212 is not already running, the timer T3212 shall be
+|               set to its initial value and restarted after the DETACH REQUEST
+|               message has been sent."
+|
+|               <R.GMM.DINITM.M.007>
+|    
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_start_t3212 ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_mm_start_t3212" );
+  {  
+    PALLOC ( mmgmm_start_t3212_req, MMGMM_START_T3212_REQ );
+    PSEND ( hCommMM, mmgmm_start_t3212_req);
+  }
+  GMM_RETURN;
+} /* kern_mm_start_t3212() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_ssim_authentication_req
++------------------------------------------------------------------------------
+| Description : The function kern_sim_authentication_req
+|       
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_sim_authentication_req ( UBYTE *random, UBYTE cksn )
+{ 
+  GMM_TRACE_FUNCTION( "kern_sim_authentication_req" );
+  {
+    PALLOC (sim_authentication_req, SIM_AUTHENTICATION_REQ);
+      sim_authentication_req->source = SRC_GMM;
+#ifdef GMM_TCS4
+      sim_authentication_req->req_id = gmm_data->kern.auth_cap.last_auth_req_id;
+#endif
+      memcpy ( 
+        sim_authentication_req->rand, random, MAX_RAND);
+        sim_authentication_req->cksn = cksn;
+    PSEND (hCommSIM, sim_authentication_req);
+  }
+  GMM_RETURN;
+} /* kern_mm_authentication_req() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_attach_started
++------------------------------------------------------------------------------
+| Description : The function kern_mm_attach_started sends the primitive 
+|                mmgmm_attach_started_req to MM
+|       
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_attach_started ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_mm_attach_started" );
+
+  SET_STATE ( MM, GMM_MM_REG_INITATED_VIA_GPRS);
+  {  
+    PALLOC ( mmgmm_attach_started_req, MMGMM_ATTACH_STARTED_REQ );
+    PSEND ( hCommMM, mmgmm_attach_started_req);
+  }
+  GMM_RETURN;
+} /* kern_mm_attach_started() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_auth_rej
++------------------------------------------------------------------------------
+| Description : The function kern_mm_atuth_rej sends the primitive 
+|                mmgmm_auth_req to MM
+|       
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_auth_rej ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_mm_auth_rej" );  
+  {  
+    PALLOC ( mmgmm_auth_rej_req, MMGMM_AUTH_REJ_REQ );
+    PSEND ( hCommMM, mmgmm_auth_rej_req);  
+  }
+  GMM_RETURN;
+} /* kern_mm_attach_rej() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_attach_rej
++------------------------------------------------------------------------------
+| Description : The function kern_mm_attach_rej sends the primitive 
+|                mmgmm_attach_rej_req to MM.  The primitive is always sent if 
+|               responce from MM is expected, .i.e no MMGMM_NREG_CNF
+|       
+| Parameters  : error_cause - the error cause given by the net or
+|               MMGMM_AAC_OVER_5 if attach_attempt_counter is greater or equal 
+|               than 5
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_attach_rej ( USHORT error_cause )
+{ 
+  GMM_TRACE_FUNCTION( "kern_mm_attach_rej" );
+
+    //if (GMM_MM_REG_INITATED_VIA_GPRS==gmm_data->mm_imsi_attached)
+    {
+      PALLOC ( mmgmm_attach_rej_req, MMGMM_ATTACH_REJ_REQ );
+        /*
+         * Anite B2 TC 44.2.1.2.8
+         */
+      SET_STATE ( MM, GMM_MM_DEREG);
+
+      mmgmm_attach_rej_req-> cause = error_cause;  /* TCS 2.1 */
+      PSEND ( hCommMM, mmgmm_attach_rej_req);  
+    }
+    /*
+    else
+    {
+        kern_mm_imsi_detach_ind ( error_cause, MMGMM_DETACH_DONE);
+    }
+    */
+  GMM_RETURN;
+} /* kern_mm_attach_rej() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_attach_acc
++------------------------------------------------------------------------------
+| Description : The function kern_mm_attach_acc  sends the promitve to MM. 
+|       
+| Parameters  : mobile_identity -  TMSI given by the network
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_attach_acc ( BOOL                v_mobile_identity,  /* TCS 2.1 */
+                                 T_mobile_identity * mobile_identity, /* TCS 2.1 */
+                                 BOOL                v_eqv_plmn_list, /* TCS 2.1 */
+                                 T_eqv_plmn_list   * eqv_plmn_list /* TCS 2.1 */
+                               ) /* TCS 2.1 */
+{ 
+  GMM_TRACE_FUNCTION( "kern_mm_attach_acc" );
+  /* 
+   * HM: This catches never...
+   * Patch HM 07-Aug-01, make GMM2503 pass >>>
+   * GMM thinks it performs a combined attach in network mode I, 
+   * but the truth is we came from network mode I and are now 
+   * performing the non-combined procedures in network mode II.
+   */
+  if ( GMM_MM_REG_INITATED_VIA_GPRS == GET_STATE(MM)  )
+  /* Patch HM 07-Aug-01, make GMM2503 pass <<< */
+  {
+    PALLOC ( mmgmm_attach_acc_req, MMGMM_ATTACH_ACC_REQ );
+
+    sig_kern_sync_set_mm_state ( MMGMM_FULL_SERVICE );
+    
+    gmm_data->kern.mm_cell_env.rai.lac = gmm_data->kern.sig_cell_info.env.rai.lac;
+    gmm_data->kern.mm_cell_env.rai.plmn = gmm_data->kern.sig_cell_info.env.rai.plmn;
+    mmgmm_attach_acc_req->v_tmsi = v_mobile_identity;
+    mmgmm_attach_acc_req->lac = gmm_data->kern.mm_cell_env.rai.lac;
+    mmgmm_attach_acc_req->plmn.v_plmn = TRUE;
+    memcpy(mmgmm_attach_acc_req->plmn.mnc,gmm_data->kern.mm_cell_env.rai.plmn.mnc,SIZE_MNC);  
+    memcpy (mmgmm_attach_acc_req->plmn.mcc, gmm_data->kern.mm_cell_env.rai.plmn.mcc,SIZE_MCC);
+    mmgmm_attach_acc_req->tmsi = 
+      (v_mobile_identity?gmm_data->tmsi:MMGMM_TMSI_INVALID);
+    mmgmm_attach_acc_req->v_equ_plmn_list = v_eqv_plmn_list; /* TCS 2.1 */
+    if (v_eqv_plmn_list)  /* TCS 2.1 */
+      memcpy(&mmgmm_attach_acc_req->equ_plmn_list, eqv_plmn_list, sizeof(T_equ_plmn_list)); /* TCS 2.1 */
+    PSEND ( hCommMM, mmgmm_attach_acc_req);
+  }
+  else
+  {
+    PALLOC ( mmgmm_allowed_req, MMGMM_ALLOWED_REQ );
+    mmgmm_allowed_req->lac = gmm_data->kern.attach_cap.rai_accepted.lac;
+    mmgmm_allowed_req->plmn.v_plmn = TRUE;
+    memcpy(mmgmm_allowed_req->plmn.mnc,gmm_data->kern.attach_cap.rai_accepted.mnc,SIZE_MNC);  
+    memcpy (mmgmm_allowed_req->plmn.mcc, gmm_data->kern.attach_cap.rai_accepted.mcc,SIZE_MCC);
+    mmgmm_allowed_req->v_equ_plmn_list = v_eqv_plmn_list; /* TCS 2.1 */
+    if (v_eqv_plmn_list) /* TCS 2.1 */
+      memcpy(&mmgmm_allowed_req->equ_plmn_list, eqv_plmn_list, sizeof(T_equ_plmn_list));   /* TCS 2.1 */
+    PSEND ( hCommMM, mmgmm_allowed_req);
+  }
+  GMM_RETURN;
+} /* kern_mm_attach_acc() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_reg_req
++------------------------------------------------------------------------------
+| Description : The function kern_mm_reg_req sends the primitive 
+|                MMGMM_REG_REQ to MM
+|       
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_reg_req (U8 reg_type, U8 bootup_act)
+{ 
+  GMM_TRACE_FUNCTION( "kern_mm_reg_req" );  
+  {  
+    PALLOC ( mmgmm_reg_req, MMGMM_REG_REQ ); /* T_MMGMM_REG_REQ */
+    mmgmm_reg_req->reg_type     = reg_type;
+    mmgmm_reg_req->service_mode = gmm_data->kern.attach_cap.service_mode;
+    mmgmm_reg_req->mobile_class = gmm_data->kern.attach_cap.mobile_class;
+    mmgmm_reg_req->bootup_act   = bootup_act;
+    PSEND ( hCommMM, mmgmm_reg_req );
+  }
+  GMM_RETURN;
+} /* kern_mm_attach_rej() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_activate_rr
++------------------------------------------------------------------------------
+| Description : The MMGMM_ACTIVATE_REQ is used to initiate GPRS Cell Selection
+|                in RR. Cell selection for CS only is triggered implicitly be 
+|                activating MM (i.e. the MS is operates as a class CC mobile) by
+|                sending the primitive discribed in function kern_mm_activate_mm
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_activate_rr ( void )
+{
+  GMM_TRACE_FUNCTION ("kern_mm_activate_rr()");
+
+  if (gmm_data->kern.attach_cap.network_selection_mode EQ MODE_AUTO)
+  {
+    kern_mm_reg_req (REG_CELL_SEARCH_ONLY, NORMAL_REG);
+  }
+  else
+  {
+    PALLOC ( mmgmm_plmn_res, MMGMM_PLMN_RES ); /* T_MMGMM_PLMN_RES */
+      mmgmm_plmn_res->plmn         = gmm_data->kern.attach_cap.plmn_requested;
+      mmgmm_plmn_res->reg_type     = REG_CELL_SEARCH_ONLY;
+      mmgmm_plmn_res->mobile_class = gmm_data->kern.attach_cap.mobile_class;
+    PSEND ( hCommMM, mmgmm_plmn_res );
+  }
+
+  kern_gmmrr_enable();
+  GMM_RETURN;
+} /* kern_mm_activate_rr () */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_activate_mm
++------------------------------------------------------------------------------
+| Description : The MM_ACTIVATE_MM_REQ is used to request MM to act as
+|               an GSM-only mobile. 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_activate_mm ( void )
+{
+  GMM_TRACE_FUNCTION ("kern_mm_activate_mm()");
+  
+  if (GMMREG_CLASS_CG!=gmm_data->kern.attach_cap.mobile_class)
+  {
+    /*
+     * remember lau initiated
+     */
+     gmm_data->kern.attach_cap.mm_lau_attempted = TRUE;
+
+     if (gmm_data->kern.attach_cap.network_selection_mode EQ MODE_AUTO)
+     {
+        kern_mm_reg_req (REG_GPRS_INACTIVE, NORMAL_REG);
+     }
+     else
+     {
+        PALLOC ( mmgmm_plmn_res, MMGMM_PLMN_RES ); /* T_MMGMM_PLMN_RES */
+        mmgmm_plmn_res->plmn         = gmm_data->kern.attach_cap.plmn_requested;
+        mmgmm_plmn_res->reg_type     = REG_GPRS_INACTIVE;
+        mmgmm_plmn_res->mobile_class = gmm_data->kern.attach_cap.mobile_class;
+        PSEND ( hCommMM, mmgmm_plmn_res );
+     }
+  }
+  GMM_RETURN;
+} /* kern_mm_activate_rr () */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_local_detach_open_proc
++------------------------------------------------------------------------------
+| Description : The function kern_local_detach_open_proc() calls all open 
+|            issues to be done upon receiving GMMRR_SUSPEND_CNF
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_local_detach_open_proc (void )
+{
+  GMM_TRACE_FUNCTION( "kern_local_detach_open_proc" );
+
+  TRACE_1_INFO ("open %d",gmm_data->kern.detach_cap.local_detach_open_proc);
+
+
+  switch ( gmm_data->kern.detach_cap.local_detach_open_proc)
+  {
+    case GMM_LOCAL_DETACH_PROC_RESUME:
+      kern_resume_grr_der();
+      break;
+    case GMM_LOCAL_DETACH_PROC_ENTER_NULL_IMSI:
+      SET_STATE (KERN, KERN_GMM_NULL_IMSI);
+      EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI);
+      /* If GMM entered No Cell Available & after coming back to GSM only N/W, the user does a manual 
+       * detach, then it is necessary for GMM to disable GRR & enable GSM only mode through MM */
+      kern_gmmrr_disable();
+      kern_mm_activate_mm();
+      break;
+    case GMM_LOCAL_DETACH_PROC_ENTER_NULL_NO_IMSI:
+      SET_STATE (KERN, KERN_GMM_NULL_NO_IMSI);
+      EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI);
+
+      break;
+    case GMM_LOCAL_DETACH_PROC_ENTER_NULL_IMSI_LIMITED_SERVICE_REQ:
+      SET_STATE (KERN, KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ);
+      EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ);
+
+      break;
+    case GMM_LOCAL_DETACH_PROC_ENTER_REG_NORMAL:
+      kern_enter_reg_normal();
+      break;
+    case GMM_LOCAL_DETACH_PROC_ENTER_DEREG:
+      kern_enter_der();
+      break;
+    case GMM_LOCAL_DETACH_PROC_UNASSIGN:
+      kern_llgmm_unassign();
+      kern_resume_grr_der();
+      break;      
+    case GMM_LOCAL_DETACH_PROC_SUSP_LAU:
+      gmm_data->kern.suspension_type &= ~GMM_SUSP_LOCAL_DETACH;
+      kern_mm_lau();
+      break;
+    case GMM_LOCAL_DETACH_PROC_RE_ATTACH:
+    
+      TRACE_0_OUT_PARA("Unassign");
+      gmm_data->tlli.old=gmm_data->tlli.current;
+      gmm_data->tlli.current_type = INVALID_TLLI;
+      gmm_data->tlli.current=GMMRR_TMSI_INVALID;
+      gmm_data->kern.attach_cap.llc_state = GMM_LLC_STATE_UNASSIGNED;
+      {
+        PALLOC (llgmm_assign_req, LLGMM_ASSIGN_REQ);
+
+        gmm_data->tlli.current_type=INVALID_TLLI;
+          
+        llgmm_assign_req->old_tlli = LLGMM_TLLI_INVALID;
+        llgmm_assign_req->new_tlli = LLGMM_TLLI_INVALID;
+
+        memset (llgmm_assign_req->llgmm_kc.key,0, sizeof (llgmm_assign_req->llgmm_kc.key));
+         
+        kern_reset_cipher ();
+        llgmm_assign_req->ciphering_algorithm = LLGMM_CIPHER_NO_ALGORITHM;
+          
+        PSEND ( hCommLLC, llgmm_assign_req );
+      }
+
+      kern_resume_grr_der();
+
+      //kern_attach_reset();
+      //kern_attach();
+
+      break;
+    case GMM_LOCAL_DETACH_PROC_RAU:
+      kern_rau();
+      break;
+    case GMM_LOCAL_DETACH_PROC_DISABLE:
+      if (gmm_data->sim_gprs_invalid)
+      {
+        SET_STATE ( KERN, KERN_GMM_NULL_NO_IMSI);
+        EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI);
+
+      }
+      else
+      {
+        SET_STATE ( KERN, KERN_GMM_NULL_IMSI);
+        EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI);
+
+      }
+      
+      kern_gmmrr_disable();
+      kern_mm_activate_mm ();
+      break;
+    case GMM_LOCAL_DETACH_PROC_COMB_DISABLE:
+      SET_STATE ( KERN, KERN_GMM_NULL_NO_IMSI);
+      EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI);
+      gmm_data->kern.attach_cap.attach_type = GMMREG_AT_NOT_KNOWN;
+      kern_gmmrr_disable();
+      kern_mm_activate_mm ();
+      break;
+    case GMM_LOCAL_DETACH_PROC_AUTH_FAILED:
+      SET_STATE ( KERN, KERN_GMM_DEREG_NO_IMSI);
+      EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI);
+      gmm_data->kern.attach_cap.attach_type = GMMREG_AT_NOT_KNOWN;
+      kern_gmmrr_disable();
+      kern_mm_imsi_detach_ind ( GMMCS_AUTHENTICATION_REJECTED,  /* TCS 2.1 */
+        GET_STATE(MM)==GMM_MM_DEREG?
+          MMGMM_DETACH_DONE:
+          MMGMM_PERFORM_DETACH,			  
+          gmm_data->kern.detach_cap.detach_type  );
+      break;
+    case GMM_LOCAL_DETACH_PROC_SIM_REMOVED:
+      SET_STATE ( KERN, KERN_GMM_DEREG_NO_IMSI);
+      EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI);
+      gmm_data->kern.attach_cap.attach_type = GMMREG_AT_NOT_KNOWN;
+      kern_gmmrr_disable();
+      kern_mm_imsi_detach_ind ( GMMCS_SIM_REMOVED,  /* TCS 2.1 */
+        GET_STATE(MM)==GMM_MM_DEREG?
+          MMGMM_DETACH_DONE:
+          MMGMM_PERFORM_DETACH,
+          gmm_data->kern.detach_cap.detach_type);
+
+      break;
+    case GMM_LOCAL_DETACH_PROC_POWER_OFF:
+      SET_STATE (KERN, KERN_GMM_DEREG_NO_IMSI);
+      EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI);
+      vsi_t_stop  ( GMM_handle, kern_TPOWER_OFF);
+      kern_gmmrr_disable();
+      kern_mm_imsi_detach_ind ( GMMCS_POWER_OFF,  /* TCS 2.1 */
+        GET_STATE(MM)==GMM_MM_DEREG?
+          MMGMM_DETACH_DONE:
+          MMGMM_PERFORM_DETACH,
+          gmm_data->kern.detach_cap.detach_type);
+
+      break;
+    case GMM_LOCAL_DETACH_PROC_SOFT_OFF:
+      
+      if (gmm_data->sim_gprs_invalid)
+      {
+        SET_STATE (KERN, KERN_GMM_DEREG_NO_IMSI);
+        EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI);
+      }
+      else
+      {
+          SET_STATE (KERN, KERN_GMM_NULL_IMSI);
+          EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI);
+      }
+      vsi_t_stop  ( GMM_handle, kern_TPOWER_OFF);
+      kern_gmmrr_disable();
+      kern_mm_imsi_detach_ind ( GMMCS_POWER_OFF,  /* TCS 2.1 */
+        GET_STATE(MM)==GMM_MM_DEREG?
+          MMGMM_DETACH_DONE:
+          MMGMM_PERFORM_DETACH,
+          gmm_data->kern.detach_cap.detach_type);
+
+      break;
+
+    case GMM_LOCAL_DETACH_PROC_NOT_CHANGED:
+    case GMM_LOCAL_DETACH_PROC_NOTHING:
+    default:
+      if (GMM_GRR_STATE_SUSPENDED==gmm_data->kern.attach_cap.grr_state)
+      {
+        kern_resume_grr_der();
+      }
+      break;
+  }
+  gmm_data->kern.detach_cap.local_detach_open_proc=GMM_LOCAL_DETACH_PROC_NOTHING;
+  GMM_RETURN;
+} /* kern_kern_local_detach_open_proc () */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_local_detach
++------------------------------------------------------------------------------
+| Description : The function kern_local_detach() .... 
+|
+| Parameters  : error_cause - error cause
+|
+|               gmm_data->kern.detach_cap.detach_type MUST be set !
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_local_detach ( USHORT error_cause, BOOL det_acc_sent, T_LOCAL_DETACH_PROC local_detach_open_proc )
+{
+  /* 
+   * compiler cl470.exe test: replace local variable detach_type with 
+   *                          gmm_data...detach_type
+   * => you may get an assembler error (because switch condition
+   *    modified within case statement ??)
+   */
+  UBYTE detach_type = gmm_data->kern.detach_cap.detach_type;
+  UBYTE kern_gmm_save_state = GET_STATE(KERN);
+
+  GMM_TRACE_FUNCTION( "kern_local_detach" );
+
+  if (GMM_LOCAL_DETACH_PROC_NOT_CHANGED!=local_detach_open_proc)
+  {
+    gmm_data->kern.detach_cap.local_detach_open_proc=local_detach_open_proc;
+  }
+  else
+  {
+    if(GMM_LOCAL_DETACH_PROC_NOTHING EQ gmm_data->kern.detach_cap.local_detach_open_proc)
+    {
+      TRACE_ERROR ("GMM_LOCAL_DETACH_PROC_NOTHING called");
+    }
+  }
+  
+  if ( gmm_data->kern.local_detached)
+  /*local_detach_done */
+  {
+    TRACE_0_INFO ("kern_local_detach() called already");
+    gmm_data->kern.local_detached = FALSE;
+    kern_local_detach_open_proc();
+    GMM_RETURN;
+  }
+  gmm_data->kern.local_detached = TRUE;
+  
+  switch (detach_type)
+  {
+    case GMMREG_DT_IMSI:
+      break;
+    case GMMREG_DT_POWER_OFF:
+      SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDING );
+      EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING );
+
+      kern_gmmsm_establich_rej();
+
+      if (det_acc_sent)
+      {
+        gmm_data->kern.suspension_type            |= GMM_SUSP_LOCAL_DETACH;
+        sig_kern_rdy_start_timer_req( kern_TPOWER_OFF, TPOWER_OFF_VALUE);
+      }
+      else
+      {
+        vsi_t_start ( GMM_handle , kern_TPOWER_OFF, TPOWER_OFF_VALUE);
+        kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LOCAL_DETACH);
+      }
+      break;
+    default:
+      SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDING );
+      EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING );
+      kern_gmmsm_establich_rej();
+
+      if (det_acc_sent)
+      {
+        gmm_data->kern.suspension_type            |= GMM_SUSP_LOCAL_DETACH;
+        sig_kern_rdy_start_timer_req( kern_TLOCAL_DETACH, TLOCAL_DETACH_VALUE);
+      }
+      else
+      {
+        kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LOCAL_DETACH);
+      }
+      break;
+  }  
+  /*
+   * LABEL UNASSIGN_GMMREG
+   */
+
+  vsi_t_stop ( GMM_handle , kern_T3321);
+
+  switch ( detach_type )
+  {
+    case GMM_DT_RE_ATTACH:
+      GMM_RETURN;
+    case GMMREG_DT_LIMITED_SERVICE:
+    case GMMREG_DT_SIM_REMOVED:
+      gmm_data->kern.detach_cap.local_detach_open_proc=
+        (GMMCS_AUTHENTICATION_REJECTED== error_cause? /* TCS 2.1 */
+                   GMM_LOCAL_DETACH_PROC_AUTH_FAILED:
+                   GMM_LOCAL_DETACH_PROC_SIM_REMOVED);
+      kern_gmmreg_detach (gmm_data->kern.detach_cap.detach_type, error_cause,
+                          GMMREG_SEARCH_NOT_RUNNING, error_cause);
+
+      break;
+    case GMMREG_DT_POWER_OFF:
+    case GMMREG_DT_SOFT_OFF:
+     /* If GPRS is already suspended and power switch off is to be done, 
+      * kern_local_detach_open_proc() will not be called as GMM will not receive
+      * GMMRR_SUSPEND_CNF from GRR, as GRR is already suspended */
+      if (kern_gmm_save_state EQ KERN_GMM_REG_SUSPENDED)
+      {
+          gmm_data->kern.local_detached = FALSE;
+          kern_local_detach_open_proc();
+      }
+      break;
+    case GMMREG_DT_IMSI:
+      kern_mm_attach_rej ( error_cause );
+      kern_gmmreg_detach (gmm_data->kern.detach_cap.detach_type, error_cause,
+                          GMMREG_SEARCH_NOT_RUNNING, error_cause);
+      gmm_data->kern.local_detached = FALSE;
+      kern_local_detach_open_proc();
+
+      break;
+    case GMMREG_DT_COMB:
+      kern_mm_attach_rej ( error_cause );
+      kern_gmmreg_detach (gmm_data->kern.detach_cap.detach_type, error_cause,
+                          GMMREG_SEARCH_NOT_RUNNING, error_cause);
+      break;
+    case GMMREG_DT_DISABLE_GPRS:
+      gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC;
+      gmm_data->kern.attach_cap.attach_type &= ~GMMREG_AT_GPRS;
+      /* NO break; */
+    case GMMREG_DT_GPRS:
+      break;
+    default:
+      TRACE_ERROR ( "Unexpected detach_type in DETACH LABEL" );
+      break;
+  }
+
+  GMM_RETURN;   
+} /* kern_local_detach() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_get_imeisv
++------------------------------------------------------------------------------
+| Description : The function kern_get_imeisv
+|               copied from MM: void csf_read_imei (T_imsi *imei) 
+|       
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_get_imeisv (T_gmobile_identity *imei)
+{
+  UBYTE buf[CL_IMEI_SIZE];
+
+
+  GMM_TRACE_FUNCTION( "kern_get_imeisv" );
+#ifdef TDSGEN
+  imei->identity_digit[0]        = 0x04;
+  imei->identity_digit[1]        = 0x04;
+  imei->identity_digit[2]        = 0x06;
+  imei->identity_digit[3]        = 0x00;
+  imei->identity_digit[4]        = 0x01;
+  imei->identity_digit[5]        = 0x09;
+  imei->identity_digit[6]        = 0x01;
+  imei->identity_digit[7]        = 0x09;
+  imei->identity_digit[8]        = 0x07;
+  imei->identity_digit[9]        = 0x05;
+  imei->identity_digit[10]       = 0x00;
+  imei->identity_digit[11]       = 0x07;
+  imei->identity_digit[12]       = 0x05;
+  imei->identity_digit[13]       = 0x09;
+  imei->identity_digit[14]       = 0x00;
+  imei->identity_digit[15]       = 0x00;/* Software Version Number */
+
+#else /* TDSGEN */
+  /*
+   * Get IMEISV from IMEI common library
+   */
+  cl_get_imeisv(CL_IMEI_SIZE, buf, CL_IMEI_GET_SECURE_IMEI);
+  imei->identity_digit[0]  = (buf [0] >> 4) & 0x0F; /* TAC 8 byte */
+  imei->identity_digit[1]  =  buf [0] & 0x0F;
+  imei->identity_digit[2]  = (buf [1] >> 4) & 0x0F;
+  imei->identity_digit[3]  =  buf [1] & 0x0F;
+  imei->identity_digit[4]  = (buf [2] >> 4) & 0x0F;
+  imei->identity_digit[5]  =  buf [2] & 0x0F;
+  imei->identity_digit[6]  = (buf [3] >> 4) & 0x0F;
+  imei->identity_digit[7]  =  buf [3] & 0x0F;
+  imei->identity_digit[8]  = (buf [4] >> 4) & 0x0F; /* SNR 6 byte */
+  imei->identity_digit[9]  =  buf [4] & 0x0F;
+  imei->identity_digit[10] = (buf [5] >> 4) & 0x0F;
+  imei->identity_digit[11] =  buf [5] & 0x0F;
+  imei->identity_digit[12] = (buf [6] >> 4) & 0x0F;
+  imei->identity_digit[13] =  buf [6] & 0x0F;
+  imei->identity_digit[14] = (buf [7] >> 4) & 0x0F; /* SV 2 byte */
+  imei->identity_digit[15] =  buf [7] & 0x0F;
+  TRACE_EVENT_P8("GMM INFO IMEI: TAC %1x%1x%1x%1x%1x%1x%1x%1x",
+                  imei->identity_digit[0], imei->identity_digit[1],
+                  imei->identity_digit[2], imei->identity_digit[3],
+                  imei->identity_digit[4], imei->identity_digit[5],
+                  imei->identity_digit[6], imei->identity_digit[7]);
+  TRACE_EVENT_P6("GMM INFO IMEI: SNR %1x%1x%1x%1x%1x%1x",
+                  imei->identity_digit[8],  imei->identity_digit[9],
+                  imei->identity_digit[10], imei->identity_digit[11],
+                  imei->identity_digit[12], imei->identity_digit[13]);
+  TRACE_EVENT_P2("GMM INFO IMEI: SV  %1x%1x", imei->identity_digit[14],
+                                              imei->identity_digit[15]);
+
+#endif /* not defined TDSGEN */
+
+  imei->v_identity_digit = TRUE;
+  imei->c_identity_digit =  16;
+  
+  imei->type_of_identity = ID_TYPE_IMEISV;
+  imei->odd_even   = 0;
+
+  GMM_RETURN;
+} /* kern_get_imeisv() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_get_imei
++------------------------------------------------------------------------------
+| Description : The function kern_get_imei
+|               copied from MM: void csf_read_imei (T_imsi *imei) 
+|       
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_get_imei (T_gmobile_identity *imei)
+{   
+  GMM_TRACE_FUNCTION( "kern_get_imei" );
+  kern_get_imeisv(imei);
+
+  /*
+     * get imeisv returns 16 digits, but imei has only 14 digits
+     * thus clear last byte:
+     */
+    imei->identity_digit[14] =  0;
+    imei->identity_digit[15] =  0;
+    imei->v_identity_digit   = TRUE;
+    imei->c_identity_digit   = 15;
+
+
+  imei->type_of_identity = ID_TYPE_IMEI;
+  imei->odd_even   = 1;
+  GMM_RETURN;
+} /* kern_get_imei() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_read_pcm
++------------------------------------------------------------------------------
+| Description : The function kern_read_pcm
+|       
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL void kern_read_pcm ( void )
+{
+#ifdef _TARGET_    
+  T_GMM_FFS ffsBuffer;
+  T_FFS_SIZE size = ffs_fread("/GPRS/gmm", &ffsBuffer, sizeof(ffsBuffer));
+  TRACE_FUNCTION( "kern_read_pcm" );
+
+  
+  if ( size != sizeof(ffsBuffer) )
+  {
+    if ( size < 0 )
+    {
+      TRACE_EVENT_P1("FFS can not read \"/GPRS/gmm\" (%d)", size);
+    }
+    else
+    {
+      TRACE_EVENT_P2("FFS contains old file of \"/GPRS/gmm\": %dBytes long, but %dBytes expected",
+                      size, sizeof(ffsBuffer));
+    }
+  }
+  else
+  {
+    gmm_data->config.cipher_on = ffsBuffer.cipher_on;
+    
+    TRACE_1_INFO("GEA2=%d", (gmm_data->config.cipher_on & 0x02)>0);
+    TRACE_1_INFO("GEA3=%d", (gmm_data->config.cipher_on & 0x04)>0);
+    TRACE_1_INFO("GEA4=%d", (gmm_data->config.cipher_on & 0x08)>0);
+    TRACE_1_INFO("GEA5=%d", (gmm_data->config.cipher_on & 0x10)>0);
+    TRACE_1_INFO("GEA6=%d", (gmm_data->config.cipher_on & 0x20)>0);
+    TRACE_1_INFO("GEA7=%d", (gmm_data->config.cipher_on & 0x40)>0);
+    
+  }
+#endif /* NOT DEFINED _SIMULATION_ */
+  return;
+}
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_build_ms_network_capability
++------------------------------------------------------------------------------
+| Description : The function kern_build_ms_network_capability() .... 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_build_ms_network_capability (T_ms_network_capability *ms_network_capability)
+{
+  T_mob_class_2 mob_class_2;
+  EXTERN  void rr_csf_get_classmark2 (T_mob_class_2 *mob_class_2);
+
+  GMM_TRACE_FUNCTION ("kern_build_ms_network_capability()");
+
+  rr_csf_get_classmark2 (&mob_class_2);
+
+#ifdef REL99
+  // HM 20-Jun-2003 Release 1999 >>>
+  // Ensure these IEs are not accidently included in the uplink message
+  // until Release 1999 is completely implemented in GMM
+  memset (ms_network_capability, 0, sizeof (T_ms_network_capability));
+  // HM 20-Jun-2003 Release 1999 <<<
+#endif
+
+  if (gmm_data->config.cipher_on)
+  {
+    ms_network_capability->gea_1                  = GEA_1_YES;
+    TRACE_EVENT ("ciphering on requested");
+  }
+  else
+  {
+    ms_network_capability->gea_1                  = GEA_1_NO;
+    TRACE_EVENT ("ciphering off requested");
+  }
+
+  ms_network_capability->ss_screening_indicator = mob_class_2.ss_screen;
+  ms_network_capability->sm_capabilities_gsm    = mob_class_2.mt_pp_sms;
+  ms_network_capability->sm_capabilities_gprs   = SM_CAP_GPRS_YES;
+  ms_network_capability->ucs2_support           = UCS2_YES;
+  /* 
+   * R99 definitions must be set to 0
+   */
+
+    ms_network_capability->solsa_capability       = NO;
+#ifdef REL99
+    ms_network_capability->rev_level_ind          = REV_LEVEL_IND_99_YES;
+    ms_network_capability->pfc_feature_mode       = YES;
+#else
+	ms_network_capability->rev_level_ind          = REV_LEVEL_IND_99_NO;
+    ms_network_capability->pfc_feature_mode       = NO;
+#endif
+  /* 
+   * end of R99 definitions
+   */
+  ms_network_capability->ext_gea_bits.gea_2     = (gmm_data->config.cipher_on & 0x02)>0;
+  ms_network_capability->ext_gea_bits.gea_3     = (gmm_data->config.cipher_on & 0x04)>0;
+  ms_network_capability->ext_gea_bits.gea_4     = (gmm_data->config.cipher_on & 0x08)>0;
+  ms_network_capability->ext_gea_bits.gea_5     = (gmm_data->config.cipher_on & 0x10)>0;
+  ms_network_capability->ext_gea_bits.gea_6     = (gmm_data->config.cipher_on & 0x20)>0;
+  ms_network_capability->ext_gea_bits.gea_7     = (gmm_data->config.cipher_on & 0x40)>0;
+
+#ifdef TDSGEN
+  ms_network_capability->sm_capabilities_gsm    = SM_CAP_GSM_NO;
+  ms_network_capability->ss_screening_indicator = 0;
+#endif
+
+  GMM_RETURN;
+} /* kern_build_ms_network_capability () */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_init
++------------------------------------------------------------------------------
+| Description : The function kern_init() .... 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_init ( void )
+{ 
+  int i;
+  TRACE_FUNCTION( "kern_init" );
+
+  /*gmm_data->gprs_enabled = TRUE;*/
+  /*
+   * Initialise service KERN with state KERN_READY.
+   */
+  INIT_STATE ( KERN, KERN_GMM_NULL_NO_IMSI );
+
+#ifdef TRACE_FUNC
+#ifdef IDENTATION
+  gmm_data->deep=0;
+#endif
+#endif
+  gmm_data->anite               = FALSE;
+  gmm_data->tlli.current        = LLGMM_TLLI_INVALID;
+  gmm_data->tlli.old            = LLGMM_TLLI_INVALID;
+  gmm_data->kern.local_detached = FALSE; 
+  gmm_data->tlli.current_type   = INVALID_TLLI;
+  INIT_STATE ( MM, GMM_MM_DEREG);
+  gmm_data->gu                  = GU3_ROAMING_NOT_ALLOWED;
+  gmm_data->acc_contr_class     = 0;
+  gmm_data->kern.gprs_indicator  = GMM_GPRS_SUPP_NO;
+#ifdef GMM_TCS4
+  gmm_data->sync.sig_cell_info.rt = RT_GSM; /* TCS 4.0 */
+#endif
+ 
+  gmm_data->kern.attach_cap.attach_acc_after_po = FALSE;
+  TRACE_EVENT ("GRR is off");
+  gmm_data->kern.attach_cap.grr_state = GMM_GRR_STATE_OFF;
+  /* 
+   * set all kc values to 0xff
+   */
+  memset (gmm_data->kern.auth_cap.kc, 0x00, MAX_KC);
+
+  gmm_data->kern.auth_cap.ciphering_algorithm = LLGMM_CIPHER_NO_ALGORITHM;
+  /*
+   * multiple outstanding SIM_AUTHENTICATION_REQ messages reset the counter
+   */
+  gmm_data->kern.auth_cap.last_auth_req_id = NOT_PRESENT_8BIT;
+  gmm_data->config.cipher_on = 0x01;
+  gmm_data->cipher = FALSE;
+  gmm_data->config.preuse_off = FALSE;
+  
+  gmm_data->ptmsi.new_grr = GMMRR_TMSI_INVALID;
+  gmm_data->ptmsi.current  = GMMRR_TMSI_INVALID;
+  gmm_data->ptmsi.old  = GMMRR_TMSI_INVALID;
+  gmm_data->tmsi  = GMMRR_TMSI_INVALID;
+  gmm_data->config.nmo = 0xff;
+  /*
+   * set the dafault timer vlaues needed in service kern
+   */
+  gmm_data->kern.t3310_val      = T3310_VALUE;
+  gmm_data->kern.t3311_val      = T3311_VALUE;
+  gmm_data->kern.t3321_val      = T3321_VALUE;
+
+  /*
+   * T3302 is loaded with the same value which is used to load T3212.
+   */ 
+  gmm_data->kern.t3302_val      = T3302_VALUE;
+
+  gmm_data->kern.timeout_t3312  = FALSE;
+
+  vsi_t_stop  ( GMM_handle, kern_T3310);
+  vsi_t_stop  ( GMM_handle, kern_T3311);
+  vsi_t_stop  ( GMM_handle, kern_T3321);
+  vsi_t_stop  ( GMM_handle, kern_TPOWER_OFF);
+  vsi_t_stop  ( GMM_handle, kern_TLOCAL_DETACH);
+
+  /*
+   * which kind of attach will be used is unknown this time
+   * nobody requested an attach 
+   */
+  
+  gmm_data->kern.attach_cap.mobile_class    = GMMREG_CLASS_BG;
+  gmm_data->kern.attach_cap.mobile_class_changed = FALSE;
+  gmm_data->kern.attach_cap.attach_type     = GMMREG_AT_NOT_KNOWN;
+  gmm_data->kern.attach_cap.service_mode    = SERVICE_MODE_LIMITED;
+  gmm_data->kern.attach_cap.gmmreg          = FALSE;
+#ifndef GMM_TCS4
+  gmm_data->kern.attach_cap.gmmsm           = FALSE;
+#endif 
+  gmm_data->kern.detach_cap.network         = FALSE;
+  gmm_data->kern.detach_cap.gmmreg          = FALSE;        
+  gmm_data->kern.detach_cap.local_detach_open_proc=GMM_LOCAL_DETACH_PROC_NOTHING;
+  gmm_data->kern.detach_cap.error_cause     = GMMCS_INT_NOT_PRESENT; /* TCS 2.1 */
+  gmm_data->kern.suspension_type            = GMM_SUSP_NONE;
+  /*
+   * the DRX parameter are hardware dependend 
+   * TI is not supporting DRX
+   * <R.GMM.AGINIT.M.006>
+   */
+
+#ifdef _SIMULATION_
+  gmm_data->drx_parameter.split_pg_cycle_code = 92 /* 95 DRX_NOT_USED */;
+#ifdef TDSGEN
+  gmm_data->drx_parameter.split_pg_cycle_code = 16;
+#endif
+
+#else  /* #ifdef _SIMULATION_ */
+  gmm_data->drx_parameter.split_pg_cycle_code = 16 /* 95 DRX_NOT_USED */;
+#endif /* #ifdef _SIMULATION_ */
+
+  gmm_data->drx_parameter.split_on_ccch       = SPLIT_NO;
+  gmm_data->drx_parameter.non_drx_timer       = DRX_2_SEC;
+
+
+  /*
+   * resets the attach and rau attempt counter
+   */
+  gmm_data->kern.aac = 0;
+  gmm_data->kern.attach_cap.rau_initiated = GMM_NO_RAU;
+  gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau=FALSE;
+
+  gmm_data->kern.sig_cell_info.env.rai.rac = GMMREG_RA_INVALID;
+  gmm_data->kern.sig_cell_info.env.rai.lac = GMMRR_LA_INVALID;
+  gmm_data->kern.sig_cell_info.gmm_status = GMMRR_SERVICE_UNKNOWN ; /* Initalize gmm status value */
+  
+#ifdef _SIMULATION_
+  gmm_data->kern.mm_cell_env.rai.rac = GMMREG_RA_INVALID;
+  gmm_data->kern.mm_cell_env.rai.lac = GMMRR_LA_INVALID;
+  gmm_data->kern.detach_cap.detach_type = VAL_DETACH_TYPE___DEF;
+#endif
+
+  /*
+   * Cel ID
+   */
+  gmm_data->kern.cell_id.lac  = (USHORT)GMMREG_LA_INVALID;
+  gmm_data->kern.cell_id.rac  = (UBYTE)GMMREG_RA_INVALID;
+
+
+  INIT_STATE (CU,CU_CELL_RES_SENT);
+  gmm_data->kern.attach_cap.llc_state=GMM_LLC_STATE_UNASSIGNED;
+  gmm_data->kern.gmmrr_resume_sent = FALSE;
+  gmm_data->kern.attach_cap.grr_via_llc_suspended=FALSE;
+  gmm_data->kern.attach_cap.mm_lau_attempted=FALSE;
+  
+  for(i=0; i<MAX_LIST_OF_FORBIDDEN_PLMNS_FOR_GPRS_SERVICE; i++)
+  {
+    memset(gmm_data->kern.attach_cap.list_of_forbidden_plmns_for_gprs_service[i].mcc, 0xFF, SIZE_MCC);
+    memset(gmm_data->kern.attach_cap.list_of_forbidden_plmns_for_gprs_service[i].mnc, 0xFF, SIZE_MNC);
+  }
+  kern_read_pcm();
+
+#ifdef REL99
+  /* Used to indicate to LLC if it should use NULL frame for
+   * performing cell updates. Cell notification is disabled by
+   * default. This field is changed only if the SGSN indicates
+   * that it supports cell notification
+   */
+   gmm_data->cell_notification = NO_CELL_NOTIFY; /* TCS 4.0 */
+  /* Initialise all the pdp context status to invalid untill GMM gets a valid status from SM */
+  gmm_data->kern.attach_cap.pdp_context_status = INVALID_PDP_CONTEXT_STATUS; /* TCS 4.0 */
+#endif
+
+  return;
+} /* kern_init() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_attach_reset
++------------------------------------------------------------------------------
+| Description : This procedure is called in cell updatingn procedure, if RA 
+|               was changed an the ATTACH procedurehas to re-initialized. 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_attach_reset ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_attach_reset" );
+  
+  /*
+   * resets the counter for TIMER t3310
+   */
+  gmm_data->kern.ct3310 = 0;
+
+  /* 
+   * I reuse timer T3310 also for T3330
+   */
+  vsi_t_stop  ( GMM_handle, kern_T3310);
+  vsi_t_stop  ( GMM_handle, kern_T3311);
+
+
+  gmm_data->kern.aac = 0;
+  gmm_data->kern.detach_cap.network = FALSE;
+  GMM_RETURN; 
+} /* kern_attach_reset() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_detach_started
++------------------------------------------------------------------------------
+| Description : The function kern_mm_detach_started indicates MM that the 
+|                GSM detach procedure is started by GMM. MM has to enter state
+|               MM-IMSI-DETACH-PENDING.
+|       
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_detach_started ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_mm_detach_started" );
+
+  switch( gmm_data->kern.detach_cap.detach_type)
+  {
+    case GMMREG_DT_SIM_REMOVED :
+      if (GMM_MM_DEREG == GET_STATE(MM))
+      {
+        break;
+      }
+      /* NO break;*/
+    case GMMREG_DT_IMSI:
+    case GMMREG_DT_COMB:
+      if (GMMRR_NET_MODE_I==gmm_data->kern.sig_cell_info.net_mode)
+      {
+        PALLOC ( mmgmm_detach_started_req, MMGMM_DETACH_STARTED_REQ);
+        PSEND ( hCommMM, mmgmm_detach_started_req ); 
+      }
+      break;
+    default:
+      break;
+  }
+  GMM_RETURN;
+} /* kern_detach_started() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_imsi_detach_ind
++------------------------------------------------------------------------------
+| Description : The function kern_mm_imsi_detach()handles the IMSI detach. 
+|      
+| Parameters  : detach_done -  indicates whether GMM has already done the IMSI
+|                detach or not.
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_imsi_detach_ind ( USHORT error_cause, BOOL detach_done, UBYTE detach_type )
+{ 
+  GMM_TRACE_FUNCTION( "kern_mm_imsi_detach_ind" );
+ 
+  {
+    PALLOC ( mmgmm_nreg_req, MMGMM_NREG_REQ); /* T_MMGMM_NREG_REQ */
+      mmgmm_nreg_req->cause = error_cause; /* TCS 2.1 */
+      mmgmm_nreg_req->detach_done = detach_done;
+      SET_STATE ( MM, GMM_MM_DEREG );
+
+      TRACE_1_OUT_PARA("detach_done %d",detach_done);
+      
+      switch ( detach_type )
+      {
+        case GMMREG_DT_SIM_REMOVED:
+          mmgmm_nreg_req->detach_cause = CS_SIM_REM; /* TCS 2.1 */
+          break;
+        case GMMREG_DT_POWER_OFF:
+          mmgmm_nreg_req->detach_cause = CS_POW_OFF; /* TCS 2.1 */
+          break;
+        case GMMREG_DT_SOFT_OFF:
+          mmgmm_nreg_req->detach_cause = CS_SOFT_OFF; /* TCS 2.1 */
+          break;
+        default:
+          mmgmm_nreg_req->detach_cause = CS_DISABLE; /* TCS 2.1 */
+          break;
+      }
+      gmm_data->kern.suspension_type &= ~GMM_SUSP_IMSI_DETACH;
+    PSEND ( hCommMM, mmgmm_nreg_req );   
+  }
+  GMM_RETURN;                  
+} /* kern_imsi_detach_ind () */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_imsi_detach
++------------------------------------------------------------------------------
+| Description : The function kern_mm_imsi_detach()handles the IMSI detach. 
+|      
+| Parameters  : detach_done -  indicates whether GMM has already done the IMSI
+|                detach or not.
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_imsi_detach ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_mm_imsi_detach" );
+  kern_mm_imsi_detach_ind (GMMCS_INT_NOT_PRESENT, MMGMM_PERFORM_DETACH,
+                           gmm_data->kern.detach_cap.detach_type); /* TCS 2.1 */
+  GMM_RETURN;
+} /* kern_imsi_detach() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_mm_lau
++------------------------------------------------------------------------------
+| Description : This procedure start the LAU procedure in entity MM
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_mm_lau ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_mm_lau" );
+
+  gmm_data->kern.attach_cap.mm_lau_attempted=TRUE;
+  gmm_data->kern.suspension_type &= ~GMM_SUSP_LAU;
+
+  if (gmm_data->kern.attach_cap.network_selection_mode EQ MODE_AUTO)
+  {
+    kern_mm_reg_req (REG_REMOTE_CONTROLLED, NORMAL_REG);
+  }
+  else
+  {
+    PALLOC ( mmgmm_plmn_res, MMGMM_PLMN_RES ); /* T_MMGMM_PLMN_RES */
+      mmgmm_plmn_res->plmn         = gmm_data->kern.attach_cap.plmn_requested;
+      mmgmm_plmn_res->reg_type = REG_REMOTE_CONTROLLED;
+      mmgmm_plmn_res->mobile_class = gmm_data->kern.attach_cap.mobile_class;
+    PSEND ( hCommMM, mmgmm_plmn_res );
+  }
+
+  GMM_RETURN;
+} /* kern_mm_lau() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_gmmrr_assign
++------------------------------------------------------------------------------
+| Description : The function kern_gmmrr_assign() 
+|               
+|               This procedure assigned the current TLLI parameter to GRR
+|               entities 
+|
+| Parameters  : void
+|              
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_gmmrr_assign ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_gmmrr_assign" );
+  
+  {
+    PALLOC ( gmmrr_assign_req, GMMRR_ASSIGN_REQ );
+      gmmrr_assign_req->new_tlli  = gmm_get_tlli ( CURRENT_TLLI );
+      gmmrr_assign_req->old_tlli  = gmm_get_tlli ( OLD_TLLI );      
+      
+      if (GMMRR_TLLI_INVALID==gmmrr_assign_req->new_tlli)
+      {
+        gmmrr_assign_req->old_ptmsi = GMMRR_TMSI_INVALID;
+        gmmrr_assign_req->new_ptmsi = GMMRR_TMSI_INVALID;
+      }
+      else
+      {
+        gmmrr_assign_req->old_ptmsi = gmm_data->ptmsi.old;
+        gmmrr_assign_req->new_ptmsi = gmm_data->ptmsi.new_grr;
+
+      }
+    gmmrr_assign_req->imsi  = gmm_data->imsi;
+    gmmrr_assign_req->rai.plmn.v_plmn=TRUE;
+    memcpy (gmmrr_assign_req->rai.plmn.mcc, gmm_data->kern.attach_cap.rai_accepted.mcc, SIZE_MCC);
+    memcpy (gmmrr_assign_req->rai.plmn.mnc, gmm_data->kern.attach_cap.rai_accepted.mnc, SIZE_MNC);
+    gmmrr_assign_req->rai.lac = gmm_data->kern.attach_cap.rai_accepted.lac;
+    gmmrr_assign_req->rai.rac = gmm_data->kern.attach_cap.rai_accepted.rac;
+
+    TRACE_3_OUT_PARA("PTMSI old: 0x%X new: 0x%X,curent:0x%X ",gmmrr_assign_req->old_ptmsi, 
+    gmmrr_assign_req->new_ptmsi, gmm_data->ptmsi.current);
+    PSEND ( hCommGRR, gmmrr_assign_req );
+  }
+  GMM_RETURN;
+} /* kern_gmmrr_assign() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_local_atach
++------------------------------------------------------------------------------
+| Description : The function kern_local_attach() 
+|               
+|               This procedure assigned the given TLLI parameter to the other
+|               entities 
+|
+| Parameters  : new_tlli_type - type of new TLLI (random, local ,..)
+|               old_tlli_type - type of old TLLI
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_local_attach ( T_TLLI_TYPE new_tlli_type, T_TLLI_TYPE old_tlli_type )
+{ 
+  GMM_TRACE_FUNCTION( "kern_local_attach" );
+  
+  kern_llgmm_assign_tlli ( new_tlli_type, old_tlli_type );
+  kern_gmmrr_assign();
+  GMM_RETURN;
+} /* kern_local_attach() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_ptmsi_negotiated
++------------------------------------------------------------------------------
+| Description : This procedure is called if an AIR message is received which 
+|               contains an optional PTMSI IE. i.e. in the ATTACH_ACCEPT or 
+|               RAU_ACCEPT message. It stores the P-TMSI and the
+|               P-TMSI Signature, if available into the SIM and changes the
+|               update state to GU1 UPDATED and triggers the cell update
+|               procedure by calling LLGMM_TRIGGER_REQ, if needed. Otherwise,
+|               if P-TMSI was negotiated CU is triggered outside of this
+|               procedure by transmitting CONFIRM message. At the end of this
+|               procedure the new genereted TLLI is passed to the other layers
+|
+| Parameters  : v_mobile_identity  - flag from AIR  if ptmsi is available
+|               mobile_identity    - ptmsi from AIR
+|               v_ptmsi_signature  - flag from AIR if psignature is available
+|               ptmsi_signature   - ptmsi signature from AIR
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_tmsi_negotiated ( BOOL v_tmsi, 
+                                   T_mobile_identity *tmsi,
+                                   BOOL v_ptmsi, 
+                                   T_gmobile_identity *ptmsi,
+                                   BOOL v_ptmsi_signature,
+                                   T_p_tmsi_signature *p_tmsi_signature
+                                 ) 
+{
+  GMM_TRACE_FUNCTION ("kern_tmsi_negotiated()");
+
+  /*
+   * save the available flags
+   */
+  gmm_data->ptmsi_signature.available = v_ptmsi_signature;
+  if ( v_ptmsi )
+  {
+    if ( !ptmsi->v_tmsi )
+    {
+      TRACE_ERROR ( "PTMSI IE received from air without ptmsi value, perhaps IMSI reseived" );
+      sig_kern_rx_gmm_status(ERRCS_IE_INVALID);
+    }
+    else
+    {
+      /*
+       * store the given PTMSI
+       */
+      gmm_data->ptmsi.old     = gmm_data->ptmsi.current,
+  
+      gmm_data->ptmsi.new_grr 
+       = gmm_data->ptmsi.current = kern_get_tmsi ((T_mobile_identity *)ptmsi );
+
+    }
+  }
+  if ( v_tmsi )
+  {
+    if ( !tmsi->v_tmsi )
+    {
+      TRACE_EVENT ( "TMSI IE received from air without ptmsi value, perhaps IMSI reseived" );
+      /* 
+       * <R.GMM.ACSUBOTH.M.011>
+       * If the message contains an IMSI (i.e. the MS is not allocated any TMSI)
+       * than the MS shall delete any TMSI.
+       */
+      gmm_data->tmsi =MMGMM_TMSI_INVALID;
+
+    }
+    else
+    {
+    /*
+     * store the given TMSI
+     */
+      gmm_data->tmsi = kern_get_tmsi ((T_mobile_identity *)tmsi );
+    }
+  }
+  /*
+   * After the rocedure the local TLLI have to be used
+   *
+   * set all TLLIs and saves the current TLLI as old TLLI
+   */
+  gmm_set_current_tlli ( LOCAL_TLLI ) ;
+
+
+  if ( v_ptmsi_signature ) 
+  {
+    /*
+     * <R.GMM.AGACCEPT.M.020>, <R.GMM.AGACCEPT.M.021>,
+     * <R.GMM.AGACCEPT.M.022>, <R.GMM.RNACCEPT.M.014>
+     */
+    gmm_data->ptmsi_signature.value 
+                           = p_tmsi_signature->p_tmsi_signature_value;
+  }
+  /*
+   * <R.GMM.AGACCEPT.M017>, <R.GMM.AGACCEPT.M019>, 
+   * <R.GMM.AGACCEPT.M022>,<R.GMM.AGACCEPT.M023>
+   */
+  gmm_data->gu                = GU1_UPDATED;
+
+  kern_sim_gmm_update();
+  vsi_o_ttrace(VSI_CALLER TC_EVENT,"Info: GU: %i", gmm_data->gu+1);
+
+  
+  if ( 
+     GMM_PERIODIC_RAU    != gmm_data->kern.attach_cap.rau_initiated
+   || ptmsi->v_tmsi
+   || tmsi->v_tmsi
+  )
+  {
+    /*
+     * in attach and RAU the TLLI as to change from foreign to local tlli
+     */
+    kern_local_attach ( CURRENT_TLLI, OLD_TLLI );
+  }
+  else
+  {
+    /* 
+     * AniteB2 44.2.3.1.5
+     * RR has to transmit the last assigned RAI with GPRS resumption
+     */
+    kern_gmmrr_assign();
+  }
+  GMM_RETURN;
+
+} /* kern_ptmsi_negotiated */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_sim_del_locigprs
++------------------------------------------------------------------------------
+| Description : This procedure resets all location infos on sim
+|               
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_sim_del_locigprs ( void ) 
+{
+  GMM_TRACE_FUNCTION ("kern_sim_del_locigprs()");
+
+  gmm_data->ptmsi.current           = GMMRR_TMSI_INVALID;
+  gmm_data->ptmsi.new_grr           = GMMRR_TMSI_INVALID;
+  gmm_data->ptmsi.old               = GMMRR_TMSI_INVALID;
+  gmm_data->ptmsi_signature.available = FALSE;
+  gmm_data->ptmsi_signature.value      = INVALID_PTMSI_SIGNATURE; 
+
+  gmm_data->kern.attach_cap.rai_accepted.lac = 0xfffe;           /* INVALID */
+  gmm_data->kern.attach_cap.rai_accepted.rac = 0xff;           /* INVALID */
+  memset (gmm_data->kern.auth_cap.kc, 0xFF, MAX_KC);
+  gmm_data->kern.auth_cap.cksn       = NO_KEY;
+  GMM_RETURN;
+} /* kern_sim_del_locigprs */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_sim_gmm_update
++------------------------------------------------------------------------------
+| Description : This procedure sends the primitive SIM_GU_UPDATE_REQ to SIM.
+|               The primitive is allocated within this function and the
+|               parameters of the primitive are filled in with the actually
+|               set global variables of GMM.
+|               
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_sim_gmm_update () 
+{
+  GMM_TRACE_FUNCTION ("kern_sim_gmm_update()");
+  {
+    PALLOC ( sim_gmm_update_req, SIM_GMM_UPDATE_REQ );
+      kern_set_loc_info   (sim_gmm_update_req);
+      kern_set_kc_cksn    (sim_gmm_update_req);
+      sim_gmm_update_req->att_status 
+        = gmm_data->kern.attach_cap.attach_acc_after_po;    
+    PSEND ( hCommSIM, sim_gmm_update_req );
+  }
+  GMM_RETURN;
+} /* kern_sim_gmm_update */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_read_imsi
++------------------------------------------------------------------------------
+| Description : This procedure reads the imsi from primitive 
+|               sim_gmm_insert_ind
+|               
+|               copied from mm_regF.c in MM
+|               
+| Parameters  : sim_gmm_insert_ind - primitiv pointer
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_read_imsi (T_SIM_GMM_INSERT_IND *sim_gmm_insert_ind)
+{
+  USHORT i;
+  UBYTE  digit;
+  UBYTE  length;
+  ULONG  init_value=25;
+#ifdef NEW_FRAME
+  T_TIME  time_val;
+#else /* NEW_FRAME */
+  T_VSI_TVALUE  time_val;
+#endif /* NEW_FRAME */
+
+  GMM_TRACE_FUNCTION ("kern_read_imsi ()");
+
+  
+  gmm_data->imsi.v_mid    = TRUE;
+  gmm_data->imsi.id_type  = TYPE_IMSI;
+  gmm_data->imsi.tmsi_dig = 0;
+
+
+  length = (sim_gmm_insert_ind->imsi_field.c_field-1)*2;
+  if (sim_gmm_insert_ind->imsi_field.field[0] & 0x08)
+  {
+    length++;
+  }
+
+  for (i = 0; i < length; i++)
+  {
+    digit = (i & 1) ?
+        sim_gmm_insert_ind->imsi_field.field[(i + 1) / 2] & 0x0f :
+       (sim_gmm_insert_ind->imsi_field.field[(i + 1) / 2] & 0xf0) >> 4;
+    gmm_data->imsi.id[i] = digit;
+    init_value += digit*digit; 
+  }
+  gmm_data->imsi.id[i] = 0xff;
+
+  vsi_t_time (VSI_CALLER &time_val); 
+  srand ((USHORT)(init_value*time_val));
+  GMM_RETURN;
+} /*kern_read_imsi*/ 
+/*
++------------------------------------------------------------------------------
+| Function    : kern_get_tmsi
++------------------------------------------------------------------------------
+| Description : This procedure translate the timer value given by ACI to
+|               an air message struct  
+|               
+|               
+| Parameters  : mobile_identity - PTMSI received from AIR
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL ULONG kern_get_tmsi (T_mobile_identity * mobile_identity )
+{ 
+  ULONG ptmsi;
+  GMM_TRACE_FUNCTION( "kern_get_tmsi" );
+  
+  ptmsi = (mobile_identity->tmsi.b_tmsi[0] << 24)+
+                    (mobile_identity->tmsi.b_tmsi[1] << 16)+
+                    (mobile_identity->tmsi.b_tmsi[2] << 8)+
+                     mobile_identity->tmsi.b_tmsi[3];
+  GMM_RETURN_ (ptmsi);
+
+} /* kern_get_tmsi */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_get_mobile_identity
++------------------------------------------------------------------------------
+| Description : Derives the mobile identiti for the AIR
+|
+| COPIED FROM : MM    mm_mmf.c : mm_fill_identity
+|               
+| Parameters  : type_of_identity  - tpe of identity
+|                gmobile_identity   - used in the AIR message
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL void kern_get_mobile_identity ( 
+  UBYTE type_of_identity,
+  T_gmobile_identity* gmobile_identity )
+{
+  GMM_TRACE_FUNCTION ("kern_get_mobile_identity()");
+ 
+  memset (gmobile_identity, 0, sizeof (T_mobile_identity));
+
+  switch (type_of_identity)
+  {
+    case ID_TYPE_IMEISV:
+      kern_get_imeisv ( gmobile_identity);
+      break;
+    case ID_TYPE_IMEI:
+      kern_get_imei ( gmobile_identity);
+      break;
+    case ID_TYPE_TMSI:
+      kern_ulong2mobile_identity (gmm_data->ptmsi.current, gmobile_identity);
+      break;
+    default:
+      TRACE_ERROR ("undefined type of Identity");
+      /*
+       * NO break;
+       */
+    case ID_TYPE_IMSI:
+      gmobile_identity->v_tmsi = FALSE;
+      gmobile_identity->type_of_identity  = ID_TYPE_IMSI;
+      gmobile_identity->v_identity_digit = TRUE;
+      gmobile_identity->c_identity_digit 
+        = kern_calculate_digits (gmm_data->imsi.id);
+      gmobile_identity->odd_even    = gmobile_identity->c_identity_digit & 1;
+      memcpy (gmobile_identity->identity_digit, gmm_data->imsi.id, 16);
+      break;
+  }
+  GMM_RETURN;
+} /* kern_get_mobile_identity() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_read_kc_cksn
++------------------------------------------------------------------------------
+| Description : Reads the location information delivered by the SIM card
+|               into the registration memory structures.
+|
+| COPIED FROM : MM    mm_regf.c : reg_read_kc_cksn
+|               
+| Parameters  : T_loc_info - the the loc_inf field from sim_gmm_inserted_ind
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_read_kc_cksn (T_SIM_GMM_INSERT_IND *sim_gmm_insert_ind)
+{
+  GMM_TRACE_FUNCTION ("kern_read_kc_cksn ()");
+  
+  switch (gmm_data->gu)
+  {
+    case GU2_NOT_UPDATED:
+      /*
+       * GSM: 04.08, Ch.4.1.3.2 GPRS update status
+       * 
+       *   GU2: NOT UPDATED
+       *     The last GPRS attach or routing area updating attempt failed procedurally,
+       *     i.e. no response was received from the network. This includes the cases of
+       *     failures or congestion inside the network.
+       *     In this case, the SIM may contain the RAI of the routing area (RA) to which
+       *     the subscriber was attached, and possibly also a valid P-TMSI,
+       *     GPRS GSM ciphering key, GPRS UMTS ciphering key, GPRS UMTS integrity key
+       *     and GPRS ciphering key sequence number. For compatibility reasons, all these
+       *     fields shall be set to the "deleted" value if the RAI is deleted. However, the
+       *     presence of other values shall not be considered an error by the MS. 
+       */
+      if ( GMMRR_LA_INVALID != gmm_data->kern.attach_cap.rai_accepted.lac) 
+      {
+        break;
+      }
+      /* NO break */
+    case GU3_ROAMING_NOT_ALLOWED:
+    case GU3_PLMN_NOT_ALLOWED:
+      /*
+       * GSM: 04.08, Ch.4.3.2.4:
+       * "When the deletion of the sequence number is described this also means
+       * that the associated key shall be considered as invalid."
+       * GSM: 04.08, Ch.4.7.7.4:
+       * "If the sequence number is deleted,
+       *  the associated key shall be considered as invalid."
+       */
+
+      gmm_data->kern.auth_cap.cksn = NO_KEY;
+      memset (gmm_data->kern.auth_cap.kc, 0xFF, MAX_KC);
+      break;
+    default:
+       gmm_data->kern.auth_cap.cksn = sim_gmm_insert_ind->kc_n.kc[MAX_KC];
+      if (NO_KEY == gmm_data->kern.auth_cap.cksn)
+      {
+        memset (gmm_data->kern.auth_cap.kc, 0xFF, MAX_KC);
+      }
+      else
+      {  
+        /*
+         * copy parameter from SIM card
+         */
+        memcpy (gmm_data->kern.auth_cap.kc, sim_gmm_insert_ind->kc_n.kc, MAX_KC);      
+      }
+      break;
+  }
+  GMM_RETURN;
+}
+/*
++------------------------------------------------------------------------------
+| Function    : kern_set_kc_cksn
++------------------------------------------------------------------------------
+| Description : sets the kc and cksn delivered by the SIM card
+|               into the registration memory structures.
+|
+| COPIED FROM : MM    mm_regf.c : reg_read_kc_cksn
+|               
+| Parameters  : T_loc_info - the the loc_inf field from sim_gmm_inserted_ind
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_set_kc_cksn (T_SIM_GMM_UPDATE_REQ *sim_gmm_update_req)
+{
+  GMM_TRACE_FUNCTION ("kern_set_kc_cksn ()");
+
+  sim_gmm_update_req->cksn = gmm_data->kern.auth_cap.cksn;
+  memcpy (sim_gmm_update_req->kc, gmm_data->kern.auth_cap.kc, MAX_KC);
+  GMM_RETURN;
+}
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_read_log_info
++------------------------------------------------------------------------------
+| Description : Reads the location information delivered by the SIM card
+|               into the registration memory structures.
+|
+| COPIED FROM : MM    mm_regf.c : reg_read_log_info
+|               
+| Parameters  : T_loc_info - the the loc_inf field from sim_gmm_inserted_ind
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_read_loc_info (T_SIM_GMM_INSERT_IND *sim_gmm_insert_ind)
+{
+  GMM_TRACE_FUNCTION ("kern_read_loc_info ()");
+  
+  gmm_data->tmsi =  (sim_gmm_insert_ind->loc_info.loc[0] << 24) +
+                    (sim_gmm_insert_ind->loc_info.loc[1] << 16) +
+                    (sim_gmm_insert_ind->loc_info.loc[2] <<  8) +
+                      sim_gmm_insert_ind->loc_info.loc[3];
+
+  gmm_data->ptmsi.new_grr =
+  gmm_data->ptmsi.current =     (sim_gmm_insert_ind->gprs_loc_info.loc[0] << 24) +
+                        (sim_gmm_insert_ind->gprs_loc_info.loc[1] << 16) +
+                        (sim_gmm_insert_ind->gprs_loc_info.loc[2] <<  8) +
+                         sim_gmm_insert_ind->gprs_loc_info.loc[3];
+
+
+  gmm_data->ptmsi_signature.value =  
+                        (sim_gmm_insert_ind->gprs_loc_info.loc[4] << 16) +
+                        (sim_gmm_insert_ind->gprs_loc_info.loc[5] <<  8) +
+                         sim_gmm_insert_ind->gprs_loc_info.loc[6];  
+  gmm_data->ptmsi_signature.available = TRUE;
+   
+  gmm_data->kern.attach_cap.rai_accepted.mcc[0] = sim_gmm_insert_ind->gprs_loc_info.loc[7] & 0x0f;
+  gmm_data->kern.attach_cap.rai_accepted.mcc[1] = sim_gmm_insert_ind->gprs_loc_info.loc[7] >> 4;
+  gmm_data->kern.attach_cap.rai_accepted.mcc[2] = sim_gmm_insert_ind->gprs_loc_info.loc[8] & 0x0f;
+  gmm_data->kern.attach_cap.rai_accepted.mnc[2] = sim_gmm_insert_ind->gprs_loc_info.loc[8] >> 4;
+  gmm_data->kern.attach_cap.rai_accepted.mnc[0] = sim_gmm_insert_ind->gprs_loc_info.loc[9] & 0x0f;
+  gmm_data->kern.attach_cap.rai_accepted.mnc[1] = sim_gmm_insert_ind->gprs_loc_info.loc[9] >> 4;
+  gmm_data->kern.attach_cap.rai_accepted.lac    = sim_gmm_insert_ind->gprs_loc_info.loc[10] * 256 +
+                         sim_gmm_insert_ind->gprs_loc_info.loc[11];
+  gmm_data->kern.attach_cap.rai_accepted.rac    = sim_gmm_insert_ind->gprs_loc_info.loc[12];
+
+  gmm_data->gu        = sim_gmm_insert_ind->gprs_loc_info.loc[13]; 
+
+  if ( GMMRR_LA_INVALID == gmm_data->kern.attach_cap.rai_accepted.lac)
+  {
+     kern_sim_del_locigprs ();
+  } 
+  TRACE_9_PARA("TMSI %x, PTMSI %x, lac %x, rac %x, MCC: %x%x%x, MNC: %x%x", 
+    gmm_data->tmsi,
+    gmm_data->ptmsi.current,          
+    gmm_data->kern.attach_cap.rai_accepted.lac,
+    gmm_data->kern.attach_cap.rai_accepted.rac,
+    gmm_data->kern.attach_cap.rai_accepted.mcc[0],
+    gmm_data->kern.attach_cap.rai_accepted.mcc[1],
+    gmm_data->kern.attach_cap.rai_accepted.mcc[2],
+    gmm_data->kern.attach_cap.rai_accepted.mnc[0],
+    gmm_data->kern.attach_cap.rai_accepted.mnc[1]
+  );
+ 
+  if (gmm_data->gu > GU3_ROAMING_NOT_ALLOWED)
+  {
+    gmm_data->gu = GU2_NOT_UPDATED;
+  }
+  GMM_RETURN;
+}
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_set_loc_info
++------------------------------------------------------------------------------
+| Description : derives the log_info field for for sim inserted
+|
+| COPIED FROM : MM    mm_regf.c : reg_set_log_info
+|               
+| Parameters  : sim_gmm_update_req - the primitive
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_set_loc_info (T_SIM_GMM_UPDATE_REQ *sim_gmm_update_req)
+{
+
+  GMM_TRACE_FUNCTION ("kern_set_loc_info ()");
+  sim_gmm_update_req->gprs_loc_info.c_loc = MAX_LOCIGPRS;
+
+  sim_gmm_update_req->gprs_loc_info.loc[0]  = (UBYTE)(gmm_data->ptmsi.current >> 24);
+  sim_gmm_update_req->gprs_loc_info.loc[1]  = (UBYTE)(gmm_data->ptmsi.current >> 16);
+  sim_gmm_update_req->gprs_loc_info.loc[2]  = (UBYTE)(gmm_data->ptmsi.current >> 8);
+  sim_gmm_update_req->gprs_loc_info.loc[3]  = (UBYTE)gmm_data->ptmsi.current;
+  
+  sim_gmm_update_req->gprs_loc_info.loc[4]  = (UBYTE)(gmm_data->ptmsi_signature.value >> 16);
+  sim_gmm_update_req->gprs_loc_info.loc[5]  = (UBYTE)(gmm_data->ptmsi_signature.value >> 8);
+  sim_gmm_update_req->gprs_loc_info.loc[6]  = (UBYTE)gmm_data->ptmsi_signature.value;
+  
+  sim_gmm_update_req->gprs_loc_info.loc[7]  = gmm_data->kern.attach_cap.rai_accepted.mcc[1] << 4;
+  sim_gmm_update_req->gprs_loc_info.loc[7] += gmm_data->kern.attach_cap.rai_accepted.mcc[0];
+
+  sim_gmm_update_req->gprs_loc_info.loc[8]  = gmm_data->kern.attach_cap.rai_accepted.mnc[2] << 4;
+  sim_gmm_update_req->gprs_loc_info.loc[8] += gmm_data->kern.attach_cap.rai_accepted.mcc[2];
+  
+  sim_gmm_update_req->gprs_loc_info.loc[9]  = gmm_data->kern.attach_cap.rai_accepted.mnc[1] << 4;
+  sim_gmm_update_req->gprs_loc_info.loc[9] += gmm_data->kern.attach_cap.rai_accepted.mnc[0];
+  sim_gmm_update_req->gprs_loc_info.loc[10]  = gmm_data->kern.attach_cap.rai_accepted.lac >> 8;
+  sim_gmm_update_req->gprs_loc_info.loc[11]  = gmm_data->kern.attach_cap.rai_accepted.lac & 0xff;
+  sim_gmm_update_req->gprs_loc_info.loc[12]  = gmm_data->kern.attach_cap.rai_accepted.rac;
+  
+  sim_gmm_update_req->gprs_loc_info.loc[13] = gmm_data->gu;
+  GMM_RETURN;
+}
+/*
++------------------------------------------------------------------------------
+| Function    : kern_ulong2mobile_identity
++------------------------------------------------------------------------------
+| Description : Derives tm mobile identiti for the AIR
+|
+| COPIED FROM : MM    mm_mmf.c : mm_fill_identity
+|               
+| Parameters  : mobile_identity   - used in the AIR message
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL void kern_ulong2mobile_identity ( ULONG ptmsi, T_gmobile_identity* gmobile_identity )
+{
+  GMM_TRACE_FUNCTION ("kern_ulong2mobile_identity()");
+ 
+  memset (gmobile_identity, 0, sizeof (T_mobile_identity));
+
+  
+  
+  if ( GMMRR_TMSI_INVALID == gmm_data->ptmsi.current )
+  {
+    /*
+     * IMSI
+     * <R.GMM.AGINIT.M.005>
+     */
+    gmobile_identity->v_tmsi      = FALSE;
+
+    kern_get_mobile_identity ( ID_TYPE_IMSI, gmobile_identity );
+  }  
+  else /* !ptmsi.available */
+  { 
+    /* 
+     * PTMSI
+     * <R.GMM.AGINIT.M.002>
+     */
+    gmobile_identity->odd_even    = EVEN;
+    gmobile_identity->v_tmsi      = TRUE;
+    gmobile_identity->type_of_identity = ID_TYPE_TMSI;
+    gmobile_identity->v_identity_digit = FALSE;
+    gmobile_identity->tmsi.l_tmsi = 32;
+  
+  
+    ccd_codeByte (gmobile_identity->tmsi.b_tmsi,  0, 8, (UBYTE)(ptmsi >> 24));
+    ccd_codeByte (gmobile_identity->tmsi.b_tmsi,  8, 8, (UBYTE)(ptmsi >> 16));
+    ccd_codeByte (gmobile_identity->tmsi.b_tmsi, 16, 8, (UBYTE)(ptmsi >> 8));
+    ccd_codeByte (gmobile_identity->tmsi.b_tmsi, 24, 8, (UBYTE) ptmsi);
+  }
+  GMM_RETURN; 
+  
+} /* kern_ulong2mobile_identity() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_kern_cell_changed
++------------------------------------------------------------------------------
+| Description : Returns TRUE if cell was changed.
+|               
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL BOOL kern_cell_changed ( void )
+{
+  GMM_TRACE_FUNCTION ("kern_cell_changed()");
+
+  if ( gmm_data->kern.sig_cell_info.env.cid != gmm_data->kern.old_sig_cell_info.env.cid)
+  {
+    TRACE_EVENT("Info: cid changed");
+    GMM_RETURN_ (TRUE);
+  }
+  else 
+  {
+    GMM_RETURN_ (kern_ra_crossed());
+  }
+} /* kern_lai_changed() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_kern_lai_changed
++------------------------------------------------------------------------------
+| Description : Returns TRUE if LA was changed.
+|               
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL BOOL kern_lai_changed ( void )
+{
+  GMM_TRACE_FUNCTION ("kern_lai_changed()");
+
+  if ( gmm_data->kern.attach_cap.rai_accepted.lac != gmm_data->kern.sig_cell_info.env.rai.lac)
+  {
+    TRACE_3_INFO ("Info: LAI changed: changed lac: %x (%x) -> %x",            
+    gmm_data->kern.attach_cap.rai_accepted.lac,
+    gmm_data->kern.old_sig_cell_info.env.rai.lac,
+    gmm_data->kern.sig_cell_info.env.rai.lac);
+    GMM_RETURN_ (TRUE);
+  }
+  else 
+  {
+    if (kern_plmn_changed()) 
+    {
+      GMM_RETURN_ (TRUE);
+    }
+  }
+
+  GMM_RETURN_ (FALSE);
+} /* kern_lai_changed() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_kern_lau_needed
++------------------------------------------------------------------------------
+| Description : Returns TRUE if LAU is needed
+|               
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL BOOL kern_lau_needed ( void )
+{
+  UBYTE mm_state;
+
+  GMM_TRACE_FUNCTION ("kern_lau_needed()");
+
+  mm_state = GET_STATE(MM);
+
+  TRACE_1_PARA ("sig_cell_info.mm_status %d", gmm_data->kern.sig_cell_info.mm_status);
+
+  switch (gmm_data->kern.attach_cap.attach_type)
+  {
+    case GMMREG_AT_IMSI:
+    case GMMREG_AT_COMB:                    
+      GMM_RETURN_ (
+        (   GMM_MM_DEREG              == mm_state
+          || GMM_MM_REG_UPDATE_NEEDED == mm_state
+          || MMGMM_WAIT_FOR_UPDATE    == gmm_data->kern.sig_cell_info.mm_status
+             
+          ||  gmm_data->kern.sig_cell_info.env.rai.lac != gmm_data->kern.mm_cell_env.rai.lac
+          || (memcmp (gmm_data->kern.sig_cell_info.env.rai.plmn.mnc, 
+                      gmm_data->kern.mm_cell_env.rai.plmn.mnc, SIZE_MNC) != 0)
+          || (memcmp (gmm_data->kern.sig_cell_info.env.rai.plmn.mcc, 
+                      gmm_data->kern.mm_cell_env.rai.plmn.mcc, SIZE_MCC) != 0)
+        )
+        
+        &&  ( MMGMM_LIMITED_SERVICE != gmm_data->kern.sig_cell_info.mm_status)
+      );
+      /* break; */
+    default:
+      GMM_RETURN_ (FALSE);
+      /* break; */
+  }
+} /* kern_lau_needed() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_ra_crossed
++------------------------------------------------------------------------------
+| Description : Returns TRUE if RA was crossed.
+|               
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL BOOL kern_ra_crossed ( void )
+{
+  GMM_TRACE_FUNCTION ("kern_ra_crossed?");
+  
+  if (gmm_data->kern.sig_cell_info.env.rai.rac != gmm_data->kern.old_sig_cell_info.env.rai.rac
+    || gmm_data->kern.sig_cell_info.env.rai.lac != gmm_data->kern.old_sig_cell_info.env.rai.lac )
+  {
+    TRACE_EVENT("Info: RA crossed");
+    GMM_RETURN_ (TRUE);
+  }
+  GMM_RETURN_(FALSE);
+} /* kern_rai_changed() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_rai_changed
++------------------------------------------------------------------------------
+| Description : Returns TRUE if RA was changed.
+|               
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL BOOL kern_rai_changed ( void )
+{
+  GMM_TRACE_FUNCTION ("kern_rai_changed()");
+  
+  if ( gmm_data->kern.sig_cell_info.env.rai.rac != gmm_data->kern.attach_cap.rai_accepted.rac )
+  {
+    TRACE_0_INFO("RAI changed");
+    GMM_RETURN_ (TRUE);
+  }
+  GMM_RETURN_ (kern_lai_changed());
+} /* kern_rai_changed() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_plmn_changed
++------------------------------------------------------------------------------
+| Description : Returns TRUE if PLMN was changed.
+|               
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL BOOL kern_plmn_changed ( void )
+{
+  GMM_TRACE_FUNCTION ("kern_plmn_changed()");
+
+  if ( (memcmp (gmm_data->kern.sig_cell_info.env.rai.plmn.mnc, gmm_data->kern.attach_cap.rai_accepted.mnc, SIZE_MNC) != 0)
+    || (memcmp (gmm_data->kern.sig_cell_info.env.rai.plmn.mcc, gmm_data->kern.attach_cap.rai_accepted.mcc, SIZE_MCC) != 0)
+    )
+  {
+    TRACE_0_INFO ("PLMN changed");
+    GMM_RETURN_ (TRUE);
+  }
+  else
+  {
+    GMM_RETURN_ (FALSE);
+  } 
+} /* kern_plmn_changed() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_set_rai
++------------------------------------------------------------------------------
+| Description : This Procedure sets the old rai and the new rai.
+|               
+| Parameters  : rai 
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL void kern_set_rai ( T_routing_area_identification * rai)
+{
+  GMM_TRACE_FUNCTION ("kern_set_rai()");
+
+  /*
+   * gmm_data->kern.attach_cap.rai_accepted has to be always the last valid assigned RAI
+   * gmm_data->rai includes the last updated lac and or rac depending
+   * on the net mode and the oroiginator:
+   * net modeII: lac may only chaged by MM so that we know
+   * whether we have to update LA or not either upon cell_ind(lac) or
+   * activate_ind(lac) dependinig on what receives first. . 
+   * That means gmm_data->rai MUST NOT sent to the  network it
+   * can be wrong, i.e. new LAC but old RAC! Use always gmm_data->kern.attach_cap.rai_accepted
+   * for transmission o the AIR.
+   */
+  gmm_data->kern.attach_cap.rai_accepted = *rai;
+
+  if (GMMRR_NET_MODE_I==gmm_data->kern.sig_cell_info.net_mode)
+  {
+    memcpy (gmm_data->kern.mm_cell_env.rai.plmn.mcc, rai->mcc, SIZE_MCC);
+    memcpy (gmm_data->kern.mm_cell_env.rai.plmn.mnc, rai->mnc, SIZE_MNC);
+
+    gmm_data->kern.mm_cell_env.rai.lac     = rai->lac;
+    gmm_data->kern.mm_cell_env.rai.rac     = rai->rac;
+    gmm_data->kern.mm_cell_env.cid         = gmm_data->kern.sig_cell_info.env.cid;
+  }
+  GMM_RETURN;
+} /* kern_set_rai() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_gmmrr_suspend
++------------------------------------------------------------------------------
+| Description : The function kern_gmmrr_suspend()
+|       
+|               This procedure suspends GRR
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_gmmrr_suspend ( UBYTE susp_gprs, UBYTE gmmrr_susp_cause, UBYTE susp_type)
+{ 
+  GMM_TRACE_FUNCTION( "kern_gmmrr_suspend" );
+
+  gmm_data->kern.suspension_type            |= susp_type;
+  TRACE_1_OUT_PARA ("susp_type: %x", gmm_data->kern.suspension_type);
+
+  if (GMM_GRR_STATE_CR==gmm_data->kern.attach_cap.grr_state)
+  {
+    TRACE_0_INFO("suspension delayed untill cell_ind is received");
+  }
+  else
+  {
+    PALLOC ( gmmrr_suspend_req, GMMRR_SUSPEND_REQ);
+      gmmrr_suspend_req->susp_gprs = susp_gprs;
+      gmmrr_suspend_req->gmmrr_susp_cause= gmmrr_susp_cause;
+      /* START PATCH UBUOB ISSUE 8379 */
+      gmm_data->kern.gmmrr_resume_sent = FALSE;
+      gmm_data->kern.attach_cap.grr_state = GMM_GRR_STATE_SUSPENDING;
+      /* END PATCH UBUOB ISSUE 8379 */
+    PSEND ( hCommGRR, gmmrr_suspend_req );
+  }
+
+  GMM_RETURN;
+} /* kern_gmmrr_suspend() */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_gmmrr_stop_waiting_for_transmission
++------------------------------------------------------------------------------
+| Description : The function kern_gmmrr_stop_waiting_for_transmission()
+|       
+|            Is sent after gmmrr_cell_ind if no RAU is needed.
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_gmmrr_stop_waiting_for_transmission (void)
+{ 
+  GMM_TRACE_FUNCTION( "kern_gmmrr_stop_waiting_for_transmission" );
+  switch(GET_STATE(CU))
+  {
+    case CU_NOT_REQUESTED:
+      {
+        PALLOC (gmmrr_cell_res, GMMRR_CELL_RES);
+          gmmrr_cell_res->cu_cause=GMMRR_RA_DEFAULT;
+          SET_STATE (CU, CU_CELL_RES_SENT);
+        PSEND (hCommGRR, gmmrr_cell_res);
+      }
+      break;
+    case CU_REQUESTED:
+      {
+        PALLOC (gmmrr_cell_res, GMMRR_CELL_RES);
+          gmmrr_cell_res->cu_cause=GMMRR_RA_CU;
+        PSEND (hCommGRR, gmmrr_cell_res);
+      }
+      /* NO break; */
+    case CU_REQUESTED_CELL_RES_SENT:
+      SET_STATE (CU, CU_CELL_RES_SENT);
+      kern_send_llgmm_trigger_req();
+      break;
+    default:
+    case CU_CELL_RES_SENT:
+      break;
+  }
+  GMM_RETURN;
+} /* kern_gmmrr_suspend() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_gmmrr_attach_started
++------------------------------------------------------------------------------
+| Description : The function kern_attach_started()
+|       |
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+          /*
+           * GMMRR_ATTACH_STARTED_REQ is used to inform GRR that routing area upodate or 
+           * attach procedure is started. This time span is closed with 
+           * GMMRR_ATTACH_FINISHED_REQ
+           * GSM 04.60, ch. 5.5.1.5 Discontinuous reception (DRX):
+           * "When initiating the MM procedures for GPRS attach and routeing area update 
+           * defined in 3GPP TS 04.08, the mobile station shall enter the MM non- DRX mode 
+           * period. This period ends when either of  the messages GPRS ATTACH ACCEPT, 
+           * GPRS ATTACH REJECT, ROUTING AREA UPDATE ACCEPT or ROUTING AREA UPDATE REJECT 
+           * is received by the mobile station. This period also ends after timeout 
+           * waiting for any of these messages."
+           */
+
+GLOBAL void kern_gmmrr_attach_started (void)
+{ 
+  GMM_TRACE_FUNCTION( "kern_gmmrr_attach_started" );
+  {
+    PALLOC (gmmrr_attach_started_req, GMMRR_ATTACH_STARTED_REQ);
+    gmm_data->kern.attach_cap.gmmrr_attach_finished_sent=FALSE;
+    PSEND (hCommGRR, gmmrr_attach_started_req);
+  }
+  GMM_RETURN;
+} /* kern_gmmrr_attach_finished() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_gmmrr_attach_finished
++------------------------------------------------------------------------------
+| Description : The function kern_attach_finished()
+|       
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_gmmrr_attach_finished (void)
+{ 
+  GMM_TRACE_FUNCTION( "kern_gmmrr_attach_finished" );
+  if(!gmm_data->kern.attach_cap.gmmrr_attach_finished_sent )
+  {
+    PALLOC (gmmrr_attach_finished_req, GMMRR_ATTACH_FINISHED_REQ);
+    gmm_data->kern.attach_cap.gmmrr_attach_finished_sent=TRUE;
+    PSEND (hCommGRR, gmmrr_attach_finished_req);
+  }
+  GMM_RETURN;
+} /* kern_gmmrr_attach_finished() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_is_cell_forbidden
++------------------------------------------------------------------------------
+| Description : The function kern_is_cell_forbidden checks whether cell is 
+|            forbidden for GPRS or not
+|       
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL kern_is_cell_forbidden (void)
+{ 
+  BOOL forbidden = (GMMRR_SERVICE_LIMITED== gmm_data->kern.sig_cell_info.gmm_status);
+  
+  int i;
+  GMM_TRACE_FUNCTION( "kern_is_cell_forbidden" );
+
+  if (MMGMM_LIMITED_SERVICE == gmm_data->kern.sig_cell_info.mm_status)
+  {
+    TRACE_0_INFO ("mm is in limited");
+    GMM_RETURN_ (TRUE);
+  }
+
+
+
+  if(MODE_AUTO EQ gmm_data->kern.attach_cap.network_selection_mode
+    /* START PATCH UBUOB ISSUE 8781 */
+    || !gmm_data->kern.attach_cap.gmmreg)
+    /* END PATCH UBUOB ISSUE 8781 */
+  {
+    for(i=0;!forbidden && (i<MAX_LIST_OF_FORBIDDEN_PLMNS_FOR_GPRS_SERVICE); i++)
+    {
+      forbidden =
+       forbidden
+       ||
+       (
+             (memcmp 
+             (gmm_data->kern.attach_cap.list_of_forbidden_plmns_for_gprs_service[i].mcc,
+                        gmm_data->kern.sig_cell_info.env.rai.plmn.mcc, SIZE_MCC) 
+                        == 0
+               )
+             &&
+              (memcmp 
+              (gmm_data->kern.attach_cap.list_of_forbidden_plmns_for_gprs_service[i].mnc,
+                        gmm_data->kern.sig_cell_info.env.rai.plmn.mnc, SIZE_MNC) 
+                        == 0
+               )
+        );
+    }
+  }
+  TRACE_1_INFO ("cell %s",forbidden?"forbidden":"allowed");
+  
+  GMM_RETURN_(forbidden);         
+      
+
+} /* kern_gmmrr_attach_finished() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_remove_plmn_from_forbidden_list
++------------------------------------------------------------------------------
+| Description : The function kern_remove_plmn_from_forbidden_list
+|       
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_remove_plmn_from_forbidden_list (T_plmn plmn)
+{ 
+  int i;
+  GMM_TRACE_FUNCTION( "kern_remove_plmn_from_forbidden_list" );
+  
+  for(i=0; i<MAX_LIST_OF_FORBIDDEN_PLMNS_FOR_GPRS_SERVICE; i++)
+  {
+    BOOL forbidden =
+     ((memcmp 
+     (gmm_data->kern.attach_cap.list_of_forbidden_plmns_for_gprs_service[i].mcc,
+                plmn.mcc, SIZE_MCC) 
+                == 0
+       )
+     &&
+      (memcmp 
+      (gmm_data->kern.attach_cap.list_of_forbidden_plmns_for_gprs_service[i].mnc,
+                plmn.mnc, SIZE_MNC) 
+                == 0
+       )
+      );
+    if (forbidden)
+    {
+      memset(gmm_data->kern.attach_cap.list_of_forbidden_plmns_for_gprs_service[i].mcc, 0xFF, SIZE_MCC);
+      memset(gmm_data->kern.attach_cap.list_of_forbidden_plmns_for_gprs_service[i].mnc, 0xFF, SIZE_MNC);
+    }
+  }
+    
+  GMM_RETURN;         
+      
+
+} /* kern_gmmrr_attach_finished() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_send_gmmreg_cell_ind
++------------------------------------------------------------------------------
+| Description : The function kern_send_gmmreg_cell_ind informs MMI 
+|            that cell has changed or that we GSM is in full service again
+|       
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_send_gmmreg_cell_ind (void)
+{ 
+  BOOL attach_cnf_to_be_sent;
+  GMM_TRACE_FUNCTION( "kern_send_gmmreg_cell_ind" );
+
+  attach_cnf_to_be_sent = (MMGMM_FULL_SERVICE == gmm_data->kern.sig_cell_info.mm_status
+      && (
+          (
+            (
+              kern_cell_changed() 
+              || gmm_data->kern.attach_cap.gmmreg
+            )
+            && 
+            (
+              GMMRR_SERVICE_NONE != gmm_data->kern.sig_cell_info.gmm_status
+              || GMMRR_SERVICE_NONE == gmm_data->kern.old_sig_cell_info.gmm_status
+            )
+          )
+                                            /* OLD !!! */
+          || MMGMM_FULL_SERVICE != gmm_data->kern.old_sig_cell_info.mm_status
+        )
+      );
+  
+  switch( GET_STATE( KERN ) )
+  {
+    case KERN_GMM_NULL_NO_IMSI:
+    case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ:
+    case KERN_GMM_NULL_IMSI:
+    case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ:
+    case KERN_GMM_NULL_PLMN_SEARCH:
+
+    case KERN_GMM_DEREG_NO_IMSI:
+    case KERN_GMM_DEREG_PLMN_SEARCH:    
+    case KERN_GMM_DEREG_NO_CELL_AVAILABLE:
+    case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH:
+    case KERN_GMM_DEREG_LIMITED_SERVICE:
+    case KERN_GMM_DEREG_RESUMING:
+    case KERN_GMM_DEREG_SUSPENDING:
+    case KERN_GMM_DEREG_SUSPENDED:
+
+      if (attach_cnf_to_be_sent)
+      {
+        if ( GMMRR_NET_MODE_III==gmm_data->kern.sig_cell_info.net_mode
+        && GMMREG_CLASS_BC==  gmm_data->kern.attach_cap.mobile_class
+        && !kern_lau_needed())
+        {
+          kern_gmmreg_attach_cnf_sr(GMMREG_AT_IMSI, 
+                                SEARCH_NOT_RUNNING);
+        }
+        else
+        {          
+          switch (gmm_data->kern.sig_cell_info.gmm_status)
+          {
+            case GMMRR_SERVICE_LIMITED:
+            case GMMRR_SERVICE_NONE:
+              kern_gmmreg_attach_cnf_sr(GMMREG_AT_IMSI, 
+                    SEARCH_NOT_RUNNING);
+              break;
+            default:
+            case GMMRR_SERVICE_FULL:
+              kern_gmmreg_attach_cnf_sr(GMMREG_AT_IMSI, 
+                     (UBYTE)(gmm_data->sim_gprs_invalid?
+                    SEARCH_NOT_RUNNING:SEARCH_RUNNING));
+              break;
+          }
+        }
+      }
+      break;
+
+    case KERN_GMM_DEREG_INITIATED:
+      break;
+    case KERN_GMM_REG_INITIATED:
+      if (attach_cnf_to_be_sent)
+      {
+        kern_gmmreg_attach_cnf_sr(GMMREG_AT_IMSI,SEARCH_RUNNING);
+      }
+      break;
+    default:
+      TRACE_ERROR ("Unexpexcted state");
+      /* NO break */
+    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE:
+    case KERN_GMM_REG_NO_CELL_AVAILABLE:
+    case KERN_GMM_REG_LIMITED_SERVICE:
+    case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM:
+    case KERN_GMM_REG_RESUMING:
+    case KERN_GMM_REG_SUSPENDED:
+    case KERN_GMM_REG_SUSPENDING:
+    case KERN_GMM_REG_IMSI_DETACH_INITIATED:
+    
+    case KERN_GMM_REG_TEST_MODE_NO_IMSI:
+    case KERN_GMM_REG_TEST_MODE:
+    case KERN_GMM_RAU_INITIATED:
+    case KERN_GMM_RAU_WAIT_FOR_NPDU_LIST:
+
+      if (attach_cnf_to_be_sent)
+      {
+        kern_gmmreg_attach_cnf(GMMREG_AT_COMB);
+      }
+      break;
+    case KERN_GMM_REG_NORMAL_SERVICE:
+      if (attach_cnf_to_be_sent)
+      {
+        kern_gmmreg_attach_cnf(GMMREG_AT_COMB);
+
+#ifdef REL99
+        if (gmm_data->kern.sig_cell_info.sgsnr_flag!= gmm_data->kern.old_sig_cell_info.sgsnr_flag) 
+        {
+          PALLOC (mmpm_attach_ind, MMPM_ATTACH_IND);
+          PSEND ( hCommSM, mmpm_attach_ind );
+        }
+#endif  
+
+      break;
+      }
+  }
+  GMM_RETURN;
+} /* kern_gmmreg_cell_ind */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_send_llgmm_trigger_req
++------------------------------------------------------------------------------
+| Description : Sends trigger request with the correct cause value
+|
+| Parameters  : None
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_send_llgmm_trigger_req(void)
+{
+   
+  GMM_TRACE_FUNCTION ("kern_send_llgmm_trigger_req()");
+  {   
+    PALLOC (llgmm_trigger_req, LLGMM_TRIGGER_REQ);
+
+#ifdef REL99
+    /* 
+     * If SGSN supports cell notification indicate that LLC
+     * can use NULL frame for performing cell updates.
+     * The first cell notification shouldn't use LLC NULL 
+     * frame. The following logic takes care of it. 
+     */
+     switch (gmm_data->cell_notification) /* TCS 4.0 */
+      { /* TCS 4.0 */
+        case FIRST_CELL_NOTIFY: /* TCS 4.0 */
+          /*
+           * Next cell update can use LLC NULL frame
+           */
+          gmm_data->cell_notification = NOT_FIRST_CELL_NOTIFY; /* TCS 4.0 */
+           /*
+            * This cell update should not use LLC NULL frame
+            */
+           llgmm_trigger_req->trigger_cause = LLGMM_TRICS_CELL_UPDATE;
+          break; /* TCS 4.0 */
+        case NOT_FIRST_CELL_NOTIFY:  /* TCS 4.0 */
+          /* 
+           * Cell notification supported and this is not the first cell update.
+           * So LLC NULL frame can be used
+           */
+          llgmm_trigger_req->trigger_cause = LLGMM_TRICS_CELL_UPDATE_NULL_FRAME;      /* TCS 4.0 */
+          break; /* TCS 4.0 */
+        default: /* TCS 4.0 */
+          /*
+           * cell notification not supported by SGSN 
+           */
+         llgmm_trigger_req->trigger_cause = LLGMM_TRICS_CELL_UPDATE; /* TCS 4.0 */
+     } /* TCS 4.0 */
+#else
+         llgmm_trigger_req->trigger_cause = LLGMM_TRICS_CELL_UPDATE; /* TCS 4.0 */
+#endif
+
+     PSEND ( hCommLLC, llgmm_trigger_req );
+  }
+  GMM_RETURN;
+} /* kern_send_llgmm_trigger_req */
+/*
++------------------------------------------------------------------------------
+| Function    : kern_attach_rau_init
++------------------------------------------------------------------------------
+| Description : The function kern_attach_rau_init initilize RAU and attach procedure
+|       
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_attach_rau_init (void)
+{ 
+  GMM_TRACE_FUNCTION( "kern_attach_rau_init" );
+  /*
+   * PATCH UBUOB 22.7.07: multiple outstanding SIM_AUTHENTICATION_REQ messages
+   * for safety reset the counter whenever a new attachment is started
+   */
+
+  gmm_data->kern.auth_cap.last_auth_req_id = NOT_PRESENT_8BIT;
+
+
+  /* START PATCH UBUOB ISSUE 8284 */
+  gmm_data->kern.detach_cap.error_cause = GMMCS_INT_NOT_PRESENT; /* TCS 2.1 */
+  /* END PATCH UBUOB ISSUE 8284 */
+
+  gmm_data->kern.attach_cap.t3310_value=0;
+  vsi_t_stop ( GMM_handle , kern_T3310);
+
+  /* #5899 */
+  /*
+   * PATCH UBUOB 25.3.02: Stop timer T3302 when you are trying to ATTACH again
+   * otherwise it may timeout in the middle of the procedure. Also this ATTACH
+   * procedure may be successful and then T3302 also needs to be stopped.
+   */
+  vsi_t_stop ( GMM_handle , kern_T3302);
+  /* end patch */
+
+  /* 
+   * PATCH UBUOB 25.10.02: there are cases where T3311 also needs to be stopped:
+   * GMM receives CGRLC_STATUS_IND(access not allowed due to cell change), starts T3311 (TCS 2.1)
+   * GMMRR_CELL_IND(cell changed), RAU restarted, but forgot to stop T3311
+   * trace 25a_night_cell_change_no_patch
+   */
+  vsi_t_stop ( GMM_handle , kern_T3311);
+  /* end patch ubuob 25.10.02 */
+  sig_kern_rdy_stop_t3302_req();
+
+  /* 
+   * patch ubuob 23.10.02: flag needs to be cleared when initiating RAU or ATTACH
+   * and not at end
+   */
+  SET_STATE (GU,GU_UPDATE_NOT_NEEDED);
+  /* end patch ubuob */
+
+  GMM_RETURN;         
+      
+
+} /* kern_attach_rau_init */
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_make_cause
++------------------------------------------------------------------------------
+| Description : The function kern_make_cause()
+|       
+|            An internal 16 bit cause is generated from the cause received
+|            from the network. The reject causes indicating a retry in a new
+|            cell are translated to a single value. In case no cause was sent 
+|            by the network a special internal value is returned to handle this.
+|
+| Parameters  : valid flag, network cause value
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL USHORT kern_make_cause (BOOL cause_valid, UBYTE network_cause)
+{
+  GMM_TRACE_FUNCTION ("kern_make_cause");
+  
+  if (cause_valid)
+  {
+    if (network_cause >= 0x30 AND /* TCS 2.1 */
+        network_cause <= 0x3F) /* TCS 2.1 */
+    { /* TCS 2.1 */
+      GMM_RETURN_ (GMMCS_RETRY_IN_NEW_CELL); /* TCS 2.1 */
+    } /* TCS 2.1 */
+    else /* TCS 2.1 */
+    { /* TCS 2.1 */
+      GMM_RETURN_ (CAUSE_MAKE (DEFBY_STD, /* TCS 2.1 */
+                         ORIGSIDE_NET, /* TCS 2.1 */
+                         GMM_ORIGINATING_ENTITY, /* TCS 2.1 */
+                         network_cause)); /* TCS 2.1 */
+    } /* TCS 2.1 */
+  }
+  else
+  {
+    GMM_RETURN_ (GMMCS_NET_CAUSE_NOT_PRESENT);
+  }
+}
+#ifdef GMM_TCS4
+/*
++------------------------------------------------------------------------------
+| Function    : kern_make_new_cause
++------------------------------------------------------------------------------
+| Description : The function kern_make_new_cause()
+|       
+|            An internal 16 bit cause is generated from the cause received
+|            from the network. The reject causes indicating a retry in a new
+|            cell are translated to a single value. In case no cause was sent 
+|            by the network a special internal value is returned to handle this.
+|
+| Parameters  : valid flag, network cause value
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_CAUSE_ps_cause kern_make_new_cause ( void )
+{
+  T_CAUSE_ps_cause ps_cause;
+  GMM_TRACE_FUNCTION ("kern_make_cause");
+  ps_cause.ctrl_value = CAUSE_is_from_mm;
+    
+  switch (gmm_data->kern.detach_cap.error_cause)
+  {
+    case GMMCS_INT_NOT_PRESENT:
+    case GMMCS_NET_CAUSE_NOT_PRESENT    :
+    case MMCS_INT_NOT_PRESENT:
+      ps_cause.value.mm_cause = CAUSE_MM_NO_ERROR;
+      break;
+    default:
+      ps_cause.ctrl_value = CAUSE_is_from_nwmm;
+      ps_cause.value.nwmm_cause = gmm_data->kern.detach_cap.error_cause&0xff; /* TCS 4.0 */
+      break;
+    case MMCS_UNSPECIFIED:
+    case GMMCS_INT_PROTOCOL_ERROR:
+      ps_cause.value.mm_cause = CAUSE_MM_PROTOCOL_ERROR;
+      break;
+    case GMMCS_SUCCESS:
+      ps_cause.value.mm_cause = CAUSE_MM_SUCCESS;
+      break;
+    case GMMCS_AAC_UNDER_5:
+    case GMMCS_AAC_OVER_5:
+      ps_cause.value.mm_cause = CAUSE_MM_TRY_TO_UPDATE;
+      break;
+    case MMCS_AUTHENTICATION_REJECTED:
+    case GMMCS_AUTHENTICATION_REJECTED:
+      ps_cause.value.mm_cause = CAUSE_MM_AUTHENTICATION_REJECTED;
+      break;
+    case MMCS_SIM_REMOVED:
+    case GMMCS_SIM_REMOVED:
+      ps_cause.value.mm_cause = CAUSE_MM_SIM_REMOVED;
+      break;
+    case GMMCS_POWER_OFF:
+      ps_cause.value.mm_cause = CAUSE_MM_POWER_OFF;
+      break;
+    case GMMCS_LIMITED_SERVICE:
+      ps_cause.value.mm_cause = CAUSE_MM_LIMITED_SERVICE;
+      break;
+    case MMCS_SUCCESS:
+      ps_cause.value.mm_cause = CAUSE_MM_SUCCESS;
+      break;
+    case MMCS_NO_REGISTRATION:
+      ps_cause.value.mm_cause = CAUSE_MM_NO_REGISTRATION;
+      break;      
+    case MMCS_TIMER_RECOVERY:
+      ps_cause.value.mm_cause = CAUSE_MM_TIMER_RECOVERY;
+      break;      
+    case MMCS_NO_REESTABLISH:
+      ps_cause.value.mm_cause = CAUSE_MM_NO_REESTABLISH;
+      break;      
+    case MMCS_INT_PREEM:
+      ps_cause.value.mm_cause = CAUSE_MM_INT_PREEM;
+      break;      
+    case MMCS_PLMN_NOT_IDLE_MODE:
+      ps_cause.value.mm_cause = CAUSE_MM_PLMN_NOT_IDLE_MODE;
+      break;   
+
+
+  }
+  GMM_RETURN_ (ps_cause);
+}
+#endif
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_call_undone_mm_proc_der 
++------------------------------------------------------------------------------
+| Description : This function starts all undone MM procedures after finishing the last 
+|            MM procedure
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_call_undone_mm_proc_der ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_call_undone_mm_proc_der" );
+  if (!gmm_data->kern.suspension_type)
+  /*
+   * default branch
+   */
+  {
+    kern_resume_grr_der(); 
+    GMM_RETURN;
+  }
+
+
+  if (GMM_SUSP_EM_CALL & gmm_data->kern.suspension_type)
+  {
+    kern_mm_cm_emergency_res(MMGMM_ESTABLISH_OK);
+  }
+  else if (GMM_SUSP_LAU & gmm_data->kern.suspension_type)
+  {
+    kern_mm_lau();
+  }
+  else if (GMM_SUSP_CALL & gmm_data->kern.suspension_type)
+  {
+    kern_mm_cm_establish_res(MMGMM_ESTABLISH_OK);
+  }
+  else if (GMM_SUSP_IMSI_DETACH & gmm_data->kern.suspension_type)
+  {
+    kern_mm_imsi_detach();
+  }
+  else if (GMM_SUSP_LOCAL_DETACH & gmm_data->kern.suspension_type)
+  {
+    kern_local_detach ( GMMCS_INT_NOT_PRESENT, FALSE, GMM_LOCAL_DETACH_PROC_NOT_CHANGED); /* TCS 2.1 */
+
+  }
+  GMM_RETURN;
+}
+/*
++------------------------------------------------------------------------------
+| Function    : kern_call_undone_mm_proc_reg 
++------------------------------------------------------------------------------
+| Description : This function starts all undone MM procedures after finishing the last 
+|            MM procedure
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_call_undone_mm_proc_reg ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_call_undone_mm_proc_reg" );
+  if (GMM_SUSP_NONE == gmm_data->kern.suspension_type)
+  /*
+   * default branch
+   */
+  {
+    kern_resume_grr_reg(); 
+    GMM_RETURN;
+  }
+
+
+  if (GMM_SUSP_EM_CALL & gmm_data->kern.suspension_type)
+  {
+    kern_mm_cm_emergency_res(MMGMM_ESTABLISH_OK);
+  }
+  else if (GMM_SUSP_LAU & gmm_data->kern.suspension_type)
+  {
+    kern_mm_lau();
+  }
+  else if (GMM_SUSP_CALL & gmm_data->kern.suspension_type)
+  {
+    kern_mm_cm_establish_res(MMGMM_ESTABLISH_OK);
+  }
+  else if (GMM_SUSP_IMSI_DETACH & gmm_data->kern.suspension_type)
+  {
+    kern_mm_imsi_detach();
+  }
+  else if (GMM_SUSP_LOCAL_DETACH & gmm_data->kern.suspension_type)
+  {
+    kern_local_detach ( GMMCS_INT_NOT_PRESENT, FALSE, GMM_LOCAL_DETACH_PROC_NOT_CHANGED); /* TCS 2.1 */
+  }
+  GMM_RETURN;
+}
+
+/*
++------------------------------------------------------------------------------
+| Function    : kern_reset_cipher
++------------------------------------------------------------------------------
+| Description : This function deletes the ciphering parameters
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void kern_reset_cipher ( void )
+{ 
+  GMM_TRACE_FUNCTION( "kern_reset_cipher" );
+  
+  /*
+   * 3GPP,24.008:
+   * 4.7.7.2   Authentication and ciphering response by the MS
+   *
+   * The RAND and RES values stored in the mobile station shall be deleted:
+   * - if the mobile station enters the GMM states GMM-DEREGISTERED or GMM-NULL.
+   */
+  /* 
+   * 3GPP,24.008:
+   * 4.7.7.4  GPRS ciphering key sequence number
+   *
+   * If the GPRS ciphering key sequence number is deleted, the associated GPRS GSM 
+   * ciphering key , GPRS UMTS ciphering key and GPRS UMTS integrity key shall be deleted 
+   * (i.e. the established GSM security context or the UMTS security context is no longer
+   * valid).  
+   */
+  TRACE_EVENT ("ciphering OFF");
+  gmm_data->cipher = FALSE;
+
+  GMM_RETURN;
+}
+