diff src/g23m-gprs/grr/grr_tcs.c @ 1:fa8dc04885d8

src/g23m-*: import from Magnetite
author Mychaela Falconia <falcon@freecalypso.org>
date Fri, 16 Oct 2020 06:25:50 +0000
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/g23m-gprs/grr/grr_tcs.c	Fri Oct 16 06:25:50 2020 +0000
@@ -0,0 +1,3182 @@
+/* 
++----------------------------------------------------------------------------- 
+|  Project :  GPRS (8441)
+|  Modul   :  GRR
++----------------------------------------------------------------------------- 
+|  Copyright 2002 Texas Instruments Berlin, AG 
+|                 All rights reserved. 
+| 
+|                 This file is confidential and a trade secret of Texas 
+|                 Instruments Berlin, AG 
+|                 The receipt of or possession of this file does not convey 
+|                 any rights to reproduce or disclose its contents or to 
+|                 manufacture, use, or sell anything it may describe, in 
+|                 whole, or in part, without the specific written consent of 
+|                 Texas Instruments Berlin, AG. 
++----------------------------------------------------------------------------- 
+|  Purpose :  This module implements signal handler functions for service
+|             TC of entity GRR.
++----------------------------------------------------------------------------- 
+*/ 
+
+#ifndef GRR_TCS_C
+#define GRR_TCS_C
+#endif
+
+#define ENTITY_GRR
+
+/*==== INCLUDES =============================================================*/
+
+#include <string.h>
+#include "typedefs.h"   /* to get Condat data types */
+#include "vsi.h"        /* to get a lot of macros */
+#include "macdef.h"
+#include "gprs.h"
+#include "gsm.h"        /* to get a lot of macros */
+#include "ccdapi.h"     /* to get CCD API */
+#include "cnf_grr.h"    /* to get cnf-definitions */
+#include "mon_grr.h"    /* to get mon-definitions */
+#include "prim.h"       /* to get the definitions of used SAP and directions */
+#include "message.h"    /* to get air message definitions */
+#include "grr.h"        /* to get the global entity definitions */
+#include "grr_f.h"      /* to get the global entity definitions */
+#include "grr_tcf.h"    /* to get the service TC procedure definitions */
+#include "grr_tcs.h"    /* to get the service TC signal definitions */
+#include "grr_ctrls.h"  /* to get the service CTRL signal definitions */
+#include "grr_cpaps.h"  /* to get the service CPAP signal definitions */
+#include "grr_meass.h"
+#include "grr_psif.h"   /* stop timers in Testmode A */
+#include "cl_rlcmac.h"
+
+/*==== CONST ================================================================*/
+
+/*==== DIAGNOSTICS ==========================================================*/
+
+/*==== LOCAL TYPES===========================================================*/
+
+LOCAL void tc_handle_new_cell ( BOOL cell_has_changed, UBYTE enable_cause );
+
+/*==== LOCAL VARS ===========================================================*/
+
+/*==== PRIVATE FUNCTIONS ====================================================*/
+/*
++------------------------------------------------------------------------------
+| Function    : tc_handle_new_cell
++------------------------------------------------------------------------------
+| Description : 
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void tc_handle_new_cell ( BOOL cell_has_changed, UBYTE enable_cause )
+{
+  UBYTE queue_mode;
+
+  TRACE_FUNCTION( "tc_handle_new_cell" );
+
+  if( cell_has_changed )
+  {
+    /* inform CPAP because it has to stop T3142 if running */
+    sig_tc_cpap_new_cell();
+
+    grr_data->ta_params.ta_valid = FALSE;
+  
+    TRACE_EVENT_P1( "tc_handle_new_cell: N3102 = %d", psc_db->gprs_cell_opt.pan_struct.pmax );
+  }
+
+  queue_mode = ( enable_cause EQ CGRLC_ENAC_NORMAL ? 
+                 CGRLC_QUEUE_MODE_GMM : CGRLC_QUEUE_MODE_LLC );
+  
+  tc_cgrlc_enable_req( queue_mode, 
+                       CGRLC_RA_DEFAULT, 
+                       cell_has_changed,
+                       enable_cause );
+} /* tc_handle_new_cell() */
+
+/*==== PUBLIC FUNCTIONS =====================================================*/
+/*
++------------------------------------------------------------------------------
+| Function    : tc_get_ctrl_blk
++------------------------------------------------------------------------------
+| Description : 
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL UBYTE* tc_get_ctrl_blk ( UBYTE *index, BOOL unacknowledged )
+{ 
+  UBYTE *ctrl_blk;
+
+  TRACE_FUNCTION( "tc_get_ctrl_blk" );
+
+  ctrl_blk = tc_set_start_ctrl_blk( index );
+ 
+  if( unacknowledged )
+  {
+    /* 
+     * in case the control blocks are send by the service RU, we are 
+     * working in unacknowledged mode, so every block is transmitted 
+     * succesfully
+     */
+    tc_set_stop_ctrl_blk( TRUE, CGRLC_BLK_OWNER_NONE, 0 );
+  }
+  
+  return( ctrl_blk );
+
+} /* tc_get_ctrl_blk() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tc_is_ctrl_blk_rdy
++------------------------------------------------------------------------------
+| Description : 
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL tc_is_ctrl_blk_rdy ( UBYTE ack_cnt_meas_rpt, UBYTE ack_cnt_other )
+{ 
+  BOOL        result    = FALSE;
+  T_BLK_INDEX blk_index = grr_data->tc.ul_ctrl_blk.seq[0];
+
+  TRACE_FUNCTION( "tc_is_ctrl_blk_rdy" );
+
+  if( blk_index NEQ MAX_CTRL_BLK_NUM )
+  {
+    switch( grr_data->tc.ul_ctrl_blk.blk[blk_index].owner )
+    {
+      case( CGRLC_BLK_OWNER_MEAS ):
+      case( CGRLC_BLK_OWNER_CS   ): result = ( ack_cnt_meas_rpt EQ 0 ); break;
+      default               : result = ( ack_cnt_other    EQ 0 ); break;
+    }
+  }
+  
+  return( result );
+
+} /* tc_is_ctrl_blk_rdy() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tc_get_num_ctrl_blck
++------------------------------------------------------------------------------
+| Description : This function returns the number of allocated control blocks.
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL UBYTE tc_get_num_ctrl_blck ( void )
+{ 
+  UBYTE i   = 0; /* used for counting                  */
+  UBYTE num = 0; /* number of allocated control blocks */
+
+  TRACE_FUNCTION( "tc_get_num_ctrl_blck" );
+
+  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 )
+    {
+      num++;
+    }
+
+    i++;
+  }
+  
+  return( num );
+
+} /* tc_get_num_ctrl_blck() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tc_cpy_ctrl_blk_to_buffer
++------------------------------------------------------------------------------
+| Description : This function ...
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL UBYTE tc_cpy_ctrl_blk_to_buffer( UBYTE *buffer )
+{ 
+  UBYTE  index;
+  UBYTE *ctrl_block = tc_get_ctrl_blk( &index, FALSE );
+
+  TRACE_FUNCTION( "tc_cpy_ctrl_blk_to_buffer" );
+
+  if( ctrl_block NEQ NULL )
+  {
+    memcpy( buffer, ctrl_block, BYTE_UL_CTRL_BLOCK );
+    grr_data->tc.v_sb_without_tbf    = FALSE;
+    /*
+     * After copying Measurement reports (PIM) in single block req 
+     * v_sb_without_tbf is not required
+     */
+  }
+  else
+  {
+    TRACE_ERROR( "tc_cpy_ctrl_blk_to_buffer: ctrl_block EQ NULL" );
+  }
+
+  return( index );
+} /* tc_cpy_ctrl_blk_to_buffer() */
+
+/*==== SIGNAL FUNCTIONS =====================================================*/
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_control_block
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_CONTROL_BLOCK
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_control_block ( T_BLK_OWNER   blk_owner_i, 
+                                          void        * blk_struct_i )
+{ 
+  TRACE_ISIG( "sig_ctrl_tc_control_block " );
+ 
+  switch( GET_STATE( TC ) )
+  {
+    case TC_ACCESS_DISABLED:
+    case TC_CPAP:
+    case TC_WAIT_ASSIGN:
+    case TC_POLLING:
+    case TC_WAIT_2P_ASSIGN:
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+    case TC_WAIT_STOP_TASK_CNF:
+      if( tc_store_ctrl_blk( blk_owner_i, blk_struct_i ) EQ FALSE )
+      {
+        sig_tc_ctrl_control_block_result( blk_owner_i, FALSE );
+      }
+      else
+      {
+        tc_send_control_msg_to_grlc();
+      }
+      break;
+    case TC_SINGLE_BLOCK:
+    case TC_PIM:
+      if( tc_store_ctrl_blk( blk_owner_i, blk_struct_i ) EQ FALSE )
+      {
+        sig_tc_ctrl_control_block_result( blk_owner_i, FALSE );
+      }
+      else
+      {
+        /*
+         * check if grlc has to transmit data
+         */
+        tc_cgrlc_access_status_req();
+/*          grr_data->tc.v_sb_without_tbf    = TRUE;
+          grr_data->uplink_tbf.nr_blocks   = 1;
+          grr_data->uplink_tbf.prio        = RADIO_PRIO_4;
+          grr_data->uplink_tbf.access_type = CGRLC_AT_SINGLE_BLOCK;
+          grr_data->uplink_tbf.ti          = 0;  
+          tc_check_access_is_needed( CAC_OTHER );*/
+      }
+      break;
+    default:
+      sig_tc_ctrl_control_block_result( blk_owner_i, FALSE );
+
+      TRACE_ERROR( "SIG_CTRL_TC_CONTROL_BLOCK unexpected" );
+      break;
+  }
+} /* sig_ctrl_tc_control_block () */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_cancel_control_block
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_CANCEL_CONTROL_BLOCK
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_cancel_control_block ( T_BLK_OWNER blk_owner_i )
+{ 
+  UBYTE state = GET_STATE( TC );
+
+  TRACE_ISIG( "sig_ctrl_tc_cancel_control_block " );
+ 
+  switch( state )
+  {
+    case TC_CPAP:
+    case TC_WAIT_ASSIGN:
+      if( tc_cancel_ctrl_blk( blk_owner_i ) EQ TRUE )
+      {
+        if( tc_get_num_ctrl_blck( )  EQ 0  )
+        {
+          if( state EQ TC_CPAP )
+          {
+            sig_tc_cpap_abort_access();
+          }
+          else
+          {
+            SET_STATE( TC, TC_PIM );
+
+            tc_send_ra_stop_req( );
+            vsi_t_stop( GRR_handle, T3170 );
+            tc_check_access_is_needed( CAC_OTHER );
+          }
+        }
+      }
+      break;
+    case TC_ACCESS_DISABLED:
+    case TC_POLLING:
+    case TC_PIM:
+      tc_cancel_ctrl_blk( blk_owner_i );
+      break;
+    case TC_SINGLE_BLOCK:
+    case TC_WAIT_2P_ASSIGN:
+      tc_cancel_ctrl_blk( blk_owner_i );
+      tc_stop_normal_burst_req( );
+      break;
+    case TC_TBF_ACTIVE:  
+    case TC_CONTENTION_RESOLUTION:
+      tc_cancel_ctrl_blk( blk_owner_i );
+      tc_handle_error_ra();
+      break;
+    default:
+      TRACE_EVENT( "SIG_CTRL_TC_CANCEL_CONTROL_BLOCK unexpected" );
+      break;
+  }
+} /* sig_ctrl_tc_cancel_control_block () */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_enable_grlc
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_ENABLE_GRLC
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_enable_grlc  (UBYTE queue_mode, UBYTE  cell_update_cause )
+{ 
+  TRACE_ISIG( "sig_ctrl_tc_enable_grlc" );
+
+  if(cell_update_cause EQ GMMRR_RA_CU)
+    tc_cgrlc_enable_req(queue_mode,CGRLC_RA_CU,FALSE,CGRLC_ENAC_NORMAL);
+  else
+    tc_cgrlc_enable_req(queue_mode,CGRLC_RA_DEFAULT,FALSE,CGRLC_ENAC_NORMAL);
+
+} /* sig_ctrl_tc_enable_grlc() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_access_disable
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_ACCESS_DISABLE
+|
+| Parameters  : dc - disable cause
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_access_disable 
+                                   ( T_TC_DISABLE_CAUSE         disable_cause,
+                                     T_TC_DISABLE_CALLBACK_FUNC callback_func ) 
+{ 
+  UBYTE         disable_class;
+
+  T_TC_DC_CLASS dc_class =          ( disable_cause & DCM_CLASS );
+  T_TC_DC_TYPE  dc_type  = ( UBYTE )( disable_cause & DCM_TYPE  );
+  UBYTE         state    = GET_STATE( TC );
+  UBYTE         prim_st  = CGRLC_PRIM_STATUS_NULL;
+
+  TRACE_ISIG( "sig_ctrl_tc_access_disable" );
+
+  disable_class =
+    ( dc_class EQ DCC_CR ? CGRLC_DISABLE_CLASS_CR : CGRLC_DISABLE_CLASS_OTHER );
+
+  if( grr_data->tc.disable_class EQ  CGRLC_DISABLE_CLASS_NULL OR 
+      disable_class              NEQ CGRLC_DISABLE_CLASS_CR      )
+  {
+    grr_data->tc.disable_class = disable_class;
+  }
+  if ( disable_cause EQ TC_DC_CR_NETWORK)
+  {
+    TRACE_EVENT("T3170 stopped if disable cause is NW CR");
+    vsi_t_stop(GRR_handle,T3170);
+  }
+  switch( state )
+  {
+    case TC_CPAP:
+      sig_tc_cpap_abort_access();
+
+      SET_STATE( TC, TC_ACCESS_DISABLED );
+
+      tc_cgrlc_disable_req(prim_st);
+
+      callback_func( );
+      break;
+
+    case TC_WAIT_2P_ASSIGN:
+      vsi_t_stop( GRR_handle, T3168 );
+#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
+      if(grr_data->tbf_type EQ CGRLC_TBF_MODE_2PA)
+      {
+        tc_abort_tbf( grr_data->tbf_type );
+      }
+      else
+#endif
+      {
+        tc_stop_normal_burst_req( );        
+      }
+
+      SET_STATE( TC, TC_ACCESS_DISABLED );
+
+      if( dc_class EQ DCC_SUSPEND )
+      {
+        prim_st = CGRLC_PRIM_STATUS_ONE; 
+      }
+      tc_cgrlc_disable_req(prim_st);
+
+      grr_data->tc.disable_callback_func = callback_func;
+      break;
+
+    case TC_POLLING:
+    case TC_WAIT_ASSIGN:
+      tc_send_ra_stop_req( );
+
+      SET_STATE( TC, TC_ACCESS_DISABLED );
+
+      if( dc_class EQ DCC_SUSPEND )
+      {
+        prim_st = CGRLC_PRIM_STATUS_ONE;
+      }
+      tc_cgrlc_disable_req(prim_st);
+
+      callback_func( );
+      break;
+
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+      TRACE_EVENT_P1( "SIG_CTRL_TC_ACCESS_DISABLE: %s of TBF",
+                      dc_type EQ DCT_NORMAL ? "normal release" : "abort" );
+
+      if(!grr_data->tc.two_2p_w_4_tbf_con AND
+         ( dc_type NEQ DCT_NORMAL ))
+      {
+        TRACE_EVENT("SB SUSPEND Before TBF_C");
+        tc_stop_normal_burst_req( );
+        SET_STATE( TC, TC_ACCESS_DISABLED );       
+        if( dc_class EQ DCC_SUSPEND )
+        {
+          prim_st = CGRLC_PRIM_STATUS_ONE; 
+        }
+        tc_cgrlc_disable_req(prim_st);
+      }
+      else if( dc_type NEQ DCT_NORMAL )
+      {
+        if( grr_data->tc.num_of_rels_running EQ  0             OR
+            grr_data->tbf_type               NEQ CGRLC_TBF_MODE_NULL    )
+        {
+          tc_abort_tbf( grr_data->tbf_type );
+
+          SET_STATE( TC, TC_ACCESS_DISABLED );
+        }
+        tc_cgrlc_disable_req(prim_st);
+      }
+
+      grr_data->tc.disable_callback_func = callback_func;
+      break;
+
+    case TC_SINGLE_BLOCK:
+      tc_stop_normal_burst_req( );
+      tc_set_stop_all_ctrl_blk( );
+
+      tc_cgrlc_disable_req(prim_st);
+
+      SET_STATE( TC, TC_ACCESS_DISABLED );
+
+      grr_data->tc.disable_callback_func = callback_func;
+      break;
+
+    case TC_PIM:
+     
+      tc_cgrlc_disable_req(prim_st);
+
+      if( grr_data->tc.num_of_rels_running NEQ 0 )
+      {
+        /* 
+         * disable request during TBF release procedure,
+         * GRR is waiting for RRGRR_STOP_TASK_CNF
+         */
+        TRACE_EVENT( "SIG_CTRL_TC_ACCESS_DISABLE: TBF release procedure is running" );
+
+        grr_data->tc.disable_callback_func = callback_func;
+      }
+      else
+      {
+        SET_STATE( TC, TC_ACCESS_DISABLED );
+
+        callback_func( );
+      }
+      break;
+
+    default:
+      TRACE_EVENT_P1( "SIG_CTRL_TC_ACCESS_DISABLE in TC state %d", state );
+
+      /*lint -fallthrough*/
+
+    case TC_ACCESS_DISABLED:
+    case TC_WAIT_STOP_TASK_CNF:
+
+      tc_cgrlc_disable_req(prim_st);
+
+      SET_STATE( TC, TC_ACCESS_DISABLED );
+      
+      if( grr_data->tc.disable_callback_func EQ NULL )
+      {
+        callback_func( );
+      }
+      else
+      {
+        grr_data->tc.disable_callback_func = callback_func;
+      }
+      break;
+  }
+#ifdef _SIMULATION_
+      tc_stop_timer_t3172();
+#endif
+} /* sig_ctrl_tc_access_disable() */
+
+
+
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_error_pim
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CPAP_TC_ERROR_PIM
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_error_pim ( void ) 
+{ 
+  TRACE_ISIG( "sig_cpap_tc_error_pim" );
+
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      SET_STATE( TC, TC_PIM );
+
+      tc_handle_error_pim();
+      break;
+    
+    default:
+      TRACE_ERROR( "SIG_CPAP_TC_ERROR_PIM unexpected" );
+      break;
+  }
+} /* sig_cpap_tc_error_pim() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_tbf_created
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CPAP_TC_TBF_CREATED
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_tbf_created ( T_TBF_TYPE tbf_type ) 
+{ 
+  TRACE_ISIG( "sig_cpap_tc_tbf_created" );
+
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      switch(tbf_type)
+      {
+        case CGRLC_TBF_MODE_UL:
+          SET_STATE(TC,TC_CONTENTION_RESOLUTION);
+          tc_activate_tbf(tbf_type);
+          tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL);
+          break;
+        case CGRLC_TBF_MODE_DL:
+          SET_STATE(TC,TC_TBF_ACTIVE);
+          tc_activate_tbf(tbf_type);
+          tc_cgrlc_dl_tbf_req();
+          break;
+        default:
+          TRACE_ERROR("unknown tbf type! sig_cpap_tc_tbf_created");
+          SET_STATE(TC,TC_PIM);
+          break;
+      }
+      break;
+    case TC_PIM:
+      switch(tbf_type)
+      {
+        case CGRLC_TBF_MODE_UL:
+          TRACE_ERROR("unexpected tbf type! sig_cpap_tc_tbf_created");
+          break;
+        case CGRLC_TBF_MODE_DL:
+          SET_STATE(TC,TC_TBF_ACTIVE);
+          tc_activate_tbf(tbf_type);
+          tc_cgrlc_dl_tbf_req();
+          break;
+        default:
+          TRACE_ERROR("unknown tbf type! sig_cpap_tc_tbf_created 2");
+          SET_STATE(TC,TC_PIM);
+          break;
+      }
+      break;
+    default:
+      TRACE_ERROR( "SIG_CPAP_TC_TBF_CREATED unexpected" );
+      break;
+  }
+} /* sig_cpap_tc_tbf_created() */
+
+
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_ia_received
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_IA_RECEIVED
+|
+| Parameters  : -
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_ia_received (T_RRGRR_IA_IND *rrgrr_ia_ind )
+{ 
+  TRACE_ISIG( "sig_ctrl_tc_ia_received" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+    case TC_SINGLE_BLOCK:
+    case TC_PIM:
+    case TC_WAIT_ASSIGN:
+    case TC_POLLING:
+    case TC_WAIT_2P_ASSIGN:
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+      sig_tc_cpap_ia_received(rrgrr_ia_ind);
+      break;
+    default:
+      TRACE_ERROR( "sig_ctrl_tc_ia_received unexpected" );
+      break;
+  }
+} /* sig_ctrl_tc_ia_received() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_iaext_received
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_IAEXT_RECEIVED
+|
+| Parameters  : UBYTE indicates the valid immediate assignment
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_iaext_received ( T_RRGRR_IAEXT_IND *rrgrr_iaext_ind )
+{ 
+  TRACE_ISIG( "sig_ctrl_tc_iaext_received" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      sig_tc_cpap_iaext_received ( rrgrr_iaext_ind);
+      break;
+    case TC_SINGLE_BLOCK:
+    case TC_PIM:
+    case TC_WAIT_ASSIGN:
+    case TC_POLLING:
+    case TC_WAIT_2P_ASSIGN:
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+
+      break;
+    default:
+      TRACE_ERROR( "sig_ctrl_tc_iaext_received unexpected" );
+      break;
+  }
+} /* sig_ctrl_tc_iaext_received() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_iarej_received
++------------------------------------------------------------------------------
+| Description : Handles the internal signal sig_ctrl_tc_iarej_received 
+|
+| Parameters  : -
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_iarej_received(T_RRGRR_ASSIGNMENT_REJ_IND *rrgrr_assignment_rej_ind )
+{ 
+  TRACE_ISIG( "sig_ctrl_tc_iarej_received" );
+   
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      sig_tc_cpap_iarej_received(rrgrr_assignment_rej_ind);
+      if(grr_data->cc_running)
+      {
+         SET_STATE(TC,TC_ACCESS_DISABLED)
+         /*
+          * todo:why state change: grlc will be disabled by sending ctrl_tc_disable
+          */
+      }
+      break;
+    case TC_SINGLE_BLOCK:
+    case TC_PIM:
+    case TC_WAIT_ASSIGN:
+    case TC_POLLING:
+    case TC_WAIT_2P_ASSIGN:
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+
+      break;
+    default:
+      TRACE_ERROR( "sig_ctrl_tc_iarej_received unexpected" );
+      break;
+  }
+
+} /* sig_ctrl_tc_iarej_received() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_ia_downlink_received
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_IA_DOWNLINK_RECEIVED 
+|
+| Parameters  : -
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_ia_downlink_received (T_RRGRR_IA_DOWNLINK_IND *rrgrr_ia_downlink_in )
+{ 
+  TRACE_ISIG( "sig_ctrl_tc_ia_downlink_received" );
+
+ 
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+    case TC_SINGLE_BLOCK:
+    case TC_PIM:
+    case TC_WAIT_ASSIGN:
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+      sig_tc_cpap_ia_downlink_received(rrgrr_ia_downlink_in);
+      break;
+    default:
+      sig_tc_ctrl_send_stop_task_req( INVALID_MSG );
+      TRACE_EVENT_P1( "sig_ctrl_tc_ia_downlink_received unexpected tc_state=%d", grr_data->tc.state);
+      TRACE_ERROR( "sig_ctrl_tc_ia_downlink_received unexpected" );
+      break;
+  }
+  
+} /* sig_ctrl_tc_ia_downlink_received() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_stop_task_cnf_received
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_STOP_TASK_CNF
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_stop_task_cnf_received ( void )
+{ 
+  TRACE_ISIG( "sig_ctrl_tc_stop_task_cnf_received" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+    case TC_PIM:
+      sig_tc_cpap_stop_task_cnf_received();
+      break;
+    default:
+      TRACE_ERROR( "SIG_CTRL_TC_STOP_TASK_CNF unexpected" );
+      break;
+  }
+} /* sig_ctrl_tc_stop_task_cnf_received() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_send_stop_task_req
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_STOP_TASK_REQ
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_send_stop_task_req( UBYTE v_stop_ccch  )
+{ 
+  TRACE_ISIG( "sig_cpap_tc_send_stop_task_req" );
+  
+  sig_tc_ctrl_send_stop_task_req( v_stop_ccch );
+
+} /* sig_cpap_tc_send_stop_task_req() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_channel_req
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CPAP_TC_CHANNEL_REQ 
+|
+| Parameters  :  req_data - data which RR has to send
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_channel_req(UBYTE req_data )
+{ 
+  TRACE_ISIG( "sig_cpap_tc_channel_req" );
+ 
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      sig_tc_ctrl_channel_req(req_data); 
+      break;
+    default:
+      TRACE_ERROR( "sig_cpap_tc_channel_req unexpected" );
+      break;
+  }
+} /* sig_cpap_tc_channel_req() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_assign_sb
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CPAP_TC_ASSIGN_SB 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_assign_sb(void *ptr2prim, UBYTE purpose)
+{ 
+  TRACE_ISIG( "sig_cpap_tc_assign_sb" );
+
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      if(TWO_PHASE_ACESS EQ purpose)
+      {
+        SET_STATE(TC,TC_WAIT_2P_ASSIGN);
+      }
+      else
+      {
+        SET_STATE(TC,TC_SINGLE_BLOCK);
+      }
+
+      sig_tc_meas_update_pch( );
+
+      {
+        T_MPHP_SINGLE_BLOCK_REQ* mphp_single_block_req = ( T_MPHP_SINGLE_BLOCK_REQ* )ptr2prim;
+        
+        TRACE_BINDUMP
+          ( hCommGRR, TC_USER4,
+            cl_rlcmac_get_msg_name
+              ( ( UBYTE )( mphp_single_block_req->l2_frame[1] >> 2 ), RLC_MAC_ROUTE_UL ),
+            mphp_single_block_req->l2_frame, MAX_L2_FRAME_SIZE ); /*lint !e569*/
+      }
+
+      PSEND(hCommL1,ptr2prim);
+      break;
+    case TC_PIM:
+      if(SINGLE_BLOCK_TRANSFER_DL EQ purpose)
+      {
+        SET_STATE(TC,TC_SINGLE_BLOCK);
+        PSEND(hCommL1,ptr2prim);
+      }
+      else
+      { /* this shall never happen! */
+        TRACE_ERROR("FATAL ERROR: single block assignment in wrong state!");
+        PFREE(ptr2prim);
+      }
+      break;
+    default:
+      TRACE_ERROR( "sig_cpap_tc_assign_sb unexpected" );
+      PFREE(ptr2prim);
+      break;
+  }
+} /* sig_cpap_tc_assign_sb() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_pdch_assign_received
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_PDCH_ASSIGN_RECEIVED 
+|
+| Parameters  : fn - reception frame number
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_pdch_assign_received( T_RRGRR_DATA_IND *rrgrr_data_ind )
+{ 
+  TRACE_ISIG( "sig_ctrl_tc_pdch_assign_received" );
+
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      sig_tc_cpap_pdch_assign_received(rrgrr_data_ind);
+      break;
+
+    case TC_SINGLE_BLOCK:
+    case TC_PIM:
+    case TC_WAIT_ASSIGN:
+    case TC_POLLING:
+    case TC_WAIT_2P_ASSIGN:
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+      break;
+    default:
+      TRACE_ERROR( "sig_ctrl_tc_pdch_assign_received unexpected" );
+      break;
+  }
+} /* sig_ctrl_tc_pdch_assign_received() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_dcch_data_req
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CPAP_TC_DCCH_DATA_REQ 
+|
+| Parameters  : pointer - to primitive with data 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_dcch_data_req( T_RRGRR_DATA_REQ * rrgrr_data_req_i )
+{ 
+  TRACE_ISIG( "sig_cpap_tc_dcch_data_req" );
+ 
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      sig_tc_ctrl_dcch_data_req(rrgrr_data_req_i);
+      break;
+    default:
+      TRACE_ERROR( "sig_cpap_tc_dcch_data_req unexpected" );
+      break;
+  }
+} /* sig_cpap_tc_dcch_data_req() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_assign_pdch
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CPAP_TC_ASSIGN_PDCH 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_assign_pdch(T_MPHP_ASSIGNMENT_REQ *ptr2prim,
+                                    T_PDCH_ASS_CAUSE cause )
+{ 
+  TRACE_ISIG( "sig_cpap_tc_assign_pdch" );
+
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      grr_data->tc.dcch_present = FALSE;
+      if( (PDCH_UL_ASS_CMD EQ cause) OR (PDCH_DL_ASS_CMD EQ cause) )
+      {
+        grr_data->tc.dcch_present = TRUE;
+      }
+
+      PSEND(hCommL1,ptr2prim);
+      break;
+    case TC_PIM:
+      grr_data->tc.dcch_present = FALSE;
+      if((IA_UL EQ cause) OR (PDCH_UL_ASS_CMD EQ cause))
+      {
+        PFREE(ptr2prim);
+        TRACE_ERROR( "uplink assignments unexpected in PIM" );
+      }
+      else
+      {        
+        if((PDCH_DL_ASS_CMD EQ cause))
+          grr_data->tc.dcch_present = TRUE;
+
+        PSEND(hCommL1,ptr2prim);
+      }
+      break;
+    case TC_WAIT_ASSIGN:
+    case TC_POLLING:
+    case TC_WAIT_2P_ASSIGN:
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+      TRACE_ERROR( "sig_cpap_tc_assign_pdch unexpected" );
+      PFREE(ptr2prim);
+      break;
+    default:
+      TRACE_ERROR( "sig_cpap_tc_assign_pdch unexpected" );
+      FREE(ptr2prim);
+      break;
+  }
+} /* sig_cpap_tc_assign_pdch() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_suspend_dedi_chan
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CPAP_TC_SUSPEND_DEDI_CHAN 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_suspend_dedi_chan(void )
+{ 
+  TRACE_ISIG( "sig_cpap_tc_suspend_dedi_chan" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      sig_tc_ctrl_suspend_dedi_chan();
+      break;
+    case TC_SINGLE_BLOCK:
+    case TC_PIM:
+    case TC_WAIT_ASSIGN:
+    case TC_POLLING:
+    case TC_WAIT_2P_ASSIGN:
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+      TRACE_ERROR( "sig_cpap_tc_suspend_dedi_chan unexpected" );
+
+      break;
+    default:
+      TRACE_ERROR( "sig_cpap_tc_suspend_dedi_chan unexpected" );
+      break;
+  }
+} /* sig_cpap_tc_suspend_dedi_chan() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_resume_dedi_chan
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CPAP_TC_RESUME_DEDI_CHAN 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_resume_dedi_chan(void )
+{ 
+  TRACE_ISIG( "sig_cpap_tc_resume_dedi_chan" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      sig_tc_ctrl_resume_dedi_chan();
+      break;
+    case TC_SINGLE_BLOCK:
+    case TC_PIM:
+    case TC_WAIT_ASSIGN:
+    case TC_POLLING:
+    case TC_WAIT_2P_ASSIGN:
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+      TRACE_ERROR( "sig_cpap_tc_resume_dedi_chan unexpected" );
+
+      break;
+    default:
+      TRACE_ERROR( "sig_cpap_tc_resume_dedi_chan unexpected" );
+      break;
+  }
+} /* sig_cpap_tc_resume_dedi_chan() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_send_gprs_data_req
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CPAP_TC_SEND_GPRS_DATA_REQ 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_send_gprs_data_req(T_RRGRR_GPRS_DATA_REQ *rrgrr_gprs_data_req)
+{ 
+  TRACE_ISIG( "sig_cpap_tc_send_gprs_data_req" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      sig_tc_ctrl_gprs_data_req(rrgrr_gprs_data_req);
+      break;
+    case TC_SINGLE_BLOCK:
+    case TC_PIM:
+    case TC_WAIT_ASSIGN:
+    case TC_POLLING:
+    case TC_WAIT_2P_ASSIGN:
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+      TRACE_ERROR( "sig_cpap_tc_send_gprs_data_req unexpected" );
+
+      break;
+    default:
+      TRACE_ERROR( "sig_cpap_tc_send_gprs_data_req unexpected" );
+      break;
+  }
+} /* sig_cpap_tc_send_gprs_data_req() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_suspend_dcch_cnf
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_SUSPEND_DCCH_CNF 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_suspend_dcch_cnf(void)
+{ 
+  TRACE_ISIG( "sig_ctrl_tc_suspend_dcch_cnf" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      sig_tc_cpap_suspend_dcch_cnf();
+      break;
+    case TC_SINGLE_BLOCK:
+    case TC_PIM:
+    case TC_WAIT_ASSIGN:
+    case TC_POLLING:
+    case TC_WAIT_2P_ASSIGN:
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+      TRACE_ERROR( "sig_ctrl_tc_suspend_dcch_cnf unexpected" );
+
+      break;
+    default:
+      TRACE_ERROR( "sig_ctrl_tc_suspend_dcch_cnf unexpected" );
+      break;
+  }
+} /* sig_ctrl_tc_suspend_dcch_cnf() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_build_res_req
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CPAP_TC_BUILD_RES_REQ 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_build_res_req(T_U_RESOURCE_REQ *ptr2res_req)
+{ 
+  TRACE_ISIG( "sig_cpap_tc_build_res_req" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+      tc_build_res_req( ptr2res_req,
+                        R_BUILD_2PHASE_ACCESS,
+                        SRC_TBF_INFO_IMM_ASSIGN ); 
+      break;
+    case TC_SINGLE_BLOCK:
+    case TC_PIM:
+    case TC_WAIT_ASSIGN:
+    case TC_POLLING:
+    case TC_WAIT_2P_ASSIGN:
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+    default:
+      TRACE_ERROR( "sig_cpap_tc_build_res_req unexpected" );
+      break;
+  }
+} /* sig_cpap_tc_build_res_req() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_ctrl_ptm
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CPAP_TC_CTRL_PTM 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_ctrl_ptm(void)
+{ 
+  TRACE_ISIG( "sig_cpap_tc_ctrl_ptm" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CPAP:
+    case TC_PIM:
+      sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_TRANSFER, TASK_STOP_DUMMY_VALUE );
+      break;
+    case TC_SINGLE_BLOCK:
+    case TC_WAIT_ASSIGN:
+    case TC_POLLING:
+    case TC_WAIT_2P_ASSIGN:
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+      TRACE_ERROR( "sig_cpap_tc_ctrl_ptm unexpected" );
+
+      break;
+    default:
+      TRACE_ERROR( "sig_cpap_tc_ctrl_ptm unexpected" );
+      break;
+  }
+} /* sig_cpap_tc_ctrl_ptm() */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_fix_alloc_ack_ptm
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_GFP_TC_FIX_ALLOC_ACK_PTM 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_fix_alloc_ack_ptm( void )
+{ 
+  MCAST(d_ul_ack,D_UL_ACK);
+  TRACE_ISIG( "sig_ru_tc_fix_alloc_ack" );
+
+  grr_data->uplink_tbf.cs_mode = d_ul_ack->gprs_ul_ack_nack_info.chan_coding_cmd;
+ 
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+      if(d_ul_ack->gprs_ul_ack_nack_info.v_f_alloc_ack EQ 0 )
+      {
+        /*
+         * if no fix alloc is present in last uplink ack/nack, delete any existing repeat alloc
+         */
+        if(grr_data->tc.fa_ctrl.fa_type EQ FA_REPEAT)
+        {
+          /*kill reapeat alloc, which is not yet started*/
+          grr_data->tc.fa_ctrl.fa_type        = FA_NO_NEXT;
+          grr_data->tc.fa_ctrl.repeat_alloc   = FALSE;
+          tc_send_ul_repeat_alloc_req();
+        }
+        else if(grr_data->tc.fa_ctrl.fa_type EQ FA_NO_NEXT AND 
+                grr_data->tc.fa_ctrl.repeat_alloc  EQ TRUE )
+        {
+          if(!grr_check_if_tbf_start_is_elapsed ( grr_data->tc.fa_ctrl.current_alloc.alloc_start_fn, grr_data->ul_fn))
+            /*grr_data->tc.fa_ctrl.ul_res_remain EQ grr_data->tc.fa_ctrl.current_alloc.ul_res_sum*/
+          {
+            /*kill reapeat alloc if is not yet started*/
+            grr_data->tc.fa_ctrl.fa_type = FA_NO_CURRENT;
+            grr_data->tc.fa_ctrl.repeat_alloc   = FALSE;
+            tc_send_ul_repeat_alloc_req();
+          }
+        }
+        return;
+      }
+
+      /*
+       * check if current allocation is active 
+       */
+      if(grr_data->tc.fa_ctrl.fa_type EQ FA_NO_CURRENT  AND
+         d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.v_ts_overr )
+      {
+        ULONG next_start_fn;
+        ULONG next_end_fn;
+        /* repeat allocation in packet uplink ack/nack received,
+         * no fixed allocation active, find out the next natural boundary
+         * and store new allocation in current allocation
+         */
+        grr_data->tc.fa_ctrl.fa_type        = FA_NO_NEXT;
+        grr_data->tc.fa_ctrl.repeat_alloc   = TRUE;
+        grr_data->tc.fa_ctrl.ts_overr       = d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.ts_overr;
+        tc_set_fa_bitmap((UBYTE)(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.ts_overr & grr_data->uplink_tbf.ts_usage),
+                            &grr_data->tc.fa_ctrl.current_alloc);
+        /*find  start of alloc (natural boundary of next allocation)*/
+        next_end_fn = grr_data->tc.fa_ctrl.current_alloc.alloc_end_fn;
+        do
+        {
+          USHORT len;
+          len = grr_data->tc.fa_ctrl.current_alloc.alloc.size_bitmap-1;
+          next_start_fn = grr_decode_tbf_start_rel(next_end_fn,0);
+          next_end_fn   = grr_decode_tbf_start_rel(next_start_fn,(USHORT)(len-1));
+          if(grr_data->ul_fn EQ next_start_fn)
+            break;
+          else if((next_end_fn > next_start_fn)   AND 
+                  (grr_data->ul_fn <= next_start_fn) AND
+                  (grr_data->ul_fn > next_start_fn) )
+          {
+            next_start_fn = grr_decode_tbf_start_rel(next_end_fn,0);
+            next_end_fn   = grr_decode_tbf_start_rel(next_start_fn,(USHORT)(len-1));
+            break;
+          }
+          else if( (next_end_fn < next_start_fn) AND
+                   (
+                    ((next_end_fn >= grr_data->ul_fn) AND (next_start_fn > grr_data->ul_fn)) OR
+                    ((next_end_fn <  grr_data->ul_fn) AND (next_start_fn < grr_data->ul_fn))
+                   )
+                 )
+          {
+            next_start_fn = grr_decode_tbf_start_rel(next_end_fn,0);
+            next_end_fn = grr_decode_tbf_start_rel(next_start_fn,(USHORT)(len-1));
+            break;
+          }
+        }
+        while (1);
+        grr_data->tc.fa_ctrl.current_alloc.alloc_start_fn = next_start_fn;
+        grr_data->tc.fa_ctrl.current_alloc.alloc_end_fn   = next_end_fn;          
+        tc_send_ul_repeat_alloc_req();
+        return;
+      }
+      else if(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.v_ts_overr )
+      {
+        UBYTE len;
+        /* repeat allocation in packet uplink ack/nack received,
+         * current allocation is active, store new alloc in next alloc
+         * overwriting is possibe.
+         */        
+        grr_data->tc.fa_ctrl.fa_type        = FA_REPEAT;
+        grr_data->tc.fa_ctrl.repeat_alloc   = TRUE;
+        grr_data->tc.fa_ctrl.ts_overr       = d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.ts_overr;
+        tc_set_fa_bitmap((UBYTE)(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.ts_overr & grr_data->uplink_tbf.ts_usage),&grr_data->tc.fa_ctrl.current_alloc);
+        
+        grr_data->tc.fa_ctrl.current_alloc.alloc_start_fn = 
+            grr_decode_tbf_start_rel(grr_data->tc.fa_ctrl.current_alloc.alloc_end_fn,0);
+        len = grr_data->tc.fa_ctrl.current_alloc.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));
+        tc_send_ul_repeat_alloc_req();
+        return;
+      }
+      grr_data->tc.fa_ctrl.repeat_alloc   = FALSE;
+      if( d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.v_fa_s2 )      
+      {
+        /*
+         * new fixed allocation with allocation bitmap
+         */
+        if(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.v_ts_alloc)
+        {
+          UBYTE tx_slots;
+          tx_slots = grr_calc_nr_of_set_bits (d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.ts_alloc);
+          grr_data->uplink_tbf.nts = tx_slots;
+          grr_data->uplink_tbf.ts_usage = d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.ts_alloc;
+          if(!handle_ms_cap(UL_ASSIGNMENT))
+          {
+            TRACE_ERROR( "TS_ALLOC not valid" );
+            return;
+          }
+        }
+        tc_handle_tbf_start(CGRLC_TBF_MODE_UL);
+      }
+      else
+      {
+        TRACE_EVENT("NO FIX ALLOC STRUCT IN D_UL_ACK " );
+      }
+      break;
+    default:
+      TRACE_ERROR( "sig_ru_tc_fix_alloc_ack unexpected" );
+      break;
+  }
+
+
+
+} /* sig_gfp_tc_fix_alloc_ack_ptm() */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_reconnect_cnf
++------------------------------------------------------------------------------
+| Description : Cell reselection has failled and we have to inform cpap 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL void sig_ctrl_tc_reconnect_dcch_cnf()
+{
+  TRACE_ISIG( "sig_ctrl_tc_reconnect_cnf" );
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+    case TC_WAIT_ASSIGN:
+      SET_STATE(TC, TC_ACCESS_DISABLED);
+      sig_tc_cpap_reconnect_ind();
+      break;
+    default:
+      TRACE_ERROR( "sig_ctrl_tc_reconnect_cnf unexpected" );
+  }
+}
+/*sig_ctrl_tc_reconnect_dcch_cnf()*/
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_cr_timerout_cnf
++------------------------------------------------------------------------------
+| Description : Cell reselection has failled because of timer out 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL void sig_ctrl_tc_cr_timerout_cnf()
+{
+  TRACE_ISIG( "sig_ctrl_tc_cr_timerout_cnf" );
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CONTENTION_RESOLUTION:    
+    case TC_TBF_ACTIVE:
+    case TC_WAIT_ASSIGN:
+      tc_abort_tbf(grr_data->tbf_type);
+      SET_STATE(TC, TC_ACCESS_DISABLED);
+      sig_tc_cpap_reconnect_ind();
+      break;
+    default:
+      TRACE_ERROR( "sig_ctrl_cr_timerout_cnf unexpected" );
+ }
+   
+
+}/*sig_ctrl_tc_cr_timerout_cnf()*/
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_abnorm_rel_with_cr_failed
++------------------------------------------------------------------------------
+| Description : Handles the internal signal 
+|               SIG_CTRL_TC_ABNORM_REL_WITH_CR_FAILED
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL sig_ctrl_tc_abnorm_rel_with_cr_failed ( BOOL cell_has_changed )
+{ 
+  TRACE_ISIG( "sig_ctrl_tc_abnorm_rel_with_cr_failed" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_ACCESS_DISABLED:
+      SET_STATE_TC_PIM_AFTER_ACCESS_DISABLED
+              ( cell_has_changed, CGRLC_ENAC_ABNORM_RELEASE_CRESELECT_FAILED );
+      break;
+
+    default:
+      TRACE_ERROR( "SIG_CTRL_TC_ABNORM_REL_WITH_CR_FAILED unexpected" );
+      break;
+  }
+
+  return( TRUE );
+} /* sig_ctrl_tc_abnorm_rel_with_cr_failed() */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_start_T3142
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CPAP_TC_START_T3142,
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_start_T3142(ULONG wait)
+{ 
+  TRACE_ISIG( "sig_cpap_tc_start_T3142" );
+
+  tc_start_timer_t3172(wait);
+  sig_tc_ctrl_t3172_running();
+
+} /* sig_cpap_tc_start_T3142 */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_cpap_tc_stop_T3142
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CPAP_TC_STOP_T3142,
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_cpap_tc_stop_T3142(void)
+{ 
+  TRACE_ISIG( "sig_cpap_tc_stop_T3142" );
+
+
+} /* sig_cpap_tc_stop_T3142 */
+
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_disable_prim_queue
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_DISABLE_PRIM_QUEUE
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL BOOL sig_ctrl_tc_disable_prim_queue ( BOOL cell_has_changed ) 
+{ 
+  TRACE_EVENT( "sig_ctrl_tc_disable_prim_queue" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_ACCESS_DISABLED:
+      SET_STATE_TC_PIM_AFTER_ACCESS_DISABLED( cell_has_changed,
+                                              CGRLC_ENAC_NORMAL );
+      break;
+    default:
+      TRACE_ERROR( "SIG_CTRL_TC_DISABLE_PRIM_QUEUE unexpected" );
+      break;
+  }
+
+  return( TRUE);
+} /* sig_ctrl_tc_disable_prim_queue() */
+
+
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_meas_tc_update_ta_req
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_MEAS_TC_UPDATE_TA_REQ.
+|               New TA values are received, it shall passed to l1
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_meas_tc_update_ta_req ( void)
+{ 
+  MCAST(d_ctrl_pwr_ta,D_CTRL_PWR_TA); /* T_D_CTRL_PWR_TA */
+
+  TRACE_FUNCTION( "tc_send_reconf_tbf_ta_req" );
+
+  TRACE_EVENT_P9("TAU: %d tav=%d - %d %d %d - %d %d %d tbf_type=%d"
+                                                                  ,d_ctrl_pwr_ta->gpta.v_ta_value
+                                                                  ,d_ctrl_pwr_ta->gpta.ta_value
+                                                                  ,d_ctrl_pwr_ta->gpta.v_ul_ta_index
+                                                                  ,d_ctrl_pwr_ta->gpta.ul_ta_index
+                                                                  ,d_ctrl_pwr_ta->gpta.ul_ta_tn
+                                                                  ,d_ctrl_pwr_ta->gpta.v_dl_ta_index
+                                                                  ,d_ctrl_pwr_ta->gpta.dl_ta_index
+                                                                  ,d_ctrl_pwr_ta->gpta.dl_ta_tn
+                                                                  ,grr_data->tbf_type );
+  switch(grr_data->tbf_type)
+  {
+    case CGRLC_TBF_MODE_DL_UL:
+      {
+        PALLOC(mphp_timing_advance_req,MPHP_TIMING_ADVANCE_REQ);/* T_MPHP_TIMING_ADVANCE_REQ */
+        mphp_timing_advance_req->assign_id = 0;
+        grr_handle_ta ( d_ctrl_pwr_ta->gpta.v_ta_value, 
+                        d_ctrl_pwr_ta->gpta.ta_value,
+                        d_ctrl_pwr_ta->gpta.v_ul_ta_index, 
+                        d_ctrl_pwr_ta->gpta.ul_ta_index,
+                        d_ctrl_pwr_ta->gpta.ul_ta_tn,
+                        d_ctrl_pwr_ta->gpta.v_dl_ta_index,
+                        d_ctrl_pwr_ta->gpta.dl_ta_index,
+                        d_ctrl_pwr_ta->gpta.dl_ta_tn,
+                        &mphp_timing_advance_req->p_timing_advance);
+        PSEND(hCommL1,mphp_timing_advance_req);
+      }
+      break;
+    case CGRLC_TBF_MODE_DL:
+      {
+        PALLOC(mphp_timing_advance_req,MPHP_TIMING_ADVANCE_REQ);/* T_MPHP_TIMING_ADVANCE_REQ */
+        mphp_timing_advance_req->assign_id = 0;
+        if(d_ctrl_pwr_ta->gpta.v_ul_ta_index)
+        {
+          d_ctrl_pwr_ta->gpta.v_ul_ta_index = 0;
+          TRACE_EVENT("TAU: only dl tbf is running, ul ta index present");
+        }
+        if(!d_ctrl_pwr_ta->gpta.v_dl_ta_index)
+        {        
+          TRACE_EVENT("TAU: only dl tbf is running, no dl ta index present");
+        }
+        grr_handle_ta ( d_ctrl_pwr_ta->gpta.v_ta_value, 
+                        d_ctrl_pwr_ta->gpta.ta_value,
+                        d_ctrl_pwr_ta->gpta.v_ul_ta_index, 
+                        d_ctrl_pwr_ta->gpta.ul_ta_index,
+                        d_ctrl_pwr_ta->gpta.ul_ta_tn,
+                        d_ctrl_pwr_ta->gpta.v_dl_ta_index,
+                        d_ctrl_pwr_ta->gpta.dl_ta_index,
+                        d_ctrl_pwr_ta->gpta.dl_ta_tn,
+                        &mphp_timing_advance_req->p_timing_advance);
+        PSEND(hCommL1,mphp_timing_advance_req);
+      }
+      break;
+    case CGRLC_TBF_MODE_UL:
+      {
+        PALLOC(mphp_timing_advance_req,MPHP_TIMING_ADVANCE_REQ);/* T_MPHP_TIMING_ADVANCE_REQ */
+        mphp_timing_advance_req->assign_id = 0;
+        if(d_ctrl_pwr_ta->gpta.v_dl_ta_index)
+        {
+          d_ctrl_pwr_ta->gpta.v_dl_ta_index = 0;
+          TRACE_EVENT("TAU: only ul tbf is running, dl ta index present");
+        }
+        if(!d_ctrl_pwr_ta->gpta.v_ul_ta_index)
+        {        
+          TRACE_EVENT("TAU: only ul tbf is running, no ul ta index present");
+        }
+        grr_handle_ta ( d_ctrl_pwr_ta->gpta.v_ta_value, 
+                        d_ctrl_pwr_ta->gpta.ta_value,
+                        d_ctrl_pwr_ta->gpta.v_ul_ta_index, 
+                        d_ctrl_pwr_ta->gpta.ul_ta_index,
+                        d_ctrl_pwr_ta->gpta.ul_ta_tn,
+                        d_ctrl_pwr_ta->gpta.v_dl_ta_index,
+                        d_ctrl_pwr_ta->gpta.dl_ta_index,
+                        d_ctrl_pwr_ta->gpta.dl_ta_tn,
+                        &mphp_timing_advance_req->p_timing_advance);
+        PSEND(hCommL1,mphp_timing_advance_req);
+      }
+      break;
+    default:
+      TRACE_ERROR ( "sig_meas_tc_update_ta_req: TBF type is invalid" );
+      TRACE_EVENT_P1 ( "TBF type = %d",grr_data->tbf_type );
+      break;
+  }
+} /* sig_meas_tc_update_ta_req() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_update_ta_req_ptm
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_GFP_TC_UPDATE_TA_REQ_PTM.
+|               New TA values are received, it shall passed to l1
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_update_ta_req_ptm ( void)
+{
+  MCAST(d_ul_ack,D_UL_ACK);
+  PALLOC(mphp_timing_advance_req,MPHP_TIMING_ADVANCE_REQ);/* T_MPHP_TIMING_ADVANCE_REQ */
+
+  TRACE_FUNCTION( "tc_send_reconf_tbf_ta_req" );
+   
+  mphp_timing_advance_req->assign_id = 0; 
+
+  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,
+                  &mphp_timing_advance_req->p_timing_advance);
+  PSEND(hCommL1,mphp_timing_advance_req);
+} /* sig_gfp_tc_update_ta_req_ptm() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_enter_pam
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_ENTER_PAM.
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_enter_pam ( void )
+{
+  TRACE_ISIG( "sig_ctrl_tc_enter_pam" );
+
+  switch( GET_STATE( TC ) )
+  {
+    case TC_WAIT_STOP_TASK_CNF:
+      if( grr_is_pbcch_present( ) )
+      {
+        if( grr_data->tc.last_eval_assign.tbf_type EQ CGRLC_TBF_MODE_DL )
+        {
+          sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ASSIGNED,
+                                     grr_data->tc.last_eval_assign.ccch_read );
+        }
+        else
+        {
+          SET_STATE( TC, TC_WAIT_ASSIGN );
+          vsi_t_start( GRR_handle, T3186, T3186_VALUE );
+          tc_send_ra_req( );
+        }
+      }
+      else
+      {
+        SET_STATE( TC, TC_CPAP );
+        sig_tc_cpap_acc_req( );
+      }
+      break;
+
+    default:
+      TRACE_ERROR( "SIG_CTRL_TC_ENTER_PAM unexpected" );
+      break;
+  }
+} /* sig_ctrl_tc_enter_pam() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_leave_to_ptm
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_LEAVE_TO_PTM
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_leave_to_ptm ( void )
+{ 
+  TRACE_ISIG( "sig_ctrl_tc_leave_to_ptm" );
+
+  switch( GET_STATE( TC ) )
+  {
+    case TC_WAIT_STOP_TASK_CNF:
+      tc_mfree_assign( TRUE );
+
+#ifdef _SIMULATION_
+
+      switch( grr_data->tc.last_eval_assign.state )
+      {
+        case TC_ACCESS_DISABLED      : SET_STATE( TC, TC_ACCESS_DISABLED );       break;
+        case TC_CPAP                 : SET_STATE( TC, TC_CPAP );                  break;
+        case TC_PIM                  : SET_STATE( TC, TC_PIM );                   break;
+        case TC_WAIT_ASSIGN          : SET_STATE( TC, TC_WAIT_ASSIGN );           break;
+        case TC_POLLING              : SET_STATE( TC, TC_POLLING );               break;
+        case TC_WAIT_2P_ASSIGN       : SET_STATE( TC, TC_WAIT_2P_ASSIGN );        break;
+        case TC_CONTENTION_RESOLUTION: SET_STATE( TC, TC_CONTENTION_RESOLUTION ); break;
+        case TC_TBF_ACTIVE           : SET_STATE( TC, TC_TBF_ACTIVE);             break;
+        case TC_SINGLE_BLOCK         : SET_STATE( TC, TC_SINGLE_BLOCK);           break;
+        case TC_WAIT_STOP_TASK_CNF   : SET_STATE( TC, TC_WAIT_STOP_TASK_CNF);     break;
+
+        default:
+          SET_STATE( TC, grr_data->tc.last_eval_assign.state );
+          TRACE_ERROR( "sig_ctrl_tc_leave_to_ptm: unknown TC state" );
+          break;
+      }
+
+#else  /* #ifdef _SIMULATION_ */
+
+      SET_STATE( TC, grr_data->tc.last_eval_assign.state );
+
+#endif /* #ifdef _SIMULATION_ */
+
+      tc_handle_tbf_start( grr_data->tc.last_eval_assign.tbf_type );
+      break;
+
+    default:
+      TRACE_ERROR( "SIG_CTRL_TC_LEAVE_TO_PTM unexpected" );
+      break;
+  }
+} /* sig_ctrl_tc_leave_to_ptm() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_leave_to_pim
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_CTRL_TC_LEAVE_TO_PIM
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_ctrl_tc_leave_to_pim ( void )
+{ 
+  TRACE_ISIG( "sig_ctrl_tc_leave_to_pim" );
+
+  tc_send_tbf_release_req( grr_data->tc.last_tbf_type, FALSE );
+
+} /* sig_ctrl_tc_leave_to_pim() */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_access_rej_ptm
++------------------------------------------------------------------------------
+| Description : Handles the signal SIG_GFP_TC_ACCESS_REJ_PTM
+|
+| Parameters  : -
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_access_rej_ptm ( void )
+{ 
+  ULONG t3172_value=0;
+
+  TRACE_ISIG( "sig_gfp_tc_access_rej_ptm" );
+  TRACE_EVENT("ACC REJ PACCH" );
+
+  
+  switch(grr_data->tbf_type)
+  {
+    case CGRLC_TBF_MODE_UL:
+      /*
+       * wait for the end of the current UL TBF
+       */
+      if(grr_t_status( T3172_1 ) EQ 0)
+      {
+        TRACE_EVENT("Return to idle mode after release of DA");
+
+#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
+        if(grr_data->tc.tbf_est_pacch AND grr_t_status( T3170) EQ 0 )
+        {
+          /* GRLC has sent PCA or PRR. PAR received before PUA */
+          vsi_t_start(GRR_handle,T3170,tc_get_t3170_value());
+
+        }
+#endif
+      }
+
+      /*lint -fallthrough*/
+
+    case CGRLC_TBF_MODE_DL_UL:
+
+      /*
+       * UL TBF ends before the number of requested octets has been transferred, as if FINAL_ALLOCATION bit
+       * go to idle mode after release
+       * stop 3168
+       * check 3172
+       * Before initiating a new packet access procedure the mobile station shall decode the 
+       * PRACH Control Parameters if they are broadcast.
+       */
+
+      if(grr_data->uplink_tbf.mac_mode EQ FIXED_ALLOCATION)
+      {
+        tc_abort_tbf(CGRLC_TBF_MODE_UL); /* abort UL TBF*/
+
+      }
+      else if(grr_t_status( T3172_1 ) EQ 0 )
+      {
+        ;
+      }
+
+      /*lint -fallthrough*/
+
+    case CGRLC_TBF_MODE_DL:
+      if(grr_t_status( T3172_1 ) EQ 0 )
+      {
+        TRACE_EVENT("CGRLC_TBF_MODE_DL, T3172_1 is not running");
+        /*
+         * primtive is delted if prim_status is set, status indication is sent to higher layers
+         */
+        tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_ACCESS_FAILED,CGRLC_PRIM_STATUS_ONE);
+        switch( tc_eval_access_rej(&t3172_value) )
+        {
+          case E_ACCESS_REJ_WAIT:
+            tc_start_timer_t3172( t3172_value );
+            sig_tc_ctrl_t3172_running();
+            break;
+          case E_ACCESS_REJ_NO_WAIT:
+            TRACE_EVENT("NO WAIT_INDICATION: nothing to do");
+            break;
+          default:
+            break;
+        }
+      } /* no else because additional rejects have to be ignored!! */
+      break;
+#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
+    case CGRLC_TBF_MODE_2PA:
+      /* PRR is sent by GRLC. NW responds with PAR */
+      if(grr_data->tc.tbf_est_pacch)
+      {
+    
+        if(grr_t_status( T3170) EQ 0 )
+           vsi_t_start(GRR_handle,T3170,tc_get_t3170_value());
+
+        switch( tc_eval_access_rej(&t3172_value) )
+        {
+          case E_ACCESS_REJ_WAIT:
+            tc_start_timer_t3172( t3172_value );
+            sig_tc_ctrl_t3172_running();
+            break;
+          case E_ACCESS_REJ_NO_WAIT:
+            TRACE_EVENT("NO WAIT_INDICATION: nothing to do");
+            break;
+          default:
+            break;
+        }
+      }
+      break;
+#endif
+    default:
+      break;
+  }/* switch tbf_type*/
+  
+} /* sig_gfp_tc_access_rej_ptm() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_ts_reconfig_ptm
++------------------------------------------------------------------------------
+| Description : Handles the 
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_ts_reconfig_ptm ( void )
+{ 
+
+  TRACE_ISIG( "sig_gfp_tc_ts_reconfig_ptm" );
+  /*
+   * ASUMPTION:
+   * This primitive (re)assigns an uplink AND downlink assignment.
+   * if not the primitive is ignored.
+   * CASES:
+   * 1. ONLY UL_TBF is running:  reassignment of uplink AND assignment of downlink
+   * 2. ONLY DL_TBF is running:  reassignment of downlink AND assignment of uplink
+   * 3. DL_TBF AND UL_TBF is running:  reassignment of downlink AND reassignment of uplink
+   */    
+
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CONTENTION_RESOLUTION:
+      TRACE_ERROR("TS RECONF in CONT: RES. ignored");
+      break; /*ignore during contention resolution procedure*/
+    case TC_TBF_ACTIVE:
+      switch(tc_eval_ts_reconf())
+      {
+        /*handle tbf starting time for uplink*/
+        case E_TS_UL_REASSIG_NEW_DL:
+        case E_TS_NEW_UL_DL_REASSIG:
+        case E_TS_UL_REASSIG_DL_REASSIG:
+          /*
+          TRACE_EVENT("Packet TS Reconfigure ");
+          */
+          tc_handle_tbf_start( CGRLC_TBF_MODE_DL_UL );
+          break;
+        case E_TS_IGNORE:
+          /*no effect on current tbfs*/
+          break;
+        case E_TS_RECONFIG_ERROR_RA:
+          TRACE_EVENT("Packet TS Reconfigure invalid");
+          vsi_t_stop(GRR_handle,T3168); 
+          tc_handle_error_ra();
+          break;
+        default:
+          TRACE_ERROR( "SIG_GFP_TC_TS_RECONFIG_PTM unexpected" );
+          break;
+      }
+      break;
+    default:
+      TRACE_ERROR( "SIG_GFP_TC_TS_RECONFIG_PTM unexpected" );
+      break;
+  }
+
+} /* sig_gfp_tc_ts_reconfig_ptm() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_ul_assign_ptm
++------------------------------------------------------------------------------
+| Description : Handles the 
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_ul_assign_ptm  (void )
+{ 
+  TRACE_ISIG( "sig_gfp_tc_ul_assign_ptm " );
+
+
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:      
+      switch( tc_eval_ul_assign() )
+      {
+        case E_UL_ASSIGN_DYNAMIC:
+          /*
+          TRACE_EVENT("Packet UL Assignment with dynamic allocation");
+          */
+          tc_handle_tbf_start( CGRLC_TBF_MODE_UL );
+          break;
+        case E_UL_ASSIGN_FIXED:
+          /*
+          TRACE_EVENT("Packet UL Assignment with fixed allocation");
+          */
+          tc_handle_tbf_start( CGRLC_TBF_MODE_UL );
+          break;
+#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
+        case  E_UL_ASSIGN_SB_2PHASE_ACCESS:
+          if((grr_data->tc.tbf_est_pacch) AND 
+             (!psc_db->gprs_cell_opt.ctrl_ack_type))
+          {
+            /* Control ack type is Access burst. GRLC would have sent 
+             * PCA as poll for initiating TBF est on PACCH. Send UL_TBF_RES
+             * to GRLC. Packet resource request message will be sent by GRLC.			 
+             */
+            TRACE_EVENT("TBF on pacch");
+            SET_STATE(TC,TC_WAIT_2P_ASSIGN);
+            tc_handle_tbf_start( CGRLC_TBF_MODE_2PA);
+          }
+          break;
+#endif
+
+
+ 
+
+        default:
+          TRACE_EVENT("Packet UL Assignment invalid");
+          tc_handle_error_ra();
+          break;
+      }
+      break;
+    default:
+      TRACE_ERROR( "SIG_GFP_TC_UL_ASSIGN_PTM  unexpected" );
+      break;
+  }
+
+} /* sig_gfp_tc_ul_assign_ptm () */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_dl_assign_ptm 
++------------------------------------------------------------------------------
+| Description : Handles the 
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_dl_assign_ptm ( void )
+{ 
+  TRACE_ISIG( "sig_gfp_tc_dl_assign_ptm" );
+
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CONTENTION_RESOLUTION:
+      TRACE_ERROR("P. DL. ASS. in CONT: RES. ignored");
+      break; /*ignore during contention resolution procedure*/
+    case TC_TBF_ACTIVE:
+      switch( tc_eval_dl_assign() )
+      {
+        case E_DL_ASSIGN:
+          /*
+          TRACE_EVENT("Packet DL Assignment");
+          */
+          tc_handle_tbf_start( CGRLC_TBF_MODE_DL );
+          break;
+        case E_DL_ASSIGN_ERROR_RA:
+          TRACE_EVENT("Packet DL Assignment invalid");
+          tc_handle_error_ra();
+          break;
+        case E_DL_ASSIGN_IGNORE:
+          /*
+           *  If a failure in the PACKET DOWNLINK ASSIGNMENT is due to any reason, 
+           *  the mobile station shall abort the procedure and continue the normal 
+           *  operation of the uplink TBF.
+           */
+          break;
+        case E_DL_ASSIGN_ABORT_DL:
+          tc_abort_tbf(CGRLC_TBF_MODE_DL);
+          break;
+        default:
+          TRACE_ERROR( "Packet DL Assignment with unexpected content" );
+          break;
+      }
+      break;
+    default:
+      TRACE_ERROR( "SIG_GFP_TC_DL_ASSIGN_PTM unexpected" );
+      break;
+  }
+} /* sig_gfp_tc_dl_assign_ptm() */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_pdch_release_ptm ( tn );
++------------------------------------------------------------------------------
+| Description : Handles 
+|
+| Parameters  : tn_i
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_pdch_release_ptm ( UBYTE tn)
+{ 
+  TRACE_ISIG( "sig_gfp_tc_pdch_release_ptm" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+      switch( tc_eval_pdch_rel(tn) )
+      {
+        case E_PDCH_REL_RECONF:
+          tc_send_pdch_rel(grr_data->pdch_rel_ts_mask);
+          break;
+        case E_PDCH_REL_RELEASE_DL_RECONF_UL:
+          tc_abort_tbf(CGRLC_TBF_MODE_DL);
+          tc_send_pdch_rel(grr_data->pdch_rel_ts_mask);
+          break;
+        case E_PDCH_REL_RELEASE_UL_RECONF_DL:
+          tc_abort_tbf(CGRLC_TBF_MODE_UL);
+          tc_send_pdch_rel(grr_data->pdch_rel_ts_mask);
+          break;
+        case E_PDCH_REL_RELEASE_BOTH:
+          tc_abort_tbf(CGRLC_TBF_MODE_DL_UL);
+          break;
+        case E_PDCH_REL_RELEASE_UL:
+          tc_abort_tbf(CGRLC_TBF_MODE_UL);
+          break;
+        case E_PDCH_REL_RELEASE_DL:
+          tc_abort_tbf(CGRLC_TBF_MODE_DL);
+          break;
+        default:
+          break;
+      } 
+      break;
+    default:
+      TRACE_ERROR( "SIG_GFP_TC_PDCH_RELEASE_PTM unexpected" );
+      break;
+  }
+
+  /*
+   *  in all states
+   */ 
+  if(grr_data->tbf_type EQ CGRLC_TBF_MODE_NULL)
+  {
+    /* new access is done when release confirm arrives */
+    SET_STATE(TC,TC_PIM);
+  }
+  else if(grr_data->tbf_type EQ CGRLC_TBF_MODE_DL)
+  {
+    SET_STATE(TC,TC_TBF_ACTIVE);
+  }
+
+
+} /* sig_gfp_tc_pdch_release_ptm() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_queuing_not 
++------------------------------------------------------------------------------
+| Description : Handles 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_queuing_not  ( void )
+{ 
+  TRACE_ISIG( "sig_gfp_tc_queuing_not " );
+  switch( GET_STATE( TC ) )
+  {
+    case TC_WAIT_ASSIGN:
+
+      SET_STATE(TC,TC_POLLING);
+      /* 
+       * stop sending packet access request 
+       */ 
+      tc_send_ra_stop_req();
+      
+      vsi_t_stop(GRR_handle,T3170);         
+      vsi_t_start(GRR_handle,T3162,T3162_VALUE);      
+
+      /*
+       * save tqi
+       */
+      {
+        MCAST(d_queuing_not,D_QUEUING_NOT);
+        grr_data->tqi = d_queuing_not->tqi;
+      }
+      break;
+    default:
+      TRACE_ERROR( "SIG_GFP_TC_QUEUING_NOT  unexpected" );
+      break;
+  }
+
+} /* sig_gfp_tc_queuing_not () */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_ul_assign
++------------------------------------------------------------------------------
+| Description : Handles 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_ul_assign ( void )
+{ 
+  UBYTE  old_state = GET_STATE( TC );
+
+  TRACE_ISIG( "sig_gfp_tc_ul_assign" );
+  
+  if( grr_t_status( T3172_1 ) > 0 ) 
+  {
+    if( grr_t_status( T3170 ) > 0 )
+    {
+      /*
+       * stop T3172 and set some parameters
+       */
+      tc_stop_timer_t3172();
+    }
+    else if ( grr_t_status( T3176 ) EQ 0)
+    {
+      TRACE_EVENT("Ignore UL Assignment");
+      return;
+    }
+  }
+  
+  switch( old_state )
+  {
+    case TC_WAIT_2P_ASSIGN:
+      grr_data->uplink_tbf.ti = 0; 
+      /*  mark that contention resulution is not yet done    */
+
+      /*lint -fallthrough*/
+
+    case TC_WAIT_STOP_TASK_CNF:       
+      if (grr_data->tc.last_eval_assign.tbf_type EQ CGRLC_TBF_MODE_UL)
+      {
+        TRACE_EVENT("Reassignment for UL ASS in CNF state");
+      }
+      else if(grr_data->tc.last_eval_assign.tbf_type EQ CGRLC_TBF_MODE_DL)
+      {
+        TRACE_EVENT("Ignore UL ASS, wait for DL start");
+        break;
+      }
+      else if(grr_data->tc.last_eval_assign.tbf_type EQ CGRLC_TBF_MODE_NULL AND grr_data->uplink_tbf.ti)
+      {
+        TRACE_EVENT("Ignore UL ASS, wait for condirn to start RA procedure  !!!!");
+        break;
+      }
+
+      /*lint -fallthrough*/
+
+      /*
+       * else :TWO PHASE ACCESS IS RUNNING
+       */
+    case TC_POLLING:
+    case TC_WAIT_ASSIGN:
+     /* 
+      * stop sending packet access request if in progress
+      */ 
+      tc_send_ra_stop_req();
+
+      /*lint -fallthrough*/
+
+    case TC_SINGLE_BLOCK:
+    case TC_CONTENTION_RESOLUTION:
+      switch( tc_eval_ul_assign() )
+      {
+        case E_UL_ASSIGN_SB_2PHASE_ACCESS:
+          SET_STATE(TC,TC_WAIT_2P_ASSIGN); 
+          /* 
+           * send MPHP_SINGLE_BLOCK_REQ with PACKET RESOURCE REQUEST
+           */
+          tc_send_resource_request_p();
+          vsi_t_stop(GRR_handle,T3170);
+          break;
+
+        case E_UL_ASSIGN_DYNAMIC:
+          /*
+          TRACE_EVENT("Packet UL Assignment with dynamic allocation");
+          */
+          if(grr_data->uplink_tbf.ti)
+          {
+            SET_STATE(TC,TC_CONTENTION_RESOLUTION);
+          }
+          else
+          {
+            SET_STATE(TC,TC_TBF_ACTIVE);
+            sig_tc_ctrl_contention_ok();
+            grr_data->tc.two_2p_w_4_tbf_con = FALSE;
+          }
+          tc_prepare_handle_tbf_start( CGRLC_TBF_MODE_UL, GET_STATE( TC ), old_state );
+          break;
+        case E_UL_ASSIGN_FIXED:
+          /*TRACE_EVENT("Packet UL Assignment with fixed allocation");*/
+          if(grr_data->uplink_tbf.ti)
+          {
+            SET_STATE(TC,TC_CONTENTION_RESOLUTION);
+          }
+          else
+          {
+            SET_STATE(TC,TC_TBF_ACTIVE);
+            sig_tc_ctrl_contention_ok();
+          }
+          tc_prepare_handle_tbf_start( CGRLC_TBF_MODE_UL, GET_STATE( TC ), old_state );
+          break;
+        case E_UL_ASSIGN_SB_WITHOUT_TBF: 
+          TRACE_EVENT("Packet UL Assignment with single block allocation");
+          /* send MPHP_SINGLE_BLOCK_REQ with DATA      
+           * (measurement report)                              */
+          tc_send_single_block();
+          SET_STATE(TC,TC_SINGLE_BLOCK);
+          vsi_t_stop(GRR_handle,T3170);
+          break;
+        default:
+          vsi_t_stop(GRR_handle,T3170);
+          if(grr_data->tc.state EQ TC_WAIT_2P_ASSIGN OR
+             grr_data->tc.state EQ TC_SINGLE_BLOCK)
+          {
+            vsi_t_stop(GRR_handle,T3168);
+            TRACE_EVENT_P1("Packet UL Assignment invalid during 2 phase access state=%d",grr_data->tc.state);            
+            tc_stop_normal_burst_req( );
+          }
+          else
+          {
+            TRACE_EVENT("Packet UL Assignment invalid");            
+            tc_handle_error_ra();
+          }
+          break;
+      }
+      break;
+    default:
+      vsi_t_stop(GRR_handle,T3170);
+      TRACE_ERROR( "SIG_GFP_TC_UL_ASSIGN unexpected" );
+      break;
+  }
+
+} /* sig_gfp_tc_ul_assign() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_dl_assign  
++------------------------------------------------------------------------------
+| Description : Handles 
+|
+| Parameters  : -
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_dl_assign  (void)
+{ 
+  UBYTE old_state = GET_STATE( TC );
+
+  TRACE_ISIG( "sig_gfp_tc_dl_assign  " );
+
+  
+  switch( old_state  )
+  {        
+    case TC_WAIT_STOP_TASK_CNF:
+      TRACE_EVENT_P4("ASS IN CNF state:ccch_read=%d  tbf_Type =%d state=%d p_assign=%ld" 
+                       ,grr_data->tc.last_eval_assign.ccch_read
+                       ,grr_data->tc.last_eval_assign.tbf_type
+                       ,grr_data->tc.last_eval_assign.state
+                       ,grr_data->tc.p_assign);
+      if (grr_data->tc.last_eval_assign.tbf_type EQ CGRLC_TBF_MODE_UL)
+      {
+        TRACE_EVENT("Ignore DL ASS, wait for UL start");
+        break;
+      }
+
+      /*lint -fallthrough*/
+
+    case TC_WAIT_ASSIGN:
+     /* 
+      * stop sending packet access request if in progress
+      */ 
+      tc_send_ra_stop_req();
+
+      /*lint -fallthrough*/
+
+    case TC_PIM:
+    case TC_POLLING:
+    case TC_SINGLE_BLOCK:
+    case TC_TBF_ACTIVE:
+      switch( tc_eval_dl_assign() )
+      {
+        case E_DL_ASSIGN:
+          /*
+          TRACE_EVENT("Packet DL Assignment");
+          */
+          SET_STATE(TC,TC_TBF_ACTIVE);
+          if( grr_t_status( T3162 ) NEQ 0 )
+          {
+            vsi_t_stop(GRR_handle,T3162);/*ETSI 4.60 7.1.2.2.2.*/
+          }
+          tc_prepare_handle_tbf_start( CGRLC_TBF_MODE_DL, GET_STATE( TC ), old_state );
+          break;
+        case E_DL_ASSIGN_ERROR_RA:
+          TRACE_EVENT("Packet DL Assignment invalid");
+          vsi_t_stop(GRR_handle,T3170);
+
+          if(grr_data->tc.state EQ TC_SINGLE_BLOCK)
+          {
+            TRACE_EVENT_P1("Packet DL Assignment invalid during IA_DL_SB state=%d",grr_data->tc.state);            
+            tc_stop_normal_burst_req( );
+          }
+          else
+          {
+            tc_handle_error_ra();
+          }
+          break;
+        case E_DL_ASSIGN_IGNORE:
+          /*
+           *  If a failure in the PACKET DOWNLINK ASSIGNMENT is due to any reason, 
+           *  the mobile station shall abort the procedure and continue the normal 
+           *  operation of the uplink TBF.
+           */
+          vsi_t_stop(GRR_handle,T3170);
+          break;
+        default:
+          vsi_t_stop(GRR_handle,T3170);
+          TRACE_ERROR( "DL_ASSIGNMENT with unexpected content" );
+          break;
+      }
+      break;
+    default:
+      vsi_t_stop(GRR_handle,T3170);
+      TRACE_ERROR( "SIG_GFP_TC_DL_ASSIGN    unexpected" );
+      break;
+  }
+
+} /* sig_gfp_tc_dl_assign  () */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_access_rej 
++------------------------------------------------------------------------------
+| Description : Handles 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_access_rej  ( void )
+{ 
+  ULONG t3172_value=0;
+  BOOL start_t3172 = TRUE;
+
+  TRACE_ISIG( "sig_gfp_tc_access_rej " );
+
+  if(grr_t_status( T3172_1 ) > 0)
+  {
+    TRACE_EVENT("T3172 running: Ignore PACKET ACCESS REJECT");
+  }
+  else
+  {
+    /*  The T3168 could running.  */
+    vsi_t_stop(GRR_handle,T3168); 
+
+    switch( GET_STATE( TC ) )
+    {
+      case TC_WAIT_ASSIGN:
+      case TC_POLLING:
+      case TC_WAIT_2P_ASSIGN:
+      case TC_SINGLE_BLOCK:
+        tc_send_ra_stop_req(); 
+        /*
+         *  stop Packet Access Request sending (T3186 will be stopped if runnig)
+         */
+        if( grr_t_status( T3174 ) > 0 )
+        {
+          TRACE_ERROR( " Access reject on the network commanded cell" );
+          grr_data->pcco_failure_cause   = 2;
+          sig_tc_ctrl_access_reject_on_new_cell();
+          /* Do not start the 3172 timer if on the new cell access reject is received */
+          start_t3172 = FALSE;
+        }
+        else
+        if(grr_t_status( T3170 ) EQ 0 )
+        {   /* T3170 is not running */
+          vsi_t_start(GRR_handle,T3170,tc_get_t3170_value());   
+          TRACE_EVENT("sig_gfp_tc_access_rej: t3170 started");
+        }
+        switch( tc_eval_access_rej( &t3172_value ) )
+        {
+          case E_ACCESS_REJ_WAIT:
+            if (start_t3172 EQ TRUE)
+            {
+              tc_start_timer_t3172( t3172_value );
+              sig_tc_ctrl_t3172_running();
+            }
+            break;
+          case E_ACCESS_REJ_NO_WAIT:
+            TRACE_EVENT("No value for T3172, go to idle mode after T3170 expiration");
+            break;
+          default:
+            break;
+        }
+        break;
+      default:
+        TRACE_ERROR( "SIG_GFP_TC_ACCESS_REJ  unexpected" );
+        break;
+    }
+  }/* ignore reject*/
+
+} /* sig_gfp_tc_access_rej () */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_ra_con
++------------------------------------------------------------------------------
+| Description : Handles 
+|
+| Parameters  : payload to primitive
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_ra_con ( T_MPHP_RA_CON * mphp_ra_con_i )
+{ 
+  TRACE_ISIG( "sig_gfp_tc_ra_con" ); /*MODIF*/
+
+  /*
+   *  save last packet access request reference
+   *  see also 0408d640, 10.5.2.28
+   */
+
+  grr_data->req_ref[grr_data->tc.n_acc_req%3].fn_mod.t1 = 
+                           (UBYTE)( ( mphp_ra_con_i->fn / 1326) % 32 );
+  grr_data->req_ref[grr_data->tc.n_acc_req%3].fn_mod.t2 = 
+                           (UBYTE)( mphp_ra_con_i->fn % 26 ); 
+  grr_data->req_ref[grr_data->tc.n_acc_req%3].fn_mod.t3 = 
+                           (UBYTE)( mphp_ra_con_i->fn % 51 );
+
+
+  /*
+   * 0 8 bit access burst
+   * 1 11 bit access burst
+   */
+  if(psc_db->gprs_cell_opt.ab_type)
+  {
+    /*
+     *  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
+     *
+     * We have to store the access info in the 
+     * b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 format
+     */
+    USHORT acc_inf, dummy = 0;
+    dummy = mphp_ra_con_i->channel_request_data;
+    dummy = dummy >> 8; /* 0 0 0 0 0 0 0 0 0 0 0 0 0 b2 b1 b0*/
+    acc_inf = mphp_ra_con_i->channel_request_data;
+    acc_inf = (acc_inf & 0xFF);/* 0 0 0 0 0 0 0 0 b10 b9 b8 b7 b6 b5 b4 b3 */
+    acc_inf = acc_inf << 3; /* 0 0 0 0 0 b10 b9 b8 b7 b6 b5 b4 b3 0 0 0 */
+    acc_inf = acc_inf | dummy;/* 0 0 0 0 0 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 */
+    grr_data->req_ref[grr_data->tc.n_acc_req%3].access_info = acc_inf;
+  }
+  else
+  {
+    grr_data->req_ref[grr_data->tc.n_acc_req%3].access_info = mphp_ra_con_i->channel_request_data;
+  }
+
+  grr_data->tc.n_acc_req++;
+
+  grr_data->tc.ra_once_sent++;
+
+  if (grr_data->tc.ra_once_sent >= 2)
+  {
+    grr_data->r_bit = 1;
+  }
+
+  switch( GET_STATE( TC ) )
+  {
+    case TC_WAIT_ASSIGN:
+      switch( tc_handle_ra_con() )
+      {
+      case H_RA_CON_STOP_REQ:
+        tc_send_ra_stop_req();
+        break;
+      case H_RA_CON_CONTINUE:
+        tc_send_ra_req();
+        break;
+      default:
+        break;
+      } 
+      break;
+    default:
+      tc_send_ra_stop_req();
+      break;
+  }
+} /* sig_gfp_tc_ra_con() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_ra_stop_con 
++------------------------------------------------------------------------------
+| Description : Handles the primitive T_MPHP_RA_STOP_CON 
+|
+| Parameters  : Ptr to primitive payload
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_ra_stop_con ( T_MPHP_RA_STOP_CON * mphp_ra_stop_con_i )
+{ 
+  TRACE_ISIG( "sig_gfp_tc_ra_stop_con" );
+   
+  switch( GET_STATE( TC ) )
+  {
+    case TC_ACCESS_DISABLED:
+      tc_call_disable_callback_func( );
+      break;
+    default:
+      /* nothing to do */
+      break;
+  }
+} /* sig_gfp_tc_ra_stop_con() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_single_block_cnf
++------------------------------------------------------------------------------
+| Description : Handles 
+|
+| Parameters  : *mphp_single_block_con - Ptr to primitive payload
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_single_block_cnf ( T_MPHP_SINGLE_BLOCK_CON *mphp_single_block_con)
+{ 
+  TRACE_ISIG( "sig_gfp_tc_single_block_cnf" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_WAIT_2P_ASSIGN:
+      if(!mphp_single_block_con->sb_status)
+      {
+        /*
+         * TRACE_EVENT_P1("T3168 start: %d ms",((psc_db->gprs_cell_opt.t3168)+1)*500);
+         */
+        vsi_t_start(GRR_handle,T3168,(psc_db->gprs_cell_opt.t3168+1)*500); 
+        sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ACCESS_TWO_PHASE, TASK_STOP_DUMMY_VALUE );
+      }
+      else
+      {
+        vsi_t_stop(GRR_handle,T3168);
+        TRACE_ERROR("Single Block not sent by layer 1");
+        TRACE_EVENT_P1("sb_status = %d",mphp_single_block_con->sb_status);
+        sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ACCESS_TWO_PHASE, TASK_STOP_DUMMY_VALUE );
+        tc_stop_normal_burst_req( );
+      }
+      break;
+    case TC_SINGLE_BLOCK:
+      if(mphp_single_block_con->purpose EQ SINGLE_BLOCK_TRANSFER_UL)   
+      {
+        BOOL is_tx_success = mphp_single_block_con->sb_status EQ SB_STAT_OK;       
+        tc_set_stop_ctrl_blk ( is_tx_success,CGRLC_BLK_OWNER_NONE, 0 ); 
+        sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_MEAS_REP_IDLE, TASK_STOP_DUMMY_VALUE );
+      }
+      else
+      {
+        sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ACCESS_TWO_PHASE, TASK_STOP_DUMMY_VALUE );
+      }
+      tc_stop_normal_burst_req( );
+      break;
+    case TC_ACCESS_DISABLED:
+      /* 
+       * After receiving a Packet Cell Change Order the signal SIG_GFP_SINGLE_BLOCK_CNF
+       * was unexpected. MPHP_STOP_SINGLE_BLOCK_REQ is sent during disableing of the
+       * GRR services.
+       */
+      break;
+    default:
+      TRACE_ERROR( "SIG_GFP_TC_SINGLE_BLOCK_CNF unexpected" );
+      break;
+  }
+} /* sig_gfp_tc_single_block_cnf () */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_assignment_con 
++------------------------------------------------------------------------------
+| Description : Handles 
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_assignment_con  ( void )
+{ 
+  TRACE_ISIG( "sig_gfp_tc_assignment_con " );
+
+  grr_data->tc.two_2p_w_4_tbf_con = TRUE;
+  
+  if(grr_data->tc.state NEQ TC_ACCESS_DISABLED)
+  {
+    if(grr_is_pbcch_present( ))
+    {
+      grr_data->tc.last_eval_assign.ccch_read = 0xFF;  
+      grr_data->tc.last_eval_assign.tbf_type  = CGRLC_TBF_MODE_NULL; 
+      grr_data->tc.last_eval_assign.state     = 0xFF;
+    }
+    sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_TRANSFER, TASK_STOP_DUMMY_VALUE );
+  }
+  else
+  {
+    TRACE_EVENT_P1("TBF_C in TC_ACCESS_DISABLED: do not sent sig_tc_ctrl_set_pckt_mode num_rel=%d ",grr_data->tc.num_of_rels_running );
+  }
+
+
+} /* sig_gfp_tc_assignment_con () */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_tbf_release_con
++------------------------------------------------------------------------------
+| Description : Handles 
+|
+| Parameters  : T_MPHP_TBF_RELEASE_CON * mphp_tbf_release_con_i  
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_tbf_release_con (  T_MPHP_TBF_RELEASE_CON * mphp_tbf_release_con_i  )
+{ 
+  T_RELEASE_STATE rel_state= REL_RUNNING;
+  TRACE_ISIG( "sig_gfp_tc_tbf_release_con" );
+
+  if(mphp_tbf_release_con_i->tbf_type EQ UL_DL_ASSIGNMENT)
+    grr_data->tc.num_of_rels_running = 0;
+  else if (grr_data->tc.num_of_rels_running)
+    grr_data->tc.num_of_rels_running--;
+  else
+  {
+    TRACE_EVENT_P2("REL CON UNEXPECTED num=%d  tbf_rel_type=%d "
+                                    ,grr_data->tc.num_of_rels_running
+                                    ,mphp_tbf_release_con_i->tbf_type);
+  }
+  
+  if(!grr_data->tc.num_of_rels_running)
+  {
+    rel_state = REL_PERFORMED;
+    if(grr_is_pbcch_present( ))
+    {
+      grr_data->tc.last_eval_assign.ccch_read = 0xFF;  
+      grr_data->tc.last_eval_assign.tbf_type  = CGRLC_TBF_MODE_NULL; 
+      grr_data->tc.last_eval_assign.state     = 0xFF;
+    }
+  }
+
+  sig_tc_ctrl_rel_state(rel_state);
+
+  switch( GET_STATE( TC ) )
+  {
+    case TC_PIM:
+      grr_data->ta_params.ta_value = 0xFF;
+      grr_data->ta_params.ta_valid = FALSE;
+      memset(&grr_data->ta_params, 0xFF, sizeof(T_TA_PARAMS));
+
+      if(0 EQ grr_data->tc.num_of_rels_running)
+      {
+        grr_data->tc.v_freq_set = FALSE;
+
+        if( grr_data->tc.disable_callback_func EQ NULL )
+        {
+          /*enable access for grlc*/
+          tc_cgrlc_tbf_rel_res( mphp_tbf_release_con_i->tbf_type ); /* release of all tbfs, grr has entered PIM, transition rule is taken into acocount*/
+        }
+        else
+        {
+          SET_STATE( TC, TC_ACCESS_DISABLED );
+
+          tc_cgrlc_disable_req ( CGRLC_PRIM_STATUS_NULL );
+          tc_call_disable_callback_func( );
+        }
+      }/* else: wait for last release confirm */
+      else
+      {
+        tc_cgrlc_tbf_rel_res( mphp_tbf_release_con_i->tbf_type );
+
+        TRACE_EVENT_P1("WAIT FOR %d TBF RELEASE CON ",grr_data->tc.num_of_rels_running);
+      }
+      break;
+    case TC_ACCESS_DISABLED:      
+      grr_data->ta_params.ta_value    = 0xFF;
+      grr_data->ta_params.ta_valid    = FALSE;
+      memset(&grr_data->ta_params, 0xFF, sizeof(T_TA_PARAMS));
+      grr_data->tc.v_freq_set         = FALSE;
+      grr_data->tc.two_2p_w_4_tbf_con = TRUE;
+
+      tc_cgrlc_disable_req ( CGRLC_PRIM_STATUS_NULL );
+
+      if(0 EQ grr_data->tc.num_of_rels_running)
+      {
+        tc_call_disable_callback_func( );
+      }
+      else
+      {
+        TRACE_EVENT_P1("REL_C in disable state: nr_rel=%d",grr_data->tc.num_of_rels_running);
+      }
+      break;
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+      /*
+       * update timimg advance
+       */
+      switch(mphp_tbf_release_con_i->tbf_type )
+      {
+        case DL_ASSIGNMENT:
+          { 
+            tc_cgrlc_tbf_rel_res( mphp_tbf_release_con_i->tbf_type );
+          
+            /* 
+             * downlink tbf released, set ul ta, if it is different 
+             */
+            if(!((grr_data->ta_params.l1_ta_value EQ grr_data->ta_params.ta_value) AND
+                 (grr_data->ta_params.l1_ta_i     EQ grr_data->ta_params.ul_ta_i)  AND
+                 (grr_data->ta_params.l1_ta_tn    EQ grr_data->ta_params.ul_ta_tn)))
+            {
+              PALLOC(mphp_timing_advance_req,MPHP_TIMING_ADVANCE_REQ);/* T_MPHP_TIMING_ADVANCE_REQ */
+              mphp_timing_advance_req->assign_id = 0;
+              mphp_timing_advance_req->p_timing_advance.ta_value = grr_data->ta_params.ta_value;
+              mphp_timing_advance_req->p_timing_advance.ta_index = grr_data->ta_params.ul_ta_i;
+              mphp_timing_advance_req->p_timing_advance.tn       = grr_data->ta_params.ul_ta_tn;
+              PSEND(hCommL1,mphp_timing_advance_req);
+              TRACE_EVENT_P5("DL TBF_REL TAU: new: %d %d %d-- old %d %d"
+                                                            ,grr_data->ta_params.ta_value
+                                                            ,grr_data->ta_params.ul_ta_i
+                                                            ,grr_data->ta_params.ul_ta_tn
+                                                            ,grr_data->ta_params.dl_ta_i
+                                                            ,grr_data->ta_params.dl_ta_tn);
+              grr_data->ta_params.dl_ta_i  = 0xFF;
+              grr_data->ta_params.dl_ta_tn = 0xFF;
+            }
+          }
+          break;
+        case UL_ASSIGNMENT:
+          { 
+            tc_cgrlc_tbf_rel_res( mphp_tbf_release_con_i->tbf_type );
+          
+            /* 
+             * uplink tbf released, set dl ta, if it is different
+             */
+            if(!((grr_data->ta_params.l1_ta_value EQ grr_data->ta_params.ta_value) AND
+                 (grr_data->ta_params.l1_ta_i     EQ grr_data->ta_params.dl_ta_i)  AND
+                 (grr_data->ta_params.l1_ta_tn    EQ grr_data->ta_params.dl_ta_tn)))
+            {
+              PALLOC(mphp_timing_advance_req,MPHP_TIMING_ADVANCE_REQ);/* T_MPHP_TIMING_ADVANCE_REQ */
+              mphp_timing_advance_req->assign_id = 0;
+              mphp_timing_advance_req->p_timing_advance.ta_value = grr_data->ta_params.ta_value;
+              mphp_timing_advance_req->p_timing_advance.ta_index = grr_data->ta_params.dl_ta_i;
+              mphp_timing_advance_req->p_timing_advance.tn       = grr_data->ta_params.dl_ta_tn;
+              PSEND(hCommL1,mphp_timing_advance_req);
+              TRACE_EVENT_P5("UL TBF_REL TAU: new: %d %d %d-- old %d %d"
+                                                            ,grr_data->ta_params.ta_value
+                                                            ,grr_data->ta_params.dl_ta_i
+                                                            ,grr_data->ta_params.dl_ta_tn
+                                                            ,grr_data->ta_params.ul_ta_i
+                                                            ,grr_data->ta_params.ul_ta_tn);
+
+              grr_data->ta_params.ul_ta_i  = 0xFF;
+              grr_data->ta_params.ul_ta_tn = 0xFF;
+            }
+          }
+          break;
+        default:
+          TRACE_ERROR( "TBF RELEASED, stay in tbf mode, concurrent tbf or no tbf ????" );
+      break;
+      }
+      break;
+    case TC_CPAP:
+    case TC_WAIT_ASSIGN:
+    case TC_POLLING:
+    case TC_WAIT_2P_ASSIGN:
+      /* in these cases the prim shall not occur */
+    default:
+      TRACE_ERROR( "SIG_GFP_TC_TBF_RELEASE_CON unexpected" );
+      break;
+  }
+   
+} /* sig_gfp_tc_tbf_release_con() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_stop_single_block_con
++------------------------------------------------------------------------------
+| Description : Handles 
+|
+| Parameters  : T_MPHP_STOP_SINGLE_BLOCK_CON * mphp_stop_single_block_con_i
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_stop_single_block_con (T_MPHP_STOP_SINGLE_BLOCK_CON * mphp_stop_single_block_con_i )
+{ 
+  TRACE_ISIG( "sig_gfp_tc_stop_single_block_con" );
+  
+  switch( GET_STATE( TC ) )
+  {
+    case TC_PIM:
+      TRACE_EVENT("MPHP_STOP_SINGLE_BLOCK_CON in TC_PIM: nothing to do");
+      tc_cgrlc_access_status_req();
+      break;
+    case TC_WAIT_2P_ASSIGN:
+      if(grr_t_status( T3172_1 ) > 0)
+      {        
+        tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_ACCESS_FAILED,CGRLC_PRIM_STATUS_ONE);
+        sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_IDLE, TASK_STOP_DUMMY_VALUE );
+      }
+      else
+      {
+        /*
+         * two phase access has failed
+         */
+        SET_STATE(TC,TC_PIM);
+        tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_ACCESS_FAILED,CGRLC_PRIM_STATUS_NULL);
+      }
+      break;
+    case TC_ACCESS_DISABLED:      
+      if(!grr_data->tc.two_2p_w_4_tbf_con)
+      {
+        TRACE_EVENT("BLC_C abort TBF");
+        tc_abort_tbf( grr_data->tbf_type );       
+      }
+      else
+      {
+        tc_call_disable_callback_func( );
+      }
+
+      break;
+    case TC_SINGLE_BLOCK:
+      /*
+       * single block procedure for uplink ctrl message or receiving DL block stopped
+       */
+       /*
+        * Stay in TC_SINGLE_BLOCK state while access reject is running.
+        * Go to TC_PIM after T3170 is expired
+        */
+      if( grr_t_status( T3170 ) EQ 0 )
+      {
+        SET_STATE(TC,TC_PIM);
+        tc_cgrlc_access_status_req();
+      }
+      break;
+    default:
+      TRACE_ERROR( "SIG_GFP_TC_STOP_SINGLE_BLOCK_CON unexpected" );
+      break;
+  }
+} /* sig_gfp_tc_stop_single_block_con () */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_packet_tbf_rel_ptm 
++------------------------------------------------------------------------------
+| Description : Handles the signal sig_gfp_tc_packet_tbf_rel_ptm
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_packet_tbf_rel_ptm (ULONG fn, UBYTE rrbp, UBYTE sp  )
+{
+  MCAST(d_tbf_release,D_TBF_RELEASE);
+
+  TRACE_ISIG( "sig_gfp_tc_packet_tbf_rel_ptm" );
+   
+  switch( GET_STATE( TC ) )
+  {
+    case TC_CONTENTION_RESOLUTION:
+    case TC_TBF_ACTIVE:
+
+
+      if( !d_tbf_release->dl_release AND  
+          !d_tbf_release->ul_release) 
+      {
+        TRACE_ERROR("no release request in packet tbf release");
+        return;
+      }
+      else
+      {
+        T_TBF_TYPE tbf_type = CGRLC_TBF_MODE_NULL;
+        UBYTE rel_cause     = CGRLC_TBF_REL_ABNORMAL;
+        ULONG rel_fn        = CGRLC_STARTING_TIME_NOT_PRESENT;
+
+
+        if( d_tbf_release->dl_release AND 
+            d_tbf_release->ul_release )
+        {
+          if (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL)
+          {
+            tbf_type = CGRLC_TBF_MODE_DL_UL;
+          }
+          else if (grr_data->tbf_type EQ CGRLC_TBF_MODE_UL)
+          {
+            tbf_type = CGRLC_TBF_MODE_UL;
+          }
+          else if (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL)
+          {
+            tbf_type = CGRLC_TBF_MODE_DL;
+          }    
+        }
+
+        else 
+        if (  d_tbf_release->dl_release                  AND 
+           ((grr_data->tbf_type EQ CGRLC_TBF_MODE_DL)    OR 
+            (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL)))
+        {
+          tbf_type = CGRLC_TBF_MODE_DL;
+        }
+
+        else 
+        if (  d_tbf_release->ul_release                  AND 
+           ((grr_data->tbf_type EQ CGRLC_TBF_MODE_UL)    OR
+            (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL)))
+        {
+          tbf_type = CGRLC_TBF_MODE_UL;
+        }
+
+
+        if( sp )
+        {
+          rel_fn = grr_calc_new_poll_pos(fn,rrbp);
+        }
+           
+        if( d_tbf_release->rel_cause EQ NORMAL_RELEASE)
+        {
+          if ( d_tbf_release->ul_release                AND 
+             ((grr_data->tbf_type EQ CGRLC_TBF_MODE_UL)  OR
+             (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL)))
+              
+          {
+             rel_cause = CGRLC_TBF_REL_NORMAL; 
+          }
+        }
+
+        tc_cgrlc_tbf_rel_req(tbf_type,rel_cause,rel_fn);
+      }
+      break;
+    default:
+      TRACE_ERROR( "SIG_GFP_TC_PACKET_TBF_REL_PTM unexpected" );
+      break;
+  }
+
+} /* sig_gfp_tc_packet_tbf_rel_ptm () */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_gfp_tc_poll_ind 
++------------------------------------------------------------------------------
+| Description : Handles the signal sig_gfp_tc_poll_ind
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void sig_gfp_tc_poll_ind (ULONG fn, UBYTE rrbp, UBYTE poll_type,UBYTE pctrl_ack  )
+{
+
+  TRACE_ISIG( "sig_gfp_tc_poll_ind" );
+   
+  switch( GET_STATE( TC ) )
+  {
+    case TC_PIM:
+    case TC_CPAP:
+    case TC_POLLING:
+    case TC_WAIT_ASSIGN:
+    case TC_WAIT_2P_ASSIGN:
+    case TC_SINGLE_BLOCK:
+    case TC_WAIT_STOP_TASK_CNF:
+
+      switch(grr_data->tbf_type)
+      {
+        case CGRLC_TBF_MODE_NULL: 
+          tc_send_polling_res ( poll_type,fn,rrbp,pctrl_ack);
+          break;
+          default:
+            TRACE_ERROR( "SIG_GFP_TC_POLL_IND unexpected tbf_type" );
+            break;
+      } 
+      break;
+    default:
+      TRACE_ERROR( "SIG_GFP_TC_POLL_IND unexpected" );
+      break;
+  }
+
+} /* sig_gfp_tc_poll_ind () */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_ctrl_tc_delete_cs_msg
++------------------------------------------------------------------------------
+| Description : This function deletes the control blocks of cs owner. This
+|               function is called when MS is moving from PAM to PTM. In this 
+|               scenario it has to delete PMRs if any.
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+
+GLOBAL void sig_ctrl_tc_delete_cs_msg        ( void )
+{
+  UBYTE i= 0;
+
+  TRACE_FUNCTION( "sig_ctrl_tc_delete_cs_msg" );
+
+    
+  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 )
+    {
+      /* remove control block */
+      TRACE_EVENT_P2("Delete Control msg sequence:%d owner:%d",
+          grr_data->tc.ul_ctrl_blk.seq[i],
+          grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].owner);
+      if (CGRLC_BLK_OWNER_CS EQ grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].owner)
+      {
+          tc_cancel_ctrl_blk(grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].owner);
+      }
+	  
+    }
+  }
+
+
+}/* sig_ctrl_tc_delete_cs_msg*/