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

#ifndef GRR_CTRLF_C
#define GRR_CTRLF_C
#endif

#define ENTITY_GRR

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

#include "typedefs.h"    /* to get Condat data types */

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

#include "grr_ctrlf.h"  /* */
#include "grr_ctrls.h"

#include "grr_meass.h"  /* */
#include "grr_pgs.h"    /* */
#include "grr_psis.h"   /* */
#include "grr_css.h"    /* */
#include "grr_tcs.h"    /* */

#include <string.h>     /* for memcpy */
#include "pcm.h"

#ifdef _TARGET_
#include "ffs/ffs.h"
#endif



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

#define BCC_OF_BSIC      7

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

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

LOCAL void ctrl_set_final_pckt_mode         ( void                          );
LOCAL BOOL ctrl_set_transient_pckt_mode     ( T_GLBL_PCKT_MODE final_pckt_mode,
                                              T_CTRL_TASK *ctrl_task        );
LOCAL void ctrl_enter_pim                   ( void                          );
LOCAL void ctrl_leave_to_pam                ( void                          );
LOCAL void ctrl_enter_pam                   ( void                          );
LOCAL void ctrl_enter_ptm                   ( void                          );
LOCAL BOOL ctrl_check_cco_freq              ( USHORT arfcn                  );
/*==== PUBLIC FUNCTIONS =====================================================*/



/*
+------------------------------------------------------------------------------
| Function    : ctrl_stop_all_activities
+------------------------------------------------------------------------------
| Description : The function ctrl_stop_all_activities() .... 
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_stop_all_activities ( T_CTRL_DISABLE_CAUSE  dc,
                                       void                 *data )
{ 
  BOOL is_pbcch_reset_needed = FALSE;

  TRACE_FUNCTION( "ctrl_stop_all_activities" );

  /*
   * inform the service PG
   * parameters dc and data are not of interest 
   */
  sig_ctrl_pg_stop( );

  /*
   * inform the service MEAS 
   * parameter data is not of interest 
   */
  switch( dc )
  {
    case( CTRL_DC_OTHER ):
    case( CTRL_DC_SUSPEND_NORMAL ):    
    case( CTRL_DC_SUSPEND_IMM_REL ):
    case( CTRL_DC_CR_NW_RR ):
    case( CTRL_DC_CR_NW_GRR ):
    case( CTRL_DC_CR_MS_GRR_NORMAL ):
    case( CTRL_DC_PSI_MANAGEMENT ):
    case( CTRL_DC_CR_MS_RR_NORMAL ):
    case( CTRL_DC_CR_MS_RR_IMM_REL ):
    case( CTRL_DC_CR_MS_GRR_ABNORMAL ):
      sig_ctrl_meas_stop( );
      break;

    default:
      TRACE_EVENT( "FATAL ERROR 1 in ctrl_stop_all_activities" );
      break;
  }
 
  /*
   * inform the service CS 
   */
  switch( dc )
  {
    case( CTRL_DC_OTHER ):
      vsi_t_stop( GRR_handle, T3174 );
      vsi_t_stop( GRR_handle, T3176 );
#ifdef _SIMULATION_
      sig_ctrl_cs_simu_timer_stop();
#endif

      /*lint -fallthrough*/

    case( CTRL_DC_CR_MS_GRR_NORMAL ):
    case( CTRL_DC_CR_MS_GRR_ABNORMAL ):
    case( CTRL_DC_PSI_MANAGEMENT ):
    case( CTRL_DC_CR_MS_RR_NORMAL ):
    case( CTRL_DC_CR_MS_RR_IMM_REL ):
      sig_ctrl_cs_stop(CS_DC_OTHER);
      break;

    case( CTRL_DC_SUSPEND_NORMAL ):    
    case( CTRL_DC_SUSPEND_IMM_REL ):
      sig_ctrl_cs_stop( CS_DC_DEDICATED );
      break; 

    case( CTRL_DC_CR_NW_RR ):
      sig_ctrl_cs_cc_order_ind( NULL, (T_D_CHANGE_ORDER *)data );
      break;

    case( CTRL_DC_CR_NW_GRR ):
      if (grr_t_status( T3174 ) > 0 )
      {
        sig_ctrl_cs_cc_order_ind( (T_D_CELL_CHAN_ORDER *)data, NULL );
      }
      else
      {
        sig_ctrl_cs_stop(CS_DC_OTHER);
      }
      break;

    default:
      TRACE_EVENT( "FATAL ERROR 2 in ctrl_stop_all_activities" );
      break;  
  }

  /*
   * inform the service PSI
   * parameter data is not of interest 
   */
  switch( dc )
  {
    case( CTRL_DC_OTHER ):
    case( CTRL_DC_CR_MS_RR_NORMAL ):
    case( CTRL_DC_CR_MS_RR_IMM_REL ):
    case( CTRL_DC_CR_MS_GRR_NORMAL ):
      sig_ctrl_psi_stop( );


      is_pbcch_reset_needed = TRUE;
      break;

    case( CTRL_DC_SUSPEND_NORMAL ):    
    case( CTRL_DC_SUSPEND_IMM_REL ):
    case( CTRL_DC_CR_NW_RR ):
    case( CTRL_DC_CR_NW_GRR ):
    case( CTRL_DC_CR_MS_GRR_ABNORMAL ):
      sig_ctrl_psi_suspend( );
      break;

    case( CTRL_DC_PSI_MANAGEMENT ):
      /* do nothing */
      break;

    default:
      TRACE_EVENT( "FATAL ERROR 3 in ctrl_stop_all_activities" );
      break;
  }
  
  /*
   * inform the service TC
   * parameter data is not of interest 
   */
  switch( dc )
  {
    case( CTRL_DC_OTHER ):
    case( CTRL_DC_PSI_MANAGEMENT ):
      ctrl_send_access_disable_if_needed
                        ( TC_DC_OTHER,           sig_tc_ctrl_tbf_release_cnf );
      break;

    case( CTRL_DC_CR_NW_RR ):
    case( CTRL_DC_CR_NW_GRR ):
      ctrl_send_access_disable_if_needed
                        ( TC_DC_CR_NETWORK,      sig_tc_ctrl_cr_started_rsp  );
      break;

    case( CTRL_DC_CR_MS_RR_NORMAL ):
      ctrl_send_access_disable_if_needed
                        ( TC_DC_CR_NORMAL,       sig_tc_ctrl_cr_started_rsp  );
      break;

    case( CTRL_DC_CR_MS_RR_IMM_REL ):
    case( CTRL_DC_CR_MS_GRR_NORMAL ):
      ctrl_send_access_disable_if_needed
                        ( TC_DC_CR_IMM_REL,      sig_tc_ctrl_cr_started_rsp  );
      break;

    case( CTRL_DC_CR_MS_GRR_ABNORMAL ):
      ctrl_send_access_disable_if_needed
                        ( TC_DC_CR_ABNORMAL,     sig_tc_ctrl_cr_started_rsp  );
      break;

    case( CTRL_DC_SUSPEND_NORMAL ):    
      ctrl_send_access_disable_if_needed
                        ( TC_DC_SUSPEND_NORMAL,  sig_tc_ctrl_suspend_cnf     );
      break;

    case( CTRL_DC_SUSPEND_IMM_REL ):
      ctrl_send_access_disable_if_needed
                        ( TC_DC_SUSPEND_IMM_REL, sig_tc_ctrl_suspend_cnf     );
      break;

    default:
      TRACE_EVENT( "FATAL ERROR 4 in ctrl_stop_all_activities" );
      break;
  }
  
  if( is_pbcch_reset_needed )
  {
    grr_set_pbcch( FALSE );
  }
} /* ctrl_stop_all_activities() */

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

  /* init parameters of CTRL*/
  
  INIT_STATE( CTRL,      CTRL_NULL           );
  INIT_STATE( CTRL_GLBL, GLBL_PCKT_MODE_NULL );

  grr_data->ctrl.new_cell_responded = FALSE;
  grr_data->ctrl.psi_tbf_rel_cause  = CTRL_PTRC_NONE;
  grr_data->ctrl_glbl.ctrl_task     = CTRL_TASK_NONE;

#ifdef _SIMULATION_

  TRACE_EVENT_P1( "ctrl_init - ctrl_task: %d", grr_data->ctrl_glbl.ctrl_task );

#endif /* #ifdef _SIMULATION_ */

  grr_data->ctrl.rr_state.monitoring_stopped = FALSE;
  grr_data->ctrl.rr_state.cr_ind_return      = CR_IND_RETURN_NONE;
  
  ctrl_read_pcm();

} /* ctrl_init() */



/*
+------------------------------------------------------------------------------
| Function    : ctrl_start_monitoring_bcch
+------------------------------------------------------------------------------
| Description : The function ctrl_start_monitoring_bcch() This function starts 
|               reading System Information (SI) on BCCH
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_start_monitoring_bcch ( UBYTE si_to_read )
{ 
  TRACE_FUNCTION( "ctrl_start_monitoring_bcch" );
    
  {
    PALLOC( rrgrr_start_mon_bcch_req, RRGRR_START_MON_BCCH_REQ );

    rrgrr_start_mon_bcch_req->si_to_read = psc_db->si_to_acquire = si_to_read;

    PSEND( hCommRR, rrgrr_start_mon_bcch_req );
  }
} /* ctrl_start_monitoring_bcch() */

  
/*
+------------------------------------------------------------------------------
| Function    : ctrl_stop_monitoring_ccch
+------------------------------------------------------------------------------
| Description : The function ctrl_stop_monitoring_ccch() This function stops 
|               monitoring CCCH
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_stop_monitoring_ccch ( void )
{ 
  TRACE_FUNCTION( "ctrl_stop_monitoring_ccch" );
  
  if(!grr_data->ctrl.rr_state.monitoring_stopped OR (grr_data->test_mode NEQ CGRLC_NO_TEST_MODE))
  {
    PALLOC ( rrgrr_stop_mon_ccch_req, RRGRR_STOP_MON_CCCH_REQ);
    rrgrr_stop_mon_ccch_req->is_pbcch_present = grr_is_pbcch_present();
    PSEND (hCommRR, rrgrr_stop_mon_ccch_req);
  }
  grr_data->ctrl.rr_state.monitoring_stopped = TRUE;
} /* ctrl_stop_monitoring_ccch() */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_start_monitoring_ccch
+------------------------------------------------------------------------------
| Description : The function ctrl_start_monitoring_ccch() This function starts 
|               monitoring CCCH
|
| Parameters  : pag_mode : indicates the page, which shall be uese by RR/L1
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_start_monitoring_ccch ( UBYTE pag_mode )
{ 
  TRACE_FUNCTION( "ctrl_start_monitoring_ccch" );
  
  {
    PALLOC ( rrgrr_start_mon_ccch_req, RRGRR_START_MON_CCCH_REQ);
    rrgrr_start_mon_ccch_req->pag_mode = pag_mode;
#if defined (REL99) AND defined (TI_PS_FF_EMR)
#else
    rrgrr_start_mon_ccch_req->split_pg = grr_data->ms.split_pg_cycle;
#endif
    PSEND (hCommRR, rrgrr_start_mon_ccch_req);
  }
  grr_data->ctrl.rr_state.monitoring_stopped = FALSE;
} /* ctrl_start_monitoring_ccch() */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_send_rr_est_req
+------------------------------------------------------------------------------
| Description : The function ctrl_send_rr_est_req() .... 
|
| Parameters  : UBYTE susp_req: whether RR needs to send
|                     GPRS Suspension Request or not
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_send_rr_est_req ( UBYTE susp_req)
{ 
  TRACE_FUNCTION( "ctrl_send_rr_est_req" );
  {
    PALLOC ( rrgrr_rr_est_req, RRGRR_RR_EST_REQ);
    
    if(psc_db->v_non_gprs_opt EQ TRUE)
    {
      rrgrr_rr_est_req->non_gprs.v_non_gprs = TRUE;
      
      /* Copy non GPRS options  */
      ctrl_copy_non_gprs_opt(&rrgrr_rr_est_req->non_gprs);
    }
    else
      rrgrr_rr_est_req->non_gprs.v_non_gprs = FALSE;
    
    rrgrr_rr_est_req->ch_needed             = grr_data->pg.ch_needed;
    
    rrgrr_rr_est_req->emlpp_prio.v_emlpp    = grr_data->pg.v_emlpp_prio;
    rrgrr_rr_est_req->emlpp_prio.emlpp      = grr_data->pg.emlpp_prio;

    rrgrr_rr_est_req->susp_req = susp_req;
    
    rrgrr_rr_est_req->ident_type = grr_data->pg.type; /* IMSI TMSI ??*/   

    PSEND (hCommRR, rrgrr_rr_est_req);
  }
} /* ctrl_send_rr_est_req() */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_send_rr_est_rsp
+------------------------------------------------------------------------------
| Description : The function ctrl_send_rr_est_rsp() .... 
|               Informs the RR whether the RR connection should be established or not!
| Parameters  : UBYTE susp_req: Suspension request needed or not
|                    UBYTE rsp: CS_PAGE was accepted or not
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_send_rr_est_rsp ( UBYTE susp_req, UBYTE rsp )
{ 
  TRACE_FUNCTION( "ctrl_send_rr_est_rsp" );
  {
    PALLOC(rrgrr_rr_est_rsp, RRGRR_RR_EST_RSP);
    
    rrgrr_rr_est_rsp->rr_est = (rsp EQ GMMRR_CS_PAGE_REJ) ? RR_EST_NOT_ALLOWED : RR_EST_ALLOWED;

    rrgrr_rr_est_rsp->susp_req = susp_req;
        
    PSEND(hCommRR, rrgrr_rr_est_rsp);
  }
}/* ctrl_send_rr_est_rsp*/

