/* 
+----------------------------------------------------------------------------- 
|  Project :  GPRS (8441)
|  Modul   :  GRR
+----------------------------------------------------------------------------- 
|  Copyright 2002 Texas Instruments Berlin, AG 
|                 All rights reserved. 
| 
|                 This file is confidential and a trade secret of Texas 
|                 Instruments Berlin, AG 
|                 The receipt of or possession of this file does not convey 
|                 any rights to reproduce or disclose its contents or to 
|                 manufacture, use, or sell anything it may describe, in 
|                 whole, or in part, without the specific written consent of 
|                 Texas Instruments Berlin, AG. 
+----------------------------------------------------------------------------- 
|  Purpose :  This module implements local functions for service TC of
|             entity GRR.
+----------------------------------------------------------------------------- 
*/ 

#ifndef GRR_TCF_C
#define GRR_TCF_C
#endif

#define ENTITY_GRR

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

#include <stdio.h>
#include <string.h>

#include "typedefs.h"   /* to get Condat data types */
#include "vsi.h"        /* to get a lot of macros */
#include "macdef.h"
#include "gprs.h"
#include "gsm.h"        /* to get a lot of macros */
#include "ccdapi.h"     /* to get CCD API */
#include "cnf_grr.h"    /* to get cnf-definitions */
#include "mon_grr.h"    /* to get mon-definitions */
#include "prim.h"       /* to get the definitions of used SAP and directions */
#include "message.h"    /* to get air message definitions */
#include "grr.h"        /* to get the global entity definitions */

#include "grr_f.h"      /* to get Process GRR global function definitions */
#include "grr_tcf.h"    /* to get Service TC global function definitions  */
#include "grr_tcs.h"    /* to get Service TC inter signal definitions  */
#include "grr_ctrls.h"  /* to get interface to service CTRL */
#include "grr_cpaps.h"  /* to get interface to service CPAP */
#include "grr_meass.h"  /* to get the definitions for interference measurements */
#include "cl_rlcmac.h"

/*==== CONST ================================================================*/

typedef enum
{
  GRR_STORE_TYPE_NONE,
  GRR_STORE_TYPE_TN_ALLOC_PWR,
  GRR_STORE_TYPE_ALF_GAM,
  GRR_STORE_TYPE_PWR_PAR
} T_GRR_STORE_TYPE;

/*
 * used in tc_calc_req
 *
 */
#define RANDOM_VALUE  0xAAAA

#define RANDOM_2BIT (RANDOM_VALUE & 0x0003)
#define RANDOM_3BIT (RANDOM_VALUE & 0x0007)
#define RANDOM_5BIT (RANDOM_VALUE & 0x001F)

#define ONE_PHASE_MASK_11BIT (0x0000 | RANDOM_3BIT )
#define SHORT_ACCESS_MASK_11BIT (0x0400 | RANDOM_3BIT )
#define TWO_PHASE_MASK_11BIT (0x0600 | RANDOM_3BIT )
#define PAGE_RESPONSE_MASK_11BIT (0x0620 | RANDOM_5BIT )
#define CELL_UPDATE_MASK_11BIT (0x0640 | RANDOM_5BIT )
#define MM_PROCEDURE_MASK_11BIT (0x0660 | RANDOM_5BIT )
#define SINGLE_BLOCK_MASK_11BIT (0x0680 | RANDOM_5BIT )

#define ONE_PHASE_MASK_8BIT (0x0080 | RANDOM_2BIT )
#define SHORT_ACCESS_MASK_8BIT (0x0000 | RANDOM_3BIT )
#define TWO_PHASE_MASK_8BIT (0x0040 | RANDOM_3BIT )
#define PAGE_RESPONSE_MASK_8BIT (0x0048 | RANDOM_3BIT )
#define CELL_UPDATE_MASK_8BIT (0x0050 | RANDOM_3BIT )
#define MM_PROCEDURE_MASK_8BIT (0x0058 | RANDOM_3BIT )
#define SINGLE_BLOCK_MASK_8BIT (0x0060 | RANDOM_3BIT )

/*
 * used in tc_handle_ra_con
 */
const UBYTE max_retrans_table[4] = {1,2,4,7};

const UBYTE tx_int_table[16] = {2,3,4,5,6,7,8,9,10,12,14,16,20,25,32,50};

const UBYTE s_table[16] = {12,15,20,30,41,55,76,109,163,217,
                           S_VALUE_RESERVED,S_VALUE_RESERVED,S_VALUE_RESERVED,
                           S_VALUE_RESERVED,S_VALUE_RESERVED,S_VALUE_RESERVED };



/*==== DIAGNOSTICS ==========================================================*/

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


/*==== PRIVATE FUNCTIONS ====================================================*/

LOCAL void tc_set_da_assignment (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i);
LOCAL void tc_set_fa_assignment (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i);
LOCAL void tc_set_dl_assignment (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i);

LOCAL void tc_close_gaps_in_ctrl_blk_seq( UBYTE index );

LOCAL void tc_prepare_send_tbf_release_req( T_TBF_TYPE tbf_type );

LOCAL BOOL tc_check_and_save_freq (void);

LOCAL USHORT grr_convert_11bit_2_etsi ( USHORT eleven_bit );

LOCAL USHORT tc_one_phase_mask_11bit (void)
{
#ifdef _TARGET_
    return (0x0000 | (USHORT)grr_random_value(PCR_RND_INDEX, 8));
#else
    return ONE_PHASE_MASK_11BIT;
#endif
}

LOCAL SHORT tc_short_access_mask_11bit (void)
{
#ifdef _TARGET_
  return (0x0400 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) );
#else
  return SHORT_ACCESS_MASK_11BIT;
#endif
}

LOCAL SHORT tc_two_phase_mask_11bit  (void)
{
#ifdef _TARGET_
  return (0x0600 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) );
#else
  return TWO_PHASE_MASK_11BIT;
#endif
}

LOCAL SHORT tc_page_response_mask_11bit  (void)
{
#ifdef _TARGET_
  return (0x0620 | (USHORT)grr_random_value(PCR_RND_INDEX, 32) );
#else
  return PAGE_RESPONSE_MASK_11BIT;
#endif
}

LOCAL SHORT tc_cell_update_mask_11bit  (void)
{
#ifdef _TARGET_
  return (0x0640 | (USHORT)grr_random_value(PCR_RND_INDEX, 32) );
#else
  return CELL_UPDATE_MASK_11BIT;
#endif
}

LOCAL SHORT tc_mm_procedure_mask_11bit  (void)
{
#ifdef _TARGET_
  return (0x0660 |(USHORT)grr_random_value(PCR_RND_INDEX, 32) );
#else
  return MM_PROCEDURE_MASK_11BIT;
#endif
}

LOCAL SHORT tc_single_block_mask_11bit  (void)
{
#ifdef _TARGET_
  return (0x0680 | (USHORT)grr_random_value(PCR_RND_INDEX, 32) );
#else
  return SINGLE_BLOCK_MASK_11BIT;
#endif
}

LOCAL SHORT tc_one_phase_mask_8bit  (void)
{
#ifdef _TARGET_
  return (0x0080 | (USHORT)grr_random_value(PCR_RND_INDEX, 4) );
#else
  return ONE_PHASE_MASK_8BIT;
#endif
}

LOCAL SHORT tc_short_access_mask_8bit  (void)
{
#ifdef _TARGET_
  return (0x0000 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) );
#else
  return SHORT_ACCESS_MASK_8BIT;
#endif
}

LOCAL SHORT tc_two_phase_mask_8bit  (void)
{
#ifdef _TARGET_
  return (0x0040 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) );
#else
  return TWO_PHASE_MASK_8BIT;
#endif
}

LOCAL SHORT tc_page_response_mask_8bit  (void)
{
#ifdef _TARGET_
  return (0x0048 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) );
#else
  return PAGE_RESPONSE_MASK_8BIT;
#endif
}

LOCAL SHORT tc_cell_update_mask_8bit  (void)
{
#ifdef _TARGET_
  return (0x0050 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) );
#else
  return CELL_UPDATE_MASK_8BIT;
#endif
}

LOCAL SHORT tc_mm_procedure_mask_8bit  (void)
{
#ifdef _TARGET_
  return (0x0058 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) );
#else
  return MM_PROCEDURE_MASK_8BIT;
#endif
}
LOCAL SHORT tc_single_block_mask_8bit  (void)
{
#ifdef _TARGET_
  return (0x0060 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) );
#else
  return SINGLE_BLOCK_MASK_8BIT;
#endif
}

/*
+------------------------------------------------------------------------------
| Function    : tc_set_hopping_par
+------------------------------------------------------------------------------
| Description : This function handles the frequency parameters in a ul or dl
|               assignment or ts reconfigure.
|
| Parameters  : ptr2prim - pointer to the MPHP_ASSIGNMENT_REQ prim
|                          that has to be set up.
|               freq_par - pointer to the received frequency parameter struct.
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL tc_set_hopping_par ( T_freq_par *freq_par )
{
  BOOL              result = FALSE;
  T_p_frequency_par frequency_par;

  TRACE_FUNCTION( "tc_set_hopping_par" );

  memset( &frequency_par, 0, sizeof( frequency_par ) );

  if(freq_par->v_indi_encod)
  {    
    result = grr_validate_ma_num_in_freq_par(freq_par,GRR_FREQ_PARAM_RECEIVED_IN_ASSIGNMENT);

    if(result)
    {
      result = grr_create_freq_list(  freq_par->indi_encod.ma_num,
                                      freq_par->indi_encod.maio,
                                     &frequency_par.p_chan_sel,
                                     &frequency_par.p_freq_list );
    }
    else
    {
      TRACE_ERROR("error creating frequency list");
      result = FALSE;
    }

  } /* if(freq_par->v_indi_encod) */
  else if(freq_par->v_di_encod1)
  {
    memcpy(&psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie,
           &freq_par->di_encod1.gprs_ms_alloc_ie, sizeof(T_gprs_ms_alloc_ie));

    psc_db->gprs_ms_alloc_in_assignment.ma_num = MA_NUMBER_4_ASSIGNMENT;
    psc_db->rfl[MAX_RFL].num                   = NOT_SET;

    result = grr_create_freq_list(  psc_db->gprs_ms_alloc_in_assignment.ma_num,
                                    freq_par->di_encod1.maio,
                                   &frequency_par.p_chan_sel,
                                   &frequency_par.p_freq_list );
  } /* if(freq_par->v_di_encod1) */
  else if(freq_par->v_di_encod2)
  {
    /* 
     * processing of T_freq_par from assignment and non-assignment messages
     * when direct encoding 2 is used, should be done in same object module as 
     * this involvs use of static array variables which are local to the 
     * object module they are used in(_local_dummy_list and _local_rfl_contents.
     * Hence processing for both assignment and non-assignement messages is done
     * in grr_f.c. If they are put in different files, we will have to duplicate
     * the static arrays.
     */
    result = 
      grr_cnv_freq_para_in_assignment_direct_enc_2(&frequency_par,freq_par);

  } /* if(freq_par->v_di_encod2) */
  else
  {
    TRACE_ERROR("FATAL ERROR: no frequency params in ul assignment!");
  }

  if( result EQ TRUE )
  {
    grr_data->tc.freq_set.freq_par = frequency_par;
    grr_data->tc.freq_set.tsc      = freq_par->tsc;
  }

  grr_data->tc.v_freq_set = result;

  return ( result );
}/* tc_set_hopping_par */



/*
+------------------------------------------------------------------------------
| Function    : tc_get_send_nb_prim_and_set_freq
+------------------------------------------------------------------------------
| Description : This function allocates a primitve depending on the hopping status
|               and sets the frequency parameter of T_MPHP_SINGLE_BLOCK_REQ
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
LOCAL T_MPHP_SINGLE_BLOCK_REQ * tc_get_send_nb_prim_and_set_freq ( void )
{
  PALLOC( mphp_single_block_req, MPHP_SINGLE_BLOCK_REQ );

  TRACE_FUNCTION( "tc_get_send_nb_prim_and_set_freq" );

  memset( mphp_single_block_req, 0, sizeof( T_MPHP_SINGLE_BLOCK_REQ ) );

  mphp_single_block_req->tsc = grr_data->tc.freq_set.tsc;

  grr_set_freq_par( &mphp_single_block_req->p_frequency_par );

  return( mphp_single_block_req );
}/* tc_get_send_nb_prim_and_set_freq */

/*
+------------------------------------------------------------------------------
| Function    : tc_check_and_save_freq
+------------------------------------------------------------------------------
| Description : This function check if the freq_par is valid or not..
|               If it is hopping case, save the hoppinging freq. 
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL tc_check_and_save_freq (void)
{
  MCAST(d_dl_assign,D_DL_ASSIGN);  /* T_D_DL_ASSIGN T_D_UL_ASSIGN T_D_TS_RECONFIG */
  MCAST(d_ul_assign,D_UL_ASSIGN);
  MCAST(d_ts_reconfig,D_TS_RECONFIG);

  BOOL      result = FALSE;
  T_freq_par   *freq_par = NULL;
  BOOL      mode_check = FALSE;

  TRACE_FUNCTION( "tc_check_and_save_freq" );

  /*
   * store frequeny parameters, if present.
   * If not present, take from data base
   */
  switch(d_dl_assign->msg_type)
  {
  case D_DL_ASSIGN:  /* T_D_DL_ASSIGN  */
    if(d_dl_assign->pda_trnc_grp.v_freq_par)
    {  /* replace possibly earlier stored freq params */
      freq_par = &d_dl_assign->pda_trnc_grp.freq_par;
    }
    if((grr_data->tbf_type EQ CGRLC_TBF_MODE_UL) OR (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL) )
    {
      mode_check = TRUE;
    }
    break;
  case D_UL_ASSIGN:  /* T_D_UL_ASSIGN */
      if(d_ul_assign->v_freq_par)
      {  /* replace possibly earlier stored freq params */
        freq_par = &d_ul_assign->freq_par;
      }
      if((grr_data->tbf_type EQ CGRLC_TBF_MODE_DL) OR (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL))
      {
        mode_check = TRUE;
      }

    break;
  case D_TS_RECONFIG:  /* T_D_TS_RECONFIG */
      if(d_ts_reconfig->v_freq_par)
      {  /* replace possibly earlier stored freq params */
        freq_par = &d_ts_reconfig->freq_par;
      }
    break;
  case D_UL_ACK:  /* T_D_UL_ACK */
    break;
  default:
    TRACE_ERROR ( "Wrong message type in _decodedMsg" );
    break;

  }
    /*  If frequency parameter element present, assigns frequency parameters to the 
        uplink TBF. If this information element is not present the mobile station 
        shall use its previously assigned frequency parameters.*/

  if( freq_par )/* save the hopping frequency */
  {
    if(freq_par->v_arfcn) /*static*/
    {
      T_FREQ_SET temp_freq_set;
      temp_freq_set.freq_par.p_chan_sel.hopping      = FALSE;
      temp_freq_set.tsc   = freq_par->tsc;
      temp_freq_set.freq_par.p_chan_sel.p_rf_ch.arfcn = grr_g23_arfcn_to_l1(freq_par->arfcn);
      
      /* variable needed by hopping case must be reset.*/
      memset(&(temp_freq_set.freq_par.p_freq_list.p_rf_chan_no.p_radio_freq), 0, sizeof(temp_freq_set.freq_par.p_freq_list.p_rf_chan_no.p_radio_freq));
      temp_freq_set.freq_par.p_freq_list.p_rf_chan_cnt = 0;

      if ( mode_check EQ TRUE ) 
      {                              
        /* checking the params already exist or not */
        if ( ( grr_data->tc.freq_set.freq_par.p_chan_sel.hopping EQ FALSE)
			 AND (temp_freq_set.tsc EQ  grr_data->tc.freq_set.tsc) 
			 AND ( temp_freq_set.freq_par.p_chan_sel.p_rf_ch.arfcn EQ 
			 grr_data->tc.freq_set.freq_par.p_chan_sel.p_rf_ch.arfcn ) )
        {
          TRACE_EVENT ("Frequency parameters are same");
          result = TRUE;
        }
        else
        {
          TRACE_EVENT ("Frequency parameters are changed, So discard it");
          result = FALSE;
        }
      }
      else
      {				           
        /* If it is new entry, storing in the grr_data */
        result = TRUE;
        grr_data->tc.v_freq_set = TRUE;
        grr_data->tc.freq_set = temp_freq_set;
      }
    }
    else
    { /* hopping cases */
      result = tc_set_hopping_par( freq_par );
    }
  }
  else if ( grr_data->tc.v_freq_set )/* if it is a two phase assignment or there is already another TBF running*/
  {
    result          = TRUE;
  }
  else
  {
    result          = FALSE;
    TRACE_ERROR("FATAL ERROR: no freq params in assignment but needed!");
  }

  if(result EQ TRUE)
  {
    grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param = TRUE;
    grr_data->pwr_ctrl_valid_flags.v_freq_param          = TRUE;
  }

  return(result);

}/* tc_check_and_save_freq */




/*
+------------------------------------------------------------------------------
| Function    : tc_set_da_assignment
+------------------------------------------------------------------------------
| Description : This function sets some parameter of T_MPHP_ASSIGNMENT_REQ is
|               case of uplink dynamic allocation.
|
| Parameters  : ptr2prim_i -  ptr to MPHP_ASSIGNMENT_REQ
|
+------------------------------------------------------------------------------
*/
LOCAL void tc_set_da_assignment (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i)
{
  MCAST(d_ul_assign,D_UL_ASSIGN);/* T_D_UL_ASSIGN */
  MCAST(d_ts_reconfig,D_TS_RECONFIG);

  TRACE_FUNCTION( "tc_set_da_assignment" );

  if( d_ul_assign->msg_type EQ D_UL_ASSIGN_c)
  {

    /*
     * timing advance
     */
    grr_handle_ta ( d_ul_assign->pta.v_ta_value, 
          d_ul_assign->pta.ta_value,
          d_ul_assign->pta.v_ta_index_tn, 
          d_ul_assign->pta.ta_index_tn.ta_index,
          d_ul_assign->pta.ta_index_tn.ta_tn,
          0xFF,
          0,
          0,
          &ptr2prim_i->p_timing_advance);

    /* bts output power control */
    if(d_ul_assign->dyn_alloc_p.v_p0)
    {
      ptr2prim_i->p_dl_power.p0 = d_ul_assign->dyn_alloc_p.p0;
      ptr2prim_i->p_dl_power.pr_mode = d_ul_assign->dyn_alloc_p.pr_mode;
      /* dynamic allocation must use mode a */
      ptr2prim_i->p_dl_power.bts_pwr_ctl_mode = MODE_A;
    }
    else
    {
      ptr2prim_i->p_dl_power.p0 = 0xff; /* 0xff -> invalid value */
      /* -> pr_mode and bts_pwr_ctl_mode don't care */
    }

    /*
     * TBF starting time
     */
    if(d_ul_assign->dyn_alloc_p.v_tbf_s_time)
    {
      ptr2prim_i->p_tbf_start.tbf_start_present = 1;
      if(d_ul_assign->dyn_alloc_p.tbf_s_time.v_abs)
      {        
        ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ul_assign->dyn_alloc_p.tbf_s_time.abs);       
      }
      else if (d_ul_assign->dyn_alloc_p.tbf_s_time.v_rel)
      { 
        ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn,
                                                              d_ul_assign->dyn_alloc_p.tbf_s_time.rel);   
      }
      else
      {  /* this shall never happen */
        ptr2prim_i->p_tbf_start.fn = grr_data->dl_fn;   
        TRACE_ERROR("UL v_start_tbf but either rel nor abs tbf included");
      }
    }
    else if(grr_data->l1_del_tbf_start_fn NEQ GRR_INVALID_FN)
    {
      ptr2prim_i->p_tbf_start.tbf_start_present = 1; 
      ptr2prim_i->p_tbf_start.fn = grr_data->l1_del_tbf_start_fn;	  
    }
    else
    {
      ptr2prim_i->p_tbf_start.tbf_start_present = 0; 
    }

   /*
    * mac mode
    */
    if (d_ul_assign->dyn_alloc_p.xdyn_alloc)
    {
      ptr2prim_i->mac_mode = EDA;
    }
    else
    {
      ptr2prim_i->mac_mode = DA;
    }

   /*
    * uplink allocation structure
    */
    if(d_ul_assign->dyn_alloc_p.v_ul_tfi_assign)
    {
      ptr2prim_i->p_ul_alloc.ul_tfi = d_ul_assign->dyn_alloc_p.ul_tfi_assign;
    }
    else
    {
      ptr2prim_i->p_ul_alloc.ul_tfi = grr_data->uplink_tbf.tfi;
    }
    ptr2prim_i->p_ul_alloc.ts_mask = grr_data->uplink_tbf.ts_usage;


   /*
    *  dynamic allocation structure
    */
    ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_gran =
                                           d_ul_assign->dyn_alloc_p.usf_grant;

    if(d_ul_assign->dyn_alloc_p.v_tn_alloc EQ 1)
    {
      UBYTE i;
      for(i = 0;i < 8;i++)
      {
        if(d_ul_assign->dyn_alloc_p.tn_alloc[i].v_usf)
        {
          ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[i] =
                                     d_ul_assign->dyn_alloc_p.tn_alloc[i].usf;
        }
      }
    }
    else if (d_ul_assign->dyn_alloc_p.v_tn_alloc_pwr)
    {
      UBYTE i;

      for(i = 0;i < 8;i++)
      {
        if(d_ul_assign->dyn_alloc_p.tn_alloc_pwr.usf_array[i].v_usf_g)
        {
          ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[i] =
                 d_ul_assign->dyn_alloc_p.tn_alloc_pwr.usf_array[i].usf_g.usf;
        }
      }

      grr_store_type_tn_alloc_pwr( &d_ul_assign->dyn_alloc_p.tn_alloc_pwr );
    }
    else
    {
      ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[0] = 5;
      TRACE_EVENT("USF-Error: set (hardcoded) USF_TN0 = 0x05");
    }

  }
  else if ( d_ts_reconfig->msg_type EQ D_TS_RECONFIG_c)
  {
    /*
     * timing advance is handled in tc_set_dl_assignment
     */
  /*  grr_handle_ta ( d_ts_reconfig->gpta.v_ta_value, 
          d_ts_reconfig->gpta.ta_value,
          d_ts_reconfig->gpta.v_ul_ta_index, 
          d_ts_reconfig->gpta.ul_ta_index,
          d_ts_reconfig->gpta.ul_ta_tn,
          0,
          0,
          0,
          ptr2prim_i->p_timing_advance);

          */
    /* bts output power control */
    if(d_ts_reconfig->dyn_alloc_ts.v_p0)
    {
      ptr2prim_i->p_dl_power.p0 = d_ts_reconfig->dyn_alloc_ts.p0;
      ptr2prim_i->p_dl_power.pr_mode = d_ts_reconfig->dyn_alloc_ts.pr_mode;
      /* dynamic allocation must use mode a */
      ptr2prim_i->p_dl_power.bts_pwr_ctl_mode = MODE_A;
    }
    else
    {
      ptr2prim_i->p_dl_power.p0 = 0xff; /* 0xff -> invalid value */
      /* -> pr_mode and bts_pwr_ctl_mode don't care */
    }

    /*
     * TBF starting time
     */    
    if(d_ts_reconfig->dyn_alloc_ts.v_tbf_s_time)
    {
      ptr2prim_i->p_tbf_start.tbf_start_present= 1;
      if(d_ts_reconfig->dyn_alloc_ts.tbf_s_time.v_abs)
      {
        ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ts_reconfig->dyn_alloc_ts.tbf_s_time.abs);              
      }
      else if (d_ts_reconfig->dyn_alloc_ts.tbf_s_time.v_rel)
      {
        ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn,
                                                              d_ts_reconfig->dyn_alloc_ts.tbf_s_time.rel);        
      }
      else
      {  /* this shall never happen */
        ptr2prim_i->p_tbf_start.fn = grr_data->dl_fn%FN_MAX;  
        TRACE_ERROR("TS RECON UL v_start_tbf but either rel nor abs tbf included");
      }
    }
    else if(grr_data->l1_del_tbf_start_fn NEQ GRR_INVALID_FN)
    {
      ptr2prim_i->p_tbf_start.tbf_start_present = 1; 
      ptr2prim_i->p_tbf_start.fn = grr_data->l1_del_tbf_start_fn;	  
    }
    else
    {
      ptr2prim_i->p_tbf_start.tbf_start_present = 0; 
    }


   /*
    * mac mode
    */
    if (d_ts_reconfig->dyn_alloc_ts.xdyn_alloc)
    {
      ptr2prim_i->mac_mode = EDA;
    }
    else
    {
      ptr2prim_i->mac_mode = DA;
    }

   /*
    * uplink allocation structure
    */
    if(d_ts_reconfig->v_ul_tfi)
    {
      ptr2prim_i->p_ul_alloc.ul_tfi = d_ts_reconfig->ul_tfi;
    }
    else
    {
      ptr2prim_i->p_ul_alloc.ul_tfi = grr_data->uplink_tbf.tfi;
    }
    ptr2prim_i->p_ul_alloc.ts_mask = grr_data->uplink_tbf.ts_usage;


   /*
    *  dynamic allocation structure
    */
    ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_gran = d_ts_reconfig->dyn_alloc_ts.usf_grant;

    if(d_ts_reconfig->dyn_alloc_ts.v_tn_alloc EQ 1)
    {
      UBYTE i;
      for(i = 0;i < 8;i++)
      {
        if(d_ts_reconfig->dyn_alloc_ts.tn_alloc[i].v_usf)
        {
          ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[i] =
                                   d_ts_reconfig->dyn_alloc_ts.tn_alloc[i].usf;
        }
      }
    }
    else if (d_ts_reconfig->dyn_alloc_ts.v_tn_alloc_pwr)
    {
      UBYTE i;

      for(i = 0;i < 8;i++)
      {
        if(d_ts_reconfig->dyn_alloc_ts.tn_alloc_pwr.usf_array[i].v_usf_g)
        {
          ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[i] =
               d_ts_reconfig->dyn_alloc_ts.tn_alloc_pwr.usf_array[i].usf_g.usf;
        }
      }

      grr_store_type_tn_alloc_pwr( &d_ts_reconfig->dyn_alloc_ts.tn_alloc_pwr );
    }
    else
    {
      ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[0] = 5;
      TRACE_EVENT("USF-Error: set (hardcoded) USF_TN0 = 0x05");
    }
  }
  else
  {
    TRACE_ERROR ( "Wrong message type in _decodedCtrlMsg" );
  }

  if(ptr2prim_i->p_tbf_start.tbf_start_present)
    grr_data->uplink_tbf.tbf_start_fn = ptr2prim_i->p_tbf_start.fn;
  else
    grr_data->uplink_tbf.tbf_start_fn = CGRLC_STARTING_TIME_NOT_PRESENT;

  grr_data->uplink_tbf.st_tfi = ptr2prim_i->p_ul_alloc.ul_tfi;



  return;
}/*tc_set_da_assignment*/


