--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/g23m-gprs/grlc/grlc_tmp.c	Thu Oct 13 04:24:13 2016 +0000
@@ -0,0 +1,1758 @@
+/* 
++----------------------------------------------------------------------------- 
+|  Project :  GPRS (8441)
+|  Modul   :  GRLC
++----------------------------------------------------------------------------- 
+|  Copyright 2002 Texas Instruments Berlin, AG 
+|                 All rights reserved. 
+| 
+|                 This file is confidential and a trade secret of Texas 
+|                 Instruments Berlin, AG 
+|                 The receipt of or possession of this file does not convey 
+|                 any rights to reproduce or disclose its contents or to 
+|                 manufacture, use, or sell anything it may describe, in 
+|                 whole, or in part, without the specific written consent of 
+|                 Texas Instruments Berlin, AG. 
++----------------------------------------------------------------------------- 
+|  Purpose :  This module implements primitive handler functions for service
+|             TM of entity GRLC.
++----------------------------------------------------------------------------- 
+*/ 
+
+#ifndef GRLC_TMP_C
+#define GRLC_TMP_C
+#endif
+
+#define ENTITY_GRLC
+
+/*==== INCLUDES =============================================================*/
+
+#include "typedefs.h"   /* to get Condat data types */
+#include "vsi.h"        /* to get a lot of macros */
+#include <string.h>
+#include "macdef.h"
+#include "gprs.h"
+#include "gsm.h"        /* to get a lot of macros */
+#include "ccdapi.h"     /* to get CCD API */
+#include "cnf_grlc.h"    /* to get cnf-definitions */
+#include "mon_grlc.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 "grlc.h"        /* to get the global entity definitions */
+#include "grlc_f.h"      /* to get the grlc global function definitions */
+#include "grlc_rus.h"    /* to get the service RU signal definitions */
+#include "grlc_rds.h"    /* to get the service RD signal definitions */
+#include "grlc_tmf.h"    /* to get the service TM functions definitions */
+#include "grlc_meass.h"  /* to get the service MEAS signal definitions */
+#include "grlc_tpcs.h"
+#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
+#include "grlc_tms.h"
+#endif
+
+/*==== CONST ================================================================*/
+
+/*==== DIAGNOSTICS ==========================================================*/
+
+/*==== LOCAL VARS ===========================================================*/
+
+/*==== LOCAL TYPES ==========================================================*/
+
+LOCAL void tm_uplink_data_req ( T_PRIM_TYPE  prim_type,
+                                void        *llc_data_req );
+
+/*==== PRIVATE FUNCTIONS ====================================================*/
+/*
++------------------------------------------------------------------------------
+| Function    : tm_uplink_data_req 
++------------------------------------------------------------------------------
+| Description : Handles the primitives GRLC_DATA_REQ and GRLC_UNITDATA_REQ
+|
+| Parameters  : *llc_data_req  - Ptr to primitive payload
+|
++------------------------------------------------------------------------------
+*/
+LOCAL void tm_uplink_data_req ( T_PRIM_TYPE  prim_type,
+                                void        *llc_data_req )
+{ 
+  UBYTE state = GET_STATE( TM );
+  BOOL  use_data_req;
+
+  T_GRLC_DATA_REQ     *grlc_data_req     = ( T_GRLC_DATA_REQ*     )llc_data_req;
+  T_GRLC_UNITDATA_REQ *grlc_unitdata_req = ( T_GRLC_UNITDATA_REQ* )llc_data_req;
+
+  TRACE_FUNCTION( "tm_uplink_data_req" );
+
+  PACCESS( llc_data_req );
+
+#ifdef FLOW_TRACE
+
+  sndcp_trace_flow_control
+                      ( FLOW_TRACE_GRLC, FLOW_TRACE_UP, FLOW_TRACE_TOP, FALSE );
+
+#endif
+  
+  if( 
+      (
+        grlc_test_mode_active( )
+      )
+      AND 
+      ( 
+        ( prim_type              EQ  CGRLC_LLC_PRIM_TYPE_DATA_REQ     AND 
+          grlc_data_req->sapi     NEQ GRLC_SAPI_TEST_MODE         )
+        OR
+        ( prim_type              EQ  CGRLC_LLC_PRIM_TYPE_UNITDATA_REQ AND 
+          grlc_unitdata_req->sapi NEQ GRLC_SAPI_TEST_MODE         )
+      )
+    )
+  {
+    /*
+     * all LLC data requests are ignored during GPRS test mode
+     */      
+    TRACE_EVENT( "tm_uplink_data_req: GPRS test mode active" );
+    PFREE( llc_data_req );
+
+    return;
+  }
+
+
+  if(   prim_type                  EQ CGRLC_LLC_PRIM_TYPE_DATA_REQ           AND 
+        grlc_data->prim_start_tbf  <  PRIM_QUEUE_SIZE                        AND  
+      ( grlc_data_req->cause       EQ GRLC_DTACS_EMPTY_FRAME            OR
+        grlc_data_req->cause       EQ GRLC_DTACS_CELL_NOTIFI_NULL_FRAME    )     )
+  {
+    TRACE_EVENT_P1("EMPTY FRAME RECEIVED, LLLC FRAME AVAILABLE, delete empty frame: sdu_len=%d", grlc_data_req->sdu.l_buf / 8);    
+    grlc_data->tm.send_grlc_ready_ind = SEND_A_GRLC_READY_IND;
+    tm_handle_grlc_ready_ind( );
+    PFREE( llc_data_req );
+    return;
+  }
+
+  
+
+/*
+
+  if( prim_type EQ PRIM_TYPE_DATA_REQ )
+  {
+    TRACE_EVENT_P2( "tm_uplink_data_req: sdu_len=%ld data_req_cnt=%d",
+                    grlc_data_req->sdu.l_buf / 8,
+                    grlc_data->grlc_data_req_cnt );
+
+    TRACE_EVENT_P9( "tm_uplink_data_req: sapi=%d tlli=%lx delay=%d relc=%d peak=%d prec=%d mean=%d r_pri=%d cause=%d",
+                    grlc_data_req->sapi,
+                    grlc_data_req->tlli,
+                    grlc_data_req->qos.delay,
+                    grlc_data_req->qos.relclass,
+                    grlc_data_req->qos.peak,
+                    grlc_data_req->qos.preced,
+                    grlc_data_req->qos.mean,
+                    grlc_data_req->radio_prio,
+                    grlc_data_req->cause );
+  }
+
+*/
+
+  grlc_data->tm.send_grlc_ready_ind = SEND_A_GRLC_READY_IND;
+
+  switch( state )
+  {
+    case TM_ACCESS_DISABLED:
+    case TM_ACCESS_PREPARED:
+      use_data_req = 
+        (
+          grlc_data->tm.disable_class EQ CGRLC_DISABLE_CLASS_CR
+        )
+        AND
+        (
+          ( prim_type           EQ CGRLC_LLC_PRIM_TYPE_DATA_REQ     AND
+            grlc_data_req->cause EQ GRLC_DTACS_DEF              )
+          OR
+          ( prim_type           EQ CGRLC_LLC_PRIM_TYPE_UNITDATA_REQ     )
+        );
+      break;
+     
+    default:
+      use_data_req = tm_access_allowed (  grlc_data_req->radio_prio  );
+      break;
+  }
+
+  if( use_data_req )
+  {
+    tm_data_req( prim_type, ( T_GRLC_DATA_REQ* )llc_data_req );
+    grlc_data->grlc_data_req_cnt++;
+
+    switch( state )
+    {
+      case TM_PIM:
+        tm_ul_tbf_ind();
+        break;
+
+      case TM_PTM:
+        tm_ul_tbf_ind();
+        
+        if( grlc_data->tbf_type NEQ TBF_TYPE_DL )
+        {
+          /* uplink is active*/
+          sig_tm_ru_queue_status( );
+        }
+        break;
+
+      default:
+        /* do nothing */
+        break;
+    }
+  }
+  else
+  {
+    tm_cgrlc_status_ind( CGRLC_ACCESS_2_NETWORK_NOT_ALLOWED );
+    PFREE( llc_data_req );
+  }
+
+  tm_handle_grlc_ready_ind( );
+
+} /* tm_uplink_data_req () */
+
+/*==== PUBLIC FUNCTIONS =====================================================*/
+/*
++------------------------------------------------------------------------------
+| Function    : tm_grlc_data_req 
++------------------------------------------------------------------------------
+| Description : Handles the primitive GRLC_DATA_REQ 
+|
+| Parameters  : *grlc_data_req  - Ptr to primitive payload
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_grlc_data_req  ( T_GRLC_DATA_REQ  *grlc_data_req  )
+{ 
+  TRACE_FUNCTION( "tm_grlc_data_req " );
+
+  tm_uplink_data_req( CGRLC_LLC_PRIM_TYPE_DATA_REQ, ( void* )grlc_data_req );
+   
+} /* tm_grlc_data_req () */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_grlc_unitdata_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive GRLC_UNITDATA_REQ
+|
+| Parameters  : *grlc_unitdata_req - Ptr to primitive payload
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_grlc_unitdata_req ( T_GRLC_UNITDATA_REQ *grlc_unitdata_req )
+{ 
+  TRACE_FUNCTION( "tm_grlc_unitdata_req" );
+  
+  tm_uplink_data_req( CGRLC_LLC_PRIM_TYPE_UNITDATA_REQ, ( void* )grlc_unitdata_req );
+
+} /* tm_grlc_unitdata_req() */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_t3168
++------------------------------------------------------------------------------
+| Description : Handles the primitive T3168
+|               This timer is involved in 3 Procedures
+|               1) Two Phase Access Procedure
+|               2) Uplink TBF Setup on existing Downlink TBF
+|               3) Uplink Realloaction Procedure on existing Uplink TBF
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_t3168 ( void )
+{ 
+  TRACE_FUNCTION( "tm_t3168" );
+  TRACE_EVENT_P1("T3168 expired: n_acc=%d",grlc_data->tm.n_res_req);
+
+  /* 
+   * The expiry of this timer may occure in 3 cases:
+   * 
+   * a) uplink allocation during running downlink TBF  --> GRLC
+   * b) two phase access procedure                    --> GRLC
+   * c) uplink reallocation procedure on uplink TBF or on concurent TBF(UL&DL)  -->GRLC
+   *
+   */
+  
+  switch( GET_STATE( TM ) )
+  {
+    case TM_PTM:
+      switch(grlc_data->tbf_type)
+      {
+#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
+        case TBF_TYPE_TP_ACCESS:
+          grlc_data->uplink_tbf.ti=1;
+          tm_handle_error_ra(); 
+          break;
+#endif
+        case TBF_TYPE_DL:
+          /*
+           *  cse a)
+           */
+        if(grlc_data->tm.n_res_req < 4) /* Is resource re-allocation is running? */  
+        {
+          grlc_data->tm.n_res_req++;
+          tm_build_chan_req_des(&grlc_data->chan_req_des, 
+                              &grlc_data->prim_queue[grlc_data->prim_start_tbf]);
+          sig_tm_rd_ul_req();     
+        }
+        else
+        { /* grlc_data->tm.n_res_req EQ 4 
+                      -> last Channel Request Description has been sent */
+          tm_handle_error_ra(); 
+        }
+        break;
+
+        case TBF_TYPE_UL:
+        case TBF_TYPE_CONC:
+          /*
+           * case c)
+           */
+        if(grlc_data->tm.n_res_req < 4) /* Is resource re-allocation is running? */  
+        { 
+          T_U_GRLC_RESOURCE_REQ resource_req;/*lint !e813*/
+
+          tm_build_res_req(&resource_req,
+                           R_RE_ALLOC); 
+          tm_store_ctrl_blk( CGRLC_BLK_OWNER_TM, ( void* )&resource_req );
+        }
+        else
+        { /* 
+           * grlc_data->tm.n_res_req EQ 4 -> last resource request has been sent 
+           * return to packet idle and indicate packet access failure to upper layers
+           */
+          while(grlc_data->prim_start_tbf < PRIM_QUEUE_SIZE_TOTAL)
+          {
+            grlc_delete_prim();
+          }
+          tm_cgrlc_status_ind(CGRLC_PACKET_ACCESS_FAILURE);
+          tm_abort_tbf(grlc_data->tbf_type);
+          grlc_data->tm.n_res_req = 0;
+          TRACE_EVENT("4x p. resource req. failed");
+          SET_STATE(TM,TM_WAIT_4_PIM);
+        }
+        break;
+        default:
+          /*
+           *  Should never occure
+           */
+          TRACE_ERROR("T3168 expired, no task should not appear");
+          break;
+      }
+      
+      break;
+
+    default:
+      TRACE_ERROR( "T3168 unexpected" );
+      break;
+  }
+
+} /* tm_t3168() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_t3188
++------------------------------------------------------------------------------
+| Description : Handles the primitive T3188
+|
+| Parameters  :   
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_t3188 ( void )
+{ 
+  TRACE_FUNCTION( "tm_t3188" );
+  
+
+  switch( GET_STATE( TM ) )
+  {
+    case TM_PTM:
+      /*
+       * perform abnormal release with random access
+       */
+      tm_handle_error_ra();
+      break;
+    default:
+      TRACE_ERROR( "tm_t3188 unexpected" );
+      break;
+  }
+
+} /* tm_t3188() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_grlc_activate_gmm_queue_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive GRLC_ACTIVATE_GMM_QUEUE_REQ
+|
+| Parameters  :   
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_grlc_activate_gmm_queue_req  ( T_GRLC_ACTIVATE_GMM_QUEUE_REQ *grlc_activate_gmm_queue_req  )
+{ 
+  TRACE_FUNCTION( "tm_grlc_activate_gmm_queue_req" );
+  
+
+  switch( GET_STATE( TM ) )
+  {
+    case TM_ACCESS_DISABLED:
+      tm_get_gmm_prim_queue( );      
+      break;
+
+    case TM_ACCESS_PREPARED:
+      SET_STATE( TM, TM_PIM );
+      sig_tm_ru_reset_poll_array();	  
+      tm_get_gmm_prim_queue( );      
+      tm_handle_grlc_ready_ind( );
+      break;
+
+    default:
+      TRACE_ERROR( "GRLC_ACTIVATE_GMM_QUEUE_REQ unexpected" );
+      break;
+  }
+
+  PFREE( grlc_activate_gmm_queue_req );
+
+} /* tm_grlc_activate_gmm_queue_req() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_grlc_flush_data_req
++------------------------------------------------------------------------------
+| Description : When LLC receives XID RESET during Inter-SGSN RAU procedure,
+|               LLC sends this primitive GRLC_FLUSH_DATA_REQ to GRLC to flush out LLC 
+|               user data maintained in GRLC
+|
+| Parameters  : void               
+|               
++------------------------------------------------------------------------------
+*/
+
+GLOBAL void tm_grlc_flush_data_req (T_GRLC_FLUSH_DATA_REQ *grlc_flush_data_req)
+{
+  
+  UBYTE i;
+  UBYTE temp_start_tbf;
+  UBYTE temp_start_free;   
+
+  TRACE_FUNCTION( "tm_grlc_flush_data_req" );
+
+  TRACE_EVENT_P4(" ps=%d, pf=%d,sps=%d,spf=%d",
+                                       grlc_data->prim_start_tbf,
+                                       grlc_data->prim_start_free,
+                                       grlc_data->save_prim_start_tbf,
+                                       grlc_data->save_prim_start_free);
+
+
+  if(!grlc_data->gmm_procedure_is_running OR 
+     !(grlc_data->prim_start_tbf >= PRIM_QUEUE_SIZE))
+  /* Check for the condition grlc_data->prim_start_tbf EQ 0xFF is not required since
+   * grlc_data->prim_start_tbf=0xFF implies there are no primitives in queue to flush out.
+   * LLC PDUs are flushed only when GMM queue is active dring Inter-SGSN RAU procedure */
+  {
+    TRACE_ERROR( "GRLC_FLUSH_DATA_REQ unexpected" );
+    PFREE(grlc_flush_data_req);
+    return;
+  }  
+
+ /* Remember GMM primitives when gmm procedure is running*/
+  temp_start_tbf = grlc_data->prim_start_tbf;
+  temp_start_free = grlc_data->prim_start_free;
+
+ /* Retrieve the saved primitive values when LLC was suspended by GMM */
+  grlc_data->prim_start_tbf = grlc_data->save_prim_start_tbf;
+  grlc_data->prim_start_free = grlc_data->save_prim_start_free;
+
+  i = grlc_data->prim_start_tbf;
+
+  grlc_data->prim_user_data = 0;
+  while(i NEQ 0xFF)
+  {
+    grlc_data->prim_user_data += BYTELEN(grlc_data->prim_queue[i].prim_ptr->sdu.l_buf);
+    i = grlc_data->prim_queue[i].next;
+  }
+  grlc_data->tm.send_grlc_ready_ind = SEND_A_GRLC_READY_IND;
+
+ /* Delete all LLC primitives (user data) irrespective of going in same or new tbf */
+
+  do
+  {
+    grlc_delete_prim();
+  } while( (grlc_data->prim_start_tbf < PRIM_QUEUE_SIZE_TOTAL));
+
+
+  grlc_data->save_prim_start_tbf = grlc_data->prim_start_tbf;
+  if(grlc_data->prim_start_tbf NEQ 0xff)
+  {
+    TRACE_ASSERT(grlc_data->prim_start_tbf NEQ 0xff);
+  }
+
+  tm_handle_grlc_ready_ind();
+
+ /* The GMM primitive values are put back */
+  grlc_data->prim_start_tbf = temp_start_tbf;
+  grlc_data->prim_start_free = temp_start_free;
+
+
+  TRACE_EVENT_P4(" ps=%d, pf=%d,sps=%d,spf=%d",
+                                       grlc_data->prim_start_tbf,
+                                       grlc_data->prim_start_free,
+                                       grlc_data->save_prim_start_tbf,
+                                       grlc_data->save_prim_start_free);
+
+
+  PFREE(grlc_flush_data_req);
+  
+}
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_enable_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive cgrlc_enable_req
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_enable_req ( T_CGRLC_ENABLE_REQ *cgrlc_enable_req )
+{ 
+  TRACE_FUNCTION( "tm_cgrlc_enable_req" );
+
+
+  switch( GET_STATE( TM ) )
+  {
+    case TM_ACCESS_DISABLED:
+    case TM_ACCESS_PREPARED:
+      if( cgrlc_enable_req->enable_cause EQ  
+                                   CGRLC_ENAC_ABNORM_RELEASE_CRESELECT_FAILED )
+      {
+        SET_STATE( TM, TM_PIM );
+        sig_tm_ru_reset_poll_array();		
+        tm_cgrlc_status_ind( CGRLC_RLC_MAC_ERROR );
+        tm_delete_prim_queue( );
+      }
+      else if(cgrlc_enable_req->queue_mode EQ CGRLC_QUEUE_MODE_GMM)
+      {
+        if(grlc_data->gmm_procedure_is_running )       
+        {
+          SET_STATE(TM, TM_PIM);
+          tm_delete_prim_queue();
+          sig_tm_ru_reset_poll_array();		  		  
+          TRACE_EVENT_P2("LLC QUEUE IS DISABLED, DELETE GMM PRIM QUEUE ps=%d pf=%d",
+                                  grlc_data->prim_start_tbf,
+                                  grlc_data->prim_start_free);
+        }
+        else
+        {
+          SET_STATE( TM, TM_ACCESS_PREPARED );
+        }
+      }
+
+      /*lint -fallthrough*/
+
+    case TM_PIM:
+    case TM_PAM:
+    case TM_PTM:
+    case TM_WAIT_4_PIM: 
+
+      grlc_data->tm.max_grlc_user_data = MAX_GRLC_USER_DATA ;
+
+      if(cgrlc_enable_req->queue_mode EQ CGRLC_QUEUE_MODE_LLC)
+      {
+        UBYTE state = GET_STATE( TM );
+
+        if( state EQ TM_ACCESS_DISABLED OR
+            state EQ TM_ACCESS_PREPARED    )
+        {
+          SET_STATE( TM, TM_PIM );
+          sig_tm_ru_reset_poll_array();		  		  
+        }
+        if(grlc_data->gmm_procedure_is_running)
+        {
+          tm_get_llc_prim_queue();
+          if ( (tm_prim_queue_get_free_count() > 0)            AND
+             (grlc_data->prim_user_data <= grlc_data->tm.max_grlc_user_data))
+          {
+            grlc_data->tm.send_grlc_ready_ind = SEND_A_GRLC_READY_IND;
+          }
+          else
+          {
+            grlc_data->tm.send_grlc_ready_ind = PRIM_QUEUE_FULL;
+          }
+        }
+        else
+        {
+          TRACE_EVENT("RESUME IS DONE");
+        }
+        /*
+         * check if cell update is required
+         */
+        if(cgrlc_enable_req->cu_cause EQ CGRLC_RA_CU)
+        {
+          TRACE_EVENT("CU REQ from GRR");
+          /*
+           * Delete Empty frames
+           */
+          if(   grlc_data->prim_start_tbf                                        <  PRIM_QUEUE_SIZE                        AND
+              ( grlc_data->prim_queue[grlc_data->prim_start_tbf].prim_ptr->cause EQ GRLC_DTACS_EMPTY_FRAME            OR 
+                grlc_data->prim_queue[grlc_data->prim_start_tbf].prim_ptr->cause EQ GRLC_DTACS_CELL_NOTIFI_NULL_FRAME    )     )
+          {
+            grlc_delete_prim();
+            TRACE_EVENT("CEll_res: delete prim");
+          }
+          grlc_data->uplink_tbf.access_type = CGRLC_AT_CELL_UPDATE;
+        }
+        tm_ul_tbf_ind();
+        tm_handle_grlc_ready_ind();
+
+      }
+
+      grlc_data->burst_type             = cgrlc_enable_req->burst_type;
+      grlc_data->ab_type                = cgrlc_enable_req->ab_type;
+      grlc_data->t3168_val              = cgrlc_enable_req->t3168_val;
+      grlc_data->uplink_tbf.tlli        = cgrlc_enable_req->ul_tlli;
+      grlc_data->uplink_tbf.ac_class    = cgrlc_enable_req->ac_class;
+      grlc_data->downlink_tbf.tlli      = cgrlc_enable_req->dl_tlli;
+      grlc_data->tm.change_mark         = cgrlc_enable_req->change_mark;
+
+#ifdef REL99
+      grlc_data->pfi_support            = cgrlc_enable_req->pfi_support;
+      grlc_data->nw_rel                 = cgrlc_enable_req->nw_rel;	  
+#endif
+      /* 
+       * set N3102 to maximum value after cell reselction
+       */
+      if(cgrlc_enable_req->v_pan_struct)
+      {
+        if(cgrlc_enable_req->pan_struct.pmax NEQ CGRLC_NO_UPDATE_N3102)
+        {
+          grlc_data->pan_struct = cgrlc_enable_req->pan_struct;
+          grlc_data->N3102      = cgrlc_enable_req->pan_struct.pmax;
+        }
+      }
+      else
+      {
+        grlc_data->pan_struct = cgrlc_enable_req->pan_struct;
+        grlc_data->N3102      = 0xFF;
+      }
+      if( grlc_data->uplink_tbf.tlli EQ (0xffffffff))
+      {
+        TRACE_EVENT("GMM HAS UNASSIGNED GRR/GRLC, DELETE DATA QUEUE");        
+        /*
+         * delete prim queue
+         */
+        while(grlc_data->prim_start_tbf < PRIM_QUEUE_SIZE_TOTAL)
+        {
+          grlc_delete_prim();
+        }
+      }
+      break;
+    default:
+      TRACE_ERROR( "CGRLC_ENABLE_REQ unexpected" );
+      break;
+  }
+  PFREE(cgrlc_enable_req);
+
+} /* tm_cgrlc_enable_req() */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_disable_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive cgrlc_disable_req
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_disable_req ( T_CGRLC_DISABLE_REQ        *cgrlc_disable_req )
+{ 
+  UBYTE state = GET_STATE( TM );
+
+  TRACE_FUNCTION( "tm_cgrlc_disable_req" );
+
+  grlc_data->tm.disable_class = cgrlc_disable_req->disable_class; 
+
+  switch( state )
+  {
+    case TM_ACCESS_PREPARED:
+      SET_STATE(TM, TM_ACCESS_DISABLED);
+      break;
+
+    case TM_ACCESS_DISABLED:
+      /* nothing to do */
+      break;
+
+    case TM_PIM:
+    case TM_WAIT_4_PIM:
+      SET_STATE(TM, TM_ACCESS_DISABLED);
+
+      tm_handle_test_mode_cnf( grlc_test_mode_active( ) );
+
+      grlc_data->rel_type = REL_TYPE_NULL;
+      break;
+
+    case TM_PTM:
+      tm_abort_tbf(grlc_data->tbf_type);
+       /*
+        * delete all poll positions
+        */
+      sig_tm_ru_reset_poll_array();  
+
+      /*lint -fallthrough*/
+
+    case TM_PAM:
+      SET_STATE(TM, TM_ACCESS_DISABLED);
+
+      tm_handle_test_mode_cnf( grlc_test_mode_active( ) );
+
+      grlc_data->rel_type = REL_TYPE_NULL;
+
+      if( state EQ TM_PAM AND cgrlc_disable_req->disable_class EQ CGRLC_DISABLE_CLASS_CR )
+      {
+        tm_cgrlc_status_ind( CGRLC_TBF_ESTABLISHMENT_FAILURE );
+      }
+      break;
+
+    default:
+      TRACE_ERROR( "CGRLC_DISABLE_REQ unexpected" );
+      break;
+  }
+
+  if(cgrlc_disable_req->prim_status EQ CGRLC_PRIM_STATUS_ONE)
+  {
+    grlc_delete_prim();
+    tm_handle_grlc_ready_ind();
+  }
+  else if(cgrlc_disable_req->prim_status EQ CGRLC_PRIM_STATUS_ALL)
+  {
+    tm_delete_prim_queue();
+  /* Reinitialize GRLC context 
+   * 1. Delete Primitives
+   * 2. Abort TBF - (This is already done by GMMRR_SUSPEND_REQ)   
+   *    We reach this disable req only after releasing all TBFs
+   * 3. Reinitialize GRLC context */
+  
+    TRACE_EVENT("Reinit GRLC");
+    grlc_init();
+  }
+
+
+  PFREE(cgrlc_disable_req);
+
+} /* tm_cgrlc_disable_req() */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_ul_tbf_res
++------------------------------------------------------------------------------
+| Description : Handles the primitive cgrlc_ul_tbf_res
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_ul_tbf_res ( T_CGRLC_UL_TBF_RES *cgrlc_ul_tbf_res )
+{ 
+  TRACE_FUNCTION( "tm_cgrlc_ul_tbf_res" );
+
+  tm_prcs_pwr_ctrl( &cgrlc_ul_tbf_res->pwr_ctrl );
+  
+  /*
+   * Ignore the request for or modification of an UL TBF in case an UL TBF 
+   * release request is currently sent to the data queue of GRR, it is just 
+   * not yet processed, but TBF will be released anyway as one of the next
+   * steps.
+   */
+  if( ( grlc_data->rel_type & REL_TYPE_UL ) EQ REL_TYPE_UL )
+  {
+    TRACE_EVENT( "tm_cgrlc_ul_tbf_res: release of UL TBF requested in parallel" );
+
+    PFREE( cgrlc_ul_tbf_res );
+
+    return;
+  }
+
+  vsi_t_stop(GRLC_handle,T3168);
+  grlc_data->tm.n_res_req = 0;
+
+  switch( GET_STATE( TM ) )
+  {
+    case TM_PAM:
+      switch(cgrlc_ul_tbf_res->tbf_mode)
+      {
+        case CGRLC_TBF_MODE_ESTABLISHMENT_FAILURE:  /* establishment failure */
+          SET_STATE(TM,TM_PIM);
+          grlc_delete_prim();
+          sig_tm_ru_reset_poll_array();		  
+          tm_cgrlc_status_ind(CGRLC_TBF_ESTABLISHMENT_FAILURE);
+          tm_handle_grlc_ready_ind();
+          tm_ul_tbf_ind();
+          break;
+        case CGRLC_TBF_MODE_ACCESS_FAILED:
+          if(cgrlc_ul_tbf_res->prim_status EQ CGRLC_PRIM_STATUS_ONE)
+          {
+            SET_STATE(TM,TM_PIM);
+            grlc_delete_prim();
+            sig_tm_ru_reset_poll_array();
+            tm_cgrlc_status_ind(CGRLC_PACKET_ACCESS_FAILURE);
+            tm_handle_grlc_ready_ind();
+            tm_ul_tbf_ind();
+          }
+          else if(cgrlc_ul_tbf_res->prim_status EQ CGRLC_PRIM_STATUS_ALL)
+          {
+            SET_STATE(TM,TM_PIM);
+            tm_delete_prim_queue();
+            sig_tm_ru_reset_poll_array();
+            tm_cgrlc_status_ind(CGRLC_PACKET_ACCESS_FAILURE);
+            tm_handle_grlc_ready_ind();
+            tm_ul_tbf_ind();
+          }
+          else if(cgrlc_ul_tbf_res->prim_status EQ CGRLC_PRIM_STATUS_TBF)
+          {
+            SET_STATE(TM,TM_PIM);
+            sig_tm_ru_reset_poll_array();
+            tm_cgrlc_status_ind(CGRLC_PACKET_ACCESS_FAILURE);
+            tm_delete_prim_queue();
+            tm_handle_grlc_ready_ind();
+            tm_ul_tbf_ind();
+          }
+          else
+          {
+            tm_handle_error_ra();
+            tm_ul_tbf_ind();
+          }
+          /*
+           * what happens to the existing tbfs
+           */
+          break;
+        case CGRLC_TBF_MODE_UL:
+        case CGRLC_TBF_MODE_TMA:
+        case CGRLC_TBF_MODE_TMB:
+          SET_STATE(TM,TM_PTM);  
+          if((grlc_data->testmode.mode EQ CGRLC_TEST_RANDOM) OR
+             (grlc_data->testmode.mode EQ CGRLC_LOOP))
+          {
+            PALLOC(cgrlc_test_mode_ind,CGRLC_TEST_MODE_IND); /*T_CGRLC_TEST_MODE_IND*/
+            cgrlc_test_mode_ind->test_mode_flag = grlc_data->testmode.mode;
+            PSEND(hCommGRR,cgrlc_test_mode_ind);
+          }
+          grlc_data->uplink_tbf.cs_type      = (T_CODING_SCHEME)cgrlc_ul_tbf_res->cs_mode;
+          grlc_data->uplink_tbf.mac_mode     = cgrlc_ul_tbf_res->mac_mode;
+          grlc_data->uplink_tbf.nts          = cgrlc_ul_tbf_res->nts_max;
+          grlc_data->uplink_tbf.ts_mask      = cgrlc_ul_tbf_res->tn_mask;
+          grlc_data->uplink_tbf.ti           = cgrlc_ul_tbf_res->ti;
+          grlc_data->uplink_tbf.tlli_cs_type = cgrlc_ul_tbf_res->tlli_cs_mode;
+          grlc_data->uplink_tbf.bs_cv_max    = cgrlc_ul_tbf_res->bs_cv_max;
+          grlc_data->r_bit                   = cgrlc_ul_tbf_res->r_bit;
+
+          grlc_data->ul_tbf_start_time       = cgrlc_ul_tbf_res->starting_time;
+          sig_tm_rd_ul_req_stop();
+          sig_tm_meas_ptm();
+
+          tm_activate_tbf ( TBF_TYPE_UL );
+
+          if(cgrlc_ul_tbf_res->mac_mode)
+          {
+            grlc_data->uplink_tbf.fa_manag.fa_type = FA_NO_CURRENT;
+            tm_store_fa_bitmap(&cgrlc_ul_tbf_res->fix_alloc_struct);
+          }
+
+          
+          if(!grlc_data->uplink_tbf.ti)
+            grlc_data->tm.n_acc_req_procedures = 0;
+
+          grlc_data->tm.n_res_req = 0;
+
+          grlc_data->uplink_tbf.rlc_db_granted = cgrlc_ul_tbf_res->rlc_db_granted;
+          
+          tm_tfi_handling  (cgrlc_ul_tbf_res->starting_time,CGRLC_TBF_MODE_UL, cgrlc_ul_tbf_res->tfi, 0xFF);
+          sig_tm_ru_assign();
+          if(cgrlc_ul_tbf_res->polling_bit NEQ 0xFF)
+            tm_handle_polling_bit(cgrlc_ul_tbf_res->starting_time,cgrlc_ul_tbf_res->polling_bit);
+          break;
+        default:
+          TRACE_ERROR("unexpected tbf mode in ul_tbf_res");
+          break;
+      }
+      break;
+    case TM_PTM:      
+      switch(cgrlc_ul_tbf_res->tbf_mode)
+      {
+        case CGRLC_TBF_MODE_ACCESS_FAILED:
+          if(cgrlc_ul_tbf_res->prim_status EQ CGRLC_PRIM_STATUS_ONE)
+          {
+            grlc_delete_prim();
+            tm_cgrlc_status_ind(CGRLC_PACKET_ACCESS_FAILURE);
+            tm_handle_grlc_ready_ind();
+            tm_ul_tbf_ind();
+          }
+          else if(cgrlc_ul_tbf_res->prim_status EQ CGRLC_PRIM_STATUS_ALL)
+          {
+            tm_delete_prim_queue();
+            tm_cgrlc_status_ind(CGRLC_PACKET_ACCESS_FAILURE);
+            tm_handle_grlc_ready_ind();
+            tm_ul_tbf_ind();
+          }
+          else if(cgrlc_ul_tbf_res->prim_status EQ CGRLC_PRIM_STATUS_TBF)
+          {
+            tm_cgrlc_status_ind(CGRLC_PACKET_ACCESS_FAILURE);
+            tm_delete_prim_queue();
+            tm_handle_grlc_ready_ind();
+            tm_ul_tbf_ind();
+          }
+          else
+          {
+			tm_cgrlc_status_ind(CGRLC_PACKET_ACCESS_FAILURE);
+            tm_handle_error_ra();
+          }
+          break;
+        case CGRLC_TBF_MODE_UL:
+        case CGRLC_TBF_MODE_TMA:
+        case CGRLC_TBF_MODE_TMB:
+          if((grlc_data->testmode.mode EQ CGRLC_TEST_RANDOM) OR
+             (grlc_data->testmode.mode EQ CGRLC_LOOP))
+          {
+            PALLOC(cgrlc_test_mode_ind,CGRLC_TEST_MODE_IND); /*T_CGRLC_TEST_MODE_IND*/
+            cgrlc_test_mode_ind->test_mode_flag = grlc_data->testmode.mode;
+            PSEND(hCommGRR,cgrlc_test_mode_ind);
+          }
+
+          grlc_data->uplink_tbf.cs_type      = (T_CODING_SCHEME)cgrlc_ul_tbf_res->cs_mode;
+          grlc_data->uplink_tbf.mac_mode     = cgrlc_ul_tbf_res->mac_mode;
+          grlc_data->uplink_tbf.nts          = cgrlc_ul_tbf_res->nts_max;
+          grlc_data->uplink_tbf.ts_mask      = cgrlc_ul_tbf_res->tn_mask;
+          grlc_data->uplink_tbf.ti           = cgrlc_ul_tbf_res->ti;
+          grlc_data->uplink_tbf.tlli_cs_type = cgrlc_ul_tbf_res->tlli_cs_mode;
+          grlc_data->uplink_tbf.bs_cv_max    = cgrlc_ul_tbf_res->bs_cv_max;
+
+#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
+          if(grlc_data->tbf_type EQ TBF_TYPE_TP_ACCESS)
+          {
+            grlc_data->uplink_tbf.rlc_db_granted = cgrlc_ul_tbf_res->rlc_db_granted;
+           
+            if((grlc_data->testmode.mode EQ CGRLC_TEST_RANDOM) OR
+               (grlc_data->testmode.mode EQ CGRLC_LOOP))
+            {
+              PALLOC(cgrlc_test_mode_ind,CGRLC_TEST_MODE_IND); /*T_CGRLC_TEST_MODE_IND*/
+              cgrlc_test_mode_ind->test_mode_flag = grlc_data->testmode.mode;
+              PSEND(hCommGRR,cgrlc_test_mode_ind);
+            }
+          }
+          else
+#endif
+          {
+            grlc_data->uplink_tbf.rlc_db_granted  = 0;
+          }
+
+
+          grlc_data->tm.n_res_req = 0;
+
+          grlc_data->ul_tbf_start_time       = cgrlc_ul_tbf_res->starting_time;
+          sig_tm_rd_ul_req_stop();
+
+          tm_activate_tbf ( TBF_TYPE_UL );
+
+          if(cgrlc_ul_tbf_res->mac_mode)
+          {
+            tm_store_fa_bitmap(&cgrlc_ul_tbf_res->fix_alloc_struct);
+          }
+
+          if(!grlc_data->uplink_tbf.ti)
+            grlc_data->tm.n_acc_req_procedures = 0;
+
+          tm_tfi_handling  (cgrlc_ul_tbf_res->starting_time,CGRLC_TBF_MODE_UL, cgrlc_ul_tbf_res->tfi, 0xFF);
+
+          sig_tm_ru_assign();
+          break;
+#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
+        case CGRLC_TBF_MODE_2PA: 
+          {
+            /*tbf establishment on PACCH*/
+            grlc_data->ul_tbf_start_time       = cgrlc_ul_tbf_res->starting_time;
+            tm_send_prr_2p_ptm();              
+            grlc_data->tm.pacch_prr_pca_sent = FALSE ; /* For Release of TBF , as two phase */
+          }
+          break;
+#endif
+        default:
+          TRACE_ERROR("unexpected tbf mode in ul_tbf_res");
+          break;
+      }
+      break;
+    default:
+      TRACE_ERROR( "CGRLC_UL_TBF_RES unexpected" );
+      break;
+  }
+  PFREE(cgrlc_ul_tbf_res);
+
+} /* tm_cgrlc_ul_tbf_res() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_dl_tbf_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive cgrlc_dl_tbf_req
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_dl_tbf_req ( T_CGRLC_DL_TBF_REQ *cgrlc_dl_tbf_req )
+{ 
+  UBYTE rd_state=GET_STATE( RD );
+  TRACE_FUNCTION( "tm_cgrlc_dl_tbf_req" );
+
+  tm_prcs_pwr_ctrl( &cgrlc_dl_tbf_req->pwr_ctrl );
+  grlc_data->downlink_tbf.trans_id++;
+
+  /*
+   * Ignore the request for or modification of an DL TBF in case an DL TBF 
+   * release request is currently sent to the data queue of GRR, it is just 
+   * not yet processed, but TBF will be released anyway as one of the next
+   * steps.
+   */
+  if( ( grlc_data->rel_type & REL_TYPE_DL ) EQ REL_TYPE_DL )
+  {
+    /* The scenario T3192 expires before packet DL assignment message has been received
+    is handled.*/
+
+    TRACE_EVENT( "tm_cgrlc_dl_tbf_req: release of DL TBF requested in parallel" );
+    
+    TRACE_EVENT( "Exception: T3192 expiry before PDA race condition, verify this" );
+    grlc_data->rel_type &= ( ~ ( REL_TYPE_DL ) );
+
+  }
+
+  switch( GET_STATE( TM ) )
+  {
+    case TM_PAM:     
+    case TM_PIM:
+    case TM_WAIT_4_PIM:
+      SET_STATE(TM,TM_PTM);
+      grlc_data->r_bit = 0; 
+
+      sig_tm_meas_ptm();
+
+      /*lint -fallthrough*/
+
+    case TM_PTM:
+      
+    if(cgrlc_dl_tbf_req->ctrl_ack_bit)
+    {
+      TRACE_EVENT("GRLC ctrl ack bit set");
+      if((grlc_data->tbf_type EQ TBF_TYPE_UL) OR 
+         (grlc_data->tbf_type EQ TBF_TYPE_NULL))
+      {
+        TRACE_EVENT("DL ass will not be discarded in GRLC");
+      }
+      {
+        sig_tm_rd_nor_rel();
+        tm_deactivate_tbf(TBF_TYPE_DL);
+        grlc_data->dl_tfi = 0xFF;
+      }
+   }
+   else if (!cgrlc_dl_tbf_req->ctrl_ack_bit  AND
+               (grlc_t_status(T3192) > 0)       AND 
+               #ifdef _TARGET_ 
+                (grlc_t_status(T3192) < 25)
+               #else
+                (grlc_t_status(T3192) < 65) 
+               #endif
+              )
+    {
+      TRACE_EVENT_P1("XXXX accepting DL Ass T3192=%ld",grlc_t_status(T3192));
+      if ( rd_state EQ RD_REL_ACK OR
+           rd_state EQ RD_REL_UACK )
+      {
+        sig_tm_rd_nor_rel();
+        tm_deactivate_tbf(TBF_TYPE_DL);
+        grlc_data->dl_tfi = 0xFF;
+      }
+    }
+
+      grlc_data->downlink_tbf.rlc_mode    = cgrlc_dl_tbf_req->rlc_mode;
+      grlc_data->downlink_tbf.cs_type     = (T_CODING_SCHEME)cgrlc_dl_tbf_req->cs_mode;
+      grlc_data->downlink_tbf.mac_mode    = cgrlc_dl_tbf_req->mac_mode;
+      grlc_data->downlink_tbf.nts         = cgrlc_dl_tbf_req->nts_max;
+      grlc_data->downlink_tbf.ts_mask     = cgrlc_dl_tbf_req->tn_mask;
+      grlc_data->downlink_tbf.t3192_val   = cgrlc_dl_tbf_req->t3192_val;
+
+      grlc_data->dl_tbf_start_time       = cgrlc_dl_tbf_req->starting_time;
+
+      tm_activate_tbf ( TBF_TYPE_DL );
+
+      tm_tfi_handling  (cgrlc_dl_tbf_req->starting_time,CGRLC_TBF_MODE_DL,0xFF,cgrlc_dl_tbf_req->tfi);
+
+      sig_tm_rd_assign();
+
+    
+      if(cgrlc_dl_tbf_req->polling_bit NEQ 0xFF)
+        tm_handle_polling_bit(cgrlc_dl_tbf_req->starting_time,cgrlc_dl_tbf_req->polling_bit);
+
+
+      tm_ul_tbf_ind(); /* dl tbf during access mode, ul tbf will be established over downlink*/
+      break;
+    default:
+      {
+        /* This shall never happen, but in case, GRLC shall inform GRR about the 
+         * immediate release of the TBF. Otherwise GRLC and GRR are running out
+         * of synchronisation and the whole system hangs.
+         */
+        PALLOC( cgrlc_tbf_rel_ind, CGRLC_TBF_REL_IND );
+
+        TRACE_ERROR( "CGRLC_DL_TBF_REQ unexpected, so send release ind!" );
+      
+        cgrlc_tbf_rel_ind->tbf_mode      = CGRLC_TBF_MODE_DL;
+        cgrlc_tbf_rel_ind->tbf_rel_cause = CGRLC_TBF_REL_ABNORMAL;
+        cgrlc_tbf_rel_ind->v_c_value     = FALSE;
+        cgrlc_tbf_rel_ind->dl_trans_id   = grlc_data->downlink_tbf.trans_id;
+
+        PSEND( hCommGRR, cgrlc_tbf_rel_ind );
+      }
+      break;
+  }
+  PFREE(cgrlc_dl_tbf_req);
+
+} /* tm_cgrlc_dl_tbf_req() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_tbf_rel_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive cgrlc_tbf_rel_req
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_tbf_rel_req ( T_CGRLC_TBF_REL_REQ       *cgrlc_tbf_rel_req )
+{ 
+  BOOL rel_ul = FALSE;
+  BOOL rel_dl = FALSE;
+  BOOL mod_ul = FALSE;
+  BOOL mod_dl = FALSE;
+
+
+  TRACE_FUNCTION( "tm_cgrlc_tbf_rel_req" );
+
+
+  switch( GET_STATE( TM ) )
+  {
+    case TM_PTM:
+      /*
+       * 1. abnomal release uplink            --> immediate release
+       * 2. normal release uplink             --> normal tbf release after current pdu is transmitted
+       * 3. abnormal release downlink no poll --> immediate release
+       * 4. abnormal release downlink with poll--> release after poll is sent
+       * release both tbfs in case of testmode B
+       */
+
+      if( (cgrlc_tbf_rel_req->tbf_mode EQ CGRLC_TBF_MODE_UL) OR
+          (cgrlc_tbf_rel_req->tbf_mode EQ CGRLC_TBF_MODE_DL_UL)
+#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
+          OR
+          (cgrlc_tbf_rel_req->tbf_mode EQ CGRLC_TBF_MODE_2PA)
+#endif
+        )
+      {
+        if(grlc_data->testmode.mode EQ CGRLC_LOOP)
+        {
+           rel_ul = TRUE;
+           rel_dl = TRUE;
+        }
+        else
+        {
+           if(cgrlc_tbf_rel_req->tbf_rel_cause EQ CGRLC_TBF_REL_ABNORMAL)
+           {
+              rel_ul = TRUE;
+           }
+           else
+           {
+              mod_ul = TRUE;
+           }
+        }
+
+      }
+      if( (cgrlc_tbf_rel_req->tbf_mode EQ CGRLC_TBF_MODE_DL) OR
+          (cgrlc_tbf_rel_req->tbf_mode EQ CGRLC_TBF_MODE_DL_UL))
+      {
+        if(grlc_data->testmode.mode EQ CGRLC_LOOP)
+        {
+           rel_ul = TRUE;
+           rel_dl = TRUE;
+        }
+        else
+        {
+           if(cgrlc_tbf_rel_req->rel_fn EQ  CGRLC_STARTING_TIME_NOT_PRESENT)
+           {
+               rel_dl = TRUE;
+           }
+           else
+           {
+               mod_dl = TRUE;
+           }
+        }
+
+      }
+
+      if(mod_ul)
+      {
+        if(grlc_data->ru.next_prim < PRIM_QUEUE_SIZE_TOTAL)
+        {
+          grlc_data->prim_queue[grlc_data->ru.next_prim].start_new_tbf = 1; 
+          TRACE_EVENT_P5("QUEUE_STATUS BEFORE start=%d,next=%d active=%d rlc_oct=%ld sdu_len=%ld"
+                                                    ,grlc_data->prim_start_tbf
+                                                    ,grlc_data->ru.next_prim
+                                                    ,grlc_data->ru.active_prim
+                                                    ,grlc_data->ru.rlc_octet_cnt
+                                                    ,grlc_data->ru.sdu_len);
+          sig_tm_ru_queue_status();
+          TRACE_EVENT_P5("QUEUE_STATUS AFTER start=%d,next=%d active=%d rlc_oct=%ld sdu_len=%ld"
+                                                    ,grlc_data->prim_start_tbf
+                                                    ,grlc_data->ru.next_prim
+                                                    ,grlc_data->ru.active_prim
+                                                    ,grlc_data->ru.rlc_octet_cnt
+                                                    ,grlc_data->ru.sdu_len);
+        }
+      }
+      if ( rel_ul AND
+          (cgrlc_tbf_rel_req->rel_fn NEQ CGRLC_STARTING_TIME_NOT_PRESENT))
+      {
+        sig_tm_ru_abrel(cgrlc_tbf_rel_req->rel_fn, TRUE);
+        mod_ul = TRUE;
+        rel_ul = FALSE;
+      }
+
+      if(mod_dl)
+      {  
+        sig_tm_rd_abrel(cgrlc_tbf_rel_req->rel_fn, TRUE);
+      }
+
+
+      if(rel_dl AND rel_ul)
+      {
+        tm_abort_tbf(grlc_data->tbf_type);
+      }
+      else if(rel_dl)
+      {
+        tm_abort_tbf(TBF_TYPE_DL);
+      }
+      else if(rel_ul)
+      {
+#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH
+        if(grlc_data->tbf_type EQ TBF_TYPE_TP_ACCESS )
+          tm_abort_tbf(TBF_TYPE_TP_ACCESS);
+         else
+#endif
+        tm_abort_tbf(TBF_TYPE_UL);
+      }
+
+
+      if(grlc_data->tbf_type EQ TBF_TYPE_NULL)
+      {
+        SET_STATE(TM,TM_WAIT_4_PIM);
+        sig_tm_ru_reset_poll_array();
+      }
+      break;
+    default:
+      TRACE_ERROR( "CGRLC_TBF_REL_REQ unexpected" );
+      break;
+  }
+  PFREE(cgrlc_tbf_rel_req);
+
+} /* tm_cgrlc_tbf_rel_req() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_tbf_rel_res
++------------------------------------------------------------------------------
+| Description : Handles the primitive cgrlc_tbf_rel_res
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_tbf_rel_res ( T_CGRLC_TBF_REL_RES *cgrlc_tbf_rel_res )
+{ 
+
+#if !defined (NTRACE)
+
+  BOOL       trace    = FALSE;
+  T_REL_TYPE rel_type = grlc_data->rel_type;
+
+#endif /* #if !defined (NTRACE) */
+
+  TRACE_FUNCTION( "tm_cgrlc_tbf_rel_res" );
+
+  /*
+   * Check for consistency: Only requested releases shall be indicated by GRR.
+   */
+  if( cgrlc_tbf_rel_res->tbf_mode EQ CGRLC_TBF_MODE_DL_UL OR
+      cgrlc_tbf_rel_res->tbf_mode EQ CGRLC_TBF_MODE_DL       )
+  {
+    if( ( grlc_data->rel_type & REL_TYPE_DL ) EQ REL_TYPE_DL )
+    {
+      grlc_data->rel_type &= ( ~ ( REL_TYPE_DL ) );
+    }
+
+#if !defined (NTRACE)
+
+    else
+    {
+      trace = TRUE;
+    } 
+
+#endif /* #if !defined (NTRACE) */
+
+  }
+
+  /*
+   * Check for consistency: Only requested releases shall be indicated by GRR.
+   */
+  if( cgrlc_tbf_rel_res->tbf_mode EQ CGRLC_TBF_MODE_DL_UL OR
+      cgrlc_tbf_rel_res->tbf_mode EQ CGRLC_TBF_MODE_UL       )
+  {
+    if( ( grlc_data->rel_type & REL_TYPE_UL ) EQ REL_TYPE_UL )
+    {
+      grlc_data->rel_type &= ( ~ ( REL_TYPE_UL ) );
+    }
+
+#if !defined (NTRACE)
+
+    else
+    {
+      trace = TRUE;
+    } 
+
+#endif /* #if !defined (NTRACE) */
+
+  }
+
+#if !defined (NTRACE)
+
+  /*
+   * Inconsistency deteced.
+   */
+  if( trace EQ TRUE )
+  {
+    TRACE_EVENT_P3
+      ( "tm_cgrlc_tbf_rel_res: unexpected release response - tbf_mode = %d, rel_type (old) = %d, rel_type (new) = %d",
+        cgrlc_tbf_rel_res->tbf_mode, rel_type, grlc_data->rel_type );
+  }
+
+#endif /* #if !defined (NTRACE) */
+
+  if( grlc_data->rel_type EQ REL_TYPE_NULL )
+  {  
+    switch( GET_STATE( TM ) )
+    {
+    case TM_ACCESS_DISABLED:
+    case TM_ACCESS_PREPARED:
+      break;
+    case TM_WAIT_4_PIM:
+      SET_STATE(TM,TM_PIM);
+      sig_tm_ru_reset_poll_array();
+      tm_handle_test_mode_cnf( grlc_data->testmode.mode EQ CGRLC_TEST_MODE_RELEASE );
+      grlc_data->tm.n_res_req            = 0;
+
+      /*lint -fallthrough*/
+
+    case TM_PIM:
+      /*
+       * reset ta value
+       */
+      grlc_data->ta_value = 0xFF;  
+
+      /*lint -fallthrough*/
+
+    case TM_PTM:
+      tm_ul_tbf_ind();
+      break;
+    default:
+      TRACE_ERROR( "CGRLC_TBF_REL_RES unexpected" );
+      break;
+    }
+  }
+  PFREE(cgrlc_tbf_rel_res);
+
+} /* tm_cgrlc_tbf_rel_res() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_data_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive cgrlc_data_req
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_data_req ( T_CGRLC_DATA_REQ          *cgrlc_data_req )
+{ 
+  TRACE_FUNCTION( "tm_cgrlc_data_req" );
+
+
+  switch( GET_STATE( TM ) )
+  {
+    case TM_PAM:
+    case TM_PTM:
+      tm_store_ctrl_blk( cgrlc_data_req->blk_owner, ( void* )cgrlc_data_req->data_array ) ;
+      break;
+    default:
+      TRACE_ERROR( "CGRLC_DATA_REQ unexpected" );
+      break;
+  }
+  PFREE(cgrlc_data_req);
+
+} /* tm_cgrlc_data_req() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_poll_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive cgrlc_poll_req
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_poll_req ( T_CGRLC_POLL_REQ          *cgrlc_poll_req )
+{ 
+  TRACE_FUNCTION( "tm_cgrlc_poll_req" );
+
+
+  switch( GET_STATE( TM ) )
+  {
+    case TM_PAM:
+      /*
+       * handle cpap polling bit, no save pass directly to layer1, poll will 
+       * be sent with the first call
+       */
+
+      grlc_data->next_poll_fn      = cgrlc_poll_req->poll_fn;
+      grlc_data->ul_poll_pos_index = 0;
+      
+      if(grlc_data->burst_type NEQ CGRLC_BURST_TYPE_NB) 
+      { 
+        grlc_send_access_burst(cgrlc_poll_req->tn);
+      }
+      else 
+      {
+        T_U_GRLC_CTRL_ACK u_ctrl_ack; /* built pca, do not use ccd, because IA is stored*/
+        u_ctrl_ack.msg_type  = U_GRLC_CTRL_ACK_c;
+        u_ctrl_ack.pctrl_ack = cgrlc_poll_req->ctrl_ack;
+        grlc_set_buf_tlli( &u_ctrl_ack.tlli_value, grlc_data->uplink_tbf.tlli );
+
+        grlc_send_normal_burst((UBYTE *)&u_ctrl_ack, NULL, cgrlc_poll_req->tn);
+      }
+
+      break;
+    case TM_PTM:
+      grlc_save_poll_pos(cgrlc_poll_req->poll_fn,
+                         cgrlc_poll_req->tn,
+                         0xFF,
+                         cgrlc_poll_req->poll_b_type,
+                         cgrlc_poll_req->ctrl_ack);
+      break;
+    default:
+      TRACE_ERROR( "CGRLC_POLL_REQ unexpected" );
+      break;
+  }
+  PFREE(cgrlc_poll_req);
+
+} /* tm_cgrlc_poll_req() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_access_status_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive cgrlc_access_status_req
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_access_status_req ( T_CGRLC_ACCESS_STATUS_REQ *cgrlc_access_status_req )
+{ 
+  TRACE_FUNCTION( "tm_cgrlc_access_status_req" );
+
+
+  switch( GET_STATE( TM ) )
+  {
+    case TM_PIM:
+    case TM_PAM:
+      tm_ul_tbf_ind();
+      break;
+    default:
+      TRACE_ERROR( "CGRLC_ACCESS_STATUS_REQ unexpected" );
+      break;
+  }
+  PFREE(cgrlc_access_status_req);
+
+} /* tm_cgrlc_access_status_req() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_test_mode_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive cgrlc_test_mode_req
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_test_mode_req ( T_CGRLC_TEST_MODE_REQ     *cgrlc_test_mode_req )
+{  
+  UBYTE pdus_to_queue;
+  UBYTE count = 0;
+
+  TRACE_FUNCTION( "tm_cgrlc_test_mode_req" );
+
+  TRACE_EVENT_P1( "cgrlc_test_mode_req test mode is activ %x",cgrlc_test_mode_req->test_mode_flag);
+  
+  switch( GET_STATE( TM ) )
+  {
+    case TM_PIM:
+    case TM_PTM:
+     /* 
+      * save the test mode data
+      */
+
+      grlc_data->testmode.mode   = cgrlc_test_mode_req->test_mode_flag; 
+
+      grlc_data->testmode.n_pdu         = (ULONG)cgrlc_test_mode_req->no_of_pdus;
+      grlc_data->testmode.dl_ts_offset  = cgrlc_test_mode_req->dl_timeslot_offset;
+
+
+      if (grlc_data->testmode.mode EQ CGRLC_LOOP)
+      {
+        TRACE_EVENT("testmode b");
+        switch(grlc_data->tbf_type)
+        {
+          case TBF_TYPE_DL:
+            /*
+             * request uplink tbf over existing DL
+             */
+            tm_queue_test_mode_prim(1);
+            /*
+             * set received buffer to special values
+             */
+            grlc_data->testmode.rec_data[0].block_status = 0xFEFE;
+            grlc_data->testmode.rec_data[0].e_bit        = 0xFE;
+            memset(grlc_data->testmode.rec_data[0].payload, 0xFE,50);
+            grlc_data->testmode.rec_data[1].block_status = 0xFEFE;
+            grlc_data->testmode.rec_data[1].e_bit        = 0xFE;
+            memset(grlc_data->testmode.rec_data[1].payload, 0xFE,50);
+            /*
+             * If the "Downlink Timeslot Offset" is set to 3, TN3 shall be treated as the first downlink
+             * timeslot if a TBF is established in TN3. If TN3 does not support a TBF, the first active 
+             * timeslot after TN3 shall be treated as the first downlink timeslot. The counting sequence 
+             * is continuous through TN7 and TN0.
+             */
+            while (!((0x80>>grlc_data->testmode.dl_ts_offset) & grlc_data->dl_tn_mask) && (count < 8))
+            {
+              if (grlc_data->testmode.dl_ts_offset > 7)
+                grlc_data->testmode.dl_ts_offset = (UBYTE)-1;
+              grlc_data->testmode.dl_ts_offset++;
+              count++;
+            }
+            TRACE_EVENT_P1 ("downlink timeslot offset is %d", grlc_data->testmode.dl_ts_offset);
+            break;
+          default:
+            TRACE_EVENT_P1("unexpected tbf type for testmode B:tbf_type=%d",grlc_data->tbf_type);
+            break;
+        }        
+
+      }
+      else  /* it is testmode A with regular PDU amount */ 
+      {
+        if (grlc_data->testmode.n_pdu EQ 0)
+        {
+          /*
+           * In case of Testmode A and 0 PDUs are requested the MS may 
+           * optionally interprete this as infinitive duration TBF.
+           */
+          TRACE_EVENT("testmode a infinite");
+          grlc_data->testmode.n_pdu -= 1;
+        }
+        else
+        {
+          TRACE_EVENT_P1("testmode a %ld pdus",grlc_data->testmode.n_pdu);
+        }
+        /*
+         * (PRIM_QUEUE_SIZE-1) to avoid the full prime queue situation in test mode.
+         * It should also not be more then 50*64 byte, which are queue here.
+         * The remainig PDUs will be queued when a PDU is completely transmitted.
+         */
+        if (grlc_data->testmode.n_pdu < (PEI_PRIM_QUEUE_SIZE/2))
+        {
+          pdus_to_queue = (UBYTE) grlc_data->testmode.n_pdu;
+          grlc_data->testmode.n_pdu = 0;
+        }
+        else
+        {
+          pdus_to_queue = (PEI_PRIM_QUEUE_SIZE/2);
+          grlc_data->testmode.n_pdu -= (PEI_PRIM_QUEUE_SIZE/2);
+        }
+        /*
+         *  generation of pseudo primitve to start the test mode tbf TBF
+         */
+        tm_queue_test_mode_prim(pdus_to_queue);
+
+        grlc_prbs(INITIALIZE, 0, 0);
+        if(!grlc_data->testmode.ptr_test_data)
+        {
+          MALLOC(grlc_data->testmode.ptr_test_data,50/*Max. RLC Block Length*/);
+        }
+      }
+
+      break;
+    default:
+      TRACE_ERROR( "CGRLC_TEST_MODE_REQ  unexpected" );
+      TRACE_EVENT_P1("tm state %d", grlc_data->tm.state);
+      break;
+  }
+
+
+  PFREE(cgrlc_test_mode_req);
+
+} /* tm_cgrlc_test_mode_req() */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_test_end_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive CGRLC_TEST_END_REQ
+|               GRLC have to leave the test mode. The leaving procedure is 
+|               finished with the transmission of GMMRR_TEST_MODE_CNF
+| Parameters  : *gmmrr_suspend_req - Ptr to primitive payload
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_test_end_req ( T_CGRLC_TEST_END_REQ *cgrlc_test_end_req )
+{ 
+  TRACE_FUNCTION( "tm_cgrlc_test_end_req" );
+
+  tm_abort_tbf( grlc_data->tbf_type );
+
+  /*
+   * delete all primitives in queue.
+   */
+  tm_delete_prim_queue();
+
+  SET_STATE(TM,TM_WAIT_4_PIM);
+
+  grlc_data->tm.n_acc_req_procedures = 0;
+  grlc_data->tm.n_res_req            = 0; /* reset counter of resource requests during access */
+  
+  PFREE(cgrlc_test_end_req);
+
+} /* tm_cgrlc_test_end_req() */
+
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_ta_value_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive cgrlc_ta_value_req
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_ta_value_req ( T_CGRLC_TA_VALUE_REQ      *cgrlc_ta_value_req )
+{ 
+  TRACE_FUNCTION( "tm_cgrlc_ta_value_req" );
+
+  grlc_data->ta_value = cgrlc_ta_value_req->ta_value;
+
+  PFREE(cgrlc_ta_value_req);
+
+} /* tm_cgrlc_ta_value_req() */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_ready_timer_config_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive tm_cgrlc_ready_timer_config_req
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_ready_timer_config_req 
+               ( T_CGRLC_READY_TIMER_CONFIG_REQ *cgrlc_ready_timer_config_req )
+{ 
+  TRACE_FUNCTION( "tm_cgrlc_ready_timer_config_req" );
+
+  grlc_data->ready_timer.handling = READY_TIMER_HANDLING_ENABLED;
+  grlc_data->ready_timer.value    = cgrlc_ready_timer_config_req->t3314_val; 
+
+  if( grlc_data->ready_timer.value EQ CGRLC_DEACTIVATED )
+  {
+    grlc_enter_ready_state( );
+  }
+
+  PFREE(cgrlc_ready_timer_config_req);
+
+} /* (tm_cgrlc_ready_timer_config_req) */
+
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_force_to_standby_req
++------------------------------------------------------------------------------
+| Description : Handles the primitive tm_cgrlc_force_to_standby_req
+|
+| Parameters  : void
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_force_to_standby_req 
+                   ( T_CGRLC_FORCE_TO_STANDBY_REQ *cgrlc_force_to_standby_req )
+{ 
+  TRACE_FUNCTION( "tm_cgrlc_force_to_standby_req" );
+
+ /*
+  * By receiving this primitive the Ready Timer State will be forced to Standby and
+  * the running Ready Timer will be stopped
+  */
+  grlc_enter_standby_state( );
+
+  PFREE(cgrlc_force_to_standby_req);
+
+} /* (tm_cgrlc_force_to_standby_req) */
+/*
++------------------------------------------------------------------------------
+| Function    : tm_cgrlc_pwr_ctrl_req
++------------------------------------------------------------------------------
+| Description : 
+|
+| Parameters  : 
+|
++------------------------------------------------------------------------------
+*/
+GLOBAL void tm_cgrlc_pwr_ctrl_req ( T_CGRLC_PWR_CTRL_REQ *pwr_ctrl_req )
+{
+  TRACE_FUNCTION( "tm_cgrlc_pwr_ctrl_req" );
+
+  tm_prcs_pwr_ctrl( &pwr_ctrl_req->pwr_ctrl );
+
+  PFREE( pwr_ctrl_req );
+
+} /* tm_cgrlc_pwr_ctrl_req */