line source
/*
+-----------------------------------------------------------------------------
| 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 primitive handler functions for service
| CTRL of entity GRR.
+-----------------------------------------------------------------------------
*/
#ifndef GRR_CTRLP_C
#define GRR_CTRLP_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_ctrlf.h" /* */
#include "grr_ctrls.h"
#include "grr_psis.h" /* */
#include "grr_pgs.h" /* */
#include "grr_meass.h" /* */
#include "grr_tcs.h" /* */
#include "grr_css.h" /* */
#include "grr_f.h" /* */
#include "grr_tcf.h"
#include <string.h> /* for memcpy */
/*==== CONST ================================================================*/
/*==== LOCAL VARS ===========================================================*/
/*==== PRIVATE FUNCTIONS ====================================================*/
/*==== PUBLIC FUNCTIONS =====================================================*/
/*
+------------------------------------------------------------------------------
| Function : ctrl_gmmrr_enable_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_ENABLE_REQ
|
| Parameters : *gmmrr_enable_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_gmmrr_enable_req ( T_GMMRR_ENABLE_REQ *gmmrr_enable_req )
{
TRACE_FUNCTION( "gmmrr_enable_req" );
switch( GET_STATE( CTRL ) )
{
case CTRL_NULL:
SET_STATE( CTRL,CTRL_READY );
/* get MS class: A, B, C*/
grr_data->ms.class_of_mode = gmmrr_enable_req->mobile_class;
/* BEGIN GRR_NMO_III*/
if(grr_data->ms.class_of_mode EQ GMMRR_CLASS_B)
{
TRACE_EVENT(" Non reverting MS in GMMRR_NET_MODE_III: MS Class B");
TRACE_EVENT(" CCCH monitoring during TBF is allowed");
grr_data->ms.reverts_NMO_III = FALSE; /* Non reverting MS in NMO_III: MS Class B*/
grr_data->ms.tbf_mon_ccch = TRUE; /* CCCH monitoring during TBF is allowed*/
}
/* END GRR_NMO_III*/
/* get MS access control class*/
grr_data->ms.access_ctrl_class = gmmrr_enable_req->acc_contr_class;
/* split_paging cycle value! NOT the code*/
grr_data->ms.split_pg_cycle = gmmrr_enable_req->split_pg_cycle;
/* split paging cycle support on CCCH */
psc_db->net_ctrl.spgc_ccch_supp.ms_supp = gmmrr_enable_req->spgc_ccch_supp;
psc_db->non_drx_timer = gmmrr_enable_req->gmmrr_non_drx_timer; /* values between 0 and 7*/
break;
default:
TRACE_ERROR( "GMMRR_ENABLE_REQ unexpected" );
break;
}
PFREE(gmmrr_enable_req);
} /* ctrl_gmmrr_enable_req() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_gmmrr_assign_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_ASSIGN_REQ
|
| Parameters : *gmmrr_assign_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_gmmrr_assign_req ( T_GMMRR_ASSIGN_REQ *gmmrr_assign_req )
{
TRACE_FUNCTION( "gmmrr_assign_req" );
/*
* PTMSI
*/
grr_data->db.ms_id.old_ptmsi = gmmrr_assign_req->old_ptmsi;
grr_data->db.ms_id.new_ptmsi = gmmrr_assign_req->new_ptmsi;
/*
* TLLI
*/
grr_data->db.ms_id.old_tlli = gmmrr_assign_req->old_tlli;
grr_data->db.ms_id.new_tlli = gmmrr_assign_req->new_tlli;
if(grr_data->db.ms_id.new_tlli EQ GMMRR_TLLI_INVALID)
{
TRACE_EVENT("GMM HAS UNASSIGNED GRR, DELETE DATA QUEUE");
}
/* for received TLLI: if old is valid take old tlli for received TLLI*/
grr_data->db.ms_id.received_tlli = (gmmrr_assign_req->old_tlli NEQ GMMRR_TLLI_INVALID)
?
gmmrr_assign_req->old_tlli
:
gmmrr_assign_req->new_tlli
;
/*send PTMSI to RR*/
grr_data->db.ms_id.rai = gmmrr_assign_req->rai;
{
PALLOC(rrgrr_gprs_data_req, RRGRR_GPRS_DATA_REQ);
rrgrr_gprs_data_req->old_ptmsi = grr_data->db.ms_id.old_ptmsi;
rrgrr_gprs_data_req->new_ptmsi =grr_data->db.ms_id.new_ptmsi;
rrgrr_gprs_data_req->tlli = gmmrr_assign_req->new_tlli;
rrgrr_gprs_data_req->rai = grr_data->db.ms_id.rai;
memset(&rrgrr_gprs_data_req->p_chan_req_des,0,sizeof(T_p_chan_req_des));
memset(&rrgrr_gprs_data_req->gprs_meas_results,0,sizeof(T_gprs_meas_results));
rrgrr_gprs_data_req->mac_req = 0;
rrgrr_gprs_data_req->cs_req = 0;
PSEND(hCommRR, rrgrr_gprs_data_req);
}
grr_data->db.ms_id.imsi.number_of_digits = ctrl_get_number_of_digits(gmmrr_assign_req->imsi.id);
memcpy(grr_data->db.ms_id.imsi.digit, gmmrr_assign_req->imsi.id, MAX_IMSI_DIGITS);
sig_ctrl_tc_enable_grlc (CGRLC_QUEUE_MODE_DEFAULT, CGRLC_RA_DEFAULT );
PFREE(gmmrr_assign_req);
} /* ctrl_gmmrr_assign_req() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_gmmrr_disable_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_DISABLE_REQ
|
| Parameters : *gmmrr_disable_req - Ptr to primitive payload
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_gmmrr_disable_req ( T_GMMRR_DISABLE_REQ *gmmrr_disable_req )
{
TRACE_FUNCTION( "gmmrr_disable_req" );
SET_STATE( CTRL,CTRL_NULL );
ctrl_stop_all_activities( CTRL_DC_OTHER, NULL );
ctrl_start_monitoring_ccch( PAG_MODE_DEFAULT );
/* Disable GRLC , delete all primitives */
tc_cgrlc_disable_req(CGRLC_PRIM_STATUS_ALL);
/* Re-initialize GRR database */
TRACE_EVENT("Reinit GRR db");
grr_init();
PFREE(gmmrr_disable_req);
} /* ctrl_gmmrr_disable_req() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_gprs_si13_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive RRGRR_GPRS_SI13_IND
|
| Parameters : *rrgrr_gprs_si13_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_gprs_si13_ind
( T_RRGRR_GPRS_SI13_IND * rrgrr_gprs_si13_ind )
{
UBYTE state = GET_STATE( CTRL );
USHORT arfcn;
UBYTE bsic;
T_GPRS_SERVICE gprs_service = ctrl_get_gprs_service( );
TRACE_FUNCTION( "ctrl_rrgrr_gprs_si13_ind" );
TRACE_EVENT_P5( "RRGRR_GPRS_SI13_IND - CELL: %d %d, %d %d, STATE: %d",
rrgrr_gprs_si13_ind->serving_cell_info.bcch_arfcn,
rrgrr_gprs_si13_ind->serving_cell_info.bcch_bsic,
rrgrr_gprs_si13_ind->cause,
rrgrr_gprs_si13_ind->serving_cell_info.limited,
state );
switch( state )
{
case CTRL_READY:
case CTRL_ACCESS_DISABLED:
case CTRL_READY_TO_PROGRESS:
case CTRL_IN_PROGRESS:
case CTRL_AUTO_RR_CR:
case CTRL_RR_CR_IN_SUSP:
switch( rrgrr_gprs_si13_ind->cause )
{
case GPRS_NOT_SUPPORTED:
ctrl_si13_received( rrgrr_gprs_si13_ind );
if( ( state & CTRL_SUSPENSION_MASK ) EQ CTRL_SUSPENSION_YES )
{
SET_STATE( CTRL, CTRL_NO_CELL_SUSP );
/*
* cell indication is sent after resume:
* ctrl_send_cell_ind( );
*/
}
else
{
SET_STATE( CTRL, CTRL_READY );
ctrl_send_cell_ind( );
}
ctrl_stop_all_activities( CTRL_DC_OTHER, NULL );
ctrl_send_cell_reselection_req( CR_COMPLETE );
break;
case GPRS_SUPPORTED:
if( grr_decode_rr
( ( T_MSGBUF* )( &rrgrr_gprs_si13_ind->sdu ) ) EQ D_SYS_INFO_13 )
{
ctrl_si13_received( rrgrr_gprs_si13_ind );
if( state EQ CTRL_IN_PROGRESS AND
gprs_service NEQ ctrl_get_gprs_service( ) )
{
ctrl_send_cell_ind( );
}
}
else
{
if( ( state & CTRL_CELL_RESEL_MASK ) EQ CTRL_CELL_RESEL_RR )
{
ctrl_send_cell_reselection_req( CR_CONT );
}
else
{
/* impl. missing, what happens if decoding failed? */
}
}
break;
case GPRS_CELL_NOT_SUITABLE:
default:
/* do nothing */
break;
}
break;
case CTRL_CR:
case CTRL_CR_IN_SUSP:
case CTRL_RR_NC_CCO:
case CTRL_GRR_NC_CCO:
if( grr_t_status(T3176) > 0 )
{
if(grr_decode_rr((T_MSGBUF *)(&(rrgrr_gprs_si13_ind->sdu))) EQ D_SYS_INFO_13)
{
if( rrgrr_gprs_si13_ind->serving_cell_info.bcch_arfcn EQ
posc_db->pbcch.bcch.arfcn )
{
/* impl. missing, what happend if service on old serving cell has changed? */
ctrl_reinstall_old_scell_cnf( TRUE );
sig_ctrl_psi_resumpt_cc( );
ctrl_si13_received( rrgrr_gprs_si13_ind );
ctrl_enable_serving_cell( FALSE );
ctrl_send_cell_reselection_req( CR_COMPLETE );
sig_ctrl_tc_enable_grlc (CGRLC_QUEUE_MODE_LLC, CGRLC_RA_DEFAULT );
arfcn = grr_data->ctrl.pcc_arfcn;
bsic = grr_data->ctrl.pcc_bsic;
ctrl_build_pcco_failure_msg(arfcn, bsic);
}
}
}
else if( pcr_db NEQ NULL )
{
if( rrgrr_gprs_si13_ind->cause EQ GPRS_CELL_NOT_SUITABLE )
{
grr_set_db_ptr( DB_MODE_CC_REQ );
SET_STATE_FAILED_CR( state );
ctrl_cc_rejected( );
}
else if( rrgrr_gprs_si13_ind->serving_cell_info.bcch_arfcn EQ
pcr_db->pbcch.bcch.arfcn AND
rrgrr_gprs_si13_ind->serving_cell_info.bcch_bsic EQ
pcr_db->pbcch.bcch.bsic )
{
if( rrgrr_gprs_si13_ind->cause EQ GPRS_NOT_SUPPORTED )
{
grr_set_db_ptr( DB_MODE_CC_REQ );
/*
* The neighbour cell does not support GPRS: No SI13
* We have to check the GPRS re-selection parameters and
* decide whether we can camp on this cell or not
* Therefore compare GPRS re-selection parameters
*/
if( sig_ctrl_cs_check_c1_new_scell
( state EQ CTRL_RR_NC_CCO OR state EQ CTRL_GRR_NC_CCO,
rrgrr_gprs_si13_ind->serving_cell_info.gprs_rxlev_access_min,
rrgrr_gprs_si13_ind->serving_cell_info.gprs_ms_txpwr_max_cch ) )
{
ctrl_si13_received( rrgrr_gprs_si13_ind );
/*
* the selected cell is suitable
*/
if( ( state & CTRL_SUSPENSION_MASK ) EQ CTRL_SUSPENSION_YES )
{
SET_STATE( CTRL, CTRL_NO_CELL_SUSP );
/*
* cell indication is sent after resume:
* ctrl_send_cell_ind( );
*/
}
else
{
SET_STATE( CTRL, CTRL_READY );
ctrl_send_cell_ind( );
}
ctrl_install_new_scell ( );
ctrl_send_cell_reselection_req( CR_COMPLETE );
grr_set_db_ptr( DB_MODE_CC_ACC );
}
else
{
/*
* the selected cell is not suitable
*/
SET_STATE_FAILED_CR( state );
ctrl_cc_rejected( );
}
}
else /* if( rrgrr_gprs_si13_ind->cause EQ GPRS_SUPPORTED ) */
{
grr_set_db_ptr( DB_MODE_CC_REQ );
if(grr_decode_rr((T_MSGBUF *)(&(rrgrr_gprs_si13_ind->sdu))) EQ D_SYS_INFO_13)
{
/*
* Check whether the selected NCELL is OK or not
*/
if( sig_ctrl_cs_check_c1_new_scell
( state EQ CTRL_RR_NC_CCO OR state EQ CTRL_GRR_NC_CCO,
rrgrr_gprs_si13_ind->serving_cell_info.gprs_rxlev_access_min,
rrgrr_gprs_si13_ind->serving_cell_info.gprs_ms_txpwr_max_cch ) )
{
ctrl_si13_received( rrgrr_gprs_si13_ind );
}
else
{
SET_STATE_FAILED_CR( state );
ctrl_cc_rejected( );
}
}
else
{
SET_STATE_FAILED_CR( state );
ctrl_cc_rejected( );
}
}
}
else
{
TRACE_EVENT_P2( "RRGRR_GPRS_SI13_IND - GPRS indication expected from CELL: %d %d",
pcr_db->pbcch.bcch.arfcn, pcr_db->pbcch.bcch.bsic );
}
}
break;
/*
* In the following states GRR does not expect a RRGRR_GPRS_SI13_IND
* due to several different reasons, please see details below.
*/
/*
* CTRL is switched off, no processing will be performed at all.
*/
case CTRL_NULL:
/*
* CTRL waits for a confirmation, all states are interim states.
* Shall GRR be ready for processing RRGRR_GPRS_SI13_IND anyway ???
*/
case CTRL_WAIT_CS_PAGE_RES:
case CTRL_WAIT_FOR_CNF_OF_SUSPENSION:
case CTRL_WAIT_RSP_4_RR_CR:
/*
* CTRL is in a temporary state, which shall be set and reset
* during one primitive processing cycle.
*/
case CTRL_FAILED_CR:
case CTRL_FAILED_CR_IN_SUSP:
/*
* CTRL expects a RRGRR_GPRS_SI13_IND during suspension only when
* a RRGRR_CR_IND was sent before, the state changes to
* CTRL_RR_CR_IN_SUSP or CTRL_CR_IN_SUSP in that case.
*/
case CTRL_SUSPENDED:
case CTRL_ACC_ENABLED_SUSP:
default:
/* do nothing */
break;
}
PFREE( rrgrr_gprs_si13_ind );
} /* ctrl_rrgrr_gprs_si13_ind() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_packet_paging_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive RRGRR_PACKET_PAGING_IND: this primitve indicates
| that the RR part has received a paging for packet data transfer
| CTRL informs the PG-Service and PG-Service has to decide how to
| react to this indication
|
| Parameters : *rrgrr_packet_paging_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_packet_paging_ind ( T_RRGRR_PACKET_PAGING_IND *rrgrr_packet_paging_ind )
{
TRACE_FUNCTION( "rrgrr_packet_paging_ind" );
switch( GET_STATE( CTRL ) )
{
case CTRL_IN_PROGRESS:
sig_ctrl_pg_indication(rrgrr_packet_paging_ind->pg_type);
break;
default:
TRACE_ERROR( "RRGRR_PACKET_PAGING_IND unexpected" );
break;
}
PFREE (rrgrr_packet_paging_ind);
} /* ctrl_rrgrr_packet_paging_ind() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_ia_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive RRGRR_IA_IND
|
| Parameters : *rrgrr_ia_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_ia_ind ( T_RRGRR_IA_IND *rrgrr_ia_ind )
{
TRACE_FUNCTION( "rrgrr_ia_ind" );
/*
{
ULONG trace[5];
trace[0] = rrgrr_ia_ind->sdu.buf[0] << 24;
trace[0] |= rrgrr_ia_ind->sdu.buf[1] << 16;
trace[0] |= rrgrr_ia_ind->sdu.buf[2] << 8;
trace[0] |= rrgrr_ia_ind->sdu.buf[3] << 0;
trace[1] = rrgrr_ia_ind->sdu.buf[4] << 24;
trace[1] |= rrgrr_ia_ind->sdu.buf[5] << 16;
trace[1] |= rrgrr_ia_ind->sdu.buf[6] << 8;
trace[1] |= rrgrr_ia_ind->sdu.buf[7] << 0;
trace[2] = rrgrr_ia_ind->sdu.buf[8] << 24;
trace[2] |= rrgrr_ia_ind->sdu.buf[9] << 16;
trace[2] |= rrgrr_ia_ind->sdu.buf[10] << 8;
trace[2] |= rrgrr_ia_ind->sdu.buf[11] << 0;
trace[3] = rrgrr_ia_ind->sdu.buf[12] << 24;
trace[3] |= rrgrr_ia_ind->sdu.buf[13] << 16;
trace[3] |= rrgrr_ia_ind->sdu.buf[14] << 8;
trace[3] |= rrgrr_ia_ind->sdu.buf[15] << 0;
trace[4] = rrgrr_ia_ind->sdu.buf[16] << 24;
trace[4] |= rrgrr_ia_ind->sdu.buf[17] << 16;
trace[4] |= rrgrr_ia_ind->sdu.buf[18] << 8;
trace[4] |= rrgrr_ia_ind->sdu.buf[19] << 0;
TRACE_EVENT_P8( "RRGRR_IA_IND: %08X%08X%08X%08X%08X%02X%02X%02X",
trace[0], trace[1], trace[2], trace[3], trace[4],
rrgrr_ia_ind->sdu.buf[20], rrgrr_ia_ind->sdu.buf[21],
rrgrr_ia_ind->sdu.buf[22] );
}
*/
if(D_IMM_ASSIGN EQ grr_decode_rr((T_MSGBUF *)(&(rrgrr_ia_ind->sdu))))
{
switch( GET_STATE( CTRL ) )
{
case CTRL_IN_PROGRESS:
case CTRL_GRR_NC_CCO:
sig_ctrl_tc_ia_received (rrgrr_ia_ind);
break;
default:
TRACE_ERROR( "RRGRR_IA_IND unexpected" );
break;
}
}
else
{
TRACE_ERROR( "RRGRR_IA_IND wrong message type" );
}
PFREE (rrgrr_ia_ind);
} /* ctrl_rrgrr_ia_ind() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_iaext_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive RRGRR_IAEXT_IND
|
| Parameters : *rrgrr_iaext_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_iaext_ind ( T_RRGRR_IAEXT_IND *rrgrr_iaext_ind)
{
TRACE_FUNCTION( "rrgrr_iaext_ind" );
if(D_IMM_ASSIGN_EXT == grr_decode_rr((T_MSGBUF *)(&(rrgrr_iaext_ind->sdu))))
{
switch( GET_STATE( CTRL ) )
{
case CTRL_IN_PROGRESS:
sig_ctrl_tc_iaext_received (rrgrr_iaext_ind);
break;
default:
TRACE_ERROR( "RRGRR_IAEXT_IND unexpected" );
break;
}
}
else
{
TRACE_ERROR( "RRGRR_IAEXT_IND wrong message type" );
}
PFREE (rrgrr_iaext_ind);
} /* ctrl_rrgrr_iaext_ind() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_assignment_rej_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive RRGRR_ASSIGNMENT_REJ_IND
|
| Parameters : *rrgrr_assignment_rej_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_assignment_rej_ind ( T_RRGRR_ASSIGNMENT_REJ_IND *rrgrr_assignment_rej_ind )
{
TRACE_FUNCTION( "rrgrr_assignment_rej_ind" );
switch( GET_STATE( CTRL ) )
{
case CTRL_IN_PROGRESS:
sig_ctrl_tc_iarej_received (rrgrr_assignment_rej_ind);
break;
case CTRL_GRR_NC_CCO:
sig_ctrl_tc_iarej_received (rrgrr_assignment_rej_ind);
ctrl_stop_T3174();
ctrl_pcco_failure();
break;
default:
TRACE_ERROR( "RRGRR_ASSIGNMENT_REJ_IND unexpected" );
break;
}
PFREE (rrgrr_assignment_rej_ind);
} /* ctrl_rrgrr_assignment_rej_ind() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_t3134
+------------------------------------------------------------------------------
| Description : Handles the time out of T3134
|
| Parameters : No parameter
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_t3134 ( void )
{
TRACE_FUNCTION( "ctrl_t3134" );
switch( GET_STATE( CTRL ) )
{
case CTRL_RR_NC_CCO:
sig_ctrl_tc_cr_timerout_cnf();
ctrl_reinstall_old_scell_req( FALSE, RECONN_TIMER_EXPIRED );
break;
default:
TRACE_ERROR( "time out of T3134 unexpected" );
break;
}
}/* ctrl_t3134() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_t3174
+------------------------------------------------------------------------------
| Description : Handles the time out of T3174
|
| Parameters : No parameter
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_t3174 ( void )
{
TRACE_FUNCTION( "ctrl_t3174" );
TRACE_EVENT("T3174 expired");
switch( GET_STATE( CTRL ) )
{
case CTRL_GRR_NC_CCO:
case CTRL_IN_PROGRESS:
grr_data->pcco_failure_cause = 1; /*No_Resp_On_Target_Cell*/
ctrl_pcco_failure( );
break;
default:
TRACE_ERROR( "time out of T3174 unexpected" );
break;
}
} /* ctrl_t3174() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_start_t3174
+------------------------------------------------------------------------------
| Description : Handles the time starting of T3174
|
| Parameters : No parameter
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_start_T3174 ( void )
{
TRACE_FUNCTION( "tc_start_T3174" );
TRACE_EVENT( "T3174 for packet cell change started" );
vsi_t_start( GRR_handle,T3174, T3174_VALUE );
} /* tc_start_T3174 */
/*
+------------------------------------------------------------------------------
| Function : ctrl_t3176
+------------------------------------------------------------------------------
| Description : Handles the timer T3176
|
| Parameters : inctance_i - identifier of timer's inctance
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_t3176 ( void )
{
TRACE_FUNCTION( "ctrl_t3176" );
TRACE_EVENT("T3176 expired");
switch( GET_STATE( CTRL ) )
{
case CTRL_GRR_NC_CCO:
SET_STATE( CTRL,CTRL_IN_PROGRESS );
/*lint -fallthrough*/
default:
ctrl_cancel_control_block( CGRLC_BLK_OWNER_CTRL );
break;
}
} /* ctrl_t3176() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_data_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive RRGRR_DATA_IN
|
| Parameters : *rrgrr_pdch_assignment_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_data_ind ( T_RRGRR_DATA_IND *rrgrr_data_ind )
{
TRACE_FUNCTION( "ctrl_rrgrr_data_ind" );
switch( GET_STATE( CTRL ) )
{
case CTRL_IN_PROGRESS:
switch( grr_decode_rr((T_MSGBUF *)(&(rrgrr_data_ind->sdu))) )
{
case D_PDCH_ASS_CMD:
sig_ctrl_tc_pdch_assign_received (rrgrr_data_ind);
break;
case D_CHANGE_ORDER:
/*
* RR Network cell change order was received
*/
{
MCAST(d_change_order,D_CHANGE_ORDER);
ctrl_cell_change_order( CCO_TYPE_RR, (void *)d_change_order );
}
break;
default:
TRACE_ERROR( "RRGRR_PDCH_ASSIGNMENT_IND grr_decode_rrgrr failed: message type NEQ PDCH_ASSIGN" );
break;
}
break;
default:
TRACE_ERROR( "RRGRR_PDCH_ASSIGNMENT_IND unexpected" );
break;
}
PFREE (rrgrr_data_ind);
} /* ctrl_rrgrr_data_ind() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_ia_downlink_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive RRGRR_IA_DOWNLINK_IND
|
| Parameters : *rrgrr_ia_downlink_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_ia_downlink_ind ( T_RRGRR_IA_DOWNLINK_IND *rrgrr_ia_downlink_ind )
{
TRACE_FUNCTION( "rrgrr_ia_downlink_ind" );
if(D_IMM_ASSIGN == grr_decode_rr((T_MSGBUF *)(&(rrgrr_ia_downlink_ind->sdu))))
{
switch( GET_STATE( CTRL ) )
{
case CTRL_IN_PROGRESS:
if (grr_data->cell_res_status)
{
sig_ctrl_tc_ia_downlink_received (rrgrr_ia_downlink_ind);
}
else
{
TRACE_ERROR ("RRGRR_IA_DOWNLINK_IND received during GMMRR_CELL_IND procedure");
}
break;
default:
ctrl_send_rrgrr_stop_task_req( CTRL_TASK_BCCH, INVALID_MSG );
TRACE_ERROR( "RRGRR_IA_DOWNLINK_IND unexpected" );
break;
}
}
else
{
ctrl_send_rrgrr_stop_task_req( CTRL_TASK_BCCH, INVALID_MSG );
TRACE_ERROR( "RRGRR_IA_IND wrong message type" );
}
PFREE (rrgrr_ia_downlink_ind);
} /* ctrl_rrgrr_ia_downlink_ind() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_stop_task_cnf
+------------------------------------------------------------------------------
| Description : Handles the primitive RRGRR_STOP_TASK_CNF
|
| Parameters : *rrgrr_stop_task_cnf - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_stop_task_cnf
( T_RRGRR_STOP_TASK_CNF *rrgrr_stop_task_cnf )
{
TRACE_FUNCTION( "ctrl_rrgrr_stop_task_cnf" );
switch( GET_STATE( CTRL ) )
{
case CTRL_ACCESS_DISABLED:
case CTRL_READY_TO_PROGRESS:
case CTRL_IN_PROGRESS:
case CTRL_WAIT_RSP_4_RR_CR:
case CTRL_WAIT_FOR_CNF_OF_SUSPENSION:
case CTRL_CR:
case CTRL_CR_IN_SUSP:
case CTRL_GRR_NC_CCO:
case CTRL_READY:
if( grr_data->ctrl_glbl.ctrl_task EQ CTRL_TASK_BCCH )
{
sig_ctrl_tc_stop_task_cnf_received( );
grr_data->ctrl_glbl.ctrl_task = CTRL_TASK_NONE;
}
else
{
ctrl_stop_rr_task_cnf( TRUE );
}
break;
default:
TRACE_ERROR( "RRGRR_STOP_TASK_CNF unexpected" );
break;
}
PFREE( rrgrr_stop_task_cnf );
} /* ctrl_rrgrr_stop_task_cnf() */
/*
+------------------------------------------------------------------------------
| Function : gmmrr_ready_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_READY_REQ
|
| Parameters : *gmmrr_ready_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_gmmrr_ready_req ( T_GMMRR_READY_REQ *gmmrr_ready_req )
{
TRACE_FUNCTION( "gmmrr_ready_req" );
ctrl_enter_ready_state( );
PFREE( gmmrr_ready_req );
} /* ctrl_gmmrr_ready_req() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_cgrlc_ready_state_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive CGRLC_READY_STATE_IND
|
| Parameters : *cgrlc_ready_state_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_cgrlc_ready_state_ind
( T_CGRLC_READY_STATE_IND *cgrlc_ready_state_ind )
{
TRACE_FUNCTION( "ctrl_cgrlc_ready_state_ind" );
ctrl_enter_ready_state( );
PFREE( cgrlc_ready_state_ind );
} /* ctrl_cgrlc_ready_state_ind() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_gmmrr_standby_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_STANDBY_REQ
|
| Parameters : *gmmrr_standby_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_gmmrr_standby_req ( T_GMMRR_STANDBY_REQ *gmmrr_standby_req )
{
TRACE_FUNCTION( "gmmrr_standby_req" );
ctrl_enter_standby_state( );
PFREE( gmmrr_standby_req );
} /* ctrl_gmmrr_standby_req() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_cgrlc_standby_state_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive CGRLC_STANDBY_STATE_IND
|
| Parameters : *cgrlc_standby_state_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_cgrlc_standby_state_ind
( T_CGRLC_STANDBY_STATE_IND *cgrlc_standby_state_ind )
{
TRACE_FUNCTION( "ctrl_cgrlc_standby_state_ind" );
ctrl_enter_standby_state( );
PFREE( cgrlc_standby_state_ind );
} /* ctrl_cgrlc_standby_state_ind() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_gmmrr_cs_page_res
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_CS_PAGE_RES
|
| Parameters : *ctrl_gmmrr_cs_page_res - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_gmmrr_cs_page_res ( T_GMMRR_CS_PAGE_RES *gmmrr_cs_page_res )
{
TRACE_FUNCTION( "gmmrr_cs_page_res" );
switch( GET_STATE( CTRL ) )
{
case CTRL_WAIT_CS_PAGE_RES:
SET_STATE(CTRL, grr_data->ctrl.last_state);
switch(grr_data->ctrl.cs_page_channel)
{
case PG_ON_PCCCH:
if(gmmrr_cs_page_res->response NEQ GMMRR_CS_PAGE_REJ)
{
/*
* GMM accepted the CS_PAGE_IND
*/
grr_data->ctrl.is_susp_needed =(gmmrr_cs_page_res->susp_gprs EQ GMMRR_SUSP_GPRS)
? SUSPENSION_REQ_NEEDED
:SUSPENSION_REQ_NOT_NEEDED;
if (grr_data->ms.class_of_mode NEQ GMMRR_CLASS_A)
{
/*
* suspend services
*/
grr_data->ctrl.after_suspension = SEND_RR_EST_REQ;
SET_STATE(CTRL, CTRL_WAIT_FOR_CNF_OF_SUSPENSION);
ctrl_suspend_services(GMMRR_ABNORMAL_RELEASE);
}
else
{
/* Do not suspend services */
ctrl_send_rr_est_req(grr_data->ctrl.is_susp_needed);
sig_ctrl_meas_suspend( );
}
}
break;
case PG_ON_CCCH:
if(gmmrr_cs_page_res->response NEQ GMMRR_CS_PAGE_REJ)
{
/*
* GMM accepted the CS_PAGE_IND
*/
grr_data->ctrl.is_susp_needed =(gmmrr_cs_page_res->susp_gprs EQ GMMRR_SUSP_GPRS)
? SUSPENSION_REQ_NEEDED
:SUSPENSION_REQ_NOT_NEEDED;
if (grr_data->ms.class_of_mode NEQ GMMRR_CLASS_A)
{
/*
* suspend services
*/
grr_data->ctrl.after_suspension = SEND_RR_EST_RSP;
SET_STATE(CTRL, CTRL_WAIT_FOR_CNF_OF_SUSPENSION);
ctrl_suspend_services(GMMRR_ABNORMAL_RELEASE);
}
else
{
/* Do not suspend services */
ctrl_send_rr_est_req(grr_data->ctrl.is_susp_needed);
sig_ctrl_meas_suspend( );
}
}
else
{
/* GMM rejected the CS_PAGE_IND*/
ctrl_send_rr_est_rsp(SUSPENSION_REQ_NOT_NEEDED/*in this case it has no meaning*/,
FALSE /* CS_PAGE was rejected*/);
}
break;
}
break;
default:
TRACE_ERROR( "GMMRR_CS_PAGE_RES unexpected" );
break;
}
PFREE(gmmrr_cs_page_res);
} /* ctrl_gmmrr_cs_page_res() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_gmmrr_suspend_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_CS_PAGE_RES
|
| Parameters : *gmmrr_suspend_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_gmmrr_suspend_req ( T_GMMRR_SUSPEND_REQ *gmmrr_suspend_req )
{
TRACE_FUNCTION( "gmmrr_suspend_req" );
switch( GET_STATE( CTRL ) )
{
case CTRL_READY:
case CTRL_IN_PROGRESS:
case CTRL_ACCESS_DISABLED:
case CTRL_WAIT_CS_PAGE_RES:
grr_data->ctrl.last_state = GET_STATE( CTRL );
grr_data->ctrl.after_suspension = ACTIVATE_RR;
grr_data->ctrl.is_susp_needed =(gmmrr_suspend_req->susp_gprs EQ GMMRR_SUSP_GPRS)
? SUSPENSION_REQ_NEEDED
:SUSPENSION_REQ_NOT_NEEDED;
SET_STATE(CTRL, CTRL_WAIT_FOR_CNF_OF_SUSPENSION);
ctrl_suspend_services( gmmrr_suspend_req->gmmrr_susp_cause );
break;
default:
TRACE_ERROR( "GMMRR_SUSPEND_REQ unexpected" );
break;
}
PFREE(gmmrr_suspend_req);
} /* ctrl_gmmrr_suspend_req() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_gmmrr_resume_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_RESUME_REQ
| GRR leaves the SUSPENDED-State
| Parameters : *gmmrr_suspend_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_gmmrr_resume_req ( T_GMMRR_RESUME_REQ *gmmrr_resume_req )
{
TRACE_FUNCTION( "ctrl_gmmrr_resume_req" );
switch( GET_STATE( CTRL ) )
{
case CTRL_NO_CELL_SUSP:
SET_STATE(CTRL, CTRL_READY);
TRACE_EVENT("No GPRS cell Inform GMM");
ctrl_send_cell_ind( );
break;
case CTRL_RR_CR_IN_SUSP:
TRACE_EVENT("CR not complete in SUSP mode");
SET_STATE(CTRL, CTRL_AUTO_RR_CR);
break;
case CTRL_CR_IN_SUSP:
SET_STATE(CTRL, CTRL_CR);
break;
case CTRL_FAILED_CR_IN_SUSP:
SET_STATE(CTRL, CTRL_FAILED_CR);
break;
case CTRL_ACC_ENABLED_SUSP:
/*
* resume PSI
* enable cell
*/
SET_STATE(CTRL, CTRL_IN_PROGRESS);
TRACE_EVENT("Cell changed within SUSP");
sig_ctrl_psi_resumpt();
ctrl_enable_serving_cell( FALSE );
break;
case CTRL_WAIT_FOR_CNF_OF_SUSPENSION:
/*
* This is an exceptional case->GMM resumes without receiving suspend_cnf
*/
case CTRL_SUSPENDED:
switch(grr_data->ctrl.last_state)
{
case CTRL_NULL:
case CTRL_READY:
case CTRL_ACCESS_DISABLED:
/*
* CTRL has to wait for receiving SI13
*/
if (grr_data->ctrl.last_state EQ CTRL_ACCESS_DISABLED)
{
SET_STATE (CTRL, CTRL_ACCESS_DISABLED)
}
else
{
SET_STATE(CTRL, CTRL_READY);
sig_ctrl_psi_stop();
grr_set_pbcch(FALSE);
}
psc_db->acq_type = COMPLETE;
ctrl_start_monitoring_bcch(COMPLETE_SI);
break;
case CTRL_IN_PROGRESS:
default:
/*
* CTRL assumes that the cell has not been changed
*/
SET_STATE(CTRL, CTRL_IN_PROGRESS);
ctrl_stop_rr_task_req( GLBL_PCKT_MODE_IDLE, TASK_STOP_DUMMY_VALUE );
break;
}
break;
default:
TRACE_ERROR( "GMMRR_RESUME_REQ unexpected" );
break;
}
PFREE(gmmrr_resume_req);
} /* ctrl_gmmrr_resume_req() */
/*
+------------------------------------------------------------------------------
| Function : rrgrr_rr_est_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive T_RRGRR_RR_EST_IND: This primitive idicates
| that the RR has received a RR connection establishment. This notification
| should be passed to PG-Service
|
| Parameters : *rrgrr_rr_est_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_rr_est_ind ( T_RRGRR_RR_EST_IND *rrgrr_rr_est_ind)
{
UBYTE state = GET_STATE( CTRL );
TRACE_FUNCTION( "ctrl_rrgrr_rr_est_ind" );
switch( state )
{
case CTRL_NULL: /* to allow class CC mobile accepting CS call*/
/*
* To pass CS page request to GMM
*/
grr_data->ctrl.cs_page_channel = PG_ON_CCCH;
SET_STATE(CTRL, CTRL_WAIT_CS_PAGE_RES);
ctrl_handle_gmmrr_cs_page_ind( state );
break;
// case CTRL_READY:
/*
* To pass the connection est. request to PG and GMM
*/
case CTRL_IN_PROGRESS:
sig_ctrl_pg_rr_est();
break;
default:
{
TRACE_ERROR( "T_RRGRR_RR_EST_IND unexpected" );
ctrl_send_rr_est_rsp(FALSE,FALSE /* CS_PAGE was NOT accepted*/);
}
break;
}
PFREE(rrgrr_rr_est_ind);
}/* rrgrr_rr_est_ind() */
/*
+------------------------------------------------------------------------------
| Function : rrgrr_suspend_dcch_cnf
+------------------------------------------------------------------------------
| Description : Handles the primitive RRGRR_SUSPEND_DCCH_CNF: This primitive
| idicates that the RR has released the DCCH connection.
| This notification should be passed to TC-Service
|
| Parameters : *rrgrr_suspend_dcch_cnf - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_suspend_dcch_cnf ( T_RRGRR_SUSPEND_DCCH_CNF *rrgrr_suspend_dcch_cnf)
{
TRACE_FUNCTION( "ctrl_rrgrr_suspend_dcch_cnf" );
switch( GET_STATE( CTRL ) )
{
case CTRL_IN_PROGRESS:
sig_ctrl_tc_suspend_dcch_cnf();
break;
default:
TRACE_ERROR( "RRGRR_SUSPEND_DCCH_CNF unexpected" );
break;
}
PFREE(rrgrr_suspend_dcch_cnf);
}/* ctrl_rrgrr_suspend_dcch_cnf() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_reconnect_dcch_cnf
+------------------------------------------------------------------------------
| Description : Handles the primitive RRGRR_RECONNECT_DCCH_CNF: This primitive
| idicates that the RR has reestablished the DCCH connection.
| This notification should be passed to TC-Service
|
| Parameters : *rrgrr_reconnect_dcch_cnf - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_reconnect_dcch_cnf
( T_RRGRR_RECONNECT_DCCH_CNF *rrgrr_reconnect_dcch_cnf )
{
TRACE_FUNCTION( "ctrl_rrgrr_reconnect_dcch_cnf" );
switch( GET_STATE( CTRL ) )
{
case CTRL_RR_NC_CCO:
if(grr_data->cc_running)
{
BOOL is_success = ( rrgrr_reconnect_dcch_cnf->reconn_state EQ RECONN_OK );
if( is_success )
{
SET_STATE( CTRL, CTRL_IN_PROGRESS );
ctrl_reinstall_old_scell_cnf( TRUE );
ctrl_enable_serving_cell( FALSE );
}
else
{
SET_STATE( CTRL, CTRL_READY );
ctrl_reinstall_old_scell_cnf( FALSE );
ctrl_enable_serving_cell( FALSE );
}
sig_ctrl_tc_reconnect_dcch_cnf( );
}
grr_data->cc_running = FALSE;
break;
default:
TRACE_ERROR( "RRGRR_RECONNECT_DCCH_CNF unexpected" );
break;
}
PFREE(rrgrr_reconnect_dcch_cnf);
}/* ctrl_rrgrr_reconnect_dcch_cnf() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_stop_dcch_ind
+------------------------------------------------------------------------------
| Description :
|
|
|
|
| Parameters : *rrgrr_stop_dcch_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_stop_dcch_ind(T_RRGRR_STOP_DCCH_IND* rrgrr_stop_dcch_ind)
{
TRACE_FUNCTION( "ctrl_rrgrr_stop_dcch_ind" );
switch( GET_STATE( CTRL ) )
{
case CTRL_IN_PROGRESS:
;
break;
default:
TRACE_ERROR( "RRGRR_STOP_DCCH_IND unexpected" );
break;
}
PFREE(rrgrr_stop_dcch_ind);
}/* ctrl_ctrl_rrgrr_stop_dcch_ind() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_cr_ind
+------------------------------------------------------------------------------
| Description : This function indicates that the cell reselection has been
| startet by the RR entity
| Parameters : *cr_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_cr_ind( T_RRGRR_CR_IND *cr_ind )
{
UBYTE state = GET_STATE( CTRL );
TRACE_FUNCTION( "ctrl_rrgrr_cr_ind" );
TRACE_ASSERT( cr_ind->cr_type EQ CR_NORMAL OR
cr_ind->cr_type EQ CR_ABNORMAL OR
cr_ind->cr_type EQ CR_REQ_CANDIDATE OR
cr_ind->cr_type EQ CR_SUSPENDED_IDLE );
TRACE_EVENT_P2( "RRGRR_CR_IND: %d in state %d", cr_ind->cr_type, state );
switch( state )
{
case CTRL_NULL:
case CTRL_READY:
switch( cr_ind->cr_type )
{
case CR_NORMAL:
case CR_ABNORMAL:
ctrl_set_old_scell( FALSE );
ctrl_send_cell_reselection_req( CR_COMPLETE );
break;
case CR_REQ_CANDIDATE:
TRACE_ERROR( "RRGRR_CR_IND unexpected" );
break;
case CR_SUSPENDED_IDLE:
/* to be defined */
break;
}
break;
case CTRL_ACC_ENABLED_SUSP:
case CTRL_NO_CELL_SUSP:
case CTRL_RR_CR_IN_SUSP:
case CTRL_SUSPENDED:
switch( cr_ind->cr_type )
{
case CR_ABNORMAL:
grr_init_ncmeas_extd_struct(&psc_db->nc_ms,FALSE);
case CR_NORMAL:
SET_STATE( CTRL, CTRL_RR_CR_IN_SUSP );
ctrl_set_old_scell( TRUE );
ctrl_stop_all_activities( CTRL_DC_CR_MS_RR_IMM_REL, NULL );
grr_prepare_db_for_new_cell( );
break;
case CR_REQ_CANDIDATE:
SET_STATE( CTRL, CTRL_CR_IN_SUSP );
sig_ctrl_cs_reselect( CS_RESELECT_CAUSE_CTRL_NORMAL );
break;
case CR_SUSPENDED_IDLE:
/* to be defined */
break;
}
break;
case CTRL_IN_PROGRESS:
case CTRL_ACCESS_DISABLED:
switch( cr_ind->cr_type )
{
case CR_NORMAL:
case CR_ABNORMAL:
SET_STATE( CTRL, CTRL_WAIT_RSP_4_RR_CR );
ctrl_set_old_scell( TRUE );
if( cr_ind->cr_type NEQ CR_NORMAL )
{
ctrl_stop_all_activities( CTRL_DC_CR_MS_RR_IMM_REL, NULL );
}
else
{
ctrl_stop_all_activities( CTRL_DC_CR_MS_RR_NORMAL, NULL );
}
break;
case CR_REQ_CANDIDATE:
TRACE_ERROR( "RRGRR_CR_IND unexpected" );
break;
case CR_SUSPENDED_IDLE:
/* to be defined */
break;
}
break;
case CTRL_CR:
case CTRL_CR_IN_SUSP:
switch( cr_ind->cr_type )
{
case CR_NORMAL:
case CR_ABNORMAL:
grr_data->ctrl.parked_rrgrr_cr_ind = TRUE;
ctrl_handle_parked_rrgrr_cr_ind( state );
break;
case CR_REQ_CANDIDATE:
TRACE_ERROR( "RRGRR_CR_IND unexpected" );
break;
case CR_SUSPENDED_IDLE:
/* to be defined */
break;
}
break;
case CTRL_AUTO_RR_CR:
switch( grr_data->ctrl.rr_state.cr_ind_return )
{
case CR_IND_RETURN_COMPLETE:
grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_RESPONSE;
ctrl_send_cell_reselection_req( CR_COMPLETE );
break;
case CR_IND_RETURN_NONE:
case CR_IND_RETURN_RESPONSE:
default:
TRACE_EVENT_P1( "RRGRR_CR_IND: cr_ind_return EQ %d",
grr_data->ctrl.rr_state.cr_ind_return );
break;
}
break;
/*
* RR is not allowed to do a MS controlled cell re-selection since
* a network controlled cell re-selection is in progress.
*/
case CTRL_RR_NC_CCO:
case CTRL_GRR_NC_CCO:
/*
* break;
*/
/*
* GRR is in a critical CTRL_WAIT_... state, just store the RRGRR_CR_IND
* and process is after leaving the critical state.
*/
case CTRL_WAIT_CS_PAGE_RES:
case CTRL_WAIT_FOR_CNF_OF_SUSPENSION:
/*
* RR has sent a RRGRR_GPRS_SI13_IND for a new serving cell and has to wait
* for response of GRR ( RRGRR_CR_REQ with appropriate parameter set )
* before sending a new cell re-selection indication.
*/
case CTRL_READY_TO_PROGRESS:
/*
* It is possible to store the RRGRR_CR_IND, to wait until the above
* states have been left and to post-process the RRGRR_CR_IND afterwards.
* But implemenation effort is quite high and it is not clear whether
* the situations can occur -> for further study.
*/
/*
* break;
*/
/*
* RR indicates a new cell re-selection but the previous one is not yet
* responded by GRR, just wait for it.
*/
case CTRL_WAIT_RSP_4_RR_CR:
/*
* The following states should never be seen when RRGRR_CR_IND has been
* received, they are just set and reset during one primitive processing
* cycle.
*/
case CTRL_FAILED_CR:
case CTRL_FAILED_CR_IN_SUSP:
default:
TRACE_ERROR( "RRGRR_CR_IND unexpected" );
break;
}
PFREE( cr_ind );
}/* ctrl_rrgrr_cr_ind() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_check_bsic_ind
+------------------------------------------------------------------------------
| Description :
|
| Parameters : *rrgrr_check_bsic_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_check_bsic_ind
( T_RRGRR_NCELL_SYNC_IND *rrgrr_check_bsic_ind )
{
TRACE_FUNCTION( "ctrl_rrgrr_check_bsic_ind" );
switch( GET_STATE( CTRL ) )
{
case CTRL_IN_PROGRESS:
case CTRL_READY:
case CTRL_CR:
case CTRL_FAILED_CR:
case CTRL_CR_IN_SUSP:
case CTRL_FAILED_CR_IN_SUSP:
case CTRL_GRR_NC_CCO:
sig_ctrl_cs_check_bsic_ind( rrgrr_check_bsic_ind );
break;
default:
TRACE_ERROR( "RRGRR_CHECK_BSIC_IND unexpected" );
break;
}
PFREE( rrgrr_check_bsic_ind );
}/* ctrl_rrgrr_check_bsic_ind() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_sync_ind
+------------------------------------------------------------------------------
| Description : This function handle the primitive rrgrr_sync_ind
| and checks whether the synchronisation was successfully or not
|
|
|
| Parameters : payload to primitive
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_sync_ind(T_RRGRR_SYNC_IND *rrgrr_sync_ind)
{
UBYTE state = GET_STATE( CTRL );
TRACE_FUNCTION( "ctrl_rrgrr_sync_ind" );
switch( state )
{
case CTRL_RR_CR_IN_SUSP:
case CTRL_AUTO_RR_CR:
if(rrgrr_sync_ind->sync_res EQ SYNC_OK)
{
/*
* Stop TBF etc., if running. We want to start
* to read PSI messages in the new cell
*/
ctrl_stop_rr_task_req( GLBL_PCKT_MODE_IDLE, TASK_STOP_DUMMY_VALUE );
ctrl_send_access_disable_if_needed( TC_DC_OTHER, sig_tc_ctrl_tbf_release_cnf );
grr_set_db_ptr( DB_MODE_CC_REQ );
sig_ctrl_psi_sync_ok();
}
else
{
SET_STATE(CTRL, CTRL_READY);
TRACE_ERROR( "Synchronisation to new NCELL failed" );
}
break;
case CTRL_CR:
case CTRL_CR_IN_SUSP:
grr_set_db_ptr( DB_MODE_CC_REQ );
if(rrgrr_sync_ind->sync_res EQ SYNC_OK)
{
/*
* There is no information about the service state available,
* so we assume that full service is offered,
* GPRS is supported anyway, because PBCCH is present
*/
ctrl_set_gprs_service( GPRS_SUPPORTED, FALSE );
/*
* We want to start
* to read PSI messages in the new cell
*/
ctrl_stop_rr_task_req( GLBL_PCKT_MODE_IDLE, TASK_STOP_DUMMY_VALUE );
sig_ctrl_psi_read_full_psi_in_new_cell();
}
else
{
SET_STATE_FAILED_CR( state );
ctrl_cc_rejected( );
TRACE_ERROR( "Sync to new NCELL failed: new/no candidate" );
}
break;
case CTRL_RR_NC_CCO:
case CTRL_GRR_NC_CCO:
if( rrgrr_sync_ind->sync_res EQ SYNC_OK )
{
/* Start reading psi information on the new cell */
/* sig_ctrl_psi_read_full_psi_in_new_cell( ); */
ctrl_stop_rr_task_req( GLBL_PCKT_MODE_IDLE, TASK_STOP_DUMMY_VALUE );
grr_set_db_ptr( DB_MODE_CC_REQ );
sig_ctrl_psi_sync_ok( );
}
break;
default:
TRACE_ERROR( "RRGRR_SYNC_IND unexpected" );
break;
}
PFREE(rrgrr_sync_ind);
}/* ctrl_rrgrr_sync_ind() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_meas_rep_cnf
+------------------------------------------------------------------------------
| Description : ...
|
| Parameters : payload to primitive
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_meas_rep_cnf( T_RRGRR_MEAS_REP_CNF *rrgrr_meas_rep_cnf )
{
TRACE_FUNCTION( "ctrl_rrgrr_meas_rep_cnf" );
switch( GET_STATE( CTRL ) )
{
case CTRL_IN_PROGRESS:
sig_ctrl_cs_meas_rep_cnf( rrgrr_meas_rep_cnf );
break;
default:
TRACE_ERROR( "RRGRR_MEAS_REP_CNF unexpected" );
break;
}
PFREE( rrgrr_meas_rep_cnf );
}/* ctrl_rrgrr_meas_rep_cnf() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_ext_meas_cnf
+------------------------------------------------------------------------------
| Description : ...
|
| Parameters : payload to primitive
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_ext_meas_cnf ( T_RRGRR_EXT_MEAS_CNF *rrgrr_ext_meas_cnf )
{
TRACE_FUNCTION( "ctrl_rrgrr_ext_meas_cnf" );
switch( GET_STATE( CTRL ) )
{
case CTRL_IN_PROGRESS:
sig_ctrl_meas_ext_meas_cnf( rrgrr_ext_meas_cnf );
break;
default:
TRACE_ERROR( "RRGRR_EXT_MEAS_CNF unexpected" );
break;
}
PFREE( rrgrr_ext_meas_cnf );
}/* ctrl_rrgrr_ext_meas_cnf() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_gmmrr_attach_started_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_ATTACH_STARTED_REQ
|
| Parameters : *gmmrr_attach_started_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_gmmrr_attach_started_req
( T_GMMRR_ATTACH_STARTED_REQ *gmmrr_attach_started_req )
{
TRACE_FUNCTION( "ctrl_gmmrr_attach_started_req" );
grr_handle_non_drx_period( GMM_NDRX, TRUE );
PFREE( gmmrr_attach_started_req );
} /* ctrl_gmmrr_attach_started_req() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_gmmrr_attach_finished_req
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_ATTACH_FINISHED_REQ
|
| Parameters : *gmmrr_attach_finished_req - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_gmmrr_attach_finished_req
( T_GMMRR_ATTACH_FINISHED_REQ *gmmrr_attach_finished_req )
{
TRACE_FUNCTION( "ctrl_gmmrr_attach_finished_req" );
grr_handle_non_drx_period( GMM_NDRX, FALSE );
PFREE( gmmrr_attach_finished_req );
} /* ctrl_gmmrr_attach_finished_req() */
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_ms_id_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive RRGRR_MS_ID_IND
|
| Parameters : *ms_id - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_ms_id_ind(T_RRGRR_MS_ID_IND *ms_id)
{
TRACE_FUNCTION( "ctrl_rrgrr_ms_id_ind" );
grr_data->db.ms_id.tmsi = ms_id->tmsi;
TRACE_EVENT_P1("TMSI: %d", ms_id->tmsi);
PFREE(ms_id);
}/*ctrl_rrgrr_ms_id_ind*/
/*
+------------------------------------------------------------------------------
| Function : ctrl_gmmrr_cell_res
+------------------------------------------------------------------------------
| Description : Handles the primitive GMMRR_CELL_RES
|
| Parameters : *gmmrr_cell_res - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_gmmrr_cell_res ( T_GMMRR_CELL_RES *gmmrr_cell_res )
{
TRACE_FUNCTION( "ctrl_gmmrr_cell_res" );
switch( GET_STATE( CTRL ) )
{
case CTRL_READY:
case CTRL_IN_PROGRESS:
sig_ctrl_tc_enable_grlc(CGRLC_QUEUE_MODE_LLC,gmmrr_cell_res->cu_cause);
grr_data->cell_res_status = TRUE;
break;
case CTRL_RR_NC_CCO:
case CTRL_GRR_NC_CCO:
TRACE_EVENT_P1("NCC ctrl_gmmrr_cell_res: cause is %d", gmmrr_cell_res->cu_cause);
if( grr_t_status( T3174 ) > 0 )
{
TRACE_EVENT("ctrl_gmmrr_cell_res: t3174 is running");
sig_ctrl_tc_enable_grlc(CGRLC_QUEUE_MODE_LLC,gmmrr_cell_res->cu_cause);
}
else
{
TRACE_EVENT("ctrl_gmmrr_cell_res: t3176 is running");
SET_STATE( CTRL,CTRL_IN_PROGRESS );
}
grr_data->cell_res_status = TRUE;
break;
default:
TRACE_ERROR( "GMMRR_CELL_RES unexpected" );
break;
}
PFREE(gmmrr_cell_res);
} /* ctrl_gmmrr_cell_res() */
#ifdef REL99
/*
+------------------------------------------------------------------------------
| Function : ctrl_t_poll_timer
+------------------------------------------------------------------------------
| Description : This is the timer handler. It is started when PCCO/PCCC is received
| with RRBP set
|
|
| Parameters :
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_t_poll_timer()
{
if(grr_data->ctrl.poll_for_msg EQ GRR_PCCO_POLL)
{
ctrl_cell_change_order ( CCO_TYPE_GRR, (void *)&grr_data->ctrl.pcco );
}
grr_data->ctrl.poll_for_msg= 0;
return;
}
#endif
#if defined (REL99) AND defined (TI_PS_FF_EMR)
/*
+------------------------------------------------------------------------------
| Function : ctrl_rrgrr_si2quater_ind
+------------------------------------------------------------------------------
| Description : ...
|
| Parameters : payload to primitive
|
+------------------------------------------------------------------------------
*/
GLOBAL void ctrl_rrgrr_si2quater_ind( T_RRGRR_SI2QUATER_IND
*rrgrr_si2quater_ind )
{
TRACE_FUNCTION( "ctrl_rrgrr_si2quater_ind" );
switch( GET_STATE( CTRL ) )
{
case CTRL_IN_PROGRESS:
sig_ctrl_cs_si2quater_ind( rrgrr_si2quater_ind );
break;
default:
TRACE_ERROR( "RRGRR_SI2QUATER_IND unexpected" );
break;
}
PFREE( rrgrr_si2quater_ind );
}/* ctrl_rrgrr_si2quater_ind() */
#endif
