FreeCalypso > hg > fc-selenite
diff src/g23m-gprs/grr/grr_ctrlp.c @ 1:d393cd9bb723
src/g23m-*: initial import from Magnetite
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sun, 15 Jul 2018 04:40:46 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/g23m-gprs/grr/grr_ctrlp.c Sun Jul 15 04:40:46 2018 +0000 @@ -0,0 +1,1895 @@ +/* ++----------------------------------------------------------------------------- +| 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 + + +