FreeCalypso > hg > fc-tourmaline
view src/g23m-gprs/gmm/gmm_kernp.c @ 273:5caa86ee2cfa
enable L1_NEW_AEC in l1_confg.h (bold change)
The AEC function implemented in DSP ROM 3606 on the Calypso silicon
we work with is the one that corresponds to L1_NEW_AEC; the same holds
for DSP 34 and even for DSP 33 with more recent patch versions.
However, TI shipped their TCS211 reference fw with L1_NEW_AEC set to 0,
thus driving AEC the old way if anyone tried to enable it, either via
AT%Nxxxx or via the audio mode facility. As a result, the fw would
try to control features which no longer exist in the DSP (long vs short
echo and the old echo suppression level bits), while providing no way
to tune the 8 new parameter words added to the DSP's NDB page.
The only sensible solution is to bite the bullet and enable L1_NEW_AEC
in L1 config, with fallout propagating into RiViera Audio Service
T_AUDIO_AEC_CFG structure and into /aud/*.cfg binary file format.
The latter fallout will be addressed in further code changes.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Thu, 29 Jul 2021 18:32:40 +0000 |
parents | fa8dc04885d8 |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : GPRS (8441) | Modul : gmm_kernp.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 | functions to handles the incoming primitives as described in | the SDL-documentation (KERN-statemachine) +----------------------------------------------------------------------------- */ #ifndef GMM_KERNP_C #define GMM_KERNP_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_f.h" /* to ger the gobal functions */ #include "gmm_kernl.h" /* to ger the local functions */ #include "gmm_kernf.h" /* to ger the local functions */ #include "gmm_rdys.h" /* to get some signals */ #include <string.h> /* to get memcpy */ #include "gmm_txs.h" /* to get some signals */ #include "gmm_syncs.h" #include "gmm_em.h" /* To get Engineering Mode functions */ /*==== CONST ================================================================*/ /*==== LOCAL VARS ===========================================================*/ /*==== PRIVATE FUNCTIONS ====================================================*/ /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : kern_t3302 +------------------------------------------------------------------------------ | Description : Handles expiry of timer T3302. This function is called from | pei_primitive(). | Timeout for Attach or RAU failure | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void kern_t3302(void) { GMM_TRACE_FUNCTION( "kern_t3302" ); TRACE_0_INFO("TIMEOUT T3302"); sig_kern_rdy_stop_t3302_req(); /* * reset attach attempt counter * <R.GMM.ATTACH.M.010> */ /* * reset rau attempt counter * <R.GMM.ATTACH.M.010> */ switch( GET_STATE( KERN ) ) { case KERN_GMM_DEREG_RESUMING: case KERN_GMM_DEREG_SUSPENDING: case KERN_GMM_DEREG_SUSPENDED: gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau=FALSE; break; case KERN_GMM_REG_SUSPENDING: gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau=FALSE; SET_STATE(GU,GU_UPDATE_NEEDED); break; case KERN_GMM_REG_RESUMING: case KERN_GMM_REG_SUSPENDED: gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau=FALSE; SET_STATE(GU,GU_UPDATE_NEEDED); break; case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: kern_attach_reset(); kern_attach (); break; case KERN_GMM_REG_ATTEMPTING_TO_UPDATE: kern_attach_reset(); if (PERIODIC_RAU == gmm_data->kern.attach_cap.update_proc_type) { /* 44.2.3.3.2 */ kern_periodic_rau(); } else { kern_rau_limited(); } break; case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM: /* * GPRS is still attached (normal service) * so we need to resume LLC again */ kern_attach_reset(); kern_rau(); break; default: TRACE_ERROR( "kern_t3302 unexpected" ); break; } GMM_RETURN; } /* kern_t3302 */ /* +------------------------------------------------------------------------------ | Function : kern_t3310 +------------------------------------------------------------------------------ | Description : Handles expiry of timer T3310. This function is called from | pei_primitive(). | Timeout for ATTACH | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void kern_t3310 (void) { GMM_TRACE_FUNCTION( "kern_t3310" ); TRACE_0_INFO("TIMEOUT T3310"); gmm_data->kern.attach_cap.t3310_value=0; switch( GET_STATE( KERN ) ) { case KERN_GMM_REG_INITIATED: /************************************************************************ * MSC: 3.8 Attach * * MSC: 3.8.1 Normal Attach * MSC: 3.8.1.4 Abnormal cases * MSC: 3.8.1.4.3 c) T3310 time-out ************************************************************************/ if ( gmm_data->kern.ct3310 < MAX_CT3310 ) { /* * ATTACH * <R.GMM.AGABNORM.M.007> */ kern_gmmreg_detach ( GMMREG_DT_GPRS, GMMCS_NET_FAIL, /* TCS 2.1 */ GMMREG_SEARCH_RUNNING, GMMCS_NET_FAIL); kern_attach(); } else { /* * AAC *<R.GMM.AGABNORM.M.008> */ kern_aac(GMMCS_NO_SERVICE); /* TCS 2.1 */ } break; case KERN_GMM_RAU_INITIATED: /************************************************************************ * MSC: 3.10 RAU * * MSC: 3.10.1 Normal and periodic RAU initiation * MSC: 3.10.1.4 Abnormal cases * MSC: 3.10.1.4.3 c) T3310 time-out * ************************************************************************/ /* * I reused the timer T3310 instead of T3330 */ if ( gmm_data->kern.ct3310 < MAX_CT3310 ) { if (PERIODIC_RAU == gmm_data->kern.attach_cap.update_proc_type) { /* 44.2.3.3.2 */ kern_periodic_rau(); } else { kern_rau_limited(); } } else { /* * AAC */ kern_aac(GMMCS_NO_SERVICE); /* TCS 2.1 */ } break; /* START PATCH UBUOB ISSUE 8274 */ case KERN_GMM_REG_RESUMING: case KERN_GMM_REG_SUSPENDING: case KERN_GMM_REG_SUSPENDED: gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = FALSE; SET_STATE(GU,GU_UPDATE_NEEDED); break; /* END PATCH UBUOB ISSUE 8274 */ case KERN_GMM_REG_LIMITED_SERVICE: TRACE_EVENT("T3310 ignored in limited mode"); break; default: TRACE_ERROR( "kern_t3310 unexpected" ); break; } GMM_RETURN; } /* kern_t3310 */ /* +------------------------------------------------------------------------------ | Function : kern_t3311 +------------------------------------------------------------------------------ | Description : Handles expiry of timer T3310. This function is called from | pei_primitive(). | Timeout for ATTACH or RAU Reject | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void kern_t3311 (void) { GMM_TRACE_FUNCTION( "kern_t3311" ); TRACE_0_INFO("TIMEOUT T3311"); switch( GET_STATE( KERN ) ) { case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: kern_attach (); break; case KERN_GMM_REG_NORMAL_SERVICE: /* * <R.GMM.RNABNORM.M.022> */ kern_periodic_rau(); break; case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM: kern_llgmm_suspend(LLGMM_RAU); /*FALLTHROUGH*/ //lint -fallthrough case KERN_GMM_REG_ATTEMPTING_TO_UPDATE: kern_rau_limited (); break; /* START PATCH UBUOB ISSUE 8893 */ case KERN_GMM_DEREG_SUSPENDING: case KERN_GMM_DEREG_SUSPENDED: case KERN_GMM_DEREG_RESUMING: /* END PATCH UBUOB ISSUE 8893 */ case KERN_GMM_REG_RESUMING: /* START PATCH UBUOB ISSUE 8273 */ case KERN_GMM_REG_SUSPENDING: case KERN_GMM_REG_SUSPENDED: gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = FALSE; SET_STATE(GU,GU_UPDATE_NEEDED); break; /* END PATCH UBUOB ISSUE 8273 */ default: TRACE_ERROR( "kern_t3311 unexpected" ); break; } GMM_RETURN; } /* kern_t3311 */ /* +------------------------------------------------------------------------------ | Function : kern_t3312 +------------------------------------------------------------------------------ | Description : Handles expiry of timer T3312. This function is called from | pei_primitive(). | Periodic RAU timer | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void kern_t3312 (void) { GMM_TRACE_FUNCTION( "kern_t3312" ); TRACE_0_INFO("TIMEOUT T3312"); switch( GET_STATE( KERN ) ) { case KERN_GMM_REG_NORMAL_SERVICE: if (GMM_GRR_STATE_CR==gmm_data->kern.attach_cap.grr_state) { gmm_data->kern.timeout_t3312 = TRUE; SET_STATE(GU,GU_UPDATE_NEEDED); } else { kern_periodic_rau(); } break; case KERN_GMM_REG_NO_CELL_AVAILABLE: /* * 24.008 ch 4.7.2.2. at the end: * * If the MS is both IMSI attached for GPRS and non-GPRS services in a network that * operates in network operation mode I, and if the MS has camped on a cell that does * not support GPRS, and timer T3312 expires, then the MS shall start an MM location * updating procedure. In addition, the MS shall perform a combined routing area update * procedure indicating "combined RA/LA updating with IMSI attach" when the MS enters * a cell that supports GPRS and indicates that the network is in operation mode I. */ gmm_data->kern.timeout_t3312 = TRUE; SET_STATE(GU,GU_UPDATE_NEEDED); if (GMM_MM_DEREG != GET_STATE(MM) && GMMRR_LA_INVALID!=gmm_data->kern.sig_cell_info.env.rai.lac) { SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING); #endif kern_llgmm_suspend(LLGMM_CALL); /* in no cell availble LLC is alread susended */ kern_gmmrr_suspend(GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU); } break; case KERN_GMM_REG_LIMITED_SERVICE: case KERN_GMM_REG_IMSI_DETACH_INITIATED: case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM: case KERN_GMM_REG_RESUMING: case KERN_GMM_REG_SUSPENDING: case KERN_GMM_REG_ATTEMPTING_TO_UPDATE: case KERN_GMM_REG_SUSPENDED: /* no break; */ /* * <R.GMM.RAUTIMER.M.009> */ gmm_data->kern.timeout_t3312 = TRUE; SET_STATE(GU,GU_UPDATE_NEEDED); break; default: break; } GMM_RETURN; } /* kern_t3312 */ /* +------------------------------------------------------------------------------ | Function : kern_t3321 +------------------------------------------------------------------------------ | Description : Handles expiry of timer T3321. This function is called from | pei_primitive(). | Timeout for DETACH | | MSC: 3.9 GPRS detach procedure | | MCS: 3.9.3 Abnormal cases | MSC: 3.9.3.1 a) Timeout of timer T3321 | | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void kern_t3321 (void) { #ifdef REL99 T_gmobile_identity gmobile_identity; /* TCS 4.0 */ #endif GMM_TRACE_FUNCTION( "kern_t3321" ); TRACE_0_INFO("TIMEOUT T3321"); /* * MSC: 3.9 GPRS detach procedure * * MCS: 3.9.3 Abnormal cases * MSC: 3.9.3.1 a) Timeout of timer T3321 */ if ( ++gmm_data->kern.ct3321 < 5 ) { MCAST (u_detach_request, U_DETACH_REQUEST); TRACE_EVENT (" START T3321" ); sig_kern_rdy_start_timer_req ( kern_T3321, gmm_data->kern.t3321_val ); u_detach_request->u_detach_type.u_type_of_detach = gmm_data->kern.detach_cap.detach_type, u_detach_request->u_detach_type.power_off = PO_NORMAL_DETACH; #ifdef REL99 /* Detach request sent to a Release 99 network has two addional * parameters. PTMSI and PTMSI signature */ switch (gmm_data->kern.sig_cell_info.sgsnr_flag)/*!gmm_data->release99 =>old code*/ /* TCS 4.0 */ { default: case PS_SGSN_UNKNOWN: case PS_SGSN_98_OLDER: u_detach_request->v_gmobile_identity = FALSE; /* TCS 4.0 */ u_detach_request->v_p_tmsi_signature_2 = FALSE; /* TCS 4.0 */ break; case PS_SGSN_99_ONWARDS: /* * PTMSI */ kern_ulong2mobile_identity( gmm_data->ptmsi.current, &gmobile_identity ); /* TCS 4.0 */ u_detach_request->v_gmobile_identity = TRUE; /* TCS 4.0 */ u_detach_request->gmobile_identity = gmobile_identity; /* TCS 4.0 */ /* * PTMSI Signature */ if(gmm_data->ptmsi_signature.available) /* TCS 4.0 */ { /* TCS 4.0 */ u_detach_request->v_p_tmsi_signature_2 =TRUE; /* TCS 4.0 */ u_detach_request->p_tmsi_signature_2.p_tmsi_signature_value /* TCS 4.0 */ = gmm_data->ptmsi_signature.value; /* TCS 4.0 */ } /* TCS 4.0 */ else /* TCS 4.0 */ { /* TCS 4.0 */ u_detach_request->v_p_tmsi_signature_2=FALSE; /* TCS 4.0 */ } /* TCS 4.0 */ break; } #endif switch ( gmm_data->kern.detach_cap.detach_type ) { case GMMREG_DT_GPRS: u_detach_request->u_detach_type.u_type_of_detach = DT_GPRS; break; case GMMREG_DT_IMSI: u_detach_request->u_detach_type.u_type_of_detach = DT_IMSI; break; case GMMREG_DT_COMB: u_detach_request->u_detach_type.u_type_of_detach = DT_COMB; break; case GMMREG_DT_SIM_REMOVED: if ( GMM_MM_DEREG != GET_STATE(MM) ) { u_detach_request->u_detach_type.u_type_of_detach = DT_COMB; } else { u_detach_request->u_detach_type.u_type_of_detach = DT_GPRS; } break; default: TRACE_ERROR ("unexpexted GMMREG_DT_TYPE"); break; } kern_mm_detach_started (); sig_kern_tx_data_req ( CURRENT_TLLI, U_DETACH_REQUEST); } else { switch( GET_STATE( KERN ) ) { case KERN_GMM_DEREG_INITIATED: kern_local_detach( GMMCS_INT_NOT_PRESENT, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_DEREG); /* TCS 2.1 */ break; case KERN_GMM_REG_IMSI_DETACH_INITIATED: /* * <R.GMM.DMABNORM.M.020> */ kern_local_detach( GMMCS_INT_NOT_PRESENT, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_REG_NORMAL); /* TCS 2.1 */ break; default: TRACE_ERROR( "kern_t3321 unexpected" ); break; } } GMM_RETURN; } /* kern_t3321 */ /* +------------------------------------------------------------------------------ | Function : kern_tpower_off +------------------------------------------------------------------------------ | Description : Handles expiry of timer Tpower_off. This function is called from | pei_primitive(). | Timeout for power_off after sending DETACH message | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void kern_tpower_off (void) { GMM_TRACE_FUNCTION( "kern_tpower_off" ); TRACE_0_INFO("TIMEOUT TPOWER_OFF"); kern_local_detach( GMMCS_POWER_OFF, FALSE, /* TCS 2.1 */ GMMREG_DT_SOFT_OFF==gmm_data->kern.detach_cap.detach_type? GMM_LOCAL_DETACH_PROC_SOFT_OFF: GMM_LOCAL_DETACH_PROC_POWER_OFF); GMM_RETURN; } /* kern_tpower_off */ /* +------------------------------------------------------------------------------ | Function : kern_tlocal_detach +------------------------------------------------------------------------------ | Description : Handles expiry of timer Tlocal_detach. This function is called from | pei_primitive(). | function local_detach is called to locally detach the MS. | GRR and LLC can not unassigned immediately. So GMM waits untill | the tlocal_detach timer has been expired or either CGRLC_TRIGGER_IND | has been received or GMMRR_SUSPEND_CNF has been received. | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void kern_tlocal_detach (void) { GMM_TRACE_FUNCTION( "kern_tlocal_detach" ); switch( GET_STATE( KERN ) ) { default: TRACE_ERROR("tlocal_detach not in state DEREG_SUSPENDING"); /* NO break; */ case KERN_GMM_DEREG_SUSPENDING: kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_UNKNOWN); break; } GMM_RETURN ; } /* kern_tlocal_detach */ /* +------------------------------------------------------------------------------ | Function : kern_gmmreg_net_req +------------------------------------------------------------------------------ | Description : Handles the primitive GMMREG_NET_REQ | | MSC: 3.20 MM Interface | MSC: 3.20.2 Network selection | | Parameters : *gmmreg_net_req - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_gmmreg_net_req ( T_GMMREG_NET_REQ *gmmreg_net_req ) { GMM_TRACE_FUNCTION( "kern_gmmreg_net_req" ); PFREE (gmmreg_net_req); kern_mm_net_req(); GMM_RETURN; } /* kern_gmmreg_net_req() */ /* +------------------------------------------------------------------------------ | Function : kern_gmmreg_plmn_res +------------------------------------------------------------------------------ | Description : Handles the primitive GMMREG_PLMN_RES | | MSC: 3.20 MM Interface | MSC: 3.20.2 Network selection | | Parameters : *gmmreg_plmn_res - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_gmmreg_plmn_res ( T_GMMREG_PLMN_RES *gmmreg_plmn_res ) { GMM_TRACE_FUNCTION( "kern_gmmreg_plmn_res" ); gmm_data->kern.attach_cap.network_selection_mode=MODE_MAN; kern_remove_plmn_from_forbidden_list(gmmreg_plmn_res->plmn); /* START PATCH UBUOB ISSUE 8276 */ /* T3302 should not be stopped here, because this is dangerous if the */ /* user selection does not lead to a different PLMN */ /*vsi_t_stop ( GMM_handle, kern_T3302);*/ /*sig_kern_rdy_start_t3302_req();*/ /* END PATCH UBUOB ISSUE 8276 */ /* When we receive manual mode network selection stop TSYNC timer */ vsi_t_stop ( GMM_handle, sync_TSYNC); gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = FALSE; /* * attach_cap.gmmreg sets the caller of the attach procedure to MMI */ gmm_data->kern.attach_cap.gmmreg = TRUE; /* * if the moble has been rejected with cause #11,#12, or #13 it has to igored * when user wanted the moile explicitly to try to attach * TC 44.2.1.1.4.3.2 */ gmm_data->kern.detach_cap.error_cause=GMMCS_INT_NOT_PRESENT; /* TCS 2.1 */ /* Setting mm_status to FULL Service immediately on receiving PLMN Response creates a false display * on MMI if selecting forbidden PLMN second time in a row. However, it is necessary in case of Normal PLMN selection * for an early indication to ACI. Hence setting mm_status to Full Service only if the selected PLMN was not rejected by * the N/W in the same power cycle. */ if((memcmp(gmm_data->kern.attach_cap.list_of_forbidden_plmns_for_gprs_service[0].mcc,gmmreg_plmn_res->plmn.mcc, SIZE_MCC) NEQ 0) AND (memcmp(gmm_data->kern.attach_cap.list_of_forbidden_plmns_for_gprs_service[0].mnc,gmmreg_plmn_res->plmn.mnc, SIZE_MNC)NEQ 0)) { gmm_data->kern.sig_cell_info.mm_status = MMGMM_FULL_SERVICE; sig_kern_sync_set_mm_state(MMGMM_FULL_SERVICE); } #ifndef NTRACE /* * My assumption is, that I have to know the class if plmn_res comes as power * on primitive with AT+COPS=1,2,"001001". There are no possabilities to * change the classes. a class change is handeled with attach_req */ if(gmm_data->kern.attach_cap.mobile_class!=gmmreg_plmn_res->mobile_class) { TRACE_ERROR("class change not expected: NO DETACH_REQ will be send!"); } #endif gmm_data->kern.attach_cap.plmn_requested = gmmreg_plmn_res->plmn; gmm_data->kern.attach_cap.mobile_class = gmmreg_plmn_res->mobile_class; gmm_data->kern.attach_cap.attach_type = gmmreg_plmn_res->attach_type; #ifndef NTRACE switch ( gmm_data->kern.attach_cap.mobile_class ) { case GMMREG_CLASS_CC: TRACE_0_PARA ("MS class CC"); break; case GMMREG_CLASS_CG: TRACE_0_PARA ("MS class CG"); break; case GMMREG_CLASS_B: TRACE_0_PARA ("MS class B"); break; case GMMREG_CLASS_BG: TRACE_0_PARA ("MS class BG"); break; case GMMREG_CLASS_BC: TRACE_0_PARA ("MS class BC"); break; case GMMREG_CLASS_A: TRACE_0_PARA ("MS class A"); break; default: TRACE_ERROR ("unknown mobile class"); break; } switch (gmm_data->kern.attach_cap.attach_type) { case GMMREG_AT_IMSI: TRACE_EVENT ("----- GSM only attach -----"); break; case GMMREG_AT_GPRS: TRACE_EVENT ("----- GPRS attach -----"); break; case GMMREG_AT_COMB: TRACE_EVENT ("----- GSM and GPRS attach -----"); break; default: TRACE_ERROR ("unknown attach type"); break; } #endif { PALLOC ( mmgmm_plmn_res, MMGMM_PLMN_RES); mmgmm_plmn_res->plmn = gmmreg_plmn_res->plmn; mmgmm_plmn_res->reg_type = REG_CELL_SEARCH_ONLY; PFREE (gmmreg_plmn_res); switch( GET_STATE( KERN ) ) { case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ: case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ: mmgmm_plmn_res->reg_type = REG_GPRS_INACTIVE; break; case KERN_GMM_NULL_NO_IMSI: if (GMMREG_CLASS_CC==gmm_data->kern.attach_cap.mobile_class || GMMREG_AT_IMSI== gmm_data->kern.attach_cap.attach_type) { /* NO state change */ } else { SET_STATE ( KERN, KERN_GMM_DEREG_NO_IMSI); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI); #endif } mmgmm_plmn_res->reg_type = REG_GPRS_INACTIVE; break; case KERN_GMM_DEREG_RESUMING: case KERN_GMM_REG_RESUMING: case KERN_GMM_DEREG_NO_IMSI: break; /* * GMM-DEREGISTERED */ case KERN_GMM_DEREG_SUSPENDING: /* * not reachable beause of save in pei */ case KERN_GMM_DEREG_SUSPENDED: kern_resume_grr_der(); /* NO break;*/ case KERN_GMM_DEREG_PLMN_SEARCH: case KERN_GMM_DEREG_LIMITED_SERVICE: case KERN_GMM_DEREG_NO_CELL_AVAILABLE: case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: if (GMMREG_CLASS_CC==gmm_data->kern.attach_cap.mobile_class || GMMREG_AT_IMSI== gmm_data->kern.attach_cap.attach_type) { SET_STATE ( KERN, KERN_GMM_NULL_PLMN_SEARCH); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_PLMN_SEARCH); #endif mmgmm_plmn_res->reg_type = REG_GPRS_INACTIVE; } else { SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH); #endif } break; case KERN_GMM_NULL_PLMN_SEARCH: case KERN_GMM_NULL_IMSI: if (GMMREG_CLASS_CC==gmm_data->kern.attach_cap.mobile_class || GMMREG_AT_IMSI== gmm_data->kern.attach_cap.attach_type) { SET_STATE ( KERN, KERN_GMM_NULL_PLMN_SEARCH); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_PLMN_SEARCH); #endif mmgmm_plmn_res->reg_type = REG_GPRS_INACTIVE; } else { SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH); #endif kern_gmmrr_enable(); } break; case KERN_GMM_REG_NORMAL_SERVICE: case KERN_GMM_REG_NO_CELL_AVAILABLE: case KERN_GMM_REG_LIMITED_SERVICE: case KERN_GMM_RAU_INITIATED: case KERN_GMM_REG_INITIATED: case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM: case KERN_GMM_REG_ATTEMPTING_TO_UPDATE: break; case KERN_GMM_REG_SUSPENDING: /* * not reachablebeause of save in pei */ case KERN_GMM_REG_SUSPENDED: /* * Attach requests in suspended mode will be handled after resumption * by triggering form GRR with GMMRR_CELL_IND */ /* * The user is not allowed to change the mobile class or establish a * voice call the same time manuall network search is started. it would * not be nice */ kern_resume_grr_reg(); TRACE_ERROR("I hoped, that this never is happened, ..."); break; default: TRACE_ERROR( "GMMREG_PLMN_RES unexpected" ); break; } mmgmm_plmn_res->mobile_class=gmm_data->kern.attach_cap.mobile_class; PSEND ( hCommMM, mmgmm_plmn_res ); } GMM_RETURN; } /* kern_gmmreg_plmn_res() */ /* +------------------------------------------------------------------------------ | Function : kern_gmmreg_plmn_mode_req +------------------------------------------------------------------------------ | Description : Handles the primitive GMMREG_PLMN_MODE_REQ | | MSC: 3.20 MM Interface | MSC: 3.20.1 Change of PLMN Mode | | Parameters : *gmmreg_plmn_mode_req - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_gmmreg_plmn_mode_req ( T_GMMREG_PLMN_MODE_REQ *gmmreg_plmn_mode_req ) { GMM_TRACE_FUNCTION( "kern_gmmreg_plmn_mode_req" ); { PPASS ( gmmreg_plmn_mode_req, mmgmm_plmn_mode_req, MMGMM_PLMN_MODE_REQ ); /* * PATCH UBUOB 11.3.02: if we change from MANUAL to AUTOMATC or vice versa, * then we need to clear the limited_service flag * Problem was: Bouyg SIM, manual registration on SFR upon return to * auto mode, first GPRS ATTACH if (gmm_data->kern.attach_cap.network_selection_mode != gmmreg_plmn_mode_req->net_selection_mode) { gmm_data->kern.sig_cell_info.mm_status = MMGMM_FULL_SERVICE; sig_kern_sync_set_mm_state(MMGMM_FULL_SERVICE); } */ /* * PLMN mode set to manual mode with PLMN_RES only gmm_data->kern.attach_cap.network_selection_mode = gmmreg_plmn_mode_req->net_selection_mode; */ if (GMMREG_NET_SEL_MODE_AUTO == gmmreg_plmn_mode_req->net_selection_mode) { gmm_data->kern.attach_cap.network_selection_mode = gmmreg_plmn_mode_req->net_selection_mode; } else { TRACE_0_INFO ("manual mode ignored. will be set with PLMN_RES"); } PSEND ( hCommMM, mmgmm_plmn_mode_req ); } GMM_RETURN; } /* kern_gmmreg_plmn_mode_req () */ /* +------------------------------------------------------------------------------ | Function : kern_gmmreg_config_req +------------------------------------------------------------------------------ | Description : Handles the primitive GMMREG_CONFIG_REQ | | Parameters : *gmmreg_config_req - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_gmmreg_config_req ( T_GMMREG_CONFIG_REQ *gmmreg_config_req ) { GMM_TRACE_FUNCTION( "kern_gmmreg_config_req" ); gmm_data->config.cipher_on = gmmreg_config_req->cipher_on; PFREE (gmmreg_config_req); GMM_RETURN; } /* kern_gmmreg_plmn_mode_req () */ /* +------------------------------------------------------------------------------ | Function : kern_gmmreg_detach_req +------------------------------------------------------------------------------ | Description : Handles the primitive GMMREG_DETACH_REQ | | Parameters : *gmmreg_detach_req - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_gmmreg_detach_req ( T_GMMREG_DETACH_REQ *gmmreg_detach_req ) { GMM_TRACE_FUNCTION( "kern_gmmreg_detach_req" ); /* * RAU may interrupt detach procedure, so we have to store the detach type */ gmm_data->kern.detach_cap.detach_type=gmmreg_detach_req->detach_type; gmm_data->kern.detach_cap.gmmreg=TRUE; switch (gmmreg_detach_req->detach_type) { case GMMREG_DT_GPRS: switch(gmm_data->kern.attach_cap.attach_type) { case GMMREG_AT_GPRS: case GMMREG_AT_NOT_KNOWN: gmm_data->kern.attach_cap.attach_type=GMMREG_AT_NOT_KNOWN; break; default: case GMMREG_AT_IMSI: case GMMREG_AT_COMB: gmm_data->kern.attach_cap.attach_type=GMMREG_AT_IMSI; break; } TRACE_EVENT ("Para: GPRS detach"); break; case GMMREG_DT_IMSI: gmm_data->kern.attach_cap.attach_type= (GMMREG_CLASS_CC == gmm_data->kern.attach_cap.mobile_class? GMMREG_AT_NOT_KNOWN: GMMREG_AT_GPRS); TRACE_EVENT ("Para: IMSI detach"); break; case GMMREG_DT_POWER_OFF: /* * TMSI reset to remove TMSI in GRR when gmmrr_assign_req will * be sent */ gmm_data->tmsi = GMMRR_TMSI_INVALID; gmm_data->kern.attach_cap.attach_type=GMMREG_AT_NOT_KNOWN; gmm_data->kern.attach_cap.network_selection_mode=MODE_AUTO; TRACE_EVENT ("Para: Power OFF"); break; case GMMREG_DT_SOFT_OFF: /* * TMSI reset to remove TMSI in GRR when gmmrr_assign_req will * be sent */ gmm_data->tmsi = GMMRR_TMSI_INVALID; gmm_data->kern.attach_cap.attach_type=GMMREG_AT_NOT_KNOWN; TRACE_EVENT ("Para: Soft OFF"); break; case GMMREG_DT_COMB: gmm_data->kern.attach_cap.service_mode=SERVICE_MODE_LIMITED; gmm_data->kern.attach_cap.attach_type=GMMREG_AT_NOT_KNOWN; TRACE_EVENT ("Para: GMMREG_DT_COMB"); break; case GMMREG_DT_SIM_REMOVED: gmm_data->kern.attach_cap.attach_type=GMMREG_AT_NOT_KNOWN; TRACE_EVENT ("Para: GMMREG_DT_SIM_REMOVED"); break; case GMMREG_DT_DISABLE_GPRS: TRACE_EVENT ("Para: GMMREG_DT_DISABLE_GPRS"); break; case GMMREG_DT_LIMITED_SERVICE: gmm_data->kern.attach_cap.service_mode=SERVICE_MODE_LIMITED; TRACE_EVENT ("Para: GMMREG_DT_LIMITED_SERVICE"); break; default: gmm_data->kern.attach_cap.attach_type= (GMMREG_CLASS_CG == gmm_data->kern.attach_cap.mobile_class? GMMREG_AT_NOT_KNOWN: GMMREG_AT_IMSI); vsi_o_ttrace(VSI_CALLER TC_ERROR,"Error: Unknown detach_type = %x", gmmreg_detach_req->detach_type); break; } gmm_data->kern.detach_cap.detach_type = gmmreg_detach_req->detach_type; gmm_data->kern.detach_cap.gmmreg = TRUE; gmm_data->kern.attach_cap.gmmreg = FALSE; #ifndef GMM_TCS4 gmm_data->kern.attach_cap.gmmsm = FALSE; #endif PFREE ( gmmreg_detach_req ); switch( GET_STATE( KERN ) ) { case KERN_GMM_REG_LIMITED_SERVICE: case KERN_GMM_REG_NO_CELL_AVAILABLE: case KERN_GMM_REG_TEST_MODE: case KERN_GMM_REG_TEST_MODE_NO_IMSI: switch ( gmm_data->kern.detach_cap.detach_type ) { case GMMREG_DT_IMSI: case GMMREG_DT_COMB: case GMMREG_DT_SIM_REMOVED: SET_STATE ( KERN, KERN_GMM_REG_SUSPENDED); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDED); #endif kern_mm_imsi_detach(); break; case GMMREG_DT_DISABLE_GPRS: kern_local_detach( GMMCS_INT_NOT_PRESENT, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_NULL_IMSI); /* TCS 2.1 */ break; case GMMREG_DT_GPRS: kern_local_detach( GMMCS_INT_NOT_PRESENT, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_NULL_IMSI); /* TCS 2.1 */ break; case GMMREG_DT_POWER_OFF: kern_local_detach( GMMCS_POWER_OFF, FALSE, /* TCS 2.1 */ GMM_LOCAL_DETACH_PROC_POWER_OFF); break; case GMMREG_DT_SOFT_OFF: kern_local_detach( GMMCS_POWER_OFF, FALSE, /* TCS 2.1 */ GMM_LOCAL_DETACH_PROC_SOFT_OFF); break; default: TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ"); break; } break; case KERN_GMM_REG_INITIATED: /* * This cause is abnormal, because the normal and not the local detach * procedure is started on power off * * MSC: 3.8.1.4.7 g) Power off * <R.GMM.AGABNORM.M.015>, * <R.GMM.AGABNORM.M.031> */ case KERN_GMM_REG_ATTEMPTING_TO_UPDATE: case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM: kern_gmmrr_attach_finished(); /* NO break;*/ case KERN_GMM_REG_NORMAL_SERVICE: switch ( gmm_data->kern.detach_cap.detach_type ) { case GMMREG_DT_IMSI: case GMMREG_DT_COMB: case GMMREG_DT_SIM_REMOVED: switch (gmm_data->kern.sig_cell_info.net_mode) { case GMMRR_NET_MODE_I: kern_detach( ); break; case GMMRR_NET_MODE_II: SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING); #endif kern_llgmm_suspend(LLGMM_CALL); kern_gmmrr_suspend(GMMRR_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_IMSI_DETACH); break; case GMMRR_NET_MODE_III: kern_detach( ); break; default: TRACE_ERROR ("unknown net mode"); break; } break; case GMMREG_DT_DISABLE_GPRS: case GMMREG_DT_GPRS: case GMMREG_DT_POWER_OFF: case GMMREG_DT_SOFT_OFF: kern_detach( ); break; default: TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ"); break; } break; case KERN_GMM_REG_IMSI_DETACH_INITIATED: switch ( gmm_data->kern.detach_cap.detach_type ) { case GMMREG_DT_DISABLE_GPRS: gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC; /* NO break */ default: kern_detach( ); break; } break; case KERN_GMM_REG_SUSPENDED: switch ( gmm_data->kern.detach_cap.detach_type ) { case GMMREG_DT_IMSI: case GMMREG_DT_COMB: case GMMREG_DT_SIM_REMOVED: kern_mm_imsi_detach(); break; case GMMREG_DT_DISABLE_GPRS: gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC; /* NO break; */ case GMMREG_DT_GPRS: /* * Wait untill GSM is finished */ break; case GMMREG_DT_POWER_OFF: kern_local_detach( GMMCS_POWER_OFF, FALSE, /* TCS 2.1 */ GMM_LOCAL_DETACH_PROC_POWER_OFF); break; case GMMREG_DT_SOFT_OFF: kern_local_detach( GMMCS_POWER_OFF, FALSE, /* TCS 2.1 */ GMM_LOCAL_DETACH_PROC_SOFT_OFF); break; default: TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ"); break; } break; case KERN_GMM_DEREG_RESUMING: case KERN_GMM_REG_RESUMING: TRACE_ERROR ("prim should be saved by pei"); /* NO break */ case KERN_GMM_REG_SUSPENDING: switch ( gmm_data->kern.detach_cap.detach_type ) { case GMMREG_DT_IMSI: case GMMREG_DT_COMB: case GMMREG_DT_SIM_REMOVED: gmm_data->kern.suspension_type |= GMM_SUSP_IMSI_DETACH; break; case GMMREG_DT_DISABLE_GPRS: gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC; /* NO break; */ case GMMREG_DT_GPRS: /* * Wait untill GSM is finished */ break; case GMMREG_DT_POWER_OFF: case GMMREG_DT_SOFT_OFF: SET_STATE ( KERN, KERN_GMM_REG_SUSPENDED); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDED); #endif kern_resume_grr_reg(); break; default: TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ"); break; } break; case KERN_GMM_NULL_NO_IMSI: case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ: switch ( gmm_data->kern.detach_cap.detach_type ) { case GMMREG_DT_IMSI: case GMMREG_DT_COMB: if ( GMM_MM_DEREG != GET_STATE(MM) ) { kern_mm_imsi_detach(); break; } /* else NO break;*/ case GMMREG_DT_SIM_REMOVED: case GMMREG_DT_GPRS: { PALLOC (gmmreg_detach_cnf, GMMREG_DETACH_CNF); gmmreg_detach_cnf->detach_type = gmm_data->kern.detach_cap.detach_type; PSEND ( hCommMMI, gmmreg_detach_cnf ); break; } case GMMREG_DT_POWER_OFF: SET_STATE ( KERN, KERN_GMM_NULL_NO_IMSI ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI ); #endif /* NO break*/ case GMMREG_DT_SOFT_OFF: kern_mm_imsi_detach_ind (GMMCS_INT_NOT_PRESENT, /* TCS 2.1 */ GET_STATE(MM)==GMM_MM_DEREG? MMGMM_DETACH_DONE: MMGMM_PERFORM_DETACH, gmm_data->kern.detach_cap.detach_type); break; case GMMREG_DT_DISABLE_GPRS: gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC; { PALLOC (gmmreg_detach_cnf, GMMREG_DETACH_CNF); gmmreg_detach_cnf->detach_type = gmm_data->kern.detach_cap.detach_type; PSEND ( hCommMMI, gmmreg_detach_cnf ); } break; default: TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ"); break; } break; case KERN_GMM_NULL_IMSI: case KERN_GMM_NULL_PLMN_SEARCH: case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ: switch ( gmm_data->kern.detach_cap.detach_type ) { case GMMREG_DT_IMSI: case GMMREG_DT_COMB: if ( GMM_MM_DEREG != GET_STATE(MM) ) { kern_mm_imsi_detach_ind (GMMCS_INT_NOT_PRESENT, MMGMM_PERFORM_DETACH, GMMREG_DT_SIM_REMOVED); break; } /* else NO break;*/ case GMMREG_DT_GPRS: { PALLOC (gmmreg_detach_cnf, GMMREG_DETACH_CNF); gmmreg_detach_cnf->detach_type = gmm_data->kern.detach_cap.detach_type; PSEND ( hCommMMI, gmmreg_detach_cnf ); break; } case GMMREG_DT_SOFT_OFF: SET_STATE ( KERN, KERN_GMM_NULL_IMSI ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI ); #endif kern_mm_imsi_detach_ind (GMMCS_INT_NOT_PRESENT, /* TCS 2.1 */ GET_STATE(MM)==GMM_MM_DEREG? MMGMM_DETACH_DONE: MMGMM_PERFORM_DETACH,gmm_data->kern.detach_cap.detach_type); break; case GMMREG_DT_SIM_REMOVED: case GMMREG_DT_POWER_OFF: SET_STATE ( KERN, KERN_GMM_NULL_NO_IMSI ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI ); #endif kern_mm_imsi_detach_ind (GMMCS_INT_NOT_PRESENT, /* TCS 2.1 */ GET_STATE(MM)==GMM_MM_DEREG? MMGMM_DETACH_DONE: MMGMM_PERFORM_DETACH, gmm_data->kern.detach_cap.detach_type); break; case GMMREG_DT_DISABLE_GPRS: gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC; { PALLOC (gmmreg_detach_cnf, GMMREG_DETACH_CNF); gmmreg_detach_cnf->detach_type = gmm_data->kern.detach_cap.detach_type; PSEND ( hCommMMI, gmmreg_detach_cnf ); } break; default: TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ"); break; } break; case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: kern_gmmrr_attach_finished(); /* NO break; */ case KERN_GMM_DEREG_NO_IMSI: case KERN_GMM_DEREG_PLMN_SEARCH: case KERN_GMM_DEREG_LIMITED_SERVICE: case KERN_GMM_DEREG_NO_CELL_AVAILABLE: case KERN_GMM_DEREG_INITIATED: case KERN_GMM_DEREG_SUSPENDED: case KERN_GMM_DEREG_SUSPENDING: switch ( gmm_data->kern.detach_cap.detach_type ) { case GMMREG_DT_IMSI: case GMMREG_DT_COMB: if ( GMM_MM_DEREG != GET_STATE(MM) ) { switch ( GET_STATE( KERN ) ) { case KERN_GMM_DEREG_SUSPENDING: gmm_data->kern.suspension_type |= GMM_SUSP_IMSI_DETACH; break; default: kern_imsi_detach_der_susp (); break; } } /* NO break;*/ case GMMREG_DT_GPRS: { PALLOC (gmmreg_detach_cnf, GMMREG_DETACH_CNF); gmmreg_detach_cnf->detach_type = gmm_data->kern.detach_cap.detach_type; PSEND ( hCommMMI, gmmreg_detach_cnf ); break; } case GMMREG_DT_SOFT_OFF: kern_local_detach( GMMCS_POWER_OFF, FALSE, GMM_LOCAL_DETACH_PROC_SOFT_OFF); /* TCS 2.1 */ break; case GMMREG_DT_POWER_OFF: kern_local_detach( GMMCS_POWER_OFF, FALSE, GMM_LOCAL_DETACH_PROC_POWER_OFF); /* TCS 2.1 */ break; case GMMREG_DT_DISABLE_GPRS: case GMMREG_DT_SIM_REMOVED: kern_local_detach( GMMCS_INT_PROTOCOL_ERROR, FALSE, /* TCS 2.1 */ GMM_LOCAL_DETACH_PROC_ENTER_DEREG ); break; default: TRACE_ERROR ("Unexpected detach type in primitive GMMREG_DETACH_REQ"); break; } break; case KERN_GMM_RAU_INITIATED: case KERN_GMM_RAU_WAIT_FOR_NPDU_LIST: /* * DETACH whilst RAU */ break; default: TRACE_ERROR( "GMMREG_DETACH_REQ unexpected" ); break; } GMM_RETURN; } /* kern_gmmreg_detach_req() */ /* +------------------------------------------------------------------------------ | Function : kern_gmmsms_reg_state_req +------------------------------------------------------------------------------ | Description : Handles the primitive GMMSMS_REG_STATE_REQ | | MSC: 3.21 Interaction with SMS | | Parameters : *gmmsms_reg_state_req - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_gmmsms_reg_state_req ( T_GMMSMS_REG_STATE_REQ *gmmsms_reg_state_req ) { GMM_TRACE_FUNCTION( "kern_gmmsms_reg_state_req" ); PFREE (gmmsms_reg_state_req); { PALLOC ( gmmsms_reg_state_cnf, GMMSMS_REG_STATE_CNF ); gmmsms_reg_state_cnf->radio_priority_level = gmm_data->kern.attach_cap.sms_radio_priority_level; switch( GET_STATE( KERN ) ) { case KERN_GMM_NULL_NO_IMSI: case KERN_GMM_NULL_IMSI: case KERN_GMM_DEREG_NO_IMSI: case KERN_GMM_REG_SUSPENDED: case KERN_GMM_REG_RESUMING: case KERN_GMM_DEREG_SUSPENDED: case KERN_GMM_DEREG_RESUMING: case KERN_GMM_DEREG_PLMN_SEARCH: case KERN_GMM_DEREG_LIMITED_SERVICE: case KERN_GMM_DEREG_NO_CELL_AVAILABLE: case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: case KERN_GMM_DEREG_INITIATED: case KERN_GMM_REG_INITIATED: 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_RAU_INITIATED: gmmsms_reg_state_cnf->reg_state = SMS_RS_DEREGISTERED; break; case KERN_GMM_REG_NORMAL_SERVICE: gmmsms_reg_state_cnf->reg_state = SMS_RS_REGISTERED; break; default: TRACE_ERROR( "GMMSMS_REG_STATE_REQ unexpected" ); break; } PSEND(hCommSMS,gmmsms_reg_state_cnf); }/* PALLOC*/ GMM_RETURN; } /* kern_gmmsms_reg_state_req() */ /* +------------------------------------------------------------------------------ | Function : kern_gmmrr_page_ind +------------------------------------------------------------------------------ | Description : Handles the primitive GMMRR_PAGE_IND | | Parameters : *gmmrr_page_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_gmmrr_page_ind ( T_GMMRR_PAGE_IND *gmmrr_page_ind ) { GMM_TRACE_FUNCTION( "kern_gmmrr_page_ind" ); switch( GET_STATE( KERN ) ) { /* * case GMM-DEREG * If the MS is not GPRS attached when it receives a paging for * GPRS services, the MS shall ignore the paging. * <R.GMM.PAGNGPRS.M.17> */ case KERN_GMM_REG_NORMAL_SERVICE: switch ( gmmrr_page_ind->page_id ) { case GMMRR_IMSI: TRACE_EVENT("paged with IMSI"); PFREE ( gmmrr_page_ind ); gmm_data->gu = GU2_NOT_UPDATED; kern_sim_del_locigprs (); kern_sim_gmm_update (); /* * <R.GMM.PGPIMSI.M.004>, <R.GMM.PGPIMSI.M.005>, * <R.GMM.PGPIMSI.M.008> */ gmm_data->kern.detach_cap.detach_type = GMM_DT_RE_ATTACH; kern_local_detach( GMMCS_INT_PROTOCOL_ERROR, /* TCS 2.1 */ FALSE, GMM_LOCAL_DETACH_PROC_RE_ATTACH); /* * goto LABEL ATTACH * * <R.GMM.PGPIMSI.M.009> * GMM-DEREG.NORMAL-SERVICE * kern_attach_reset(); kern_attach(); */ break; case GMMRR_PTMSI: TRACE_EVENT("paged with P-TMSI"); PFREE ( gmmrr_page_ind ); { /* * <R.GMM.PGPPTMS.M.007> */ PALLOC (llgmm_trigger_req, LLGMM_TRIGGER_REQ); llgmm_trigger_req->trigger_cause = LLGMM_TRICS_PAGE_RESPONSE; PSEND ( hCommLLC, llgmm_trigger_req ); break; } default: PFREE ( gmmrr_page_ind ); TRACE_ERROR( "IMSI or PTMSI page ID expected" ); break; } break; default: PFREE ( gmmrr_page_ind ); TRACE_ERROR( "GMMRR_PAGE_IND unexpected" ); break; } GMM_RETURN; } /* kern_gmmrr_page_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_gmmrr_cs_page_ind +------------------------------------------------------------------------------ | Description : Handles the primitive GMMRR_CS_PAGE_IND | | Parameters : *gmmrr_cs_page_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_gmmrr_cs_page_ind ( T_GMMRR_CS_PAGE_IND *gmmrr_cs_page_ind ) { GMM_TRACE_FUNCTION( "kern_gmmrr_cs_page_ind" ); PFREE ( gmmrr_cs_page_ind ); { PALLOC ( gmmrr_cs_page_res, GMMRR_CS_PAGE_RES ); switch (gmm_data->kern.attach_cap.mobile_class) { case GMMRR_CLASS_CG: gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ; gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS; break; /* PATCH JPS 26.10.02: with class BX, we can have BC in NMOIII */ case GMMREG_CLASS_BG: if (GMMRR_NET_MODE_III==gmm_data->kern.sig_cell_info.net_mode) { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ; gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS; break; } /* NO break; */ case GMMREG_CLASS_BC: case GMMREG_CLASS_B: /* PATCH JPS 26.10.02 END */ switch( GET_STATE( KERN ) ) { case KERN_GMM_DEREG_RESUMING: case KERN_GMM_REG_RESUMING: TRACE_ERROR ("prim should be saved by pei"); break; case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = TRUE; /* NO break;*/ case KERN_GMM_DEREG_NO_IMSI: case KERN_GMM_DEREG_SUSPENDED: case KERN_GMM_DEREG_LIMITED_SERVICE: case KERN_GMM_DEREG_NO_CELL_AVAILABLE: case KERN_GMM_DEREG_PLMN_SEARCH: case KERN_GMM_DEREG_INITIATED: case KERN_GMM_REG_INITIATED: if (GMM_MM_DEREG != GET_STATE(MM) && MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status ) { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF; SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDED ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDED ); #endif } else { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ; } gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS; break; case KERN_GMM_REG_SUSPENDED: case KERN_GMM_REG_LIMITED_SERVICE: case KERN_GMM_REG_NO_CELL_AVAILABLE: if (GMM_MM_DEREG != GET_STATE(MM) && MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status) { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF; SET_STATE ( KERN, KERN_GMM_REG_SUSPENDED ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDED ); #endif kern_llgmm_suspend(LLGMM_CALL); } else { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ; } gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS; break; case KERN_GMM_REG_ATTEMPTING_TO_UPDATE: if (GMM_MM_DEREG != GET_STATE(MM) && MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status) { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF; gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = TRUE; SET_STATE ( KERN, KERN_GMM_REG_SUSPENDED ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDED ); #endif kern_llgmm_suspend(LLGMM_CALL); } else { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ; } gmmrr_cs_page_res->susp_gprs = GMMRR_SUSP_GPRS; /* * kern_llgmm_unassign(); */ break; case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM: /* IOT: Combined RA/LA is accepted with network cause 16 * MSC temporarily unavailable. MM state is reset to GMM_MM_DEREG * From the IOT, it was observed that after GMM moves to NMOII, MM * was able to perform LAU successfully, but not combined RAU. Hence * in this state we should be able to make and receive CS calls * Also network is able to reach us through paging */ if (/*GMM_MM_DEREG != GET_STATE(MM) && */ MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status) { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF; gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = TRUE; SET_STATE ( KERN, KERN_GMM_REG_SUSPENDED ); kern_llgmm_suspend(LLGMM_CALL); } else { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ; } gmmrr_cs_page_res->susp_gprs = GMMRR_SUSP_GPRS; /* * kern_llgmm_unassign(); */ break; case KERN_GMM_RAU_INITIATED: case KERN_GMM_REG_NORMAL_SERVICE: if (GMM_MM_DEREG != GET_STATE(MM) && MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status) { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF; SET_STATE ( KERN, KERN_GMM_REG_SUSPENDED ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDED ); #endif kern_llgmm_suspend(LLGMM_CALL); } else { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ; } gmmrr_cs_page_res->susp_gprs = GMMRR_SUSP_GPRS; /* * kern_llgmm_unassign(); */ break; case KERN_GMM_NULL_IMSI: /* * in state KERN_GMM_NULL_IMSI MS is doing a GPRS detach * and GMM has informed MM to act as GSM only mobile but * before MM processes the message, GMM receives CS_PAGE_IND * GMM must reject the CS_PAGE as MM will take care of the * next CS_PAGE_IND after processing MMGMM_REG_REQ to act as * GSM only mobile. if GMM accepts the CS_PAGE, GRR will be * suspended and after coming out of dedicated mode MM will * not inform GMM about CS connection release and GRR will * not be resumed. This is to prevent such a race condition. */ TRACE_EVENT("CS Call Received To GMM In GMM_NULL_IMSI state"); gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ; gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS; break; case KERN_GMM_NULL_PLMN_SEARCH: if (GMM_MM_DEREG != GET_STATE(MM) && MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status) { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF; } else { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ; } gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS; break; default: if (GMM_MM_DEREG != GET_STATE(MM) && MMGMM_LIMITED_SERVICE!=gmm_data->kern.sig_cell_info.mm_status) { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF; } else { gmmrr_cs_page_res->response = GMMRR_CS_PAGE_REJ; } gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS; TRACE_ERROR( "GMMRR_CS_PAGE_IND unexpected" ); break; } break; case GMMRR_CLASS_A: case GMMRR_CLASS_CC: gmmrr_cs_page_res->response = GMMRR_CS_PAGE_CNF; gmmrr_cs_page_res->susp_gprs = GMMRR_NOT_SUSP_GPRS; /* GMM1903A */ break; default: TRACE_ERROR( "unknown MS class"); break; } /* START PATCH UBUOB ISSUE 8379 */ if (gmmrr_cs_page_res->response == GMMRR_CS_PAGE_CNF) { gmm_data->kern.gmmrr_resume_sent = FALSE; } /* END PATCH UBUOB ISSUES 8379 */ PSEND ( hCommGRR, gmmrr_cs_page_res ); } GMM_RETURN; } /* kern_gmmrr_cs_page_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_gmmrr_cr_ind +------------------------------------------------------------------------------ | Description : Handles the primitive GMMRR_CR_IND | | Parameters : *gmmrr_cr_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_gmmrr_cr_ind ( T_GMMRR_CR_IND *gmmrr_cr_ind ) { GMM_TRACE_FUNCTION( "kern_gmmrr_cr_ind" ); PFREE ( gmmrr_cr_ind ); if ( GMM_GRR_STATE_ON == gmm_data->kern.attach_cap.grr_state) /* * If GRR is suspended state should be kept. */ { gmm_data->kern.attach_cap.grr_state = GMM_GRR_STATE_CR; } switch( GET_STATE( KERN ) ) { case KERN_GMM_REG_INITIATED: case KERN_GMM_RAU_INITIATED: /* * store timer value to be able to restart timer after cell reselection */ gmm_data->kern.attach_cap.t3310_value=0; if (VSI_OK == vsi_t_status ( GMM_handle , kern_T3310, &(gmm_data->kern.attach_cap.t3310_value)) && gmm_data->kern.attach_cap.t3310_value>0) { vsi_t_stop ( GMM_handle , kern_T3310); } TRACE_1_INFO ("TIMER t3310 = %dmsec stopped - waiting for CELL_IND",gmm_data->kern.attach_cap.t3310_value); break; default: break; } GMM_RETURN; }/* kern_gmmrr_cr_ind */ /* +------------------------------------------------------------------------------ | Function : kern_cgrlc_status_ind (TCS 2.1) +------------------------------------------------------------------------------ | Description : Handles the primitive CGRLC_STATUS_IND (TCS 2.1) | | Parameters : *cgrlc_status_ind - Ptr to primitive payload (TCS 2.1) | +------------------------------------------------------------------------------ */ GLOBAL void kern_cgrlc_status_ind ( T_CGRLC_STATUS_IND *cgrlc_status_ind ) /* TCS 2.1 */ { GMM_TRACE_FUNCTION( "kern_cgrlc_status_ind" ); /* TCS 2.1 */ switch (cgrlc_status_ind->failure) /* TCS 2.1 */ { case CGRLC_ACCESS_2_NETWORK_NOT_ALLOWED: /* TCS 2.1 */ TRACE_EVENT ("Access to the network is not allowed"); break; case CGRLC_PACKET_ACCESS_FAILURE: /* TCS 2.1 */ TRACE_EVENT("Failure during packet access procedure, e.g. T3162 expired"); break; case CGRLC_RLC_MAC_ERROR: /* TCS 2.1 */ TRACE_EVENT("T3168 expires during contention resolution"); break; case CGRLC_TLLI_MISMATCH: /* TCS 2.1 */ TRACE_EVENT ("TLLI mismatch has occurred"); break; case CGRLC_TBF_ESTABLISHMENT_FAILURE: /* TCS 2.1 */ TRACE_EVENT ("T3164 expires or failure occurs due to any other reason"); break; case CGRLC_RESUMPTION_FAILURE: /* TCS 2.1 */ TRACE_EVENT ("resumption failure after dedicated mode was left"); break; case CGRLC_CONTENTION_RESOLUTION_FAILED: /* TCS 2.1 */ TRACE_EVENT ("Contantion Resolution has failed"); /* TCS 2.1 */ break; /* TCS 2.1 */ default: TRACE_ERROR ("unknown failure"); break; } PFREE (cgrlc_status_ind); /* TCS 2.1 */ switch( GET_STATE( KERN ) ) { case KERN_GMM_REG_INITIATED: case KERN_GMM_RAU_INITIATED: /************************************************************************ * MSC: 3.8 Attach * * MSC: 3.8.1 Normal Attach * MSC: 3.8.1.4 Abnormal cases * MSC: 3.8.1.4.2 b) Lower layer failure before the ATTACH ACCEPT or * ATTACH REJECT * message is received ************************************************************************ * *<R.GMM.AGABNORM.M.004>, <R.GMM.LOWERFAIL.M.001> */ kern_aac( /*llgmm_status_ind->error_cause*/ 0); break; case KERN_GMM_DEREG_INITIATED: /************************************************************************ * MSC: 3.9 GPRS detach procedure * * MCS: 3.9.3 Abnormal cases * MSC: 3.9.3.2 b) Lower layer failure ************************************************************************/ kern_local_detach ( GMMCS_INT_PROTOCOL_ERROR, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_DEREG); /* TCS 2.1 */ break; case KERN_GMM_REG_IMSI_DETACH_INITIATED: /* * <R.GMM.DMABNORM.M.021> */ /************************************************************************ * MSC: 3.9 GPRS detach procedure * * MCS: 3.9.3 Abnormal cases * MSC: 3.9.3.2 b) Lower layer failure ************************************************************************/ gmm_data->kern.detach_cap.detach_type = GMMREG_DT_IMSI; kern_local_detach( GMMCS_INT_PROTOCOL_ERROR, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_REG_NORMAL); /* TCS 2.1 */ break; case KERN_GMM_DEREG_RESUMING: case KERN_GMM_DEREG_SUSPENDED: case KERN_GMM_REG_RESUMING: case KERN_GMM_REG_SUSPENDED: TRACE_ERROR( "CGRLC_STATUS_IND unexpected" ); /* TCS 2.1 */ break; default: break; } GMM_RETURN; } /* kern_cgrlc_status_ind() */ /* TCS 2.1 */ /* +------------------------------------------------------------------------------ | Function : kern_llgmm_status_ind +------------------------------------------------------------------------------ | Description : Handles the primitive LLGMM_STATUS_IND | | Parameters : *llgmm_status_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_llgmm_status_ind ( T_LLGMM_STATUS_IND *llgmm_status_ind ) { GMM_TRACE_FUNCTION( "kern_llgmm_status_ind" ); PFREE (llgmm_status_ind); switch( GET_STATE( KERN ) ) { case KERN_GMM_REG_INITIATED: case KERN_GMM_RAU_INITIATED: /************************************************************************ * MSC: 3.8 Attach * * MSC: 3.8.1 Normal Attach * MSC: 3.8.1.4 Abnormal cases * MSC: 3.8.1.4.2 b) Lower layer failure before the ATTACH ACCEPT or * ATTACH REJECT * message is received ************************************************************************ * *<R.GMM.AGABNORM.M.004>, <R.GMM.LOWERFAIL.M.001> */ kern_aac( /*llgmm_status_ind->error_cause*/ GMMCS_NO_SERVICE); /* TCS 2.1 */ break; case KERN_GMM_DEREG_INITIATED: /************************************************************************ * MSC: 3.9 GPRS detach procedure * * MCS: 3.9.3 Abnormal cases * MSC: 3.9.3.2 b) Lower layer failure ************************************************************************/ kern_local_detach( GMMCS_INT_PROTOCOL_ERROR, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_DEREG); /* TCS 2.1 */ break; case KERN_GMM_REG_IMSI_DETACH_INITIATED: /* * <R.GMM.DMABNORM.M.021> */ /************************************************************************ * MSC: 3.9 GPRS detach procedure * * MCS: 3.9.3 Abnormal cases * MSC: 3.9.3.2 b) Lower layer failure ************************************************************************/ gmm_data->kern.detach_cap.detach_type = GMMREG_DT_IMSI; kern_local_detach( GMMCS_INT_PROTOCOL_ERROR, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_REG_NORMAL); /* TCS 2.1 */ break; default: TRACE_ERROR( "LLGMM_STATUS_IND unexpected" ); break; } GMM_RETURN; } /* kern_llgmm_status_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_llgmm_tlli_ind +------------------------------------------------------------------------------ | Description : Handles the primitive LLGMM_TLLI_IND | | Parameters : *llgmm_status_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_llgmm_tlli_ind ( T_LLGMM_TLLI_IND *llgmm_tlli_ind ) { GMM_TRACE_FUNCTION( "kern_llgmm_tlli_ind" ); TRACE_1_PARA ("TLLI: 0x%x", llgmm_tlli_ind->new_tlli); GMM_TRACE_GMM_DATA(GMM_DEBUG_PRINT_MASK_TLLI); switch( GET_STATE( KERN ) ) { default: case KERN_GMM_NULL_NO_IMSI: case KERN_GMM_NULL_IMSI: case KERN_GMM_NULL_PLMN_SEARCH: case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ: case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ: TRACE_ERROR("LLGMM_TLLI_IND unexpected"); break; case KERN_GMM_DEREG_INITIATED: case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: case KERN_GMM_DEREG_NO_CELL_AVAILABLE: case KERN_GMM_DEREG_LIMITED_SERVICE: case KERN_GMM_DEREG_NO_IMSI: case KERN_GMM_DEREG_PLMN_SEARCH: case KERN_GMM_DEREG_SUSPENDED: case KERN_GMM_REG_INITIATED: 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_ATTEMPTING_TO_UPDATE: case KERN_GMM_REG_SUSPENDED: case KERN_GMM_REG_NORMAL_SERVICE: case KERN_GMM_RAU_INITIATED: case KERN_GMM_RAU_WAIT_FOR_NPDU_LIST: case KERN_GMM_REG_IMSI_DETACH_INITIATED: case KERN_GMM_REG_RESUMING: case KERN_GMM_DEREG_SUSPENDING: case KERN_GMM_DEREG_RESUMING: case KERN_GMM_REG_SUSPENDING: case KERN_GMM_REG_TEST_MODE: case KERN_GMM_REG_TEST_MODE_NO_IMSI: if ( llgmm_tlli_ind->new_tlli != gmm_data->tlli.current) { TRACE_ERROR("TLLI value not expected"); } TRACE_0_OUT_PARA("Unassign Old PTMSI"); gmm_data->tlli.old = GMMRR_TLLI_INVALID; gmm_data->ptmsi.old = GMMRR_TMSI_INVALID; GMM_TRACE_GMM_DATA(GMM_DEBUG_PRINT_MASK_TLLI | GMM_DEBUG_PRINT_MASK_PTMSI); /* * LLC should know about unassigning itself */ kern_gmmrr_assign(); break; } PFREE (llgmm_tlli_ind); GMM_RETURN; } /* kern_llgmm_tlli_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_sim_gmm_insert_ind +------------------------------------------------------------------------------ | Description : Handles the primitive SIM_GMM_INSERT_IND | | MSC: 3.2 SIM | | Parameters : *sim_gmm_insert_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_sim_gmm_insert_ind ( T_SIM_GMM_INSERT_IND *sim_gmm_insert_ind ) { GMM_TRACE_FUNCTION( "kern_sim_gmm_insert_ind" ); /* * Set IMSI */ kern_read_imsi ( sim_gmm_insert_ind ) ; GMM_TRACE_GMM_DATA(GMM_DEBUG_PRINT_MASK_IMSI); kern_read_loc_info (sim_gmm_insert_ind); GMM_TRACE_GMM_DATA(GMM_DEBUG_PRINT_MASK_CID); GMM_TRACE_GMM_DATA(GMM_DEBUG_PRINT_MASK_KERN_ATTACH); gmm_data->acc_contr_class = sim_gmm_insert_ind->acc_ctrl.acc[0] * 256 + sim_gmm_insert_ind->acc_ctrl.acc[1]; gmm_data->kern.sim_op_mode = sim_gmm_insert_ind->op_mode; kern_read_kc_cksn (sim_gmm_insert_ind); PFREE ( sim_gmm_insert_ind ); switch( GET_STATE( KERN ) ) { case KERN_GMM_NULL_NO_IMSI: case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ: case KERN_GMM_DEREG_NO_IMSI: /* * MSC: 3.2 SIM * * MSC: 3.2.1 SIM is inserted and valid */ /* * SIM is considered as invalid until SIM removed or switching off */ gmm_data->sim_gprs_invalid = FALSE; /* * reset the attach attampt counter and the rau attempt counter * <R.GMM.ATTACH.M.007> */ gmm_data->kern.aac = 0; switch( GET_STATE( KERN ) ) { case KERN_GMM_NULL_NO_IMSI: /* * <R.GMM.DOTHCASE.M.001> * SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH ); * * state GMM-DEREGISTERED.IMSI discribes the state GMM-NULL.IMSI-VALID */ SET_STATE ( KERN, KERN_GMM_NULL_IMSI ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI ); #endif break; case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ: SET_STATE (KERN, KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ); #endif break; case KERN_GMM_DEREG_NO_IMSI: /* * GMM enters state NULL_IMSI beause GMM is waiting for a new attach * prim from GACI (COPS=0) */ SET_STATE ( KERN, KERN_GMM_NULL_IMSI ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI ); #endif break; default: TRACE_ERROR( "State unexpected" ); break; } break; default: TRACE_ERROR( "SIM_GMM_INSERT_IND unexpected" ); break; } GMM_RETURN; } /* kern_sim_gmm_insert_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_sim_remove_ind +------------------------------------------------------------------------------ | Description : Handles the primitive SIM_REMOVE_IND | | Parameters : *sim_remove_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_sim_remove_ind ( T_SIM_REMOVE_IND *sim_remove_ind ) { GMM_TRACE_FUNCTION( "kern_sim_remove_ind" ); PFREE ( sim_remove_ind ); gmm_data->sim_gprs_invalid = TRUE; gmm_data->kern.detach_cap.detach_type = GMMREG_DT_SIM_REMOVED; /* * multiple outstanding SIM_AUTHENTICATION_REQ messages reset the * counter whenever SIM is removed */ gmm_data->kern.auth_cap.last_auth_req_id = NOT_PRESENT_8BIT; switch( GET_STATE( KERN ) ) { /* * MSC: 3.2 SIM * * MSC: 3.2.2. No SIM present or SIM not valid * MSC: 3.2.2.2 State GMM-REG */ /* * MSC: 3.2.2.2.1 Network not reachable * state GMM_REG */ case KERN_GMM_DEREG_RESUMING: case KERN_GMM_DEREG_SUSPENDED: case KERN_GMM_REG_RESUMING: case KERN_GMM_REG_SUSPENDED: if (GMM_GRR_STATE_SUSPENDED==gmm_data->kern.attach_cap.grr_state) /* * wait for MMGMM_CM_RELEASE_IND */ { break; } /* NO break;*/ case KERN_GMM_REG_LIMITED_SERVICE: case KERN_GMM_REG_NO_CELL_AVAILABLE: { kern_local_detach (GMMCS_SIM_REMOVED, FALSE,GMM_LOCAL_DETACH_PROC_SIM_REMOVED); /* TCS 2.1 */ break; } case KERN_GMM_REG_TEST_MODE: { PALLOC (cgrlc_test_end_req, CGRLC_TEST_END_REQ); /* TCS 2.1 */ SET_STATE (KERN, KERN_GMM_REG_TEST_MODE_NO_IMSI); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_TEST_MODE_NO_IMSI); #endif PSEND (hCommGRLC, cgrlc_test_end_req); /* TCS 2.1 */ } break; /* * MSC: 3.2.2.2.2 Network reachable * state GMM_REG.NORMAL_SERVICE */ case KERN_GMM_RAU_INITIATED: case KERN_GMM_RAU_WAIT_FOR_NPDU_LIST: case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM: case KERN_GMM_REG_ATTEMPTING_TO_UPDATE: case KERN_GMM_REG_NORMAL_SERVICE: /* * <R.GMM.DSUBFANO.M.003> */ kern_detach (); break; /* * MSC: 3.2 SIM * * MSC: 3.2.2. No SIM present or SIM not valid * MSC: 3.2.2.1 State GMM-DEREG */ /* * state GMM_DEREG */ case KERN_GMM_DEREG_PLMN_SEARCH: case KERN_GMM_DEREG_NO_CELL_AVAILABLE: case KERN_GMM_DEREG_LIMITED_SERVICE: case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: case KERN_GMM_REG_INITIATED: case KERN_GMM_DEREG_INITIATED: kern_mm_imsi_detach_ind ( GMMCS_SIM_REMOVED, MMGMM_PERFORM_DETACH, gmm_data->kern.detach_cap.detach_type); /* TCS 2.1 */ /* * <R.GMM.ODNOIMSI.M.001> */ SET_STATE ( KERN, KERN_GMM_DEREG_NO_IMSI ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI ); #endif break; case KERN_GMM_NULL_IMSI: kern_mm_imsi_detach_ind ( GMMCS_SIM_REMOVED, MMGMM_PERFORM_DETACH, gmm_data->kern.detach_cap.detach_type ); /* TCS 2.1 */ /* * <R.GMM.ODNOIMSI.M.001> */ SET_STATE ( KERN, KERN_GMM_NULL_NO_IMSI ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI ); #endif break; default: kern_mm_imsi_detach_ind ( GMMCS_SIM_REMOVED, MMGMM_PERFORM_DETACH, gmm_data->kern.detach_cap.detach_type); /* TCS 2.1 */ TRACE_ERROR( "SIM_REMOVE_IND unexpected" ); break; } GMM_RETURN; } /* kern_sim_remove_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_gmmrr_suspend_cnf +------------------------------------------------------------------------------ | Description : Handles the primitive GMMRR_SUSPEND_CNF | | GRR confirms that GRR is successful suspended and RR is | activated. | | Parameters : *gmmrr_suspend_cnf - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_gmmrr_suspend_cnf ( T_GMMRR_SUSPEND_CNF *gmmrr_suspend_cnf ) { GMM_TRACE_FUNCTION( "kern_gmmrr_suspend_cnf" ); PFREE(gmmrr_suspend_cnf); gmm_data->kern.attach_cap.grr_state = GMM_GRR_STATE_SUSPENDED; TRACE_1_PARA ("susp_type: %x", gmm_data->kern.suspension_type); switch( GET_STATE( KERN ) ) { case KERN_GMM_DEREG_SUSPENDING: SET_STATE (KERN, KERN_GMM_DEREG_SUSPENDED); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDED); #endif if(gmm_data->kern.detach_cap.detach_type EQ GMMREG_DT_GPRS) { if ( GET_STATE(MM) != GMM_MM_REG_NORMAL_SERVICE) /* * The state of MM is forwarded to MMI */ { gmm_data->kern.detach_cap.detach_type = GMMREG_DT_COMB; } if ( kern_lau_needed()) { /* * see also kern_enter_der () */ kern_gmmreg_detach (gmm_data->kern.detach_cap.detach_type, GMMCS_INT_NOT_PRESENT, GMMREG_SEARCH_RUNNING, GMMCS_INT_NOT_PRESENT); } else { kern_gmmreg_detach (gmm_data->kern.detach_cap.detach_type, GMMCS_INT_NOT_PRESENT, GMMREG_SEARCH_NOT_RUNNING,GMMCS_INT_NOT_PRESENT); } } kern_call_undone_mm_proc_der(); break; case KERN_GMM_REG_SUSPENDING: SET_STATE (KERN, KERN_GMM_REG_SUSPENDED); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDED); #endif kern_call_undone_mm_proc_reg(); break; case KERN_GMM_NULL_NO_IMSI: kern_local_detach ( GMMCS_POWER_OFF, /* TCS 2.1 */ FALSE, GMM_LOCAL_DETACH_PROC_NOTHING); break; default: TRACE_ERROR( "GMMRR_SUSPNED_CNF unexpected" ); break; } GMM_RETURN; } /* kern_gmmrr_suspend_cnf() */ /* +------------------------------------------------------------------------------ | Function : kern_cgrlc_test_mode_cnf (TCS 2.1) +------------------------------------------------------------------------------ | Description : Handles the primitive GMMRR_SUSPEND_CNF | | GRR confirms that the test mode is finished | | Parameters : *cgrlc_test_mode_cnf - Ptr to primitive payload (TCS 2.1) | +------------------------------------------------------------------------------ */ GLOBAL void kern_cgrlc_test_mode_cnf ( T_CGRLC_TEST_MODE_CNF *cgrlc_test_mode_cnf ) /* TCS 2.1 */ { GMM_TRACE_FUNCTION( "kern_cgrlc_test_mode_cnf" ); /* TCS 2.1 */ PFREE (cgrlc_test_mode_cnf); /* TCS 2.1 */ switch( GET_STATE( KERN ) ) { case KERN_GMM_REG_TEST_MODE: kern_enter_reg_normal(); break; case KERN_GMM_REG_TEST_MODE_NO_IMSI: /* * <R.GMM.DSUBFANO.M.003> */ gmm_data->kern.detach_cap.detach_type = GMMREG_DT_SIM_REMOVED; kern_detach (); break; default: TRACE_ERROR( "CGRLC_TEST_MODE_CNF unexpected" ); /* TCS 2.1 */ break; } GMM_RETURN; } /* kern_cgrlc_test_mode_cnf() */ /* TCS 2.1 */ /* +------------------------------------------------------------------------------ | Function : kern_mmgmm_lup_needed_ind +------------------------------------------------------------------------------ | Description : Handles the primitive MMGMM_LUP_NEEDED_IND | | MSC: 3.20.8 MMGMM LUP NEEDED IND | | Parameters : *mmgmm_lup_needed_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_mmgmm_lup_needed_ind ( T_MMGMM_LUP_NEEDED_IND *mmgmm_lup_needed_ind ) { GMM_TRACE_FUNCTION( "kern_mmgmm_lup_needed_ind" ); #ifndef NTRACE switch (mmgmm_lup_needed_ind->reason) /* TCS 2.1 */ { case MMGMM_T3212: TRACE_EVENT("T3212 has expired"); break; case MMGMM_T_ACCEPT: TRACE_EVENT("T_ACCEPT has expired"); break; case MMGMM_IMSI_IN_VLR: TRACE_EVENT("IMSI unknown in VLR received"); break; case MMGMM_RXLEV_JUMP: TRACE_EVENT("RR indicated an increased RX level"); break; case MMGMM_REG_TIMER: TRACE_EVENT("Registration timer in MM expired"); break; default: TRACE_ERROR("GPRS indicator is out of range"); break; } #endif switch (GET_STATE( KERN )) { case KERN_GMM_DEREG_RESUMING: case KERN_GMM_DEREG_SUSPENDED: 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_DEREG_INITIATED: 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_SUSPENDING: case KERN_GMM_REG_NO_CELL_AVAILABLE: break; default: if( GMMRR_NET_MODE_I==gmm_data->kern.sig_cell_info.net_mode && MMGMM_T3212==mmgmm_lup_needed_ind->reason) /* TCS 2.1 */ /* * <R.GMM.MMGMMONE.M.002>, <R.GMM.MMGMMONE.M.003> */ { PFREE (mmgmm_lup_needed_ind); GMM_RETURN; } break; } 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: /* * After deregistration MM will receive mmgmm_reg_req * automatically */ break; case KERN_GMM_DEREG_NO_IMSI: /* PLU also if #7 */ /*NO break;*/ case KERN_GMM_DEREG_PLMN_SEARCH: case KERN_GMM_DEREG_NO_CELL_AVAILABLE: case KERN_GMM_DEREG_LIMITED_SERVICE: case KERN_GMM_REG_INITIATED: SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDING ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING ); #endif kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU); break; case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = TRUE; SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDING ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING ); #endif kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU); break; case KERN_GMM_DEREG_INITIATED: case KERN_GMM_DEREG_RESUMING: case KERN_GMM_DEREG_SUSPENDED: case KERN_GMM_REG_SUSPENDED: case KERN_GMM_REG_RESUMING: case KERN_GMM_RAU_INITIATED: case KERN_GMM_RAU_WAIT_FOR_NPDU_LIST: case KERN_GMM_REG_IMSI_DETACH_INITIATED: SET_STATE(MM, GMM_MM_REG_UPDATE_NEEDED); break; case KERN_GMM_REG_SUSPENDING: case KERN_GMM_DEREG_SUSPENDING: gmm_data->kern.suspension_type |= GMM_SUSP_LAU; break; case KERN_GMM_REG_ATTEMPTING_TO_UPDATE: gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau=TRUE; SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING ); #endif kern_llgmm_suspend(LLGMM_CALL); kern_gmmrr_suspend (GMMRR_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU); break; case KERN_GMM_REG_LIMITED_SERVICE: case KERN_GMM_REG_NO_CELL_AVAILABLE: if(gmm_data->kern.gmmrr_resume_sent) /* * GMM is waiting for GMMRR_CELL_IND. So I rememmber to attach MM with * seting mm_imsi_attached to update_needed */ { SET_STATE(MM,GMM_MM_REG_UPDATE_NEEDED); } else { SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING ); #endif kern_llgmm_suspend(LLGMM_CALL); kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU); } break; case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM: case KERN_GMM_REG_NORMAL_SERVICE: if( GMMRR_NET_MODE_I==gmm_data->kern.sig_cell_info.net_mode) { kern_rau(); } else { SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING ); #endif kern_llgmm_suspend(LLGMM_CALL); kern_gmmrr_suspend (GMMRR_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU); } break; case KERN_GMM_REG_TEST_MODE_NO_IMSI: case KERN_GMM_REG_TEST_MODE: break; default: TRACE_ERROR ("Unexpexcted state"); break; } PFREE (mmgmm_lup_needed_ind); GMM_RETURN; } /* kern_mmgmm_lup_needed_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_mmgmm_lup_accept_ind +------------------------------------------------------------------------------ | Description : Handles the primitive MMGMM_LUP_ACCEPT_IND | | MSC: 3.20.3 IMSI attach/detach | | Parameters : *mmgmm_lup_accept_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_mmgmm_lup_accept_ind ( T_MMGMM_LUP_ACCEPT_IND *mmgmm_lup_accept_ind ) { GMM_TRACE_FUNCTION( "kern_mmgmm_lup_accept_ind" ); switch( GET_STATE( KERN ) ) { case KERN_GMM_NULL_PLMN_SEARCH: case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ: case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ: case KERN_GMM_NULL_NO_IMSI: case KERN_GMM_NULL_IMSI: case KERN_GMM_DEREG_NO_IMSI: case KERN_GMM_DEREG_LIMITED_SERVICE: case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: case KERN_GMM_DEREG_NO_CELL_AVAILABLE: case KERN_GMM_DEREG_PLMN_SEARCH: case KERN_GMM_REG_INITIATED: case KERN_GMM_DEREG_RESUMING: case KERN_GMM_DEREG_SUSPENDED: case KERN_GMM_DEREG_SUSPENDING: if ( GMMRR_NET_MODE_III==gmm_data->kern.sig_cell_info.net_mode && GMMREG_CLASS_BC== gmm_data->kern.attach_cap.mobile_class ) { kern_mmgmmreg_attach_cnf (GMMREG_AT_IMSI, SEARCH_NOT_RUNNING, (T_MMGMM_REG_CNF*)mmgmm_lup_accept_ind); } else { kern_mmgmmreg_attach_cnf (GMMREG_AT_IMSI, SEARCH_RUNNING, (T_MMGMM_REG_CNF*)mmgmm_lup_accept_ind); } break; case KERN_GMM_REG_NORMAL_SERVICE: 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_DEREG_INITIATED: case KERN_GMM_RAU_INITIATED: case KERN_GMM_REG_RESUMING: case KERN_GMM_REG_SUSPENDED: kern_mmgmmreg_attach_cnf (GMMREG_AT_COMB, SEARCH_RUNNING, (T_MMGMM_REG_CNF*)mmgmm_lup_accept_ind); break; default: TRACE_ERROR ("Unexpexcted state"); break; } PFREE ( mmgmm_lup_accept_ind ); GMM_RETURN; } /* kern_mmgmm_lup_accept_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_mmgmm_lup_accept_ind +------------------------------------------------------------------------------ | Description : Handles the primitive MMGMM_INFO_IND | | MSC: 3.20.6 MM Information | | Parameters : *mmgmm_info_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_mmgmm_info_ind ( T_MMGMM_INFO_IND *mmgmm_info_ind ) { GMM_TRACE_FUNCTION( "kern_mmgmm_info_ind" ); { PPASS (mmgmm_info_ind, gmmreg_info_ind, GMMREG_INFO_IND); PSEND ( hCommMMI, gmmreg_info_ind ); } GMM_RETURN; } /* kern_mmgmm_info_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_sim_authentication_cnf +------------------------------------------------------------------------------ | Description : The function kern_sim_authentication_cnf | | Parameters : *sim_authentication_cnf - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_sim_authentication_cnf ( T_SIM_AUTHENTICATION_CNF * sim_authentication_cnf ) { GMM_TRACE_FUNCTION( "kern_sim_authentication_cnf" ); switch( GET_STATE( KERN ) ) { case KERN_GMM_REG_NORMAL_SERVICE: 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_INITIATED: case KERN_GMM_DEREG_INITIATED: case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: case KERN_GMM_RAU_INITIATED: case KERN_GMM_REG_IMSI_DETACH_INITIATED: /* * PATCH ubuob 19.7.02: multiple outstanding AUTHENTICATION REQ messages * reduce the count of outstanding requests */ /* * only use this SIM answer if there are no other outstanding SIM_AUTHENTICATION_REQ messages! */ if (gmm_data->kern.auth_cap.last_auth_req_id == sim_authentication_cnf->req_id) if (gmm_data->kern.auth_cap.last_auth_req_id == sim_authentication_cnf->req_id) { MCAST (authentication_and_ciphering_response, AUTHENTICATION_AND_CIPHERING_RESPONSE); authentication_and_ciphering_response->a_c_reference_number .a_c_reference_number_value = gmm_data->kern.auth_cap.a_c_reference_number; authentication_and_ciphering_response ->v_authentication_parameter_sres = TRUE; authentication_and_ciphering_response ->authentication_parameter_sres.sres_value.l_sres_value = MAX_SRES*8; authentication_and_ciphering_response ->authentication_parameter_sres.sres_value.o_sres_value = 0; memcpy (authentication_and_ciphering_response-> authentication_parameter_sres.sres_value.b_sres_value, sim_authentication_cnf->sres, MAX_SRES); memcpy ( gmm_data->kern.auth_cap.kc, sim_authentication_cnf->kc, MAX_KC ) ; #ifdef GMM_TCS4 gmm_data->kern.auth_cap.last_auth_req_id = NOT_PRESENT_8BIT; #endif PFREE (sim_authentication_cnf); /* * <R.GMM.AUTH_RES.M.006> */ { PALLOC ( llgmm_assign_req, LLGMM_ASSIGN_REQ ); llgmm_assign_req->old_tlli = LLGMM_TLLI_INVALID; llgmm_assign_req->new_tlli = gmm_data->tlli.current; 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 = gmm_data->kern.auth_cap.ciphering_algorithm; PSEND ( hCommLLC, llgmm_assign_req ); } if (IMEISV_REQUESTED == gmm_data->kern.auth_cap.imeisv_requested) { authentication_and_ciphering_response->v_gmobile_identity = TRUE; kern_get_imeisv ( &authentication_and_ciphering_response->gmobile_identity); } else { authentication_and_ciphering_response->v_gmobile_identity = FALSE; } sig_kern_tx_data_req (CURRENT_TLLI,AUTHENTICATION_AND_CIPHERING_RESPONSE); } else { PFREE (sim_authentication_cnf); /* * mutliple authentication request problem occurred!!!! * ignore this SIM answer because another request has already been sent to * the SIM again and this overwrote the A&C reference number */ TRACE_0_INFO ("error: Authentication received twice, SIM ignored"); } /* end patch ubuob */ break; default: PFREE (sim_authentication_cnf); TRACE_1_INFO ("state: %x", GET_STATE( KERN )); TRACE_ERROR("A&C RES unexpected"); break; } GMM_RETURN; } /* kern_sim_authentication_cnf() */ /* +------------------------------------------------------------------------------ | Function : kern_mmgmm_nreg_cnf +------------------------------------------------------------------------------ | Description : Handles the primitive MMGMM_NREG_CNF | | MSC: 3.20.3 IMSI attach/detach | | Parameters : *mmgmm_nreg_cnf - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_mmgmm_nreg_cnf ( T_MMGMM_NREG_CNF *mmgmm_nreg_cnf ) { UBYTE detach_type; GMM_TRACE_FUNCTION( "kern_mmgmm_nreg_cnf" ); if (gmm_data->kern.attach_cap.mobile_class_changed && GMM_GRR_STATE_ON == gmm_data->kern.attach_cap.grr_state) { gmm_data->kern.attach_cap.mobile_class_changed=FALSE; kern_gmmrr_enable(); } switch (mmgmm_nreg_cnf->detach_cause) /* TCS 2.1 */ { case CS_SIM_REM: detach_type = GMMREG_DT_SIM_REMOVED; TRACE_EVENT ("SIM is removed"); break; case CS_POW_OFF: detach_type = GMMREG_DT_POWER_OFF; TRACE_EVENT ("Power is switched off"); break; case CS_SOFT_OFF: detach_type = GMMREG_DT_SOFT_OFF; TRACE_EVENT ("Power is soft switched off"); break; case CS_DISABLE: detach_type = GMMREG_DT_IMSI; TRACE_EVENT ("GSM switched off"); break; default: detach_type = GMMREG_DT_POWER_OFF; TRACE_EVENT ("unknown detach type in MMGMM_NREG_CNF"); break; } SET_STATE( MM, GMM_MM_DEREG ); sig_kern_sync_set_mm_state(MMGMM_CELL_SELECTED); if (gmm_data->sim_gprs_invalid && gmm_data->kern.cell_id.lac == GMMREG_LA_INVALID && mmgmm_nreg_cnf->detach_cause == CS_SIM_REM) { switch ( GET_STATE (KERN) ) { case KERN_GMM_DEREG_PLMN_SEARCH: case KERN_GMM_DEREG_SUSPENDED: SET_STATE(KERN,KERN_GMM_DEREG_NO_IMSI); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI); #endif break; case KERN_GMM_REG_IMSI_DETACH_INITIATED: kern_enter_reg_normal(); break; case KERN_GMM_DEREG_NO_IMSI: SET_STATE(KERN,KERN_GMM_NULL_NO_IMSI); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI); #endif break; default: break; } PFREE ( mmgmm_nreg_cnf ); GMM_RETURN; } switch ( GET_STATE (KERN) ) { case KERN_GMM_DEREG_PLMN_SEARCH: switch(mmgmm_nreg_cnf->detach_cause) /* TCS 2.1 */ { case CS_SOFT_OFF: case CS_POW_OFF: kern_gmmreg_detach (GMMREG_DT_POWER_OFF, GMMCS_POWER_OFF, /* TCS 2.1 */ SEARCH_NOT_RUNNING, GMMCS_POWER_OFF); break; case CS_SIM_REM: SET_STATE(KERN,KERN_GMM_DEREG_NO_IMSI); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI); #endif kern_gmmreg_detach (GMMREG_DT_SIM_REMOVED, GMMCS_SIM_REMOVED, /* TCS 2.1 */ SEARCH_NOT_RUNNING, GMMCS_SIM_REMOVED); break; default: kern_gmmreg_detach (GMMREG_DT_COMB, /* START UBUOB PATCH ISSUE 8381 */ GMMCS_NET_CAUSE_NOT_PRESENT, /* TCS 2.1 */ /* END UBUOB PATCH ISSUE 8381 */ SEARCH_RUNNING, GMMCS_NET_CAUSE_NOT_PRESENT); kern_mm_activate_rr(); break; } break; case KERN_GMM_NULL_NO_IMSI: case KERN_GMM_NULL_IMSI: /* * POWER OFF */ if( CS_DISABLE==mmgmm_nreg_cnf->detach_cause) /* TCS 2.1 */ { detach_type=GMMREG_DT_IMSI; } kern_gmmreg_detach (detach_type, gmm_data->kern.detach_cap.error_cause, /* TCS 2.1 */ SEARCH_NOT_RUNNING, gmm_data->kern.detach_cap.error_cause); break; case KERN_GMM_DEREG_SUSPENDED: switch(mmgmm_nreg_cnf->detach_cause) /* TCS 2.1 */ { case CS_SOFT_OFF: kern_gmmreg_detach (GMMREG_DT_SOFT_OFF, GMMCS_POWER_OFF, /* TCS 2.1 */ SEARCH_NOT_RUNNING, GMMCS_POWER_OFF); break; case CS_POW_OFF: kern_gmmreg_detach (GMMREG_DT_POWER_OFF, GMMCS_POWER_OFF, /* TCS 2.1 */ SEARCH_NOT_RUNNING, GMMCS_POWER_OFF); break; case CS_SIM_REM: SET_STATE(KERN,KERN_GMM_DEREG_NO_IMSI); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_NO_IMSI); #endif kern_gmmreg_detach (GMMREG_DT_SIM_REMOVED, GMMCS_SIM_REMOVED, /* TCS 2.1 */ SEARCH_NOT_RUNNING, GMMCS_SIM_REMOVED); break; default: /* ACI can not handle SEARCH RUNNING to show GSM detached */ if (GMMRR_NET_MODE_III==gmm_data->kern.sig_cell_info.net_mode && GMMREG_CLASS_BG== gmm_data->kern.attach_cap.mobile_class ) { kern_gmmreg_detach (GMMREG_DT_COMB, GMMCS_NET_CAUSE_NOT_PRESENT, /* TCS 2.1 */ SEARCH_RUNNING, GMMCS_NET_CAUSE_NOT_PRESENT); } else { kern_gmmreg_detach (GMMREG_DT_COMB, GMMCS_NET_CAUSE_NOT_PRESENT, /* TCS 2.1 */ SEARCH_NOT_RUNNING, GMMCS_NET_CAUSE_NOT_PRESENT); } break; } kern_call_undone_mm_proc_der(); break; case KERN_GMM_REG_SUSPENDED: switch(mmgmm_nreg_cnf->detach_cause) /* TCS 2.1 */ { case CS_SOFT_OFF: kern_gmmreg_detach (GMMREG_DT_SOFT_OFF, GMMCS_POWER_OFF, /* TCS 2.1 */ SEARCH_NOT_RUNNING, GMMCS_POWER_OFF); break; case CS_POW_OFF: kern_gmmreg_detach (GMMREG_DT_POWER_OFF, GMMCS_POWER_OFF, /* TCS 2.1 */ SEARCH_NOT_RUNNING, GMMCS_POWER_OFF); break; case CS_DISABLE: if (GMMREG_DT_IMSI == gmm_data->kern.detach_cap.detach_type) { kern_gmmreg_detach (GMMREG_DT_IMSI, GMMCS_NET_CAUSE_NOT_PRESENT, /* TCS 2.1 */ SEARCH_NOT_RUNNING, GMMCS_NET_CAUSE_NOT_PRESENT); break; } /* * else: wait for gprs detach to be finished * FALLTHROUGH */ case CS_SIM_REM: if (GMMRR_NET_MODE_III!=gmm_data->kern.sig_cell_info.net_mode) { /* * Wait until GPRS is deregistered */ break; } /* * else NO break; * we are ms class BG and have switched off GSM */ default: kern_gmmreg_detach (GMMREG_DT_IMSI, GMMCS_NET_CAUSE_NOT_PRESENT, /* TCS 2.1 */ SEARCH_NOT_RUNNING, GMMCS_NET_CAUSE_NOT_PRESENT); break; } kern_call_undone_mm_proc_reg(); break; case KERN_GMM_REG_IMSI_DETACH_INITIATED: kern_enter_reg_normal(); if(GMMRR_NET_MODE_I!=gmm_data->kern.sig_cell_info.net_mode) /* * In NMO I gmmreg_detach_cnf was sent before requesting * mmgmm_net_req */ { kern_gmmreg_detach (detach_type, GMMCS_NET_CAUSE_NOT_PRESENT, /* TCS 2.1 */ GMMREG_SEARCH_NOT_RUNNING, GMMCS_NET_CAUSE_NOT_PRESENT); } break; case KERN_GMM_REG_NORMAL_SERVICE: break; case KERN_GMM_DEREG_NO_IMSI: SET_STATE(KERN,KERN_GMM_NULL_NO_IMSI); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI); #endif kern_gmmreg_detach (detach_type, GMMCS_INT_NOT_PRESENT, /* TCS 2.1 */ GMMREG_SEARCH_NOT_RUNNING, GMMCS_INT_NOT_PRESENT); break; default: TRACE_ERROR( "MMGMM_NREG_CNF unexpected" ); break; } PFREE ( mmgmm_nreg_cnf ); #ifdef TRACE_FUNC #ifdef IDENTATION if (gmm_data->deep<=0) { /* * after power off deep is set to 0 in kern_init so we need here normal * return */ return; } else { GMM_RETURN; } #endif #endif } /* kern_mmgmm_nreg_cnf() */ /* +------------------------------------------------------------------------------ | Function : kern_mmgmm_auth_rej_ind +------------------------------------------------------------------------------ | Description : Handles the primitive MMGMM_AUTH_REJ_IND | | Parameters : *mmgmm_auth_rej_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_mmgmm_auth_rej_ind ( T_MMGMM_AUTH_REJ_IND *mmgmm_auth_rej_ind ) { GMM_TRACE_FUNCTION( "kern_mmgmm_auth_rej_ind" ); PFREE (mmgmm_auth_rej_ind); gmm_data->sim_gprs_invalid = TRUE; gmm_data->kern.detach_cap.detach_type = GMMREG_DT_SIM_REMOVED; kern_sim_del_locigprs (); gmm_data->gu = GU3_ROAMING_NOT_ALLOWED; kern_sim_gmm_update (); GMM_RETURN; } /* kern_mmgmm_auth_rej_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_mmgmm_t3212_val_ind | | Description : Handles the primitive MMGMM_T3212_VAL _IND | | Parameters : *mmgmm_t3212_val_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_mmgmm_t3212_val_ind ( T_MMGMM_T3212_VAL_IND *mmgmm_t3212_val_ind ) { GMM_TRACE_FUNCTION( "kern_mmgmm_t3212_val_ind" ); #ifdef REL99 switch (gmm_data->kern.sig_cell_info.sgsnr_flag)/*!gmm_data->release99 =>old code*/ /* TCS 4.0 */ { default: case PS_SGSN_UNKNOWN: case PS_SGSN_98_OLDER: #endif /* * see GSM04.08 ch. 11.2.2 NOTE 4 */ gmm_data->kern.t3302_val = mmgmm_t3212_val_ind->t3212_val; /* * Boeser Hack wegen Faulheit, signal should be taken */ gmm_data->sync.mm_cell_info.t3212_val = gmm_data->kern.t3302_val; #ifdef REL99 break; case PS_SGSN_99_ONWARDS: break; } #endif PFREE ( mmgmm_t3212_val_ind ); GMM_RETURN; } /* kern_mmgmm_t3212_val_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_mmgmm_cm_establish_ind +------------------------------------------------------------------------------ | Description : Handles the primitive MMGMM_CM_ESTABLISH_IND | | Parameters : *mmgmm_cm_establish_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_mmgmm_cm_establish_ind ( T_MMGMM_CM_ESTABLISH_IND *mmgmm_cm_establish_ind ) { GMM_TRACE_FUNCTION( "kern_mmgmm_cm_establish_ind" ); PFREE ( mmgmm_cm_establish_ind ); if (gmm_data->kern.gmmrr_resume_sent) { kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT); GMM_RETURN; } switch( GET_STATE( KERN ) ) { case KERN_GMM_DEREG_RESUMING: case KERN_GMM_REG_RESUMING: TRACE_ERROR ("prim should be saved"); break; case KERN_GMM_DEREG_SUSPENDING: case KERN_GMM_REG_SUSPENDING: gmm_data->kern.suspension_type |= GMM_SUSP_CALL; break; case KERN_GMM_DEREG_SUSPENDED: case KERN_GMM_NULL_IMSI: kern_mm_cm_establish_res (MMGMM_ESTABLISH_OK); break; case KERN_GMM_DEREG_LIMITED_SERVICE: case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: case KERN_GMM_DEREG_NO_CELL_AVAILABLE: case KERN_GMM_DEREG_PLMN_SEARCH: case KERN_GMM_DEREG_INITIATED: case KERN_GMM_REG_INITIATED: switch (gmm_data->kern.attach_cap.mobile_class) { case GMMREG_CLASS_A: if (GMMRR_NET_MODE_III == gmm_data->kern.sig_cell_info.net_mode) { kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT); } else { kern_mm_cm_establish_res (MMGMM_ESTABLISH_OK); } break; case GMMREG_CLASS_CG: kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT); break; case GMMREG_CLASS_BG: if (GMMRR_NET_MODE_III == gmm_data->kern.sig_cell_info.net_mode) { kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT); break; } /* NO break */ case GMMREG_CLASS_B: case GMMREG_CLASS_BC: /* START PATCH UBUOB ISSUE 8278 */ switch (GET_STATE (KERN)) { case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = TRUE; break; default: break; } /* END PATCH UBUOB ISSUE 8278 */ if (GMM_MM_DEREG != GET_STATE(MM)) { SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDING ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING ); #endif /* START PATCH UBUOB ISSUE 8781 */ /* kern_gmmreg_suspend (GMMREG_CS_CALL); */ /* END PATCH UBUOB ISSUE 8781 */ kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_CALL); vsi_t_stop(GMM_handle, kern_T3321); } else { SET_STATE( KERN, KERN_GMM_DEREG_SUSPENDING); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING); #endif /* * kern_llgmm_unassign(); */ kern_llgmm_suspend(LLGMM_CALL); kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_CALL); } break; default: TRACE_ERROR( "unknown MS class"); break; } 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_RAU_INITIATED: switch (gmm_data->kern.attach_cap.mobile_class) { case GMMREG_CLASS_A: kern_mm_cm_establish_res (MMGMM_ESTABLISH_OK); break; case GMMREG_CLASS_CG: kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT); break; case GMMREG_CLASS_BG: if (GMMRR_NET_MODE_III == gmm_data->kern.sig_cell_info.net_mode) { kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT); break; } /* NO break; */ case GMMREG_CLASS_B: case GMMREG_CLASS_BC: /* START PATCH UBUOB ISSUE 8278 */ switch (GET_STATE (KERN)) { case KERN_GMM_REG_ATTEMPTING_TO_UPDATE: gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = TRUE; break; default: break; } /* END PATCH UBUOB ISSUE 8278 */ SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING ); #endif kern_llgmm_suspend(LLGMM_CALL); kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_CALL); break; default: TRACE_ERROR( "unknown MS class"); break; } break; case KERN_GMM_REG_NORMAL_SERVICE: switch (gmm_data->kern.attach_cap.mobile_class) { case GMMREG_CLASS_A: kern_mm_cm_establish_res (MMGMM_ESTABLISH_OK); break; case GMMREG_CLASS_CG: kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT); break; case GMMREG_CLASS_BG: if (GMMRR_NET_MODE_III == gmm_data->kern.sig_cell_info.net_mode) { kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT); break; } /* NO break; */ case GMMREG_CLASS_B: case GMMREG_CLASS_BC: SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING ); #endif kern_llgmm_suspend(LLGMM_CALL); kern_gmmrr_suspend (GMMRR_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_CALL); break; default: TRACE_ERROR( "unknown MS class"); break; } break; case KERN_GMM_REG_SUSPENDED: switch (gmm_data->kern.attach_cap.mobile_class) { case GMMREG_CLASS_A: kern_mm_cm_establish_res (MMGMM_ESTABLISH_OK); break; case GMMREG_CLASS_CG: kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT); break; case GMMREG_CLASS_BG: if (GMMRR_NET_MODE_III == gmm_data->kern.sig_cell_info.net_mode) { kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT); break; } /* NO break; */ case GMMREG_CLASS_B: case GMMREG_CLASS_BC: /* * call is rejected because MM may establish the call by itself. * When state REG_RESUMING will be defined than GMM will return OK. * In case of waiting for GMMRR_CELL_IND after GMMRR_RESUME_REQ * the mobile will run into a dead lock situation otherwise. */ kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT); break; default: TRACE_ERROR( "unknown MS class"); break; } break; case KERN_GMM_DEREG_NO_IMSI: case KERN_GMM_NULL_NO_IMSI: kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT); break; default: kern_mm_cm_establish_res (MMGMM_ESTABLISH_REJECT); TRACE_1_INFO ("state: %x", GET_STATE( KERN )); TRACE_ERROR( "MMGMM_CM_ESTABLISH_IND unexpected" ); break; } GMM_RETURN; } /* kern_mm_cm_establish_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_mmgmm_cm_emergency_ind +------------------------------------------------------------------------------ | Description : Handles the primitive MMGMM_CM_EMERGENCY_IND | | Parameters : *mmgmm_cm_emergency_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_mmgmm_cm_emergency_ind ( T_MMGMM_CM_EMERGENCY_IND *mmgmm_cm_emergency_ind ) { GMM_TRACE_FUNCTION( "kern_mmgmm_cm_emeregncy_ind" ); PFREE ( mmgmm_cm_emergency_ind ); if (GMMREG_CLASS_A == gmm_data->kern.attach_cap.mobile_class && GMMRR_NET_MODE_III != gmm_data->kern.sig_cell_info.net_mode) { kern_mm_cm_emergency_res (MMGMM_ESTABLISH_OK); GMM_RETURN; } switch( GET_STATE( KERN ) ) { case KERN_GMM_DEREG_RESUMING: case KERN_GMM_REG_RESUMING: TRACE_ERROR ("prim should be saved"); break; case KERN_GMM_DEREG_SUSPENDING: case KERN_GMM_REG_SUSPENDING: gmm_data->kern.suspension_type |= GMM_SUSP_EM_CALL; break; case KERN_GMM_DEREG_SUSPENDED: case KERN_GMM_REG_SUSPENDED: case KERN_GMM_NULL_IMSI: case KERN_GMM_NULL_NO_IMSI: case KERN_GMM_NULL_PLMN_SEARCH: case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ: case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ: kern_mm_cm_emergency_res (MMGMM_ESTABLISH_OK); break; case KERN_GMM_DEREG_NO_IMSI: if (gmm_data->kern.detach_cap.gmmreg) /* * The mobile is switching off this moment. Thera are no power anymore */ { kern_mm_cm_emergency_res (MMGMM_ESTABLISH_REJECT); } break; case KERN_GMM_DEREG_PLMN_SEARCH: case KERN_GMM_DEREG_LIMITED_SERVICE: case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: case KERN_GMM_DEREG_NO_CELL_AVAILABLE: case KERN_GMM_DEREG_INITIATED: case KERN_GMM_REG_INITIATED: SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDING ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING ); #endif kern_llgmm_suspend(LLGMM_CALL); kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_EM_CALL); break; case KERN_GMM_RAU_WAIT_FOR_NPDU_LIST: case KERN_GMM_REG_IMSI_DETACH_INITIATED: 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_RAU_INITIATED: SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING); #endif kern_llgmm_suspend(LLGMM_CALL); kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_EM_CALL); break; case KERN_GMM_REG_NORMAL_SERVICE: SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING ); #endif /* * kern_llgmm_unassign(); */ kern_llgmm_suspend(LLGMM_CALL); kern_gmmrr_suspend (GMMRR_SUSP_GPRS, GMMRR_ABNORMAL_RELEASE, GMM_SUSP_EM_CALL); break; default: TRACE_ERROR( "MMGMM_CM_EMERGENCY_IND unexpected" ); break; } GMM_RETURN; } /* kern_mm_cm_emergency_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_mmgmm_cm_release_ind +------------------------------------------------------------------------------ | Description : Handles the primitive MMGMM_CM_RELEASE_IND | | Parameters : *mmgmm_cm_release_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_mmgmm_cm_release_ind ( T_MMGMM_CM_RELEASE_IND *mmgmm_cm_release_ind ) { GMM_TRACE_FUNCTION( "kern_mmgmm_cm_release_ind" ); switch( GET_STATE( KERN ) ) { case KERN_GMM_REG_SUSPENDED: /* * resume with cell_ind */ if (MMGMM_RESUMPTION_OK!=mmgmm_cm_release_ind->resumption) { TRACE_EVENT("Para: resumption failure: RAU needed"); SET_STATE(GU,GU_UPDATE_NEEDED); } else { TRACE_EVENT("OPar: resumption OK."); } PFREE ( mmgmm_cm_release_ind ); kern_call_undone_mm_proc_reg(); break; case KERN_GMM_DEREG_SUSPENDED: PFREE ( mmgmm_cm_release_ind ); kern_call_undone_mm_proc_der(); break; case KERN_GMM_DEREG_SUSPENDING: case KERN_GMM_REG_SUSPENDING: gmm_data->kern.suspension_type &= ~ (GMM_SUSP_CALL|GMM_SUSP_EM_CALL); PFREE ( mmgmm_cm_release_ind ); break; default: if (GMMREG_CLASS_A!=gmm_data->kern.attach_cap.mobile_class) { TRACE_ERROR( "MMGMM_CM_RELEASE_IND unexpected" ); } PFREE ( mmgmm_cm_release_ind ); break; } GMM_RETURN; } /* kern_mm_cm_release_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_mmgmm_plmn_ind +------------------------------------------------------------------------------ | Description : Handles the primitive MMGMM_PLMN_IND | | MSC: 3.20 MM Interface | MSC: 3.20.2 Network selection | | Parameters : *mmgmm_plmn_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_mmgmm_plmn_ind ( T_MMGMM_PLMN_IND *mmgmm_plmn_ind ) { GMM_TRACE_FUNCTION( "kern_mmgmm_plmn_ind" ); { PPASS (mmgmm_plmn_ind, gmmreg_plmn_ind, GMMREG_PLMN_IND); PSEND ( hCommMMI, gmmreg_plmn_ind ); } GMM_RETURN; } /* kern_mm_plmn_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_gmmreg_attach_req +------------------------------------------------------------------------------ | Description : Handles the the primitive GMMREG_ATTACH_REQ | | This signal passed the attach_type from MMI to | the service KERN | | MSC : 3.4 MMI-initiated normal/combined GPRS attach | | Parameters : *gmmreq_attach_req - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_gmmreg_attach_req ( T_GMMREG_ATTACH_REQ *gmmreg_attach_req ) { U8 attach_type_changed = FALSE; GMM_TRACE_FUNCTION( "kern_gmmreg_attach_req" ); TRACE_EVENT ("hp_gmm_24473#1#24473"); /* TCS 2.1 */ /* Changes for Boot Time Speedup. GMM will get dummy GMMREG_ATTACH_REQ indicating QUICK_REG. * GMM will send MMGMM_REG_REQ indicating QUICK_REG. No need to process this request as it is * dummy request and GMM will get other GMMREG_ATTACH_REQ indicating NORMAL_REG */ if (gmmreg_attach_req->bootup_act EQ QUICK_REG) { kern_mm_reg_req (REG_GPRS_INACTIVE, QUICK_REG); return ; } vsi_t_stop ( GMM_handle, kern_T3302); sig_kern_rdy_stop_t3302_req(); gmm_data->kern.attach_cap.enter_attempting_to_update_after_lau = FALSE; /* * attach_cap.gmmreg sets the caller of the attach procedure to MMI */ gmm_data->kern.attach_cap.gmmreg = TRUE; gmm_data->kern.detach_cap.gmmreg = FALSE; gmm_data->kern.attach_cap.service_mode = gmmreg_attach_req->service_mode; if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode) { /* * I expect that limited service means emergency call over GSM only * CLASS_CC can be set, because service mode is changed via * GMMREG_ATTACH_REQ only, so that the wanted mobile class is giveb again */ gmm_data->kern.attach_cap.mobile_class = GMMREG_CLASS_CC; gmm_data->kern.attach_cap.attach_type = GMMREG_AT_IMSI; } else { /* *PATCH TB 26/10/02 < * Inform GRR of the new MS class */ attach_type_changed = ( gmm_data->kern.attach_cap.mobile_class != gmmreg_attach_req->mobile_class || gmm_data->kern.attach_cap.attach_type!= gmmreg_attach_req->attach_type); if (GMM_GRR_STATE_OFF != gmm_data->kern.attach_cap.grr_state && (gmm_data->kern.attach_cap.mobile_class != gmmreg_attach_req->mobile_class)) { if (GMMRR_NET_MODE_III==gmm_data->kern.sig_cell_info.net_mode) { gmm_data->kern.attach_cap.mobile_class_changed = TRUE; gmm_data->kern.attach_cap.mobile_class = gmmreg_attach_req->mobile_class; /* * inform GRR after switch (mmgmm_nreg_cnf xor kern _enter_der) * kern_gmmrr_enable(); */ } else { gmm_data->kern.attach_cap.mobile_class = gmmreg_attach_req->mobile_class; kern_gmmrr_enable(); } } /* PATCH TB 26/10/02 > */ gmm_data->kern.attach_cap.mobile_class = gmmreg_attach_req->mobile_class; /* * if MMI wants to detach, then detach is expected or class change */ gmm_data->kern.attach_cap.attach_type = (GMMREG_CLASS_CG == gmmreg_attach_req->mobile_class? GMMREG_AT_GPRS: gmm_data->kern.attach_cap.attach_type|gmmreg_attach_req->attach_type); } #ifndef NTRACE switch (gmmreg_attach_req->service_mode) { case SERVICE_MODE_LIMITED: TRACE_EVENT ("Limited Service"); break; case SERVICE_MODE_FULL: TRACE_EVENT ("Full Service"); break; default: TRACE_ERROR ("wrong Service requested"); } switch ( gmm_data->kern.attach_cap.mobile_class ) { case GMMREG_CLASS_CC: TRACE_0_PARA("MS class CC"); break; case GMMREG_CLASS_CG: TRACE_0_PARA("MS class CG"); break; case GMMREG_CLASS_B: TRACE_0_PARA("MS class B"); break; case GMMREG_CLASS_BG: TRACE_0_PARA("MS class BG"); break; case GMMREG_CLASS_BC: TRACE_0_PARA("MS class BC"); break; case GMMREG_CLASS_A: TRACE_0_PARA("MS class A"); break; default: TRACE_ERROR ("unknown mobile class"); break; } switch (gmm_data->kern.attach_cap.attach_type) { case GMMREG_AT_IMSI: TRACE_0_PARA("GSM only attach"); break; case GMMREG_AT_GPRS: TRACE_0_PARA("GPRS attach"); break; case GMMREG_AT_COMB: TRACE_0_PARA("GSM and GPRS attach"); break; default: TRACE_ERROR ("unknown attach type"); TRACE_1_PARA("%d",gmm_data->kern.attach_cap.attach_type); break; } #endif if (gmm_data->sim_gprs_invalid && GMMREG_CLASS_CG == gmm_data->kern.attach_cap.mobile_class) /* * i.e. error cause 7: gprs not allowed */ { PREUSE(gmmreg_attach_req,gmmreg_attach_rej,GMMREG_ATTACH_REJ ); gmmreg_attach_rej->detach_type = (GMM_MM_REG_NORMAL_SERVICE == GET_STATE(MM)?GMMREG_DT_GPRS:GMMREG_DT_COMB), gmmreg_attach_rej->search_running = GMMREG_SEARCH_NOT_RUNNING, gmmreg_attach_rej->cause = GMMCS_GPRS_NOT_ALLOWED; /* TCS 2.1 */ gmmreg_attach_rej->service = GMMCS_GPRS_NOT_ALLOWED; gmm_data->kern.attach_cap.gmmreg = FALSE; PSEND ( hCommMMI, gmmreg_attach_rej ); GMM_RETURN; } PFREE ( gmmreg_attach_req ); switch( GET_STATE( KERN ) ) { /* * GMM-DEREGISTERED */ case KERN_GMM_DEREG_RESUMING: case KERN_GMM_REG_RESUMING: TRACE_ERROR ("prim should be saved"); break; case KERN_GMM_DEREG_PLMN_SEARCH: case KERN_GMM_DEREG_LIMITED_SERVICE: case KERN_GMM_DEREG_NO_CELL_AVAILABLE: case KERN_GMM_DEREG_ATTEMPTING_TO_ATTACH: case KERN_GMM_DEREG_SUSPENDING: case KERN_GMM_DEREG_SUSPENDED: if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode) { SET_STATE ( KERN, KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ); #endif kern_gmmrr_disable(); kern_mm_activate_mm(); break; } if (GMMREG_CLASS_CC==gmm_data->kern.attach_cap.mobile_class || GMMREG_AT_IMSI== gmm_data->kern.attach_cap.attach_type) { SET_STATE ( KERN, KERN_GMM_NULL_IMSI ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI ); #endif kern_gmmrr_disable(); kern_mm_activate_mm(); if ( GMM_MM_REG_NORMAL_SERVICE == GET_STATE(MM) ) { kern_gmmreg_attach_cnf( GMMREG_AT_IMSI); } break; } switch ( gmm_data->kern.attach_cap.mobile_class ) { case GMMREG_CLASS_CG: if ( GMM_MM_DEREG != GET_STATE(MM) ) { switch( GET_STATE( KERN ) ) { case KERN_GMM_DEREG_SUSPENDED: /* * Case GMMREG_CLASS_CG. * The detach procedure for cs is only possible after receiving * GMMRR_CELL_IND */ break; case KERN_GMM_DEREG_SUSPENDING: gmm_data->kern.suspension_type |=GMM_SUSP_IMSI_DETACH; break; default: if (kern_lai_changed() ) { SET_STATE ( KERN, KERN_GMM_DEREG_SUSPENDING ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_SUSPENDING ); #endif kern_gmmrr_suspend (GMMRR_NOT_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU); } else { kern_imsi_detach_der_susp(); } GMM_RETURN; } } break; default: break; } switch( GET_STATE( KERN ) ) { case KERN_GMM_DEREG_SUSPENDED: gmm_data->kern.attach_cap.mm_lau_attempted=TRUE; gmm_data->kern.suspension_type &= ~GMM_SUSP_LAU; break; case KERN_GMM_DEREG_SUSPENDING: gmm_data->kern.suspension_type |=GMM_SUSP_LAU; break; default: { kern_mm_reg_req (REG_CELL_SEARCH_ONLY, NORMAL_REG); } break; } break; case KERN_GMM_NULL_PLMN_SEARCH: if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode) { SET_STATE (KERN,KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ); #endif kern_mm_activate_mm (); break; } if (GMMREG_CLASS_CC==gmm_data->kern.attach_cap.mobile_class || GMMREG_AT_IMSI== gmm_data->kern.attach_cap.attach_type) { kern_mm_activate_mm (); break; } switch ( gmm_data->kern.attach_cap.mobile_class ) { case GMMREG_CLASS_CG: if ( GMM_MM_DEREG != GET_STATE(MM) ) { SET_STATE(KERN, KERN_GMM_DEREG_PLMN_SEARCH); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH); #endif /* * MM enters autmaticly gprs cell search mode so that GMM * need not to send mmgmm_reg_req (cell_search_only) */ kern_mm_imsi_detach(); } else { SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH ); #endif kern_mm_activate_rr(); } break; default: /* * class A and B */ SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH ); #endif kern_mm_activate_rr(); break; } break; /* * GPRS will be enabled */ case KERN_GMM_NULL_IMSI: if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode) { SET_STATE (KERN,KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ); #endif kern_mm_activate_mm (); break; } if (GMM_MM_DEREG != GET_STATE(MM) && GMMREG_CLASS_CC == gmm_data->kern.attach_cap.mobile_class) { TRACE_EVENT ("GMMREG_ATTACH_REQ has been come twice and is ignored!"); /* * the funcion is not alled because mm_plmn is used. */ kern_gmmreg_attach_cnf(GMMREG_AT_IMSI); gmm_data->kern.attach_cap.gmmreg = FALSE; break; } /* NO break */ case KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ: if (SERVICE_MODE_LIMITED != gmm_data->kern.attach_cap.service_mode) { gmm_data->kern.sig_cell_info.gmm_status = GMMRR_SERVICE_UNKNOWN ; /* Initalize gmm status value */ switch ( gmm_data->kern.attach_cap.mobile_class ) { case GMMREG_CLASS_CC: if (KERN_GMM_NULL_IMSI_LIMITED_SERVICE_REQ==GET_STATE(KERN) || GMM_MM_DEREG == GET_STATE(MM)) { SET_STATE ( KERN, KERN_GMM_NULL_PLMN_SEARCH ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_PLMN_SEARCH ); #endif kern_mm_activate_mm(); } else { SET_STATE(KERN,KERN_GMM_NULL_IMSI); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_IMSI); #endif kern_gmmreg_attach_cnf( GMMREG_AT_IMSI); } break; case GMMREG_CLASS_CG: if ( GMM_MM_DEREG != GET_STATE(MM) ) { switch(GET_STATE(KERN)) { case KERN_GMM_NULL_IMSI: SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH); #endif /* * MM enters autmaticly gprs cell search mode so that GMM * need not to send mmgmm_reg_req (cell_search_only) */ kern_mm_imsi_detach(); break; default: break; } } else { SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH ); #endif kern_mm_activate_rr(); } break; default: /* * class A and B */ if (GMMREG_AT_IMSI== gmm_data->kern.attach_cap.attach_type) { SET_STATE ( KERN, KERN_GMM_NULL_PLMN_SEARCH ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_PLMN_SEARCH ); #endif kern_mm_activate_mm(); } else { SET_STATE ( KERN, KERN_GMM_DEREG_PLMN_SEARCH ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_DEREG_PLMN_SEARCH ); #endif kern_mm_activate_rr(); } break; } } break; /* end case KERN_GMM_NULL_IMSI */ case KERN_GMM_DEREG_NO_IMSI: /* * this state is not necessary, it is the same as NULL_NO_IMSI * and will be romoved soon */ if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode) { SET_STATE (KERN,KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ); #endif } else { SET_STATE (KERN,KERN_GMM_NULL_NO_IMSI); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI); #endif } kern_gmmrr_disable(); kern_mm_activate_mm(); break; case KERN_GMM_NULL_NO_IMSI: /* * Attach Rejected for the first time to enable POWER_OFF */ if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode) { SET_STATE (KERN,KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ); #endif } kern_mm_activate_mm(); break; case KERN_GMM_NULL_NO_IMSI_LIMITED_SERVICE_REQ: if ( SERVICE_MODE_LIMITED != gmm_data->kern.attach_cap.service_mode) { SET_STATE (KERN,KERN_GMM_NULL_NO_IMSI); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_NULL_NO_IMSI); #endif } kern_mm_activate_mm(); break; case KERN_GMM_REG_NORMAL_SERVICE: if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode) { kern_l_sim_rem_reg(); } else { switch ( gmm_data->kern.attach_cap.mobile_class ) { case GMMREG_CLASS_CC: if ( GMM_MM_REG_NORMAL_SERVICE == GET_STATE(MM) ) { kern_gmmreg_attach_cnf ( GMMREG_AT_IMSI ); } kern_disable(); break; case GMMREG_CLASS_CG: if (GMM_MM_DEREG != GET_STATE(MM)) { if (kern_lai_changed() ) { switch (gmm_data->kern.sig_cell_info.net_mode) { case GMMRR_NET_MODE_I: kern_rau(); break; default: SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING ); #endif kern_llgmm_suspend(LLGMM_CALL); kern_gmmrr_suspend (GMMRR_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU); break; } } else { switch (gmm_data->kern.sig_cell_info.net_mode) { case GMMRR_NET_MODE_I: gmm_data->kern.detach_cap.detach_type = GMMREG_DT_IMSI; kern_detach(); break; default: kern_imsi_detach_reg_susp(); break; } } GMM_RETURN; } /* * <R.GMM.AGACCEPT.M.027>, * <R.GMM.PATTCNF.M.001> */ else { kern_gmmreg_attach_cnf ( GMMREG_AT_GPRS ); } break; default: if (attach_type_changed) { /* * class A and B */ if ( GMM_MM_REG_NORMAL_SERVICE == GET_STATE(MM) ) { kern_gmmreg_attach_cnf ( GMMREG_AT_COMB ); } else { /* * Combined RAU procedure is established * if GPRS is attached and IMSI should attached */ kern_rau(); } } else { kern_mm_reg_req (REG_CELL_SEARCH_ONLY, NORMAL_REG); } break; } } break; case KERN_GMM_REG_SUSPENDED: case KERN_GMM_REG_SUSPENDING: if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode) { kern_l_sim_rem_reg_lim (); break; } /* * Attach requests in suspended mode will be handled after resumption * by triggering form GRR with GMMRR_CELL_IND */ break; case KERN_GMM_REG_NO_CELL_AVAILABLE: case KERN_GMM_REG_LIMITED_SERVICE: if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode) { kern_l_sim_rem_reg_lim (); break; } /* NO break */ case KERN_GMM_RAU_INITIATED: case KERN_GMM_REG_INITIATED: case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM: case KERN_GMM_REG_ATTEMPTING_TO_UPDATE: if (SERVICE_MODE_LIMITED == gmm_data->kern.attach_cap.service_mode) { kern_l_sim_rem_reg (); } else { switch ( gmm_data->kern.attach_cap.mobile_class ) { case GMMREG_CLASS_CC: gmm_data->kern.detach_cap.detach_type = GMMREG_DT_DISABLE_GPRS; kern_local_detach( GMMCS_INT_PROTOCOL_ERROR, FALSE, GMM_LOCAL_DETACH_PROC_ENTER_NULL_IMSI); /* TCS 2.1 */ if ( GMM_MM_REG_NORMAL_SERVICE == GET_STATE(MM) ) { kern_gmmreg_attach_cnf ( GMMREG_AT_IMSI ); } kern_enter_der(); break; case GMMREG_CLASS_CG: if (GMM_MM_DEREG != GET_STATE(MM)) { if (kern_lai_changed() ) { switch(GET_STATE(KERN)) { case KERN_GMM_REG_NO_CELL_AVAILABLE: case KERN_GMM_RAU_INITIATED: case KERN_GMM_REG_ATTEMPTING_TO_UPDATE_MM: case KERN_GMM_REG_ATTEMPTING_TO_UPDATE: kern_llgmm_suspend(LLGMM_CALL); break; default: break; } SET_STATE ( KERN, KERN_GMM_REG_SUSPENDING ); #ifdef FF_EM_MODE EM_GMM_SET_STATE(KERN_GMM_REG_SUSPENDING ); #endif kern_gmmrr_suspend (GMMRR_SUSP_GPRS, GMMRR_NORMAL_RELEASE, GMM_SUSP_LAU); } else { kern_imsi_detach_reg_susp(); } GMM_RETURN; } else /* * <R.GMM.AGACCEPT.M.027>, * <R.GMM.PATTCNF.M.001> */ { if (KERN_GMM_REG_INITIATED!=GET_STATE(KERN)) { kern_gmmreg_attach_cnf ( GMMREG_AT_GPRS ); } } break; default: { kern_mm_reg_req (REG_CELL_SEARCH_ONLY, NORMAL_REG); } break; } } break; default: TRACE_ERROR( "GMMREG_ATTACH_REQ unexpected" ); break; } GMM_RETURN; } /* kern_gmmreg_attach_req() */ /* +------------------------------------------------------------------------------ | Function : kern_gmmsm_sequence_res +------------------------------------------------------------------------------ | Description : Handles the primitive GMMSM_SEQENCE_RES | | Parameters : *gmmsm_sequence_res - Ptr to primitive payload | +------------------------------------------------------------------------------ */ #ifdef GMM_TCS4 GLOBAL void kern_gmmsm_sequence_res ( T_MMPM_SEQUENCE_RES *gmmsm_sequence_res ) #else GLOBAL void kern_gmmsm_sequence_res ( T_GMMSM_SEQUENCE_RES *gmmsm_sequence_res ) #endif { GMM_TRACE_FUNCTION( "kern_gmmsm_sequence_res" ); switch( GET_STATE( KERN ) ) { case KERN_GMM_RAU_WAIT_FOR_NPDU_LIST: { int i=0; MCAST (routing_area_update_complete, ROUTING_AREA_UPDATE_COMPLETE); routing_area_update_complete->v_receive_n_pdu_number_list = TRUE; routing_area_update_complete->receive_n_pdu_number_list. c_receive_n_pdu_number_list_val = gmmsm_sequence_res->c_npdu_list; for (i=0;i<routing_area_update_complete->receive_n_pdu_number_list.c_receive_n_pdu_number_list_val;i++) { routing_area_update_complete ->receive_n_pdu_number_list.receive_n_pdu_number_list_val[i] .nsapi = gmmsm_sequence_res->npdu_list[i].nsapi; routing_area_update_complete ->receive_n_pdu_number_list.receive_n_pdu_number_list_val[i] .receive_n_pdu_number_val = gmmsm_sequence_res->npdu_list[i].receive_n_pdu_number_val; } PFREE (gmmsm_sequence_res); kern_rau_complete (gmm_data->kern.attach_cap.result_type); break; } default: PFREE (gmmsm_sequence_res); TRACE_ERROR( "GMMSM_SEQUENCE_RES received in an unusual state." ); break; } GMM_RETURN; } /* kern_gmmsm_sequence_res() */ /*TI DK primitive*/ #ifdef REL99 /*+------------------------------------------------------------------------------ | Function : kern_gmmsm_pdp_status_req +------------------------------------------------------------------------------ | Description : Handles the primitive GMMSM_PDP_STATUS_REQ | | Parameters : *gmmsm_pdp_status_req - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_gmmsm_pdp_status_req ( T_MMPM_PDP_CONTEXT_STATUS_REQ *gmmsm_pdp_status_req ) { GMM_TRACE_FUNCTION( "kern_gmmsm_pdp_status_req" ); /* Store the data in context */ gmm_data->kern.attach_cap.pdp_context_status = gmmsm_pdp_status_req->nsapi_set; GMM_RETURN; } /* kern_gmmsm_pdp_status_req() */ #endif /* +------------------------------------------------------------------------------ | Function : kern_mmgmm_ciphering_ind +------------------------------------------------------------------------------ | Description : forwards the ciphering indicator of GSM to MMI | | Parameters : *mmgmm_ciphering_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_mmgmm_ciphering_ind ( T_MMGMM_CIPHERING_IND *mmgmm_ciphering_ind ) { GMM_TRACE_FUNCTION( "kern_mmgmm_ciphering_ind" ); { PALLOC (gmmreg_ciphering_ind, GMMREG_CIPHERING_IND); gmmreg_ciphering_ind->gsm_ciph = mmgmm_ciphering_ind->ciph; /* * do not include the ciphering status of gprs purposely to have the * behaviour for GSM and for GPRS (do not remember the status of the other!) */ gmmreg_ciphering_ind->gprs_ciph = CIPH_NA; PFREE ( mmgmm_ciphering_ind ); PSEND ( hCommMMI, gmmreg_ciphering_ind ); } GMM_RETURN; } /* kern_mmgmm_ciphering_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_mmgmm_tmsi_ind +------------------------------------------------------------------------------ | Description : forwards the TMSI received in MM to GMM | | Parameters : *mmgmm_tmsi_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_mmgmm_tmsi_ind ( T_MMGMM_TMSI_IND *mmgmm_tmsi_ind ) { GMM_TRACE_FUNCTION( "kern_mmgmm_tmsi_ind" ); gmm_data->tmsi = mmgmm_tmsi_ind->tmsi; TRACE_1_PARA("TMSI %x", gmm_data->tmsi ); PFREE ( mmgmm_tmsi_ind ); GMM_RETURN; } /* kern_mmgmm_ciphering_ind() */ /* +------------------------------------------------------------------------------ | Function : kern_mmgmm_ahplmn_ind +------------------------------------------------------------------------------ | Description : forwards the ahplmn indicator to MMI | | Parameters : *mmgmm_ahplmn_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void kern_mmgmm_ahplmn_ind ( T_MMGMM_AHPLMN_IND *mmgmm_ahplmn_ind ) { GMM_TRACE_FUNCTION( "kern_mmgmm_ahplmn_ind" ); { PPASS (mmgmm_ahplmn_ind, gmmreg_ahplmn_ind, GMMREG_AHPLMN_IND); PSEND ( hCommMMI, gmmreg_ahplmn_ind ); } GMM_RETURN; } /* kern_mmgmm_ahplmn_ind() */