view src/g23m-gprs/grr/grr_f.c @ 588:f2e752052db5

beginning of SE J100 target support
author Mychaela Falconia <falcon@freecalypso.org>
date Wed, 13 Mar 2019 18:08:34 +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 global functions for GRR
+----------------------------------------------------------------------------- 
*/ 

#ifndef GRR_F_C
#define GRR_F_C
#endif

#define ENTITY_GRR

#ifdef _SIMULATION_

/*
 * Report warning 4005 as an error.
 * 
 * There are identical macro definitons in the GRR message and the RRGRR SAP 
 * document which should be aligned at all the time
 * (e.g. GPRS_RXLEV_ACCESS_MIN_INVALID, GPRS_MS_TXPWR_MAX_CCH, etc.)
 */
#pragma warning( error : 4005 )

#endif /* #ifdef _SIMULATION_ */

/*==== INCLUDES =============================================================*/

#include <stdio.h>
#include <string.h>     /* to get definition of memcpy() */ 
#include <math.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"    /* to get message describtion                        */
#include "pcm.h"

#include "grr.h"        /* to get the global entity definitions              */

#include "grr_f.h"      /* to check own definitions         */
#include "grr_ctrlf.h"  /* to get definition of ctrl_init() */
#include "grr_tcf.h"    /* to get definition of tc_init()   */
#include "grr_cpapf.h"  /* to get definition of cpap_init() */
#include "grr_psif.h"   /* to get definition of psi_init()  */
#include "grr_pgf.h"    /* to get definition of pg_init()   */
#include "grr_gfpf.h"   /* to get definition of gfp_init()  */
#include "grr_meass.h"  /* to get definition of meas_init() */
#include "grr_csf.h"    /* to get definition of cs_init()   */
#include "grr_tcs.h"
#include "grr_em.h"     /*for Engineering mode*/ 

/*==== CONST ================================================================*/
/*
 * Mask- and shift tables for use with macro GET_N_BITS(N)
 */
static const 
UBYTE maskTab1[] = { 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF };

static const 
UBYTE maskTab2[] = { 0xFF, 0x7F, 0x3F, 0x1F, 0x0F, 0x07, 0x03, 0x01 };

static const 
UBYTE shiftTab[] = { 0x00, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 };
/*==== DIAGNOSTICS ==========================================================*/

/*==== LOCAL VARS ===========================================================*/

static UBYTE* pBuf;     /* Global Var: pointer to air message data buffer    */
static int    startBit; /* Global Var: current pBuf decode offset            */
static int    bitLen;   /* Global Var: current remaining undecoded pbuf bits */
LOCAL T_LIST _local_dummy_list;
LOCAL T_f_range _local_rfl_contents;
/*==== GLOBAL VARS ===========================================================*/

/*==== LOCAL MACROS =========================================================*/
/*
 * GET_N_BITS reads next N (1..8) bits from UBYTE* pBuf, starting from integer
 * startBit. N is added to startBit and removed from bitLen after call to this 
 * macro.
 */
#define GET_N_BITS(N)                                                         \
          (( (startBit%8) + (N) <= 8)                                         \
           ? (pBuf[startBit/8] >> shiftTab[(startBit+(N))%8]) & maskTab1[N]   \
           : (pBuf[(startBit+(N))/8] >> shiftTab[(startBit+(N))%8]) +         \
           ((pBuf[startBit/8] & maskTab2[startBit%8]) << ((startBit+(N))%8))  \
          ); startBit += (N); bitLen -= (N)


/*==== FUNCTIONS PROTOTYPES =================================================*/
LOCAL BOOL grr_check_request_reference ( T_req_ref_p * req_ref_i );
LOCAL BOOL grr_check_glob_tfi ( T_glob_tfi * glob_tfi_i, UBYTE tn );
LOCAL BOOL grr_check_add_reject ( UBYTE tn );
LOCAL BOOL grr_check_add_1 ( T_add1 * add1_i,UBYTE tn );
LOCAL BOOL grr_check_add_2 ( T_add2 * add2_i,UBYTE tn );
LOCAL BOOL grr_check_add_3 ( T_add3 * add3_i,UBYTE tn );
LOCAL BOOL grr_check_add_4 ( T_add4 * add4_i,UBYTE tn );
LOCAL void grr_clean_up_seg_ctrl_blk_tbl ( void );
LOCAL void grr_align_seg_ctrl_blk_nxt ( void );

LOCAL UBYTE grr_decode_ie_tlli (BUF_tlli_value* tlli);
LOCAL UBYTE grr_decode_ie_pta (T_pta* pta);
LOCAL UBYTE grr_decode_ie_pwr_par (T_pwr_par* pwr_par);
LOCAL UBYTE grr_decode_ie_glob_tfi (T_glob_tfi* glob_tfi);
LOCAL UBYTE grr_decode_ie_meas_map (T_meas_map* meas_map);
LOCAL UBYTE grr_decode_ie_tbf_s_time (T_tbf_s_time* tbf_s_time);
LOCAL UBYTE grr_decode_ie_dyn_alloc_p (T_dyn_alloc_p* dyn_alloc_p);
LOCAL UBYTE grr_decode_ie_dyn_alloc_ts (T_dyn_alloc_ts* dyn_alloc_ts);
LOCAL UBYTE grr_decode_ie_freq_par (T_freq_par* freq_par);

LOCAL UBYTE grr_decode_dl_assignment (UBYTE* buf, int off, int len);
LOCAL UBYTE grr_decode_ul_assignment (UBYTE* buf, int off, int len);
LOCAL UBYTE grr_decode_ts_reconfig (UBYTE* buf, int off, int len);

LOCAL UBYTE grr_decode_pdch_release (UBYTE* buf, int off, int len);
LOCAL UBYTE grr_decode_polling_req (UBYTE* buf, int off, int len);
LOCAL UBYTE grr_decode_tbf_release_req (UBYTE* buf, int off, int len);

#ifdef REL99
LOCAL UBYTE grr_decode_ie_egprs_link_adpt_para(T_egprs_link_adpt_para *trgt);
LOCAL UBYTE  grr_decode_ie_compact_red_ma(T_compact_red_ma *trgt);
#endif

LOCAL void  grr_init_ms_data     ( void                                 );

/*
 * transmit power control 
 */
LOCAL void  grr_set_alpha_flags  ( BOOL              v_alpha,
                                   UBYTE             alpha              );

LOCAL void  grr_set_sngl_gamma   ( UBYTE             gamma,
                                   UBYTE             tn                 );

/*
 * NC and extended measurements
 */
LOCAL void  grr_init_rfreq_list  ( T_NC_RFREQ_LIST  *list               );

LOCAL void  grr_init_ncmeas_struct
                                 ( T_NCMEAS         *ncmeas,
                                   BOOL              is_cw              );

LOCAL void  grr_copy_em1_struct  ( T_XMEAS_EM1      *db_em1,
                                   T_em1            *ext_em1,
                                   BOOL              cpy_prm_set,
                                   UBYTE            *start_ext_lst_idx,
                                   UBYTE            *stop_ext_lst_idx   );

/*
 * database management
 */
LOCAL void  grr_init_db_srvc_param ( T_SC_DATABASE *db      );

LOCAL UBYTE grr_get_db_num         ( T_SC_DATABASE *db      );

/*
 * miscellaneous
 */
LOCAL void  grr_mrk_ext_lst_freq   ( T_EXT_FREQ_LIST *list  );

LOCAL UBYTE grr_ccd_error_handling ( UBYTE    entity_i      );

LOCAL void  grr_get_si_cell_alloc_list  ( T_LIST     *list  );

LOCAL BOOL  grr_get_psi_cell_alloc_list ( T_LIST     *list  );

LOCAL BOOL  grr_get_ms_alloc_list       ( T_LIST             *list,
                                          const T_gprs_ms_alloc_ie *ms_alloc );
/*==== FUNCTIONS ============================================================*/

/*
+------------------------------------------------------------------------------
| Function    : grr_check_request_reference
+------------------------------------------------------------------------------
| Description : The function grr_check_request_reference() compares the addresses
|               in req_ref_i with the entity data ent returns TRUE if the address
|               in req_ref_i is valid otherwise FALSE
|
| Parameters  : tlli_i - ptr to tlli buffer
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL grr_check_request_reference ( T_req_ref_p * req_ref_i )
{ 
  BOOL result = FALSE;
  UBYTE i,t1,t2,t3;
  USHORT acc_inf;

  t1 = req_ref_i->fn_mod.t1;
  t2 = req_ref_i->fn_mod.t2;
  t3 = req_ref_i->fn_mod.t3;
  acc_inf = req_ref_i->access_info;

  TRACE_FUNCTION( "grr_check_request_reference" );

  for(i=0;i<3;i++)
  {
    if( 
        (grr_data->req_ref[i].fn_mod.t1 EQ t1 )
        AND
        (grr_data->req_ref[i].fn_mod.t2 EQ t2 )
        AND
        (grr_data->req_ref[i].fn_mod.t3 EQ t3 )
        AND
        (grr_data->req_ref[i].access_info EQ acc_inf )
      )
    {
      result = TRUE;
      break;
    }
  }

  if(!result)
  {
    TRACE_EVENT("grr_check_request_reference failed");
  }

  return(result);
} /* grr_check_request_reference() */






/*
+------------------------------------------------------------------------------
| Function    : grr_check_glob_tfi();
+------------------------------------------------------------------------------
| Description : The function grr_check_glob_tfi() returns true if the TFI 
|               is correct.
|
| Parameters  : glob_tfi_i - pointer to global TFI structure
|               tn         - timeslot on which the message is received, this is
|                            required, because tfi is valid only for one 
|                            direction and the assigned PDCHs of a TBF(4.60 5.2)
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL grr_check_glob_tfi ( T_glob_tfi * glob_tfi_i, UBYTE tn )
{ 
  
  BOOL result = FALSE;
  TRACE_FUNCTION( "grr_check_glob_tfi" );


  if(glob_tfi_i->v_ul_tfi)
  {
    if((glob_tfi_i->ul_tfi EQ grr_data->uplink_tbf.tfi) AND
      ((0x80>>tn) & grr_data->uplink_tbf.ts_mask))
    {
      result = TRUE;
    }
  }
  else if(glob_tfi_i->v_dl_tfi)
  {
    if((glob_tfi_i->dl_tfi EQ grr_data->downlink_tbf.tfi) AND
      ((0x80>>tn) & grr_data->downlink_tbf.ts_mask))
    {
      result = TRUE;
    }
  }

  if(!result)
  {
    if(glob_tfi_i->v_ul_tfi)
    {
      TRACE_EVENT_P7("grr_check_glob_tfi failed: UL addressed tfi=%d, ul_tfi=%d, dl_tfi=%d || tn=%d ->mask=%x curr_mask=%x, st_mask=%x ",
                                        glob_tfi_i->ul_tfi,
                                        grr_data->uplink_tbf.tfi,
                                        grr_data->downlink_tbf.tfi,
                                        tn,
                                        0x80>>tn,
                                        grr_data->uplink_tbf.ts_mask,
                                        grr_data->uplink_tbf.ts_usage);
    }
    else if(glob_tfi_i->v_dl_tfi)
    {
      TRACE_EVENT_P7("grr_check_glob_tfi failed: DL addressed tfi=%d, ul_tfi=%d, dl_tfi=%d|| tn=%d ->mask=%x curr_mask=%x, st_mask=%x ",
                                        glob_tfi_i->dl_tfi,
                                        grr_data->uplink_tbf.tfi,
                                        grr_data->downlink_tbf.tfi,
                                        tn,
                                        0x80>>tn,
                                        grr_data->downlink_tbf.ts_mask,
                                        grr_data->downlink_tbf.ts_usage);

    }
    else
    {
      TRACE_EVENT("grr_check_glob_tfi failed: NO addressed tfi ");
    }
  }

  return(result);
  
} /* grr_check_glob_tfi() */



/*
+------------------------------------------------------------------------------
| Function    : grr_check_add_reject
+------------------------------------------------------------------------------
| Description : The function grr_check_add_reject() checks the address in
|               addtional rejects in a Packet Access Reject.
|
| Parameters  : tn - timeslot: need to check if tfi is on assigned PDCH
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL grr_check_add_reject ( UBYTE tn )
{ 
  MCAST(access_rej,D_ACCESS_REJ);
  BOOL result = FALSE;

  TRACE_FUNCTION( "grr_check_add_reject" );

  if(access_rej->reject.v_tlli_value)
    result = grr_check_all_tlli(& access_rej->reject.tlli_value);
  else if (access_rej->reject.req_ref_tfi.v_req_ref_p)
    result = grr_check_request_reference( & access_rej->reject.req_ref_tfi.req_ref_p);
  else if (access_rej->reject.req_ref_tfi.v_glob_tfi)
    result = grr_check_glob_tfi(& access_rej->reject.req_ref_tfi.glob_tfi,tn);

  /* SZML-SGLBL/004 */

  return(result); 
  
} /* grr_check_add_reject() */



/*
+------------------------------------------------------------------------------
| Function    : grr_check_add_1
+------------------------------------------------------------------------------
| Description : The function grr_check_add_1() compares address (add1).
|
| Parameters  : add1_i - pointer to address structure to check
|               tn     - timeslot: need to check if tfi is on assigned PDCH
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL grr_check_add_1 ( T_add1 * add1_i,UBYTE tn )
{ 

  BOOL result = FALSE;
  TRACE_FUNCTION( "grr_check_add_1" );

  if(add1_i->v_glob_tfi) 
    result = grr_check_glob_tfi( & add1_i->glob_tfi,tn );
  else if (add1_i->v_tlli_value) 
    result = grr_check_all_tlli(& add1_i->tlli_value);

  return(result); 
  
} /* grr_check_add_1() */



/*
+------------------------------------------------------------------------------
| Function    : grr_check_add_2
+------------------------------------------------------------------------------
| Description : The function grr_check_add_2() checks address structure 2(add2).
|
| Parameters  : add2_i - pointer address structure to check
|               tn     - timeslot: need to check if tfi is on assigned PDCH
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL grr_check_add_2 ( T_add2 * add2_i,UBYTE tn )
{ 

  BOOL result = FALSE;
  TRACE_FUNCTION( "grr_check_add_2" );

  if(add2_i->v_glob_tfi) 
    result = grr_check_glob_tfi( & add2_i->glob_tfi,tn );
  else if (add2_i->v_tlli_value) 
    result = grr_check_all_tlli(& add2_i->tlli_value);
  else if (add2_i->v_tqi)
    result = (add2_i->tqi EQ grr_data->tqi);
  
  return(result); 
  
} /* grr_check_add_2() */


/*
+------------------------------------------------------------------------------
| Function    : grr_check_add_3
+------------------------------------------------------------------------------
| Description : The function grr_check_add_3() checks address structure 3(add3). 
|
| Parameters  : add3_i - address of address structure to check
|               tn     - timeslot: need to check if tfi is on assigned PDCH
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL grr_check_add_3 ( T_add3 * add3_i,UBYTE tn )
{ 
  BOOL result = FALSE;

  TRACE_FUNCTION( "grr_check_add_3" );

  if(add3_i->v_glob_tfi) 
    result = grr_check_glob_tfi( & add3_i->glob_tfi,tn );
  else if (add3_i->v_tlli_value) 
    result = grr_check_all_tlli(& add3_i->tlli_value);
  else if (add3_i->v_tqi)
    result = (add3_i->tqi EQ grr_data->tqi);
  else if (add3_i->v_req_ref_p)
    result = grr_check_request_reference( & add3_i->req_ref_p);

  return(result); 
  
} /* grr_check_add_3() */


/* The following function is added for handling address 4*/
/*
+------------------------------------------------------------------------------
| Function    : grr_check_add_4
+------------------------------------------------------------------------------
| Description : The function grr_check_add_4() checks address structure 4(add4).
|
| Parameters  : add4_i - address of address structure to check
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL grr_check_add_4 ( T_add4 * add4_i,UBYTE tn  )
{
  BOOL result = FALSE;

  TRACE_FUNCTION( "grr_check_add_4" );

  if(add4_i->v_glob_tfi)
    result = grr_check_glob_tfi( & add4_i->glob_tfi,tn );
  else if (add4_i->tqi_req_ref_p.v_tqi)
    result = (add4_i->tqi_req_ref_p.tqi EQ grr_data->tqi);
  else if (add4_i->tqi_req_ref_p.v_req_ref_p)
    result = grr_check_request_reference( & add4_i->tqi_req_ref_p.req_ref_p);

  return(result);

} /* grr_check_add_4() */

/*
+------------------------------------------------------------------------------
| Function    : grr_clean_up_seg_ctrl_blk_tbl
+------------------------------------------------------------------------------
| Description : The function grr_clean_up_seg_ctrl_blk_tbl() checks the table 
|               for old entries to be 'deleted'.
|
| Parameters  : no
|
+------------------------------------------------------------------------------
*/
LOCAL void grr_clean_up_seg_ctrl_blk_tbl ( void )
{ 
  ULONG fn_i,T3200_i;
  UBYTE i;
  TRACE_FUNCTION( "grr_clean_up_seg_ctrl_blk_tbl" );
  for(i = 0;i < SEG_CTRL_BLOCK_SIZE;i++)
  {
    if(0xFF NEQ grr_data->seg_ctrl_blk.blk[i].rti)
    {
      fn_i = grr_data->dl_fn;
      T3200_i = grr_data->seg_ctrl_blk.blk[i].T3200;
      if((grr_data->seg_ctrl_blk.blk[i].T3200 < 60000) AND (fn_i > (FN_MAX - 60000)))
      {
        T3200_i += FN_MAX;
      }
      else if((grr_data->seg_ctrl_blk.blk[i].T3200 > (FN_MAX - 60000)) AND (fn_i < 60000))
      {
        fn_i += FN_MAX;
      }
      if((T3200_i < fn_i) OR (T3200_i > (fn_i + 60000)))
      {
        grr_data->seg_ctrl_blk.blk[i].rti = 0xFF;
      }
    }
  }
} /* grr_clean_up_seg_ctrl_blk_tbl() */


/*
+------------------------------------------------------------------------------
| Function    : grr_align_seg_ctrl_blk_nxt
+------------------------------------------------------------------------------
| Description : The function grr_align_seg_ctrl_blk_nxt() checks the table for
|               the next field to use and sets grr_data->seg_ctrl_blk.next.
|
| Parameters  : no
|
+------------------------------------------------------------------------------
*/
LOCAL void grr_align_seg_ctrl_blk_nxt ( void )
{ 
  ULONG T3200_i1,T3200_i2;
  UBYTE i,n;

  TRACE_FUNCTION( "grr_align_seg_ctrl_blk_nxt" );
  grr_data->seg_ctrl_blk.next++;
  grr_data->seg_ctrl_blk.next %= SEG_CTRL_BLOCK_SIZE;
  if(0xFF NEQ grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].rti)
  {
    for(i = 0;i < SEG_CTRL_BLOCK_SIZE;i++)
    { /* is there an empty field */
      if(0xFF EQ grr_data->seg_ctrl_blk.blk[i].rti)
        break;
    }
    if(SEG_CTRL_BLOCK_SIZE > i)
    { /* there is an empty field */
      grr_data->seg_ctrl_blk.next = i;
    }
    else
    {/* there is no empty field -> find the oldest entry */
      for(i = 0,n = 0;i < SEG_CTRL_BLOCK_SIZE;i++)
      {
        T3200_i1 = grr_data->seg_ctrl_blk.blk[i].T3200;
        T3200_i2 = grr_data->seg_ctrl_blk.blk[n].T3200;
        if((T3200_i1 > (FN_MAX - 60000)) AND (T3200_i2 < 60000))
        {
          T3200_i2 += FN_MAX;
        }
        else if((T3200_i2 > (FN_MAX - 60000)) AND (T3200_i1 < 60000))
        {
          T3200_i1 += FN_MAX;
        }
        if(T3200_i1 < T3200_i2)
        {
          n = i;
        }
      }
      grr_data->seg_ctrl_blk.next = n;
    }
  }
} /* grr_align_seg_ctrl_blk_nxt() */

/*
+------------------------------------------------------------------------------
| Function    : grr_decode_ie_tlli
+------------------------------------------------------------------------------
| Description : This function decodes a compressed TLLI struct
|
| Parameters  : tlli     - BUF_tlli struct destination pointer
|
| Globals:      pBuf     - Ptr to the compressed TLLI buffer
|               startBit - Bit offset of the first TLLI bit
|               bitLen   - Lenght of the buffer in bits
|
| Returns     : ccdOK    - If no error is occured
|                        - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_ie_tlli (BUF_tlli_value* tlli)
{
  if (bitLen < 32)
    return ERR_MAND_ELEM_MISS;

  tlli->l_tlli_value = 32;
  tlli->o_tlli_value = startBit%8;

  tlli->b_tlli_value[0] = pBuf[startBit/8] & maskTab2[tlli->o_tlli_value];
  startBit += 8;

  tlli->b_tlli_value[1] = pBuf[startBit/8];
  startBit += 8;

  tlli->b_tlli_value[2] = pBuf[startBit/8];
  startBit += 8;

  tlli->b_tlli_value[3] = pBuf[startBit/8];
  startBit += 8;

  tlli->b_tlli_value[4] = pBuf[startBit/8] & ~(maskTab2[tlli->o_tlli_value]);

  bitLen   -= 32;

  return ccdOK;
}


/*
+------------------------------------------------------------------------------
| Function    : grr_decode_ie_pta
+------------------------------------------------------------------------------
| Description : This function decodes a compressed T_pta struct
|
| Parameters  : pta      - T_pta struct destination pointer
|
| Globals:      pBuf     - Ptr to the compressed T_pta buffer
|               startBit - Bit offset of the first T_pta bit
|               bitLen   - Lenght of the buffer in bits
|
| Returns     : ccdOK    - If no error is occured
|                        - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_ie_pta (T_pta* pta)
{
  int bit;                                    

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  bit = GET_N_BITS(1);                        
  if (bit == 1)                               /* TIMING_ADVANCED_VALUE:bit(6) */
  {
    if (bitLen < 6)
      return ERR_MAND_ELEM_MISS;              

    pta->v_ta_value = TRUE;                   
    pta->ta_value   = GET_N_BITS(6);
  }

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  pta->v_ta_index_tn = GET_N_BITS(1);
  if (pta->v_ta_index_tn == 1)                         /* TIMING_ADVANCED_INDEX:bit(4) */
  {                                           /* TI.A.-TIMESLOT_NUMBER:bit(3) */
    if (bitLen < 7)
      return ERR_MAND_ELEM_MISS;              

    pta->ta_index_tn.ta_index   = GET_N_BITS(4);
    pta->ta_index_tn.ta_tn      = GET_N_BITS(3);
  }

  return ccdOK;
}


/*
+------------------------------------------------------------------------------
| Function    : grr_decode_ie_pwr_par
+------------------------------------------------------------------------------
| Description : This function decodes a compressed T_pwr_par struct
|
| Parameters  : pwr_par      - T_pwr_par struct destination pointer
|
| Globals:      pBuf     - Ptr to the compressed T_pwr_par buffer
|               startBit - Bit offset of the first T_pwr_par bit
|               bitLen   - Lenght of the buffer in bits
|
| Returns     : ccdOK    - If no error is occured
|                        - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_ie_pwr_par (T_pwr_par* pwr_par)
{
  int i;
  int bit;                                    
                                              /* Power Control Parameters    */
  if (bitLen < 4)
    return ERR_MAND_ELEM_MISS;              

  pwr_par->alpha = GET_N_BITS(4);

  for (i=0; i<8; i++)
  {
    if (bitLen < 1)
      return ERR_MAND_ELEM_MISS;              

    bit = GET_N_BITS(1);

    if (bit == 1)
    {
      if (bitLen < 5)
        return ERR_MAND_ELEM_MISS;              

      pwr_par->gamma_tn[i].v_gamma = TRUE;    /* any values are allowed      */
      pwr_par->gamma_tn[i].gamma   = GET_N_BITS(5);
    }
  }

  return ccdOK;
}


/*
+------------------------------------------------------------------------------
| Function    : grr_decode_ie_glob_tfi
+------------------------------------------------------------------------------
| Description : This function decodes a compressed T_glob_tfi struct
|
| Parameters  : glob_tfi   - T_glob_tfi struct destination pointer
|
| Globals:      pBuf       - Ptr to the compressed T_glob_tfi buffer
|               startBit   - Bit offset of the first T_glob_tfi bit
|               bitLen     - Lenght of the buffer in bits
|
| Returns     : ccdOK    - If no error is occured
|                        - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_ie_glob_tfi (T_glob_tfi* glob_tfi)
{
  if (bitLen < 6)
    return ERR_MAND_ELEM_MISS;              
  
  glob_tfi->flag = GET_N_BITS(1);
  if (glob_tfi->flag == 0)                    /* UPLINK_TFI                  */
  {
    glob_tfi->v_ul_tfi = TRUE;
    glob_tfi->ul_tfi   = GET_N_BITS(5);
  }
  else                                        /* DOWNLINK_TFI                */
  {
    glob_tfi->v_dl_tfi = TRUE;
    glob_tfi->dl_tfi   = GET_N_BITS(5);
  }

  return ccdOK;
}


/*
+------------------------------------------------------------------------------
| Function    : grr_decode_ie_meas_map
+------------------------------------------------------------------------------
| Description : This function decodes a compressed T_meas_map struct
|
| Parameters  : meas_map   - T_meas_map struct destination pointer
|
| Globals:      pBuf       - Ptr to the compressed T_meas_map buffer
|               startBit   - Bit offset of the first T_meas_map bit
|               bitLen     - Lenght of the buffer in bits
|
| Returns     : ccdOK    - If no error is occured
|                        - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_ie_meas_map (T_meas_map* meas_map)
{
  USHORT h_byte;

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;              

  meas_map->meas_start_grr.flag = GET_N_BITS(1);
  if (meas_map->meas_start_grr.flag == 1)         /* Relative Frame Number Encod.*/
  {
    if (bitLen < 13)
      return ERR_MAND_ELEM_MISS;              

    meas_map->meas_start_grr.v_rel = TRUE;
                             h_byte = GET_N_BITS(5);
    meas_map->meas_start_grr.rel   = (h_byte << 8) + GET_N_BITS(8);
  }
  else                                        /* Absolute Frame Number Encod.*/
  {
    if (bitLen < 16)
      return ERR_MAND_ELEM_MISS;              

    meas_map->meas_start_grr.v_abs  = TRUE;
    meas_map->meas_start_grr.abs.t1 = GET_N_BITS(5);
    meas_map->meas_start_grr.abs.t3 = GET_N_BITS(6);
    meas_map->meas_start_grr.abs.t2 = GET_N_BITS(5);
  }

  if (bitLen < 13)
    return ERR_MAND_ELEM_MISS;

  meas_map->meas_inter  = GET_N_BITS(5);
  meas_map->meas_bitmap = GET_N_BITS(8);

  return ccdOK;
}


#ifdef REL99
/*
+------------------------------------------------------------------------------
| Function    : grr_decode_ie_egprs_link_adpt_para
+------------------------------------------------------------------------------
| Description : This function decodes the EGPRS link adaptation parameters
|
| Parameters  : trgt   - T_egprs_link_adpt_para destination pointer
|
| Globals:      pBuf       - Ptr to the compressed T_egprs_link_adpt_para buffer
|               startBit   - Bit offset of the first T_egprs_link_adpt_para bit
|               bitLen     - Lenght of the buffer in bits
|
| Returns     : ccdOK    - If no error is occured
|                        - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_ie_egprs_link_adpt_para(T_egprs_link_adpt_para *trgt)
{

  TRACE_FUNCTION("grr_decode_ie_egprs_link_adpt_para");

  if (bitLen < 8) /*5+2+1*/
    return ERR_MAND_ELEM_MISS;

  trgt->egprs_ws = GET_N_BITS(5);
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;

  trgt->lqm_mode = GET_N_BITS(2);
  trgt->v_bep_period2 = GET_N_BITS(1);
  if(trgt->v_bep_period2)
  {
    trgt->bep_period2 = GET_N_BITS(4);
  }
  return ccdOK;
}


/*
+------------------------------------------------------------------------------
| Function    : grr_decode_ie_compact_red_ma
+------------------------------------------------------------------------------
| Description : This function decodes the compact_red_ma parameters
|
| Parameters  : trgt   - T_compact_red_ma destination pointer
|
| Globals:      pBuf       - Ptr to the T_compact_red_ma buffer
|               startBit   - Bit offset of the first T_compact_red_ma bit
|               bitLen     - Lenght of the buffer in bits
|
| Returns     : ccdOK    - If no error is occured
|                        - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE  grr_decode_ie_compact_red_ma(T_compact_red_ma *trgt)
{
  UBYTE     i=0;

  TRACE_FUNCTION("grr_decode_ie_compact_red_ma");

  if (bitLen < 8) /*7(for length_reduced_bitmap)+1(for v_maio_2) */
    return ERR_MAND_ELEM_MISS;

  trgt->length_reduced_bitmap = GET_N_BITS(7);
  if(bitLen < trgt->c_reduced_ma_bitmap )
      return ERR_MAND_ELEM_MISS;

  for(i=0 ; i < trgt->c_reduced_ma_bitmap ;i++)
  {
    trgt->reduced_ma_bitmap[i] = GET_N_BITS(1);
  }
  trgt->v_maio_2 = GET_N_BITS(1);
  if(trgt->v_maio_2 == 1)
  {
    if (bitLen < 6)
      return ERR_MAND_ELEM_MISS;

    trgt->maio_2 = GET_N_BITS(6);
  }
  return ccdOK;
}

#endif


/*
+------------------------------------------------------------------------------
| Function    : grr_decode_ie_tbf_s_time
+------------------------------------------------------------------------------
| Description : This function decodes a compressed T_tbf_s_time struct
|
| Parameters  : tbf_s_time - T_tbf_s_time struct destination pointer
|
| Globals:      pBuf       - Ptr to the compressed T_tbf_s_time buffer
|               startBit   - Bit offset of the first T_tbf_s_time bit
|               bitLen     - Lenght of the buffer in bits
|
| Returns     : ccdOK    - If no error is occured
|                        - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_ie_tbf_s_time (T_tbf_s_time* tbf_s_time)
{
  USHORT h_byte;
                                              /* TBF Starting Time: Starting */
                                              /* frame number description    */
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;              

  tbf_s_time->flag = GET_N_BITS(1);
  if (tbf_s_time->flag == 1)                  /* Relative Frame Number Encod.*/
  {
    if (bitLen < 13)
      return ERR_MAND_ELEM_MISS;              
    
    tbf_s_time->v_rel = TRUE;

               h_byte = GET_N_BITS(5);
    tbf_s_time->rel   = (h_byte << 8) + GET_N_BITS(8);
  }
  else                                        /* Absolute Frame Number Encod.*/
  {
    if (bitLen < 16)
      return ERR_MAND_ELEM_MISS;              
    
    tbf_s_time->v_abs = TRUE;

    tbf_s_time->abs.t1 = GET_N_BITS(5);
    tbf_s_time->abs.t3 = GET_N_BITS(6);
    tbf_s_time->abs.t2 = GET_N_BITS(5);
  }

  return ccdOK;
}

/*
+------------------------------------------------------------------------------
| Function    : grr_decode_ie_dyn_alloc_p
+------------------------------------------------------------------------------
| Description : This function decodes a compressed Dynamic Allocation IE
|
| Parameters  : dyn_alloc_p - T_dyn_alloc_p struct destination pointer
|
| Globals:      pBuf        - Ptr to the compressed T_dyn_alloc_p buffer
|               startBit    - Bit offset of the first T_dyn_alloc_p bit
|               bitLen      - Lenght of the buffer in bits
|
| Returns     : ccdOK    - If no error is occured
|                        - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_ie_dyn_alloc_p (T_dyn_alloc_p* dyn_alloc_p)
{
  int i;
  int bit;                                    
  UBYTE  ret_code;


  if (bitLen < 2)                       
    return ERR_MAND_ELEM_MISS;

  dyn_alloc_p->xdyn_alloc = GET_N_BITS(1);

  dyn_alloc_p->flag2 = GET_N_BITS(1);
  if (dyn_alloc_p->flag2 == 1)                /* P0:bit(4), PR_MODE:bit(1)   */
  {
    if (bitLen < 5)
      return ERR_MAND_ELEM_MISS;

    dyn_alloc_p->v_p0      = TRUE;
    dyn_alloc_p->p0        = GET_N_BITS(4);
    dyn_alloc_p->v_pr_mode = TRUE;
    dyn_alloc_p->pr_mode   = GET_N_BITS(1);
  }

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;

  dyn_alloc_p->usf_grant = GET_N_BITS(1);     /* USF_GRANULARITY:bit(1)      */

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* UL_TFI_ASSIGNMENT : bit(5)  */
  {
    if (bitLen < 5)
      return ERR_MAND_ELEM_MISS;

    dyn_alloc_p->v_ul_tfi_assign = TRUE;
    dyn_alloc_p->ul_tfi_assign   = GET_N_BITS(5);
  }

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* RLC_DATA_B._GRANTED:bit(8)  */
  {
    if (bitLen < 8)
      return ERR_MAND_ELEM_MISS;

    dyn_alloc_p->v_rlc_db_granted = TRUE;
    dyn_alloc_p->rlc_db_granted   = GET_N_BITS(8);
  }

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* TBF Starting Time: Starting */
  {                                           /* frame number description    */
    ret_code = grr_decode_ie_tbf_s_time (&dyn_alloc_p->tbf_s_time);

    if (ret_code == ccdOK)
      dyn_alloc_p->v_tbf_s_time = TRUE;
    else
      return ret_code;
  }

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;

  dyn_alloc_p->flag = GET_N_BITS(1);
  if (dyn_alloc_p->flag == 0)                 /* Timeslot Allocation         */
  {
    for (i=0; i<8; i++)
    {
      if (bitLen < 1)
        return ERR_MAND_ELEM_MISS;

      bit = GET_N_BITS(1);
      if (bit == 1)
      {
        if (bitLen < 3)
          return ERR_MAND_ELEM_MISS;

        dyn_alloc_p->tn_alloc[i].v_usf = TRUE;
        dyn_alloc_p->tn_alloc[i].usf   = GET_N_BITS(3);
      }
    }

    dyn_alloc_p->v_tn_alloc = TRUE;
  }
  else                                        /* Timeslot Allocation with    */
  {                                           /*   Power Control Parameters  */
    if (bitLen < 4)
      return ERR_MAND_ELEM_MISS;

    dyn_alloc_p->tn_alloc_pwr.alpha = GET_N_BITS(4);

    for (i=0; i<8; i++)
    {
      if (bitLen < 1)
        return ERR_MAND_ELEM_MISS;

      bit = GET_N_BITS(1);
      if (bit == 1)
      {
        if (bitLen < 8)
          return ERR_MAND_ELEM_MISS;

        dyn_alloc_p->tn_alloc_pwr.usf_array[i].v_usf_g     = TRUE;
        dyn_alloc_p->tn_alloc_pwr.usf_array[i].usf_g.usf   = GET_N_BITS(3);
        dyn_alloc_p->tn_alloc_pwr.usf_array[i].usf_g.gamma = GET_N_BITS(5);
      }
    }

    dyn_alloc_p->v_tn_alloc_pwr = TRUE;
  }

  return ccdOK;
} /* grr_decode_ie_dyn_alloc_p */


/*
+------------------------------------------------------------------------------
| Function    : grr_decode_ie_dyn_alloc_ts
+------------------------------------------------------------------------------
| Description : This function decodes a compressed Dynamic Allocation IE
|
| Parameters  : dyn_alloc_ts - T_dyn_alloc_ts struct destination pointer
|
| Globals:      pBuf        - Ptr to the compressed T_dyn_alloc_p buffer
|               startBit    - Bit offset of the first T_dyn_alloc_p bit
|               bitLen      - Lenght of the buffer in bits
|
| Returns     : ccdOK    - If no error is occured
|                        - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_ie_dyn_alloc_ts (T_dyn_alloc_ts* dyn_alloc_ts)
{
  int i;
  int bit;                                    
  UBYTE  ret_code;


  if (bitLen < 2)                       
    return ERR_MAND_ELEM_MISS;

  dyn_alloc_ts->xdyn_alloc = GET_N_BITS(1);

  dyn_alloc_ts->flag2 = GET_N_BITS(1);
  if (dyn_alloc_ts->flag2 == 1)                /* P0:bit(4), PR_MODE:bit(1)   */
  {
    if (bitLen < 5)
      return ERR_MAND_ELEM_MISS;

    dyn_alloc_ts->v_p0      = TRUE;
    dyn_alloc_ts->p0        = GET_N_BITS(4);
    dyn_alloc_ts->v_pr_mode = TRUE;
    dyn_alloc_ts->pr_mode   = GET_N_BITS(1);
  }

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;

  dyn_alloc_ts->usf_grant = GET_N_BITS(1);     /* USF_GRANULARITY:bit(1)      */

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* RLC_DATA_B._GRANTED:bit(8)  */
  {
    if (bitLen < 8)
      return ERR_MAND_ELEM_MISS;

    dyn_alloc_ts->v_rlc_db_granted = TRUE;
    dyn_alloc_ts->rlc_db_granted   = GET_N_BITS(8);
  }

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* TBF Starting Time: Starting */
  {                                           /* frame number description    */
    ret_code = grr_decode_ie_tbf_s_time (&dyn_alloc_ts->tbf_s_time);

    if (ret_code == ccdOK)
      dyn_alloc_ts->v_tbf_s_time = TRUE;
    else
      return ret_code;
  }

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;

  dyn_alloc_ts->flag = GET_N_BITS(1);
  if (dyn_alloc_ts->flag == 0)                 /* Timeslot Allocation         */
  {
    for (i=0; i<8; i++)
    {
      if (bitLen < 1)
        return ERR_MAND_ELEM_MISS;

      bit = GET_N_BITS(1);
      if (bit == 1)
      {
        if (bitLen < 3)
          return ERR_MAND_ELEM_MISS;

        dyn_alloc_ts->tn_alloc[i].v_usf = TRUE;
        dyn_alloc_ts->tn_alloc[i].usf   = GET_N_BITS(3);
      }
    }

    dyn_alloc_ts->v_tn_alloc = TRUE;
  }
  else                                        /* Timeslot Allocation with    */
  {                                           /*   Power Control Parameters  */
    if (bitLen < 4)
      return ERR_MAND_ELEM_MISS;

    dyn_alloc_ts->tn_alloc_pwr.alpha = GET_N_BITS(4);

    for (i=0; i<8; i++)
    {
      if (bitLen < 1)
        return ERR_MAND_ELEM_MISS;

      bit = GET_N_BITS(1);
      if (bit == 1)
      {
        if (bitLen < 8)
          return ERR_MAND_ELEM_MISS;

        dyn_alloc_ts->tn_alloc_pwr.usf_array[i].v_usf_g     = TRUE;
        dyn_alloc_ts->tn_alloc_pwr.usf_array[i].usf_g.usf   = GET_N_BITS(3);
        dyn_alloc_ts->tn_alloc_pwr.usf_array[i].usf_g.gamma = GET_N_BITS(5);
      }
    }

    dyn_alloc_ts->v_tn_alloc_pwr = TRUE;
  }

  return ccdOK;
} /* grr_decode_ie_dyn_alloc_ts */


