FreeCalypso > hg > leo2moko-debug
diff g23m/condat/ms/src/alr/alr_nc.c @ 0:509db1a7b7b8
initial import: leo2moko-r1
| author | Space Falcon <falcon@ivan.Harhan.ORG> |
|---|---|
| date | Mon, 01 Jun 2015 03:24:05 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/g23m/condat/ms/src/alr/alr_nc.c Mon Jun 01 03:24:05 2015 +0000 @@ -0,0 +1,6961 @@ +/* ++----------------------------------------------------------------------------- +| Project : GSM-PS +| Modul : ALR_NC ++----------------------------------------------------------------------------- +| 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 Modul defines the SDL process Idle_Neighbour_Cells. ++----------------------------------------------------------------------------- +*/ + +#ifndef ALR_NC_C +#define ALR_NC_C + +#define ENTITY_PL + +/*==== INCLUDES ===================================================*/ +#include <string.h> +#include <stdlib.h> +#include <limits.h> +#include <ctype.h> +#include "typedefs.h" +#include "message.h" +#include "ccdapi.h" +#include "vsi.h" +#include "custom.h" +#include "gsm.h" +#include "prim.h" +#include "cnf_alr.h" +#include "mon_alr.h" +#include "pei.h" +#include "tok.h" +#include "pcm.h" +#ifdef GPRS +#include "alr_gprs.h" +#endif + +#if !defined(NTRACE) +#define TRACING +#endif /* !TRACING */ + +#include "alr.h" +#include "alr_em.h" + +#if !defined(NTRACE) && defined(TRACING) +LOCAL const char *nc_get_nc_state_str(UBYTE status); +LOCAL const char * const alr_nc_state_trc[18] = { + "INACT", + "IDLE", + "RD_BCCH", + "FB_SB_SYNC", + "FB_SB_FAIL", + "RD_FB_SB", + "RD_SB", + "IDLE_SYNC", + "EXCL", + "FB_SB_SYNC_RR", + "RD_SB_BCCH", + "RD_BCCH_P", + "RD_FB_SB_P", + "RD_SB_P", + "RD_SB_BCCH_P", + "RD_BCCH_RR", + "RD_BCCH_P_RR", + "???"}; +#endif /* !NTRACE && TRACING */ +LOCAL const UBYTE unc_values[] = +{ + 2, 4, 8, 12, 16, 22, 30, NOT_PRESENT_8BIT +}; +/*==== EXPORT =====================================================*/ + +/*==== PRIVAT =====================================================*/ +LOCAL void nc_update_ba_list (USHORT serving_cell, + T_MPH_NEIGHBOURCELL_REQ * ncell_list); +LOCAL UBYTE nc_remove_channel_from_ba_list (USHORT index); +LOCAL UBYTE nc_is_in_ncell_list (USHORT channel, + T_MPH_NEIGHBOURCELL_REQ * ncell_list); +LOCAL void nc_process_status (void); +LOCAL void nc_process_status_sync (void); +LOCAL void nc_process_status_last_bsic (void); +LOCAL void nc_process_status_bcch (void); +LOCAL BOOL nc_ncell_in_plmn_permitted (UBYTE bsic); +LOCAL void nc_find_cells (USHORT * c_found, + USHORT max, + UBYTE limitation, + UBYTE min_rxlev); +LOCAL void nc_store_rxlev (T_MPHC_RXLEV_PERIODIC_IND * report); +LOCAL void nc_rank_ncells (void); +LOCAL void nc_check_status (UBYTE start_list); +LOCAL void nc_build_rr_report_dedi (T_MPH_MEASUREMENT_IND * rr_report); + +LOCAL void nc_store_dedicated (T_MPHC_MEAS_REPORT * report); +LOCAL UBYTE nc_convert_quality (USHORT errors, + USHORT total); +LOCAL void nc_store_bcch (T_MPHC_DATA_IND * data_ind, + USHORT index, + UBYTE which); +LOCAL void nc_stop_bcch (USHORT index, + UBYTE new_status); +LOCAL void nc_stop_sync (USHORT index, + UBYTE new_status); +LOCAL void nc_clean_store_bcch (USHORT index); +LOCAL UBYTE nc_check_bsic (USHORT index, + UBYTE bsic); +#if 0 +#if !defined(NTRACE) && defined(TRACING) +LOCAL UBYTE nc_get_status (USHORT index); +#endif /* !NTRACE && TRACING */ +#endif /* 0|1 */ +LOCAL void nc_restart_bcch (USHORT index); +LOCAL void nc_set_fb_sb_sync_initial (USHORT index); +LOCAL void nc_set_fb_sb_failed (USHORT index, + UBYTE c_sync); +LOCAL UBYTE nc_sys_info_78_required (USHORT index); +LOCAL void nc_sync_failed_attempt (USHORT index); +LOCAL void nc_sync_failed_attempt_dedicated(USHORT index); +LOCAL void nc_build_rr_report (T_MPH_MEASUREMENT_IND* rr_report); +LOCAL void nc_release_bcch (void); +LOCAL void nc_find_list_cells (void); +LOCAL void nc_ncell_list_req (void); +LOCAL void nc_start_eotd_confirm (void); +LOCAL void nc_process_pos_req (T_MPH_NCELL_POS_REQ* pos_req); +LOCAL void nc_check_sync_ind_eotd (T_MPHC_NCELL_SYNC_IND* sync_ind, + USHORT arfcn); +LOCAL void nc_store_eotd (T_eotd_sc_res* p_res, + T_MPHC_NCELL_SYNC_IND* sync_ind, + USHORT arfcn); +LOCAL void nc_sync_ind_last_bsic_req (T_MPHC_NCELL_SYNC_IND* sync_ind, + USHORT index, + USHORT arfcn, + UBYTE bsic); +LOCAL void nc_sync_ind_ncell (T_MPHC_NCELL_SYNC_IND* sync_ind, + USHORT index, + USHORT arfcn, + UBYTE bsic); +LOCAL void nc_clear_last_bsic (void); +#if 0 +Symbol 'nc_stop_all_bcch(void)' 'nc_stop_all_sync(void)' and not referenced at the moment +LOCAL void nc_stop_all_bcch (void); +LOCAL void nc_stop_all_sync (void); +#endif /* 0|1 */ +LOCAL void nc_stop_all (void); +LOCAL void nc_stop_all_inactive (void); +LOCAL void nc_stop_if_active (USHORT i); +LOCAL void nc_ncell_list_req_pos (T_ncell_list* p_ncell_list, + T_ncell_eotd* asd_cell, + USHORT arfcn); +LOCAL void nc_get_timing_eotd (T_ncell_list* p_ncell_list, + T_ncell_eotd* asd_cell); + +LOCAL BOOL nc_is_sync (T_NC * p_ncell); +LOCAL void nc_build_sync_req (USHORT index); +LOCAL void nc_init_pos_ind (USHORT req_id); +LOCAL void nc_enable_conf (void); +LOCAL void nc_disable_conf (BOOL bFree); +LOCAL void nc_start_ncell_confirm (void); +LOCAL void nc_handle_new_strong_cells (void); +LOCAL void nc_check_new_strong_cell (USHORT index, UBYTE o_1of6, UBYTE rxlev); +#ifdef GPRS +LOCAL void nc_rxlev_sc_req (UBYTE rxlev); +LOCAL void nc_inform_grr_of_ncell (USHORT index, + UBYTE type); +LOCAL void remove_ncell_and_inform_grr (USHORT index); +LOCAL void nc_sync_failed_gprs (USHORT index); +LOCAL void nc_check_bsic_pbcch(T_MPH_NEIGHBOURCELL_REQ* ncell_list); +LOCAL void nc_process_status_sync_gprs(void); +#endif /* #ifdef GPRS */ + +#if defined(_SIMULATION_) +LOCAL void trace_nc(void); +#endif /* _SIMULATION_ */ +LOCAL void nc_start_ncsync (void); + +/*==== CONSTANTS ==================================================*/ +#define MAX_L1_SYNC_CNT 12 +#define MAX_L1_BCCH_CNT 6 +#define MAX_L1_SYNC_EOTD_CNT 14 +#define MAX_RR_NCELL_CNT 6 + +#define ONLY_BCC 7 +#define ONLY_BSIC 63 + +#define NC_CHECK_OK 0 +#define NC_CHECK_NCC_FAILED 1 +#define NC_CHECK_BSIC_CHANGED 2 + +#define CHECK_FOR_ACQUIRE_AND_BCCH_AND_FAIL 0 +#define CHECK_FOR_CONFIRM 1 + +#define DONT_FREE_POS_IND 0 +#define FREE_POS_IND 1 + +/* + * Counter to realize a time interval of 10sec in terms of Control Multiframe + * Idle state : 42 * 51 * 4.615ms = 9885ms + * Dedicated State : 42 * 104/2 * 4.615ms = 10079ms + */ +#define TEN_SECONDS_NCSYNC 42 + +#define TEN_SECONDS 1 +#define TWENTY_SECONDS 2 +#define THIRTY_SECONDS 3 +#define FIVE_MINUTES 30 +#define C_INVALID_SYNC (THIRTY_SECONDS+1) +/* +2 for rounding BCCH reading to confirmation boundary */ +#define C_INVALID_BCCH (FIVE_MINUTES+2+1) + +#ifdef GPRS +#define GRR_SB_FOUND (MPH_BSIC_UNKNOWN+1) +#define GRR_SB_NOT_FOUND NOT_PRESENT_8BIT +#define GRR_SB_UNKNOWN MPH_BSIC_UNKNOWN +#endif + +/*==== VARIABLES ==================================================*/ + +/*==== FUNCTIONS ==================================================*/ +#if defined (WIN32) && !defined (_SIMULATION_) +#define _SIMULATION_ +#endif + +#if defined (_SIMULATION_) +#define TRACING +#endif /* _SIMULATION_ */ + +/* + * some traces + */ +#if defined (TRACING) +#define ALR_TRACE_NC(a) ALR_TRACE(a) +#define ALR_TRACE_NC_CNT(a,b) TRACE_EVENT_P2 ("[%4u] c_sync %d", \ + ARFCN_TO_G23(a)&ARFCN_MASK, b) +#define ALR_TRACE_NC_BSIC_CNF(a) TRACE_EVENT_P1 ("[%4u] NC BSIC CNF passed", \ + ARFCN_TO_G23(a)&ARFCN_MASK) +#define ALR_TRACE_NC_SB_FAILED(a) TRACE_EVENT_P1 ("[%4u] NCELL SB IND failed", \ + ARFCN_TO_G23(a)&ARFCN_MASK) +#define ALR_TRACE_NC_BSIC_REQ(a) TRACE_EVENT_P4 ("[%4u] NC BSIC REQ %d %d %d", \ + a&ARFCN_MASK, GET_STATE (STATE_NC), \ + alr_data->nc_data.cell[LAST_BSIC_REQ].status, \ + alr_data->nc_data.c_bcch_req) +#define ALR_TRACE_NC_BCCH_OK(f,m) TRACE_EVENT_P2 ("[%4u] NCELL BCCH IND passed msg:%d", \ + f&ARFCN_MASK,m) +#define ALR_TRACE_NC_SB_IND_PASSED(f) TRACE_EVENT_P1 ("[%4u] NCELL SB IND passed", \ + f&ARFCN_MASK) +#define ALR_TRACE_NC_RESELECT(a) TRACE_EVENT_P1 ("[%4u] start reselect", a&ARFCN_MASK) +#define ALR_TRACE_NC_FN_TA(_i,f,t) TRACE_EVENT_P3 ("i %d, fn %d, ta %d ", _i, f, t) +#if 0 +#define GET_NC_STATE(i) nc_get_status(i) +#endif /* 0|1 */ +#if defined(_SIMULATION_) +#define ALR_TRACE_ALL_NC() trace_nc() +#else /* _SIMULATION_ */ +#define ALR_TRACE_ALL_NC() +#endif /* _SIMULATION_ */ +#else /* TRACING */ +#define ALR_TRACE_NC(a) +#define ALR_TRACE_NC_CNT(a,b) +#define ALR_TRACE_NC_BSIC_CNF(a) +#define ALR_TRACE_NC_SB_FAILED(a) +#define ALR_TRACE_NC_BSIC_REQ(a) +#define ALR_TRACE_NC_BCCH_OK(f,m) +#define ALR_TRACE_NC_SB_IND_PASSED(f) +#define ALR_TRACE_NC_RESELECT(a) +#define ALR_TRACE_NC_FN_TA(i,f,t) +#define GET_NC_STATE(i) alr_data->nc_data.cell[i].status +#define ALR_TRACE_ALL_NC() +#undef TRACE_EVENT +#undef TRACE_EVENT_P1 +#undef TRACE_EVENT_P2 +#undef TRACE_EVENT_P3 +#undef TRACE_EVENT_P4 +#undef TRACE_EVENT_P5 +#undef TRACE_EVENT_P6 +#undef TRACE_EVENT_P7 +#undef TRACE_EVENT_P8 +#undef TRACE_EVENT_P9 +#define TRACE_EVENT(s) +#define TRACE_EVENT_P1(s,a) +#define TRACE_EVENT_P2(s,a,b) +#define TRACE_EVENT_P3(s,a,b,c) +#define TRACE_EVENT_P4(s,a,b,c,d) +#define TRACE_EVENT_P5(s,a,b,c,d,e) +#define TRACE_EVENT_P6(s,a,b,c,d,e,f) +#define TRACE_EVENT_P7(s,a,b,c,d,e,f,g) +#define TRACE_EVENT_P8(s,a,b,c,d,e,f,g,h) +#define TRACE_EVENT_P9(s,a,b,c,d,e,f,g,h,i) +#endif /* TRACING */ + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_init | ++--------------------------------------------------------------------+ + + PURPOSE : Initialize Idle Neighbour Cell Process. + +*/ +GLOBAL void nc_init (void) +{ + nc_stop_all(); + alr_data->nc_data.c_ba_arfcn = 0; + alr_data->nc_data.ba_id = ALR_BA_LOW; + alr_data->nc_data.sc_included = FALSE; + alr_data->nc_data.cell[LAST_BSIC_REQ].status = IDLE; + alr_data->nc_data.cell[LAST_BSIC_REQ].ba_arfcn = NOT_PRESENT_16BIT; + alr_data->nc_data.c_reports = (UBYTE)-1; + alr_data->nc_data.cr_cell.ba_arfcn = NOT_PRESENT_16BIT; + alr_data->nc_data.tim_state = NC_TIM_STOPPED; + alr_data->nc_data.c_nc_timer = 0; + if (alr_data->nc_data.ppos_ind NEQ NULL) + { + PFREE(alr_data->nc_data.ppos_ind); + alr_data->nc_data.ppos_ind = NULL; + } + if (alr_data->nc_data.ppos_req NEQ NULL) + { + PFREE(alr_data->nc_data.ppos_req); + alr_data->nc_data.ppos_req = NULL; + } + + /* Initialize the counter for realizing 10sec timer value */ + alr_data->nc_data.c_ncsync_tim = 0; + alr_data->nc_data.ncsync_start_tim = 0; + + SET_STATE(STATE_NC_PROC, NC_ACQUIRE); + SET_STATE(STATE_NC, NC_NULL); +} + +#ifdef GPRS +/* ++----------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_GPRS | +| STATE : code ROUTINE : nc_start_pbcch| ++----------------------------------------------------------------------+ + + PURPOSE :Checks whether pbcch is available and sets a relevant state. + +*/ + +GLOBAL void nc_start_pbcch(void) +{ + if(alr_data->gprs_data.ptm AND + alr_data->gprs_data.pbcch) + { + SET_STATE(STATE_NC, NC_PTM_PBCCH); + } + else if(alr_data->gprs_data.pbcch) + { + SET_STATE(STATE_NC, NC_PIM_PBCCH); + } + + nc_enable_conf(); + nc_process_status(); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_GPRS | +| STATE : code ROUTINE : gprs_check_bsic_pbcch | ++--------------------------------------------------------------------+ + + PURPOSE : + +*/ +LOCAL void nc_check_bsic_pbcch(T_MPH_NEIGHBOURCELL_REQ* ncell_list) +{ + TRACE_EVENT("gprs_alr_check_bsic_pbcch"); + if(!alr_data->gprs_data.pbcch) return; + + if(ncell_list->sync_only EQ SYNC_LIST) + { + + USHORT n_rr; /* index of RR neighbor cell list */ + USHORT n_alr; /* index of ALR neighbor cell list */ + UBYTE last_alr; /* last index of ALR neighbor cell list */ + USHORT arfcn; + TRACE_EVENT("pbcch/check bsic"); + + /* + * remove all channels which are not longer member of the + * neighbour cell list. + */ + last_alr = alr_data->nc_data.c_ba_arfcn; /* current last index */ + for (n_alr = 0; n_alr < last_alr; n_alr++) + { + arfcn = alr_data->nc_data.cell[n_alr].ba_arfcn; + if (!nc_is_in_ncell_list (arfcn, ncell_list)) + /* AND + (arfcn NEQ alr_data->serving_cell))*/ + { + switch(alr_data->nc_data.cell[n_alr].status) + { + case READ_FB_SB: + case READ_FB_SB_PENDING: + case READ_SB_PENDING: + case READ_SB: + case READ_SB_BCCH: /* in case we come from BCCH */ + case INACTIVE: /* in case we returned from DEDIC */ + case IDLE: /* in case we returned from DEDIC */ + case EXCLUDED: /* in case we returned from DEDIC */ + TRACE_EVENT_P1("rem cell i%d",n_alr); + remove_ncell_and_inform_grr(n_alr); + last_alr = alr_data->nc_data.c_ba_arfcn; + n_alr--; + break; + case FB_SB_SYNC_RR_NOT_INFORMED: + case READ_BCCH_RR_NOT_INFORMED: + case READ_BCCH: + case FB_SB_SYNC: + case IDLE_SYNC: + case FB_SB_FAILED: + /*state change will be done with check_status*/ + TRACE_EVENT_P1("i%d reset 1o6", n_alr); + alr_data->nc_data.cell[n_alr].one_of_six = FALSE; + alr_data->nc_data.cell[n_alr].one_of_twelve = FALSE; + break; + default: + TRACE_EVENT_P3("i%d,arfcn:%d illegal status %d",n_alr, + alr_data->nc_data.cell[n_alr].ba_arfcn, + alr_data->nc_data.cell[n_alr].status); + break; + } + } + else + { /* ncell is in both lists */ + switch(alr_data->nc_data.cell[n_alr].status) + { + case READ_FB_SB: +// case READ_FB_SB_PENDING: + //case READ_SB_PENDING: + case READ_SB: + break; + case READ_SB_BCCH: /* in case we come from BCCH */ + nc_set_status(n_alr, READ_SB); + break; + case INACTIVE: /* in case we returned from DEDIC */ + case IDLE: /* in case we returned from DEDIC */ + case EXCLUDED: /* in case we returned from DEDIC */ + nc_set_status (n_alr, INACTIVE); + /* ALR does not receive measurements */ + /* set them to idle */ + nc_set_status (n_alr, IDLE); + /* and set it to one_of_six , the rest is done by check_status */ + nc_set_status(n_alr, READ_FB_SB); + break; + case FB_SB_SYNC_RR_NOT_INFORMED: + case READ_BCCH_RR_NOT_INFORMED: + case READ_BCCH: + nc_set_status(n_alr, FB_SB_SYNC); + break; + default: + break; + } + alr_data->nc_data.cell[n_alr].one_of_six = FALSE; + alr_data->nc_data.cell[n_alr].one_of_twelve = TRUE; + } + } + + /* + * add all new channels. + */ + for (n_rr = 0; + (n_rr < MAX_NEIGHBOURCELLS) AND (last_alr < BA_LIST_SIZE-1); + n_rr++) + { + arfcn = ncell_list->arfcn[n_rr]; + if (arfcn EQ NOT_PRESENT_16BIT) + break; /* no more entries in the RR ncell_list */ + + n_alr = nc_get_index (arfcn); + + if (((n_alr EQ NOT_PRESENT_16BIT) OR (n_alr EQ LAST_BSIC_REQ)) AND + (arfcn NEQ alr_data->serving_cell)) + { + T_NC* pcell = &alr_data->nc_data.cell[last_alr]; + +#if defined(TRACING) + TRACE_EVENT_P2 ("NC%u[%u] add", last_alr, arfcn); +#endif /* TRACING */ + pcell->ba_arfcn = arfcn; + nc_set_status (last_alr, INACTIVE); + /* ALR does not receive measurements */ + /* set them to idle */ + nc_set_status (last_alr, IDLE); + /* and set it to one_of_six , the rest is done by check_status */ + alr_data->nc_data.cell[last_alr].one_of_six = FALSE; + alr_data->nc_data.cell[last_alr].one_of_twelve = TRUE; + alr_data->nc_data.cell[last_alr].ba_status = IN_BA; + last_alr++; /* increment last index */ + } + } + alr_data->nc_data.c_ba_arfcn = last_alr; /* store new last index */ + ALR_TRACE_ALL_NC (); + + { + UBYTE six=0; + last_alr = alr_data->nc_data.c_ba_arfcn; /* current last index */ + for (n_alr = 0; n_alr < last_alr; n_alr++) + { + six += alr_data->nc_data.cell[n_alr].one_of_six; + } + /*XXX change this to handle 12 ncells */ + if(six > 6) + { + TRACE_ERROR("more then six candidates!"); + } + } +#if 0 /*only for easing debugging */ + /* + * Reorder the entries. The goal is that the propably strongest neigbour + * cells + * are measured in the first measurement period of a subsequent + * MPHC_RXLEV_PERIODIC_REQ/IND. The appropriate arfcn's are the first + * ones in + * ncell_list->arfcn + */ + { + T_NC temp, *prr, *palr; + + for (n_rr = 0; n_rr < 7; n_rr++) + { + if(ncell_list->arfcn[n_rr] NEQ NOT_PRESENT_16BIT) + n_alr = nc_get_index (ncell_list->arfcn[n_rr]); + else + break; + + if ( ((n_alr NEQ NOT_PRESENT_16BIT) OR (n_alr NEQ LAST_BSIC_REQ)) AND + n_rr NEQ n_alr) + { + palr = &(alr_data->nc_data.cell[n_alr]); + prr = &(alr_data->nc_data.cell[n_rr]); + memcpy(&temp, palr, sizeof(T_NC)); + memcpy(palr, prr, sizeof(T_NC)); + memcpy(prr, &temp, sizeof(T_NC)); + /*TRACE_EVENT_P4("reordered NC%u[%u] and NC%u[%u]", + n_rr, + ncell_list->arfcn[n_rr], + n_alr, ncell_list->arfcn[n_alr]);*/ + } + } + } +#endif + nc_check_status(CHECK_FOR_ACQUIRE_AND_BCCH_AND_FAIL); + + if(alr_data->nc_sync_with_grr) + { + TRACE_EVENT("sync_with_grr"); + last_alr = alr_data->nc_data.c_ba_arfcn; /* current last index */ + for (n_alr = 0; n_alr < last_alr; n_alr++) + { + switch(alr_data->nc_data.cell[n_alr].status) + { + case IDLE_SYNC: + case FB_SB_SYNC: + case READ_SB: + case READ_SB_PENDING: + case READ_FB_SB_PENDING: + TRACE_EVENT_P1("sync %d",alr_data->nc_data.cell[n_alr].ba_arfcn); + nc_inform_grr_of_ncell(n_alr, GRR_SB_FOUND); + break; + case FB_SB_FAILED: + case EXCLUDED: + case INACTIVE: + case IDLE: + TRACE_EVENT_P1("sync %d",alr_data->nc_data.cell[n_alr].ba_arfcn); + nc_inform_grr_of_ncell(n_alr, GRR_SB_NOT_FOUND); + break; + /* READ_FB_SB ->the cell will be synchronized next + and a result will be returnded anyway */ + default: + break; + } + } + alr_data->nc_sync_with_grr=FALSE; + } + + switch(GET_STATE(STATE_NC)) + { + case NC_PIM_PBCCH: + case NC_PTM_PBCCH: + nc_process_status(); + break; + default: + break; + } + } + else if(ncell_list->sync_only EQ RECONFIRM_SYNC_LIST) + { + nc_ncsync_tim_expiry(); + } + +} + +#endif +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_stop | ++--------------------------------------------------------------------+ + + PURPOSE : stop the neighbourcell process. Is called by main process + if a recovery with power measurements is started. + +*/ + +GLOBAL void nc_stop (void) +{ + /* + * clean or neighbourcells of the BA and LAST_BSIC_REQ list if needed + */ + nc_stop_all_inactive(); + + /* + * initialize neighbourcell process and stops timer + */ + nc_init(); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_stop_all_inactive | ++--------------------------------------------------------------------+ + + PURPOSE : This stops all activities to bring a channel to state NC_NULL. + +*/ + +LOCAL void nc_stop_all_inactive (void) +{ + UBYTE i, stopped_sync=0, stopped_bcch=0; + /* + * depending on the current status + */ + for (i = 0; i < alr_data->nc_data.c_ba_arfcn; i++) + { + switch (alr_data->nc_data.cell[i].status) + { + case READ_FB_SB_PENDING: + case READ_SB_PENDING: + case READ_SB_BCCH_PENDING: + /* + * stop the current running request for synchronisation in layer 1. + */ + nc_set_status (i, INACTIVE); + stopped_sync++; + break; + + case READ_BCCH_PENDING: + case READ_BCCH_PENDING_RR_NOT_INFORMED: + /* + * stop the current running request for BCCH reading in layer 1. + * If sys info 4 is already stored, but sys info 7 or 8 is requested + * clear also a stored BCCH message. + */ + nc_set_status (i, INACTIVE); + stopped_bcch++; + break; + default: + /* + * sys infos are stored, but RR is still not informed. + * Then clean the stored message + */ + nc_set_status (i, INACTIVE); + break; + } + } + switch (alr_data->nc_data.cell[LAST_BSIC_REQ].status) + { + case READ_FB_SB_PENDING: + nc_set_status (LAST_BSIC_REQ, IDLE); + alr_data->nc_data.cell[LAST_BSIC_REQ].ba_arfcn = NOT_PRESENT_16BIT; + stopped_sync++; + break; + case READ_BCCH_PENDING: + nc_set_status (LAST_BSIC_REQ, IDLE); + alr_data->nc_data.cell[LAST_BSIC_REQ].ba_arfcn = NOT_PRESENT_16BIT; + stopped_bcch++; + break; + } + + /*send to L1*/ + if (stopped_sync > 0) + { /* stop all synchronizations */ + PALLOC (stop_req, MPHC_STOP_NCELL_SYNC_REQ); + stop_req->radio_freq_array_size = MAX_L1_SYNC_CNT; + PSENDX(L1, stop_req); + } + if (stopped_bcch > 0) + { /* stop all bcch */ + PALLOC (stop_req, MPHC_STOP_NCELL_BCCH_REQ); + stop_req->radio_freq_array_size = MAX_L1_BCCH_CNT; + PSENDX(L1, stop_req); + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_stop_all | ++--------------------------------------------------------------------+ + + PURPOSE : This stops all activities to bring a channel + its corresping READ_ state. + +*/ + +LOCAL void nc_stop_all (void) +{ + UBYTE i, stopped_sync=0, stopped_bcch=0; + /* + * depending on the current status + */ + for (i = 0; i < alr_data->nc_data.c_ba_arfcn; i++) + { + switch (alr_data->nc_data.cell[i].status) + { + case READ_FB_SB_PENDING: + nc_set_status (i, READ_FB_SB); + stopped_sync++; + break; + case READ_SB_PENDING: + nc_set_status (i, READ_SB); + stopped_sync++; + break; + case READ_SB_BCCH_PENDING: + nc_set_status (i, READ_SB_BCCH); + stopped_sync++; + break; + case READ_BCCH_PENDING: + nc_set_status (i, READ_BCCH); + stopped_bcch++; + break; + case READ_BCCH_PENDING_RR_NOT_INFORMED: + nc_set_status (i, READ_BCCH_RR_NOT_INFORMED); + stopped_bcch++; + break; + case FB_SB_SYNC_RR_NOT_INFORMED: + nc_set_status (i, READ_BCCH_RR_NOT_INFORMED); + break; + } + } + switch (alr_data->nc_data.cell[LAST_BSIC_REQ].status) + { + case READ_FB_SB_PENDING: + nc_set_status (LAST_BSIC_REQ, READ_FB_SB); + stopped_sync++; + break; + case READ_BCCH_PENDING: + nc_set_status (LAST_BSIC_REQ, READ_BCCH); + stopped_bcch++; + break; + } + /*send to L1*/ + if ( stopped_sync > 0 OR + alr_data->nc_data.c_sync_req > 0 OR + (alr_data->nc_data.eotd_avail AND GET_STATE(STATE_NC_PROC) EQ NC_CONFIRM)) + { /* stop all synchronizations if waiting for any NC synchronization (or 2nd SC in EOTD case) */ + PALLOC (stop_req, MPHC_STOP_NCELL_SYNC_REQ); + stop_req->radio_freq_array_size = MAX_L1_SYNC_CNT; + PSENDX(L1, stop_req); + alr_data->nc_data.c_sync_req=0; + if (alr_data->nc_data.eotd_avail) + SET_STATE(STATE_NC_PROC, NC_ACQUIRE); + } + if(stopped_bcch > 0) + { /* stop all bcch */ + PALLOC (stop_req, MPHC_STOP_NCELL_BCCH_REQ); + stop_req->radio_freq_array_size = MAX_L1_BCCH_CNT; + PSENDX(L1, stop_req); + alr_data->nc_data.c_bcch_req=0; + } +} + +#if 0 +Symbol 'nc_stop_all_bcch(void)' not referenced at the moment +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_stop_all_sync | ++--------------------------------------------------------------------+ + + PURPOSE : This stops all sync activities. + +*/ +LOCAL void nc_stop_all_sync (void) +{ + UBYTE i, stopped_sync=0; + /* + * depending on the current status + */ + for (i = 0; i < alr_data->nc_data.c_ba_arfcn; i++) + { + switch (alr_data->nc_data.cell[i].status) + { + case READ_FB_SB_PENDING: + nc_set_status (i, READ_FB_SB); + stopped_sync++; + break; + case READ_SB_PENDING: + nc_set_status (i, READ_SB); + stopped_sync++; + break; + case READ_SB_BCCH_PENDING: + nc_set_status (i, READ_SB_BCCH); + stopped_sync++; + break; + } + } + switch (alr_data->nc_data.cell[LAST_BSIC_REQ].status) + { + case READ_FB_SB_PENDING: + nc_set_status (LAST_BSIC_REQ, READ_FB_SB); + stopped_sync++; + break; + } + /*send to L1*/ + if (stopped_sync > 0) + { /* stop all synchronizations */ + PALLOC (stop_req, MPHC_STOP_NCELL_SYNC_REQ); + stop_req->radio_freq_array_size = MAX_L1_SYNC_CNT; + PSENDX(L1, stop_req); + alr_data->nc_data.c_sync_req=0; + } +} +#endif /* 0|1 */ + +#if 0 +Symbol 'nc_stop_all_bcch(void)' not referenced at the moment +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_stop_all_bcch | ++--------------------------------------------------------------------+ + + PURPOSE : This stops all activities to bring a channel to state NC_NULL. + +*/ +LOCAL void nc_stop_all_bcch (void) +{ + UBYTE i, stopped_bcch=0; + /* + * depending on the current status + */ + for (i = 0; i < alr_data->nc_data.c_ba_arfcn; i++) + { + switch (alr_data->nc_data.cell[i].status) + { + case READ_BCCH_PENDING_RR_NOT_INFORMED: + nc_set_status (i, READ_BCCH_RR_NOT_INFORMED); + stopped_bcch++; + break; + case READ_BCCH_PENDING: + nc_set_status (i, READ_BCCH); + stopped_bcch++; + break; + } + } + switch (alr_data->nc_data.cell[LAST_BSIC_REQ].status) + { + case READ_BCCH_PENDING: + nc_set_status (LAST_BSIC_REQ, READ_BCCH); + stopped_bcch++; + break; + } + /*send to L1*/ + if (stopped_bcch > 0) + { /* stop all bcch */ + PALLOC (stop_req, MPHC_STOP_NCELL_BCCH_REQ); + stop_req->radio_freq_array_size = MAX_L1_BCCH_CNT; + PSENDX(L1, stop_req); + alr_data->nc_data.c_bcch_req=0; + } +} +#endif /* 0|1 */ + +LOCAL void nc_clear_last_bsic(void) +{ + switch (alr_data->nc_data.cell[LAST_BSIC_REQ].status) + { + case READ_BCCH_PENDING: + nc_stop_bcch (LAST_BSIC_REQ, IDLE); + break; + case READ_FB_SB_PENDING: + nc_stop_sync (LAST_BSIC_REQ, IDLE); + break; + } + + nc_set_status(LAST_BSIC_REQ, IDLE); + alr_data->nc_data.cell[LAST_BSIC_REQ].ba_arfcn = NOT_PRESENT_16BIT; + +} + +LOCAL void nc_stop_if_active(USHORT i) +{ + /* + * the requested channel number is member of the BA list. + * clear a request to layer 1 if needed. + */ + switch(alr_data->nc_data.cell[i].status) + { + case READ_SB_PENDING: + nc_stop_sync (i, READ_SB); + break; + case READ_SB_BCCH_PENDING: + nc_stop_sync (i, READ_SB_BCCH); + break; + case READ_FB_SB_PENDING: + nc_stop_sync (i, READ_FB_SB); + break; + case READ_BCCH_PENDING: + nc_stop_bcch (i, READ_BCCH); + break; + case READ_BCCH_PENDING_RR_NOT_INFORMED: + nc_stop_bcch (i, READ_BCCH_RR_NOT_INFORMED); + break; + default: + break; + } +} +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_ncell_list | ++--------------------------------------------------------------------+ + + PURPOSE : Reception of a new neighbourcell list from RR. + +*/ + +GLOBAL void nc_ncell_list (T_MPH_NEIGHBOURCELL_REQ * mph_neighbourcell_req) +{ + UBYTE i, j; + switch (GET_STATE (STATE_NC)) + { + case NC_DEDICATED: + { + UBYTE c_ba_arfcn; + PALLOC (upd_dedi, MPHC_UPDATE_BA_LIST); + + /* + * mix new list with old list + */ + nc_update_ba_list (alr_data->serving_cell, + mph_neighbourcell_req); + + /* + * create new list for layer 1 + */ + c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + for (i = 0, j = 0; i < c_ba_arfcn; i++) + { + if (alr_data->nc_data.cell[i].ba_status EQ IN_BA) + upd_dedi->chan_list.radio_freq[j++] = + ARFCN_TO_L1(alr_data->nc_data.cell[i].ba_arfcn); + } + + /* + * send new list to layer 1 + */ + upd_dedi->num_of_chans = j; + + alr_data->nc_data.ba_id = ALR_ALLOCATE_NEW_BA ( alr_data->nc_data.ba_id ); + upd_dedi->ba_id = alr_data->nc_data.ba_id; + + upd_dedi->pwrc = alr_data->nc_data.pwrc; + upd_dedi->dtx_allowed = alr_data->nc_data.dtx; + + alr_data->nc_data.update = TRUE; + ma_nc_update_ba_list (upd_dedi); + + } + break; + case NC_CON_EST: /*for PBCCH just update the list, is checked in + nc_check_bsic_pbcch */ +#ifdef GPRS + case NC_PIM_PBCCH: + case NC_PTM_PBCCH: + nc_check_bsic_pbcch(mph_neighbourcell_req); +#endif + break; + default: + /* + * idle mode + */ + ALR_TRACE_NC ("ncell req in idle"); + + /* + * mix new list with old list + */ + nc_update_ba_list (alr_data->serving_cell, mph_neighbourcell_req); + + /* + * configure layer 1 and start monitoring on new list + */ + nc_start_monitoring(); + break; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_start_monitoring | ++--------------------------------------------------------------------+ + + PURPOSE : Configure layer 1 with a new list for neighbourcell + measurements. + +*/ + +static const UBYTE NO_OF_REPORTS [8] = +{ + 10, 7, 5, 4, 3, 3, 2, 2 +}; + +static const UBYTE INIT_OF_C_REPORTS [8] = +{ + 5, 5, 2, 2, 1, 1, 0, 0 /* empirical for FTA 20.7, 20.19, for TC 084, 047 */ +}; + +static BOOL first_period = FALSE, first_l1_meas = FALSE; + +GLOBAL void nc_start_monitoring (void) +{ + USHORT index, prim_index; + UBYTE report_idx = alr_data->bs_pa_mfrms; + UBYTE c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + PALLOC (update, MPHC_RXLEV_PERIODIC_REQ); + + ALR_TRACE_NC ("nc_start_mon"); + + first_period = first_l1_meas = TRUE; + + alr_data->nc_data.max_reports = NO_OF_REPORTS [report_idx]; + alr_data->nc_data.fn_offset = (report_idx+2) * NO_OF_REPORTS[report_idx] * 51; + + if (alr_data->nc_data.c_reports EQ (UBYTE)-1) /* initial value */ + alr_data->nc_data.c_reports = INIT_OF_C_REPORTS [report_idx]; + else /* don´t touch c_reports except for max_reports is less */ + if (alr_data->nc_data.c_reports >= alr_data->nc_data.max_reports) + alr_data->nc_data.c_reports = alr_data->nc_data.max_reports - 1; + index = nc_get_index(alr_data->serving_cell); + if (index NEQ NOT_PRESENT_16BIT) + alr_data->nc_data.cell[index].c_rxlev = NOT_PRESENT_8BIT; + + /* + * for all neighbourcells: convert channel number + * and fill the primitive to layer 1. + */ + for (index = 0, prim_index = 0; index < c_ba_arfcn; index++) + { + if (alr_data->nc_data.cell[index].ba_status EQ IN_BA) + update->chan_list.radio_freq[prim_index++] = + ARFCN_TO_L1(alr_data->nc_data.cell[index].ba_arfcn); + } + + /* + * set number of channels and band id + */ + update->num_of_chans = (UBYTE)prim_index; + alr_data->nc_data.ba_id = ALR_ALLOCATE_NEW_BA ( alr_data->nc_data.ba_id ); + update->ba_id = alr_data->nc_data.ba_id; + update->next_radio_freq_measured = 0; + +#if defined(_SIMULATION_) + { + char buf[80], o; + o = sprintf (buf, "RXLEV_PERIODIC: c=%d id=%02x:", update->num_of_chans, update->ba_id); + for (index=0; index < update->num_of_chans; index++) + { + if (o > 80-6) + { + TRACE_EVENT (buf); + o = 0; + } + o += sprintf (buf+o, "%u,", update->chan_list.radio_freq[index]); + } + buf[o-1]=0; + TRACE_EVENT (buf); + } +#endif /* _SIMULATION_ */ + + SET_STATE (STATE_NC, NC_IDLE); +/* + TRACE_EVENT_P2("glob reps: %d max_report: %d", + alr_data->nc_data.c_reports, alr_data->nc_data.max_reports); +*/ + + /* + * configure layer 1. + */ + ma_nc_rxlev_periodic_req(update); + + nc_enable_conf(); +} +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_enable_conf | ++--------------------------------------------------------------------+ + + PURPOSE : Maintains what happens after 10 seconds interval. + restarts a pending ncell confirmation +*/ +LOCAL void nc_enable_conf(void) +{ + UBYTE tim_state = alr_data->nc_data.tim_state; + UBYTE st = GET_STATE(STATE_NC); + + TRACE_EVENT("nc_enable_conf()"); + alr_data->nc_data.tim_state = NC_CONF_ENABLED; + SET_STATE(STATE_NC_PROC, NC_ACQUIRE); + switch(tim_state) + { + case NC_TIM_STOPPED: + if (alr_data->nc_data.ppos_req) + nc_process_pos_req (alr_data->nc_data.ppos_req); + /* Load the 10sec timer counter variable */ + nc_start_ncsync(); + break; + case NC_CONF_PENDING: + if (alr_data->nc_data.ppos_req) + nc_process_pos_req (alr_data->nc_data.ppos_req); + else + nc_start_ncell_confirm(); + break; + case NC_CONF_DISABLED: + if (alr_data->nc_data.ppos_req) + nc_process_pos_req (alr_data->nc_data.ppos_req); + else if (alr_data->nc_data.c_nc_timer EQ 0) + nc_start_ncell_confirm(); /* a confirmation is to restart */ + break; + default: + break; + } + + +/*XXX add PBCCH here also */ +#ifdef GPRS + if ((st EQ NC_DEDICATED OR st EQ NC_PIM_PBCCH OR st EQ NC_PTM_PBCCH) AND +#else + if ((st EQ NC_DEDICATED) AND +#endif + alr_data->nc_data.c_nc_timer > TEN_SECONDS) + { + alr_data->nc_data.c_nc_timer = TEN_SECONDS; + } + else if (alr_data->nc_data.c_nc_timer EQ 0) + { + if( st EQ NC_DEDICATED OR alr_data->nc_data.eotd_avail +#ifdef GPRS + OR st EQ NC_PIM_PBCCH OR st EQ NC_PTM_PBCCH +#endif + ) + alr_data->nc_data.c_nc_timer = TEN_SECONDS; + else + alr_data->nc_data.c_nc_timer = THIRTY_SECONDS; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_disable_conf | ++--------------------------------------------------------------------+ + + PURPOSE : Maintains what happens after TIM_NCSYNC expiry. + prevents ncell confirmation +*/ +LOCAL void nc_disable_conf(BOOL bFree) +{ + TRACE_EVENT("nc_disable_conf()"); + switch(alr_data->nc_data.tim_state) + { + case NC_TIM_STOPPED: + case NC_CONF_PENDING: + TRACE_ERROR("nc_disable_conf() in unexpected state"); + break; + default: + break; + } + + if(bFree AND (alr_data->nc_data.ppos_ind NEQ NULL)) + { + PFREE(alr_data->nc_data.ppos_ind); + alr_data->nc_data.ppos_ind = NULL; + } + + if(GET_STATE(STATE_NC_PROC) EQ NC_CONFIRM) + { + /* + * restart confirmation if it was aborted + * after the first expiry after the POS_REQ is done. + */ + alr_data->nc_data.c_nc_timer = 0; + } + + SET_STATE(STATE_NC_PROC, NC_ACQUIRE); + alr_data->nc_data.tim_state = NC_CONF_DISABLED; +} + +LOCAL void nc_start_ncell_confirm(void) +{ + BOOL acquire = FALSE; + + switch(GET_STATE(STATE_NC)) + { + case NC_DEDICATED: + case NC_IDLE: +#ifdef GPRS + case NC_PIM_PBCCH: + case NC_PTM_PBCCH: +#endif + if (alr_data->nc_data.eotd_avail AND + alr_data->nc_data.c_nc_timer EQ 0) + { + alr_data->nc_data.c_nc_timer = TEN_SECONDS; + + nc_stop_all(); + nc_check_status(CHECK_FOR_CONFIRM); + nc_start_eotd_confirm(); + } + else if ((alr_data->nc_data.c_nc_timer EQ 0) OR + (alr_data->nc_data.c_sync_intrupted EQ TRUE) ) + { + /* + * confirm ncells every thirty seconds in idle + * or every 10 seconds in dedicated + */ + if (GET_STATE(STATE_NC) EQ NC_DEDICATED +#ifdef GPRS + OR GET_STATE(STATE_NC) EQ NC_PIM_PBCCH + OR GET_STATE(STATE_NC) EQ NC_PTM_PBCCH +#endif + ) + alr_data->nc_data.c_nc_timer = TEN_SECONDS; + else + alr_data->nc_data.c_nc_timer = THIRTY_SECONDS; + nc_stop_all(); + nc_check_status(CHECK_FOR_CONFIRM); + nc_ncell_list_req(); + /* if a list_req was send we are in NC_CONFIRM + if no list_req was send we are in NC_ACQUIRE + This is needed for PBCCH, because there are + no measurements in ALR to trigger the initial + synchronizations, so we have to check this here + if no list_req was send, when a list_req was send + then we continue with initial sync after the last + sync_ind + */ + if(GET_STATE(STATE_NC_PROC) EQ NC_ACQUIRE) + acquire = TRUE; + + } + else /* acquire ncells (initial or previous failed ones) or + * read bcch + */ + { + acquire = TRUE; + } + + if(acquire EQ TRUE) + { + SET_STATE(STATE_NC_PROC, NC_ACQUIRE); + nc_check_status(CHECK_FOR_ACQUIRE_AND_BCCH_AND_FAIL); + nc_process_status(); + } + break; + default: + TRACE_ERROR("nc_ncsync_tim_expiry in wrong state"); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_start_ncsync | ++--------------------------------------------------------------------+ + PURPOSE : Assigns/resets c_ncsync_tim counter +*/ +LOCAL void nc_start_ncsync (void) +{ + alr_data->nc_data.c_ncsync_tim = TEN_SECONDS_NCSYNC; + TRACE_EVENT("NCSYNC counter loaded with 10 seconds"); + vsi_t_time(VSI_CALLER &alr_data->nc_data.ncsync_start_tim); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_ncsync_tim_expiry | ++--------------------------------------------------------------------+ + PURPOSE : Called at the end of 10 seconds interval for NCELL synchronization + +*/ +GLOBAL void nc_ncsync_tim_expiry(void) +{ + UBYTE i; + UBYTE c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + T_NC* pcell; + + #ifdef GPRS + if(!alr_data->gprs_data.pbcch) + #endif + { + T_TIME tval; + vsi_t_time(VSI_CALLER &tval); + if(tval<alr_data->nc_data.ncsync_start_tim) + TRACE_EVENT_P2("NCSYNC expiry at %d milliseconds, BS_PA_MFRMS = %d", + ULONG_MAX-alr_data->nc_data.ncsync_start_tim+tval, + alr_data->bs_pa_mfrms+2); + else + TRACE_EVENT_P2("NCSYNC expiry at %d milliseconds, BS_PA_MFRMS = %d", + tval-alr_data->nc_data.ncsync_start_tim, + alr_data->bs_pa_mfrms+2); + } + + + + if (alr_data->nc_data.tim_state NEQ NC_TIM_STOPPED) + { + #ifdef GPRS + if(!alr_data->gprs_data.pbcch) + #endif + { + nc_start_ncsync(); + } + + if (alr_data->nc_data.c_nc_timer > 0) + alr_data->nc_data.c_nc_timer--; + TRACE_EVENT_P1("c_nc_timer %d", alr_data->nc_data.c_nc_timer); + + /* decrement counters */ + for (i=0,pcell = &alr_data->nc_data.cell[0]; i < c_ba_arfcn; i++,pcell++) + { + if (pcell->c_sync > 0 AND pcell->c_sync < C_INVALID_SYNC) + pcell->c_sync--; + if (pcell->c_bcch > 0 AND pcell->c_bcch < C_INVALID_BCCH) + pcell->c_bcch--; + + if(pcell->ba_arfcn NEQ alr_data->serving_cell) + { + switch(pcell->ba_status) + { + case NOT_IN_BA_SHORT: + pcell->ba_status = NOT_IN_BA_LONG; +#if defined(TRACING) + TRACE_EVENT_P2 ("NC%u[%u] -> NOT_IN_BA_LONG", i, pcell->ba_arfcn); +#endif /* TRACING */ + break; + case NOT_IN_BA_LONG: +#if defined(TRACING) + TRACE_EVENT_P2 ("NC%u[%u] remove", i, pcell->ba_arfcn); + /* this trace must be performed before the removal to get right results */ +#endif /* TRACING */ + c_ba_arfcn = nc_remove_channel_from_ba_list (i); + i--; + pcell--; + ALR_TRACE_ALL_NC (); + break; + case IN_BA: + /* do nothing */ + break; + } + } + } + } + + switch(alr_data->nc_data.tim_state) + { + case NC_CONF_ENABLED: + nc_start_ncell_confirm(); + break; + case NC_CONF_DISABLED: + alr_data->nc_data.tim_state = NC_CONF_PENDING; + break; + case NC_CONF_PENDING: + TRACE_ERROR("TIM_NCSYNC expiry in unexpected state"); + /* + * this should never happen, but in case ALR is waiting + * more than 20 seconds for the last MPHC_NCELL_SYNC_IND of the + * confirmation procedure and the reason isn't a position request, + * then the confirmation procedure is restarted + */ + if (GET_STATE(STATE_NC_PROC) EQ NC_CONFIRM AND + alr_data->nc_data.ppos_req EQ NULL) + { + alr_data->nc_data.c_nc_timer = 0; + nc_start_ncell_confirm(); + } + break; + } +} +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_init_pos_ind | ++--------------------------------------------------------------------+ + + PURPOSE : initial setting of a MPH_NCELL_POS_IND + +*/ + +LOCAL void nc_init_pos_ind (USHORT req_id) +{ + memset(&(alr_data->nc_data.ppos_ind->eotd_sc_res), 0, sizeof (T_eotd_sc_res )); + memset(&(alr_data->nc_data.ppos_ind->eotd_sc_res1), 0, sizeof (T_eotd_sc_res1)); + alr_data->nc_data.ppos_ind->c_eotd_nc_res = 0; + alr_data->nc_data.ppos_ind->req_id = req_id; + alr_data->nc_data.ppos_ind->eotd_res = 0; +} +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_is_sync | ++--------------------------------------------------------------------+ + + PURPOSE : checks whether a ncell is synchronized and timing values + are valid + +*/ +LOCAL BOOL nc_is_sync (T_NC * p_ncell) +{ + switch (p_ncell->status) + { + case FB_SB_SYNC: + case READ_SB: + case READ_SB_BCCH: + case READ_BCCH: + case READ_BCCH_RR_NOT_INFORMED: + case IDLE_SYNC: + return TRUE; + default: + return FALSE; + } +} +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_ncell_pos_req | ++--------------------------------------------------------------------+ + + PURPOSE : reception of a ncell_pos_req + +*/ + +void nc_ncell_pos_req (T_MPH_NCELL_POS_REQ* pos_req) +{ + /* if there is an earlier position request disgard it*/ + if (alr_data->nc_data.ppos_req NEQ NULL) + PFREE(alr_data->nc_data.ppos_req); + /* store the request until the end of the respective position indication */ + alr_data->nc_data.ppos_req = pos_req; + + /* + * process the request immediately if confirmation is enabled or + * another measurement is in progress + * (otherwise start processing when confirmation becomes enabled + */ + if ( (alr_data->nc_data.tim_state EQ NC_CONF_ENABLED) OR + (alr_data->nc_data.tim_state EQ NC_CONF_DISABLED AND + GET_STATE(STATE_NC_PROC) EQ NC_CONFIRM) ) + nc_process_pos_req(pos_req); +} +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_process_pos_req | ++--------------------------------------------------------------------+ + + PURPOSE : processes a ncell_pos_req + +*/ + +LOCAL void nc_process_pos_req (T_MPH_NCELL_POS_REQ* pos_req) +{ + UBYTE fail=1; + + if (alr_data->nc_data.ppos_ind EQ NULL) + { + PALLOC (pos_ind, MPH_NCELL_POS_IND); + alr_data->nc_data.ppos_ind = pos_ind; + } + + nc_init_pos_ind(pos_req->req_id); + +#if 0 /* allow position requests also in NC_IDLE mode to be able to answer a test SMS */ + switch(GET_STATE(STATE_NC)) + { + case NC_DEDICATED: +#endif /* 0|1 */ + if(alr_data->nc_data.eotd_avail) + { + T_NC* p_ncell; + T_ncell_eotd* p_ncell_pos = &pos_req->ncell_eotd[0]; + T_NC* list_of_asd_1o12 [12]; + T_ncell_eotd* list_of_asd_ba [15]; + T_ncell_eotd* list_of_asd [15]; + T_NC** p_asd_1o12 = &list_of_asd_1o12[0]; + T_ncell_eotd** p_asd_ba = &list_of_asd_ba[0]; + T_ncell_eotd** p_asd = &list_of_asd[0]; + UBYTE c_ba = alr_data->nc_data.c_ba_arfcn; + UBYTE i,j; + UBYTE c_list; + UBYTE found; + + fail=0; + + nc_stop_all(); + + /* + * generate and send an appropriate MPHC_NCELL_LIST_SYNC_REQ + * 1/ take all ncells which are in ASD list and the twelve + * strongest synchronized of the BA list (using timing values + * from former synchronisation) + * 2/ then all ncells which are in ASD list and in the BA list + * (using timings from the ASD list) + * 3/ then rest of ASD cells (using timings from the ASD list) + * 4/ then rest of BA list cells which are synchronized (using + * timing values from former synchronisation) + */ + { + PALLOC (ncell_list_req, MPHC_NCELL_LIST_SYNC_REQ); + ncell_list_req->eotd = TRUE; + + /* for all ncells in ASD list */ + for(j=0; j < MAX_NCELL_EOTD_L1 AND j < pos_req->c_ncell_eotd; + j++, p_ncell_pos++) + { + if (p_ncell_pos->arfcn EQ alr_data->serving_cell) + { + continue; + } + /* look if it is in BA list */ + found=FALSE; + for (i = 0, p_ncell = &alr_data->nc_data.cell[0]; i < c_ba; i++, p_ncell++) + { + if(p_ncell_pos->arfcn EQ p_ncell->ba_arfcn) + { + /* + * if it is in both list then check + * if it is synchronized or not + * and use the correct list + */ + if(nc_is_sync(p_ncell)) + { /* case 1/ */ + *(p_asd_1o12++) = p_ncell; + found=TRUE; + } + else + { /* case 2/ */ + *(p_asd_ba++) = p_ncell_pos; + found=TRUE; + } /* is sync */ + break; + } /*arfcn*/ + } /*ba list*/ + + /* if nothing was found, then it is case 3/ */ + if(!found) + *(p_asd++) = p_ncell_pos; + + } /* asd list */ + + c_list=0; + for(i=0; c_list < MAX_L1_SYNC_CNT AND i < p_asd_1o12-list_of_asd_1o12;i++) + { + nc_ncell_list_req_pos(&ncell_list_req->ncell_list[c_list++], + NULL, + list_of_asd_1o12[i]->ba_arfcn); + } /*asd_1o12 */ + for(i=0 ;c_list < MAX_L1_SYNC_CNT AND i < p_asd_ba-list_of_asd_ba;i++) + { + nc_ncell_list_req_pos(&ncell_list_req->ncell_list[c_list++], + list_of_asd_ba[i], + list_of_asd_ba[i]->arfcn); + + } + for(i=0 ;c_list < MAX_L1_SYNC_CNT AND i < p_asd-list_of_asd;i++) + { + nc_ncell_list_req_pos(&ncell_list_req->ncell_list[c_list++], + list_of_asd[i], + list_of_asd[i]->arfcn); + } + /* + * fill the ncell list req with the remaining synchronized + * neigbour cells of the BA list (case 4/ ) + */ + for (i=0, p_ncell = &alr_data->nc_data.cell[0]; + c_list < MAX_L1_SYNC_CNT AND i < c_ba; + i++, p_ncell++) + { + if (p_ncell->ba_arfcn EQ alr_data->serving_cell) + { + continue; + } + if (nc_is_sync(p_ncell)) + { + USHORT l1_arfcn = ARFCN_TO_L1(p_ncell->ba_arfcn); + found=FALSE; + for (j=0; j < c_list;j++) + { + if (ncell_list_req->ncell_list[j].radio_freq EQ l1_arfcn) + { + found = TRUE; + break; + } + } /* MPHC_NCELL_LIST_SYNC_REQ */ + if (!found) + nc_ncell_list_req_pos(&ncell_list_req->ncell_list[c_list++], + NULL, + p_ncell->ba_arfcn); + } /* is sync */ + } /* BA list */ + + if (c_list > 0) + { + ncell_list_req->list_size = c_list; + alr_data->nc_data.c_sync_req = c_list; + if (c_list < MAX_NCELL_EOTD_L1) + memset(&(ncell_list_req->ncell_list[c_list]), + 0, + (MAX_NCELL_EOTD_L1 - c_list) * sizeof(T_ncell_list)); + + alr_data->nc_data.c_sync_req += 2; /* for the 2 scell ind's */ + nc_disable_conf(DONT_FREE_POS_IND); + SET_STATE(STATE_NC_PROC, NC_CONFIRM); + ma_nc_list_sync_req (ncell_list_req); + TRACE_EVENT_P1("MPHC_NCELL_LIST_SYNC_REQ eotd=TRUE c_sync_req=%u", alr_data->nc_data.c_sync_req); + } + else + fail = TRUE; + }/* PALLOC list_req */ + } /* eotd_avail */ + /* else fail=1*/ +#if 0 + break; + default: + /*fail=1*/ + break; + } /*switch NC_STATE*/ +#endif /* 0|1 */ + + if(fail) + { /* TODO complete ?? */ + alr_data->nc_data.ppos_ind->eotd_res = EOTD_REF; + PSENDX(RR, alr_data->nc_data.ppos_ind); + alr_data->nc_data.ppos_ind = NULL; + PFREE(pos_req); + alr_data->nc_data.ppos_req = NULL; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_ncell_list_req_pos | ++--------------------------------------------------------------------+ + + PURPOSE : Handles cell lists. + +*/ + +LOCAL void nc_ncell_list_req_pos(T_ncell_list* p_ncell_list, + T_ncell_eotd* asd_cell, + USHORT arfcn) +{ + USHORT index = nc_get_index(arfcn); + + p_ncell_list->radio_freq = ARFCN_TO_L1(arfcn); + + if(asd_cell) + { + if(index NEQ NOT_PRESENT_16BIT AND index NEQ LAST_BSIC_REQ AND + alr_data->nc_data.cell[index].status EQ IDLE_SYNC) + { + p_ncell_list->fn_offset = alr_data->nc_data.cell[index].frame_offset; + p_ncell_list->time_alignment = alr_data->nc_data.cell[index].time_align; + p_ncell_list->timing_validity = TV_VALID_TIMING_INFO; + /*TODO what about reception of ncell_sync_ind for this cell + are timing info and counter updated ?*/ + } + else + { + nc_get_timing_eotd(p_ncell_list, asd_cell); + p_ncell_list->timing_validity = TV_VALID_TIMING_INFO; /* TV_APPROX_TIMING_INFO;*/ + } + } /*asd_cell*/ + else + { + if(index NEQ NOT_PRESENT_16BIT AND index NEQ LAST_BSIC_REQ) + { + /* cell is in BA list and 1o12, so use the data we have */ + switch(alr_data->nc_data.cell[index].status) + { + case READ_SB_BCCH: + case READ_BCCH: + nc_set_status(index,READ_SB_BCCH_PENDING); + break; + case READ_SB: + case FB_SB_SYNC: + nc_set_status(index,READ_SB_PENDING); + break; + case READ_FB_SB: + case READ_BCCH_RR_NOT_INFORMED: + case FB_SB_SYNC_RR_NOT_INFORMED: + /*TODO what about reception of ncell_sync_ind for this cell + are timing info and counter updated ?*/ + break; + } /*status*/ + p_ncell_list->fn_offset = alr_data->nc_data.cell[index].frame_offset; + p_ncell_list->time_alignment = alr_data->nc_data.cell[index].time_align; + p_ncell_list->timing_validity = TV_VALID_TIMING_INFO; + } + else + { + TRACE_ERROR("nc_ncell_list_req_pos: asd_cell==0 but cell not in BA"); + } + }/*asd_cell*/ +} + +LOCAL void nc_get_timing_eotd(T_ncell_list* p_ncell_list, + T_ncell_eotd* asd_cell) +{ + USHORT td, adjust = 0, offs; + /* + * The values mfrm_offset, rough_rtd and exp_otd are differences + * between the BTS in question and the reference BTS. + * L1 expects the differences between serving BTS and BTS in question: + * + * +----+----+----+----+----+....+----+----+----+----+----+ serving BTS + * 0 51 + * | + * 0 Net | L1 1250 (5000) + * +---->V<----+ + * \ / + * \ / + * +----+----+----+----+----+....+----+----+----+----+----+ BTS in question + * 0 51 + * +-----Net----->| |<---------L1----------------------+ + * + * time differences are indicated in bits by the net, but expected + * in quarterbits by L1 + */ + + offs = asd_cell->mfrm_offset; + + if (asd_cell->otd_type EQ BOTH_OTD) + { + int diff = asd_cell->rough_rtd - asd_cell->exp_otd; + if (diff >= 850) + adjust = 1; + else if (diff <= -850) + adjust = -1; + /* + * GSM 04.31 section A.2.2.3 version 8.7.0 says that adjust shall be + * equal 0 for -400 <= diff <= 400 and states an error for + * -850 < diff < -450 and for 450 < diff < 850, but doesn't + * describe the behaviour in this cases. + * All this valid and invalid cases are implemented here by + * adjust = 0 + */ + } + + if (asd_cell->otd_type EQ ROUGH_OTD) + td = asd_cell->rough_rtd; + else + { /* + * uncertainty indicates how many bits the search window + * for measurement should be opended earlier than the expected + * value. Because of the subsequent subtraction we have to ADD + * the uncertainty value. + * no special handling for uncertainty value 7 (uncertainty > 30 bits) + * is implemented yet + */ + td = asd_cell->exp_otd + unc_values[asd_cell->uncertainty]; + if (td >= 1250) + offs++; + } + td %= 1250; + + if (td) + { + p_ncell_list->time_alignment = 5000 - 4 * td; + offs++; + } + else + p_ncell_list->time_alignment = 0; + + offs = (offs + adjust) % 51; + + if (offs) + p_ncell_list->fn_offset = 51 - offs; + else + p_ncell_list->fn_offset = 0; +} +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_start_eotd_confirm | ++--------------------------------------------------------------------+ + + PURPOSE : generates an MPHC_NCELL_LIST_SYNC_REQ from the BA list. +*/ +LOCAL void nc_start_eotd_confirm(void) +{ + /* + * this check is needed for the resume + * in the GPRS case because we need + * to keep the states over a + * start transition + */ + if(alr_data->nc_data.ppos_ind EQ NULL) + { + PALLOC (pos_ind, MPH_NCELL_POS_IND); + alr_data->nc_data.ppos_ind = pos_ind; + } + nc_init_pos_ind (NOT_PRESENT_16BIT); + + /* generate and send an appropriate MPHC_NCELL_LIST_SYNC_REQ */ + nc_ncell_list_req(); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_ncell_list_req | ++--------------------------------------------------------------------+ + + PURPOSE : generates an MPHC_NCELL_LIST_SYNC_REQ based on the 12 + strongest neighbour cells of the BA + +*/ +LOCAL void nc_ncell_list_req (void) +{ + UBYTE c_found = 0, found, i, validity; + USHORT c_ba = alr_data->nc_data.c_ba_arfcn; + T_NC* pcell; + T_ncell_list *pnc; + PALLOC (ncell_list_req, MPHC_NCELL_LIST_SYNC_REQ); + + if (alr_data->nc_data.c_sync_req NEQ 0) + TRACE_EVENT_P1("nc_ncell_list_req with c_sync_req=%u before", alr_data->nc_data.c_sync_req); + + ncell_list_req->eotd = alr_data->nc_data.eotd_avail; + + nc_stop_all(); + for (i = 0, pcell = &alr_data->nc_data.cell[0]; i < c_ba; i++, pcell++) + { + if (alr_data->nc_data.eotd_avail AND pcell->ba_arfcn EQ alr_data->serving_cell) + { + continue; + } + if (pcell->one_of_twelve) + { + switch (pcell->status) + { + case READ_SB: + nc_set_status(nc_get_index(pcell->ba_arfcn), READ_SB_PENDING); + found = TRUE; + validity = TV_VALID_TIMING_INFO; + break; + case READ_SB_BCCH: + nc_set_status(nc_get_index(pcell->ba_arfcn), READ_SB_BCCH_PENDING); + found = TRUE; + validity = TV_VALID_TIMING_INFO; + break; + /* TODO(opt): if !eotd_avail maybe optimize later + case READ_FB_SB: + break*/ + /* + case READ_BCCH_RR_NOT_INFORMED: + case READ_BCCH_PENDING_RR_NOT_INFORMED: + case READ_BCCH: + case READ_BCCH_PENDING: + found = TRUE; + validity = TV_VALID_TIMING_INFO; + break;*/ + default: + found = FALSE; + validity = TV_INVALID_TIMING_INFO; + break; + } + + if (found) + { + pnc = &(ncell_list_req->ncell_list[c_found++]); + pnc->radio_freq = ARFCN_TO_L1(pcell->ba_arfcn); + if (validity EQ TV_VALID_TIMING_INFO) + { + pnc->fn_offset = pcell->frame_offset; + pnc->time_alignment = pcell->time_align; + } + else + { + pnc->fn_offset = 0; + pnc->time_alignment = 0; + } + pnc->timing_validity = validity; + } + } + } + + /* + * in case there are no synchronized neighbour cells + * send an empty MPHC_NCELL_LIST_SYNC_REQ to L1 + * (to serve the cursor task later with a position indication + * containing measurements of the serving cell only) + */ + if(c_found OR alr_data->nc_data.eotd_avail) + { + ncell_list_req->list_size = c_found; + alr_data->nc_data.c_sync_req = c_found; + if (c_found < MAX_NCELL_EOTD_L1) + memset(&(ncell_list_req->ncell_list[c_found]), + 0, + (MAX_NCELL_EOTD_L1 - c_found) * sizeof(T_ncell_list)); + + if(alr_data->nc_data.eotd_avail) + /* add the 2 scell sync_ind */ + alr_data->nc_data.c_sync_req += 2; + + nc_disable_conf(DONT_FREE_POS_IND); + SET_STATE(STATE_NC_PROC, NC_CONFIRM); + ma_nc_list_sync_req (ncell_list_req); + TRACE_EVENT_P3("MPHC_NCELL_LIST_SYNC_REQ eotd=%d c_sync_req=%u SC=%u", + alr_data->nc_data.eotd_avail, + alr_data->nc_data.c_sync_req, + alr_data->serving_cell); + } + else + { + PFREE(ncell_list_req); + SET_STATE(STATE_NC_PROC, NC_ACQUIRE); + nc_enable_conf(); + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_store_eotd | ++--------------------------------------------------------------------+ + + PURPOSE : copies the measurement results into the MPH_NCELL_POS_IND + +*/ +LOCAL void nc_store_eotd (T_eotd_sc_res * p_res, + T_MPHC_NCELL_SYNC_IND * sync_ind, + USHORT arfcn) +{ + p_res->sb_flag = sync_ind->sb_flag; + p_res->bsic = sync_ind->bsic; + p_res->arfcn = arfcn; + memcpy(&(p_res->eotd_crosscor), + &(sync_ind->a_eotd_crosscor), + sizeof(sync_ind->a_eotd_crosscor)); + p_res->d_eotd_nrj = sync_ind->d_eotd_nrj; + p_res->time_tag = sync_ind->time_tag; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_stop_ext_meas_ind | ++--------------------------------------------------------------------+ + + PURPOSE : Notify RR about the end of the end of the Extended + Measurement procedure. + +*/ +GLOBAL void nc_stop_ext_meas_ind (void) +{ + PALLOC ( mph_sync_ind, MPH_SYNC_IND ); + mph_sync_ind->cs = CS_STOP_PLMN_SEARCH; + mph_sync_ind->arfcn = NOT_PRESENT_16BIT; + PSENDX ( RR, mph_sync_ind ); + + if( alr_data->cs_data.p_power_cnf NEQ NULL ) + { + PFREE(alr_data->cs_data.p_power_cnf) + alr_data->cs_data.p_power_cnf = NULL; + } + if( IS_EXT_MEAS_RUNNING )/*alr_data->cs_data.mph_ext_meas_req NEQ NULL */ + { + PFREE ( alr_data->cs_data.mph_ext_meas_req ); + alr_data->cs_data.mph_ext_meas_req = NULL; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_stop_rr_activity | ++--------------------------------------------------------------------+ + + PURPOSE : Stop BCCH reading or PLMN seach originated by RR. + +*/ +GLOBAL void nc_stop_rr_activity (UBYTE stop) +{ + /* + * RR signals stop BCCH reading or stop PLMN search + */ + if( (IS_EXT_MEAS_RUNNING) AND + (alr_data->nc_data.cell[LAST_BSIC_REQ].status EQ READ_FB_SB_PENDING) ) + { + /* + * Wait for MPHC_NCELL_SYNC_IND or MPHC_STOP_NCELL_SYNC_CON + */ + alr_data->cs_data.ext_meas_state_pend = CS_ACTIVE_SYNC; + } + nc_clear_last_bsic(); + + /* + * RR signals end of PLMN search + */ + if (stop) + { + alr_data->plmn_search_running = FALSE; + nc_enable_conf(); + } + + if ( IS_EXT_MEAS_RUNNING AND (alr_data->cs_data.ext_meas_state_pend EQ CS_NULL) ) + { + nc_stop_ext_meas_ind(); + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_bsic_req | ++--------------------------------------------------------------------+ + + PURPOSE : Request of RR to search for frequency correction + burst and synchron burst. + +*/ + +GLOBAL void nc_bsic_req (T_MPH_BSIC_REQ *mph_bsic_req) +{ + USHORT i; + + mph_bsic_req->arfcn &= ARFCN_MASK; + ALR_TRACE_NC_BSIC_REQ (mph_bsic_req->arfcn); + + ALR_EM_NEIGHBOURCELL_BSIC_REQUEST; + + nc_clear_last_bsic(); + + /* + * look if the requested channel number is also in the normal + * BA list to stop it. + */ + i = nc_get_index( mph_bsic_req->arfcn ); + + switch(i) + { + case NOT_PRESENT_16BIT: + case LAST_BSIC_REQ: + break; + default: + nc_stop_if_active(i); + TRACE_ERROR("bsic_req for arfcn which is in BA list"); + break; + } + + + /* + * fill in parameters for BSIC request + */ + nc_set_status (LAST_BSIC_REQ, READ_FB_SB); + alr_data->nc_data.cell[LAST_BSIC_REQ].ba_arfcn = mph_bsic_req->arfcn; + + /* + * forward synchronisation request to layer 1, if not full + */ + if (alr_data->nc_data.c_sync_req < MAX_L1_SYNC_CNT) + { + /* + * reset if we are in NC_CON_EST + */ + + if(GET_STATE(STATE_NC) EQ NC_CON_EST +#ifdef GPRS + AND !alr_data->gprs_data.pbcch +#endif + ) + { + SET_STATE(STATE_NC, NC_IDLE); + } +#ifdef GPRS + else if(GET_STATE(STATE_NC) EQ NC_CON_EST AND + alr_data->gprs_data.pbcch) /* AND */ +/* add later alr_data->gprs_data.pim) */ + { + SET_STATE(STATE_NC, NC_PIM_PBCCH); + } +#endif + + nc_process_status (); + } + +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : alr_nc | +| STATE : code ROUTINE : nc_bcch_ind | ++--------------------------------------------------------------------+ + + PURPOSE : Reception of a system information message for a neighbourcell. + +*/ + +GLOBAL void nc_bcch_ind (T_MPHC_NCELL_BCCH_IND *data_ind) +{ + USHORT index; + UBYTE msg_t = data_ind->l2_frame.content[SI_CONTENTS_MSG_T]; + + if (alr_data->nc_data.cell[LAST_BSIC_REQ].status EQ READ_BCCH_PENDING AND + alr_data->nc_data.cell[LAST_BSIC_REQ].ba_arfcn EQ ARFCN_TO_G23(data_ind->radio_freq)) + { + /* + * Cell selection or PLMN available search triggered by RR. + */ + if (data_ind->error_flag NEQ VALID_BLOCK) + { + /* + * Reception of an invalid block + */ + ALR_TRACE_NC ("invalid PLMN BCCH"); + + /* + * indicate BCCH read error to RR, too many errors are controlled by RR + */ + ma_error_ind (CS_BCCH_READ_ERROR, ARFCN_TO_G23(data_ind->radio_freq)); + } + else + { + UBYTE mt = data_ind->l2_frame.content[2]; + + ALR_TRACE_NC ("valid PLMN BCCH"); + + /* + * forward message to RR + */ + ma_send_unitdata ((T_MPHC_DATA_IND *)data_ind); + + switch (mt) + { + case D_SYS_INFO_3: + case D_SYS_INFO_4: + alr_data->nc_data.cell[LAST_BSIC_REQ].blocks_required = 0; + break; + + default: + /* + * Reception of any other message. Shall not happen after + * GSM 5.02 chapter 6.3.1.3 Mapping of BCCH data, but + * is possible for future extensions. + * Read this tc again plus all which are not read until now. + */ + break; + } + } + + /* + * all frames received, then decrement pending BCCH request + */ + if (alr_data->nc_data.cell[LAST_BSIC_REQ].blocks_required EQ 0) + { + + nc_set_status (LAST_BSIC_REQ, IDLE); + alr_data->nc_data.cell[LAST_BSIC_REQ].ba_arfcn = NOT_PRESENT_16BIT; + + /* + * L3 may avoid sending a stop message to terminate a NCELL_BCCH process + * if there no more pending request in L1 + */ + if (alr_data->nc_data.c_bcch_req > 0) + { + /* + * stop any ongoing request in layer 1 + */ + ma_nc_stop_ncell_bcch_req(ARFCN_TO_G23(data_ind->radio_freq)); + + /* + * decrement the number of pending requests in layer 1. + */ + alr_data->nc_data.c_bcch_req--; + } + } + else + { + /* + * stop pending request and start again. + */ + nc_restart_bcch (LAST_BSIC_REQ); + } + return ; + } + + /* + * Normal Ncell Handling, get position in neighbourcell list + */ + index = nc_get_index (ARFCN_TO_G23(data_ind->radio_freq)); + + if (index NEQ NOT_PRESENT_16BIT AND + index NEQ LAST_BSIC_REQ AND + (alr_data->nc_data.cell[index].status EQ READ_BCCH_PENDING OR + alr_data->nc_data.cell[index].status EQ READ_BCCH_PENDING_RR_NOT_INFORMED)) + { + /* + * normal member of the neighbourcell list and an answer is expected. + */ + if (data_ind->error_flag EQ VALID_BLOCK) + { + switch (msg_t) + { + case D_SYS_INFO_3: + /* + * Sys Info 3 contains the needed information in any case + */ +#if defined(TRACING) + TRACE_EVENT_P3("NC%u[%d] BCCH ok %s", + index, + alr_data->nc_data.cell[index].ba_arfcn EQ NOT_PRESENT_16BIT ? + -1 : alr_data->nc_data.cell[index].ba_arfcn&ARFCN_MASK, "si3"); +#endif /* TRACING */ + if (alr_data->nc_data.cell[index].status EQ READ_BCCH_PENDING_RR_NOT_INFORMED) + { + /* + * store data if RR is not informed yet about + * synchronisation + */ + nc_store_bcch((T_MPHC_DATA_IND *) data_ind, index,0); + nc_set_status (index, FB_SB_SYNC_RR_NOT_INFORMED); + } + else + { + /* + * forward information to RR + */ + ma_send_unitdata ((T_MPHC_DATA_IND *)data_ind); + nc_set_fb_sb_sync_initial (index); + + } + break; + + case D_SYS_INFO_4: + if ((data_ind->l2_frame.content[SI_CONTENTS_CS2] & ONLY_ACS) EQ 0) + { +#if defined(TRACING) + TRACE_EVENT_P3("NC%u[%d] BCCH ok %s", + index, + alr_data->nc_data.cell[index].ba_arfcn EQ NOT_PRESENT_16BIT ? + -1 : alr_data->nc_data.cell[index].ba_arfcn&ARFCN_MASK, "si4"); +#endif /* TRACING */ + /* + * additional cell selection info from sys info 7 or 8 is not necessary + */ + if (alr_data->nc_data.cell[index].status EQ READ_BCCH_PENDING_RR_NOT_INFORMED) + { + /* + * store data if RR is not informed yet about synchronisation + */ + nc_store_bcch((T_MPHC_DATA_IND *) data_ind, index,0); + nc_set_status (index, FB_SB_SYNC_RR_NOT_INFORMED); + } + else + { + /* + * forward information to RR + */ + ma_send_unitdata ((T_MPHC_DATA_IND *)data_ind); + nc_set_fb_sb_sync_initial (index); + + } + } + else + { +#if defined(TRACING) + TRACE_EVENT_P3("NC%u[%d] BCCH ok %s", + index, + alr_data->nc_data.cell[index].ba_arfcn EQ NOT_PRESENT_16BIT ? + -1 : alr_data->nc_data.cell[index].ba_arfcn&ARFCN_MASK, "si4_n78"); +#endif /* TRACING */ + /* + * additional information from system info 7 or 8 + * is needed for cell reselection purposes + */ + if(alr_data->nc_data.cell[index].status EQ READ_BCCH_PENDING_RR_NOT_INFORMED) + { + /* + * store data if RR is not informed yet about synchronisation + */ + nc_store_bcch((T_MPHC_DATA_IND *) data_ind, index,0); + } + else + { + /* + * forward information to RR + */ + ma_send_unitdata ((T_MPHC_DATA_IND *)data_ind); + } + + /* + * system info 3, 7 or 8 required + * -> tc = 2,6 for normal BCCH or 3,7 for extended BCCH + */ + alr_data->nc_data.cell[index].blocks_required = NCELL_BCCH_SI_3_7_8; + } + break; + + case D_SYS_INFO_7: + case D_SYS_INFO_8: + if (nc_sys_info_78_required (index)) + { +#if defined(TRACING) + TRACE_EVENT_P3("NC%u[%d] BCCH ok %s", + index, + alr_data->nc_data.cell[index].ba_arfcn EQ NOT_PRESENT_16BIT ? + -1 : alr_data->nc_data.cell[index].ba_arfcn&ARFCN_MASK, "si78"); +#endif /* TRACING */ + if(alr_data->nc_data.cell[index].status EQ READ_BCCH_PENDING_RR_NOT_INFORMED) + { + /* + * store data if RR is not informed yet about synchronisation + */ + nc_store_bcch((T_MPHC_DATA_IND *) data_ind, index,1); + nc_set_status (index, FB_SB_SYNC_RR_NOT_INFORMED); + } + else + { + /* + * forward information to RR + */ + ma_send_unitdata ((T_MPHC_DATA_IND *)data_ind); + nc_set_fb_sb_sync_initial (index); + + } + } + else + /* + * increment error counter and request tc again. + */ + alr_data->nc_data.cell[index].c_error++; + + break; + + default: + /* + * increment error counter and request tc again. + */ + alr_data->nc_data.cell[index].c_error++; + break; + } + } + else + { + /* + * BCCH reading failed + * + * error counter is incremented and tc shall be read again. + */ + alr_data->nc_data.cell[index].c_error++; + } + + /* + * restart next attempt + */ + if (alr_data->nc_data.cell[index].blocks_required EQ 0) + { + if (alr_data->nc_data.c_bcch_req > 0) + { + /* + * decrement number of pending BCCH requests in layer 1. + */ + alr_data->nc_data.c_bcch_req--; + + /* + * Stop the pending reading, if not all tc-s read + */ + ma_nc_stop_ncell_bcch_req (alr_data->nc_data.cell[index].ba_arfcn); + } + alr_data->nc_data.cell[index].c_attempt = 0; + + /* + * start next request to layer 1 if necessary + */ + nc_process_status (); + } + else + { + if (alr_data->nc_data.cell[index].c_error >= 4) + { + /* + * set status to failed or excluded depending on the failed + * attempt counter and/or restart for this channel. + */ + nc_sync_failed_attempt (index); + + /* + * L3 may avoid sending a stop message to terminate a NCELL_BCCH process + * if there no more pending request in L1 + */ + if (alr_data->nc_data.c_bcch_req > 0) + { + /* + * decrement number of pending BCCH requests in layer 1. + */ + alr_data->nc_data.c_bcch_req--; + + /* + * Stop the pending reading, if not all tc-s read + */ + ma_nc_stop_ncell_bcch_req (alr_data->nc_data.cell[index].ba_arfcn); + } + + /* + * start next request to layer 1 if necessary + */ + nc_process_status (); + } + else + { + /* + * restart the BCCH reading for this TC again. + */ + nc_restart_bcch (index); + } + } + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : alr_nc | +| STATE : code ROUTINE : nc_restart_bcch | ++--------------------------------------------------------------------+ + + PURPOSE : Stop old request and start new request to layer 1. + +*/ + +LOCAL void nc_restart_bcch (USHORT index) +{ + PALLOC (ncell_bcch, MPHC_NCELL_BCCH_REQ); + + if (alr_data->nc_data.c_bcch_req > 0) + { + /* + * if necessary stop previous request to avoid on the fly change + */ + ma_nc_stop_ncell_bcch_req(alr_data->nc_data.cell[index].ba_arfcn); + } + + ncell_bcch->radio_freq = ARFCN_TO_L1(alr_data->nc_data.cell[index].ba_arfcn); + ncell_bcch->fn_offset = alr_data->nc_data.cell[index].frame_offset; + ncell_bcch->time_alignment = alr_data->nc_data.cell[index].time_align; + ncell_bcch->tsc = (UBYTE)(alr_data->nc_data.cell[index].bsic & ONLY_BCC); + ncell_bcch->bcch_blocks_required = alr_data->nc_data.cell[index].blocks_required; +#ifdef GPRS + /*if the mobile is in PTM the GPRS_PRIORITY must be set to TOP*/ + if(ma_is_ptm()) + { + ncell_bcch->gprs_prio = GPRS_PRIO_TOP; + } + else +#endif + ncell_bcch->gprs_prio = GPRS_PRIO_NORM; + + /* + * and start next request + */ + ma_nc_bcch_req (ncell_bcch); +} +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : alr_nc | +| STATE : code ROUTINE : nc_store_sync_ind | ++--------------------------------------------------------------------+ + + PURPOSE : stores the data of an MPHC_NCELL_SYNC_IND end enters + a new state of ncell. + +*/ + +LOCAL void nc_store_sync_ind (USHORT index, + T_MPHC_NCELL_SYNC_IND *sync_ind, + UBYTE new_status) +{ + T_NC* pcell = &alr_data->nc_data.cell[index]; + pcell->bsic = (UBYTE)(sync_ind->bsic & ONLY_BSIC); + pcell->frame_offset = sync_ind->fn_offset; + pcell->time_align = sync_ind->time_alignment; + pcell->tim_valid = TV_VALID_TIMING_INFO; + nc_set_status (index, new_status); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : alr_nc | +| STATE : code ROUTINE : nc_sync_ind | ++--------------------------------------------------------------------+ + + PURPOSE : Confirmation for a synchronisation request to layer 1. + +*/ + +GLOBAL void nc_sync_ind (T_MPHC_NCELL_SYNC_IND *sync_ind) +{ + USHORT index; + UBYTE bsic = (UBYTE)(sync_ind->bsic & ONLY_BSIC); + USHORT arfcn = ARFCN_TO_G23(sync_ind->radio_freq)&ARFCN_MASK; + index = nc_get_index (arfcn); + + switch (GET_STATE (STATE_NC)) + { + case NC_IDLE: + case NC_DEDICATED: +#ifdef GPRS + case NC_PIM_PBCCH: + case NC_PTM_PBCCH: /*XXX*/ +#endif + TRACE_EVENT_P5("nc_sync_ind[%d] sb_flag=%d fn_offset=%ld time_alignment=%ld bsic=%d", + arfcn, sync_ind->sb_flag, sync_ind->fn_offset, + sync_ind->time_alignment, sync_ind->bsic); + if (alr_data->nc_data.c_sync_req > 0) + alr_data->nc_data.c_sync_req--; + + if (alr_data->nc_data.cell[LAST_BSIC_REQ].status EQ READ_FB_SB_PENDING AND + alr_data->nc_data.cell[LAST_BSIC_REQ].ba_arfcn EQ arfcn AND +#ifdef GPRS + (GET_STATE(STATE_NC) EQ NC_IDLE OR GET_STATE(STATE_NC) EQ NC_PIM_PBCCH) + ) +#else + GET_STATE(STATE_NC) EQ NC_IDLE + ) +#endif + { + nc_sync_ind_last_bsic_req(sync_ind,index,arfcn,bsic); + } + else + { + if (index NEQ NOT_PRESENT_16BIT AND + index NEQ LAST_BSIC_REQ) + { + nc_sync_ind_ncell(sync_ind,index,arfcn,bsic); + } /* valid index check */ + else if (alr_data->nc_data.eotd_avail AND + alr_data->nc_data.ppos_ind NEQ NULL) + nc_check_sync_ind_eotd(sync_ind, arfcn); + /* LAST_BSIC_REQ check */ + else if ( (index EQ NOT_PRESENT_16BIT) AND (IS_EXT_MEAS_RUNNING) AND + (GET_STATE(STATE_NC) EQ NC_IDLE)) + { + if ( alr_data->cs_data.ext_meas_state_pend NEQ CS_NULL ) + { + nc_stop_ext_meas_ind(); + alr_data->cs_data.ext_meas_state_pend = CS_NULL; + return; + } + } + } + + if( alr_data->nc_data.c_sync_intrupted EQ TRUE AND alr_data->nc_data.c_sync_req EQ 0) + { + nc_enable_conf(); + alr_data->nc_data.c_sync_intrupted = FALSE; + } + + if(GET_STATE(STATE_NC_PROC) EQ NC_ACQUIRE) + { + nc_process_status(); + } + + break; + default: + break; + } /* STATE_NC */ +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : alr_nc | +| STATE : code ROUTINE : nc_sync_ind_last_bsic_req | ++--------------------------------------------------------------------+ + + PURPOSE : Confirmation of the LAST_BSIC_REQ synchronisation request + +*/ + +LOCAL void nc_sync_ind_last_bsic_req(T_MPHC_NCELL_SYNC_IND* sync_ind, + USHORT index, + USHORT arfcn, + UBYTE bsic) +{ + + /* + * decoding of FB / SB of hplmn cell is in progress + * send confirmation to RR. + */ + PALLOC (mph_bsic_cnf, MPH_BSIC_CNF); + + mph_bsic_cnf->arfcn = arfcn; + mph_bsic_cnf->bsic = bsic; + + if (sync_ind->sb_flag EQ SB_FOUND) + { + ALR_TRACE_NC_BSIC_CNF(sync_ind->radio_freq); + + /* + * FCB and SCB found, set result code + */ + mph_bsic_cnf->cs = CS_NO_ERROR; + + if ( IS_EXT_MEAS_RUNNING ) + { + nc_set_status (LAST_BSIC_REQ, IDLE); + alr_data->nc_data.cell[LAST_BSIC_REQ].ba_arfcn = NOT_PRESENT_16BIT; + + if ( alr_data->cs_data.ext_meas_state_pend NEQ CS_NULL ) + { + PFREE ( mph_bsic_cnf ); + nc_stop_ext_meas_ind(); + } + else + { + ma_bsic_cnf (mph_bsic_cnf); + } + return; + } + + ALR_EM_NEIGHBOURCELL_BCCH(EM_AVAIL); + + /* save data for next cell reselection */ + { + T_NC *pcr_cell = &alr_data->nc_data.cr_cell; + pcr_cell->ba_arfcn = arfcn; + pcr_cell->bsic = bsic; + pcr_cell->frame_offset = sync_ind->fn_offset; + pcr_cell->time_align = sync_ind->time_alignment; + } + + ma_bsic_cnf (mph_bsic_cnf); + + nc_store_sync_ind (LAST_BSIC_REQ, sync_ind, READ_BCCH); +#ifdef GPRS + /* don't do the next checks for PBCCH just return + * maybe later TODO(opt) + */ + if (GET_STATE (STATE_NC) EQ NC_PIM_PBCCH OR + GET_STATE (STATE_NC) EQ NC_PTM_PBCCH) + { + return; + } +#endif + + index = nc_get_index (arfcn); + + if(index NEQ LAST_BSIC_REQ AND + index NEQ NOT_PRESENT_16BIT) + { + /* + * check BSIC of the incoming BCCH message + */ + switch (nc_check_bsic (index, bsic)) + { + case NC_CHECK_OK: + /* + * channel has passed NCC permitted check. + */ + switch (alr_data->nc_data.cell[index].status) + { + + case IDLE: + /* This patch helps during parallel search in Limited service. + * Cell synchronised in the last BSIC_REQ fromm RR during parallel + * search is also a part of BA list. In such a case, we store the + * synchrinisation information, so that its can be used later by + * nc_start_reselect. + */ + if(alr_data->nc_data.cell[index].one_of_twelve) + nc_store_sync_ind (index, sync_ind, READ_BCCH_RR_NOT_INFORMED); + else + nc_store_sync_ind (index, sync_ind, IDLE_SYNC); + break; + + case READ_FB_SB: + /* + * the channel shall start synchronisation of FB/SB + * so reading of BCCH shall be started. + */ + if(alr_data->nc_data.cell[index].one_of_six AND + GET_STATE(STATE_NC) NEQ NC_DEDICATED) + nc_store_sync_ind (index, sync_ind, READ_BCCH_RR_NOT_INFORMED); + else if(alr_data->nc_data.cell[index].one_of_twelve) + nc_store_sync_ind (index, sync_ind, FB_SB_SYNC); + break; + + case READ_SB: + /* + * the channel shall start synchronisation of SB + * so this is done. + */ + if(alr_data->nc_data.cell[index].one_of_twelve) + nc_store_sync_ind (index, sync_ind, FB_SB_SYNC); + break; + + case FB_SB_FAILED: + /* + * A channel synchronisation has failed in the past. + * Now it is synchronized again. Start BCCH reading + * and send this information to RR after indicating + * the synchronisation with next measurement report. + */ + if(alr_data->nc_data.cell[index].one_of_six AND + GET_STATE(STATE_NC) NEQ NC_DEDICATED) + nc_store_sync_ind (index, sync_ind, READ_BCCH_RR_NOT_INFORMED); + else if(alr_data->nc_data.cell[index].one_of_twelve) + nc_store_sync_ind (index, sync_ind, FB_SB_SYNC); + break; + + + case READ_SB_BCCH: + /* + * the channel shall start synchronisation of SB + * followed by BCCH reading. SB synchronisation + * is done. + */ + if(alr_data->nc_data.cell[index].one_of_six) + nc_store_sync_ind (index, sync_ind, READ_BCCH); + break; + + case READ_FB_SB_PENDING: + case READ_SB_PENDING: + case READ_SB_BCCH_PENDING: + case READ_BCCH_PENDING: + case READ_BCCH_PENDING_RR_NOT_INFORMED: + /* + * REMARK: this shall not happen, because this + * attempt shall be killed if RR requests + * procedure for the channel. + */ + ALR_TRACE_NC ("Abnormal situation sync ind"); + break; + + default: + break; + } + break; + + case NC_CHECK_BSIC_CHANGED: + /* + * BSIC of the channel has changed. + */ + switch (alr_data->nc_data.cell[index].status) + { + case READ_SB: + /* + * the channel shall start synchronisation of SB + * so this is done, but a changed BSIC is stored. + * Read BCCH of the channel and forward to RR. + */ + if(alr_data->nc_data.cell[index].one_of_six AND + GET_STATE(STATE_NC) NEQ NC_DEDICATED) + nc_store_sync_ind (index, sync_ind, READ_BCCH_RR_NOT_INFORMED); + else if(alr_data->nc_data.cell[index].one_of_twelve) + nc_store_sync_ind (index, sync_ind, FB_SB_SYNC); + break; + + case FB_SB_FAILED: + /* + * A channel synchronisation has failed in the past. + * Now it is synchronized again. Start BCCH reading + * and send this information to RR after indicating + * the synchronisation with next measurement report. + */ + if(alr_data->nc_data.cell[index].one_of_six AND + GET_STATE(STATE_NC) NEQ NC_DEDICATED) + nc_store_sync_ind (index, sync_ind, READ_BCCH_RR_NOT_INFORMED); + else if(alr_data->nc_data.cell[index].one_of_twelve) + nc_store_sync_ind (index, sync_ind, FB_SB_SYNC); + break; + + case READ_SB_BCCH: + /* + * the channel shall start synchronisation of SB + * followed by BCCH reading. SB synchronisation + * is done. Read BCCH of the channel and forward to RR. + */ + if(alr_data->nc_data.cell[index].one_of_six) + nc_store_sync_ind (index, sync_ind, READ_BCCH_RR_NOT_INFORMED); + break; + + case READ_FB_SB: + case READ_FB_SB_PENDING: + case READ_SB_PENDING: + case READ_SB_BCCH_PENDING: + case READ_BCCH_PENDING: + case READ_BCCH_PENDING_RR_NOT_INFORMED: + /* + * REMARK: this shall not happen, because this + * attempt shall be killed if RR requests + * procedure for the channel. + */ + ALR_TRACE_NC ("Abnormal situation sync ind (changed BSIC)"); + break; + + default: + break; + } + break; + + case NC_CHECK_NCC_FAILED: + /* + * ncc permitted check failed + */ + nc_set_status (index, EXCLUDED); + break; + + default: + break; + } + } + + ALR_EM_NEIGHBOURCELL_BSIC_CONFIRM(EM_AVAIL); + + } + else + { + /* + * FCB and SCB not found, set result code, + * mark cell[LAST_BSIC_REQ] and cr_cell as invalid + * and send negative answer to RR + */ + mph_bsic_cnf->cs = CS_NO_BCCH_AVAIL; + nc_set_status (LAST_BSIC_REQ, IDLE); + alr_data->nc_data.cell[LAST_BSIC_REQ].ba_arfcn = NOT_PRESENT_16BIT; + alr_data->nc_data.cr_cell.ba_arfcn = NOT_PRESENT_16BIT; + + ma_bsic_cnf (mph_bsic_cnf); + + ALR_EM_NEIGHBOURCELL_BSIC_CONFIRM(EM_NOT_AVAIL); + + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : alr_nc | +| STATE : code ROUTINE : nc_sync_ind_ncell | ++--------------------------------------------------------------------+ + + PURPOSE : Confirmation of a ncell synchronisation request + +*/ + +LOCAL void nc_sync_ind_ncell(T_MPHC_NCELL_SYNC_IND* sync_ind, + USHORT index, + USHORT arfcn, + UBYTE bsic) +{ +#ifdef GPRS + BOOL bsic_chg = FALSE; +#endif + + if (GET_STATE(STATE_NC_PROC) EQ NC_CONFIRM) + { + /* eotd confirmation is active */ + if(alr_data->nc_data.eotd_avail) + nc_check_sync_ind_eotd(sync_ind, arfcn); + + TRACE_EVENT_P2("sync_ind[%u] c_sync_req=%u", arfcn, alr_data->nc_data.c_sync_req); + /* + * check if the end of the CONFIRM procedure (LIST_REQ) is + * reached + * this is done here because it is independent from EOTD + */ + if(alr_data->nc_data.c_sync_req EQ 0) + { + nc_enable_conf(); + } + /* + * skip the rest of this function for scell + * because the status for the scell is always FB_SB_SYNC + */ + if(alr_data->nc_data.eotd_avail AND + arfcn EQ alr_data->serving_cell) + return; + } + + if (sync_ind->sb_flag EQ SB_FOUND) + { + /* + * Synchronization successful for a normal member of the BA list. + */ + ALR_TRACE_NC_SB_IND_PASSED(arfcn); + + ALR_EM_NEIGHBOURCELL_SB(EM_AVAIL); + + switch (GET_STATE (STATE_NC)) + { + case NC_IDLE: + case NC_DEDICATED: + /* + * check neighbourcell + */ + switch (nc_check_bsic (index, bsic)) + { + case NC_CHECK_OK: + /* + * channel has passed NCC permitted check. + */ + switch (alr_data->nc_data.cell[index].status) + { + case READ_FB_SB_PENDING: + /* + * initial synchronization to FB and SB + * if the cell is a 1o6 we read the BCCH + * otherwise we just set it to synchronized + */ + + if(alr_data->nc_data.cell[index].one_of_six AND + GET_STATE(STATE_NC) NEQ NC_DEDICATED) + { + nc_store_sync_ind (index, sync_ind, READ_BCCH_RR_NOT_INFORMED); + } + else if(alr_data->nc_data.cell[index].one_of_twelve) + nc_store_sync_ind (index, sync_ind, FB_SB_SYNC); + else + { + TRACE_EVENT_P1("sync ind for not 1o12 cell %d", arfcn); + } + break; + + case READ_SB_PENDING: + /* + * confirmation of SB + */ + alr_data->nc_data.cell[index].c_attempt = 0; + if(alr_data->nc_data.cell[index].one_of_twelve) + nc_store_sync_ind (index, sync_ind, FB_SB_SYNC); + else + nc_store_sync_ind (index, sync_ind, IDLE_SYNC); + break; + + case READ_SB_BCCH_PENDING: + /* + * confirmation of SB before reading + * neighbour cell BCCH all five minutes. + */ + if(alr_data->nc_data.cell[index].one_of_six AND + GET_STATE(STATE_NC) EQ NC_IDLE) + { + nc_store_sync_ind (index, sync_ind, READ_BCCH); + } + else + { + alr_data->nc_data.cell[index].c_attempt = 0; + if(alr_data->nc_data.cell[index].one_of_twelve) + nc_store_sync_ind (index, sync_ind, FB_SB_SYNC); + else + nc_store_sync_ind (index, sync_ind, IDLE_SYNC); + } + break; + case READ_BCCH_RR_NOT_INFORMED: /*TODO(opt)*/ + case READ_BCCH_PENDING_RR_NOT_INFORMED:/*TODO(opt)*/ + case READ_BCCH:/*TODO(opt)*/ + case READ_BCCH_PENDING:/*TODO(opt)*/ + TRACE_ERROR("sync_ind for ncell in READ_BCCH*"); + if(alr_data->nc_data.cell[index].one_of_six AND + GET_STATE(STATE_NC) EQ NC_IDLE) + { + nc_store_sync_ind (index, sync_ind, FB_SB_SYNC); + } + break; + default: + break; + } /*switch(status)*/ + break; + case NC_CHECK_BSIC_CHANGED: + /* + * channel has passed NCC permitted check, + * but a changed BSIC has been detected. + */ + switch (alr_data->nc_data.cell[index].status) + { + case READ_SB_PENDING: + case READ_SB_BCCH_PENDING: + /* + * confirmation of SB indicates new BSIC + */ + if(alr_data->nc_data.cell[index].one_of_six AND + GET_STATE(STATE_NC) NEQ NC_DEDICATED) + { + nc_store_sync_ind (index, sync_ind, READ_BCCH_RR_NOT_INFORMED); + } + else if(alr_data->nc_data.cell[index].one_of_twelve) + { + alr_data->nc_data.cell[index].c_attempt = 0; + nc_store_sync_ind (index, sync_ind, FB_SB_SYNC); + } + else + { + TRACE_EVENT_P1("sync ind for not 1o12 cell %d", arfcn); + nc_store_sync_ind (index, sync_ind, IDLE_SYNC); + } + break; + + default: + break; + } /*switch(status)*/ + break; + + case NC_CHECK_NCC_FAILED: + /* + * ncc permitted check failed. Attempt again. + * BSIC of a cell may always change. So do not + * exclude this cell in IDLE mode meaurements + */ + if(GET_STATE(STATE_NC) EQ NC_IDLE) + { + alr_data->nc_data.cell[index].c_attempt = 0; + nc_set_fb_sb_failed (index, TEN_SECONDS); + } + else if(GET_STATE(STATE_NC) EQ NC_DEDICATED) + { + alr_data->nc_data.cell[index].c_attempt = 0; + nc_set_fb_sb_failed (index, THIRTY_SECONDS); + } + else + { + nc_set_status (index, EXCLUDED); + } + break; + } + break; +#ifdef GPRS + case NC_PIM_PBCCH: + case NC_PTM_PBCCH: /*XXX*/ + TRACE_EVENT("sync_ind PBCCH"); + switch (alr_data->nc_data.cell[index].status) + { + case READ_FB_SB_PENDING: + nc_store_sync_ind (index, sync_ind, FB_SB_SYNC); + nc_inform_grr_of_ncell(index, GRR_SB_FOUND); + break; + case READ_SB_PENDING: + if(bsic NEQ alr_data->nc_data.cell[index].bsic) + bsic_chg = TRUE; + else + bsic_chg = FALSE; + + if(alr_data->nc_data.cell[index].one_of_twelve) + nc_store_sync_ind (index, sync_ind, FB_SB_SYNC); + else + nc_store_sync_ind (index, sync_ind, IDLE_SYNC); + + if(bsic_chg) + nc_inform_grr_of_ncell(index, GRR_SB_FOUND); + break; + default: + break; + } + break; + default: + break; +#endif + } /* NC_STATE */ + } + else /* sb_flag EQ FALSE */ + { + /* + * Synchronization failed + */ + ALR_TRACE_NC_SB_FAILED (sync_ind->radio_freq); + if (alr_data->nc_data.cell[index].ba_status EQ IN_BA) + { + switch (alr_data->nc_data.cell[index].status) + { + case READ_FB_SB_PENDING: + case READ_SB_PENDING: + case READ_SB_BCCH_PENDING: + + ALR_EM_NEIGHBOURCELL_SB(EM_NOT_AVAIL); + + if(GET_STATE(STATE_NC) EQ NC_IDLE) + nc_sync_failed_attempt(index); + else if(GET_STATE(STATE_NC) EQ NC_DEDICATED) + nc_sync_failed_attempt_dedicated(index); +#ifdef GPRS /*XXX*/ + else + nc_sync_failed_gprs(index); +#endif + break; + default: + break; + } + } + else + { /* + * the cell currently or perhaps for a longer time doesn't + * belong to the BA list, no more attempts to synchronize now + */ + switch (alr_data->nc_data.cell[index].status) + { + case READ_FB_SB_PENDING: + nc_set_status (index, IDLE); + break; + case READ_SB_PENDING: + alr_data->nc_data.cell[index].c_attempt++; + alr_data->nc_data.cell[index].tim_valid = TV_APPROX_TIMING_INFO; + nc_set_status (index, READ_SB); + break; + case READ_SB_BCCH_PENDING: + alr_data->nc_data.cell[index].c_attempt++; + alr_data->nc_data.cell[index].tim_valid = TV_APPROX_TIMING_INFO; + nc_set_status (index, READ_SB_BCCH); + break; + default: + break; + } + } + } /* error_flag check */ +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_check_sync_ind_eotd | ++--------------------------------------------------------------------+ + + PURPOSE : copies the measurement results to the MPH_NCELL_POS_IND + while EOTD is active + +*/ +LOCAL void nc_check_sync_ind_eotd (T_MPHC_NCELL_SYNC_IND* sync_ind, USHORT arfcn) +{ + T_MPH_NCELL_POS_IND* ppos_ind; + + if ((ppos_ind = alr_data->nc_data.ppos_ind) EQ NULL) + { + TRACE_ERROR("nc_check_sync_ind_eotd() while alr_data->nc_data.ppos_ind==0"); + return; + } + + if (arfcn EQ alr_data->serving_cell) + { + if (ppos_ind->eotd_res EQ 0) /*0 doesn't mean EOTD_SUCC here + - it indicates that no SC results are present*/ + { + nc_store_eotd(&(ppos_ind->eotd_sc_res), sync_ind, arfcn); + ppos_ind->fn = sync_ind->fn_in_sb; + ppos_ind->eotd_res++; + } + else /*first EOTD results for SC are already present + - now continue with second SC results*/ + { + nc_store_eotd((T_eotd_sc_res*)(&(ppos_ind->eotd_sc_res1)), sync_ind, + arfcn); + ppos_ind->eotd_res = EOTD_SUCC; + ppos_ind->ta = GET_STATE(STATE_NC) EQ NC_DEDICATED ? + alr_data->nc_data.tav : NOT_PRESENT_8BIT; + PSENDX (RR, ppos_ind); + alr_data->nc_data.ppos_ind = NULL; + + if (alr_data->nc_data.ppos_req NEQ NULL) + { + PFREE(alr_data->nc_data.ppos_req); + alr_data->nc_data.ppos_req = NULL; + } + } + } + else + { + if (ppos_ind->c_eotd_nc_res < MAX_NCELL_EOTD_RES) + { + nc_store_eotd((T_eotd_sc_res*)( + &(ppos_ind->eotd_nc_res[ppos_ind->c_eotd_nc_res])) , sync_ind, arfcn); + (ppos_ind->c_eotd_nc_res)++; + } + else + TRACE_ERROR("more than MAX_NCELL_EOTD_RES ncell sync indications"); + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_sync_failed_attempt | ++--------------------------------------------------------------------+ + + PURPOSE : A synchronisation attempt has failed during idle mode. + +*/ +LOCAL void nc_sync_failed_attempt (USHORT index) +{ + switch (alr_data->nc_data.cell[index].c_attempt) + { + case 0: + case 1: + case 2: + case 3: + /* + * for attempts 1 to 4 try it again + * after ten seconds + */ + nc_set_fb_sb_failed (index, TEN_SECONDS); + + break; + default: + /* + * if there are more attempts, exclude + * the cell from further attempts + * Store last fieldstrength value + */ + nc_set_status (index, EXCLUDED); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_sync_failed_attempt_dedicated | ++--------------------------------------------------------------------+ + + PURPOSE : A synchronisation attempt has failed during dedicated mode. + +*/ +LOCAL void nc_sync_failed_attempt_dedicated (USHORT index) +{ + /* + * Store last fieldstrength value + */ + switch (alr_data->nc_data.cell[index].c_attempt) + { + case 0: + case 1: + case 2: + /* + * for attempts 1 to 3 try it again immediately + */ + alr_data->nc_data.cell[index].c_attempt++; + if (alr_data->nc_data.cell[index].status EQ READ_FB_SB_PENDING) + alr_data->nc_data.cell[index].tim_valid = TV_INVALID_TIMING_INFO; + else + alr_data->nc_data.cell[index].tim_valid = TV_APPROX_TIMING_INFO; + nc_set_status (index, READ_FB_SB); + break; + default: + /* + * if there are more attempts, exclude + * the cell from further attempts + */ + nc_set_status (index, EXCLUDED); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_start_dedicated | ++--------------------------------------------------------------------+ + + PURPOSE : Process signal nc_start_dedicated from SDL process + Main_Control. + +*/ + +GLOBAL void nc_start_dedicated (UBYTE pwrc, UBYTE dtx) +{ + USHORT i; + + switch(GET_STATE(STATE_NC)) + { + case NC_CON_EST: + for (i = 0; i < alr_data->nc_data.c_ba_arfcn; i++) + { + switch (alr_data->nc_data.cell[i].status) + { + case READ_BCCH_RR_NOT_INFORMED: + case FB_SB_SYNC_RR_NOT_INFORMED: + case READ_BCCH: + /* + * BCCH reading is not needed during dedicated mode, + * but SB synchronisation is already done. + * clear a stored BCCH if needed. + */ + nc_set_status (i, FB_SB_SYNC); + break; + + case READ_SB_BCCH: + nc_set_status (i, READ_SB); + break; + + case READ_FB_SB_PENDING: + case READ_SB_PENDING: + case READ_SB_BCCH_PENDING: + case READ_BCCH_PENDING_RR_NOT_INFORMED: + case READ_BCCH_PENDING: + TRACE_ERROR("Abnormal situation nc_start_dedi"); + nc_set_status (i, IDLE); + break; + case FB_SB_FAILED: + nc_set_status (i, IDLE); + break; + case IDLE_SYNC: + if (alr_data->nc_data.cell[i].c_sync > 0) + alr_data->nc_data.cell[i].c_sync = TEN_SECONDS; + break; + default: + break; + } + } + + nc_clear_last_bsic(); + + alr_data->nc_data.pwrc = pwrc; + alr_data->nc_data.dtx = dtx; + + SET_STATE (STATE_NC, NC_DEDICATED); + nc_enable_conf(); + break; + default: + TRACE_ERROR("nc_start_dedicated in wrong state"); + break; + } + +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_suspend | ++--------------------------------------------------------------------+ + + PURPOSE : This stops all active processes like FB/SB and BCCH reading + if + - the mobile start connection establishment + - RR requests power measurements parallel to idle mode + - leave dedicated mode. + +*/ + +GLOBAL void nc_suspend (void) +{ + ALR_TRACE_NC( "nc_suspend"); + + switch (GET_STATE(STATE_NC)) + { + case NC_IDLE: + case NC_DEDICATED: + nc_clear_last_bsic(); + nc_stop_all(); + nc_disable_conf(FREE_POS_IND); + + SET_STATE(STATE_NC, NC_CON_EST); + break; + case NC_CON_EST: + break; +#ifdef GPRS + case NC_PIM_PBCCH: + if(alr_data->nc_data.cell[LAST_BSIC_REQ].status NEQ IDLE) + nc_clear_last_bsic(); + /*lint -fallthrough*/ + case NC_PTM_PBCCH: + nc_stop_all(); + nc_disable_conf(FREE_POS_IND); + SET_STATE(STATE_NC, NC_CON_EST); + break; +#endif + default: + break; + } +} + +GLOBAL void nc_suspend_handover (void) +{ + ALR_TRACE_NC( "nc_suspend_handover"); + + switch (GET_STATE(STATE_NC)) + { + case NC_DEDICATED: + nc_stop_all(); + nc_disable_conf(FREE_POS_IND); + break; + } +} +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : alr_nc | +| STATE : code ROUTINE : nc_resume | ++--------------------------------------------------------------------+ + + PURPOSE : Only needed for alr_gprs.c + +*/ + +GLOBAL void nc_resume (void) +{ + SET_STATE (STATE_NC, NC_IDLE); + nc_enable_conf(); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_update_dedicated | ++--------------------------------------------------------------------+ + + PURPOSE : Process signal nc_update_dedicated from SDL process + Dedi_Control. + +*/ + +GLOBAL void nc_update_dedicated (UBYTE dtx, UBYTE pwrc) +{ + UBYTE i, j; + UBYTE c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + + switch(GET_STATE (STATE_NC)) + { + case NC_DEDICATED: + { + PALLOC (upd_dedi, MPHC_UPDATE_BA_LIST); + + /* + * updated values of pwrc or dtx can be configure + * only by sending a new neighbourcell list to layer 1 + */ + alr_data->nc_data.pwrc = pwrc; + alr_data->nc_data.dtx = dtx; + + for (i = 0, j = 0; i < c_ba_arfcn; i++) + { + if (alr_data->nc_data.cell[i].ba_status EQ IN_BA) + upd_dedi->chan_list.radio_freq[j++] = + ARFCN_TO_L1(alr_data->nc_data.cell[i].ba_arfcn); + } + + upd_dedi->num_of_chans = j; + alr_data->nc_data.ba_id = ALR_ALLOCATE_NEW_BA ( alr_data->nc_data.ba_id ); + upd_dedi->ba_id = alr_data->nc_data.ba_id; + upd_dedi->pwrc = alr_data->nc_data.pwrc; + upd_dedi->dtx_allowed = alr_data->nc_data.dtx; + + alr_data->nc_data.update = TRUE; + ma_nc_update_ba_list (upd_dedi); + } + break; + default: + TRACE_ERROR("nc_update_dedicated in wrong state"); + break; + } +} + +GLOBAL void nc_resume_dedicated(void) +{ + nc_enable_conf(); +} +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_get_fn_time | ++--------------------------------------------------------------------+ + + PURPOSE : Export Procedure to request frame offset and time + alignment of neighbour cells. + + Returns FALSE if timing information not found. + +*/ + +GLOBAL BOOL nc_get_fn_time (USHORT channel, + ULONG *fn, + ULONG *time) +{ + USHORT index; + if( channel EQ alr_data->serving_cell) + { + *fn = 0; + *time = 0; + return TRUE; + } + + /* Check if we have read SYNC on this channel */ + index = nc_get_index (channel); + if (index NEQ NOT_PRESENT_16BIT) + { + *fn = alr_data->nc_data.cell[index].frame_offset; + *time = alr_data->nc_data.cell[index].time_align; + + if( (*fn EQ NOT_PRESENT_32BIT) OR (*time EQ NOT_PRESENT_32BIT)) + { + return FALSE; + } + else + { + return TRUE; + } + } + else + { + *fn = NOT_PRESENT_32BIT; + *time = NOT_PRESENT_32BIT; + return FALSE; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_start_reselect | ++--------------------------------------------------------------------+ + + PURPOSE : Process signal nc_start_reselect from SDL process + Main_Control. + +*/ + +GLOBAL void nc_start_reselect (USHORT arfcn) +{ + USHORT index; + T_NC *pcell; + + ALR_TRACE_NC_RESELECT(arfcn); + + index = nc_get_index (arfcn); + if (index EQ NOT_PRESENT_16BIT) + { + if (arfcn NEQ alr_data->nc_data.cr_cell.ba_arfcn) + { + ma_error_ind (CS_BCCH_READ_ERROR, arfcn); + return; + } + else + { + pcell = &alr_data->nc_data.cr_cell; + } + } + else + { + pcell = &alr_data->nc_data.cell[index]; + + /* Cannot to reselect to a cell for which the synchronization information + * is not available + */ + if (pcell->bsic EQ NOT_PRESENT_8BIT) + { + ma_error_ind (CS_NC_SYNC_FAILED, arfcn); + return; + } + } + + + { + PALLOC(reselect, MPHC_NEW_SCELL_REQ); + + reselect->radio_freq = ARFCN_TO_L1(arfcn); + reselect->fn_offset = (ULONG)pcell->frame_offset; + reselect->time_alignment = (ULONG)pcell->time_align; + reselect->tsc = pcell->bsic; + alr_data->nc_data.channel = arfcn; + + ALR_TRACE_NC_FN_TA(index, reselect->fn_offset, reselect->time_alignment); + + ALR_EM_CONFIGURE_CELL_RESELECTION; + + ma_new_scell_req(reselect); + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_report | ++--------------------------------------------------------------------+ + + PURPOSE : Process signal nc_report from SDL process + Main_Control. + +*/ + +GLOBAL void nc_report (T_MPHC_RXLEV_PERIODIC_IND *rxlev_periodic_ind) +{ + ALR_TRACE_NC("nc_report"); + + + switch(GET_STATE(STATE_NC)) + { + case NC_IDLE: + case NC_CON_EST: + nc_store_rxlev (rxlev_periodic_ind); + +#ifdef GPRS + nc_rxlev_sc_req (rxlev_periodic_ind->s_rxlev); +#endif + nc_check_activity(); + break; + default: + TRACE_ERROR("nc_report in invalid state"); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_report_dedicated | ++--------------------------------------------------------------------+ + + PURPOSE : Process signal nc_report_dedicated from SDL process + Main_Control. + +*/ + +GLOBAL void nc_report_dedicated (T_MPHC_MEAS_REPORT *meas_report) +{ + switch(GET_STATE(STATE_NC)) + { + case NC_DEDICATED: + nc_store_dedicated (meas_report); + nc_check_activity (); + break; + default: + TRACE_ERROR("nc_report_dedicated in wrong state"); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_update_list | ++--------------------------------------------------------------------+ + + PURPOSE : Procedure to update frame offset and time alignment after + cell change. All values are relative to the actual serving + cell. + +*/ + +#define TDMA_FRAMES_PER_HYPERFRAME 2715648 + +GLOBAL void nc_update_list (USHORT channel) +{ + USHORT index; + USHORT i; + + switch(GET_STATE(STATE_NC)) + { + case NC_CON_EST: + case NC_DEDICATED: + case NC_IDLE: + index = nc_get_index (channel); + if (index NEQ NOT_PRESENT_16BIT) + { + for (i = 0; i < alr_data->nc_data.c_ba_arfcn; i++) + { + if (i NEQ index) + { + ULONG new_frame_offset; + ULONG new_time_align; + + new_frame_offset = (alr_data->nc_data.cell[i].frame_offset - + alr_data->nc_data.cell[index].frame_offset + + TDMA_FRAMES_PER_HYPERFRAME) % + TDMA_FRAMES_PER_HYPERFRAME; + if (alr_data->nc_data.cell[i].time_align >= alr_data->nc_data.cell[index].time_align) + { + new_time_align = alr_data->nc_data.cell[i].time_align - + alr_data->nc_data.cell[index].time_align; + } + else + { + new_time_align = 5000 + alr_data->nc_data.cell[i].time_align - + alr_data->nc_data.cell[index].time_align; + new_frame_offset = (new_frame_offset + 1) % + TDMA_FRAMES_PER_HYPERFRAME; + } /* time_align */ + alr_data->nc_data.cell[i].frame_offset = new_frame_offset; + alr_data->nc_data.cell[i].time_align = new_time_align; + } /* i NEQ index */ + } /* for(all ncells) */ + + ALR_TRACE_NC("set chan to 0"); + + alr_data->nc_data.cell[index].frame_offset = 0; + alr_data->nc_data.cell[index].time_align = 0; + } /* NOT_PRESENT */ + break; + default: + TRACE_ERROR("nc_update_list in invalid state"); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_add_offset | ++--------------------------------------------------------------------+ + + PURPOSE : If the mobile comes back from dedicated mode all synchronized + neighbourcells make a status transition to READ_BCCH_RR_NOT_INFORMED. + This triggers reading of the neighbourcell BCCH. + +*/ + +GLOBAL void nc_add_offset (void) +{ + USHORT i; + USHORT c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + + for (i = 0; i < c_ba_arfcn; i++) + { + if (alr_data->nc_data.cell[i].ba_arfcn NEQ alr_data->serving_cell) + { + /*XXX c_sync should be the same in idle and dedic also for pbcchc + so no action here */ + switch (alr_data->nc_data.cell[i].status) + { + case FB_SB_SYNC: + case READ_SB: + nc_set_status (i, READ_BCCH_RR_NOT_INFORMED); + break; + default: + break; + + } + } + else + nc_set_status (i, FB_SB_SYNC); + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_fill_report_sc_dedi | ++--------------------------------------------------------------------+ + + PURPOSE : Fills the serving cell values for a measurement report. + +*/ + +GLOBAL void nc_fill_report_sc_dedi (T_MPH_MEASUREMENT_IND *rr_report, + UBYTE ncells) +{ + rr_report->valid = TRUE; + rr_report->ncells.no_of_ncells = ncells; + rr_report->arfcn = alr_data->serving_cell; + rr_report->fn_offset = 103; /* average of SDCCH/FACCH */ + rr_report->dtx = alr_data->nc_data.act_dtx; + rr_report->rx_lev_full = (UBYTE)alr_data->nc_data.rxlev_full; + if (rr_report->rx_lev_full > 63) + rr_report->rx_lev_full = 63; + rr_report->rx_lev_sub = (UBYTE)alr_data->nc_data.rxlev_sub; + if (rr_report->rx_lev_sub > 63) + rr_report->rx_lev_sub = 63; + rr_report->rx_qual_full = alr_data->nc_data.rxqual_full; + rr_report->rx_qual_sub = alr_data->nc_data.rxqual_sub; + rr_report->otd = alr_data->nc_data.tav; + + if(ncells EQ 0) + { + /* + * rxlev of SC BCCH channel is not avail + * use approx value (rxlev_sub) + */ + rr_report->bcch_rxlev_of_sc = rr_report->rx_lev_sub; + } + else + { + USHORT index = nc_get_index(alr_data->serving_cell); + if(index EQ NOT_PRESENT_16BIT) + { + TRACE_EVENT("Error SC not present in BA list"); + rr_report->bcch_rxlev_of_sc = rr_report->rx_lev_sub; + } + else + { + if((UBYTE) alr_data->nc_data.cell[index].rxlev_average > 63) + rr_report->bcch_rxlev_of_sc = 63; + else + rr_report->bcch_rxlev_of_sc = (UBYTE)alr_data->nc_data.cell[index].rxlev_average; + } + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : inform GRR | ++--------------------------------------------------------------------+ + + PURPOSE : inform GRR + +*/ + +#ifdef GPRS +LOCAL void nc_inform_grr_of_ncell (USHORT index, UBYTE type) +{ + PALLOC(rr_rep, MPH_MEASUREMENT_IND); + rr_rep->ncells.no_of_ncells = 1; + rr_rep->ncells.arfcn[0] = alr_data->nc_data.cell[index].ba_arfcn; + if(type EQ GRR_SB_FOUND) + rr_rep->ncells.bsic[0] = alr_data->nc_data.cell[index].bsic; + else + rr_rep->ncells.bsic[0] = type; + rr_rep->gprs_sync = SYNC_RESULTS; + PSENDX(RR,rr_rep); +} + +LOCAL void remove_ncell_and_inform_grr (USHORT index) +{ + nc_inform_grr_of_ncell (index, GRR_SB_UNKNOWN); + nc_remove_channel_from_ba_list(index); +} +#endif + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_build_rr_report | ++--------------------------------------------------------------------+ + + PURPOSE : Fills a measurement report to RR with neighbour cell + information. + +*/ + +LOCAL void nc_build_rr_report (T_MPH_MEASUREMENT_IND *rr_report) +{ + UBYTE c_report; + UBYTE c_ba_list; + T_NC * pcell = alr_data->nc_data.cell; + + c_report = 0; + rr_report->valid = TRUE; + + for (c_ba_list = 0; c_ba_list < alr_data->nc_data.c_ba_arfcn AND + c_report < MAX_RR_NCELL_CNT; c_ba_list++, pcell++) + { + if(pcell->one_of_six AND pcell->ba_status EQ IN_BA) + { + switch (pcell->status) + { + case FB_SB_SYNC_RR_NOT_INFORMED: + /* + * the cell is synchronized but RR has no prior + * knowledge of the cell, but we may have already + * read data from the ncell BCCH. This check is performed + * after sending the measurement report + */ + case FB_SB_SYNC: + case READ_BCCH: + case READ_SB: + case READ_SB_BCCH: + /* + * we may be currently reading this SB/FB or BCCH of the cell + * pass up this cell also + * if READ_FB_SB_PENDING this may be the first time that the + * cell is read so check if the bsic of this cell has been + * read already + */ + case READ_SB_PENDING: + case READ_SB_BCCH_PENDING: + case READ_BCCH_PENDING: + case READ_FB_SB_PENDING: + if (pcell->ba_arfcn NEQ alr_data->serving_cell AND + pcell->bsic NEQ NOT_PRESENT_8BIT) + { + rr_report->ncells.arfcn[c_report] = pcell->ba_arfcn; + rr_report->ncells.rx_lev[c_report] = (UBYTE)pcell->rxlev_average; + #if defined(_SIMULATION_) + TRACE_EVENT_P3 ("rx_lev%u[%u]=%d", + c_report, rr_report->ncells.arfcn[c_report], + rr_report->ncells.rx_lev[c_report]); + #endif /* _SIMULATION_ */ + rr_report->ncells.bsic[c_report] = pcell->bsic; + rr_report->ncells.time_alignmt[c_report] = pcell->time_align; + rr_report->ncells.frame_offset[c_report++] = pcell->frame_offset; + } + break; + case READ_BCCH_RR_NOT_INFORMED: + case READ_BCCH_PENDING_RR_NOT_INFORMED: + case READ_FB_SB: + /* do nothing */ + default: + break; + } + }/* not one_of_six*/ + } + rr_report->ncells.no_of_ncells = c_report; +} + + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_build_nwctrl_rr_report | ++--------------------------------------------------------------------+ + + PURPOSE : Fills a measurement report to RR with neighbour cell + information. + +*/ + + +#ifdef GPRS +GLOBAL void nc_build_nwctrl_rr_report (T_MPH_MEAS_REP_CNF *rr_report) +{ + UBYTE c_report; + UBYTE c_ba_list; + USHORT index; + T_NC * pcell; + + /* + * Store the rxlev average for the serving cell + */ + index = nc_get_index(alr_data->serving_cell); + if ( index NEQ NOT_PRESENT_16BIT ) + { + pcell = &alr_data->nc_data.cell[index]; + rr_report->meas_rep[0].arfcn = alr_data->serving_cell; + rr_report->meas_rep[0].bsic = pcell->bsic; + + if(pcell->c_nc_rxlev) + { + rr_report->meas_rep[0].rx_lev = pcell->nc_rxlev/pcell->c_nc_rxlev; + } +#if defined(_SIMULATION_) + TRACE_EVENT_P3 ("nw_sc__rxlev[%u]=acc : %d, count:%d",rr_report->meas_rep[0].arfcn,pcell->nc_rxlev,pcell->c_nc_rxlev); +#endif /* _SIMULATION_ */ + } + + c_report = 0; + pcell = alr_data->nc_data.cell; + + for (c_ba_list = 0; c_ba_list < alr_data->nc_data.c_ba_arfcn AND + c_report < MAX_RR_NCELL_CNT; c_ba_list++, pcell++) + { + if(pcell->one_of_six AND pcell->ba_status EQ IN_BA) + { + switch (pcell->status) + { + case FB_SB_SYNC_RR_NOT_INFORMED: + /* + * the cell is synchronized but RR has no prior + * knowledge of the cell, but we may have already + * read data from the ncell BCCH. This check is performed + * after sending the measurement report + */ + case FB_SB_SYNC: + case READ_BCCH: + case READ_SB: + case READ_SB_BCCH: + /* + * we may be currently reading this SB/FB or BCCH of the cell + * pass up this cell also + * if READ_FB_SB_PENDING this may be the first time that the + * cell is read so check if the bsic of this cell has been + * read already + */ + case READ_SB_PENDING: + case READ_SB_BCCH_PENDING: + case READ_BCCH_PENDING: + case READ_FB_SB_PENDING: + if (pcell->ba_arfcn NEQ alr_data->serving_cell AND + pcell->bsic NEQ NOT_PRESENT_8BIT) + { + rr_report->meas_rep[c_report+1].arfcn = pcell->ba_arfcn; + rr_report->meas_rep[c_report+1].bsic = pcell->bsic; + if(pcell->c_nc_rxlev) + { + rr_report->meas_rep[c_report+1].rx_lev = pcell->nc_rxlev/pcell->c_nc_rxlev; + } + +#if defined(_SIMULATION_) + TRACE_EVENT_P3 ("nwctrl_rxlev%u[%u]=%d",c_report+1, rr_report->meas_rep[c_report+1].arfcn,rr_report->meas_rep[c_report+1].rx_lev); +#endif /* _SIMULATION_ */ + c_report++; + } + break; + case READ_BCCH_RR_NOT_INFORMED: + case READ_BCCH_PENDING_RR_NOT_INFORMED: + case READ_FB_SB: + /* do nothing */ + default: + break; + } + }/* not one_of_six*/ + } + + if( (c_report + 1 ) < RR_ALR_MEAS_REPORT_SIZE ) + { + rr_report->meas_rep[c_report+1].arfcn = NOT_PRESENT_16BIT ; + rr_report->meas_rep[c_report+1].rx_lev = NOT_PRESENT_8BIT ; + rr_report->meas_rep[c_report+1].bsic = NOT_PRESENT_8BIT ; + } +} +#endif /* ifdef GPRS */ + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_store_tav | ++--------------------------------------------------------------------+ + + PURPOSE : Stores timing advance receveived with dedicated mode SI's +*/ +GLOBAL void nc_store_tav(USHORT tav) +{ + alr_data->nc_data.tav = tav; +} + + +/* + *======================================================================== + * Helper Functions + *======================================================================== + */ + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_check_status | ++--------------------------------------------------------------------+ + + PURPOSE : Checks the status of the neighbour cells. +*/ + +LOCAL void nc_check_status (UBYTE start_list) +{ + USHORT i; + USHORT c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + T_NC * pcell = alr_data->nc_data.cell; + + for (i = 0; i < c_ba_arfcn; i++, pcell++) + { + if (pcell->ba_arfcn NEQ alr_data->serving_cell) + { + switch (GET_STATE(STATE_NC)) + { + case NC_DEDICATED: + switch (pcell->status) + { + case INACTIVE: + break; + case IDLE: + if (pcell->one_of_twelve) + nc_set_status (i, READ_FB_SB); + if (start_list EQ CHECK_FOR_CONFIRM) + { + if (pcell->tim_valid EQ TV_VALID_TIMING_INFO) + pcell->tim_valid = TV_APPROX_TIMING_INFO; + else if (pcell->tim_valid EQ TV_APPROX_TIMING_INFO) + pcell->tim_valid = TV_INVALID_TIMING_INFO; + } + break; + case READ_FB_SB: + if (pcell->one_of_twelve EQ FALSE) + { + nc_set_status (i, IDLE); + if (start_list EQ CHECK_FOR_CONFIRM AND pcell->tim_valid EQ TV_APPROX_TIMING_INFO) + pcell->tim_valid = TV_INVALID_TIMING_INFO; + } + break; + case FB_SB_SYNC: + if (pcell->one_of_twelve EQ FALSE) + { + nc_set_status (i, IDLE_SYNC); + } + else + { + if ( (start_list) AND (alr_data->nc_data.c_sync_intrupted EQ FALSE)) + nc_set_status (i, READ_SB); + } + break; + case IDLE_SYNC: + if (pcell->one_of_twelve) + { + if (pcell->c_sync EQ 0) + nc_set_status (i, READ_FB_SB); + else + nc_set_status (i, FB_SB_SYNC); + } + else + { + if (pcell->c_sync EQ 0) + { + nc_set_status (i, IDLE); + } + } + break; + case READ_SB: + if (pcell->one_of_twelve EQ FALSE) + { + pcell->tim_valid = TV_APPROX_TIMING_INFO; + nc_set_status (i, IDLE); + } + break; + case READ_BCCH_RR_NOT_INFORMED: + case READ_BCCH: + case READ_SB_BCCH: + TRACE_EVENT("unexpected STATE_NC during NC_DEDICATED"); + if (pcell->one_of_twelve) + nc_set_status (i, READ_FB_SB); + else + { + pcell->tim_valid = TV_APPROX_TIMING_INFO; + nc_set_status (i, IDLE); + } + break; + + case FB_SB_FAILED: + if (pcell->one_of_twelve EQ FALSE) + nc_set_status (i, IDLE); + else if (pcell->c_sync EQ 0) + nc_set_status (i, READ_FB_SB); + break; + + default: + break; + } + break; + case NC_IDLE: + switch (pcell->status) + { + case INACTIVE: + break; + case IDLE: + if (pcell->one_of_twelve) + nc_set_status (i, READ_FB_SB); + if (start_list EQ CHECK_FOR_CONFIRM) + { + if (pcell->tim_valid EQ TV_VALID_TIMING_INFO) + pcell->tim_valid = TV_APPROX_TIMING_INFO; + else if (pcell->tim_valid EQ TV_APPROX_TIMING_INFO) + pcell->tim_valid = TV_INVALID_TIMING_INFO; + } + break; + case READ_FB_SB: + if (pcell->one_of_twelve EQ FALSE) + { + nc_set_status (i, IDLE); + if (start_list EQ CHECK_FOR_CONFIRM AND pcell->tim_valid EQ TV_APPROX_TIMING_INFO) + pcell->tim_valid = TV_INVALID_TIMING_INFO; + } + break; + case FB_SB_SYNC: + if (pcell->one_of_twelve EQ FALSE) + { + nc_set_status (i, IDLE_SYNC); + } + else + { + if (start_list) + nc_set_status (i, READ_SB); + if (pcell->one_of_six AND + pcell->c_bcch EQ 0) + nc_set_status (i, READ_SB_BCCH); + } + break; + case FB_SB_SYNC_RR_NOT_INFORMED: + if (pcell->one_of_six EQ FALSE) + { + if (pcell->one_of_twelve EQ FALSE) + { + nc_set_status (i, IDLE_SYNC); + } + else + { + nc_set_status (i, FB_SB_SYNC); + } + } + break; + case FB_SB_FAILED: + if (pcell->one_of_twelve EQ FALSE) + nc_set_status (i, IDLE); + else if (pcell->c_sync EQ 0) + nc_set_status (i, READ_FB_SB); + break; + case IDLE_SYNC: + if (pcell->one_of_twelve) + { + if(pcell->one_of_six) + { + if (pcell->c_sync EQ 0) + nc_set_status (i, READ_FB_SB); + else + nc_set_status (i, READ_BCCH_RR_NOT_INFORMED); + } + else + { + if (pcell->c_sync EQ 0) + nc_set_status (i, READ_FB_SB); + else + nc_set_status (i, FB_SB_SYNC); + } + } + else + { + if (pcell->c_sync EQ 0) + { + pcell->tim_valid = TV_APPROX_TIMING_INFO; + nc_set_status (i, IDLE); + } + } + break; + case READ_SB: + if (pcell->one_of_twelve EQ FALSE) + { + pcell->tim_valid = TV_APPROX_TIMING_INFO; + nc_set_status (i, IDLE); + } + else + { + if (pcell->c_bcch EQ 0) + nc_set_status (i, READ_SB_BCCH); + } + break; + case READ_BCCH: + if (pcell->one_of_six EQ FALSE) + { + if (pcell->one_of_twelve EQ FALSE) + { + nc_set_status (i, IDLE_SYNC); + } + else + { + nc_set_status (i, FB_SB_SYNC); + } + } + break; + case READ_BCCH_RR_NOT_INFORMED: + if (pcell->one_of_six EQ FALSE) + { + if (pcell->one_of_twelve EQ FALSE) + { + nc_set_status (i, IDLE_SYNC); + } + else + { + nc_set_status (i, FB_SB_SYNC); + } + } + break; + + case READ_SB_BCCH: + if (pcell->one_of_six EQ FALSE) + { + if (pcell->one_of_twelve) + nc_set_status(i, READ_SB); + else + { + pcell->tim_valid = TV_APPROX_TIMING_INFO; + nc_set_status (i, IDLE); + } + } + break; + + default: + break; + } + break; +#ifdef GPRS + case NC_PIM_PBCCH: + case NC_PTM_PBCCH: /*XXX*/ + case NC_CON_EST: /*in case of an updated list in CON_EST */ + switch (pcell->status) + { + case IDLE: + if(pcell->one_of_twelve) + nc_set_status (i, READ_FB_SB); + if (start_list EQ CHECK_FOR_CONFIRM) + { + if (pcell->tim_valid EQ TV_VALID_TIMING_INFO) + pcell->tim_valid = TV_APPROX_TIMING_INFO; + else if (pcell->tim_valid EQ TV_APPROX_TIMING_INFO) + pcell->tim_valid = TV_INVALID_TIMING_INFO; + } + break; + case FB_SB_SYNC: + if(pcell->one_of_twelve EQ FALSE) + nc_set_status (i, IDLE_SYNC); + else + { + if (start_list) + nc_set_status (i, READ_SB); + } + break; + case FB_SB_FAILED: + if(pcell->one_of_twelve EQ FALSE) + remove_ncell_and_inform_grr(i); + else + if(pcell->c_sync EQ 0) + nc_set_status (i, READ_FB_SB); + break; + case READ_FB_SB: + break; + case READ_SB: + if (pcell->one_of_twelve EQ FALSE) + { + pcell->tim_valid = TV_APPROX_TIMING_INFO; + nc_set_status (i, IDLE); + } + break; + case IDLE_SYNC: + if(pcell->c_sync EQ 0) + remove_ncell_and_inform_grr(i); + else + { + if(pcell->one_of_twelve) + nc_set_status (i, FB_SB_SYNC); + } + break; + case READ_BCCH_RR_NOT_INFORMED: + case READ_BCCH: + case FB_SB_SYNC_RR_NOT_INFORMED: + if (pcell->one_of_twelve EQ FALSE) + { + nc_set_status (i, IDLE_SYNC); + } + break; + default: + TRACE_EVENT_P4("wrong state in check_st: i%d a%d 1o6%d st%d", i, + pcell->ba_arfcn, + pcell->one_of_six, + pcell->status); + break; + } +#endif + break; + default: + break; + }/*switch state*/ + } /*if*/ + } /*for*/ +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_build_rr_report_dedi | ++--------------------------------------------------------------------+ + + PURPOSE : Fills a measurement report to RR with neighbour cell + information in dedicated mode. + In dedicated mode the serving cell may be included. + +*/ +LOCAL void nc_build_rr_report_dedi (T_MPH_MEASUREMENT_IND *rr_report) +{ + UBYTE c_report = 0; + UBYTE c_ba_list; + UBYTE found = TRUE; + UBYTE index; + UBYTE i; + UBYTE in_report[34]; + T_NC * pcell1; + + memset (in_report, 0, 34); + + for ( i = 0; i < 6 AND found EQ TRUE; i++) + { + found = FALSE; + index = NOT_PRESENT_8BIT; + pcell1 = alr_data->nc_data.cell; + + for (c_ba_list = 0; c_ba_list < alr_data->nc_data.c_ba_arfcn; c_ba_list++, pcell1++) + { + if (in_report[c_ba_list] EQ FALSE AND pcell1->ba_status EQ IN_BA) + { + switch (pcell1->status) + { + case FB_SB_SYNC: + case READ_SB: + case READ_SB_PENDING: + if (nc_ncell_in_plmn_permitted(pcell1->bsic)) + { + if ((pcell1->ba_arfcn NEQ alr_data->serving_cell AND + pcell1->one_of_six) OR + (pcell1->ba_arfcn EQ alr_data->serving_cell AND + alr_data->nc_data.sc_included)) + { + if (index EQ NOT_PRESENT_8BIT) + index = c_ba_list; + else + { + if (pcell1->rxlev_average > + alr_data->nc_data.cell[index].rxlev_average) + index = c_ba_list; + } + } + } + break; + } + } + } + + if (index NEQ NOT_PRESENT_8BIT) + { + T_NC* pcell = &alr_data->nc_data.cell[index]; + found = TRUE; + in_report[index] = TRUE; + + rr_report->ncells.arfcn[c_report] = pcell->ba_arfcn; + + if ((UBYTE)pcell->rxlev_average > 63) + rr_report->ncells.rx_lev[c_report] = 63; + else + rr_report->ncells.rx_lev[c_report] = (UBYTE)pcell->rxlev_average; + + rr_report->ncells.bsic[c_report] = pcell->bsic; + rr_report->ncells.time_alignmt[c_report] = pcell->time_align; + rr_report->ncells.frame_offset[c_report++] = pcell->frame_offset; + } + + } /*for (up to 6 ncells)*/ + /* + * insert serving cell values + */ + nc_fill_report_sc_dedi (rr_report, c_report); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_rank_ncells | ++--------------------------------------------------------------------+ + + PURPOSE : Searches for the six and additionally the twelve strongest neighbourcells. + +*/ +LOCAL void nc_rank_ncells (void) +{ + USHORT c_found, i; + USHORT last = (sizeof alr_data->nc_data.cell / + sizeof alr_data->nc_data.cell[0]); + UBYTE old_1of6[ sizeof alr_data->nc_data.cell / + sizeof alr_data->nc_data.cell[0] ]; + UBYTE num_1of6, hyst_rxlev, nc_conf_active = FALSE; + + num_1of6 = 0; + hyst_rxlev = 63; + alr_data->nc_data.new_strong_cell_detect = FALSE; + + for ( i = 0; i < last; i++ ) + { + old_1of6[i] = alr_data->nc_data.cell[i].one_of_six; + alr_data->nc_data.cell[i].new_strong_cell = FALSE; + + if(old_1of6[i]) + { + num_1of6++; + + if(alr_data->nc_data.cell[i].rxlev_average < hyst_rxlev) + hyst_rxlev = alr_data->nc_data.cell[i].rxlev_average; + } + + alr_data->nc_data.cell[i].one_of_six = FALSE; + + } + + if(num_1of6 < MAX_RR_NCELL_CNT) + hyst_rxlev = 0; + + if((GET_STATE(STATE_NC_PROC) EQ NC_CONFIRM) AND + (GET_STATE(STATE_NC) EQ NC_DEDICATED) AND + (!alr_data->nc_data.eotd_avail)) + nc_conf_active = TRUE; + + c_found = 0; + + if ((std EQ STD_DUAL) OR (std EQ STD_DUAL_EGSM) OR (std EQ STD_DUAL_US)) + { + switch (alr_data->nc_data.multiband) + { + case MULTI_BAND_0: + /* Find 6 cells from any band */ + nc_find_cells (&c_found, MAX_RR_NCELL_CNT, NO_BAND_LIMITATION, ALR_RXLEV_AVERAGE_MIN); + break; + case MULTI_BAND_1: + /* Find 1 cell from bands other than Serving cell band */ + nc_find_cells (&c_found, 1, EXCLUDE_SC_BAND, ALR_RXLEV_AVERAGE_LWR_THR); + + /* Find 5 cells from the Serving cell band */ + nc_find_cells (&c_found, MAX_RR_NCELL_CNT-1, ONLY_SC_BAND, ALR_RXLEV_AVERAGE_LWR_THR); + + /* If number of found cells are less than six, find the remaining from any band. + * Also relax the Rxlev criteria + */ + nc_find_cells (&c_found, (USHORT)(MAX_RR_NCELL_CNT - c_found), NO_BAND_LIMITATION, + ALR_RXLEV_AVERAGE_MIN); + break; + case MULTI_BAND_2: + /* Find 2 cell from bands other than Serving cell band */ + nc_find_cells (&c_found, 2, EXCLUDE_SC_BAND, ALR_RXLEV_AVERAGE_LWR_THR); + + /* Find 4 cells from the Serving cell band */ + nc_find_cells (&c_found, MAX_RR_NCELL_CNT-2, ONLY_SC_BAND, ALR_RXLEV_AVERAGE_LWR_THR); + + /* If number of found cells are less than six, find the remaining from any band. + * Also relax the Rxlev criteria + */ + nc_find_cells (&c_found, (USHORT)(MAX_RR_NCELL_CNT - c_found), NO_BAND_LIMITATION, + ALR_RXLEV_AVERAGE_MIN); + break; + case MULTI_BAND_3: + /* Find 3 cell from bands other than Serving cell band */ + nc_find_cells (&c_found, 3, EXCLUDE_SC_BAND, ALR_RXLEV_AVERAGE_LWR_THR); + + /* Find 3 cells from the Serving cell band */ + nc_find_cells (&c_found, MAX_RR_NCELL_CNT-3, ONLY_SC_BAND, ALR_RXLEV_AVERAGE_LWR_THR); + + /* If number of found cells are less than six, find the remaining from any band. + * Also relax the Rxlev criteria + */ + nc_find_cells (&c_found, (USHORT)(MAX_RR_NCELL_CNT - c_found), NO_BAND_LIMITATION, + ALR_RXLEV_AVERAGE_MIN); + break; + } + } + else + nc_find_cells (&c_found, MAX_RR_NCELL_CNT, NO_BAND_LIMITATION, ALR_RXLEV_AVERAGE_MIN); + + for ( i = 0; i < last; i++ ) + { + if (alr_data->nc_data.cell[i].one_of_six AND !old_1of6[i] AND + GET_STATE(STATE_NC) NEQ NC_DEDICATED) + { /* the cell becomes one of six */ + switch (alr_data->nc_data.cell[i].status) + { + case FB_SB_SYNC: + /* the cell is treaded as synchronized, perform BCCH reading ASAP */ + nc_set_status(i, READ_BCCH_RR_NOT_INFORMED); + break; + case READ_SB: + case IDLE_SYNC: + case FB_SB_FAILED: + /* the cell shall be synchronized ASAP, then BCCH info is to send to RR */ + nc_set_status(i, READ_FB_SB); + break; + case READ_SB_PENDING: + /* after receipt of sync ind the BCCH is to read and to send to RR */ + nc_set_status(i, READ_FB_SB_PENDING); + break; + default: + break; + } + } + if (old_1of6[i] AND + !alr_data->nc_data.cell[i].one_of_six AND + alr_data->nc_data.cell[i].status EQ FB_SB_SYNC) + alr_data->nc_data.cell[i].c_attempt = 0; + + /* Check the new strong cell criteria when confirmation is active */ + if(nc_conf_active) + { + nc_check_new_strong_cell(i, old_1of6[i], hyst_rxlev); + + } + } + + nc_find_list_cells(); + + TRACE_EVENT_P1("New strong cell detect:%d", + alr_data->nc_data.new_strong_cell_detect); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_find_cells | ++--------------------------------------------------------------------+ + + PURPOSE : Searches for the six strongest neighbourcells, + using multiband parameter if needed. + Called only in case of the value of 'std' is set to + STD_DUAL, STD_DUAL_EGSM or STD_DUAL_US. + (And therefore only for the combination of + GSM900/E-GSM/DCS1800 or GSM850/PCS1900.) + +*/ +LOCAL void nc_find_cells (USHORT *c_found, USHORT max, UBYTE limitation, + UBYTE min_rxlev) +{ + int i, j; + BOOL limit; + int index; + + + USHORT c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + T_NC* pcell; + UBYTE band_nc; + UBYTE band_sc = get_band (alr_data->serving_cell); + + if (*c_found >= MAX_RR_NCELL_CNT) + return; + + if (band_sc EQ BAND_E_GSM) + band_sc = BAND_GSM_900; /* equal treatment of E-GSM and GSM900 */ + + for (j = 0, index = 0; (j < max) AND (index NEQ NOT_PRESENT_16BIT); j++) + { + index = NOT_PRESENT_16BIT; + + for (i = 0; i < c_ba_arfcn; i++) + { + pcell = &alr_data->nc_data.cell[i]; + /* + * The six strongest neighbour cells do not include cells + * currently not belonging to BA list + */ + if (pcell->ba_status NEQ IN_BA) + continue; + + switch (pcell->status) + { + case INACTIVE: + case EXCLUDED: + /* + * The six strongest neighbour cells do not include failed ncells. + */ + break; + default: + if (pcell->ba_arfcn NEQ alr_data->serving_cell AND + pcell->one_of_six EQ FALSE AND + pcell->rxlev_average > min_rxlev) /* > -106 dBm */ + { + band_nc = get_band (pcell->ba_arfcn); + if (band_nc EQ BAND_E_GSM) + band_nc = BAND_GSM_900; /* equal treatment of E-GSM and GSM900 */ + + switch (limitation) + { + default: + case NO_BAND_LIMITATION: + limit = FALSE; + break; + case EXCLUDE_SC_BAND: + limit = (band_sc EQ band_nc); + break; + case ONLY_SC_BAND: + limit = (band_sc NEQ band_nc); + break; + } + + if (!limit) + { + if (index EQ NOT_PRESENT_16BIT) + { + index = i; + } + else + { + if (pcell->rxlev_average > + alr_data->nc_data.cell[index].rxlev_average) + { + index = i; + } + } + } + } + break; + } /*ncell status*/ + } + + if (index NEQ NOT_PRESENT_16BIT) + { + alr_data->nc_data.cell[index].one_of_six = TRUE; + (*c_found)++; + } + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_find_list_cells | ++--------------------------------------------------------------------+ + + PURPOSE : Searches for the 6 or 12 strongest neighbourcells + +*/ +LOCAL void nc_find_list_cells (void) +{ + USHORT i, j; + UBYTE found, c_found = 0; + USHORT index; + USHORT c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + T_NC* pcell; + + for (i = 0, pcell = &alr_data->nc_data.cell[0]; i < c_ba_arfcn; i++, pcell++ ) + { + if ((pcell->one_of_twelve = pcell->one_of_six) EQ TRUE) + c_found++; + } + /* + * The flag one_of_six controls the property to include a neighbour cell + * into the measurement report, + * the flag one_of_twelve controls whether the ncell is included into the + * synchronisation confirmation process. In case of EOTD up to 12 cell are + * included, in case of non-EOTD 6 cells are sufficient. + */ + if (!alr_data->nc_data.eotd_avail) + return; + + for (j = c_found, found = TRUE; (j < MAX_L1_SYNC_CNT) AND (found EQ TRUE); j++) + { + index = NOT_PRESENT_16BIT; + found = FALSE; + + for (i = 0; i < c_ba_arfcn; i++) + { + pcell = &alr_data->nc_data.cell[i]; + /* + * The 12 strongest neighbour cells do not include ncells currently not belonging to BA list. + */ + if (pcell->ba_status NEQ IN_BA) + continue; + + switch (pcell->status) + { + case INACTIVE: + case EXCLUDED: + /* + * The 12 strongest neighbour cells do not include failed ncells. + */ + break; + default: + if (pcell->ba_arfcn NEQ alr_data->serving_cell AND + pcell->one_of_twelve EQ FALSE AND + pcell->rxlev_average > ALR_RXLEV_AVERAGE_MIN) /* > -110 dBm */ + { + if (index EQ NOT_PRESENT_16BIT) + { + index = i; + found = TRUE; + } + else + { + if (pcell->rxlev_average > + alr_data->nc_data.cell[index].rxlev_average) + { + index = i; + found = TRUE; + } + } + } + break; + } /*ncell status*/ + } + + if (found AND (index NEQ NOT_PRESENT_16BIT)) + alr_data->nc_data.cell[index].one_of_twelve = TRUE; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_store_rxlev | ++--------------------------------------------------------------------+ + + PURPOSE : Stores the fieldstrength values of the neighbour cells. + Calculates the average of the fieldstrength after five + samples. + +*/ + + +LOCAL void nc_store_rxlev (T_MPHC_RXLEV_PERIODIC_IND *report) +{ + USHORT i; + USHORT index; + UBYTE diff; + int max_attempt; + T_NC* pcell; + + ALR_TRACE_NC("store rxlev"); + /* + * Patch for 20.5 + * The fieldstrength average for a new channel + * increases too slow if more then eight channels + * are in the neighbourcell list, because layer 1 + * sends not raw data every paging period. + */ + if (test_house AND + alr_data->nc_data.c_ba_arfcn > 8) + max_attempt = 3; + else + max_attempt = 5; + + if (alr_data->nc_data.tim_state NEQ NC_TIM_STOPPED) + { + /* Decrement the 10sec timer counter variable by BS_PA_MFRMS */ + alr_data->nc_data.c_ncsync_tim = (UBYTE)(alr_data->nc_data.c_ncsync_tim - alr_data->bs_pa_mfrms - 2); + + if ((signed char)(alr_data->nc_data.c_ncsync_tim) < 0) + alr_data->nc_data.c_ncsync_tim = 0; + + if( alr_data->nc_data.c_ncsync_tim EQ 0 ) + nc_ncsync_tim_expiry(); /* 10 sec have elapsed. Perform all requisite tasks */ + } + + /* serving cell rxlev storage */ + index = nc_get_index (alr_data->serving_cell); + pcell = &alr_data->nc_data.cell[index]; + + if ( (signed char)report->s_rxlev < 0) + report->s_rxlev = 0; + + if (pcell->c_rxlev EQ NOT_PRESENT_8BIT) + { + pcell->c_rxlev = 0; + memset (pcell->rxlev, report->s_rxlev, 5); + } + else + { + pcell->rxlev[pcell->c_rxlev++] = report->s_rxlev; + } + pcell->c_rxlev %= 5; + + /* + * store the results seperately for averaging when NC=1 or NC=2 + */ +#ifdef GPRS + if(alr_data->nwctrl_meas_active) + { + pcell->nc_rxlev += report->s_rxlev; + pcell->c_nc_rxlev++; + } +#endif + + /* + * ncell rxlev storage + */ + for (i = 0; i < report->nbr_of_carriers; i++) + { + /* + * The RX level from TI is signed in the SAP + * we define it as unsigned + */ + if ((signed char) (report->result[i].rxlev) < 0) + { + report->result[i].rxlev = 0; + } + + index = nc_get_index (ARFCN_TO_G23(report->result[i].radio_freq)); + if (index NEQ NOT_PRESENT_16BIT AND + index NEQ LAST_BSIC_REQ AND + ARFCN_TO_G23(report->result[i].radio_freq) NEQ alr_data->serving_cell) + { + int temp; + UBYTE rxlev = report->result[i].rxlev; + pcell = &alr_data->nc_data.cell[index]; + + if (pcell->c_rxlev EQ NOT_PRESENT_8BIT) + { + /* + * if it is a new cell, build an average from the first value + * to speed up fb sb read + */ + pcell->rxlev[0] = rxlev; + pcell->rxlev[1] = rxlev; + pcell->rxlev[2] = rxlev; + pcell->rxlev[3] = rxlev; + pcell->rxlev[4] = rxlev; + pcell->c_rxlev = 0; + } + else + { + pcell->rxlev[pcell->c_rxlev++] = rxlev; + if (pcell->c_rxlev >= (UBYTE)max_attempt) + pcell->c_rxlev = 0; + } + temp = pcell->rxlev[0] + + pcell->rxlev[1] + + pcell->rxlev[2]; + + if (max_attempt EQ 5) + { + temp += pcell->rxlev[3] + + pcell->rxlev[4]; + } + + pcell->rxlev_average = (UBYTE)(temp / max_attempt); + /* + * store the results seperately for averaging when NC=1 or NC=2 + */ +#ifdef GPRS + if(alr_data->nwctrl_meas_active) + { + pcell->nc_rxlev += rxlev; + pcell->c_nc_rxlev++; + } +#endif + + +#if defined(TRACING) + TRACE_EVENT_P4("NC%u[%d] rx=%d av=%d", + index, + pcell->ba_arfcn EQ NOT_PRESENT_16BIT ? -1 : pcell->ba_arfcn&ARFCN_MASK, + report->result[i].rxlev, pcell->rxlev_average); +#endif /* TRACING */ + + switch (pcell->status) + { + case INACTIVE: + nc_set_status (index, IDLE); + break; + case EXCLUDED: + diff = (UBYTE)(pcell->rxlev_average - pcell->last_rxlev); + if (diff < 128 AND diff >= 6) + { + /* + * result is positive and more than 6 dBm + */ + nc_set_status (index, IDLE); + } + break; + default: + break; + } + } + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_find_serving_cell_entry | ++--------------------------------------------------------------------+ + + PURPOSE : Finds an entry for serving cell + in the BCCH allocation list. + +*/ +LOCAL T_NC* nc_find_serving_cell_entry (USHORT serving_cell) +{ + T_NC* pcell; + USHORT i; + UBYTE last_alr = alr_data->nc_data.c_ba_arfcn; + + if (last_alr < LAST_BSIC_REQ) + { + pcell = &alr_data->nc_data.cell[last_alr]; +#if defined(TRACING) + TRACE_EVENT_P2 ("NC%u[%u] add", last_alr, serving_cell); +#endif /* TRACING */ + alr_data->nc_data.c_ba_arfcn = last_alr+1; /* store new last index */ + i = last_alr; + ALR_TRACE_ALL_NC (); + } + else + { /* ALR list is full, search for an entry not in state IN_BA */ + for (i = 0, pcell = alr_data->nc_data.cell; i < LAST_BSIC_REQ; i++, pcell++) + { + if (pcell->ba_status NEQ IN_BA) + break; + } /* for (i...) */ + if (i >= LAST_BSIC_REQ) + { /* + * no entry found + * reuse the last entry to make sure there is a place for serving cell + */ + i = LAST_BSIC_REQ-1; + pcell = &alr_data->nc_data.cell[i]; + } + + nc_stop_if_active(i); +#if defined(TRACING) + TRACE_EVENT_P2 ("NC%u[%u] replace", i, serving_cell); +#endif /* TRACING */ + } + nc_set_status (i, FB_SB_SYNC); + pcell->ba_status = IN_BA; /* even if not in the BA but other functions need it */ + pcell->ba_arfcn = serving_cell; + return pcell; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_add_serving_cell_ba_list| ++--------------------------------------------------------------------+ + + PURPOSE : Adds serving cell to neighbourcell list. + This function is called just before nc_start_reselect + and not after the MPHC_NEW_SCELL_CNF. + +*/ +LOCAL void nc_add_serving_cell_ba_list (USHORT serving_cell) +{ + USHORT index = nc_get_index (serving_cell); + T_NC* pcell; + + /* + * Add serving cell if not included + */ + switch (index) + { + case NOT_PRESENT_16BIT: + case LAST_BSIC_REQ: + /* serving cell isn´t inside the BA list */ + pcell = nc_find_serving_cell_entry(serving_cell); + pcell->bsic = alr_data->nc_data.cr_cell.bsic; + pcell->frame_offset = alr_data->nc_data.cr_cell.frame_offset; + pcell->time_align = alr_data->nc_data.cr_cell.time_align; + break; + + default: + if (index < ELEMENTS(alr_data->nc_data.cell)) + { + /* serving cell is already included in ba list */ + /* For GPRS the scell may not be in FB_SB_SYNC so put it there */ + pcell = &alr_data->nc_data.cell[index]; + + /* Check whether the cell has valid sync info */ + if (pcell->bsic NEQ NOT_PRESENT_8BIT) + { + nc_set_status(index, FB_SB_SYNC); + alr_data->nc_data.cell[index].one_of_six = FALSE; + alr_data->nc_data.cell[index].ba_status = IN_BA; /* even if not in the BA but other functions need it */ + } + } + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_update_ba_list | ++--------------------------------------------------------------------+ + + PURPOSE : Updates the BCCH allocation list. + +*/ + +LOCAL void nc_update_ba_list (USHORT serving_cell, T_MPH_NEIGHBOURCELL_REQ *ncell_list) +{ + USHORT n_rr; /* index of RR neighbor cell list */ + USHORT n_alr; /* index of ALR neighbor cell list */ + UBYTE last_alr; /* last index of ALR neighbor cell list */ + USHORT arfcn; + T_NC* pcell; + + alr_data->nc_data.multiband = ncell_list->multi_band; + + /* + * remove or mark all channels which are not longer member of the + * neighbour cell list. + */ + last_alr = alr_data->nc_data.c_ba_arfcn; /* current last index */ + for (n_alr = 0; n_alr < last_alr; n_alr++) + { + pcell = &alr_data->nc_data.cell[n_alr]; + arfcn = pcell->ba_arfcn; + if (!nc_is_in_ncell_list (arfcn, ncell_list) AND + (arfcn NEQ serving_cell)) + { + if (GET_STATE(STATE_NC) EQ NC_IDLE) + { /* the RR neighbor cell list is complete */ + last_alr = nc_remove_channel_from_ba_list (n_alr); +#if defined(TRACING) + TRACE_EVENT_P2 ("NC%u[%u] remove", n_alr, arfcn); +#endif /* TRACING */ + n_alr--; + ALR_TRACE_ALL_NC (); + } + else + { /* the RR neighbor cell list may be incomplete so mark only the entry */ + if (pcell->ba_status EQ IN_BA) + { + pcell->ba_status = NOT_IN_BA_SHORT; + +#if defined(TRACING) + TRACE_EVENT_P2 ("NC%u[%u] -> NOT_IN_BA_SHORT", n_alr, arfcn); +#endif /* TRACING */ + } + } + } + } + + /* + * add all new channels. + */ + for (n_rr = 0; n_rr < MAX_NEIGHBOURCELLS; n_rr++) + { + arfcn = ncell_list->arfcn[n_rr]; + if (arfcn EQ NOT_PRESENT_16BIT) + break; /* no more entries in the RR ncell_list */ + + n_alr = nc_get_index (arfcn); + + if (arfcn NEQ serving_cell) + { + if (n_alr EQ NOT_PRESENT_16BIT OR n_alr EQ LAST_BSIC_REQ) + { + if (last_alr < BA_LIST_SIZE) + { + pcell = &alr_data->nc_data.cell[last_alr]; + +#if defined(TRACING) + TRACE_EVENT_P2 ("NC%u[%u] add", last_alr, arfcn); +#endif /* TRACING */ + pcell->ba_arfcn = arfcn; + nc_set_status (last_alr, INACTIVE); + pcell->ba_status = IN_BA; + last_alr++; /* increment last index */ + } + else + { /* ALR list is full, search for an entry not in state IN_BA */ + USHORT i; + for (i = 0, pcell = alr_data->nc_data.cell; i < BA_LIST_SIZE; i++, pcell++) + { + if (pcell->ba_status NEQ IN_BA AND pcell->ba_arfcn NEQ serving_cell) + { + nc_stop_if_active(i); +#if defined(TRACING) + TRACE_EVENT_P2 ("NC%u[%u] replace", i, arfcn); +#endif /* TRACING */ + pcell->ba_arfcn = arfcn; + nc_set_status (i, INACTIVE); + pcell->ba_status = IN_BA; + break; + } + } /* for (i...) */ + } + } + else + { +#if defined(TRACING) + if (alr_data->nc_data.cell[n_alr].ba_status NEQ IN_BA) + TRACE_EVENT_P2 ("NC%u[%u] -> IN_BA", n_alr, arfcn); +#endif + alr_data->nc_data.cell[n_alr].ba_status = IN_BA; + } + } /* if (arfcn NEQ serving_cell) */ + } + + /* + * store whether SC was included into the BA list by the net + */ + if (nc_is_in_ncell_list (serving_cell, ncell_list)) + { + alr_data->nc_data.sc_included = TRUE; + } + else + { + alr_data->nc_data.sc_included = FALSE; + } + alr_data->nc_data.c_ba_arfcn = last_alr; /* store new last index */ + + /* + * Add serving cell if not included + */ + n_alr = nc_get_index (serving_cell); + switch (n_alr) + { + case NOT_PRESENT_16BIT: + case LAST_BSIC_REQ: + pcell = nc_find_serving_cell_entry(serving_cell); + + pcell->bsic = alr_data->bsic; + pcell->frame_offset = 0; + pcell->time_align = 0; + break; + + default: + /* serving cell is already included */ + pcell = &alr_data->nc_data.cell[n_alr]; + pcell->bsic = alr_data->bsic; + pcell->frame_offset = 0; + pcell->time_align = 0; + pcell->ba_status = IN_BA; /* even if not in the BA but other functions need it */ + nc_set_status (n_alr, FB_SB_SYNC); /* make sure the SC is reported in measurement reports if included into BA list */ + break; + } + + /* + * reset status of neighbour cells with failed + * synchronisation attempts. + */ + for (n_alr = 0; n_alr < last_alr; n_alr++) + { + switch (alr_data->nc_data.cell[n_alr].status) + { + case FB_SB_FAILED: + case EXCLUDED: + alr_data->nc_data.cell[n_alr].tim_valid = TV_INVALID_TIMING_INFO; + nc_set_status (n_alr, IDLE); + break; + } + } + + /* + * Reorder the entries. The goal is that the propably strongest neigbour cells + * are measured in the first measurement period of a subsequent + * MPHC_RXLEV_PERIODIC_REQ/IND. The appropriate arfcn's are the first ones in + * ncell_list->arfcn + */ + if (last_alr > 8) + { + T_NC temp, *prr, *palr; + + for (n_rr = 0; n_rr < 8 && ncell_list->arfcn[n_rr] NEQ NOT_PRESENT_16BIT; n_rr++) + { + n_alr = nc_get_index (ncell_list->arfcn[n_rr]); + if (n_rr NEQ n_alr) + { + palr = &(alr_data->nc_data.cell[n_alr]); + prr = &(alr_data->nc_data.cell[n_rr]); + memcpy(&temp, palr, sizeof(T_NC)); + memcpy(palr, prr, sizeof(T_NC)); + memcpy(prr, &temp, sizeof(T_NC)); + /*TRACE_EVENT_P4("reordered NC%u[%u] and NC%u[%u]", + n_rr, + ncell_list->arfcn[n_rr], + n_alr, ncell_list->arfcn[n_alr]);*/ + } + } + } + + ALR_TRACE_ALL_NC (); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_new_serving_cell | ++--------------------------------------------------------------------+ + + PURPOSE : Store old, set new serving cell, and add to neighbourcell list. + +*/ +GLOBAL void nc_new_serving_cell (USHORT serving_cell) +{ + alr_data->old_serving_cell = alr_data->serving_cell; + alr_data->serving_cell = serving_cell; + alr_data->sc_band = get_band (alr_data->serving_cell); + nc_add_serving_cell_ba_list(serving_cell); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_is_in_ncell_list | ++--------------------------------------------------------------------+ + + PURPOSE : Checks whether a channel is in the ncell_list of RR. + +*/ +LOCAL UBYTE nc_is_in_ncell_list (USHORT channel, T_MPH_NEIGHBOURCELL_REQ *ncell_list) +{ + USHORT i; + + for (i = 0; i < MAX_NEIGHBOURCELLS AND ncell_list->arfcn[i] NEQ NOT_PRESENT_16BIT; i++) + { + if (channel EQ ncell_list->arfcn[i]) + return TRUE; + } + + return FALSE; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_remove_channel_from_ba_list | ++--------------------------------------------------------------------+ + + PURPOSE : Removes one channel from the BCCH allocation. + +*/ + +LOCAL UBYTE nc_remove_channel_from_ba_list (USHORT index) +{ + USHORT i; + UBYTE c_ba_arfcn; + + switch(alr_data->nc_data.cell[index].status) + { + case READ_SB_PENDING: + case READ_SB_BCCH_PENDING: + if ( alr_data->nc_data.eotd_avail AND + ( GET_STATE(STATE_NC_PROC) EQ NC_CONFIRM) ) + { + /* we cannot stop this + * because we are using a list_req + */ + nc_set_status(index, INACTIVE); + break; + } + /*lint -fallthrough*/ + case READ_FB_SB_PENDING: + /* + * sync request is ongoing in layer 1. + */ + nc_stop_sync (index, INACTIVE); + break; + case READ_BCCH_PENDING: + case READ_BCCH_PENDING_RR_NOT_INFORMED: + /* + * stop pending BCCH request + */ + nc_stop_bcch (index, INACTIVE); + break; + default: + nc_set_status (index, INACTIVE); + break; + } + + c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + for (i = index + 1; i < c_ba_arfcn; i++) + { + memcpy (&alr_data->nc_data.cell[i - 1],&alr_data->nc_data.cell[i],sizeof(T_NC)); /*shift NC*/ + } + memset (&alr_data->nc_data.cell[i - 1],0,sizeof (T_NC));/*delete old content of obsolete ba_list entry*/ + + alr_data->nc_data.c_ba_arfcn--; + return (alr_data->nc_data.c_ba_arfcn); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_get_index | ++--------------------------------------------------------------------+ + + PURPOSE : Calculates the index in the BCCH allocation. + +*/ + +GLOBAL USHORT nc_get_index (USHORT arfcn) +{ + USHORT i; + T_NC *pcell; /* use pointer to increase processing speed */ + USHORT last_alr; /* last index of ALR neighbor cell list */ + + last_alr = alr_data->nc_data.c_ba_arfcn; + pcell = &alr_data->nc_data.cell[0]; /* pointer to first cell */ + for (i = 0; i < last_alr; i++, pcell++) + { + if (arfcn EQ pcell->ba_arfcn) + return i; + } + + if (arfcn EQ alr_data->nc_data.cell[LAST_BSIC_REQ].ba_arfcn) + return LAST_BSIC_REQ; + + return NOT_PRESENT_16BIT; +} +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_build_sync_req | ++--------------------------------------------------------------------+ + + PURPOSE : Builds an MPHC_NCELL_SYNC_REQ and sends it to L1. + +*/ +LOCAL void nc_build_sync_req (USHORT index) +{ + T_NC * p_ncell = &alr_data->nc_data.cell[index]; + PALLOC (sync_req, MPHC_NCELL_SYNC_REQ); + + sync_req->radio_freq = ARFCN_TO_L1(p_ncell->ba_arfcn); + if (p_ncell->tim_valid EQ TV_INVALID_TIMING_INFO) + { + sync_req->fn_offset = 0; + sync_req->time_alignment = 0; + } + else + { + sync_req->fn_offset = p_ncell->frame_offset; + sync_req->time_alignment = p_ncell->time_align; + } + sync_req->timing_validity = p_ncell->tim_valid; + TRACE_EVENT_P4("nc_build_sync_req[%d] timing_validity=%d fn_offset=%ld, time_alignment=%ld", + p_ncell->ba_arfcn, + sync_req->timing_validity, + sync_req->fn_offset, + sync_req->time_alignment); + ma_nc_sync_req (sync_req); + + ALR_EM_READ_NEIGHBOURCELL_SB; + + nc_set_status (index, READ_FB_SB_PENDING); + alr_data->nc_data.c_sync_req++; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_process_status | ++--------------------------------------------------------------------+ + + PURPOSE : Starts a specific procedure for neighbour cells like + synchronisation to frequency correction burst and + synchron burst, confirmation of synchron burst or + reading of BCCH. With the new ALR interface it's possible + to send up to 12 SYNC_REQ's and BCCH_REQ's. + +*/ + +LOCAL void nc_process_status (void) +{ + UBYTE st = GET_STATE(STATE_NC); + + /* Sync requests for New cells are allowed only in dedicated state + * when eotd is not enabled. Fix for + */ + if(((alr_data->nc_data.eotd_avail) OR ( st NEQ NC_DEDICATED)) AND + (GET_STATE(STATE_NC_PROC) EQ NC_CONFIRM)) + return; + +#ifdef GPRS + if((st EQ NC_IDLE AND !ma_is_ptm()) OR + st EQ NC_PIM_PBCCH ) + nc_process_status_last_bsic(); +#else + nc_process_status_last_bsic(); +#endif + + + if(alr_data->plmn_search_running) + return; + +#ifdef GPRS + if(st EQ NC_PIM_PBCCH OR + st EQ NC_PTM_PBCCH ) + nc_process_status_sync_gprs(); + else +#endif + nc_process_status_sync(); + + if(st EQ NC_IDLE) + nc_process_status_bcch(); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_process_status_last_bsic| ++--------------------------------------------------------------------+ + + PURPOSE : When doing idle mode cell selection we use + LAST_BSIC_REQ for storing the information of the cell. + This has priority over normal neighbour cell monitoring. + +*/ + + +LOCAL void nc_process_status_last_bsic(void) +{ + T_NC* pbsic = &alr_data->nc_data.cell[LAST_BSIC_REQ]; + + + switch (pbsic->status) + { + case READ_FB_SB: + if (alr_data->nc_data.c_sync_req < MAX_L1_SYNC_CNT) + { + pbsic->tim_valid = TV_INVALID_TIMING_INFO; + nc_build_sync_req (LAST_BSIC_REQ); + ALR_TRACE_NC ("ncell_sync_req HPLMN"); + + /* If the Mobile is in page mode REORG the NC search cannot be + * performed because L1 is too busy listening to the PCH. Therefore + * the page mode is changed from REORG to REORG_NC_SYNC (NORMAL). + */ + if(alr_data->pch_data.pl_idle.page_mode EQ PGM_REORG OR + alr_data->pch_data.pl_idle.page_mode EQ PGM_REORG_CS) + { + page_mode_before_hplmn_search = alr_data->pch_data.pl_idle.page_mode; + alr_data->pch_data.pl_idle.page_mode = PGM_REORG_NC_SYNC; + pch_start_ccch_req (); + ALR_TRACE_NC ("HPLMN search cannot be performed with REORG - possible loss of pagings"); + } + + } + return ; + + case READ_BCCH: + if (alr_data->nc_data.c_bcch_req < MAX_L1_BCCH_CNT) + { + PALLOC (ncell_bcch, MPHC_NCELL_BCCH_REQ); + + ncell_bcch->radio_freq = ARFCN_TO_L1(pbsic->ba_arfcn); + ncell_bcch->fn_offset = pbsic->frame_offset; + ncell_bcch->time_alignment = pbsic->time_align; + /* + * The training sequence code on broadcast and common control channels + * has to be equal to the base station color code see GSM 5.02 + */ + ncell_bcch->tsc = (UBYTE)(pbsic->bsic & ONLY_BCC); + /* + * Read SI 3/4 to get the MNC/MCC + */ + pbsic->blocks_required = + ncell_bcch->bcch_blocks_required = NCELL_BCCH_SI_3_4; + ncell_bcch->gprs_prio = GPRS_PRIO_NORM; + + ma_nc_bcch_req (ncell_bcch); + alr_data->nc_data.c_bcch_req++; + nc_set_status (LAST_BSIC_REQ, READ_BCCH_PENDING); + } + return; + case READ_FB_SB_PENDING: + case READ_BCCH_PENDING: + return; + default: + break; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_process_status_sync | ++--------------------------------------------------------------------+ + + PURPOSE : Processes cell synchronisation. + +*/ + + + +LOCAL void nc_process_status_sync(void) +{ + USHORT i; + USHORT index; + T_NC* pbsic = &alr_data->nc_data.cell[LAST_BSIC_REQ]; + + /* Sync requests for New cells are allowed only in dedicated state + * when eotd is not enabled. Patch for + */ + if((!alr_data->nc_data.eotd_avail) AND + ( GET_STATE(STATE_NC) EQ NC_DEDICATED) AND + (GET_STATE(STATE_NC_PROC) EQ NC_CONFIRM)) + { + if(alr_data->nc_data.new_strong_cell_detect) + nc_handle_new_strong_cells(); + + alr_data->nc_data.new_strong_cell_detect = FALSE; + return; + } + + while (alr_data->nc_data.c_sync_req < MAX_L1_SYNC_CNT) + { + /* + * It is possible to send more sync requests to layer 1 + */ + USHORT c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + index = NOT_PRESENT_16BIT; + + for (i = 0; i < c_ba_arfcn; i++) + { + /* + * search for the candidate with the highest fieldstrength + */ + T_NC* pcell = &alr_data->nc_data.cell[i]; + + if ((pcell->ba_arfcn NEQ pbsic->ba_arfcn) AND + (pcell->ba_arfcn NEQ alr_data->serving_cell)) + { + switch (pcell->status) + { + case READ_FB_SB: + if (index EQ NOT_PRESENT_16BIT) + index = i; + else + { + if (pcell->rxlev_average > + alr_data->nc_data.cell[index].rxlev_average) + index = i; + } + break; + default: + break; + } + } + } + + if (index NEQ NOT_PRESENT_16BIT) + { + /* + * Request synchronisation for this cell + */ + nc_build_sync_req(index); + ALR_TRACE_NC ("ncell_sync_req"); + } + else + break; /*while loop */ + } /* while( c_sync_req < MAX_L1_SYNC_CNT) */ +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_process_status_sync_gprs| ++--------------------------------------------------------------------+ + + PURPOSE : Processes GPRS cell synchronisation. + +*/ + + +#ifdef GPRS /*XXX*/ +LOCAL void nc_process_status_sync_gprs(void) +{ + USHORT i; + T_NC* pbsic = &alr_data->nc_data.cell[LAST_BSIC_REQ]; + USHORT c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + + + for (i = 0; i < c_ba_arfcn AND alr_data->nc_data.c_sync_req < MAX_L1_SYNC_CNT; i++) + { + /* + * search for the candidate with the highest fieldstrength + */ + T_NC* pcell = &alr_data->nc_data.cell[i]; + + if ((pcell->ba_arfcn NEQ pbsic->ba_arfcn) AND + (pcell->ba_arfcn NEQ alr_data->serving_cell) AND + (pcell->status EQ READ_FB_SB)) + { + /* + * Request synchronisation for this cell + */ + nc_build_sync_req(i); + ALR_TRACE_NC ("ncell_sync_req"); + } + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_sync_failed_gprs | ++--------------------------------------------------------------------+ + + PURPOSE : Handles synchronisation failed situation + +*/ + + +LOCAL void nc_sync_failed_gprs(USHORT index) +{ + alr_data->nc_data.cell[index].c_sync = 1; /*XXX*/ + nc_set_status (index, FB_SB_FAILED); + nc_inform_grr_of_ncell(index, GRR_SB_NOT_FOUND); +} +#endif + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_process_status_bcch | ++--------------------------------------------------------------------+ + + PURPOSE : Processes CB status + +*/ + + +LOCAL void nc_process_status_bcch(void) +{ + USHORT i; + USHORT index; + T_NC* pbsic = &alr_data->nc_data.cell[LAST_BSIC_REQ]; + + while (alr_data->nc_data.c_bcch_req < MAX_L1_BCCH_CNT) + { + /* + * It is possible to send more BCCH request to layer 1 + */ + USHORT c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + index = NOT_PRESENT_16BIT; + + for (i = 0; i < c_ba_arfcn; i++) + { + /* + * search for the candidate with the highest fieldstrength + */ + T_NC* pcell = &alr_data->nc_data.cell[i]; + + if ((pcell->ba_arfcn NEQ pbsic->ba_arfcn) AND + (pcell->ba_arfcn NEQ alr_data->serving_cell)) + { + switch (pcell->status) + { + case READ_BCCH: + case READ_BCCH_RR_NOT_INFORMED: + if (index EQ NOT_PRESENT_16BIT) + index = i; + else + { + if (pcell->rxlev_average > + alr_data->nc_data.cell[index].rxlev_average) + index = i; + } + break; + default: + break; + } + } + } + + if (index NEQ NOT_PRESENT_16BIT) + { + /* + * Request BCCH reading for this cell + */ + T_NC* pcell = &alr_data->nc_data.cell[index]; + PALLOC (ncell_bcch, MPHC_NCELL_BCCH_REQ); + + ncell_bcch->radio_freq = ARFCN_TO_L1(pcell->ba_arfcn); + ncell_bcch->fn_offset = pcell->frame_offset; + ncell_bcch->time_alignment = pcell->time_align; + /* + * The training sequence code on broadcast and common control channels + * has to be equal to the Base Station Colour Code (BCC), + * see 3GPP TS 5.02, section 5.2.3 and + * 3GPP TS 03.03, section 4.3.2 Base Station Identify Code (BSIC) + */ + ncell_bcch->tsc = (UBYTE)(pcell->bsic & ONLY_BCC); + pcell->blocks_required = + ncell_bcch->bcch_blocks_required = NCELL_BCCH_SI_3_4; +#ifdef GPRS + /*if the mobile is in PTM the GPRS_PRIORITY must be set to TOP*/ + if(ma_is_ptm()) + { + ncell_bcch->gprs_prio = GPRS_PRIO_TOP; + } + else +#endif + ncell_bcch->gprs_prio = GPRS_PRIO_NORM; + + + ma_nc_bcch_req (ncell_bcch); + + ALR_TRACE_NC("ncell_bcch_read"); + + alr_data->nc_data.c_bcch_req++; + /* + * read a maximum of four blocks + * + * sys info 3 normal BCCH TC 2 or 6 + * sys info 4 normal BCCH TC 3 or 7 + */ + if(pcell->status EQ READ_BCCH) + nc_set_status (index, READ_BCCH_PENDING); + else + nc_set_status (index, READ_BCCH_PENDING_RR_NOT_INFORMED); + } + else + break; /*while loop */ + } /* while(c_bcch_req < MAX_L1_BCCH_CNT)*/ +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_ncell_in_plmn_permitted | ++--------------------------------------------------------------------+ + + PURPOSE : checks whether the national colour code (ncc) is member + of the ncc permitted field. + +*/ +static const UBYTE ncc_bit_mask[8] = + { + BIT_0, BIT_1, BIT_2, BIT_3, + BIT_4, BIT_5, BIT_6, BIT_7 + }; + +LOCAL BOOL nc_ncell_in_plmn_permitted (UBYTE bsic) +{ + return ((BOOL) ((UBYTE) (alr_data->ncc_permitted & + ncc_bit_mask[(bsic >> 3) & BIT_012])) NEQ 0); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_store_dedicated | ++--------------------------------------------------------------------+ + + PURPOSE : Stores the values of the neighbour cells + and the serving cell. + +*/ +LOCAL void nc_store_dedicated (T_MPHC_MEAS_REPORT *report) +{ + USHORT i; + USHORT index; + USHORT c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + + if (alr_data->nc_data.tim_state NEQ NC_TIM_STOPPED) + { + /* Decrement the 10sec timer counter variable by 2 */ + alr_data->nc_data.c_ncsync_tim = alr_data->nc_data.c_ncsync_tim-2; + + if ((signed char)( alr_data->nc_data.c_ncsync_tim) < 0) + alr_data->nc_data.c_ncsync_tim = 0; + + if( alr_data->nc_data.c_ncsync_tim EQ 0 ) /* 10 sec have elapsed. Perform all requisite tasks */ + nc_ncsync_tim_expiry(); + } + + for (i = 0; i < report->no_of_ncells_meas; i++) + { + T_NC* pcell; + T_res_list* plist = &report->ncell_meas.res_list[i]; + + index = nc_get_index (ARFCN_TO_G23(plist->bcch_freq)); + if ((index EQ NOT_PRESENT_16BIT) OR (index EQ LAST_BSIC_REQ)) + continue; + pcell = &alr_data->nc_data.cell[index]; + + if (plist->rxlev_nbr_meas EQ 0) + pcell->rxlev_average = 0; + else + { + if ((signed short)(plist->rxlev_acc) < 0) + plist->rxlev_acc = 0; + + /* why this casting? - a "real" expression is of type int */ + pcell->rxlev_average = (UBYTE)(plist->rxlev_acc/plist->rxlev_nbr_meas); + } + if (pcell->status EQ INACTIVE) + nc_set_status (index, IDLE); + + if (pcell->status EQ EXCLUDED) + { + int diff; + + diff = pcell->rxlev_average - pcell->last_rxlev; + + if (diff >= 6) + { + /* + * result is positive and more than 6 dBm + */ + nc_set_status (index, IDLE); + } + } + } + + + alr_data->nc_data.act_dtx = report->dtx_used; + + if (report->rxlev_full_nbr_meas EQ 0) + alr_data->nc_data.rxlev_full = 0; + else + { + if ((signed short)(report->rxlev_full_acc) < 0) + report->rxlev_full_acc = 0; + + alr_data->nc_data.rxlev_full = + (UBYTE)(report->rxlev_full_acc / report->rxlev_full_nbr_meas); + } + + if (report->rxlev_sub_nbr_meas EQ 0) + alr_data->nc_data.rxlev_sub = 0; + else + { + if ((signed short)(report->rxlev_sub_acc) < 0) + report->rxlev_sub_acc = 0; + alr_data->nc_data.rxlev_sub = (UBYTE)(report->rxlev_sub_acc / report->rxlev_sub_nbr_meas); + } + + alr_data->nc_data.rxqual_full = + nc_convert_quality (report->rxqual_full_acc_errors, + report->rxqual_full_nbr_bits); + + alr_data->nc_data.rxqual_sub = + nc_convert_quality (report->rxqual_sub_acc_errors, + report->rxqual_sub_nbr_bits); +} + + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_convert_quality | ++--------------------------------------------------------------------+ + + PURPOSE : Calculates the quality Value. + +*/ + +LOCAL UBYTE nc_convert_quality (USHORT errors, USHORT total) +{ + USHORT quality; + + if (total EQ 0) + quality = 0; + else + quality = (USHORT)((errors * 500) / total); + + if (quality EQ 0) + return 0; /* RX_QUAL_0 */ + + if (quality EQ 1) + return 1; /* RX_QUAL_1 */ + + if (quality < 4) + return 2; /* RX_QUAL_2 */ + + if (quality < 8) + return 3; /* RX_QUAL_3 */ + + if (quality < 16) + return 4; /* RX_QUAL_4 */ + + if (quality < 32) + return 5; /* RX_QUAL_5 */ + + if (quality < 64) + return 6; /* RX_QUAL_6 */ + + return 7; /* RX_QUAL_7 */ + +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_release_bcch | ++--------------------------------------------------------------------+ + +PURPOSE : Check if we have read the BCCH of a ncell but RR has + not yet received the data because this cell has not + been reported to RR before. +*/ + +LOCAL void nc_release_bcch (void) +{ + USHORT i; + USHORT c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + /* + * for every ncell + */ + for (i = 0; i < c_ba_arfcn; i++) + { + T_NC* pcell = &alr_data->nc_data.cell[i]; + + switch (pcell->status) + { + case FB_SB_SYNC_RR_NOT_INFORMED: + /* + * Reading of the BCCH of the neighbourcell is performed, + * but RR has been just informed with a measurement report + * about synchronisation. + */ + if(pcell->mph_unitdata_ind NEQ NULL) + { + ALR_TRACE_NC ("send 34"); + + /* + * a system info type 3 or 4 message is stored. + * Send the message to RR and clear the internal variable. + */ + PSENDX(RR, pcell->mph_unitdata_ind); + pcell->mph_unitdata_ind = NULL; + } + + if(pcell->mph_unitdata_ind78 NEQ NULL) + { + ALR_TRACE_NC ("send 78"); + + /* + * a system info type 7 or 8 message is stored. + * Send the message to RR and clear the internal variable. + */ + PSENDX(RR, pcell->mph_unitdata_ind78); + pcell->mph_unitdata_ind78 = NULL; + } + + /* + * set status to FB_SB_SYNC, that means RR is completely informed. + */ + nc_set_fb_sb_sync_initial (i); + break; + + default: + break; + } + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_store_bcch | ++--------------------------------------------------------------------+ + +PURPOSE : Temporarily store BCCH data for ncell. + +*/ + +LOCAL void nc_store_bcch (T_MPHC_DATA_IND* data_ind, USHORT index, UBYTE sys_info_78) +{ + #define SYS_INFO_LEN 24 + + USHORT len_in_bits = SYS_INFO_LEN * BITS_PER_BYTE; + T_NC* pcell = &alr_data->nc_data.cell[index]; + /* + * Allocate a SDU for sending later to RR + */ + PALLOC_SDU (data_out, MPH_UNITDATA_IND, len_in_bits); + + /* + * set length and offset, but cut IE and Pseudo Length + */ + data_out->sdu.l_buf = (SYS_INFO_LEN - 2) * BITS_PER_BYTE; + data_out->sdu.o_buf = 1 * BITS_PER_BYTE; + + /* + * copy content of the message + */ + memcpy (data_out->sdu.buf, &data_ind->l2_frame, SYS_INFO_LEN - 1);/*lint !e419 (Warning -- Apparent data overrun)*/ + + /* + * set BCCH frequency of the message + */ + data_out->arfcn = ARFCN_TO_G23(data_ind->radio_freq)&ARFCN_MASK; + data_out->fn = data_ind->fn; + + if (sys_info_78) + { + ALR_TRACE_NC ("store 78"); + + /* + * if it is a system info 7 or 8 message, free the previous + * stored message, if something is stored and store the new + * one. + */ + if (pcell->mph_unitdata_ind78 NEQ NULL) + { + ALR_TRACE_NC ("store,free old 78"); + + PFREE(pcell->mph_unitdata_ind78); + } + + pcell->mph_unitdata_ind78 = data_out; + + } + else + { + ALR_TRACE_NC ("store 34"); + + /* + * if it is a system info 3 or 4 message, free the previous + * stored message, if something is stored and store the new + * one. + */ + if (pcell->mph_unitdata_ind NEQ NULL) + { + ALR_TRACE_NC( "store,free old 34"); + + PFREE(pcell->mph_unitdata_ind); + } + + pcell->mph_unitdata_ind = data_out; + + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_sys_info_78_required | ++--------------------------------------------------------------------+ + +PURPOSE : The function checks whether sys info 7 or 8 are expected + and required. + +*/ + +LOCAL UBYTE nc_sys_info_78_required (USHORT index) +{ + if (alr_data->nc_data.cell[index].mph_unitdata_ind NEQ 0) + { + T_sdu * sdu = &alr_data->nc_data.cell[index].mph_unitdata_ind->sdu; +/*lint -e415 (Warning -- creation of out-of-bounds pointer)*/ +/*lint -e416 (Warning -- access of out-of-bounds pointer)*/ + if ((sdu->buf[SI_CONTENTS_CS2] & ONLY_ACS) NEQ 0) + return TRUE; +/*lint +e415 (Warning -- creation of out-of-bounds pointer)*/ +/*lint +e416 (Warning -- access of out-of-bounds pointer)*/ + } + return FALSE; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_stop_bcch | ++--------------------------------------------------------------------+ + + PURPOSE : Stop a pending BCCH. + +*/ + +LOCAL void nc_stop_bcch (USHORT index, UBYTE new_status) +{ + /* + * L3 may avoid sending a stop message to terminate a NCELL_BCCH process + * if there no more pending request in L1 + */ + + if (alr_data->nc_data.c_bcch_req > 0) + { + /* + * stop BCCH request in layer 1. + */ + ma_nc_stop_ncell_bcch_req(alr_data->nc_data.cell[index].ba_arfcn); + + /* + * decrement counter of pending requests + */ + alr_data->nc_data.c_bcch_req--; + } + + /* + * set new status + */ + nc_set_status (index, new_status); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_stop_sync | ++--------------------------------------------------------------------+ + + PURPOSE : Stop a pending Sync request. + +*/ + +LOCAL void nc_stop_sync (USHORT index, UBYTE new_status) +{ + /* + * L3 may avoid sending a stop message to terminate a NCELL_SYNC process + * if there no more pending request in L1 + */ + + if (alr_data->nc_data.c_sync_req > 0) + { + /* + * stop sync request in layer 1. + */ + ma_nc_stop_ncell_sync_req (alr_data->nc_data.cell[index].ba_arfcn); + + /* + * decrement counter of pending requests + */ + alr_data->nc_data.c_sync_req--; + /* + * check whether the confirmation procedure is finished indirectly + */ + if (alr_data->nc_data.c_sync_req EQ 0 AND + alr_data->nc_data.eotd_avail EQ FALSE AND + GET_STATE(STATE_NC_PROC) EQ NC_CONFIRM) + { + nc_enable_conf(); + } + } + + /* + * set new status + */ + nc_set_status (index, new_status); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_clean_store_bcch | ++--------------------------------------------------------------------+ + + PURPOSE : Clean a stored BCCH. + +*/ + +LOCAL void nc_clean_store_bcch (USHORT index) +{ + T_NC* pcell = &alr_data->nc_data.cell[index]; + if (pcell->mph_unitdata_ind NEQ NULL) + { + ALR_TRACE_NC ("free 34"); + + /* + * a system info type 3 or 4 message is stored + * then free the message and clean the pointer. + */ + + PFREE(pcell->mph_unitdata_ind); + pcell->mph_unitdata_ind = NULL; + + } + + if(pcell->mph_unitdata_ind78 NEQ NULL) + { + ALR_TRACE_NC ("free 78"); + + /* + * a system info type 7 or 8 message is stored + * then free the message and clean the pointer. + */ + + PFREE(pcell->mph_unitdata_ind78); + pcell->mph_unitdata_ind78 = NULL; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_check_bsic | ++--------------------------------------------------------------------+ + + PURPOSE : Check a base station identification code of a neighbourcell + The following return values are possible: + + NC_CHECK_OK : BSIC has not changed and is permitted. + NC_CHECK_NCC_FAILED : NCC permitted check has failed + NC_CHECK_BSIC_CHANGED : a BSIC change has occured + + +*/ + +LOCAL UBYTE nc_check_bsic (USHORT index, UBYTE bsic) +{ + /* + * check only the lowest 6 bits (= NCC + BCC) + */ + bsic = (UBYTE)(bsic & ONLY_BSIC); + + /* + * first check whether ncc is member of the ncc permitted field + */ + if (!nc_ncell_in_plmn_permitted (bsic)) + return NC_CHECK_NCC_FAILED; + + /* + * no bsic stored until now. + */ + if (alr_data->nc_data.cell[index].bsic EQ NOT_PRESENT_8BIT) + return NC_CHECK_OK; + + /* + * check against BSIC changes + */ + if (alr_data->nc_data.cell[index].bsic NEQ bsic) + return NC_CHECK_BSIC_CHANGED; + + /* + * all checks passed + */ + return NC_CHECK_OK; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_check_new_ncc_permitted | ++--------------------------------------------------------------------+ + +PURPOSE : Checks whether status transitions are needed after reception + of a changed NCC permitted field. + +*/ + +GLOBAL void nc_check_new_ncc_permitted (UBYTE new_ncc_permitted) +{ + USHORT i; + USHORT c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + if (new_ncc_permitted NEQ alr_data->ncc_permitted) + { + /* + * a change has occured, so store new value and check all cells + */ + alr_data->ncc_permitted = new_ncc_permitted; + + for (i = 0; i < c_ba_arfcn; i++) + { + switch (alr_data->nc_data.cell[i].status) + { + case FB_SB_SYNC: + case FB_SB_SYNC_RR_NOT_INFORMED: + case READ_SB: + case READ_BCCH: + case IDLE_SYNC: + case READ_SB_BCCH: + case READ_BCCH_RR_NOT_INFORMED: + if (nc_ncell_in_plmn_permitted(alr_data->nc_data.cell[i].bsic) EQ FALSE) + nc_set_status (i, EXCLUDED); + break; + + case READ_BCCH_PENDING: + case READ_BCCH_PENDING_RR_NOT_INFORMED: + if (nc_ncell_in_plmn_permitted(alr_data->nc_data.cell[i].bsic) EQ FALSE) + nc_set_status (i, EXCLUDED); + break; + + case EXCLUDED: + /* + * give channel a new chance + */ + nc_set_status (i, IDLE); + break; + } + } + } +} + +#if !defined(DEFINE_OLD_NC_STATUS) +LOCAL UBYTE nc_get_nc_status(UBYTE status) +{ + UBYTE st; + + switch (status) + { + case INACTIVE:st=0;break; + case IDLE:st=1;break; + case READ_BCCH:st=2;break; + case FB_SB_SYNC:st=3;break; + case FB_SB_FAILED:st=4;break; + case READ_FB_SB:st=5;break; + case READ_SB:st=6;break; + case IDLE_SYNC:st=7;break; + case EXCLUDED:st=8;break; + case FB_SB_SYNC_RR_NOT_INFORMED:st=9;break; + case READ_SB_BCCH:st=10;break; + case READ_BCCH_PENDING:st=11;break; + case READ_FB_SB_PENDING:st=12;break; + case READ_SB_PENDING:st=13;break; + case READ_SB_BCCH_PENDING:st=14;break; + case READ_BCCH_RR_NOT_INFORMED:st=15;break; + case READ_BCCH_PENDING_RR_NOT_INFORMED:st=16;break; + default:st=17;break; + } + + return st; +} +#else /* DEFINE_OLD_NC_STATUS */ +#define nc_get_nc_status(st) (((int)(st) >= 18) ? 18 : (st)) +#endif /* DEFINE_OLD_NC_STATUS */ + +#if !defined(NTRACE) && defined(TRACING) +LOCAL const char * nc_get_nc_state_str(UBYTE status) +{ + return alr_nc_state_trc[nc_get_nc_status(status)]; +} +#endif /* !NTRACE && TRACING */ +#if 0 /* not needed currently */ +#if defined(TRACING) +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_get_status | ++--------------------------------------------------------------------+ + +PURPOSE : The function returns the status for a channel. + +*/ + +LOCAL UBYTE nc_get_status (USHORT index) +{ + /* use pointer to save time and ROM */ + T_NC* pcell = &alr_data->nc_data.cell[index]; + + TRACE_USER_CLASS_P3 (TC_USER1, "NC%u[%d] %s", + index, + pcell->ba_arfcn EQ NOT_PRESENT_16BIT ? -1 : pcell->ba_arfcn&ARFCN_MASK, + nc_get_nc_state_str(pcell->status)); + + return pcell->status; +} +#endif /* TRACING */ +#endif /* 0|1 */ +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_set_status | ++--------------------------------------------------------------------+ + +PURPOSE : The function sets a new status for a channel. Depending on + the new status several variables which are not valid in + the new status are initialised to their default values. + + +*/ + +GLOBAL void nc_set_status (USHORT index, UBYTE new_status) +{ + /* use pointer to save time and ROM */ + T_NC* pcell = &alr_data->nc_data.cell[index]; + +#if defined(TRACING) + TRACE_EVENT_P4 ("NC%u[%d] %s -> %s", + index, + pcell->ba_arfcn EQ NOT_PRESENT_16BIT ? -1 : pcell->ba_arfcn&ARFCN_MASK, + nc_get_nc_state_str(pcell->status), + nc_get_nc_state_str(new_status)); +#endif /* TRACING */ + + switch (new_status) + { + case INACTIVE: + pcell->bsic = NOT_PRESENT_8BIT; + pcell->frame_offset = NOT_PRESENT_32BIT; + pcell->time_align = NOT_PRESENT_32BIT; + pcell->last_rxlev = 0; + pcell->c_rxlev = NOT_PRESENT_8BIT; + pcell->rxlev_average = 0; + memset (pcell->rxlev, 0, 5); + pcell->one_of_six = FALSE; + pcell->one_of_twelve = FALSE; + pcell->c_attempt = 0; + pcell->c_bcch = C_INVALID_BCCH; + pcell->c_sync = C_INVALID_SYNC; + pcell->tim_valid = TV_INVALID_TIMING_INFO; + pcell->blocks_required = 0; + pcell->c_error = 0; + nc_clean_store_bcch (index); + break; + + case IDLE: + pcell->bsic = NOT_PRESENT_8BIT; +/* pcell->frame_offset = 0; + pcell->time_align = 0; + pcell->last_rxlev = 0; */ + pcell->one_of_six = FALSE; + pcell->one_of_twelve = FALSE; + /*pcell->c_attempt = 0;*/ + pcell->c_bcch = C_INVALID_BCCH; + pcell->c_sync = C_INVALID_SYNC; + pcell->blocks_required = 0; + pcell->c_error = 0; + nc_clean_store_bcch (index); + break; + + case READ_FB_SB: + case READ_FB_SB_PENDING: + pcell->bsic = NOT_PRESENT_8BIT; +/* pcell->frame_offset = 0; + pcell->time_align = 0; */ + pcell->last_rxlev = 0; + pcell->c_bcch = C_INVALID_BCCH; + pcell->c_sync = C_INVALID_SYNC; + pcell->blocks_required = 0; + pcell->c_error = 0; + nc_clean_store_bcch (index); + break; + + case READ_BCCH: + pcell->last_rxlev = 0; + /*pcell->c_attempt = 0;*/ + pcell->c_bcch = C_INVALID_BCCH; + pcell->c_sync = C_INVALID_SYNC; + pcell->c_error = 0; + pcell->blocks_required = 0; + nc_clean_store_bcch (index); + break; + case READ_BCCH_RR_NOT_INFORMED: + pcell->last_rxlev = 0; + pcell->c_bcch = C_INVALID_BCCH; + pcell->c_sync = C_INVALID_SYNC; + pcell->c_error = 0; + pcell->blocks_required = 0; + nc_clean_store_bcch (index); + break; + + case FB_SB_SYNC_RR_NOT_INFORMED: + pcell->last_rxlev = 0; + pcell->c_bcch = C_INVALID_BCCH; + pcell->c_sync = C_INVALID_SYNC; + pcell->blocks_required = 0; + pcell->c_attempt = 0; + pcell->c_error = 0; + break; + + case FB_SB_SYNC: + pcell->last_rxlev = 0; + pcell->blocks_required = 0; + if (!pcell->one_of_six) + pcell->c_attempt = 0; + pcell->c_error = 0; + pcell->c_sync = C_INVALID_SYNC; + nc_clean_store_bcch (index); + break; + + case READ_SB: + case READ_SB_PENDING: + pcell->last_rxlev = 0; + pcell->c_sync = C_INVALID_SYNC; + pcell->blocks_required = 0; + /*pcell->c_attempt = 0;*/ + pcell->c_error = 0; + nc_clean_store_bcch (index); + break; + + case READ_SB_BCCH: + case READ_SB_BCCH_PENDING: + pcell->last_rxlev = 0; + pcell->c_bcch = C_INVALID_BCCH; + pcell->c_sync = C_INVALID_SYNC; + pcell->blocks_required = 0; + pcell->c_error = 0; + /*pcell->c_attempt = 0;*/ + nc_clean_store_bcch (index); + break; + + + case IDLE_SYNC: + pcell->last_rxlev = 0; + pcell->c_bcch = C_INVALID_BCCH; + pcell->one_of_six = FALSE; + pcell->one_of_twelve = FALSE; + pcell->c_attempt = 0; + pcell->blocks_required = 0; + pcell->c_error = 0; + pcell->c_sync = alr_data->nc_data.c_nc_timer; /*TODO maybe move this to a function*/ + nc_clean_store_bcch (index); + break; + + case FB_SB_FAILED: + pcell->bsic = NOT_PRESENT_8BIT; + if (pcell->status EQ READ_FB_SB_PENDING) + { + pcell->frame_offset = NOT_PRESENT_32BIT; + pcell->time_align = NOT_PRESENT_32BIT; + pcell->tim_valid = TV_INVALID_TIMING_INFO; + } + else + pcell->tim_valid = TV_APPROX_TIMING_INFO; + pcell->last_rxlev = 0; + pcell->c_bcch = C_INVALID_BCCH; + pcell->blocks_required = 0; + pcell->c_error = 0; + nc_clean_store_bcch (index); + break; + + case EXCLUDED: + pcell->bsic = NOT_PRESENT_8BIT; + pcell->frame_offset = NOT_PRESENT_32BIT; + pcell->time_align = NOT_PRESENT_32BIT; + pcell->one_of_six = FALSE; + pcell->one_of_twelve = FALSE; + pcell->last_rxlev = pcell->rxlev_average; /* TODO maybe move this to a function */ + pcell->c_attempt = 0; + pcell->c_bcch = C_INVALID_BCCH; + pcell->c_sync = C_INVALID_SYNC; + pcell->tim_valid = TV_INVALID_TIMING_INFO; + pcell->blocks_required = 0; + pcell->c_error = 0; + nc_clean_store_bcch (index); + break; + + case READ_BCCH_PENDING: + case READ_BCCH_PENDING_RR_NOT_INFORMED: + pcell->last_rxlev = 0; + /*pcell->c_attempt = 0;*/ + pcell->c_bcch = C_INVALID_BCCH; + pcell->c_sync = C_INVALID_SYNC; + nc_clean_store_bcch (index); + break; + } + + /* + * set new status + */ + pcell->status = new_status; +} + +GLOBAL void nc_check_activity (void) +{ + int i; + switch(GET_STATE(STATE_NC)) + { + case NC_IDLE: + /* count number of reports */ + alr_data->nc_data.c_reports++; + + nc_rank_ncells (); + nc_check_status (CHECK_FOR_ACQUIRE_AND_BCCH_AND_FAIL); + nc_process_status(); + + if (first_period AND !first_l1_meas) + { + if (alr_data->nc_data.c_reports EQ alr_data->nc_data.max_reports OR + alr_data->nc_data.c_reports EQ alr_data->nc_data.max_reports - 1) + { + UBYTE all_sync = TRUE; + /* + * for every ncell + */ + for (i = 0; i < alr_data->nc_data.c_ba_arfcn; i++) + { + if (alr_data->nc_data.cell[i].status EQ READ_BCCH_PENDING OR + alr_data->nc_data.cell[i].status EQ READ_BCCH_PENDING_RR_NOT_INFORMED) + { + /* not all needed SI are read yet */ + all_sync = FALSE; + break; + } + } + if (!all_sync AND + alr_data->nc_data.c_reports EQ alr_data->nc_data.max_reports) + { + /* spend an additional reporting period to give FTA 20.7 a better chance to pass */ + alr_data->nc_data.c_reports--; + first_period = FALSE; + ALR_TRACE_NC ("one additional period"); + } + else if (all_sync AND + alr_data->nc_data.c_reports EQ alr_data->nc_data.max_reports - 1) + { + /* skip an additional reporting period to give FTA 20.19 a better chance to pass */ + alr_data->nc_data.c_reports++; + first_period = FALSE; + ALR_TRACE_NC ("one period skipped"); + } + } + } + first_l1_meas = FALSE; + +#if defined(_SIMULATION_) + TRACE_EVENT_P2 ("c_reports=%u/%u", + alr_data->nc_data.c_reports, alr_data->nc_data.max_reports); +#endif /* WIN32 */ + + /* check if 5sec have passed, we then have to inform RR */ + if (alr_data->nc_data.c_reports EQ alr_data->nc_data.max_reports) + { + USHORT index, average; + T_NC* pcell; + PALLOC (report, MPH_MEASUREMENT_IND); + memset (report, 0, sizeof (T_MPH_MEASUREMENT_IND)); + + first_period = FALSE; +#ifdef GPRS + report->gprs_sync = NORMAL_MEAS_REP; +#endif + + report->arfcn = alr_data->serving_cell; + + average = 0; + index = nc_get_index(alr_data->serving_cell); + if ( index NEQ NOT_PRESENT_16BIT ) + { + pcell = &alr_data->nc_data.cell[index]; + pcell->rxlev_average = 0; /* Is this really needed? */ + for (i = 0; i < 5; i++) + average += pcell->rxlev[i]; + } + + report->rx_lev_full = (UBYTE) (average / 5); + report->fn_offset = alr_data->nc_data.fn_offset; + + alr_data->nc_data.c_reports = 0; + + nc_build_rr_report (report); + ma_nc_report_res (report); + nc_release_bcch (); + } + break; + case NC_DEDICATED: + nc_rank_ncells (); + nc_check_status (CHECK_FOR_ACQUIRE_AND_BCCH_AND_FAIL); + nc_process_status(); + { + PALLOC(mph_measurement_ind, MPH_MEASUREMENT_IND); +#ifdef GPRS + mph_measurement_ind->gprs_sync = NORMAL_MEAS_REP; +#endif + nc_build_rr_report_dedi (mph_measurement_ind); + ma_nc_report_res (mph_measurement_ind); + } + break; + default: + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_set_fb_sb_sync_initial | ++--------------------------------------------------------------------+ + +PURPOSE : Inital setting of status FB_SB_SYNC. Counter for SB + confirmation and BCCH re-reading are initialized. + +*/ + +LOCAL void nc_set_fb_sb_sync_initial (USHORT index) +{ + alr_data->nc_data.cell[index].c_bcch = FIVE_MINUTES; + + if(!alr_data->nc_data.eotd_avail) + { + /*round to next confirmation boundary */ + if(alr_data->nc_data.c_nc_timer NEQ THIRTY_SECONDS) + alr_data->nc_data.cell[index].c_bcch += alr_data->nc_data.c_nc_timer; + } + + nc_set_status (index, FB_SB_SYNC); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_set_fb_sb_failed | ++--------------------------------------------------------------------+ + +PURPOSE : Set the status to FB_SB_FAILED, update the attempt counter + and set time until next attempt is started. + +*/ + +LOCAL void nc_set_fb_sb_failed (USHORT index, + UBYTE c_sync) +{ + alr_data->nc_data.cell[index].c_attempt++; + alr_data->nc_data.cell[index].c_sync = c_sync; + nc_set_status (index, FB_SB_FAILED); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_rxlev_sc_req | ++--------------------------------------------------------------------+ + +PURPOSE : A new RXLEV value of the serving cell has been measured. + Inform GPL in case it is necessary. + +*/ +#ifdef GPRS + +LOCAL void nc_rxlev_sc_req (UBYTE rxlev) +{ + if(GET_STATE (STATE_NC) EQ NC_IDLE) + { + PALLOC (rxlev_sc_req, TB_RXLEV_SC_REQ); + + rxlev_sc_req->sc_rxlev = rxlev; + + ma_nc_rxlev_sc_req (rxlev_sc_req); + } +} + +#endif /* #ifdef GPRS */ + +#if defined(_SIMULATION_) +LOCAL void trace_nc(void) +{ + char buf[80]; + int i, o; + T_NC* pcell; + o = sprintf (buf, "NC: "); + + for (i=0,pcell = &alr_data->nc_data.cell[0]; i < alr_data->nc_data.c_ba_arfcn; i++,pcell++) + { + if(pcell->ba_arfcn EQ alr_data->serving_cell) + { + o += sprintf (buf+o, "%u[SC=%u]%u, ", i, pcell->ba_arfcn, pcell->ba_status); + } + else + { + o += sprintf (buf+o, "%u[%u]%u, ", i, pcell->ba_arfcn, pcell->ba_status); + } + if (o > 60) + { + TRACE_EVENT (buf); + o = sprintf (buf, "NC: "); + } + } + if (o>4) + { + buf[o-2]=0; + TRACE_EVENT (buf); + } +} +#endif /* _SIMULATION_ */ + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_check_new_strong_cell | ++--------------------------------------------------------------------+ + + PURPOSE : Checks the New strong cell criteria + +*/ + +LOCAL void nc_check_new_strong_cell(USHORT index, UBYTE o_1of6, + UBYTE rxlev) +{ + T_NC* pcell = &alr_data->nc_data.cell[index]; + + if((pcell->one_of_six ) AND (!o_1of6)) + { + /* NCELL confirmation active. New 1of6 cell found */ + if((pcell->rxlev_average > rxlev) AND + ((pcell->rxlev_average - rxlev ) >= 5)) + pcell->new_strong_cell = TRUE; + } + else if ((pcell->one_of_six ) AND (o_1of6) AND + (pcell->status EQ READ_FB_SB) AND + (pcell->c_attempt EQ 0 )) + { + /* NCELL confirmation interrupted the sync of last 1of6 cell + * This has to be synchronized again + */ + pcell->new_strong_cell = TRUE; + } + + if(pcell->new_strong_cell) + { + alr_data->nc_data.new_strong_cell_detect = TRUE; + TRACE_EVENT_P1("[%d]New strong cell",pcell->ba_arfcn); + } + +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6103) MODULE : ALR_NC | +| STATE : code ROUTINE : nc_handle_new_strong_cells | ++--------------------------------------------------------------------+ + + PURPOSE : Processes cell synchronisation. + +*/ + +LOCAL void nc_handle_new_strong_cells(void) +{ + USHORT i; + USHORT index; + UBYTE first_sync_req = TRUE; + T_NC* pbsic = &alr_data->nc_data.cell[LAST_BSIC_REQ]; + + alr_data->nc_data.c_sync_intrupted = FALSE; + + while (alr_data->nc_data.c_sync_req < MAX_L1_SYNC_CNT) + { + /* + * It is possible to send more sync requests to layer 1 + */ + USHORT c_ba_arfcn = alr_data->nc_data.c_ba_arfcn; + index = NOT_PRESENT_16BIT; + + for (i = 0; i < c_ba_arfcn; i++) + { + /* + * search for "New strong cell" with the highest fieldstrength + */ + T_NC* pcell = &alr_data->nc_data.cell[i]; + + if ((pcell->ba_arfcn NEQ pbsic->ba_arfcn) AND + (pcell->ba_arfcn NEQ alr_data->serving_cell) AND + (pcell->new_strong_cell)) + { + switch (pcell->status) + { + case READ_FB_SB: + if (index EQ NOT_PRESENT_16BIT) + index = i; + else + { + if (pcell->rxlev_average > + alr_data->nc_data.cell[index].rxlev_average) + index = i; + } + break; + default: + break; + } + } + } + + if (index NEQ NOT_PRESENT_16BIT) + { + + if(first_sync_req EQ TRUE) + { + first_sync_req = FALSE; + + if(alr_data->nc_data.c_sync_req > 0) + { + + TRACE_EVENT("RE-SYNC interrupted"); + alr_data->nc_data.c_sync_intrupted = TRUE; + + nc_stop_all(); + + if(!alr_data->nc_data.c_sync_req) + { + alr_data->nc_data.tim_state = NC_CONF_PENDING; + SET_STATE(STATE_NC_PROC, NC_ACQUIRE); + } + } + } /* first_sync_req */ + + /* + * Request synchronisation for this cell + */ + nc_build_sync_req(index); + alr_data->nc_data.cell[index].new_strong_cell = FALSE; + TRACE_EVENT_P1("[%d]N_S_C sync req",alr_data->nc_data.cell[index].ba_arfcn); + } + else + break; /*while loop */ + } /* while( c_sync_req < MAX_L1_SYNC_CNT) */ +} +#endif