FreeCalypso > hg > fc-magnetite
view src/g23m-gprs/grr/grr_psif.c @ 694:005151e56328
Tango modem RI output implemented
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Tue, 20 Oct 2020 00:58:52 +0000 |
| parents | 219afcfc6250 |
| children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | 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