/*
+------------------------------------------------------------------------------
| Function    : grr_decode_ie_freq_par
+------------------------------------------------------------------------------
| Description : This function decodes a compressed T_freq_par struct
|
| Parameters  : freq_par - T_freq_par struct destination pointer
|
| Globals:      pBuf     - Ptr to the compressed T_freq_par buffer
|               startBit - Bit offset of the first T_freq_par bit
|               bitLen   - Lenght of the buffer in bits
|
| Returns     : ccdOK    - If no error is occured
|                        - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_ie_freq_par (T_freq_par* freq_par)
{
  int    i;                                      
  int    bit;                                    
  USHORT h_byte;


  if (bitLen < 5)
    return ERR_MAND_ELEM_MISS;                

  freq_par->tsc   = GET_N_BITS(3);            /* TSC : bit (3)               */

  freq_par->flag  = GET_N_BITS(1);
  freq_par->flag2 = GET_N_BITS(1);

  if (freq_par->flag == 0)             
  {
    if (freq_par->flag2 == 0)                 /* ARFCN : bit(10)             */
    {
      if (bitLen < 10)
        return ERR_MAND_ELEM_MISS;

      freq_par->v_arfcn = TRUE;
                    h_byte   = GET_N_BITS(2);
      freq_par->arfcn   = (h_byte << 8) + GET_N_BITS(8);
    }
    else                                      /* Indirect encoding           */
    {
      if (bitLen < 11)
        return ERR_MAND_ELEM_MISS;

      freq_par->indi_encod.maio   = GET_N_BITS(6);
      freq_par->indi_encod.ma_num = GET_N_BITS(4);

      bit = GET_N_BITS(1);
      if (bit == 1)
      {
        if (bitLen < 3)
          return ERR_MAND_ELEM_MISS;

        freq_par->indi_encod.v_chamge_ma_sub   = TRUE;
        freq_par->indi_encod.chamge_ma_sub.cm1 = GET_N_BITS(2);

        bit = GET_N_BITS(1);
        if (bit == 1)
        {
          if (bitLen < 2)
            return ERR_MAND_ELEM_MISS;

          freq_par->indi_encod.chamge_ma_sub.v_cm2 = TRUE;
          freq_par->indi_encod.chamge_ma_sub.cm2   = GET_N_BITS(2);
        }
      }

      freq_par->v_indi_encod = TRUE;
    }
  }
  else
  {
    if (freq_par->flag2 == 0)                 /* Direct encoding 1           */
    {
      if (bitLen < 13)
        return ERR_MAND_ELEM_MISS;

      freq_par->di_encod1.maio = GET_N_BITS(6);
      
      freq_par->di_encod1.gprs_ms_alloc_ie.hsn = GET_N_BITS(6);

      bit = GET_N_BITS(1);                    
      if (bit == 1)                           /* RFL number list             */
      {
        i = 0;

        do {
          if (i >= MAX_RFL_NUM_LIST)
            return ERR_MAND_ELEM_MISS;

          if (bitLen < 5)
            return ERR_MAND_ELEM_MISS;

          freq_par->di_encod1.gprs_ms_alloc_ie.rfl_num_list[i++].
                                                     rfl_num = GET_N_BITS(4);
          bit = GET_N_BITS(1);

        } while (bit == 1);
        
        freq_par->di_encod1.gprs_ms_alloc_ie.c_rfl_num_list = i; 
        freq_par->di_encod1.gprs_ms_alloc_ie.v_rfl_num_list = TRUE;
      }

      if (bitLen < 1)
        return ERR_MAND_ELEM_MISS;

      freq_par->di_encod1.gprs_ms_alloc_ie.flag = GET_N_BITS(1);
      if (freq_par->di_encod1.gprs_ms_alloc_ie.flag == 0)
      {                                       /* MA_LENGTH, MA_BITMAP        */
        if (bitLen < 6)
          return ERR_MAND_ELEM_MISS;

        i = GET_N_BITS(6);
        freq_par->di_encod1.gprs_ms_alloc_ie.ma_struct.ma_len   = i;
        freq_par->di_encod1.gprs_ms_alloc_ie.ma_struct.c_ma_map = i + 1;

        if (bitLen < (i + 1))
          return ERR_MAND_ELEM_MISS;

        for (i=0; i<freq_par->di_encod1.gprs_ms_alloc_ie.ma_struct.c_ma_map; i++)
        {
          freq_par->di_encod1.gprs_ms_alloc_ie.ma_struct.ma_map[i] = GET_N_BITS(1);
        }

        freq_par->di_encod1.gprs_ms_alloc_ie.v_ma_struct = TRUE;
      }
      else                                    /* ARFCN index list            */
      {
        if (bitLen < 1)
          return ERR_MAND_ELEM_MISS;

        bit = GET_N_BITS(1);                    
        if (bit == 1)                         
        {
          i = 0;

          do {
            if (i >= MAX_ARFCN_LIST)
              return ERR_MAND_ELEM_MISS;

            if (bitLen < 7)
              return ERR_MAND_ELEM_MISS;

            freq_par->di_encod1.gprs_ms_alloc_ie.arfcn_index_list[i++].
                                                 arfcn_index = GET_N_BITS(6);
            bit = GET_N_BITS(1);

          } while (bit == 1);
      
          freq_par->di_encod1.gprs_ms_alloc_ie.c_arfcn_index_list = i; 
          freq_par->di_encod1.gprs_ms_alloc_ie.v_rfl_num_list     = TRUE;
        }

        freq_par->di_encod1.gprs_ms_alloc_ie.v_arfcn_index_list = TRUE;
      }

      freq_par->v_di_encod1 = TRUE;
    }
    else                                      /* Direct encoding 2           */
    {
      if (bitLen < 16)
        return ERR_MAND_ELEM_MISS;

      freq_par->di_encod2.maio        = GET_N_BITS(6);
      freq_par->di_encod2.hsn         = GET_N_BITS(6);
      freq_par->di_encod2.len_ma_list = GET_N_BITS(4);
      freq_par->di_encod2.c_ma_list   = freq_par->di_encod2.len_ma_list + 3;

      if (bitLen < (freq_par->di_encod2.c_ma_list << 3))
        return ERR_MAND_ELEM_MISS;

      for (i=0; i<freq_par->di_encod2.c_ma_list; i++)
      {
        freq_par->di_encod2.ma_list[i] = GET_N_BITS(8);
      }

      freq_par->v_di_encod2 = TRUE;
    }
  }

  return ccdOK;
}

/*
+------------------------------------------------------------------------------
| Function    : grr_decode_dl_assignment
+------------------------------------------------------------------------------
| Description : For performance reasons this function replaces the call to the
|               function ccd_decodeMsg. If no error occured, the D_DL_ASSIGN 
|               message is decoded into _decodeCtrlMsg.
|
| Parameters  : buf    - pointer to beginning of the D_DL_ASSIGN IE
|               len    - lenght of the buffer in bits
|               off    - bit offset of the first bit in the buffer
|
| Returns     : ccdOK  - if no error is occured
|                      - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_dl_assignment (UBYTE* buf, int off, int len)
{ 
  int    bit;                                    
  UBYTE  ret_code;

  MCAST(pMsg, D_DL_ASSIGN);

  /*-------------------------------------------------------------------------*/
  startBit = off;                             /* Initiate global data        */
  bitLen   = len;
  pBuf     = buf;

  memset (pMsg, 0, sizeof(T_D_DL_ASSIGN));    /* init destination struct     */
  /*-------------------------------------------------------------------------*/

  if (bitLen < 8)                             
    return ERR_MAND_ELEM_MISS;
  
  pMsg->msg_type  = GET_N_BITS(6);            /* MESSAGE_TYPE : bit(6)       */
  
  /* --- DISTRIBUTION CONTENTS --- */

  pMsg->page_mode = GET_N_BITS(2);            /* PAGE_MODE : bit(2)          */ 

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ccdOK;                             

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* PERSISTENCE_LEVEL: bit(4)*4 */
  {
    if (bitLen < 16)
      return ERR_MAND_ELEM_MISS;
    
    pMsg->v_pers_lev = TRUE;                  

    pMsg->pers_lev.plev[0] = GET_N_BITS(4);
    pMsg->pers_lev.plev[1] = GET_N_BITS(4);
    pMsg->pers_lev.plev[2] = GET_N_BITS(4);
    pMsg->pers_lev.plev[3] = GET_N_BITS(4);
  }

  if (bitLen <= 0)
    return ccdOK;                             

  /* --- ADDRESS INFORMATON --- */

  /*-------------------------------------------------------------------------*/
  pMsg->add1.flag = GET_N_BITS(1);
  if (pMsg->add1.flag == 0)                   /* Global TFI                  */
  {
    ret_code = grr_decode_ie_glob_tfi (&pMsg->add1.glob_tfi);

    if (ret_code == ccdOK)
      pMsg->add1.v_glob_tfi = TRUE;
    else
      return ret_code;
  }
  else
  {
    if (bitLen < 1)
      return ERR_MAND_ELEM_MISS;              

    bit = GET_N_BITS(1);
    if (bit == 0)                             /* TLLI                        */
    {
      ret_code = grr_decode_ie_tlli (&pMsg->add1.tlli_value);

      if(ret_code == ccdOK)
        pMsg->add1.v_tlli_value = TRUE;               
      else
        return ret_code;
    }
    else
    {
      return ERR_MAND_ELEM_MISS;              
    }
  }

  /*-------------------------------------------------------------------------*/

  /* --- MESSAGE ESCAPE --- */
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* 1 equals to Message Escape  */
    return ccdOK;                             /*   then we are ready         */

  /* --- NON-DISTRIBUTION CONTENTS --- */

  if (bitLen < 12)
    return ERR_MAND_ELEM_MISS;                

  pMsg->mac_mode = GET_N_BITS(2);             /* MAC_MODE : bit(2)           */
  pMsg->rlc_mode = GET_N_BITS(1);             /* RLC_MODE : bit(1)           */
  pMsg->ctrl_ack = GET_N_BITS(1);             /* CONTROL_ACK : bit(1)        */
  pMsg->ts_alloc = GET_N_BITS(8);             /* TIMESLOT_ALLOCATION : bit(8)*/

  /*-------------------------------------------------------------------------*/

  ret_code = grr_decode_ie_pta (&pMsg->pta);  /* Packet Timing Advanced IE   */
  
  if(ret_code != ccdOK)
    return ret_code;

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* P0:bit(4)                   */
  {                                           /* BTS_PWR_CTRL_MODE : bit(1)  */
                                              /* PR_MODE : bit(1)            */
    if (bitLen < 6)
      return ERR_MAND_ELEM_MISS;              

    pMsg->v_bts_pwr_ctrl       = TRUE;        
    pMsg->bts_pwr_ctrl.p0      = GET_N_BITS(4);
    pMsg->bts_pwr_ctrl.mode    = GET_N_BITS(1);   
    pMsg->bts_pwr_ctrl.pr_mode = GET_N_BITS(1);
  }

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* Frequency Parameters IE     */
  {
    ret_code = grr_decode_ie_freq_par (&pMsg->pda_trnc_grp.freq_par);

    if (ret_code == ccdOK)
      pMsg->pda_trnc_grp.v_freq_par = TRUE;
    else
      return ret_code;
  }

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* DOWNL.TFI_ASSIGNEMENT:bit(5)*/
  {
    if (bitLen < 5)
      return ERR_MAND_ELEM_MISS;              

    pMsg->pda_trnc_grp.v_dl_tfi_assign = TRUE;             
    pMsg->pda_trnc_grp.dl_tfi_assign   = GET_N_BITS(5);  
  }
  
  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* Power Control Parameters    */
  {
    ret_code = grr_decode_ie_pwr_par (&pMsg->pda_trnc_grp.pwr_par);

    if (ret_code == ccdOK)
      pMsg->pda_trnc_grp.v_pwr_par = TRUE;
    else
      return ret_code;
  }

  /*-------------------------------------------------------------------------*/
  bit = GET_N_BITS(1);
  if (bit == 1)                               /* TBF Starting Time: Starting */
  {                                           /* frame number description    */
    ret_code = grr_decode_ie_tbf_s_time (&pMsg->pda_trnc_grp.tbf_s_time);

    if (ret_code == ccdOK)
      pMsg->pda_trnc_grp.v_tbf_s_time = TRUE;
    else
      return ret_code;
  }

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;              

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* Measurement Mapping         */
  {                                       
    ret_code = grr_decode_ie_meas_map (&pMsg->pda_trnc_grp.meas_map);

    if (ret_code == ccdOK)
      pMsg->pda_trnc_grp.v_meas_map = TRUE;
    else
      return ret_code;
  }

#ifdef REL99
  /*Extending the Packet downlink assignment message decoding
   *for R99 additions
   */
  pMsg->pda_trnc_grp.v_release_99_str_pda = GET_N_BITS(1);
  
  if(pMsg->pda_trnc_grp.v_release_99_str_pda == 1)
  {
    bit = GET_N_BITS(1);
    if(bit == 1)
    {
      ret_code = grr_decode_ie_egprs_link_adpt_para(
        &pMsg->pda_trnc_grp.release_99_str_pda.egprs_link_adpt_para);
      if(ret_code == ccdOK)
        pMsg->pda_trnc_grp.release_99_str_pda.v_egprs_link_adpt_para = TRUE;
      else
        return ret_code;
    }
    if(bitLen < 1)
      return ERR_MAND_ELEM_MISS;
    bit = GET_N_BITS(1);
    if(bit == 1)
    {
      if(bitLen < 2)
        return ERR_MAND_ELEM_MISS;
      pMsg->pda_trnc_grp.release_99_str_pda.v_p_ext_ta = TRUE;
      pMsg->pda_trnc_grp.release_99_str_pda.p_ext_ta = GET_N_BITS(2);
    }

    if(bitLen < 1)
      return ccdOK;
    bit = GET_N_BITS(1);
    if(bit == 1)
    {

      ret_code = grr_decode_ie_compact_red_ma(&pMsg->pda_trnc_grp.release_99_str_pda.compact_red_ma);
      if(ret_code == ccdOK)
        pMsg->pda_trnc_grp.release_99_str_pda.v_compact_red_ma = TRUE;
      else
        return ret_code;
    }
  }
#endif

  /* --- PADDING BITS --- */ /* -> currently not decoded and/or validated */

  return ccdOK;
}
/*
+------------------------------------------------------------------------------
| Function    : grr_decode_pdch_release
+------------------------------------------------------------------------------
| Description : For performance reasons this function replaces the call to the
|               function ccd_decodeMsg. If no error occured, the D_PDCH_RELEASE 
|               message is decoded into _decodeCtrlMsg.
|
| Parameters  : buf    - pointer to beginning of the D_PDCH_RELEASE IE
|               len    - lenght of the buffer in bits
|               off    - bit offset of the first bit in the buffer
|
| Returns     : ccdOK  - if no error is occured
|                      - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_pdch_release (UBYTE* buf, int off, int len)
{ 
  MCAST(pMsg, D_PDCH_RELEASE);

  /*-------------------------------------------------------------------------*/
  startBit = off;                             /* Initiate global data        */
  bitLen   = len;
  pBuf     = buf;

  memset (pMsg, 0, sizeof(T_D_PDCH_RELEASE)); /* init destination struct     */
  /*-------------------------------------------------------------------------*/

  if (bitLen < 8)                             
    return ERR_MAND_ELEM_MISS;
  
  pMsg->msg_type  = GET_N_BITS(6);            /* MESSAGE_TYPE : bit(6)       */
  
  /* --- DISTRIBUTION CONTENTS --- */

  pMsg->page_mode = GET_N_BITS(2);            /* PAGE_MODE : bit(2)          */ 

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ccdOK;                             

  pMsg->v_ts_available = GET_N_BITS(1);       /* TIMESLOT AVAILABLE bit(1)  */

  if (bitLen <= 0)
    return ccdOK;                             

  pMsg->ts_available   = GET_N_BITS(8);       /* TIMESLOT MASK     bit(8)   */

  /* --- PADDING BITS --- */ /* -> currently not decoded and/or validated */

  return ccdOK;
}

/*
+------------------------------------------------------------------------------
| Function    : grr_decode_ul_assignment
+------------------------------------------------------------------------------
| Description : For performance reasons this function replaces the call to the
|               function ccd_decodeMsg. If no error occured, the D_UL_ASSIGN 
|               message is decoded into _decodeCtrlMsg.
|
| Parameters  : buf    - pointer to beginning of the D_DL_ASSIGN IE
|               len    - lenght of the buffer in bits
|               off    - bit offset of the first bit in the buffer
|
| Returns     : ccdOK  - if no error is occured
|                      - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_ul_assignment (UBYTE* buf, int off, int len)
{ 
  int    i;
  int    bit;                                    
  USHORT h_byte;
  UBYTE  ret_code;

  MCAST(pMsg, D_UL_ASSIGN);

  /*-------------------------------------------------------------------------*/
  startBit = off;                             /* Initiate global data        */
  bitLen   = len;
  pBuf     = buf;

  memset (pMsg, 0, sizeof(T_D_UL_ASSIGN));    /* init destination struct     */

  /*-------------------------------------------------------------------------*/

  if (bitLen < 8)                             
    return ERR_MAND_ELEM_MISS;
  
  pMsg->msg_type  = GET_N_BITS(6);            /* MESSAGE_TYPE : bit(6)       */
  
  /* --- DISTRIBUTION CONTENTS --- */

  pMsg->page_mode = GET_N_BITS(2);            /* PAGE_MODE : bit(2)          */ 

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ccdOK;                             

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* PERSISTENCE_LEVEL: bit(4)*4 */
  {
    if (bitLen < 16)
      return ERR_MAND_ELEM_MISS;
    
    pMsg->v_pers_lev = TRUE;                  

    pMsg->pers_lev.plev[0] = GET_N_BITS(4);
    pMsg->pers_lev.plev[1] = GET_N_BITS(4);
    pMsg->pers_lev.plev[2] = GET_N_BITS(4);
    pMsg->pers_lev.plev[3] = GET_N_BITS(4);
  }

  if (bitLen <= 0)
    return ccdOK;                             

  /*-------------------------------------------------------------------------*/

  /* --- ADDRESS INFORMATON --- */

  pMsg->add3.flag = GET_N_BITS(1);
  if (pMsg->add3.flag == 0)                   /* Global TFI                  */
  {
    ret_code = grr_decode_ie_glob_tfi (&pMsg->add3.glob_tfi);

    if (ret_code == ccdOK)
      pMsg->add3.v_glob_tfi = TRUE;
    else
      return ret_code;
  }
  else
  {
    if (bitLen < 1)
      return ERR_MAND_ELEM_MISS;              

    pMsg->add3.v_flag2 = TRUE;

    pMsg->add3.flag2 = GET_N_BITS(1);
    if (pMsg->add3.flag2 == 0)                /* TLLI                        */
    {
      if (bitLen < 32)
        return ERR_MAND_ELEM_MISS;

      ret_code = grr_decode_ie_tlli (&pMsg->add3.tlli_value);

      if(ret_code == ccdOK)
        pMsg->add3.v_tlli_value = TRUE;             
      else
        return ret_code;
    }
    else
    {
      if (bitLen < 1)
        return ERR_MAND_ELEM_MISS;              

      pMsg->add3.v_flag3 = TRUE;

      pMsg->add3.flag3 = GET_N_BITS(1);
      if (pMsg->add3.flag3 == 0)              /* TQI : bit(16)               */
      {
        if (bitLen < 16)
          return ERR_MAND_ELEM_MISS;              

        pMsg->add3.v_tqi = TRUE;             
                  h_byte = GET_N_BITS(8);
        pMsg->add3.tqi   = (h_byte << 8) + GET_N_BITS(8);
      }
      else                                    /* Packet Request Reference    */
      {
        if (bitLen < 27)
          return ERR_MAND_ELEM_MISS;              

        pMsg->add3.v_req_ref_p = TRUE;

                                  h_byte = GET_N_BITS(3);
        pMsg->add3.req_ref_p.access_info = (h_byte << 8) +  GET_N_BITS(8);

        pMsg->add3.req_ref_p.fn_mod.t1 = GET_N_BITS(5);
        pMsg->add3.req_ref_p.fn_mod.t3 = GET_N_BITS(6);
        pMsg->add3.req_ref_p.fn_mod.t2 = GET_N_BITS(5);
      }
    }
  }

  /*-------------------------------------------------------------------------*/

  /* --- MESSAGE ESCAPE --- */

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;

#ifdef REL99  
  pMsg->egprs_flag = GET_N_BITS(1);
  if (pMsg->egprs_flag == 1)
  {
    /* Extending the Packet uplink assignment message decoding 
	 * for EGPRS additions. We do not support EGPRS. So return
	 * doing nothing
	 */
    return ccdOK;
  }
#else
  bit = GET_N_BITS(1);
  if (bit == 1)                               /* 1 equals to Message Escape  */
    return ccdOK;                             /*   then we are ready         */
#endif

  /* When message egprs_flag is FALSE, the valid flags of all the 
   * corresponding conditional elements, is made TRUE here
   */
  pMsg->v_chan_coding_cmd = pMsg->v_tlli_chan_coding = TRUE;
  pMsg->v_pta = pMsg->v_flag = pMsg->v_flag2 = TRUE;
#ifdef REL99
  pMsg->v_release_99 = TRUE;
#endif

  /* --- NON-DISTRIBUTION CONTENTS --- */

  if (bitLen < 3)
    return ERR_MAND_ELEM_MISS;                

  pMsg->chan_coding_cmd  = GET_N_BITS(2);     /* CHANNEL_COD._COMMAND:bit(2) */

  pMsg->tlli_chan_coding = GET_N_BITS(1);     /* TLLI_BLOCK_CHAN_COD.:bit(1) */

  /*-------------------------------------------------------------------------*/
  ret_code = grr_decode_ie_pta (&pMsg->pta);  /* Packet Timing Advanced IE   */
  
  if(ret_code != ccdOK)
    return ret_code;

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* Frequency Parameters IE     */
  {
    ret_code = grr_decode_ie_freq_par (&pMsg->freq_par);

    if (ret_code == ccdOK)
      pMsg->v_freq_par = TRUE;
    else
      return ret_code;
  }

  /*-------------------------------------------------------------------------*/

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  pMsg->flag = GET_N_BITS(1);
  if (pMsg->flag == 0)                        
  {
    if (bitLen < 1)
      return ERR_MAND_ELEM_MISS;                

    pMsg->flag2 = GET_N_BITS(1);
    if (pMsg->flag2 == 1)                     /* 01: Dynamic Allocation IE   */
    {
      ret_code = grr_decode_ie_dyn_alloc_p (&pMsg->dyn_alloc_p);

      if (ret_code == ccdOK)
        pMsg->v_dyn_alloc_p = TRUE;
      else
        return ret_code;
    }
    else
    {
      /* ffs. */                              /* 00: for further extensions  */
    }
  }
  else
  {
    if (bitLen < 1)
      return ERR_MAND_ELEM_MISS;                

    pMsg->flag2 = GET_N_BITS(1);
    if (pMsg->flag2 == 0)                     /* 10: Single Block Allocation */
    {
      if (bitLen < 4)
        return ERR_MAND_ELEM_MISS;                

      pMsg->sin_alloc.tn = GET_N_BITS(3);

      if (bitLen < 1)
        return ERR_MAND_ELEM_MISS;

      bit = GET_N_BITS(1);
      if (bit == 1)
      {
        if (bitLen < 9)
          return ERR_MAND_ELEM_MISS;

        pMsg->sin_alloc.v_alf_gam = TRUE;
        pMsg->sin_alloc.alf_gam.alpha = GET_N_BITS(4);
        pMsg->sin_alloc.alf_gam.gamma = GET_N_BITS(5);
      }

      if (bitLen < 1)
        return ERR_MAND_ELEM_MISS;

      bit = GET_N_BITS(1);
      if (bit == 1)
      {
        if (bitLen < 6)
          return ERR_MAND_ELEM_MISS;

        pMsg->sin_alloc.v_bts_pwr_ctrl       = TRUE;
        pMsg->sin_alloc.bts_pwr_ctrl.p0      = GET_N_BITS(4);
        pMsg->sin_alloc.bts_pwr_ctrl.mode    = GET_N_BITS(1);
        pMsg->sin_alloc.bts_pwr_ctrl.pr_mode = GET_N_BITS(1);
      }

      ret_code = grr_decode_ie_tbf_s_time (&pMsg->sin_alloc.tbf_s_time);

      if (ret_code != ccdOK)
        return ret_code;

      pMsg->v_sin_alloc = TRUE;
    }
    else                                      /* 11: Fixed Allocation        */
    {
      if (bitLen < 1)
        return ERR_MAND_ELEM_MISS;

      bit = GET_N_BITS(1);
      if (bit == 1)
      {
        pMsg->f_alloc_ul.v_ul_tfi_assign = TRUE;
        pMsg->f_alloc_ul.ul_tfi_assign   = GET_N_BITS(5);
      }

      if (bitLen < 5)
        return ERR_MAND_ELEM_MISS;

      pMsg->f_alloc_ul.final_alloc = GET_N_BITS(1);;
      pMsg->f_alloc_ul.dl_ctrl_ts  = GET_N_BITS(3);;

      bit = GET_N_BITS(1);
      if (bit == 1)
      {
        if (bitLen < 6)
          return ERR_MAND_ELEM_MISS;

        pMsg->f_alloc_ul.v_bts_pwr_ctrl       = TRUE;
        pMsg->f_alloc_ul.bts_pwr_ctrl.p0      = GET_N_BITS(4);
        pMsg->f_alloc_ul.bts_pwr_ctrl.mode    = GET_N_BITS(1);
        pMsg->f_alloc_ul.bts_pwr_ctrl.pr_mode = GET_N_BITS(1);
      }

      pMsg->f_alloc_ul.flag = GET_N_BITS(1);
      if(pMsg->f_alloc_ul.flag == 0)
      {
        pMsg->f_alloc_ul.v_ts_alloc = TRUE;
        pMsg->f_alloc_ul.ts_alloc   = GET_N_BITS(8);
      }
      else
      {
        ret_code = grr_decode_ie_pwr_par (&pMsg->f_alloc_ul.pwr_par);

        if (ret_code == ccdOK)
          pMsg->f_alloc_ul.v_pwr_par = TRUE;
        else
          return ret_code;
      }

      if (bitLen < 1)
        return ERR_MAND_ELEM_MISS;

      pMsg->f_alloc_ul.half_dupelx = GET_N_BITS(1);

      ret_code = grr_decode_ie_tbf_s_time (&pMsg->f_alloc_ul.tbf_s_time);

      if (ret_code != ccdOK)
        return ret_code;

      bit = GET_N_BITS(1);
      if(bit == 0)
      {
        if (bitLen < 1)
          return ERR_MAND_ELEM_MISS;

        pMsg->f_alloc_ul.flag2 = GET_N_BITS(1);
        if (pMsg->f_alloc_ul.flag2 == 0)      /* with len Allocation Bitmap  */
        {
          if (bitLen < 8)
            return ERR_MAND_ELEM_MISS;

          pMsg->f_alloc_ul.block_struct.bl_o_bl_per = GET_N_BITS(1);
          pMsg->f_alloc_ul.block_struct.a_map_len   = GET_N_BITS(7);

          if (bitLen < pMsg->f_alloc_ul.block_struct.a_map_len)
            return ERR_MAND_ELEM_MISS;

          for (i=0; i<pMsg->f_alloc_ul.block_struct.a_map_len; i++)
          {
            pMsg->f_alloc_ul.block_struct.alloc_map[i] = GET_N_BITS(1);
          }

          pMsg->f_alloc_ul.block_struct.c_alloc_map = i;
          pMsg->f_alloc_ul.v_block_struct           = TRUE;
        }
        else                          /* without lenght of Allocation Bitmap */
        {                             /* Bitmap fills remainder of message   */
          pMsg->f_alloc_ul.v_alloc_map = TRUE;

          if (bitLen > 127)
            pMsg->f_alloc_ul.c_alloc_map = 127;
          else
            pMsg->f_alloc_ul.c_alloc_map = bitLen;

          for (i=0; i<pMsg->f_alloc_ul.c_alloc_map; i++)
          {
            pMsg->f_alloc_ul.alloc_map[i] = GET_N_BITS(1);
          }
        }
      }
      else
      {
         /* Message Escape */
      }

      pMsg->v_f_alloc_ul = TRUE;
    }
  }

#ifdef REL99
  /* Updation of packet uplink assignment message decoding for 
   * R99 extensions 
   */
  pMsg->release_99 = GET_N_BITS(1);
  if(pMsg->release_99 == 1)
  {
    if(bitLen < 2)
      return ERR_MAND_ELEM_MISS;
    pMsg->v_p_ext_ta = TRUE;
    pMsg->p_ext_ta = GET_N_BITS(2);
  }
#endif

  /* --- PADDING BITS --- */ /* -> currently not decoded and/or validated */
  return ccdOK;
}

/*
+------------------------------------------------------------------------------
| Function    : grr_decode_polling_req
+------------------------------------------------------------------------------
| Description : For performance reasons this function replaces the call to the
|               function ccd_decodeMsg. If no error occured, the D_POLLING_REQ 
|               message is decoded into _decodeCtrlMsg.
|
| Parameters  : buf    - pointer to beginning of the D_POLLING_REQ IE
|               len    - lenght of the buffer in bits
|               off    - bit offset of the first bit in the buffer
|
| Returns     : ccdOK  - if no error is occured
|                      - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_polling_req (UBYTE* buf, int off, int len)
{ 
  int    bit;                                    
  USHORT h_byte;
  UBYTE  ret_code;

  MCAST(pMsg, D_POLLING_REQ);

  /*-------------------------------------------------------------------------*/
  startBit = off;                             /* Initiate global data        */
  bitLen   = len;
  pBuf     = buf;

  memset (pMsg, 0, sizeof(T_D_POLLING_REQ));  /* init destination struct     */

  /*-------------------------------------------------------------------------*/

  if (bitLen < 8)                             
    return ERR_MAND_ELEM_MISS;
  
  pMsg->msg_type  = GET_N_BITS(6);            /* MESSAGE_TYPE : bit(6)       */
  
  /* --- DISTRIBUTION CONTENTS --- */

  pMsg->page_mode = GET_N_BITS(2);            /* PAGE_MODE : bit(2)          */ 


  /*-------------------------------------------------------------------------*/

  /* --- ADDRESS INFORMATON --- */

  pMsg->add2.flag = GET_N_BITS(1);
  if (pMsg->add2.flag == 0)                   /* Global TFI                  */
  {
    ret_code = grr_decode_ie_glob_tfi (&pMsg->add2.glob_tfi);

    if (ret_code == ccdOK)
      pMsg->add2.v_glob_tfi = TRUE;
    else
      return ret_code;
  }
  else
  {
    if (bitLen < 1)
      return ERR_MAND_ELEM_MISS;              

    pMsg->add2.v_flag2 = TRUE;

    pMsg->add2.flag2 = GET_N_BITS(1);
    if (pMsg->add2.flag2 == 0)                /* TLLI                        */
    {
      if (bitLen < 32)
        return ERR_MAND_ELEM_MISS;

      ret_code = grr_decode_ie_tlli (&pMsg->add2.tlli_value);

      if(ret_code == ccdOK)
        pMsg->add2.v_tlli_value = TRUE;             
      else
        return ret_code;
    }
    else
    {
      if (bitLen < 1)
        return ERR_MAND_ELEM_MISS;              

      bit = GET_N_BITS(1);
      if (bit == 0)                           /* TQI : bit(16)               */
      {
        if (bitLen < 16)
          return ERR_MAND_ELEM_MISS;              

        pMsg->add2.v_tqi = TRUE;             
                  h_byte = GET_N_BITS(8);
        pMsg->add2.tqi   = (h_byte << 8) + GET_N_BITS(8);
      }
      else 
      {
        return ERR_ADDR_INFO_PART;              
      }
    }
  }

  /*-------------------------------------------------------------------------*/

  /* --- TYPE OF ACK --- */

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  pMsg->ctrl_ack_type = GET_N_BITS(1);

  /* --- PADDING BITS --- */ /* -> currently not decoded and/or validated */

  return ccdOK;
}
/*
+------------------------------------------------------------------------------
| Function    : grr_decode_tbf_release_req
+------------------------------------------------------------------------------
| Description : For performance reasons this function replaces the call to the
|               function ccd_decodeMsg. If no error occured, the D_TBF_RELEASE 
|               message is decoded into _decodeCtrlMsg.
|
| Parameters  : buf    - pointer to beginning of the D_TBF_RELEASE IE
|               len    - lenght of the buffer in bits
|               off    - bit offset of the first bit in the buffer
|
| Returns     : ccdOK  - if no error is occured
|                      - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_tbf_release_req (UBYTE* buf, int off, int len)
{ 
  int    bit;                                    
  UBYTE  ret_code;

  MCAST(pMsg, D_TBF_RELEASE);

  /*-------------------------------------------------------------------------*/
  startBit = off;                             /* Initiate global data        */
  bitLen   = len;
  pBuf     = buf;

  memset (pMsg, 0, sizeof(T_D_TBF_RELEASE));  /* init destination struct     */

  /*-------------------------------------------------------------------------*/

  if (bitLen < 8)                             
    return ERR_MAND_ELEM_MISS;
  
  pMsg->msg_type  = GET_N_BITS(6);            /* MESSAGE_TYPE : bit(6)       */
  
  /* --- DISTRIBUTION CONTENTS --- */

  pMsg->page_mode = GET_N_BITS(2);            /* PAGE_MODE : bit(2)          */ 


  /*-------------------------------------------------------------------------*/

  /* --- ADDRESS INFORMATON --- */

  bit = GET_N_BITS(1);
  if (bit == 0)                               /* Global TFI                  */
  {
    ret_code = grr_decode_ie_glob_tfi (&pMsg->glob_tfi);

    if (ret_code NEQ ccdOK)
      return ret_code;
  }
  else
  {
    return ERR_ADDR_INFO_PART;              
  }

  /*-------------------------------------------------------------------------*/

  /* --- UPLINK/ DOWNLINK RELEASE VALUES --- */

  if (bitLen < 6)
    return ERR_MAND_ELEM_MISS;                

  pMsg->ul_release = GET_N_BITS(1);
  pMsg->dl_release = GET_N_BITS(1);
  pMsg->rel_cause  = GET_N_BITS(4);

  /* --- PADDING BITS --- */ /* -> currently not decoded and/or validated */

  return ccdOK;
}
/*
+------------------------------------------------------------------------------
| Function    : grr_decode_ts_reconfig
+------------------------------------------------------------------------------
| Description : For performance reasons this function replaces the call to the
|               function ccd_decodeMsg. If no error occured, the D_TS_RECONFIG
|               message is decoded into _decodeCtrlMsg.
|
| Parameters  : buf    - pointer to beginning of the D_TS_RECONFIG IE
|               len    - lenght of the buffer in bits
|               off    - bit offset of the first bit in the buffer
|
| Returns     : ccdOK  - if no error is occured
|                      - else CCD error code
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_decode_ts_reconfig (UBYTE* buf, int off, int len)
{ 
  int    i;
  int    bit;                                    
  UBYTE  ret_code;

  MCAST(pMsg, D_TS_RECONFIG);

  /*-------------------------------------------------------------------------*/
  startBit = off;                             /* Initiate global data        */
  bitLen   = len;
  pBuf     = buf;

  memset (pMsg, 0, sizeof(T_D_TS_RECONFIG));  /* init destination struct     */

  /*-------------------------------------------------------------------------*/

  if (bitLen < 8)                             
    return ERR_MAND_ELEM_MISS;
  
  pMsg->msg_type  = GET_N_BITS(6);            /* MESSAGE_TYPE : bit(6)       */
  
  /* --- DISTRIBUTION CONTENTS --- */

  pMsg->page_mode = GET_N_BITS(2);            /* PAGE_MODE : bit(2)          */ 

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ccdOK;                             

  /*-------------------------------------------------------------------------*/
  bit = GET_N_BITS(1);
  if(bit == 0)                                /* GLOBAL_TFI                  */
  {
    ret_code = grr_decode_ie_glob_tfi (&pMsg->glob_tfi);

    if (ret_code != ccdOK)
      return ret_code;
  }

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

#ifdef REL99
  pMsg->egprs_flag = GET_N_BITS(1);
  if (pMsg->egprs_flag == 1)
  {
    /*EGPRS is not supported. Just return */
    return ccdOK;
  }
#else
  bit = GET_N_BITS(1);
  if (bit == 1)                               /* 1 equals to Message Escape  */
    return ccdOK;                             /*   then we are ready         */