/*
+------------------------------------------------------------------------------
| Function    : tc_calc_fa_bitmap
+------------------------------------------------------------------------------
| Description : This function calculates rhe allocation bitmap in
|               case of fixed allocation
|
| Parameters  : blks_or_blkps  - indicates if blocks(0) or block periods(1) is used
|               len            - len of the allocation bitmap
|               ptr2_alloc_map - ptr to the allocation bitmap array
|               ptr2_fix_alloc - ptr to the fixed allocation struct
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_calc_fa_bitmap (ULONG tbf_start,
                               UBYTE blks_or_blkps,
                               USHORT len,
                               UBYTE * ptr2_alloc_map,
                               T_p_fixed_alloc  * ptr2_fix_alloc)
{
  UBYTE i;
  UBYTE help;
  UBYTE tn[8];
  UBYTE x,y;
  UBYTE len_1;
  USHORT index;

  TRACE_FUNCTION( "tc_calc_fa_bitmap" );

/*
  TRACE_EVENT_P9("FA bitmap: start_fn=%ld, blk=%d  len=%ld  bitmap: %d %d %d %d %d %d",
                                  tbf_start,
                                  blks_or_blkps,
                                  len,
                                  ptr2_alloc_map[0],
                                  ptr2_alloc_map[1],
                                  ptr2_alloc_map[2],
                                  ptr2_alloc_map[3],
                                  ptr2_alloc_map[4],
                                  ptr2_alloc_map[5]);

  TRACE_EVENT_P9("%d %d %d %d %d %d %d %d %d",
                                  ptr2_alloc_map[6],
                                  ptr2_alloc_map[7],
                                  ptr2_alloc_map[8],
                                  ptr2_alloc_map[9],
                                  ptr2_alloc_map[10],
                                  ptr2_alloc_map[11],
                                  ptr2_alloc_map[12],
                                  ptr2_alloc_map[13],
                                  ptr2_alloc_map[14]);

  TRACE_EVENT_P9("%d %d %d %d %d %d %d %d %d",
                                  ptr2_alloc_map[15],
                                  ptr2_alloc_map[16],
                                  ptr2_alloc_map[17],
                                  ptr2_alloc_map[18],
                                  ptr2_alloc_map[19],
                                  ptr2_alloc_map[20],
                                  ptr2_alloc_map[21],
                                  ptr2_alloc_map[22],
                                  ptr2_alloc_map[23]);
  TRACE_EVENT_P9("%d %d %d %d %d %d %d %d %d",
                                  ptr2_alloc_map[24],
                                  ptr2_alloc_map[25],
                                  ptr2_alloc_map[26],
                                  ptr2_alloc_map[27],
                                  ptr2_alloc_map[28],
                                  ptr2_alloc_map[29],
                                  ptr2_alloc_map[30],
                                  ptr2_alloc_map[31],
                                  ptr2_alloc_map[32]);
*/
  memset( tn, 0, sizeof(tn) );

  if(blks_or_blkps)
  {
    /*
     * block periods are used
     */
    for(i=0;i<len;i++)
    {
      if(ptr2_alloc_map[i])
      {
        ptr2_fix_alloc->bitmap[i] = grr_data->uplink_tbf.ts_usage;
      }
      else
        ptr2_fix_alloc->bitmap[i] = 0;
    }
    ptr2_fix_alloc->size_bitmap = (UBYTE)len;
  }
  else
  {
    UBYTE L;
    /*
     * blocks are used
     */
    /*
     * determinate the timeslot positions
     */
    help = grr_data->uplink_tbf.ts_usage;
    index = 0;
    for(i=0;i<=7;i++)
    {
      if(help >= (0x80 >> i))
      {
        tn[index]=i;
        index++;
        help -= (0x80 >> i);
      }
    }
    memset(ptr2_fix_alloc->bitmap,0,sizeof(ptr2_fix_alloc->bitmap));
    L = len - 1;
    for(i=0;i<=L;i++)
    {
      if(ptr2_alloc_map[i])
      {
        x = i / grr_data->uplink_tbf.nts;
        y = i % grr_data->uplink_tbf.nts;
        ptr2_fix_alloc->bitmap[x] |= 0x80 >> tn[y];
      }
    }
    ptr2_fix_alloc->size_bitmap = (UBYTE)len / grr_data->uplink_tbf.nts;
  }
  /*
   * set fa_ctrl
   */


  grr_data->tc.fa_ctrl.fa_type = FA_BITMAP;


  grr_data->tc.fa_ctrl.current_alloc.alloc_start_fn = tbf_start;

  /* store end of fixed allocation */
  len_1 = ptr2_fix_alloc->size_bitmap - 1;
  grr_data->tc.fa_ctrl.current_alloc.alloc_end_fn =
    grr_decode_tbf_start_rel(grr_data->tc.fa_ctrl.current_alloc.alloc_start_fn,(USHORT)(len_1-1));

  memcpy( &grr_data->tc.fa_ctrl.current_alloc.alloc,
            ptr2_fix_alloc,
            sizeof(T_p_fixed_alloc));

 /* TRACE_EVENT_P9("L1 bitmap %d %d %d %d %d %d %d %d %d",
                                  ptr2_fix_alloc->bitmap[0],
                                  ptr2_fix_alloc->bitmap[1],
                                  ptr2_fix_alloc->bitmap[2],
                                  ptr2_fix_alloc->bitmap[3],
                                  ptr2_fix_alloc->bitmap[4],
                                  ptr2_fix_alloc->bitmap[5],
                                  ptr2_fix_alloc->bitmap[6],
                                  ptr2_fix_alloc->bitmap[7],
                                  ptr2_fix_alloc->bitmap[8]);

  TRACE_EVENT_P9("%d %d %d %d %d %d %d %d %d",
                                  ptr2_fix_alloc->bitmap[9],
                                  ptr2_fix_alloc->bitmap[10],
                                  ptr2_fix_alloc->bitmap[11],
                                  ptr2_fix_alloc->bitmap[12],
                                  ptr2_fix_alloc->bitmap[13],
                                  ptr2_fix_alloc->bitmap[14],
                                  ptr2_fix_alloc->bitmap[15],
                                  ptr2_fix_alloc->bitmap[16],
                                  ptr2_fix_alloc->bitmap[17]);
  TRACE_EVENT_P9("%d %d %d %d %d %d %d %d %d",
                                  ptr2_fix_alloc->bitmap[18],
                                  ptr2_fix_alloc->bitmap[19],
                                  ptr2_fix_alloc->bitmap[20],
                                  ptr2_fix_alloc->bitmap[21],
                                  ptr2_fix_alloc->bitmap[22],
                                  ptr2_fix_alloc->bitmap[23],
                                  ptr2_fix_alloc->bitmap[24],
                                  ptr2_fix_alloc->bitmap[25],
                                  ptr2_fix_alloc->bitmap[26]);
*/
} /* tc_calc_fa_bitmap() */

/*
+------------------------------------------------------------------------------
| Function    : tc_handle_final_alloc
+------------------------------------------------------------------------------
| Description : This function handles the final allocation bit.
|
| Parameters  :   -
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_handle_final_alloc (UBYTE final_allocation)
{

  TRACE_FUNCTION( "tc_handle_final_alloc" );



} /* tc_handle_final_alloc() */

/*
+------------------------------------------------------------------------------
| Function    : tc_set_fa_assignment
+------------------------------------------------------------------------------
| Description : This function sets some parameter of T_MPHP_ASSIGNMENT_REQ is
|               case of fixed allocation
|
| Parameters  : ptr2prim_i -  ptr to MPHP_ASSIGNMENT_REQ
|
+------------------------------------------------------------------------------
*/
LOCAL void tc_set_fa_assignment (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i)
{
/*  ULONG var; */
  MCAST(d_ul_assign,D_UL_ASSIGN);     /* T_D_UL_ASSIGN */
  MCAST(d_ts_reconfig,D_TS_RECONFIG); /* T_TS_RECONFIG */
  MCAST(d_ul_ack,D_UL_ACK);           /* T_D_UL_ACK */




  TRACE_FUNCTION( "tc_set_fa_assignment" );

#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
  if((d_ul_assign->msg_type EQ D_UL_ASSIGN_c) AND 
     (ptr2prim_i->assign_cmd EQ UL_TP_ACCESS))
  {
    /* training sequence code */
    ptr2prim_i->tsc = d_ul_assign->freq_par.tsc;

    /* handle timing advance */
    grr_handle_ta ( d_ul_assign->pta.v_ta_value, 
      d_ul_assign->pta.ta_value,
      d_ul_assign->pta.v_ta_index_tn, 
      d_ul_assign->pta.ta_index_tn.ta_index,
      d_ul_assign->pta.ta_index_tn.ta_tn,
      0xFF,
      0,
      0,
      &ptr2prim_i->p_timing_advance);

    /* Mac mode */	
    ptr2prim_i->mac_mode = FA;

    /* Handle single block allocation */
    if(d_ul_assign->v_sin_alloc EQ TRUE )
    {
      /* timeslot mask */
      ptr2prim_i->p_ul_alloc.ts_mask = 0x80>>d_ul_assign->sin_alloc.tn;

      /* PO, BTS_POWER_MODE and PR_ MODE */
      if(d_ul_assign->sin_alloc.v_bts_pwr_ctrl EQ TRUE  )
      {
        ptr2prim_i->p_dl_power.p0 = 
          d_ul_assign->sin_alloc.bts_pwr_ctrl.p0;

        ptr2prim_i->p_dl_power.bts_pwr_ctl_mode =
          d_ul_assign->sin_alloc.bts_pwr_ctrl.mode;

        ptr2prim_i->p_dl_power.pr_mode = 
          d_ul_assign->sin_alloc.bts_pwr_ctrl.pr_mode;
      }
      else
      {
        ptr2prim_i->p_dl_power.p0 = 0xff;
      }

      /* Downlink Control Timeslot */
      ptr2prim_i->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = d_ul_assign->sin_alloc.tn;

      /*
       * handle TBF starting time
       * is always present in single block allocation
       */
      if(d_ul_assign->sin_alloc.tbf_s_time.v_abs)
      {
        ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ul_assign->sin_alloc.tbf_s_time.abs);
        if(!grr_check_if_tbf_start_is_elapsed ( ptr2prim_i->p_tbf_start.fn, grr_data->ul_fn))
        {
          /*Allocated Number of time slots are 1 */
          ptr2prim_i->p_ul_alloc.p_fixed_alloc.size_bitmap = 1;
          ptr2prim_i->p_tbf_start.tbf_start_present=TRUE;
          ptr2prim_i->p_ul_alloc.p_fixed_alloc.bitmap[0] = 0x80 >> d_ul_assign->sin_alloc.tn;
        }
        else
        {
          TRACE_ERROR("TBF Starting time is ELAPSED in single block allocation!");
        }
      }
      else if (d_ul_assign->sin_alloc.tbf_s_time.v_rel)
      {
        ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn, 
                                                           (USHORT)(d_ul_assign->sin_alloc.tbf_s_time.rel));
        if(!grr_check_if_tbf_start_is_elapsed ( ptr2prim_i->p_tbf_start.fn, grr_data->ul_fn))
        {
          /*Allocated Number of time slots are 1 */
          ptr2prim_i->p_ul_alloc.p_fixed_alloc.size_bitmap = 1;
          ptr2prim_i->p_tbf_start.tbf_start_present=TRUE;
          ptr2prim_i->p_ul_alloc.p_fixed_alloc.bitmap[0] = 0x80 >> d_ul_assign->sin_alloc.tn;
        }
        else
        {
          TRACE_ERROR("TBF Starting time is ELAPSED in single block allocation!");
        }
      }
	}/* single block */
  }
  else
#endif
  if( d_ul_assign->msg_type EQ D_UL_ASSIGN_c)
  {
    /*
     * timing advance
     */

    grr_handle_ta ( d_ul_assign->pta.v_ta_value, 
          d_ul_assign->pta.ta_value,
          d_ul_assign->pta.v_ta_index_tn, 
          d_ul_assign->pta.ta_index_tn.ta_index,
          d_ul_assign->pta.ta_index_tn.ta_tn,
          0xFF,
          0,
          0,
          &ptr2prim_i->p_timing_advance);

    if(d_ul_assign->f_alloc_ul.v_bts_pwr_ctrl)
    {
      ptr2prim_i->p_dl_power.p0 = d_ul_assign->f_alloc_ul.bts_pwr_ctrl.p0;
      ptr2prim_i->p_dl_power.bts_pwr_ctl_mode =
                                    d_ul_assign->f_alloc_ul.bts_pwr_ctrl.mode;
      ptr2prim_i->p_dl_power.pr_mode =
                                 d_ul_assign->f_alloc_ul.bts_pwr_ctrl.pr_mode;
    }
    else
    {
      ptr2prim_i->p_dl_power.p0 = 0xff;
    }

    /*
     * mac mode
     */
    ptr2prim_i->mac_mode = FA;
    /*
     * uplink allocation structure
     */
    if(d_ul_assign->f_alloc_ul.v_ul_tfi_assign)
    {
      ptr2prim_i->p_ul_alloc.ul_tfi = d_ul_assign->f_alloc_ul.ul_tfi_assign;
    }
    else
    {
      ptr2prim_i->p_ul_alloc.ul_tfi = grr_data->uplink_tbf.tfi;
    }
    ptr2prim_i->p_ul_alloc.ts_mask = grr_data->uplink_tbf.ts_usage;
    /*
     *  fixed allocation structure
     *  half duplex mode is ignored, only valid for MS class 19 to 29
     */

    /*
     *  TBF STARTING TIME for fixed allocation structure
     */    
    if(d_ul_assign->f_alloc_ul.tbf_s_time.v_abs)
    {
      ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ul_assign->f_alloc_ul.tbf_s_time.abs);
    }
    else if (d_ul_assign->f_alloc_ul.tbf_s_time.v_rel)
    {
      ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn,
                                                              d_ul_assign->f_alloc_ul.tbf_s_time.rel);
    }
    else
    {  /* this shall never happen */
      ptr2prim_i->p_tbf_start.fn = (grr_data->dl_fn+13)%FN_MAX;       
      TRACE_ERROR("NO STARTING TIME IN FIXED ALLOCATION!!");
    }
    ptr2prim_i->p_tbf_start.tbf_start_present = 1;
    /*
     *  Downlink Control Timeslot
     */
    ptr2prim_i->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = d_ul_assign->f_alloc_ul.dl_ctrl_ts;
    grr_data->tc.fa_ctrl.dl_ctrl_ts                 = d_ul_assign->f_alloc_ul.dl_ctrl_ts;
    /*
     * ALLOCATION BITMAP
     */
    if(d_ul_assign->f_alloc_ul.v_block_struct)
    {
      tc_calc_fa_bitmap(ptr2prim_i->p_tbf_start.fn,                      /*starting time of cuurent tbf*/
                        d_ul_assign->f_alloc_ul.block_struct.bl_o_bl_per,/* blocks or block periods*/
                        d_ul_assign->f_alloc_ul.block_struct.a_map_len,  /* bitmap length*/
                        d_ul_assign->f_alloc_ul.block_struct.alloc_map,  /* ptr to alloc struct*/
                        &ptr2prim_i->p_ul_alloc.p_fixed_alloc);          /* ptr to fix sttruct*/
    }
    else if(d_ul_assign->f_alloc_ul.v_alloc_map)
    {
      tc_calc_fa_bitmap(ptr2prim_i->p_tbf_start.fn,                      /*starting time of cuurent tbf*/
                        0,                                               /* blocks : default*/
                        d_ul_assign->f_alloc_ul.c_alloc_map,             /* bitmap length*/
                        d_ul_assign->f_alloc_ul.alloc_map,               /* ptr to alloc struct*/
                        &ptr2prim_i->p_ul_alloc.p_fixed_alloc);          /* ptr to fix sttruct*/
    }
    /*
     * check final allocation
     */
    grr_data->tc.fa_ctrl.current_alloc.final_alloc = d_ul_assign->f_alloc_ul.final_alloc;
  }
  else if ( d_ts_reconfig->msg_type EQ D_TS_RECONFIG_c)
  {
    /*
     * timing advance is handled in tc_set_dl_assignment
     */

    if(d_ts_reconfig->f_alloc_re.v_bts_pwr_ctrl)
    {
      ptr2prim_i->p_dl_power.p0 = d_ts_reconfig->f_alloc_re.bts_pwr_ctrl.p0;
      ptr2prim_i->p_dl_power.bts_pwr_ctl_mode =
                                    d_ts_reconfig->f_alloc_re.bts_pwr_ctrl.mode;
      ptr2prim_i->p_dl_power.pr_mode =
                                 d_ts_reconfig->f_alloc_re.bts_pwr_ctrl.pr_mode;
    }
    else
    {
      ptr2prim_i->p_dl_power.p0 = 0xff;
    }

    /*
     * mac mode
     */
    ptr2prim_i->mac_mode = FA;
    /*
     * uplink allocation structure
     */
    if(d_ts_reconfig->v_ul_tfi)
    {
      ptr2prim_i->p_ul_alloc.ul_tfi = d_ts_reconfig->ul_tfi;
    }
    else
    {
      ptr2prim_i->p_ul_alloc.ul_tfi = grr_data->uplink_tbf.tfi;
    }
    ptr2prim_i->p_ul_alloc.ts_mask = grr_data->uplink_tbf.ts_usage;
    /*
     *  fixed allocation structure
     *  half duplex mode is ignored, only valid for MS class 19 to 29
     */
    /*
     *  TBF STARTING TIME for fixed allocation structure
     */
    if(d_ts_reconfig->f_alloc_re.tbf_s_time.v_abs)
    {
      ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ts_reconfig->f_alloc_re.tbf_s_time.abs);
    }
    else if (d_ts_reconfig->f_alloc_re.tbf_s_time.v_rel)
    {
      ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn,
                                                              d_ts_reconfig->f_alloc_re.tbf_s_time.rel);
    }
    else
    {  /* this shall never happen */
      ptr2prim_i->p_tbf_start.fn = (grr_data->dl_fn+13)%FN_MAX;       
      TRACE_ERROR("NO STARTING TIME IN FIXED ALLOCATION!!");
    }
    ptr2prim_i->p_tbf_start.tbf_start_present = 1;
     /*
     *  Downlink Control Timeslot
     */
    ptr2prim_i->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = d_ts_reconfig->f_alloc_re.dl_ctrl_ts;
    grr_data->tc.fa_ctrl.dl_ctrl_ts = d_ts_reconfig->f_alloc_re.dl_ctrl_ts;
    /*
     * ALLOCATION BITMAP
     */
    if(d_ts_reconfig->f_alloc_re.v_block_struct)
    {
      tc_calc_fa_bitmap(ptr2prim_i->p_tbf_start.fn,                         /*starting time of cuurent tbf*/
                        d_ts_reconfig->f_alloc_re.block_struct.bl_o_bl_per, /* blocks or block periods*/
                        d_ts_reconfig->f_alloc_re.block_struct.a_map_len,   /* bitmap length*/
                        d_ts_reconfig->f_alloc_re.block_struct.alloc_map,   /* ptr to alloc struct*/
                        &ptr2prim_i->p_ul_alloc.p_fixed_alloc);             /* ptr to fix sttruct*/
    }
    else if(d_ts_reconfig->f_alloc_re.v_alloc_map)
    {
      tc_calc_fa_bitmap(ptr2prim_i->p_tbf_start.fn,                         /*starting time of cuurent tbf*/
                        0,                                                  /* blocks : default*/
                        d_ts_reconfig->f_alloc_re.c_alloc_map,              /* bitmap length*/
                        d_ts_reconfig->f_alloc_re.alloc_map,                /* ptr to alloc struct*/
                        &ptr2prim_i->p_ul_alloc.p_fixed_alloc);             /* ptr to fix sttruct*/
    }
    /*
     * check final allocation
     */
    grr_data->tc.fa_ctrl.current_alloc.final_alloc = d_ts_reconfig->f_alloc_re.final_alloc;
  }
  else if ( d_ul_ack->msg_type EQ D_UL_ACK_c)
  {
    /*
     * Timing Advance in packet uplink ack/nack with fixed allocation
     */
    if(d_ul_ack->gprs_ul_ack_nack_info.v_pta)
    {
      grr_handle_ta ( d_ul_ack->gprs_ul_ack_nack_info.pta.v_ta_value, 
                      d_ul_ack->gprs_ul_ack_nack_info.pta.ta_value,
                      d_ul_ack->gprs_ul_ack_nack_info.pta.v_ta_index_tn, 
                      d_ul_ack->gprs_ul_ack_nack_info.pta.ta_index_tn.ta_index,
                      d_ul_ack->gprs_ul_ack_nack_info.pta.ta_index_tn.ta_tn,
                      0xFF,
                      0,
                      0,
                      &ptr2prim_i->p_timing_advance);
    }
    else
    {
      grr_handle_ta ( 0, 
                      0,
                      0xFF, 
                      0,
                      0,
                      0xFF,
                      0,
                      0,
                      &ptr2prim_i->p_timing_advance);
    }
 
    /*
     * mac mode
     */
    ptr2prim_i->mac_mode = FA;
    /*
     * uplink allocation structure
     */

    /*no change, therefore take from database*/
    ptr2prim_i->p_ul_alloc.ul_tfi = grr_data->uplink_tbf.tfi;
    ptr2prim_i->p_ul_alloc.ts_mask = grr_data->uplink_tbf.ts_usage;
    /*
     *  fixed allocation structure
     *  half duplex mode is ignored, only valid for MS class 19 to 29
     */
    /*
     *  TBF STARTING TIME for fixed allocation structure
     */
    if(d_ul_ack->gprs_ul_ack_nack_info.v_f_alloc_ack AND d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.v_fa_s2)
    {
      if(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.tbf_s_time.v_abs)
      {
        ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.tbf_s_time.abs);
      }
      else if (d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.tbf_s_time.v_rel)
      {
        ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn,
                                                              d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.tbf_s_time.rel);
      }
      else
      {  /* this shall never happen */
        ptr2prim_i->p_tbf_start.fn = (grr_data->dl_fn+13)%FN_MAX;       
        TRACE_ERROR("NO STARTING TIME IN FIXED ALLOCATION!! struct problem");
      }
    }
    else
    {  /* this shall never happen */
      ptr2prim_i->p_tbf_start.fn = (grr_data->dl_fn+13)%FN_MAX;       
      TRACE_ERROR("NO STARTING TIME IN FIXED ALLOCATION!!");
    }
    ptr2prim_i->p_tbf_start.tbf_start_present = 1;

 
    /*
     *  Downlink Control Timeslot, take from database
     */
    ptr2prim_i->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = grr_data->tc.fa_ctrl.dl_ctrl_ts;
    /*
     * ALLOCATION BITMAP
     */
    if(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.v_block_struct)
    {
      tc_calc_fa_bitmap(ptr2prim_i->p_tbf_start.fn,                          /* starting time of cuurent tbf*/
                        d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.block_struct.bl_o_bl_per,/* blocks or block periods*/
                        d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.block_struct.a_map_len,  /* bitmap length */
                        d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.block_struct.alloc_map,  /* ptr to alloc struct*/
                        &ptr2prim_i->p_ul_alloc.p_fixed_alloc);              /* ptr to fix sttruct*/
    }
    else if(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.v_alloc_map)
    {
      tc_calc_fa_bitmap(ptr2prim_i->p_tbf_start.fn,                      /*starting time of cuurent tbf*/
                        0,                                               /* blocks : default*/
                        d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.c_alloc_map,         /* bitmap length*/
                        d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.alloc_map,           /* ptr to alloc struct*/
                        &ptr2prim_i->p_ul_alloc.p_fixed_alloc);          /* ptr to fix sttruct*/
    }
    /*
     * check final allocation
     */
    grr_data->tc.fa_ctrl.current_alloc.final_alloc = d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.final_alloc;
  }
  else
  {
    TRACE_ERROR ( "Wrong message type in _decodedCtrlMsg" );
  }
   
  if(ptr2prim_i->p_tbf_start.tbf_start_present)
    grr_data->uplink_tbf.tbf_start_fn = ptr2prim_i->p_tbf_start.fn;
  else
    grr_data->uplink_tbf.tbf_start_fn = CGRLC_STARTING_TIME_NOT_PRESENT;

  grr_data->uplink_tbf.st_tfi = ptr2prim_i->p_ul_alloc.ul_tfi;


  return;
} /* tc_set_fa_assignment() */


