FreeCalypso > hg > fc-magnetite
diff src/g23m-gprs/grr/grr_ctrlf.c @ 183:219afcfc6250
src/g23m-gprs: initial import from TCS3.2/LoCosto
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Thu, 13 Oct 2016 04:24:13 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/g23m-gprs/grr/grr_ctrlf.c Thu Oct 13 04:24:13 2016 +0000 @@ -0,0 +1,3112 @@ +/* ++----------------------------------------------------------------------------- +| Project : GPRS (8441) +| Modul : GRR ++----------------------------------------------------------------------------- +| Copyright 2002 Texas Instruments Berlin, AG +| All rights reserved. +| +| This file is confidential and a trade secret of Texas +| Instruments Berlin, AG +| The receipt of or possession of this file does not convey +| any rights to reproduce or disclose its contents or to +| manufacture, use, or sell anything it may describe, in +| whole, or in part, without the specific written consent of +| Texas Instruments Berlin, AG. ++----------------------------------------------------------------------------- +| Purpose : This module implements local functions for service CTRL of +| entity GRR. ++----------------------------------------------------------------------------- +*/ + +#ifndef GRR_CTRLF_C +#define GRR_CTRLF_C +#endif + +#define ENTITY_GRR + +/*==== INCLUDES =============================================================*/ + +#include "typedefs.h" /* to get Condat data types */ + +#include "vsi.h" /* to get a lot of macros */ +#include "macdef.h" +#include "gprs.h" +#include "gsm.h" /* to get a lot of macros */ +#include "ccdapi.h" /* to get CCD API */ +#include "cnf_grr.h" /* to get cnf-definitions */ +#include "mon_grr.h" /* to get mon-definitions */ +#include "prim.h" /* to get the definitions of used SAP and directions */ +#include "message.h" +#include "grr.h" /* to get the global entity definitions */ +#include "grr_f.h" + +#include "grr_ctrlf.h" /* */ +#include "grr_ctrls.h" + +#include "grr_meass.h" /* */ +#include "grr_pgs.h" /* */ +#include "grr_psis.h" /* */ +#include "grr_css.h" /* */ +#include "grr_tcs.h" /* */ + +#include <string.h> /* for memcpy */ +#include "pcm.h" + +#ifdef _TARGET_ +#include "ffs/ffs.h" +#endif + + + +/*==== CONST ================================================================*/ + +#define BCC_OF_BSIC 7 + +/*==== LOCAL VARS ===========================================================*/ + +/*==== PRIVATE FUNCTIONS ====================================================*/ + +LOCAL void ctrl_set_final_pckt_mode ( void ); +LOCAL BOOL ctrl_set_transient_pckt_mode ( T_GLBL_PCKT_MODE final_pckt_mode, + T_CTRL_TASK *ctrl_task ); +LOCAL void ctrl_enter_pim ( void ); +LOCAL void ctrl_leave_to_pam ( void ); +LOCAL void ctrl_enter_pam ( void ); +LOCAL void ctrl_enter_ptm ( void ); +LOCAL BOOL ctrl_check_cco_freq ( USHORT arfcn ); +/*==== PUBLIC FUNCTIONS =====================================================*/ + + + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_stop_all_activities ++------------------------------------------------------------------------------ +| Description : The function ctrl_stop_all_activities() .... +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_stop_all_activities ( T_CTRL_DISABLE_CAUSE dc, + void *data ) +{ + BOOL is_pbcch_reset_needed = FALSE; + + TRACE_FUNCTION( "ctrl_stop_all_activities" ); + + /* + * inform the service PG + * parameters dc and data are not of interest + */ + sig_ctrl_pg_stop( ); + + /* + * inform the service MEAS + * parameter data is not of interest + */ + switch( dc ) + { + case( CTRL_DC_OTHER ): + case( CTRL_DC_SUSPEND_NORMAL ): + case( CTRL_DC_SUSPEND_IMM_REL ): + case( CTRL_DC_CR_NW_RR ): + case( CTRL_DC_CR_NW_GRR ): + case( CTRL_DC_CR_MS_GRR_NORMAL ): + case( CTRL_DC_PSI_MANAGEMENT ): + case( CTRL_DC_CR_MS_RR_NORMAL ): + case( CTRL_DC_CR_MS_RR_IMM_REL ): + case( CTRL_DC_CR_MS_GRR_ABNORMAL ): + sig_ctrl_meas_stop( ); + break; + + default: + TRACE_EVENT( "FATAL ERROR 1 in ctrl_stop_all_activities" ); + break; + } + + /* + * inform the service CS + */ + switch( dc ) + { + case( CTRL_DC_OTHER ): + vsi_t_stop( GRR_handle, T3174 ); + vsi_t_stop( GRR_handle, T3176 ); +#ifdef _SIMULATION_ + sig_ctrl_cs_simu_timer_stop(); +#endif + + /*lint -fallthrough*/ + + case( CTRL_DC_CR_MS_GRR_NORMAL ): + case( CTRL_DC_CR_MS_GRR_ABNORMAL ): + case( CTRL_DC_PSI_MANAGEMENT ): + case( CTRL_DC_CR_MS_RR_NORMAL ): + case( CTRL_DC_CR_MS_RR_IMM_REL ): + sig_ctrl_cs_stop(CS_DC_OTHER); + break; + + case( CTRL_DC_SUSPEND_NORMAL ): + case( CTRL_DC_SUSPEND_IMM_REL ): + sig_ctrl_cs_stop( CS_DC_DEDICATED ); + break; + + case( CTRL_DC_CR_NW_RR ): + sig_ctrl_cs_cc_order_ind( NULL, (T_D_CHANGE_ORDER *)data ); + break; + + case( CTRL_DC_CR_NW_GRR ): + if (grr_t_status( T3174 ) > 0 ) + { + sig_ctrl_cs_cc_order_ind( (T_D_CELL_CHAN_ORDER *)data, NULL ); + } + else + { + sig_ctrl_cs_stop(CS_DC_OTHER); + } + break; + + default: + TRACE_EVENT( "FATAL ERROR 2 in ctrl_stop_all_activities" ); + break; + } + + /* + * inform the service PSI + * parameter data is not of interest + */ + switch( dc ) + { + case( CTRL_DC_OTHER ): + case( CTRL_DC_CR_MS_RR_NORMAL ): + case( CTRL_DC_CR_MS_RR_IMM_REL ): + case( CTRL_DC_CR_MS_GRR_NORMAL ): + sig_ctrl_psi_stop( ); + + + is_pbcch_reset_needed = TRUE; + break; + + case( CTRL_DC_SUSPEND_NORMAL ): + case( CTRL_DC_SUSPEND_IMM_REL ): + case( CTRL_DC_CR_NW_RR ): + case( CTRL_DC_CR_NW_GRR ): + case( CTRL_DC_CR_MS_GRR_ABNORMAL ): + sig_ctrl_psi_suspend( ); + break; + + case( CTRL_DC_PSI_MANAGEMENT ): + /* do nothing */ + break; + + default: + TRACE_EVENT( "FATAL ERROR 3 in ctrl_stop_all_activities" ); + break; + } + + /* + * inform the service TC + * parameter data is not of interest + */ + switch( dc ) + { + case( CTRL_DC_OTHER ): + case( CTRL_DC_PSI_MANAGEMENT ): + ctrl_send_access_disable_if_needed + ( TC_DC_OTHER, sig_tc_ctrl_tbf_release_cnf ); + break; + + case( CTRL_DC_CR_NW_RR ): + case( CTRL_DC_CR_NW_GRR ): + ctrl_send_access_disable_if_needed + ( TC_DC_CR_NETWORK, sig_tc_ctrl_cr_started_rsp ); + break; + + case( CTRL_DC_CR_MS_RR_NORMAL ): + ctrl_send_access_disable_if_needed + ( TC_DC_CR_NORMAL, sig_tc_ctrl_cr_started_rsp ); + break; + + case( CTRL_DC_CR_MS_RR_IMM_REL ): + case( CTRL_DC_CR_MS_GRR_NORMAL ): + ctrl_send_access_disable_if_needed + ( TC_DC_CR_IMM_REL, sig_tc_ctrl_cr_started_rsp ); + break; + + case( CTRL_DC_CR_MS_GRR_ABNORMAL ): + ctrl_send_access_disable_if_needed + ( TC_DC_CR_ABNORMAL, sig_tc_ctrl_cr_started_rsp ); + break; + + case( CTRL_DC_SUSPEND_NORMAL ): + ctrl_send_access_disable_if_needed + ( TC_DC_SUSPEND_NORMAL, sig_tc_ctrl_suspend_cnf ); + break; + + case( CTRL_DC_SUSPEND_IMM_REL ): + ctrl_send_access_disable_if_needed + ( TC_DC_SUSPEND_IMM_REL, sig_tc_ctrl_suspend_cnf ); + break; + + default: + TRACE_EVENT( "FATAL ERROR 4 in ctrl_stop_all_activities" ); + break; + } + + if( is_pbcch_reset_needed ) + { + grr_set_pbcch( FALSE ); + } +} /* ctrl_stop_all_activities() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_init ++------------------------------------------------------------------------------ +| Description : The function ctrl_init() .... +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_init ( void) +{ + TRACE_FUNCTION( "ctrl_init" ); + + /* init parameters of CTRL*/ + + INIT_STATE( CTRL, CTRL_NULL ); + INIT_STATE( CTRL_GLBL, GLBL_PCKT_MODE_NULL ); + + grr_data->ctrl.new_cell_responded = FALSE; + grr_data->ctrl.psi_tbf_rel_cause = CTRL_PTRC_NONE; + grr_data->ctrl_glbl.ctrl_task = CTRL_TASK_NONE; + +#ifdef _SIMULATION_ + + TRACE_EVENT_P1( "ctrl_init - ctrl_task: %d", grr_data->ctrl_glbl.ctrl_task ); + +#endif /* #ifdef _SIMULATION_ */ + + grr_data->ctrl.rr_state.monitoring_stopped = FALSE; + grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_NONE; + + ctrl_read_pcm(); + +} /* ctrl_init() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_start_monitoring_bcch ++------------------------------------------------------------------------------ +| Description : The function ctrl_start_monitoring_bcch() This function starts +| reading System Information (SI) on BCCH +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_start_monitoring_bcch ( UBYTE si_to_read ) +{ + TRACE_FUNCTION( "ctrl_start_monitoring_bcch" ); + + { + PALLOC( rrgrr_start_mon_bcch_req, RRGRR_START_MON_BCCH_REQ ); + + rrgrr_start_mon_bcch_req->si_to_read = psc_db->si_to_acquire = si_to_read; + + PSEND( hCommRR, rrgrr_start_mon_bcch_req ); + } +} /* ctrl_start_monitoring_bcch() */ + + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_stop_monitoring_ccch ++------------------------------------------------------------------------------ +| Description : The function ctrl_stop_monitoring_ccch() This function stops +| monitoring CCCH +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_stop_monitoring_ccch ( void ) +{ + TRACE_FUNCTION( "ctrl_stop_monitoring_ccch" ); + + if(!grr_data->ctrl.rr_state.monitoring_stopped OR (grr_data->test_mode NEQ CGRLC_NO_TEST_MODE)) + { + PALLOC ( rrgrr_stop_mon_ccch_req, RRGRR_STOP_MON_CCCH_REQ); + rrgrr_stop_mon_ccch_req->is_pbcch_present = grr_is_pbcch_present(); + PSEND (hCommRR, rrgrr_stop_mon_ccch_req); + } + grr_data->ctrl.rr_state.monitoring_stopped = TRUE; +} /* ctrl_stop_monitoring_ccch() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_start_monitoring_ccch ++------------------------------------------------------------------------------ +| Description : The function ctrl_start_monitoring_ccch() This function starts +| monitoring CCCH +| +| Parameters : pag_mode : indicates the page, which shall be uese by RR/L1 +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_start_monitoring_ccch ( UBYTE pag_mode ) +{ + TRACE_FUNCTION( "ctrl_start_monitoring_ccch" ); + + { + PALLOC ( rrgrr_start_mon_ccch_req, RRGRR_START_MON_CCCH_REQ); + rrgrr_start_mon_ccch_req->pag_mode = pag_mode; +#if defined (REL99) AND defined (TI_PS_FF_EMR) +#else + rrgrr_start_mon_ccch_req->split_pg = grr_data->ms.split_pg_cycle; +#endif + PSEND (hCommRR, rrgrr_start_mon_ccch_req); + } + grr_data->ctrl.rr_state.monitoring_stopped = FALSE; +} /* ctrl_start_monitoring_ccch() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_send_rr_est_req ++------------------------------------------------------------------------------ +| Description : The function ctrl_send_rr_est_req() .... +| +| Parameters : UBYTE susp_req: whether RR needs to send +| GPRS Suspension Request or not +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_send_rr_est_req ( UBYTE susp_req) +{ + TRACE_FUNCTION( "ctrl_send_rr_est_req" ); + { + PALLOC ( rrgrr_rr_est_req, RRGRR_RR_EST_REQ); + + if(psc_db->v_non_gprs_opt EQ TRUE) + { + rrgrr_rr_est_req->non_gprs.v_non_gprs = TRUE; + + /* Copy non GPRS options */ + ctrl_copy_non_gprs_opt(&rrgrr_rr_est_req->non_gprs); + } + else + rrgrr_rr_est_req->non_gprs.v_non_gprs = FALSE; + + rrgrr_rr_est_req->ch_needed = grr_data->pg.ch_needed; + + rrgrr_rr_est_req->emlpp_prio.v_emlpp = grr_data->pg.v_emlpp_prio; + rrgrr_rr_est_req->emlpp_prio.emlpp = grr_data->pg.emlpp_prio; + + rrgrr_rr_est_req->susp_req = susp_req; + + rrgrr_rr_est_req->ident_type = grr_data->pg.type; /* IMSI TMSI ??*/ + + PSEND (hCommRR, rrgrr_rr_est_req); + } +} /* ctrl_send_rr_est_req() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_send_rr_est_rsp ++------------------------------------------------------------------------------ +| Description : The function ctrl_send_rr_est_rsp() .... +| Informs the RR whether the RR connection should be established or not! +| Parameters : UBYTE susp_req: Suspension request needed or not +| UBYTE rsp: CS_PAGE was accepted or not +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_send_rr_est_rsp ( UBYTE susp_req, UBYTE rsp ) +{ + TRACE_FUNCTION( "ctrl_send_rr_est_rsp" ); + { + PALLOC(rrgrr_rr_est_rsp, RRGRR_RR_EST_RSP); + + rrgrr_rr_est_rsp->rr_est = (rsp EQ GMMRR_CS_PAGE_REJ) ? RR_EST_NOT_ALLOWED : RR_EST_ALLOWED; + + rrgrr_rr_est_rsp->susp_req = susp_req; + + PSEND(hCommRR, rrgrr_rr_est_rsp); + } +}/* ctrl_send_rr_est_rsp*/ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_suspend_services ++------------------------------------------------------------------------------ +| Description : The function ctrl_suspend_services() .... +| This function suspends working services in GRR +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_suspend_services ( UBYTE susp_cause ) +{ + TRACE_FUNCTION( "ctrl_suspend_services" ); + + if(susp_cause EQ GMMRR_ABNORMAL_RELEASE) + ctrl_stop_all_activities( CTRL_DC_SUSPEND_IMM_REL, NULL ); + else + ctrl_stop_all_activities( CTRL_DC_SUSPEND_NORMAL, NULL ); + +}/* ctrl_suspend_services*/ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_suspend_services ++------------------------------------------------------------------------------ +| Description : The function ctrl_copy_non_gprs_opt() .... +| Copies the stored non-GPRS options into the given structure +| Parameters : p_non_gprs_opt: Pointer to the structure for non-GPRS access; derived from +| RRGRR.doc +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_copy_non_gprs_opt( T_non_gprs *p_non_gprs_opt) +{ + + TRACE_FUNCTION( "ctrl_copy_non_gprs_opt" ); + + /* Copy non GPRS options */ + p_non_gprs_opt->att = psc_db->non_gprs_opt.att; /*< 0> Attach / detach allowed */ + + p_non_gprs_opt->v_T3212 = psc_db->non_gprs_opt.v_t3212; /*< 1> valid-flag */ + p_non_gprs_opt->T3212 = psc_db->non_gprs_opt.t3212; /*< 2> T 3212 time-out value */ + + p_non_gprs_opt->neci = psc_db->non_gprs_opt.neci; /*< 3> Half rate support */ + p_non_gprs_opt->pwrc = psc_db->non_gprs_opt.pwcr; /*< 4> Power Control */ + p_non_gprs_opt->dtx = psc_db->non_gprs_opt.dtx; /*< 5> Discontinuous Transmission (BCCH) */ + p_non_gprs_opt->radio_link_timeout = psc_db->non_gprs_opt.rl_timeout; /*< 6> Radio Link Timeout */ + p_non_gprs_opt->bs_ag_blks_res = psc_db->non_gprs_opt.bs_ag_blks_res; /*< 7> BS_AG_BLKS_RES */ + p_non_gprs_opt->ccch_conf = psc_db->non_gprs_opt.ccch_conf; /*< 8> CCCF-CONF */ + p_non_gprs_opt->bs_pa_mfrms = psc_db->non_gprs_opt.bs_pa_mfrms; /*< 9> BS-PA-MFRMS */ + p_non_gprs_opt->max_retrans = psc_db->non_gprs_opt.max_retrans; /*< 10> MAX_RETRANS */ + p_non_gprs_opt->tx_integer = psc_db->non_gprs_opt.tx_integer; /*< 11> TX_INTEGER */ + p_non_gprs_opt->ec = psc_db->non_gprs_opt.ec; /*< 12> EC */ + p_non_gprs_opt->gprs_ms_txpwr_max_cch = psc_db->non_gprs_opt.txpwr_max_cch; /*< 13> GPRS_MS_TXPWR_MAX_CCH */ + +#ifdef REL99 + /* copy non GPRS extension information */ + if( (psc_db->non_gprs_opt.v_non_gprs_ext_bits EQ TRUE) AND + (psc_db->non_gprs_opt.non_gprs_ext_bits.ext_len) ) + { + /* copy Early classmark sending control flag from GRR database */ + p_non_gprs_opt->ecsc = + psc_db->non_gprs_opt.non_gprs_ext_bits.non_gprs_ext_info.ecsc; + } + else + { + p_non_gprs_opt->ecsc = ECS_ALLOWED; + } +#endif + +}/* ctrl_copy_non_gprs_opt*/ + + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_is_gprs_suspension_request_needed ++------------------------------------------------------------------------------ +| Description : The function ctrl_is_gprs_suspension_request_needed() .... +| checks whether MS has to send GPRS Suspension Request to the network +| or not +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL BOOL ctrl_is_gprs_suspension_request_needed( void) +{ + TRACE_FUNCTION( "ctrl_is_gprs_suspension_request_needed" ); + + if( + (psc_db->cell_info_for_gmm.cell_info.net_mode NEQ GMMRR_NET_MODE_III) + AND + ( +/* BEGIN GRR_NMO_III*/ + (grr_data->ms.class_of_mode EQ GMMRR_CLASS_B) OR +/* END GRR_NMO_III*/ + (grr_data->ms.class_of_mode EQ GMMRR_CLASS_BC) OR + (grr_data->ms.class_of_mode EQ GMMRR_CLASS_BG) + ) + ) + { + /* We have to suspend GPRS activities on the network side, because of MS + * is not able to handle GPRS activities during the dedicated mode of operations + */ + return TRUE; + } + return FALSE; +}/* ctrl_is_gprs_suspension_request_needed*/ + + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_get_number_of_digits ++------------------------------------------------------------------------------ +| Description : The function ctrl_get_number_of_digits() .... +| gets the number of valid digits in the array e.g. IMSI digits +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL UBYTE ctrl_get_number_of_digits( UBYTE *digits) +{ + UBYTE i = 0; + + TRACE_FUNCTION ("ctrl_get_number_of_digits"); + + while (digits[i] < 0x0A AND i < 16) + i++; + + return i; +}/* ctrl_get_number_of_digits*/ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_send_cell_reselection_req ++------------------------------------------------------------------------------ +| Description : The function ctrl_send_cell_reselection_req() .... +| Prepares the cell reselection parameters for RR +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_send_cell_reselection_req ( UBYTE cr_type ) +{ + TRACE_FUNCTION( "ctrl_send_cell_reselection_req" ); + + switch( cr_type ) + { + case( CR_NEW ): + case( CR_NEW_NOT_SYNCED ): + { + ctrl_stop_rr_task_req( GLBL_PCKT_MODE_NULL, TASK_STOP_DUMMY_VALUE ); + + grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_COMPLETE; + + if( grr_data->ctrl.parked_rrgrr_cr_ind EQ TRUE ) + { + ctrl_handle_parked_rrgrr_cr_ind( GET_STATE( CTRL ) ); + } + else + { + PALLOC( rrgrr_cr_req, RRGRR_CR_REQ ); + + rrgrr_cr_req->cr_type = cr_type; + + if( grr_t_status( T3176 ) > 0 ) + { + /*TRACE_ASSERT( posc_db NEQ NULL );*/ + + rrgrr_cr_req->arfcn = grr_data->ctrl.old_arfcn; + rrgrr_cr_req->bsic = grr_data->ctrl.old_bsic; + } + else + { + T_NC_MVAL *nc_mval; + + nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx]; + + rrgrr_cr_req->arfcn = nc_mval->arfcn; + rrgrr_cr_req->bsic = nc_mval->sync_info.bsic; + } + + TRACE_EVENT_P3( "RRGRR_CR_REQ: %d %d %d", + rrgrr_cr_req->cr_type, + rrgrr_cr_req->arfcn, + rrgrr_cr_req->bsic ); + + PSEND( hCommRR, rrgrr_cr_req ); + } + } + break; + + case( CR_COMPLETE ): + { + switch( grr_data->ctrl.rr_state.cr_ind_return ) + { + case( CR_IND_RETURN_NONE ): + { + TRACE_EVENT( "RRGRR_CR_REQ: CR_IND_RETURN_NONE" ); + } + break; + + case( CR_IND_RETURN_RESPONSE ): + { + PALLOC( cr_rsp, RRGRR_CR_RSP ); + + TRACE_EVENT( "RRGRR_CR_RSP: CR_IND_RETURN_RESPONSE" ); + + PSEND( hCommRR, cr_rsp ); + + ctrl_stop_rr_task_req( GLBL_PCKT_MODE_NULL, TASK_STOP_DUMMY_VALUE ); + + grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_COMPLETE; + } + break; + + case( CR_IND_RETURN_COMPLETE ): + { + PALLOC( rrgrr_cr_req, RRGRR_CR_REQ ); + + rrgrr_cr_req->cr_type = cr_type; + rrgrr_cr_req->arfcn = 0; + rrgrr_cr_req->bsic = 0; + + TRACE_EVENT_P1( "RRGRR_CR_REQ: %d", rrgrr_cr_req->cr_type ); + + PSEND( hCommRR, rrgrr_cr_req ); + + grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_NONE; + } + break; + + default: + { + TRACE_ASSERT + ( grr_data->ctrl.rr_state.cr_ind_return EQ CR_IND_RETURN_NONE OR + grr_data->ctrl.rr_state.cr_ind_return EQ CR_IND_RETURN_RESPONSE OR + grr_data->ctrl.rr_state.cr_ind_return EQ CR_IND_RETURN_COMPLETE ); + } + break; + } + } + break; + + case( CR_CS ): + { + ctrl_stop_rr_task_req( GLBL_PCKT_MODE_NULL, TASK_STOP_DUMMY_VALUE ); + } + + /*lint -fallthrough*/ + + case( CR_CONT ): + { + PALLOC( rrgrr_cr_req, RRGRR_CR_REQ ); + + rrgrr_cr_req->cr_type = cr_type; + + TRACE_EVENT_P1( "RRGRR_CR_REQ: %d", rrgrr_cr_req->cr_type ); + + PSEND( hCommRR, rrgrr_cr_req ); + + grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_COMPLETE; + } + break; + + default: + { + TRACE_ASSERT( cr_type EQ CR_NEW OR + cr_type EQ CR_NEW_NOT_SYNCED OR + cr_type EQ CR_COMPLETE OR + cr_type EQ CR_CONT OR + cr_type EQ CR_CS ); + } + break; + } +}/* ctrl_send_cell_reselection_req */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_enable_serving_cell ++------------------------------------------------------------------------------ +| Description : The function ctrl_enable_serving_cell() .... +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_enable_serving_cell( UBYTE final ) +{ + TRACE_FUNCTION( "ctrl_enable_serving_cell" ); + + if( final ) + { + ctrl_install_new_scell( ); + } + +#ifdef REL99 + /* Update SGSN release in the common library */ + cl_nwrl_set_sgsn_release(psc_db->sgsn_rel); +#endif + + ctrl_send_cell_ind(); + + sig_ctrl_pg_start(); + + sig_ctrl_cs_pim(); + + sig_ctrl_cs_start( ); + + sig_ctrl_meas_pim( ); + + sig_ctrl_meas_start( ); + + ctrl_tc_access_enable( sig_ctrl_tc_disable_prim_queue ); + +}/* ctrl_enable_serving_cell */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_install_new_scell ++------------------------------------------------------------------------------ +| Description : The function ctrl_install_new_scell() .... +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_install_new_scell( void ) +{ + TRACE_FUNCTION( "ctrl_install_new_scell" ); + + if( ctrl_get_gprs_service( ) NEQ GPRS_SERVICE_NONE ) + { + sig_ctrl_cs_install_new_scell( ); + } + + sig_ctrl_cs_cc_result( TRUE ); + +}/* ctrl_install_new_scell */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_reinstall_old_scell_req ++------------------------------------------------------------------------------ +| Description : The function ctrl_reinstall_old_scell_req() .... +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_reinstall_old_scell_req( BOOL is_pcco, UBYTE cause ) +{ + TRACE_FUNCTION( "ctrl_reinstall_old_scell_req" ); + + if( grr_get_db_mode( ) EQ DB_MODE_CC_REQ ) + { + ctrl_stop_all_activities( CTRL_DC_OTHER, NULL ); + } + + ctrl_send_reconnect_dcch_req( cause ); + +}/* ctrl_reinstall_old_scell_req */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_reinstall_old_scell_cnf ++------------------------------------------------------------------------------ +| Description : The function ctrl_reinstall_old_scell_cnf() .... +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_reinstall_old_scell_cnf( BOOL is_success ) +{ + TRACE_FUNCTION( "ctrl_reinstall_old_scell_cnf" ); + + if( is_success ) + { + ctrl_cc_rejected( ); + } + else + { + grr_set_db_ptr( DB_MODE_CC_REJ ); + + /* + * service PSI is still suspended, we have to stop it finally + */ + sig_ctrl_psi_stop( ); + /* grr_set_pbcch( FALSE ); */ + } +}/* ctrl_reinstall_old_scell_cnf */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_send_cell_ind ++------------------------------------------------------------------------------ +| Description : ctrl_send_cell_ind: composes and sends a GMMRR_CELL_IND message +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_send_cell_ind() +{ + TRACE_FUNCTION( "ctrl_send_cell_ind" ); + { + PALLOC(gmmrr_cell_ind, GMMRR_CELL_IND); + + grr_set_cell_info_service( ); + + memcpy( &gmmrr_cell_ind->cell_info, + &psc_db->cell_info_for_gmm.cell_info, + sizeof( T_cell_info ) ); + +#if !defined (NTRACE) + + if( grr_data->cs.v_crp_trace EQ TRUE ) + { + TRACE_EVENT_P9( "CELL_ENV: %x%x%x %x%x%x %x %x %x", + gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mcc[0], + gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mcc[1], + gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mcc[2], + gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mnc[0], + gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mnc[1], + gmmrr_cell_ind->cell_info.cell_env.rai.plmn.mnc[2], + gmmrr_cell_ind->cell_info.cell_env.rai.lac, + gmmrr_cell_ind->cell_info.cell_env.rai.rac, + gmmrr_cell_ind->cell_info.cell_env.cid ); + } + +#endif /* #if !defined (NTRACE) */ + grr_data->cell_res_status = FALSE; + PSEND(hCommGMM, gmmrr_cell_ind); + } +}/*ctrl_send_cell_ind */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_init_params ++------------------------------------------------------------------------------ +| Description : ctrl_init_params initializes the parameters of the CTRL service +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_init_params() +{ + TRACE_FUNCTION( "ctrl_init_params" ); + + grr_data->ctrl.imm_rel = 0; + grr_data->cc_running = FALSE; + grr_data->pcco_failure_cause = 8; + +}/* ctrl_init_params */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_copy_pbcch_des_from_ncell ++------------------------------------------------------------------------------ +| Description : Copies pbcch description from the ncell description to a +| specific database +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_copy_pbcch_des_from_ncell( T_SC_DATABASE *db ) +{ + T_NC_MVAL *nc_mval; + T_ncell_info *ncell_info; + + nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx]; + ncell_info = grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic ); + + TRACE_FUNCTION( "ctrl_copy_pbcch_des_from_ncell" ); + + if( ncell_info NEQ NULL ) + { + db->pbcch.pbcch_des.pb = 0; + db->pbcch.pbcch_des.tn = ncell_info->cr_par.si13_pbcch.pbcch_location; + + /* + * for broadcast and common control channels, the TSC must be equal to BCC + */ + db->pbcch.pbcch_des.tsc = ncell_info->bsic & BCC_OF_BSIC; + + /* + * to indicate that the arfcn of the BCCH carrier should be used + */ + db->pbcch.pbcch_des.flag = 0; + db->pbcch.pbcch_des.v_flag2 = 0; + db->pbcch.pbcch_des.flag2 = 0; + + db->pbcch.bcch.arfcn = ncell_info->arfcn; + db->pbcch.bcch.bsic = ncell_info->bsic; + db->pbcch.bcch.pbcch_present = TRUE; + + db->pccch.bs_pbcch_blks = 0; + + db->psi1_params.psi1_repeat_period + = ncell_info->cr_par.si13_pbcch.psi1_repeat_period; + } + else + { + TRACE_ERROR( "ctrl_copy_pbcch_des_from_ncell: ncell_info EQ NULL" ); + } +}/*ctrl_copy_pbcch_des_from_ncell*/ + + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_sync_to_given_cell() ++------------------------------------------------------------------------------ +| Description : This function starts synchronisation to the given cell +| neighbour cell +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_sync_to_given_cell ( void ) +{ + T_NC_MVAL *nc_mval; + T_ncell_info *ncell_info; + + TRACE_FUNCTION( "ctrl_sync_to_given_cell" ); + + nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx]; + ncell_info = grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic ); + + if( ncell_info NEQ NULL ) + { + ctrl_stop_rr_task_req( GLBL_PCKT_MODE_SYNC, TASK_STOP_DUMMY_VALUE ); + + grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_COMPLETE; + + if( grr_data->ctrl.parked_rrgrr_cr_ind EQ TRUE ) + { + ctrl_handle_parked_rrgrr_cr_ind( GET_STATE( CTRL ) ); + } + else + { + PALLOC( rrgrr_sync_req, RRGRR_SYNC_REQ ); + + rrgrr_sync_req->arfcn = ncell_info->arfcn; + rrgrr_sync_req->bsic = ncell_info->bsic; + + PSEND( hCommRR, rrgrr_sync_req ); + } + + } + else + { + TRACE_ERROR( "ctrl_sync_to_given_cell: ncell_info EQ NULL" ); + } +} /* ctrl_sync_to_given_cell */ + + + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_stop_T3174 ++------------------------------------------------------------------------------ +| Description : The function stops T3174 when running. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_stop_T3174 ( void ) +{ + TRACE_FUNCTION( "ctrl_stop_T3174" ); + + TRACE_EVENT( "T3174 for packet cell change stopped" ); + + vsi_t_stop( GRR_handle, T3174 ); + +} /* ctrl_stop_T3174 */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_send_access_disable_if_needed() ++------------------------------------------------------------------------------ +| Description : The function sends access disabled signal to TC, if needed +| +| Parameters : dc - disable cause +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_send_access_disable_if_needed + ( T_TC_DISABLE_CAUSE disable_cause, + T_TC_DISABLE_CALLBACK_FUNC callback_func ) +{ + TRACE_FUNCTION( "ctrl_send_access_disable_if_needed" ); + + psc_db->is_access_enabled = FALSE; + + sig_ctrl_tc_access_disable( disable_cause, callback_func ); + +} /* ctrl_send_access_disable_if_needed() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_copy_cell_env() ++------------------------------------------------------------------------------ +| Description : +| Parameters : ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_copy_cell_env( T_cell_env *cell_env, + T_serving_cell_info *scell_info ) +{ + TRACE_FUNCTION( "ctrl_copy_cell_env" ); + + psc_db->pbcch.bcch.arfcn = scell_info->bcch_arfcn; + psc_db->pbcch.bcch.bsic = scell_info->bcch_bsic; + + cell_env->rai.plmn = scell_info->rr_cell_env.plmn; + cell_env->rai.lac = scell_info->rr_cell_env.lac; + cell_env->cid = scell_info->rr_cell_env.cid; + +#ifdef _SIMULATION_ + + TRACE_EVENT_P2( "ctrl_copy_cell_env - SCELL: %d %d", + psc_db->pbcch.bcch.arfcn, psc_db->pbcch.bcch.bsic ); + +#endif /* #ifdef _SIMULATION_ */ + +} /* ctrl_copy_cell_env */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_copy_scell_params() ++------------------------------------------------------------------------------ +| Description : This function copies some serving cell specific parameters into +| database of GRR +| +| Parameters : sc_inf: pointer to serving cell information +| ++------------------------------------------------------------------------------ +*/ +GLOBAL BOOL ctrl_copy_scell_params( T_serving_cell_info *sc_inf ) +{ + BOOL ba_bcch_changed = FALSE; + + TRACE_FUNCTION("ctrl_copy_scell_params"); + + psc_db->scell_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch + = sc_inf->gprs_ms_txpwr_max_cch; + psc_db->prach.ac_class = sc_inf->ac_class; + + ctrl_copy_cell_env( &psc_db->cell_info_for_gmm.cell_info.cell_env, sc_inf ); + + grr_data->meas.pwr_offset = sc_inf->pwr_offset; + psc_db->net_ctrl.bs_pa_mfrms = sc_inf->bs_pa_mfrms; + + if(sc_inf->arfcn[0] EQ RRGRR_INVALID_ARFCN) + { + TRACE_EVENT("No BA list sent with SI13 info"); + return ba_bcch_changed; + } +#if defined (REL99) AND defined (TI_PS_FF_EMR) +/* Copy ba_ind of the NC list */ + if(sc_inf->ba_ind NEQ psc_db->ba_ind) + { + grr_init_ba_bcch_nc_list(psc_db); + psc_db->ba_ind = sc_inf->ba_ind; + } +#endif + + if( grr_t_status( T3176 ) > 0 ) + { + TRACE_EVENT + ( "ctrl_copy_scell_params: packet cell change order - do not delete psc_db->nc_cw.list.number" ); + } + else + { + UBYTE i = 0; /* used for counting */ + + while( i < RRGRR_BA_LIST_SIZE AND + i < MAX_NR_OF_NCELL AND + sc_inf->arfcn[i] NEQ RRGRR_INVALID_ARFCN ) + { + if( psc_db->nc_cw.list.info[i].index NEQ i OR + psc_db->nc_cw.list.info[i].arfcn NEQ sc_inf->arfcn[i] OR + psc_db->nc_cw.list.info[i].bsic NEQ RRGRR_INVALID_BSIC ) + { + psc_db->nc_cw.list.info[i].index = i; + psc_db->nc_cw.list.info[i].arfcn = sc_inf->arfcn[i]; + psc_db->nc_cw.list.info[i].bsic = RRGRR_INVALID_BSIC; + + NC_SET_TYPE ( psc_db->nc_cw.list.info[i].info_src, INFO_TYPE_BA_BCCH ); + NC_SET_INSTANCE( psc_db->nc_cw.list.info[i].info_src, 0 ); + NC_SET_NUMBER ( psc_db->nc_cw.list.info[i].info_src, 0 ); + + ba_bcch_changed = TRUE; + } + + i++; + } + + if( psc_db->nc_cw.list.number NEQ i ) + { + psc_db->nc_cw.list.number = i; + ba_bcch_changed = TRUE; + } + } + + grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param = TRUE; + grr_data->pwr_ctrl_valid_flags.v_freq_param = TRUE; + + return( ba_bcch_changed ); + +}/* ctrl_copy_scell_params */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_cell_change_order ++------------------------------------------------------------------------------ +| Description : Start processing packet cell change order or cell change order +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_cell_change_order ( T_CTRL_CCO_TYPE type, void *data ) +{ + T_NC_MVAL *nc_mval; + + TRACE_FUNCTION("ctrl_cell_change_order"); + TRACE_EVENT("ctrl_cell_change_order_started");/*to show the trace on target*/ + + switch( type ) + { + case( CCO_TYPE_RR ): + { + T_D_CHANGE_ORDER *d_change_order = (T_D_CHANGE_ORDER *)data; + + SET_STATE(CTRL,CTRL_RR_NC_CCO); /* set network commanded cell change order */ + + ctrl_stop_all_activities( CTRL_DC_CR_NW_RR, d_change_order ); + + grr_init_db( pcr_db ); + + /* process BCCH ARFCN and BSIC */ + pcr_db->pbcch.bcch.arfcn = + ((USHORT)d_change_order->cell_desc.bcch_arfcn_hi << 8) + + (USHORT)d_change_order->cell_desc.bcch_arfcn_lo; + pcr_db->pbcch.bcch.bsic = + (d_change_order->cell_desc.ncc << 3) + + d_change_order->cell_desc.bcc; + + /* process state variable */ + grr_data->cc_running = TRUE; + + vsi_t_start(GRR_handle,T3134,T3134_VALUE); + } + break; + + case( CCO_TYPE_GRR ): + { + T_D_CELL_CHAN_ORDER *d_cell_chan_order = ( T_D_CELL_CHAN_ORDER *)data; + + grr_data->ctrl.pcc_arfcn = d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.arfcn; + grr_data->ctrl.pcc_bsic = d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.bsic;; + grr_data->ctrl.old_arfcn = psc_db->pbcch.bcch.arfcn; + grr_data->ctrl.old_bsic = psc_db->pbcch.bcch.bsic ; + + TRACE_EVENT_P2("ctrl_cell_change_order:commanded cell is arfcn:%d ,bsic:%d", + d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.arfcn, + d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.bsic); + + if( grr_data->cs.gmm_state EQ STANDBY_STATE ) + { + TRACE_EVENT("ctrl_cell_change_order:GMM in STANDBY state"); + grr_data->pcco_failure_cause = 5;/*MS in GMM standby mode*/ + ctrl_build_pcco_failure_msg(grr_data->ctrl.pcc_arfcn, grr_data->ctrl.pcc_bsic); + + } + else + if (ctrl_check_cco_freq(grr_data->ctrl.pcc_arfcn)) + { + SET_STATE( CTRL, CTRL_GRR_NC_CCO ); + ctrl_start_T3174( ); + sig_ctrl_cs_check_cell_location + ( d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.arfcn, + d_cell_chan_order->tgt_cell_gsm_info.gsm_target_cell.bsic); + + nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx]; + + /* ncell_info = grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic ); */ + + grr_data->ctrl.imm_rel = d_cell_chan_order->tgt_cell_gsm_info.im_rel_c0; + + ctrl_stop_all_activities( CTRL_DC_CR_NW_GRR, d_cell_chan_order ); + + grr_init_db( pcr_db ); + + pcr_db->pbcch.bcch.arfcn = nc_mval->arfcn; + pcr_db->pbcch.bcch.bsic = nc_mval->sync_info.bsic; + } + else + { + TRACE_EVENT("ctrl_cell_change_order:frequency not implemented"); + grr_data->pcco_failure_cause = 0;/*Freq_Not_Impl*/ + ctrl_build_pcco_failure_msg(grr_data->ctrl.pcc_arfcn, grr_data->ctrl.pcc_bsic); + } + } + break; + } +}/* ctrl_cell_change_order */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_send_reconnect_dcch_req ++------------------------------------------------------------------------------ +| Description : This is only to be sent when cell change failure occures +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_send_reconnect_dcch_req ( UBYTE cause ) +{ + TRACE_FUNCTION( "ctrl_send_reconnect_dcch_req" ); + + { + PALLOC( rrgrr_reconnect_dcch_req, RRGRR_RECONNECT_DCCH_REQ ); + + rrgrr_reconnect_dcch_req->reconn_cause = cause; + + PSEND( hCommRR, rrgrr_reconnect_dcch_req ); + } +}/* ctrl_send_reconnect_dcch_req */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_si13_received ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_si13_received( T_RRGRR_GPRS_SI13_IND * rrgrr_si13_ind ) +{ + BOOL ba_bcch_changed; + + TRACE_FUNCTION( "ctrl_si13_received" ); + + ctrl_set_gprs_service( rrgrr_si13_ind->cause, + rrgrr_si13_ind->serving_cell_info.limited ); + + ba_bcch_changed = ctrl_copy_scell_params( &rrgrr_si13_ind->serving_cell_info ); + + if( rrgrr_si13_ind->cause EQ GPRS_SUPPORTED ) + { + sig_ctrl_psi_si13_received( rrgrr_si13_ind, ba_bcch_changed ); + } + + grr_cgrlc_pwr_ctrl_req( FALSE ); + +}/* ctrl_si13_received */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_cc_rejected ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_cc_rejected ( void ) +{ + TRACE_FUNCTION( "ctrl_cc_rejected" ); + + grr_set_db_ptr( DB_MODE_CC_REJ ); + + if( grr_data->ctrl.parked_rrgrr_cr_ind EQ TRUE ) + { + sig_ctrl_cs_cc_result( TRUE ); + } + else + { + sig_ctrl_cs_cc_result( FALSE ); + } +}/* ctrl_cc_rejected */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_failure_processing ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_failure_processing ( T_FAILURE_SIGNAL fail_sig ) +{ + UBYTE state = GET_STATE( CTRL ); + + TRACE_FUNCTION( "ctrl_failure_processing" ); + + TRACE_EVENT_P1( "ctrl_failure_processing: failure signal %d", fail_sig ); + + switch( state ) + { + case CTRL_READY_TO_PROGRESS: + if (grr_data->db.old_scell.pbcch_present EQ TRUE) + { + grr_set_db_ptr( DB_MODE_CC_REJ ); + sig_ctrl_cs_reselect( CS_RESELECT_CAUSE_CTRL_NORMAL ); + } + else + { + /* The old cell is without PBBCH */ + ctrl_send_cell_reselection_req( CR_CONT ); + } + break; + + case CTRL_READY: + case CTRL_ACCESS_DISABLED: + case CTRL_IN_PROGRESS: + if (fail_sig EQ FAIL_SIG_DSF_IND) + { + sig_ctrl_cs_reselect( CS_RESELECT_CAUSE_CTRL_DL_SIG_FAIL ); + } + else + { + sig_ctrl_cs_reselect( CS_RESELECT_CAUSE_CTRL_NORMAL ); + } + break; + + case CTRL_RR_CR_IN_SUSP: + case CTRL_AUTO_RR_CR: + ctrl_send_cell_reselection_req( CR_CONT ); + break; + + case CTRL_CR: + case CTRL_CR_IN_SUSP: + SET_STATE_FAILED_CR( state ); + + ctrl_cc_rejected( ); + break; + + case CTRL_RR_NC_CCO: + SET_STATE( CTRL, CTRL_IN_PROGRESS ); + + ctrl_reinstall_old_scell_req( FALSE, RECONN_NO_ACTIVITY ); + break; + case CTRL_GRR_NC_CCO: + if ( grr_t_status(T3174) > 0) + { + ctrl_stop_T3174(); + } + ctrl_pcco_failure( ); + break; + + default: + TRACE_ERROR( "ctrl_failure_processing: failure signal unexpected" ); + break; + } +} /* ctrl_failure_processing */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_pcco_failure ++------------------------------------------------------------------------------ +| Description : Handles the internal signal ctrl_pcco_failure +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ + +GLOBAL void ctrl_pcco_failure(void) +{ + TRACE_ISIG( "ctrl_pcco_failure" ); + + vsi_t_start( GRR_handle, T3176, T3176_VALUE ); + + TRACE_EVENT( "ctrl_pcco_failure:T3176 started." ); + + ctrl_stop_all_activities( CTRL_DC_CR_NW_GRR, NULL ); + +} /* ctrl_pcoo_failure */ + + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_build_pcco_failure_msg ++------------------------------------------------------------------------------ +| Description : The function is to send packet cell change failure message +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_build_pcco_failure_msg(USHORT arfcn, UBYTE bsic) +{ + TRACE_FUNCTION( "ctrl_build_pcco_failure_msg" ); + TRACE_EVENT("ctrl_build_pcco_failure_msg"); + { + T_U_CELL_CHAN_FAILURE u_cell_chan_failure; + + u_cell_chan_failure.msg_type = U_CELL_CHAN_FAILURE_c; + + grr_set_buf_tlli( &u_cell_chan_failure.tlli_value, grr_get_tlli( ) ); + + u_cell_chan_failure.arfcn = arfcn; + u_cell_chan_failure.bsic = bsic; + u_cell_chan_failure.failure_cause = grr_data->pcco_failure_cause; + + TRACE_EVENT_P2("ctrl_build_pcco_failure_msg: pcc_arfcn = %1d,pcc_bsic = %1d", arfcn,bsic); + + ctrl_send_control_block( CGRLC_BLK_OWNER_CTRL, (void*)(&u_cell_chan_failure) ); + } +} /*ctrl_build_pcco_failure_msg */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_send_control_block ++------------------------------------------------------------------------------ +| Description : This function is used to signal service TC the request for +| sending a control block. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_send_control_block ( T_BLK_OWNER blk_owner, + void * blk_struct ) +{ + + TRACE_FUNCTION( "ctrl_send_control_block" ); + TRACE_EVENT( "ctrl_send_control_block" ); + + switch( blk_owner ) + { + case( CGRLC_BLK_OWNER_MEAS ): + case( CGRLC_BLK_OWNER_CS ): + /* + * If the timers related to measurement reporting expire while the + * reselection procedure has not yet been completed, these timers + * shall be restarted so that the mobile station resumes measurement + * reporting procedures once camped on the new cell + */ + if( grr_t_status( T3174 ) > 0 OR grr_t_status( T3176 ) > 0 ) + { + ctrl_send_control_block_result( blk_owner, FALSE ); + + TRACE_ERROR( "ctrl_send_control_block: measurement reporting not allowed" ); + } + else + { + sig_ctrl_tc_control_block( blk_owner, blk_struct ); + } + break; + + default: + sig_ctrl_tc_control_block( blk_owner, blk_struct ); + break; + } +} /* ctrl_send_control_block */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_cancel_control_block ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_cancel_control_block ( T_BLK_OWNER blk_owner ) +{ + TRACE_FUNCTION( "ctrl_cancel_control_block" ); + + sig_ctrl_tc_cancel_control_block( blk_owner ); + +} /* ctrl_cancel_control_block */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_send_control_block_result ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_send_control_block_result ( T_BLK_OWNER blk_owner, + BOOL is_success ) +{ + TRACE_FUNCTION( "ctrl_send_control_block_result" ); + + switch( blk_owner ) + { + case( CGRLC_BLK_OWNER_MEAS ): + if( is_success ) sig_ctrl_meas_pmr_accept( ); + else sig_ctrl_meas_pmr_reject( ); + break; + + case( CGRLC_BLK_OWNER_CS ): + if( is_success ) sig_ctrl_cs_pmr_accept( ); + else sig_ctrl_cs_pmr_reject( ); + break; + + case( CGRLC_BLK_OWNER_CTRL ): + vsi_t_stop( GRR_handle, T3176 ); + TRACE_EVENT("ctrl_send_control_block_result:T3176 stopped"); + break; + + default: + TRACE_ERROR( "ctrl_send_control_block_result: blk_owner out of range" ); + break; + } +} /* ctrl_send_control_block_result */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_resp_resume ++------------------------------------------------------------------------------ +| Description : The function ctrl_resp_resume() .... +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_resp_resume( void ) +{ + psc_db->is_access_enabled = TRUE; + + ctrl_send_cell_ind(); + + sig_ctrl_pg_start(); + + sig_ctrl_psi_resumpt(); + + sig_ctrl_cs_pim( ); + + sig_ctrl_cs_start( ); + + sig_ctrl_meas_pim( ); + + sig_ctrl_meas_resume( ); + + ctrl_tc_access_enable( sig_ctrl_tc_disable_prim_queue ); + +}/* ctrl_resp_resume */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_handle_new_candidate ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_handle_new_candidate( BOOL initial ) +{ + UBYTE state; + T_NC_MVAL *nc_mval; + T_ncell_info *ncell_info; + + TRACE_FUNCTION( "ctrl_handle_new_candidate" ); + + grr_init_db( pcr_db ); + + state = GET_STATE( CTRL ); + + switch( state ) + { + case CTRL_CR: + case CTRL_FAILED_CR: + case CTRL_GRR_NC_CCO: + SET_STATE( CTRL, CTRL_CR ); + break; + + case CTRL_CR_IN_SUSP: + case CTRL_FAILED_CR_IN_SUSP: + SET_STATE( CTRL, CTRL_CR_IN_SUSP ); + break; + + default: + TRACE_EVENT_P1( "ctrl_handle_new_candidate: unexpected state %d", state ); + break; + } + + nc_mval = &grr_data->db.nc_mval_list.nc_mval[grr_data->db.cr_cell->idx]; + ncell_info = grr_get_ncell_info( nc_mval->arfcn, nc_mval->sync_info.bsic ); + + /* + * Store ARFCN and BSIC of the cell re-selection candidate, + * these parameters should be used to avoid considering RRGRR_SI13_IND + * and RRGRR_GPRS_IND primitives which maybe present in the data queue + * of GRR but belong to the old serving cell. + */ + pcr_db->pbcch.bcch.arfcn = nc_mval->arfcn; + pcr_db->pbcch.bcch.bsic = nc_mval->sync_info.bsic; + + if( ncell_info NEQ NULL ) + { + +#ifdef _SIMULATION_ + + if( ncell_info->cr_par.v_si13_pbcch AND + !ncell_info->cr_par.si13_pbcch.v_si13_location ) + { + /* + * Copy pbcch description from the ncell description to pcr_db + */ + ctrl_copy_pbcch_des_from_ncell( pcr_db ); + + /* + * We have to synchronize to the new cell to be able + * to read full PSI in the new cell + */ + ctrl_start_cell_reselection( CTRL_CR_TYPE_NEW_PBCCH_INFO, initial ); + } + else + +#endif /* #ifdef _SIMULATION_ */ + + { + ctrl_start_cell_reselection( CTRL_CR_TYPE_NEW, initial ); + } + } + else + { + ctrl_start_cell_reselection( CTRL_CR_TYPE_NEW, initial ); + } +} /* ctrl_handle_new_candidate */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_handle_no_more_candidate ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_handle_no_more_candidate( T_CTRL_CR_TYPE ctrl_cr_type, + BOOL initial ) +{ + TRACE_FUNCTION( "ctrl_handle_no_more_candidate" ); + + SET_STATE( CTRL, CTRL_READY ); + + /* grr_set_db_ptr( DB_MODE_INIT ); */ + ctrl_start_cell_reselection( ctrl_cr_type, initial ); + +} /* ctrl_handle_no_more_candidate */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_start_rr_task ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_start_rr_task ( UBYTE state ) +{ + TRACE_FUNCTION( "ctrl_start_rr_task" ); + + if( state EQ TASK_STATE_PTM OR grr_is_pbcch_present( ) ) + { + PALLOC( rrgrr_start_task_req, RRGRR_START_TASK_REQ ); + + rrgrr_start_task_req->state = state; + + PSEND( hCommRR, rrgrr_start_task_req ); + } +} /* ctrl_start_rr_task */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_stop_rr_task_req ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_stop_rr_task_req + ( T_GLBL_PCKT_MODE final_pckt_mode, UBYTE param ) +{ + BOOL pbcch_present = grr_is_pbcch_present( ); + BOOL change_pckt_mode; + UBYTE curr_pckt_mode; + T_CTRL_TASK ctrl_task; + + TRACE_FUNCTION( "ctrl_stop_rr_task_req" ); + + change_pckt_mode = ctrl_set_transient_pckt_mode( final_pckt_mode, &ctrl_task ); + curr_pckt_mode = GET_STATE( CTRL_GLBL ); + + if( change_pckt_mode ) + { + if( curr_pckt_mode EQ GLBL_PCKT_MODE_IDLE_ASSIGNED OR + curr_pckt_mode EQ GLBL_PCKT_MODE_IDLE_ACCESS OR + ( curr_pckt_mode EQ GLBL_PCKT_MODE_TRANSFER_ACCESS AND + !pbcch_present ) OR + curr_pckt_mode EQ GLBL_PCKT_MODE_RELEASED_ACCESS ) + { + ctrl_leave_to_pam( ); + } + + if( ctrl_task EQ CTRL_TASK_PBCCH_LEAVE_NULL AND + pbcch_present EQ TRUE ) + { + grr_data->ctrl_glbl.ctrl_task = ctrl_task; + + sig_ctrl_psi_rel_state( REL_PERFORMED ); + ctrl_stop_rr_task_cnf( TRUE ); + } + else if( ctrl_task EQ CTRL_TASK_PBCCH_LEAVE_SUSP ) + { + grr_data->ctrl_glbl.ctrl_task = ctrl_task; + + ctrl_stop_rr_task_cnf( TRUE ); + } + else if( pbcch_present ) + { + if( ctrl_task NEQ CTRL_TASK_NONE AND + ctrl_task NEQ CTRL_TASK_PBCCH_LEAVE_SYNC ) + { + ctrl_send_rrgrr_stop_task_req( ctrl_task, param ); + } + else + { + ctrl_stop_rr_task_cnf( change_pckt_mode ); + } + } + else + { + ctrl_stop_rr_task_cnf( change_pckt_mode ); + } + } + else + { + if ( curr_pckt_mode EQ GLBL_PCKT_MODE_ACCESS ) + { + ctrl_enter_pam( ); + } + else if( curr_pckt_mode EQ GLBL_PCKT_MODE_ACCESS_TWO_PHASE ) + { + sig_ctrl_pg_mode_ind( PACKET_MODE_2P_PTM ); + } + else if( curr_pckt_mode EQ GLBL_PCKT_MODE_MEAS_REP_IDLE ) + { + sig_ctrl_pg_mode_ind( PACKET_MODE_PIM ); + } + else if( curr_pckt_mode EQ GLBL_PCKT_MODE_SUSP ) + { + ctrl_start_rr_task( TASK_STATE_PIM ); + } + + ctrl_stop_rr_task_cnf( change_pckt_mode ); + } +} /* ctrl_stop_rr_task_req */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_stop_rr_task_cnf ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_stop_rr_task_cnf ( BOOL change_pckt_mode ) +{ + TRACE_FUNCTION( "ctrl_stop_rr_task_cnf" ); + + ctrl_set_final_pckt_mode( ); + + if( change_pckt_mode ) + { + T_GLBL_PCKT_MODE pckt_mode = GET_STATE( CTRL_GLBL ); + + if( pckt_mode EQ GLBL_PCKT_MODE_IDLE ) + { + if ( grr_data->ctrl_glbl.ctrl_task EQ CTRL_TASK_PBCCH_LEAVE_SUSP ) + { + ctrl_resp_resume( ); + } + else if( grr_data->ctrl_glbl.ctrl_task EQ CTRL_TASK_PBCCH_LEAVE_SYNC ) + { + /* + * just set the correct state, + * detailed processing will be performed by the calling function + */ + } + else if( grr_data->ctrl_glbl.ctrl_task NEQ CTRL_TASK_PBCCH_LEAVE_NULL ) + { + ctrl_enter_pim( ); + ctrl_start_rr_task( TASK_STATE_PIM ); + } + } + else if( pckt_mode EQ GLBL_PCKT_MODE_ACCESS ) + { + ctrl_enter_pam( ); + + if( grr_data->tc.last_eval_assign.tbf_type EQ CGRLC_TBF_MODE_NULL ) + { + ctrl_start_rr_task( TASK_STATE_PAM ); + } + else + { + TRACE_EVENT( "No task start for PAM, DL assignment received" ); + } + } + else if( pckt_mode EQ GLBL_PCKT_MODE_ASSIGNED ) + { + if( grr_data->tc.last_eval_assign.ccch_read EQ DONT_STOP_CCCH ) + { + sig_ctrl_pg_mode_ind( PACKET_MODE_PAM ); + } + + sig_ctrl_tc_leave_to_ptm( ); + } + else if( pckt_mode EQ GLBL_PCKT_MODE_TRANSFER ) + { + ctrl_enter_ptm( ); + ctrl_start_rr_task( TASK_STATE_PTM ); + } + else if( pckt_mode EQ GLBL_PCKT_MODE_RELEASED ) + { + sig_ctrl_tc_leave_to_pim( ); + } + } + + grr_data->ctrl_glbl.ctrl_task = CTRL_TASK_NONE; +} /* ctrl_stop_rr_task_cnf */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_send_rrgrr_stop_task_req ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_send_rrgrr_stop_task_req ( T_CTRL_TASK ctrl_task, UBYTE param ) +{ + PALLOC( rrgrr_stop_task_req, RRGRR_STOP_TASK_REQ ); + + TRACE_FUNCTION( "ctrl_send_rrgrr_stop_task_req" ); + + switch( ctrl_task ) + { + case CTRL_TASK_PBCCH_LEAVE_IDLE: + rrgrr_stop_task_req->ctrl_task = LEAVE_PIM_PBCCH; + rrgrr_stop_task_req->task.v_pim_pbcch = param; + break; + + case CTRL_TASK_PBCCH_LEAVE_ACCESS: + rrgrr_stop_task_req->ctrl_task = LEAVE_PAM_PBCCH; + rrgrr_stop_task_req->task.v_pam_pbcch = param; + break; + + case CTRL_TASK_PBCCH_LEAVE_TRANSFER: + rrgrr_stop_task_req->ctrl_task = LEAVE_PTM_PBCCH; + rrgrr_stop_task_req->task.v_ptm_pbcch = param; + break; + + case CTRL_TASK_BCCH: + rrgrr_stop_task_req->ctrl_task = RR_TASK_1; + rrgrr_stop_task_req->task.v_stop_ccch = param; + break; + + default: + PFREE( rrgrr_stop_task_req ); + + TRACE_ERROR( "ctrl_send_rrgrr_stop_task_req: invalid control task" ); + TRACE_EVENT_P1( "FATAL ERROR: ctrl_send_rrgrr_stop_task_req: %d", + ctrl_task ); + return; + } + + /* + * Issue #22667, Patch FDS 28-04-04 - Fix for TIL 06 in spain + * Don't change the ctrl state if RR doesn't respond to the stop_task_req + */ + + if ( (ctrl_task NEQ CTRL_TASK_BCCH) OR (param NEQ INVALID_MSG) ) + grr_data->ctrl_glbl.ctrl_task = ctrl_task; + +#ifdef _SIMULATION_ + + TRACE_EVENT_P1( "ctrl_send_rrgrr_stop_task_req - ctrl_task: %d", + grr_data->ctrl_glbl.ctrl_task ); + +#endif /* #ifdef _SIMULATION_ */ + + PSEND( hCommRR, rrgrr_stop_task_req ); + +} /* ctrl_send_rrgrr_stop_task_req */ + + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_set_final_pckt_mode ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +LOCAL void ctrl_set_final_pckt_mode ( void ) +{ + UBYTE pckt_mode = GET_STATE( CTRL_GLBL ); + + TRACE_FUNCTION( "ctrl_set_final_pckt_mode" ); + + switch( pckt_mode ) + { + case( GLBL_PCKT_MODE_NULL_IDLE ): + case( GLBL_PCKT_MODE_SUSP_IDLE ): + case( GLBL_PCKT_MODE_SYNC_IDLE ): + case( GLBL_PCKT_MODE_ACCESS_IDLE ): + case( GLBL_PCKT_MODE_ASSIGNED_IDLE ): + case( GLBL_PCKT_MODE_TRANSFER_IDLE ): + case( GLBL_PCKT_MODE_RELEASED_IDLE ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE ); + break; + + case( GLBL_PCKT_MODE_IDLE_ACCESS ): + case( GLBL_PCKT_MODE_TRANSFER_ACCESS ): + case( GLBL_PCKT_MODE_RELEASED_ACCESS ): + case( GLBL_PCKT_MODE_ACCESS_TWO_PHASE ): + case( GLBL_PCKT_MODE_MEAS_REP_IDLE ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS ); + break; + + case( GLBL_PCKT_MODE_IDLE_ASSIGNED ): + case( GLBL_PCKT_MODE_ACCESS_ASSIGNED ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ASSIGNED ); + break; + + case( GLBL_PCKT_MODE_IDLE_TRANSFER ): + case( GLBL_PCKT_MODE_ASSIGNED_TRANSFER ): + case( GLBL_PCKT_MODE_ACCESS_TRANSFER ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER ); + break; + + case( GLBL_PCKT_MODE_TRANSFER_RELEASED ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_RELEASED ); + break; + + case( GLBL_PCKT_MODE_NULL ): + case( GLBL_PCKT_MODE_SUSP ): + case( GLBL_PCKT_MODE_SYNC ): + case( GLBL_PCKT_MODE_IDLE ): + case( GLBL_PCKT_MODE_ACCESS ): + case( GLBL_PCKT_MODE_ASSIGNED ): + case( GLBL_PCKT_MODE_TRANSFER ): + case( GLBL_PCKT_MODE_RELEASED ): + /* do nothing */ + break; + + default: + TRACE_ERROR( "ctrl_set_final_pckt_mode: invalid transition packet mode" ); + TRACE_EVENT_P1( "FATAL ERROR: ctrl_set_final_pckt_mode: %d", pckt_mode ); + break; + } +} /* ctrl_set_final_pckt_mode */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_set_transient_pckt_mode ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +LOCAL BOOL ctrl_set_transient_pckt_mode + ( T_GLBL_PCKT_MODE final_pckt_mode, T_CTRL_TASK *ctrl_task ) +{ + BOOL change_pckt_mode = TRUE; + UBYTE curr_pckt_mode = GET_STATE( CTRL_GLBL ); + + TRACE_FUNCTION( "ctrl_set_transient_pckt_mode" ); + + *ctrl_task = CTRL_TASK_NONE; + + switch( final_pckt_mode ) + { + case( GLBL_PCKT_MODE_NULL ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_NULL ); + + change_pckt_mode = FALSE; + break; + + case( GLBL_PCKT_MODE_SUSP ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_SUSP ); + + change_pckt_mode = FALSE; + break; + + case( GLBL_PCKT_MODE_SYNC ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_SYNC ); + + change_pckt_mode = FALSE; + break; + + case( GLBL_PCKT_MODE_IDLE ): + switch( curr_pckt_mode ) + { + case( GLBL_PCKT_MODE_NULL ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_NULL_IDLE ); + + *ctrl_task = CTRL_TASK_PBCCH_LEAVE_NULL; + break; + + case( GLBL_PCKT_MODE_SUSP ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_SUSP_IDLE ); + + *ctrl_task = CTRL_TASK_PBCCH_LEAVE_SUSP; + break; + + case( GLBL_PCKT_MODE_SYNC ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_SYNC_IDLE ); + + *ctrl_task = CTRL_TASK_PBCCH_LEAVE_SYNC; + break; + + case( GLBL_PCKT_MODE_IDLE ): + change_pckt_mode = FALSE; + break; + + case( GLBL_PCKT_MODE_ACCESS ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS_IDLE ); + + *ctrl_task = CTRL_TASK_PBCCH_LEAVE_ACCESS; + break; + + case( GLBL_PCKT_MODE_ASSIGNED ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ASSIGNED_IDLE ); + break; + + case( GLBL_PCKT_MODE_TRANSFER ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER_IDLE ); + + *ctrl_task = CTRL_TASK_PBCCH_LEAVE_TRANSFER; + break; + + case( GLBL_PCKT_MODE_RELEASED ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_RELEASED_IDLE ); + break; + + default: + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE ); + + change_pckt_mode = FALSE; + + TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d", + curr_pckt_mode, final_pckt_mode ); + break; + } + break; + + case( GLBL_PCKT_MODE_ACCESS ): + switch( curr_pckt_mode ) + { + case( GLBL_PCKT_MODE_IDLE ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE_ACCESS ); + + *ctrl_task = CTRL_TASK_PBCCH_LEAVE_IDLE; + break; + + case( GLBL_PCKT_MODE_ACCESS ): + change_pckt_mode = FALSE; + break; + + case( GLBL_PCKT_MODE_TRANSFER ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER_ACCESS ); + + *ctrl_task = CTRL_TASK_PBCCH_LEAVE_TRANSFER; + break; + + case( GLBL_PCKT_MODE_RELEASED ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_RELEASED_ACCESS ); + break; + + default: + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS ); + + change_pckt_mode = FALSE; + + TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d", + curr_pckt_mode, final_pckt_mode ); + break; + } + break; + + case( GLBL_PCKT_MODE_ACCESS_TWO_PHASE ): + switch( curr_pckt_mode ) + { + case( GLBL_PCKT_MODE_ACCESS ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS_TWO_PHASE ); + + change_pckt_mode = FALSE; + break; + + default: + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS ); + + change_pckt_mode = FALSE; + + TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d", + curr_pckt_mode, final_pckt_mode ); + break; + } + break; + + case( GLBL_PCKT_MODE_MEAS_REP_IDLE ): + switch( curr_pckt_mode ) + { + case( GLBL_PCKT_MODE_ACCESS ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_MEAS_REP_IDLE ); + + change_pckt_mode = FALSE; + break; + + default: + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS ); + + change_pckt_mode = FALSE; + + TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d", + curr_pckt_mode, final_pckt_mode ); + break; + } + break; + + case( GLBL_PCKT_MODE_ASSIGNED ): + switch( curr_pckt_mode ) + { + case( GLBL_PCKT_MODE_IDLE ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE_ASSIGNED ); + + *ctrl_task = CTRL_TASK_PBCCH_LEAVE_IDLE; + break; + + case( GLBL_PCKT_MODE_ACCESS ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS_ASSIGNED ); + + *ctrl_task = CTRL_TASK_PBCCH_LEAVE_ACCESS; + break; + + case( GLBL_PCKT_MODE_ASSIGNED ): + change_pckt_mode = FALSE; + break; + + default: + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ASSIGNED ); + + change_pckt_mode = FALSE; + + TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d", + curr_pckt_mode, final_pckt_mode ); + break; + } + break; + + case( GLBL_PCKT_MODE_TRANSFER ): + switch( curr_pckt_mode ) + { + case( GLBL_PCKT_MODE_IDLE ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_IDLE_TRANSFER ); + + *ctrl_task = CTRL_TASK_PBCCH_LEAVE_IDLE; + break; + + case( GLBL_PCKT_MODE_ACCESS ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ACCESS_TRANSFER ); + + *ctrl_task = CTRL_TASK_PBCCH_LEAVE_ACCESS; + break; + + case( GLBL_PCKT_MODE_ASSIGNED ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_ASSIGNED_TRANSFER ); + break; + + case( GLBL_PCKT_MODE_TRANSFER ): + change_pckt_mode = FALSE; + break; + + default: + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER ); + + change_pckt_mode = FALSE; + + TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d", + curr_pckt_mode, final_pckt_mode ); + break; + } + break; + + case( GLBL_PCKT_MODE_RELEASED ): + switch( curr_pckt_mode ) + { + case( GLBL_PCKT_MODE_TRANSFER ): + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_TRANSFER_RELEASED ); + + *ctrl_task = CTRL_TASK_PBCCH_LEAVE_TRANSFER; + break; + + case( GLBL_PCKT_MODE_RELEASED ): + change_pckt_mode = FALSE; + break; + + default: + SET_STATE( CTRL_GLBL, GLBL_PCKT_MODE_RELEASED ); + + change_pckt_mode = FALSE; + + TRACE_EVENT_P2( "WARNING: ctrl_set_transient_pckt_mode: %d, %d", + curr_pckt_mode, final_pckt_mode ); + break; + } + break; + + default: + change_pckt_mode = FALSE; + + TRACE_ERROR ( "ctrl_set_transient_pckt_mode: invalid final packet mode" ); + TRACE_EVENT_P1( "FATAL ERROR: ctrl_set_transient_pckt_mode: %d", + final_pckt_mode ); + break; + } + + return( change_pckt_mode ); + +} /* ctrl_set_transient_pckt_mode */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_enter_pim ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +LOCAL void ctrl_enter_pim ( void ) +{ + TRACE_FUNCTION( "ctrl_enter_pim" ); + + /* + * Reset TA-Values + */ + memset(&grr_data->ta_params, 0xFF, sizeof(T_TA_PARAMS)); + grr_data->ta_params.ta_valid = FALSE; + + sig_ctrl_pg_mode_ind( PACKET_MODE_PIM ); + sig_ctrl_psi_pim( ); + sig_ctrl_meas_pim( ); + sig_ctrl_cs_pim( ); + +} /* ctrl_enter_pim */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_leave_to_pam ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +LOCAL void ctrl_leave_to_pam ( void ) +{ + TRACE_FUNCTION( "ctrl_leave_to_pam" ); + + sig_ctrl_meas_pam( ); + sig_ctrl_psi_pam( ); + sig_ctrl_cs_leave_to_pam( ); + +} /* ctrl_leave_to_pam */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_enter_pam ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +LOCAL void ctrl_enter_pam ( void ) +{ + TRACE_FUNCTION( "ctrl_enter_pam" ); + + sig_ctrl_pg_mode_ind( PACKET_MODE_PAM ); + sig_ctrl_cs_enter_pam( ); + + /* + * PATCH 1 BEGIN 10.12.2002 + */ + + /* + * wait 2 ms after pccch_req, otherwise prach will not sent --> L1 BUG02724 + */ + vsi_t_sleep( VSI_CALLER 2 ); + + /* + * PATCH 1 END 10.12.2002 + */ + + sig_ctrl_tc_enter_pam( ); +} /* ctrl_enter_pam */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_enter_ptm ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +LOCAL void ctrl_enter_ptm ( void ) +{ + TRACE_FUNCTION( "ctrl_enter_ptm" ); + + sig_ctrl_psi_ptm( ); + sig_ctrl_pg_mode_ind( PACKET_MODE_PTM ); + sig_ctrl_meas_ptm( ); + sig_ctrl_cs_ptm( ); +} /* ctrl_enter_ptm */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_set_old_scell ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_set_old_scell ( BOOL service ) +{ + TRACE_FUNCTION( "ctrl_set_old_scell" ); + + ctrl_send_gmmrr_cr_ind( ); + + if( service ) + { + grr_data->db.old_scell.arfcn = psc_db->pbcch.bcch.arfcn; + grr_data->db.old_scell.bsic = psc_db->pbcch.bcch.bsic; + grr_data->db.old_scell.pbcch_present = psc_db->pbcch.bcch.pbcch_present; + } + else + { + grr_data->db.old_scell.arfcn = RRGRR_INVALID_ARFCN; + grr_data->db.old_scell.bsic = RRGRR_INVALID_BSIC; + grr_data->db.old_scell.pbcch_present = FALSE; + } + + grr_data->ctrl.new_cell_responded = FALSE; + grr_data->ctrl.rr_state.cr_ind_return = CR_IND_RETURN_RESPONSE; + +#ifdef _SIMULATION_ + + TRACE_EVENT_P2( "ctrl_set_old_scell - old SCELL: %d %d", + grr_data->db.old_scell.arfcn, grr_data->db.old_scell.bsic ); + +#endif /* #ifdef _SIMULATION_ */ + +} /* ctrl_set_old_scell( ) */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_send_gmmrr_cr_ind ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_send_gmmrr_cr_ind ( void ) +{ + PALLOC( gmmrr_cr_ind, GMMRR_CR_IND ); + PSEND( hCommGMM, gmmrr_cr_ind ); + + TRACE_FUNCTION( "ctrl_send_gmmrr_cr_ind" ); +} /* ctrl_send_gmmrr_cr_ind( ) */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_start_cell_reselection ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_start_cell_reselection ( T_CTRL_CR_TYPE ctrl_cr_type, + BOOL initial ) +{ + UBYTE cr_type = CR_CS; + + TRACE_FUNCTION( "ctrl_start_cell_reselection" ); + + if( initial EQ TRUE ) + { + ctrl_set_old_scell( TRUE ); + } + + switch( ctrl_cr_type ) + { + case CTRL_CR_TYPE_CS : /* nothing to do */ break; + case CTRL_CR_TYPE_NEW : + case CTRL_CR_TYPE_NEW_PBCCH_INFO: cr_type = CR_NEW; break; + case CTRL_CR_TYPE_NEW_NOT_SYNCED: cr_type = CR_NEW_NOT_SYNCED; break; + case CTRL_CR_TYPE_CONT : cr_type = CR_CONT; break; + + default: + TRACE_ASSERT( ctrl_cr_type EQ CTRL_CR_TYPE_CS OR + ctrl_cr_type EQ CTRL_CR_TYPE_NEW OR + ctrl_cr_type EQ CTRL_CR_TYPE_NEW_PBCCH_INFO OR + ctrl_cr_type EQ CTRL_CR_TYPE_NEW_NOT_SYNCED OR + ctrl_cr_type EQ CTRL_CR_TYPE_CONT ); + break; + } + + if( ctrl_cr_type EQ CTRL_CR_TYPE_NEW_PBCCH_INFO ) + { + ctrl_sync_to_given_cell( ); + } + else + { + ctrl_send_cell_reselection_req( cr_type ); + } + + sig_ctrl_cs_start_cell_selection( cr_type ); + +} /* ctrl_start_cell_reselection() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_cell_has_changed ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL BOOL ctrl_cell_has_changed ( void ) +{ +#ifdef _SIMULATION_ + + TRACE_EVENT_P5( "ctrl_cell_has_changed - %d - new SCELL: %d %d - old SCELL: %d %d", + grr_data->ctrl.new_cell_responded, + psc_db->pbcch.bcch.arfcn, + psc_db->pbcch.bcch.bsic, + grr_data->db.old_scell.arfcn, + grr_data->db.old_scell.bsic ); + +#endif /* #ifdef _SIMULATION_ */ + + return + ( grr_data->ctrl.new_cell_responded EQ FALSE AND + ( grr_data->db.old_scell.arfcn NEQ psc_db->pbcch.bcch.arfcn OR + grr_data->db.old_scell.bsic NEQ psc_db->pbcch.bcch.bsic ) ); +} /* ctrl_cell_has_changed() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_tc_access_enable ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_tc_access_enable( T_TC_ACCESS_ENABLE_FUNC access_enable_func ) +{ + grr_data->ctrl.new_cell_responded |= + access_enable_func( ctrl_cell_has_changed( ) ); + +#ifdef _SIMULATION_ + + TRACE_EVENT_P5( "ctrl_tc_access_enable - %d - new SCELL: %d %d - old SCELL: %d %d", + grr_data->ctrl.new_cell_responded, + psc_db->pbcch.bcch.arfcn, + psc_db->pbcch.bcch.bsic, + grr_data->db.old_scell.arfcn, + grr_data->db.old_scell.bsic ); + +#endif /* #ifdef _SIMULATION_ */ + +} /* ctrl_tc_access_enable() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_check_cco_freq ++------------------------------------------------------------------------------ +| Description : Check if the frequency in the Cell change order is capable of +| using +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +LOCAL BOOL ctrl_check_cco_freq ( USHORT arfcn ) +{ + BOOL result = FALSE; + + TRACE_FUNCTION( "ctrl_check_cco_freq" ); + TRACE_EVENT( "ctrl_check_cco_freq started" );/*for target trace*/ + + switch( std ) + { + case STD_900: /* frequencies must between 1 and 124 */ + + if(( arfcn >= LOW_CHANNEL_900 ) AND ( arfcn <= HIGH_CHANNEL_900)) + { + result = TRUE; + } + break; + + case STD_EGSM: + + if(( arfcn <= HIGH_CHANNEL_900) OR + (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1))) + { + result = TRUE; + } + break; + + case STD_1900: + + if(( arfcn >= LOW_CHANNEL_1900 ) AND ( arfcn <= HIGH_CHANNEL_1900)) + { + result = TRUE; + } + break; + + case STD_1800: + + if(( arfcn >= LOW_CHANNEL_1800 ) AND ( arfcn <= HIGH_CHANNEL_1800)) + { + result = TRUE; + } + break; + + case STD_850: + + if(( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) + { + result = TRUE; + } + break; + + case STD_DUAL: + + if ((( arfcn >= LOW_CHANNEL_900 ) AND ( arfcn <= HIGH_CHANNEL_900)) OR + (( arfcn >= LOW_CHANNEL_1800 ) AND ( arfcn <= HIGH_CHANNEL_1800))) + { + result = TRUE; + } + break; + + case STD_DUAL_EGSM: + + if((( arfcn <= HIGH_CHANNEL_900) OR + (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1))) + OR + (( arfcn >= LOW_CHANNEL_1800 ) AND + ( arfcn <= HIGH_CHANNEL_1800))) + { + result = TRUE; + } + break; + + case STD_DUAL_US: + if ((( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) OR + (( arfcn >= LOW_CHANNEL_1900 ) AND ( arfcn <= HIGH_CHANNEL_1900))) + { + result = TRUE; + } + break; + +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + case STD_850_1800: + if ((( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) OR + (( arfcn >= LOW_CHANNEL_1800 ) AND ( arfcn <= HIGH_CHANNEL_1800))) + { + result = TRUE; + } + break; + + case STD_900_1900: + if(( arfcn <= HIGH_CHANNEL_900) OR + (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1)) OR + (( arfcn >= LOW_CHANNEL_1900 ) AND ( arfcn <= HIGH_CHANNEL_1900))) + { + result = TRUE; + } + break; + + case STD_850_900_1800: + if ((( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) OR + ( arfcn <= HIGH_CHANNEL_900) OR + (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1)) OR + (( arfcn >= LOW_CHANNEL_1800 ) AND ( arfcn <= HIGH_CHANNEL_1800))) + { + result = TRUE; + } + break; + + case STD_850_900_1900: + if ((( arfcn >= LOW_CHANNEL_850 ) AND ( arfcn <= HIGH_CHANNEL_850)) OR + ( arfcn <= HIGH_CHANNEL_900) OR + (( arfcn >= LOW_CHANNEL_EGSM) AND ( arfcn <= HIGH_CHANNEL_EGSM - 1)) OR + (( arfcn >= LOW_CHANNEL_1900 ) AND ( arfcn <= HIGH_CHANNEL_1900))) + { + result = TRUE; + } + break; +#endif + + default: + break; + } + return(result); + +} /* ctrl_check_cco_freq() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_get_gprs_service ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL T_GPRS_SERVICE ctrl_get_gprs_service ( void ) +{ + TRACE_FUNCTION( "ctrl_get_gprs_service" ); + + return( psc_db->cell_info_for_gmm.gprs_service ); +} /* ctrl_get_gprs_service() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_set_gprs_service ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_set_gprs_service ( UBYTE cause, UBYTE limited ) +{ + TRACE_FUNCTION( "ctrl_set_gprs_service" ); + + switch( cause ) + { + case GPRS_SUPPORTED: + psc_db->cell_info_for_gmm.gprs_service = + ( limited EQ TRUE ? GPRS_SERVICE_LIMITED : GPRS_SERVICE_FULL ); + break; + + case GPRS_NOT_SUPPORTED: + case GPRS_CELL_NOT_SUITABLE: + default: + psc_db->cell_info_for_gmm.gprs_service = GPRS_SERVICE_NONE; + break; + } + + grr_set_cell_info_service( ); + +} /* ctrl_set_gprs_service() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_send_gmmrr_suspend_cnf ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_send_gmmrr_suspend_cnf ( void ) +{ + TRACE_FUNCTION( "ctrl_send_gmmrr_suspend_cnf" ); + + { + PALLOC( gmmrr_suspend_cnf, GMMRR_SUSPEND_CNF ); + PSEND( hCommGMM, gmmrr_suspend_cnf ); + } +} /* ctrl_send_gmmrr_suspend_cnf() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_handle_gmmrr_cs_page_ind ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_handle_gmmrr_cs_page_ind( UBYTE state ) +{ + TRACE_FUNCTION( "ctrl_handle_gmmrr_cs_page_ind" ); + + grr_data->ctrl.last_state = state; + + { + PALLOC( gmmrr_cs_page_ind, GMMRR_CS_PAGE_IND ); + PSEND( hCommGMM, gmmrr_cs_page_ind ); + } +} /* ctrl_handle_gmmrr_cs_page_ind() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_handle_parked_rrgrr_cr_ind ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_handle_parked_rrgrr_cr_ind( UBYTE state ) +{ + UBYTE glbl_state = GET_STATE( CTRL_GLBL ); + + TRACE_FUNCTION( "ctrl_handle_parked_rrgrr_cr_ind" ); + + if( glbl_state EQ GLBL_PCKT_MODE_NULL OR + glbl_state EQ GLBL_PCKT_MODE_SYNC OR + glbl_state EQ GLBL_PCKT_MODE_SUSP ) + { + /* + * In this state the cell re-selection triggered by GRR + * is already requested with a RRGRR_CR_REQ + */ + if( state EQ CTRL_CR ) + { + SET_STATE( CTRL, CTRL_AUTO_RR_CR ); + } + else if( state EQ CTRL_CR_IN_SUSP ) + { + SET_STATE( CTRL, CTRL_RR_CR_IN_SUSP ); + } + else + { + TRACE_EVENT_P1( "ctrl_handle_parked_rrgrr_cr_ind in state %d", state ); + } + + ctrl_cc_rejected( ); + ctrl_set_old_scell( FALSE ); + ctrl_send_cell_reselection_req( CR_COMPLETE ); + + grr_data->ctrl.parked_rrgrr_cr_ind = FALSE; + } +} /* ctrl_handle_parked_rrgrr_cr_ind() */ + + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_read_pcm ++------------------------------------------------------------------------------ +| Description : The function ctrl_read_pcm read some info from ffs to decide +| if nc2 should be switched on or off +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ + +GLOBAL void ctrl_read_pcm ( void ) +{ +#ifdef _TARGET_ + T_GRR_FFS GRR_ffsBuffer; + T_FFS_SIZE size = ffs_fread("/GPRS/grr", &GRR_ffsBuffer, sizeof(GRR_ffsBuffer)); +#endif + + TRACE_FUNCTION( "ctrl_read_pcm" ); + + grr_data->nc2_on = TRUE; +#ifdef _TARGET_ + if ( size != sizeof(GRR_ffsBuffer) ) + { + if ( size < 0 ) + { + TRACE_EVENT_P1("FFS can not be read \"/GPRS/grr\" (%d)", size); + } + else + { + TRACE_EVENT_P2("FFS contains old file of \"/GPRS/grr\": %dBytes long, but %dBytes expected", + size, sizeof(GRR_ffsBuffer)); + } + } + else + { + grr_data->nc2_on = GRR_ffsBuffer.nc2_on; + } +#endif + TRACE_EVENT_P1("ctrl_read_pcm: grr_data->nc2_on is %d",grr_data->nc2_on); + return; +} + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_enter_standby_state ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_enter_standby_state( void ) +{ + TRACE_FUNCTION( "ctrl_enter_standby_state" ); + + switch( GET_STATE( CTRL ) ) + { + case CTRL_NULL: + TRACE_ERROR( "ctrl_enter_standby_state: unexpected signalling" ); + break; + + default: + sig_ctrl_cs_gmm_state( STANDBY_STATE ); + + if( grr_is_pbcch_present( ) EQ FALSE ) + { + PALLOC( rrgrr_standby_state_ind, RRGRR_STANDBY_STATE_IND ); + PSEND( hCommRR, rrgrr_standby_state_ind ); + } + break; + } +} /* ctrl_enter_standby_state() */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_enter_ready_state ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void ctrl_enter_ready_state( void ) +{ + TRACE_FUNCTION( "ctrl_enter_ready_state" ); + + switch( GET_STATE( CTRL ) ) + { + case CTRL_NULL: + TRACE_ERROR( "ctrl_enter_ready_state: unexpected signalling" ); + break; + + default: + sig_ctrl_cs_gmm_state( READY_STATE ); + + if( grr_is_pbcch_present( ) EQ FALSE ) + { + PALLOC( rrgrr_ready_state_ind, RRGRR_READY_STATE_IND ); + PSEND( hCommRR, rrgrr_ready_state_ind ); + } + break; + } +} /* ctrl_enter_ready_state() */ + +#ifdef REL99 +/* ++------------------------------------------------------------------------------ +| Function : ctrl_create_freq_list_cbch ++------------------------------------------------------------------------------ +| Description : Creates the frequency list to be used for mobile allocation +| when CBCH has hopping channel. +| Parameters. : cbch_req -output ; points the cbch information structure +| that would be sent in RRGRR_CBCH_INFO_IND +| freq_par : frequency parameters struct received in PSI 8 +| describing the CBCH channel. +| gp_ma : GPRS mobile allocation IE referred in Freq parametrs +| struct. +| ma_num : MA_NUM received in freq params, when indirect encoding +| is used. Otherwise, this parameter is not important. ++------------------------------------------------------------------------------ +*/ +GLOBAL BOOL ctrl_create_freq_list_cbch(T_cbch *cbch_req,const T_freq_par *freq_par,const T_gprs_ms_alloc_ie *gp_ma,UBYTE ma_num) +{ + T_LIST list1; /*lint !e813*/ + USHORT list2[64]; /*lint !e813*/ + USHORT count = 0; + TRACE_FUNCTION( "ctrl_create_freq_list_cbch" ); + memset(&list1, 0, sizeof(T_LIST)); + memset(list2, NOT_PRESENT_16BIT, sizeof(list2)); + /* + * Now we have the GPRS Mobile Allocation corresponding to the ma_num. + * Get the referenced set of radio frequency lists for this + * particular GPRS Mobile Allocation IE. + * If RFL number list is not present in the IE, then cell allocation + * would be returned by this function. + */ + if(!grr_get_ref_list_or_cell_allocation(&list1,gp_ma,ma_num)) + { + TRACE_ERROR("Could not get ref list"); + return FALSE; + } + + /* + * Copy ARFCN values into freq_list + */ + srv_create_list (&list1, list2, 64, TRUE, 0); + + /* + * Take MA_BITMAP or ARFCN_INDEX into account + */ + grr_ma_filter_list( list2, /* input */ + cbch_req->ma, /* output */ + gp_ma + ); + + /* + * Get number of copied frequencies + */ + if(!grr_validate_and_count_frequencies( cbch_req->ma,&count)) + { + TRACE_ERROR( "grr_create_freq_list: validation failed/freq count zero" ); + return FALSE; + } + + /* The hopping frequency list has to be sent to RR should be in the form + * that is used in MPH sap. The T_p_freq_list used in MPHP sap. The temporary + * variable temp_p_freq_list has been temporarily used here to reuse the + * code. The last element in temp_p_freq_list should be set to NOT_PRESENT_16BIT + * and then copied back to T_cbch cbch_req. + */ + cbch_req->ma[count] = NOT_PRESENT_16BIT; + + /*There is no need to convert the frequencies to L1 form. This would be + * done by ALR when this information is passed to it by RR. + */ + + cbch_req->hsn = gp_ma->hsn; + return TRUE; +}/* ctrl_create_freq_list_cbch */ + +/* ++------------------------------------------------------------------------------ +| Function : ctrl_fill_cbch_hopping_params ++------------------------------------------------------------------------------ +| Description : Fills the hopping list to be sent in RRGRR_CBCH_INFO_IND +| +| Parameters : cbch_req - points to cbch info that would go in primitive. +| freq_par - frequency parameters received in psi8 +| ++------------------------------------------------------------------------------ +*/ +GLOBAL BOOL ctrl_fill_cbch_hopping_params(T_cbch *cbch_req,const T_freq_par *freq_par) +{ + T_gprs_ms_alloc_ie *gp_ma = NULL; + BOOL result = FALSE; + + + TRACE_FUNCTION("ctrl_fill_cbch_hopping_params"); + + if(freq_par->v_indi_encod) + { + result = grr_validate_ma_num_in_freq_par(freq_par,GRR_FREQ_PARAM_RECEIVED_IN_NON_ASSIGNMENT); + if(result) + { + gp_ma = grr_get_gprs_ma(freq_par->indi_encod.ma_num); + if(gp_ma EQ NULL) + { + TRACE_EVENT("No valid GPRS_MA found"); + return FALSE; + } + if(!ctrl_create_freq_list_cbch(cbch_req, + freq_par, + gp_ma, + freq_par->indi_encod.ma_num)) + { + TRACE_EVENT("Failed to create freq list for cbch"); + return FALSE; + } + cbch_req->maio = freq_par->indi_encod.maio; + } + else + { + TRACE_ERROR("error creating frequency list,Invalid MA_NUM"); + result = FALSE; + } + } /* if(freq_par->v_indi_encod) */ + else if(freq_par->v_di_encod1) + { + + /* In this case, the GPRS mobile allocation IE is present + * in the message itself. + */ + if(!ctrl_create_freq_list_cbch(cbch_req, + freq_par, + &freq_par->di_encod1.gprs_ms_alloc_ie, + 0)) + { + TRACE_EVENT("Failed to create freq list for cbch"); + return FALSE; + } + cbch_req->maio = freq_par->di_encod1.maio; + + } /* if(freq_par->v_di_encod1) */ + else if(freq_par->v_di_encod2) + { + /* processing of T_freq_par from assignment and non-assignment messages + * when direct encoding 2 is used, should be done in same object module as + * this involvs use of temporary static array variables which are local to the + * object module they are used in(_local_dummy_list and _local_rfl_contents). + * Hence processing for both assignment and non-assignement messages is done + * in grr_f.c. If they are put in different files, we will have to duplicate + * the temporary static arrays. + */ + result = grr_cnv_freq_para_in_psi8_direct_enc_2(cbch_req,freq_par); + + } /* if(freq_par->v_di_encod2) */ + else + { + TRACE_ERROR("FATAL ERROR: no frequency params in cbch description."); + } + + return (result); +}/* ctrl_fill_cbch_hopping_params */ +#endif +