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