/*
+------------------------------------------------------------------------------
| Function    : tc_set_dl_assignment
+------------------------------------------------------------------------------
| Description : This function sets some parameter of T_MPHP_ASSIGNMENT_REQ is
|               case of downlink allocation
|
| Parameters  : ptr2prim_i -  ptr to MPHP_ASSIGNMENT_REQ
|
+------------------------------------------------------------------------------
*/
LOCAL void tc_set_dl_assignment (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i)
{
  MCAST(d_dl_assign, D_DL_ASSIGN); /* T_D_DL_ASSIGN  */
  MCAST(d_ts_reconfig,D_TS_RECONFIG);

  TRACE_FUNCTION( "tc_set_dl_assignment" );
  if( d_dl_assign->msg_type EQ D_DL_ASSIGN_c)
  {
    /*
     * timing advance
     */
  grr_handle_ta ( d_dl_assign->pta.v_ta_value, 
          d_dl_assign->pta.ta_value,
          0xFF, 
          0,
          0,
          d_dl_assign->pta.v_ta_index_tn,
          d_dl_assign->pta.ta_index_tn.ta_index,
          d_dl_assign->pta.ta_index_tn.ta_tn,
          &ptr2prim_i->p_timing_advance);
    /*
     * TBF starting time
     */
    
    if(d_dl_assign->pda_trnc_grp.v_tbf_s_time)
    {
      ptr2prim_i->p_tbf_start.tbf_start_present = 1;
      if(d_dl_assign->pda_trnc_grp.tbf_s_time.v_abs)
      {
        ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_dl_assign->pda_trnc_grp.tbf_s_time.abs);
      }
      else if (d_dl_assign->pda_trnc_grp.tbf_s_time.v_rel)
      {
        ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn,
                                                              d_dl_assign->pda_trnc_grp.tbf_s_time.rel);
      }
      else
      {  /* this shall never happen */
        ptr2prim_i->p_tbf_start.fn = grr_data->dl_fn%FN_MAX;
        TRACE_ERROR("DL v_start_tbf but either rel nor abs tbf included");
      }      
    }
    else if(grr_data->l1_del_tbf_start_fn NEQ GRR_INVALID_FN)
    {
      ptr2prim_i->p_tbf_start.tbf_start_present = 1;  
      ptr2prim_i->p_tbf_start.fn = grr_data->l1_del_tbf_start_fn;
    }
    else
    {
      ptr2prim_i->p_tbf_start.tbf_start_present = 0;  
    }


    if(d_dl_assign->v_bts_pwr_ctrl)
    {
      ptr2prim_i->p_dl_power.p0 = d_dl_assign->bts_pwr_ctrl.p0;
      ptr2prim_i->p_dl_power.bts_pwr_ctl_mode = d_dl_assign->bts_pwr_ctrl.mode;
      ptr2prim_i->p_dl_power.pr_mode = d_dl_assign->bts_pwr_ctrl.pr_mode;
    }
    else
    {
      ptr2prim_i->p_dl_power.p0 = 0xff;
    }
    /*
    * mac mode
    */
    ptr2prim_i->mac_mode = d_dl_assign->mac_mode;

   /*
    *  downlink allocation structure
    */
    if(d_dl_assign->pda_trnc_grp.v_dl_tfi_assign)
    {
      ptr2prim_i->p_dl_alloc.dl_tfi = d_dl_assign->pda_trnc_grp.dl_tfi_assign;
    }
    else
    {
      ptr2prim_i->p_dl_alloc.dl_tfi = grr_data->downlink_tbf.tfi;
    }
    ptr2prim_i->p_dl_alloc.ts_mask = d_dl_assign->ts_alloc;

  }
  else if ( d_ts_reconfig->msg_type EQ D_TS_RECONFIG_c)
  {
    /* TS Reconfigure allways contains ul assign -> TBF starting time
     * is handled there
     */
    if(d_ts_reconfig->v_dl_tfi)
    {
      ptr2prim_i->p_dl_alloc.dl_tfi = d_ts_reconfig->dl_tfi;
    }
    else
    {
      ptr2prim_i->p_dl_alloc.dl_tfi = grr_data->downlink_tbf.tfi;
    }
    ptr2prim_i->p_dl_alloc.ts_mask = grr_data->downlink_tbf.ts_usage;
    /*
     * timing advance
     */
    grr_handle_ta ( d_ts_reconfig->gpta.v_ta_value, 
          d_ts_reconfig->gpta.ta_value,
          d_ts_reconfig->gpta.v_ul_ta_index, 
          d_ts_reconfig->gpta.ul_ta_index,
          d_ts_reconfig->gpta.ul_ta_tn,
          d_ts_reconfig->gpta.v_dl_ta_index,
          d_ts_reconfig->gpta.dl_ta_index,
          d_ts_reconfig->gpta.dl_ta_tn,
          &ptr2prim_i->p_timing_advance);
  }
  else
  {
    TRACE_ERROR ( "Wrong message type in _decodedCtrlMsg" );
  }


  if(ptr2prim_i->p_tbf_start.tbf_start_present)
    grr_data->downlink_tbf.tbf_start_fn = ptr2prim_i->p_tbf_start.fn;
  else
    grr_data->downlink_tbf.tbf_start_fn = CGRLC_STARTING_TIME_NOT_PRESENT;

  grr_data->downlink_tbf.st_tfi      = ptr2prim_i->p_dl_alloc.dl_tfi;
  grr_data->downlink_tbf.polling_bit = 0xFF;

  
  
  return;
} /* tc_set_dl_assignment() */



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



/*
+------------------------------------------------------------------------------
| Function    : tc_gen_rand
+------------------------------------------------------------------------------
| Description : This function generates a random value between db.prach.s
|               and (db.prach.tx_int -1)
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL USHORT tc_gen_rand ( void )
{
  USHORT result ;
  UBYTE i;
  TRACE_FUNCTION( "tc_gen_rand" );

  /*
   * the "-1" defined in ETS 04.60 will be done by tc_random_value()
   *
   */
  i = tx_int_table[psc_db->prach.tx_int];
  
  result =  (USHORT)grr_random_value (S_T_RND_INDEX, i );

  result +=  s_table[psc_db->prach.s_prach];

#ifndef _TARGET_
  TRACE_EVENT_P2("S, S+1 ..:%d tx_init:%d",result, i);
#endif /* _TARGET_ */

  return (result);

} /* tc_gen_rand() */



/*
+------------------------------------------------------------------------------
| Function    : tc_calc_req
+------------------------------------------------------------------------------
| Description : The function tc_calc_req() generate the message
|               Packet Access Request.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL USHORT tc_calc_req ( void )
{
  USHORT channel_request_data = 0;

  TRACE_FUNCTION( "tc_calc_req" );

  switch(psc_db->gprs_cell_opt.ab_type)
  {
    case AB_8_BIT:
      switch(grr_data->uplink_tbf.access_type)
      {
        case CGRLC_AT_ONE_PHASE:
          channel_request_data = tc_one_phase_mask_8bit();
          channel_request_data |= ((grr_get_gprs_ms_class( )-1)<<2);
          break;
        case CGRLC_AT_SHORT_ACCESS:
          channel_request_data = tc_short_access_mask_8bit();
          channel_request_data |= ((grr_data->uplink_tbf.nr_blocks-1)<<3);
          break;
        case CGRLC_AT_TWO_PHASE:
          channel_request_data=tc_two_phase_mask_8bit();
          break;
        case CGRLC_AT_PAGE_RESPONSE:
          channel_request_data=tc_page_response_mask_8bit();
          break;
        case CGRLC_AT_CELL_UPDATE:
          channel_request_data=tc_cell_update_mask_8bit();
          break;
        case CGRLC_AT_MM_PROCEDURE:
          channel_request_data=tc_mm_procedure_mask_8bit();
          break;
        case CGRLC_AT_SINGLE_BLOCK:
          channel_request_data=tc_single_block_mask_8bit();
          break;
        default:
          break;
      }
      break;

    case AB_11_BIT:
      switch(grr_data->uplink_tbf.access_type)
      {
        case CGRLC_AT_ONE_PHASE:
          channel_request_data=tc_one_phase_mask_11bit();
          channel_request_data |= ((grr_get_gprs_ms_class( )-1)<<5);
          channel_request_data |= (grr_data->uplink_tbf.prio<<3);
          break;
        case CGRLC_AT_SHORT_ACCESS:
          channel_request_data=tc_short_access_mask_11bit();
          channel_request_data |= (grr_data->uplink_tbf.prio<<3);
          channel_request_data |= ((grr_data->uplink_tbf.nr_blocks-1)<<5);
          break;
        case CGRLC_AT_TWO_PHASE:
          channel_request_data=tc_two_phase_mask_11bit();
          channel_request_data |= (grr_data->uplink_tbf.prio<<3);
          break;
        case CGRLC_AT_PAGE_RESPONSE:
          channel_request_data=tc_page_response_mask_11bit();
          break;
        case CGRLC_AT_CELL_UPDATE:
          channel_request_data=tc_cell_update_mask_11bit();
          break;
        case CGRLC_AT_MM_PROCEDURE:
          channel_request_data=tc_mm_procedure_mask_11bit();
          break;
        case CGRLC_AT_SINGLE_BLOCK:
          channel_request_data=tc_single_block_mask_11bit();
          break;
        default:
          channel_request_data = 0;
          break;
      }
      channel_request_data = grr_convert_11bit_2_etsi(channel_request_data);
      TRACE_EVENT_P1("11 bit Channel Request: 0x%X", channel_request_data);
      break;
    default:
      break;
  }
 return(channel_request_data);

} /* tc_calc_req() */



/*
+------------------------------------------------------------------------------
| Function    : tc_check_p_level
+------------------------------------------------------------------------------
| Description : The function tc_check_p_level() checks the p-level for the
|               PDU's radio priority aigainst a random value and returns
|               wheather to send the random access or to continue with
|               calculating.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL T_CHECK_P_LEVEL tc_check_p_level ( void )
{
  UBYTE p_level,i;
  T_CHECK_P_LEVEL result;
  TRACE_FUNCTION( "tc_check_p_level" );

  /*
   * get value between 0 and 15
   */
  i = (UBYTE) grr_random_value (PLEV_RND_INDEX, 16);

  p_level = psc_db->prach.pers_lev.plev[grr_data->uplink_tbf.prio];

  if(p_level EQ 15)
  {
    /*
     * transmission in every case forbitten, because refer to ETS the value 0xf
     * have to be interpreted as 16 and i is in every case more little (0 <= i <= 15).
     * This case should be avoided (dead lock!) and have to be checked
     * in tc_start_access()
     */
    TRACE_ERROR("unexpected persistence_level_value");
    result = C_P_LEVEL_DO_NOT_SEND;
  }
  else
  {
    result = ( (i >= p_level)  ?  C_P_LEVEL_SEND : C_P_LEVEL_DO_NOT_SEND );
  }

  return( result );

} /* tc_check_p_level() */



/*
+------------------------------------------------------------------------------
| Function    : tc_send_assign_req
+------------------------------------------------------------------------------
| Description : The function tc_send_assign_req() builds MPHP_ASSIGNMENT_REQ
|               and send it.
|
| Parameters  : tbf_type_i - type of TBF that is to activate
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_send_assign_req ( T_TBF_TYPE tbf_type_i )
{

  TRACE_FUNCTION( "tc_send_assign_req" );
  {
    T_MPHP_ASSIGNMENT_REQ * ptr2prim;//=NULL;

    ptr2prim=tc_set_freq();

    grr_set_tbf_cfg_req_param( ptr2prim );

    switch( tbf_type_i )
    {
      case CGRLC_TBF_MODE_DL:
        ptr2prim->assign_cmd = DL_ASSIGNMENT;
        tc_set_dl_assignment(ptr2prim);
        break;
      case CGRLC_TBF_MODE_UL:
        ptr2prim->assign_cmd = UL_ASSIGNMENT;
        if(grr_data->uplink_tbf.mac_mode EQ DA)
          tc_set_da_assignment(ptr2prim);
        else
          tc_set_fa_assignment(ptr2prim);
        break;
      case CGRLC_TBF_MODE_DL_UL:
        ptr2prim->assign_cmd = UL_DL_ASSIGNMENT;
        if(grr_data->uplink_tbf.mac_mode EQ DA)
          tc_set_da_assignment(ptr2prim);
        else
          tc_set_fa_assignment(ptr2prim);
        tc_set_dl_assignment(ptr2prim);
        break;
#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
      case CGRLC_TBF_MODE_2PA:
        ptr2prim->assign_cmd = UL_TP_ACCESS;
        tc_set_fa_assignment(ptr2prim);
        break;
#endif
      default:
        break;
    } /* switch (tbf_type_i) */ 
    PSEND(hCommL1,ptr2prim);
    
  }
} /* tc_send_assign_req() */



/*
+------------------------------------------------------------------------------
| Function    : tc_send_tbf_rel
+------------------------------------------------------------------------------
| Description : The function tc_send_tbf_rel() builds MPHP_TBF_RELEASE_REQ
|               and send it.
|
| Parameters  : TBP-Type - that have to be deleted
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_send_tbf_rel ( T_TBF_TYPE tbf_i )
{
  UBYTE dummy = grr_data->tc.num_of_rels_running;

  TRACE_FUNCTION( "tc_send_tbf_rel" );

  tc_prepare_send_tbf_release_req( tbf_i );

  {
    T_RELEASE_STATE rel_state= REL_PERFORMED;

    if(dummy NEQ grr_data->tc.num_of_rels_running)
    {
      rel_state = REL_RUNNING;
    }
    sig_tc_ctrl_rel_state(rel_state);
  }


} /* tc_send_tbf_rel() */



/*
+------------------------------------------------------------------------------
| Function    : tc_send_pdch_rel
+------------------------------------------------------------------------------
| Description : The function tc_send_pdch_rel() builds MPHP_PDCH_RELEASE_REQ
|               and send it.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_send_pdch_rel ( UBYTE ts_available )
{
  PALLOC(mphp_pdch_release_req,MPHP_PDCH_RELEASE_REQ);

  TRACE_FUNCTION( "tc_send_pdch_rel" );

  mphp_pdch_release_req->assign_id = 0;
  mphp_pdch_release_req->ts_mask   = ts_available;
  PSEND(hCommL1,mphp_pdch_release_req);

} /* tc_send_pdch_rel() */



/*
+------------------------------------------------------------------------------
| Function    : tc_abort_tbf
+------------------------------------------------------------------------------
| Description : The function tc_abort_tbf() stops a TBF.
|
| Parameters  : tbf_i - TBF type to abort
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_abort_tbf ( T_TBF_TYPE tbf_i )
{

  TRACE_FUNCTION( "tc_abort_tbf" );

  switch( tbf_i )
  {
    case CGRLC_TBF_MODE_NULL:
      TRACE_EVENT("NULL TBF active: check if tbf starting time is running");
      tc_cgrlc_ul_tbf_res ( CGRLC_TBF_MODE_ACCESS_FAILED, CGRLC_PRIM_STATUS_NULL );
      break;
#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
    case CGRLC_TBF_MODE_2PA:
      tc_send_tbf_rel(tbf_i);
      tc_cgrlc_tbf_rel_req(tbf_i,CGRLC_TBF_REL_ABNORMAL,CGRLC_STARTING_TIME_NOT_PRESENT);
      tc_deactivate_tbf(tbf_i);
      break;
#endif
    case CGRLC_TBF_MODE_UL:
      tc_send_tbf_rel(tbf_i);
      tc_cgrlc_tbf_rel_req(tbf_i,CGRLC_TBF_REL_ABNORMAL,CGRLC_STARTING_TIME_NOT_PRESENT);
      tc_deactivate_tbf(tbf_i);
      break;
    case CGRLC_TBF_MODE_DL:
      tc_send_tbf_rel(tbf_i);
      tc_cgrlc_tbf_rel_req(tbf_i,CGRLC_TBF_REL_ABNORMAL,CGRLC_STARTING_TIME_NOT_PRESENT);
      tc_deactivate_tbf(tbf_i);
      break;
    case CGRLC_TBF_MODE_DL_UL:
      tc_send_tbf_rel(tbf_i);
      tc_cgrlc_tbf_rel_req(tbf_i,CGRLC_TBF_REL_ABNORMAL,CGRLC_STARTING_TIME_NOT_PRESENT);
      tc_deactivate_tbf(tbf_i);
      break;
    default:
      TRACE_ERROR ( "tc_abort_tbf: TBF type is invalid" );
      break;
  }
} /* tc_abort_tbf() */