#endif



  /* When message egprs_flag is FALSE, the valid flags of all the 
   * corresponding conditional elements, is made TRUE here
   */
  pMsg->v_chan_coding_cmd = pMsg->v_gpta = pMsg->v_dl_rlc_mode = TRUE;
  pMsg->v_ctrl_ack = pMsg->v_dl_tn_alloc = pMsg->v_flag = TRUE;

#ifdef REL99
  pMsg->v_release_99 = TRUE;
#endif



  /*-------------------------------------------------------------------------*/
  if (bitLen < 2)
    return ERR_MAND_ELEM_MISS;                

  pMsg->chan_coding_cmd = GET_N_BITS(2);      /* CHANNEL_COD._COMMAND:bit(2) */

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* TIMING_ADVANCED_VALUE       */
  {
    if (bitLen < 6)
      return ERR_MAND_ELEM_MISS;                

    pMsg->gpta.v_ta_value = TRUE;
    pMsg->gpta.ta_value   = GET_N_BITS(6);
  }

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  pMsg->gpta.flag = GET_N_BITS(1);
  if (pMsg->gpta.flag == 1)                   /* UPLINK_TIMING_ADVANCED      */
  {
    if (bitLen < 7)
      return ERR_MAND_ELEM_MISS;                

    pMsg->gpta.v_ul_ta_index = TRUE;
    pMsg->gpta.ul_ta_index   = GET_N_BITS(4);

    pMsg->gpta.v_ul_ta_tn    = TRUE;
    pMsg->gpta.ul_ta_tn      = GET_N_BITS(3);
  }

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  pMsg->gpta.flag2 = GET_N_BITS(1);
  if (pMsg->gpta.flag2 == 1)                  /* DOWNLINK_TIMING_ADVANCED    */
  {
    if (bitLen < 7)
      return ERR_MAND_ELEM_MISS;                

    pMsg->gpta.v_dl_ta_index = TRUE;
    pMsg->gpta.dl_ta_index   = GET_N_BITS(4);

    pMsg->gpta.v_dl_ta_tn    = TRUE;
    pMsg->gpta.dl_ta_tn      = GET_N_BITS(3);
  }

  /*-------------------------------------------------------------------------*/
  if (bitLen < 2)
    return ERR_MAND_ELEM_MISS;      
              
  pMsg->dl_rlc_mode = GET_N_BITS(1);
  pMsg->ctrl_ack    = GET_N_BITS(1);

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;      

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* DOWNLINK_TFI_ASSIGNMENT     */
  {
    if (bitLen < 5)
      return ERR_MAND_ELEM_MISS;      

    pMsg->v_dl_tfi = TRUE;
    pMsg->dl_tfi   = GET_N_BITS(5);
  }

  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;      

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* UPLINK_DFI_ASSIGNMENT       */
  {
    if (bitLen < 5)
      return ERR_MAND_ELEM_MISS;      

    pMsg->v_ul_tfi = TRUE;
    pMsg->ul_tfi   = GET_N_BITS(5);
  }

  /*-------------------------------------------------------------------------*/
  if (bitLen < 8)
    return ERR_MAND_ELEM_MISS;      

  pMsg->dl_tn_alloc = GET_N_BITS(8);          /* DOWNLINK_TIMESLOT_ALLOCATION*/

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  bit = GET_N_BITS(1);
  if (bit == 1)                               /* Frequency Parameters IE     */
  {
    ret_code = grr_decode_ie_freq_par (&pMsg->freq_par);

    if (ret_code == ccdOK)
      pMsg->v_freq_par = TRUE;
    else
      return ret_code;
  }

  /*-------------------------------------------------------------------------*/
  if (bitLen < 1)
    return ERR_MAND_ELEM_MISS;                

  pMsg->flag = GET_N_BITS(1);
  if (pMsg->flag == 0)                        /* Dynamic Allocation struct   */
  {
    ret_code = grr_decode_ie_dyn_alloc_ts (&pMsg->dyn_alloc_ts);

    if (ret_code == ccdOK)                      
      pMsg->v_dyn_alloc_ts = TRUE;
    else
      return ret_code;
  }
  else                                        /* Fixed Allocation struct     */
  {
    if (bitLen < 1)
      return ERR_MAND_ELEM_MISS;                

    pMsg->f_alloc_re.flag = GET_N_BITS(1);
    if (pMsg->f_alloc_re.flag == 0)           /* UPLINK_TIMESLOT_ALLOCATION  */
    {
      if (bitLen < 8)
        return ERR_MAND_ELEM_MISS;                

      pMsg->f_alloc_re.v_ul_ts_alloc = TRUE;
      pMsg->f_alloc_re.ul_ts_alloc   = GET_N_BITS(8);
    }
    else                                      /* Power Control Parameters IE */
    {
      ret_code = grr_decode_ie_pwr_par (&pMsg->f_alloc_re.pwr_par);

      if (ret_code == ccdOK)
        pMsg->f_alloc_re.v_pwr_par = TRUE;
      else
        return ret_code;
    }

    if (bitLen < 4)
      return ERR_MAND_ELEM_MISS;                

    pMsg->f_alloc_re.final_alloc = GET_N_BITS(1);
    pMsg->f_alloc_re.dl_ctrl_ts  = GET_N_BITS(3);

    bit = GET_N_BITS(1);
    if (bit == 1)
    {
      if (bitLen < 6)
        return ERR_MAND_ELEM_MISS;

      pMsg->f_alloc_re.v_bts_pwr_ctrl       = TRUE;
      pMsg->f_alloc_re.bts_pwr_ctrl.p0      = GET_N_BITS(4);
      pMsg->f_alloc_re.bts_pwr_ctrl.mode    = GET_N_BITS(1);
      pMsg->f_alloc_re.bts_pwr_ctrl.pr_mode = GET_N_BITS(1);
    }

    if (bitLen < 1)
      return ERR_MAND_ELEM_MISS;              

    bit = GET_N_BITS(1);
    if (bit == 1)                               /* Measurement Mapping         */
    {                                       
      ret_code = grr_decode_ie_meas_map (&pMsg->f_alloc_re.meas_map);

      if (ret_code == ccdOK)
        pMsg->f_alloc_re.v_meas_map = TRUE;
      else
        return ret_code;
    }
                                                /* TBF Starting Time           */
    ret_code = grr_decode_ie_tbf_s_time (&pMsg->f_alloc_re.tbf_s_time);

    if (ret_code != ccdOK)
      return ret_code;

    bit = GET_N_BITS(1);
    if(bit == 0)
    {
      if (bitLen < 1)
        return ERR_MAND_ELEM_MISS;

      pMsg->f_alloc_re.flag2 = GET_N_BITS(1);
      if (pMsg->f_alloc_re.flag2 == 0) /* with lenght of Allocation Bitmap */
      {
        if (bitLen < 8)
          return ERR_MAND_ELEM_MISS;

        pMsg->f_alloc_re.block_struct.bl_o_bl_per = GET_N_BITS(1);
        pMsg->f_alloc_re.block_struct.a_map_len   = GET_N_BITS(7);

        if (bitLen < pMsg->f_alloc_re.block_struct.a_map_len)
          return ERR_MAND_ELEM_MISS;

        for (i=0; i<pMsg->f_alloc_re.block_struct.a_map_len; i++)
        {
          pMsg->f_alloc_re.block_struct.alloc_map[i] = GET_N_BITS(1);
        }

        pMsg->f_alloc_re.block_struct.c_alloc_map = i;
        pMsg->f_alloc_re.v_block_struct           = TRUE;
      }
      else                          /* without lenght of Allocation Bitmap */
      {                             /* Bitmap fills remainder of message   */
        pMsg->f_alloc_re.v_alloc_map = TRUE;

        if (bitLen > 127)
          pMsg->f_alloc_re.c_alloc_map = 127;
        else
          pMsg->f_alloc_re.c_alloc_map = bitLen;

        for (i=0; i<pMsg->f_alloc_re.c_alloc_map; i++)
        {
          pMsg->f_alloc_re.alloc_map[i] = GET_N_BITS(1);
        }
      }
    }
    else
    {
       /* Message Escape */
    }

    pMsg->v_f_alloc_re = TRUE;
  }

#ifdef REL99
  /* Updation of packet time slot reconf message decoding for R99 
   * extensions
   */
  pMsg->release_99 = GET_N_BITS(1);
  if(pMsg->release_99 == 1)
  {
    if(bitLen < 2)
      return ERR_MAND_ELEM_MISS;
    pMsg->v_p_ext_ta = TRUE;
    pMsg->p_ext_ta = GET_N_BITS(2);
  }
#endif

  return ccdOK;
}

/*
+------------------------------------------------------------------------------
| Function    : grr_ccd_error_handling
+------------------------------------------------------------------------------
| Description : The function grr_ccd_error_handling() ...
|
| Parameters  : entity_i - the CCD was called for this entity
|
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_ccd_error_handling ( UBYTE entity_i  )
{ 
  UBYTE result = DELETE_MESSAGE;
  USHORT parlist [MAX_ERR_PAR];
  UBYTE first_error; 

  TRACE_FUNCTION( "grr_ccd_error_handling" );


  memset (parlist, 0, sizeof (parlist));
  
  first_error = ccd_getFirstError (entity_i, parlist);
  
  switch (first_error)
  {
    
  case ERR_PATTERN_MISMATCH:      /* A spare pattern does not match with  */
    /* the specified content                */
    /* Error params[0] = bitposition        */
    {
      MCAST(ptr,D_DL_ASSIGN);
      result = ptr->msg_type;
    }
    break;
    
  default:
    /* SZML-GLBL/010 */
    TRACE_ERROR( "Ctrl-Message will be deleted" );
    break;
  }
  
  return(result);

} /* grr_ccd_error_handling() */


/*==== PUBLIC FUNCTIONS =====================================================*/



/*
+------------------------------------------------------------------------------
| Function    : grr_check_ptmsi
+------------------------------------------------------------------------------
| Description : The function grr_check_ptmsi() checks the ptmsi and returns 
|               TRUE if the ptmsi is correct.
|
| Parameters  : ptmsi_i - ptr to ptmsi buffer
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_check_ptmsi ( BUF_ptmsi * ptmsi_i )
{ 
  ULONG ptmsi;
  BOOL result = FALSE;

  TRACE_FUNCTION( "grr_check_ptmsi" );
  
  ptmsi = grr_buffer2ulong( ptmsi_i );

  /*
   * if the new_pmsi is invalid the old should be onsidered s invalid too
   */
  if(grr_data->db.ms_id.new_ptmsi NEQ GMMRR_TMSI_INVALID)
  {
    if(grr_data->db.ms_id.old_ptmsi EQ ptmsi
    OR
    grr_data->db.ms_id.new_ptmsi EQ ptmsi)
    {
      result= TRUE;
    };
  }
  else
  {
    TRACE_EVENT_P2("NO valid PTMSI IN GRR PRESENT !!! old_ptmsi=%lx  new_ptmsi=%lx"
                                                            ,grr_data->db.ms_id.old_ptmsi
                                                            ,grr_data->db.ms_id.new_ptmsi);  
  }
  if(!result)
  {
    TRACE_EVENT_P5("OLD PTMSI: %LX, DESTINATION PTMSI: %LX   len=%d off=%d  NEW PTMSI=%lx"
                   ,grr_data->db.ms_id.old_ptmsi
                   ,ptmsi
                   ,ptmsi_i->l_ptmsi
                   ,ptmsi_i->o_ptmsi
                   ,grr_data->db.ms_id.new_ptmsi);
    
    TRACE_EVENT_P8("PTMSI BUF:buf[0 .. 7]=  %x %x %x %x %x %x %x %x "
                   ,ptmsi_i->b_ptmsi[0]
                   ,ptmsi_i->b_ptmsi[1]
                   ,ptmsi_i->b_ptmsi[2]
                   ,ptmsi_i->b_ptmsi[3]
                   ,ptmsi_i->b_ptmsi[4]
                   ,ptmsi_i->b_ptmsi[5]
                   ,ptmsi_i->b_ptmsi[6]
                   ,ptmsi_i->b_ptmsi[7]);

  }

  return(result);
} /* grr_check_ptmsi() */



/*
+------------------------------------------------------------------------------
| Function    : grr_check_tmsi
+------------------------------------------------------------------------------
| Description : The function grr_check_tmsi() checks the tmsi and returns 
|               TRUE if the tmsi is correct.
|
| Parameters  : tmsi_i - ptr to tmsi buffer
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_check_tmsi ( BUF_tmsi_field * tmsi_i )
{ 
  ULONG tmsi;
  BOOL result = FALSE;

  TRACE_FUNCTION( "grr_check_tmsi" );
  
  tmsi = grr_buffer2ulong( (BUF_ptmsi*) tmsi_i );
  
  if(tmsi EQ grr_data->db.ms_id.tmsi) result = TRUE;

  return(result);

} /* grr_check_tmsi() */




/*
+------------------------------------------------------------------------------
| Function    : grr_check_all_tlli
+------------------------------------------------------------------------------
| Description : The function grr_check_all_tlli() checks the tlli with all TLLI
|               GMM has assigned and returns TRUE if the tlli is between them. 
|
| Parameters  : tlli_i - ptr to tlli buffer
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_check_all_tlli ( BUF_tlli_value * tlli_i )
{ 
  ULONG tlli;
  BOOL result = FALSE;

  TRACE_FUNCTION( "grr_check_all_tlli" );
  
  tlli = grr_buffer2ulong( (BUF_ptmsi*)tlli_i );

  /*
   * if the new_tlli is invalid the old should be onsidered s invalid too
   */
  if(grr_data->db.ms_id.new_tlli NEQ GMMRR_TLLI_INVALID)
  {
    if(grr_data->db.ms_id.new_tlli EQ tlli)
    {
      grr_data->db.ms_id.received_tlli = grr_data->db.ms_id.new_tlli;
      result = TRUE;
    }
    else if (grr_data->db.ms_id.old_tlli EQ tlli)
    {
      
      grr_data->db.ms_id.received_tlli = grr_data->db.ms_id.old_tlli;
      result = TRUE;
    };
  }

  if(result)
  {
    tc_cgrlc_enable_req(CGRLC_QUEUE_MODE_DEFAULT,CGRLC_RA_DEFAULT,FALSE,CGRLC_ENAC_NORMAL);
  }
  else
  {
    TRACE_EVENT_P5("OLD TLLI: %LX, DESTINATION TLLI: %LX   len=%d off=%d  NEW TLLI=%lx"
                   ,grr_data->db.ms_id.old_tlli
                   ,tlli
                   ,tlli_i->l_tlli_value
                   ,tlli_i->o_tlli_value
                   ,grr_data->db.ms_id.new_tlli);
    
    TRACE_EVENT_P8("TLLI BUF:buf[0 .. 7]=  %x %x %x %x %x %x %x %x "
                   ,tlli_i->b_tlli_value[0]
                   ,tlli_i->b_tlli_value[1]
                   ,tlli_i->b_tlli_value[2]
                   ,tlli_i->b_tlli_value[3]
                   ,tlli_i->b_tlli_value[4]
                   ,tlli_i->b_tlli_value[5]
                   ,tlli_i->b_tlli_value[6]
                   ,tlli_i->b_tlli_value[7]);

  }

  return(result);

} /* grr_check_all_tlli() */



/*
+------------------------------------------------------------------------------
| Function    : grr_buffer2ulong
+------------------------------------------------------------------------------
| Description : The function grr_buffer2ulong() copy a 32-Bit-Buffer in a ULONG
|               variable
|               
|               SZML-GLBL/002
|
| Parameters  : ptmsi - pointer to buffer that contains the 32bit for the ULONG 
|
+------------------------------------------------------------------------------
*/
GLOBAL ULONG grr_buffer2ulong ( BUF_ptmsi * ptmsi)
{
  ULONG ul;
 
  UBYTE l, dummy; 
  USHORT i, ii;
  UBYTE off1, off2;
  
  TRACE_FUNCTION( "grr_buffer2ulong" ); 
  
  ul= 0;
  
  l = (UBYTE)ptmsi->l_ptmsi;
  
  off1 = ptmsi->o_ptmsi / 8;
  off2 = ptmsi->o_ptmsi % 8;
  
  dummy = 0;
  dummy = ptmsi->b_ptmsi[off1] << off2;
  
  if(l <= (8-off2))
  {
    dummy = dummy >> (8-l);
    ul |= dummy;
    return ul;
  }
  dummy = dummy >> off2;
  ul |= dummy;
  l -= (8-off2);
  
  do
  {
    off1++;
    
    if(l < 8)
    {
      dummy = ptmsi->b_ptmsi[off1] >> (8-l);
      ii = 1;
      ul = ul << l;
      for(i=0; i< l; i++)
      {
        ul = ul | (dummy & ii);
        ii *= 2;
      }
      return ul;  
    }
    else
    {
      ul = ul << 8;
      ul |= ptmsi->b_ptmsi[off1];
      l -= 8;
      if(l EQ 0)
        return ul;
    }
  }
  while(TRUE);
}






/*
+------------------------------------------------------------------------------
| Function    : grr_decode_rr
+------------------------------------------------------------------------------
| Description : The function grr_decode_rr() calls the function ccd_decodeMsg.
|               After the call the decoded Message is in _decodeCtrlMsg.
|               
|
| Parameters  : msg_ptr_i - pointer to buffer that should be decoded
|
+------------------------------------------------------------------------------
*/

GLOBAL UBYTE grr_decode_rr (   T_MSGBUF  *  msg_ptr_i )
{ 
  UBYTE result;


  TRACE_FUNCTION( "grr_decode_rr" );

  
  
  result = ccd_decodeMsg ( CCDENT_RR, 
                  DOWNLINK,
                  msg_ptr_i,
                  _decodedMsg, 
                  NOT_PRESENT_8BIT);


  if ( result EQ ccdError)
  {
    TRACE_ERROR( "grr_decode_rr - decoding of RR message failed" );

    result = grr_ccd_error_handling(CCDENT_RR);
  }
  else
  {
    MCAST(ptr, D_SYS_INFO_13); /* get one message from the RR message-base*/
    result = ptr->msg_type; /*  this is the type of the decoded message*/
  }
  
  return(result);
  
} /* grr_decode_rr() */


  
/*
+------------------------------------------------------------------------------
| Function    : grr_calc_new_poll_pos
+------------------------------------------------------------------------------
| Description : The function grr_calc_new_poll_pos() calculates the fn of the 
|               new poll position
|
| Parameters  : fn_i    - framenumber
|               rrbp_i  - relative position
|
+------------------------------------------------------------------------------
*/
GLOBAL ULONG grr_calc_new_poll_pos ( ULONG fn_i, UBYTE rrbp_i )
{ 
  ULONG result=0;
  TRACE_FUNCTION( "grr_calc_new_poll_pos" );

  switch( rrbp_i )
  {
  case 0:
    result = (fn_i+13);
    break;
  case 1:
    if((fn_i+18)%13)
      result = (fn_i+17);
    else
      result = (fn_i+18);
    break;
  case 2:
    if(((fn_i+21)%13) EQ 8)
      result = (fn_i+21);
    else
      result = (fn_i+22);
    break;
  case 3:
    result = (fn_i+26);
    break;
  default:
    TRACE_ERROR( "unexpected rrbp  value" );
    break;
  } /* switch (rrbp_i) */
  result = result % 0x297000;

  return result;

} /* grr_calc_new_poll_pos() */






/*
+------------------------------------------------------------------------------
| Function    : grr_encode_ctrl
+------------------------------------------------------------------------------
| Description : The function grr_encode_ctrl() build a T_SDU buffer that 
|               contains the encode Ctrl Block ready to transmit. 
|
| Parameters  : ULONG ptr_in_i - ptr to the input structure
|               ULONG ptr_out_i - ptr to begin of output buffer
|               UBYTE r_bit_i - value of r_bit
+------------------------------------------------------------------------------
*/
GLOBAL void grr_encode_ctrl ( UBYTE * ptr_in_i, 
                              T_MSGBUF * ptr_out_i, 
                              UBYTE r_bit_i)
{ 
  TRACE_FUNCTION( "grr_encode_ctrl" );

  ptr_out_i->buf[0] = grr_get_ul_ctrl_block_header( r_bit_i );
  ptr_out_i->o_buf  = BIT_UL_CTRL_BLOCK_MAC_HEADER;
  ptr_out_i->l_buf  = BIT_UL_CTRL_BLOCK_CONTENTS;

  ccd_codeMsg ( CCDENT_GRR, 
                UPLINK,
                ptr_out_i,
                ptr_in_i, 
                NOT_PRESENT_8BIT);

  ptr_out_i->l_buf += ptr_out_i->o_buf;
  ptr_out_i->o_buf  = 0;

} /* grr_encode_ctrl() */


/*
+------------------------------------------------------------------------------
| Function    : grr_save_persistence_level
+------------------------------------------------------------------------------
| Description : The function grr_save_persistence_level() saves the persistence 
|               level values to the data_base. 
|
| Parameters  : ptr2persistence_level_i - pointer to received data
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_save_persistence_level ( T_pers_lev * ptr2persistence_level_i )
{ 
  UBYTE i ;
  TRACE_FUNCTION( "grr_save_persistence_level" );


  for(i=0; i<4; i++)
  {
     psc_db->prach.pers_lev.plev[i] = ptr2persistence_level_i->plev[i];
  }

} /* grr_save_persistence_level() */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_db_mode
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL T_DB_MODE grr_get_db_mode( void )
{ 
  TRACE_FUNCTION( "grr_get_db_mode" );

  return( grr_data->sc_db_mode );

}/* grr_get_db_mode */

/*
+------------------------------------------------------------------------------
| Function    : grr_set_db_ptr
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_set_db_ptr( T_DB_MODE mode )
{ 
  UBYTE old_mode = grr_data->sc_db_mode;

  TRACE_FUNCTION( "grr_set_db_ptr" );

  switch( mode )
  {
    case( DB_MODE_INIT ):
      grr_data->sc_db_mode = (UBYTE)mode;
      
      psc_db  = &grr_data->sc_db_1;
      posc_db = NULL;
      prsc_db = NULL;
      pcr_db  = &grr_data->sc_db_2;
      break;

    case( DB_MODE_CC_REQ ):
      if( grr_data->sc_db_mode NEQ DB_MODE_CC_REQ )
      {
        grr_data->sc_db_mode = (UBYTE)mode;

        if( psc_db EQ &grr_data->sc_db_1 )
        {
          psc_db  = &grr_data->sc_db_2;
          posc_db = &grr_data->sc_db_1;
        }
        else
        {
          psc_db  = &grr_data->sc_db_1;
          posc_db = &grr_data->sc_db_2;
        }

        prsc_db = NULL;
        pcr_db  = NULL;
      }
      break;

    case( DB_MODE_SWAP ):
      {
        T_SC_DATABASE *db;

        if( posc_db EQ psc_db )
        {
          posc_db = pcr_db;
        }
        else if( posc_db EQ pcr_db )
        {
          posc_db = psc_db;
        }
        
        if( prsc_db EQ psc_db )
        {
          prsc_db = pcr_db;
        }
        else if( prsc_db EQ pcr_db )
        {
          prsc_db = psc_db;
        }

        db     = psc_db;
        psc_db = pcr_db;
        pcr_db = db;
      }
      break;

    case( DB_MODE_CC_ACC ):
      if( grr_data->sc_db_mode EQ DB_MODE_CC_REQ )
      {
        grr_data->sc_db_mode = (UBYTE)mode;

        if( psc_db EQ &grr_data->sc_db_1 )
        {
          pcr_db = &grr_data->sc_db_2;
        }
        else
        {
          pcr_db = &grr_data->sc_db_1;
        }
      }
/*
      else
      {
        TRACE_ERROR( "Database mode: !DB_MODE_CC_REQ -> DB_MODE_CC_ACC" );
      }
*/
      break;

    case( DB_MODE_CC_REJ ):
      if( grr_data->sc_db_mode EQ DB_MODE_CC_REQ )
      {
        grr_data->sc_db_mode = (UBYTE)mode;

        if( psc_db EQ &grr_data->sc_db_1 )
        {
          psc_db  = &grr_data->sc_db_2;
          prsc_db = &grr_data->sc_db_1;
          pcr_db  = &grr_data->sc_db_1;
        }
        else
        {
          psc_db  = &grr_data->sc_db_1;
          prsc_db = &grr_data->sc_db_2;
          pcr_db  = &grr_data->sc_db_2;
        }

        posc_db = NULL;
      }
/*
      else
      {
        TRACE_ERROR( "Database mode: !DB_MODE_CC_REQ -> DB_MODE_CC_REJ" );
      }
*/
      break;

    default:
      TRACE_ASSERT( mode EQ DB_MODE_INIT   OR
                    mode EQ DB_MODE_CC_REQ OR
                    mode EQ DB_MODE_CC_ACC OR
                    mode EQ DB_MODE_CC_REJ OR
                    mode EQ DB_MODE_SWAP      );
      break;
  }

  TRACE_EVENT_P6( "mode: %d -> %d, database: psc = %d, posc = %d, prsc = %d, pcr = %d",
                  old_mode, mode,
                  grr_get_db_num( psc_db  ), grr_get_db_num( posc_db ),
                  grr_get_db_num( prsc_db ), grr_get_db_num( pcr_db  ) );

}/* grr_set_db_ptr */

/*
+------------------------------------------------------------------------------
| Function    : grr_init_db_srvc_param
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
LOCAL void grr_init_db_srvc_param ( T_SC_DATABASE *db )
{ 
  T_SC_DATABASE *original_db = psc_db;

  TRACE_FUNCTION( "grr_init_db_srvc_param" );

  psc_db = db;
  
  ctrl_init_params( );

  psi_init( );

  pg_init_params( );

  psc_db = original_db;
  
  grr_set_pbcch( FALSE );

}/* grr_init_db_srvc_param */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_db_num
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
LOCAL UBYTE grr_get_db_num ( T_SC_DATABASE *db )
{ 
  UBYTE db_num;

  TRACE_FUNCTION( "grr_get_db_num" );

  if     ( db EQ NULL               ) db_num = 0;
  else if( db EQ &grr_data->sc_db_1 ) db_num = 1;
  else if( db EQ &grr_data->sc_db_2 ) db_num = 2;
  else                                db_num = 3;

  return( db_num );

}/* grr_get_db_num */

/*
+------------------------------------------------------------------------------
| Function    : grr_init_db
+------------------------------------------------------------------------------
| Description : The function grr_init_db initializes the database in GRR_DATA.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_init_db ( T_SC_DATABASE *db )
{
  TRACE_FUNCTION( "grr_init_db" );
 
  db->cell_info_for_gmm.access_status              = GPRS_ACCESS_BARRED; 
  db->cell_info_for_gmm.cell_info.cell_env.rai.rac = GMMRR_RAC_INVALID;
  db->gprs_attach_is_running                       = FALSE;
  db->non_drx_timer_running                        = FALSE;
  db->non_drx_timer                                = DRX_NO;
  db->nc2_non_drx_period_running                   = FALSE;

  grr_init_db_srvc_param( db );

#ifdef REL99
  db->network_rel = BSS_NW_REL_97;     /*Default Network Release 97 */
#endif

}/* grr_init_db */

/*
+------------------------------------------------------------------------------
| Function    : grr_init
+------------------------------------------------------------------------------
| Description : The function grr_init initializes the entity GRR
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_init ( void )
{ 
  TRACE_FUNCTION( "grr_init" );
  
  /* initialize all GRR data */
  grr_data = &grr_data_base;
  memset( grr_data, 0, sizeof( T_GRR_DATA ) );

  /* initialize the pointers to the databases */
  grr_set_db_ptr( DB_MODE_INIT );

  /* initialize the serving cell databases */
  grr_init_db( psc_db );
  grr_init_db( pcr_db );


  /* 
   * call of service init functions 
   */
  ctrl_init();
  tc_init();
  cpap_init(); 
  psi_init();
  pg_init();
  meas_init( IM_MODE_TRANSFER );
  cs_grr_init();
  gfp_init();

  ccd_register(CCD_REENTRANT);
  
  grr_init_ms_data( );

  grr_data->db.ms_id.old_ptmsi    = GMMRR_TMSI_INVALID;               /* No valid PTMSI*/
  grr_data->db.ms_id.new_ptmsi    = GMMRR_TMSI_INVALID;               /* No valid PTMSI*/
  grr_data->db.ms_id.old_tlli     = GMMRR_TLLI_INVALID;
  grr_data->db.ms_id.new_tlli     = GMMRR_TLLI_INVALID;

  /*
   * SZML-GLBL/003
   */  
  /*set ms capabilty*/
  grr_data->ms_cap[0].Rx   = 1;
  grr_data->ms_cap[0].Tx   = 1;
  grr_data->ms_cap[0].Sum  = 2;
  grr_data->ms_cap[0].Ttb  = 2;
  grr_data->ms_cap[0].Tra  = 4;  /* Tra value for all classes */

  grr_data->ms_cap[1].Rx   = 2;
  grr_data->ms_cap[1].Tx   = 1;
  grr_data->ms_cap[1].Sum  = 3;
  grr_data->ms_cap[1].Ttb  = 2;
  grr_data->ms_cap[1].Tra  = 3;

  grr_data->ms_cap[2].Rx   = 2;
  grr_data->ms_cap[2].Tx   = 2;
  grr_data->ms_cap[2].Sum  = 3;
  grr_data->ms_cap[2].Ttb  = 2;
  grr_data->ms_cap[2].Tra  = 3;

  grr_data->ms_cap[3].Rx   = 3;
  grr_data->ms_cap[3].Tx   = 1;
  grr_data->ms_cap[3].Sum  = 4;
  grr_data->ms_cap[3].Ttb  = 1;
  grr_data->ms_cap[3].Tra  = 3;

  grr_data->ms_cap[4].Rx   = 2;
  grr_data->ms_cap[4].Tx   = 2;
  grr_data->ms_cap[4].Sum  = 4;
  grr_data->ms_cap[4].Ttb  = 1;
  grr_data->ms_cap[4].Tra  = 3;

  grr_data->ms_cap[5].Rx   = 3;
  grr_data->ms_cap[5].Tx   = 2;
  grr_data->ms_cap[5].Sum  = 4;
  grr_data->ms_cap[5].Ttb  = 1;
  grr_data->ms_cap[5].Tra  = 3;

  grr_data->ms_cap[6].Rx   = 3;
  grr_data->ms_cap[6].Tx   = 3;
  grr_data->ms_cap[6].Sum  = 4;
  grr_data->ms_cap[6].Ttb  = 1;
  grr_data->ms_cap[6].Tra  = 3;

  grr_data->ms_cap[7].Rx   = 4;
  grr_data->ms_cap[7].Tx   = 1;
  grr_data->ms_cap[7].Sum  = 5;
  grr_data->ms_cap[7].Ttb  = 1;
  grr_data->ms_cap[7].Tra  = 2;

  grr_data->ms_cap[8].Rx   = 3;
  grr_data->ms_cap[8].Tx   = 2;
  grr_data->ms_cap[8].Sum  = 5;
  grr_data->ms_cap[8].Ttb  = 1;
  grr_data->ms_cap[8].Tra  = 2;

  grr_data->ms_cap[9].Rx   = 4;
  grr_data->ms_cap[9].Tx   = 2;
  grr_data->ms_cap[9].Sum  = 5;
  grr_data->ms_cap[9].Ttb  = 1;
  grr_data->ms_cap[9].Tra  = 2;

  grr_data->ms_cap[10].Rx   = 4;
  grr_data->ms_cap[10].Tx   = 3;
  grr_data->ms_cap[10].Sum  = 5;
  grr_data->ms_cap[10].Ttb  = 1;
  grr_data->ms_cap[10].Tra  = 2;

  grr_data->ms_cap[11].Rx   = 4;
  grr_data->ms_cap[11].Tx   = 4;
  grr_data->ms_cap[11].Sum  = 5;
  grr_data->ms_cap[11].Ttb  = 1;
  grr_data->ms_cap[11].Tra  = 2;


  memset(&grr_data->ta_params, 0xFF, sizeof(T_TA_PARAMS));
  grr_data->ta_params.ta_valid = FALSE;
  grr_data->cc_running         = FALSE;

  grr_data->uplink_tbf.access_type = CGRLC_AT_NULL; /* NO CELL UPDATE NEED */

  grr_data->test_mode = CGRLC_NO_TEST_MODE;

  grr_data->l1_del_tbf_start_fn = GRR_INVALID_FN; 

  grr_set_pbcch( FALSE );

  grr_data->cell_res_status = TRUE;

#ifdef REL99

#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
  psc_db->band_indicator = NOT_PRESENT_8BIT;
#endif

  /* Initialize SGSN release to unknown value at Power ON */
  psc_db->sgsn_rel = PS_SGSN_UNKNOWN;

  cl_nwrl_set_sgsn_release(psc_db->sgsn_rel);

  /* Initialize the BSS release to R97 */
  psc_db->network_rel = BSS_NW_REL_97;
#endif

} /* grr_init() */

/*
+------------------------------------------------------------------------------
| Function    : grr_is_pbcch_present
+------------------------------------------------------------------------------
| Description : grr_is_pbcch_present returns whether the PBCCH is present or not
|
| Parameters  : no parameters
|
+------------------------------------------------------------------------------
*/

GLOBAL BOOL grr_is_pbcch_present (void)
{
  
  return (psc_db->pbcch.bcch.pbcch_present);
}/*grr_is_pbcch_present*/





/*
+------------------------------------------------------------------------------
| Function    : grr_random_value
+------------------------------------------------------------------------------
| Description : This function generates a random value between 0 and max_i-1           
|               The function is current implemented by a random sequence.
|               It may replace by a other generation method in the future,
|               i.e. last bits of framenumber, systemtime or powervalue etc..
|
| Parameters  : max_i -  return_value is between 0 and (max_i-1)
|                        maximum value 256
|
+------------------------------------------------------------------------------
*/
GLOBAL ULONG grr_random_value (UBYTE index, ULONG max_i)
{
  /* The indexing is done to avoid unpredictable distortion of uniform */
  /* probability distribution of random values delivered to a specific */
  /* caller */
  static ULONG next[3] = {1,1,1};
  ULONG return_value;
#ifdef _TARGET_  
  static BOOL initflag[3] = {FALSE,FALSE,FALSE};
  T_TIME time_val;
#endif

  TRACE_FUNCTION( "grr_random_value" );
  
  if(index > 2)
  {
    TRACE_ERROR("Invalid inex in random value generation function");
    return(0);
  }

#ifdef _SIMULATION_
  if (grr_data->tc.res_random)
  {
    UBYTE i;
    TRACE_EVENT( "grr_data->tc.res_random is set" );
    for (i=0; i<3; i++)
    {
      next[i] = 1;
    }
    grr_data->tc.res_random = 0;
  }
#endif


#ifdef _TARGET_
  /* on target each random value sequence is initialized on its first usage */
  /* with system time to get different sequences for each mobile and each   */
  /* caller */
  if(initflag[index] EQ FALSE)
  {
    vsi_t_time (VSI_CALLER &time_val);
    next[index] = (ULONG)time_val;
    initflag[index] = TRUE;
  }
#endif

  next[index] = next[index] * 1103515245 + 12345;
  return_value = (next[index]/65536) % (max_i);

#ifndef _TARGET_
  TRACE_EVENT_P3("random index: %d max: %d value: %d",index, max_i, return_value);
#endif /* _TARGET_ */

  return(return_value);
}


/*
+------------------------------------------------------------------------------
| Function    : grr_decode_tbf_start_abs
|------------------------------------------------------------------------------
| Description : The function grr_decode_tbf_start_abs() translates the TBF- 
|               Starting-Time-Absolute into full frame number. Therefore the 
|               received frame number is needed in grr_data->dl_fn !! 
|
| Parameters  : ptr2tbf_abs - pointer to the tbf_abs structure to be decoded
|
+------------------------------------------------------------------------------
*/
GLOBAL ULONG grr_decode_tbf_start_abs(T_abs *ptr2tbf_abs)
{ 
  ULONG var1,var2,var3,result;
  UBYTE var4;
  TRACE_FUNCTION( "grr_decode_tbf_start_abs" );

  var3 = (ULONG)ptr2tbf_abs->t3;
  var2 = (ULONG)ptr2tbf_abs->t2;
  var1 = (ULONG)ptr2tbf_abs->t1;
        
  result = (51 * ((26+var3 - var2)%26) + var3 + 1326 * var1);
  /* see GSM 04.08 v 6.4.2 section 10.5.2.38 */
  /* T_abs delivers only the fn modulo 42432 so it has to be adjusted to the */
  /* current fn.*/
  result += (grr_data->dl_fn-(grr_data->dl_fn%42432));
  if(result < grr_data->dl_fn)
  {
    if((result + 10808) < grr_data->dl_fn)
    {
      result += 42432;
    }
  }
  else if(result > (grr_data->dl_fn + 31623))
  {
    if(result < 42432)
      result += 2715648;
    result -= 42432;
  }
  /* fn has to be aligned to first tdma frame in a block */
  var4 = (UBYTE)(result%13);
  if(var4 > 8)
    result += (13 - var4);
  else if(var4 > 4)
    result += (8 - var4);
  else if(var4 > 0)
    result += (4 - var4);
  if(FN_MAX <= result)
    result %= FN_MAX;
  return result;
}  /* grr_decode_tbf_start_abs */



/*
+------------------------------------------------------------------------------
| Function    : grr_decode_tbf_start_rel
|------------------------------------------------------------------------------
| Description : The function grr_decode_tbf_start_rel() translates the TBF- 
|               Starting-Time-Relative into full frame number. Therefore the 
|               received frame number is needed in start_fn !! 
|
| Parameters  : rel_pos - number in blocks added to current framenuber
|
+------------------------------------------------------------------------------
*/
GLOBAL ULONG grr_decode_tbf_start_rel(ULONG start_fn, USHORT rel_pos)
{ 
  ULONG result;

  TRACE_FUNCTION( "grr_decode_tbf_start_rel" );
  
  result = 4+4*rel_pos + start_fn + rel_pos/3;
  
  if ((12 EQ (result%13))  OR
       (7 EQ (result%13))  OR
       (3 EQ (result%13)))
  {
    result += 1;  
  }
  if(FN_MAX <= result)
  {
    result %= FN_MAX;
  }

  return result;
}  /* grr_decode_tbf_start_rel */



