fc-selenite: src/g23m-gprs/grr/grr

comparison src/g23m-gprs/grr/grr_csf.c @ 1:d393cd9bb723

src/g23m-*: initial import from Magnetite

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

comparison

equal deleted inserted replaced

-:b6a5e36de839
+:d393cd9bb723
+/*
++-----------------------------------------------------------------------------
+|  Project :  GPRS (8441)
+|  Modul   :  GRR
++-----------------------------------------------------------------------------
+|  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 implements local functions for service CS of
+|             entity GRR.
++-----------------------------------------------------------------------------
+*/
+#ifndef GRR_CSF_C
+#define GRR_CSF_C
+#endif
+#define ENTITY_GRR
+/*==== INCLUDES =============================================================*/
+#include <stdio.h>
+#include <string.h>
+#include "typedefs.h"    /* to get Condat data types */
+#include "vsi.h"        /* to get a lot of macros */
+#include "macdef.h"
+#include "gprs.h"
+#include "gsm.h"        /* to get a lot of macros */
+#include "ccdapi.h"     /* to get CCD API */
+#include "cnf_grr.h"    /* to get cnf-definitions */
+#include "mon_grr.h"    /* to get mon-definitions */
+#include "prim.h"       /* to get the definitions of used SAP and directions */
+#include "message.h"
+#include "grr.h"        /* to get the global entity definitions */
+#include "grr_f.h"
+#include "grr_ctrls.h"
+#include "grr_meass.h"
+#include "grr_csf.h"
+#include "grr_em.h"     /*for Engineering mode*/
+/*==== CONST ================================================================*/
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/*
+* Bitmasks
+*/
+#define BIT_0                     0x01
+#define BIT_1                     0x02
+#define BIT_2                     0x04
+#define BIT_3                     0x08
+#define BIT_4                     0x10
+#define BIT_5                     0x20
+#define BIT_6                     0x40
+#define BIT_7                     0x80
+#endif
+T_NC_DATA* nc_data = NULL; /* pointer to neighbour cell data */
+const SHORT p_res_off[32]       = { -52,  /*  0 -> -52 dB */
+-48,  /*  1 -> -48 dB */
+-44,  /*  2 -> -44 dB */
+-40,  /*  3 -> -40 dB */
+-36,  /*  4 -> -36 dB */
+-32,  /*  5 -> -32 dB */
+-28,  /*  6 -> -28 dB */
+-24,  /*  7 -> -24 dB */
+-20,  /*  8 -> -20 dB */
+-16,  /*  9 -> -16 dB */
+-12,  /* 10 -> -12 dB */
+-10,  /* 11 -> -10 dB */
+- 8,  /* 12 -> - 8 dB */
+- 6,  /* 13 -> - 6 dB */
+- 4,  /* 14 -> - 4 dB */
+- 2,  /* 15 -> - 2 dB */
+0,  /* 16 ->   0 dB */
+2,  /* 17 ->   2 dB */
+4,  /* 18 ->   4 dB */
+6,  /* 19 ->   6 dB */
+8,  /* 20 ->   8 dB */
+10,  /* 21 ->  10 dB */
+12,  /* 22 ->  12 dB */
+16,  /* 23 ->  16 dB */
+20,  /* 24 ->  20 dB */
+24,  /* 25 ->  24 dB */
+28,  /* 26 ->  28 dB */
+32,  /* 27 ->  32 dB */
+36,  /* 28 ->  36 dB */
+40,  /* 29 ->  40 dB */
+44,  /* 30 ->  44 dB */
+48   /* 31 ->  48 dB */
+};
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/*
+PURPOSE : checks whether the network colour code (ncc) is member
+of the ncc permitted field.
+*/
+LOCAL const UBYTE ncc_bit_mask[8] =
+{
+BIT_0, BIT_1, BIT_2, BIT_3,
+BIT_4, BIT_5, BIT_6, BIT_7
+};
+#endif
+#define NC_MODE_LEN        1
+#define NC_RXLEV_SCELL_LEN 6
+#define NC_IF_SCELL_LEN    6
+#define NC_NUM_OF_MEAS_LEN 3
+#define NC_FREQ_N_LEN      6
+#define NC_BSIC_N_LEN      6
+#define NC_RXLEV_N_LEN     6
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+#define BA_USED_LEN        1
+#define BA_USED_3G_LEN     1
+#define PSI3_CM_LEN        2
+#define PMO_USED_LEN       1
+#endif
+#define GET_NC_RPT_PRD(x)  ((0x01<<(x))*480) /* multiple of 480 ms */
+#define CS_PERIOD_1_SEC    217               /* 1 second defined by           */
+/* multiplies of TDMA frames     */
+#define MAX_SYNC_FAILED_CNT 3
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+#define INRANGE(min, x, max)  ((unsigned)(x-min) <= (max-min))
+#endif
+#ifdef _TARGET_
+#define MIN_RXLEV_FOR_SIX_STRGST 4 /* minimum RXLEV value of neighbour cells  */
+/* which shall be considered for cell      */
+/* re-selection decision                   */
+#endif /* #ifdef _TARGET_ */
+#define RXLEV_ACRCY        1000
+#define RXLEV_MAX_NBR      ((T_RXLEV_DATA_NBR)(~((T_RXLEV_DATA_NBR)0)))
+#define RXLEV_AVG_INVALID  0xFF
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+#define CHECK_DUAL_BANDS (std EQ STD_DUAL        OR std EQ STD_DUAL_EGSM    OR \
+std EQ STD_DUAL_US     OR std EQ STD_850_1800     OR \
+std EQ STD_900_1900    OR std EQ STD_850_900_1800 OR \
+std EQ STD_850_900_1900)
+#endif
+/*==== GLOBAL VARS ===========================================================*/
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+EXTERN BOOL use_ba_gprs;
+#endif
+/*==== LOCAL VARS ===========================================================*/
+/*==== PRIVATE FUNCTIONS ====================================================*/
+LOCAL void   cs_trace_nc_mval_lst ( void                           );
+LOCAL void   cs_init_nc_mval      ( T_NC_MVAL       *mval          );
+LOCAL void   cs_reorg_nc_mval_lst ( void                           );
+LOCAL BOOL   cs_build_meas_rpt    ( T_U_MEAS_REPORT *u_meas_report );
+LOCAL BOOL cs_process_serving_cell_data
+( UBYTE *rxlev_scell, UBYTE *v_i_scell,
+UBYTE *i_scell, UBYTE *used_bits,
+BOOL *rsc_avail, BOOL *isc_avail );
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+LOCAL void cs_build_enh_sorted_strng_arfcn_list
+(T_ENH_STRNG_ARFCN_LIST *f_bin   );
+/*
+LOCAL UBYTE cs_sort_arfcns_into_bins
+( T_ENH_STRNG_ARFCN_LIST *p_s_bin,
+T_ENH_STRNG_ARFCN_LIST *p_m_bin,
+T_ENH_STRNG_ARFCN_LIST *p_r_bin);*/
+LOCAL UBYTE cs_sort_arfcns_into_bins
+( T_ENH_STRNG_ARFCN_LIST *p_s_bin,
+T_ENH_STRNG_ARFCN_LIST *p_r_bin);
+LOCAL void cs_sort_store_in_desc_order_rxlev
+( T_ENH_STRNG_ARFCN_LIST *p_bin,
+T_ENH_STRNG_ARFCN_LIST *p_f_bin);
+LOCAL BOOL cs_build_enh_meas_rpt( T_U_ENHNC_MEAS_REPORT *u_enh_meas_report );
+LOCAL BOOL cs_fill_nc_enh_meas_results
+(T_nc_meas_rep_enh *nc_meas_rep_enh);
+LOCAL void cs_form_enh_cell_list (void                            );
+LOCAL void cs_form_ba_bcch_enh_cell_list
+(void                            );
+LOCAL void cs_nc_sort_and_update_emr_info
+(void                            );
+LOCAL void cs_nc_sort_cells_into_bins
+(T_ENH_BIN *p_sbin,T_ENH_BIN *p_mbin,
+T_ENH_BIN *p_rbin               );
+LOCAL void cs_nc_sort_and_store_meas_results
+(T_ENH_BIN *p_bin, UBYTE nbr_rpt );
+LOCAL void cs_nc_update_rest_bin
+(T_ENH_BIN *p_rbin,
+T_ENH_BIN *p_bin, UBYTE nbr_rpt );
+LOCAL UBYTE cs_get_band_index_for_emr
+(USHORT arfcn);
+LOCAL UBYTE cs_nc_scale_rxlev    (void);
+#endif
+LOCAL void   cs_build_nc_freq_list
+( T_SC_DATABASE   *db            );
+LOCAL void   cs_find_strongest_with_status
+( UBYTE           *count,
+UBYTE           *index,
+UBYTE            select_status,
+UBYTE            maximum,
+UBYTE            limitation    );
+LOCAL void   cs_consider_multiband
+( UBYTE           *count,
+UBYTE           *index,
+UBYTE            select_status,
+UBYTE            maximum       );
+LOCAL BOOL   cs_update_strongest  ( UBYTE            cnt_strgst,
+UBYTE            cnt_candid,
+UBYTE           *index,
+ULONG            fn_offset     );
+LOCAL void   cs_start_t3158       ( T_TIME           time          );
+LOCAL void   cs_set_cnt_nc_six    ( UBYTE            strgst,
+UBYTE            candid        );
+LOCAL T_TIME cs_get_nc_rpt_prd_idle
+( void                           );
+LOCAL void cs_copy_rxlev_from_avg( UBYTE            rxlev_avg,
+T_CELL          *cell           );
+LOCAL void cs_reuse_old_cell_rxlev  (void);
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+LOCAL void cs_build_ba_bcch_nc_freq_list ();
+#endif
+/*
++------------------------------------------------------------------------------
+| Function    : cs_set_cnt_nc_six
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_set_cnt_nc_six ( UBYTE strgst, UBYTE candid )
+{
+TRACE_FUNCTION( "cs_set_cnt_nc_six" );
+#if defined FF_EOTD
+grr_data->db.cnt_nc_six.strgst = MINIMUM( CS_MAX_STRONG_CARRIER_CR, strgst );
+#else  /* #if defined FF_EOTD */
+grr_data->db.cnt_nc_six.strgst = strgst;
+#endif /* #if defined FF_EOTD */
+grr_data->db.cnt_nc_six.candid = candid;
+} /* cs_set_cnt_nc_six() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_build_meas_rpt
++------------------------------------------------------------------------------
+| Description : This function ...
+|
+| Parameters  : u_meas_report - Pointer to measurement report
+|
++------------------------------------------------------------------------------
+*/
+LOCAL BOOL cs_build_meas_rpt ( T_U_MEAS_REPORT *u_meas_report )
+{
+T_NC_ORDER      nc_ord        = cs_get_network_ctrl_order( TRUE );
+BOOL            pbcch_present = grr_is_pbcch_present( );
+UBYTE           used_bits;
+/* bits currently used for the measurement report */
+UBYTE           next_meas_bits = 0;
+/* bits used for the next element of the          */
+/* measurement result list                        */
+BOOL            is_first_instance;
+T_CS_MEAS_DATA *nmeas      = &grr_data->cs_meas;
+T_nc_meas_rep  *ncmeas_rep = &u_meas_report->nc_meas_rep;
+T_nc_meas_s1   *p_mrpt;
+T_ncell_info   *ncell;
+T_NC_MVAL      *mval;
+UBYTE return_value;
+BOOL rsc_avail = FALSE;
+BOOL isc_avail = FALSE;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+UBYTE psi3_cm = grr_get_psi3_cm();
+#endif
+TRACE_FUNCTION( "cs_build_meas_rpt" );
+/* process message type */
+used_bits               = PMR_MSG_TYPE_LEN;
+u_meas_report->msg_type = U_MEAS_REPORT_c;
+/* process TLLI */
+used_bits += PMR_TLLI_LEN;
+grr_set_buf_tlli( &u_meas_report->tlli_value, grr_get_tlli( ) );
+/* process PSI5 change mark */
+used_bits += PMR_FLAG_LEN;
+if( pbcch_present                 EQ FALSE                       OR
+grr_data->db.nc_ref_lst.param EQ &psc_db->nc_ms.ncmeas.param    )
+{
+u_meas_report->v_psi5_cm = FALSE;
+}
+else if( grr_data->db.nc_ref_lst.param EQ &psc_db->nc_cw.param )
+{
+used_bits += PMR_PSI5_CHNGE_MRK_LEN;
+u_meas_report->v_psi5_cm = TRUE;
+u_meas_report->psi5_cm   = psc_db->psi5_params.psi5_change_mark;
+}
+else
+{
+TRACE_ERROR( "cs_build_meas_rpt no valid data set" );
+return( FALSE );
+}
+/* process flags */
+used_bits                    += PMR_FLAG_LEN;
+u_meas_report->flag           = 0;
+u_meas_report->v_nc_meas_rep  = TRUE;
+u_meas_report->v_xmeas_rep    = FALSE;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/*if(psc_db->network_rel NEQ BSS_NW_REL_97)*/
+{
+used_bits                += PMR_FLAG_LEN;
+u_meas_report->v_release_99_str_pmr = TRUE;
+used_bits                += PMR_FLAG_LEN;
+u_meas_report->release_99_str_pmr.v_meas_rep_3g_str = FALSE;
+used_bits                += PMR_FLAG_LEN;
+u_meas_report->release_99_str_pmr.v_ba_psi3_str = TRUE;
+used_bits                += PMO_IND_USED_LEN;
+u_meas_report->release_99_str_pmr.ba_psi3_str.pmo_ind_used = psc_db->nc_ms.pmo_ind;
+/* 1 bit for u_meas_report->ba_psi3_str.flag */
+used_bits                += PMR_FLAG_LEN;
+/* process BA used, PSI3 change mark and PMO used */
+if( pbcch_present EQ FALSE )
+{
+TRACE_EVENT_P1("pbcch_present %d", pbcch_present);
+u_meas_report->release_99_str_pmr.ba_psi3_str.flag = FALSE;
+u_meas_report->release_99_str_pmr.ba_psi3_str.v_ba_ind_used = TRUE;
+u_meas_report->release_99_str_pmr.ba_psi3_str.v_ba_ind_used_3g = TRUE;
+used_bits                += PMR_BA_IND_USED_LEN;
+u_meas_report->release_99_str_pmr.ba_psi3_str.ba_ind_used = psc_db->ba_ind;
+/* Add 1 bit for ba_ind_used_3g */
+u_meas_report->release_99_str_pmr.ba_psi3_str.ba_ind_used_3g = 0;
+used_bits                += PMR_BA_IND_USED_LEN;
+}
+else
+{
+u_meas_report->release_99_str_pmr.ba_psi3_str.flag = TRUE;
+u_meas_report->release_99_str_pmr.ba_psi3_str.v_psi3_cm = TRUE;
+used_bits                += PMR_PSI3_CHNGE_MRK_LEN;
+u_meas_report->release_99_str_pmr.ba_psi3_str.psi3_cm = psi3_cm;
+}
+}
+#endif
+/* process NC mode */
+used_bits += NC_MODE_LEN;
+switch( nc_ord )
+{
+case NC_NC1: ncmeas_rep->nc_mode = NCMODE_NC1; break;
+case NC_NC2: ncmeas_rep->nc_mode = NCMODE_NC2; break;
+default: TRACE_ERROR( "cs_build_meas_rpt no valid NC mode" ); return( FALSE );
+}
+/* process serving cell data - rxlev and ilev */
+return_value =
+cs_process_serving_cell_data(&ncmeas_rep->rxlev_scell,
+&ncmeas_rep->v_i_scell,
+&ncmeas_rep->i_scell, &used_bits,
+&rsc_avail, &isc_avail);
+if((return_value EQ FALSE) AND (rsc_avail EQ FALSE))
+return(FALSE);
+/* process NC measurement results */
+used_bits               += NC_NUM_OF_MEAS_LEN;
+ncmeas_rep->num_nc_meas  = 0;
+ncmeas_rep->c_nc_meas_s1 = 0;
+is_first_instance        = nmeas->pmr_snd_ref EQ 0 ? TRUE : FALSE;
+do
+{
+/* calculate estimated length of next measurement result */
+if( nmeas->pmr_snd_ref >= grr_data->db.cnt_nc_six.candid )
+{
+mval  = NULL;
+ncell = NULL;
+}
+else
+{
+mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.nc_six_strgst[nmeas->pmr_snd_ref].idx];
+next_meas_bits = NC_FREQ_N_LEN + NC_RXLEV_N_LEN + PMR_FLAG_LEN;
+if( mval->sync_info.sync.status EQ STAT_SYNC_OK )
+{
+UBYTE ncell_idx = 0;
+ncell = grr_get_ncell_info( mval->arfcn, mval->sync_info.bsic );
+while( ncell_idx  <  grr_data->db.nc_ref_lst.number AND
+ncell      EQ NULL                               )
+{
+ncell = grr_data->db.nc_ref_lst.info[ncell_idx];
+if( ncell->arfcn                   NEQ mval->arfcn       OR
+NC_GET_TYPE( ncell->info_src ) NEQ INFO_TYPE_BA_BCCH    )
+{
+ncell = NULL;
+}
+ncell_idx++;
+}
+if( ncell NEQ NULL )
+{
+next_meas_bits = NC_FREQ_N_LEN + NC_RXLEV_N_LEN + PMR_FLAG_LEN;
+if( NC_GET_TYPE( ncell->info_src ) EQ INFO_TYPE_BA_BCCH )
+{
+next_meas_bits += NC_BSIC_N_LEN;
+}
+}
+}
+else
+{
+ncell = NULL;
+}
+}
+if( ncell NEQ NULL AND mval NEQ NULL)
+{
+if( BIT_UL_CTRL_BLOCK_CONTENTS - used_bits  >=  next_meas_bits     )
+{
+/* copy next measurement result to measurement report */
+ncmeas_rep->num_nc_meas++;
+ncmeas_rep->c_nc_meas_s1++;
+used_bits += next_meas_bits;
+p_mrpt     = &ncmeas_rep->nc_meas_s1[ncmeas_rep->c_nc_meas_s1 - 1];
+p_mrpt->freq_n   = ncell->index;
+p_mrpt->rxlev_n  = mval->rxlev_avg;
+if( NC_GET_TYPE( ncell->info_src ) EQ INFO_TYPE_BA_BCCH )
+{
+p_mrpt->bsic   = mval->sync_info.bsic;
+p_mrpt->v_bsic = TRUE;
+}
+else
+{
+p_mrpt->v_bsic = FALSE;
+}
+nmeas->pmr_snd_ref++;
+}
+else
+{
+mval = NULL;
+}
+}
+else
+{
+nmeas->pmr_snd_ref++;
+}
+}
+while( mval NEQ NULL );
+return( is_first_instance OR ncmeas_rep->num_nc_meas );
+} /* cs_build_meas_rpt() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_is_meas_reporting
++------------------------------------------------------------------------------
+| Description : This function ...
+|
+| Parameters  : ...
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL UBYTE cs_is_meas_reporting ( void )
+{
+T_NC_ORDER ctrl_order = cs_get_network_ctrl_order( TRUE );
+TRACE_FUNCTION( "cs_is_meas_reporting" );
+return( ctrl_order EQ NC_NC1 OR ctrl_order EQ NC_NC2 );
+} /* cs_is_meas_reporting() */
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/*
++------------------------------------------------------------------------------
+| Function    : cs_is_enh_meas_reporting
++------------------------------------------------------------------------------
+| Description : This function is used to check whether enhanced measurement
+|               reporting is to be done.
+|
+| Parameters  : returns TRUE if ENH reporting is to be done
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL cs_is_enh_meas_reporting ( void )
+{
+BOOL return_value = FALSE;
+TRACE_FUNCTION( "cs_is_enh_meas_reporting" );
+if ( cs_is_meas_reporting() AND
+(grr_data->db.nc_ref_lst.enh_param->rept_type EQ REPORT_TYPE_ENH_REP) )
+{
+return_value = TRUE;
+}
+return( return_value );
+} /* cs_is_enh_meas_reporting() */
+#endif
+/*
++------------------------------------------------------------------------------
+| Function    : cs_build_nc_freq_list
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  : db - pointer to serving cell database
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_build_nc_freq_list ( T_SC_DATABASE *db )
+{
+UBYTE i, j, k;        /* used for counting                              */
+UBYTE act_idx;        /* index of actual processed reference list entry */
+BOOL  is_removed;
+BOOL  is_overwritten;
+T_ncell_info *info_ref_lst;
+T_ncell_info *info_prev  = ( db->nc_cw.list.number EQ 0 ?
+NULL :
+&db->nc_cw.list.info[db->nc_cw.list.number-1] );
+T_ncell_info *info_curr;
+T_INFO_SRC    info_src   = 0;
+TRACE_FUNCTION( "cs_build_nc_freq_list" );
+/*
+* add neighbour cell information of BA(GPRS) to reference list
+* in case they are not removed
+*/
+for( i = 0; i < db->nc_cw.list.number; i++ )
+{
+/*
+* looking for entry with correct index,
+* they are no longer sorted with increasing number
+*/
+k = 0;
+while( k < db->nc_cw.list.number AND i NEQ db->nc_cw.list.info[k].index )
+{
+k++;
+}
+if( db->nc_cw.list.info[k].arfcn EQ psc_db->pbcch.bcch.arfcn )
+{
+/* remove the serving cell from the neighbour cell reference list */
+is_removed = TRUE;
+}
+else
+{
+for( j = 0, is_removed = FALSE;
+j < db->nc_ms.rfreq.number AND is_removed EQ FALSE;
+j++ )
+{
+if( db->nc_cw.list.info[k].index EQ db->nc_ms.rfreq.idx[j] )
+{
+is_removed = TRUE;
+}
+}
+}
+if( is_removed EQ FALSE )
+{
+if( !( db->nc_cw.list.info[k].v_cr_par                EQ  FALSE             AND
+NC_GET_TYPE( db->nc_cw.list.info[k].info_src ) NEQ INFO_TYPE_BA_BCCH AND
+cs_get_network_ctrl_order( TRUE )              NEQ NC_NC2                )
+AND
+!( db->nc_cw.list.info[k].cr_par.cell_ba                                    ) )
+{
+grr_data->db.nc_ref_lst.info[grr_data->db.nc_ref_lst.number] =
+&db->nc_cw.list.info[k];
+grr_data->db.nc_ref_lst.number++;
+}
+else
+{
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT_P2( "cs_build_nc_freq_list 1: not added to NC_REF_LST %d %d",
+db->nc_cw.list.info[k].arfcn, db->nc_cw.list.info[k].bsic );
+}
+#endif /* #if !defined (NTRACE) */
+}
+}
+else
+{
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT_P2( "cs_build_nc_freq_list 2: not added to NC_REF_LST %d %d",
+db->nc_cw.list.info[k].arfcn, db->nc_cw.list.info[k].bsic );
+}
+#endif /* #if !defined (NTRACE) */
+}
+}
+/*
+* add/overwrite neighbour cell information to/of reference list
+*/
+i = 0;
+while( ( info_curr = grr_get_next_bigger_ncell_param
+( &db->nc_ms.ncmeas.list, info_src ) ) NEQ NULL )
+{
+j              = 0;
+is_overwritten = FALSE;
+while( j < grr_data->db.nc_ref_lst.number AND is_overwritten EQ FALSE )
+{
+info_ref_lst = grr_data->db.nc_ref_lst.info[j];
+if( NC_GET_TYPE( info_ref_lst->info_src ) NEQ INFO_TYPE_BA_BCCH AND
+info_ref_lst->v_cr_par                EQ  TRUE              AND
+info_curr->v_cr_par                   EQ  TRUE              AND
+info_ref_lst->bsic                    EQ  info_curr->bsic   AND
+info_ref_lst->arfcn                   EQ  info_curr->arfcn      )
+{
+is_overwritten = TRUE;
+}
+else
+{
+j++;
+}
+}
+/*
+* calculate the index of the reference list entry
+* which shall be used for further processing
+*/
+if( is_overwritten EQ FALSE )
+{
+if( grr_data->db.nc_ref_lst.number < MAX_NR_OF_NCELL )
+{
+act_idx = grr_data->db.nc_ref_lst.number;
+}
+else
+{
+TRACE_ERROR( "cs_build_nc_freq_list: reference list full" );
+return;
+}
+}
+else
+{
+act_idx = j;
+}
+if(
+!( info_curr->v_cr_par                EQ  FALSE                    AND
+NC_GET_TYPE( info_curr->info_src ) NEQ INFO_TYPE_BA_BCCH        AND
+cs_get_network_ctrl_order( TRUE )  NEQ NC_NC2                       )
+AND
+!( info_curr->cr_par.cell_ba                                           )
+AND
+( info_curr->arfcn                   NEQ psc_db->pbcch.bcch.arfcn     )
+)
+{
+/*
+* add/overwrite reference list entry
+*/
+grr_data->db.nc_ref_lst.info[act_idx] = info_curr;
+grr_data->db.nc_ref_lst.number++;
+/* process cell selection parameter */
+grr_restore_cs_param
+( info_curr, info_prev, (UBYTE)( db->nc_cw.list.number + i ) );
+if( info_curr->v_cr_par EQ TRUE )
+{
+info_prev = info_curr;
+}
+}
+else
+{
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT_P2( "cs_build_nc_freq_list 3: not added to NC_REF_LST %d %d",
+info_curr->arfcn, info_curr->bsic );
+}
+#endif /* #if !defined (NTRACE) */
+info_curr->index = db->nc_cw.list.number + i;
+}
+info_src = info_curr->info_src;
+i++;
+}
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+UBYTE         read;
+USHORT        crp_s;
+ULONG         crp[4];
+T_ncell_info *info;
+crp[0]  = ( ( ULONG )psc_db->pbcch.bcch.arfcn  << 16 );
+crp[0] |= ( ( ULONG )psc_db->pbcch.bcch.bsic   <<  8 );
+crp[0] |=   ( ULONG )psc_db->scell_par.cell_ba;
+crp[1]  = ( ( ULONG )psc_db->scell_par.exc_acc                                   << 24 );
+crp[1] |= ( ( ULONG )psc_db->scell_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min << 16 );
+crp[1] |= ( ( ULONG )psc_db->scell_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch <<  8 );
+if( psc_db->scell_par.cr_par_1.v_hcs_par )
+{
+crp[1] |=   ( ULONG  )psc_db->scell_par.cr_par_1.hcs_par.gprs_prio_class;
+crp_s   = ( ( USHORT )psc_db->scell_par.cr_par_1.hcs_par.gprs_hcs_thr    << 8 );
+}
+else
+{
+crp[1] |=   ( ULONG  )0xFF;
+crp_s   = ( ( USHORT )0xFF << 8 );
+}
+crp_s |= ( ULONG )psc_db->scell_par.multi_band_rep;
+TRACE_EVENT_P3( "SCELL %08X%08X%04X", crp[0], crp[1], crp_s );
+for( read = 0; read < grr_data->db.nc_ref_lst.number; read++ )
+{
+info = grr_data->db.nc_ref_lst.info[read];
+crp[0]  = ( ( ULONG )info->arfcn << 16 );
+crp[0] |= ( ( ULONG )info->bsic  <<  8 );
+if( info->v_cr_par )
+{
+crp[0] |=   ( ULONG )info->cr_par.cell_ba;
+crp[1]  = ( ( ULONG )info->cr_par.exc_acc                                   << 24 );
+crp[1] |= ( ( ULONG )info->cr_par.same_ra_scell                             << 16 );
+crp[1] |= ( ( ULONG )info->cr_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min <<  8 );
+crp[1] |=   ( ULONG )info->cr_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch;
+crp[2]  = ( ( ULONG )info->cr_par.cr_offset.gprs_temp_offset  << 24 );
+crp[2] |= ( ( ULONG )info->cr_par.cr_offset.gprs_penalty_time << 16 );
+crp[2] |= ( ( ULONG )info->cr_par.gprs_resel_off              <<  8 );
+if( grr_data->db.nc_ref_lst.info[read]->cr_par.cr_par_1.v_hcs_par )
+{
+crp[2] |=   ( ULONG )info->cr_par.cr_par_1.hcs_par.gprs_prio_class;
+crp[3]  = ( ( ULONG )info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr    << 24 );
+}
+else
+{
+crp[2] |=   ( ULONG )0xFF;
+crp[3]  = ( ( ULONG )0xFF << 24 );
+}
+if( info->cr_par.v_si13_pbcch )
+{
+if( info->cr_par.si13_pbcch.v_si13_location )
+{
+crp[3] |= ( ( ULONG )info->cr_par.si13_pbcch.si13_location << 16 );
+crp[3] |= ( ( ULONG )0xFF                                  << 8  );
+crp[3] |=   ( ULONG )0xFF;
+}
+else
+{
+crp[3] |= ( ( ULONG )0xFF                                       << 16 );
+crp[3] |= ( ( ULONG )info->cr_par.si13_pbcch.pbcch_location     << 8  );
+crp[3] |=   ( ULONG )info->cr_par.si13_pbcch.psi1_repeat_period;
+}
+}
+else
+{
+crp[3] |= ( ULONG )0xFFFFFF;
+}
+}
+else
+{
+crp[1] |= ( ULONG )0xFF;
+crp[2]  = ( ULONG )0xFFFFFFFF;
+crp[3]  = ( ULONG )0xFFFFFFFF;
+}
+TRACE_EVENT_P5( "NC_REF_LST[%d] %08X%08X%08X%08X",
+read, crp[0], crp[1], crp[2], crp[3] );
+}
+}
+#endif /* #if !defined (NTRACE) */
+}/* cs_build_nc_freq_list */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_reorg_nc_mval_lst
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_reorg_nc_mval_lst ( void )
+{
+BOOL          scell_restored = FALSE;
+UBYTE         mval_idx;
+UBYTE         nc_idx;
+T_NC_MVAL    *nc_mval;
+T_ncell_info *ncell_info;
+TRACE_FUNCTION( "cs_reorg_nc_mval_lst" );
+for( mval_idx = 0; mval_idx < MAX_NR_OF_NC_MVAL; mval_idx++ )
+{
+/*
+* check whether measured values can be reused
+*/
+nc_mval = &grr_data->db.nc_mval_list.nc_mval[mval_idx];
+if( nc_mval->status NEQ NC_MVAL_STAT_NONE )
+{
+/*
+* only used entries shall be considered
+*/
+if( psc_db->pbcch.bcch.arfcn EQ  nc_mval->arfcn      AND
+psc_db->pbcch.bcch.arfcn NEQ RRGRR_INVALID_ARFCN     )
+{
+/*
+* remove the measured values from the serving cell,
+* this cell will not be used for cell re-selection
+*/
+cs_init_nc_mval( nc_mval );
+}
+else
+{
+ncell_info = grr_get_ncell_info( nc_mval->arfcn, RRGRR_INVALID_BSIC );
+if( ncell_info EQ NULL )
+{
+/*
+* cell is not on the neighbor cell list,
+* keep the measured values until RR informs GRR,
+* but do not use them
+*/
+nc_mval->status     = NC_MVAL_STAT_PENDING;
+nc_mval->rla_p.stat = CS_RLA_P_NOT_AVAIL;
+}
+else
+{
+/*
+* cell is on the neighbor cell list,
+* re-activate the measured values
+*/
+nc_mval->status = NC_MVAL_STAT_ASSIGNED;
+}
+if( grr_data->db.old_scell.arfcn EQ  nc_mval->arfcn      AND
+grr_data->db.old_scell.arfcn NEQ RRGRR_INVALID_ARFCN     )
+{
+/*
+* in case the old serving cell is on the measured values list,
+* keep the results for further use
+*/
+scell_restored = TRUE;
+nc_mval->sync_info.bsic                 = grr_data->db.old_scell.bsic;
+nc_mval->sync_info.sync.status          = STAT_SYNC_OK;
+nc_mval->sync_info.sync.sync_failed_cnt = 0;
+}
+}
+}
+}
+for( nc_idx = 0; nc_idx < grr_data->db.nc_ref_lst.number; nc_idx++ )
+{
+nc_mval = grr_get_nc_mval( grr_data->db.nc_ref_lst.info[nc_idx]->arfcn,
+RRGRR_INVALID_BSIC, &mval_idx );
+if( nc_mval EQ NULL )
+{
+nc_mval =
+grr_get_nc_mval( RRGRR_INVALID_ARFCN, RRGRR_INVALID_BSIC, &mval_idx );
+if( nc_mval NEQ NULL )
+{
+nc_mval->status = NC_MVAL_STAT_ASSIGNED;
+nc_mval->arfcn  = grr_data->db.nc_ref_lst.info[nc_idx]->arfcn;
+if( grr_data->db.old_scell.arfcn EQ  nc_mval->arfcn      AND
+grr_data->db.old_scell.arfcn NEQ RRGRR_INVALID_ARFCN     )
+{
+scell_restored = TRUE;
+nc_mval->sync_info.bsic                 = grr_data->db.old_scell.bsic;
+nc_mval->sync_info.sync.status          = STAT_SYNC_OK;
+nc_mval->sync_info.sync.sync_failed_cnt = 0;
+TRACE_EVENT_P2( "cs_reorg_nc_mval_lst: old SCELL on new NCELL list (1) %d %d",
+grr_data->db.nc_ref_lst.info[nc_idx]->arfcn,
+grr_data->db.nc_ref_lst.info[nc_idx]->bsic );
+}
+}
+else
+{
+TRACE_EVENT_P1( "cs_reorg_nc_mval_lst: nc_mval EQ NULL (1) %d",
+RRGRR_INVALID_ARFCN );
+}
+}
+else
+{
+if( grr_data->db.old_scell.arfcn EQ  nc_mval->arfcn      AND
+grr_data->db.old_scell.arfcn NEQ RRGRR_INVALID_ARFCN     )
+{
+scell_restored = TRUE;
+nc_mval->status                         = NC_MVAL_STAT_ASSIGNED;
+nc_mval->sync_info.bsic                 = grr_data->db.old_scell.bsic;
+nc_mval->sync_info.sync.status          = STAT_SYNC_OK;
+nc_mval->sync_info.sync.sync_failed_cnt = 0;
+TRACE_EVENT_P2( "cs_reorg_nc_mval_lst: old SCELL on new NCELL list (2) %d %d",
+grr_data->db.nc_ref_lst.info[nc_idx]->arfcn,
+grr_data->db.nc_ref_lst.info[nc_idx]->bsic );
+}
+}
+}
+if( scell_restored               EQ  FALSE               AND
+grr_data->db.old_scell.arfcn NEQ RRGRR_INVALID_ARFCN     )
+{
+nc_mval =
+grr_get_nc_mval( RRGRR_INVALID_ARFCN, RRGRR_INVALID_BSIC, &mval_idx );
+if( nc_mval NEQ NULL )
+{
+nc_mval->status                         = NC_MVAL_STAT_PENDING;
+nc_mval->arfcn                          = grr_data->db.old_scell.arfcn;
+nc_mval->sync_info.bsic                 = grr_data->db.old_scell.bsic;
+nc_mval->sync_info.sync.status          = STAT_SYNC_OK;
+nc_mval->sync_info.sync.sync_failed_cnt = 0;
+}
+else
+{
+TRACE_EVENT_P1( "cs_reorg_nc_mval_lst: nc_mval EQ NULL (2) %d",
+RRGRR_INVALID_ARFCN );
+}
+}
+grr_data->cs.is_mval_initialized = FALSE;
+cs_trace_nc_mval_lst( );
+}/* cs_reorg_nc_mval_lst */
+/*==== PUBLIC FUNCTIONS =====================================================*/
+/*
++------------------------------------------------------------------------------
+| Function    : cs_grr_init
++------------------------------------------------------------------------------
+| Description : The function cs_grr_init() .... name change becauce there is a
+|               function in cs_init in TIL.
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_grr_init ( void )
+{
+TRACE_FUNCTION( "cs_grr_init" );
+grr_data->cs.gmm_state           = STANDBY_STATE;
+grr_data->cs.last_cr             = 0;
+grr_data->cs.reselect_cause      = CS_RESELECT_CAUSE_CS_NORMAL;
+grr_data->cs.is_mval_initialized = FALSE;
+grr_data->cs.nc_sync_rep_pd      = 0;
+#if !defined (NTRACE)
+grr_data->cs.v_crp_trace = FALSE;
+#endif /* #if !defined (NTRACE) */
+grr_init_ncmeas_extd_struct( &psc_db->nc_ms, FALSE );
+cs_init_nc_ref_list( &grr_data->db.nc_ref_lst );
+cs_init_nc_mval_lst( );
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/* Initialize Enhanced Measurement parameters and list */
+grr_init_enh_param(&psc_db->enh_ms, TRUE);
+grr_init_enh_cell_list();
+#endif
+grr_data->cs_meas.pmr_snd_ref = 0;
+grr_data->cs_meas.packet_mode = PACKET_MODE_NULL;
+nc_data = &grr_data->nc_data;
+cs_reset_all_cell_results( );
+grr_data->cs.list_id             = 0;
+grr_data->cs.stop_req            = FALSE;
+nc_data->c_cell                  = 0;
+grr_data->cs.cr_meas_mode        = CS_CRMM_BA_GPRS;
+grr_data->cs.cr_meas_update      = FALSE;
+grr_data->cs.last_assignment_id  = 0;
+INIT_STATE( CS_MEAS, CS_MEAS_NULL  );
+INIT_STATE( CS, CS_NULL );
+} /* cs_grr_init() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_process_cc_order
++------------------------------------------------------------------------------
+| Description : The function cs_process_cc_order() ....
+|
+| Parameters  : d_cell_chan_order - Pointer to packet cell change order message
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_process_cc_order ( T_nc_meas_par  *nc_meas_par,
+UBYTE           v_nc_freq_list,
+T_nc_freq_list *nc_freq_list
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+, UBYTE       v_enh_meas_param_pcco,
+T_enh_meas_param_pcco   *enh_meas_param_pcco
+#endif
+)
+{
+TRACE_FUNCTION( "cs_process_cc_order" );
+grr_init_ncmeas_extd_struct( &pcr_db->nc_ms, FALSE );
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/* Initialize Enhanced Measurement parameters */
+grr_init_enh_param(&pcr_db->enh_ms, TRUE);
+#endif
+/*
+* process the NC measurement parameter
+*
+* only one instance of PCCO, store data in final location
+*/
+grr_prcs_nc_param_struct ( &pcr_db->nc_ms.ncmeas.param,
+nc_meas_par,
+0 );
+/* For PCCO the paramater obtained in PCCO should be applied immediately
+Sec 5.6.1 Spec 4.60 */
+grr_data->db.nc_ref_lst.param = &pcr_db->nc_ms.ncmeas.param;
+/*
+* process NC_FREQUENCY_LIST
+*
+* only one instance of PCCO, store data in final location
+*/
+grr_prcs_nc_freq_list ( &pcr_db->nc_ms.ncmeas.list,
+&pcr_db->nc_ms.rfreq,
+v_nc_freq_list,
+nc_freq_list,
+INFO_TYPE_PCCO,
+0 );
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/*
+* process the ENH measurement parameter
+*
+* only one instance of PCCO, store data in final location
+*/
+if(v_enh_meas_param_pcco)
+{
+grr_prcs_enh_param_pcco ( pcr_db, enh_meas_param_pcco );
+}
+#endif
+} /* cs_process_cc_order() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_calc_cr_criterion
++------------------------------------------------------------------------------
+| Description : The function cs_calc_cr_criterion() ....
+|
+| Parameters  : dummy - description of parameter dummy
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_calc_cr_criterion ( T_CR_CRITERIONS *cr_crit,
+USHORT           arfcn,
+T_rla_p         *rla_p,
+T_CR_PAR_1      *cr_par_1 )
+{
+T_MS_PWR_CAP mspc;
+SHORT        A, B;
+TRACE_FUNCTION( "cs_calc_cr_criterion" );
+/* C1     = A - MAX(B,0)                                                 */
+/* A      = RLA_P - GPRS_RXLEV_ACCESS_MIN                                */
+/* B      = GPRS_MS_TXPWR_MAX_CCH - P                                    */
+/* P      = max MS RF output power                                       */
+/* C31    = RLA_P(s) - HCS_THR(s) (serving cell)                         */
+/* C31    = RLA_P(n) - HCS_THR(n) - TO(n)*L(n) (neighbour cell)          */
+/* TO(n)  = GPRS_TEMPORARY_OFFSET(n) * H( GPRS_PENALTY_TIME(N) - T(n) )  */
+/* L(n)   = 0 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s)                   */
+/*          1 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s)                   */
+/* C32(s) = C1(s)                                                        */
+/* C32(n) = C1(n) + GPRS_RESELECT OFFSET(n) - TO(n)*(1-L(n))             */
+/* TO(n)  = GPRS_TEMPORARY_OFFSET(n) * H( GPRS_PENALTY_TIME(N) - T(n) )  */
+/* L(n)   = 0 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s)                   */
+/*          1 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s)                   */
+/* H(n)   = 0 for x <  0                                                 */
+/*          1 for x >= 0                                                 */
+/* T(n)   = ?????                                                        */
+grr_get_ms_pwr_cap( arfcn, grr_data->meas.pwr_offset, &mspc );
+/*
+* calculate cell re-selection criteria acc. GSM05.08,
+* chapter 10.1.2 for the serving/neighbour cell
+*/
+/* intermediate results for serving/neighbour cell */
+A = (SHORT)rla_p->lev - (SHORT)cr_par_1->cr_pow_par.gprs_rxlev_access_min;
+B = mspc.p_control[cr_par_1->cr_pow_par.gprs_ms_txpwr_max_cch] - mspc.p[mspc.ms_power];
+/* path loss criterion for serving/neighbour cell */
+cr_crit->c1 = A - MAXIMUM( B, 0 );
+/* signal threshold criterion for serving/neighbour cell */
+cr_crit->c31 = ( SHORT )rla_p->lev;
+if( cr_par_1->v_hcs_par )
+{
+cr_crit->c31 -= ( 2 * cr_par_1->hcs_par.gprs_hcs_thr );
+}
+/* cell ranking criterion for serving/neighbour cell */
+cr_crit->c32 = cr_crit->c1;
+} /* cs_calc_cr_criterion() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_calc_params
++------------------------------------------------------------------------------
+| Description : The function cs_calc_params() ....
+|
+| Parameters  : dummy - description of parameter dummy
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_calc_params ( void )
+{
+BOOL          prio_cr = FALSE;
+UBYTE         h;
+UBYTE         i, prios, prion, strgst = 0xFF;
+T_ncell_info *ncell_info;
+T_NC_MVAL    *nc_mval;
+TRACE_FUNCTION( "cs_calc_params" );
+/* C1     = A - MAX(B,0)                                                 */
+/* A      = RLA_P - GPRS_RXLEV_ACCESS_MIN                                */
+/* B      = GPRS_MS_TXPWR_MAX_CCH - P                                    */
+/* P      = max MS RF output power                                       */
+/* C31    = RLA_P(s) - HCS_THR(s) (serving cell)                         */
+/* C31    = RLA_P(n) - HCS_THR(n) - TO(n)*L(n) (neighbour cell)          */
+/* TO(n)  = GPRS_TEMPORARY_OFFSET(n) * H( GPRS_PENALTY_TIME(N) - T(n) )  */
+/* L(n)   = 0 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s)                   */
+/*          1 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s)                   */
+/* C32(s) = C1(s)                                                        */
+/* C32(n) = C1(n) + GPRS_RESELECT OFFSET(n) - TO(n)*(1-L(n))             */
+/* TO(n)  = GPRS_TEMPORARY_OFFSET(n) * H( GPRS_PENALTY_TIME(N) - T(n) )  */
+/* L(n)   = 0 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s)                   */
+/*          1 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s)                   */
+/* H(n)   = 0 for x <  0                                                 */
+/*          1 for x >= 0                                                 */
+/* T(n)   = ?????                                                        */
+cs_calc_cr_criterion( &grr_data->db.scell_info.cr_crit,
+psc_db->pbcch.bcch.arfcn,
+&grr_data->db.scell_info.rla_p,
+&psc_db->scell_par.cr_par_1 );
+/* priority class for serving cell */
+prios = ( psc_db->scell_par.cr_par_1.v_hcs_par ) ?
+psc_db->scell_par.cr_par_1.hcs_par.gprs_prio_class : 0;
+/*
+* calculate cell re-selection criteria acc. GSM05.08,
+* chapter 10.1.2 for the neighbour cells
+*/
+for( i = 0; i < grr_data->db.cnt_nc_six.strgst; i++ )
+{
+h          = FALSE;
+nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.nc_six_strgst[i].idx];
+if( nc_mval->sync_info.sync.status EQ STAT_SYNC_OK )
+{
+ncell_info =
+grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic );
+if( ncell_info NEQ NULL )
+{
+cs_calc_cr_criterion( &grr_data->db.nc_six_strgst[i].cr_crit,
+ncell_info->arfcn,
+&nc_mval->rla_p,
+&ncell_info->cr_par.cr_par_1 );
+/* cell ranking criterion for neighbour cell, add GPRS_RESELECT_OFFSET */
+/*
+* if the parameter C32_QUAL is set, positive GPRS_RESELECT_OFFSET values
+* shall only be applied to the neighbour cell with the highest RLA_P value
+* of those cells for which C32 is compared.
+*
+* calculation part 1
+*/
+if( psc_db->gen_cell_par.c32_qual                EQ FALSE OR
+p_res_off[ncell_info->cr_par.gprs_resel_off] <  0        )
+{
+grr_data->db.nc_six_strgst[i].cr_crit.c32 +=
+p_res_off[ncell_info->cr_par.gprs_resel_off];
+}
+/* priority class of neighbour cell */
+prion = ( ncell_info->cr_par.cr_par_1.v_hcs_par ) ?
+ncell_info->cr_par.cr_par_1.hcs_par.gprs_prio_class : 0;
+/* check whether GPRS_TEMPORARY_OFFSET shall be considered */
+if( (ULONG)( ( ncell_info->cr_par.cr_offset.gprs_penalty_time + 1 ) *
+10 * CS_PERIOD_1_SEC ) > grr_data->db.nc_six_strgst[i].avail_time )
+{
+h = TRUE;
+}
+/*
+* cell ranking and signal threshold criterion for neighbour cell,
+* subtract GPRS_TEMPORARY_OFFSET
+*/
+if( h )
+{
+SHORT *criterion;
+if( prios NEQ prion )
+{
+criterion = &grr_data->db.nc_six_strgst[i].cr_crit.c31;
+}
+else
+{
+criterion = &grr_data->db.nc_six_strgst[i].cr_crit.c32;
+}
+if( ncell_info->cr_par.cr_offset.gprs_temp_offset EQ
+GPRS_TEMPORARY_OFFSET_INFINITY                   )
+{
+*criterion = CS_SMALLEST_SHORT_VALUE;
+}
+else
+{
+*criterion -= 10 * ncell_info->cr_par.cr_offset.gprs_temp_offset;
+}
+}
+/*
+* cell ranking and signal threshold criterion for neighbour cell,
+* subtract RA_RESELECT_HYSTERESIS and/or GPRS_CELL_RESELECT_HYSTERESIS
+*/
+if( !ncell_info->cr_par.same_ra_scell )
+{
+grr_data->db.nc_six_strgst[i].cr_crit.c32 -=
+2 * psc_db->gen_cell_par.ra_re_hyst;
+}
+else if( grr_data->cs.gmm_state NEQ STANDBY_STATE )
+{
+grr_data->db.nc_six_strgst[i].cr_crit.c32 -=
+2 * psc_db->gen_cell_par.gprs_c_hyst;
+if( psc_db->gen_cell_par.c31_hyst )
+{
+grr_data->db.nc_six_strgst[i].cr_crit.c31 -=
+2 * psc_db->gen_cell_par.gprs_c_hyst;
+}
+}
+/*
+* in case a cell re-selection occured within the
+* previous 15 seconds, subtract 5 dB
+*/
+if(grr_t_status( T15_SEC_CC ) > 0)
+{
+grr_data->db.nc_six_strgst[i].cr_crit.c32 -= 5;
+}
+}
+else
+{
+grr_data->db.nc_six_strgst[i].cr_crit.c1  = -2;
+grr_data->db.nc_six_strgst[i].cr_crit.c31 = -2;
+grr_data->db.nc_six_strgst[i].cr_crit.c32 = -2;
+}
+}
+else
+{
+grr_data->db.nc_six_strgst[i].cr_crit.c1  = -1;
+grr_data->db.nc_six_strgst[i].cr_crit.c31 = -1;
+grr_data->db.nc_six_strgst[i].cr_crit.c32 = -1;
+}
+}
+/*
+* calculate the correct neighbour cell for adding positive
+* GPRS_RESELECT_OFFSET values to C32 in case C32_QUAL is set
+*/
+if( psc_db->gen_cell_par.c32_qual EQ TRUE )
+{
+/*
+* check whether priorized cell re-selection should be performed
+*/
+for( i = 0; i < grr_data->db.cnt_nc_six.strgst; i++ )
+{
+if( grr_data->db.nc_six_strgst[i].cr_crit.c31 >= 0 )
+{
+prio_cr = TRUE;
+}
+}
+if( grr_data->db.scell_info.cr_crit.c31 >= 0 )
+{
+prio_cr = TRUE;
+}
+/* find out the strongest neighbour cell */
+for( i = 0; i < grr_data->db.cnt_nc_six.strgst; i++ )
+{
+if( ( prio_cr AND grr_data->db.nc_six_strgst[i].cr_crit.c31 >= 0 ) OR
+( !prio_cr )                                                      )
+{
+if( strgst EQ 0xFF                                                                        OR
+grr_data->db.nc_mval_list.nc_mval[grr_data->db.nc_six_strgst[i].idx].rla_p.lev      >
+grr_data->db.nc_mval_list.nc_mval[grr_data->db.nc_six_strgst[strgst].idx].rla_p.lev      )
+{
+strgst = i;
+}
+}
+}
+if( strgst NEQ 0xFF )
+{
+nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.nc_six_strgst[strgst].idx];
+if( nc_mval->sync_info.sync.status EQ STAT_SYNC_OK )
+{
+ncell_info =
+grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic );
+if( ncell_info NEQ NULL )
+{
+/*
+* if the parameter C32_QUAL is set, positive GPRS_RESELECT_OFFSET values
+* shall only be applied to the neighbour cell with the highest RLA_P value
+* of those cells for which C32 is compared.
+*
+* calculation part 2
+*/
+if( p_res_off[ncell_info->cr_par.gprs_resel_off] > 0 )
+{
+grr_data->db.nc_six_strgst[strgst].cr_crit.c32 +=
+p_res_off[ncell_info->cr_par.gprs_resel_off];
+}
+}
+}
+}
+}
+/*
+* perform some tracing
+*/
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+/* trace the C1 criterion */
+for( i = grr_data->db.cnt_nc_six.strgst; i < CS_MAX_STRONG_CARRIER; i++ )
+{
+grr_data->db.nc_six_strgst[i].cr_crit.c1 = 0;
+}
+TRACE_EVENT_P7
+(
+"C1   : %6d %6d %6d %6d %6d %6d %6d",
+grr_data->db.scell_info.cr_crit.c1,
+grr_data->db.nc_six_strgst[0].cr_crit.c1,
+grr_data->db.nc_six_strgst[1].cr_crit.c1,
+grr_data->db.nc_six_strgst[2].cr_crit.c1,
+grr_data->db.nc_six_strgst[3].cr_crit.c1,
+grr_data->db.nc_six_strgst[4].cr_crit.c1,
+grr_data->db.nc_six_strgst[5].cr_crit.c1
+);
+/* trace the C31 criterion */
+for( i = grr_data->db.cnt_nc_six.strgst; i < CS_MAX_STRONG_CARRIER; i++ )
+{
+grr_data->db.nc_six_strgst[i].cr_crit.c31 = 0;
+}
+TRACE_EVENT_P7
+(
+"C31  : %6d %6d %6d %6d %6d %6d %6d",
+grr_data->db.scell_info.cr_crit.c31,
+grr_data->db.nc_six_strgst[0].cr_crit.c31,
+grr_data->db.nc_six_strgst[1].cr_crit.c31,
+grr_data->db.nc_six_strgst[2].cr_crit.c31,
+grr_data->db.nc_six_strgst[3].cr_crit.c31,
+grr_data->db.nc_six_strgst[4].cr_crit.c31,
+grr_data->db.nc_six_strgst[5].cr_crit.c31
+);
+/* trace the C32 criterion */
+for( i = grr_data->db.cnt_nc_six.strgst; i < CS_MAX_STRONG_CARRIER; i++ )
+{
+grr_data->db.nc_six_strgst[i].cr_crit.c32 = 0;
+}
+TRACE_EVENT_P7
+(
+"C32  : %6d %6d %6d %6d %6d %6d %6d",
+grr_data->db.scell_info.cr_crit.c32,
+grr_data->db.nc_six_strgst[0].cr_crit.c32,
+grr_data->db.nc_six_strgst[1].cr_crit.c32,
+grr_data->db.nc_six_strgst[2].cr_crit.c32,
+grr_data->db.nc_six_strgst[3].cr_crit.c32,
+grr_data->db.nc_six_strgst[4].cr_crit.c32,
+grr_data->db.nc_six_strgst[5].cr_crit.c32
+);
+}
+#endif /* #if !defined (NTRACE) */
+} /* cs_calc_params() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_store_meas_values
++------------------------------------------------------------------------------
+| Description : The function cs_store_meas_values() saves the received
+|               rla_p values in the grr database
+|
+| Parameters  : ...
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_store_meas_values ( void )
+{
+UBYTE   i, j; /* used for counting */
+USHORT  arfcn;
+T_rla_p rla_p;
+TRACE_FUNCTION( "cs_store_meas_values" );
+/*
+* store the first value as serving cell
+*/
+grr_data->db.scell_info.rla_p.stat =
+cs_get_rla_p( &nc_data->cell[0].rla_p_data,
+&grr_data->db.scell_info.rla_p.lev );
+if( grr_data->db.scell_info.rla_p.stat NEQ CS_RLA_P_NOT_AVAIL )
+{
+#ifdef FF_PS_RSSI
+RX_SetValue( grr_data->db.scell_info.rla_p.lev,
+RX_QUAL_UNAVAILABLE,
+psc_db->scell_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min);
+#else
+RX_SetValue( grr_data->db.scell_info.rla_p.lev );
+#endif
+}
+/*
+* store the next values as neighbour cells
+*/
+for( j = 1; j < nc_data->c_cell; j++ )
+{
+i          = 0;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+arfcn      = nc_data->cell[j].arfcn;
+#else
+arfcn      = grr_l1_arfcn_to_g23( nc_data->cell[j].arfcn );
+#endif
+rla_p.stat = cs_get_rla_p( &nc_data->cell[j].rla_p_data, &rla_p.lev );
+while( i                                          <   MAX_NR_OF_NC_MVAL AND
+grr_data->db.nc_mval_list.nc_mval[i].arfcn NEQ arfcn                 )
+{
+i++;
+}
+if( i < MAX_NR_OF_NC_MVAL )
+{
+grr_data->db.nc_mval_list.nc_mval[i].rla_p = rla_p;
+}
+}
+} /* cs_store_meas_values() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_store_rxlev_values
++------------------------------------------------------------------------------
+| Description : The function cs_store_rxlev_values()
+|
+| Parameters  : ...
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_store_rxlev_values ( void )
+{
+UBYTE  i, j; /* used for counting */
+USHORT  arfcn;
+TRACE_FUNCTION( "cs_store_rxlev_values" );
+/*
+* store the first value as serving cell
+*/
+grr_data->db.scell_info.rxlev_avg =
+cs_get_rxlev_avg( &nc_data->cell[0].rxlev_data );
+/*
+* store the next values as neighbour cells
+*/
+for( j = 1; j < nc_data->c_cell; j++ )
+{
+i     = 0;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+arfcn      = nc_data->cell[j].arfcn;
+#else
+arfcn      = grr_l1_arfcn_to_g23( nc_data->cell[j].arfcn );
+#endif
+while( i                                          <   MAX_NR_OF_NC_MVAL AND
+grr_data->db.nc_mval_list.nc_mval[i].arfcn NEQ arfcn                 )
+{
+i++;
+}
+if( i < MAX_NR_OF_NC_MVAL )
+{
+grr_data->db.nc_mval_list.nc_mval[i].rxlev_avg =
+cs_get_rxlev_avg( &nc_data->cell[j].rxlev_data );
+}
+}
+} /* cs_store_rxlev_values() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_find_strongest
++------------------------------------------------------------------------------
+| Description : The function cs_find_strongest() finds out the six strongest
+|               neighbour cells and stores their indices in an array.
+|
+| Parameters  : cnt_strgst - number of strongest carriers
+|               cnt_candid - number of strongest plus candidate carriers
+|               index      - index of carriers
+|               status     - status of carriers
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL cs_find_strongest ( ULONG fn_offset )
+{
+UBYTE cnt_strgst;
+UBYTE cnt_candid;
+UBYTE index[CS_MAX_STRONG_CARRIER];
+UBYTE max_nc_excl_sc_band = 0; /* maximum number of reported neighbour */
+/* cells that should be not in the band */
+/* of the serving cell                  */
+TRACE_FUNCTION( "cs_find_strongest" );
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+if( CHECK_DUAL_BANDS EQ TRUE)
+#else
+if( std EQ STD_DUAL OR std EQ STD_DUAL_EGSM OR std EQ STD_DUAL_US )
+#endif
+{
+switch( psc_db->scell_par.multi_band_rep )
+{
+case GRR_MULTIBAND_REPORTING_1: max_nc_excl_sc_band = 1; break;
+case GRR_MULTIBAND_REPORTING_2: max_nc_excl_sc_band = 2; break;
+case GRR_MULTIBAND_REPORTING_3: max_nc_excl_sc_band = 3; break;
+default                       : max_nc_excl_sc_band = 0; break;
+}
+}
+/*
+* look for strongest neighbour cells with a valid RLA_P value,
+* these are used for cell re-selection only
+*/
+cnt_strgst = 0;
+cs_consider_multiband
+( &cnt_strgst, index, CS_RLA_P_VALID, max_nc_excl_sc_band );
+/*
+* look for strongest neighbour cells with a RLA_P which is not valid
+* but available and add them to the remaining storage areas in the list
+* of strongest neighbour cells, these are used for checking the BSIC
+* in advance, these cells may become a valid RLA_P value soon
+*/
+cnt_candid = cnt_strgst;
+if( cnt_candid < CS_MAX_STRONG_CARRIER )
+{
+cs_consider_multiband
+( &cnt_candid, index, CS_RLA_P_NOT_VALID, max_nc_excl_sc_band );
+}
+return(cs_update_strongest( cnt_strgst, cnt_candid, index, fn_offset ));
+} /* cs_find_strongest() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_consider_multiband
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_consider_multiband ( UBYTE *count,
+UBYTE *index,
+UBYTE  select_status,
+UBYTE  maximum )
+{
+TRACE_FUNCTION( "cs_consider_multiband" );
+if( maximum NEQ 0 )
+{
+/*
+* A maximum of zero means that normal reporting of the six strongest
+* cell irrespective of the band used should be performed.
+*
+* A maximum greater zero means that multi band reporting should be
+* performed, so the MS shall report the strongest cells in each of the
+* frequency bands in the BA list, excluding the frequency band of the
+* serving cell. The remaining positions shall be used for reporting of
+* the cells in the band of the serving cell.
+*/
+cs_find_strongest_with_status
+( count, index, select_status, maximum, CS_EXCLUDE_SC_BAND );
+cs_find_strongest_with_status
+( count, index, select_status,
+(UBYTE)( CS_MAX_STRONG_CARRIER - maximum ), CS_ONLY_SC_BAND );
+}
+if( *count < CS_MAX_STRONG_CARRIER )
+{
+cs_find_strongest_with_status
+( count, index, select_status,
+(UBYTE)( CS_MAX_STRONG_CARRIER - *count ), CS_NO_BAND_LIMITATION );
+}
+} /* cs_consider_multiband() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_find_strongest_with_status
++------------------------------------------------------------------------------
+| Description : The function cs_find_strongest_with_status() finds out the
+|               six strongest neighbour cells with a specific status and
+|               stores their indices in an array.
+|
+| Parameters  : count         - number of strongest carriers
+|               index         - index of carriers
+|               status        - status of carriers
+|               select_status - status which should be used for selection
+|
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_find_strongest_with_status ( UBYTE *count,
+UBYTE *index,
+UBYTE  select_status,
+UBYTE  maximum,
+UBYTE  limitation )
+{
+UBYTE          strgst_idx;         /* used for counting                       */
+UBYTE          mval_idx;           /* used for counting                       */
+UBYTE          k;                  /* used for counting                       */
+BOOL           cells_left = TRUE;  /* indicates whether there are more cells  */
+/* which may belong to the strongest       */
+SHORT          max_rla_p;          /* next maximum RLA_P value                */
+UBYTE          idx_next_max;       /* index of the cell with the next max.    */
+/* RLA_P value                             */
+BOOL           one_of_six_flag;    /* indicates whether a cell already        */
+/* belongs to the strongest                */
+BOOL           limit;              /* indicator for limitation precedence     */
+BOOL           scell_is_high_band; /* serving cell is in DCS or PCS band      */
+BOOL           ncell_is_high_band; /* neighbour cell is in DCS or PCS band    */
+UBYTE          max_found_cell = MINIMUM( *count + maximum, CS_MAX_STRONG_CARRIER );
+/* maximum number of strongest neighbour   */
+/* cells that should be found after        */
+/* leaving this function                   */
+USHORT         low_channel;
+USHORT         high_channel;
+T_NC_MVAL  *nc_mval;
+TRACE_FUNCTION( "cs_find_strongest_with_status" );
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+if( std EQ STD_DUAL_US OR std EQ STD_900_1900 OR
+std EQ STD_850_900_1900 )
+#else
+if( std EQ STD_DUAL_US )
+#endif
+{
+low_channel  = LOW_CHANNEL_1900;
+high_channel = HIGH_CHANNEL_1900;
+}
+else
+{
+low_channel  = LOW_CHANNEL_1800;
+high_channel = HIGH_CHANNEL_1800;
+}
+for( strgst_idx = *count;
+strgst_idx < max_found_cell AND cells_left;
+strgst_idx++ )
+{
+max_rla_p    = -1;
+idx_next_max = 0xFF;
+for( mval_idx = 0; mval_idx < MAX_NR_OF_NC_MVAL; mval_idx++  )
+{
+nc_mval = &grr_data->db.nc_mval_list.nc_mval[mval_idx];
+if( nc_mval->status EQ NC_MVAL_STAT_ASSIGNED  )
+{
+one_of_six_flag = FALSE;
+for( k = 0; k < *count AND one_of_six_flag EQ FALSE; k++ )
+{
+if( mval_idx EQ index[k] )
+{
+one_of_six_flag = TRUE;
+}
+}
+if( one_of_six_flag     EQ FALSE                    AND
+nc_mval->rla_p.stat EQ select_status            AND
+#ifdef _TARGET_
+nc_mval->rla_p.lev  >= MIN_RXLEV_FOR_SIX_STRGST AND
+#endif /* #ifdef _TARGET_ */
+nc_mval->rla_p.lev  >  max_rla_p                    )
+{
+switch( limitation )
+{
+default:
+TRACE_ASSERT( limitation EQ CS_NO_BAND_LIMITATION OR
+limitation EQ CS_EXCLUDE_SC_BAND    OR
+limitation EQ CS_ONLY_SC_BAND          );
+/*lint -fallthrough*/
+/*
+* fallthrough statement inserted to pass lint process,
+* error 644: (Warning -- limit may not have been initialized)
+*/
+case( CS_NO_BAND_LIMITATION ):
+limit = FALSE;
+break;
+case( CS_EXCLUDE_SC_BAND ):
+scell_is_high_band =
+( psc_db->pbcch.bcch.arfcn >= low_channel  AND
+psc_db->pbcch.bcch.arfcn <= high_channel     );
+ncell_is_high_band =
+( nc_mval->arfcn >= low_channel  AND
+nc_mval->arfcn <= high_channel     );
+limit = ( scell_is_high_band EQ ncell_is_high_band  );
+break;
+case( CS_ONLY_SC_BAND ):
+scell_is_high_band =
+( psc_db->pbcch.bcch.arfcn >= low_channel  AND
+psc_db->pbcch.bcch.arfcn <= high_channel     );
+ncell_is_high_band =
+( nc_mval->arfcn >= low_channel  AND
+nc_mval->arfcn <= high_channel     );
+limit = ( scell_is_high_band NEQ ncell_is_high_band );
+break;
+}
+/*
+* limitation may take precedence,
+* do not consider neighbour cell in case
+*/
+if( limit EQ FALSE )
+{
+max_rla_p    = nc_mval->rla_p.lev;
+idx_next_max = mval_idx;
+}
+}
+}
+}
+if( idx_next_max EQ 0xFF )
+{
+cells_left = FALSE;
+}
+else
+{
+index[strgst_idx] = idx_next_max;
+(*count)++;
+}
+}
+} /* cs_find_strongest_with_status() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_update_strongest
++------------------------------------------------------------------------------
+| Description : The function cs_update_strongest() updates the list of the
+|               strongest neighbour cells stored in the database.
+|
+| Parameters  : cnt_strgst - number of strongest carriers
+|               cnt_candid - number of strongest plus candidate carriers
+|               index      - index of carriers
+|               status     - status of carriers
+|               fn_offset  - frame number offset
+|
++------------------------------------------------------------------------------
+*/
+LOCAL BOOL cs_update_strongest ( UBYTE  cnt_strgst,
+UBYTE  cnt_candid,
+UBYTE *index,
+ULONG  fn_offset )
+{
+UBYTE i, j;          /* used for counting                                  */
+ULONG avail_time[CS_MAX_STRONG_CARRIER];
+/* used to store the times when a cell becomes first  */
+/* a cell of the strongest carriers for a possible    */
+/* rearrangment of the list of the strongest carriers */
+T_NC_SIX_STRGST *six_strgst;
+T_NC_SIX_STRGST *six_candid;
+BOOL has_changed = ( grr_data->db.cnt_nc_six.candid NEQ cnt_candid );
+TRACE_FUNCTION( "cs_update_strongest" );
+memset( avail_time, 0, sizeof( avail_time ) );
+for( i = 0; i < cnt_candid; i++ )
+{
+/*
+* check whether cell is already inserted in list of strongest carrier
+*/
+six_strgst = NULL;
+six_candid = NULL;
+j          = 0;
+while( j          <  grr_data->db.cnt_nc_six.candid AND
+six_strgst EQ NULL                           AND
+six_candid EQ NULL                               )
+{
+six_candid = &grr_data->db.nc_six_strgst[j];
+if( index[i] EQ six_candid->idx )
+{
+if( j < grr_data->db.cnt_nc_six.strgst )
+{
+six_strgst = six_candid;
+}
+}
+else
+{
+six_candid = NULL;
+j++;
+}
+}
+if( six_strgst NEQ NULL )
+{
+if( six_strgst->avail_time                               <=
+( GPRS_PENALTY_TIME_MAX + 1 ) * 10 * CS_PERIOD_1_SEC    )
+{
+/*
+* the time how long the cell is already inserted
+* is stored up to a limited period
+*/
+avail_time[i] = six_strgst->avail_time + fn_offset;
+}
+else
+{
+avail_time[i] = six_strgst->avail_time;
+}
+}
+else
+{
+if( six_candid EQ NULL )
+{
+has_changed = TRUE;
+}
+if( grr_data->db.old_scell.arfcn EQ
+grr_data->db.nc_mval_list.nc_mval[index[i]].arfcn           AND
+grr_data->db.old_scell.bsic  EQ
+grr_data->db.nc_mval_list.nc_mval[index[i]].sync_info.bsic           )
+{
+/* for the old serving cell timer T shall always set to status expired */
+avail_time[i] =
+( ( GPRS_PENALTY_TIME_MAX + 1 ) * 10 * CS_PERIOD_1_SEC ) + 1;
+}
+}
+}
+for( i = 0; i < cnt_candid; i++ )
+{
+grr_data->db.nc_six_strgst[i].idx        = index[i];
+grr_data->db.nc_six_strgst[i].avail_time = avail_time[i];
+/*
+* every time a new list of strongest carriers is build-up
+* the parameter mode should be set to CS_MODE_IDLE.
+*/
+grr_data->db.nc_six_strgst[i].mode = CS_MODE_IDLE;
+}
+cs_set_cnt_nc_six( cnt_strgst, cnt_candid );
+/*
+* perform some tracing
+*/
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+/* trace the ARFCN */
+{
+USHORT arfcn[CS_MAX_STRONG_CARRIER];
+memset( arfcn, RRGRR_INVALID_ARFCN, sizeof( arfcn ) );
+for( i = 0; i < grr_data->db.cnt_nc_six.candid; i++ )
+{
+arfcn[i] =
+grr_data->db.nc_mval_list.nc_mval[grr_data->db.nc_six_strgst[i].idx].arfcn;
+}
+TRACE_EVENT_P7
+(
+"ARFCN: %6d %6d %6d %6d %6d %6d %6d",
+psc_db->pbcch.bcch.arfcn,
+arfcn[0], arfcn[1], arfcn[2], arfcn[3], arfcn[4], arfcn[5]
+);
+}
+/* trace the BSIC */
+{
+USHORT bsic[CS_MAX_STRONG_CARRIER];
+memset( bsic, RRGRR_INVALID_BSIC, sizeof( bsic ) );
+for( i = 0; i < grr_data->db.cnt_nc_six.candid; i++ )
+{
+bsic[i] =
+grr_data->db.nc_mval_list.nc_mval[grr_data->db.nc_six_strgst[i].idx].sync_info.bsic;
+}
+TRACE_EVENT_P7
+(
+"BSIC : %6d %6d %6d %6d %6d %6d %6d",
+psc_db->pbcch.bcch.bsic,
+bsic[0], bsic[1], bsic[2], bsic[3], bsic[4], bsic[5]
+);
+}
+/* trace the RLA_P */
+{
+UBYTE rla_p[CS_MAX_STRONG_CARRIER];
+UBYTE rxlev_avg[CS_MAX_STRONG_CARRIER];
+memset( rla_p, 0, sizeof( rla_p ) );
+memset( rxlev_avg, 0, sizeof( rxlev_avg ) );
+for( i = 0; i < grr_data->db.cnt_nc_six.candid; i++ )
+{
+rla_p[i] =
+grr_data->db.nc_mval_list.nc_mval[grr_data->db.nc_six_strgst[i].idx].rla_p.lev;
+rxlev_avg[i] =
+grr_data->db.nc_mval_list.nc_mval[grr_data->db.nc_six_strgst[i].idx].rxlev_avg;
+}
+TRACE_EVENT_P7
+(
+"RLA_P: %6d %6d %6d %6d %6d %6d %6d",
+grr_data->db.scell_info.rla_p.lev,
+rla_p[0], rla_p[1], rla_p[2], rla_p[3], rla_p[4], rla_p[5]
+);
+TRACE_EVENT_P7
+(
+"RXLEV_AVG: %6d %6d %6d %6d %6d %6d %6d",
+grr_data->db.scell_info.rxlev_avg,
+rxlev_avg[0], rxlev_avg[1], rxlev_avg[2], rxlev_avg[3], rxlev_avg[4], rxlev_avg[5]
+);
+}
+/* trace the synchronisation status */
+{
+UBYTE sync_stat[CS_MAX_STRONG_CARRIER];
+memset( sync_stat, 0xFF, sizeof( sync_stat ) );
+for( i = 0; i < grr_data->db.cnt_nc_six.candid; i++ )
+{
+sync_stat[i] =
+grr_data->db.nc_mval_list.nc_mval[grr_data->db.nc_six_strgst[i].idx].sync_info.sync.status;
+}
+TRACE_EVENT_P6
+(
+"SYNC :        %6d %6d %6d %6d %6d %6d",
+sync_stat[0], sync_stat[1], sync_stat[2],
+sync_stat[3], sync_stat[4], sync_stat[5]
+);
+}
+}
+#endif /* #if !defined (NTRACE) */
+return( has_changed );
+} /* cs_update_strongest() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_compare_bsic
++------------------------------------------------------------------------------
+| Description : The function cs_compare_bsic() compares the indicated BSIC
+|               with the stored BSICs
+|
+| Parameters  : rrgrr_check_bsic_ind - pointer to primitive
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_compare_bsic ( T_RRGRR_NCELL_SYNC_IND *rrgrr_check_bsic_ind )
+{
+UBYTE      i = 0;
+UBYTE      j;
+UBYTE      nc_mval_idx;
+T_NC_MVAL *nc_mval;
+TRACE_FUNCTION( "cs_compare_bsic" );
+while( i                                          <   RRGRR_MAX_RSLT_NCELL_SYNC_IND AND
+rrgrr_check_bsic_ind->sync_result[i].arfcn NEQ RRGRR_INVALID_ARFCN               )
+{
+if( ( nc_mval = grr_get_nc_mval(  rrgrr_check_bsic_ind->sync_result[i].arfcn,
+RRGRR_INVALID_BSIC, &nc_mval_idx ) ) NEQ NULL )
+{
+switch( rrgrr_check_bsic_ind->sync_result[i].sb_flag )
+{
+case( SB_FOUND ):
+nc_mval->sync_info.bsic                 = rrgrr_check_bsic_ind->sync_result[i].bsic;
+nc_mval->sync_info.sync.status          = STAT_SYNC_OK;
+nc_mval->sync_info.sync.sync_failed_cnt = 0;
+break;
+case( NO_SB_FOUND ):
+nc_mval->sync_info.bsic = RRGRR_INVALID_BSIC;
+if( nc_mval->sync_info.sync.sync_failed_cnt EQ MAX_SYNC_FAILED_CNT )
+{
+nc_mval->sync_info.sync.status          = STAT_SYNC_NONE;
+nc_mval->sync_info.sync.sync_failed_cnt = 0;
+j=0;
+while( j < grr_data->nc_data.c_cell                   AND
+grr_data->nc_data.cell[j].arfcn    NEQ
+nc_mval->arfcn         )
+{
+j++;
+}
+if( j < grr_data->nc_data.c_cell )
+{
+cs_reset_meas_result( &grr_data->nc_data.cell[j] );
+}
+}
+else
+{
+nc_mval->sync_info.sync.status          =  STAT_SYNC_FAILED;
+nc_mval->sync_info.sync.sync_failed_cnt += 1;
+}
+break;
+case( SB_UNKNOWN ):
+if( nc_mval->status EQ NC_MVAL_STAT_PENDING )
+{
+cs_init_nc_mval( nc_mval );
+}
+else
+{
+nc_mval->sync_info.bsic                 = RRGRR_INVALID_BSIC;
+nc_mval->sync_info.sync.status          = STAT_SYNC_NONE;
+nc_mval->sync_info.sync.sync_failed_cnt = 0;
+}
+break;
+}
+}
+if( nc_mval EQ NULL )
+{
+if( ( nc_mval = grr_get_nc_mval( RRGRR_INVALID_ARFCN,
+RRGRR_INVALID_BSIC,
+&nc_mval_idx ) ) NEQ NULL )
+{
+switch( rrgrr_check_bsic_ind->sync_result[i].sb_flag )
+{
+case( SB_FOUND ):
+nc_mval->status                         = NC_MVAL_STAT_PENDING;
+nc_mval->arfcn                          = rrgrr_check_bsic_ind->sync_result[i].arfcn;
+nc_mval->sync_info.bsic                 = rrgrr_check_bsic_ind->sync_result[i].bsic;
+nc_mval->sync_info.sync.status          = STAT_SYNC_OK;
+nc_mval->sync_info.sync.sync_failed_cnt = 0;
+grr_data->cs.is_mval_initialized        = FALSE;
+break;
+case( NO_SB_FOUND ):
+nc_mval->status                         = NC_MVAL_STAT_PENDING;
+nc_mval->arfcn                          = rrgrr_check_bsic_ind->sync_result[i].arfcn;
+nc_mval->sync_info.bsic                 = RRGRR_INVALID_BSIC;
+nc_mval->sync_info.sync.status          = STAT_SYNC_FAILED;
+nc_mval->sync_info.sync.sync_failed_cnt = 0;
+grr_data->cs.is_mval_initialized        = FALSE;
+break;
+case( SB_UNKNOWN ):
+TRACE_EVENT_P1( "cs_compare_bsic: SB_UNKNOWN for %d which is not on measured values list, e.g. after GRR suspension",
+rrgrr_check_bsic_ind->sync_result[i].arfcn );
+break;
+}
+}
+else
+{
+TRACE_EVENT_P1( "cs_compare_bsic: no free entry for measured values found %d",
+rrgrr_check_bsic_ind->sync_result[i].arfcn );
+}
+}
+#ifdef _SIMULATION_
+TRACE_EVENT_P3( "BSIC: %d %d %d",
+rrgrr_check_bsic_ind->sync_result[i].arfcn,
+rrgrr_check_bsic_ind->sync_result[i].sb_flag,
+rrgrr_check_bsic_ind->sync_result[i].bsic );
+#endif /* #ifdef _SIMULATION_ */
+i++;
+}
+cs_trace_nc_mval_lst( );
+} /* cs_compare_bsic() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_get_best_cell
++------------------------------------------------------------------------------
+| Description : The function cs_get_best_cell() checks the start of
+|               cell reselection.
+|               Is a criterion fulfilled for cell reselction, then reading of
+|               best neighbourcell is started.
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_get_best_cell ( T_NC_SIX_STRGST **nc, T_scell_info **sc )
+{
+UBYTE            strgst_idx;
+UBYTE            i;
+T_NC_SIX_STRGST *next_cell;
+BOOL             c31_bc;     /* best neighbour cell priorized           */
+BOOL             c31_nc;     /* next neighbour cell priorized           */
+BOOL             c31_sc;     /* serving cell priorized                  */
+T_ncell_info    *ncell_best; /* best neighbour cell                     */
+T_ncell_info    *ncell_next; /* next neighbour cell                     */
+T_NC_MVAL       *mval_best;  /* measured values for best neighbour cell */
+T_NC_MVAL       *mval_next;  /* measured values for next neighbour cell */
+TRACE_FUNCTION( "cs_get_best_cell" );
+/*
+* start cell reselection if:
+*
+* 1. C1 for the serving cell falls below zero: C1 < 0
+*
+* 2. A non-serving cell is evaluated to be better than the serving cell.
+*
+*    a) The best cell is the cell with the highest value of C32 among those
+*       cells that have the highest PRIOROTY_CLASS among those that fulfill
+*       the criterion C31 >= 0.
+*
+*       Interpretation: If C31 is fulfilled, take cells with highest
+*                       priority and then select the cell with highest
+*                       C32 value.
+*
+*    b) The best cell is the cell with the highest value of C32 among all
+*       cells if no cell fulfill the criterion C31 >= 0.
+*
+*       Interpretation: If C31 is not fulfilled, take the cell with the
+*                       highest C32 value.
+*
+* NOTE: When selecting a neighbour cell to be the new serving cell,
+*       C1 criterion of that cell shall be taken into account.
+*/
+/*
+* set default results
+*/
+*sc        = NULL;
+*nc        = NULL;
+mval_best  = NULL;
+strgst_idx = 0xFF;
+if( grr_data->cs.is_upd_ncell_stat_needed )
+{
+TRACE_EVENT( "cs_get_best_cell: is_upd_ncell_stat_needed EQ TRUE" );
+return;
+}
+if(
+(
+grr_data->db.scell_info.rla_p.stat  NEQ CS_RLA_P_VALID
+)
+OR
+(
+grr_data->db.scell_info.rla_p.stat  EQ  CS_RLA_P_VALID AND
+grr_data->db.scell_info.cr_crit.c1  >=  0              AND
+grr_data->db.scell_info.cell_barred EQ  FALSE
+)
+)
+{
+*sc = &grr_data->db.scell_info;
+}
+/*
+* search the best neighbour cell,
+* this cell should not be used for a cell re-selection attempt before
+*/
+for( i = 0;
+i < grr_data->db.cnt_nc_six.strgst AND *nc EQ NULL;
+i++ )
+{
+*nc        = &grr_data->db.nc_six_strgst[i];
+mval_best  = &grr_data->db.nc_mval_list.nc_mval[(*nc)->idx];
+strgst_idx = i;
+if( (*nc)->mode                      NEQ CS_MODE_IDLE OR
+mval_best->sync_info.sync.status NEQ STAT_SYNC_OK OR
+(*nc)->cr_crit.c1                <   0               )
+{
+*nc        = NULL;
+mval_best  = NULL;
+strgst_idx = 0xFF;
+}
+}
+/*
+* if no best neighbour cell was found inform the caller
+*/
+if( *nc EQ NULL OR mval_best EQ NULL )
+{
+return;
+}
+ncell_best =
+grr_get_ncell_info( mval_best->arfcn, mval_best->sync_info.bsic );
+if( ncell_best EQ NULL )
+{
+TRACE_EVENT( "cs_get_best_cell: ncell_best EQ NULL" );
+*nc        = NULL;
+strgst_idx = 0xFF;
+return;
+}
+/*
+* check whether best neighbour cell is priorized
+*/
+c31_bc = ( (*nc)->cr_crit.c31                    >= 0    AND
+ncell_best->cr_par.cr_par_1.v_hcs_par EQ TRUE     );
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT_P4( "cs_get_best_cell: ncell_best %d %d %d %d",
+mval_best->arfcn,
+mval_best->sync_info.bsic,
+c31_bc,
+ncell_best->cr_par.cr_par_1.hcs_par.gprs_prio_class );
+}
+#endif /* #if !defined (NTRACE) */
+/*
+* look for a better neighbour cell
+*/
+for( i = 0; i < grr_data->db.cnt_nc_six.strgst; i++ )
+{
+next_cell = &grr_data->db.nc_six_strgst[i];
+mval_next = &grr_data->db.nc_mval_list.nc_mval[next_cell->idx];
+if( next_cell->mode                  EQ   CS_MODE_IDLE AND
+next_cell                        NEQ *nc           AND
+mval_next->sync_info.sync.status EQ   STAT_SYNC_OK AND
+next_cell->cr_crit.c1            >=   0                )
+{
+ncell_next =
+grr_get_ncell_info( mval_next->arfcn, mval_next->sync_info.bsic );
+if( ncell_next EQ NULL )
+{
+TRACE_EVENT( "cs_get_best_cell: ncell_next EQ NULL" );
+*nc        = NULL;
+strgst_idx = 0xFF;
+return;
+}
+/*
+* check whether next neighbour cell is priorized
+*/
+c31_nc = ( next_cell->cr_crit.c31                >= 0    AND
+ncell_next->cr_par.cr_par_1.v_hcs_par EQ TRUE     );
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT_P4( "cs_get_best_cell: ncell_next %d %d %d %d",
+mval_next->arfcn,
+mval_next->sync_info.bsic,
+c31_nc,
+ncell_next->cr_par.cr_par_1.hcs_par.gprs_prio_class );
+}
+#endif /* #if !defined (NTRACE) */
+if( c31_bc AND
+c31_nc AND
+(
+( ncell_next->cr_par.cr_par_1.hcs_par.gprs_prio_class EQ
+ncell_best->cr_par.cr_par_1.hcs_par.gprs_prio_class  AND
+next_cell->cr_crit.c32 > (*nc)->cr_crit.c32                )
+OR
+( ncell_next->cr_par.cr_par_1.hcs_par.gprs_prio_class >
+ncell_best->cr_par.cr_par_1.hcs_par.gprs_prio_class      )
+)
+)
+{
+/*
+* priorized cell reselection must be done
+*/
+*nc        = next_cell;
+ncell_best = ncell_next;
+strgst_idx = i;
+}
+else if ( !c31_bc )
+{
+/*
+* check whether next neighbour cell is priorized
+*/
+if( c31_nc )
+{
+/*
+* first priorized cell found
+*/
+c31_bc     = TRUE;
+*nc        = next_cell;
+ncell_best = ncell_next;
+strgst_idx = i;
+}
+else if ( next_cell->cr_crit.c32 > (*nc)->cr_crit.c32 )
+{
+/*
+* until now, no priorized cell found
+*/
+*nc        = next_cell;
+ncell_best = ncell_next;
+strgst_idx = i;
+}
+}
+}
+}
+/*
+* check whether serving cell is priorized
+*/
+c31_sc = ( grr_data->db.scell_info.cr_crit.c31  >= 0    AND
+psc_db->scell_par.cr_par_1.v_hcs_par EQ TRUE     );
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT_P3( "cs_get_best_cell: scell %d %d %d",
+*sc, c31_sc,
+psc_db->scell_par.cr_par_1.hcs_par.gprs_prio_class );
+}
+#endif /* #if !defined (NTRACE) */
+/*
+* check whether cell reselection must be done
+*/
+if(
+(
+*sc EQ NULL
+)
+OR
+(
+c31_bc AND
+c31_sc AND
+(
+( ncell_best->cr_par.cr_par_1.hcs_par.gprs_prio_class EQ
+psc_db->scell_par.cr_par_1.hcs_par.gprs_prio_class     AND
+(*nc)->cr_crit.c32 > grr_data->db.scell_info.cr_crit.c32     )
+OR
+( ncell_best->cr_par.cr_par_1.hcs_par.gprs_prio_class >
+psc_db->scell_par.cr_par_1.hcs_par.gprs_prio_class         )
+)
+)
+OR
+(
+!c31_bc                                                  AND
+!c31_sc                                                  AND
+(*nc)->cr_crit.c32 > grr_data->db.scell_info.cr_crit.c32
+)
+OR
+(
+c31_bc AND
+!c31_sc
+)
+)
+{
+*sc = NULL;
+}
+else
+{
+*nc        = NULL;
+strgst_idx = 0xFF;
+}
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT_P3( "cs_get_best_cell: strong/candid %d %d %d",
+grr_data->db.cnt_nc_six.strgst,
+grr_data->db.cnt_nc_six.candid,
+strgst_idx );
+}
+#endif /* #if !defined (NTRACE) */
+} /* cs_get_best_cell() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_get_network_ctrl_order
++------------------------------------------------------------------------------
+| Description : The NETWORK_CONTROL_ORDER values NC1 and NC2 shall only apply
+|               in Ready state. In Standby state, the MS shall always use
+|               normal MS control independent of the ordered NC mode.
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_NC_ORDER cs_get_network_ctrl_order ( BOOL consider_gmm_state )
+{
+T_NC_ORDER ctrl_order = NC_NC0;
+TRACE_FUNCTION( "cs_get_network_ctrl_order" );
+if( grr_data->nc2_on )
+{
+if(
+(
+(
+consider_gmm_state     EQ TRUE        AND
+grr_data->cs.gmm_state EQ READY_STATE
+)
+OR
+(
+consider_gmm_state     EQ FALSE
+)
+)
+AND
+(
+grr_data->db.nc_ref_lst.param NEQ NULL
+)
+)
+{
+ctrl_order = grr_data->db.nc_ref_lst.param->ctrl_order;
+}
+}
+#ifdef _SIMULATION_
+TRACE_EVENT_P2( "NETWORK_CONTROL_ORDER: %d, GMM_STATE: %d",
+grr_data->db.nc_ref_lst.param EQ NULL ?
+ctrl_order : grr_data->db.nc_ref_lst.param->ctrl_order,
+grr_data->cs.gmm_state );
+#endif /* #ifdef _SIMULATION_ */
+return( ctrl_order );
+} /* cs_get_network_ctrl_order() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_reset_nc_change_mark
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_reset_nc_change_mark ( T_SC_DATABASE *db )
+{
+TRACE_FUNCTION( "cs_reset_nc_change_mark" );
+db->nc_cw.list.chng_mrk.curr         = 0;
+db->nc_cw.list.chng_mrk.prev         = 0;
+db->nc_cw.param.chng_mrk.curr        = 0;
+db->nc_cw.param.chng_mrk.prev        = 0;
+db->nc_ms.ncmeas.list.chng_mrk.curr  = 0;
+db->nc_ms.ncmeas.list.chng_mrk.prev  = 0;
+db->nc_ms.ncmeas.param.chng_mrk.curr = 0;
+db->nc_ms.ncmeas.param.chng_mrk.prev = 0;
+} /* cs_reset_nc_change_mark() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_get_cr_meas_mode
++------------------------------------------------------------------------------
+| Description : The function cs_get_cr_meas_mode() returns the cell
+|               re-selection measurement mode used in context of TBF
+|               establishment.
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL UBYTE cs_get_cr_meas_mode ( void )
+{
+TRACE_FUNCTION( "cs_get_cr_meas_mode" );
+return( grr_is_pbcch_present() ? CS_CRMM_BA_GPRS : CS_CRMM_BA_BCCH );
+} /* cs_get_cr_meas_mode() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_send_cr_meas_req
++------------------------------------------------------------------------------
+| Description : The function cs_send_cr_meas_req() sends the cell reselection
+|               measurement request to L1 (MPHP_CR_MEAS_REQ)
+|
+| Parameters  : dummy - description of parameter dummy
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_send_cr_meas_req ( UBYTE del_meas_rslt )
+{
+BOOL           is_pbcch_present = grr_is_pbcch_present( );
+UBYTE          i, j,number_of_frequencies;
+BOOL           is_existing;
+BOOL           v_cs_par[MAX_NR_OF_NCELL];
+T_NC_ORDER     nc_ord  = cs_get_network_ctrl_order( TRUE );
+T_NC_REF_LIST *nc_list = &grr_data->db.nc_ref_lst;
+TRACE_FUNCTION( "cs_send_cr_meas_req" );
+{
+/*
+* first value represents the arfcn of the serving cell
+*/
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+grr_data->nc_data.cell[0].arfcn =  psc_db->pbcch.bcch.arfcn;
+#else
+grr_data->nc_data.cell[0].arfcn =  grr_g23_arfcn_to_l1( psc_db->pbcch.bcch.arfcn );
+#endif
+number_of_frequencies           = 1;
+memset( v_cs_par, ( is_pbcch_present ? FALSE : TRUE ), sizeof( v_cs_par ) );
+for( i = 0; i < nc_list->number; i++ )
+{
+if( is_pbcch_present )
+{
+v_cs_par[i] |= nc_list->info[i]->v_cr_par;
+}
+for( j = i + 1, is_existing = FALSE;
+j < nc_list->number AND is_existing EQ FALSE;
+j++ )
+{
+if( nc_list->info[j]->arfcn EQ nc_list->info[i]->arfcn )
+{
+is_existing  = TRUE;
+if( is_pbcch_present )
+{
+v_cs_par[j] |= nc_list->info[i]->v_cr_par;
+}
+}
+}
+if( !is_existing                                                  AND
+( nc_ord EQ NC_NC2 OR ( nc_ord NEQ NC_NC2 AND v_cs_par[i] ) )     )
+{
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+grr_data->nc_data.cell[number_of_frequencies].arfcn = nc_list->info[i]->arfcn;
+#else
+grr_data->nc_data.cell[number_of_frequencies].arfcn =
+grr_g23_arfcn_to_l1( nc_list->info[i]->arfcn );
+#endif
+number_of_frequencies++;
+}
+}
+if( del_meas_rslt EQ CS_DELETE_MEAS_RSLT )
+{
+cs_reuse_old_cell_rxlev( );
+}
+grr_data->nc_data.c_cell = number_of_frequencies;
+cs_req_cr_meas( );
+}
+} /* cs_send_cr_meas_req() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_send_cr_meas_stop_req
++------------------------------------------------------------------------------
+| Description : The function cs_send_cr_meas_stop_req() sends the cell
+|               reselection measurement stop request to L1
+|               (MPHP_CR_MEAS_STOP_REQ)
+|
+| Parameters  : dummy - description of parameter dummy
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_send_cr_meas_stop_req ( void )
+{
+TRACE_FUNCTION( "cs_send_cr_meas_stop_req" );
+grr_data->nc_data.c_cell   = 0;
+grr_data->cs.cr_meas_mode  = cs_get_cr_meas_mode( );
+cs_stop_cr_meas( );
+} /* cs_send_cr_meas_stop_req() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_send_update_ba_req
++------------------------------------------------------------------------------
+| Description : The function cs_send_update_ba_req() updates the BA(BCCH) list
+|               by passing the lists of added and removed frequencies.
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_send_update_ba_req ( T_SC_DATABASE *db )
+{
+UBYTE            i, j;     /* used for counting */
+BOOL             is_found;
+T_add_freq_list *afreq;
+T_ncell_info    *ncinfo;
+T_NC_ORDER       ctrl_order = cs_get_network_ctrl_order( FALSE );
+TRACE_FUNCTION( "cs_send_update_ba_req" );
+{
+PALLOC( rrgrr_upd_ba_req, RRGRR_UPDATE_BA_REQ );
+/* process cell type */
+rrgrr_upd_ba_req->cell_type = SYNC_SCELL;
+/* process NC mode */
+switch( ctrl_order )
+{
+case NC_NC2:   rrgrr_upd_ba_req->nc_mode = NC2_USED;     break;
+case NC_RESET: rrgrr_upd_ba_req->nc_mode = NC_RESET;     break;
+default    :   rrgrr_upd_ba_req->nc_mode = NC2_NOT_USED; break;
+}
+/* process list of removed frequencies */
+if( db->nc_ms.rfreq.number > RRGRR_BA_LIST_SIZE )
+{
+TRACE_ERROR ( "Number of removed frequencies > RRGRR_BA_LIST_SIZE" );
+}
+i = 0;
+while( i < db->nc_ms.rfreq.number AND i < RRGRR_BA_LIST_SIZE )
+{
+j        = 0;
+is_found = FALSE;
+while( j < db->nc_cw.list.number AND is_found EQ FALSE )
+{
+if( db->nc_cw.list.info[j].index EQ db->nc_ms.rfreq.idx[i] )
+{
+is_found = TRUE;
+}
+else
+{
+j++;
+}
+}
+if( is_found EQ TRUE )
+{
+rrgrr_upd_ba_req->rm_freq_list[i].arfcn = db->nc_cw.list.info[j].arfcn;
+rrgrr_upd_ba_req->rm_freq_list[i].bsic  = db->nc_cw.list.info[j].bsic;
+}
+else
+{
+TRACE_ERROR( "Removed frequency cannot be found in nc_cw structure" );
+}
+i++;
+}
+if( i < RRGRR_BA_LIST_SIZE )
+{
+rrgrr_upd_ba_req->rm_freq_list[i].arfcn = RRGRR_INVALID_ARFCN;
+rrgrr_upd_ba_req->rm_freq_list[i].bsic  = RRGRR_INVALID_BSIC;
+}
+#ifdef _SIMULATION_
+i++;
+while( i < RRGRR_BA_LIST_SIZE )
+{
+rrgrr_upd_ba_req->rm_freq_list[i].arfcn = RRGRR_INVALID_ARFCN;
+rrgrr_upd_ba_req->rm_freq_list[i].bsic  = RRGRR_INVALID_BSIC;
+i++;
+}
+#endif /* #ifdef _SIMULATION_  */
+/* process list of added frequencies */
+if( db->nc_ms.ncmeas.list.number > RRGRR_BA_LIST_SIZE )
+{
+TRACE_ERROR ( "Number of added frequencies > RRGRR_BA_LIST_SIZE" );
+}
+i = 0;
+while( i < db->nc_ms.ncmeas.list.number AND i < RRGRR_BA_LIST_SIZE )
+{
+afreq        = &rrgrr_upd_ba_req->add_freq_list[i];
+ncinfo       = &db->nc_ms.ncmeas.list.info[i];
+afreq->arfcn = ncinfo->arfcn;
+afreq->bsic  = ncinfo->bsic;
+if( ncinfo->v_cr_par EQ TRUE )
+{
+afreq->v_cr_par = TRUE;
+afreq->cr_par.cell_bar_access_2       = ncinfo->cr_par.cell_ba;
+afreq->cr_par.exc_acc                 = ncinfo->cr_par.exc_acc;
+afreq->cr_par.same_ra_as_serving_cell = ncinfo->cr_par.same_ra_scell;
+afreq->cr_par.gprs_rxlev_access_min   = ncinfo->cr_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min;
+afreq->cr_par.gprs_ms_txpwr_max_cch   = ncinfo->cr_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch;
+afreq->cr_par.gprs_temporary_offset   = ncinfo->cr_par.cr_offset.gprs_temp_offset;
+afreq->cr_par.gprs_penalty_time       = ncinfo->cr_par.cr_offset.gprs_penalty_time;
+afreq->cr_par.gprs_reselect_offset    = ncinfo->cr_par.gprs_resel_off;
+afreq->cr_par.priority_class          = ncinfo->cr_par.cr_par_1.hcs_par.gprs_prio_class;
+afreq->cr_par.hcs_thr                 = ncinfo->cr_par.cr_par_1.hcs_par.gprs_hcs_thr;
+afreq->cr_par.si13_location           = SI13_LOC_INVALID;
+afreq->cr_par.pbcch_location          = PBCCH_LOC_INVALID;
+afreq->cr_par.psi1_repeat_period      = PSI1_RPT_PRD_INVALID;
+if( ncinfo->cr_par.v_si13_pbcch )
+{
+if( ncinfo->cr_par.si13_pbcch.v_si13_location )
+{
+afreq->cr_par.si13_location       = ncinfo->cr_par.si13_pbcch.si13_location;
+}
+else
+{
+afreq->cr_par.pbcch_location      = ncinfo->cr_par.si13_pbcch.pbcch_location;
+afreq->cr_par.psi1_repeat_period  = ncinfo->cr_par.si13_pbcch.psi1_repeat_period - 1;
+}
+}
+}
+else
+{
+afreq->v_cr_par = FALSE;
+}
+i++;
+}
+if( i < RRGRR_BA_LIST_SIZE )
+{
+rrgrr_upd_ba_req->add_freq_list[i].arfcn = RRGRR_INVALID_ARFCN;
+rrgrr_upd_ba_req->add_freq_list[i].bsic  = RRGRR_INVALID_BSIC;
+}
+#ifdef _SIMULATION_
+i++;
+while( i < RRGRR_BA_LIST_SIZE )
+{
+rrgrr_upd_ba_req->add_freq_list[i].arfcn = RRGRR_INVALID_ARFCN;
+rrgrr_upd_ba_req->add_freq_list[i].bsic  = RRGRR_INVALID_BSIC;
+i++;
+}
+#endif /* #ifdef _SIMULATION_  */
+PSEND( hCommRR, rrgrr_upd_ba_req );
+}
+} /* cs_send_update_ba_req() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_send_meas_rep_req
++------------------------------------------------------------------------------
+| Description : The function cs_send_meas_rep_req() updates RR with cause
+|               NC_START_MEAS or NC_REPORT_MEAS or NC_STOP_MEAS.
+|
+| Parameters  : NC_START_MEAS  - start the measurement
+|               NC_REPORT_MEAS - report the measurement
+|               NC_STOP_MEAS   - stop the measurement
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_send_meas_rep_req ( UBYTE cause )
+{
+TRACE_FUNCTION( "cs_send_meas_rep_req" );
+{
+PALLOC( rrgrr_meas_rep_req, RRGRR_MEAS_REP_REQ );
+rrgrr_meas_rep_req->meas_cause = grr_data->cs_meas.nc_meas_cause = cause;
+PSEND( hCommRR, rrgrr_meas_rep_req );
+}
+} /* cs_send_meas_rep_req() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_store_meas_rep_cnf
++------------------------------------------------------------------------------
+| Description : ...
+|
+| Parameters  : ...
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_store_meas_rep_cnf ( T_RRGRR_MEAS_REP_CNF *rrgrr_meas_rep_cnf )
+{
+UBYTE      i;        /* used for counting */
+UBYTE      mval_idx;
+T_NC_MVAL *mval;
+TRACE_FUNCTION( "cs_store_meas_rep_cnf" );
+/*
+* store the first value as serving cell
+*/
+grr_data->db.scell_info.rxlev_avg = rrgrr_meas_rep_cnf->meas_res[0].rxlev;
+/*
+* store the next values as neighbour cells
+*/
+cs_init_nc_mval_lst( );
+for( i = 1;
+i                                     <   RRGRR_MEAS_REP_LIST_SIZE AND
+rrgrr_meas_rep_cnf->meas_res[i].arfcn NEQ RRGRR_INVALID_ARFCN;
+i++ )
+{
+mval = grr_get_nc_mval( RRGRR_INVALID_ARFCN, RRGRR_INVALID_BSIC, &mval_idx );
+if( mval NEQ NULL )
+{
+mval->status                = NC_MVAL_STAT_ASSIGNED;
+mval->arfcn                 = rrgrr_meas_rep_cnf->meas_res[i].arfcn;
+mval->rla_p.stat            = CS_RLA_P_VALID;
+mval->rla_p.lev             =
+mval->rxlev_avg             = rrgrr_meas_rep_cnf->meas_res[i].rxlev;
+mval->sync_info.bsic        = rrgrr_meas_rep_cnf->meas_res[i].bsic;
+mval->sync_info.sync.status = STAT_SYNC_OK;
+grr_data->cs.is_mval_initialized = FALSE;
+}
+else
+{
+TRACE_EVENT_P2( "No free entry for measured value found: %d %d",
+rrgrr_meas_rep_cnf->meas_res[i].arfcn,
+rrgrr_meas_rep_cnf->meas_res[i].bsic );
+}
+}
+} /* cs_store_meas_rep_cnf() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_build_strongest
++------------------------------------------------------------------------------
+| Description : ...
+|
+| Parameters  : ...
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_build_strongest ( void )
+{
+UBYTE i;
+UBYTE count = 0;
+UBYTE index[CS_MAX_STRONG_CARRIER];
+TRACE_FUNCTION( "cs_build_strongest" );
+cs_find_strongest_with_status
+( &count, index, CS_RLA_P_VALID,
+(UBYTE)( CS_MAX_STRONG_CARRIER - count ), CS_NO_BAND_LIMITATION );
+for( i = 0; i < count; i++ )
+{
+grr_data->db.nc_six_strgst[i].idx = index[i];
+}
+cs_set_cnt_nc_six( count, count );
+} /* cs_build_strongest() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_send_meas_rpt
++------------------------------------------------------------------------------
+| Description : This function ...
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL cs_send_meas_rpt ( BOOL perform_init )
+{
+BOOL            rpt_snd;
+T_U_MEAS_REPORT meas_rpt;
+TRACE_FUNCTION( "cs_send_meas_rpt" );
+if( perform_init EQ TRUE )
+{
+grr_data->cs_meas.pmr_snd_ref = 0;
+}
+memset(&meas_rpt, 0, sizeof(T_U_MEAS_REPORT));
+rpt_snd = cs_build_meas_rpt( &meas_rpt );
+if( rpt_snd EQ TRUE )
+{
+sig_cs_ctrl_meas_report( &meas_rpt );
+}
+return( rpt_snd );
+} /* cs_send_meas_rpt() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_start_t_reselect
++------------------------------------------------------------------------------
+| Description : ...
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_start_t_reselect ( void )
+{
+TRACE_FUNCTION( "cs_start_t_reselect" );
+if( grr_t_status( T_RESELECT ) EQ 0 )
+{
+vsi_t_start( GRR_handle, T_RESELECT, T_RESELECT_VALUE );
+TRACE_EVENT( "Timer T_RESELECT started" );
+}
+} /* cs_start_t_reselect() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_stop_t_reselect
++------------------------------------------------------------------------------
+| Description : ...
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_stop_t_reselect ( void )
+{
+TRACE_FUNCTION( "cs_stop_t_reselect" );
+if( grr_t_status( T_RESELECT ) NEQ 0 )
+{
+vsi_t_stop( GRR_handle, T_RESELECT );
+TRACE_EVENT( "Timer T_RESELECT stopped" );
+}
+} /* cs_stop_t_reselect() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_process_t3158
++------------------------------------------------------------------------------
+| Description : ...
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_process_t3158 ( void )
+{
+T_TIME reporting_period;
+T_TIME time_to_go;
+BOOL   tmr_3158_rng_le_rp = FALSE;
+TRACE_FUNCTION( "cs_process_t3158" );
+if( cs_is_meas_reporting( ) )
+/* Implies NC measurement conditions are satisfied. May mean Enhanced
+measurement conditions are also satisfied */
+{
+switch( grr_data->cs_meas.packet_mode )
+{
+case( PACKET_MODE_PIM ):
+case( PACKET_MODE_PAM ):
+reporting_period = cs_get_nc_rpt_prd_idle( );
+break;
+case( PACKET_MODE_PTM ):
+/*
+* In packet transfer mode, the reporting period is indicated in
+* NC_REPORTING_PERIOD_T.
+*/
+reporting_period =
+GET_NC_RPT_PRD( grr_data->db.nc_ref_lst.param->rep_per_t );
+break;
+default:
+if( GET_STATE( CS ) EQ CS_CR_NETWORK )
+{
+/*
+* In case timer T3158 expires during processing of Packet Cell Change
+* Order, the timer should be re-started and not stopped at all.
+*/
+reporting_period = cs_get_nc_rpt_prd_idle( );
+}
+else
+{
+reporting_period = 0;
+}
+break;
+}
+time_to_go = grr_t_status( T3158 );
+if( time_to_go > 0 )
+{
+if( time_to_go > reporting_period )
+{
+cs_stop_t3158( );
+if(  grr_is_pbcch_present( ) EQ FALSE      AND
+grr_data->cs_meas.nc_meas_cause NEQ NC_STOP_MEAS   )
+{
+cs_send_meas_rep_req ( NC_STOP_MEAS );
+}
+}
+else
+{
+tmr_3158_rng_le_rp = TRUE;
+}
+}
+if( reporting_period NEQ 0 )
+{
+if( tmr_3158_rng_le_rp EQ FALSE )
+{
+cs_reset_all_rxlev_results( );
+cs_start_t3158( reporting_period );
+/*
+* Start rx_lev averaging when NC=1 or NC=2 in ALR
+*/
+if(  grr_is_pbcch_present( ) EQ FALSE     AND
+grr_data->cs_meas.nc_meas_cause EQ NC_STOP_MEAS   )
+{
+cs_send_meas_rep_req ( NC_START_MEAS ) ;
+}
+}
+}
+else
+{
+cs_reset_all_rxlev_results( );
+}
+}
+else
+{
+cs_reset_all_rxlev_results( );
+cs_stop_t3158( );
+/*
+* Stop rx_lev averaging when NC=1 or NC=2 in ALR
+*/
+if(  grr_is_pbcch_present( ) EQ FALSE      AND
+grr_data->cs_meas.nc_meas_cause NEQ NC_STOP_MEAS   )
+{
+cs_send_meas_rep_req ( NC_STOP_MEAS );
+}
+}
+} /* cs_process_t3158() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_start_t3158
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_start_t3158 ( T_TIME time )
+{
+TRACE_FUNCTION( "cs_start_t3158" );
+vsi_t_start( GRR_handle, T3158, time );
+TRACE_EVENT_P1( "T3158: %d", time );
+} /* cs_start_t3158() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_stop_t3158
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_stop_t3158 ( void )
+{
+TRACE_FUNCTION( "cs_stop_t3158" );
+if( grr_t_status( T3158 ) > 0 )
+{
+vsi_t_stop( GRR_handle, T3158 );
+TRACE_EVENT( "T3158 stopped" );
+}
+} /* cs_stop_t3158() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_cancel_meas_report
++------------------------------------------------------------------------------
+| Description : ...
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_cancel_meas_report ( void )
+{
+TRACE_FUNCTION( "cs_cancel_meas_report" );
+switch( GET_STATE( CS_MEAS ) )
+{
+case CS_MEAS_REP_REQ:
+SET_STATE( CS_MEAS, CS_NULL );
+break;
+case CS_MEAS_PMR_SENDING:
+sig_cs_ctrl_cancel_meas_report( );
+break;
+default:
+/* do nothing */
+break;
+}
+} /* cs_cancel_meas_report() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_build_nc_ref_list
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  : db - pointer to serving cell database
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_build_nc_ref_list ( T_SC_DATABASE *db, BOOL is_dsf )
+{
+TRACE_FUNCTION( "cs_build_nc_ref_list" );
+cs_init_nc_ref_list( &grr_data->db.nc_ref_lst );
+if(
+grr_data->cs.gmm_state EQ READY_STATE AND
+is_dsf                 EQ FALSE       AND
+(
+db->nc_ms.ncmeas.param.ctrl_order EQ NC_NC0 OR
+db->nc_ms.ncmeas.param.ctrl_order EQ NC_NC1 OR
+db->nc_ms.ncmeas.param.ctrl_order EQ NC_NC2
+)
+)
+{
+grr_data->db.nc_ref_lst.param = &db->nc_ms.ncmeas.param;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+grr_data->db.nc_ref_lst.enh_param = &db->enh_ms;
+#endif
+}
+else if( db->nc_cw.param.ctrl_order EQ NC_NC0 OR
+db->nc_cw.param.ctrl_order EQ NC_NC1 OR
+db->nc_cw.param.ctrl_order EQ NC_NC2    )
+{
+grr_data->db.nc_ref_lst.param = &db->nc_cw.param;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+grr_data->db.nc_ref_lst.enh_param = &db->enh_cw;
+#endif
+}
+cs_build_nc_freq_list( db );
+cs_reorg_nc_mval_lst( );
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+if( !grr_is_pbcch_present() AND
+grr_data->db.nc_ref_lst.enh_param->rept_type EQ REPORT_TYPE_ENH_REP)
+{
+cs_init_ba_bcch_nc_ref_list();
+cs_build_ba_bcch_nc_freq_list();
+}
+#endif
+}/* cs_build_nc_ref_list */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_init_nc_ref_list
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  : list  - pointer to NC measurement pointer list
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_init_nc_ref_list ( T_NC_REF_LIST *list )
+{
+TRACE_FUNCTION( "cs_init_nc_ref_list" );
+list->number = 0;
+list->param  = NULL;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+list->enh_param = NULL;
+#endif
+}/* cs_init_nc_ref_list */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_init_nc_mval_lst
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_init_nc_mval_lst ( void )
+{
+UBYTE i;
+TRACE_FUNCTION( "cs_init_nc_mval_lst" );
+if( grr_data->cs.is_mval_initialized EQ FALSE )
+{
+for( i = 0; i < MAX_NR_OF_NC_MVAL; i++ )
+{
+cs_init_nc_mval( &grr_data->db.nc_mval_list.nc_mval[i] );
+}
+grr_data->cs.is_mval_initialized = TRUE;
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT( "cs_init_nc_mval_lst: now initialized" );
+}
+#endif /* #if !defined (NTRACE) */
+}
+else
+{
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT( "cs_init_nc_mval_lst: already initialized" );
+}
+#endif /* #if !defined (NTRACE) */
+}
+}/* cs_init_nc_mval_lst */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_init_nc_mval
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  : mval - pointer to NC measured value
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_init_nc_mval ( T_NC_MVAL *mval )
+{
+TRACE_FUNCTION( "cs_init_nc_mval" );
+mval->arfcn                          = RRGRR_INVALID_ARFCN;
+mval->sync_info.bsic                 = RRGRR_INVALID_BSIC;
+mval->sync_info.sync.status          = STAT_SYNC_NONE;
+mval->sync_info.sync.sync_failed_cnt = 0;
+mval->rla_p.stat                     = CS_RLA_P_NOT_AVAIL;
+mval->rxlev_avg                      = RXLEV_AVG_INVALID;
+mval->status                         = NC_MVAL_STAT_NONE;
+}/* cs_init_nc_mval */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_update_bsic
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_update_bsic ( void )
+{
+UBYTE i
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+,j, k
+#endif
+;
+/* used for counting */
+#if defined (TI_PS_FF_RTD) AND defined (REL99)
+UBYTE i_max,rtd_index,rtd_count;
+#else
+UBYTE i_max;
+#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */
+TRACE_FUNCTION( "cs_update_bsic" );
+i     = 0;
+i_max = MINIMUM( grr_data->db.cnt_nc_six.candid, CS_MAX_STRONG_CARRIER );
+i_max = MINIMUM( i_max, RRGRR_MAX_ARFCN_NCELL_SYNC_REQ );
+if( i_max NEQ 0 )
+{
+PALLOC( rrgrr_check_bsic_req, RRGRR_NCELL_SYNC_REQ );
+while( i < i_max )
+{
+#if defined (TI_PS_FF_RTD) AND defined (REL99)
+rrgrr_check_bsic_req->ncell_sync_list[i].arfcn = grr_data->db.nc_mval_list.nc_mval[grr_data->db.nc_six_strgst[i].idx].arfcn;
+#else
+rrgrr_check_bsic_req->arfcn[i] = grr_data->db.nc_mval_list.nc_mval[grr_data->db.nc_six_strgst[i].idx].arfcn;
+#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */
+i++;
+}
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/* Extend the ARFCN list only if ENH reporting is requested */
+if(cs_is_enh_meas_reporting())
+{
+T_ENH_STRNG_ARFCN_LIST f_bin;/* Stores the ARFCN-RXLEV pair in descending
+order of RXLEV */
+BOOL found; /* Will be set, if ARFCN in f_bin is found in NC_MVAL */
+memset(&f_bin, 0, sizeof(T_ENH_STRNG_ARFCN_LIST));
+/* Form a ARFCN-RXLEV pair list in descending order of RXLEV */
+cs_build_enh_sorted_strng_arfcn_list(&f_bin);
+/* Fill the NCELL_SYNC_REQ with ARFCNs from the above list. This list
+will be filled without disturbing the six strongest cells for
+cell reselection or PMR. The request for SYNC is now done for a
+max of 12 cells with 1st few cells upto a max of six for cell
+reselection and the remaining will be filled with ARFCNs from
+the ENH list in the order of serving band, multiband and the rest
+contains the excess from the above bands, each group containing
+cells in descending order of RXLEV */
+j = 0;
+while(i_max < RRGRR_MAX_ARFCN_NCELL_SYNC_REQ AND j < f_bin.num)
+{
+found = FALSE;
+for(k = 0; k < grr_data->db.cnt_nc_six.candid; k++)
+{
+if(f_bin.meas[j].arfcn EQ
+grr_data->db.nc_mval_list.nc_mval[grr_data->db.nc_six_strgst[k].idx].arfcn)
+{
+found = TRUE;
+break;
+}
+}
+if(!found)
+{
+#if defined (TI_PS_FF_RTD) AND defined (REL99)
+rrgrr_check_bsic_req->ncell_sync_list[i_max].arfcn = f_bin.meas[j].arfcn;
+#else
+rrgrr_check_bsic_req->arfcn[i_max] = f_bin.meas[j].arfcn;
+#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */
+i_max++;
+}
+j++;
+}
+}
+if( i_max < RRGRR_MAX_ARFCN_NCELL_SYNC_REQ )
+{
+#if defined (TI_PS_FF_RTD) AND defined (REL99)
+rrgrr_check_bsic_req->ncell_sync_list[i_max].arfcn = RRGRR_INVALID_ARFCN;
+#else
+rrgrr_check_bsic_req->arfcn[i_max] = RRGRR_INVALID_ARFCN;
+#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */
+} /*if*/
+#if defined (TI_PS_FF_RTD) AND defined (REL99)
+i=0;
+while (i < i_max)
+{
+j = 0;
+rtd_count = 0;
+/*More than 3 RTD values is not acceptable */
+while( j < grr_data->db.nc_ref_lst.number AND rtd_count < MAX_NUM_OF_RTD_VALUES )
+{
+/* Check the NC ARFCN in the BA-list to get the index of that ARFCN in BA-list*/
+if(rrgrr_check_bsic_req->ncell_sync_list[i].arfcn EQ (grr_data->db.nc_ref_lst.info[j])->arfcn)
+{
+/* Pickup the right RTD value for that ARFCN */
+rtd_index = (grr_data->db.nc_ref_lst.info[j])->index;
+/*Maximum number of ncell is 32 if it exceeds then store RTD_NOT_AVAILABLE for that ARFCN*/
+if(rtd_index < MAX_NR_OF_NCELL AND psc_db->rtd[rtd_index] NEQ RTD_NOT_AVAILABLE )
+{
+rrgrr_check_bsic_req->ncell_sync_list[i].v_rtd          = 1;
+rrgrr_check_bsic_req->ncell_sync_list[i].rtd[rtd_count] = psc_db->rtd[rtd_index];
+rtd_count++;
+}/*if*/
+} /*if*/
+j++;
+} /*while*/
+rrgrr_check_bsic_req->ncell_sync_list[i].c_rtd = rtd_count;
+i++;
+} /*while*/
+#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */
+#ifdef _SIMULATION_
+i_max = i_max + 1;
+while( i_max < RRGRR_MAX_ARFCN_NCELL_SYNC_REQ )
+{
+#if defined (TI_PS_FF_RTD) AND defined (REL99)
+rrgrr_check_bsic_req->ncell_sync_list[i_max].arfcn = RRGRR_INVALID_ARFCN;
+#else
+rrgrr_check_bsic_req->arfcn[i_max] = RRGRR_INVALID_ARFCN;
+#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */
+i_max++;
+}
+#endif
+#else
+if( i < RRGRR_MAX_ARFCN_NCELL_SYNC_REQ )
+{
+rrgrr_check_bsic_req->arfcn[i] = RRGRR_INVALID_ARFCN;
+}
+#ifdef _SIMULATION_
+i = i + 1;
+while( i < RRGRR_MAX_ARFCN_NCELL_SYNC_REQ )
+{
+rrgrr_check_bsic_req->arfcn[i] = RRGRR_INVALID_ARFCN;
+i++;
+}
+#endif /* #ifdef _SIMULATION_ */
+#endif /* REL99 AND TI_PS_FF_EMR */
+rrgrr_check_bsic_req->sync_type = SYNC_INITIAL;
+PSEND( hCommRR, rrgrr_check_bsic_req );
+}
+}/* cs_update_bsic */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_find_candidate
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL cs_find_candidate ( void )
+{
+BOOL          is_new_candidate = FALSE;
+T_scell_info *sc;
+TRACE_FUNCTION( "cs_find_candidate" );
+if( grr_data->cs.reselect_cause   EQ CS_RESELECT_CAUSE_CTRL_ABNORMAL AND
+psc_db->gen_cell_par.rab_acc_re EQ GRR_RA_RETRY_DISABLED               )
+{
+grr_data->db.cr_cell = NULL;
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT( "no candidate found, RA retry bit for abnormal cell re-selection not set" );
+}
+#endif /* #if !defined (NTRACE) */
+}
+else if( grr_data->cs.reselect_cause EQ CS_RESELECT_CAUSE_CTRL_SCELL )
+{
+if( cs_create_cr_cell( psc_db->pbcch.bcch.arfcn,
+psc_db->pbcch.bcch.bsic ) NEQ NULL )
+{
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT( "serving cell found as candidate" );
+}
+#endif /* #if !defined (NTRACE) */
+/*
+* the cell re-selection process will be started
+*/
+is_new_candidate = TRUE;
+}
+}
+else
+{
+cs_get_best_cell( &grr_data->db.cr_cell, &sc );
+if( grr_data->db.cr_cell NEQ NULL )
+{
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT( "candidate found" );
+}
+#endif /* #if !defined (NTRACE) */
+/*
+* the cell re-selection process will be started
+*/
+is_new_candidate = TRUE;
+}
+else if( sc NEQ NULL )
+{
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT( "no candidate found, serving cell good" );
+}
+#endif /* #if !defined (NTRACE) */
+/*
+* the serving cell becomes good again or is still good
+*/
+cs_stop_t_reselect( );
+}
+else
+{
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT( "no candidate found, serving cell bad" );
+}
+#endif /* #if !defined (NTRACE) */
+/*
+* the serving cell becomes bad but
+* no suitable neighbour cell is available
+*/
+cs_start_t_reselect( );
+}
+}
+return( is_new_candidate );
+}/* cs_find_candidate */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_cr_decision
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL cs_cr_decision ( T_CRDM mode )
+{
+T_NC_ORDER ctrl_order;
+BOOL       cr_initiated = FALSE;
+TRACE_FUNCTION( "cs_cr_decision" );
+switch( mode )
+{
+case( CRDM_T_RESELECT ):
+sig_cs_ctrl_no_more_candidate( grr_data->cs.reselect_cause );
+cr_initiated = TRUE;
+break;
+case( CRDM_CR_CTRL ):
+ctrl_order = cs_get_network_ctrl_order( TRUE );
+if( ctrl_order                  EQ NC_NC0                       OR
+ctrl_order                  EQ NC_NC1                       OR
+grr_data->cs.reselect_cause EQ CS_RESELECT_CAUSE_CTRL_SCELL            OR
+( grr_data->cs.reselect_cause EQ CS_RESELECT_CAUSE_CTRL_DL_SIG_FAIL    AND
+ctrl_order                  EQ NC_NC2 ) )
+{
+/*
+* Only in case the NETWORK_CONTROL_ORDER is either equal to
+* NC0 or NC1 the MS shall perform automomous cell re-selection
+*/
+if( cs_find_candidate( ) )
+{
+sig_cs_ctrl_new_candidate( grr_data->cs.reselect_cause );
+}
+else
+{
+sig_cs_ctrl_no_more_candidate( grr_data->cs.reselect_cause );
+}
+}
+else
+{
+sig_cs_ctrl_no_more_candidate( grr_data->cs.reselect_cause );
+}
+cr_initiated = TRUE;
+break;
+case( CRDM_CR_INITIAL ):
+ctrl_order = cs_get_network_ctrl_order( TRUE );
+if( ctrl_order EQ NC_NC0 OR ctrl_order EQ NC_NC1 )
+{
+/*
+* Only in case the NETWORK_CONTROL_ORDER is either equal to
+* NC0 or NC1 the MS shall perform automomous cell re-selection
+*/
+grr_data->db.cr_cell = NULL;
+cs_calc_params( );
+if( cs_find_candidate( ) )
+{
+sig_cs_ctrl_new_candidate( grr_data->cs.reselect_cause );
+cr_initiated = TRUE;
+}
+}
+break;
+case( CRDM_CR_CONT ):
+if( cs_find_candidate( ) )
+{
+sig_cs_ctrl_new_candidate( grr_data->cs.reselect_cause );
+}
+else
+{
+sig_cs_ctrl_no_more_candidate( grr_data->cs.reselect_cause );
+}
+cr_initiated = TRUE;
+break;
+default:
+TRACE_ASSERT( mode EQ CRDM_T_RESELECT OR
+mode EQ CRDM_CR_CTRL    OR
+mode EQ CRDM_CR_INITIAL OR
+mode EQ CRDM_CR_CONT       );
+break;
+}
+if( cr_initiated EQ TRUE )
+{
+TRACE_EVENT_P2( "cs_cr_decision: mode %d, reselect_cause %d",
+mode, grr_data->cs.reselect_cause );
+}
+return( cr_initiated );
+}/* cs_cr_decision */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_trace_nc_mval_lst
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_trace_nc_mval_lst ( void )
+{
+#if !defined (NTRACE)
+UBYTE            read, write;
+USHORT           arfcn[8];
+UBYTE            bsic[8];
+T_NC_MVAL_STATUS status[8];
+T_RXLEV_AVG      rxlev_avg[8];
+UBYTE            rla_p_lev[8];
+UBYTE            rla_p_stat[8];
+TRACE_FUNCTION( "cs_trace_nc_mval_lst" );
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+memset( arfcn,  0xFF, sizeof( arfcn  ) );
+memset( bsic,   0xFF, sizeof( bsic   ) );
+memset( status, 0xFF, sizeof( status ) );
+memset( rxlev_avg, 0xFF, sizeof( rxlev_avg ) );
+memset( rla_p_lev, 0xFF, sizeof( rla_p_lev ) );
+memset( rla_p_stat, 0xFF, sizeof( rla_p_stat ) );
+write = 0;
+for( read = 0; read < MAX_NR_OF_NC_MVAL; read++ )
+{
+if( grr_data->db.nc_mval_list.nc_mval[read].status NEQ NC_MVAL_STAT_NONE )
+{
+arfcn[write]  = grr_data->db.nc_mval_list.nc_mval[read].arfcn;
+bsic[write]   = grr_data->db.nc_mval_list.nc_mval[read].sync_info.bsic;
+status[write] = grr_data->db.nc_mval_list.nc_mval[read].status;
+rla_p_lev [write] = grr_data->db.nc_mval_list.nc_mval[read].rla_p.lev;
+rla_p_stat [write] = grr_data->db.nc_mval_list.nc_mval[read].rla_p.stat;
+rxlev_avg [write] = grr_data->db.nc_mval_list.nc_mval[read].rxlev_avg;
+write++;
+}
+if( write EQ 8 )
+{
+TRACE_EVENT_P8
+( "NC_MVAL_LIST ARFCN:  %5d %5d %5d %5d %5d %5d %5d %5d",
+arfcn[0], arfcn[1], arfcn[2], arfcn[3],
+arfcn[4], arfcn[5], arfcn[6], arfcn[7] );
+TRACE_EVENT_P8
+( "NC_MVAL_LIST BSIC:   %5d %5d %5d %5d %5d %5d %5d %5d",
+bsic[0], bsic[1], bsic[2], bsic[3],
+bsic[4], bsic[5], bsic[6], bsic[7] );
+TRACE_EVENT_P8
+( "NC_MVAL_LIST STATUS: %5d %5d %5d %5d %5d %5d %5d %5d",
+status[0], status[1], status[2], status[3],
+status[4], status[5], status[6], status[7] );
+TRACE_EVENT_P8
+( "NC_MVAL_LIST T_RXLEV_AVG: %5d %5d %5d %5d %5d %5d %5d %5d",
+rxlev_avg[0], rxlev_avg[1], rxlev_avg[2], rxlev_avg[3],
+rxlev_avg[4], rxlev_avg[5], rxlev_avg[6], rxlev_avg[7] );
+TRACE_EVENT_P8
+( "NC_MVAL_LIST rla_p.stat: %5d %5d %5d %5d %5d %5d %5d %5d",
+rla_p_stat[0], rla_p_stat[1], rla_p_stat[2], rla_p_stat[3],
+rla_p_stat[4], rla_p_stat[5], rla_p_stat[6], rla_p_stat[7] );
+TRACE_EVENT_P8
+( "NC_MVAL_LIST rla_p.lev: %5d %5d %5d %5d %5d %5d %5d %5d",
+rla_p_lev[0], rla_p_lev[1], rla_p_lev[2], rla_p_lev[3],
+rla_p_lev[4], rla_p_lev[5], rla_p_lev[6], rla_p_lev[7] );
+memset( arfcn,  0xFF, sizeof( arfcn  ) );
+memset( bsic,   0xFF, sizeof( bsic   ) );
+memset( status, 0xFF, sizeof( status ) );
+memset( rxlev_avg, 0xFF, sizeof( rxlev_avg ) );
+memset( rla_p_lev, 0xFF, sizeof( rla_p_lev ) );
+memset( rla_p_stat, 0xFF, sizeof( rla_p_stat ) );
+write = 0;
+}
+}
+if( write NEQ 0 )
+{
+TRACE_EVENT_P8
+( "NC_MVAL_LIST ARFCN:  %5d %5d %5d %5d %5d %5d %5d %5d",
+arfcn[0], arfcn[1], arfcn[2], arfcn[3],
+arfcn[4], arfcn[5], arfcn[6], arfcn[7] );
+TRACE_EVENT_P8
+( "NC_MVAL_LIST BSIC:   %5d %5d %5d %5d %5d %5d %5d %5d",
+bsic[0], bsic[1], bsic[2], bsic[3],
+bsic[4], bsic[5], bsic[6], bsic[7] );
+TRACE_EVENT_P8
+( "NC_MVAL_LIST STATUS: %5d %5d %5d %5d %5d %5d %5d %5d",
+status[0], status[1], status[2], status[3],
+status[4], status[5], status[6], status[7] );
+TRACE_EVENT_P8
+( "NC_MVAL_LIST T_RXLEV_AVG: %5d %5d %5d %5d %5d %5d %5d %5d",
+rxlev_avg[0], rxlev_avg[1], rxlev_avg[2], rxlev_avg[3],
+rxlev_avg[4], rxlev_avg[5], rxlev_avg[6], rxlev_avg[7] );
+TRACE_EVENT_P8
+( "NC_MVAL_LIST rla_p.stat: %5d %5d %5d %5d %5d %5d %5d %5d",
+rla_p_stat[0], rla_p_stat[1], rla_p_stat[2], rla_p_stat[3],
+rla_p_stat[4], rla_p_stat[5], rla_p_stat[6], rla_p_stat[7] );
+TRACE_EVENT_P8
+( "NC_MVAL_LIST rla_p.lev: %5d %5d %5d %5d %5d %5d %5d %5d",
+rla_p_lev[0], rla_p_lev[1], rla_p_lev[2], rla_p_lev[3],
+rla_p_lev[4], rla_p_lev[5], rla_p_lev[6], rla_p_lev[7] );
+}
+}
+#endif /* #if !defined (NTRACE) */
+} /* cs_trace_nc_mval_lst( ) */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_stop_cr_meas
++------------------------------------------------------------------------------
+| Description : The function cs_stop_cr_meas () ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_stop_cr_meas( void )
+{
+TRACE_FUNCTION( "cs_stop_cr_meas" );
+switch( grr_data->cs.cr_meas_mode )
+{
+case( CS_CRMM_BA_GPRS ):
+if( grr_data->cs.stop_req EQ FALSE )
+{
+PALLOC( mphp_cr_meas_stop_req, MPHP_CR_MEAS_STOP_REQ );
+#if 0
+/*
+* the timing for the MPHP_CR_MEAS_STOP_CON is not correct on
+* layer 1 side, so we are no longer consider the confirmation
+*/
+grr_data->cs.stop_req = TRUE;
+#endif /* #if 0 */
+PSEND( hCommL1, mphp_cr_meas_stop_req );
+}
+break;
+case( CS_CRMM_BA_BCCH ):
+grr_data->cs.cr_meas_update = FALSE;
+break;
+}
+} /* cs_stop_cr_meas() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_req_cr_meas
++------------------------------------------------------------------------------
+| Description : The function cs_req_cr_meas () ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_req_cr_meas ( void )
+{
+TRACE_FUNCTION( "cs_req_cr_meas" );
+if( nc_data->c_cell NEQ 0 )
+{
+if( grr_data->cs_meas.packet_mode NEQ PACKET_MODE_PTM )
+{
+PALLOC( mphp_cr_meas_req, MPHP_CR_MEAS_REQ );
+cs_fill_cr_meas_req( mphp_cr_meas_req, grr_data->cs.list_id );
+grr_data->cs.list_id++;
+PSEND( hCommL1, mphp_cr_meas_req );
+}
+else
+{
+PALLOC( mphp_tcr_meas_req, MPHP_TCR_MEAS_REQ );
+grr_data->cs.last_assignment_id++;
+grr_data->cs.cr_meas_update = TRUE;
+cs_fill_cr_meas_req( (T_MPHP_CR_MEAS_REQ*)mphp_tcr_meas_req,
+grr_data->cs.last_assignment_id );
+PSEND( hCommL1, mphp_tcr_meas_req );
+}
+grr_data->cs.stop_req = FALSE;
+}
+} /* cs_req_cr_meas() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_fill_cr_meas_req
++------------------------------------------------------------------------------
+| Description : ...
+|
+| Parameters  : prim - Pointer to primitive buffer
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_fill_cr_meas_req ( T_MPHP_CR_MEAS_REQ *prim, UBYTE id )
+{
+UBYTE i; /* used for counting */
+TRACE_FUNCTION( "cs_fill_cr_meas_req" );
+prim->nb_carrier = nc_data->c_cell;
+prim->list_id    = id;
+for( i = 0; i < nc_data->c_cell; i++ )
+{
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+prim->carrier_list[i] = grr_g23_arfcn_to_l1(nc_data->cell[i].arfcn);
+#else
+prim->carrier_list[i] = nc_data->cell[i].arfcn;
+#endif
+}
+#ifdef _SIMULATION_
+for( i = nc_data->c_cell; i < MPHP_NUMC_BA_GPRS_SC; i++ )
+{
+prim->carrier_list[i] = 0xFFFF;
+}
+#endif /* #ifdef _SIMULATION_ */
+} /* cs_fill_cr_meas_req() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_reset_all_cell_results
++------------------------------------------------------------------------------
+| Description : The function cs_reset_all_cell_results() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_reset_all_cell_results ( void )
+{
+UBYTE i; /* used for counting */
+TRACE_FUNCTION( "cs_reset_all_cell_results" );
+for( i = 0; i < MPHP_NUMC_BA_GPRS_SC; i++ )
+{
+cs_reset_meas_result( &nc_data->cell[i] );
+}
+} /* cs_reset_all_cell_results () */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_reset_all_rxlev_results
++------------------------------------------------------------------------------
+| Description : The function cs_reset_all_rxlev_results() ....
+|
+| Parameters  : ...
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_reset_all_rxlev_results ( void )
+{
+UBYTE i; /* used for counting */
+TRACE_FUNCTION( "cs_reset_all_rxlev_results" );
+for( i = 0; i < MPHP_NUMC_BA_GPRS_SC; i++ )
+{
+nc_data->cell[i].rxlev_data.acc = 0;
+nc_data->cell[i].rxlev_data.nbr = 0;
+}
+} /* cs_reset_all_rxlev_results () */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_reset_meas_result
++------------------------------------------------------------------------------
+| Description : The function cs_reset_meas_result() ....
+|
+| Parameters  : ...
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_reset_meas_result ( T_CELL *cell )
+{
+T_RLA_P_DATA *rla_p_data = &cell->rla_p_data;
+T_RXLEV_DATA *rxlev_data = &cell->rxlev_data;
+UBYTE i; /* used for counting */
+TRACE_FUNCTION( "cs_reset_meas_result" );
+TRACE_EVENT_P2( "cs_reset_meas_result arfcn =%ld LOI=%ld",cell->arfcn,rla_p_data->loi );
+rla_p_data->loi    = CS_IDX_NOT_USED;
+rla_p_data->ovrflw = FALSE;
+for( i = 0; i < CS_MAX_MEAS_RSLT; i++ )
+{
+rla_p_data->meas[i].cnt     = 0;
+rla_p_data->meas[i].acc     = 0;
+rla_p_data->meas[i].rpt_prd = 0;
+}
+rxlev_data->acc = 0;
+rxlev_data->nbr = 0;
+} /* cs_reset_meas_result () */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_fill_meas_rslt
++------------------------------------------------------------------------------
+| Description : ...
+|
+| Parameters  : ...
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_fill_meas_rslt ( T_MPHP_CR_MEAS_IND  *mphp_cr_meas_ind,
+T_MPHP_TCR_MEAS_IND *mphp_tcr_meas_ind  )
+{
+T_RLA_P_DATA *rla_p_data;
+T_RXLEV_DATA *rxlev_data;
+T_RXLEV_DATA_NBR del_nbr;
+UBYTE  i;
+UBYTE  index  = 0;
+BOOL   ovrflw = FALSE;
+UBYTE  cnt;
+SHORT  acc;
+USHORT rpt_prd;
+TRACE_FUNCTION( "cs_fill_meas_rslt" );
+if( mphp_cr_meas_ind NEQ NULL )
+{
+rpt_prd = mphp_cr_meas_ind->reporting_period;
+}
+else
+{
+rpt_prd = CS_RPT_PRD_PTM;
+}
+/*
+* Process all data relevant for RLA_P derivation
+*/
+for( i = 0; i < nc_data->c_cell; i++ )
+{
+rla_p_data = &nc_data->cell[i].rla_p_data;
+rxlev_data = &nc_data->cell[i].rxlev_data;
+if( mphp_cr_meas_ind NEQ NULL )
+{
+cnt = 1;
+	  if((signed char)mphp_cr_meas_ind->p_ncell_meas[i].rxlev <0)
+{
+acc = 0;
+}
+else
+{
+acc = (signed char)mphp_cr_meas_ind->p_ncell_meas[i].rxlev;
+	  }
+}
+else
+{
+cnt = mphp_tcr_meas_ind->acc_nbr[i];
+	   if((SHORT)mphp_tcr_meas_ind->acc_level[i] <0)
+{
+acc = 0;
+}
+else
+{
+acc = mphp_tcr_meas_ind->acc_level[i];
+}
+}
+if( rla_p_data->loi NEQ CS_IDX_NOT_USED )
+{
+if( rla_p_data->loi EQ CS_MAX_MEAS_RSLT - 1 )
+{
+ovrflw = TRUE;
+}
+else
+{
+index = rla_p_data->loi + 1;
+}
+}
+if( cnt EQ 0 )
+{
+if( rla_p_data->meas[index].cnt EQ 0 )
+{
+rla_p_data->meas[index].rpt_prd += rpt_prd;
+}
+else
+{
+rla_p_data->meas[index].cnt      = 0;
+rla_p_data->meas[index].acc      = 0;
+rla_p_data->meas[index].rpt_prd = rpt_prd;
+}
+}
+else
+{
+rla_p_data->meas[index].cnt     = cnt;
+rla_p_data->meas[index].acc     = acc;
+rla_p_data->meas[index].rpt_prd = rpt_prd;
+rla_p_data->loi = index;
+/* if an overflow once occured it will be forever */
+if( rla_p_data->ovrflw EQ FALSE )
+{
+rla_p_data->ovrflw = ovrflw;
+}
+}
+/*
+* Process all data relevant for average RXLEV derivation
+*/
+if( cnt NEQ 0 )
+{
+if( rxlev_data->nbr > RXLEV_MAX_NBR - cnt )
+{
+del_nbr          = cnt - ( RXLEV_MAX_NBR - rxlev_data->nbr );
+rxlev_data->acc -= del_nbr * ( rxlev_data->acc / rxlev_data->nbr );
+rxlev_data->nbr -= del_nbr;
+}
+rxlev_data->acc += ( acc * RXLEV_ACRCY );
+rxlev_data->nbr += cnt;
+}
+}
+} /* cs_fill_meas_rslt() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_get_rla_p
++------------------------------------------------------------------------------
+| Description : The function cs_get_rla_p() ....
+|
+| Parameters  : rla_p_data - pointer to RLA_P raw data
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL cs_get_rla_p( T_RLA_P_DATA *rla_p_data, UBYTE *rla_p )
+{
+BOOL  s_avg;             /* status of average RXLEV value                  */
+LONG  avg;               /* average RXLEV value used for cell re-selection */
+LONG  cnt         = 0;   /* number of accumulated measurement samples      */
+LONG  acc         = 0;   /* accumulated receive level values               */
+ULONG run_avg_prd = 0;   /* running average period                         */
+UBYTE c_meas      = 0;   /* number of measurements                         */
+UBYTE index       = rla_p_data->loi;
+/* index to actual used measurement result  */
+BOOL  v_meas_left = rla_p_data->loi NEQ CS_IDX_NOT_USED;
+/* indicates whether more measurement results     */
+/* are not yet considered                         */
+TRACE_FUNCTION( "cs_get_rla_p" );
+while(
+(
+c_meas      <  CS_MIN_RLA_P_SAMPLES OR
+run_avg_prd <  CS_MIN_RUN_AVG_PRD
+)
+AND
+(
+v_meas_left EQ TRUE
+)
+)
+{
+/*
+* check whether valid measurement results are available
+*/
+if( rla_p_data->meas[index].cnt NEQ 0                AND
+c_meas                      <   CS_MAX_MEAS_RSLT     )
+{
+c_meas++;
+/*
+* accumulate individual measurement results
+*/
+run_avg_prd += rla_p_data->meas[index].rpt_prd;
+cnt         += rla_p_data->meas[index].cnt;
+acc         += rla_p_data->meas[index].acc;
+/* determine the next index to be used for RLA_P calculation */
+if( index EQ 0 )
+{
+if( rla_p_data->ovrflw EQ TRUE )
+{
+index = CS_MAX_MEAS_RSLT - 1;
+}
+else
+{
+v_meas_left= FALSE;
+}
+}
+else
+{
+index--;
+}
+}
+else
+{
+v_meas_left = FALSE;
+}
+}
+/*
+* calculate status of RLA_P
+*/
+if( cnt EQ 0 )
+{
+s_avg = CS_RLA_P_NOT_AVAIL;
+}
+else if(
+(
+c_meas      < CS_MIN_RLA_P_SAMPLES
+)
+OR
+(
+run_avg_prd < CS_MIN_RUN_AVG_PRD
+AND
+c_meas      < CS_MAX_MEAS_RSLT
+)
+)
+{
+s_avg = CS_RLA_P_NOT_VALID;
+}
+else
+{
+s_avg = CS_RLA_P_VALID;
+}
+if( cnt > 0 )
+{
+/*
+* calculate RLA_P
+*/
+avg = acc / cnt;
+/*
+* clip RLA_P to values between 0 and 63
+*/
+if( (signed char)( avg ) < CGRLC_RXLEV_MIN )
+{
+avg = CGRLC_RXLEV_MIN;
+}
+else if ( (signed char)( avg ) > CGRLC_RXLEV_MAX )
+{
+avg = CGRLC_RXLEV_MAX;
+}
+}
+else
+{
+avg = CGRLC_RXLEV_NONE;
+}
+*rla_p = (UBYTE)avg;
+return( s_avg );
+} /* cs_get_rla_p () */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_get_rxlev_avg
++------------------------------------------------------------------------------
+| Description : The function cs_get_rxlev_avg() ....
+|
+| Parameters  : rxlev_data - pointer to RXLEV raw data
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_RXLEV_AVG cs_get_rxlev_avg( T_RXLEV_DATA *rxlev_data )
+{
+T_RXLEV_AVG rxlev_avg;
+TRACE_FUNCTION( "cs_get_rxlev_avg" );
+if( rxlev_data->nbr EQ 0 )
+{
+rxlev_avg = RXLEV_AVG_INVALID;
+}
+else
+{
+rxlev_avg =
+( T_RXLEV_AVG )( rxlev_data->acc / ( rxlev_data->nbr * RXLEV_ACRCY ) );
+}
+TRACE_EVENT_P2("1_cs_get_rxlev_avg: nbr=%ld rx_avg=%ld",rxlev_data->nbr,rxlev_avg);
+return( rxlev_avg );
+} /* cs_get_rxlev_avg () */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_tcr_meas_ind_to_pl
++------------------------------------------------------------------------------
+| Description : The function cs_tcr_meas_ind_to_pl () forwards the cell
+|               re-selection measurement results catched during packet transfer
+|               mode to ALR.
+|
+| Parameters  : prim - pointer to primitive payload
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_tcr_meas_ind_to_pl ( T_MPHP_TCR_MEAS_IND * prim )
+{
+UBYTE i; /* used for counting */
+TRACE_FUNCTION( "cs_tcr_meas_ind_to_pl" );
+{
+PALLOC( tb_meas_ind, TB_MEAS_IND );
+for( i = 0; i < TB_BA_LIST_SIZE; i++ )
+{
+if(( grr_data->cs.cr_meas_update EQ TRUE) AND
+(nc_data->cell[i].arfcn NEQ 0))
+{
+if(nc_data->cell[i].arfcn NEQ 0)
+{
+tb_meas_ind->tb_meas_result[i].arfcn  = grr_g23_arfcn_to_l1(nc_data->cell[i].arfcn);
+}
+else
+{
+tb_meas_ind->tb_meas_result[i].arfcn  = TB_INVALID_ARFCN;
+}
+}
+else
+{
+tb_meas_ind->tb_meas_result[i].arfcn  = TB_INVALID_ARFCN;
+}
+tb_meas_ind->tb_meas_result[i].rxlev    = prim->acc_level[i];
+tb_meas_ind->tb_meas_result[i].num_meas = prim->acc_nbr[i];
+}
+PSEND( hCommPL, tb_meas_ind );
+}
+} /* cs_tcr_meas_ind_to_pl() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_create_cr_cell
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_NC_MVAL* cs_create_cr_cell ( USHORT arfcn, UBYTE  bsic )
+{
+T_NC_MVAL *nc_mval;
+UBYTE      nc_mval_idx;
+TRACE_FUNCTION( "cs_create_cr_cell" );
+/* if the new selected cell is not found in the neighbour cell list */
+nc_mval = grr_get_nc_mval( RRGRR_INVALID_ARFCN, RRGRR_INVALID_BSIC, &nc_mval_idx );
+if( nc_mval NEQ NULL )
+{
+nc_mval->arfcn          = arfcn;
+nc_mval->sync_info.bsic = bsic;
+/*
+* The function cs_create_cr_cell is only called in case of processing a
+* packet cell change order. If the packet cell change order has been
+* received on a cell without PBCCH, GRR should forward the RRGRR_CR_REQ
+* with parameter CR_NEW in all cases. This is forced by setting the
+* synchronisation status to STAT_SYNC_OK.
+*/
+if( grr_is_pbcch_present( ) )
+{
+TRACE_EVENT( "cs_create_cr_cell: cell not part of neighbour cell list" );
+nc_mval->sync_info.sync.status = STAT_SYNC_NONE;
+}
+else
+{
+nc_mval->sync_info.sync.status = STAT_SYNC_OK;
+}
+grr_data->db.cr_cell             = &grr_data->db.nc_nw_slctd.strgst;
+grr_data->db.cr_cell->idx        = nc_mval_idx;
+grr_data->db.cr_cell->mode       = CS_MODE_IDLE;
+grr_data->db.cr_cell->avail_time = 0;
+}
+return( nc_mval );
+} /* cs_create_cr_cell() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_get_nc_rpt_prd_idle
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+LOCAL T_TIME cs_get_nc_rpt_prd_idle ( void )
+{
+T_TIME reporting_period;
+ULONG  small_int_multi; /* smallest integer multiple of DRX period */
+ULONG  drx_period;      /* DRX period in milliseconds              */
+TRACE_FUNCTION( "cs_get_nc_rpt_prd_idle" );
+reporting_period = GET_NC_RPT_PRD( grr_data->db.nc_ref_lst.param->rep_per_i );
+drx_period       = meas_im_get_drx_period_seconds( );
+drx_period       = M_ROUND_UP( drx_period, DRX_NORM_FACTOR );
+/*
+* In packet idle mode, the reporting period is NC_REPORTING_PERIOD_I
+* rounded off to the nearest smaller integer multiple of DRX period
+* if NC_REPORTING_PERIOD_I is greater than DRX period, else, the
+* reporting period is DRX period.
+*/
+if( drx_period NEQ NO_PAGING )
+{
+if( reporting_period > drx_period )
+{
+small_int_multi  = reporting_period / drx_period;
+reporting_period = drx_period * small_int_multi;
+}
+else
+{
+reporting_period = drx_period;
+}
+}
+return( reporting_period );
+} /* cs_get_nc_rpt_prd_idle() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_reset_meas_rep_params
++------------------------------------------------------------------------------
+| Description : This function will reset measurement reporting parameters
+|
+| Parameters  : db - pointer to serving cell database
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_reset_meas_rep_params ( T_SC_DATABASE *db )
+{
+TRACE_FUNCTION( "cs_reset_meas_rep_params" );
+db->nc_ms.ncmeas.param.ctrl_order = NC_RESET;
+db->nc_ms.ncmeas.param.rep_per_i = 0;
+db->nc_ms.ncmeas.param.rep_per_t = 0;
+} /* cs_reset_meas_rep_params() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_check_nc_sync_timer
++------------------------------------------------------------------------------
+| Description : Handles the nc sync timer of 10 sec in case of PIM_PBCCH and
+| PTM_PBCCH
+|
+| Parameters  : reporting_period
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_check_nc_sync_timer(USHORT reporting_pd)
+{
+if(!grr_data->db.cnt_nc_six.candid) return;
+grr_data->cs.nc_sync_rep_pd += reporting_pd;
+if(grr_data->cs.nc_sync_rep_pd >= CS_NCSYNC_RPT_PRD_PIM)
+{
+PALLOC( rrgrr_check_bsic_req, RRGRR_NCELL_SYNC_REQ );
+rrgrr_check_bsic_req->sync_type = SYNC_RECONFIRM;
+PSEND( hCommRR, rrgrr_check_bsic_req );
+/*subtracting nc_sync_rep_pd from CS_NCSYNC_RPT_PRD_PIM wil provide take care
+of periodicity of non-uniform reporting_period values*/
+TRACE_EVENT_P1("GRR_NC_SYNC:EXPIRY: nc_sync_rep_pd=%d", grr_data->cs.nc_sync_rep_pd);
+grr_data->cs.nc_sync_rep_pd -= CS_NCSYNC_RPT_PRD_PIM;
+}
+return;
+}
+/*
++------------------------------------------------------------------------------
+| Function    : cs_process_serving_cell_data
++------------------------------------------------------------------------------
+| Description : This function is used to fill rxlev and interference measurements
+|               of the serving cell
+|
+| Parameters  : rxlev, iscell
+|
++------------------------------------------------------------------------------
+*/
+LOCAL BOOL cs_process_serving_cell_data ( UBYTE *rxlev_scell, UBYTE *v_i_scell,
+UBYTE *i_scell, UBYTE *used_bits,
+BOOL *rsc_avail, BOOL *isc_avail )
+{
+TRACE_FUNCTION( "cs_process_serving_cell_data" );
+*used_bits += NC_RXLEV_SCELL_LEN;
+if( grr_data->db.scell_info.rxlev_avg EQ RXLEV_AVG_INVALID )
+{
+TRACE_ERROR( "cs_build_xxx_meas_rpt no RXLEV of serving cell" );
+return( FALSE );
+}
+else
+{
+*rsc_avail   = TRUE;
+*rxlev_scell = grr_data->db.scell_info.rxlev_avg;
+}
+/* process interference measurement of serving cell */
+*used_bits             += PMR_FLAG_LEN;
+*v_i_scell  = FALSE;
+if( grr_is_pbcch_present( )       EQ  TRUE            AND
+psc_db->paging_group.kc       NEQ 0               AND
+grr_data->cs_meas.packet_mode EQ  PACKET_MODE_PIM     )
+{
+T_p_frequency_par freq_par;
+if( grr_get_pccch_freq_par
+( ( UBYTE )( grr_imsi_mod( ) % psc_db->paging_group.kc ),
+&freq_par.p_chan_sel, &freq_par.p_freq_list ) )
+{
+T_MEAS_IM_CARRIER ma;
+UBYTE             written_bits;
+T_ilev_abs        i_level;
+meas_im_set_carrier( &ma, &freq_par );
+written_bits = meas_im_get_abs_i_level( &ma, &i_level );
+if( written_bits > CGRLC_MAX_TIMESLOTS * PMR_FLAG_LEN )
+{
+*v_i_scell = TRUE;
+*used_bits += NC_IF_SCELL_LEN;
+if     ( i_level.v_ilevabs0 EQ TRUE )
+{
+*i_scell = i_level.ilevabs0;
+*isc_avail = TRUE;
+}
+else if( i_level.v_ilevabs1 EQ TRUE )
+{
+*i_scell = i_level.ilevabs1;
+*isc_avail = TRUE;
+}
+else if( i_level.v_ilevabs2 EQ TRUE )
+{
+*i_scell = i_level.ilevabs2;
+*isc_avail = TRUE;
+}
+else if( i_level.v_ilevabs3 EQ TRUE )
+{
+*i_scell = i_level.ilevabs3;
+*isc_avail = TRUE;
+}
+else if( i_level.v_ilevabs4 EQ TRUE )
+{
+*i_scell = i_level.ilevabs4;
+*isc_avail = TRUE;
+}
+else if( i_level.v_ilevabs5 EQ TRUE )
+{
+*i_scell = i_level.ilevabs5;
+*isc_avail = TRUE;
+}
+else if( i_level.v_ilevabs6 EQ TRUE )
+{
+*i_scell = i_level.ilevabs6;
+*isc_avail = TRUE;
+}
+else if( i_level.v_ilevabs7 EQ TRUE )
+{
+*i_scell = i_level.ilevabs7;
+*isc_avail = TRUE;
+}
+else
+{
+TRACE_ERROR( "cs_process_serving_cell_data corrupted I_LEVEL data" );
+return( FALSE );
+}
+}
+}
+}
+return(TRUE);
+}/* cs_process_serving_cell_data */
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/*
++------------------------------------------------------------------------------
+| Function    : cs_send_enh_meas_rpt
++------------------------------------------------------------------------------
+| Description : This function is used to send enh meas report to the network
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL cs_send_enh_meas_rpt (void)
+{
+T_U_ENHNC_MEAS_REPORT enh_meas_rpt;
+BOOL  rpt_send;
+TRACE_FUNCTION( "cs_send_enh_meas_rpt" );
+if(grr_is_pbcch_present())
+{
+cs_form_enh_cell_list();
+}
+else
+{
+cs_form_ba_bcch_enh_cell_list();
+}
+cs_nc_sort_and_update_emr_info();
+memset (&enh_meas_rpt, 0, sizeof(T_U_ENHNC_MEAS_REPORT));
+rpt_send = cs_build_enh_meas_rpt(&enh_meas_rpt);
+if( rpt_send EQ TRUE )
+{
+sig_cs_ctrl_enh_meas_report(&enh_meas_rpt);
+}
+return(rpt_send);
+} /* cs_send_enh_meas_rpt() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_form_enh_cell_list
++------------------------------------------------------------------------------
+| Description : This function is used to form enhanced cell list from BA list
+|               (nc_ref_lst) and Measured values list(nc_mval_list)
+|
+|
+| Parameters  : Nil
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_form_enh_cell_list(void)
+{
+UBYTE i = 0, n = 0, j;
+UBYTE nc_ref_index_arfcn, nc_ref_index_bsic;
+TRACE_FUNCTION( "cs_form_enh_cell_list" );
+memset((grr_data->db.enh_cell_list), 0xFF, sizeof(T_ENH_CELL_LIST)*MAX_NR_OF_NCELL);
+grr_data->db.cnt_enh_cell_list = 0;
+/* Check one entry of Measured values list against all entries of BA list */
+while(i < MAX_NR_OF_NC_MVAL AND n < MAX_NR_OF_NCELL)
+{
+if( (grr_data->db.nc_mval_list.nc_mval[i].status EQ NC_MVAL_STAT_ASSIGNED)
+AND
+(grr_data->db.nc_mval_list.nc_mval[i].arfcn NEQ RRGRR_INVALID_ARFCN)
+AND
+(grr_data->db.nc_mval_list.nc_mval[i].sync_info.sync.status EQ
+STAT_SYNC_OK)
+AND
+(grr_data->db.nc_mval_list.nc_mval[i].rla_p.stat EQ CS_RLA_P_VALID) )
+{
+nc_ref_index_arfcn = NOT_SET; /* Will be set the 1st time ARFCN matches
+in the BA list */
+nc_ref_index_bsic = NOT_SET;  /* Will be set the 1st time ARFCN-BSIC pair
+matches in the BA list */
+/* Comparison with BA list */
+for (j = 0; j < grr_data->db.nc_ref_lst.number; j++)
+{
+if(grr_data->db.nc_mval_list.nc_mval[i].arfcn EQ
+grr_data->db.nc_ref_lst.info[j]->arfcn)
+{
+if(nc_ref_index_arfcn EQ NOT_SET)
+{
+/* ARFCN matched for the 1st time in BA list */
+nc_ref_index_arfcn  = j;
+}
+/* In case the same cell (ARFCN+BSIC) or the same ARFCN without BSIC
+occur more than once in the resulting GSM Neighbour Cell list,
+each occurrence shall be assigned an index but only the cell with
+the highest index shall be used for cell re-selection and referred
+to in measurement reports. */
+if(grr_data->db.nc_ref_lst.info[j]->index >
+grr_data->db.nc_ref_lst.info[nc_ref_index_arfcn]->index)
+{
+nc_ref_index_arfcn = j;
+}
+if(grr_data->db.nc_mval_list.nc_mval[i].sync_info.bsic EQ
+grr_data->db.nc_ref_lst.info[j]->bsic)
+{
+nc_ref_index_bsic = nc_ref_index_arfcn;
+}
+}
+}
+/* Store ARFCN, BSIC, RLA_P and RXLEV, if ARFCN and/or BSIC matches */
+if(nc_ref_index_arfcn NEQ NOT_SET)
+{
+grr_data->db.enh_cell_list[n].arfcn =
+grr_data->db.nc_mval_list.nc_mval[i].arfcn;
+grr_data->db.enh_cell_list[n].bsic.bsic =
+grr_data->db.nc_mval_list.nc_mval[i].sync_info.bsic;
+grr_data->db.enh_cell_list[n].rla_p =
+grr_data->db.nc_mval_list.nc_mval[i].rla_p.lev;
+grr_data->db.enh_cell_list[n].rxlev_avg =
+grr_data->db.nc_mval_list.nc_mval[i].rxlev_avg;
+}
+/* Store in the enhanced cell list as Valid and Invalid BSICs */
+if (nc_ref_index_bsic NEQ NOT_SET)
+{
+grr_data->db.enh_cell_list[n].index =
+grr_data->db.nc_ref_lst.info[nc_ref_index_bsic]->index;
+grr_data->db.enh_cell_list[n].rept_prio =
+grr_data->db.nc_ref_lst.enh_param->gprs_rept_prio_desc.
+rept_prio[grr_data->db.nc_ref_lst.info[nc_ref_index_bsic]->index];
+grr_data->db.enh_cell_list[n++].bsic.status = BSIC_VALID;
+}
+else if(nc_ref_index_arfcn NEQ NOT_SET)
+{
+grr_data->db.enh_cell_list[n].index =
+grr_data->db.nc_ref_lst.info[nc_ref_index_arfcn]->index;
+/* Set the reporting priority to high for invalid BSICs and allowed
+NCC part. Refer Section 8.4.8.1 of 3GPP TS 05.08 V8.15.0 (2002-06) */
+grr_data->db.enh_cell_list[n].rept_prio = HIGH_PRIO;
+grr_data->db.enh_cell_list[n++].bsic.status = BSIC_INVALID;
+}
+}
+i++;
+}
+grr_data->db.cnt_enh_cell_list = n;
+}/* cs_form_enh_cell_list */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_form_ba_bcch_enh_cell_list
++------------------------------------------------------------------------------
+| Description : This function is used to form enhanced cell list from BA list
+|               (nc_ref_lst) and Measured values list(nc_mval_list)
+|
+|
+| Parameters  : Nil
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_form_ba_bcch_enh_cell_list(void)
+{
+UBYTE i = 0, n = 0, j;
+UBYTE nc_ref_index_arfcn, nc_ref_index_bsic;
+TRACE_FUNCTION( "cs_form_ba_bcch_enh_cell_list" );
+memset((grr_data->db.enh_cell_list), 0xFF, sizeof(T_ENH_CELL_LIST)*MAX_NR_OF_NCELL);
+grr_data->db.cnt_enh_cell_list = 0;
+/* Check one entry of Measured values list against all entries of BA list */
+while(i < MAX_NR_OF_NC_MVAL AND n < MAX_NR_OF_NCELL)
+{
+if( (grr_data->db.nc_mval_list.nc_mval[i].status EQ NC_MVAL_STAT_ASSIGNED)
+AND
+(grr_data->db.nc_mval_list.nc_mval[i].arfcn NEQ RRGRR_INVALID_ARFCN)
+AND
+(grr_data->db.nc_mval_list.nc_mval[i].sync_info.sync.status EQ
+STAT_SYNC_OK)
+AND
+(grr_data->db.nc_mval_list.nc_mval[i].rla_p.stat EQ CS_RLA_P_VALID) )
+{
+nc_ref_index_arfcn = NOT_SET; /* Will be set the 1st time ARFCN matches
+in the BA list */
+nc_ref_index_bsic = NOT_SET; /* Will be set the 1st time ARFCN-BSIC pair
+matches in the BA list */
+/* Comparison with BA list */
+for (j = 0; j < grr_data->db.ba_bcch_nc_ref_lst.number; j++)
+{
+if(grr_data->db.nc_mval_list.nc_mval[i].arfcn EQ
+grr_data->db.ba_bcch_nc_ref_lst.info[j]->arfcn)
+{
+if(nc_ref_index_arfcn EQ NOT_SET)
+{
+/* ARFCN matched for the 1st time in BA list */
+nc_ref_index_arfcn  = j;
+}
+/* In case the same cell (ARFCN+BSIC) or the same ARFCN without BSIC
+occur more than once in the resulting GSM Neighbour Cell list,
+each occurrence shall be assigned an index but only the cell with
+the highest index shall be used for cell re-selection and referred
+to in measurement reports. */
+if(grr_data->db.ba_bcch_nc_ref_lst.info[j]->index >
+grr_data->db.ba_bcch_nc_ref_lst.info[nc_ref_index_arfcn]->index)
+{
+nc_ref_index_arfcn = j;
+}
+if(grr_data->db.nc_mval_list.nc_mval[i].sync_info.bsic EQ
+grr_data->db.ba_bcch_nc_ref_lst.info[j]->bsic)
+{
+nc_ref_index_bsic = nc_ref_index_arfcn;
+}
+}
+}
+/* Store ARFCN, BSIC, RLA_P AND RXLEV, if ARFCN and/or BSIC matches */
+if(nc_ref_index_arfcn NEQ NOT_SET)
+{
+grr_data->db.enh_cell_list[n].arfcn =
+grr_data->db.nc_mval_list.nc_mval[i].arfcn;
+grr_data->db.enh_cell_list[n].bsic.bsic =
+grr_data->db.nc_mval_list.nc_mval[i].sync_info.bsic;
+grr_data->db.enh_cell_list[n].rla_p =
+grr_data->db.nc_mval_list.nc_mval[i].rla_p.lev;
+grr_data->db.enh_cell_list[n].rxlev_avg =
+grr_data->db.nc_mval_list.nc_mval[i].rxlev_avg;
+}
+/* Store in the enhanced cell list as Valid and Invalid BSICs */
+if (nc_ref_index_bsic NEQ NOT_SET)
+{
+grr_data->db.enh_cell_list[n].index =
+grr_data->db.ba_bcch_nc_ref_lst.info[nc_ref_index_bsic]->index;
+grr_data->db.enh_cell_list[n].rept_prio =
+grr_data->db.nc_ref_lst.enh_param->gprs_rept_prio_desc.
+rept_prio[grr_data->db.ba_bcch_nc_ref_lst.info[nc_ref_index_bsic]->index];
+grr_data->db.enh_cell_list[n++].bsic.status = BSIC_VALID;
+}
+else if(nc_ref_index_arfcn NEQ NOT_SET)
+{
+grr_data->db.enh_cell_list[n].index =
+grr_data->db.ba_bcch_nc_ref_lst.info[nc_ref_index_arfcn]->index;
+/* Set the reporting priority to high for invalid BSICs and allowed
+NCC part. Refer Section 8.4.8.1 of 3GPP TS 05.08 V8.15.0 (2002-06) */
+grr_data->db.enh_cell_list[n].rept_prio = HIGH_PRIO;
+grr_data->db.enh_cell_list[n++].bsic.status = BSIC_INVALID;
+}
+}
+i++;
+}
+grr_data->db.cnt_enh_cell_list = n;
+}/* cs_form_ba_bcch_enh_cell_list */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_nc_sort_and_update_emr_info
++------------------------------------------------------------------------------
+| Description : The purpose of this function is to handle all the specific
+|               requirements for EMR - sorting according to priority as given
+|               in 5.08 V8.16.0, sec.8.4.8.1, and scaling of rxlev values.
+|
+|
+| Parameters  : Nil
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_nc_sort_and_update_emr_info(void)
+{
+T_ENH_BIN     sc_bin;
+T_ENH_BIN     mband_bin[5]; /* 0 - 900, 1 - 1800, 2 - 400, 3 - 1900, 4 - 850*/
+T_ENH_BIN     rest_bin;
+UBYTE         i;
+UBYTE         temp;
+T_GRR_ENH_PARA  *p_enh          = grr_data->db.nc_ref_lst.enh_param;
+T_ENH_CELL_LIST *enh_cell_list  = &(grr_data->db.enh_cell_list[0]);
+BOOL            include_cell    = FALSE;
+grr_data->db.sorted_enh_cell_list.num_valid = 0;
+TRACE_FUNCTION( "cs_nc_sort_and_update_emr_info" );
+/* Flush off the old sorted ENH cell list before forming a new one */
+memset(&grr_data->db.sorted_enh_cell_list,0,sizeof(T_ENH_BIN));
+/* Step 1: Sort cells into different bins - serving cell band bin,
+non-serving cell band bin, and the rest which can contain invalid BSIC
+cells */
+cs_nc_sort_cells_into_bins(&sc_bin, mband_bin, &rest_bin);
+/* Step 2: Fill the cells from each bin, after sorting in descending order
+of RXLEV, in the order of : sc_bin, mband_bin and rest_bin.
+Further number of cells from sc_bin and mband_bin is restricted by SERVING_BAND
+and MULTIBAND reporting parameters */
+if ( (sc_bin.num_valid > 0) AND (p_enh->servingband_rep > 0) )
+{
+cs_nc_sort_and_store_meas_results(&sc_bin, p_enh->servingband_rep);
+if (sc_bin.num_valid > p_enh->servingband_rep)
+{
+cs_nc_update_rest_bin(&rest_bin, &sc_bin, p_enh->servingband_rep);
+}
+}
+/* Fill cells from multi band after sorting*/
+for ( i = 0; i < MAX_NUM_BANDS AND
+grr_data->db.sorted_enh_cell_list.num_valid
+< grr_data->db.cnt_enh_cell_list; i++)
+{
+if ( (mband_bin[i].num_valid > 0) AND (p_enh->multiband_rep > 0) )
+{
+cs_nc_sort_and_store_meas_results(&mband_bin[i], p_enh->multiband_rep);
+if (mband_bin[i].num_valid > p_enh->multiband_rep)
+{
+cs_nc_update_rest_bin(&rest_bin, &mband_bin[i], p_enh->multiband_rep );
+}
+}
+}
+/* Now sort cells in the rest bin which may contain both valid and
+invalid BSIC cells. Here we use the reporting offset along with measured RXLEV,
+for sorting. According to 5.08, sec.8.4.8.1 we need to find those cells whose sum of
+RXLEV and xxx_reporting_offset is maximum. This can be acheived by sorting the cells
+in the order of their rxlevm, where rxlevm = rxlev + offset */
+if ( (rest_bin.num_valid > 0) AND (grr_data->db.sorted_enh_cell_list.num_valid
+< grr_data->db.cnt_enh_cell_list) )
+{
+UBYTE     j;
+UBYTE     max_rxlevm;
+UBYTE     band;
+UBYTE     rxlevm;
+UBYTE     k;
+T_ncell_info *ncell;
+for (i = 0; i < rest_bin.num_valid; i++)
+{
+band = cs_get_band_index_for_emr (enh_cell_list[rest_bin.enh_index[i]].arfcn);
+max_rxlevm = enh_cell_list[rest_bin.enh_index[i]].rla_p +
+(p_enh->enh_rep_data[band].rep_offset * 6);
+k = i;
+for ( j = i+1; j < rest_bin.num_valid ; j++ )
+{
+band = cs_get_band_index_for_emr (enh_cell_list[rest_bin.enh_index[j]].arfcn);
+rxlevm = enh_cell_list[rest_bin.enh_index[j]].rla_p +
+(p_enh->enh_rep_data[band].rep_offset * 6) ;
+if ( rxlevm > max_rxlevm )
+{
+k = j;
+max_rxlevm = rxlevm;
+}
+}
+include_cell = TRUE;
+/* When reduced reporting is enabled we have to report low priority cell
+once in 4 reporting periods. The RXLEV then should be average of previous
+two periods */
+if ( (enh_cell_list[rest_bin.enh_index[k]].rept_prio EQ NORMAL_PRIO) AND
+(p_enh->rep_rate EQ REPORTING_RATE_REDUCED) )
+{
+/* ncell cannot be NULL since the loop will be entered only for a
+valid BSIC */
+ncell = grr_get_ncell_info(enh_cell_list[rest_bin.enh_index[k]].arfcn,
+enh_cell_list[rest_bin.enh_index[k]].bsic.bsic);
+/* For every 4th time, we include this cell in the report */
+if ( (ncell->rep_count & (0x03)) EQ 0 )
+{
+/* For those cells that are not reported in every measurement report,
+the MS shall average the measurements of the current and the previous
+reporting period (i.e. over two reporting periods). */
+enh_cell_list[rest_bin.enh_index[k]].rxlev_avg =
+(enh_cell_list[rest_bin.enh_index[k]].rxlev_avg + ncell->last_rxlev) >> 1;
+/* division by 2 */
+}
+else
+{
+ncell->last_rxlev = enh_cell_list[rest_bin.enh_index[k]].rxlev_avg;
+include_cell = FALSE;
+}
+/* modulo 4 addition */
+ncell->rep_count = (ncell->rep_count + 1) & 0x03;
+}
+if (include_cell EQ TRUE)
+{
+grr_data->db.sorted_enh_cell_list.
+enh_index[grr_data->db.sorted_enh_cell_list.num_valid] =
+rest_bin.enh_index[k];
+grr_data->db.sorted_enh_cell_list.num_valid++;
+}
+if(k NEQ i)
+{
+temp = rest_bin.enh_index[k];
+rest_bin.enh_index[k] = rest_bin.enh_index[i];
+rest_bin.enh_index[i] = temp;
+}
+}
+}
+/* This leaves us with final step in neighbour cell measurement reporting - scaling.*/
+grr_data->db.pemr_params.scale_used = cs_nc_scale_rxlev ();
+}/* cs_nc_sort_and_update_emr_info */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_nc_sort_cells_into_bins
++------------------------------------------------------------------------------
+| Description : The purpose of this function is to sort the cells into various
+|               bins. This is the first step in handling reporting priority
+|               as given in 5.08 sec.8.4.8.1
+|
+|
+| Parameters  : Pointers to the three bins
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_nc_sort_cells_into_bins(T_ENH_BIN *p_sbin,T_ENH_BIN *p_mbin,
+T_ENH_BIN *p_rbin)
+{
+UBYTE     i, j;
+UBYTE     band;
+UBYTE     sc_band;
+UBYTE     rth;
+T_ENH_CELL_LIST *enh_cell_list  = &(grr_data->db.enh_cell_list[0]);
+T_GRR_ENH_PARA  *p_enh          = grr_data->db.nc_ref_lst.enh_param;
+TRACE_FUNCTION( "cs_nc_sort_cells_into_bins" );
+memset(p_sbin, 0xFF, sizeof(T_ENH_BIN));
+p_sbin->num_valid = 0;
+memset(p_rbin, 0xFF, sizeof(T_ENH_BIN));
+p_rbin->num_valid = 0;
+for( i = 0; i < MAX_NUM_BANDS; i++)
+{
+memset(&p_mbin[i], 0xFF, sizeof(T_ENH_BIN));
+p_mbin[i].num_valid = 0;
+}
+sc_band = cs_get_band_index_for_emr (psc_db->pbcch.bcch.arfcn);
+for ( j = 0; j < grr_data->db.cnt_enh_cell_list; j++ )
+{
+if(enh_cell_list[j].bsic.status EQ BSIC_VALID) /* Valid BSIC */
+{
+/*Find the band of this arfcn*/
+band = cs_get_band_index_for_emr(enh_cell_list[j].arfcn);
+rth = p_enh->enh_rep_data[band].rep_threshold;
+if (band EQ sc_band )
+{
+/* Apply the threshold criteria for this band*/
+if ( rth NEQ REP_THRESHOLD_INF )
+{
+if((rth EQ REP_THRESHOLD_DEF) OR
+(enh_cell_list[j].rla_p >= (rth * 6)))
+{
+p_sbin->enh_index[p_sbin->num_valid++] = j;
+}
+else
+{
+p_rbin->enh_index[p_rbin->num_valid++] = j;
+}
+} /*otherwise report-never*/
+} /* otherwise cell in non-serving band*/
+else
+{
+/* Apply the threshold criteria for this band*/
+if ( rth NEQ REP_THRESHOLD_INF )
+{
+if((rth EQ REP_THRESHOLD_DEF) OR
+(enh_cell_list[j].rla_p >= (rth * 6)))
+{
+p_mbin[band].enh_index[p_mbin[band].num_valid++] = j;
+}
+else
+{
+p_rbin->enh_index[p_rbin->num_valid++] = j;
+}
+} /*otherwise report never*/
+}
+}
+else /* If there's no cell with the given BSIC, then it falls under Invalid
+BSIC category */
+{
+/* check whether Invalid BSIC reporting is enabled or not and NCC part is
+permitted or not */
+if ( (p_enh->inv_bsic_enabled EQ TRUE) AND
+((BOOL)((UBYTE)(p_enh->ncc_permitted &
+ncc_bit_mask[(enh_cell_list[j].bsic.bsic & BSIC_NCC_MASK) >> 3])) NEQ 0) )
+{
+/* put it in rest bin */
+p_rbin->enh_index[p_rbin->num_valid++] = j;
+}
+} /* if enh_cell_list.index */
+} /* end of for */
+}/* cs_nc_sort_cells_into_bins */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_get_band_index_for_emr
++------------------------------------------------------------------------------
+| Description : This is implementation specific function. This is used to
+|               get index into emr reporting data (reporting threshold and
+|               offset) array, which is band specific.
+|
+|
+| Parameters  : ARFCN
+|
++------------------------------------------------------------------------------
+*/
+LOCAL UBYTE cs_get_band_index_for_emr (USHORT arfcn)
+{
+TRACE_FUNCTION( "cs_get_band_index_for_emr" );
+if ( INRANGE(LOW_CHANNEL_900, arfcn, HIGH_CHANNEL_900) )
+{
+return 0;
+}
+else if ( INRANGE(LOW_CHANNEL_1800, arfcn, HIGH_CHANNEL_1800))
+{
+return 1;
+}
+else if (INRANGE(LOW_CHANNEL_1900, arfcn, HIGH_CHANNEL_1900))
+{
+return 3;
+}
+else if ( INRANGE(LOW_CHANNEL_850, arfcn, HIGH_CHANNEL_850))
+{
+return 4;
+}
+else
+{
+return 2;
+}
+}/* cs_get_band_index_for_emr */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_nc_sort_and_store_meas_results
++------------------------------------------------------------------------------
+| Description : This function sorts the cells collected in each bin, in
+|               descending order of RXLEV
+|
+|
+| Parameters  : Pointer to bin, Number of cells to be reported
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_nc_sort_and_store_meas_results(T_ENH_BIN *p_bin, UBYTE nbr_rpt)
+{
+UBYTE     i;
+UBYTE     j;
+UBYTE     max_rxlev;
+UBYTE     k;
+UBYTE     temp;
+T_ENH_CELL_LIST *enh_cell_list  = &(grr_data->db.enh_cell_list[0]);
+TRACE_FUNCTION( "cs_nc_sort_and_store_meas_results" );
+for (i = 0; (i < p_bin->num_valid AND nbr_rpt > 0); i++,nbr_rpt--)
+{
+max_rxlev = enh_cell_list[p_bin->enh_index[i]].rla_p;
+k = i;
+for ( j = i+1; j < p_bin->num_valid ; j++ )
+{
+if ( enh_cell_list[p_bin->enh_index[j]].rla_p > max_rxlev )
+{
+k = j;
+max_rxlev = enh_cell_list[p_bin->enh_index[j]].rla_p;
+}
+}
+grr_data->db.sorted_enh_cell_list.
+enh_index[grr_data->db.sorted_enh_cell_list.num_valid] =
+p_bin->enh_index[k];
+grr_data->db.sorted_enh_cell_list.num_valid++;
+if(k NEQ i)
+{
+temp = p_bin->enh_index[k];
+p_bin->enh_index[k] = p_bin->enh_index[i];
+p_bin->enh_index[i] = temp;
+}
+}
+}/* cs_nc_sort_and_store_meas_results */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_nc_update_rest_bin
++------------------------------------------------------------------------------
+| Description : This function updates the rest bin by appending the left out
+|               cells in the other bins. These may also have to be reported
+|               along with the cells in rest bin.
+|
+|
+| Parameters  : Pointers to the rest and a bin, Number of cells to be reported
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_nc_update_rest_bin(T_ENH_BIN *p_rbin, T_ENH_BIN *p_bin,
+UBYTE nbr_rpt)
+{
+UBYTE i, count;
+TRACE_FUNCTION( "cs_nc_update_rest_bin" );
+count = p_bin->num_valid - nbr_rpt;
+for ( i = 0; i < count; i++)
+{
+p_rbin->enh_index[p_rbin->num_valid++] = p_bin->enh_index[nbr_rpt++];
+p_bin->num_valid--;
+}
+}/* cs_nc_update_rest_bin */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_nc_scale_rxlev
++------------------------------------------------------------------------------
+| Description : This function performs the scaling of RXLEV.
+|
+|
+| Parameters  : Nil
+|
++------------------------------------------------------------------------------
+*/
+LOCAL UBYTE cs_nc_scale_rxlev (void)
+{
+UBYTE     i;
+UBYTE     no_of_cells = grr_data->db.cnt_enh_cell_list;
+UBYTE     scale;
+T_ENH_CELL_LIST   *enh_cell_list   = &(grr_data->db.enh_cell_list[0]);
+UBYTE     scale_order = grr_data->db.nc_ref_lst.enh_param->scale_order;
+TRACE_FUNCTION( "cs_nc_scale_rxlev" );
+/*If scaling is automatic, then we find the scaling as below:
+If the maximum RXLEV is greater than 63 (MAX_RXLEV), then we add 10dB
+and check whether it falls into the range after scaling*/
+/* Note: The assumption is L1 reports values in the following way -
+if actual value of rxlev (x) is between y and y+1 dBm, then the reported value
+is 110+x rounded off to next integer. */
+if ( scale_order EQ SCALE_AUTO )
+{
+UBYTE     max = 0;
+if( grr_data->db.scell_info.rxlev_avg NEQ RXLEV_AVG_INVALID )
+{
+max = grr_data->db.scell_info.rxlev_avg;
+}
+for ( i = 0; i < no_of_cells ; i++ )
+{
+if (enh_cell_list[i].rxlev_avg > max )
+{
+max = enh_cell_list[i].rxlev_avg;
+}
+}
+if ( max > 63 )
+{
+/* If the max value is greater than 63, we scale by 10 so that
+rxlev values of maximum cells will come into range(0 - 63) */
+scale = 10;
+}
+else
+{
+scale = 0;
+}
+}
+else
+{
+scale = scale_order * 10;
+}
+/* Apply the scale to the values to be reported for SCELL and NCELLs */
+if( grr_data->db.scell_info.rxlev_avg NEQ RXLEV_AVG_INVALID )
+{
+grr_data->db.scell_info.rxlev_avg -= scale;
+}
+for ( i = 0; i < no_of_cells ; i++ )
+{
+if (enh_cell_list[i].rxlev_avg > scale)
+{
+enh_cell_list[i].rxlev_avg -= scale;
+}
+else
+{
+enh_cell_list[i].rxlev_avg = 0;
+}
+if (enh_cell_list[i].rxlev_avg > 63)
+{
+enh_cell_list[i].rxlev_avg = 63;
+}
+}
+return (scale/10);
+}/* cs_nc_scale_rxlev */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_build_enh_meas_rpt
++------------------------------------------------------------------------------
+| Description : This function is used to build PEMR
+|
+| Parameters  : u_enh_meas_report - Pointer to ENH measurement report
+|
++------------------------------------------------------------------------------
+*/
+LOCAL BOOL cs_build_enh_meas_rpt ( T_U_ENHNC_MEAS_REPORT *u_enh_meas_report )
+{
+T_NC_ORDER nc_ord        = cs_get_network_ctrl_order( TRUE );
+/*UBYTE     size_avail     = MSG_SIZE_PEMR - MAND_SIZE_PEMR;*/
+BOOL   pbcch_present     = grr_is_pbcch_present( );
+UBYTE  psi3_cm = grr_get_psi3_cm();
+T_nc_meas_rep_enh *nc_meas_rep_enh = &(u_enh_meas_report->nc_meas_rep_enh);
+UBYTE used_bits = 0; /* for formality sake only, not used here */
+UBYTE rxlev_scell;
+UBYTE v_i_scell;
+UBYTE i_scell;
+BOOL rsc_avail = FALSE;
+BOOL isc_avail = FALSE;
+TRACE_FUNCTION( "cs_build_enh_meas_rpt" );
+/* process message type */
+u_enh_meas_report->msg_type = U_ENHNC_MEAS_REPORT_c;
+/* process TLLI */
+grr_set_buf_tlli( &u_enh_meas_report->tlli_value, grr_get_tlli( ) );
+/* Process NC Measurements */
+/* process NC mode */
+switch( nc_ord )
+{
+case NC_NC1: nc_meas_rep_enh->nc_mode = NCMODE_NC1; break;
+case NC_NC2: nc_meas_rep_enh->nc_mode = NCMODE_NC2; break;
+default:
+TRACE_ERROR( "cs_build_enh_meas_rpt no valid NC mode" );
+return( FALSE );
+}
+/* process BA used, PSI3 change mark and PMO used */
+if( pbcch_present EQ FALSE )
+{
+u_enh_meas_report->nc_meas_rep_enh.ba_psi3_str.flag = FALSE;
+u_enh_meas_report->nc_meas_rep_enh.ba_psi3_str.v_ba_ind_used = TRUE;
+u_enh_meas_report->nc_meas_rep_enh.ba_psi3_str.v_ba_ind_used_3g = TRUE;
+u_enh_meas_report->nc_meas_rep_enh.ba_psi3_str.ba_ind_used =
+psc_db->ba_ind;
+}
+else
+{
+u_enh_meas_report->nc_meas_rep_enh.ba_psi3_str.flag = TRUE;
+u_enh_meas_report->nc_meas_rep_enh.ba_psi3_str.v_psi3_cm = TRUE;
+u_enh_meas_report->nc_meas_rep_enh.ba_psi3_str.psi3_cm = psi3_cm;
+}
+u_enh_meas_report->nc_meas_rep_enh.ba_psi3_str.pmo_ind_used =
+psc_db->nc_ms.pmo_ind;
+/* process serving cell data - rxlev and ilev */
+cs_process_serving_cell_data(&rxlev_scell, &v_i_scell, &i_scell, &used_bits,
+&rsc_avail, &isc_avail);
+if((rsc_avail EQ TRUE) AND (isc_avail EQ FALSE))
+{
+/* Only RXLEV of SCELL avalable. ILEV of SCELL not available */
+nc_meas_rep_enh->v_serv_cell_data = TRUE;
+nc_meas_rep_enh->serv_cell_data.v_i_scell = FALSE;
+nc_meas_rep_enh->serv_cell_data.rxlev_scell = rxlev_scell;
+}
+else if(rsc_avail EQ FALSE)
+{
+/* RXLEV of SCELL not avalable. Hence SCELL info is not reported */
+nc_meas_rep_enh->v_serv_cell_data = FALSE;
+}
+else if((rsc_avail EQ TRUE) AND (isc_avail EQ TRUE))
+{
+/* Both RXLEV and ILEV of SCELL available and reported */
+nc_meas_rep_enh->v_serv_cell_data = TRUE;
+nc_meas_rep_enh->serv_cell_data.v_i_scell = TRUE;
+nc_meas_rep_enh->serv_cell_data.rxlev_scell = rxlev_scell;
+nc_meas_rep_enh->serv_cell_data.i_scell = i_scell;
+}
+/* process NC measurement results */
+if(cs_fill_nc_enh_meas_results(nc_meas_rep_enh) EQ FALSE)
+{
+nc_meas_rep_enh->v_nc_rep_quan = FALSE;
+}
+/* process BSIC_SEEN and SCALE */
+if(nc_meas_rep_enh->c_rep_invalid_bsic_info NEQ 0)
+{
+nc_meas_rep_enh->bsic_seen = TRUE;
+}
+else
+{
+nc_meas_rep_enh->bsic_seen = FALSE;
+}
+nc_meas_rep_enh->scale = grr_data->db.pemr_params.scale_used;
+return(TRUE);
+} /* cs_build_enh_meas_rpt() */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_fill_nc_meas_results
++------------------------------------------------------------------------------
+| Description : This function is used to fill ENH measurements of neighbour
+|               cells in the PEMR message
+|
+|
+| Parameters  : Pointer to ENH meas parameters struct
+|
++------------------------------------------------------------------------------
+*/
+LOCAL BOOL cs_fill_nc_enh_meas_results(T_nc_meas_rep_enh *nc_meas_rep_enh)
+{
+UBYTE     size_avail = MSG_SIZE_PEMR - MAND_SIZE_PEMR;
+UBYTE     i;
+UBYTE     highest_index = 0;
+T_ENH_CELL_LIST *enh_cell_list = &(grr_data->db.enh_cell_list[0]);
+T_ENH_BIN *sorted_list = &grr_data->db.sorted_enh_cell_list;
+UBYTE     index_0 = 1;
+nc_meas_rep_enh->nc_rep_quan.c_reporting_quantity_bmp = 0;
+nc_meas_rep_enh->c_rep_invalid_bsic_info = 0;
+TRACE_FUNCTION( "cs_fill_nc_meas_results" );
+/*lint -e{437} Passing struct '' to ellipsis */
+TRACE_EVENT_P1("dump=%x",grr_data->db.enh_cell_list[0]);
+if(grr_data->db.sorted_enh_cell_list.num_valid EQ 0)
+{
+return(FALSE);
+}
+nc_meas_rep_enh->v_nc_rep_quan = TRUE;
+for(i = 0; i < sorted_list->num_valid; i++)
+{
+if(enh_cell_list[sorted_list->enh_index[i]].bsic.status EQ BSIC_VALID)
+{
+/*Fill it in valid BSIC bit map reporting, enh_cell_list[i]->index
+corresponds to the bit in the report. Find whether size permits */
+TRACE_EVENT_P2("I%x = %x",i,enh_cell_list[sorted_list->enh_index[i]].index);
+nc_meas_rep_enh->nc_rep_quan.
+reporting_quantity_bmp[enh_cell_list[sorted_list->enh_index[i]].index].
+v_reporting_quantity = TRUE;
+nc_meas_rep_enh->nc_rep_quan.
+reporting_quantity_bmp[enh_cell_list[sorted_list->enh_index[i]].index].
+reporting_quantity = enh_cell_list[sorted_list->enh_index[i]].rxlev_avg;
+size_avail = size_avail - index_0;
+index_0 = 0;
+if ( enh_cell_list[sorted_list->enh_index[i]].index > highest_index )
+{
+/* When the place where the RXLEV has to be filled requires
+additional bits in bit map, then we have to account for
+these single bits and additional 6 bits for RXLEV */
+if ( size_avail >= (enh_cell_list[sorted_list->enh_index[i]].index
+- highest_index) + NC_RXLEV_N_LEN )
+{
+/* This means we require atleast enh_cell_list[i]->index -
+highest_index+6 bits in bit map to include this rxlev */
+/* 6 bits for RXLEV itself */
+size_avail = size_avail -
+(enh_cell_list[sorted_list->enh_index[i]].index - highest_index
++ NC_RXLEV_N_LEN);
+highest_index = enh_cell_list[sorted_list->enh_index[i]].index;
+nc_meas_rep_enh->nc_rep_quan.
+c_reporting_quantity_bmp =
+enh_cell_list[sorted_list->enh_index[i]].index + 1; /* counter is index+1 */
+continue;
+}
+else if (size_avail >= NC_RXLEV_N_LEN)
+{
+continue;
+}
+else
+break; /* No more filling possible */
+}
+else if (size_avail >= NC_RXLEV_N_LEN)
+{
+size_avail -= NC_RXLEV_N_LEN; /* size for bit map is already accounted for*/
+nc_meas_rep_enh->nc_rep_quan.
+c_reporting_quantity_bmp = highest_index +1;
+continue;
+}
+else
+{
+break; /*no more inclusion of results is possible*/
+}
+}
+else
+{
+/* fill in invalid BSIC list since cell is not present in the neighbour cell
+list. Here the index that needs to be filled is index of the ARFCN in BA(list)*/
+if ( size_avail > NC_INVBSIC_PEMR )
+{
+nc_meas_rep_enh->v_rep_invalid_bsic_info = TRUE;
+nc_meas_rep_enh->rep_invalid_bsic_info
+[nc_meas_rep_enh->c_rep_invalid_bsic_info].bcch_freq_ncell
+= enh_cell_list[sorted_list->enh_index[i]].index;
+nc_meas_rep_enh->rep_invalid_bsic_info
+[nc_meas_rep_enh->c_rep_invalid_bsic_info].bsic
+= enh_cell_list[sorted_list->enh_index[i]].bsic.bsic;
+nc_meas_rep_enh->rep_invalid_bsic_info
+[nc_meas_rep_enh->c_rep_invalid_bsic_info].rxlev_ncell
+= enh_cell_list[sorted_list->enh_index[i]].rxlev_avg;
+nc_meas_rep_enh->c_rep_invalid_bsic_info++;
+size_avail -= NC_INVBSIC_PEMR;
+}
+}
+}
+return(TRUE);
+}/* cs_fill_nc_enh_meas_results */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_build_enh_sorted_strng_arfcn_list
++------------------------------------------------------------------------------
+| Description : The purpose of this function is to sort the cells into various
+|               bins and in desc order of RXLEV in each of the bin. The ARFCNs
+|               in the sorted bin are finally sent to RR for decoding purpose
+|
+|
+| Parameters  : Pointers to the final sorted bin for storage
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_build_enh_sorted_strng_arfcn_list(T_ENH_STRNG_ARFCN_LIST *f_bin)
+{
+T_ENH_STRNG_ARFCN_LIST s_bin, r_bin;
+UBYTE total_arfcns;
+f_bin->num = 0;
+TRACE_FUNCTION( "cs_build_enh_sorted_strng_arfcn_list" );
+/* Sort ARFCNs into Serving, Non-serving or the Rest*/
+total_arfcns = cs_sort_arfcns_into_bins(&s_bin, &r_bin);
+/* Sort the ARFCNs in desc order of RXLEV and store them in the final bin */
+if(total_arfcns NEQ 0)
+{
+cs_sort_store_in_desc_order_rxlev(&s_bin, f_bin);
+cs_sort_store_in_desc_order_rxlev(&r_bin, f_bin);
+}
+}
+/*
++------------------------------------------------------------------------------
+| Function    : cs_sort_arfcns_into_bins
++------------------------------------------------------------------------------
+| Description : The purpose of this function is to sort the ARFCNs into various
+|               bins.
+|
+|
+| Parameters  : Pointers to the the bins
+|
++------------------------------------------------------------------------------
+*/
+LOCAL UBYTE cs_sort_arfcns_into_bins(T_ENH_STRNG_ARFCN_LIST *p_s_bin,
+T_ENH_STRNG_ARFCN_LIST *p_r_bin)
+{
+UBYTE     i;
+UBYTE     band, sc_band;
+UBYTE     total_cells = 0;
+p_s_bin->num = 0;
+p_r_bin->num = 0;
+TRACE_FUNCTION( "cs_sort_arfcns_into_bins" );
+sc_band = cs_get_band_index_for_emr (psc_db->pbcch.bcch.arfcn);
+/* Check the ARFCNs in the NC_MVAL and store them in Serving or
+Rest bins according to their bands */
+i = 0;
+while( (i < MAX_NR_OF_NC_MVAL) AND (total_cells <= MAX_NR_OF_NCELL) )
+{
+if( (grr_data->db.nc_mval_list.nc_mval[i].arfcn NEQ RRGRR_INVALID_ARFCN)
+AND (grr_data->db.nc_mval_list.nc_mval[i].status EQ NC_MVAL_STAT_ASSIGNED) )
+{
+band = cs_get_band_index_for_emr(grr_data->db.nc_mval_list.nc_mval[i].arfcn);
+if (band EQ sc_band)
+{
+p_s_bin->meas[p_s_bin->num].arfcn =
+grr_data->db.nc_mval_list.nc_mval[i].arfcn;
+p_s_bin->meas[p_s_bin->num].rxlev =
+grr_data->db.nc_mval_list.nc_mval[i].rla_p.lev;
+p_s_bin->num++;
+}
+else /* Process the non-serving bands */
+{
+p_r_bin->meas[p_r_bin->num].arfcn =
+grr_data->db.nc_mval_list.nc_mval[i].arfcn;
+p_r_bin->meas[p_r_bin->num].rxlev =
+grr_data->db.nc_mval_list.nc_mval[i].rla_p.lev;
+p_r_bin->num++;
+}
+total_cells = p_s_bin->num + p_r_bin->num;
+}
+i++;
+} /* end of while */
+return(total_cells);
+}/* cs_sort_arfcns_into_bins */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_sort_in_desc_order_rxlev
++------------------------------------------------------------------------------
+| Description : This function sorts the cells collected in each bin, in
+|               descending order of RXLEV. It will be stored in the final bin
+|               as and when sorted.
+|
+|
+| Parameters  : Pointer to serving or multiband bin, Pointer to final bin
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_sort_store_in_desc_order_rxlev(T_ENH_STRNG_ARFCN_LIST *p_bin,
+T_ENH_STRNG_ARFCN_LIST *p_f_bin)
+{
+UBYTE     i;
+UBYTE     j;
+UBYTE     max_rxlev;
+UBYTE     k;
+T_MEAS    temp;
+TRACE_FUNCTION( "cs_sort_store_in_desc_order_rxlev" );
+for (i = 0; i < p_bin->num; i++)
+{
+max_rxlev = p_bin->meas[i].rxlev;
+k = i;
+for ( j = i + 1; j < p_bin->num; j++ )
+{
+if ( p_bin->meas[j].rxlev > max_rxlev )
+{
+k = j;
+max_rxlev = p_bin->meas[j].rxlev;
+}
+}
+/* Store the ARFCN-RXLEV pair in the final bin in desc order of RXLEV */
+p_f_bin->meas[p_f_bin->num++] = p_bin->meas[k];
+if(k NEQ i)
+{
+temp = p_bin->meas[k];
+p_bin->meas[k] = p_bin->meas[i];
+p_bin->meas[i] = temp;
+}
+}
+}/* cs_sort_store_in_desc_order_rxlev */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_init_ba_bcch_nc_ref_list
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  : list  - pointer to NC measurement pointer list
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void cs_init_ba_bcch_nc_ref_list ()
+{
+TRACE_FUNCTION( "cs_init_ba_bcch_nc_ref_list" );
+grr_data->db.ba_bcch_nc_ref_lst.number = 0;
+}/* cs_init_ba_bcch_nc_ref_list */
+/*
++------------------------------------------------------------------------------
+| Function    : cs_build_ba_bcch_nc_freq_list
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  : db - pointer to serving cell database
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_build_ba_bcch_nc_freq_list ()
+{
+UBYTE i;
+TRACE_FUNCTION( "cs_build_ba_bcch_nc_freq_list" );
+/*
+* add neighbour cell information of SI2 and PMO to reference list
+*/
+for( i = 0; i < psc_db->nc_ba_bcch_cw.number; i++ )
+{
+grr_data->db.ba_bcch_nc_ref_lst.info[i] = &psc_db->nc_ba_bcch_cw.info[i];
+grr_data->db.ba_bcch_nc_ref_lst.number++;
+}
+if(use_ba_gprs EQ FALSE)
+{
+UBYTE number = psc_db->nc_ba_bcch_cw.number;
+for(i = 0; i < psc_db->nc_ms.ncmeas.list.number; i++)
+{
+grr_data->db.ba_bcch_nc_ref_lst.info[number] =
+&psc_db->nc_ms.ncmeas.list.info[i];
+grr_data->db.ba_bcch_nc_ref_lst.info[number]->index = number;
+grr_data->db.ba_bcch_nc_ref_lst.number++;
+number++;
+}
+}
+}
+#endif
+/*
++------------------------------------------------------------------------------
+| Function    : cs_copy_rxlev_from_avg
++------------------------------------------------------------------------------
+| Description : The function cs_copy_rxlev_from_avg() helps to retain the old
+|               rxlev data obtained for the neighbour cells before the cell
+|               change.
+| Parameters  : Index of the nc_data->cell,nc_mval->rxlev_avg
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_copy_rxlev_from_avg(UBYTE rxlev_avg,T_CELL *cell)
+{
+#define INITIAL_ACC_MEAS 4
+UBYTE i; /* used for counting */
+T_RLA_P_DATA *rla_p_data = &cell->rla_p_data;
+T_RXLEV_DATA *rxlev_data = &cell->rxlev_data;
+TRACE_FUNCTION( "cs_copy_rxlev_from_avg" );
+TRACE_EVENT_P3( "cs_copy_rxlev_from_avg arfcn=%ld LOI=%ld rxlev_avg=%ld", cell->arfcn,rla_p_data->loi,rxlev_avg);
+rla_p_data->loi    = INITIAL_ACC_MEAS - 1 ;
+rla_p_data->ovrflw = FALSE;
+for( i = 0; i < INITIAL_ACC_MEAS; i++ )
+{
+rla_p_data->meas[i].cnt     = 1;
+rla_p_data->meas[i].acc     = (USHORT)rxlev_avg;
+rla_p_data->meas[i].rpt_prd = 208;
+}
+rxlev_data->acc = rxlev_avg*INITIAL_ACC_MEAS*RXLEV_ACRCY;
+rxlev_data->nbr = INITIAL_ACC_MEAS;
+}
+/*
++------------------------------------------------------------------------------
+| Function    : cs_reuse_old_cell_rxlev
++------------------------------------------------------------------------------
+| Description : The function cs_reuse_old_cell_rxlev() helps to reuse rxlev data
+|               obtained for the neighbour cells in the old cell before the cell
+|               change.
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void cs_reuse_old_cell_rxlev()
+{
+T_NC_MVAL  *nc_mval;
+UBYTE       i,found,mval_idx ;
+UBYTE       mval_index=0;
+TRACE_FUNCTION( "cs_reuse_old_cell_rxlev" );
+TRACE_EVENT( "cs_reuse_old_cell_rxlev" );
+for( i = 0; i < MPHP_NUMC_BA_GPRS_SC; i++ )
+{
+#if 0
+mval_index = 0;
+nc_mval = grr_get_nc_mval( nc_data->cell[i].arfcn, RRGRR_INVALID_BSIC, &mval_index );
+if(nc_mval NEQ 0)
+{
+if(nc_mval->rla_p.stat EQ CS_RLA_P_VALID)
+{
+cs_copy_rxlev_from_avg( (UBYTE)nc_mval->rxlev_avg,&nc_data->cell[i] );
+}
+else
+{
+cs_reset_meas_result( &nc_data->cell[i] );
+}
+}
+else
+{
+cs_reset_meas_result( &nc_data->cell[i] );
+}
+#else
+found=0;
+for( mval_idx = 0; mval_idx < MAX_NR_OF_NC_MVAL; mval_idx++ )
+{
+nc_mval = &grr_data->db.nc_mval_list.nc_mval[mval_idx];
+if((UBYTE)nc_mval->rxlev_avg EQ 0xFF AND
+nc_mval->rla_p.stat EQ CS_RLA_P_VALID)
+{
+TRACE_EVENT_P4("PATCH: arfcn=%ld avg_lev=%ld rla_p_lev=%ld stat=%ld "
+,nc_mval->arfcn,nc_mval->rxlev_avg,nc_mval->rla_p.lev,nc_mval->rla_p.stat);
+}
+if(
+(nc_mval->arfcn EQ nc_data->cell[i].arfcn)
+AND
+(nc_mval->rla_p.stat EQ CS_RLA_P_VALID)
+AND
+((UBYTE)nc_mval->rxlev_avg NEQ 0xFF)
+)
+{
+cs_copy_rxlev_from_avg( (UBYTE)nc_mval->rxlev_avg,&nc_data->cell[i] );
+found=1;
+}
+}
+if(!found)
+cs_reset_meas_result( &nc_data->cell[i] );
+#endif
+}
+}

FreeCalypso > hg > fc-selenite

comparison src/g23m-gprs/grr/grr_csf.c @ 1:d393cd9bb723