/*
+------------------------------------------------------------------------------
| Function    : tc_build_res_req
+------------------------------------------------------------------------------
| Description : The function tc_build_res_req() builds Packet Resource Request.
|
| Parameters  : reason_i   - the reason for building that packet resouce
|                            reallocation
|               src_info_i - indicates where to get the carrier information
|                            regarding the assigned TBF
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_build_res_req (T_U_RESOURCE_REQ *ptr2res_req,
                              T_REASON_BUILD    reason_i,
                              T_SRC_TBF_INFO    src_info_i )
{
  UBYTE change_mark;

  TRACE_FUNCTION( "tc_build_res_req" );


  memset(ptr2res_req,0,sizeof(T_U_RESOURCE_REQ) );

  /* processing of messsage type */
  ptr2res_req->msg_type = U_RESOURCE_REQ_c;

  /* processing of change mark */
  if( grr_is_pbcch_present( ) )
  {
    change_mark = psc_db->psi2_params.psi2_change_mark;
  }
  else
  {
    change_mark = psc_db->psi13_params.si13_change_mark;
  }
  
  if( change_mark EQ NOT_SET )
  {
    ptr2res_req->v_ma_ch_mark = 0;
  }
  else
  {
    ptr2res_req->v_ma_ch_mark = 1;
    ptr2res_req->ma_ch_mark   = change_mark;
  }


  if(reason_i EQ R_BUILD_2PHASE_ACCESS)
  {
    /* 1 - processing of ACCESS_TYPE */
    ptr2res_req->v_access_type = 1;
    ptr2res_req->access_type   = TWO_PHASE;

    /* 2 - processing of global TFI and TLLI */
    ptr2res_req->flag          = 1;
    ptr2res_req->v_glob_tfi    = 0;
    ptr2res_req->v_tlli_value  = 1;

    grr_set_buf_tlli( &ptr2res_req->tlli_value, grr_data->db.ms_id.new_tlli );

    /* 3 - processing of radio access capabilities */
    if( rr_csf_get_radio_access_capability( &ptr2res_req->ra_cap ) EQ 0 )
    {
      ptr2res_req->v_ra_cap = TRUE;
    }
    else
    {
      ptr2res_req->v_ra_cap = FALSE;

      TRACE_ERROR( "tc_build_res_req: radio access capabilities invalid" );
    }
    /* 4 - processing of channel request description */
    ptr2res_req->chan_req_des.peak_thr_class  = (UBYTE) grr_data->uplink_tbf.peak;
    ptr2res_req->chan_req_des.radio_prio      = grr_data->uplink_tbf.prio;
    if(grr_data->uplink_tbf.prim_type EQ CGRLC_LLC_PRIM_TYPE_UNITDATA_REQ)
    {
      ptr2res_req->chan_req_des.rlc_mode = CGRLC_RLC_MODE_UACK;
    }
    else
    {
      ptr2res_req->chan_req_des.rlc_mode = CGRLC_RLC_MODE_ACK;
    }
    ptr2res_req->chan_req_des.llc_pdu_type    = LLC_NOT_ACK;
    ptr2res_req->chan_req_des.rlc_octet_cnt   = grr_data->uplink_tbf.rlc_oct_cnt;

    /* 5 - processing of signal variance */
    ptr2res_req->v_signvar = FALSE;
  }

  /* processing of C value */
  {
    ptr2res_req->c_value = meas_c_get_value( );
  }

  /* processing of relative interference levels */
  {
    T_p_frequency_par freq_par;
    T_MEAS_IM_CARRIER ma;

    switch( src_info_i )
    {
      case( SRC_TBF_INFO_RE_ASSIGN ):
      case( SRC_TBF_INFO_IMM_ASSIGN ):
      case( SRC_TBF_INFO_UL_ASSIGN ):
        grr_set_freq_par( &freq_par );
        meas_im_set_carrier( &ma, &freq_par );
        break;

      default:
        TRACE_ASSERT( src_info_i EQ SRC_TBF_INFO_RE_ASSIGN  OR
                      src_info_i EQ SRC_TBF_INFO_IMM_ASSIGN OR
                      src_info_i EQ SRC_TBF_INFO_UL_ASSIGN     );
        break;
    }

    meas_im_get_rel_i_level( &ma, &ptr2res_req->ilev );
  }

#ifdef REL99
  ptr2res_req->v_release_99_str_prr              = FALSE;
  ptr2res_req->release_99_str_prr.flag           = 0;
  ptr2res_req->release_99_str_prr.flag2          = 0;
  ptr2res_req->release_99_str_prr.v_pfi          = 0;
  ptr2res_req->release_99_str_prr.add_ms_rac     = 0;
  ptr2res_req->release_99_str_prr.retrans_of_prr = 0;
#endif

} /* tc_build_res_req() */


/*
+------------------------------------------------------------------------------
| Function    : tc_eval_pdch_rel
+------------------------------------------------------------------------------
| Description : The function tc_eval_pdch_rel() evaluate a
|               Packet PDCH Release.
|
| Parameters  : slot_i - the slot where the message was received
|
+------------------------------------------------------------------------------
*/
GLOBAL T_EVAL_PDCH_REL tc_eval_pdch_rel ( UBYTE slot_i )
{
  MCAST(d_pdch_release,D_PDCH_RELEASE); /* T_D_PDCH_RELEASE */

  UBYTE mask,help=0xFF, help2=0xFF;
  T_EVAL_PDCH_REL result=E_PDCH_REL_NULL;

  TRACE_FUNCTION( "tc_eval_pdch_rel" );

  if(!d_pdch_release->v_ts_available)
  {
    mask  = 0x80;
    mask  >>= slot_i;
    mask ^= 0xFF;
    TRACE_EVENT_P7("NO TS PDCH REL: slot=%d ->mask=%x ul=%x st_ul=%x dl=%x st_dl=%x c_fn=%ld"
                                                                      ,slot_i
                                                                      ,mask
                                                                      ,grr_data->uplink_tbf.ts_mask
                                                                      ,grr_data->uplink_tbf.ts_usage
                                                                      ,grr_data->downlink_tbf.ts_mask
                                                                      ,grr_data->downlink_tbf.ts_usage
                                                                      , grr_data->ul_fn);
  }
  else
  {
    mask = d_pdch_release->ts_available;
    TRACE_EVENT_P7("ts PDCH REL: mask=%x ul=%x st_ul=%x dl=%x st_dl=%x c_fn=%ld"
                                                                      ,slot_i
                                                                      ,mask
                                                                      ,grr_data->uplink_tbf.ts_mask
                                                                      ,grr_data->uplink_tbf.ts_usage
                                                                      ,grr_data->downlink_tbf.ts_mask
                                                                      ,grr_data->downlink_tbf.ts_usage
                                                                      , grr_data->ul_fn); 
  }
  grr_data->pdch_rel_ts_mask = mask;

  switch(grr_data->tbf_type)
  {
    case CGRLC_TBF_MODE_UL:
      help = grr_data->uplink_tbf.ts_mask;
      grr_data->uplink_tbf.ts_mask &= mask;
      if(!grr_data->uplink_tbf.ts_mask)
      {
        result = E_PDCH_REL_RELEASE_UL;
      }
      else if(grr_data->uplink_tbf.ts_mask NEQ help)
      {
        grr_data->uplink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->uplink_tbf.ts_mask);
        result = E_PDCH_REL_RECONF;
        tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL);
      }
      else
      {
        TRACE_EVENT("NO change in pdch rel for ul tbf");
        result = E_PDCH_REL_NULL;
      }
      break;
    case CGRLC_TBF_MODE_DL:
      help = grr_data->downlink_tbf.ts_mask;
      grr_data->downlink_tbf.ts_mask &= mask;
      if(!grr_data->downlink_tbf.ts_mask)
      {
        result = E_PDCH_REL_RELEASE_DL;
      }
      else if(grr_data->downlink_tbf.ts_mask NEQ help)
      {
        grr_data->downlink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->downlink_tbf.ts_mask);
        tc_cgrlc_dl_tbf_req();
        result = E_PDCH_REL_RECONF;
      }
      else
      {
        TRACE_EVENT("NO change in pdch rel for dl tbf");
        result = E_PDCH_REL_IGNORE;
      }
      break;
    case CGRLC_TBF_MODE_DL_UL:
      help  = grr_data->uplink_tbf.ts_mask;
      help2 = grr_data->downlink_tbf.ts_mask;
      grr_data->uplink_tbf.ts_mask   &= mask;
      grr_data->downlink_tbf.ts_mask &= mask;
      if( !handle_ms_cap(UL_DL_ASSIGNMENT))
      {
        result = E_PDCH_REL_RELEASE_BOTH;
        TRACE_EVENT_P3("MS CLASS ERROR in PDCH assignment  ul_mask=%x, dl_mask=%x, pdch_mask=%x",
                                                grr_data->uplink_tbf.ts_mask,
                                                grr_data->downlink_tbf.ts_mask,
                                                mask);
      }
      else if(!grr_data->downlink_tbf.ts_mask AND !grr_data->uplink_tbf.ts_mask)
      {
        result = E_PDCH_REL_RELEASE_BOTH;
        TRACE_EVENT_P3("rel of UL and DL  ul_mask=%x, dl_mask=%x, pdch_mask=%x",
                                                grr_data->uplink_tbf.ts_mask,
                                                grr_data->downlink_tbf.ts_mask,
                                                mask);
      }
      else if(!grr_data->downlink_tbf.ts_mask)
      { /*DL release*/
        if(grr_data->uplink_tbf.ts_mask EQ help)
        { /* no change for uplink*/
          result = E_PDCH_REL_RELEASE_DL;
          TRACE_EVENT_P3("rel of DL  ul_mask=%x, dl_mask=%x, pdch_mask=%x",
                                                grr_data->uplink_tbf.ts_mask,
                                                grr_data->downlink_tbf.ts_mask,
                                                mask);
        }
        else
        { /*uplink reconfigure*/
          result = E_PDCH_REL_RELEASE_DL_RECONF_UL;
          grr_data->uplink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->uplink_tbf.ts_mask);
          tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL);
          TRACE_EVENT_P3("rel of DL, conf UL ul_mask=%x, dl_mask=%x, pdch_mask=%x",
                                                grr_data->uplink_tbf.ts_mask,
                                                grr_data->downlink_tbf.ts_mask,
                                                mask);
        }
      }
      else if(!grr_data->uplink_tbf.ts_mask)
      { /*UL release*/
        if(grr_data->downlink_tbf.ts_mask EQ help2)
        { /* no change for downlink*/
          result = E_PDCH_REL_RELEASE_UL;
          TRACE_EVENT_P3("rel of UL  ul_mask=%x, dl_mask=%x, pdch_mask=%x",
                                                grr_data->uplink_tbf.ts_mask,
                                                grr_data->downlink_tbf.ts_mask,
                                                mask);
        }
        else
        { /*downlink reconfigure*/
          result = E_PDCH_REL_RELEASE_UL_RECONF_DL;
          grr_data->downlink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->downlink_tbf.ts_mask);
          tc_cgrlc_dl_tbf_req();
          TRACE_EVENT_P3("rel of UL, conf DL ul_mask=%x, dl_mask=%x, pdch_mask=%x",
                                                grr_data->uplink_tbf.ts_mask,
                                                grr_data->downlink_tbf.ts_mask,
                                                mask);
        }
      }
      else if(grr_data->downlink_tbf.ts_mask NEQ help2)
      { /*change in DL*/
        result = E_PDCH_REL_RECONF;
        grr_data->downlink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->downlink_tbf.ts_mask);
        tc_cgrlc_dl_tbf_req();
        if(grr_data->uplink_tbf.ts_mask EQ help)
        { /* no change for uplink*/
          TRACE_EVENT_P3("conf of DL  ul_mask=%x, dl_mask=%x, pdch_mask=%x",
                                                grr_data->uplink_tbf.ts_mask,
                                                grr_data->downlink_tbf.ts_mask,
                                                mask);
        }
        else
        { /*uplink reconfigure*/
          grr_data->uplink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->uplink_tbf.ts_mask);
          tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL);
          TRACE_EVENT_P3("conf ofDL/UL ul_mask=%x, dl_mask=%x, pdch_mask=%x",
                                                grr_data->uplink_tbf.ts_mask,
                                                grr_data->downlink_tbf.ts_mask,
                                                mask);
        }
      }
      else
      { /* no change in DL*/
        if(grr_data->uplink_tbf.ts_mask EQ help)
        { /* no change for uplink*/
          result = E_PDCH_REL_IGNORE;
          TRACE_EVENT_P3("NO conf UL/DL  ul_mask=%x, dl_mask=%x, pdch_mask=%x",
                                                grr_data->uplink_tbf.ts_mask,
                                                grr_data->downlink_tbf.ts_mask,
                                                mask);
        }
        else
        { /*uplink reconfigure*/
          result = E_PDCH_REL_RECONF;
          grr_data->uplink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->uplink_tbf.ts_mask);
          tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL);
          TRACE_EVENT_P3("conf of UL ul_mask=%x, dl_mask=%x, pdch_mask=%x",
                                                grr_data->uplink_tbf.ts_mask,
                                                grr_data->downlink_tbf.ts_mask,
                                                mask);
        }
      }
      break;
    default:
      TRACE_ERROR("unknown tbf type in tc_eval_pdch_rel");
      break;
  }
  return(result);

} /* tc_eval_pdch_rel() */



/*
+------------------------------------------------------------------------------
| Function    : tc_eval_ul_assign
+------------------------------------------------------------------------------
| Description : The function tc_eval_ul_assign() evaluates a
|               Packet Uplink Assignment.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL T_EVAL_UL_ASSIGN tc_eval_ul_assign ( void )
{
  MCAST(d_ul_assign,D_UL_ASSIGN); /* T_D_UL_ASSIGN */
  T_EVAL_UL_ASSIGN result = E_UL_ASSIGN_NULL;
  UBYTE tx_slots = 0;
  UBYTE i,mask;

  T_GRR_STORE_TYPE grr_store_type = GRR_STORE_TYPE_NONE;

  TRACE_FUNCTION( "tc_eval_ul_assign" );

#ifdef REL99
  if(d_ul_assign->egprs_flag)
  {
    
    TRACE_ERROR("EGPRS TBF received in UL ASSIGNMENT");
    
    if(grr_data->tbf_type EQ CGRLC_TBF_MODE_NULL)
    {
      /* TBF is not active. Handling abnormal case
       * 7.1.4  If the mobile station has been assigned a TBF in EGPRS mode and 
       * the MS does not support EGPRS, or has been assigned an MCS (e.g. 8-PSK 
       * in the Uplink) that the MS does not support, the MS shall return to packet
       * idle mode and notify higher layers (TBF establishment failure)
       */
      return E_UL_ASSIGN_ERROR_RA;	  
    }
    else
    {
      /* TBF is active. Handling abnormal case
       * 8.7 While a TBF is in progress, if a mobile station receives a 
       * PACKET UPLINK ASSIGNMENT, PACKET UPLINK ACK/NACK or PACKET TIMESLOT RECONFIGURE 
       * message with message escape bit indicating EGPRS (resp. GPRS) contents whereas 
       * the current TBF mode is GPRS (resp. EGPRS), the mobile station shall ignore the 
       * message.
       */
      return E_UL_ASSIGN_IGNORE;
    }
  }
#endif

  /*
   * Handle mac mode
   */  
  switch( grr_data->tbf_type )
  {
    case CGRLC_TBF_MODE_DL:
      grr_data->uplink_tbf.ti = 0;  /* contention resolution NOT required */

      /*lint -fallthrough*/

    case CGRLC_TBF_MODE_NULL:
      if(d_ul_assign->v_dyn_alloc_p)
      {
        if(!d_ul_assign->dyn_alloc_p.xdyn_alloc)
          grr_data->uplink_tbf.mac_mode = DA;
        else
        {
          grr_data->uplink_tbf.mac_mode = EDA;
        }
      }          
      else if(d_ul_assign->v_f_alloc_ul)
        grr_data->uplink_tbf.mac_mode = FA; 
      break;
    case CGRLC_TBF_MODE_UL:
      if( grr_data->uplink_tbf.mac_mode NEQ DA  AND 
          d_ul_assign->v_dyn_alloc_p
        )
      { 
        TRACE_ERROR("dynamic alloc received while fixed is running in uplink");
        return  E_UL_ASSIGN_ERROR_RA;
      }
      else if( grr_data->uplink_tbf.mac_mode NEQ FA  AND 
               d_ul_assign->v_f_alloc_ul 
             )
      {
        TRACE_ERROR("fixed alloc received while dynamic is running in uplink");
        return  E_UL_ASSIGN_ERROR_RA;
      }
      break;
    default:
      break;
  } 
  grr_data->uplink_tbf.cs_mode      = d_ul_assign->chan_coding_cmd;
  grr_data->uplink_tbf.tlli_cs_mode = d_ul_assign->tlli_chan_coding;
  grr_data->uplink_tbf.polling_bit  = 0xFF;

  if(d_ul_assign->v_dyn_alloc_p)
  {
    if( grr_data->uplink_tbf.mac_mode NEQ DA)
    {
      result = E_UL_ASSIGN_ERROR_RA;
      TRACE_ERROR("dyn alloc received but diff mac mode");
      TRACE_EVENT_P3("MAC_MODE:   ms=%d, Ex.DA=%d  tbf_mode=%d"
                                                              ,grr_data->uplink_tbf.mac_mode
                                                              ,d_ul_assign->dyn_alloc_p.xdyn_alloc
                                                              ,grr_data->tbf_type);
    }
    else
    {
      result = E_UL_ASSIGN_DYNAMIC;
      /* SZML-TC/071*/
      
      if (d_ul_assign->dyn_alloc_p.v_rlc_db_granted)/* close-ended TBF*/
      {
        UBYTE   data_size=20;

        switch( grr_data->uplink_tbf.cs_mode)
        {
          case CGRLC_CS_MODE_1:
            data_size = 20;
            break;
          case CGRLC_CS_MODE_2:
            data_size = 30;
            break;
          case CGRLC_CS_MODE_3:
            data_size = 36;
            break;
          case CGRLC_CS_MODE_4:
            data_size = 50;
            break;
          default:
            TRACE_ERROR("unknown Coding Scheme");
            break;
        }
        data_size -= grr_data->uplink_tbf.ti*4; /* CR TLLI */
  
        grr_data->uplink_tbf.rlc_db_granted = (d_ul_assign->dyn_alloc_p.rlc_db_granted + 9);

        if (grr_data->uplink_tbf.rlc_db_granted * data_size <  grr_data->uplink_tbf.rlc_oct_cnt)
        /* granted rlc blocks in bytes are not enough to transmit the first pdu*/
        {
          result = E_UL_ASSIGN_ERROR_RA;
          TRACE_EVENT_P3("granted rlc blocks are not enough to transmit the first pdu rlc_g=%ld sdu_len =%ld data_size=%d"
                          ,grr_data->uplink_tbf.rlc_db_granted * data_size
                          ,grr_data->uplink_tbf.rlc_oct_cnt
                          ,data_size);
          return(result);
        }
      }
      else
      {
        /*
         * open ended TBF
         */
        grr_data->uplink_tbf.rlc_db_granted = 0;
      }

      grr_data->uplink_tbf.ts_usage = 0;

      if(d_ul_assign->dyn_alloc_p.v_tn_alloc)
      {
        for(i = 0,mask = 0x80;i < 8;i++)
        {
          if(d_ul_assign->dyn_alloc_p.tn_alloc[i].v_usf)
          {
            grr_data->uplink_tbf.ts_usage |= mask;
            tx_slots++;
          }
          mask >>= 1;
        }
      }
      else if(d_ul_assign->dyn_alloc_p.v_tn_alloc_pwr)
      {
        for(i = 0,mask = 0x80;i < 8;i++)
        {
          if(d_ul_assign->dyn_alloc_p.tn_alloc_pwr.usf_array[i].v_usf_g)
          {

            grr_data->uplink_tbf.ts_usage |= mask;
            tx_slots++;
          }
          mask >>= 1;
        }

        grr_store_type = GRR_STORE_TYPE_TN_ALLOC_PWR;
      }
      grr_data->uplink_tbf.nts = tx_slots;
    }
  }
  else if(d_ul_assign->v_sin_alloc)
  {
    if( grr_data->tc.v_sb_without_tbf )
    {
      result = E_UL_ASSIGN_SB_WITHOUT_TBF;
    }
    else
    {
      result = E_UL_ASSIGN_SB_2PHASE_ACCESS ;
      grr_data->uplink_tbf.ti = 0;
    }

    /*
     *   estimate timeslot
     */
    grr_data->uplink_tbf.ts_usage = (0x80 >> d_ul_assign->sin_alloc.tn);
    tx_slots=1;
    grr_data->uplink_tbf.nts = tx_slots;

    if(d_ul_assign->sin_alloc.v_alf_gam)
    {
      grr_store_type = GRR_STORE_TYPE_ALF_GAM;
    }

    /* starting time allready elapsed? */
    if(d_ul_assign->sin_alloc.tbf_s_time.v_abs)
    {
      ULONG fn_out;
      fn_out = grr_decode_tbf_start_abs(&d_ul_assign->sin_alloc.tbf_s_time.abs);           
      TRACE_EVENT_P5("eval_ul fn_out:%ld fn_in:%d %d %d data->fn:%ld",
                                                                 fn_out,
                                                                 d_ul_assign->sin_alloc.tbf_s_time.abs.t1,
                                                                 d_ul_assign->sin_alloc.tbf_s_time.abs.t2,
                                                                 d_ul_assign->sin_alloc.tbf_s_time.abs.t3,
                                                                 grr_data->dl_fn);
      if(grr_check_if_tbf_start_is_elapsed ( fn_out, grr_data->ul_fn))
      {
        TRACE_ERROR("TBF Starting time is ELAPSED in single block allocation!");
        TRACE_EVENT_P2("CPAP SBR TBF ST ELAPSED st=%ld  c_fn=%ld  ", fn_out,grr_data->ul_fn);
        result = E_UL_ASSIGN_ERROR_RA;
      }
    }
    else if(d_ul_assign->sin_alloc.tbf_s_time.v_rel AND !d_ul_assign->sin_alloc.tbf_s_time.rel)
    {
      TRACE_ERROR("rel. TBF Starting time in single block allocation k=0 NOT ALLOWED");
      TRACE_EVENT_P1("k=%d ", d_ul_assign->sin_alloc.tbf_s_time.rel);
      result = E_UL_ASSIGN_ERROR_RA;
    }
    else if(!d_ul_assign->sin_alloc.tbf_s_time.v_rel)
    {
      TRACE_ERROR("NO TBF Starting time in single block allocation ");
      TRACE_EVENT_P2("v_abs=%d  v_rel=%d ", d_ul_assign->sin_alloc.tbf_s_time.v_abs
                                          , d_ul_assign->sin_alloc.tbf_s_time.v_rel);
      result = E_UL_ASSIGN_ERROR_RA;
    }
  }
  else if(d_ul_assign->v_f_alloc_ul)
  {
    if( grr_data->uplink_tbf.mac_mode EQ DA )
    {
      result = E_UL_ASSIGN_ERROR_RA;
      TRACE_ERROR("fixed alloc received while dynamic is running in uplink");
    }
    else
    {
      result = E_UL_ASSIGN_FIXED;
      grr_data->uplink_tbf.ts_usage = 0;
      tx_slots=0;
      if(d_ul_assign->f_alloc_ul.v_ts_alloc)
      {
        grr_data->uplink_tbf.ts_usage = d_ul_assign->f_alloc_ul.ts_alloc;
        /*calculate number of timeslots*/
        tx_slots = grr_calc_nr_of_set_bits(grr_data->uplink_tbf.ts_usage);
      }
      else if(d_ul_assign->f_alloc_ul.v_pwr_par)
      {
        for(i = 0,mask = 0x80;i < 8;i++)
        {
          if(d_ul_assign->f_alloc_ul.pwr_par.gamma_tn[i].v_gamma)
          {
            grr_data->uplink_tbf.ts_usage |= mask;
            tx_slots++;
          }
          mask >>= 1;
        }

        grr_store_type = GRR_STORE_TYPE_PWR_PAR;
      }
      grr_data->uplink_tbf.nts = tx_slots;
    }
  }
  else
  {
    TRACE_ERROR ("Packet Uplink Assignment without allocation type - corrupt airmessage!");
  }

  if( !handle_ms_cap(UL_ASSIGNMENT) )
  {
    result = E_UL_ASSIGN_ERROR_RA;
    TRACE_EVENT("tc_eval_.. will return E_UL_ASSIGN_ERROR_RA (tx_slots wrong)");
  }

  if ( !tc_check_and_save_freq ())
  {
    if ((grr_data->tbf_type EQ CGRLC_TBF_MODE_DL) OR (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL) )
    {
      result = E_UL_ASSIGN_IGNORE;
      TRACE_EVENT("tc_eval_.. will return E_UL_ASSIGN_IGNORE , DL ACTIVE (frequencies wrong)");		   
    }
    else
    {
      result = E_UL_ASSIGN_ERROR_RA;
      TRACE_EVENT("tc_eval_.. will return E_UL_ASSIGN_ERROR_RA (frequencies wrong)");	
    }
    return result;
  } 

  if( result NEQ E_UL_ASSIGN_ERROR_RA AND
      result NEQ E_UL_ASSIGN_NULL         )
  {
    switch( grr_store_type )
    {
      case GRR_STORE_TYPE_TN_ALLOC_PWR:
        grr_store_type_tn_alloc_pwr( &d_ul_assign->dyn_alloc_p.tn_alloc_pwr );
        break;

      case GRR_STORE_TYPE_ALF_GAM:
        grr_store_type_alf_gam( &d_ul_assign->sin_alloc.alf_gam,
                                 d_ul_assign->sin_alloc.tn       );
        break;
      
      case GRR_STORE_TYPE_PWR_PAR:
        grr_store_type_pwr_par( &d_ul_assign->f_alloc_ul.pwr_par, FALSE );
        break;
      
      default: 
        /* do nothing */
        break;
    }
  }

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



