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

comparison src/g23m-gprs/grr/grr_psif.c @ 183:219afcfc6250

src/g23m-gprs: initial import from TCS3.2/LoCosto

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

comparison

equal deleted inserted replaced

-:f02d0a0e1849
+:219afcfc6250
+/*
++-----------------------------------------------------------------------------
+|  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 PSI of
+|             entity GRR.
++-----------------------------------------------------------------------------
+*/
+#ifndef GRR_PSIF_C
+#define GRR_PSIF_C
+#endif
+#define ENTITY_GRR
+#ifdef _SIMULATION_
+/*
+* Report warning 4005 as an error.
+*
+* There are identical macro definitons in the GRR message and the RRGRR SAP
+* document which should be aligned at all the time
+* (e.g. GPRS_RXLEV_ACCESS_MIN_INVALID, GPRS_MS_TXPWR_MAX_CCH, etc.)
+*/
+#pragma warning( error : 4005 )
+#endif /* #ifdef _SIMULATION_ */
+/*==== INCLUDES =============================================================*/
+#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_psif.h"   /* */
+#include "grr_ctrls.h"  /* */
+#include "grr_css.h"   /* signals exchanged between PSI and CS*/
+#include "grr_meass.h"   /* signals exchanged between PSI and MEAS*/
+#include <string.h>    /* for memcpy */
+#include <stdio.h>     /* for memcpy */
+#include "grr_em.h"     /*for Engineering mode*/
+/*==== DIAGNOSTICS ==========================================================*/
+/*==== CONST ================================================================*/
+#define PBCCH_NOT_PRESENT    0x0           /* PBCCH not present in the cell  */
+#define PBCCH_PRESENT        0x1           /* PBCCH present in the cell      */
+/*==== LOCAL VARS ===========================================================*/
+LOCAL void psi_reset_psi_pos  ( void );
+#ifndef _TARGET_
+LOCAL void psi_fill_rel_pos(UBYTE *src, UBYTE max_src, UBYTE *psi_nr, UBYTE *pos_array);
+#endif /*_TARGET_*/
+/*==== PRIVATE FUNCTIONS ====================================================*/
+LOCAL void psi_reset_complete_acq ( void );
+LOCAL void psi_reset_psi1 (void );
+LOCAL void psi_reset_psi2 (void );
+LOCAL void psi_reset_psi3 (void );
+LOCAL void psi_reset_psi3bis (void );
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+LOCAL void psi_reset_psi3ter (void );
+#endif
+LOCAL void psi_reset_psi4 (void );
+LOCAL void psi_reset_psi5 (void );
+#ifdef REL99
+LOCAL void psi_reset_psi8 (void);
+#endif
+LOCAL void psi_reset_psi13 (void );
+LOCAL void psi_init_states_of_psi ( void );
+LOCAL void psi_init_rfl_psi2(void);
+LOCAL void psi_init_cell_alloc(void);
+LOCAL void psi_init_gprs_ms_alloc(BOOL psi2_only);
+LOCAL void psi_copy_si13_params(T_D_SYS_INFO_13* si13);
+LOCAL void psi_copy_psi13_params(T_PSI_13* psi13);
+LOCAL BOOL psi_check_change_field (UBYTE psi_change_field);
+LOCAL UBYTE psi_compare_change_mark(UBYTE received_change_mark, UBYTE stored_change_mark);
+LOCAL BOOL psi_is_pbcch_des_different(T_PSI_13* psi13);
+/*
+* Private functions for handling of PSI3 and PSI3BIS messages.
+* Reading of those messages in not ordered sequence.
+*/
+/*
+* Storing
+*/
+LOCAL UBYTE psi_store_ncell_param  ( T_ncell_par      *p_ncell_par,
+UBYTE             c_ncell_par,
+UBYTE             v_ncell_par,
+T_INFO_TYPE       type,
+UBYTE             instance       );
+LOCAL void psi_store_ncell_param2  ( T_PSI_3_BIS      *psi3bis,
+UBYTE             number         );
+LOCAL BOOL psi_store_cs_param2     ( T_NC_LIST        *nc_list,
+T_ncell_par2_set *cs_par2,
+UBYTE             instance,
+UBYTE            *number,
+USHORT           *freq,
+USHORT            freq_diff,
+UBYTE             same_ra_scell,
+UBYTE             cell_ba,
+UBYTE             bcc            );
+/*
+* Restoring
+*/
+LOCAL void psi_restore_ncell_param ( void                             );
+#ifdef REL99
+LOCAL void psi_update_bss_sgsn_rel ( T_D_SYS_INFO_13  *si13,
+BOOL              pbcch_status   );
+#endif
+/*==== PUBLIC FUNCTIONS =====================================================*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_compare_change_mark()
++------------------------------------------------------------------------------
+| Description : The function psi_compare_change_mark() .... compares the change_mark values
+|               and indicates the incrementatiton value
+|
+| Parameters  : UBYTE received_change_mark, UBYTE stored_change_mark
+|
++------------------------------------------------------------------------------
+*/
+LOCAL UBYTE psi_compare_change_mark(UBYTE received_change_mark, UBYTE stored_change_mark)
+{
+UBYTE incremented_value = 0;
+if(received_change_mark NEQ stored_change_mark)
+{
+UBYTE dummy = (stored_change_mark + 1)%8;
+if(dummy EQ received_change_mark)
+incremented_value = 1;
+else
+incremented_value = 2;
+}
+return incremented_value;
+}/* psi_compare_change_mark*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_stop_psi_reading()
++------------------------------------------------------------------------------
+| Description : The function psi_stop_psi_reading() .... stops to read PSI messages
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_stop_psi_reading( ACQ_TYPE acq_type_in_idle)
+{
+TRACE_FUNCTION( "psi_stop_psi_reading" );
+psc_db->acq_type = acq_type_in_idle;
+if(grr_is_pbcch_present())
+{
+PALLOC(mphp_scell_pbcch_req, MPHP_SCELL_PBCCH_STOP_REQ);
+PSEND(hCommL1,mphp_scell_pbcch_req);
+}
+}/* psi_stop_psi_reading*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_check_acq_state
++------------------------------------------------------------------------------
+| Description : The function psi_check_acq_state() .... checks the state of the acquisition
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_ACQ_STATE_RET psi_check_acq_state ( void )
+{
+UBYTE n;
+T_ACQ_STATE_RET return_val = ACQ_RUNNING;
+TRACE_FUNCTION( "psi_check_acq_state" );
+switch(psc_db->acq_type)
+{
+case PARTIAL:
+return_val = ACQ_PART_OK;
+for(n = 0; n <MAX_PSI; n++)
+{
+if(psc_db->state_of_PSI[n].state EQ NEEDED)
+{
+/*
+* partial acquisition not completed
+*/
+return_val = ACQ_RUNNING;
+}
+}
+if(return_val EQ ACQ_PART_OK)
+{
+psi_stop_10sec(); /* partial acquisition completed */
+psc_db->acq_type = NONE; /* e.g. wait 30 sec for reread PSI1*/
+psc_db->psi1_params.first_psi1 = FALSE;
+#ifdef REL99
+/* Partial acquisition is complete. Send CBCH info
+* to RR if needed.
+*/
+if(psc_db->send_cbch_info_ind)
+{
+sig_psi_ctrl_cbch_info_ind();
+psc_db->send_cbch_info_ind = FALSE;
+}
+#endif
+}
+break;
+case COMPLETE:
+return_val = ACQ_COMP_OK;
+/*
+* Check whether reading process completed or not
+*/
+for(n = 0; n <MAX_PSI; n++)
+{
+if(psc_db->state_of_PSI[n].state EQ NEEDED)
+{
+/*
+* acquisition of some PSI not completed
+*/
+{
+if(n EQ 3)
+{
+TRACE_EVENT("acq. incomplete PSI3bis missing!");
+}
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+else if(n EQ 4)
+{
+TRACE_EVENT("acq. incomplete PSI3ter  missing!");
+}
+else if(n EQ 7)
+{
+TRACE_EVENT("acq. incomplete PSI8  missing!");
+}
+else
+{
+TRACE_EVENT_P1("acq. incomplete PSI%d missing!", ((n>3)?n-1:n+1));
+}
+#else
+else
+{
+TRACE_EVENT_P1("acq. incomplete PSI%d missing!", ((n>3)?n:n+1));
+}
+#endif
+}
+return_val = ACQ_RUNNING;
+break; /* break for loop*/
+}
+}
+if(return_val EQ ACQ_COMP_OK)
+{
+/*
+* Start timer for 10 sec. if running
+*/
+TRACE_EVENT("Acq. complete");
+vsi_t_stop(GRR_handle, T_COMP_PSI);
+psi_stop_10sec(); /* acquisition of all PSI  completed */
+psc_db->acq_type = NONE; /* e.g. wait 30 sec for reread PSI1*/
+psc_db->psi1_params.first_psi1 = FALSE;
+}
+break;
+case PERIODICAL_PSI1_READING:
+psc_db->acq_type = NONE; /* e.g. wait 30 sec for reread PSI1*/
+return_val = ACQ_PERIOD_OK;
+break;
+case FULL_PSI_IN_NEW_CELL:
+return_val = ACQ_NPSI_OK;
+psc_db->acq_type = NONE; /* e.g. wait 30 sec for reread PSI1*/
+/*
+* E.g. read all PSI in the reselected cell
+* Check whether reading process completed or not
+*/
+for(n = 0; n <MAX_PSI; n++)
+{
+if(psc_db->state_of_PSI[n].state EQ NEEDED)
+{
+/*
+* acquisition of some PSI not completed
+*/
+return_val = ACQ_RUNNING;
+psc_db->acq_type = FULL_PSI_IN_NEW_CELL;
+break; /* break for loop*/
+}
+}
+if(n>MAX_PSI)
+psc_db->psi1_params.first_psi1 = FALSE;
+break;
+case NONE:
+/* nothing to do: we may received a PSI message without sending a request
+*                e.g. on PCCCH (PPCH: paging channel or paging group)
+*/
+break;
+default:
+break;
+}
+return return_val;
+} /* psi_check_acq_state() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reset_complete_acq
++------------------------------------------------------------------------------
+| Description : The function psi_reset_complete_acq() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_reset_complete_acq ( void )
+{
+TRACE_FUNCTION( "psi_reset_complete_acq" );
+psc_db->acq_type = COMPLETE;
+psc_db->complete_acq.needed = TRUE;
+psc_db->complete_acq.psi1_ok = FALSE;
+psc_db->complete_acq.psi2_ok = FALSE;
+psc_db->complete_acq.made_at_least_one_attempt = FALSE;
+}/* psi_reset_complete_acq*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reset_psi1
++------------------------------------------------------------------------------
+| Description : The function psi_reset_psi1() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL  void psi_reset_psi1 ( void )
+{
+TRACE_FUNCTION( "psi_reset_psi1" );
+psc_db->psi1_params.pbcch_change_mark = NOT_SET;
+psc_db->psi1_params.psi_change_field = NOT_SET;
+psc_db->psi1_params.psi_cnt_lr = 0;
+psc_db->psi1_params.psi_cnt_hr = 0;
+psc_db->psi1_params.psi1_repeat_period = NOT_SET;
+psc_db->psi1_params.first_psi1 = TRUE;
+}/* psi_reset_psi1*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reset_psi2
++------------------------------------------------------------------------------
+| Description : The function psi_reset_psi2() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_reset_psi2 ( void )
+{
+UBYTE n;
+TRACE_FUNCTION( "psi_reset_psi2" );
+/* reset psi2 parameters*/
+psc_db->psi2_params.psi2_change_mark = NOT_SET; /*not set*/
+psc_db->psi2_params.psi2_count = NOT_SET; /*not set*/
+for(n = 0; n <MAX_NR_OF_INSTANCES_OF_PSI2 + 1; n++)
+psc_db->psi2_params.instances[n] = FALSE;
+#ifdef REL99
+psc_db->v_add_psi = FALSE;
+#endif
+psi_init_rfl_psi2();
+psi_init_cell_alloc();
+psi_init_gprs_ms_alloc(TRUE);
+} /* psi_reset_psi2 */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reset_psi3
++------------------------------------------------------------------------------
+| Description : The function psi_reset_psi3() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL  void psi_reset_psi3 ( void )
+{
+TRACE_FUNCTION( "psi_reset_psi3" );
+/* reset psi3 parameters*/
+psc_db->psi3_params.psi3_change_mark = NOT_SET;
+psc_db->psi3_params.psi3_bis_count = NOT_SET;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+grr_init_nc_list( &psc_db->nc_cw.list );
+#endif
+} /* psi_reset_psi3 */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reset_psi3bis
++------------------------------------------------------------------------------
+| Description : The function psi_reset_psi3bis() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL  void psi_reset_psi3bis ( void )
+{
+UBYTE n;
+TRACE_FUNCTION( "psi_reset_psi3bis" );
+psc_db->psi3bis_params.psi3bis_change_mark = NOT_SET;
+psc_db->psi3bis_params.psi3bis_index = 0;
+for(n = 0; n <MAX_NR_OF_INSTANCES_OF_PSI3BIS + 1; n++)
+psc_db->psi3bis_params.instances[n] = FALSE;
+grr_init_nc_list( &psc_db->nc_cw.list );
+} /* psi_reset_psi3bis */
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reset_psi3ter
++------------------------------------------------------------------------------
+| Description : The function psi_reset_psi3ter() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL  void psi_reset_psi3ter ( void )
+{
+UBYTE n;
+TRACE_FUNCTION( "psi_reset_psi3ter" );
+psc_db->psi3ter_params.psi3ter_change_mark = NOT_SET;
+psc_db->psi3ter_params.prev_psi3ter_index = 0;
+psc_db->psi3ter_params.psi3ter_index = 0;
+for(n = 0; n <MAX_NR_OF_INSTANCES_OF_PSI3TER + 1; n++)
+psc_db->psi3ter_params.instances[n] = FALSE;
+psc_db->enh_cw.gprs_rept_prio_desc.num_cells = 0;
+#ifdef TI_PS_FF_RTD
+/* Rtd values has to be reset to not available */
+for( n = 0; n < MAX_NR_OF_NCELL; n++ )
+psc_db->rtd[n] = RTD_NOT_AVAILABLE;
+#endif /* #ifdef TI_PS_FF_RTD */
+} /* psi_reset_psi3ter */
+#endif
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reset_psi4
++------------------------------------------------------------------------------
+| Description : The function psi_reset_psi4() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL  void psi_reset_psi4 ( void )
+{
+UBYTE n;
+TRACE_FUNCTION( "psi_reset_psi4" );
+/* reset psi_reset_psi4 parameters*/
+psc_db->psi4_params.psi4_index = 0;
+psc_db->psi4_params.psi4_change_mark = NOT_SET;
+for(n = 0; n <MAX_NR_OF_INSTANCES_OF_PSI4 + 1; n++)
+psc_db->psi4_params.instances[n] = FALSE;
+} /* psi_reset_psi4 */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reset_psi5
++------------------------------------------------------------------------------
+| Description : The function psi_reset_psi5() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL  void psi_reset_psi5 ( void )
+{
+UBYTE i;
+TRACE_FUNCTION( "psi_reset_psi5" );
+/* reset psi_reset_psi5 parameters*/
+psc_db->psi5_params.psi5_index = 0;
+psc_db->psi5_params.psi5_change_mark = NOT_SET;
+for( i = 0; i < MAX_NR_OF_INSTANCES_OF_PSI5; i++ )
+{
+psc_db->psi5_params.idx[i].start = RRGRR_INVALID_IDX;
+psc_db->psi5_params.idx[i].stop  = RRGRR_INVALID_IDX;
+psc_db->psi5_params.instances[i] = FALSE;
+}
+/*
+* used for checking the consistency of PSI5. instances[0]: number of instances
+*/
+psc_db->psi5_params.instances[MAX_NR_OF_INSTANCES_OF_PSI5] = FALSE;
+grr_init_nc_param( &psc_db->nc_cw.param, TRUE );
+grr_init_xmeas_struct( &psc_db->ext_psi5 );
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+grr_init_enh_param(&psc_db->enh_cw, FALSE);
+grr_init_enh_param(&grr_data->psi.enh_param, FALSE);
+#endif
+} /* psi_reset_psi5 */
+#ifdef REL99
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reset_psi8
++------------------------------------------------------------------------------
+| Description : The function psi_reset_psi8() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL  void psi_reset_psi8 ( void )
+{
+UBYTE n;
+TRACE_FUNCTION( "psi_reset_psi8" );
+/* reset psi_reset_psi8 parameters*/
+psc_db->psi8_params.psi8_index = 0;
+psc_db->psi8_params.psi8_change_mark = NOT_SET;
+for(n = 0; n <MAX_NR_OF_INSTANCES_OF_PSI8 + 1; n++)
+psc_db->psi8_params.instances[n] = FALSE;
+psc_db->send_cbch_info_ind = FALSE;
+psc_db->v_cbch_chan_desc = FALSE;
+} /* psi_reset_psi8 */
+#endif
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reset_psi13
++------------------------------------------------------------------------------
+| Description : The function psi_reset_psi13() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL  void psi_reset_psi13 ( void )
+{
+TRACE_FUNCTION( "psi_reset_psi13" );
+grr_init_nc_param( &psc_db->nc_cw.param, TRUE );
+} /* psi_reset_psi13 */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reset_all
++------------------------------------------------------------------------------
+| Description : The function psi_reset_all() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_reset_all ( void )
+{
+TRACE_FUNCTION( "psi_reset_all" );
+/* reset complete acq.*/
+psi_reset_complete_acq();
+/* reset PSI1 parameters */
+psi_reset_psi1();
+/* reset psi2 parameters*/
+psi_reset_psi2();
+/* reset psi3 parameters*/
+psi_reset_psi3();
+/* reset psi3bis parameters*/
+psi_reset_psi3bis();
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/* reset psi3ter parameters*/
+psi_reset_psi3ter();
+#endif
+/* reset psi4 parameters*/
+psi_reset_psi4();
+/* reset psi5 parameters*/
+psi_reset_psi5();
+#ifdef REL99
+/* reset psi8 parameters*/
+psi_reset_psi8();
+#endif
+/* reset psi13 parameters*/
+psi_reset_psi13();
+/* */
+psc_db->send_psi_status = FALSE;
+/* init the states of the PSI parameters*/
+psi_init_states_of_psi();
+psi_reset_si_entries();
+} /* psi_reset_all() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_stop_10sec
++------------------------------------------------------------------------------
+| Description : The function psi_stop_10sec() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_stop_10sec ( void )
+{
+TRACE_FUNCTION( "psi_stop_10sec" );
+vsi_t_stop(GRR_handle,T_10_SEC);
+} /* psi_stop_10sec() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_start_10sec
++------------------------------------------------------------------------------
+| Description : The function psi_start_10sec() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_start_10sec ( void )
+{
+TRACE_FUNCTION( "psi_start_10sec" );
+if(grr_data->psi.is_start_of_10_sec_allowed)
+vsi_t_start(GRR_handle,T_10_SEC, T_10_SEC_VALUE);
+} /* psi_start_10sec() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_partial_acq
++------------------------------------------------------------------------------
+| Description : The function psi_partial_acq() performs partial acquisition
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_partial_acq ( void )
+{
+UBYTE psi_reading_type;
+UBYTE dummy=0;
+TRACE_FUNCTION( "psi_partial_acq" );
+psi_reading_type = PSI_IN_HR_AND_LR;
+psc_db->acq_type = PARTIAL;
+if(  psc_db->state_of_PSI[PSI2].state EQ NEEDED)
+{
+psi_reading_type = READ_PSI2;
+psi_reset_psi2();
+dummy++;
+TRACE_EVENT("PSI 2 needed");
+}
+if(  psc_db->state_of_PSI[PSI3].state EQ NEEDED)
+{
+psi_reading_type = READ_PSI3_3BIS;
+psi_reset_psi3();
+psi_reset_psi3bis();
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+psi_reset_psi3ter();
+#endif
+dummy++;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+TRACE_EVENT("PSI3/3bis/3ter  needed");
+#else
+TRACE_EVENT("PSI3/3bis needed");
+#endif
+}
+if(  psc_db->state_of_PSI[PSI4].state EQ NEEDED)
+{
+psi_reading_type = READ_PSI4;
+psi_reset_psi4();
+dummy++;
+TRACE_EVENT("PSI 4 needed");
+}
+if(  psc_db->state_of_PSI[PSI5].state EQ NEEDED)
+{
+psi_reading_type = READ_PSI5;
+psi_reset_psi5();
+dummy++;
+TRACE_EVENT("PSI 5 needed");
+}
+#ifdef REL99
+if(  psc_db->state_of_PSI[PSI8].state EQ NEEDED)
+{
+psi_reading_type = READ_PSI8;
+psi_reset_psi8();
+dummy++;
+TRACE_EVENT("PSI 8 needed");
+}
+#endif
+if(dummy > 1)
+psi_reading_type = PSI_IN_HR_AND_LR;
+psi_receive_psi(psi_reading_type);
+} /* psi_partial_acq() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_init_states_of_psi
++------------------------------------------------------------------------------
+| Description : The function psi_init_states_of_psi() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL  void psi_init_states_of_psi ( void )
+{
+psc_db->state_of_PSI[PSI1].state     = NEEDED;
+psc_db->state_of_PSI[PSI2].state     = NEEDED;
+psc_db->state_of_PSI[PSI3].state     = NEEDED;
+psc_db->state_of_PSI[PSI3bis].state  = NEEDED;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+psc_db->state_of_PSI[PSI3ter].state  = NEEDED;
+#endif
+psc_db->state_of_PSI[PSI4].state     = NEEDED;
+psc_db->state_of_PSI[PSI5].state     = NEEDED;
+#ifdef REL99
+psc_db->state_of_PSI[PSI8].state     = NEEDED;
+#endif
+psc_db->state_of_PSI[PSI13].state    = NEEDED;
+}/* psi_init_states_of_psi() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_init_rfl_psi2
++------------------------------------------------------------------------------
+| Description : The function psi_init_rfl_psi2() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_init_rfl_psi2(void)
+{
+UBYTE n;
+/*
+* please note that only the RFL_NUMBERs defined
+* in the PSI2 will be marked as invalid
+*/
+for (n = 0; n < MAX_RFL; n++)
+{
+psc_db->rfl[n].num = NOT_SET;
+}
+}/* psi_init_rfl_psi2() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_init_cell_alloc
++------------------------------------------------------------------------------
+| Description : The function psi_init_cell_alloc() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_init_cell_alloc(void)
+{
+UBYTE n;
+/*TRACE_EVENT("psi_init_cell_alloc");*/
+psc_db->v_cell_alloc = FALSE;
+for (n = 0; n < MAX_CELL_ALLOC; n++)
+psc_db->cell_alloc[n].rfl_num = NOT_SET;
+}/* psi_init_cell_alloc() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_init_gprs_ms_alloc
++------------------------------------------------------------------------------
+| Description : The function psi_init_gprs_ms_alloc() ....
+|
+| Parameters  : BOOL psi2_only
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_init_gprs_ms_alloc(BOOL psi2_only)
+{
+UBYTE n;
+if(psi2_only)
+{
+TRACE_EVENT("remove only PSI2 entries in GPRS_MA");
+}
+else
+{
+TRACE_EVENT("remove all entries in GPRS_MA");
+}
+for (n = 0; n < MAX_GPRS_MS_ALLOC; n++)
+{
+if(psi2_only)
+{
+if(
+(psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num NEQ MA_NUMBER_4_PSI13_OR_CELL_ALLOC )
+AND  /* ignore MA_NUMBER with 14 or 15: 0..13 in PSI2*/
+(psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num NEQ MA_NUMBER_4_ASSIGNMENT )
+)
+{
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num = NOT_SET;
+}
+}
+else
+{
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num = NOT_SET;
+}
+}
+/*
+* When deleting the MA defined in the assignment message,
+* the corresponding RFL list should be deleted, too.
+*/
+psc_db->gprs_ms_alloc_in_assignment.ma_num = NOT_SET;
+psc_db->rfl[MAX_RFL].num                   = NOT_SET;
+}/* psi_init_gprs_ms_alloc() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_init
++------------------------------------------------------------------------------
+| Description : The function psi_init() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_init ( void )
+{
+TRACE_FUNCTION( "psi_init" );
+psi_init_params();
+psi_reset_psi_pos( );
+INIT_STATE(PSI, PSI_NULL);
+} /* psi_init() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_complete_acq
++------------------------------------------------------------------------------
+| Description : The function psi_complete_acq() ....
+|
+| Parameters  : UBYTE acq_type: COMPLETE (in serving cell) or FULL_PSI_IN_NEW_CELL
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_complete_acq ( ACQ_TYPE acq_type )
+{
+TRACE_FUNCTION( "psi_complete_acq" );
+/*
+* Start timer for 10 sec.
+*/
+vsi_t_start(GRR_handle,T_COMP_PSI, T_10_SEC_VALUE);
+psi_receive_psi(READ_COMPLETE);
+psi_reset_all();
+psc_db->acq_type = acq_type;
+psc_db->state_of_PSI[PSI13].state = RECEIPT_OK; /* we do not need to read PSI13 again*/
+} /* psi_complete_acq() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_send_psi_status
++------------------------------------------------------------------------------
+| Description : The function psi_send_psi_status() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_send_psi_status (void )
+{
+TRACE_FUNCTION( "psi_send_psi_status" );
+/* SZML-PSI/003 */
+} /* psi_send_psi_status() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_stop_30sec
++------------------------------------------------------------------------------
+| Description : The function psi_stop_30sec() ....
+|
+| Parameters  : BOOL start_again: whether the timer should be started again or not
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_stop_30sec (BOOL start_again )
+{
+TRACE_FUNCTION( "psi_stop_30sec" );
+vsi_t_stop(GRR_handle,T_30_SEC);
+if(start_again)
+{
+/*
+TRACE_EVENT("30 sec. running");
+*/
+vsi_t_start(GRR_handle,T_30_SEC, T_30_SEC_VALUE);
+}
+else
+{
+TRACE_EVENT("30 sec. stopped");
+}
+} /* psi_stop_30sec() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_start_30sec
++------------------------------------------------------------------------------
+| Description : The function psi_start_30sec() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_start_30sec (void )
+{
+TRACE_FUNCTION( "psi_start_30sec" );
+/*
+TRACE_EVENT("30 sec. running");
+*/
+vsi_t_start(GRR_handle,T_30_SEC, T_30_SEC_VALUE);
+} /* psi_start_30sec() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_start_60sec
++------------------------------------------------------------------------------
+| Description : The function psi_start_60sec() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_start_60sec ( void )
+{
+TRACE_FUNCTION( "psi_start_60sec" );
+/*
+TRACE_EVENT("60 sec. running");
+*/
+vsi_t_start(GRR_handle,T_60_SEC, T_60_SEC_VALUE);
+} /* psi_start_60sec() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_stop_60sec
++------------------------------------------------------------------------------
+| Description : The function psi_stop_60sec () ....
+|
+| Parameters  : BOOL start_again
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_stop_60sec ( BOOL start_again )
+{
+TRACE_FUNCTION( "psi_stop_60sec " );
+vsi_t_stop(GRR_handle,T_60_SEC);
+if(start_again)
+{
+/*
+TRACE_EVENT("60 sec. running");
+*/
+vsi_t_start(GRR_handle,T_60_SEC, T_60_SEC_VALUE);
+}
+else
+{
+TRACE_EVENT("60 sec. stopped");
+}
+} /* psi_stop_60sec () */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_copy_ma_from_psi13
++------------------------------------------------------------------------------
+| Description : The function psi_copy_ma_from_psi13() ....
+|
+| Parameters  : T_gprs_ms_alloc* ms_alloc: pointer to T_gprs_ms_alloc
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_copy_ma_from_psi13(T_gprs_ms_alloc_ie* ms_alloc)
+{
+UBYTE n;
+MCAST(si13,D_SYS_INFO_13); /* T_D_SYS_INFO_13  */
+TRACE_FUNCTION( "psi_copy_ma_from_psi13 " );
+if(D_SYS_INFO_13 NEQ si13->msg_type)
+{  /* PSI13 was received */
+for(n = 0; n < MAX_GPRS_MS_ALLOC; n++)
+{
+if( (psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num EQ MA_NUMBER_4_PSI13_OR_CELL_ALLOC) ||
+(psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num EQ NOT_SET) )
+{
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num = MA_NUMBER_4_PSI13_OR_CELL_ALLOC;
+memcpy(&(psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie),
+ms_alloc, sizeof(T_gprs_ms_alloc_ie));
+n = MAX_GPRS_MS_ALLOC; /* break for loop*/
+}
+}
+}
+else
+{  /* SI13 was received */
+UBYTE i;
+T_gprs_ma *gprs_ma = (T_gprs_ma*)ms_alloc;
+for(n = 0; n < MAX_GPRS_MS_ALLOC; n++)
+{
+if( (psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num EQ MA_NUMBER_4_PSI13_OR_CELL_ALLOC) ||
+(psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num EQ NOT_SET) )
+{
+memset(&(psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie), 0,
+sizeof(T_gprs_ms_alloc_ie));
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num =
+MA_NUMBER_4_PSI13_OR_CELL_ALLOC;
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie.hsn =
+gprs_ma->hsn;
+if(gprs_ma->v_rfln)
+{
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie.v_rfl_num_list
+= TRUE;
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie.c_rfl_num_list
+= gprs_ma->c_rfln;
+for(i = 0;i < gprs_ma->c_rfln;i++)
+{
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie.rfl_num_list[i].rfl_num
+= gprs_ma->rfln[i];
+}
+}
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie.flag =
+gprs_ma->hop;
+if(gprs_ma->hop)
+{
+if(gprs_ma->v_arfcn_idx)
+{
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie.v_arfcn_index_list
+= TRUE;
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie.c_arfcn_index_list
+= gprs_ma->c_arfcn_idx;
+for(i = 0;i < gprs_ma->c_arfcn_idx;i++)
+{
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie.arfcn_index_list[i].arfcn_index
+= gprs_ma->arfcn_idx[i];
+}
+}
+}
+else
+{
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie.v_ma_struct
+= TRUE;
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie.ma_struct.ma_len
+= gprs_ma->allo_len6;
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie.ma_struct.c_ma_map
+= gprs_ma->c_allo_bmp6;
+for(i = 0;i < gprs_ma->c_allo_bmp6;i++)
+{
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie.ma_struct.ma_map[i]
+= gprs_ma->allo_bmp6[i];
+}
+}
+break;
+}
+}
+}
+}/*psi_copy_ma_from_psi13*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_process_si13()
++------------------------------------------------------------------------------
+| Description : The function psi_process_si13()....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_SI13_RET psi_process_si13( T_D_SYS_INFO_13 *si13)
+{
+BOOL pbcch_was_present;
+T_SI13_RET ret_value = SI13_OK;
+#ifdef REL99
+UBYTE current_nw_rel = psc_db->network_rel;
+#endif
+TRACE_FUNCTION( "psi_process_si13" );
+if(!si13->si13_rest_oct.v_si13_info)
+{
+TRACE_ERROR( "No restoctects present in SI13: reread si13" );
+ret_value = SI13_REREAD;
+}
+else
+{
+#ifdef REL99
+/* Update the BSS release when the 1st SI13 message is received in case of
+* PBCCH's PRESENCE.
+* The correct BSS release will be updated after receiving PSIs
+*/
+if(si13->si13_rest_oct.si13_info.flag1)
+{
+/* PBCCH is present in the cell */
+/* This is the 1st SI13 message */
+if(psc_db->psi13_params.bcch_change_mark EQ NOT_SET)
+{
+/* Update the BSS and the SGSN releases */
+psi_update_bss_sgsn_rel(si13, PBCCH_PRESENT);
+}
+}
+else
+{
+/* Update the BSS and SGSN releases every time the SI13 message is received
+* in case of PBCCH's ABSENCE.
+*/
+psi_update_bss_sgsn_rel(si13, PBCCH_NOT_PRESENT);
+if(psc_db->network_rel NEQ current_nw_rel)
+{
+TRACE_EVENT_P2("((SI13)BSS Network release changed from %d to %d <0 - REL_97, 1 - REL_99, 2 - REL_04>",
+current_nw_rel, psc_db->network_rel);
+}
+}
+#endif
+pbcch_was_present = grr_is_pbcch_present();
+/*
+* Copy PBCCH or non PBCCH desc. and change field
+*/
+if( !pbcch_was_present AND si13->si13_rest_oct.si13_info.v_pbcch_des )
+{
+/* No PBCCH description was present in the GPRS_DATA_BASE or PBCCH was released:
+* SI13 message contains PBCCH description, so we have to start a complete acq of
+* PSI messages.
+*/
+if(psc_db->psi13_params.bcch_change_mark EQ NOT_SET)
+{
+psi_copy_si13_params(si13);
+}
+psc_db->psi13_params.bcch_change_mark = si13->si13_rest_oct.si13_info.bcch_cm;
+ret_value = SI13_COMPLETE_PSI;
+}
+else
+{
+psi_copy_si13_params(si13);
+/*
+* There is no PBCCH description present in the SI13 message and there can be
+* no PBCCH description in the GPRS_DATA_BASE
+*/
+if(psc_db->psi13_params.bcch_change_mark NEQ NOT_SET)
+{
+/*
+* This is not the first SI13 message.
+* Check BCCH_CHANGE_MARK
+*/
+{
+UBYTE incremented_value =
+psi_compare_change_mark
+(
+si13->si13_rest_oct.si13_info.bcch_cm,
+psc_db->psi13_params.bcch_change_mark
+);
+if(incremented_value EQ 1)      /*partial acq*/
+{
+if(psi_is_update_needed(si13->si13_rest_oct.si13_info.si_cf))
+{
+ret_value = SI13_PARTIAL_SI;
+}
+}
+else if(incremented_value > 1) /* incremented_value > 1: complete acq*/
+{
+ret_value = SI13_COMPLETE_SI;
+}
+}
+}
+psc_db->psi13_params.bcch_change_mark = si13->si13_rest_oct.si13_info.bcch_cm;
+}
+}
+psc_db->state_of_PSI[PSI13].state = RECEIPT_OK;
+grr_set_pg_nmo();
+TRACE_EVENT_P1("SI13 processed: %d", ret_value);
+return ret_value;
+} /* psi_process_si13() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_process_psi13
++------------------------------------------------------------------------------
+| Description : The function psi_process_psi13() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_PSI13_RET psi_process_psi13 ( T_PSI_13 * psi13 )
+{
+T_PSI13_RET ret_val = PSI13_OK;
+TRACE_FUNCTION( "psi_process_psi13" );
+if(grr_is_pbcch_present())
+{
+/*
+* PBCCH description already exists: we have to compare PBCCH parameters
+*/
+if(psi_is_pbcch_des_different(psi13))
+{
+/*
+* PBCCH no longer available
+* or PBCCH description is differnt from the saved one in the MS
+*/
+if(psi13->flag)
+{
+ret_val =  PSI13_COMPLETE_PSI;
+}
+else
+{
+ret_val =  PSI13_PBCCH_RELEASED;
+}
+}
+else
+{
+/*
+* PBCCH description is the same
+* Copy at least SI13_CHANGE_MARK and GPRS Mobile Allocation
+*/
+psi_copy_psi13_params(psi13);
+#ifdef REL99
+/* PSI13 message has been received when PBCCH is present.
+* CBCH information may have to be updated if hopping is
+* allowed.
+*/
+if(psc_db->v_cbch_chan_desc AND !psc_db->cbch_chan_desc.freq_par.v_arfcn)
+{
+sig_psi_ctrl_cbch_info_ind();
+}
+#endif
+/*
+* Check BCCH_CHANGE_MARK
+*/
+{
+UBYTE incremented_value = psi_compare_change_mark(psi13->bcch_change_ma, psc_db->psi13_params.bcch_change_mark);
+psc_db->psi13_params.bcch_change_mark = psi13->bcch_change_ma;
+if(incremented_value EQ 1)      /*partial acq*/
+{
+if(psi_is_update_needed(psi13->si_change_ma))
+{
+ret_val = PSI13_PARTIAL_SI;
+}
+}
+else if(incremented_value > 1) /* incremented_value > 1: complete acq*/
+{
+ret_val = PSI13_COMPLETE_SI;
+}
+}
+}
+}
+else
+{
+/*
+* No PBCCH description present in the GPRS_DATA_BASE:
+* and we received a PSI13 in BCCH_TRANSFER state
+* So we have to check whether this message contains a
+* PBCCH description or not. If YES, complete acq. of PSI
+* messages should be started. If NO, BCCH_CHANGE_MARK should be compared
+*/
+if(psi13->flag)
+{
+ret_val = PSI13_PBCCH_ESTABLISHED;
+}
+else
+{
+/*
+* Copy PBCCH or non PBCCH desc. and change field
+*/
+psi_copy_psi13_params(psi13);
+{
+UBYTE incremented_value = psi_compare_change_mark(psi13->bcch_change_ma, psc_db->psi13_params.bcch_change_mark);
+psc_db->psi13_params.bcch_change_mark = psi13->bcch_change_ma;
+if(incremented_value EQ 1)      /*partial acq*/
+{
+if(psi_is_update_needed(psi13->si_change_ma))
+{
+ret_val = PSI13_PARTIAL_SI;
+}
+}
+else if(incremented_value > 1) /* incremented_value > 1: complete acq*/
+{
+ret_val = PSI13_COMPLETE_SI;
+}
+}
+}
+}
+#ifdef REL99
+/* Update the SGSN release */
+if (psi13->v_release_99_str_psi_13)
+{
+psc_db->sgsn_rel = psi13->release_99_str_psi_13.sgsnr ? PS_SGSN_99_ONWARDS : PS_SGSN_98_OLDER;
+/* Update the SGSN release in the Common library context */
+cl_nwrl_set_sgsn_release(psc_db->sgsn_rel);
+}
+#endif
+psc_db->state_of_PSI[PSI13].state = RECEIPT_OK;
+grr_set_pg_nmo();
+return ret_val;
+} /* psi_process_psi13() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_process_psi5
++------------------------------------------------------------------------------
+| Description : The function psi_process_psi5() ....
+|
+| Parameters  : T_PSI_5 *psi5
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_PSI5_RET psi_process_psi5 (T_PSI_5 *psi5 )
+{
+BOOL  is_psi5_ok;
+UBYTE n;
+BOOL  cpy_prm_set;
+TRACE_FUNCTION( "psi_process_psi5" );
+/*
+* Check consistency
+*/
+if(psc_db->psi5_params.psi5_change_mark EQ NOT_SET)
+{
+/*
+* Copy change mark etc.
+*/
+psc_db->psi5_params.psi5_change_mark = psi5->psi5_cm;
+psc_db->psi5_params.psi5_count   = psi5->psi5_cnt;
+psc_db->psi5_params.instances[0] = psi5->psi5_cnt;/* number of instances */
+}
+else
+{
+/*
+* There is a valid change mark present in the database
+* Check consistency of COUNT and INDEX
+*/
+if(
+(psc_db->psi5_params.psi5_count NEQ psi5->psi5_cnt)
+OR
+(psc_db->psi5_params.psi5_count < psi5->psi5_ind)
+OR
+(psc_db->psi5_params.psi5_change_mark NEQ psi5->psi5_cm)
+)
+{
+/*
+* Error situation read a new PSI5
+* The PSI5 change mark field is changed each time information has been updated
+* A new value indicates that the mobile
+* station shall re-read the information from the PSI5
+*/
+TRACE_ERROR( "PSI5: inconsistent parameter" );
+psc_db->is_ext_psi5_valid = FALSE;
+return PSI5_REREAD;
+}
+/* psi5_change_markhas not changed, i.e.
+* PSI5 message has not changed, we already have a consistent set, so we
+* do not have to read the PSI5 message
+*/
+if((psc_db->psi5_params.psi5_change_mark EQ psi5->psi5_cm) &&
+(psc_db->state_of_PSI[PSI5].state EQ RECEIPT_OK))
+{
+/* Message has not changed, we already have a consistent set, so we
+* do not have to read it
+*/
+TRACE_EVENT( "PSI5: message has not changed" );
+return PSI5_OK;
+}
+}
+psc_db->psi5_params.psi5_index = psi5->psi5_ind;
+if( psc_db->psi5_params.instances[psi5->psi5_ind + 1] EQ FALSE )
+{
+if( grr_data->nc2_on )
+{
+if(
+psi5->v_nc_meas_par AND
+(
+psc_db->nc_cw.param.idx EQ NOT_SET        OR
+psc_db->nc_cw.param.idx <  psi5->psi5_ind
+)
+)
+{
+/*
+* This is the first time that we want to save network controlled
+* measurement parameters or the last index for NC parameters were
+* not bigger than the currently received one.
+*
+* Maybe more than one instance of PSI5, store data in temporary location.
+*/
+grr_data->psi.v_nc_param = TRUE;
+grr_prcs_nc_param_struct
+( &grr_data->psi.nc_param, &psi5->nc_meas_par, psi5->psi5_ind );
+}
+if( psi5->v_xmeas_par )
+{
+cpy_prm_set = ( psc_db->ext_psi5.idx EQ NOT_SET        OR
+psc_db->ext_psi5.idx <  psi5->psi5_ind    );
+grr_prcs_xmeas_struct ( &psc_db->ext_psi5,
+&psi5->xmeas_par,
+cpy_prm_set,
+psi5->psi5_ind,
+&psc_db->psi5_params.idx[psi5->psi5_ind].start,
+&psc_db->psi5_params.idx[psi5->psi5_ind].stop );
+}
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+if(psi5->v_release_99_str_psi_5 AND psi5->release_99_str_psi_5.v_enh_rep_param_struct)
+{
+psc_db->psi5_params.v_enh_rep_param_struct = TRUE;
+grr_prcs_enh_param_cw_temp
+( &grr_data->psi.enh_param, &psi5->release_99_str_psi_5.enh_rep_param_struct,
+psi5->psi5_ind );
+}
+#endif
+}
+/*
+* check whether PSI5 has been received completely or not
+*/
+psc_db->psi5_params.instances[psi5->psi5_ind + 1] = TRUE;
+is_psi5_ok = TRUE;
+for(n = 0; n <= psc_db->psi5_params.instances[0]; n++ )
+{
+if(!(psc_db->psi5_params.instances[n + 1]))
+{
+is_psi5_ok = FALSE;/* consistent set of PSI5 not complete */
+break;
+}
+}
+TRACE_EVENT_P2( "PSI5: received with count = %d, index = %d ",
+psi5->psi5_cnt, psi5->psi5_ind);
+if(is_psi5_ok)
+{
+psc_db->state_of_PSI[PSI5].state = RECEIPT_OK;
+/*
+* the NC parameter are stored temporarily and
+* now transferred to final location
+*/
+if( grr_data->nc2_on )
+{
+grr_prcs_nc_param_final ( &psc_db->nc_cw.param,
+&grr_data->psi.v_nc_param,
+&grr_data->psi.nc_param );
+grr_sort_ext_lst_freq ( &psc_db->ext_psi5.em1.list,
+MAX_NR_OF_INSTANCES_OF_PSI5,
+&psc_db->psi5_params.idx[0] );
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+if(rr_get_support_for_emr() AND psc_db->psi5_params.v_enh_rep_param_struct)
+{
+/*
+* the ENH parameter are stored temporarily and
+* now transferred to final location
+*/
+memcpy(&(psc_db->enh_cw), &(grr_data->psi.enh_param),
+sizeof(T_GRR_ENH_PARA));
+}
+else
+{
+memset(&(psc_db->enh_cw), 0, sizeof(T_GRR_ENH_PARA));
+psc_db->enh_cw.rept_type = REPORT_TYPE_REP;
+psc_db->psi5_params.v_enh_rep_param_struct = FALSE;
+}
+#endif
+/*
+* Inform MEAS that the Interference parameters are valid
+*/
+psc_db->is_ext_psi5_valid = TRUE;
+return PSI5_MEAS_PARAM_VALID;
+}
+}
+}
+else
+{
+TRACE_EVENT_P2( "PSI5: already received with count = %d, index = %d",
+psi5->psi5_cnt, psi5->psi5_ind );
+}
+return PSI5_OK;
+} /* psi_process_psi5() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_process_psi4
++------------------------------------------------------------------------------
+| Description : The function psi_process_psi4() ....
+|
+| Parameters  : T_PSI_4 *psi4
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_PSI4_RET psi_process_psi4 (T_PSI_4 *psi4 )
+{
+UBYTE i,m,n;
+BOOL is_psi4_ok;
+TRACE_FUNCTION( "psi_process_psi4" );
+/*
+* Check consistency
+*/
+if(psc_db->psi4_params.psi4_change_mark EQ NOT_SET)
+{
+/*
+* Copy change mark etc.
+*/
+psc_db->psi4_params.psi4_change_mark = psi4->psi4_cm;
+psc_db->psi4_params.psi4_count   = psi4->psi4_cnt;
+psc_db->psi4_params.instances[0] = psi4->psi4_cnt;/* number of instances */
+}
+else
+{
+/*
+* There is a valid change mark present in the database
+* Check consistency of COUNT and INDEX
+*/
+if(
+(psc_db->psi4_params.psi4_count NEQ psi4->psi4_cnt)
+OR
+(psc_db->psi4_params.psi4_count < psi4->psi4_ind)
+OR
+(psc_db->psi4_params.psi4_change_mark NEQ psi4->psi4_cm)
+)
+{
+/*
+* Error situation read a new PSI4
+* The PSI4 change mark field is changed each time information has been updated
+* A new value indicates that the mobile
+* station shall re-read the information from the PSI4
+*/
+TRACE_ERROR( "PSI4: inconsistent parameters" );
+psc_db->number_of_valid_int_meas_channels = 0;
+return PSI4_REREAD;
+}
+/* psi4_change_markhas not changed, i.e.
+* PSI4 message has not changed, we already have a consistent set, so we
+* do not have to read the PSI4 message
+*/
+if((psc_db->psi4_params.psi4_change_mark EQ psi4->psi4_cm) &&
+(psc_db->state_of_PSI[PSI4].state EQ RECEIPT_OK))
+{
+/* Message has not changed, we already have a consistent set, so we
+* do not have to read it
+*/
+TRACE_EVENT( "PSI4: message has not changed" );
+return PSI4_OK;
+}
+}
+psc_db->psi4_params.psi4_index = psi4->psi4_ind;
+if( psc_db->psi4_params.instances[psi4->psi4_ind + 1] EQ FALSE )
+{
+/*
+* We assume that we receive PSI4 instances in the right order,
+* i.e. instance1, instance2, instance3, ..., instance8
+* This is ETSI-Requirement 05.02
+*/
+m = psc_db->number_of_valid_int_meas_channels;
+if(m < MAX_CHAN_IMEAS)
+{
+/*
+* copy first channel list in the current instance
+*/
+psc_db->int_meas_chan_list[m].v_arfcn = FALSE;
+psc_db->int_meas_chan_list[m].v_ma_num_maio = FALSE;
+if(psi4->chan_list_imeas.chan_group.v_arfcn)
+{
+psc_db->int_meas_chan_list[m].v_arfcn = TRUE;        /* valid-flag   for arfcn*/
+psc_db->int_meas_chan_list[m].arfcn = psi4->chan_list_imeas.chan_group.arfcn; /* ARFCN*/
+}
+else
+{
+psc_db->int_meas_chan_list[m].v_ma_num_maio = TRUE;
+psc_db->int_meas_chan_list[m].ma_num = psi4->chan_list_imeas.chan_group.ma_num_maio.ma_num;
+psc_db->int_meas_chan_list[m].maio = psi4->chan_list_imeas.chan_group.ma_num_maio.maio;
+}
+psc_db->int_meas_chan_list[m].ts_alloc = psi4->chan_list_imeas.chan_group.ts_alloc;
+m++;
+if(psi4->chan_list_imeas.v_chan_list2)
+{
+for(i=0; i < (psi4->chan_list_imeas.c_chan_list2) AND (m < MAX_CHAN_IMEAS); i++ )
+{
+/*
+* copy remaining channel list in the current instance
+*/
+psc_db->int_meas_chan_list[m].v_arfcn = FALSE;
+psc_db->int_meas_chan_list[m].v_ma_num_maio = FALSE;
+if(psi4->chan_list_imeas.chan_list2[i].chan_group.v_arfcn)
+{
+psc_db->int_meas_chan_list[m].v_arfcn = TRUE;        /* valid-flag   for arfcn*/
+psc_db->int_meas_chan_list[m].arfcn = psi4->chan_list_imeas.chan_list2[i].chan_group.arfcn; /* ARFCN*/
+}
+else
+{
+psc_db->int_meas_chan_list[m].v_ma_num_maio = TRUE;
+psc_db->int_meas_chan_list[m].ma_num = psi4->chan_list_imeas.chan_list2[i].chan_group.ma_num_maio.ma_num;
+psc_db->int_meas_chan_list[m].maio = psi4->chan_list_imeas.chan_list2[i].chan_group.ma_num_maio.maio;
+}
+psc_db->int_meas_chan_list[m].ts_alloc = psi4->chan_list_imeas.chan_list2[i].chan_group.ts_alloc;
+m++;
+}
+}
+}
+else
+{
+TRACE_ERROR( "PSI4: list of INT meas. channels full" );
+}
+psc_db->number_of_valid_int_meas_channels = m;
+/*
+* check whether PSI4 has been received completely or not
+*/
+psc_db->psi4_params.instances[psi4->psi4_ind + 1] = TRUE;
+is_psi4_ok = TRUE;
+for(n = 0; n <= psc_db->psi4_params.instances[0]; n++ )
+{
+if(!(psc_db->psi4_params.instances[n + 1]))
+{
+is_psi4_ok = FALSE;/* consistent set of PSI4 not complete */
+break;
+}
+}
+TRACE_EVENT_P2( "PSI4: received with count = %d, index = %d",
+psi4->psi4_cnt, psi4->psi4_ind );
+if(is_psi4_ok)
+{
+psc_db->state_of_PSI[PSI4].state = RECEIPT_OK;
+return PSI4_INT_LIST_VALID;
+}
+}
+else
+{
+TRACE_EVENT_P2( "PSI4: already received with count = %d, index = %d",
+psi4->psi4_cnt, psi4->psi4_ind );
+}
+return PSI4_OK;
+} /* psi_process_psi4() */
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/*
++------------------------------------------------------------------------------
+| Function    : psi_process_psi3ter
++------------------------------------------------------------------------------
+| Description : The function psi_process_psi3ter() processes the IEs received
+|               in PSI3 ter message
+|
+| Parameters  : T_PSI_3_TER *psi3ter
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_PSI3TER_RET psi_process_psi3ter (T_PSI_3_TER *psi3ter)
+{
+BOOL is_psi3ter_ok;
+#ifdef TI_PS_FF_RTD
+UBYTE n,rtd_index;
+#else
+UBYTE n;
+#endif /* #ifdef TI_PS_FF_RTD */
+TRACE_FUNCTION( "psi_process_psi3ter" );
+if(psc_db->psi3ter_params.psi3ter_change_mark EQ NOT_SET)
+{
+if(  ( (psc_db->psi3_params.psi3_change_mark NEQ NOT_SET) AND
+(psi3ter->psi3_cm NEQ psc_db->psi3_params.psi3_change_mark) ) OR
+( (psc_db->psi3bis_params.psi3bis_change_mark NEQ NOT_SET) AND
+(psi3ter->psi3_cm NEQ psc_db->psi3bis_params.psi3bis_change_mark) )  )
+{
+/*
+* Error situation read new PSI3ter
+* The PSI3 change mark field is changed each time information has been updated
+* in any of the PSI3 to PSI3 ter messages. A new value indicates that the mobile
+* station shall re-read the information from the PSI3 to PSI3 ter messages.
+*/
+TRACE_ERROR( "PSI3ter: inconsistent change mark, read PSI3 to PSI3ter");
+return PSI3TER_REREAD_PSI3_3BIS_3TER;
+}
+/*
+* Copy change mark etc.
+*/
+psc_db->psi3ter_params.psi3ter_change_mark = psi3ter->psi3_cm;
+psc_db->psi3ter_params.psi3ter_count       = psi3ter->psi3ter_cnt;
+psc_db->psi3ter_params.instances[0]        = psi3ter->psi3ter_cnt; /* number of instances */
+}
+else
+/*
+* There is a valid change mark present in the database
+* Check consistency of COUNT and INDEX
+*/
+{
+if(  (psc_db->psi3ter_params.psi3ter_change_mark NEQ psi3ter->psi3_cm) OR
+( (psc_db->psi3_params.psi3_change_mark NEQ NOT_SET) AND
+(psc_db->psi3ter_params.psi3ter_change_mark NEQ
+psc_db->psi3_params.psi3_change_mark) ) OR
+( (psc_db->psi3bis_params.psi3bis_change_mark NEQ NOT_SET) AND
+(psc_db->psi3ter_params.psi3ter_change_mark NEQ
+psc_db->psi3bis_params.psi3bis_change_mark) )  )
+{
+/*
+* Error situation read new PSI3ter
+* The PSI3 change mark field is changed each time information has been updated
+* in any of the PSI3 to PSI3 ter messages. A new value indicates that the mobile
+* station shall re-read the information from the PSI3 to PSI3 ter messages.
+*/
+TRACE_ERROR( "PSI3ter: inconsistent change mark, read PSI3 to PSI3ter");
+return PSI3TER_REREAD_PSI3_3BIS_3TER;
+}
+if( (psc_db->psi3ter_params.psi3ter_count NEQ psi3ter->psi3ter_cnt) OR
+(psc_db->psi3ter_params.psi3ter_count < psi3ter->psi3ter_ind) )
+{
+TRACE_ERROR( "PSI3ter: inconsistent parameters, read PSI3ter");
+return PSI3TER_REREAD_PSI3TER;
+}
+if((psc_db->psi3ter_params.psi3ter_change_mark EQ psi3ter->psi3_cm) AND
+(psc_db->state_of_PSI[PSI3ter].state EQ RECEIPT_OK))
+{
+/* Message has not changed, we already have a consistent set, so we
+* do not have to read it
+*/
+TRACE_EVENT("PSI3ter: message has not changed");
+return PSI3TER_OK;
+}
+} /* psi3ter_change_mark valid */
+psc_db->psi3ter_params.psi3ter_index = psi3ter->psi3ter_ind;
+if( psc_db->psi3ter_params.instances[psi3ter->psi3ter_ind + 1] EQ FALSE )
+{
+/*
+* Copy GPRS report priority parameters
+*/
+/* GPRS Report priority can be received in only one instance since start
+index is not given for mapping to BA as in RTD and BSIC mapping in SI */
+if( (psi3ter->rtd_rep_prio_trnc_grp.v_gprs_rep_prio_cell_desc EQ TRUE) AND
+(psi3ter->rtd_rep_prio_trnc_grp.gprs_rep_prio_cell_desc.number_cells NEQ 0) )
+{
+if(psi3ter->rtd_rep_prio_trnc_grp.gprs_rep_prio_cell_desc.number_cells > MAX_NR_OF_GSM_NC)
+{
+grr_data->psi.enh_param.gprs_rept_prio_desc.num_cells =
+MAX_NR_OF_GSM_NC;
+}
+else
+{
+grr_data->psi.enh_param.gprs_rept_prio_desc.num_cells =
+psi3ter->rtd_rep_prio_trnc_grp.gprs_rep_prio_cell_desc.number_cells;
+/* Set default report prio for the remaining cells upto max of 96 cells */
+for(n = psi3ter->rtd_rep_prio_trnc_grp.gprs_rep_prio_cell_desc.number_cells;
+n < MAX_NR_OF_GSM_NC; n++)
+{
+grr_data->psi.enh_param.gprs_rept_prio_desc.rept_prio[n] =
+NORMAL_PRIO;
+}
+}
+for (n = 0; n < grr_data->psi.enh_param.gprs_rept_prio_desc.num_cells; n++)
+{
+grr_data->psi.enh_param.gprs_rept_prio_desc.rept_prio[n] =
+psi3ter->rtd_rep_prio_trnc_grp.gprs_rep_prio_cell_desc.rep_prio[n];
+}
+}
+#ifdef TI_PS_FF_RTD
+/* Store the received RTD values into the temporary location */
+if(psi3ter->rtd_rep_prio_trnc_grp.v_real_time_diff EQ TRUE)
+{
+if(psi3ter->rtd_rep_prio_trnc_grp.real_time_diff.v_rtd_struct_6bit EQ TRUE)
+{
+if(psi3ter->rtd_rep_prio_trnc_grp.real_time_diff.rtd_struct_6bit.v_cell_index_start_rtd EQ TRUE)
+rtd_index = psi3ter->rtd_rep_prio_trnc_grp.real_time_diff.rtd_struct_6bit.cell_index_start_rtd;
+else
+rtd_index = RTD_DEFAULT_INDEX;
+if( rtd_index < MAX_NR_OF_NCELL )
+{
+grr_data->psi.rtd[rtd_index] = psi3ter->rtd_rep_prio_trnc_grp.real_time_diff.rtd_struct_6bit.rtd6_struct.rtd_6bit;
+for(n=0;n<psi3ter->rtd_rep_prio_trnc_grp.real_time_diff.rtd_struct_6bit.c_rtd6_struct_opt_array AND rtd_index < MAX_NR_OF_NCELL - 1;n++)
+{
+rtd_index++;
+grr_data->psi.rtd[rtd_index] = psi3ter->rtd_rep_prio_trnc_grp.real_time_diff.rtd_struct_6bit.rtd6_struct_opt_array[n].rtd_6bit;
+} /*for*/
+} /*if*/
+} /*if*/
+if(psi3ter->rtd_rep_prio_trnc_grp.real_time_diff.v_rtd_struct_12bit EQ TRUE)
+{
+if(psi3ter->rtd_rep_prio_trnc_grp.real_time_diff.rtd_struct_12bit.v_cell_index_start_rtd EQ TRUE)
+rtd_index = psi3ter->rtd_rep_prio_trnc_grp.real_time_diff.rtd_struct_12bit.cell_index_start_rtd;
+else
+rtd_index = RTD_DEFAULT_INDEX;
+if( rtd_index < MAX_NR_OF_NCELL )
+{
+grr_data->psi.rtd[rtd_index] = RTD_12BIT;
+grr_data->psi.rtd[rtd_index] |= psi3ter->rtd_rep_prio_trnc_grp.real_time_diff.rtd_struct_12bit.rtd12_struct.rtd_12bit;
+for(n=0;n<psi3ter->rtd_rep_prio_trnc_grp.real_time_diff.rtd_struct_12bit.c_rtd12_struct_opt_array AND rtd_index < MAX_NR_OF_NCELL - 1;n++)
+{
+rtd_index++;
+grr_data->psi.rtd[rtd_index] = RTD_12BIT;
+grr_data->psi.rtd[rtd_index] |= psi3ter->rtd_rep_prio_trnc_grp.real_time_diff.rtd_struct_12bit.rtd12_struct_opt_array[n].rtd_12bit;
+} /*for*/
+}/*if*/
+} /*if*/
+} /*if*/
+#endif /* #ifdef TI_PS_FF_RTD */
+TRACE_EVENT_P2( "PSI3ter: received with count = %d, index = %d",
+psi3ter->psi3ter_cnt, psi3ter->psi3ter_ind );
+/*
+* check whether PSI3TER has been received completely or not
+*/
+psc_db->psi3ter_params.instances[psi3ter->psi3ter_ind + 1] = TRUE;
+psc_db->psi3ter_params.prev_psi3ter_index =
+psc_db->psi3ter_params.psi3ter_index;
+is_psi3ter_ok = TRUE;
+for(n = 0; n <= psc_db->psi3ter_params.instances[0]; n++ )
+{
+if(!(psc_db->psi3ter_params.instances[n + 1]))
+{
+is_psi3ter_ok = FALSE;/* consistent set of PSI3TER not complete */
+break;
+}
+}
+if(is_psi3ter_ok)
+{
+psc_db->state_of_PSI[PSI3ter].state = RECEIPT_OK;
+/* Copy the GPRS priority information to permanent storage */
+if(grr_data->psi.enh_param.gprs_rept_prio_desc.num_cells NEQ 0)
+{
+for(n = 0; n <= grr_data->psi.enh_param.gprs_rept_prio_desc.num_cells; n++)
+{
+psc_db->enh_cw.gprs_rept_prio_desc.rept_prio[n] =
+grr_data->psi.enh_param.gprs_rept_prio_desc.rept_prio[n];
+}
+/* Initialize to 0 before receiving the next consistent set of PSI3 ter */
+grr_data->psi.enh_param.gprs_rept_prio_desc.num_cells = 0;
+}
+else
+{
+/* Set report priority to NORMAL if not received */
+for(n = 0; n < MAX_NR_OF_GSM_NC; n++)
+{
+psc_db->enh_cw.gprs_rept_prio_desc.rept_prio[n] = NORMAL_PRIO;
+}
+}
+#ifdef TI_PS_FF_RTD
+/* store the RTD values received in all instances of PSI3ter in permanent location */
+memcpy(&psc_db->rtd,&grr_data->psi.rtd,MAX_NR_OF_NCELL*sizeof(T_RTD_VALUE));
+/* reset the temporary storage to RTD value not available */
+for( n = 0; n < MAX_NR_OF_NCELL; n++ )
+grr_data->psi.rtd[n] = RTD_NOT_AVAILABLE;
+#endif /* #ifdef TI_PS_FF_RTD */
+return PSI3TER_OK;
+}
+}
+else
+{
+TRACE_EVENT_P2( "PSI3ter: already received with count = %d, index = %d",
+psi3ter->psi3ter_cnt, psi3ter->psi3ter_ind );
+}
+return PSI3TER_OK;
+} /* psi_process_psi3ter() */
+#endif
+/*
++------------------------------------------------------------------------------
+| Function    : psi_process_psi3bis
++------------------------------------------------------------------------------
+| Description : The function psi_process_psi3bis() ....
+|
+| Parameters  : T_PSI_3_BIS *psi3bis
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_PSI3BIS_RET psi_process_psi3bis (T_PSI_3_BIS *psi3bis)
+{
+BOOL is_psi3bis_ok;
+UBYTE n;
+TRACE_FUNCTION( "psi_process_psi3bis" );
+/*
+* Each neighbour cell listed in PSI3 and in one or more instances
+* of PSI3bis is assigned an ascending index used for measurement reports.
+* The first neighbour cell in PSI3 has the lowest index  (= 0),
+* and the last neighbour cell in the highest indexed PSI3bis message has
+* the highest index. The total number of neighbour cells in the BA-GPRS
+* shall not exceed 32.
+* If a mobile station receives more than 32 cells in the BA-GPRS,
+* only the 32 cells with the lowest indexes shall be considered.
+*/
+if(psc_db->psi3bis_params.psi3bis_change_mark EQ NOT_SET)
+{
+/*
+* Copy change mark etc.
+*/
+psc_db->psi3bis_params.psi3bis_change_mark = psi3bis->psi3_cm;
+psc_db->psi3bis_params.psi3bis_count       = psi3bis->psi3bis_cnt;
+psc_db->psi3bis_params.instances[0]        = psi3bis->psi3bis_cnt; /* number of instances */
+}
+else
+{
+/*
+* There is a valid change mark present in the database
+* Check consistency of COUNT and INDEX
+*/
+if(
+(psc_db->psi3bis_params.psi3bis_count NEQ psi3bis->psi3bis_cnt)
+OR
+(psc_db->psi3bis_params.psi3bis_count < psi3bis->psi3bis_ind)
+OR
+(psc_db->psi3bis_params.psi3bis_change_mark NEQ psi3bis->psi3_cm)
+)
+{
+/*
+* Error situation read a new PSI3bis
+* The PSI3 change mark field is changed each time information has been updated
+* in any of the PSI3 or PSI3 bis messages. A new value indicates that the mobile
+* station shall re-read the information from the PSI3 and all PSI3 bis messages.
+*/
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+TRACE_ERROR( "PSI3bis: inconsistent parameters, read PSI3 PSI3bis and PSI3ter");
+return PSI3BIS_REREAD_PSI3_3BIS_3TER;
+#else
+TRACE_ERROR( "PSI3bis: inconsistent parameters, read PSI3 and PSI3bis");
+return PSI3BIS_REREAD_PSI3_3BIS;
+#endif
+}
+if((psc_db->psi3bis_params.psi3bis_change_mark EQ psi3bis->psi3_cm) &&
+(psc_db->state_of_PSI[PSI3bis].state EQ RECEIPT_OK))
+{
+/* Message has not changed, we already have a consistent set, so we
+* do not have to read it
+*/
+TRACE_EVENT("PSI3bis: message has not changed");
+return PSI3BIS_OK;
+}
+else if(psc_db->psi3bis_params.psi3bis_change_mark NEQ psi3bis->psi3_cm)
+{
+TRACE_ERROR("PSI3bis: message has changed");
+return PSI3BIS_REREAD_PSI3BIS;
+}
+} /* psi3bis_change_mark valid */
+psc_db->psi3bis_params.psi3bis_index = psi3bis->psi3bis_ind;
+if( psc_db->psi3bis_params.instances[psi3bis->psi3bis_ind + 1] EQ FALSE )
+{
+UBYTE number;
+/*
+* Copy NCELL parameters
+*/
+number =
+psi_store_ncell_param( &psi3bis->ncell_par_trnc_grp.ncell_par[0],
+psi3bis->ncell_par_trnc_grp.c_ncell_par,
+psi3bis->ncell_par_trnc_grp.v_ncell_par,
+INFO_TYPE_PSI3BIS,
+psi3bis->psi3bis_ind );
+/*
+* Copy NCELL parameters 2
+*/
+psi_store_ncell_param2( psi3bis, number );
+TRACE_EVENT_P2( "PSI3bis: received with count = %d, index = %d",
+psi3bis->psi3bis_cnt, psi3bis->psi3bis_ind );
+/*
+* check whether PSI3BIS has been received completely or not
+*/
+psc_db->psi3bis_params.instances[psi3bis->psi3bis_ind + 1] = TRUE;
+is_psi3bis_ok = TRUE;
+for(n = 0; n <= psc_db->psi3bis_params.instances[0]; n++ )
+{
+if(!(psc_db->psi3bis_params.instances[n + 1]))
+{
+is_psi3bis_ok = FALSE;/* consistent set of PSI3BIS not complete */
+break;
+}
+}
+if(is_psi3bis_ok)
+{
+psc_db->state_of_PSI[PSI3bis].state = RECEIPT_OK;
+if( psc_db->state_of_PSI[PSI3].state EQ RECEIPT_OK )
+{
+psi_restore_ncell_param( );
+return PSI3BIS_NCELL_VALID;
+}
+else
+{
+return PSI3BIS_OK;
+}
+}
+}
+else
+{
+TRACE_EVENT_P2( "PSI3bis: already received with count = %d, index = %d",
+psi3bis->psi3bis_cnt, psi3bis->psi3bis_ind );
+}
+return PSI3BIS_OK;
+} /* psi_process_psi3bis() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_process_psi3
++------------------------------------------------------------------------------
+| Description : The function psi_process_psi3() ....
+|
+| Parameters  : T_PSI_3 *psi3
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_PSI3_RET psi_process_psi3 (T_PSI_3 *psi3 )
+{
+T_PSI3_RET return_val = PSI3_OK;
+TRACE_FUNCTION( "psi_process_psi3" );
+/*
+* Check whether the cell has been barred or not. If YES, inform CTRL
+*/
+if(psi3->scell_par.cell_ba)
+{
+/*Barred*/
+TRACE_EVENT( "PSI3: cell barred" );
+GRR_EM_SET_CELL_BARRED;
+return PSI3_CELL_BARRED;
+}
+psc_db->state_of_PSI[PSI3].state = RECEIPT_OK;
+if(psc_db->psi3_params.psi3_change_mark  NEQ NOT_SET)
+{
+/* compare change mark*/
+if(psc_db->psi3_params.psi3_change_mark EQ psi3->psi3_cm)
+{
+/*
+* Information of the PSI3 PSI3ter messages have  NOT been updated: return!!
+*/
+TRACE_EVENT( "PSI3: messages PSI3 and PSI3bis have not changed" );
+return PSI3_OK;
+}
+/*
+* Information of the PSI3 message has been updated, so we have to re-read the parameters
+*
+* A new value indicates that the mobile station shall re-read the information from
+* the PSI3 - PSI3ter messages.
+*/
+/*
+* Set the change mark parameter of psi3bis to NOT_SET. This causes that the PSI3BIS and
+* PSI3 ter instances to be read again
+*/
+psc_db->psi3bis_params.psi3bis_change_mark = NOT_SET;
+psc_db->state_of_PSI[PSI3bis].state = NEEDED;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+psc_db->psi3ter_params.psi3ter_change_mark = NOT_SET;
+if(psc_db->v_add_psi AND psc_db->add_psi.psi3ter_broadcast)
+{
+psc_db->state_of_PSI[PSI3ter].state = NEEDED;
+}
+else
+{
+psc_db->state_of_PSI[PSI3ter].state = NOT_SEND;
+}
+#endif
+/*
+* Set the consistent set parameters to FALSE
+*/
+psi_reset_psi3bis();
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+psi_reset_psi3ter();
+#endif
+/* This field is coded as the binary representation of the PSI3 bis index
+* (in the PSI3 bis message) for the last (highest indexed) individual PSI3
+* bis message.Range: 0-15.
+*/
+psc_db->psi3_params.psi3_bis_count = psi3->psi3bis_cnt;
+/*
+* Ncell parameter are invalid. We have to inform MEAS-Service
+*/
+return_val = PSI3_NCELL_INVALID;
+}
+else
+{
+/*  This is the first time that we have received a PSI3 message*/
+psc_db->psi3_params.psi3_change_mark = psi3->psi3_cm;
+psc_db->psi3_params.psi3_bis_count   = psi3->psi3bis_cnt;
+}
+/* copy Serving Cell parameters        */
+psc_db->scell_par.cell_ba                          = psi3->scell_par.cell_ba;
+psc_db->scell_par.exc_acc                          = psi3->scell_par.exc_acc;
+psc_db->scell_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min
+= psi3->scell_par.gprs_rxlev_access_min;
+psc_db->scell_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch
+= psi3->scell_par.txpwr_max_cch;
+grr_data->meas.pwr_offset                          = 0;
+psc_db->scell_par.cr_par_1.v_hcs_par               = psi3->scell_par.v_hcs_par;
+psc_db->scell_par.cr_par_1.hcs_par                 = psi3->scell_par.hcs_par;
+psc_db->scell_par.multi_band_rep                   = psi3->scell_par.multi_band_rep;
+/*copy General Cell Selection parameter */
+memcpy(&(psc_db->gen_cell_par), &(psi3->gen_cell_par),sizeof(T_gen_cell_par));
+/* process default values for General Cell Selection parameter */
+if( psc_db->gen_cell_par.v_t_resel EQ FALSE )
+{
+psc_db->gen_cell_par.v_t_resel = TRUE;
+psc_db->gen_cell_par.t_resel   = GRR_T_RESEL_DEFAULT;
+}
+if( psc_db->gen_cell_par.v_ra_re_hyst EQ FALSE )
+{
+psc_db->gen_cell_par.v_ra_re_hyst = TRUE;
+psc_db->gen_cell_par.ra_re_hyst   = psc_db->gen_cell_par.gprs_c_hyst;
+}
+/* copy Neighbor cell parameters*/
+psi_store_ncell_param( &psi3->ncell_par[0], psi3->c_ncell_par,
+psi3->v_ncell_par, INFO_TYPE_PSI3, 0 );
+if( psc_db->state_of_PSI[PSI3].state    EQ RECEIPT_OK AND
+psc_db->state_of_PSI[PSI3bis].state EQ RECEIPT_OK     )
+{
+psi_restore_ncell_param( );
+return_val = PSI3_NCELL_VALID;
+}
+TRACE_EVENT_P1( "PSI3: received with return value %d", return_val );
+grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param = TRUE;
+return return_val;
+} /* psi_process_psi3() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_copy_rfl
++------------------------------------------------------------------------------
+| Description : The function psi_copy_rfl() .... copy Reference Frequency List (RFL)
+|
+| Parameters  : T_PSI_2 *psi2: pointer to PSI2 message
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void  psi_copy_rfl(T_PSI_2 *psi2)
+{
+UBYTE m, n;
+TRACE_FUNCTION( "psi_copy_rfl" );
+for(m = 0; m < psi2->psi_2_trnc_grp.c_rfl; m++)
+{
+for(n = 0; n < MAX_RFL; n++)
+{
+if( (psi2->psi_2_trnc_grp.rfl[m].rfl_num EQ psc_db->rfl[n].num) OR (psc_db->rfl[n].num EQ NOT_SET) )
+{
+psc_db->rfl[n].num       = psi2->psi_2_trnc_grp.rfl[m].rfl_num;
+/*
+* This function copies the frequencies into list. This function takes the arranging
+* of ARFCN into account cf. 12.10a GPRS Mobile Allocation in 04.60
+*/
+grr_create_channel_list (&psi2->psi_2_trnc_grp.rfl[m], psc_db->rfl[n].list);
+/*
+* Exit from the for loop
+*/
+n = MAX_RFL;
+}
+}
+}
+}/* psi_copy_rfl*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_copy_ma_from_psi2
++------------------------------------------------------------------------------
+| Description : The function psi_copy_ma_from_psi2() .... copy GPRS Mobile Allocation (MA)
+|
+| Parameters  : T_PSI_2 *psi2: pointer to PSI2 message
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void  psi_copy_ma_from_psi2(T_PSI_2 *psi2)
+{
+UBYTE m, n, copiedElements = 0;
+TRACE_FUNCTION( "psi_copy_ma_from_psi2" );
+for(m = 0; m < psi2->psi_2_trnc_grp.c_gprs_ms_alloc; m++)
+{
+if((psi2->psi_2_trnc_grp.gprs_ms_alloc[m].ma_num != MA_NUMBER_4_PSI13_OR_CELL_ALLOC ) && /* ignore MA_NUMBER with 14 or 15: 0..13 in PSI2*/
+(psi2->psi_2_trnc_grp.gprs_ms_alloc[m].ma_num != MA_NUMBER_4_ASSIGNMENT ))
+{
+for(n = 0; n < MAX_GPRS_MS_ALLOC; n++)
+{
+if( (psi2->psi_2_trnc_grp.gprs_ms_alloc[m].ma_num EQ psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num) ||
+(psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num EQ NOT_SET) )
+{
+psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num = psi2->psi_2_trnc_grp.gprs_ms_alloc[m].ma_num;
+memcpy(&(psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie),
+&(psi2->psi_2_trnc_grp.gprs_ms_alloc[m].gprs_ms_alloc_ie),
+sizeof(T_gprs_ms_alloc_ie));
+n = MAX_GPRS_MS_ALLOC; /* to break the for loop*/
+copiedElements++; /* for debug*/
+}
+}
+}
+}
+if(copiedElements < psi2->psi_2_trnc_grp.c_gprs_ms_alloc)
+{
+TRACE_ERROR("copiedElements < psi2->c_gprs_ms_alloc in" );
+}
+}/* psi_copy_ma_from_psi2*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_copy_ca
++------------------------------------------------------------------------------
+| Description : The function psi_copy_ca() .... copy Cell Allocation (CA)
+|
+| Parameters  : T_PSI_2 *psi2: pointer to PSI2 message
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void  psi_copy_ca(T_PSI_2 *psi2)
+{
+UBYTE m,n;
+TRACE_FUNCTION( "psi_copy_ca" );
+/*TRACE_EVENT("psi_copy_ca");
+TRACE_EVENT_P1("c_ca: %d", psi2->c_cell_alloc);
+*/
+for(m = 0; m < psi2->psi_2_trnc_grp.c_cell_alloc; m++)
+{
+for(n = 0; n < MAX_CELL_ALLOC; n++)
+{
+if( (psi2->psi_2_trnc_grp.cell_alloc[m].rfl_num EQ psc_db->cell_alloc[n].rfl_num)
+|| (psc_db->cell_alloc[n].rfl_num EQ NOT_SET) )
+{
+psc_db->cell_alloc[n].rfl_num = psi2->psi_2_trnc_grp.cell_alloc[m].rfl_num;
+n = MAX_CELL_ALLOC;
+}
+}
+psc_db->v_cell_alloc = TRUE;
+}
+}/* psi_copy_ca*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_copy_pccch
++------------------------------------------------------------------------------
+| Description : The function psi_copy_pccch() .... copy PCCCH Description
+|
+| Parameters  : T_PSI_2 *psi2: pointer to PSI2 message
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void  psi_copy_pccch(T_PSI_2 *psi2)
+{
+UBYTE m, n, i, ii, j;
+TRACE_FUNCTION( "psi_copy_pccch" );
+m = 0;
+for(n = 0; n < psi2->psi_2_trnc_grp.c_pccch_des; n++)
+{
+if(psi2->psi_2_trnc_grp.pccch_des[n].v_nh_pccch_c AND (m < MAX_PCCCH_DES))
+{
+/*
+* Non hopping parameters
+*/
+for(j = 0; j < psi2->psi_2_trnc_grp.pccch_des[n].c_nh_pccch_c; j++)
+{
+ii = 128;
+for(i = 0; i < 8; i++)
+{
+if( ((psi2->psi_2_trnc_grp.pccch_des[n].nh_pccch_c[j].ts_alloc & ii ) EQ ii) ) /* to get the timeslot number */
+{
+psc_db->paging_group.pccch[m].is_static = TRUE;
+psc_db->paging_group.pccch[m].tsc    = psi2->psi_2_trnc_grp.pccch_des[n].tsc;
+psc_db->paging_group.pccch[m].arfcn = psi2->psi_2_trnc_grp.pccch_des[n].nh_pccch_c[j].arfcn;
+psc_db->paging_group.pccch[m].tn = i;/* timeslot number*/
+m++;
+if( m >= MAX_PCCCH_DES )
+break;
+}
+ii = ii/2;
+}
+}
+}
+if(psi2->psi_2_trnc_grp.pccch_des[n].v_ma_h_s1 AND (m < MAX_PCCCH_DES))
+{
+/*
+* Hopping parameters
+*/
+for(j = 0; j < psi2->psi_2_trnc_grp.pccch_des[n].ma_h_s1.c_h_pccch_c; j++)
+{
+ii = 128;
+for(i = 0; i < 8; i++)
+{
+if( ((psi2->psi_2_trnc_grp.pccch_des[n].ma_h_s1.h_pccch_c[j].ts_alloc & ii ) EQ ii) ) /* to get the timeslot number */
+{
+psc_db->paging_group.pccch[m].is_static = FALSE;
+psc_db->paging_group.pccch[m].ma_num    = psi2->psi_2_trnc_grp.pccch_des[n].ma_h_s1.ma_num;
+psc_db->paging_group.pccch[m].tsc       = psi2->psi_2_trnc_grp.pccch_des[n].tsc;
+psc_db->paging_group.pccch[m].maio      = psi2->psi_2_trnc_grp.pccch_des[n].ma_h_s1.h_pccch_c[j].maio;
+psc_db->paging_group.pccch[m].tn        = i;/* timeslot number*/
+m++;
+if( m >= MAX_PCCCH_DES )
+break;
+}
+ii = ii/2;
+}
+}
+}
+psc_db->paging_group.kc = m; /*number of timeslots carrying PCCCH*/
+}
+}/* psi_copy_pccch*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_copy_cell_id
++------------------------------------------------------------------------------
+| Description : The function psi_copy_cell_id() ....
+|
+| Parameters  : T_PSI_2 *psi2: pointer to PSI2 message strcuture
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_copy_cell_id(T_PSI_2 *psi2)
+{
+TRACE_FUNCTION( "psi_copy_cell_id" );
+psc_db->cell_info_for_gmm.cell_info.cell_env.rai.plmn.v_plmn = TRUE;
+if( psi2->psi_2_trnc_grp.cell_id.loc_area_ident.c_mnc EQ 2 )
+{
+/* Internally G23 uses always 3-digit-MNC */
+psi2->psi_2_trnc_grp.cell_id.loc_area_ident.c_mnc  = SIZE_MNC;
+psi2->psi_2_trnc_grp.cell_id.loc_area_ident.mnc[2] = 0xf;
+}
+memcpy( psc_db->cell_info_for_gmm.cell_info.cell_env.rai.plmn.mcc,
+psi2->psi_2_trnc_grp.cell_id.loc_area_ident.mcc, SIZE_MCC );
+memcpy( psc_db->cell_info_for_gmm.cell_info.cell_env.rai.plmn.mnc,
+psi2->psi_2_trnc_grp.cell_id.loc_area_ident.mnc, SIZE_MNC );
+psc_db->cell_info_for_gmm.cell_info.cell_env.rai.lac = psi2->psi_2_trnc_grp.cell_id.loc_area_ident.lac;
+psc_db->cell_info_for_gmm.cell_info.cell_env.rai.rac = psi2->psi_2_trnc_grp.cell_id.rac;
+psc_db->cell_info_for_gmm.cell_info.cell_env.cid     = psi2->psi_2_trnc_grp.cell_id.cell_id_ie;
+}/* psi_copy_cell_id*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_copy_non_gprs_opt
++------------------------------------------------------------------------------
+| Description : The function psi_copy_non_gprs_opt() ....
+|
+| Parameters  : T_PSI_2 *psi2: pointer to PSI2 message strcuture
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_copy_non_gprs_opt(T_PSI_2 *psi2)
+{
+TRACE_FUNCTION( "psi_copy_non_gprs_opt" );
+psc_db->v_non_gprs_opt = TRUE;
+/* copy parameters*/
+memcpy(&(psc_db->non_gprs_opt), &(psi2->psi_2_trnc_grp.non_gprs_opt), sizeof(T_non_gprs_opt));
+}/* psi_copy_non_gprs_opt*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_process_psi2
++------------------------------------------------------------------------------
+| Description : The function psi_process_psi2() ....
+|
+| Parameters  : T_PSI_2 *psi2
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_PSI2_RET psi_process_psi2 (T_PSI_2 *psi2 )
+{
+UBYTE n=0;
+TRACE_FUNCTION( "psi_process_psi2" );
+if(psc_db->psi2_params.psi2_change_mark EQ NOT_SET)
+{
+/* This is the first PSI2 message*/
+psc_db->psi2_params.psi2_change_mark = psi2->psi2_cm;
+psc_db->psi2_params.psi2_count   = psi2->psi2_cnt;
+psc_db->psi2_params.instances[0] = psi2->psi2_cnt;/* number of instances */
+}
+else
+{
+/* Check consistency of COUNT and INDEX*/
+if(
+(psc_db->psi2_params.psi2_count NEQ psi2->psi2_cnt)
+OR
+(psc_db->psi2_params.psi2_count < psi2->psi2_ind)
+OR
+(psc_db->psi2_params.psi2_change_mark NEQ psi2->psi2_cm)
+)
+{
+/* Error situation read a new PSI2*/
+TRACE_EVENT( "PSI2: inconsistent parameters" );
+return PSI2_REREAD;
+}
+/* There was a valid psi2_change_mark: compare change_mark values*/
+if((psc_db->psi2_params.psi2_change_mark EQ psi2->psi2_cm) AND
+(psc_db->state_of_PSI[PSI2].state EQ RECEIPT_OK))
+{
+/* PSI2 message has not changed, we already have a consistent set, so we
+* do not have to read the PSI2 message
+*/
+TRACE_EVENT( "PSI2: message has not changed" );
+return PSI2_OK;
+}
+} /* psi2_change_mark set */
+if( psc_db->psi2_params.instances[psi2->psi2_ind + 1] EQ FALSE )
+{
+psc_db->psi2_params.instances[psi2->psi2_ind + 1] = TRUE;
+/*check consistency */
+psc_db->complete_acq.psi2_ok = TRUE;
+for(n = 0; n <= psc_db->psi2_params.instances[0]; n++ )
+{
+if(!(psc_db->psi2_params.instances[n + 1]))
+{
+psc_db->complete_acq.psi2_ok = FALSE;/* consistent set of PSI2 not complete */
+break;
+}
+}
+psc_db->state_of_PSI[PSI2].state = (psc_db->complete_acq.psi2_ok) ? RECEIPT_OK : NEEDED;
+if(psi2->psi_2_trnc_grp.v_cell_id)
+{
+/* copy cell identification*/
+psi_copy_cell_id(psi2);
+}
+if(psi2->psi_2_trnc_grp.v_non_gprs_opt)
+{
+/* copy non GPRS cell options*/
+psi_copy_non_gprs_opt(psi2);
+}
+/*
+* copy Reference Frequency List (RFL)
+*/
+psi_copy_rfl(psi2);
+/*
+* copy Cell Allocation (CA)
+*/
+psi_copy_ca(psi2);
+/*
+* copy GPRS Mobile Allocation (MA)
+*/
+psi_copy_ma_from_psi2(psi2);
+/*
+* copy PCCCH Description
+*/
+psi_copy_pccch(psi2);
+#ifdef REL99
+if(psi2->psi_2_trnc_grp.v_release_99_str_psi_2 AND psi2->psi_2_trnc_grp.release_99_str_psi_2.v_add_psi)
+{
+psc_db->add_psi = psi2->psi_2_trnc_grp.release_99_str_psi_2.add_psi;
+psc_db->v_add_psi = TRUE;
+if(!psi2->psi_2_trnc_grp.release_99_str_psi_2.add_psi.Psi8_broadcast)
+{
+psc_db->state_of_PSI[PSI8].state = NOT_SEND;
+psc_db->v_cbch_chan_desc = FALSE;
+/* as this is r-99 network, and PBCCH is present
+* CBCH info should be sent to RR. As psi8 is
+* not present, it will deactivated.
+*/
+psc_db->send_cbch_info_ind = TRUE;
+}
+/* Process psi3ter broadcast indicator */
+if(!psi2->psi_2_trnc_grp.release_99_str_psi_2.add_psi.psi3ter_broadcast)
+{
+psc_db->state_of_PSI[PSI3ter].state = NOT_SEND;
+}
+}
+if(psc_db->state_of_PSI[PSI2].state EQ RECEIPT_OK)
+{
+/* A consistent set of PSI2 has been received. */
+/* Additional PSI Messages information element is within truncation
+notation. If it wasn't received at all, then we should assume 0,
+hence mark PSI3 ter and PSI 8 as "NOT_SEND"                   */
+if(!psc_db->v_add_psi)
+{
+psc_db->state_of_PSI[PSI8].state = NOT_SEND;
+psc_db->v_cbch_chan_desc = FALSE;
+if(psc_db->network_rel)
+{
+/* as this is r-99 network, and PBCCH is present
+* CBCH info should be sent to RR. As psi8 is
+* not present, it will deactivated.
+*/
+psc_db->send_cbch_info_ind = TRUE;
+}
+psc_db->state_of_PSI[PSI3ter].state = NOT_SEND;
+}
+/* PSI2 has got updated. CBCH channel description
+* could depend of PSI2 in case hopping is allowed
+*/
+if(psc_db->v_cbch_chan_desc AND !psc_db->cbch_chan_desc.freq_par.v_arfcn)
+{
+psc_db->send_cbch_info_ind = TRUE;
+}
+}
+#endif
+TRACE_EVENT_P2( "PSI2: received with count = %d, index = %d",
+psi2->psi2_cnt, psi2->psi2_ind );
+}
+else
+{
+TRACE_EVENT_P2( "PSI2: already received with count = %d, index = %d",
+psi2->psi2_cnt, psi2->psi2_ind );
+}
+return PSI2_OK;
+} /* psi_process_psi2() */
+#ifdef REL99
+/*
++------------------------------------------------------------------------------
+| Function    : psi_process_psi8
++------------------------------------------------------------------------------
+| Description : This function stores the contents of PSI 8 for further
+|               processing.
+|               In R-99, PSI8 contains CBCH configuration. If PSI8 is not
+|               broadcast or if none of the instances of PSI8 contain
+|               CBCH information, then SMSCB is not active in the cell.
+|
+|               CBCH is handled in ALR entity and is configured through RR entity.
+|               This message contains CBCH channel description. If cbch
+|               channel description indicates hopping, then to decode
+|               frequency parameters to extract the frequencies for mobile allocation,
+|               prior receipt of PSI 2(all instances) and
+|               optionally SI13 messages is essential.
+|               Hence PSI 8 frequency parameters is not decoded here. It is
+|               stored in psc data blase and is decoded before giving
+|               RRGRR_CBCH_INFO_IND to RR entity. RRGRR sap messages are
+|               sent from service CTRL.
+| Parameters  : T_PSI_4 *psi4
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_PSI8_RET psi_process_psi8 (T_PSI_8 *psi8 )
+{
+UBYTE n;
+BOOL is_psi8_ok;
+TRACE_FUNCTION( "psi_process_psi8" );
+/*
+* Check consistency
+*/
+if(psc_db->psi8_params.psi8_change_mark EQ NOT_SET)
+{
+/*
+* Copy change mark etc.
+*/
+psc_db->psi8_params.psi8_change_mark = psi8->psi8_cm;
+psc_db->psi8_params.psi8_count   = psi8->psi8_cnt;
+psc_db->psi8_params.instances[0] = psi8->psi8_cnt;/* number of instances */
+psc_db->v_cbch_chan_desc = FALSE;
+}
+else
+{
+/*
+* There is a valid change mark present in the database
+* Check consistency of COUNT and INDEX
+*/
+if(
+(psc_db->psi8_params.psi8_count NEQ psi8->psi8_cnt)
+OR
+(psc_db->psi8_params.psi8_count < psi8->psi8_ind)
+OR
+(psc_db->psi8_params.psi8_change_mark NEQ psi8->psi8_cm)
+)
+{
+/*
+* Error situation; read a new PSI4
+* The PSI4 change mark field is changed each time information has been updated
+* A new value indicates that the mobile
+* station shall re-read the information from the PSI4
+*/
+TRACE_ERROR( "PSI8: inconsistent parameters" );
+psc_db->v_cbch_chan_desc = FALSE;
+return PSI8_REREAD;
+}
+/* psi8_change_markh as not changed, i.e.
+* PSI8 message has not changed, we already have a consistent set, so we
+* do not have to read the PSI4 message
+*/
+if((psc_db->psi8_params.psi8_change_mark EQ psi8->psi8_cm) &&
+(psc_db->state_of_PSI[PSI8].state EQ RECEIPT_OK))
+{
+/* Message has not changed, we already have a consistent set, so we
+* do not have to read it
+*/
+TRACE_EVENT( "PSI8: message has not changed" );
+return PSI8_OK;
+}
+}
+psc_db->psi8_params.psi8_index = psi8->psi8_ind;
+if( psc_db->psi8_params.instances[psi8->psi8_ind + 1] EQ FALSE )
+{
+/* Store CBCH channel description. To decode Frequency Parameters,
+* it is necessary to receive all instances of PSI2 message.
+* Hence defer decoding of hopping frequency list till
+* end of acquisition.
+*/
+if(psi8->v_cbch_chan_desc)
+{
+memcpy(&(psc_db->cbch_chan_desc),&(psi8->cbch_chan_desc),sizeof(T_cbch_chan_desc));
+psc_db->v_cbch_chan_desc = TRUE;
+}
+/*
+* check whether PSI8 has been received completely or not
+*/
+psc_db->psi8_params.instances[psi8->psi8_ind + 1] = TRUE;
+is_psi8_ok = TRUE;
+for(n = 0; n <= psc_db->psi8_params.instances[0]; n++ )
+{
+if(!(psc_db->psi8_params.instances[n + 1]))
+{
+is_psi8_ok = FALSE;/* consistent set of PSI8 not complete */
+break;
+}
+}
+TRACE_EVENT_P2( "PSI8: received with count = %d, index = %d",
+psi8->psi8_cnt, psi8->psi8_ind );
+if(is_psi8_ok)
+{
+if(psc_db->state_of_PSI[PSI8].state NEQ RECEIPT_OK)
+{
+/* A new copy of PSI8 has been received.
+* RRGRR_CBCH_INFO_IND has to be sent after
+* all instances of PSI2 have been received when
+* acquisition is PARTIAL, and in case of COMPLETE
+*  acquisition after access to the cell is enabled.
+*/
+psc_db->state_of_PSI[PSI8].state = RECEIPT_OK;
+psc_db->send_cbch_info_ind = TRUE;
+return PSI8_OK;
+}
+}
+}
+else
+{
+TRACE_EVENT_P2( "PSI8: already received with count = %d, index = %d",
+psi8->psi8_cnt, psi8->psi8_ind );
+}
+return PSI8_OK;
+} /* psi_process_psi8() */
+#endif
+/*
++------------------------------------------------------------------------------
+| Function    : psi_check_change_field
++------------------------------------------------------------------------------
+| Description : The function psi_check_change_field() ....
+|
+| Parameters  : UBYTE psi_change_field; return TRUE: acq needed, FALSE: not needed
+|
++------------------------------------------------------------------------------
+*/
+LOCAL BOOL psi_check_change_field (UBYTE psi_change_field)
+{
+BOOL return_value = FALSE;
+TRACE_FUNCTION( "psi_check_change_field" );
+switch(psi_change_field)
+{
+case UPDATE_UNS_PSI: /*Update of unspecified PSI message(s);*/
+psc_db->state_of_PSI[PSI2].state = NEEDED;
+psc_db->state_of_PSI[PSI3].state = NEEDED;
+psc_db->state_of_PSI[PSI3bis].state = NEEDED;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+psc_db->state_of_PSI[PSI3ter].state = NEEDED;
+#endif
+psc_db->state_of_PSI[PSI4].state = NEEDED;
+psc_db->state_of_PSI[PSI5].state = NEEDED; /*??*/
+#ifdef REL99
+/* It is necessary to set PSI 8 to needed here. In case
+* PSI 8 is not broadcast in the cell, this value \
+* would be sent to NOT_SEND when PSI 2 is received
+*/
+psc_db->state_of_PSI[PSI8].state = NEEDED;
+#endif
+/*psc_db->state_of_PSI[13] = NEEDED;*/
+return_value = TRUE;
+break;
+case UPDATE_UNKNOWN: /* Unknown*/
+return_value = FALSE;
+break;
+case UPDATE_PSI2: /* PSI2 updated*/
+psc_db->state_of_PSI[PSI2].state = NEEDED;
+return_value = TRUE;
+break;
+case UPDATE_PSI3: /* PSI3/PSI3bis/PSI3ter updated*/
+psc_db->state_of_PSI[PSI3].state = NEEDED;
+psc_db->state_of_PSI[PSI3bis].state = NEEDED;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+if(psc_db->v_add_psi AND psc_db->add_psi.psi3ter_broadcast)
+{
+psc_db->state_of_PSI[PSI3ter].state = NEEDED;
+}
+else
+{
+psc_db->state_of_PSI[PSI3ter].state = NOT_SEND;
+}
+#endif
+return_value = TRUE;
+break;
+case UPDATE_PSI4: /* PSI4 updated*/
+psc_db->state_of_PSI[PSI4].state = NEEDED;
+return_value = TRUE;
+break;
+case UPDATE_PSI5: /* PSI5 updated*/
+psc_db->state_of_PSI[PSI5].state = NEEDED;
+return_value = TRUE;
+break;
+#ifdef REL99
+case UPDATE_PSI8:
+psc_db->state_of_PSI[PSI8].state = NEEDED;
+return_value = TRUE;
+break;
+#endif
+default: /* All other values shall be interpreted as 'Update of unknown SI message type'.*/
+return_value = FALSE;
+break;
+}
+return return_value;
+} /* psi_check_change_field() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_process_psi1
++------------------------------------------------------------------------------
+| Description : The function psi_process_psi1() ....
+|
+| Parameters  : T_PSI_1 *psi1
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_PSI1_RET psi_process_psi1 (T_PSI_1 *psi1 )
+{
+T_PSI1_RET return_val = PSI1_OK;
+#ifdef REL99
+UBYTE current_nw_rel  = psc_db->network_rel;
+#endif
+TRACE_FUNCTION( "psi_process_psi1" );
+if(psi1->pccch_org_par.bs_pcc_rel)
+{
+/*
+* last PDCH carrying PCCCH and PBCCH will be released shortly, receive si13
+*/
+return_val = PSI1_PBCCH_RELEASED;
+}
+else if( grr_is_pbcch_present( ) EQ FALSE )
+{
+return_val = PSI1_PBCCH_ESTABLISHED;
+}
+else
+{
+psc_db->state_of_PSI[PSI1].state = RECEIPT_OK;
+psc_db->complete_acq.psi1_ok = TRUE; /*PSI1 has been received*/
+/* copy repeat period*/
+psc_db->psi1_params.psi1_repeat_period = psi1->psi1_rep_per + 1;
+/* copy repetition rates */
+psc_db->psi1_params.psi_cnt_lr = psi1->psi_cnt_lr;
+if(psi1->v_psi_cnt_hr)
+{
+psc_db->psi1_params.psi_cnt_hr = psi1->psi_cnt_hr + 1;
+}
+else
+{
+psc_db->psi1_params.psi_cnt_hr = 0;/*default*/
+}
+psc_db->psi1_params.psi_status_supported = (psi1->psi_status_ind EQ 1) ? TRUE : FALSE;
+psc_db->measurement_order = psi1->meas_order; /*PSI5 is present in the cell or not*/
+if(!psc_db->measurement_order)
+psc_db->state_of_PSI[PSI5].state = RECEIPT_OK;
+/* Process PRACH parameters*/
+psi_process_prach(&(psi1->prach_ctrl_par));
+/*copy pccch org params*/
+psc_db->pccch.bs_pcc_rel    = psi1->pccch_org_par.bs_pcc_rel;
+psc_db->pccch.bs_pbcch_blks = psi1->pccch_org_par.bs_pbcch_blks;
+psc_db->pccch.bs_pag_blks   = CLIP_BS_PAG_BLKS_RES( psi1->pccch_org_par.bs_pag_blks );
+psc_db->pccch.bs_prach_blks = CLIP_BS_PRACH_BLKS( psi1->pccch_org_par.bs_prach_blks );
+/*copy GPRS cell options*/
+psc_db->v_gprs_cell_opt                      = TRUE;
+psc_db->cell_info_for_gmm.cell_info.net_mode = psi1->gprs_cell_opt.nmo;
+psc_db->gprs_cell_opt.nmo                    = psi1->gprs_cell_opt.nmo;
+psc_db->gprs_cell_opt.t3168                  = psi1->gprs_cell_opt.t3168;
+psc_db->gprs_cell_opt.t3192                  = psi1->gprs_cell_opt.t3192;
+psc_db->gprs_cell_opt.drx_t_max              = psi1->gprs_cell_opt.drx_t_max;
+psc_db->gprs_cell_opt.ab_type                = psi1->gprs_cell_opt.ab_type;
+psc_db->gprs_cell_opt.ctrl_ack_type          = psi1->gprs_cell_opt.ctrl_ack_type;
+psc_db->gprs_cell_opt.bs_cv_max              = psi1->gprs_cell_opt.bs_cv_max;
+memcpy(&(psc_db->gprs_cell_opt), &(psi1->gprs_cell_opt), sizeof(T_gprs_cell_opt));
+/*if(psi1->gprs_cell_opt.v_pan_struct)
+{
+psc_db->gprs_cell_opt.pan_struct.inc  = psi1->gprs_cell_opt.pan_struct.inc;
+psc_db->gprs_cell_opt.pan_struct.dec  = psi1->gprs_cell_opt.pan_struct.dec;
+psc_db->gprs_cell_opt.pan_struct.pmax = ( psi1->gprs_cell_opt.pan_struct.pmax + 1 ) * 4;
+psc_db->gprs_cell_opt.v_pan_struct    = 1;
+}*/
+if(psi1->gprs_cell_opt.v_gprs_ext_bits)
+{
+memcpy(&(psc_db->gprs_cell_opt.gprs_ext_bits), &(psi1->gprs_cell_opt.gprs_ext_bits), sizeof(T_gprs_ext_bits));
+psc_db->gprs_cell_opt.v_gprs_ext_bits = 1;
+}
+/*Global power control parameters*/
+grr_store_g_pwr_par( &psi1->g_pwr_par );
+/* check whether the PSI4 is broadcast or not*/
+if(!psc_db->g_pwr_par.imeas_chan_list)
+psc_db->state_of_PSI[PSI4].state = RECEIPT_OK;
+TRACE_EVENT_P2( "PSI1: database change mark: %d, message change mark: %d",
+psc_db->psi1_params.pbcch_change_mark,
+psi1->pbcch_change_ma );
+if(psc_db->psi1_params.first_psi1)
+{
+psc_db->psi1_params.pbcch_change_mark = psi1->pbcch_change_ma; /* set the new change mark value*/
+}
+else
+{
+UBYTE incremented_value = psi_compare_change_mark(psi1->pbcch_change_ma, psc_db->psi1_params.pbcch_change_mark);
+psc_db->psi1_params.pbcch_change_mark = psi1->pbcch_change_ma; /* set the new change mark value*/
+if(incremented_value EQ 1)/*partial acq*/
+{
+if(psi_check_change_field(psi1->psi_change_field))
+{
+return_val = PSI1_PARTIAL_ACQ;
+}
+}
+else if(incremented_value > 1) /* incremented_value more than 1: complete acq*/
+{
+return_val = PSI1_COMPLETE_ACQ;
+}
+}
+#ifdef REL99
+/* Update the BSS release from PSI1 instead of SI13, when PBCCH is present */
+/* Update the SGSN release */
+if (psi1->v_release_99_str_psi_1)
+{
+psc_db->network_rel = BSS_NW_REL_99;
+psc_db->sgsn_rel = psi1->release_99_str_psi_1.sgsnr ? PS_SGSN_99_ONWARDS : PS_SGSN_98_OLDER;
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+psc_db->band_indicator = psi1->release_99_str_psi_1.band_indicator;
+#endif
+}
+else
+{
+psc_db->sgsn_rel = PS_SGSN_98_OLDER;
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+psc_db->band_indicator = NOT_PRESENT_8BIT;
+#endif
+}
+#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
+/*
+* Update std depending on the band indicator
+*/
+att_update_std_band_indicator ( psc_db->band_indicator );
+#endif
+/* Please note that there is no check for (psi1->release_99 EQ FALSE) and
+* then setting the psc_db->network_rel to BSS_NW_REL_97 as sometimes the
+* the R99 or R4 network may not broadcast the optional R99 IEs. At that
+* time, the network release is assigned wrongly if the above check exists.
+*/
+if(psc_db->network_rel NEQ current_nw_rel)
+{
+TRACE_EVENT_P2("(PSI1)BSS Network release changed from %d to %d <0 - REL_97, 1 - REL_99, 2 - REL_04>",
+current_nw_rel, psc_db->network_rel);
+}
+/* Update the SGSN release in the Common library context */
+cl_nwrl_set_sgsn_release(psc_db->sgsn_rel);
+#endif
+}
+TRACE_EVENT_P1( "PSI1: received with return value %d", return_val );
+grr_set_pg_nmo();
+return return_val;
+} /* psi_process_psi1() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_receive_psi
++------------------------------------------------------------------------------
+| Description : The function psi_receive_psi() ....
+|
+| Parameters  : BOOL read_all
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_receive_psi ( UBYTE  psi_reading_type)
+{
+TRACE_FUNCTION( "psi_receive_psi" );
+if(grr_data->psi.is_pbcch_req_allowed)
+{
+/*
+* Prepare MPHP_SCELL_PBCCH_REQ to receive psi
+*/
+PALLOC(mphp_scell_pbcch_req, MPHP_SCELL_PBCCH_REQ);
+psi_prepare_scell_pbcch_req(mphp_scell_pbcch_req, psi_reading_type);
+PSEND(hCommL1,mphp_scell_pbcch_req);
+grr_data->psi.is_pbcch_req_needed =FALSE;
+}
+else
+{
+TRACE_EVENT("PBCCH request needed after release of TBF, stop of RR tasks, etc.");
+grr_data->psi.is_pbcch_req_needed =TRUE;
+/*
+* store the reading_type in case of needed in/after release procedure
+*/
+grr_data->psi.reading_type=psi_reading_type;
+}
+} /* psi_receive_psi() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_process_prach
++------------------------------------------------------------------------------
+| Description : The function psi_process_prach() ....
+|
+| Parameters  : T_prach_ctrl_par *prach: pointer to PRACH control parameters
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_process_prach ( T_prach_ctrl_par *prach )
+{
+TRACE_FUNCTION( "psi_process_prach" );
+psc_db->v_prach = TRUE;
+memcpy(&(psc_db->prach), prach, sizeof(T_prach_ctrl_par));
+TRACE_EVENT_P5("ac_class: %d max_ret %d %d %d %d",
+prach->ac_class,
+prach->max_retrans[0],
+prach->max_retrans[1],
+prach->max_retrans[2],
+prach->max_retrans[3]);
+TRACE_EVENT_P2("s_prach: %d tx_int:%d", prach->s_prach, prach->tx_int);
+if(prach->v_pers_lev)
+{
+TRACE_EVENT_P4("pers: %d %d %d %d",
+prach->pers_lev.plev[0],
+prach->pers_lev.plev[1],
+prach->pers_lev.plev[2],
+prach->pers_lev.plev[3]);
+}
+} /* psi_process_prach() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reset_si_entries
++------------------------------------------------------------------------------
+| Description : The function psi_reset_si_entries() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_reset_si_entries ( void )
+{
+TRACE_FUNCTION( "psi_reset_si_entries" );
+psc_db->psi13_params.bcch_change_mark = NOT_SET;
+psc_db->psi13_params.si13_change_mark = NOT_SET;
+} /* psi_reset_si_entries() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_acq_state_of_si
++------------------------------------------------------------------------------
+| Description : The function psi_acq_state_of_si() ....
+|               This function is ONLY called after processing SI13 message
+| Parameters  : T_si_states  si_states: contains the state of the SI messages
+|               needed for checking for packet access allowance
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL T_ACQ_STATE_RET psi_acq_state_of_si ( T_si_states  si_states)
+{
+T_ACQ_STATE_RET ret_value = ACQ_RUNNING;
+TRACE_FUNCTION( "psi_acq_state_of_si" );
+switch(psc_db->acq_type)
+{
+case PARTIAL:
+ret_value = ACQ_PART_OK;
+break;
+case COMPLETE:
+if((si_states.si3_state EQ SI3_RECEIVED) AND (si_states.si13_state EQ SI13_RECEIVED))
+{
+if((si_states.si1_state EQ SI1_NOT_SEND) OR (si_states.si1_state EQ SI1_RECEIVED))
+{
+ret_value = ACQ_COMP_OK;
+}
+}
+break;
+case PERIODICAL_SI13_READING:
+ret_value = ACQ_PERIOD_OK;
+break;
+default:
+break;
+}
+return ret_value;
+} /* psi_acq_state_of_si() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_is_update_needed
++------------------------------------------------------------------------------
+| Description : The function psi_is_update_needed() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL psi_is_update_needed ( UBYTE si_change_field )
+{
+TRACE_FUNCTION( "psi_is_update_needed" );
+switch(si_change_field)
+{
+case UNSPECIFIED_SI:
+case UPDATE_SI1:
+case UPDATE_SI2_SI2BIS_OR_SI2TER:
+case UPDATE_SI3_SI4_SI7_OR_SI8:
+case UPDATE_SI9:
+return TRUE;
+default:
+return FALSE;
+}
+} /* psi_is_update_needed() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_update_data_to_request
++------------------------------------------------------------------------------
+| Description : The function psi_update_data_to_request updates the static
+|                   and  hopping frequencies and other parameters to request PSI
+|                   data. This function is called after receiving SI13 or PSI13 or PSI1
+|
+| Parameters  : UBYTE init_needed: checks whether initialization is needed or not
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_update_data_to_request( UBYTE init_needed)
+{
+T_MPHP_SCELL_PBCCH_REQ *ptr_prim;
+TRACE_FUNCTION( "psi_update_data_to_request" );
+ptr_prim = &psc_db->scell_pbcch;
+if(init_needed)
+{
+TRACE_EVENT("Init Needed");
+memset(&psc_db->pccch, 0, sizeof(T_pccch_org_par)); /*initial*/
+psc_db->psi1_params.psi_cnt_hr = 0; /* initial*/
+psc_db->psi1_params.psi_cnt_lr = 0; /* initial*/
+}
+/*
+* set values for mphp_scell_pbcch_req
+*/
+ptr_prim->pb              = psc_db->pbcch.pbcch_des.pb;             /*<   Power reduction value          */
+ptr_prim->bs_pbcch_blks   = psc_db->pccch.bs_pbcch_blks;            /*<   Number of PBCCH per multiframe */
+ptr_prim->psi1_rep_period = psc_db->psi1_params.psi1_repeat_period; /*<   PSI1 repeat period             */
+ptr_prim->p_ch_des.tsc    = psc_db->pbcch.pbcch_des.tsc;            /*<  Training sequence code         */
+ptr_prim->p_ch_des.tn     = psc_db->pbcch.pbcch_des.tn;             /*<  timeslot number */
+if  (psc_db->pbcch.pbcch_des.v_arfcn
+OR
+(
+(psc_db->pbcch.pbcch_des.flag EQ 0)
+AND /* use bcch.arfcn*/
+(psc_db->pbcch.pbcch_des.flag2 EQ 0)
+)
+)
+{
+ptr_prim->p_ch_des.p_chan_sel.hopping       = 0;
+ptr_prim->p_ch_des.p_chan_sel.p_rf_ch.arfcn = (psc_db->pbcch.pbcch_des.v_arfcn )
+?grr_g23_arfcn_to_l1(psc_db->pbcch.pbcch_des.arfcn)
+:grr_g23_arfcn_to_l1(psc_db->pbcch.bcch.arfcn);
+TRACE_EVENT_P8("Up_s: pbcch:%d per:%d hr:%d lr:%d pb:%d tsc:%d tn:%d arfcn:%d",
+psc_db->pccch.bs_pbcch_blks,
+psc_db->psi1_params.psi1_repeat_period,
+psc_db->psi1_params.psi_cnt_hr,
+psc_db->psi1_params.psi_cnt_lr,
+psc_db->pbcch.pbcch_des.pb,
+psc_db->pbcch.pbcch_des.tsc,
+psc_db->pbcch.pbcch_des.tn,
+ptr_prim->p_ch_des.p_chan_sel.p_rf_ch.arfcn);
+}
+else
+{
+grr_create_freq_list(  MA_NUMBER_4_PSI13_OR_CELL_ALLOC,
+psc_db->pbcch.pbcch_des.maio,
+&ptr_prim->p_ch_des.p_chan_sel,
+&ptr_prim->p_freq_list );
+TRACE_EVENT_P8("Up_h1: pbcch:%d per:%d hr:%d lr:%d pb:%d tsc:%d tn:%d maio:%d",
+psc_db->pccch.bs_pbcch_blks,
+psc_db->psi1_params.psi1_repeat_period,
+psc_db->psi1_params.psi_cnt_hr,
+psc_db->psi1_params.psi_cnt_lr,
+psc_db->pbcch.pbcch_des.pb,
+psc_db->pbcch.pbcch_des.tsc,
+psc_db->pbcch.pbcch_des.tn,
+psc_db->pbcch.pbcch_des.maio);
+}
+} /* psi_update_data_to_request() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_is_access_class_changed
++------------------------------------------------------------------------------
+| Description : This function checks the access class control parameter and
+|               return TRUE/FALSE value
+|
+| Parameters  : void; return BOOL: TRUE: access class changed; FALSE: nothing has changed
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL psi_is_access_class_changed(void)
+{
+USHORT dummy1, dummy2, access_changed;
+TRACE_FUNCTION("psi_is_access_class_changed");
+access_changed = FALSE;
+/* check the access control class and inform the service: CTRL
+* check access class control for authorized classes 0 to 9 and
+* check access class control for authorized classes 11 to 15 and
+*/
+dummy1 = grr_data->ms.access_ctrl_class & 0x3FF;
+dummy2 = grr_data->ms.access_ctrl_class & 0xF800;
+if(
+((dummy1 & ~psc_db->prach.ac_class) > 0) /* 0 to 9*/
+OR
+((dummy2 & ~psc_db->prach.ac_class) > 0) /* 11 to 15*/
+)
+{
+/*
+* The MS belongs to one of the authorized access classes
+*/
+if(psc_db->cell_info_for_gmm.access_status NEQ GPRS_ACCESS_ALLOWED)
+{
+/*
+* Access was NOT allowed, so we have to inform GMM
+*/
+access_changed = TRUE;
+psc_db->cell_info_for_gmm.access_status = GPRS_ACCESS_ALLOWED;
+}
+}
+else
+{
+/*
+* Access barred
+*/
+if(psc_db->cell_info_for_gmm.access_status NEQ GPRS_ACCESS_BARRED)
+{
+/*
+* Access was ALLOWED, so we have to inform GMM
+*/
+access_changed = TRUE;
+psc_db->cell_info_for_gmm.access_status = GPRS_ACCESS_BARRED;
+}
+}
+if( access_changed )
+{
+TRACE_EVENT( "Access class changed" );
+grr_set_cell_info_service( );
+}
+return( access_changed );
+}/* psi_is_access_class_changed*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_init_params
++------------------------------------------------------------------------------
+| Description : The function psi_init_params() ....
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_init_params ( void )
+{
+#if defined (TI_PS_FF_RTD) AND defined (REL99)
+UBYTE n;
+#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */
+TRACE_FUNCTION( "psi_init_params" );
+grr_data->psi.is_pbcch_req_needed =FALSE; /*PBCCH req. waiting for perform*/
+grr_data->psi.is_pbcch_req_allowed =TRUE; /*PBCCH req. allowed due to transition rules or not*/
+#if defined (TI_PS_FF_RTD) AND defined (REL99)
+for( n = 0; n < MAX_NR_OF_NCELL; n++ )
+grr_data->psi.rtd[n] = RTD_NOT_AVAILABLE;
+#endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */
+psi_reset_all();
+psi_init_rfl_psi2(); /* set the Reference Frequency List parameters to initial values */
+psi_init_cell_alloc(); /* init cell allocation structure */
+psi_init_gprs_ms_alloc(FALSE); /* init GPRS Mobile Allocations struct */
+} /* psi_init_params() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_stop_timer
++------------------------------------------------------------------------------
+| Description : The function stops psi timers if they are running
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_stop_timer ( void )
+{
+TRACE_FUNCTION( "psi_stop_timer" );
+vsi_t_stop(GRR_handle,T_10_SEC);
+vsi_t_stop(GRR_handle,T_30_SEC);
+vsi_t_stop(GRR_handle,T_60_SEC);
+vsi_t_stop(GRR_handle,T_COMP_PSI);
+} /* psi_stop_timer() */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_is_access_allowed
++------------------------------------------------------------------------------
+| Description : The function checks whether the access to the network is allowed
+|               or not
+|
+| Parameters  : BOOL: TRUE if access allowed, otherwise FALSE
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL psi_is_access_allowed(void)
+{
+TRACE_FUNCTION("psi_is_access_allowed");
+/*
+* Check whether access is enabled or not: Access is allowed
+* if PSI acquisition is completed or PSI1&PSI2 was read with
+* success AND psi status is suppoerted by the network
+*/
+#ifdef _SIMULATION_
+if(
+psc_db->psi1_params.psi_status_supported
+AND
+psc_db->complete_acq.psi1_ok
+AND
+psc_db->complete_acq.psi2_ok
+)
+return TRUE;
+#endif /* #ifdef _SIMULATION_ */
+return FALSE;
+}/*psi_is_access_allowed */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reread_psi2
++------------------------------------------------------------------------------
+| Description : The function starts the reading process of PSI2
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_reread_psi2(void)
+{
+TRACE_FUNCTION("psi_reread_psi2");
+psc_db->state_of_PSI[PSI2].state = NEEDED;
+psi_partial_acq();
+psi_reset_psi2();
+psi_start_10sec();
+}/* psi_reread_psi2*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reread_psi3_and_3bis
++------------------------------------------------------------------------------
+| Description : The function starts the reading process of PSI3 nad PSI3bis
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_reread_psi3_and_3bis(void)
+{
+TRACE_FUNCTION("psi_reread_psi3_and_3bis");
+psc_db->state_of_PSI[PSI3bis].state = NEEDED;
+psc_db->state_of_PSI[PSI3].state = NEEDED;
+psi_partial_acq();
+/*
+* Reset PSI3 and PSI3BIS paramter
+*/
+psi_reset_psi3bis();
+psi_reset_psi3();
+psi_start_10sec();
+}/* psi_reread_psi3_and_3bis*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reread_psi3bis
++------------------------------------------------------------------------------
+| Description : The function starts the reading process of PSI3bis
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_reread_psi3bis(void)
+{
+TRACE_FUNCTION("psi_reread_psi3bis");
+/*
+* Message has changed, reset all values and read new consistent message set
+*/
+psc_db->state_of_PSI[PSI3bis].state = NEEDED;
+psi_partial_acq();
+psi_reset_psi3bis();
+psi_start_10sec();
+}/* psi_reread_psi3bis*/
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reread_psi3ter
++------------------------------------------------------------------------------
+| Description : The function starts the reading process of PSI3ter
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_reread_psi3ter(void)
+{
+TRACE_FUNCTION("psi_reread_psi3ter");
+/*
+* Message has changed, reset all values and read new consistent message set
+*/
+psc_db->state_of_PSI[PSI3ter].state = NEEDED;
+psi_partial_acq();
+psi_reset_psi3ter();
+psi_start_10sec();
+}/* psi_reread_psi3ter*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reread_psi3_3bis_3ter
++------------------------------------------------------------------------------
+| Description : The function starts the reading process of PSI3 to PSI3ter
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_reread_psi3_3bis_3ter(void)
+{
+TRACE_FUNCTION("psi_reread_psi3_3bis_3ter");
+if(psc_db->v_add_psi AND psc_db->add_psi.psi3ter_broadcast)
+{
+psc_db->state_of_PSI[PSI3ter].state = NEEDED;
+}
+else
+{
+psc_db->state_of_PSI[PSI3ter].state = NOT_SEND;
+}
+psc_db->state_of_PSI[PSI3bis].state = NEEDED;
+psc_db->state_of_PSI[PSI3].state = NEEDED;
+psi_partial_acq();
+/*
+* Reset PSI3 to PSI3ter parameters
+*/
+/* psi_reset_psi3quater(); */
+psi_reset_psi3ter();
+psi_reset_psi3bis();
+psi_reset_psi3();
+psi_start_10sec();
+}/* psi_reread_psi3_3bis_3ter */
+#endif
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reread_psi4
++------------------------------------------------------------------------------
+| Description : The function starts the reading process of PSI4
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_reread_psi4(void)
+{
+TRACE_FUNCTION("psi_reread_psi4");
+psc_db->state_of_PSI[PSI4].state = NEEDED;
+psi_partial_acq();
+/*
+* Reset PSI4
+*/
+psi_reset_psi4();
+psi_start_10sec();
+}/* psi_reread_psi4*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reread_psi5
++------------------------------------------------------------------------------
+| Description : The function starts the reading process of PSI5
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_reread_psi5(void)
+{
+TRACE_FUNCTION("psi_reread_psi5");
+psc_db->state_of_PSI[PSI5].state = NEEDED;
+psi_partial_acq();
+/*
+* Reset PSI5
+*/
+psi_reset_psi5();
+psi_start_10sec();
+}/* psi_reread_psi5*/
+#ifdef REL99
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reread_psi8
++------------------------------------------------------------------------------
+| Description : The function starts the reading process of PSI8
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_reread_psi8(void)
+{
+TRACE_FUNCTION("psi_reread_psi8");
+psc_db->state_of_PSI[PSI8].state = NEEDED;
+psi_partial_acq();
+/*
+* Reset PSI8
+*/
+psi_reset_psi8();
+psi_start_10sec();
+}/* psi_reread_psi8*/
+#endif
+/*
++------------------------------------------------------------------------------
+| Function    : psi_handle_psi1
++------------------------------------------------------------------------------
+| Description : The function handles PSI1 message on both PBCCH and PACCH channels
+|
+| Parameters  : T_PSI_1*
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_handle_psi1(T_PSI_1 * psi1)
+{
+TRACE_FUNCTION("psi_handle_psi1");
+switch(psi_process_psi1(psi1))
+{
+case PSI1_PBCCH_RELEASED:
+SET_STATE( PSI, PSI_NULL );
+psi_initiate_pbcch_switching( PSI_DC_PBCCH_RELEASED );
+return; /* sorry: dirty solution */
+case PSI1_PBCCH_ESTABLISHED:
+SET_STATE( PSI, PSI_NULL );
+psi_initiate_pbcch_switching( PSI_DC_PBCCH_ESTABLISHED );
+return; /* sorry: another dirty solution */
+case PSI1_OK:
+if( psc_db->measurement_order EQ FALSE )
+{
+sig_psi_ctrl_meas_param_invalid_psi5( );
+}
+/* update readin parameters of psi */
+psi_update_data_to_request(INIT_NOT_NEEDED);
+/*
+* check the state of the acquisition
+*/
+switch(psi_check_acq_state())
+{
+case ACQ_RUNNING:
+/*
+* Check whether access to the network is allowed or not,
+* in case of having complete acq
+*/
+if(psi_is_access_allowed() AND (psc_db->acq_type EQ COMPLETE))
+{
+psc_db->psi1_params.first_psi1 = FALSE;
+psi_stop_psi_reading(NONE);
+psi_stop_10sec(); /* Stop this timer, if running */
+#ifdef _SIMULATION_
+vsi_t_stop(GRR_handle,T_COMP_PSI);
+#endif
+/*
+* restart 30 sec:e.g. wait 30 sec for reread PSI1
+*/
+psi_stop_30sec(TRUE);
+/*
+* Access to the network is allowed
+*/
+psi_send_access_enable_if_needed();
+}
+else if(psi_is_access_allowed() AND (psc_db->acq_type EQ FULL_PSI_IN_NEW_CELL))
+{
+/*
+* Access to the new re-selected cell is allowed
+*/
+psc_db->psi1_params.first_psi1 = FALSE;
+psi_stop_psi_reading(NONE);
+/*
+* restart 30 sec:e.g. wait 30 sec for reread PSI1
+*/
+psi_stop_30sec(TRUE);
+sig_psi_ctrl_ncell_psi_read( TRUE);
+}
+else
+{
+/*
+* Acq. is running, check whether we received the PSI1 message
+* for the first time or not.
+* if the PSI1 message is received for the first time, restart to read PBCCH blocks,
+* because of reading new parameters in PSI1 message,e.g. PCCCH parameters
+*/
+if(
+psc_db->psi1_params.first_psi1
+AND
+((psc_db->acq_type EQ COMPLETE) OR (psc_db->acq_type EQ FULL_PSI_IN_NEW_CELL))
+)
+{
+psi_stop_30sec(TRUE);/*restart 30 sec*/
+psi_receive_psi(READ_COMPLETE);
+}
+}
+break;
+case ACQ_PART_OK:
+psi_stop_psi_reading(NONE);
+#ifdef _TARGET_
+TRACE_EVENT("PSI1->NEW_PCCCH");
+sig_psi_ctrl_new_pccch();
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+psc_db->network_pg_mode = psi1->page_mode;
+#endif
+#endif
+break;
+case ACQ_COMP_OK:
+psi_stop_60sec(TRUE);/*restart 60 sec*/
+psi_stop_30sec(TRUE);/*restart 30 sec*/
+psi_stop_psi_reading(NONE);
+/*
+* Access to the network is allowed
+*/
+psi_send_access_enable_if_needed();
+break;
+case ACQ_PERIOD_OK:
+/*
+* Periodical pSI1 reading is O.K.
+*/
+psi_stop_60sec(TRUE);/*restart 60 sec*/
+psi_stop_30sec(TRUE);/*restart 30 sec*/
+psi_stop_psi_reading(NONE);
+break;
+default:
+TRACE_ERROR("Unexpected acq_ret in PSI1");
+break;
+}/* switch acq_state*/
+break;
+case PSI1_COMPLETE_ACQ:
+psi_initiate_read_complete_psi( INIT_NOT_NEEDED );
+break;
+case PSI1_PARTIAL_ACQ:
+/* update psi data*/
+psi_stop_60sec(TRUE);/*restart 60 sec*/
+psi_stop_30sec(TRUE);/*restart 30 sec*/
+psi_update_data_to_request( INIT_NOT_NEEDED);
+psi_partial_acq();
+/*TRACE_EVENT("Complete instead partial");
+psi_receive_psi(READ_COMPLETE);*/
+psc_db->send_psi_status = TRUE; /* this parameters has meaning if the network supports PSI STATUS */
+psi_start_10sec();
+break;
+}/* switch process_psi1*/
+if(psi_is_access_class_changed() AND !psc_db->psi1_params.first_psi1)
+{
+/*
+* Implies the CTRL to send CELL_IND
+*/
+sig_psi_ctrl_access_changed();
+}
+if(psc_db->acq_type NEQ COMPLETE)
+{
+psc_db->psi1_params.first_psi1 = FALSE;
+}
+}/* psi_handle_psi1*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_handle_psi2
++------------------------------------------------------------------------------
+| Description : The function handles PSI2 message on both PBCCH and PACCH channels
+|
+| Parameters  : T_PSI_2*
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_handle_psi2(T_PSI_2 * psi2)
+{
+TRACE_FUNCTION("psi_handle_psi2");
+switch(psi_process_psi2(psi2))
+{
+case PSI2_OK:
+switch(psi_check_acq_state())
+{
+case ACQ_RUNNING:
+/*
+* Check whether access to the network is allowed or not,
+* in case of having complete acq
+*/
+if(psi_is_access_allowed() AND (psc_db->acq_type EQ COMPLETE))
+{
+psi_stop_psi_reading(NONE);
+psi_stop_10sec(); /* Stop this timer, if running */
+#ifdef _SIMULATION_
+vsi_t_stop(GRR_handle,T_COMP_PSI);
+#endif
+/*
+* Access to the network is allowed
+*/
+psi_send_access_enable_if_needed();
+}
+else if(psi_is_access_allowed() AND (psc_db->acq_type EQ FULL_PSI_IN_NEW_CELL))
+{
+/*
+* Access to the new re-selected cell is allowed
+*/
+psi_stop_psi_reading(NONE);
+sig_psi_ctrl_ncell_psi_read( TRUE );
+}
+break;
+case ACQ_PART_OK:
+psi_stop_psi_reading(NONE);
+/*
+* TimeSlot number may have changed, so we have to restart PCCCH reading
+*/
+TRACE_EVENT("PSI2->NEW_PCCCH");
+sig_psi_ctrl_new_pccch();
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+psc_db->network_pg_mode = psi2->page_mode;
+#endif
+break;
+case ACQ_COMP_OK:
+psi_stop_psi_reading(NONE);
+/*
+* Access to the network is allowed
+*/
+psi_send_access_enable_if_needed();
+break;
+default:
+TRACE_ERROR("Unexpected acq_ret in PSI2");
+break;
+}/*switch check_acq*/
+break;
+case PSI2_REREAD:
+/*
+* Error situation read a new PSI2
+*/
+psi_reread_psi2();
+break;
+}
+}/* psi_handle_psi2*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_handle_psi3
++------------------------------------------------------------------------------
+| Description : The function handles PSI3 message on both PBCCH and PACCH channels
+|
+| Parameters  : T_PSI_3*
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_handle_psi3(T_PSI_3 * psi3)
+{
+TRACE_FUNCTION("psi_handle_psi3");
+switch(psi_process_psi3(psi3))
+{
+case PSI3_NCELL_VALID:
+/*
+* Inform MEAS that the NCELL parameters are valid
+*/
+sig_psi_ctrl_ncell_param_valid();
+/*lint -fallthrough*/
+case PSI3_OK:
+/*
+* check the acquisition state: it is only for having a complete set of information
+*/
+switch(psi_check_acq_state())
+{
+case ACQ_RUNNING:
+/*
+* Nothing to do
+*/
+break;
+case ACQ_PART_OK:
+psi_stop_psi_reading(NONE);
+#ifdef _TARGET_
+TRACE_EVENT("PSI3->NEW_PCCCH");
+sig_psi_ctrl_new_pccch();
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+psc_db->network_pg_mode = psi3->page_mode;
+#endif
+#endif
+break;
+case ACQ_COMP_OK:
+psi_stop_psi_reading(NONE);
+/*
+* Access to the network is allowed
+*/
+psi_send_access_enable_if_needed();
+break;
+default:
+TRACE_ERROR("Unexpected acq_ret in PSI3");
+break;
+}/*switch check_acq*/
+break;
+case PSI3_NCELL_INVALID:
+grr_init_nc_list( &psc_db->nc_cw.list );
+sig_psi_ctrl_ncell_param_invalid();
+break;
+case PSI3_CELL_BARRED:
+sig_psi_ctrl_access_barred();
+break;
+}/* switch psi_process_psi3*/
+}/*psi_handle_psi3*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_handle_psi3bis
++------------------------------------------------------------------------------
+| Description : The function handles PSI3_BIS message on both PBCCH and PACCH channels
+|
+| Parameters  : T_PSI_3_BIS*
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_handle_psi3bis(T_PSI_3_BIS * psi3bis)
+{
+TRACE_FUNCTION("psi_handle_psi3bis");
+switch(psi_process_psi3bis(psi3bis))
+{
+case PSI3BIS_REREAD_PSI3BIS:
+psi_reread_psi3bis();
+/*
+* Ncell parameter are invalid. We have to inform MEAS-Service
+*/
+grr_init_nc_list( &psc_db->nc_cw.list );
+sig_psi_ctrl_ncell_param_invalid();
+break;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+case PSI3BIS_REREAD_PSI3_3BIS_3TER:
+psi_reread_psi3_3bis_3ter();
+#else
+case PSI3BIS_REREAD_PSI3_3BIS:
+psi_reread_psi3_and_3bis();
+#endif
+/*
+* Ncell parameter are invalid. We have to inform MEAS-Service
+*/
+grr_init_nc_list( &psc_db->nc_cw.list );
+sig_psi_ctrl_ncell_param_invalid();
+break;
+case PSI3BIS_NCELL_VALID:
+/*
+* Inform MEAS that the NCELL parameters are valid
+*/
+sig_psi_ctrl_ncell_param_valid();
+/*lint -fallthrough*/
+case PSI3BIS_OK:
+/*
+* check the acquisition state: it is only for having a complete set of information
+*/
+switch(psi_check_acq_state())
+{
+case ACQ_RUNNING:
+/*
+* Nothing to do
+*/
+break;
+case ACQ_PART_OK:
+psi_stop_psi_reading(NONE);
+#ifdef _TARGET_
+TRACE_EVENT("PSI3bis->NEW_PCCCH");
+sig_psi_ctrl_new_pccch();
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+psc_db->network_pg_mode = psi3bis->page_mode;
+#endif
+#endif
+break;
+case ACQ_COMP_OK:
+psi_stop_psi_reading(NONE);
+/*
+* Access to the network is allowed
+*/
+psi_send_access_enable_if_needed();
+break;
+default:
+TRACE_ERROR("Unexpected acq_ret in PSI3bis");
+break;
+}/*switch check_acq*/
+break;
+}/* switch process_psi3bis*/
+}/*psi_handle_psi3bis*/
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+/*
++------------------------------------------------------------------------------
+| Function    : psi_handle_psi3ter
++------------------------------------------------------------------------------
+| Description : The function handles PSI3_TER message on both PBCCH and PACCH channels
+|
+| Parameters  : T_PSI_3_TER*
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_handle_psi3ter(T_PSI_3_TER * psi3ter)
+{
+TRACE_FUNCTION("psi_handle_psi3ter");
+switch(psi_process_psi3ter(psi3ter))
+{
+case PSI3TER_REREAD_PSI3TER:
+psi_reread_psi3ter();
+break;
+case PSI3TER_REREAD_PSI3_3BIS_3TER:
+psi_reread_psi3_3bis_3ter();
+break;
+case PSI3TER_OK:
+/*
+* check the acquisition state: it is only for having a complete set of information
+*/
+switch(psi_check_acq_state())
+{
+case ACQ_RUNNING:
+/*
+* Nothing to do
+*/
+break;
+case ACQ_PART_OK:
+psi_stop_psi_reading(NONE);
+#ifdef _TARGET_
+TRACE_EVENT("PSI3ter->NEW_PCCCH");
+sig_psi_ctrl_new_pccch();
+psc_db->network_pg_mode = psi3ter->page_mode;
+#endif
+break;
+case ACQ_COMP_OK:
+psi_stop_psi_reading(NONE);
+/*
+* Access to the network is allowed
+*/
+psi_send_access_enable_if_needed();
+break;
+default:
+TRACE_ERROR("Unexpected acq_ret in PSI3bis");
+break;
+}/*switch check_acq*/
+break;
+}/* switch process_psi3ter*/
+}/*psi_handle_psi3ter*/
+#endif
+/*
++------------------------------------------------------------------------------
+| Function    : psi_handle_psi4
++------------------------------------------------------------------------------
+| Description : The function handles PSI4 message on both PBCCH and PACCH channels
+|
+| Parameters  : T_PSI_4*
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_handle_psi4(T_PSI_4 * psi4)
+{
+TRACE_FUNCTION("psi_handle_psi4");
+switch(psi_process_psi4(psi4))
+{
+case PSI4_REREAD:
+psi_reread_psi4();
+/*
+* Interference channel list is invalid. We have to inform MEAS-Service
+*/
+sig_psi_ctrl_int_list_invalid();
+break;
+case PSI4_INT_LIST_VALID:
+/*
+* Inform MEAS that the Interference parameters are valid
+*/
+sig_psi_ctrl_int_list_valid();
+/*lint -fallthrough*/
+case PSI4_OK:
+/*
+* check the acquisition state: it is only for having a complete set of information
+*/
+switch(psi_check_acq_state())
+{
+case ACQ_RUNNING:
+/*
+* Nothing to do
+*/
+break;
+case ACQ_PART_OK:
+psi_stop_psi_reading(NONE);
+#ifdef _TARGET_
+TRACE_EVENT("PSI4->NEW_PCCCH");
+sig_psi_ctrl_new_pccch();
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+psc_db->network_pg_mode = psi4->page_mode;
+#endif
+#endif
+break;
+case ACQ_COMP_OK:
+psi_stop_psi_reading(NONE);
+/*
+* Access to the network is allowed
+*/
+psi_send_access_enable_if_needed();
+break;
+default:
+TRACE_ERROR("Unexpected acq_ret in PSI4");
+break;
+}/*switch check_acq*/
+break;
+}
+}/* psi_handle_psi4*/
+#ifdef REL99
+/*
++------------------------------------------------------------------------------
+| Function    : psi_handle_psi8
++------------------------------------------------------------------------------
+| Description : The function handles PSI8 message on both PBCCH and PACCH channels
+|
+| Parameters  : T_PSI_8*
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_handle_psi8(T_PSI_8 * psi8)
+{
+TRACE_FUNCTION("psi_handle_psi8");
+switch(psi_process_psi8(psi8))
+{
+case PSI8_REREAD:
+psi_reread_psi8();
+break;
+case PSI8_OK:
+/*
+* check the acquisition state: it is only for having a complete set of information
+*/
+switch(psi_check_acq_state())
+{
+case ACQ_RUNNING:
+/*
+* Nothing to do
+*/
+break;
+case ACQ_PART_OK:
+psi_stop_psi_reading(NONE);
+#ifdef _TARGET_
+TRACE_EVENT("PSI8->NEW_PCCCH");
+sig_psi_ctrl_new_pccch();
+psc_db->network_pg_mode = psi8->page_mode;
+#endif
+break;
+case ACQ_COMP_OK:
+psi_stop_psi_reading(NONE);
+/*
+* Access to the network is allowed
+*/
+psi_send_access_enable_if_needed();
+break;
+default:
+TRACE_ERROR("Unexpected acq_ret in PSI8");
+break;
+}/*switch check_acq*/
+break;
+}
+}/* psi_handle_psi8*/
+#endif
+/*
++------------------------------------------------------------------------------
+| Function    : psi_copy_si13_params
++------------------------------------------------------------------------------
+| Description : The function copies si13 parameters into sc_db
+|
+| Parameters  : T_D_SYS_INFO_13*
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_copy_si13_params(T_D_SYS_INFO_13* si13)
+{
+TRACE_FUNCTION("psi_copy_si13_params");
+/*
+* Copy SI13_CHANGE_MARK and GPRS Mobile Allocation
+*/
+if(si13->si13_rest_oct.si13_info.flag)
+{
+psc_db->psi13_params.si13_change_mark = si13->si13_rest_oct.si13_info.si13_cm;
+psi_copy_ma_from_psi13((T_gprs_ms_alloc_ie*)&(si13->si13_rest_oct.si13_info.gprs_ma));
+}
+grr_set_pbcch( si13->si13_rest_oct.si13_info.v_pbcch_des );
+if(si13->si13_rest_oct.si13_info.v_pbcch_des)
+{
+/*
+* PBCCH description present in the SI13 message
+*/
+psc_db->psi1_params.psi1_repeat_period = si13->si13_rest_oct.si13_info.psi1_period + 1;
+/* pbcch description in database and in SI13 is different!!!*/
+psc_db->pbcch.pbcch_des.pb = si13->si13_rest_oct.si13_info.pbcch_des.pb;
+psc_db->pbcch.pbcch_des.tsc = si13->si13_rest_oct.si13_info.pbcch_des.tsc;
+psc_db->pbcch.pbcch_des.tn = si13->si13_rest_oct.si13_info.pbcch_des.tn;
+if((si13->si13_rest_oct.si13_info.pbcch_des.flag EQ FALSE) AND (si13->si13_rest_oct.si13_info.pbcch_des.flag2 EQ FALSE))
+{
+psc_db->pbcch.pbcch_des.flag = FALSE;
+}
+else
+{
+psc_db->pbcch.pbcch_des.flag = TRUE;
+}
+psc_db->pbcch.pbcch_des.v_arfcn = si13->si13_rest_oct.si13_info.pbcch_des.v_arfcn;
+psc_db->pbcch.pbcch_des.arfcn = si13->si13_rest_oct.si13_info.pbcch_des.arfcn;
+psc_db->pbcch.pbcch_des.v_maio = si13->si13_rest_oct.si13_info.pbcch_des.v_maio;
+psc_db->pbcch.pbcch_des.maio = si13->si13_rest_oct.si13_info.pbcch_des.maio;
+}
+else
+{
+/*
+* No PBCCH description present in the SI13 message
+*/
+/*
+* Copy non PBCCH parameters: RAC, SPGC_CCCH_SUP, PRIORITY_ACCESS_THR,
+* NETWORK_CONTROL_ORDER
+*/
+/* Set RAC value */
+psc_db->cell_info_for_gmm.cell_info.cell_env.rai.rac = si13->si13_rest_oct.si13_info.rac;
+psc_db->net_ctrl.spgc_ccch_supp.nw_supp = si13->si13_rest_oct.si13_info.spgc;
+psc_db->net_ctrl.priority_access_thr = si13->si13_rest_oct.si13_info.prio_acc_thr;
+/*
+* Copy NC measurement parameter
+*/
+{
+T_nc_meas_par nc_meas_par;
+nc_meas_par.ctrl_order = si13->si13_rest_oct.si13_info.nco;
+nc_meas_par.v_nc_meas_per       = FALSE;
+/*
+* SI13 doesnt carry the nc meas parameters. So we should not reset/change the
+* parameters after receiving every SI13 periodic reading.
+*/
+if( (nc_meas_par.ctrl_order EQ NCMEAS_NC2) OR (nc_meas_par.ctrl_order EQ NCMEAS_NC1) )
+{
+if ( (psc_db->nc_cw.param.rep_per_i NEQ NC_REP_PER_I_DEFAULT )  AND
+(psc_db->nc_cw.param.rep_per_t NEQ NC_REP_PER_T_DEFAULT) AND
+(psc_db->nc_cw.param.non_drx_per NEQ NC_NON_DRX_PER_DEFAULT) AND
+(psc_db->nc_cw.param.ctrl_order NEQ NC_NC0) AND
+(psc_db->nc_cw.param.idx NEQ NOT_SET) )
+{
+nc_meas_par.nc_meas_per.non_drx_per = psc_db->nc_cw.param.non_drx_per;
+nc_meas_par.nc_meas_per.rep_per_i   = psc_db->nc_cw.param.rep_per_i ;
+nc_meas_par.nc_meas_per.rep_per_t   = psc_db->nc_cw.param.rep_per_t;
+nc_meas_par.v_nc_meas_per = TRUE;
+}
+}
+/*
+* Only one instance of SI13, store data in final location.
+*/
+grr_prcs_nc_param_struct ( &psc_db->nc_cw.param, &nc_meas_par, 0 );
+}
+/*
+* Copy GPRS cell options
+*/
+psc_db->v_gprs_cell_opt = TRUE;
+/*
+* SZML-PSI/001
+*/
+memcpy(&(psc_db->gprs_cell_opt), &(si13->si13_rest_oct.si13_info.gprs_cell_opt), sizeof(T_gprs_cell_opt));
+if(si13->si13_rest_oct.si13_info.gprs_cell_opt.nmo EQ GMMRR_NET_MODE_III)
+{
+TRACE_EVENT("NMO III in network ----> GMMRR_NET_MODE_II");
+psc_db->cell_info_for_gmm.cell_info.net_mode =  GMMRR_NET_MODE_II;
+}
+else
+{
+psc_db->cell_info_for_gmm.cell_info.net_mode = si13->si13_rest_oct.si13_info.gprs_cell_opt.nmo;
+}
+/*
+* Copy power control parameters
+*/
+{
+T_si13_info *si13_info = &si13->si13_rest_oct.si13_info;
+psc_db->v_g_pwr_par = TRUE;
+psc_db->g_pwr_par.alpha           = CLIP_ALPHA( si13_info->alpha );
+psc_db->g_pwr_par.t_avg_w         = CLIP_T_AVG( si13_info->t_avg_w );
+psc_db->g_pwr_par.t_avg_t         = CLIP_T_AVG( si13_info->t_avg_t );
+psc_db->g_pwr_par.pb              = 0;
+psc_db->g_pwr_par.pc_meas_chan    = si13_info->pc_meas_chan;
+psc_db->g_pwr_par.imeas_chan_list = FALSE;
+psc_db->g_pwr_par.n_avg_i         = si13_info->n_avg_i;
+grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param = TRUE;
+}
+}
+}/* psi_copy_si13_params */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_is_pbcch_des_different
++------------------------------------------------------------------------------
+| Description : The function checks whether PBCCH description of the received
+|               PSI13 message is different from the stored one
+|
+| Parameters  : T_PSI_13*; TRUE: If desc. are different FALSE: same
+|
++------------------------------------------------------------------------------
+*/
+LOCAL BOOL psi_is_pbcch_des_different(T_PSI_13* psi13)
+{
+TRACE_FUNCTION("psi_is_pbcch_des_different");
+if(!psi13->flag) /* No PBCCH description present: PBCCH no longer available*/
+return TRUE;
+/* compare PBCCH descriptions*/
+if((psc_db->pbcch.pbcch_des.pb EQ psi13->psi1_pbcch_info.pbcch_des.pb) AND
+(psc_db->pbcch.pbcch_des.tsc EQ psi13->psi1_pbcch_info.pbcch_des.tsc) AND
+(psc_db->pbcch.pbcch_des.tn EQ psi13->psi1_pbcch_info.pbcch_des.tn))
+{
+/* compare BCCH carrier-flag, if exists*/
+if(psc_db->pbcch.pbcch_des.flag NEQ psi13->psi1_pbcch_info.pbcch_des.flag)
+return TRUE;
+/* compare non-hopping carrier, if exists: ARFCN*/
+if(
+(psc_db->pbcch.pbcch_des.v_arfcn NEQ psi13->psi1_pbcch_info.pbcch_des.v_arfcn)
+OR
+(psc_db->pbcch.pbcch_des.arfcn NEQ psi13->psi1_pbcch_info.pbcch_des.arfcn)
+)
+return TRUE;
+/* Compare hopping carrier, if exists: MAIO*/
+if(
+(psc_db->pbcch.pbcch_des.v_maio NEQ psi13->psi1_pbcch_info.pbcch_des.v_maio)
+OR
+(psc_db->pbcch.pbcch_des.maio NEQ psi13->psi1_pbcch_info.pbcch_des.maio)
+)
+return TRUE;
+}
+else
+{
+return TRUE;
+}
+return FALSE;
+}/* psi_is_pbcch_des_different*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_copy_psi13_params
++------------------------------------------------------------------------------
+| Description : The function copies psi13 parameters into sc_db
+|
+| Parameters  : T_PSI_13*
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_copy_psi13_params(T_PSI_13* psi13)
+{
+TRACE_FUNCTION("psi_copy_psi13_params");
+/*
+* Handle SI13_CHANGE_MARK and GPRS Mobile Allocation
+*/
+if(psi13->v_si13_cm_gprs_alloc)
+{
+psc_db->psi13_params.si13_change_mark = psi13->si13_cm_gprs_alloc.si13_cm;
+psi_copy_ma_from_psi13(&(psi13->si13_cm_gprs_alloc.gprs_ms_alloc_ie));
+}
+grr_set_pbcch( psi13->flag );
+if(psi13->flag)
+{
+/*
+* PBCCH description present in the PSI13 message
+*/
+psc_db->psi1_params.psi1_repeat_period = psi13->psi1_pbcch_info.psi1_rep_per + 1;
+memcpy(&(psc_db->pbcch.pbcch_des), &(psi13->psi1_pbcch_info.pbcch_des), sizeof(T_pbcch_des));
+}
+else
+{
+/*
+* No PBCCH description present in the PSI13 message
+*/
+/*
+* Copy non PBCCH parameters: RAC, SPGC_CCCH_SUP, PRIORITY_ACCESS_THR
+*/
+/* Set RAC value */
+psc_db->cell_info_for_gmm.cell_info.cell_env.rai.rac = psi13->pbcch_n_pres.rac;
+psc_db->net_ctrl.spgc_ccch_supp.nw_supp = psi13->pbcch_n_pres.spgc_ccch_sup;
+psc_db->net_ctrl.priority_access_thr = psi13->pbcch_n_pres.prio_acc_thr;
+/*
+* Copy NC measurement parameter
+*/
+{
+T_nc_meas_par nc_meas_par;
+nc_meas_par.ctrl_order = psi13->pbcch_n_pres.ctrl_order;
+nc_meas_par.v_nc_meas_per       = FALSE;
+/*
+* Only one instance of PSI13, store data in final location.
+*/
+grr_prcs_nc_param_struct ( &psc_db->nc_cw.param, &nc_meas_par, 0 );
+}
+/*
+* Copy GPRS cell options
+*/
+psc_db->v_gprs_cell_opt = TRUE;
+/*
+* SZML-PSI/002
+*/
+memcpy(&(psc_db->gprs_cell_opt), &(psi13->pbcch_n_pres.gprs_cell_opt), sizeof(T_gprs_cell_opt));
+psc_db->cell_info_for_gmm.cell_info.net_mode = psi13->pbcch_n_pres.gprs_cell_opt.nmo;
+/*
+* Copy power control parameters
+*/
+{
+T_psi13_pwr_par *pwr_par = &psi13->pbcch_n_pres.psi13_pwr_par;
+psc_db->v_g_pwr_par = TRUE;
+psc_db->g_pwr_par.alpha           = CLIP_ALPHA( pwr_par->alpha);
+psc_db->g_pwr_par.t_avg_w         = CLIP_T_AVG( pwr_par->t_avg_w );
+psc_db->g_pwr_par.t_avg_t         = CLIP_T_AVG( pwr_par->t_avg_t );
+psc_db->g_pwr_par.pb              = 0;
+psc_db->g_pwr_par.pc_meas_chan    = pwr_par->pc_meas_chan;
+psc_db->g_pwr_par.imeas_chan_list = FALSE;
+psc_db->g_pwr_par.n_avg_i         = pwr_par->n_avg_i;
+grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param = TRUE;
+}
+}
+} /* psi_copy_psi13_params */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_send_access_enable_if_needed
++------------------------------------------------------------------------------
+| Description : The function sends signal to CTRL to indicate that the access
+|               is enabled
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_send_access_enable_if_needed()
+{
+TRACE_FUNCTION("psi_send_access_enable_if_needed");
+if(!psc_db->is_access_enabled)
+{
+psc_db->is_access_enabled = TRUE;
+sig_psi_ctrl_access_enabled( );
+}
+#ifdef _TARGET_
+else if(grr_is_pbcch_present())
+{
+/*
+* Inform CTRL about new pccch, if there is a new one exists.
+* It may be the PBCCH and/or PCCCH description has been
+* changed, so that PCCCH reading should be started again.
+* If not this is not a big problem. This is done to avoid
+* saving PCCCH description in database to compare whether
+* it has been changed or not.
+*/
+TRACE_EVENT("Access enabled, PCCCH may have changed");
+sig_psi_ctrl_new_pccch();
+}
+#endif /* _TARGET_ */
+#ifdef REL99
+TRACE_EVENT_P2 ("pbbch %d, cbch_info %d", grr_is_pbcch_present(), psc_db->send_cbch_info_ind);
+if(grr_is_pbcch_present() AND psc_db->send_cbch_info_ind)
+{
+sig_psi_ctrl_cbch_info_ind();
+psc_db->send_cbch_info_ind = FALSE;
+}
+#endif
+}/*psi_send_access_enable_if_needed */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_initiate_read_complete_si
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_initiate_read_complete_si ( void )
+{
+TRACE_FUNCTION( "psi_initiate_read_complete_si" );
+psi_stop_60sec( TRUE );
+psi_stop_30sec( TRUE );
+sig_psi_ctrl_access_disabled( PSI_DC_OTHER );
+} /* psi_initiate_read_complete_si */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_initiate_read_complete_psi
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_initiate_read_complete_psi ( UBYTE init_needed )
+{
+TRACE_FUNCTION( "psi_initiate_read_complete_psi" );
+TRACE_EVENT( "PBCCH present" );
+psi_stop_60sec( TRUE );
+psi_stop_30sec( TRUE );
+psi_update_data_to_request( init_needed );
+sig_psi_ctrl_access_disabled( PSI_DC_READ_PSI );
+} /* psi_initiate_read_complete_psi */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_initiate_pbcch_switching
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_initiate_pbcch_switching ( T_PSI_DISABLE_CAUSE dc )
+{
+TRACE_FUNCTION( "psi_initiate_pbcch_switching" );
+if( psc_db->acq_type NEQ NONE )
+{
+psi_stop_psi_reading(NONE);
+}
+sig_psi_ctrl_access_disabled( dc );
+psi_stop_timer();
+psi_init_params();
+grr_set_pbcch( FALSE );
+} /* psi_initiate_pbcch_switching */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_store_ncell_param
++------------------------------------------------------------------------------
+| Description :
+| Parameters  :
++------------------------------------------------------------------------------
+*/
+LOCAL UBYTE psi_store_ncell_param ( T_ncell_par *p_ncell_par,
+UBYTE        c_ncell_par,
+UBYTE        v_ncell_par,
+T_INFO_TYPE  type,
+UBYTE        instance )
+{
+UBYTE  i, j;
+UBYTE  number    = 0;
+USHORT last_freq;
+TRACE_FUNCTION( "psi_store_ncell_param" );
+if( !v_ncell_par )
+{
+switch ( type )
+{
+case( INFO_TYPE_PSI3 ):
+TRACE_EVENT( "No ncell parameters in PSI3" );
+break;
+case( INFO_TYPE_PSI3BIS ):
+TRACE_EVENT( "No ncell parameters in PSI3BIS" );
+break;
+default:
+TRACE_EVENT( "Unexpected neighbour cell information source" );
+break;
+}
+return( number ); /* no ncell parameters */
+}
+switch ( type )
+{
+case( INFO_TYPE_PSI3 ):
+case( INFO_TYPE_PSI3BIS ):
+break;
+default:
+TRACE_EVENT( "Unexpected neighbour cell information source" );
+return( number );
+}
+for( i = 0; i < c_ncell_par; i++ )
+{
+last_freq = 0;
+if( grr_store_cs_param
+( &psc_db->nc_cw.list,
+TRUE,
+&p_ncell_par[i].cs_par,
+type,
+instance,
+&number,
+&last_freq,
+p_ncell_par[i].start_freq,
+p_ncell_par[i].bsic ) EQ FALSE )
+{
+TRACE_EVENT( "psi_store_ncell_param: NC_CW list full" );
+return( number );
+}
+for( j = 0; j < p_ncell_par[i].n_rest; j++ )
+{
+if( grr_store_cs_param
+( &psc_db->nc_cw.list,
+TRUE,
+&p_ncell_par[i].ncell_par_rest[j].cs_par,
+type,
+instance,
+&number,
+&last_freq,
+p_ncell_par[i].ncell_par_rest[j].freq_diff_struct.freq_diff,
+p_ncell_par[i].ncell_par_rest[j].bsic ) EQ FALSE )
+{
+TRACE_EVENT( "psi_store_ncell_param: NC_CW list full" );
+return( number );
+}
+}
+}
+return( number );
+}/* psi_store_ncell_param */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_store_ncell_param2
++------------------------------------------------------------------------------
+| Description :
+| Parameters  :
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_store_ncell_param2 ( T_PSI_3_BIS *psi3bis, UBYTE number )
+{
+T_ncell_par2_s1 *p_sub_1;
+T_ncell_par2_s2 *p_sub_2;
+USHORT last_freq;
+UBYTE  i, j, cell_params_ptr, x, y, n;
+TRACE_FUNCTION( "psi_store_ncell_param2" );
+if( !psi3bis->ncell_par_trnc_grp.v_ncell_par2 )
+{
+return;
+}
+for( i = 0;
+i < psi3bis->ncell_par_trnc_grp.c_ncell_par2;
+i++ )
+{
+for( n = 0;
+n < psi3bis->ncell_par_trnc_grp.ncell_par2[i].c_ncell_par2_des;
+n++ )
+{
+cell_params_ptr = psi3bis->ncell_par_trnc_grp.ncell_par2[i].ncell_par2_des[n].para_ptr;
+if( cell_params_ptr > psi3bis->ncell_par_trnc_grp.ncell_par2[i].c_ncell_par2_set )
+{
+TRACE_ERROR( "cell_params_ptr > psi3bis->ncell_par2[i].c_ncell_par2_set" );
+return;
+}
+for( j = 0;
+j < psi3bis->ncell_par_trnc_grp.ncell_par2[i].ncell_par2_des[n].c_ncell_par2_s1;
+j++ )
+{
+last_freq = 0;
+p_sub_1   = &psi3bis->ncell_par_trnc_grp.ncell_par2[i].ncell_par2_des[n].ncell_par2_s1[j];
+if( psi_store_cs_param2
+( &psc_db->nc_cw.list,
+&psi3bis->ncell_par_trnc_grp.ncell_par2[i].ncell_par2_set[cell_params_ptr],
+psi3bis->psi3bis_ind,
+&number,
+&last_freq,
+p_sub_1->start_freq,
+p_sub_1->same_ra_scell,
+p_sub_1->cell_ba,
+p_sub_1->bcc ) EQ FALSE )
+{
+TRACE_EVENT( "psi_store_ncell_param2: NC_CW list full" );
+return;
+}
+if( p_sub_1->n_r_cells NEQ 0 )
+{
+y = p_sub_1->c_ncell_par2_s2;
+for( x = 0; x < y; x++ )
+{
+p_sub_2 = &p_sub_1->ncell_par2_s2[x];
+if( psi_store_cs_param2
+( &psc_db->nc_cw.list,
+&psi3bis->ncell_par_trnc_grp.ncell_par2[i].ncell_par2_set[cell_params_ptr],
+psi3bis->psi3bis_ind,
+&number,
+&last_freq,
+p_sub_2->freq_diff_struct.freq_diff,
+p_sub_2->same_ra_scell,
+p_sub_2->cell_ba,
+p_sub_2->bcc ) EQ FALSE )
+{
+TRACE_EVENT( "psi_store_ncell_param2: NC_CW list full" );
+return;
+}
+}
+}
+}
+}
+}
+} /* psi_store_ncell_param2 */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_store_cs_param2
++------------------------------------------------------------------------------
+| Description :
+| Parameters  :
++------------------------------------------------------------------------------
+*/
+LOCAL BOOL psi_store_cs_param2 ( T_NC_LIST        *nc_list,
+T_ncell_par2_set *cs_par2,
+UBYTE             instance,
+UBYTE            *number,
+USHORT           *freq,
+USHORT            freq_diff,
+UBYTE             same_ra_scell,
+UBYTE             cell_ba,
+UBYTE             bcc )
+{
+T_INFO_SRC    info_src = 0;
+T_ncell_info *ncell_info;
+TRACE_FUNCTION( "psi_store_cs_param2" );
+NC_SET_TYPE    ( info_src, INFO_TYPE_PSI3BIS );
+NC_SET_INSTANCE( info_src, instance          );
+NC_SET_NUMBER  ( info_src, *number           );
+ncell_info = grr_get_next_ncell_param( MAX_NR_OF_NCELL,
+nc_list,
+info_src );
+if( ncell_info EQ NULL )
+{
+return( FALSE );
+}
+number++;
+nc_list->number++;
+*freq = ( *freq + freq_diff ) % 1024;
+ncell_info->info_src = info_src;
+ncell_info->arfcn    = *freq;
+if( cs_par2->v_ncc )
+{
+ncell_info->bsic = bcc | ( cs_par2->ncc << 3 );
+}
+else
+{
+ncell_info->bsic = bcc | ( psc_db->pbcch.bcch.bsic & BSIC_NCC_MASK );
+}
+ncell_info->v_cr_par             = TRUE;
+ncell_info->cr_par.same_ra_scell = same_ra_scell;
+ncell_info->cr_par.exc_acc       = cs_par2->exc_acc;
+ncell_info->cr_par.cell_ba       = cell_ba;
+#if !defined (NTRACE)
+if( grr_data->cs.v_crp_trace EQ TRUE )
+{
+TRACE_EVENT_P2( "psi_store_cs_param2: cell barred status %d %d",
+ncell_info->arfcn, ncell_info->cr_par.cell_ba );
+}
+#endif /* #if !defined (NTRACE) */
+SET_GPRS_RXLEV_ACCESS_MIN
+( ncell_info->cr_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min,
+cs_par2->v_gprs_rxlev_access_min, cs_par2->gprs_rxlev_access_min );
+SET_GPRS_MS_TXPWR_MAX_CCH
+( ncell_info->cr_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch,
+cs_par2->v_txpwr_max_cch, cs_par2->txpwr_max_cch );
+SET_GPRS_TEMP_OFFSET
+( ncell_info->cr_par.cr_offset.gprs_temp_offset,
+TRUE, cs_par2->gprs_temp_offset );
+SET_GPRS_PENALTY_TIME
+( ncell_info->cr_par.cr_offset.gprs_penalty_time,
+TRUE, cs_par2->gprs_penalty_time );
+SET_GPRS_RESEL_OFF
+( ncell_info->cr_par.gprs_resel_off,
+TRUE, cs_par2->gprs_resel_off );
+ncell_info->cr_par.cr_par_1.v_hcs_par =
+( cs_par2->v_gprs_hcs_thr AND cs_par2->v_gprs_prio_class );
+SET_GPRS_HCS_THR
+( ncell_info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr,
+cs_par2->v_gprs_hcs_thr, cs_par2->gprs_hcs_thr );
+SET_GPRS_PRIO_CLASS
+( ncell_info->cr_par.cr_par_1.hcs_par.gprs_prio_class,
+cs_par2->v_gprs_prio_class, cs_par2->gprs_prio_class );
+grr_store_si13_pbcch_location( &ncell_info->cr_par,
+cs_par2->v_si13_pbcch,
+&cs_par2->si13_pbcch );
+return( TRUE );
+}/* psi_store_cs_param2 */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_restore_ncell_param
++------------------------------------------------------------------------------
+| Description :
+| Parameters  :
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_restore_ncell_param ( void )
+{
+UBYTE         idx_curr   = 0;
+T_ncell_info *info_prev  = NULL;
+T_ncell_info *info_curr;
+T_INFO_SRC    info_src   = 0;
+TRACE_FUNCTION( "psi_restore_ncell_param" );
+/* update change mark value */
+psc_db->nc_cw.list.chng_mrk.curr++;
+while( ( info_curr = grr_get_next_bigger_ncell_param
+( &psc_db->nc_cw.list, info_src ) ) NEQ NULL )
+{
+grr_restore_cs_param( info_curr, info_prev, idx_curr );
+info_src  = info_curr->info_src;
+info_prev = info_curr;
+idx_curr++;
+}
+}/* psi_restore_ncell_param */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_prepare_scell_pbcch_req
++------------------------------------------------------------------------------
+| Description : The function psi_prepare_scell_pbcch_req() prepares the mphp_
+|               scell_pbcch_req
+|
+| Parameters  : T_MPHP_SCELL_PBCCH_REQ *mphp_scell_pbcch_req
+|                                        UBYTE  psi_reading_type
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_prepare_scell_pbcch_req(T_MPHP_SCELL_PBCCH_REQ *mphp_scell_pbcch_req,
+UBYTE  psi_reading_type)
+{
+#ifndef _TARGET_
+UBYTE i, j;
+#endif /* #ifndef _TARGET_ */
+UBYTE hr, lr, *psi_nr;
+UBYTE *pos_array;
+TRACE_FUNCTION( "psi_prepare_scell_pbcch_req" );
+memcpy(mphp_scell_pbcch_req,&psc_db->scell_pbcch,sizeof(T_MPHP_SCELL_PBCCH_REQ));
+psi_nr = &mphp_scell_pbcch_req->psi_nr;
+pos_array = mphp_scell_pbcch_req->relative_pos_array;
+*psi_nr = 0;
+memset(pos_array, 0, MAX_RELATIVE_POS);
+hr = psc_db->psi1_params.psi_cnt_hr;
+lr = psc_db->psi1_params.psi_cnt_lr;
+TRACE_EVENT_P1("psi_reading_type:%d", psi_reading_type);
+switch(psi_reading_type)
+{
+case READ_COMPLETE:
+/* attempt to receive messages shall be made each time
+* the message is scheduled on the broadcast channel.
+*/
+mphp_scell_pbcch_req->psi_nr = 0;/*read all PSI in all PBCCH*/
+/*
+* mphp_scell_pbcch_req->relative_pos_array has no meaning,
+* if we want to receive all PSI
+*/
+psi_reset_psi_pos();
+break;
+case READ_PSI1_IN_PSI1_REPEAT_PERIODS:
+/* attempt to receive PSI1 each time
+* the message is scheduled on the broadcast channel
+* with psi1_repeat_periods (only once in a multiframe, e.g. in PBCCH->B0)
+*/
+/* mphp_scell_pbcch_req->relative_pos_array will contain only one element,
+* because of mphp_scell_pbcch_req.psi_nr = 1
+*/
+mphp_scell_pbcch_req->psi_nr = 1;
+/*Read PSI1 only in BO in psi1 repeat period
+*/
+mphp_scell_pbcch_req->relative_pos_array[0] = 0;
+break;
+case PSI_IN_HR: /* PSI in high repetition rate*/
+if(!hr) /* no HR */
+{
+TRACE_ERROR("no HR, read all");
+mphp_scell_pbcch_req->psi_nr = 0;/*read all PSI in all PBCCH*/
+}
+else
+{
+#ifdef _TARGET_
+mphp_scell_pbcch_req->psi_nr = 0;
+#else
+mphp_scell_pbcch_req->psi_nr = 0;
+i = (mphp_scell_pbcch_req->bs_pbcch_blks > 0) ? 1 : 0;
+while(hr > 0)
+{
+mphp_scell_pbcch_req->relative_pos_array[mphp_scell_pbcch_req->psi_nr] = i + hr;
+if(mphp_scell_pbcch_req->psi_nr EQ 19)
+break;/* break condition*/
+mphp_scell_pbcch_req->psi_nr++;
+hr--;
+}
+#endif
+}
+break;
+case PSI_IN_LR:  /* PSI in low repetition rate */
+if(!lr) /* no LR */
+{
+TRACE_ERROR("no LR, read all");
+mphp_scell_pbcch_req->psi_nr = 0;/*read all PSI in all PBCCH*/
+}
+else
+{
+#ifdef _TARGET_
+mphp_scell_pbcch_req->psi_nr = 0;
+#else
+mphp_scell_pbcch_req->psi_nr = 0;
+i = (mphp_scell_pbcch_req->bs_pbcch_blks > 0) ? 1 : 0;
+while(lr > 0)
+{
+mphp_scell_pbcch_req->relative_pos_array[mphp_scell_pbcch_req->psi_nr] = i + hr + lr;
+if(mphp_scell_pbcch_req->psi_nr EQ 19)
+break;/* break condition*/
+mphp_scell_pbcch_req->psi_nr++;
+lr--;
+}
+#endif
+}
+break;
+case PSI_IN_HR_AND_LR:   /* PSI in high and low repetition rate*/
+if(!(lr + hr)) /* no LR+HR */
+{
+TRACE_ERROR("no HR+LR, read all");
+mphp_scell_pbcch_req->psi_nr = 0;/*read all PSI in all PBCCH*/
+}
+else
+{
+#ifdef _TARGET_
+mphp_scell_pbcch_req->psi_nr = 0;
+#else
+mphp_scell_pbcch_req->psi_nr = 0;
+i = (mphp_scell_pbcch_req->bs_pbcch_blks > 0) ? 2 : 1;
+for(j=0; j<(lr + hr);j++)
+{
+mphp_scell_pbcch_req->relative_pos_array[mphp_scell_pbcch_req->psi_nr] = i + j;
+if(mphp_scell_pbcch_req->psi_nr EQ 19)
+break;/* break condition*/
+mphp_scell_pbcch_req->psi_nr++;
+}
+#endif
+}
+break;
+case   READ_PSI1_AND_IN_HR:
+/* PSI in high repetition rate and PSI1*/
+#ifdef _TARGET_
+mphp_scell_pbcch_req->psi_nr = 0;
+#else
+mphp_scell_pbcch_req->psi_nr = 0;
+mphp_scell_pbcch_req->relative_pos_array[mphp_scell_pbcch_req->psi_nr++] = 0;
+i = (mphp_scell_pbcch_req->bs_pbcch_blks > 0) ? 1 : 0;
+if(i EQ 1)
+{
+mphp_scell_pbcch_req->relative_pos_array[mphp_scell_pbcch_req->psi_nr++] = 1;
+}
+while(hr > 0)
+{
+mphp_scell_pbcch_req->relative_pos_array[mphp_scell_pbcch_req->psi_nr] = i + hr;
+if(mphp_scell_pbcch_req->psi_nr EQ 19)
+break;/* break condition*/
+mphp_scell_pbcch_req->psi_nr++;
+hr--;
+}
+#endif
+break;
+case   READ_PSI1_AND_IN_LR:/* PSI in low repetition rate and PSI1*/
+#ifdef _TARGET_
+mphp_scell_pbcch_req->psi_nr = 0;
+#else
+mphp_scell_pbcch_req->psi_nr = 0;
+mphp_scell_pbcch_req->relative_pos_array[mphp_scell_pbcch_req->psi_nr++] = 0;
+i = (mphp_scell_pbcch_req->bs_pbcch_blks > 0) ? 1 : 0;
+if(i EQ 1)
+{
+mphp_scell_pbcch_req->relative_pos_array[mphp_scell_pbcch_req->psi_nr++] = 1;
+}
+while(lr > 0)
+{
+mphp_scell_pbcch_req->relative_pos_array[mphp_scell_pbcch_req->psi_nr] = i + hr + lr;
+if(mphp_scell_pbcch_req->psi_nr EQ 19)
+break;/* break condition*/
+mphp_scell_pbcch_req->psi_nr++;
+lr--;
+}
+#endif
+break;
+case  READ_PSI2:
+#ifdef _TARGET_
+mphp_scell_pbcch_req->psi_nr = 0;
+#else
+psi_fill_rel_pos(grr_data->psi.psi2_pos, MAX_NR_OF_INSTANCES_OF_PSI2, psi_nr, pos_array);
+#endif
+break;
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+case  READ_PSI3TER:
+case  READ_PSI3_3BIS_3TER:
+#endif
+case  READ_PSI3_3BIS:
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+case  READ_PSI3BIS:
+#endif
+#ifdef _TARGET_
+mphp_scell_pbcch_req->psi_nr = 0;
+#else
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+psi_fill_rel_pos(grr_data->psi.psi3_set_pos,
+MAX_NR_OF_INSTANCES_OF_PSI3TER + MAX_NR_OF_INSTANCES_OF_PSI3 +
+MAX_NR_OF_INSTANCES_OF_PSI3BIS, psi_nr, pos_array);
+#else
+psi_fill_rel_pos(grr_data->psi.psi3bis_pos,
+MAX_NR_OF_INSTANCES_OF_PSI3 + MAX_NR_OF_INSTANCES_OF_PSI3BIS,
+psi_nr, pos_array);
+#endif /* #ifdef REL99 AND TI_PS_FF_EMR */
+#endif /* ifdef _TARGET_ */
+break;
+case  READ_PSI4:
+#ifdef _TARGET_
+mphp_scell_pbcch_req->psi_nr = 0;
+#else
+psi_fill_rel_pos(grr_data->psi.psi4_pos, MAX_NR_OF_INSTANCES_OF_PSI4, psi_nr, pos_array);
+#endif
+break;
+case  READ_PSI5:
+#ifdef _TARGET_
+mphp_scell_pbcch_req->psi_nr = 0;
+#else
+psi_fill_rel_pos(grr_data->psi.psi5_pos, MAX_NR_OF_INSTANCES_OF_PSI5, psi_nr, pos_array);
+#endif
+break;
+#ifdef REL99
+case  READ_PSI8:
+#ifdef _TARGET_
+mphp_scell_pbcch_req->psi_nr = 0;
+#else
+psi_fill_rel_pos(grr_data->psi.psi8_pos, MAX_NR_OF_INSTANCES_OF_PSI8, psi_nr, pos_array);
+#endif
+break;
+#endif
+default:
+TRACE_ERROR ("default in psi_prepare_scell_pbcch_req");
+break;
+}
+TRACE_EVENT_P7("psi_nr:%d blks:%d pb:%d per:%d pos[0]:%d pos[1]:%d pos[2]:%d",
+mphp_scell_pbcch_req->psi_nr,
+mphp_scell_pbcch_req->bs_pbcch_blks,
+mphp_scell_pbcch_req->pb,
+mphp_scell_pbcch_req->psi1_rep_period,
+mphp_scell_pbcch_req->relative_pos_array[0],
+mphp_scell_pbcch_req->relative_pos_array[1],
+mphp_scell_pbcch_req->relative_pos_array[2]);
+TRACE_EVENT_P4("tn:%d tsc:%d hop:%d arfcn:%d",
+mphp_scell_pbcch_req->p_ch_des.tn,
+mphp_scell_pbcch_req->p_ch_des.tsc,
+mphp_scell_pbcch_req->p_ch_des.p_chan_sel.hopping,
+mphp_scell_pbcch_req->p_ch_des.p_chan_sel.p_rf_ch.arfcn);
+TRACE_EVENT_P5("f_cnt:%d f1:%d f2:%d f3:%d f4:%d",
+mphp_scell_pbcch_req->p_freq_list.p_rf_chan_cnt,
+mphp_scell_pbcch_req->p_freq_list.p_rf_chan_no.p_radio_freq[0],
+mphp_scell_pbcch_req->p_freq_list.p_rf_chan_no.p_radio_freq[1],
+mphp_scell_pbcch_req->p_freq_list.p_rf_chan_no.p_radio_freq[2],
+mphp_scell_pbcch_req->p_freq_list.p_rf_chan_no.p_radio_freq[3]);
+} /* psi_prepare_scell_pbcch_req */
+/*
++------------------------------------------------------------------------------
+| Function    : psi_store_rel_pos
++------------------------------------------------------------------------------
+| Description : The function psi_store_rel_pos () .stores the values relative
+|               position for each PSI message
+| Parameters  : dest: destination array; rel_pos: relative position; max_dest:
+|               MAX size OF dest array
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void psi_store_rel_pos(UBYTE *dest, UBYTE rel_pos, UBYTE max_dest)
+{
+UBYTE i;
+TRACE_FUNCTION("psi_store_rel_pos");
+for ( i = 0; i < max_dest; i++)
+{
+if(dest[i] EQ 0xFF)
+{
+dest[i] = rel_pos;
+break;
+}
+}
+}/*psi_store_rel_pos*/
+#ifndef _TARGET_
+/*
++------------------------------------------------------------------------------
+| Function    : psi_fill_rel_pos
++------------------------------------------------------------------------------
+| Description : The function psi_fill_rel_pos () .fills the relative position
+|               array and sets the psi_number
+| Parameters  : src: array containing rel positions; max_src: MAX size of src
+|               psi_nr: ptr to psi_number; pos_array: ptr to position_array
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_fill_rel_pos(UBYTE *src, UBYTE max_src, UBYTE *psi_nr, UBYTE *pos_array)
+{
+UBYTE i;
+TRACE_FUNCTION("psi_fill_rel_pos");
+for(i = 0; i<max_src; i++)
+{
+if(src[i] NEQ 0xff)
+{
+pos_array[(*psi_nr)] = src[i];
+(*psi_nr)++;
+}
+}
+}/*psi_fill_rel_pos*/
+#endif /*_TARGET_*/
+/*
++------------------------------------------------------------------------------
+| Function    : psi_reset_psi_pos
++------------------------------------------------------------------------------
+| Description : The function spsi_reset_psi_pos () ....
+|
+| Parameters  : -
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_reset_psi_pos  ( void )
+{
+TRACE_FUNCTION( "psi_reset_psi_pos " );
+memset(grr_data->psi.psi2_pos, 0xFF, MAX_NR_OF_INSTANCES_OF_PSI2);
+#if defined (REL99) AND defined (TI_PS_FF_EMR)
+memset(grr_data->psi.psi3_set_pos, 0xFF, MAX_NR_OF_INSTANCES_OF_PSI3TER
++MAX_NR_OF_INSTANCES_OF_PSI3BIS+MAX_NR_OF_INSTANCES_OF_PSI3);
+#else
+memset(grr_data->psi.psi3bis_pos, 0xFF, MAX_NR_OF_INSTANCES_OF_PSI3BIS+MAX_NR_OF_INSTANCES_OF_PSI3);
+#endif
+memset(grr_data->psi.psi4_pos, 0xFF, MAX_NR_OF_INSTANCES_OF_PSI4);
+memset(grr_data->psi.psi5_pos, 0xFF, MAX_NR_OF_INSTANCES_OF_PSI5);
+#ifdef REL99
+memset(grr_data->psi.psi8_pos, 0xFF, MAX_NR_OF_INSTANCES_OF_PSI8);
+#endif
+} /* psi_reset_psi_pos () */
+#ifdef REL99
+/*
++------------------------------------------------------------------------------
+| Function    : psi_update_bss_sgsn_rel
++------------------------------------------------------------------------------
+| Description : The function psi_update_bss_sgsn_rel () updates BSS and SGSN
+|               releases during the processing of SI13 message.
+|
+| Parameters  : SI13 message, status of PBCCH presence in the cell
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void psi_update_bss_sgsn_rel  ( T_D_SYS_INFO_13  *si13,
+BOOL              pbcch_status )
+{
+TRACE_FUNCTION( "psi_update_bss_sgsn_rel " );
+/* Update the BSS release */
+if (si13->si13_rest_oct.si13_info.v_sgsnr)
+{
+psc_db->network_rel = BSS_NW_REL_99;
+psc_db->sgsn_rel =
+si13->si13_rest_oct.si13_info.sgsnr ? PS_SGSN_99_ONWARDS : PS_SGSN_98_OLDER;
+}
+else
+{
+psc_db->network_rel = BSS_NW_REL_97;
+if(pbcch_status EQ PBCCH_NOT_PRESENT)
+{
+psc_db->sgsn_rel = PS_SGSN_98_OLDER;
+}
+else
+{
+psc_db->sgsn_rel = PS_SGSN_UNKNOWN;
+}
+}
+/* Update the SGSN release in the Common library context */
+cl_nwrl_set_sgsn_release(psc_db->sgsn_rel);
+} /* psi_update_bss_sgsn_rel () */
+#endif

FreeCalypso > hg > fc-magnetite

comparison src/g23m-gprs/grr/grr_psif.c @ 183:219afcfc6250