FreeCalypso > hg > fc-magnetite
view src/g23m-gsm/rr/rr_attg.c @ 180:24955aef4da3
t30.lib compiles
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Thu, 13 Oct 2016 03:35:20 +0000 |
| parents | 27a4235405c6 |
| children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | 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 holds the functions for handling primitives | sent from entity GRR to entity RR and vice versa. +----------------------------------------------------------------------------- */ #ifndef RR_GPRS_C #define RR_GPRS_C #ifdef GPRS #define ENTITY_RR /*==== INCLUDES ===================================================*/ #include <string.h> #include <stddef.h> #include "typedefs.h" #include "pcm.h" #include "pconst.cdg" #include "mconst.cdg" #include "message.h" #include "vsi.h" #include "custom.h" #include "gsm.h" #include "prim.h" #include "pei.h" #include "tok.h" #include "rr_gprs.h" #include "rr.h" #include "rr_em.h" static void att_get_scell_info (T_serving_cell_info* sc, UBYTE idx); static void att_gprs_store_nc_mode(T_D_SYS_INFO_13* sys_info_13); #ifdef REL99 static void att_gprs_store_nw_release(T_D_SYS_INFO_13* sys_info_13); #endif static T_NC_DATA* is_nc_in_list(USHORT arfcn); static T_NC_DATA* find_empty_slot_in_list(void); static BOOL rr_ext_meas_can_start ( void ); /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_for_sysinfo_type13 | +--------------------------------------------------------------------+ PURPOSE : Checks GPRS availability of cell */ void att_for_sysinfo_type13 (T_MPH_UNITDATA_IND* data_ind, T_D_SYS_INFO_13* sys_info_13) { GET_INSTANCE_DATA; /* * get the storage area by checking the channel number */ UBYTE index = att_get_index (data_ind->arfcn); TRACE_FUNCTION("att_for_sysinfo_type13"); switch(GET_STATE(STATE_ATT)) { case ATT_CS2: /* * during cell selection * only CR_INDEX is taken in account */ if (index EQ CR_INDEX) { switch(GET_STATE(STATE_GPRS)) { case GPRS_ACTIVATED: case GPRS_PIM_BCCH: case GPRS_DEDI_SDCCH: if(sys_info_13->si13_rest_oct.v_si13_info AND sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) { SET_STATE(STATE_GPRS, GPRS_PIM_PBCCH); } else { SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); /* * check the NC mode, this is the default * value of the NW which can be overriden * by a Packet Measurement Order. * In CS2 we can always use the value provided * by the NW */ att_gprs_store_nc_mode(sys_info_13); } break; case GPRS_PIM_PBCCH: TRACE_EVENT("GPRS config changed during CS2!"); if(sys_info_13->si13_rest_oct.v_si13_info AND !sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) { SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); } break; default: break; } gprs_rrgrr_store_sdu(rr_data->gprs_data.si13_sdu, &data_ind->sdu); att_set_sys_info_read (SYS_INFO_13_READ, CR_INDEX); #ifdef REL99 att_gprs_store_nw_release(sys_info_13); #endif att_check_bcch_carrier_si (); } break; case ATT_CS3: /* * during cell reselection * only CR_INDEX is taken in account */ if (index EQ CR_INDEX) { switch(GET_STATE(STATE_GPRS)) { case GPRS_ACTIVATED: case GPRS_PIM_BCCH: if(sys_info_13->si13_rest_oct.v_si13_info AND sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) { SET_STATE(STATE_GPRS, GPRS_PIM_PBCCH); } else { SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); /* * check the NC mode, this is the default * value of the NW which can be overriden * by a Packet Measurement Order. * In CS3 we can always use the value provided * by the NW */ att_gprs_store_nc_mode(sys_info_13); } break; case GPRS_PIM_PBCCH: if(sys_info_13->si13_rest_oct.v_si13_info AND !sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) { TRACE_EVENT("GPRS config changed during CS3!"); SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); } break; default: break; } gprs_rrgrr_store_sdu(rr_data->gprs_data.si13_sdu, &data_ind->sdu); att_set_sys_info_read (SYS_INFO_13_READ, CR_INDEX); #ifdef REL99 att_gprs_store_nw_release(sys_info_13); #endif att_check_neighbourcell_si_reestab(); } break; case ATT_CON_EST: case ATT_IDLE: switch (index) { case SC_INDEX: /* now we want to send the SI13 to GRR */ if(/*rr_data->ms_data.rr_service EQ LIMITED_SERVICE OR*/ !att_gprs_is_avail()) return; switch(GET_STATE(STATE_GPRS)) { case GPRS_ACTIVATED: if((rr_data->sc_data.selection_type EQ CELL_RESELECTION_ON_GPRS_ACT) AND (rr_data->sc_data.cd.sys_info_read EQ ALL_SYS_INFO_READ)) { TRACE_EVENT(" CELL_RESELECTION_ON_GPRS_ACT should end"); TIMERSTOP(T_RESELECT); } if(sys_info_13->si13_rest_oct.v_si13_info AND sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) { if(rr_data->sc_data.cd.sys_info_read EQ ALL_SYS_INFO_READ) { att_gprs_stop_pl(); } SET_STATE(STATE_GPRS, GPRS_PIM_PBCCH); } else { SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); if(rr_data->sc_data.cd.sys_info_read EQ ALL_SYS_INFO_READ) { att_build_idle_req(SC_INDEX, MODE_SYS_INFO_CHANGE); } /* * check the NC mode, this is the default * value of the NW which can be overriden * by a Packet Measurement Order. * */ att_gprs_store_nc_mode(sys_info_13); } break; case GPRS_PIM_BCCH: case GPRS_PTM_BCCH: /* * check the NC mode, this is the default * value of the NW which can be overriden * by a Packet Measurement Order. * */ att_gprs_store_nc_mode(sys_info_13); /* XXX */ /* * Right now it not clear what how the activation of PBCCH * should be handled in RR/GRR */ if (GET_STATE(STATE_GPRS) EQ GPRS_PTM_BCCH) break; if(sys_info_13->si13_rest_oct.v_si13_info AND sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) { att_gprs_stop_pl(); SET_STATE(STATE_GPRS, GPRS_PIM_PBCCH); } break; case GPRS_PIM_PBCCH: if(sys_info_13->si13_rest_oct.v_si13_info AND !sys_info_13->si13_rest_oct.si13_info.v_pbcch_des) { /*XXX not possible actually */ SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); } break; default: break; } /* * GRR requests reading of SI13 every 30 seconds * pass the SI13 to GRR, for further evaluation */ TRACE_EVENT("idle sc"); TRACE_EVENT_P1("sys_info_read %d", rr_data->sc_data.cd.sys_info_read); gprs_rrgrr_store_sdu(rr_data->gprs_data.si13_sdu, &data_ind->sdu); att_set_sys_info_read (SYS_INFO_13_READ, SC_INDEX); #ifdef REL99 att_gprs_store_nw_release(sys_info_13); #endif att_signal_gprs_support(); break; case NOT_PRESENT_8BIT: /* * unexpected channel number */ break; default: /* * neighbour cell, ignore. * si13 info is not needed, at first * maybe get PBCCH info later */ break; } break; default: break; } } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS () MODULE : RR_GPRS | | STATE : code ROUTINE : att_set_gprs_indication | +-----------------------------------------------------------------------------+ PURPOSE : sets a flag indicating whether GPRS is wanted by upper layer or not. */ void att_set_gprs_indication (UBYTE gprs_indic) { GET_INSTANCE_DATA; TRACE_FUNCTION ("att_set_gprs_indication()"); /* * store parameter from MM */ rr_data->gprs_data.gprs_indic = gprs_indic; if(rr_data->gprs_data.gprs_indic) { SET_STATE(STATE_GPRS, GPRS_ACTIVATED); TRACE_EVENT("MM wants GPRS"); } else { SET_STATE(STATE_GPRS, GPRS_NULL); rr_data->gprs_data.ready_state = FALSE; /* Standby */ } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_check_gprs_supp | +--------------------------------------------------------------------+ PURPOSE : Checks GPRS availability of cell and sets the internal flag */ void att_check_gprs_supp (UBYTE v_gprs_ind, T_gprs_indic * data) { GET_INSTANCE_DATA; TRACE_FUNCTION ("att_check_gprs_supp ()"); /* * if rest octets for GPRS are available * and GPRS support is requested by MM */ switch(GET_STATE(STATE_GPRS)) { case GPRS_NULL: if(GET_STATE(STATE_ATT) EQ ATT_CS2 OR GET_STATE(STATE_ATT) EQ ATT_CS3) att_set_sys_info_read(SYS_INFO_13_READ, CR_INDEX); else att_set_sys_info_read(SYS_INFO_13_READ, SC_INDEX); break; case GPRS_ACTIVATED: if(GET_STATE(STATE_ATT) EQ ATT_CS2 OR GET_STATE(STATE_ATT) EQ ATT_CS3) { if(v_gprs_ind) { SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); /* * If System Info 13 is send on extended BCCH, * request reading, else it is reading on normal BCCH */ if(data->si13_pos EQ SI13_ON_BCCH_EXT) { PALLOC(mon_ctrl, MPH_MON_CTRL_REQ); mon_ctrl->action = START_MON_EBCCH; mon_ctrl->si_to_read = UPDATE_SI13; PSENDX(PL, mon_ctrl); } /* else we will read it on NBCCH */ } else { /* no state change */ att_set_sys_info_read(SYS_INFO_13_READ, CR_INDEX); } } /* * when GPRS is activated in idle this will be handled * when the SI13 is received */ break; case GPRS_PIM_BCCH: case GPRS_PIM_PBCCH: if(!v_gprs_ind) { SET_STATE(STATE_GPRS, GPRS_ACTIVATED); att_set_sys_info_read(SYS_INFO_13_READ, SC_INDEX); if(GET_STATE(STATE_ATT) EQ ATT_IDLE) { /*XY:n inform GRR, and wait for CR_RSP */ att_rrgrr_cr_ind(CR_ABNORMAL); rr_data->gprs_data.start_proc = START_PROC_CFG_CHG; } } else { /* * If System Info 13 is send on extended BCCH, * request reading, else it is reading on normal BCCH */ if(data->si13_pos EQ SI13_ON_BCCH_EXT) { PALLOC(mon_ctrl, MPH_MON_CTRL_REQ); mon_ctrl->action = START_MON_EBCCH; mon_ctrl->si_to_read = UPDATE_SI13; PSENDX(PL, mon_ctrl); } /* else we will read it on NBCCH */ } break; default: break; } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_signal_gprs_support | +--------------------------------------------------------------------+ PURPOSE : Signal GPRS support to GRR */ void att_signal_gprs_support (void) { GET_INSTANCE_DATA; PALLOC_SDU(rrgrr_gprs_si13_ind, RRGRR_GPRS_SI13_IND, MAX_L2_FRAME_SIZE * BITS_PER_BYTE); TRACE_FUNCTION ("att_signal_gprs_support()"); /* * gprs_support : Y Y X N N * rr_service : F L N F L * sdu : Y Y - - - * servng_cell_info: */ if(GET_STATE(STATE_ATT) EQ ATT_IDLE AND rr_data->sc_data.cd.sys_info_read NEQ ALL_SYS_INFO_READ) { PFREE(rrgrr_gprs_si13_ind); return; } if((GET_STATE(STATE_GPRS) NEQ GPRS_ACTIVATED AND GET_STATE(STATE_GPRS) NEQ GPRS_NULL) AND !(rr_data->ms_data.rr_service EQ NO_SERVICE) ) { rrgrr_gprs_si13_ind->cause = GPRS_SUPPORTED; /* * copy message content */ gprs_rrgrr_fill_from_stored_sdu(&rrgrr_gprs_si13_ind->sdu, rr_data->gprs_data.si13_sdu); TRACE_EVENT_P4 ("cs=%u C[%d] bsic=%u #%u", rrgrr_gprs_si13_ind->cause, rrgrr_gprs_si13_ind->serving_cell_info.bcch_arfcn, rrgrr_gprs_si13_ind->serving_cell_info.bcch_bsic, __LINE__); /* * set system information state */ rrgrr_gprs_si13_ind->si_states.si1_state = SI1_RECEIVED; rrgrr_gprs_si13_ind->si_states.si3_state = SI3_RECEIVED; rrgrr_gprs_si13_ind->si_states.si13_state = SI13_RECEIVED; } else { rrgrr_gprs_si13_ind->cause = GPRS_NOT_SUPPORTED; } /*When BA (BCCH) list is modified by PMO/PCCO, this is just for RR, RR should not inform GRR as it would have already formed the list. Sending this new list will change all the index, as GRR would assume it to be new BA(BCCH). When New BA(BCCH) is received then this flag would be reset and GRR should update the BA list*/ if(rr_data->gprs_data.ba_bcch_modified AND (GET_STATE(STATE_ATT) NEQ ATT_CS3)) { rrgrr_gprs_si13_ind->serving_cell_info.arfcn[0]= RRGRR_INVALID_ARFCN; } else { memcpy(rrgrr_gprs_si13_ind->serving_cell_info.arfcn, rr_data->act_ncell_list, sizeof(rrgrr_gprs_si13_ind->serving_cell_info.arfcn)); } att_get_scell_info(&rrgrr_gprs_si13_ind->serving_cell_info, SC_INDEX); /* we have found a cell, reset cr flag*/ rr_data->gprs_data.cr_pbcch_active = FALSE; #if defined (REL99) AND defined (TI_PS_FF_EMR) rrgrr_gprs_si13_ind->serving_cell_info.ba_ind = rr_data->sc_data.ba_index; #endif PSENDX(GRR, rrgrr_gprs_si13_ind); } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_add_ptmsi | +-----------------------------------------------------------------------------+ PURPOSE : Add the ptmsi if GPRS is supported. */ void att_add_ptmsi (T_MPH_IDENTITY_REQ * mph_identity_req) { GET_INSTANCE_DATA; TRACE_FUNCTION ("att_add_ptmsi()"); /* * check availability of GPRS */ switch (GET_STATE(STATE_GPRS)) { case GPRS_NULL: mph_identity_req->mid.v_ptmsi = FALSE; mph_identity_req->mid.ptmsi = 0L; mph_identity_req->mid.v_ptmsi2 = FALSE; mph_identity_req->mid.ptmsi2 = 0L; break; default: if (rr_data->gprs_data.ptmsi EQ 0xFFFFFFFF OR rr_data->gprs_data.ptmsi EQ 0L) { mph_identity_req->mid.v_ptmsi = FALSE; mph_identity_req->mid.ptmsi = 0L; } else { mph_identity_req->mid.v_ptmsi = TRUE; mph_identity_req->mid.ptmsi = rr_data->gprs_data.ptmsi; } /*the candidate PTMSI has to be checked also*/ if (rr_data->gprs_data.ptmsi2 EQ 0xFFFFFFFF OR rr_data->gprs_data.ptmsi2 EQ 0L) { mph_identity_req->mid.v_ptmsi2 = FALSE; mph_identity_req->mid.ptmsi2 = 0L; } else { mph_identity_req->mid.v_ptmsi2 = TRUE; mph_identity_req->mid.ptmsi2 = rr_data->gprs_data.ptmsi2; } break; } } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_rrgrr_cr_ind | +-----------------------------------------------------------------------------+ PURPOSE : IN : OUT : */ void att_rrgrr_cr_ind (UBYTE type) { GET_INSTANCE_DATA; /* * Following cases are possible: * BCCH always CR_ABNORMAL * after con est fail, after dedi, normal cr in idle and ptm, * plmn search,activate req, cell selection * PBCCH: * after con est fail(CR_REQ_CANDIDATE), * activate_req (CR_NORMAL) * after dedi (CR_ABNORMAL) * after imm_ass_rej (CR_SUSPENDED_IDLE) */ if(GET_STATE(STATE_GPRS) NEQ GPRS_NULL) { PALLOC(cr_ind, RRGRR_CR_IND); cr_ind->cr_type = type; TRACE_EVENT("cr_ind"); PSENDX(GRR, cr_ind); } else { TRACE_EVENT("cr already active"); } } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_rrgrr_cr_req | +-----------------------------------------------------------------------------+ PURPOSE : */ void att_rrgrr_cr_req (T_RRGRR_CR_REQ *cr_req) { GET_INSTANCE_DATA; int gprs_state; TRACE_FUNCTION ("gprs_rrgrr_cell_reselection_req ()"); gprs_state = GET_STATE(STATE_GPRS); TRACE_EVENT_P3 ("RRGRR_CR_REQ %u [%u] st=%u", cr_req->cr_type, cr_req->arfcn, gprs_state); TRACE_EVENT_P6 ( "r MCC/MNC=%x%x%x/%x%x%x", rr_data->ms_data.plmn.mcc[0], rr_data->ms_data.plmn.mcc[1], rr_data->ms_data.plmn.mcc[2], rr_data->ms_data.plmn.mnc[0], rr_data->ms_data.plmn.mnc[1], rr_data->ms_data.plmn.mnc[2]); switch(gprs_state) { case GPRS_PAM_PBCCH: case GPRS_ACTIVATED: case GPRS_PIM_PBCCH: case GPRS_PTM_PBCCH: case GPRS_SUSPENDED_PBCCH: switch(cr_req->cr_type) { case CR_NEW: { UBYTE i; UBYTE found=0; for(i=0; i<6;i++) { if(rr_data->nc_data[i].arfcn EQ cr_req->arfcn AND rr_data->nc_data[i].bsic EQ cr_req->bsic) { found=1; break; } } if(!found) { TRACE_ERROR("cr_req(NEW): data does not match");} memset (&rr_data->nc_data[CR_INDEX], 0, sizeof (T_NC_DATA)); rr_data->gprs_data.cr_pbcch_active = TRUE; rr_data->nc_data[CR_INDEX].arfcn = cr_req->arfcn; rr_data->nc_data[CR_INDEX].bsic = cr_req->bsic; if (rr_data->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI) { /*inform MM and stop everything*/ /* * send Please Retry to the MMI */ rr_data->sc_data.found_entries = 0; att_code_rr_abort_ind (RRCS_ABORT_CEL_SEL_FAIL); } if( ! rr_data->gprs_data.cr_pcco_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); } break; } case CR_NEW_NOT_SYNCED: { /* * a Packet Cell Change Order for a cell which * is not in the BA list has been requested by the NW */ PALLOC (mph_bsic_req, MPH_BSIC_REQ); { PALLOC (mph_sync_req, MPH_SYNC_REQ); mph_sync_req->cs = CS_START_PCCO; PSENDX (PL, mph_sync_req); } TRACE_EVENT("cco w/ not synced"); /* * remember we got a CR_REQ, will be used * on reception of the BSIC_CNF and the UNITDATA_IND */ rr_data->gprs_data.cr_pbcch_active = TRUE; SET_STATE (STATE_CELL_SEL, CS_CCO); /* avoid reacting to PAGINGs and ESTABLISH_REQ */ dat_att_null(); SET_STATE (STATE_ATT, ATT_CS3); cs_set_all(); rr_data->gprs_data.bsic = cr_req->bsic; rr_data->gprs_data.arfcn = mph_bsic_req->arfcn = cr_req->arfcn; PSENDX (PL, mph_bsic_req); } break; case CR_CS: if (rr_data->gprs_data.cr_pcco_active EQ FALSE) rr_data->gprs_data.cr_pbcch_active = TRUE; else rr_data->gprs_data.cr_pcco_active = FALSE; if (rr_data->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI) { /*inform MM and stop everything*/ /* * send Please Retry to the MMI */ rr_data->sc_data.found_entries = 0; att_code_rr_abort_ind (RRCS_ABORT_CEL_SEL_FAIL); } /*XY:n don't inform GRR */ att_start_cell_selection(RR_ORIGINATED, CS_NOT_PARALLEL,NORMAL_SEARCH_MODE); break; case CR_CONT: att_continue_cell_reselect (); break; case CR_COMPLETE: /* * we have a PBCCH and GRR has read it * we inform MM now */ if( rr_data->gprs_data.cr_pcco_active EQ FALSE ) { PALLOC(mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); mph_mon_ctrl_req->action = ENTER_PIM_PBCCH; PSENDX (PL, mph_mon_ctrl_req); } rr_data->gprs_data.cr_pcco_active = FALSE; /* initialize the ba_bcch_modified value when Cell reselection is done */ rr_data->gprs_data.ba_bcch_modified= FALSE; dat_att_cell_selected (); SET_STATE (STATE_ATT, ATT_IDLE); dat_send_bcchinfo_mm (rr_data->cr_data.cr_white_list.si2); if(rr_data->ms_data.rr_service EQ LIMITED_SERVICE AND rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH) { att_copy_old_lai_rac(SC_INDEX); #if 0 memcpy (&rr_data->old_lai, &rr_data->nc_data[SC_INDEX].lai, sizeof(T_loc_area_ident)); rr_data->old_cell_id = rr_data->nc_data[SC_INDEX].cell_id; #endif att_code_rr_abort_ind (RRCS_ABORT_CEL_SEL_FAIL); } else { if (rr_data->sc_data.mm_started) att_code_rr_act_cnf (); else att_code_rr_act_ind (); } /* * This instruction disdurbs test case 20.7 * unclear why it is coded here * rr_data->first_meas_received = TRUE; TRACE_EVENT("first_meas_received set to TRUE(rr_attg.c)"); */ /* * Start registration timer if needed */ att_start_registration_timer (); att_mph_identity_req (); #ifdef REL99 if(rr_data->ms_data.rr_service EQ FULL_SERVICE) att_config_cbch (); #else if(rr_data->ms_data.rr_service EQ FULL_SERVICE) att_build_cbch (); #endif srv_use_stored_prim (); /* * if the cell reselection has been started after a dedicated connection * attempt with failed SABM / UA content a second attempt is started * immediately. */ if (rr_data->repeat_est) { rr_data->repeat_est = FALSE; dat_start_immediate_assign (rr_data->ms_data.establish_cause); } break; default: break; } break; case GPRS_PTM_BCCH: if( (cr_req->cr_type EQ CR_NEW) || (cr_req->cr_type EQ CR_NEW_NOT_SYNCED)) { UBYTE i; UBYTE found=0; for(i=0; i<6;i++) { if(rr_data->nc_data[i].arfcn EQ cr_req->arfcn AND rr_data->nc_data[i].bsic EQ cr_req->bsic) { found=1; break; } } memset (&rr_data->nc_data[CR_INDEX], 0, sizeof (T_NC_DATA)); rr_data->nc_data[CR_INDEX].arfcn = cr_req->arfcn; rr_data->nc_data[CR_INDEX].bsic = cr_req->bsic; if (rr_data->ms_data.req_mm_service EQ FUNC_NET_SRCH_BY_MMI) { /*inform MM and stop everything*/ /* * send Please Retry to the MMI */ rr_data->sc_data.found_entries = 0; att_code_rr_abort_ind (RRCS_ABORT_CEL_SEL_FAIL); } rr_data->gprs_data.cr_pcco_active = TRUE; if(!found) { /* * a Packet Cell Change Order for a cell which * is not in the BA list has been requested by the NW */ PALLOC (mph_bsic_req, MPH_BSIC_REQ); { PALLOC (mph_sync_req, MPH_SYNC_REQ); mph_sync_req->cs = CS_START_PCCO; PSENDX (PL, mph_sync_req); } TRACE_EVENT("cco w/ not synced"); SET_STATE (STATE_CELL_SEL, CS_CCO); /* avoid reacting to PAGINGs and ESTABLISH_REQ */ dat_att_null(); SET_STATE (STATE_ATT, ATT_CS3); cs_set_all(); rr_data->gprs_data.bsic = cr_req->bsic; rr_data->gprs_data.arfcn = mph_bsic_req->arfcn = cr_req->arfcn; PSENDX (PL, mph_bsic_req); } 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); } } break; case GPRS_PIM_BCCH: /* * we have a BCCH * we have informed GRR of this (with additional info that we * have Full or Limited service) * we inform MM now */ switch(cr_req->cr_type) { case CR_COMPLETE: case CR_NEW: case CR_NEW_NOT_SYNCED: case CR_CS: case CR_CONT: dat_att_cell_selected (); SET_STATE (STATE_ATT, ATT_IDLE); dat_send_bcchinfo_mm (rr_data->cr_data.cr_white_list.si2); if(rr_data->ms_data.rr_service EQ LIMITED_SERVICE AND rr_data->ms_data.req_mm_service EQ FUNC_PLMN_SRCH) { att_copy_old_lai_rac(SC_INDEX); #if 0 memcpy (&rr_data->old_lai, &rr_data->nc_data[SC_INDEX].lai, sizeof(T_loc_area_ident)); rr_data->old_cell_id = rr_data->nc_data[SC_INDEX].cell_id; #endif att_code_rr_abort_ind (RRCS_ABORT_CEL_SEL_FAIL); } else { if (rr_data->sc_data.mm_started) att_code_rr_act_cnf (); else att_code_rr_act_ind (); } /* * Start registration timer if needed */ att_start_registration_timer (); att_mph_identity_req (); srv_use_stored_prim (); /* * if the cell reselection has been started after a dedicated connection * attempt with failed SABM / UA content a second attempt is started * immediately. */ if (rr_data->repeat_est) { rr_data->repeat_est = FALSE; dat_start_immediate_assign (rr_data->ms_data.establish_cause); } break; default: break; } break; case GPRS_PAM_BCCH: TRACE_EVENT("CR during PA"); break; default: break; } PFREE (cr_req); } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_rrgrr_stop_mon_ccch_req | +-----------------------------------------------------------------------------+ PURPOSE : Process the primitive RRGRR_STOP_MON_CCCH_REQ received from GRR. This primitive indicates to the RR that the monitoring of CCCH should be stopped. This is only a signal, no parameters needed. This signal is forwarded to ALR. */ /* * This is reqiured for Testmode A */ /*lint -esym(526,grlc_test_mode_active) : not defined | defined in GRR */ EXTERN UBYTE grlc_test_mode_active(void); void att_rrgrr_stop_mon_ccch_req (T_RRGRR_STOP_MON_CCCH_REQ* stop_mon) { GET_INSTANCE_DATA; TRACE_FUNCTION ("att_rrgrr_stop_mon_ccch_req ()"); switch(GET_STATE(STATE_GPRS)) { /* * This case is necessary to stop ccch monitoring in STATE_GPRS=GPRS_PTM * during Testmode A/B */ case GPRS_PTM_BCCH: if(grlc_test_mode_active()) { PALLOC(mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); mph_mon_ctrl_req->action = STOP_MON_CCCH; PSENDX (PL, mph_mon_ctrl_req); TRACE_EVENT("STOP_MON_CCCH during TESTMODE !!"); } break; case GPRS_PIM_BCCH: case GPRS_PIM_PBCCH: case GPRS_PAM_PBCCH: case GPRS_PTM_PBCCH: case GPRS_PAM_BCCH: TRACE_EVENT("stop ccch"); break; default: break; } PFREE (stop_mon); } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_rrgrr_start_mon_ccch_req | +-----------------------------------------------------------------------------+ PURPOSE : Process the primitive RRGRR_START_MON_CCCH_REQ received from GRR. This primitive indicates to the RR that the monitoring of CCCH should be started. This is only a signal, no parameters needed. This signal is forwarded to ALR. */ void att_rrgrr_start_mon_ccch_req (T_RRGRR_START_MON_CCCH_REQ* mon_req) { GET_INSTANCE_DATA; TRACE_EVENT ("att_rrgrr_start_mon_ccch_req ()"); /* * store split paging cycle */ if (mon_req->split_pg EQ RRGRR_NO_DRX) rr_data->gprs_data.split_pg=256; else rr_data->gprs_data.split_pg=mon_req->split_pg; switch(GET_STATE(STATE_GPRS)) { case GPRS_PIM_BCCH: TRACE_EVENT("GPRS_PIM_BCCH"); if(mon_req->pag_mode EQ PAG_MODE_DEFAULT AND rr_data->gprs_data.page_mode EQ PAG_MODE_REORG) { /* * go back to normal page mode */ rr_data->gprs_data.page_mode = PAG_MODE_DEFAULT; att_build_idle_req (SC_INDEX, MODE_SYS_INFO_CHANGE); } if(mon_req->pag_mode EQ PAG_MODE_PTM_NP) { /* * we may have received dl assignment in reog idle mode * we shopuld directly switch to transfer mode with: * NORMAL_PAGING */ SET_STATE(STATE_GPRS, GPRS_PTM_BCCH); SET_STATE(STATE_ATT, ATT_IDLE); SET_STATE(STATE_DAT, DAT_IDLE); att_build_idle_req(SC_INDEX, MODE_PACKET_TRANSFER); { PALLOC(mon_ctrl, MPH_MON_CTRL_REQ); mon_ctrl->action = START_MON_CCCH; mon_ctrl->si_to_read = 0; PSENDX(PL, mon_ctrl); } } break; case GPRS_PTM_BCCH: /* * set page_mode to REORG if NON_DRX_TIMER is used * set page_mode to DEFAULT if NON_DRX_TIMER is not used or 0 */ TRACE_EVENT("GPRS_PTM"); if(mon_req->pag_mode EQ PAG_MODE_PTM_NP) { PALLOC(mon_ctrl, MPH_MON_CTRL_REQ); mon_ctrl->action = START_MON_CCCH; mon_ctrl->si_to_read = 0; PSENDX(PL, mon_ctrl); } else if(mon_req->pag_mode EQ PAG_MODE_PIM_NP) { /* * Go into idle mode but start ONLY CCCH reading with the following order: * start with REORG and then switch to NORMAL paging */ TRACE_EVENT("PTM->IDLE: CCCH reorg+normal"); } else { rr_data->gprs_data.page_mode = mon_req->pag_mode; SET_STATE (STATE_GPRS, GPRS_PIM_BCCH); att_return_to_idle(); /* Transition from PTM to PIM state. PBCCH is not present in the * cell. Check if the previous PTM state was used for routing Area update. * start black list search to look for inactive carriers * Cell-Selection Improvement LLD - 4.1.4.3 */ if((rr_data->ms_data.establish_cause EQ ESTCS_GPRS_1P) AND (rr_data->cs_data.black_list_search_pending EQ TRUE)) { rr_data->cs_data.black_list_search_pending = FALSE; if(cs_check_region(rr_data->cs_data.region)) { /* Do not start Black list search,when Black list database is empty */ #ifdef TI_PS_FF_QUAD_BAND_SUPPORT if (rr_data->cs_data.region EQ BOTH_REGIONS) { if(srv_is_list_set(&rr_data->cs_data.black_list.list[EUROPEAN_REGION]) OR srv_is_list_set(&rr_data->cs_data.black_list.list[AMERICAN_REGION])) { att_start_cell_selection(RR_ORIGINATED,CS_PARALLEL,BLACK_LIST_SEARCH_MODE); } else { TRACE_EVENT("Black List empty"); } } #else if(srv_is_list_set( &rr_data->cs_data.black_list.list[rr_data->cs_data.region])) { att_start_cell_selection(RR_ORIGINATED,CS_PARALLEL,BLACK_LIST_SEARCH_MODE); } #endif else { #ifdef TI_PS_FF_QUAD_BAND_SUPPORT if(srv_is_list_set( &rr_data->cs_data.black_list.list[rr_data->cs_data.region])) { att_start_cell_selection(RR_ORIGINATED,CS_PARALLEL,BLACK_LIST_SEARCH_MODE); } else #endif { TRACE_EVENT("Black List empty"); } } } } } break; case GPRS_PAM_BCCH: rr_data->gprs_data.page_mode = mon_req->pag_mode; SET_STATE (STATE_GPRS, GPRS_PIM_BCCH); att_return_to_idle(); break; case GPRS_PAM_PBCCH: //break; case GPRS_PTM_PBCCH: case GPRS_PIM_PBCCH: { PALLOC(mon_ctrl, MPH_MON_CTRL_REQ); mon_ctrl->action = START_MON_CCCH; mon_ctrl->si_to_read = 0; PSENDX(PL, mon_ctrl); SET_STATE(STATE_DAT, DAT_IDLE); /* allow reception of pagings */ } break; default: TRACE_EVENT("start_mon_ccch_req not handled"); break; } PFREE (mon_req); } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_rrgrr_start_mon_bcch_req | +-----------------------------------------------------------------------------+ PURPOSE : Process the primitive RRGRR_START_MON_BCCH_REQ received from GRR. This primitive indicates to the RR to read SI. This primitive contains the parameter which indicates to the SI to read on BCCH. This signal is forwarded to ALR. */ void att_rrgrr_start_mon_bcch_req (T_RRGRR_START_MON_BCCH_REQ *rrgrr_start_mon_bcch_req) { GET_INSTANCE_DATA; TRACE_EVENT ("att_rrgrr_start_mon_bcch_req ()"); switch (GET_STATE(STATE_GPRS)) { case GPRS_PIM_BCCH: case GPRS_PIM_PBCCH: case GPRS_PAM_PBCCH: case GPRS_PTM_PBCCH: case GPRS_PTM_BCCH: { UBYTE si_to_read = rrgrr_start_mon_bcch_req->si_to_read; USHORT sys_info_read = rr_data->sc_data.cd.sys_info_read; PALLOC ( mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); TRACE_EVENT_P1 ( "rrgrr_start_mon_bcch_req->si_to_read = %d", rrgrr_start_mon_bcch_req->si_to_read ); mph_mon_ctrl_req->action = START_MON_NBCCH; switch ( si_to_read ) { case UNSPECIFIED_SI: sys_info_read = 0; break; case UPDATE_SI1: sys_info_read &= ~ SYS_INFO_1_READ; break; case UPDATE_SI2_SI2BIS_OR_SI2TER: sys_info_read &= ~ (SYS_INFO_2_READ | SYS_INFO_2BIS_READ | SYS_INFO_2TER_READ); #if defined (REL99) AND defined (TI_PS_FF_EMR) /*Once SI-2,2Bis,2Ter are read, we can configure ALR for acquiring SI-2quater*/ if ( (rr_data->sc_data.cd.si2quater_status NEQ SI2QUATER_ABSENT ) AND (rr_data->sc_data.cd.si2quater_pos EQ SI2QUATER_ON_EBCCH) ) rr_data->sc_data.cd.si2quater_status = SI2QUATER_CONFIGURE; #endif break; case UPDATE_SI3_SI4_SI7_OR_SI8: sys_info_read &= ~ (SYS_INFO_3_READ | SYS_INFO_4_READ ); break; case UPDATE_SI9: /* no support of SI 9 */ break; case COMPLETE_SI: sys_info_read = 0; break; case UPDATE_SI13: sys_info_read &= ~ SYS_INFO_13_READ; if(rr_data->nc_data[SC_INDEX].si13_loc_ind EQ EXTENDED_BCCH) { mph_mon_ctrl_req->action = START_MON_EBCCH; } break; default: break; } rr_data->sc_data.cd.sys_info_read = sys_info_read; TRACE_EVENT_P1("st_bcch:sys_info_read %d", rr_data->sc_data.cd.sys_info_read); mph_mon_ctrl_req->si_to_read = si_to_read; PSENDX (PL, mph_mon_ctrl_req); } break; case GPRS_ACTIVATED: if(GET_STATE(STATE_ATT) EQ ATT_IDLE) att_signal_gprs_support(); break; default: break; } PFREE (rrgrr_start_mon_bcch_req); } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_convert_idle_c31_cr | +-----------------------------------------------------------------------------+ PURPOSE : */ GLOBAL void att_convert_idle_c31_cr(UBYTE index) { GET_INSTANCE_DATA; TRACE_EVENT_P2("att_convert_idle_c31_cr called for index=%d conversion = %d", index, rr_data->nc_data[index].v_cr_par); switch(rr_data->nc_data[index].v_cr_par) { case CR_PAR_VALID: /* * For the first neighbour cell in the message where the struct exists, * the following default values shall be used for missing parameters: * GPRS_RXLEV_ACCESS_MIN = Serving cell RXLEV_ACCESS_MIN * GPRS_MS_TXPWR_MAX_CCH = Serving cell MS_TXPWR_MAX_CCH * GPRS_TEMPORARY_OFFSET = Serving cell TEMPORARY_OFFSET * GPRS_PENALTY_TIME = Serving cell PENALTY_TIME * GPRS_RESELECT_OFFSET = 0 * HCS_THR = infinity * PRIORITY_CLASS = undefined * SI13_PBCCH_LOCATION = undefined * */ if( rr_data->nc_data[index].cr_par.gprs_rxlev_access_min EQ GPRS_RXLEV_ACCESS_MIN_INVALID) rr_data->nc_data[index].cr_par.gprs_rxlev_access_min = rr_data->nc_data[SC_INDEX].select_para.rxlev_access_min; if(rr_data->nc_data[index].cr_par.gprs_ms_txpwr_max_cch EQ GPRS_MS_TXPWR_MAX_CCH_INVALID) rr_data->nc_data[index].cr_par.gprs_ms_txpwr_max_cch = rr_data->nc_data[SC_INDEX].select_para.ms_txpwr_max_cch; if(rr_data->nc_data[index].cr_par.gprs_temporary_offset EQ GPRS_TEMPORARY_OFFSET_INVALID) rr_data->nc_data[index].cr_par.gprs_temporary_offset = rr_data->nc_data[SC_INDEX].c2_par.temp_offset; if(rr_data->nc_data[index].cr_par.gprs_penalty_time EQ GPRS_PENALTY_TIME_INVALID) rr_data->nc_data[index].cr_par.gprs_penalty_time = rr_data->nc_data[SC_INDEX].c2_par.penalty_time * 2; if(rr_data->nc_data[index].cr_par.gprs_reselect_offset EQ GPRS_RESEL_OFF_INVALID) rr_data->nc_data[index].cr_par.gprs_reselect_offset = GPRS_RESEL_OFF_DEFAULT; /* * 31 is the maximum 5 bit value. * hcs_thr = 31 , means infinity */ if(rr_data->nc_data[index].cr_par.hcs_thr EQ GPRS_HCS_THR_INVALID) { rr_data->nc_data[index].cr_par.hcs_thr = 31; } /* priority class remains undefined */ break; case CR_PAR_INVALID: /* * initialise values * conversion of idle mode parameters to GPRS cell reselection parameters * GPRS_RXLEV_ACCESS_MIN = RXLEV_ACCESS_MIN * GPRS_MS_TXPWR_MAX_CCH = MS_TXPWR_MAX_CCH * C31 = 0 * GPRS_RESELECT_OFFSET(n) = * CELL_RESELECT_OFFSET(n) - CELL_RESELECT_OFFSET(s) * GPRS_TEMPORARY_OFFSET = TEMPORARY OFFSET * GPRS_PENALTY_TIME = PENALTY_TIME * PRIORITY_CLASS = 0 * C32_QUAL = 0 * GPRS_CELL_RESELECT_HYSTERESIS = CELL_RESELECT_HYSTERESIS * RA_RESELECT_HYSTERESIS = CELL_RESELECT_HYSTERESIS */ rr_data->nc_data[index].cr_par.gprs_rxlev_access_min = rr_data->nc_data[index].select_para.rxlev_access_min; rr_data->nc_data[index].cr_par.gprs_ms_txpwr_max_cch = rr_data->nc_data[index].select_para.ms_txpwr_max_cch; /* * NOTE: If PENALTY_TIME = 11111 for a cell, * the sign of CELL_RESELECT_OFFSET shall be changed * and TEMPORARY OFFSET set to 0 for that cell. */ if( rr_data->nc_data[index].c2_par.penalty_time EQ 31) { rr_data->nc_data[index].cr_par.gprs_temporary_offset = GPRS_RESEL_OFF_DEFAULT; } else { rr_data->nc_data[index].cr_par.gprs_temporary_offset = rr_data->nc_data[index].c2_par.temp_offset; } rr_data->nc_data[index].cr_par.priority_class = 0; rr_data->nc_data[index].cr_par.gprs_penalty_time = rr_data->nc_data[index].c2_par.penalty_time; rr_data->nc_data[index].cr_par.gprs_penalty_time *= 2; if( rr_data->nc_data[index].bcch_status NEQ DECODED ) TRACE_EVENT_P1("Error BCCH in NOT DECODED for arfcn %d in att_convert_idle_cr" , rr_data->nc_data[index].arfcn); break; default : break; } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : RR_ATT | | STATE : code ROUTINE : att_insert_c31_cr_data_in_cell | +--------------------------------------------------------------------+ PURPOSE : To store T_cr_par in rr_data->nc_data */ GLOBAL void att_insert_c31_cr_data_in_cell (UBYTE index) { GET_INSTANCE_DATA; UBYTE i; TRACE_EVENT_P1("att_insert_c31_cr_data_in_cell called for arfcn=%d" , rr_data->nc_data[index].arfcn ); rr_data->nc_data[index].v_cr_par = CR_PAR_INVALID; for( i = 0; i < rr_data->gprs_data.num_add_freq_list; i++ ) { if( rr_data->nc_data[index].arfcn EQ rr_data->gprs_data.add_freq_lists[i].arfcn ) { if( rr_data->gprs_data.add_freq_lists[i].v_cr_par ) { TRACE_EVENT_P2(" Cr_par found for arfcn =%d, index in add freq list = %d", rr_data->nc_data[index].arfcn, i); rr_data->nc_data[index].v_cr_par = CR_PAR_VALID; memcpy( & (rr_data->nc_data[index].cr_par), & (rr_data->gprs_data.add_freq_lists[i].cr_par), sizeof( T_cr_par) ); att_convert_idle_c31_cr(index); } else { TRACE_EVENT_P1("Cr_par found for arfcn =%d in add freq list", rr_data->nc_data[index].arfcn); if( rr_data->nc_data[index].bcch_status EQ DECODED) att_convert_idle_c31_cr(index); } return; } } if( rr_data->nc_data[index].bcch_status EQ DECODED) att_convert_idle_c31_cr(index); } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_init_c31_cr_par | +-----------------------------------------------------------------------------+ PURPOSE : */ static void att_init_nc_data_c31_cr_par(void) { GET_INSTANCE_DATA; UBYTE index = 0; TRACE_EVENT(" att_init_nc_data_c31_cr_par called"); for(index = 0; index <= SC_INDEX; index++) { rr_data->nc_data[index].v_cr_par = CR_PAR_INVALID; if( rr_data->nc_data[index].bcch_status NEQ EMPTY ) { att_insert_c31_cr_data_in_cell(index); } } } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_init_cr_c31_data | +-----------------------------------------------------------------------------+ PURPOSE : */ static void att_init_cr_c31_data(void) { GET_INSTANCE_DATA; UBYTE i = 0; UBYTE first_valid_par = 0; UBYTE valid_found = FALSE; for( ; (i < rr_data->gprs_data.num_add_freq_list) AND (valid_found EQ FALSE) ; i++) { if( rr_data->gprs_data.add_freq_lists[i].v_cr_par) { valid_found = TRUE; first_valid_par = i; } } if( valid_found ) { for( i = first_valid_par + 1 ; i < rr_data->gprs_data.num_add_freq_list ; i++) { if( rr_data->gprs_data.add_freq_lists[i].v_cr_par EQ FALSE ) { /* entire structure is missing */ rr_data->gprs_data.add_freq_lists[i].v_cr_par = TRUE; memcpy(& (rr_data->gprs_data.add_freq_lists[i].cr_par), & (rr_data->gprs_data.add_freq_lists[i-1].cr_par), sizeof(T_cr_par)); } else { /* a part of the structure may be missing */ if( rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_rxlev_access_min EQ GPRS_RXLEV_ACCESS_MIN_INVALID) rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_rxlev_access_min = rr_data->gprs_data.add_freq_lists[i-1].cr_par.gprs_rxlev_access_min; if(rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_ms_txpwr_max_cch EQ GPRS_MS_TXPWR_MAX_CCH_INVALID) rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_ms_txpwr_max_cch = rr_data->gprs_data.add_freq_lists[i-1].cr_par.gprs_ms_txpwr_max_cch; if(rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_temporary_offset EQ GPRS_TEMPORARY_OFFSET_INVALID ) rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_temporary_offset = rr_data->gprs_data.add_freq_lists[i-1].cr_par.gprs_temporary_offset; if(rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_penalty_time EQ GPRS_PENALTY_TIME_INVALID) rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_penalty_time = rr_data->gprs_data.add_freq_lists[i-1].cr_par.gprs_penalty_time; if(rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_reselect_offset EQ GPRS_RESEL_OFF_INVALID) rr_data->gprs_data.add_freq_lists[i].cr_par.gprs_reselect_offset = rr_data->gprs_data.add_freq_lists[i-1].cr_par.gprs_reselect_offset; if(rr_data->gprs_data.add_freq_lists[i].cr_par.hcs_thr EQ GPRS_HCS_THR_INVALID ) rr_data->gprs_data.add_freq_lists[i].cr_par.hcs_thr = rr_data->gprs_data.add_freq_lists[i-1].cr_par.hcs_thr; if(rr_data->gprs_data.add_freq_lists[i].cr_par.priority_class EQ GPRS_PRIORITY_CLASS_INVALID) rr_data->gprs_data.add_freq_lists[i].cr_par.priority_class = rr_data->gprs_data.add_freq_lists[i-1].cr_par.priority_class; if(rr_data->gprs_data.add_freq_lists[i].cr_par.si13_location EQ SI13_LOC_INVALID) rr_data->gprs_data.add_freq_lists[i].cr_par.si13_location = rr_data->gprs_data.add_freq_lists[i-1].cr_par.si13_location; if(rr_data->gprs_data.add_freq_lists[i].cr_par.psi1_repeat_period EQ PSI1_RPT_PRD_INVALID ) rr_data->gprs_data.add_freq_lists[i].cr_par.psi1_repeat_period = rr_data->gprs_data.add_freq_lists[i-1].cr_par.psi1_repeat_period; if(rr_data->gprs_data.add_freq_lists[i].cr_par.pbcch_location EQ PBCCH_LOC_INVALID ) rr_data->gprs_data.add_freq_lists[i].cr_par.pbcch_location = rr_data->gprs_data.add_freq_lists[i-1].cr_par.pbcch_location; } } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : RR_ATT | | STATE : code ROUTINE : att_calculate_c31_c32 | +--------------------------------------------------------------------+ PURPOSE : calculates C31 and C32 criterion of cell reselection is still valid. */ GLOBAL void att_calculate_c31_c32 (UBYTE index) { GET_INSTANCE_DATA; USHORT h; T_NC_DATA *rrd; T_NC_DATA *sc_ptr; UBYTE prios, prion; /*lint -esym(526,p_res_off) : not defined | defined in GRR */ extern const SHORT p_res_off[]; /* C1 = A - MAX(B,0) */ /* A = RLA_P - GPRS_RXLEV _ACCESS_MIN */ /* B = GPRS_MS_TXPWR_MAX_CCH - P */ /* P = max MS RF output power */ /* C31 = RLA_P(s) - HCS_THR(s) (serving cell) */ /* C31 = RLA_P(n) - HCS_THR(n) - TO(n)*L(n) (neighbour cell) */ /* TO(n) = GPRS_TEMPORARY_OFFSET(n) * H( GPRS_PENALTY_TIME(N) - T(n) ) */ /* L(n) = 0 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s) */ /* 1 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s) */ /* C32(s) = C1(s) */ /* C32(n) = C1(n) + GPRS_RESELECT OFFSET(n) - TO(n)*(1-L(n)) */ /* TO(n) = GPRS_TEMPORARY_OFFSET(n) * H( GPRS_PENALTY_TIME(N) - T(n) ) */ /* L(n) = 0 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s) */ /* 1 if PRIORITY_CLASS(n) = PRIORITY_CLASS(s) */ /* H(n) = 0 for x < 0 */ /* 1 for x >= 0 */ TRACE_FUNCTION ("att_calculate_c31_c32()"); /* * get a pointer to the data of the cell */ rrd = &(rr_data->nc_data[index]); att_calculate_c1(index); TRACE_EVENT_P5("arfcn = %d, C1 = %d, rxlev = %d, GPRS_RXLEV _ACCESS_MIN = %d, GPRS_MS_TXPWR_MAX_CCH = %d", rrd->arfcn, rrd->c1, rrd->rxlev, rrd->cr_par.gprs_rxlev_access_min, rrd->cr_par.gprs_ms_txpwr_max_cch); TRACE_EVENT_P3 ("hcs thr = %d, prion = %d, valid = %d", rrd->cr_par.hcs_thr, rrd->cr_par.priority_class , rrd->v_cr_par); if( rrd->v_cr_par EQ CR_PAR_INVALID) { rrd->c31 = 0; /* conversion of idle mode to GPRS cell reselection parameters */ } else { rrd->c31 = rrd->rxlev; if( rrd->cr_par.hcs_thr NEQ 31 ) rrd->c31 -= ( 2 * rrd->cr_par.hcs_thr ); else rrd->c31 = -32768; } rrd->c32 = rrd->c1; /* C31 = RLA_P(s) - HCS_THR(s) (serving cell) */ /* C32(s) = C1(s) */ TRACE_EVENT_P1("C31 = %d", rrd->c31); if( index EQ SC_INDEX ) return; sc_ptr = &rr_data->nc_data[SC_INDEX]; prios = (sc_ptr->cr_par.priority_class NEQ GPRS_PRIORITY_CLASS_INVALID) ? sc_ptr->cr_par.priority_class : (UBYTE) 0; prion = (rrd->cr_par.priority_class NEQ GPRS_PRIORITY_CLASS_INVALID ) ? rrd->cr_par.priority_class : (UBYTE) 0; if( rr_data->nc_data[index].v_cr_par EQ CR_PAR_INVALID) { /* * conversion of idle mode paramter to GPRS cell reselection parameters. * the conversion for GPRS_RESELECTION_OFFSET is done here. * the coversion of other parameters are done as * part of the function att_calculate_c1() * * GPRS_RESELECT_OFFSET(n) = * CELL_RESELECT_OFFSET(n) - CELL_RESELECT_OFFSET(s) * * NOTE: If PENALTY_TIME = 11111 for a cell, * the sign of CELL_RESELECT_OFFSET shall be changed * */ SHORT nc_sign = 1; SHORT sc_sign = 1; if(rrd->cr_par.gprs_penalty_time EQ 31 ) { nc_sign = -1; } if(sc_ptr->cr_par.gprs_penalty_time EQ 31 ) { sc_sign = -1; } rrd->c32 += (USHORT)(nc_sign * 2 * rrd->c2_par.cell_reselect_offset ) - (USHORT)(sc_sign * 2 * sc_ptr->c2_par.cell_reselect_offset); TRACE_EVENT_P5(" nc_sign =%d, sc_sign =%d, nc_rese_off=%d, sc_res_off=%d, c31=%d", nc_sign, sc_sign, rrd->c2_par.cell_reselect_offset, sc_ptr->c2_par.cell_reselect_offset, rrd->c32); } else { /* a valid paramter for GPRS_RESELECT_OFFSET is received */ rrd->c32 += p_res_off[rrd->cr_par.gprs_reselect_offset]; TRACE_EVENT_P3(" gprs_reselect_offset = %d, c32 = %d, res off index =%d", p_res_off[rrd->cr_par.gprs_reselect_offset], rrd->c32, rrd->cr_par.gprs_reselect_offset); } /* c32_qual is not known, if there is no PCCCH */ /* * Calculate x for H(x) and set H(x) */ TRACE_EVENT_P2("penalty time = %d, avail time = %d", (rrd->cr_par.gprs_penalty_time + 1) * 10, rrd->avail_time/PERIOD_1_SEC ); if ((USHORT)((rrd->cr_par.gprs_penalty_time + 1) * 10) >= (USHORT)(rrd->avail_time/PERIOD_1_SEC)) h = TRUE; else h = FALSE; if (h) { SHORT *criterion; TRACE_EVENT_P3("penalty timer not expired: %d offset will be applied to (prios)%d NEQ (prion)%d (if 0 c31, if 1 C32 )", 10 * rrd->cr_par.gprs_temporary_offset, prios, prion); if( prios NEQ prion ) { criterion = & (rrd->c31); } else { criterion = & (rrd->c32); } if( rrd->cr_par.gprs_temporary_offset EQ 7 ) { *criterion = -32768; } else { *criterion -= 10 * rrd->cr_par.gprs_temporary_offset; } } else { TRACE_EVENT("penalty timer expired"); } if( rrd->cr_par.same_ra_as_serving_cell NEQ SAME_RA_AS_SCELL) { TRACE_EVENT(" cell is NOT SAME_RA_AS_SCELL"); rrd->c32 -= 2 * rrd->select_para.cell_resel_hyst ; } else if(rr_data->gprs_data.ready_state) { /* MS in ready state*/ TRACE_EVENT(" MS in ready state"); rrd->c32 -= (SHORT)2 * rrd->select_para.cell_resel_hyst ; /* C31 hyst not known */ } if ( IS_TIMER_ACTIVE (T_NO_RESELECT) ) { rrd->c32 -= 5; } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : RR_ATT | | STATE : code ROUTINE : att_get_next_best_c32_index | +--------------------------------------------------------------------+ PURPOSE : This function returns the index of a target cell, for reselection. If no target cell is available then NO_AVAILABLE is returned. The parameter c31_calculated, indicates if C31 and C32 are already calculated. */ GLOBAL UBYTE att_get_next_best_c32_index (BOOL c31_calculated) { GET_INSTANCE_DATA; UBYTE max_result = SC_INDEX; UBYTE result = NO_AVAILABLE; UBYTE i; T_cr_par *ncell_first, *ncell_next, *scell_ptr; BOOL c31_bc, c31_nc, c31_sc; TRACE_FUNCTION ("att_get_next_best_c32_index()"); switch (rr_data->sc_data.selection_type) { case BACK_FROM_DEDICATED: case BACK_FROM_DEDICATED_RLF: case CELL_RESELECTION_CR: case CELL_RESELECTION_RACH: /* not valid */ break; default: /* * Normal Cell reselection * */ if( ! c31_calculated ) { att_calculate_c31_c32(SC_INDEX); for (i = 0; i < SC_INDEX; i++) { if (rr_data->nc_data[i].bcch_status EQ DECODED) { att_calculate_c31_c32 (i); } } } TRACE_EVENT_P1("Scell = %d", rr_data->nc_data[SC_INDEX].arfcn); for(i=0;i<=SC_INDEX; i++) { if( rr_data->nc_data[i].bcch_status EQ DECODED ) { ncell_first = &rr_data->nc_data[i].cr_par; TRACE_EVENT_P6("First best Cell(arfcn=%d), C1=%d,C31=%d,C32=%d,Priority class =%d,hcs_thr=%d", rr_data->nc_data[i].arfcn, rr_data->nc_data[i].c1, rr_data->nc_data[i].c31, rr_data->nc_data[i].c32, ncell_first->priority_class, ncell_first->hcs_thr ); } } /* * Now find the the first one which is not previously used */ for (i = 0; (i < SC_INDEX) AND (max_result EQ SC_INDEX) ; i++) { if ( (!rr_data->nc_data[i].c32_used) AND rr_data->nc_data[i].bcch_status EQ DECODED AND rr_data->nc_data[i].c1 > 0) { max_result = i; } } if( max_result EQ SC_INDEX ) { return NO_AVAILABLE; } ncell_first = &( rr_data->nc_data[max_result].cr_par); c31_bc = ( (rr_data->nc_data[max_result].c31 >= 0) AND (ncell_first->priority_class NEQ GPRS_PRIORITY_CLASS_INVALID) ); /* choose the best cell */ for (i = max_result+1; i < 6 ; i++) { if ( (!rr_data->nc_data[i].c32_used) AND (rr_data->nc_data[i].bcch_status EQ DECODED) AND (rr_data->nc_data[i].c1) > 0 ) { ncell_next = &( rr_data->nc_data[i].cr_par); c31_nc = ( (rr_data->nc_data[i].c31 >= 0) AND (ncell_next->priority_class NEQ GPRS_PRIORITY_CLASS_INVALID )); if( ( c31_bc AND c31_nc AND (ncell_next->priority_class EQ ncell_first->priority_class ) AND (rr_data->nc_data[i].c32 > rr_data->nc_data[max_result].c32) ) OR ( c31_bc AND c31_nc AND (ncell_next->priority_class > ncell_first->priority_class ) ) ) { /* prioritized cell reselection must be done */ max_result = i; ncell_first = ncell_next; } else if ( !c31_bc ) { if( c31_nc) { c31_bc = c31_nc; max_result = i; ncell_first = ncell_next; } else if ( rr_data->nc_data[i].c32 > rr_data->nc_data[max_result].c32 ) { /* no prioritized cell found yet */ max_result = i; ncell_first = ncell_next; } } } } /* compare with Serving cell */ scell_ptr = &( rr_data->nc_data[SC_INDEX].cr_par); c31_sc = ( (rr_data->nc_data[SC_INDEX].c31 >= 0 ) AND (scell_ptr->priority_class NEQ GPRS_PRIORITY_CLASS_INVALID)); TRACE_EVENT_P2("c31_sc=%d and c31_bc=%d",c31_sc, c31_bc); if( ( c31_sc AND c31_bc AND (ncell_first->priority_class EQ scell_ptr->priority_class) AND (rr_data->nc_data[max_result].c32 > rr_data->nc_data[SC_INDEX].c32) ) OR ( c31_sc AND c31_bc AND (ncell_first->priority_class > scell_ptr->priority_class) ) OR ( c31_bc AND !c31_sc ) OR ( !c31_bc AND !c31_sc AND (rr_data->nc_data[max_result].c32 > rr_data->nc_data[SC_INDEX].c32) ) ) { result = max_result; } else { result = NO_AVAILABLE; } } /* * return the index of the highest C2. */ return result; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : RR_ATT | | STATE : code ROUTINE : att_check_c31_reselect_decision| +--------------------------------------------------------------------+ PURPOSE : */ GLOBAL void att_check_c31_reselect_decision (UBYTE start_now) { GET_INSTANCE_DATA; UBYTE index; UBYTE delta = 1; TRACE_FUNCTION("att_check_c31_reselect_decision()"); index = att_get_next_best_c32_index(TRUE); while( index NEQ NO_AVAILABLE ) { /* found a suitable cell to reselect */ TRACE_EVENT_P1("found a cell %d", index); /* * Check cell barred status before going * into Cell Reselection state. * This will actually also be checked again * in att_check_cell but the CRH value will * not be used for subsequent ncells leading * to false CR's. We check it here * to use CRH for the next cell if needed. */ /* Implements RR Clone findings #8 */ if(att_cell_barred_status_cr_no_cr( index)) delta =0; /* * Do not trigger a cell reselection decision on meas. report * receipt if the cell belong to a LA not allowed for roaming. * According to 3.22 chapter 3.5.4 cell reselection on a * forbidden LA for regional provision of service is allowed. */ if (rr_data->ms_data.rr_service EQ FULL_SERVICE) { if (!dat_roam_forb_lai_check(index)) delta = 0; #if defined(_SIMULATION_) TRACE_EVENT_WIN_P1 ("delta=%d", delta); #endif } if (delta > 0) { if (start_now) { att_start_cell_reselection_gprs(CELL_RESELECTION_NC); } return; } rr_data->nc_data[index].c32_used = TRUE; index = att_get_next_best_c32_index(TRUE); } TRACE_EVENT(" index == NO_AVAILABLE in function att_check_c31_reselect_decision"); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : RR_ATT | | STATE : code ROUTINE : att_check_cell_c31 | +--------------------------------------------------------------------+ PURPOSE : if a cell reselection decision has been taken based on C31 and C32 criterion , this function looks for a candidate for cell reselection taking in account several requirements. The reselect_index stores the index of the RR storage area for the neighbourcell. The return value indicates whether a cell has been found or not. */ GLOBAL BOOL att_check_cell_c31 (void) { GET_INSTANCE_DATA; BOOL cell_ok = FALSE; TRACE_FUNCTION ("att_check_cell_c31()"); /* * while no suitable candidate has been found, * but still possible cells available. */ while (rr_data->reselect_index NEQ NO_AVAILABLE AND ! cell_ok) { /* * calculate the cell reselection criterion C31 and C32 for the candidate */ //att_calculate_c31_c32(rr_data->reselect_index); /* * attempting reselection. Mark used */ rr_data->nc_data[rr_data->reselect_index].c32_used = TRUE; /* * Cell should not be barred. * If GPRS cell reselection parameters are received, look for CELL_BAR_ACCESS_2 * else SI3 RACH parameters would indicate cell barred */ if( rr_data->nc_data[rr_data->reselect_index].v_cr_par EQ CR_PAR_VALID) { TRACE_EVENT_P2("Cell Barred arfcn = %d, barred = %d", rr_data->nc_data[rr_data->reselect_index].arfcn, rr_data->nc_data[rr_data->reselect_index].cr_par.cell_bar_access_2 ); cell_ok = (rr_data->nc_data[rr_data->reselect_index].cr_par.cell_bar_access_2 EQ CBA_2_NORMAL) ? TRUE : FALSE; } else { /* Implements RR Clone findings #8 */ cell_ok = !att_cell_barred_status_cr_no_cr (rr_data->reselect_index); } /* * 1. the cell shall be not temporarily excluded (tnnn e.g. after random access * failure). * 2. C31-C32 parameters are still valid */ if( cell_ok ) cell_ok = ( ! is_tnnn (rr_data->reselect_index) AND att_check_c31_criterion(rr_data->reselect_index) ); if ((cell_ok) AND (rr_data->ms_data.rr_service EQ FULL_SERVICE)) { if(rr_data->nc_data[rr_data->reselect_index].v_cr_par EQ CR_PAR_VALID) { cell_ok = (rr_data->nc_data[rr_data->reselect_index].cr_par.exc_acc EQ EXC_ACC_NORMAL) ? TRUE : FALSE; } else cell_ok = dat_roam_forb_lai_check (rr_data->reselect_index); } if (cell_ok) { /* * suitable cell has been found */ TRACE_EVENT ("use neighbour cell"); /* * configure layer 1 for cell reselection */ TRACE_EVENT_P2 ("config L1 for CR [%d]->[%d]", rr_data->nc_data[SC_INDEX].arfcn, rr_data->nc_data[rr_data->reselect_index].arfcn); rr_data->gprs_data.ready_state = FALSE; /* Standby */ att_start_cr_in_pl(rr_data->reselect_index); } else { /* * cell is not suitable. Look for another cell. */ rr_data->reselect_index = att_get_next_best_c32_index(TRUE); } } /* * return whether a cell has been found or not. */ return cell_ok; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : RR_ATT | | STATE : code ROUTINE : att_check_c31_criterion | +--------------------------------------------------------------------+ PURPOSE : returns TRUE if C31 and C32 criterion of cell reselection is still valid. */ GLOBAL BOOL att_check_c31_criterion(UBYTE index) { GET_INSTANCE_DATA; T_cr_par *ncell_ptr, *scell_ptr; BOOL c31_bc, c31_sc; att_calculate_c31_c32(index); ncell_ptr = & rr_data->nc_data[index].cr_par; scell_ptr = & rr_data->nc_data[SC_INDEX].cr_par; c31_bc = ((rr_data->nc_data[index].c31 >= 0) AND (ncell_ptr->priority_class NEQ GPRS_PRIORITY_CLASS_INVALID )); c31_sc = ( (rr_data->nc_data[SC_INDEX].c31 >= 0 ) AND (scell_ptr->priority_class NEQ GPRS_PRIORITY_CLASS_INVALID)); /* * check for C32 values, depending on priority */ if( ( c31_sc AND c31_bc AND (ncell_ptr->priority_class > scell_ptr->priority_class) ) OR ( c31_sc AND c31_bc AND (ncell_ptr->priority_class EQ scell_ptr->priority_class) AND (rr_data->nc_data[index].c32 > rr_data->nc_data[SC_INDEX].c32) ) OR ( c31_bc AND (!c31_sc) ) OR ( (!c31_sc) AND (!c31_bc) AND (rr_data->nc_data[index].c32 > rr_data->nc_data[SC_INDEX].c32) ) ) { return TRUE; } return FALSE; } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_rrgrr_update_ba_req | +-----------------------------------------------------------------------------+ PURPOSE : */ void att_rrgrr_update_ba_req(T_RRGRR_UPDATE_BA_REQ* ba_req) { GET_INSTANCE_DATA; UBYTE i; T_LIST new_list; T_CELL_DATA * cd; TRACE_EVENT ("update_ba"); switch(GET_STATE(STATE_GPRS)) { case GPRS_PIM_BCCH: case GPRS_PTM_BCCH: case GPRS_PIM_PBCCH: case GPRS_PAM_PBCCH: case GPRS_PTM_PBCCH: #if 0 if (ba_req->cell_type EQ SYNC_SCELL) #endif cd = &rr_data->sc_data.cd; #if 0 /* this is not used anymore but it still in the SAp for some time */ else cd = &rr_data->cr_data.cd; #endif if(!rr_data->gprs_data.ba_bcch_modified) srv_copy_list (&rr_data->ba_ncell_list, &cd->ncell_list, sizeof (T_LIST)); /* store GPRS cell reselection parameters */ memcpy(rr_data->gprs_data.add_freq_lists, ba_req->add_freq_list, sizeof(T_add_freq_list) * RRGRR_BA_LIST_SIZE ); srv_copy_list (&new_list, &rr_data->ba_ncell_list, sizeof (T_LIST)); if( ba_req->add_freq_list[0].arfcn NEQ NOT_PRESENT_16BIT ) rr_data->gprs_data.use_c31 = FALSE; for(i=0; i<RRGRR_BA_LIST_SIZE AND ba_req->add_freq_list[i].arfcn NEQ NOT_PRESENT_16BIT; i++) { /*add*/ srv_set_channel (&new_list, ba_req->add_freq_list[i].arfcn); if((ba_req->add_freq_list[i].v_cr_par) AND ( ba_req->cell_type EQ SYNC_SCELL)) { rr_data->gprs_data.use_c31 = TRUE; TRACE_EVENT("use_c31 turned TRUE"); } } if( rr_data->gprs_data.use_c31) { rr_data->gprs_data.num_add_freq_list = i; TRACE_EVENT_P1("number of added arfcn = %d", i); att_init_cr_c31_data(); att_init_nc_data_c31_cr_par(); } else { rr_data->gprs_data.num_add_freq_list = 0; } for(i=0; i<RRGRR_BA_LIST_SIZE AND ba_req->rm_freq_list[i].arfcn NEQ NOT_PRESENT_16BIT; i++) { /*remove*/ srv_unset_channel(&new_list, ba_req->rm_freq_list[i].arfcn); } /* * The NC2 indication in the Packet Measurement Order * overrides the setting in the SI13 */ rr_data->gprs_data.nc_mode_of_pmo = ba_req->nc_mode; rr_data->gprs_data.ba_bcch_modified=TRUE; if (srv_compare_list (&cd->ncell_list, &new_list) EQ FALSE) { /* both lists are different or it is the first one */ srv_copy_list (&cd->ncell_list, &new_list, sizeof (T_LIST)); /* forward new neighbour cell list to layer 1 if * changes shall be indicated */ if (ba_req->cell_type EQ SYNC_SCELL) { att_remove_bad_rr_data_ncells(); att_code_mph_ncell_req (SC_INDEX); #if defined (REL99) AND defined (TI_PS_FF_EMR) /*BA(BCCH) is modified by GRR, this list now loses the indices' sync that it has with NW, so can no longer use it when moved to dedicated mode, for reporting*/ rr_data->sc_data.ba_list_idle = FALSE; rr_data->sc_data.enh_para_status = ENH_PARA_INVALID_STATE; for_set_default_emr_data(&rr_data->sc_data.emr_data_current); for_set_default_emr_data(&rr_data->sc_data.emr_data_temp); #endif } } break; default: break; } PFREE(ba_req); } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_rrgrr_meas_rep_req | +-----------------------------------------------------------------------------+ PURPOSE : */ void att_rrgrr_meas_rep_req (T_RRGRR_MEAS_REP_REQ* rrgrr_meas_rep_req) { PALLOC(mph_meas_rep_req,MPH_MEAS_REP_REQ); TRACE_FUNCTION("rrgrr_meas_rep_req()"); mph_meas_rep_req->cause = rrgrr_meas_rep_req->meas_cause; PFREE(rrgrr_meas_rep_req); PSENDX(PL,mph_meas_rep_req); } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_check_sync_results | +-----------------------------------------------------------------------------+ PURPOSE : */ BOOL att_check_sync_results(T_MPH_MEASUREMENT_IND* mph_measurement_ind) { UBYTE i=0; T_NC_DATA* pnc = NULL; if(mph_measurement_ind->gprs_sync EQ SYNC_RESULTS) { PALLOC(bsic_ind, RRGRR_NCELL_SYNC_IND); TRACE_EVENT ("check_sync_res:TRUE"); for(; i < mph_measurement_ind->ncells.no_of_ncells ;i++) { bsic_ind->sync_result[i].arfcn = mph_measurement_ind->ncells.arfcn[i]; if(mph_measurement_ind->ncells.bsic[i] EQ NOT_PRESENT_8BIT OR mph_measurement_ind->ncells.bsic[i] EQ MPH_BSIC_UNKNOWN) { if((pnc = is_nc_in_list(mph_measurement_ind->ncells.arfcn[i])) NEQ NULL) { pnc->arfcn = NOT_PRESENT_16BIT; pnc->bcch_status = EMPTY; } if(mph_measurement_ind->ncells.bsic[i] EQ NOT_PRESENT_8BIT) bsic_ind->sync_result[i].sb_flag = NO_SB_FOUND; else bsic_ind->sync_result[i].sb_flag = SB_UNKNOWN; /*UNKNOWN*/ } else { /* cell with BSIC */ if( (pnc = is_nc_in_list(mph_measurement_ind->ncells.arfcn[i])) NEQ NULL) { /*found -> update if needed */ pnc->bsic = bsic_ind->sync_result[i].bsic = mph_measurement_ind->ncells.bsic[i]; pnc->bcch_status=NON_DECODED; } else { /*add*/ pnc = find_empty_slot_in_list(); if(pnc) { pnc->bsic = bsic_ind->sync_result[i].bsic = mph_measurement_ind->ncells.bsic[i]; pnc->arfcn = mph_measurement_ind->ncells.arfcn[i]; pnc->bcch_status=NON_DECODED; } } bsic_ind->sync_result[i].sb_flag = SB_FOUND; } } if(i>0) { for(/*dont init i*/; i < RRGRR_MAX_RSLT_NCELL_SYNC_IND; i++) { bsic_ind->sync_result[i].arfcn = NOT_PRESENT_16BIT; } PSENDX(GRR, bsic_ind); } else { PFREE(bsic_ind); } PFREE(mph_measurement_ind); return TRUE; } return FALSE; } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_check_bsic | +-----------------------------------------------------------------------------+ PURPOSE : */ void att_check_bsic(T_RRGRR_NCELL_SYNC_REQ* check_bsic) { GET_INSTANCE_DATA; #if defined (TI_PS_FF_RTD) AND defined (REL99) T_rr_enh_para *p_cur = &rr_data->sc_data.emr_data_current; #endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */ TRACE_EVENT ("acq_bsic"); switch(GET_STATE(STATE_GPRS)) { case GPRS_PIM_PBCCH: case GPRS_PTM_PBCCH: case GPRS_PAM_PBCCH: { #if defined (TI_PS_FF_RTD) AND defined (REL99) UBYTE i,j; #else UBYTE i; #endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */ PALLOC(ncell_req, MPH_NEIGHBOURCELL_REQ); if(check_bsic->sync_type EQ SYNC_RECONFIRM) ncell_req->sync_only = RECONFIRM_SYNC_LIST; else ncell_req->sync_only = SYNC_LIST; memset(ncell_req->arfcn, NOT_PRESENT_8BIT, 2*MAX_NEIGHBOURCELLS); for(i=0; i<RRGRR_MAX_ARFCN_NCELL_SYNC_REQ AND #if defined (TI_PS_FF_RTD) AND defined (REL99) check_bsic->ncell_sync_list[i].arfcn #else check_bsic->arfcn[i] #endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */ NEQ NOT_PRESENT_16BIT; i++) { #if defined (TI_PS_FF_RTD) AND defined (REL99) ncell_req->arfcn[i] = check_bsic->ncell_sync_list[i].arfcn; #else ncell_req->arfcn[i] = check_bsic->arfcn[i]; #endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */ #if defined (TI_PS_FF_RTD) AND defined (REL99) for(j = 0;j < check_bsic->ncell_sync_list[i].c_rtd;j++) p_cur->enh_para.enh_cell_list[i].rtd[j] = check_bsic->ncell_sync_list[i].rtd[j]; p_cur->enh_para.enh_cell_list[i].v_rtd = check_bsic->ncell_sync_list[i].v_rtd; p_cur->enh_para.enh_cell_list[i].c_rtd = check_bsic->ncell_sync_list[i].c_rtd; #endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */ } #if defined (TI_PS_FF_RTD) AND defined (REL99) attf_send_enh_para_to_alr(p_cur->rep_type,&p_cur->enh_para); #endif /* #if defined (TI_PS_FF_RTD) AND defined (REL99) */ PSENDX(PL, ncell_req); } break; default: break; } PFREE(check_bsic); } static T_NC_DATA* is_nc_in_list(USHORT arfcn) { GET_INSTANCE_DATA; T_NC_DATA* p_nc = &rr_data->nc_data[0]; T_NC_DATA* p_nc_l = &rr_data->nc_data[6]; for(; p_nc < p_nc_l;p_nc++) if(p_nc->arfcn EQ arfcn) return p_nc; return NULL; } static T_NC_DATA* find_empty_slot_in_list(void) { GET_INSTANCE_DATA; T_NC_DATA* p_nc = &rr_data->nc_data[0]; T_NC_DATA* p_nc_l = &rr_data->nc_data[6]; for(; p_nc < p_nc_l;p_nc++) if(p_nc->bcch_status EQ EMPTY) return p_nc; return NULL; } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_is_gprs_avail | +-----------------------------------------------------------------------------+ PURPOSE : */ BOOL att_gprs_is_avail(void) { GET_INSTANCE_DATA; if(GET_STATE(STATE_GPRS) NEQ GPRS_NULL) return TRUE; else return FALSE; } BOOL att_gprs_cell_has_pbcch(void) { GET_INSTANCE_DATA; UBYTE st = GET_STATE(STATE_GPRS); switch(st) { case GPRS_PIM_PBCCH: case GPRS_PAM_PBCCH: case GPRS_PTM_PBCCH: case GPRS_SUSPENDED_PBCCH: return TRUE; default: return FALSE; } } void att_gprs_stop_pl (void) { GET_INSTANCE_DATA; att_build_classmark_req (); att_build_idle_req(SC_INDEX, MODE_CONFIG_PL); #if defined (REL99) AND defined (TI_PS_FF_EMR) /*reset SI-2quater information and enhanced parameters if present when PBCCH is present*/ rr_data->sc_data.cd.si2quater_status = SI2QUATER_ABSENT; rr_data->sc_data.cd.si2quater_pos = 0; memset (rr_data->sc_data.rep_count, NOT_PRESENT_8BIT, MAX_NEIGHBOURCELLS); for_set_default_emr_data(&rr_data->sc_data.emr_data_current); rr_data->sc_data.enh_para_status = ENH_PARA_INVALID_STATE; rr_data->sc_data.ba_list_ded = rr_data->sc_data.ba_list_idle = FALSE; #endif /* * use neighbour cell list from system info 2/2bis/2ter */ memset (rr_data->act_ncell_list, 0xFF, 2*MAX_NEIGHBOURCELLS); srv_create_list (&rr_data->sc_data.cd.ncell_list, rr_data->act_ncell_list, MAX_NEIGHBOURCELLS, FALSE, 0); } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_gprs_cr_rsp | +-----------------------------------------------------------------------------+ PURPOSE : */ void att_gprs_cr_rsp(T_RRGRR_CR_RSP* cr_rsp) { GET_INSTANCE_DATA; TRACE_FUNCTION("att_gprs_cr_rsp()"); switch(rr_data->gprs_data.start_proc) { case START_PROC_ACTIVATE_REQ: srv_use_stored_prim(); break; case START_PROC_ENTER_LIMITED: att_signal_gprs_support(); if(att_gprs_cell_has_pbcch()) { /* * RR is now in idle and configures L1 for * BCCH only */ SET_STATE(STATE_GPRS, GPRS_PIM_BCCH); switch(GET_STATE(STATE_ATT)) { case ATT_IDLE: case ATT_CON_EST: att_build_idle_req(SC_INDEX, MODE_SYS_INFO_CHANGE); break; default: break; } } else { switch(GET_STATE(STATE_GPRS)) { case GPRS_PTM_BCCH: case GPRS_PAM_BCCH: /* * Due to the CR_IND GRR has released the TBF so we * have to correctly enter idle mode * to respect transition rules */ rr_data->gprs_data.page_mode = PAG_MODE_DEFAULT; SET_STATE (STATE_GPRS, GPRS_PIM_BCCH); att_return_to_idle(); break; default: break; } } break; case START_PROC_NORMAL_CR: att_start_cell_reselection (rr_data->gprs_data.cr_type); break; case START_PROC_NORMAL_CS: att_start_cell_selection (rr_data->gprs_data.cr_orig, CS_NOT_PARALLEL, rr_data->cs_data.current_search_mode); break; case START_PROC_CFG_CHG: /*XXX not ok*/ att_signal_gprs_support(); break; case START_PROC_GPRS_ACT: { PALLOC ( mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); TRACE_EVENT("START_PROC_GPRS_ACT----- "); rr_data->sc_data.mm_started = MM_ORIGINATED; if((rr_data->sc_data.cd.sys_info_read EQ ALL_SYS_INFO_READ) OR ((rr_data->sc_data.cd.sys_info_read | SYS_INFO_13_READ) EQ ALL_SYS_INFO_READ)) { rr_data->sc_data.cd.sys_info_read &= ~(SYS_INFO_13_READ); mph_mon_ctrl_req->si_to_read = UPDATE_SI13; if( rr_data->nc_data[SC_INDEX].si13_loc_ind EQ NORMAL_BCCH) { mph_mon_ctrl_req->action = START_MON_NBCCH; mph_mon_ctrl_req->si_to_read = UPDATE_SI13_GSM; } else mph_mon_ctrl_req->action = START_MON_EBCCH; } else { TRACE_EVENT ("START_PROC_GPRS_ACT: Read Complete SI"); rr_data->sc_data.cd.sys_info_read = NO_SYS_INFO_READ; mph_mon_ctrl_req->si_to_read = COMPLETE_SI; mph_mon_ctrl_req->action = START_MON_NBCCH; } PSENDX (PL, mph_mon_ctrl_req); TIMERSTART (T_RESELECT, TRESELECT_VALUE); } break; default: break; } rr_data->gprs_data.start_proc = START_PROC_NOTHING; PFREE(cr_rsp); } void att_gprs_sync_req( T_RRGRR_SYNC_REQ *sync_req) { GET_INSTANCE_DATA; switch(GET_STATE(STATE_GPRS)) { case GPRS_PIM_PBCCH: case GPRS_PTM_PBCCH: { memset (&rr_data->nc_data[CR_INDEX], 0, sizeof (T_NC_DATA)); rr_data->nc_data[CR_INDEX].arfcn = sync_req->arfcn; rr_data->nc_data[CR_INDEX].bsic = sync_req->bsic; att_start_cell_reselection_pbcch(MODE_CELL_RESELECTION_SYNC_ONLY); } break; default: break; } PFREE(sync_req); } void att_start_cell_reselection_gprs(UBYTE mode) { GET_INSTANCE_DATA; /*set start proc */ if(att_gprs_is_avail()) { UBYTE st = GET_STATE(STATE_ATT); if(st NEQ ATT_CS3 AND st NEQ ATT_CS2 AND st NEQ ATT_CS1) { att_rrgrr_cr_ind(CR_ABNORMAL); rr_data->gprs_data.start_proc = START_PROC_NORMAL_CR; rr_data->gprs_data.cr_type = mode; return; } } att_start_cell_reselection(mode); } void att_start_cell_selection_gprs(UBYTE originator,UBYTE search_mode) { GET_INSTANCE_DATA; /*set start proc*/ if(att_gprs_is_avail()) { UBYTE st = GET_STATE(STATE_ATT); if(st NEQ ATT_CS3 AND st NEQ ATT_CS2 AND st NEQ ATT_CS1) { if(originator EQ MM_ORIGINATED) { TRACE_EVENT("start_cs_gprs: MM_ORIG!"); att_rrgrr_cr_ind(CR_NORMAL); } else { att_rrgrr_cr_ind(CR_ABNORMAL); EM_FMM_RESEL_START_IND; } CS_SET_CURRENT_SEARCH_MODE(search_mode); rr_data->gprs_data.start_proc = START_PROC_NORMAL_CS; rr_data->gprs_data.cr_orig = originator; return; } } att_start_cell_selection(originator, CS_NOT_PARALLEL,search_mode); } void att_gprs_idle_req(T_MPH_IDLE_REQ* idle_req) { GET_INSTANCE_DATA; /* * At this point it is necessary to do the following things: * o send a CR_IND (optional) * o set the parameter gprs_support (if needed, the default has already been set before) * o set the parameter reorg_only (if needed) */ switch(idle_req->mod) { case MODE_CELL_SELECTION: if(GET_STATE(STATE_GPRS) EQ GPRS_NULL OR GET_STATE(STATE_GPRS) EQ GPRS_ACTIVATED) { idle_req->gprs_support = MPH_GPRS_PROCS_NOT_USED; } else { idle_req->gprs_support = MPH_GPRS_PROCS_USED; if(rr_data->gprs_data.page_mode EQ PAG_MODE_REORG) idle_req->reorg_only = REORG_ONLY; else idle_req->reorg_only = NORMAL_PGM; } break; case MODE_CONFIG_PL: idle_req->gprs_support = MPH_GPRS_PROCS_USED; break; case MODE_SYS_INFO_CHANGE: if(GET_STATE(STATE_GPRS) EQ GPRS_NULL OR GET_STATE(STATE_GPRS) EQ GPRS_ACTIVATED OR rr_data->ms_data.rr_service EQ LIMITED_SERVICE) { idle_req->gprs_support = MPH_GPRS_PROCS_NOT_USED; } else { idle_req->gprs_support = MPH_GPRS_PROCS_USED; idle_req->reorg_only = NORMAL_PGM; } break; default: break; } } BOOL att_gprs_check_ncell(void) { GET_INSTANCE_DATA; BOOL cell_ok; BOOL cell_barred; BOOL check_nw; BOOL roam_forb; BOOL plmn_equal; TRACE_EVENT_P1 ("att_gprs_check_ncell() cr_pbcch_active=%d", rr_data->gprs_data.cr_pbcch_active); if((rr_data->gprs_data.cr_pbcch_active) OR (rr_data->gprs_data.cr_pcco_active)) { /* Implements RR Clone findings #8 */ cell_barred = !att_cell_barred_status_cr_no_cr (CR_INDEX); check_nw = att_check_network (&rr_data->nc_data[CR_INDEX].lai); roam_forb = dat_roam_forb_lai_check (CR_INDEX); plmn_equal = dat_plmn_equal_req (rr_data->nc_data[CR_INDEX].lai.mcc, rr_data->nc_data[CR_INDEX].lai.mnc, rr_data->ms_data.plmn.mcc, rr_data->ms_data.plmn.mnc); TRACE_EVENT_P6 ( "r MCC/MNC=%x%x%x/%x%x%x", rr_data->ms_data.plmn.mcc[0], rr_data->ms_data.plmn.mcc[1], rr_data->ms_data.plmn.mcc[2], rr_data->ms_data.plmn.mnc[0], rr_data->ms_data.plmn.mnc[1], rr_data->ms_data.plmn.mnc[2]); TRACE_EVENT_P6 ( "i MCC/MNC=%x%x%x/%x%x%x", rr_data->nc_data[CR_INDEX].lai.mcc[0], rr_data->nc_data[CR_INDEX].lai.mcc[1], rr_data->nc_data[CR_INDEX].lai.mcc[2], rr_data->nc_data[CR_INDEX].lai.mnc[0], rr_data->nc_data[CR_INDEX].lai.mnc[1], rr_data->nc_data[CR_INDEX].lai.mnc[2]); TRACE_EVENT_P5 ("[%u] cb %d nw %d ro %d pl %d", rr_data->nc_data[CR_INDEX].arfcn, cell_barred, check_nw, roam_forb, plmn_equal); cell_ok = cell_barred AND check_nw AND roam_forb AND plmn_equal; if (cell_ok) { TRACE_EVENT_P2 ("NEW SC [%d]->[%d]", rr_data->nc_data[SC_INDEX].arfcn, rr_data->nc_data[CR_INDEX].arfcn); if(rr_data->ms_data.rr_service EQ LIMITED_SERVICE AND rr_data->ms_data.req_mm_service NEQ FUNC_LIM_SERV_ST_SRCH) { /* * We are in LIMITED service. * If the req_mm_service is FUNC_LIM_SERV_ST_SRCH we * will stay in LIMITED. * If we are in limited because of forbidden LAI we * enter FULL SERVICE. */ rr_data->ms_data.rr_service = FULL_SERVICE; } /* TIMERSTOP (T_RESELECT);*/ att_copy_cr_data (); memcpy (&rr_data->sc_data.cd, &rr_data->cr_data.cd, sizeof (T_CELL_DATA)); if (rr_data->old_serving_cell < SC_INDEX) rr_data->nc_data[rr_data->old_serving_cell].avail_time = PERIOD_700_SEC; rr_data->nc_data[CR_INDEX].arfcn = NOT_PRESENT_16BIT; rr_data->gprs_data.cr_pbcch_active = FALSE; if(GET_STATE(STATE_GPRS) EQ GPRS_PIM_BCCH OR GET_STATE(STATE_GPRS) EQ GPRS_ACTIVATED) { att_set_pl_in_idle_mode (); } else if (att_gprs_cell_has_pbcch()) { att_gprs_stop_pl(); } att_signal_gprs_support(); /* XXX ??? * set a barrier of 15 seconds for the next cell reselection * if it was a cell reselection due to C2(NC) > C2(SC) */ if (rr_data->sc_data.selection_type EQ CELL_RESELECTION_NC) TIMERSTART (T_NO_RESELECT, THIRTY_SEC/2); } else { /* * inform GRR that the currently chosen cell * not suitable and wait for the next rrgrr_cr_req */ att_cell_reselection_gprs_failed(); } return TRUE; } else { return FALSE; } } void att_cell_reselection_gprs_failed(void) { GET_INSTANCE_DATA; PALLOC_SDU(gprs_ind, RRGRR_GPRS_SI13_IND, MAX_L2_FRAME_SIZE * BITS_PER_BYTE); gprs_ind->cause = GPRS_CELL_NOT_SUITABLE; gprs_ind->serving_cell_info.bcch_arfcn = rr_data->nc_data[CR_INDEX].arfcn; gprs_ind->serving_cell_info.bcch_bsic = rr_data->nc_data[CR_INDEX].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__); SET_STATE(STATE_GPRS, GPRS_PIM_PBCCH); PSENDX(GRR, gprs_ind); } void att_gprs_start_task (T_RRGRR_START_TASK_REQ* start_task) { GET_INSTANCE_DATA; switch(GET_STATE(STATE_GPRS)) { case GPRS_PIM_PBCCH: case GPRS_PAM_PBCCH: case GPRS_PTM_PBCCH: switch(start_task->state) { case TASK_STATE_PTM: { PALLOC(mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); mph_mon_ctrl_req->action = ENTER_PTM_PBCCH; PSENDX (PL, mph_mon_ctrl_req); SET_STATE(STATE_GPRS, GPRS_PTM_PBCCH); } break; case TASK_STATE_PIM: { PALLOC(mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); mph_mon_ctrl_req->action = ENTER_PIM_PBCCH; PSENDX (PL, mph_mon_ctrl_req); SET_STATE(STATE_GPRS, GPRS_PIM_PBCCH); #ifdef REL99 if(rr_data->gprs_data.cbch_info_rxvd_in_ptm) { rr_data->gprs_data.cbch_info_rxvd_in_ptm = FALSE; att_config_cbch(); } #endif } break; case TASK_STATE_PAM: { SET_STATE(STATE_GPRS, GPRS_PAM_PBCCH); } break; default: break; } break; case GPRS_PIM_BCCH: case GPRS_PAM_BCCH: case GPRS_PTM_BCCH: switch(start_task->state) { case TASK_STATE_PTM: { PALLOC(mph_mon_ctrl_req, MPH_MON_CTRL_REQ ); mph_mon_ctrl_req->action = ENTER_PTM_BCCH; PSENDX (PL, mph_mon_ctrl_req); } break; default: break; } break; default: break; } { PALLOC(stop_cnf, RRGRR_START_TASK_CNF); PSENDX(GRR, stop_cnf); } PFREE(start_task); } void att_start_cell_reselection_pbcch(UBYTE mode) { GET_INSTANCE_DATA; att_init_cell_selection(CELL_RESELECTION, RR_ORIGINATED); att_init_pl_status (); rr_data->bcch_error = 0; 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(); srv_clear_list (&rr_data->cr_data.cd.ncell_list); dat_att_null(); rr_data->gprs_data.cr_pbcch_active = TRUE; SET_STATE (STATE_ATT, ATT_CS3); att_build_idle_req (CR_INDEX, mode); } /* +------------------------------------------------------------------------------ | Function : rr_ext_meas_can_start +------------------------------------------------------------------------------ | Description : Check if the Ext Meas procedure can be performed. | | Parameters : none | +------------------------------------------------------------------------------ */ static BOOL rr_ext_meas_can_start ( void ) { GET_INSTANCE_DATA; if( GET_STATE(STATE_ATT) EQ ATT_IDLE ) { if( (GET_STATE(STATE_GPRS) EQ GPRS_PIM_BCCH) OR (GET_STATE ( STATE_GPRS ) EQ GPRS_PIM_PBCCH) ) return TRUE; } return FALSE; } /* +------------------------------------------------------------------------------ | Function : att_rrgrr_ext_meas_req +------------------------------------------------------------------------------ | Description : Start Extended Measurement (GPRS) at RR. | | Parameters : *rrgrr_ext_meas_req - Frequencies to be measured | +------------------------------------------------------------------------------ */ GLOBAL void att_rrgrr_ext_meas_req ( T_RRGRR_EXT_MEAS_REQ *rrgrr_ext_meas_req ) { GET_INSTANCE_DATA; T_GPRS_DATA *gprs_data = &rr_data->gprs_data; UBYTE i,n; T_arfcn_idx *s; USHORT *d; /* Store the primitive 'rrgrr_ext_meas_req' during the Ext Meas procedure. */ if ( gprs_data->rrgrr_ext_meas_req NEQ NULL AND gprs_data->rrgrr_ext_meas_req NEQ rrgrr_ext_meas_req ) { PFREE ( gprs_data->rrgrr_ext_meas_req ); } gprs_data->rrgrr_ext_meas_req = rrgrr_ext_meas_req; if ( rr_ext_meas_can_start() ) { PALLOC ( mph_ext_meas_req, MPH_EXT_MEAS_REQ ); SET_STATE (STATE_CELL_SEL, CS_XMEAS); n = rrgrr_ext_meas_req->c_arfcn_idx; if ( n > RRGRR_MAX_ARFCN_EXT_MEAS ) { n = RRGRR_MAX_ARFCN_EXT_MEAS; TRACE_ERROR ( "cut freq list (in)" ); } if ( n > MAX_CHANNELS ) { n = MAX_CHANNELS; TRACE_ERROR ( "cut freq list (out)" ); } mph_ext_meas_req->num_of_chan = n; d = &mph_ext_meas_req->arfcn[0]; s = &rrgrr_ext_meas_req->arfcn_idx[0]; for ( i = 0; i < n; ++i, ++s, ++d ) *d = s->arfcn; /* Other elements of mph_ext_meas_req remain uninitialized here (set in ALR). */ mph_ext_meas_req->freq_bands = cs_get_freq_band(FALSE); gprs_data->ext_meas_ctrl = 0; PSENDX (PL, mph_ext_meas_req); } else { PALLOC ( rrgrr_ext_meas_cnf, RRGRR_EXT_MEAS_CNF ); rrgrr_ext_meas_cnf->c_xmeas_res = 0; rrgrr_ext_meas_cnf->xmeas_cause = EXT_MEAS_RESET; rrgrr_ext_meas_cnf->call_ref = rrgrr_ext_meas_req->call_ref; PSENDX ( GRR, rrgrr_ext_meas_cnf ); PFREE ( rrgrr_ext_meas_req ); gprs_data->rrgrr_ext_meas_req = NULL; } return; } /* +------------------------------------------------------------------------------ | Function : rr_ext_meas_idx +------------------------------------------------------------------------------ | Description : Retrieve InDeX associated to ARFCN during | Extended Measurement (GPRS). | | Parameters : ARFCN - channel number in 'rrgrr_ext_meas_req' | +------------------------------------------------------------------------------ */ GLOBAL UBYTE rr_ext_meas_idx (USHORT arfcn ) { GET_INSTANCE_DATA; UBYTE i,n; T_arfcn_idx *arfcn_idx; T_RRGRR_EXT_MEAS_REQ *rrgrr_ext_meas_req; rrgrr_ext_meas_req = rr_data->gprs_data.rrgrr_ext_meas_req; if ( rrgrr_ext_meas_req EQ NULL ) { return NOT_PRESENT_8BIT; } n = rrgrr_ext_meas_req->c_arfcn_idx; arfcn_idx = &rrgrr_ext_meas_req->arfcn_idx[0]; for ( i = 0; i < n; ++i, ++arfcn_idx ) { if ( arfcn_idx->arfcn EQ arfcn ) return arfcn_idx->idx; } return NOT_PRESENT_8BIT; } /* +------------------------------------------------------------------------------ | Function : rr_ext_meas_end +------------------------------------------------------------------------------ | Description : Deallocate memory used during Extended Measurement (GPRS). | This function is called in three scenarios: | (1) System start (pei_init) | (2) Cell Change triggered via gprs_init_gprs_data | (3) End of Extended Measurement procedure | | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void att_ext_meas_end ( BOOL destory_rrgrr_ext_meas_cnf ) { GET_INSTANCE_DATA; /* Note : If att_ext_meas_end is called via gprs_init_gprs_data and * Ext Meas is running, then a repsonse from Lower Layers is still * to be expected, which will be ignored. */ T_GPRS_DATA *gprs_data = &rr_data->gprs_data; if ( gprs_data->rrgrr_ext_meas_req NEQ NULL ) { PFREE ( gprs_data->rrgrr_ext_meas_req ); gprs_data->rrgrr_ext_meas_req = NULL; } if ( gprs_data->rrgrr_ext_meas_cnf NEQ NULL ) { if ( destory_rrgrr_ext_meas_cnf ) { PFREE ( gprs_data->rrgrr_ext_meas_cnf ); } gprs_data->rrgrr_ext_meas_cnf = NULL; } if ( gprs_data->mph_ext_meas_cnf NEQ NULL ) { PFREE ( gprs_data->mph_ext_meas_cnf ); gprs_data->mph_ext_meas_cnf = NULL; } if ( (gprs_data->ext_meas_ctrl & EXT_MEAS_START_CR) NEQ 0 ) { /* handle the outstanding Cell Reselection request */ gprs_data->ext_meas_ctrl &= ~EXT_MEAS_START_CR; att_start_cell_reselection(rr_data->sc_data.selection_type); } gprs_data->ext_meas_ctrl = 0; } /* +------------------------------------------------------------------------------ | Function : att_ext_meas_next_bsic +------------------------------------------------------------------------------ | Description : Check for next BSIC scanning during Extended Measurement. | If all BSICs are scanned, then a response is sent to GRR. | | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void att_ext_meas_next_bsic (void) { GET_INSTANCE_DATA; T_GPRS_DATA *gprs_data = &rr_data->gprs_data; T_RRGRR_EXT_MEAS_REQ *rrgrr_ext_meas_req = gprs_data->rrgrr_ext_meas_req; 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; UBYTE stop = gprs_data->ext_meas_ctrl & EXT_MEAS_RESET; if ( (rrgrr_ext_meas_req->report_type EQ REP_TYPE_1 OR rrgrr_ext_meas_req->report_type EQ REP_TYPE_2 ) AND rrgrr_ext_meas_cnf->c_xmeas_res >= 6 OR rrgrr_ext_meas_cnf->c_xmeas_res >= RRGRR_MAX_ARFCN_EXT_MEAS OR n >= mph_ext_meas_cnf->num_of_chan OR stop ) { /* stop PLMN search at lower layers */ PALLOC (mph_sync_req, MPH_SYNC_REQ); mph_sync_req->cs = CS_STOP_PLMN_SEARCH; PSENDX (PL, mph_sync_req); } else { PALLOC ( mph_bsic_req, MPH_BSIC_REQ ); mph_bsic_req->arfcn = mph_ext_meas_cnf->arfcn[n]; PSENDX ( PL, mph_bsic_req ); } } /* +------------------------------------------------------------------------------ | Function : att_mph_ext_meas_cnf +------------------------------------------------------------------------------ | Description : Evaluate rxlev during Start Extended Measurement (GPRS). | | Parameters : *mph_ext_meas_cnf - ARFCNs and RXLEVs from MPH | +------------------------------------------------------------------------------ */ GLOBAL void att_mph_ext_meas_cnf ( T_MPH_EXT_MEAS_CNF *mph_ext_meas_cnf ) { GET_INSTANCE_DATA; T_GPRS_DATA *gprs_data = &rr_data->gprs_data; T_RRGRR_EXT_MEAS_REQ *rrgrr_ext_meas_req = gprs_data->rrgrr_ext_meas_req; /* Check that Ext Meas is still active at RR */ if ( rrgrr_ext_meas_req NEQ NULL ) { PALLOC ( rrgrr_ext_meas_cnf, RRGRR_EXT_MEAS_CNF ); gprs_data->rrgrr_ext_meas_cnf = rrgrr_ext_meas_cnf; /* Depending on the Reporting Type either obtain BSICs or respond immediately. */ if ( rrgrr_ext_meas_req->report_type EQ REP_TYPE_1 OR rrgrr_ext_meas_req->report_type EQ REP_TYPE_2 ) { /* allocate RRGRR_EXT_MEAS_CNF, save mph_ext_meas_cnf and send initial BSIC_REQ */ rrgrr_ext_meas_cnf->c_xmeas_res = 0; gprs_data->mph_ext_meas_cnf = mph_ext_meas_cnf; gprs_data->mph_ext_meas_num = 0; att_ext_meas_next_bsic(); } else { /* With REP_TYPE_3 no BSIC scanning is needed, RRGRR_EXT_MEAS_CNF is sent. */ /* Note: the premature end of the Ext Meas procedure could have been requested, */ /* but this 'normal' procedure end is performed instead (now). */ UBYTE i,n; T_xmeas_res *xmeas_res; PALLOC (mph_sync_req, MPH_SYNC_REQ); n = mph_ext_meas_cnf->num_of_chan; if ( n > RRGRR_MAX_ARFCN_EXT_MEAS ) { n = RRGRR_MAX_ARFCN_EXT_MEAS; TRACE_ERROR ( "cut freq list (meas_cnf)" ); } rrgrr_ext_meas_cnf->c_xmeas_res = n; xmeas_res = &rrgrr_ext_meas_cnf->xmeas_res[0]; for ( i = 0; i < n; ++i, ++xmeas_res ) { USHORT arfcn = mph_ext_meas_cnf->arfcn[i] & ARFCN_MASK; UBYTE idx = rr_ext_meas_idx ( arfcn ); xmeas_res->arfcn_idx.arfcn = arfcn; xmeas_res->arfcn_idx.idx = idx; xmeas_res->rxlev = mph_ext_meas_cnf->rx_lev[i]; xmeas_res->bsic = 0; } PFREE(mph_ext_meas_cnf); mph_sync_req->cs = CS_STOP_PLMN_SEARCH; PSENDX (PL, mph_sync_req); } } else { PFREE(mph_ext_meas_cnf); } return; } /* +------------------------------------------------------------------------------ | Function : att_rrgrr_ext_meas_stop_req +------------------------------------------------------------------------------ | Description : Premature stop of Extended Measurement (GPRS). | | Parameters : *rrgrr_ext_meas_stop_req - Signal. | +------------------------------------------------------------------------------ */ GLOBAL void att_rrgrr_ext_meas_stop_req ( T_RRGRR_EXT_MEAS_STOP_REQ *rrgrr_ext_meas_stop_req) { GET_INSTANCE_DATA; 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_stop_req) PFREE ( rrgrr_ext_meas_stop_req ); if ( rrgrr_ext_meas_req EQ NULL ) return; gprs_data->ext_meas_ctrl |= EXT_MEAS_RESET; /* Continue the stop of the Ext Meas procedure with the next response from Lower Layers. */ } /* +------------------------------------------------------------------------------ | Function : att_rrgrr_standby_ind +------------------------------------------------------------------------------ | Description : Store information that MS is in Standby State. | | Parameters : T_RRGRR_STANDBY_STATE_IND | +------------------------------------------------------------------------------ */ void att_rrgrr_standby_ind(T_RRGRR_STANDBY_STATE_IND* stdby) { GET_INSTANCE_DATA; rr_data->gprs_data.ready_state = FALSE; PFREE(stdby); } /* +------------------------------------------------------------------------------ | Function : att_rrgrr_ready_ind +------------------------------------------------------------------------------ | Description : Store information that MS is in Ready State. | | Parameters : T_RRGRR_READY_STATE_IND | +------------------------------------------------------------------------------ */ void att_rrgrr_ready_ind(T_RRGRR_READY_STATE_IND* rdy) { GET_INSTANCE_DATA; rr_data->gprs_data.ready_state = TRUE; PFREE(rdy); } #ifdef REL99 /* +------------------------------------------------------------------------------ | Function : att_rrgrr_cbch_info_ind +------------------------------------------------------------------------------ | Description : Stores the CBCH configuration received from GRR. | This information corresponds to the cbch channel | description received on PBCCH. | This primitive upates RR with latest CBCH information | whenever new PSI8, PSI2 or PSI13 is received by GRR | in PIM or PTM. This primitive should not come when | the mobile has camped on a R97/98 network. | | Parameters : cbch_inf points to RRGRR_CBCH_INFO_IND primitive. | +------------------------------------------------------------------------------ */ void att_rrgrr_cbch_info_ind(T_RRGRR_CBCH_INFO_IND* cbch_inf) { GET_INSTANCE_DATA; /* we should now be in R-99 network and in a cell having * pbcch. Otherwise this message should not be received. */ TRACE_FUNCTION("att_rrgrr_cbch_info_ind"); if(att_gprs_get_nw_release() AND att_gprs_cell_has_pbcch()) { /* Store the CBCH configuration in serving cell context */ TRACE_EVENT("CBCH info on PBCCH received"); rr_data->gprs_data.cbch_psi_valid = TRUE; memcpy(&(rr_data->gprs_data.cbch_psi8),&(cbch_inf->cbch),sizeof(T_cbch)); if( GET_STATE(STATE_ATT) EQ ATT_IDLE) { att_config_cbch(); } } else { TRACE_ERROR( " CBCH Info received when PBCCH not present or when in R97 cell"); } PFREE(cbch_inf); } #endif /* +------------------------------------------------------------------------------ | Function : is_nc2_used +------------------------------------------------------------------------------ | Description : Check if the cell reselection should be done | or not. | Parameters : none | Return Value: TRUE -> don't do cell reselection | FALSE -> do cell reselection +------------------------------------------------------------------------------ */ BOOL is_nc2_used(void) { GET_INSTANCE_DATA; BOOL ret = FALSE; UBYTE st = GET_STATE(STATE_GPRS); TRACE_FUNCTION("is_nc2_used()"); if (st EQ GPRS_NULL OR st EQ GPRS_ACTIVATED) return ret; /* * Check: * Ready State * NC mode of PMO * NC mode of SI13 */ TRACE_EVENT_P3("nc2: rdy: %d, pmo_nc: %d, si13 nc: %d", rr_data->gprs_data.ready_state, rr_data->gprs_data.nc_mode_of_pmo, rr_data->gprs_data.is_nc2_used_in_si13); if(rr_data->gprs_data.ready_state) { /* we are in READY */ if(rr_data->gprs_data.nc_mode_of_pmo NEQ NC_MODE_RESET) { if(rr_data->gprs_data.nc_mode_of_pmo EQ NC2_USED) ret = TRUE; else ret = FALSE; } else { /* use SI13 NC mode */ ret = rr_data->gprs_data.is_nc2_used_in_si13; } } else { /* we are in STANDBY */ /* in STANDBY NC mode is not used */ ret = FALSE; } return ret; } #ifdef REL99 /* +------------------------------------------------------------------------------ | Function : att_gprs_get_nw_release +------------------------------------------------------------------------------ | Description : returns the network release received in SI 13 | Parameters : none | Return Value: RR_GPRS_R97, RR_GPRS_R99 depending on the network | release. +------------------------------------------------------------------------------ */ UBYTE att_gprs_get_nw_release(void) { GET_INSTANCE_DATA; return rr_data->gprs_data.nw_release; } #endif /*===========================================================================*/ /* */ /* */ /* L O C A L S */ /* */ /* */ /*===========================================================================*/ /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_get_scell_info | +-----------------------------------------------------------------------------+ PURPOSE : fill the serving cell struct */ static void att_get_scell_info (T_serving_cell_info* sc, UBYTE idx) { GET_INSTANCE_DATA; sc->gprs_ms_txpwr_max_cch = rr_data->nc_data[idx].select_para.ms_txpwr_max_cch; sc->gprs_rxlev_access_min = rr_data->nc_data[idx].select_para.rxlev_access_min; sc->bcch_arfcn = rr_data->nc_data[idx].arfcn; sc->bcch_bsic = rr_data->nc_data[idx].bsic; sc->ac_class = rr_data->nc_data[idx].rach.ac; /* air-interface coding */ sc->pwr_offset = (UBYTE)(rr_data->nc_data[idx].c2_par.power_off_ind ? rr_data->nc_data[idx].c2_par.power_off : 0); if (!(dat_forb_lai_check (SC_INDEX) AND dat_roam_forb_lai_check (SC_INDEX))) sc->limited = 1; else sc->limited = (UBYTE)(rr_data->ms_data.rr_service EQ LIMITED_SERVICE); sc->rr_cell_env.plmn.v_plmn = TRUE; memcpy (sc->rr_cell_env.plmn.mcc, rr_data->nc_data[idx].lai.mcc, SIZE_MCC); memcpy (sc->rr_cell_env.plmn.mnc, rr_data->nc_data[idx].lai.mnc, SIZE_MNC); sc->rr_cell_env.lac = rr_data->nc_data[idx].lai.lac; sc->rr_cell_env.cid = rr_data->nc_data[idx].cell_id; sc->bs_pa_mfrms = rr_data->nc_data[idx].control_descr.bs_pa_mfrms; } /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_gprs_store_nc_mode | +-----------------------------------------------------------------------------+ PURPOSE : store the NC mode of SI13 */ static void att_gprs_store_nc_mode(T_D_SYS_INFO_13* sys_info_13) { GET_INSTANCE_DATA; if( !sys_info_13->si13_rest_oct.si13_info.flag1 AND sys_info_13->si13_rest_oct.si13_info.nco EQ NCO_NET_RESEL) { rr_data->gprs_data.is_nc2_used_in_si13 = TRUE; } else { rr_data->gprs_data.is_nc2_used_in_si13 = FALSE; } } #ifdef REL99 /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : att_gprs_store_nw_release | +-----------------------------------------------------------------------------+ PURPOSE : stores the network release received in si13 */ static void att_gprs_store_nw_release(T_D_SYS_INFO_13* sys_info_13) { GET_INSTANCE_DATA; if(sys_info_13->si13_rest_oct.v_si13_info) { if(sys_info_13->si13_rest_oct.si13_info.v_sgsnr) { rr_data->gprs_data.nw_release = RR_GPRS_R99; } else { rr_data->gprs_data.nw_release = RR_GPRS_R97; } } else { rr_data->gprs_data.nw_release = RR_GPRS_R97; } } #ifdef TI_PS_FF_EMR /* +-----------------------------------------------------------------------------+ | PROJECT : GSM-GPRS (6147) MODULE : RR_GPRS | | STATE : code ROUTINE : attg_send_enh_para_to_grr | +-----------------------------------------------------------------------------+ PURPOSE : To format and send a primitive indicating enhanced measurement parameters received from SI-2quater. */ GLOBAL void att_send_enh_para_to_grr(T_rr_enh_para *p_src) { PALLOC(p_enh,RRGRR_SI2QUATER_IND); TRACE_FUNCTION("att_send_enh_para_to_grr"); p_enh->rep_type = p_src->grr_rep_type; p_enh->enh_para_struct = p_src->enh_para; p_enh->nc_para_struct = p_src->nc_para; PSENDX(GRR, p_enh); return; } #endif #endif #endif /* GPRS */ #endif /* !RR_GPRS_C */