/*
+------------------------------------------------------------------------------
| Function    : ctrl_suspend_services
+------------------------------------------------------------------------------
| Description : The function ctrl_suspend_services() .... 
|               This function suspends working services in GRR
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_suspend_services ( UBYTE susp_cause )
{ 
  TRACE_FUNCTION( "ctrl_suspend_services" );
  
  if(susp_cause EQ GMMRR_ABNORMAL_RELEASE)
    ctrl_stop_all_activities( CTRL_DC_SUSPEND_IMM_REL, NULL );
  else
    ctrl_stop_all_activities( CTRL_DC_SUSPEND_NORMAL, NULL );
  
}/* ctrl_suspend_services*/

/*
+------------------------------------------------------------------------------
| Function    : ctrl_suspend_services
+------------------------------------------------------------------------------
| Description : The function ctrl_copy_non_gprs_opt() .... 
|               Copies the stored non-GPRS options into the given structure
| Parameters  : p_non_gprs_opt: Pointer to the structure for non-GPRS access; derived from 
|                   RRGRR.doc
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_copy_non_gprs_opt( T_non_gprs *p_non_gprs_opt)
{ 

    TRACE_FUNCTION( "ctrl_copy_non_gprs_opt" );

    /* Copy non GPRS options  */
    p_non_gprs_opt->att                   = psc_db->non_gprs_opt.att;            /*<  0> Attach / detach allowed        */ 
    
    p_non_gprs_opt->v_T3212               = psc_db->non_gprs_opt.v_t3212;        /*<  1> valid-flag                     */ 
    p_non_gprs_opt->T3212                 = psc_db->non_gprs_opt.t3212;          /*<  2> T 3212 time-out value          */ 
    
    p_non_gprs_opt->neci                  = psc_db->non_gprs_opt.neci;           /*<  3> Half rate support              */ 
    p_non_gprs_opt->pwrc                  = psc_db->non_gprs_opt.pwcr;           /*<  4> Power Control                  */ 
    p_non_gprs_opt->dtx                   = psc_db->non_gprs_opt.dtx;            /*<  5> Discontinuous Transmission (BCCH) */ 
    p_non_gprs_opt->radio_link_timeout    = psc_db->non_gprs_opt.rl_timeout;     /*<  6> Radio Link Timeout             */ 
    p_non_gprs_opt->bs_ag_blks_res        = psc_db->non_gprs_opt.bs_ag_blks_res; /*<  7> BS_AG_BLKS_RES                 */ 
    p_non_gprs_opt->ccch_conf             = psc_db->non_gprs_opt.ccch_conf;      /*<  8> CCCF-CONF                      */ 
    p_non_gprs_opt->bs_pa_mfrms           = psc_db->non_gprs_opt.bs_pa_mfrms;    /*<  9> BS-PA-MFRMS                    */ 
    p_non_gprs_opt->max_retrans           = psc_db->non_gprs_opt.max_retrans;    /*< 10> MAX_RETRANS                    */ 
    p_non_gprs_opt->tx_integer            = psc_db->non_gprs_opt.tx_integer;     /*< 11> TX_INTEGER                     */ 
    p_non_gprs_opt->ec                    = psc_db->non_gprs_opt.ec;             /*< 12> EC                             */ 
    p_non_gprs_opt->gprs_ms_txpwr_max_cch = psc_db->non_gprs_opt.txpwr_max_cch;  /*< 13> GPRS_MS_TXPWR_MAX_CCH          */ 

#ifdef REL99
  /* copy non GPRS extension information */
  if( (psc_db->non_gprs_opt.v_non_gprs_ext_bits EQ TRUE) AND 
      (psc_db->non_gprs_opt.non_gprs_ext_bits.ext_len) )
  {
    /* copy Early classmark sending control flag from GRR database */
    p_non_gprs_opt->ecsc = 
      psc_db->non_gprs_opt.non_gprs_ext_bits.non_gprs_ext_info.ecsc;
  }
  else
  {
    p_non_gprs_opt->ecsc = ECS_ALLOWED;
  }
#endif

}/* ctrl_copy_non_gprs_opt*/


/*
+------------------------------------------------------------------------------
| Function    : ctrl_is_gprs_suspension_request_needed
+------------------------------------------------------------------------------
| Description : The function ctrl_is_gprs_suspension_request_needed() .... 
|               checks whether MS has to send GPRS Suspension Request to the network
|                 or not
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL ctrl_is_gprs_suspension_request_needed( void)
{ 
    TRACE_FUNCTION( "ctrl_is_gprs_suspension_request_needed" );

    if(
      (psc_db->cell_info_for_gmm.cell_info.net_mode NEQ GMMRR_NET_MODE_III)
      AND
      (
/* BEGIN GRR_NMO_III*/      
      (grr_data->ms.class_of_mode EQ GMMRR_CLASS_B) OR 
/* END GRR_NMO_III*/      
      (grr_data->ms.class_of_mode EQ GMMRR_CLASS_BC) OR 
      (grr_data->ms.class_of_mode EQ GMMRR_CLASS_BG)
      )
      )
    {
        /*  We have to suspend GPRS activities on the network side, because of MS 
         *  is not able to handle GPRS activities during the dedicated mode of operations
         */
      return TRUE;
    }
    return FALSE;
}/* ctrl_is_gprs_suspension_request_needed*/


/*
+------------------------------------------------------------------------------
| Function    : ctrl_get_number_of_digits
+------------------------------------------------------------------------------
| Description : The function ctrl_get_number_of_digits() .... 
|               gets the  number of valid digits in the array e.g. IMSI digits
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL UBYTE ctrl_get_number_of_digits( UBYTE *digits)
{ 
  UBYTE i = 0;

  TRACE_FUNCTION ("ctrl_get_number_of_digits");

  while (digits[i] < 0x0A AND i < 16)
    i++;

  return i;
}/* ctrl_get_number_of_digits*/

