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

comparison src/g23m-gsm/rr/rr_attf.c @ 1:d393cd9bb723

src/g23m-*: initial import from Magnetite

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

comparison

equal deleted inserted replaced

-:b6a5e36de839
+:d393cd9bb723
+/*
++-----------------------------------------------------------------------------
+|  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 defines the functions for the attachment
+|             capability of the module Radio Resource.
++-----------------------------------------------------------------------------
+*/
+#ifndef RR_ATTF_C
+#define RR_ATTF_C
+#define ENTITY_RR
+/*==== INCLUDES ===================================================*/
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>     /* offsetof */
+#include "typedefs.h"
+#include "pcm.h"
+#include "pconst.cdg"
+#include "mconst.cdg"
+#include "message.h"
+#include "ccdapi.h"
+#include "vsi.h"
+#include "custom.h"
+#include "gsm.h"
+#include "prim.h"
+#include "cnf_rr.h"
+#include "tok.h"
+#include "rr.h"
+#include "rr_em.h"
+#include "cl_shrd.h"
+#if defined (_SIMULATION_)
+#include <stdio.h>
+#endif
+/*==== EXPORT =====================================================*/
+/*==== PRIVATE =====================================================*/
+LOCAL void rr_unpack_plmn (T_plmn *plmn, const UBYTE *packed, USHORT index);
+/* OMAPS00085607 - N950 Memory Optimization */
+LOCAL void start_treg_timer(void);
+#define TWO 2
+static void att_build_back_from_dedicated (void);
+static void att_calculate_c2            (UBYTE               index);
+static SHORT att_calculate_c2_diff      (UBYTE               index);
+static UBYTE att_calculate_digits       (UBYTE               *digits);
+static BOOL att_cell_in_data_structures (T_MPH_MEASUREMENT_IND *report,
+UBYTE               index);
+static UBYTE att_cell_in_measure_report  (T_MPH_MEASUREMENT_IND *report,
+UBYTE               index);
+static void att_check_2ter_read         (UBYTE               index);
+static BOOL att_check_cell              (void);
+LOCAL  UBYTE att_get_txpwr_max_cch      (UBYTE index);
+static void att_clear_forb_list (int list_type);
+static void att_clear_parallel_search   (void);
+static void att_code_prr_mm_info        (T_mm_info           *mm_info);
+static void att_copy_c2_parameter       (T_C2_PARAMETER     *c2_par,
+T_si3_rest_oct     *rest_oct );
+static void att_copy_c2_parameter_si3   (UBYTE               index,
+T_si3_rest_oct     *rest_oct);
+static void att_copy_found_plmn         (T_FOUND_LIST * list,
+USHORT n_in_source_85_dBm,
+USHORT i_in_copy);
+static void att_copy_rach_parameter     (UBYTE               index,
+T_rach_ctrl         *rach,
+UBYTE               indicate_changes);
+static UBYTE att_get_highest_c2_index   (void);
+static UBYTE att_get_next_highest_c2_idx(UBYTE               old_index);
+static UBYTE att_get_next_highest_c2_val(void);
+static UBYTE att_get_func               (void);
+static UBYTE att_get_next_highest_rx    (void);
+static void att_insert_cell_in_data     (T_MPH_MEASUREMENT_IND *report,
+UBYTE               index);
+static void att_order_plmns             (void);
+static USHORT att_number_of_plmns_greater_85_dBm (void);
+static void att_copy_plmns_lower_or_equal_85_dBm (T_FOUND_LIST * list, USHORT i_in_copy);
+static BOOL att_priority_check          (void);
+static void att_reorder_mph_ncell_req   (T_MPH_NEIGHBOURCELL_REQ*
+mph_ncell_req);
+static void att_search_cell             (void);
+static void att_select_cell_dedicated (void);
+static void att_try_old_cell            (void);
+static void att_print_selection_type    (UBYTE                selection_type);
+/* Implements Measure#32: Row 36, 39 and 40 */
+static void att_print_op                (T_op                *op,
+T_S2I_STRING        titel);
+static void att_begin_cs                (UBYTE req_mm_service);
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+static void att_check_for_si5ter_and_enhpara (UBYTE old_index);
+#endif
+LOCAL void att_copy_sys_info_2bis_2ter_par(UBYTE index, T_SI_TYPE si_type,
+T_LIST  *new_2_bis_ter_list,
+BUF_neigh_cell_desc   *neigh_cell_desc,
+UBYTE  indicate_changes);
+/*==== VARIABLES ==================================================*/
+GLOBAL UBYTE test_house = FALSE;
+/*==== MACROS =====================================================*/
+#if !defined (NTRACE)
+#define TRACE_C1(index)\
+TRACE_EVENT_P4 ("[%u]i%u C1=%-2d rxlev=%u",\
+rr_data->nc_data[index].arfcn,index,\
+rr_data->nc_data[index].c1,\
+rr_data->nc_data[index].rxlev)
+#define TRACE_C2(index)\
+TRACE_EVENT_P3 ("[%u]i%u C2=%-2d AT=%d",\
+rr_data->nc_data[index].arfcn,index,\
+rr_data->nc_data[index].c2,\
+rr_data->nc_data[index].avail_time)
+#define TRACE_C1_C2(index)\
+TRACE_EVENT_P6 ("[%u]i%u C1=%-2d C2=%-2d rxlev=%-2u AT=%d",\
+rr_data->nc_data[index].arfcn,index,\
+rr_data->nc_data[index].c1,\
+rr_data->nc_data[index].c2,\
+rr_data->nc_data[index].rxlev,\
+rr_data->nc_data[index].avail_time)
+#define TRACE_SELECTION_TYPE(type)      att_print_selection_type(type)
+/* Implements Measure#32: Row 36, 39 and 40 */
+#define TRACE_OP_TYPE(op,titel)         att_print_op (op, S2I_STRING(titel))
+#else   /* !NTRACE */
+#define TRACE_C1(i)
+#define TRACE_C2(i)
+#define TRACE_C1_C2(i)
+#define TRACE_SELECTION_TYPE(type)
+#define TRACE_OP_TYPE(op,titel)
+#endif  /* !NTRACE */
+/*==== FUNCTIONS ==================================================*/
+/*
+* -------------------------------------------------------------------
+* Procedures
+* -------------------------------------------------------------------
+*/
+/* Implements Measure#32: Row 60 */
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_print_forb_list
++--------------------------------------------------------------------+
+PURPOSE : After a successful location updating request MM informs
+RR about this. If the location area information is stored
+inside of one of the forbidden location area lists this
+information must be updated. In this function, the entry
+is deleted from the given forbidden list.
+*/
+LOCAL void att_print_forb_list ( int                list_type,
+const T_plmn     * plmn,
+USHORT             lac,
+unsigned int       index,
+BOOL               to_delete)
+{
+if(list_type EQ FORBIDDEN_LIST_NORMAL)
+{
+if(to_delete EQ FALSE)
+{
+TRACE_EVENT_P1 ( "ADD FORB LIST %u:", index);
+}
+else
+{
+TRACE_EVENT_P1 ( "DEL FORB LIST %u:", index);
+}
+}
+else
+{
+if(to_delete EQ FALSE)
+{
+TRACE_EVENT_P1 ( "ADD FORB LIST %u:", index);
+}
+else
+{
+TRACE_EVENT_P1 ( "DEL ROAM FORB LIST %u:", index);
+}
+}
+TRACE_EVENT_P7 ( "    MCC/MNC=%x%x%x/%x%x%x LAC=%x",
+plmn->mcc[0],
+plmn->mcc[1],
+plmn->mcc[2],
+plmn->mnc[0],
+plmn->mnc[1],
+plmn->mnc[2],
+lac);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_add_to_forb_list       |
++--------------------------------------------------------------------+
+PURPOSE : RR stores a list of forbidden location area codes. After
+a specific location updating reject cause this information
+will be given by MM with a RR_SYNC_REQ. The check against
+forbidden location areas is part of the cell selection and
+cell reselection process.
+*/
+GLOBAL void att_add_to_forb_list (int         list_type,
+const T_plmn     *plmn,
+USHORT            lac)
+{
+GET_INSTANCE_DATA;
+int i;
+T_loc_area_ident *forb_list;
+if (list_type EQ FORBIDDEN_LIST_NORMAL)
+forb_list = &rr_data->ms_data.forb_lac_list[0];
+else
+forb_list = &rr_data->ms_data.roam_forb_lac_list[0];
+TRACE_FUNCTION ("att_add_to_forb_list()");
+for (i = 0; i < MAX_LAI; i++)
+{
+/*
+* Check whether the location area code is already stored. In
+* this case it is not necessary to store it again
+*/
+if ((lac EQ forb_list[i].lac) AND
+dat_plmn_equal_req (plmn->mcc, plmn->mnc,
+forb_list[i].mcc, forb_list[i].mnc))
+break;
+}
+if (i EQ MAX_LAI)
+{
+/*
+* Location Area Code is not stored yet. Look for a free entry
+* and store the location area code.
+*/
+for (i = 0; i < MAX_LAI; i++)
+{
+if (forb_list[i].lac EQ NOT_PRESENT_16BIT)
+{
+memcpy (forb_list[i].mcc, plmn->mcc, SIZE_MCC);
+memcpy (forb_list[i].mnc, plmn->mnc, SIZE_MNC);
+forb_list[i].lac = lac;
+break;
+}
+}
+if (i EQ MAX_LAI)
+{
+/*
+* all entries are used. Then delete the first (and oldest) one,
+* move each entry and store the new one in the last position.
+*/
+memmove (&forb_list[0], &forb_list[1],
+sizeof (T_loc_area_ident) * (MAX_LAI-1));
+memcpy (forb_list[MAX_LAI-1].mcc, plmn->mcc, SIZE_MCC);
+memcpy (forb_list[MAX_LAI-1].mnc, plmn->mnc, SIZE_MNC);
+forb_list[MAX_LAI-1].lac = lac;
+i--;
+}
+}
+/* Implements Measure#32: Row 4 */
+att_print_forb_list ( list_type, plmn, lac, i, FALSE);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_analyze_measure_report |
++--------------------------------------------------------------------+
+PURPOSE : After reception of a MPH_MEASUREMENT_IND from layer 1 the
+channels are analyzed for a cell reselection decision.
+*/
+GLOBAL void att_analyze_measure_report (T_MPH_MEASUREMENT_IND *report)
+{
+GET_INSTANCE_DATA;
+UBYTE i = 0;
+TRACE_FUNCTION ("att_analyze_measure_report()");
+/*
+* The variable no_reselect controls the condition not to perform a
+* new cell reselection due to  C2(NC) > C2(SC) after a cell reselection
+* for 15 seconds
+*/
+/*
+* The fieldtest has shown, that sometimes the serving cell was also reported
+* as a neighbourcell. This function removes double entries
+*/
+att_remove_multiple_channels ();
+/*
+* All possible neighbourcells plus the serving cell are checked.
+*/
+for (i = 0; i < 6; i++)
+{
+/*
+* The tnnn variable controls the condition that a cell is barred for five seconds
+* for cell reselection purposes after a random access failure.
+*/
+/*
+* check the status of a cell using the data stored in RR for neighbour- and serving
+* cell.
+*/
+switch (rr_data->nc_data[i].bcch_status)
+{
+case EMPTY:
+/*
+* RR has nothing stored in this area. So there is nothing to do.
+*/
+break;
+case DECODED:
+/*
+* In this area RR has stored Data for a neighbourcell. The status is decoded,
+* that means RR has received a system information 3,4,7 or 8 to calculate
+* the cell reselection criterion C2.
+*
+* Now it is checked against the incoming measurement report.
+*/
+switch (att_cell_in_measure_report (report, i))
+{
+case CELL_IS_INSERTED:
+/*
+* The cell is still included in the measurement report, that means
+* it is one of the six strongest carrier and layer 1 is synchronized
+* to the cell.
+*
+* The time how long the cell is already synchronized is stored up to
+* a period of 700 seconds. This informatin is used for the calculation
+* of the cell reselection criterion C2 which may has a time dependent
+* factor. In fact the frames of layer 1 are counted.
+*/
+if (rr_data->nc_data[i].avail_time < PERIOD_700_SEC)
+rr_data->nc_data[i].avail_time += rr_data->ms_data.fn_offset;
+break;
+case BSIC_HAS_CHANGED:
+/*
+* The cell is still included in the measurement report, but layer1
+* has detected a change of the BSIC during re-synchronisation on the
+* SB channel. So the stored information for calculation of C2 is useless
+* and the status and the avail time is cleared.
+*/
+rr_data->nc_data[i].bcch_status = NON_DECODED;
+rr_data->nc_data[i].avail_time  = 0;
+break;
+case CELL_IS_NOT_INSERTED:
+/*
+* The cell is not longer included. The area in RR is released.
+*/
+rr_data->nc_data[i].bcch_status = EMPTY;
+break;
+}
+break;
+case NON_DECODED:
+/*
+* RR has already stored this cell in its data, but has not received
+* the needed information for calculation of cell reselection criterion C2.
+*
+* Now it is checked against the incoming measurement report.
+*/
+switch (att_cell_in_measure_report (report, i))
+{
+case CELL_IS_INSERTED:
+/*
+* The cell is still included. For later calculation of the cell
+* reselection criterion C2 the time is counted for which the cell
+* is synchronized.
+*/
+if (rr_data->nc_data[i].avail_time < PERIOD_700_SEC)
+rr_data->nc_data[i].avail_time += rr_data->ms_data.fn_offset;
+break;
+case BSIC_HAS_CHANGED:
+/*
+* The layer 1 indicated that the BSIC has changed during re-synchronisation
+* to the SB channel. The status will not change, but the avail time is
+* resetted.
+*/
+rr_data->nc_data[i].avail_time = 0;
+break;
+case CELL_IS_NOT_INSERTED:
+/*
+* Layer 1 indicates that the cell is not longer one of the six strongest or
+* that the synchronisation has been lost. The storage area in RR is released.
+*/
+rr_data->nc_data[i].bcch_status = EMPTY;
+rr_data->nc_data[i].avail_time  = 0;
+break;
+}
+break;
+}
+}
+/*
+* store the Fieldstrength of the serving cell and update the information
+* of the power campaign.
+*/
+rr_data->nc_data[SC_INDEX].rxlev = report->rx_lev_full;
+cs_set_rxlev (report->rx_lev_full, rr_data->nc_data[SC_INDEX].arfcn);
+if (rr_data->nc_data[SC_INDEX].rxlev >
+rr_data->lup_rxlev + 10)
+{
+/*
+* A fieldstrength jump more then 10 dBm has been detected. This can be the
+* trigger for MM to restart a location updating request if needed. It indicates
+* for example that the mobile has left a tunnel area without coverage.
+*
+* This is not used by MM if a test SIM is inserted. It is an improvement for
+* the field beside the GSM specifications.
+*/
+PALLOC (sync, RR_SYNC_IND);
+sync->ciph              = NOT_PRESENT_8BIT;
+sync->chm.ch_mode       = NOT_PRESENT_8BIT;
+sync->synccs            = SYNCCS_LUP_RETRY;
+sync->mm_info.valid     = FALSE;
+sync->bcch_info.v_bcch  = FALSE;
+PSENDX (MM, sync);
+/*
+* Store the new value to avoid multiple signalling of the fieldstrength jump
+*/
+rr_data->lup_rxlev = rr_data->nc_data[SC_INDEX].rxlev;
+}
+/*
+* Now look for all neighbourcells in the measurement report if they are new.
+*/
+for (i = 0; i < report->ncells.no_of_ncells; i++)
+{
+cs_set_rxlev (report->ncells.rx_lev[i], report->ncells.arfcn[i]);
+/*
+* If a channel is not inside the RR data structure, insert the cell
+*/
+if (! att_cell_in_data_structures (report, i))
+att_insert_cell_in_data (report, i);
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_bcch_status_to_decoded |
++--------------------------------------------------------------------+
+PURPOSE : After reception of the system information type 3,4,7 or 8
+the status of a cell changes from NON_DECODED to DECODED
+and it is possible to calculate the cell reselection
+criterion C2.
+*/
+GLOBAL void att_bcch_status_to_decoded (UBYTE index)
+{
+GET_INSTANCE_DATA;
+TRACE_EVENT_P2 ("[%u]%u att_bcch_status_to_decoded()", rr_data->nc_data[index].arfcn, index);
+rr_data->nc_data[index].bcch_status  = DECODED;
+rr_data->nc_data[index].bcch_counter = 0;
+rr_data->nc_data[index].c1_counter   = 0;
+#ifdef GPRS
+if( rr_data->gprs_data.use_c31 NEQ TRUE )
+{
+#endif
+if ((rr_data->c_ncell_bcch > 0) AND (rr_data->c_ncell_bcch NEQ NOT_INITIALISED))
+rr_data->c_ncell_bcch--;
+if (rr_data->resel_pending)
+{
+if (rr_data->c_ncell_bcch EQ 0)
+{
+SET_STATE (STATE_ATT, ATT_CON_EST);
+#ifdef GPRS
+att_start_cell_reselection_gprs(CELL_RESELECTION_RACH);
+#else
+att_start_cell_reselection(CELL_RESELECTION_RACH);
+#endif
+rr_data->resel_pending = FALSE;
+rr_data->c_ncell_bcch = NOT_INITIALISED;
+}
+}
+else
+{
+att_calculate_c2 (index);
+}
+#ifdef GPRS
+}
+else
+{
+if( rr_data->nc_data[index].v_cr_par EQ CR_PAR_INVALID )
+{
+att_convert_idle_c31_cr(index);
+}
+else
+{
+TRACE_EVENT_P2(" arfcn %d, index = %d has valid CR_ PAR", rr_data->nc_data[index].arfcn, index);
+}
+}
+#endif
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_bits_to_byte           |
++--------------------------------------------------------------------+
+PURPOSE : The function is used to calculate the positions of 1-bits
+into a byte array. This is needed for calculation of a
+frequency hopping list for a mobile allocation. The input
+parameter are the bitmap and the size of the bitmap in bytes.
+The result is a byte array containing the positions of 1-bits
+followed by an end identifier NOT_PRESENT_8BIT (0xFF). The
+maximum size of the incoming array is 32 bytes.
+Example: a mobile allocation looks like this:
+0x42 = 0b01000010  -> bit    15 14 13 12 11 10  9  8
+0x81 = 0b10000001  -> bit     7  6  5  4  3  2  1  0
+The size of the input array is 2 and the output is:
+1,8,10,15,0xFF    (starting with position 1 in bit 0)
+*/
+GLOBAL void att_bits_to_byte (UBYTE  * num,
+UBYTE    size,
+UBYTE  * bits)
+{
+SHORT ix;
+UBYTE bit;
+UBYTE buf_ix;
+TRACE_FUNCTION ("att_bits_to_byte()");
+/*
+* For all bytes in the input field
+*/
+for (ix = 0; ix < size; ix++)
+{
+buf_ix = bits[size-1-ix];
+/*
+* for each bit inside this byte
+*/
+bit = 0;
+while (8 > bit)
+{
+if (buf_ix & (1 << bit))
+{
+/*
+* If bit is set, store the position in the output field
+*/
+*num++ = ((USHORT)ix << 3) + bit + 1;
+}
+bit++;
+}
+}
+/*
+* add the end identifier
+*/
+*num = NOT_PRESENT_8BIT;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_build_cbch             |
++--------------------------------------------------------------------+
+PURPOSE : configure at the end of the cell selection the CBCH channel
+in layer 1. The CBCH channel is optional defined in system
+information type 4.
+When the cell has PBCCH and it is a Release-99 cell,
+the CBCH configuration should be taken from gprs database.
+This information is provided by GRR through RRGRR_CBCH_INFO_IND.
+CBCH channel configuration is received on PBCCH on PSI8.
+*/
+#ifdef REL99
+LOCAL  void att_build_cbch (void)
+#else
+GLOBAL void att_build_cbch (void)
+#endif
+{/*lint -e813 supress info of length of T_LIST*/
+GET_INSTANCE_DATA;
+T_LIST hop_list;
+PALLOC (cbch_req, MPH_CBCH_REQ);
+TRACE_FUNCTION ("att_build_cbch()");
+/*
+* Initialize the primitive to layer 1
+*/
+memset (cbch_req, 0, sizeof (T_MPH_CBCH_REQ));
+if (rr_data->ms_data.rr_service EQ FULL_SERVICE)
+{
+/*
+* CBCH is activated only if RR is in full service
+*/
+if (rr_data->sc_data.cd.cbch_chan_desc_avail NEQ NO_CONTENT )
+{
+/*
+* If a CBCH channel description has been received with
+* system information tpye 4, activate the channel in layer 1.
+*/
+cbch_req->cbch.stat = STAT_ACT;
+cbch_req->cbch.ch   = rr_data->sc_data.cd.cbch_chan_desc.chan_type;
+cbch_req->cbch.tn   = rr_data->sc_data.cd.cbch_chan_desc.tn;
+cbch_req->cbch.tsc  = rr_data->sc_data.cd.cbch_chan_desc.tsc;
+cbch_req->cbch.h    = rr_data->sc_data.cd.cbch_chan_desc.hop;
+switch (cbch_req->cbch.h)
+{
+case H_NO:
+/*
+* CBCH does not use frequency hopping, then configure simply the
+* channel number
+*/
+cbch_req->cbch.arfcn = rr_data->sc_data.cd.cbch_chan_desc.arfcn;
+break;
+case H_FREQ:
+/*
+* CBCH uses frequency hopping, then configure MAIO and HSN
+* and create a frequency hopping list from the cell channel
+* description in system information 1 and the mobile allocation
+* in system information 4.
+*/
+cbch_req->cbch.maio  = rr_data->sc_data.cd.cbch_chan_desc.maio;
+cbch_req->cbch.hsn   = rr_data->sc_data.cd.cbch_chan_desc.hsn;
+srv_create_chan_mob_alloc (&rr_data->sc_data.cd.cell_chan_desc,
+&hop_list,
+rr_data->sc_data.cd.cbch_mob_alloc);
+/* CSI-LLD section:4.1.1.11
+* This function Updates the black list with the MA list received
+* in the CBCH allocation
+*/
+cs_remove_BA_MA_from_black_list(rr_data->cs_data.region,&hop_list);
+srv_create_list (&hop_list, cbch_req->cbch.ma, MAX_MA_CHANNELS, TRUE,
+0);
+break;
+}
+}
+else
+/*
+* In all other cases configure layer 1 without CBCH.
+*/
+cbch_req->cbch.stat = STAT_INACT;
+}
+PSENDX (PL, cbch_req);
+}
+#ifdef REL99
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_config_cbch            |
++--------------------------------------------------------------------+
+PURPOSE : The following conditions have to be satisfied for
+configuring CBCH.
+1. Full service should have been enabled.
+2. Mobile should be in idle/packet mode.
+This function checks these conditions before configuring
+CBCH. If function is called during packet transfer mode,
+a flag in GPRS data is set signalling that this function
+should be called again after entering idle mode.
+*/
+GLOBAL void att_config_cbch (void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_config_cbch()");
+/*
+* CBCH is activated only if RR is in full service
+*/
+if ((rr_data->ms_data.rr_service EQ FULL_SERVICE) )
+{
+#ifdef GPRS
+/* check if mobile is in PTM */
+if(!dat_gprs_cell_in_ptm())
+{
+/* mobile is NOT in packet transfer mode */
+if(!att_gprs_cell_has_pbcch() OR !att_gprs_get_nw_release())
+{
+/* This cell does not have pbcch,
+* OR this is a R - 98 or lower cell.
+* hence take info stored in SI 4
+*/
+#endif /* GPRS */
+att_build_cbch();
+#ifdef GPRS
+}
+else
+{
+/* This Cell has PBCCH and also this is Release-99 cell.
+* Configure ALR if CBCH info is available form GRR.
+*/
+if(rr_data->gprs_data.cbch_psi_valid)
+{
+PALLOC (cbch_req, MPH_CBCH_REQ);
+memcpy(&(cbch_req->cbch),
+&(rr_data->gprs_data.cbch_psi8),
+sizeof(T_cbch));
+PSENDX (PL, cbch_req);
+}
+/*else wait till CBCH info is received from GRR */
+}
+rr_data->gprs_data.cbch_info_rxvd_in_ptm = FALSE;
+}
+else
+{
+rr_data->gprs_data.cbch_info_rxvd_in_ptm = TRUE;
+}
+#endif /* GPRS */
+}
+else
+{
+#ifdef GPRS
+if(!dat_gprs_cell_in_ptm())
+#endif /* GPRS */
+{
+PALLOC (cbch_req, MPH_CBCH_REQ);
+memset (cbch_req, 0, sizeof (T_MPH_CBCH_REQ));
+cbch_req->cbch.stat = STAT_INACT;
+PSENDX (PL, cbch_req);
+}
+}
+}
+#endif
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_build_classmark_req    |
++--------------------------------------------------------------------+
+PURPOSE : Configure at the end of the cell selection the classmark of
+the mobile to layer 1. This information is used by layer 1
+for random access.
+*/
+GLOBAL void att_build_classmark_req (void)
+{
+GET_INSTANCE_DATA;
+PALLOC (classmark_req, MPH_CLASSMARK_REQ);
+TRACE_FUNCTION ("att_build_classmark_req()");
+#if defined (_SIMULATION_)
+/*
+* In the windows simulation it is necessary to read the data
+* from the non-volantile memory (PCM) again.
+*/
+rr_csf_check_rfcap (FALSE);
+#endif
+if((std EQ STD_DUAL) OR (std EQ STD_DUAL_EGSM))
+{
+classmark_req->classmark.pclass = rr_data->ms_data.rf_cap.rf_power.pow_class4[IDX_PWRCLASS_900].pow_class-1;
+classmark_req->classmark.pclass2 = rr_data->ms_data.rf_cap.rf_power.pow_class4[IDX_PWRCLASS_1800].pow_class-1;
+}
+else if(std EQ STD_DUAL_US)
+{
+classmark_req->classmark.pclass = rr_data->ms_data.rf_cap.rf_power.pow_class4[IDX_PWRCLASS_850].pow_class-1;
+classmark_req->classmark.pclass2 = rr_data->ms_data.rf_cap.rf_power.pow_class4[IDX_PWRCLASS_1900].pow_class-1;
+}
+else
+{
+/*
+* In single bands only one power class is forwarded to layer 1.
+*/
+#ifdef GPRS
+#ifdef REL99
+classmark_req->classmark.pclass = rr_data->ms_data.ra_cap.ra_cap_values.acc_cap.pow_class-1;
+#else
+classmark_req->classmark.pclass = rr_data->ms_data.ra_cap.acc_cap.pow_class-1;
+#endif
+#else
+if (std EQ STD_1900)
+{
+classmark_req->classmark.pclass = rr_data->ms_data.classmark3.pcs1900_cap-1;
+}
+else if (std EQ STD_850)
+{
+classmark_req->classmark.pclass = rr_data->ms_data.classmark3.gsm850_cap-1;
+}
+else
+{
+classmark_req->classmark.pclass = rr_data->ms_data.classmark3.radio_cap_1-1;
+}
+#endif
+classmark_req->classmark.pclass2= 0;
+}
+PSENDX (PL, classmark_req );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_build_idle_req         |
++--------------------------------------------------------------------+
+PURPOSE : The function is used to configure the idle mode in layer 1.
+Two modes are possible: cell selection and cell reselection.
+In cell selection mode RR has all information to perform
+a complete layer 1 configuration. In cell reselection mode
+layer 1 is configured only as much as needed and it is
+expected that layer 1 goes in paging reorganization mode
+to catch all pagings and BCCH messages.
+*/
+GLOBAL void att_build_idle_req (UBYTE     index,
+UBYTE     mode)
+{
+GET_INSTANCE_DATA;
+T_CELL_DATA *cd;
+PALLOC (idle_req, MPH_IDLE_REQ);
+TRACE_FUNCTION ("att_build_idle_req()");
+/*
+* configure the mode of layer 1 (cell selection or cell reselection
+*/
+idle_req->mod       = mode;
+/*
+* set the pointer to the correct data
+* serving cell or one of the neighbourcells.
+*/
+if (index EQ SC_INDEX)
+{
+cd = &rr_data->sc_data.cd;
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+idle_req->si2quater_status = cd->si2quater_status;
+idle_req->si2quater_pos       = cd->si2quater_pos;
+if ( (mode EQ MODE_CELL_SELECTION ) AND
+(cd->si2quater_status EQ SI2QUATER_CONFIGURE) AND
+((rr_data->sc_data.cd.sys_info_read & (ALL_SYS_INFO_READ | SYS_INFO_2QUATER_READ)) EQ ALL_SYS_INFO_READ))
+rr_data->sc_data.cd.si2quater_status = SI2QUATER_ACQ_PENDING;
+#endif
+}
+else
+{
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+idle_req->si2quater_status = SI2QUATER_ABSENT;
+#endif
+cd = &rr_data->cr_data.cd;
+}
+/*
+* look to the reached service of RR
+*/
+switch (rr_data->ms_data.rr_service)
+{
+case LIMITED_SERVICE:
+/*
+* In limited mode no pagings are possible. To save
+* power the minimum number of measurements (equal
+* to a long paging period) is configured.
+* The other parameters are independent from BCCH or
+* SIM card, because paging is not possible.
+*/
+idle_req->pg            = 0;
+idle_req->tn            = 0;
+idle_req->ncc_permitted = NOT_PRESENT_8BIT;
+idle_req->dlt           = 10; /* for bs_pa_mfmrs = 9 */
+idle_req->bs_pa_mfrms   = 7;  /* for bs_pa_mfmrs = 9 */
+break;
+case FULL_SERVICE:
+/*
+* The MS is in full service. In this case the paging
+* block must be correctly from the SIM and the BCCH
+* data.
+*/
+idle_req->pg   = dat_calc_paging_group (index);
+idle_req->tn   = dat_calc_tn           (index);
+/*
+* The NCC permitted check in layer 1 is used to
+* avoid synchronisation to cells of other networks.
+*/
+#ifdef GPRS
+if(mode NEQ MODE_CELL_RESELECTION AND
+mode NEQ MODE_CELL_RESELECTION_SYNC_ONLY)
+#else
+if (mode NEQ MODE_CELL_RESELECTION)
+#endif
+idle_req->ncc_permitted = cd->ncc_permitted;
+else
+idle_req->ncc_permitted = NOT_PRESENT_8BIT;
+idle_req->dlt         = dat_calc_downlink_timeout (index);
+idle_req->bs_pa_mfrms = rr_data->nc_data[index].control_descr.bs_pa_mfrms;
+break;
+}
+idle_req->arfcn = rr_data->nc_data[index].arfcn;
+/* XXX
+* use ext_bcch for forwarding bsic, this solves
+* fieldtest problem of mismatch of BSICs.
+*/
+idle_req->ext_bcch  = rr_data->nc_data[index].bsic;
+idle_req->comb_ccch = rr_data->nc_data[index].control_descr.ccch_conf EQ COMB_CCCH_COMB;
+idle_req->bs_ag_blocks_res =
+rr_data->nc_data[index].control_descr.bs_ag_blks_res;
+idle_req->power = att_get_txpwr_max_cch (index);
+idle_req->reorg_only = NORMAL_PGM;
+idle_req->gprs_support = NOT_PRESENT_8BIT;
+#if defined FF_EOTD
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+idle_req->eotd_avail = (std EQ STD_1900 OR std EQ STD_850 OR std EQ STD_DUAL_US OR std EQ STD_850_1800 OR std EQ STD_850_900_1800 OR std EQ STD_850_900_1900);
+#else
+idle_req->eotd_avail = (std EQ STD_1900 OR std EQ STD_850 OR std EQ STD_DUAL_US);
+#endif
+#else
+idle_req->eotd_avail = 0;
+#endif
+#ifdef GPRS
+att_gprs_idle_req(idle_req);
+#endif
+EM_IDLE_MODE;
+#if defined(_SIMULATION_)
+switch (idle_req->mod)
+{
+case MODE_CELL_SELECTION      :  /* 0x0 cell selection                 */
+TRACE_EVENT_WIN ("MODE_CELL_SELECTION");
+break;
+case MODE_CELL_RESELECTION    :  /* 0x1 cell reselection               */
+TRACE_EVENT_WIN ("MODE_CELL_RESELECTION");
+break;
+#if defined(MODE_BACK_FROM_DEDICATED)
+case MODE_BACK_FROM_DEDICATED :  /* 0x2 back from dedicated            */
+TRACE_EVENT_WIN ("MODE_BACK_FROM_DEDICATED");
+break;
+#endif  /* MODE_BACK_FROM_DEDICATED */
+case MODE_IMM_ASSIGN          :  /* 0x3 immediate assignment           */
+TRACE_EVENT_WIN ("MODE_IMM_ASSIGN");
+break;
+case MODE_CHAN_ASSIGN         :  /* 0x4 channel assignment             */
+TRACE_EVENT_WIN ("MODE_CHAN_ASSIGN");
+break;
+case MODE_ASYNC_HANDOVER      :  /* 0x5 asynchronous handover          */
+TRACE_EVENT_WIN ("MODE_ASYNC_HANDOVER");
+break;
+case MODE_SYNC_HANDOVER       :  /* 0x6 synchronous handover           */
+TRACE_EVENT_WIN ("MODE_SYNC_HANDOVER");
+break;
+case MODE_PRE_SYNC_HANDOVER   :  /* 0x7 pre synchronous handover       */
+TRACE_EVENT_WIN ("MODE_PRE_SYNC_HANDOVER");
+break;
+case MODE_PSEUDO_SYNC_HANDOVER:  /* 0x8 pseudo synchronous handover    */
+TRACE_EVENT_WIN ("MODE_PSEUDO_SYNC_HANDOVER");
+break;
+case MODE_SYS_INFO_CHANGE     :  /* 0x9 sys info has changed           */
+TRACE_EVENT_WIN ("MODE_SYS_INFO_CHANGE");
+break;
+case MODE_PACKET_TRANSFER     :  /* 0xa enter packet transfer mode     */
+TRACE_EVENT_WIN ("MODE_PACKET_TRANSFER");
+break;
+case MODE_PDCH_ASSIGN         :  /* 0xb PDCH assignment                */
+TRACE_EVENT_WIN ("MODE_PDCH_ASSIGN");
+break;
+case MODE_CELL_CHANGE_ORDER   :  /* 0xc Network controlled Cell Change */
+TRACE_EVENT_WIN ("MODE_CELL_CHANGE_ORDER");
+break;
+case MODE_CELL_RESELECTION_SYNC_ONLY:  /* 0xc Network controlled Cell Change */
+TRACE_EVENT_WIN ("MODE_CR_SYNC_ONLY");
+break;
+case MODE_CONFIG_PL:  /* PBCCH */
+TRACE_EVENT_WIN ("MODE_CONFIG_PL");
+break;
+default:
+TRACE_EVENT_WIN_P1 ("idle_req mode %d unknown!", idle_req->mod);
+break;
+}
+#endif  /* _SIMULATION_ */
+if ((mode EQ MODE_CELL_SELECTION) AND
+(rr_data->ms_data.rr_service EQ FULL_SERVICE) AND
+(rr_data->cs_data.act_index NEQ NOT_PRESENT_8BIT))
+{
+rr_data->cs_data.act_index = NOT_PRESENT_8BIT;
+rr_csf_fit_capability ();
+#if !defined(NTRACE)
+rr_csf_trace_power ();
+#endif  /* !NTRACE */
+}
+PSENDX (PL, idle_req);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_calculate_c1           |
++--------------------------------------------------------------------+
+PURPOSE : The function calculates the path loss criterion C1 for
+cell selection and cell reselection purposes.
+REFERENCE: GSM 5.08, chapter 6.4 Criteria for cell selection and reselection
+*/
+/*
+* The following tables define conversion for the power in dBm depending
+* on the frequency band (GSM, DCS or PCS) and the power class (1 to 5).
+*/
+/*lint -esym(765,p_dcs) | external could be made static | used by GRR  */
+/*lint -esym(765,p_pcs) | external could be made static | used by GRR  */
+/*lint -esym(765,p_gsm) | external could be made static | used by GRR  */
+/*lint -esym(765,p_control_dcs) | external could be made static | used by GRR  */
+/*lint -esym(765,p_control_pcs) | external could be made static | used by GRR  */
+/*lint -esym(765,p_control_gsm) | external could be made static | used by GRR  */
+const SHORT p_dcs [MAX_CLASSES] = { P_CLASS_1_1800,
+P_CLASS_2_1800,
+P_CLASS_3_1800,
+P_CLASS_3_1800,
+P_CLASS_3_1800 };
+const SHORT p_pcs [MAX_CLASSES] = { P_CLASS_1_1900,
+P_CLASS_2_1900,
+P_CLASS_3_1900,
+P_CLASS_3_1900,
+P_CLASS_3_1900 };
+const SHORT p_gsm [MAX_CLASSES] = { P_CLASS_2_900,
+P_CLASS_2_900,
+P_CLASS_3_900,
+P_CLASS_4_900,
+P_CLASS_5_900 };
+/*
+* The following tables converts the air-interface coding of
+* the system information parameter MAX_TXPWR_CCCH to a value
+* in dBm depending on the frequency standard (GSM, DCS or PCS).
+*/
+const UBYTE p_control_gsm [32] =
+{                                   39,   /*  0 -> 39 dBm */
+39,   /*  1 -> 39 dBm */
+39,   /*  2 -> 39 dBm */
+37,   /*  3 -> 37 dBm */
+35,   /*  4 -> 35 dBm */
+33,   /*  5 -> 33 dBm */
+31,   /*  6 -> 31 dBm */
+29,   /*  7 -> 29 dBm */
+27,   /*  8 -> 27 dBm */
+25,   /*  9 -> 25 dBm */
+23,   /* 10 -> 23 dBm */
+21,   /* 11 -> 21 dBm */
+19,   /* 12 -> 19 dBm */
+17,   /* 13 -> 17 dBm */
+15,   /* 14 -> 15 dBm */
+13,   /* 15 -> 13 dBm */
+11,   /* 16 -> 11 dBm */
+9,   /* 17 ->  9 dBm */
+7,   /* 18 ->  7 dBm */
+5,   /* 19 ->  5 dBm */
+5,   /* 20 ->  5 dBm */
+5,   /* 21 ->  5 dBm */
+5,   /* 22 ->  5 dBm */
+5,   /* 23 ->  5 dBm */
+5,   /* 24 ->  5 dBm */
+5,   /* 25 ->  5 dBm */
+5,   /* 26 ->  5 dBm */
+5,   /* 27 ->  5 dBm */
+5,   /* 28 ->  5 dBm */
+5,   /* 29 ->  5 dBm */
+5,   /* 30 ->  5 dBm */
+5    /* 31 ->  5 dBm */
+};
+const UBYTE p_control_dcs [32] =
+{                                   30,   /*  0 -> 30 dBm */
+28,   /*  1 -> 28 dBm */
+26,   /*  2 -> 26 dBm */
+24,   /*  3 -> 24 dBm */
+22,   /*  4 -> 22 dBm */
+20,   /*  5 -> 20 dBm */
+18,   /*  6 -> 18 dBm */
+16,   /*  7 -> 16 dBm */
+14,   /*  8 -> 14 dBm */
+12,   /*  9 -> 12 dBm */
+10,   /* 10 -> 10 dBm */
+8,   /* 11 ->  8 dBm */
+6,   /* 12 ->  6 dBm */
+4,   /* 13 ->  4 dBm */
+2,   /* 14 ->  2 dBm */
+0,   /* 15 ->  0 dBm */
+0,   /* 16 ->  0 dBm */
+0,   /* 17 ->  0 dBm */
+0,   /* 18 ->  0 dBm */
+0,   /* 19 ->  0 dBm */
+0,   /* 20 ->  0 dBm */
+0,   /* 21 ->  0 dBm */
+0,   /* 22 ->  0 dBm */
+0,   /* 23 ->  0 dBm */
+0,   /* 24 ->  0 dBm */
+0,   /* 25 ->  0 dBm */
+0,   /* 26 ->  0 dBm */
+0,   /* 27 ->  0 dBm */
+0,   /* 28 ->  0 dBm */
+36,   /* 29 -> 36 dBm */
+34,   /* 30 -> 34 dBm */
+32    /* 31 -> 32 dBm */
+};
+const UBYTE p_control_pcs [32] =
+{                                   30,   /*  0 -> 30 dBm */
+28,   /*  1 -> 28 dBm */
+26,   /*  2 -> 26 dBm */
+24,   /*  3 -> 24 dBm */
+22,   /*  4 -> 22 dBm */
+20,   /*  5 -> 20 dBm */
+18,   /*  6 -> 18 dBm */
+16,   /*  7 -> 16 dBm */
+14,   /*  8 -> 14 dBm */
+12,   /*  9 -> 12 dBm */
+10,   /* 10 -> 10 dBm */
+8,   /* 11 ->  8 dBm */
+6,   /* 12 ->  6 dBm */
+4,   /* 13 ->  4 dBm */
+2,   /* 14 ->  2 dBm */
+0,   /* 15 ->  0 dBm */
+0,   /* 16 ->  0 dBm */
+0,   /* 17 ->  0 dBm */
+0,   /* 18 ->  0 dBm */
+0,   /* 19 ->  0 dBm */
+0,   /* 20 ->  0 dBm */
+0,   /* 21 ->  0 dBm */
+33,   /* 22 -> 33 dBm */
+33,   /* 23 -> 33 dBm */
+33,   /* 24 -> 33 dBm */
+33,   /* 25 -> 33 dBm */
+33,   /* 26 -> 33 dBm */
+33,   /* 27 -> 33 dBm */
+33,   /* 28 -> 33 dBm */
+33,   /* 29 -> 33 dBm */
+33,   /* 30 -> 33 dBm */
+32    /* 31 -> 32 dBm */
+};
+/*lint +e765 / used by GRR */
+GLOBAL void att_calculate_c1 (UBYTE      index)
+{
+GET_INSTANCE_DATA;
+SHORT a;
+SHORT b;
+const SHORT *p;
+const UBYTE *p_control;
+SHORT power_offset = 0;
+UBYTE ms_power;
+SHORT offset;
+TRACE_FUNCTION ("att_calculate_c1()");
+ms_power = att_get_power ();
+switch (std)
+{
+case STD_900:
+case STD_EGSM:
+case STD_850:
+/*
+* The table for the power class conversion is GSM 900, E-GSM or GSM 850
+*/
+p         = p_gsm;
+/*
+* The table for the MAX_TXPWR_CCCH conversion is GSM 900, E-GSM or GSM 850
+*/
+p_control = p_control_gsm;
+/*
+* The gsm_offset parameter can be set by a dynamic configuration command
+* and is not used.
+*/
+offset    = rr_data->dyn_config.gsm_offset;
+break;
+case STD_1900:
+p         = p_pcs;
+p_control = p_control_pcs;
+/*
+* The dcs_offset parameter can be set by a dynamic configuration command
+* and is not used.
+*/
+offset    = rr_data->dyn_config.dcs_offset;
+break;
+case STD_1800:
+p         = p_dcs;
+p_control = p_control_dcs;
+/* Ref 04.18 Section 10.5.2.35
+* Rest Octets IE includes parameters which are used by the mobile station
+* for cell selection and reselection purposes. It may also include the
+* POWER OFFSET parameter used by DCS 1800 Class 3 MS.
+*/
+if (ms_power EQ 0x02 AND
+rr_data->nc_data[index].c2_par.power_off_ind)
+{
+power_offset = rr_data->nc_data[index].c2_par.power_off << 1;
+}
+offset    = rr_data->dyn_config.dcs_offset;
+break;
+case STD_DUAL:
+case STD_DUAL_EGSM:
+/*
+* For dualband mobiles the calculation depends on the channel number
+*/
+if (INRANGE(LOW_CHANNEL_1800,rr_data->nc_data[index].arfcn,HIGH_CHANNEL_1800))
+{
+/*
+* All DCS 1800 channels
+*/
+p         = p_dcs;
+p_control = p_control_dcs;
+/* Ref 04.18 Section 10.5.2.35 */
+if (ms_power EQ 0x02 AND
+rr_data->nc_data[index].c2_par.power_off_ind)
+{
+power_offset = rr_data->nc_data[index].c2_par.power_off << 1;
+}
+offset    = rr_data->dyn_config.dcs_offset;
+}
+else
+{
+/*
+* All GSM 900 and E-GSM channels
+*/
+p         = p_gsm;
+p_control = p_control_gsm;
+offset    = rr_data->dyn_config.gsm_offset;
+}
+break;
+case STD_DUAL_US:
+if (rr_data->nc_data[index].arfcn < LOW_CHANNEL_1900)
+{
+/*
+* Then it is a GSM 850 channel
+*/
+p         = p_gsm;
+p_control = p_control_gsm;
+offset    = rr_data->dyn_config.gsm_offset;
+}
+else
+{
+/*
+* else it is a PCS 1900 channel
+*/
+p         = p_pcs;
+p_control = p_control_pcs;
+offset    = rr_data->dyn_config.dcs_offset;
+}
+break;
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+case STD_850_1800:
+case STD_850_900_1800:
+if (INRANGE(LOW_CHANNEL_1800,rr_data->nc_data[index].arfcn,HIGH_CHANNEL_1800))
+{
+/*
+* Then it is a DCS 1800 channel
+*/
+p         = p_dcs;
+p_control = p_control_dcs;
+if (ms_power EQ 0x02 AND
+rr_data->nc_data[index].c2_par.power_off_ind)
+{
+power_offset = rr_data->nc_data[index].c2_par.power_off << 1;
+}
+offset    = rr_data->dyn_config.dcs_offset;
+}
+else
+{
+/*
+* Else it is a GSM 900 and E-GSM or GSM 850 channel
+*/
+p         = p_gsm;
+p_control = p_control_gsm;
+offset    = rr_data->dyn_config.gsm_offset;
+}
+break;
+case STD_900_1900:
+case STD_850_900_1900:
+/*
+* For dualband mobiles the calculation depends on the channel number
+*/
+if (INRANGE(LOW_CHANNEL_1900,rr_data->nc_data[index].arfcn,HIGH_CHANNEL_1900))
+{
+/*
+* All PCS 1900 channels
+*/
+p         = p_pcs;
+p_control = p_control_pcs;
+offset    = rr_data->dyn_config.dcs_offset;
+}
+else
+{
+/*
+* All GSM 900 and E-GSM or GSM 850 channels
+*/
+p         = p_gsm;
+p_control = p_control_gsm;
+offset    = rr_data->dyn_config.gsm_offset;
+}
+break;
+#endif
+default:
+/*
+* Just for LINT
+*/
+rr_data->nc_data[index].c1 = 0;
+return;
+}
+/*
+* Parameter A indicates the difference between current fieldstrength and
+* the minimum expected from the infrastructure. It indicates how good is the
+* receiving part.
+*/
+#ifdef GPRS
+if(rr_data->gprs_data.use_c31)
+{
+a = (SHORT) rr_data->nc_data[index].rxlev -
+(SHORT) rr_data->nc_data[index].cr_par.gprs_rxlev_access_min;
+}
+else
+{
+#endif
+a = (SHORT) rr_data->nc_data[index].rxlev -
+(SHORT) rr_data->nc_data[index].select_para.rxlev_access_min;
+#ifdef GPRS
+}
+#endif
+/*
+* Parameter B indicates the difference between the maximum sending power
+* expected by the infrastructure and the maximum power which is possible by
+* the mobile. In the formula the maximum of B and zero is taking in account.
+* If B is negative, the MS has enough power to reach the base station,
+* because it has more power than expected and it will not have any affect
+* in the C1 calculation. If B is positive, the MS will send with less power
+* than expected by the infrastructure. Then this difference is subtracted
+* from A. The maximum power is expected at the boarder of the cell. If the
+* mobile is nearer to the base station, a lower power is needed. On the
+* other hand will the mobile receive the base station with a higher
+* fieldstrength as on the boarder. So this surplus compensates the lower
+* sending capabilities.
+*/
+#ifdef GPRS
+if(rr_data->gprs_data.use_c31)
+{
+b = p_control [rr_data->nc_data[index].cr_par.gprs_ms_txpwr_max_cch] - p[ms_power];
+}
+else
+{
+#endif
+b = p_control [rr_data->nc_data[index].select_para.ms_txpwr_max_cch] +
+power_offset - p[ms_power];
+#ifdef GPRS
+}
+#endif
+/*
+* The resulting path loss criterion is C1 = A - MAX (B,0)
+*
+* An additional C1_offset and offset is not really used. This values can
+* be configured and may compensate RF problems.
+*/
+rr_data->nc_data[index].c1 = a - att_max (b, 0) + rr_data->c1_offset +
+offset;
+/*
+* To avoid too many reselection the C1 of a neighbourcell is decreased,
+* that means beside the GSM specifications a threshold value is introduced.
+* If a test SIM card is inserted, this is not used.
+*/
+if (index NEQ SC_INDEX AND index NEQ CR_INDEX AND !dat_test_sim_available())
+rr_data->nc_data[index].c1 -= TWO;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_calculate_c2           |
++--------------------------------------------------------------------+
+PURPOSE : The reselection criterion C2 is used for cell reselection
+only and is defined by:
+C2 = C1 + CELL_RESELECT_OFFSET -
+TEMPORARY OFFSET * H(PENALTY_TIME - T)
+for PENALTY_TIME <> 11111
+C2 = C1 - CELL_RESELECT_OFFSET
+for PENALTY_TIME = 11111
+where
+For non-serving cells:
+H(x) = 0 for x < 0
+= 1 for x = 0
+For serving cells:
+H(x) = 0
+T is a timer implemented for each cell in the list of strongest carriers.
+T shall be started from zero at the time the cell is placed by the MS on the
+list of strongest carriers, except when the previous serving cell is placed
+on the list of strongest carriers at cell reselection. In this, case,
+T shall be set to the value of PENALTY_TIME (i.e. expired).
+CELL_RESELECT_OFFSET applies an offset to the C2 reselection criterion for that cell.
+NOTE: CELL_RESELECT_OFFSET may be used to give different priorities to different
+bands when multiband operation is used.
+TEMPORARY_OFFSET applies a negative offset to C2 for the duration of PENALTY_TIME
+after the timer T has started for that cell.
+PENALTY_TIME is the duration for which TEMPORARY_OFFSET applies The all ones bit
+pattern on the PENALTY_TIME parameter is reserved to change the sign of
+CELL_RESELECT_OFFSET and the value of TEMPORARY_OFFSET is ignored as indicated
+by the equation defining C2.
+CELL_RESELECT_OFFSET, TEMPORARY_OFFSET, PENALTY_TIME and CELL_BAR_QUALIFY are
+optionally broadcast on the BCCH of the cell. If not broadcast, the default values
+are CELL_BAR_QUALIFY = 0, and C2 = C1. The use of C2 is described in GSM 03.22.
+These parameters are used to ensure that the MS is camped on the cell with which it
+has the highest probability of successful communication on uplink and downlink.
+REFERENCE: GSM 5.08, chapter 6.4 Criteria for cell selection and reselection
+*/
+static void att_calculate_c2 (UBYTE index)
+{
+GET_INSTANCE_DATA;
+USHORT     h;
+T_NC_DATA *rrd;
+TRACE_FUNCTION ("att_calculate_c2()");
+/*
+* get a pointer to the data of the cell
+*/
+rrd = &rr_data->nc_data[index];
+/*
+* Calculate C1 as a base if no C2 parameters are available
+*/
+att_calculate_c1 (index);
+if ( rrd->c2_par.param_ind EQ 0 )
+{
+/*
+* C2 is equal C1 if no C2 parameters are available.
+*/
+rrd->c2 = rrd->c1;
+TRACE_C1_C2(index);
+return;
+}
+/*
+* Special case penalty time = 0b11111
+*/
+if (rrd->c2_par.penalty_time EQ 31)
+{
+rrd->c2 = rrd->c1 - 2 * rrd->c2_par.cell_reselect_offset;
+TRACE_C1_C2(index);
+return;
+}
+/*
+* Calculate x for H(x) and set H(x)
+*/
+if ((USHORT)((rrd->c2_par.penalty_time + 1) * 20) >=
+(USHORT)(rrd->avail_time/PERIOD_1_SEC))
+h = 1;
+else
+h = 0;
+/*
+* for the serving cells H(x) us ever zero.
+*/
+if (index EQ SC_INDEX)
+h = 0;
+/*
+* Calculate C2 using the formula
+*/
+rrd->c2 = rrd->c1 + 2 * rrd->c2_par.cell_reselect_offset -
+10 * rrd->c2_par.temp_offset * h;
+if (h EQ 1 AND rrd->c2_par.temp_offset EQ 7)
+{
+/*
+* temp offset = 7 means C2 = - infinite
+*/
+rrd->c2 = -127;
+}
+TRACE_C1_C2(index);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_calculate_c2_diff      |
++--------------------------------------------------------------------+
+PURPOSE : For cell reselection decision the C2 difference between
+a neighbourcell and the serving cell is calculated. This
+function shall be called only if both cells are in a
+different location area.
+If no SIM card is inserted (that means limited service)
+the threshold value is not taken in account. This is
+beside the GSM specifications and shall ensure a better
+coverage of the mobile. It leads not to more signalling
+on the air-interface.
+REFERENCE: GSM 5.08, chapter 6.6.2 Path loss criteria and timings for
+cell re-selection
+*/
+static SHORT att_calculate_c2_diff (UBYTE index)
+{
+GET_INSTANCE_DATA;
+SHORT delta;
+TRACE_FUNCTION ("att_calculate_c2_diff()");
+/*
+* calculate delta
+*/
+delta = rr_data->nc_data[index].c2 - rr_data->nc_data[SC_INDEX].c2;
+/* According to 3GPP 05.08 Sec 6.8 MS is supposed to use ZERO for
+* CELL_RESELECT_HYSTERESIS when in Limited service.
+* c)	The MS shall perform cell reselection at least among the cells of
+* the PLMN of the cell on which the MS has camped, according to the
+* algorithm of 3GPP TS 03.22, except that a zero value of
+* CELL_RESELECT_HYSTERESIS shall be used.
+*/
+if ((rr_data->ms_data.imsi_available) AND
+(rr_data->ms_data.rr_service NEQ LIMITED_SERVICE))
+delta -= 2*rr_data->nc_data[SC_INDEX].select_para.cell_resel_hyst;
+/*
+* return the difference
+*/
+return delta;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_calculate_digits       |
++--------------------------------------------------------------------+
+PURPOSE : The function calculates the number of the digits in a
+mobile identity infoelement. The input parameter contains
+one BCD digit in each field entry.
+*/
+static UBYTE att_calculate_digits (UBYTE *digits)
+{
+UBYTE i = 0;
+TRACE_FUNCTION ("att_calculate_digits()");
+/*
+* Check whether the end is detected
+*/
+while (digits[i] < 0x0A AND i < 16)
+i++;
+return i;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_cell_barred_status_cr_no_cr  |
++--------------------------------------------------------------------+
+PURPOSE : Checks whether a cell is barred or not for cell reselection
+purposes.
+CELL_BAR QUALIFY   CELL_BAR ACCESS   CS priority    Status for CR
+0                     0             normal          normal
+0                     1             barred          barred
+1                     0             low             normal (see note 2)
+1                     1             low             normal (see note 2)
+If all the following conditions are met, then the "Cell selection priority"
+and the "Status for cell reselection" shall be set to normal:
+- the cell belongs to the MS HPLMN;
+- the MS is in cell test operation mode;
+- the CELL_BAR_ACCESS is set to "1";
+- the CELL_BAR_QUALIFY is set to "0";
+- the Access Control class 15 is barred.
+NOTE 1: A low priority cell is only selected if there are no
+suitable cells
+of normal priority (see GSM 03.22).
+NOTE 2: Two identical semantics are used for cross phase
+compatibility reasons.
+This allows an operator to declare a cell always as a low
+priority one for a phase 2 MS, but keeps the opportunity
+for an operator to decide wether a phase 1 MS is permitted
+to camp on such a cell or not.
+REFERENCE: GSM 5.08, chapter 9, table 1a
+*/
+GLOBAL BOOL att_cell_barred_status_cr_no_cr (UBYTE index)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_cell_barred_status_cr_no_cr()");
+TRACE_EVENT_P5 ("[%u]%u cbq=%u cba=%u access class=%04x",
+rr_data->nc_data[index].arfcn,
+index,
+rr_data->nc_data[index].c2_par.cbq,
+rr_data->nc_data[index].rach.cell_bar_access,
+rr_data->nc_data[index].rach.ac);
+/*
+* check first the special case
+*/
+if (dat_hplmn (rr_data->nc_data[index].lai.mcc,
+rr_data->nc_data[index].lai.mnc) AND
+rr_data->cell_test_operation AND
+rr_data->nc_data[index].c2_par.cbq EQ 0 AND
+rr_data->nc_data[index].rach.cell_bar_access EQ 1)
+{
+/*
+* access class 15 is set
+*/
+if (rr_data->nc_data[index].rach.ac & 0x8000)
+return FALSE;
+}
+/*
+* the cell reselection status is normal. According
+* to the table above the cell is only barred if
+* the cell bar qualifier is set to 0 and the
+* cell bar access is set to 1.
+*/
+if((rr_data->nc_data[index].rach.cell_bar_access EQ BARRED_YES) AND
+rr_data->nc_data[index].c2_par.cbq EQ CBQ_NO)
+return TRUE;
+else
+return FALSE;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_cell_in_data_structures|
++--------------------------------------------------------------------+
+PURPOSE : After reception of new measurement values from layer 1
+this function checks whether a neighbourcell indicated
+with the parameter index is stored inside the RR
+storage area.
+*/
+static BOOL att_cell_in_data_structures (T_MPH_MEASUREMENT_IND *report,
+UBYTE                  index)
+{
+GET_INSTANCE_DATA;
+USHORT i;
+TRACE_FUNCTION ("att_cell_in_data_structures()");
+/*
+* check for all areas
+*/
+for (i = 0; i < 6; i++)
+{
+/*
+* If a cell is stored in the data area
+*/
+if (rr_data->nc_data[i].bcch_status NEQ EMPTY)
+{
+/*
+* check the channel number
+*/
+if (rr_data->nc_data[i].arfcn EQ report->ncells.arfcn[index])
+return TRUE;
+}
+}
+return FALSE;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)     MODULE  : RR_ATT                       |
+| STATE   : code              ROUTINE : att_remove_multiple_channels |
++--------------------------------------------------------------------+
+PURPOSE : During fieldtests it had happens that the measurements from
+layer 1 may contain the serving cell as a neighbourcell
+(which is possible during connection and can be forwarded
+to RR after connection). This leads to double stored data
+in RR.
+*/
+GLOBAL void att_remove_multiple_channels (void)
+{
+GET_INSTANCE_DATA;
+USHORT i;
+TRACE_FUNCTION ("att_remove_multiple_channels()");
+/*
+* For all neighbourcells in the measurement report
+*/
+for (i = 0; i < 6; i++)
+{
+if (rr_data->nc_data[i].arfcn EQ rr_data->nc_data[SC_INDEX].arfcn)
+{
+/*
+* If the neighbourcell channel number is equal to the serving
+* cell, clear the whole storage area.
+*/
+rr_data->nc_data[i].arfcn       = 0;
+rr_data->nc_data[i].bcch_status = EMPTY;
+}
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_cell_in_measure_report |
++--------------------------------------------------------------------+
+PURPOSE : The function checks whether a cell in the RR storage
+area is still in a new measurement report and returns
+one of the three possibilities:
+CELL_IS_INSERTED      the cell is inside with the same BSIC
+BSIC_HAS_CHANGED      the cell is inside, but the BSIC has changed
+CELL_IS_NOT_INSERTED  the cell is not longer inside.
+*/
+static UBYTE att_cell_in_measure_report (T_MPH_MEASUREMENT_IND *report,
+UBYTE                  index)
+{
+GET_INSTANCE_DATA;
+UBYTE  i;
+UBYTE  bsic;
+TRACE_FUNCTION ("att_cell_in_measure_report()");
+/*
+* check all neighbourcells in the measurent report
+*/
+for (i = 0; i < report->ncells.no_of_ncells; i++)
+{
+/*
+* Check first the channel number
+*/
+if (rr_data->nc_data[index].arfcn EQ report->ncells.arfcn[i])
+{
+/*
+* Update fieldstrength value in the RR storage area
+*/
+rr_data->nc_data[index].rxlev = report->ncells.rx_lev[i];
+/*
+* Check whether the BSIC has been changed. Layer 1 sends an
+* 8 bit value, but only the lower 6 bits are significant.
+*/
+bsic = rr_data->nc_data[index].bsic & 0x3F;
+if (bsic EQ (report->ncells.bsic[i] & 0x3F))
+return CELL_IS_INSERTED;
+else
+{
+/*
+* If it is a changed BSIC, update the value in the RR storage area.
+*/
+rr_data->nc_data[index].bsic = report->ncells.bsic[i] & 0x3F;
+return BSIC_HAS_CHANGED;
+}
+}
+}
+/*
+* Not found
+*/
+return CELL_IS_NOT_INSERTED;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_check_bcch_carrier_cco |
++--------------------------------------------------------------------+
+PURPOSE : During a Cell Change Order procedure:
+After reception of all needed system information messages
+a carrier is checked for cell selection purposes.
+*/
+#ifdef GPRS
+LOCAL void att_check_bcch_carrier_cco (void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_check_bcch_carrier_cco()");
+dat_rrgrr_data_ind (rr_data->gprs_data.dl_data_ind);
+rr_data->gprs_data.dl_data_ind = NULL;
+att_build_idle_req (CR_INDEX, MODE_CELL_SELECTION);
+SET_STATE (STATE_ATT, ATT_IDLE);
+dat_att_cell_selected();
+if (att_gprs_is_avail())
+{
+att_signal_gprs_support();
+}
+att_start_registration_timer ();
+}
+#endif
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_check_bcch_carrier_si  |
++--------------------------------------------------------------------+
+PURPOSE : After reception of all needed system information messages
+a carrier is checked for cell selection purposes.
+Perform the check on the presence of the SIs.
+*/
+GLOBAL void att_check_bcch_carrier_si (void)
+{
+GET_INSTANCE_DATA;
+if (rr_data->cr_data.cd.sys_info_read EQ ALL_SYS_INFO_READ)
+{
+att_check_bcch_carrier ();
+}
+}
+GLOBAL void att_store_plmn_in_found_list (T_loc_area_ident *lai)
+{
+GET_INSTANCE_DATA;
+T_FOUND_ELEMENT *found;
+/* Implements RR Clone findings #8 */
+BOOL cell_ok = !att_cell_barred_status_cr_no_cr(CR_INDEX) AND
+(rr_data->nc_data[CR_INDEX].c1 > 0) AND
+att_priority_check ();
+if ( (found = att_plmn_in_found_list (lai->mcc, lai->mnc)) NEQ NULL )
+{
+if ( found->cell_ok  EQ 0 AND   /* old cell did not allow access */
+cell_ok NEQ 0 )     /* new cell does    allow access */
+{
+;    /* a better cell has been found */
+}
+else
+{
+found = NULL;
+}
+}
+else
+if ( rr_data->sc_data.found_entries < MAX_PLMN AND att_check_network(lai) )
+{
+found = &rr_data->sc_data.found[rr_data->sc_data.found_entries];
+rr_data->sc_data.found_entries++;
+}
+else
+{
+TRACE_EVENT ("cannot store PLMN" );
+}
+if ( found )
+{
+att_save_found_plmn (
+found,
+lai->mcc, lai->mnc,
+rr_data->nc_data[CR_INDEX].arfcn,
+rr_data->nc_data[CR_INDEX].rxlev, lai->lac, (UBYTE)cell_ok);
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_check_bcch_carrier     |
++--------------------------------------------------------------------+
+PURPOSE : After reception of all needed system information messages
+a carrier is checked for cell selection purposes.
+*/
+GLOBAL void att_check_bcch_carrier (void)
+{
+GET_INSTANCE_DATA;
+T_loc_area_ident * lai;
+BOOL  plmn_ok = FALSE;
+BOOL  cell_ok,prio_ok;
+UBYTE tried_to_reach_full_try_limited = (rr_data->cs_data.scan_mode EQ CS_SECOND_SCAN);
+TRACE_FUNCTION ("att_check_bcch_carrier()");
+/*
+* stop the timer which controls the reception of
+* all system information messages during cell selection.
+*/
+TIMERSTOP (T_RESELECT);
+/*
+* If procedure RR Network Controlled Cell Change Order
+* is running then call a different function and return.
+*/
+#ifdef GPRS
+if ( rr_data->gprs_data.tbf_est EQ TBF_EST_CCO )
+{
+att_check_bcch_carrier_cco();
+return;
+}
+#endif
+lai = &rr_data->nc_data[CR_INDEX].lai;
+/*
+* calculate the path loss criterion
+*/
+att_calculate_c1 (CR_INDEX);
+TRACE_C1(CR_INDEX);
+/*
+* the check depends on the service which has been requested
+* by RR. This can be the same as the service requested by MM,
+*/
+switch (rr_data->ms_data.req_mm_service)
+{
+case FUNC_PLMN_SRCH:
+/*
+* For full service the mobile country code and the mobile network code
+* must match with the PLMN identification requested by MM.
+*/
+plmn_ok = dat_plmn_equal_req (lai->mcc,
+lai->mnc,
+rr_data->ms_data.plmn.mcc,
+rr_data->ms_data.plmn.mnc);
+TRACE_EVENT_P6 ( "MCC/MNC r=%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_P7 ( "MCC/MNC i=%x%x%x/%x%x%x %s",
+lai->mcc[0],
+lai->mcc[1],
+lai->mcc[2],
+lai->mnc[0],
+lai->mnc[1],
+lai->mnc[2],
+plmn_ok?"OK":"");
+if (!plmn_ok AND
+(GET_STATE(STATE_ATT) EQ ATT_CS2) AND
+(rr_data->ms_data.rr_service EQ LIMITED_SERVICE OR
+rr_data->ms_data.rr_service EQ NO_SERVICE) AND
+(rr_data->cs_data.check_hplmn EQ TRUE) AND
+(((rr_data->ms_data.operation_mode >> SHIFT_FOR_SEARCH_OFFSET) & 1) EQ M_AUTO))
+{
+/* Compare with HPLMN */
+if (rr_data->ms_data.imsi_available)
+{
+plmn_ok = dat_plmn_equal_req (lai->mcc,
+lai->mnc,
+&rr_data->ms_data.imsi.ident_dig[0],
+&rr_data->ms_data.imsi.ident_dig[3]);
+if (plmn_ok)
+{
+TRACE_EVENT ("HPLMN Matched");
+}
+}
+/* compare with AHPLMN */
+if(!plmn_ok AND rr_data->ms_data.ahplmn.v_plmn EQ TRUE)
+{
+plmn_ok = dat_plmn_equal_req (lai->mcc,
+lai->mnc,
+rr_data->ms_data.ahplmn.mcc,
+rr_data->ms_data.ahplmn.mnc);
+if (plmn_ok)
+{
+TRACE_EVENT ("AHPLMN Matched");
+}
+}
+/* Compare with LRPLMN */
+if (!plmn_ok AND rr_data->cs_data.last_reg_plmn.v_plmn EQ V_PLMN_PRES)
+{
+plmn_ok = dat_plmn_equal_req (lai->mcc,
+lai->mnc,
+rr_data->cs_data.last_reg_plmn.mcc,
+rr_data->cs_data.last_reg_plmn.mnc);
+if (plmn_ok)
+{
+TRACE_EVENT ("LRPLMN Matched");
+}
+}
+/* Compare with Last Serving Cell PLMN from White List */
+if ((!plmn_ok) AND (rr_data->sc_data.mm_started EQ RR_ORIGINATED) AND
+(rr_data->ms_data.plmn.v_plmn EQ V_PLMN_PRES))
+{
+plmn_ok = dat_plmn_equal_req (lai->mcc,
+lai->mnc,
+rr_data->cs_data.white_list.last_sc_lac.mcc,
+rr_data->cs_data.white_list.last_sc_lac.mnc);
+if (plmn_ok)
+{
+TRACE_EVENT ("White List PLMN Matched");
+}
+}
+}
+if (plmn_ok)
+tried_to_reach_full_try_limited = FALSE;
+/*lint -fallthrough*/
+case FUNC_LIM_SERV_ST_SRCH:
+if((rr_data->ms_data.req_mm_service EQ FUNC_LIM_SERV_ST_SRCH) OR
+tried_to_reach_full_try_limited)
+{
+/*
+* The mobile shall reach limited service. This is the case
+* if no full service is possible or no SIM card is inserted.
+*
+* The network check is in principle ever true. The function
+* att_check_network realises a SW shielding to reject public
+* networks in final type approvals.
+*
+* The criterion for the cell checking is a non-barred cell and
+* a positive path loss criterion.
+*/
+plmn_ok = att_check_network (lai);
+/* Implements RR Clone findings #8 */
+cell_ok = !att_cell_barred_status_cr_no_cr (CR_INDEX) AND
+(rr_data->nc_data[CR_INDEX].c1 > 0);
+}
+else
+{
+/*
+* Full service is requested.
+*
+* First store PLMN of the cell in the PLMN found list
+* if the list is not stored yet and not full. SW shielding
+* is taking into account for FTA purposes.
+*
+* If the cell selection fails and no carrier was suitable,
+* at least a list of the found channels is available.
+*/
+if(dat_forb_lai_check (CR_INDEX))
+{
+att_store_plmn_in_found_list (lai);
+}
+else
+{
+TRACE_EVENT ("Do not store Forbidden LAI PLMN in the found PLMN list");
+}
+/*
+* The requirements for the cell are: it must be a non-barred cell,
+* it must have a positive path loss criterion. The cell shall not
+* be inside of a forbidden location area and it must be a high priority
+* cell if it is the first scan first attempt.
+*/
+/* Implements RR Clone findings #8 */
+cell_ok = !att_cell_barred_status_cr_no_cr (CR_INDEX) AND
+(rr_data->nc_data[CR_INDEX].c1 > 0);
+prio_ok = att_priority_check ();
+TRACE_EVENT_P1 ( "cell_ok     = %d", cell_ok);
+TRACE_EVENT_P1 ( "prio_ok     = %d", prio_ok);
+/*
+* if the network and cell are okay, but the priority check fails,
+* this cell is a low priority cell and can be checked in the
+* first scan second attempt.
+*/
+if (plmn_ok AND cell_ok AND !prio_ok)
+cs_set_attributes (LOW_PRIORITY_CELL,
+rr_data->nc_data[CR_INDEX].arfcn);
+/*
+* if the bcch carrier is not suitable for full service,
+* but suitable for limited service, try it
+* for emergency services in the second attempt.
+* priority check is not required for emergency cells
+*/
+if (cell_ok AND !plmn_ok)
+cs_set_attributes (EMERGENCY_CELL,
+rr_data->nc_data[CR_INDEX].arfcn);
+/* Update the cell_ok flag with with priority check flag */
+if(cell_ok)
+cell_ok = prio_ok;
+/* Checking access class and the list for cause #12 for */
+/* selection of the cell to camp on may not meet the    */
+/* requirements of GSM 03.22 subclause 3.5.3, 3.5.4.    */
+/* However, it is perfectly correct to consider the     */
+/* forbidden location areas for roaming list here.      */
+/*
+* If cell selection has been launched by MM in manual mode
+* we don't check against the forbidden location area lists.
+* This is to allow the user to select a network manually
+* which is a member of a forbidden list.
+* Maybe the distinction manual/automatic is not worth the
+* effort, as in contradiction to the forbidden list for
+* cause #11 the user can get rid of the forbidden lists for
+* cause #12 and #13 either by a power cycle or by simply
+* waiting some hours.
+*/
+if (!rr_data->sc_data.mm_started OR
+((rr_data->ms_data.operation_mode >> SHIFT_FOR_SEARCH_OFFSET) & 1) EQ M_AUTO)
+{
+/*
+* RR started cell selection, or MM started but in automatic
+* so ensure no barred LA is entered.
+*/
+if (cell_ok)
+{
+cell_ok = (dat_forb_lai_check (CR_INDEX) AND
+dat_roam_forb_lai_check (CR_INDEX));
+/* Candidate for Limited service */
+if(!cell_ok)
+cs_set_attributes (EMERGENCY_CELL,
+rr_data->nc_data[CR_INDEX].arfcn);
+}
+}
+#if defined (_SIMULATION_)
+{
+/*
+* Trace output for cell selection analysis
+*/
+/* Implements RR Clone findings #8 */
+BOOL cb_stat = att_cell_barred_status_cr_no_cr (CR_INDEX);
+BOOL for_lai = dat_forb_lai_check (CR_INDEX);
+BOOL prio    = att_priority_check();
+TRACE_EVENT_WIN_P1 ( "CB_STAT     = %d", cb_stat);
+TRACE_EVENT_WIN_P1 ( "C1          = %d", rr_data->nc_data[CR_INDEX].c1);
+TRACE_EVENT_WIN_P1 ( "FOR_LAI     = %d", for_lai);
+TRACE_EVENT_WIN_P1 ( "PRIO        = %d", prio);
+}
+#endif  /* _SIMULATION_ */
+}
+break;
+default:
+/*
+* MM has requested the list of the available PLMNs. The algorithm
+* for this is to indicate all carriers as "not suitable" for cell
+* selection. As a result the list of the available PLMNs is build
+* after scanning all carriers.
+*
+* First step is to store PLMN in plmn found list if the PLMN is not
+* stored yet and the list is not full. SW shielding is used for
+* FTA purposes.
+*/
+att_store_plmn_in_found_list (lai);
+/*
+* Define the channel as a candidate for limited service.
+*/
+cs_set_attributes (EMERGENCY_CELL,
+rr_data->nc_data[CR_INDEX].arfcn);
+/*
+* Remove all channels of the neighbourcell list from the power campaign
+* list. If the configuration of the network is sensible, this cell will
+* contain also channels of the same network. So it is not necessary to
+* scan this channels. The available PLMN list is the same, it consumes
+* only time.
+*/
+cs_del_list (&rr_data->cr_data.cd.ncell_list);
+plmn_ok = FALSE;
+cell_ok = FALSE;
+/*
+* start synchronisation attempt to the next cell
+*/
+memset (&rr_data->nc_data[CR_INDEX], 0, sizeof (T_NC_DATA));
+if (rr_data->ms_data.rr_service EQ NO_SERVICE)
+{
+SET_STATE (STATE_ATT, ATT_CS1);
+}
+srv_clear_list (&rr_data->cr_data.cd.ncell_list);
+cs_sync_next ();
+return;
+}
+if( (!tried_to_reach_full_try_limited) AND (rr_data->cs_data.scan_mode EQ CS_SECOND_SCAN))
+{
+if(!cell_ok)
+{
+/*
+* plmn is OK, cell is not OK for full service
+* however cell may be OK for limited service
+*/
+tried_to_reach_full_try_limited = TRUE;
+/* Implements RR Clone findings #8 */
+cell_ok = !att_cell_barred_status_cr_no_cr (CR_INDEX) AND
+(rr_data->nc_data[CR_INDEX].c1 > 0);
+}
+}
+/*
+* Trace output for cell selection analysis
+*/
+TRACE_EVENT_P1 ( "req.service = %s", _rr_str_FUNC[rr_data->ms_data.req_mm_service]);
+TRACE_EVENT_P1 ( "plmn_ok     = %d", plmn_ok );
+TRACE_EVENT_P1 ( "cell_ok     = %d", cell_ok);
+/*
+* checking of the requirements has been done. The result
+* is defined by plmn_ok and cell_ok.
+*/
+if (plmn_ok AND cell_ok)
+{
+/*
+* Network and Cell are okay. Just use the cell
+* set RR service according to the checked service
+*/
+/* If the MS reselects back onto the same SC and T3122 is still running, it should */
+/* be left running. If a new cell is selected, this timer should be stopped. */
+if( rr_data->nc_data[SC_INDEX].arfcn NEQ rr_data->nc_data[CR_INDEX].arfcn)
+{
+TIMERSTOP(T3122);
+}
+if (rr_data->ms_data.req_mm_service EQ FUNC_LIM_SERV_ST_SRCH OR
+(tried_to_reach_full_try_limited))
+{
+rr_data->ms_data.rr_service = LIMITED_SERVICE;
+}
+else
+{
+rr_data->ms_data.rr_service = FULL_SERVICE;
+}
+TRACE_EVENT_P4 ("NEW SC [%d]->[%d] (rMM=%s RRs=%s)",
+rr_data->nc_data[SC_INDEX].arfcn,
+rr_data->nc_data[CR_INDEX].arfcn,
+_rr_str_FUNC[rr_data->ms_data.req_mm_service],
+_rr_str_SERVICE[rr_data->ms_data.rr_service]);
+/*
+* set the result in the CR_INDEX area and copy then all
+* stuff to the SC_INDEX area.
+*/
+rr_data->nc_data[CR_INDEX].bcch_status  = DECODED;
+rr_data->nc_data[CR_INDEX].bcch_counter = 0;
+rr_data->nc_data[CR_INDEX].c1_counter   = 0;
+att_copy_cr_data ();
+memcpy (&rr_data->sc_data.cd, &rr_data->cr_data.cd,
+sizeof (T_CELL_DATA));
+rr_data->nc_data[CR_INDEX].arfcn = NOT_PRESENT_16BIT;
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+rr_data->sc_data.ba_index  = rr_data->cr_data.ba_index;
+rr_data->cr_data.ba_index = NOT_PRESENT_8BIT;
+#endif
+/* CSI-LLD section:4.1.1.10
+* This function updates the black list after the first successful
+* FUNC_PLMN_SEARCH
+*/
+if(rr_data->cs_data.initial_plmn_search EQ INITIAL_PLMN_SEARCH_ACTIVE)
+{
+cs_update_black_list();
+rr_data->cs_data.initial_plmn_search = INITIAL_PLMN_SEARCH_DONE;
+}
+/* Full service reached. Perform all necessary tasks */
+if(rr_data->ms_data.rr_service EQ FULL_SERVICE)
+{
+att_full_service_found();
+}
+/*
+* Indicate the result of cell selection to MM
+*/
+if (tried_to_reach_full_try_limited)
+{
+/*
+* The result is not what MM has requested.
+* E.g. MM has requested full service, but RR has
+* reached only limited service. In this case
+* MM gets the list of the available PLMNs and may
+* select on of the networks for a new attempt in
+* case of automatic registration.
+*/
+att_copy_old_lai_rac(CR_INDEX);
+#if 0
+memcpy (&rr_data->old_lai, &rr_data->nc_data[CR_INDEX].lai,
+sizeof(T_loc_area_ident));
+rr_data->old_cell_id = rr_data->nc_data[CR_INDEX].cell_id;
+#endif
+#ifdef GPRS
+if(att_gprs_is_avail())
+{ /* we have GPRS and have reached limited service */
+cs_set_stop_active();
+if(att_gprs_cell_has_pbcch())
+{
+att_gprs_stop_pl();
+}
+else
+{
+att_set_pl_in_idle_mode ();
+}
+att_signal_gprs_support();
+/* and wait for CR_REQ(CR_COMPLETE) from GRR */
+}
+else
+{
+#endif
+/*
+* Configure layer 1
+*/
+att_set_pl_in_idle_mode ();
+/*
+* Indicated the data transfer process that the MS is attached.
+*/
+dat_att_cell_selected ();
+SET_STATE (STATE_ATT, ATT_IDLE);
+cs_set_stop_active();
+att_code_rr_abort_ind (RRCS_ABORT_CEL_SEL_FAIL);
+att_start_registration_timer ();
+att_mph_identity_req ();
+srv_use_stored_prim ();
+#ifdef GPRS
+}
+#endif
+}
+else
+{
+/*
+* the cell selection was successful. The counter
+* for failed registration attempts is resetted and
+* MM is informed.
+*/
+rr_data->ms_data.reg_counter = 0;
+#ifdef GPRS
+if(! att_gprs_is_avail())
+{
+#endif
+/*
+* Configure layer 1
+*/
+att_set_pl_in_idle_mode ();
+/*
+* Indicated the data transfer process that the MS is attached.
+*/
+dat_att_cell_selected ();
+SET_STATE (STATE_ATT, ATT_IDLE);
+cs_set_stop_active();
+/* inform GRR if we have GPRS support */
+#ifdef GPRS
+if(att_gprs_is_avail())
+{
+att_signal_gprs_support();
+}
+#endif
+/* Inform MM */
+if (rr_data->sc_data.mm_started)
+att_code_rr_act_cnf ();
+else
+att_code_rr_act_ind ();
+srv_use_stored_prim ();
+att_start_registration_timer ();
+att_mph_identity_req ();
+#ifdef GPRS
+}
+else
+{ /* we have GPRS and have reached full service */
+cs_set_stop_active();
+if(att_gprs_cell_has_pbcch())
+{
+att_gprs_stop_pl();
+}
+else
+{
+att_set_pl_in_idle_mode ();
+}
+att_signal_gprs_support();
+/* and wait for CR_REQ(CR_COMPLETE) from GRR */
+}
+#endif
+/* This flag will help to identify whether cell reselection following
+* TRESELECT expiry waiting for SI2TER is successfull or not
+*/
+rr_data->cr_treselect_exp = TRUE;
+}
+return;
+}
+/*
+* BCCH carrier check has failed
+* Either cell_ok or plmn_ok is FALSE or both.
+*/
+if(plmn_ok EQ FALSE)
+{
+/*
+*  PLMN is not okay, but the cell
+*/
+if (rr_data->ms_data.imsi_available AND
+(dat_test_sim_available () EQ FALSE))
+{
+/*
+* with SIM card, that means full service.
+* "delete neighbourcells", that means give all
+* neighbourcells a low priority in scanning.
+*
+* It is assumed that this cell will fail also
+* because they are also member of the wrong network.
+*
+* This is not done during FTA campaign.
+*/
+cs_del_list (&rr_data->cr_data.cd.ncell_list);
+}
+}
+if(plmn_ok AND
+cell_ok EQ FALSE)
+{
+/*
+* plmn okay but not the cell
+*/
+if (rr_data->ms_data.imsi_available AND
+dat_test_sim_available() EQ FALSE)
+{
+/*
+* with SIM card, that means full service.
+* "set neighbourcells", that means give all
+* neighbourcells a higher priority in scanning.
+* Not done during FTA campaign
+*/
+cs_set_list (&rr_data->cr_data.cd.ncell_list);
+}
+}
+/*
+* start synchronisation attempt to the next cell
+*/
+memset (&rr_data->nc_data[CR_INDEX], 0, sizeof (T_NC_DATA));
+/*
+* After BCCH Reading if the requested service is not found,
+* before sending BSIC_REQ RR has to be moved to ATT_CS1.
+*/
+if(rr_data->ms_data.rr_service EQ NO_SERVICE OR
+GET_STATE(STATE_ATT) EQ ATT_CS2)
+{
+SET_STATE (STATE_ATT, ATT_CS1);
+}
+srv_clear_list (&rr_data->cr_data.cd.ncell_list);
+#ifdef GPRS
+if(GET_STATE(STATE_ATT) NEQ ATT_IDLE)
+gprs_init_data_cr();
+#endif
+cs_sync_next ();
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_check_fplmn_cell       |
++--------------------------------------------------------------------+
+PURPOSE : If the mobile is in limited service, but MM has requested
+full service, RR starts after timeout of the registration
+timer new attempts to reach full service. After reading
+system information message 3 or 4 of the candidate, this
+function is called, to check whether the cell fullfills
+the requirements for a full service cell. In this case
+a cell reselection is started to read the whole BCCH to
+configure layer 1.
+*/
+GLOBAL void att_check_fplmn_cell (void)
+{
+GET_INSTANCE_DATA;
+UBYTE              cell_ok;
+UBYTE              plmn_ok;
+T_loc_area_ident * lai = &rr_data->nc_data[CR_INDEX].lai;
+TRACE_FUNCTION ("att_check_fplmn_cell()");
+/*
+* Calculate the path loss criterion
+*/
+att_calculate_c1 (CR_INDEX);
+TRACE_C1(CR_INDEX);
+/*
+* check that the cell is not barred and has a positive path loss
+* criterion.
+*/
+/* Implements RR Clone findings #8 */
+cell_ok = (!att_cell_barred_status_cr_no_cr (CR_INDEX) AND
+(rr_data->nc_data[CR_INDEX].c1 > 0)AND dat_roam_forb_lai_check (CR_INDEX));
+;
+/*
+* check whether the PLMN identification is equal to the PLMN which has
+* been requested by MM.
+*/
+plmn_ok = dat_plmn_equal_req (lai->mcc,
+lai->mnc,
+rr_data->ms_data.plmn.mcc,
+rr_data->ms_data.plmn.mnc);
+/*
+* stop of T_RESELECT. This timer controls the reception of the initial
+* system information message.
+*/
+TIMERSTOP (T_RESELECT);
+/*
+* store PLMN in plmn found list to provide this information to MM
+* at the end of a failed registration attempt.
+*/
+if(dat_forb_lai_check (CR_INDEX))
+{
+att_store_plmn_in_found_list (lai);
+}
+else
+{
+TRACE_EVENT ("Do not store Forbidden LAI PLMN in the found PLMN list");
+}
+if (plmn_ok)
+{
+if (cell_ok)
+{
+/*
+* Enable nc monitoring to resume in lower layer
+* when recovering full service
+*/
+att_notify_stop_plmn_search (FALSE);
+/*
+* cell and PLMN are okay, then start cell reselection to read
+* the complete BCCH to configure layer 1.
+*/
+/*XY:n inform GRR, and       wait for CR_RSP */
+#ifdef GPRS
+att_start_cell_reselection_gprs (CELL_RESELECTION_CR);
+#else
+att_start_cell_reselection (CELL_RESELECTION_CR);
+#endif
+return;
+}
+}
+if (cell_ok)
+{
+/*
+* PLMN is not okay, but the cell
+*
+* "delete neighbourcells", that means give all
+* neighbourcells a low priority in scanning.
+*/
+if (dat_test_sim_available () EQ FALSE)
+cs_del_list (&rr_data->cr_data.cd.ncell_list);
+}
+else
+{
+/*
+* PLMN okay but not the cell
+*
+* "set neighbourcells", that means give all
+* neighbourcells a higher priority in scanning.
+*/
+if (dat_test_sim_available () EQ FALSE)
+{
+if (plmn_ok)
+/*
+* with SIM card, that means full service.
+* "set neighbourcells", that means give all
+* neighbourcells a higher priority in scanning.
+*/
+cs_set_list (&rr_data->cr_data.cd.ncell_list);
+else
+/*
+* with SIM card, that means full service.
+* "delete neighbourcells", that means give all
+* neighbourcells a low priority in scanning.
+*
+* It is assumed that this cell will fail also
+* because they are also member of the wrong network.
+*
+* This is not done during FTA campaign.
+*/
+cs_del_list (&rr_data->cr_data.cd.ncell_list);
+}
+}
+/*
+* start synchronisation attempt to the next cell
+*/
+memset (&rr_data->nc_data[CR_INDEX], 0, sizeof (T_NC_DATA));
+cs_sync_next ();
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_check_cell             |
++--------------------------------------------------------------------+
+PURPOSE : if a cell reselection decision has been taken, 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.
+*/
+static BOOL att_check_cell (void)
+{
+GET_INSTANCE_DATA;
+BOOL cell_ok = FALSE;
+TRACE_FUNCTION ("att_check_cell()");
+/*
+* 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 C2 for the candidate
+*/
+att_calculate_c2 (rr_data->reselect_index);
+/*
+* check the cell requirements:
+* 1. check the cell barred status (if shall be non-barred)
+* 2. the cell shall be not temporarily excluded (tnnn e.g. after random access
+*    failure).
+* 3. the cell must have a positive cell reselection criterion C2.
+*/
+/* Implements RR Clone findings #8 */
+cell_ok = (! att_cell_barred_status_cr_no_cr (rr_data->reselect_index) AND
+! is_tnnn (rr_data->reselect_index) AND
+rr_data->nc_data[rr_data->reselect_index].c2 > 0);
+/*
+* Forbidden LA for roaming shall be tested there in case a C2-base cell
+* reselection has been triggered on a cell candidate belonging to a
+* valid LA but unsuccesfull. Then RR will continue cell reselection
+* with the next candidate that might be part of a forbidden LAC.
+* Should be trapped by att_check_neighbourcell() at the end of the
+* CS3 session... but it skips one CR and secures the process.
+* Question : should this test be bypassed if MM requested limited
+* service ??
+*/
+if (rr_data->ms_data.rr_service EQ FULL_SERVICE)
+{
+if (cell_ok)
+cell_ok = dat_roam_forb_lai_check (rr_data->reselect_index);
+}
+if (cell_ok)
+{
+/*
+* suitable cell has been found
+*/
+TRACE_EVENT ("use neighbour cell");
+/*
+* after random access failure we found another cell,
+* that means, we will process a normal cell reselection
+* and will not come back directly to idle mode if the
+* cell reselection fails for the new cell.
+*/
+if (rr_data->sc_data.selection_type EQ CELL_RESELECTION_RACH)
+{
+rr_data->sc_data.selection_type = CELL_RESELECTION;
+#ifdef GPRS
+rr_data->gprs_data.use_c31 = FALSE;
+#endif
+}
+/*
+* 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);
+#ifdef GPRS
+rr_data->gprs_data.ready_state         = FALSE;    /* Standby */
+#endif
+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_highest_c2_idx (rr_data->reselect_index);
+}
+}
+/*
+* return whether a cell has been found or not.
+*/
+return cell_ok;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_clean_buf              |
++--------------------------------------------------------------------+
+PURPOSE : trigger cleaning of the SI buffers indicated by si_to_clean
+*/
+void att_clean_buf (USHORT si_to_clean)
+{
+PALLOC(clean_buf, MPH_CLEAN_BUF_REQ);
+clean_buf->si_to_clean = si_to_clean;
+PSENDX(PL, clean_buf);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_start_cr_in_pl         |
++--------------------------------------------------------------------+
+PURPOSE : trigger CR in PL and init some necessary parameters
+*/
+void att_start_cr_in_pl(UBYTE index)
+{
+GET_INSTANCE_DATA;
+att_init_pl_status ();
+att_build_idle_req (index, MODE_CELL_RESELECTION);
+/*
+* Clean the CR_INDEX storage area in RR to get the complete
+* BCCH of the new cell
+*/
+att_init_cr_data();
+memcpy (&rr_data->nc_data[CR_INDEX],
+&rr_data->nc_data[index],
+sizeof (T_NC_DATA));
+srv_clear_list (&rr_data->cr_data.cd.ncell_list);
+SET_STATE (STATE_ATT, ATT_CS3);
+rr_data->bcch_error = 0;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_stop_dedicated        |
++--------------------------------------------------------------------+
+PURPOSE : Send primitive MPH_STOP_DEDICATED_REQ
+*/
+GLOBAL void att_stop_dedicated(void)
+{
+PALLOC(mph_stop_dedi, MPH_STOP_DEDICATED_REQ);
+PSENDX(PL, mph_stop_dedi);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_leave_dedicated        |
++--------------------------------------------------------------------+
+PURPOSE : Decide if we do a CR or return to idle directly
+*/
+GLOBAL void att_leave_dedicated(void)
+{
+GET_INSTANCE_DATA;
+if (IS_TIMER_ACTIVE(T_DEDICATED_MODE))
+{ /* spent less than 30 seconds in dedicated mode */
+TIMERSTOP(T_DEDICATED_MODE);
+}
+else
+{ /* spent at least 30 seconds in dedicated mode */
+rr_data->mode_after_dedi = MODE_CELL_RESELECTION;
+}
+if((rr_data->mode_after_dedi EQ MODE_CELL_SELECTION) AND
+(rr_data->sc_data.selection_type NEQ BACK_FROM_DEDICATED_RLF)) /*does not seem correct!!!*/
+{
+/*
+* go back directly to the old cell after dedicated
+* mode if we were in dedicated mode shorter than 30 seconds
+* and have not made a handover in dedicated mode
+*/
+#ifdef GPRS
+if(GPRS_SUSPENDED_BCCH EQ GET_STATE(STATE_GPRS))
+{
+SET_STATE(STATE_GPRS,GPRS_PIM_BCCH);
+}
+else if(GPRS_SUSPENDED_PBCCH EQ GET_STATE(STATE_GPRS))
+{
+SET_STATE(STATE_GPRS,GPRS_PIM_PBCCH);
+}
+#endif
+att_return_to_idle();
+/*
+* restore the neighbour cell list which was valid
+* in idle mode (derived from SI 2x)
+* Note: SI 5x may contain other neighbour cells than SI 2x
+*/
+memcpy(&rr_data->sc_data.cd.ncell_list,
+&rr_data->sc_data.ncell_list_idle,
+sizeof(T_LIST));
+/*
+* restore the sys_info_read bitmap if we are going
+* directly to idle
+*/
+rr_data->sc_data.cd.sys_info_read = ALL_SYS_INFO_READ;
+if (rr_data->repeat_est)
+{
+rr_data->repeat_est = FALSE;
+dat_start_immediate_assign (rr_data->ms_data.establish_cause);
+}
+else
+{
+#ifdef GPRS
+if(!att_gprs_cell_has_pbcch())
+#endif
+att_code_mph_ncell_req(SC_INDEX);
+}
+/* After Dedicated mode lass than 30 seconds for a Location Area Update or
+* 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_SERV_REQ_BY_MM) AND
+(rr_data->cs_data.black_list_search_pending EQ TRUE))
+{
+TRACE_EVENT("black_list_search_pending : 1");
+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
+{
+#endif
+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
+{
+TRACE_EVENT("Black List empty");
+}
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+}
+#endif
+}
+}
+}
+else
+{
+#ifdef GPRS
+att_start_cell_reselection_gprs(BACK_FROM_DEDICATED);
+#else
+att_start_cell_reselection(BACK_FROM_DEDICATED);
+#endif
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_leave_dat_imm_ass      |
++--------------------------------------------------------------------+
+PURPOSE : return to idle mode directly and clean up
+immediate assignment procedure
+*/
+GLOBAL void att_leave_dat_imm_ass(void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_leave_dat_imm_ass()");
+#ifdef GPRS
+if(GPRS_SUSPENDED_BCCH EQ GET_STATE(STATE_GPRS))
+{
+SET_STATE(STATE_GPRS,GPRS_PIM_BCCH);
+}
+else if(GPRS_SUSPENDED_PBCCH EQ GET_STATE(STATE_GPRS))
+{
+SET_STATE(STATE_GPRS,GPRS_PIM_PBCCH);
+}
+#endif
+att_return_to_idle();
+rr_data->repeat_est = FALSE;
+#ifdef GPRS
+if(!att_gprs_cell_has_pbcch())
+#endif
+att_code_mph_ncell_req(SC_INDEX);
+/*
+* 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_SERV_REQ_BY_MM) AND
+(rr_data->cs_data.black_list_search_pending EQ TRUE))
+{
+TRACE_EVENT("black_list_search_pending : 1");
+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
+{
+#endif
+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
+{
+TRACE_EVENT("Black List empty");
+}
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+}
+#endif
+}
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_select_cell_dedicated  |
++--------------------------------------------------------------------+
+PURPOSE : The function selects a cell for cell reselection after
+coming back from a dedicated connected (normal release
+or radio link failure.
+*/
+static void att_select_cell_dedicated (void)
+{
+GET_INSTANCE_DATA;
+U8 search_mode;
+TRACE_FUNCTION ("att_select_cell_dedicated()");
+if (rr_data->reselect_index NEQ NO_AVAILABLE)
+{
+TRACE_EVENT_P3 ("[%u] new CS/CR (mode=%u, sel.type=%d)",
+rr_data->nc_data[rr_data->reselect_index].arfcn,
+rr_data->mode_after_dedi, rr_data->sc_data.selection_type);
+/*
+* A cell has been found for coming back from dedicated mode.
+* Configure layer 1 for cell reselection.
+*/
+att_start_cr_in_pl(rr_data->reselect_index);
+}
+else
+{
+/*
+* no suitable cell is available
+*/
+if (rr_data->sc_data.selection_type EQ BACK_FROM_DEDICATED_RLF)
+{
+/*
+* In case of coming back after radio link failure
+* the old cell shall be used only if no other cell
+* is suitable. So the selection type is changed to
+* "normal" comeback from dedicated mode. MM is informed
+* that no reestablishment is possible and a cell is
+* searched again inclusive the old serving cell.
+*/
+rr_data->sc_data.selection_type = BACK_FROM_DEDICATED;
+dat_code_reestablishment_fail ();
+TIMERSTART (T_RESELECT, TRESELECT_VALUE);
+att_search_cell ();
+}
+else
+{
+/* Cell Selection Improvements-LLD section:4.1.3.9 */
+if((rr_data->net_lost) AND (rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH))
+{
+/* Radio Link failure in dedicated state and cell reselection failed.
+* Start Fast search
+*/
+search_mode = FAST_SEARCH_MODE;
+}
+else
+{
+/* Normal return from dedicated mode, cell reselection failed
+* Start Normal search
+*/
+search_mode = NORMAL_SEARCH_MODE;
+}
+/*
+* there is no candidate for coming back. So a cell
+* selection is started from RR.
+*/
+/* XY:n inform GRR, and       wait for CR_RSP */
+#ifdef GPRS
+att_start_cell_selection_gprs (RR_ORIGINATED,search_mode);
+#else
+att_start_cell_selection (RR_ORIGINATED, CS_NOT_PARALLEL,search_mode);
+#endif
+}
+}
+//rr_data->mode_after_dedi = MODE_CELL_SELECTION; /* reset mode */
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_check_neighbourcell    |
++--------------------------------------------------------------------+
+PURPOSE : The function checks a cell after cell reselection.
+*/
+GLOBAL void att_check_neighbourcell (void)
+{
+GET_INSTANCE_DATA;
+BOOL               cell_ok;
+T_loc_area_ident * lai = &rr_data->nc_data[CR_INDEX].lai;
+TRACE_FUNCTION ("att_check_neighbourcell()");
+#ifdef GPRS
+if(att_gprs_check_ncell())
+return;
+#endif
+/*
+* Calculate the cell reselection criterion C2 or C31/C32.
+*/
+#ifdef GPRS
+if( rr_data->gprs_data.use_c31)
+{
+att_calculate_c31_c32(CR_INDEX);
+/* Implements RR Clone findings #8 */
+cell_ok = (!att_cell_barred_status_cr_no_cr (CR_INDEX) AND
+att_check_c31_criterion(CR_INDEX) );
+}
+else
+{
+#endif
+att_calculate_c2 (CR_INDEX);
+/*
+* Check the cell. It shall not be barred and must have
+* a positive cell reselection criterion C2.
+*/
+/* Implements RR Clone findings #8 */
+cell_ok = ! att_cell_barred_status_cr_no_cr (CR_INDEX) AND
+rr_data->nc_data[CR_INDEX].c2 > 0;
+#ifdef GPRS
+}
+#endif
+/*
+* the cell can be rejected by the SW shielding function.
+* This has only an affect during type approval.
+*/
+if (cell_ok)
+cell_ok = att_check_network (lai);
+/*
+* Check against the list of forbidden location areas for roaming,
+* but only if MM requested full service and we are still searching
+* for full service. Do not prevent limited service reselection.
+*/
+if (cell_ok AND
+(rr_data->cs_data.scan_mode NEQ CS_SECOND_SCAN) AND
+(rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH))
+{
+cell_ok = dat_roam_forb_lai_check (CR_INDEX);
+}
+/*
+* Additional tests are performed depending on the cell
+* reselection type.
+*/
+TRACE_SELECTION_TYPE (rr_data->sc_data.selection_type);
+switch (rr_data->sc_data.selection_type)
+{
+case CELL_RESELECTION_CR:
+/*
+* The MS was in idle mode and the check is
+* 1. from limited service to full service or
+* 2. from full service (VPLMN) to full service (HPLMN)
+*
+* The resulting RR service is set only if the cell is okay.
+*/
+if (cell_ok)
+{
+if (rr_data->ms_data.req_mm_service EQ FUNC_LIM_SERV_ST_SRCH OR
+rr_data->cs_data.scan_mode EQ CS_SECOND_SCAN)
+{
+rr_data->ms_data.rr_service = LIMITED_SERVICE;
+}
+else
+{
+cell_ok = dat_plmn_equal_req(lai->mcc, lai->mnc,
+rr_data->ms_data.plmn.mcc,
+rr_data->ms_data.plmn.mnc);
+if (cell_ok)
+rr_data->ms_data.rr_service = FULL_SERVICE;
+else
+rr_data->ms_data.rr_service = LIMITED_SERVICE;
+}
+}
+break;
+case CELL_SELECTION:
+case CELL_RESELECTION:
+case CELL_RESELECTION_NC:
+case CELL_RESELECTION_RACH:
+if(cell_ok)
+{
+/*
+* 2 checks to be made
+*
+* - In case of FULL SERVICE additionally the PLMN is checked
+*
+* - 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.
+*/
+if(rr_data->ms_data.rr_service EQ FULL_SERVICE)
+{
+cell_ok = dat_plmn_equal_req (lai->mcc,
+lai->mnc,
+rr_data->ms_data.plmn.mcc,
+rr_data->ms_data.plmn.mnc);
+}
+else if((rr_data->ms_data.rr_service EQ LIMITED_SERVICE) AND
+(rr_data->ms_data.req_mm_service NEQ FUNC_LIM_SERV_ST_SRCH) AND
+dat_plmn_equal_req (lai->mcc,
+lai->mnc,
+rr_data->ms_data.plmn.mcc,
+rr_data->ms_data.plmn.mnc) )
+{
+rr_data->ms_data.rr_service = FULL_SERVICE;
+}
+}
+break;
+case BACK_FROM_DEDICATED:
+case BACK_FROM_DEDICATED_RLF:
+/* The mobile is trying to select a cell after coming back from dedicated
+* state. The cell is selected only if it belongs to the previously selected
+* PLMN
+*/
+if(cell_ok)
+{
+/* While selecting a cell after an emergency call, we need not check the
+* PLMN ID of the cell */
+if(rr_data->ms_data.rr_service EQ FULL_SERVICE)
+{
+cell_ok = dat_plmn_equal_req (lai->mcc,
+lai->mnc,
+rr_data->ms_data.plmn.mcc,
+rr_data->ms_data.plmn.mnc);
+}
+TRACE_EVENT_P6 ("B_F_D New PLMN : MCC=%X%X%X MNC=%X%X%X",
+lai->mcc[0],
+lai->mcc[1],
+lai->mcc[2],
+lai->mnc[0],
+lai->mnc[1],
+lai->mnc[2]);
+TRACE_EVENT_P6 ("B_F_D Old PLMN : MCC=%X%X%X MNC=%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]);
+}
+if(rr_data->sc_data.selection_type EQ BACK_FROM_DEDICATED)
+break;
+/*
+* in case of call reestablishment check also call reestablishment flag
+*/
+if (cell_ok)
+{
+if (rr_data->nc_data[CR_INDEX].rach.re NEQ REESTAB_YES)
+cell_ok = FALSE;
+}
+break;
+}
+/*
+* the requirement check is finished
+*/
+if (cell_ok)
+{
+TRACE_EVENT_P2 ("NEW SC [%d]->[%d]",
+rr_data->nc_data[SC_INDEX].arfcn,
+rr_data->nc_data[CR_INDEX].arfcn);
+/*
+* Stop T_RESELECT, which controls the reception of the complete BCCH
+* during Cell Reselection.
+*/
+TIMERSTOP (T_RESELECT);
+/* T3122 controls after how long the MS is able to attempt access back to the */
+/* cell from which it received a IMM ASSGN REJ. This no longer applies after a */
+/* cell reselection onto a new cell. */
+TIMERSTOP(T3122);
+/*
+* copy all data from the SC_INDEX storage area to the neighbourcell area.
+* copy all data from the CR_INDEX storage area to the SC_INDEX area.
+* old serving cell data index is stored in old_serving_cell.
+*/
+att_copy_cr_data ();
+memcpy (&rr_data->sc_data.cd, &rr_data->cr_data.cd,
+sizeof (T_CELL_DATA));
+if(rr_data->ms_data.rr_service EQ FULL_SERVICE)
+{
+att_full_service_found();
+}
+rr_data->nc_data[CR_INDEX].arfcn = NOT_PRESENT_16BIT;
+/*
+* GSM 5.08, chapter 6.4:
+*
+* T is a timer implemented for each cell in the list of strongest
+* carriers.
+* T shall be started from zero at the time the cell is placed by the MS on
+* the list of strongest carriers, except when the previous serving cell is
+* placed on the list of strongest carriers at cell reselection. In this
+* case, T shall be set to the value of PENALTY_TIME (i.e. expired).
+*/
+switch (rr_data->sc_data.selection_type)
+{
+case CELL_RESELECTION:
+case CELL_RESELECTION_NC:
+case CELL_RESELECTION_RACH:
+/*
+* set the avail time of the old serving cell to PENALTY_TIME.
+*/
+if (rr_data->old_serving_cell < SC_INDEX)
+rr_data->nc_data[rr_data->old_serving_cell].avail_time =
+rr_data->nc_data[rr_data->old_serving_cell].c2_par.penalty_time;
+break;
+default:
+break;
+}
+/*
+* 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);
+#ifdef GPRS
+if(! att_gprs_is_avail())
+{
+#endif
+/*
+* configure layer 1
+*/
+att_remove_bad_rr_data_ncells();
+att_set_pl_in_idle_mode ();
+/*
+* inform data transfer process that the cell is attached.
+*/
+dat_att_cell_selected ();
+/*
+* inform MM about new cell
+*/
+if (rr_data->sc_data.mm_started)
+att_code_rr_act_cnf ();
+else
+att_code_rr_act_ind ();
+SET_STATE (STATE_ATT, ATT_IDLE);
+srv_use_stored_prim ();
+/*
+* Start registration timer if needed
+*/
+att_start_registration_timer ();
+/*
+* 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);
+}
+#ifdef GPRS
+}
+else
+{
+if(rr_data->ms_data.rr_service NEQ FULL_SERVICE)
+{
+if(att_gprs_cell_has_pbcch())
+{
+/* set to PIM_BCCH if the cell hs a PBCCH but we
+* only have limited service
+*/
+SET_STATE(STATE_GPRS, GPRS_PIM_BCCH);
+}
+}
+if(att_gprs_cell_has_pbcch())
+{
+att_gprs_stop_pl();
+}
+else
+{
+att_remove_bad_rr_data_ncells();
+att_set_pl_in_idle_mode ();
+}
+/* inform GRR if we have GPRS support */
+att_signal_gprs_support();
+/* and wait for CR_REQ(CR_COMPLETE) from GRR */
+}
+#endif
+}
+else
+{
+/*
+* the cell reselection failed for this channel and is continued
+* with the next candidate.
+*/
+TRACE_EVENT_P1 ("[%u] CR failed", rr_data->nc_data[CR_INDEX].arfcn);
+rr_data->pag_rec = FALSE;
+srv_clear_stored_prim (MPH_PAGING_IND);
+att_continue_cell_reselect ();
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_check_neighbourcell_si_reestab  |
++--------------------------------------------------------------------+
+PURPOSE : This function checks if revelant sys info is present is ATT_CS3 state.
+Special case : Sys Info 2Ter is not needed if we have a pending call re-establishment
+*/
+GLOBAL void att_check_neighbourcell_si_reestab (void)
+{
+GET_INSTANCE_DATA;
+/*
+* Sometimes the network indicates SI2Ter but never sends it.
+* If we have a call re-establishment pending, then we must not wait
+* for SI2Ter.
+*/
+if( (rr_data->cr_data.cd.sys_info_read EQ ALL_SYS_INFO_READ)
+OR
+( (rr_data->cr_data.cd.sys_info_read EQ SYS_INFO_EXCEPT_2TER) AND
+(rr_data->sc_data.selection_type EQ BACK_FROM_DEDICATED_RLF))
+)
+{
+att_check_neighbourcell ();
+}
+/*
+* In case of Radio Link Failure, check cell for call
+* re-establishment capability.
+*/
+if (rr_data->sc_data.selection_type EQ BACK_FROM_DEDICATED_RLF)
+att_check_reestablishment();
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_check_reestablishment  |
++--------------------------------------------------------------------+
+PURPOSE : The function checks whether a cell has no call re-establishment
+capability. In this case the cell reselection is resumed
+with the next cell.
+*/
+GLOBAL void att_check_reestablishment (void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_check_reestablishment()");
+if (rr_data->nc_data[CR_INDEX].rach.re NEQ REESTAB_YES)
+{
+/*
+* the cell reselection failed for this channel and is continued
+* with the next candidate due to no call re-establishment
+* capability.
+*/
+TRACE_EVENT_P2 ("[%u]7 (BCCH-St=%u) have no call re-establishment capability",
+rr_data->nc_data[CR_INDEX].arfcn, rr_data->nc_data[CR_INDEX].bcch_status);
+rr_data->pag_rec = FALSE;
+srv_clear_stored_prim (MPH_PAGING_IND);
+att_continue_cell_reselect ();
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_check_reselect_decision|
++--------------------------------------------------------------------+
+PURPOSE : After reception of measurement values from layer 1 in
+idle mode the cell reselection decision is done by this
+function. It checks the measurement related criterions
+for cell reselection. The flag start_now indicates
+whether only the decision is taken or the cell reselection
+is started immediately. It is senseful to delay a cell
+reselection during a PLMN available search triggered by MM.
+*/
+GLOBAL void att_check_reselect_decision (UBYTE start_now)
+{
+GET_INSTANCE_DATA;
+UBYTE    i;
+SHORT    delta;
+TRACE_FUNCTION ("att_check_reselect_decision()");
+#ifdef GPRS
+TRACE_EVENT_P2("check_reselect: start_cell_reselection=%u calc %s",
+rr_data->start_cell_reselection, rr_data->gprs_data.use_c31 ? "C31,C32":"C2");
+#endif
+/*
+* Calculate for all synchronized neighbourcells, which have
+* decoded the system information messages for calculation C2,
+* and for the serving cell the cell reselection criterion C2.
+*/
+for (i = 0; i < 7; i++)
+{
+if (rr_data->nc_data[i].bcch_status EQ DECODED)
+{
+#ifdef GPRS
+if( rr_data->gprs_data.use_c31)
+att_calculate_c31_c32(i);
+else
+#endif
+att_calculate_c2 (i);
+}
+else if (rr_data->nc_data[i].bcch_status NEQ EMPTY AND
+rr_data->nc_data[i].arfcn NEQ NOT_PRESENT_16BIT )
+{
+TRACE_EVENT_P2("[%u]i%u no C2 (SIs missing)",
+rr_data->nc_data[i].arfcn,i);
+}
+}
+/*
+* Check C1 serving cell < 0 for more then 5 seconds
+* The c1_counter counts the number of reports where
+* this criterion has passed.
+*/
+if (rr_data->nc_data[SC_INDEX].c1 < 0)
+{
+/*
+* if c1_counter has a value of at least 1 it had happened
+* for at least two successive reports, that means more
+* then five seconds.
+*/
+if ( (rr_data->nc_data[SC_INDEX].c1_counter > 0)
+#ifdef GPRS
+OR
+(rr_data->gprs_data.use_c31)
+#endif
+)
+{
+/*
+* reset the counter and start !
+*/
+rr_data->nc_data[SC_INDEX].c1_counter = 0;
+#ifdef GPRS
+/* check if we can do a cell reselection */
+if(!is_nc2_used())
+{
+#endif
+if (start_now )
+{
+/*XY:n inform GRR, and       wait for CR_RSP */
+#ifdef GPRS
+att_start_cell_reselection_gprs (CELL_RESELECTION);
+#else
+att_start_cell_reselection (CELL_RESELECTION);
+#endif
+}
+#ifdef GPRS
+}
+#endif
+return;
+}
+else
+{
+/*
+* the criterion has passed the first time, so
+* increase the counter and wait for the next measurement value.
+*/
+rr_data->nc_data[SC_INDEX].c1_counter++;
+#if defined(_SIMULATION_)
+TRACE_EVENT_WIN_P1 ("CR SC delayed (%d)", rr_data->nc_data[SC_INDEX].c1_counter);
+#endif
+}
+}
+else
+{
+/*
+* The C1 of the serving cell is positive, so clear the c1_counter.
+*/
+rr_data->nc_data[SC_INDEX].c1_counter = 0;
+#if defined(_SIMULATION_)
+TRACE_EVENT_WIN_P1 ("CR SC c1_counter=%d", rr_data->nc_data[SC_INDEX].c1_counter);
+#endif
+}
+/*
+* check if C31\C32 based reselection is required
+*/
+#ifdef GPRS
+if( rr_data->gprs_data.use_c31 )
+{
+att_check_c31_reselect_decision(start_now);
+return;
+}
+#endif
+/*
+* Check C2(NC) > C2(SC) for all neighbourcells
+*/
+for (i = 0; i < 6; i++)
+{
+/*
+* If data is stored for this neighbourcell
+*/
+if (rr_data->nc_data[i].bcch_status EQ DECODED)
+{
+/*
+TRACE_EVENT_P2 ("COMPARE NC[%d]-SC[%d]",
+rr_data->nc_data[i].arfcn,
+rr_data->nc_data[SC_INDEX].arfcn);
+*/
+#ifdef GPRS
+/*
+* check if the location area has changed
+* or the routing area if the scell supports GPRS
+*/
+{
+BOOL la_same, ra_same;
+if (dat_plmn_equal_req (rr_data->nc_data[i].lai.mcc,
+rr_data->nc_data[i].lai.mnc,
+rr_data->nc_data[SC_INDEX].lai.mcc,
+rr_data->nc_data[SC_INDEX].lai.mnc)
+AND
+rr_data->nc_data[i].lai.lac EQ
+rr_data->nc_data[SC_INDEX].lai.lac)
+la_same = TRUE;
+else
+la_same = FALSE;
+/*
+*  If gprs is not available do not care about the routing area
+*
+*/
+if(att_gprs_is_avail())
+{
+if(rr_data->nc_data[i].rac EQ NOT_PRESENT_8BIT OR
+rr_data->nc_data[i].rac EQ rr_data->nc_data[SC_INDEX].rac)
+{
+ra_same = TRUE;
+}
+else
+{
+ra_same = FALSE;
+}
+}
+else
+{
+ra_same = TRUE;
+}
+if(la_same AND ra_same AND !rr_data->gprs_data.ready_state)
+#else /* GPRS */
+if (dat_plmn_equal_req (rr_data->nc_data[i].lai.mcc,
+rr_data->nc_data[i].lai.mnc,
+rr_data->nc_data[SC_INDEX].lai.mcc,
+rr_data->nc_data[SC_INDEX].lai.mnc)
+AND
+rr_data->nc_data[i].lai.lac EQ
+rr_data->nc_data[SC_INDEX].lai.lac)
+#endif  /* GPRS */
+{
+/*
+* If it is in the same location area as the serving cell,
+* the delta is simply the difference of both cell reselection
+* criterion values C2.
+*/
+TRACE_EVENT_P3 ("NC[%d]i%u-SC[%d] same LAI",
+rr_data->nc_data[i].arfcn,i,
+rr_data->nc_data[SC_INDEX].arfcn);
+delta = rr_data->nc_data[i].c2 -
+rr_data->nc_data[SC_INDEX].c2;
+/*
+* 3GPP TS 05.08, section 6.6.2:
+* in case of a cell reselection occurring within the previous 15 seconds
+* in which case the C2 value for the new cell shall exceed the C2 value
+* of the serving cell by at least 5 dB for a period of 5 seconds
+*/
+if ( IS_TIMER_ACTIVE (T_NO_RESELECT) )
+{
+delta -= 5;
+}
+else
+{
+/* When C2(NC)==C2(SC) i.e. delta=0, an invalid cell reselection gets triggered below.
+* 'delta' needs to be adjusted to prevent this happening. The '=' in the '>='
+* condition below only applies when T_NO_RESELECT timer is active and
+* c2_corr has been decremented by 5 (above statement)
+*/
+if(delta EQ 0 )
+{
+delta = -1;
+			      }
+}
+}
+else
+{
+/*
+* If both are member of different location areas, a threshold
+* value CELL_RESELECTION_HYSTERESE is taken in account.
+*/
+TRACE_EVENT_P3 ("NC[%d]i%u-SC[%d] different LAI",
+rr_data->nc_data[i].arfcn,i,
+rr_data->nc_data[SC_INDEX].arfcn);
+delta = att_calculate_c2_diff (i);
+}
+#ifdef GPRS
+}
+#endif
+/*
+* 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(i))
+delta = -1;
+/*
+* 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(i))
+delta = -1;
+}
+#if defined(_SIMULATION_)
+TRACE_EVENT_WIN_P1 ("delta=%d", delta);
+#endif
+if(delta == 0) TRACE_EVENT("No reselection delta == 0");
+if (delta > 0)
+{
+/*
+* The condition C2(NC) > C2(SC) is fulfilled.
+*/
+if (rr_data->nc_data[i].c1_counter > 0)
+{
+/*
+* the conditions is fulfilled at least two times ( > 5 seconds)
+* and there is no barrier to start the cell
+* reselection.
+*/
+#ifdef GPRS
+/* check if we can do a cell reselection */
+if(!is_nc2_used())
+{
+#endif
+if (start_now)
+{
+rr_data->nc_data[i].c1_counter = 0;
+/*XY:n inform GRR, and       wait for CR_RSP */
+#ifdef GPRS
+att_start_cell_reselection_gprs(CELL_RESELECTION_NC);
+#else
+att_start_cell_reselection (CELL_RESELECTION_NC);
+#endif
+}
+#ifdef GPRS
+}
+#endif
+return;
+}
+else
+{
+/*
+* The condition has passed the first time or is delayed
+* by the barrier to perform a cell reselection due to this reasons
+* not faster then in periods of 15 seconds.
+*/
+rr_data->nc_data[i].c1_counter++;
+TRACE_EVENT_P3 ("NC[%u]i%u CR delayed (%d)",
+rr_data->nc_data[i].arfcn,i,rr_data->nc_data[i].c1_counter);
+}
+}
+else
+{
+/*
+* the condition is not fullfilled and the counter is resetted.
+*/
+rr_data->nc_data[i].c1_counter = 0;
+}
+}
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_check_barred_status_in_idle|
++--------------------------------------------------------------------+
+PURPOSE :
+*/
+GLOBAL void att_check_barred_status_in_idle (void)
+{
+TRACE_FUNCTION ("att_check_barred_status_in_idle()");
+/*
+* check whether serving cell is barred
+*/
+/*XY:n inform GRR, and       wait for CR_RSP */
+/* Implements RR Clone findings #8 */
+if (att_cell_barred_status_cr_no_cr (SC_INDEX) EQ TRUE)
+{
+#ifdef GPRS
+att_start_cell_reselection_gprs (CELL_RESELECTION);
+#else
+att_start_cell_reselection (CELL_RESELECTION);
+#endif
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_clear_forb_list        |
++--------------------------------------------------------------------+
+PURPOSE : RR stores some forbidden lists. This function clears
+the given forbidden list.
+*/
+static void att_clear_forb_list (int list_type)
+{
+GET_INSTANCE_DATA;
+int i;
+T_loc_area_ident *forb_list;
+TRACE_FUNCTION ("att_clear_forb_list()");
+if (list_type EQ FORBIDDEN_LIST_NORMAL)
+forb_list = &rr_data->ms_data.forb_lac_list[0];
+else
+forb_list = &rr_data->ms_data.roam_forb_lac_list[0];
+/* Implements Measure#32: Row 29 */
+if(list_type EQ FORBIDDEN_LIST_NORMAL)
+{
+TRACE_EVENT ( "CLEAR FORB LIST");
+}
+else
+{
+TRACE_EVENT ( "CLEAR ROAM FORB LIST");
+}
+for (i = 0; i < MAX_LAI; i++)
+{
+memset (forb_list[i].mcc, NOT_PRESENT_8BIT, SIZE_MCC);
+memset (forb_list[i].mnc, NOT_PRESENT_8BIT, SIZE_MNC);
+forb_list[i].lac = NOT_PRESENT_16BIT;
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_clear_registration_data|
++--------------------------------------------------------------------+
+PURPOSE : The function is called after reception of RR_SYNC_REQ,
+which is sent by MM after some Location Updating Reject
+causes which indicate that the IMSI is invalid, paging
+shall be suppressed and RR shall enter only a limited mode.
+*/
+GLOBAL void att_clear_registration_data (void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_clear_registration_data()");
+TRACE_EVENT ("CLEAR registration data (IMSI, MCC, MNC)");
+/*
+* Clear the IMSI related data and enter the
+* limited mode.
+*/
+rr_data->ms_data.operation_mode  = 0;
+att_clear_parallel_search ();
+rr_data->ms_data.current_plmn_search_type = FUNC_LIM_SERV_ST_SRCH;
+rr_data->ms_data.imsi_available  = FALSE;
+rr_data->ms_data.plmn.mcc[0]     = NOT_PRESENT_8BIT;
+rr_data->ms_data.plmn.mnc[0]     = NOT_PRESENT_8BIT;
+rr_data->ms_data.v_eq_plmn       = FALSE;
+/*we only have limited service*/
+rr_data->ms_data.rr_service = LIMITED_SERVICE;
+rr_data->ms_data.req_mm_service = FUNC_LIM_SERV_ST_SRCH;
+TRACE_EVENT_P3 ("att_clear_registration_data: current=%s, service:rMM=%s RRs=%s",
+_rr_str_FUNC[rr_data->ms_data.current_plmn_search_type],
+_rr_str_FUNC[rr_data->ms_data.req_mm_service],
+_rr_str_SERVICE[rr_data->ms_data.rr_service]);
+/*
+* clear TMSI and ciphering data
+*/
+att_clear_reg_without_imsi ();
+att_set_rr_service_info();
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_clear_reg_without_imsi |
++--------------------------------------------------------------------+
+PURPOSE : After some location updating reject causes MM informs RR
+that the TMSI and the ciphering data are invalid.
+*/
+GLOBAL void att_clear_reg_without_imsi (void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_clear_reg_without_imsi()");
+/*
+* clear TMSI
+*/
+rr_data->ms_data.tmsi_available = FALSE;
+rr_data->ms_data.tmsi_binary    = 0;
+/*
+* clear ciphering data
+*/
+rr_data->ms_data.cksn           = CKSN_NOT_PRES;
+memset (rr_data->ms_data.kc, NOT_PRESENT_8BIT, KC_STRING_SIZE);
+memset (rr_data->ms_data.new_kc, NOT_PRESENT_8BIT, KC_STRING_SIZE);
+/*
+* update the identities in layer 1.
+*/
+att_mph_identity_req ();
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_reorder_mph_ncell_req  |
++--------------------------------------------------------------------+
+PURPOSE : reorders a neighbourcell list for layer 1 to make sure
+that the strongest neighbour cells are the first ones
+in the list and are therefore measured first by layer 1
+*/
+static void att_reorder_mph_ncell_req (T_MPH_NEIGHBOURCELL_REQ * mph_ncell_req)
+{
+GET_INSTANCE_DATA;
+#define MAX_STRONGEST 6 /* MAX_STRONGEST must be at least 6 but up to 8 makes sense */
+UBYTE  i_nc,
+i_nc1,
+c_str_nc = 0,
+c_str_cs = 0,
+is_old = !IS_TIMER_ACTIVE(TCSVALID),
+is_inserted, i, j;
+SHORT  arfcn,
+rxlev,
+str_arfcn[MAX_STRONGEST],
+str_rxlev[MAX_STRONGEST];
+#if defined(_SIMULATION_)
+TRACE_EVENT_WIN_P6("ncell_req arfcns:%4d %4d %4d %4d %4d %4d",
+mph_ncell_req->arfcn[0] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[0] : -1,
+mph_ncell_req->arfcn[1] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[1] : -1,
+mph_ncell_req->arfcn[2] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[2] : -1,
+mph_ncell_req->arfcn[3] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[3] : -1,
+mph_ncell_req->arfcn[4] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[4] : -1,
+mph_ncell_req->arfcn[5] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[5] : -1);
+#endif
+memset (str_arfcn, -1, sizeof str_arfcn);  /* for easier debugging */
+memset (str_rxlev, -1, sizeof str_rxlev);
+/*
+* search for the strongest neighbourcells and collect them in
+* the arrays str_arfcn/str_rxlev. An arfcn found in the nc_data
+* is always stored before an arfcn found in the cs_data. The reason
+* is that the nc_data are almost younger and probably more important be
+* and there may big differences between the rxlev values for the
+* same arfcn delevered by MPHC_RXLEV_IND and by MPHC_RXLEV_PERIODIC_IND
+*/
+for (i_nc = 0; i_nc < MAX_NEIGHBOURCELLS AND
+mph_ncell_req->arfcn[i_nc] NEQ NOT_PRESENT_16BIT; i_nc++)
+{
+arfcn = mph_ncell_req->arfcn[i_nc];
+if (arfcn EQ rr_data->nc_data[SC_INDEX].arfcn)
+continue;  /* processing neighbour cell list in *mph_ncell_req */
+/*
+* for all channels of stored neighbour cell data
+*/
+is_inserted = FALSE;
+for (i_nc1 = 0; i_nc1 < 6; i_nc1++)
+{
+if (arfcn EQ rr_data->nc_data[i_nc1].arfcn)
+{
+if (rr_data->nc_data[i_nc1].bcch_status NEQ EMPTY)
+{
+rxlev = rr_data->nc_data[i_nc1].rxlev;
+is_inserted = TRUE; /* avoid double inserting */
+for (i = c_str_nc; i > 0 AND rxlev > str_rxlev[i-1]; i--)
+; /* search for the place to insert */
+if (i EQ c_str_nc AND c_str_nc >= MAX_STRONGEST)
+break; /* not strong enough */
+j = (c_str_cs >= MAX_STRONGEST) ? MAX_STRONGEST-1 : c_str_cs;
+for ( ; j > i; j--)
+{ /* make place for current entry */
+str_rxlev[j] = str_rxlev[j-1];
+str_arfcn[j] = str_arfcn[j-1];
+}
+str_arfcn[i] = arfcn;
+str_rxlev[i] = rxlev;
+/* if (c_str_nc < MAX_STRONGEST) needed if MAX_STRONGEST < 6 */
+c_str_nc++;
+if (c_str_cs < MAX_STRONGEST)
+c_str_cs++;
+}
+break; /* scanning stored neighbour cell data */
+}
+} /* for: stored neighbour cell data */
+if (is_old OR is_inserted)
+continue;   /* CS measurements are too old */
+/*
+* for all channels of the power campaign list
+*/
+for (i_nc1 = 0; i_nc1 < rr_data->cs_data.max_arfcn; i_nc1++)
+{
+if (arfcn EQ rr_data->cs_data.arfcn[i_nc1])
+{
+rxlev = rr_data->cs_data.rxlev[i_nc1];
+for (i = c_str_cs; i > c_str_nc AND rxlev > str_rxlev[i-1]; i--)
+; /* search for the place to insert */
+if (i EQ c_str_cs AND c_str_cs >= MAX_STRONGEST)
+break; /* not strong enough */
+j = (c_str_cs >= MAX_STRONGEST) ? MAX_STRONGEST-1 : c_str_cs;
+for (; j > i; j--)
+{ /* make place for current entry */
+str_rxlev[j] = str_rxlev[j-1];
+str_arfcn[j] = str_arfcn[j-1];
+}
+str_arfcn[i] = arfcn;
+str_rxlev[i] = rxlev;
+if (c_str_cs < MAX_STRONGEST)
+c_str_cs++;
+break; /* scanning power campaign list */
+}
+} /* for: power campaign list */
+} /* for: mph_ncell_req->arfcn */
+TRACE_EVENT_P7("c_str_nc=%u arfcn:%4d %4d %4d %4d %4d %4d",
+c_str_nc, str_arfcn[0], str_arfcn[1], str_arfcn[2],
+str_arfcn[3], str_arfcn[4], str_arfcn[5]);
+TRACE_EVENT_P7("c_str_cs=%u rxlev:%4d %4d %4d %4d %4d %4d",
+c_str_cs, str_rxlev[0], str_rxlev[1], str_rxlev[2],
+str_rxlev[3], str_rxlev[4], str_rxlev[5]);
+/* now reorder the arfcn's in the primitive */
+for (i_nc1 = 0; i_nc1 < c_str_cs; i_nc1++)
+{
+for (i_nc = 0; i_nc < MAX_NEIGHBOURCELLS AND
+mph_ncell_req->arfcn[i_nc] NEQ NOT_PRESENT_16BIT; i_nc++)
+{
+if (str_arfcn[i_nc1] EQ mph_ncell_req->arfcn[i_nc])
+{ /* swap */
+arfcn = mph_ncell_req->arfcn[i_nc1];
+mph_ncell_req->arfcn[i_nc1] = mph_ncell_req->arfcn[i_nc];
+mph_ncell_req->arfcn[i_nc] = arfcn;
+break;
+}
+} /* for: mph_ncell_req->arfcn */
+} /* for: str_arfcn */
+TRACE_EVENT_P6("strongest arfcns:%4d %4d %4d %4d %4d %4d",
+mph_ncell_req->arfcn[0] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[0] : -1,
+mph_ncell_req->arfcn[1] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[1] : -1,
+mph_ncell_req->arfcn[2] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[2] : -1,
+mph_ncell_req->arfcn[3] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[3] : -1,
+mph_ncell_req->arfcn[4] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[4] : -1,
+mph_ncell_req->arfcn[5] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[5] : -1);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_remove_bad_ncell         |
++--------------------------------------------------------------------+
+PURPOSE : removes outdated ncells from RR store.
+*/
+GLOBAL void att_remove_bad_rr_data_ncells()
+{
+GET_INSTANCE_DATA;
+T_CELL_DATA * cd;
+UBYTE  i_nc, index;
+UBYTE  found;
+USHORT act_ncell_list [MAX_NEIGHBOURCELLS];
+/*
+* get the pointer to the correct list.
+*/
+cd = &rr_data->sc_data.cd;
+memset (act_ncell_list, 0xFF, 2*MAX_NEIGHBOURCELLS);
+srv_create_list (&cd->ncell_list, act_ncell_list, MAX_NEIGHBOURCELLS, FALSE, 0);
+for( index = 0; index < SC_INDEX; index++)
+{
+TRACE_EVENT_P3("[%u]i%u bcch_status=%u", rr_data->nc_data[index].arfcn,
+index, rr_data->nc_data[index].bcch_status);
+if( rr_data->nc_data[index].bcch_status NEQ EMPTY )
+{
+found = FALSE;
+for( i_nc = 0;  act_ncell_list[i_nc] NEQ NOT_PRESENT_16BIT ; i_nc++)
+{
+if( rr_data->nc_data[index].arfcn EQ act_ncell_list[i_nc] )
+{
+found = TRUE;
+break;
+}
+}
+if( ! found )
+{
+TRACE_EVENT_P1(" Removing bad ncell [%u]", rr_data->nc_data[index].arfcn );
+rr_data->nc_data[index].bcch_status = EMPTY;
+rr_data->nc_data[index].arfcn = 0;
+rr_data->nc_data[index].avail_time = 0;
+}
+}
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_code_mph_ncell_req     |
++--------------------------------------------------------------------+
+PURPOSE : build a neighbourcell list for layer 1 in idle mode.
+*/
+GLOBAL void att_code_mph_ncell_req (UBYTE index)
+{
+GET_INSTANCE_DATA;
+T_CELL_DATA * cd;
+PALLOC (mph_ncell_req, MPH_NEIGHBOURCELL_REQ);
+TRACE_FUNCTION ("att_code_mph_ncell_req()");
+/*
+* get the pointer to the correct list.
+*/
+if (index EQ SC_INDEX)
+cd = &rr_data->sc_data.cd;
+else
+cd = &rr_data->cr_data.cd;
+cs_remove_BA_MA_from_black_list(rr_data->cs_data.region,&cd->ncell_list);
+/*
+* use neighbour cell list from system info 2/2bis/2ter
+*/
+memset (mph_ncell_req->arfcn, 0xFF, 2*MAX_NEIGHBOURCELLS);
+srv_create_list (&cd->ncell_list,
+mph_ncell_req->arfcn, MAX_NEIGHBOURCELLS, FALSE,
+0);
+memcpy (rr_data->act_ncell_list, mph_ncell_req->arfcn,
+sizeof (rr_data->act_ncell_list));
+#if defined(_SIMULATION_)
+TRACE_EVENT_WIN_P6("ncell_req arfcns:%4d %4d %4d %4d %4d %4d",
+mph_ncell_req->arfcn[0] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[0] : -1,
+mph_ncell_req->arfcn[1] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[1] : -1,
+mph_ncell_req->arfcn[2] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[2] : -1,
+mph_ncell_req->arfcn[3] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[3] : -1,
+mph_ncell_req->arfcn[4] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[4] : -1,
+mph_ncell_req->arfcn[5] NEQ NOT_PRESENT_16BIT ?
+mph_ncell_req->arfcn[5] : -1);
+#endif
+/*
+* set the multiband parameter
+*/
+mph_ncell_req->multi_band = rr_data->ncell_mb;
+#ifdef GPRS
+mph_ncell_req->sync_only  = NORMAL_BA;
+#endif
+/*
+* check the list against band restrictions.
+*/
+srv_remove_frequencies_in_array (&mph_ncell_req->arfcn[0]);
+att_reorder_mph_ncell_req(mph_ncell_req);
+/*
+* send the list to layer 1
+*/
+PSENDX (PL, mph_ncell_req);
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+for_check_and_configure_si2quater(index);
+#endif
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147) MODULE  : RR_ATT                           |
+| STATE   : code          ROUTINE : att_code_mph_ncell_req_dedicated |
++--------------------------------------------------------------------+
+PURPOSE : builds a neighbourcell list for layer 1 in dedicated mode.
+*/
+GLOBAL void att_code_mph_ncell_req_dedicated (void)
+{
+GET_INSTANCE_DATA;
+UBYTE start_index = 0;
+UBYTE old_index;
+if ( rr_data->emo_arfcn EQ NULL )
+{
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+USHORT     si_read = (USHORT) (SYS_INFO_5_READ | SYS_INFO_5BIS_READ);
+rr_data->sc_data.ba_list_ded = FALSE;
+if ( (rr_data->sc_data.cd.sys_info_read & si_read ) EQ si_read )
+{
+rr_data->sc_data.ba_list_ded = TRUE;
+rr_data->sc_data.ba_list_idle = FALSE;
+old_index = rr_data->sc_data.ba_index;
+rr_data->sc_data.ba_index = rr_data->sc_data.new_ba_index;
+}
+else if (rr_data->sc_data.ba_list_idle EQ TRUE)
+return;
+#endif
+{
+PALLOC (mph_ncell_req, MPH_NEIGHBOURCELL_REQ);
+/*
+* initialise data structures,
+* clear ncell list to layer 1,
+* set multiband parameter.
+*/
+memset (mph_ncell_req->arfcn, 0xFF, 2*MAX_NEIGHBOURCELLS);
+mph_ncell_req->multi_band = rr_data->ncell_mb;
+/*
+* fill system info 5 and 5bis
+*/
+if (rr_data->sc_data.cd.sys_info_read & (SYS_INFO_5_READ | SYS_INFO_5BIS_READ))
+start_index = srv_create_list (&rr_data->sc_data.cd.ncell_list,
+mph_ncell_req->arfcn,
+MAX_NEIGHBOURCELLS,
+FALSE,
+0);
+/*
+* fill system info 5ter
+*/
+if (rr_data->sc_data.cd.sys_info_read & SYS_INFO_5TER_READ)
+srv_create_list (&rr_data->sc_data.five_ter_list,
+mph_ncell_req->arfcn,
+MAX_NEIGHBOURCELLS,
+FALSE,
+start_index);
+/*
+* Copy complete list for position detection for uplink
+* measurement reports.
+*/
+memcpy (rr_data->act_ncell_list, mph_ncell_req->arfcn,
+sizeof (rr_data->act_ncell_list));
+/*
+* check against band restrictions
+*/
+srv_remove_frequencies_in_array (&mph_ncell_req->arfcn[0]);
+/*
+* send list to layer 1.
+*/
+PSENDX (PL, mph_ncell_req);
+}
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+if (rr_data->sc_data.ba_list_ded NEQ TRUE )
+return;
+att_check_for_si5ter_and_enhpara(old_index);
+#endif
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_code_prr_mm_info       |
++--------------------------------------------------------------------+
+PURPOSE : provide MM at the end of cell selection or cell reselection
+with MM relevant data from the BCCH channel. These
+informations are:
+IMSI attach / detach
+Call Reestablishment capability
+Base Station Identification Code
+Periodic Location Updating Time T3212
+and whether the MS camps in a forbidden location area.
+*/
+static void att_code_prr_mm_info (T_mm_info *mm_info)
+{
+GET_INSTANCE_DATA;
+T_NC_DATA *rrd = &rr_data->nc_data[SC_INDEX];
+TRACE_FUNCTION ("att_code_prr_mm_info()");
+mm_info->valid          = TRUE;
+mm_info->att            = rrd->control_descr.att;
+mm_info->re             = rrd->rach.re;
+mm_info->ncc            = (rrd->bsic >> 3) & 7;
+mm_info->bcc            = rrd->bsic & 7;
+mm_info->t3212          = rrd->control_descr.t3212;
+mm_info->la             = (!(dat_forb_lai_check (SC_INDEX) AND
+dat_roam_forb_lai_check (SC_INDEX)));
+/*
+* Parameter band needs a dummy value, otherwise component tests of RR
+* fail due to lack of ability of TAP
+*/
+mm_info->band           = BND_DMY_VAL;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_code_rr_abort_ind      |
++--------------------------------------------------------------------+
+PURPOSE : Indication of a failed cell selection or cell reselection
+to MM.
+*/
+GLOBAL void att_code_rr_abort_ind_original (T_RR_DATA *rr_dat, USHORT    cause)
+{
+GET_INSTANCE_DATA;
+int i;
+PALLOC (abort_ind, RR_ABORT_IND);/* T_RR_ABORT_IND */
+TRACE_FUNCTION ("att_code_rr_abort_ind()");
+memset (abort_ind, 0, sizeof (*abort_ind));
+/*
+* Indicates the end of a plmn available search
+*/
+if (rr_dat->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI)
+{
+/* this sets the state of CS */
+cs_set_stop_active();
+}
+TIMERSTOP(TABORT);
+/*
+* Set the parameters for MM, especially the requested service
+* from MM and the real reached service of RR.
+*/
+abort_ind->op.v_op    = 1;
+abort_ind->op.ts      = (rr_dat->ms_data.operation_mode >> SHIFT_FOR_SIM_TYPE) & 1;
+abort_ind->op.m       = (rr_dat->ms_data.operation_mode >> SHIFT_FOR_SEARCH_OFFSET) & 1;
+abort_ind->op.sim_ins = (rr_dat->ms_data.operation_mode >> SHIFT_FOR_SIM_INSERTED) & 1;
+abort_ind->op.func    = rr_dat->ms_data.req_mm_service;
+abort_ind->op.service = rr_dat->ms_data.rr_service;
+abort_ind->cause      = cause;
+if(rr_dat->ms_data.rr_service EQ NO_SERVICE)
+att_notify_stop_plmn_search (TRUE);
+else
+att_notify_stop_plmn_search (FALSE);
+/*
+* resume normal RR operation and update the previous
+* requested MM and RR services
+*/
+att_clear_parallel_search ();
+rr_dat->ms_data.req_mm_service = att_get_func ();
+rr_data->cs_data.scan_mode = CS_NO_SCAN;
+TRACE_EVENT_P1 ("cause=%x", cause);
+if (cause EQ RRCS_ABORT_CEL_SEL_FAIL)
+{
+#ifdef GPRS
+if (abort_ind->op.func    NEQ FUNC_NET_SRCH_BY_MMI AND
+abort_ind->op.service EQ  NO_SERVICE           AND
+att_gprs_is_avail())
+{
+att_signal_gprs_support();
+}
+#endif
+/*
+* If the abort cause is cell selection failed
+* add the list of available PLMNs.
+*/
+att_order_plmns ();
+abort_ind->plmn_avail = rr_dat->sc_data.found_entries;
+for (i=0; i < rr_dat->sc_data.found_entries; i++)
+{
+T_FOUND_ELEMENT *pfound = &rr_dat->sc_data.found[i];
+abort_ind->plmn[i] = pfound->plmn;
+abort_ind->rxlevel[i] = pfound->rxlev;
+abort_ind->lac_list[i] =pfound->lac; //LOL 02.01.2003: added for EONS support
+TRACE_EVENT_P9 ("RR_ABORT_IND: [%u] MCC/MNC=%x%x%x/%x%x%x lac=%04x rx=%u",
+pfound->arfcn,
+pfound->plmn.mcc[0],
+pfound->plmn.mcc[1],
+pfound->plmn.mcc[2],
+pfound->plmn.mnc[0],
+pfound->plmn.mnc[1],
+pfound->plmn.mnc[2],
+pfound->lac,
+pfound->rxlev);
+}
+EM_NET_SEARCH_PASSED;
+}
+else
+{
+/*
+* else clear this area of the primitive.
+*/
+abort_ind->plmn_avail = 0;
+memset (abort_ind->plmn, 0, sizeof (abort_ind->plmn));
+memset (abort_ind->rxlevel, 0, sizeof (abort_ind->rxlevel));
+EM_NET_SEARCH_FAILED;
+}
+/*
+* Set mobile RF capability for MM messages
+*/
+if (rr_dat->ms_data.rr_service EQ NO_SERVICE)
+abort_ind->power = 0;
+else
+abort_ind->power = att_get_power();
+if ((rr_data->ms_data.req_mm_service NEQ FUNC_NET_SRCH_BY_MMI) AND
+(cause EQ RRCS_ABORT_CEL_SEL_FAIL))
+att_set_rr_service_info();
+TRACE_OP_TYPE (&abort_ind->op, "RR_ABORT_IND");
+PSENDX (MM, abort_ind);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_order_plmns            |
++--------------------------------------------------------------------+
+PURPOSE : The function orders the found PLMNs after the following
+criterions:
+all PLMNs with a fieldstrength greater then -85 dBm are
+ordered randomly. This is 50 percent of the requirement
+regarding GSM 3.22, chapter 4.4.3.1. MM checks then
+the HPLMN condition and the preferred PLMN condition.
+*/
+static void att_order_plmns (void)
+{
+GET_INSTANCE_DATA;
+USHORT nr;
+USHORT i;
+/*
+* allocate dynamic memory to build a copy
+* of the list which is ordered randomly
+*/
+T_FOUND_LIST * list;
+TRACE_FUNCTION ("att_order_plmns()");
+/*
+* initialize the copy
+*/
+MALLOC (list, sizeof (T_FOUND_LIST));
+memset (list, 0, sizeof (T_FOUND_LIST));
+/*
+* get the number of PLMNs which have a fieldstrength
+* greater then -85 dBm.
+*/
+i=0;
+while ((nr = att_number_of_plmns_greater_85_dBm()) NEQ 0 )
+{
+/*
+* get a value in the range 0..nr-1
+* i.e. select a PLMN greater -85 randomly
+*/
+nr = dat_random (nr);
+/*
+* copy the nr-th plmn and indicate it in the source
+* as copied.
+*/
+att_copy_found_plmn (list, nr, i);
+/*
+* increment the number of copied networks.
+*/
+i++;
+}
+/*
+* copy all networks with a fieldstrength lower or equal -85 dBm.
+*/
+att_copy_plmns_lower_or_equal_85_dBm (list, i);
+/*
+* copy back the randomly sorted list
+*/
+for (i=0; i < MAX_PLMN; i++)
+rr_data->sc_data.found[i] = list->element[i];
+/*
+* de-allocate the dynamic memory
+*/
+MFREE (list);
+}
+/*
++-----------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)  MODULE  : RR_ATT                             |
+| STATE   : code           ROUTINE : att_number_of_plmns_greater_85_dBm |
++-----------------------------------------------------------------------+
+PURPOSE : The function calculates the number of available PLMNs with a
+fieldstrength higher then -85 dBm.
+*/
+static USHORT att_number_of_plmns_greater_85_dBm (void)
+{
+GET_INSTANCE_DATA;
+USHORT nr = 0;
+USHORT i;
+for (i=0; i< rr_data->sc_data.found_entries;i++)
+{
+if (rr_data->sc_data.found[i].plmn.v_plmn EQ V_PLMN_PRES)
+{
+if (rr_data->sc_data.found[i].rxlev > 25)
+{
+/*
+* -85 dBm = -110 + 25 !
+*
+* increment the number of found plmns.
+*/
+nr++;
+}
+}
+}
+/*
+* return the number of PLMNs with a fieldstrength greater than -85 dBm
+*/
+return nr;
+}
+/*
++-----------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)  MODULE  : RR_ATT                             |
+| STATE   : code           ROUTINE : att_copy_found_plmn                |
++-----------------------------------------------------------------------+
+PURPOSE : The function copies the n-th plmn with a fieldstrength
+higher then -85 dBm in the found plmn copy.
+*/
+static void att_copy_found_plmn (T_FOUND_LIST * list,
+USHORT n_in_source_85_dBm,
+USHORT i_in_copy)
+{
+GET_INSTANCE_DATA;
+USHORT x_in_source_85_dBm = 0;
+USHORT i_in_source        = 0;
+T_FOUND_ELEMENT *in_source;
+in_source = &rr_data->sc_data.found[0];
+for (i_in_source=0; i_in_source< rr_data->sc_data.found_entries;
+i_in_source++, in_source++)
+{
+if ((in_source->plmn.v_plmn EQ V_PLMN_PRES) AND (in_source->rxlev > 25))
+{
+/*
+* -85 dBm = -110 + 25 !
+*
+* increment the number of found plmns.
+*/
+if (x_in_source_85_dBm EQ n_in_source_85_dBm)
+{
+/*
+* n-th PLMN with fieldstrength greater -85 dBm found
+*/
+list->element[i_in_copy] = *in_source;
+i_in_copy ++;
+in_source->plmn.v_plmn = V_PLMN_NOT_PRES;
+return;
+}
+else
+x_in_source_85_dBm++;
+}
+}
+}
+/*
++-------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)  MODULE  : RR_ATT                               |
+| STATE   : code           ROUTINE : att_copy_plmns_lower_or_equal_85_dBm |
++-------------------------------------------------------------------------+
+PURPOSE : The function copies the remaining networks with a fieldstrength
+lower or equal -85 dBm in the found plmn copy.
+*/
+static void att_copy_plmns_lower_or_equal_85_dBm (T_FOUND_LIST * list,
+USHORT i_in_copy)
+{
+GET_INSTANCE_DATA;
+USHORT i_in_source;
+T_FOUND_ELEMENT * in_source = &rr_data->sc_data.found[0];
+for (i_in_source=0; i_in_source< rr_data->sc_data.found_entries;
+i_in_source++, in_source++)
+{
+if (in_source->plmn.v_plmn EQ V_PLMN_PRES)
+{
+/*
+* PLMN with fieldstrength less or equal -85 dBm found
+*/
+list->element[i_in_copy] = *in_source;
+i_in_copy ++;
+}
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_code_net_lost          |
++--------------------------------------------------------------------+
+PURPOSE :
+*/
+GLOBAL void att_code_net_lost (void)
+{
+GET_INSTANCE_DATA;
+PALLOC (abort_ind, RR_ABORT_IND);
+TRACE_FUNCTION ("att_code_net_lost()");
+srv_clear_stored_prim (RR_ESTABLISH_REQ);
+abort_ind->op.v_op    = 1;
+abort_ind->op.ts      = (rr_data->ms_data.operation_mode >> SHIFT_FOR_SIM_TYPE) & 1;
+abort_ind->op.m       = (rr_data->ms_data.operation_mode >> SHIFT_FOR_SEARCH_OFFSET) & 1;
+abort_ind->op.sim_ins = (rr_data->ms_data.operation_mode >> SHIFT_FOR_SIM_INSERTED) & 1;
+abort_ind->op.func    = rr_data->ms_data.req_mm_service;
+abort_ind->op.service = NO_SERVICE;
+abort_ind->cause = RRCS_ABORT_CEL_SEL_FAIL;
+abort_ind->plmn_avail = 0;
+memset (abort_ind->plmn, 0, sizeof(abort_ind->plmn));
+memset (abort_ind->rxlevel, 0, sizeof (abort_ind->rxlevel));
+TRACE_OP_TYPE (&abort_ind->op, "RR_ABORT_IND");
+PSENDX (MM, abort_ind);
+rr_data->old_lai.lac = 0xFFFF;
+#ifdef GPRS
+rr_data->old_rac     = NOT_PRESENT_8BIT;
+#endif
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_code_rr_act_cnf        |
++--------------------------------------------------------------------+
+PURPOSE : The function indicates a successful end of cell selection.
+The cell selection was initiated by MM.
+*/
+GLOBAL void att_code_rr_act_cnf (void)
+{
+GET_INSTANCE_DATA;
+T_NC_DATA * rrd = &rr_data->nc_data[SC_INDEX];
+PALLOC (rr_activate_cnf, RR_ACTIVATE_CNF);
+TRACE_FUNCTION ("att_code_rr_act_cnf()");
+TRACE_EVENT ("cell selection");
+rr_data->net_lost = FALSE;
+TIMERSTOP(TABORT);
+/*
+* indicate the requested MM service and the reached RR service
+* to MM.
+*/
+rr_activate_cnf->op.v_op    = 1;
+rr_activate_cnf->op.ts      = (rr_data->ms_data.operation_mode >> SHIFT_FOR_SIM_TYPE) & 1;
+rr_activate_cnf->op.m       = (rr_data->ms_data.operation_mode >> SHIFT_FOR_SEARCH_OFFSET) & 1;
+rr_activate_cnf->op.sim_ins = (rr_data->ms_data.operation_mode >> SHIFT_FOR_SIM_INSERTED) & 1;
+rr_activate_cnf->op.func    = rr_data->ms_data.req_mm_service;
+rr_activate_cnf->op.service = rr_data->ms_data.rr_service;
+TRACE_EVENT_P9 ("RR_ACTIVATE_CNF[%u]: rMM=%s RRs=%s MCC/MNC=%x%x%x/%x%x%x",
+rrd->arfcn,
+_rr_str_FUNC[rr_data->ms_data.req_mm_service],
+_rr_str_SERVICE[rr_data->ms_data.rr_service],
+rrd->lai.mcc[0],
+rrd->lai.mcc[1],
+rrd->lai.mcc[2],
+rrd->lai.mnc[0],
+rrd->lai.mnc[1],
+rrd->lai.mnc[2]);
+if(GET_STATE(STATE_ATT) EQ ATT_CS_INIT )
+{ /*Boot Time: Indicate only the start of power scan to MM*/
+memset( &rr_activate_cnf->mm_info, 0, sizeof(rr_activate_cnf->mm_info));
+memset( &rr_activate_cnf->plmn, 0, sizeof(rr_activate_cnf->plmn));
+rr_activate_cnf->lac = NOT_PRESENT_16BIT;
+rr_activate_cnf->cid = NOT_PRESENT_16BIT;
+rr_activate_cnf->gprs_indication = NOT_PRESENT_8BIT;
+rr_activate_cnf->power = NOT_PRESENT_8BIT;
+}
+else
+{
+/*
+* stop possibly parallel PLMN search
+*/
+att_notify_stop_plmn_search (FALSE);
+/*
+* resume normal RR operation and update the previous
+* requested MM and RR services
+*/
+att_clear_parallel_search ();
+rr_data->ms_data.req_mm_service = att_get_func ();
+rr_data->cs_data.scan_mode = CS_NO_SCAN;
+if (rr_data->ms_data.req_mm_service NEQ rr_activate_cnf->op.func)
+{
+TRACE_EVENT_P2 ("rMM=%s RRs=%s resume normal RR operation",
+_rr_str_FUNC[rr_data->ms_data.req_mm_service],
+_rr_str_SERVICE[rr_data->ms_data.rr_service]);
+}
+TRACE_OP_TYPE (&rr_activate_cnf->op, "RR_ACTIVATE_CNF");
+/*
+* indicate the relevant BCCH parameter to MM
+*/
+att_code_prr_mm_info (&rr_activate_cnf->mm_info);
+/*
+* indicate the PLMN, Location Area and Cell Identity to NN
+*/
+rr_activate_cnf->plmn.v_plmn = V_PLMN_PRES;
+memcpy (rr_activate_cnf->plmn.mcc, rrd->lai.mcc, SIZE_MCC);
+memcpy (rr_activate_cnf->plmn.mnc, rrd->lai.mnc, SIZE_MNC);
+#if defined(_SIMULATION_)
+/* Implements Measure#32: Row 40 */
+att_print_mcc_mnc(rrd->arfcn, rrd->lai.mcc, rrd->lai.mnc, S2I_STRING("RR_ACTIVATE_CNF"));
+#endif
+rr_activate_cnf->lac = rrd->lai.lac;
+rr_activate_cnf->cid = rrd->cell_id;
+EM_PLMN_SRCH_PASSED;
+/*
+* store the current location area and cell id to avoid
+* double signalling to MM
+*/
+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
+#ifdef GPRS
+/*
+* indicates whether gprs operation is provided by the cell
+*/
+/* MS Patch: CQ 24473 */
+rr_activate_cnf->gprs_indication = (rr_data->nc_data[SC_INDEX].rac NEQ
+NOT_PRESENT_8BIT);
+#else
+rr_activate_cnf->gprs_indication = FALSE;
+#endif
+/*
+* set the power class needed for some MM messages depending
+* on the frequency standard and the channel number
+*/
+rr_activate_cnf->power = att_get_power();
+/*
+* Display the Signal bar after camping on a cell with Full service
+*/
+#ifdef FF_PS_RSSI
+RX_SetValue (rr_data->nc_data[SC_INDEX].rxlev,
+RX_QUAL_UNAVAILABLE,
+rr_data->nc_data[SC_INDEX].select_para.rxlev_access_min);
+#else
+RX_SetValue (rr_data->nc_data[SC_INDEX].rxlev);
+#endif
+att_set_rr_service_info();
+}
+PSENDX (MM, rr_activate_cnf);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_code_rr_act_ind        |
++--------------------------------------------------------------------+
+PURPOSE : The function indicates a successful end of RR originated
+cell selection or a successful end of cell reselection.
+*/
+GLOBAL void att_code_rr_act_ind (void)
+{
+GET_INSTANCE_DATA;
+T_NC_DATA * rrd = &rr_data->nc_data[SC_INDEX];
+TRACE_FUNCTION ("att_code_rr_act_ind()");
+TRACE_EVENT ("cell reselection");
+rr_data->net_lost = FALSE;
+TIMERSTOP (TABORT);
+/* It is expected that this works, but this means that   */
+/* the la-field in T_mm_info is superflous. This is also */
+/* true with some other variables in T_mm_info.          */
+/*
+* Special case if we have reselected on a cell belonging to a forbidden
+* location area in FS : it should not be possible on a LAC barred with a
+* LU_REJ(#13) ie roaming not allowed but can happen with a LAC barred
+* for regional provision of service ie LU_REJ(#12).
+* Then a RR_ABORT_IND is sent to MM to switch the entity into limited
+* service even if RR is happy with full service. An empty list of
+* available PLMN is reported so that no PLMN selection is triggered
+* by MM if MS is in automatic mode.
+*/
+if (rr_data->ms_data.rr_service EQ FULL_SERVICE)
+{
+if (!(dat_forb_lai_check (SC_INDEX) AND
+dat_roam_forb_lai_check (SC_INDEX)))
+{
+/*
+* store the current location area and cell id to notify MM
+* when we are back in service
+*/
+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
+/*
+* Indicate limited service, no PLMN available to MM
+*/
+rr_data->sc_data.found_entries    = 0;
+rr_data->ms_data.rr_service       = LIMITED_SERVICE;
+att_code_rr_abort_ind (RRCS_ABORT_CEL_SEL_FAIL);
+rr_data->ms_data.rr_service       = FULL_SERVICE;
+return;
+}
+}
+/* Set the black list search flag, whenever the location area or
+* routing area changes, so that black list search is started
+* after location/routing area update
+*/
+if(rr_data->dyn_config.bl_cs_en)
+{
+if((!dat_plmn_equal_req (rrd->lai.mcc, rrd->lai.mnc,
+rr_data->old_lai.mcc, rr_data->old_lai.mnc))
+OR
+(rrd->lai.lac NEQ rr_data->old_lai.lac ))
+{
+/* Location area has changed. This flag shall be used to start black
+* list search after location area update
+*/
+rr_data->cs_data.black_list_search_pending = TRUE;
+}
+#ifdef GPRS
+if(att_gprs_is_avail() AND (GET_STATE(STATE_GPRS) EQ GPRS_PIM_BCCH))
+{
+if((rrd->rac NEQ NOT_PRESENT_8BIT) AND (rrd->rac NEQ rr_data->old_rac))
+{
+/* Routing area has changed. This flag shall be used to start black
+* list search after routing area update in PIM_BCCH state
+*/
+rr_data->cs_data.black_list_search_pending = TRUE;
+}
+}
+#endif
+if(rr_data->cs_data.black_list_search_pending)
+TRACE_EVENT("black_list_search_pending : 1");
+}
+/*
+* check the current location area identification and cell identity
+* against the last signalled one to MM. If it is not the same
+* a signalling with RR_ACTIVATE_IND is needed
+*/
+if (!dat_plmn_equal_req (rrd->lai.mcc, rrd->lai.mnc,
+rr_data->old_lai.mcc, rr_data->old_lai.mnc)
+OR
+rrd->lai.lac NEQ rr_data->old_lai.lac
+OR
+rrd->cell_id NEQ rr_data->old_cell_id)
+{
+PALLOC (rr_activate_ind, RR_ACTIVATE_IND);
+/*
+* A cell change has occurred. So a running Immediate assignment reject
+* timer is stopped.
+*/
+/* If the MS reselects back onto the same SC (ARFCN) and T3122 is still
+running, it should be left running. If a new cell is selected, this timer
+should is stopped. MM is not informed, because it have already received a
+RR_ABORT_IND and left its state.*/
+TIMERSTOP (T3122);
+/*
+* indicate the requested MM service and the reached RR service
+* to MM.
+*/
+rr_activate_ind->op.v_op    = 1;
+rr_activate_ind->op.ts      = (rr_data->ms_data.operation_mode >> SHIFT_FOR_SIM_TYPE) & 1;
+rr_activate_ind->op.m       = (rr_data->ms_data.operation_mode >> SHIFT_FOR_SEARCH_OFFSET) & 1;
+rr_activate_ind->op.sim_ins = (rr_data->ms_data.operation_mode >> SHIFT_FOR_SIM_INSERTED) & 1;
+if (rr_data->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI)
+rr_activate_ind->op.func  = FUNC_PLMN_SRCH;
+else
+rr_activate_ind->op.func    = rr_data->ms_data.req_mm_service;
+rr_activate_ind->op.service = rr_data->ms_data.rr_service;
+TRACE_OP_TYPE (&rr_activate_ind->op, "RR_ACTIVATE_IND");
+/*
+* stop possibly parallel PLMN search
+*/
+att_notify_stop_plmn_search (FALSE);
+/*
+* resume normal RR operation and update the previous
+* requested MM and RR services
+*/
+att_clear_parallel_search();
+rr_data->ms_data.req_mm_service = att_get_func ();
+rr_data->cs_data.scan_mode = CS_NO_SCAN;
+/*
+* indicate the relevant BCCH parameter to MM
+*/
+att_code_prr_mm_info (&rr_activate_ind->mm_info);
+/*
+* indicate the PLMN, Location Area and Cell Identity to NN
+*/
+rr_activate_ind->plmn.v_plmn = V_PLMN_PRES;
+memcpy (rr_activate_ind->plmn.mcc, rrd->lai.mcc, SIZE_MCC);
+memcpy (rr_activate_ind->plmn.mnc, rrd->lai.mnc, SIZE_MNC);
+#if defined(_SIMULATION_)
+/* Implements Measure#32: Row 40 */
+att_print_mcc_mnc(rrd->arfcn, rrd->lai.mcc, rrd->lai.mnc, S2I_STRING("RR_ACTIVATE_IND"));
+#endif
+rr_activate_ind->lac = rrd->lai.lac;
+rr_activate_ind->cid = rrd->cell_id;
+/*
+* store the current location area and cell id to avoid
+* double signalling to MM
+*/
+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
+#ifdef GPRS
+/*
+* indicates whether gprs operation is provided by the cell
+*/
+/* MS Patch: CQ 24473 */
+rr_activate_ind->gprs_indication = (rr_data->nc_data[SC_INDEX].rac NEQ
+NOT_PRESENT_8BIT);
+#else
+rr_activate_ind->gprs_indication = FALSE;
+#endif
+/*
+* set the power class needed for some MM messages depending
+* on the frequency standard and the channel number
+*/
+rr_activate_ind->power = att_get_power();
+/*
+* Limited to full service reselection
+* TMSI/IMSI data to be refreshed in TIL otherwise no paging possible
+*/
+att_mph_identity_req();
+EM_CELL_RESEL_FINISHED;
+EM_FMM_RESEL_END_IND;
+PSENDX (MM, rr_activate_ind);
+}
+else
+{
+/*
+* indicate changed imsi attach status or
+* changed periodic location updating time to MM
+* if it has changed, else it is only signalled to MM.
+*/
+PALLOC (sync, RR_SYNC_IND);
+att_code_prr_mm_info (&sync->mm_info);
+sync->ciph              = NOT_PRESENT_8BIT;
+sync->chm.ch_mode       = NOT_PRESENT_8BIT;
+switch (rr_data->sc_data.selection_type)
+{
+case CELL_SELECTION:
+case CELL_RESELECTION:
+case CELL_RESELECTION_NC:
+case CELL_RESELECTION_RACH:
+case CELL_RESELECTION_CR:
+/*
+* cell reselection in idle mode
+*/
+sync->synccs            = SYNCCS_IDLE_SELECTION;
+break;
+default:
+/*
+* cell reselection after dedicated mode
+*/
+sync->synccs            = SYNCCS_BACK_FROM_DEDICATED;
+break;
+}
+sync->bcch_info.v_bcch  = FALSE;
+PSENDX (MM, sync);
+EM_FMM_RESEL_END_IND;
+}
+att_set_rr_service_info();
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_get_power              |
++--------------------------------------------------------------------+
+PURPOSE : get the power class needed for some MM messages depending
+on the frequency standard and the channel number of the
+serving cell.
+*/
+GLOBAL UBYTE att_get_power (void)
+{
+GET_INSTANCE_DATA;
+UBYTE power = 0;
+UBYTE power_idx = (UBYTE)-1;
+TRACE_FUNCTION ("att_get_power()");
+/* new method, use directly the rf capabilities */
+/* coding of power class according to classmark 3 [1..5] */
+switch (std)
+{
+case STD_900:
+case STD_EGSM:
+power_idx = IDX_PWRCLASS_900;
+break;
+case STD_1800:
+power_idx = IDX_PWRCLASS_1800;
+break;
+case STD_DUAL:
+case STD_DUAL_EGSM:
+if (INRANGE(LOW_CHANNEL_1800,rr_data->nc_data[SC_INDEX].arfcn,HIGH_CHANNEL_1800))
+power_idx = IDX_PWRCLASS_1800;
+else
+power_idx = IDX_PWRCLASS_900;
+break;
+case STD_1900:
+power_idx = IDX_PWRCLASS_1900;
+break;
+case STD_850:
+power_idx = IDX_PWRCLASS_850;
+break;
+case STD_DUAL_US:
+if (rr_data->nc_data[SC_INDEX].arfcn < LOW_CHANNEL_1900)
+power_idx = IDX_PWRCLASS_850;
+else
+power_idx = IDX_PWRCLASS_1900;
+break;
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+case STD_850_1800:
+if (INRANGE(LOW_CHANNEL_1800,rr_data->nc_data[SC_INDEX].arfcn,HIGH_CHANNEL_1800))
+power_idx = IDX_PWRCLASS_1800;
+else
+power_idx = IDX_PWRCLASS_850;
+break;
+case STD_900_1900:
+if (INRANGE(LOW_CHANNEL_1900,rr_data->nc_data[SC_INDEX].arfcn,HIGH_CHANNEL_1900))
+power_idx = IDX_PWRCLASS_1900;
+else
+power_idx = IDX_PWRCLASS_900;
+break;
+case STD_850_900_1800:
+if (INRANGE(LOW_CHANNEL_1800,rr_data->nc_data[SC_INDEX].arfcn,HIGH_CHANNEL_1800))
+power_idx = IDX_PWRCLASS_1800;
+else if (INRANGE(LOW_CHANNEL_850,rr_data->nc_data[SC_INDEX].arfcn,HIGH_CHANNEL_850))
+power_idx = IDX_PWRCLASS_850;
+else
+power_idx = IDX_PWRCLASS_900;
+break;
+case STD_850_900_1900:
+if (INRANGE(LOW_CHANNEL_1900,rr_data->nc_data[SC_INDEX].arfcn,HIGH_CHANNEL_1900))
+power_idx = IDX_PWRCLASS_1900;
+else if (INRANGE(LOW_CHANNEL_850,rr_data->nc_data[SC_INDEX].arfcn,HIGH_CHANNEL_850))
+power_idx = IDX_PWRCLASS_850;
+else
+power_idx = IDX_PWRCLASS_900;
+break;
+#endif
+}
+if (power_idx NEQ (UBYTE)-1)
+power = rr_data->ms_data.rf_cap.rf_power.pow_class4[power_idx].pow_class;
+else
+power = 0;
+/*
+TRACE_EVENT_P3 ("power=%u(new),  idx=%d, std=%u", power, power_idx, std);
+*/
+if (power)
+power--; /* coding of power class according to classmark 1 and 2 [0..4] */
+return power;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_continue_cell_reselect |
++--------------------------------------------------------------------+
+PURPOSE : A cell reselection candidate has failed. Inside this function
+the next one is searched.
+*/
+GLOBAL void att_continue_cell_reselect (void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_continue_cell_reselect()");
+switch (rr_data->sc_data.selection_type)
+{
+case BACK_FROM_DEDICATED:
+case BACK_FROM_DEDICATED_RLF:
+/*
+* After a dedicated connection
+*/
+rr_data->reselect_index =
+att_get_next_highest_c2_idx (rr_data->reselect_index);
+att_select_cell_dedicated ();
+break;
+default:
+/*
+* In idle mode
+*/
+#ifdef GPRS
+if( rr_data->gprs_data.use_c31)
+{
+rr_data->reselect_index =  att_get_next_best_c32_index(TRUE);
+if (! att_check_cell_c31())
+att_try_old_cell();
+}
+else
+{
+#endif
+rr_data->reselect_index =
+att_get_next_highest_c2_idx (rr_data->reselect_index);
+/*
+* If no other cell is available, try the old one
+*/
+if (! att_check_cell ())
+{
+TRACE_EVENT ("no further cell found -> try old one");
+att_try_old_cell ();
+}
+else
+{
+TRACE_EVENT_P2 ("try next cell [%u]i%u",
+rr_data->nc_data[rr_data->reselect_index].arfcn,
+rr_data->reselect_index);
+}
+#ifdef GPRS
+}
+#endif
+break;
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_copy_rach_parameter    |
++--------------------------------------------------------------------+
+PURPOSE : After reception of system information message 1 to 4 in
+idle mode or cell selection / reselection the RACH parameters
+are stored. The flag indicate_changes defines whether
+changes in the RACH parameter shall be forwarded to MM
+(in idle mode for serving cell) or not (any other cases).
+*/
+static void att_copy_rach_parameter (UBYTE        index,
+T_rach_ctrl *rach,
+UBYTE        indicate_changes)
+{
+GET_INSTANCE_DATA;
+T_NC_DATA *rrd = &rr_data->nc_data[index];
+TRACE_FUNCTION ("att_copy_rach_parameter()");
+if (index EQ SC_INDEX AND
+indicate_changes)
+{
+/*
+* compare only for serving cell
+*/
+if (rrd->rach.re NEQ rach->re)
+{
+/*
+* change of reestablishment flag indicate to MM
+*/
+PALLOC (sync, RR_SYNC_IND);
+rrd->rach.re = rach->re;
+att_code_prr_mm_info (&sync->mm_info);
+sync->ciph              = NOT_PRESENT_8BIT;
+sync->chm.ch_mode       = NOT_PRESENT_8BIT;
+sync->synccs            = SYNCCS_SYS_INFO_CHANGE;
+memset(&sync->bcch_info, 0, sizeof(T_bcch_info));
+sync->bcch_info.v_bcch  = FALSE;
+PSENDX (MM, sync);
+}
+if (rrd->rach.ac NEQ rach->ac)
+{
+/*
+* change of access classes indicate to MM
+*/
+PALLOC (sync, RR_SYNC_IND);
+sync->ciph              = NOT_PRESENT_8BIT;
+sync->chm.ch_mode       = NOT_PRESENT_8BIT;
+sync->synccs            = SYNCCS_ACC_CLS_CHA;
+memset(&sync->mm_info,   0, sizeof(T_mm_info));
+sync->mm_info.valid     = FALSE;
+memset(&sync->bcch_info, 0, sizeof(T_bcch_info));
+sync->bcch_info.v_bcch  = FALSE;
+PSENDX (MM, sync);
+}
+}
+rrd->rach = *rach;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_copy_sys_info_1_par    |
++--------------------------------------------------------------------+
+PURPOSE : copy the relevant system information type 1 parameter after
+reception in idle mode or during cell selection or cell
+reselection.
+*/
+GLOBAL void att_copy_sys_info_1_par (UBYTE           index,
+T_D_SYS_INFO_1 *sys_info_1,
+T_LIST         *cell_chan_desc)
+{
+GET_INSTANCE_DATA;
+T_CELL_DATA * cd;
+UBYTE indicate_changes = index EQ SC_INDEX;
+switch (index)
+{
+case SC_INDEX:
+case CR_INDEX:
+/*
+* set pointer to data
+*/
+if (index EQ SC_INDEX)
+cd = &rr_data->sc_data.cd;
+else
+cd = &rr_data->cr_data.cd;
+/*
+* If a cell channel description is not stored for
+* this cell or the new cell channel description is
+* different, store the new one.
+*/
+if (cd->v_cell_chan_desc EQ NO_CONTENT OR
+srv_compare_list (&cd->cell_chan_desc,
+cell_chan_desc) EQ FALSE)
+{
+srv_copy_list (&cd->cell_chan_desc,
+cell_chan_desc,
+sizeof (T_LIST));
+cd->v_cell_chan_desc = WITH_CHANGED_CONTENT;
+if((indicate_changes) AND (GET_STATE(STATE_ATT) EQ ATT_IDLE)
+AND ( rr_data->sc_data.cd.cbch_chan_desc.hop EQ H_FREQ) )
+{
+#ifdef REL99
+att_config_cbch();
+#else
+att_build_cbch();
+#endif
+}
+}
+/* Get the band indicator value from SI1 message */
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+cd->band_indicator = sys_info_1->si1_rest_oct.band_indicator;
+if (index EQ SC_INDEX)
+{
+att_update_std_band_indicator (cd->band_indicator);
+}
+#endif
+break;
+}
+att_copy_rach_parameter (index, &sys_info_1->rach_ctrl, indicate_changes);
+/*
+* Indicate that the system information type 1 message has been read.
+*/
+att_set_sys_info_read (SYS_INFO_1_READ, index);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_copy_sys_info_2bis_par |
++--------------------------------------------------------------------+
+PURPOSE : copy the relevant system information type 2bis parameter after
+reception in idle mode (in this case changes are to detect)
+or during cell selection or cell reselection.
+*/
+GLOBAL void att_copy_sys_info_2bis_par (UBYTE              index,
+T_D_SYS_INFO_2BIS *sys_info_2bis,
+T_LIST            *new_2bis_list,
+UBYTE              ncell_ext,
+UBYTE              indicate_changes)
+{
+/* Implements RR Clone findings #3 */
+TRACE_FUNCTION ("att_copy_sys_info_2bis_par()");
+/* Implements RR Clone findings #3 */
+att_copy_sys_info_2bis_2ter_par(index, SI_TYPE_2BIS, new_2bis_list,
+&sys_info_2bis->neigh_cell_desc,
+indicate_changes);
+att_copy_rach_parameter (index, &sys_info_2bis->rach_ctrl, indicate_changes);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_copy_sys_info_2_par    |
++--------------------------------------------------------------------+
+PURPOSE : copy the relevant system information type 2 parameter after
+reception in idle mode (in this case changes are to detect)
+or during cell selection or cell reselection.
+*/
+GLOBAL void att_copy_sys_info_2_par (UBYTE           index,
+T_D_SYS_INFO_2 *sys_info_2,
+T_LIST         *new_2_list,
+UBYTE           ncell_ext,
+UBYTE           indicate_changes)
+{
+GET_INSTANCE_DATA;
+T_LIST        new_list;
+T_CELL_DATA   *cd;
+BOOL          modified = FALSE;
+TRACE_FUNCTION ("att_copy_sys_info_2_par()");
+switch (index)
+{
+case SC_INDEX:
+case CR_INDEX:
+if (index EQ SC_INDEX)
+{
+cd = &rr_data->sc_data.cd;
+if ((cd->sys_info_read & SYS_INFO_2_READ) EQ SYS_INFO_2_READ)
+{
+srv_copy_list (&cd->ncell_list, new_2_list, sizeof (T_LIST));
+att_clean_buf ((USHORT)(IND_SI_2BIS | IND_SI_2TER));
+cd->sys_info_read &= ~(SYS_INFO_2BIS_READ | SYS_INFO_2TER_READ);
+att_check_2ter_read (index);
+}
+else
+srv_merge_list (&cd->ncell_list, new_2_list);
+if( cd->ncell_ext NEQ ncell_ext )
+{
+PALLOC (mph_sync_req, MPH_SYNC_REQ);
+mph_sync_req->cs = CS_SYS_INFO_2BIS_SUPPORT_CHANGED;
+PSENDX (PL, mph_sync_req);
+cd->ncell_ext = ncell_ext;
+}
+modified = TRUE;
+#ifdef GPRS
+rr_data->gprs_data.ba_bcch_modified= FALSE;
+#endif
+}
+else
+{
+cd = &rr_data->cr_data.cd;
+/*
+* merge 2 list with the old neighbour cell list
+*/
+srv_copy_list (&new_list, &cd->ncell_list,
+sizeof (T_LIST));
+srv_merge_list (&new_list, new_2_list);
+if (srv_compare_list (&cd->ncell_list, &new_list) EQ FALSE)
+{
+/*
+* both lists are different
+*/
+srv_copy_list (&cd->ncell_list, &new_list, sizeof (T_LIST));
+modified = TRUE;
+}
+cd->ncell_ext = ncell_ext;
+}
+/* CSI-LLD section:4.1.1.11
+* This function Updates the black list with the BA list received in si2
+*/
+cs_remove_BA_MA_from_black_list(rr_data->cs_data.region,&cd->ncell_list);
+dat_store_neigh_cell_desc (SYS_INFO_2_MSG, index,
+&sys_info_2->neigh_cell_desc,&cd->ncell_list);
+/*
+* Indicate that the system information type 2 message has been read
+* and if applicable the system information type 2bis is not needed to read.
+*/
+att_set_sys_info_read (SYS_INFO_2_READ, index);
+if (ncell_ext EQ 0)
+att_set_sys_info_read (SYS_INFO_2BIS_READ, index);
+/*
+* forward new neighbour cell list to layer 1 if
+* changes shall be indicated
+*/
+if (modified AND indicate_changes)
+{
+att_code_mph_ncell_req (index);
+}
+/*
+* copy ncc permitted field
+*/
+cd->ncc_permitted = sys_info_2->ncc_permit;
+break;
+}
+att_copy_rach_parameter (index, &sys_info_2->rach_ctrl, indicate_changes);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_copy_sys_info_2ter_par |
++--------------------------------------------------------------------+
+PURPOSE : copy the relevant system information type 2ter parameter after
+reception in idle mode or during cell selection or cell
+reselection.
+*/
+GLOBAL void att_copy_sys_info_2ter_par (UBYTE              index,
+T_D_SYS_INFO_2TER *sys_info_2ter,
+T_LIST            *new_2ter_list,
+UBYTE              indicate_changes)
+{
+/* Implements RR Clone findings #3 */
+TRACE_FUNCTION ("att_copy_sys_info_2ter_par()");
+/* Implements RR Clone findings #8 */
+att_copy_sys_info_2bis_2ter_par(index, SI_TYPE_2TER, new_2ter_list,
+&sys_info_2ter->neigh_cell_desc,
+indicate_changes);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_check_2ter_read        |
++--------------------------------------------------------------------+
+PURPOSE : checks whether to wait for SI_2ter.
+*/
+static void att_check_2ter_read (UBYTE index)
+{
+GET_INSTANCE_DATA;
+if (rr_data->nc_data[index].c2_par.two_ter EQ FALSE)
+att_set_sys_info_read (SYS_INFO_2TER_READ, index);
+/*
+* only in dualband standards 2ter is taken in account
+* in single bands it is ignored.
+*/
+switch (std)
+{
+case STD_900:
+case STD_EGSM:
+case STD_1800:
+case STD_850:
+case STD_1900:
+att_set_sys_info_read (SYS_INFO_2TER_READ, index);
+break;
+default:
+break;
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_copy_sys_info_3_par    |
++--------------------------------------------------------------------+
+PURPOSE : copy the relevant system information type 3 parameter after
+reception in idle mode or during cell selection or cell
+reselection.
+*/
+/*
+* conversion from air interface coding for DTX usage to internal
+* notation
+*/
+static const UBYTE dtx_bcch [3] = { DTX_USED, DTX_USED, DTX_NOT_USED };
+GLOBAL void att_copy_sys_info_3_par (UBYTE           index,
+T_D_SYS_INFO_3 *sys_info_3,
+UBYTE           indicate_changes)
+{
+GET_INSTANCE_DATA;
+T_NC_DATA * rrd                = &rr_data->nc_data[index];
+UBYTE       lai_changed        = FALSE;
+UBYTE       control_changed_mm = FALSE;
+UBYTE       control_changed_l1 = FALSE;
+TRACE_FUNCTION ("att_copy_sys_info_3_par()");
+#if defined(_SIMULATION_)
+TRACE_EVENT_WIN_P7 ( "MCC o/i[%d]= %x%x%x/%x%x%x",
+((int)rrd->arfcn),
+rrd->lai.mcc[0],
+rrd->lai.mcc[1],
+rrd->lai.mcc[2],
+sys_info_3->loc_area_ident.mcc[0],
+sys_info_3->loc_area_ident.mcc[1],
+sys_info_3->loc_area_ident.mcc[2]);
+TRACE_EVENT_WIN_P7 ( "MNC o/i[%d]= %x%x%x/%x%x%x",
+((int)rrd->arfcn),
+rrd->lai.mnc[0],
+rrd->lai.mnc[1],
+rrd->lai.mnc[2],
+sys_info_3->loc_area_ident.mnc[0],
+sys_info_3->loc_area_ident.mnc[1],
+sys_info_3->loc_area_ident.mnc[2]);
+#endif
+if (index EQ SC_INDEX)
+{
+/*
+* compare only for serving cell
+*
+* check location area information and cell id
+*/
+if (rrd->cell_id NEQ sys_info_3->cell_ident)
+lai_changed = TRUE;
+rrd->cell_id = sys_info_3->cell_ident;
+if (!dat_plmn_equal_req (sys_info_3->loc_area_ident.mcc,
+sys_info_3->loc_area_ident.mnc,
+rrd->lai.mcc,
+rrd->lai.mnc))
+lai_changed = TRUE;
+if (rrd->lai.lac NEQ sys_info_3->loc_area_ident.lac)
+lai_changed = TRUE;
+#if defined(_SIMULATION_)
+TRACE_EVENT_WIN_P3 ( "LAI[%d] changed=%d indicate_changes=%d",
+rr_data->nc_data[index].arfcn, lai_changed, indicate_changes);
+#endif
+if (lai_changed AND indicate_changes)
+{
+/*
+* If a change of location area code is detected,
+* signal this as a cell reselection to MM to force
+* a location updating.
+*/
+att_reset_old_lai_rac();
+memcpy (&rrd->lai, &sys_info_3->loc_area_ident,
+sizeof (T_loc_area_ident));
+att_code_rr_act_ind ();
+#ifdef GPRS
+if (att_gprs_is_avail())
+{
+/*XY: inform GRR, and don't wait for CR_RSP */
+att_rrgrr_cr_ind(CR_ABNORMAL);
+/*
+* we are in the process of acquiring SIs because GRR
+* has requested it. We have to set the sys_info_read bitmap
+* to complete. in order to send a GPRS_SI13_IND to GRR below.
+* The missing SIs which RR requested will still arrive from ALR
+* so it does not matter that we reset the bitmap now.
+*/
+att_set_sys_info_read(ALL_SYS_INFO_READ, SC_INDEX);
+rr_data->gprs_data.start_proc = START_PROC_NOTHING;
+att_signal_gprs_support();
+}
+#endif
+}
+/*
+* check imsi attach status and
+* periodic location update time
+*/
+if ((rrd->control_descr.att NEQ sys_info_3->ctrl_chan_desc.att
+OR
+rrd->control_descr.t3212 NEQ sys_info_3->ctrl_chan_desc.t3212)
+AND
+indicate_changes)
+control_changed_mm = TRUE;
+/*
+* check control channel description
+*/
+if (rrd->control_descr.bs_ag_blks_res NEQ
+sys_info_3->ctrl_chan_desc.bs_ag_blks_res)
+control_changed_l1 = TRUE;
+if (rrd->control_descr.ccch_conf NEQ
+sys_info_3->ctrl_chan_desc.ccch_conf)
+control_changed_l1 = TRUE;
+if (rrd->control_descr.bs_pa_mfrms NEQ
+sys_info_3->ctrl_chan_desc.bs_pa_mfrms)
+control_changed_l1 = TRUE;
+/*
+* check cell selection parameters
+*/
+if (rrd->select_para.ms_txpwr_max_cch NEQ
+sys_info_3->cell_select.ms_txpwr_max_cch)
+{
+control_changed_l1 = TRUE;
+TRACE_EVENT_P2("txpwr_max_cch changed from %d -> %d in SI3", rrd->select_para.ms_txpwr_max_cch,
+sys_info_3->cell_select.ms_txpwr_max_cch);
+}
+}
+/*
+* store location information and control channel description
+*/
+rrd->cell_id = sys_info_3->cell_ident;
+#ifdef REL99
+rrd->mscr_flag = sys_info_3->ctrl_chan_desc.mscr;
+#endif
+memcpy (&rrd->lai, &sys_info_3->loc_area_ident,
+sizeof (T_loc_area_ident));
+memcpy (&rrd->control_descr, &sys_info_3->ctrl_chan_desc,
+sizeof (T_ctrl_chan_desc));
+if (control_changed_mm)
+{
+/*
+* indicate changed imsi attach status or
+* changed periodic location updating time to MM
+*/
+PALLOC (sync, RR_SYNC_IND);
+att_code_prr_mm_info (&sync->mm_info);
+sync->ciph              = NOT_PRESENT_8BIT;
+sync->chm.ch_mode       = NOT_PRESENT_8BIT;
+sync->synccs            = SYNCCS_SYS_INFO_CHANGE;
+sync->bcch_info.v_bcch  = FALSE;
+PSENDX (MM, sync);
+}
+/*
+* store the system information type 3 message parameter.
+*/
+switch (index)
+{
+case SC_INDEX:
+rr_data->sc_data.cd.cell_options.pow_ctrl =
+sys_info_3->cell_opt_bcch.pow_ctrl;
+rr_data->sc_data.cd.cell_options.rlt      =
+sys_info_3->cell_opt_bcch.rlt;
+rr_data->sc_data.cd.dtx                   =
+dtx_bcch [sys_info_3->cell_opt_bcch.dtx_b];
+rr_data->sc_data.cd.dtx_half              =
+rr_data->sc_data.cd.dtx_full        =
+rr_data->sc_data.cd.dtx;
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+/*The SI-2quater information that we store is useful for monitoring appropriate
+BCCH periodically: no need to change status in re-acquisition*/
+if ( sys_info_3->si3_rest_oct.v_si2quater_ind )
+{
+if ( rr_data->sc_data.cd.si2quater_status EQ SI2QUATER_ABSENT)
+rr_data->sc_data.cd.si2quater_status = SI2QUATER_CONFIGURE;
+rr_data->sc_data.cd.si2quater_pos = sys_info_3->si3_rest_oct.si2quater_ind.si2quater_pos;
+}
+#endif
+break;
+case CR_INDEX:
+rr_data->cr_data.cd.cell_options.pow_ctrl =
+sys_info_3->cell_opt_bcch.pow_ctrl;
+rr_data->cr_data.cd.cell_options.rlt      =
+sys_info_3->cell_opt_bcch.rlt;
+rr_data->cr_data.cd.dtx                   =
+dtx_bcch [sys_info_3->cell_opt_bcch.dtx_b];
+rr_data->cr_data.cd.dtx_half              =
+rr_data->cr_data.cd.dtx_full        =
+rr_data->cr_data.cd.dtx;
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+/*The SI-2quater information that we store is used only if this cell is selected
+In case of serving cell, this information should be useful for monitoring appropriate
+BCCH periodically*/
+rr_data->cr_data.cd.si2quater_status = SI2QUATER_ABSENT;
+if ( sys_info_3->si3_rest_oct.v_si2quater_ind )
+{
+rr_data->cr_data.cd.si2quater_status = SI2QUATER_CONFIGURE;
+rr_data->cr_data.cd.si2quater_pos = sys_info_3->si3_rest_oct.si2quater_ind.si2quater_pos;
+}
+#endif
+break;
+}
+memcpy (&rrd->select_para, &sys_info_3->cell_select,
+sizeof (T_cell_select));
+att_copy_rach_parameter (index, &sys_info_3->rach_ctrl,
+indicate_changes);
+att_copy_c2_parameter_si3 (index, &sys_info_3->si3_rest_oct);
+att_set_sys_info_read (SYS_INFO_3_READ, index);
+att_check_2ter_read (index);
+if (control_changed_l1 AND indicate_changes)
+{
+/*
+* forward changed control channel description
+* to layer 1
+*/
+att_build_idle_req (SC_INDEX, MODE_SYS_INFO_CHANGE);
+#ifdef REL99
+att_config_cbch ();
+#else
+att_build_cbch();
+#endif
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_copy_sys_info_4_par    |
++--------------------------------------------------------------------+
+PURPOSE : copy the relevant system information type 4 parameter after
+reception in idle mode or during cell selection or cell
+reselection.
+*/
+GLOBAL void att_copy_sys_info_4_par (UBYTE           index,
+T_D_SYS_INFO_4 *sys_info_4,
+UBYTE           indicate_changes)
+{
+GET_INSTANCE_DATA;
+T_NC_DATA   * rrd         = &rr_data->nc_data[index];
+UBYTE         lai_changed = FALSE;
+UBYTE       control_changed_l1 = FALSE;
+T_CELL_DATA * cd;
+TRACE_FUNCTION ("att_copy_sys_info_4_par()");
+switch (index)
+{
+case SC_INDEX:
+case CR_INDEX:
+/*
+* set pointer to data
+*/
+if (index EQ SC_INDEX)
+cd = &rr_data->sc_data.cd;
+else
+cd = &rr_data->cr_data.cd;
+if (index EQ SC_INDEX)
+{
+/*
+* compare only for serving cell
+*
+* check location information
+*/
+if (!dat_plmn_equal_req (sys_info_4->loc_area_ident.mcc,
+sys_info_4->loc_area_ident.mnc,
+rrd->lai.mcc,
+rrd->lai.mnc))
+lai_changed = TRUE;
+if (rrd->lai.lac NEQ sys_info_4->loc_area_ident.lac)
+lai_changed = TRUE;
+if (lai_changed AND indicate_changes)
+{
+/*
+* If a change of location area code is detected,
+* signal this as a cell reselection to MM to force
+* a location updating.
+*/
+att_reset_old_lai_rac();
+memcpy (&rrd->lai, &sys_info_4->loc_area_ident,
+sizeof (T_loc_area_ident));
+att_code_rr_act_ind ();
+#ifdef GPRS
+if (att_gprs_is_avail())
+{
+/*XY: inform GRR, and don't wait for CR_RSP */
+att_rrgrr_cr_ind(CR_ABNORMAL);
+/*
+* we are in the process of acquiring SIs because GRR
+* has requested it. We have to set the sys_info_read bitmap
+* to complete. in order to send a GPRS_SI13_IND to GRR below.
+* The missing SIs which RR requested will still arrive from ALR
+* so it does not matter that we reset the bitmap now.
+*/
+att_set_sys_info_read(ALL_SYS_INFO_READ, SC_INDEX);
+rr_data->gprs_data.start_proc = START_PROC_NOTHING;
+att_signal_gprs_support();
+}
+#endif
+}
+/*
+* check cell selection parameters
+*/
+if (rrd->select_para.ms_txpwr_max_cch NEQ
+sys_info_4->cell_select.ms_txpwr_max_cch)
+{
+control_changed_l1 = TRUE;
+TRACE_EVENT_P2("txpwr_max_cch changed from %d -> %d in SI4", rrd->select_para.ms_txpwr_max_cch,
+sys_info_4->cell_select.ms_txpwr_max_cch);
+}
+}
+if (sys_info_4->v_chan_desc)
+{
+/*
+* the message contains a CBCH channel description.
+*/
+if(memcmp(&cd->cbch_chan_desc,&sys_info_4->chan_desc, sizeof (T_chan_desc)) NEQ 0)
+{
+memcpy (&cd->cbch_chan_desc, &sys_info_4->chan_desc, sizeof (T_chan_desc));
+cd->cbch_chan_desc_avail = WITH_CONTENT;
+att_bits_to_byte (cd->cbch_mob_alloc,
+sys_info_4->mob_alloc.c_mac,
+sys_info_4->mob_alloc.mac);
+if( (index EQ SC_INDEX) AND ( GET_STATE(STATE_ATT) EQ ATT_IDLE))
+#ifdef REL99
+att_config_cbch();
+#else
+att_build_cbch();
+#endif
+}
+}
+else
+{
+memset (&cd->cbch_chan_desc, 0, sizeof (T_chan_desc));
+if( cd->cbch_chan_desc_avail NEQ NO_CONTENT)
+{
+cd->cbch_chan_desc_avail = NO_CONTENT;
+if( (index EQ SC_INDEX) AND ( GET_STATE(STATE_ATT) EQ ATT_IDLE))
+#ifdef REL99
+att_config_cbch();
+#else
+att_build_cbch();
+#endif
+}
+}
+/*
+* set system information bits
+*/
+att_set_sys_info_read (SYS_INFO_4_READ, index);
+break;
+default:
+break;
+}
+/*
+* copy the parameters
+*/
+rrd->v_acs       = sys_info_4->cell_select.acs;    /* use of sys info 7&8 */
+rrd->lai         = sys_info_4->loc_area_ident;
+rrd->select_para = sys_info_4->cell_select;
+att_copy_rach_parameter (index, &sys_info_4->rach_ctrl, indicate_changes);
+if (control_changed_l1 AND indicate_changes)
+{
+/*
+* forward changed control channel description
+* to layer 1
+*/
+att_build_idle_req (SC_INDEX, MODE_SYS_INFO_CHANGE);
+att_build_cbch ();
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_copy_sys_info_7_8_par  |
++--------------------------------------------------------------------+
+PURPOSE : copy the relevant system information type 7 and 8
+parameter after reception in idle mode for neighbourcells.
+The messages  are only expected if system information
+message 4 does not contain the C2 parameter due to a big
+CBCH channel description and system information
+message 3 is hidden by the own paging block.
+*/
+GLOBAL void att_copy_sys_info_7_8_par (UBYTE           index,
+T_D_SYS_INFO_8 *sys_info_8)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_copy_sys_info_7_8_par()");
+/*
+* system info 4 does not contain enough information
+*/
+if (rr_data->nc_data[index].v_acs)
+att_copy_c2_parameter_si4 (index, (T_si4_rest_oct *)&sys_info_8->si8_rest_oct);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_copy_c2_parameter      |
++--------------------------------------------------------------------+
+PURPOSE : Rest Octets of System Information Type 3/4/7/8 are decoded
+to get the C2 parameter for cell reselection.
+*/
+static void att_copy_c2_parameter (T_C2_PARAMETER *c2_par,
+T_si3_rest_oct *rest_oct )
+{
+TRACE_FUNCTION ("att_copy_c2_parameter()");
+/* Optional selection parameters */
+if(rest_oct->v_opt_sel_par)
+{
+c2_par->param_ind            = TRUE;
+c2_par->cbq                  = rest_oct->opt_sel_par.cell_bar_qual;
+c2_par->cell_reselect_offset = rest_oct->opt_sel_par.cell_resel_offs;
+c2_par->temp_offset          = rest_oct->opt_sel_par.temp_offs;
+c2_par->penalty_time         = rest_oct->opt_sel_par.penalty_time;
+}
+else
+{
+c2_par->param_ind            = FALSE;
+c2_par->cbq                  = 0;
+c2_par->cell_reselect_offset = 0;
+c2_par->temp_offset          = 0;
+c2_par->penalty_time         = 0;
+}
+/* Optional Power Offset */
+if(rest_oct->v_pow_offs)
+{
+c2_par->power_off_ind = TRUE;
+c2_par->power_off     = rest_oct->pow_offs;
+}
+else
+{
+c2_par->power_off_ind = FALSE;
+c2_par->power_off     = 0;
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_copy_c2_parameter_si3  |
++--------------------------------------------------------------------+
+PURPOSE : rest octets of system information 3 are decoded
+to get the C2 parameter for cell reselection.
+*/
+static void att_copy_c2_parameter_si3 (UBYTE           index,
+T_si3_rest_oct *rest_oct)
+{
+GET_INSTANCE_DATA;
+T_NC_DATA      * nc     = &rr_data->nc_data[index];
+T_C2_PARAMETER * c2_par = &nc->c2_par;
+TRACE_FUNCTION ("att_copy_c2_parameter_si3()");
+att_copy_c2_parameter (c2_par, rest_oct);
+if(index EQ SC_INDEX AND
+c2_par->two_ter NEQ rest_oct->v_si2ter_ind)
+{
+PALLOC (mph_sync_req, MPH_SYNC_REQ);
+mph_sync_req->cs = CS_SYS_INFO_2TER_SUPPORT_CHANGED;
+PSENDX (PL, mph_sync_req);
+}
+/* System Information 2ter Indicator */
+if (rest_oct->v_si2ter_ind)
+{
+c2_par->two_ter = TRUE;
+}
+else
+{
+c2_par->two_ter = FALSE;
+}
+/* Early Classmark Sending Control */
+if (rest_oct->v_es_ind_tag)
+{
+c2_par->ecsc = TRUE;
+}
+else
+{
+c2_par->ecsc = FALSE;
+}
+#ifdef GPRS
+if (rest_oct->v_gprs_indic)
+nc->rac = rest_oct->gprs_indic.ra_color;
+else
+nc->rac = NOT_PRESENT_8BIT;
+#endif
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_copy_c2_parameter_si4  |
++--------------------------------------------------------------------+
+PURPOSE : Rrest Octets of System Information Type 4 are decoded
+to get the C2 parameter for cell reselection.
+*/
+GLOBAL void att_copy_c2_parameter_si4 (UBYTE           index,
+T_si4_rest_oct *rest_oct)
+{
+GET_INSTANCE_DATA;
+T_NC_DATA      * nc     = &rr_data->nc_data[index];
+T_C2_PARAMETER * c2_par = &nc->c2_par;
+TRACE_FUNCTION ("att_copy_c2_parameter_si4()");
+att_copy_c2_parameter (c2_par, (T_si3_rest_oct *)rest_oct);
+#ifdef GPRS
+if (rest_oct->v_gprs_indic)
+nc->rac = rest_oct->gprs_indic.ra_color;
+else
+nc->rac = NOT_PRESENT_8BIT;
+#endif
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_get_highest_c2_index   |
++--------------------------------------------------------------------+
+PURPOSE : If a cell reselection shall be performed, a ranking
+of the available candidates is done. Depending on the
+calculated C2 values a C2-Index is used (because more
+than one cell can have the same C2-value or the value
+changes during cell reselection). This function looks
+for the cell with the highest c2 index.
+*/
+static UBYTE att_get_highest_c2_index (void)
+{
+GET_INSTANCE_DATA;
+UBYTE max_result = SC_INDEX;
+UBYTE next_result;
+UBYTE result;
+UBYTE i;
+TRACE_FUNCTION ("att_get_highest_c2_index()");
+switch (rr_data->sc_data.selection_type)
+{
+case BACK_FROM_DEDICATED:
+case BACK_FROM_DEDICATED_RLF:
+/*
+* prepare cell reselection list
+*/
+for (i = 0; i < 7; i++)
+{
+rr_data->nc_data[i].c2_used = FALSE;
+if (rr_data->nc_data[i].bcch_status NEQ EMPTY)
+if (rr_data->nc_data[i].rxlev > rr_data->nc_data[max_result].rxlev)
+max_result = i;
+}
+if (rr_data->sc_data.selection_type EQ BACK_FROM_DEDICATED)
+{
+/*
+* In case of normal release start with serving cell
+*/
+rr_data->nc_data[SC_INDEX].c2_used = TRUE;
+max_result                         = SC_INDEX;
+rr_data->ms_data.c2_tab[SC_INDEX]  = MAX_C2;
+result = SC_INDEX;
+}
+else
+{
+/*
+* In case of call re-establishment start with highest fieldstrength
+*/
+rr_data->nc_data[max_result].c2_used = TRUE;
+rr_data->ms_data.c2_tab[max_result]  = MAX_C2;
+result = max_result;
+}
+/*
+* Fill with the rest of neighbourcells
+*/
+while ((next_result = att_get_next_highest_rx ())
+NEQ NO_AVAILABLE)
+{
+rr_data->ms_data.c2_tab[next_result] =
+rr_data->ms_data.c2_tab[result] - 1;
+result = next_result;
+}
+break;
+case CELL_RESELECTION_CR:
+/*
+* Start with CR cell (from idle mode to another cell)
+*/
+rr_data->nc_data[CR_INDEX].c2_used = TRUE;
+max_result                         = CR_INDEX;
+result                             = max_result;
+rr_data->ms_data.c2_tab[CR_INDEX]  = MAX_C2;
+/*
+* Fill with the rest of neighbourcells
+*/
+while ((next_result = att_get_next_highest_rx ())
+NEQ NO_AVAILABLE)
+{
+rr_data->ms_data.c2_tab[next_result] =
+rr_data->ms_data.c2_tab[result] - 1;
+result = next_result;
+}
+break;
+default:
+/*
+* Normal Cell reselection
+*
+* use a corrected C2 value for calculation,
+* because for cell reselection due to C2(NC) > C2(SC) a
+* threshold value must be taken in account if serving
+* and neighbourcell are members of different location areas.
+*/
+att_calculate_c2 (SC_INDEX);
+rr_data->nc_data[SC_INDEX].c2_corr = rr_data->nc_data[SC_INDEX].c2;
+/*
+* Calculate the corrected C2 values for all available neighbourcells.
+*/
+for (i = 0; i < 6; i++)
+{
+if (rr_data->nc_data[i].bcch_status EQ DECODED)
+{
+att_calculate_c2 (i);
+rr_data->nc_data[i].c2_corr = rr_data->nc_data[i].c2;
+/*
+* Take the cell reselection hysterese threshold value in
+* account, if there are different location areas,
+* a cell reselection due to C2(NC) > C2(SC)
+*/
+#ifdef GPRS
+/*
+* check if the location area has changed
+* or the routing area if the scell supports GPRS
+*/
+{
+BOOL la_changed, ra_changed;
+if (!dat_plmn_equal_req (rr_data->nc_data[i].lai.mcc,
+rr_data->nc_data[i].lai.mnc,
+rr_data->nc_data[SC_INDEX].lai.mcc,
+rr_data->nc_data[SC_INDEX].lai.mnc)
+OR
+rr_data->nc_data[i].lai.lac NEQ
+rr_data->nc_data[SC_INDEX].lai.lac)
+la_changed = TRUE;
+else
+la_changed = FALSE;
+if(att_gprs_is_avail())
+{
+if(rr_data->nc_data[i].rac NEQ
+rr_data->nc_data[SC_INDEX].rac)
+ra_changed = TRUE;
+else
+ra_changed = FALSE;
+}
+else
+{
+ra_changed = FALSE;
+}
+if(la_changed OR ra_changed OR rr_data->gprs_data.ready_state)
+#else
+if (!dat_plmn_equal_req (rr_data->nc_data[i].lai.mcc,
+rr_data->nc_data[i].lai.mnc,
+rr_data->nc_data[SC_INDEX].lai.mcc,
+rr_data->nc_data[SC_INDEX].lai.mnc)
+OR
+rr_data->nc_data[i].lai.lac NEQ
+rr_data->nc_data[SC_INDEX].lai.lac)
+#endif
+{
+if ((rr_data->ms_data.imsi_available) AND
+(rr_data->ms_data.rr_service NEQ LIMITED_SERVICE) AND
+(rr_data->sc_data.selection_type EQ CELL_RESELECTION_NC))
+{
+rr_data->nc_data[i].c2_corr -=
+2*rr_data->nc_data[SC_INDEX].select_para.cell_resel_hyst;
+}
+}
+else
+{
+/*
+* in case of a cell reselection occurring within the previous 15 seconds
+* in which case the C2 value for the new cell shall exceed the C2 value
+* of the serving cell by at least 5 dB for a period of 5 seconds
+*/
+if ( IS_TIMER_ACTIVE (T_NO_RESELECT) )
+{
+rr_data->nc_data[i].c2_corr -= 5;
+}
+else
+{
+/* If the C2(NC)=C2(SC), this will get mis-interpreted in the check below
+* c2_corr must be adjusted to make this condition false. The '=' in the '>='
+* condition below only applies when T_NO_RESELECT timer is active and
+* c2_corr has been decremented by 5 (above statement)
+*/
+if( rr_data->nc_data[i].c2_corr EQ rr_data->nc_data[max_result].c2_corr)
+{
+rr_data->nc_data[i].c2_corr -= 1;
+}
+}
+}
+#ifdef GPRS
+}
+#endif
+}
+}
+/*
+* Now find the the highest one
+*/
+for (i = 0; i < 7; i++)
+{
+rr_data->nc_data[i].c2_used = FALSE;
+if (rr_data->nc_data[i].bcch_status EQ DECODED)
+{
+if (rr_data->nc_data[i].c2_corr >=
+rr_data->nc_data[max_result].c2_corr)
+max_result = i;
+}
+}
+result = max_result;
+rr_data->nc_data[result].c2_used = TRUE;
+rr_data->ms_data.c2_tab[result] = MAX_C2;
+/*
+* make the ranking for the other cells.
+*/
+while ((next_result = att_get_next_highest_c2_val ())
+NEQ NO_AVAILABLE)
+{
+rr_data->ms_data.c2_tab[next_result] =
+rr_data->ms_data.c2_tab[result] - 1;
+result = next_result;
+}
+break;
+}
+/*
+* return the index of the highest C2.
+*/
+return max_result;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_get_next_highest_c2_idx|
++--------------------------------------------------------------------+
+PURPOSE : During the ranking of the cell reselection list this
+function searches for the cell with the next highest c2 index.
+*/
+static UBYTE att_get_next_highest_c2_idx (UBYTE      old_index)
+{
+GET_INSTANCE_DATA;
+UBYTE new_index = NO_AVAILABLE;
+UBYTE i;
+TRACE_FUNCTION ("att_get_next_highest_c2_idx()");
+/*
+* depending on the cell reselection type
+*/
+switch (rr_data->sc_data.selection_type)
+{
+case BACK_FROM_DEDICATED:
+case BACK_FROM_DEDICATED_RLF:
+/*
+* check all cells
+*/
+for (i = 0; i <= SC_INDEX; i++)
+{
+/*
+* If cell is available and is not selected yet
+*/
+if (rr_data->nc_data[i].bcch_status NEQ EMPTY AND
+rr_data->ms_data.c2_tab[i] NEQ MAX_C2)
+{
+/*
+* it is the first candidate, then select it
+*/
+if (new_index EQ NO_AVAILABLE)
+new_index = i;
+else
+{
+/*
+* else take the one with the higher C2
+*/
+if (rr_data->ms_data.c2_tab[i] >
+rr_data->ms_data.c2_tab[new_index])
+new_index = i;
+}
+}
+}
+/*
+* If a new cell is found, mark this cell as selected
+* for the next round
+*/
+if (new_index NEQ NO_AVAILABLE)
+rr_data->ms_data.c2_tab[new_index] = MAX_C2;
+break;
+default:
+/*
+* all other cell reselections
+*/
+for (i = 0; i <= SC_INDEX; i++)
+{
+if (rr_data->nc_data[i].bcch_status EQ DECODED)
+{
+if (old_index NEQ i)
+{
+if (new_index EQ NO_AVAILABLE)
+{
+if (rr_data->ms_data.c2_tab[i] <
+rr_data->ms_data.c2_tab[old_index])
+{
+new_index = i;
+}
+}
+else
+{
+if (rr_data->ms_data.c2_tab[i] >
+rr_data->ms_data.c2_tab[new_index] AND
+rr_data->ms_data.c2_tab[i] <
+rr_data->ms_data.c2_tab[old_index])
+{
+new_index = i;
+}
+}
+}
+}
+}
+break;
+}
+return new_index;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_get_next_highest_c2_val|
++--------------------------------------------------------------------+
+PURPOSE : During the ranking of the cell reselection list this
+function searches for the cell with the next highest c2 value.
+*/
+static UBYTE att_get_next_highest_c2_val (void)
+{
+GET_INSTANCE_DATA;
+UBYTE new_index = NO_AVAILABLE;
+UBYTE i;
+TRACE_FUNCTION ("att_get_next_highest_c2_val()");
+/*
+* look for all cells inclusive the serving cell
+*/
+for (i = 0; i < 7; i++)
+{
+/*
+* the cell must have read the system infos to calculate c2.
+*/
+if (rr_data->nc_data[i].bcch_status EQ DECODED)
+{
+/*
+* if not ranked yet
+*/
+if (rr_data->nc_data[i].c2_used EQ FALSE)
+{
+/*
+* if no cell is selected yet,
+* then select this one.
+*/
+if (new_index EQ NO_AVAILABLE)
+{
+new_index = i;
+}
+else
+{
+/*
+* the corrected c2 value must be higher
+* then the selected one.
+*/
+if (rr_data->nc_data[i].c2_corr >
+rr_data->nc_data[new_index].c2_corr)
+{
+new_index = i;
+}
+}
+}
+}
+}
+/*
+* a cell has been selected, then mark this cell
+* to be not selected the next time.
+*/
+if (new_index NEQ NO_AVAILABLE)
+{
+rr_data->nc_data[new_index].c2_used = TRUE;
+}
+/*
+* return the selected cell index
+*/
+return new_index;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_get_next_highest_rx    |
++--------------------------------------------------------------------+
+PURPOSE : During the ranking of the cell reselection list this
+function searches for the cell with the next highest rx value.
+*/
+static UBYTE att_get_next_highest_rx (void)
+{
+GET_INSTANCE_DATA;
+UBYTE new_index = NO_AVAILABLE;
+UBYTE i;
+TRACE_FUNCTION ("att_get_next_highest_rx()");
+/*
+* for all neighbourcells and the serving cell
+*/
+for (i = 0; i < 7; i++)
+{
+/*
+* if something is stored for this index
+* that means at least MS is synchronized.
+*/
+if (rr_data->nc_data[i].bcch_status NEQ EMPTY)
+{
+/*
+* the cell has not been ranked
+*/
+if (rr_data->nc_data[i].c2_used EQ FALSE)
+{
+/*
+* if it is the first cell in this attempt,
+* then select it.
+*/
+if (new_index EQ NO_AVAILABLE)
+{
+new_index = i;
+}
+else
+{
+/*
+* to select the cell it must have a higher
+* fieldstrength
+*/
+if (rr_data->nc_data[i].rxlev >
+rr_data->nc_data[new_index].rxlev)
+{
+new_index = i;
+}
+}
+}
+}
+}
+/*
+* A cell has been selected, then mark it as
+* ranked to avoid selection in the next attempt.
+*/
+if (new_index NEQ NO_AVAILABLE)
+{
+rr_data->nc_data[new_index].c2_used = TRUE;
+}
+/*
+* return the index of the selected cell.
+*/
+return new_index;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_handle_rr_act_req      |
++--------------------------------------------------------------------+
+PURPOSE : MM requests with the primitive RR_ACTIVATE_REQ one of the
+following procedures:
+1. Full Service     - search for a specific PLMN
+2. Limited Service  - search for a cell for limited service
+3. PLMN Search      - request the PLMN available list.
+*/
+GLOBAL void att_handle_rr_act_req (UBYTE              initial_act,
+T_RR_ACTIVATE_REQ *rr_activate_req)
+{
+GET_INSTANCE_DATA;
+UBYTE count = 0;
+TRACE_FUNCTION ("att_handle_rr_act_req()");
+/*
+* stop time control for an ongoing cell reselection
+*/
+TIMERSTOP (T_RESELECT);
+TIMERSTOP (TABORT);
+rr_data->net_lost = FALSE;
+if (initial_act)
+{
+/*
+* read ms data from e2prom
+*/
+att_clear_parallel_search();
+rr_csf_ms_cap ();
+rr_csf_check_rfcap (FALSE);
+rr_csf_read_imei (&rr_data->ms_data.imei);
+rr_data->ms_data.rr_service = NO_SERVICE;   /* set initial to no service */
+}
+for(count=0;count<MAX_MCC_SHIELD;count++)
+{
+TRACE_EVENT_P3 ( "Current software shielded MCC are =%d%d%d",
+rr_data->dyn_config.mcc_shield.mcc[count][0],
+rr_data->dyn_config.mcc_shield.mcc[count][1],
+rr_data->dyn_config.mcc_shield.mcc[count][2]);
+}
+/*
+* store EPLMN list, if available, for use in cell selection/reselection.
+*/
+att_copy_eplmn_list(&rr_activate_req->eq_plmn_list);
+/*
+* store operation mode data
+*/
+rr_data->ms_data.operation_mode =
+(rr_activate_req->op.ts << 7) +
+(rr_activate_req->op.m  << 6) +
+(rr_activate_req->op.sim_ins << 5);
+/*
+* some optimisations must be removed for the FTA campaign.
+*/
+if (dat_test_sim_available() EQ TRUE)
+test_house = TRUE;
+att_set_func (rr_activate_req->op.func);
+/*
+* start cell selection procedure
+*/
+rr_data->ms_data.req_mm_service = att_get_func ();
+TRACE_EVENT_P6 ("RR_ACTIVATE_REQ: %s func op=%s %scurrent=%s rMM=%s RRs=%s",
+initial_act ? "initial" : "",
+_rr_str_FUNC[rr_activate_req->op.func],
+_rr_str_PARFUNC[rr_data->ms_data.parallel_net_plmn_search_type],
+_rr_str_FUNC[rr_data->ms_data.current_plmn_search_type],
+_rr_str_FUNC[rr_data->ms_data.req_mm_service],
+_rr_str_SERVICE[rr_data->ms_data.rr_service]);
+switch (rr_data->ms_data.req_mm_service)
+{
+case FUNC_LIM_SERV_ST_SRCH:
+#ifdef GPRS
+att_set_gprs_indication(rr_activate_req->gprs_indication);
+#endif
+rr_data->c1_offset = C1_OFFSET;
+att_begin_cs(FUNC_LIM_SERV_ST_SRCH);
+break;
+case FUNC_NET_SRCH_BY_MMI:
+/*
+* clear found_channel parameter from previous search
+*/
+switch(GET_STATE(STATE_ATT))
+{
+case ATT_IDLE:
+case ATT_CON_EST:
+/* Cell Selection Improvements-LLD section:4.1.3.9 */
+att_start_cell_selection(MM_ORIGINATED, CS_PARALLEL,FULL_SEARCH_MODE);
+break;
+default:
+att_begin_cs(FUNC_NET_SRCH_BY_MMI);
+break;
+}
+EM_NET_SEARCH_STARTED;
+break;
+case FUNC_PLMN_SRCH:
+/*
+* copy full service parameter from SIM
+*/
+#ifdef GPRS
+att_set_gprs_indication (rr_activate_req->gprs_indication);
+#endif
+if (rr_data->ms_data.rr_service NEQ NO_SERVICE)
+cs_clear_attributes (CHECKED_FLAG, rr_data->nc_data[SC_INDEX].arfcn);
+/* Implements Measure#32: Row 52,53 */
+att_print_mcc_mnc (NOT_PRESENT_16BIT, rr_data->ms_data.plmn.mcc,
+rr_data->ms_data.plmn.mnc, S2I_STRING("old_req_plmn"));
+att_print_mcc_mnc (NOT_PRESENT_16BIT, rr_activate_req->plmn.mcc,
+rr_activate_req->plmn.mnc, S2I_STRING("new_req_plmn"));
+memcpy (&rr_data->ms_data.plmn, &rr_activate_req->plmn, sizeof (T_plmn));
+rr_data->ms_data.cksn = rr_activate_req->cksn;
+memcpy (rr_data->ms_data.new_kc, &rr_activate_req->kcv.kc, KC_STRING_SIZE);
+rr_data->ms_data.access_classes = rr_activate_req->accc;
+#if defined(_SIMULATION_)
+/* Implements Measure#32: Row 52 */
+att_print_mcc_mnc(rr_data->nc_data[SC_INDEX].arfcn,
+rr_data->ms_data.plmn.mcc, rr_data->ms_data.plmn.mnc, S2I_STRING("req"));
+#endif
+/*
+* copy IMSI if available
+*/
+if (rr_activate_req->imsi_struct.id_type EQ TYPE_IMSI)
+{
+memset (&rr_data->ms_data.imsi, 0, sizeof (rr_data->ms_data.imsi));
+rr_data->ms_data.imsi_available = TRUE;
+rr_data->ms_data.imsi.ident_type  = TYPE_IMSI;
+rr_data->ms_data.imsi.v_ident_dig = TRUE;
+rr_data->ms_data.imsi.c_ident_dig =
+att_calculate_digits (rr_activate_req->imsi_struct.id);
+rr_data->ms_data.imsi.odd_even    =
+rr_data->ms_data.imsi.c_ident_dig & 1;
+memcpy (rr_data->ms_data.imsi.ident_dig, rr_activate_req->imsi_struct.id, 16);
+}
+else
+rr_data->ms_data.imsi_available    = FALSE;
+/*
+* copy TMSI if available
+*/
+if (rr_activate_req->tmsi_struct.id_type EQ TYPE_TMSI)
+{
+rr_data->ms_data.tmsi_available = TRUE;
+rr_data->ms_data.tmsi_binary    = rr_activate_req->tmsi_struct.tmsi_dig;
+}
+else
+rr_data->ms_data.tmsi_available    = FALSE;
+if (dat_test_sim_available())
+rr_data->c1_offset = 0;
+else
+rr_data->c1_offset = C1_OFFSET;
+/* CSI-LLD section:4.1.1.11
+* First FUNC_PLMN_SEARCH
+*/
+if(rr_data->cs_data.initial_plmn_search EQ INITIAL_PLMN_SEARCH_NOT_ACTIVE)
+{
+rr_data->cs_data.initial_plmn_search = INITIAL_PLMN_SEARCH_ACTIVE;
+}
+cs_set_bcch_info(&rr_activate_req->bcch_info);
+att_begin_cs(FUNC_PLMN_SRCH);
+EM_PLMN_SRCH_STARTED;
+break;
+case FUNC_ST_PWR_SCAN:
+SET_STATE(STATE_ATT, ATT_CS_INIT );
+att_start_cell_selection(MM_ORIGINATED, CS_NOT_PARALLEL,FULL_SEARCH_MODE);
+break;
+}
+PFREE (rr_activate_req);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_begin_cs               |
++--------------------------------------------------------------------+
+PURPOSE : This function initializes a cell selection or starts BCCH
+reading depending on the ATT state on an RR_ACTIVATE_REQ
+*/
+static void att_begin_cs (UBYTE req_mm_service)
+{
+GET_INSTANCE_DATA;
+if(GET_STATE(STATE_ATT) EQ ATT_CS_INIT )
+{
+SET_STATE(STATE_ATT, ATT_CS1 ); /*Boot Time*/
+/* Boot Time Performance Enhancement:
+* Start the TABORT timer on receiving the second activate_req
+*/
+tstart_tabort(TABORT_VALUE);
+/* Invalidate whitelist if its PLMN ID does not match
+*  with the requested PLMN
+*/
+if((rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH)   AND
+(!dat_plmn_equal_req(rr_data->cs_data.white_list.last_sc_lac.mcc,
+rr_data->cs_data.white_list.last_sc_lac.mnc,
+rr_data->ms_data.plmn.mcc,
+rr_data->ms_data.plmn.mnc)))
+{
+rr_data->cs_data.white_list.region = NOT_PRESENT_8BIT;
+}
+if( srv_check_stored_prim(MPH_POWER_CNF))
+{
+srv_use_stored_prim();
+}
+/*
+* reset the time for net search to finish
+* a PLMN available search during 60 seconds.
+*/
+if( req_mm_service EQ FUNC_NET_SRCH_BY_MMI)
+TIMERSTART(T_PLMN_SEARCH, T_PLMN_SEARCH_VALUE);
+}
+else
+{
+/* Cell Selection Improvements-LLD section:4.1.3.9 */
+att_start_cell_selection(MM_ORIGINATED, CS_NOT_PARALLEL,FULL_SEARCH_MODE);
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_increase_power_on_time |
++--------------------------------------------------------------------+
+PURPOSE : A requirement in GSM 5.08 indicates that the list of
+forbidden location areas must be cleared all 12 hours.
+Therefore this counters power_on_low and power_on_high
+are used. They are triggered by the periodic measurement
+reports in idle mode.
+*/
+GLOBAL void att_increase_power_on_time (USHORT inc)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_increase_power_on_time()");
+/*
+* increment power_on_low
+*/
+rr_data->power_on_low += inc;
+if (rr_data->power_on_low >= 60)
+{
+/* if it is more then 60 seconds,
+* increment power_on_high = minutes
+*/
+rr_data->power_on_low = 0;
+rr_data->power_on_high++;
+if (rr_data->power_on_high >= 720)
+{
+/*
+* after 12 hours = 720 minutes clear all forbidden location area lists
+*/
+rr_data->power_on_low  = 0;
+rr_data->power_on_high = 0;
+att_clear_forb_list (FORBIDDEN_LIST_NORMAL);
+att_clear_forb_list (FORBIDDEN_LIST_ROAMING);
+}
+}
+}
+#if defined (TI_PS_FF_RTD) AND defined (REL99)
+LOCAL void att_init_rtd_data(T_rr_enh_para  *p_cur)
+{
+UBYTE         j,k;
+TRACE_FUNCTION ("att_init_rtd_data");
+for(j = 0;j < MAX_NR_OF_NCELL; j++ )
+{
+p_cur->enh_para.enh_cell_list[j].v_rtd = FALSE;
+for(k = 0;k < MAX_NUM_OF_RTD_VALUES; k++)
+p_cur->enh_para.enh_cell_list[j].rtd[k]= RTD_NOT_AVAILABLE;
+p_cur->enh_para.enh_cell_list[j].c_rtd = 0;
+}/*for*/
+return;
+}
+#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_init_cell_selection    |
++--------------------------------------------------------------------+
+PURPOSE : The function initializes some variables needed for control
+of cell selection and cell reselection.
+*/
+GLOBAL void att_init_cell_selection (UBYTE     selection,
+BOOL      initiator)
+{
+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_FUNCTION ("att_init_cell_selection()");
+TRACE_EVENT_P2 ("init CELL_%sSELECTION %s_ORIGINATED",
+(selection EQ CELL_SELECTION) ? ""   : "RE",
+(initiator EQ MM_ORIGINATED)  ? "MM" : "RR" );
+/*
+* store type of selection and the initiator (RR or MM).
+*/
+rr_data->sc_data.selection_type   = selection;
+rr_data->sc_data.mm_started       = initiator;
+/*
+* clear the list of the found PLMNs
+*/
+rr_data->sc_data.found_entries     = 0;
+/*
+* clear the bitmap indicating whether all system information
+* messages are read.
+*/
+att_init_cr_data();
+#if defined (TI_PS_FF_RTD) AND defined (REL99)
+att_init_rtd_data(p_cur);
+#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */
+/*
+* reset multiband parameter
+*/
+rr_data->ncell_mb                 = 0;
+if (GET_STATE (STATE_ATT) EQ ATT_CS2 OR GET_STATE (STATE_ATT) EQ ATT_CS3)
+{
+rr_data->nc_data[SC_INDEX].lai.mcc[0] = NOT_PRESENT_8BIT;
+rr_data->nc_data[SC_INDEX].lai.mnc[0] = NOT_PRESENT_8BIT;
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_init_gsm_data          |
++--------------------------------------------------------------------+
+PURPOSE : Intialize all gsm specific variables of RR.
+*/
+GLOBAL void att_init_gsm_data (void)
+{
+GET_INSTANCE_DATA;
+SHORT i;
+UBYTE save;
+UBYTE  gprs_ms, cmsp;
+BOOL   ms_configured, cmsp_configured;
+#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_FUNCTION ("att_init_gsm_data()");
+save = rr_data->dyn_config.no_sys_time;
+/* save configured GPRS multislot class */
+ms_configured = rr_data->ms_data.multislot_class_configured;
+gprs_ms = rr_data->ms_data.rf_cap.rf_ms.gprs_ms_class;
+dat_emo_stop ( FALSE );
+/* save configured CMSP bit */
+cmsp_configured = rr_data->ms_data.cmsp_configured;
+cmsp = rr_data->ms_data.rf_cap.cmsp;
+/*
+* clar all RR data with the default value
+*/
+memset (rr_data, 0, sizeof (T_RR_DATA));
+/*
+* some parameters have a different default value
+*/
+rr_data->lup_rxlev    = 63;
+rr_data->dyn_config.no_sys_time  = save;
+rr_data->ms_data.cksn = CKSN_NOT_PRES;
+/* restore configured GPRS multislot class */
+if (ms_configured)
+{
+rr_data->ms_data.multislot_class_configured = TRUE;
+rr_data->ms_data.rf_cap.rf_ms.gprs_ms_class = gprs_ms;
+TRACE_EVENT_P1 ("'gprs_ms_class' configured to a value of %d", gprs_ms);
+}
+/* restore configured CMSP bit */
+if (cmsp_configured)
+{
+rr_data->ms_data.cmsp_configured = TRUE;
+rr_data->ms_data.rf_cap.cmsp= cmsp;
+TRACE_EVENT_P1 ("'cmsp' configured to a value of %d", cmsp);
+}
+#if defined (REL99) AND defined (TI_PS_FF_EMR) AND defined (GPRS)
+rr_data->ms_data.enable_ps_emr = TRUE;
+#endif
+for (i = 0; i < 8; i++)
+{
+rr_data->nc_data[i].lai.mcc[0] = NOT_PRESENT_8BIT;
+rr_data->nc_data[i].lai.mnc[0] = NOT_PRESENT_8BIT;
+}
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+/*Default initializations for EMR*/
+memset (rr_data->sc_data.rep_count, NOT_PRESENT_8BIT, MAX_NEIGHBOURCELLS);
+for_set_default_emr_data(&rr_data->sc_data.emr_data_current);
+for_set_default_emr_data(&rr_data->sc_data.emr_data_temp);
+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;
+rr_data->sc_data.ba_index = NOT_PRESENT_8BIT;
+#endif
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+rr_data->sc_data.cd.band_indicator = NOT_PRESENT_8BIT;
+rr_data->cr_data.cd.band_indicator = NOT_PRESENT_8BIT;
+#endif
+#if defined (TI_PS_FF_RTD) AND defined (REL99)
+att_init_rtd_data(p_cur);
+#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */
+/*
+* clear the forbidden lists
+*/
+att_clear_forb_list (FORBIDDEN_LIST_NORMAL);
+att_clear_forb_list (FORBIDDEN_LIST_ROAMING);
+/*
+* indicate all RR timer as not running
+*/
+memset (rr_data->t_running, 0, sizeof (rr_data->t_running));
+rr_data->t_expire[T3110]         = tim_t3110;
+rr_data->t_expire[T3122]         = tim_t3122;
+rr_data->t_expire[T3126]         = tim_t3126;
+rr_data->t_expire[TREG]          = tim_treg;
+rr_data->t_expire[T_RESELECT]    = tim_treselect;
+rr_data->t_expire[TIM_EXT_MEAS]  = tim_ext_meas;
+rr_data->t_expire[T_NO_RESELECT] = NULL;
+rr_data->t_expire[TCSVALID]      = NULL;
+rr_data->t_expire[TABORT]        = tim_tabort;
+rr_data->t_expire[T_PLMN_SEARCH] = tim_plmn_search_expiry;
+rr_data->t_expire[T_FAST_CS]     = tim_tfast_cs;
+rr_data->t_expire[T_NORMAL_CS]   = tim_tnormal_cs;
+rr_data->net_lost = FALSE;
+#if defined FF_EOTD
+rr_data->t_expire[TAPDU] = tim_apdu;
+#endif /* FF_EOTD */
+rr_data->t_expire[TNNN] = tim_tnnn;
+rr_data->t_expire[T_DEDICATED_MODE] = NULL;
+rr_data->treg_pending = FALSE;
+rr_data->old_serving_cell           = NOT_PRESENT_8BIT;
+rr_data->ms_data.rr_service         = NO_SERVICE;
+/* tch loop "open" */
+rr_data->tch_loop_subch             = NOT_PRESENT_8BIT;
+#if defined FF_EOTD
+rr_data->eotd_req_id                =  NOT_PRESENT_16BIT;
+#endif /* FF_EOTD */
+#ifdef _SIMULATION_
+{
+int i=0;
+for (;i<NUM_OF_RR_TIMERS;i++)
+{
+#ifdef OPTION_TIMER
+/* vsi_t_config is removed in latest GPF */
+#endif
+}
+}
+#endif
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_init_pl_status         |
++--------------------------------------------------------------------+
+PURPOSE : the function clear the cell channel description list
+of the serving cell.
+*/
+GLOBAL void att_init_pl_status (void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_init_pl_status()");
+rr_data->sc_data.cd.v_cell_chan_desc = NO_CONTENT;
+srv_clear_list (&rr_data->sc_data.cd.cell_chan_desc);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_insert_cell_in_data    |
++--------------------------------------------------------------------+
+PURPOSE : During the analysis of an incoming measurement report a
+new cell has been detected. The data of this cell are
+stored in RR.
+*/
+static void att_insert_cell_in_data (T_MPH_MEASUREMENT_IND *report,
+UBYTE                   index)
+{
+GET_INSTANCE_DATA;
+UBYTE       i;
+T_NC_DATA * rrd;
+TRACE_FUNCTION ("att_insert_cell_in_data()");
+/*
+* search for a free entry in the RR storage area.
+*/
+for (i = 0; i < 6; i++)
+if (rr_data->nc_data[i].bcch_status EQ EMPTY)
+break;
+if (i < 6)
+{
+/*
+* RR will ever find a free area, because all
+* cells which are not longer in the measurement
+* report, are removed from the RR storage.
+* The if-condition is only for security reasons
+*
+* Store the data from the measurement report and
+* wait for the system information messages.
+*/
+rrd              = &rr_data->nc_data[i];
+rrd->bsic        = report->ncells.bsic[index];
+rrd->arfcn       = report->ncells.arfcn[index];
+rrd->rxlev       = report->ncells.rx_lev[index];
+rrd->bcch_status = NON_DECODED;
+rrd->avail_time  = 0;
+#ifdef GPRS
+if( rr_data->gprs_data.use_c31 )
+att_insert_c31_cr_data_in_cell(i);
+#endif
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_max                    |
++--------------------------------------------------------------------+
+PURPOSE : The function calculates the maximum from two values a and b.
+*/
+GLOBAL SHORT att_max (SHORT a,
+SHORT b)
+{
+TRACE_FUNCTION ("att_max()");
+return ((a > b) ? a : b);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_plmn_in_found_list     |
++--------------------------------------------------------------------+
+PURPOSE : The function checks whether a PLMN identification is already
+stored in the found list or not during cell selection / cell
+reselection.
+*/
+GLOBAL T_FOUND_ELEMENT *att_plmn_in_found_list (UBYTE *mcc, UBYTE *mnc)
+{
+GET_INSTANCE_DATA;
+T_FOUND_ELEMENT *result = NULL;
+int    i;
+T_FOUND_ELEMENT *found;
+TRACE_FUNCTION ("att_plmn_in_found_list()");
+/*
+* look for all entries, which are already stored
+*/
+/*att_print_mcc_mnc(0, mcc, mnc, "compare with");*/
+found = &rr_data->sc_data.found[0];
+for (i = 0; i < rr_data->sc_data.found_entries; i++, found++)
+{
+/*
+* compare mobile country code and mobile network code.
+*/
+/*att_print_mcc_mnc(found->arfcn, found->plmn.mcc, found->plmn.mnc, "list");*/
+if (dat_plmn_equal_req (mcc, mnc,
+found->plmn.mcc, found->plmn.mnc))
+{
+result = found;
+/*att_print_mcc_mnc(found->arfcn, mcc, mnc, "found");*/
+break;
+}
+}
+/*
+* return the result of the compare.
+*/
+return result;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_save_found_plmn         |
++--------------------------------------------------------------------+
+PURPOSE : The function set all list elements of a found PLMN.
+It marks the element as present (V_PLMN_PRES)
+*/
+GLOBAL void att_save_found_plmn (T_FOUND_ELEMENT *element, UBYTE mcc[], UBYTE mnc[],
+USHORT arfcn, UBYTE rxlev, USHORT lac, UBYTE cell_ok)
+{
+GET_INSTANCE_DATA;
+element->plmn.v_plmn = V_PLMN_PRES;
+memcpy (element->plmn.mcc, mcc, SIZE_MCC);
+memcpy (element->plmn.mnc, mnc, SIZE_MNC);
+element->arfcn   = arfcn;
+element->rxlev   = rxlev;
+element->lac     = lac; /* LOL 02.01.2003: added for EONS support */
+element->cell_ok = cell_ok;
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+if (rr_data->cs_data.region EQ BOTH_REGIONS)
+{
+element->region = srv_get_region_from_std_arfcn (std, arfcn);
+}
+else
+{
+#endif
+element->region  = rr_data->cs_data.region;
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+}
+#endif
+TRACE_EVENT_P9 ("[%u] save new PLMN (%x%x%x %x%x%x) region=%d, entries=%u",
+arfcn, mcc[0], mcc[1], mcc[2], mnc[0], mnc[1], mnc[2],element->region,
+rr_data->sc_data.found_entries+1);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_priority_check         |
++--------------------------------------------------------------------+
+PURPOSE : The function checks the priority of a cell during cell
+selection. It must be differed between first and second
+attempt.
+During the first attempt it will be differed between
+low and high (or normal) priority.
+In the first attempt the cell bar qualifier is used to
+differ between low and high priority. Beside this there
+is an exception defined in GSM 5.08 chapter 9.
+In the second attempt the priority check is ever successful.
+*/
+static BOOL att_priority_check (void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_priority_check()");
+/*
+* During the First Scan second attempt and second scan the priority
+* check is ever successful.
+*/
+if((rr_data->cs_data.scan_mode EQ CS_FIRST_SCAN_SECOND_ATTEMPT) OR
+(rr_data->cs_data.scan_mode EQ CS_SECOND_SCAN))
+{
+return TRUE;
+}
+/*
+* Exception condition handling according GSM 5.08, chapter 9
+*/
+if (dat_hplmn (rr_data->nc_data[CR_INDEX].lai.mcc,
+rr_data->nc_data[CR_INDEX].lai.mnc) AND
+rr_data->cell_test_operation AND
+rr_data->nc_data[CR_INDEX].c2_par.cbq EQ 0 AND
+rr_data->nc_data[CR_INDEX].rach.cell_bar_access EQ 1 AND
+(rr_data->nc_data[CR_INDEX].rach.ac & 0x8000) NEQ 0)
+return TRUE;
+/*
+* Else the cell bar qualifier indicates the priority
+*/
+if (rr_data->nc_data[CR_INDEX].c2_par.cbq)
+return FALSE;
+else
+return TRUE;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_remove_bad_ncell       |
++--------------------------------------------------------------------+
+PURPOSE : During fieldtest sometimes a neighbourcell in the
+measurement report was equal to a neighbourcell. This
+function deletes neighbourcell data if the channel is
+equal to the serving cell.
+*/
+GLOBAL void att_remove_bad_ncell (T_MPH_MEASUREMENT_IND *report)
+{
+GET_INSTANCE_DATA;
+SHORT       i = 0;
+SHORT       j;
+T_ncells    *pncells = &report->ncells;
+TRACE_FUNCTION ("att_remove_bad_ncell()");
+/*
+* for all neighbourcells in the measurement report.
+*/
+while (i < pncells->no_of_ncells)
+{
+/*
+* Do nothing if the channel number is different from
+* the serving cell.
+*/
+if (pncells->arfcn[i] NEQ rr_data->nc_data[SC_INDEX].arfcn)
+i++;
+else
+{
+/*
+* else overwrite this entry by moving the rest one index
+*/
+for (j = i + 1; j < pncells->no_of_ncells; j++)
+{
+pncells->arfcn[j-1]         = pncells->arfcn[j];
+pncells->rx_lev[j-1]        = pncells->rx_lev[j];
+pncells->bsic[j-1]          = pncells->bsic[j];
+pncells->time_alignmt[j-1]  = pncells->time_alignmt[j];
+pncells->frame_offset[j-1]  = pncells->frame_offset[j];
+}
+/*
+* clean the last entry
+*/
+pncells->bsic[j-1]          = 0;
+pncells->arfcn[j-1]         = 0;
+pncells->rx_lev[j-1]        = 0;
+pncells->time_alignmt[j-1]  = 0;
+pncells->frame_offset[j-1]  = 0;
+pncells->no_of_ncells--;
+}
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_allow_lai_in_list      |
++--------------------------------------------------------------------+
+PURPOSE : After a successful location updating request MM informs
+RR about this. If the location area information is stored
+inside of one of the forbidden location area lists this
+information must be updated. In this function, the entry
+is deleted from the given forbidden list.
+*/
+LOCAL void att_allow_lai_in_list (int         list_type,
+const T_plmn     * plmn,
+USHORT             lac)
+{
+GET_INSTANCE_DATA;
+unsigned int i;
+T_loc_area_ident *forb_list;
+if (list_type EQ FORBIDDEN_LIST_NORMAL)
+forb_list = &rr_data->ms_data.forb_lac_list[0];
+else
+forb_list = &rr_data->ms_data.roam_forb_lac_list[0];
+TRACE_FUNCTION ("att_allow_lai_in_list()");
+for (i = 0; i < (MAX_LAI-1); i++)
+{
+if ((lac EQ forb_list[i].lac) AND
+dat_plmn_equal_req (plmn->mcc, plmn->mnc,
+forb_list[i].mcc, forb_list[i].mnc))
+{
+/*
+* if the location area code is stored, overwrite this information
+* and fill the last issue with a default value
+*/
+/* Implements Measure#32: Row 60 */
+att_print_forb_list ( list_type, plmn, lac, i, TRUE);
+memmove (&forb_list[i], &forb_list[i + 1],
+(MAX_LAI - i - 1) * sizeof (T_loc_area_ident));
+forb_list[MAX_LAI - 1].lac    =  NOT_PRESENT_16BIT;
+memset (forb_list[MAX_LAI - 1].mcc, NOT_PRESENT_8BIT, SIZE_MCC);
+memset (forb_list[MAX_LAI - 1].mnc, NOT_PRESENT_8BIT, SIZE_MNC);
+}
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_rem_lai_from_forb_list |
++--------------------------------------------------------------------+
+PURPOSE : After a successful location updating request MM informs
+RR about this. If the location area information is stored
+inside of one of the forbidden location area lists this
+information must be updated. In this function, the entry
+is deleted from all forbidden lists.
+*/
+GLOBAL void att_rem_lai_from_forb_list (const T_plmn * plmn,
+USHORT         lac)
+{
+TRACE_FUNCTION ("att_rem_lai_from_forb_list()");
+att_allow_lai_in_list (FORBIDDEN_LIST_NORMAL, plmn, lac);
+att_allow_lai_in_list (FORBIDDEN_LIST_ROAMING, plmn, lac);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_search_cell            |
++--------------------------------------------------------------------+
+PURPOSE : This function searches for a cell for cell reselection.
+*/
+static void att_search_cell (void)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_search_cell()");
+#if defined(_SIMULATION_)
+TRACE_SELECTION_TYPE (rr_data->sc_data.selection_type);
+#endif /* _SIMULATION_ */
+/*
+* depending on the cell reselection mode.
+*/
+switch (rr_data->sc_data.selection_type)
+{
+case BACK_FROM_DEDICATED:
+case BACK_FROM_DEDICATED_RLF:
+/*
+* back from dedicated use the fieldstrength of the
+* cells as the criterion
+*/
+rr_data->reselect_index = att_get_highest_c2_index ();
+att_select_cell_dedicated ();
+break;
+case CELL_RESELECTION:
+case CELL_RESELECTION_NC:
+#ifdef GPRS
+if( rr_data->gprs_data.use_c31 )
+{
+SHORT i;
+TRACE_EVENT ("c32 used in att_search_cell");
+for( i = 0; i < 6; i++ )
+rr_data->nc_data[i].c32_used = FALSE;
+rr_data->ms_data.old_cell_tried = FALSE;
+rr_data->reselect_index = att_get_next_best_c32_index (FALSE);
+/*
+* if no suitable cell is available
+* try the old cell again.
+*/
+if (! att_check_cell_c31 ())
+att_try_old_cell ();
+break;
+}
+#endif
+/*lint -fallthrough*/
+default:
+/*
+* cell reselection in idle mode, use the cell
+* reselection criterion C2.
+*/
+rr_data->ms_data.old_cell_tried = FALSE;
+rr_data->reselect_index = att_get_highest_c2_index ();
+/*
+* if no suitable cell is available
+* try the old cell again.
+*/
+if (! att_check_cell ())
+att_try_old_cell ();
+break;
+}
+EM_FMM_RESEL_START_IND;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_set_pl_in_idle_mode    |
++--------------------------------------------------------------------+
+PURPOSE : The function configures the idle mode at the end of
+cell selection and cell reselection.
+*/
+GLOBAL void att_set_pl_in_idle_mode (void)
+{
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+GET_INSTANCE_DATA;
+#endif
+TRACE_FUNCTION ("att_set_pl_in_idle_mode()");
+/* Update std value depending upon the band indicator value */
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+att_update_std_band_indicator (rr_data->sc_data.cd.band_indicator);
+#endif
+/*
+* forward classmark information to layer 1 for random access procedure
+*/
+att_build_classmark_req ();
+/*
+* configure the idle mode (paging group etc.)
+*/
+att_build_idle_req (SC_INDEX, MODE_CELL_SELECTION);
+/*
+* configure the CBCH channel
+*/
+#ifdef REL99
+att_config_cbch ();
+#else
+att_build_cbch();
+#endif
+/*
+* configure the neighbourcell list
+*/
+att_code_mph_ncell_req (SC_INDEX);
+/*
+* store the neighbourcell information in PCM and the SIM card.
+*/
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_set_sys_info_read      |
++--------------------------------------------------------------------+
+PURPOSE : The decision whether all system information messages are
+read during cell selection / cell reselection is done with
+this function. The variable sys_info_read is organized as
+a bitmap. Each system information message belongs to one
+bit of the bitmap.
+*/
+GLOBAL void att_set_sys_info_read (USHORT mess_bit, UBYTE index)
+{
+GET_INSTANCE_DATA;
+T_CELL_DATA * cd;
+USHORT si;
+TRACE_FUNCTION ("att_set_sys_info_read()");
+/*
+* set pointer to data
+*/
+if (index EQ SC_INDEX)
+cd = &rr_data->sc_data.cd;
+else if (index EQ CR_INDEX)
+cd = &rr_data->cr_data.cd;
+else
+{
+TRACE_EVENT ("unexpected index in att_set_sys_info_read()");
+return;
+}
+/*
+* set the bit of the bitmap according to the message type.
+*/
+cd->sys_info_read |= mess_bit;
+#if !defined(NTRACE)
+si = cd->sys_info_read;
+/*  if (GET_STATE (STATE_ATT) EQ ATT_CS2) comment out just for debugging */
+{
+if (si EQ ALL_SYS_INFO_READ)
+{
+TRACE_EVENT ("SI complete");
+}
+else
+{
+#ifdef GPRS
+TRACE_EVENT_P9 ( "await SI%s%s%s%s%s%s%s (%x) for %s",
+(si & SYS_INFO_1_READ   ) ? "" : " 1"   ,
+(si & SYS_INFO_2_READ   ) ? "" : " 2"   ,
+(si & SYS_INFO_2BIS_READ) ? "" : " 2bis",
+(si & SYS_INFO_3_READ   ) ? "" : " 3"   ,
+(si & SYS_INFO_4_READ   ) ? "" : " 4"   ,
+(si & SYS_INFO_2TER_READ) ? "" : " 2ter",
+(si & SYS_INFO_13_READ  ) ? "" : " 13",
+si,
+(index EQ SC_INDEX      ) ? "SC_INDEX" : "CR_INDEX");
+#else
+TRACE_EVENT_P8 ( "await SI%s%s%s%s%s%s (%x) for %s",
+(si & SYS_INFO_1_READ   ) ? "" : " 1"   ,
+(si & SYS_INFO_2_READ   ) ? "" : " 2"   ,
+(si & SYS_INFO_2BIS_READ) ? "" : " 2bis",
+(si & SYS_INFO_3_READ   ) ? "" : " 3"   ,
+(si & SYS_INFO_4_READ   ) ? "" : " 4"   ,
+(si & SYS_INFO_2TER_READ) ? "" : " 2ter",
+si,
+(index EQ SC_INDEX      ) ? "SC_INDEX" : "CR_INDEX");
+#endif
+}
+}
+#endif  /* !NTRACE */
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_start_cell_reselection |
++--------------------------------------------------------------------+
+PURPOSE : The function is called at the beginning of a cell
+reselection.
+*/
+GLOBAL void att_start_cell_reselection (UBYTE     mode)
+{
+GET_INSTANCE_DATA;
+#ifdef GPRS
+T_GPRS_DATA  *gprs_data = &rr_data->gprs_data;
+#endif
+TRACE_FUNCTION ("att_start_cell_reselection()");
+if( mode EQ BACK_FROM_DEDICATED_RLF)
+{
+/*
+* Allow 20 seconds for call re-establishment
+* In case of data link failure
+*/
+tstart_tabort(2 * TABORT_VALUE);
+}
+else
+{
+tstart_tabort(TABORT_VALUE);
+}
+#ifdef GPRS
+if ( gprs_data->rrgrr_ext_meas_req NEQ NULL )
+{
+/*
+* Save the request to perform Cell Reselection.
+* Then stop the Ext Meas procedure.
+* At the very end of the Ext Meas continue with CR.
+*/
+gprs_data->ext_meas_ctrl |= EXT_MEAS_START_CR;
+rr_data->sc_data.selection_type = mode;
+att_rrgrr_ext_meas_stop_req(NULL);
+return;
+}
+#endif
+/*
+* intialise some variables
+*/
+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);
+/*
+* MM has initiated GPRS Activation. While waiting for SI13 a local reselection
+* is triggered in RR because of a better neighbour cell. Since MM initiated GPRS
+* is pending; RR should respond by RR_ACTIVATE_CNF and not by RR_ACTIVATE_IND.
+*/
+#ifdef GPRS
+if ( GET_STATE(STATE_GPRS) EQ GPRS_ACTIVATED AND
+rr_data->sc_data.mm_started EQ MM_ORIGINATED AND
+rr_data->sc_data.selection_type EQ CELL_RESELECTION_ON_GPRS_ACT)
+{
+att_init_cell_selection (mode, MM_ORIGINATED);
+}
+else
+#endif
+{
+att_init_cell_selection (mode, RR_ORIGINATED);
+}
+dat_att_null();
+#ifdef GPRS
+gprs_init_data_cr();
+#endif
+/*
+* stop any reselection related timer.
+*/
+if (rr_data->sc_data.selection_type EQ BACK_FROM_DEDICATED_RLF)
+{
+/*
+* according GSM 5.08, chapter 6.7.2 call re-establishment
+* shall be finished latest during 20 seconds (=2*normal
+* cell reselection time).
+*/
+TIMERSTART (T_RESELECT, 2*TRESELECT_VALUE);
+}
+else
+{
+TIMERSTART (T_RESELECT, TRESELECT_VALUE);
+}
+/*
+* depending on the cell reselection type
+*/
+switch (rr_data->sc_data.selection_type)
+{
+case CELL_RESELECTION:
+case CELL_RESELECTION_RACH:
+/*
+* exclude serving cell for five seconds
+*/
+set_tnnn (SC_INDEX, 5*ONE_SEC);
+break;
+case BACK_FROM_DEDICATED:
+case BACK_FROM_DEDICATED_RLF:
+/*
+* remove serving cell from neighbourcell results
+*/
+att_remove_bad_ncell (&rr_data->ms_data.measurement_report);
+att_build_back_from_dedicated ();
+break;
+case CELL_RESELECTION_CR:
+/*
+* check cell to get back in full service
+*/
+break;
+}
+EM_CELL_RESEL_STARTED;
+/*
+* find a suitable cell for cell reselection
+*/
+att_search_cell ();
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_start_cell_selection   |
++--------------------------------------------------------------------+
+PURPOSE : The function is called at the beginning of a cell selection.
+*/
+GLOBAL void att_start_cell_selection (BOOL originator, BOOL parallel,
+U8 search_mode)
+{
+GET_INSTANCE_DATA;
+TRACE_FUNCTION ("att_start_cell_selection()");
+TRACE_EVENT_P2 ("START %sparallel CELL SELECTION %s_ORIGINATED",
+parallel?"":"not ",
+originator?"MM":"RR");
+tstart_tabort(TABORT_VALUE);
+rr_data->net_lost = FALSE;
+rr_data->cs_data.black_list_search_pending = FALSE;
+EM_CELL_SELECTION;
+/* Set the current search mode */
+CS_SET_CURRENT_SEARCH_MODE(search_mode);
+/*
+* initialize some variables
+*/
+/* found channel handling */
+if(originator EQ MM_ORIGINATED)
+{
+if(rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH)
+cs_get_channel_from_found_list ();
+else
+cs_clear_channel_from_found_list();
+}
+att_init_cell_selection (CELL_SELECTION, originator);
+/* Reset scan mode */
+rr_data->cs_data.scan_mode = CS_FIRST_SCAN_FIRST_ATTEMPT;
+/*
+* init process and start power measurements
+*/
+#ifdef GPRS
+rr_data->gprs_data.use_c31 = FALSE;
+#endif
+if(!parallel)
+{
+memset (rr_data->nc_data, 0, 6*sizeof (T_NC_DATA));
+cs_set_null ();
+}
+cs_set_all ();
+/*
+* Why should a RR caused cell selection forego the helpfully information
+* of the neighbor cell description of the last serving cell to speed up
+* the selection of the new cell?
+* But it is appropriate only for non PARALLEL search!
+* Therefore we collect first the (at cs_data) stored cell discription
+* and merge it into a channel list (cs_data.bcch_info). As second step
+* we use this list to level up the priority of the matching cells after
+* the scan execution (cs_mph_power_cnf).
+*/
+#ifdef GPRS
+if(att_gprs_is_avail() AND !parallel)
+gprs_init_data_cr();
+#endif
+/* Cell Selection Improvements-LLD section:4.1.3.4.1.3
+* This function updates the new search mode based on the current
+* dynamic search mode configuration
+*/
+att_check_dynamic_search_mode_config();
+cs_start_scan ();
+if(!parallel)
+{
+if( GET_STATE(STATE_ATT) EQ ATT_CS_INIT )
+{
+att_code_rr_act_cnf();
+}
+else
+{
+SET_STATE (STATE_ATT, ATT_CS1);
+}
+dat_att_null();
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_try_old_cell           |
++--------------------------------------------------------------------+
+PURPOSE : if no suitable cell has been found during cell reselection
+the old serving cell is tried.
+*/
+static void att_try_old_cell (void)
+{
+GET_INSTANCE_DATA;
+UBYTE search_mode =0;
+TRACE_FUNCTION ("att_try_old_cell()");
+/*
+* check whether the old serving cell is possible
+*/
+if (rr_data->nc_data[SC_INDEX].arfcn EQ rr_data->nc_data[CR_INDEX].arfcn)
+rr_data->ms_data.old_cell_tried = TRUE;
+/* Implements RR Clone findings #8 */
+if (! att_cell_barred_status_cr_no_cr (SC_INDEX) AND
+! is_tnnn (SC_INDEX) AND
+rr_data->nc_data[SC_INDEX].c1 > 0 AND
+rr_data->ms_data.old_cell_tried EQ FALSE)
+{
+if (rr_data->sc_data.selection_type EQ CELL_RESELECTION_RACH)
+{
+/*
+* go direct back to the old cell after random access failure
+*/
+att_return_to_idle();
+}
+else
+{
+/*
+* serving cell is possible. Configure layer 1
+* to start cell reselection
+*/
+rr_data->ms_data.old_cell_tried = TRUE;
+att_start_cr_in_pl(SC_INDEX);
+}
+}
+else
+{
+/*
+* old serving cell is not possible. Then start
+* cell selection for recovering.
+*/
+/* Refer Cell Selection Improvements-LLD section:4.1.3.9  */
+if(rr_data->ms_data.rr_service EQ FULL_SERVICE)
+{
+/* RR is in full service and in ATT_IDLE state. Cell reselection started
+* and failed. Start Fast search
+*/
+search_mode = FAST_SEARCH_MODE;
+}
+else
+{
+if((rr_data->ms_data.rr_service EQ LIMITED_SERVICE) AND
+(rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH))
+{
+/* RR is in Limited service and in ATT_IDLE state. The requested service
+* by MM is Full service. Cell reselection started and failed.
+* Obtain new search mode based on the current search mode.
+*/
+search_mode = cs_get_new_search_mode();
+}
+else
+{
+/* RR is in Limited service and in ATT_IDLE state. The requested service
+* by MM is Limited service. Cell reselection started and failed.
+* Start Normal search
+*/
+search_mode = NORMAL_SEARCH_MODE;
+}
+}
+/* XY:n don't inform GRR , and don't call start_cs_gprs  !!!
+* we can go here after sending a CR_IND but not being in CS3
+*/
+att_start_cell_selection (RR_ORIGINATED, CS_NOT_PARALLEL,search_mode);
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_mph_identity_req       |
++--------------------------------------------------------------------+
+PURPOSE : Forwards the mobile identities to Layer 1.
+*/
+GLOBAL void att_mph_identity_req (void)
+{
+GET_INSTANCE_DATA;
+PALLOC (mph_identity_req, MPH_IDENTITY_REQ);
+TRACE_FUNCTION ("att_mph_identity_req()");
+memset (mph_identity_req, 0, sizeof (T_MPH_IDENTITY_REQ));
+switch (rr_data->ms_data.rr_service)
+{
+case FULL_SERVICE:
+/*
+* identities are only forwarded in full service
+*/
+if (rr_data->ms_data.imsi_available)
+{
+/*
+* fill in the international mobile identity, if available
+*/
+mph_identity_req->mid.len_imsi = rr_data->ms_data.imsi.c_ident_dig;
+memcpy (mph_identity_req->mid.imsi, rr_data->ms_data.imsi.ident_dig,
+mph_identity_req->mid.len_imsi);
+}
+if (rr_data->ms_data.tmsi_available)
+{
+/*
+* fill in the temporary mobile identity, if available
+*/
+mph_identity_req->mid.v_tmsi = TRUE;
+mph_identity_req->mid.tmsi   = rr_data->ms_data.tmsi_binary;
+}
+break;
+}
+#ifdef GPRS
+if (rr_data->gprs_data.gprs_indic)
+{
+att_add_ptmsi (mph_identity_req);
+{
+PALLOC(ms_id, RRGRR_MS_ID_IND);
+ms_id->tmsi = rr_data->ms_data.tmsi_binary;
+PSENDX(GRR, ms_id);
+}
+}
+#endif
+/*
+* send the valid identities to layer 1.
+*/
+PSENDX (PL, mph_identity_req);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)     MODULE  : RR_ATT                       |
+| STATE   : code              ROUTINE : att_start_registration_timer |
++--------------------------------------------------------------------+
+PURPOSE : Checks whether to start, to stop or to let run the
+registration timer depending on the requested service by MM
+and the actual RR service.
+*/
+/*
+* Time tables with increasing periods depending on the registration attempt
+*/
+#ifdef TI_PS_FF_AT_P_CMD_CTREG
+/* Initialize the table with default values
+* All the values are in secs / 10 format
+* Ex: T_TEN_SEC = 10 Sec / 10
+*/
+const UBYTE no_service_mode_time [25] =
+{      T_TEN_SEC, T_TEN_SEC, T_TEN_SEC, T_TEN_SEC,
+T_TWENTY_SEC, T_TWENTY_SEC, T_TWENTY_SEC, T_TWENTY_SEC, T_TWENTY_SEC,
+T_THIRTY_SEC, T_THIRTY_SEC, T_THIRTY_SEC, T_THIRTY_SEC, T_THIRTY_SEC,
+T_SIXTY_SEC, T_SIXTY_SEC, T_SIXTY_SEC, T_SIXTY_SEC, T_SIXTY_SEC,
+T_TWO_MIN, T_TWO_MIN, T_TWO_MIN, T_TWO_MIN, T_TWO_MIN,
+T_SIX_MIN
+};
+#else
+const T_TIME no_service_mode_time [25] =
+{      TEN_SEC,    TEN_SEC,    TEN_SEC,    TEN_SEC,
+TWENTY_SEC, TWENTY_SEC, TWENTY_SEC, TWENTY_SEC, TWENTY_SEC,
+THIRTY_SEC, THIRTY_SEC, THIRTY_SEC, THIRTY_SEC, THIRTY_SEC,
+SIXTY_SEC,  SIXTY_SEC,  SIXTY_SEC,  SIXTY_SEC,  SIXTY_SEC,
+TWO_MIN,    TWO_MIN,    TWO_MIN,    TWO_MIN,    TWO_MIN,
+SIX_MIN
+};
+#endif /* TI_PS_FF_AT_P_CMD_CTREG */
+#ifdef TI_PS_FF_AT_P_CMD_CTREG
+const UBYTE lim_service_mode_time [25] =
+{      T_TEN_SEC, T_TEN_SEC, T_TEN_SEC, T_TEN_SEC,
+T_TWENTY_SEC, T_TWENTY_SEC, T_TWENTY_SEC, T_TWENTY_SEC, T_TWENTY_SEC,
+T_THIRTY_SEC, T_THIRTY_SEC, T_THIRTY_SEC, T_THIRTY_SEC, T_THIRTY_SEC,
+T_SIXTY_SEC, T_SIXTY_SEC, T_SIXTY_SEC, T_SIXTY_SEC, T_SIXTY_SEC,
+T_TWO_MIN, T_TWO_MIN, T_TWO_MIN, T_TWO_MIN, T_TWO_MIN,
+T_SIX_MIN
+};
+#else
+const T_TIME lim_service_mode_time [25] =
+{      TEN_SEC,    TEN_SEC,    TEN_SEC,    TEN_SEC,
+TWENTY_SEC, TWENTY_SEC, TWENTY_SEC, TWENTY_SEC, TWENTY_SEC,
+THIRTY_SEC, THIRTY_SEC, THIRTY_SEC, THIRTY_SEC, THIRTY_SEC,
+SIXTY_SEC,  SIXTY_SEC,  SIXTY_SEC,  SIXTY_SEC,  SIXTY_SEC,
+TWO_MIN,    TWO_MIN,    TWO_MIN,    TWO_MIN,    TWO_MIN,
+SIX_MIN
+};
+#endif /* TI_PS_FF_AT_P_CMD_CTREG */
+#ifdef TI_PS_FF_AT_P_CMD_CTREG
+/*
+* Function used to convert the user given TREG timer values in secs to ms
+* Ex: User value   TREG value
+*         0           1  Sec
+*         1           10 Sec
+*         2           20 Sec etc
+*/
+T_TIME cast2T_Time(UBYTE tab_val)
+{
+return (tab_val)? tab_val*10000: 1000;
+}
+#endif /* TI_PS_FF_AT_P_CMD_CTREG */
+GLOBAL void att_start_registration_timer (void)
+{
+GET_INSTANCE_DATA;
+T_TIME status = 0L;
+#ifdef TI_PS_FF_AT_P_CMD_CTREG
+BOOL ret;
+UBYTE tab_val;
+#endif /* TI_PS_FF_AT_P_CMD_CTREG */
+TRACE_FUNCTION ("att_start_registration_timer()");
+/*
+* is there a TREG expiry which couldn't be handled yet
+* so restart TREG with a short time
+*/
+if (rr_data->treg_pending)
+{
+TIMERSTART (TREG, ONE_SEC);
+rr_data->treg_pending = FALSE;
+return;
+}
+/*
+* preparation to avoid the change of a running TREG
+*/
+TIMER_STATUS (rr_handle, TREG, &status);
+/*
+* depending on the current service of RR
+*/
+switch (rr_data->ms_data.rr_service)
+{
+case NO_SERVICE:
+/*
+* RR has no service, so it will try to come back
+* to limited or full service after timeout
+* set fieldstrength to 0.
+*/
+#ifdef FF_PS_RSSI
+RX_SetValue ( 0, RX_QUAL_UNAVAILABLE, RX_ACCE_UNAVAILABLE);
+#else
+RX_SetValue (0);
+#endif
+cs_set_all ();
+if (status)
+return;
+if (!IS_TIMER_ACTIVE(TREG))
+{
+#ifdef TI_PS_HCOMM_CHANGE
+PSIGNAL (_hCommDL, DL_TRACE_REQ, NULL);
+#else
+PSIGNAL (hCommDL, DL_TRACE_REQ, NULL);
+#endif /* TI_PS_HCOMM_CHANGE */
+}
+#ifdef TI_PS_FF_AT_P_CMD_CTREG
+ret = cl_shrd_get_treg(RR_MOD_NOSERVICE_TIME,
+rr_data->ms_data.reg_counter,
+&tab_val);
+TRACE_EVENT_P1("Reading of the TREG value is %s",ret? "SUCCESS":"FAILURE");
+if (!ret)
+{
+/* Use default on failure */
+tab_val = no_service_mode_time [rr_data->ms_data.reg_counter];
+}
+if (rr_data->ms_data.reg_counter < 24)
+{
+rr_data->ms_data.reg_counter++;
+}
+TIMERSTART (TREG, cast2T_Time(tab_val));
+#else
+if (rr_data->ms_data.reg_counter < 24)
+{
+TIMERSTART (TREG, no_service_mode_time [rr_data->ms_data.reg_counter++]);
+}
+else
+{
+TIMERSTART (TREG, no_service_mode_time [24]);
+}
+#endif /* TI_PS_FF_AT_P_CMD_CTREG */
+break;
+case LIMITED_SERVICE:
+/*
+* RR has limited service
+* The timer is only started if MM has requested Full Service.
+*/
+if (rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH)
+{
+cs_set_all ();
+if (status)
+return;
+#ifdef TI_PS_FF_AT_P_CMD_CTREG
+ret = cl_shrd_get_treg(RR_MOD_LIMSERVICE_TIME,
+rr_data->ms_data.reg_counter,
+&tab_val);
+TRACE_EVENT_P1("Reading of the TREG value is %s",ret? "SUCCESS":"FAILURE");
+if (!ret)
+{
+/* Use default on failure */
+tab_val = lim_service_mode_time [rr_data->ms_data.reg_counter];
+}
+if (rr_data->ms_data.reg_counter < 24)
+{
+rr_data->ms_data.reg_counter++;
+}
+TIMERSTART (TREG, cast2T_Time(tab_val));
+#else
+if (rr_data->ms_data.reg_counter < 24)
+{
+TIMERSTART (TREG, lim_service_mode_time [rr_data->ms_data.reg_counter++]);
+}
+else
+{
+TIMERSTART (TREG, lim_service_mode_time [24]);
+}
+#endif /* TI_PS_FF_AT_P_CMD_CTREG */
+}
+break;
+case FULL_SERVICE:
+/*
+* In full service mode, the timer is not started.
+*/
+TIMERSTOP (TREG);
+break;
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_set_func               |
++--------------------------------------------------------------------+
+PURPOSE : Sets the requested MM functionality. If MM requests a
+PLMN available search (FUNC_NET_SRCH_BY_MMI) the current
+search request must be stored until the PLMN available
+search has been finished.
+*/
+GLOBAL void att_set_func (UBYTE func)
+{
+GET_INSTANCE_DATA;
+#if !defined(NTRACE)
+TRACE_EVENT_P5 ("att_set_func: func op=%s %scurrent=%s, service:rMM=%s RRs=%s",
+_rr_str_FUNC[func],
+_rr_str_PARFUNC[rr_data->ms_data.parallel_net_plmn_search_type],
+_rr_str_FUNC[rr_data->ms_data.current_plmn_search_type],
+_rr_str_FUNC[rr_data->ms_data.req_mm_service],
+_rr_str_SERVICE[rr_data->ms_data.rr_service]);
+if ((func EQ FUNC_NET_SRCH_BY_MMI) AND
+(func NEQ rr_data->ms_data.parallel_net_plmn_search_type))
+{
+TRACE_EVENT_P2 ("att_set_func: NEW %scurrent=%s",
+_rr_str_PARFUNC[func],
+_rr_str_FUNC[rr_data->ms_data.current_plmn_search_type]);
+}
+else if ((func NEQ rr_data->ms_data.current_plmn_search_type) OR
+(rr_data->ms_data.parallel_net_plmn_search_type NEQ 0))
+{
+TRACE_EVENT_P1 ("att_set_func: NEW current=%s", _rr_str_FUNC[func]);
+}
+#endif  /* !NTRACE */
+switch (func)
+{
+case FUNC_LIM_SERV_ST_SRCH:
+case FUNC_PLMN_SRCH:
+case FUNC_ST_PWR_SCAN:
+rr_data->ms_data.parallel_net_plmn_search_type = 0;
+rr_data->ms_data.current_plmn_search_type  = func;
+break;
+case FUNC_NET_SRCH_BY_MMI:
+rr_data->ms_data.parallel_net_plmn_search_type = func;
+break;
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_get_func               |
++--------------------------------------------------------------------+
+PURPOSE : Requests the MM functionality. If a temporary PLMN available
+search request is active (temp_func = FUNC_NET_SRCH_BY_MMI)
+this function is returned, else the last one which was
+requested by MMI.
+*/
+static UBYTE att_get_func (void)
+{
+GET_INSTANCE_DATA;
+switch (rr_data->ms_data.parallel_net_plmn_search_type)
+{
+case FUNC_NET_SRCH_BY_MMI:
+return (rr_data->ms_data.parallel_net_plmn_search_type);
+default:
+return (rr_data->ms_data.current_plmn_search_type);
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_clear_parallel_search  |
++--------------------------------------------------------------------+
+PURPOSE : Resets the temporary requested MM functionality.
+*/
+static void att_clear_parallel_search (void)
+{
+GET_INSTANCE_DATA;
+rr_data->ms_data.parallel_net_plmn_search_type = 0;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_init_cr_data           |
++--------------------------------------------------------------------+
+PURPOSE : The CR index contains the whole data of the new cell.
+It is cleared prior to cell reselection
+*/
+GLOBAL void att_init_cr_data (void)
+{
+GET_INSTANCE_DATA;
+/*
+* clear sys info bitmap
+*/
+rr_data->cr_data.cd.sys_info_read    = NO_SYS_INFO_READ;
+/*
+* reset BA list from SI 2, 2Bis and 2Ter
+*/
+memset(&rr_data->cr_data.cr_white_list, 0 , sizeof(T_CR_WHITE_LIST));
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_copy_cr_data           |
++--------------------------------------------------------------------+
+PURPOSE : The CR index contains the whole data of the new cell.
+It shall replace the content of the old serving cell.
+The content of the old serving cell is copied to the
+column of the new cell (in the neighbour cell area). The
+status is set to DECODED.
+*/
+GLOBAL void att_copy_cr_data (void)
+{
+GET_INSTANCE_DATA;
+UBYTE i;
+/*
+* look for all neighbourcells.
+*/
+for (i=0;i<6;i++)
+if (rr_data->nc_data[CR_INDEX].arfcn EQ rr_data->nc_data[i].arfcn)
+{
+/*
+* channel found, then update neighbourcell
+*/
+memcpy (&rr_data->nc_data[i], &rr_data->nc_data[SC_INDEX],
+sizeof (T_NC_DATA));
+rr_data->nc_data[i].bcch_status = DECODED;
+rr_data->old_serving_cell       = i;
+break;
+}
+/*
+* update SC_INDEX column.
+*/
+memcpy (&rr_data->nc_data[SC_INDEX], &rr_data->nc_data[CR_INDEX],
+sizeof (T_NC_DATA));
+/*
+* implementation problem: must be set for RR originated search
+* e.g. limited to full service
+*/
+rr_data->nc_data[SC_INDEX].bcch_status = DECODED;
+/*
+* fit classmarks depend on the values of 'std' and the new serving cell
+*/
+rr_csf_fit_capability ();
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+/*When there's no SI-2quater in the reselected cell and in the current
+cell the reporting is of enhanced type, we can no longer use these
+enhanced parameters. */
+/*Reset EMR data and indicate the same to GRR and ALR*/
+if ( rr_data->sc_data.emr_data_current.is_data_valid EQ TRUE )
+{
+memset (rr_data->sc_data.rep_count, NOT_PRESENT_8BIT, MAX_NEIGHBOURCELLS);
+for_set_default_emr_data(&rr_data->sc_data.emr_data_current);
+for_send_enh_para(&rr_data->sc_data.emr_data_current);
+}
+#endif
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : att_copy_eplmn_list        |
++--------------------------------------------------------------------+
+PURPOSE : This function copies the EPLMN list to rr_data global area
+*/
+GLOBAL void att_copy_eplmn_list (T_eq_plmn_list *eq_plmn_list)
+{
+GET_INSTANCE_DATA;
+UBYTE i;
+/* List only copied if valid and PLMNs greater than 1 (HPLMN included)
+else EPLMN list is marked as invalid */
+if(eq_plmn_list->v_eq_plmn)
+{
+for(i=0;i<RR_EPLMNLIST_SIZE;i++)
+{
+T_plmn local_copy;
+rr_unpack_plmn(&local_copy, eq_plmn_list->eq_plmn, i);
+rr_data->ms_data.eq_plmn_list[i] = local_copy;  /*Struct copy*/
+}
+rr_data->ms_data.v_eq_plmn = TRUE;
+}
+else
+{
+rr_data->ms_data.v_eq_plmn = FALSE;
+memset(&rr_data->ms_data.eq_plmn_list, 0xFF, SIZE_EPLMN);
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)       MODULE  : RR_ATT                     |
+| STATE   : code                ROUTINE : rr_unpack_plmn             |
++--------------------------------------------------------------------+
+PURPOSE : Unpacks a PLMN from compressed form to uncompressed form.
+*/
+LOCAL void rr_unpack_plmn (T_plmn *plmn, const UBYTE *packed, USHORT index)
+{
+index *= UBYTES_PER_PLMN;
+plmn->mcc[0] = packed[index] & 0x0f;
+plmn->mcc[1] = packed[index] >> 4;
+index++;
+plmn->mcc[2] = packed[index] & 0x0f;
+plmn->mnc[2] = packed[index] >> 4;
+index++;
+plmn->mnc[0] = packed[index] & 0x0f;
+plmn->mnc[1] = packed[index] >> 4;
+index++;
+if ((plmn->mcc[0] & 0x0F) EQ 0x0F)
+plmn->v_plmn = V_PLMN_NOT_PRES;
+else
+plmn->v_plmn = V_PLMN_PRES;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : RR_ATT                        |
+| STATE   : code             ROUTINE : att_build_back_from_dedicated |
++--------------------------------------------------------------------+
+PURPOSE : A list is build containing the serving cell followed by
+the synchronized neighbourcells in decreasing fieldstrenght.
+In case of call re-establishment the serving cell is not used.
+The list controls the cell reselection after dedicated mode.
+*/
+static void att_build_back_from_dedicated (void)
+{
+GET_INSTANCE_DATA;
+UBYTE       i;
+T_NC_DATA * rrd;
+/*
+* update the neighbourcell entries
+*/
+for (i=0;i<6;i++)
+{
+/*
+* clear the data for this neighbourcell
+*/
+memset (&rr_data->nc_data[i], 0, sizeof (T_NC_DATA));
+rrd = &rr_data->nc_data[i];
+if (rr_data->ms_data.measurement_report.ncells.no_of_ncells > i)
+{
+/*
+* if neighbourcell data is available in the measurement report
+* copy the data.
+*/
+rrd->bsic        = rr_data->ms_data.measurement_report.ncells.bsic[i];
+rrd->arfcn       = rr_data->ms_data.measurement_report.ncells.arfcn[i];
+rrd->rxlev       = rr_data->ms_data.measurement_report.ncells.rx_lev[i];
+rrd->bcch_status = NON_DECODED;
+rrd->avail_time  = 0;
+}
+else
+rrd->bcch_status = EMPTY;
+}
+/*
+* update the serving cell fieldstrength data.
+* It is important to make distinction between rxlev of the traffic channel and of the BCCH channel
+* for C1 and C2 calculations
+*/
+rr_data->nc_data[SC_INDEX].rxlev = rr_data->ms_data.measurement_report.bcch_rxlev_of_sc;
+/*
+* implementation problem: must be set to have a defined status.
+*/
+rr_data->nc_data[SC_INDEX].bcch_status = DECODED;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : RR_ATT                        |
+| STATE   : code             ROUTINE : att_check_network             |
++--------------------------------------------------------------------+
+PURPOSE : This function is a SW shield for the FTA campaign. Due
+to bad cables and public networks with high fieldstrength
+some FTA testcases (especially MM testcases with limited
+services) fails on our Anite System. To avoid this these
+function is a SW shield, excluding all german networks.
+This function must be adapted for other countries if needed.
+*/
+GLOBAL UBYTE att_check_network (T_loc_area_ident * lai)
+{
+GET_INSTANCE_DATA;
+UBYTE count=0;
+/*
+* if a test SIM is inserted and "Software Shielding" is enabled then check mcc value with stored mcc value
+* (durig dynamic configuration command shield).The network exists in the list updated using dynamic
+* configauration command SHIELD then return FALSE.
+*/
+if ((test_house EQ TRUE) AND (rr_data->dyn_config.mcc_shield.enabled EQ TRUE))
+{
+for(count=0;count< MAX_MCC_SHIELD;count++)
+{
+if (lai->mcc[0] EQ rr_data->dyn_config.mcc_shield.mcc[count][0] AND
+lai->mcc[1] EQ rr_data->dyn_config.mcc_shield.mcc[count][1] AND
+lai->mcc[2] EQ rr_data->dyn_config.mcc_shield.mcc[count][2] )
+{
+TRACE_EVENT ("att_check_network() returns FALSE");
+return FALSE;
+}
+}
+}
+return TRUE;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)      MODULE  : RR_ATT                      |
+| STATE   : code               ROUTINE : att_return_to_idle          |
++--------------------------------------------------------------------+
+PURPOSE : The functions configures PL for idle mode without going
+through a complete cell reselection.
+*/
+GLOBAL void att_return_to_idle (void)
+{
+GET_INSTANCE_DATA;
+TIMERSTOP (T_RESELECT);
+/*
+* configure layer 1
+*/
+#ifdef GPRS
+if(att_gprs_cell_has_pbcch())
+{
+att_gprs_stop_pl();
+}
+else
+{
+#endif
+att_build_idle_req (SC_INDEX, MODE_CELL_SELECTION);
+#ifdef GPRS
+}
+#endif
+SET_STATE (STATE_ATT, ATT_IDLE);
+dat_att_cell_selected();
+srv_use_stored_prim ();
+#ifdef REL99
+#ifdef GPRS
+/* RR is returning to idle mode. If cbch info was received
+* during transfer mode, send it now.
+*/
+if(rr_data->gprs_data.cbch_info_rxvd_in_ptm)
+{
+rr_data->gprs_data.cbch_info_rxvd_in_ptm = FALSE;
+att_config_cbch();
+}
+#endif
+#endif
+/*
+* Start registration timer if needed
+*/
+att_start_registration_timer ();
+rr_data->bcch_error       = 0;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)      MODULE  : RR_ATT                      |
+| STATE   : code               ROUTINE : att_notify_stop_plmn_search |
++--------------------------------------------------------------------+
+PURPOSE : Network search has to be aborted in lower layer so that
+NC monitoring can be resumed when going back to idle mode.
+*/
+GLOBAL void att_notify_stop_plmn_search (UBYTE deactivate_pl)
+{
+GET_INSTANCE_DATA;
+UCHAR  state = GET_STATE (STATE_ATT);
+TRACE_EVENT_P1("att_notify_stop_plmn_search - %x", rr_data->start_cell_reselection);
+if ( rr_data->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI                              OR
+(rr_data->ms_data.rr_service EQ LIMITED_SERVICE AND !rr_data->start_cell_reselection) OR
+(rr_data->ms_data.rr_service EQ NO_SERVICE AND !rr_data->start_cell_reselection)      OR
+state EQ ATT_CS1                                                                     OR
+state EQ ATT_CS2                                                                     OR
+CS_GET_CURRENT_SEARCH_MODE EQ BLACK_LIST_SEARCH_MODE)
+{
+PALLOC (mph_sync_req, MPH_SYNC_REQ);
+if(deactivate_pl)
+mph_sync_req->cs = CS_STOP_PLMN_SEARCH_AND_DEACTIVATE;
+else
+mph_sync_req->cs = CS_STOP_PLMN_SEARCH;
+PSENDX (PL, mph_sync_req);
+rr_data->start_cell_reselection = TRUE;
+TRACE_EVENT_P1("Start_cell_reselection %d",rr_data->start_cell_reselection);
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)      MODULE  : RR_ATT                      |
+| STATE   : code               ROUTINE : att_reset_old_lai                  |
++--------------------------------------------------------------------+
+PURPOSE : This function is used to reset old lai parameters
+*/
+GLOBAL void att_reset_old_lai_rac ()
+{
+GET_INSTANCE_DATA;
+rr_data->old_cell_id = NOT_PRESENT_16BIT;
+#ifdef GPRS
+rr_data->old_rac     = NOT_PRESENT_8BIT;
+#endif
+memset (&rr_data->old_lai, NOT_PRESENT_8BIT, sizeof(T_loc_area_ident));
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)      MODULE  : RR_ATT                      |
+| STATE   : code               ROUTINE : att_copy_old_lai_rac        |
++--------------------------------------------------------------------+
+PURPOSE : This function is used to copy old lai and rac parameters
+*/
+GLOBAL void att_copy_old_lai_rac (U8 index)
+{
+GET_INSTANCE_DATA;
+memcpy (&rr_data->old_lai, &rr_data->nc_data[index].lai,
+sizeof(T_loc_area_ident));
+rr_data->old_cell_id =  rr_data->nc_data[index].cell_id;
+#ifdef GPRS
+rr_data->old_rac     =  rr_data->nc_data[index].rac;
+#endif
+}
+/*
++--------------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)      MODULE  : RR_ATT                                  |
+| STATE   : code               ROUTINE : att_check_dynamic_search_mode_config    |
++--------------------------------------------------------------------------------+
+PURPOSE : This function updates the new search mode based on the current
+dynamic search mode configuration
+CSI-LLD section:4.1.3.4.1.8
+*/
+GLOBAL void att_check_dynamic_search_mode_config(void)
+{
+GET_INSTANCE_DATA;
+U8 new_mode = CS_GET_CURRENT_SEARCH_MODE;
+TRACE_FUNCTION("att_check_dynamic_search_mode_config()");
+TRACE_EVENT_P1("New Search Mode : %d", CS_GET_CURRENT_SEARCH_MODE);
+if(new_mode EQ FAST_SEARCH_MODE AND !rr_data->dyn_config.tfast_cs_val)
+{
+/* If Fast search is disabled, use Normal search */
+new_mode = NORMAL_SEARCH_MODE;
+TRACE_EVENT("Fast Search is disabled");
+}
+if(new_mode EQ NORMAL_SEARCH_MODE AND !rr_data->dyn_config.tnormal_cs_val)
+{
+/* If Normal search is disabled, use Full search */
+new_mode = FULL_SEARCH_MODE;
+TRACE_EVENT("Normal Search is disabled");
+}
+if(new_mode NEQ CS_GET_CURRENT_SEARCH_MODE)
+TRACE_EVENT_P1("Allowed Search Mode : %d", new_mode);
+CS_SET_CURRENT_SEARCH_MODE(new_mode);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)      MODULE  : RR_ATT                      |
+| STATE   : code               ROUTINE : att_get_txpwr_max_cch       |
++--------------------------------------------------------------------+
+PURPOSE : This function is used to calculate the MAX power used on CCH
+*/
+LOCAL UBYTE att_get_txpwr_max_cch (UBYTE index)
+{
+GET_INSTANCE_DATA;
+UBYTE max_cch = rr_data->nc_data[index].select_para.ms_txpwr_max_cch;
+UBYTE dbm_value;
+TRACE_FUNCTION("att_get_txpwr_max_cch()");
+switch(std)
+{
+case STD_1800:
+case STD_DUAL_EGSM:
+case STD_DUAL:
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+case STD_850_1800:
+case STD_850_900_1800:
+#endif
+/* Ref 04.18 Section 10.5.2.35
+* Rest Octets IE includes parameters which are used by the mobile station
+* for cell selection and reselection purposes. It may also include the
+* POWER OFFSET parameter used by DCS 1800 Class 3 MS.
+*/
+if (INRANGE(LOW_CHANNEL_1800,rr_data->nc_data[index].arfcn,HIGH_CHANNEL_1800))
+{
+/* DCS 1800 */
+if (att_get_power() EQ 0x02 AND
+rr_data->nc_data[index].c2_par.power_off_ind)
+{
+TRACE_EVENT(" IDLE_REQ :DCS_PCLASS3");
+/* Class 3 & Valid Power offset */
+dbm_value = p_control_dcs[max_cch] +
+(rr_data->nc_data[index].c2_par.power_off << 1);
+/* dbm value is more than 36 return the max cch power level as 29 */
+if(dbm_value > 36) return 29;
+if(dbm_value NEQ 0)
+{
+/* map the calculated dbm value to power control value
+* Specification : 0505  Section : 4.1.1
+*/
+max_cch =  (30 - dbm_value) >= 0 ?
+(30 - dbm_value) >> 1 :
+(31 - ((dbm_value - 32) >> 1));
+}
+} /* if att_get_power */
+} /* if INRANGE */
+break;
+default :
+break;
+} /* switch std */
+return max_cch;
+}
+#if !defined(NTRACE)
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)      MODULE  : RR_ATT                      |
+| STATE   : code               ROUTINE : att_print_mcc_mnc           |
++--------------------------------------------------------------------+
+PURPOSE : Outputs to trace mcc and mnc arrays
+*/
+/* Implements Measure#32: Row 52,53, 124 & 125 */
+GLOBAL void att_print_mcc_mnc (USHORT arfcn, UBYTE *mcc, UBYTE *mnc, T_S2I_STRING titel)
+{
+TRACE_EVENT_P8 ( "[%d] MCC=%x%x%x MNC=%x%x%x %s",
+((int)arfcn), mcc[0], mcc[1], mcc[2], mnc[0], mnc[1], mnc[2],
+S2I_STRING(titel)); /* A valid string is expected */
+}
+LOCAL void att_print_selection_type (UBYTE selection_type)
+{
+GET_INSTANCE_DATA;
+switch (rr_data->sc_data.selection_type)
+{
+case CELL_SELECTION:
+TRACE_EVENT_WIN ("selection_type=CELL_SELECTION");
+break;
+case CELL_RESELECTION:
+TRACE_EVENT_WIN ("selection_type=CELL_RESELECTION");
+break;
+case BACK_FROM_DEDICATED:
+TRACE_EVENT_WIN ("selection_type=BACK_FROM_DEDICATED");
+break;
+case CELL_RESELECTION_NC:
+TRACE_EVENT_WIN ("selection_type=CELL_RESELECTION_NC");
+break;
+case BACK_FROM_DEDICATED_RLF:
+TRACE_EVENT_WIN ("selection_type=BACK_FROM_DEDICATED_RLF");
+break;
+case CELL_RESELECTION_RACH:
+TRACE_EVENT_WIN ("selection_type=CELL_RESELECTION_RACH");
+break;
+case CELL_RESELECTION_CR:
+TRACE_EVENT_WIN ("selection_type=CELL_RESELECTION_CR");
+break;
+}
+}
+/* Implements Measure#32: Row 36, 39 and 40 */
+LOCAL void att_print_op (T_op *op, T_S2I_STRING titel)
+{
+T_S2I_STRING sim, mode;
+if (op->v_op)
+{
+sim = op->sim_ins ? (op->ts ? S2I_STRING("TEST") : S2I_STRING("NORMAL")) : S2I_STRING("NO");
+mode = op->m ? S2I_STRING("MAN") : S2I_STRING("AUTO");
+TRACE_EVENT_P5 ("%s: SIM=%s mode=%s func=%s service=%s",
+S2I_STRING(titel),
+S2I_STRING(sim),
+S2I_STRING(mode),
+S2I_STRING(_rr_str_FUNC[op->func]),
+S2I_STRING(_rr_str_SERVICE[op->service]));
+}
+}
+#endif /* !NTRACE */
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)      MODULE  : RR_ATT                      |
+| STATE   : code               ROUTINE : att_set_rr_service_info     |
++--------------------------------------------------------------------+
+PURPOSE : Copies the RR related service info(service,PLMN,lac,cell_id)
+*/
+GLOBAL void att_set_rr_service_info (void)
+{
+GET_INSTANCE_DATA;
+T_LOC_INFO loc_info;
+loc_info.service_mode = rr_data->ms_data.rr_service;
+if(rr_data->ms_data.rr_service NEQ NO_SERVICE)
+{
+loc_info.lac = rr_data->nc_data[SC_INDEX].lai.lac;
+loc_info.cell_id = rr_data->nc_data[SC_INDEX].cell_id;
+memcpy (loc_info.mcc,rr_data->nc_data[SC_INDEX].lai.mcc,SIZE_MCC);
+memcpy (loc_info.mnc,rr_data->nc_data[SC_INDEX].lai.mnc,SIZE_MNC);
+}
+cl_shrd_set_loc(&loc_info);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)      MODULE  : RR_ATT                      |
+| STATE   : code               ROUTINE : att_set_tim_advance_info    |
++--------------------------------------------------------------------+
+PURPOSE : Copies the Timing Advance info.ME_STATUS is presently using
+only ME_STATUS_IDLE which is not as per the standard.We need to assign
+me_status correctly.
+*/
+GLOBAL void att_set_tim_advance_info (void)
+{
+GET_INSTANCE_DATA;
+T_TIM_ADV tim_adv;
+tim_adv.me_status = ME_STATUS_IDLE;
+tim_adv.tm_adv = rr_data->sc_data.new_ta;
+cl_shrd_set_tim_adv(&tim_adv);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)      MODULE  : RR_ATT                      |
+| STATE   : code               ROUTINE : att_func1_opt     |
++--------------------------------------------------------------------+
+PURPOSE : This function sets the system information read flag of the passed
+si_type . It saves the neighbour cell list or Merges it to previously
+saved list if available.
+*/
+LOCAL void att_copy_sys_info_2bis_2ter_par(UBYTE index,T_SI_TYPE si_type,
+T_LIST  *new_2_bis_ter_list,  BUF_neigh_cell_desc  *neigh_cell_desc,
+UBYTE   indicate_changes)
+{
+GET_INSTANCE_DATA;
+T_LIST  new_list;
+T_CELL_DATA   *cd;
+BOOL          modified = FALSE;
+USHORT cur_si_type_read; /*Current SI type*/
+USHORT oth_si_type_read; /*The other SI type in this function */
+USHORT oth_si_to_clean;/*The other SI to clean in this function*/
+UCHAR si_type_msg; /* 2BIS or 2TER type msg*/
+TRACE_FUNCTION("att_copy_sys_info_2bis_2ter_par()");
+switch (index)
+{
+case SC_INDEX:
+case CR_INDEX:
+if(si_type EQ SI_TYPE_2BIS)
+{
+cur_si_type_read = SYS_INFO_2BIS_READ;
+oth_si_type_read = SYS_INFO_2TER_READ;
+oth_si_to_clean = IND_SI_2TER;
+si_type_msg = SYS_INFO_2bis_MSG;
+}
+else
+{
+cur_si_type_read = SYS_INFO_2TER_READ;
+oth_si_type_read = SYS_INFO_2BIS_READ;
+oth_si_to_clean = IND_SI_2BIS;
+si_type_msg = SYS_INFO_2ter_MSG;
+}
+if (index EQ SC_INDEX)
+{
+cd = &rr_data->sc_data.cd;
+if ((cd->sys_info_read & cur_si_type_read) EQ cur_si_type_read)
+{
+srv_copy_list (&cd->ncell_list, new_2_bis_ter_list, sizeof (T_LIST));
+att_clean_buf ((USHORT)(IND_SI_2 | oth_si_to_clean));
+cd->sys_info_read &= ~(SYS_INFO_2_READ | oth_si_type_read);
+att_check_2ter_read (index);
+}
+else
+srv_merge_list (&cd->ncell_list, new_2_bis_ter_list);
+modified = TRUE;
+#ifdef GPRS
+rr_data->gprs_data.ba_bcch_modified= FALSE;
+#endif
+}
+else
+{
+cd = &rr_data->cr_data.cd;
+/*
+* merge 2bis list with the old neighbour cell list
+*/
+srv_copy_list (&new_list, &cd->ncell_list,
+sizeof (T_LIST));
+srv_merge_list (&new_list, new_2_bis_ter_list);
+if (srv_compare_list (&cd->ncell_list, &new_list) EQ FALSE)
+{
+/*
+* both lists are different
+*/
+srv_copy_list (&cd->ncell_list, &new_list, sizeof (T_LIST));
+modified = TRUE;
+}
+}
+/* CSI-LLD section:4.1.1.11
+* This function Updates the black list with the BA list received in si2bis/ter
+*/
+cs_remove_BA_MA_from_black_list(rr_data->cs_data.region,&cd->ncell_list);
+dat_store_neigh_cell_desc (si_type_msg, index,
+neigh_cell_desc, &cd->ncell_list);
+/*
+* Indicate that the system information type 2bis message has been read.
+*/
+att_set_sys_info_read (cur_si_type_read, index);
+/*
+* forward new neighbour cell list to layer 1
+* if changes shall be indicated
+*/
+if (modified AND indicate_changes)
+{
+att_code_mph_ncell_req (index);
+}
+break;
+}
+}
+#if defined (REL99) && defined (TI_PS_FF_EMR)
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)      MODULE  : RR_ATT                      |
+| STATE   : code               ROUTINE : attf_send_enh_para_to_alr                  |
++--------------------------------------------------------------------+
+PURPOSE : This function formats and sends a primitive with enhanced measurement
+parameters.
+*/
+GLOBAL void attf_send_enh_para_to_alr(UBYTE rep_type, T_enh_para_struct *p_src)
+{
+PALLOC(p_enh, MPH_ENHPARA_UPDATE_REQ);
+TRACE_FUNCTION ("attf_send_enh_para_to_alr");
+p_enh->rep_type = rep_type;
+p_enh->enh_para = *p_src;
+PSENDX(PL,p_enh);
+return;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)      MODULE  : RR_ATT                      |
+| STATE   : code               ROUTINE : att_print_mcc_mnc           |
++--------------------------------------------------------------------+
+PURPOSE : Outputs to trace mcc and mnc arrays
+*/
+LOCAL void att_check_for_si5ter_and_enhpara (UBYTE old_index)
+{
+GET_INSTANCE_DATA;
+T_rr_enh_para *p_temp = &rr_data->sc_data.emr_data_temp;
+T_rr_enh_para *p_cur = &rr_data->sc_data.emr_data_current;
+/*we have complete BA(SACCH) list (with or without SI-5 ter ) : we will
+discard any enhanced para that are present in previous state which are
+aligned to BA(BCCH)*/
+if (rr_data->sc_data.enh_para_status EQ ENH_PARA_IDLE )
+{
+/*The enhanced parameters available are from different state, reset them*/
+for_set_default_emr_data(p_temp);
+memset (rr_data->sc_data.rep_count, NOT_PRESENT_8BIT, MAX_NEIGHBOURCELLS);
+for_set_default_emr_data(p_cur);
+for_send_enh_para(p_cur);
+rr_data->sc_data.enh_para_status = ENH_PARA_INVALID_STATE;
+return;
+}
+if(old_index EQ rr_data->sc_data.ba_index)
+{
+/*Updation of enhanced cell list for EMR : we can receive
+SI-5ter and MI in any random order*/
+if ( (rr_data->sc_data.emr_data_temp.is_data_valid EQ TRUE) AND
+rr_data->sc_data.emr_data_temp.ba2bsic_map_pending )
+for_att_update_ba2bsic_mapping(&rr_data->sc_data.emr_data_temp);
+else if ( (rr_data->sc_data.emr_data_current.is_data_valid EQ TRUE) AND
+rr_data->sc_data.emr_data_current.ba2bsic_map_pending )
+for_att_update_ba2bsic_mapping(&rr_data->sc_data.emr_data_current);
+/*When BA(SACCH) is ready, check whether there are enhanced parameters in
+temp that needs attention*/
+if ( (rr_data->sc_data.enh_para_status EQ ENH_PARA_DEDICATED) AND
+(p_temp->is_data_valid EQ TRUE ) )
+{
+/* This means enhanced parameters were received before BA list - so update
+the enhanced list with actual ARFCN and update current EMR data*/
+if ( for_update_enh_cell_list( rr_data->act_ncell_list) EQ TRUE)
+{
+*p_cur = *p_temp;
+if (p_cur->ba2bsic_map_pending EQ 0) /*send parameters when there are no more mapping pending*/
+for_send_enh_para(p_cur);
+}
+/*Reset temporary, irrespective of whether updation is succesful or not*/
+for_set_default_emr_data(p_temp);
+}
+else if (p_cur->is_data_valid EQ TRUE AND p_cur->ba2bsic_map_pending EQ 0)
+for_send_enh_para(p_cur);
+}
+else
+{
+for_set_default_emr_data(p_temp);
+for_set_default_emr_data(p_cur);
+for_send_enh_para(p_cur);
+}
+return;
+}
+#endif
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : RR_ATT                        |
+| STATE   : code             ROUTINE : att_update_std_band_indicator |
++--------------------------------------------------------------------+
+PURPOSE : This function updates the std value depending upon the band
+indicator value received in the SI1 or SI6 message. band
+indicator will be ignored when received in the DCS 1800 or
+PCS 1900 frequency band. Depending upon the std value region
+will be updated.
+*/
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+GLOBAL void att_update_std_band_indicator (UBYTE band_indicator)
+{
+GET_INSTANCE_DATA;
+UBYTE band_index = cs_get_band_index (rr_data->nc_data[SC_INDEX].arfcn);
+UBYTE freq_bands;
+UBYTE new_region = NOT_PRESENT_8BIT;
+UBYTE mscr = 0;     /* variable to hold msc release version*/
+TRACE_FUNCTION ("att_update_std_band_indicator");
+get_msc_release_version(&mscr);
+TRACE_EVENT_P1("mscr (MSC release) version : 0x%X", mscr);
+if (mscr NEQ MSCR_99)
+{
+TRACE_EVENT ("band indicator received when MSC release is not R99");
+TRACE_ERROR ("band indicator received when MSC release is not R99");
+return;
+}
+if ((band_index EQ B_DCS_1800) OR (band_index EQ B_PCS_1900))
+{
+TRACE_EVENT_P2 ("band indicator %x received in band %x", band_indicator, band_index);
+return;
+}
+rr_csf_get_freq_bands (&freq_bands);
+if (band_indicator NEQ NOT_PRESENT_8BIT)
+{
+if (band_indicator EQ BAND_IND_1800)
+{
+if ((freq_bands & BAND_DCS_1800) EQ BAND_DCS_1800)
+{
+if (std EQ STD_DUAL_US)
+{
+std = STD_850_1800;
+new_region = BOTH_REGIONS;
+}
+else if (std EQ STD_850_900_1900)
+{
+std = STD_850_900_1800;
+new_region = BOTH_REGIONS;
+}
+}
+}
+else
+{
+if ((freq_bands & BAND_PCS_1900) EQ BAND_PCS_1900)
+{
+if (std EQ STD_DUAL_EGSM)
+{
+std = STD_900_1900;
+new_region = BOTH_REGIONS;
+}
+else if (std EQ STD_850_900_1800)
+{
+std = STD_850_900_1900;
+new_region = BOTH_REGIONS;
+}
+}
+}
+TRACE_EVENT_P1 ("Updated std to %x", std);
+}
+if (new_region NEQ NOT_PRESENT_8BIT)
+rr_data->cs_data.region = new_region;
+}
+#endif
+#endif  /* RR_ATTF_C */

FreeCalypso > hg > fc-selenite

comparison src/g23m-gsm/rr/rr_attf.c @ 1:d393cd9bb723