/*
+------------------------------------------------------------------------------
| Function    : tc_eval_dl_assign
+------------------------------------------------------------------------------
| Description : The function tc_eval_dl_assign() evaluates a
|               Packet Downlink Assignment.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL T_EVAL_DL_ASSIGN tc_eval_dl_assign ()
{
  MCAST(d_dl_assign,D_DL_ASSIGN); /* T_D_DL_ASSIGN */
  T_EVAL_DL_ASSIGN result = E_DL_ASSIGN_IGNORE;

  TRACE_FUNCTION( "tc_eval_dl_assign" );

  /* SZML-TC/072: check for things that results in E_DL_ASSIGN_ERROR_RA */


     
  grr_data->downlink_tbf.ctrl_ack_bit= 0;   

  /*
   * compare uplink and new assigned downlink mac mode 
   * and set downlink mac mode
   */ 
  switch( grr_data->tbf_type )
  {
    case CGRLC_TBF_MODE_NULL:
      grr_data->downlink_tbf.mac_mode    = d_dl_assign->mac_mode;
      grr_data->downlink_tbf.t3192       = FALSE;                      /* indicates if t3192 is running*/
      grr_data->downlink_tbf.rlc_mode    = d_dl_assign->rlc_mode;

      result = E_DL_ASSIGN;
      break;
    case CGRLC_TBF_MODE_UL:
      grr_data->downlink_tbf.mac_mode    = d_dl_assign->mac_mode;
      grr_data->downlink_tbf.t3192       = FALSE;                      /* indicates if t3192 is running*/
      grr_data->downlink_tbf.rlc_mode    = d_dl_assign->rlc_mode;

      /*lint -fallthrough*/
    case CGRLC_TBF_MODE_DL_UL:
      if(d_dl_assign->mac_mode NEQ grr_data->uplink_tbf.mac_mode)
      {
        result = E_DL_ASSIGN_IGNORE;
        TRACE_EVENT_P2("Ignore DL_ASS, Diff MAC Mode UL=%d DL=%d ",grr_data->uplink_tbf.mac_mode,d_dl_assign->mac_mode);
        return result;
      }
      if ((grr_data->downlink_tbf.rlc_mode NEQ d_dl_assign->rlc_mode) AND !d_dl_assign->ctrl_ack)
      {
        TRACE_ERROR("Diff rlc mode in downlink ass..aborting tbf");
        result = E_DL_ASSIGN_ABORT_DL;
        return result;
      }
      grr_data->downlink_tbf.rlc_mode    = d_dl_assign->rlc_mode;
      result = E_DL_ASSIGN;
      break;
    case CGRLC_TBF_MODE_DL:
      if ((grr_data->downlink_tbf.rlc_mode NEQ d_dl_assign->rlc_mode) AND !d_dl_assign->ctrl_ack)
      {
        TRACE_ERROR("Diff rlc mode in downlink ass..aborting tbf");
        result = E_DL_ASSIGN_ABORT_DL;
        return result;
      }
      grr_data->downlink_tbf.rlc_mode    = d_dl_assign->rlc_mode;
      result = E_DL_ASSIGN;
      break;
    default:
      result = E_DL_ASSIGN;
      break;
  } 

  /*
   * compare old and new mac mode for downlink
   */ 
  if ( d_dl_assign->mac_mode EQ  FA_HALF_DUPLEX)
  {
    result = E_DL_ASSIGN_IGNORE;
    TRACE_EVENT( "DL ASS: Half duplex not supported" );
    return result;
  } 
  else if(d_dl_assign->mac_mode NEQ  grr_data->downlink_tbf.mac_mode)
  {
    result = E_DL_ASSIGN_IGNORE;
    TRACE_EVENT_P3( "DL ASS: current mac mode= %d differs from commanded =%d  tbf_type=%d"
                                                                ,grr_data->downlink_tbf.mac_mode
                                                                ,d_dl_assign->mac_mode
                                                                ,grr_data->tbf_type );
    return result;
  }


  /* 
   * ckeck if tfi is present while no downlink tbf is active
   */
  switch( grr_data->tbf_type )
  {
    case CGRLC_TBF_MODE_UL:
    case CGRLC_TBF_MODE_NULL:
      if(!d_dl_assign->pda_trnc_grp.v_dl_tfi_assign)
      {
        result = E_DL_ASSIGN_IGNORE;
        TRACE_EVENT("Ignore DL_ASS, no dl_tfi in P DL Ass(no dl tbf active) ");
        return result;
      }
      result = E_DL_ASSIGN;
      break;
    default:
      result = E_DL_ASSIGN;
      break;
  } 


  if(d_dl_assign->ctrl_ack)
  {
    if(grr_data->downlink_tbf.t3192)
    {
      grr_data->downlink_tbf.ctrl_ack_bit= 1;   
      grr_data->downlink_tbf.t3192    = FALSE;                      /* indicates if t3192 is running*/

    }
    else
    {
      result = E_DL_ASSIGN_IGNORE;
      TRACE_EVENT("DL ASS IGNORED, ctrl ack bit set but t3192 is not running");
      return result;
    }
  }
  else if(grr_data->downlink_tbf.t3192)
  {
    TRACE_EVENT("DL assignment:ctrl ack bit is not set but t3192 is running");
  }

  grr_data->downlink_tbf.ts_usage = d_dl_assign->ts_alloc;
  grr_data->downlink_tbf.nts      = grr_calc_nr_of_set_bits(grr_data->downlink_tbf.ts_usage);
  if( !handle_ms_cap(DL_ASSIGNMENT))
  {
    result = E_DL_ASSIGN_ERROR_RA;
    TRACE_EVENT("tc_eval_.. will return E_DL_ASSIGN_ERROR_RA (ms class error)");
    return result;
  }

  if( tc_check_and_save_freq( ) EQ FALSE )
  {
    if ((grr_data->tbf_type EQ CGRLC_TBF_MODE_UL) OR (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL))
    {
      result = E_DL_ASSIGN_IGNORE;
      TRACE_EVENT("tc_eval_.. will return E_DL_ASSIGN_IGNORE , UL ACTIVE (frequencies wrong)");
    }
    else
    {
      result = E_DL_ASSIGN_ERROR_RA;
      TRACE_EVENT("tc_eval_.. will return E_DL_ASSIGN_ERROR_RA (frequencies wrong)");
    }
    return result;
  }

  if( d_dl_assign->pda_trnc_grp.v_pwr_par EQ TRUE )
  {
    grr_store_type_pwr_par( &d_dl_assign->pda_trnc_grp.pwr_par, FALSE );
  }

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



/*
+------------------------------------------------------------------------------
| Function    : tc_eval_access_rej
+------------------------------------------------------------------------------
| Description : The function tc_eval_access_rej() evaluates a
|               Packet Access Reject.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL T_EVAL_ACCESS_REJ tc_eval_access_rej ( ULONG * t3172_value_i)
{
  MCAST(d_access_rej,D_ACCESS_REJ);
  T_EVAL_ACCESS_REJ result = E_ACCESS_REJ_NULL;

  TRACE_FUNCTION( "tc_eval_access_rej" );
  /*SZML-TC/122*/

  if(d_access_rej->reject.v_wait)
  {
    result = E_ACCESS_REJ_WAIT;

    *t3172_value_i = d_access_rej->reject.wait.wait_ind;
    if( d_access_rej->reject.wait.waitsize  )
    {
      *t3172_value_i *= 20;
    }
    else
    {
      *t3172_value_i *= 1000;
    }
  }
  else
  {
    result = E_ACCESS_REJ_NO_WAIT;
  }

  return(result);

} /* tc_eval_access_rej() */



/*
+------------------------------------------------------------------------------
| Function    : tc_send_ra_req
+------------------------------------------------------------------------------
| Description : The function tc_send_ra_req() starts the build-process for a
|               Packet Access Request and send a MPHP_RA_REQ.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_send_ra_req ( void )
{
  TRACE_FUNCTION( "tc_send_ra_req" );


  while( (grr_data->tc.n_acc_req < 
          max_retrans_table[psc_db->prach.max_retrans[grr_data->uplink_tbf.prio]]+1)
         AND (tc_check_p_level() EQ C_P_LEVEL_DO_NOT_SEND) )
  {
    TRACE_EVENT("C_P_LEVEL_DO_NOT_SEND");
    grr_data->tc.n_acc_req++;
  }


  if (grr_data->tc.n_acc_req < 
    max_retrans_table[psc_db->prach.max_retrans[grr_data->uplink_tbf.prio]]+1)
  {
    PALLOC(mphp_ra_req,MPHP_RA_REQ);
    memset(mphp_ra_req,0x00,sizeof(T_MPHP_RA_REQ));
    /*
     * The powervalue txpwr_max_cch in DB is always a useful value.
     * The value is set by PSI. First a useful initial value.
     * After that a value from RR and after reception of PSI3 txpwr_max_cch
     * is set to a value from the scell-structure.
     */

    mphp_ra_req->txpwr = 
      grr_get_ms_txpwr_max_cch
        ( psc_db->pbcch.bcch.arfcn,
          grr_data->meas.pwr_offset, 
          psc_db->scell_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch );

    if(grr_data->tc.sending_req EQ TRUE)
    {
      mphp_ra_req->rand               = (USHORT)tc_gen_rand();
    }
    else 
    {
      /* The first PCR may be sent immediately when ready. Only the second PCR   */
      /* needs a random value which has to have uniform probability distribution */
      mphp_ra_req->rand               = 1;
    }
    mphp_ra_req->channel_request_data = tc_calc_req();
    mphp_ra_req->bs_prach_blks        = psc_db->pccch.bs_prach_blks;  
    mphp_ra_req->burst_type           = psc_db->gprs_cell_opt.ab_type;

    {
      UBYTE channel_request_data[RLC_MAC_MAX_LEN_CHANNEL_REQ];

      channel_request_data[0] = ( mphp_ra_req->channel_request_data >> 8 );
      channel_request_data[1] = ( UBYTE )mphp_ra_req->channel_request_data;
      
      TRACE_BINDUMP
        ( hCommGRR, TC_USER4, 
          cl_rlcmac_get_msg_name( U_MSG_TYPE_CHANNEL_REQ_c, RLC_MAC_ROUTE_UL ),
          channel_request_data, RLC_MAC_MAX_LEN_CHANNEL_REQ ); /*lint !e569*/
    }

    PSEND(hCommL1,mphp_ra_req);
    grr_data->tc.sending_req = TRUE;
  }
  else 
  {
    vsi_t_start(GRR_handle,T3170,tc_get_t3170_value());
    vsi_t_stop(GRR_handle,T3186);
    tc_send_ra_stop_req();

  }


} /* tc_send_ra_req() */



/*
+------------------------------------------------------------------------------
| Function    : tc_send_ra_stop_req
+------------------------------------------------------------------------------
| Description : The function tc_send_ra_stop_req() stops the
|               sending of packet access requests.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_send_ra_stop_req ( void )
{
  TRACE_FUNCTION( "tc_send_ra_stop_req" );

  /*
   *  This timer might be run - in case of MPHP_RA_CON has not been received by GRR.
   *  If it does not run the stop-command will be ignored by vsi.
   */
  vsi_t_stop(GRR_handle,T3186);

  if(grr_data->tc.sending_req)
  {
    PALLOC(mphp_ra_stop_req,MPHP_RA_STOP_REQ);
    PSEND(hCommL1,mphp_ra_stop_req); 
      /*
       *   reset number of access in this procedure
       */
    grr_data->tc.n_acc_req =0;
        
    /*
     * to make sure that TC only stops
     * the sending procedure if it
     * is running
     */
    grr_data->tc.sending_req = FALSE;
  }

} /* tc_send_ra_stop_req() */



/*
+------------------------------------------------------------------------------
| Function    : tc_send_polling_res
+------------------------------------------------------------------------------
| Description : The function tc_send_polling_res() sends the primitive
|               MPHP_POLLING_RESPONSE_REQ.
|
| Parameters  : ctrl_ack_type_i - indicates if normal or access burst shall sent
|               rrbp_i - depending on this variable the send frame number is computed
|               fn_i   - frame number where Packet Polling Request was received
|               ctrl_ack_i - this value is sent within the pca, depends frim mac header
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_send_polling_res (UBYTE poll_type_i, ULONG fn_i, UBYTE rrbp_i,UBYTE ctrl_ack_i )
{
  PALLOC( mphp_polling_response_req, MPHP_POLLING_RESPONSE_REQ );

  TRACE_FUNCTION( "tc_send_polling_res" );

  mphp_polling_response_req->fn    = grr_calc_new_poll_pos( fn_i, rrbp_i );

  mphp_polling_response_req->txpwr =
    grr_get_ms_txpwr_max_cch 
      ( psc_db->pbcch.bcch.arfcn,
        grr_data->meas.pwr_offset, 
        psc_db->scell_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch );

  if(poll_type_i EQ CGRLC_POLL_RES_NB)
  {
    mphp_polling_response_req->poll_resp_type = POLL_RESP_NB_CS1;
    memset( mphp_polling_response_req->poll_data,
            0x2b,
            sizeof(mphp_polling_response_req->poll_data) );    
    mphp_polling_response_req->poll_data[23] = 0 ; /* Byte is not used, set to 0 for test purposes */

    /* code without CCD, air message buffer is used by other service*/
    mphp_polling_response_req->poll_data[0] = 0x40 | grr_data->r_bit;
    mphp_polling_response_req->poll_data[1] = 0x04 |((UBYTE)(grr_data->db.ms_id.new_tlli>>30));
    mphp_polling_response_req->poll_data[2] = ((UBYTE)(grr_data->db.ms_id.new_tlli>>22));
    mphp_polling_response_req->poll_data[3] = ((UBYTE)(grr_data->db.ms_id.new_tlli>>14));
    mphp_polling_response_req->poll_data[4] = ((UBYTE)(grr_data->db.ms_id.new_tlli>>06));
    mphp_polling_response_req->poll_data[5] = ((UBYTE)(grr_data->db.ms_id.new_tlli<<2)) + ctrl_ack_i;
  
    /*
     * get TA from paxket uplink/downlink assignment
     */
    if(grr_data->ta_params.ta_value EQ 0xFF)
    {
      MCAST( d_ul_assign, D_UL_ASSIGN );
      MCAST( d_dl_assign, D_DL_ASSIGN);

      if(( d_dl_assign->msg_type EQ D_DL_ASSIGN_c) AND
           d_dl_assign->pta.v_ta_value)
           
      {
        mphp_polling_response_req->ta_index = d_dl_assign->pta.ta_value;
      }
      else if(( d_ul_assign->msg_type EQ D_UL_ASSIGN_c) AND
                d_ul_assign->pta.v_ta_value)
      {
        mphp_polling_response_req->ta_index = d_ul_assign->pta.ta_value;
      }
      else
      {
        TRACE_ERROR("NO TA IN MPHP_POLLING_REQ");
        TRACE_EVENT_P5("msg_typ=%d, v_pta_dl=%d v_pta_ul=%d v_ptai_dl=%d v_ptai_ul=%d"
                                                                                       ,d_ul_assign->msg_type
                                                                                       ,d_dl_assign->pta.v_ta_value
                                                                                       ,d_ul_assign->pta.v_ta_value
                                                                                       ,d_dl_assign->pta.v_ta_index_tn
                                                                                       ,d_ul_assign->pta.v_ta_index_tn);
      }

    }
    else
    {
      mphp_polling_response_req->ta_index     = grr_data->ta_params.ta_value;
      TRACE_EVENT_P1("valid ta in database at sending MPHP_POLLING_RES_REQ ta=%d",grr_data->ta_params.ta_value);
    }

    TRACE_BINDUMP
      ( hCommGRR, TC_USER4,
        cl_rlcmac_get_msg_name
          ( ( UBYTE )( mphp_polling_response_req->poll_data[1] >> 2 ), RLC_MAC_ROUTE_UL ),
        mphp_polling_response_req->poll_data, MAX_L2_FRAME_SIZE ); /*lint !e569*/
  }
  else
  {
    USHORT data;

    /*
     * initalize channel request data array
     */   
    memset( mphp_polling_response_req->poll_data,
            0,
            sizeof(mphp_polling_response_req->poll_data) );

    /*
     * format is four access bursts
     */
    if(psc_db->gprs_cell_opt.ab_type EQ AB_8_BIT)
    {
      /*
       *  8 Bit access burst
       */
      mphp_polling_response_req->poll_resp_type =  POLL_RESP_AB_8_BIT;
      data =0x0000;
      data|=0x7f;
      /*TRACE_EVENT_P1("POLL_RESP_8BIT_AB: FN %Ld", mphp_polling_response_req->fn);*/
    }
    else
    {
      /*
       *  11 Bit access burst
       */

      mphp_polling_response_req->poll_resp_type = POLL_RESP_AB_11_BIT;
      data = (0x07<<8);
      data|=0xe7;

      data = grr_convert_11bit_2_etsi(data);
      /*TRACE_EVENT_P1("POLL_RESP_11BIT_AB: FN %Ld", mphp_polling_response_req->fn);*/
    }

    mphp_polling_response_req->poll_data[0]= (UBYTE)(data & 0x00ff);        
    mphp_polling_response_req->poll_data[1]= (UBYTE)((data & 0xff00) >> 8);

    TRACE_BINDUMP
      ( hCommGRR, TC_USER4,
        cl_rlcmac_get_msg_name( U_MSG_TYPE_CHANNEL_REQ_c, RLC_MAC_ROUTE_UL ),
        mphp_polling_response_req->poll_data,
        RLC_MAC_MAX_LEN_CHANNEL_REQ ); /*lint !e569*/
  }

  PSEND( hCommL1, mphp_polling_response_req );

} /* tc_send_polling_res() */



/*
+------------------------------------------------------------------------------
| Function    : tc_send_single_block
+------------------------------------------------------------------------------
| Description : The function tc_send_single_block() sends the primitive
|               MPHP_SINGLE_BLOCK_REQ with measurement report.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_send_single_block ( void )
{
  MCAST(d_ul_assign,D_UL_ASSIGN);
  T_MPHP_SINGLE_BLOCK_REQ * ptr2prim;

  TRACE_FUNCTION( "tc_send_single_block" );

  ptr2prim = tc_get_send_nb_prim_and_set_freq( );

  ptr2prim->assign_id    = 0;
  ptr2prim->purpose      = SINGLE_BLOCK_TRANSFER_UL;
  ptr2prim->pc_meas_chan = psc_db->g_pwr_par.pc_meas_chan;
  ptr2prim->burst_type   = ( psc_db->gprs_cell_opt.ab_type EQ AB_8_BIT )
                           ? AB_8_BIT : AB_11_BIT;
  /* timing advance */
  if (d_ul_assign->pta.v_ta_value)
  {
    ptr2prim->p_timing_advance.ta_value = d_ul_assign->pta.ta_value;
  }
  else
  {
    ptr2prim->p_timing_advance.ta_value = 0xff;
  }

  if(d_ul_assign->pta.v_ta_index_tn)
  {
    ptr2prim->p_timing_advance.ta_index = d_ul_assign->pta.ta_index_tn.ta_index;
  }
  else
  {
    ptr2prim->p_timing_advance.ta_index = 0xff;
  }

  /*  trainings sequence   */
  ptr2prim->tsc = d_ul_assign->freq_par.tsc;

  /* handle TBF starting time (is always present in single block allocation) */
  if(d_ul_assign->sin_alloc.tbf_s_time.v_abs)
  {
    ptr2prim->p_tbf_start.tbf_start_present  = 1; 
    ptr2prim->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ul_assign->sin_alloc.tbf_s_time.abs);
    if(grr_check_if_tbf_start_is_elapsed ( ptr2prim->p_tbf_start.fn, grr_data->ul_fn))
    { /* SZML-TC/077: drop message, enter pim  */
      TRACE_ERROR("TBF Starting time is ELAPSED in single block allocation!");
      TRACE_EVENT_P2("CPAP SBR TBF ST ELAPSED st=%ld  c_fn=%ld  ", ptr2prim->p_tbf_start.fn,grr_data->ul_fn);      
    }
  }
  else if (d_ul_assign->sin_alloc.tbf_s_time.v_rel)
  {
    ptr2prim->p_tbf_start.tbf_start_present  = 1;         
    /* 
     * For the relative position set d_ul_assign->sin_alloc.tbf_s_time.rel-1, because grr_data->fn is
     * received from mphp_data_ind. This fn is the current fn, and not the received fn.
     */
    ptr2prim->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn,
                                                        (USHORT)(d_ul_assign->sin_alloc.tbf_s_time.rel));
  }
  else
  {
    TRACE_ERROR("TBF Starting time is missing in single block allocation!");
      /* SZML-TC/078:  drop message, enter pim  !  */
  }

  /* timeslot number */
  ptr2prim->tn=d_ul_assign->sin_alloc.tn;

  /* put measurement report into buffer */
  tc_cpy_ctrl_blk_to_buffer( ptr2prim->l2_frame );
  
  sig_tc_meas_update_pch( );

  TRACE_BINDUMP
    ( hCommGRR, TC_USER4,
      cl_rlcmac_get_msg_name
        ( ( UBYTE )( ptr2prim->l2_frame[1] >> 2 ), RLC_MAC_ROUTE_UL ),
      ptr2prim->l2_frame, MAX_L2_FRAME_SIZE ); /*lint !e569*/
  
  PSEND(hCommL1,ptr2prim);
} /* tc_send_single_block() */