/*
+------------------------------------------------------------------------------
| Function    : grr_calc_nr_of_set_bits
+------------------------------------------------------------------------------
| Description : this function calculates the number of set bits 
|               (for example timeslots) form value
|
| Parameters  : value - input value
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE grr_calc_nr_of_set_bits (  UBYTE value  )
{ 
  UBYTE tx_slots=0;
  UBYTE mask=128;
  UBYTE i;

  TRACE_FUNCTION( "grr_calc_nr_of_set_bits" );
        
  for(i=0; i<=7; i++)
  {
    if(value & mask)
      tx_slots++;
    mask>>=1;
  }
  /*
  if(tx_slots > 1)
  {
    TRACE_EVENT_P1("MULTISLOT: %d timeslots assigned ",tx_slots);
  }
  */
  return tx_slots;
} /* grr_calc_nr_of_set_bits() */

/*
+------------------------------------------------------------------------------
| Function    : grr_check_dist
+------------------------------------------------------------------------------
| Description : The function grr_check_dist() checks if high_i is bigger/equal 
|               than low_i(modulo calculation). 
|               The return value is true, if high_i is equal to low_i or 
|               bigger than low_i.
| Parameters  : high_i - expected high value
|               low_i  - expected low value
|               dist_i - max. allowed distance between high_i and low_i
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_check_dist ( ULONG high_i, ULONG low_i, ULONG dist_i)
{
  BOOL  result = FALSE;
  ULONG  real_dist;

  TRACE_FUNCTION( "grr_check_dist" );
    
  if (high_i >= low_i)
    real_dist = high_i - low_i;
  else
    real_dist = high_i + (FN_MAX-low_i);

  if (real_dist <= dist_i )
  {
     result = TRUE;
  }
  return result;
} /* grr_check_dist() */

/*
+------------------------------------------------------------------------------
| Function    : handle_ms_cap
+------------------------------------------------------------------------------
| Description : The function handle_ms_cap() checks if the ms capability is 
|               fulfilled or not 
| Parameters  : -
+------------------------------------------------------------------------------
*/
GLOBAL BOOL handle_ms_cap (UBYTE msg_type)
{
  UBYTE ms_class_index, dl_mask, ul_mask;
  BOOL check_ul;
  BOOL check_dl;

  TRACE_FUNCTION( "handle_ms_cap" );

  /*
   * use current slot mask if now new is assigned
   *
   */
  if(grr_data->downlink_tbf.ts_usage)
  {
    dl_mask = grr_data->downlink_tbf.ts_usage;
  }
  else
  {
    dl_mask = grr_data->downlink_tbf.ts_mask;
  }

    
  if(grr_data->uplink_tbf.ts_usage)
  {
    ul_mask = grr_data->uplink_tbf.ts_usage;
  }
  else
  {
    ul_mask = grr_data->uplink_tbf.ts_mask;
  }

  ms_class_index = grr_get_gprs_ms_class( ) - 1;

  switch(msg_type)
  {
    case UL_ASSIGNMENT:
      /* 
       * new uplink assignment received
       */
      check_ul = TRUE;
      if(grr_data->tbf_type EQ CGRLC_TBF_MODE_DL   OR
         grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL  )
      {
        check_dl = TRUE;
      }
      else
      {
        check_dl = FALSE;
      }
      break;
    case DL_ASSIGNMENT:
      /* 
       * new uplink assignment received
       */
      check_dl = TRUE;
      if(grr_data->tbf_type EQ CGRLC_TBF_MODE_UL  OR
         grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL   )
      {
        check_ul = TRUE;
      }
      else
      {
        check_ul = FALSE;
      }
      break;
    case UL_DL_ASSIGNMENT:
      /* 
       * new uplink and downlink assignment received
       */
      check_ul = TRUE;
      check_dl = TRUE;
      break;
    default:
      {
        TRACE_ERROR( "unexpected msg_type" );
        return FALSE;
      }
  }
  if (check_ul  AND
      ((grr_data->uplink_tbf.nts > grr_data->ms_cap[ms_class_index].Tx ) OR (!grr_data->uplink_tbf.nts)))
  {
    TRACE_ERROR( "uplink nts is bigger than allowed ms capability" );

    TRACE_EVENT_P8("MS CLASS ERROR 1: ul_mask=%x ul_nts=%d dl_mask=%x dl_nts=%d ms_class=%d Tx=%d Rx=%d sum=%d"
                                                                ,ul_mask
                                                                ,grr_data->uplink_tbf.nts
                                                                ,dl_mask
                                                                ,grr_data->downlink_tbf.nts
                                                                ,ms_class_index+1
                                                                ,grr_data->ms_cap[ms_class_index].Tx
                                                                ,grr_data->ms_cap[ms_class_index].Rx
                                                                ,grr_data->ms_cap[ms_class_index].Sum);
    return FALSE;
  }
  if (check_dl AND
      ((grr_data->downlink_tbf.nts > grr_data->ms_cap[ms_class_index].Rx) OR (!grr_data->downlink_tbf.nts)))
  {
    TRACE_ERROR( "downlink nts is bigger than allowed ms capability" );

    TRACE_EVENT_P8("MS CLASS ERROR 2:ul_mask=%x ul_nts=%d dl_mask=%x dl_nts=%d ms_class=%d Tx=%d Rx=%d sum=%d"
                                                                ,ul_mask
                                                                ,grr_data->uplink_tbf.nts
                                                                ,dl_mask
                                                                ,grr_data->downlink_tbf.nts
                                                                ,ms_class_index+1
                                                                ,grr_data->ms_cap[ms_class_index].Tx
                                                                ,grr_data->ms_cap[ms_class_index].Rx
                                                                ,grr_data->ms_cap[ms_class_index].Sum);
    return FALSE;
  }

  if (check_dl AND check_ul )
  {
    UBYTE help;

    if (((grr_data->uplink_tbf.nts + grr_data->downlink_tbf.nts)  > grr_data->ms_cap[ms_class_index].Sum) OR
         (!grr_data->uplink_tbf.nts) OR
         (!grr_data->downlink_tbf.nts))
    {
      TRACE_ERROR( "Sum bigger than allowed ms capability" );

      TRACE_EVENT_P8("MS CLASS ERROR 3:ul_mask=%x ul_nts=%d dl_mask=%x dl_nts=%d ms_class=%d Tx=%d Rx=%d sum=%d"
                                                                  ,ul_mask
                                                                  ,grr_data->uplink_tbf.nts
                                                                  ,dl_mask
                                                                  ,grr_data->downlink_tbf.nts
                                                                  ,ms_class_index+1
                                                                  ,grr_data->ms_cap[ms_class_index].Tx
                                                                  ,grr_data->ms_cap[ms_class_index].Rx
                                                                  ,grr_data->ms_cap[ms_class_index].Sum);
      return FALSE;
    }

    help = grr_calculate_Ttb(ul_mask,dl_mask);
    if (help < grr_data->ms_cap[ms_class_index].Ttb)
    {
      TRACE_ERROR("Ttb calculated not equal to the one of the multislot class ");
      TRACE_EVENT_P5("ul_mask=%x dl_mask=%x  ms_class=%d calc_ttb=%d ms_class_TTB=%d "
                                                                ,ul_mask
                                                                ,dl_mask
                                                                ,ms_class_index+1
                                                                ,help
                                                                ,grr_data->ms_cap[ms_class_index].Ttb);
      return FALSE;
    }
    help = grr_calculate_Tra(ul_mask,dl_mask);
    if ( help < grr_data->ms_cap[ms_class_index].Tra )
    {
      TRACE_ERROR("Tra calculated not equal to the one of the multislot class ");
      TRACE_EVENT_P5("ul_mask=%x dl_mask=%x  ms_class=%d calc_tra=%d ms_class_tra=%d "
                                                                ,ul_mask
                                                                ,dl_mask
                                                                ,ms_class_index+1
                                                                ,help
                                                                ,grr_data->ms_cap[ms_class_index].Tra);
      return FALSE;
    }
  }
  return TRUE;
} /* handle_ms_cap() */

/*
+------------------------------------------------------------------------------
| Function    : grr_copy_em1_struct
+------------------------------------------------------------------------------
| Description : The function grr_copy_em1_struct copies the em1 struct 
|               parameters.
|
| Parameters  : db_em1      - em1 structure in the GRR database
|               ext_em1     - em1 structure in the EXT measurement parameter
|               cpy_prm_set - indicates whether the new extended measurement 
|                             parameter overwrite the present ones due to a 
|                             messsage with higher sequence number
|
+------------------------------------------------------------------------------
*/
LOCAL void grr_copy_em1_struct( T_XMEAS_EM1 *db_em1,
                                T_em1       *ext_em1,
                                BOOL         cpy_prm_set,
                                UBYTE       *start_ext_lst_idx,
                                UBYTE       *stop_ext_lst_idx )
{
  UBYTE  i, j, m, n;

  TRACE_FUNCTION("grr_copy_em1_struct");

  if( cpy_prm_set )
  {
    /*
     * Copy EM1 struct parameters
     */
    db_em1->param.reporting_type = REP_TYPE_1;
    if(ext_em1->flag)
    {
      /*
       * check ext_reporting_type
       */
      switch(ext_em1->xrep_type)
      {
        case XREP_TYPE1:    /* 00 */
          db_em1->param.reporting_type = REP_TYPE_1;
          break;
        case XREP_TYPE2:    /* 01 */
          db_em1->param.reporting_type = REP_TYPE_2;
          db_em1->param.ncc_permitted  = ext_em1->ncc_permitted;
          break;
        case XREP_TYPE3:    /* 10 */
          db_em1->param.reporting_type = REP_TYPE_3;
          if(ext_em1->v_int_freq)
          {
            db_em1->param.int_frequency = ext_em1->int_freq;
          }
          else
          {
            db_em1->param.int_frequency = NOT_SET;
          }
          break;
        case XREP_RESERVED: /* 11 */
          db_em1->param.reporting_type = REP_TYPE_RES;
          break;
      }
    }

    /*
     * Check ext reporting period
     */
    db_em1->param.reporting_period = EXT_REP_PER_DEFAULT;
    if(ext_em1->v_xrep_per)
    {
      db_em1->param.reporting_period = ext_em1->xrep_per;
    }
  }

  /*
   * Copy extended frequency list Parameters
   */
  if(db_em1->list.number < RRGRR_MAX_ARFCN_EXT_MEAS)
  {
    /*
     * copy first EXT Frequency list structure
     */
    j                    = db_em1->list.number;
    *start_ext_lst_idx   = db_em1->list.number;
    db_em1->list.freq[j] = ext_em1->xfreq_list.start_freq;
    j++;

    /*
     * check remaining frequencies
     */
    for( i = 0;
         i < ext_em1->xfreq_list.nr_freq AND j < RRGRR_MAX_ARFCN_EXT_MEAS;
         i++ )
    {
      db_em1->list.freq[j] = 
        ( db_em1->list.freq[j-1] + ext_em1->xfreq_list.freq_diff_struct[i].freq_diff ) % 1024;
      j++;
    }

    /*
     * check whether EXT Frequency list structure is repeated
     */
    if(ext_em1->v_xfreq_list2)
    {
      for( m = 0; 
           m < ext_em1->c_xfreq_list2 AND j < RRGRR_MAX_ARFCN_EXT_MEAS;
           m++ )
      {
        db_em1->list.freq[j] = ext_em1->xfreq_list2[m].start_freq;
        j++;

        for( n = 0;
             n < ext_em1->xfreq_list2[m].nr_freq AND j < RRGRR_MAX_ARFCN_EXT_MEAS; 
             n++ )
        {
          db_em1->list.freq[j] =
            ( db_em1->list.freq[j-1] + ext_em1->xfreq_list2[m].freq_diff_struct[n].freq_diff ) % 1024;
          j++;
        }
      }
    }
    db_em1->list.number = j;
    *stop_ext_lst_idx   = db_em1->list.number - 1;
  }
  else
  {
    TRACE_ERROR("grr_copy_em1_struct EXT frequency list full");
  }
}/* grr_copy_em1_struct*/

/*
+------------------------------------------------------------------------------
| Function    : grr_prcs_xmeas_struct
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : db_xmeas    - extended measurement parameter in the GRR database
|               air_xmeas   - extended measurement parameter of the air interface
|                             message
|               cpy_prm_set - indicates whether the new extended measurement 
|                             parameter overwrite the present ones due to a 
|                             messsage with higher sequence number
|               new_idx     - sequence number of the message
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_prcs_xmeas_struct ( T_XMEAS     *db_xmeas, 
                                    T_xmeas_par *air_xmeas,
                                    BOOL         cpy_prm_set,
                                    UBYTE        new_inst_idx,
                                    UBYTE       *start_ext_lst_idx,
                                    UBYTE       *stop_ext_lst_idx )
{ 
  TRACE_FUNCTION( "grr_prcs_xmeas_struct" );
  
  /*
   * check ext meas order parameters:
   */
  switch(air_xmeas->xmeas_order)
  {
    case XMEAS_EM1:      /* 01 */
      db_xmeas->em_order_type = EM_EM1;
  
      if( cpy_prm_set )
      {
        db_xmeas->idx = new_inst_idx;
      }

      grr_copy_em1_struct( &db_xmeas->em1, &air_xmeas->em1, cpy_prm_set, 
                           start_ext_lst_idx, stop_ext_lst_idx );
      break;
    case XMEAS_RESET:    /* 11 */
      db_xmeas->em_order_type = EM_RESET;
      break;
    case XMEAS_EM0:      /* 00 */
    case XMEAS_RESERVED: /* 10 it is reseved but shall be interpreted as EM0 by the receiver */
      db_xmeas->em_order_type = EM_EM0;
      break;
  }
}/* grr_prcs_xmeas_struct */

/*
+------------------------------------------------------------------------------
| Function    : grr_init_xmeas_struct
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : xmeas  - pointer to extended measurement parameter
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_init_xmeas_struct( T_XMEAS *xmeas )
{ 
  TRACE_FUNCTION( "grr_init_xmeas_struct" );
  
  xmeas->idx                     = NOT_SET;
  xmeas->em_order_type           = EM_EMPTY;
  xmeas->em1.list.number         = 0;
  xmeas->em1.param.int_frequency = NOT_SET;
}/* grr_init_xmeas_struct */

/*
+------------------------------------------------------------------------------
| Function    : grr_prcs_nc_freq_list
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : db_list    - NC frequency list in the GRR database
|               v_air_list - valid flag for NC frequency list of the air
|                            interface message
|               air_list   - NC frequency list of the air interface message
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_prcs_nc_freq_list ( T_NC_LIST       *nc_list,
                                    T_NC_RFREQ_LIST *rfreq_list,
                                    BOOL             v_air_list,
                                    T_nc_freq_list  *air_list,
                                    T_INFO_TYPE      type,
                                    UBYTE            instance )
{ 
  UBYTE i, j; /* used for counting */

  TRACE_FUNCTION( "grr_prcs_nc_freq_list" );

  if( v_air_list EQ TRUE )
  {
    if( air_list->v_list_rf EQ TRUE )
    {
      /* process the list of removed frequencies */
      for( i = 0;
           i                  < air_list->list_rf.c_rfreq_index AND
           rfreq_list->number < MAX_NR_OF_NCELL; 
           i++ )
      {
        rfreq_list->idx[rfreq_list->number] = air_list->list_rf.rfreq_index[i];
        
        rfreq_list->number++;
      }      

      if( i < air_list->list_rf.c_rfreq_index )
      {
        TRACE_ERROR( "grr_prcs_nc_freq_list removed frequency list full" );
      }
    }

    if( air_list->v_list_af EQ TRUE )
    {
      UBYTE  number    = 0;
      USHORT last_freq;

      /* process the list of added frequencies */
      for( i = 0; i < air_list->c_list_af; i++ )
      {
        last_freq = 0;

        if( grr_store_cs_param
              ( nc_list,
                air_list->list_af[i].v_cs_par,
                &air_list->list_af[i].cs_par,
                type,
                instance,
                &number,
                &last_freq,
                air_list->list_af[i].start_freq,
                air_list->list_af[i].bsic ) EQ FALSE )
        {
          TRACE_EVENT( "grr_prcs_nc_freq_list: NC_MS list full" );

          return( v_air_list );
        }
        
        for( j = 0; j < air_list->list_af[i].nr_freq; j++ )
        {
          if( grr_store_cs_param
                ( nc_list,
                  air_list->list_af[i].afreq_s[j].v_cs_par,
                  &air_list->list_af[i].afreq_s[j].cs_par,
                  type,
                  instance,
                  &number,
                  &last_freq,
                  air_list->list_af[i].afreq_s[j].freq_diff_struct.freq_diff,
                  air_list->list_af[i].afreq_s[j].bsic ) EQ FALSE )
          {
            TRACE_EVENT( "grr_prcs_nc_freq_list: NC_MS list full" );

            return( v_air_list );
          }
        }
      }      
    }
  }

  return( v_air_list );
}/* grr_prcs_nc_freq_list */

/*
+------------------------------------------------------------------------------
| Function    : grr_prcs_nc_freq_final
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_prcs_nc_freq_final ( T_NC_LIST       *dest_list,
                                     T_NC_RFREQ_LIST *dest_rfreq,
                                     BOOL            *v_src_list_rfreq,
                                     T_NC_LIST       *src_list,
                                     T_NC_RFREQ_LIST *src_rfreq )
{ 
  BOOL  is_pbcch_present = grr_is_pbcch_present( );
  BOOL  is_identical;
  UBYTE i;

  TRACE_FUNCTION( "grr_prcs_nc_freq_final" );

  if( *v_src_list_rfreq EQ TRUE )
  {
    *v_src_list_rfreq = FALSE;

    /*
     * The change mark values should be increased in case 
     * at least one parameter has changed
     */
    if( dest_list->number  EQ src_list->number  AND
        dest_rfreq->number EQ src_rfreq->number     )
    {
      is_identical = TRUE;
    
      for( i = 0; i < dest_list->number AND is_identical; i++ )
      {
        if( is_pbcch_present )
        {
          is_identical =
            ( dest_list->info[i].arfcn EQ src_list->info[i].arfcn AND
              dest_list->info[i].bsic  EQ src_list->info[i].bsic      );
        }
        else
        {
          is_identical =
            ( dest_list->info[i].arfcn EQ src_list->info[i].arfcn );
        }
      }

      for( i = 0; i < dest_rfreq->number AND is_identical; i++ )
      {
        is_identical = ( dest_rfreq->idx[i] EQ src_rfreq->idx[i] );
      }
    }
    else
    {
      is_identical = FALSE;
    }

    if( !is_identical )
    {
      dest_list->chng_mrk.curr++;
    }

    /* copy remaining parameters except change mark */
    dest_list->number = src_list->number;

    memcpy( dest_list->info, src_list->info,
            sizeof( T_ncell_info ) * src_list->number );

    memcpy( dest_rfreq, src_rfreq, sizeof( T_NC_RFREQ_LIST ) );
  }
  else
  {
    if( dest_list->number NEQ 0 OR dest_rfreq->number NEQ 0 )
    {
      dest_list->number  = 0;
      dest_rfreq->number = 0;

      dest_list->chng_mrk.curr++;
    }
  }
}/* grr_prcs_nc_freq_final */

/*
+------------------------------------------------------------------------------
| Function    : grr_prcs_nc_param_struct
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : db_nc        - NC measurement parameter in the GRR database
|               air_nc       - NC measurement parameter of the air interface
|                              message
|               new_idx      - sequence number of the message
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_prcs_nc_param_struct ( T_NC_PARAM    *db_nc,
                                       T_nc_meas_par *ext_nc,
                                       UBYTE          new_idx )
{ 
  T_NC_ORDER ctrl_order;  /* NETWORK_CONTROL_ORDER */
  UBYTE      non_drx_per; /* NC_NON_DRX_PERIOD     */
  UBYTE      rep_per_i;   /* NC_REPORTING_PERIOD_I */
  UBYTE      rep_per_t;   /* NC_REPORTING_PERIOD_T */

  TRACE_FUNCTION( "grr_prcs_nc_param_struct" );

  /*
   * Store the network control order value in a temporary buffer
   */
  switch( ext_nc->ctrl_order )
  {
    case NCMEAS_NC0   : ctrl_order = NC_NC0;   break;
    case NCMEAS_NC1   : ctrl_order = NC_NC1;   break;
    case NCMEAS_NC2   : ctrl_order = NC_NC2;   break;
    case NCMEAS_RESET : 
    default           : ctrl_order = NC_RESET; break;
  }
 
  /*
   * Store the remaining parameters in temporary buffers
   */
  if(ext_nc->v_nc_meas_per)
  {
    non_drx_per = ext_nc->nc_meas_per.non_drx_per;
    rep_per_i   = ext_nc->nc_meas_per.rep_per_i;
    rep_per_t   = ext_nc->nc_meas_per.rep_per_t;
  }
  else
  {
    /*
     * Use default values, see 04.60 PSI5 Information Element Details
     */
    non_drx_per = NC_NON_DRX_PER_DEFAULT;
    rep_per_i   = NC_REP_PER_I_DEFAULT;
    rep_per_t   = NC_REP_PER_T_DEFAULT;
  }

  /*
   * The change mark values should be increased in case 
   * at least one parameter has changed
   */
  if( db_nc->ctrl_order  NEQ ctrl_order  OR
      db_nc->non_drx_per NEQ non_drx_per OR
      db_nc->rep_per_i   NEQ rep_per_i   OR
      db_nc->rep_per_t   NEQ rep_per_t      )
  {
    db_nc->chng_mrk.curr++;
  }

  db_nc->idx         = new_idx;
  db_nc->ctrl_order  = ctrl_order;
  db_nc->non_drx_per = non_drx_per;
  db_nc->rep_per_i   = rep_per_i;
  db_nc->rep_per_t   = rep_per_t;
}/* grr_prcs_nc_param_struct */

/*
+------------------------------------------------------------------------------
| Function    : grr_prcs_nc_param_final
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_prcs_nc_param_final ( T_NC_PARAM *dest_nc, 
                                      BOOL       *v_src_nc,
                                      T_NC_PARAM *src_nc )
{ 
  TRACE_FUNCTION( "grr_prcs_nc_param_final" );

  if( *v_src_nc EQ TRUE )
  {
    *v_src_nc = FALSE;

    /*
     * The change mark values should be increased in case 
     * at least one parameter has changed
     */
    if( dest_nc->ctrl_order  NEQ src_nc->ctrl_order  OR
        dest_nc->non_drx_per NEQ src_nc->non_drx_per OR
        dest_nc->rep_per_i   NEQ src_nc->rep_per_i   OR
        dest_nc->rep_per_t   NEQ src_nc->rep_per_t      )
    {
      dest_nc->chng_mrk.curr++;
    }

    /* Copy remaining parameters except change mark */
    dest_nc->idx         = src_nc->idx;
    dest_nc->ctrl_order  = src_nc->ctrl_order;
    dest_nc->non_drx_per = src_nc->non_drx_per;
    dest_nc->rep_per_i   = src_nc->rep_per_i;
    dest_nc->rep_per_t   = src_nc->rep_per_t;
  }
}/* grr_prcs_nc_param_final */

/*
+------------------------------------------------------------------------------
| Function    : grr_init_ncmeas_struct
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : ncmeas - pointer to NC measurement parameter
|               is_cw  - indicates whether the parameter pointer is related
|                        to cell wide or MS specific information
|
+------------------------------------------------------------------------------
*/
LOCAL void grr_init_ncmeas_struct( T_NCMEAS *ncmeas, BOOL is_cw )
{ 
  TRACE_FUNCTION( "grr_init_ncmeas_struct" );
  
  grr_init_nc_param( &ncmeas->param, is_cw );
  grr_init_nc_list( &ncmeas->list );
}/* grr_init_ncmeas_struct */

/*
+------------------------------------------------------------------------------
| Function    : grr_init_ncmeas_extd_struct
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : extd  - pointer to NC measurement extended parameter
|               is_cw - indicates whether the parameter pointer is related
|                       to cell wide or MS specific information
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_init_ncmeas_extd_struct ( T_NCMEAS_EXTENDED *extd, BOOL is_cw )
{ 
  TRACE_FUNCTION( "grr_init_ncmeas_extd_struct" );
  
  grr_init_ncmeas_struct( &extd->ncmeas, is_cw );
  grr_init_rfreq_list( &extd->rfreq );

#if defined (REL99) AND defined (TI_PS_FF_EMR)
  /* 
   * If PMO has not been received, PMO_USED shall be set to zero. 
   * Refer 3GPP TS 04.60 V8.17.0 (2002-12) Table 11.2.9d.2 
   */
  extd->pmo_ind = 0;
  extd->psi3_cm = NOT_SET;
  extd->ba_ind = NOT_SET;
#endif

}/* grr_init_ncmeas_extd_struct */

/*
+------------------------------------------------------------------------------
| Function    : grr_init_nc_list
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : list  - pointer to NC measurement list
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_init_nc_list( T_NC_LIST *list )
{ 
  TRACE_FUNCTION( "grr_init_nc_list" );
  
  list->number = 0;
}/* grr_init_nc_list */

/*
+------------------------------------------------------------------------------
| Function    : grr_init_nc_param
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : param - pointer to NC measurement parameter
|               is_cw - indicates whether the parameter pointer is related
|                       to cell wide or MS specific information
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_init_nc_param( T_NC_PARAM *param, BOOL is_cw )
{ 
  TRACE_FUNCTION( "grr_init_nc_param" );
  
  param->ctrl_order = ( is_cw EQ TRUE ? NC_NC0 : NC_EMPTY );
  param->idx        = NOT_SET;
}/* grr_init_nc_param */

/*
+------------------------------------------------------------------------------
| Function    : grr_init_rfreq_list
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : list  - pointer to NC measurement removed frequency list
|
+------------------------------------------------------------------------------
*/
LOCAL void grr_init_rfreq_list ( T_NC_RFREQ_LIST *list )
{ 
  TRACE_FUNCTION( "grr_init_rfreq_list" );
  
  list->number = 0;
}/* grr_init_rfreq_list */

/*
+------------------------------------------------------------------------------
| Function    : grr_sort_ext_lst_freq
+------------------------------------------------------------------------------
| Description : 
| Parameters  : 
+------------------------------------------------------------------------------
*/
GLOBAL void grr_sort_ext_lst_freq ( T_EXT_FREQ_LIST  *list,
                                    UBYTE             max_number,
                                    T_EXT_START_STOP *start_stop )
{
  UBYTE           i, j;     /* used for counting                    */
  T_EXT_FREQ_LIST tmp_list; /* temporary copy of EXT frequency list */

  tmp_list.number = 0;


  TRACE_FUNCTION( "grr_sort_ext_lst_freq" );

  for( i = 0; i < max_number; i++ )
  {
    if( start_stop[i].start NEQ RRGRR_INVALID_IDX AND 
        start_stop[i].stop  NEQ RRGRR_INVALID_IDX     )
    {
      for( j  = start_stop[i].start;
           j <= start_stop[i].stop;
           j++ )
      {
        tmp_list.freq[tmp_list.number] = list->freq[j];
        tmp_list.number++;
      }
    }
  }

  for( j = 0; j < tmp_list.number; j++ )
  {
    list->freq[j] = tmp_list.freq[j];
  }

  grr_mrk_ext_lst_freq( list );
} /* grr_sort_ext_lst_freq() */

/*
+------------------------------------------------------------------------------
| Function    : grr_mrk_ext_lst_freq
+------------------------------------------------------------------------------
| Description : ...
|
| Parameters  : ...
|
+------------------------------------------------------------------------------
*/
LOCAL void grr_mrk_ext_lst_freq ( T_EXT_FREQ_LIST *list )
{ 
  UBYTE i, j;

  TRACE_FUNCTION( "grr_mrk_ext_lst_freq" );

  if( list->number NEQ 0 )
  {
    for( i = 0; i < list->number - 1; i++ )
    {
      for( j = i + 1; 
           j < list->number AND IS_NOT_FLAGGED( list->freq[i],
                                                EM_VLDTY_ARFCN_MASK, 
                                                EM_NON_VLD_ARFCN );
           j++ )
      {
        if( list->freq[i] EQ list->freq[j] )
        {
          SET_FLAG( list->freq[i], EM_VLDTY_ARFCN_MASK, EM_NON_VLD_ARFCN, USHORT );       
        }
      }
    }
  }
}/* grr_mrk_ext_lst_freq */







/*
+------------------------------------------------------------------------------
| Function    : grr_create_channel_list
+------------------------------------------------------------------------------
| Description : The function grr_create_channel_list()  
|               Use a function from RR entity to extract frequencies from a frequency list structure
|               defined in 04.08
|               This function copies the frequencies into list. This function takes the arranging
|               of ARFCN into account cf. 12.10a GPRS Mobile Allocation in 04.60
| Parameters  : T_rfl*: pointer to the rfl received in PSI2 and UBYTE*list: pointer to 
|               the list similar to T_LIST
+------------------------------------------------------------------------------
*/
GLOBAL void grr_create_channel_list(T_rfl* rfl, UBYTE* list)
{
  T_f_range rfl_contents;
  UBYTE i;

  TRACE_FUNCTION( "grr_create_channel_list" );
  /*
   * Copy RFL contents into the T_LIST
   */
  memset (&rfl_contents, 0, sizeof(T_f_range));
  /* 
   * Length in bits
   */
  rfl_contents.l_f = (rfl->rfl_cont_len+3)*8;
  /*
   * Copy RFL content bits into the structure
   */
  for(i=0; i < rfl->c_rfl_cont; i++)
  {
    rfl_contents.b_f[i] = rfl->rfl_cont[i].flist;
  }
        
  /*
   * Use a function from RR
   * This function copies the frequencies into list. This function takes the arranging
   * of ARFCN into account cf. 12.10a GPRS Mobile Allocation in 04.60
   */
  for_create_channel_list (&rfl_contents, (T_LIST*)list);

}/* grr_create_channel_list */


/*
+------------------------------------------------------------------------------
| Function    : grr_get_si_cell_alloc_list
+------------------------------------------------------------------------------
| Description : 
|      
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
LOCAL void grr_get_si_cell_alloc_list( T_LIST *list )
{
#ifndef _TARGET_

  T_LIST cell_chan_des = {
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,
    0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0x00,0x00 }; 

#endif

  TRACE_FUNCTION( "grr_get_si_cell_alloc_list" );

  /*
   * Use cell allocation in SI1
   */

  /* Cell allocation is stored in rr at                                 */
  /* rr_data->sc_data.cd.cell_chan_desc for now use hazardous hack of   */
  /* access database of RR entity later make a new entity that replaces */
  /* RR and GRR or make a communication between RR and GRR to transfer  */
  /* list.                                                              */
  /* Used selfmade glumps hack function in RR to get cell allocation    */
  /* because getting typedefs from RR to use rr_data pointer is not     */
  /* that easy cause by name equalities in RR and GRR                   */

#ifndef _TARGET_

  srv_merge_list( list, &cell_chan_des );

#else
   
  /* TRACE_EVENT( "Use cell allocation in S1" ); */

  srv_get_cell_alloc_list( list );

#endif

} /* grr_get_si_cell_alloc_list */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_psi_cell_alloc_list
+------------------------------------------------------------------------------
| Description : 
|      
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL grr_get_psi_cell_alloc_list ( T_LIST *list )
{
  BOOL  rfl_not_found = FALSE;
  
  UBYTE n;
  UBYTE i;

  TRACE_FUNCTION( "grr_get_psi_cell_alloc_list" );

  for( n = 0; n < MAX_CELL_ALLOC; n++ )
  {
    if( psc_db->cell_alloc[n].rfl_num EQ NOT_SET )
    {
      if( n EQ 0 )
      {
#ifdef _SIMULATION_

        TRACE_ASSERT( FALSE );

#endif /* #ifdef _SIMULATION_ */

        rfl_not_found = TRUE;
      }
     
      break;
    }

    /* find rfl list with that number */
    i = 0;
   
    /* do not check the RFL received in an assignment message */
    while( i < MAX_RFL )
    {
      if( psc_db->rfl[i].num EQ psc_db->cell_alloc[n].rfl_num )
      {
        /* TRACE_EVENT_P1( "psc_db->rfl[i].num:%d", psc_db->rfl[i].num ); */
        break;
      }

      i++;
    }

    if( MAX_RFL > i )
    {
      srv_merge_list( list,                            /* output, result */ 
                      (T_LIST *)psc_db->rfl[i].list );
    }
    else
    {
#ifdef _SIMULATION_

      TRACE_ASSERT( FALSE );

#endif /* #ifdef _SIMULATION_ */

      rfl_not_found = TRUE;
      break;
    }
  }

  return( rfl_not_found EQ FALSE );

} /* grr_get_psi_cell_alloc_list */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_ms_alloc_list
+------------------------------------------------------------------------------
| Description : 
|      
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL grr_get_ms_alloc_list ( T_LIST             *list,
                                   const T_gprs_ms_alloc_ie *ms_alloc )
{
  BOOL  rfl_not_found = FALSE;
  
  UBYTE n;
  UBYTE i;

  TRACE_FUNCTION( "grr_get_ms_alloc_list" );

  for( n = 0; n < ms_alloc->c_rfl_num_list; n++ )
  {
    if( ms_alloc->rfl_num_list[n].rfl_num EQ NOT_SET )
    {
#ifdef _SIMULATION_

      TRACE_ASSERT( FALSE );

#endif /* #ifdef _SIMULATION_ */

      rfl_not_found = TRUE;
      break;
    }

    /* find rfl list with that number */
    i = 0;
    
    while( i <= MAX_RFL )
    {
      if( psc_db->rfl[i].num EQ ms_alloc->rfl_num_list[n].rfl_num )
      {
        break;
      }

      i++;
    }

    if( MAX_RFL >= i )
    {
      srv_merge_list( list,                            /* output, result */ 
                      (T_LIST *)psc_db->rfl[i].list );
    }
    else
    {
#ifdef _SIMULATION_

      TRACE_ASSERT( FALSE );

#endif /* #ifdef _SIMULATION_ */

      rfl_not_found = TRUE;
      break;
    }
  }

  return( rfl_not_found EQ FALSE );

} /* grr_get_ms_alloc_list */

/*
+------------------------------------------------------------------------------
| Function    : grr_create_freq_list
+------------------------------------------------------------------------------
| Description : The function grr_create_freq_list()  
|      
|               Get the according GPRS Mobile Allocation: Take into account MA_NUMBER
|               Write frequencies into frequency list
|      
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_create_freq_list( UBYTE          ma_num,
                                  UBYTE          maio,
                                  T_p_chan_sel  *chan_sel,
                                  T_p_freq_list *freq_list )
{
  BOOL                pbcch_is_present = grr_is_pbcch_present( );
  UBYTE               n                = 0;
  T_gprs_ms_alloc_ie *gp_ma            = NULL;
  
  T_LIST list1;
  USHORT list2[64];
  
  TRACE_FUNCTION( "grr_create_freq_list" );

  memset(&list1, 0, sizeof(T_LIST));
  memset(list2, NOT_PRESENT_16BIT, sizeof(list2));

  gp_ma = grr_get_gprs_ma (ma_num);
  
  if( gp_ma EQ NULL )
  {
    TRACE_EVENT("No valid GPRS_MA found");
    return FALSE;
  }

  /*
   * Copy hopping sequence number and mobile allocation index offset
   */
  chan_sel->p_rf_ch.arfcn = ( ( USHORT )gp_ma->hsn << 8 ) | ( USHORT )maio;

  /* Now we have the GPRS Mobile Allocation corresponding to the ma_num.
   * Get the referenced set of radio frequency lists for this
   * particular GPRS Mobile Allocation IE.
   * If RFL number list is not present in the IE, then cell allocation
   * would be returned by this function.
   */
  if(!grr_get_ref_list_or_cell_allocation(&list1,gp_ma,ma_num))
  {
     TRACE_ERROR("Could not get ref list");
     return FALSE;
  }

  /*
   * Copy ARFCN values into freq_list
   */
  srv_create_list (&list1, list2, 64, TRUE, 0);

  /*
   * Take MA_BITMAP or ARFCN_INDEX into account
   */
  grr_ma_filter_list( 
                      list2, /* input*/
                      freq_list->p_rf_chan_no.p_radio_freq, /* output*/
                      gp_ma
                     );

  /*
   * Get number of copied frequencies
   */
  if(!grr_validate_and_count_frequencies(freq_list->p_rf_chan_no.p_radio_freq,
                                                  &(freq_list->p_rf_chan_cnt)))
  {
    TRACE_ERROR( "grr_create_freq_list: validation failed/freq count zero" );
    return FALSE;
  }
  
  chan_sel->hopping        = 1;  
  
  /* Frequencies stored in freq_list are in form used by 3GPP(g23) standards.
   * convert them to the form used by L1.
   */
  for( n = 0; n < freq_list->p_rf_chan_cnt; n++ )     
  {
    freq_list->p_rf_chan_no.p_radio_freq[n] = 
                grr_g23_arfcn_to_l1( freq_list->p_rf_chan_no.p_radio_freq[n] );
  }

  return TRUE;

}/* grr_create_freq_list*/