/*
+------------------------------------------------------------------------------
| Function    : ctrl_send_cell_reselection_req
+------------------------------------------------------------------------------
| Description : The function ctrl_send_cell_reselection_req() .... 
|               Prepares the cell reselection parameters for RR
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_send_cell_reselection_req ( UBYTE cr_type )
{ 
  TRACE_FUNCTION( "ctrl_send_cell_reselection_req" );

  switch( cr_type )
  {
    case( CR_NEW ):
    case( CR_NEW_NOT_SYNCED ):
    {
      ctrl_stop_rr_task_req( GLBL_PCKT_MODE_NULL, TASK_STOP_DUMMY_VALUE );

      grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_COMPLETE;

      if( grr_data->ctrl.parked_rrgrr_cr_ind EQ TRUE )
      {
        ctrl_handle_parked_rrgrr_cr_ind( GET_STATE( CTRL ) );
      }
      else
      {
        PALLOC( rrgrr_cr_req, RRGRR_CR_REQ );

        rrgrr_cr_req->cr_type = cr_type;

        if( grr_t_status( T3176 ) > 0 ) 
        {
          /*TRACE_ASSERT( posc_db NEQ NULL );*/

          rrgrr_cr_req->arfcn = grr_data->ctrl.old_arfcn;
          rrgrr_cr_req->bsic  = grr_data->ctrl.old_bsic;
        }
        else
        {
          T_NC_MVAL *nc_mval;
  
          nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx];

          rrgrr_cr_req->arfcn = nc_mval->arfcn;
          rrgrr_cr_req->bsic  = nc_mval->sync_info.bsic;
        }

        TRACE_EVENT_P3( "RRGRR_CR_REQ: %d %d %d",
                        rrgrr_cr_req->cr_type,
                        rrgrr_cr_req->arfcn,
                        rrgrr_cr_req->bsic );

        PSEND( hCommRR, rrgrr_cr_req );
      }
    }
    break;

    case( CR_COMPLETE ):
    {
      switch( grr_data->ctrl.rr_state.cr_ind_return )
      {
        case( CR_IND_RETURN_NONE ):
        {
          TRACE_EVENT( "RRGRR_CR_REQ: CR_IND_RETURN_NONE" );
        }
        break;

        case( CR_IND_RETURN_RESPONSE ):
        {
          PALLOC( cr_rsp, RRGRR_CR_RSP );

          TRACE_EVENT( "RRGRR_CR_RSP: CR_IND_RETURN_RESPONSE" );

          PSEND( hCommRR, cr_rsp );

          ctrl_stop_rr_task_req( GLBL_PCKT_MODE_NULL, TASK_STOP_DUMMY_VALUE );

          grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_COMPLETE;
        }
        break;

        case( CR_IND_RETURN_COMPLETE ):
        {
          PALLOC( rrgrr_cr_req, RRGRR_CR_REQ );

          rrgrr_cr_req->cr_type = cr_type;
          rrgrr_cr_req->arfcn = 0;
          rrgrr_cr_req->bsic  = 0;

          TRACE_EVENT_P1( "RRGRR_CR_REQ: %d", rrgrr_cr_req->cr_type );

          PSEND( hCommRR, rrgrr_cr_req );

          grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_NONE;
        }
        break;

        default:
        {
          TRACE_ASSERT
            ( grr_data->ctrl.rr_state.cr_ind_return EQ CR_IND_RETURN_NONE     OR 
              grr_data->ctrl.rr_state.cr_ind_return EQ CR_IND_RETURN_RESPONSE OR
              grr_data->ctrl.rr_state.cr_ind_return EQ CR_IND_RETURN_COMPLETE    );
        }
        break;
      }
    }
    break;

    case( CR_CS ):
    {
      ctrl_stop_rr_task_req( GLBL_PCKT_MODE_NULL, TASK_STOP_DUMMY_VALUE );
    }
    
    /*lint -fallthrough*/

    case( CR_CONT ):
    {
      PALLOC( rrgrr_cr_req, RRGRR_CR_REQ );

      rrgrr_cr_req->cr_type = cr_type;

      TRACE_EVENT_P1( "RRGRR_CR_REQ: %d", rrgrr_cr_req->cr_type );

      PSEND( hCommRR, rrgrr_cr_req );

      grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_COMPLETE;
    }
    break;

    default:
    {
      TRACE_ASSERT( cr_type EQ CR_NEW            OR
                    cr_type EQ CR_NEW_NOT_SYNCED OR
                    cr_type EQ CR_COMPLETE       OR
                    cr_type EQ CR_CONT           OR
                    cr_type EQ CR_CS                );
    }
    break;
  }
}/* ctrl_send_cell_reselection_req */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_enable_serving_cell
+------------------------------------------------------------------------------
| Description : The function ctrl_enable_serving_cell() .... 
|               
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_enable_serving_cell( UBYTE final )
{ 
  TRACE_FUNCTION( "ctrl_enable_serving_cell" );

  if( final )
  {
    ctrl_install_new_scell( );
  }

#ifdef REL99 
  /* Update SGSN release in the common library */
  cl_nwrl_set_sgsn_release(psc_db->sgsn_rel);
#endif

  ctrl_send_cell_ind();

  sig_ctrl_pg_start();                                                          

  sig_ctrl_cs_pim();

  sig_ctrl_cs_start( );

  sig_ctrl_meas_pim( );

  sig_ctrl_meas_start( );

  ctrl_tc_access_enable( sig_ctrl_tc_disable_prim_queue );

}/* ctrl_enable_serving_cell */

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

  if( ctrl_get_gprs_service( ) NEQ GPRS_SERVICE_NONE )  
  {    
    sig_ctrl_cs_install_new_scell( );    
  }  

  sig_ctrl_cs_cc_result( TRUE );

}/* ctrl_install_new_scell */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_reinstall_old_scell_req
+------------------------------------------------------------------------------
| Description : The function ctrl_reinstall_old_scell_req() .... 
|               
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_reinstall_old_scell_req( BOOL is_pcco, UBYTE cause )
{ 
  TRACE_FUNCTION( "ctrl_reinstall_old_scell_req" );

  if( grr_get_db_mode( ) EQ DB_MODE_CC_REQ )
  {
    ctrl_stop_all_activities( CTRL_DC_OTHER, NULL );
  }
   
  ctrl_send_reconnect_dcch_req( cause );

}/* ctrl_reinstall_old_scell_req */

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

  if( is_success )
  {
    ctrl_cc_rejected( );  
  }
  else
  {
    grr_set_db_ptr( DB_MODE_CC_REJ );
     
    /*
     * service PSI is still suspended, we have to stop it finally 
     */
    sig_ctrl_psi_stop( );
    /* grr_set_pbcch( FALSE ); */
  }
}/* ctrl_reinstall_old_scell_cnf */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_send_cell_ind
+------------------------------------------------------------------------------
| Description : ctrl_send_cell_ind: composes and sends a GMMRR_CELL_IND message
|
| Parameters  : void 
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_send_cell_ind()
{
  TRACE_FUNCTION( "ctrl_send_cell_ind" );
  {
    PALLOC(gmmrr_cell_ind, GMMRR_CELL_IND);
    
    grr_set_cell_info_service( );

    memcpy( &gmmrr_cell_ind->cell_info,
            &psc_db->cell_info_for_gmm.cell_info,
             sizeof( T_cell_info ) );
    
#if !defined (NTRACE)

    if( grr_data->cs.v_crp_trace EQ TRUE )
    {
      TRACE_EVENT_P9( "CELL_ENV: %x%x%x %x%x%x %x %x %x",
                      gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mcc[0],
                      gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mcc[1],
                      gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mcc[2],
                      gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mnc[0],
                      gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mnc[1],
                      gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mnc[2],
                      gmmrr_cell_ind->cell_info.cell_env.rai.lac,
                      gmmrr_cell_ind->cell_info.cell_env.rai.rac,
                      gmmrr_cell_ind->cell_info.cell_env.cid );
    }

#endif /* #if !defined (NTRACE) */
    grr_data->cell_res_status = FALSE;
    PSEND(hCommGMM, gmmrr_cell_ind);
  }
}/*ctrl_send_cell_ind */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_init_params
+------------------------------------------------------------------------------
| Description : ctrl_init_params initializes the parameters of the CTRL service
|
| Parameters  : void 
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_init_params()
{
  TRACE_FUNCTION( "ctrl_init_params" );
  
  grr_data->ctrl.imm_rel             = 0;
  grr_data->cc_running               = FALSE;
  grr_data->pcco_failure_cause       = 8;

}/* ctrl_init_params */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_copy_pbcch_des_from_ncell
+------------------------------------------------------------------------------
| Description : Copies pbcch description from the ncell description to a 
|               specific database
|
| Parameters  : void 
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_copy_pbcch_des_from_ncell( T_SC_DATABASE *db )
{
  T_NC_MVAL    *nc_mval;
  T_ncell_info *ncell_info;
  
  nc_mval    = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx];
  ncell_info =  grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic );

  TRACE_FUNCTION( "ctrl_copy_pbcch_des_from_ncell" );

  if( ncell_info NEQ NULL )
  {
    db->pbcch.pbcch_des.pb      = 0;
    db->pbcch.pbcch_des.tn      = ncell_info->cr_par.si13_pbcch.pbcch_location;

    /*
     * for broadcast and common control channels, the TSC must be equal to BCC
     */
    db->pbcch.pbcch_des.tsc     = ncell_info->bsic & BCC_OF_BSIC;

    /*
     * to indicate that the arfcn of the BCCH carrier should be used
     */
    db->pbcch.pbcch_des.flag    = 0;
    db->pbcch.pbcch_des.v_flag2 = 0;
    db->pbcch.pbcch_des.flag2   = 0;

    db->pbcch.bcch.arfcn         = ncell_info->arfcn;
    db->pbcch.bcch.bsic          = ncell_info->bsic;
    db->pbcch.bcch.pbcch_present = TRUE;

    db->pccch.bs_pbcch_blks     = 0;

    db->psi1_params.psi1_repeat_period 
                                = ncell_info->cr_par.si13_pbcch.psi1_repeat_period;
  }
  else
  {
    TRACE_ERROR( "ctrl_copy_pbcch_des_from_ncell: ncell_info EQ NULL" );
  }
}/*ctrl_copy_pbcch_des_from_ncell*/


/*
+------------------------------------------------------------------------------
| Function    : ctrl_sync_to_given_cell()
+------------------------------------------------------------------------------
| Description : This function starts synchronisation to the given cell 
|               neighbour cell
|
| Parameters  : void 
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_sync_to_given_cell ( void )
{
  T_NC_MVAL    *nc_mval;
  T_ncell_info *ncell_info;
  
  TRACE_FUNCTION( "ctrl_sync_to_given_cell" );

  nc_mval    = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx];
  ncell_info =  grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic );

  if( ncell_info NEQ NULL )
  {
    ctrl_stop_rr_task_req( GLBL_PCKT_MODE_SYNC, TASK_STOP_DUMMY_VALUE );

    grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_COMPLETE;

    if( grr_data->ctrl.parked_rrgrr_cr_ind EQ TRUE )
    {
      ctrl_handle_parked_rrgrr_cr_ind( GET_STATE( CTRL ) );
    }
    else
    {
      PALLOC( rrgrr_sync_req, RRGRR_SYNC_REQ );

      rrgrr_sync_req->arfcn = ncell_info->arfcn;
      rrgrr_sync_req->bsic  = ncell_info->bsic;

      PSEND( hCommRR, rrgrr_sync_req );
    }

  }
  else
  {
    TRACE_ERROR( "ctrl_sync_to_given_cell: ncell_info EQ NULL" );
  }
} /* ctrl_sync_to_given_cell */



