/* 
+----------------------------------------------------------------------------- 
|  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 */