/*
+------------------------------------------------------------------------------
| Function    : grr_ma_filter_list
+------------------------------------------------------------------------------
| Description : The function grr_ma_filter_list()  
|               takes MA_BITMAP or ARFCN_INDEX into account
|
|      
| Parameters  : list1 pointer to the input list
|               list2: pointer to the output list
|               gp_ma: pointer to the GPRS Mobile Allocation
+------------------------------------------------------------------------------
*/
GLOBAL void grr_ma_filter_list( 
                               USHORT* list1, /* input*/
                               USHORT* list2, /* output*/
                               const T_gprs_ms_alloc_ie* gp_ma
                               )
{
  UBYTE m,n,i,j;
  TRACE_FUNCTION("grr_ma_filter_list");

  if(gp_ma->v_ma_struct)
  {
    /*
     * MA_BITMAP is valid. First received bit corresponds to the last of T_LIST
     * and the last value of
     */
    i=0, j=0;
    for(n=gp_ma->ma_struct.c_ma_map; n NEQ 0; n--)
    {
      if(gp_ma->ma_struct.ma_map[n-1])
      {
        /*
         * Corresponding frequency is valid
         */
        list2[j] = list1[i];
        j++;
      }
      i++;
      if(list1[i] EQ NOT_PRESENT_16BIT)
        break;
    }
    list2[j] = NOT_PRESENT_16BIT;
  }
  else
  {
    /*
     * Check whether ARFCN list is valid or not
     */
    if(gp_ma->v_arfcn_index_list)
    {
      BOOL is_index_in_the_list=FALSE;
      /*
       * ARFCN Index list is valid
       */
      i=0, j=0;
      for(n=0; n < 64; n++)
      {
        for(m=0; m < gp_ma->c_arfcn_index_list; m++)
        {
          if(n EQ gp_ma->arfcn_index_list[m].arfcn_index)
          {
            /*
             * ARFCN_INDEX is in the list
             */
            is_index_in_the_list = TRUE;
            break;
          }
        }
        if(!is_index_in_the_list)
        {
          list2[j] = list1[i];
          j++;
        }
        is_index_in_the_list = FALSE;
        i++;
        
        if(list1[i] EQ NOT_PRESENT_16BIT)
          break;
      }
      list2[j] = NOT_PRESENT_16BIT;
    }
    else
    {
      /*
       * All radio frequencies are valid
       */
      /*list2 = list1;*/
      memcpy(list2, list1, 64*sizeof(USHORT));
    }
  }
}/* grr_ma_filter_list*/








/*
+------------------------------------------------------------------------------
| Function    : grr_calc_t_diff
+------------------------------------------------------------------------------
| Description : The function grr_calc_t_diff() calculates the difference 
|               between two time stamps taken into account an overflow of the
|               system ticks counter value.
|
| Parameters  : t_start - starting time
|               t_stop  - stopping time
|
+------------------------------------------------------------------------------
*/
GLOBAL T_TIME grr_calc_t_diff (T_TIME t_start, T_TIME t_stop)
{
  T_TIME t_diff;

  TRACE_FUNCTION("grr_calc_t_diff");
  
  if( t_start <= t_stop )
  {
    t_diff = t_stop - t_start;
  }
  else
  {
    t_diff = t_stop + ( ( ~ ( (T_TIME)0 ) ) - t_start ) + 1;
  }

  return( t_diff );
}/*grr_calc_t_diff()*/

/*
+------------------------------------------------------------------------------
| Function    : grr_prepare_db_for_new_cell
+------------------------------------------------------------------------------
| Description : The function grr_prepare_db_for_new_cell prepares the psi 
|               parameters and sc_db parameters like pbcch and pccch for
|               reading new SI13 and if needed PSI messages
|
| Parameters  : void
+------------------------------------------------------------------------------
*/
GLOBAL void grr_prepare_db_for_new_cell ( void )
{
  TRACE_FUNCTION("grr_prepare_db_for_new_cell");
   
  psi_init();

  /*initial PCCCH organization parameters */
  memset(&psc_db->pccch, 0, sizeof(T_pccch_org_par)); 

  /* Initial paging group*/
  memset(&psc_db->paging_group, 0, sizeof(T_PAGING_GROUP));

  psc_db->cell_info_for_gmm.cell_info.cell_env.rai.rac = GMMRR_RAC_INVALID;

  grr_set_pbcch( FALSE );

}/* grr_prepare_db_for_new_cell*/


/*
+------------------------------------------------------------------------------
| Function    : grr_is_non_drx_mode
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_is_non_drx_mode ( void )
{
  TRACE_FUNCTION( "grr_is_non_drx_mode" );

  return( grr_data->ms.split_pg_cycle   EQ  GMMRR_NO_DRX       OR
          ( grr_data->ms.split_pg_cycle NEQ GMMRR_NO_DRX AND 
            grr_is_non_drx_period( )    EQ  TRUE             )    );

}/* grr_is_non_drx_mode */

/*
+------------------------------------------------------------------------------
| Function    : grr_is_non_drx_period
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : Input: void
|               Return: Sends TRUE if one of the three NON DRX period is valid,
|                       otherwise FALSE;
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_is_non_drx_period ( void )
{
  TRACE_FUNCTION( "grr_is_non_drx_period" );

  return( psc_db->gprs_attach_is_running     OR
          psc_db->non_drx_timer_running      OR
          psc_db->nc2_non_drx_period_running    );

}/* grr_is_non_drx_period */

/*
+------------------------------------------------------------------------------
| Function    : grr_handle_non_drx_period
+------------------------------------------------------------------------------
| Description : Handles the timer of non DRX mode
|
| Parameters  : non_drx_type          - type of non DRX mode
|               non_drx_timer_running - indicates whether non DRX period 
|                                       is active or not
+------------------------------------------------------------------------------
*/
GLOBAL void grr_handle_non_drx_period ( T_NON_DRX_TYPE non_drx_type,
                                        BOOL           non_drx_timer_running )
{ 
  TRACE_FUNCTION( "grr_handle_non_drx_period" );
  
  switch( non_drx_type )
  {
    case TRANSFER_NDRX:
      psc_db->non_drx_timer_running      = non_drx_timer_running;
      break;

    case GMM_NDRX:
      psc_db->gprs_attach_is_running     = non_drx_timer_running;
      break;

    case NC2_NDRX:
      psc_db->nc2_non_drx_period_running = non_drx_timer_running;
      break;
  }

  pg_non_drx( );

}/*grr_handle_non_drx_period*/ 

/*
+------------------------------------------------------------------------------
| Function    : grr_store_g_pwr_par
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_store_g_pwr_par ( T_g_pwr_par *g_pwr_par )
{ 
  TRACE_FUNCTION( "grr_store_g_pwr_par" );
  
  psc_db->v_g_pwr_par = TRUE;

  psc_db->g_pwr_par.alpha           = CLIP_ALPHA( g_pwr_par->alpha );
  psc_db->g_pwr_par.t_avg_w         = CLIP_T_AVG( g_pwr_par->t_avg_w );
  psc_db->g_pwr_par.t_avg_t         = CLIP_T_AVG( g_pwr_par->t_avg_t );
  psc_db->g_pwr_par.pb              = g_pwr_par->pb;
  psc_db->g_pwr_par.pc_meas_chan    = g_pwr_par->pc_meas_chan;
  psc_db->g_pwr_par.imeas_chan_list = g_pwr_par->imeas_chan_list;
  psc_db->g_pwr_par.n_avg_i         = g_pwr_par->n_avg_i;

  grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param = TRUE;

} /* grr_store_g_pwr_par */

/*
+------------------------------------------------------------------------------
| Function    : grr_store_type_pwr_par
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_store_type_pwr_par ( T_pwr_par *pwr_par, BOOL use_prev )
{ 
  UBYTE i; /* used for counting */

  TRACE_FUNCTION( "grr_store_type_pwr_par" );
  
  grr_set_alpha_flags( TRUE, pwr_par->alpha );

  for( i = 0; i < 8; i++ )
  {
    /*
     * if the information element is not present for certain previously 
     * allocated timeslots, the MS shall continue to use the previous
     * power on these timeslots
     */
    if( pwr_par->gamma_tn[i].v_gamma OR !use_prev )
    {
      psc_db->pwr_par.gamma_tn[i].v_gamma = pwr_par->gamma_tn[i].v_gamma;
      psc_db->pwr_par.gamma_tn[i].gamma   = pwr_par->gamma_tn[i].gamma;
    }
  }

  grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE;

} /* grr_store_type_pwr_par */

/*
+------------------------------------------------------------------------------
| Function    : grr_store_type_tn_alloc_pwr
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_store_type_tn_alloc_pwr ( T_tn_alloc_pwr *pwr_par )
{ 
  UBYTE i; /* used for counting */

  TRACE_FUNCTION( "grr_store_type_tn_alloc_pwr" );
  
  grr_set_alpha_flags( TRUE, pwr_par->alpha );

  for( i = 0; i < 8; i++ )
  {
    psc_db->pwr_par.gamma_tn[i].v_gamma = pwr_par->usf_array[i].v_usf_g;
    psc_db->pwr_par.gamma_tn[i].gamma   = pwr_par->usf_array[i].usf_g.gamma;
  }

  grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE;
  
} /* grr_store_type_tn_alloc_pwr */

/*
+------------------------------------------------------------------------------
| Function    : grr_store_type_dyn_alloc
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_store_type_dyn_alloc ( T_dyn_alloc *pwr_par )
{ 
  UBYTE i; /* used for counting */

  TRACE_FUNCTION( "grr_store_type_dyn_alloc" );
  
  grr_set_alpha_flags( pwr_par->v_alpha, pwr_par->alpha );

  if( pwr_par->v_usf_gamma_csn1 EQ TRUE )
  {
    for( i = 0; i < 8; i++ )
    {
      psc_db->pwr_par.gamma_tn[i].v_gamma = pwr_par->usf_gamma_csn1[i].v_usf_gamma;
      psc_db->pwr_par.gamma_tn[i].gamma   = pwr_par->usf_gamma_csn1[i].usf_gamma.gamma;
    }
  }

  grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE;

} /* grr_store_type_dyn_alloc */

/*
+------------------------------------------------------------------------------
| Function    : grr_store_type_alf_gam
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_store_type_alf_gam ( T_alf_gam *pwr_par, UBYTE tn )
{ 
  TRACE_FUNCTION( "grr_store_type_alf_gam" );
  
  grr_set_alpha_flags( TRUE, pwr_par->alpha );
  grr_set_sngl_gamma ( pwr_par->gamma, tn );

  grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE;

} /* grr_store_type_alf_gam */

/*
+------------------------------------------------------------------------------
| Function    : grr_store_type_pck_upl_ass_ia
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_store_type_pck_upl_ass_ia ( T_tfi_ass_alloc *pwr_par,
                                            UBYTE             tn       )
{ 
  TRACE_FUNCTION( "grr_store_type_pck_upl_ass_ia" );
  
  grr_set_alpha_flags( pwr_par->v_alpha, pwr_par->alpha );
  grr_set_sngl_gamma ( pwr_par->gamma, tn );

  grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE;

} /* grr_store_type_pck_upl_ass_ia */

/*
+------------------------------------------------------------------------------
| Function    : grr_store_type_pck_snbl_ass_ia
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_store_type_pck_snbl_ass_ia ( T_sngl_block_alloc *pwr_par,
                                            UBYTE             tn       )
{ 
  TRACE_FUNCTION( "grr_store_type_pck_snbl_ass_ia" );
  
  grr_set_alpha_flags( pwr_par->v_alpha, pwr_par->alpha );
  grr_set_sngl_gamma ( pwr_par->gamma, tn );

} /* grr_store_type_pck_snbl_ass_ia */


/*
+------------------------------------------------------------------------------
| Function    : grr_store_type_tfi_ass_rlc
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_store_type_tfi_ass_rlc ( T_tfi_ass_rlc *pwr_par,
                                         UBYTE          tn       )
{ 
  TRACE_FUNCTION( "grr_store_type_tfi_ass_rlc" );
  
  grr_set_alpha_flags( pwr_par->v_alpha, pwr_par->alpha );
  grr_set_sngl_gamma ( pwr_par->gamma, tn );

  grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE;

} /* grr_store_type_tfi_ass_rlc */


/*
+------------------------------------------------------------------------------
| Function    : grr_store_type_alpha_gamma
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_store_type_alpha_gamma ( T_alpha_gamma *pwr_par,
                                         UBYTE          tn       )
{ 
  TRACE_FUNCTION( "grr_store_type_alpha_gamma" );
  
  grr_set_alpha_flags( TRUE, pwr_par->alpha );
  grr_set_sngl_gamma ( pwr_par->gamma, tn );

  grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE;

} /* grr_store_type_alpha_gamma */

/*
+------------------------------------------------------------------------------
| Function    : grr_store_type_pwr_ctrl
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_store_type_pwr_ctrl ( T_pwr_ctrl *pwr_par )
{ 
  UBYTE i; /* used for counting */

  TRACE_FUNCTION( "grr_store_type_pwr_ctrl" );
  
  grr_set_alpha_flags( TRUE, pwr_par->alpha );

  for( i = 0; i < 8; i++ )
  {
    psc_db->pwr_par.gamma_tn[i].v_gamma = pwr_par->tagged_gamma[i].v_gamma;
    psc_db->pwr_par.gamma_tn[i].gamma   = pwr_par->tagged_gamma[i].gamma;
  }

  grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE;

} /* grr_store_type_pwr_ctrl */



/*
+------------------------------------------------------------------------------
| Function    : grr_set_alpha_flags
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
LOCAL void grr_set_alpha_flags ( BOOL v_alpha, UBYTE alpha )
{ 
  TRACE_FUNCTION( "grr_set_alpha_flags" );
  
  if( v_alpha )
  {
    psc_db->pwr_par.v_alpha = TRUE;
    psc_db->pwr_par.alpha   = CLIP_ALPHA( alpha );
  }

  psc_db->v_pwr_par = TRUE;

} /* grr_set_alpha_flags */

/*
+------------------------------------------------------------------------------
| Function    : grr_set_sngl_gamma
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
LOCAL void grr_set_sngl_gamma ( UBYTE gamma, UBYTE tn )
{ 
  UBYTE i; /* used for counting */

  TRACE_FUNCTION( "grr_set_sngl_gamma" );
  
  for( i = 0; i < 8; i++ )
  {
    psc_db->pwr_par.gamma_tn[i].v_gamma = FALSE;
  }

  psc_db->pwr_par.gamma_tn[tn].v_gamma = TRUE;
  psc_db->pwr_par.gamma_tn[tn].gamma   = gamma;

} /* grr_set_sngl_gamma */

/*
+------------------------------------------------------------------------------
| Function    : grr_set_tbf_cfg_req_param
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_set_tbf_cfg_req_param
                                ( T_MPHP_ASSIGNMENT_REQ *tbf_cfg_req )
{ 
  TRACE_FUNCTION( "grr_set_tbf_cfg_req_param" );

  tbf_cfg_req->assign_id          = 0;
  grr_data->cs.last_assignment_id = tbf_cfg_req->assign_id; 
  tbf_cfg_req->m_class            = grr_get_gprs_ms_class( );
  tbf_cfg_req->if_meas_enable     = meas_im_get_permit( );
  tbf_cfg_req->pc_meas_chan       = psc_db->g_pwr_par.pc_meas_chan;
 
  if( psc_db->gprs_cell_opt.ab_type EQ AB_8_BIT )
  {
    tbf_cfg_req->burst_type = AB_8_BIT;
  }
  else
  {
    tbf_cfg_req->burst_type = AB_11_BIT;
  }
} /* grr_set_tbf_cfg_req_param */

/*
+------------------------------------------------------------------------------
| Function    : grr_init_ms_data
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
LOCAL void grr_init_ms_data ( void )
{ 
  TRACE_FUNCTION( "grr_init_ms_data" );

#ifdef _TARGET_
  grr_data->ms.reverts_NMO_III = TRUE;
  grr_data->ms.tbf_mon_ccch    = FALSE; /* Target: Not allowed*/
#else
  grr_data->ms.reverts_NMO_III = FALSE;
  grr_data->ms.tbf_mon_ccch    = TRUE; /* WIN 32: allowed*/
#endif
} /* grr_init_ms_data */




/*
+------------------------------------------------------------------------------
| Function    : grr_update_pacch
+------------------------------------------------------------------------------
| Description : The function grr_update_pacch updates the power reduction and 
|               access burst type in case of change and being in transfer mode
|
| Parameters  : none
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_update_pacch( void )
{ 
  TRACE_FUNCTION( "grr_update_pacch" );

  {
    PALLOC(update_psi, MPHP_UPDATE_PSI_PARAM_REQ);
    update_psi->pb         = psc_db->g_pwr_par.pb;
    update_psi->burst_type = psc_db->gprs_cell_opt.ab_type;    
    PSEND(hCommL1, update_psi);
  }

} /* grr_update_pacch */


/*
+------------------------------------------------------------------------------
| Function    : grr_imsi_mod
+------------------------------------------------------------------------------
| Description : The function grr_imsi_mod() returns the imsi modulo 1000
|
| Parameters  : in: NONE out: USHORT imsimod
|
+------------------------------------------------------------------------------
*/

GLOBAL USHORT grr_imsi_mod ()
{
  UBYTE i= grr_data->db.ms_id.imsi.number_of_digits;
  TRACE_FUNCTION("grr_imsi_mod ");
  
  return ((SHORT)grr_data->db.ms_id.imsi.digit[i - 3] * 100 +
        (SHORT)grr_data->db.ms_id.imsi.digit[i - 2] * 10 +
        (SHORT)grr_data->db.ms_id.imsi.digit[i - 1]);

}

/*
+------------------------------------------------------------------------------
| Function    : grr_set_buf_tlli
+------------------------------------------------------------------------------
| Description : The function grr_set_buf_tlli() fills the TLLI buffer.
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_set_buf_tlli ( BUF_tlli_value *buf_tlli_o, ULONG tlli_i )
{
  TRACE_FUNCTION( "grr_set_buf_tlli" );

  grr_set_tlli( &buf_tlli_o->l_tlli_value, 
                &buf_tlli_o->o_tlli_value,
                &buf_tlli_o->b_tlli_value[0],
                tlli_i );

} /* grr_set_buf_tlli */


/*
+------------------------------------------------------------------------------
| Function    : grr_set_tlli
+------------------------------------------------------------------------------
| Description : The function grr_set_tlli() fills the TLLI buffer.
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_set_tlli
                ( USHORT *l_tlli, USHORT *o_tlli, UBYTE *b_tlli, ULONG tlli )
{
  TRACE_FUNCTION( "grr_set_tlli" );

  *l_tlli   = 32;
  *o_tlli   = 0;
  
  b_tlli[0] = (UBYTE)((tlli >> 24) & 0x000000ff);
  b_tlli[1] = (UBYTE)((tlli >> 16) & 0x000000ff);
  b_tlli[2] = (UBYTE)((tlli >> 8 ) & 0x000000ff);
  b_tlli[3] = (UBYTE)((tlli      ) & 0x000000ff);

  /* unused byte must be set to 0x00, otherwise CCD has some problems */
  b_tlli[4] = 0;

} /* grr_set_tlli */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_tlli
+------------------------------------------------------------------------------
| Description : The function grr_get_tlli() returns the TLLI.
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL ULONG grr_get_tlli ( void )
{
  TRACE_FUNCTION( "grr_get_tlli" );

  return( grr_data->db.ms_id.new_tlli );

} /* grr_get_tlli */

/*
+------------------------------------------------------------------------------
| Function    : grr_encode_ul_ctrl_block
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_encode_ul_ctrl_block ( UBYTE *ul_ctrl_block, 
                                       UBYTE *ul_ctrl_data )
{
  T_CTRLBUF enc_block;

  TRACE_FUNCTION( "grr_encode_ul_ctrl_block" );

  grr_encode_ctrl( ul_ctrl_data, ( T_MSGBUF* )&enc_block , grr_data->r_bit );
  memcpy( ul_ctrl_block, enc_block.buf, BYTELEN( enc_block.l_buf ) );    

} /* grr_encode_ul_ctrl_block */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_ul_ctrl_block_header
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE grr_get_ul_ctrl_block_header ( UBYTE r_bit )
{
  TRACE_FUNCTION( "grr_get_ul_ctrl_block_header" );

  /* 
   * set Payload Type and R Bit
   */
  return( ( CTRL_BLK_NO_OPT << 6 ) | r_bit );

} /* grr_get_ul_ctrl_block_header */

/*
+------------------------------------------------------------------------------
| Function    : grr_check_if_tbf_start_is_elapsed
+------------------------------------------------------------------------------
| Description : The function grr_check_if_tbf_start_is_elapsed() checks if 
|               tbf starting time is elapsed or not, modulo calculation is 
|               needed
| Parameters  : start_fn    - tbf starting time
|               current_fn  - current frame number
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_check_if_tbf_start_is_elapsed ( ULONG start_fn, ULONG current_fn)
{
  BOOL  result = FALSE;
  ULONG d1;
  /* ULONG d2; */
  /* FN_MAX=0x297000 == 2715648 ==125463 seconds(4.62ms per frame)
   * the starting time is within  current_fn-10808 and current_fn+31623
   * modulo operation must be taken in account
   */
  TRACE_FUNCTION( "grr_check_if_tbf_start_is_elapsed" );

  /*
   * handle maximum distance for tbf starting time
   */

  if(start_fn EQ 0xFFFFFFFF)
  {
    result =TRUE;
    return result;
  }
  d1 = 10808;
  /* d2 = 31623; */
  if( (start_fn <= current_fn)     AND
      ((current_fn-start_fn) <= d1))
  {
    result = TRUE;
    TRACE_EVENT_P2(" case 1: st time elapsed st_fn=%ld  c_fn=%ld",start_fn,current_fn);
  }
  else if((start_fn >= current_fn) AND
          (FN_MAX-start_fn+current_fn) <= d1)
  {
    result = TRUE;
    TRACE_EVENT_P2("case 2: st time elapsed st_fn=%ld  c_fn=%ld",start_fn,current_fn);
  }
  else
  {
    TRACE_EVENT_P2("case 3: WAIT FOR ST TIME st_fn=%ld  c_fn=%ld",start_fn,current_fn);
  }

    

  return result;
} /* grr_check_if_tbf_start_is_elapsed() */

/*
+------------------------------------------------------------------------------
| Function    : grr_calculate_Tra
+------------------------------------------------------------------------------
| Description : The function has to calculate for mobile type 1 (ms_class 1-12)
|               the minimum timeslots between end of last previous downlink  
|               timeslot and the  next uplink or two consecutive uplinks.
|
| Parameters  : ul_usage : uplink timeslot mask
|               dl_usage : downlink timeslot mask
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE grr_calculate_Tra (UBYTE ul_usage, UBYTE dl_usage)
{
  UBYTE mask=0x80, z_mask=0;
  UBYTE Tx[8],Rx[8],ul_seted_slot,dl_seted_slot,j,i,tra,rc_dl_usage;

  TRACE_FUNCTION( "grr_calculate_Tra" );

  memset( Tx, 0, sizeof( Tx ) );
  memset( Rx, 0, sizeof( Rx ) );


  ul_seted_slot = 0;
  dl_seted_slot = 0;

  /*
   * detect position of uplink seted slots and the number of slots
   */
  if(ul_usage NEQ z_mask)
  {
    for(j=0;j<8;j++)
    {
      if(mask & ul_usage)
      {
        Tx[ul_seted_slot]=j+1;
        ul_seted_slot++;
      }
      mask>>=1;
    }
  }
  /*
   * detect position of downlink seted slots and the number of slots
   * and shift them for 3 positions(delay between uplink and downlink)
   */  
  mask        = 0x80; /* set again, it is reused*/
  rc_dl_usage = grr_reconstruct_dl_usage(dl_usage);
  if(rc_dl_usage NEQ z_mask)
  {
    for(i=0;i<=7;i++)
    {
      if(mask & rc_dl_usage)
      {
        Rx[dl_seted_slot]=i+1;
        dl_seted_slot++;
      }
      mask>>=1;
    }
  }
  tra=0xFF; /* set to invalid value */
  /*
   * calculate tra
   */
  for(i=0;i<ul_seted_slot;i++)
  {
    for(j=0;j<dl_seted_slot;j++)
    {
      if (Rx[j] EQ Tx[i])
      { /* tranmission and receiving at the same time not allowed*/
        tra=0;
        TRACE_EVENT_P6("OVERLAP TRA  Rx[%d]=%d  Tx[%d]=%d ul_mask=%x dl_mask=%x"
                                  ,j
                                  ,Rx[j]
                                  ,i
                                  ,Tx[i]
                                  ,ul_usage
                                  ,dl_usage);
        return tra;
      }
      else if(Rx[j] > Tx[i])
      {
        if(tra > (Rx[j] - Tx[i]-1))
        {
          tra = Rx[j] - Tx[i]-1;
        }
      }
      else
      {
        if(tra > (Rx[j]+8 - Tx[i]-1))
        {
          tra = Rx[j]+8 - Tx[i]-1;
        }
      }
    }      
  }
  return tra;
} /*grr_calculate_Tra */

/*
+------------------------------------------------------------------------------
| Function    : grr_calculate_Ttb
+------------------------------------------------------------------------------
| Description : The function has to calculate for mobile type 1 (ms_class 1-12)
|               the minimum timeslot between end of last previous uplink  
|               timeslot and the first next downlink or two cnsecutive Downlinks.
|
| Parameters  : ul_usage : uplink timeslot mask
|               dl_usage : downlink timeslot mask
|
+------------------------------------------------------------------------------
*/

GLOBAL UBYTE grr_calculate_Ttb (UBYTE ul_usage, UBYTE dl_usage)
{
  UBYTE mask=0x80, z_mask=0;
  UBYTE Tx[8],Rx[8],ul_seted_slot,dl_seted_slot,j,i,ttb;

  TRACE_FUNCTION( "grr_calculate_Ttb" );

  memset( Tx, 0, sizeof( Tx ) );
  memset( Rx, 0, sizeof( Rx ) );
 
  ul_seted_slot = 0;
  dl_seted_slot = 0;

  /*
   * detecte position of uplink seted slots and the number of slots  
   * uplink slots gets an offset of 3 positions(Air interface).
   */
  if(ul_usage NEQ z_mask)
  {
    for(j=0;j<8;j++)
    {
      if(mask & ul_usage)
      {
        Tx[ul_seted_slot]=j+1+3;
        ul_seted_slot++;
      }
      mask>>=1;
    }
  }
  /* 
   * detecte position of downlink seted slots and the number of slots 
   */
  mask=0x80;
  if(dl_usage NEQ z_mask)
  {
    for(i=0;i<=7;i++)
    {
      if(mask & dl_usage)
      {
        Rx[dl_seted_slot]=i+1;
        dl_seted_slot++;
      }
      mask>>=1;
    }
  }
  ttb=0xFF; /* set to invalid value */
  /*
   * calculate ttb
   */
  for(i=0;i<dl_seted_slot;i++)
  {
    for(j=0;j<ul_seted_slot;j++)
    {
      if ((Tx[j] EQ Rx[i])  OR
          !(Tx[j] - Rx[i]-8))
      { /* tranmission and receiving at the same time not allowed*/
        ttb=0;
        TRACE_EVENT_P6("OVERLAP TTB    Tx[%d]=%d  Rx[%d]=%d ul_mask=%x dl_mask=%x"
                                    ,j
                                    ,Tx[j]
                                    ,i
                                    ,Rx[i]
                                    ,ul_usage
                                    ,dl_usage);
        return ttb;
      }
      else if(Tx[j] > Rx[i])
      {
        if((Tx[j] - Rx[i] > 8) AND
           (ttb > (Tx[j] - Rx[i]-8-1)))
        {
          ttb  = Tx[j] - Rx[i]-8-1;
        }
        else if(ttb > (Tx[j] - Rx[i]-1))
        {
          ttb  = Tx[j] - Rx[i]-1;          
        }
      }
      else if(ttb > (Tx[j]+8 - Rx[i]-1) )
      {
        ttb = Tx[j]+8 - Rx[i]-1;
      }
    }
  }
  return ttb;
} /* grr_calculate_Ttb */


/*
+------------------------------------------------------------------------------
| Function    : grr_reconstruct_dl_usage
+------------------------------------------------------------------------------
| Description : this function converts the downlink slot mask. The first 3 MSB
|               are switched to the first LSB bits.
|               B0 is the MSB, B7 is the LSB
|               dl_usage (input)     : B0 B1 B2 B3 B4 B5 B6 B7
|               new_dl_usage (output): B3 B4 B5 B6 B7 B0 B1 B2
|
| Parameters  : dl_usage: this is timeslot mask for downlink
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE grr_reconstruct_dl_usage(UBYTE dl_usage)
{
  UBYTE help, new_dl_usage;

  TRACE_FUNCTION( "grr_reconstruct_dl_usage" );

  help         = 0xE0;
  help        &= dl_usage;
  dl_usage   <<= 3;
  help       >>= 5;
  new_dl_usage = dl_usage | help;

  return new_dl_usage;
}/* grr_reconstruct_dl_usage */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_gprs_ms_class
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE grr_get_gprs_ms_class ( void )
{
  T_rf_cap *rf_cap         = rr_csf_get_rf_capability( );
  UBYTE     gprs_ms_class;

  TRACE_FUNCTION( "grr_get_gprs_ms_class" );

  if( rf_cap NEQ NULL )
  {
    gprs_ms_class = rf_cap->rf_ms.gprs_ms_class;
  }
  else
  {
    gprs_ms_class = MSLOT_CLASS_1;

    TRACE_ERROR( "grr_get_gprs_ms_class: RF capabilities invalid" );
  }

  return( gprs_ms_class );

} /* grr_get_gprs_ms_class */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_next_ncell_param
+------------------------------------------------------------------------------
| Description : 
| Parameters  : 
+------------------------------------------------------------------------------
*/
GLOBAL T_ncell_info* grr_get_next_ncell_param ( UBYTE       max_number,
                                                T_NC_LIST  *list,
                                                T_INFO_SRC  info_src )
{
  UBYTE         i;
  T_ncell_info *ncell_info_max;
  T_ncell_info *ncell_info_next;

  TRACE_FUNCTION( "grr_get_next_ncell_param" );

  /*
   * looking for the next free entry or in case there is no more free entry
   * available, looking for the highest indexed entry which will be deleted
   */
  if( list->number < max_number )
  {
    ncell_info_max = &list->info[list->number];
  }
  else
  {
    ncell_info_max = &list->info[0];

    for( i = 1; i < max_number; i++ )
    {
      ncell_info_next = &list->info[i];

      if( ncell_info_next->info_src > ncell_info_max->info_src )
      {
        ncell_info_max = ncell_info_next;
      }
    }

    TRACE_ERROR( "grr_get_next_ncell_param: Number of NCELLs > max_number" );

    if( ncell_info_max->info_src < info_src )
    {
      TRACE_EVENT( "grr_get_next_ncell_param: Keep NCELL list" );

      ncell_info_max = NULL;
    }
    else if( ncell_info_max->info_src EQ info_src )
    {
      TRACE_ERROR( "grr_get_next_ncell_param: Two identical NCELL" );

      ncell_info_max = NULL;
    }
    else
    {
      TRACE_EVENT( "grr_get_next_ncell_param: Change NCELL list" );
    }
  }

  return( ncell_info_max );

}/* grr_get_next_ncell_param */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_next_bigger_ncell_param
+------------------------------------------------------------------------------
| Description : 
| Parameters  : 
+------------------------------------------------------------------------------
*/
GLOBAL T_ncell_info* grr_get_next_bigger_ncell_param ( T_NC_LIST  *list,
                                                       T_INFO_SRC  info_src )
{
  UBYTE         i;
  T_INFO_SRC    info_src_max;
  T_ncell_info *ncell_info_next;
  T_ncell_info *ncell_info_bigger = NULL;

  TRACE_FUNCTION( "grr_get_next_bigger_ncell_param" );

  if( list->number NEQ 0 )
  {
    /*
     * all indeces should be set to unused in case info_src EQ 0,
     * which marks the start of a new search process 
     */    
    if( info_src EQ 0 )
    {
      for( i = 0; i < list->number; i++ )
      {
        list->info[i].index = 0xFF;
      }
    }

    i            = 0;
    info_src_max = ~((T_INFO_SRC)0);

    do
    {
      ncell_info_next = &list->info[i];

      TRACE_ASSERT( info_src               NEQ ncell_info_next->info_src OR 
                    ncell_info_next->index NEQ 0xFF                         );


      if( info_src                  < ncell_info_next->info_src AND 
          ncell_info_next->info_src < info_src_max                  )
      {
        info_src_max      = ncell_info_next->info_src;
        ncell_info_bigger = ncell_info_next;
      }

      i++;
    }
    while( i < list->number );
  }

  return( ncell_info_bigger );

}/* grr_get_next_bigger_ncell_param */

/*
+------------------------------------------------------------------------------
| Function    : grr_store_cs_param
+------------------------------------------------------------------------------
| Description : 
| Parameters  : ncell_info     - neighbour cell information
|               v_cs_par       - valid falg for cell selection parameter
|               cs_par         - cell selection parameter
|               info_src       - source of neighbour cell information
|               arfcn          - absolute radio frequency channel number
|               bsic           - base station identity code
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_store_cs_param ( T_NC_LIST    *nc_list,
                                 BOOL          v_cs_par,
                                 T_cs_par     *cs_par,
                                 T_INFO_TYPE   type,
                                 UBYTE         instance,
                                 UBYTE        *number,
                                 USHORT       *freq,
                                 USHORT        freq_diff,
                                 UBYTE         bsic )
{
  T_INFO_SRC    info_src=0;
  T_ncell_info *ncell_info;

  TRACE_FUNCTION( "grr_store_cs_param" );

  NC_SET_TYPE    ( info_src, type     );
  NC_SET_INSTANCE( info_src, instance );
  NC_SET_NUMBER  ( info_src, *number  );

  ncell_info = grr_get_next_ncell_param( MAX_NR_OF_NCELL,
                                         nc_list, 
                                         info_src );

  if( ncell_info EQ NULL )
  {
    return( FALSE );
  }

  (*number)++;
  nc_list->number++;

  *freq = ( *freq + freq_diff ) % 1024;

  ncell_info->info_src = info_src;
  ncell_info->arfcn    = *freq;
  ncell_info->bsic     = bsic;

  ncell_info->v_cr_par = v_cs_par;

  if( v_cs_par EQ TRUE )
  {
    ncell_info->cr_par.same_ra_scell = cs_par->same_ra_scell;
    ncell_info->cr_par.exc_acc       = cs_par->exc_acc;
    ncell_info->cr_par.cell_ba       = cs_par->cell_ba;

#if !defined (NTRACE)

    if( grr_data->cs.v_crp_trace EQ TRUE )
    {
      TRACE_EVENT_P3( "grr_store_cs_param: cell barred status %d %d, info_src %x",
                      ncell_info->arfcn, ncell_info->cr_par.cell_ba, info_src );
    }

#endif /* #if !defined (NTRACE) */

    SET_GPRS_RXLEV_ACCESS_MIN
      ( ncell_info->cr_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min,
        cs_par->v_cs_par_s1, cs_par->cs_par_s1.gprs_rxlev_access_min );

    SET_GPRS_MS_TXPWR_MAX_CCH
      ( ncell_info->cr_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch,
        cs_par->v_cs_par_s1, cs_par->cs_par_s1.txpwr_max_cch );

    SET_GPRS_TEMP_OFFSET
      ( ncell_info->cr_par.cr_offset.gprs_temp_offset,
        cs_par->v_cs_par_s2, cs_par->cs_par_s2.gprs_temp_offset );

    SET_GPRS_PENALTY_TIME
      ( ncell_info->cr_par.cr_offset.gprs_penalty_time,
        cs_par->v_cs_par_s2, cs_par->cs_par_s2.gprs_penalty_time );

    SET_GPRS_RESEL_OFF
      ( ncell_info->cr_par.gprs_resel_off,
        cs_par->v_gprs_resel_off, cs_par->gprs_resel_off );

    ncell_info->cr_par.cr_par_1.v_hcs_par = cs_par->v_hcs_par;

    SET_GPRS_HCS_THR
      ( ncell_info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr,
        cs_par->v_hcs_par, cs_par->hcs_par.gprs_hcs_thr );

    SET_GPRS_PRIO_CLASS
      ( ncell_info->cr_par.cr_par_1.hcs_par.gprs_prio_class,
        cs_par->v_hcs_par, cs_par->hcs_par.gprs_prio_class );

    grr_store_si13_pbcch_location( &ncell_info->cr_par,
                                   cs_par->v_si13_pbcch,
                                   &cs_par->si13_pbcch );
  }

  return( TRUE );

}/* grr_store_cs_param */

/*
+------------------------------------------------------------------------------
| Function    : grr_store_si13_pbcch_locaction
+------------------------------------------------------------------------------
| Description : 
| Parameters  : 
+------------------------------------------------------------------------------
*/
GLOBAL void grr_store_si13_pbcch_location ( T_CR_PAR     *cr_par,
                                            BOOL          v_si13_pbcch,
                                            T_si13_pbcch *si13_pbcch )
{
  TRACE_FUNCTION( "grr_store_si13_pbcch_locaction" );

  cr_par->v_si13_pbcch = v_si13_pbcch;

  if( v_si13_pbcch )
  {
    cr_par->si13_pbcch.v_si13_location = si13_pbcch->v_si13_loc;

    if( si13_pbcch->v_si13_loc )
    {
      cr_par->si13_pbcch.si13_location = si13_pbcch->si13_loc;
    }
    else
    {
      cr_par->si13_pbcch.pbcch_location     =
        si13_pbcch->si13_pbcch_s1.pbcch_loc;
      cr_par->si13_pbcch.psi1_repeat_period =
        si13_pbcch->si13_pbcch_s1.psi1_rep_per + 1;
    }
  }
}/* grr_store_si13_pbcch_locaction */