/*
+------------------------------------------------------------------------------
| Function    : ctrl_stop_T3174 
+------------------------------------------------------------------------------
| Description : The function stops T3174 when running.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_stop_T3174 ( void )
{
  TRACE_FUNCTION( "ctrl_stop_T3174" );

  TRACE_EVENT( "T3174 for packet cell change stopped" );

  vsi_t_stop( GRR_handle, T3174 );

} /* ctrl_stop_T3174  */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_send_access_disable_if_needed()
+------------------------------------------------------------------------------
| Description : The function sends access disabled signal to TC, if needed
|
| Parameters  : dc - disable cause
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_send_access_disable_if_needed 
                                   ( T_TC_DISABLE_CAUSE         disable_cause,
                                     T_TC_DISABLE_CALLBACK_FUNC callback_func )
{
  TRACE_FUNCTION( "ctrl_send_access_disable_if_needed" );
  
  psc_db->is_access_enabled = FALSE;

  sig_ctrl_tc_access_disable( disable_cause, callback_func );

} /* ctrl_send_access_disable_if_needed() */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_copy_cell_env()
+------------------------------------------------------------------------------
| Description : 
| Parameters  : 
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_copy_cell_env( T_cell_env          *cell_env,
                                T_serving_cell_info *scell_info )
{
  TRACE_FUNCTION( "ctrl_copy_cell_env" );

  psc_db->pbcch.bcch.arfcn                 = scell_info->bcch_arfcn;
  psc_db->pbcch.bcch.bsic                  = scell_info->bcch_bsic;

  cell_env->rai.plmn = scell_info->rr_cell_env.plmn;
  cell_env->rai.lac  = scell_info->rr_cell_env.lac;
  cell_env->cid      = scell_info->rr_cell_env.cid;

#ifdef _SIMULATION_

  TRACE_EVENT_P2( "ctrl_copy_cell_env - SCELL: %d %d",
                  psc_db->pbcch.bcch.arfcn, psc_db->pbcch.bcch.bsic );

#endif /* #ifdef _SIMULATION_ */

} /* ctrl_copy_cell_env */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_copy_scell_params()
+------------------------------------------------------------------------------
| Description : This function copies some serving cell specific parameters into 
|               database of GRR
|
| Parameters  : sc_inf: pointer to serving cell information
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL ctrl_copy_scell_params( T_serving_cell_info *sc_inf )
{
  BOOL ba_bcch_changed = FALSE;

  TRACE_FUNCTION("ctrl_copy_scell_params");

  psc_db->scell_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch 
                                           = sc_inf->gprs_ms_txpwr_max_cch;
  psc_db->prach.ac_class                   = sc_inf->ac_class;
  
  ctrl_copy_cell_env( &psc_db->cell_info_for_gmm.cell_info.cell_env, sc_inf );

  grr_data->meas.pwr_offset                = sc_inf->pwr_offset;
  psc_db->net_ctrl.bs_pa_mfrms             = sc_inf->bs_pa_mfrms;

  if(sc_inf->arfcn[0] EQ RRGRR_INVALID_ARFCN) 
  {
    TRACE_EVENT("No BA list sent with SI13 info");
    return ba_bcch_changed;
  }
#if defined (REL99) AND defined (TI_PS_FF_EMR)
/* Copy ba_ind of the NC list */
  if(sc_inf->ba_ind NEQ psc_db->ba_ind)
  {
    grr_init_ba_bcch_nc_list(psc_db);
    psc_db->ba_ind = sc_inf->ba_ind;
  }
#endif

  if( grr_t_status( T3176 ) > 0 ) 
  {
    TRACE_EVENT
      ( "ctrl_copy_scell_params: packet cell change order - do not delete psc_db->nc_cw.list.number" );
  }
  else
  {
    UBYTE i = 0; /* used for counting */

    while( i                  <   RRGRR_BA_LIST_SIZE  AND
           i                  <   MAX_NR_OF_NCELL     AND
           sc_inf->arfcn[i]   NEQ RRGRR_INVALID_ARFCN     )
    {
      if( psc_db->nc_cw.list.info[i].index NEQ i                  OR
          psc_db->nc_cw.list.info[i].arfcn NEQ sc_inf->arfcn[i]   OR 
          psc_db->nc_cw.list.info[i].bsic  NEQ RRGRR_INVALID_BSIC    )
      {
        psc_db->nc_cw.list.info[i].index = i;
        psc_db->nc_cw.list.info[i].arfcn = sc_inf->arfcn[i];
        psc_db->nc_cw.list.info[i].bsic  = RRGRR_INVALID_BSIC;

        NC_SET_TYPE    ( psc_db->nc_cw.list.info[i].info_src, INFO_TYPE_BA_BCCH );
        NC_SET_INSTANCE( psc_db->nc_cw.list.info[i].info_src, 0                 );
        NC_SET_NUMBER  ( psc_db->nc_cw.list.info[i].info_src, 0                 );

        ba_bcch_changed = TRUE;
      }

      i++;
    }
    
    if( psc_db->nc_cw.list.number NEQ i )
    {
      psc_db->nc_cw.list.number = i;
      ba_bcch_changed           = TRUE;
    }
  }

  grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param = TRUE;
  grr_data->pwr_ctrl_valid_flags.v_freq_param          = TRUE;
  
  return( ba_bcch_changed );

}/* ctrl_copy_scell_params */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_cell_change_order
+------------------------------------------------------------------------------
| Description : Start processing packet cell change order or cell change order 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_cell_change_order ( T_CTRL_CCO_TYPE type, void *data )
{
  T_NC_MVAL *nc_mval;

  TRACE_FUNCTION("ctrl_cell_change_order");
  TRACE_EVENT("ctrl_cell_change_order_started");/*to show the trace on target*/

  switch( type )
  {
    case( CCO_TYPE_RR ):
      {
        T_D_CHANGE_ORDER *d_change_order = (T_D_CHANGE_ORDER *)data;

        SET_STATE(CTRL,CTRL_RR_NC_CCO); /* set network commanded cell change order */

        ctrl_stop_all_activities( CTRL_DC_CR_NW_RR, d_change_order );

        grr_init_db( pcr_db );

        /* process BCCH ARFCN and BSIC */
        pcr_db->pbcch.bcch.arfcn =
                       ((USHORT)d_change_order->cell_desc.bcch_arfcn_hi << 8) +
                        (USHORT)d_change_order->cell_desc.bcch_arfcn_lo;
        pcr_db->pbcch.bcch.bsic  =
                               (d_change_order->cell_desc.ncc << 3) +
                                d_change_order->cell_desc.bcc;  

        /* process state variable */
        grr_data->cc_running = TRUE;

        vsi_t_start(GRR_handle,T3134,T3134_VALUE);
      }
      break;
  
    case( CCO_TYPE_GRR ):
      {
        T_D_CELL_CHAN_ORDER *d_cell_chan_order = ( T_D_CELL_CHAN_ORDER *)data;

        grr_data->ctrl.pcc_arfcn = d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.arfcn;
        grr_data->ctrl.pcc_bsic  = d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.bsic;;
        grr_data->ctrl.old_arfcn = psc_db->pbcch.bcch.arfcn;
        grr_data->ctrl.old_bsic = psc_db->pbcch.bcch.bsic ;

        TRACE_EVENT_P2("ctrl_cell_change_order:commanded cell is arfcn:%d ,bsic:%d",
          d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.arfcn, 
          d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.bsic);

        if( grr_data->cs.gmm_state EQ STANDBY_STATE )
        {
          TRACE_EVENT("ctrl_cell_change_order:GMM in STANDBY state");
          grr_data->pcco_failure_cause = 5;/*MS in GMM standby mode*/
          ctrl_build_pcco_failure_msg(grr_data->ctrl.pcc_arfcn, grr_data->ctrl.pcc_bsic);
  
        }
        else
        if (ctrl_check_cco_freq(grr_data->ctrl.pcc_arfcn))
        {
          SET_STATE( CTRL, CTRL_GRR_NC_CCO );
          ctrl_start_T3174( );
          sig_ctrl_cs_check_cell_location
              ( d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.arfcn,
                d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.bsic);
        
          nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx];

          /* ncell_info = grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic ); */

          grr_data->ctrl.imm_rel   = d_cell_chan_order->tgt_cell_gsm_info.im_rel_c0;
       
          ctrl_stop_all_activities( CTRL_DC_CR_NW_GRR, d_cell_chan_order );

          grr_init_db( pcr_db );
       
          pcr_db->pbcch.bcch.arfcn = nc_mval->arfcn;
          pcr_db->pbcch.bcch.bsic  = nc_mval->sync_info.bsic;
        }
        else
        {
          TRACE_EVENT("ctrl_cell_change_order:frequency not implemented");
          grr_data->pcco_failure_cause = 0;/*Freq_Not_Impl*/
          ctrl_build_pcco_failure_msg(grr_data->ctrl.pcc_arfcn, grr_data->ctrl.pcc_bsic);
        }
      }  
      break;
  }
}/* ctrl_cell_change_order */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_send_reconnect_dcch_req
+------------------------------------------------------------------------------
| Description : This is only to be sent when cell change failure occures
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_send_reconnect_dcch_req ( UBYTE cause )
{
  TRACE_FUNCTION( "ctrl_send_reconnect_dcch_req" );

  {
    PALLOC( rrgrr_reconnect_dcch_req, RRGRR_RECONNECT_DCCH_REQ );

    rrgrr_reconnect_dcch_req->reconn_cause = cause;

    PSEND( hCommRR, rrgrr_reconnect_dcch_req );
  }
}/* ctrl_send_reconnect_dcch_req */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_si13_received
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_si13_received( T_RRGRR_GPRS_SI13_IND * rrgrr_si13_ind )
{
  BOOL ba_bcch_changed;
  
  TRACE_FUNCTION( "ctrl_si13_received" );

  ctrl_set_gprs_service( rrgrr_si13_ind->cause,
                         rrgrr_si13_ind->serving_cell_info.limited );

  ba_bcch_changed = ctrl_copy_scell_params( &rrgrr_si13_ind->serving_cell_info );

  if( rrgrr_si13_ind->cause EQ GPRS_SUPPORTED )
  {
    sig_ctrl_psi_si13_received( rrgrr_si13_ind, ba_bcch_changed );
  }

  grr_cgrlc_pwr_ctrl_req( FALSE );

}/* ctrl_si13_received */

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

  grr_set_db_ptr( DB_MODE_CC_REJ );
  
  if( grr_data->ctrl.parked_rrgrr_cr_ind EQ TRUE )
  {
    sig_ctrl_cs_cc_result( TRUE );
  }
  else
  {
    sig_ctrl_cs_cc_result( FALSE );
  }
}/* ctrl_cc_rejected */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_failure_processing
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : 
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_failure_processing ( T_FAILURE_SIGNAL fail_sig )
{
  UBYTE state = GET_STATE( CTRL );

  TRACE_FUNCTION( "ctrl_failure_processing" );

  TRACE_EVENT_P1( "ctrl_failure_processing: failure signal %d", fail_sig );

  switch( state )
  {
    case CTRL_READY_TO_PROGRESS:
      if (grr_data->db.old_scell.pbcch_present EQ TRUE)
      {
        grr_set_db_ptr( DB_MODE_CC_REJ );
        sig_ctrl_cs_reselect( CS_RESELECT_CAUSE_CTRL_NORMAL );
      }
      else
      {
        /* The old cell is without PBBCH */
        ctrl_send_cell_reselection_req( CR_CONT );
      }
      break;

    case CTRL_READY:
    case CTRL_ACCESS_DISABLED:
    case CTRL_IN_PROGRESS:   
      if (fail_sig EQ FAIL_SIG_DSF_IND)
      {
        sig_ctrl_cs_reselect( CS_RESELECT_CAUSE_CTRL_DL_SIG_FAIL );
      }
      else
      {
      sig_ctrl_cs_reselect( CS_RESELECT_CAUSE_CTRL_NORMAL );
      }
      break;

    case CTRL_RR_CR_IN_SUSP:
    case CTRL_AUTO_RR_CR:
      ctrl_send_cell_reselection_req( CR_CONT );
      break;

    case CTRL_CR:
    case CTRL_CR_IN_SUSP:
      SET_STATE_FAILED_CR( state );

      ctrl_cc_rejected( );
      break;

    case CTRL_RR_NC_CCO:
      SET_STATE( CTRL, CTRL_IN_PROGRESS );

      ctrl_reinstall_old_scell_req( FALSE, RECONN_NO_ACTIVITY );
      break;
    case CTRL_GRR_NC_CCO:
      if ( grr_t_status(T3174) > 0) 
      { 
        ctrl_stop_T3174();
      }
      ctrl_pcco_failure( );
      break;

    default:
      TRACE_ERROR( "ctrl_failure_processing: failure signal unexpected" );
      break;
  }
} /* ctrl_failure_processing */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_pcco_failure
+------------------------------------------------------------------------------
| Description : Handles the internal signal ctrl_pcco_failure
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/

GLOBAL void ctrl_pcco_failure(void)
{
  TRACE_ISIG( "ctrl_pcco_failure" );

  vsi_t_start( GRR_handle, T3176, T3176_VALUE );

  TRACE_EVENT( "ctrl_pcco_failure:T3176 started." );
    
  ctrl_stop_all_activities( CTRL_DC_CR_NW_GRR, NULL );

} /* ctrl_pcoo_failure */


