FreeCalypso > hg > freecalypso-sw
diff gsm-fw/g23m-gsm/rr/rr_attg.c @ 673:2f7df7a314f8
gsm-fw/g23m-gsm subtree: initial import from LoCosto source
| author | Michael Spacefalcon <msokolov@ivan.Harhan.ORG> |
|---|---|
| date | Sun, 28 Sep 2014 23:20:04 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gsm-fw/g23m-gsm/rr/rr_attg.c Sun Sep 28 23:20:04 2014 +0000 @@ -0,0 +1,3562 @@ +/* ++----------------------------------------------------------------------------- +| Project : +| Modul : ++----------------------------------------------------------------------------- +| Copyright 2002 Texas Instruments Berlin, AG +| All rights reserved. +| +| This file is confidential and a trade secret of Texas +| Instruments Berlin, AG +| The receipt of or possession of this file does not convey +| any rights to reproduce or disclose its contents or to +| manufacture, use, or sell anything it may describe, in +| whole, or in part, without the specific written consent of +| Texas Instruments Berlin, AG. ++----------------------------------------------------------------------------- +| Purpose : This module holds the functions for handling primitives +| sent from entity GRR to entity RR and vice versa. ++----------------------------------------------------------------------------- +*/ + +#ifndef RR_GPRS_C +#define RR_GPRS_C + +#ifdef GPRS + +#define ENTITY_RR + +/*==== INCLUDES ===================================================*/ + +#include <string.h> +#include <stddef.h> +#include "typedefs.h" +#include "pcm.h" +#include "pconst.cdg" +#include "mconst.cdg" +#include "message.h" +#include "vsi.h" +#include "custom.h" +#include "gsm.h" +#include "prim.h" +#include "pei.h" +#include "tok.h" +#include "rr_gprs.h" +#include "rr.h" +#include "rr_em.h" + +static void att_get_scell_info (T_serving_cell_info* sc, UBYTE idx); +static void att_gprs_store_nc_mode(T_D_SYS_INFO_13* sys_info_13); +#ifdef REL99 +static void att_gprs_store_nw_release(T_D_SYS_INFO_13* sys_info_13); +#endif + +static T_NC_DATA* is_nc_in_list(USHORT arfcn); +static T_NC_DATA* find_empty_slot_in_list(void); +static BOOL rr_ext_meas_can_start ( void ); +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_for_sysinfo_type13 | ++--------------------------------------------------------------------+ + + PURPOSE : Checks GPRS availability of cell +*/ +void att_for_sysinfo_type13 (T_MPH_UNITDATA_IND* data_ind, + T_D_SYS_INFO_13* sys_info_13) +{ + GET_INSTANCE_DATA; + /* + * get the storage area by checking the channel number + */ + UBYTE index = att_get_index (data_ind->arfcn); + TRACE_FUNCTION("att_for_sysinfo_type13"); + switch(GET_STATE(STATE_ATT)) + { + case ATT_CS2: + /* + * during cell selection + * only CR_INDEX is taken in account + */ + if (index EQ CR_INDEX) + { + switch(GET_STATE(STATE_GPRS)) + { + case GPRS_ACTIVATED: + case GPRS_PIM_BCCH: + case GPRS_DEDI_SDCCH: + if(sys_info_13->si13_rest_oct.v_si13_info AND + sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) + { + SET_STATE(STATE_GPRS, GPRS_PIM_PBCCH); + } + else + { + SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); + /* + * check the NC mode, this is the default + * value of the NW which can be overriden + * by a Packet Measurement Order. + * In CS2 we can always use the value provided + * by the NW + */ + att_gprs_store_nc_mode(sys_info_13); + } + break; + case GPRS_PIM_PBCCH: + TRACE_EVENT("GPRS config changed during CS2!"); + if(sys_info_13->si13_rest_oct.v_si13_info AND + !sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) + { + SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); + } + break; + default: + break; + } + + gprs_rrgrr_store_sdu(rr_data->gprs_data.si13_sdu, &data_ind->sdu); + att_set_sys_info_read (SYS_INFO_13_READ, CR_INDEX); +#ifdef REL99 + att_gprs_store_nw_release(sys_info_13); +#endif + att_check_bcch_carrier_si (); + } + break; + case ATT_CS3: + /* + * during cell reselection + * only CR_INDEX is taken in account + */ + if (index EQ CR_INDEX) + { + switch(GET_STATE(STATE_GPRS)) + { + case GPRS_ACTIVATED: + case GPRS_PIM_BCCH: + if(sys_info_13->si13_rest_oct.v_si13_info AND + sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) + { + SET_STATE(STATE_GPRS, GPRS_PIM_PBCCH); + } + else + { + SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); + /* + * check the NC mode, this is the default + * value of the NW which can be overriden + * by a Packet Measurement Order. + * In CS3 we can always use the value provided + * by the NW + */ + att_gprs_store_nc_mode(sys_info_13); + } + break; + case GPRS_PIM_PBCCH: + if(sys_info_13->si13_rest_oct.v_si13_info AND + !sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) + { + TRACE_EVENT("GPRS config changed during CS3!"); + SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); + } + break; + default: + break; + } + + gprs_rrgrr_store_sdu(rr_data->gprs_data.si13_sdu, &data_ind->sdu); + att_set_sys_info_read (SYS_INFO_13_READ, CR_INDEX); +#ifdef REL99 + att_gprs_store_nw_release(sys_info_13); +#endif + + att_check_neighbourcell_si_reestab(); + + } + break; + case ATT_CON_EST: + case ATT_IDLE: + switch (index) + { + case SC_INDEX: + /* now we want to send the SI13 to GRR */ + if(/*rr_data->ms_data.rr_service EQ LIMITED_SERVICE OR*/ + !att_gprs_is_avail()) + return; + + switch(GET_STATE(STATE_GPRS)) + { + case GPRS_ACTIVATED: + if((rr_data->sc_data.selection_type EQ CELL_RESELECTION_ON_GPRS_ACT) AND + (rr_data->sc_data.cd.sys_info_read EQ ALL_SYS_INFO_READ)) + { + TRACE_EVENT(" CELL_RESELECTION_ON_GPRS_ACT should end"); + TIMERSTOP(T_RESELECT); + } + + if(sys_info_13->si13_rest_oct.v_si13_info AND + sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) + { + if(rr_data->sc_data.cd.sys_info_read EQ ALL_SYS_INFO_READ) + { + att_gprs_stop_pl(); + } + SET_STATE(STATE_GPRS, GPRS_PIM_PBCCH); + } + else + { + SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); + if(rr_data->sc_data.cd.sys_info_read EQ ALL_SYS_INFO_READ) + { + att_build_idle_req(SC_INDEX, MODE_SYS_INFO_CHANGE); + } + /* + * check the NC mode, this is the default + * value of the NW which can be overriden + * by a Packet Measurement Order. + * + */ + att_gprs_store_nc_mode(sys_info_13); + } + break; + case GPRS_PIM_BCCH: + case GPRS_PTM_BCCH: + /* + * check the NC mode, this is the default + * value of the NW which can be overriden + * by a Packet Measurement Order. + * + */ + att_gprs_store_nc_mode(sys_info_13); + /* XXX */ + /* + * Right now it not clear what how the activation of PBCCH + * should be handled in RR/GRR + */ + if (GET_STATE(STATE_GPRS) EQ GPRS_PTM_BCCH) + break; + + if(sys_info_13->si13_rest_oct.v_si13_info AND + sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) + { + att_gprs_stop_pl(); + SET_STATE(STATE_GPRS, GPRS_PIM_PBCCH); + } + break; + case GPRS_PIM_PBCCH: + if(sys_info_13->si13_rest_oct.v_si13_info AND + !sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) + { + /*XXX not possible actually */ + SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); + } + break; + default: + break; + } + + /* + * GRR requests reading of SI13 every 30 seconds + * pass the SI13 to GRR, for further evaluation + */ + TRACE_EVENT("idle sc"); + TRACE_EVENT_P1("sys_info_read %d", rr_data->sc_data.cd.sys_info_read); + gprs_rrgrr_store_sdu(rr_data->gprs_data.si13_sdu, &data_ind->sdu); + att_set_sys_info_read (SYS_INFO_13_READ, SC_INDEX); + +#ifdef REL99 + att_gprs_store_nw_release(sys_info_13); +#endif + att_signal_gprs_support(); + break; + case NOT_PRESENT_8BIT: + /* + * unexpected channel number + */ + break; + default: + /* + * neighbour cell, ignore. + * si13 info is not needed, at first + * maybe get PBCCH info later + */ + break; + } + break; + default: + break; + } +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS () MODULE : RR_GPRS | +| STATE : code ROUTINE : att_set_gprs_indication | ++-----------------------------------------------------------------------------+ + + PURPOSE : sets a flag indicating whether GPRS is wanted by upper layer + or not. + +*/ +void att_set_gprs_indication (UBYTE gprs_indic) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("att_set_gprs_indication()"); + + /* + * store parameter from MM + */ + rr_data->gprs_data.gprs_indic = gprs_indic; + + if(rr_data->gprs_data.gprs_indic) + { + SET_STATE(STATE_GPRS, GPRS_ACTIVATED); + TRACE_EVENT("MM wants GPRS"); + } + else + { + SET_STATE(STATE_GPRS, GPRS_NULL); + rr_data->gprs_data.ready_state = FALSE; /* Standby */ + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_check_gprs_supp | ++--------------------------------------------------------------------+ + + PURPOSE : Checks GPRS availability of cell and sets the internal + flag +*/ +void att_check_gprs_supp (UBYTE v_gprs_ind, T_gprs_indic * data) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("att_check_gprs_supp ()"); + + /* + * if rest octets for GPRS are available + * and GPRS support is requested by MM + */ + switch(GET_STATE(STATE_GPRS)) + { + case GPRS_NULL: + if(GET_STATE(STATE_ATT) EQ ATT_CS2 OR + GET_STATE(STATE_ATT) EQ ATT_CS3) + att_set_sys_info_read(SYS_INFO_13_READ, CR_INDEX); + else + att_set_sys_info_read(SYS_INFO_13_READ, SC_INDEX); + break; + case GPRS_ACTIVATED: + if(GET_STATE(STATE_ATT) EQ ATT_CS2 OR + GET_STATE(STATE_ATT) EQ ATT_CS3) + { + if(v_gprs_ind) + { + SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); + /* + * If System Info 13 is send on extended BCCH, + * request reading, else it is reading on normal BCCH + */ + if(data->si13_pos EQ SI13_ON_BCCH_EXT) + { + PALLOC(mon_ctrl, MPH_MON_CTRL_REQ); + + mon_ctrl->action = START_MON_EBCCH; + mon_ctrl->si_to_read = UPDATE_SI13; + + PSENDX(PL, mon_ctrl); + } + /* else we will read it on NBCCH */ + } + else + { + /* no state change */ + att_set_sys_info_read(SYS_INFO_13_READ, CR_INDEX); + } + } + /* + * when GPRS is activated in idle this will be handled + * when the SI13 is received + */ + break; + case GPRS_PIM_BCCH: + case GPRS_PIM_PBCCH: + if(!v_gprs_ind) + { + SET_STATE(STATE_GPRS, GPRS_ACTIVATED); + att_set_sys_info_read(SYS_INFO_13_READ, SC_INDEX); + if(GET_STATE(STATE_ATT) EQ ATT_IDLE) + { + /*XY:n inform GRR, and wait for CR_RSP */ + att_rrgrr_cr_ind(CR_ABNORMAL); + rr_data->gprs_data.start_proc = START_PROC_CFG_CHG; + } + } + else + { + /* + * If System Info 13 is send on extended BCCH, + * request reading, else it is reading on normal BCCH + */ + if(data->si13_pos EQ SI13_ON_BCCH_EXT) + { + PALLOC(mon_ctrl, MPH_MON_CTRL_REQ); + mon_ctrl->action = START_MON_EBCCH; + mon_ctrl->si_to_read = UPDATE_SI13; + PSENDX(PL, mon_ctrl); + } + /* else we will read it on NBCCH */ + } + break; + default: + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_signal_gprs_support | ++--------------------------------------------------------------------+ + + PURPOSE : Signal GPRS support to GRR +*/ +void att_signal_gprs_support (void) +{ + GET_INSTANCE_DATA; + PALLOC_SDU(rrgrr_gprs_si13_ind, RRGRR_GPRS_SI13_IND, MAX_L2_FRAME_SIZE * BITS_PER_BYTE); + TRACE_FUNCTION ("att_signal_gprs_support()"); + /* + * gprs_support : Y Y X N N + * rr_service : F L N F L + * sdu : Y Y - - - + * servng_cell_info: + */ + + if(GET_STATE(STATE_ATT) EQ ATT_IDLE AND + rr_data->sc_data.cd.sys_info_read NEQ ALL_SYS_INFO_READ) + { + PFREE(rrgrr_gprs_si13_ind); + return; + } + + if((GET_STATE(STATE_GPRS) NEQ GPRS_ACTIVATED AND + GET_STATE(STATE_GPRS) NEQ GPRS_NULL) AND + !(rr_data->ms_data.rr_service EQ NO_SERVICE) + ) + { + rrgrr_gprs_si13_ind->cause = GPRS_SUPPORTED; + + /* + * copy message content + */ + gprs_rrgrr_fill_from_stored_sdu(&rrgrr_gprs_si13_ind->sdu, + rr_data->gprs_data.si13_sdu); + + TRACE_EVENT_P4 ("cs=%u C[%d] bsic=%u #%u", + rrgrr_gprs_si13_ind->cause, + rrgrr_gprs_si13_ind->serving_cell_info.bcch_arfcn, + rrgrr_gprs_si13_ind->serving_cell_info.bcch_bsic, + __LINE__); + + /* + * set system information state + */ + rrgrr_gprs_si13_ind->si_states.si1_state = SI1_RECEIVED; + rrgrr_gprs_si13_ind->si_states.si3_state = SI3_RECEIVED; + rrgrr_gprs_si13_ind->si_states.si13_state = SI13_RECEIVED; + } + else + { + rrgrr_gprs_si13_ind->cause = GPRS_NOT_SUPPORTED; + } + + /*When BA (BCCH) list is modified by PMO/PCCO, this is just for RR, RR should not inform + GRR as it would have already formed the list. Sending this new list will change all the + index, as GRR would assume it to be new BA(BCCH). When New BA(BCCH) is received then this flag + would be reset and GRR should update the BA list*/ + + if(rr_data->gprs_data.ba_bcch_modified AND (GET_STATE(STATE_ATT) NEQ ATT_CS3)) + { + rrgrr_gprs_si13_ind->serving_cell_info.arfcn[0]= RRGRR_INVALID_ARFCN; + } + else + { + memcpy(rrgrr_gprs_si13_ind->serving_cell_info.arfcn, rr_data->act_ncell_list, + sizeof(rrgrr_gprs_si13_ind->serving_cell_info.arfcn)); + } + + + att_get_scell_info(&rrgrr_gprs_si13_ind->serving_cell_info, SC_INDEX); + + /* we have found a cell, reset cr flag*/ + rr_data->gprs_data.cr_pbcch_active = FALSE; + +#if defined (REL99) AND defined (TI_PS_FF_EMR) + rrgrr_gprs_si13_ind->serving_cell_info.ba_ind = rr_data->sc_data.ba_index; +#endif + + PSENDX(GRR, rrgrr_gprs_si13_ind); +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_add_ptmsi | ++-----------------------------------------------------------------------------+ + + PURPOSE : Add the ptmsi if GPRS is supported. + +*/ +void att_add_ptmsi (T_MPH_IDENTITY_REQ * mph_identity_req) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("att_add_ptmsi()"); + + /* + * check availability of GPRS + */ + switch (GET_STATE(STATE_GPRS)) + { + case GPRS_NULL: + mph_identity_req->mid.v_ptmsi = FALSE; + mph_identity_req->mid.ptmsi = 0L; + + + mph_identity_req->mid.v_ptmsi2 = FALSE; + mph_identity_req->mid.ptmsi2 = 0L; + break; + default: + if (rr_data->gprs_data.ptmsi EQ 0xFFFFFFFF OR + rr_data->gprs_data.ptmsi EQ 0L) + { + mph_identity_req->mid.v_ptmsi = FALSE; + mph_identity_req->mid.ptmsi = 0L; + } + else + { + mph_identity_req->mid.v_ptmsi = TRUE; + mph_identity_req->mid.ptmsi = rr_data->gprs_data.ptmsi; + } + /*the candidate PTMSI has to be checked also*/ + if (rr_data->gprs_data.ptmsi2 EQ 0xFFFFFFFF OR + rr_data->gprs_data.ptmsi2 EQ 0L) + { + mph_identity_req->mid.v_ptmsi2 = FALSE; + mph_identity_req->mid.ptmsi2 = 0L; + } + else + { + mph_identity_req->mid.v_ptmsi2 = TRUE; + mph_identity_req->mid.ptmsi2 = rr_data->gprs_data.ptmsi2; + } + break; + } +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_rrgrr_cr_ind | ++-----------------------------------------------------------------------------+ + + PURPOSE : + IN : + OUT : + +*/ + +void att_rrgrr_cr_ind (UBYTE type) +{ + GET_INSTANCE_DATA; + /* + * Following cases are possible: + * BCCH always CR_ABNORMAL + * after con est fail, after dedi, normal cr in idle and ptm, + * plmn search,activate req, cell selection + * PBCCH: + * after con est fail(CR_REQ_CANDIDATE), + * activate_req (CR_NORMAL) + * after dedi (CR_ABNORMAL) + * after imm_ass_rej (CR_SUSPENDED_IDLE) + */ + if(GET_STATE(STATE_GPRS) NEQ GPRS_NULL) + { + PALLOC(cr_ind, RRGRR_CR_IND); + cr_ind->cr_type = type; + TRACE_EVENT("cr_ind"); + PSENDX(GRR, cr_ind); + } + else + { + TRACE_EVENT("cr already active"); + } +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_rrgrr_cr_req | ++-----------------------------------------------------------------------------+ + + PURPOSE : + +*/ +void att_rrgrr_cr_req (T_RRGRR_CR_REQ *cr_req) +{ + GET_INSTANCE_DATA; + int gprs_state; + + TRACE_FUNCTION ("gprs_rrgrr_cell_reselection_req ()"); + + gprs_state = GET_STATE(STATE_GPRS); + + TRACE_EVENT_P3 ("RRGRR_CR_REQ %u [%u] st=%u", + cr_req->cr_type, cr_req->arfcn, gprs_state); + TRACE_EVENT_P6 ( "r MCC/MNC=%x%x%x/%x%x%x", + rr_data->ms_data.plmn.mcc[0], + rr_data->ms_data.plmn.mcc[1], + rr_data->ms_data.plmn.mcc[2], + rr_data->ms_data.plmn.mnc[0], + rr_data->ms_data.plmn.mnc[1], + rr_data->ms_data.plmn.mnc[2]); + + switch(gprs_state) + { + case GPRS_PAM_PBCCH: + case GPRS_ACTIVATED: + case GPRS_PIM_PBCCH: + case GPRS_PTM_PBCCH: + case GPRS_SUSPENDED_PBCCH: + switch(cr_req->cr_type) + { + case CR_NEW: + { + UBYTE i; + UBYTE found=0; + for(i=0; i<6;i++) + { + if(rr_data->nc_data[i].arfcn EQ cr_req->arfcn AND + rr_data->nc_data[i].bsic EQ cr_req->bsic) + { + found=1; + break; + } + } + + if(!found) { TRACE_ERROR("cr_req(NEW): data does not match");} + + memset (&rr_data->nc_data[CR_INDEX], + 0, + sizeof (T_NC_DATA)); + rr_data->gprs_data.cr_pbcch_active = TRUE; + rr_data->nc_data[CR_INDEX].arfcn = cr_req->arfcn; + rr_data->nc_data[CR_INDEX].bsic = cr_req->bsic; + + if (rr_data->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI) + { + /*inform MM and stop everything*/ + /* + * send Please Retry to the MMI + */ + rr_data->sc_data.found_entries = 0; + att_code_rr_abort_ind (RRCS_ABORT_CEL_SEL_FAIL); + } + + if( ! rr_data->gprs_data.cr_pcco_active ) + att_start_cell_reselection_pbcch(MODE_CELL_RESELECTION); + else + { + att_init_cell_selection(CELL_RESELECTION, RR_ORIGINATED); + rr_data->dyn_config.fcr = 0; + rr_data->dyn_config.scr = 0; + rr_data->bcch_error = 0; + rr_data->pag_rec = FALSE; + srv_clear_stored_prim (MPH_PAGING_IND); + gprs_init_data_cr(); + dat_att_null(); + + SET_STATE (STATE_ATT, ATT_CS3); + att_build_idle_req (CR_INDEX, MODE_CELL_RESELECTION); + } + break; + } + case CR_NEW_NOT_SYNCED: + { + /* + * a Packet Cell Change Order for a cell which + * is not in the BA list has been requested by the NW + */ + PALLOC (mph_bsic_req, MPH_BSIC_REQ); + { + PALLOC (mph_sync_req, MPH_SYNC_REQ); + mph_sync_req->cs = CS_START_PCCO; + PSENDX (PL, mph_sync_req); + } + TRACE_EVENT("cco w/ not synced"); + + /* + * remember we got a CR_REQ, will be used + * on reception of the BSIC_CNF and the UNITDATA_IND + */ + rr_data->gprs_data.cr_pbcch_active = TRUE; + SET_STATE (STATE_CELL_SEL, CS_CCO); + /* avoid reacting to PAGINGs and ESTABLISH_REQ */ + dat_att_null(); + SET_STATE (STATE_ATT, ATT_CS3); + + cs_set_all(); + rr_data->gprs_data.bsic = cr_req->bsic; + rr_data->gprs_data.arfcn = mph_bsic_req->arfcn = cr_req->arfcn; + PSENDX (PL, mph_bsic_req); + } + break; + case CR_CS: + if (rr_data->gprs_data.cr_pcco_active EQ FALSE) + rr_data->gprs_data.cr_pbcch_active = TRUE; + else + rr_data->gprs_data.cr_pcco_active = FALSE; + + + if (rr_data->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI) + { + /*inform MM and stop everything*/ + /* + * send Please Retry to the MMI + */ + rr_data->sc_data.found_entries = 0; + att_code_rr_abort_ind (RRCS_ABORT_CEL_SEL_FAIL); + } + /*XY:n don't inform GRR */ + att_start_cell_selection(RR_ORIGINATED, CS_NOT_PARALLEL,NORMAL_SEARCH_MODE); + break; + case CR_CONT: + att_continue_cell_reselect (); + break; + case CR_COMPLETE: + /* + * we have a PBCCH and GRR has read it + * we inform MM now + */ + if( rr_data->gprs_data.cr_pcco_active EQ FALSE ) + { + PALLOC(mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); + mph_mon_ctrl_req->action = ENTER_PIM_PBCCH; + PSENDX (PL, mph_mon_ctrl_req); + } + rr_data->gprs_data.cr_pcco_active = FALSE; + + /* initialize the ba_bcch_modified value when Cell reselection is done */ + rr_data->gprs_data.ba_bcch_modified= FALSE; + + dat_att_cell_selected (); + SET_STATE (STATE_ATT, ATT_IDLE); + dat_send_bcchinfo_mm (rr_data->cr_data.cr_white_list.si2); + + + + if(rr_data->ms_data.rr_service EQ LIMITED_SERVICE AND + rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH) + { + att_copy_old_lai_rac(SC_INDEX); +#if 0 + memcpy (&rr_data->old_lai, &rr_data->nc_data[SC_INDEX].lai, + sizeof(T_loc_area_ident)); + rr_data->old_cell_id = rr_data->nc_data[SC_INDEX].cell_id; +#endif + att_code_rr_abort_ind (RRCS_ABORT_CEL_SEL_FAIL); + } + else + { + if (rr_data->sc_data.mm_started) + att_code_rr_act_cnf (); + else + att_code_rr_act_ind (); + } + + /* + * This instruction disdurbs test case 20.7 + * unclear why it is coded here + * + rr_data->first_meas_received = TRUE; + TRACE_EVENT("first_meas_received set to TRUE(rr_attg.c)"); + */ + /* + * Start registration timer if needed + */ + att_start_registration_timer (); + att_mph_identity_req (); +#ifdef REL99 + if(rr_data->ms_data.rr_service EQ FULL_SERVICE) att_config_cbch (); +#else + if(rr_data->ms_data.rr_service EQ FULL_SERVICE) att_build_cbch (); +#endif + srv_use_stored_prim (); + /* + * if the cell reselection has been started after a dedicated connection + * attempt with failed SABM / UA content a second attempt is started + * immediately. + */ + if (rr_data->repeat_est) + { + rr_data->repeat_est = FALSE; + dat_start_immediate_assign (rr_data->ms_data.establish_cause); + } + break; + default: + break; + + } + break; + case GPRS_PTM_BCCH: + if( (cr_req->cr_type EQ CR_NEW) || + (cr_req->cr_type EQ CR_NEW_NOT_SYNCED)) + { + UBYTE i; + UBYTE found=0; + for(i=0; i<6;i++) + { + if(rr_data->nc_data[i].arfcn EQ cr_req->arfcn AND + rr_data->nc_data[i].bsic EQ cr_req->bsic) + { + found=1; + break; + } + } + memset (&rr_data->nc_data[CR_INDEX], 0, sizeof (T_NC_DATA)); + rr_data->nc_data[CR_INDEX].arfcn = cr_req->arfcn; + rr_data->nc_data[CR_INDEX].bsic = cr_req->bsic; + if (rr_data->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI) + { + /*inform MM and stop everything*/ + /* + * send Please Retry to the MMI + */ + rr_data->sc_data.found_entries = 0; + att_code_rr_abort_ind (RRCS_ABORT_CEL_SEL_FAIL); + } + + rr_data->gprs_data.cr_pcco_active = TRUE; + + if(!found) + { + /* + * a Packet Cell Change Order for a cell which + * is not in the BA list has been requested by the NW + */ + PALLOC (mph_bsic_req, MPH_BSIC_REQ); + { + PALLOC (mph_sync_req, MPH_SYNC_REQ); + mph_sync_req->cs = CS_START_PCCO; + PSENDX (PL, mph_sync_req); + } + TRACE_EVENT("cco w/ not synced"); + + + SET_STATE (STATE_CELL_SEL, CS_CCO); + /* avoid reacting to PAGINGs and ESTABLISH_REQ */ + dat_att_null(); + SET_STATE (STATE_ATT, ATT_CS3); + + cs_set_all(); + rr_data->gprs_data.bsic = cr_req->bsic; + rr_data->gprs_data.arfcn = mph_bsic_req->arfcn = cr_req->arfcn; + PSENDX (PL, mph_bsic_req); + } + else + { + att_init_cell_selection(CELL_RESELECTION, RR_ORIGINATED); + rr_data->dyn_config.fcr = 0; + rr_data->dyn_config.scr = 0; + rr_data->bcch_error = 0; + rr_data->pag_rec = FALSE; + srv_clear_stored_prim (MPH_PAGING_IND); + gprs_init_data_cr(); + dat_att_null(); + + SET_STATE (STATE_ATT, ATT_CS3); + att_build_idle_req (CR_INDEX, MODE_CELL_RESELECTION); + } + } + break; + case GPRS_PIM_BCCH: + /* + * we have a BCCH + * we have informed GRR of this (with additional info that we + * have Full or Limited service) + * we inform MM now + */ + switch(cr_req->cr_type) + { + case CR_COMPLETE: + case CR_NEW: + case CR_NEW_NOT_SYNCED: + case CR_CS: + case CR_CONT: + dat_att_cell_selected (); + SET_STATE (STATE_ATT, ATT_IDLE); + dat_send_bcchinfo_mm (rr_data->cr_data.cr_white_list.si2); + + if(rr_data->ms_data.rr_service EQ LIMITED_SERVICE AND + rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH) + { + + att_copy_old_lai_rac(SC_INDEX); +#if 0 + memcpy (&rr_data->old_lai, &rr_data->nc_data[SC_INDEX].lai, + sizeof(T_loc_area_ident)); + rr_data->old_cell_id = rr_data->nc_data[SC_INDEX].cell_id; +#endif + att_code_rr_abort_ind (RRCS_ABORT_CEL_SEL_FAIL); + } + else + { + if (rr_data->sc_data.mm_started) + att_code_rr_act_cnf (); + else + att_code_rr_act_ind (); + } + + /* + * Start registration timer if needed + */ + att_start_registration_timer (); + att_mph_identity_req (); + srv_use_stored_prim (); + /* + * if the cell reselection has been started after a dedicated connection + * attempt with failed SABM / UA content a second attempt is started + * immediately. + */ + if (rr_data->repeat_est) + { + rr_data->repeat_est = FALSE; + dat_start_immediate_assign (rr_data->ms_data.establish_cause); + } + break; + default: + break; + } + break; + case GPRS_PAM_BCCH: + TRACE_EVENT("CR during PA"); + break; + default: + break; + } + PFREE (cr_req); +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_rrgrr_stop_mon_ccch_req | ++-----------------------------------------------------------------------------+ + + PURPOSE : Process the primitive RRGRR_STOP_MON_CCCH_REQ received from GRR. + This primitive indicates to the RR that the monitoring of CCCH + should be stopped. This is only a signal, no parameters needed. + This signal is forwarded to ALR. + +*/ +/* + * This is reqiured for Testmode A + */ +/*lint -esym(526,grlc_test_mode_active) : not defined | defined in GRR */ +EXTERN UBYTE grlc_test_mode_active(void); + +void att_rrgrr_stop_mon_ccch_req (T_RRGRR_STOP_MON_CCCH_REQ* stop_mon) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("att_rrgrr_stop_mon_ccch_req ()"); + + switch(GET_STATE(STATE_GPRS)) + { + /* + * This case is necessary to stop ccch monitoring in STATE_GPRS=GPRS_PTM + * during Testmode A/B + */ + case GPRS_PTM_BCCH: + if(grlc_test_mode_active()) + { + PALLOC(mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); + mph_mon_ctrl_req->action = STOP_MON_CCCH; + PSENDX (PL, mph_mon_ctrl_req); + TRACE_EVENT("STOP_MON_CCCH during TESTMODE !!"); + } + break; + case GPRS_PIM_BCCH: + case GPRS_PIM_PBCCH: + case GPRS_PAM_PBCCH: + case GPRS_PTM_PBCCH: + case GPRS_PAM_BCCH: + TRACE_EVENT("stop ccch"); + break; + default: + break; + } + + PFREE (stop_mon); +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_rrgrr_start_mon_ccch_req | ++-----------------------------------------------------------------------------+ + + PURPOSE : Process the primitive RRGRR_START_MON_CCCH_REQ received from GRR. + This primitive indicates to the RR that the monitoring of CCCH + should be started. This is only a signal, no parameters needed. + This signal is forwarded to ALR. + +*/ +void att_rrgrr_start_mon_ccch_req (T_RRGRR_START_MON_CCCH_REQ* + mon_req) +{ + GET_INSTANCE_DATA; + TRACE_EVENT ("att_rrgrr_start_mon_ccch_req ()"); + /* + * store split paging cycle + */ + if (mon_req->split_pg EQ RRGRR_NO_DRX) + rr_data->gprs_data.split_pg=256; + else + rr_data->gprs_data.split_pg=mon_req->split_pg; + + switch(GET_STATE(STATE_GPRS)) + { + case GPRS_PIM_BCCH: + TRACE_EVENT("GPRS_PIM_BCCH"); + if(mon_req->pag_mode EQ PAG_MODE_DEFAULT AND + rr_data->gprs_data.page_mode EQ PAG_MODE_REORG) + { + /* + * go back to normal page mode + */ + rr_data->gprs_data.page_mode = PAG_MODE_DEFAULT; + att_build_idle_req (SC_INDEX, MODE_SYS_INFO_CHANGE); + } + if(mon_req->pag_mode EQ PAG_MODE_PTM_NP) + { + /* + * we may have received dl assignment in reog idle mode + * we shopuld directly switch to transfer mode with: + * NORMAL_PAGING + */ + SET_STATE(STATE_GPRS, GPRS_PTM_BCCH); + SET_STATE(STATE_ATT, ATT_IDLE); + SET_STATE(STATE_DAT, DAT_IDLE); + + att_build_idle_req(SC_INDEX, MODE_PACKET_TRANSFER); + { + PALLOC(mon_ctrl, MPH_MON_CTRL_REQ); + mon_ctrl->action = START_MON_CCCH; + mon_ctrl->si_to_read = 0; + PSENDX(PL, mon_ctrl); + } + } + break; + case GPRS_PTM_BCCH: + /* + * set page_mode to REORG if NON_DRX_TIMER is used + * set page_mode to DEFAULT if NON_DRX_TIMER is not used or 0 + */ + TRACE_EVENT("GPRS_PTM"); + if(mon_req->pag_mode EQ PAG_MODE_PTM_NP) + { + PALLOC(mon_ctrl, MPH_MON_CTRL_REQ); + mon_ctrl->action = START_MON_CCCH; + mon_ctrl->si_to_read = 0; + PSENDX(PL, mon_ctrl); + } + else if(mon_req->pag_mode EQ PAG_MODE_PIM_NP) + { + /* + * Go into idle mode but start ONLY CCCH reading with the following order: + * start with REORG and then switch to NORMAL paging + */ + TRACE_EVENT("PTM->IDLE: CCCH reorg+normal"); + } + else + { + rr_data->gprs_data.page_mode = mon_req->pag_mode; + SET_STATE (STATE_GPRS, GPRS_PIM_BCCH); + att_return_to_idle(); + + /* Transition from PTM to PIM state. PBCCH is not present in the + * cell. Check if the previous PTM state was used for routing Area update. + * start black list search to look for inactive carriers + * Cell-Selection Improvement LLD - 4.1.4.3 + */ + if((rr_data->ms_data.establish_cause EQ ESTCS_GPRS_1P) AND + (rr_data->cs_data.black_list_search_pending EQ TRUE)) + { + + rr_data->cs_data.black_list_search_pending = FALSE; + + if(cs_check_region(rr_data->cs_data.region)) + { + /* Do not start Black list search,when Black list database is empty */ +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + if (rr_data->cs_data.region EQ BOTH_REGIONS) + { + if(srv_is_list_set(&rr_data->cs_data.black_list.list[EUROPEAN_REGION]) OR + srv_is_list_set(&rr_data->cs_data.black_list.list[AMERICAN_REGION])) + { + att_start_cell_selection(RR_ORIGINATED,CS_PARALLEL,BLACK_LIST_SEARCH_MODE); + } + else + { + TRACE_EVENT("Black List empty"); + } + } +#else + if(srv_is_list_set( + &rr_data->cs_data.black_list.list[rr_data->cs_data.region])) + { + att_start_cell_selection(RR_ORIGINATED,CS_PARALLEL,BLACK_LIST_SEARCH_MODE); + } +#endif + else + { +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + if(srv_is_list_set( + &rr_data->cs_data.black_list.list[rr_data->cs_data.region])) + { + att_start_cell_selection(RR_ORIGINATED,CS_PARALLEL,BLACK_LIST_SEARCH_MODE); + } + else +#endif + { + TRACE_EVENT("Black List empty"); + } + } + } + } + } + break; + case GPRS_PAM_BCCH: + rr_data->gprs_data.page_mode = mon_req->pag_mode; + SET_STATE (STATE_GPRS, GPRS_PIM_BCCH); + att_return_to_idle(); + break; + case GPRS_PAM_PBCCH: + //break; + case GPRS_PTM_PBCCH: + case GPRS_PIM_PBCCH: + { + PALLOC(mon_ctrl, MPH_MON_CTRL_REQ); + mon_ctrl->action = START_MON_CCCH; + mon_ctrl->si_to_read = 0; + + PSENDX(PL, mon_ctrl); + SET_STATE(STATE_DAT, DAT_IDLE); /* allow reception of pagings */ + } + break; + default: + TRACE_EVENT("start_mon_ccch_req not handled"); + break; + } + PFREE (mon_req); +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_rrgrr_start_mon_bcch_req | ++-----------------------------------------------------------------------------+ + + PURPOSE : Process the primitive RRGRR_START_MON_BCCH_REQ received from GRR. + This primitive indicates to the RR to read SI. This primitive + contains the parameter which indicates to the SI to read on BCCH. + This signal is forwarded to ALR. + +*/ +void att_rrgrr_start_mon_bcch_req (T_RRGRR_START_MON_BCCH_REQ + *rrgrr_start_mon_bcch_req) +{ + GET_INSTANCE_DATA; + TRACE_EVENT ("att_rrgrr_start_mon_bcch_req ()"); + switch (GET_STATE(STATE_GPRS)) + { + case GPRS_PIM_BCCH: + case GPRS_PIM_PBCCH: + case GPRS_PAM_PBCCH: + case GPRS_PTM_PBCCH: + case GPRS_PTM_BCCH: + { + UBYTE si_to_read = rrgrr_start_mon_bcch_req->si_to_read; + USHORT sys_info_read = rr_data->sc_data.cd.sys_info_read; + PALLOC ( mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); + + TRACE_EVENT_P1 ( "rrgrr_start_mon_bcch_req->si_to_read = %d", + rrgrr_start_mon_bcch_req->si_to_read ); + + mph_mon_ctrl_req->action = START_MON_NBCCH; + switch ( si_to_read ) + { + case UNSPECIFIED_SI: + sys_info_read = 0; + break; + case UPDATE_SI1: + sys_info_read &= ~ SYS_INFO_1_READ; + break; + case UPDATE_SI2_SI2BIS_OR_SI2TER: + sys_info_read &= ~ (SYS_INFO_2_READ | SYS_INFO_2BIS_READ | SYS_INFO_2TER_READ); +#if defined (REL99) AND defined (TI_PS_FF_EMR) + /*Once SI-2,2Bis,2Ter are read, we can configure ALR for acquiring SI-2quater*/ + if ( (rr_data->sc_data.cd.si2quater_status NEQ SI2QUATER_ABSENT ) AND + (rr_data->sc_data.cd.si2quater_pos EQ SI2QUATER_ON_EBCCH) ) + rr_data->sc_data.cd.si2quater_status = SI2QUATER_CONFIGURE; +#endif + break; + case UPDATE_SI3_SI4_SI7_OR_SI8: + sys_info_read &= ~ (SYS_INFO_3_READ | SYS_INFO_4_READ ); + break; + case UPDATE_SI9: + /* no support of SI 9 */ + break; + case COMPLETE_SI: + sys_info_read = 0; + break; + case UPDATE_SI13: + sys_info_read &= ~ SYS_INFO_13_READ; + if(rr_data->nc_data[SC_INDEX].si13_loc_ind EQ EXTENDED_BCCH) + { + mph_mon_ctrl_req->action = START_MON_EBCCH; + } + break; + default: + break; + } + rr_data->sc_data.cd.sys_info_read = sys_info_read; + TRACE_EVENT_P1("st_bcch:sys_info_read %d", + rr_data->sc_data.cd.sys_info_read); + mph_mon_ctrl_req->si_to_read = si_to_read; + PSENDX (PL, mph_mon_ctrl_req); + } + break; + case GPRS_ACTIVATED: + if(GET_STATE(STATE_ATT) EQ ATT_IDLE) + att_signal_gprs_support(); + break; + default: + break; + } + PFREE (rrgrr_start_mon_bcch_req); +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_convert_idle_c31_cr | ++-----------------------------------------------------------------------------+ + + PURPOSE : + +*/ +GLOBAL void att_convert_idle_c31_cr(UBYTE index) +{ + GET_INSTANCE_DATA; + TRACE_EVENT_P2("att_convert_idle_c31_cr called for index=%d conversion = %d", index, + rr_data->nc_data[index].v_cr_par); + switch(rr_data->nc_data[index].v_cr_par) + { + case CR_PAR_VALID: + + /* + * For the first neighbour cell in the message where the struct exists, + * the following default values shall be used for missing parameters: + * GPRS_RXLEV_ACCESS_MIN = Serving cell RXLEV_ACCESS_MIN + * GPRS_MS_TXPWR_MAX_CCH = Serving cell MS_TXPWR_MAX_CCH + * GPRS_TEMPORARY_OFFSET = Serving cell TEMPORARY_OFFSET + * GPRS_PENALTY_TIME = Serving cell PENALTY_TIME + * GPRS_RESELECT_OFFSET = 0 + * HCS_THR = infinity + * PRIORITY_CLASS = undefined + * SI13_PBCCH_LOCATION = undefined + * + */ + if( rr_data->nc_data[index].cr_par.gprs_rxlev_access_min EQ + GPRS_RXLEV_ACCESS_MIN_INVALID) + rr_data->nc_data[index].cr_par.gprs_rxlev_access_min = + rr_data->nc_data[SC_INDEX].select_para.rxlev_access_min; + + if(rr_data->nc_data[index].cr_par.gprs_ms_txpwr_max_cch EQ + GPRS_MS_TXPWR_MAX_CCH_INVALID) + rr_data->nc_data[index].cr_par.gprs_ms_txpwr_max_cch = + rr_data->nc_data[SC_INDEX].select_para.ms_txpwr_max_cch; + + if(rr_data->nc_data[index].cr_par.gprs_temporary_offset EQ + GPRS_TEMPORARY_OFFSET_INVALID) + rr_data->nc_data[index].cr_par.gprs_temporary_offset = + rr_data->nc_data[SC_INDEX].c2_par.temp_offset; + + if(rr_data->nc_data[index].cr_par.gprs_penalty_time EQ + GPRS_PENALTY_TIME_INVALID) + rr_data->nc_data[index].cr_par.gprs_penalty_time = + rr_data->nc_data[SC_INDEX].c2_par.penalty_time * 2; + + if(rr_data->nc_data[index].cr_par.gprs_reselect_offset EQ + GPRS_RESEL_OFF_INVALID) + rr_data->nc_data[index].cr_par.gprs_reselect_offset = + GPRS_RESEL_OFF_DEFAULT; + + /* + * 31 is the maximum 5 bit value. + * hcs_thr = 31 , means infinity + */ + if(rr_data->nc_data[index].cr_par.hcs_thr EQ + GPRS_HCS_THR_INVALID) + { + rr_data->nc_data[index].cr_par.hcs_thr = 31; + } + /* priority class remains undefined */ + break; + case CR_PAR_INVALID: + /* + * initialise values + * conversion of idle mode parameters to GPRS cell reselection parameters + * GPRS_RXLEV_ACCESS_MIN = RXLEV_ACCESS_MIN + * GPRS_MS_TXPWR_MAX_CCH = MS_TXPWR_MAX_CCH + * C31 = 0 + * GPRS_RESELECT_OFFSET(n) = + * CELL_RESELECT_OFFSET(n) - CELL_RESELECT_OFFSET(s) + * GPRS_TEMPORARY_OFFSET = TEMPORARY OFFSET + * GPRS_PENALTY_TIME = PENALTY_TIME + * PRIORITY_CLASS = 0 + * C32_QUAL = 0 + * GPRS_CELL_RESELECT_HYSTERESIS = CELL_RESELECT_HYSTERESIS + * RA_RESELECT_HYSTERESIS = CELL_RESELECT_HYSTERESIS + */ + + rr_data->nc_data[index].cr_par.gprs_rxlev_access_min = + rr_data->nc_data[index].select_para.rxlev_access_min; + rr_data->nc_data[index].cr_par.gprs_ms_txpwr_max_cch = + rr_data->nc_data[index].select_para.ms_txpwr_max_cch; + + /* + * NOTE: If PENALTY_TIME = 11111 for a cell, + * the sign of CELL_RESELECT_OFFSET shall be changed + * and TEMPORARY OFFSET set to 0 for that cell. + */ + if( rr_data->nc_data[index].c2_par.penalty_time EQ 31) + { + rr_data->nc_data[index].cr_par.gprs_temporary_offset = + GPRS_RESEL_OFF_DEFAULT; + } + else + { + rr_data->nc_data[index].cr_par.gprs_temporary_offset = + rr_data->nc_data[index].c2_par.temp_offset; + } + + rr_data->nc_data[index].cr_par.priority_class = 0; + rr_data->nc_data[index].cr_par.gprs_penalty_time = + rr_data->nc_data[index].c2_par.penalty_time; + rr_data->nc_data[index].cr_par.gprs_penalty_time *= 2; + + if( rr_data->nc_data[index].bcch_status NEQ DECODED ) + TRACE_EVENT_P1("Error BCCH in NOT DECODED for arfcn %d in att_convert_idle_cr" , + rr_data->nc_data[index].arfcn); + break; + default : + break; + + } +} +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_ATT | +| STATE : code ROUTINE : att_insert_c31_cr_data_in_cell | ++--------------------------------------------------------------------+ + + PURPOSE : To store T_cr_par in rr_data->nc_data + +*/ + +GLOBAL void att_insert_c31_cr_data_in_cell (UBYTE index) +{ + GET_INSTANCE_DATA; + UBYTE i; + TRACE_EVENT_P1("att_insert_c31_cr_data_in_cell called for arfcn=%d" , + rr_data->nc_data[index].arfcn ); + + + rr_data->nc_data[index].v_cr_par = CR_PAR_INVALID; + for( i = 0; i < rr_data->gprs_data.num_add_freq_list; i++ ) + { + if( rr_data->nc_data[index].arfcn EQ rr_data->gprs_data.add_freq_lists[i].arfcn ) + { + if( rr_data->gprs_data.add_freq_lists[i].v_cr_par ) + { + TRACE_EVENT_P2(" Cr_par found for arfcn =%d, index in add freq list = %d", + rr_data->nc_data[index].arfcn, i); + rr_data->nc_data[index].v_cr_par = CR_PAR_VALID; + memcpy( & (rr_data->nc_data[index].cr_par), + & (rr_data->gprs_data.add_freq_lists[i].cr_par), + sizeof( T_cr_par) ); + att_convert_idle_c31_cr(index); + } + else + { + TRACE_EVENT_P1("Cr_par found for arfcn =%d in add freq list", rr_data->nc_data[index].arfcn); + if( rr_data->nc_data[index].bcch_status EQ DECODED) + att_convert_idle_c31_cr(index); + } + return; + } + } + if( rr_data->nc_data[index].bcch_status EQ DECODED) + att_convert_idle_c31_cr(index); +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_init_c31_cr_par | ++-----------------------------------------------------------------------------+ + + PURPOSE : + +*/ +static void att_init_nc_data_c31_cr_par(void) +{ + GET_INSTANCE_DATA; + UBYTE index = 0; + TRACE_EVENT(" att_init_nc_data_c31_cr_par called"); + for(index = 0; index <= SC_INDEX; index++) + { + rr_data->nc_data[index].v_cr_par = CR_PAR_INVALID; + + if( rr_data->nc_data[index].bcch_status NEQ EMPTY ) + { + att_insert_c31_cr_data_in_cell(index); + } + } +} + + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_init_cr_c31_data | ++-----------------------------------------------------------------------------+ + + PURPOSE : + +*/ +static void att_init_cr_c31_data(void) +{ + GET_INSTANCE_DATA; + UBYTE i = 0; + UBYTE first_valid_par = 0; + UBYTE valid_found = FALSE; + + for( ; (i < rr_data->gprs_data.num_add_freq_list) AND (valid_found EQ FALSE) ; i++) + { + if( rr_data->gprs_data.add_freq_lists[i].v_cr_par) + { + valid_found = TRUE; + first_valid_par = i; + } + } + + if( valid_found ) + { + for( i = first_valid_par + 1 ; i < rr_data->gprs_data.num_add_freq_list ; i++) + { + if( rr_data->gprs_data.add_freq_lists[i].v_cr_par EQ FALSE ) + { + /* entire structure is missing */ + rr_data->gprs_data.add_freq_lists[i].v_cr_par = TRUE; + memcpy(& (rr_data->gprs_data.add_freq_lists[i].cr_par), + & (rr_data->gprs_data.add_freq_lists[i-1].cr_par), sizeof(T_cr_par)); + } + else + { + /* a part of the structure may be missing */ + if( rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_rxlev_access_min EQ + GPRS_RXLEV_ACCESS_MIN_INVALID) + rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_rxlev_access_min = + rr_data->gprs_data.add_freq_lists[i-1].cr_par.gprs_rxlev_access_min; + + if(rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_ms_txpwr_max_cch EQ + GPRS_MS_TXPWR_MAX_CCH_INVALID) + rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_ms_txpwr_max_cch = + rr_data->gprs_data.add_freq_lists[i-1].cr_par.gprs_ms_txpwr_max_cch; + + if(rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_temporary_offset EQ + GPRS_TEMPORARY_OFFSET_INVALID ) + rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_temporary_offset = + rr_data->gprs_data.add_freq_lists[i-1].cr_par.gprs_temporary_offset; + + if(rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_penalty_time EQ + GPRS_PENALTY_TIME_INVALID) + rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_penalty_time = + rr_data->gprs_data.add_freq_lists[i-1].cr_par.gprs_penalty_time; + + if(rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_reselect_offset EQ + GPRS_RESEL_OFF_INVALID) + rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_reselect_offset = + rr_data->gprs_data.add_freq_lists[i-1].cr_par.gprs_reselect_offset; + + if(rr_data->gprs_data.add_freq_lists[i].cr_par.hcs_thr EQ + GPRS_HCS_THR_INVALID ) + rr_data->gprs_data.add_freq_lists[i].cr_par.hcs_thr = + rr_data->gprs_data.add_freq_lists[i-1].cr_par.hcs_thr; + + if(rr_data->gprs_data.add_freq_lists[i].cr_par.priority_class EQ + GPRS_PRIORITY_CLASS_INVALID) + rr_data->gprs_data.add_freq_lists[i].cr_par.priority_class = + rr_data->gprs_data.add_freq_lists[i-1].cr_par.priority_class; + + if(rr_data->gprs_data.add_freq_lists[i].cr_par.si13_location EQ + SI13_LOC_INVALID) + rr_data->gprs_data.add_freq_lists[i].cr_par.si13_location = + rr_data->gprs_data.add_freq_lists[i-1].cr_par.si13_location; + + if(rr_data->gprs_data.add_freq_lists[i].cr_par.psi1_repeat_period EQ + PSI1_RPT_PRD_INVALID ) + rr_data->gprs_data.add_freq_lists[i].cr_par.psi1_repeat_period = + rr_data->gprs_data.add_freq_lists[i-1].cr_par.psi1_repeat_period; + + if(rr_data->gprs_data.add_freq_lists[i].cr_par.pbcch_location EQ + PBCCH_LOC_INVALID ) + rr_data->gprs_data.add_freq_lists[i].cr_par.pbcch_location = + rr_data->gprs_data.add_freq_lists[i-1].cr_par.pbcch_location; + + } + } + } + +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_ATT | +| STATE : code ROUTINE : att_calculate_c31_c32 | ++--------------------------------------------------------------------+ + + PURPOSE : calculates C31 and C32 criterion of cell reselection is still valid. + +*/ + +GLOBAL void att_calculate_c31_c32 (UBYTE index) +{ + GET_INSTANCE_DATA; + USHORT h; + T_NC_DATA *rrd; + T_NC_DATA *sc_ptr; + + UBYTE prios, prion; + /*lint -esym(526,p_res_off) : not defined | defined in GRR */ + extern const SHORT p_res_off[]; + + /* C1 = A - MAX(B,0) */ + /* A = RLA_P - GPRS_RXLEV _ACCESS_MIN */ + /* B = GPRS_MS_TXPWR_MAX_CCH - P */ + /* P = max MS RF output power */ + + /* C31 = RLA_P(s) - HCS_THR(s) (serving cell) */ + /* C31 = RLA_P(n) - HCS_THR(n) - TO(n)*L(n) (neighbour cell) */ + /* TO(n) = GPRS_TEMPORARY_OFFSET(n) * H( GPRS_PENALTY_TIME(N) - T(n) ) */ + /* L(n) = 0 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s) */ + /* 1 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s) */ + + /* C32(s) = C1(s) */ + /* C32(n) = C1(n) + GPRS_RESELECT OFFSET(n) - TO(n)*(1-L(n)) */ + /* TO(n) = GPRS_TEMPORARY_OFFSET(n) * H( GPRS_PENALTY_TIME(N) - T(n) ) */ + /* L(n) = 0 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s) */ + /* 1 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s) */ + /* H(n) = 0 for x < 0 */ + /* 1 for x >= 0 */ + + TRACE_FUNCTION ("att_calculate_c31_c32()"); + + /* + * get a pointer to the data of the cell + */ + rrd = &(rr_data->nc_data[index]); + + att_calculate_c1(index); + + TRACE_EVENT_P5("arfcn = %d, C1 = %d, rxlev = %d, GPRS_RXLEV _ACCESS_MIN = %d, GPRS_MS_TXPWR_MAX_CCH = %d", + rrd->arfcn, rrd->c1, + rrd->rxlev, + rrd->cr_par.gprs_rxlev_access_min, + rrd->cr_par.gprs_ms_txpwr_max_cch); + + TRACE_EVENT_P3 ("hcs thr = %d, prion = %d, valid = %d", + rrd->cr_par.hcs_thr, rrd->cr_par.priority_class , rrd->v_cr_par); + + if( rrd->v_cr_par EQ CR_PAR_INVALID) + { + rrd->c31 = 0; /* conversion of idle mode to GPRS cell reselection parameters */ + } + else + { + rrd->c31 = rrd->rxlev; + if( rrd->cr_par.hcs_thr NEQ 31 ) + rrd->c31 -= ( 2 * rrd->cr_par.hcs_thr ); + else + rrd->c31 = -32768; + } + + rrd->c32 = rrd->c1; + + /* C31 = RLA_P(s) - HCS_THR(s) (serving cell) */ + /* C32(s) = C1(s) */ + + TRACE_EVENT_P1("C31 = %d", rrd->c31); + + if( index EQ SC_INDEX ) + return; + + sc_ptr = &rr_data->nc_data[SC_INDEX]; + prios = (sc_ptr->cr_par.priority_class NEQ GPRS_PRIORITY_CLASS_INVALID) ? + sc_ptr->cr_par.priority_class : (UBYTE) 0; + + prion = (rrd->cr_par.priority_class NEQ GPRS_PRIORITY_CLASS_INVALID ) ? + rrd->cr_par.priority_class : (UBYTE) 0; + + if( rr_data->nc_data[index].v_cr_par EQ CR_PAR_INVALID) + { + /* + * conversion of idle mode paramter to GPRS cell reselection parameters. + * the conversion for GPRS_RESELECTION_OFFSET is done here. + * the coversion of other parameters are done as + * part of the function att_calculate_c1() + * + * GPRS_RESELECT_OFFSET(n) = + * CELL_RESELECT_OFFSET(n) - CELL_RESELECT_OFFSET(s) + * + * NOTE: If PENALTY_TIME = 11111 for a cell, + * the sign of CELL_RESELECT_OFFSET shall be changed + * + */ + SHORT nc_sign = 1; + SHORT sc_sign = 1; + + + if(rrd->cr_par.gprs_penalty_time EQ 31 ) + { + nc_sign = -1; + } + if(sc_ptr->cr_par.gprs_penalty_time EQ 31 ) + { + sc_sign = -1; + } + rrd->c32 += (USHORT)(nc_sign * 2 * rrd->c2_par.cell_reselect_offset ) - + (USHORT)(sc_sign * 2 * sc_ptr->c2_par.cell_reselect_offset); + TRACE_EVENT_P5(" nc_sign =%d, sc_sign =%d, nc_rese_off=%d, sc_res_off=%d, c31=%d", + nc_sign, sc_sign, rrd->c2_par.cell_reselect_offset, sc_ptr->c2_par.cell_reselect_offset, + rrd->c32); + } + else + { + /* a valid paramter for GPRS_RESELECT_OFFSET is received */ + rrd->c32 += p_res_off[rrd->cr_par.gprs_reselect_offset]; + TRACE_EVENT_P3(" gprs_reselect_offset = %d, c32 = %d, res off index =%d", + p_res_off[rrd->cr_par.gprs_reselect_offset], rrd->c32, rrd->cr_par.gprs_reselect_offset); + } + /* c32_qual is not known, if there is no PCCCH */ + + + /* + * Calculate x for H(x) and set H(x) + */ + TRACE_EVENT_P2("penalty time = %d, avail time = %d", (rrd->cr_par.gprs_penalty_time + 1) * 10, rrd->avail_time/PERIOD_1_SEC ); + if ((USHORT)((rrd->cr_par.gprs_penalty_time + 1) * 10) >= + (USHORT)(rrd->avail_time/PERIOD_1_SEC)) + h = TRUE; + else + h = FALSE; + + if (h) + { + SHORT *criterion; + TRACE_EVENT_P3("penalty timer not expired: %d offset will be applied to (prios)%d NEQ (prion)%d (if 0 c31, if 1 C32 )", + 10 * rrd->cr_par.gprs_temporary_offset, + prios, prion); + if( prios NEQ prion ) + { + criterion = & (rrd->c31); + } + else + { + criterion = & (rrd->c32); + } + if( rrd->cr_par.gprs_temporary_offset EQ 7 ) + { + *criterion = -32768; + } + else + { + *criterion -= 10 * rrd->cr_par.gprs_temporary_offset; + } + } + else + { + TRACE_EVENT("penalty timer expired"); + } + if( rrd->cr_par.same_ra_as_serving_cell NEQ SAME_RA_AS_SCELL) + { + TRACE_EVENT(" cell is NOT SAME_RA_AS_SCELL"); + rrd->c32 -= 2 * rrd->select_para.cell_resel_hyst ; + } + else if(rr_data->gprs_data.ready_state) + { + /* MS in ready state*/ + TRACE_EVENT(" MS in ready state"); + rrd->c32 -= (SHORT)2 * rrd->select_para.cell_resel_hyst ; + /* C31 hyst not known */ + } + if ( IS_TIMER_ACTIVE (T_NO_RESELECT) ) + { + rrd->c32 -= 5; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_ATT | +| STATE : code ROUTINE : att_get_next_best_c32_index | ++--------------------------------------------------------------------+ + + PURPOSE : This function returns the index of a target cell, for reselection. + If no target cell is available then NO_AVAILABLE is returned. + The parameter c31_calculated, indicates if C31 and C32 are already calculated. + +*/ +GLOBAL UBYTE att_get_next_best_c32_index (BOOL c31_calculated) + { + GET_INSTANCE_DATA; + UBYTE max_result = SC_INDEX; + UBYTE result = NO_AVAILABLE; + UBYTE i; + T_cr_par *ncell_first, *ncell_next, *scell_ptr; + BOOL c31_bc, c31_nc, c31_sc; + + TRACE_FUNCTION ("att_get_next_best_c32_index()"); + + switch (rr_data->sc_data.selection_type) + { + case BACK_FROM_DEDICATED: + case BACK_FROM_DEDICATED_RLF: + case CELL_RESELECTION_CR: + case CELL_RESELECTION_RACH: + + /* not valid */ + break; + + default: + /* + * Normal Cell reselection + * + */ + if( ! c31_calculated ) + { + att_calculate_c31_c32(SC_INDEX); + for (i = 0; i < SC_INDEX; i++) + { + if (rr_data->nc_data[i].bcch_status EQ DECODED) + { + att_calculate_c31_c32 (i); + } + } + } + TRACE_EVENT_P1("Scell = %d", rr_data->nc_data[SC_INDEX].arfcn); + for(i=0;i<=SC_INDEX; i++) + { + if( rr_data->nc_data[i].bcch_status EQ DECODED ) + { + ncell_first = &rr_data->nc_data[i].cr_par; + TRACE_EVENT_P6("First best Cell(arfcn=%d), C1=%d,C31=%d,C32=%d,Priority class =%d,hcs_thr=%d", + rr_data->nc_data[i].arfcn, + rr_data->nc_data[i].c1, + rr_data->nc_data[i].c31, + rr_data->nc_data[i].c32, + ncell_first->priority_class, + ncell_first->hcs_thr ); + } + } + + /* + * Now find the the first one which is not previously used + */ + for (i = 0; (i < SC_INDEX) AND (max_result EQ SC_INDEX) ; i++) + { + if ( (!rr_data->nc_data[i].c32_used) AND + rr_data->nc_data[i].bcch_status EQ DECODED AND + rr_data->nc_data[i].c1 > 0) + { + max_result = i; + } + } + if( max_result EQ SC_INDEX ) + { + return NO_AVAILABLE; + } + ncell_first = &( rr_data->nc_data[max_result].cr_par); + c31_bc = ( (rr_data->nc_data[max_result].c31 >= 0) AND + (ncell_first->priority_class NEQ GPRS_PRIORITY_CLASS_INVALID) ); + + /* choose the best cell */ + for (i = max_result+1; i < 6 ; i++) + { + if ( + (!rr_data->nc_data[i].c32_used) AND + (rr_data->nc_data[i].bcch_status EQ DECODED) AND + (rr_data->nc_data[i].c1) > 0 + ) + { + ncell_next = &( rr_data->nc_data[i].cr_par); + c31_nc = ( (rr_data->nc_data[i].c31 >= 0) AND + (ncell_next->priority_class NEQ GPRS_PRIORITY_CLASS_INVALID )); + if( + ( + c31_bc AND + c31_nc AND + (ncell_next->priority_class EQ ncell_first->priority_class ) AND + (rr_data->nc_data[i].c32 > rr_data->nc_data[max_result].c32) + ) + OR + ( + c31_bc AND + c31_nc AND + (ncell_next->priority_class > ncell_first->priority_class ) + ) + ) + { + /* prioritized cell reselection must be done */ + max_result = i; + ncell_first = ncell_next; + } + else if ( !c31_bc ) + { + if( c31_nc) + { + c31_bc = c31_nc; + max_result = i; + ncell_first = ncell_next; + } + else if ( rr_data->nc_data[i].c32 > rr_data->nc_data[max_result].c32 ) + { + /* no prioritized cell found yet */ + max_result = i; + ncell_first = ncell_next; + } + } + } + } + + /* compare with Serving cell */ + scell_ptr = &( rr_data->nc_data[SC_INDEX].cr_par); + c31_sc = ( (rr_data->nc_data[SC_INDEX].c31 >= 0 ) AND + (scell_ptr->priority_class NEQ GPRS_PRIORITY_CLASS_INVALID)); + TRACE_EVENT_P2("c31_sc=%d and c31_bc=%d",c31_sc, c31_bc); + if( + ( + c31_sc AND + c31_bc AND + (ncell_first->priority_class EQ scell_ptr->priority_class) AND + (rr_data->nc_data[max_result].c32 > rr_data->nc_data[SC_INDEX].c32) + ) + OR + ( + c31_sc AND + c31_bc AND + (ncell_first->priority_class > scell_ptr->priority_class) + ) + OR + ( c31_bc AND !c31_sc ) + OR + ( + !c31_bc AND + !c31_sc AND + (rr_data->nc_data[max_result].c32 > rr_data->nc_data[SC_INDEX].c32) + ) + ) + { + result = max_result; + } + else + { + result = NO_AVAILABLE; + } + } + + /* + * return the index of the highest C2. + */ + return result; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_ATT | +| STATE : code ROUTINE : att_check_c31_reselect_decision| ++--------------------------------------------------------------------+ + + PURPOSE : + +*/ + +GLOBAL void att_check_c31_reselect_decision (UBYTE start_now) +{ + GET_INSTANCE_DATA; + UBYTE index; + UBYTE delta = 1; + TRACE_FUNCTION("att_check_c31_reselect_decision()"); + index = att_get_next_best_c32_index(TRUE); + while( index NEQ NO_AVAILABLE ) + { + /* found a suitable cell to reselect */ + TRACE_EVENT_P1("found a cell %d", index); + /* + * Check cell barred status before going + * into Cell Reselection state. + * This will actually also be checked again + * in att_check_cell but the CRH value will + * not be used for subsequent ncells leading + * to false CR's. We check it here + * to use CRH for the next cell if needed. + */ +/* Implements RR Clone findings #8 */ + if(att_cell_barred_status_cr_no_cr( index)) + delta =0; + + /* + * Do not trigger a cell reselection decision on meas. report + * receipt if the cell belong to a LA not allowed for roaming. + * According to 3.22 chapter 3.5.4 cell reselection on a + * forbidden LA for regional provision of service is allowed. + */ + if (rr_data->ms_data.rr_service EQ FULL_SERVICE) + { + if (!dat_roam_forb_lai_check(index)) + delta = 0; +#if defined(_SIMULATION_) + TRACE_EVENT_WIN_P1 ("delta=%d", delta); +#endif + } + + if (delta > 0) + { + if (start_now) + { + att_start_cell_reselection_gprs(CELL_RESELECTION_NC); + } + return; + } + rr_data->nc_data[index].c32_used = TRUE; + index = att_get_next_best_c32_index(TRUE); + } + TRACE_EVENT(" index == NO_AVAILABLE in function att_check_c31_reselect_decision"); + + +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_ATT | +| STATE : code ROUTINE : att_check_cell_c31 | ++--------------------------------------------------------------------+ + + PURPOSE : if a cell reselection decision has been taken based on C31 + and C32 criterion , this function looks for a candidate for cell + reselection taking in account several requirements. + The reselect_index stores the index of the RR storage area + for the neighbourcell. The return value indicates whether a + cell has been found or not. +*/ + + +GLOBAL BOOL att_check_cell_c31 (void) +{ +GET_INSTANCE_DATA; + BOOL cell_ok = FALSE; + + TRACE_FUNCTION ("att_check_cell_c31()"); + + /* + * while no suitable candidate has been found, + * but still possible cells available. + */ + while (rr_data->reselect_index NEQ NO_AVAILABLE AND ! cell_ok) + { + /* + * calculate the cell reselection criterion C31 and C32 for the candidate + */ + //att_calculate_c31_c32(rr_data->reselect_index); + /* + * attempting reselection. Mark used + */ + rr_data->nc_data[rr_data->reselect_index].c32_used = TRUE; + + /* + * Cell should not be barred. + * If GPRS cell reselection parameters are received, look for CELL_BAR_ACCESS_2 + * else SI3 RACH parameters would indicate cell barred + */ + if( rr_data->nc_data[rr_data->reselect_index].v_cr_par EQ CR_PAR_VALID) + { + TRACE_EVENT_P2("Cell Barred arfcn = %d, barred = %d", + rr_data->nc_data[rr_data->reselect_index].arfcn, + rr_data->nc_data[rr_data->reselect_index].cr_par.cell_bar_access_2 ); + cell_ok = (rr_data->nc_data[rr_data->reselect_index].cr_par.cell_bar_access_2 + EQ CBA_2_NORMAL) ? TRUE : FALSE; + } + else + { +/* Implements RR Clone findings #8 */ + cell_ok = !att_cell_barred_status_cr_no_cr (rr_data->reselect_index); + } + /* + * 1. the cell shall be not temporarily excluded (tnnn e.g. after random access + * failure). + * 2. C31-C32 parameters are still valid + */ + if( cell_ok ) + cell_ok = ( ! is_tnnn (rr_data->reselect_index) AND + att_check_c31_criterion(rr_data->reselect_index) ); + + if ((cell_ok) AND (rr_data->ms_data.rr_service EQ FULL_SERVICE)) + { + if(rr_data->nc_data[rr_data->reselect_index].v_cr_par EQ CR_PAR_VALID) + { + cell_ok = (rr_data->nc_data[rr_data->reselect_index].cr_par.exc_acc + EQ EXC_ACC_NORMAL) ? TRUE : FALSE; + } + else + cell_ok = dat_roam_forb_lai_check (rr_data->reselect_index); + } + + if (cell_ok) + { + /* + * suitable cell has been found + */ + TRACE_EVENT ("use neighbour cell"); + + /* + * configure layer 1 for cell reselection + */ + TRACE_EVENT_P2 ("config L1 for CR [%d]->[%d]", + rr_data->nc_data[SC_INDEX].arfcn, + rr_data->nc_data[rr_data->reselect_index].arfcn); + + rr_data->gprs_data.ready_state = FALSE; /* Standby */ + + att_start_cr_in_pl(rr_data->reselect_index); + } + else + { + /* + * cell is not suitable. Look for another cell. + */ + rr_data->reselect_index = + att_get_next_best_c32_index(TRUE); + } + } + + /* + * return whether a cell has been found or not. + */ + return cell_ok; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_ATT | +| STATE : code ROUTINE : att_check_c31_criterion | ++--------------------------------------------------------------------+ + + PURPOSE : returns TRUE if C31 and C32 criterion of cell reselection is still valid. + +*/ +GLOBAL BOOL att_check_c31_criterion(UBYTE index) +{ + GET_INSTANCE_DATA; + T_cr_par *ncell_ptr, *scell_ptr; + BOOL c31_bc, c31_sc; + + att_calculate_c31_c32(index); + + ncell_ptr = & rr_data->nc_data[index].cr_par; + scell_ptr = & rr_data->nc_data[SC_INDEX].cr_par; + + c31_bc = ((rr_data->nc_data[index].c31 >= 0) AND + (ncell_ptr->priority_class NEQ GPRS_PRIORITY_CLASS_INVALID )); + c31_sc = ( (rr_data->nc_data[SC_INDEX].c31 >= 0 ) AND + (scell_ptr->priority_class NEQ GPRS_PRIORITY_CLASS_INVALID)); + /* + * check for C32 values, depending on priority + */ + + if( + ( + c31_sc AND + c31_bc AND + (ncell_ptr->priority_class > scell_ptr->priority_class) + ) + OR + ( + c31_sc AND + c31_bc AND + (ncell_ptr->priority_class EQ scell_ptr->priority_class) AND + (rr_data->nc_data[index].c32 > rr_data->nc_data[SC_INDEX].c32) + ) + OR + + ( + c31_bc AND (!c31_sc) + ) + OR + ( + (!c31_sc) AND + (!c31_bc) AND + (rr_data->nc_data[index].c32 > rr_data->nc_data[SC_INDEX].c32) + ) + ) + { + return TRUE; + } + return FALSE; +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_rrgrr_update_ba_req | ++-----------------------------------------------------------------------------+ + + PURPOSE : + +*/ +void att_rrgrr_update_ba_req(T_RRGRR_UPDATE_BA_REQ* ba_req) +{ + GET_INSTANCE_DATA; + UBYTE i; + T_LIST new_list; + T_CELL_DATA * cd; + + TRACE_EVENT ("update_ba"); + switch(GET_STATE(STATE_GPRS)) + { + case GPRS_PIM_BCCH: + case GPRS_PTM_BCCH: + case GPRS_PIM_PBCCH: + case GPRS_PAM_PBCCH: + case GPRS_PTM_PBCCH: +#if 0 + if (ba_req->cell_type EQ SYNC_SCELL) +#endif + cd = &rr_data->sc_data.cd; +#if 0 /* this is not used anymore but it still in the SAp for some time */ + else + cd = &rr_data->cr_data.cd; +#endif + + if(!rr_data->gprs_data.ba_bcch_modified) + srv_copy_list (&rr_data->ba_ncell_list, &cd->ncell_list, sizeof (T_LIST)); + + + /* store GPRS cell reselection parameters */ + memcpy(rr_data->gprs_data.add_freq_lists, ba_req->add_freq_list, + sizeof(T_add_freq_list) * RRGRR_BA_LIST_SIZE ); + + srv_copy_list (&new_list, &rr_data->ba_ncell_list, sizeof (T_LIST)); + + + if( ba_req->add_freq_list[0].arfcn NEQ NOT_PRESENT_16BIT ) + rr_data->gprs_data.use_c31 = FALSE; + + for(i=0; + i<RRGRR_BA_LIST_SIZE AND ba_req->add_freq_list[i].arfcn NEQ NOT_PRESENT_16BIT; + i++) + { + /*add*/ + srv_set_channel (&new_list, ba_req->add_freq_list[i].arfcn); + + if((ba_req->add_freq_list[i].v_cr_par) AND ( ba_req->cell_type EQ SYNC_SCELL)) + { + rr_data->gprs_data.use_c31 = TRUE; + TRACE_EVENT("use_c31 turned TRUE"); + } + } + + if( rr_data->gprs_data.use_c31) + { + rr_data->gprs_data.num_add_freq_list = i; + TRACE_EVENT_P1("number of added arfcn = %d", i); + att_init_cr_c31_data(); + att_init_nc_data_c31_cr_par(); + } + else + { + rr_data->gprs_data.num_add_freq_list = 0; + } + + for(i=0; + i<RRGRR_BA_LIST_SIZE AND ba_req->rm_freq_list[i].arfcn NEQ NOT_PRESENT_16BIT; + i++) + { + /*remove*/ + srv_unset_channel(&new_list, ba_req->rm_freq_list[i].arfcn); + } + + /* + * The NC2 indication in the Packet Measurement Order + * overrides the setting in the SI13 + */ + rr_data->gprs_data.nc_mode_of_pmo = ba_req->nc_mode; + rr_data->gprs_data.ba_bcch_modified=TRUE; + + if (srv_compare_list (&cd->ncell_list, &new_list) EQ FALSE) + { + /* both lists are different or it is the first one */ + srv_copy_list (&cd->ncell_list, + &new_list, + sizeof (T_LIST)); + + /* forward new neighbour cell list to layer 1 if + * changes shall be indicated + */ + if (ba_req->cell_type EQ SYNC_SCELL) + { + att_remove_bad_rr_data_ncells(); + att_code_mph_ncell_req (SC_INDEX); +#if defined (REL99) AND defined (TI_PS_FF_EMR) + /*BA(BCCH) is modified by GRR, this list now loses the + indices' sync that it has with NW, so can no longer use it + when moved to dedicated mode, for reporting*/ + rr_data->sc_data.ba_list_idle = FALSE; + rr_data->sc_data.enh_para_status = ENH_PARA_INVALID_STATE; + for_set_default_emr_data(&rr_data->sc_data.emr_data_current); + for_set_default_emr_data(&rr_data->sc_data.emr_data_temp); +#endif + } + } + break; + default: + break; + } + PFREE(ba_req); +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_rrgrr_meas_rep_req | ++-----------------------------------------------------------------------------+ + + PURPOSE : + +*/ + +void att_rrgrr_meas_rep_req (T_RRGRR_MEAS_REP_REQ* rrgrr_meas_rep_req) +{ + PALLOC(mph_meas_rep_req,MPH_MEAS_REP_REQ); + TRACE_FUNCTION("rrgrr_meas_rep_req()"); + mph_meas_rep_req->cause = rrgrr_meas_rep_req->meas_cause; + PFREE(rrgrr_meas_rep_req); + PSENDX(PL,mph_meas_rep_req); +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_check_sync_results | ++-----------------------------------------------------------------------------+ + + PURPOSE : + +*/ +BOOL att_check_sync_results(T_MPH_MEASUREMENT_IND* mph_measurement_ind) +{ + UBYTE i=0; + T_NC_DATA* pnc = NULL; + + if(mph_measurement_ind->gprs_sync EQ SYNC_RESULTS) + { + PALLOC(bsic_ind, RRGRR_NCELL_SYNC_IND); + TRACE_EVENT ("check_sync_res:TRUE"); + + for(; i < mph_measurement_ind->ncells.no_of_ncells ;i++) + { + bsic_ind->sync_result[i].arfcn = mph_measurement_ind->ncells.arfcn[i]; + + if(mph_measurement_ind->ncells.bsic[i] EQ NOT_PRESENT_8BIT OR + mph_measurement_ind->ncells.bsic[i] EQ MPH_BSIC_UNKNOWN) + { + if((pnc = is_nc_in_list(mph_measurement_ind->ncells.arfcn[i])) + NEQ NULL) + { + pnc->arfcn = NOT_PRESENT_16BIT; + pnc->bcch_status = EMPTY; + } + if(mph_measurement_ind->ncells.bsic[i] EQ NOT_PRESENT_8BIT) + bsic_ind->sync_result[i].sb_flag = NO_SB_FOUND; + else + bsic_ind->sync_result[i].sb_flag = SB_UNKNOWN; /*UNKNOWN*/ + + } + else + { + /* cell with BSIC */ + if( (pnc = is_nc_in_list(mph_measurement_ind->ncells.arfcn[i])) NEQ NULL) + { + /*found -> update if needed */ + pnc->bsic = bsic_ind->sync_result[i].bsic = + mph_measurement_ind->ncells.bsic[i]; + pnc->bcch_status=NON_DECODED; + } + else + { + /*add*/ + pnc = find_empty_slot_in_list(); + if(pnc) + { + pnc->bsic = bsic_ind->sync_result[i].bsic = + mph_measurement_ind->ncells.bsic[i]; + pnc->arfcn = mph_measurement_ind->ncells.arfcn[i]; + pnc->bcch_status=NON_DECODED; + } + } + bsic_ind->sync_result[i].sb_flag = SB_FOUND; + } + } + if(i>0) + { + for(/*dont init i*/; i < RRGRR_MAX_RSLT_NCELL_SYNC_IND; i++) + { + bsic_ind->sync_result[i].arfcn = NOT_PRESENT_16BIT; + } + + PSENDX(GRR, bsic_ind); + } + else + { + PFREE(bsic_ind); + } + + PFREE(mph_measurement_ind); + return TRUE; + } + return FALSE; +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_check_bsic | ++-----------------------------------------------------------------------------+ + + PURPOSE : + +*/ +void att_check_bsic(T_RRGRR_NCELL_SYNC_REQ* check_bsic) +{ + GET_INSTANCE_DATA; +#if defined (TI_PS_FF_RTD) AND defined (REL99) + T_rr_enh_para *p_cur = &rr_data->sc_data.emr_data_current; +#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */ + + TRACE_EVENT ("acq_bsic"); + + switch(GET_STATE(STATE_GPRS)) + { + case GPRS_PIM_PBCCH: + case GPRS_PTM_PBCCH: + case GPRS_PAM_PBCCH: + { + #if defined (TI_PS_FF_RTD) AND defined (REL99) + UBYTE i,j; + #else + UBYTE i; + #endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */ + PALLOC(ncell_req, MPH_NEIGHBOURCELL_REQ); + if(check_bsic->sync_type EQ SYNC_RECONFIRM) + ncell_req->sync_only = RECONFIRM_SYNC_LIST; + else + ncell_req->sync_only = SYNC_LIST; + memset(ncell_req->arfcn, NOT_PRESENT_8BIT, 2*MAX_NEIGHBOURCELLS); + + for(i=0; + i<RRGRR_MAX_ARFCN_NCELL_SYNC_REQ AND + #if defined (TI_PS_FF_RTD) AND defined (REL99) + check_bsic->ncell_sync_list[i].arfcn + #else + check_bsic->arfcn[i] + #endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */ + NEQ NOT_PRESENT_16BIT; i++) + { + #if defined (TI_PS_FF_RTD) AND defined (REL99) + ncell_req->arfcn[i] = check_bsic->ncell_sync_list[i].arfcn; + #else + ncell_req->arfcn[i] = check_bsic->arfcn[i]; + #endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */ +#if defined (TI_PS_FF_RTD) AND defined (REL99) + for(j = 0;j < check_bsic->ncell_sync_list[i].c_rtd;j++) + p_cur->enh_para.enh_cell_list[i].rtd[j] = check_bsic->ncell_sync_list[i].rtd[j]; + p_cur->enh_para.enh_cell_list[i].v_rtd = check_bsic->ncell_sync_list[i].v_rtd; + p_cur->enh_para.enh_cell_list[i].c_rtd = check_bsic->ncell_sync_list[i].c_rtd; +#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */ + } +#if defined (TI_PS_FF_RTD) AND defined (REL99) + attf_send_enh_para_to_alr(p_cur->rep_type,&p_cur->enh_para); +#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */ + + PSENDX(PL, ncell_req); + } + break; + default: + break; + } + PFREE(check_bsic); +} + +static T_NC_DATA* is_nc_in_list(USHORT arfcn) +{ + GET_INSTANCE_DATA; + T_NC_DATA* p_nc = &rr_data->nc_data[0]; + T_NC_DATA* p_nc_l = &rr_data->nc_data[6]; + for(; p_nc < p_nc_l;p_nc++) + if(p_nc->arfcn EQ arfcn) return p_nc; + return NULL; +} + +static T_NC_DATA* find_empty_slot_in_list(void) +{ + GET_INSTANCE_DATA; + T_NC_DATA* p_nc = &rr_data->nc_data[0]; + T_NC_DATA* p_nc_l = &rr_data->nc_data[6]; + for(; p_nc < p_nc_l;p_nc++) + if(p_nc->bcch_status EQ EMPTY) return p_nc; + return NULL; +} +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_is_gprs_avail | ++-----------------------------------------------------------------------------+ + + PURPOSE : + +*/ +BOOL att_gprs_is_avail(void) +{ + GET_INSTANCE_DATA; + if(GET_STATE(STATE_GPRS) NEQ GPRS_NULL) + return TRUE; + else + return FALSE; +} + +BOOL att_gprs_cell_has_pbcch(void) +{ + GET_INSTANCE_DATA; + UBYTE st = GET_STATE(STATE_GPRS); + + switch(st) + { + case GPRS_PIM_PBCCH: + case GPRS_PAM_PBCCH: + case GPRS_PTM_PBCCH: + case GPRS_SUSPENDED_PBCCH: + return TRUE; + default: + return FALSE; + } +} + +void att_gprs_stop_pl (void) +{ + GET_INSTANCE_DATA; + att_build_classmark_req (); + att_build_idle_req(SC_INDEX, MODE_CONFIG_PL); + +#if defined (REL99) AND defined (TI_PS_FF_EMR) + /*reset SI-2quater information and enhanced parameters if present + when PBCCH is present*/ + rr_data->sc_data.cd.si2quater_status = SI2QUATER_ABSENT; + rr_data->sc_data.cd.si2quater_pos = 0; + memset (rr_data->sc_data.rep_count, NOT_PRESENT_8BIT, MAX_NEIGHBOURCELLS); + for_set_default_emr_data(&rr_data->sc_data.emr_data_current); + rr_data->sc_data.enh_para_status = ENH_PARA_INVALID_STATE; + rr_data->sc_data.ba_list_ded = rr_data->sc_data.ba_list_idle = FALSE; +#endif + + /* + * use neighbour cell list from system info 2/2bis/2ter + */ + memset (rr_data->act_ncell_list, 0xFF, 2*MAX_NEIGHBOURCELLS); + srv_create_list (&rr_data->sc_data.cd.ncell_list, + rr_data->act_ncell_list, MAX_NEIGHBOURCELLS, FALSE, 0); +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_gprs_cr_rsp | ++-----------------------------------------------------------------------------+ + + PURPOSE : + +*/ +void att_gprs_cr_rsp(T_RRGRR_CR_RSP* cr_rsp) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION("att_gprs_cr_rsp()"); + switch(rr_data->gprs_data.start_proc) + { + case START_PROC_ACTIVATE_REQ: + srv_use_stored_prim(); + break; + case START_PROC_ENTER_LIMITED: + att_signal_gprs_support(); + if(att_gprs_cell_has_pbcch()) + { + /* + * RR is now in idle and configures L1 for + * BCCH only + */ + SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); + switch(GET_STATE(STATE_ATT)) + { + case ATT_IDLE: + case ATT_CON_EST: + att_build_idle_req(SC_INDEX, MODE_SYS_INFO_CHANGE); + break; + default: + break; + } + } + else + { + switch(GET_STATE(STATE_GPRS)) + { + case GPRS_PTM_BCCH: + case GPRS_PAM_BCCH: + /* + * Due to the CR_IND GRR has released the TBF so we + * have to correctly enter idle mode + * to respect transition rules + */ + rr_data->gprs_data.page_mode = PAG_MODE_DEFAULT; + SET_STATE (STATE_GPRS, GPRS_PIM_BCCH); + att_return_to_idle(); + break; + default: + break; + } + } + break; + case START_PROC_NORMAL_CR: + att_start_cell_reselection (rr_data->gprs_data.cr_type); + break; + case START_PROC_NORMAL_CS: + att_start_cell_selection (rr_data->gprs_data.cr_orig, CS_NOT_PARALLEL, + rr_data->cs_data.current_search_mode); + break; + case START_PROC_CFG_CHG: /*XXX not ok*/ + att_signal_gprs_support(); + break; + case START_PROC_GPRS_ACT: + { + PALLOC ( mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); + TRACE_EVENT("START_PROC_GPRS_ACT----- "); + + rr_data->sc_data.mm_started = MM_ORIGINATED; + + if((rr_data->sc_data.cd.sys_info_read EQ ALL_SYS_INFO_READ) OR + ((rr_data->sc_data.cd.sys_info_read | SYS_INFO_13_READ) EQ ALL_SYS_INFO_READ)) + { + rr_data->sc_data.cd.sys_info_read &= ~(SYS_INFO_13_READ); + mph_mon_ctrl_req->si_to_read = UPDATE_SI13; + + if( rr_data->nc_data[SC_INDEX].si13_loc_ind EQ NORMAL_BCCH) + { + mph_mon_ctrl_req->action = START_MON_NBCCH; + mph_mon_ctrl_req->si_to_read = UPDATE_SI13_GSM; + } + else + mph_mon_ctrl_req->action = START_MON_EBCCH; + } + else + { + TRACE_EVENT ("START_PROC_GPRS_ACT: Read Complete SI"); + rr_data->sc_data.cd.sys_info_read = NO_SYS_INFO_READ; + mph_mon_ctrl_req->si_to_read = COMPLETE_SI; + mph_mon_ctrl_req->action = START_MON_NBCCH; + } + + PSENDX (PL, mph_mon_ctrl_req); + TIMERSTART (T_RESELECT, TRESELECT_VALUE); + } + break; + default: + break; + } + rr_data->gprs_data.start_proc = START_PROC_NOTHING; + PFREE(cr_rsp); +} + +void att_gprs_sync_req( T_RRGRR_SYNC_REQ *sync_req) +{ + GET_INSTANCE_DATA; + switch(GET_STATE(STATE_GPRS)) + { + case GPRS_PIM_PBCCH: + case GPRS_PTM_PBCCH: + { + memset (&rr_data->nc_data[CR_INDEX], + 0, + sizeof (T_NC_DATA)); + + rr_data->nc_data[CR_INDEX].arfcn = sync_req->arfcn; + rr_data->nc_data[CR_INDEX].bsic = sync_req->bsic; + att_start_cell_reselection_pbcch(MODE_CELL_RESELECTION_SYNC_ONLY); + } + break; + default: + break; + } + PFREE(sync_req); +} + +void att_start_cell_reselection_gprs(UBYTE mode) +{ + GET_INSTANCE_DATA; + /*set start proc */ + if(att_gprs_is_avail()) + { + UBYTE st = GET_STATE(STATE_ATT); + if(st NEQ ATT_CS3 AND + st NEQ ATT_CS2 AND + st NEQ ATT_CS1) + { + att_rrgrr_cr_ind(CR_ABNORMAL); + rr_data->gprs_data.start_proc = START_PROC_NORMAL_CR; + rr_data->gprs_data.cr_type = mode; + return; + } + } + att_start_cell_reselection(mode); +} + +void att_start_cell_selection_gprs(UBYTE originator,UBYTE search_mode) +{ + GET_INSTANCE_DATA; + /*set start proc*/ + if(att_gprs_is_avail()) + { + UBYTE st = GET_STATE(STATE_ATT); + if(st NEQ ATT_CS3 AND + st NEQ ATT_CS2 AND + st NEQ ATT_CS1) + { + if(originator EQ MM_ORIGINATED) + { + TRACE_EVENT("start_cs_gprs: MM_ORIG!"); + att_rrgrr_cr_ind(CR_NORMAL); + } + else + { + att_rrgrr_cr_ind(CR_ABNORMAL); + EM_FMM_RESEL_START_IND; + } + + CS_SET_CURRENT_SEARCH_MODE(search_mode); + rr_data->gprs_data.start_proc = START_PROC_NORMAL_CS; + rr_data->gprs_data.cr_orig = originator; + return; + } + } + att_start_cell_selection(originator, CS_NOT_PARALLEL,search_mode); +} + + +void att_gprs_idle_req(T_MPH_IDLE_REQ* idle_req) +{ + GET_INSTANCE_DATA; + /* + * At this point it is necessary to do the following things: + * o send a CR_IND (optional) + * o set the parameter gprs_support (if needed, the default has already + been set before) + * o set the parameter reorg_only (if needed) + */ + switch(idle_req->mod) + { + case MODE_CELL_SELECTION: + if(GET_STATE(STATE_GPRS) EQ GPRS_NULL OR + GET_STATE(STATE_GPRS) EQ GPRS_ACTIVATED) + { + idle_req->gprs_support = MPH_GPRS_PROCS_NOT_USED; + } + else + { + idle_req->gprs_support = MPH_GPRS_PROCS_USED; + + if(rr_data->gprs_data.page_mode EQ PAG_MODE_REORG) + idle_req->reorg_only = REORG_ONLY; + else + idle_req->reorg_only = NORMAL_PGM; + + + } + break; + case MODE_CONFIG_PL: + idle_req->gprs_support = MPH_GPRS_PROCS_USED; + break; + case MODE_SYS_INFO_CHANGE: + if(GET_STATE(STATE_GPRS) EQ GPRS_NULL OR + GET_STATE(STATE_GPRS) EQ GPRS_ACTIVATED OR + rr_data->ms_data.rr_service EQ LIMITED_SERVICE) + { + idle_req->gprs_support = MPH_GPRS_PROCS_NOT_USED; + } + else + { + idle_req->gprs_support = MPH_GPRS_PROCS_USED; + idle_req->reorg_only = NORMAL_PGM; + + } + break; + default: + break; + } +} + +BOOL att_gprs_check_ncell(void) +{ + GET_INSTANCE_DATA; + BOOL cell_ok; + BOOL cell_barred; + BOOL check_nw; + BOOL roam_forb; + BOOL plmn_equal; + + TRACE_EVENT_P1 ("att_gprs_check_ncell() cr_pbcch_active=%d", + rr_data->gprs_data.cr_pbcch_active); + + if((rr_data->gprs_data.cr_pbcch_active) OR (rr_data->gprs_data.cr_pcco_active)) + { + +/* Implements RR Clone findings #8 */ + cell_barred = !att_cell_barred_status_cr_no_cr (CR_INDEX); + + check_nw = att_check_network (&rr_data->nc_data[CR_INDEX].lai); + roam_forb = dat_roam_forb_lai_check (CR_INDEX); + plmn_equal = dat_plmn_equal_req (rr_data->nc_data[CR_INDEX].lai.mcc, + rr_data->nc_data[CR_INDEX].lai.mnc, + rr_data->ms_data.plmn.mcc, + rr_data->ms_data.plmn.mnc); + + TRACE_EVENT_P6 ( "r MCC/MNC=%x%x%x/%x%x%x", + rr_data->ms_data.plmn.mcc[0], + rr_data->ms_data.plmn.mcc[1], + rr_data->ms_data.plmn.mcc[2], + rr_data->ms_data.plmn.mnc[0], + rr_data->ms_data.plmn.mnc[1], + rr_data->ms_data.plmn.mnc[2]); + TRACE_EVENT_P6 ( "i MCC/MNC=%x%x%x/%x%x%x", + rr_data->nc_data[CR_INDEX].lai.mcc[0], + rr_data->nc_data[CR_INDEX].lai.mcc[1], + rr_data->nc_data[CR_INDEX].lai.mcc[2], + rr_data->nc_data[CR_INDEX].lai.mnc[0], + rr_data->nc_data[CR_INDEX].lai.mnc[1], + rr_data->nc_data[CR_INDEX].lai.mnc[2]); + TRACE_EVENT_P5 ("[%u] cb %d nw %d ro %d pl %d", rr_data->nc_data[CR_INDEX].arfcn, + cell_barred, check_nw, roam_forb, plmn_equal); + + cell_ok = cell_barred AND check_nw AND roam_forb AND plmn_equal; + if (cell_ok) + { + TRACE_EVENT_P2 ("NEW SC [%d]->[%d]", + rr_data->nc_data[SC_INDEX].arfcn, + rr_data->nc_data[CR_INDEX].arfcn); + + if(rr_data->ms_data.rr_service EQ LIMITED_SERVICE AND + rr_data->ms_data.req_mm_service NEQ FUNC_LIM_SERV_ST_SRCH) + { + /* + * We are in LIMITED service. + * If the req_mm_service is FUNC_LIM_SERV_ST_SRCH we + * will stay in LIMITED. + * If we are in limited because of forbidden LAI we + * enter FULL SERVICE. + */ + rr_data->ms_data.rr_service = FULL_SERVICE; + } + + /* TIMERSTOP (T_RESELECT);*/ + att_copy_cr_data (); + memcpy (&rr_data->sc_data.cd, &rr_data->cr_data.cd, + sizeof (T_CELL_DATA)); + if (rr_data->old_serving_cell < SC_INDEX) + rr_data->nc_data[rr_data->old_serving_cell].avail_time = + PERIOD_700_SEC; + rr_data->nc_data[CR_INDEX].arfcn = NOT_PRESENT_16BIT; + + rr_data->gprs_data.cr_pbcch_active = FALSE; + if(GET_STATE(STATE_GPRS) EQ GPRS_PIM_BCCH OR + GET_STATE(STATE_GPRS) EQ GPRS_ACTIVATED) + { + att_set_pl_in_idle_mode (); + } + else if (att_gprs_cell_has_pbcch()) + { + att_gprs_stop_pl(); + } + att_signal_gprs_support(); + + /* XXX ??? + * set a barrier of 15 seconds for the next cell reselection + * if it was a cell reselection due to C2(NC) > C2(SC) + */ + if (rr_data->sc_data.selection_type EQ CELL_RESELECTION_NC) + TIMERSTART (T_NO_RESELECT, THIRTY_SEC/2); + } + else + { + /* + * inform GRR that the currently chosen cell + * not suitable and wait for the next rrgrr_cr_req + */ + att_cell_reselection_gprs_failed(); + } + return TRUE; + } + else + { + return FALSE; + } + +} + +void att_cell_reselection_gprs_failed(void) +{ + GET_INSTANCE_DATA; + PALLOC_SDU(gprs_ind, RRGRR_GPRS_SI13_IND, MAX_L2_FRAME_SIZE * BITS_PER_BYTE); + gprs_ind->cause = GPRS_CELL_NOT_SUITABLE; + gprs_ind->serving_cell_info.bcch_arfcn = rr_data->nc_data[CR_INDEX].arfcn; + gprs_ind->serving_cell_info.bcch_bsic = rr_data->nc_data[CR_INDEX].bsic; + + TRACE_EVENT_P4 ("cs=%u C[%d] bsic=%u #%u", + gprs_ind->cause, + gprs_ind->serving_cell_info.bcch_arfcn, + gprs_ind->serving_cell_info.bcch_bsic, + __LINE__); + + SET_STATE(STATE_GPRS, GPRS_PIM_PBCCH); + PSENDX(GRR, gprs_ind); +} + +void att_gprs_start_task (T_RRGRR_START_TASK_REQ* start_task) +{ + GET_INSTANCE_DATA; + switch(GET_STATE(STATE_GPRS)) + { + case GPRS_PIM_PBCCH: + case GPRS_PAM_PBCCH: + case GPRS_PTM_PBCCH: + switch(start_task->state) + { + case TASK_STATE_PTM: + { + PALLOC(mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); + mph_mon_ctrl_req->action = ENTER_PTM_PBCCH; + PSENDX (PL, mph_mon_ctrl_req); + SET_STATE(STATE_GPRS, GPRS_PTM_PBCCH); + } + break; + case TASK_STATE_PIM: + { + PALLOC(mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); + mph_mon_ctrl_req->action = ENTER_PIM_PBCCH; + PSENDX (PL, mph_mon_ctrl_req); + SET_STATE(STATE_GPRS, GPRS_PIM_PBCCH); +#ifdef REL99 + if(rr_data->gprs_data.cbch_info_rxvd_in_ptm) + { + rr_data->gprs_data.cbch_info_rxvd_in_ptm = FALSE; + att_config_cbch(); + } +#endif + } + break; + case TASK_STATE_PAM: + { + SET_STATE(STATE_GPRS, GPRS_PAM_PBCCH); + } + break; + default: + break; + } + break; + case GPRS_PIM_BCCH: + case GPRS_PAM_BCCH: + case GPRS_PTM_BCCH: + switch(start_task->state) + { + case TASK_STATE_PTM: + { + PALLOC(mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); + mph_mon_ctrl_req->action = ENTER_PTM_BCCH; + PSENDX (PL, mph_mon_ctrl_req); + } + break; + default: + break; + } + break; + default: + break; + } + + { + PALLOC(stop_cnf, RRGRR_START_TASK_CNF); + PSENDX(GRR, stop_cnf); + } + + PFREE(start_task); +} + +void att_start_cell_reselection_pbcch(UBYTE mode) +{ + GET_INSTANCE_DATA; + att_init_cell_selection(CELL_RESELECTION, RR_ORIGINATED); + att_init_pl_status (); + rr_data->bcch_error = 0; + rr_data->dyn_config.fcr = 0; + rr_data->dyn_config.scr = 0; + rr_data->bcch_error = 0; + rr_data->pag_rec = FALSE; + srv_clear_stored_prim (MPH_PAGING_IND); + gprs_init_data_cr(); + srv_clear_list (&rr_data->cr_data.cd.ncell_list); + dat_att_null(); + rr_data->gprs_data.cr_pbcch_active = TRUE; + SET_STATE (STATE_ATT, ATT_CS3); + att_build_idle_req (CR_INDEX, mode); +} + +/* ++------------------------------------------------------------------------------ +| Function : rr_ext_meas_can_start ++------------------------------------------------------------------------------ +| Description : Check if the Ext Meas procedure can be performed. +| +| Parameters : none +| ++------------------------------------------------------------------------------ +*/ +static BOOL rr_ext_meas_can_start ( void ) +{ + GET_INSTANCE_DATA; + if( GET_STATE(STATE_ATT) EQ ATT_IDLE ) + { + if( + (GET_STATE(STATE_GPRS) EQ GPRS_PIM_BCCH) + OR + (GET_STATE ( STATE_GPRS ) EQ GPRS_PIM_PBCCH) + ) + return TRUE; + } + return FALSE; +} + +/* ++------------------------------------------------------------------------------ +| Function : att_rrgrr_ext_meas_req ++------------------------------------------------------------------------------ +| Description : Start Extended Measurement (GPRS) at RR. +| +| Parameters : *rrgrr_ext_meas_req - Frequencies to be measured +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void att_rrgrr_ext_meas_req ( T_RRGRR_EXT_MEAS_REQ *rrgrr_ext_meas_req ) +{ + GET_INSTANCE_DATA; + T_GPRS_DATA *gprs_data = &rr_data->gprs_data; + UBYTE i,n; + T_arfcn_idx *s; + USHORT *d; + + /* Store the primitive 'rrgrr_ext_meas_req' during the Ext Meas procedure. */ + + if ( gprs_data->rrgrr_ext_meas_req NEQ NULL AND + gprs_data->rrgrr_ext_meas_req NEQ rrgrr_ext_meas_req ) + { + PFREE ( gprs_data->rrgrr_ext_meas_req ); + } + gprs_data->rrgrr_ext_meas_req = rrgrr_ext_meas_req; + + if ( rr_ext_meas_can_start() ) + { + PALLOC ( mph_ext_meas_req, MPH_EXT_MEAS_REQ ); + + SET_STATE (STATE_CELL_SEL, CS_XMEAS); + + n = rrgrr_ext_meas_req->c_arfcn_idx; + if ( n > RRGRR_MAX_ARFCN_EXT_MEAS ) + { + n = RRGRR_MAX_ARFCN_EXT_MEAS; + TRACE_ERROR ( "cut freq list (in)" ); + } + if ( n > MAX_CHANNELS ) + { + n = MAX_CHANNELS; + TRACE_ERROR ( "cut freq list (out)" ); + } + + mph_ext_meas_req->num_of_chan = n; + d = &mph_ext_meas_req->arfcn[0]; + s = &rrgrr_ext_meas_req->arfcn_idx[0]; + + for ( i = 0; i < n; ++i, ++s, ++d ) + *d = s->arfcn; + + /* Other elements of mph_ext_meas_req remain uninitialized here (set in ALR). */ + mph_ext_meas_req->freq_bands = cs_get_freq_band(FALSE); + gprs_data->ext_meas_ctrl = 0; + PSENDX (PL, mph_ext_meas_req); + } + else + { + PALLOC ( rrgrr_ext_meas_cnf, RRGRR_EXT_MEAS_CNF ); + rrgrr_ext_meas_cnf->c_xmeas_res = 0; + rrgrr_ext_meas_cnf->xmeas_cause = EXT_MEAS_RESET; + rrgrr_ext_meas_cnf->call_ref = rrgrr_ext_meas_req->call_ref; + PSENDX ( GRR, rrgrr_ext_meas_cnf ); + PFREE ( rrgrr_ext_meas_req ); + gprs_data->rrgrr_ext_meas_req = NULL; + } + return; +} + +/* ++------------------------------------------------------------------------------ +| Function : rr_ext_meas_idx ++------------------------------------------------------------------------------ +| Description : Retrieve InDeX associated to ARFCN during +| Extended Measurement (GPRS). +| +| Parameters : ARFCN - channel number in 'rrgrr_ext_meas_req' +| ++------------------------------------------------------------------------------ +*/ +GLOBAL UBYTE rr_ext_meas_idx (USHORT arfcn ) +{ + GET_INSTANCE_DATA; + UBYTE i,n; + T_arfcn_idx *arfcn_idx; + T_RRGRR_EXT_MEAS_REQ *rrgrr_ext_meas_req; + + rrgrr_ext_meas_req = rr_data->gprs_data.rrgrr_ext_meas_req; + if ( rrgrr_ext_meas_req EQ NULL ) + { + return NOT_PRESENT_8BIT; + } + + n = rrgrr_ext_meas_req->c_arfcn_idx; + arfcn_idx = &rrgrr_ext_meas_req->arfcn_idx[0]; + for ( i = 0; i < n; ++i, ++arfcn_idx ) + { + if ( arfcn_idx->arfcn EQ arfcn ) + return arfcn_idx->idx; + } + + return NOT_PRESENT_8BIT; +} + +/* ++------------------------------------------------------------------------------ +| Function : rr_ext_meas_end ++------------------------------------------------------------------------------ +| Description : Deallocate memory used during Extended Measurement (GPRS). +| This function is called in three scenarios: +| (1) System start (pei_init) +| (2) Cell Change triggered via gprs_init_gprs_data +| (3) End of Extended Measurement procedure +| +| Parameters : none +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void att_ext_meas_end ( BOOL destory_rrgrr_ext_meas_cnf ) +{ + GET_INSTANCE_DATA; + /* Note : If att_ext_meas_end is called via gprs_init_gprs_data and + * Ext Meas is running, then a repsonse from Lower Layers is still + * to be expected, which will be ignored. */ + + T_GPRS_DATA *gprs_data = &rr_data->gprs_data; + + if ( gprs_data->rrgrr_ext_meas_req NEQ NULL ) + { + PFREE ( gprs_data->rrgrr_ext_meas_req ); + gprs_data->rrgrr_ext_meas_req = NULL; + } + + if ( gprs_data->rrgrr_ext_meas_cnf NEQ NULL ) + { + if ( destory_rrgrr_ext_meas_cnf ) + { + PFREE ( gprs_data->rrgrr_ext_meas_cnf ); + } + gprs_data->rrgrr_ext_meas_cnf = NULL; + } + + if ( gprs_data->mph_ext_meas_cnf NEQ NULL ) + { + PFREE ( gprs_data->mph_ext_meas_cnf ); + gprs_data->mph_ext_meas_cnf = NULL; + } + + if ( (gprs_data->ext_meas_ctrl & EXT_MEAS_START_CR) NEQ 0 ) + { + /* handle the outstanding Cell Reselection request */ + gprs_data->ext_meas_ctrl &= ~EXT_MEAS_START_CR; + att_start_cell_reselection(rr_data->sc_data.selection_type); + } + + gprs_data->ext_meas_ctrl = 0; +} + +/* ++------------------------------------------------------------------------------ +| Function : att_ext_meas_next_bsic ++------------------------------------------------------------------------------ +| Description : Check for next BSIC scanning during Extended Measurement. +| If all BSICs are scanned, then a response is sent to GRR. +| +| Parameters : none +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void att_ext_meas_next_bsic (void) +{ + GET_INSTANCE_DATA; + T_GPRS_DATA *gprs_data = &rr_data->gprs_data; + T_RRGRR_EXT_MEAS_REQ *rrgrr_ext_meas_req = gprs_data->rrgrr_ext_meas_req; + T_RRGRR_EXT_MEAS_CNF *rrgrr_ext_meas_cnf = gprs_data->rrgrr_ext_meas_cnf; + T_MPH_EXT_MEAS_CNF *mph_ext_meas_cnf = gprs_data->mph_ext_meas_cnf; + UBYTE n = gprs_data->mph_ext_meas_num; + UBYTE stop = gprs_data->ext_meas_ctrl & EXT_MEAS_RESET; + + if ( (rrgrr_ext_meas_req->report_type EQ REP_TYPE_1 OR + rrgrr_ext_meas_req->report_type EQ REP_TYPE_2 ) AND + rrgrr_ext_meas_cnf->c_xmeas_res >= 6 OR + rrgrr_ext_meas_cnf->c_xmeas_res >= RRGRR_MAX_ARFCN_EXT_MEAS OR + n >= mph_ext_meas_cnf->num_of_chan OR + stop ) + { + /* stop PLMN search at lower layers */ + + PALLOC (mph_sync_req, MPH_SYNC_REQ); + mph_sync_req->cs = CS_STOP_PLMN_SEARCH; + PSENDX (PL, mph_sync_req); + } + else + { + PALLOC ( mph_bsic_req, MPH_BSIC_REQ ); + mph_bsic_req->arfcn = mph_ext_meas_cnf->arfcn[n]; + PSENDX ( PL, mph_bsic_req ); + } +} + +/* ++------------------------------------------------------------------------------ +| Function : att_mph_ext_meas_cnf ++------------------------------------------------------------------------------ +| Description : Evaluate rxlev during Start Extended Measurement (GPRS). +| +| Parameters : *mph_ext_meas_cnf - ARFCNs and RXLEVs from MPH +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void att_mph_ext_meas_cnf ( T_MPH_EXT_MEAS_CNF *mph_ext_meas_cnf ) +{ + GET_INSTANCE_DATA; + T_GPRS_DATA *gprs_data = &rr_data->gprs_data; + T_RRGRR_EXT_MEAS_REQ *rrgrr_ext_meas_req = gprs_data->rrgrr_ext_meas_req; + + /* Check that Ext Meas is still active at RR */ + + if ( rrgrr_ext_meas_req NEQ NULL ) + { + PALLOC ( rrgrr_ext_meas_cnf, RRGRR_EXT_MEAS_CNF ); + gprs_data->rrgrr_ext_meas_cnf = rrgrr_ext_meas_cnf; + + /* Depending on the Reporting Type either obtain BSICs or respond immediately. */ + + if ( rrgrr_ext_meas_req->report_type EQ REP_TYPE_1 OR + rrgrr_ext_meas_req->report_type EQ REP_TYPE_2 ) + { + /* allocate RRGRR_EXT_MEAS_CNF, save mph_ext_meas_cnf and send initial BSIC_REQ */ + + rrgrr_ext_meas_cnf->c_xmeas_res = 0; + + gprs_data->mph_ext_meas_cnf = mph_ext_meas_cnf; + gprs_data->mph_ext_meas_num = 0; + + att_ext_meas_next_bsic(); + } + else + { + /* With REP_TYPE_3 no BSIC scanning is needed, RRGRR_EXT_MEAS_CNF is sent. */ + /* Note: the premature end of the Ext Meas procedure could have been requested, */ + /* but this 'normal' procedure end is performed instead (now). */ + + UBYTE i,n; + T_xmeas_res *xmeas_res; + PALLOC (mph_sync_req, MPH_SYNC_REQ); + + n = mph_ext_meas_cnf->num_of_chan; + if ( n > RRGRR_MAX_ARFCN_EXT_MEAS ) + { + n = RRGRR_MAX_ARFCN_EXT_MEAS; + TRACE_ERROR ( "cut freq list (meas_cnf)" ); + } + + rrgrr_ext_meas_cnf->c_xmeas_res = n; + + xmeas_res = &rrgrr_ext_meas_cnf->xmeas_res[0]; + for ( i = 0; i < n; ++i, ++xmeas_res ) + { + USHORT arfcn = mph_ext_meas_cnf->arfcn[i] & ARFCN_MASK; + UBYTE idx = rr_ext_meas_idx ( arfcn ); + + xmeas_res->arfcn_idx.arfcn = arfcn; + xmeas_res->arfcn_idx.idx = idx; + xmeas_res->rxlev = mph_ext_meas_cnf->rx_lev[i]; + xmeas_res->bsic = 0; + } + PFREE(mph_ext_meas_cnf); + mph_sync_req->cs = CS_STOP_PLMN_SEARCH; + PSENDX (PL, mph_sync_req); + } + } + else + { + PFREE(mph_ext_meas_cnf); + } + return; +} + +/* ++------------------------------------------------------------------------------ +| Function : att_rrgrr_ext_meas_stop_req ++------------------------------------------------------------------------------ +| Description : Premature stop of Extended Measurement (GPRS). +| +| Parameters : *rrgrr_ext_meas_stop_req - Signal. +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void att_rrgrr_ext_meas_stop_req ( T_RRGRR_EXT_MEAS_STOP_REQ *rrgrr_ext_meas_stop_req) +{ + GET_INSTANCE_DATA; + T_GPRS_DATA *gprs_data = &rr_data->gprs_data; + T_RRGRR_EXT_MEAS_REQ *rrgrr_ext_meas_req = gprs_data->rrgrr_ext_meas_req; + + if (rrgrr_ext_meas_stop_req) + PFREE ( rrgrr_ext_meas_stop_req ); + + if ( rrgrr_ext_meas_req EQ NULL ) + return; + + gprs_data->ext_meas_ctrl |= EXT_MEAS_RESET; + + /* Continue the stop of the Ext Meas procedure with the next response from Lower Layers. */ +} + +/* ++------------------------------------------------------------------------------ +| Function : att_rrgrr_standby_ind ++------------------------------------------------------------------------------ +| Description : Store information that MS is in Standby State. +| +| Parameters : T_RRGRR_STANDBY_STATE_IND +| ++------------------------------------------------------------------------------ +*/ +void att_rrgrr_standby_ind(T_RRGRR_STANDBY_STATE_IND* stdby) +{ + GET_INSTANCE_DATA; + rr_data->gprs_data.ready_state = FALSE; + PFREE(stdby); +} + +/* ++------------------------------------------------------------------------------ +| Function : att_rrgrr_ready_ind ++------------------------------------------------------------------------------ +| Description : Store information that MS is in Ready State. +| +| Parameters : T_RRGRR_READY_STATE_IND +| ++------------------------------------------------------------------------------ +*/ +void att_rrgrr_ready_ind(T_RRGRR_READY_STATE_IND* rdy) +{ + GET_INSTANCE_DATA; + rr_data->gprs_data.ready_state = TRUE; + PFREE(rdy); +} + +#ifdef REL99 +/* ++------------------------------------------------------------------------------ +| Function : att_rrgrr_cbch_info_ind ++------------------------------------------------------------------------------ +| Description : Stores the CBCH configuration received from GRR. +| This information corresponds to the cbch channel +| description received on PBCCH. +| This primitive upates RR with latest CBCH information +| whenever new PSI8, PSI2 or PSI13 is received by GRR +| in PIM or PTM. This primitive should not come when +| the mobile has camped on a R97/98 network. +| +| Parameters : cbch_inf points to RRGRR_CBCH_INFO_IND primitive. +| ++------------------------------------------------------------------------------ +*/ +void att_rrgrr_cbch_info_ind(T_RRGRR_CBCH_INFO_IND* cbch_inf) +{ + GET_INSTANCE_DATA; + /* we should now be in R-99 network and in a cell having + * pbcch. Otherwise this message should not be received. + */ + TRACE_FUNCTION("att_rrgrr_cbch_info_ind"); + if(att_gprs_get_nw_release() AND att_gprs_cell_has_pbcch()) + { + /* Store the CBCH configuration in serving cell context */ + TRACE_EVENT("CBCH info on PBCCH received"); + rr_data->gprs_data.cbch_psi_valid = TRUE; + memcpy(&(rr_data->gprs_data.cbch_psi8),&(cbch_inf->cbch),sizeof(T_cbch)); + if( GET_STATE(STATE_ATT) EQ ATT_IDLE) + { + att_config_cbch(); + } + } + else + { + TRACE_ERROR( " CBCH Info received when PBCCH not present or when in R97 cell"); + + } + PFREE(cbch_inf); +} +#endif + +/* ++------------------------------------------------------------------------------ +| Function : is_nc2_used ++------------------------------------------------------------------------------ +| Description : Check if the cell reselection should be done +| or not. +| Parameters : none +| Return Value: TRUE -> don't do cell reselection +| FALSE -> do cell reselection ++------------------------------------------------------------------------------ +*/ +BOOL is_nc2_used(void) +{ + GET_INSTANCE_DATA; + BOOL ret = FALSE; + UBYTE st = GET_STATE(STATE_GPRS); + + TRACE_FUNCTION("is_nc2_used()"); + if (st EQ GPRS_NULL OR + st EQ GPRS_ACTIVATED) + return ret; + /* + * Check: + * Ready State + * NC mode of PMO + * NC mode of SI13 + */ + TRACE_EVENT_P3("nc2: rdy: %d, pmo_nc: %d, si13 nc: %d", + rr_data->gprs_data.ready_state, + rr_data->gprs_data.nc_mode_of_pmo, + rr_data->gprs_data.is_nc2_used_in_si13); + + if(rr_data->gprs_data.ready_state) + { + /* we are in READY */ + if(rr_data->gprs_data.nc_mode_of_pmo NEQ NC_MODE_RESET) + { + if(rr_data->gprs_data.nc_mode_of_pmo EQ NC2_USED) + ret = TRUE; + else + ret = FALSE; + } + else + { + /* use SI13 NC mode */ + ret = rr_data->gprs_data.is_nc2_used_in_si13; + } + } + else + { + /* we are in STANDBY */ + /* in STANDBY NC mode is not used */ + ret = FALSE; + } + return ret; +} + +#ifdef REL99 +/* ++------------------------------------------------------------------------------ +| Function : att_gprs_get_nw_release ++------------------------------------------------------------------------------ +| Description : returns the network release received in SI 13 +| Parameters : none +| Return Value: RR_GPRS_R97, RR_GPRS_R99 depending on the network +| release. ++------------------------------------------------------------------------------ +*/ +UBYTE att_gprs_get_nw_release(void) +{ + GET_INSTANCE_DATA; + return rr_data->gprs_data.nw_release; +} +#endif + +/*===========================================================================*/ +/* */ +/* */ +/* L O C A L S */ +/* */ +/* */ +/*===========================================================================*/ + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_get_scell_info | ++-----------------------------------------------------------------------------+ + + PURPOSE : fill the serving cell struct + +*/ +static void att_get_scell_info (T_serving_cell_info* sc, UBYTE idx) +{ + GET_INSTANCE_DATA; + + sc->gprs_ms_txpwr_max_cch = rr_data->nc_data[idx].select_para.ms_txpwr_max_cch; + sc->gprs_rxlev_access_min = rr_data->nc_data[idx].select_para.rxlev_access_min; + sc->bcch_arfcn = rr_data->nc_data[idx].arfcn; + sc->bcch_bsic = rr_data->nc_data[idx].bsic; + sc->ac_class = rr_data->nc_data[idx].rach.ac; + /* air-interface coding */ + sc->pwr_offset = (UBYTE)(rr_data->nc_data[idx].c2_par.power_off_ind ? + rr_data->nc_data[idx].c2_par.power_off : 0); + + if (!(dat_forb_lai_check (SC_INDEX) AND + dat_roam_forb_lai_check (SC_INDEX))) + sc->limited = 1; + else + sc->limited = (UBYTE)(rr_data->ms_data.rr_service EQ LIMITED_SERVICE); + + sc->rr_cell_env.plmn.v_plmn = TRUE; + + memcpy (sc->rr_cell_env.plmn.mcc, rr_data->nc_data[idx].lai.mcc, SIZE_MCC); + memcpy (sc->rr_cell_env.plmn.mnc, rr_data->nc_data[idx].lai.mnc, SIZE_MNC); + + sc->rr_cell_env.lac = rr_data->nc_data[idx].lai.lac; + sc->rr_cell_env.cid = rr_data->nc_data[idx].cell_id; + + sc->bs_pa_mfrms = rr_data->nc_data[idx].control_descr.bs_pa_mfrms; +} + +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_gprs_store_nc_mode | ++-----------------------------------------------------------------------------+ + + PURPOSE : store the NC mode of SI13 + +*/ +static void att_gprs_store_nc_mode(T_D_SYS_INFO_13* sys_info_13) +{ + GET_INSTANCE_DATA; + if( !sys_info_13->si13_rest_oct.si13_info.flag1 AND + sys_info_13->si13_rest_oct.si13_info.nco EQ NCO_NET_RESEL) + { + rr_data->gprs_data.is_nc2_used_in_si13 = TRUE; + } + else + { + rr_data->gprs_data.is_nc2_used_in_si13 = FALSE; + } +} + +#ifdef REL99 +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : att_gprs_store_nw_release | ++-----------------------------------------------------------------------------+ + + PURPOSE : stores the network release received in si13 + +*/ +static void att_gprs_store_nw_release(T_D_SYS_INFO_13* sys_info_13) +{ + GET_INSTANCE_DATA; + if(sys_info_13->si13_rest_oct.v_si13_info) + { + if(sys_info_13->si13_rest_oct.si13_info.v_sgsnr) + { + rr_data->gprs_data.nw_release = RR_GPRS_R99; + } + else + { + rr_data->gprs_data.nw_release = RR_GPRS_R97; + } + } + else + { + rr_data->gprs_data.nw_release = RR_GPRS_R97; + } +} + +#ifdef TI_PS_FF_EMR +/* ++-----------------------------------------------------------------------------+ +| PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | +| STATE : code ROUTINE : attg_send_enh_para_to_grr | ++-----------------------------------------------------------------------------+ + + PURPOSE : To format and send a primitive indicating enhanced measurement parameters + received from SI-2quater. +*/ +GLOBAL void att_send_enh_para_to_grr(T_rr_enh_para *p_src) +{ + PALLOC(p_enh,RRGRR_SI2QUATER_IND); + TRACE_FUNCTION("att_send_enh_para_to_grr"); + p_enh->rep_type = p_src->grr_rep_type; + p_enh->enh_para_struct = p_src->enh_para; + p_enh->nc_para_struct = p_src->nc_para; + PSENDX(GRR, p_enh); + return; +} +#endif +#endif + +#endif /* GPRS */ +#endif /* !RR_GPRS_C */