/*
+------------------------------------------------------------------------------
| Function    : grr_restore_cs_param
+------------------------------------------------------------------------------
| Description : 
| Parameters  : 
+------------------------------------------------------------------------------
*/
GLOBAL void grr_restore_cs_param ( T_ncell_info *curr_info,
                                   T_ncell_info *prev_info,
                                   UBYTE         curr_idx )
{
  TRACE_FUNCTION( "grr_restore_cs_param" );

  curr_info->index = curr_idx;

  if( grr_is_pbcch_present( ) )
  {
    if( curr_info->cr_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min EQ 
        GPRS_RXLEV_ACCESS_MIN_INVALID                                  )
    {
      if( prev_info NEQ NULL )
      {
        curr_info->cr_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min =
          prev_info->cr_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min;
      }
      else
      {
        curr_info->cr_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min =
          psc_db->scell_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min;
      }
    }

    if( curr_info->cr_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch EQ 
        GPRS_MS_TXPWR_MAX_CCH_INVALID                                  )
    {
      if( prev_info NEQ NULL )
      {
        curr_info->cr_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch =
          prev_info->cr_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch;
      }
      else
      {
        curr_info->cr_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch =
          psc_db->scell_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch;
      }
    }

    if( curr_info->cr_par.cr_offset.gprs_temp_offset EQ 
        GPRS_TEMPORARY_OFFSET_INVALID                   )
    {
      if( prev_info NEQ NULL )
      {
        curr_info->cr_par.cr_offset.gprs_temp_offset =
          prev_info->cr_par.cr_offset.gprs_temp_offset;
      }
      else
      {
        TRACE_ERROR( "gprs_temp_offset not present in 1st NCELL");

        curr_info->cr_par.cr_offset.gprs_temp_offset =
          GPRS_TEMPORARY_OFFSET_00_DB;
      }
    }

    if( curr_info->cr_par.cr_offset.gprs_penalty_time EQ 
        GPRS_PENALTY_TIME_INVALID                        )
    {
      if( prev_info NEQ NULL )
      {
        curr_info->cr_par.cr_offset.gprs_penalty_time =
          prev_info->cr_par.cr_offset.gprs_penalty_time;
      }
      else
      {
        TRACE_ERROR( "gprs_penalty_time not present in 1st NCELL");

        curr_info->cr_par.cr_offset.gprs_penalty_time =
          GPRS_PENALTY_TIME_MAX;
      }
    }

    if( psc_db->scell_par.cr_par_1.v_hcs_par EQ FALSE )
    {
      /*
       * If the HCS struct is omitted for the serving cell,
       * HCS is not used and the HCS parameters for the other
       * cells shall be neglected i.e the HCS signal strength
       * threshold shall be set to infinity for all cells.
       */
      curr_info->cr_par.cr_par_1.v_hcs_par = FALSE;
    }
    else
    {
      if( curr_info->cr_par.cr_par_1.v_hcs_par EQ FALSE )
      {
        if( prev_info NEQ NULL )
        {
          curr_info->cr_par.cr_par_1.v_hcs_par = 
            prev_info->cr_par.cr_par_1.v_hcs_par;

          if( curr_info->cr_par.cr_par_1.hcs_par.gprs_prio_class EQ
              GPRS_PRIORITY_CLASS_INVALID                           )
          {
            curr_info->cr_par.cr_par_1.hcs_par.gprs_prio_class =
              prev_info->cr_par.cr_par_1.hcs_par.gprs_prio_class;
          }

          if( curr_info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr EQ 
              GPRS_HCS_THR_INVALID                               )
          {
            curr_info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr =
              prev_info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr;
          }
        }
        else
        {
          curr_info->cr_par.cr_par_1.v_hcs_par = 
            psc_db->scell_par.cr_par_1.v_hcs_par;

          if( curr_info->cr_par.cr_par_1.hcs_par.gprs_prio_class EQ
              GPRS_PRIORITY_CLASS_INVALID                           )
          {
            curr_info->cr_par.cr_par_1.hcs_par.gprs_prio_class =
              psc_db->scell_par.cr_par_1.hcs_par.gprs_prio_class;
          }

          if( curr_info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr EQ 
              GPRS_HCS_THR_INVALID                               )
          {
            curr_info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr =
              psc_db->scell_par.cr_par_1.hcs_par.gprs_hcs_thr;
          }
        }
      }
    }
  }
}/* grr_restore_cs_param */



/*
+------------------------------------------------------------------------------
| Function    : grr_handle_ta
+------------------------------------------------------------------------------
| Description : This function handles the timing advance of the MS
| Parameters  : v_tav:    valid flag ta_value
|               tav:      ta value
|               v_ul_tai: valid flag dl ta_index
|               ul_tai:   dl ta index
|               ul_tatn:  dl ta timeslot number
|               v_dl_tai: valid flag dl ta_index
|               dl_tai:   dl ta index
|               dl_tatn:  dl ta timeslot number
|               ptr2ta:   pointer to the ta structue, which is passed to l1
+------------------------------------------------------------------------------
*/
GLOBAL void grr_handle_ta ( UBYTE v_tav,
                            UBYTE tav,
                            UBYTE v_ul_tai, 
                            UBYTE ul_tai,
                            UBYTE ul_tatn, 
                            UBYTE v_dl_tai, 
                            UBYTE dl_tai,
                            UBYTE dl_tatn, 
                            T_p_timing_advance *ptr2ta)
{
  BOOL use_dl_par = FALSE;
  TRACE_FUNCTION( "grr_handle_ta" );

  ptr2ta->ta_value             = 0xFF;
  ptr2ta->ta_index             = 0xFF;
  ptr2ta->tn                   = 0xFF;

  /*TRACE_EVENT_P1("grr_data->tbf_type: %d", grr_data->tbf_type);*/
  switch(grr_data->tbf_type)
  {
    case CGRLC_TBF_MODE_DL:
    case CGRLC_TBF_MODE_DL_UL:
      /*use DL TA parameters*/
      use_dl_par = TRUE;
      break;
    case CGRLC_TBF_MODE_NULL:
    case CGRLC_TBF_MODE_UL:
#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
    case CGRLC_TBF_MODE_2PA:
#endif
    default:
      /*future use*/
      break;
  }
  /*
   * TA-Value, if present
   */
  if(v_tav) /* New TA value Received */
  { 
    /*  
    TRACE_EVENT("New TA value Received");
    */
    if(tav NEQ grr_data->ta_params.ta_value )
    {
      /*
       * inform grlc that new ta is received
       */

      PALLOC(cgrlc_ta_value_req, CGRLC_TA_VALUE_REQ);
      cgrlc_ta_value_req->ta_value = tav;
      PSEND(hCommGRLC, cgrlc_ta_value_req);
    }
    ptr2ta->ta_value             = tav;
    grr_data->ta_params.ta_value = tav;
    grr_data->ta_params.ta_valid = TRUE;
  }
  else if(grr_data->ta_params.ta_valid) /* use old TA value */
  {
    /*
    TRACE_EVENT("Use old TA value in IA or PUL on (P)AGCH");
    */
    ptr2ta->ta_value = grr_data->ta_params.ta_value;
  }
  else
  {
    /*TRACE_EVENT("No valid TA in neither in message nor stored TA: check TAI");*/
    grr_data->ta_params.ta_value = 0xFF;
    grr_data->ta_params.ta_valid = FALSE;
  }

  /*
   * If TAI present the MS shall use "continuos TA"
   */
  if(v_dl_tai EQ 0)
  {
    /* Reset the tai & ta_tn */
    if(grr_data->ta_params.dl_ta_i NEQ 0xFF)
    {
      TRACE_EVENT_P4("TA_INFO: Switch off DL CTA dl_tai=%d dl_ta_tn=%d ul_tai=%d, ul_ta_tn=%d",
      grr_data->ta_params.dl_ta_i,
      grr_data->ta_params.dl_ta_tn,
      grr_data->ta_params.ul_ta_i,
      grr_data->ta_params.ul_ta_tn);
    }
    grr_data->ta_params.dl_ta_i  = 0xFF;
    grr_data->ta_params.dl_ta_tn = 0xFF;
  }
  else if(v_dl_tai EQ 1)
  {
    /* TRACE_EVENT("DL TAI: cont TA: if UL TAI is also valid, we prefer to use DL TAI"); */
    grr_data->ta_params.dl_ta_i  = dl_tai;
    grr_data->ta_params.dl_ta_tn = dl_tatn;
    ptr2ta->ta_index             = dl_tai;
    ptr2ta->tn                   = dl_tatn;
  }

  if(v_ul_tai EQ 0)
  {
    /* Reset the tai & ta_tn */
    if(grr_data->ta_params.ul_ta_i NEQ 0xFF)
    {
      TRACE_EVENT_P7("TA_INFO: Switch off UL CTA ul_tai=%d ul_ta_tn=%d dl_tai=%d dl_ta_tn=%d v_dl_tai=%d new_dl_tai=%d new_dl_ta_tn=%d",
      grr_data->ta_params.ul_ta_i,
      grr_data->ta_params.ul_ta_tn,
      grr_data->ta_params.dl_ta_i,
      grr_data->ta_params.dl_ta_tn,
      v_dl_tai,
      dl_tai,
      dl_tatn);
    }
    grr_data->ta_params.ul_ta_i  = 0xFF;
    grr_data->ta_params.ul_ta_tn = 0xFF;

    if(use_dl_par AND grr_data->ta_params.dl_ta_i NEQ 0xFF)
    {
      ptr2ta->ta_index             = grr_data->ta_params.dl_ta_i;
      ptr2ta->tn                   = grr_data->ta_params.dl_ta_tn;
    }
  }
  else if(v_ul_tai EQ 1)
  {
    grr_data->ta_params.ul_ta_i  = ul_tai;
    grr_data->ta_params.ul_ta_tn = ul_tatn;
    if(use_dl_par AND grr_data->ta_params.dl_ta_i NEQ 0xFF)
    {
      /* TRACE_EVENT("Conc TBF: use DL TA for UL"); */
      ptr2ta->ta_index             = grr_data->ta_params.dl_ta_i;
      ptr2ta->tn                   = grr_data->ta_params.dl_ta_tn;
    }
    else
    {
      /* TRACE_EVENT("Single TBF or TBF_Type is not set to concurrent: UL TAI: cont TA"); */
      ptr2ta->ta_index             = ul_tai;
      ptr2ta->tn                   = ul_tatn;
    }
  }
  /*
   * store values ,which are passed to layer 1
   */
  grr_data->ta_params.l1_ta_value = ptr2ta->ta_value;
  grr_data->ta_params.l1_ta_i     = ptr2ta->ta_index;
  grr_data->ta_params.l1_ta_tn    = ptr2ta->tn;
/*

  {
    ULONG trace[4];

    trace[0]  = ul_tai   <<  0;
    trace[0] |= v_ul_tai <<  8;
    trace[0] |= tav      << 16;
    trace[0] |= v_tav    << 24;

    trace[1]  = dl_tatn  <<  0;
    trace[1] |= dl_tai   <<  8;
    trace[1] |= v_dl_tai << 16;
    trace[1] |= ul_tatn  << 24;

    trace[2]  = grr_data->ta_params.ul_ta_tn <<  0;
    trace[2] |= grr_data->ta_params.ul_ta_i  <<  8;
    trace[2] |= grr_data->ta_params.ta_value << 16;
    trace[2] |= grr_data->ta_params.ta_valid << 24;

    trace[3]  = grr_data->ta_params.l1_ta_i     <<  0;
    trace[3] |= grr_data->ta_params.l1_ta_value <<  8;
    trace[3] |= grr_data->ta_params.dl_ta_tn    << 16;
    trace[3] |= grr_data->ta_params.dl_ta_i     << 24;

    TRACE_EVENT_P5( "TA_PARAM_1: %08X%08X %08X%08X%02X",
                    trace[0], trace[1], trace[2], trace[3],
                    grr_data->ta_params.l1_ta_tn );
  }
*/
}/* grr_handle_ta */

/*---------------------- GET FROM PPC-----------------------------------------*/
/*
+------------------------------------------------------------------------------
| Function    : grr_decode_grr
+------------------------------------------------------------------------------
| Description : The function grr_decode_grr() calls the function ccd_decodeMsg.
|               After the call the decoded Message is in _decodeCtrlMsg.
|
| Parameters  : msg_ptr_i - pointer to buffer that should be decoded
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE grr_decode_grr (T_MSGBUF  *  msg_ptr_i)
{ 
  UBYTE result;
  UBYTE msg_type = msg_ptr_i->buf[0] >> 2;;

  TRACE_FUNCTION( "grr_decode_grr" );

  /*
   * Offset must be zero, else code to get msg_type is illegal
   */
  TRACE_ASSERT (msg_ptr_i->o_buf==0);

#ifdef _SIMULATION_
  /*
   * If one of the following asserts fail, you have to verify the message
   * decoders.
   */
#ifdef REL99
  TRACE_ASSERT (sizeof(T_D_DL_ASSIGN)   == 0x02E0); /*lint !e774*/
  TRACE_ASSERT (sizeof(T_D_UL_ASSIGN)   == 0x0410); /*lint !e774*/
  TRACE_ASSERT (sizeof(T_D_TS_RECONFIG) == 0x03D8); /*lint !e774*/
#else
  TRACE_ASSERT (sizeof(T_D_DL_ASSIGN)   == 0x024C); /*lint !e774*/
  TRACE_ASSERT (sizeof(T_D_UL_ASSIGN)   == 0x040C); /*lint !e774*/
  TRACE_ASSERT (sizeof(T_D_TS_RECONFIG) == 0x03D4); /*lint !e774*/
#endif
#endif


  switch (msg_type)
  {
    case D_DL_ASSIGN:
      result = grr_decode_dl_assignment (msg_ptr_i->buf, msg_ptr_i->o_buf, msg_ptr_i->l_buf);
      break;

    case D_UL_ASSIGN:
      result = grr_decode_ul_assignment (msg_ptr_i->buf, msg_ptr_i->o_buf, msg_ptr_i->l_buf);
      break;

    case D_TS_RECONFIG:
      result = grr_decode_ts_reconfig (msg_ptr_i->buf, msg_ptr_i->o_buf, msg_ptr_i->l_buf);
      break;
    case D_PDCH_RELEASE:
      result = grr_decode_pdch_release (msg_ptr_i->buf, msg_ptr_i->o_buf, msg_ptr_i->l_buf);
      break;
    case D_POLLING_REQ:
      result = grr_decode_polling_req (msg_ptr_i->buf, msg_ptr_i->o_buf, msg_ptr_i->l_buf);
      break;
    case D_TBF_RELEASE:
      result = grr_decode_tbf_release_req (msg_ptr_i->buf, msg_ptr_i->o_buf, msg_ptr_i->l_buf);
      break;
     
    default:
      result = ccd_decodeMsg (CCDENT_GRR, DOWNLINK, msg_ptr_i, _decodedMsg, NOT_PRESENT_8BIT);
      break;
  }


  if ( result EQ ccdError ) switch (msg_type)
  {
    case D_DL_ASSIGN:
    case D_UL_ASSIGN:
    case D_TS_RECONFIG:
      /* This should not be the final version of error handling */
      return DELETE_MESSAGE;

    default:
      return grr_ccd_error_handling( CCDENT_GRR );
  }

  return msg_type;

} /* grr_decode_grr() */


/*
+------------------------------------------------------------------------------
| Function    : grr_decode_rlcmac
+------------------------------------------------------------------------------
| Description : The function grr_decode_rlcmac() 
|
| Parameters  : ptr_msg_i     - pointer to rlcmac-ctrl message
|               ptr_header_i  - pointer to mac header of the rlc block
+------------------------------------------------------------------------------
*/
GLOBAL void grr_decode_rlcmac ( UBYTE * ptr_msg_i, T_D_HEADER * ptr_d_header_i )
{   
  UBYTE rrbp, sp, payload;
  TRACE_FUNCTION( "grr_decode_rlcmac" );
  /*MAC Header*/
  payload      = (ptr_msg_i[0] & 0xC0) >> 6;
  rrbp         = (ptr_msg_i[0] & 0x30) >> 4;
  sp           = (ptr_msg_i[0] & 0x08) >> 3;
  ptr_d_header_i->payload  = payload;
  /*if ctrl block with optional parameter*/
  if(payload EQ CTRL_BLK_OPT )
  {
    ptr_d_header_i->d_ctrl.rrbp         = rrbp;
    ptr_d_header_i->d_ctrl.sp           = sp;
    ptr_d_header_i->d_ctrl.rbsn         = (ptr_msg_i[1] & 0x80) >> 7;
    ptr_d_header_i->d_ctrl.rti          = (ptr_msg_i[1] & 0x7C) >> 2;
    ptr_d_header_i->d_ctrl.fs           = (ptr_msg_i[1] & 0x02) >> 1;
    ptr_d_header_i->d_ctrl.ac           = (ptr_msg_i[1] & 0x01);
    if(ptr_d_header_i->d_ctrl.ac EQ 1)
    {
      ptr_d_header_i->d_ctrl.msg_type     = ptr_msg_i[3] >> 2;
      ptr_d_header_i->d_ctrl.tfi          = (ptr_msg_i[2] & 0x3E) >> 1;
      ptr_d_header_i->d_ctrl.d            = (ptr_msg_i[2] & 0x01);
      ptr_d_header_i->ptr_block           = &ptr_msg_i[3];
    }
    else
    {
      ptr_d_header_i->d_ctrl.msg_type     = ptr_msg_i[2] >> 2;
      ptr_d_header_i->ptr_block           = &ptr_msg_i[2];
    }

    TRACE_EVENT_P4("optional header received: 0x%x 0x%x 0x%x 0x%x",ptr_msg_i[0],ptr_msg_i[1],ptr_msg_i[2],ptr_msg_i[3]);
  }
  else if(payload EQ CTRL_BLK_NO_OPT )
    /*if ctrl block with optional parameter*/
  {
    ptr_d_header_i->d_ctrl.msg_type     = ptr_msg_i[1] >> 2;
    ptr_d_header_i->d_ctrl.rrbp         = rrbp;
    ptr_d_header_i->d_ctrl.sp           = sp;
    ptr_d_header_i->ptr_block           = &ptr_msg_i[1];
  }
  else
  {
    TRACE_ERROR("unknown payload type");
    TRACE_EVENT_P5("pt=%d FIRST 5 BYTES: 0x%x 0x%x 0x%x 0x%x",payload,ptr_msg_i[0],ptr_msg_i[1],ptr_msg_i[2],ptr_msg_i[3]);
  }

} /* grr_decode_rlcmac() */



/*
+------------------------------------------------------------------------------
| Function    : grr_handle_rlcmac_header
+------------------------------------------------------------------------------
| Description : The function grr_handle_rlcmac_header() 
|
| Parameters  : mode_i - possible values: 
|                        PACKET_MODE_PIM/PACKET_MODE_PAM and 
|                         (that means message was received over MPHP)
|                        PACKET_MODE_PTM
|                         (that means message was received over RLCMAC)
|               remark: the reason for introduce mode_i is lost? 
|               ptr_header_i - pointer to mac header of the rlc block
|               fn_i - frame number
|               
+------------------------------------------------------------------------------
*/
GLOBAL T_MSGBUF * grr_handle_rlcmac_header ( T_PACKET_MODE   mode_i, 
                                             T_D_HEADER    * ptr_header_i,
                                             ULONG           fn_i )
{ 

  T_MSGBUF * result = (T_MSGBUF *)(& grr_data->ctrl_msg);

  UBYTE i;
  UBYTE frame_periods;

  TRACE_FUNCTION( "grr_handle_rlcmac_header" );

  if(ptr_header_i->payload EQ CTRL_BLK_NO_OPT)
  {
    /*
     * not segmented control block
     */
    result->l_buf = 22*8;
    result->o_buf = 0;
    memcpy(result->buf, ptr_header_i->ptr_block, (result->l_buf)/8);
    ptr_header_i->pctrl_ack = 3;
  } 
  else if (ptr_header_i->payload EQ CTRL_BLK_OPT)
  { 
    /*
     * segmented control block
     */
    if(ptr_header_i->d_ctrl.ac)
      result->l_buf = (22-2)*8;
    else
      result->l_buf = (22-1)*8;
    
    if(ptr_header_i->d_ctrl.fs AND !ptr_header_i->d_ctrl.rbsn)
    {
      result->o_buf  = 0;
      memcpy(result->buf, ptr_header_i->ptr_block, (result->l_buf)/8);
      ptr_header_i->pctrl_ack = 2;
      /*
      TRACE_EVENT("optional rlc mac header without segmentation");
      */
    }
    else if(ptr_header_i->d_ctrl.fs)
    {
      /*
       * check if the first part is received, otherwise delete
       */
      grr_clean_up_seg_ctrl_blk_tbl();
/*      for(i=grr_data->seg_ctrl_blk.next-1;i NEQ grr_data->seg_ctrl_blk.next;((i--)%8))*/
      for(i = 0;i < SEG_CTRL_BLOCK_SIZE ;i++)
      {
        if(ptr_header_i->d_ctrl.rti EQ grr_data->seg_ctrl_blk.blk[i].rti)
        { 
          /*
           * a part of the recently received control block is saved, 
           * reassabling is possible 
           */
          if(!(ptr_header_i->d_ctrl.rbsn))
          { /*
             * received part is the first part of the segmented block
             * copy recently received as first part
             */
            memcpy(result->buf, ptr_header_i->ptr_block, (result->l_buf)/8);
            /*
             * copy previous saved as second part 
             */
            memcpy(result->buf+(result->l_buf)/8,grr_data->seg_ctrl_blk.blk[i].ctrl_blk.buf, 
                                        (grr_data->seg_ctrl_blk.blk[i].ctrl_blk.l_buf)/8);
          }
          else
          { 
            /*
             * received part is the second part of the segmented block
             * copy saved part as first part
             */
            memcpy(result->buf, grr_data->seg_ctrl_blk.blk[i].ctrl_blk.buf, 
                          (grr_data->seg_ctrl_blk.blk[i].ctrl_blk.l_buf)/8);
            /*
             * copy recently received as second part
             */
            memcpy(result->buf+(grr_data->seg_ctrl_blk.blk[i].ctrl_blk.l_buf)/8, 
                                     ptr_header_i->ptr_block, (result->l_buf)/8);
          }
          result->l_buf += grr_data->seg_ctrl_blk.blk[i].ctrl_blk.l_buf;
          result->o_buf  = 0;
          ptr_header_i->pctrl_ack = 3;
          grr_data->seg_ctrl_blk.blk[i].rti = 0xFF;
          /*
           * break condition: saved part was found 
           */
          break; 
        }
        else
        {
          if(i EQ SEG_CTRL_BLOCK_SIZE)
          {
            result = NULL;  
            TRACE_ERROR("final segment but no identical rti values");
          }
        }
      }
    }
    else
    {
      /*
       * save the first part of a control block
       */
      if(0xff EQ grr_data->seg_ctrl_blk.next)
        grr_data->seg_ctrl_blk.next = 0; /* for safety only (former glumpshack) */
      if(0xFF NEQ grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].rti)
      {
        grr_clean_up_seg_ctrl_blk_tbl();
        grr_align_seg_ctrl_blk_nxt();
      }
      
      /*
       * calculate the timeout value for T3200 in untis of frames 
       */       
      if( mode_i                  EQ PACKET_MODE_PIM AND
          grr_is_non_drx_period( )           )
      {
        frame_periods = 4 * MAXIMUM( 1, psc_db->gprs_cell_opt.bs_cv_max );
      }
      else
      {
        USHORT drx_p;
        drx_p = meas_im_get_drx_period_frames( );
        frame_periods = MAXIMUM( 1,drx_p );
      }

      grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].rbsn  = 
                                         ptr_header_i->d_ctrl.rbsn;
      grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].rti   = 
                                         ptr_header_i->d_ctrl.rti;
      grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].T3200 = 
        ( fn_i + 4 * frame_periods ) % FN_MAX;
      grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].ctrl_blk.l_buf = 
                                                               result->l_buf;
      grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].ctrl_blk.o_buf = 0;
      memcpy(grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].ctrl_blk.buf, 
                                        ptr_header_i->ptr_block, (result->l_buf/8));
      
/*      (grr_data->seg_ctrl_blk.next++)%8; */
      grr_clean_up_seg_ctrl_blk_tbl();
      grr_align_seg_ctrl_blk_nxt();

      if(ptr_header_i->d_ctrl.rbsn)
        ptr_header_i->pctrl_ack = 1; 
      else
        ptr_header_i->pctrl_ack = 2; 
      result = NULL;
    }    
  }
  else
    {
      TRACE_ERROR(" payload type is not a control block ");
    }
  return(result);

} /* grr_handle_rlcmac_header() */


/*
+------------------------------------------------------------------------------
| Function    : grr_check_address
+------------------------------------------------------------------------------
| Description : The function grr_check_address() this function checks the 
|               message of the message in _decodeCtrlMsg. The Function returns 
|               TRUE if the address is correct.    
|
| Parameters  : msg_type_i - the airmessage type defined in M_GRR.val
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_check_address ( UBYTE msg_type_i,UBYTE tn_i )
{ 

  BOOL result = FALSE;
  TRACE_FUNCTION( "grr_check_address" );

  switch( msg_type_i )
    {
    case D_ACCESS_REJ_c:
      result = grr_check_add_reject(tn_i);
      break;

    case D_QUEUING_NOT_c:
      {
        MCAST(queuing_not,D_QUEUING_NOT);
        result = grr_check_request_reference(&(queuing_not->req_ref_p));
      }
      break;

    case D_TBF_RELEASE_c:
      {
        MCAST(tbf_release,D_TBF_RELEASE);
        result = grr_check_glob_tfi(&(tbf_release->glob_tfi),tn_i );
      }
      break;

    case D_TS_RECONFIG_c:
      {
        MCAST(d_ts_reconfig,D_TS_RECONFIG);
        result = grr_check_glob_tfi( &(d_ts_reconfig->glob_tfi),tn_i );
      }
      break;

    case D_PAGING_REQ_c:
      result = TRUE;
        /*grr_check_page_add();*/
      break;

    case D_UL_ACK_c:
      {
        MCAST(ul_ack,D_UL_ACK);
        if((grr_data->uplink_tbf.tfi EQ ul_ack->ul_tfi) AND
           ((0x80>>tn_i) & grr_data->uplink_tbf.ts_mask))
        {
          result = TRUE;
        }
        else
        {
          TRACE_EVENT_P6("ul_ack adress failed add_tfi=%d, ul_tfi=%d, || tn=%d ->mask=%x curr_mask=%x, st_mask=%x ",
                                        ul_ack->ul_tfi,
                                        grr_data->uplink_tbf.tfi,
                                        tn_i,
                                        0x80>>tn_i,
                                        grr_data->uplink_tbf.ts_mask,
                                        grr_data->uplink_tbf.ts_usage);

        }
      }
      break;

    case D_CELL_CHAN_ORDER_c:
      {
        MCAST(d_cell_chan_order,D_CELL_CHAN_ORDER);
        result = grr_check_add_1( &(d_cell_chan_order->add1),tn_i );
      }
      break;

    case D_MEAS_ORDER_c:
      {
        MCAST(d_meas_order,D_MEAS_ORDER);
        result = grr_check_add_1( &(d_meas_order->add1),tn_i );
      }
      break;

    case D_DL_ASSIGN_c:
      {
        MCAST(d_dl_assign,D_DL_ASSIGN);
        result = grr_check_add_1( &(d_dl_assign->add1),tn_i );
      }
      break;

    case D_POLLING_REQ_c:
      {
        MCAST(d_polling_req,D_POLLING_REQ);
        result = grr_check_add_2( &(d_polling_req->add2),tn_i );
      }
      break;

    case D_CTRL_PWR_TA_c:
      {
        MCAST(d_ctrl_pwr_ta,D_CTRL_PWR_TA);
        result = grr_check_add_4( &(d_ctrl_pwr_ta->add4),tn_i );
      }
      break;

    case D_UL_ASSIGN_c:
      {
        MCAST(d_ul_assign,D_UL_ASSIGN);
        result = grr_check_add_3( &(d_ul_assign->add3),tn_i );
      }
      break;

      /*
       * the following messages do not have a address field 
       * therefore the result is always TRUE
       */
    case PSI_1_c:            
    case PSI_2_c:                
    case PSI_3_c:               
    case PSI_3_BIS_c:
#if defined (REL99) AND defined (TI_PS_FF_EMR)
    case PSI_3_TER_c:
#endif
    case PSI_4_c:           
    case PSI_5_c:
#ifdef REL99
    case PSI_8_c:               
#endif
    case PSI_13_c:               
    case D_DL_DUMMY_c:   
    case D_PDCH_RELEASE_c:
    case D_PRACH_PAR_c:       
      result = TRUE;
      break;

    default:
      TRACE_ERROR("grr_check_address with invalid message type");
      break;
  } /* switch (msg_type_i) */
  
  return(result); 
  
} /* grr_check_address() */


/*
+------------------------------------------------------------------------------
| Function    : grr_increase_dsc
+------------------------------------------------------------------------------
| Description : The function grr_increase_dsc increases dsc by 1
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/          
GLOBAL void grr_increase_dsc ( void )
{
  TRACE_FUNCTION( "grr_increase_dsc" );
  
  grr_data->pg.dsc++;

  if(grr_data->pg.dsc > grr_data->pg.initial_dsc)
  {
    grr_data->pg.dsc = grr_data->pg.initial_dsc;
  }

  GRR_EM_SET_DSC_VAL(grr_data->pg.dsc);
  
#ifdef _SIMULATION_
  TRACE_EVENT_P1( "DSC: %d", grr_data->pg.dsc );
#endif /* #ifdef _SIMULATION_ */
}/* grr_increase_dsc*/

/*
+------------------------------------------------------------------------------
| Function    : grr_decrease_dsc
+------------------------------------------------------------------------------
| Description : The function grr_decrease_dsc decreases dsc by 4
|
| Parameters  : return BOOL: indicates whether downlink siganlling failure 
|               occured or not
|
+------------------------------------------------------------------------------
*/          
GLOBAL BOOL grr_decrease_dsc ( void )
{
  TRACE_FUNCTION( "grr_decrease_dsc" );
  
  if( grr_data->pg.dsc <= 4 )
  {
    grr_data->pg.dsc  = 0;
  }
  else
  {
    grr_data->pg.dsc -= 4;
  }

  GRR_EM_SET_DSC_VAL(grr_data->pg.dsc);

#ifdef _SIMULATION_
  TRACE_EVENT_P1( "DSC: %d", grr_data->pg.dsc );
#endif /* #ifdef _SIMULATION_ */

  return( grr_data->pg.dsc EQ 0 );
}/* grr_decrease_dsc*/

/*
+------------------------------------------------------------------------------
| Function    : grr_t_status
+------------------------------------------------------------------------------
| Description : This function returns the remaining time in milliseconds.
|               A value of 0L is returned in case the timer is not existing or
|               not running.
|
| Parameters  : t_index : timer index
|
+------------------------------------------------------------------------------
*/
GLOBAL T_TIME grr_t_status( USHORT t_index )
{
  T_TIME t_time = 0L;
  
  TRACE_FUNCTION( "grr_t_status" );

  vsi_t_status( GRR_handle, t_index, &t_time );

  return( t_time );
} /* grr_t_status */ 

/*
+------------------------------------------------------------------------------
| Function    : grr_get_nc_mval
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL T_NC_MVAL* grr_get_nc_mval ( USHORT arfcn, UBYTE bsic, UBYTE *idx )
{
  UBYTE      i;
  T_NC_MVAL *nc_mval = NULL;

  TRACE_FUNCTION( "grr_get_nc_mval" );

  for( i = 0; i < MAX_NR_OF_NC_MVAL AND nc_mval EQ NULL; i++ )
  {
    nc_mval = &grr_data->db.nc_mval_list.nc_mval[i];
    *idx    = i;

    if( bsic EQ RRGRR_INVALID_BSIC )
    {
      if( nc_mval->arfcn NEQ arfcn )
      {
        nc_mval = NULL;
      }
    }
    else
    {
      if( nc_mval->arfcn NEQ arfcn OR nc_mval->sync_info.bsic NEQ bsic )
      {
        nc_mval = NULL;
      }
    }
  }

  return( nc_mval );
} /* grr_get_nc_mval */ 

/*
+------------------------------------------------------------------------------
| Function    : grr_get_ncell_info
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL T_ncell_info* grr_get_ncell_info ( USHORT arfcn, UBYTE bsic )
{
  UBYTE         i;
  T_ncell_info *ncell_info = NULL;

  TRACE_FUNCTION( "grr_get_ncell_info" );

  for( i = 0; i < grr_data->db.nc_ref_lst.number AND ncell_info EQ NULL; i++ )
  {
    ncell_info = grr_data->db.nc_ref_lst.info[i];

    if( bsic EQ RRGRR_INVALID_BSIC )
    {
      if( ncell_info->arfcn NEQ arfcn )
      {
        ncell_info = NULL;
      }
    }
    else
    {
      if( ncell_info->arfcn NEQ arfcn OR ncell_info->bsic NEQ bsic )
      {
        ncell_info = NULL;
      }
    }
  }

  return( ncell_info );
} /* grr_get_ncell_info */ 

/*
+------------------------------------------------------------------------------
| Function    : grr_set_pbcch
+------------------------------------------------------------------------------
| Description : This function sets pbcch presence. It is no more handled 
|               in PSI only.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_set_pbcch ( BOOL pbcch_presence )
{
  TRACE_FUNCTION( "grr_set_pbcch" );

  psc_db->pbcch.bcch.pbcch_present = pbcch_presence;

#if !defined (NTRACE)

  if( grr_data->cs.v_crp_trace EQ TRUE )
  {
    TRACE_EVENT_P3( "database: psc = %d, PBCCH presence: %d %d",
                    grr_get_db_num( psc_db ), 
                    grr_data->sc_db_1.pbcch.bcch.pbcch_present, 
                    grr_data->sc_db_2.pbcch.bcch.pbcch_present );
  }

#endif /* #if !defined (NTRACE) */

} /* grr_set_pbcch */

/*
+------------------------------------------------------------------------------
| Function    : grr_set_pg_nmo
+------------------------------------------------------------------------------
| Description : This function sets NMO for paging
|               If NMO II and PBCCH present, then assume paging coordination
|               is used. The MS will act as NMO I mobile with PBCCH
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_set_pg_nmo(void)
{
  if( psc_db->pbcch.bcch.pbcch_present
      AND 
      psc_db->cell_info_for_gmm.cell_info.net_mode EQ GMMRR_NET_MODE_II )
  {
    grr_data->pg.nmo = GMMRR_NET_MODE_I;
    TRACE_EVENT("Network is NMO II, but with PBCCH. The MS will act as NMO I (paging coordination)");
  }
  else
    grr_data->pg.nmo = psc_db->cell_info_for_gmm.cell_info.net_mode;
}/*grr_set_pg_nmo*/

/*
+------------------------------------------------------------------------------
| Function    : grr_set_freq_par
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_set_freq_par ( T_p_frequency_par *freq_par )
{
  TRACE_FUNCTION( "grr_set_freq_par" );

  freq_par->p_chan_sel = grr_data->tc.freq_set.freq_par.p_chan_sel;

  if( grr_data->tc.freq_set.freq_par.p_chan_sel.hopping )
  {
    freq_par->p_freq_list = grr_data->tc.freq_set.freq_par.p_freq_list;
  }
  else
  {
    memset( &freq_par->p_freq_list, 0, sizeof( freq_par->p_freq_list ) );
  }
} /* grr_set_freq_par */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_pccch_freq_par
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_get_pccch_freq_par ( UBYTE          pccch_group, 
                                     T_p_chan_sel  *chan_sel,
                                     T_p_freq_list *freq_list )
{
  BOOL result = FALSE;

  TRACE_FUNCTION( "grr_get_pccch_freq_par" );

  if( pccch_group > psc_db->paging_group.kc - 1 )
  {
    TRACE_ERROR( "pccch_group > psc_db->paging_group.kc - 1" );

    return( result );
  }

  if( psc_db->paging_group.pccch[pccch_group].is_static )
  {
    chan_sel->hopping       = 0;
    chan_sel->p_rf_ch.arfcn = psc_db->paging_group.pccch[pccch_group].arfcn;

    result = TRUE;
  }
  else
  {
    result = 
      grr_create_freq_list(  psc_db->paging_group.pccch[pccch_group].ma_num,
                             psc_db->paging_group.pccch[pccch_group].maio,
                             chan_sel,
                             freq_list );
  }

  return( result );
} /* grr_get_pccch_freq_par */

/*
+------------------------------------------------------------------------------
| Function    : grr_cgrlc_pwr_ctrl_cnf
+------------------------------------------------------------------------------
| Description : Handles the primitive CGRLC_PWR_CTRL_CNF
|
| Parameters  : cgrlc_pwr_ctrl_cnf - Ptr to primitive payload  
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_cgrlc_pwr_ctrl_cnf ( T_CGRLC_PWR_CTRL_CNF *cgrlc_pwr_ctrl_cnf )
{ 
  TRACE_FUNCTION( "grr_cgrlc_pwr_ctrl_cnf" );

  PFREE( cgrlc_pwr_ctrl_cnf );

} /* grr_cgrlc_pwr_ctrl_cnf() */

/*
+------------------------------------------------------------------------------
| Function    : grr_cgrlc_pwr_ctrl_req
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_cgrlc_pwr_ctrl_req( BOOL v_c_value )
{
  TRACE_FUNCTION( "grr_cgrlc_pwr_ctrl_req" );

  {
    PALLOC( cgrlc_pwr_ctrl_req, CGRLC_PWR_CTRL_REQ );

    grr_prcs_pwr_ctrl( &cgrlc_pwr_ctrl_req->pwr_ctrl, v_c_value );

    if( cgrlc_pwr_ctrl_req->pwr_ctrl.v_pwr_ctrl_param      EQ FALSE AND
        cgrlc_pwr_ctrl_req->pwr_ctrl.v_glbl_pwr_ctrl_param EQ FALSE AND
        cgrlc_pwr_ctrl_req->pwr_ctrl.v_freq_param          EQ FALSE AND
        cgrlc_pwr_ctrl_req->pwr_ctrl.v_c_value             EQ FALSE     )
    {
      PFREE( cgrlc_pwr_ctrl_req );
    }
    else
    {
      PSEND( hCommGRLC, cgrlc_pwr_ctrl_req );
    }
  }
} /* grr_cgrlc_pwr_ctrl_req() */

