FreeCalypso > hg > fc-magnetite
view src/g23m-gprs/grr/grr_f.c @ 588:f2e752052db5
beginning of SE J100 target support
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Wed, 13 Mar 2019 18:08:34 +0000 |
| parents | 219afcfc6250 |
| children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : GPRS (8441) | Modul : GRR +----------------------------------------------------------------------------- | Copyright 2002 Texas Instruments Berlin, AG | All rights reserved. | | This file is confidential and a trade secret of Texas | Instruments Berlin, AG | The receipt of or possession of this file does not convey | any rights to reproduce or disclose its contents or to | manufacture, use, or sell anything it may describe, in | whole, or in part, without the specific written consent of | Texas Instruments Berlin, AG. +----------------------------------------------------------------------------- | Purpose: This module implements global functions for GRR +----------------------------------------------------------------------------- */ #ifndef GRR_F_C #define GRR_F_C #endif #define ENTITY_GRR #ifdef _SIMULATION_ /* * Report warning 4005 as an error. * * There are identical macro definitons in the GRR message and the RRGRR SAP * document which should be aligned at all the time * (e.g. GPRS_RXLEV_ACCESS_MIN_INVALID, GPRS_MS_TXPWR_MAX_CCH, etc.) */ #pragma warning( error : 4005 ) #endif /* #ifdef _SIMULATION_ */ /*==== INCLUDES =============================================================*/ #include <stdio.h> #include <string.h> /* to get definition of memcpy() */ #include <math.h> #include "typedefs.h" /* to get Condat data types */ #include "vsi.h" /* to get a lot of macros */ #include "macdef.h" #include "gprs.h" #include "gsm.h" /* to get a lot of macros */ #include "ccdapi.h" /* to get CCD API */ #include "cnf_grr.h" /* to get cnf-definitions */ #include "mon_grr.h" /* to get mon-definitions */ #include "prim.h" /* to get the definitions of used SAP and directions */ #include "message.h" /* to get message describtion */ #include "pcm.h" #include "grr.h" /* to get the global entity definitions */ #include "grr_f.h" /* to check own definitions */ #include "grr_ctrlf.h" /* to get definition of ctrl_init() */ #include "grr_tcf.h" /* to get definition of tc_init() */ #include "grr_cpapf.h" /* to get definition of cpap_init() */ #include "grr_psif.h" /* to get definition of psi_init() */ #include "grr_pgf.h" /* to get definition of pg_init() */ #include "grr_gfpf.h" /* to get definition of gfp_init() */ #include "grr_meass.h" /* to get definition of meas_init() */ #include "grr_csf.h" /* to get definition of cs_init() */ #include "grr_tcs.h" #include "grr_em.h" /*for Engineering mode*/ /*==== CONST ================================================================*/ /* * Mask- and shift tables for use with macro GET_N_BITS(N) */ static const UBYTE maskTab1[] = { 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF }; static const UBYTE maskTab2[] = { 0xFF, 0x7F, 0x3F, 0x1F, 0x0F, 0x07, 0x03, 0x01 }; static const UBYTE shiftTab[] = { 0x00, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; /*==== DIAGNOSTICS ==========================================================*/ /*==== LOCAL VARS ===========================================================*/ static UBYTE* pBuf; /* Global Var: pointer to air message data buffer */ static int startBit; /* Global Var: current pBuf decode offset */ static int bitLen; /* Global Var: current remaining undecoded pbuf bits */ LOCAL T_LIST _local_dummy_list; LOCAL T_f_range _local_rfl_contents; /*==== GLOBAL VARS ===========================================================*/ /*==== LOCAL MACROS =========================================================*/ /* * GET_N_BITS reads next N (1..8) bits from UBYTE* pBuf, starting from integer * startBit. N is added to startBit and removed from bitLen after call to this * macro. */ #define GET_N_BITS(N) \ (( (startBit%8) + (N) <= 8) \ ? (pBuf[startBit/8] >> shiftTab[(startBit+(N))%8]) & maskTab1[N] \ : (pBuf[(startBit+(N))/8] >> shiftTab[(startBit+(N))%8]) + \ ((pBuf[startBit/8] & maskTab2[startBit%8]) << ((startBit+(N))%8)) \ ); startBit += (N); bitLen -= (N) /*==== FUNCTIONS PROTOTYPES =================================================*/ LOCAL BOOL grr_check_request_reference ( T_req_ref_p * req_ref_i ); LOCAL BOOL grr_check_glob_tfi ( T_glob_tfi * glob_tfi_i, UBYTE tn ); LOCAL BOOL grr_check_add_reject ( UBYTE tn ); LOCAL BOOL grr_check_add_1 ( T_add1 * add1_i,UBYTE tn ); LOCAL BOOL grr_check_add_2 ( T_add2 * add2_i,UBYTE tn ); LOCAL BOOL grr_check_add_3 ( T_add3 * add3_i,UBYTE tn ); LOCAL BOOL grr_check_add_4 ( T_add4 * add4_i,UBYTE tn ); LOCAL void grr_clean_up_seg_ctrl_blk_tbl ( void ); LOCAL void grr_align_seg_ctrl_blk_nxt ( void ); LOCAL UBYTE grr_decode_ie_tlli (BUF_tlli_value* tlli); LOCAL UBYTE grr_decode_ie_pta (T_pta* pta); LOCAL UBYTE grr_decode_ie_pwr_par (T_pwr_par* pwr_par); LOCAL UBYTE grr_decode_ie_glob_tfi (T_glob_tfi* glob_tfi); LOCAL UBYTE grr_decode_ie_meas_map (T_meas_map* meas_map); LOCAL UBYTE grr_decode_ie_tbf_s_time (T_tbf_s_time* tbf_s_time); LOCAL UBYTE grr_decode_ie_dyn_alloc_p (T_dyn_alloc_p* dyn_alloc_p); LOCAL UBYTE grr_decode_ie_dyn_alloc_ts (T_dyn_alloc_ts* dyn_alloc_ts); LOCAL UBYTE grr_decode_ie_freq_par (T_freq_par* freq_par); LOCAL UBYTE grr_decode_dl_assignment (UBYTE* buf, int off, int len); LOCAL UBYTE grr_decode_ul_assignment (UBYTE* buf, int off, int len); LOCAL UBYTE grr_decode_ts_reconfig (UBYTE* buf, int off, int len); LOCAL UBYTE grr_decode_pdch_release (UBYTE* buf, int off, int len); LOCAL UBYTE grr_decode_polling_req (UBYTE* buf, int off, int len); LOCAL UBYTE grr_decode_tbf_release_req (UBYTE* buf, int off, int len); #ifdef REL99 LOCAL UBYTE grr_decode_ie_egprs_link_adpt_para(T_egprs_link_adpt_para *trgt); LOCAL UBYTE grr_decode_ie_compact_red_ma(T_compact_red_ma *trgt); #endif LOCAL void grr_init_ms_data ( void ); /* * transmit power control */ LOCAL void grr_set_alpha_flags ( BOOL v_alpha, UBYTE alpha ); LOCAL void grr_set_sngl_gamma ( UBYTE gamma, UBYTE tn ); /* * NC and extended measurements */ LOCAL void grr_init_rfreq_list ( T_NC_RFREQ_LIST *list ); LOCAL void grr_init_ncmeas_struct ( T_NCMEAS *ncmeas, BOOL is_cw ); LOCAL void grr_copy_em1_struct ( T_XMEAS_EM1 *db_em1, T_em1 *ext_em1, BOOL cpy_prm_set, UBYTE *start_ext_lst_idx, UBYTE *stop_ext_lst_idx ); /* * database management */ LOCAL void grr_init_db_srvc_param ( T_SC_DATABASE *db ); LOCAL UBYTE grr_get_db_num ( T_SC_DATABASE *db ); /* * miscellaneous */ LOCAL void grr_mrk_ext_lst_freq ( T_EXT_FREQ_LIST *list ); LOCAL UBYTE grr_ccd_error_handling ( UBYTE entity_i ); LOCAL void grr_get_si_cell_alloc_list ( T_LIST *list ); LOCAL BOOL grr_get_psi_cell_alloc_list ( T_LIST *list ); LOCAL BOOL grr_get_ms_alloc_list ( T_LIST *list, const T_gprs_ms_alloc_ie *ms_alloc ); /*==== FUNCTIONS ============================================================*/ /* +------------------------------------------------------------------------------ | Function : grr_check_request_reference +------------------------------------------------------------------------------ | Description : The function grr_check_request_reference() compares the addresses | in req_ref_i with the entity data ent returns TRUE if the address | in req_ref_i is valid otherwise FALSE | | Parameters : tlli_i - ptr to tlli buffer | +------------------------------------------------------------------------------ */ LOCAL BOOL grr_check_request_reference ( T_req_ref_p * req_ref_i ) { BOOL result = FALSE; UBYTE i,t1,t2,t3; USHORT acc_inf; t1 = req_ref_i->fn_mod.t1; t2 = req_ref_i->fn_mod.t2; t3 = req_ref_i->fn_mod.t3; acc_inf = req_ref_i->access_info; TRACE_FUNCTION( "grr_check_request_reference" ); for(i=0;i<3;i++) { if( (grr_data->req_ref[i].fn_mod.t1 EQ t1 ) AND (grr_data->req_ref[i].fn_mod.t2 EQ t2 ) AND (grr_data->req_ref[i].fn_mod.t3 EQ t3 ) AND (grr_data->req_ref[i].access_info EQ acc_inf ) ) { result = TRUE; break; } } if(!result) { TRACE_EVENT("grr_check_request_reference failed"); } return(result); } /* grr_check_request_reference() */ /* +------------------------------------------------------------------------------ | Function : grr_check_glob_tfi(); +------------------------------------------------------------------------------ | Description : The function grr_check_glob_tfi() returns true if the TFI | is correct. | | Parameters : glob_tfi_i - pointer to global TFI structure | tn - timeslot on which the message is received, this is | required, because tfi is valid only for one | direction and the assigned PDCHs of a TBF(4.60 5.2) | +------------------------------------------------------------------------------ */ LOCAL BOOL grr_check_glob_tfi ( T_glob_tfi * glob_tfi_i, UBYTE tn ) { BOOL result = FALSE; TRACE_FUNCTION( "grr_check_glob_tfi" ); if(glob_tfi_i->v_ul_tfi) { if((glob_tfi_i->ul_tfi EQ grr_data->uplink_tbf.tfi) AND ((0x80>>tn) & grr_data->uplink_tbf.ts_mask)) { result = TRUE; } } else if(glob_tfi_i->v_dl_tfi) { if((glob_tfi_i->dl_tfi EQ grr_data->downlink_tbf.tfi) AND ((0x80>>tn) & grr_data->downlink_tbf.ts_mask)) { result = TRUE; } } if(!result) { if(glob_tfi_i->v_ul_tfi) { TRACE_EVENT_P7("grr_check_glob_tfi failed: UL addressed tfi=%d, ul_tfi=%d, dl_tfi=%d || tn=%d ->mask=%x curr_mask=%x, st_mask=%x ", glob_tfi_i->ul_tfi, grr_data->uplink_tbf.tfi, grr_data->downlink_tbf.tfi, tn, 0x80>>tn, grr_data->uplink_tbf.ts_mask, grr_data->uplink_tbf.ts_usage); } else if(glob_tfi_i->v_dl_tfi) { TRACE_EVENT_P7("grr_check_glob_tfi failed: DL addressed tfi=%d, ul_tfi=%d, dl_tfi=%d|| tn=%d ->mask=%x curr_mask=%x, st_mask=%x ", glob_tfi_i->dl_tfi, grr_data->uplink_tbf.tfi, grr_data->downlink_tbf.tfi, tn, 0x80>>tn, grr_data->downlink_tbf.ts_mask, grr_data->downlink_tbf.ts_usage); } else { TRACE_EVENT("grr_check_glob_tfi failed: NO addressed tfi "); } } return(result); } /* grr_check_glob_tfi() */ /* +------------------------------------------------------------------------------ | Function : grr_check_add_reject +------------------------------------------------------------------------------ | Description : The function grr_check_add_reject() checks the address in | addtional rejects in a Packet Access Reject. | | Parameters : tn - timeslot: need to check if tfi is on assigned PDCH | +------------------------------------------------------------------------------ */ LOCAL BOOL grr_check_add_reject ( UBYTE tn ) { MCAST(access_rej,D_ACCESS_REJ); BOOL result = FALSE; TRACE_FUNCTION( "grr_check_add_reject" ); if(access_rej->reject.v_tlli_value) result = grr_check_all_tlli(& access_rej->reject.tlli_value); else if (access_rej->reject.req_ref_tfi.v_req_ref_p) result = grr_check_request_reference( & access_rej->reject.req_ref_tfi.req_ref_p); else if (access_rej->reject.req_ref_tfi.v_glob_tfi) result = grr_check_glob_tfi(& access_rej->reject.req_ref_tfi.glob_tfi,tn); /* SZML-SGLBL/004 */ return(result); } /* grr_check_add_reject() */ /* +------------------------------------------------------------------------------ | Function : grr_check_add_1 +------------------------------------------------------------------------------ | Description : The function grr_check_add_1() compares address (add1). | | Parameters : add1_i - pointer to address structure to check | tn - timeslot: need to check if tfi is on assigned PDCH | +------------------------------------------------------------------------------ */ LOCAL BOOL grr_check_add_1 ( T_add1 * add1_i,UBYTE tn ) { BOOL result = FALSE; TRACE_FUNCTION( "grr_check_add_1" ); if(add1_i->v_glob_tfi) result = grr_check_glob_tfi( & add1_i->glob_tfi,tn ); else if (add1_i->v_tlli_value) result = grr_check_all_tlli(& add1_i->tlli_value); return(result); } /* grr_check_add_1() */ /* +------------------------------------------------------------------------------ | Function : grr_check_add_2 +------------------------------------------------------------------------------ | Description : The function grr_check_add_2() checks address structure 2(add2). | | Parameters : add2_i - pointer address structure to check | tn - timeslot: need to check if tfi is on assigned PDCH | +------------------------------------------------------------------------------ */ LOCAL BOOL grr_check_add_2 ( T_add2 * add2_i,UBYTE tn ) { BOOL result = FALSE; TRACE_FUNCTION( "grr_check_add_2" ); if(add2_i->v_glob_tfi) result = grr_check_glob_tfi( & add2_i->glob_tfi,tn ); else if (add2_i->v_tlli_value) result = grr_check_all_tlli(& add2_i->tlli_value); else if (add2_i->v_tqi) result = (add2_i->tqi EQ grr_data->tqi); return(result); } /* grr_check_add_2() */ /* +------------------------------------------------------------------------------ | Function : grr_check_add_3 +------------------------------------------------------------------------------ | Description : The function grr_check_add_3() checks address structure 3(add3). | | Parameters : add3_i - address of address structure to check | tn - timeslot: need to check if tfi is on assigned PDCH | +------------------------------------------------------------------------------ */ LOCAL BOOL grr_check_add_3 ( T_add3 * add3_i,UBYTE tn ) { BOOL result = FALSE; TRACE_FUNCTION( "grr_check_add_3" ); if(add3_i->v_glob_tfi) result = grr_check_glob_tfi( & add3_i->glob_tfi,tn ); else if (add3_i->v_tlli_value) result = grr_check_all_tlli(& add3_i->tlli_value); else if (add3_i->v_tqi) result = (add3_i->tqi EQ grr_data->tqi); else if (add3_i->v_req_ref_p) result = grr_check_request_reference( & add3_i->req_ref_p); return(result); } /* grr_check_add_3() */ /* The following function is added for handling address 4*/ /* +------------------------------------------------------------------------------ | Function : grr_check_add_4 +------------------------------------------------------------------------------ | Description : The function grr_check_add_4() checks address structure 4(add4). | | Parameters : add4_i - address of address structure to check | +------------------------------------------------------------------------------ */ LOCAL BOOL grr_check_add_4 ( T_add4 * add4_i,UBYTE tn ) { BOOL result = FALSE; TRACE_FUNCTION( "grr_check_add_4" ); if(add4_i->v_glob_tfi) result = grr_check_glob_tfi( & add4_i->glob_tfi,tn ); else if (add4_i->tqi_req_ref_p.v_tqi) result = (add4_i->tqi_req_ref_p.tqi EQ grr_data->tqi); else if (add4_i->tqi_req_ref_p.v_req_ref_p) result = grr_check_request_reference( & add4_i->tqi_req_ref_p.req_ref_p); return(result); } /* grr_check_add_4() */ /* +------------------------------------------------------------------------------ | Function : grr_clean_up_seg_ctrl_blk_tbl +------------------------------------------------------------------------------ | Description : The function grr_clean_up_seg_ctrl_blk_tbl() checks the table | for old entries to be 'deleted'. | | Parameters : no | +------------------------------------------------------------------------------ */ LOCAL void grr_clean_up_seg_ctrl_blk_tbl ( void ) { ULONG fn_i,T3200_i; UBYTE i; TRACE_FUNCTION( "grr_clean_up_seg_ctrl_blk_tbl" ); for(i = 0;i < SEG_CTRL_BLOCK_SIZE;i++) { if(0xFF NEQ grr_data->seg_ctrl_blk.blk[i].rti) { fn_i = grr_data->dl_fn; T3200_i = grr_data->seg_ctrl_blk.blk[i].T3200; if((grr_data->seg_ctrl_blk.blk[i].T3200 < 60000) AND (fn_i > (FN_MAX - 60000))) { T3200_i += FN_MAX; } else if((grr_data->seg_ctrl_blk.blk[i].T3200 > (FN_MAX - 60000)) AND (fn_i < 60000)) { fn_i += FN_MAX; } if((T3200_i < fn_i) OR (T3200_i > (fn_i + 60000))) { grr_data->seg_ctrl_blk.blk[i].rti = 0xFF; } } } } /* grr_clean_up_seg_ctrl_blk_tbl() */ /* +------------------------------------------------------------------------------ | Function : grr_align_seg_ctrl_blk_nxt +------------------------------------------------------------------------------ | Description : The function grr_align_seg_ctrl_blk_nxt() checks the table for | the next field to use and sets grr_data->seg_ctrl_blk.next. | | Parameters : no | +------------------------------------------------------------------------------ */ LOCAL void grr_align_seg_ctrl_blk_nxt ( void ) { ULONG T3200_i1,T3200_i2; UBYTE i,n; TRACE_FUNCTION( "grr_align_seg_ctrl_blk_nxt" ); grr_data->seg_ctrl_blk.next++; grr_data->seg_ctrl_blk.next %= SEG_CTRL_BLOCK_SIZE; if(0xFF NEQ grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].rti) { for(i = 0;i < SEG_CTRL_BLOCK_SIZE;i++) { /* is there an empty field */ if(0xFF EQ grr_data->seg_ctrl_blk.blk[i].rti) break; } if(SEG_CTRL_BLOCK_SIZE > i) { /* there is an empty field */ grr_data->seg_ctrl_blk.next = i; } else {/* there is no empty field -> find the oldest entry */ for(i = 0,n = 0;i < SEG_CTRL_BLOCK_SIZE;i++) { T3200_i1 = grr_data->seg_ctrl_blk.blk[i].T3200; T3200_i2 = grr_data->seg_ctrl_blk.blk[n].T3200; if((T3200_i1 > (FN_MAX - 60000)) AND (T3200_i2 < 60000)) { T3200_i2 += FN_MAX; } else if((T3200_i2 > (FN_MAX - 60000)) AND (T3200_i1 < 60000)) { T3200_i1 += FN_MAX; } if(T3200_i1 < T3200_i2) { n = i; } } grr_data->seg_ctrl_blk.next = n; } } } /* grr_align_seg_ctrl_blk_nxt() */ /* +------------------------------------------------------------------------------ | Function : grr_decode_ie_tlli +------------------------------------------------------------------------------ | Description : This function decodes a compressed TLLI struct | | Parameters : tlli - BUF_tlli struct destination pointer | | Globals: pBuf - Ptr to the compressed TLLI buffer | startBit - Bit offset of the first TLLI bit | bitLen - Lenght of the buffer in bits | | Returns : ccdOK - If no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_ie_tlli (BUF_tlli_value* tlli) { if (bitLen < 32) return ERR_MAND_ELEM_MISS; tlli->l_tlli_value = 32; tlli->o_tlli_value = startBit%8; tlli->b_tlli_value[0] = pBuf[startBit/8] & maskTab2[tlli->o_tlli_value]; startBit += 8; tlli->b_tlli_value[1] = pBuf[startBit/8]; startBit += 8; tlli->b_tlli_value[2] = pBuf[startBit/8]; startBit += 8; tlli->b_tlli_value[3] = pBuf[startBit/8]; startBit += 8; tlli->b_tlli_value[4] = pBuf[startBit/8] & ~(maskTab2[tlli->o_tlli_value]); bitLen -= 32; return ccdOK; } /* +------------------------------------------------------------------------------ | Function : grr_decode_ie_pta +------------------------------------------------------------------------------ | Description : This function decodes a compressed T_pta struct | | Parameters : pta - T_pta struct destination pointer | | Globals: pBuf - Ptr to the compressed T_pta buffer | startBit - Bit offset of the first T_pta bit | bitLen - Lenght of the buffer in bits | | Returns : ccdOK - If no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_ie_pta (T_pta* pta) { int bit; if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* TIMING_ADVANCED_VALUE:bit(6) */ { if (bitLen < 6) return ERR_MAND_ELEM_MISS; pta->v_ta_value = TRUE; pta->ta_value = GET_N_BITS(6); } /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ERR_MAND_ELEM_MISS; pta->v_ta_index_tn = GET_N_BITS(1); if (pta->v_ta_index_tn == 1) /* TIMING_ADVANCED_INDEX:bit(4) */ { /* TI.A.-TIMESLOT_NUMBER:bit(3) */ if (bitLen < 7) return ERR_MAND_ELEM_MISS; pta->ta_index_tn.ta_index = GET_N_BITS(4); pta->ta_index_tn.ta_tn = GET_N_BITS(3); } return ccdOK; } /* +------------------------------------------------------------------------------ | Function : grr_decode_ie_pwr_par +------------------------------------------------------------------------------ | Description : This function decodes a compressed T_pwr_par struct | | Parameters : pwr_par - T_pwr_par struct destination pointer | | Globals: pBuf - Ptr to the compressed T_pwr_par buffer | startBit - Bit offset of the first T_pwr_par bit | bitLen - Lenght of the buffer in bits | | Returns : ccdOK - If no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_ie_pwr_par (T_pwr_par* pwr_par) { int i; int bit; /* Power Control Parameters */ if (bitLen < 4) return ERR_MAND_ELEM_MISS; pwr_par->alpha = GET_N_BITS(4); for (i=0; i<8; i++) { if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) { if (bitLen < 5) return ERR_MAND_ELEM_MISS; pwr_par->gamma_tn[i].v_gamma = TRUE; /* any values are allowed */ pwr_par->gamma_tn[i].gamma = GET_N_BITS(5); } } return ccdOK; } /* +------------------------------------------------------------------------------ | Function : grr_decode_ie_glob_tfi +------------------------------------------------------------------------------ | Description : This function decodes a compressed T_glob_tfi struct | | Parameters : glob_tfi - T_glob_tfi struct destination pointer | | Globals: pBuf - Ptr to the compressed T_glob_tfi buffer | startBit - Bit offset of the first T_glob_tfi bit | bitLen - Lenght of the buffer in bits | | Returns : ccdOK - If no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_ie_glob_tfi (T_glob_tfi* glob_tfi) { if (bitLen < 6) return ERR_MAND_ELEM_MISS; glob_tfi->flag = GET_N_BITS(1); if (glob_tfi->flag == 0) /* UPLINK_TFI */ { glob_tfi->v_ul_tfi = TRUE; glob_tfi->ul_tfi = GET_N_BITS(5); } else /* DOWNLINK_TFI */ { glob_tfi->v_dl_tfi = TRUE; glob_tfi->dl_tfi = GET_N_BITS(5); } return ccdOK; } /* +------------------------------------------------------------------------------ | Function : grr_decode_ie_meas_map +------------------------------------------------------------------------------ | Description : This function decodes a compressed T_meas_map struct | | Parameters : meas_map - T_meas_map struct destination pointer | | Globals: pBuf - Ptr to the compressed T_meas_map buffer | startBit - Bit offset of the first T_meas_map bit | bitLen - Lenght of the buffer in bits | | Returns : ccdOK - If no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_ie_meas_map (T_meas_map* meas_map) { USHORT h_byte; if (bitLen < 1) return ERR_MAND_ELEM_MISS; meas_map->meas_start_grr.flag = GET_N_BITS(1); if (meas_map->meas_start_grr.flag == 1) /* Relative Frame Number Encod.*/ { if (bitLen < 13) return ERR_MAND_ELEM_MISS; meas_map->meas_start_grr.v_rel = TRUE; h_byte = GET_N_BITS(5); meas_map->meas_start_grr.rel = (h_byte << 8) + GET_N_BITS(8); } else /* Absolute Frame Number Encod.*/ { if (bitLen < 16) return ERR_MAND_ELEM_MISS; meas_map->meas_start_grr.v_abs = TRUE; meas_map->meas_start_grr.abs.t1 = GET_N_BITS(5); meas_map->meas_start_grr.abs.t3 = GET_N_BITS(6); meas_map->meas_start_grr.abs.t2 = GET_N_BITS(5); } if (bitLen < 13) return ERR_MAND_ELEM_MISS; meas_map->meas_inter = GET_N_BITS(5); meas_map->meas_bitmap = GET_N_BITS(8); return ccdOK; } #ifdef REL99 /* +------------------------------------------------------------------------------ | Function : grr_decode_ie_egprs_link_adpt_para +------------------------------------------------------------------------------ | Description : This function decodes the EGPRS link adaptation parameters | | Parameters : trgt - T_egprs_link_adpt_para destination pointer | | Globals: pBuf - Ptr to the compressed T_egprs_link_adpt_para buffer | startBit - Bit offset of the first T_egprs_link_adpt_para bit | bitLen - Lenght of the buffer in bits | | Returns : ccdOK - If no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_ie_egprs_link_adpt_para(T_egprs_link_adpt_para *trgt) { TRACE_FUNCTION("grr_decode_ie_egprs_link_adpt_para"); if (bitLen < 8) /*5+2+1*/ return ERR_MAND_ELEM_MISS; trgt->egprs_ws = GET_N_BITS(5); if (bitLen < 1) return ERR_MAND_ELEM_MISS; trgt->lqm_mode = GET_N_BITS(2); trgt->v_bep_period2 = GET_N_BITS(1); if(trgt->v_bep_period2) { trgt->bep_period2 = GET_N_BITS(4); } return ccdOK; } /* +------------------------------------------------------------------------------ | Function : grr_decode_ie_compact_red_ma +------------------------------------------------------------------------------ | Description : This function decodes the compact_red_ma parameters | | Parameters : trgt - T_compact_red_ma destination pointer | | Globals: pBuf - Ptr to the T_compact_red_ma buffer | startBit - Bit offset of the first T_compact_red_ma bit | bitLen - Lenght of the buffer in bits | | Returns : ccdOK - If no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_ie_compact_red_ma(T_compact_red_ma *trgt) { UBYTE i=0; TRACE_FUNCTION("grr_decode_ie_compact_red_ma"); if (bitLen < 8) /*7(for length_reduced_bitmap)+1(for v_maio_2) */ return ERR_MAND_ELEM_MISS; trgt->length_reduced_bitmap = GET_N_BITS(7); if(bitLen < trgt->c_reduced_ma_bitmap ) return ERR_MAND_ELEM_MISS; for(i=0 ; i < trgt->c_reduced_ma_bitmap ;i++) { trgt->reduced_ma_bitmap[i] = GET_N_BITS(1); } trgt->v_maio_2 = GET_N_BITS(1); if(trgt->v_maio_2 == 1) { if (bitLen < 6) return ERR_MAND_ELEM_MISS; trgt->maio_2 = GET_N_BITS(6); } return ccdOK; } #endif /* +------------------------------------------------------------------------------ | Function : grr_decode_ie_tbf_s_time +------------------------------------------------------------------------------ | Description : This function decodes a compressed T_tbf_s_time struct | | Parameters : tbf_s_time - T_tbf_s_time struct destination pointer | | Globals: pBuf - Ptr to the compressed T_tbf_s_time buffer | startBit - Bit offset of the first T_tbf_s_time bit | bitLen - Lenght of the buffer in bits | | Returns : ccdOK - If no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_ie_tbf_s_time (T_tbf_s_time* tbf_s_time) { USHORT h_byte; /* TBF Starting Time: Starting */ /* frame number description */ if (bitLen < 1) return ERR_MAND_ELEM_MISS; tbf_s_time->flag = GET_N_BITS(1); if (tbf_s_time->flag == 1) /* Relative Frame Number Encod.*/ { if (bitLen < 13) return ERR_MAND_ELEM_MISS; tbf_s_time->v_rel = TRUE; h_byte = GET_N_BITS(5); tbf_s_time->rel = (h_byte << 8) + GET_N_BITS(8); } else /* Absolute Frame Number Encod.*/ { if (bitLen < 16) return ERR_MAND_ELEM_MISS; tbf_s_time->v_abs = TRUE; tbf_s_time->abs.t1 = GET_N_BITS(5); tbf_s_time->abs.t3 = GET_N_BITS(6); tbf_s_time->abs.t2 = GET_N_BITS(5); } return ccdOK; } /* +------------------------------------------------------------------------------ | Function : grr_decode_ie_dyn_alloc_p +------------------------------------------------------------------------------ | Description : This function decodes a compressed Dynamic Allocation IE | | Parameters : dyn_alloc_p - T_dyn_alloc_p struct destination pointer | | Globals: pBuf - Ptr to the compressed T_dyn_alloc_p buffer | startBit - Bit offset of the first T_dyn_alloc_p bit | bitLen - Lenght of the buffer in bits | | Returns : ccdOK - If no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_ie_dyn_alloc_p (T_dyn_alloc_p* dyn_alloc_p) { int i; int bit; UBYTE ret_code; if (bitLen < 2) return ERR_MAND_ELEM_MISS; dyn_alloc_p->xdyn_alloc = GET_N_BITS(1); dyn_alloc_p->flag2 = GET_N_BITS(1); if (dyn_alloc_p->flag2 == 1) /* P0:bit(4), PR_MODE:bit(1) */ { if (bitLen < 5) return ERR_MAND_ELEM_MISS; dyn_alloc_p->v_p0 = TRUE; dyn_alloc_p->p0 = GET_N_BITS(4); dyn_alloc_p->v_pr_mode = TRUE; dyn_alloc_p->pr_mode = GET_N_BITS(1); } if (bitLen < 1) return ERR_MAND_ELEM_MISS; dyn_alloc_p->usf_grant = GET_N_BITS(1); /* USF_GRANULARITY:bit(1) */ if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* UL_TFI_ASSIGNMENT : bit(5) */ { if (bitLen < 5) return ERR_MAND_ELEM_MISS; dyn_alloc_p->v_ul_tfi_assign = TRUE; dyn_alloc_p->ul_tfi_assign = GET_N_BITS(5); } if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* RLC_DATA_B._GRANTED:bit(8) */ { if (bitLen < 8) return ERR_MAND_ELEM_MISS; dyn_alloc_p->v_rlc_db_granted = TRUE; dyn_alloc_p->rlc_db_granted = GET_N_BITS(8); } if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* TBF Starting Time: Starting */ { /* frame number description */ ret_code = grr_decode_ie_tbf_s_time (&dyn_alloc_p->tbf_s_time); if (ret_code == ccdOK) dyn_alloc_p->v_tbf_s_time = TRUE; else return ret_code; } if (bitLen < 1) return ERR_MAND_ELEM_MISS; dyn_alloc_p->flag = GET_N_BITS(1); if (dyn_alloc_p->flag == 0) /* Timeslot Allocation */ { for (i=0; i<8; i++) { if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) { if (bitLen < 3) return ERR_MAND_ELEM_MISS; dyn_alloc_p->tn_alloc[i].v_usf = TRUE; dyn_alloc_p->tn_alloc[i].usf = GET_N_BITS(3); } } dyn_alloc_p->v_tn_alloc = TRUE; } else /* Timeslot Allocation with */ { /* Power Control Parameters */ if (bitLen < 4) return ERR_MAND_ELEM_MISS; dyn_alloc_p->tn_alloc_pwr.alpha = GET_N_BITS(4); for (i=0; i<8; i++) { if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) { if (bitLen < 8) return ERR_MAND_ELEM_MISS; dyn_alloc_p->tn_alloc_pwr.usf_array[i].v_usf_g = TRUE; dyn_alloc_p->tn_alloc_pwr.usf_array[i].usf_g.usf = GET_N_BITS(3); dyn_alloc_p->tn_alloc_pwr.usf_array[i].usf_g.gamma = GET_N_BITS(5); } } dyn_alloc_p->v_tn_alloc_pwr = TRUE; } return ccdOK; } /* grr_decode_ie_dyn_alloc_p */ /* +------------------------------------------------------------------------------ | Function : grr_decode_ie_dyn_alloc_ts +------------------------------------------------------------------------------ | Description : This function decodes a compressed Dynamic Allocation IE | | Parameters : dyn_alloc_ts - T_dyn_alloc_ts struct destination pointer | | Globals: pBuf - Ptr to the compressed T_dyn_alloc_p buffer | startBit - Bit offset of the first T_dyn_alloc_p bit | bitLen - Lenght of the buffer in bits | | Returns : ccdOK - If no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_ie_dyn_alloc_ts (T_dyn_alloc_ts* dyn_alloc_ts) { int i; int bit; UBYTE ret_code; if (bitLen < 2) return ERR_MAND_ELEM_MISS; dyn_alloc_ts->xdyn_alloc = GET_N_BITS(1); dyn_alloc_ts->flag2 = GET_N_BITS(1); if (dyn_alloc_ts->flag2 == 1) /* P0:bit(4), PR_MODE:bit(1) */ { if (bitLen < 5) return ERR_MAND_ELEM_MISS; dyn_alloc_ts->v_p0 = TRUE; dyn_alloc_ts->p0 = GET_N_BITS(4); dyn_alloc_ts->v_pr_mode = TRUE; dyn_alloc_ts->pr_mode = GET_N_BITS(1); } if (bitLen < 1) return ERR_MAND_ELEM_MISS; dyn_alloc_ts->usf_grant = GET_N_BITS(1); /* USF_GRANULARITY:bit(1) */ if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* RLC_DATA_B._GRANTED:bit(8) */ { if (bitLen < 8) return ERR_MAND_ELEM_MISS; dyn_alloc_ts->v_rlc_db_granted = TRUE; dyn_alloc_ts->rlc_db_granted = GET_N_BITS(8); } if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* TBF Starting Time: Starting */ { /* frame number description */ ret_code = grr_decode_ie_tbf_s_time (&dyn_alloc_ts->tbf_s_time); if (ret_code == ccdOK) dyn_alloc_ts->v_tbf_s_time = TRUE; else return ret_code; } if (bitLen < 1) return ERR_MAND_ELEM_MISS; dyn_alloc_ts->flag = GET_N_BITS(1); if (dyn_alloc_ts->flag == 0) /* Timeslot Allocation */ { for (i=0; i<8; i++) { if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) { if (bitLen < 3) return ERR_MAND_ELEM_MISS; dyn_alloc_ts->tn_alloc[i].v_usf = TRUE; dyn_alloc_ts->tn_alloc[i].usf = GET_N_BITS(3); } } dyn_alloc_ts->v_tn_alloc = TRUE; } else /* Timeslot Allocation with */ { /* Power Control Parameters */ if (bitLen < 4) return ERR_MAND_ELEM_MISS; dyn_alloc_ts->tn_alloc_pwr.alpha = GET_N_BITS(4); for (i=0; i<8; i++) { if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) { if (bitLen < 8) return ERR_MAND_ELEM_MISS; dyn_alloc_ts->tn_alloc_pwr.usf_array[i].v_usf_g = TRUE; dyn_alloc_ts->tn_alloc_pwr.usf_array[i].usf_g.usf = GET_N_BITS(3); dyn_alloc_ts->tn_alloc_pwr.usf_array[i].usf_g.gamma = GET_N_BITS(5); } } dyn_alloc_ts->v_tn_alloc_pwr = TRUE; } return ccdOK; } /* grr_decode_ie_dyn_alloc_ts */ /* +------------------------------------------------------------------------------ | Function : grr_decode_ie_freq_par +------------------------------------------------------------------------------ | Description : This function decodes a compressed T_freq_par struct | | Parameters : freq_par - T_freq_par struct destination pointer | | Globals: pBuf - Ptr to the compressed T_freq_par buffer | startBit - Bit offset of the first T_freq_par bit | bitLen - Lenght of the buffer in bits | | Returns : ccdOK - If no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_ie_freq_par (T_freq_par* freq_par) { int i; int bit; USHORT h_byte; if (bitLen < 5) return ERR_MAND_ELEM_MISS; freq_par->tsc = GET_N_BITS(3); /* TSC : bit (3) */ freq_par->flag = GET_N_BITS(1); freq_par->flag2 = GET_N_BITS(1); if (freq_par->flag == 0) { if (freq_par->flag2 == 0) /* ARFCN : bit(10) */ { if (bitLen < 10) return ERR_MAND_ELEM_MISS; freq_par->v_arfcn = TRUE; h_byte = GET_N_BITS(2); freq_par->arfcn = (h_byte << 8) + GET_N_BITS(8); } else /* Indirect encoding */ { if (bitLen < 11) return ERR_MAND_ELEM_MISS; freq_par->indi_encod.maio = GET_N_BITS(6); freq_par->indi_encod.ma_num = GET_N_BITS(4); bit = GET_N_BITS(1); if (bit == 1) { if (bitLen < 3) return ERR_MAND_ELEM_MISS; freq_par->indi_encod.v_chamge_ma_sub = TRUE; freq_par->indi_encod.chamge_ma_sub.cm1 = GET_N_BITS(2); bit = GET_N_BITS(1); if (bit == 1) { if (bitLen < 2) return ERR_MAND_ELEM_MISS; freq_par->indi_encod.chamge_ma_sub.v_cm2 = TRUE; freq_par->indi_encod.chamge_ma_sub.cm2 = GET_N_BITS(2); } } freq_par->v_indi_encod = TRUE; } } else { if (freq_par->flag2 == 0) /* Direct encoding 1 */ { if (bitLen < 13) return ERR_MAND_ELEM_MISS; freq_par->di_encod1.maio = GET_N_BITS(6); freq_par->di_encod1.gprs_ms_alloc_ie.hsn = GET_N_BITS(6); bit = GET_N_BITS(1); if (bit == 1) /* RFL number list */ { i = 0; do { if (i >= MAX_RFL_NUM_LIST) return ERR_MAND_ELEM_MISS; if (bitLen < 5) return ERR_MAND_ELEM_MISS; freq_par->di_encod1.gprs_ms_alloc_ie.rfl_num_list[i++]. rfl_num = GET_N_BITS(4); bit = GET_N_BITS(1); } while (bit == 1); freq_par->di_encod1.gprs_ms_alloc_ie.c_rfl_num_list = i; freq_par->di_encod1.gprs_ms_alloc_ie.v_rfl_num_list = TRUE; } if (bitLen < 1) return ERR_MAND_ELEM_MISS; freq_par->di_encod1.gprs_ms_alloc_ie.flag = GET_N_BITS(1); if (freq_par->di_encod1.gprs_ms_alloc_ie.flag == 0) { /* MA_LENGTH, MA_BITMAP */ if (bitLen < 6) return ERR_MAND_ELEM_MISS; i = GET_N_BITS(6); freq_par->di_encod1.gprs_ms_alloc_ie.ma_struct.ma_len = i; freq_par->di_encod1.gprs_ms_alloc_ie.ma_struct.c_ma_map = i + 1; if (bitLen < (i + 1)) return ERR_MAND_ELEM_MISS; for (i=0; i<freq_par->di_encod1.gprs_ms_alloc_ie.ma_struct.c_ma_map; i++) { freq_par->di_encod1.gprs_ms_alloc_ie.ma_struct.ma_map[i] = GET_N_BITS(1); } freq_par->di_encod1.gprs_ms_alloc_ie.v_ma_struct = TRUE; } else /* ARFCN index list */ { if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) { i = 0; do { if (i >= MAX_ARFCN_LIST) return ERR_MAND_ELEM_MISS; if (bitLen < 7) return ERR_MAND_ELEM_MISS; freq_par->di_encod1.gprs_ms_alloc_ie.arfcn_index_list[i++]. arfcn_index = GET_N_BITS(6); bit = GET_N_BITS(1); } while (bit == 1); freq_par->di_encod1.gprs_ms_alloc_ie.c_arfcn_index_list = i; freq_par->di_encod1.gprs_ms_alloc_ie.v_rfl_num_list = TRUE; } freq_par->di_encod1.gprs_ms_alloc_ie.v_arfcn_index_list = TRUE; } freq_par->v_di_encod1 = TRUE; } else /* Direct encoding 2 */ { if (bitLen < 16) return ERR_MAND_ELEM_MISS; freq_par->di_encod2.maio = GET_N_BITS(6); freq_par->di_encod2.hsn = GET_N_BITS(6); freq_par->di_encod2.len_ma_list = GET_N_BITS(4); freq_par->di_encod2.c_ma_list = freq_par->di_encod2.len_ma_list + 3; if (bitLen < (freq_par->di_encod2.c_ma_list << 3)) return ERR_MAND_ELEM_MISS; for (i=0; i<freq_par->di_encod2.c_ma_list; i++) { freq_par->di_encod2.ma_list[i] = GET_N_BITS(8); } freq_par->v_di_encod2 = TRUE; } } return ccdOK; } /* +------------------------------------------------------------------------------ | Function : grr_decode_dl_assignment +------------------------------------------------------------------------------ | Description : For performance reasons this function replaces the call to the | function ccd_decodeMsg. If no error occured, the D_DL_ASSIGN | message is decoded into _decodeCtrlMsg. | | Parameters : buf - pointer to beginning of the D_DL_ASSIGN IE | len - lenght of the buffer in bits | off - bit offset of the first bit in the buffer | | Returns : ccdOK - if no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_dl_assignment (UBYTE* buf, int off, int len) { int bit; UBYTE ret_code; MCAST(pMsg, D_DL_ASSIGN); /*-------------------------------------------------------------------------*/ startBit = off; /* Initiate global data */ bitLen = len; pBuf = buf; memset (pMsg, 0, sizeof(T_D_DL_ASSIGN)); /* init destination struct */ /*-------------------------------------------------------------------------*/ if (bitLen < 8) return ERR_MAND_ELEM_MISS; pMsg->msg_type = GET_N_BITS(6); /* MESSAGE_TYPE : bit(6) */ /* --- DISTRIBUTION CONTENTS --- */ pMsg->page_mode = GET_N_BITS(2); /* PAGE_MODE : bit(2) */ /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ccdOK; bit = GET_N_BITS(1); if (bit == 1) /* PERSISTENCE_LEVEL: bit(4)*4 */ { if (bitLen < 16) return ERR_MAND_ELEM_MISS; pMsg->v_pers_lev = TRUE; pMsg->pers_lev.plev[0] = GET_N_BITS(4); pMsg->pers_lev.plev[1] = GET_N_BITS(4); pMsg->pers_lev.plev[2] = GET_N_BITS(4); pMsg->pers_lev.plev[3] = GET_N_BITS(4); } if (bitLen <= 0) return ccdOK; /* --- ADDRESS INFORMATON --- */ /*-------------------------------------------------------------------------*/ pMsg->add1.flag = GET_N_BITS(1); if (pMsg->add1.flag == 0) /* Global TFI */ { ret_code = grr_decode_ie_glob_tfi (&pMsg->add1.glob_tfi); if (ret_code == ccdOK) pMsg->add1.v_glob_tfi = TRUE; else return ret_code; } else { if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 0) /* TLLI */ { ret_code = grr_decode_ie_tlli (&pMsg->add1.tlli_value); if(ret_code == ccdOK) pMsg->add1.v_tlli_value = TRUE; else return ret_code; } else { return ERR_MAND_ELEM_MISS; } } /*-------------------------------------------------------------------------*/ /* --- MESSAGE ESCAPE --- */ if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* 1 equals to Message Escape */ return ccdOK; /* then we are ready */ /* --- NON-DISTRIBUTION CONTENTS --- */ if (bitLen < 12) return ERR_MAND_ELEM_MISS; pMsg->mac_mode = GET_N_BITS(2); /* MAC_MODE : bit(2) */ pMsg->rlc_mode = GET_N_BITS(1); /* RLC_MODE : bit(1) */ pMsg->ctrl_ack = GET_N_BITS(1); /* CONTROL_ACK : bit(1) */ pMsg->ts_alloc = GET_N_BITS(8); /* TIMESLOT_ALLOCATION : bit(8)*/ /*-------------------------------------------------------------------------*/ ret_code = grr_decode_ie_pta (&pMsg->pta); /* Packet Timing Advanced IE */ if(ret_code != ccdOK) return ret_code; /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* P0:bit(4) */ { /* BTS_PWR_CTRL_MODE : bit(1) */ /* PR_MODE : bit(1) */ if (bitLen < 6) return ERR_MAND_ELEM_MISS; pMsg->v_bts_pwr_ctrl = TRUE; pMsg->bts_pwr_ctrl.p0 = GET_N_BITS(4); pMsg->bts_pwr_ctrl.mode = GET_N_BITS(1); pMsg->bts_pwr_ctrl.pr_mode = GET_N_BITS(1); } /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* Frequency Parameters IE */ { ret_code = grr_decode_ie_freq_par (&pMsg->pda_trnc_grp.freq_par); if (ret_code == ccdOK) pMsg->pda_trnc_grp.v_freq_par = TRUE; else return ret_code; } /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* DOWNL.TFI_ASSIGNEMENT:bit(5)*/ { if (bitLen < 5) return ERR_MAND_ELEM_MISS; pMsg->pda_trnc_grp.v_dl_tfi_assign = TRUE; pMsg->pda_trnc_grp.dl_tfi_assign = GET_N_BITS(5); } /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* Power Control Parameters */ { ret_code = grr_decode_ie_pwr_par (&pMsg->pda_trnc_grp.pwr_par); if (ret_code == ccdOK) pMsg->pda_trnc_grp.v_pwr_par = TRUE; else return ret_code; } /*-------------------------------------------------------------------------*/ bit = GET_N_BITS(1); if (bit == 1) /* TBF Starting Time: Starting */ { /* frame number description */ ret_code = grr_decode_ie_tbf_s_time (&pMsg->pda_trnc_grp.tbf_s_time); if (ret_code == ccdOK) pMsg->pda_trnc_grp.v_tbf_s_time = TRUE; else return ret_code; } /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* Measurement Mapping */ { ret_code = grr_decode_ie_meas_map (&pMsg->pda_trnc_grp.meas_map); if (ret_code == ccdOK) pMsg->pda_trnc_grp.v_meas_map = TRUE; else return ret_code; } #ifdef REL99 /*Extending the Packet downlink assignment message decoding *for R99 additions */ pMsg->pda_trnc_grp.v_release_99_str_pda = GET_N_BITS(1); if(pMsg->pda_trnc_grp.v_release_99_str_pda == 1) { bit = GET_N_BITS(1); if(bit == 1) { ret_code = grr_decode_ie_egprs_link_adpt_para( &pMsg->pda_trnc_grp.release_99_str_pda.egprs_link_adpt_para); if(ret_code == ccdOK) pMsg->pda_trnc_grp.release_99_str_pda.v_egprs_link_adpt_para = TRUE; else return ret_code; } if(bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if(bit == 1) { if(bitLen < 2) return ERR_MAND_ELEM_MISS; pMsg->pda_trnc_grp.release_99_str_pda.v_p_ext_ta = TRUE; pMsg->pda_trnc_grp.release_99_str_pda.p_ext_ta = GET_N_BITS(2); } if(bitLen < 1) return ccdOK; bit = GET_N_BITS(1); if(bit == 1) { ret_code = grr_decode_ie_compact_red_ma(&pMsg->pda_trnc_grp.release_99_str_pda.compact_red_ma); if(ret_code == ccdOK) pMsg->pda_trnc_grp.release_99_str_pda.v_compact_red_ma = TRUE; else return ret_code; } } #endif /* --- PADDING BITS --- */ /* -> currently not decoded and/or validated */ return ccdOK; } /* +------------------------------------------------------------------------------ | Function : grr_decode_pdch_release +------------------------------------------------------------------------------ | Description : For performance reasons this function replaces the call to the | function ccd_decodeMsg. If no error occured, the D_PDCH_RELEASE | message is decoded into _decodeCtrlMsg. | | Parameters : buf - pointer to beginning of the D_PDCH_RELEASE IE | len - lenght of the buffer in bits | off - bit offset of the first bit in the buffer | | Returns : ccdOK - if no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_pdch_release (UBYTE* buf, int off, int len) { MCAST(pMsg, D_PDCH_RELEASE); /*-------------------------------------------------------------------------*/ startBit = off; /* Initiate global data */ bitLen = len; pBuf = buf; memset (pMsg, 0, sizeof(T_D_PDCH_RELEASE)); /* init destination struct */ /*-------------------------------------------------------------------------*/ if (bitLen < 8) return ERR_MAND_ELEM_MISS; pMsg->msg_type = GET_N_BITS(6); /* MESSAGE_TYPE : bit(6) */ /* --- DISTRIBUTION CONTENTS --- */ pMsg->page_mode = GET_N_BITS(2); /* PAGE_MODE : bit(2) */ /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ccdOK; pMsg->v_ts_available = GET_N_BITS(1); /* TIMESLOT AVAILABLE bit(1) */ if (bitLen <= 0) return ccdOK; pMsg->ts_available = GET_N_BITS(8); /* TIMESLOT MASK bit(8) */ /* --- PADDING BITS --- */ /* -> currently not decoded and/or validated */ return ccdOK; } /* +------------------------------------------------------------------------------ | Function : grr_decode_ul_assignment +------------------------------------------------------------------------------ | Description : For performance reasons this function replaces the call to the | function ccd_decodeMsg. If no error occured, the D_UL_ASSIGN | message is decoded into _decodeCtrlMsg. | | Parameters : buf - pointer to beginning of the D_DL_ASSIGN IE | len - lenght of the buffer in bits | off - bit offset of the first bit in the buffer | | Returns : ccdOK - if no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_ul_assignment (UBYTE* buf, int off, int len) { int i; int bit; USHORT h_byte; UBYTE ret_code; MCAST(pMsg, D_UL_ASSIGN); /*-------------------------------------------------------------------------*/ startBit = off; /* Initiate global data */ bitLen = len; pBuf = buf; memset (pMsg, 0, sizeof(T_D_UL_ASSIGN)); /* init destination struct */ /*-------------------------------------------------------------------------*/ if (bitLen < 8) return ERR_MAND_ELEM_MISS; pMsg->msg_type = GET_N_BITS(6); /* MESSAGE_TYPE : bit(6) */ /* --- DISTRIBUTION CONTENTS --- */ pMsg->page_mode = GET_N_BITS(2); /* PAGE_MODE : bit(2) */ /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ccdOK; bit = GET_N_BITS(1); if (bit == 1) /* PERSISTENCE_LEVEL: bit(4)*4 */ { if (bitLen < 16) return ERR_MAND_ELEM_MISS; pMsg->v_pers_lev = TRUE; pMsg->pers_lev.plev[0] = GET_N_BITS(4); pMsg->pers_lev.plev[1] = GET_N_BITS(4); pMsg->pers_lev.plev[2] = GET_N_BITS(4); pMsg->pers_lev.plev[3] = GET_N_BITS(4); } if (bitLen <= 0) return ccdOK; /*-------------------------------------------------------------------------*/ /* --- ADDRESS INFORMATON --- */ pMsg->add3.flag = GET_N_BITS(1); if (pMsg->add3.flag == 0) /* Global TFI */ { ret_code = grr_decode_ie_glob_tfi (&pMsg->add3.glob_tfi); if (ret_code == ccdOK) pMsg->add3.v_glob_tfi = TRUE; else return ret_code; } else { if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->add3.v_flag2 = TRUE; pMsg->add3.flag2 = GET_N_BITS(1); if (pMsg->add3.flag2 == 0) /* TLLI */ { if (bitLen < 32) return ERR_MAND_ELEM_MISS; ret_code = grr_decode_ie_tlli (&pMsg->add3.tlli_value); if(ret_code == ccdOK) pMsg->add3.v_tlli_value = TRUE; else return ret_code; } else { if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->add3.v_flag3 = TRUE; pMsg->add3.flag3 = GET_N_BITS(1); if (pMsg->add3.flag3 == 0) /* TQI : bit(16) */ { if (bitLen < 16) return ERR_MAND_ELEM_MISS; pMsg->add3.v_tqi = TRUE; h_byte = GET_N_BITS(8); pMsg->add3.tqi = (h_byte << 8) + GET_N_BITS(8); } else /* Packet Request Reference */ { if (bitLen < 27) return ERR_MAND_ELEM_MISS; pMsg->add3.v_req_ref_p = TRUE; h_byte = GET_N_BITS(3); pMsg->add3.req_ref_p.access_info = (h_byte << 8) + GET_N_BITS(8); pMsg->add3.req_ref_p.fn_mod.t1 = GET_N_BITS(5); pMsg->add3.req_ref_p.fn_mod.t3 = GET_N_BITS(6); pMsg->add3.req_ref_p.fn_mod.t2 = GET_N_BITS(5); } } } /*-------------------------------------------------------------------------*/ /* --- MESSAGE ESCAPE --- */ if (bitLen < 1) return ERR_MAND_ELEM_MISS; #ifdef REL99 pMsg->egprs_flag = GET_N_BITS(1); if (pMsg->egprs_flag == 1) { /* Extending the Packet uplink assignment message decoding * for EGPRS additions. We do not support EGPRS. So return * doing nothing */ return ccdOK; } #else bit = GET_N_BITS(1); if (bit == 1) /* 1 equals to Message Escape */ return ccdOK; /* then we are ready */ #endif /* When message egprs_flag is FALSE, the valid flags of all the * corresponding conditional elements, is made TRUE here */ pMsg->v_chan_coding_cmd = pMsg->v_tlli_chan_coding = TRUE; pMsg->v_pta = pMsg->v_flag = pMsg->v_flag2 = TRUE; #ifdef REL99 pMsg->v_release_99 = TRUE; #endif /* --- NON-DISTRIBUTION CONTENTS --- */ if (bitLen < 3) return ERR_MAND_ELEM_MISS; pMsg->chan_coding_cmd = GET_N_BITS(2); /* CHANNEL_COD._COMMAND:bit(2) */ pMsg->tlli_chan_coding = GET_N_BITS(1); /* TLLI_BLOCK_CHAN_COD.:bit(1) */ /*-------------------------------------------------------------------------*/ ret_code = grr_decode_ie_pta (&pMsg->pta); /* Packet Timing Advanced IE */ if(ret_code != ccdOK) return ret_code; /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* Frequency Parameters IE */ { ret_code = grr_decode_ie_freq_par (&pMsg->freq_par); if (ret_code == ccdOK) pMsg->v_freq_par = TRUE; else return ret_code; } /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->flag = GET_N_BITS(1); if (pMsg->flag == 0) { if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->flag2 = GET_N_BITS(1); if (pMsg->flag2 == 1) /* 01: Dynamic Allocation IE */ { ret_code = grr_decode_ie_dyn_alloc_p (&pMsg->dyn_alloc_p); if (ret_code == ccdOK) pMsg->v_dyn_alloc_p = TRUE; else return ret_code; } else { /* ffs. */ /* 00: for further extensions */ } } else { if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->flag2 = GET_N_BITS(1); if (pMsg->flag2 == 0) /* 10: Single Block Allocation */ { if (bitLen < 4) return ERR_MAND_ELEM_MISS; pMsg->sin_alloc.tn = GET_N_BITS(3); if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) { if (bitLen < 9) return ERR_MAND_ELEM_MISS; pMsg->sin_alloc.v_alf_gam = TRUE; pMsg->sin_alloc.alf_gam.alpha = GET_N_BITS(4); pMsg->sin_alloc.alf_gam.gamma = GET_N_BITS(5); } if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) { if (bitLen < 6) return ERR_MAND_ELEM_MISS; pMsg->sin_alloc.v_bts_pwr_ctrl = TRUE; pMsg->sin_alloc.bts_pwr_ctrl.p0 = GET_N_BITS(4); pMsg->sin_alloc.bts_pwr_ctrl.mode = GET_N_BITS(1); pMsg->sin_alloc.bts_pwr_ctrl.pr_mode = GET_N_BITS(1); } ret_code = grr_decode_ie_tbf_s_time (&pMsg->sin_alloc.tbf_s_time); if (ret_code != ccdOK) return ret_code; pMsg->v_sin_alloc = TRUE; } else /* 11: Fixed Allocation */ { if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) { pMsg->f_alloc_ul.v_ul_tfi_assign = TRUE; pMsg->f_alloc_ul.ul_tfi_assign = GET_N_BITS(5); } if (bitLen < 5) return ERR_MAND_ELEM_MISS; pMsg->f_alloc_ul.final_alloc = GET_N_BITS(1);; pMsg->f_alloc_ul.dl_ctrl_ts = GET_N_BITS(3);; bit = GET_N_BITS(1); if (bit == 1) { if (bitLen < 6) return ERR_MAND_ELEM_MISS; pMsg->f_alloc_ul.v_bts_pwr_ctrl = TRUE; pMsg->f_alloc_ul.bts_pwr_ctrl.p0 = GET_N_BITS(4); pMsg->f_alloc_ul.bts_pwr_ctrl.mode = GET_N_BITS(1); pMsg->f_alloc_ul.bts_pwr_ctrl.pr_mode = GET_N_BITS(1); } pMsg->f_alloc_ul.flag = GET_N_BITS(1); if(pMsg->f_alloc_ul.flag == 0) { pMsg->f_alloc_ul.v_ts_alloc = TRUE; pMsg->f_alloc_ul.ts_alloc = GET_N_BITS(8); } else { ret_code = grr_decode_ie_pwr_par (&pMsg->f_alloc_ul.pwr_par); if (ret_code == ccdOK) pMsg->f_alloc_ul.v_pwr_par = TRUE; else return ret_code; } if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->f_alloc_ul.half_dupelx = GET_N_BITS(1); ret_code = grr_decode_ie_tbf_s_time (&pMsg->f_alloc_ul.tbf_s_time); if (ret_code != ccdOK) return ret_code; bit = GET_N_BITS(1); if(bit == 0) { if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->f_alloc_ul.flag2 = GET_N_BITS(1); if (pMsg->f_alloc_ul.flag2 == 0) /* with len Allocation Bitmap */ { if (bitLen < 8) return ERR_MAND_ELEM_MISS; pMsg->f_alloc_ul.block_struct.bl_o_bl_per = GET_N_BITS(1); pMsg->f_alloc_ul.block_struct.a_map_len = GET_N_BITS(7); if (bitLen < pMsg->f_alloc_ul.block_struct.a_map_len) return ERR_MAND_ELEM_MISS; for (i=0; i<pMsg->f_alloc_ul.block_struct.a_map_len; i++) { pMsg->f_alloc_ul.block_struct.alloc_map[i] = GET_N_BITS(1); } pMsg->f_alloc_ul.block_struct.c_alloc_map = i; pMsg->f_alloc_ul.v_block_struct = TRUE; } else /* without lenght of Allocation Bitmap */ { /* Bitmap fills remainder of message */ pMsg->f_alloc_ul.v_alloc_map = TRUE; if (bitLen > 127) pMsg->f_alloc_ul.c_alloc_map = 127; else pMsg->f_alloc_ul.c_alloc_map = bitLen; for (i=0; i<pMsg->f_alloc_ul.c_alloc_map; i++) { pMsg->f_alloc_ul.alloc_map[i] = GET_N_BITS(1); } } } else { /* Message Escape */ } pMsg->v_f_alloc_ul = TRUE; } } #ifdef REL99 /* Updation of packet uplink assignment message decoding for * R99 extensions */ pMsg->release_99 = GET_N_BITS(1); if(pMsg->release_99 == 1) { if(bitLen < 2) return ERR_MAND_ELEM_MISS; pMsg->v_p_ext_ta = TRUE; pMsg->p_ext_ta = GET_N_BITS(2); } #endif /* --- PADDING BITS --- */ /* -> currently not decoded and/or validated */ return ccdOK; } /* +------------------------------------------------------------------------------ | Function : grr_decode_polling_req +------------------------------------------------------------------------------ | Description : For performance reasons this function replaces the call to the | function ccd_decodeMsg. If no error occured, the D_POLLING_REQ | message is decoded into _decodeCtrlMsg. | | Parameters : buf - pointer to beginning of the D_POLLING_REQ IE | len - lenght of the buffer in bits | off - bit offset of the first bit in the buffer | | Returns : ccdOK - if no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_polling_req (UBYTE* buf, int off, int len) { int bit; USHORT h_byte; UBYTE ret_code; MCAST(pMsg, D_POLLING_REQ); /*-------------------------------------------------------------------------*/ startBit = off; /* Initiate global data */ bitLen = len; pBuf = buf; memset (pMsg, 0, sizeof(T_D_POLLING_REQ)); /* init destination struct */ /*-------------------------------------------------------------------------*/ if (bitLen < 8) return ERR_MAND_ELEM_MISS; pMsg->msg_type = GET_N_BITS(6); /* MESSAGE_TYPE : bit(6) */ /* --- DISTRIBUTION CONTENTS --- */ pMsg->page_mode = GET_N_BITS(2); /* PAGE_MODE : bit(2) */ /*-------------------------------------------------------------------------*/ /* --- ADDRESS INFORMATON --- */ pMsg->add2.flag = GET_N_BITS(1); if (pMsg->add2.flag == 0) /* Global TFI */ { ret_code = grr_decode_ie_glob_tfi (&pMsg->add2.glob_tfi); if (ret_code == ccdOK) pMsg->add2.v_glob_tfi = TRUE; else return ret_code; } else { if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->add2.v_flag2 = TRUE; pMsg->add2.flag2 = GET_N_BITS(1); if (pMsg->add2.flag2 == 0) /* TLLI */ { if (bitLen < 32) return ERR_MAND_ELEM_MISS; ret_code = grr_decode_ie_tlli (&pMsg->add2.tlli_value); if(ret_code == ccdOK) pMsg->add2.v_tlli_value = TRUE; else return ret_code; } else { if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 0) /* TQI : bit(16) */ { if (bitLen < 16) return ERR_MAND_ELEM_MISS; pMsg->add2.v_tqi = TRUE; h_byte = GET_N_BITS(8); pMsg->add2.tqi = (h_byte << 8) + GET_N_BITS(8); } else { return ERR_ADDR_INFO_PART; } } } /*-------------------------------------------------------------------------*/ /* --- TYPE OF ACK --- */ if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->ctrl_ack_type = GET_N_BITS(1); /* --- PADDING BITS --- */ /* -> currently not decoded and/or validated */ return ccdOK; } /* +------------------------------------------------------------------------------ | Function : grr_decode_tbf_release_req +------------------------------------------------------------------------------ | Description : For performance reasons this function replaces the call to the | function ccd_decodeMsg. If no error occured, the D_TBF_RELEASE | message is decoded into _decodeCtrlMsg. | | Parameters : buf - pointer to beginning of the D_TBF_RELEASE IE | len - lenght of the buffer in bits | off - bit offset of the first bit in the buffer | | Returns : ccdOK - if no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_tbf_release_req (UBYTE* buf, int off, int len) { int bit; UBYTE ret_code; MCAST(pMsg, D_TBF_RELEASE); /*-------------------------------------------------------------------------*/ startBit = off; /* Initiate global data */ bitLen = len; pBuf = buf; memset (pMsg, 0, sizeof(T_D_TBF_RELEASE)); /* init destination struct */ /*-------------------------------------------------------------------------*/ if (bitLen < 8) return ERR_MAND_ELEM_MISS; pMsg->msg_type = GET_N_BITS(6); /* MESSAGE_TYPE : bit(6) */ /* --- DISTRIBUTION CONTENTS --- */ pMsg->page_mode = GET_N_BITS(2); /* PAGE_MODE : bit(2) */ /*-------------------------------------------------------------------------*/ /* --- ADDRESS INFORMATON --- */ bit = GET_N_BITS(1); if (bit == 0) /* Global TFI */ { ret_code = grr_decode_ie_glob_tfi (&pMsg->glob_tfi); if (ret_code NEQ ccdOK) return ret_code; } else { return ERR_ADDR_INFO_PART; } /*-------------------------------------------------------------------------*/ /* --- UPLINK/ DOWNLINK RELEASE VALUES --- */ if (bitLen < 6) return ERR_MAND_ELEM_MISS; pMsg->ul_release = GET_N_BITS(1); pMsg->dl_release = GET_N_BITS(1); pMsg->rel_cause = GET_N_BITS(4); /* --- PADDING BITS --- */ /* -> currently not decoded and/or validated */ return ccdOK; } /* +------------------------------------------------------------------------------ | Function : grr_decode_ts_reconfig +------------------------------------------------------------------------------ | Description : For performance reasons this function replaces the call to the | function ccd_decodeMsg. If no error occured, the D_TS_RECONFIG | message is decoded into _decodeCtrlMsg. | | Parameters : buf - pointer to beginning of the D_TS_RECONFIG IE | len - lenght of the buffer in bits | off - bit offset of the first bit in the buffer | | Returns : ccdOK - if no error is occured | - else CCD error code +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_decode_ts_reconfig (UBYTE* buf, int off, int len) { int i; int bit; UBYTE ret_code; MCAST(pMsg, D_TS_RECONFIG); /*-------------------------------------------------------------------------*/ startBit = off; /* Initiate global data */ bitLen = len; pBuf = buf; memset (pMsg, 0, sizeof(T_D_TS_RECONFIG)); /* init destination struct */ /*-------------------------------------------------------------------------*/ if (bitLen < 8) return ERR_MAND_ELEM_MISS; pMsg->msg_type = GET_N_BITS(6); /* MESSAGE_TYPE : bit(6) */ /* --- DISTRIBUTION CONTENTS --- */ pMsg->page_mode = GET_N_BITS(2); /* PAGE_MODE : bit(2) */ /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ccdOK; /*-------------------------------------------------------------------------*/ bit = GET_N_BITS(1); if(bit == 0) /* GLOBAL_TFI */ { ret_code = grr_decode_ie_glob_tfi (&pMsg->glob_tfi); if (ret_code != ccdOK) return ret_code; } /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ERR_MAND_ELEM_MISS; #ifdef REL99 pMsg->egprs_flag = GET_N_BITS(1); if (pMsg->egprs_flag == 1) { /*EGPRS is not supported. Just return */ return ccdOK; } #else bit = GET_N_BITS(1); if (bit == 1) /* 1 equals to Message Escape */ return ccdOK; /* then we are ready */ #endif /* When message egprs_flag is FALSE, the valid flags of all the * corresponding conditional elements, is made TRUE here */ pMsg->v_chan_coding_cmd = pMsg->v_gpta = pMsg->v_dl_rlc_mode = TRUE; pMsg->v_ctrl_ack = pMsg->v_dl_tn_alloc = pMsg->v_flag = TRUE; #ifdef REL99 pMsg->v_release_99 = TRUE; #endif /*-------------------------------------------------------------------------*/ if (bitLen < 2) return ERR_MAND_ELEM_MISS; pMsg->chan_coding_cmd = GET_N_BITS(2); /* CHANNEL_COD._COMMAND:bit(2) */ /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* TIMING_ADVANCED_VALUE */ { if (bitLen < 6) return ERR_MAND_ELEM_MISS; pMsg->gpta.v_ta_value = TRUE; pMsg->gpta.ta_value = GET_N_BITS(6); } if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->gpta.flag = GET_N_BITS(1); if (pMsg->gpta.flag == 1) /* UPLINK_TIMING_ADVANCED */ { if (bitLen < 7) return ERR_MAND_ELEM_MISS; pMsg->gpta.v_ul_ta_index = TRUE; pMsg->gpta.ul_ta_index = GET_N_BITS(4); pMsg->gpta.v_ul_ta_tn = TRUE; pMsg->gpta.ul_ta_tn = GET_N_BITS(3); } if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->gpta.flag2 = GET_N_BITS(1); if (pMsg->gpta.flag2 == 1) /* DOWNLINK_TIMING_ADVANCED */ { if (bitLen < 7) return ERR_MAND_ELEM_MISS; pMsg->gpta.v_dl_ta_index = TRUE; pMsg->gpta.dl_ta_index = GET_N_BITS(4); pMsg->gpta.v_dl_ta_tn = TRUE; pMsg->gpta.dl_ta_tn = GET_N_BITS(3); } /*-------------------------------------------------------------------------*/ if (bitLen < 2) return ERR_MAND_ELEM_MISS; pMsg->dl_rlc_mode = GET_N_BITS(1); pMsg->ctrl_ack = GET_N_BITS(1); /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* DOWNLINK_TFI_ASSIGNMENT */ { if (bitLen < 5) return ERR_MAND_ELEM_MISS; pMsg->v_dl_tfi = TRUE; pMsg->dl_tfi = GET_N_BITS(5); } if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* UPLINK_DFI_ASSIGNMENT */ { if (bitLen < 5) return ERR_MAND_ELEM_MISS; pMsg->v_ul_tfi = TRUE; pMsg->ul_tfi = GET_N_BITS(5); } /*-------------------------------------------------------------------------*/ if (bitLen < 8) return ERR_MAND_ELEM_MISS; pMsg->dl_tn_alloc = GET_N_BITS(8); /* DOWNLINK_TIMESLOT_ALLOCATION*/ /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* Frequency Parameters IE */ { ret_code = grr_decode_ie_freq_par (&pMsg->freq_par); if (ret_code == ccdOK) pMsg->v_freq_par = TRUE; else return ret_code; } /*-------------------------------------------------------------------------*/ if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->flag = GET_N_BITS(1); if (pMsg->flag == 0) /* Dynamic Allocation struct */ { ret_code = grr_decode_ie_dyn_alloc_ts (&pMsg->dyn_alloc_ts); if (ret_code == ccdOK) pMsg->v_dyn_alloc_ts = TRUE; else return ret_code; } else /* Fixed Allocation struct */ { if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->f_alloc_re.flag = GET_N_BITS(1); if (pMsg->f_alloc_re.flag == 0) /* UPLINK_TIMESLOT_ALLOCATION */ { if (bitLen < 8) return ERR_MAND_ELEM_MISS; pMsg->f_alloc_re.v_ul_ts_alloc = TRUE; pMsg->f_alloc_re.ul_ts_alloc = GET_N_BITS(8); } else /* Power Control Parameters IE */ { ret_code = grr_decode_ie_pwr_par (&pMsg->f_alloc_re.pwr_par); if (ret_code == ccdOK) pMsg->f_alloc_re.v_pwr_par = TRUE; else return ret_code; } if (bitLen < 4) return ERR_MAND_ELEM_MISS; pMsg->f_alloc_re.final_alloc = GET_N_BITS(1); pMsg->f_alloc_re.dl_ctrl_ts = GET_N_BITS(3); bit = GET_N_BITS(1); if (bit == 1) { if (bitLen < 6) return ERR_MAND_ELEM_MISS; pMsg->f_alloc_re.v_bts_pwr_ctrl = TRUE; pMsg->f_alloc_re.bts_pwr_ctrl.p0 = GET_N_BITS(4); pMsg->f_alloc_re.bts_pwr_ctrl.mode = GET_N_BITS(1); pMsg->f_alloc_re.bts_pwr_ctrl.pr_mode = GET_N_BITS(1); } if (bitLen < 1) return ERR_MAND_ELEM_MISS; bit = GET_N_BITS(1); if (bit == 1) /* Measurement Mapping */ { ret_code = grr_decode_ie_meas_map (&pMsg->f_alloc_re.meas_map); if (ret_code == ccdOK) pMsg->f_alloc_re.v_meas_map = TRUE; else return ret_code; } /* TBF Starting Time */ ret_code = grr_decode_ie_tbf_s_time (&pMsg->f_alloc_re.tbf_s_time); if (ret_code != ccdOK) return ret_code; bit = GET_N_BITS(1); if(bit == 0) { if (bitLen < 1) return ERR_MAND_ELEM_MISS; pMsg->f_alloc_re.flag2 = GET_N_BITS(1); if (pMsg->f_alloc_re.flag2 == 0) /* with lenght of Allocation Bitmap */ { if (bitLen < 8) return ERR_MAND_ELEM_MISS; pMsg->f_alloc_re.block_struct.bl_o_bl_per = GET_N_BITS(1); pMsg->f_alloc_re.block_struct.a_map_len = GET_N_BITS(7); if (bitLen < pMsg->f_alloc_re.block_struct.a_map_len) return ERR_MAND_ELEM_MISS; for (i=0; i<pMsg->f_alloc_re.block_struct.a_map_len; i++) { pMsg->f_alloc_re.block_struct.alloc_map[i] = GET_N_BITS(1); } pMsg->f_alloc_re.block_struct.c_alloc_map = i; pMsg->f_alloc_re.v_block_struct = TRUE; } else /* without lenght of Allocation Bitmap */ { /* Bitmap fills remainder of message */ pMsg->f_alloc_re.v_alloc_map = TRUE; if (bitLen > 127) pMsg->f_alloc_re.c_alloc_map = 127; else pMsg->f_alloc_re.c_alloc_map = bitLen; for (i=0; i<pMsg->f_alloc_re.c_alloc_map; i++) { pMsg->f_alloc_re.alloc_map[i] = GET_N_BITS(1); } } } else { /* Message Escape */ } pMsg->v_f_alloc_re = TRUE; } #ifdef REL99 /* Updation of packet time slot reconf message decoding for R99 * extensions */ pMsg->release_99 = GET_N_BITS(1); if(pMsg->release_99 == 1) { if(bitLen < 2) return ERR_MAND_ELEM_MISS; pMsg->v_p_ext_ta = TRUE; pMsg->p_ext_ta = GET_N_BITS(2); } #endif return ccdOK; } /* +------------------------------------------------------------------------------ | Function : grr_ccd_error_handling +------------------------------------------------------------------------------ | Description : The function grr_ccd_error_handling() ... | | Parameters : entity_i - the CCD was called for this entity | +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_ccd_error_handling ( UBYTE entity_i ) { UBYTE result = DELETE_MESSAGE; USHORT parlist [MAX_ERR_PAR]; UBYTE first_error; TRACE_FUNCTION( "grr_ccd_error_handling" ); memset (parlist, 0, sizeof (parlist)); first_error = ccd_getFirstError (entity_i, parlist); switch (first_error) { case ERR_PATTERN_MISMATCH: /* A spare pattern does not match with */ /* the specified content */ /* Error params[0] = bitposition */ { MCAST(ptr,D_DL_ASSIGN); result = ptr->msg_type; } break; default: /* SZML-GLBL/010 */ TRACE_ERROR( "Ctrl-Message will be deleted" ); break; } return(result); } /* grr_ccd_error_handling() */ /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : grr_check_ptmsi +------------------------------------------------------------------------------ | Description : The function grr_check_ptmsi() checks the ptmsi and returns | TRUE if the ptmsi is correct. | | Parameters : ptmsi_i - ptr to ptmsi buffer | +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_check_ptmsi ( BUF_ptmsi * ptmsi_i ) { ULONG ptmsi; BOOL result = FALSE; TRACE_FUNCTION( "grr_check_ptmsi" ); ptmsi = grr_buffer2ulong( ptmsi_i ); /* * if the new_pmsi is invalid the old should be onsidered s invalid too */ if(grr_data->db.ms_id.new_ptmsi NEQ GMMRR_TMSI_INVALID) { if(grr_data->db.ms_id.old_ptmsi EQ ptmsi OR grr_data->db.ms_id.new_ptmsi EQ ptmsi) { result= TRUE; }; } else { TRACE_EVENT_P2("NO valid PTMSI IN GRR PRESENT !!! old_ptmsi=%lx new_ptmsi=%lx" ,grr_data->db.ms_id.old_ptmsi ,grr_data->db.ms_id.new_ptmsi); } if(!result) { TRACE_EVENT_P5("OLD PTMSI: %LX, DESTINATION PTMSI: %LX len=%d off=%d NEW PTMSI=%lx" ,grr_data->db.ms_id.old_ptmsi ,ptmsi ,ptmsi_i->l_ptmsi ,ptmsi_i->o_ptmsi ,grr_data->db.ms_id.new_ptmsi); TRACE_EVENT_P8("PTMSI BUF:buf[0 .. 7]= %x %x %x %x %x %x %x %x " ,ptmsi_i->b_ptmsi[0] ,ptmsi_i->b_ptmsi[1] ,ptmsi_i->b_ptmsi[2] ,ptmsi_i->b_ptmsi[3] ,ptmsi_i->b_ptmsi[4] ,ptmsi_i->b_ptmsi[5] ,ptmsi_i->b_ptmsi[6] ,ptmsi_i->b_ptmsi[7]); } return(result); } /* grr_check_ptmsi() */ /* +------------------------------------------------------------------------------ | Function : grr_check_tmsi +------------------------------------------------------------------------------ | Description : The function grr_check_tmsi() checks the tmsi and returns | TRUE if the tmsi is correct. | | Parameters : tmsi_i - ptr to tmsi buffer | +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_check_tmsi ( BUF_tmsi_field * tmsi_i ) { ULONG tmsi; BOOL result = FALSE; TRACE_FUNCTION( "grr_check_tmsi" ); tmsi = grr_buffer2ulong( (BUF_ptmsi*) tmsi_i ); if(tmsi EQ grr_data->db.ms_id.tmsi) result = TRUE; return(result); } /* grr_check_tmsi() */ /* +------------------------------------------------------------------------------ | Function : grr_check_all_tlli +------------------------------------------------------------------------------ | Description : The function grr_check_all_tlli() checks the tlli with all TLLI | GMM has assigned and returns TRUE if the tlli is between them. | | Parameters : tlli_i - ptr to tlli buffer | +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_check_all_tlli ( BUF_tlli_value * tlli_i ) { ULONG tlli; BOOL result = FALSE; TRACE_FUNCTION( "grr_check_all_tlli" ); tlli = grr_buffer2ulong( (BUF_ptmsi*)tlli_i ); /* * if the new_tlli is invalid the old should be onsidered s invalid too */ if(grr_data->db.ms_id.new_tlli NEQ GMMRR_TLLI_INVALID) { if(grr_data->db.ms_id.new_tlli EQ tlli) { grr_data->db.ms_id.received_tlli = grr_data->db.ms_id.new_tlli; result = TRUE; } else if (grr_data->db.ms_id.old_tlli EQ tlli) { grr_data->db.ms_id.received_tlli = grr_data->db.ms_id.old_tlli; result = TRUE; }; } if(result) { tc_cgrlc_enable_req(CGRLC_QUEUE_MODE_DEFAULT,CGRLC_RA_DEFAULT,FALSE,CGRLC_ENAC_NORMAL); } else { TRACE_EVENT_P5("OLD TLLI: %LX, DESTINATION TLLI: %LX len=%d off=%d NEW TLLI=%lx" ,grr_data->db.ms_id.old_tlli ,tlli ,tlli_i->l_tlli_value ,tlli_i->o_tlli_value ,grr_data->db.ms_id.new_tlli); TRACE_EVENT_P8("TLLI BUF:buf[0 .. 7]= %x %x %x %x %x %x %x %x " ,tlli_i->b_tlli_value[0] ,tlli_i->b_tlli_value[1] ,tlli_i->b_tlli_value[2] ,tlli_i->b_tlli_value[3] ,tlli_i->b_tlli_value[4] ,tlli_i->b_tlli_value[5] ,tlli_i->b_tlli_value[6] ,tlli_i->b_tlli_value[7]); } return(result); } /* grr_check_all_tlli() */ /* +------------------------------------------------------------------------------ | Function : grr_buffer2ulong +------------------------------------------------------------------------------ | Description : The function grr_buffer2ulong() copy a 32-Bit-Buffer in a ULONG | variable | | SZML-GLBL/002 | | Parameters : ptmsi - pointer to buffer that contains the 32bit for the ULONG | +------------------------------------------------------------------------------ */ GLOBAL ULONG grr_buffer2ulong ( BUF_ptmsi * ptmsi) { ULONG ul; UBYTE l, dummy; USHORT i, ii; UBYTE off1, off2; TRACE_FUNCTION( "grr_buffer2ulong" ); ul= 0; l = (UBYTE)ptmsi->l_ptmsi; off1 = ptmsi->o_ptmsi / 8; off2 = ptmsi->o_ptmsi % 8; dummy = 0; dummy = ptmsi->b_ptmsi[off1] << off2; if(l <= (8-off2)) { dummy = dummy >> (8-l); ul |= dummy; return ul; } dummy = dummy >> off2; ul |= dummy; l -= (8-off2); do { off1++; if(l < 8) { dummy = ptmsi->b_ptmsi[off1] >> (8-l); ii = 1; ul = ul << l; for(i=0; i< l; i++) { ul = ul | (dummy & ii); ii *= 2; } return ul; } else { ul = ul << 8; ul |= ptmsi->b_ptmsi[off1]; l -= 8; if(l EQ 0) return ul; } } while(TRUE); } /* +------------------------------------------------------------------------------ | Function : grr_decode_rr +------------------------------------------------------------------------------ | Description : The function grr_decode_rr() calls the function ccd_decodeMsg. | After the call the decoded Message is in _decodeCtrlMsg. | | | Parameters : msg_ptr_i - pointer to buffer that should be decoded | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grr_decode_rr ( T_MSGBUF * msg_ptr_i ) { UBYTE result; TRACE_FUNCTION( "grr_decode_rr" ); result = ccd_decodeMsg ( CCDENT_RR, DOWNLINK, msg_ptr_i, _decodedMsg, NOT_PRESENT_8BIT); if ( result EQ ccdError) { TRACE_ERROR( "grr_decode_rr - decoding of RR message failed" ); result = grr_ccd_error_handling(CCDENT_RR); } else { MCAST(ptr, D_SYS_INFO_13); /* get one message from the RR message-base*/ result = ptr->msg_type; /* this is the type of the decoded message*/ } return(result); } /* grr_decode_rr() */ /* +------------------------------------------------------------------------------ | Function : grr_calc_new_poll_pos +------------------------------------------------------------------------------ | Description : The function grr_calc_new_poll_pos() calculates the fn of the | new poll position | | Parameters : fn_i - framenumber | rrbp_i - relative position | +------------------------------------------------------------------------------ */ GLOBAL ULONG grr_calc_new_poll_pos ( ULONG fn_i, UBYTE rrbp_i ) { ULONG result=0; TRACE_FUNCTION( "grr_calc_new_poll_pos" ); switch( rrbp_i ) { case 0: result = (fn_i+13); break; case 1: if((fn_i+18)%13) result = (fn_i+17); else result = (fn_i+18); break; case 2: if(((fn_i+21)%13) EQ 8) result = (fn_i+21); else result = (fn_i+22); break; case 3: result = (fn_i+26); break; default: TRACE_ERROR( "unexpected rrbp value" ); break; } /* switch (rrbp_i) */ result = result % 0x297000; return result; } /* grr_calc_new_poll_pos() */ /* +------------------------------------------------------------------------------ | Function : grr_encode_ctrl +------------------------------------------------------------------------------ | Description : The function grr_encode_ctrl() build a T_SDU buffer that | contains the encode Ctrl Block ready to transmit. | | Parameters : ULONG ptr_in_i - ptr to the input structure | ULONG ptr_out_i - ptr to begin of output buffer | UBYTE r_bit_i - value of r_bit +------------------------------------------------------------------------------ */ GLOBAL void grr_encode_ctrl ( UBYTE * ptr_in_i, T_MSGBUF * ptr_out_i, UBYTE r_bit_i) { TRACE_FUNCTION( "grr_encode_ctrl" ); ptr_out_i->buf[0] = grr_get_ul_ctrl_block_header( r_bit_i ); ptr_out_i->o_buf = BIT_UL_CTRL_BLOCK_MAC_HEADER; ptr_out_i->l_buf = BIT_UL_CTRL_BLOCK_CONTENTS; ccd_codeMsg ( CCDENT_GRR, UPLINK, ptr_out_i, ptr_in_i, NOT_PRESENT_8BIT); ptr_out_i->l_buf += ptr_out_i->o_buf; ptr_out_i->o_buf = 0; } /* grr_encode_ctrl() */ /* +------------------------------------------------------------------------------ | Function : grr_save_persistence_level +------------------------------------------------------------------------------ | Description : The function grr_save_persistence_level() saves the persistence | level values to the data_base. | | Parameters : ptr2persistence_level_i - pointer to received data | +------------------------------------------------------------------------------ */ GLOBAL void grr_save_persistence_level ( T_pers_lev * ptr2persistence_level_i ) { UBYTE i ; TRACE_FUNCTION( "grr_save_persistence_level" ); for(i=0; i<4; i++) { psc_db->prach.pers_lev.plev[i] = ptr2persistence_level_i->plev[i]; } } /* grr_save_persistence_level() */ /* +------------------------------------------------------------------------------ | Function : grr_get_db_mode +------------------------------------------------------------------------------ | Description : | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL T_DB_MODE grr_get_db_mode( void ) { TRACE_FUNCTION( "grr_get_db_mode" ); return( grr_data->sc_db_mode ); }/* grr_get_db_mode */ /* +------------------------------------------------------------------------------ | Function : grr_set_db_ptr +------------------------------------------------------------------------------ | Description : | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void grr_set_db_ptr( T_DB_MODE mode ) { UBYTE old_mode = grr_data->sc_db_mode; TRACE_FUNCTION( "grr_set_db_ptr" ); switch( mode ) { case( DB_MODE_INIT ): grr_data->sc_db_mode = (UBYTE)mode; psc_db = &grr_data->sc_db_1; posc_db = NULL; prsc_db = NULL; pcr_db = &grr_data->sc_db_2; break; case( DB_MODE_CC_REQ ): if( grr_data->sc_db_mode NEQ DB_MODE_CC_REQ ) { grr_data->sc_db_mode = (UBYTE)mode; if( psc_db EQ &grr_data->sc_db_1 ) { psc_db = &grr_data->sc_db_2; posc_db = &grr_data->sc_db_1; } else { psc_db = &grr_data->sc_db_1; posc_db = &grr_data->sc_db_2; } prsc_db = NULL; pcr_db = NULL; } break; case( DB_MODE_SWAP ): { T_SC_DATABASE *db; if( posc_db EQ psc_db ) { posc_db = pcr_db; } else if( posc_db EQ pcr_db ) { posc_db = psc_db; } if( prsc_db EQ psc_db ) { prsc_db = pcr_db; } else if( prsc_db EQ pcr_db ) { prsc_db = psc_db; } db = psc_db; psc_db = pcr_db; pcr_db = db; } break; case( DB_MODE_CC_ACC ): if( grr_data->sc_db_mode EQ DB_MODE_CC_REQ ) { grr_data->sc_db_mode = (UBYTE)mode; if( psc_db EQ &grr_data->sc_db_1 ) { pcr_db = &grr_data->sc_db_2; } else { pcr_db = &grr_data->sc_db_1; } } /* else { TRACE_ERROR( "Database mode: !DB_MODE_CC_REQ -> DB_MODE_CC_ACC" ); } */ break; case( DB_MODE_CC_REJ ): if( grr_data->sc_db_mode EQ DB_MODE_CC_REQ ) { grr_data->sc_db_mode = (UBYTE)mode; if( psc_db EQ &grr_data->sc_db_1 ) { psc_db = &grr_data->sc_db_2; prsc_db = &grr_data->sc_db_1; pcr_db = &grr_data->sc_db_1; } else { psc_db = &grr_data->sc_db_1; prsc_db = &grr_data->sc_db_2; pcr_db = &grr_data->sc_db_2; } posc_db = NULL; } /* else { TRACE_ERROR( "Database mode: !DB_MODE_CC_REQ -> DB_MODE_CC_REJ" ); } */ break; default: TRACE_ASSERT( mode EQ DB_MODE_INIT OR mode EQ DB_MODE_CC_REQ OR mode EQ DB_MODE_CC_ACC OR mode EQ DB_MODE_CC_REJ OR mode EQ DB_MODE_SWAP ); break; } TRACE_EVENT_P6( "mode: %d -> %d, database: psc = %d, posc = %d, prsc = %d, pcr = %d", old_mode, mode, grr_get_db_num( psc_db ), grr_get_db_num( posc_db ), grr_get_db_num( prsc_db ), grr_get_db_num( pcr_db ) ); }/* grr_set_db_ptr */ /* +------------------------------------------------------------------------------ | Function : grr_init_db_srvc_param +------------------------------------------------------------------------------ | Description : | | Parameters : void | +------------------------------------------------------------------------------ */ LOCAL void grr_init_db_srvc_param ( T_SC_DATABASE *db ) { T_SC_DATABASE *original_db = psc_db; TRACE_FUNCTION( "grr_init_db_srvc_param" ); psc_db = db; ctrl_init_params( ); psi_init( ); pg_init_params( ); psc_db = original_db; grr_set_pbcch( FALSE ); }/* grr_init_db_srvc_param */ /* +------------------------------------------------------------------------------ | Function : grr_get_db_num +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL UBYTE grr_get_db_num ( T_SC_DATABASE *db ) { UBYTE db_num; TRACE_FUNCTION( "grr_get_db_num" ); if ( db EQ NULL ) db_num = 0; else if( db EQ &grr_data->sc_db_1 ) db_num = 1; else if( db EQ &grr_data->sc_db_2 ) db_num = 2; else db_num = 3; return( db_num ); }/* grr_get_db_num */ /* +------------------------------------------------------------------------------ | Function : grr_init_db +------------------------------------------------------------------------------ | Description : The function grr_init_db initializes the database in GRR_DATA. | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void grr_init_db ( T_SC_DATABASE *db ) { TRACE_FUNCTION( "grr_init_db" ); db->cell_info_for_gmm.access_status = GPRS_ACCESS_BARRED; db->cell_info_for_gmm.cell_info.cell_env.rai.rac = GMMRR_RAC_INVALID; db->gprs_attach_is_running = FALSE; db->non_drx_timer_running = FALSE; db->non_drx_timer = DRX_NO; db->nc2_non_drx_period_running = FALSE; grr_init_db_srvc_param( db ); #ifdef REL99 db->network_rel = BSS_NW_REL_97; /*Default Network Release 97 */ #endif }/* grr_init_db */ /* +------------------------------------------------------------------------------ | Function : grr_init +------------------------------------------------------------------------------ | Description : The function grr_init initializes the entity GRR | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void grr_init ( void ) { TRACE_FUNCTION( "grr_init" ); /* initialize all GRR data */ grr_data = &grr_data_base; memset( grr_data, 0, sizeof( T_GRR_DATA ) ); /* initialize the pointers to the databases */ grr_set_db_ptr( DB_MODE_INIT ); /* initialize the serving cell databases */ grr_init_db( psc_db ); grr_init_db( pcr_db ); /* * call of service init functions */ ctrl_init(); tc_init(); cpap_init(); psi_init(); pg_init(); meas_init( IM_MODE_TRANSFER ); cs_grr_init(); gfp_init(); ccd_register(CCD_REENTRANT); grr_init_ms_data( ); grr_data->db.ms_id.old_ptmsi = GMMRR_TMSI_INVALID; /* No valid PTMSI*/ grr_data->db.ms_id.new_ptmsi = GMMRR_TMSI_INVALID; /* No valid PTMSI*/ grr_data->db.ms_id.old_tlli = GMMRR_TLLI_INVALID; grr_data->db.ms_id.new_tlli = GMMRR_TLLI_INVALID; /* * SZML-GLBL/003 */ /*set ms capabilty*/ grr_data->ms_cap[0].Rx = 1; grr_data->ms_cap[0].Tx = 1; grr_data->ms_cap[0].Sum = 2; grr_data->ms_cap[0].Ttb = 2; grr_data->ms_cap[0].Tra = 4; /* Tra value for all classes */ grr_data->ms_cap[1].Rx = 2; grr_data->ms_cap[1].Tx = 1; grr_data->ms_cap[1].Sum = 3; grr_data->ms_cap[1].Ttb = 2; grr_data->ms_cap[1].Tra = 3; grr_data->ms_cap[2].Rx = 2; grr_data->ms_cap[2].Tx = 2; grr_data->ms_cap[2].Sum = 3; grr_data->ms_cap[2].Ttb = 2; grr_data->ms_cap[2].Tra = 3; grr_data->ms_cap[3].Rx = 3; grr_data->ms_cap[3].Tx = 1; grr_data->ms_cap[3].Sum = 4; grr_data->ms_cap[3].Ttb = 1; grr_data->ms_cap[3].Tra = 3; grr_data->ms_cap[4].Rx = 2; grr_data->ms_cap[4].Tx = 2; grr_data->ms_cap[4].Sum = 4; grr_data->ms_cap[4].Ttb = 1; grr_data->ms_cap[4].Tra = 3; grr_data->ms_cap[5].Rx = 3; grr_data->ms_cap[5].Tx = 2; grr_data->ms_cap[5].Sum = 4; grr_data->ms_cap[5].Ttb = 1; grr_data->ms_cap[5].Tra = 3; grr_data->ms_cap[6].Rx = 3; grr_data->ms_cap[6].Tx = 3; grr_data->ms_cap[6].Sum = 4; grr_data->ms_cap[6].Ttb = 1; grr_data->ms_cap[6].Tra = 3; grr_data->ms_cap[7].Rx = 4; grr_data->ms_cap[7].Tx = 1; grr_data->ms_cap[7].Sum = 5; grr_data->ms_cap[7].Ttb = 1; grr_data->ms_cap[7].Tra = 2; grr_data->ms_cap[8].Rx = 3; grr_data->ms_cap[8].Tx = 2; grr_data->ms_cap[8].Sum = 5; grr_data->ms_cap[8].Ttb = 1; grr_data->ms_cap[8].Tra = 2; grr_data->ms_cap[9].Rx = 4; grr_data->ms_cap[9].Tx = 2; grr_data->ms_cap[9].Sum = 5; grr_data->ms_cap[9].Ttb = 1; grr_data->ms_cap[9].Tra = 2; grr_data->ms_cap[10].Rx = 4; grr_data->ms_cap[10].Tx = 3; grr_data->ms_cap[10].Sum = 5; grr_data->ms_cap[10].Ttb = 1; grr_data->ms_cap[10].Tra = 2; grr_data->ms_cap[11].Rx = 4; grr_data->ms_cap[11].Tx = 4; grr_data->ms_cap[11].Sum = 5; grr_data->ms_cap[11].Ttb = 1; grr_data->ms_cap[11].Tra = 2; memset(&grr_data->ta_params, 0xFF, sizeof(T_TA_PARAMS)); grr_data->ta_params.ta_valid = FALSE; grr_data->cc_running = FALSE; grr_data->uplink_tbf.access_type = CGRLC_AT_NULL; /* NO CELL UPDATE NEED */ grr_data->test_mode = CGRLC_NO_TEST_MODE; grr_data->l1_del_tbf_start_fn = GRR_INVALID_FN; grr_set_pbcch( FALSE ); grr_data->cell_res_status = TRUE; #ifdef REL99 #ifdef TI_PS_FF_QUAD_BAND_SUPPORT psc_db->band_indicator = NOT_PRESENT_8BIT; #endif /* Initialize SGSN release to unknown value at Power ON */ psc_db->sgsn_rel = PS_SGSN_UNKNOWN; cl_nwrl_set_sgsn_release(psc_db->sgsn_rel); /* Initialize the BSS release to R97 */ psc_db->network_rel = BSS_NW_REL_97; #endif } /* grr_init() */ /* +------------------------------------------------------------------------------ | Function : grr_is_pbcch_present +------------------------------------------------------------------------------ | Description : grr_is_pbcch_present returns whether the PBCCH is present or not | | Parameters : no parameters | +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_is_pbcch_present (void) { return (psc_db->pbcch.bcch.pbcch_present); }/*grr_is_pbcch_present*/ /* +------------------------------------------------------------------------------ | Function : grr_random_value +------------------------------------------------------------------------------ | Description : This function generates a random value between 0 and max_i-1 | The function is current implemented by a random sequence. | It may replace by a other generation method in the future, | i.e. last bits of framenumber, systemtime or powervalue etc.. | | Parameters : max_i - return_value is between 0 and (max_i-1) | maximum value 256 | +------------------------------------------------------------------------------ */ GLOBAL ULONG grr_random_value (UBYTE index, ULONG max_i) { /* The indexing is done to avoid unpredictable distortion of uniform */ /* probability distribution of random values delivered to a specific */ /* caller */ static ULONG next[3] = {1,1,1}; ULONG return_value; #ifdef _TARGET_ static BOOL initflag[3] = {FALSE,FALSE,FALSE}; T_TIME time_val; #endif TRACE_FUNCTION( "grr_random_value" ); if(index > 2) { TRACE_ERROR("Invalid inex in random value generation function"); return(0); } #ifdef _SIMULATION_ if (grr_data->tc.res_random) { UBYTE i; TRACE_EVENT( "grr_data->tc.res_random is set" ); for (i=0; i<3; i++) { next[i] = 1; } grr_data->tc.res_random = 0; } #endif #ifdef _TARGET_ /* on target each random value sequence is initialized on its first usage */ /* with system time to get different sequences for each mobile and each */ /* caller */ if(initflag[index] EQ FALSE) { vsi_t_time (VSI_CALLER &time_val); next[index] = (ULONG)time_val; initflag[index] = TRUE; } #endif next[index] = next[index] * 1103515245 + 12345; return_value = (next[index]/65536) % (max_i); #ifndef _TARGET_ TRACE_EVENT_P3("random index: %d max: %d value: %d",index, max_i, return_value); #endif /* _TARGET_ */ return(return_value); } /* +------------------------------------------------------------------------------ | Function : grr_decode_tbf_start_abs |------------------------------------------------------------------------------ | Description : The function grr_decode_tbf_start_abs() translates the TBF- | Starting-Time-Absolute into full frame number. Therefore the | received frame number is needed in grr_data->dl_fn !! | | Parameters : ptr2tbf_abs - pointer to the tbf_abs structure to be decoded | +------------------------------------------------------------------------------ */ GLOBAL ULONG grr_decode_tbf_start_abs(T_abs *ptr2tbf_abs) { ULONG var1,var2,var3,result; UBYTE var4; TRACE_FUNCTION( "grr_decode_tbf_start_abs" ); var3 = (ULONG)ptr2tbf_abs->t3; var2 = (ULONG)ptr2tbf_abs->t2; var1 = (ULONG)ptr2tbf_abs->t1; result = (51 * ((26+var3 - var2)%26) + var3 + 1326 * var1); /* see GSM 04.08 v 6.4.2 section 10.5.2.38 */ /* T_abs delivers only the fn modulo 42432 so it has to be adjusted to the */ /* current fn.*/ result += (grr_data->dl_fn-(grr_data->dl_fn%42432)); if(result < grr_data->dl_fn) { if((result + 10808) < grr_data->dl_fn) { result += 42432; } } else if(result > (grr_data->dl_fn + 31623)) { if(result < 42432) result += 2715648; result -= 42432; } /* fn has to be aligned to first tdma frame in a block */ var4 = (UBYTE)(result%13); if(var4 > 8) result += (13 - var4); else if(var4 > 4) result += (8 - var4); else if(var4 > 0) result += (4 - var4); if(FN_MAX <= result) result %= FN_MAX; return result; } /* grr_decode_tbf_start_abs */ /* +------------------------------------------------------------------------------ | Function : grr_decode_tbf_start_rel |------------------------------------------------------------------------------ | Description : The function grr_decode_tbf_start_rel() translates the TBF- | Starting-Time-Relative into full frame number. Therefore the | received frame number is needed in start_fn !! | | Parameters : rel_pos - number in blocks added to current framenuber | +------------------------------------------------------------------------------ */ GLOBAL ULONG grr_decode_tbf_start_rel(ULONG start_fn, USHORT rel_pos) { ULONG result; TRACE_FUNCTION( "grr_decode_tbf_start_rel" ); result = 4+4*rel_pos + start_fn + rel_pos/3; if ((12 EQ (result%13)) OR (7 EQ (result%13)) OR (3 EQ (result%13))) { result += 1; } if(FN_MAX <= result) { result %= FN_MAX; } return result; } /* grr_decode_tbf_start_rel */ /* +------------------------------------------------------------------------------ | Function : grr_calc_nr_of_set_bits +------------------------------------------------------------------------------ | Description : this function calculates the number of set bits | (for example timeslots) form value | | Parameters : value - input value | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grr_calc_nr_of_set_bits ( UBYTE value ) { UBYTE tx_slots=0; UBYTE mask=128; UBYTE i; TRACE_FUNCTION( "grr_calc_nr_of_set_bits" ); for(i=0; i<=7; i++) { if(value & mask) tx_slots++; mask>>=1; } /* if(tx_slots > 1) { TRACE_EVENT_P1("MULTISLOT: %d timeslots assigned ",tx_slots); } */ return tx_slots; } /* grr_calc_nr_of_set_bits() */ /* +------------------------------------------------------------------------------ | Function : grr_check_dist +------------------------------------------------------------------------------ | Description : The function grr_check_dist() checks if high_i is bigger/equal | than low_i(modulo calculation). | The return value is true, if high_i is equal to low_i or | bigger than low_i. | Parameters : high_i - expected high value | low_i - expected low value | dist_i - max. allowed distance between high_i and low_i +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_check_dist ( ULONG high_i, ULONG low_i, ULONG dist_i) { BOOL result = FALSE; ULONG real_dist; TRACE_FUNCTION( "grr_check_dist" ); if (high_i >= low_i) real_dist = high_i - low_i; else real_dist = high_i + (FN_MAX-low_i); if (real_dist <= dist_i ) { result = TRUE; } return result; } /* grr_check_dist() */ /* +------------------------------------------------------------------------------ | Function : handle_ms_cap +------------------------------------------------------------------------------ | Description : The function handle_ms_cap() checks if the ms capability is | fulfilled or not | Parameters : - +------------------------------------------------------------------------------ */ GLOBAL BOOL handle_ms_cap (UBYTE msg_type) { UBYTE ms_class_index, dl_mask, ul_mask; BOOL check_ul; BOOL check_dl; TRACE_FUNCTION( "handle_ms_cap" ); /* * use current slot mask if now new is assigned * */ if(grr_data->downlink_tbf.ts_usage) { dl_mask = grr_data->downlink_tbf.ts_usage; } else { dl_mask = grr_data->downlink_tbf.ts_mask; } if(grr_data->uplink_tbf.ts_usage) { ul_mask = grr_data->uplink_tbf.ts_usage; } else { ul_mask = grr_data->uplink_tbf.ts_mask; } ms_class_index = grr_get_gprs_ms_class( ) - 1; switch(msg_type) { case UL_ASSIGNMENT: /* * new uplink assignment received */ check_ul = TRUE; if(grr_data->tbf_type EQ CGRLC_TBF_MODE_DL OR grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL ) { check_dl = TRUE; } else { check_dl = FALSE; } break; case DL_ASSIGNMENT: /* * new uplink assignment received */ check_dl = TRUE; if(grr_data->tbf_type EQ CGRLC_TBF_MODE_UL OR grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL ) { check_ul = TRUE; } else { check_ul = FALSE; } break; case UL_DL_ASSIGNMENT: /* * new uplink and downlink assignment received */ check_ul = TRUE; check_dl = TRUE; break; default: { TRACE_ERROR( "unexpected msg_type" ); return FALSE; } } if (check_ul AND ((grr_data->uplink_tbf.nts > grr_data->ms_cap[ms_class_index].Tx ) OR (!grr_data->uplink_tbf.nts))) { TRACE_ERROR( "uplink nts is bigger than allowed ms capability" ); TRACE_EVENT_P8("MS CLASS ERROR 1: ul_mask=%x ul_nts=%d dl_mask=%x dl_nts=%d ms_class=%d Tx=%d Rx=%d sum=%d" ,ul_mask ,grr_data->uplink_tbf.nts ,dl_mask ,grr_data->downlink_tbf.nts ,ms_class_index+1 ,grr_data->ms_cap[ms_class_index].Tx ,grr_data->ms_cap[ms_class_index].Rx ,grr_data->ms_cap[ms_class_index].Sum); return FALSE; } if (check_dl AND ((grr_data->downlink_tbf.nts > grr_data->ms_cap[ms_class_index].Rx) OR (!grr_data->downlink_tbf.nts))) { TRACE_ERROR( "downlink nts is bigger than allowed ms capability" ); TRACE_EVENT_P8("MS CLASS ERROR 2:ul_mask=%x ul_nts=%d dl_mask=%x dl_nts=%d ms_class=%d Tx=%d Rx=%d sum=%d" ,ul_mask ,grr_data->uplink_tbf.nts ,dl_mask ,grr_data->downlink_tbf.nts ,ms_class_index+1 ,grr_data->ms_cap[ms_class_index].Tx ,grr_data->ms_cap[ms_class_index].Rx ,grr_data->ms_cap[ms_class_index].Sum); return FALSE; } if (check_dl AND check_ul ) { UBYTE help; if (((grr_data->uplink_tbf.nts + grr_data->downlink_tbf.nts) > grr_data->ms_cap[ms_class_index].Sum) OR (!grr_data->uplink_tbf.nts) OR (!grr_data->downlink_tbf.nts)) { TRACE_ERROR( "Sum bigger than allowed ms capability" ); TRACE_EVENT_P8("MS CLASS ERROR 3:ul_mask=%x ul_nts=%d dl_mask=%x dl_nts=%d ms_class=%d Tx=%d Rx=%d sum=%d" ,ul_mask ,grr_data->uplink_tbf.nts ,dl_mask ,grr_data->downlink_tbf.nts ,ms_class_index+1 ,grr_data->ms_cap[ms_class_index].Tx ,grr_data->ms_cap[ms_class_index].Rx ,grr_data->ms_cap[ms_class_index].Sum); return FALSE; } help = grr_calculate_Ttb(ul_mask,dl_mask); if (help < grr_data->ms_cap[ms_class_index].Ttb) { TRACE_ERROR("Ttb calculated not equal to the one of the multislot class "); TRACE_EVENT_P5("ul_mask=%x dl_mask=%x ms_class=%d calc_ttb=%d ms_class_TTB=%d " ,ul_mask ,dl_mask ,ms_class_index+1 ,help ,grr_data->ms_cap[ms_class_index].Ttb); return FALSE; } help = grr_calculate_Tra(ul_mask,dl_mask); if ( help < grr_data->ms_cap[ms_class_index].Tra ) { TRACE_ERROR("Tra calculated not equal to the one of the multislot class "); TRACE_EVENT_P5("ul_mask=%x dl_mask=%x ms_class=%d calc_tra=%d ms_class_tra=%d " ,ul_mask ,dl_mask ,ms_class_index+1 ,help ,grr_data->ms_cap[ms_class_index].Tra); return FALSE; } } return TRUE; } /* handle_ms_cap() */ /* +------------------------------------------------------------------------------ | Function : grr_copy_em1_struct +------------------------------------------------------------------------------ | Description : The function grr_copy_em1_struct copies the em1 struct | parameters. | | Parameters : db_em1 - em1 structure in the GRR database | ext_em1 - em1 structure in the EXT measurement parameter | cpy_prm_set - indicates whether the new extended measurement | parameter overwrite the present ones due to a | messsage with higher sequence number | +------------------------------------------------------------------------------ */ LOCAL void grr_copy_em1_struct( T_XMEAS_EM1 *db_em1, T_em1 *ext_em1, BOOL cpy_prm_set, UBYTE *start_ext_lst_idx, UBYTE *stop_ext_lst_idx ) { UBYTE i, j, m, n; TRACE_FUNCTION("grr_copy_em1_struct"); if( cpy_prm_set ) { /* * Copy EM1 struct parameters */ db_em1->param.reporting_type = REP_TYPE_1; if(ext_em1->flag) { /* * check ext_reporting_type */ switch(ext_em1->xrep_type) { case XREP_TYPE1: /* 00 */ db_em1->param.reporting_type = REP_TYPE_1; break; case XREP_TYPE2: /* 01 */ db_em1->param.reporting_type = REP_TYPE_2; db_em1->param.ncc_permitted = ext_em1->ncc_permitted; break; case XREP_TYPE3: /* 10 */ db_em1->param.reporting_type = REP_TYPE_3; if(ext_em1->v_int_freq) { db_em1->param.int_frequency = ext_em1->int_freq; } else { db_em1->param.int_frequency = NOT_SET; } break; case XREP_RESERVED: /* 11 */ db_em1->param.reporting_type = REP_TYPE_RES; break; } } /* * Check ext reporting period */ db_em1->param.reporting_period = EXT_REP_PER_DEFAULT; if(ext_em1->v_xrep_per) { db_em1->param.reporting_period = ext_em1->xrep_per; } } /* * Copy extended frequency list Parameters */ if(db_em1->list.number < RRGRR_MAX_ARFCN_EXT_MEAS) { /* * copy first EXT Frequency list structure */ j = db_em1->list.number; *start_ext_lst_idx = db_em1->list.number; db_em1->list.freq[j] = ext_em1->xfreq_list.start_freq; j++; /* * check remaining frequencies */ for( i = 0; i < ext_em1->xfreq_list.nr_freq AND j < RRGRR_MAX_ARFCN_EXT_MEAS; i++ ) { db_em1->list.freq[j] = ( db_em1->list.freq[j-1] + ext_em1->xfreq_list.freq_diff_struct[i].freq_diff ) % 1024; j++; } /* * check whether EXT Frequency list structure is repeated */ if(ext_em1->v_xfreq_list2) { for( m = 0; m < ext_em1->c_xfreq_list2 AND j < RRGRR_MAX_ARFCN_EXT_MEAS; m++ ) { db_em1->list.freq[j] = ext_em1->xfreq_list2[m].start_freq; j++; for( n = 0; n < ext_em1->xfreq_list2[m].nr_freq AND j < RRGRR_MAX_ARFCN_EXT_MEAS; n++ ) { db_em1->list.freq[j] = ( db_em1->list.freq[j-1] + ext_em1->xfreq_list2[m].freq_diff_struct[n].freq_diff ) % 1024; j++; } } } db_em1->list.number = j; *stop_ext_lst_idx = db_em1->list.number - 1; } else { TRACE_ERROR("grr_copy_em1_struct EXT frequency list full"); } }/* grr_copy_em1_struct*/ /* +------------------------------------------------------------------------------ | Function : grr_prcs_xmeas_struct +------------------------------------------------------------------------------ | Description : | | Parameters : db_xmeas - extended measurement parameter in the GRR database | air_xmeas - extended measurement parameter of the air interface | message | cpy_prm_set - indicates whether the new extended measurement | parameter overwrite the present ones due to a | messsage with higher sequence number | new_idx - sequence number of the message | +------------------------------------------------------------------------------ */ GLOBAL void grr_prcs_xmeas_struct ( T_XMEAS *db_xmeas, T_xmeas_par *air_xmeas, BOOL cpy_prm_set, UBYTE new_inst_idx, UBYTE *start_ext_lst_idx, UBYTE *stop_ext_lst_idx ) { TRACE_FUNCTION( "grr_prcs_xmeas_struct" ); /* * check ext meas order parameters: */ switch(air_xmeas->xmeas_order) { case XMEAS_EM1: /* 01 */ db_xmeas->em_order_type = EM_EM1; if( cpy_prm_set ) { db_xmeas->idx = new_inst_idx; } grr_copy_em1_struct( &db_xmeas->em1, &air_xmeas->em1, cpy_prm_set, start_ext_lst_idx, stop_ext_lst_idx ); break; case XMEAS_RESET: /* 11 */ db_xmeas->em_order_type = EM_RESET; break; case XMEAS_EM0: /* 00 */ case XMEAS_RESERVED: /* 10 it is reseved but shall be interpreted as EM0 by the receiver */ db_xmeas->em_order_type = EM_EM0; break; } }/* grr_prcs_xmeas_struct */ /* +------------------------------------------------------------------------------ | Function : grr_init_xmeas_struct +------------------------------------------------------------------------------ | Description : | | Parameters : xmeas - pointer to extended measurement parameter | +------------------------------------------------------------------------------ */ GLOBAL void grr_init_xmeas_struct( T_XMEAS *xmeas ) { TRACE_FUNCTION( "grr_init_xmeas_struct" ); xmeas->idx = NOT_SET; xmeas->em_order_type = EM_EMPTY; xmeas->em1.list.number = 0; xmeas->em1.param.int_frequency = NOT_SET; }/* grr_init_xmeas_struct */ /* +------------------------------------------------------------------------------ | Function : grr_prcs_nc_freq_list +------------------------------------------------------------------------------ | Description : | | Parameters : db_list - NC frequency list in the GRR database | v_air_list - valid flag for NC frequency list of the air | interface message | air_list - NC frequency list of the air interface message | +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_prcs_nc_freq_list ( T_NC_LIST *nc_list, T_NC_RFREQ_LIST *rfreq_list, BOOL v_air_list, T_nc_freq_list *air_list, T_INFO_TYPE type, UBYTE instance ) { UBYTE i, j; /* used for counting */ TRACE_FUNCTION( "grr_prcs_nc_freq_list" ); if( v_air_list EQ TRUE ) { if( air_list->v_list_rf EQ TRUE ) { /* process the list of removed frequencies */ for( i = 0; i < air_list->list_rf.c_rfreq_index AND rfreq_list->number < MAX_NR_OF_NCELL; i++ ) { rfreq_list->idx[rfreq_list->number] = air_list->list_rf.rfreq_index[i]; rfreq_list->number++; } if( i < air_list->list_rf.c_rfreq_index ) { TRACE_ERROR( "grr_prcs_nc_freq_list removed frequency list full" ); } } if( air_list->v_list_af EQ TRUE ) { UBYTE number = 0; USHORT last_freq; /* process the list of added frequencies */ for( i = 0; i < air_list->c_list_af; i++ ) { last_freq = 0; if( grr_store_cs_param ( nc_list, air_list->list_af[i].v_cs_par, &air_list->list_af[i].cs_par, type, instance, &number, &last_freq, air_list->list_af[i].start_freq, air_list->list_af[i].bsic ) EQ FALSE ) { TRACE_EVENT( "grr_prcs_nc_freq_list: NC_MS list full" ); return( v_air_list ); } for( j = 0; j < air_list->list_af[i].nr_freq; j++ ) { if( grr_store_cs_param ( nc_list, air_list->list_af[i].afreq_s[j].v_cs_par, &air_list->list_af[i].afreq_s[j].cs_par, type, instance, &number, &last_freq, air_list->list_af[i].afreq_s[j].freq_diff_struct.freq_diff, air_list->list_af[i].afreq_s[j].bsic ) EQ FALSE ) { TRACE_EVENT( "grr_prcs_nc_freq_list: NC_MS list full" ); return( v_air_list ); } } } } } return( v_air_list ); }/* grr_prcs_nc_freq_list */ /* +------------------------------------------------------------------------------ | Function : grr_prcs_nc_freq_final +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_prcs_nc_freq_final ( T_NC_LIST *dest_list, T_NC_RFREQ_LIST *dest_rfreq, BOOL *v_src_list_rfreq, T_NC_LIST *src_list, T_NC_RFREQ_LIST *src_rfreq ) { BOOL is_pbcch_present = grr_is_pbcch_present( ); BOOL is_identical; UBYTE i; TRACE_FUNCTION( "grr_prcs_nc_freq_final" ); if( *v_src_list_rfreq EQ TRUE ) { *v_src_list_rfreq = FALSE; /* * The change mark values should be increased in case * at least one parameter has changed */ if( dest_list->number EQ src_list->number AND dest_rfreq->number EQ src_rfreq->number ) { is_identical = TRUE; for( i = 0; i < dest_list->number AND is_identical; i++ ) { if( is_pbcch_present ) { is_identical = ( dest_list->info[i].arfcn EQ src_list->info[i].arfcn AND dest_list->info[i].bsic EQ src_list->info[i].bsic ); } else { is_identical = ( dest_list->info[i].arfcn EQ src_list->info[i].arfcn ); } } for( i = 0; i < dest_rfreq->number AND is_identical; i++ ) { is_identical = ( dest_rfreq->idx[i] EQ src_rfreq->idx[i] ); } } else { is_identical = FALSE; } if( !is_identical ) { dest_list->chng_mrk.curr++; } /* copy remaining parameters except change mark */ dest_list->number = src_list->number; memcpy( dest_list->info, src_list->info, sizeof( T_ncell_info ) * src_list->number ); memcpy( dest_rfreq, src_rfreq, sizeof( T_NC_RFREQ_LIST ) ); } else { if( dest_list->number NEQ 0 OR dest_rfreq->number NEQ 0 ) { dest_list->number = 0; dest_rfreq->number = 0; dest_list->chng_mrk.curr++; } } }/* grr_prcs_nc_freq_final */ /* +------------------------------------------------------------------------------ | Function : grr_prcs_nc_param_struct +------------------------------------------------------------------------------ | Description : | | Parameters : db_nc - NC measurement parameter in the GRR database | air_nc - NC measurement parameter of the air interface | message | new_idx - sequence number of the message | +------------------------------------------------------------------------------ */ GLOBAL void grr_prcs_nc_param_struct ( T_NC_PARAM *db_nc, T_nc_meas_par *ext_nc, UBYTE new_idx ) { T_NC_ORDER ctrl_order; /* NETWORK_CONTROL_ORDER */ UBYTE non_drx_per; /* NC_NON_DRX_PERIOD */ UBYTE rep_per_i; /* NC_REPORTING_PERIOD_I */ UBYTE rep_per_t; /* NC_REPORTING_PERIOD_T */ TRACE_FUNCTION( "grr_prcs_nc_param_struct" ); /* * Store the network control order value in a temporary buffer */ switch( ext_nc->ctrl_order ) { case NCMEAS_NC0 : ctrl_order = NC_NC0; break; case NCMEAS_NC1 : ctrl_order = NC_NC1; break; case NCMEAS_NC2 : ctrl_order = NC_NC2; break; case NCMEAS_RESET : default : ctrl_order = NC_RESET; break; } /* * Store the remaining parameters in temporary buffers */ if(ext_nc->v_nc_meas_per) { non_drx_per = ext_nc->nc_meas_per.non_drx_per; rep_per_i = ext_nc->nc_meas_per.rep_per_i; rep_per_t = ext_nc->nc_meas_per.rep_per_t; } else { /* * Use default values, see 04.60 PSI5 Information Element Details */ non_drx_per = NC_NON_DRX_PER_DEFAULT; rep_per_i = NC_REP_PER_I_DEFAULT; rep_per_t = NC_REP_PER_T_DEFAULT; } /* * The change mark values should be increased in case * at least one parameter has changed */ if( db_nc->ctrl_order NEQ ctrl_order OR db_nc->non_drx_per NEQ non_drx_per OR db_nc->rep_per_i NEQ rep_per_i OR db_nc->rep_per_t NEQ rep_per_t ) { db_nc->chng_mrk.curr++; } db_nc->idx = new_idx; db_nc->ctrl_order = ctrl_order; db_nc->non_drx_per = non_drx_per; db_nc->rep_per_i = rep_per_i; db_nc->rep_per_t = rep_per_t; }/* grr_prcs_nc_param_struct */ /* +------------------------------------------------------------------------------ | Function : grr_prcs_nc_param_final +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_prcs_nc_param_final ( T_NC_PARAM *dest_nc, BOOL *v_src_nc, T_NC_PARAM *src_nc ) { TRACE_FUNCTION( "grr_prcs_nc_param_final" ); if( *v_src_nc EQ TRUE ) { *v_src_nc = FALSE; /* * The change mark values should be increased in case * at least one parameter has changed */ if( dest_nc->ctrl_order NEQ src_nc->ctrl_order OR dest_nc->non_drx_per NEQ src_nc->non_drx_per OR dest_nc->rep_per_i NEQ src_nc->rep_per_i OR dest_nc->rep_per_t NEQ src_nc->rep_per_t ) { dest_nc->chng_mrk.curr++; } /* Copy remaining parameters except change mark */ dest_nc->idx = src_nc->idx; dest_nc->ctrl_order = src_nc->ctrl_order; dest_nc->non_drx_per = src_nc->non_drx_per; dest_nc->rep_per_i = src_nc->rep_per_i; dest_nc->rep_per_t = src_nc->rep_per_t; } }/* grr_prcs_nc_param_final */ /* +------------------------------------------------------------------------------ | Function : grr_init_ncmeas_struct +------------------------------------------------------------------------------ | Description : | | Parameters : ncmeas - pointer to NC measurement parameter | is_cw - indicates whether the parameter pointer is related | to cell wide or MS specific information | +------------------------------------------------------------------------------ */ LOCAL void grr_init_ncmeas_struct( T_NCMEAS *ncmeas, BOOL is_cw ) { TRACE_FUNCTION( "grr_init_ncmeas_struct" ); grr_init_nc_param( &ncmeas->param, is_cw ); grr_init_nc_list( &ncmeas->list ); }/* grr_init_ncmeas_struct */ /* +------------------------------------------------------------------------------ | Function : grr_init_ncmeas_extd_struct +------------------------------------------------------------------------------ | Description : | | Parameters : extd - pointer to NC measurement extended parameter | is_cw - indicates whether the parameter pointer is related | to cell wide or MS specific information | +------------------------------------------------------------------------------ */ GLOBAL void grr_init_ncmeas_extd_struct ( T_NCMEAS_EXTENDED *extd, BOOL is_cw ) { TRACE_FUNCTION( "grr_init_ncmeas_extd_struct" ); grr_init_ncmeas_struct( &extd->ncmeas, is_cw ); grr_init_rfreq_list( &extd->rfreq ); #if defined (REL99) AND defined (TI_PS_FF_EMR) /* * If PMO has not been received, PMO_USED shall be set to zero. * Refer 3GPP TS 04.60 V8.17.0 (2002-12) Table 11.2.9d.2 */ extd->pmo_ind = 0; extd->psi3_cm = NOT_SET; extd->ba_ind = NOT_SET; #endif }/* grr_init_ncmeas_extd_struct */ /* +------------------------------------------------------------------------------ | Function : grr_init_nc_list +------------------------------------------------------------------------------ | Description : | | Parameters : list - pointer to NC measurement list | +------------------------------------------------------------------------------ */ GLOBAL void grr_init_nc_list( T_NC_LIST *list ) { TRACE_FUNCTION( "grr_init_nc_list" ); list->number = 0; }/* grr_init_nc_list */ /* +------------------------------------------------------------------------------ | Function : grr_init_nc_param +------------------------------------------------------------------------------ | Description : | | Parameters : param - pointer to NC measurement parameter | is_cw - indicates whether the parameter pointer is related | to cell wide or MS specific information | +------------------------------------------------------------------------------ */ GLOBAL void grr_init_nc_param( T_NC_PARAM *param, BOOL is_cw ) { TRACE_FUNCTION( "grr_init_nc_param" ); param->ctrl_order = ( is_cw EQ TRUE ? NC_NC0 : NC_EMPTY ); param->idx = NOT_SET; }/* grr_init_nc_param */ /* +------------------------------------------------------------------------------ | Function : grr_init_rfreq_list +------------------------------------------------------------------------------ | Description : | | Parameters : list - pointer to NC measurement removed frequency list | +------------------------------------------------------------------------------ */ LOCAL void grr_init_rfreq_list ( T_NC_RFREQ_LIST *list ) { TRACE_FUNCTION( "grr_init_rfreq_list" ); list->number = 0; }/* grr_init_rfreq_list */ /* +------------------------------------------------------------------------------ | Function : grr_sort_ext_lst_freq +------------------------------------------------------------------------------ | Description : | Parameters : +------------------------------------------------------------------------------ */ GLOBAL void grr_sort_ext_lst_freq ( T_EXT_FREQ_LIST *list, UBYTE max_number, T_EXT_START_STOP *start_stop ) { UBYTE i, j; /* used for counting */ T_EXT_FREQ_LIST tmp_list; /* temporary copy of EXT frequency list */ tmp_list.number = 0; TRACE_FUNCTION( "grr_sort_ext_lst_freq" ); for( i = 0; i < max_number; i++ ) { if( start_stop[i].start NEQ RRGRR_INVALID_IDX AND start_stop[i].stop NEQ RRGRR_INVALID_IDX ) { for( j = start_stop[i].start; j <= start_stop[i].stop; j++ ) { tmp_list.freq[tmp_list.number] = list->freq[j]; tmp_list.number++; } } } for( j = 0; j < tmp_list.number; j++ ) { list->freq[j] = tmp_list.freq[j]; } grr_mrk_ext_lst_freq( list ); } /* grr_sort_ext_lst_freq() */ /* +------------------------------------------------------------------------------ | Function : grr_mrk_ext_lst_freq +------------------------------------------------------------------------------ | Description : ... | | Parameters : ... | +------------------------------------------------------------------------------ */ LOCAL void grr_mrk_ext_lst_freq ( T_EXT_FREQ_LIST *list ) { UBYTE i, j; TRACE_FUNCTION( "grr_mrk_ext_lst_freq" ); if( list->number NEQ 0 ) { for( i = 0; i < list->number - 1; i++ ) { for( j = i + 1; j < list->number AND IS_NOT_FLAGGED( list->freq[i], EM_VLDTY_ARFCN_MASK, EM_NON_VLD_ARFCN ); j++ ) { if( list->freq[i] EQ list->freq[j] ) { SET_FLAG( list->freq[i], EM_VLDTY_ARFCN_MASK, EM_NON_VLD_ARFCN, USHORT ); } } } } }/* grr_mrk_ext_lst_freq */ /* +------------------------------------------------------------------------------ | Function : grr_create_channel_list +------------------------------------------------------------------------------ | Description : The function grr_create_channel_list() | Use a function from RR entity to extract frequencies from a frequency list structure | defined in 04.08 | This function copies the frequencies into list. This function takes the arranging | of ARFCN into account cf. 12.10a GPRS Mobile Allocation in 04.60 | Parameters : T_rfl*: pointer to the rfl received in PSI2 and UBYTE*list: pointer to | the list similar to T_LIST +------------------------------------------------------------------------------ */ GLOBAL void grr_create_channel_list(T_rfl* rfl, UBYTE* list) { T_f_range rfl_contents; UBYTE i; TRACE_FUNCTION( "grr_create_channel_list" ); /* * Copy RFL contents into the T_LIST */ memset (&rfl_contents, 0, sizeof(T_f_range)); /* * Length in bits */ rfl_contents.l_f = (rfl->rfl_cont_len+3)*8; /* * Copy RFL content bits into the structure */ for(i=0; i < rfl->c_rfl_cont; i++) { rfl_contents.b_f[i] = rfl->rfl_cont[i].flist; } /* * Use a function from RR * This function copies the frequencies into list. This function takes the arranging * of ARFCN into account cf. 12.10a GPRS Mobile Allocation in 04.60 */ for_create_channel_list (&rfl_contents, (T_LIST*)list); }/* grr_create_channel_list */ /* +------------------------------------------------------------------------------ | Function : grr_get_si_cell_alloc_list +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL void grr_get_si_cell_alloc_list( T_LIST *list ) { #ifndef _TARGET_ T_LIST cell_chan_des = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa, 0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0x00,0x00 }; #endif TRACE_FUNCTION( "grr_get_si_cell_alloc_list" ); /* * Use cell allocation in SI1 */ /* Cell allocation is stored in rr at */ /* rr_data->sc_data.cd.cell_chan_desc for now use hazardous hack of */ /* access database of RR entity later make a new entity that replaces */ /* RR and GRR or make a communication between RR and GRR to transfer */ /* list. */ /* Used selfmade glumps hack function in RR to get cell allocation */ /* because getting typedefs from RR to use rr_data pointer is not */ /* that easy cause by name equalities in RR and GRR */ #ifndef _TARGET_ srv_merge_list( list, &cell_chan_des ); #else /* TRACE_EVENT( "Use cell allocation in S1" ); */ srv_get_cell_alloc_list( list ); #endif } /* grr_get_si_cell_alloc_list */ /* +------------------------------------------------------------------------------ | Function : grr_get_psi_cell_alloc_list +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL BOOL grr_get_psi_cell_alloc_list ( T_LIST *list ) { BOOL rfl_not_found = FALSE; UBYTE n; UBYTE i; TRACE_FUNCTION( "grr_get_psi_cell_alloc_list" ); for( n = 0; n < MAX_CELL_ALLOC; n++ ) { if( psc_db->cell_alloc[n].rfl_num EQ NOT_SET ) { if( n EQ 0 ) { #ifdef _SIMULATION_ TRACE_ASSERT( FALSE ); #endif /* #ifdef _SIMULATION_ */ rfl_not_found = TRUE; } break; } /* find rfl list with that number */ i = 0; /* do not check the RFL received in an assignment message */ while( i < MAX_RFL ) { if( psc_db->rfl[i].num EQ psc_db->cell_alloc[n].rfl_num ) { /* TRACE_EVENT_P1( "psc_db->rfl[i].num:%d", psc_db->rfl[i].num ); */ break; } i++; } if( MAX_RFL > i ) { srv_merge_list( list, /* output, result */ (T_LIST *)psc_db->rfl[i].list ); } else { #ifdef _SIMULATION_ TRACE_ASSERT( FALSE ); #endif /* #ifdef _SIMULATION_ */ rfl_not_found = TRUE; break; } } return( rfl_not_found EQ FALSE ); } /* grr_get_psi_cell_alloc_list */ /* +------------------------------------------------------------------------------ | Function : grr_get_ms_alloc_list +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL BOOL grr_get_ms_alloc_list ( T_LIST *list, const T_gprs_ms_alloc_ie *ms_alloc ) { BOOL rfl_not_found = FALSE; UBYTE n; UBYTE i; TRACE_FUNCTION( "grr_get_ms_alloc_list" ); for( n = 0; n < ms_alloc->c_rfl_num_list; n++ ) { if( ms_alloc->rfl_num_list[n].rfl_num EQ NOT_SET ) { #ifdef _SIMULATION_ TRACE_ASSERT( FALSE ); #endif /* #ifdef _SIMULATION_ */ rfl_not_found = TRUE; break; } /* find rfl list with that number */ i = 0; while( i <= MAX_RFL ) { if( psc_db->rfl[i].num EQ ms_alloc->rfl_num_list[n].rfl_num ) { break; } i++; } if( MAX_RFL >= i ) { srv_merge_list( list, /* output, result */ (T_LIST *)psc_db->rfl[i].list ); } else { #ifdef _SIMULATION_ TRACE_ASSERT( FALSE ); #endif /* #ifdef _SIMULATION_ */ rfl_not_found = TRUE; break; } } return( rfl_not_found EQ FALSE ); } /* grr_get_ms_alloc_list */ /* +------------------------------------------------------------------------------ | Function : grr_create_freq_list +------------------------------------------------------------------------------ | Description : The function grr_create_freq_list() | | Get the according GPRS Mobile Allocation: Take into account MA_NUMBER | Write frequencies into frequency list | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_create_freq_list( UBYTE ma_num, UBYTE maio, T_p_chan_sel *chan_sel, T_p_freq_list *freq_list ) { BOOL pbcch_is_present = grr_is_pbcch_present( ); UBYTE n = 0; T_gprs_ms_alloc_ie *gp_ma = NULL; T_LIST list1; USHORT list2[64]; TRACE_FUNCTION( "grr_create_freq_list" ); memset(&list1, 0, sizeof(T_LIST)); memset(list2, NOT_PRESENT_16BIT, sizeof(list2)); gp_ma = grr_get_gprs_ma (ma_num); if( gp_ma EQ NULL ) { TRACE_EVENT("No valid GPRS_MA found"); return FALSE; } /* * Copy hopping sequence number and mobile allocation index offset */ chan_sel->p_rf_ch.arfcn = ( ( USHORT )gp_ma->hsn << 8 ) | ( USHORT )maio; /* Now we have the GPRS Mobile Allocation corresponding to the ma_num. * Get the referenced set of radio frequency lists for this * particular GPRS Mobile Allocation IE. * If RFL number list is not present in the IE, then cell allocation * would be returned by this function. */ if(!grr_get_ref_list_or_cell_allocation(&list1,gp_ma,ma_num)) { TRACE_ERROR("Could not get ref list"); return FALSE; } /* * Copy ARFCN values into freq_list */ srv_create_list (&list1, list2, 64, TRUE, 0); /* * Take MA_BITMAP or ARFCN_INDEX into account */ grr_ma_filter_list( list2, /* input*/ freq_list->p_rf_chan_no.p_radio_freq, /* output*/ gp_ma ); /* * Get number of copied frequencies */ if(!grr_validate_and_count_frequencies(freq_list->p_rf_chan_no.p_radio_freq, &(freq_list->p_rf_chan_cnt))) { TRACE_ERROR( "grr_create_freq_list: validation failed/freq count zero" ); return FALSE; } chan_sel->hopping = 1; /* Frequencies stored in freq_list are in form used by 3GPP(g23) standards. * convert them to the form used by L1. */ for( n = 0; n < freq_list->p_rf_chan_cnt; n++ ) { freq_list->p_rf_chan_no.p_radio_freq[n] = grr_g23_arfcn_to_l1( freq_list->p_rf_chan_no.p_radio_freq[n] ); } return TRUE; }/* grr_create_freq_list*/ /* +------------------------------------------------------------------------------ | Function : grr_ma_filter_list +------------------------------------------------------------------------------ | Description : The function grr_ma_filter_list() | takes MA_BITMAP or ARFCN_INDEX into account | | | Parameters : list1 pointer to the input list | list2: pointer to the output list | gp_ma: pointer to the GPRS Mobile Allocation +------------------------------------------------------------------------------ */ GLOBAL void grr_ma_filter_list( USHORT* list1, /* input*/ USHORT* list2, /* output*/ const T_gprs_ms_alloc_ie* gp_ma ) { UBYTE m,n,i,j; TRACE_FUNCTION("grr_ma_filter_list"); if(gp_ma->v_ma_struct) { /* * MA_BITMAP is valid. First received bit corresponds to the last of T_LIST * and the last value of */ i=0, j=0; for(n=gp_ma->ma_struct.c_ma_map; n NEQ 0; n--) { if(gp_ma->ma_struct.ma_map[n-1]) { /* * Corresponding frequency is valid */ list2[j] = list1[i]; j++; } i++; if(list1[i] EQ NOT_PRESENT_16BIT) break; } list2[j] = NOT_PRESENT_16BIT; } else { /* * Check whether ARFCN list is valid or not */ if(gp_ma->v_arfcn_index_list) { BOOL is_index_in_the_list=FALSE; /* * ARFCN Index list is valid */ i=0, j=0; for(n=0; n < 64; n++) { for(m=0; m < gp_ma->c_arfcn_index_list; m++) { if(n EQ gp_ma->arfcn_index_list[m].arfcn_index) { /* * ARFCN_INDEX is in the list */ is_index_in_the_list = TRUE; break; } } if(!is_index_in_the_list) { list2[j] = list1[i]; j++; } is_index_in_the_list = FALSE; i++; if(list1[i] EQ NOT_PRESENT_16BIT) break; } list2[j] = NOT_PRESENT_16BIT; } else { /* * All radio frequencies are valid */ /*list2 = list1;*/ memcpy(list2, list1, 64*sizeof(USHORT)); } } }/* grr_ma_filter_list*/ /* +------------------------------------------------------------------------------ | Function : grr_calc_t_diff +------------------------------------------------------------------------------ | Description : The function grr_calc_t_diff() calculates the difference | between two time stamps taken into account an overflow of the | system ticks counter value. | | Parameters : t_start - starting time | t_stop - stopping time | +------------------------------------------------------------------------------ */ GLOBAL T_TIME grr_calc_t_diff (T_TIME t_start, T_TIME t_stop) { T_TIME t_diff; TRACE_FUNCTION("grr_calc_t_diff"); if( t_start <= t_stop ) { t_diff = t_stop - t_start; } else { t_diff = t_stop + ( ( ~ ( (T_TIME)0 ) ) - t_start ) + 1; } return( t_diff ); }/*grr_calc_t_diff()*/ /* +------------------------------------------------------------------------------ | Function : grr_prepare_db_for_new_cell +------------------------------------------------------------------------------ | Description : The function grr_prepare_db_for_new_cell prepares the psi | parameters and sc_db parameters like pbcch and pccch for | reading new SI13 and if needed PSI messages | | Parameters : void +------------------------------------------------------------------------------ */ GLOBAL void grr_prepare_db_for_new_cell ( void ) { TRACE_FUNCTION("grr_prepare_db_for_new_cell"); psi_init(); /*initial PCCCH organization parameters */ memset(&psc_db->pccch, 0, sizeof(T_pccch_org_par)); /* Initial paging group*/ memset(&psc_db->paging_group, 0, sizeof(T_PAGING_GROUP)); psc_db->cell_info_for_gmm.cell_info.cell_env.rai.rac = GMMRR_RAC_INVALID; grr_set_pbcch( FALSE ); }/* grr_prepare_db_for_new_cell*/ /* +------------------------------------------------------------------------------ | Function : grr_is_non_drx_mode +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_is_non_drx_mode ( void ) { TRACE_FUNCTION( "grr_is_non_drx_mode" ); return( grr_data->ms.split_pg_cycle EQ GMMRR_NO_DRX OR ( grr_data->ms.split_pg_cycle NEQ GMMRR_NO_DRX AND grr_is_non_drx_period( ) EQ TRUE ) ); }/* grr_is_non_drx_mode */ /* +------------------------------------------------------------------------------ | Function : grr_is_non_drx_period +------------------------------------------------------------------------------ | Description : | | Parameters : Input: void | Return: Sends TRUE if one of the three NON DRX period is valid, | otherwise FALSE; | +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_is_non_drx_period ( void ) { TRACE_FUNCTION( "grr_is_non_drx_period" ); return( psc_db->gprs_attach_is_running OR psc_db->non_drx_timer_running OR psc_db->nc2_non_drx_period_running ); }/* grr_is_non_drx_period */ /* +------------------------------------------------------------------------------ | Function : grr_handle_non_drx_period +------------------------------------------------------------------------------ | Description : Handles the timer of non DRX mode | | Parameters : non_drx_type - type of non DRX mode | non_drx_timer_running - indicates whether non DRX period | is active or not +------------------------------------------------------------------------------ */ GLOBAL void grr_handle_non_drx_period ( T_NON_DRX_TYPE non_drx_type, BOOL non_drx_timer_running ) { TRACE_FUNCTION( "grr_handle_non_drx_period" ); switch( non_drx_type ) { case TRANSFER_NDRX: psc_db->non_drx_timer_running = non_drx_timer_running; break; case GMM_NDRX: psc_db->gprs_attach_is_running = non_drx_timer_running; break; case NC2_NDRX: psc_db->nc2_non_drx_period_running = non_drx_timer_running; break; } pg_non_drx( ); }/*grr_handle_non_drx_period*/ /* +------------------------------------------------------------------------------ | Function : grr_store_g_pwr_par +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_store_g_pwr_par ( T_g_pwr_par *g_pwr_par ) { TRACE_FUNCTION( "grr_store_g_pwr_par" ); psc_db->v_g_pwr_par = TRUE; psc_db->g_pwr_par.alpha = CLIP_ALPHA( g_pwr_par->alpha ); psc_db->g_pwr_par.t_avg_w = CLIP_T_AVG( g_pwr_par->t_avg_w ); psc_db->g_pwr_par.t_avg_t = CLIP_T_AVG( g_pwr_par->t_avg_t ); psc_db->g_pwr_par.pb = g_pwr_par->pb; psc_db->g_pwr_par.pc_meas_chan = g_pwr_par->pc_meas_chan; psc_db->g_pwr_par.imeas_chan_list = g_pwr_par->imeas_chan_list; psc_db->g_pwr_par.n_avg_i = g_pwr_par->n_avg_i; grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param = TRUE; } /* grr_store_g_pwr_par */ /* +------------------------------------------------------------------------------ | Function : grr_store_type_pwr_par +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_store_type_pwr_par ( T_pwr_par *pwr_par, BOOL use_prev ) { UBYTE i; /* used for counting */ TRACE_FUNCTION( "grr_store_type_pwr_par" ); grr_set_alpha_flags( TRUE, pwr_par->alpha ); for( i = 0; i < 8; i++ ) { /* * if the information element is not present for certain previously * allocated timeslots, the MS shall continue to use the previous * power on these timeslots */ if( pwr_par->gamma_tn[i].v_gamma OR !use_prev ) { psc_db->pwr_par.gamma_tn[i].v_gamma = pwr_par->gamma_tn[i].v_gamma; psc_db->pwr_par.gamma_tn[i].gamma = pwr_par->gamma_tn[i].gamma; } } grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE; } /* grr_store_type_pwr_par */ /* +------------------------------------------------------------------------------ | Function : grr_store_type_tn_alloc_pwr +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_store_type_tn_alloc_pwr ( T_tn_alloc_pwr *pwr_par ) { UBYTE i; /* used for counting */ TRACE_FUNCTION( "grr_store_type_tn_alloc_pwr" ); grr_set_alpha_flags( TRUE, pwr_par->alpha ); for( i = 0; i < 8; i++ ) { psc_db->pwr_par.gamma_tn[i].v_gamma = pwr_par->usf_array[i].v_usf_g; psc_db->pwr_par.gamma_tn[i].gamma = pwr_par->usf_array[i].usf_g.gamma; } grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE; } /* grr_store_type_tn_alloc_pwr */ /* +------------------------------------------------------------------------------ | Function : grr_store_type_dyn_alloc +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_store_type_dyn_alloc ( T_dyn_alloc *pwr_par ) { UBYTE i; /* used for counting */ TRACE_FUNCTION( "grr_store_type_dyn_alloc" ); grr_set_alpha_flags( pwr_par->v_alpha, pwr_par->alpha ); if( pwr_par->v_usf_gamma_csn1 EQ TRUE ) { for( i = 0; i < 8; i++ ) { psc_db->pwr_par.gamma_tn[i].v_gamma = pwr_par->usf_gamma_csn1[i].v_usf_gamma; psc_db->pwr_par.gamma_tn[i].gamma = pwr_par->usf_gamma_csn1[i].usf_gamma.gamma; } } grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE; } /* grr_store_type_dyn_alloc */ /* +------------------------------------------------------------------------------ | Function : grr_store_type_alf_gam +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_store_type_alf_gam ( T_alf_gam *pwr_par, UBYTE tn ) { TRACE_FUNCTION( "grr_store_type_alf_gam" ); grr_set_alpha_flags( TRUE, pwr_par->alpha ); grr_set_sngl_gamma ( pwr_par->gamma, tn ); grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE; } /* grr_store_type_alf_gam */ /* +------------------------------------------------------------------------------ | Function : grr_store_type_pck_upl_ass_ia +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_store_type_pck_upl_ass_ia ( T_tfi_ass_alloc *pwr_par, UBYTE tn ) { TRACE_FUNCTION( "grr_store_type_pck_upl_ass_ia" ); grr_set_alpha_flags( pwr_par->v_alpha, pwr_par->alpha ); grr_set_sngl_gamma ( pwr_par->gamma, tn ); grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE; } /* grr_store_type_pck_upl_ass_ia */ /* +------------------------------------------------------------------------------ | Function : grr_store_type_pck_snbl_ass_ia +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_store_type_pck_snbl_ass_ia ( T_sngl_block_alloc *pwr_par, UBYTE tn ) { TRACE_FUNCTION( "grr_store_type_pck_snbl_ass_ia" ); grr_set_alpha_flags( pwr_par->v_alpha, pwr_par->alpha ); grr_set_sngl_gamma ( pwr_par->gamma, tn ); } /* grr_store_type_pck_snbl_ass_ia */ /* +------------------------------------------------------------------------------ | Function : grr_store_type_tfi_ass_rlc +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_store_type_tfi_ass_rlc ( T_tfi_ass_rlc *pwr_par, UBYTE tn ) { TRACE_FUNCTION( "grr_store_type_tfi_ass_rlc" ); grr_set_alpha_flags( pwr_par->v_alpha, pwr_par->alpha ); grr_set_sngl_gamma ( pwr_par->gamma, tn ); grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE; } /* grr_store_type_tfi_ass_rlc */ /* +------------------------------------------------------------------------------ | Function : grr_store_type_alpha_gamma +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_store_type_alpha_gamma ( T_alpha_gamma *pwr_par, UBYTE tn ) { TRACE_FUNCTION( "grr_store_type_alpha_gamma" ); grr_set_alpha_flags( TRUE, pwr_par->alpha ); grr_set_sngl_gamma ( pwr_par->gamma, tn ); grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE; } /* grr_store_type_alpha_gamma */ /* +------------------------------------------------------------------------------ | Function : grr_store_type_pwr_ctrl +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_store_type_pwr_ctrl ( T_pwr_ctrl *pwr_par ) { UBYTE i; /* used for counting */ TRACE_FUNCTION( "grr_store_type_pwr_ctrl" ); grr_set_alpha_flags( TRUE, pwr_par->alpha ); for( i = 0; i < 8; i++ ) { psc_db->pwr_par.gamma_tn[i].v_gamma = pwr_par->tagged_gamma[i].v_gamma; psc_db->pwr_par.gamma_tn[i].gamma = pwr_par->tagged_gamma[i].gamma; } grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = TRUE; } /* grr_store_type_pwr_ctrl */ /* +------------------------------------------------------------------------------ | Function : grr_set_alpha_flags +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL void grr_set_alpha_flags ( BOOL v_alpha, UBYTE alpha ) { TRACE_FUNCTION( "grr_set_alpha_flags" ); if( v_alpha ) { psc_db->pwr_par.v_alpha = TRUE; psc_db->pwr_par.alpha = CLIP_ALPHA( alpha ); } psc_db->v_pwr_par = TRUE; } /* grr_set_alpha_flags */ /* +------------------------------------------------------------------------------ | Function : grr_set_sngl_gamma +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL void grr_set_sngl_gamma ( UBYTE gamma, UBYTE tn ) { UBYTE i; /* used for counting */ TRACE_FUNCTION( "grr_set_sngl_gamma" ); for( i = 0; i < 8; i++ ) { psc_db->pwr_par.gamma_tn[i].v_gamma = FALSE; } psc_db->pwr_par.gamma_tn[tn].v_gamma = TRUE; psc_db->pwr_par.gamma_tn[tn].gamma = gamma; } /* grr_set_sngl_gamma */ /* +------------------------------------------------------------------------------ | Function : grr_set_tbf_cfg_req_param +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_set_tbf_cfg_req_param ( T_MPHP_ASSIGNMENT_REQ *tbf_cfg_req ) { TRACE_FUNCTION( "grr_set_tbf_cfg_req_param" ); tbf_cfg_req->assign_id = 0; grr_data->cs.last_assignment_id = tbf_cfg_req->assign_id; tbf_cfg_req->m_class = grr_get_gprs_ms_class( ); tbf_cfg_req->if_meas_enable = meas_im_get_permit( ); tbf_cfg_req->pc_meas_chan = psc_db->g_pwr_par.pc_meas_chan; if( psc_db->gprs_cell_opt.ab_type EQ AB_8_BIT ) { tbf_cfg_req->burst_type = AB_8_BIT; } else { tbf_cfg_req->burst_type = AB_11_BIT; } } /* grr_set_tbf_cfg_req_param */ /* +------------------------------------------------------------------------------ | Function : grr_init_ms_data +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL void grr_init_ms_data ( void ) { TRACE_FUNCTION( "grr_init_ms_data" ); #ifdef _TARGET_ grr_data->ms.reverts_NMO_III = TRUE; grr_data->ms.tbf_mon_ccch = FALSE; /* Target: Not allowed*/ #else grr_data->ms.reverts_NMO_III = FALSE; grr_data->ms.tbf_mon_ccch = TRUE; /* WIN 32: allowed*/ #endif } /* grr_init_ms_data */ /* +------------------------------------------------------------------------------ | Function : grr_update_pacch +------------------------------------------------------------------------------ | Description : The function grr_update_pacch updates the power reduction and | access burst type in case of change and being in transfer mode | | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void grr_update_pacch( void ) { TRACE_FUNCTION( "grr_update_pacch" ); { PALLOC(update_psi, MPHP_UPDATE_PSI_PARAM_REQ); update_psi->pb = psc_db->g_pwr_par.pb; update_psi->burst_type = psc_db->gprs_cell_opt.ab_type; PSEND(hCommL1, update_psi); } } /* grr_update_pacch */ /* +------------------------------------------------------------------------------ | Function : grr_imsi_mod +------------------------------------------------------------------------------ | Description : The function grr_imsi_mod() returns the imsi modulo 1000 | | Parameters : in: NONE out: USHORT imsimod | +------------------------------------------------------------------------------ */ GLOBAL USHORT grr_imsi_mod () { UBYTE i= grr_data->db.ms_id.imsi.number_of_digits; TRACE_FUNCTION("grr_imsi_mod "); return ((SHORT)grr_data->db.ms_id.imsi.digit[i - 3] * 100 + (SHORT)grr_data->db.ms_id.imsi.digit[i - 2] * 10 + (SHORT)grr_data->db.ms_id.imsi.digit[i - 1]); } /* +------------------------------------------------------------------------------ | Function : grr_set_buf_tlli +------------------------------------------------------------------------------ | Description : The function grr_set_buf_tlli() fills the TLLI buffer. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_set_buf_tlli ( BUF_tlli_value *buf_tlli_o, ULONG tlli_i ) { TRACE_FUNCTION( "grr_set_buf_tlli" ); grr_set_tlli( &buf_tlli_o->l_tlli_value, &buf_tlli_o->o_tlli_value, &buf_tlli_o->b_tlli_value[0], tlli_i ); } /* grr_set_buf_tlli */ /* +------------------------------------------------------------------------------ | Function : grr_set_tlli +------------------------------------------------------------------------------ | Description : The function grr_set_tlli() fills the TLLI buffer. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_set_tlli ( USHORT *l_tlli, USHORT *o_tlli, UBYTE *b_tlli, ULONG tlli ) { TRACE_FUNCTION( "grr_set_tlli" ); *l_tlli = 32; *o_tlli = 0; b_tlli[0] = (UBYTE)((tlli >> 24) & 0x000000ff); b_tlli[1] = (UBYTE)((tlli >> 16) & 0x000000ff); b_tlli[2] = (UBYTE)((tlli >> 8 ) & 0x000000ff); b_tlli[3] = (UBYTE)((tlli ) & 0x000000ff); /* unused byte must be set to 0x00, otherwise CCD has some problems */ b_tlli[4] = 0; } /* grr_set_tlli */ /* +------------------------------------------------------------------------------ | Function : grr_get_tlli +------------------------------------------------------------------------------ | Description : The function grr_get_tlli() returns the TLLI. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL ULONG grr_get_tlli ( void ) { TRACE_FUNCTION( "grr_get_tlli" ); return( grr_data->db.ms_id.new_tlli ); } /* grr_get_tlli */ /* +------------------------------------------------------------------------------ | Function : grr_encode_ul_ctrl_block +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_encode_ul_ctrl_block ( UBYTE *ul_ctrl_block, UBYTE *ul_ctrl_data ) { T_CTRLBUF enc_block; TRACE_FUNCTION( "grr_encode_ul_ctrl_block" ); grr_encode_ctrl( ul_ctrl_data, ( T_MSGBUF* )&enc_block , grr_data->r_bit ); memcpy( ul_ctrl_block, enc_block.buf, BYTELEN( enc_block.l_buf ) ); } /* grr_encode_ul_ctrl_block */ /* +------------------------------------------------------------------------------ | Function : grr_get_ul_ctrl_block_header +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grr_get_ul_ctrl_block_header ( UBYTE r_bit ) { TRACE_FUNCTION( "grr_get_ul_ctrl_block_header" ); /* * set Payload Type and R Bit */ return( ( CTRL_BLK_NO_OPT << 6 ) | r_bit ); } /* grr_get_ul_ctrl_block_header */ /* +------------------------------------------------------------------------------ | Function : grr_check_if_tbf_start_is_elapsed +------------------------------------------------------------------------------ | Description : The function grr_check_if_tbf_start_is_elapsed() checks if | tbf starting time is elapsed or not, modulo calculation is | needed | Parameters : start_fn - tbf starting time | current_fn - current frame number +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_check_if_tbf_start_is_elapsed ( ULONG start_fn, ULONG current_fn) { BOOL result = FALSE; ULONG d1; /* ULONG d2; */ /* FN_MAX=0x297000 == 2715648 ==125463 seconds(4.62ms per frame) * the starting time is within current_fn-10808 and current_fn+31623 * modulo operation must be taken in account */ TRACE_FUNCTION( "grr_check_if_tbf_start_is_elapsed" ); /* * handle maximum distance for tbf starting time */ if(start_fn EQ 0xFFFFFFFF) { result =TRUE; return result; } d1 = 10808; /* d2 = 31623; */ if( (start_fn <= current_fn) AND ((current_fn-start_fn) <= d1)) { result = TRUE; TRACE_EVENT_P2(" case 1: st time elapsed st_fn=%ld c_fn=%ld",start_fn,current_fn); } else if((start_fn >= current_fn) AND (FN_MAX-start_fn+current_fn) <= d1) { result = TRUE; TRACE_EVENT_P2("case 2: st time elapsed st_fn=%ld c_fn=%ld",start_fn,current_fn); } else { TRACE_EVENT_P2("case 3: WAIT FOR ST TIME st_fn=%ld c_fn=%ld",start_fn,current_fn); } return result; } /* grr_check_if_tbf_start_is_elapsed() */ /* +------------------------------------------------------------------------------ | Function : grr_calculate_Tra +------------------------------------------------------------------------------ | Description : The function has to calculate for mobile type 1 (ms_class 1-12) | the minimum timeslots between end of last previous downlink | timeslot and the next uplink or two consecutive uplinks. | | Parameters : ul_usage : uplink timeslot mask | dl_usage : downlink timeslot mask | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grr_calculate_Tra (UBYTE ul_usage, UBYTE dl_usage) { UBYTE mask=0x80, z_mask=0; UBYTE Tx[8],Rx[8],ul_seted_slot,dl_seted_slot,j,i,tra,rc_dl_usage; TRACE_FUNCTION( "grr_calculate_Tra" ); memset( Tx, 0, sizeof( Tx ) ); memset( Rx, 0, sizeof( Rx ) ); ul_seted_slot = 0; dl_seted_slot = 0; /* * detect position of uplink seted slots and the number of slots */ if(ul_usage NEQ z_mask) { for(j=0;j<8;j++) { if(mask & ul_usage) { Tx[ul_seted_slot]=j+1; ul_seted_slot++; } mask>>=1; } } /* * detect position of downlink seted slots and the number of slots * and shift them for 3 positions(delay between uplink and downlink) */ mask = 0x80; /* set again, it is reused*/ rc_dl_usage = grr_reconstruct_dl_usage(dl_usage); if(rc_dl_usage NEQ z_mask) { for(i=0;i<=7;i++) { if(mask & rc_dl_usage) { Rx[dl_seted_slot]=i+1; dl_seted_slot++; } mask>>=1; } } tra=0xFF; /* set to invalid value */ /* * calculate tra */ for(i=0;i<ul_seted_slot;i++) { for(j=0;j<dl_seted_slot;j++) { if (Rx[j] EQ Tx[i]) { /* tranmission and receiving at the same time not allowed*/ tra=0; TRACE_EVENT_P6("OVERLAP TRA Rx[%d]=%d Tx[%d]=%d ul_mask=%x dl_mask=%x" ,j ,Rx[j] ,i ,Tx[i] ,ul_usage ,dl_usage); return tra; } else if(Rx[j] > Tx[i]) { if(tra > (Rx[j] - Tx[i]-1)) { tra = Rx[j] - Tx[i]-1; } } else { if(tra > (Rx[j]+8 - Tx[i]-1)) { tra = Rx[j]+8 - Tx[i]-1; } } } } return tra; } /*grr_calculate_Tra */ /* +------------------------------------------------------------------------------ | Function : grr_calculate_Ttb +------------------------------------------------------------------------------ | Description : The function has to calculate for mobile type 1 (ms_class 1-12) | the minimum timeslot between end of last previous uplink | timeslot and the first next downlink or two cnsecutive Downlinks. | | Parameters : ul_usage : uplink timeslot mask | dl_usage : downlink timeslot mask | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grr_calculate_Ttb (UBYTE ul_usage, UBYTE dl_usage) { UBYTE mask=0x80, z_mask=0; UBYTE Tx[8],Rx[8],ul_seted_slot,dl_seted_slot,j,i,ttb; TRACE_FUNCTION( "grr_calculate_Ttb" ); memset( Tx, 0, sizeof( Tx ) ); memset( Rx, 0, sizeof( Rx ) ); ul_seted_slot = 0; dl_seted_slot = 0; /* * detecte position of uplink seted slots and the number of slots * uplink slots gets an offset of 3 positions(Air interface). */ if(ul_usage NEQ z_mask) { for(j=0;j<8;j++) { if(mask & ul_usage) { Tx[ul_seted_slot]=j+1+3; ul_seted_slot++; } mask>>=1; } } /* * detecte position of downlink seted slots and the number of slots */ mask=0x80; if(dl_usage NEQ z_mask) { for(i=0;i<=7;i++) { if(mask & dl_usage) { Rx[dl_seted_slot]=i+1; dl_seted_slot++; } mask>>=1; } } ttb=0xFF; /* set to invalid value */ /* * calculate ttb */ for(i=0;i<dl_seted_slot;i++) { for(j=0;j<ul_seted_slot;j++) { if ((Tx[j] EQ Rx[i]) OR !(Tx[j] - Rx[i]-8)) { /* tranmission and receiving at the same time not allowed*/ ttb=0; TRACE_EVENT_P6("OVERLAP TTB Tx[%d]=%d Rx[%d]=%d ul_mask=%x dl_mask=%x" ,j ,Tx[j] ,i ,Rx[i] ,ul_usage ,dl_usage); return ttb; } else if(Tx[j] > Rx[i]) { if((Tx[j] - Rx[i] > 8) AND (ttb > (Tx[j] - Rx[i]-8-1))) { ttb = Tx[j] - Rx[i]-8-1; } else if(ttb > (Tx[j] - Rx[i]-1)) { ttb = Tx[j] - Rx[i]-1; } } else if(ttb > (Tx[j]+8 - Rx[i]-1) ) { ttb = Tx[j]+8 - Rx[i]-1; } } } return ttb; } /* grr_calculate_Ttb */ /* +------------------------------------------------------------------------------ | Function : grr_reconstruct_dl_usage +------------------------------------------------------------------------------ | Description : this function converts the downlink slot mask. The first 3 MSB | are switched to the first LSB bits. | B0 is the MSB, B7 is the LSB | dl_usage (input) : B0 B1 B2 B3 B4 B5 B6 B7 | new_dl_usage (output): B3 B4 B5 B6 B7 B0 B1 B2 | | Parameters : dl_usage: this is timeslot mask for downlink | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grr_reconstruct_dl_usage(UBYTE dl_usage) { UBYTE help, new_dl_usage; TRACE_FUNCTION( "grr_reconstruct_dl_usage" ); help = 0xE0; help &= dl_usage; dl_usage <<= 3; help >>= 5; new_dl_usage = dl_usage | help; return new_dl_usage; }/* grr_reconstruct_dl_usage */ /* +------------------------------------------------------------------------------ | Function : grr_get_gprs_ms_class +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grr_get_gprs_ms_class ( void ) { T_rf_cap *rf_cap = rr_csf_get_rf_capability( ); UBYTE gprs_ms_class; TRACE_FUNCTION( "grr_get_gprs_ms_class" ); if( rf_cap NEQ NULL ) { gprs_ms_class = rf_cap->rf_ms.gprs_ms_class; } else { gprs_ms_class = MSLOT_CLASS_1; TRACE_ERROR( "grr_get_gprs_ms_class: RF capabilities invalid" ); } return( gprs_ms_class ); } /* grr_get_gprs_ms_class */ /* +------------------------------------------------------------------------------ | Function : grr_get_next_ncell_param +------------------------------------------------------------------------------ | Description : | Parameters : +------------------------------------------------------------------------------ */ GLOBAL T_ncell_info* grr_get_next_ncell_param ( UBYTE max_number, T_NC_LIST *list, T_INFO_SRC info_src ) { UBYTE i; T_ncell_info *ncell_info_max; T_ncell_info *ncell_info_next; TRACE_FUNCTION( "grr_get_next_ncell_param" ); /* * looking for the next free entry or in case there is no more free entry * available, looking for the highest indexed entry which will be deleted */ if( list->number < max_number ) { ncell_info_max = &list->info[list->number]; } else { ncell_info_max = &list->info[0]; for( i = 1; i < max_number; i++ ) { ncell_info_next = &list->info[i]; if( ncell_info_next->info_src > ncell_info_max->info_src ) { ncell_info_max = ncell_info_next; } } TRACE_ERROR( "grr_get_next_ncell_param: Number of NCELLs > max_number" ); if( ncell_info_max->info_src < info_src ) { TRACE_EVENT( "grr_get_next_ncell_param: Keep NCELL list" ); ncell_info_max = NULL; } else if( ncell_info_max->info_src EQ info_src ) { TRACE_ERROR( "grr_get_next_ncell_param: Two identical NCELL" ); ncell_info_max = NULL; } else { TRACE_EVENT( "grr_get_next_ncell_param: Change NCELL list" ); } } return( ncell_info_max ); }/* grr_get_next_ncell_param */ /* +------------------------------------------------------------------------------ | Function : grr_get_next_bigger_ncell_param +------------------------------------------------------------------------------ | Description : | Parameters : +------------------------------------------------------------------------------ */ GLOBAL T_ncell_info* grr_get_next_bigger_ncell_param ( T_NC_LIST *list, T_INFO_SRC info_src ) { UBYTE i; T_INFO_SRC info_src_max; T_ncell_info *ncell_info_next; T_ncell_info *ncell_info_bigger = NULL; TRACE_FUNCTION( "grr_get_next_bigger_ncell_param" ); if( list->number NEQ 0 ) { /* * all indeces should be set to unused in case info_src EQ 0, * which marks the start of a new search process */ if( info_src EQ 0 ) { for( i = 0; i < list->number; i++ ) { list->info[i].index = 0xFF; } } i = 0; info_src_max = ~((T_INFO_SRC)0); do { ncell_info_next = &list->info[i]; TRACE_ASSERT( info_src NEQ ncell_info_next->info_src OR ncell_info_next->index NEQ 0xFF ); if( info_src < ncell_info_next->info_src AND ncell_info_next->info_src < info_src_max ) { info_src_max = ncell_info_next->info_src; ncell_info_bigger = ncell_info_next; } i++; } while( i < list->number ); } return( ncell_info_bigger ); }/* grr_get_next_bigger_ncell_param */ /* +------------------------------------------------------------------------------ | Function : grr_store_cs_param +------------------------------------------------------------------------------ | Description : | Parameters : ncell_info - neighbour cell information | v_cs_par - valid falg for cell selection parameter | cs_par - cell selection parameter | info_src - source of neighbour cell information | arfcn - absolute radio frequency channel number | bsic - base station identity code +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_store_cs_param ( T_NC_LIST *nc_list, BOOL v_cs_par, T_cs_par *cs_par, T_INFO_TYPE type, UBYTE instance, UBYTE *number, USHORT *freq, USHORT freq_diff, UBYTE bsic ) { T_INFO_SRC info_src=0; T_ncell_info *ncell_info; TRACE_FUNCTION( "grr_store_cs_param" ); NC_SET_TYPE ( info_src, type ); NC_SET_INSTANCE( info_src, instance ); NC_SET_NUMBER ( info_src, *number ); ncell_info = grr_get_next_ncell_param( MAX_NR_OF_NCELL, nc_list, info_src ); if( ncell_info EQ NULL ) { return( FALSE ); } (*number)++; nc_list->number++; *freq = ( *freq + freq_diff ) % 1024; ncell_info->info_src = info_src; ncell_info->arfcn = *freq; ncell_info->bsic = bsic; ncell_info->v_cr_par = v_cs_par; if( v_cs_par EQ TRUE ) { ncell_info->cr_par.same_ra_scell = cs_par->same_ra_scell; ncell_info->cr_par.exc_acc = cs_par->exc_acc; ncell_info->cr_par.cell_ba = cs_par->cell_ba; #if !defined (NTRACE) if( grr_data->cs.v_crp_trace EQ TRUE ) { TRACE_EVENT_P3( "grr_store_cs_param: cell barred status %d %d, info_src %x", ncell_info->arfcn, ncell_info->cr_par.cell_ba, info_src ); } #endif /* #if !defined (NTRACE) */ SET_GPRS_RXLEV_ACCESS_MIN ( ncell_info->cr_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min, cs_par->v_cs_par_s1, cs_par->cs_par_s1.gprs_rxlev_access_min ); SET_GPRS_MS_TXPWR_MAX_CCH ( ncell_info->cr_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch, cs_par->v_cs_par_s1, cs_par->cs_par_s1.txpwr_max_cch ); SET_GPRS_TEMP_OFFSET ( ncell_info->cr_par.cr_offset.gprs_temp_offset, cs_par->v_cs_par_s2, cs_par->cs_par_s2.gprs_temp_offset ); SET_GPRS_PENALTY_TIME ( ncell_info->cr_par.cr_offset.gprs_penalty_time, cs_par->v_cs_par_s2, cs_par->cs_par_s2.gprs_penalty_time ); SET_GPRS_RESEL_OFF ( ncell_info->cr_par.gprs_resel_off, cs_par->v_gprs_resel_off, cs_par->gprs_resel_off ); ncell_info->cr_par.cr_par_1.v_hcs_par = cs_par->v_hcs_par; SET_GPRS_HCS_THR ( ncell_info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr, cs_par->v_hcs_par, cs_par->hcs_par.gprs_hcs_thr ); SET_GPRS_PRIO_CLASS ( ncell_info->cr_par.cr_par_1.hcs_par.gprs_prio_class, cs_par->v_hcs_par, cs_par->hcs_par.gprs_prio_class ); grr_store_si13_pbcch_location( &ncell_info->cr_par, cs_par->v_si13_pbcch, &cs_par->si13_pbcch ); } return( TRUE ); }/* grr_store_cs_param */ /* +------------------------------------------------------------------------------ | Function : grr_store_si13_pbcch_locaction +------------------------------------------------------------------------------ | Description : | Parameters : +------------------------------------------------------------------------------ */ GLOBAL void grr_store_si13_pbcch_location ( T_CR_PAR *cr_par, BOOL v_si13_pbcch, T_si13_pbcch *si13_pbcch ) { TRACE_FUNCTION( "grr_store_si13_pbcch_locaction" ); cr_par->v_si13_pbcch = v_si13_pbcch; if( v_si13_pbcch ) { cr_par->si13_pbcch.v_si13_location = si13_pbcch->v_si13_loc; if( si13_pbcch->v_si13_loc ) { cr_par->si13_pbcch.si13_location = si13_pbcch->si13_loc; } else { cr_par->si13_pbcch.pbcch_location = si13_pbcch->si13_pbcch_s1.pbcch_loc; cr_par->si13_pbcch.psi1_repeat_period = si13_pbcch->si13_pbcch_s1.psi1_rep_per + 1; } } }/* grr_store_si13_pbcch_locaction */ /* +------------------------------------------------------------------------------ | Function : grr_restore_cs_param +------------------------------------------------------------------------------ | Description : | Parameters : +------------------------------------------------------------------------------ */ GLOBAL void grr_restore_cs_param ( T_ncell_info *curr_info, T_ncell_info *prev_info, UBYTE curr_idx ) { TRACE_FUNCTION( "grr_restore_cs_param" ); curr_info->index = curr_idx; if( grr_is_pbcch_present( ) ) { if( curr_info->cr_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min EQ GPRS_RXLEV_ACCESS_MIN_INVALID ) { if( prev_info NEQ NULL ) { curr_info->cr_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min = prev_info->cr_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min; } else { curr_info->cr_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min = psc_db->scell_par.cr_par_1.cr_pow_par.gprs_rxlev_access_min; } } if( curr_info->cr_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch EQ GPRS_MS_TXPWR_MAX_CCH_INVALID ) { if( prev_info NEQ NULL ) { curr_info->cr_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch = prev_info->cr_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch; } else { curr_info->cr_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch = psc_db->scell_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch; } } if( curr_info->cr_par.cr_offset.gprs_temp_offset EQ GPRS_TEMPORARY_OFFSET_INVALID ) { if( prev_info NEQ NULL ) { curr_info->cr_par.cr_offset.gprs_temp_offset = prev_info->cr_par.cr_offset.gprs_temp_offset; } else { TRACE_ERROR( "gprs_temp_offset not present in 1st NCELL"); curr_info->cr_par.cr_offset.gprs_temp_offset = GPRS_TEMPORARY_OFFSET_00_DB; } } if( curr_info->cr_par.cr_offset.gprs_penalty_time EQ GPRS_PENALTY_TIME_INVALID ) { if( prev_info NEQ NULL ) { curr_info->cr_par.cr_offset.gprs_penalty_time = prev_info->cr_par.cr_offset.gprs_penalty_time; } else { TRACE_ERROR( "gprs_penalty_time not present in 1st NCELL"); curr_info->cr_par.cr_offset.gprs_penalty_time = GPRS_PENALTY_TIME_MAX; } } if( psc_db->scell_par.cr_par_1.v_hcs_par EQ FALSE ) { /* * If the HCS struct is omitted for the serving cell, * HCS is not used and the HCS parameters for the other * cells shall be neglected i.e the HCS signal strength * threshold shall be set to infinity for all cells. */ curr_info->cr_par.cr_par_1.v_hcs_par = FALSE; } else { if( curr_info->cr_par.cr_par_1.v_hcs_par EQ FALSE ) { if( prev_info NEQ NULL ) { curr_info->cr_par.cr_par_1.v_hcs_par = prev_info->cr_par.cr_par_1.v_hcs_par; if( curr_info->cr_par.cr_par_1.hcs_par.gprs_prio_class EQ GPRS_PRIORITY_CLASS_INVALID ) { curr_info->cr_par.cr_par_1.hcs_par.gprs_prio_class = prev_info->cr_par.cr_par_1.hcs_par.gprs_prio_class; } if( curr_info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr EQ GPRS_HCS_THR_INVALID ) { curr_info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr = prev_info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr; } } else { curr_info->cr_par.cr_par_1.v_hcs_par = psc_db->scell_par.cr_par_1.v_hcs_par; if( curr_info->cr_par.cr_par_1.hcs_par.gprs_prio_class EQ GPRS_PRIORITY_CLASS_INVALID ) { curr_info->cr_par.cr_par_1.hcs_par.gprs_prio_class = psc_db->scell_par.cr_par_1.hcs_par.gprs_prio_class; } if( curr_info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr EQ GPRS_HCS_THR_INVALID ) { curr_info->cr_par.cr_par_1.hcs_par.gprs_hcs_thr = psc_db->scell_par.cr_par_1.hcs_par.gprs_hcs_thr; } } } } } }/* grr_restore_cs_param */ /* +------------------------------------------------------------------------------ | Function : grr_handle_ta +------------------------------------------------------------------------------ | Description : This function handles the timing advance of the MS | Parameters : v_tav: valid flag ta_value | tav: ta value | v_ul_tai: valid flag dl ta_index | ul_tai: dl ta index | ul_tatn: dl ta timeslot number | v_dl_tai: valid flag dl ta_index | dl_tai: dl ta index | dl_tatn: dl ta timeslot number | ptr2ta: pointer to the ta structue, which is passed to l1 +------------------------------------------------------------------------------ */ GLOBAL void grr_handle_ta ( UBYTE v_tav, UBYTE tav, UBYTE v_ul_tai, UBYTE ul_tai, UBYTE ul_tatn, UBYTE v_dl_tai, UBYTE dl_tai, UBYTE dl_tatn, T_p_timing_advance *ptr2ta) { BOOL use_dl_par = FALSE; TRACE_FUNCTION( "grr_handle_ta" ); ptr2ta->ta_value = 0xFF; ptr2ta->ta_index = 0xFF; ptr2ta->tn = 0xFF; /*TRACE_EVENT_P1("grr_data->tbf_type: %d", grr_data->tbf_type);*/ switch(grr_data->tbf_type) { case CGRLC_TBF_MODE_DL: case CGRLC_TBF_MODE_DL_UL: /*use DL TA parameters*/ use_dl_par = TRUE; break; case CGRLC_TBF_MODE_NULL: case CGRLC_TBF_MODE_UL: #if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH case CGRLC_TBF_MODE_2PA: #endif default: /*future use*/ break; } /* * TA-Value, if present */ if(v_tav) /* New TA value Received */ { /* TRACE_EVENT("New TA value Received"); */ if(tav NEQ grr_data->ta_params.ta_value ) { /* * inform grlc that new ta is received */ PALLOC(cgrlc_ta_value_req, CGRLC_TA_VALUE_REQ); cgrlc_ta_value_req->ta_value = tav; PSEND(hCommGRLC, cgrlc_ta_value_req); } ptr2ta->ta_value = tav; grr_data->ta_params.ta_value = tav; grr_data->ta_params.ta_valid = TRUE; } else if(grr_data->ta_params.ta_valid) /* use old TA value */ { /* TRACE_EVENT("Use old TA value in IA or PUL on (P)AGCH"); */ ptr2ta->ta_value = grr_data->ta_params.ta_value; } else { /*TRACE_EVENT("No valid TA in neither in message nor stored TA: check TAI");*/ grr_data->ta_params.ta_value = 0xFF; grr_data->ta_params.ta_valid = FALSE; } /* * If TAI present the MS shall use "continuos TA" */ if(v_dl_tai EQ 0) { /* Reset the tai & ta_tn */ if(grr_data->ta_params.dl_ta_i NEQ 0xFF) { TRACE_EVENT_P4("TA_INFO: Switch off DL CTA dl_tai=%d dl_ta_tn=%d ul_tai=%d, ul_ta_tn=%d", grr_data->ta_params.dl_ta_i, grr_data->ta_params.dl_ta_tn, grr_data->ta_params.ul_ta_i, grr_data->ta_params.ul_ta_tn); } grr_data->ta_params.dl_ta_i = 0xFF; grr_data->ta_params.dl_ta_tn = 0xFF; } else if(v_dl_tai EQ 1) { /* TRACE_EVENT("DL TAI: cont TA: if UL TAI is also valid, we prefer to use DL TAI"); */ grr_data->ta_params.dl_ta_i = dl_tai; grr_data->ta_params.dl_ta_tn = dl_tatn; ptr2ta->ta_index = dl_tai; ptr2ta->tn = dl_tatn; } if(v_ul_tai EQ 0) { /* Reset the tai & ta_tn */ if(grr_data->ta_params.ul_ta_i NEQ 0xFF) { TRACE_EVENT_P7("TA_INFO: Switch off UL CTA ul_tai=%d ul_ta_tn=%d dl_tai=%d dl_ta_tn=%d v_dl_tai=%d new_dl_tai=%d new_dl_ta_tn=%d", grr_data->ta_params.ul_ta_i, grr_data->ta_params.ul_ta_tn, grr_data->ta_params.dl_ta_i, grr_data->ta_params.dl_ta_tn, v_dl_tai, dl_tai, dl_tatn); } grr_data->ta_params.ul_ta_i = 0xFF; grr_data->ta_params.ul_ta_tn = 0xFF; if(use_dl_par AND grr_data->ta_params.dl_ta_i NEQ 0xFF) { ptr2ta->ta_index = grr_data->ta_params.dl_ta_i; ptr2ta->tn = grr_data->ta_params.dl_ta_tn; } } else if(v_ul_tai EQ 1) { grr_data->ta_params.ul_ta_i = ul_tai; grr_data->ta_params.ul_ta_tn = ul_tatn; if(use_dl_par AND grr_data->ta_params.dl_ta_i NEQ 0xFF) { /* TRACE_EVENT("Conc TBF: use DL TA for UL"); */ ptr2ta->ta_index = grr_data->ta_params.dl_ta_i; ptr2ta->tn = grr_data->ta_params.dl_ta_tn; } else { /* TRACE_EVENT("Single TBF or TBF_Type is not set to concurrent: UL TAI: cont TA"); */ ptr2ta->ta_index = ul_tai; ptr2ta->tn = ul_tatn; } } /* * store values ,which are passed to layer 1 */ grr_data->ta_params.l1_ta_value = ptr2ta->ta_value; grr_data->ta_params.l1_ta_i = ptr2ta->ta_index; grr_data->ta_params.l1_ta_tn = ptr2ta->tn; /* { ULONG trace[4]; trace[0] = ul_tai << 0; trace[0] |= v_ul_tai << 8; trace[0] |= tav << 16; trace[0] |= v_tav << 24; trace[1] = dl_tatn << 0; trace[1] |= dl_tai << 8; trace[1] |= v_dl_tai << 16; trace[1] |= ul_tatn << 24; trace[2] = grr_data->ta_params.ul_ta_tn << 0; trace[2] |= grr_data->ta_params.ul_ta_i << 8; trace[2] |= grr_data->ta_params.ta_value << 16; trace[2] |= grr_data->ta_params.ta_valid << 24; trace[3] = grr_data->ta_params.l1_ta_i << 0; trace[3] |= grr_data->ta_params.l1_ta_value << 8; trace[3] |= grr_data->ta_params.dl_ta_tn << 16; trace[3] |= grr_data->ta_params.dl_ta_i << 24; TRACE_EVENT_P5( "TA_PARAM_1: %08X%08X %08X%08X%02X", trace[0], trace[1], trace[2], trace[3], grr_data->ta_params.l1_ta_tn ); } */ }/* grr_handle_ta */ /*---------------------- GET FROM PPC-----------------------------------------*/ /* +------------------------------------------------------------------------------ | Function : grr_decode_grr +------------------------------------------------------------------------------ | Description : The function grr_decode_grr() calls the function ccd_decodeMsg. | After the call the decoded Message is in _decodeCtrlMsg. | | Parameters : msg_ptr_i - pointer to buffer that should be decoded | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grr_decode_grr (T_MSGBUF * msg_ptr_i) { UBYTE result; UBYTE msg_type = msg_ptr_i->buf[0] >> 2;; TRACE_FUNCTION( "grr_decode_grr" ); /* * Offset must be zero, else code to get msg_type is illegal */ TRACE_ASSERT (msg_ptr_i->o_buf==0); #ifdef _SIMULATION_ /* * If one of the following asserts fail, you have to verify the message * decoders. */ #ifdef REL99 TRACE_ASSERT (sizeof(T_D_DL_ASSIGN) == 0x02E0); /*lint !e774*/ TRACE_ASSERT (sizeof(T_D_UL_ASSIGN) == 0x0410); /*lint !e774*/ TRACE_ASSERT (sizeof(T_D_TS_RECONFIG) == 0x03D8); /*lint !e774*/ #else TRACE_ASSERT (sizeof(T_D_DL_ASSIGN) == 0x024C); /*lint !e774*/ TRACE_ASSERT (sizeof(T_D_UL_ASSIGN) == 0x040C); /*lint !e774*/ TRACE_ASSERT (sizeof(T_D_TS_RECONFIG) == 0x03D4); /*lint !e774*/ #endif #endif switch (msg_type) { case D_DL_ASSIGN: result = grr_decode_dl_assignment (msg_ptr_i->buf, msg_ptr_i->o_buf, msg_ptr_i->l_buf); break; case D_UL_ASSIGN: result = grr_decode_ul_assignment (msg_ptr_i->buf, msg_ptr_i->o_buf, msg_ptr_i->l_buf); break; case D_TS_RECONFIG: result = grr_decode_ts_reconfig (msg_ptr_i->buf, msg_ptr_i->o_buf, msg_ptr_i->l_buf); break; case D_PDCH_RELEASE: result = grr_decode_pdch_release (msg_ptr_i->buf, msg_ptr_i->o_buf, msg_ptr_i->l_buf); break; case D_POLLING_REQ: result = grr_decode_polling_req (msg_ptr_i->buf, msg_ptr_i->o_buf, msg_ptr_i->l_buf); break; case D_TBF_RELEASE: result = grr_decode_tbf_release_req (msg_ptr_i->buf, msg_ptr_i->o_buf, msg_ptr_i->l_buf); break; default: result = ccd_decodeMsg (CCDENT_GRR, DOWNLINK, msg_ptr_i, _decodedMsg, NOT_PRESENT_8BIT); break; } if ( result EQ ccdError ) switch (msg_type) { case D_DL_ASSIGN: case D_UL_ASSIGN: case D_TS_RECONFIG: /* This should not be the final version of error handling */ return DELETE_MESSAGE; default: return grr_ccd_error_handling( CCDENT_GRR ); } return msg_type; } /* grr_decode_grr() */ /* +------------------------------------------------------------------------------ | Function : grr_decode_rlcmac +------------------------------------------------------------------------------ | Description : The function grr_decode_rlcmac() | | Parameters : ptr_msg_i - pointer to rlcmac-ctrl message | ptr_header_i - pointer to mac header of the rlc block +------------------------------------------------------------------------------ */ GLOBAL void grr_decode_rlcmac ( UBYTE * ptr_msg_i, T_D_HEADER * ptr_d_header_i ) { UBYTE rrbp, sp, payload; TRACE_FUNCTION( "grr_decode_rlcmac" ); /*MAC Header*/ payload = (ptr_msg_i[0] & 0xC0) >> 6; rrbp = (ptr_msg_i[0] & 0x30) >> 4; sp = (ptr_msg_i[0] & 0x08) >> 3; ptr_d_header_i->payload = payload; /*if ctrl block with optional parameter*/ if(payload EQ CTRL_BLK_OPT ) { ptr_d_header_i->d_ctrl.rrbp = rrbp; ptr_d_header_i->d_ctrl.sp = sp; ptr_d_header_i->d_ctrl.rbsn = (ptr_msg_i[1] & 0x80) >> 7; ptr_d_header_i->d_ctrl.rti = (ptr_msg_i[1] & 0x7C) >> 2; ptr_d_header_i->d_ctrl.fs = (ptr_msg_i[1] & 0x02) >> 1; ptr_d_header_i->d_ctrl.ac = (ptr_msg_i[1] & 0x01); if(ptr_d_header_i->d_ctrl.ac EQ 1) { ptr_d_header_i->d_ctrl.msg_type = ptr_msg_i[3] >> 2; ptr_d_header_i->d_ctrl.tfi = (ptr_msg_i[2] & 0x3E) >> 1; ptr_d_header_i->d_ctrl.d = (ptr_msg_i[2] & 0x01); ptr_d_header_i->ptr_block = &ptr_msg_i[3]; } else { ptr_d_header_i->d_ctrl.msg_type = ptr_msg_i[2] >> 2; ptr_d_header_i->ptr_block = &ptr_msg_i[2]; } TRACE_EVENT_P4("optional header received: 0x%x 0x%x 0x%x 0x%x",ptr_msg_i[0],ptr_msg_i[1],ptr_msg_i[2],ptr_msg_i[3]); } else if(payload EQ CTRL_BLK_NO_OPT ) /*if ctrl block with optional parameter*/ { ptr_d_header_i->d_ctrl.msg_type = ptr_msg_i[1] >> 2; ptr_d_header_i->d_ctrl.rrbp = rrbp; ptr_d_header_i->d_ctrl.sp = sp; ptr_d_header_i->ptr_block = &ptr_msg_i[1]; } else { TRACE_ERROR("unknown payload type"); TRACE_EVENT_P5("pt=%d FIRST 5 BYTES: 0x%x 0x%x 0x%x 0x%x",payload,ptr_msg_i[0],ptr_msg_i[1],ptr_msg_i[2],ptr_msg_i[3]); } } /* grr_decode_rlcmac() */ /* +------------------------------------------------------------------------------ | Function : grr_handle_rlcmac_header +------------------------------------------------------------------------------ | Description : The function grr_handle_rlcmac_header() | | Parameters : mode_i - possible values: | PACKET_MODE_PIM/PACKET_MODE_PAM and | (that means message was received over MPHP) | PACKET_MODE_PTM | (that means message was received over RLCMAC) | remark: the reason for introduce mode_i is lost? | ptr_header_i - pointer to mac header of the rlc block | fn_i - frame number | +------------------------------------------------------------------------------ */ GLOBAL T_MSGBUF * grr_handle_rlcmac_header ( T_PACKET_MODE mode_i, T_D_HEADER * ptr_header_i, ULONG fn_i ) { T_MSGBUF * result = (T_MSGBUF *)(& grr_data->ctrl_msg); UBYTE i; UBYTE frame_periods; TRACE_FUNCTION( "grr_handle_rlcmac_header" ); if(ptr_header_i->payload EQ CTRL_BLK_NO_OPT) { /* * not segmented control block */ result->l_buf = 22*8; result->o_buf = 0; memcpy(result->buf, ptr_header_i->ptr_block, (result->l_buf)/8); ptr_header_i->pctrl_ack = 3; } else if (ptr_header_i->payload EQ CTRL_BLK_OPT) { /* * segmented control block */ if(ptr_header_i->d_ctrl.ac) result->l_buf = (22-2)*8; else result->l_buf = (22-1)*8; if(ptr_header_i->d_ctrl.fs AND !ptr_header_i->d_ctrl.rbsn) { result->o_buf = 0; memcpy(result->buf, ptr_header_i->ptr_block, (result->l_buf)/8); ptr_header_i->pctrl_ack = 2; /* TRACE_EVENT("optional rlc mac header without segmentation"); */ } else if(ptr_header_i->d_ctrl.fs) { /* * check if the first part is received, otherwise delete */ grr_clean_up_seg_ctrl_blk_tbl(); /* for(i=grr_data->seg_ctrl_blk.next-1;i NEQ grr_data->seg_ctrl_blk.next;((i--)%8))*/ for(i = 0;i < SEG_CTRL_BLOCK_SIZE ;i++) { if(ptr_header_i->d_ctrl.rti EQ grr_data->seg_ctrl_blk.blk[i].rti) { /* * a part of the recently received control block is saved, * reassabling is possible */ if(!(ptr_header_i->d_ctrl.rbsn)) { /* * received part is the first part of the segmented block * copy recently received as first part */ memcpy(result->buf, ptr_header_i->ptr_block, (result->l_buf)/8); /* * copy previous saved as second part */ memcpy(result->buf+(result->l_buf)/8,grr_data->seg_ctrl_blk.blk[i].ctrl_blk.buf, (grr_data->seg_ctrl_blk.blk[i].ctrl_blk.l_buf)/8); } else { /* * received part is the second part of the segmented block * copy saved part as first part */ memcpy(result->buf, grr_data->seg_ctrl_blk.blk[i].ctrl_blk.buf, (grr_data->seg_ctrl_blk.blk[i].ctrl_blk.l_buf)/8); /* * copy recently received as second part */ memcpy(result->buf+(grr_data->seg_ctrl_blk.blk[i].ctrl_blk.l_buf)/8, ptr_header_i->ptr_block, (result->l_buf)/8); } result->l_buf += grr_data->seg_ctrl_blk.blk[i].ctrl_blk.l_buf; result->o_buf = 0; ptr_header_i->pctrl_ack = 3; grr_data->seg_ctrl_blk.blk[i].rti = 0xFF; /* * break condition: saved part was found */ break; } else { if(i EQ SEG_CTRL_BLOCK_SIZE) { result = NULL; TRACE_ERROR("final segment but no identical rti values"); } } } } else { /* * save the first part of a control block */ if(0xff EQ grr_data->seg_ctrl_blk.next) grr_data->seg_ctrl_blk.next = 0; /* for safety only (former glumpshack) */ if(0xFF NEQ grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].rti) { grr_clean_up_seg_ctrl_blk_tbl(); grr_align_seg_ctrl_blk_nxt(); } /* * calculate the timeout value for T3200 in untis of frames */ if( mode_i EQ PACKET_MODE_PIM AND grr_is_non_drx_period( ) ) { frame_periods = 4 * MAXIMUM( 1, psc_db->gprs_cell_opt.bs_cv_max ); } else { USHORT drx_p; drx_p = meas_im_get_drx_period_frames( ); frame_periods = MAXIMUM( 1,drx_p ); } grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].rbsn = ptr_header_i->d_ctrl.rbsn; grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].rti = ptr_header_i->d_ctrl.rti; grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].T3200 = ( fn_i + 4 * frame_periods ) % FN_MAX; grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].ctrl_blk.l_buf = result->l_buf; grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].ctrl_blk.o_buf = 0; memcpy(grr_data->seg_ctrl_blk.blk[grr_data->seg_ctrl_blk.next].ctrl_blk.buf, ptr_header_i->ptr_block, (result->l_buf/8)); /* (grr_data->seg_ctrl_blk.next++)%8; */ grr_clean_up_seg_ctrl_blk_tbl(); grr_align_seg_ctrl_blk_nxt(); if(ptr_header_i->d_ctrl.rbsn) ptr_header_i->pctrl_ack = 1; else ptr_header_i->pctrl_ack = 2; result = NULL; } } else { TRACE_ERROR(" payload type is not a control block "); } return(result); } /* grr_handle_rlcmac_header() */ /* +------------------------------------------------------------------------------ | Function : grr_check_address +------------------------------------------------------------------------------ | Description : The function grr_check_address() this function checks the | message of the message in _decodeCtrlMsg. The Function returns | TRUE if the address is correct. | | Parameters : msg_type_i - the airmessage type defined in M_GRR.val | +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_check_address ( UBYTE msg_type_i,UBYTE tn_i ) { BOOL result = FALSE; TRACE_FUNCTION( "grr_check_address" ); switch( msg_type_i ) { case D_ACCESS_REJ_c: result = grr_check_add_reject(tn_i); break; case D_QUEUING_NOT_c: { MCAST(queuing_not,D_QUEUING_NOT); result = grr_check_request_reference(&(queuing_not->req_ref_p)); } break; case D_TBF_RELEASE_c: { MCAST(tbf_release,D_TBF_RELEASE); result = grr_check_glob_tfi(&(tbf_release->glob_tfi),tn_i ); } break; case D_TS_RECONFIG_c: { MCAST(d_ts_reconfig,D_TS_RECONFIG); result = grr_check_glob_tfi( &(d_ts_reconfig->glob_tfi),tn_i ); } break; case D_PAGING_REQ_c: result = TRUE; /*grr_check_page_add();*/ break; case D_UL_ACK_c: { MCAST(ul_ack,D_UL_ACK); if((grr_data->uplink_tbf.tfi EQ ul_ack->ul_tfi) AND ((0x80>>tn_i) & grr_data->uplink_tbf.ts_mask)) { result = TRUE; } else { TRACE_EVENT_P6("ul_ack adress failed add_tfi=%d, ul_tfi=%d, || tn=%d ->mask=%x curr_mask=%x, st_mask=%x ", ul_ack->ul_tfi, grr_data->uplink_tbf.tfi, tn_i, 0x80>>tn_i, grr_data->uplink_tbf.ts_mask, grr_data->uplink_tbf.ts_usage); } } break; case D_CELL_CHAN_ORDER_c: { MCAST(d_cell_chan_order,D_CELL_CHAN_ORDER); result = grr_check_add_1( &(d_cell_chan_order->add1),tn_i ); } break; case D_MEAS_ORDER_c: { MCAST(d_meas_order,D_MEAS_ORDER); result = grr_check_add_1( &(d_meas_order->add1),tn_i ); } break; case D_DL_ASSIGN_c: { MCAST(d_dl_assign,D_DL_ASSIGN); result = grr_check_add_1( &(d_dl_assign->add1),tn_i ); } break; case D_POLLING_REQ_c: { MCAST(d_polling_req,D_POLLING_REQ); result = grr_check_add_2( &(d_polling_req->add2),tn_i ); } break; case D_CTRL_PWR_TA_c: { MCAST(d_ctrl_pwr_ta,D_CTRL_PWR_TA); result = grr_check_add_4( &(d_ctrl_pwr_ta->add4),tn_i ); } break; case D_UL_ASSIGN_c: { MCAST(d_ul_assign,D_UL_ASSIGN); result = grr_check_add_3( &(d_ul_assign->add3),tn_i ); } break; /* * the following messages do not have a address field * therefore the result is always TRUE */ case PSI_1_c: case PSI_2_c: case PSI_3_c: case PSI_3_BIS_c: #if defined (REL99) AND defined (TI_PS_FF_EMR) case PSI_3_TER_c: #endif case PSI_4_c: case PSI_5_c: #ifdef REL99 case PSI_8_c: #endif case PSI_13_c: case D_DL_DUMMY_c: case D_PDCH_RELEASE_c: case D_PRACH_PAR_c: result = TRUE; break; default: TRACE_ERROR("grr_check_address with invalid message type"); break; } /* switch (msg_type_i) */ return(result); } /* grr_check_address() */ /* +------------------------------------------------------------------------------ | Function : grr_increase_dsc +------------------------------------------------------------------------------ | Description : The function grr_increase_dsc increases dsc by 1 | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void grr_increase_dsc ( void ) { TRACE_FUNCTION( "grr_increase_dsc" ); grr_data->pg.dsc++; if(grr_data->pg.dsc > grr_data->pg.initial_dsc) { grr_data->pg.dsc = grr_data->pg.initial_dsc; } GRR_EM_SET_DSC_VAL(grr_data->pg.dsc); #ifdef _SIMULATION_ TRACE_EVENT_P1( "DSC: %d", grr_data->pg.dsc ); #endif /* #ifdef _SIMULATION_ */ }/* grr_increase_dsc*/ /* +------------------------------------------------------------------------------ | Function : grr_decrease_dsc +------------------------------------------------------------------------------ | Description : The function grr_decrease_dsc decreases dsc by 4 | | Parameters : return BOOL: indicates whether downlink siganlling failure | occured or not | +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_decrease_dsc ( void ) { TRACE_FUNCTION( "grr_decrease_dsc" ); if( grr_data->pg.dsc <= 4 ) { grr_data->pg.dsc = 0; } else { grr_data->pg.dsc -= 4; } GRR_EM_SET_DSC_VAL(grr_data->pg.dsc); #ifdef _SIMULATION_ TRACE_EVENT_P1( "DSC: %d", grr_data->pg.dsc ); #endif /* #ifdef _SIMULATION_ */ return( grr_data->pg.dsc EQ 0 ); }/* grr_decrease_dsc*/ /* +------------------------------------------------------------------------------ | Function : grr_t_status +------------------------------------------------------------------------------ | Description : This function returns the remaining time in milliseconds. | A value of 0L is returned in case the timer is not existing or | not running. | | Parameters : t_index : timer index | +------------------------------------------------------------------------------ */ GLOBAL T_TIME grr_t_status( USHORT t_index ) { T_TIME t_time = 0L; TRACE_FUNCTION( "grr_t_status" ); vsi_t_status( GRR_handle, t_index, &t_time ); return( t_time ); } /* grr_t_status */ /* +------------------------------------------------------------------------------ | Function : grr_get_nc_mval +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL T_NC_MVAL* grr_get_nc_mval ( USHORT arfcn, UBYTE bsic, UBYTE *idx ) { UBYTE i; T_NC_MVAL *nc_mval = NULL; TRACE_FUNCTION( "grr_get_nc_mval" ); for( i = 0; i < MAX_NR_OF_NC_MVAL AND nc_mval EQ NULL; i++ ) { nc_mval = &grr_data->db.nc_mval_list.nc_mval[i]; *idx = i; if( bsic EQ RRGRR_INVALID_BSIC ) { if( nc_mval->arfcn NEQ arfcn ) { nc_mval = NULL; } } else { if( nc_mval->arfcn NEQ arfcn OR nc_mval->sync_info.bsic NEQ bsic ) { nc_mval = NULL; } } } return( nc_mval ); } /* grr_get_nc_mval */ /* +------------------------------------------------------------------------------ | Function : grr_get_ncell_info +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL T_ncell_info* grr_get_ncell_info ( USHORT arfcn, UBYTE bsic ) { UBYTE i; T_ncell_info *ncell_info = NULL; TRACE_FUNCTION( "grr_get_ncell_info" ); for( i = 0; i < grr_data->db.nc_ref_lst.number AND ncell_info EQ NULL; i++ ) { ncell_info = grr_data->db.nc_ref_lst.info[i]; if( bsic EQ RRGRR_INVALID_BSIC ) { if( ncell_info->arfcn NEQ arfcn ) { ncell_info = NULL; } } else { if( ncell_info->arfcn NEQ arfcn OR ncell_info->bsic NEQ bsic ) { ncell_info = NULL; } } } return( ncell_info ); } /* grr_get_ncell_info */ /* +------------------------------------------------------------------------------ | Function : grr_set_pbcch +------------------------------------------------------------------------------ | Description : This function sets pbcch presence. It is no more handled | in PSI only. | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void grr_set_pbcch ( BOOL pbcch_presence ) { TRACE_FUNCTION( "grr_set_pbcch" ); psc_db->pbcch.bcch.pbcch_present = pbcch_presence; #if !defined (NTRACE) if( grr_data->cs.v_crp_trace EQ TRUE ) { TRACE_EVENT_P3( "database: psc = %d, PBCCH presence: %d %d", grr_get_db_num( psc_db ), grr_data->sc_db_1.pbcch.bcch.pbcch_present, grr_data->sc_db_2.pbcch.bcch.pbcch_present ); } #endif /* #if !defined (NTRACE) */ } /* grr_set_pbcch */ /* +------------------------------------------------------------------------------ | Function : grr_set_pg_nmo +------------------------------------------------------------------------------ | Description : This function sets NMO for paging | If NMO II and PBCCH present, then assume paging coordination | is used. The MS will act as NMO I mobile with PBCCH | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void grr_set_pg_nmo(void) { if( psc_db->pbcch.bcch.pbcch_present AND psc_db->cell_info_for_gmm.cell_info.net_mode EQ GMMRR_NET_MODE_II ) { grr_data->pg.nmo = GMMRR_NET_MODE_I; TRACE_EVENT("Network is NMO II, but with PBCCH. The MS will act as NMO I (paging coordination)"); } else grr_data->pg.nmo = psc_db->cell_info_for_gmm.cell_info.net_mode; }/*grr_set_pg_nmo*/ /* +------------------------------------------------------------------------------ | Function : grr_set_freq_par +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_set_freq_par ( T_p_frequency_par *freq_par ) { TRACE_FUNCTION( "grr_set_freq_par" ); freq_par->p_chan_sel = grr_data->tc.freq_set.freq_par.p_chan_sel; if( grr_data->tc.freq_set.freq_par.p_chan_sel.hopping ) { freq_par->p_freq_list = grr_data->tc.freq_set.freq_par.p_freq_list; } else { memset( &freq_par->p_freq_list, 0, sizeof( freq_par->p_freq_list ) ); } } /* grr_set_freq_par */ /* +------------------------------------------------------------------------------ | Function : grr_get_pccch_freq_par +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_get_pccch_freq_par ( UBYTE pccch_group, T_p_chan_sel *chan_sel, T_p_freq_list *freq_list ) { BOOL result = FALSE; TRACE_FUNCTION( "grr_get_pccch_freq_par" ); if( pccch_group > psc_db->paging_group.kc - 1 ) { TRACE_ERROR( "pccch_group > psc_db->paging_group.kc - 1" ); return( result ); } if( psc_db->paging_group.pccch[pccch_group].is_static ) { chan_sel->hopping = 0; chan_sel->p_rf_ch.arfcn = psc_db->paging_group.pccch[pccch_group].arfcn; result = TRUE; } else { result = grr_create_freq_list( psc_db->paging_group.pccch[pccch_group].ma_num, psc_db->paging_group.pccch[pccch_group].maio, chan_sel, freq_list ); } return( result ); } /* grr_get_pccch_freq_par */ /* +------------------------------------------------------------------------------ | Function : grr_cgrlc_pwr_ctrl_cnf +------------------------------------------------------------------------------ | Description : Handles the primitive CGRLC_PWR_CTRL_CNF | | Parameters : cgrlc_pwr_ctrl_cnf - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void grr_cgrlc_pwr_ctrl_cnf ( T_CGRLC_PWR_CTRL_CNF *cgrlc_pwr_ctrl_cnf ) { TRACE_FUNCTION( "grr_cgrlc_pwr_ctrl_cnf" ); PFREE( cgrlc_pwr_ctrl_cnf ); } /* grr_cgrlc_pwr_ctrl_cnf() */ /* +------------------------------------------------------------------------------ | Function : grr_cgrlc_pwr_ctrl_req +------------------------------------------------------------------------------ | Description : | | Parameters : void | +------------------------------------------------------------------------------ */ GLOBAL void grr_cgrlc_pwr_ctrl_req( BOOL v_c_value ) { TRACE_FUNCTION( "grr_cgrlc_pwr_ctrl_req" ); { PALLOC( cgrlc_pwr_ctrl_req, CGRLC_PWR_CTRL_REQ ); grr_prcs_pwr_ctrl( &cgrlc_pwr_ctrl_req->pwr_ctrl, v_c_value ); if( cgrlc_pwr_ctrl_req->pwr_ctrl.v_pwr_ctrl_param EQ FALSE AND cgrlc_pwr_ctrl_req->pwr_ctrl.v_glbl_pwr_ctrl_param EQ FALSE AND cgrlc_pwr_ctrl_req->pwr_ctrl.v_freq_param EQ FALSE AND cgrlc_pwr_ctrl_req->pwr_ctrl.v_c_value EQ FALSE ) { PFREE( cgrlc_pwr_ctrl_req ); } else { PSEND( hCommGRLC, cgrlc_pwr_ctrl_req ); } } } /* grr_cgrlc_pwr_ctrl_req() */ /* +------------------------------------------------------------------------------ | Function : grr_prcs_pwr_ctrl +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_prcs_pwr_ctrl ( T_CGRLC_pwr_ctrl *pwr_ctrl, BOOL v_c_value ) { USHORT pdch_arfcn; TRACE_FUNCTION( "grr_prcs_pwr_ctrl" ); if( grr_data->tc.v_freq_set ) { /* * Apply the ARFCN value obtained from the assignment message. * * When getting the ARFCN value, reconvert it to the absolute * ARFCN value, since grr_data->tc has L1 mapped ARFCN values. */ if( grr_data->tc.freq_set.freq_par.p_chan_sel.hopping ) { /* If hopping is enabled, then take the first ARFCN value from the assignment */ pdch_arfcn = grr_l1_arfcn_to_g23 ( grr_data->tc.freq_set.freq_par.p_freq_list.p_rf_chan_no.p_radio_freq[0] ); } else { /* If hopping is disabled, then take the ARFCN value from the assignment */ pdch_arfcn = grr_l1_arfcn_to_g23 ( grr_data->tc.freq_set.freq_par.p_chan_sel.p_rf_ch.arfcn ); } } else { pdch_arfcn = psc_db->pbcch.bcch.arfcn; } if( grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param ) { T_CGRLC_pwr_ctrl_param *pwr_ctrl_param = &pwr_ctrl->pwr_ctrl_param; if( psc_db->v_pwr_par EQ TRUE AND psc_db->pwr_par.v_alpha EQ TRUE ) { pwr_ctrl_param->alpha = psc_db->pwr_par.alpha; } else { pwr_ctrl_param->alpha = CGRLC_ALPHA_INVALID; } { UBYTE i; for( i = 0; i < CGRLC_MAX_TIMESLOTS; i++ ) { if( psc_db->v_pwr_par EQ TRUE AND psc_db->pwr_par.gamma_tn[i].v_gamma EQ TRUE ) { pwr_ctrl_param->gamma_ch[i] = psc_db->pwr_par.gamma_tn[i].gamma; } else { pwr_ctrl_param->gamma_ch[i] = CGRLC_GAMMA_INVALID; } } } } if( grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param ) { T_CGRLC_glbl_pwr_ctrl_param *glbl_pwr_ctrl_param = &pwr_ctrl->glbl_pwr_ctrl_param; T_MS_PWR_CAP mspc; glbl_pwr_ctrl_param->alpha = psc_db->g_pwr_par.alpha; glbl_pwr_ctrl_param->t_avg_t = psc_db->g_pwr_par.t_avg_t; glbl_pwr_ctrl_param->pb = psc_db->g_pwr_par.pb; glbl_pwr_ctrl_param->pc_meas_chan = psc_db->g_pwr_par.pc_meas_chan; glbl_pwr_ctrl_param->pwr_max = grr_get_pms_max ( pdch_arfcn, grr_data->meas.pwr_offset, psc_db->scell_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch, &mspc ); } if( grr_data->pwr_ctrl_valid_flags.v_freq_param ) { T_CGRLC_freq_param *freq = &pwr_ctrl->freq_param; T_MS_PWR_CAP mspc; grr_get_ms_pwr_cap( pdch_arfcn, grr_data->meas.pwr_offset, &mspc ); freq->bcch_arfcn = grr_g23_arfcn_to_l1( psc_db->pbcch.bcch.arfcn ); freq->pdch_hopping = ( grr_data->tc.v_freq_set AND grr_data->tc.freq_set.freq_par.p_chan_sel.hopping ); freq->pdch_band = mspc.band_ind; } if( v_c_value ) { if( grr_data->pwr_ctrl_valid_flags.v_c_value ) { meas_c_get_c_value( &pwr_ctrl->c_value ); } pwr_ctrl->v_c_value = grr_data->pwr_ctrl_valid_flags.v_c_value; grr_data->pwr_ctrl_valid_flags.v_c_value = FALSE; } else { pwr_ctrl->v_c_value = v_c_value; } pwr_ctrl->v_pwr_ctrl_param = grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param; pwr_ctrl->v_glbl_pwr_ctrl_param = grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param; pwr_ctrl->v_freq_param = grr_data->pwr_ctrl_valid_flags.v_freq_param; grr_data->pwr_ctrl_valid_flags.v_pwr_ctrl_param = FALSE; grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param = FALSE; grr_data->pwr_ctrl_valid_flags.v_freq_param = FALSE; } /* grr_prcs_pwr_ctrl */ /* +------------------------------------------------------------------------------ | Function : grr_set_cell_info_service +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_set_cell_info_service( void ) { TRACE_FUNCTION( "grr_set_cell_info_service" ); if ( psc_db->cell_info_for_gmm.gprs_service EQ GPRS_SERVICE_NONE ) { psc_db->cell_info_for_gmm.cell_info.service_state = GMMRR_SERVICE_NONE; } else if( psc_db->cell_info_for_gmm.gprs_service EQ GPRS_SERVICE_FULL AND psc_db->cell_info_for_gmm.access_status EQ GPRS_ACCESS_ALLOWED ) { psc_db->cell_info_for_gmm.cell_info.service_state = GMMRR_SERVICE_FULL; } else { psc_db->cell_info_for_gmm.cell_info.service_state = GMMRR_SERVICE_LIMITED; } } /* grr_set_cell_info_service */ /* +------------------------------------------------------------------------------ | Function : grr_is_packet_idle_mode +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_is_packet_idle_mode( void ) { /* * The entity GRR as a whole is in packet idle mode in case the three state * machines below are in packet idle mode in detail. * * There are state transitions, in which one of these state machines is in * packet idle mode, but the others are in different states (e.g. during * processing of RRGRR_STOP_TASK_REQ/CNF or MPHP_ASSIGNMENT_REQ/CON). That's * why all three states shall be considered. */ return( GET_STATE( CTRL_GLBL ) EQ GLBL_PCKT_MODE_IDLE AND GET_STATE( TC ) EQ TC_PIM AND GET_STATE( CPAP ) EQ CPAP_IDLE ); } /* grr_is_packet_idle_mode */ /* +------------------------------------------------------------------------------ | Function : grr_clip_rxlev +------------------------------------------------------------------------------ | Description : This function is used to clip received signal level values. | | Parameters : clipp - pointer to clipped received signal level values | rxlev - pointer to received signal level values | number - number of received signal level values | +------------------------------------------------------------------------------ */ GLOBAL void grr_clip_rxlev ( UBYTE *clipp, UBYTE *rxlev, UBYTE number ) { UBYTE i; /* used for counting */ TRACE_FUNCTION( "grr_clip_rxlev" ); for( i = 0; i < number; i++ ) { if( (signed char)( rxlev[i] ) < CGRLC_RXLEV_MIN AND rxlev[i] NEQ CGRLC_RXLEV_NONE ) { clipp[i] = CGRLC_RXLEV_MIN; } else if ( (signed char)( rxlev[i] ) > CGRLC_RXLEV_MAX ) { clipp[i] = CGRLC_RXLEV_MAX; } else if( rxlev[i] EQ CGRLC_RXLEV_NONE ) { clipp[i] = CGRLC_RXLEV_NONE; } else { clipp[i] = rxlev[i]; } } } /* grr_clip_rxlev() */ /* +------------------------------------------------------------------------------ | Function : grr_get_pms_max +------------------------------------------------------------------------------ | Description : This function is used to ... | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grr_get_pms_max ( USHORT arfcn, UBYTE pwr_offset, UBYTE gprs_ms_txpwr_max_cch, T_MS_PWR_CAP *mspc ) { UBYTE pms_max; /* maximum output power applied by the MS */ TRACE_FUNCTION( "grr_get_pms_max" ); grr_get_ms_pwr_cap( arfcn, pwr_offset, mspc ); pms_max = mspc->pwr_offset + mspc->p_control[gprs_ms_txpwr_max_cch]; pms_max = MINIMUM( pms_max, mspc->p[mspc->ms_power] ); return( pms_max ); } /* grr_get_pms_max() */ /* +------------------------------------------------------------------------------ | Function : grr_get_ms_txpwr_max_cch +------------------------------------------------------------------------------ | Description : ... | | Parameters : ... | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grr_get_ms_txpwr_max_cch ( USHORT arfcn, UBYTE pwr_offset, UBYTE gprs_ms_txpwr_max_cch ) { T_MS_PWR_CAP mspc; /* MS power capabilities */ UBYTE pms_max; /* maximum output power applied by the MS */ TRACE_FUNCTION( "grr_get_ms_txpwr_max_cch" ); pms_max = grr_get_pms_max( arfcn, pwr_offset, gprs_ms_txpwr_max_cch, &mspc ); return( grr_get_pcl( mspc.p_control, pms_max ) ); } /* grr_get_ms_txpwr_max_cch() */ /* +------------------------------------------------------------------------------ | Function : grr_get_ms_pwr_cap +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_get_ms_pwr_cap ( USHORT arfcn, UBYTE pow_offset, T_MS_PWR_CAP *mspc ) { TRACE_FUNCTION( "grr_get_ms_pwr_cap" ); switch( std ) { case STD_850: grr_get_ms_pwr_cap_gsm900 ( grr_get_power_class( IDX_PWRCLASS_850 ), mspc ); break; case STD_900: case STD_EGSM: grr_get_ms_pwr_cap_gsm900 ( grr_get_power_class( IDX_PWRCLASS_900 ), mspc ); break; case STD_1900: grr_get_ms_pwr_cap_pcs1900 ( grr_get_power_class( IDX_PWRCLASS_1900 ), pow_offset, mspc ); break; case STD_1800: grr_get_ms_pwr_cap_dcs1800 ( grr_get_power_class( IDX_PWRCLASS_1800 ), pow_offset, mspc ); break; case STD_DUAL: /* * For dualband mobiles the calculation depends on the channel number */ if( arfcn < LOW_CHANNEL_1800 ) { /* * All GSM 900 */ grr_get_ms_pwr_cap_gsm900 ( grr_get_power_class( IDX_PWRCLASS_900 ), mspc ); } else { /* * All DCS 1800 channels */ grr_get_ms_pwr_cap_dcs1800 ( grr_get_power_class( IDX_PWRCLASS_1800 ), pow_offset, mspc ); } break; case STD_DUAL_EGSM: if( arfcn < LOW_CHANNEL_1800 OR arfcn > HIGH_CHANNEL_1800 ) { /* * All GSM 900 and E-GSM channels */ grr_get_ms_pwr_cap_gsm900 ( grr_get_power_class( IDX_PWRCLASS_900 ), mspc ); } else { /* * All DCS 1800 channels */ grr_get_ms_pwr_cap_dcs1800 ( grr_get_power_class( IDX_PWRCLASS_1800 ), pow_offset, mspc ); } break; case STD_DUAL_US: if( arfcn < LOW_CHANNEL_1900 ) { /* * All GSM 850 channels */ grr_get_ms_pwr_cap_gsm900 ( grr_get_power_class( IDX_PWRCLASS_850 ), mspc ); } else { /* * All PCS 1900 channels */ grr_get_ms_pwr_cap_pcs1900 ( grr_get_power_class( IDX_PWRCLASS_1900 ), pow_offset, mspc ); } break; #ifdef TI_PS_FF_QUAD_BAND_SUPPORT case STD_850_1800: if( arfcn < LOW_CHANNEL_1800 ) { /* * All GSM 850 channels */ grr_get_ms_pwr_cap_gsm900 ( grr_get_power_class( IDX_PWRCLASS_850 ), mspc ); } else { /* * All DCS 1800 channels */ grr_get_ms_pwr_cap_dcs1800 ( grr_get_power_class( IDX_PWRCLASS_1800 ), pow_offset, mspc ); } break; case STD_900_1900: if( arfcn >= LOW_CHANNEL_1900 AND arfcn <= HIGH_CHANNEL_1900 ) { /* * All PCS 1900 channels */ grr_get_ms_pwr_cap_pcs1900 ( grr_get_power_class( IDX_PWRCLASS_1900 ), pow_offset, mspc ); } else { /* * All GSM 900 and E-GSM channels */ grr_get_ms_pwr_cap_gsm900 ( grr_get_power_class( IDX_PWRCLASS_900 ), mspc ); } break; case STD_850_900_1800: if( arfcn >= LOW_CHANNEL_1800 AND arfcn <= HIGH_CHANNEL_1800 ) { /* * All DCS 1800 channels */ grr_get_ms_pwr_cap_dcs1800 ( grr_get_power_class( IDX_PWRCLASS_1800 ), pow_offset, mspc ); } else { if((arfcn >= LOW_CHANNEL_850) AND (arfcn <= HIGH_CHANNEL_850)) { /* * All GSM 850 channels */ grr_get_ms_pwr_cap_gsm900 ( grr_get_power_class( IDX_PWRCLASS_850 ), mspc ); } else { /* * All GSM 900 and E-GSM channels */ grr_get_ms_pwr_cap_gsm900 ( grr_get_power_class( IDX_PWRCLASS_900 ), mspc ); } } break; case STD_850_900_1900: if( arfcn >= LOW_CHANNEL_1900 AND arfcn <= HIGH_CHANNEL_1900 ) { /* * All PCS 1900 channels */ grr_get_ms_pwr_cap_pcs1900 ( grr_get_power_class( IDX_PWRCLASS_1900 ), pow_offset, mspc ); } else { if((arfcn >= LOW_CHANNEL_850) AND (arfcn <= HIGH_CHANNEL_850)) { /* * All GSM 850 channels */ grr_get_ms_pwr_cap_gsm900 ( grr_get_power_class( IDX_PWRCLASS_850 ), mspc ); } else { /* * All GSM 900 and E-GSM channels */ grr_get_ms_pwr_cap_gsm900 ( grr_get_power_class( IDX_PWRCLASS_900 ), mspc ); } } break; default : TRACE_EVENT_P1 (" std : %d",std); break; #endif } } /* grr_get_ms_pwr_cap */ /* +------------------------------------------------------------------------------ | Function : grr_get_ms_pwr_cap_gsm900 +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_get_ms_pwr_cap_gsm900 ( UBYTE rf_pow_cap, T_MS_PWR_CAP *mspc ) { TRACE_FUNCTION( "grr_get_ms_pwr_cap_gsm900" ); /* * The table for the power class conversion in GSM 900 */ mspc->p = p_gsm; /* * The table for the GPRS_MAX_TXPWR_CCCH conversion in GSM 900 */ mspc->p_control = p_control_gsm; /* * The MS power class is defined in classmark 2 of the non-volatile * memory data for GSM 900. */ mspc->ms_power = rf_pow_cap - 1; /* * For a power class 3 mobile in the DCS or PCS frequency * standard an additional power offset can be defined * * Note: This parameter is only available for the serving cell * */ mspc->pwr_offset = 0; /* * Maximum allowed output power in the cell */ mspc->pwr_max = p_control_gsm[MAX_PCL_GSM900]; /* * Minimum required output power in the cell */ mspc->pwr_min = p_control_gsm[MIN_PCL_GSM900]; mspc->gamma_0 = GAMMA_0_GSM900; mspc->band_ind = CGRLC_GSM_900; } /* grr_get_ms_pwr_cap_gsm900 */ /* +------------------------------------------------------------------------------ | Function : grr_get_ms_pwr_cap_dcs1800 +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_get_ms_pwr_cap_dcs1800 ( UBYTE rf_pow_cap, UBYTE pow_offset, T_MS_PWR_CAP *mspc ) { TRACE_FUNCTION( "grr_get_ms_pwr_cap_dcs1800" ); mspc->p = p_dcs; mspc->p_control = p_control_dcs; mspc->ms_power = rf_pow_cap - 1; mspc->pwr_offset = ( ( rf_pow_cap EQ POWER_CLASS_3 ) ? 2 * pow_offset : 0 ); mspc->pwr_max = p_control_dcs[MAX_PCL_DCS1800]; mspc->pwr_min = p_control_dcs[MIN_PCL_DCS1800]; mspc->gamma_0 = GAMMA_0_DCS1800; mspc->band_ind = CGRLC_DCS_1800; } /* grr_get_ms_pwr_cap_dcs1800 */ /* +------------------------------------------------------------------------------ | Function : grr_get_ms_pwr_cap_pcs1900 +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void grr_get_ms_pwr_cap_pcs1900 ( UBYTE rf_pow_cap, UBYTE pow_offset, T_MS_PWR_CAP *mspc ) { TRACE_FUNCTION( "grr_get_ms_pwr_cap_pcs1900" ); mspc->p = p_pcs; mspc->p_control = p_control_pcs; mspc->ms_power = rf_pow_cap - 1; mspc->pwr_offset = ( ( rf_pow_cap EQ POWER_CLASS_3 ) ? 2 * pow_offset : 0 ); mspc->pwr_max = p_control_pcs[MAX_PCL_PCS1900]; mspc->pwr_min = p_control_pcs[MIN_PCL_PCS1900]; mspc->gamma_0 = GAMMA_0_PCS1900; mspc->band_ind = CGRLC_PCS_1900; } /* grr_get_ms_pwr_cap_pcs1900 */ /* +------------------------------------------------------------------------------ | Function : grr_get_power_class +------------------------------------------------------------------------------ | Description : | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grr_get_power_class ( UBYTE index ) { T_rf_cap *rf_cap = rr_csf_get_rf_capability( ); UBYTE power_class; TRACE_FUNCTION( "grr_get_power_class" ); if( rf_cap NEQ NULL ) { power_class = rf_cap->rf_power.pow_class4[index].pow_class; } else { power_class = POWER_CLASS_1; TRACE_ERROR( "grr_get_power_class: RF capabilities invalid" ); } return( power_class ); } /* grr_get_power_class */ /* +------------------------------------------------------------------------------ | Function : grr_get_pcl +------------------------------------------------------------------------------ | Description : This function is used to convert the nominal output power to | the power control level | | Parameters : p_ctrl - pointer to table of power control levels | nop - nominal output power | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grr_get_pcl ( UBYTE const *p_ctrl, SHORT nop ) { UBYTE pcl = 0; /* power control level */ TRACE_FUNCTION( "grr_get_pcl" ); /* get power control level */ while( nop < (SHORT)p_ctrl[pcl] - 1 OR nop >= (SHORT)p_ctrl[pcl] + 1 ) pcl++; return( pcl ); } /* grr_get_pcl() */ /* +------------------------------------------------------------------------------ | Function : grr_validate_ma_num_in_freq_par +------------------------------------------------------------------------------ | Description : Validates MA_NUM in indirect encoding. | This validation is required only when | freq parameters are received with indirect | encoding. | Change mark received with Frequency parameters is compared | with the stored change mark for PSI2/PSI13/SI13 to determine | if the mobile allocation stored in these messages could be used. | | Frequency parameters received in an assignment message could refer | to GPRS mobile allocation received in a previous assignment message | by using MA_NUM = 15 in indirect encoding. Frequency parameters | received in non-assignment message( For example PSI 8 or PSI 14) | cannot refer to GPRS mobile received in a previous message. | This validation is done using the second parameter. | | This function should be used before using the GPRS mobile allocation | referred in freq_par. | Parameters : freq_par - points to the frequency parameter structure | received in system information/some assignment message. | | msg_type - identifies the type of message in which freq par | was received. Two values are possible. | GRR_FREQ_PARAM_RECEIVED_IN_ASSIGNMENT 0 | GRR_FREQ_PARAM_RECEIVED_IN_NON_ASSIGNMENT 1 | Return value : True - if validation sucessful. +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_validate_ma_num_in_freq_par(const T_freq_par *freq_par,UBYTE msg_type) { BOOL result; TRACE_FUNCTION("grr_validate_ma_num_in_freq_par"); if(MA_NUMBER_4_ASSIGNMENT EQ freq_par->indi_encod.ma_num) { if(GRR_FREQ_PARAM_RECEIVED_IN_ASSIGNMENT NEQ msg_type ) { TRACE_ERROR("Frequency parameter in a non assignment message"); TRACE_ERROR("cannot have ma_num==MA_NUMBER_4_ASSIGNMENT"); result = FALSE; } else if( (MA_NUMBER_4_ASSIGNMENT EQ psc_db->gprs_ms_alloc_in_assignment.ma_num) AND (!freq_par->indi_encod.v_chamge_ma_sub) ) { result = TRUE; } else { TRACE_ERROR("mobile allocation in assignment wrong"); result = FALSE; } } else if(MA_NUMBER_4_PSI13_OR_CELL_ALLOC EQ freq_par->indi_encod.ma_num) { if( ( (freq_par->indi_encod.v_chamge_ma_sub ) AND (freq_par->indi_encod.chamge_ma_sub.cm1 EQ psc_db->psi13_params.si13_change_mark ) ) OR ( (freq_par->indi_encod.chamge_ma_sub.v_cm2 ) AND (freq_par->indi_encod.chamge_ma_sub.cm2 EQ psc_db->psi13_params.si13_change_mark ) ) OR ( !freq_par->indi_encod.v_chamge_ma_sub AND !freq_par->indi_encod.chamge_ma_sub.v_cm2 )) { result = TRUE; } else { TRACE_ERROR("wrong si13 change mark value"); result = FALSE; } } else { if( ( (freq_par->indi_encod.v_chamge_ma_sub ) AND (freq_par->indi_encod.chamge_ma_sub.cm1 EQ psc_db->psi2_params.psi2_change_mark ) ) OR ( (freq_par->indi_encod.chamge_ma_sub.v_cm2 ) AND (freq_par->indi_encod.chamge_ma_sub.cm2 EQ psc_db->psi2_params.psi2_change_mark ) ) OR ( !freq_par->indi_encod.v_chamge_ma_sub AND !freq_par->indi_encod.chamge_ma_sub.v_cm2 )) { result = TRUE; } else { TRACE_ERROR("wrong psi2 change mark value"); TRACE_EVENT_P5("psi2cm:%d vcm1:%d cm1:%d vcm2:%d cm2:%d", psc_db->psi2_params.psi2_change_mark, freq_par->indi_encod.v_chamge_ma_sub, freq_par->indi_encod.chamge_ma_sub.cm1, freq_par->indi_encod.chamge_ma_sub.v_cm2, freq_par->indi_encod.chamge_ma_sub.cm2); result = FALSE; } } return result; } /* grr_validate_ma_num_in_freq_par */ /* +------------------------------------------------------------------------------ | Function : grr_get_gprs_ma +------------------------------------------------------------------------------ | Description : ma_num identifies the GPRS mobile allocation received | in PSI 2, PSI 13 or the previous assignment message. | This function returns the matching pointer to the | GPRS Mobile allocation IE. | | Parameters : ma_num - 0 to 13 - gprs mobile allocation received in PSI 2 | 14 gprs mobile allocation received in Si13/PSI13 | 15 GPRS mobile allocation received in previous | assignment message. | Return value : Pointer to appropriate GPRS MA stored in psc db. +------------------------------------------------------------------------------ */ GLOBAL T_gprs_ms_alloc_ie* grr_get_gprs_ma(UBYTE ma_num) { USHORT n = 0; T_gprs_ms_alloc_ie *gp_ma = NULL; TRACE_FUNCTION( "grr_get_gprs_ma" ); if(ma_num > MA_NUMBER_4_ASSIGNMENT) { TRACE_ERROR("ma_num > MA_NUMBER_4_ASSIGNMENT"); return NULL; } /* * Get the GPRS Mobile Allocation IE corresponding to the ma_num */ switch(ma_num) { /* MA_NUMBER used to reference a MA received in a previous assignent */ case MA_NUMBER_4_ASSIGNMENT: if( psc_db->gprs_ms_alloc_in_assignment.ma_num NEQ NOT_SET ) { gp_ma = &psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie; } break; /* MA_NUMBER used to reference a Mobile Allocation * (MA) received in PSI13, which may referenced from * an assignment message or which referes to the cell * allocation defined for the cell in SI1 or PSI2 */ case MA_NUMBER_4_PSI13_OR_CELL_ALLOC: /*lint -fallthrough*/ /* GPRS Mobile Allocations received in PSI2 and/or PSI13 values 0...13 */ default: for(n = 0; n < MAX_GPRS_MS_ALLOC; n++) { if( psc_db->gprs_ms_alloc_in_psi2_psi13[n].ma_num EQ ma_num) { gp_ma = &psc_db->gprs_ms_alloc_in_psi2_psi13[n].gprs_ms_alloc_ie; break; } } break; } return gp_ma; } /* grr_get_gprs_ma */ /* +------------------------------------------------------------------------------ | Function : grr_cnv_freq_para_in_assignment_direct_enc_2 +------------------------------------------------------------------------------ | Description : This function decodes the frequency parametes received | in direct encoding2 form. It constructs the Mobile allocation | list as required by TI L1 MPHP primitives. | | Parameters : | | NOTE: THIS FUNCTION USES THE LOCAL TEMPORARY ARRAYS - _local_rfl_contents AND | _local_dummy_list. These are use by grr_cnv_freq_para_in_psi8_direct_enc_2() | also. These two functions are placed in the same object module to avoid | the need for two copies of temporary arrays. +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_cnv_freq_para_in_assignment_direct_enc_2 (T_p_frequency_par *frequency_par,T_freq_par *freq_par) { TRACE_FUNCTION("grr_cnv_freq_para_in_assignment_direct_enc_2"); /* decode and store rfl list */ /* clean RFL content */ memset (&_local_rfl_contents, 0, sizeof(T_f_range)); /* Length in bits */ _local_rfl_contents.l_f = (freq_par->di_encod2.len_ma_list+3)*8; /* Copy RFL content bits into the structure */ memcpy(_local_rfl_contents.b_f, freq_par->di_encod2.ma_list, freq_par->di_encod2.len_ma_list+3); /* * Use a function from RR * This function copies the frequencies into list. This function takes the arranging * of ARFCN into account cf. 12.10a GPRS Mobile Allocation in 04.60 */ for_create_channel_list (&_local_rfl_contents, &_local_dummy_list); memcpy(psc_db->rfl[MAX_RFL].list, _local_dummy_list.b_f, sizeof(psc_db->rfl[MAX_RFL].list)); /* grr_create_channel_list(freq_par->di_encod2.ma_list, psc_db->rfl[MAX_RFL].list);*/ psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie.hsn = freq_par->di_encod2.hsn; psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie.v_rfl_num_list = TRUE; psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie.c_rfl_num_list = 1; psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie.v_ma_struct = FALSE; psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie.v_arfcn_index_list = FALSE; /* set up gprs_ms_alloc_in_assignment struct in database */ psc_db->gprs_ms_alloc_in_assignment.ma_num = MA_NUMBER_4_ASSIGNMENT; psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie.rfl_num_list[0].rfl_num = psc_db->rfl[MAX_RFL].num = RFL_NUMBER_4_DIRECT_ENCODING_2; return(grr_create_freq_list( psc_db->gprs_ms_alloc_in_assignment.ma_num, freq_par->di_encod2.maio, &frequency_par->p_chan_sel, &frequency_par->p_freq_list )); }/* grr_cnv_freq_para_in_assignment_direct_enc_2 */ #ifdef REL99 /* +------------------------------------------------------------------------------ | Function : grr_cnv_freq_para_in_psi8_direct_enc_2 +------------------------------------------------------------------------------ | Description : This function decodes the Frequency parameters in direct encoding 2 | The output of this function is in form which could be used by | MPH_* primitives in RR. This The mobile allocation list | generated by this function is different from the ones used by | MPHP_* primitives. | CBCH parameters are passed to RR and RR passes to ALR and ALR | converts these frequencies to TI L1 form and passes in MPHC_* | primitive to L1. | The caller of this function should make sure that the type of | encoding used in freq_par is of direct encoding 2. | Parameters : cbch_req - output. | freq_par - input | NOTE: THIS FUNCTION USES THE LOCAL TEMPORARY ARRAYS - _local_rfl_contents AND | _local_dummy_list. These are use by grr_cnv_freq_para_in_assignment_direct_enc_2() | also.These two functions are placed in the same object module to avoid | the need for two copies of temporary arrays. +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_cnv_freq_para_in_psi8_direct_enc_2(T_cbch *cbch_req,const T_freq_par *freq_par) { USHORT count = 0; TRACE_FUNCTION( "grr_cnv_freq_para_in_psi8_direct_enc_2"); /* decode and store rfl list */ /* clean RFL content */ memset (&_local_rfl_contents, 0, sizeof(T_f_range)); /* Length in bits */ _local_rfl_contents.l_f = (freq_par->di_encod2.len_ma_list+3)*8; /* Copy RFL content bits into the structure */ memcpy(_local_rfl_contents.b_f, freq_par->di_encod2.ma_list, freq_par->di_encod2.len_ma_list+3); /* * Use a function from RR * This function copies the frequencies into list. This function takes the arranging * of ARFCN into account cf. 12.10a GPRS Mobile Allocation in 04.60 */ for_create_channel_list (&_local_rfl_contents, &_local_dummy_list); /* Local dummy list represents the mobile allocation. * This list need not be filtered with grr_ma_filter_list * as ALL arfcns in this list are part of mobile allocation. * But we need to validate this list. */ srv_create_list(&_local_dummy_list,cbch_req->ma, 64 , TRUE ,0); if(!grr_validate_and_count_frequencies(cbch_req->ma,&count)) { TRACE_ERROR( "grr_cnv_freq_para_in_psi8_direct_enc_2:validation failed/freq count zero" ); return FALSE; } cbch_req->ma[count] = NOT_PRESENT_16BIT; cbch_req->maio = freq_par->di_encod2.maio; cbch_req->hsn = freq_par->di_encod2.hsn ; return TRUE; }/* grr_cnv_freq_para_in_psi8_direct_enc_2 */ #endif /* +------------------------------------------------------------------------------ | Function : grr_validate_and_count_frequencies +------------------------------------------------------------------------------ | Description : This function ensures that all the frequencies in the list | are of same band. It returns the cout of frequencies in the list. | NOT_PRESENT_16BIT represents the end of list. | Parameters : Array representing the frequency list | ptr_cnt - output, returns the count. | Return value :TRUE/FALSE +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_validate_and_count_frequencies(USHORT radio_freq_list[MPHP_NUMC_MA],USHORT* ptr_cnt) { USHORT n = 0; TRACE_FUNCTION("grr_validate_and_count_frequencies"); switch( std ) { case STD_900: /* frequencies must between 1 and 124 */ for(n=0, *ptr_cnt=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_900 ) AND ( radio_freq_list[n] <= HIGH_CHANNEL_900)) { (*ptr_cnt)++; } else { TRACE_EVENT_P1( "STD_900:Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } break; case STD_EGSM: for(n=0, *ptr_cnt=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1))) { (*ptr_cnt)++; } else { TRACE_EVENT_P1( "STD_EGSM: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } break; case STD_1900: for(n=0, *ptr_cnt=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_1900 ) AND ( radio_freq_list[n] <= HIGH_CHANNEL_1900)) { (*ptr_cnt)++; } else { TRACE_EVENT_P1( "STD_1900: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } break; case STD_1800: for(n=0, *ptr_cnt=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_1800 ) AND ( radio_freq_list[n] <= HIGH_CHANNEL_1800)) { (*ptr_cnt)++; } else { TRACE_EVENT_P1( "STD_1800: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } break; case STD_850: for(n=0, *ptr_cnt=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_850 ) AND ( radio_freq_list[n] <= HIGH_CHANNEL_850)) { (*ptr_cnt)++; } else { TRACE_EVENT_P1( "STD_850: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } break; case STD_DUAL: if (( radio_freq_list[0] >= LOW_CHANNEL_900 ) AND (radio_freq_list[0] <= HIGH_CHANNEL_900)) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_900 ) AND (radio_freq_list[n] <= HIGH_CHANNEL_900)) { *(ptr_cnt)+=1; } else { TRACE_EVENT_P1( "STD_DUAL: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else if (( radio_freq_list[0] >= LOW_CHANNEL_1800 ) AND (radio_freq_list[0] <= HIGH_CHANNEL_1800)) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_1800 ) AND (radio_freq_list[n] <= HIGH_CHANNEL_1800)) { *(ptr_cnt)+=1; } else { TRACE_EVENT_P1( "STD_DUAL: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else { TRACE_EVENT_P1( "STD_DUAL: Frequency %d not in the band!", radio_freq_list[0]); return FALSE; } break; case STD_DUAL_EGSM: if((radio_freq_list[0] <= HIGH_CHANNEL_900) OR ((radio_freq_list[0] >= LOW_CHANNEL_EGSM) AND (radio_freq_list[0] <= HIGH_CHANNEL_EGSM - 1))) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1))) { *(ptr_cnt)+=1; } else { TRACE_EVENT_P1( "STD_DUAL_EGSM: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else if (( radio_freq_list[0] >= LOW_CHANNEL_1800 ) AND (radio_freq_list[0] <= HIGH_CHANNEL_1800)) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_1800 ) AND (radio_freq_list[n] <= HIGH_CHANNEL_1800)) { *(ptr_cnt)+=1; } else { TRACE_EVENT_P1( "STD_DUAL_EGSM: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else { TRACE_EVENT_P1( "STD_DUAL_EGSM: Frequency %d not in the band!", radio_freq_list[0]); return FALSE; } break; case STD_DUAL_US: if (( radio_freq_list[0] >= LOW_CHANNEL_850 ) AND (radio_freq_list[0] <= HIGH_CHANNEL_850)) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_850 ) AND (radio_freq_list[n] <= HIGH_CHANNEL_850)) { *(ptr_cnt)+=1; } else { TRACE_EVENT_P1( "STD_DUAL_US: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else if (( radio_freq_list[0] >= LOW_CHANNEL_1900 ) AND (radio_freq_list[0] <= HIGH_CHANNEL_1900)) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_1900 ) AND ( radio_freq_list[n] <= HIGH_CHANNEL_1900)) { (*ptr_cnt)++; } else { TRACE_EVENT_P1( "STD_DUAL_US: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else { TRACE_EVENT_P1( "STD_DUAL_US: Frequency %d not in the band!", radio_freq_list[0]); return FALSE; } break; #ifdef TI_PS_FF_QUAD_BAND_SUPPORT case STD_850_1800: if (( radio_freq_list[0] >= LOW_CHANNEL_850 ) AND ( radio_freq_list[0] <= HIGH_CHANNEL_850)) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_850 ) AND ( radio_freq_list[n] <= HIGH_CHANNEL_850)) { *(ptr_cnt)+=1; } else { TRACE_EVENT_P1( "STD_850_1800: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else if (( radio_freq_list[0] >= LOW_CHANNEL_1800 ) AND ( radio_freq_list[0] <= HIGH_CHANNEL_1800)) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_1800 ) AND ( radio_freq_list[n] <= HIGH_CHANNEL_1800)) { (*ptr_cnt)++; } else { TRACE_EVENT_P1( "STD_850_1800: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else { TRACE_EVENT_P1( "STD_850_1800: Frequency %d not in the band!", radio_freq_list[0]); return FALSE; } break; case STD_900_1900: if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1))) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1))) { *(ptr_cnt)+=1; } else { TRACE_EVENT_P1( "STD_900_1900: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else if (( radio_freq_list[0] >= LOW_CHANNEL_1900 ) AND ( radio_freq_list[0] <= HIGH_CHANNEL_1900)) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_1900 ) AND ( radio_freq_list[n] <= HIGH_CHANNEL_1900)) { (*ptr_cnt)++; } else { TRACE_EVENT_P1( "STD_900_1900: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else { TRACE_EVENT_P1( "STD_900_1900: Frequency %d not in the band!", radio_freq_list[0]); return FALSE; } break; case STD_850_900_1800: if (( radio_freq_list[0] >= LOW_CHANNEL_850 ) AND ( radio_freq_list[0] <= HIGH_CHANNEL_850)) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_850 ) AND ( radio_freq_list[n] <= HIGH_CHANNEL_850)) { *(ptr_cnt)+=1; } else { TRACE_EVENT_P1( "STD_850_900_1800: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1))) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1))) { (*ptr_cnt)++; } else { TRACE_EVENT_P1( "STD_850_900_1800: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else if (( radio_freq_list[0] >= LOW_CHANNEL_1800 ) AND ( radio_freq_list[0] <= HIGH_CHANNEL_1800)) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_1800 ) AND ( radio_freq_list[n] <= HIGH_CHANNEL_1800)) { (*ptr_cnt)++; } else { TRACE_EVENT_P1( "STD_850_900_1800: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else { TRACE_EVENT_P1( "STD_850_900_1800: Frequency %d not in the band!", radio_freq_list[0]); return FALSE; } break; case STD_850_900_1900: if (( radio_freq_list[0] >= LOW_CHANNEL_850 ) AND ( radio_freq_list[0] <= HIGH_CHANNEL_850)) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_850 ) AND ( radio_freq_list[n] <= HIGH_CHANNEL_850)) { *(ptr_cnt)+=1; } else { TRACE_EVENT_P1( "STD_850_900_1900: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1))) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if((radio_freq_list[n] <= HIGH_CHANNEL_900) OR ((radio_freq_list[n] >= LOW_CHANNEL_EGSM) AND (radio_freq_list[n] <= HIGH_CHANNEL_EGSM - 1))) { (*ptr_cnt)++; } else { TRACE_EVENT_P1( "STD_850_900_1900: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else if (( radio_freq_list[0] >= LOW_CHANNEL_1900 ) AND ( radio_freq_list[0] <= HIGH_CHANNEL_1900)) { for(n=0, *(ptr_cnt)=0; n < 64; n++) { if(radio_freq_list[n] EQ NOT_PRESENT_16BIT) break; if(( radio_freq_list[n] >= LOW_CHANNEL_1900 ) AND ( radio_freq_list[n] <= HIGH_CHANNEL_1900)) { (*ptr_cnt)++; } else { TRACE_EVENT_P1( "STD_850_900_1900: Frequency %d not in the band!", radio_freq_list[n]); return FALSE; } } } else { TRACE_EVENT_P1( "STD_850_900_1900: Frequency %d not in the band!", radio_freq_list[0]); return FALSE; } break; #endif default: #ifdef TI_PS_FF_QUAD_BAND_SUPPORT TRACE_ASSERT( std EQ STD_850 OR std EQ STD_900 OR std EQ STD_EGSM OR std EQ STD_1900 OR std EQ STD_1800 OR std EQ STD_DUAL OR std EQ STD_DUAL_EGSM OR std EQ STD_DUAL_US OR std EQ STD_850_1800 OR std EQ STD_900_1900 OR std EQ STD_850_900_1800 OR std EQ STD_850_900_1900 ); #else TRACE_ASSERT( std EQ STD_850 OR std EQ STD_900 OR std EQ STD_EGSM OR std EQ STD_1900 OR std EQ STD_1800 OR std EQ STD_DUAL OR std EQ STD_DUAL_EGSM OR std EQ STD_DUAL_US ); #endif break; } memset(&radio_freq_list[n], 0, (128-2*n)); /*lint !e669*/ /*set values back to zero, neeeded by windows test cases*/ *(ptr_cnt) = MINIMUM( MPHP_NUMC_MA, *ptr_cnt ); if( *ptr_cnt EQ 0 ) { TRACE_ERROR( "grr_validate_and_count_frequencies: freq count EQ 0" ); return FALSE; } return TRUE; }/* grr_validate_and_count_frequencies */ /* +------------------------------------------------------------------------------ | Function : grr_get_ref_list_or_cell_allocation +------------------------------------------------------------------------------ | Description : Determining the frequency list to be used for a hopping channel | involvs following steps. | 1. Determining the referenced set of reference frequency lists | or cell allocation.( See 3GPP 04.60 12.10a) | 2. Filtering this list based on MA_BITMAP and ARFCN index list. | | This function performs the first step. ie it generates | the referenced set of referncelists or Cell allocation list | depending on the presence of RFL number list in | the GPRS Mobile allocation IE. | Parameters : list1 - output, This is list will hold the referenced set of | reference freq list or Cell allocation depending on the | contents of gp_ma passed. | gp_ma - pointer to gprs mobile allocation IE | ma_num - identifies the MA_NUM in freq parameters IE. | 3GPP 04.60 Sec 5.5.1.7 | | Return value : TRUE/FALSE +------------------------------------------------------------------------------ */ GLOBAL BOOL grr_get_ref_list_or_cell_allocation(T_LIST *list1,const T_gprs_ms_alloc_ie *gp_ma,UBYTE ma_num) { BOOL pbcch_is_present = grr_is_pbcch_present( ); /* * Check RFL number list. If NOT exists, use cell allocation (CA) */ TRACE_FUNCTION(" grr_get_ref_list_or_cell_allocation "); if(!gp_ma->v_rfl_num_list) { /* * Use CA defined in PSI2 or in SI1 depending on the table below * * Case | PBCCH | PSI2 | RFL_NUMBERs | Action * | present | complete | all found | * -----+---------+----------+-------------+----------- * * 0 <= MA_NUMBER <= 15 * * -----+---------+----------+-------------+----------- * A | y | y | y | Use CA PSI * -----+---------+----------+-------------+----------- * B | y | y | n | Use CA SI * -----+---------+----------+-------------+----------- * C | y | n | x | Use CA SI * -----+---------+----------+-------------+----------- * D | n | x | x | Use CA SI * -----+---------+----------+-------------+----------- * * y = yes, n = no, x = don't case * */ if( pbcch_is_present EQ TRUE AND psc_db->state_of_PSI[PSI2].state EQ RECEIPT_OK AND psc_db->v_cell_alloc EQ TRUE ) { /* * Use CA in PSI2. RFLs define a CA. * If needed, we have to merge frequencies defined in different RFL's into one list */ /* Implementation of case A and B */ if( grr_get_psi_cell_alloc_list( list1 ) EQ FALSE ) { /* Implementation of case B */ TRACE_ERROR( "grr_create_freq_list: grr_get_psi_cell_alloc_list( ) EQ FALSE in case B" ); grr_get_si_cell_alloc_list( list1 ); } } else { /* Implementation of case C and D */ if( pbcch_is_present EQ TRUE ) { TRACE_EVENT( "grr_create_freq_list: PSI2 not OK in case C and D" ); } grr_get_si_cell_alloc_list( list1 ); } } else { /* * Use MA depending on the table below * * Case | PBCCH | PSI2 | RFL_NUMBERs | 0 <= RFL_NUMBER <= 15 | RFL_NUMBER == 16 | Action * | present | complete | all found | | | * -----+---------+----------+-------------+-----------------------+------------------+------------ * * 0 <= MA_NUMBER <= 13 * * -----+---------+----------+-------------+-----------------------+------------------+------------ * E | y | y | y | x | x | Use list * -----+---------+----------+-------------+-----------------------+------------------+------------ * F | y | y | n | x | x | Reject list * -----+---------+----------+-------------+-----------------------+------------------+------------ * G | y | n | x | x | x | Reject list * -----+---------+----------+-------------+-----------------------+------------------+------------ * H | n | x | x | x | x | Reject list * -----+---------+----------+-------------+-----------------------+------------------+------------ * * MA_NUMBER == 14 * * -----+---------+----------+-------------+-----------------------+------------------+------------ * I | y | y | y | x | x | Use list * -----+---------+----------+-------------+-----------------------+------------------+------------ * J | y | y | n | x | x | Use CA PSI * -----+---------+----------+-------------+-----------------------+------------------+------------ * K | y | n | x | x | x | Use CA SI * -----+---------+----------+-------------+-----------------------+------------------+------------ * L | n | x | x | x | x | Use CA SI * -----+---------+----------+-------------+-----------------------+------------------+------------ * * MA_NUMBER == 15 * * -----+---------+----------+-------------+-----------------------+------------------+------------ * M | y | y | y | x | x | Use list * -----+---------+----------+-------------+-----------------------+------------------+------------ * N | y | y | n | x | x | Reject list * -----+---------+----------+-------------+-----------------------+------------------+------------ * O | y | n | x | y | n | Reject list * -----+---------+----------+-------------+-----------------------+------------------+------------ * P | y | n | x | n | y | Use list * -----+---------+----------+-------------+-----------------------+------------------+------------ * Q | n | x | x | y | n | Reject list * -----+---------+----------+-------------+-----------------------+------------------+------------ * R | n | x | x | n | y | Use list * -----+---------+----------+-------------+-----------------------+------------------+------------ * * y = yes, n = no, x = don't case * */ /* * Use the defined RFL in GPRS MA * If needed, we have to merge frequencies defined in different RFL's into one list */ if( ma_num EQ MA_NUMBER_4_ASSIGNMENT ) { if( pbcch_is_present EQ TRUE AND psc_db->state_of_PSI[PSI2].state EQ RECEIPT_OK ) { /* Implementation of case M and N */ if( grr_get_ms_alloc_list( list1, gp_ma ) EQ FALSE ) { /* Implementation of case N */ TRACE_ERROR( "grr_create_freq_list: grr_get_ms_alloc_list( ) EQ FALSE in case N" ); return FALSE; } } else { if( gp_ma->c_rfl_num_list EQ 1 AND gp_ma->rfl_num_list[0].rfl_num EQ RFL_NUMBER_4_DIRECT_ENCODING_2 ) { /* Implementation of case P and R */ if( grr_get_ms_alloc_list( list1, gp_ma ) EQ FALSE ) { TRACE_ERROR( "grr_create_freq_list: grr_get_ms_alloc_list( ) EQ FALSE in case P and R" ); return FALSE; } } else { /* Implementation of case O and Q */ if( pbcch_is_present EQ TRUE ) { TRACE_ERROR( "grr_create_freq_list: PSI2 not OK in case O and Q" ); } else { TRACE_ERROR( "grr_create_freq_list: no PBCCH present and error in case O and Q" ); } return FALSE; } } } else if( ma_num EQ MA_NUMBER_4_PSI13_OR_CELL_ALLOC ) { if( pbcch_is_present EQ TRUE AND psc_db->state_of_PSI[PSI2].state EQ RECEIPT_OK ) { /* Implementation of case I and J */ if( grr_get_ms_alloc_list( list1, gp_ma ) EQ FALSE ) { /* Implementation of case J */ TRACE_ERROR( "grr_create_freq_list: grr_get_ms_alloc_list( ) EQ FALSE in case J" ); if( grr_get_psi_cell_alloc_list( list1 ) EQ FALSE ) { TRACE_ERROR( "grr_create_freq_list: grr_get_psi_cell_alloc_list( ) EQ FALSE in case J" ); grr_get_si_cell_alloc_list( list1 ); } } } else { /* Implementation of case K and L */ if( pbcch_is_present EQ TRUE ) { TRACE_ERROR( "grr_create_freq_list: PSI2 not OK in case K and L" ); } grr_get_si_cell_alloc_list( list1 ); } } else { if( pbcch_is_present EQ TRUE AND psc_db->state_of_PSI[PSI2].state EQ RECEIPT_OK ) { /* Implementation of case E and F */ if( grr_get_ms_alloc_list( list1, gp_ma ) EQ FALSE ) { /* Implementation of case F */ TRACE_ERROR( "grr_create_freq_list: grr_get_ms_alloc_list( ) EQ FALSE in case F" ); return FALSE; } } else { /* Implementation of case G and H */ if( pbcch_is_present EQ TRUE ) { TRACE_ERROR( "grr_create_freq_list: PSI2 not OK in case G and H" ); } return FALSE; } } } return TRUE; }/* grr_get_ref_list_or_cell_allocation */ #ifdef REL99 /* +------------------------------------------------------------------------------ | Function : grr_get_time_to_send_poll +------------------------------------------------------------------------------ | Description : This function retrun the duration in milliseconds to transmit a | poll.The basic for the calucation is based on RRBP obtained in | the downlink message. The calculation is mentioned in the function. | Parameters : rrbp | +------------------------------------------------------------------------------ */ GLOBAL T_TIME grr_get_time_to_send_poll(UBYTE rrbp) { /* * This calculation is based on the following calculation * t_ms = (Number of frame to transmit Poll)*(Frame Duration in millseconds) * Number of frame to transmit Poll:- are 13,18,22,26 for rrbp 0,1,2,3 respectively * Frame Duration in millseconds:-is 4.615millseconds * eg . t_ms[0] = 13*4.615 =60, */ T_TIME t_ms[] = {60, 83,102,120}; return (t_ms[rrbp]); } #ifdef TI_PS_FF_EMR /* +------------------------------------------------------------------------------ | Function : grr_init_enh_param +------------------------------------------------------------------------------ | Description : This function is used to initialize ENH parameters | | Parameters : param - pointer to ENH measurement parameter | +------------------------------------------------------------------------------ */ GLOBAL void grr_init_enh_param( T_GRR_ENH_PARA *param, BOOL rep_prio_pres ) { TRACE_FUNCTION( "grr_init_enh_param" ); param->idx = NOT_SET; param->rept_type = REPORT_TYPE_REP; if(rep_prio_pres) { param->gprs_rept_prio_desc.num_cells = 0; } }/* grr_init_enh_param */ /* +------------------------------------------------------------------------------ | Function : grr_init_enh_cell_list +------------------------------------------------------------------------------ | Description : This function is used to initialize ENH cell list | | Parameters : Nil | +------------------------------------------------------------------------------ */ GLOBAL void grr_init_enh_cell_list( void ) { TRACE_FUNCTION( "grr_init_enh_cell_list" ); grr_data->db.cnt_enh_cell_list = 0; grr_data->db.sorted_enh_cell_list.num_valid = 0; }/* grr_init_enh_cell_list */ /* +------------------------------------------------------------------------------ | Function : grr_prcs_enh_param_cw_temp +------------------------------------------------------------------------------ | Description : This function is used to copy the enhanced parameters received | in PSI5. Here it is copied into a temporary storage until all | the instances are properly received. | | Parameters : db_enh - ENH measurement parameter in the GRR database | air_enh - ENH measurement parameter of the air interface | message | new_idx - sequence number of the message | +------------------------------------------------------------------------------ */ GLOBAL void grr_prcs_enh_param_cw_temp ( T_GRR_ENH_PARA *db_enh, T_enh_rep_param_struct *air_enh, UBYTE new_idx ) { UBYTE n; TRACE_FUNCTION( "grr_prcs_enh_param_cw_temp" ); if(db_enh->idx EQ NOT_SET) { /* Store default values for optional enhanced measurement paramaters */ db_enh->ncc_permitted = NCC_PERMITTED_DEFAULT; db_enh->multiband_rep = GRR_MULTIBAND_REPORTING_0; db_enh->servingband_rep = SERVING_BAND_REPORTING_DEFAULT; db_enh->scale_order = SCALE_0dB; for(n = 0; n < MAX_NUM_BANDS; n++) { db_enh->enh_rep_data[n].rep_threshold = REP_THRESHOLD_DEF; db_enh->enh_rep_data[n].rep_offset = REP_OFFSET_0; } } /* Update Enhanced Measurement parameters */ db_enh->rept_type = air_enh->reporting_type; db_enh->rep_rate = air_enh->reporting_rate; db_enh->inv_bsic_enabled = air_enh->invalid_bsic_rep; if( (air_enh->v_ncc_permitted) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->ncc_permitted = air_enh->ncc_permitted; } /* Update GPRS measurement parameters */ if(air_enh->v_gprs_meas_par_report) { if( (air_enh->gprs_meas_par_report.v_multi_band_rep) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->multiband_rep = air_enh->gprs_meas_par_report.multi_band_rep; } if( (air_enh->gprs_meas_par_report.v_serv_cell_rep) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->servingband_rep = air_enh->gprs_meas_par_report.serv_cell_rep; } if( (air_enh->gprs_meas_par_report.v_scale_ord) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->scale_order = air_enh->gprs_meas_par_report.scale_ord; } if( (air_enh->gprs_meas_par_report.v_report_900_grr) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->enh_rep_data[0].rep_threshold = air_enh->gprs_meas_par_report.report_900_grr.rep_thres_900; db_enh->enh_rep_data[0].rep_offset = air_enh->gprs_meas_par_report.report_900_grr.rep_offset_900; } if( (air_enh->gprs_meas_par_report.v_report_1800_grr) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->enh_rep_data[1].rep_threshold = air_enh->gprs_meas_par_report.report_1800_grr.rep_thres_1800; db_enh->enh_rep_data[1].rep_offset = air_enh->gprs_meas_par_report.report_1800_grr.rep_offset_1800; } if( (air_enh->gprs_meas_par_report.v_report_400_grr) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->enh_rep_data[2].rep_threshold = air_enh->gprs_meas_par_report.report_400_grr.rep_thres_400; db_enh->enh_rep_data[2].rep_offset = air_enh->gprs_meas_par_report.report_400_grr.rep_offset_400; } if( (air_enh->gprs_meas_par_report.v_report_1900_grr) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->enh_rep_data[3].rep_threshold = air_enh->gprs_meas_par_report.report_1900_grr.rep_thres_1900; db_enh->enh_rep_data[3].rep_offset = air_enh->gprs_meas_par_report.report_1900_grr.rep_offset_1900; } if( (air_enh->gprs_meas_par_report.v_report_850_grr) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->enh_rep_data[4].rep_threshold = air_enh->gprs_meas_par_report.report_850_grr.rep_thres_850; db_enh->enh_rep_data[4].rep_offset = air_enh->gprs_meas_par_report.report_850_grr.rep_offset_850; } } db_enh->idx = new_idx; }/* grr_prcs_enh_param_cw_temp */ /* +------------------------------------------------------------------------------ | Function : grr_prcs_enh_param_pmo +------------------------------------------------------------------------------ | Description : This function is used to copy temporarily the enhanced | measurement parameters from PMO. | | Parameters : db_enh - ENH measurement parameter in the GRR database | air_enh - ENH measurement parameter of the air interface | message | new_idx - sequence number of the message | +------------------------------------------------------------------------------ */ GLOBAL void grr_prcs_enh_param_pmo ( T_GRR_ENH_PARA *db_enh, T_enh_meas_param_pmo *air_enh, UBYTE new_idx, UBYTE *pmo_ind ) { UBYTE n; UBYTE num_cells = db_enh->gprs_rept_prio_desc.num_cells; UBYTE number_cells = air_enh->gprs_rep_prio_cell_desc.number_cells; TRACE_FUNCTION( "grr_prcs_enh_param_pmo" ); if(db_enh->idx EQ NOT_SET) { /* Store default values for optional enhanced measurement paramaters */ db_enh->ncc_permitted = NCC_PERMITTED_DEFAULT; db_enh->multiband_rep = GRR_MULTIBAND_REPORTING_0; db_enh->servingband_rep = SERVING_BAND_REPORTING_DEFAULT; db_enh->scale_order = SCALE_0dB; for(n = 0; n < MAX_NUM_BANDS; n++) { db_enh->enh_rep_data[n].rep_threshold = REP_THRESHOLD_DEF; db_enh->enh_rep_data[n].rep_offset = REP_OFFSET_0; } for(n = 0; n < MAX_NR_OF_GSM_NC; n++) { db_enh->gprs_rept_prio_desc.rept_prio[n] = NORMAL_PRIO; } } /* Update Enhanced Measurement parameters */ *pmo_ind = air_enh->ba_psi3_str.pmo_ind_used; db_enh->rept_type = air_enh->reporting_type; db_enh->rep_rate = air_enh->reporting_rate; db_enh->inv_bsic_enabled = air_enh->invalid_bsic_rep; /* GPRS Report priority can be received in only one instance since start index is not given for mapping to BA as in RTD and BSIC mapping in SI */ if((air_enh->v_gprs_rep_prio_cell_desc) AND (number_cells NEQ 0)) { if(number_cells > MAX_NR_OF_GSM_NC) { num_cells = MAX_NR_OF_GSM_NC; } else { num_cells = number_cells; } for(n = 0; n < num_cells; n++) { db_enh->gprs_rept_prio_desc.rept_prio[n] = air_enh->gprs_rep_prio_cell_desc.rep_prio[n]; } } /* Update GPRS measurement parameters */ if(air_enh->v_gprs_meas_par_desc_meas) { if( (air_enh->gprs_meas_par_desc_meas.v_multi_band_rep) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->multiband_rep = air_enh->gprs_meas_par_desc_meas.multi_band_rep; } if( (air_enh->gprs_meas_par_desc_meas.v_serv_cell_rep) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->servingband_rep = air_enh->gprs_meas_par_desc_meas.serv_cell_rep; } db_enh->scale_order = air_enh->gprs_meas_par_desc_meas.scale_ord; if( (air_enh->gprs_meas_par_desc_meas.v_report_900_grr) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->enh_rep_data[0].rep_threshold = air_enh->gprs_meas_par_desc_meas.report_900_grr.rep_thres_900; db_enh->enh_rep_data[0].rep_offset = air_enh->gprs_meas_par_desc_meas.report_900_grr.rep_offset_900; } if( (air_enh->gprs_meas_par_desc_meas.v_report_1800_grr) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->enh_rep_data[1].rep_threshold = air_enh->gprs_meas_par_desc_meas.report_1800_grr.rep_thres_1800; db_enh->enh_rep_data[1].rep_offset = air_enh->gprs_meas_par_desc_meas.report_1800_grr.rep_offset_1800; } if( (air_enh->gprs_meas_par_desc_meas.v_report_400_grr) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->enh_rep_data[2].rep_threshold = air_enh->gprs_meas_par_desc_meas.report_400_grr.rep_thres_400; db_enh->enh_rep_data[2].rep_offset = air_enh->gprs_meas_par_desc_meas.report_400_grr.rep_offset_400; } if( (air_enh->gprs_meas_par_desc_meas.v_report_1900_grr) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->enh_rep_data[3].rep_threshold = air_enh->gprs_meas_par_desc_meas.report_1900_grr.rep_thres_1900; db_enh->enh_rep_data[3].rep_offset = air_enh->gprs_meas_par_desc_meas.report_1900_grr.rep_offset_1900; } if( (air_enh->gprs_meas_par_desc_meas.v_report_850_grr) AND ((db_enh->idx EQ NOT_SET) OR (new_idx > db_enh->idx)) ) { db_enh->enh_rep_data[4].rep_threshold = air_enh->gprs_meas_par_desc_meas.report_850_grr.rep_thres_850; db_enh->enh_rep_data[4].rep_offset = air_enh->gprs_meas_par_desc_meas.report_850_grr.rep_offset_850; } } db_enh->idx = new_idx; }/* grr_prcs_enh_param_pmo */ /* +------------------------------------------------------------------------------ | Function : grr_prcs_enh_param_pcco +------------------------------------------------------------------------------ | Description : This function is used to copy the enhanced measurement | parameters from PCCO. | | Parameters : db - Network directed cell database | air_enh - ENH measurement parameter of the air interface | message | +------------------------------------------------------------------------------ */ GLOBAL void grr_prcs_enh_param_pcco ( T_SC_DATABASE *db, T_enh_meas_param_pcco *air_enh ) { UBYTE n; T_GRR_ENH_PARA *db_enh = &db->enh_ms; UBYTE max_num_ncells = db_enh->gprs_rept_prio_desc.num_cells; TRACE_FUNCTION( "grr_prcs_enh_param_pcco" ); if(db_enh->idx EQ NOT_SET) { /* Store default values for optional enhanced measurement paramaters */ db_enh->ncc_permitted = NCC_PERMITTED_DEFAULT; db_enh->multiband_rep = GRR_MULTIBAND_REPORTING_0; db_enh->servingband_rep = SERVING_BAND_REPORTING_DEFAULT; db_enh->scale_order = SCALE_0dB; for(n = 0; n < MAX_NUM_BANDS; n++) { db_enh->enh_rep_data[n].rep_threshold = REP_THRESHOLD_DEF; db_enh->enh_rep_data[n].rep_offset = REP_OFFSET_0; } } /* Update Enhanced Measurement parameters */ db->nc_ms.psi3_cm = air_enh->ba_psi3_str.psi3_cm; db->nc_ms.ba_ind = air_enh->ba_psi3_str.ba_ind_used; db->nc_ms.pmo_ind = air_enh->ba_psi3_str.pmo_ind_used; db_enh->rept_type = air_enh->reporting_type; db_enh->rep_rate = air_enh->reporting_rate; db_enh->inv_bsic_enabled = air_enh->invalid_bsic_rep; if((air_enh->v_gprs_rep_prio_cell_desc) AND (air_enh->gprs_rep_prio_cell_desc.number_cells NEQ 0)) { if(air_enh->gprs_rep_prio_cell_desc.number_cells > MAX_NR_OF_NCELL) { max_num_ncells = MAX_NR_OF_NCELL; } else { max_num_ncells = air_enh->gprs_rep_prio_cell_desc.number_cells; } for(n = 0; n < max_num_ncells; n++) { db_enh->gprs_rept_prio_desc.rept_prio[n] = air_enh->gprs_rep_prio_cell_desc.rep_prio[n]; } } /* Update GPRS measurement parameters */ if(air_enh->v_gprs_meas_par_desc_meas) { if(air_enh->gprs_meas_par_desc_meas.v_multi_band_rep) { db_enh->multiband_rep = air_enh->gprs_meas_par_desc_meas.multi_band_rep; } if(air_enh->gprs_meas_par_desc_meas.v_serv_cell_rep) { db_enh->servingband_rep = air_enh->gprs_meas_par_desc_meas.serv_cell_rep; } db_enh->scale_order = air_enh->gprs_meas_par_desc_meas.scale_ord; if(air_enh->gprs_meas_par_desc_meas.v_report_900_grr) { db_enh->enh_rep_data[0].rep_threshold = air_enh->gprs_meas_par_desc_meas.report_900_grr.rep_thres_900; db_enh->enh_rep_data[0].rep_offset = air_enh->gprs_meas_par_desc_meas.report_900_grr.rep_offset_900; } if(air_enh->gprs_meas_par_desc_meas.v_report_1800_grr) { db_enh->enh_rep_data[1].rep_threshold = air_enh->gprs_meas_par_desc_meas.report_1800_grr.rep_thres_1800; db_enh->enh_rep_data[1].rep_offset = air_enh->gprs_meas_par_desc_meas.report_1800_grr.rep_offset_1800; } if(air_enh->gprs_meas_par_desc_meas.v_report_400_grr) { db_enh->enh_rep_data[2].rep_threshold = air_enh->gprs_meas_par_desc_meas.report_400_grr.rep_thres_400; db_enh->enh_rep_data[2].rep_offset = air_enh->gprs_meas_par_desc_meas.report_400_grr.rep_offset_400; } if(air_enh->gprs_meas_par_desc_meas.v_report_1900_grr) { db_enh->enh_rep_data[3].rep_threshold = air_enh->gprs_meas_par_desc_meas.report_1900_grr.rep_thres_1900; db_enh->enh_rep_data[3].rep_offset = air_enh->gprs_meas_par_desc_meas.report_1900_grr.rep_offset_1900; } if(air_enh->gprs_meas_par_desc_meas.v_report_850_grr) { db_enh->enh_rep_data[4].rep_threshold = air_enh->gprs_meas_par_desc_meas.report_850_grr.rep_thres_850; db_enh->enh_rep_data[4].rep_offset = air_enh->gprs_meas_par_desc_meas.report_850_grr.rep_offset_850; } } db_enh->idx = 0; }/* grr_prcs_enh_param_pcco */ /* +------------------------------------------------------------------------------ | Function : grr_copy_enh_and_nc_params_from_si2qtr +------------------------------------------------------------------------------ | Description : This function is meant to copy the ENH and NC parameters that | are received by SI2 quater, when PBCCH is not present | | Parameters : Pointer to RRGRR_SI2QUATER_IND message contents | +------------------------------------------------------------------------------ */ GLOBAL void grr_copy_enh_and_nc_params_from_si2qtr(T_RRGRR_SI2QUATER_IND *rrgrr_si2quater_ind) { UBYTE n; T_enh_para_struct *enh_para_struct = &(rrgrr_si2quater_ind->enh_para_struct); T_nc_para_struct *nc_para_struct = &(rrgrr_si2quater_ind->nc_para_struct); TRACE_FUNCTION( "grr_copy_enh_nc_params" ); /* Copy Enhanced Measurement parameters only if report type indicates ENH */ if(rrgrr_si2quater_ind->rep_type EQ ENHANCED_MEAS) { /* Copy GSM Neighbour Cell list, if present. Otherwise, only ENH params have changed. Use old NC list and new ENH params */ for(n = 0; n < enh_para_struct->num_valid_cells; n++) { /* Do not include the serving cell in the GSM Neighbour Cell list */ if ( (enh_para_struct->enh_cell_list[n].arfcn EQ psc_db->pbcch.bcch.arfcn) AND (enh_para_struct->enh_cell_list[n].bsic EQ psc_db->pbcch.bcch.bsic) ) { continue; } psc_db->nc_ba_bcch_cw.info[n].index = n; psc_db->nc_ba_bcch_cw.info[n].arfcn = enh_para_struct->enh_cell_list[n].arfcn; psc_db->nc_ba_bcch_cw.info[n].bsic = enh_para_struct->enh_cell_list[n].bsic; psc_db->enh_cw.gprs_rept_prio_desc.rept_prio[n] = enh_para_struct->enh_cell_list[n].rep_priority; } psc_db->nc_ba_bcch_cw.number = n; /* Copy Enhanced Measurement parameters */ psc_db->enh_cw.rept_type = rrgrr_si2quater_ind->rep_type; psc_db->enh_cw.rep_rate = enh_para_struct->rep_rate; psc_db->enh_cw.inv_bsic_enabled = enh_para_struct->inv_bsic_enabled; psc_db->enh_cw.ncc_permitted = enh_para_struct->ncc_permitted; psc_db->enh_cw.multiband_rep = enh_para_struct->multiband_rep; psc_db->enh_cw.servingband_rep = enh_para_struct->servingband_rep; psc_db->enh_cw.scale_order = enh_para_struct->scale_order; for(n = 0; n < MAX_NUM_BANDS; n++) { psc_db->enh_cw.enh_rep_data[n].rep_offset = enh_para_struct->enh_rep_data[n].rep_offset; psc_db->enh_cw.enh_rep_data[n].rep_threshold = enh_para_struct->enh_rep_data[n].rep_threshold; } } /* Copy NC Measurement parameters if received by SI2 quater */ if(nc_para_struct->nco NEQ NC_EMPTY) { T_nc_meas_par nc_meas_par; nc_meas_par.ctrl_order = nc_para_struct->nco; nc_meas_par.v_nc_meas_per = nc_para_struct->is_valid; if(nc_meas_par.v_nc_meas_per) { nc_meas_par.nc_meas_per.non_drx_per = nc_para_struct->nc_non_drx; nc_meas_par.nc_meas_per.rep_per_i = nc_para_struct->nc_rep_per_i; nc_meas_par.nc_meas_per.rep_per_t = nc_para_struct->nc_rep_per_t; } grr_prcs_nc_param_struct ( &psc_db->nc_cw.param, &nc_meas_par, 0 ); } cs_build_nc_ref_list( psc_db, FALSE ); if( psc_db->nc_cw.param.chng_mrk.prev NEQ psc_db->nc_cw.param.chng_mrk.curr ) { if( cs_is_meas_reporting( ) EQ FALSE ) { cs_cancel_meas_report( ); } cs_process_t3158( ); psc_db->nc_cw.param.chng_mrk.prev = psc_db->nc_cw.param.chng_mrk.curr; } } /* grr_copy_enh_and_nc_params_from_si2qtr */ /* +------------------------------------------------------------------------------ | Function : grr_get_psi3_cm +------------------------------------------------------------------------------ | Description : This function returns the value of PSI3 change mark. The PSI3 | change mark is received on PSI3, PSI3 bis and on optional | PSI3 ter message | | Parameters : Nil | +------------------------------------------------------------------------------ */ GLOBAL UBYTE grr_get_psi3_cm(void) { UBYTE psi3_cm = NOT_SET; TRACE_FUNCTION("grr_get_psi3_cm"); if(psc_db->psi3_params.psi3_change_mark EQ psc_db->psi3bis_params.psi3bis_change_mark) { psi3_cm = psc_db->psi3_params.psi3_change_mark; if(psc_db->psi3ter_params.psi3ter_change_mark NEQ NOT_SET AND psc_db->psi3ter_params.psi3ter_change_mark NEQ psi3_cm) { psi3_cm = NOT_SET; } } return(psi3_cm); } /* grr_get_psi3_cm */ /* +------------------------------------------------------------------------------ | Function : grr_init_ba_bcch_nc_list +------------------------------------------------------------------------------ | Description : | | Parameters : list - pointer to NC measurement list | +------------------------------------------------------------------------------ */ GLOBAL void grr_init_ba_bcch_nc_list(T_SC_DATABASE *db) { TRACE_FUNCTION( "grr_init_ba_bcch_nc_list" ); db->nc_ba_bcch_cw.number = 0; db->ba_ind = 0; /* BA-IND of BA-BCCH */ }/* grr_init_ba_bcch_nc_list */ #endif #endif