/*
+------------------------------------------------------------------------------
| Function    : ctrl_build_pcco_failure_msg
+------------------------------------------------------------------------------
| Description : The function is to send packet cell change failure message
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_build_pcco_failure_msg(USHORT arfcn, UBYTE bsic)
{
  TRACE_FUNCTION( "ctrl_build_pcco_failure_msg" );
  TRACE_EVENT("ctrl_build_pcco_failure_msg");
  {         
     T_U_CELL_CHAN_FAILURE u_cell_chan_failure;

     u_cell_chan_failure.msg_type = U_CELL_CHAN_FAILURE_c;

     grr_set_buf_tlli( &u_cell_chan_failure.tlli_value, grr_get_tlli( ) );

     u_cell_chan_failure.arfcn         = arfcn;
     u_cell_chan_failure.bsic          = bsic;
     u_cell_chan_failure.failure_cause = grr_data->pcco_failure_cause;

     TRACE_EVENT_P2("ctrl_build_pcco_failure_msg: pcc_arfcn = %1d,pcc_bsic = %1d", arfcn,bsic);

     ctrl_send_control_block( CGRLC_BLK_OWNER_CTRL, (void*)(&u_cell_chan_failure) );
  }
} /*ctrl_build_pcco_failure_msg */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_send_control_block
+------------------------------------------------------------------------------
| Description : This function is used to signal service TC the request for
|               sending a control block.
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_send_control_block ( T_BLK_OWNER   blk_owner, 
                                      void        * blk_struct )
{

  TRACE_FUNCTION( "ctrl_send_control_block" );
  TRACE_EVENT( "ctrl_send_control_block" );

  switch( blk_owner )
  {
    case( CGRLC_BLK_OWNER_MEAS ):
    case( CGRLC_BLK_OWNER_CS   ):
      /*
       * If the timers related to measurement reporting expire while the
       * reselection procedure has not yet been completed, these timers
       * shall be restarted so that the mobile station resumes measurement
       * reporting procedures once camped on the new cell 
       */
      if( grr_t_status( T3174 ) > 0 OR grr_t_status( T3176 ) > 0 )
      {
        ctrl_send_control_block_result( blk_owner, FALSE );

        TRACE_ERROR( "ctrl_send_control_block: measurement reporting not allowed" );
      }
      else
      {
        sig_ctrl_tc_control_block( blk_owner, blk_struct );
      }
      break;

    default:
      sig_ctrl_tc_control_block( blk_owner, blk_struct );
      break;
  }
} /* ctrl_send_control_block */

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

  sig_ctrl_tc_cancel_control_block( blk_owner );

} /* ctrl_cancel_control_block */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_send_control_block_result
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_send_control_block_result ( T_BLK_OWNER blk_owner,
                                             BOOL        is_success )
{
  TRACE_FUNCTION( "ctrl_send_control_block_result" );

  switch( blk_owner )
  {
    case( CGRLC_BLK_OWNER_MEAS ):
      if( is_success ) sig_ctrl_meas_pmr_accept( );
      else             sig_ctrl_meas_pmr_reject( );
      break;

    case( CGRLC_BLK_OWNER_CS ):
      if( is_success ) sig_ctrl_cs_pmr_accept( );
      else             sig_ctrl_cs_pmr_reject( );
      break;

    case( CGRLC_BLK_OWNER_CTRL ):
      vsi_t_stop( GRR_handle, T3176 );
      TRACE_EVENT("ctrl_send_control_block_result:T3176 stopped");
      break;

    default:
      TRACE_ERROR( "ctrl_send_control_block_result: blk_owner out of range" );
      break;
  }
} /* ctrl_send_control_block_result */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_resp_resume
+------------------------------------------------------------------------------
| Description : The function ctrl_resp_resume() .... 
|               
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_resp_resume( void )
{
  psc_db->is_access_enabled = TRUE;

  ctrl_send_cell_ind();
  
  sig_ctrl_pg_start();

  sig_ctrl_psi_resumpt();

  sig_ctrl_cs_pim( );

  sig_ctrl_cs_start( );

  sig_ctrl_meas_pim( );

  sig_ctrl_meas_resume( );

  ctrl_tc_access_enable( sig_ctrl_tc_disable_prim_queue );

}/* ctrl_resp_resume */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_handle_new_candidate
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_handle_new_candidate( BOOL initial )
{
  UBYTE         state;
  T_NC_MVAL    *nc_mval;
  T_ncell_info *ncell_info;

  TRACE_FUNCTION( "ctrl_handle_new_candidate" );

  grr_init_db( pcr_db );

  state = GET_STATE( CTRL );
    
  switch( state )
  {
    case CTRL_CR:
    case CTRL_FAILED_CR:
    case CTRL_GRR_NC_CCO:
      SET_STATE( CTRL, CTRL_CR );
      break;

    case CTRL_CR_IN_SUSP:
    case CTRL_FAILED_CR_IN_SUSP:
      SET_STATE( CTRL, CTRL_CR_IN_SUSP );
      break;

    default:
      TRACE_EVENT_P1( "ctrl_handle_new_candidate: unexpected state %d", state );
      break;
  }

  nc_mval    = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx];
  ncell_info =  grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic );

  /* 
   * Store ARFCN and BSIC of the cell re-selection candidate,
   * these parameters should be used to avoid considering RRGRR_SI13_IND
   * and RRGRR_GPRS_IND primitives which maybe present in the data queue
   * of GRR but belong to the old serving cell.
   */
  pcr_db->pbcch.bcch.arfcn = nc_mval->arfcn;
  pcr_db->pbcch.bcch.bsic  = nc_mval->sync_info.bsic;

  if( ncell_info NEQ NULL )
  {

#ifdef _SIMULATION_

    if(  ncell_info->cr_par.v_si13_pbcch               AND
        !ncell_info->cr_par.si13_pbcch.v_si13_location     )
    {
      /*
       * Copy pbcch description from the ncell description to pcr_db
       */
      ctrl_copy_pbcch_des_from_ncell( pcr_db );

      /* 
       * We have to synchronize to the new cell to be able 
       * to read full PSI in the new cell 
       */
      ctrl_start_cell_reselection( CTRL_CR_TYPE_NEW_PBCCH_INFO, initial );
    }
    else

#endif /* #ifdef _SIMULATION_ */

    {
      ctrl_start_cell_reselection( CTRL_CR_TYPE_NEW, initial );
    }
  }
  else
  {
    ctrl_start_cell_reselection( CTRL_CR_TYPE_NEW, initial );
  }
} /* ctrl_handle_new_candidate */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_handle_no_more_candidate
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_handle_no_more_candidate( T_CTRL_CR_TYPE ctrl_cr_type,
                                           BOOL           initial )
{
  TRACE_FUNCTION( "ctrl_handle_no_more_candidate" );

  SET_STATE( CTRL, CTRL_READY );

  /* grr_set_db_ptr( DB_MODE_INIT ); */
  ctrl_start_cell_reselection( ctrl_cr_type, initial );

} /* ctrl_handle_no_more_candidate */

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

  if( state EQ TASK_STATE_PTM OR grr_is_pbcch_present( ) )
  {
    PALLOC( rrgrr_start_task_req, RRGRR_START_TASK_REQ );

    rrgrr_start_task_req->state = state;

    PSEND( hCommRR, rrgrr_start_task_req );
  }
} /* ctrl_start_rr_task */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_stop_rr_task_req
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_stop_rr_task_req
                              ( T_GLBL_PCKT_MODE final_pckt_mode, UBYTE param )
{
  BOOL        pbcch_present = grr_is_pbcch_present( );
  BOOL        change_pckt_mode;
  UBYTE       curr_pckt_mode;
  T_CTRL_TASK ctrl_task;

  TRACE_FUNCTION( "ctrl_stop_rr_task_req" );

  change_pckt_mode = ctrl_set_transient_pckt_mode( final_pckt_mode, &ctrl_task );
  curr_pckt_mode   = GET_STATE( CTRL_GLBL );

  if( change_pckt_mode )
  {
    if(   curr_pckt_mode EQ GLBL_PCKT_MODE_IDLE_ASSIGNED         OR
          curr_pckt_mode EQ GLBL_PCKT_MODE_IDLE_ACCESS           OR 
        ( curr_pckt_mode EQ GLBL_PCKT_MODE_TRANSFER_ACCESS AND 
          !pbcch_present                                       ) OR
          curr_pckt_mode EQ GLBL_PCKT_MODE_RELEASED_ACCESS          )
    {
      ctrl_leave_to_pam( );
    }

    if( ctrl_task     EQ CTRL_TASK_PBCCH_LEAVE_NULL AND 
        pbcch_present EQ TRUE                           )
    {
      grr_data->ctrl_glbl.ctrl_task = ctrl_task;

      sig_ctrl_psi_rel_state( REL_PERFORMED );
      ctrl_stop_rr_task_cnf( TRUE );
    }
    else if( ctrl_task EQ CTRL_TASK_PBCCH_LEAVE_SUSP )
    {
      grr_data->ctrl_glbl.ctrl_task = ctrl_task;

      ctrl_stop_rr_task_cnf( TRUE );
    }
    else if( pbcch_present )
    {
      if( ctrl_task NEQ CTRL_TASK_NONE             AND 
          ctrl_task NEQ CTRL_TASK_PBCCH_LEAVE_SYNC     )
      {
        ctrl_send_rrgrr_stop_task_req( ctrl_task, param );
      }
      else
      {
        ctrl_stop_rr_task_cnf( change_pckt_mode );
      }
    }
    else
    {
      ctrl_stop_rr_task_cnf( change_pckt_mode );
    }
  }
  else
  {
    if     ( curr_pckt_mode EQ GLBL_PCKT_MODE_ACCESS )
    {
      ctrl_enter_pam( );
    }
    else if( curr_pckt_mode EQ GLBL_PCKT_MODE_ACCESS_TWO_PHASE )
    {
      sig_ctrl_pg_mode_ind( PACKET_MODE_2P_PTM );
    }
    else if( curr_pckt_mode EQ GLBL_PCKT_MODE_MEAS_REP_IDLE )
    {
      sig_ctrl_pg_mode_ind( PACKET_MODE_PIM );
    }
    else if( curr_pckt_mode EQ GLBL_PCKT_MODE_SUSP )
    {
      ctrl_start_rr_task( TASK_STATE_PIM );
    }

    ctrl_stop_rr_task_cnf( change_pckt_mode );
  }
} /* ctrl_stop_rr_task_req */

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

  ctrl_set_final_pckt_mode( );

  if( change_pckt_mode )
  {
    T_GLBL_PCKT_MODE pckt_mode = GET_STATE( CTRL_GLBL );

    if( pckt_mode EQ GLBL_PCKT_MODE_IDLE )
    {
      if     ( grr_data->ctrl_glbl.ctrl_task EQ  CTRL_TASK_PBCCH_LEAVE_SUSP )
      {
        ctrl_resp_resume( );
      }
      else if( grr_data->ctrl_glbl.ctrl_task EQ  CTRL_TASK_PBCCH_LEAVE_SYNC )
      {
        /* 
         * just set the correct state,
         * detailed processing will be performed by the calling function
         */
      }
      else if( grr_data->ctrl_glbl.ctrl_task NEQ CTRL_TASK_PBCCH_LEAVE_NULL )
      {
        ctrl_enter_pim( );
        ctrl_start_rr_task( TASK_STATE_PIM );
      }
    } 
    else if( pckt_mode EQ GLBL_PCKT_MODE_ACCESS )
    {
      ctrl_enter_pam( );
 
      if( grr_data->tc.last_eval_assign.tbf_type EQ CGRLC_TBF_MODE_NULL )
      {
        ctrl_start_rr_task( TASK_STATE_PAM );
      }
      else
      {
        TRACE_EVENT( "No task start for PAM, DL assignment received" );
      }
    }
    else if( pckt_mode EQ GLBL_PCKT_MODE_ASSIGNED )
    {
      if( grr_data->tc.last_eval_assign.ccch_read EQ DONT_STOP_CCCH )
      {
        sig_ctrl_pg_mode_ind( PACKET_MODE_PAM );
      }

      sig_ctrl_tc_leave_to_ptm( );
    }
    else if( pckt_mode EQ GLBL_PCKT_MODE_TRANSFER )
    {
      ctrl_enter_ptm( );
      ctrl_start_rr_task( TASK_STATE_PTM );
    }
    else if( pckt_mode EQ GLBL_PCKT_MODE_RELEASED )
    {
      sig_ctrl_tc_leave_to_pim( );
    }
  }

  grr_data->ctrl_glbl.ctrl_task = CTRL_TASK_NONE;
} /* ctrl_stop_rr_task_cnf */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_send_rrgrr_stop_task_req
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_send_rrgrr_stop_task_req ( T_CTRL_TASK ctrl_task, UBYTE param )
{
  PALLOC( rrgrr_stop_task_req, RRGRR_STOP_TASK_REQ );

  TRACE_FUNCTION( "ctrl_send_rrgrr_stop_task_req" );

  switch( ctrl_task )
  {
    case CTRL_TASK_PBCCH_LEAVE_IDLE:
      rrgrr_stop_task_req->ctrl_task        = LEAVE_PIM_PBCCH;
      rrgrr_stop_task_req->task.v_pim_pbcch = param;
      break;

    case CTRL_TASK_PBCCH_LEAVE_ACCESS:
      rrgrr_stop_task_req->ctrl_task        = LEAVE_PAM_PBCCH;
      rrgrr_stop_task_req->task.v_pam_pbcch = param;
      break;

    case CTRL_TASK_PBCCH_LEAVE_TRANSFER:
      rrgrr_stop_task_req->ctrl_task        = LEAVE_PTM_PBCCH;
      rrgrr_stop_task_req->task.v_ptm_pbcch = param;
      break;

    case CTRL_TASK_BCCH:
      rrgrr_stop_task_req->ctrl_task        = RR_TASK_1;
      rrgrr_stop_task_req->task.v_stop_ccch = param;
      break;

    default:
      PFREE( rrgrr_stop_task_req );

      TRACE_ERROR( "ctrl_send_rrgrr_stop_task_req: invalid control task" );
      TRACE_EVENT_P1( "FATAL ERROR: ctrl_send_rrgrr_stop_task_req: %d", 
                      ctrl_task );
      return;
  }

  /*
   *   Issue #22667, Patch FDS 28-04-04 - Fix for TIL 06 in spain
   *   Don't change the ctrl state if RR doesn't respond to the stop_task_req
   */
  
  if ( (ctrl_task NEQ CTRL_TASK_BCCH) OR (param NEQ INVALID_MSG) )
    grr_data->ctrl_glbl.ctrl_task = ctrl_task;

#ifdef _SIMULATION_

  TRACE_EVENT_P1( "ctrl_send_rrgrr_stop_task_req - ctrl_task: %d",
                  grr_data->ctrl_glbl.ctrl_task );

#endif /* #ifdef _SIMULATION_ */

  PSEND( hCommRR, rrgrr_stop_task_req );

} /* ctrl_send_rrgrr_stop_task_req */