/*
+------------------------------------------------------------------------------
| Function    : grr_prcs_pwr_ctrl
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_prcs_pwr_ctrl ( T_CGRLC_pwr_ctrl *pwr_ctrl, BOOL v_c_value )
{
  USHORT pdch_arfcn;

  TRACE_FUNCTION( "grr_prcs_pwr_ctrl" );

  if( grr_data->tc.v_freq_set )
  {
    /*
     * Apply the ARFCN value obtained from the assignment message.
     *
     * When getting the ARFCN value, reconvert it to the absolute
     * ARFCN value, since grr_data->tc has L1 mapped ARFCN values.
     */
    if( grr_data->tc.freq_set.freq_par.p_chan_sel.hopping )
    {
      /* If hopping is enabled, then take the first ARFCN value from the assignment */
      pdch_arfcn = 
        grr_l1_arfcn_to_g23
          ( grr_data->tc.freq_set.freq_par.p_freq_list.p_rf_chan_no.p_radio_freq[0] );
    }
    else 
    {
      /* If hopping is disabled, then take the ARFCN value from the assignment */
      pdch_arfcn = 
        grr_l1_arfcn_to_g23
          ( grr_data->tc.freq_set.freq_par.p_chan_sel.p_rf_ch.arfcn );
    }
  }
  else
  {
    pdch_arfcn = psc_db->pbcch.bcch.arfcn;
  }
   
  if( grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param )
  {
    T_CGRLC_pwr_ctrl_param *pwr_ctrl_param = &pwr_ctrl->pwr_ctrl_param;

    if( psc_db->v_pwr_par EQ TRUE AND psc_db->pwr_par.v_alpha EQ TRUE )
    {
      pwr_ctrl_param->alpha = psc_db->pwr_par.alpha;
    }
    else
    {
      pwr_ctrl_param->alpha = CGRLC_ALPHA_INVALID;
    }
        
    {
      UBYTE i;

      for( i = 0; i < CGRLC_MAX_TIMESLOTS; i++ )
      {
        if( psc_db->v_pwr_par                   EQ TRUE AND
            psc_db->pwr_par.gamma_tn[i].v_gamma EQ TRUE     )
        {
          pwr_ctrl_param->gamma_ch[i] = psc_db->pwr_par.gamma_tn[i].gamma;
        }
        else
        {
          pwr_ctrl_param->gamma_ch[i] = CGRLC_GAMMA_INVALID;
        }
      }
    }
  }

  if( grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param )
  {
    T_CGRLC_glbl_pwr_ctrl_param *glbl_pwr_ctrl_param =
                                                &pwr_ctrl->glbl_pwr_ctrl_param;
    
    T_MS_PWR_CAP mspc;

    glbl_pwr_ctrl_param->alpha        = psc_db->g_pwr_par.alpha;
    glbl_pwr_ctrl_param->t_avg_t      = psc_db->g_pwr_par.t_avg_t;
    glbl_pwr_ctrl_param->pb           = psc_db->g_pwr_par.pb;
    glbl_pwr_ctrl_param->pc_meas_chan = psc_db->g_pwr_par.pc_meas_chan;
    glbl_pwr_ctrl_param->pwr_max      = grr_get_pms_max
                                          (  pdch_arfcn,
                                             grr_data->meas.pwr_offset,
                                             psc_db->scell_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch,
                                            &mspc );
  }

  if( grr_data->pwr_ctrl_valid_flags.v_freq_param )
  {
    T_CGRLC_freq_param *freq = &pwr_ctrl->freq_param;

    T_MS_PWR_CAP mspc;

    grr_get_ms_pwr_cap(  pdch_arfcn, grr_data->meas.pwr_offset, &mspc );
    
    freq->bcch_arfcn   = grr_g23_arfcn_to_l1( psc_db->pbcch.bcch.arfcn );
    freq->pdch_hopping = ( grr_data->tc.v_freq_set                           AND 
                           grr_data->tc.freq_set.freq_par.p_chan_sel.hopping     );
    freq->pdch_band    = mspc.band_ind;
  }
      
  if( v_c_value )
  {
    if( grr_data->pwr_ctrl_valid_flags.v_c_value )
    {
      meas_c_get_c_value( &pwr_ctrl->c_value );
    }

    pwr_ctrl->v_c_value           = grr_data->pwr_ctrl_valid_flags.v_c_value;
    grr_data->pwr_ctrl_valid_flags.v_c_value           = FALSE;
  }
  else
  {
    pwr_ctrl->v_c_value           = v_c_value;
  }

  pwr_ctrl->v_pwr_ctrl_param      = grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param;
  pwr_ctrl->v_glbl_pwr_ctrl_param = grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param;
  pwr_ctrl->v_freq_param          = grr_data->pwr_ctrl_valid_flags.v_freq_param;

  grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param      = FALSE;
  grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param = FALSE;
  grr_data->pwr_ctrl_valid_flags.v_freq_param          = FALSE;

} /* grr_prcs_pwr_ctrl */

/*
+------------------------------------------------------------------------------
| Function    : grr_set_cell_info_service
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_set_cell_info_service( void )
{
  TRACE_FUNCTION( "grr_set_cell_info_service" );

  if     ( psc_db->cell_info_for_gmm.gprs_service  EQ GPRS_SERVICE_NONE       )
  {
    psc_db->cell_info_for_gmm.cell_info.service_state = GMMRR_SERVICE_NONE;
  }
  else if( psc_db->cell_info_for_gmm.gprs_service  EQ GPRS_SERVICE_FULL   AND
           psc_db->cell_info_for_gmm.access_status EQ GPRS_ACCESS_ALLOWED     )
  {
    psc_db->cell_info_for_gmm.cell_info.service_state = GMMRR_SERVICE_FULL;
  }
  else
  {
    psc_db->cell_info_for_gmm.cell_info.service_state = GMMRR_SERVICE_LIMITED;
  }
} /* grr_set_cell_info_service */

/*
+------------------------------------------------------------------------------
| Function    : grr_is_packet_idle_mode
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_is_packet_idle_mode( void )
{
  /*
   * The entity GRR as a whole is in packet idle mode in case the three state
   * machines below are in packet idle mode in detail.
   *
   * There are state transitions, in which one of these state machines is in
   * packet idle mode, but the others are in different states (e.g. during
   * processing of RRGRR_STOP_TASK_REQ/CNF or MPHP_ASSIGNMENT_REQ/CON). That's
   * why all three states shall be considered.
   */

  return( GET_STATE( CTRL_GLBL ) EQ GLBL_PCKT_MODE_IDLE AND
          GET_STATE( TC        ) EQ TC_PIM              AND 
          GET_STATE( CPAP      ) EQ CPAP_IDLE               );

} /* grr_is_packet_idle_mode */

/*
+------------------------------------------------------------------------------
| Function    : grr_clip_rxlev
+------------------------------------------------------------------------------
| Description : This function is used to clip received signal level values.
|
| Parameters  : clipp  - pointer to clipped received signal level values
|               rxlev  - pointer to received signal level values
|               number - number of received signal level values
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_clip_rxlev ( UBYTE *clipp, UBYTE *rxlev, UBYTE number )
{ 
  UBYTE i; /* used for counting */
  
  TRACE_FUNCTION( "grr_clip_rxlev" );

  for( i = 0; i < number; i++ )
  { 
    if( (signed char)( rxlev[i] ) <   CGRLC_RXLEV_MIN  AND
                       rxlev[i]   NEQ CGRLC_RXLEV_NONE     )
    {
      clipp[i] = CGRLC_RXLEV_MIN;
    }
    else if ( (signed char)( rxlev[i] ) > CGRLC_RXLEV_MAX )
    {
      clipp[i] = CGRLC_RXLEV_MAX;
    }
    else if( rxlev[i] EQ CGRLC_RXLEV_NONE )
    {
      clipp[i] = CGRLC_RXLEV_NONE;
    }
    else
    {
      clipp[i] = rxlev[i];
    }
  }
} /* grr_clip_rxlev() */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_pms_max
+------------------------------------------------------------------------------
| Description : This function is used to ...
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE grr_get_pms_max ( USHORT        arfcn,
                               UBYTE         pwr_offset,
                               UBYTE         gprs_ms_txpwr_max_cch,
                               T_MS_PWR_CAP *mspc                   )
{ 
  UBYTE pms_max; /* maximum output power applied by the MS */
  
  TRACE_FUNCTION( "grr_get_pms_max" ); 

  grr_get_ms_pwr_cap( arfcn, pwr_offset, mspc );

  pms_max = mspc->pwr_offset + mspc->p_control[gprs_ms_txpwr_max_cch];
  pms_max = MINIMUM( pms_max, mspc->p[mspc->ms_power] );

  return( pms_max );

} /* grr_get_pms_max() */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_ms_txpwr_max_cch
+------------------------------------------------------------------------------
| Description : ...
|
| Parameters  : ...
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE grr_get_ms_txpwr_max_cch ( USHORT arfcn,
                                        UBYTE  pwr_offset,
                                        UBYTE  gprs_ms_txpwr_max_cch )
{ 
  T_MS_PWR_CAP mspc;    /* MS power capabilities                  */
  UBYTE        pms_max; /* maximum output power applied by the MS */

  TRACE_FUNCTION( "grr_get_ms_txpwr_max_cch" );

  pms_max = grr_get_pms_max( arfcn, pwr_offset, gprs_ms_txpwr_max_cch, &mspc );

  return( grr_get_pcl( mspc.p_control, pms_max ) );

} /* grr_get_ms_txpwr_max_cch() */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_ms_pwr_cap
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_get_ms_pwr_cap ( USHORT        arfcn,
                                 UBYTE         pow_offset,
                                 T_MS_PWR_CAP *mspc        )
{ 
  TRACE_FUNCTION( "grr_get_ms_pwr_cap" );
  
  switch( std )
  {
    case STD_850:
      grr_get_ms_pwr_cap_gsm900
        ( grr_get_power_class( IDX_PWRCLASS_850 ), mspc );
      break;

    case STD_900:
    case STD_EGSM:
      grr_get_ms_pwr_cap_gsm900
        ( grr_get_power_class( IDX_PWRCLASS_900 ), mspc );
      break;

    case STD_1900:
      grr_get_ms_pwr_cap_pcs1900
        ( grr_get_power_class( IDX_PWRCLASS_1900 ), pow_offset, mspc );
      break;

    case STD_1800:
      grr_get_ms_pwr_cap_dcs1800
        ( grr_get_power_class( IDX_PWRCLASS_1800 ), pow_offset, mspc );
      break;

    case STD_DUAL:
      /*
       * For dualband mobiles the calculation depends on the channel number
       */
      if( arfcn < LOW_CHANNEL_1800 )
      {
        /*
         * All GSM 900
         */
        grr_get_ms_pwr_cap_gsm900
          ( grr_get_power_class( IDX_PWRCLASS_900 ), mspc );
      }
      else
      {
        /*
         * All DCS 1800 channels
         */
        grr_get_ms_pwr_cap_dcs1800
          ( grr_get_power_class( IDX_PWRCLASS_1800 ), pow_offset, mspc );
      }
      break;

    case STD_DUAL_EGSM:
      if( arfcn < LOW_CHANNEL_1800  OR
          arfcn > HIGH_CHANNEL_1800    )
      {
        /*
         * All GSM 900 and E-GSM channels
         */
        grr_get_ms_pwr_cap_gsm900
          ( grr_get_power_class( IDX_PWRCLASS_900 ), mspc );
      }
      else
      {
        /*
         * All DCS 1800 channels
         */
        grr_get_ms_pwr_cap_dcs1800
          ( grr_get_power_class( IDX_PWRCLASS_1800 ), pow_offset, mspc );
      }
      break;

    case STD_DUAL_US:
      if( arfcn < LOW_CHANNEL_1900 )
      {
        /*
         * All GSM 850 channels
         */
        grr_get_ms_pwr_cap_gsm900
          ( grr_get_power_class( IDX_PWRCLASS_850 ), mspc );
      }
      else
      {
        /*
         * All PCS 1900 channels
         */
        grr_get_ms_pwr_cap_pcs1900
          ( grr_get_power_class( IDX_PWRCLASS_1900 ), pow_offset, mspc );
      }
      break;

#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
      case STD_850_1800:
      if( arfcn < LOW_CHANNEL_1800 )
      {
        /*
         * All GSM 850 channels
         */
        grr_get_ms_pwr_cap_gsm900
          ( grr_get_power_class( IDX_PWRCLASS_850 ), mspc );
      }
      else
      {
        /*
         * All DCS 1800 channels
         */
        grr_get_ms_pwr_cap_dcs1800
          ( grr_get_power_class( IDX_PWRCLASS_1800 ), pow_offset, mspc );
      }
      break;

      case STD_900_1900:
      if( arfcn >= LOW_CHANNEL_1900  AND
          arfcn <= HIGH_CHANNEL_1900 )
      {
        /*
         * All PCS 1900 channels
         */
        grr_get_ms_pwr_cap_pcs1900
          ( grr_get_power_class( IDX_PWRCLASS_1900 ), pow_offset, mspc );

      }
      else
      {
        /*
         * All GSM 900 and E-GSM channels
         */
        grr_get_ms_pwr_cap_gsm900
          ( grr_get_power_class( IDX_PWRCLASS_900 ), mspc );
      }
      break;
        
      case STD_850_900_1800:
      if( arfcn >= LOW_CHANNEL_1800  AND
          arfcn <= HIGH_CHANNEL_1800 )
      {
        /*
         * All DCS 1800 channels
         */
        grr_get_ms_pwr_cap_dcs1800
          ( grr_get_power_class( IDX_PWRCLASS_1800 ), pow_offset, mspc );

      }
      else
      {
        if((arfcn >= LOW_CHANNEL_850) AND (arfcn <= HIGH_CHANNEL_850))
        {
          /*
           * All GSM 850 channels
           */
          grr_get_ms_pwr_cap_gsm900
            ( grr_get_power_class( IDX_PWRCLASS_850 ), mspc );
        }
        else
        {
          /*
           * All GSM 900 and E-GSM channels
           */
          grr_get_ms_pwr_cap_gsm900
            ( grr_get_power_class( IDX_PWRCLASS_900 ), mspc );
        }
      }
      break;

      case STD_850_900_1900:
      if( arfcn >= LOW_CHANNEL_1900  AND
          arfcn <= HIGH_CHANNEL_1900 )
      {
        /*
         * All PCS 1900 channels
         */
        grr_get_ms_pwr_cap_pcs1900
          ( grr_get_power_class( IDX_PWRCLASS_1900 ), pow_offset, mspc );

      }
      else
      {
        if((arfcn >= LOW_CHANNEL_850) AND (arfcn <= HIGH_CHANNEL_850))
        {
          /*
           * All GSM 850 channels
           */
          grr_get_ms_pwr_cap_gsm900
            ( grr_get_power_class( IDX_PWRCLASS_850 ), mspc );
        }
        else
        {
          /*
           * All GSM 900 and E-GSM channels
           */
          grr_get_ms_pwr_cap_gsm900
            ( grr_get_power_class( IDX_PWRCLASS_900 ), mspc );
        }
      }
      break;

      default :
        TRACE_EVENT_P1 (" std : %d",std);
        break;
#endif
  }
} /* grr_get_ms_pwr_cap */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_ms_pwr_cap_gsm900
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_get_ms_pwr_cap_gsm900 ( UBYTE         rf_pow_cap,
                                        T_MS_PWR_CAP *mspc        )
{ 
  TRACE_FUNCTION( "grr_get_ms_pwr_cap_gsm900" );

  /*
   * The table for the power class conversion in GSM 900
   */
  mspc->p          = p_gsm;

  /*
   * The table for the GPRS_MAX_TXPWR_CCCH conversion in GSM 900
   */
  mspc->p_control  = p_control_gsm;

  /*
   * The MS power class is defined in classmark 2 of the non-volatile
   * memory data for GSM 900.
   */
  mspc->ms_power   = rf_pow_cap - 1;

  /*
   * For a power class 3 mobile in the DCS or PCS frequency 
   * standard an additional power offset can be defined
   *
   * Note: This parameter is only available for the serving cell
   *
   */
  mspc->pwr_offset = 0;

  /*
   * Maximum allowed output power in the cell
   */
  mspc->pwr_max    = p_control_gsm[MAX_PCL_GSM900];
   
  /*
   * Minimum required output power in the cell 
   */
  mspc->pwr_min    = p_control_gsm[MIN_PCL_GSM900];

  mspc->gamma_0    = GAMMA_0_GSM900;

  mspc->band_ind   = CGRLC_GSM_900;
} /* grr_get_ms_pwr_cap_gsm900 */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_ms_pwr_cap_dcs1800
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_get_ms_pwr_cap_dcs1800 ( UBYTE         rf_pow_cap,
                                         UBYTE         pow_offset,
                                         T_MS_PWR_CAP *mspc        )
{ 
  TRACE_FUNCTION( "grr_get_ms_pwr_cap_dcs1800" );

  mspc->p          = p_dcs;
  mspc->p_control  = p_control_dcs;
  mspc->ms_power   = rf_pow_cap - 1;
  mspc->pwr_offset = ( ( rf_pow_cap EQ POWER_CLASS_3 ) ? 2 * pow_offset : 0 );
  mspc->pwr_max    = p_control_dcs[MAX_PCL_DCS1800];
  mspc->pwr_min    = p_control_dcs[MIN_PCL_DCS1800];
  mspc->gamma_0    = GAMMA_0_DCS1800;
  mspc->band_ind   = CGRLC_DCS_1800;
} /* grr_get_ms_pwr_cap_dcs1800 */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_ms_pwr_cap_pcs1900
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_get_ms_pwr_cap_pcs1900 ( UBYTE         rf_pow_cap,
                                         UBYTE         pow_offset,
                                         T_MS_PWR_CAP *mspc        )
{ 
  TRACE_FUNCTION( "grr_get_ms_pwr_cap_pcs1900" );

  mspc->p          = p_pcs;
  mspc->p_control  = p_control_pcs;
  mspc->ms_power   = rf_pow_cap - 1;
  mspc->pwr_offset = ( ( rf_pow_cap EQ POWER_CLASS_3 ) ? 2 * pow_offset : 0 );
  mspc->pwr_max    = p_control_pcs[MAX_PCL_PCS1900];
  mspc->pwr_min    = p_control_pcs[MIN_PCL_PCS1900];
  mspc->gamma_0    = GAMMA_0_PCS1900;
  mspc->band_ind   = CGRLC_PCS_1900;
} /* grr_get_ms_pwr_cap_pcs1900 */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_power_class
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE grr_get_power_class ( UBYTE index )
{
  T_rf_cap *rf_cap      = rr_csf_get_rf_capability( );
  UBYTE     power_class;

  TRACE_FUNCTION( "grr_get_power_class" );

  if( rf_cap NEQ NULL )
  {
    power_class = rf_cap->rf_power.pow_class4[index].pow_class;
  }
  else
  {
    power_class = POWER_CLASS_1;

    TRACE_ERROR( "grr_get_power_class: RF capabilities invalid" );
  }

  return( power_class );

} /* grr_get_power_class */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_pcl
+------------------------------------------------------------------------------
| Description : This function is used to convert the nominal output power to 
|               the power control level
|
| Parameters  : p_ctrl - pointer to table of power control levels
|               nop    - nominal output power
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE grr_get_pcl ( UBYTE const *p_ctrl,
                           SHORT        nop )
{ 
  UBYTE pcl = 0; /* power control level */

  TRACE_FUNCTION( "grr_get_pcl" ); 

  /* get power control level */
  while( nop < (SHORT)p_ctrl[pcl] - 1 OR nop >= (SHORT)p_ctrl[pcl] + 1 ) pcl++;

  return( pcl );

} /* grr_get_pcl() */

/*
+------------------------------------------------------------------------------
| Function    : grr_validate_ma_num_in_freq_par
+------------------------------------------------------------------------------
| Description : Validates MA_NUM in indirect encoding.
|               This validation is required only when
|               freq parameters are received with indirect
|               encoding.
|               Change mark received with Frequency parameters is compared
|               with the stored change mark for PSI2/PSI13/SI13 to determine
|               if the mobile allocation stored in these messages could be used.
|
|               Frequency parameters received in an assignment message could refer
|               to GPRS mobile allocation received in a previous assignment message
|               by using MA_NUM = 15 in indirect encoding. Frequency parameters
|               received in non-assignment message( For example PSI 8 or PSI 14)
|               cannot refer to GPRS mobile received in a previous message.
|               This validation is done using the second parameter.
|
|               This function should be used before using the GPRS mobile allocation
|               referred in freq_par.
| Parameters  : freq_par - points to the frequency parameter structure
|               received in system information/some assignment message.
|
|               msg_type - identifies the type of message in which freq par
|                          was received. Two values are possible.
|                          GRR_FREQ_PARAM_RECEIVED_IN_ASSIGNMENT 0
|                          GRR_FREQ_PARAM_RECEIVED_IN_NON_ASSIGNMENT 1
| Return value : True - if validation sucessful.
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_validate_ma_num_in_freq_par(const T_freq_par *freq_par,UBYTE msg_type)
{
  BOOL result;

  TRACE_FUNCTION("grr_validate_ma_num_in_freq_par");

  if(MA_NUMBER_4_ASSIGNMENT EQ freq_par->indi_encod.ma_num)
    {
      if(GRR_FREQ_PARAM_RECEIVED_IN_ASSIGNMENT NEQ msg_type )
        {
          TRACE_ERROR("Frequency parameter in a non assignment message");
          TRACE_ERROR("cannot have ma_num==MA_NUMBER_4_ASSIGNMENT");
          result = FALSE;
        }
      else if( (MA_NUMBER_4_ASSIGNMENT EQ psc_db->gprs_ms_alloc_in_assignment.ma_num) AND
               (!freq_par->indi_encod.v_chamge_ma_sub)                )
      {
        result = TRUE;
      }
      else
      {
        TRACE_ERROR("mobile allocation in assignment wrong");
        result = FALSE;
      }
    }
    else if(MA_NUMBER_4_PSI13_OR_CELL_ALLOC EQ freq_par->indi_encod.ma_num)
    {
      if( ( (freq_par->indi_encod.v_chamge_ma_sub      ) AND
            (freq_par->indi_encod.chamge_ma_sub.cm1 EQ
             psc_db->psi13_params.si13_change_mark                 )
          ) OR
          ( (freq_par->indi_encod.chamge_ma_sub.v_cm2  ) AND
            (freq_par->indi_encod.chamge_ma_sub.cm2 EQ
             psc_db->psi13_params.si13_change_mark                 )
          ) OR
          (
            !freq_par->indi_encod.v_chamge_ma_sub     AND
            !freq_par->indi_encod.chamge_ma_sub.v_cm2
          ))
      {
        result = TRUE;
      }
      else
      {
        TRACE_ERROR("wrong si13 change mark value");
        result = FALSE;
      }
    }
    else
    {
      if( ( (freq_par->indi_encod.v_chamge_ma_sub      ) AND
            (freq_par->indi_encod.chamge_ma_sub.cm1 EQ
             psc_db->psi2_params.psi2_change_mark                  )
          ) OR
          ( (freq_par->indi_encod.chamge_ma_sub.v_cm2  ) AND
            (freq_par->indi_encod.chamge_ma_sub.cm2 EQ
             psc_db->psi2_params.psi2_change_mark                  )
          ) OR
          (
            !freq_par->indi_encod.v_chamge_ma_sub     AND
            !freq_par->indi_encod.chamge_ma_sub.v_cm2
          ))
      {
        result = TRUE;
      }
      else
      {
        TRACE_ERROR("wrong psi2 change mark value");
        TRACE_EVENT_P5("psi2cm:%d vcm1:%d cm1:%d vcm2:%d cm2:%d",
          psc_db->psi2_params.psi2_change_mark,
          freq_par->indi_encod.v_chamge_ma_sub,
          freq_par->indi_encod.chamge_ma_sub.cm1,
          freq_par->indi_encod.chamge_ma_sub.v_cm2,
          freq_par->indi_encod.chamge_ma_sub.cm2);
        result = FALSE;
      }
    }
    return result;
} /* grr_validate_ma_num_in_freq_par */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_gprs_ma
+------------------------------------------------------------------------------
| Description : ma_num identifies the GPRS mobile allocation received
|               in PSI 2, PSI 13 or the previous assignment message.
|               This function returns the matching pointer to the
|               GPRS Mobile allocation IE.
|
| Parameters  : ma_num - 0 to 13 - gprs mobile allocation received in PSI 2
|                             14 gprs mobile allocation received in Si13/PSI13
|                             15 GPRS mobile allocation received in previous
|                                assignment message.
| Return value : Pointer to appropriate GPRS MA stored in psc db.
+------------------------------------------------------------------------------
*/
GLOBAL T_gprs_ms_alloc_ie* grr_get_gprs_ma(UBYTE ma_num)
{
  USHORT n = 0;
  T_gprs_ms_alloc_ie *gp_ma = NULL;
  TRACE_FUNCTION( "grr_get_gprs_ma" );
  if(ma_num > MA_NUMBER_4_ASSIGNMENT)
  {
    TRACE_ERROR("ma_num > MA_NUMBER_4_ASSIGNMENT");
    return NULL;
  }

  /*
   * Get the GPRS Mobile Allocation IE corresponding to the ma_num
   */
  switch(ma_num)
  {
    /* MA_NUMBER used to reference a MA received in a previous assignent */
    case MA_NUMBER_4_ASSIGNMENT:
      if( psc_db->gprs_ms_alloc_in_assignment.ma_num NEQ NOT_SET )
      {
        gp_ma = &psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie;
      }
      break;

    /* MA_NUMBER used to reference a Mobile Allocation
     * (MA) received in PSI13, which may referenced from
     * an assignment message or which referes to the cell
     * allocation defined for the cell in SI1 or PSI2
     */
    case MA_NUMBER_4_PSI13_OR_CELL_ALLOC:

      /*lint -fallthrough*/

    /* GPRS Mobile Allocations received in PSI2 and/or PSI13 values 0...13 */
    default:
      for(n = 0; n < MAX_GPRS_MS_ALLOC; n++)
      {
        if( psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num EQ ma_num)
        {
          gp_ma = &psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie;
          break;
        }
      }
      break;
  }
   return gp_ma;
} /* grr_get_gprs_ma */

/*
+------------------------------------------------------------------------------
| Function    : grr_cnv_freq_para_in_assignment_direct_enc_2
+------------------------------------------------------------------------------
| Description : This function decodes the frequency parametes received
|               in direct encoding2 form. It constructs the Mobile allocation
|               list as required by TI L1 MPHP primitives.
|
| Parameters  :
|
| NOTE: THIS FUNCTION USES THE LOCAL TEMPORARY ARRAYS - _local_rfl_contents AND
|      _local_dummy_list. These are use by grr_cnv_freq_para_in_psi8_direct_enc_2()
|       also. These two functions are placed in the same object module to avoid
|       the need for two copies of temporary arrays.
+------------------------------------------------------------------------------
*/

GLOBAL BOOL grr_cnv_freq_para_in_assignment_direct_enc_2
             (T_p_frequency_par *frequency_par,T_freq_par *freq_par)
{
   TRACE_FUNCTION("grr_cnv_freq_para_in_assignment_direct_enc_2");
   /* decode and store rfl list */
    /* clean RFL content  */
    memset (&_local_rfl_contents, 0, sizeof(T_f_range));
    /* Length in bits */
    _local_rfl_contents.l_f = (freq_par->di_encod2.len_ma_list+3)*8;
    /* Copy RFL content bits into the structure */
    memcpy(_local_rfl_contents.b_f, freq_par->di_encod2.ma_list,
      freq_par->di_encod2.len_ma_list+3);

    /*
     * Use a function from RR
     * This function copies the frequencies into list. This function takes the arranging
     * of ARFCN into account cf. 12.10a GPRS Mobile Allocation in 04.60
     */
    for_create_channel_list (&_local_rfl_contents, &_local_dummy_list);

    memcpy(psc_db->rfl[MAX_RFL].list, _local_dummy_list.b_f,
      sizeof(psc_db->rfl[MAX_RFL].list));

/*    grr_create_channel_list(freq_par->di_encod2.ma_list, psc_db->rfl[MAX_RFL].list);*/

    psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie.hsn =
                                                      freq_par->di_encod2.hsn;
    psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie.v_rfl_num_list = TRUE;
    psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie.c_rfl_num_list = 1;
    psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie.v_ma_struct = FALSE;
    psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie.v_arfcn_index_list = FALSE;

    /* set up gprs_ms_alloc_in_assignment struct in database */
    psc_db->gprs_ms_alloc_in_assignment.ma_num = MA_NUMBER_4_ASSIGNMENT;
    psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie.rfl_num_list[0].rfl_num =
    psc_db->rfl[MAX_RFL].num                   = RFL_NUMBER_4_DIRECT_ENCODING_2;

    return(grr_create_freq_list(  psc_db->gprs_ms_alloc_in_assignment.ma_num,
                                  freq_par->di_encod2.maio,
                                  &frequency_par->p_chan_sel,
                                  &frequency_par->p_freq_list ));
}/* grr_cnv_freq_para_in_assignment_direct_enc_2 */

#ifdef REL99

/*
+------------------------------------------------------------------------------
| Function    : grr_cnv_freq_para_in_psi8_direct_enc_2
+------------------------------------------------------------------------------
| Description : This function decodes the Frequency parameters in direct encoding 2
|               The output of this function is in form which could be used by
|               MPH_* primitives in RR. This The mobile allocation list
|               generated by this function is different from the ones used by
|               MPHP_* primitives.
|               CBCH parameters are passed to RR and RR passes to ALR and ALR
|               converts these frequencies to TI L1 form and passes in MPHC_*
|               primitive to L1.
|               The caller of this function should make sure that the type of
|               encoding used in freq_par is of direct encoding 2.
| Parameters  : cbch_req - output.
|               freq_par - input
| NOTE: THIS FUNCTION USES THE LOCAL TEMPORARY ARRAYS - _local_rfl_contents AND
|       _local_dummy_list. These are use by grr_cnv_freq_para_in_assignment_direct_enc_2()
|       also.These two functions are placed in the same object module to avoid
|       the need for two copies of temporary arrays.
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_cnv_freq_para_in_psi8_direct_enc_2(T_cbch *cbch_req,const T_freq_par *freq_par)
{
    USHORT count = 0;
    TRACE_FUNCTION( "grr_cnv_freq_para_in_psi8_direct_enc_2");
    /* decode and store rfl list */
    /* clean RFL content  */
    memset (&_local_rfl_contents, 0, sizeof(T_f_range));
    /* Length in bits */
    _local_rfl_contents.l_f = (freq_par->di_encod2.len_ma_list+3)*8;
    /* Copy RFL content bits into the structure */
    memcpy(_local_rfl_contents.b_f, freq_par->di_encod2.ma_list,
      freq_par->di_encod2.len_ma_list+3);

    /*
     * Use a function from RR
     * This function copies the frequencies into list. This function takes the arranging
     * of ARFCN into account cf. 12.10a GPRS Mobile Allocation in 04.60
     */
    for_create_channel_list (&_local_rfl_contents, &_local_dummy_list);

    /* Local dummy list represents the mobile allocation.
     * This list need not be filtered with grr_ma_filter_list
     * as ALL arfcns in this list are part of mobile allocation.
     * But we need to validate this list.
     */
    srv_create_list(&_local_dummy_list,cbch_req->ma, 64 , TRUE ,0);

    if(!grr_validate_and_count_frequencies(cbch_req->ma,&count))
    {
      TRACE_ERROR( "grr_cnv_freq_para_in_psi8_direct_enc_2:validation failed/freq count zero" );
      return FALSE;
    }
    cbch_req->ma[count] = NOT_PRESENT_16BIT;
    cbch_req->maio = freq_par->di_encod2.maio;
    cbch_req->hsn = freq_par->di_encod2.hsn ;
    return TRUE;
}/* grr_cnv_freq_para_in_psi8_direct_enc_2 */
#endif