/*
+------------------------------------------------------------------------------
| Function    : tc_send_resource_request_p
+------------------------------------------------------------------------------
| Description : The function tc_send_resource_request_p() sends the primitive
|               MPHP_SINGLE_BLOCK_REQ with Packet Resource Request for
|               two phase access due to reception of airmessage packet uplink
|               assignment.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_send_resource_request_p ( void )
{
  MCAST(d_ul_assign,D_UL_ASSIGN);

  T_MPHP_SINGLE_BLOCK_REQ * ptr2prim;

  TRACE_FUNCTION( "tc_send_resource_request_p" );


  ptr2prim = tc_get_send_nb_prim_and_set_freq( );

  /*
   *   mark that single block is because of two phase access procedure
   */
  ptr2prim->assign_id    = 0;
  ptr2prim->purpose      = TWO_PHASE_ACESS;
  ptr2prim->pc_meas_chan = psc_db->g_pwr_par.pc_meas_chan;
  ptr2prim->burst_type   = (psc_db->gprs_cell_opt.ab_type EQ AB_8_BIT)
                           ?AB_8_BIT
                           :AB_11_BIT;

  if (d_ul_assign->pta.v_ta_value)
  {
    ptr2prim->p_timing_advance.ta_value = d_ul_assign->pta.ta_value;
  }
  else
  {
    ptr2prim->p_timing_advance.ta_value = 0xff;
  }

  if(d_ul_assign->pta.v_ta_index_tn)
  {
    ptr2prim->p_timing_advance.ta_index =d_ul_assign->pta.ta_index_tn.ta_index;
  }
  else
  {
    ptr2prim->p_timing_advance.ta_index =0xff;
  }

  /*
   *  trainings sequence
   */
  ptr2prim->tsc = d_ul_assign->freq_par.tsc;


 /*
  * handle TBF starting time
  * is always present in single block allocation
  */
  if(d_ul_assign->sin_alloc.tbf_s_time.v_abs)
  {
    ptr2prim->p_tbf_start.tbf_start_present = 1; 
    ptr2prim->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ul_assign->sin_alloc.tbf_s_time.abs);
    if(grr_check_if_tbf_start_is_elapsed ( ptr2prim->p_tbf_start.fn, grr_data->ul_fn))
    { /* SZML-TC/079 */
      TRACE_ERROR("TBF Starting time is ELAPSED in single block allocation!");
      TRACE_EVENT_P2("CPAP SBR TBF ST ELAPSED st=%ld  c_fn=%ld  ", ptr2prim->p_tbf_start.fn,grr_data->ul_fn);
    }
    TRACE_EVENT_P5("res_req fn_out:%ld fn_in:%d %d %d data->fn:%ld",
                                                                ptr2prim->p_tbf_start.fn,
                                                                d_ul_assign->sin_alloc.tbf_s_time.abs.t1,
                                                                d_ul_assign->sin_alloc.tbf_s_time.abs.t2,
                                                                d_ul_assign->sin_alloc.tbf_s_time.abs.t3,
                                                                grr_data->dl_fn);
  }
  else if (d_ul_assign->sin_alloc.tbf_s_time.v_rel)
  {
    ptr2prim->p_tbf_start.tbf_start_present   = 1;
    /* 
     * For the relative position set d_ul_assign->sin_alloc.tbf_s_time.rel-1, because grr_data->fn is
     * received from mphp_data_ind. This fn is the current fn, and not the received fn.
     */
    ptr2prim->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn, 
                                                       (USHORT)(d_ul_assign->sin_alloc.tbf_s_time.rel));
    TRACE_EVENT_P3("REL: ST_TIME for PRR:  fn_i=%ld rel=%ld fn_out=%ld"
                                                                       ,grr_data->dl_fn
                                                                       ,d_ul_assign->sin_alloc.tbf_s_time.rel
                                                                       ,ptr2prim->p_tbf_start.fn);
  }
  else
  {
    TRACE_ERROR("TBF Starting time is missing in single block allocation!");
  }

  ptr2prim->tn = d_ul_assign->sin_alloc.tn;

  {
    T_U_RESOURCE_REQ resource_req;

    tc_build_res_req( &resource_req,
                      R_BUILD_2PHASE_ACCESS,
                      SRC_TBF_INFO_UL_ASSIGN );

    grr_encode_ul_ctrl_block( ptr2prim->l2_frame, ( UBYTE* )&resource_req );
  }

  sig_tc_meas_update_pch( );

  TRACE_BINDUMP
    ( hCommGRR, TC_USER4,
      cl_rlcmac_get_msg_name
        ( ( UBYTE )( ptr2prim->l2_frame[1] >> 2 ), RLC_MAC_ROUTE_UL ),
      ptr2prim->l2_frame, MAX_L2_FRAME_SIZE ); /*lint !e569*/

  PSEND(hCommL1,ptr2prim);

  return;

} /* tc_send_resource_request_p() */


/*
+------------------------------------------------------------------------------
| Function    : tc_handle_ra_con
+------------------------------------------------------------------------------
| Description : The function tc_handle_ra_con() checks wheather there is to send
|               another Packet Access Request or not.
|
| Parameters  : void
+------------------------------------------------------------------------------
*/
GLOBAL T_HANDLE_RA_CON tc_handle_ra_con ( void )
{
  T_HANDLE_RA_CON result;
  UBYTE max_retrans;
  TRACE_FUNCTION( "tc_handle_ra_con" );


  /*
   *  stop T3186 becauce packet access request was sent
   */


  /*
   *  get current max. retransmissson value
   */
  max_retrans
    = max_retrans_table[psc_db->prach.max_retrans[grr_data->uplink_tbf.prio]];

  if(grr_data->tc.n_acc_req >= max_retrans + 1) 
  {
    result = H_RA_CON_STOP_REQ;
    vsi_t_start(GRR_handle,T3170,tc_get_t3170_value());
    vsi_t_stop(GRR_handle,T3186);
  }
  else
  {
    result = H_RA_CON_CONTINUE;
  }


  return(result);

} /* tc_handle_ra_con() */







/*
+------------------------------------------------------------------------------
| Function    : tc_init
+------------------------------------------------------------------------------
| Description : The function tc_init() initialize the TC data structure.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_init ( void )
{
  UBYTE i;

  TRACE_FUNCTION( "tc_init" );

  /*
   *  set some values
   */
  grr_data->tc.disable_callback_func = NULL;
  grr_data->tc.disable_class         = CGRLC_DISABLE_CLASS_CR;
  grr_data->tbf_type                 = CGRLC_TBF_MODE_NULL;
  grr_data->tc.dcch_present          = FALSE;
  grr_data->tc.v_freq_set            = FALSE;

  /*
   * values for fixed alloc
   */
  grr_data->tc.fa_ctrl.fa_type       = FA_NO_CURRENT;
  grr_data->tc.fa_ctrl.repeat_alloc  = FALSE;
  grr_data->tc.fa_ctrl.ts_overr      = 0;

  grr_data->tc.num_of_rels_running   = 0;

  /* initialize the relevant data for uplink control block */
  grr_data->tc.v_sb_without_tbf      = FALSE;

  grr_data->tc.ul_ctrl_blk.seq[0]    = MAX_CTRL_BLK_NUM;

  for( i = 0; i < MAX_CTRL_BLK_NUM; i++ )
  {
    grr_data->tc.ul_ctrl_blk.blk[i].state = BLK_STATE_NONE;
    grr_data->tc.ul_ctrl_blk.blk[i].owner = CGRLC_BLK_OWNER_NONE;
  }

  grr_data->tc.two_2p_w_4_tbf_con           = TRUE;


  grr_data->tc.two_2p_w_4_tbf_con    = TRUE;

  /*
   * Initialise service name (uses define SERVICE_NAME_* in GRR.H);
   */

  INIT_STATE(TC,TC_ACCESS_DISABLED);
  /*
   *  initialize primitive queue
   */

  grr_data->tc.p_assign = NULL;

  grr_data->uplink_tbf.ts_mask    = 0;
  grr_data->uplink_tbf.ts_usage   = 0;
  grr_data->downlink_tbf.ts_mask  = 0;
  grr_data->downlink_tbf.ts_usage = 0;
  grr_data->tc.n_acc_req          = 0;

#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
  grr_data->tc.tbf_est_pacch = FALSE;
#endif

} /* tc_init() */





/*
+------------------------------------------------------------------------------
| Function    : tc_handle_error_pim
+------------------------------------------------------------------------------
| Description : The function tc_handle_error_pim() ...
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_handle_error_pim ( void )
{
  TRACE_FUNCTION( "tc_handle_error_pim" );
  TRACE_EVENT( "tc_handle_error_pim" );
  
  if( grr_data->tc.v_sb_without_tbf )
  {
    tc_set_stop_ctrl_blk( FALSE, CGRLC_BLK_OWNER_NONE, 0 );
    
      tc_cgrlc_access_status_req();
    }
  else
  {
      tc_cgrlc_ul_tbf_res ( CGRLC_TBF_MODE_ESTABLISHMENT_FAILURE, CGRLC_PRIM_STATUS_ONE );
    }
  
} /* tc_handle_error_pim() */

/*
+------------------------------------------------------------------------------
| Function    : tc_handle_error_ra
+------------------------------------------------------------------------------
| Description : The function tc_handle_error_ra() handles actions related
|               to errors that leads to randam access procedure
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_handle_error_ra ( void )
{
  TRACE_FUNCTION( "tc_handle_error_ra" );


  /*
   * - called in case of contention resulution failed in RU
   * - t3168 expires contention resulution failed in 2P-Access
   * - If the mobile station has been assigned more PDCHs than it supports according
   *  to its MS multislot class, the mobile station shall reinitiate the packet access
   *  procedure unless it has already been repeated 4 times. In that
   *  case, TBF failure has occurred.
   */

  /*
   *  cancel access procedure if running
   */
  if(grr_is_pbcch_present() 
#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
      AND !grr_data->tc.tbf_est_pacch
#endif
    )
  {
    tc_send_ra_stop_req();
  }

  /*
   *  Kill TBF if running
   */
  tc_abort_tbf(grr_data->tbf_type);

  SET_STATE(TC,TC_PIM);



} /* tc_handle_error_ra() */

/*
+------------------------------------------------------------------------------
| Function    : tc_activate_tbf
+------------------------------------------------------------------------------
| Description : The function tc_activate_tbf() set the assigned TBF
|               into the data structures
|
| Parameters  : tbf_type_i - type of TBF to deactivate
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_activate_tbf ( T_TBF_TYPE tbf_type_i )
{
  TRACE_FUNCTION( "tc_activate_tbf" );

  /*
   *  Reset of n_acc_req_procedures because of the fact that number of
   *  access procedures during pacet access procedures must not considered in
   *  a error with random access occured during running TBF.
   */
 /* grr_data->tc.n_acc_req_procedures = 0;*/

  switch( tbf_type_i )
  {

  case CGRLC_TBF_MODE_UL:
    switch( grr_data->tbf_type )
    {
    case CGRLC_TBF_MODE_DL:
      grr_data->tbf_type = CGRLC_TBF_MODE_DL_UL;
      break;
    case CGRLC_TBF_MODE_NULL:
#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
    case CGRLC_TBF_MODE_2PA:
#endif
      grr_data->tbf_type = CGRLC_TBF_MODE_UL;
      break;
    default:
      break;
    }
    break;

  case CGRLC_TBF_MODE_DL:
    switch( grr_data->tbf_type )
    {
    case CGRLC_TBF_MODE_UL:
      grr_data->tbf_type = CGRLC_TBF_MODE_DL_UL;
      break;
    case CGRLC_TBF_MODE_NULL:
      grr_data->tbf_type = CGRLC_TBF_MODE_DL;
      break;
    default:
      break;
    }
    break;
  case CGRLC_TBF_MODE_DL_UL:
    switch( grr_data->tbf_type )
    {
    case CGRLC_TBF_MODE_UL:
    case CGRLC_TBF_MODE_DL:
    case CGRLC_TBF_MODE_DL_UL:
      grr_data->tbf_type = CGRLC_TBF_MODE_DL_UL;
      break;
    default:
      {
        TRACE_ERROR("FATAL ERROR: tc_activate_tbf called with wrong tbf_type");
      }
      break;
    }
    break;
#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
  case CGRLC_TBF_MODE_2PA:
    switch( grr_data->tbf_type )
    {
      case  CGRLC_TBF_MODE_UL:
        if (grr_data->tc.tbf_est_pacch)
        {
          grr_data->tbf_type = CGRLC_TBF_MODE_2PA;
        }
        else
        {
          TRACE_ERROR("FATAL ERROR: tc_activate_tbf called with wrong tbf_type");
        }
        break;
    
      default:
        TRACE_ERROR("FATAL ERROR: tc_activate_tbf called with wrong tbf_type:CGRLC_TBF_MODE_2PA");
        break;
    }
    break;
#endif
  default:
    {
      TRACE_ERROR("FATAL ERROR: tc_activate_tbf called with wrong tbf_type");
    }
    break;
  } /* switch (tbf_type_i) */


} /* tc_activate_tbf() */


/*
+------------------------------------------------------------------------------
| Function    : tc_deactivate_tbf
+------------------------------------------------------------------------------
| Description : The function tc_deactivate_tbf() removes a TBF logical from TC
|               end estimates how to continue.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_deactivate_tbf ( T_TBF_TYPE tbf_i )
{
  TRACE_FUNCTION( "tc_deactivate_tbf" );

#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
  if((tbf_i EQ CGRLC_TBF_MODE_UL) OR 
     (tbf_i EQ CGRLC_TBF_MODE_2PA ))
  {
    grr_data->tc.tbf_est_pacch = FALSE;
  }
#endif

  switch( grr_data->tbf_type )
  {

  case CGRLC_TBF_MODE_DL_UL:
    switch( tbf_i )
    {
    case CGRLC_TBF_MODE_UL:
      grr_data->tbf_type = CGRLC_TBF_MODE_DL;
      break;
    case CGRLC_TBF_MODE_DL:
      grr_data->tbf_type = CGRLC_TBF_MODE_UL;
      break;
    case CGRLC_TBF_MODE_DL_UL:
      grr_data->tbf_type = CGRLC_TBF_MODE_NULL;
      break;
    }
    break;

  case CGRLC_TBF_MODE_DL:
  case CGRLC_TBF_MODE_UL:
#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
  case CGRLC_TBF_MODE_2PA:  
#endif
      grr_data->tbf_type = CGRLC_TBF_MODE_NULL;
    break;

  default:
    break;
  }

  switch( grr_data->tbf_type )
  {
  case CGRLC_TBF_MODE_DL:
    SET_STATE(TC,TC_TBF_ACTIVE);    
    /*  
     * downlink tbf is running --> TC_TBF_ACTIVE 
     */
    break;

  case CGRLC_TBF_MODE_UL:
    /*
     *  uplink tbf is running, no state change required
     */
    break;

  case CGRLC_TBF_MODE_NULL:
    SET_STATE(TC,TC_PIM);
    /*
     *  no tbf is running, enter TC_PIM
     */
     break;

  default:
    break;
  }


} /* tc_deactivate_tbf() */


/*
+------------------------------------------------------------------------------
| Function    : tc_start_timer_t3172
+------------------------------------------------------------------------------
| Description : The function tc_start_timer_t3172()
|               SZML-TC/085 this timer start
|               caused p access reject will be done
|               with cell reselection procedures
|
| Parameters  : none
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_start_timer_t3172 ( ULONG t3172_value_i )
{

  if(t3172_value_i > 10000)
  {
    TRACE_EVENT_P1( "T3172 start %d s", (t3172_value_i/1000));
  }
  else
  {
    TRACE_EVENT_P1( "T3172 start %d ms", t3172_value_i);
  }
  vsi_t_start(GRR_handle,T3172_1,t3172_value_i);

} /* tc_start_timer_t3172() */



/*
+------------------------------------------------------------------------------
| Function    : tc_handle_tbf_start
|------------------------------------------------------------------------------
| Description : The function tc_handle_tbf_start() handles the TBF-Starting-
|               Time in a Packet Uplink Assignment.
|
| Parameters  : tbf_type - type of tbf to be handled,
|               tbf_wait - pointer to variable to store the calculated timmer
|               value
+------------------------------------------------------------------------------
*/
GLOBAL void tc_handle_tbf_start( T_TBF_TYPE tbf_type )
{
  TRACE_FUNCTION( "tc_handle_tbf_start" );


  tc_send_assign_req(tbf_type);
  tc_activate_tbf(tbf_type);

  if((tbf_type EQ CGRLC_TBF_MODE_UL))
  {
    vsi_t_stop(GRR_handle,T3162);
    vsi_t_stop(GRR_handle,T3168);
    vsi_t_stop(GRR_handle,T3170);
    vsi_t_stop(GRR_handle,T3186);

    tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL);
  }
  else if(tbf_type EQ CGRLC_TBF_MODE_DL)
  {
    tc_cgrlc_dl_tbf_req();
    if(grr_data->tc.v_sb_without_tbf EQ TRUE)
    {
    /*When Single Block is request for Measurement Report
      but network has sent the DL assignment, then this measurement report
      is sent to GRLC to be sent as normal control block*/
      tc_send_control_msg_to_grlc();
      grr_data->tc.v_sb_without_tbf = FALSE;
    }
  }
  else if(tbf_type EQ CGRLC_TBF_MODE_DL_UL)
  {
    vsi_t_stop(GRR_handle,T3168);
    tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL);
    tc_cgrlc_dl_tbf_req();
  }
#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
  else if(tbf_type EQ CGRLC_TBF_MODE_2PA)
  {
    tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_2PA,CGRLC_PRIM_STATUS_NULL);
  }
#endif
}  /* tc_handle_tbf_start()  */

/*
+------------------------------------------------------------------------------
| Function    : tc_prepare_handle_tbf_start
|------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
+------------------------------------------------------------------------------
*/
GLOBAL void tc_prepare_handle_tbf_start ( T_TBF_TYPE tbf_type,
                                          UBYTE      new_state,
                                          UBYTE      old_state )
{
  MCAST( p_d_dl_assign, D_DL_ASSIGN );

  TRACE_FUNCTION( "tc_prepare_handle_tbf_start" );

  if( grr_is_pbcch_present( )          AND 
      ( 
        old_state EQ TC_PIM            OR
        old_state EQ TC_WAIT_ASSIGN    OR
        old_state EQ TC_WAIT_2P_ASSIGN OR
        old_state EQ TC_POLLING        OR
        old_state EQ TC_WAIT_STOP_TASK_CNF        
      )
    )
  {
    UBYTE ccch_read;

    if( p_d_dl_assign->msg_type EQ D_DL_ASSIGN )
    {
      ccch_read = ( p_d_dl_assign->pda_trnc_grp.v_tbf_s_time ? DONT_STOP_CCCH : STOP_CCCH );
    }
    else
    {
      MCAST( p_d_ul_assign, D_UL_ASSIGN );

      if( ( p_d_ul_assign->v_dyn_alloc_p            AND
            p_d_ul_assign->dyn_alloc_p.v_tbf_s_time     ) OR
            p_d_ul_assign->v_sin_alloc                    OR
            p_d_ul_assign->v_f_alloc_ul                      )
      {
        ccch_read = DONT_STOP_CCCH;
      }
      else
      {
        ccch_read = STOP_CCCH;
      }
    }

    grr_data->tc.last_eval_assign.ccch_read = ccch_read;
    grr_data->tc.last_eval_assign.tbf_type  = tbf_type;
    grr_data->tc.last_eval_assign.state     = new_state;

    SET_STATE( TC, TC_WAIT_STOP_TASK_CNF );

    tc_malloc_assign( );
    if(old_state NEQ TC_WAIT_STOP_TASK_CNF)
    {
      sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ASSIGNED, ccch_read );
    }
  }
  else
  {
    tc_handle_tbf_start( tbf_type );

#ifdef _TARGET_

    if( p_d_dl_assign->msg_type     EQ  D_DL_ASSIGN AND 
        grr_data->downlink_tbf.tbf_start_fn NEQ 0xFFFFFFFF      )
    {
      sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ACCESS, TASK_STOP_DUMMY_VALUE );
    }

#endif

  }
} /* tc_prepare_handle_tbf_start() */
/*
+------------------------------------------------------------------------------
| Function    : tc_set_fa_bitmap
+------------------------------------------------------------------------------
| Description : sets fixed allocation bitmap for requested allocation after
|               receiving a repeat allocation with ts_override
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL USHORT tc_set_fa_bitmap( UBYTE ts_mask, T_FIX_ALLOC* ptr_alloc)
{
  UBYTE  i;
  USHORT  tx_slots=0;
  TRACE_FUNCTION( "tc_set_fa_bitmap" );

  if (ts_mask)
  {
    /*
     * add new time slots to current allocation
     */
    for(i=0;i<grr_data->tc.fa_ctrl.current_alloc.alloc.size_bitmap;i++)
    {
      ptr_alloc->alloc.bitmap[i] = grr_data->tc.fa_ctrl.current_alloc.alloc.bitmap[i] | ts_mask;
    }
  }

  return (tx_slots);

} /* tc_set_fa_bitmap() */


/*
+------------------------------------------------------------------------------
| Function    : tc_send_ul_repeat_alloc_req
+------------------------------------------------------------------------------
| Description : send the primitive MPHP_REPEAT_UL_FIXED_ALLOC_REQ
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_send_ul_repeat_alloc_req( void)
{
  PALLOC(ptr_2prim,MPHP_REPEAT_UL_FIXED_ALLOC_REQ);

  TRACE_FUNCTION( "tc_send_ul_repeat_alloc_req" );

  ptr_2prim->repeat_alloc = grr_data->tc.fa_ctrl.repeat_alloc;
  ptr_2prim->ts_override  = grr_data->tc.fa_ctrl.ts_overr;

  if(grr_data->tc.fa_ctrl.repeat_alloc)
  {
    ptr_2prim->p_tbf_start.tbf_start_present = 1;
    ptr_2prim->p_tbf_start.fn  = grr_data->tc.fa_ctrl.current_alloc.alloc_start_fn;
  }
  else
  {
    ptr_2prim->p_tbf_start.tbf_start_present = 0;
    ptr_2prim->p_tbf_start.fn                = 0xffffffff;
  }
  PSEND(hCommL1,ptr_2prim);

} /* tc_send_ul_repeat_alloc_req() */




/*
+------------------------------------------------------------------------------
| Function    : tc_eval_ts_reconf
+------------------------------------------------------------------------------
| Description : The function tc_eval_ts_reconf() evaluates a
|               Packet Timeslot reconfigure.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL T_EVAL_TS_RECONFIG tc_eval_ts_reconf ( void )
{
  MCAST(d_ts_reconfig,D_TS_RECONFIG);  /* T_D_TS_RECONFIG */
  T_EVAL_TS_RECONFIG result = E_TS_IGNORE;
  UBYTE tx_slots;
  UBYTE i,mask;

  T_GRR_STORE_TYPE grr_store_type = GRR_STORE_TYPE_NONE;

  TRACE_FUNCTION( "tc_eval_ts_reconf" );
      
  grr_data->downlink_tbf.ctrl_ack_bit = 0;   

#ifdef REL99
  /* This function is called only when TBF is active. Handling abnormal case
   * 8.7 While a TBF is in progress, if a mobile station receives a 
   * PACKET UPLINK ASSIGNMENT, PACKET UPLINK ACK/NACK or PACKET TIMESLOT RECONFIGURE 
   * message with message escape bit indicating EGPRS (resp. GPRS) contents whereas 
   * the current TBF mode is GPRS (resp. EGPRS), the mobile station shall ignore the 
   * message.
   */
  if(d_ts_reconfig->egprs_flag)
  {
    TRACE_ERROR( " EGPRS TBF received in TS_RECONFIGURE " );
    return E_TS_IGNORE;
  }
