diff gsm-fw/g23m-gsm/rr/rr_attf.c @ 673:2f7df7a314f8

gsm-fw/g23m-gsm subtree: initial import from LoCosto source
author Michael Spacefalcon <msokolov@ivan.Harhan.ORG>
date Sun, 28 Sep 2014 23:20:04 +0000
parents
children a6f45d948d22
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gsm-fw/g23m-gsm/rr/rr_attf.c	Sun Sep 28 23:20:04 2014 +0000
@@ -0,0 +1,9502 @@
+/*
++-----------------------------------------------------------------------------
+|  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 */