/*
+------------------------------------------------------------------------------
| Function    : grr_validate_and_count_frequencies
+------------------------------------------------------------------------------
| Description : This function ensures that all the frequencies in the list
|               are of same band. It returns the cout of frequencies in the list.
|               NOT_PRESENT_16BIT represents the end of list.
| Parameters  : Array representing the frequency list
|               ptr_cnt - output, returns the count.
| Return value :TRUE/FALSE
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_validate_and_count_frequencies(USHORT radio_freq_list[MPHP_NUMC_MA],USHORT* ptr_cnt)
{
  USHORT n = 0;
  TRACE_FUNCTION("grr_validate_and_count_frequencies");
  switch( std )
    {
      case STD_900: /* frequencies must between 1 and 124 */

       for(n=0, *ptr_cnt=0; n < 64; n++)
       {
         if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
           break;

         if(( radio_freq_list[n] >= LOW_CHANNEL_900 ) AND
            ( radio_freq_list[n] <= HIGH_CHANNEL_900))
         {
            (*ptr_cnt)++;
         }
         else
         {
           TRACE_EVENT_P1( "STD_900:Frequency %d not in the band!", radio_freq_list[n]);
           return FALSE;
         }
       }

        break;

      case STD_EGSM:

       for(n=0, *ptr_cnt=0; n < 64; n++)
       {
         if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
           break;

         if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR
           ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND
            (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1)))
         {
           (*ptr_cnt)++;
         }
         else
         {
           TRACE_EVENT_P1( "STD_EGSM: Frequency %d not in the band!", radio_freq_list[n]);
           return FALSE;
         }
       }
        break;

      case STD_1900:

       for(n=0, *ptr_cnt=0; n < 64; n++)
       {
         if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
           break;

         if(( radio_freq_list[n] >= LOW_CHANNEL_1900 ) AND
            ( radio_freq_list[n] <= HIGH_CHANNEL_1900))
         {
            (*ptr_cnt)++;
         }
         else
         {
           TRACE_EVENT_P1( "STD_1900: Frequency %d not in the band!", radio_freq_list[n]);
           return FALSE;
         }
       }
        break;

      case STD_1800:

       for(n=0, *ptr_cnt=0; n < 64; n++)
       {
         if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
           break;

         if(( radio_freq_list[n] >= LOW_CHANNEL_1800 ) AND
           (  radio_freq_list[n] <= HIGH_CHANNEL_1800))
         {
           (*ptr_cnt)++;
         }
         else
         {
           TRACE_EVENT_P1( "STD_1800: Frequency %d not in the band!", radio_freq_list[n]);
           return FALSE;
         }
       }
       break;

      case STD_850:
       for(n=0, *ptr_cnt=0; n < 64; n++)
       {
         if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
           break;

         if(( radio_freq_list[n] >= LOW_CHANNEL_850 ) AND
            ( radio_freq_list[n] <= HIGH_CHANNEL_850))
         {
           (*ptr_cnt)++;
         }
         else
         {
           TRACE_EVENT_P1( "STD_850: Frequency %d not in the band!", radio_freq_list[n]);
           return FALSE;
         }
       }
       break;

      case STD_DUAL:

        if (( radio_freq_list[0] >= LOW_CHANNEL_900 ) AND
           (radio_freq_list[0] <= HIGH_CHANNEL_900))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if(( radio_freq_list[n] >= LOW_CHANNEL_900 ) AND
            (radio_freq_list[n] <= HIGH_CHANNEL_900))
            {
              *(ptr_cnt)+=1;
            }
            else
            {
              TRACE_EVENT_P1( "STD_DUAL: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
        if (( radio_freq_list[0] >= LOW_CHANNEL_1800 ) AND
           (radio_freq_list[0] <= HIGH_CHANNEL_1800))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if(( radio_freq_list[n] >= LOW_CHANNEL_1800 ) AND
               (radio_freq_list[n] <= HIGH_CHANNEL_1800))
            {
              *(ptr_cnt)+=1;
            }
            else
            {
              TRACE_EVENT_P1( "STD_DUAL: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
        {
              TRACE_EVENT_P1( "STD_DUAL: Frequency %d not in the band!", radio_freq_list[0]);
              return FALSE;
        }
        break;

      case STD_DUAL_EGSM:

         if((radio_freq_list[0] <= HIGH_CHANNEL_900) OR
           ((radio_freq_list[0] >= LOW_CHANNEL_EGSM) AND
           (radio_freq_list[0] <= HIGH_CHANNEL_EGSM - 1)))
         {
           for(n=0, *(ptr_cnt)=0; n < 64; n++)
           {
             if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
             break;

             if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR
             ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND
             (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1)))
             {
               *(ptr_cnt)+=1;
             }
             else
             {
               TRACE_EVENT_P1( "STD_DUAL_EGSM: Frequency %d not in the band!", radio_freq_list[n]);
               return FALSE;
             }
           }
         }
         else
         if (( radio_freq_list[0] >= LOW_CHANNEL_1800 ) AND
           (radio_freq_list[0] <= HIGH_CHANNEL_1800))
         {
           for(n=0, *(ptr_cnt)=0; n < 64; n++)
           {
             if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
             break;

             if(( radio_freq_list[n] >= LOW_CHANNEL_1800 ) AND
             (radio_freq_list[n] <= HIGH_CHANNEL_1800))
             {
               *(ptr_cnt)+=1;
             }
             else
             {
              TRACE_EVENT_P1( "STD_DUAL_EGSM: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
             }
           }
         }
         else
         {
             TRACE_EVENT_P1( "STD_DUAL_EGSM: Frequency %d not in the band!", radio_freq_list[0]);
             return FALSE;
         }
         break;

      case STD_DUAL_US:
        if (( radio_freq_list[0] >= LOW_CHANNEL_850 ) AND
           (radio_freq_list[0] <= HIGH_CHANNEL_850))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if(( radio_freq_list[n] >= LOW_CHANNEL_850 ) AND
            (radio_freq_list[n] <= HIGH_CHANNEL_850))
            {
              *(ptr_cnt)+=1;
            }
            else
            {
              TRACE_EVENT_P1( "STD_DUAL_US: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
        if (( radio_freq_list[0] >= LOW_CHANNEL_1900 ) AND
           (radio_freq_list[0] <= HIGH_CHANNEL_1900))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if(( radio_freq_list[n] >= LOW_CHANNEL_1900 ) AND
               ( radio_freq_list[n] <= HIGH_CHANNEL_1900))
            {
              (*ptr_cnt)++;
            }
            else
            {
              TRACE_EVENT_P1( "STD_DUAL_US: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
        {
              TRACE_EVENT_P1( "STD_DUAL_US: Frequency %d not in the band!", radio_freq_list[0]);
              return FALSE;
        }
        break;

#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
      case STD_850_1800:
        if (( radio_freq_list[0] >= LOW_CHANNEL_850 ) AND
            ( radio_freq_list[0] <= HIGH_CHANNEL_850))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if(( radio_freq_list[n] >= LOW_CHANNEL_850 ) AND
               ( radio_freq_list[n] <= HIGH_CHANNEL_850))
            {
              *(ptr_cnt)+=1;
            }
            else
            {
              TRACE_EVENT_P1( "STD_850_1800: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
        if (( radio_freq_list[0] >= LOW_CHANNEL_1800 ) AND
            ( radio_freq_list[0] <= HIGH_CHANNEL_1800))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if(( radio_freq_list[n] >= LOW_CHANNEL_1800 ) AND
               ( radio_freq_list[n] <= HIGH_CHANNEL_1800))
            {
              (*ptr_cnt)++;
            }
            else
            {
              TRACE_EVENT_P1( "STD_850_1800: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
        {
          TRACE_EVENT_P1( "STD_850_1800: Frequency %d not in the band!", radio_freq_list[0]);
          return FALSE;
        }
        break;

      case STD_900_1900:
         if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR
           ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND
            (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1)))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR
              ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND
               (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1)))
            {
              *(ptr_cnt)+=1;
            }
            else
            {
              TRACE_EVENT_P1( "STD_900_1900: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
        if (( radio_freq_list[0] >= LOW_CHANNEL_1900 ) AND
            ( radio_freq_list[0] <= HIGH_CHANNEL_1900))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if(( radio_freq_list[n] >= LOW_CHANNEL_1900 ) AND
               ( radio_freq_list[n] <= HIGH_CHANNEL_1900))
            {
              (*ptr_cnt)++;
            }
            else
            {
              TRACE_EVENT_P1( "STD_900_1900: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
        {
              TRACE_EVENT_P1( "STD_900_1900: Frequency %d not in the band!", radio_freq_list[0]);
              return FALSE;
        }
        break;
        
      case STD_850_900_1800:
        if (( radio_freq_list[0] >= LOW_CHANNEL_850 ) AND
            ( radio_freq_list[0] <= HIGH_CHANNEL_850))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if(( radio_freq_list[n] >= LOW_CHANNEL_850 ) AND
               ( radio_freq_list[n] <= HIGH_CHANNEL_850))
            {
              *(ptr_cnt)+=1;
            }
            else
            {
              TRACE_EVENT_P1( "STD_850_900_1800: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
         if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR
           ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND
            (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1)))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR
              ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND
               (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1)))
            {
              (*ptr_cnt)++;
            }
            else
            {
              TRACE_EVENT_P1( "STD_850_900_1800: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
        if (( radio_freq_list[0] >= LOW_CHANNEL_1800 ) AND
            ( radio_freq_list[0] <= HIGH_CHANNEL_1800))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if(( radio_freq_list[n] >= LOW_CHANNEL_1800 ) AND
               ( radio_freq_list[n] <= HIGH_CHANNEL_1800))
            {
              (*ptr_cnt)++;
            }
            else
            {
              TRACE_EVENT_P1( "STD_850_900_1800: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
        {
              TRACE_EVENT_P1( "STD_850_900_1800: Frequency %d not in the band!", radio_freq_list[0]);
              return FALSE;
        }
        break;

      case STD_850_900_1900:
        if (( radio_freq_list[0] >= LOW_CHANNEL_850 ) AND
            ( radio_freq_list[0] <= HIGH_CHANNEL_850))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if(( radio_freq_list[n] >= LOW_CHANNEL_850 ) AND
               ( radio_freq_list[n] <= HIGH_CHANNEL_850))
            {
              *(ptr_cnt)+=1;
            }
            else
            {
              TRACE_EVENT_P1( "STD_850_900_1900: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
         if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR
           ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND
            (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1)))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR
              ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND
               (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1)))
            {
              (*ptr_cnt)++;
            }
            else
            {
              TRACE_EVENT_P1( "STD_850_900_1900: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
        if (( radio_freq_list[0] >= LOW_CHANNEL_1900 ) AND
            ( radio_freq_list[0] <= HIGH_CHANNEL_1900))
        {
          for(n=0, *(ptr_cnt)=0; n < 64; n++)
          {
            if(radio_freq_list[n] EQ NOT_PRESENT_16BIT)
            break;

            if(( radio_freq_list[n] >= LOW_CHANNEL_1900 ) AND
               ( radio_freq_list[n] <= HIGH_CHANNEL_1900))
            {
              (*ptr_cnt)++;
            }
            else
            {
              TRACE_EVENT_P1( "STD_850_900_1900: Frequency %d not in the band!", radio_freq_list[n]);
              return FALSE;
            }
          }
        }
        else
        {
              TRACE_EVENT_P1( "STD_850_900_1900: Frequency %d not in the band!", radio_freq_list[0]);
              return FALSE;
        }
        break;
#endif

      default:
#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
        TRACE_ASSERT( std EQ STD_850       OR
                      std EQ STD_900       OR
                      std EQ STD_EGSM      OR
                      std EQ STD_1900      OR
                      std EQ STD_1800      OR
                      std EQ STD_DUAL      OR
                      std EQ STD_DUAL_EGSM OR
                      std EQ STD_DUAL_US   OR  
                      std EQ STD_850_1800  OR 
                      std EQ STD_900_1900  OR 
                      std EQ STD_850_900_1800 OR 
                      std EQ STD_850_900_1900 );
#else
        TRACE_ASSERT( std EQ STD_850       OR
                      std EQ STD_900       OR
                      std EQ STD_EGSM      OR
                      std EQ STD_1900      OR
                      std EQ STD_1800      OR
                      std EQ STD_DUAL      OR
                      std EQ STD_DUAL_EGSM OR
                      std EQ STD_DUAL_US      );
#endif
        break;
    }

  memset(&radio_freq_list[n], 0, (128-2*n)); /*lint !e669*/
  /*set values back to zero, neeeded by windows test cases*/

  *(ptr_cnt) = MINIMUM( MPHP_NUMC_MA, *ptr_cnt );

  if( *ptr_cnt EQ 0 )
  {
    TRACE_ERROR( "grr_validate_and_count_frequencies: freq count EQ 0" );

    return FALSE;
  }
  return TRUE;
}/* grr_validate_and_count_frequencies */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_ref_list_or_cell_allocation
+------------------------------------------------------------------------------
| Description : Determining the frequency list to be used for a hopping channel
|               involvs following steps.
|               1. Determining the referenced set of reference frequency lists
|                  or cell allocation.( See 3GPP 04.60 12.10a)
|               2. Filtering this list based on MA_BITMAP and ARFCN index list.
|
|               This function performs the first step. ie it generates
|               the referenced set of referncelists or Cell allocation list
|               depending on the presence of RFL number list in
|               the GPRS Mobile allocation IE.
| Parameters  : list1 - output, This is list will hold the referenced set of
|               reference freq list or Cell allocation depending on the
|               contents of gp_ma passed.
|               gp_ma - pointer to gprs mobile allocation IE
|               ma_num - identifies the MA_NUM in freq parameters IE.
|                        3GPP 04.60 Sec 5.5.1.7
|
| Return value : TRUE/FALSE
+------------------------------------------------------------------------------
*/
GLOBAL BOOL grr_get_ref_list_or_cell_allocation(T_LIST *list1,const T_gprs_ms_alloc_ie *gp_ma,UBYTE ma_num)
{
  BOOL                pbcch_is_present = grr_is_pbcch_present( );
  /*
   * Check RFL number list. If NOT exists, use cell allocation (CA)
   */
  TRACE_FUNCTION(" grr_get_ref_list_or_cell_allocation ");
  if(!gp_ma->v_rfl_num_list)
  {
    /*
     * Use CA defined in PSI2 or in SI1 depending on the table below
     *
     *  Case | PBCCH   | PSI2     | RFL_NUMBERs | Action
     *       | present | complete | all found   |
     *  -----+---------+----------+-------------+-----------
     *
     * 0 <= MA_NUMBER <= 15
     *
     *  -----+---------+----------+-------------+-----------
     *    A  |    y    |    y     |      y      | Use CA PSI
     *  -----+---------+----------+-------------+-----------
     *    B  |    y    |    y     |      n      | Use CA SI
     *  -----+---------+----------+-------------+-----------
     *    C  |    y    |    n     |      x      | Use CA SI
     *  -----+---------+----------+-------------+-----------
     *    D  |    n    |    x     |      x      | Use CA SI
     *  -----+---------+----------+-------------+-----------
     *
     * y = yes, n = no, x = don't case
     *
     */
    if( pbcch_is_present                 EQ TRUE       AND
        psc_db->state_of_PSI[PSI2].state EQ RECEIPT_OK AND
        psc_db->v_cell_alloc             EQ TRUE           )
    {
      /*
       * Use CA in PSI2. RFLs define a CA.
       * If needed, we have to merge frequencies defined in different RFL's into one list
       */

      /* Implementation of case A and B */

      if( grr_get_psi_cell_alloc_list( list1 ) EQ FALSE )
      {
        /* Implementation of case B */

        TRACE_ERROR( "grr_create_freq_list: grr_get_psi_cell_alloc_list( ) EQ FALSE in case B" );

        grr_get_si_cell_alloc_list( list1 );
      }
    }
    else
    {
      /* Implementation of case C and D */

      if( pbcch_is_present EQ TRUE )
      {
        TRACE_EVENT( "grr_create_freq_list: PSI2 not OK in case C and D" );
      }

      grr_get_si_cell_alloc_list( list1 );
    }
  }
  else
  {
    /*
     * Use MA depending on the table below
     *
     * Case | PBCCH   | PSI2     | RFL_NUMBERs | 0 <= RFL_NUMBER <= 15 | RFL_NUMBER == 16 | Action
     *      | present | complete | all found   |                       |                  |
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *
     * 0 <= MA_NUMBER <= 13
     *
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   E  |    y    |    y     |      y      |           x           |         x        | Use list
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   F  |    y    |    y     |      n      |           x           |         x        | Reject list
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   G  |    y    |    n     |      x      |           x           |         x        | Reject list
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   H  |    n    |    x     |      x      |           x           |         x        | Reject list
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *
     * MA_NUMBER == 14
     *
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   I  |    y    |    y     |      y      |           x           |         x        | Use list
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   J  |    y    |    y     |      n      |           x           |         x        | Use CA PSI
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   K  |    y    |    n     |      x      |           x           |         x        | Use CA SI
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   L  |    n    |    x     |      x      |           x           |         x        | Use CA SI
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *
     * MA_NUMBER == 15
     *
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   M  |    y    |    y     |      y      |           x           |         x        | Use list
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   N  |    y    |    y     |      n      |           x           |         x        | Reject list
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   O  |    y    |    n     |      x      |           y           |         n        | Reject list
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   P  |    y    |    n     |      x      |           n           |         y        | Use list
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   Q  |    n    |    x     |      x      |           y           |         n        | Reject list
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *   R  |    n    |    x     |      x      |           n           |         y        | Use list
     * -----+---------+----------+-------------+-----------------------+------------------+------------
     *
     * y = yes, n = no, x = don't case
     *
     */

    /*
     * Use the defined RFL in GPRS MA
     * If needed, we have to merge frequencies defined in different RFL's into one list
     */
    if( ma_num EQ MA_NUMBER_4_ASSIGNMENT )
    {
      if( pbcch_is_present                 EQ TRUE       AND
          psc_db->state_of_PSI[PSI2].state EQ RECEIPT_OK     )
      {
        /* Implementation of case M and N */

        if( grr_get_ms_alloc_list( list1, gp_ma ) EQ FALSE )
        {
          /* Implementation of case N */

          TRACE_ERROR( "grr_create_freq_list: grr_get_ms_alloc_list( ) EQ FALSE in case N" );

          return FALSE;
        }
      }
      else
      {
        if( gp_ma->c_rfl_num_list          EQ 1                              AND
            gp_ma->rfl_num_list[0].rfl_num EQ RFL_NUMBER_4_DIRECT_ENCODING_2     )
        {
          /* Implementation of case P and R */

          if( grr_get_ms_alloc_list( list1, gp_ma ) EQ FALSE )
          {
            TRACE_ERROR( "grr_create_freq_list: grr_get_ms_alloc_list( ) EQ FALSE in case P and R" );

            return FALSE;
          }
        }
        else
        {
          /* Implementation of case O and Q */

          if( pbcch_is_present EQ TRUE )
          {
            TRACE_ERROR( "grr_create_freq_list: PSI2 not OK in case O and Q" );
          }
          else
          {
            TRACE_ERROR( "grr_create_freq_list: no PBCCH present and error in case O and Q" );
          }

          return FALSE;
        }
      }
    }
    else if( ma_num EQ MA_NUMBER_4_PSI13_OR_CELL_ALLOC )
    {
      if( pbcch_is_present                 EQ TRUE       AND
          psc_db->state_of_PSI[PSI2].state EQ RECEIPT_OK     )
      {
        /* Implementation of case I and J */

        if( grr_get_ms_alloc_list( list1, gp_ma ) EQ FALSE )
        {
          /* Implementation of case J */

          TRACE_ERROR( "grr_create_freq_list: grr_get_ms_alloc_list( ) EQ FALSE in case J" );

          if( grr_get_psi_cell_alloc_list( list1 ) EQ FALSE )
          {
            TRACE_ERROR( "grr_create_freq_list: grr_get_psi_cell_alloc_list( ) EQ FALSE in case J" );

            grr_get_si_cell_alloc_list( list1 );
          }
        }
      }
      else
      {
        /* Implementation of case K and L */

        if( pbcch_is_present EQ TRUE )
        {
          TRACE_ERROR( "grr_create_freq_list: PSI2 not OK in case K and L" );
        }

        grr_get_si_cell_alloc_list( list1 );
      }
    }
    else
    {
      if( pbcch_is_present                 EQ TRUE       AND
          psc_db->state_of_PSI[PSI2].state EQ RECEIPT_OK     )
      {
        /* Implementation of case E and F */

        if( grr_get_ms_alloc_list( list1, gp_ma ) EQ FALSE )
        {
          /* Implementation of case F */

          TRACE_ERROR( "grr_create_freq_list: grr_get_ms_alloc_list( ) EQ FALSE in case F" );

          return FALSE;
        }
      }
      else
      {
        /* Implementation of case G and H */

        if( pbcch_is_present EQ TRUE )
        {
          TRACE_ERROR( "grr_create_freq_list: PSI2 not OK in case G and H" );
        }

        return FALSE;
      }
    }
  }
  return TRUE;
}/* grr_get_ref_list_or_cell_allocation  */

#ifdef REL99
/*
+------------------------------------------------------------------------------
| Function    : grr_get_time_to_send_poll
+------------------------------------------------------------------------------
| Description : This function retrun the duration in milliseconds to transmit a 
|               poll.The basic for the calucation is based on RRBP obtained in 
|               the downlink message. The calculation is mentioned in the function.
| Parameters  : rrbp
|
+------------------------------------------------------------------------------
*/
GLOBAL T_TIME grr_get_time_to_send_poll(UBYTE rrbp)
{
   /*
   * This calculation is based on the following calculation
   * t_ms = (Number of frame to transmit Poll)*(Frame Duration in millseconds)
   * Number of frame to transmit Poll:- are 13,18,22,26 for rrbp 0,1,2,3 respectively
   * Frame Duration in millseconds:-is 4.615millseconds
   * eg . t_ms[0] = 13*4.615 =60,
   */
   T_TIME t_ms[] = {60, 83,102,120};
   return (t_ms[rrbp]);
}

#ifdef TI_PS_FF_EMR

/*
+------------------------------------------------------------------------------
| Function    : grr_init_enh_param
+------------------------------------------------------------------------------
| Description : This function is used to initialize ENH parameters
|
| Parameters  : param - pointer to ENH measurement parameter
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_init_enh_param( T_GRR_ENH_PARA *param, BOOL rep_prio_pres )
{ 
  TRACE_FUNCTION( "grr_init_enh_param" );
  
  param->idx        = NOT_SET;
  param->rept_type  = REPORT_TYPE_REP;
  if(rep_prio_pres)
  {
    param->gprs_rept_prio_desc.num_cells = 0;
  }
  
}/* grr_init_enh_param */

/*
+------------------------------------------------------------------------------
| Function    : grr_init_enh_cell_list
+------------------------------------------------------------------------------
| Description : This function is used to initialize ENH cell list
|
| Parameters  : Nil
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_init_enh_cell_list( void )
{ 
  TRACE_FUNCTION( "grr_init_enh_cell_list" );

  grr_data->db.cnt_enh_cell_list = 0;

  grr_data->db.sorted_enh_cell_list.num_valid = 0;

}/* grr_init_enh_cell_list */

/*
+------------------------------------------------------------------------------
| Function    : grr_prcs_enh_param_cw_temp
+------------------------------------------------------------------------------
| Description : This function is used to copy the enhanced parameters received 
|               in PSI5. Here it is copied into a temporary storage until all
|               the instances are properly received.
|
| Parameters  : db_enh  - ENH measurement parameter in the GRR database
|               air_enh - ENH measurement parameter of the air interface
|                         message
|               new_idx - sequence number of the message
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_prcs_enh_param_cw_temp ( T_GRR_ENH_PARA  *db_enh,
                                         T_enh_rep_param_struct *air_enh,
                                         UBYTE  new_idx )
{ 
  UBYTE n;
  
  TRACE_FUNCTION( "grr_prcs_enh_param_cw_temp" );

  if(db_enh->idx EQ NOT_SET)
  {
    /* Store default values for optional enhanced measurement paramaters */
    db_enh->ncc_permitted = NCC_PERMITTED_DEFAULT;
    db_enh->multiband_rep = GRR_MULTIBAND_REPORTING_0;
    db_enh->servingband_rep = SERVING_BAND_REPORTING_DEFAULT;
    db_enh->scale_order = SCALE_0dB;
    for(n = 0; n < MAX_NUM_BANDS; n++)
    {
      db_enh->enh_rep_data[n].rep_threshold = REP_THRESHOLD_DEF;
      db_enh->enh_rep_data[n].rep_offset = REP_OFFSET_0;
    }
  }    
  
  /* Update Enhanced Measurement parameters */
  db_enh->rept_type = air_enh->reporting_type;
  db_enh->rep_rate = air_enh->reporting_rate;
  db_enh->inv_bsic_enabled = air_enh->invalid_bsic_rep;
  
  if( (air_enh->v_ncc_permitted) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
  {
    db_enh->ncc_permitted = air_enh->ncc_permitted;
  }

  /* Update GPRS measurement parameters */
  if(air_enh->v_gprs_meas_par_report)
  {
    if( (air_enh->gprs_meas_par_report.v_multi_band_rep) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->multiband_rep = air_enh->gprs_meas_par_report.multi_band_rep;
    }

    if( (air_enh->gprs_meas_par_report.v_serv_cell_rep) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->servingband_rep = 
      air_enh->gprs_meas_par_report.serv_cell_rep;
    }

    if( (air_enh->gprs_meas_par_report.v_scale_ord) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->scale_order = 
      air_enh->gprs_meas_par_report.scale_ord;
    }

    if( (air_enh->gprs_meas_par_report.v_report_900_grr) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->enh_rep_data[0].rep_threshold = 
      air_enh->gprs_meas_par_report.report_900_grr.rep_thres_900;
      db_enh->enh_rep_data[0].rep_offset = 
      air_enh->gprs_meas_par_report.report_900_grr.rep_offset_900;
    }

    if( (air_enh->gprs_meas_par_report.v_report_1800_grr) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->enh_rep_data[1].rep_threshold = 
      air_enh->gprs_meas_par_report.report_1800_grr.rep_thres_1800;
      db_enh->enh_rep_data[1].rep_offset = 
      air_enh->gprs_meas_par_report.report_1800_grr.rep_offset_1800;
    }

    if( (air_enh->gprs_meas_par_report.v_report_400_grr) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->enh_rep_data[2].rep_threshold = 
      air_enh->gprs_meas_par_report.report_400_grr.rep_thres_400;
      db_enh->enh_rep_data[2].rep_offset = 
      air_enh->gprs_meas_par_report.report_400_grr.rep_offset_400;
    }

    if( (air_enh->gprs_meas_par_report.v_report_1900_grr) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->enh_rep_data[3].rep_threshold = 
      air_enh->gprs_meas_par_report.report_1900_grr.rep_thres_1900;
      db_enh->enh_rep_data[3].rep_offset = 
      air_enh->gprs_meas_par_report.report_1900_grr.rep_offset_1900;
    }

    if( (air_enh->gprs_meas_par_report.v_report_850_grr) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->enh_rep_data[4].rep_threshold = 
      air_enh->gprs_meas_par_report.report_850_grr.rep_thres_850;
      db_enh->enh_rep_data[4].rep_offset = 
      air_enh->gprs_meas_par_report.report_850_grr.rep_offset_850;
    }
  }    

  db_enh->idx = new_idx;
}/* grr_prcs_enh_param_cw_temp */

/*
+------------------------------------------------------------------------------
| Function    : grr_prcs_enh_param_pmo
+------------------------------------------------------------------------------
| Description : This function is used to copy temporarily the enhanced 
|               measurement parameters from PMO.
|
| Parameters  : db_enh  - ENH measurement parameter in the GRR database
|               air_enh - ENH measurement parameter of the air interface
|                         message
|               new_idx - sequence number of the message
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_prcs_enh_param_pmo ( T_GRR_ENH_PARA  *db_enh,
                                     T_enh_meas_param_pmo  *air_enh,  
                                     UBYTE  new_idx, UBYTE *pmo_ind )
{
  UBYTE n;
  UBYTE num_cells = db_enh->gprs_rept_prio_desc.num_cells;
  UBYTE number_cells = air_enh->gprs_rep_prio_cell_desc.number_cells;

  TRACE_FUNCTION( "grr_prcs_enh_param_pmo" );

  if(db_enh->idx EQ NOT_SET)
  {
    /* Store default values for optional enhanced measurement paramaters */
    db_enh->ncc_permitted = NCC_PERMITTED_DEFAULT;
    db_enh->multiband_rep = GRR_MULTIBAND_REPORTING_0;
    db_enh->servingband_rep = SERVING_BAND_REPORTING_DEFAULT;
    db_enh->scale_order = SCALE_0dB;
    for(n = 0; n < MAX_NUM_BANDS; n++)
    {
      db_enh->enh_rep_data[n].rep_threshold = REP_THRESHOLD_DEF;
      db_enh->enh_rep_data[n].rep_offset = REP_OFFSET_0;
    }
    for(n = 0; n < MAX_NR_OF_GSM_NC; n++)
    {
      db_enh->gprs_rept_prio_desc.rept_prio[n] = NORMAL_PRIO;
    }
  }    
  
  /* Update Enhanced Measurement parameters */
  
  *pmo_ind = air_enh->ba_psi3_str.pmo_ind_used;
  db_enh->rept_type = air_enh->reporting_type;
  db_enh->rep_rate = air_enh->reporting_rate;
  db_enh->inv_bsic_enabled = air_enh->invalid_bsic_rep;

  /* GPRS Report priority can be received in only one instance since start 
    index is not given for mapping to BA as in RTD and BSIC mapping in SI */
  if((air_enh->v_gprs_rep_prio_cell_desc) AND (number_cells NEQ 0))
  {
    if(number_cells > MAX_NR_OF_GSM_NC)
    {
      num_cells = MAX_NR_OF_GSM_NC;
    }
    else
    {
      num_cells = number_cells;
    }

    for(n = 0; n < num_cells; n++)
    {
      db_enh->gprs_rept_prio_desc.rept_prio[n] = 
        air_enh->gprs_rep_prio_cell_desc.rep_prio[n];
    }
  }

  /* Update GPRS measurement parameters */
  if(air_enh->v_gprs_meas_par_desc_meas)
  {
    if( (air_enh->gprs_meas_par_desc_meas.v_multi_band_rep) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->multiband_rep = 
        air_enh->gprs_meas_par_desc_meas.multi_band_rep;
    }

    if( (air_enh->gprs_meas_par_desc_meas.v_serv_cell_rep) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->servingband_rep = 
      air_enh->gprs_meas_par_desc_meas.serv_cell_rep;
    }

    db_enh->scale_order = air_enh->gprs_meas_par_desc_meas.scale_ord;

    if( (air_enh->gprs_meas_par_desc_meas.v_report_900_grr) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->enh_rep_data[0].rep_threshold = 
      air_enh->gprs_meas_par_desc_meas.report_900_grr.rep_thres_900;
      db_enh->enh_rep_data[0].rep_offset = 
      air_enh->gprs_meas_par_desc_meas.report_900_grr.rep_offset_900;
    }

    if( (air_enh->gprs_meas_par_desc_meas.v_report_1800_grr) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->enh_rep_data[1].rep_threshold = 
      air_enh->gprs_meas_par_desc_meas.report_1800_grr.rep_thres_1800;
      db_enh->enh_rep_data[1].rep_offset =
      air_enh->gprs_meas_par_desc_meas.report_1800_grr.rep_offset_1800;
    }

    if( (air_enh->gprs_meas_par_desc_meas.v_report_400_grr) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->enh_rep_data[2].rep_threshold = 
      air_enh->gprs_meas_par_desc_meas.report_400_grr.rep_thres_400;
      db_enh->enh_rep_data[2].rep_offset =
      air_enh->gprs_meas_par_desc_meas.report_400_grr.rep_offset_400;
    }

    if( (air_enh->gprs_meas_par_desc_meas.v_report_1900_grr) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->enh_rep_data[3].rep_threshold = 
      air_enh->gprs_meas_par_desc_meas.report_1900_grr.rep_thres_1900;
      db_enh->enh_rep_data[3].rep_offset =
      air_enh->gprs_meas_par_desc_meas.report_1900_grr.rep_offset_1900;
    }

    if( (air_enh->gprs_meas_par_desc_meas.v_report_850_grr) AND
      ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) )
    {
      db_enh->enh_rep_data[4].rep_threshold = 
      air_enh->gprs_meas_par_desc_meas.report_850_grr.rep_thres_850;
      db_enh->enh_rep_data[4].rep_offset =
      air_enh->gprs_meas_par_desc_meas.report_850_grr.rep_offset_850;
    }
  }
  
  db_enh->idx = new_idx;
}/* grr_prcs_enh_param_pmo */

/*
+------------------------------------------------------------------------------
| Function    : grr_prcs_enh_param_pcco
+------------------------------------------------------------------------------
| Description : This function is used to copy the enhanced measurement 
|               parameters from PCCO.
|
| Parameters  : db      - Network directed cell database
|               air_enh - ENH measurement parameter of the air interface
|                         message
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_prcs_enh_param_pcco ( T_SC_DATABASE  *db,
                                      T_enh_meas_param_pcco *air_enh )
{
  UBYTE n;
  T_GRR_ENH_PARA *db_enh = &db->enh_ms;
  UBYTE max_num_ncells = db_enh->gprs_rept_prio_desc.num_cells;

  TRACE_FUNCTION( "grr_prcs_enh_param_pcco" );

  if(db_enh->idx EQ NOT_SET)
  {
    /* Store default values for optional enhanced measurement paramaters */
    db_enh->ncc_permitted = NCC_PERMITTED_DEFAULT;
    db_enh->multiband_rep = GRR_MULTIBAND_REPORTING_0;
    db_enh->servingband_rep = SERVING_BAND_REPORTING_DEFAULT;
    db_enh->scale_order = SCALE_0dB;
    for(n = 0; n < MAX_NUM_BANDS; n++)
    {
      db_enh->enh_rep_data[n].rep_threshold = REP_THRESHOLD_DEF;
      db_enh->enh_rep_data[n].rep_offset = REP_OFFSET_0;
    }
  }    
  
  /* Update Enhanced Measurement parameters */

  db->nc_ms.psi3_cm = air_enh->ba_psi3_str.psi3_cm;
  db->nc_ms.ba_ind  = air_enh->ba_psi3_str.ba_ind_used;  
  db->nc_ms.pmo_ind = air_enh->ba_psi3_str.pmo_ind_used;
  db_enh->rept_type = air_enh->reporting_type;
  db_enh->rep_rate = air_enh->reporting_rate;
  db_enh->inv_bsic_enabled = air_enh->invalid_bsic_rep;

  if((air_enh->v_gprs_rep_prio_cell_desc) AND 
  (air_enh->gprs_rep_prio_cell_desc.number_cells NEQ 0))
  {

    if(air_enh->gprs_rep_prio_cell_desc.number_cells > MAX_NR_OF_NCELL)
    {
      max_num_ncells = MAX_NR_OF_NCELL;
    }
    else
    {
      max_num_ncells = air_enh->gprs_rep_prio_cell_desc.number_cells;
    }
    
    for(n = 0; n < max_num_ncells; n++)
    {
      db_enh->gprs_rept_prio_desc.rept_prio[n] = 
      air_enh->gprs_rep_prio_cell_desc.rep_prio[n];
    }
    
  }
  /* Update GPRS measurement parameters */
  if(air_enh->v_gprs_meas_par_desc_meas)
  {
    if(air_enh->gprs_meas_par_desc_meas.v_multi_band_rep)
    {
      db_enh->multiband_rep = 
        air_enh->gprs_meas_par_desc_meas.multi_band_rep;
    }

    if(air_enh->gprs_meas_par_desc_meas.v_serv_cell_rep)
    {
      db_enh->servingband_rep = 
      air_enh->gprs_meas_par_desc_meas.serv_cell_rep;
    }

    db_enh->scale_order = air_enh->gprs_meas_par_desc_meas.scale_ord;

    if(air_enh->gprs_meas_par_desc_meas.v_report_900_grr)
    {
      db_enh->enh_rep_data[0].rep_threshold = 
      air_enh->gprs_meas_par_desc_meas.report_900_grr.rep_thres_900;
      db_enh->enh_rep_data[0].rep_offset = 
      air_enh->gprs_meas_par_desc_meas.report_900_grr.rep_offset_900;
    }

    if(air_enh->gprs_meas_par_desc_meas.v_report_1800_grr)
    {
      db_enh->enh_rep_data[1].rep_threshold = 
      air_enh->gprs_meas_par_desc_meas.report_1800_grr.rep_thres_1800;
      db_enh->enh_rep_data[1].rep_offset =
      air_enh->gprs_meas_par_desc_meas.report_1800_grr.rep_offset_1800;
    }

    if(air_enh->gprs_meas_par_desc_meas.v_report_400_grr)
    {
      db_enh->enh_rep_data[2].rep_threshold = 
      air_enh->gprs_meas_par_desc_meas.report_400_grr.rep_thres_400;
      db_enh->enh_rep_data[2].rep_offset =
      air_enh->gprs_meas_par_desc_meas.report_400_grr.rep_offset_400;
    }

    if(air_enh->gprs_meas_par_desc_meas.v_report_1900_grr)
    {
      db_enh->enh_rep_data[3].rep_threshold = 
      air_enh->gprs_meas_par_desc_meas.report_1900_grr.rep_thres_1900;
      db_enh->enh_rep_data[3].rep_offset =
      air_enh->gprs_meas_par_desc_meas.report_1900_grr.rep_offset_1900;
    }

    if(air_enh->gprs_meas_par_desc_meas.v_report_850_grr)
    {
      db_enh->enh_rep_data[4].rep_threshold = 
      air_enh->gprs_meas_par_desc_meas.report_850_grr.rep_thres_850;
      db_enh->enh_rep_data[4].rep_offset =
      air_enh->gprs_meas_par_desc_meas.report_850_grr.rep_offset_850;
    }
  }    

  db_enh->idx = 0;
}/* grr_prcs_enh_param_pcco */

/*
+------------------------------------------------------------------------------
| Function    : grr_copy_enh_and_nc_params_from_si2qtr
+------------------------------------------------------------------------------
| Description : This function is meant to copy the ENH and NC parameters that
|               are received by SI2 quater, when PBCCH is not present
|
| Parameters  : Pointer to RRGRR_SI2QUATER_IND message contents
|                
+------------------------------------------------------------------------------
*/
GLOBAL void grr_copy_enh_and_nc_params_from_si2qtr(T_RRGRR_SI2QUATER_IND 
                                                   *rrgrr_si2quater_ind)
{
  UBYTE n;
  T_enh_para_struct *enh_para_struct = 
    &(rrgrr_si2quater_ind->enh_para_struct);

  T_nc_para_struct *nc_para_struct = &(rrgrr_si2quater_ind->nc_para_struct);
  
  TRACE_FUNCTION( "grr_copy_enh_nc_params" );
  
  /* Copy Enhanced Measurement parameters only if report type indicates ENH */
  if(rrgrr_si2quater_ind->rep_type EQ ENHANCED_MEAS)
  {
    /* Copy GSM Neighbour Cell list, if present. Otherwise, only ENH params have 
       changed. Use old NC list and new ENH params */
    for(n = 0; n < enh_para_struct->num_valid_cells; n++)
    {
      /* Do not include the serving cell in the GSM Neighbour Cell list */
      if ( (enh_para_struct->enh_cell_list[n].arfcn EQ psc_db->pbcch.bcch.arfcn)
            AND 
           (enh_para_struct->enh_cell_list[n].bsic EQ psc_db->pbcch.bcch.bsic) )
      {
        continue;
      }
      psc_db->nc_ba_bcch_cw.info[n].index = n;
      psc_db->nc_ba_bcch_cw.info[n].arfcn = 
        enh_para_struct->enh_cell_list[n].arfcn;
      psc_db->nc_ba_bcch_cw.info[n].bsic = 
        enh_para_struct->enh_cell_list[n].bsic;
      psc_db->enh_cw.gprs_rept_prio_desc.rept_prio[n] =
        enh_para_struct->enh_cell_list[n].rep_priority;
    }

     psc_db->nc_ba_bcch_cw.number = n;
    
    /* Copy Enhanced Measurement parameters */
    psc_db->enh_cw.rept_type = rrgrr_si2quater_ind->rep_type;
    psc_db->enh_cw.rep_rate = enh_para_struct->rep_rate;
    psc_db->enh_cw.inv_bsic_enabled = enh_para_struct->inv_bsic_enabled;
    psc_db->enh_cw.ncc_permitted = enh_para_struct->ncc_permitted;
    psc_db->enh_cw.multiband_rep = enh_para_struct->multiband_rep;
    psc_db->enh_cw.servingband_rep = enh_para_struct->servingband_rep;
    psc_db->enh_cw.scale_order = enh_para_struct->scale_order;
    for(n = 0; n < MAX_NUM_BANDS; n++)
    {
      psc_db->enh_cw.enh_rep_data[n].rep_offset = 
        enh_para_struct->enh_rep_data[n].rep_offset;
      psc_db->enh_cw.enh_rep_data[n].rep_threshold = 
        enh_para_struct->enh_rep_data[n].rep_threshold;
    }
  }
  
  /* Copy NC Measurement parameters if received by SI2 quater */
  if(nc_para_struct->nco NEQ NC_EMPTY)
  {
    T_nc_meas_par nc_meas_par;
    
    nc_meas_par.ctrl_order = nc_para_struct->nco;
    nc_meas_par.v_nc_meas_per = nc_para_struct->is_valid;
    if(nc_meas_par.v_nc_meas_per)
    {
      nc_meas_par.nc_meas_per.non_drx_per = nc_para_struct->nc_non_drx;
      nc_meas_par.nc_meas_per.rep_per_i = nc_para_struct->nc_rep_per_i;
      nc_meas_par.nc_meas_per.rep_per_t = nc_para_struct->nc_rep_per_t;
    }
    
    grr_prcs_nc_param_struct ( &psc_db->nc_cw.param, &nc_meas_par, 0 );
  }

  cs_build_nc_ref_list( psc_db, FALSE );
  
  if( 
    psc_db->nc_cw.param.chng_mrk.prev        NEQ
    psc_db->nc_cw.param.chng_mrk.curr
    )
  {
    if( cs_is_meas_reporting( ) EQ FALSE )
    {
      cs_cancel_meas_report( );
    }
    
    cs_process_t3158( );
    
    psc_db->nc_cw.param.chng_mrk.prev = psc_db->nc_cw.param.chng_mrk.curr;
  }
} /* grr_copy_enh_and_nc_params_from_si2qtr */

/*
+------------------------------------------------------------------------------
| Function    : grr_get_psi3_cm
+------------------------------------------------------------------------------
| Description : This function returns the value of PSI3 change mark. The PSI3
|               change mark is received on PSI3, PSI3 bis and on optional 
|               PSI3 ter message
|
| Parameters  : Nil
|                
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE grr_get_psi3_cm(void)
{
  UBYTE psi3_cm = NOT_SET;

  TRACE_FUNCTION("grr_get_psi3_cm");

  if(psc_db->psi3_params.psi3_change_mark EQ
     psc_db->psi3bis_params.psi3bis_change_mark) 
  {
    psi3_cm = psc_db->psi3_params.psi3_change_mark;
    
    if(psc_db->psi3ter_params.psi3ter_change_mark NEQ NOT_SET AND
      psc_db->psi3ter_params.psi3ter_change_mark NEQ psi3_cm)
    {
      psi3_cm = NOT_SET;
    }
  }
  return(psi3_cm);
} /* grr_get_psi3_cm */


/*
+------------------------------------------------------------------------------
| Function    : grr_init_ba_bcch_nc_list
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : list  - pointer to NC measurement list
|
+------------------------------------------------------------------------------
*/
GLOBAL void grr_init_ba_bcch_nc_list(T_SC_DATABASE *db)
{ 
  TRACE_FUNCTION( "grr_init_ba_bcch_nc_list" );
  
  db->nc_ba_bcch_cw.number = 0;
  db->ba_ind = 0; /* BA-IND of BA-BCCH */
}/* grr_init_ba_bcch_nc_list */

#endif 

#endif