/*
+------------------------------------------------------------------------------
| Function    : ctrl_set_final_pckt_mode
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
LOCAL void ctrl_set_final_pckt_mode ( void )
{
  UBYTE pckt_mode = GET_STATE( CTRL_GLBL );

  TRACE_FUNCTION( "ctrl_set_final_pckt_mode" );

  switch( pckt_mode )
  {
    case( GLBL_PCKT_MODE_NULL_IDLE     ):
    case( GLBL_PCKT_MODE_SUSP_IDLE     ):
    case( GLBL_PCKT_MODE_SYNC_IDLE     ):
    case( GLBL_PCKT_MODE_ACCESS_IDLE   ):
    case( GLBL_PCKT_MODE_ASSIGNED_IDLE ):
    case( GLBL_PCKT_MODE_TRANSFER_IDLE ):
    case( GLBL_PCKT_MODE_RELEASED_IDLE ):
      SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE );
      break;

    case( GLBL_PCKT_MODE_IDLE_ACCESS      ):
    case( GLBL_PCKT_MODE_TRANSFER_ACCESS  ):
    case( GLBL_PCKT_MODE_RELEASED_ACCESS  ):
    case( GLBL_PCKT_MODE_ACCESS_TWO_PHASE ):
    case( GLBL_PCKT_MODE_MEAS_REP_IDLE ):
      SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS );
      break;

    case( GLBL_PCKT_MODE_IDLE_ASSIGNED ):
    case( GLBL_PCKT_MODE_ACCESS_ASSIGNED ):
      SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ASSIGNED );
      break;

    case( GLBL_PCKT_MODE_IDLE_TRANSFER     ):
    case( GLBL_PCKT_MODE_ASSIGNED_TRANSFER ):
    case( GLBL_PCKT_MODE_ACCESS_TRANSFER   ):
      SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER );
      break;

    case( GLBL_PCKT_MODE_TRANSFER_RELEASED ):
      SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_RELEASED );
      break;

    case( GLBL_PCKT_MODE_NULL     ):
    case( GLBL_PCKT_MODE_SUSP     ):
    case( GLBL_PCKT_MODE_SYNC     ):
    case( GLBL_PCKT_MODE_IDLE     ):
    case( GLBL_PCKT_MODE_ACCESS   ):
    case( GLBL_PCKT_MODE_ASSIGNED ):
    case( GLBL_PCKT_MODE_TRANSFER ):
    case( GLBL_PCKT_MODE_RELEASED ):
      /* do nothing */
      break;

    default: 
      TRACE_ERROR( "ctrl_set_final_pckt_mode: invalid transition packet mode" );
      TRACE_EVENT_P1( "FATAL ERROR: ctrl_set_final_pckt_mode: %d", pckt_mode );
      break;
  }
} /* ctrl_set_final_pckt_mode */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_set_transient_pckt_mode
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL ctrl_set_transient_pckt_mode 
                   ( T_GLBL_PCKT_MODE final_pckt_mode, T_CTRL_TASK *ctrl_task )
{
  BOOL  change_pckt_mode = TRUE;
  UBYTE curr_pckt_mode   = GET_STATE( CTRL_GLBL );
    
  TRACE_FUNCTION( "ctrl_set_transient_pckt_mode" );

  *ctrl_task = CTRL_TASK_NONE;

  switch( final_pckt_mode )
  {
    case( GLBL_PCKT_MODE_NULL ):      
      SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_NULL );

      change_pckt_mode = FALSE;
      break;

    case( GLBL_PCKT_MODE_SUSP ):
      SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_SUSP );
      
      change_pckt_mode = FALSE;
      break;

    case( GLBL_PCKT_MODE_SYNC ):
      SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_SYNC );

      change_pckt_mode = FALSE;
      break;

    case( GLBL_PCKT_MODE_IDLE ):
      switch( curr_pckt_mode )
      {
        case( GLBL_PCKT_MODE_NULL ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_NULL_IDLE );

          *ctrl_task = CTRL_TASK_PBCCH_LEAVE_NULL;
          break;

        case( GLBL_PCKT_MODE_SUSP ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_SUSP_IDLE );

          *ctrl_task = CTRL_TASK_PBCCH_LEAVE_SUSP;
          break;

        case( GLBL_PCKT_MODE_SYNC ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_SYNC_IDLE );

          *ctrl_task = CTRL_TASK_PBCCH_LEAVE_SYNC;
          break;

        case( GLBL_PCKT_MODE_IDLE ):
          change_pckt_mode = FALSE;
          break;

        case( GLBL_PCKT_MODE_ACCESS ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS_IDLE );
          
          *ctrl_task = CTRL_TASK_PBCCH_LEAVE_ACCESS;
          break;

        case( GLBL_PCKT_MODE_ASSIGNED ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ASSIGNED_IDLE );
          break;

        case( GLBL_PCKT_MODE_TRANSFER ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER_IDLE );
          
          *ctrl_task = CTRL_TASK_PBCCH_LEAVE_TRANSFER;
          break;

        case( GLBL_PCKT_MODE_RELEASED ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_RELEASED_IDLE );
          break;

        default: 
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE );

          change_pckt_mode = FALSE;
          
          TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d",
                          curr_pckt_mode, final_pckt_mode );
          break;
      }
      break;

    case( GLBL_PCKT_MODE_ACCESS ):
      switch( curr_pckt_mode )
      {
        case( GLBL_PCKT_MODE_IDLE ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE_ACCESS );
          
          *ctrl_task = CTRL_TASK_PBCCH_LEAVE_IDLE;
          break;

        case( GLBL_PCKT_MODE_ACCESS ):
          change_pckt_mode = FALSE;
          break;

        case( GLBL_PCKT_MODE_TRANSFER ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER_ACCESS );

          *ctrl_task = CTRL_TASK_PBCCH_LEAVE_TRANSFER;
          break;

        case( GLBL_PCKT_MODE_RELEASED ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_RELEASED_ACCESS );
          break;

        default: 
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS );

          change_pckt_mode = FALSE;

          TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d", 
                          curr_pckt_mode, final_pckt_mode );
          break;
      }
      break;

    case( GLBL_PCKT_MODE_ACCESS_TWO_PHASE ):
      switch( curr_pckt_mode )
      {
        case( GLBL_PCKT_MODE_ACCESS ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS_TWO_PHASE );
          
          change_pckt_mode = FALSE;
          break;

        default: 
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS );

          change_pckt_mode = FALSE;

          TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d",
                          curr_pckt_mode, final_pckt_mode );
          break;
      }
      break;

    case( GLBL_PCKT_MODE_MEAS_REP_IDLE ):
      switch( curr_pckt_mode )
      {
        case( GLBL_PCKT_MODE_ACCESS ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_MEAS_REP_IDLE );
          
          change_pckt_mode = FALSE;
          break;

        default: 
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS );

          change_pckt_mode = FALSE;

          TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d",
                          curr_pckt_mode, final_pckt_mode );
          break;
      }
      break;      

    case( GLBL_PCKT_MODE_ASSIGNED ):
      switch( curr_pckt_mode )
      {
        case( GLBL_PCKT_MODE_IDLE ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE_ASSIGNED );
          
          *ctrl_task = CTRL_TASK_PBCCH_LEAVE_IDLE;
          break;

        case( GLBL_PCKT_MODE_ACCESS ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS_ASSIGNED );
          
          *ctrl_task = CTRL_TASK_PBCCH_LEAVE_ACCESS;
          break;

        case( GLBL_PCKT_MODE_ASSIGNED ):
          change_pckt_mode = FALSE;
          break;

        default: 
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ASSIGNED );

          change_pckt_mode = FALSE;

          TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d",
                          curr_pckt_mode, final_pckt_mode );
          break;
      }
      break;

    case( GLBL_PCKT_MODE_TRANSFER ):
      switch( curr_pckt_mode )
      {
        case( GLBL_PCKT_MODE_IDLE ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE_TRANSFER );
          
          *ctrl_task = CTRL_TASK_PBCCH_LEAVE_IDLE;
          break;

        case( GLBL_PCKT_MODE_ACCESS ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS_TRANSFER );
          
          *ctrl_task = CTRL_TASK_PBCCH_LEAVE_ACCESS;
          break;

        case( GLBL_PCKT_MODE_ASSIGNED ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ASSIGNED_TRANSFER );
          break;

        case( GLBL_PCKT_MODE_TRANSFER ):
          change_pckt_mode = FALSE;
          break;

        default: 
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER );

          change_pckt_mode = FALSE;

          TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d",
                          curr_pckt_mode, final_pckt_mode );
          break;
      }
      break;

    case( GLBL_PCKT_MODE_RELEASED ):
      switch( curr_pckt_mode )
      {
        case( GLBL_PCKT_MODE_TRANSFER ):
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER_RELEASED );

          *ctrl_task = CTRL_TASK_PBCCH_LEAVE_TRANSFER;
          break;

        case( GLBL_PCKT_MODE_RELEASED ):
          change_pckt_mode = FALSE;
          break;

        default: 
          SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_RELEASED );

          change_pckt_mode = FALSE;

          TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d",
                          curr_pckt_mode, final_pckt_mode );
          break;
      }
      break;

    default:
      change_pckt_mode = FALSE;

      TRACE_ERROR   ( "ctrl_set_transient_pckt_mode: invalid final packet mode" );
      TRACE_EVENT_P1( "FATAL ERROR: ctrl_set_transient_pckt_mode: %d",
                      final_pckt_mode );
      break;
  }

  return( change_pckt_mode );

} /* ctrl_set_transient_pckt_mode */

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

  /*
   * Reset TA-Values
   */
  memset(&grr_data->ta_params, 0xFF, sizeof(T_TA_PARAMS));
  grr_data->ta_params.ta_valid = FALSE;

  sig_ctrl_pg_mode_ind( PACKET_MODE_PIM );
  sig_ctrl_psi_pim( );
  sig_ctrl_meas_pim( );
  sig_ctrl_cs_pim( );

} /* ctrl_enter_pim */

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

  sig_ctrl_meas_pam( );
  sig_ctrl_psi_pam( );
  sig_ctrl_cs_leave_to_pam( );

} /* ctrl_leave_to_pam */

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

  sig_ctrl_pg_mode_ind( PACKET_MODE_PAM );
  sig_ctrl_cs_enter_pam( );

  /*
   * PATCH 1 BEGIN 10.12.2002
   */

  /*
   * wait 2 ms after pccch_req, otherwise prach will not sent --> L1 BUG02724
   */
  vsi_t_sleep( VSI_CALLER 2 );

  /*
   * PATCH 1 END 10.12.2002
   */

  sig_ctrl_tc_enter_pam( );
} /* ctrl_enter_pam */

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

  sig_ctrl_psi_ptm( );
  sig_ctrl_pg_mode_ind( PACKET_MODE_PTM );
  sig_ctrl_meas_ptm( );
  sig_ctrl_cs_ptm( );
} /* ctrl_enter_ptm */

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

  ctrl_send_gmmrr_cr_ind( );

  if( service )
  {
    grr_data->db.old_scell.arfcn         = psc_db->pbcch.bcch.arfcn;
    grr_data->db.old_scell.bsic          = psc_db->pbcch.bcch.bsic;
    grr_data->db.old_scell.pbcch_present = psc_db->pbcch.bcch.pbcch_present;
  }
  else
  {
    grr_data->db.old_scell.arfcn         = RRGRR_INVALID_ARFCN;
    grr_data->db.old_scell.bsic          = RRGRR_INVALID_BSIC;
    grr_data->db.old_scell.pbcch_present = FALSE;
  }

  grr_data->ctrl.new_cell_responded     = FALSE;
  grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_RESPONSE;

