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 signal handler functions for service
| MEAS of entity GRR.
+-----------------------------------------------------------------------------
*/
#ifndef GRR_MEASS_C
#define GRR_MEASS_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 definitions for interference measurements */
#include "grr_meass.h" /* to get the own definitions */
#include "grr_measp.h" /* to get the own definitions */
#include "cl_rlcmac.h"
#include "grr_tcs.h"
/*==== CONST ================================================================*/
#define BS_PA_MFRMS_OFFSET 2 /* BS_PA_MRMS is coded within 3 bits and */
/* ranges from 2 to 9 */
#define DRX_DENOMINATOR_FOR_CCCH 4
/*==== LOCAL VARS ===========================================================*/
/*==== LOCAL TYPES===========================================================*/
#if !defined (NTRACE)
LOCAL void meas_im_trace_i_level( T_MEAS_IM_FILTER *filter,
T_ilev *i_level );
#endif /* #if !defined (NTRACE) */
/*==== PUBLIC FUNCTIONS =====================================================*/
/*
+------------------------------------------------------------------------------
| Function : meas_im_get_permit
+------------------------------------------------------------------------------
| Description : This function returns whether interference measurements in
| packet transfer mode shall be performed by Layer 1
| autonomously.
|
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE meas_im_get_permit ( void )
{
UBYTE permit = MPHP_IM_ENABLED;
TRACE_FUNCTION( "meas_im_get_permit" );
if( grr_data->meas_im.mode NEQ IM_MODE_IDLE_TRANSFER AND
grr_data->meas_im.mode NEQ IM_MODE_TRANSFER )
{
permit = MPHP_IM_DISABLED;
}
return( permit );
} /* meas_im_get_permit() */
/*
+------------------------------------------------------------------------------
| Function : meas_init
+------------------------------------------------------------------------------
| Description : This function initializes the measurement module.
|
| Parameters : im_mode - operation mode for interference measurements
|
+------------------------------------------------------------------------------
*/
GLOBAL void meas_init ( T_MEAS_IM_MODE im_mode )
{
TRACE_FUNCTION( "meas_init" );
/* general initialization */
INIT_STATE( MEAS, MEAS_NULL );
/* initialization of interference measurements */
meas_im_init( im_mode );
/* initialization of extended measurements */
meas_em_init( );
/* initialization of C value derivation */
meas_c_init( );
} /* meas_init() */
/*
+------------------------------------------------------------------------------
| Function : meas_im_get_rel_i_level
+------------------------------------------------------------------------------
| Description : This function returns the interference level values mapped to
| values relative to the C value.
|
| Parameters : *ma - Ptr to frequency information in MA format
| *i_level - Ptr to relative interference level values
|
+------------------------------------------------------------------------------
*/
GLOBAL void meas_im_get_rel_i_level ( T_MEAS_IM_CARRIER *ma,
T_ilev *i_level )
{
T_MEAS_IM_FILTER *filter; /* filter */
TRACE_FUNCTION( "meas_im_get_rel_i_level" );
filter = meas_im_get_filter( ma );
meas_im_fill_rel_iLevel( &i_level->v_ilev0, &i_level->ilev0, filter, 0 );
meas_im_fill_rel_iLevel( &i_level->v_ilev1, &i_level->ilev1, filter, 1 );
meas_im_fill_rel_iLevel( &i_level->v_ilev2, &i_level->ilev2, filter, 2 );
meas_im_fill_rel_iLevel( &i_level->v_ilev3, &i_level->ilev3, filter, 3 );
meas_im_fill_rel_iLevel( &i_level->v_ilev4, &i_level->ilev4, filter, 4 );
meas_im_fill_rel_iLevel( &i_level->v_ilev5, &i_level->ilev5, filter, 5 );
meas_im_fill_rel_iLevel( &i_level->v_ilev6, &i_level->ilev6, filter, 6 );
meas_im_fill_rel_iLevel( &i_level->v_ilev7, &i_level->ilev7, filter, 7 );
#if !defined (NTRACE)
meas_im_trace_i_level( filter, i_level );
#endif /* #if !defined (NTRACE) */
} /* meas_im_get_rel_i_level() */
/*
+------------------------------------------------------------------------------
| Function : meas_im_get_drx_period_seconds
+------------------------------------------------------------------------------
| Description :
|
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL ULONG meas_im_get_drx_period_seconds ( void )
{
ULONG t_drx; /* DRX period for the MS */
TRACE_FUNCTION( "meas_im_get_drx_period_seconds" );
if( grr_is_pbcch_present( ) EQ TRUE )
{
if( grr_is_non_drx_mode( ) )
{
t_drx = DRX_NORM_FACTOR / BLOCK_PER_MF;
}
else
{
t_drx = ( DRX_NORM_FACTOR * PAGING_CYCLE ) / grr_data->ms.split_pg_cycle;
}
t_drx *= ( USEC_PER_MF / MEAS_ACRCY );
}
else
{
if( meas_is_spgc_ccch_supported( ) )
{
if( grr_is_non_drx_mode( ) )
{
t_drx = DRX_NORM_FACTOR / DRX_DENOMINATOR_FOR_CCCH;
}
else
{
t_drx = ( DRX_NORM_FACTOR * PAGING_CYCLE ) / grr_data->ms.split_pg_cycle;
}
}
else
{
t_drx = DRX_NORM_FACTOR *
( psc_db->net_ctrl.bs_pa_mfrms + BS_PA_MFRMS_OFFSET );
}
t_drx *= ( USEC_PER_CS_MF / MEAS_ACRCY );
}
return( t_drx );
} /* meas_im_get_drx_period_seconds() */
/*
+------------------------------------------------------------------------------
| Function : meas_im_get_drx_period_frames
+------------------------------------------------------------------------------
| Description :
|
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL USHORT meas_im_get_drx_period_frames ( void )
{
ULONG frames;
TRACE_FUNCTION( "meas_im_get_drx_period_frames" );
frames = meas_im_get_drx_period_seconds( ) * N_MSEC_PER_FRAME;
frames = M_ROUND_UP( frames, Z_MSEC_PER_FRAME * DRX_NORM_FACTOR );
return( ( USHORT )frames );
} /* meas_im_get_drx_period_frames() */
/*
+------------------------------------------------------------------------------
| Function : meas_im_get_abs_i_level
+------------------------------------------------------------------------------
| Description : This function returns the interference level values mapped to
| values as defined for RXLEV. It returns the number of bits
| occupied within the measurement report.
|
| Parameters : *ma - Ptr to frequency information in MA format
| *i_level - Ptr to absolute interference level values
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE meas_im_get_abs_i_level ( T_MEAS_IM_CARRIER *ma,
T_ilev_abs *i_level )
{
UBYTE used_bits;
T_MEAS_IM_FILTER *filter; /* filter */
TRACE_FUNCTION( "meas_im_get_abs_i_level" );
filter = meas_im_get_filter( ma );
used_bits =
meas_im_fill_abs_iLevel( &i_level->v_ilevabs0, &i_level->ilevabs0, filter, 0 );
used_bits +=
meas_im_fill_abs_iLevel( &i_level->v_ilevabs1, &i_level->ilevabs1, filter, 1 );
used_bits +=
meas_im_fill_abs_iLevel( &i_level->v_ilevabs2, &i_level->ilevabs2, filter, 2 );
used_bits +=
meas_im_fill_abs_iLevel( &i_level->v_ilevabs3, &i_level->ilevabs3, filter, 3 );
used_bits +=
meas_im_fill_abs_iLevel( &i_level->v_ilevabs4, &i_level->ilevabs4, filter, 4 );
used_bits +=
meas_im_fill_abs_iLevel( &i_level->v_ilevabs5, &i_level->ilevabs5, filter, 5 );
used_bits +=
meas_im_fill_abs_iLevel( &i_level->v_ilevabs6, &i_level->ilevabs6, filter, 6 );
used_bits +=
meas_im_fill_abs_iLevel( &i_level->v_ilevabs7, &i_level->ilevabs7, filter, 7 );
#if !defined (NTRACE)
meas_im_trace_i_level( filter, ( T_ilev* )i_level );
#endif /* #if !defined (NTRACE) */
return( used_bits );
} /* meas_im_get_abs_i_level() */
/*
+------------------------------------------------------------------------------
| Function : meas_im_set_carrier
+------------------------------------------------------------------------------
| 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 :
|
+------------------------------------------------------------------------------
*/
GLOBAL void meas_im_set_carrier ( T_MEAS_IM_CARRIER *carrier,
T_p_frequency_par *freq_par )
{
TRACE_FUNCTION( "meas_im_set_carrier" );
if( freq_par->p_chan_sel.hopping )
{
UBYTE i;
UBYTE bit_shift;
USHORT array_idx;
USHORT arfcn;
carrier->hopping = TRUE;
carrier->alloc.hop_param.hsn = ( freq_par->p_chan_sel.p_rf_ch.arfcn >> 8 );
carrier->alloc.hop_param.maio = ( freq_par->p_chan_sel.p_rf_ch.arfcn & 0x00FF );
memset( carrier->alloc.hop_param.arfcn_bit_field,
0, MAX_IM_HOP_ARFCN_BIT_FIELD_SIZE );
for( i = 0; i < freq_par->p_freq_list.p_rf_chan_cnt; i++ )
{
arfcn = freq_par->p_freq_list.p_rf_chan_no.p_radio_freq[i];
switch( std )
{
case STD_1900: arfcn -= LOW_CHANNEL_1900; break;
case STD_1800: arfcn -= LOW_CHANNEL_1800; break;
default : break;
}
array_idx = arfcn / 8;
bit_shift = ( UBYTE )( arfcn % 8 );
if( array_idx < MAX_IM_HOP_ARFCN_BIT_FIELD_SIZE )
{
carrier->alloc.hop_param.arfcn_bit_field[array_idx] |=
( 0x01 << bit_shift );
}
else
{
TRACE_ERROR( "meas_im_set_carrier: array_idx >= MAX_IM_HOP_ARFCN_BIT_FIELD_SIZE" );
}
}
}
else
{
carrier->hopping = FALSE;
carrier->alloc.arfcn = freq_par->p_chan_sel.p_rf_ch.arfcn;
}
#if !defined (NTRACE)
if( grr_data->meas_im.n_im_trace & M_IM_TRACE_FREQUENCY )
{
if( carrier->hopping )
{
ULONG arfcn[4];
ULONG freq[4];
arfcn[0] = ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[0] << 0;
arfcn[0] |= ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[1] << 8;
arfcn[0] |= ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[2] << 16;
arfcn[0] |= ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[3] << 24;
arfcn[1] = ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[4] << 0;
arfcn[1] |= ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[5] << 8;
arfcn[1] |= ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[6] << 16;
arfcn[1] |= ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[7] << 24;
arfcn[2] = ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[8] << 0;
arfcn[2] |= ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[9] << 8;
arfcn[2] |= ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[10] << 16;
arfcn[2] |= ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[11] << 24;
arfcn[3] = ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[12] << 0;
arfcn[3] |= ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[13] << 8;
arfcn[3] |= ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[14] << 16;
arfcn[3] |= ( ULONG )carrier->alloc.hop_param.arfcn_bit_field[15] << 24;
freq[0] = ( ULONG )freq_par->p_freq_list.p_rf_chan_no.p_radio_freq[0] << 16;
freq[0] |= ( ULONG )freq_par->p_freq_list.p_rf_chan_no.p_radio_freq[1] << 0;
freq[1] = ( ULONG )freq_par->p_freq_list.p_rf_chan_no.p_radio_freq[2] << 16;
freq[1] |= ( ULONG )freq_par->p_freq_list.p_rf_chan_no.p_radio_freq[3] << 0;
freq[2] = ( ULONG )freq_par->p_freq_list.p_rf_chan_no.p_radio_freq[4] << 16;
freq[2] |= ( ULONG )freq_par->p_freq_list.p_rf_chan_no.p_radio_freq[5] << 0;
freq[3] = ( ULONG )freq_par->p_freq_list.p_rf_chan_no.p_radio_freq[6] << 16;
freq[3] |= ( ULONG )freq_par->p_freq_list.p_rf_chan_no.p_radio_freq[7] << 0;
TRACE_EVENT_P9( "meas_im_get_trns_freq: %08X%08X%08X%08X Num: %d Freq: %08X %08X %08X %08X",
arfcn[3], arfcn[2], arfcn[1], arfcn[0],
freq_par->p_freq_list.p_rf_chan_cnt,
freq[0], freq[1], freq[2], freq[3] );
}
else
{
TRACE_EVENT_P1( "meas_im_get_trns_freq: %d", carrier->alloc.arfcn );
}
}
#endif /* #if !defined (NTRACE) */
} /* meas_im_set_carrier() */
/*
+------------------------------------------------------------------------------
| Function : meas_prepare_and_start_idle
+------------------------------------------------------------------------------
| Description : ...
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void meas_prepare_and_start_idle ( void )
{
TRACE_FUNCTION( "meas_prepare_and_start_idle" );
meas_im_cgrlc_int_level_req( TRUE );
switch( GET_STATE( MEAS ) )
{
case MEAS_IDLE:
if ( grr_data->meas_im.mode EQ IM_MODE_IDLE_TRANSFER OR
grr_data->meas_im.mode EQ IM_MODE_IDLE )
{
meas_im_prepare_idle( );
switch( GET_STATE( MEAS_IM ) )
{
case MEAS_IM_NULL:
{
if( meas_im_start_idle( ) )
{
SET_STATE( MEAS_IM, MEAS_IM_START );
}
}
break;
default:
/* do nothing */
break;
}
}
break;
default:
/* do nothing */
break;
}
} /* meas_prepare_and_start_idle() */
/*
+------------------------------------------------------------------------------
| Function : meas_prepare_and_stop_idle
+------------------------------------------------------------------------------
| Description : ...
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void meas_prepare_and_stop_idle ( void )
{
TRACE_FUNCTION( "meas_prepare_and_stop_idle" );
switch( GET_STATE( MEAS ) )
{
case MEAS_IDLE:
{
meas_im_prepare_idle( );
}
break;
default:
/* do nothing */
break;
}
} /* meas_prepare_and_stop_idle() */
/*==== SIGNAL FUNCTIONS =====================================================*/
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_start
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CTRL_MEAS_START
|
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_start ( void )
{
TRACE_ISIG( "sig_ctrl_meas_start" );
/* process the extended measurement service */
if( psc_db->is_ext_psi5_valid EQ TRUE )
{
sig_ctrl_meas_ext_valid_psi5( );
}
/* process the interference measurement service */
sig_ctrl_meas_int_list_valid( );
} /* sig_ctrl_meas_start() */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_stop
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CTRL_MEAS_STOP
|
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_stop ( void )
{
UBYTE state = GET_STATE( MEAS );
TRACE_ISIG( "sig_ctrl_meas_stop" );
/* process the interference measurement service */
switch( state )
{
case MEAS_ACCESS:
case MEAS_TRANSFER:
{
meas_im_stop_trns( );
SET_STATE( MEAS_IM, MEAS_IM_NULL );
}
break;
case MEAS_IDLE:
{
switch( GET_STATE( MEAS_IM ) )
{
case MEAS_IM_START:
{
meas_im_stop_idle( );
SET_STATE( MEAS_IM, MEAS_IM_STOP_REQ );
}
break;
case MEAS_IM_NULL:
SET_STATE( MEAS_IM, MEAS_IM_NULL );
break;
default:
TRACE_ERROR( "SIG_CTRL_MEAS_STOP unexpected INT MEAS 1" );
break;
}
}
break;
default:
/* do nothing */;
break;
}
/* process the extended measurement service */
switch( state )
{
case MEAS_NULL:
case MEAS_IDLE:
case MEAS_ACCESS:
case MEAS_TRANSFER:
switch( GET_STATE( MEAS_EM ) )
{
case MEAS_EM_REP_REQ:
meas_em_stop_req( );
break;
case MEAS_EM_PMR_SENDING:
case MEAS_EM_PENDING:
SET_STATE( MEAS_EM, MEAS_EM_NULL );
break;
default:
TRACE_ERROR( "SIG_CTRL_MEAS_STOP unexpected EXT MEAS 1" );
break;
}
if( grr_t_status( T3178) NEQ 0 )
{
vsi_t_stop( GRR_handle, T3178);
TRACE_EVENT( "Timer T3178 stopped" );
}
break;
default:
TRACE_ERROR( "SIG_CTRL_MEAS_STOP unexpected EXT MEAS 2" );
break;
}
/* process the signal quality service */
if( state EQ MEAS_TRANSFER )
{
RX_SetRxQual( RX_QUAL_UNAVAILABLE );
}
SET_STATE( MEAS, MEAS_NULL );
} /* sig_ctrl_meas_stop() */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_suspend
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CTRL_MEAS_SUSPEND
| This signal suspends the measurement service
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_suspend ( void )
{
TRACE_ISIG( "sig_ctrl_meas_suspend" );
/* process the interference measurement service */
switch( GET_STATE( MEAS ) )
{
case MEAS_IDLE:
case MEAS_ACCESS:
case MEAS_TRANSFER:
{
switch( GET_STATE( MEAS_IM ) )
{
case MEAS_IM_START:
{
meas_im_stop_idle( );
grr_data->meas_im.trig_signal = IM_TRIG_SIGNAL_PAUSE;
SET_STATE( MEAS_IM, MEAS_IM_STOP_REQ );
}
break;
default:
/* do nothing */
break;
}
}
break;
default:
/* do nothing */
break;
}
/* process the extended measurement service */
switch( GET_STATE( MEAS ) )
{
case MEAS_IDLE:
case MEAS_ACCESS:
case MEAS_TRANSFER:
SET_STATE( MEAS_EM, MEAS_EM_SUSPEND );
meas_em_process_t3178( );
break;
default:
/* do nothing */
break;
}
} /* sig_ctrl_meas_suspend() */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_resume
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CTRL_MEAS_RESUME
| This signal resumes the measurement service
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_resume ( void )
{
TRACE_ISIG( "sig_ctrl_meas_resume" );
/* process the interference measurement service */
switch( GET_STATE( MEAS ) )
{
case MEAS_IDLE:
case MEAS_ACCESS:
case MEAS_TRANSFER:
if ( grr_data->meas_im.mode EQ IM_MODE_IDLE_TRANSFER OR
grr_data->meas_im.mode EQ IM_MODE_IDLE )
{
if( meas_im_start_idle( ) )
{
SET_STATE( MEAS_IM, MEAS_IM_START );
}
else
{
SET_STATE( MEAS_IM, MEAS_IM_NULL );
}
break;
}
break;
default:
/* do nothing */
break;
}
/* process the extended measurement service */
switch( GET_STATE( MEAS ) )
{
case MEAS_IDLE:
case MEAS_ACCESS:
case MEAS_TRANSFER:
SET_STATE( MEAS_EM, MEAS_EM_NULL );
meas_em_process_t3178( );
break;
default:
/* do nothing */
break;
}
} /* sig_ctrl_meas_resume() */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_pim
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CTRL_MEAS_PIM
|
| Parameters : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_pim ( void )
{
UBYTE state = GET_STATE( MEAS );
TRACE_ISIG( "sig_ctrl_meas_pim" );
/* process the interference measurement service */
switch( state )
{
case MEAS_TRANSFER:
meas_im_state_changed( MEAS_IDLE );
/*lint -fallthrough*/
case MEAS_ACCESS:
meas_im_stop_trns( );
SET_STATE( MEAS_IM, MEAS_IM_NULL );
if ( grr_data->meas_im.mode EQ IM_MODE_IDLE_TRANSFER OR
grr_data->meas_im.mode EQ IM_MODE_IDLE )
{
meas_im_prepare_idle( );
if( meas_im_start_idle( ) )
{
SET_STATE( MEAS_IM, MEAS_IM_START );
}
}
break;
default:
/* do nothing */
break;
}
/* process the extended measurement service */
switch( state )
{
case MEAS_ACCESS:
case MEAS_TRANSFER:
{
if( GET_STATE( MEAS_EM ) EQ MEAS_EM_PENDING )
{
meas_em_start( );
SET_STATE( MEAS_EM, MEAS_EM_REP_REQ );
}
}
break;
default:
/* do nothing */
break;
}
/* process the signal quality service */
if( state EQ MEAS_TRANSFER )
{
RX_SetRxQual( RX_QUAL_UNAVAILABLE );
}
SET_STATE( MEAS, MEAS_IDLE );
} /* sig_ctrl_meas_pim() */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_pam
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CTRL_MEAS_PAM
|
| Parameters : dummy - description of parameter dummy
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_pam ( void )
{
UBYTE state = GET_STATE( MEAS );
TRACE_ISIG( "sig_ctrl_meas_pam" );
/* process the interference measurement service */
switch( state )
{
case MEAS_IDLE:
{
switch( GET_STATE( MEAS_IM ) )
{
case MEAS_IM_START:
{
meas_im_stop_idle( );
grr_data->meas_im.trig_signal = IM_TRIG_SIGNAL_PAM;
SET_STATE( MEAS_IM, MEAS_IM_STOP_REQ );
}
break;
case MEAS_IM_NULL:
{
if ( grr_data->meas_im.mode EQ IM_MODE_IDLE_TRANSFER OR
grr_data->meas_im.mode EQ IM_MODE_TRANSFER )
{
meas_im_prepare_trns( );
meas_im_start_trns( );
SET_STATE( MEAS_IM, MEAS_IM_START );
}
}
break;
default:
TRACE_ERROR( "SIG_CTRL_MEAS_PAM unexpected" );
break;
}
}
break;
case MEAS_TRANSFER:
meas_im_state_changed( MEAS_ACCESS );
break;
default:
/* do nothing */
break;
}
/* process the extended measurement service */
switch( state )
{
case MEAS_IDLE:
{
switch( GET_STATE( MEAS_EM ) )
{
case MEAS_EM_REP_REQ:
meas_em_stop_req( );
SET_STATE( MEAS_EM, MEAS_EM_PENDING );
break;
default:
/* do nothing */
break;
}
}
break;
default:
TRACE_ERROR( "SIG_CTRL_MEAS_PAM unexpected, EXT MEAS 2" );
break;
}
/* process the signal quality service */
if( state EQ MEAS_TRANSFER )
{
RX_SetRxQual( RX_QUAL_UNAVAILABLE );
}
SET_STATE( MEAS, MEAS_ACCESS );
} /* sig_ctrl_meas_pam() */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_ptm
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CTRL_MEAS_PTM
|
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_ptm ( void )
{
TRACE_ISIG( "sig_ctrl_meas_ptm" );
switch( GET_STATE( MEAS ) )
{
case MEAS_IDLE:
case MEAS_ACCESS:
meas_im_state_changed( MEAS_TRANSFER );
break;
default:
/* do nothing */
break;
}
SET_STATE( MEAS, MEAS_TRANSFER );
} /* sig_ctrl_meas_ptm() */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_int_list_invalid
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CTRL_MEAS_INT_LIST_INVALID
| If this signal is received then the list for interfrence
| measurements are invalid
| and interference measurements shall be stopped, if running
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_int_list_invalid ( void )
{
TRACE_ISIG( "sig_ctrl_meas_int_list_invalid" );
meas_prepare_and_stop_idle( );
} /* sig_ctrl_meas_int_list_invalid() */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_int_list_valid
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CTRL_MEAS_INT_LIST_VALID
| If this signal is received then the list for interfrence
| measurements are valid
| and interference measurements could be started, refreshed etc.
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_int_list_valid ( void )
{
TRACE_ISIG( "sig_ctrl_meas_int_list_valid" );
meas_prepare_and_start_idle( );
} /* sig_ctrl_meas_int_list_valid() */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_ext_invalid_psi5
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CTRL_MEAS_EXT_INVALID_PSI5
| If this signal is received then the list for extended
| measurements are invalid
| and interference measurements could be stopped, if already running
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_ext_invalid_psi5 ( void )
{
TRACE_ISIG( "sig_ctrl_meas_ext_invalid_psi5" );
switch( GET_STATE( MEAS ) )
{
case MEAS_NULL:
case MEAS_IDLE:
case MEAS_ACCESS:
case MEAS_TRANSFER:
if( !meas_em_is_valid_pmo_present( ) )
{
meas_em_valid_psi5( );
switch( GET_STATE( MEAS_EM ) )
{
case MEAS_EM_REP_REQ:
meas_em_stop_req( );
break;
default:
SET_STATE( MEAS_EM, MEAS_NULL );
break;
}
}
break;
default:
TRACE_ERROR( "SIG_CTRL_MEAS_EXT_INVALID_PSI5 unexpected" );
break;
}
} /* sig_ctrl_meas_ext_invalid_psi5() */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_ext_valid_psi5
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CTRL_MEAS_EXT_VALID_PSI5
| If this signal is received then the list for extended
| measurements are valid
| and interference measurements could performed
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_ext_valid_psi5 ( void )
{
TRACE_ISIG( "sig_ctrl_meas_ext_valid_psi5" );
switch( GET_STATE( MEAS ) )
{
case MEAS_IDLE:
if( !meas_em_is_valid_pmo_present( ) )
{
switch( GET_STATE( MEAS_EM ) )
{
case MEAS_EM_REP_REQ:
meas_em_stop_req( );
/*lint -fallthrough*/
case MEAS_EM_NULL:
meas_em_valid_psi5( );
meas_em_process_t3178( );
break;
default:
TRACE_ERROR( "SIG_CTRL_MEAS_EXT_VALID_PSI5 unexpected 1" );
break;
}
}
break;
case MEAS_NULL:
case MEAS_ACCESS:
case MEAS_TRANSFER:
if( !meas_em_is_valid_pmo_present( ) )
{
/* measurement report parameters of PSI5 shall only be taken into */
/* account in case there is no individually parameter set send to */
/* the MS using a Packet Measurement Order message */
meas_em_valid_psi5( );
meas_em_process_t3178( );
}
break;
default:
TRACE_ERROR( "SIG_CTRL_MEAS_EXT_VALID_PSI5 unexpected 2" );
break;
}
} /* sig_ctrl_meas_ext_valid_psi5() */
/*
+------------------------------------------------------------------------------
| Function : sig_cs_meas_start
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CS_MEAS_START
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_cs_meas_start ( void )
{
TRACE_ISIG( "sig_cs_meas_start" );
grr_data->meas_im.v_cs_meas_active = TRUE;
meas_prepare_and_start_idle( );
} /* sig_cs_meas_start() */
/*
+------------------------------------------------------------------------------
| Function : sig_cs_meas_stop
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CS_MEAS_STOP
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_cs_meas_stop ( void )
{
TRACE_ISIG( "sig_cs_meas_stop" );
grr_data->meas_im.v_cs_meas_active = FALSE;
meas_prepare_and_stop_idle( );
} /* sig_cs_meas_stop() */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_pmr_accept
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CTRL_MEAS_PMR_ACCEPT
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_pmr_accept ( void )
{
TRACE_ISIG( "sig_ctrl_meas_pmr_accept" );
switch( GET_STATE( MEAS_EM ) )
{
case( MEAS_EM_PMR_SENDING ):
if( meas_em_send_meas_rpt( FALSE ) EQ FALSE )
{
SET_STATE( MEAS_EM, MEAS_EM_NULL );
meas_em_process_t3178( );
}
break;
default:
TRACE_ERROR( "SIG_CTRL_MEAS_PMR_ACCEPT unexpected" );
break;
}
} /* sig_ctrl_meas_pmr_accept() */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_pmr_reject
+------------------------------------------------------------------------------
| Description : Handles the internal signal SIG_CTRL_MEAS_PMR_REJECT
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_pmr_reject ( void )
{
TRACE_ISIG( "sig_ctrl_meas_pmr_reject" );
switch( GET_STATE( MEAS_EM ) )
{
case( MEAS_EM_PMR_SENDING ):
SET_STATE( MEAS_EM, MEAS_EM_NULL );
meas_em_process_t3178( );
break;
default:
TRACE_ERROR( "SIG_CTRL_MEAS_PMR_REJECT unexpected" );
break;
}
} /* sig_ctrl_meas_pmr_reject() */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_ext_meas_cnf
+------------------------------------------------------------------------------
| Description : ...
|
| Parameters : ...
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_ext_meas_cnf
( T_RRGRR_EXT_MEAS_CNF *rrgrr_ext_meas_cnf )
{
TRACE_ISIG( "sig_ctrl_meas_ext_meas_cnf" );
switch( GET_STATE( MEAS ) )
{
case MEAS_IDLE:
case MEAS_ACCESS:
case MEAS_TRANSFER:
switch( GET_STATE( MEAS_EM ) )
{
case( MEAS_EM_REP_REQ ):
if( meas_em_store_rslt( rrgrr_ext_meas_cnf ) EQ TRUE )
{
SET_STATE( MEAS_EM, MEAS_EM_PMR_SENDING );
if( meas_em_send_meas_rpt( TRUE ) EQ FALSE )
{
/*
* The additional state check is necessary because signals
* might be send during the processing of the function
* meas_em_send_meas_rpt.
*/
if( GET_STATE( MEAS_EM ) EQ MEAS_EM_PMR_SENDING )
{
SET_STATE( MEAS_EM, MEAS_NULL );
meas_em_process_t3178( );
}
}
}
else
{
SET_STATE( MEAS_EM, MEAS_NULL );
meas_em_process_t3178( );
}
break;
default:
TRACE_EVENT( "SIG_CTRL_MEAS_EXT_MEAS_CNF unexpected 1" );
break;
}
break;
default:
TRACE_EVENT( "SIG_CTRL_MEAS_EXT_MEAS_CNF unexpected 2" );
break;
}
} /* sig_ctrl_meas_ext_meas_cnf() */
/*
+------------------------------------------------------------------------------
| Function : sig_gfp_meas_order
+------------------------------------------------------------------------------
| Description : Handles the signal SIG_GFP_MEAS_ORDER
|
| Parameters : -
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_gfp_meas_order ( void )
{
MCAST( d_meas_order, D_MEAS_ORDER );
TRACE_ISIG( "sig_gfp_meas_order" );
if (grr_data->nc2_on)
{
meas_p_meas_order_ind(d_meas_order);
}
else
{
TRACE_EVENT( "PACKET MEASUREMENT ORDER RECEIVED,but NC2 is deactivated" );
}
} /* sig_gfp_meas_order() */
/*
+------------------------------------------------------------------------------
| Function : sig_gfp_meas_int_meas_stop_con
+------------------------------------------------------------------------------
| Description : Handles the signal SIG_GFP_MEAS_INT_MEAS_STOP_CON
|
| Parameters : *dummy - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_gfp_meas_int_meas_stop_con ( T_MPHP_INT_MEAS_STOP_CON * dummy )
{
TRACE_ISIG( "sig_gfp_meas_int_meas_stop_con" );
switch( GET_STATE( MEAS ) )
{
case MEAS_NULL:
case MEAS_IDLE:
case MEAS_ACCESS:
case MEAS_TRANSFER:
{
switch( GET_STATE( MEAS_IM ) )
{
case MEAS_IM_STOP_REQ:
{
if( grr_data->meas_im.trig_signal EQ IM_TRIG_SIGNAL_PAM )
{
meas_im_prepare_trns( );
}
SET_STATE( MEAS_IM, MEAS_IM_NULL );
grr_data->meas_im.trig_signal = IM_TRIG_SIGNAL_NULL;
}
break;
default:
TRACE_ERROR( "SIG_GFP_MEAS_INT_MEAS_STOP_CON unexpected 1" );
break;
}
}
break;
default:
TRACE_ERROR( "SIG_GFP_MEAS_INT_MEAS_STOP_CON unexpected 2" );
break;
}
} /* sig_gfp_meas_int_meas_stop_con() */
/*
+------------------------------------------------------------------------------
| Function : sig_gfp_meas_int_meas_ind
+------------------------------------------------------------------------------
| Description : Handles the signal sig_gfp_meas_int_meas_ind
|
| Parameters : *mphp_int_meas_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_gfp_meas_int_meas_ind ( T_MPHP_INT_MEAS_IND *mphp_int_meas_ind )
{
UBYTE state = GET_STATE( MEAS );
TRACE_ISIG( "sig_gfp_meas_int_meas_ind" );
switch( state )
{
case MEAS_ACCESS:
case MEAS_TRANSFER:
meas_im_new_value( mphp_int_meas_ind, state );
break;
case MEAS_IDLE:
{
switch( GET_STATE( MEAS_IM ) )
{
case MEAS_IM_START:
meas_im_new_value( mphp_int_meas_ind, state );
break;
case MEAS_IM_STOP_REQ:
/* do nothing */
break;
default:
TRACE_ERROR( "SIG_GFP_MEAS_INT_MEAS_IND unexpected 1" );
break;
}
}
break;
default:
TRACE_ERROR( "SIG_GFP_MEAS_INT_MEAS_IND unexpected 2" );
break;
}
} /* sig_gfp_meas_int_meas_ind() */
#if !defined (NTRACE)
/*
+------------------------------------------------------------------------------
| Function : meas_im_trace_i_level
+------------------------------------------------------------------------------
| Description :
|
| Parameters :
|
+------------------------------------------------------------------------------
*/
LOCAL void meas_im_trace_i_level( T_MEAS_IM_FILTER *filter,
T_ilev *i_level )
{
TRACE_ISIG( "meas_im_trace_i_level" );
if( grr_data->meas_im.n_im_trace & M_IM_TRACE_OUTPUT_VALUE )
{
if( filter NEQ NULL )
{
TRACE_EVENT_P8( "meas_im_trace_i_level: %02X %02X %02X %02X %02X %02X %02X %02X",
i_level->ilev0, i_level->ilev1, i_level->ilev2,
i_level->ilev3, i_level->ilev4, i_level->ilev5,
i_level->ilev6, i_level->ilev7 );
}
else
{
TRACE_EVENT( "meas_im_trace_i_level: filter EQ NULL" );
}
}
} /* meas_im_trace_i_level() */
#endif /* #if !defined (NTRACE) */
/*
+------------------------------------------------------------------------------
| Function : sig_ctrl_meas_ba_changed
+------------------------------------------------------------------------------
| Description : Handles the signal SIG_CTRL_MEAS_BA_CHANGED
|
| Parameters :
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_ctrl_meas_ba_changed ( void )
{
TRACE_ISIG( "sig_ctrl_meas_ba_changed" );
switch( GET_STATE( MEAS ) )
{
case MEAS_IDLE:
case MEAS_ACCESS:
case MEAS_TRANSFER:
psc_db->nc_ms.ncmeas.list.number = 0;
psc_db->nc_ms.rfreq.number = 0;
psc_db->nc_ms.ncmeas.list.chng_mrk.curr++;
break;
default:
TRACE_ERROR( "SIG_CTRL_MEAS_BA_CHANGED unexpected" );
break;
}
} /* sig_ctrl_meas_ba_changed() */
/*
+------------------------------------------------------------------------------
| Function : sig_gfp_meas_rxlev_pccch_ind
+------------------------------------------------------------------------------
| Description : Handles the signal SIG_GFP_MEAS_RXLEV_PCCCH_IND
|
| Parameters : pccch_lev - signal level received on pccch
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_gfp_meas_rxlev_pccch_ind( UBYTE pccch_lev )
{
TRACE_ISIG( "sig_gfp_meas_rxlev_pccch_ind" );
switch( GET_STATE( MEAS ) )
{
case MEAS_IDLE:
case MEAS_ACCESS:
meas_c_val_update_pim( pccch_lev );
grr_cgrlc_pwr_ctrl_req( TRUE );
break;
default:
TRACE_ERROR( "SIG_GFP_MEAS_RXLEV_PCCCH_IND unexpected" );
break;
}
} /* sig_gfp_meas_rxlev_pccch_ind() */
/*
+------------------------------------------------------------------------------
| Function : sig_gfp_meas_ctrl_pwr_ta_ptm
+------------------------------------------------------------------------------
| Description : Handles the signal SIG_GFP_MEAS_CTRL_PWR_TA_PTM
|
| Parameters : -
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_gfp_meas_ctrl_pwr_ta_ptm ( void )
{
MCAST( d_ctrl_pwr_ta, D_CTRL_PWR_TA );
TRACE_ISIG( "sig_gfp_meas_ctrl_pwr_ta_ptm" );
switch( GET_STATE( MEAS ) )
{
case MEAS_TRANSFER:
if( d_ctrl_pwr_ta->v_gpta )
{
sig_meas_tc_update_ta_req( );
}
{
UBYTE pb;
pb = psc_db->g_pwr_par.pb;
meas_handle_pwr_par( );
if( pb NEQ psc_db->g_pwr_par.pb )
{
grr_update_pacch();
}
}
break;
default:
TRACE_ERROR( "SIG_GFP_MEAS_CTRL_PWR_TA_PTM unexpected" );
break;
}
} /* sig_gfp_meas_ctrl_pwr_ta_ptm() */
/*
+------------------------------------------------------------------------------
| Function : sig_tc_meas_update_pch
+------------------------------------------------------------------------------
| Description : ...
|
| Parameters : ...
|
+------------------------------------------------------------------------------
*/
GLOBAL void sig_tc_meas_update_pch ( void )
{
TRACE_ISIG( "sig_tc_meas_update_pch" );
grr_cgrlc_pwr_ctrl_req( FALSE );
} /* sig_tc_meas_update_pch() */
/*
+------------------------------------------------------------------------------
| Function : meas_c_get_value
+------------------------------------------------------------------------------
| Description : This function returns the current C value.
|
| Parameters : void
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE meas_c_get_value ( void )
{
UBYTE c_value;
TRACE_FUNCTION( "meas_c_get_value" );
if( grr_data->meas.c_filter.index > 0 )
{
c_value = ( M_ROUND_UP( grr_data->meas.c_filter.value, MEAS_ACRCY ) );
}
else
{
#ifdef _SIMULATION_
TRACE_ERROR( "meas_c_get_value: grr_data->meas.c_filter.index EQ 0" );
#endif /* #ifdef _SIMULATION_ */
c_value = C_VALUE_DEFAULT;
}
return( c_value );
} /* meas_c_get_value() */
/*
+------------------------------------------------------------------------------
| Function : meas_c_get_c_value
+------------------------------------------------------------------------------
| Description :
|
| Parameters :
|
+------------------------------------------------------------------------------
*/
GLOBAL void meas_c_get_c_value ( T_CGRLC_c_value *c_value )
{
TRACE_FUNCTION( "meas_c_get_c_value" );
c_value->c_acrcy = MEAS_ACRCY;
c_value->c_lev = grr_data->meas.c_filter.value;
c_value->c_idx = grr_data->meas.c_filter.index;
} /* meas_c_get_c_value() */
/*
+------------------------------------------------------------------------------
| Function : meas_c_set_c_value
+------------------------------------------------------------------------------
| Description :
|
| Parameters :
|
+------------------------------------------------------------------------------
*/
GLOBAL void meas_c_set_c_value ( T_CGRLC_c_value *c_value )
{
TRACE_FUNCTION( "meas_c_set_c_value" );
grr_data->meas.c_filter.value = ( c_value->c_lev * MEAS_ACRCY ) /
c_value->c_acrcy;
grr_data->meas.c_filter.index = c_value->c_idx;
} /* meas_c_set_c_value() */