FreeCalypso > hg > fc-tourmaline
view src/g23m-gprs/grr/grr_ctrlf.c @ 235:ee04ca45053d
config system: add FCBM
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sat, 01 May 2021 10:36:52 +0000 |
| parents | fa8dc04885d8 |
| children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : GPRS (8441) | Modul : GRR +----------------------------------------------------------------------------- | Copyright 2002 Texas Instruments Berlin, AG | All rights reserved. | | This file is confidential and a trade secret of Texas | Instruments Berlin, AG | The receipt of or possession of this file does not convey | any rights to reproduce or disclose its contents or to | manufacture, use, or sell anything it may describe, in | whole, or in part, without the specific written consent of | Texas Instruments Berlin, AG. +----------------------------------------------------------------------------- | Purpose : This module implements 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