#ifdef _SIMULATION_

  TRACE_EVENT_P2( "ctrl_set_old_scell - old SCELL: %d %d",
                  grr_data->db.old_scell.arfcn, grr_data->db.old_scell.bsic );

#endif /* #ifdef _SIMULATION_ */

} /* ctrl_set_old_scell( ) */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_send_gmmrr_cr_ind
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  : void
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_send_gmmrr_cr_ind ( void )
{
  PALLOC( gmmrr_cr_ind, GMMRR_CR_IND );
  PSEND( hCommGMM, gmmrr_cr_ind );

  TRACE_FUNCTION( "ctrl_send_gmmrr_cr_ind" );
} /* ctrl_send_gmmrr_cr_ind( ) */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_start_cell_reselection 
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_start_cell_reselection ( T_CTRL_CR_TYPE ctrl_cr_type,
                                          BOOL           initial )
{ 
  UBYTE cr_type = CR_CS;

  TRACE_FUNCTION( "ctrl_start_cell_reselection" );

  if( initial EQ TRUE )
  {
    ctrl_set_old_scell( TRUE );
  }

  switch( ctrl_cr_type )
  {
    case CTRL_CR_TYPE_CS            : /* nothing to do */          break;
    case CTRL_CR_TYPE_NEW           :
    case CTRL_CR_TYPE_NEW_PBCCH_INFO: cr_type = CR_NEW;            break;
    case CTRL_CR_TYPE_NEW_NOT_SYNCED: cr_type = CR_NEW_NOT_SYNCED; break;
    case CTRL_CR_TYPE_CONT          : cr_type = CR_CONT;           break;

    default: 
      TRACE_ASSERT( ctrl_cr_type EQ CTRL_CR_TYPE_CS             OR 
                    ctrl_cr_type EQ CTRL_CR_TYPE_NEW            OR
                    ctrl_cr_type EQ CTRL_CR_TYPE_NEW_PBCCH_INFO OR
                    ctrl_cr_type EQ CTRL_CR_TYPE_NEW_NOT_SYNCED OR
                    ctrl_cr_type EQ CTRL_CR_TYPE_CONT              );
      break;
  }

  if( ctrl_cr_type EQ CTRL_CR_TYPE_NEW_PBCCH_INFO )
  {
    ctrl_sync_to_given_cell( );
  }
  else
  {
    ctrl_send_cell_reselection_req( cr_type );
  }

  sig_ctrl_cs_start_cell_selection( cr_type ); 

} /* ctrl_start_cell_reselection() */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_cell_has_changed 
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL ctrl_cell_has_changed ( void )
{ 
#ifdef _SIMULATION_

  TRACE_EVENT_P5( "ctrl_cell_has_changed - %d - new SCELL: %d %d - old SCELL: %d %d",
                  grr_data->ctrl.new_cell_responded,
                  psc_db->pbcch.bcch.arfcn, 
                  psc_db->pbcch.bcch.bsic,
                  grr_data->db.old_scell.arfcn,
                  grr_data->db.old_scell.bsic );

#endif /* #ifdef _SIMULATION_ */

  return
    (   grr_data->ctrl.new_cell_responded EQ  FALSE                         AND 
      ( grr_data->db.old_scell.arfcn      NEQ psc_db->pbcch.bcch.arfcn OR
        grr_data->db.old_scell.bsic       NEQ psc_db->pbcch.bcch.bsic     )     );
} /* ctrl_cell_has_changed() */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_tc_access_enable 
+------------------------------------------------------------------------------
| Description :
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_tc_access_enable( T_TC_ACCESS_ENABLE_FUNC access_enable_func )
{ 
  grr_data->ctrl.new_cell_responded |= 
                                access_enable_func( ctrl_cell_has_changed( ) );

#ifdef _SIMULATION_

  TRACE_EVENT_P5( "ctrl_tc_access_enable - %d - new SCELL: %d %d - old SCELL: %d %d",
                  grr_data->ctrl.new_cell_responded,
                  psc_db->pbcch.bcch.arfcn, 
                  psc_db->pbcch.bcch.bsic,
                  grr_data->db.old_scell.arfcn,
                  grr_data->db.old_scell.bsic );

#endif /* #ifdef _SIMULATION_ */

} /* ctrl_tc_access_enable() */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_check_cco_freq 
+------------------------------------------------------------------------------
| Description : Check if the frequency in the Cell change order is capable of 
|               using
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL ctrl_check_cco_freq ( USHORT arfcn )
{
  BOOL result = FALSE;

  TRACE_FUNCTION( "ctrl_check_cco_freq" );
  TRACE_EVENT( "ctrl_check_cco_freq started" );/*for target trace*/

  switch( std )
    {
      case STD_900: /* frequencies must between 1 and 124 */ 

        if(( arfcn >= LOW_CHANNEL_900 ) AND ( arfcn <= HIGH_CHANNEL_900))
        {
          result = TRUE;
        }
        break;

      case STD_EGSM:

        if(( arfcn <= HIGH_CHANNEL_900) OR
           (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1)))
        {
          result = TRUE;
        }
        break;

      case STD_1900:

        if(( arfcn >= LOW_CHANNEL_1900 ) AND ( arfcn <= HIGH_CHANNEL_1900)) 
        {
          result = TRUE;
        }
        break;

      case STD_1800:

        if(( arfcn >= LOW_CHANNEL_1800 ) AND ( arfcn <= HIGH_CHANNEL_1800)) 
        {
          result = TRUE;
        }        
        break;

      case STD_850:

        if(( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) 
        {
          result = TRUE;
        }     
        break;

      case STD_DUAL:

        if ((( arfcn >= LOW_CHANNEL_900 ) AND ( arfcn <= HIGH_CHANNEL_900)) OR
          (( arfcn >= LOW_CHANNEL_1800 ) AND ( arfcn <= HIGH_CHANNEL_1800))) 
        {     
          result = TRUE;
        }
        break;

      case STD_DUAL_EGSM:
 
        if((( arfcn <= HIGH_CHANNEL_900) OR
          (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1))) 
          OR     
          (( arfcn >= LOW_CHANNEL_1800 ) AND
          ( arfcn <= HIGH_CHANNEL_1800)))
        {
           result = TRUE;
        }
        break;

      case STD_DUAL_US:
        if ((( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) OR
         (( arfcn >= LOW_CHANNEL_1900 ) AND ( arfcn <= HIGH_CHANNEL_1900)))
        {
           result = TRUE;
        }
        break;

#ifdef TI_PS_FF_QUAD_BAND_SUPPORT
      case STD_850_1800:
        if ((( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) OR
           (( arfcn >= LOW_CHANNEL_1800 ) AND ( arfcn <= HIGH_CHANNEL_1800)))
        {
           result = TRUE;
        }
        break;

      case STD_900_1900:
        if(( arfcn <= HIGH_CHANNEL_900) OR
          (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1)) OR
          (( arfcn >= LOW_CHANNEL_1900 ) AND ( arfcn <= HIGH_CHANNEL_1900)))
        {
           result = TRUE;
        }
        break;
        
      case STD_850_900_1800:
        if ((( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) OR
            ( arfcn <= HIGH_CHANNEL_900) OR
           (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1)) OR
           (( arfcn >= LOW_CHANNEL_1800 ) AND ( arfcn <= HIGH_CHANNEL_1800)))
        {
           result = TRUE;
        }
        break;

      case STD_850_900_1900:
        if ((( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) OR
            ( arfcn <= HIGH_CHANNEL_900) OR
           (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1)) OR
           (( arfcn >= LOW_CHANNEL_1900 ) AND ( arfcn <= HIGH_CHANNEL_1900)))
        {
           result = TRUE;
        }
        break;
#endif      

      default:
        break;
    }
  return(result);

} /* ctrl_check_cco_freq() */

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

  return( psc_db->cell_info_for_gmm.gprs_service );
} /* ctrl_get_gprs_service() */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_set_gprs_service 
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_set_gprs_service ( UBYTE cause, UBYTE limited )
{
  TRACE_FUNCTION( "ctrl_set_gprs_service" );

  switch( cause )
  {
    case GPRS_SUPPORTED:
      psc_db->cell_info_for_gmm.gprs_service = 
        ( limited EQ TRUE ? GPRS_SERVICE_LIMITED : GPRS_SERVICE_FULL );
      break;

    case GPRS_NOT_SUPPORTED:
    case GPRS_CELL_NOT_SUITABLE:
    default:
      psc_db->cell_info_for_gmm.gprs_service = GPRS_SERVICE_NONE;
      break;
  }

  grr_set_cell_info_service( );

} /* ctrl_set_gprs_service() */

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

  {
    PALLOC( gmmrr_suspend_cnf, GMMRR_SUSPEND_CNF );
    PSEND( hCommGMM, gmmrr_suspend_cnf );
  }
} /* ctrl_send_gmmrr_suspend_cnf() */

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

  grr_data->ctrl.last_state = state;

  {
    PALLOC( gmmrr_cs_page_ind, GMMRR_CS_PAGE_IND );
    PSEND( hCommGMM, gmmrr_cs_page_ind );
  }
} /* ctrl_handle_gmmrr_cs_page_ind() */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_handle_parked_rrgrr_cr_ind 
+------------------------------------------------------------------------------
| Description : 
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_handle_parked_rrgrr_cr_ind( UBYTE state )
{
  UBYTE glbl_state = GET_STATE( CTRL_GLBL );

  TRACE_FUNCTION( "ctrl_handle_parked_rrgrr_cr_ind" );

  if( glbl_state EQ GLBL_PCKT_MODE_NULL OR
      glbl_state EQ GLBL_PCKT_MODE_SYNC OR 
      glbl_state EQ GLBL_PCKT_MODE_SUSP    )
  {
    /*
     * In this state the cell re-selection triggered by GRR
     * is already requested with a RRGRR_CR_REQ
     */
    if( state EQ CTRL_CR )
    {
      SET_STATE( CTRL, CTRL_AUTO_RR_CR );
    }
    else if( state EQ CTRL_CR_IN_SUSP )
    {
      SET_STATE( CTRL, CTRL_RR_CR_IN_SUSP );
    }
    else
    {
      TRACE_EVENT_P1( "ctrl_handle_parked_rrgrr_cr_ind in state %d", state );
    }
            
    ctrl_cc_rejected( );
    ctrl_set_old_scell( FALSE );
    ctrl_send_cell_reselection_req( CR_COMPLETE );

    grr_data->ctrl.parked_rrgrr_cr_ind = FALSE;
  }
} /* ctrl_handle_parked_rrgrr_cr_ind() */