#endif

  switch(grr_data->tbf_type)
  {
    case CGRLC_TBF_MODE_UL:
      /*
       * reassignment of uplink and downlink assignment
       */
      grr_data->downlink_tbf.mac_mode    = grr_data->uplink_tbf.mac_mode;
      grr_data->downlink_tbf.t3192       = FALSE;                      /* indicates if t3192 is running*/
      grr_data->downlink_tbf.rlc_mode    = d_ts_reconfig->dl_rlc_mode;

      if(d_ts_reconfig->v_dl_tfi EQ 0)
      {
        TRACE_ERROR( "No downlnik assignment in TS_RECONFIGURE " );
        result = E_TS_RECONFIG_ERROR_RA;
        return result;
      }
      if((d_ts_reconfig->v_dyn_alloc_ts EQ 1) AND
         grr_data->uplink_tbf.mac_mode EQ FIXED_ALLOCATION)
      {
        TRACE_ERROR( "fixed alloc expected but dynamic alloc received" );
        result = E_TS_RECONFIG_ERROR_RA;
        return result;
      }
      if(d_ts_reconfig->v_f_alloc_re EQ 1 AND
         grr_data->uplink_tbf.mac_mode EQ DYNAMIC_ALLOCATION)
      {
        TRACE_ERROR( "dynamic alloc expected but fixed alloc received" );
        result = E_TS_RECONFIG_ERROR_RA;
        return result;
      }
      result = E_TS_UL_REASSIG_NEW_DL;
      break;
    case CGRLC_TBF_MODE_DL:
      grr_data->uplink_tbf.ti = 0;  /* contention resolution NOT required */
      if(d_ts_reconfig->v_dyn_alloc_ts)
      {
        if(d_ts_reconfig->dyn_alloc_ts.xdyn_alloc)
          grr_data->uplink_tbf.mac_mode =EDA;
        else
          grr_data->uplink_tbf.mac_mode =DA;
      }
      else if(d_ts_reconfig->v_f_alloc_re)
      {
        grr_data->uplink_tbf.mac_mode = FA;
      }
      /*
       * downlink tbf active,
       * assignment of uplink and downlink reassignment
       */
      if(d_ts_reconfig->v_ul_tfi EQ 0)
      {
        TRACE_ERROR( "No uplnik tfi in TS_RECONFIGURE" );
        result = E_TS_RECONFIG_ERROR_RA;
        return result;
      }
      if ((grr_data->downlink_tbf.rlc_mode NEQ d_ts_reconfig->dl_rlc_mode) AND !d_ts_reconfig->ctrl_ack)
      {
        TRACE_ERROR("Diff rlc mode in TS_RECONFIGURE..msg rejected..aborting");
        result = E_TS_RECONFIG_ERROR_RA;
        return result;
      }
      grr_data->downlink_tbf.rlc_mode    = d_ts_reconfig->dl_rlc_mode;
      result = E_TS_NEW_UL_DL_REASSIG;
      break;
    case CGRLC_TBF_MODE_DL_UL:
      
      if((d_ts_reconfig->v_dyn_alloc_ts EQ 1) AND
         grr_data->uplink_tbf.mac_mode EQ FIXED_ALLOCATION)
      {
        TRACE_ERROR( "fixed alloc expected but dynamic alloc received" );
        result = E_TS_RECONFIG_ERROR_RA;
        return result;
      }
      if(d_ts_reconfig->v_f_alloc_re EQ 1 AND
         grr_data->uplink_tbf.mac_mode EQ DYNAMIC_ALLOCATION)
      {
        TRACE_ERROR( "dynamic alloc expected but fixed alloc received" );
        result = E_TS_RECONFIG_ERROR_RA;
        return result;
      }
      if ((grr_data->downlink_tbf.rlc_mode NEQ d_ts_reconfig->dl_rlc_mode) AND !d_ts_reconfig->ctrl_ack)
      {
        TRACE_ERROR("Diff rlc mode in TS_RECONFIGURE..msg rejected..aborting");
        result = E_TS_RECONFIG_ERROR_RA;
        return result;
      }
      grr_data->downlink_tbf.rlc_mode    = d_ts_reconfig->dl_rlc_mode;
      result = E_TS_UL_REASSIG_DL_REASSIG;
      break;
   default:
      {
        TRACE_ERROR( " tc_eval_ts_reconf unexpected" );
        return E_TS_IGNORE;
      }
  }

  /*
   * set DOWNLINK data base
   */

  grr_data->downlink_tbf.ts_usage = d_ts_reconfig->dl_tn_alloc;  
  grr_data->downlink_tbf.nts      = grr_calc_nr_of_set_bits(grr_data->downlink_tbf.ts_usage);

  if(d_ts_reconfig->ctrl_ack)
  {
    if(grr_data->downlink_tbf.t3192)
    {
      grr_data->downlink_tbf.ctrl_ack_bit= 1;
      grr_data->downlink_tbf.t3192 = FALSE;
    }
    else
    {
      result = E_TS_RECONFIG_ERROR_RA;
      TRACE_EVENT("TS_RECONF INVALID->error_ra, ctrl ack bit set but t3192 is not running");
      return result;
    }  
  }

  /*
   * set UPLINK data base
   */
    grr_data->uplink_tbf.cs_mode      = d_ts_reconfig->chan_coding_cmd; 
    grr_data->uplink_tbf.tlli_cs_mode = 1;
    grr_data->uplink_tbf.polling_bit  = 0xFF;
    grr_data->uplink_tbf.ti           = 0;

  /*
   * set glob parameters
   */

  if(d_ts_reconfig->v_freq_par)
  {
    /* SZML-TC/091 */
    /*
     *  here is also to consider a possiblely existing dl_tbf slot ussage:SZML-TC/092
     */
  }
  if(d_ts_reconfig->v_dyn_alloc_ts)
  {
    tx_slots = 0;
    grr_data->uplink_tbf.ts_usage = 0;
    if(d_ts_reconfig->dyn_alloc_ts.v_tn_alloc)
    {
      for(i = 0,mask = 0x80;i < 8;i++)
      {
        if(d_ts_reconfig->dyn_alloc_ts.tn_alloc[i].v_usf)
        {
          grr_data->uplink_tbf.ts_usage |= mask;
          tx_slots++;
        }
        mask >>= 1;
      }
    }
    else if(d_ts_reconfig->dyn_alloc_ts.v_tn_alloc_pwr)
    {
      for(i = 0,mask = 0x80;i < 8;i++)
      {
        if(d_ts_reconfig->dyn_alloc_ts.tn_alloc_pwr.usf_array[i].v_usf_g)
        {
          grr_data->uplink_tbf.ts_usage |= mask;
          tx_slots++;
        }
        mask >>= 1;
      }

      grr_store_type = GRR_STORE_TYPE_TN_ALLOC_PWR;
    }
    grr_data->uplink_tbf.nts = tx_slots;
  }
  else if(d_ts_reconfig->v_f_alloc_re)
  {
    grr_data->uplink_tbf.ts_usage = 0;
    tx_slots=0;
    if(d_ts_reconfig->f_alloc_re.v_ul_ts_alloc)
    {
      grr_data->uplink_tbf.ts_usage = d_ts_reconfig->f_alloc_re.ul_ts_alloc;
      /*calculate number of timeslots*/
      tx_slots = grr_calc_nr_of_set_bits(grr_data->uplink_tbf.ts_usage);
    }
    else if(d_ts_reconfig->f_alloc_re.v_pwr_par)
    {
      for(i = 0,mask = 0x80;i < 8;i++)
      {
        if(d_ts_reconfig->f_alloc_re.pwr_par.gamma_tn[i].v_gamma)
        {
          grr_data->uplink_tbf.ts_usage |= mask;
          tx_slots++;
        }
        mask >>= 1;
      }

      grr_store_type = GRR_STORE_TYPE_PWR_PAR;
    }
    grr_data->uplink_tbf.nts = tx_slots;
  }
  else
  {
    TRACE_ERROR ("Packet Timeslot Reconfigure without allocation type - corrupt airmessage!");
  }

  if( !handle_ms_cap(UL_DL_ASSIGNMENT) )
  {
    result = E_TS_RECONFIG_ERROR_RA;
    TRACE_EVENT("tc_eval_.. will return E_TS_RECONFIG_ERROR_RA (ms class error)");
  }

  if( tc_check_and_save_freq( ) EQ FALSE )
  {
    result = E_TS_RECONFIG_ERROR_RA;
    TRACE_EVENT("tc_eval_.. will return E_TS_RECONFIG_ERROR_RA (frequencies wrong)");
  }

  if( result NEQ E_TS_RECONFIG_ERROR_RA AND
      result NEQ E_TS_IGNORE                )
  {
    switch( grr_store_type )
    {
      case GRR_STORE_TYPE_TN_ALLOC_PWR:
        grr_store_type_tn_alloc_pwr( &d_ts_reconfig->dyn_alloc_ts.tn_alloc_pwr );
        break;

      case GRR_STORE_TYPE_PWR_PAR:
        grr_store_type_pwr_par( &d_ts_reconfig->f_alloc_re.pwr_par, FALSE );
        break;

      default:
        /* do nothing */
        break;
    }
  }

  return result;
} /* tc_eval_ts_reconf() */








/*
+------------------------------------------------------------------------------
| Function    : tc_stop_timer_t3172
+------------------------------------------------------------------------------
| Description : The function tc_stop_timer_t3172()
|               SZML-TC/094 this timer start
|               caused p access reject will be done
|               with cell reselection procedures
|
| Parameters  : none
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_stop_timer_t3172 ( void )
{
  TRACE_FUNCTION( "tc_stop_timer_t3172" );

  vsi_t_stop(GRR_handle,T3172_1);

} /* tc_stop_timer_t3172() */

/*
+------------------------------------------------------------------------------
| Function    : tc_close_gaps_in_ctrl_blk_seq
+------------------------------------------------------------------------------
| Description : The function tc_close_gaps_in_ctrl_blk_seq reorders the queue
|               holding the order which is used to identify the next control
|               block to sent.
|
| Parameters  : index - at this index the reordering starts
|
+------------------------------------------------------------------------------
*/
LOCAL void tc_close_gaps_in_ctrl_blk_seq ( UBYTE index )
{
  TRACE_FUNCTION( "tc_close_gaps_in_ctrl_blk_seq" );

  while( index                               <   MAX_CTRL_BLK_NUM AND
         grr_data->tc.ul_ctrl_blk.seq[index] NEQ MAX_CTRL_BLK_NUM     )
  {
    grr_data->tc.ul_ctrl_blk.seq[index-1] = grr_data->tc.ul_ctrl_blk.seq[index];

    index++;
  }

  grr_data->tc.ul_ctrl_blk.seq[index-1] = MAX_CTRL_BLK_NUM;

} /* tc_close_gaps_in_ctrl_blk_seq() */

/*
+------------------------------------------------------------------------------
| Function    : tc_store_ctrl_blk
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL tc_store_ctrl_blk ( T_BLK_OWNER blk_owner, void *blk_struct )
{
  UBYTE       i;                 /* used for counting                  */
  BOOL        result    = FALSE; /* indicates whether control block is */
                                 /* stored successfully or not         */
  T_BLK_INDEX blk_index;         /* index to the control block buffer  */

  TRACE_FUNCTION( "tc_store_ctrl_msg" );

  /*
   * we have to find a free buffer for the control block which is
   * indicated by the index to the control block buffer
   */
  blk_index = MAX_CTRL_BLK_NUM;

  switch( blk_owner )
  {
    case( CGRLC_BLK_OWNER_CTRL ):
      if( grr_data->tc.ul_ctrl_blk.blk[BLK_INDEX_CTRL].state EQ BLK_STATE_NONE )
      {
        blk_index = BLK_INDEX_CTRL;
      }
      break;

    case( CGRLC_BLK_OWNER_CS ):
      if( grr_data->tc.ul_ctrl_blk.blk[BLK_INDEX_CS].state EQ BLK_STATE_NONE )
      {
        blk_index = BLK_INDEX_CS;
      }
      break;

    case( CGRLC_BLK_OWNER_TM ):
      if( grr_data->tc.ul_ctrl_blk.blk[BLK_INDEX_TC].state EQ BLK_STATE_NONE )
      {
        blk_index = BLK_INDEX_TC;
      }
      break;

    case( CGRLC_BLK_OWNER_MEAS ):

      blk_index = BLK_INDEX_MEAS;

      while( blk_index                                     <   MAX_CTRL_BLK_NUM AND
             grr_data->tc.ul_ctrl_blk.blk[blk_index].state NEQ BLK_STATE_NONE       )
      {
        blk_index++;
      }
      break;

    default:
      /* do nothing */
      break;
  }

  /*
   * check whether the control block buffer is free,
   */
  if( blk_index < MAX_CTRL_BLK_NUM )
  {
    /*
     * check the queue holding the order which is used to identify the next
     * control block to send
     */
    i = 0;

    while( i                               <   MAX_CTRL_BLK_NUM AND
           grr_data->tc.ul_ctrl_blk.seq[i] NEQ MAX_CTRL_BLK_NUM     )
    {
      i++;
    }

    /*
     * check whether there is a free entry in the order queue,
     * in case the check fails, there is something wrong with the concept
     */
    if( i < MAX_CTRL_BLK_NUM )
    {
      /*
       * store the control block data and state in the queues
       */
      grr_encode_ul_ctrl_block
        ( ( UBYTE* )&grr_data->tc.ul_ctrl_blk.blk[blk_index].data[0],
          ( UBYTE* )blk_struct );

      grr_data->tc.ul_ctrl_blk.blk[blk_index].state = BLK_STATE_ALLOCATED;
      grr_data->tc.ul_ctrl_blk.blk[blk_index].owner = blk_owner;
      grr_data->tc.ul_ctrl_blk.seq[i]               = blk_index;

      if( i < MAX_CTRL_BLK_NUM - 1 )
      {
        grr_data->tc.ul_ctrl_blk.seq[i+1] = MAX_CTRL_BLK_NUM;
      }

      result = TRUE;
    }
    else
    {
      TRACE_ERROR( "tc_store_ctrl_blk: no free entry in queue found" );
    }
  }

  if( result EQ FALSE )
  {
    if( blk_owner EQ CGRLC_BLK_OWNER_MEAS )
    {
      TRACE_EVENT( "tc_store_ctrl_blk: no table entry allocated" );
    }
    else
    {
      TRACE_ERROR( "tc_store_ctrl_blk: no table entry allocated" );
    }
  }

  return( result );

} /* tc_store_ctrl_blk() */

/*
+------------------------------------------------------------------------------
| Function    : tc_cancel_ctrl_blk
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL tc_cancel_ctrl_blk ( T_BLK_OWNER blk_owner )
{
  BOOL  result     = FALSE;
  UBYTE i         = 0;
  UBYTE blk_index = grr_data->tc.ul_ctrl_blk.seq[i];

  TRACE_FUNCTION( "tc_cancel_ctrl_blk" );


  while( blk_index NEQ MAX_CTRL_BLK_NUM AND
         result    EQ  FALSE                )
  {
    if( grr_data->tc.ul_ctrl_blk.blk[blk_index].owner EQ blk_owner           AND
        grr_data->tc.ul_ctrl_blk.blk[blk_index].state EQ BLK_STATE_ALLOCATED     )
    {
      /*
       * mark the entry in the queue as free
       */
      grr_data->tc.ul_ctrl_blk.blk[blk_index].state = BLK_STATE_NONE;
      grr_data->tc.ul_ctrl_blk.blk[blk_index].owner = CGRLC_BLK_OWNER_NONE;

      tc_close_gaps_in_ctrl_blk_seq( (UBYTE)( i + 1 ) );

      /*
       * notify owner of the control block, TC always runs in unacknowledged mode
       */
      if( blk_owner NEQ CGRLC_BLK_OWNER_TM )
      {
        sig_tc_ctrl_control_block_result( blk_owner, FALSE );
      }
    
      result = TRUE;
    }

    i++;
    if( i < MAX_CTRL_BLK_NUM )
    {
      blk_index = grr_data->tc.ul_ctrl_blk.seq[i];
    }
    else
    {
      blk_index = MAX_CTRL_BLK_NUM;
    }
  }

  if( result EQ FALSE )
  {
    TRACE_EVENT( "tc_cancel_ctrl_blk: no block found" );
  }

  return( result );

} /* tc_cancel_ctrl_blk() */

/*
+------------------------------------------------------------------------------
| Function    : tc_set_start_ctrl_blk
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE* tc_set_start_ctrl_blk ( UBYTE *index )
{
  UBYTE       i         = 0;
  T_BLK_INDEX blk_index = MAX_CTRL_BLK_NUM;

  TRACE_FUNCTION( "tc_set_start_ctrl_blk" );

  while( i                               <   MAX_CTRL_BLK_NUM AND
         grr_data->tc.ul_ctrl_blk.seq[i] NEQ MAX_CTRL_BLK_NUM AND
         blk_index                       EQ  MAX_CTRL_BLK_NUM     )
  {
    blk_index = grr_data->tc.ul_ctrl_blk.seq[i];

    if( grr_data->tc.ul_ctrl_blk.blk[blk_index].state EQ BLK_STATE_ALLOCATED )
    {
      grr_data->tc.ul_ctrl_blk.blk[blk_index].state = BLK_STATE_SENT_REQ;

      /*
       * the control block was encoded without having correct information
       * about the value of the R bit. So we have to set the correct value now.
       */
      grr_data->tc.ul_ctrl_blk.blk[blk_index].data[0] =
                               grr_get_ul_ctrl_block_header( grr_data->r_bit );
    }
    else
    {
      blk_index = MAX_CTRL_BLK_NUM;
    }

    i++;
  }

  *index = blk_index;

  return( blk_index EQ MAX_CTRL_BLK_NUM ?
                         NULL : grr_data->tc.ul_ctrl_blk.blk[blk_index].data );

} /* tc_set_start_ctrl_blk() */

/*
+------------------------------------------------------------------------------
| Function    : tc_set_stop_ctrl_blk
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL T_BLK_INDEX tc_set_stop_ctrl_blk
        ( BOOL is_tx_success, T_BLK_OWNER srch_owner, T_BLK_INDEX start_index )
{
  T_BLK_INDEX blk_index = grr_data->tc.ul_ctrl_blk.seq[start_index];
  T_BLK_INDEX nxt_index;

  TRACE_FUNCTION( "tc_set_stop_ctrl_blk" );

  if( blk_index < MAX_CTRL_BLK_NUM )
  {
    T_BLK_OWNER blk_owner = grr_data->tc.ul_ctrl_blk.blk[blk_index].owner;

    if( srch_owner EQ CGRLC_BLK_OWNER_NONE OR
        srch_owner EQ blk_owner         )
    {
      /*
       * mark the entry in the queue as free
       */
      grr_data->tc.ul_ctrl_blk.blk[blk_index].state = BLK_STATE_NONE;
      grr_data->tc.ul_ctrl_blk.blk[blk_index].owner = CGRLC_BLK_OWNER_NONE;

      tc_close_gaps_in_ctrl_blk_seq( 1 );

      /*
       * notify owner of the control block, TC always runs in unacknowledged mode
       */
      if( blk_owner NEQ CGRLC_BLK_OWNER_TM )
      {
        sig_tc_ctrl_control_block_result( blk_owner, is_tx_success );
      }

      nxt_index = start_index;
    }
    else
    {
      nxt_index = start_index + 1;
    }
  }
  else
  {
    nxt_index = MAX_CTRL_BLK_NUM;
  }

  return( nxt_index );

} /* tc_set_stop_ctrl_blk() */

/*
+------------------------------------------------------------------------------
| Function    : tc_set_stop_tc_ctrl_blk
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_set_stop_tc_ctrl_blk ( void )
{
  T_BLK_INDEX start_index = 0;

  TRACE_FUNCTION( "tc_set_stop_tc_ctrl_blk" );

  while
  (
    ( start_index = tc_set_stop_ctrl_blk( FALSE, CGRLC_BLK_OWNER_TM, start_index ) )
                                                           NEQ MAX_CTRL_BLK_NUM
                                                           ){};
} /* tc_set_stop_tc_ctrl_blk() */

/*
+------------------------------------------------------------------------------
| Function    : tc_set_stop_all_ctrl_blk
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_set_stop_all_ctrl_blk ( void )
{
  T_BLK_INDEX start_index = 0;

  TRACE_FUNCTION( "tc_set_stop_all_ctrl_blk" );

  while
  (
    ( start_index = tc_set_stop_ctrl_blk( FALSE,
                                          CGRLC_BLK_OWNER_NONE,
                                          start_index ) ) NEQ MAX_CTRL_BLK_NUM
                                          ){};
} /* tc_set_stop_all_ctrl_blk() */


/*
+------------------------------------------------------------------------------
| Function    : tc_check_access_is_needed
+------------------------------------------------------------------------------
| Description : The function tc_check_access_is_needed () ....
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_check_access_is_needed ( T_CHECK_ACCESS_CAUSE cause )
{
  TRACE_FUNCTION( "tc_check_access_is_needed " );

  if( ((grr_t_status( T3172_1 ) > 0) OR (grr_t_status( T3170 ) > 0) ) AND
      (grr_t_status( T3176 ) EQ 0))
  {
    if( cause EQ CAC_T3170_EXPIRED )
    {
      sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_IDLE, TASK_STOP_DUMMY_VALUE );
    }

    TRACE_EVENT_P3("ACCESS_REJ RUNNING t3170=%d t3172=%d t3176=%d",grr_t_status( T3170 )
                                                                  ,grr_t_status( T3172_1 )
                                                                  ,grr_t_status( T3176 ));
    return;
  }

  switch(grr_data->tbf_type)
  {
    case CGRLC_TBF_MODE_NULL:
      if(grr_data->tc.num_of_rels_running)
      {
        TRACE_EVENT_P1("WAIT FOR %d REL CON ", grr_data->tc.num_of_rels_running);
        return;
      }
      SET_STATE( TC, TC_WAIT_STOP_TASK_CNF );
      sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ACCESS, TASK_STOP_DUMMY_VALUE );
     

    break;
    case CGRLC_TBF_MODE_DL:
    case CGRLC_TBF_MODE_UL:
    case CGRLC_TBF_MODE_DL_UL:
#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
    case CGRLC_TBF_MODE_2PA:
#endif
      break;
    default:
      TRACE_ERROR("unknown tbf type during uplink access");
      break;
  }
} /* tc_check_access_is_needed  */

/*
+------------------------------------------------------------------------------
| Function    : tc_stop_normal_burst_req
+------------------------------------------------------------------------------
| Description : this function sends the primitive MPHP_STOP_SINGLE_BLOCK_REQ
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_stop_normal_burst_req ( void )
{
  TRACE_FUNCTION( "tc_stop_normal_burst_req" );

  {
    PALLOC(mphp_stop_single_block_req,MPHP_STOP_SINGLE_BLOCK_REQ);
    PSEND(hCommL1,mphp_stop_single_block_req);
  }
} /* tc_stop_normal_burst_req() */



/*
+------------------------------------------------------------------------------
| Function    : tc_malloc_assign
+------------------------------------------------------------------------------
| Description : The function tc_malloc_assign() .... 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_malloc_assign ( void )
{ 
  MCAST( p_d_dl_assign, D_DL_ASSIGN );

  TRACE_FUNCTION( "tc_malloc_assign" );

  if( grr_data->tc.p_assign EQ NULL )
  {
    if( p_d_dl_assign->msg_type EQ D_DL_ASSIGN )
    {
      MALLOC( grr_data->tc.p_assign, sizeof( T_D_DL_ASSIGN ) );
    }
    else
    {
      MALLOC( grr_data->tc.p_assign, sizeof( T_D_UL_ASSIGN ) );
    }
  }
  else
  {
    TRACE_ERROR( "tc_malloc_assign: fatal error, memory reallocation not implemented" );
  }

  if( p_d_dl_assign->msg_type EQ D_DL_ASSIGN )
  {
    *grr_data->tc.p_assign = *( ( T_D_DL_ASSIGN * )_decodedMsg );
  }
  else
  {
    *( ( T_D_UL_ASSIGN * )grr_data->tc.p_assign ) = *( ( T_D_UL_ASSIGN * )_decodedMsg );
  }
} /* tc_malloc_assign() */

