FreeCalypso > hg > fc-magnetite
diff src/g23m-gprs/grr/grr_psif.c @ 183:219afcfc6250
src/g23m-gprs: initial import from TCS3.2/LoCosto
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Thu, 13 Oct 2016 04:24:13 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/g23m-gprs/grr/grr_psif.c Thu Oct 13 04:24:13 2016 +0000 @@ -0,0 +1,5397 @@ +/* ++----------------------------------------------------------------------------- +| 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 +