FreeCalypso > hg > fc-selenite
diff src/g23m-gsm/rr/rr_cs.c @ 1:d393cd9bb723
src/g23m-*: initial import from Magnetite
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sun, 15 Jul 2018 04:40:46 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/g23m-gsm/rr/rr_cs.c Sun Jul 15 04:40:46 2018 +0000 @@ -0,0 +1,2921 @@ +/* ++----------------------------------------------------------------------------- +| Project : +| Modul : ++----------------------------------------------------------------------------- +| Copyright 2002 Texas Instruments Berlin, AG +| All rights reserved. +| +| This file is confidential and a trade secret of Texas +| Instruments Berlin, AG +| The receipt of or possession of this file does not convey +| any rights to reproduce or disclose its contents or to +| manufacture, use, or sell anything it may describe, in +| whole, or in part, without the specific written consent of +| Texas Instruments Berlin, AG. ++----------------------------------------------------------------------------- +| Purpose : This module defines the functions for Cell Selection +| capability of Radio Resource. ++----------------------------------------------------------------------------- +*/ + +#ifndef RR_CS_C +#define RR_CS_C + +#define ENTITY_RR + +/*==== INCLUDES ===================================================*/ + +#include <string.h> +#include <stdlib.h> +#include <stddef.h> /* offsetof */ +#include "typedefs.h" +#include "pcm.h" +#include "pconst.cdg" +#include "mconst.cdg" +#include "message.h" +#include "ccdapi.h" +#include "vsi.h" +#include "custom.h" +#include "gsm.h" +#include "prim.h" +#include "cnf_rr.h" +#include "tok.h" +#include "rr.h" + +/*==== EXPORT =====================================================*/ + +/*==== PRIVATE ====================================================*/ +static void cs_remove_co_chan (USHORT arfcn, USHORT co_arfcn); +static void cs_remove_co_channels (USHORT arfcn); +static UBYTE cs_check_channel (USHORT arfcn); +static BOOL cs_sync_next_bsic (void); + + +/*==== VARIABLES ==================================================*/ + +EXTERN UBYTE test_house; + +/*==== FUNCTIONS ==================================================*/ + +LOCAL void cs_add_current_network_to_found_list (); +LOCAL BOOL cs_check_black_list_criteria(U8 region, U16 arfcn, U8 rxlev); +LOCAL BOOL cs_is_in_black_list(U8 region, U16 arfcn); +LOCAL BOOL cs_is_in_white_list(U8 region, U16 arfcn); +LOCAL U8 cs_get_sync_fail_counter(U8 region, U16 arfcn); +LOCAL void cs_reset_sync_fail_counter(U8 region, U16 arfcn); +LOCAL void cs_inc_sync_fail_counter(U8 region, U16 arfcn); +LOCAL void cs_use_white_list_info(U8 num_of_chan); +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT +LOCAL UBYTE cs_update_std_ffs (UBYTE new_std); +#else +LOCAL UBYTE get_band_index(USHORT arfcn); +#endif + + +/* + * ------------------------------------------------------------------- + * Procedures + * ------------------------------------------------------------------- + */ + +/* + * The cell selection process bases on attributes for each channel + * of the power campaign. This attributes are defined by a bitmap + * + * Bit 1 0 priority + * --------------------------------- + * 0 0 low priority + * 0 1 mid priority + * 1 0 high priority + * 1 1 reserved + * + * The selection of a cell for synchronisation depends on + * the priority and the fieldstrength. It will be the cell + * selected, which is not checked yet, has the highest + * priority and the highest fieldstrength. + * + * Bit 2 reserved + * + * Bit 3 checked flag + * --------------------------------- + * 0 cell is not checked + * 1 cell is checked + * + * The flag indicates whether a cell is already checked or not. + * + * Bit 4 detected flag + * --------------------------------- + * 0 bcch is not detected + * 1 bcch is checked + * + * The flag indicates whether a BCCH is detected or not. + * + * Bit 5 emergency cell flag + * --------------------------------- + * 0 emergency services possible + * 1 emergency services not possible + * + * The flag indicates whether emergency services are possible or not. + * + * Bit 6 low priority cell flag + * --------------------------------- + * 0 no low priority cell + * 1 low priority cell + * + * The flag indicates whether a cell has a low priority or not. + * + * Bit 8 BCCH info list flag + * --------------------------------- + * 0 not member of the BCCH info list + * 1 member of the BCCH info list + * + * The flag indicates whether a cell is member of the BCCH information list or not. + */ + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_init_process | ++--------------------------------------------------------------------+ + + PURPOSE : Initialisation of the cell selection process. + Called from 'pei_init' exclusively and rr_deactivate. + +*/ + +GLOBAL void cs_init_process (void) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cs_init_process()"); + + /* + * set the state and clear all variables. + */ + SET_STATE (STATE_CELL_SEL, CS_NULL); + memset (&rr_data->cs_data, 0, sizeof (&rr_data->cs_data)); + + rr_data->cs_data.arfcn_sc = NOT_PRESENT_16BIT; + rr_data->cs_data.arfcn_cr = NOT_PRESENT_16BIT; + + /* CSI-LLD section:4.1.1.11 */ + rr_data->cs_data.initial_plmn_search = INITIAL_PLMN_SEARCH_NOT_ACTIVE; + + /* In all simulation testcases written prior to cell selection + * improvements feature, US_BIT and STD values were not set in + * the ARFCN field + */ +#if !defined (_SIMULATION_) + rr_data->cs_data.region = NOT_PRESENT_8BIT; +#endif + + rr_data->cs_data.white_list.last_sc_arfcn = NOT_PRESENT_16BIT; + rr_data->cs_data.white_list.region = NOT_PRESENT_8BIT; + TRACE_EVENT_P1("white_list_region %d", rr_data->cs_data.white_list.region); + + rr_data->start_cell_reselection = TRUE; + TRACE_EVENT_P1("start_cell_reselection %d", rr_data->start_cell_reselection); + + /* Dynamic configuration parameters */ + rr_data->dyn_config.bl_cs_en = TRUE; + rr_data->dyn_config.tfast_cs_val = TFAST_CS_VALUE; + rr_data->dyn_config.tnormal_cs_val = TNORMAL_CS_VALUE; + rr_data->dyn_config.lim_ser_nps_delay= DELAY_NON_PAR_SEARCH_LIM_SER; + +#if defined(_SIMULATION_FFS_) + rr_csf_ffs_init(); +#endif +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_set_bcch_info | ++--------------------------------------------------------------------+ + + PURPOSE : The function merges bcch information from SIM to White list + database + CSI-LLD - 4.1.2.2.1 +*/ + +GLOBAL void cs_set_bcch_info (T_bcch_info * sim_bcch_info) +{ + GET_INSTANCE_DATA; + T_LIST tmp_list; + BUF_neigh_cell_desc cd; + + TRACE_FUNCTION ("cs_set_bcch_info()"); + + /* Check for availability of sim_bcch_info data */ + if(cs_check_region(rr_data->cs_data.white_list.region) AND + (sim_bcch_info NEQ NULL)) + { + if(sim_bcch_info->v_bcch) + { + /* Store the sim_bcch_info data to white_list structure */ + memcpy(cd.b_neigh_cell_desc,sim_bcch_info->bcch,BA_BITMAP_SIZE); + cd.o_neigh_cell_desc = 0; + cd.l_neigh_cell_desc = NCELL_DESC_BIT_LEN; + + /* Merge BCCH info into white list */ + for_create_channel_list((T_f_range *)&cd,&tmp_list); + srv_merge_list(&rr_data->cs_data.white_list.list,&tmp_list); + } + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_clear_white_list | ++--------------------------------------------------------------------+ + + PURPOSE : The function clears the bcch information (neigbour cell + description) of sys info 2, 2bis and 2ter stored in RAM + and FFS. + CSI-LLD - 4.1.2.2.6 +*/ + +GLOBAL void cs_clear_white_list(U8 clr_bcch_info) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cs_clear_white_list()"); + + if (clr_bcch_info & CLR_WHITE_LIST_SIM) + { + dat_send_bcchinfo_mm (NULL); + + TRACE_EVENT ("White List: SIM cleared"); + } + + if (clr_bcch_info & CLR_WHITE_LIST_RAM) + { + rr_data->cs_data.arfcn_sc = NOT_PRESENT_16BIT; + rr_data->cs_data.arfcn_cr = NOT_PRESENT_16BIT; + + memset(&rr_data->cs_data.white_list, 0 , sizeof(T_CS_WHITE_LIST)); + + rr_data->cs_data.white_list.last_sc_arfcn = NOT_PRESENT_16BIT; + rr_data->cs_data.white_list.region = NOT_PRESENT_8BIT; + + TRACE_EVENT ("White List: RAM cleared"); + } + +#if defined (_SIMULATION_FFS_) + if (clr_bcch_info & CLR_WHITE_LIST_FFS) + { + T_CS_WHITE_LIST white_list; + memset(&white_list,0,sizeof(T_CS_WHITE_LIST)); + + rr_data->cs_data.white_list.region = NOT_PRESENT_8BIT; + rr_data->cs_data.white_list.last_sc_arfcn = NOT_PRESENT_16BIT; + + rr_csf_write_white_list(&white_list); + + TRACE_EVENT ("White List: FFS cleared"); + } +#endif /* _SIMULATION_FFS_ */ +} + + +#if defined (_SIMULATION_FFS_) +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_store_white_list | ++--------------------------------------------------------------------+ + + PURPOSE : The function stores while list information to FFS. + CSI-LLD - 4.1.2.2.3 +*/ + +GLOBAL void cs_store_white_list (void) +{ + GET_INSTANCE_DATA; + /* Store the white List to FFS */ + rr_csf_write_white_list(&rr_data->cs_data.white_list); +} +#endif /*_SIMULATION_FFS_*/ + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_use_white_list_info | ++--------------------------------------------------------------------+ + + PURPOSE : The function uses the stored white list information and + increases the priority of these channels. + CSI-LLD - 4.1.2.2.8 +*/ + +LOCAL void cs_use_white_list_info(U8 num_of_chan) +{ + GET_INSTANCE_DATA; + U8 i, priority; + + TRACE_FUNCTION ("cs_use_white_list_info()"); + + /* Boot Time: If white list is invalidated by the second activate_req, + * decrease priority of white list carriers in power_cnf + */ + priority = (cs_check_region(rr_data->cs_data.white_list.region)) ? + CS_HIGH_PRIORITY : CS_LOW_PRIORITY ; + + for (i=0;i<num_of_chan;i++) + { + /* + * Power cnf always contains White list carriers at the top + */ + rr_data->cs_data.attributes [i] = priority; + + TRACE_EVENT_P3 ("Whie List: change prio of [%d]%u to 0x%02x", + rr_data->cs_data.arfcn[i]&ARFCN_MASK, + i, rr_data->cs_data.attributes [i]); + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_set_all | ++--------------------------------------------------------------------+ + + PURPOSE : The function clears all attributes and all stored BCCH + information. + +*/ + +GLOBAL void cs_set_all (void) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cs_set_all()"); + + /* + * clear all attributes + */ + memset (&rr_data->cs_data.attributes, 0, sizeof (rr_data->cs_data.attributes)); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_set_freq_band | ++--------------------------------------------------------------------+ + + PURPOSE : This function sets the frequency band bit mask. + +*/ + +GLOBAL UBYTE cs_get_freq_band (UBYTE pch_interrupt) +{ + UBYTE freq_bands; + + rr_csf_get_freq_bands (&freq_bands); + + if (!pch_interrupt) + {/* + * Power measurements without PCH interruption => PLMN search + * ---------------------------------------------------------- + * In this case we use the found and set value of 'std' for the frequency + * area to mask out not available frequencies from 'freq_bands'. + * Use only frequencies of the current area. + */ + switch (std) + { + case STD_900: + freq_bands &= BAND_GSM_900; + break; + case STD_EGSM: + freq_bands &= BAND_E_GSM; /* BAND_GSM_900|BAND_E_GSM */ + break; + case STD_1900: + freq_bands &= BAND_PCS_1900; + break; + case STD_1800: + freq_bands &= BAND_DCS_1800; + break; + case STD_DUAL: + freq_bands &= BAND_DUAL; /* BAND_GSM_900|BAND_DCS_1800 */ + break; + case STD_DUAL_EGSM: + freq_bands &= BAND_DUAL_EXT; /* BAND_GSM_900|BAND_E_GSM|BAND_DCS_1800 */ + break; + case STD_850: + freq_bands &= BAND_GSM_850; + break; + case STD_DUAL_US: + freq_bands &= BAND_DUAL_US; /* BAND_GSM_850|BAND_PCS_1900 */ + break; +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + case STD_850_1800: + freq_bands &= BAND_850_1800; /* BAND_GSM_850|BAND_DCS_1800 */ + break; + case STD_900_1900: + freq_bands &= BAND_900_1900; /* BAND_E_GSM|BAND_PCS_1900 */ + break; + case STD_850_900_1800: + freq_bands &= BAND_850_900_1800; /* BAND_E_GSM|BAND_GSM_850|BAND_DCS_1800 */ + break; + case STD_850_900_1900: + freq_bands &= BAND_850_900_1900; /* BAND_GSM_850|BAND_E_GSM|BAND_PCS_1900 */ + break; +#endif + } + } + return freq_bands; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : get_band_index | ++--------------------------------------------------------------------+ + + PURPOSE : The function extracts the frequency band index from the given + 'arfcn' parameter. +*/ + +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT +GLOBAL UBYTE cs_get_band_index (USHORT arfcn) +#else +GLOBAL UBYTE get_band_index (USHORT arfcn) +#endif +{ + UBYTE local_std = STD_GET_FROM_ARFCN(arfcn); + UBYTE sc_band; + + if(local_std EQ STD_NOT_PRESENT) + { + /* Parallel search case */ +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + local_std = std; +#else + local_std = std_bands[std-1]; +#endif + } + + switch (local_std) + { + case STD_900: + sc_band = B_GSM_900; + break; + + case STD_EGSM: + sc_band = B_E_GSM; + break; + + case STD_1800: + sc_band = B_DCS_1800; + break; + + case STD_1900: + sc_band = B_PCS_1900; + break; + + case STD_850: + sc_band = B_GSM_850; + break; + + case STD_DUAL: + if (arfcn >= LOW_CHANNEL_1800) + sc_band = B_DCS_1800; + else + sc_band = B_GSM_900; + break; + + case STD_DUAL_EGSM: + if (arfcn >= LOW_CHANNEL_EGSM) + sc_band = B_E_GSM; + else if (arfcn >= LOW_CHANNEL_1800) + sc_band = B_DCS_1800; + else if (arfcn EQ CHANNEL_0) + sc_band = B_E_GSM; + else + sc_band = B_GSM_900; + break; + + case STD_DUAL_US: + if (arfcn >= LOW_CHANNEL_1900) + sc_band = B_PCS_1900; + else + sc_band = B_GSM_850; + break; + +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + case STD_850_1800: + if (arfcn >= LOW_CHANNEL_1800) + sc_band = B_DCS_1800; + else + sc_band = B_GSM_850; + break; + + case STD_900_1900: + if (arfcn >= LOW_CHANNEL_EGSM) + sc_band = B_E_GSM; + else if (arfcn >= LOW_CHANNEL_1900) + sc_band = B_PCS_1900; + else if (arfcn EQ CHANNEL_0) + sc_band = B_E_GSM; + else + sc_band = B_GSM_900; + break; + + case STD_850_900_1800: + if (arfcn >= LOW_CHANNEL_EGSM) + sc_band = B_E_GSM; + else if (arfcn >= LOW_CHANNEL_1800) + sc_band = B_DCS_1800; + else if (arfcn EQ CHANNEL_0) + sc_band = B_E_GSM; + else if (arfcn >= LOW_CHANNEL_850) + sc_band = B_GSM_850; + else + sc_band = B_GSM_900; + break; + + case STD_850_900_1900: + if (arfcn >= LOW_CHANNEL_EGSM) + sc_band = B_E_GSM; + else if (arfcn >= LOW_CHANNEL_1900) + sc_band = B_PCS_1900; + else if (arfcn EQ CHANNEL_0) + sc_band = B_E_GSM; + else if (arfcn >= LOW_CHANNEL_850) + sc_band = B_GSM_850; + else + sc_band = B_GSM_900; + break; +#endif + + default: + sc_band = MAX_NUM_BANDS; + break; + } + /* this trace causes a lot of trace load; switch on only if needed + TRACE_EVENT_P3 (" [%u] std=%02x, sc_band=%02x", arfcn&ARFCN_MASK, local_std, sc_band); + */ + return sc_band; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_start_scan | ++--------------------------------------------------------------------+ + + PURPOSE : This function starts the scanning. The power measurements + are triggered. Power measurements means that layer 1 + performs fieldstrength measurements on all carriers and + sends a list of the best to RR back for FB/SB scanning and + BCCH reading. There are two variants: with or without + paging channel (PCH) interruption. If RR is already in + idle mode, scanning without PCH interruption is performed, + that means the MS is pageable during that time. + +*/ + +GLOBAL void cs_start_scan () +{ + GET_INSTANCE_DATA; + U16 arfcn; + U8 i=0; + U8 region; + PALLOC (mph_power_req, MPH_POWER_REQ);/* T_MPH_POWER_REQ */ + + TRACE_FUNCTION ("cs_start_scan()"); + + memset(mph_power_req,0,sizeof(T_MPH_POWER_REQ )); + + TIMERSTOP (TREG); + rr_data->cs_data.act_index = NOT_PRESENT_8BIT; + + switch (GET_STATE (STATE_CELL_SEL)) + { + case CS_NULL: + case CS_NULL_ACTIVE: + /* + * start power measurements with PCH interruption + */ + mph_power_req->pch_interrupt = PCH_INTERRUPT; + rr_data->first_meas_received = FALSE; + rr_data->resel_pending = FALSE; + rr_data->c_ncell_bcch = NOT_INITIALISED; + rr_data->cs_data.all_freq_area = FALSE; + /* In all simulation testcases written prior to cell selection + * improvements feature, US_BIT and STD values were not set in + * the ARFCN field + */ +#if !defined (_SIMULATION_) + rr_data->cs_data.region = NOT_PRESENT_8BIT; +#endif + + dat_att_null (); + SET_STATE (STATE_CELL_SEL, CS_NULL_ACTIVE); + + /* stop possibly parallel search and allow start of cell reselection */ + att_notify_stop_plmn_search (FALSE); + break; + + case CS_IDLE: + case CS_IDLE_ACTIVE: + /* + * start power measurements without PCH interruption. + */ + mph_power_req->pch_interrupt = NO_PCH_INTERRUPT; + SET_STATE (STATE_CELL_SEL, CS_IDLE_ACTIVE); + + /* indicate suspend state of nc monitoring in lower layer */ + rr_data->start_cell_reselection = FALSE; + TRACE_EVENT_P1("start_cell_reselection %d", rr_data->start_cell_reselection); + break; + + default: + break; + } + +#ifndef TI_PS_FF_QUAD_BAND_SUPPORT + mph_power_req->freq_bands = cs_get_freq_band (mph_power_req->pch_interrupt); +#endif + + /* CSI-LLD : 4.1.3.4.1.4 */ + /* Set the new search mode */ + mph_power_req->search_mode = CS_GET_CURRENT_SEARCH_MODE; + + /* Set Lower Rxlev threshold */ + memcpy( mph_power_req->lower_rxlevel_threshold, rr_data->dyn_config.lower_rxlev_thr, MAX_NUM_BANDS*sizeof(UBYTE)); + + /* Copy the black list information */ + for(i=0;i<MAX_REGIONS;i++) + { + srv_copy_list ((T_LIST *)&mph_power_req->black_list.list[i], + &rr_data->cs_data.black_list.list[i],sizeof(T_LIST)); + } + + /* In case of Black List search, include "grey" carriers also + * in the Black list while sending to ALR + */ + if(CS_GET_CURRENT_SEARCH_MODE EQ BLACK_LIST_SEARCH_MODE) + { + TRACE_EVENT(" Black_List_Search_Started"); + +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + mph_power_req->freq_bands = cs_get_freq_band (FALSE); +#endif + + region = rr_data->cs_data.region; + +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + if (region EQ BOTH_REGIONS) + { + for (i=0; i<MAX_REGIONS; i++) + { + for(arfcn=CHANNEL_0;arfcn<CHANNEL_0_INTERNAL;arfcn++) + { + /* Since Black List search is always a parallel search, "grey" carriers + * belonging to the current region only have to be added + */ + if(cs_get_sync_fail_counter(i,arfcn)) + srv_set_channel((T_LIST*)&mph_power_req->black_list.list[i],arfcn); + } + } + } + else + { +#endif + for(arfcn=CHANNEL_0;arfcn<CHANNEL_0_INTERNAL;arfcn++) + { + /* Since Black List search is always a parallel search, "grey" carriers + * belonging to the current region only have to be added + */ + if(cs_get_sync_fail_counter(region,arfcn)) + srv_set_channel((T_LIST*)&mph_power_req->black_list.list[region],arfcn); + } +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + } +#endif + } + else + { +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + mph_power_req->freq_bands = cs_get_freq_band (TRUE); +#endif + + TRACE_EVENT_P9 ( "White List:[%d]Reg,[%d]Arfcn, MCC/MNC r=%x%x%x/%x%x%x/%d", + rr_data->cs_data.white_list.region, + rr_data->cs_data.white_list.last_sc_arfcn, + rr_data->cs_data.white_list.last_sc_lac.mcc[0], + rr_data->cs_data.white_list.last_sc_lac.mcc[1], + rr_data->cs_data.white_list.last_sc_lac.mcc[2], + rr_data->cs_data.white_list.last_sc_lac.mnc[0], + rr_data->cs_data.white_list.last_sc_lac.mnc[1], + rr_data->cs_data.white_list.last_sc_lac.mnc[2], + rr_data->cs_data.white_list.last_sc_lac.lac); + + /* Copy white list information + * White list cannot be used, when the region it belongs to, is not known + * or its PLMN ID does not match with the requested PLMN + */ + if((!cs_check_region(rr_data->cs_data.white_list.region)) OR + ((rr_data->ms_data.req_mm_service NEQ FUNC_PLMN_SRCH) AND + (GET_STATE(STATE_ATT) NEQ ATT_CS_INIT)) OR + ((rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH) AND + (!dat_plmn_equal_req(rr_data->cs_data.white_list.last_sc_lac.mcc, + rr_data->cs_data.white_list.last_sc_lac.mnc, + rr_data->ms_data.plmn.mcc, + rr_data->ms_data.plmn.mnc)))) + { + TRACE_EVENT("White List is not used"); + } + else + { + /* Copy the white list information */ + srv_copy_list((T_LIST*)&mph_power_req->white_list.list, + &rr_data->cs_data.white_list.list,sizeof (T_LIST)); + + /* Set the region */ + mph_power_req->white_list.region = rr_data->cs_data.white_list.region; + + /* White list is valid */ + mph_power_req->white_list.white_list_valid = TRUE; + + } + } + + /* Handle the search mode timers based on the new search mode */ + cs_handle_search_mode_timer(CS_GET_CURRENT_SEARCH_MODE); + + /* + * reset the time for net search to finish + * a PLMN available search during 35 seconds. + */ + if( rr_data->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI) + TIMERSTART(T_PLMN_SEARCH, T_PLMN_SEARCH_VALUE); + + /* + * start power measurements in layer 1. + */ + TRACE_EVENT_P2 ("cs_start_scan(): freq_bands=%02x Search Mode = %d", + mph_power_req->freq_bands,mph_power_req->search_mode); + + PSENDX (PL, mph_power_req); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_start_sync | ++--------------------------------------------------------------------+ + + PURPOSE : Start the synchronisation to FB/SB without power measurements. + Synchronisation to the frequency correction burst (FB) followed + by a synchronisation to the synchron burst (SB) is carried + out by layer 1. It means that the MS is synchronised to the + base station and then able to read the BCCH to check the cell. + +*/ + +GLOBAL void cs_start_sync (void) +{ + GET_INSTANCE_DATA; + UBYTE i; + + TRACE_FUNCTION ("cs_start_sync()"); + + /* While scanning for limited service, we scan all carriers */ + if((CS_GET_PREVIOUS_SEARCH_MODE NEQ FAST_SEARCH_MODE) AND + (rr_data->cs_data.scan_mode EQ CS_SECOND_SCAN)) + { + for (i=0;i<rr_data->cs_data.max_arfcn;i++) + /* + * reset check bit for all channels + */ + rr_data->cs_data.attributes[i] &= CS_NON_CHECKED_BITS; + } + + if (cs_sync_next_bsic () EQ FALSE) + { + /* + * indicate the end of scanning to attachment process + */ + TIMERSTOP(T_PLMN_SEARCH); + att_no_bsic_ind (); + } + else + { + /* + * Another FB/SB scan is requested + */ + SET_STATE (STATE_CELL_SEL, CS_IDLE_ACTIVE); + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_del_list | ++--------------------------------------------------------------------+ + + PURPOSE : A list of carriers (neighbourcell list) is used to speed up + the cell selection process. All members of the list and the + list of the power campaign are set to low priority. + +*/ + +GLOBAL void cs_del_list (T_LIST *list) +{ + GET_INSTANCE_DATA; + UBYTE i; + + TRACE_FUNCTION ("cs_del_list()"); + + /* + * for all cells of the power campaign list + */ + + for (i=0;i<rr_data->cs_data.max_arfcn;i++) + { + /* + * if they are member of the given list and not just checked + */ + if (srv_get_channel (list, (USHORT)(rr_data->cs_data.arfcn[i]&ARFCN_MASK)) AND + rr_data->cs_data.act_index NEQ i) + { + /* + * set to low priority + */ + rr_data->cs_data.attributes [i] &= CS_SET_TO_LOW_PRIORITY; + /*TRACE_EVENT_P1("[%u] del from list",rr_data->cs_data.arfcn[i]);*/ + } + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_set_list | ++--------------------------------------------------------------------+ + + PURPOSE : A list of carriers (neighbourcell list) is used to speed up + the cell selection process. All members of the list and the + list of the power campaign are set to high priority. + + +*/ + +GLOBAL void cs_set_list (T_LIST *list) +{ + GET_INSTANCE_DATA; + UBYTE i; + + TRACE_FUNCTION ("cs_set_list()"); + + /* + * Not in the test house + */ + if (rr_data->cell_test_operation OR + dat_test_sim_available ()) + return; + + /* + * for all channels in the power campaign list + */ + for (i=0;i<rr_data->cs_data.max_arfcn;i++) + { + /* + * if they are also member of the given list + */ + if (srv_get_channel (list, (USHORT)(rr_data->cs_data.arfcn[i]&ARFCN_MASK))) + { + /* + * set to high priority + */ + rr_data->cs_data.attributes [i] &= CS_SET_TO_LOW_PRIORITY; + rr_data->cs_data.attributes [i] += CS_HIGH_PRIORITY; + } + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_def_list | ++--------------------------------------------------------------------+ + + PURPOSE : Checks whether a member of the list has the requested + attributes (e.g. emergency or low priority cell) + +*/ + +GLOBAL UBYTE cs_def_list (UBYTE attribute) +{ + GET_INSTANCE_DATA; + UBYTE i; + UBYTE result = FALSE; + + TRACE_FUNCTION ("cs_def_list()"); + + /* + * for all channels of the power campaign list + */ + for (i=0;i<rr_data->cs_data.max_arfcn;i++) + { + + /* + * check only cells which have high/mid priority + */ + if ((rr_data->cs_data.attributes [i] & CS_CHECK_FLAG) EQ 0 AND + (rr_data->cs_data.attributes [i] & CS_PRIORITY) NEQ 0) + /* + * channel is not checked yet, so it is possible that + * the channel has this attribute + */ + { + rr_data->cs_data.attributes [i] = CS_MID_PRIORITY; + result = TRUE; + } + + /* + * check the attribute of the cell. If an attribute + * like emergency or low priority cell is set, the channel + * has been checked. + */ + if (rr_data->cs_data.attributes[i] & attribute) + { + /* + * channel has this attribute, then set priority to high + */ + rr_data->cs_data.attributes [i] &= CS_SET_TO_LOW_PRIORITY; + rr_data->cs_data.attributes [i] += CS_HIGH_PRIORITY; + + /* reset check bit for this channel */ + rr_data->cs_data.attributes[i] &= CS_NON_CHECKED_BITS; + result = TRUE; + } + } + + return result; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_sync_next | ++--------------------------------------------------------------------+ + + PURPOSE : The function starts the next FB/SB synchronisation request. + It selects the channel with the highest priority and field- + strength which is not checked yet. + +*/ + +GLOBAL BOOL cs_sync_next (void) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cs_sync_next()"); + + /* + * no further channel is possible + */ + if (cs_sync_next_bsic () EQ FALSE) + { + /* + * stop any timer which controls cell selection + */ + TIMERSTOP (T_RESELECT); + SET_STATE (STATE_CELL_SEL, CS_IDLE); + + /* + * indicate end of search to attachment process + */ + TIMERSTOP(T_PLMN_SEARCH); + att_no_bsic_ind (); + + return FALSE; + } + + return TRUE; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_sync_next_bsic | ++--------------------------------------------------------------------+ + + PURPOSE : The function looks for the next candidate for a FB/SB + sync request. The channel is not checked yet, has the + highest priority and the highest fieldstrength. + Return TRUE if another MPH_BSIC_REQ is sent. +*/ + +static BOOL cs_sync_next_bsic (void) +{ + GET_INSTANCE_DATA; + UBYTE i; + UBYTE x = NOT_PRESENT_8BIT; + + TRACE_FUNCTION ("cs_sync_next_bsic()"); + + /* + * try to use 'found channel' from previous cell selection + */ + + if( rr_data->found_channel NEQ NOT_PRESENT_16BIT ) + { + for ( i = 0; i < rr_data->cs_data.max_arfcn; i++ ) + { + if ( ((rr_data->cs_data.arfcn[i] & ARFCN_MASK) EQ + (rr_data->found_channel & ARFCN_MASK)) AND + ((rr_data->cs_data.arfcn[i] & US_BIT) EQ + (rr_data->found_channel & US_BIT)) AND + (rr_data->cs_data.attributes[i] & CS_CHECK_FLAG) EQ 0) + { + TRACE_EVENT ( "rr_found_channel in CS_DATA" ); + rr_data->found_channel = NOT_PRESENT_16BIT; + x = i; + break; + } + } + } + + /* + * for all channels of the power campaign list + */ + if ( x EQ NOT_PRESENT_8BIT ) + { + for ( i=0; i < rr_data->cs_data.max_arfcn; i++ ) + { + if ((rr_data->cs_data.attributes[i] & CS_CHECK_FLAG) EQ 0) + { + /* + * channel is not checked yet + */ + if (x EQ NOT_PRESENT_8BIT) + { + /* + * first channel which is not checked yet + */ + x = i; + + /* High priority cell. Start sync */ + if((rr_data->cs_data.attributes[i] & CS_PRIORITY) EQ CS_HIGH_PRIORITY) + break; + } + else + { + if ((rr_data->cs_data.attributes[i] & CS_PRIORITY) > + (rr_data->cs_data.attributes[x] & CS_PRIORITY)) + { + /* + * new channel has higher priority + */ + x = i; + } + } + } /* CS_CHECK FLAG */ + } /* i < max_arfcn */ + } /* x NEQ NOT_PRESENT_8BIT */ + + if (x NEQ NOT_PRESENT_8BIT) + { + rr_data->cs_data.act_index = x; + + if ((rr_data->ms_data.rr_service NEQ NO_SERVICE) AND + (rr_data->cs_data.arfcn[x] EQ rr_data->nc_data[SC_INDEX].arfcn)) + { + /* + * Synchronization request for serving cell. + * No need to send MPH_BSIC_REQ as we are already synchronized to + * serving cell, instead fake MPH_BSIC_CNF. + */ + PALLOC (mph_bsic_cnf, MPH_BSIC_CNF); /* T_MPH_BSIC_CNF */ + mph_bsic_cnf->arfcn = rr_data->cs_data.arfcn[x]; + mph_bsic_cnf->bsic = rr_data->nc_data[SC_INDEX].bsic; + mph_bsic_cnf->cs = CS_NO_ERROR; + if (srv_store_prim ((T_PRIM *)D2P(mph_bsic_cnf))) + { + TRACE_EVENT ("Shortcut for sync to SC taken"); + USE_STORED_ENTRIES(); + return TRUE; + } + else + { + /* In the unlikely event that we could not store the primitive */ + PFREE (mph_bsic_cnf); + } + } + else + { + + /* + *start BSIC Reading;For fast search, the first scan is only on reasonably strong carriers.i.e carrires with rxlev>MEDIUM_RXLEV_THRESHOLD + *This is as per the cell selection improvements document. Hence dont send BSIC request on white listed low power carrires for first scan. + *(OMAPS00109145)*/ + if( (rr_data->cs_data.previous_search_mode EQ FAST_SEARCH_MODE) AND (rr_data->cs_data.scan_mode NEQ CS_SECOND_SCAN) AND ( rr_data->cs_data.rxlev[x]<MEDIUM_RXLEV_THRESHOLD)) + return FALSE; + else + { + PALLOC (mph_bsic_req, MPH_BSIC_REQ); + + mph_bsic_req->arfcn = rr_data->cs_data.arfcn[x]; + + TRACE_EVENT_P3 ("BSIC REQ[%u]%u a=0x%x", + rr_data->cs_data.arfcn[x] & ARFCN_MASK, + x, rr_data->cs_data.attributes[x]); + + PSENDX (PL, mph_bsic_req); + } + return TRUE; + } + } + else + return FALSE; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_set_null | ++--------------------------------------------------------------------+ + + PURPOSE : Initialize the cell selection process. + +*/ + +GLOBAL void cs_set_null (void) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cs_set_null()"); + + SET_STATE (STATE_CELL_SEL, CS_NULL); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_set_stop_active | ++--------------------------------------------------------------------+ + + PURPOSE : The function resets the state of the cell selection + process to an non-active state. + +*/ + +GLOBAL void cs_set_stop_active (void) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cs_set_stop_active()"); + + switch (GET_STATE(STATE_CELL_SEL)) + { + case CS_NULL: + case CS_NULL_ACTIVE: + SET_STATE (STATE_CELL_SEL, CS_NULL); + break; + case CS_IDLE: + case CS_IDLE_ACTIVE: + SET_STATE (STATE_CELL_SEL, CS_IDLE); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_set_attributes | ++--------------------------------------------------------------------+ + + PURPOSE : The function sets an attribute for a channel (e.g. + emergency or low priority cell). + +*/ + +GLOBAL void cs_set_attributes (UBYTE attribute, USHORT arfcn) +{ + GET_INSTANCE_DATA; + UBYTE i; + + TRACE_FUNCTION ("cs_set_attributes()"); + + /* + * for all channels of the power campaign list + */ + for (i=0;i<rr_data->cs_data.max_arfcn;i++) + { + /* + * if it is the given channel number, set the attributes. + */ + if ((rr_data->cs_data.arfcn[i]&ARFCN_MASK) EQ arfcn) + rr_data->cs_data.attributes [i] |= attribute; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_set_rxlev | ++--------------------------------------------------------------------+ + + PURPOSE : Updating of a fieldstrength value in the list of the + power campaign. + +*/ + +GLOBAL void cs_set_rxlev (UBYTE rxlev, USHORT arfcn) +{ + GET_INSTANCE_DATA; + UBYTE i; + + TRACE_FUNCTION ("cs_set_rxlev()"); + + /* + * for all channels in the power campaign list + */ + for (i=0;i<rr_data->cs_data.max_arfcn;i++) + { + /* + * if it is the given channel number, update the fieldstrength. + */ + if ((rr_data->cs_data.arfcn[i]&ARFCN_MASK) EQ arfcn) + rr_data->cs_data.rxlev [i] = rxlev; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_clear_attributes | ++--------------------------------------------------------------------+ + + PURPOSE : The function clears an attribute for a channel (e.g. + emergency or low priority cell). + +*/ + +GLOBAL void cs_clear_attributes (UBYTE attribute, USHORT arfcn) +{ + GET_INSTANCE_DATA; + UBYTE i; + + TRACE_FUNCTION ("cs_clear_attributes()"); + + /* + * for all channels in the power campaign list + */ + for (i=0;i<rr_data->cs_data.max_arfcn;i++) + { + /* + * if it is the given channel number, clear the attributes. + */ + if ((rr_data->cs_data.arfcn[i]&ARFCN_MASK) EQ arfcn) + rr_data->cs_data.attributes [i] &= ~attribute; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_mph_power_cnf | ++--------------------------------------------------------------------+ + + PURPOSE : The result of a power request to layer 1. Layer 1 returns + a list of up to 40 GSM 900 + 40 DCS 1800 channels to RR. + +*/ + +GLOBAL void cs_mph_power_cnf (T_MPH_POWER_CNF * mph_power_cnf) +{ + GET_INSTANCE_DATA; + UBYTE i,j,rxlev; + USHORT mask = 0xFFFF; /* no mask */ + U8 x; + BOOL copy = TRUE; + + TRACE_FUNCTION ("cs_mph_power_cnf()"); + + if(GET_STATE(STATE_ATT) EQ ATT_CS_INIT ) + { + if( !srv_store_prim ((T_PRIM *)D2P(mph_power_cnf)) ) + { + /* + * primitive storing failed + */ + PFREE (mph_power_cnf); + SET_STATE(STATE_CELL_SEL, CS_NULL); + SET_STATE(STATE_ATT, ATT_NULL); + } + else + { + /* + * Boot Time: Do not store primitive for more than 10 s in case + * of quick registration. If the second activate_req does not + * come before this time move to ATT_NULL. + * The T_RESELECT timer is used for a different purpose here. + */ + TIMERSTART(T_RESELECT, TRESELECT_VALUE); + } + return; + } + + TRACE_EVENT_P1 ("mph_power_cnf: %u freq.", mph_power_cnf->num_of_chan); + + for (i = 0; i < mph_power_cnf->num_of_chan; i++) + { + TRACE_EVENT_P3("[%4u] std=%u rx_lev=%2u", + mph_power_cnf->arfcn[i]&ARFCN_MASK, + STD_GET_FROM_ARFCN(mph_power_cnf->arfcn[i]), + mph_power_cnf->rx_lev[i]); + } + + /* Remove the inactive carriers from Black List */ + if((CS_GET_CURRENT_SEARCH_MODE EQ BLACK_LIST_SEARCH_MODE) OR + (mph_power_cnf->num_of_chan)) + { + /* In case of "Full", "Normal" and "Fast" search modes, remove + * inactive carriers from Black List, only when there is atleast + * one strong carrier in that area + */ + cs_rem_inactive_carriers_from_bl(mph_power_cnf); + } + + if(CS_GET_CURRENT_SEARCH_MODE NEQ BLACK_LIST_SEARCH_MODE) + { + /* Update previous search mode */ + CS_SET_PREVIOUS_SEARCH_MODE(CS_GET_CURRENT_SEARCH_MODE); + + switch (GET_STATE(STATE_CELL_SEL)) + { + case CS_IDLE_ACTIVE: + /* We will start parallel scan in 2 cases + 1. After HPLMN timer expiry + 2. After TREG timer expiry + In these both cases don't mask out std and US_BIT + */ +#ifndef TI_PS_FF_QUAD_BAND_SUPPORT + mask = ARFCN_MASK; /* for parallel search mask out 'std' and US_BIT. */ +#endif + /*lint -fallthrough*/ + case CS_NULL_ACTIVE: + /* + * copy channel list from layer 1, set the number + * of entries in the list + */ + rr_data->cs_data.max_arfcn = mph_power_cnf->num_of_chan; + + /* + * for all channels coming from layer 1 + */ + for (i=0,j=0;i<mph_power_cnf->num_of_chan;i++) + { +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + x = cs_get_band_index(mph_power_cnf->arfcn[i]); +#else + x = get_band_index(mph_power_cnf->arfcn[i]); +#endif + + /* for OMAPS00109145, in which the I-Sample is not camping on to the agilent ,once down link failure is + occured on current cell and at power levels < -100dB, this is because in the fast search mode we are not + considering the low rxlev carriers. So this modification is required in order to come back to the network + even after a down link failure has happened and if another BCCH carrer of less power become active and available + for the mobile to camp */ + + rxlev = rr_data->dyn_config.lower_rxlev_thr[x]; + copy = TRUE; + + if((i >= mph_power_cnf->num_of_white_list_chan) AND + (mph_power_cnf->rx_lev[i] < rxlev)) + + { + copy = FALSE; + } + + /* + * check against band restrictions + */ + if (copy AND cs_check_channel ((USHORT)(mph_power_cnf->arfcn[i]&ARFCN_MASK))) + { +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + /* For parallel search mask serving cell */ + if ((GET_STATE(STATE_CELL_SEL) EQ CS_IDLE_ACTIVE) AND (rr_data->nc_data[SC_INDEX].arfcn EQ (mph_power_cnf->arfcn[i]&ARFCN_MASK))) + rr_data->cs_data.arfcn[j] = mph_power_cnf->arfcn[i]&ARFCN_MASK; + else +#endif + rr_data->cs_data.arfcn[j] = mph_power_cnf->arfcn[i]&mask; + rr_data->cs_data.rxlev[j] = mph_power_cnf->rx_lev[i]; + /* + * set initial to middle priority + */ + rr_data->cs_data.attributes [j++] = CS_MID_PRIORITY; + } + else + { + /* + * a cell is not copied due to band restrictions + */ + rr_data->cs_data.max_arfcn--; + } + } + + TRACE_EVENT_P2("No_chan > [%d]min_rxlev copied:%d",rxlev,rr_data->cs_data.max_arfcn); + + /* Increase the priority of white list carriers */ + if(rr_data->cs_data.max_arfcn ) + cs_use_white_list_info(mph_power_cnf->num_of_white_list_chan); + + /* + * add actual PLMN to the found list, if available + */ + if (rr_data->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI AND + GET_STATE(STATE_ATT) EQ ATT_IDLE AND + (!rr_data->net_lost)) + cs_add_current_network_to_found_list (); + + /* + * Select channel with the highest fieldstrength and priority + * and start BSIC scanning, else send signal that no further + * channel is available + */ + if (cs_sync_next_bsic () EQ FALSE) + { + SET_STATE (STATE_CELL_SEL, CS_IDLE); + TIMERSTOP(T_PLMN_SEARCH); + att_no_bsic_ind (); + } + else + { + SET_STATE (STATE_CELL_SEL, CS_IDLE_ACTIVE); + } + + /* + * CS power measurements may be used to reorder arfcns'n in + * MPH_NEIGHBOURCELL_REQ while TCSVALID is running + */ + TIMERSTART(TCSVALID, THIRTY_SEC); + break; + } + } /* NEQ black list search */ + else + { + + /* Stop the parallel PLMN search */ + att_notify_stop_plmn_search(FALSE); + + SET_STATE (STATE_CELL_SEL, CS_IDLE); + + /* Black list search is a temporary search. It is not used + * in deciding the next search. Hence we need to update current search + * mode when Black List search is over */ + CS_SET_CURRENT_SEARCH_MODE(CS_GET_PREVIOUS_SEARCH_MODE); + + + } /* Black list search */ + + PFREE (mph_power_cnf); + srv_use_stored_prim (); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_mph_bsic_cnf | ++--------------------------------------------------------------------+ + + PURPOSE : The response of a FB/SB synchronisation request from layer 1. + +*/ + +GLOBAL void cs_mph_bsic_cnf (T_MPH_BSIC_CNF * mph_bsic_cnf) +{ + GET_INSTANCE_DATA; + U8 local_region; + U16 local_arfcn; + + TRACE_FUNCTION ("cs_mph_bsic_cnf()"); + + switch (GET_STATE (STATE_CELL_SEL)) + { + case CS_IDLE_ACTIVE: + if (mph_bsic_cnf->cs EQ CS_NO_ERROR) + { + UBYTE new_std = STD_GET_FROM_ARFCN(mph_bsic_cnf->arfcn); + /* + * FB / SB is decoded, cell has the attributes + * BCCH detected and checked + */ + /* + * reset std from the current MPH_BSIC_CNF(only if it is non-zero) + */ + TRACE_EVENT_P2("reset std: new_std = %d, old_std = %d", new_std, std); + if(new_std) + { +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + UBYTE new_region; + + std = cs_update_std_ffs (new_std); + new_region = srv_get_region_from_std(std); + TRACE_EVENT_P1("update std: new_std = %d", std); +#else + UBYTE new_region = srv_get_region_from_std(new_std); + + std = new_std; +#endif + + /* Both American and European bands are detected in the current + * region. Following TREG timer expiry in Limited Service state, + * non-parallel search will be issued + * CSI-LLD section:4.3 + */ + if(rr_data->cs_data.region NEQ NOT_PRESENT_8BIT) + { + if(rr_data->cs_data.region NEQ new_region) + { + rr_data->cs_data.all_freq_area = TRUE; + TRACE_EVENT("all_freq_area : 1"); + } + + } + + /* CSI-LLD section:4.1.1.3.12 + * This stores region in rr_data base by extracting from std + */ + rr_data->cs_data.region = new_region; + } + /* + * remove co channels + */ + if (test_house EQ FALSE) + cs_remove_co_channels ((USHORT)(mph_bsic_cnf->arfcn&ARFCN_MASK)); + + rr_data->cs_data.attributes [rr_data->cs_data.act_index] |= + (CS_CHECK_FLAG | CS_BCCH_READ); + + /* CSI-LLD section:4.1.1.11 + * Synchronisation succeeded. Remove the carrier from black list + */ + cs_del_from_black_list(rr_data->cs_data.region, + (U16)(mph_bsic_cnf->arfcn&ARFCN_MASK)); + + att_bsic_ind ((USHORT)(mph_bsic_cnf->arfcn&ARFCN_MASK), + rr_data->cs_data.rxlev [rr_data->cs_data.act_index], + mph_bsic_cnf->bsic); + } + else + { + /* + * FB / SB is not decoded, cell has the attributes + * BCCH not detected and checked + */ + rr_data->cs_data.attributes [rr_data->cs_data.act_index] |= CS_CHECK_FLAG; + + /* Extract region information */ + + local_arfcn = rr_data->cs_data.arfcn[rr_data->cs_data.act_index]; + + if(STD_GET_FROM_ARFCN(local_arfcn) NEQ STD_NOT_PRESENT) + { + /* During Non-Parallel search, region information is available + * in ARFCN + */ + local_region = CS_GET_REGION_FROM_FREQ(local_arfcn); + } + else + { + /* Parallel search case */ + local_region = srv_get_region_from_std(std); +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + if (local_region EQ BOTH_REGIONS) + local_region = srv_get_region_from_std_arfcn (std, local_arfcn); +#endif + } + + /* CSI-LLD section:4.1.1.6 + * Sync failed. Add the carrier to Black list + */ + cs_add_to_black_list(local_region, + (U16)(local_arfcn), + rr_data->cs_data.rxlev[rr_data->cs_data.act_index]); + + /* CSI-LLD section:4.1.1.11 + * Set the BLACK LIST attribute flag for this carrier + */ + if(rr_data->cs_data.initial_plmn_search EQ INITIAL_PLMN_SEARCH_ACTIVE) + { + CS_SET_BLACK_LIST_FLAG(rr_data->cs_data.act_index); + } + + if (cs_sync_next_bsic () EQ FALSE) + { + TIMERSTOP(T_PLMN_SEARCH); + SET_STATE (STATE_CELL_SEL, CS_IDLE); + att_no_bsic_ind (); /* stop in RR */ + } + } + break; + +#ifdef GPRS + case CS_CCO: + SET_STATE (STATE_CELL_SEL, CS_IDLE); + if (rr_data->gprs_data.cr_pbcch_active OR rr_data->gprs_data.cr_pcco_active) + { + /* + * a Packet Cell Change Order for a cell which + * is not in the BA list has been requested by the NW + */ + if (mph_bsic_cnf->cs EQ CS_NO_ERROR AND + (mph_bsic_cnf->arfcn&ARFCN_MASK) EQ rr_data->gprs_data.arfcn AND + mph_bsic_cnf->bsic EQ rr_data->gprs_data.bsic ) + { + /* + * PL successfuly sycnhronized to the cell + * now RR will do a normal Cell Reselection + */ + memset (&rr_data->nc_data[CR_INDEX], + 0, + sizeof (T_NC_DATA)); + rr_data->nc_data[CR_INDEX].arfcn = mph_bsic_cnf->arfcn&ARFCN_MASK; + rr_data->nc_data[CR_INDEX].bsic = mph_bsic_cnf->bsic; + + /* CSI-LLD section:4.1.1.11 + * Synchronisation succeeded. Remove the carrier from black list + */ + cs_del_from_black_list(rr_data->cs_data.region, + (U16)(mph_bsic_cnf->arfcn&ARFCN_MASK)); + + if( rr_data->gprs_data.cr_pbcch_active ) + att_start_cell_reselection_pbcch(MODE_CELL_RESELECTION); + else + { + att_init_cell_selection(CELL_RESELECTION, RR_ORIGINATED); + rr_data->dyn_config.fcr = 0; + rr_data->dyn_config.scr = 0; + rr_data->bcch_error = 0; + rr_data->pag_rec = FALSE; + srv_clear_stored_prim (MPH_PAGING_IND); + gprs_init_data_cr(); + dat_att_null(); + SET_STATE (STATE_ATT, ATT_CS3); + att_build_idle_req (CR_INDEX, MODE_CELL_RESELECTION); + } + } + else + { + /* + * PL did not sycnhronize to the cell + * inform GRR and wait for a CR_REQ(CR_REQ) with + * the old cell and return to it + */ + PALLOC(gprs_ind, RRGRR_GPRS_SI13_IND); + rr_data->gprs_data.cr_pbcch_active = FALSE; + + gprs_ind->cause = GPRS_CELL_NOT_SUITABLE; + gprs_ind->serving_cell_info.bcch_arfcn = rr_data->gprs_data.arfcn; + gprs_ind->serving_cell_info.bcch_bsic = rr_data->gprs_data.bsic; + + TRACE_EVENT_P4 ("cs=%u C[%d] bsic=%u #%u", + gprs_ind->cause, + gprs_ind->serving_cell_info.bcch_arfcn, + gprs_ind->serving_cell_info.bcch_bsic, + __LINE__); + + PSENDX(GRR, gprs_ind); + /* wait for CR_REQ for old cell */ + } + } + else + if (mph_bsic_cnf->cs EQ CS_NO_ERROR AND + (mph_bsic_cnf->arfcn&ARFCN_MASK) EQ rr_data->gprs_data.arfcn AND + mph_bsic_cnf->bsic EQ rr_data->gprs_data.bsic ) + { + rr_data->gprs_data.tbf_est = TBF_EST_CCO; + + rr_data->nc_data[CR_INDEX].arfcn = rr_data->gprs_data.arfcn; + rr_data->nc_data[CR_INDEX].rxlev = 0; + rr_data->nc_data[CR_INDEX].bsic = rr_data->gprs_data.bsic; + + att_init_cr_data(); + TIMERSTART (T_RESELECT, TRESELECT_VALUE); + rr_data->nc_data[CR_INDEX].bcch_error = 0; + srv_clear_list (&rr_data->cr_data.cd.ncell_list); + SET_STATE (STATE_ATT, ATT_CS2); + + /* CSI-LLD section:4.1.1.11 + * Synchronisation succeeded. Remove the carrier from black list + */ + cs_del_from_black_list(rr_data->cs_data.region, + (U16)(mph_bsic_cnf->arfcn&ARFCN_MASK)); + /* wait for System Information Messages */ + } + else /* initiate switch back to old cell */ + { + dat_code_mph_old_chan_req(); + + PFREE ( rr_data->gprs_data.dl_data_ind ); + rr_data->gprs_data.dl_data_ind = NULL; + + rr_data->gprs_data.reconn_cause = RRC_PROT_UNSPECIFIED; + rr_data->gprs_data.cco_need_reconnect_cnf = FALSE; + SET_STATE (STATE_DAT, DAT_CCO_3); + } + break; + + case CS_XMEAS: + + /* enter result in rr_data->gprs_data.rrgrr_ext_meas_cnf, call att_ext_meas_next_bsic */ + + { + UBYTE bsic = mph_bsic_cnf->bsic; + T_GPRS_DATA *gprs_data = &rr_data->gprs_data; + T_RRGRR_EXT_MEAS_REQ *rrgrr_ext_meas_req = gprs_data->rrgrr_ext_meas_req; + + + if ( rrgrr_ext_meas_req->report_type EQ REP_TYPE_1 OR /* "6 strongest carriers independent of BSIC decoding or not" */ + rrgrr_ext_meas_req->report_type EQ REP_TYPE_2 AND /* "BSICs for 6 carriers with decoded BSIC with allowed NCC" */ + mph_bsic_cnf->cs EQ CS_NO_ERROR AND + (rrgrr_ext_meas_req->ncc_permitted & (1 << ((bsic>>3) & 0x07)))) /* check for "NCC allowed" */ + { + T_RRGRR_EXT_MEAS_CNF *rrgrr_ext_meas_cnf = gprs_data->rrgrr_ext_meas_cnf; + T_MPH_EXT_MEAS_CNF *mph_ext_meas_cnf = gprs_data->mph_ext_meas_cnf; + UBYTE n = gprs_data->mph_ext_meas_num; + USHORT arfcn = mph_ext_meas_cnf->arfcn[n]; + UBYTE rx_lev = mph_ext_meas_cnf->rx_lev[n]; + UBYTE idx = rr_ext_meas_idx ( arfcn ); + UBYTE k = rrgrr_ext_meas_cnf->c_xmeas_res++; + T_xmeas_res *xmeas_res = &rrgrr_ext_meas_cnf-> xmeas_res[k]; + + /* + * Function att_ext_meas_next_bsic checks for the maximum number of elements in the + * array rrgrr_ext_meas_cnf->xmeas_res. Therefore this check is not performed here. + */ + + xmeas_res->arfcn_idx.arfcn = arfcn; + xmeas_res->arfcn_idx.idx = idx; + xmeas_res->rxlev = rx_lev; + if (mph_bsic_cnf->cs EQ CS_NO_ERROR) + xmeas_res->bsic = bsic; + else + xmeas_res->bsic = RRGRR_INVALID_BSIC; + } + } + + rr_data->gprs_data.mph_ext_meas_num++; + att_ext_meas_next_bsic(); + break; +#endif + default: + break; + } + PFREE (mph_bsic_cnf); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_get_channel_from_found_list | ++--------------------------------------------------------------------+ + + PURPOSE : If a network available list was created in former times + (found_plmn / found_channel) and one of this networks is + requested, the associated channel is stored to give it + high priority to speed up cell selection. + +*/ +GLOBAL void cs_get_channel_from_found_list () +{ + GET_INSTANCE_DATA; + UBYTE i; + T_FOUND_ELEMENT * found; + + TRACE_FUNCTION ("cs_get_channel_from_found_list()"); + + /* + * initialise the local variable + */ + rr_data->found_channel = NOT_PRESENT_16BIT; + + /* + * for all PLMNs stored in the found list + */ + found = &rr_data->sc_data.found[0]; + for (i=0; i<rr_data->sc_data.found_entries; i++, found++) + { + /* + * if the network in the found list is equal to the PLMN requested by MM, + * set the found channel + */ +/* Implements Measure#32: Row 124 */ + att_print_mcc_mnc(found->arfcn, found->plmn.mcc, found->plmn.mnc, S2I_STRING("list")); + if (dat_plmn_equal_req (found->plmn.mcc, + found->plmn.mnc, + rr_data->ms_data.plmn.mcc, + rr_data->ms_data.plmn.mnc)) + { + rr_data->found_channel = found->arfcn; + + /* Embed region information in the found channel arfcn */ + if(found->region EQ AMERICAN_REGION) + rr_data->found_channel |= US_BIT; +/* Implements Measure#32: Row 125 */ + att_print_mcc_mnc(found->arfcn, found->plmn.mcc, found->plmn.mnc, S2I_STRING("found_channel")); + return; + } + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_clear_channel_from_found_list | ++--------------------------------------------------------------------+ + + PURPOSE : If a network available list was created in former times + (found_plmn / rr_found_channel) and one of this networks is + requested, the associated channel is stored to give it + high priority to speed up cell selection. This function + clear the stored data if a network or limited search is + started. + +*/ + +GLOBAL void cs_clear_channel_from_found_list (void) +{ + GET_INSTANCE_DATA; + /* + * initialize the found channel number + */ + rr_data->found_channel = NOT_PRESENT_16BIT; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_remove_co_channels | ++--------------------------------------------------------------------+ + + PURPOSE : If a channel x fails and the channels x-1 and x+1 have + a fieldstrength difference greater 9 dB, it is not necessary + to try on this cells. Sense of this is to speed up search. + +*/ + +static void cs_remove_co_channels (USHORT arfcn) +{ + /* + * depending on the channel number. Some extra cases + * for channel numbers on the boarders of the frequency Band + */ + switch (arfcn) + { + case CHANNEL_0: + /* + * E-GSM channel 0 has no co-channels + */ + break; + + /* + * all LOW channel boarders + */ + case LOW_CHANNEL_850: + case LOW_CHANNEL_900: + case LOW_CHANNEL_1800: + case LOW_CHANNEL_EGSM: + cs_remove_co_chan (arfcn, (USHORT)(arfcn+1)); + break; + + /* + * all HIGH channel boarders + */ + case HIGH_CHANNEL_1900: + if (std NEQ STD_1900 AND std NEQ STD_DUAL_US) + { + cs_remove_co_chan (arfcn, (USHORT)(arfcn+1));/* DCS 1800 */ + } + /*lint -fallthrough*/ + case HIGH_CHANNEL_850: + case HIGH_CHANNEL_900: + case HIGH_CHANNEL_1800: + case HIGH_CHANNEL_EGSM-1: + cs_remove_co_chan (arfcn, (USHORT)(arfcn-1)); + break; + + default: + /* + * all other channels inside the frequency bands + */ + cs_remove_co_chan (arfcn, (USHORT)(arfcn+1)); + cs_remove_co_chan (arfcn, (USHORT)(arfcn-1)); + break; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_remove_co_chan | ++--------------------------------------------------------------------+ + + PURPOSE : if co_chan - chan has a fieldstrength difference greater + 9 dBm, remove the channel. + +*/ + +static void cs_remove_co_chan (USHORT arfcn, USHORT co_arfcn) +{ + GET_INSTANCE_DATA; + UBYTE index_arfcn = NOT_PRESENT_8BIT; + UBYTE index_co_arfcn = NOT_PRESENT_8BIT; + UBYTE i; + SHORT rxlev_arfcn; + SHORT rxlev_co_arfcn; + USHORT *p_arfcn; + TRACE_FUNCTION ("cs_remove_co_chan()"); + + /* + * calculate the index in the power campaign list + * for the channel + */ + p_arfcn = rr_data->cs_data.arfcn; + for (i=0; i<rr_data->cs_data.max_arfcn; i++) + { + if (arfcn EQ (p_arfcn[i]&ARFCN_MASK)) + { + index_arfcn = i; + break; + } + } + /* + * if the channel is not inside the list, + * then nothing is to compare else get the + * fieldstrength. + */ + if (index_arfcn EQ NOT_PRESENT_8BIT) + return; + + /* + * calculate the index in the power campaign list + * for the co-channel + */ + for (i=0;i<rr_data->cs_data.max_arfcn;i++) + { + if (co_arfcn EQ (p_arfcn[i]&ARFCN_MASK)) + { + index_co_arfcn = i; + break; + } + } + /* + * if the co-channel is not inside the list, + * then nothing is to compare else get the + * fieldstrength. + */ + if (index_co_arfcn EQ NOT_PRESENT_8BIT) + return; + + rxlev_arfcn = (SHORT)rr_data->cs_data.rxlev [index_arfcn]; + rxlev_co_arfcn = (SHORT)rr_data->cs_data.rxlev [index_co_arfcn]; + + /* + * if the difference is > 9 dBm, + * set to low priority. + */ + if ((rxlev_arfcn - rxlev_co_arfcn) > 9) + { + rr_data->cs_data.attributes [index_co_arfcn] &= CS_SET_TO_LOW_PRIORITY; + } +} + +/* ++---------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_add_current_network .... | ++---------------------------------------------------------------------+ + + PURPOSE : Adds the current PLMN to the found list if available. + +*/ +LOCAL void cs_add_current_network_to_found_list (void) +{ + GET_INSTANCE_DATA; + T_loc_area_ident *lai = &rr_data->nc_data[SC_INDEX].lai; + + TRACE_FUNCTION ("cs_add_current_network_to_found_list()"); + + switch (rr_data->ms_data.rr_service) + { + case LIMITED_SERVICE: + case FULL_SERVICE: + /* + * The mobile was in full service + * Add this PLMN to the list of found PLMN + * and clean power measurement list. + */ + if (! att_plmn_in_found_list (lai->mcc, lai->mnc) AND + rr_data->sc_data.found_entries < MAX_PLMN) + { + att_save_found_plmn ( + &rr_data->sc_data.found[rr_data->sc_data.found_entries], + lai->mcc, lai->mnc, + rr_data->nc_data[SC_INDEX].arfcn, + rr_data->nc_data[SC_INDEX].rxlev, lai->lac, 0); + rr_data->sc_data.found_entries++; + } + /* + * Consider only high priority cells to speed up search + */ + cs_del_list (&rr_data->sc_data.cd.ncell_list); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_check_channel | ++--------------------------------------------------------------------+ + + PURPOSE : Depending on the settings (default, GSM 900, DCS 1800) + all non-interesting channels are removed. + +*/ +static UBYTE cs_check_channel (USHORT arfcn) +{ + GET_INSTANCE_DATA; + /* + * TRACE_FUNCTION ("cs_check_channel") + */ + { + switch (rr_data->dyn_config.set_band) + { + case 0: + /* + * default behaviour + */ + return TRUE; + + case 1: + /* + * set to GSM 900 + */ +/* + if (arfcn <= LOW_CHANNEL_900 OR + arfcn >= HIGH_CHANNEL_900) +*/ + if (INRANGE(LOW_CHANNEL_900,arfcn,HIGH_CHANNEL_900)) + return FALSE; + else + return TRUE; + + case 2: + /* + * set to DCS 1800 + */ +/* + if (arfcn >= LOW_CHANNEL_1800 AND + arfcn <= HIGH_CHANNEL_1800) +*/ + if (INRANGE(LOW_CHANNEL_1800,arfcn,HIGH_CHANNEL_1800)) + return TRUE; + else + return FALSE; + } + } + return TRUE; +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_check_region | ++----------------------------------------------------------------------+ + + PURPOSE : This routine validates the region + Cell Selection Improvements-LLD section:4.1.1.2 +*/ + +GLOBAL BOOL cs_check_region(U8 region) +{ +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + if((region EQ EUROPEAN_REGION) OR (region EQ AMERICAN_REGION) OR (region EQ BOTH_REGIONS)) +#else + if((region EQ EUROPEAN_REGION) OR (region EQ AMERICAN_REGION)) +#endif + { + return TRUE; + } + else + { + TRACE_ERROR("Invalid region"); + return FALSE; + } +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_validate_arfcn_index | ++----------------------------------------------------------------------+ + + PURPOSE : This routine validates the ARFCN index + Cell Selection Improvements-LLD section:4.1.1.2 +*/ + +GLOBAL BOOL cs_check_arfcn_range(U16 arfcn) +{ + + if(arfcn EQ CHANNEL_0) + arfcn = CHANNEL_0_INTERNAL; + + if((arfcn > CHANNEL_0) AND (arfcn <= CHANNEL_0_INTERNAL)) + { + return TRUE; + } + else + { + TRACE_ERROR("Invalid ARFCN"); + return FALSE; + } +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_inc_sync_fail_counter | ++----------------------------------------------------------------------+ + + PURPOSE : This routine increments the sync fail counter value for GSM + carrier. Seperate counters are maintained for European and + American regions.The size of SFC counter is 4 bits. As a + result two carriers are accommodated in one byte. This function + first converts the ARFCN range from 1-1023 to 0-511 format and + increments the SFC accordingly. The SFC format is shown below + + CSI-LLD section:4.1.1.5.9 + + ------------------------------------------ + | Index | MSB 4 bits | LSB 4 bits | + ------------------------------------------ + | 0 | ARFCN : 2 | ARFCN : 1 | + ------------------------------------------ + | 1 | ARFCN : 4 | ARFCN 3 | + ------------------------------------------ + | - | - | - | + ------------------------------------------ + | - | - | - | + ------------------------------------------ + | 510 | ARFCN : 1022 | ARFCN: 1021 | + ------------------------------------------ + | 511 | ARFCN : 0 | ARFCN :1023 | + ----------------------------------------- + ARFCN: 0 = CHANNEL_0_INTERNAL + +*/ + +LOCAL void cs_inc_sync_fail_counter(U8 region, U16 arfcn) +{ + GET_INSTANCE_DATA; + U16 index=0; + U8 inc = 0; + + if(!cs_check_region(region)) + return; + + if(!cs_check_arfcn_range((U16)(arfcn & ARFCN_MASK))) + return; + + if(arfcn EQ CHANNEL_0) + arfcn = CHANNEL_0_INTERNAL; + + /* Convert ARFCN range to 0-511 from 1-1023 range */ + index = ((arfcn & ARFCN_MASK) -1) >> 1; + + if(arfcn & 0x01) + { + /* Increment LSB 4 bits for odd ARFCN */ + inc = 0x01; + } + else + { + /* Increment MSB 4 bits for even ARFCN */ + inc = 0x10; + } + + /* Increment the synchronisation counter */ + rr_data->cs_data.black_list.sfc[region][index] += inc; + + TRACE_EVENT_P3("[%d]Reg,[%d]Arfcn, SFC = 0x%x", + region, + arfcn, + rr_data->cs_data.black_list.sfc[region][index]); +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_reset_sync_fail_counter | ++----------------------------------------------------------------------+ + + PURPOSE : This routine resets the synchronisation fail counter value of + GSM carrier. + Seperate counters are maintained for European and American + regions.The size of SFC counter is 4 bits. As a result two + carriers are accommodated in one byte. This function + first converts the ARFCN range from 1-1023 to 0-511 format and + increments the SFC accordingly.The SFC format is shown below + + CSI-LLD section:4.1.1.5.10 + + ------------------------------------------ + | Index | MSB 4 bits | LSB 4 bits | + ------------------------------------------ + | 0 | ARFCN : 2 | ARFCN : 1 | + ------------------------------------------ + | 1 | ARFCN : 4 | ARFCN 3 | + ------------------------------------------ + | - | - | - | + ------------------------------------------ + | - | - | - | + ------------------------------------------ + | 510 | ARFCN : 1022 | ARFCN: 1021 | + ------------------------------------------ + | 511 | ARFCN : 0 | ARFCN :1023 | + ----------------------------------------- + ARFCN: 0 = CHANNEL_0_INTERNAL +*/ + +LOCAL void cs_reset_sync_fail_counter(U8 region, U16 arfcn) +{ + GET_INSTANCE_DATA; + USHORT index=0; + + if(!cs_check_region(region)) + return; + + if(!cs_check_arfcn_range((U16)(arfcn & ARFCN_MASK))) + return; + + if(arfcn EQ CHANNEL_0) + arfcn = CHANNEL_0_INTERNAL; + + /* Convert ARFCN range to 0-511 from 1-1023 range */ + index = ((arfcn & ARFCN_MASK) -1) >> 1; + + if(arfcn & 0x01) + { + /* Reset LSB 4 bits for odd ARFCN */ + rr_data->cs_data.black_list.sfc[region][index] &=0xf0; + } + else + { + /* Reset MSB 4 bits for even ARFCN */ + rr_data->cs_data.black_list.sfc[region][index] &=0x0f; + } + + TRACE_EVENT_P2("SFC reset for [%d]Reg,[%d]Arfcn",region,arfcn); +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_get_sync_fail_counter | ++----------------------------------------------------------------------+ + + PURPOSE : This function returns the SFC counter of GSM carriers + Seperate counters are maintained for European and American + regions.The size of SFC counter is 4 bits. As a result two + carriers are accommodated in one byte. This function + first converts the ARFCN range from 1-1023 to 0-511 format and + increments the SFC accordingly.The SFC format is shown below + + CSI-LLD section:4.1.1.5.11 + + ------------------------------------------ + | Index | MSB 4 bits | LSB 4 bits | + ------------------------------------------ + | 0 | ARFCN : 2 | ARFCN : 1 | + ------------------------------------------ + | 1 | ARFCN : 4 | ARFCN 3 | + ------------------------------------------ + | - | - | - | + ------------------------------------------ + | - | - | - | + ------------------------------------------ + | 510 | ARFCN : 1022 | ARFCN: 1021 | + ------------------------------------------ + | 511 | ARFCN : 0 | ARFCN :1023 | + ----------------------------------------- + ARFCN: 0 = CHANNEL_0_INTERNAL +*/ + +LOCAL U8 cs_get_sync_fail_counter(U8 region, U16 arfcn) +{ + GET_INSTANCE_DATA; + USHORT index=0; + UBYTE sfc_count=0; + + if(!cs_check_region(region)) + return sfc_count; + + if(!cs_check_arfcn_range((U16)(arfcn & ARFCN_MASK))) + return sfc_count; + + if(arfcn EQ CHANNEL_0) + arfcn = CHANNEL_0_INTERNAL; + + /* Convert to 0-511 range from 1-1024 range */ + index = ((arfcn & ARFCN_MASK) -1) >> 1; + + if(arfcn & 0x01) + { + /* obtain LSB 4 bits for odd ARFCN */ + sfc_count = (rr_data->cs_data.black_list.sfc[region][index] & 0x0f); + } + else + { + /* obtain MSB 4 bits for even ARFCN */ + sfc_count = (rr_data->cs_data.black_list.sfc[region][index] & 0xf0) >> 4; + } + + return sfc_count; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_add_to_black_list | ++--------------------------------------------------------------------+ + + PURPOSE : This function is used to add GSM channels to "Black List". + The function checks the "Black List" criteria before adding + it to the list. This function is called whenever MS fails + to synchronize to a GSM channel. + CSI-LLD section:4.1.1.5.5 +*/ + +GLOBAL void cs_add_to_black_list(U8 region, U16 arfcn, U8 rxlev) +{ + GET_INSTANCE_DATA; + U16 local_arfcn = arfcn & ARFCN_MASK; + + TRACE_FUNCTION("cs_add_to_black_list()"); + + /* "Region" and "arfcn" are used to index "Black List" database + * Check whether they are within proper range + */ + if(!cs_check_region(region)) + return; + + if(!cs_check_arfcn_range(local_arfcn)) + return; + + /* Check Black List criteria */ + if(cs_check_black_list_criteria(region,arfcn,rxlev)) + { + /* Add the channel to Black List */ + srv_set_channel(&rr_data->cs_data.black_list.list[region],local_arfcn); + + /* Reset the sync fail counter for this channel. So that when this + * carrier is removed from BL(BA_MA list), counter will start from zero + * again + */ + cs_reset_sync_fail_counter(region, local_arfcn); + + TRACE_EVENT_P2("[%d]Reg[%d]Arfcn added to BL",region,local_arfcn); + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_del_from_black_list | ++--------------------------------------------------------------------+ + + PURPOSE : This routine removes the arfcn from black list and resets the sync + fail counter for that arfcn + CSI-LLD section:4.1.1.5.6 +*/ + +GLOBAL void cs_del_from_black_list(U8 region, U16 arfcn) +{ + GET_INSTANCE_DATA; + USHORT local_arfcn = arfcn & ARFCN_MASK; +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + UBYTE i; +#endif + + TRACE_FUNCTION("cs_del_from_black_list()"); + + /* "Region" and "arfcn" are used to index "Black List" database + * Check whether they are within proper range + */ + if(!cs_check_region(region)) + return; + + if(!cs_check_arfcn_range(local_arfcn)) + return; + +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + if (region EQ BOTH_REGIONS) + { + for (i=0; i<MAX_REGIONS; i++) + { + if(srv_get_channel(&rr_data->cs_data.black_list.list[i],local_arfcn)) + { + /* Remove the channel from Black List */ + srv_unset_channel(&rr_data->cs_data.black_list.list[i],local_arfcn); + + /* Reset the sync fail counter for this channel */ + cs_reset_sync_fail_counter(i, local_arfcn); + + TRACE_EVENT_P2("ARFCN:%d Region:%d deleted from BL",local_arfcn,i); + } + } + } + else + { +#endif + if(srv_get_channel(&rr_data->cs_data.black_list.list[region],local_arfcn)) + { + /* Remove the channel from Black List */ + srv_unset_channel(&rr_data->cs_data.black_list.list[region],local_arfcn); + + /* Reset the sync fail counter for this channel */ + cs_reset_sync_fail_counter(region, local_arfcn); + + TRACE_EVENT_P2("ARFCN:%d Region:%d deleted from BL",local_arfcn,region); + } +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + } +#endif +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_clear_black_list | ++--------------------------------------------------------------------+ + + PURPOSE : This function is used to clear "Black List" database. + The function clears the "Black List" database from + 1) Only RAM + 2) Only FFS + 3) Both RAM and FFS. + + This function is called in the following cases + 1) In response to "ERASE_BL" dynamic configuration command + 2) After Initial PLMN search based on its outcome + + CSI-LLD section:4.1.1.5.1 +*/ + +GLOBAL void cs_clear_black_list(U8 erase_type) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION ("cs_clear_black_list()"); + + /* clear Black List from RAM */ + if(erase_type & CLR_BLACK_LIST_RAM) + { + memset(&rr_data->cs_data.black_list,0,sizeof(T_CS_BLACK_LIST)); + + TRACE_EVENT ("Black List: RAM cleared"); + } + + /* Clear Black List from FFS */ +#if defined(_SIMULATION_FFS_) + if(erase_type & CLR_BLACK_LIST_FFS) + { + T_LIST local_black_list[MAX_REGIONS]; + + memset(&local_black_list[0],0,MAX_REGIONS*sizeof(T_LIST)); + + rr_csf_write_black_list(&local_black_list[0]); + + TRACE_EVENT ("Black List: FFS cleared"); + } +#endif + +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_remove_BA_MA_from_black_list| ++--------------------------------------------------------------------+ + + PURPOSE : This function is used to remove the GSM channels present + in MA and BA lists from the "Black List". The function + deletes these channels from the "Black List" and also + resets their SFC counter to zero. This function is called + whenever MS receives BA and MA list information in any RR + message. + CSI-LLD section:4.1.1.5.7 +*/ + +GLOBAL void cs_remove_BA_MA_from_black_list(U8 region, T_LIST *source_list) +{ + GET_INSTANCE_DATA; + + TRACE_FUNCTION("cs_remove_BA_MA_from_black_list()"); + + /* "Region" is to index "Black List" database + * Check whether it is within proper range + */ + if(!cs_check_region(region)) + return; + + if(source_list NEQ NULL) + { +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + if (region EQ BOTH_REGIONS) + { + cs_remove_BA_MA_from_black_list(EUROPEAN_REGION,source_list); + cs_remove_BA_MA_from_black_list(AMERICAN_REGION,source_list); + } + else +#endif + srv_unmask_list(&rr_data->cs_data.black_list.list[region],source_list); + + TRACE_EVENT("BL updated with BA/MA/Inactive carrier list"); + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_rem_inactive_carriers_from_bl| ++--------------------------------------------------------------------+ + + PURPOSE : This function is used to remove the inactive carriers from + the "Black List". This is done whenever the mobile changes + LA/RA + Cell Selection Improvements-LLD section:4.1.1.3.4 +*/ + +GLOBAL void cs_rem_inactive_carriers_from_bl(T_MPH_POWER_CNF *mph_power_cnf) +{ + + TRACE_FUNCTION("cs_remove_inactive_from_black_list"); + + /* Remove the inactive carriers from Black list for European region */ + cs_remove_BA_MA_from_black_list(EUROPEAN_REGION, + (T_LIST *)&mph_power_cnf->inactive_carrier_list.list[EUROPEAN_REGION]); + + /* Remove the inactive carriers from Black list for American region */ + cs_remove_BA_MA_from_black_list(AMERICAN_REGION, + (T_LIST *)&mph_power_cnf->inactive_carrier_list.list[AMERICAN_REGION]); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_is_in_black_list | ++--------------------------------------------------------------------+ + + PURPOSE : This routine checks whether a carrier is already part of Black + list or not + CSI-LLD section:4.1.1.5.12 +*/ + +LOCAL BOOL cs_is_in_black_list(U8 region, U16 arfcn) +{ + GET_INSTANCE_DATA; + U8 status; + + status = srv_get_channel((T_LIST*)&rr_data->cs_data.black_list.list[region], + (USHORT)arfcn & ARFCN_MASK); + + TRACE_EVENT_P3("[%d]Reg[%d]Arfcn, BL status:%d",region,arfcn,status); + + return status; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_is_in_white_list | ++--------------------------------------------------------------------+ + + PURPOSE : This routine checks whether a carrier is part of White + list or not + CSI-LLD section:4.1.2.2.7 +*/ + +LOCAL BOOL cs_is_in_white_list(U8 region, U16 arfcn) +{ + GET_INSTANCE_DATA; + U8 status = FALSE; + +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + if((rr_data->cs_data.white_list.region EQ BOTH_REGIONS) OR + (region EQ rr_data->cs_data.white_list.region)) +#else + if(region EQ rr_data->cs_data.white_list.region) +#endif + { + status = srv_get_channel(&rr_data->cs_data.white_list.list, + ((U16)arfcn & ARFCN_MASK)); + } + + TRACE_EVENT_P3("[%d]Reg[%d]Arfcn, WL status:%d", region,arfcn,status); + + return status; +} + +/* ++---------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_check_black_list_criteria| ++---------------------------------------------------------------------+ + + PURPOSE : This function checks the criteria for adding a GSM channel + to "Black List". GSM channels are added to "Black List" only + after they satisfy this criteria. + CSI-LLD section:4.1.1.5.13 +*/ + +LOCAL BOOL cs_check_black_list_criteria(U8 region,U16 arfcn,U8 rxlev) +{ + GET_INSTANCE_DATA; + UBYTE band_index; + U16 local_arfcn = arfcn&ARFCN_MASK; + TRACE_FUNCTION("cs_check_black_list_criteria()"); + + /* Check if the carrier is already present in the black list */ + if(cs_is_in_black_list(region, local_arfcn)) + return FALSE; + + /* Check if the carrier is present in White List */ + if(cs_is_in_white_list(region, local_arfcn)) + return FALSE; + +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT + band_index = cs_get_band_index(arfcn); +#else + band_index = get_band_index(arfcn); +#endif + /* RxLev of carrier is above upper threshold. Add the carrier + * to Black List immediately + */ + if(rxlev >= rr_data->dyn_config.upper_rxlev_thr[band_index]) + { + return TRUE; + } + + /* Reasonably strong carrier. Add to Black List only if its sync fail + * counter criteria is satisfied + */ + if((rxlev >= rr_data->dyn_config.medium_rxlev_thr[band_index]) AND + (rxlev < rr_data->dyn_config.upper_rxlev_thr[band_index])) + { + cs_inc_sync_fail_counter(region, local_arfcn); + + if(cs_get_sync_fail_counter(region, local_arfcn) >= MAX_SYNC_FAILURES) + { + return TRUE; + } + } + return FALSE; +} + +/* ++----------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_update_black_list | ++----------------------------------------------------------------+ + + PURPOSE : This function is used to update "Black List" database + after initial PLMN search.It first clears the current + "Black list" database from RAM and then adds some cells + to "Black List" according to the current attrib-utes + array values(BLACK_LIST_FLAG) of the Initial PLMN + selection process. This function is called un-der the + following cases + 1.MS enters Limited or No service after Initial PLMN search + 2.MS enters Full service in a different Location area + from where it is switched off after initial PLMN search + CSI-LLD section:4.1.1.5.8 +*/ + +GLOBAL void cs_update_black_list(void) +{ + GET_INSTANCE_DATA; + + U8 update_black_list = FALSE; + U8 i, region; + + TRACE_FUNCTION("cs_update_black_list()"); + + /* If the outcome of first FUNC_PLMN_SEARCH is not full service. + * Erase the Black List + */ + if((rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH AND + rr_data->ms_data.rr_service NEQ FULL_SERVICE)) + { + update_black_list = TRUE; + } + + TRACE_EVENT_P8 ( "Old [%d]SC MCC/MNC r=%x%x%x/%x%x%x/%d", + rr_data->cs_data.white_list.last_sc_arfcn, + rr_data->cs_data.white_list.last_sc_lac.mcc[0], + rr_data->cs_data.white_list.last_sc_lac.mcc[1], + rr_data->cs_data.white_list.last_sc_lac.mcc[2], + rr_data->cs_data.white_list.last_sc_lac.mnc[0], + rr_data->cs_data.white_list.last_sc_lac.mnc[1], + rr_data->cs_data.white_list.last_sc_lac.mnc[2], + rr_data->cs_data.white_list.last_sc_lac.lac); + + TRACE_EVENT_P8 ( "New [%d]SC MCC/MNC r=%x%x%x/%x%x%x/%d", + rr_data->nc_data[SC_INDEX].arfcn, + rr_data->nc_data[SC_INDEX].lai.mcc[0], + rr_data->nc_data[SC_INDEX].lai.mcc[1], + rr_data->nc_data[SC_INDEX].lai.mcc[2], + rr_data->nc_data[SC_INDEX].lai.mnc[0], + rr_data->nc_data[SC_INDEX].lai.mnc[1], + rr_data->nc_data[SC_INDEX].lai.mnc[2], + rr_data->nc_data[SC_INDEX].lai.lac); + + /* If the current serving cell belongs to a different Location area. + * Erase the Black List + */ + if((rr_data->ms_data.rr_service EQ FULL_SERVICE) AND + ((rr_data->cs_data.white_list.last_sc_arfcn EQ NOT_PRESENT_16BIT) OR + (!dat_plmn_equal_req(rr_data->cs_data.white_list.last_sc_lac.mcc, + rr_data->cs_data.white_list.last_sc_lac.mnc, + rr_data->nc_data[SC_INDEX].lai.mcc, + rr_data->nc_data[SC_INDEX].lai.mnc)) OR + (rr_data->cs_data.white_list.last_sc_lac.lac NEQ + rr_data->nc_data[SC_INDEX].lai.lac))) + { + update_black_list = TRUE; + } + + if(update_black_list) + { + /* Erase the current Black List */ + cs_clear_black_list(CLR_BLACK_LIST_RAM); + + for(i=0;i<rr_data->cs_data.max_arfcn;i++) + { + if(CS_GET_BLACK_LIST_FLAG(i)) + { + /* Obtain the region */ + region = CS_GET_REGION_FROM_FREQ(rr_data->cs_data.arfcn[i]); + + cs_add_to_black_list(region, + (USHORT)(rr_data->cs_data.arfcn[i]), + rr_data->cs_data.rxlev[i]); + } + } /* i < max_arfcn */ + + TRACE_EVENT("BL updated after inital PLMN search"); + } +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_store_black_list | ++----------------------------------------------------------------------+ + + PURPOSE : This is a wrapper function for storing "Black List" + information to FFS . This in turn calls + rr_csf_write_black_list( ) to store "Black List" to FFS. + This function is called during power off. + CSI-LLD section:4.1.1.5.2 +*/ + +GLOBAL void cs_store_black_list(void) +{ + GET_INSTANCE_DATA; +#if defined(_SIMULATION_FFS_) + rr_csf_write_black_list(&rr_data->cs_data.black_list.list[0]); +#endif +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_get_new_search_mode | ++----------------------------------------------------------------------+ + + PURPOSE : This routine returns the new search mode depending on the timer active + and the previous search mode + CSI-LLD section:4.1.3.4.1.1 +*/ + +GLOBAL U8 cs_get_new_search_mode(void) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION("cs_get_new_search_mode()"); + + if(IS_TIMER_ACTIVE(T_FAST_CS)) + { + /* Fast search timer is active */ + return FAST_SEARCH_MODE; + } + + if(IS_TIMER_ACTIVE(T_NORMAL_CS)) + { + /* Normal search timer is active */ + return NORMAL_SEARCH_MODE; + } + + TRACE_EVENT_P1("Previous Search Mode : %d", + rr_data->cs_data.previous_search_mode); + + if((rr_data->cs_data.previous_search_mode EQ FULL_SEARCH_MODE) + OR (rr_data->cs_data.previous_search_mode EQ FAST_SEARCH_MODE)) + { + return NORMAL_SEARCH_MODE; + } + + if(rr_data->cs_data.previous_search_mode EQ NORMAL_SEARCH_MODE) + { + return FULL_SEARCH_MODE; + } + + return FULL_SEARCH_MODE; +} +/* ++----------------------------------------------------------------------+ +| PROJECT : GSM-PS (8403) MODULE : RR_CS | +| STATE : code ROUTINE : cs_handle_search_mode_timer | ++----------------------------------------------------------------------+ + + PURPOSE : This routine handles the timers for the new search modes + CSI-LLD section:4.1.3.4.1.2 +*/ +GLOBAL void cs_handle_search_mode_timer(U8 search_mode) +{ + GET_INSTANCE_DATA; + TRACE_FUNCTION("cs_handle_search_mode_timer()"); + + if((search_mode EQ FAST_SEARCH_MODE) AND (rr_data->dyn_config.tfast_cs_val)) + { + if(!IS_TIMER_ACTIVE(T_FAST_CS)) + { + TIMERSTART (T_FAST_CS,rr_data->dyn_config.tfast_cs_val); + } + } + + if((search_mode EQ NORMAL_SEARCH_MODE) AND (rr_data->dyn_config.tnormal_cs_val)) + { + if(!IS_TIMER_ACTIVE(T_NORMAL_CS)) + { + TIMERSTART (T_NORMAL_CS, rr_data->dyn_config.tnormal_cs_val); + } + } + + if(search_mode EQ FULL_SEARCH_MODE) + { + if(rr_data->sc_data.mm_started EQ MM_ORIGINATED AND + rr_data->ms_data.req_mm_service NEQ FUNC_NET_SRCH_BY_MMI) + { + TIMERSTOP(T_FAST_CS); + TIMERSTOP(T_NORMAL_CS); + } + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : RR_CS | +| STATE : code ROUTINE : cs_update_std_ffs | ++--------------------------------------------------------------------+ + + PURPOSE : This function updates the std value depending upon the + frequency band support by MS. Frequncy band support is + available in the FFS. + +*/ +#ifdef TI_PS_FF_QUAD_BAND_SUPPORT +LOCAL UBYTE cs_update_std_ffs (UBYTE new_std) +{ + UBYTE freq_bands; + + rr_csf_get_freq_bands (&freq_bands); + switch (new_std) + { + case STD_DUAL_EGSM: + if ((freq_bands & BAND_GSM_850) EQ BAND_GSM_850) + { + return STD_850_900_1800; + } + break; + case STD_DUAL_US: + if ((freq_bands & BAND_GSM_900) EQ BAND_GSM_900) + { + return STD_850_900_1900; + } + break; + default: + TRACE_EVENT_P1 ("wrong std for updation using FFS %x", new_std); + } + return new_std; +} +#endif +#endif