+
−/* 
+
−+----------------------------------------------------------------------------- 
+
−|  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
+
−