--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/g23m-gprs/grlc/grlc_meass.c	Fri Oct 16 06:25:50 2020 +0000
@@ -0,0 +1,767 @@
+/* 
++----------------------------------------------------------------------------- 
+|  Project :  GPRS (8441)
+|  Modul   :  GRLC
++----------------------------------------------------------------------------- 
+|  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 GRLC.
++----------------------------------------------------------------------------- 
+*/ 
+
+#ifndef GRLC_MEASS_C
+#define GRLC_MEASS_C
+#endif /* #ifndef GRLC_MEASS_C */
+
+#define ENTITY_GRLC
+
+/*==== INCLUDES =============================================================*/
+
+#include "typedefs.h"
+#include "vsi.h"
+#include "macdef.h"
+#include "gprs.h"
+#include "gsm.h"
+#include "ccdapi.h"
+#include "prim.h"
+#include "message.h"
+#include "grlc.h"
+#include "grlc_meass.h"   
+#include "grlc_measf.h"
+#include "cl_rlcmac.h"
+
+/*==== CONST ================================================================*/
+
+#define MEAS_MAX_NUM_MEAN     1000   /* maximum numbers of element considered for    */
+                                     /* calculating the mean                         */
+/* maybe for later use */
+/* 
+#define M_ROUND_UP(x,meas_acrcy) (((x)>=0)?                                        \
+                                  ((((x)%(meas_acrcy))< ((meas_acrcy)/ 2))?        \
+                                   ( (x)/(meas_acrcy)   ):(((x)/(meas_acrcy))+1)): \
+                                  ((((x)%(meas_acrcy))<=((meas_acrcy)/-2))?        \
+                                   (((x)/(meas_acrcy))-1):( (x)/(meas_acrcy)   )))
+*/
+
+#define M_ROUND_UP(x,meas_acrcy)  ((((x)%(meas_acrcy))< ((meas_acrcy)/ 2))?        \
+                                   ( (x)/(meas_acrcy)   ):(((x)/(meas_acrcy))+1))
+
+#define MEAS_C_INC_INDEX(index) {                                        \
+                                  if( index < (T_C_INDEX)(~0) ) index++; \
+                                }
+
+#define NORM_FFB_MAX   (ULONG)100000 /* normalised forgetting factor b maximum value */
+#define NORM_FFC_MAX   (ULONG)500000 /* normalised forgetting factor c maximum value */
+#define NORM_FFB_DIV   (ULONG)10     /* normalised forgetting factor b divisor value */
+#define NORM_FFC_DIV   (ULONG)20     /* normalised forgetting factor c divisor value */
+
+#define SV_ACRCY_DIV   (ULONG)10     /* signal variance accuracy divisor             */
+
+#define C_VALUE_IDX_DEFAULT  0
+#define C_VALUE_DEFAULT      0
+#define SV_VALUE_DEFAULT     0
+#define RXQUAL_VALUE_DEFAULT 0
+
+#define SV_LEVEL_MAX            63
+#define SV_LEVEL_STEP           ((T_SIGN_VAR_VALUE)(MEAS_ACRCY/4))
+                                            /* dB2 step size of the signal   */
+                                            /* variance                      */
+
+/*==== LOCAL VARS ===========================================================*/
+
+/*
+ * normalised forgetting factor b used in context of C value calculation
+ *
+ * NORM_FFB_MAX * ( 1 / ( 6 * t_avg_t ) )
+ */
+LOCAL const ULONG norm_ffb[] = { NORM_FFB_MAX,
+                                 70711, 50000, 35355, 25000, 17678, 12500,
+                                  8839,  6250,  4419,  3125,  2210,  1563,
+                                  1105,   781,   552,   391,   276,   195,
+                                   138,    98,    69,    49,    35,    24,
+                                    17 };
+
+/*
+ * normalised forgetting factor c used in context of C value calculation
+ *
+ * NORM_FFC_MAX * ( 1 / ( 12 * t_avg_t ) )
+ */
+LOCAL const ULONG norm_ffc[] = { NORM_FFC_MAX,
+                                 353553, 250000, 176777, 125000,  88388,  62500,
+                                  44194,  31250,  22097,  15625,  11049,   7813,
+                                   5524,   3906,   2762,   1953,   1381,    977,
+                                    691,    488,    345,    244,    173,    122,
+                                     86 };
+
+/*==== LOCAL TYPES===========================================================*/
+
+#if !defined (NTRACE)
+
+LOCAL void meas_int_trace_i_level( T_ilev *i_level );
+  
+#endif /* #if !defined (NTRACE) */
+
+/*==== PUBLIC FUNCTIONS =====================================================*/
+/*
++------------------------------------------------------------------------------
+| Function    : meas_grlc_init
++------------------------------------------------------------------------------
+| Description : 
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void meas_grlc_init ( void )
+{ 
+  TRACE_FUNCTION( "meas_grlc_init" );
+
+  /* initialization of C value management */
+  meas_c_restart( );
+
+  /* initialization of signal variance management */
+  meas_sv_restart( );
+
+  /* initialization of signal quality management */
+  meas_sq_restart( );
+
+} /* grlc_meas_init() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_rd_meas_qual_rpt_sent
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_RD_MEAS_QUAL_RPT_SENT
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_rd_meas_qual_rpt_sent ( void )
+{ 
+  TRACE_ISIG( "sig_rd_meas_qual_rpt_sent" );
+
+  meas_sv_restart( );
+  
+  grlc_data->meas.sq_restart = TRUE;
+  
+} /* sig_rd_meas_qual_rpt_sent() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_tm_meas_ptm
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_TM_MEAS_PTM
+|               
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_tm_meas_ptm ( void )
+{ 
+  TRACE_ISIG( "sig_tm_meas_ptm" );
+
+  meas_sv_restart( );
+  meas_sq_restart( );
+
+} /* sig_tm_meas_ptm() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : meas_grlc_c_get_value
++------------------------------------------------------------------------------
+| Description : This function returns the current C value.
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL UBYTE meas_grlc_c_get_value ( void )
+{
+  UBYTE c_value;
+
+  TRACE_FUNCTION( "meas_grlc_c_get_value" );
+
+  if( grlc_data->meas.c_filter.index > 0 )
+  {
+    c_value = ( M_ROUND_UP( grlc_data->meas.c_filter.value, MEAS_ACRCY ) );
+  }
+  else
+  {
+
+#ifdef _SIMULATION_
+    TRACE_ERROR( "meas_grlc_c_get_value: grlc_data->meas.c_filter.index EQ 0" );
+#endif /* #ifdef _SIMULATION_ */
+
+    c_value = C_VALUE_DEFAULT;
+  }
+
+  return( c_value );
+
+} /* meas_grlc_c_get_value() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : meas_grlc_c_get_c_value
++------------------------------------------------------------------------------
+| Description : 
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void meas_grlc_c_get_c_value ( T_CGRLC_c_value *c_value )
+{
+  TRACE_FUNCTION( "meas_grlc_c_get_c_value" );
+
+  c_value->c_acrcy = MEAS_ACRCY;
+  c_value->c_lev   = grlc_data->meas.c_filter.value;
+  c_value->c_idx   = grlc_data->meas.c_filter.index;
+
+} /* meas_grlc_c_get_c_value() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : meas_grlc_c_set_c_value
++------------------------------------------------------------------------------
+| Description : 
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void meas_grlc_c_set_c_value ( T_CGRLC_c_value *c_value )
+{
+  TRACE_FUNCTION( "meas_grlc_c_set_c_value" );
+
+  grlc_data->meas.c_filter.value = (c_value->c_lev / c_value->c_acrcy) * 
+									MEAS_ACRCY;
+
+  grlc_data->meas.c_filter.index = c_value->c_idx;
+
+} /* meas_grlc_c_set_c_value() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : meas_c_val_update_ptm 
++------------------------------------------------------------------------------
+| Description : ... 
+|
+| Parameters  : -
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void meas_c_val_update_ptm ( T_MAC_PWR_CTRL_IND          *mac_pwr_ctrl_ind,
+                                    T_CGRLC_glbl_pwr_ctrl_param *pwr_ctrl_param,
+                                    T_CGRLC_freq_param          *freq_param )
+{ 
+  UBYTE       pb_rdc;       /* Pb reduction              */
+  UBYTE       vld_smpl = 0; /* valid measurement samples */
+ 
+  ULONG       ff_value;
+  ULONG       c_value;
+  
+  T_C_FILTER *c_filter = &grlc_data->meas.c_filter;
+
+  TRACE_FUNCTION( "meas_c_val_update_ptm" );
+
+  if( pwr_ctrl_param->pc_meas_chan EQ  CGRLC_MEAS_CHAN_BCCH AND
+      mac_pwr_ctrl_ind->bcch_level NEQ MAC_RXLEV_NONE           )
+  {
+    MEAS_C_INC_INDEX( c_filter->index );
+
+    if( c_filter->index EQ 1 )
+    {
+      c_filter->value = MEAS_ACRCY * mac_pwr_ctrl_ind->bcch_level;
+    }
+    else
+    {
+      /* calculate the forgetting factor */
+      ff_value = norm_ffb[pwr_ctrl_param->t_avg_t];
+
+      /* update the filter */
+      c_value = ( NORM_FFB_MAX - ff_value )       * 
+                ( c_filter->value / NORM_FFB_DIV ) 
+                +
+                ff_value                          * 
+                ( MEAS_ACRCY / NORM_FFB_DIV )     *
+                mac_pwr_ctrl_ind->bcch_level;
+    
+      c_filter->value = (T_C_VALUE)(c_value / (NORM_FFB_MAX / NORM_FFB_DIV));
+    }
+
+#ifdef _SIMULATION_
+    TRACE_EVENT_P2( "C-Value = %d, C-Index = %d", 
+                    c_filter->value, c_filter->index );
+#endif /* #ifdef _SIMULATION_ */
+  }
+  else if( pwr_ctrl_param->pc_meas_chan EQ CGRLC_MEAS_CHAN_PDCH )
+  {
+    vld_smpl = meas_c_calc_mean ( mac_pwr_ctrl_ind->burst_level,
+                                  mac_pwr_ctrl_ind->radio_freq,
+                                  &c_value, &pb_rdc, freq_param );
+
+    if( vld_smpl )
+    {
+      MEAS_C_INC_INDEX( c_filter->index );
+
+      /* consider the BTS output power reduction */
+      c_value -= ( ( 2 * pwr_ctrl_param->pb ) *
+                   ( MEAS_ACRCY * pb_rdc ) / MAC_BURST_PER_BLOCK );
+
+
+      if( c_filter->index EQ 1 )
+      {
+        c_filter->value = (T_C_VALUE)c_value;
+      }
+      else
+      {
+        /* calculate the forgetting factor */
+        ff_value = norm_ffc[pwr_ctrl_param->t_avg_t];
+
+        /* update the filter */
+        c_value = ( NORM_FFC_MAX - ff_value )      *
+                  ( c_filter->value / NORM_FFC_DIV ) 
+                  +
+                  ff_value                         *
+                  ( c_value / NORM_FFC_DIV );
+    
+        c_filter->value = (T_C_VALUE)(c_value / (NORM_FFC_MAX / NORM_FFC_DIV));
+      }
+    }
+    else
+    {
+#ifdef _SIMULATION_
+      TRACE_EVENT( "no valid RXLEV information in meas_c_val_update_ptm 1" );
+#endif /* #ifdef _SIMULATION_ */
+    }
+
+#ifdef _SIMULATION_
+      TRACE_EVENT_P2( "C-Value = %d, C-Index = %d", 
+                      c_filter->value, c_filter->index );
+#endif /* #ifdef _SIMULATION_ */
+  }
+  else
+  {
+#ifdef _SIMULATION_
+    TRACE_EVENT( "no valid RXLEV information in meas_c_val_update_ptm 2" );
+#endif /* #ifdef _SIMULATION_ */
+  }
+} /* meas_c_val_update_ptm() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : meas_c_restart 
++------------------------------------------------------------------------------
+| Description : This function initializes the parameters for deriving the
+|               C value.
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void meas_c_restart ( void )
+{
+  TRACE_FUNCTION( "meas_c_restart" );
+
+  grlc_data->meas.c_filter.value = 0;
+  grlc_data->meas.c_filter.index = 0;
+} /* meas_c_restart() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : meas_sv_get_value
++------------------------------------------------------------------------------
+| Description : This function returns the current signal variance.
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL UBYTE meas_sv_get_value ( void )
+{
+  T_SIGN_VAR_VALUE sv_val; 
+
+  TRACE_FUNCTION( "meas_sv_get_value" );
+
+  sv_val = grlc_data->meas.sign_var.value / SV_LEVEL_STEP;
+
+  if( grlc_data->meas.sign_var.value % SV_LEVEL_STEP EQ  0 AND 
+      grlc_data->meas.sign_var.value                 NEQ 0     )
+  {
+    sv_val -= 1;
+  }
+
+  if( sv_val > SV_LEVEL_MAX )
+  {
+    sv_val = SV_LEVEL_MAX;
+  }
+
+  return( (UBYTE)sv_val );
+} /* meas_sv_get_value() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : meas_sv_update
++------------------------------------------------------------------------------
+| Description : ... 
+|
+| Parameters  : -
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void meas_sv_update ( T_MAC_PWR_CTRL_IND          *mac_pwr_ctrl_ind,
+                             T_CGRLC_glbl_pwr_ctrl_param *pwr_ctrl_param,
+                             T_CGRLC_freq_param          *freq_param )
+{ 
+  T_SIGN_VAR *sign_var = &grlc_data->meas.sign_var;
+
+  UBYTE   i;               /* used for counting                         */
+  UBYTE   ss_on_bcch[MAC_BURST_PER_BLOCK];
+                           /* receive signal level measured on BCCH     */
+  UBYTE   ss_off_bcch[MAC_BURST_PER_BLOCK];
+                           /* receive signal level not measured on BCCH */
+  UBYTE   j    = 0;        /* indicates the number of bursts received   */
+                           /* on BCCH frequency                         */
+  UBYTE  *ss_k = NULL;     /* points to the receive signal levels       */
+
+  TRACE_FUNCTION( "meas_sv_update" );
+
+  /* initialize arrays */
+  for( i = 0; i < MAC_BURST_PER_BLOCK; i++ )
+  {
+    ss_on_bcch [i] = MAC_RXLEV_NONE;
+    ss_off_bcch[i] = MAC_RXLEV_NONE;
+  }
+
+  if( mac_pwr_ctrl_ind->crc_error  EQ GRLC_CRC_PASS        AND
+      pwr_ctrl_param->pc_meas_chan EQ CGRLC_MEAS_CHAN_PDCH     )
+  {
+    if( !freq_param->pdch_hopping )
+    {
+      /* sort burst level acc. its radio frequency */
+      for( i = 0; i < MAC_BURST_PER_BLOCK; i++ )
+      {
+        if( mac_pwr_ctrl_ind->radio_freq[i] EQ freq_param->bcch_arfcn )
+        {
+          j++;
+
+          ss_on_bcch[i] = mac_pwr_ctrl_ind->burst_level[i];
+        }
+        else
+        {
+          ss_off_bcch[i] = mac_pwr_ctrl_ind->burst_level[i];
+        }
+      }
+
+      /* calculate the burst level that should be taken into account */
+      switch( j )
+      {
+        case( 0 ): ss_k = &ss_off_bcch[0]; j = 4; break;
+        case( 1 ): ss_k = &ss_off_bcch[0]; j = 3; break;
+        case( 2 ): ss_k = NULL;                   break;
+        case( 3 ): ss_k = &ss_on_bcch[0];  j = 3; break;
+        case( 4 ): ss_k = &ss_on_bcch[0];  j = 4; break;
+        default  : TRACE_ASSERT( j < 4 );         break;
+
+      }
+    }
+    else
+    {
+      /* calculate the burst level that should be taken into account */
+      ss_k = &mac_pwr_ctrl_ind->burst_level[0];
+      j    = 4;
+    }
+  }
+
+  if( ss_k NEQ NULL )
+  {
+    T_SIGN_VAR_INDEX  old_num;
+    ULONG             old_elem; 
+    UBYTE             pb_rdc;        /* Pb reduction                      */
+    LONG              base;
+    ULONG             sum      = 0;  /* sum of all squares                */
+    ULONG             bl_var;        /* block variance                    */
+    ULONG             ss_block;
+
+    if( meas_c_calc_mean ( ss_k, mac_pwr_ctrl_ind->radio_freq,
+                           &ss_block, &pb_rdc, freq_param ) > 0 )
+    {
+      /* calculate the sum of the squares of the difference between */
+      /* each individual burst level value and the mean             */
+      for( i = 0; i < j; i++ )
+      {
+        if( ss_k[i] NEQ MAC_RXLEV_NONE )
+        {
+          base = ( ( ss_k[i] * MEAS_ACRCY ) / SV_ACRCY_DIV ) -
+                 ( ss_block / SV_ACRCY_DIV );
+          sum += ( ULONG )( base * base );
+        }
+      }
+
+      /*
+       * calculate block variance
+       *
+       * in case ss_k NEQ NULL, j will be either set to the value 3 or 4 
+       *
+       * the lint comment below only works when linting current file alone, 
+       * when linting current file together with all other files of the project,
+       * an error message will be generated anyway
+       *
+       * I don't know why and gave-up to fix it 
+       */
+      bl_var = sum / ( UBYTE )( j - 1 ); /*lint !e414*/
+
+      /* calculate the signal variance */
+      if( sign_var->index EQ MEAS_MAX_NUM_MEAN )
+      {
+        old_num = MEAS_MAX_NUM_MEAN - 1;
+      } 
+      else
+      {
+        old_num = sign_var->index;
+        sign_var->index++;
+      }
+
+      old_elem = sign_var->value * old_num;
+
+      sign_var->value = 
+        (T_SIGN_VAR_VALUE)((old_elem + (bl_var / SV_ACRCY_DIV)) / sign_var->index);
+    }
+    else
+    {
+#ifdef _SIMULATION_
+      TRACE_EVENT( "no valid RXLEV information in meas_sv_update 1" );
+#endif /* #ifdef _SIMULATION_ */
+    }
+
+#ifdef _SIMULATION_
+    TRACE_EVENT_P2( "SIGN-VAR-Value = %d, SIGN-VAR-Index = %d", 
+                    sign_var->value, sign_var->index );
+#endif /* #ifdef _SIMULATION_ */
+  }
+  else
+  {
+#ifdef _SIMULATION_
+    TRACE_EVENT( "no valid RXLEV information in meas_sv_update 2" );
+#endif /* #ifdef _SIMULATION_ */
+  }
+} /* meas_sv_update() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : meas_sv_restart 
++------------------------------------------------------------------------------
+| Description : This function initializes the parameters for deriving the
+|               signal variance.
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void meas_sv_restart ( void )
+{
+  TRACE_FUNCTION( "meas_sv_restart" );
+
+  grlc_data->meas.sign_var.value = 0;
+  grlc_data->meas.sign_var.index = 0;
+} /* meas_sv_restart() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : meas_sq_get_rxqual_value
++------------------------------------------------------------------------------
+| Description : This function returns the current RXQUAL value
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL UBYTE meas_sq_get_rxqual_value ( void)
+{
+  UBYTE      rxqual;
+  T_BER_AVG *ber_avg = &grlc_data->meas.ber_avg; 
+
+  TRACE_FUNCTION( "meas_sq_get_rxqual_value" );
+
+  if      ( ber_avg->value < 200   )
+  {
+    rxqual = 0;         /* RX_QUAL_0 */
+  }
+  else if ( ber_avg->value < 400   )
+  {
+    rxqual = 1;         /* RX_QUAL_1 */
+  }
+  else if ( ber_avg->value < 800   )
+  {
+    rxqual = 2;         /* RX_QUAL_2 */
+  }
+  else if ( ber_avg->value < 1600  )
+  {
+    rxqual = 3;         /* RX_QUAL_3 */
+  }
+  else if ( ber_avg->value < 3200  )
+  {
+    rxqual = 4;         /* RX_QUAL_4 */
+  }
+  else if ( ber_avg->value < 6400  )
+  {
+    rxqual = 5;         /* RX_QUAL_5 */
+  }
+  else if ( ber_avg->value < 12800 )
+  {
+    rxqual = 6;         /* RX_QUAL_6 */
+  }
+  else 
+  {
+    rxqual = 7;         /* RX_QUAL_7 */
+  }
+
+  return ( rxqual );
+} /* meas_sq_get_rxqual_value() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : meas_sq_update
++------------------------------------------------------------------------------
+| Description : This function updates the RXQUAL value.
+|
+| Parameters  : per_ind - Ptr to struct T_BER_IND
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void meas_sq_update ( T_BER_IND *ber_ind )
+{
+  UBYTE        i;  
+  ULONG        norm_fault;
+  ULONG        norm_ber;
+  ULONG        old_elem; 
+  T_BER_INDEX  old_num;
+
+  T_BER_AVG   *ber_avg = &grlc_data->meas.ber_avg;
+
+  TRACE_FUNCTION( "meas_sq_update" );
+  
+  if(grlc_data->meas.sq_restart)
+  {
+    grlc_data->meas.ber_avg.value = 0;
+    grlc_data->meas.ber_avg.index = 0;
+
+    grlc_data->meas.sq_restart = FALSE;
+  }
+
+  for( i = 0; i < ber_ind->num_dl_blck; i++ )
+  {
+    if( ber_ind->be_info[i].total NEQ 0 )
+    {
+      if( ber_avg->index EQ MEAS_MAX_NUM_MEAN )
+      {
+        old_num = MEAS_MAX_NUM_MEAN - 1;
+      } 
+      else
+      {
+        old_num = ber_avg->index;
+        ber_avg->index++;
+      }
+
+      old_elem       = ber_avg->value * old_num;
+      norm_fault     = ber_ind->be_info[i].fault * MEAS_ACRCY * 100;
+      norm_ber       = norm_fault / ber_ind->be_info[i].total;
+      ber_avg->value = (T_BER_VALUE)((old_elem + norm_ber) / ber_avg->index);
+
+      RX_SetRxQual( meas_sq_get_rxqual_value( ) );
+    }
+  }
+
+#ifdef _SIMULATION_
+  TRACE_EVENT_P2( "BER-Value = %d, BER-Index = %d", 
+                  ber_avg->value, ber_avg->index );
+#endif /* #ifdef _SIMULATION_ */
+} /* meas_sq_update() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : meas_sq_restart 
++------------------------------------------------------------------------------
+| Description : This function initializes the parameters for deriving the
+|               RXQUAL value.
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void meas_sq_restart ( void )
+{
+  TRACE_FUNCTION( "meas_sq_restart" );
+
+  grlc_data->meas.ber_avg.value = 0;
+  grlc_data->meas.ber_avg.index = 0;
+} /* meas_sq_restart() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : meas_int_get_rel_i_level
++------------------------------------------------------------------------------
+| Description : This function returns the interference level values mapped to
+|               values relative to the C value.
+|
+| Parameters  : *i_level - Ptr to relative interference level values
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void meas_int_get_rel_i_level ( T_ilev *i_level )
+{
+  USHORT c_raw_data_lev = grlc_data->meas.c_filter.value;
+
+  TRACE_FUNCTION( "meas_int_get_rel_i_level" );
+
+  meas_int_fill_rel_iLevel( &i_level->v_ilev0, &i_level->ilev0, 0, c_raw_data_lev );
+  meas_int_fill_rel_iLevel( &i_level->v_ilev1, &i_level->ilev1, 1, c_raw_data_lev );
+  meas_int_fill_rel_iLevel( &i_level->v_ilev2, &i_level->ilev2, 2, c_raw_data_lev );
+  meas_int_fill_rel_iLevel( &i_level->v_ilev3, &i_level->ilev3, 3, c_raw_data_lev );
+  meas_int_fill_rel_iLevel( &i_level->v_ilev4, &i_level->ilev4, 4, c_raw_data_lev );
+  meas_int_fill_rel_iLevel( &i_level->v_ilev5, &i_level->ilev5, 5, c_raw_data_lev );
+  meas_int_fill_rel_iLevel( &i_level->v_ilev6, &i_level->ilev6, 6, c_raw_data_lev );
+  meas_int_fill_rel_iLevel( &i_level->v_ilev7, &i_level->ilev7, 7, c_raw_data_lev );
+
+#if !defined (NTRACE)
+
+  meas_int_trace_i_level( i_level );
+  
+#endif /* #if !defined (NTRACE) */
+
+} /* meas_int_get_rel_i_level() */
+
+#if !defined (NTRACE)
+
+/*
++------------------------------------------------------------------------------
+| Function    : meas_int_trace_i_level
++------------------------------------------------------------------------------
+| Description :
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void meas_int_trace_i_level( T_ilev *i_level )
+{ 
+  if( grlc_data->meas.v_im_trace NEQ 0 )
+  {
+    TRACE_EVENT_P8( "meas_int_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 );
+  }
+} /* meas_int_trace_i_level() */
+  
+#endif /* #if !defined (NTRACE) */