fc-magnetite: src/g23m-gsm/rr/rr

comparison src/g23m-gsm/rr/rr_attg.c @ 104:27a4235405c6

src/g23m-gsm: import from LoCosto source

author	Mychaela Falconia <falcon@freecalypso.org>
date	Tue, 04 Oct 2016 18:24:05 +0000
parents
children

comparison

equal deleted inserted replaced

-:76d139c7a25e
+:27a4235405c6
+/*
++-----------------------------------------------------------------------------
+|  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 */

FreeCalypso > hg > fc-magnetite

comparison src/g23m-gsm/rr/rr_attg.c @ 104:27a4235405c6