/*
+------------------------------------------------------------------------------
| Function    : ctrl_read_pcm
+------------------------------------------------------------------------------
| Description : The function ctrl_read_pcm read some info from ffs to decide
|               if nc2 should be switched on or off
|       
| Parameters  : void
|
+------------------------------------------------------------------------------
*/

GLOBAL void ctrl_read_pcm ( void )
{
#ifdef _TARGET_
  T_GRR_FFS GRR_ffsBuffer;
  T_FFS_SIZE size = ffs_fread("/GPRS/grr", &GRR_ffsBuffer, sizeof(GRR_ffsBuffer));
#endif

  TRACE_FUNCTION( "ctrl_read_pcm" );

  grr_data->nc2_on = TRUE;
#ifdef _TARGET_
  if ( size != sizeof(GRR_ffsBuffer) )
  {
    if ( size < 0 )
    {
      TRACE_EVENT_P1("FFS can not be read \"/GPRS/grr\" (%d)", size);
    }
    else
    {
      TRACE_EVENT_P2("FFS contains old file of \"/GPRS/grr\": %dBytes long, but %dBytes expected",
                      size, sizeof(GRR_ffsBuffer));
    }
  }
  else
  {
    grr_data->nc2_on = GRR_ffsBuffer.nc2_on;
  }
#endif
  TRACE_EVENT_P1("ctrl_read_pcm: grr_data->nc2_on is %d",grr_data->nc2_on);
  return;
}

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

  switch( GET_STATE( CTRL ) )
  {
    case CTRL_NULL:
      TRACE_ERROR( "ctrl_enter_standby_state: unexpected signalling" );
      break;

    default:
      sig_ctrl_cs_gmm_state( STANDBY_STATE );

      if( grr_is_pbcch_present( ) EQ FALSE )
      {
        PALLOC( rrgrr_standby_state_ind, RRGRR_STANDBY_STATE_IND );
        PSEND( hCommRR, rrgrr_standby_state_ind );
      }
      break;
  }
} /* ctrl_enter_standby_state() */

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

  switch( GET_STATE( CTRL ) )
  {
    case CTRL_NULL:
      TRACE_ERROR( "ctrl_enter_ready_state: unexpected signalling" );
      break;

    default:
      sig_ctrl_cs_gmm_state( READY_STATE );

      if( grr_is_pbcch_present( ) EQ FALSE )
      {
        PALLOC( rrgrr_ready_state_ind, RRGRR_READY_STATE_IND );
        PSEND( hCommRR, rrgrr_ready_state_ind );
      }
      break;
  }
} /* ctrl_enter_ready_state() */

#ifdef REL99
/*
+------------------------------------------------------------------------------
| Function    : ctrl_create_freq_list_cbch
+------------------------------------------------------------------------------
| Description : Creates the frequency list to be used for mobile allocation
|               when CBCH has hopping channel.
| Parameters. : cbch_req -output ; points the cbch information structure
|                                  that would be sent in RRGRR_CBCH_INFO_IND
|               freq_par : frequency parameters struct received in PSI 8 
|                          describing the CBCH channel.
|               gp_ma    : GPRS mobile allocation IE referred in Freq parametrs
|                          struct.
|               ma_num   : MA_NUM received in freq params, when indirect encoding 
|                          is used. Otherwise, this parameter is not important.
+------------------------------------------------------------------------------
*/
GLOBAL BOOL ctrl_create_freq_list_cbch(T_cbch *cbch_req,const T_freq_par *freq_par,const T_gprs_ms_alloc_ie *gp_ma,UBYTE ma_num)
{
  T_LIST list1;     /*lint !e813*/
  USHORT list2[64]; /*lint !e813*/
  USHORT count = 0;
  TRACE_FUNCTION( "ctrl_create_freq_list_cbch" );
  memset(&list1, 0, sizeof(T_LIST));
  memset(list2, NOT_PRESENT_16BIT, sizeof(list2));  
  /* 
   * Now we have the GPRS Mobile Allocation corresponding to the ma_num.
   * Get the referenced set of radio frequency lists for this
   * particular GPRS Mobile Allocation IE.
   * If RFL number list is not present in the IE, then cell allocation
   * would be returned by this function.
   */
  if(!grr_get_ref_list_or_cell_allocation(&list1,gp_ma,ma_num))
  {
    TRACE_ERROR("Could not get ref list");
    return FALSE; 
  }
    
  /*
   * Copy ARFCN values into freq_list
   */
  srv_create_list (&list1, list2, 64, TRUE, 0);

  /*
   * Take MA_BITMAP or ARFCN_INDEX into account
   */
  grr_ma_filter_list( list2,         /* input  */
                      cbch_req->ma,  /* output */
                      gp_ma
                    );

  /*
   * Get number of copied frequencies
   */
  if(!grr_validate_and_count_frequencies( cbch_req->ma,&count))
  {
    TRACE_ERROR( "grr_create_freq_list: validation failed/freq count zero" );  
    return FALSE;
  }

  /* The hopping frequency list has to be sent to RR should be in the form
   * that is used in MPH sap. The T_p_freq_list used in MPHP sap. The temporary
   * variable temp_p_freq_list has been temporarily used here to reuse the
   * code. The last element in temp_p_freq_list should be set to NOT_PRESENT_16BIT
   * and then copied back to T_cbch cbch_req.
   */
  cbch_req->ma[count] = NOT_PRESENT_16BIT;
   
  /*There is no need to convert the frequencies to L1 form. This would be
   * done by ALR when this information is passed to it by RR.
   */

  cbch_req->hsn = gp_ma->hsn;
  return TRUE;
}/* ctrl_create_freq_list_cbch */

/*
+------------------------------------------------------------------------------
| Function    : ctrl_fill_cbch_hopping_params
+------------------------------------------------------------------------------
| Description : Fills the hopping list to be sent in RRGRR_CBCH_INFO_IND
|
| Parameters  : cbch_req - points to cbch info that would go in primitive.
|               freq_par - frequency parameters received in psi8
|
+------------------------------------------------------------------------------
*/
GLOBAL BOOL ctrl_fill_cbch_hopping_params(T_cbch *cbch_req,const T_freq_par *freq_par)
{
  T_gprs_ms_alloc_ie *gp_ma  = NULL;
  BOOL                result = FALSE;


  TRACE_FUNCTION("ctrl_fill_cbch_hopping_params");

  if(freq_par->v_indi_encod)
  {
    result = grr_validate_ma_num_in_freq_par(freq_par,GRR_FREQ_PARAM_RECEIVED_IN_NON_ASSIGNMENT);
    if(result)
    {
      gp_ma = grr_get_gprs_ma(freq_par->indi_encod.ma_num);    
      if(gp_ma EQ NULL)
      {
        TRACE_EVENT("No valid GPRS_MA found");
        return FALSE;
      }
      if(!ctrl_create_freq_list_cbch(cbch_req,
                                     freq_par,
                                     gp_ma,
                                     freq_par->indi_encod.ma_num))
      {
        TRACE_EVENT("Failed to create freq list for cbch");
        return FALSE;
      }
      cbch_req->maio = freq_par->indi_encod.maio;
    }
    else
    {
      TRACE_ERROR("error creating frequency list,Invalid MA_NUM");
      result = FALSE;
    }
  } /* if(freq_par->v_indi_encod) */
  else if(freq_par->v_di_encod1)
  {
   
    /* In this case, the GPRS mobile allocation IE is present 
     * in the message itself. 
     */
    if(!ctrl_create_freq_list_cbch(cbch_req,
                                  freq_par,
                                  &freq_par->di_encod1.gprs_ms_alloc_ie,
                                  0))
    {
      TRACE_EVENT("Failed to create freq list for cbch");
      return FALSE;
    }
    cbch_req->maio = freq_par->di_encod1.maio;
   
  } /* if(freq_par->v_di_encod1) */
  else if(freq_par->v_di_encod2)
  {
    /* processing of T_freq_par from assignment and non-assignment messages
     * when direct encoding 2 is used, should be done in same object module as 
     * this involvs use of temporary static array variables which are local to the 
     * object module they are used in(_local_dummy_list and _local_rfl_contents).
     * Hence processing for both assignment and non-assignement messages is done
     * in grr_f.c. If they are put in different files, we will have to duplicate
     * the temporary static arrays.
     */
    result = grr_cnv_freq_para_in_psi8_direct_enc_2(cbch_req,freq_par);
      
  } /* if(freq_par->v_di_encod2) */
  else
  {
    TRACE_ERROR("FATAL ERROR: no frequency params in cbch description.");
  }

  return (result);
}/* ctrl_fill_cbch_hopping_params */
#endif