/*
+------------------------------------------------------------------------------
| Function    : tc_mfree_assign
+------------------------------------------------------------------------------
| Description : The function tc_mfree_assign() .... 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_mfree_assign ( BOOL restore_data )
{ 
  TRACE_FUNCTION( "tc_mfree_assign" );

  if( grr_data->tc.p_assign NEQ NULL )
  {
    if( restore_data )
    {
      if( grr_data->tc.p_assign->msg_type EQ D_DL_ASSIGN )
      {
        *( ( T_D_DL_ASSIGN * )_decodedMsg ) = *grr_data->tc.p_assign;
      }
      else
      {
        *( ( T_D_UL_ASSIGN * )_decodedMsg ) = *( ( T_D_UL_ASSIGN * )grr_data->tc.p_assign );
      }
    }

    MFREE( grr_data->tc.p_assign );
    grr_data->tc.p_assign = NULL;
  }
  else
  {
    TRACE_ERROR( "tc_mfree_assign: fatal error, no memory allocated" );
  }
} /* tc_mfree_assign() */

/*
+------------------------------------------------------------------------------
| Function    : tc_prepare_send_tbf_release_req
+------------------------------------------------------------------------------
| Description : The function tc_prepare_send_tbf_release_req() .... 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
LOCAL void tc_prepare_send_tbf_release_req( T_TBF_TYPE tbf_type )
{ 
  TRACE_FUNCTION( "tc_prepare_send_tbf_release_req" );

  if( grr_is_pbcch_present( ) AND tbf_type EQ grr_data->tbf_type )
  {
    grr_data->tc.last_tbf_type = tbf_type;
  
    grr_data->tc.num_of_rels_running++;

    sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_RELEASED, TASK_STOP_DUMMY_VALUE );
  }
  else
  {
    tc_send_tbf_release_req( tbf_type, TRUE );
  }
} /* tc_prepare_send_tbf_release_req() */

/*
+------------------------------------------------------------------------------
| Function    : tc_send_tbf_release_req
+------------------------------------------------------------------------------
| Description : The function tc_send_tbf_release_req() .... 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_send_tbf_release_req( T_TBF_TYPE tbf_type, BOOL is_synchron )
{ 
  UBYTE rel_req_tbf_type;
  UBYTE transid;

  TRACE_FUNCTION( "tc_send_tbf_release_req" );

  switch( tbf_type )
  {
    case CGRLC_TBF_MODE_UL:    rel_req_tbf_type = UL_ASSIGNMENT;    break;
    case CGRLC_TBF_MODE_DL:    rel_req_tbf_type = DL_ASSIGNMENT;    break;
    case CGRLC_TBF_MODE_DL_UL: rel_req_tbf_type = UL_DL_ASSIGNMENT; break;
#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
    case CGRLC_TBF_MODE_2PA:   rel_req_tbf_type = UL_TP_ACCESS;     break;
#endif

    default:
      TRACE_ERROR( "tc_send_tbf_release_req: unknown tbf type" );
      return;
  }

  {
    PALLOC(mphp_tbf_release_req,MPHP_TBF_RELEASE_REQ);
    mphp_tbf_release_req->tbf_type = rel_req_tbf_type;
    PSEND(hCommL1,mphp_tbf_release_req);

    if( is_synchron )
    {
      grr_data->tc.num_of_rels_running++;
    }
  }

  switch(rel_req_tbf_type)
  {
    case UL_ASSIGNMENT:
#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
    case UL_TP_ACCESS:
#endif
      memset(&grr_data->uplink_tbf,0xEE,sizeof(T_UL_TBF));
      grr_data->test_mode = CGRLC_NO_TEST_MODE;
      break;
    case DL_ASSIGNMENT:
      transid = grr_data->downlink_tbf.trans_id;
      memset(&grr_data->downlink_tbf,0xEE,sizeof(T_DL_TBF));
      grr_data->downlink_tbf.trans_id = transid;
      break;
    case UL_DL_ASSIGNMENT:
      transid = grr_data->downlink_tbf.trans_id;
      memset(&grr_data->uplink_tbf,0xEE,sizeof(T_UL_TBF));
      memset(&grr_data->downlink_tbf,0xEE,sizeof(T_DL_TBF));
      grr_data->test_mode = CGRLC_NO_TEST_MODE;
      grr_data->downlink_tbf.trans_id = transid;
      break;
  }



} /* tc_send_tbf_release_req() */



/*
+------------------------------------------------------------------------------
| Function    : tc_get_t3170_value
+------------------------------------------------------------------------------
| Description : The function tc_get_t3170_value() calculates T3170 and returns it 
|
| Parameters  : return T_TIME
|
+------------------------------------------------------------------------------
*/
GLOBAL T_TIME tc_get_t3170_value(void)
{
  T_TIME t3170_value;

  t3170_value = s_table[psc_db->prach.s_prach];

  if(S_VALUE_RESERVED EQ t3170_value)
    t3170_value = 0;
  
  t3170_value *= 2;
  t3170_value += tx_int_table[psc_db->prach.tx_int];
  /* T3170 value = TX_INT + 2 * S from prach control parameters */
  /* see gsm 04.60 13.1 */
  t3170_value *= 5;  /* 1 tdma frame ~ 5ms */
  TRACE_EVENT_P1("T3170: %ld", t3170_value);
  return t3170_value;
}




/*
+------------------------------------------------------------------------------
| Function    : tc_call_disable_callback_func
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_call_disable_callback_func ( void )
{
  if( grr_data->tc.disable_callback_func NEQ NULL )
  {
    T_TC_DISABLE_CALLBACK_FUNC disable_callback_func;

    TRACE_EVENT( "Call disable_callback_func after TBF release" );

    disable_callback_func              = grr_data->tc.disable_callback_func;
    grr_data->tc.disable_callback_func = NULL;
    
    disable_callback_func( );
  }
} /* tc_call_disable_callback_func */

/*
+------------------------------------------------------------------------------
| Function    : tc_set_freq
+------------------------------------------------------------------------------
| Description : This function allocates a primitve depending on the hopping status
|               and sets the frequency parameter of T_MPHP_ASSIGNMENT_REQ
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL T_MPHP_ASSIGNMENT_REQ * tc_set_freq ( void )
{
  PALLOC( ptr2prim, MPHP_ASSIGNMENT_REQ );

  TRACE_FUNCTION( "tc_set_freq" );

  memset( ptr2prim, 0, sizeof( T_MPHP_ASSIGNMENT_REQ ) );

  ptr2prim->tsc = grr_data->tc.freq_set.tsc;

  grr_set_freq_par( &ptr2prim->p_frequency_par );

  return( ptr2prim );
}/* tc_set_freq */

/*
+------------------------------------------------------------------------------
| Function    : tc_cgrlc_disable_req
+------------------------------------------------------------------------------
| Description : This function allocates sends the the primtive CGRLC_DISABLE_REQ
|               to GRLC
|
| Parameters  : prim_st - indicates if a primitive shall be deleted or not
|
+------------------------------------------------------------------------------
*/
GLOBAL void tc_cgrlc_disable_req        ( UBYTE prim_st )
{
  PALLOC(cgrlc_disable_req,CGRLC_DISABLE_REQ); /*T_CGRLC_DISABLE_REQ*/

  TRACE_FUNCTION( "tc_cgrlc_disable_req" );

  cgrlc_disable_req->disable_class = grr_data->tc.disable_class;
  cgrlc_disable_req->prim_status   = prim_st;

  PSEND(hCommGRLC,cgrlc_disable_req);

}/* tc_cgrlc_disable_req */


/*
+------------------------------------------------------------------------------
| Function    : tc_cgrlc_ul_tbf_res
+------------------------------------------------------------------------------
| Description : This function 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/

GLOBAL void tc_cgrlc_ul_tbf_res        ( UBYTE tbf_mode, UBYTE prim_status )
{
  PALLOC(cgrlc_ul_tbf_res,CGRLC_UL_TBF_RES); /*T_CGRLC_UL_TBF_RES*/

  TRACE_FUNCTION( "tc_cgrlc_ul_tbf_res" );

  cgrlc_ul_tbf_res->starting_time = grr_data->uplink_tbf.tbf_start_fn;     
  cgrlc_ul_tbf_res->tbf_mode      = tbf_mode;          
  cgrlc_ul_tbf_res->prim_status   = prim_status;       
  cgrlc_ul_tbf_res->polling_bit   = grr_data->uplink_tbf.polling_bit;       
  cgrlc_ul_tbf_res->cs_mode       = grr_data->uplink_tbf.cs_mode;           
  cgrlc_ul_tbf_res->mac_mode      = grr_data->uplink_tbf.mac_mode;          
  cgrlc_ul_tbf_res->nts_max       = grr_data->uplink_tbf.nts;
  cgrlc_ul_tbf_res->rlc_db_granted= grr_data->uplink_tbf.rlc_db_granted;

  if(grr_data->uplink_tbf.ts_usage)
  {
    cgrlc_ul_tbf_res->tn_mask     = grr_data->uplink_tbf.ts_usage;
  }
  else
  {
    cgrlc_ul_tbf_res->tn_mask     = grr_data->uplink_tbf.ts_mask;
    TRACE_EVENT("UL tn mask passed to grlc instead of ts_usage");
  }

  if(grr_data->uplink_tbf.st_tfi EQ 0xFF)
    cgrlc_ul_tbf_res->tfi = grr_data->uplink_tbf.tfi;               
  else
    cgrlc_ul_tbf_res->tfi = grr_data->uplink_tbf.st_tfi;
  
  cgrlc_ul_tbf_res->ti            = grr_data->uplink_tbf.ti;                
  cgrlc_ul_tbf_res->bs_cv_max     = psc_db->gprs_cell_opt.bs_cv_max;         
  cgrlc_ul_tbf_res->tlli_cs_mode  = grr_data->uplink_tbf.tlli_cs_mode;
  cgrlc_ul_tbf_res->r_bit         = grr_data->r_bit;

  if(cgrlc_ul_tbf_res->mac_mode EQ FA)
  {
    cgrlc_ul_tbf_res->fix_alloc_struct.bitmap_len  = grr_data->tc.fa_ctrl.current_alloc.alloc.size_bitmap;
    cgrlc_ul_tbf_res->fix_alloc_struct.end_fn      = grr_data->tc.fa_ctrl.current_alloc.alloc_end_fn;             
    cgrlc_ul_tbf_res->fix_alloc_struct.final_alloc = grr_data->tc.fa_ctrl.current_alloc.final_alloc;        
    memcpy (cgrlc_ul_tbf_res->fix_alloc_struct.bitmap_array,
            grr_data->tc.fa_ctrl.current_alloc.alloc.bitmap,
            MAX_ALLOC_BITMAP);
  }

  grr_prcs_pwr_ctrl ( &cgrlc_ul_tbf_res->pwr_ctrl, FALSE );
  
  /*Reset the GRR database for parameters which are used only once*/
  grr_data->uplink_tbf.polling_bit=0xFF;
  
  PSEND(hCommGRLC,cgrlc_ul_tbf_res);

}/* tc_cgrlc_ul_tbf_res */



/*
+------------------------------------------------------------------------------
| Function    : tc_cgrlc_access_status_req
+------------------------------------------------------------------------------
| Description : This function 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/

GLOBAL void tc_cgrlc_access_status_req        ( void )  
{
  PALLOC(cgrlc_access_status_req,CGRLC_ACCESS_STATUS_REQ); /*T_CGRLC_ACCESS_STATUS_REQ*/

  TRACE_FUNCTION( "tc_cgrlc_access_status_req" );

  PSEND(hCommGRLC,cgrlc_access_status_req);

}/* tc_cgrlc_access_status_req*/ 


/*
+------------------------------------------------------------------------------
| Function    : tc_send_control_msg_to_grlc
+------------------------------------------------------------------------------
| Description : This function 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/

GLOBAL void tc_send_control_msg_to_grlc        ( void )
{
  UBYTE i= 0;

  TRACE_FUNCTION( "tc_send_control_msg_to_grlc" );

    
  while( i                               <   MAX_CTRL_BLK_NUM AND 
         grr_data->tc.ul_ctrl_blk.seq[i] NEQ MAX_CTRL_BLK_NUM     )
  {
    if( grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].state
                                                       EQ BLK_STATE_ALLOCATED )
    {
      PALLOC(cgrlc_data_req,CGRLC_DATA_REQ);  /* T_CGRLC_DATA_REQ */

 
      cgrlc_data_req->blk_owner  = grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].owner;        
 
      memcpy(cgrlc_data_req->data_array,grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].data,23);

      PSEND(hCommGRLC,cgrlc_data_req);
     
      /* remove control block */

      tc_cancel_ctrl_blk(grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].owner);
    }
  }


}/* tc_send_control_msg_to_grlc*/ 

/*
+------------------------------------------------------------------------------
| Function    : tc_cgrlc_dl_tbf_req
+------------------------------------------------------------------------------
| Description : This function 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/

GLOBAL void tc_cgrlc_dl_tbf_req        ( void )
{
  PALLOC(cgrlc_dl_tbf_req,CGRLC_DL_TBF_REQ); /*T_CGRLC_DL_TBF_REQ*/


  TRACE_FUNCTION( "tc_cgrlc_dl_tbf_req" );

  grr_data->downlink_tbf.trans_id++;

  cgrlc_dl_tbf_req->starting_time = grr_data->downlink_tbf.tbf_start_fn;     
  cgrlc_dl_tbf_req->rlc_mode      = grr_data->downlink_tbf.rlc_mode;          
  cgrlc_dl_tbf_req->mac_mode      = grr_data->downlink_tbf.mac_mode;  
  cgrlc_dl_tbf_req->polling_bit   = grr_data->downlink_tbf.polling_bit;
  cgrlc_dl_tbf_req->nts_max       = grr_data->downlink_tbf.nts;

  if(grr_data->downlink_tbf.ts_usage)
  {
    cgrlc_dl_tbf_req->tn_mask      = grr_data->downlink_tbf.ts_usage;
    grr_data->downlink_tbf.ts_mask = grr_data->downlink_tbf.ts_usage; /* set before starting time is elapsed */
  }
  else
  {
    cgrlc_dl_tbf_req->tn_mask     = grr_data->downlink_tbf.ts_mask;
    TRACE_EVENT("DL tn mask passed to grlc instead of ts_usage");
  }


  if(grr_data->downlink_tbf.st_tfi EQ 0xFF)
    cgrlc_dl_tbf_req->tfi = grr_data->downlink_tbf.tfi;               
  else
    cgrlc_dl_tbf_req->tfi = grr_data->downlink_tbf.st_tfi;
          
  cgrlc_dl_tbf_req->t3192_val     = psc_db->gprs_cell_opt.t3192;          
  cgrlc_dl_tbf_req->ctrl_ack_bit  = grr_data->downlink_tbf.ctrl_ack_bit;    

  grr_prcs_pwr_ctrl ( &cgrlc_dl_tbf_req->pwr_ctrl, FALSE );
  
  /*Reset the GRR database for parameters which are used only once*/
  grr_data->downlink_tbf.ctrl_ack_bit=0;
  grr_data->downlink_tbf.polling_bit=0xFF;

  PSEND(hCommGRLC,cgrlc_dl_tbf_req);


}/* tc_cgrlc_dl_tbf_req*/ 


/*
+------------------------------------------------------------------------------
| Function    : tc_cgrlc_tbf_rel_res
+------------------------------------------------------------------------------
| Description : This function 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/

GLOBAL void tc_cgrlc_tbf_rel_res ( UBYTE tbf_type )
{
  PALLOC(cgrlc_tbf_rel_res,CGRLC_TBF_REL_RES);

  TRACE_FUNCTION( "tc_cgrlc_tbf_rel_res" );

  switch( tbf_type )
  {
    case DL_ASSIGNMENT:    cgrlc_tbf_rel_res->tbf_mode = CGRLC_TBF_MODE_DL;    break;
    case UL_ASSIGNMENT:    cgrlc_tbf_rel_res->tbf_mode = CGRLC_TBF_MODE_UL;    break;
    case UL_DL_ASSIGNMENT: cgrlc_tbf_rel_res->tbf_mode = CGRLC_TBF_MODE_DL_UL; break;
#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
    case UL_TP_ACCESS:     cgrlc_tbf_rel_res->tbf_mode = CGRLC_TBF_MODE_2PA;   break;
#endif
  }

  PSEND(hCommGRLC,cgrlc_tbf_rel_res);

}/* tc_cgrlc_tbf_rel_res*/ 




/*
+------------------------------------------------------------------------------
| Function    : tc_cgrlc_tbf_rel_req
+------------------------------------------------------------------------------
| Description : This function 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/

GLOBAL void tc_cgrlc_tbf_rel_req        ( UBYTE tbf_type, UBYTE rel_cause, ULONG rel_fn )
{
  PALLOC(cgrlc_tbf_rel_req,CGRLC_TBF_REL_REQ); /*T_CGRLC_TBF_REL_REQ*/
 
  TRACE_FUNCTION( "tc_cgrlc_tbf_rel_req" );
 
  cgrlc_tbf_rel_req->tbf_mode       = tbf_type; 
  cgrlc_tbf_rel_req->tbf_rel_cause  = rel_cause;       
  cgrlc_tbf_rel_req->rel_fn         = rel_fn;    

  PSEND(hCommGRLC,cgrlc_tbf_rel_req);

}/* tc_cgrlc_tbf_rel_req*/ 



/*
+------------------------------------------------------------------------------
| Function    : tc_cgrlc_enable_req
+------------------------------------------------------------------------------
| Description : This function sends the primitive cgrlc_enable_req to GRLC
|
| Parameters  : queue_mode - indicates the queue mode
|               cu_cause   - indicates if cell update is required or not 
|
+------------------------------------------------------------------------------
*/

GLOBAL void tc_cgrlc_enable_req ( UBYTE queue_mode,
                                  UBYTE cu_cause,
                                  BOOL  cell_has_changed,
                                  UBYTE enable_cause )
{
 
  PALLOC(cgrlc_enable_req,CGRLC_ENABLE_REQ); /*T_CGRLC_ENABLE_REQ*/
 
  TRACE_FUNCTION( "tc_cgrlc_enable_req" );

  cgrlc_enable_req->enable_cause       = enable_cause;
  cgrlc_enable_req->queue_mode         = queue_mode;
  cgrlc_enable_req->cu_cause           = cu_cause;                 /* cell update request will be handled sig_ctrl_tc_enable_grlc */
  /*************Burst type handling********************************/
  cgrlc_enable_req->burst_type         = psc_db->gprs_cell_opt.ctrl_ack_type; 
  cgrlc_enable_req->ab_type            = psc_db->gprs_cell_opt.ab_type;

  /*************Counter N3102 handling*****************************/
  cgrlc_enable_req->v_pan_struct     = psc_db->gprs_cell_opt.v_pan_struct;
  cgrlc_enable_req->pan_struct.inc   = psc_db->gprs_cell_opt.pan_struct.inc;
  cgrlc_enable_req->pan_struct.dec   = psc_db->gprs_cell_opt.pan_struct.dec;
  if(cell_has_changed)
    cgrlc_enable_req->pan_struct.pmax  = (psc_db->gprs_cell_opt.pan_struct.pmax + 1 ) *4;
  else
    cgrlc_enable_req->pan_struct.pmax  = CGRLC_NO_UPDATE_N3102;

  cgrlc_enable_req->ul_tlli          = grr_data->db.ms_id.new_tlli;
  cgrlc_enable_req->dl_tlli          = grr_data->db.ms_id.received_tlli;

  cgrlc_enable_req->t3168_val        = psc_db->gprs_cell_opt.t3168;
  
  if(grr_is_pbcch_present())

  {
    cgrlc_enable_req->change_mark  = psc_db->psi2_params.psi2_change_mark;
    if(grr_data->ms.access_ctrl_class & ~psc_db->prach.ac_class)
    {
      cgrlc_enable_req->ac_class = CGRLC_PCCCH_AC_ALLOWED;
    }
    else
    {
      cgrlc_enable_req->ac_class = CGRLC_PCCCH_AC_NOT_ALLOWED;
      TRACE_EVENT_P3("ACCESS NOT ALLOWED PBCCH:  ms_acc=%d prach_ac=%d tc_state=%d"
                                                                                    ,grr_data->ms.access_ctrl_class
                                                                                    ,psc_db->prach.ac_class
                                                                                    ,grr_data->tc.state);
    }
  }
  else
  {
    cgrlc_enable_req->change_mark  = psc_db->psi13_params.si13_change_mark;
    if(grr_data->ms.access_ctrl_class & ~psc_db->prach.ac_class)
    {
      cgrlc_enable_req->ac_class = psc_db->net_ctrl.priority_access_thr;
    }
    else
    {
      cgrlc_enable_req->ac_class = CGRLC_PCCCH_AC_NOT_ALLOWED;
      TRACE_EVENT_P3("ACCESS NOT ALLOWED CCCH:  ms_acc=%d prach_ac=%d   tc_state=%d"
                                                                               ,grr_data->ms.access_ctrl_class
                                                                               ,psc_db->prach.ac_class
                                                                               ,grr_data->tc.state);
    }
  }

#ifdef REL99
  cgrlc_enable_req->pfi_support = psc_db->gprs_cell_opt.gprs_ext_bits.gprs_ext_info.pfc_feature_mode;
  cgrlc_enable_req->nw_rel      = psc_db->network_rel; /*Network Release Order*/
#endif

  PSEND(hCommGRLC,cgrlc_enable_req);
 
}/* tc_cgrlc_enable_req*/ 

/*
+------------------------------------------------------------------------------
| Function    : grr_convert_11bit_2_etsi
+------------------------------------------------------------------------------
| Description : Converts the 11 bit access burst value into ETSI format
|
| Parameters  : In:  eleven bit value
|               Out: converted eleven bit
|
+------------------------------------------------------------------------------
*/
LOCAL USHORT grr_convert_11bit_2_etsi ( USHORT eleven_bit )
{
  USHORT etsi11bit;
  USHORT dummy1 = 0, dummy2 = 0;

  TRACE_FUNCTION( "grr_convert_11bit_2_etsi" );

  /*
   *  11 Bit access burst
   * b: bit
   * b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0
   * should be sent to the network -according 04.60 and 0404- in the
   * following 16-bit format:
   * 0 0 0 0 0 b2 b1 b0 b10 b9 b8 b7 b6 b5 b4 b3
   */

  /*
   * get b2 b1 b0
   */
  dummy1 = 0x0007 & eleven_bit;

  /*
   * shift it 8 bits to left
   */
  dummy1 = ( dummy1 << 8 );

  /*
   * get b10 b9 b8 b7 b6 b5 b4 b3
   */
  dummy2 = 0xFFF8 & eleven_bit;

  /*
   * shift it 3 bits to right
   */
  dummy2 = ( dummy2 >> 3 );

  /*
   * compose dummy1 and dummy2 to the target 16-bit format
   */
  etsi11bit = dummy1 | dummy2;
  
  return etsi11bit;

} /* grr_convert_11bit_2_etsi() */