fc-selenite: src/g23m-gprs/gmm/gmm

comparison src/g23m-gprs/gmm/gmm_kernf.c @ 1:d393cd9bb723

src/g23m-*: initial import from Magnetite

author	Mychaela Falconia <falcon@freecalypso.org>
date	Sun, 15 Jul 2018 04:40:46 +0000
parents
children

comparison

equal deleted inserted replaced

-:b6a5e36de839
+:d393cd9bb723
+/*
++-----------------------------------------------------------------------------
+|  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;
+}

FreeCalypso > hg > fc-selenite

comparison src/g23m-gprs/gmm/gmm_kernf.c @ 1:d393cd9bb723