FreeCalypso > hg > fc-magnetite
view src/g23m-gprs/grr/grr_measf.c @ 689:b1ece12237b2
scripts/config-luna-min.sh: development aid
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Wed, 14 Oct 2020 01:18:45 +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 MEAS of | entity GRR. +----------------------------------------------------------------------------- */ #ifndef GRR_MEASF_C #define GRR_MEASF_C #endif #define ENTITY_GRR /*==== INCLUDES =============================================================*/ #include <string.h> #include "typedefs.h" /* to get Condat data types */ #include "vsi.h" /* to get a lot of macros */ #include "macdef.h" #include "gprs.h" #include "gsm.h" /* to get a lot of macros */ #include "ccdapi.h" /* to get CCD API */ #include "cnf_grr.h" /* to get cnf-definitions */ #include "mon_grr.h" /* to get mon-definitions */ #include "prim.h" /* to get the definitions of used SAP and directions */ #include "message.h" #include "grr.h" /* to get the global entity definitions */ #include "grr_f.h" #include "grr_measf.h" /* to get the own definitions */ #include "grr_meass.h" /* to get the own definitions */ #include "grr_ctrls.h" /*==== CONST ================================================================*/ #define IDX_UBYTE_INVALID 0xFF /* invalid index */ #define IDX_USHORT_INVALID 0xFFFF /* invalid index */ #define TIME_INVALID 0x7FFFFFFF /* invalid time, should be the */ /* largest possible value for an */ /* variable of type LONG */ #define USE_ALL_TIMESLOTS 0xFF /* timeslot mask */ #define EM_EXT_RPT_TYPE_LEN 2 /* length of EXT reporting type bit field */ #define EM_ABS_I_LEVEL_LEN 6 /* length of absolute I_LEVEL bit field */ #define EM_NUM_OF_MEAS_LEN 5 /* length of number of measurement bit field */ #define EM_FREQ_N_LEN 6 /* length of FREQ_N bit field */ #define EM_BSIC_N_LEN 6 /* length of BSIC_N bit field */ #define EM_RXLEV_N_LEN 6 /* length of RXLEV_N bit field */ #ifdef _SIMULATION_ #define GET_EM_RPT_PRD(x) ((0x01<<(x))*10000) /* multiple of 10 sec., to get */ /* a reduced test duration */ #else /* #ifdef _SIMULATION_ */ #define GET_EM_RPT_PRD(x) ((0x01<<(x))*60000) /* multiple of 60 sec. */ #endif /* #ifdef _SIMULATION_ */ #define I_LEVEL_MIN I_LEVEL_0 #define I_LEVEL_0 0 /* i.lev. is greater than C */ #define I_LEVEL_15 15 /* i.lev. is less than or equal to C - 28 dB */ #define I_LEVEL_MAX I_LEVEL_15 #define I_LEVEL_GAMMA_0_SKIPPED 0xF0 /* used for tracing */ #define I_LEVEL_GAMMA_1_SKIPPED 0xF1 /* used for tracing */ #define I_LEVEL_GAMMA_2_SKIPPED 0xF2 /* used for tracing */ #define I_LEVEL_GAMMA_3_SKIPPED 0xF3 /* used for tracing */ #define I_LEVEL_STATE_MISMATCH 0xFD /* used for tracing */ #define I_LEVEL_IDX_TO_SMALL 0xFE /* used for tracing */ #define I_LEVEL_NOT_AVAIL 0xFF /* used for tracing */ #define NORM_NAVGI_FAC (ULONG)10 /* normalised Navg_i factor */ #ifdef _TARGET_ #define MIN_GAMMA_FOR_I_LEVEL_RPTING 4 /* minimum I-LEVEL value of neighbour */ /* cells that will be reported to the */ #else /* network, otherwise I-LEVEL values */ /* will be reported as not available */ #define MIN_GAMMA_FOR_I_LEVEL_RPTING 0 #endif /* #ifdef _TARGET_ */ #define MEAS_C_INC_INDEX(index) { \ if( index < (T_C_INDEX)(~0) ) index++; \ } /*==== LOCAL VARS ===========================================================*/ LOCAL T_MEAS_IM_DATA* imeas = NULL; /* pointer to interference measurement parameter */ LOCAL T_MEAS_EM_DATA* emeas = NULL; /* pointer to extended measurement parameter */ #if defined (REL99) AND defined (TI_PS_FF_EMR) LOCAL BOOL nc_freq_list_valid = FALSE; LOCAL BOOL nc_freq_list_pres = FALSE; GLOBAL BOOL use_ba_gprs = TRUE; #endif /* * normalised math.power value * * NORM_POW_MIN * ( 2 ** ( k / 2 ) ) */ GLOBAL const ULONG norm_pow[] = { NORM_POW_MIN, 1414, 2000, 2828, 4000, 5657, 8000, 11314, 16000, 22627, 32000, 45255, 64000, 90510, 128000, 181019, 256000, 362039, 512000, 724077, 1024000, 1448155, 2048000, 2896309, 4096000, 5792619 }; /*==== LOCAL TYPES===========================================================*/ LOCAL void meas_im_restart_all_filters ( void ); LOCAL void meas_im_restart_filter ( T_MEAS_IM_FILTER *filter ); LOCAL void meas_im_restart_gamma ( T_MEAS_IM_FILTER *filter, UBYTE index ); LOCAL T_MEAS_IM_FILTER* meas_im_get_unused_filter ( void ); LOCAL void meas_im_update_filter ( T_MEAS_IM_FILTER *filter, UBYTE *rxlev, UBYTE state ); LOCAL BOOL meas_im_freq_cmp_a ( USHORT arfcn1, USHORT arfcn2 ); LOCAL BOOL meas_im_freq_cmp_m ( T_MEAS_IM_CARRIER *ma1, T_MEAS_IM_CARRIER *ma2 ); LOCAL ULONG meas_im_get_val_trns ( void ); LOCAL ULONG meas_im_get_val_idle ( void ); LOCAL UBYTE meas_im_get_number_of_measured_channels ( void ); LOCAL T_MEAS_IM_FILTER* meas_im_get_oldest_filter ( void ); LOCAL BOOL meas_im_get_int_meas_freq ( UBYTE index, T_MEAS_IM_CARRIER *carrier, UBYTE *ts_mask ); LOCAL BOOL meas_im_get_trns_freq ( T_MEAS_IM_CARRIER *ma ); LOCAL BOOL meas_im_get_idle_freq ( ULONG id, T_MEAS_IM_CARRIER *carrier, UBYTE *ts_mask ); LOCAL void meas_im_timer_reorg ( T_TIME time_to_elapse, LONG time_diff ); LOCAL void meas_im_delete_em_rslt ( void ); LOCAL USHORT meas_im_get_unmsk_int_freq ( UBYTE index ); LOCAL void meas_im_start_t_im_sync ( T_TIME vld_prd ); LOCAL ULONG meas_im_get_paging_period ( void ); LOCAL void meas_im_set_freq_par ( T_p_frequency_par *freq_par, T_MEAS_IM_CARRIER *carrier ); LOCAL void meas_em_init_pmo_seq ( void ); LOCAL UBYTE meas_em_build_meas_rpt ( T_U_MEAS_REPORT *u_meas_report ); LOCAL UBYTE meas_em_extrct_strgst ( void ); LOCAL UBYTE meas_em_extrct_strgst_with_bsic ( void ); LOCAL void meas_em_req ( void ); LOCAL BOOL meas_em_is_meas_reporting ( void ); LOCAL void meas_em_start_t3178 ( T_TIME time ); LOCAL void meas_em_stop_t3178 ( void ); /*==== PRIVATE FUNCTIONS ====================================================*/ /* +------------------------------------------------------------------------------ | Function : meas_im_init +------------------------------------------------------------------------------ | Description : ... | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_im_init ( T_MEAS_IM_MODE im_mode ) { TRACE_FUNCTION( "meas_im_init" ); INIT_STATE( MEAS_IM, MEAS_IM_NULL ); imeas = &grr_data->meas_im; #if !defined (NTRACE) imeas->n_im_trace = 0; #endif /* #if !defined (NTRACE) */ imeas->mode = im_mode; imeas->carrier_id = IDX_USHORT_INVALID; imeas->trig_signal = IM_TRIG_SIGNAL_NULL; imeas->v_cs_meas_active = FALSE; meas_im_restart_all_filters( ); } /* meas_im_init() */ /* +------------------------------------------------------------------------------ | Function : meas_im_restart_all_filters +------------------------------------------------------------------------------ | Description : This function restarts all filters used in context of | interference measurements. | | Parameters : void | +------------------------------------------------------------------------------ */ LOCAL void meas_im_restart_all_filters ( void ) { UBYTE i; /* used for counting */ TRACE_FUNCTION( "meas_im_restart_all_filters" ); for( i = 0; i < MAX_IM_CHANNELS; i++ ) { meas_im_restart_filter( &imeas->filter[i] ); } } /* meas_im_restart_all_filters() */ /* +------------------------------------------------------------------------------ | Function : meas_im_restart_filter +------------------------------------------------------------------------------ | Description : This function restarts all filters for one carrier | used in context of interference measurements. | | Parameters : *filter - Ptr to filter | +------------------------------------------------------------------------------ */ LOCAL void meas_im_restart_filter ( T_MEAS_IM_FILTER* filter ) { UBYTE i; /* used for counting */ TRACE_FUNCTION( "meas_im_restart_filter" ); for( i = 0; i < CGRLC_MAX_TIMESLOTS; i++ ) { meas_im_restart_gamma( filter, i ); } } /* meas_im_restart_filter() */ /* +------------------------------------------------------------------------------ | Function : meas_im_restart_gamma +------------------------------------------------------------------------------ | Description : This function restarts an individual filter for | one channel used in context of interference measurements. | | Parameters : *filter - Ptr to filter | index - index of the interference level values | +------------------------------------------------------------------------------ */ LOCAL void meas_im_restart_gamma ( T_MEAS_IM_FILTER* filter, UBYTE index ) { T_MEAS_IM_GAMMA* gamma = &filter->i_level[index]; SET_FLAG( filter->used, IM_U_MASK << index, IM_U_UNUSED << index, UBYTE ); gamma->index = 0; gamma->m_gamma = IM_I_NONE; gamma->gamma = 0; gamma->remain_time = TIME_INVALID; } /* meas_im_restart_gamma() */ /* +------------------------------------------------------------------------------ | Function : meas_im_get_filter +------------------------------------------------------------------------------ | Description : This function is used to look for the filter that should be | updated. It searches for the filter with the same channel | description. | | Parameters : *ma - Ptr to frequency information in MA format | +------------------------------------------------------------------------------ */ GLOBAL T_MEAS_IM_FILTER* meas_im_get_filter ( T_MEAS_IM_CARRIER *ma ) { UBYTE i; /* used for counting */ T_MEAS_IM_FILTER *filter = NULL; /* found filter */ BOOL filter_found = FALSE; /* indicator */ TRACE_FUNCTION( "meas_im_get_filter" ); i = 0; while( i < MAX_IM_CHANNELS AND !filter_found ) { filter = &imeas->filter[i]; if( ma->hopping ) { if( ma NEQ NULL AND filter->used NEQ IM_U_UNUSED AND filter->carrier.hopping EQ TRUE AND meas_im_freq_cmp_m( ma, &filter->carrier )) { filter_found = TRUE; } } else { if( filter->used NEQ IM_U_UNUSED AND filter->carrier.hopping EQ FALSE AND meas_im_freq_cmp_a( ma->alloc.arfcn, filter->carrier.alloc.arfcn ) ) { filter_found = TRUE; } } i++; } return( filter_found ? filter : NULL ); } /* meas_im_get_filter() */ /* +------------------------------------------------------------------------------ | Function : meas_im_get_unused_filter +------------------------------------------------------------------------------ | Description : This function is used to look for the first unused filter. | | Parameters : void | +------------------------------------------------------------------------------ */ LOCAL T_MEAS_IM_FILTER* meas_im_get_unused_filter ( void ) { UBYTE i; /* used for counting */ T_MEAS_IM_FILTER *filter = NULL; /* found filter */ TRACE_FUNCTION( "meas_im_get_unused_filter" ); i = 0; while( i < MAX_IM_CHANNELS AND filter EQ NULL ) { if( imeas->filter[i].used EQ IM_U_UNUSED ) { filter = &imeas->filter[i]; } i++; } return( filter ); } /* meas_im_get_unused_filter() */ /* +------------------------------------------------------------------------------ | Function : meas_im_update_filter +------------------------------------------------------------------------------ | Description : This function is used to update an interference level filter. | | Parameters : *filter - Ptr to filter | *rxlev - Ptr to measurement values | mode - Packet idle or packet transfer mode | +------------------------------------------------------------------------------ */ LOCAL void meas_im_update_filter ( T_MEAS_IM_FILTER *filter, UBYTE *rxlev, UBYTE state ) { UBYTE i; /* used for counting */ BOOL valid_meas = FALSE; /* indicates if at least one valid */ /* measurement sample is present */ T_TIME time_to_elapse =0; /* this is the remaining time until */ /* timer T_IM_SYNC will elpase */ LONG remain_time = 0; /* this is the remaining time for an */ /* individual filter */ ULONG d; /* forgetting factor */ ULONG g_value; T_MEAS_IM_GAMMA *ilevel; /* inteference level */ ULONG validity; /* validity period of the measurement results */ BOOL v_t_im_sync = FALSE; /* indicates whether the timer T_IM_SYNC is */ /* running or not */ TRACE_FUNCTION( "meas_im_update_filter" ); /* calculate validity period of the measurements */ if( state EQ MEAS_IDLE ) { validity = meas_im_get_val_idle( ); } else { validity = meas_im_get_val_trns( ); } /* calculate remaining time */ time_to_elapse = grr_t_status( T_IM_SYNC ); if( time_to_elapse > 0 ) { remain_time = validity - time_to_elapse; v_t_im_sync = TRUE; } for( i = 0; i < CGRLC_MAX_TIMESLOTS; i++ ) { ilevel = &filter->i_level[i]; if( rxlev[i] NEQ CGRLC_RXLEV_NONE ) { SET_FLAG( filter->used, IM_U_MASK << i, IM_U_USED << i, UBYTE ); valid_meas = TRUE; ilevel->remain_time = remain_time; #ifdef _SIMULATION_ TRACE_EVENT_P1("REMAIN_TIME = %d", remain_time); #endif /* #ifdef (_SIMULATION_) */ /* counting the iteration index */ if( NORM_POW_MIN * ilevel->index < norm_pow[psc_db->g_pwr_par.n_avg_i] ) { ilevel->index++; } /* calculate the forgetting factor */ d = ( NORM_POW_MIN * NORM_POW_MIN * NORM_NAVGI_FAC ) / MINIMUM( NORM_POW_MIN * ilevel->index, norm_pow[psc_db->g_pwr_par.n_avg_i] ); /* update the filter */ g_value = ( ( NORM_POW_MIN * NORM_NAVGI_FAC ) - d ) * ilevel->gamma + d * MEAS_ACRCY * rxlev[i]; ilevel->gamma = (T_IM_GAMMA)(g_value / (NORM_POW_MIN * NORM_NAVGI_FAC)); #ifdef _SIMULATION_ TRACE_EVENT_P2("TS = %d, I-LEVEL = %d", i, ilevel->gamma); #endif /* #ifdef (_SIMULATION_) */ /* store the mode in which the measurement was performed */ if( state EQ MEAS_IDLE ) { SET_FLAG( ilevel->m_gamma, IM_I_MASK_IDL, IM_I_IDL, UBYTE ); SET_FLAG( ilevel->m_gamma, IM_I_MASK_TRNS, IM_I_NONE, UBYTE ); } else { SET_FLAG( ilevel->m_gamma, IM_I_MASK_TRNS, IM_I_TRNS, UBYTE ); SET_FLAG( ilevel->m_gamma, IM_I_MASK_IDL, IM_I_NONE, UBYTE ); } } } /* i */ /* * do some administrative stuff only in case there was at least * one valid sample reported by Layer 1 */ if( valid_meas ) { if( v_t_im_sync ) { if( remain_time < 0 ) { meas_im_timer_reorg( time_to_elapse, remain_time ); } } else { meas_im_start_t_im_sync( (ULONG)validity ); } } } /* meas_im_update_filter() */ /* +------------------------------------------------------------------------------ | Function : meas_im_freq_cmp_a +------------------------------------------------------------------------------ | Description : This function returns whether two frequencies are identical | or not. | | Parameters : arfcn1 - First frequency used for comparison | arfcn2 - Second frequency used for comparison | +------------------------------------------------------------------------------ */ LOCAL BOOL meas_im_freq_cmp_a ( USHORT arfcn1, USHORT arfcn2 ) { return( arfcn1 EQ arfcn2 ); } /* meas_im_freq_cmp_a() */ /* +------------------------------------------------------------------------------ | Function : meas_im_freq_cmp_m +------------------------------------------------------------------------------ | Description : This function returns whether two frequency information given | in mobile allocation format are identical or not. Channels | that only differ in MAIO are considered the same. | | Parameters : *ma1 - First channel description used for comparison | *ma2 - Second channel description used for comparison | +------------------------------------------------------------------------------ */ LOCAL BOOL meas_im_freq_cmp_m ( T_MEAS_IM_CARRIER *ma1, T_MEAS_IM_CARRIER *ma2 ) { return ( ma1->alloc.hop_param.hsn EQ ma2->alloc.hop_param.hsn AND memcmp( ma1->alloc.hop_param.arfcn_bit_field, ma2->alloc.hop_param.arfcn_bit_field, sizeof( ma1->alloc.hop_param.arfcn_bit_field ) ) EQ 0 ); } /* meas_im_freq_cmp_m() */ /* +------------------------------------------------------------------------------ | Function : meas_im_get_val_trns +------------------------------------------------------------------------------ | Description : This function returns the validity period of a measurement | performed in packet transfer mode (unit is milliseconds). | | Parameters : void | +------------------------------------------------------------------------------ */ LOCAL ULONG meas_im_get_val_trns ( void ) { ULONG n_avg_i_half = norm_pow[psc_db->g_pwr_par.n_avg_i] / 2; return(ULONG) ( ( n_avg_i_half * ( USEC_PER_MF / (ULONG)10 ) ) / ( NORM_POW_MIN * (ULONG)MEAS_ACRCY / (ULONG)10 ) ); } /* meas_im_get_val_trns() */ /* +------------------------------------------------------------------------------ | Function : meas_im_get_val_idle +------------------------------------------------------------------------------ | Description : This function returns the validity period of a measurement | performed in packet idle mode (unit is milliseconds). | | Parameters : void | +------------------------------------------------------------------------------ */ LOCAL ULONG meas_im_get_val_idle ( void ) { ULONG val_idle = TIME_INVALID - 1; ULONG paging_period = meas_im_get_paging_period( ); if( paging_period NEQ NO_PAGING ) { ULONG acrcy_n, acrcy_p; ULONG novimc_t_navgi = meas_im_get_number_of_measured_channels( ) * norm_pow[psc_db->g_pwr_par.n_avg_i]; if ( paging_period <= 650000 ) acrcy_p = 10; else if( paging_period <= 6500000 ) acrcy_p = 100; else acrcy_p = 1000; if ( novimc_t_navgi <= 130000 ) acrcy_n = 1; else if( novimc_t_navgi <= 1300000 ) acrcy_n = 10; else acrcy_n = 100; val_idle = (ULONG) ( ( MAXIMUM( ( novimc_t_navgi / ( (ULONG)4 * acrcy_n ) ) * ( USEC_PER_MF / acrcy_p ), ( novimc_t_navgi / ( (ULONG)2 * acrcy_n ) ) * ( paging_period / acrcy_p ) ) ) / ( NORM_POW_MIN * (ULONG)MEAS_ACRCY / ( acrcy_n * acrcy_p ) ) ); } return val_idle; } /* meas_im_get_val_idle() */ /* +------------------------------------------------------------------------------ | Function : meas_im_get_number_of_measured_channels +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL UBYTE meas_im_get_number_of_measured_channels ( void ) { UBYTE number = psc_db->number_of_valid_int_meas_channels; if( imeas->idle_chan.ident[CHN_ID_EM_BASE] NEQ CHN_ID_INVALID ) { number++; } if( imeas->idle_chan.ident[CHN_ID_PCCCH_BASE] NEQ CHN_ID_INVALID ) { number++; } return( number ); } /* meas_im_get_number_of_measured_channels() */ /* +------------------------------------------------------------------------------ | Function : meas_im_get_oldest_filter +------------------------------------------------------------------------------ | Description : This functions returns a filter that can be used for storing | measurement results | | Parameters : void | +------------------------------------------------------------------------------ */ LOCAL T_MEAS_IM_FILTER* meas_im_get_oldest_filter ( void ) { UBYTE i, j; /* used for counting */ LONG remain1 = TIME_INVALID; /* holds remaining time */ LONG remain2; /* holds remaining time */ BOOL all_invalid; /* indicates if all remaining times */ /* are invalid */ UBYTE filter_idx = IDX_UBYTE_INVALID; /* index of oldest filter */ T_MEAS_IM_GAMMA *ilevel; /* interference level */ TRACE_FUNCTION( "meas_im_get_oldest_filter" ); for( i = 0; i < MAX_IM_CHANNELS; i++ ) { remain2 = TIME_INVALID; all_invalid = TRUE; for( j = 0; j < CGRLC_MAX_TIMESLOTS; j++ ) { ilevel = &imeas->filter[i].i_level[j]; if( ilevel->remain_time NEQ TIME_INVALID ) { all_invalid = FALSE; if( remain2 EQ TIME_INVALID ) { remain2 = ilevel->remain_time; } else { remain2 = MINIMUM( ilevel->remain_time, remain2 ); } } } if( all_invalid ) { filter_idx = i; } else if( remain1 EQ TIME_INVALID OR remain1 < remain2 ) { remain1 = remain2; filter_idx = i; } } return( filter_idx EQ IDX_UBYTE_INVALID ? NULL : &imeas->filter[i] ); } /* meas_im_get_oldest_filter() */ /* +------------------------------------------------------------------------------ | Function : meas_im_get_int_meas_freq +------------------------------------------------------------------------------ | Description : ... | | Parameters : ... | +------------------------------------------------------------------------------ */ LOCAL BOOL meas_im_get_int_meas_freq ( UBYTE index, T_MEAS_IM_CARRIER *carrier, UBYTE *ts_mask ) { T_p_frequency_par freq_par; T_int_meas_chan_lst *lst = &psc_db->int_meas_chan_list[index]; BOOL valid = TRUE; TRACE_FUNCTION( "meas_im_get_int_meas_freq" ); if( lst->v_arfcn EQ TRUE ) { carrier->hopping = FALSE; carrier->alloc.arfcn = lst->arfcn; } else if( lst->v_ma_num_maio EQ TRUE ) { if( ( valid = grr_create_freq_list( lst->ma_num, lst->maio, &freq_par.p_chan_sel, &freq_par.p_freq_list ) ) EQ TRUE ) { meas_im_set_carrier( carrier, &freq_par ); } } else { valid = FALSE; } *ts_mask = lst->ts_alloc; return( valid ); } /* meas_im_get_int_meas_freq() */ /* +------------------------------------------------------------------------------ | Function : meas_im_get_trns_freq +------------------------------------------------------------------------------ | Description : ... | | Parameters : ... | +------------------------------------------------------------------------------ */ LOCAL BOOL meas_im_get_trns_freq ( T_MEAS_IM_CARRIER *ma ) { TRACE_FUNCTION( "meas_im_get_trns_freq" ); if( grr_data->tc.v_freq_set EQ TRUE ) { T_p_frequency_par freq_par; grr_set_freq_par( &freq_par ); meas_im_set_carrier( ma, &freq_par ); } return( grr_data->tc.v_freq_set ); } /* meas_im_get_trns_freq() */ /* +------------------------------------------------------------------------------ | Function : meas_im_get_idle_freq +------------------------------------------------------------------------------ | Description : ... | | Parameters : ... | +------------------------------------------------------------------------------ */ LOCAL BOOL meas_im_get_idle_freq ( ULONG id, T_MEAS_IM_CARRIER *carrier, UBYTE *ts_mask ) { BOOL valid_id = TRUE; T_MEAS_IM_IDLE_CHN* chn = &imeas->idle_chan; TRACE_FUNCTION( "meas_im_get_idle_freq" ); if( id >= MAX_IM_IDLE_CHANNELS OR chn->ident[id] EQ CHN_ID_INVALID ) { TRACE_ERROR( "ID invalid in meas_im_get_idle_freq" ); valid_id = FALSE; } else if( id EQ CHN_ID_EM_BASE ) { *ts_mask = USE_ALL_TIMESLOTS; /* SZML-MEAS/005 */ carrier->hopping = FALSE; carrier->alloc.arfcn = meas_im_get_unmsk_int_freq( chn->ident[id] ); } else if( id EQ CHN_ID_PCCCH_BASE ) { T_p_frequency_par freq_par; *ts_mask = ( 0x80 >> psc_db->paging_group.pccch[chn->ident[id]].tn ); grr_get_pccch_freq_par( chn->ident[id], &freq_par.p_chan_sel, &freq_par.p_freq_list ); meas_im_set_carrier( carrier, &freq_par ); } else { valid_id = meas_im_get_int_meas_freq( chn->ident[id], carrier, ts_mask ); } return( valid_id ); } /* meas_im_get_idle_freq() */ /* +------------------------------------------------------------------------------ | Function : meas_im_timer_reorg +------------------------------------------------------------------------------ | Description : ... | | Parameters : ... | +------------------------------------------------------------------------------ */ LOCAL void meas_im_timer_reorg ( T_TIME time_to_elapse, LONG time_diff ) { UBYTE i, j; /* used for counting */ TRACE_FUNCTION( "meas_im_timer_reorg" ); vsi_t_stop( GRR_handle, T_IM_SYNC ); for( i = 0; i < MAX_IM_CHANNELS; i++ ) { for( j = 0; j < CGRLC_MAX_TIMESLOTS; j++ ) { if( imeas->filter[i].i_level[j].remain_time NEQ TIME_INVALID ) { imeas->filter[i].i_level[j].remain_time -= time_diff; } } } meas_im_start_t_im_sync( ( LONG )time_to_elapse + time_diff ); } /* meas_im_timer_reorg() */ /* +------------------------------------------------------------------------------ | Function : meas_im_fill_rel_iLevel +------------------------------------------------------------------------------ | Description : ... | | Parameters : ... | +------------------------------------------------------------------------------ */ GLOBAL void meas_im_fill_rel_iLevel ( UBYTE *v_ilev, UBYTE *ilev, T_MEAS_IM_FILTER *filter, UBYTE idx ) { UBYTE val; /* holds interference level data */ *v_ilev = FALSE; if( filter NEQ NULL ) { #ifdef _TARGET_ UBYTE state = GET_STATE( MEAS ); if( ( state EQ MEAS_IDLE AND IS_FLAGGED( filter->i_level[idx].m_gamma, IM_I_MASK_IDL, IM_I_IDL ) ) OR ( state EQ MEAS_TRANSFER AND IS_FLAGGED( filter->i_level[idx].m_gamma, IM_I_MASK_TRNS, IM_I_TRNS ) ) ) #endif /* #ifdef _TARGET_ */ { if( NORM_POW_MIN * filter->i_level[idx].index >= norm_pow[psc_db->g_pwr_par.n_avg_i] ) { if( filter->i_level[idx].gamma >= ( MIN_GAMMA_FOR_I_LEVEL_RPTING * MEAS_ACRCY ) ) /*lint !e685*/ { T_C_FILTER *c_filter = &grr_data->meas.c_filter; USHORT c_value; if( c_filter->index > 0 ) { c_value = c_filter->value; } else { c_value = C_VALUE_DEFAULT; } /* calculation of interference level */ if( c_value < filter->i_level[idx].gamma ) { *ilev = I_LEVEL_MIN; } else { val = ( c_value - filter->i_level[idx].gamma ) / ( 2 * MEAS_ACRCY ) + 1; if( val > I_LEVEL_MAX ) *ilev = I_LEVEL_MAX; else *ilev = val; } *v_ilev = TRUE; } #if !defined (NTRACE) else { /* prepare proper tracing information */ switch( filter->i_level[idx].gamma / MEAS_ACRCY ) { case 0: *ilev = I_LEVEL_GAMMA_0_SKIPPED; break; case 1: *ilev = I_LEVEL_GAMMA_1_SKIPPED; break; case 2: *ilev = I_LEVEL_GAMMA_2_SKIPPED; break; case 3: *ilev = I_LEVEL_GAMMA_3_SKIPPED; break; default: TRACE_ERROR( "meas_im_fill_rel_iLevel: impossible case" ); break; } } #endif /* #if !defined (NTRACE) */ } #if !defined (NTRACE) else { /* prepare proper tracing information */ *ilev = I_LEVEL_IDX_TO_SMALL; } #endif /* #if !defined (NTRACE) */ } #ifdef _TARGET_ #if !defined (NTRACE) else { /* prepare proper tracing information */ *ilev = I_LEVEL_STATE_MISMATCH; } #endif /* #if !defined (NTRACE) */ #endif /* #ifdef _TARGET_ */ } #if !defined (NTRACE) else { /* prepare proper tracing information */ *ilev = I_LEVEL_NOT_AVAIL; } #endif /* #if !defined (NTRACE) */ } /* meas_im_fill_rel_iLevel() */ /* +------------------------------------------------------------------------------ | Function : meas_im_fill_abs_iLevel +------------------------------------------------------------------------------ | Description : ... | | Parameters : ... | +------------------------------------------------------------------------------ */ GLOBAL UBYTE meas_im_fill_abs_iLevel ( UBYTE *v_ilev, UBYTE *ilev, T_MEAS_IM_FILTER *filter, UBYTE idx ) { UBYTE used_bits = PMR_FLAG_LEN; *v_ilev = FALSE; if( filter NEQ NULL ) { #ifdef _TARGET_ UBYTE state = GET_STATE( MEAS ); if( ( state EQ MEAS_IDLE AND IS_FLAGGED( filter->i_level[idx].m_gamma, IM_I_MASK_IDL, IM_I_IDL ) ) OR ( state EQ MEAS_TRANSFER AND IS_FLAGGED( filter->i_level[idx].m_gamma, IM_I_MASK_TRNS, IM_I_TRNS ) ) ) #endif /* #ifdef _TARGET_ */ { if( NORM_POW_MIN * filter->i_level[idx].index >= norm_pow[psc_db->g_pwr_par.n_avg_i] ) { if( filter->i_level[idx].gamma >= ( MIN_GAMMA_FOR_I_LEVEL_RPTING * MEAS_ACRCY ) ) /*lint !e685*/ { /* calculation of interference level */ used_bits += EM_ABS_I_LEVEL_LEN; *ilev = (UBYTE)M_ROUND_UP( filter->i_level[idx].gamma, MEAS_ACRCY ); *v_ilev = TRUE; } #if !defined (NTRACE) else { /* prepare proper tracing information */ switch( filter->i_level[idx].gamma / MEAS_ACRCY ) { case 0: *ilev = I_LEVEL_GAMMA_0_SKIPPED; break; case 1: *ilev = I_LEVEL_GAMMA_1_SKIPPED; break; case 2: *ilev = I_LEVEL_GAMMA_2_SKIPPED; break; case 3: *ilev = I_LEVEL_GAMMA_3_SKIPPED; break; default: TRACE_ERROR( "meas_im_fill_rel_iLevel: impossible case" ); break; } } #endif /* #if !defined (NTRACE) */ } #if !defined (NTRACE) else { /* prepare proper tracing information */ *ilev = I_LEVEL_IDX_TO_SMALL; } #endif /* #if !defined (NTRACE) */ } #ifdef _TARGET_ #if !defined (NTRACE) else { /* prepare proper tracing information */ *ilev = I_LEVEL_STATE_MISMATCH; } #endif /* #if !defined (NTRACE) */ #endif /* #ifdef _TARGET_ */ } #if !defined (NTRACE) else { /* prepare proper tracing information */ *ilev = I_LEVEL_NOT_AVAIL; } #endif /* #if !defined (NTRACE) */ return( used_bits ); } /* meas_im_fill_abs_iLevel() */ /* +------------------------------------------------------------------------------ | Function : meas_im_delete_em_rslt +------------------------------------------------------------------------------ | Description : ... | | Parameters : ... | +------------------------------------------------------------------------------ */ LOCAL void meas_im_delete_em_rslt ( void ) { T_MEAS_IM_FILTER *filter; TRACE_FUNCTION( "meas_im_delete_em_rslt" ); if( emeas->xmeas_set.param->em1.param.int_frequency NEQ NOT_SET ) { T_MEAS_IM_CARRIER ma; ma.hopping = FALSE; ma.alloc.arfcn = meas_im_get_unmsk_int_freq( emeas->xmeas_set.param->em1.param.int_frequency ); filter = meas_im_get_filter( &ma ); if( filter NEQ NULL ) { meas_im_restart_filter ( filter ); } } } /* meas_im_delete_em_rslt() */ /* +------------------------------------------------------------------------------ | Function : meas_im_get_unmsk_int_freq +------------------------------------------------------------------------------ | Description : ... | | Parameters : ... | +------------------------------------------------------------------------------ */ LOCAL USHORT meas_im_get_unmsk_int_freq ( UBYTE index ) { USHORT arfcn; TRACE_FUNCTION( "meas_im_get_unmsk_int_freq" ); arfcn = emeas->xmeas_set.param->em1.list.freq[index]; SET_FLAG( arfcn, EM_VLDTY_ARFCN_MASK, EM_VLD_ARFCN, USHORT ); return( arfcn ); } /* meas_im_get_unmsk_int_freq() */ /* +------------------------------------------------------------------------------ | Function : meas_im_start_t_im_sync +------------------------------------------------------------------------------ | Description : ... | | Parameters : ... | +------------------------------------------------------------------------------ */ LOCAL void meas_im_start_t_im_sync ( T_TIME vld_prd ) { TRACE_FUNCTION( "meas_im_start_t_im_sync" ); if( vld_prd NEQ 0 ) { vsi_t_start( GRR_handle, T_IM_SYNC, vld_prd ); #ifdef _SIMULATION_ TRACE_EVENT_P1( "T_IM_SYNC: %d ms", vld_prd ); #endif /* #ifdef _SIMULATION_ */ } else { TRACE_ERROR( "Try to start T_IM_SYNC with 0 ms" ); } } /* meas_im_start_t_im_sync() */ /* +------------------------------------------------------------------------------ | Function : meas_im_get_paging_period +------------------------------------------------------------------------------ | Description : This functon calculates the paging period in microseconds. | | Please look at GSM 05.02, chapter 6.5.6, Determination of | PCCCH_GROUP and PAGING_GROUP for MS in GPRS attached mode. | | Parameters : void | +------------------------------------------------------------------------------ */ LOCAL ULONG meas_im_get_paging_period ( void ) { ULONG paging_period = NO_PAGING; /* paging period in MICROSECONDS */ USHORT paging_distance; /* paging period as difference of two paging */ /* groups */ USHORT paging_group[BL_FOR_PAGE_PERIOD_CALC]; /* blocks which are used to page the MS, in */ /* maximum 2 blocks are needed to calculate */ /* the paging period */ USHORT M; /* number of paging blocks "available" on */ /* one PCCCH */ USHORT m; /* number of paging groups for this MS */ USHORT min; /* minimum of M and SPLIT_PG_CYCLE */ USHORT imsi_mod = grr_imsi_mod( ); /* IMSI modulo 1000 */ USHORT N = 1; /* N */ USHORT res_blocks = psc_db->pccch.bs_pag_blks + psc_db->pccch.bs_pbcch_blks + 1; /* number of reserved blocks for access */ /* grant and PBCCH */ TRACE_FUNCTION( "meas_im_get_paging_period" ); /* see GSM 05.02, Clause 7 Table 7 of 7: Mapping of logical channels onto */ /* physical channels ( see subclause 6.3, 6.4, 6.5 ) */ M = ( res_blocks > ( BLOCK_PER_MF - 1 ) ? 0 : ( BLOCK_PER_MF - res_blocks ) * PAGING_CYCLE ); /* in case M is equal to zero no paging blocks are reserved */ if( M NEQ 0 ) { if( grr_data->ms.split_pg_cycle EQ GMMRR_NO_DRX ) { /* in non-DRX mode the MS shall listen to all M blocks per */ /* multiframe where paging may appear on a PCCCH channel */ /* we assume that all paging groups have the same distance */ /* to its preceding and subsequent paging groups ( equi- */ /* distance) */ paging_period = ( PAGING_CYCLE * USEC_PER_MF ) / M; } else { min = MINIMUM( M, grr_data->ms.split_pg_cycle ); if( min EQ 1 ) { /* in case only one paging group is available the MS is */ /* paged every PAGING_CYCLE multiframes */ paging_period = PAGING_CYCLE * USEC_PER_MF; } else { /* calculate two paging groups, this is the minimum which */ /* is needed to calculate a time difference ( paging */ /* period ), we assume that all paging groups have the */ /* same distance to its preceding and subsequent paging */ /* groups ( equi-distance ) */ for( m = 0; m < BL_FOR_PAGE_PERIOD_CALC; m++ ) { /* the following statement calculates the paging groups */ paging_group[m] = ( ( ( imsi_mod / ( psc_db->paging_group.kc * N ) ) * N ) + ( imsi_mod % N ) + MAXIMUM( ( m * M ) / grr_data->ms.split_pg_cycle, m ) ) % M; } /* the paging is repeated cyclic every PAGING_CYCLE multiframes, */ /* this should be taken into account when calculating the time */ /* difference between two paging groups */ if( paging_group[1] > paging_group[0] ) { paging_distance = paging_group[1] - paging_group[0]; } else { paging_distance = M - paging_group[0] + paging_group[1]; } paging_period = ( paging_distance * PAGING_CYCLE * USEC_PER_MF ) / M; } } } return( paging_period ); } /* meas_im_get_paging_period() */ /* +------------------------------------------------------------------------------ | Function : meas_em_init +------------------------------------------------------------------------------ | Description : ... | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_em_init ( void ) { TRACE_FUNCTION( "meas_em_init" ); INIT_STATE( MEAS_EM, MEAS_EM_NULL ); emeas = &grr_data->meas_em; emeas->xmeas_set.ident = 0; emeas->xmeas_set.param = NULL; emeas->pmr_snd_ref = 0; grr_init_xmeas_struct( &psc_db->ext_pmo ); meas_em_init_pmo_seq( ); } /* meas_em_init() */ /* +------------------------------------------------------------------------------ | Function : meas_em_init_pmo_seq +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : void | +------------------------------------------------------------------------------ */ LOCAL void meas_em_init_pmo_seq ( void ) { UBYTE i; TRACE_FUNCTION( "meas_em_init_pmo_seq" ); grr_init_xmeas_struct( &emeas->pmo.extd ); grr_init_ncmeas_extd_struct( &emeas->pmo.nc, FALSE ); #if defined (REL99) AND defined (TI_PS_FF_EMR) grr_init_enh_param(&emeas->pmo.enh, TRUE); #endif for( i = 0; i < MAX_NR_OF_INSTANCES_OF_PMO; i++ ) { emeas->pmo.prm.instances[i] = FALSE; emeas->pmo.prm.idx[i].start = RRGRR_INVALID_IDX; emeas->pmo.prm.idx[i].stop = RRGRR_INVALID_IDX; } emeas->pmo.prm.count = NOT_SET; } /* meas_em_init_pmo_seq() */ /* +------------------------------------------------------------------------------ | Function : meas_em_build_meas_rpt +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : u_meas_report - Pointer to measurement report | +------------------------------------------------------------------------------ */ LOCAL UBYTE meas_em_build_meas_rpt ( T_U_MEAS_REPORT *u_meas_report ) { UBYTE used_bits; /* bits currently used for the measurement report */ UBYTE next_meas_bits; /* bits used for the next element of the */ /* measurement result list */ UBYTE strg_bsic; UBYTE strg_rxlev; UBYTE rslt_rxlev; T_ext_mp_s1 *p_mrpt; #if defined (REL99) AND defined (TI_PS_FF_EMR) UBYTE psi3_cm = grr_get_psi3_cm(); BOOL pbcch_present = grr_is_pbcch_present( ); #endif T_xmeas_rep *xmeas_rep = &u_meas_report->xmeas_rep; TRACE_FUNCTION( "meas_em_build_meas_rpt" ); /* process message type */ used_bits = PMR_MSG_TYPE_LEN; u_meas_report->msg_type = U_MEAS_REPORT_c; /* process TLLI */ used_bits += PMR_TLLI_LEN; grr_set_buf_tlli( &u_meas_report->tlli_value, grr_get_tlli( ) ); /* process PSI5 change mark */ used_bits += PMR_FLAG_LEN; if( emeas->xmeas_set.param EQ &psc_db->ext_psi5 ) { used_bits += PMR_PSI5_CHNGE_MRK_LEN; u_meas_report->v_psi5_cm = TRUE; u_meas_report->psi5_cm = psc_db->psi5_params.psi5_change_mark; } else if ( emeas->xmeas_set.param EQ &psc_db->ext_pmo ) { u_meas_report->v_psi5_cm = FALSE; } else { TRACE_ERROR( "no valid data set in meas_em_build_meas_rpt" ); return( 0 ); } /* process flags */ used_bits += PMR_FLAG_LEN; u_meas_report->flag = 1; u_meas_report->v_nc_meas_rep = FALSE; u_meas_report->v_xmeas_rep = TRUE; #if defined (REL99) AND defined (TI_PS_FF_EMR) /*if(psc_db->network_rel NEQ BSS_NW_REL_97)*/ { used_bits += PMR_FLAG_LEN; u_meas_report->v_release_99_str_pmr = TRUE; used_bits += PMR_FLAG_LEN; u_meas_report->release_99_str_pmr.v_meas_rep_3g_str = FALSE; used_bits += PMR_FLAG_LEN; u_meas_report->release_99_str_pmr.v_ba_psi3_str = TRUE; used_bits += PMO_IND_USED_LEN; u_meas_report->release_99_str_pmr.ba_psi3_str.pmo_ind_used = psc_db->nc_ms.pmo_ind; /* 1 bit for u_meas_report->ba_psi3_str.flag */ used_bits += PMR_FLAG_LEN; /* process BA used, PSI3 change mark and PMO used */ if( pbcch_present EQ FALSE ) { u_meas_report->release_99_str_pmr.ba_psi3_str.flag = FALSE; u_meas_report->release_99_str_pmr.ba_psi3_str.v_ba_ind_used = TRUE; u_meas_report->release_99_str_pmr.ba_psi3_str.v_ba_ind_used_3g = TRUE; used_bits += PMR_BA_IND_USED_LEN; u_meas_report->release_99_str_pmr.ba_psi3_str.ba_ind_used = psc_db->ba_ind; /* Add 1 bit for ba_ind_used_3g */ u_meas_report->release_99_str_pmr.ba_psi3_str.ba_ind_used_3g = 0; used_bits += PMR_BA_IND_USED_LEN; } else { u_meas_report->release_99_str_pmr.ba_psi3_str.flag = TRUE; u_meas_report->release_99_str_pmr.ba_psi3_str.v_psi3_cm = TRUE; used_bits += PMR_PSI3_CHNGE_MRK_LEN; u_meas_report->release_99_str_pmr.ba_psi3_str.psi3_cm = psi3_cm; } } #elif defined (REL99) used_bits += PMR_FLAG_LEN; u_meas_report->v_release_99_str_pmr = FALSE; #endif /* process report type */ used_bits += EM_EXT_RPT_TYPE_LEN; xmeas_rep->xrep_type = emeas->xmeas_set.param->em1.param.reporting_type; /* process interference measurement results */ used_bits += PMR_FLAG_LEN; if( emeas->xmeas_set.param->em1.param.reporting_type EQ REP_TYPE_3 AND emeas->xmeas_set.param->em1.param.int_frequency NEQ NOT_SET ) { T_MEAS_IM_CARRIER ma; xmeas_rep->v_ilev_abs = TRUE; ma.hopping = FALSE; ma.alloc.arfcn = meas_im_get_unmsk_int_freq( emeas->xmeas_set.param->em1.param.int_frequency ); used_bits += meas_im_get_abs_i_level( &ma, &xmeas_rep->ilev_abs ); } else { xmeas_rep->v_ilev_abs = FALSE; } /* process EXT measurement results */ used_bits += EM_NUM_OF_MEAS_LEN; xmeas_rep->num_meas = 0; xmeas_rep->c_ext_mp_s1 = 0; do { /* calculate length of next measurement result */ next_meas_bits = EM_FREQ_N_LEN + EM_RXLEV_N_LEN + PMR_FLAG_LEN; strg_rxlev = 0; rslt_rxlev = 0; strg_bsic = EM_INVLD_BSIC; switch( emeas->xmeas_set.param->em1.param.reporting_type ) { case( REP_TYPE_1 ): case( REP_TYPE_2 ): if( emeas->pmr_snd_ref EQ emeas->strg.number ) { next_meas_bits = 0; } else { strg_bsic = emeas->rslt.elem[emeas->strg.refidx[emeas->pmr_snd_ref]].bsic; strg_rxlev = emeas->rslt.elem[emeas->strg.refidx[emeas->pmr_snd_ref]].rxlev; if( strg_bsic NEQ RRGRR_INVALID_BSIC OR emeas->xmeas_set.param->em1.param.reporting_type EQ REP_TYPE_2 ) { next_meas_bits += EM_BSIC_N_LEN; } } break; case( REP_TYPE_3 ): if( emeas->pmr_snd_ref EQ emeas->rslt.number ) { next_meas_bits = 0; } else { rslt_rxlev = emeas->rslt.elem[emeas->pmr_snd_ref].rxlev; } break; default: next_meas_bits = 0; TRACE_ERROR( "no valid reporting type in meas_em_build_meas_rpt" ); break; } if( next_meas_bits NEQ 0 AND ( BIT_UL_CTRL_BLOCK_CONTENTS - used_bits ) >= next_meas_bits ) { /* copy next measurement result to measurement report */ xmeas_rep->num_meas++; xmeas_rep->c_ext_mp_s1++; used_bits += next_meas_bits; p_mrpt = &xmeas_rep->ext_mp_s1[xmeas_rep->c_ext_mp_s1 - 1]; switch( emeas->xmeas_set.param->em1.param.reporting_type ) { case( REP_TYPE_1 ): case( REP_TYPE_2 ): p_mrpt->freq_n = emeas->rslt.elem[emeas->strg.refidx[emeas->pmr_snd_ref]].refidx; p_mrpt->rxlev_n = strg_rxlev; if( strg_bsic NEQ RRGRR_INVALID_BSIC OR emeas->xmeas_set.param->em1.param.reporting_type EQ REP_TYPE_2 ) { p_mrpt->bsic = strg_bsic; p_mrpt->v_bsic = TRUE; } else { p_mrpt->v_bsic = FALSE; } break; case( REP_TYPE_3 ): p_mrpt->freq_n = emeas->rslt.elem[emeas->pmr_snd_ref].refidx; p_mrpt->rxlev_n = rslt_rxlev; p_mrpt->v_bsic = FALSE; break; default: TRACE_ERROR( "no valid reporting type in meas_em_build_meas_rpt" ); break; } emeas->pmr_snd_ref++; } else { next_meas_bits = 0; } } while( next_meas_bits NEQ 0 ); return( xmeas_rep->num_meas ); } /* meas_em_build_meas_rpt() */ /* +------------------------------------------------------------------------------ | Function : meas_em_extrct_strgst +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : void | +------------------------------------------------------------------------------ */ LOCAL UBYTE meas_em_extrct_strgst ( void ) { UBYTE i, j; /* used for couting */ UBYTE min_rxlev; UBYTE min_index; TRACE_FUNCTION( "meas_em_extrct_strgst" ); emeas->strg.number = 0; for( i = 0; i < emeas->rslt.number; i++ ) { if( emeas->rslt.elem[i].rxlev NEQ RRGRR_INVALID_RXLEV ) { if( emeas->strg.number < EM_MAX_STRONG_CARRIER ) { emeas->strg.refidx[emeas->strg.number] = i; emeas->strg.number++; } else { min_rxlev = 0xFF; min_index = 0xFF; for( j = 0; j < emeas->strg.number; j++ ) { if( emeas->rslt.elem[emeas->strg.refidx[j]].rxlev < min_rxlev ) { min_rxlev = emeas->rslt.elem[emeas->strg.refidx[j]].rxlev; min_index = j; } } if( emeas->rslt.elem[i].rxlev < min_rxlev ) { if( min_index < EM_MAX_STRONG_CARRIER ) { emeas->strg.refidx[min_index] = i; } else { TRACE_ASSERT( min_index < EM_MAX_STRONG_CARRIER ); } } } } } return( emeas->strg.number ); } /* meas_em_extrct_strgst() */ /* +------------------------------------------------------------------------------ | Function : meas_em_extrct_strgst_with_bsic +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : void | +------------------------------------------------------------------------------ */ LOCAL UBYTE meas_em_extrct_strgst_with_bsic ( void ) { UBYTE i, j; /* used for couting */ TRACE_FUNCTION( "meas_em_extrct_strgst_with_bsic" ); meas_em_extrct_strgst( ); for( i = 0, j = 0; i < emeas->strg.number; i++ ) { if( emeas->rslt.elem[emeas->strg.refidx[i]].bsic NEQ RRGRR_INVALID_BSIC AND ((0x01 << ((emeas->rslt.elem[emeas->strg.refidx[i]].bsic & BSIC_NCC_MASK) >> 3)) & emeas->xmeas_set.param->em1.param.ncc_permitted ) NEQ 0 ) { emeas->strg.refidx[j] = emeas->strg.refidx[i]; j++; } } emeas->strg.number = j; return( emeas->strg.number ); } /* meas_em_extrct_strgst_with_bsic() */ /* +------------------------------------------------------------------------------ | Function : meas_em_store_rslt +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL BOOL meas_em_store_rslt ( T_RRGRR_EXT_MEAS_CNF *rrgrr_em_cnf ) { UBYTE i; /* used for counting */ BOOL result = FALSE; TRACE_FUNCTION( "meas_em_store_rslt" ); /* check call reference */ if( rrgrr_em_cnf->call_ref EQ emeas->xmeas_set.ident - 1 ) { if( rrgrr_em_cnf->xmeas_cause EQ EXT_MEAS_OK ) { T_xmeas_res *em_res; result = TRUE; emeas->rslt.number = 0; for( i = 0; i < rrgrr_em_cnf->c_xmeas_res; i++ ) { em_res = &rrgrr_em_cnf->xmeas_res[i]; if( em_res->arfcn_idx.idx < emeas->xmeas_set.param->em1.list.number AND em_res->arfcn_idx.arfcn EQ emeas->xmeas_set.param->em1.list.freq[em_res->arfcn_idx.idx] ) { emeas->rslt.elem[emeas->rslt.number].refidx = em_res->arfcn_idx.idx; emeas->rslt.elem[emeas->rslt.number].rxlev = em_res->rxlev; emeas->rslt.elem[emeas->rslt.number].bsic = em_res->bsic; emeas->rslt.number++; } else { TRACE_ERROR( "meas_em_store_rslt: mismatch of ARFCNs" ); } } } else { TRACE_EVENT_P1( "meas_em_store_rslt: unexpected cause %d", rrgrr_em_cnf->xmeas_cause ); } } else { TRACE_EVENT_P2( "meas_em_store_rslt: mismatch of call references %d %d", rrgrr_em_cnf->call_ref, emeas->xmeas_set.ident - 1 ); } return( result ); } /* meas_em_store_rslt() */ /* +------------------------------------------------------------------------------ | Function : meas_em_req +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : void | +------------------------------------------------------------------------------ */ LOCAL void meas_em_req ( void ) { UBYTE i; /* used for counting */ TRACE_FUNCTION( "meas_em_req" ); { PALLOC( em_req, RRGRR_EXT_MEAS_REQ ); em_req->c_arfcn_idx = 0; for( i = 0; i < emeas->xmeas_set.param->em1.list.number; i++ ) { if( IS_NOT_FLAGGED( emeas->xmeas_set.param->em1.list.freq[i], EM_VLDTY_ARFCN_MASK, EM_NON_VLD_ARFCN ) ) { em_req->arfcn_idx[em_req->c_arfcn_idx].idx = i; em_req->arfcn_idx[em_req->c_arfcn_idx].arfcn = emeas->xmeas_set.param->em1.list.freq[i]; em_req->c_arfcn_idx++; } } #ifdef _SIMULATION_ for( i = em_req->c_arfcn_idx; i < RRGRR_MAX_ARFCN_EXT_MEAS; i++ ) { em_req->arfcn_idx[i].arfcn = RRGRR_INVALID_ARFCN; em_req->arfcn_idx[i].idx = RRGRR_INVALID_IDX; } #endif /* #ifdef _SIMULATION_ */ em_req->call_ref = emeas->xmeas_set.ident; em_req->report_type = emeas->xmeas_set.param->em1.param.reporting_type; em_req->ncc_permitted = emeas->xmeas_set.param->em1.param.ncc_permitted; PSEND( hCommRR, em_req ); } emeas->xmeas_set.ident++; } /* meas_em_req() */ /* +------------------------------------------------------------------------------ | Function : meas_em_is_meas_reporting +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : void | +------------------------------------------------------------------------------ */ LOCAL BOOL meas_em_is_meas_reporting ( void ) { TRACE_FUNCTION( "meas_em_is_meas_reporting" ); return( emeas->xmeas_set.param NEQ NULL AND emeas->xmeas_set.param->em_order_type EQ EM_EM1 AND GET_STATE( MEAS_EM ) NEQ MEAS_EM_SUSPEND ); } /* meas_em_is_meas_reporting() */ /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : meas_im_new_value +------------------------------------------------------------------------------ | Description : This function is used to process new interference measurement | samples send by Layer 1 measured in packet transfer or packet | transfer mode. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void meas_im_new_value ( T_MPHP_INT_MEAS_IND *mphp_int_meas_ind, UBYTE state ) { T_MEAS_IM_FILTER *filter; /* filter to be updated */ UBYTE rx_lev[8]; UBYTE dummy; /* dummy parameter, not used */ TRACE_FUNCTION( "meas_im_new_value" ); meas_handle_int_meas_values ( mphp_int_meas_ind, rx_lev ); if( imeas->carrier_id NEQ mphp_int_meas_ind->carrier_id ) { BOOL valid; if( state EQ MEAS_IDLE ) { valid = meas_im_get_idle_freq( mphp_int_meas_ind->carrier_id, &imeas->carrier, &dummy ); } else { valid = meas_im_get_trns_freq( &imeas->carrier ); } if( valid EQ TRUE ) { imeas->carrier_id = ( USHORT )mphp_int_meas_ind->carrier_id; } else { TRACE_ERROR( "FATAL ERROR 1 in meas_im_new_value" ); return; } } filter = meas_im_get_filter( &imeas->carrier ); if( filter EQ NULL ) { filter = meas_im_get_unused_filter( ); if( filter EQ NULL ) { filter = meas_im_get_oldest_filter( ); if( filter EQ NULL ) { TRACE_ERROR( "FATAL ERROR 2 in meas_im_new_value" ); return; } else { meas_im_restart_filter( filter ); } } filter->carrier = imeas->carrier; } meas_im_update_filter( filter, rx_lev, state ); if( state EQ MEAS_IDLE ) { meas_im_start_idle( ); } meas_im_cgrlc_int_level_req( FALSE ); } /* meas_im_new_value() */ /* +------------------------------------------------------------------------------ | Function : meas_im_cgrlc_int_level_req +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void meas_im_cgrlc_int_level_req ( BOOL init ) { PALLOC( int_level_req, CGRLC_INT_LEVEL_REQ ); TRACE_FUNCTION( "meas_im_cgrlc_int_level_req" ); /* * | | primitive content | primitive shall * init | v_ilev_abs | changed | be sent * -----+------------+-------------------+---------------- * 0 | 0 | X | 1 * 0 | 0 | X | 1 * 0 | 1 | 0 | 0 * 0 | 1 | 1 | 1 * 1 | 0 | X | 1 * 1 | 0 | X | 1 * 1 | 1 | 0 | 0 * 1 | 1 | 1 | 1 */ memset( int_level_req->ilev, CGRLC_RXLEV_NONE, CGRLC_MAX_TIMESLOTS ); if( init EQ FALSE AND grr_data->tc.v_freq_set EQ TRUE ) { T_p_frequency_par freq_par; T_MEAS_IM_CARRIER ma; T_ilev_abs ilev; grr_set_freq_par( &freq_par ); meas_im_set_carrier( &ma, &freq_par ); meas_im_get_abs_i_level( &ma, &ilev ); if( ilev.v_ilevabs0 EQ TRUE ) int_level_req->ilev[0] = ilev.ilevabs0; if( ilev.v_ilevabs1 EQ TRUE ) int_level_req->ilev[1] = ilev.ilevabs1; if( ilev.v_ilevabs2 EQ TRUE ) int_level_req->ilev[2] = ilev.ilevabs2; if( ilev.v_ilevabs3 EQ TRUE ) int_level_req->ilev[3] = ilev.ilevabs3; if( ilev.v_ilevabs4 EQ TRUE ) int_level_req->ilev[4] = ilev.ilevabs4; if( ilev.v_ilevabs5 EQ TRUE ) int_level_req->ilev[5] = ilev.ilevabs5; if( ilev.v_ilevabs6 EQ TRUE ) int_level_req->ilev[6] = ilev.ilevabs6; if( ilev.v_ilevabs7 EQ TRUE ) int_level_req->ilev[7] = ilev.ilevabs7; } PSEND( hCommGRLC, int_level_req ); } /* meas_im_cgrlc_int_level_req() */ /* +------------------------------------------------------------------------------ | Function : meas_im_stop_trns +------------------------------------------------------------------------------ | Description : This function stops the interference measurements in packet | transfer mode. | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_im_stop_trns ( void ) { TRACE_FUNCTION( "meas_im_stop_trns" ); imeas->carrier_id = IDX_USHORT_INVALID; } /* meas_im_stop_trns() */ /* +------------------------------------------------------------------------------ | Function : meas_im_stop_idle +------------------------------------------------------------------------------ | Description : This function stops the interference measurements in packet | idle mode. | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_im_stop_idle ( void ) { TRACE_FUNCTION( "meas_im_stop_idle" ); { PALLOC( mphp_int_meas_stop_req, MPHP_INT_MEAS_STOP_REQ ); PSEND( hCommL1, mphp_int_meas_stop_req ); } imeas->carrier_id = IDX_USHORT_INVALID; } /* meas_im_stop_idle() */ /* +------------------------------------------------------------------------------ | Function : meas_im_prepare_trns +------------------------------------------------------------------------------ | Description : This function prepares the interference measurements in packet | transfer mode. | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_im_prepare_trns ( void ) { TRACE_FUNCTION( "meas_im_prepare_trns" ); } /* meas_im_prepare_trns() */ /* +------------------------------------------------------------------------------ | Function : meas_im_prepare_idle +------------------------------------------------------------------------------ | Description : This function prepares the interference measurements in packet | idle mode. | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_im_prepare_idle ( void ) { UBYTE i; /* used for counting */ TRACE_FUNCTION( "meas_im_prepare_idle" ); /* process the carrier indicated in the parameter EXT_FREQUENCY_LIST */ #if ( ! ( CHN_ID_EM_BASE < MAX_IM_IDLE_CHANNELS ) ) #error CHN_ID_EM_BASE < MAX_IM_IDLE_CHANNELS required #endif if( emeas->xmeas_set.param NEQ NULL AND emeas->xmeas_set.param->em1.param.reporting_type EQ REP_TYPE_3 AND emeas->xmeas_set.param->em1.param.int_frequency NEQ NOT_SET ) { imeas->idle_chan.ident[CHN_ID_EM_BASE] = emeas->xmeas_set.param->em1.param.int_frequency; } else { imeas->idle_chan.ident[CHN_ID_EM_BASE] = CHN_ID_INVALID; } /* process the monitored PCCCH */ #if ( ! ( CHN_ID_PCCCH_BASE < MAX_IM_IDLE_CHANNELS ) ) #error CHN_ID_PCCCH_BASE < MAX_IM_IDLE_CHANNELS required #endif if( imeas->v_cs_meas_active EQ TRUE AND psc_db->paging_group.kc NEQ 0 ) { UBYTE pccch_group; pccch_group = ( UBYTE )( grr_imsi_mod( ) % psc_db->paging_group.kc ); if( pccch_group > psc_db->paging_group.kc - 1 ) { TRACE_ERROR( "pccch_group > psc_db->paging_group.kc - 1 in meas_im_prepare_idle" ); imeas->idle_chan.ident[CHN_ID_PCCCH_BASE] = CHN_ID_INVALID; } else { imeas->idle_chan.ident[CHN_ID_PCCCH_BASE] = pccch_group; } } else { imeas->idle_chan.ident[CHN_ID_PCCCH_BASE] = CHN_ID_INVALID; } /* process the carriers indicated by the parameter INT_MEAS_CHANNEL_LIST */ i = CHN_ID_IM_BASE; while( i < MAX_IM_IDLE_CHANNELS AND ( i - CHN_ID_IM_BASE ) < psc_db->number_of_valid_int_meas_channels ) { imeas->idle_chan.ident[i] = i - CHN_ID_IM_BASE; i++; } while( i < MAX_IM_IDLE_CHANNELS ) { imeas->idle_chan.ident[i] = CHN_ID_INVALID; i++; } /* let's start measurements with the first entry in the idle channel list */ imeas->idle_chan.index = 0; } /* meas_im_prepare_idle() */ /* +------------------------------------------------------------------------------ | Function : meas_im_timer_elapsed +------------------------------------------------------------------------------ | Description : | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_im_timer_elapsed ( void ) { UBYTE i, j; /* used for counting */ LONG new_remain_time = TIME_INVALID; LONG* old_remain_time; TRACE_FUNCTION( "meas_im_timer_elapsed" ); for( i = 0; i < MAX_IM_CHANNELS; i++ ) { for( j = 0; j < CGRLC_MAX_TIMESLOTS; j++ ) { old_remain_time = &imeas->filter[i].i_level[j].remain_time; if( *old_remain_time < 0 ) { TRACE_ERROR( "unexpected time value in meas_im_timer_elapsed" ); } if( *old_remain_time EQ 0 ) { *old_remain_time = TIME_INVALID; } else if ( *old_remain_time NEQ TIME_INVALID AND *old_remain_time < new_remain_time ) { new_remain_time = *old_remain_time; } } } if( new_remain_time NEQ TIME_INVALID ) { meas_im_timer_reorg( 0, new_remain_time ); } } /* meas_im_timer_elapsed() */ /* +------------------------------------------------------------------------------ | Function : meas_im_state_changed +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void meas_im_state_changed ( UBYTE state ) { UBYTE i, j; /* used for counting */ TRACE_FUNCTION( "meas_im_state_changed" ); /* * the three if-statements below are just used to skip * the following for-loops in all impossible cases */ if( grr_data->meas_im.mode EQ IM_MODE_NONE ) { return; } if( ( state EQ MEAS_IDLE OR state EQ MEAS_ACCESS ) AND ( grr_data->meas_im.mode EQ IM_MODE_TRANSFER ) ) { return; } if( state EQ MEAS_TRANSFER AND grr_data->meas_im.mode EQ IM_MODE_IDLE ) { return; } for( i = 0; i < MAX_IM_CHANNELS; i++ ) { for( j = 0; j < CGRLC_MAX_TIMESLOTS; j++ ) { if( ( ( state EQ MEAS_IDLE OR state EQ MEAS_ACCESS ) AND IS_FLAGGED( imeas->filter[i].i_level[j].m_gamma, IM_I_MASK_IDL, IM_I_IDL ) ) OR ( ( state EQ MEAS_TRANSFER ) AND IS_FLAGGED( imeas->filter[i].i_level[j].m_gamma, IM_I_MASK_TRNS, IM_I_TRNS ) ) ) { if( imeas->filter[i].i_level[j].remain_time EQ TIME_INVALID ) { meas_im_restart_gamma( &imeas->filter[i], j ); } } } } } /* meas_im_state_changed() */ /* +------------------------------------------------------------------------------ | Function : meas_im_start_idle +------------------------------------------------------------------------------ | Description : This function starts the interference measurements in packet | idle mode. | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL BOOL meas_im_start_idle ( void ) { T_MEAS_IM_IDLE_CHN* chn = &imeas->idle_chan; UBYTE ts_mask; UBYTE max_checks = MAX_IM_IDLE_CHANNELS; BOOL is_started = FALSE; TRACE_FUNCTION( "meas_im_start_idle" ); while( chn->ident[chn->index] EQ CHN_ID_INVALID AND max_checks > 0 ) { chn->index = ((chn->index < MAX_IM_IDLE_CHANNELS - 1) ? chn->index + 1 : 0); max_checks--; } if( max_checks > 0 ) { PALLOC( mphp_int_meas_req, MPHP_INT_MEAS_REQ ); meas_im_get_idle_freq( chn->index, &imeas->carrier, &ts_mask ); meas_im_set_freq_par( &mphp_int_meas_req->p_frequency_par, &imeas->carrier ); imeas->carrier_id = chn->index; mphp_int_meas_req->carrier_id = ( UBYTE )chn->index; mphp_int_meas_req->ts_mask = ts_mask; mphp_int_meas_req->m_class = grr_get_gprs_ms_class( ); PSEND( hCommL1, mphp_int_meas_req ); is_started = TRUE; if( chn->index < MAX_IM_IDLE_CHANNELS ) { chn->index++; } else { chn->index = 0; } } return( is_started ); } /* meas_im_start_idle() */ /* +------------------------------------------------------------------------------ | Function : meas_im_set_freq_par +------------------------------------------------------------------------------ | Description : | | Frequency Band config. ETSI GSM spec. coding used in L1 | GSM 900 STD_900 1-124 1-124 | E-GSM STD_EGSM 1-124, 1-124, | 975-1023, 0 125-174 | PCS 1900 STD_1900 512-810 512-810 | DCS 1800 STD_1800 512-885 512-885 | GSM 900/DCS 1800 STD_DUAL 1-124, 1-124, | 512-885 125-498 | E-GSM/DCS 1800 STD_DUAL_EGSM 1-124, 1-124, | 975-1023,0 125-174, | 512-885 175-548 | GSM 850 STD_850 128-251 128-251 | GSM 850/PCS 1900 STD_DUAL_US 128-251, 1-124, | 512-810 125-424 | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL void meas_im_set_freq_par ( T_p_frequency_par *freq_par, T_MEAS_IM_CARRIER *carrier ) { TRACE_FUNCTION( "meas_im_set_freq_par" ); if( carrier->hopping ) { UBYTE i = 0; UBYTE bit_shift; USHORT array_idx; USHORT arfcn; freq_par->p_chan_sel.hopping = MPHP_INT_MEAS_HOPPING; freq_par->p_chan_sel.p_rf_ch.arfcn = ( ( USHORT )carrier->alloc.hop_param.hsn << 8 ) | ( USHORT )carrier->alloc.hop_param.maio; for ( array_idx = 0; array_idx < MAX_IM_HOP_ARFCN_BIT_FIELD_SIZE; array_idx++ ) { for( bit_shift = 0; bit_shift < 8 AND i < MPHP_NUMC_MA; bit_shift++ ) { if( ( carrier->alloc.hop_param.arfcn_bit_field[array_idx] & ( 0x01 << bit_shift ) ) NEQ 0 ) { arfcn = ( array_idx * 8 ) + bit_shift; switch( std ) { case STD_1900: arfcn += LOW_CHANNEL_1900; break; case STD_1800: arfcn += LOW_CHANNEL_1800; break; default : break; } freq_par->p_freq_list.p_rf_chan_no.p_radio_freq[i] = arfcn; i++; } } } freq_par->p_freq_list.p_rf_chan_cnt = i; } else { freq_par->p_chan_sel.hopping = MPHP_INT_MEAS_STATIC; freq_par->p_chan_sel.p_rf_ch.arfcn = grr_g23_arfcn_to_l1( carrier->alloc.arfcn ); } } /* meas_im_set_freq_par() */ /* +------------------------------------------------------------------------------ | Function : meas_im_start_trns +------------------------------------------------------------------------------ | Description : This function starts the interference measurements in packet | transfer mode. | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_im_start_trns ( void ) { TRACE_FUNCTION( "meas_im_start_trns" ); } /* meas_im_start_trns() */ /* +------------------------------------------------------------------------------ | Function : meas_em_prcs_meas_order +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : d_meas_order - Pointer to packet measurement order message | +------------------------------------------------------------------------------ */ GLOBAL UBYTE meas_em_prcs_meas_order ( T_D_MEAS_ORDER *d_meas_order, T_NC_ORDER *ctrl_order ) { BOOL is_pmo_ok; UBYTE i; UBYTE ret_value = PMO_NONE_VLD; #if defined (REL99) AND defined (TI_PS_FF_EMR) UBYTE psi3_cm = grr_get_psi3_cm(); #endif TRACE_FUNCTION( "meas_em_prcs_meas_order" ); TRACE_EVENT_P2( "D_MEAS_ORDER received idx = %d, cnt = %d", d_meas_order->pmo_index, d_meas_order->pmo_cnt ); /* process the PMO_COUNT and PMO_INDEX parameter */ if( ( emeas->pmo.prm.count NEQ NOT_SET AND emeas->pmo.prm.count NEQ d_meas_order->pmo_cnt ) OR d_meas_order->pmo_cnt < d_meas_order->pmo_index ) { TRACE_ERROR( "D_MEAS_ORDER: parameter inconsistent" ); meas_em_init_pmo_seq( ); return( ret_value ); } #if defined (REL99) AND defined (TI_PS_FF_EMR) /* Set to ENH params not present by default */ if( emeas->pmo.prm.count EQ NOT_SET ) { emeas->pmo.v_enh_meas_param_pmo = FALSE; nc_freq_list_pres = FALSE; nc_freq_list_valid = FALSE; use_ba_gprs = TRUE; } #endif emeas->pmo.prm.instances[d_meas_order->pmo_index] = TRUE; emeas->pmo.prm.count = d_meas_order->pmo_cnt; /* process the EXT measurement parameter */ if( d_meas_order->v_xmeas_par EQ TRUE ) { grr_prcs_xmeas_struct ( &emeas->pmo.extd, &d_meas_order->xmeas_par, TRUE, d_meas_order->pmo_index, &emeas->pmo.prm.idx[d_meas_order->pmo_index].start, &emeas->pmo.prm.idx[d_meas_order->pmo_index].stop ); } if( d_meas_order->v_nc_meas_par_list EQ TRUE ) { /* * process the NC measurement parameter * * maybe more than one instance of PMO, store data in temporary location */ emeas->v_pmo_nc_ncmeas_param = TRUE; #if defined (REL99) AND defined (TI_PS_FF_EMR) /* Do not get back to BA-GPRS list since NC_FREQ_LIST is present */ if(d_meas_order->nc_meas_par_list.v_nc_freq_list) { nc_freq_list_pres = TRUE; } #endif grr_prcs_nc_param_struct ( &emeas->pmo.nc.ncmeas.param, &d_meas_order->nc_meas_par_list.nc_meas_par, d_meas_order->pmo_index ); #if defined (REL99) AND defined (TI_PS_FF_EMR) /* Check for presence of ENH parameters in PMO. If present, then PSI3_CM or BA_IND will be checked depending on the presence or absence of PBCCH for consistency with the BA list existing currently. If consistent, then only the PMO NC frequency list is considered. */ if( d_meas_order->release_98_str_d_meas_order.v_release_99_str_d_meas_order AND (d_meas_order->release_98_str_d_meas_order.release_99_str_d_meas_order.v_enh_meas_param_pmo EQ TRUE) ) { if(grr_is_pbcch_present() AND d_meas_order->release_98_str_d_meas_order.release_99_str_d_meas_order.enh_meas_param_pmo.ba_psi3_str.v_psi3_cm) { if(d_meas_order->release_98_str_d_meas_order.release_99_str_d_meas_order.enh_meas_param_pmo.ba_psi3_str.psi3_cm EQ psi3_cm) { nc_freq_list_valid = TRUE; } } else if(!grr_is_pbcch_present() AND d_meas_order->release_98_str_d_meas_order.release_99_str_d_meas_order.enh_meas_param_pmo.ba_psi3_str.v_ba_ind_used) { if(d_meas_order->release_98_str_d_meas_order.release_99_str_d_meas_order.enh_meas_param_pmo.ba_psi3_str.ba_ind_used EQ psc_db->ba_ind) { nc_freq_list_valid = TRUE; } } } else /* PMO is not checked for BA_IND or PSI3_CM consistency since ENH params are absent */ { nc_freq_list_valid = TRUE; } if(nc_freq_list_valid EQ TRUE) { #endif /* * process NC_FREQUENCY_LIST * * maybe more than one instance of PMO, store data in temporary location */ emeas->v_pmo_nc_ncmeas_list_rfreq = grr_prcs_nc_freq_list ( &emeas->pmo.nc.ncmeas.list, &emeas->pmo.nc.rfreq, d_meas_order->nc_meas_par_list.v_nc_freq_list, &d_meas_order->nc_meas_par_list.nc_freq_list, INFO_TYPE_PMO, d_meas_order->pmo_index ); #if defined (REL99) AND defined (TI_PS_FF_EMR) } } if( d_meas_order->release_98_str_d_meas_order.v_release_99_str_d_meas_order AND (d_meas_order->release_98_str_d_meas_order.release_99_str_d_meas_order.v_enh_meas_param_pmo EQ TRUE) ) { emeas->pmo.v_enh_meas_param_pmo = TRUE; /* * process the ENH measurement parameter * * maybe more than one instance of PMO, store data in temporary location */ grr_prcs_enh_param_pmo(&emeas->pmo.enh, &d_meas_order->release_98_str_d_meas_order.release_99_str_d_meas_order.enh_meas_param_pmo, d_meas_order->pmo_index, &emeas->pmo.nc.pmo_ind); #endif } for( i = 0, is_pmo_ok = TRUE; i <= emeas->pmo.prm.count AND is_pmo_ok EQ TRUE; i++ ) { if( emeas->pmo.prm.instances[i] EQ FALSE ) { is_pmo_ok = FALSE; } } if( is_pmo_ok ) { /* process EXT measurement service */ grr_sort_ext_lst_freq ( &emeas->pmo.extd.em1.list, MAX_NR_OF_INSTANCES_OF_PMO, &emeas->pmo.prm.idx[0] ); memcpy( &psc_db->ext_pmo, &emeas->pmo.extd, sizeof( psc_db->ext_pmo ) ); if( emeas->pmo.extd.em_order_type NEQ EM_EMPTY AND !( emeas->pmo.extd.em_order_type EQ EM_EM1 AND emeas->pmo.extd.em1.param.reporting_type EQ REP_TYPE_RES ) ) { ret_value |= PMO_EXT_VLD; } /* process NC measurement service */ /* * Before copying the NC parameter store the old value * for the network control order */ *ctrl_order = psc_db->nc_ms.ncmeas.param.ctrl_order; grr_prcs_nc_param_final ( &psc_db->nc_ms.ncmeas.param, &emeas->v_pmo_nc_ncmeas_param, &emeas->pmo.nc.ncmeas.param ); #if defined (REL99) AND defined (TI_PS_FF_EMR) if( (nc_freq_list_pres EQ TRUE) AND (psc_db->nc_ms.ncmeas.param.ctrl_order NEQ NC_RESET) ) { use_ba_gprs = FALSE; } if(rr_get_support_for_emr() AND emeas->pmo.v_enh_meas_param_pmo EQ TRUE) { /* The ENH parameters that are temporarily stored are moved to final destination after consistent set of PMO is received */ memcpy(&(psc_db->enh_ms), &(emeas->pmo.enh), sizeof(T_GRR_ENH_PARA)); psc_db->nc_ms.pmo_ind = emeas->pmo.nc.pmo_ind; } else { memset(&(psc_db->enh_ms), 0, sizeof(T_GRR_ENH_PARA)); psc_db->enh_ms.rept_type = REPORT_TYPE_REP; emeas->pmo.v_enh_meas_param_pmo = FALSE; } #endif /* * At cell re-selection the NC measurement parameters valid for the mobile * station in the new cell are brought from the old cell if received in a * PACKET MEASUREMENT ORDER message. Storing is done in advance even in * case no cell re-selection took place at this time. */ memcpy( &pcr_db->nc_ms.ncmeas.param, &psc_db->nc_ms.ncmeas.param, sizeof( T_NC_PARAM ) ); pcr_db->nc_ms.ncmeas.param.chng_mrk.curr = 0; pcr_db->nc_ms.ncmeas.param.chng_mrk.prev = 0; #if defined (REL99) AND defined (TI_PS_FF_EMR) if(nc_freq_list_valid EQ TRUE) { grr_prcs_nc_freq_final ( &psc_db->nc_ms.ncmeas.list, &psc_db->nc_ms.rfreq, &emeas->v_pmo_nc_ncmeas_list_rfreq, &emeas->pmo.nc.ncmeas.list, &emeas->pmo.nc.rfreq ); } #else grr_prcs_nc_freq_final ( &psc_db->nc_ms.ncmeas.list, &psc_db->nc_ms.rfreq, &emeas->v_pmo_nc_ncmeas_list_rfreq, &emeas->pmo.nc.ncmeas.list, &emeas->pmo.nc.rfreq ); #endif if( emeas->pmo.nc.ncmeas.param.ctrl_order NEQ NC_EMPTY ) { ret_value |= PMO_NC_VLD; } meas_em_init_pmo_seq( ); } return( ret_value ); } /* meas_em_prcs_meas_order() */ /* +------------------------------------------------------------------------------ | Function : meas_em_valid_pmo +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_em_valid_pmo ( void ) { TRACE_FUNCTION( "meas_em_valid_pmo" ); switch( psc_db->ext_pmo.em_order_type ) { case( EM_RESET ): meas_em_valid_psi5( ); break; default: if( psc_db->ext_pmo.em_order_type EQ EM_EM1 ) { emeas->xmeas_set.param = &psc_db->ext_pmo; } else { emeas->xmeas_set.param = NULL; } break; } } /* meas_em_valid_pmo() */ /* +------------------------------------------------------------------------------ | Function : meas_em_valid_psi5 +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_em_valid_psi5 ( void ) { TRACE_FUNCTION( "meas_em_valid_psi5" ); if( psc_db->ext_psi5.em_order_type EQ EM_EM1 ) { emeas->xmeas_set.param = &psc_db->ext_psi5; } else { emeas->xmeas_set.param = NULL; } } /* meas_em_valid_psi5() */ /* +------------------------------------------------------------------------------ | Function : meas_em_is_valid_pmo_present +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL BOOL meas_em_is_valid_pmo_present ( void ) { TRACE_FUNCTION( "meas_em_is_valid_pmo_present" ); return( psc_db->ext_pmo.em_order_type NEQ EM_EMPTY AND psc_db->ext_pmo.em_order_type NEQ EM_RESET ); } /* meas_em_is_valid_pmo_present() */ /* +------------------------------------------------------------------------------ | Function : meas_em_process_t3178 +------------------------------------------------------------------------------ | Description : ... | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_em_process_t3178 ( void ) { T_TIME reporting_period; T_TIME time_to_go; BOOL tmr_3178_rng_le_rp = FALSE; TRACE_FUNCTION( "meas_em_process_t3178" ); if( meas_em_is_meas_reporting( ) ) { reporting_period = GET_EM_RPT_PRD( emeas->xmeas_set.param->em1.param.reporting_period ); time_to_go = grr_t_status( T3178 ); if( time_to_go > 0 ) { if( time_to_go > reporting_period ) { meas_em_stop_t3178( ); } else { tmr_3178_rng_le_rp = TRUE; } } if( reporting_period NEQ 0 AND tmr_3178_rng_le_rp EQ FALSE ) { meas_em_start_t3178( reporting_period ); } } else { meas_em_stop_t3178( ); } } /* meas_em_process_t3178() */ /* +------------------------------------------------------------------------------ | Function : meas_em_start_t3178 +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL void meas_em_start_t3178 ( T_TIME time ) { TRACE_FUNCTION( "meas_em_start_t3178" ); vsi_t_start( GRR_handle, T3178, time ); TRACE_EVENT_P1( "T3178: %d", time ); } /* meas_em_start_t3178() */ /* +------------------------------------------------------------------------------ | Function : meas_em_stop_t3178 +------------------------------------------------------------------------------ | Description : | | Parameters : void | +------------------------------------------------------------------------------ */ LOCAL void meas_em_stop_t3178 ( void ) { TRACE_FUNCTION( "meas_em_stop_t3178" ); if( grr_t_status( T3178 ) > 0 ) { vsi_t_stop( GRR_handle, T3178 ); TRACE_EVENT( "T3178 stopped" ); } } /* meas_em_stop_t3178() */ /* +------------------------------------------------------------------------------ | Function : meas_em_stop_req +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_em_stop_req ( void ) { TRACE_FUNCTION( "meas_em_stop_req" ); { PALLOC( rrgrr_em_stop_req, RRGRR_EXT_MEAS_STOP_REQ ); PSEND( hCommRR, rrgrr_em_stop_req ); } } /* meas_em_stop_req() */ /* +------------------------------------------------------------------------------ | Function : meas_em_start +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_em_start ( void ) { TRACE_FUNCTION( "meas_em_start" ); meas_im_delete_em_rslt( ); meas_em_req( ); meas_em_process_t3178( ); } /* meas_em_start() */ /* +------------------------------------------------------------------------------ | Function : meas_em_send_meas_rpt +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL BOOL meas_em_send_meas_rpt ( BOOL perform_init ) { BOOL rpt_snd; T_U_MEAS_REPORT meas_rpt; TRACE_FUNCTION( "meas_em_send_meas_rpt" ); if( perform_init EQ TRUE ) { emeas->pmr_snd_ref = 0; if ( emeas->xmeas_set.param->em1.param.reporting_type EQ REP_TYPE_1 ) { meas_em_extrct_strgst( ); } else if( emeas->xmeas_set.param->em1.param.reporting_type EQ REP_TYPE_2 ) { meas_em_extrct_strgst_with_bsic( ); } } if( meas_em_build_meas_rpt( &meas_rpt ) NEQ 0 OR perform_init EQ TRUE ) { sig_meas_ctrl_meas_report( &meas_rpt ); rpt_snd = TRUE; } else { rpt_snd = FALSE; } return( rpt_snd ); } /* meas_em_send_meas_rpt() */ /* +------------------------------------------------------------------------------ | Function : meas_is_spgc_ccch_supported +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL BOOL meas_is_spgc_ccch_supported ( void ) { TRACE_FUNCTION( "meas_is_spgc_ccch_supported" ); return ( psc_db->net_ctrl.spgc_ccch_supp.nw_supp EQ GMMRR_SPGC_CCCH_SUPP_YES AND psc_db->net_ctrl.spgc_ccch_supp.ms_supp EQ GMMRR_SPGC_CCCH_SUPP_YES ); } /* meas_is_spgc_ccch_supported() */ /* +------------------------------------------------------------------------------ | Function : meas_handle_int_meas_values +------------------------------------------------------------------------------ | Description : This function ... | | Parameters : mphp_int_meas_ind - pointer to primitive | rx_lev - pointer on array of 8 byte, | where the results are stored | +------------------------------------------------------------------------------ */ GLOBAL void meas_handle_int_meas_values ( T_MPHP_INT_MEAS_IND *mphp_int_meas_ind, UBYTE *rx_lev ) { UBYTE i; /* used for counting */ T_int_meas_rxlev *sample; TRACE_FUNCTION( "meas_handle_int_meas_values" ); for ( i = 0; i < CGRLC_MAX_TIMESLOTS; i++ ) { sample = &mphp_int_meas_ind->int_meas_rxlev[i]; if( sample->rx_lev[0] EQ CGRLC_RXLEV_NONE ) { if( sample->rx_lev[1] EQ CGRLC_RXLEV_NONE ) { rx_lev[i] = CGRLC_RXLEV_NONE; } else { rx_lev[i] = sample->rx_lev[1]; } } else { if( sample->rx_lev[1] EQ CGRLC_RXLEV_NONE ) { rx_lev[i] = sample->rx_lev[0]; } else { rx_lev[i] = MINIMUM( (signed char)( sample->rx_lev[0] ), (signed char)( sample->rx_lev[1] ) ); } } } grr_clip_rxlev ( rx_lev, rx_lev, CGRLC_MAX_TIMESLOTS ); #if !defined (NTRACE) if( grr_data->meas_im.n_im_trace & M_IM_TRACE_INPUT_VALUE ) { USHORT rx_lev[8]; rx_lev[0] = ( USHORT )mphp_int_meas_ind->int_meas_rxlev[0].rx_lev[0] << 0; rx_lev[0] |= ( USHORT )mphp_int_meas_ind->int_meas_rxlev[0].rx_lev[1] << 8; rx_lev[1] = ( USHORT )mphp_int_meas_ind->int_meas_rxlev[1].rx_lev[0] << 0; rx_lev[1] |= ( USHORT )mphp_int_meas_ind->int_meas_rxlev[1].rx_lev[1] << 8; rx_lev[2] = ( USHORT )mphp_int_meas_ind->int_meas_rxlev[2].rx_lev[0] << 0; rx_lev[2] |= ( USHORT )mphp_int_meas_ind->int_meas_rxlev[2].rx_lev[1] << 8; rx_lev[3] = ( USHORT )mphp_int_meas_ind->int_meas_rxlev[3].rx_lev[0] << 0; rx_lev[3] |= ( USHORT )mphp_int_meas_ind->int_meas_rxlev[3].rx_lev[1] << 8; rx_lev[4] = ( USHORT )mphp_int_meas_ind->int_meas_rxlev[4].rx_lev[0] << 0; rx_lev[4] |= ( USHORT )mphp_int_meas_ind->int_meas_rxlev[4].rx_lev[1] << 8; rx_lev[5] = ( USHORT )mphp_int_meas_ind->int_meas_rxlev[5].rx_lev[0] << 0; rx_lev[5] |= ( USHORT )mphp_int_meas_ind->int_meas_rxlev[5].rx_lev[1] << 8; rx_lev[6] = ( USHORT )mphp_int_meas_ind->int_meas_rxlev[6].rx_lev[0] << 0; rx_lev[6] |= ( USHORT )mphp_int_meas_ind->int_meas_rxlev[6].rx_lev[1] << 8; rx_lev[7] = ( USHORT )mphp_int_meas_ind->int_meas_rxlev[7].rx_lev[0] << 0; rx_lev[7] |= ( USHORT )mphp_int_meas_ind->int_meas_rxlev[7].rx_lev[1] << 8; TRACE_EVENT_P8( "meas_handle_int_meas_values: %04X %04X %04X %04X %04X %04X %04X %04X", rx_lev[0], rx_lev[1], rx_lev[2], rx_lev[3], rx_lev[4], rx_lev[5], rx_lev[6], rx_lev[7] ); } #endif /* #if !defined (NTRACE) */ } /* meas_handle_int_meas_values() */ /* +------------------------------------------------------------------------------ | Function : meas_c_init +------------------------------------------------------------------------------ | Description : This function initializes the parameters for deriving the | C value. | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_c_init ( void ) { TRACE_FUNCTION( "meas_c_init" ); grr_data->meas.c_filter.value = 0; grr_data->meas.c_filter.index = 0; } /* meas_c_init() */ /* +------------------------------------------------------------------------------ | Function : meas_c_val_update_pim +------------------------------------------------------------------------------ | Description : ... | | Parameters : - | +------------------------------------------------------------------------------ */ GLOBAL void meas_c_val_update_pim ( UBYTE rx_lev ) { ULONG ff; /* forgetting factor */ ULONG avgw_drx; ULONG c_value; UBYTE c_block; T_C_FILTER *c_filter = &grr_data->meas.c_filter; TRACE_FUNCTION( "meas_c_val_update_pim" ); grr_clip_rxlev ( &c_block, &rx_lev, 1 ); if( c_block NEQ CGRLC_RXLEV_NONE ) { MEAS_C_INC_INDEX( c_filter->index ); /* calculate the forgetting factor */ avgw_drx = ( (NORM_TAVGW_FAC * NORM_TAVGW_FAC * norm_pow[psc_db->g_pwr_par.t_avg_w]) / 6 ) / meas_im_get_drx_period_seconds( ); ff = DRX_NORM_FACTOR / MINIMUM( NORM_TAVGW_FAC * c_filter->index, MAXIMUM( 5 * NORM_TAVGW_FAC, avgw_drx ) ); /* update the filter */ c_value = ( NORM_POW_MIN - ff ) * c_filter->value + MEAS_ACRCY * ff * c_block; c_filter->value = (T_C_VALUE)( M_ROUND_UP( c_value, NORM_POW_MIN ) ); #ifdef _SIMULATION_ TRACE_EVENT_P2( "C-Value = %d, C-Index = %d", c_filter->value, c_filter->index ); #endif /* #ifdef _SIMULATION_ */ grr_data->pwr_ctrl_valid_flags.v_c_value = TRUE; } else { #ifdef _SIMULATION_ TRACE_EVENT( "no valid RXLEV information in meas_c_val_update_pim" ); #endif /* #ifdef _SIMULATION_ */ } } /* meas_c_val_update_pim() */ /* +------------------------------------------------------------------------------ | Function : meas_handle_pwr_par +------------------------------------------------------------------------------ | Description : The function meas_handle_pwr_par() .... | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void meas_handle_pwr_par ( void ) { MCAST( d_ctrl_pwr_ta, D_CTRL_PWR_TA ); /* T_D_CTRL_PWR_TA */ TRACE_FUNCTION( "meas_handle_pwr_par" ); /* process global power control parameter */ if( d_ctrl_pwr_ta->v_g_pwr_par ) { grr_store_g_pwr_par( &d_ctrl_pwr_ta->g_pwr_par ); } /* process power control parameter */ if( d_ctrl_pwr_ta->v_pwr_par ) { grr_store_type_pwr_par( &d_ctrl_pwr_ta->pwr_par, FALSE ); } } /* meas_handle_pwr_par() */