FreeCalypso > hg > fc-tourmaline
diff src/g23m-gprs/grr/grr_tcf.c @ 1:fa8dc04885d8
src/g23m-*: import from Magnetite
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Fri, 16 Oct 2020 06:25:50 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/g23m-gprs/grr/grr_tcf.c Fri Oct 16 06:25:50 2020 +0000 @@ -0,0 +1,5298 @@ +/* ++----------------------------------------------------------------------------- +| Project : GPRS (8441) +| Modul : GRR ++----------------------------------------------------------------------------- +| Copyright 2002 Texas Instruments Berlin, AG +| All rights reserved. +| +| This file is confidential and a trade secret of Texas +| Instruments Berlin, AG +| The receipt of or possession of this file does not convey +| any rights to reproduce or disclose its contents or to +| manufacture, use, or sell anything it may describe, in +| whole, or in part, without the specific written consent of +| Texas Instruments Berlin, AG. ++----------------------------------------------------------------------------- +| Purpose : This module implements local functions for service TC of +| entity GRR. ++----------------------------------------------------------------------------- +*/ + +#ifndef GRR_TCF_C +#define GRR_TCF_C +#endif + +#define ENTITY_GRR + +/*==== INCLUDES =============================================================*/ + +#include <stdio.h> +#include <string.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 air message definitions */ +#include "grr.h" /* to get the global entity definitions */ + +#include "grr_f.h" /* to get Process GRR global function definitions */ +#include "grr_tcf.h" /* to get Service TC global function definitions */ +#include "grr_tcs.h" /* to get Service TC inter signal definitions */ +#include "grr_ctrls.h" /* to get interface to service CTRL */ +#include "grr_cpaps.h" /* to get interface to service CPAP */ +#include "grr_meass.h" /* to get the definitions for interference measurements */ +#include "cl_rlcmac.h" + +/*==== CONST ================================================================*/ + +typedef enum +{ + GRR_STORE_TYPE_NONE, + GRR_STORE_TYPE_TN_ALLOC_PWR, + GRR_STORE_TYPE_ALF_GAM, + GRR_STORE_TYPE_PWR_PAR +} T_GRR_STORE_TYPE; + +/* + * used in tc_calc_req + * + */ +#define RANDOM_VALUE 0xAAAA + +#define RANDOM_2BIT (RANDOM_VALUE & 0x0003) +#define RANDOM_3BIT (RANDOM_VALUE & 0x0007) +#define RANDOM_5BIT (RANDOM_VALUE & 0x001F) + +#define ONE_PHASE_MASK_11BIT (0x0000 | RANDOM_3BIT ) +#define SHORT_ACCESS_MASK_11BIT (0x0400 | RANDOM_3BIT ) +#define TWO_PHASE_MASK_11BIT (0x0600 | RANDOM_3BIT ) +#define PAGE_RESPONSE_MASK_11BIT (0x0620 | RANDOM_5BIT ) +#define CELL_UPDATE_MASK_11BIT (0x0640 | RANDOM_5BIT ) +#define MM_PROCEDURE_MASK_11BIT (0x0660 | RANDOM_5BIT ) +#define SINGLE_BLOCK_MASK_11BIT (0x0680 | RANDOM_5BIT ) + +#define ONE_PHASE_MASK_8BIT (0x0080 | RANDOM_2BIT ) +#define SHORT_ACCESS_MASK_8BIT (0x0000 | RANDOM_3BIT ) +#define TWO_PHASE_MASK_8BIT (0x0040 | RANDOM_3BIT ) +#define PAGE_RESPONSE_MASK_8BIT (0x0048 | RANDOM_3BIT ) +#define CELL_UPDATE_MASK_8BIT (0x0050 | RANDOM_3BIT ) +#define MM_PROCEDURE_MASK_8BIT (0x0058 | RANDOM_3BIT ) +#define SINGLE_BLOCK_MASK_8BIT (0x0060 | RANDOM_3BIT ) + +/* + * used in tc_handle_ra_con + */ +const UBYTE max_retrans_table[4] = {1,2,4,7}; + +const UBYTE tx_int_table[16] = {2,3,4,5,6,7,8,9,10,12,14,16,20,25,32,50}; + +const UBYTE s_table[16] = {12,15,20,30,41,55,76,109,163,217, + S_VALUE_RESERVED,S_VALUE_RESERVED,S_VALUE_RESERVED, + S_VALUE_RESERVED,S_VALUE_RESERVED,S_VALUE_RESERVED }; + + + +/*==== DIAGNOSTICS ==========================================================*/ + +/*==== LOCAL VARS ===========================================================*/ + + +/*==== PRIVATE FUNCTIONS ====================================================*/ + +LOCAL void tc_set_da_assignment (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i); +LOCAL void tc_set_fa_assignment (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i); +LOCAL void tc_set_dl_assignment (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i); + +LOCAL void tc_close_gaps_in_ctrl_blk_seq( UBYTE index ); + +LOCAL void tc_prepare_send_tbf_release_req( T_TBF_TYPE tbf_type ); + +LOCAL BOOL tc_check_and_save_freq (void); + +LOCAL USHORT grr_convert_11bit_2_etsi ( USHORT eleven_bit ); + +LOCAL USHORT tc_one_phase_mask_11bit (void) +{ +#ifdef _TARGET_ + return (0x0000 | (USHORT)grr_random_value(PCR_RND_INDEX, 8)); +#else + return ONE_PHASE_MASK_11BIT; +#endif +} + +LOCAL SHORT tc_short_access_mask_11bit (void) +{ +#ifdef _TARGET_ + return (0x0400 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) ); +#else + return SHORT_ACCESS_MASK_11BIT; +#endif +} + +LOCAL SHORT tc_two_phase_mask_11bit (void) +{ +#ifdef _TARGET_ + return (0x0600 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) ); +#else + return TWO_PHASE_MASK_11BIT; +#endif +} + +LOCAL SHORT tc_page_response_mask_11bit (void) +{ +#ifdef _TARGET_ + return (0x0620 | (USHORT)grr_random_value(PCR_RND_INDEX, 32) ); +#else + return PAGE_RESPONSE_MASK_11BIT; +#endif +} + +LOCAL SHORT tc_cell_update_mask_11bit (void) +{ +#ifdef _TARGET_ + return (0x0640 | (USHORT)grr_random_value(PCR_RND_INDEX, 32) ); +#else + return CELL_UPDATE_MASK_11BIT; +#endif +} + +LOCAL SHORT tc_mm_procedure_mask_11bit (void) +{ +#ifdef _TARGET_ + return (0x0660 |(USHORT)grr_random_value(PCR_RND_INDEX, 32) ); +#else + return MM_PROCEDURE_MASK_11BIT; +#endif +} + +LOCAL SHORT tc_single_block_mask_11bit (void) +{ +#ifdef _TARGET_ + return (0x0680 | (USHORT)grr_random_value(PCR_RND_INDEX, 32) ); +#else + return SINGLE_BLOCK_MASK_11BIT; +#endif +} + +LOCAL SHORT tc_one_phase_mask_8bit (void) +{ +#ifdef _TARGET_ + return (0x0080 | (USHORT)grr_random_value(PCR_RND_INDEX, 4) ); +#else + return ONE_PHASE_MASK_8BIT; +#endif +} + +LOCAL SHORT tc_short_access_mask_8bit (void) +{ +#ifdef _TARGET_ + return (0x0000 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) ); +#else + return SHORT_ACCESS_MASK_8BIT; +#endif +} + +LOCAL SHORT tc_two_phase_mask_8bit (void) +{ +#ifdef _TARGET_ + return (0x0040 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) ); +#else + return TWO_PHASE_MASK_8BIT; +#endif +} + +LOCAL SHORT tc_page_response_mask_8bit (void) +{ +#ifdef _TARGET_ + return (0x0048 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) ); +#else + return PAGE_RESPONSE_MASK_8BIT; +#endif +} + +LOCAL SHORT tc_cell_update_mask_8bit (void) +{ +#ifdef _TARGET_ + return (0x0050 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) ); +#else + return CELL_UPDATE_MASK_8BIT; +#endif +} + +LOCAL SHORT tc_mm_procedure_mask_8bit (void) +{ +#ifdef _TARGET_ + return (0x0058 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) ); +#else + return MM_PROCEDURE_MASK_8BIT; +#endif +} +LOCAL SHORT tc_single_block_mask_8bit (void) +{ +#ifdef _TARGET_ + return (0x0060 | (USHORT)grr_random_value(PCR_RND_INDEX, 8) ); +#else + return SINGLE_BLOCK_MASK_8BIT; +#endif +} + +/* ++------------------------------------------------------------------------------ +| Function : tc_set_hopping_par ++------------------------------------------------------------------------------ +| Description : This function handles the frequency parameters in a ul or dl +| assignment or ts reconfigure. +| +| Parameters : ptr2prim - pointer to the MPHP_ASSIGNMENT_REQ prim +| that has to be set up. +| freq_par - pointer to the received frequency parameter struct. +| ++------------------------------------------------------------------------------ +*/ +GLOBAL BOOL tc_set_hopping_par ( T_freq_par *freq_par ) +{ + BOOL result = FALSE; + T_p_frequency_par frequency_par; + + TRACE_FUNCTION( "tc_set_hopping_par" ); + + memset( &frequency_par, 0, sizeof( frequency_par ) ); + + if(freq_par->v_indi_encod) + { + result = grr_validate_ma_num_in_freq_par(freq_par,GRR_FREQ_PARAM_RECEIVED_IN_ASSIGNMENT); + + if(result) + { + result = grr_create_freq_list( freq_par->indi_encod.ma_num, + freq_par->indi_encod.maio, + &frequency_par.p_chan_sel, + &frequency_par.p_freq_list ); + } + else + { + TRACE_ERROR("error creating frequency list"); + result = FALSE; + } + + } /* if(freq_par->v_indi_encod) */ + else if(freq_par->v_di_encod1) + { + memcpy(&psc_db->gprs_ms_alloc_in_assignment.gprs_ms_alloc_ie, + &freq_par->di_encod1.gprs_ms_alloc_ie, sizeof(T_gprs_ms_alloc_ie)); + + psc_db->gprs_ms_alloc_in_assignment.ma_num = MA_NUMBER_4_ASSIGNMENT; + psc_db->rfl[MAX_RFL].num = NOT_SET; + + result = grr_create_freq_list( psc_db->gprs_ms_alloc_in_assignment.ma_num, + freq_par->di_encod1.maio, + &frequency_par.p_chan_sel, + &frequency_par.p_freq_list ); + } /* if(freq_par->v_di_encod1) */ + else if(freq_par->v_di_encod2) + { + /* + * processing of T_freq_par from assignment and non-assignment messages + * when direct encoding 2 is used, should be done in same object module as + * this involvs use of static array variables which are local to the + * object module they are used in(_local_dummy_list and _local_rfl_contents. + * Hence processing for both assignment and non-assignement messages is done + * in grr_f.c. If they are put in different files, we will have to duplicate + * the static arrays. + */ + result = + grr_cnv_freq_para_in_assignment_direct_enc_2(&frequency_par,freq_par); + + } /* if(freq_par->v_di_encod2) */ + else + { + TRACE_ERROR("FATAL ERROR: no frequency params in ul assignment!"); + } + + if( result EQ TRUE ) + { + grr_data->tc.freq_set.freq_par = frequency_par; + grr_data->tc.freq_set.tsc = freq_par->tsc; + } + + grr_data->tc.v_freq_set = result; + + return ( result ); +}/* tc_set_hopping_par */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_get_send_nb_prim_and_set_freq ++------------------------------------------------------------------------------ +| Description : This function allocates a primitve depending on the hopping status +| and sets the frequency parameter of T_MPHP_SINGLE_BLOCK_REQ +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +LOCAL T_MPHP_SINGLE_BLOCK_REQ * tc_get_send_nb_prim_and_set_freq ( void ) +{ + PALLOC( mphp_single_block_req, MPHP_SINGLE_BLOCK_REQ ); + + TRACE_FUNCTION( "tc_get_send_nb_prim_and_set_freq" ); + + memset( mphp_single_block_req, 0, sizeof( T_MPHP_SINGLE_BLOCK_REQ ) ); + + mphp_single_block_req->tsc = grr_data->tc.freq_set.tsc; + + grr_set_freq_par( &mphp_single_block_req->p_frequency_par ); + + return( mphp_single_block_req ); +}/* tc_get_send_nb_prim_and_set_freq */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_check_and_save_freq ++------------------------------------------------------------------------------ +| Description : This function check if the freq_par is valid or not.. +| If it is hopping case, save the hoppinging freq. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +LOCAL BOOL tc_check_and_save_freq (void) +{ + MCAST(d_dl_assign,D_DL_ASSIGN); /* T_D_DL_ASSIGN T_D_UL_ASSIGN T_D_TS_RECONFIG */ + MCAST(d_ul_assign,D_UL_ASSIGN); + MCAST(d_ts_reconfig,D_TS_RECONFIG); + + BOOL result = FALSE; + T_freq_par *freq_par = NULL; + BOOL mode_check = FALSE; + + TRACE_FUNCTION( "tc_check_and_save_freq" ); + + /* + * store frequeny parameters, if present. + * If not present, take from data base + */ + switch(d_dl_assign->msg_type) + { + case D_DL_ASSIGN: /* T_D_DL_ASSIGN */ + if(d_dl_assign->pda_trnc_grp.v_freq_par) + { /* replace possibly earlier stored freq params */ + freq_par = &d_dl_assign->pda_trnc_grp.freq_par; + } + if((grr_data->tbf_type EQ CGRLC_TBF_MODE_UL) OR (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL) ) + { + mode_check = TRUE; + } + break; + case D_UL_ASSIGN: /* T_D_UL_ASSIGN */ + if(d_ul_assign->v_freq_par) + { /* replace possibly earlier stored freq params */ + freq_par = &d_ul_assign->freq_par; + } + if((grr_data->tbf_type EQ CGRLC_TBF_MODE_DL) OR (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL)) + { + mode_check = TRUE; + } + + break; + case D_TS_RECONFIG: /* T_D_TS_RECONFIG */ + if(d_ts_reconfig->v_freq_par) + { /* replace possibly earlier stored freq params */ + freq_par = &d_ts_reconfig->freq_par; + } + break; + case D_UL_ACK: /* T_D_UL_ACK */ + break; + default: + TRACE_ERROR ( "Wrong message type in _decodedMsg" ); + break; + + } + /* If frequency parameter element present, assigns frequency parameters to the + uplink TBF. If this information element is not present the mobile station + shall use its previously assigned frequency parameters.*/ + + if( freq_par )/* save the hopping frequency */ + { + if(freq_par->v_arfcn) /*static*/ + { + T_FREQ_SET temp_freq_set; + temp_freq_set.freq_par.p_chan_sel.hopping = FALSE; + temp_freq_set.tsc = freq_par->tsc; + temp_freq_set.freq_par.p_chan_sel.p_rf_ch.arfcn = grr_g23_arfcn_to_l1(freq_par->arfcn); + + /* variable needed by hopping case must be reset.*/ + memset(&(temp_freq_set.freq_par.p_freq_list.p_rf_chan_no.p_radio_freq), 0, sizeof(temp_freq_set.freq_par.p_freq_list.p_rf_chan_no.p_radio_freq)); + temp_freq_set.freq_par.p_freq_list.p_rf_chan_cnt = 0; + + if ( mode_check EQ TRUE ) + { + /* checking the params already exist or not */ + if ( ( grr_data->tc.freq_set.freq_par.p_chan_sel.hopping EQ FALSE) + AND (temp_freq_set.tsc EQ grr_data->tc.freq_set.tsc) + AND ( temp_freq_set.freq_par.p_chan_sel.p_rf_ch.arfcn EQ + grr_data->tc.freq_set.freq_par.p_chan_sel.p_rf_ch.arfcn ) ) + { + TRACE_EVENT ("Frequency parameters are same"); + result = TRUE; + } + else + { + TRACE_EVENT ("Frequency parameters are changed, So discard it"); + result = FALSE; + } + } + else + { + /* If it is new entry, storing in the grr_data */ + result = TRUE; + grr_data->tc.v_freq_set = TRUE; + grr_data->tc.freq_set = temp_freq_set; + } + } + else + { /* hopping cases */ + result = tc_set_hopping_par( freq_par ); + } + } + else if ( grr_data->tc.v_freq_set )/* if it is a two phase assignment or there is already another TBF running*/ + { + result = TRUE; + } + else + { + result = FALSE; + TRACE_ERROR("FATAL ERROR: no freq params in assignment but needed!"); + } + + if(result EQ TRUE) + { + grr_data->pwr_ctrl_valid_flags.v_glbl_pwr_ctrl_param = TRUE; + grr_data->pwr_ctrl_valid_flags.v_freq_param = TRUE; + } + + return(result); + +}/* tc_check_and_save_freq */ + + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_set_da_assignment ++------------------------------------------------------------------------------ +| Description : This function sets some parameter of T_MPHP_ASSIGNMENT_REQ is +| case of uplink dynamic allocation. +| +| Parameters : ptr2prim_i - ptr to MPHP_ASSIGNMENT_REQ +| ++------------------------------------------------------------------------------ +*/ +LOCAL void tc_set_da_assignment (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i) +{ + MCAST(d_ul_assign,D_UL_ASSIGN);/* T_D_UL_ASSIGN */ + MCAST(d_ts_reconfig,D_TS_RECONFIG); + + TRACE_FUNCTION( "tc_set_da_assignment" ); + + if( d_ul_assign->msg_type EQ D_UL_ASSIGN_c) + { + + /* + * timing advance + */ + grr_handle_ta ( d_ul_assign->pta.v_ta_value, + d_ul_assign->pta.ta_value, + d_ul_assign->pta.v_ta_index_tn, + d_ul_assign->pta.ta_index_tn.ta_index, + d_ul_assign->pta.ta_index_tn.ta_tn, + 0xFF, + 0, + 0, + &ptr2prim_i->p_timing_advance); + + /* bts output power control */ + if(d_ul_assign->dyn_alloc_p.v_p0) + { + ptr2prim_i->p_dl_power.p0 = d_ul_assign->dyn_alloc_p.p0; + ptr2prim_i->p_dl_power.pr_mode = d_ul_assign->dyn_alloc_p.pr_mode; + /* dynamic allocation must use mode a */ + ptr2prim_i->p_dl_power.bts_pwr_ctl_mode = MODE_A; + } + else + { + ptr2prim_i->p_dl_power.p0 = 0xff; /* 0xff -> invalid value */ + /* -> pr_mode and bts_pwr_ctl_mode don't care */ + } + + /* + * TBF starting time + */ + if(d_ul_assign->dyn_alloc_p.v_tbf_s_time) + { + ptr2prim_i->p_tbf_start.tbf_start_present = 1; + if(d_ul_assign->dyn_alloc_p.tbf_s_time.v_abs) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ul_assign->dyn_alloc_p.tbf_s_time.abs); + } + else if (d_ul_assign->dyn_alloc_p.tbf_s_time.v_rel) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn, + d_ul_assign->dyn_alloc_p.tbf_s_time.rel); + } + else + { /* this shall never happen */ + ptr2prim_i->p_tbf_start.fn = grr_data->dl_fn; + TRACE_ERROR("UL v_start_tbf but either rel nor abs tbf included"); + } + } + else if(grr_data->l1_del_tbf_start_fn NEQ GRR_INVALID_FN) + { + ptr2prim_i->p_tbf_start.tbf_start_present = 1; + ptr2prim_i->p_tbf_start.fn = grr_data->l1_del_tbf_start_fn; + } + else + { + ptr2prim_i->p_tbf_start.tbf_start_present = 0; + } + + /* + * mac mode + */ + if (d_ul_assign->dyn_alloc_p.xdyn_alloc) + { + ptr2prim_i->mac_mode = EDA; + } + else + { + ptr2prim_i->mac_mode = DA; + } + + /* + * uplink allocation structure + */ + if(d_ul_assign->dyn_alloc_p.v_ul_tfi_assign) + { + ptr2prim_i->p_ul_alloc.ul_tfi = d_ul_assign->dyn_alloc_p.ul_tfi_assign; + } + else + { + ptr2prim_i->p_ul_alloc.ul_tfi = grr_data->uplink_tbf.tfi; + } + ptr2prim_i->p_ul_alloc.ts_mask = grr_data->uplink_tbf.ts_usage; + + + /* + * dynamic allocation structure + */ + ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_gran = + d_ul_assign->dyn_alloc_p.usf_grant; + + if(d_ul_assign->dyn_alloc_p.v_tn_alloc EQ 1) + { + UBYTE i; + for(i = 0;i < 8;i++) + { + if(d_ul_assign->dyn_alloc_p.tn_alloc[i].v_usf) + { + ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[i] = + d_ul_assign->dyn_alloc_p.tn_alloc[i].usf; + } + } + } + else if (d_ul_assign->dyn_alloc_p.v_tn_alloc_pwr) + { + UBYTE i; + + for(i = 0;i < 8;i++) + { + if(d_ul_assign->dyn_alloc_p.tn_alloc_pwr.usf_array[i].v_usf_g) + { + ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[i] = + d_ul_assign->dyn_alloc_p.tn_alloc_pwr.usf_array[i].usf_g.usf; + } + } + + grr_store_type_tn_alloc_pwr( &d_ul_assign->dyn_alloc_p.tn_alloc_pwr ); + } + else + { + ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[0] = 5; + TRACE_EVENT("USF-Error: set (hardcoded) USF_TN0 = 0x05"); + } + + } + else if ( d_ts_reconfig->msg_type EQ D_TS_RECONFIG_c) + { + /* + * timing advance is handled in tc_set_dl_assignment + */ + /* grr_handle_ta ( d_ts_reconfig->gpta.v_ta_value, + d_ts_reconfig->gpta.ta_value, + d_ts_reconfig->gpta.v_ul_ta_index, + d_ts_reconfig->gpta.ul_ta_index, + d_ts_reconfig->gpta.ul_ta_tn, + 0, + 0, + 0, + ptr2prim_i->p_timing_advance); + + */ + /* bts output power control */ + if(d_ts_reconfig->dyn_alloc_ts.v_p0) + { + ptr2prim_i->p_dl_power.p0 = d_ts_reconfig->dyn_alloc_ts.p0; + ptr2prim_i->p_dl_power.pr_mode = d_ts_reconfig->dyn_alloc_ts.pr_mode; + /* dynamic allocation must use mode a */ + ptr2prim_i->p_dl_power.bts_pwr_ctl_mode = MODE_A; + } + else + { + ptr2prim_i->p_dl_power.p0 = 0xff; /* 0xff -> invalid value */ + /* -> pr_mode and bts_pwr_ctl_mode don't care */ + } + + /* + * TBF starting time + */ + if(d_ts_reconfig->dyn_alloc_ts.v_tbf_s_time) + { + ptr2prim_i->p_tbf_start.tbf_start_present= 1; + if(d_ts_reconfig->dyn_alloc_ts.tbf_s_time.v_abs) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ts_reconfig->dyn_alloc_ts.tbf_s_time.abs); + } + else if (d_ts_reconfig->dyn_alloc_ts.tbf_s_time.v_rel) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn, + d_ts_reconfig->dyn_alloc_ts.tbf_s_time.rel); + } + else + { /* this shall never happen */ + ptr2prim_i->p_tbf_start.fn = grr_data->dl_fn%FN_MAX; + TRACE_ERROR("TS RECON UL v_start_tbf but either rel nor abs tbf included"); + } + } + else if(grr_data->l1_del_tbf_start_fn NEQ GRR_INVALID_FN) + { + ptr2prim_i->p_tbf_start.tbf_start_present = 1; + ptr2prim_i->p_tbf_start.fn = grr_data->l1_del_tbf_start_fn; + } + else + { + ptr2prim_i->p_tbf_start.tbf_start_present = 0; + } + + + /* + * mac mode + */ + if (d_ts_reconfig->dyn_alloc_ts.xdyn_alloc) + { + ptr2prim_i->mac_mode = EDA; + } + else + { + ptr2prim_i->mac_mode = DA; + } + + /* + * uplink allocation structure + */ + if(d_ts_reconfig->v_ul_tfi) + { + ptr2prim_i->p_ul_alloc.ul_tfi = d_ts_reconfig->ul_tfi; + } + else + { + ptr2prim_i->p_ul_alloc.ul_tfi = grr_data->uplink_tbf.tfi; + } + ptr2prim_i->p_ul_alloc.ts_mask = grr_data->uplink_tbf.ts_usage; + + + /* + * dynamic allocation structure + */ + ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_gran = d_ts_reconfig->dyn_alloc_ts.usf_grant; + + if(d_ts_reconfig->dyn_alloc_ts.v_tn_alloc EQ 1) + { + UBYTE i; + for(i = 0;i < 8;i++) + { + if(d_ts_reconfig->dyn_alloc_ts.tn_alloc[i].v_usf) + { + ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[i] = + d_ts_reconfig->dyn_alloc_ts.tn_alloc[i].usf; + } + } + } + else if (d_ts_reconfig->dyn_alloc_ts.v_tn_alloc_pwr) + { + UBYTE i; + + for(i = 0;i < 8;i++) + { + if(d_ts_reconfig->dyn_alloc_ts.tn_alloc_pwr.usf_array[i].v_usf_g) + { + ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[i] = + d_ts_reconfig->dyn_alloc_ts.tn_alloc_pwr.usf_array[i].usf_g.usf; + } + } + + grr_store_type_tn_alloc_pwr( &d_ts_reconfig->dyn_alloc_ts.tn_alloc_pwr ); + } + else + { + ptr2prim_i->p_ul_alloc.p_dynamic_alloc.usf_table[0] = 5; + TRACE_EVENT("USF-Error: set (hardcoded) USF_TN0 = 0x05"); + } + } + else + { + TRACE_ERROR ( "Wrong message type in _decodedCtrlMsg" ); + } + + if(ptr2prim_i->p_tbf_start.tbf_start_present) + grr_data->uplink_tbf.tbf_start_fn = ptr2prim_i->p_tbf_start.fn; + else + grr_data->uplink_tbf.tbf_start_fn = CGRLC_STARTING_TIME_NOT_PRESENT; + + grr_data->uplink_tbf.st_tfi = ptr2prim_i->p_ul_alloc.ul_tfi; + + + + return; +}/*tc_set_da_assignment*/ + + +/* ++------------------------------------------------------------------------------ +| Function : tc_calc_fa_bitmap ++------------------------------------------------------------------------------ +| Description : This function calculates rhe allocation bitmap in +| case of fixed allocation +| +| Parameters : blks_or_blkps - indicates if blocks(0) or block periods(1) is used +| len - len of the allocation bitmap +| ptr2_alloc_map - ptr to the allocation bitmap array +| ptr2_fix_alloc - ptr to the fixed allocation struct +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_calc_fa_bitmap (ULONG tbf_start, + UBYTE blks_or_blkps, + USHORT len, + UBYTE * ptr2_alloc_map, + T_p_fixed_alloc * ptr2_fix_alloc) +{ + UBYTE i; + UBYTE help; + UBYTE tn[8]; + UBYTE x,y; + UBYTE len_1; + USHORT index; + + TRACE_FUNCTION( "tc_calc_fa_bitmap" ); + +/* + TRACE_EVENT_P9("FA bitmap: start_fn=%ld, blk=%d len=%ld bitmap: %d %d %d %d %d %d", + tbf_start, + blks_or_blkps, + len, + ptr2_alloc_map[0], + ptr2_alloc_map[1], + ptr2_alloc_map[2], + ptr2_alloc_map[3], + ptr2_alloc_map[4], + ptr2_alloc_map[5]); + + TRACE_EVENT_P9("%d %d %d %d %d %d %d %d %d", + ptr2_alloc_map[6], + ptr2_alloc_map[7], + ptr2_alloc_map[8], + ptr2_alloc_map[9], + ptr2_alloc_map[10], + ptr2_alloc_map[11], + ptr2_alloc_map[12], + ptr2_alloc_map[13], + ptr2_alloc_map[14]); + + TRACE_EVENT_P9("%d %d %d %d %d %d %d %d %d", + ptr2_alloc_map[15], + ptr2_alloc_map[16], + ptr2_alloc_map[17], + ptr2_alloc_map[18], + ptr2_alloc_map[19], + ptr2_alloc_map[20], + ptr2_alloc_map[21], + ptr2_alloc_map[22], + ptr2_alloc_map[23]); + TRACE_EVENT_P9("%d %d %d %d %d %d %d %d %d", + ptr2_alloc_map[24], + ptr2_alloc_map[25], + ptr2_alloc_map[26], + ptr2_alloc_map[27], + ptr2_alloc_map[28], + ptr2_alloc_map[29], + ptr2_alloc_map[30], + ptr2_alloc_map[31], + ptr2_alloc_map[32]); +*/ + memset( tn, 0, sizeof(tn) ); + + if(blks_or_blkps) + { + /* + * block periods are used + */ + for(i=0;i<len;i++) + { + if(ptr2_alloc_map[i]) + { + ptr2_fix_alloc->bitmap[i] = grr_data->uplink_tbf.ts_usage; + } + else + ptr2_fix_alloc->bitmap[i] = 0; + } + ptr2_fix_alloc->size_bitmap = (UBYTE)len; + } + else + { + UBYTE L; + /* + * blocks are used + */ + /* + * determinate the timeslot positions + */ + help = grr_data->uplink_tbf.ts_usage; + index = 0; + for(i=0;i<=7;i++) + { + if(help >= (0x80 >> i)) + { + tn[index]=i; + index++; + help -= (0x80 >> i); + } + } + memset(ptr2_fix_alloc->bitmap,0,sizeof(ptr2_fix_alloc->bitmap)); + L = len - 1; + for(i=0;i<=L;i++) + { + if(ptr2_alloc_map[i]) + { + x = i / grr_data->uplink_tbf.nts; + y = i % grr_data->uplink_tbf.nts; + ptr2_fix_alloc->bitmap[x] |= 0x80 >> tn[y]; + } + } + ptr2_fix_alloc->size_bitmap = (UBYTE)len / grr_data->uplink_tbf.nts; + } + /* + * set fa_ctrl + */ + + + grr_data->tc.fa_ctrl.fa_type = FA_BITMAP; + + + grr_data->tc.fa_ctrl.current_alloc.alloc_start_fn = tbf_start; + + /* store end of fixed allocation */ + len_1 = ptr2_fix_alloc->size_bitmap - 1; + grr_data->tc.fa_ctrl.current_alloc.alloc_end_fn = + grr_decode_tbf_start_rel(grr_data->tc.fa_ctrl.current_alloc.alloc_start_fn,(USHORT)(len_1-1)); + + memcpy( &grr_data->tc.fa_ctrl.current_alloc.alloc, + ptr2_fix_alloc, + sizeof(T_p_fixed_alloc)); + + /* TRACE_EVENT_P9("L1 bitmap %d %d %d %d %d %d %d %d %d", + ptr2_fix_alloc->bitmap[0], + ptr2_fix_alloc->bitmap[1], + ptr2_fix_alloc->bitmap[2], + ptr2_fix_alloc->bitmap[3], + ptr2_fix_alloc->bitmap[4], + ptr2_fix_alloc->bitmap[5], + ptr2_fix_alloc->bitmap[6], + ptr2_fix_alloc->bitmap[7], + ptr2_fix_alloc->bitmap[8]); + + TRACE_EVENT_P9("%d %d %d %d %d %d %d %d %d", + ptr2_fix_alloc->bitmap[9], + ptr2_fix_alloc->bitmap[10], + ptr2_fix_alloc->bitmap[11], + ptr2_fix_alloc->bitmap[12], + ptr2_fix_alloc->bitmap[13], + ptr2_fix_alloc->bitmap[14], + ptr2_fix_alloc->bitmap[15], + ptr2_fix_alloc->bitmap[16], + ptr2_fix_alloc->bitmap[17]); + TRACE_EVENT_P9("%d %d %d %d %d %d %d %d %d", + ptr2_fix_alloc->bitmap[18], + ptr2_fix_alloc->bitmap[19], + ptr2_fix_alloc->bitmap[20], + ptr2_fix_alloc->bitmap[21], + ptr2_fix_alloc->bitmap[22], + ptr2_fix_alloc->bitmap[23], + ptr2_fix_alloc->bitmap[24], + ptr2_fix_alloc->bitmap[25], + ptr2_fix_alloc->bitmap[26]); +*/ +} /* tc_calc_fa_bitmap() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_handle_final_alloc ++------------------------------------------------------------------------------ +| Description : This function handles the final allocation bit. +| +| Parameters : - +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_handle_final_alloc (UBYTE final_allocation) +{ + + TRACE_FUNCTION( "tc_handle_final_alloc" ); + + + +} /* tc_handle_final_alloc() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_set_fa_assignment ++------------------------------------------------------------------------------ +| Description : This function sets some parameter of T_MPHP_ASSIGNMENT_REQ is +| case of fixed allocation +| +| Parameters : ptr2prim_i - ptr to MPHP_ASSIGNMENT_REQ +| ++------------------------------------------------------------------------------ +*/ +LOCAL void tc_set_fa_assignment (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i) +{ +/* ULONG var; */ + MCAST(d_ul_assign,D_UL_ASSIGN); /* T_D_UL_ASSIGN */ + MCAST(d_ts_reconfig,D_TS_RECONFIG); /* T_TS_RECONFIG */ + MCAST(d_ul_ack,D_UL_ACK); /* T_D_UL_ACK */ + + + + + TRACE_FUNCTION( "tc_set_fa_assignment" ); + +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + if((d_ul_assign->msg_type EQ D_UL_ASSIGN_c) AND + (ptr2prim_i->assign_cmd EQ UL_TP_ACCESS)) + { + /* training sequence code */ + ptr2prim_i->tsc = d_ul_assign->freq_par.tsc; + + /* handle timing advance */ + grr_handle_ta ( d_ul_assign->pta.v_ta_value, + d_ul_assign->pta.ta_value, + d_ul_assign->pta.v_ta_index_tn, + d_ul_assign->pta.ta_index_tn.ta_index, + d_ul_assign->pta.ta_index_tn.ta_tn, + 0xFF, + 0, + 0, + &ptr2prim_i->p_timing_advance); + + /* Mac mode */ + ptr2prim_i->mac_mode = FA; + + /* Handle single block allocation */ + if(d_ul_assign->v_sin_alloc EQ TRUE ) + { + /* timeslot mask */ + ptr2prim_i->p_ul_alloc.ts_mask = 0x80>>d_ul_assign->sin_alloc.tn; + + /* PO, BTS_POWER_MODE and PR_ MODE */ + if(d_ul_assign->sin_alloc.v_bts_pwr_ctrl EQ TRUE ) + { + ptr2prim_i->p_dl_power.p0 = + d_ul_assign->sin_alloc.bts_pwr_ctrl.p0; + + ptr2prim_i->p_dl_power.bts_pwr_ctl_mode = + d_ul_assign->sin_alloc.bts_pwr_ctrl.mode; + + ptr2prim_i->p_dl_power.pr_mode = + d_ul_assign->sin_alloc.bts_pwr_ctrl.pr_mode; + } + else + { + ptr2prim_i->p_dl_power.p0 = 0xff; + } + + /* Downlink Control Timeslot */ + ptr2prim_i->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = d_ul_assign->sin_alloc.tn; + + /* + * handle TBF starting time + * is always present in single block allocation + */ + if(d_ul_assign->sin_alloc.tbf_s_time.v_abs) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ul_assign->sin_alloc.tbf_s_time.abs); + if(!grr_check_if_tbf_start_is_elapsed ( ptr2prim_i->p_tbf_start.fn, grr_data->ul_fn)) + { + /*Allocated Number of time slots are 1 */ + ptr2prim_i->p_ul_alloc.p_fixed_alloc.size_bitmap = 1; + ptr2prim_i->p_tbf_start.tbf_start_present=TRUE; + ptr2prim_i->p_ul_alloc.p_fixed_alloc.bitmap[0] = 0x80 >> d_ul_assign->sin_alloc.tn; + } + else + { + TRACE_ERROR("TBF Starting time is ELAPSED in single block allocation!"); + } + } + else if (d_ul_assign->sin_alloc.tbf_s_time.v_rel) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn, + (USHORT)(d_ul_assign->sin_alloc.tbf_s_time.rel)); + if(!grr_check_if_tbf_start_is_elapsed ( ptr2prim_i->p_tbf_start.fn, grr_data->ul_fn)) + { + /*Allocated Number of time slots are 1 */ + ptr2prim_i->p_ul_alloc.p_fixed_alloc.size_bitmap = 1; + ptr2prim_i->p_tbf_start.tbf_start_present=TRUE; + ptr2prim_i->p_ul_alloc.p_fixed_alloc.bitmap[0] = 0x80 >> d_ul_assign->sin_alloc.tn; + } + else + { + TRACE_ERROR("TBF Starting time is ELAPSED in single block allocation!"); + } + } + }/* single block */ + } + else +#endif + if( d_ul_assign->msg_type EQ D_UL_ASSIGN_c) + { + /* + * timing advance + */ + + grr_handle_ta ( d_ul_assign->pta.v_ta_value, + d_ul_assign->pta.ta_value, + d_ul_assign->pta.v_ta_index_tn, + d_ul_assign->pta.ta_index_tn.ta_index, + d_ul_assign->pta.ta_index_tn.ta_tn, + 0xFF, + 0, + 0, + &ptr2prim_i->p_timing_advance); + + if(d_ul_assign->f_alloc_ul.v_bts_pwr_ctrl) + { + ptr2prim_i->p_dl_power.p0 = d_ul_assign->f_alloc_ul.bts_pwr_ctrl.p0; + ptr2prim_i->p_dl_power.bts_pwr_ctl_mode = + d_ul_assign->f_alloc_ul.bts_pwr_ctrl.mode; + ptr2prim_i->p_dl_power.pr_mode = + d_ul_assign->f_alloc_ul.bts_pwr_ctrl.pr_mode; + } + else + { + ptr2prim_i->p_dl_power.p0 = 0xff; + } + + /* + * mac mode + */ + ptr2prim_i->mac_mode = FA; + /* + * uplink allocation structure + */ + if(d_ul_assign->f_alloc_ul.v_ul_tfi_assign) + { + ptr2prim_i->p_ul_alloc.ul_tfi = d_ul_assign->f_alloc_ul.ul_tfi_assign; + } + else + { + ptr2prim_i->p_ul_alloc.ul_tfi = grr_data->uplink_tbf.tfi; + } + ptr2prim_i->p_ul_alloc.ts_mask = grr_data->uplink_tbf.ts_usage; + /* + * fixed allocation structure + * half duplex mode is ignored, only valid for MS class 19 to 29 + */ + + /* + * TBF STARTING TIME for fixed allocation structure + */ + if(d_ul_assign->f_alloc_ul.tbf_s_time.v_abs) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ul_assign->f_alloc_ul.tbf_s_time.abs); + } + else if (d_ul_assign->f_alloc_ul.tbf_s_time.v_rel) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn, + d_ul_assign->f_alloc_ul.tbf_s_time.rel); + } + else + { /* this shall never happen */ + ptr2prim_i->p_tbf_start.fn = (grr_data->dl_fn+13)%FN_MAX; + TRACE_ERROR("NO STARTING TIME IN FIXED ALLOCATION!!"); + } + ptr2prim_i->p_tbf_start.tbf_start_present = 1; + /* + * Downlink Control Timeslot + */ + ptr2prim_i->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = d_ul_assign->f_alloc_ul.dl_ctrl_ts; + grr_data->tc.fa_ctrl.dl_ctrl_ts = d_ul_assign->f_alloc_ul.dl_ctrl_ts; + /* + * ALLOCATION BITMAP + */ + if(d_ul_assign->f_alloc_ul.v_block_struct) + { + tc_calc_fa_bitmap(ptr2prim_i->p_tbf_start.fn, /*starting time of cuurent tbf*/ + d_ul_assign->f_alloc_ul.block_struct.bl_o_bl_per,/* blocks or block periods*/ + d_ul_assign->f_alloc_ul.block_struct.a_map_len, /* bitmap length*/ + d_ul_assign->f_alloc_ul.block_struct.alloc_map, /* ptr to alloc struct*/ + &ptr2prim_i->p_ul_alloc.p_fixed_alloc); /* ptr to fix sttruct*/ + } + else if(d_ul_assign->f_alloc_ul.v_alloc_map) + { + tc_calc_fa_bitmap(ptr2prim_i->p_tbf_start.fn, /*starting time of cuurent tbf*/ + 0, /* blocks : default*/ + d_ul_assign->f_alloc_ul.c_alloc_map, /* bitmap length*/ + d_ul_assign->f_alloc_ul.alloc_map, /* ptr to alloc struct*/ + &ptr2prim_i->p_ul_alloc.p_fixed_alloc); /* ptr to fix sttruct*/ + } + /* + * check final allocation + */ + grr_data->tc.fa_ctrl.current_alloc.final_alloc = d_ul_assign->f_alloc_ul.final_alloc; + } + else if ( d_ts_reconfig->msg_type EQ D_TS_RECONFIG_c) + { + /* + * timing advance is handled in tc_set_dl_assignment + */ + + if(d_ts_reconfig->f_alloc_re.v_bts_pwr_ctrl) + { + ptr2prim_i->p_dl_power.p0 = d_ts_reconfig->f_alloc_re.bts_pwr_ctrl.p0; + ptr2prim_i->p_dl_power.bts_pwr_ctl_mode = + d_ts_reconfig->f_alloc_re.bts_pwr_ctrl.mode; + ptr2prim_i->p_dl_power.pr_mode = + d_ts_reconfig->f_alloc_re.bts_pwr_ctrl.pr_mode; + } + else + { + ptr2prim_i->p_dl_power.p0 = 0xff; + } + + /* + * mac mode + */ + ptr2prim_i->mac_mode = FA; + /* + * uplink allocation structure + */ + if(d_ts_reconfig->v_ul_tfi) + { + ptr2prim_i->p_ul_alloc.ul_tfi = d_ts_reconfig->ul_tfi; + } + else + { + ptr2prim_i->p_ul_alloc.ul_tfi = grr_data->uplink_tbf.tfi; + } + ptr2prim_i->p_ul_alloc.ts_mask = grr_data->uplink_tbf.ts_usage; + /* + * fixed allocation structure + * half duplex mode is ignored, only valid for MS class 19 to 29 + */ + /* + * TBF STARTING TIME for fixed allocation structure + */ + if(d_ts_reconfig->f_alloc_re.tbf_s_time.v_abs) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ts_reconfig->f_alloc_re.tbf_s_time.abs); + } + else if (d_ts_reconfig->f_alloc_re.tbf_s_time.v_rel) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn, + d_ts_reconfig->f_alloc_re.tbf_s_time.rel); + } + else + { /* this shall never happen */ + ptr2prim_i->p_tbf_start.fn = (grr_data->dl_fn+13)%FN_MAX; + TRACE_ERROR("NO STARTING TIME IN FIXED ALLOCATION!!"); + } + ptr2prim_i->p_tbf_start.tbf_start_present = 1; + /* + * Downlink Control Timeslot + */ + ptr2prim_i->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = d_ts_reconfig->f_alloc_re.dl_ctrl_ts; + grr_data->tc.fa_ctrl.dl_ctrl_ts = d_ts_reconfig->f_alloc_re.dl_ctrl_ts; + /* + * ALLOCATION BITMAP + */ + if(d_ts_reconfig->f_alloc_re.v_block_struct) + { + tc_calc_fa_bitmap(ptr2prim_i->p_tbf_start.fn, /*starting time of cuurent tbf*/ + d_ts_reconfig->f_alloc_re.block_struct.bl_o_bl_per, /* blocks or block periods*/ + d_ts_reconfig->f_alloc_re.block_struct.a_map_len, /* bitmap length*/ + d_ts_reconfig->f_alloc_re.block_struct.alloc_map, /* ptr to alloc struct*/ + &ptr2prim_i->p_ul_alloc.p_fixed_alloc); /* ptr to fix sttruct*/ + } + else if(d_ts_reconfig->f_alloc_re.v_alloc_map) + { + tc_calc_fa_bitmap(ptr2prim_i->p_tbf_start.fn, /*starting time of cuurent tbf*/ + 0, /* blocks : default*/ + d_ts_reconfig->f_alloc_re.c_alloc_map, /* bitmap length*/ + d_ts_reconfig->f_alloc_re.alloc_map, /* ptr to alloc struct*/ + &ptr2prim_i->p_ul_alloc.p_fixed_alloc); /* ptr to fix sttruct*/ + } + /* + * check final allocation + */ + grr_data->tc.fa_ctrl.current_alloc.final_alloc = d_ts_reconfig->f_alloc_re.final_alloc; + } + else if ( d_ul_ack->msg_type EQ D_UL_ACK_c) + { + /* + * Timing Advance in packet uplink ack/nack with fixed allocation + */ + if(d_ul_ack->gprs_ul_ack_nack_info.v_pta) + { + grr_handle_ta ( d_ul_ack->gprs_ul_ack_nack_info.pta.v_ta_value, + d_ul_ack->gprs_ul_ack_nack_info.pta.ta_value, + d_ul_ack->gprs_ul_ack_nack_info.pta.v_ta_index_tn, + d_ul_ack->gprs_ul_ack_nack_info.pta.ta_index_tn.ta_index, + d_ul_ack->gprs_ul_ack_nack_info.pta.ta_index_tn.ta_tn, + 0xFF, + 0, + 0, + &ptr2prim_i->p_timing_advance); + } + else + { + grr_handle_ta ( 0, + 0, + 0xFF, + 0, + 0, + 0xFF, + 0, + 0, + &ptr2prim_i->p_timing_advance); + } + + /* + * mac mode + */ + ptr2prim_i->mac_mode = FA; + /* + * uplink allocation structure + */ + + /*no change, therefore take from database*/ + ptr2prim_i->p_ul_alloc.ul_tfi = grr_data->uplink_tbf.tfi; + ptr2prim_i->p_ul_alloc.ts_mask = grr_data->uplink_tbf.ts_usage; + /* + * fixed allocation structure + * half duplex mode is ignored, only valid for MS class 19 to 29 + */ + /* + * TBF STARTING TIME for fixed allocation structure + */ + if(d_ul_ack->gprs_ul_ack_nack_info.v_f_alloc_ack AND d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.v_fa_s2) + { + if(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.tbf_s_time.v_abs) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.tbf_s_time.abs); + } + else if (d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.tbf_s_time.v_rel) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn, + d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.tbf_s_time.rel); + } + else + { /* this shall never happen */ + ptr2prim_i->p_tbf_start.fn = (grr_data->dl_fn+13)%FN_MAX; + TRACE_ERROR("NO STARTING TIME IN FIXED ALLOCATION!! struct problem"); + } + } + else + { /* this shall never happen */ + ptr2prim_i->p_tbf_start.fn = (grr_data->dl_fn+13)%FN_MAX; + TRACE_ERROR("NO STARTING TIME IN FIXED ALLOCATION!!"); + } + ptr2prim_i->p_tbf_start.tbf_start_present = 1; + + + /* + * Downlink Control Timeslot, take from database + */ + ptr2prim_i->p_ul_alloc.p_fixed_alloc.dl_ctrl_ts = grr_data->tc.fa_ctrl.dl_ctrl_ts; + /* + * ALLOCATION BITMAP + */ + if(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.v_block_struct) + { + tc_calc_fa_bitmap(ptr2prim_i->p_tbf_start.fn, /* starting time of cuurent tbf*/ + d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.block_struct.bl_o_bl_per,/* blocks or block periods*/ + d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.block_struct.a_map_len, /* bitmap length */ + d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.block_struct.alloc_map, /* ptr to alloc struct*/ + &ptr2prim_i->p_ul_alloc.p_fixed_alloc); /* ptr to fix sttruct*/ + } + else if(d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.v_alloc_map) + { + tc_calc_fa_bitmap(ptr2prim_i->p_tbf_start.fn, /*starting time of cuurent tbf*/ + 0, /* blocks : default*/ + d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.c_alloc_map, /* bitmap length*/ + d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.fa_s2.alloc_map, /* ptr to alloc struct*/ + &ptr2prim_i->p_ul_alloc.p_fixed_alloc); /* ptr to fix sttruct*/ + } + /* + * check final allocation + */ + grr_data->tc.fa_ctrl.current_alloc.final_alloc = d_ul_ack->gprs_ul_ack_nack_info.f_alloc_ack.final_alloc; + } + else + { + TRACE_ERROR ( "Wrong message type in _decodedCtrlMsg" ); + } + + if(ptr2prim_i->p_tbf_start.tbf_start_present) + grr_data->uplink_tbf.tbf_start_fn = ptr2prim_i->p_tbf_start.fn; + else + grr_data->uplink_tbf.tbf_start_fn = CGRLC_STARTING_TIME_NOT_PRESENT; + + grr_data->uplink_tbf.st_tfi = ptr2prim_i->p_ul_alloc.ul_tfi; + + + return; +} /* tc_set_fa_assignment() */ + + +/* ++------------------------------------------------------------------------------ +| Function : tc_set_dl_assignment ++------------------------------------------------------------------------------ +| Description : This function sets some parameter of T_MPHP_ASSIGNMENT_REQ is +| case of downlink allocation +| +| Parameters : ptr2prim_i - ptr to MPHP_ASSIGNMENT_REQ +| ++------------------------------------------------------------------------------ +*/ +LOCAL void tc_set_dl_assignment (T_MPHP_ASSIGNMENT_REQ * ptr2prim_i) +{ + MCAST(d_dl_assign, D_DL_ASSIGN); /* T_D_DL_ASSIGN */ + MCAST(d_ts_reconfig,D_TS_RECONFIG); + + TRACE_FUNCTION( "tc_set_dl_assignment" ); + if( d_dl_assign->msg_type EQ D_DL_ASSIGN_c) + { + /* + * timing advance + */ + grr_handle_ta ( d_dl_assign->pta.v_ta_value, + d_dl_assign->pta.ta_value, + 0xFF, + 0, + 0, + d_dl_assign->pta.v_ta_index_tn, + d_dl_assign->pta.ta_index_tn.ta_index, + d_dl_assign->pta.ta_index_tn.ta_tn, + &ptr2prim_i->p_timing_advance); + /* + * TBF starting time + */ + + if(d_dl_assign->pda_trnc_grp.v_tbf_s_time) + { + ptr2prim_i->p_tbf_start.tbf_start_present = 1; + if(d_dl_assign->pda_trnc_grp.tbf_s_time.v_abs) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_dl_assign->pda_trnc_grp.tbf_s_time.abs); + } + else if (d_dl_assign->pda_trnc_grp.tbf_s_time.v_rel) + { + ptr2prim_i->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn, + d_dl_assign->pda_trnc_grp.tbf_s_time.rel); + } + else + { /* this shall never happen */ + ptr2prim_i->p_tbf_start.fn = grr_data->dl_fn%FN_MAX; + TRACE_ERROR("DL v_start_tbf but either rel nor abs tbf included"); + } + } + else if(grr_data->l1_del_tbf_start_fn NEQ GRR_INVALID_FN) + { + ptr2prim_i->p_tbf_start.tbf_start_present = 1; + ptr2prim_i->p_tbf_start.fn = grr_data->l1_del_tbf_start_fn; + } + else + { + ptr2prim_i->p_tbf_start.tbf_start_present = 0; + } + + + if(d_dl_assign->v_bts_pwr_ctrl) + { + ptr2prim_i->p_dl_power.p0 = d_dl_assign->bts_pwr_ctrl.p0; + ptr2prim_i->p_dl_power.bts_pwr_ctl_mode = d_dl_assign->bts_pwr_ctrl.mode; + ptr2prim_i->p_dl_power.pr_mode = d_dl_assign->bts_pwr_ctrl.pr_mode; + } + else + { + ptr2prim_i->p_dl_power.p0 = 0xff; + } + /* + * mac mode + */ + ptr2prim_i->mac_mode = d_dl_assign->mac_mode; + + /* + * downlink allocation structure + */ + if(d_dl_assign->pda_trnc_grp.v_dl_tfi_assign) + { + ptr2prim_i->p_dl_alloc.dl_tfi = d_dl_assign->pda_trnc_grp.dl_tfi_assign; + } + else + { + ptr2prim_i->p_dl_alloc.dl_tfi = grr_data->downlink_tbf.tfi; + } + ptr2prim_i->p_dl_alloc.ts_mask = d_dl_assign->ts_alloc; + + } + else if ( d_ts_reconfig->msg_type EQ D_TS_RECONFIG_c) + { + /* TS Reconfigure allways contains ul assign -> TBF starting time + * is handled there + */ + if(d_ts_reconfig->v_dl_tfi) + { + ptr2prim_i->p_dl_alloc.dl_tfi = d_ts_reconfig->dl_tfi; + } + else + { + ptr2prim_i->p_dl_alloc.dl_tfi = grr_data->downlink_tbf.tfi; + } + ptr2prim_i->p_dl_alloc.ts_mask = grr_data->downlink_tbf.ts_usage; + /* + * timing advance + */ + grr_handle_ta ( d_ts_reconfig->gpta.v_ta_value, + d_ts_reconfig->gpta.ta_value, + d_ts_reconfig->gpta.v_ul_ta_index, + d_ts_reconfig->gpta.ul_ta_index, + d_ts_reconfig->gpta.ul_ta_tn, + d_ts_reconfig->gpta.v_dl_ta_index, + d_ts_reconfig->gpta.dl_ta_index, + d_ts_reconfig->gpta.dl_ta_tn, + &ptr2prim_i->p_timing_advance); + } + else + { + TRACE_ERROR ( "Wrong message type in _decodedCtrlMsg" ); + } + + + if(ptr2prim_i->p_tbf_start.tbf_start_present) + grr_data->downlink_tbf.tbf_start_fn = ptr2prim_i->p_tbf_start.fn; + else + grr_data->downlink_tbf.tbf_start_fn = CGRLC_STARTING_TIME_NOT_PRESENT; + + grr_data->downlink_tbf.st_tfi = ptr2prim_i->p_dl_alloc.dl_tfi; + grr_data->downlink_tbf.polling_bit = 0xFF; + + + + return; +} /* tc_set_dl_assignment() */ + + + +/*==== PUBLIC FUNCTIONS =====================================================*/ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_gen_rand ++------------------------------------------------------------------------------ +| Description : This function generates a random value between db.prach.s +| and (db.prach.tx_int -1) +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL USHORT tc_gen_rand ( void ) +{ + USHORT result ; + UBYTE i; + TRACE_FUNCTION( "tc_gen_rand" ); + + /* + * the "-1" defined in ETS 04.60 will be done by tc_random_value() + * + */ + i = tx_int_table[psc_db->prach.tx_int]; + + result = (USHORT)grr_random_value (S_T_RND_INDEX, i ); + + result += s_table[psc_db->prach.s_prach]; + +#ifndef _TARGET_ + TRACE_EVENT_P2("S, S+1 ..:%d tx_init:%d",result, i); +#endif /* _TARGET_ */ + + return (result); + +} /* tc_gen_rand() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_calc_req ++------------------------------------------------------------------------------ +| Description : The function tc_calc_req() generate the message +| Packet Access Request. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL USHORT tc_calc_req ( void ) +{ + USHORT channel_request_data = 0; + + TRACE_FUNCTION( "tc_calc_req" ); + + switch(psc_db->gprs_cell_opt.ab_type) + { + case AB_8_BIT: + switch(grr_data->uplink_tbf.access_type) + { + case CGRLC_AT_ONE_PHASE: + channel_request_data = tc_one_phase_mask_8bit(); + channel_request_data |= ((grr_get_gprs_ms_class( )-1)<<2); + break; + case CGRLC_AT_SHORT_ACCESS: + channel_request_data = tc_short_access_mask_8bit(); + channel_request_data |= ((grr_data->uplink_tbf.nr_blocks-1)<<3); + break; + case CGRLC_AT_TWO_PHASE: + channel_request_data=tc_two_phase_mask_8bit(); + break; + case CGRLC_AT_PAGE_RESPONSE: + channel_request_data=tc_page_response_mask_8bit(); + break; + case CGRLC_AT_CELL_UPDATE: + channel_request_data=tc_cell_update_mask_8bit(); + break; + case CGRLC_AT_MM_PROCEDURE: + channel_request_data=tc_mm_procedure_mask_8bit(); + break; + case CGRLC_AT_SINGLE_BLOCK: + channel_request_data=tc_single_block_mask_8bit(); + break; + default: + break; + } + break; + + case AB_11_BIT: + switch(grr_data->uplink_tbf.access_type) + { + case CGRLC_AT_ONE_PHASE: + channel_request_data=tc_one_phase_mask_11bit(); + channel_request_data |= ((grr_get_gprs_ms_class( )-1)<<5); + channel_request_data |= (grr_data->uplink_tbf.prio<<3); + break; + case CGRLC_AT_SHORT_ACCESS: + channel_request_data=tc_short_access_mask_11bit(); + channel_request_data |= (grr_data->uplink_tbf.prio<<3); + channel_request_data |= ((grr_data->uplink_tbf.nr_blocks-1)<<5); + break; + case CGRLC_AT_TWO_PHASE: + channel_request_data=tc_two_phase_mask_11bit(); + channel_request_data |= (grr_data->uplink_tbf.prio<<3); + break; + case CGRLC_AT_PAGE_RESPONSE: + channel_request_data=tc_page_response_mask_11bit(); + break; + case CGRLC_AT_CELL_UPDATE: + channel_request_data=tc_cell_update_mask_11bit(); + break; + case CGRLC_AT_MM_PROCEDURE: + channel_request_data=tc_mm_procedure_mask_11bit(); + break; + case CGRLC_AT_SINGLE_BLOCK: + channel_request_data=tc_single_block_mask_11bit(); + break; + default: + channel_request_data = 0; + break; + } + channel_request_data = grr_convert_11bit_2_etsi(channel_request_data); + TRACE_EVENT_P1("11 bit Channel Request: 0x%X", channel_request_data); + break; + default: + break; + } + return(channel_request_data); + +} /* tc_calc_req() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_check_p_level ++------------------------------------------------------------------------------ +| Description : The function tc_check_p_level() checks the p-level for the +| PDU's radio priority aigainst a random value and returns +| wheather to send the random access or to continue with +| calculating. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL T_CHECK_P_LEVEL tc_check_p_level ( void ) +{ + UBYTE p_level,i; + T_CHECK_P_LEVEL result; + TRACE_FUNCTION( "tc_check_p_level" ); + + /* + * get value between 0 and 15 + */ + i = (UBYTE) grr_random_value (PLEV_RND_INDEX, 16); + + p_level = psc_db->prach.pers_lev.plev[grr_data->uplink_tbf.prio]; + + if(p_level EQ 15) + { + /* + * transmission in every case forbitten, because refer to ETS the value 0xf + * have to be interpreted as 16 and i is in every case more little (0 <= i <= 15). + * This case should be avoided (dead lock!) and have to be checked + * in tc_start_access() + */ + TRACE_ERROR("unexpected persistence_level_value"); + result = C_P_LEVEL_DO_NOT_SEND; + } + else + { + result = ( (i >= p_level) ? C_P_LEVEL_SEND : C_P_LEVEL_DO_NOT_SEND ); + } + + return( result ); + +} /* tc_check_p_level() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_send_assign_req ++------------------------------------------------------------------------------ +| Description : The function tc_send_assign_req() builds MPHP_ASSIGNMENT_REQ +| and send it. +| +| Parameters : tbf_type_i - type of TBF that is to activate +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_send_assign_req ( T_TBF_TYPE tbf_type_i ) +{ + + TRACE_FUNCTION( "tc_send_assign_req" ); + { + T_MPHP_ASSIGNMENT_REQ * ptr2prim;//=NULL; + + ptr2prim=tc_set_freq(); + + grr_set_tbf_cfg_req_param( ptr2prim ); + + switch( tbf_type_i ) + { + case CGRLC_TBF_MODE_DL: + ptr2prim->assign_cmd = DL_ASSIGNMENT; + tc_set_dl_assignment(ptr2prim); + break; + case CGRLC_TBF_MODE_UL: + ptr2prim->assign_cmd = UL_ASSIGNMENT; + if(grr_data->uplink_tbf.mac_mode EQ DA) + tc_set_da_assignment(ptr2prim); + else + tc_set_fa_assignment(ptr2prim); + break; + case CGRLC_TBF_MODE_DL_UL: + ptr2prim->assign_cmd = UL_DL_ASSIGNMENT; + if(grr_data->uplink_tbf.mac_mode EQ DA) + tc_set_da_assignment(ptr2prim); + else + tc_set_fa_assignment(ptr2prim); + tc_set_dl_assignment(ptr2prim); + break; +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + case CGRLC_TBF_MODE_2PA: + ptr2prim->assign_cmd = UL_TP_ACCESS; + tc_set_fa_assignment(ptr2prim); + break; +#endif + default: + break; + } /* switch (tbf_type_i) */ + PSEND(hCommL1,ptr2prim); + + } +} /* tc_send_assign_req() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_send_tbf_rel ++------------------------------------------------------------------------------ +| Description : The function tc_send_tbf_rel() builds MPHP_TBF_RELEASE_REQ +| and send it. +| +| Parameters : TBP-Type - that have to be deleted +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_send_tbf_rel ( T_TBF_TYPE tbf_i ) +{ + UBYTE dummy = grr_data->tc.num_of_rels_running; + + TRACE_FUNCTION( "tc_send_tbf_rel" ); + + tc_prepare_send_tbf_release_req( tbf_i ); + + { + T_RELEASE_STATE rel_state= REL_PERFORMED; + + if(dummy NEQ grr_data->tc.num_of_rels_running) + { + rel_state = REL_RUNNING; + } + sig_tc_ctrl_rel_state(rel_state); + } + + +} /* tc_send_tbf_rel() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_send_pdch_rel ++------------------------------------------------------------------------------ +| Description : The function tc_send_pdch_rel() builds MPHP_PDCH_RELEASE_REQ +| and send it. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_send_pdch_rel ( UBYTE ts_available ) +{ + PALLOC(mphp_pdch_release_req,MPHP_PDCH_RELEASE_REQ); + + TRACE_FUNCTION( "tc_send_pdch_rel" ); + + mphp_pdch_release_req->assign_id = 0; + mphp_pdch_release_req->ts_mask = ts_available; + PSEND(hCommL1,mphp_pdch_release_req); + +} /* tc_send_pdch_rel() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_abort_tbf ++------------------------------------------------------------------------------ +| Description : The function tc_abort_tbf() stops a TBF. +| +| Parameters : tbf_i - TBF type to abort +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_abort_tbf ( T_TBF_TYPE tbf_i ) +{ + + TRACE_FUNCTION( "tc_abort_tbf" ); + + switch( tbf_i ) + { + case CGRLC_TBF_MODE_NULL: + TRACE_EVENT("NULL TBF active: check if tbf starting time is running"); + tc_cgrlc_ul_tbf_res ( CGRLC_TBF_MODE_ACCESS_FAILED, CGRLC_PRIM_STATUS_NULL ); + break; +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + case CGRLC_TBF_MODE_2PA: + tc_send_tbf_rel(tbf_i); + tc_cgrlc_tbf_rel_req(tbf_i,CGRLC_TBF_REL_ABNORMAL,CGRLC_STARTING_TIME_NOT_PRESENT); + tc_deactivate_tbf(tbf_i); + break; +#endif + case CGRLC_TBF_MODE_UL: + tc_send_tbf_rel(tbf_i); + tc_cgrlc_tbf_rel_req(tbf_i,CGRLC_TBF_REL_ABNORMAL,CGRLC_STARTING_TIME_NOT_PRESENT); + tc_deactivate_tbf(tbf_i); + break; + case CGRLC_TBF_MODE_DL: + tc_send_tbf_rel(tbf_i); + tc_cgrlc_tbf_rel_req(tbf_i,CGRLC_TBF_REL_ABNORMAL,CGRLC_STARTING_TIME_NOT_PRESENT); + tc_deactivate_tbf(tbf_i); + break; + case CGRLC_TBF_MODE_DL_UL: + tc_send_tbf_rel(tbf_i); + tc_cgrlc_tbf_rel_req(tbf_i,CGRLC_TBF_REL_ABNORMAL,CGRLC_STARTING_TIME_NOT_PRESENT); + tc_deactivate_tbf(tbf_i); + break; + default: + TRACE_ERROR ( "tc_abort_tbf: TBF type is invalid" ); + break; + } +} /* tc_abort_tbf() */ + + + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_build_res_req ++------------------------------------------------------------------------------ +| Description : The function tc_build_res_req() builds Packet Resource Request. +| +| Parameters : reason_i - the reason for building that packet resouce +| reallocation +| src_info_i - indicates where to get the carrier information +| regarding the assigned TBF +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_build_res_req (T_U_RESOURCE_REQ *ptr2res_req, + T_REASON_BUILD reason_i, + T_SRC_TBF_INFO src_info_i ) +{ + UBYTE change_mark; + + TRACE_FUNCTION( "tc_build_res_req" ); + + + memset(ptr2res_req,0,sizeof(T_U_RESOURCE_REQ) ); + + /* processing of messsage type */ + ptr2res_req->msg_type = U_RESOURCE_REQ_c; + + /* processing of change mark */ + if( grr_is_pbcch_present( ) ) + { + change_mark = psc_db->psi2_params.psi2_change_mark; + } + else + { + change_mark = psc_db->psi13_params.si13_change_mark; + } + + if( change_mark EQ NOT_SET ) + { + ptr2res_req->v_ma_ch_mark = 0; + } + else + { + ptr2res_req->v_ma_ch_mark = 1; + ptr2res_req->ma_ch_mark = change_mark; + } + + + if(reason_i EQ R_BUILD_2PHASE_ACCESS) + { + /* 1 - processing of ACCESS_TYPE */ + ptr2res_req->v_access_type = 1; + ptr2res_req->access_type = TWO_PHASE; + + /* 2 - processing of global TFI and TLLI */ + ptr2res_req->flag = 1; + ptr2res_req->v_glob_tfi = 0; + ptr2res_req->v_tlli_value = 1; + + grr_set_buf_tlli( &ptr2res_req->tlli_value, grr_data->db.ms_id.new_tlli ); + + /* 3 - processing of radio access capabilities */ + if( rr_csf_get_radio_access_capability( &ptr2res_req->ra_cap ) EQ 0 ) + { + ptr2res_req->v_ra_cap = TRUE; + } + else + { + ptr2res_req->v_ra_cap = FALSE; + + TRACE_ERROR( "tc_build_res_req: radio access capabilities invalid" ); + } + /* 4 - processing of channel request description */ + ptr2res_req->chan_req_des.peak_thr_class = (UBYTE) grr_data->uplink_tbf.peak; + ptr2res_req->chan_req_des.radio_prio = grr_data->uplink_tbf.prio; + if(grr_data->uplink_tbf.prim_type EQ CGRLC_LLC_PRIM_TYPE_UNITDATA_REQ) + { + ptr2res_req->chan_req_des.rlc_mode = CGRLC_RLC_MODE_UACK; + } + else + { + ptr2res_req->chan_req_des.rlc_mode = CGRLC_RLC_MODE_ACK; + } + ptr2res_req->chan_req_des.llc_pdu_type = LLC_NOT_ACK; + ptr2res_req->chan_req_des.rlc_octet_cnt = grr_data->uplink_tbf.rlc_oct_cnt; + + /* 5 - processing of signal variance */ + ptr2res_req->v_signvar = FALSE; + } + + /* processing of C value */ + { + ptr2res_req->c_value = meas_c_get_value( ); + } + + /* processing of relative interference levels */ + { + T_p_frequency_par freq_par; + T_MEAS_IM_CARRIER ma; + + switch( src_info_i ) + { + case( SRC_TBF_INFO_RE_ASSIGN ): + case( SRC_TBF_INFO_IMM_ASSIGN ): + case( SRC_TBF_INFO_UL_ASSIGN ): + grr_set_freq_par( &freq_par ); + meas_im_set_carrier( &ma, &freq_par ); + break; + + default: + TRACE_ASSERT( src_info_i EQ SRC_TBF_INFO_RE_ASSIGN OR + src_info_i EQ SRC_TBF_INFO_IMM_ASSIGN OR + src_info_i EQ SRC_TBF_INFO_UL_ASSIGN ); + break; + } + + meas_im_get_rel_i_level( &ma, &ptr2res_req->ilev ); + } + +#ifdef REL99 + ptr2res_req->v_release_99_str_prr = FALSE; + ptr2res_req->release_99_str_prr.flag = 0; + ptr2res_req->release_99_str_prr.flag2 = 0; + ptr2res_req->release_99_str_prr.v_pfi = 0; + ptr2res_req->release_99_str_prr.add_ms_rac = 0; + ptr2res_req->release_99_str_prr.retrans_of_prr = 0; +#endif + +} /* tc_build_res_req() */ + + +/* ++------------------------------------------------------------------------------ +| Function : tc_eval_pdch_rel ++------------------------------------------------------------------------------ +| Description : The function tc_eval_pdch_rel() evaluate a +| Packet PDCH Release. +| +| Parameters : slot_i - the slot where the message was received +| ++------------------------------------------------------------------------------ +*/ +GLOBAL T_EVAL_PDCH_REL tc_eval_pdch_rel ( UBYTE slot_i ) +{ + MCAST(d_pdch_release,D_PDCH_RELEASE); /* T_D_PDCH_RELEASE */ + + UBYTE mask,help=0xFF, help2=0xFF; + T_EVAL_PDCH_REL result=E_PDCH_REL_NULL; + + TRACE_FUNCTION( "tc_eval_pdch_rel" ); + + if(!d_pdch_release->v_ts_available) + { + mask = 0x80; + mask >>= slot_i; + mask ^= 0xFF; + TRACE_EVENT_P7("NO TS PDCH REL: slot=%d ->mask=%x ul=%x st_ul=%x dl=%x st_dl=%x c_fn=%ld" + ,slot_i + ,mask + ,grr_data->uplink_tbf.ts_mask + ,grr_data->uplink_tbf.ts_usage + ,grr_data->downlink_tbf.ts_mask + ,grr_data->downlink_tbf.ts_usage + , grr_data->ul_fn); + } + else + { + mask = d_pdch_release->ts_available; + TRACE_EVENT_P7("ts PDCH REL: mask=%x ul=%x st_ul=%x dl=%x st_dl=%x c_fn=%ld" + ,slot_i + ,mask + ,grr_data->uplink_tbf.ts_mask + ,grr_data->uplink_tbf.ts_usage + ,grr_data->downlink_tbf.ts_mask + ,grr_data->downlink_tbf.ts_usage + , grr_data->ul_fn); + } + grr_data->pdch_rel_ts_mask = mask; + + switch(grr_data->tbf_type) + { + case CGRLC_TBF_MODE_UL: + help = grr_data->uplink_tbf.ts_mask; + grr_data->uplink_tbf.ts_mask &= mask; + if(!grr_data->uplink_tbf.ts_mask) + { + result = E_PDCH_REL_RELEASE_UL; + } + else if(grr_data->uplink_tbf.ts_mask NEQ help) + { + grr_data->uplink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->uplink_tbf.ts_mask); + result = E_PDCH_REL_RECONF; + tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL); + } + else + { + TRACE_EVENT("NO change in pdch rel for ul tbf"); + result = E_PDCH_REL_NULL; + } + break; + case CGRLC_TBF_MODE_DL: + help = grr_data->downlink_tbf.ts_mask; + grr_data->downlink_tbf.ts_mask &= mask; + if(!grr_data->downlink_tbf.ts_mask) + { + result = E_PDCH_REL_RELEASE_DL; + } + else if(grr_data->downlink_tbf.ts_mask NEQ help) + { + grr_data->downlink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->downlink_tbf.ts_mask); + tc_cgrlc_dl_tbf_req(); + result = E_PDCH_REL_RECONF; + } + else + { + TRACE_EVENT("NO change in pdch rel for dl tbf"); + result = E_PDCH_REL_IGNORE; + } + break; + case CGRLC_TBF_MODE_DL_UL: + help = grr_data->uplink_tbf.ts_mask; + help2 = grr_data->downlink_tbf.ts_mask; + grr_data->uplink_tbf.ts_mask &= mask; + grr_data->downlink_tbf.ts_mask &= mask; + if( !handle_ms_cap(UL_DL_ASSIGNMENT)) + { + result = E_PDCH_REL_RELEASE_BOTH; + TRACE_EVENT_P3("MS CLASS ERROR in PDCH assignment ul_mask=%x, dl_mask=%x, pdch_mask=%x", + grr_data->uplink_tbf.ts_mask, + grr_data->downlink_tbf.ts_mask, + mask); + } + else if(!grr_data->downlink_tbf.ts_mask AND !grr_data->uplink_tbf.ts_mask) + { + result = E_PDCH_REL_RELEASE_BOTH; + TRACE_EVENT_P3("rel of UL and DL ul_mask=%x, dl_mask=%x, pdch_mask=%x", + grr_data->uplink_tbf.ts_mask, + grr_data->downlink_tbf.ts_mask, + mask); + } + else if(!grr_data->downlink_tbf.ts_mask) + { /*DL release*/ + if(grr_data->uplink_tbf.ts_mask EQ help) + { /* no change for uplink*/ + result = E_PDCH_REL_RELEASE_DL; + TRACE_EVENT_P3("rel of DL ul_mask=%x, dl_mask=%x, pdch_mask=%x", + grr_data->uplink_tbf.ts_mask, + grr_data->downlink_tbf.ts_mask, + mask); + } + else + { /*uplink reconfigure*/ + result = E_PDCH_REL_RELEASE_DL_RECONF_UL; + grr_data->uplink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->uplink_tbf.ts_mask); + tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL); + TRACE_EVENT_P3("rel of DL, conf UL ul_mask=%x, dl_mask=%x, pdch_mask=%x", + grr_data->uplink_tbf.ts_mask, + grr_data->downlink_tbf.ts_mask, + mask); + } + } + else if(!grr_data->uplink_tbf.ts_mask) + { /*UL release*/ + if(grr_data->downlink_tbf.ts_mask EQ help2) + { /* no change for downlink*/ + result = E_PDCH_REL_RELEASE_UL; + TRACE_EVENT_P3("rel of UL ul_mask=%x, dl_mask=%x, pdch_mask=%x", + grr_data->uplink_tbf.ts_mask, + grr_data->downlink_tbf.ts_mask, + mask); + } + else + { /*downlink reconfigure*/ + result = E_PDCH_REL_RELEASE_UL_RECONF_DL; + grr_data->downlink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->downlink_tbf.ts_mask); + tc_cgrlc_dl_tbf_req(); + TRACE_EVENT_P3("rel of UL, conf DL ul_mask=%x, dl_mask=%x, pdch_mask=%x", + grr_data->uplink_tbf.ts_mask, + grr_data->downlink_tbf.ts_mask, + mask); + } + } + else if(grr_data->downlink_tbf.ts_mask NEQ help2) + { /*change in DL*/ + result = E_PDCH_REL_RECONF; + grr_data->downlink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->downlink_tbf.ts_mask); + tc_cgrlc_dl_tbf_req(); + if(grr_data->uplink_tbf.ts_mask EQ help) + { /* no change for uplink*/ + TRACE_EVENT_P3("conf of DL ul_mask=%x, dl_mask=%x, pdch_mask=%x", + grr_data->uplink_tbf.ts_mask, + grr_data->downlink_tbf.ts_mask, + mask); + } + else + { /*uplink reconfigure*/ + grr_data->uplink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->uplink_tbf.ts_mask); + tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL); + TRACE_EVENT_P3("conf ofDL/UL ul_mask=%x, dl_mask=%x, pdch_mask=%x", + grr_data->uplink_tbf.ts_mask, + grr_data->downlink_tbf.ts_mask, + mask); + } + } + else + { /* no change in DL*/ + if(grr_data->uplink_tbf.ts_mask EQ help) + { /* no change for uplink*/ + result = E_PDCH_REL_IGNORE; + TRACE_EVENT_P3("NO conf UL/DL ul_mask=%x, dl_mask=%x, pdch_mask=%x", + grr_data->uplink_tbf.ts_mask, + grr_data->downlink_tbf.ts_mask, + mask); + } + else + { /*uplink reconfigure*/ + result = E_PDCH_REL_RECONF; + grr_data->uplink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->uplink_tbf.ts_mask); + tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL); + TRACE_EVENT_P3("conf of UL ul_mask=%x, dl_mask=%x, pdch_mask=%x", + grr_data->uplink_tbf.ts_mask, + grr_data->downlink_tbf.ts_mask, + mask); + } + } + break; + default: + TRACE_ERROR("unknown tbf type in tc_eval_pdch_rel"); + break; + } + return(result); + +} /* tc_eval_pdch_rel() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_eval_ul_assign ++------------------------------------------------------------------------------ +| Description : The function tc_eval_ul_assign() evaluates a +| Packet Uplink Assignment. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL T_EVAL_UL_ASSIGN tc_eval_ul_assign ( void ) +{ + MCAST(d_ul_assign,D_UL_ASSIGN); /* T_D_UL_ASSIGN */ + T_EVAL_UL_ASSIGN result = E_UL_ASSIGN_NULL; + UBYTE tx_slots = 0; + UBYTE i,mask; + + T_GRR_STORE_TYPE grr_store_type = GRR_STORE_TYPE_NONE; + + TRACE_FUNCTION( "tc_eval_ul_assign" ); + +#ifdef REL99 + if(d_ul_assign->egprs_flag) + { + + TRACE_ERROR("EGPRS TBF received in UL ASSIGNMENT"); + + if(grr_data->tbf_type EQ CGRLC_TBF_MODE_NULL) + { + /* TBF is not active. Handling abnormal case + * 7.1.4 If the mobile station has been assigned a TBF in EGPRS mode and + * the MS does not support EGPRS, or has been assigned an MCS (e.g. 8-PSK + * in the Uplink) that the MS does not support, the MS shall return to packet + * idle mode and notify higher layers (TBF establishment failure) + */ + return E_UL_ASSIGN_ERROR_RA; + } + else + { + /* TBF is active. Handling abnormal case + * 8.7 While a TBF is in progress, if a mobile station receives a + * PACKET UPLINK ASSIGNMENT, PACKET UPLINK ACK/NACK or PACKET TIMESLOT RECONFIGURE + * message with message escape bit indicating EGPRS (resp. GPRS) contents whereas + * the current TBF mode is GPRS (resp. EGPRS), the mobile station shall ignore the + * message. + */ + return E_UL_ASSIGN_IGNORE; + } + } +#endif + + /* + * Handle mac mode + */ + switch( grr_data->tbf_type ) + { + case CGRLC_TBF_MODE_DL: + grr_data->uplink_tbf.ti = 0; /* contention resolution NOT required */ + + /*lint -fallthrough*/ + + case CGRLC_TBF_MODE_NULL: + if(d_ul_assign->v_dyn_alloc_p) + { + if(!d_ul_assign->dyn_alloc_p.xdyn_alloc) + grr_data->uplink_tbf.mac_mode = DA; + else + { + grr_data->uplink_tbf.mac_mode = EDA; + } + } + else if(d_ul_assign->v_f_alloc_ul) + grr_data->uplink_tbf.mac_mode = FA; + break; + case CGRLC_TBF_MODE_UL: + if( grr_data->uplink_tbf.mac_mode NEQ DA AND + d_ul_assign->v_dyn_alloc_p + ) + { + TRACE_ERROR("dynamic alloc received while fixed is running in uplink"); + return E_UL_ASSIGN_ERROR_RA; + } + else if( grr_data->uplink_tbf.mac_mode NEQ FA AND + d_ul_assign->v_f_alloc_ul + ) + { + TRACE_ERROR("fixed alloc received while dynamic is running in uplink"); + return E_UL_ASSIGN_ERROR_RA; + } + break; + default: + break; + } + grr_data->uplink_tbf.cs_mode = d_ul_assign->chan_coding_cmd; + grr_data->uplink_tbf.tlli_cs_mode = d_ul_assign->tlli_chan_coding; + grr_data->uplink_tbf.polling_bit = 0xFF; + + if(d_ul_assign->v_dyn_alloc_p) + { + if( grr_data->uplink_tbf.mac_mode NEQ DA) + { + result = E_UL_ASSIGN_ERROR_RA; + TRACE_ERROR("dyn alloc received but diff mac mode"); + TRACE_EVENT_P3("MAC_MODE: ms=%d, Ex.DA=%d tbf_mode=%d" + ,grr_data->uplink_tbf.mac_mode + ,d_ul_assign->dyn_alloc_p.xdyn_alloc + ,grr_data->tbf_type); + } + else + { + result = E_UL_ASSIGN_DYNAMIC; + /* SZML-TC/071*/ + + if (d_ul_assign->dyn_alloc_p.v_rlc_db_granted)/* close-ended TBF*/ + { + UBYTE data_size=20; + + switch( grr_data->uplink_tbf.cs_mode) + { + case CGRLC_CS_MODE_1: + data_size = 20; + break; + case CGRLC_CS_MODE_2: + data_size = 30; + break; + case CGRLC_CS_MODE_3: + data_size = 36; + break; + case CGRLC_CS_MODE_4: + data_size = 50; + break; + default: + TRACE_ERROR("unknown Coding Scheme"); + break; + } + data_size -= grr_data->uplink_tbf.ti*4; /* CR TLLI */ + + grr_data->uplink_tbf.rlc_db_granted = (d_ul_assign->dyn_alloc_p.rlc_db_granted + 9); + + if (grr_data->uplink_tbf.rlc_db_granted * data_size < grr_data->uplink_tbf.rlc_oct_cnt) + /* granted rlc blocks in bytes are not enough to transmit the first pdu*/ + { + result = E_UL_ASSIGN_ERROR_RA; + TRACE_EVENT_P3("granted rlc blocks are not enough to transmit the first pdu rlc_g=%ld sdu_len =%ld data_size=%d" + ,grr_data->uplink_tbf.rlc_db_granted * data_size + ,grr_data->uplink_tbf.rlc_oct_cnt + ,data_size); + return(result); + } + } + else + { + /* + * open ended TBF + */ + grr_data->uplink_tbf.rlc_db_granted = 0; + } + + grr_data->uplink_tbf.ts_usage = 0; + + if(d_ul_assign->dyn_alloc_p.v_tn_alloc) + { + for(i = 0,mask = 0x80;i < 8;i++) + { + if(d_ul_assign->dyn_alloc_p.tn_alloc[i].v_usf) + { + grr_data->uplink_tbf.ts_usage |= mask; + tx_slots++; + } + mask >>= 1; + } + } + else if(d_ul_assign->dyn_alloc_p.v_tn_alloc_pwr) + { + for(i = 0,mask = 0x80;i < 8;i++) + { + if(d_ul_assign->dyn_alloc_p.tn_alloc_pwr.usf_array[i].v_usf_g) + { + + grr_data->uplink_tbf.ts_usage |= mask; + tx_slots++; + } + mask >>= 1; + } + + grr_store_type = GRR_STORE_TYPE_TN_ALLOC_PWR; + } + grr_data->uplink_tbf.nts = tx_slots; + } + } + else if(d_ul_assign->v_sin_alloc) + { + if( grr_data->tc.v_sb_without_tbf ) + { + result = E_UL_ASSIGN_SB_WITHOUT_TBF; + } + else + { + result = E_UL_ASSIGN_SB_2PHASE_ACCESS ; + grr_data->uplink_tbf.ti = 0; + } + + /* + * estimate timeslot + */ + grr_data->uplink_tbf.ts_usage = (0x80 >> d_ul_assign->sin_alloc.tn); + tx_slots=1; + grr_data->uplink_tbf.nts = tx_slots; + + if(d_ul_assign->sin_alloc.v_alf_gam) + { + grr_store_type = GRR_STORE_TYPE_ALF_GAM; + } + + /* starting time allready elapsed? */ + if(d_ul_assign->sin_alloc.tbf_s_time.v_abs) + { + ULONG fn_out; + fn_out = grr_decode_tbf_start_abs(&d_ul_assign->sin_alloc.tbf_s_time.abs); + TRACE_EVENT_P5("eval_ul fn_out:%ld fn_in:%d %d %d data->fn:%ld", + fn_out, + d_ul_assign->sin_alloc.tbf_s_time.abs.t1, + d_ul_assign->sin_alloc.tbf_s_time.abs.t2, + d_ul_assign->sin_alloc.tbf_s_time.abs.t3, + grr_data->dl_fn); + if(grr_check_if_tbf_start_is_elapsed ( fn_out, grr_data->ul_fn)) + { + TRACE_ERROR("TBF Starting time is ELAPSED in single block allocation!"); + TRACE_EVENT_P2("CPAP SBR TBF ST ELAPSED st=%ld c_fn=%ld ", fn_out,grr_data->ul_fn); + result = E_UL_ASSIGN_ERROR_RA; + } + } + else if(d_ul_assign->sin_alloc.tbf_s_time.v_rel AND !d_ul_assign->sin_alloc.tbf_s_time.rel) + { + TRACE_ERROR("rel. TBF Starting time in single block allocation k=0 NOT ALLOWED"); + TRACE_EVENT_P1("k=%d ", d_ul_assign->sin_alloc.tbf_s_time.rel); + result = E_UL_ASSIGN_ERROR_RA; + } + else if(!d_ul_assign->sin_alloc.tbf_s_time.v_rel) + { + TRACE_ERROR("NO TBF Starting time in single block allocation "); + TRACE_EVENT_P2("v_abs=%d v_rel=%d ", d_ul_assign->sin_alloc.tbf_s_time.v_abs + , d_ul_assign->sin_alloc.tbf_s_time.v_rel); + result = E_UL_ASSIGN_ERROR_RA; + } + } + else if(d_ul_assign->v_f_alloc_ul) + { + if( grr_data->uplink_tbf.mac_mode EQ DA ) + { + result = E_UL_ASSIGN_ERROR_RA; + TRACE_ERROR("fixed alloc received while dynamic is running in uplink"); + } + else + { + result = E_UL_ASSIGN_FIXED; + grr_data->uplink_tbf.ts_usage = 0; + tx_slots=0; + if(d_ul_assign->f_alloc_ul.v_ts_alloc) + { + grr_data->uplink_tbf.ts_usage = d_ul_assign->f_alloc_ul.ts_alloc; + /*calculate number of timeslots*/ + tx_slots = grr_calc_nr_of_set_bits(grr_data->uplink_tbf.ts_usage); + } + else if(d_ul_assign->f_alloc_ul.v_pwr_par) + { + for(i = 0,mask = 0x80;i < 8;i++) + { + if(d_ul_assign->f_alloc_ul.pwr_par.gamma_tn[i].v_gamma) + { + grr_data->uplink_tbf.ts_usage |= mask; + tx_slots++; + } + mask >>= 1; + } + + grr_store_type = GRR_STORE_TYPE_PWR_PAR; + } + grr_data->uplink_tbf.nts = tx_slots; + } + } + else + { + TRACE_ERROR ("Packet Uplink Assignment without allocation type - corrupt airmessage!"); + } + + if( !handle_ms_cap(UL_ASSIGNMENT) ) + { + result = E_UL_ASSIGN_ERROR_RA; + TRACE_EVENT("tc_eval_.. will return E_UL_ASSIGN_ERROR_RA (tx_slots wrong)"); + } + + if ( !tc_check_and_save_freq ()) + { + if ((grr_data->tbf_type EQ CGRLC_TBF_MODE_DL) OR (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL) ) + { + result = E_UL_ASSIGN_IGNORE; + TRACE_EVENT("tc_eval_.. will return E_UL_ASSIGN_IGNORE , DL ACTIVE (frequencies wrong)"); + } + else + { + result = E_UL_ASSIGN_ERROR_RA; + TRACE_EVENT("tc_eval_.. will return E_UL_ASSIGN_ERROR_RA (frequencies wrong)"); + } + return result; + } + + if( result NEQ E_UL_ASSIGN_ERROR_RA AND + result NEQ E_UL_ASSIGN_NULL ) + { + switch( grr_store_type ) + { + case GRR_STORE_TYPE_TN_ALLOC_PWR: + grr_store_type_tn_alloc_pwr( &d_ul_assign->dyn_alloc_p.tn_alloc_pwr ); + break; + + case GRR_STORE_TYPE_ALF_GAM: + grr_store_type_alf_gam( &d_ul_assign->sin_alloc.alf_gam, + d_ul_assign->sin_alloc.tn ); + break; + + case GRR_STORE_TYPE_PWR_PAR: + grr_store_type_pwr_par( &d_ul_assign->f_alloc_ul.pwr_par, FALSE ); + break; + + default: + /* do nothing */ + break; + } + } + + return(result); +} /* tc_eval_ul_assign() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_eval_dl_assign ++------------------------------------------------------------------------------ +| Description : The function tc_eval_dl_assign() evaluates a +| Packet Downlink Assignment. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL T_EVAL_DL_ASSIGN tc_eval_dl_assign () +{ + MCAST(d_dl_assign,D_DL_ASSIGN); /* T_D_DL_ASSIGN */ + T_EVAL_DL_ASSIGN result = E_DL_ASSIGN_IGNORE; + + TRACE_FUNCTION( "tc_eval_dl_assign" ); + + /* SZML-TC/072: check for things that results in E_DL_ASSIGN_ERROR_RA */ + + + + grr_data->downlink_tbf.ctrl_ack_bit= 0; + + /* + * compare uplink and new assigned downlink mac mode + * and set downlink mac mode + */ + switch( grr_data->tbf_type ) + { + case CGRLC_TBF_MODE_NULL: + grr_data->downlink_tbf.mac_mode = d_dl_assign->mac_mode; + grr_data->downlink_tbf.t3192 = FALSE; /* indicates if t3192 is running*/ + grr_data->downlink_tbf.rlc_mode = d_dl_assign->rlc_mode; + + result = E_DL_ASSIGN; + break; + case CGRLC_TBF_MODE_UL: + grr_data->downlink_tbf.mac_mode = d_dl_assign->mac_mode; + grr_data->downlink_tbf.t3192 = FALSE; /* indicates if t3192 is running*/ + grr_data->downlink_tbf.rlc_mode = d_dl_assign->rlc_mode; + + /*lint -fallthrough*/ + case CGRLC_TBF_MODE_DL_UL: + if(d_dl_assign->mac_mode NEQ grr_data->uplink_tbf.mac_mode) + { + result = E_DL_ASSIGN_IGNORE; + TRACE_EVENT_P2("Ignore DL_ASS, Diff MAC Mode UL=%d DL=%d ",grr_data->uplink_tbf.mac_mode,d_dl_assign->mac_mode); + return result; + } + if ((grr_data->downlink_tbf.rlc_mode NEQ d_dl_assign->rlc_mode) AND !d_dl_assign->ctrl_ack) + { + TRACE_ERROR("Diff rlc mode in downlink ass..aborting tbf"); + result = E_DL_ASSIGN_ABORT_DL; + return result; + } + grr_data->downlink_tbf.rlc_mode = d_dl_assign->rlc_mode; + result = E_DL_ASSIGN; + break; + case CGRLC_TBF_MODE_DL: + if ((grr_data->downlink_tbf.rlc_mode NEQ d_dl_assign->rlc_mode) AND !d_dl_assign->ctrl_ack) + { + TRACE_ERROR("Diff rlc mode in downlink ass..aborting tbf"); + result = E_DL_ASSIGN_ABORT_DL; + return result; + } + grr_data->downlink_tbf.rlc_mode = d_dl_assign->rlc_mode; + result = E_DL_ASSIGN; + break; + default: + result = E_DL_ASSIGN; + break; + } + + /* + * compare old and new mac mode for downlink + */ + if ( d_dl_assign->mac_mode EQ FA_HALF_DUPLEX) + { + result = E_DL_ASSIGN_IGNORE; + TRACE_EVENT( "DL ASS: Half duplex not supported" ); + return result; + } + else if(d_dl_assign->mac_mode NEQ grr_data->downlink_tbf.mac_mode) + { + result = E_DL_ASSIGN_IGNORE; + TRACE_EVENT_P3( "DL ASS: current mac mode= %d differs from commanded =%d tbf_type=%d" + ,grr_data->downlink_tbf.mac_mode + ,d_dl_assign->mac_mode + ,grr_data->tbf_type ); + return result; + } + + + /* + * ckeck if tfi is present while no downlink tbf is active + */ + switch( grr_data->tbf_type ) + { + case CGRLC_TBF_MODE_UL: + case CGRLC_TBF_MODE_NULL: + if(!d_dl_assign->pda_trnc_grp.v_dl_tfi_assign) + { + result = E_DL_ASSIGN_IGNORE; + TRACE_EVENT("Ignore DL_ASS, no dl_tfi in P DL Ass(no dl tbf active) "); + return result; + } + result = E_DL_ASSIGN; + break; + default: + result = E_DL_ASSIGN; + break; + } + + + if(d_dl_assign->ctrl_ack) + { + if(grr_data->downlink_tbf.t3192) + { + grr_data->downlink_tbf.ctrl_ack_bit= 1; + grr_data->downlink_tbf.t3192 = FALSE; /* indicates if t3192 is running*/ + + } + else + { + result = E_DL_ASSIGN_IGNORE; + TRACE_EVENT("DL ASS IGNORED, ctrl ack bit set but t3192 is not running"); + return result; + } + } + else if(grr_data->downlink_tbf.t3192) + { + TRACE_EVENT("DL assignment:ctrl ack bit is not set but t3192 is running"); + } + + grr_data->downlink_tbf.ts_usage = d_dl_assign->ts_alloc; + grr_data->downlink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->downlink_tbf.ts_usage); + if( !handle_ms_cap(DL_ASSIGNMENT)) + { + result = E_DL_ASSIGN_ERROR_RA; + TRACE_EVENT("tc_eval_.. will return E_DL_ASSIGN_ERROR_RA (ms class error)"); + return result; + } + + if( tc_check_and_save_freq( ) EQ FALSE ) + { + if ((grr_data->tbf_type EQ CGRLC_TBF_MODE_UL) OR (grr_data->tbf_type EQ CGRLC_TBF_MODE_DL_UL)) + { + result = E_DL_ASSIGN_IGNORE; + TRACE_EVENT("tc_eval_.. will return E_DL_ASSIGN_IGNORE , UL ACTIVE (frequencies wrong)"); + } + else + { + result = E_DL_ASSIGN_ERROR_RA; + TRACE_EVENT("tc_eval_.. will return E_DL_ASSIGN_ERROR_RA (frequencies wrong)"); + } + return result; + } + + if( d_dl_assign->pda_trnc_grp.v_pwr_par EQ TRUE ) + { + grr_store_type_pwr_par( &d_dl_assign->pda_trnc_grp.pwr_par, FALSE ); + } + + return(result); +} /* tc_eval_dl_assign() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_eval_access_rej ++------------------------------------------------------------------------------ +| Description : The function tc_eval_access_rej() evaluates a +| Packet Access Reject. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL T_EVAL_ACCESS_REJ tc_eval_access_rej ( ULONG * t3172_value_i) +{ + MCAST(d_access_rej,D_ACCESS_REJ); + T_EVAL_ACCESS_REJ result = E_ACCESS_REJ_NULL; + + TRACE_FUNCTION( "tc_eval_access_rej" ); + /*SZML-TC/122*/ + + if(d_access_rej->reject.v_wait) + { + result = E_ACCESS_REJ_WAIT; + + *t3172_value_i = d_access_rej->reject.wait.wait_ind; + if( d_access_rej->reject.wait.waitsize ) + { + *t3172_value_i *= 20; + } + else + { + *t3172_value_i *= 1000; + } + } + else + { + result = E_ACCESS_REJ_NO_WAIT; + } + + return(result); + +} /* tc_eval_access_rej() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_send_ra_req ++------------------------------------------------------------------------------ +| Description : The function tc_send_ra_req() starts the build-process for a +| Packet Access Request and send a MPHP_RA_REQ. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_send_ra_req ( void ) +{ + TRACE_FUNCTION( "tc_send_ra_req" ); + + + while( (grr_data->tc.n_acc_req < + max_retrans_table[psc_db->prach.max_retrans[grr_data->uplink_tbf.prio]]+1) + AND (tc_check_p_level() EQ C_P_LEVEL_DO_NOT_SEND) ) + { + TRACE_EVENT("C_P_LEVEL_DO_NOT_SEND"); + grr_data->tc.n_acc_req++; + } + + + if (grr_data->tc.n_acc_req < + max_retrans_table[psc_db->prach.max_retrans[grr_data->uplink_tbf.prio]]+1) + { + PALLOC(mphp_ra_req,MPHP_RA_REQ); + memset(mphp_ra_req,0x00,sizeof(T_MPHP_RA_REQ)); + /* + * The powervalue txpwr_max_cch in DB is always a useful value. + * The value is set by PSI. First a useful initial value. + * After that a value from RR and after reception of PSI3 txpwr_max_cch + * is set to a value from the scell-structure. + */ + + mphp_ra_req->txpwr = + grr_get_ms_txpwr_max_cch + ( psc_db->pbcch.bcch.arfcn, + grr_data->meas.pwr_offset, + psc_db->scell_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch ); + + if(grr_data->tc.sending_req EQ TRUE) + { + mphp_ra_req->rand = (USHORT)tc_gen_rand(); + } + else + { + /* The first PCR may be sent immediately when ready. Only the second PCR */ + /* needs a random value which has to have uniform probability distribution */ + mphp_ra_req->rand = 1; + } + mphp_ra_req->channel_request_data = tc_calc_req(); + mphp_ra_req->bs_prach_blks = psc_db->pccch.bs_prach_blks; + mphp_ra_req->burst_type = psc_db->gprs_cell_opt.ab_type; + + { + UBYTE channel_request_data[RLC_MAC_MAX_LEN_CHANNEL_REQ]; + + channel_request_data[0] = ( mphp_ra_req->channel_request_data >> 8 ); + channel_request_data[1] = ( UBYTE )mphp_ra_req->channel_request_data; + + TRACE_BINDUMP + ( hCommGRR, TC_USER4, + cl_rlcmac_get_msg_name( U_MSG_TYPE_CHANNEL_REQ_c, RLC_MAC_ROUTE_UL ), + channel_request_data, RLC_MAC_MAX_LEN_CHANNEL_REQ ); /*lint !e569*/ + } + + PSEND(hCommL1,mphp_ra_req); + grr_data->tc.sending_req = TRUE; + } + else + { + vsi_t_start(GRR_handle,T3170,tc_get_t3170_value()); + vsi_t_stop(GRR_handle,T3186); + tc_send_ra_stop_req(); + + } + + +} /* tc_send_ra_req() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_send_ra_stop_req ++------------------------------------------------------------------------------ +| Description : The function tc_send_ra_stop_req() stops the +| sending of packet access requests. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_send_ra_stop_req ( void ) +{ + TRACE_FUNCTION( "tc_send_ra_stop_req" ); + + /* + * This timer might be run - in case of MPHP_RA_CON has not been received by GRR. + * If it does not run the stop-command will be ignored by vsi. + */ + vsi_t_stop(GRR_handle,T3186); + + if(grr_data->tc.sending_req) + { + PALLOC(mphp_ra_stop_req,MPHP_RA_STOP_REQ); + PSEND(hCommL1,mphp_ra_stop_req); + /* + * reset number of access in this procedure + */ + grr_data->tc.n_acc_req =0; + + /* + * to make sure that TC only stops + * the sending procedure if it + * is running + */ + grr_data->tc.sending_req = FALSE; + } + +} /* tc_send_ra_stop_req() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_send_polling_res ++------------------------------------------------------------------------------ +| Description : The function tc_send_polling_res() sends the primitive +| MPHP_POLLING_RESPONSE_REQ. +| +| Parameters : ctrl_ack_type_i - indicates if normal or access burst shall sent +| rrbp_i - depending on this variable the send frame number is computed +| fn_i - frame number where Packet Polling Request was received +| ctrl_ack_i - this value is sent within the pca, depends frim mac header +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_send_polling_res (UBYTE poll_type_i, ULONG fn_i, UBYTE rrbp_i,UBYTE ctrl_ack_i ) +{ + PALLOC( mphp_polling_response_req, MPHP_POLLING_RESPONSE_REQ ); + + TRACE_FUNCTION( "tc_send_polling_res" ); + + mphp_polling_response_req->fn = grr_calc_new_poll_pos( fn_i, rrbp_i ); + + mphp_polling_response_req->txpwr = + grr_get_ms_txpwr_max_cch + ( psc_db->pbcch.bcch.arfcn, + grr_data->meas.pwr_offset, + psc_db->scell_par.cr_par_1.cr_pow_par.gprs_ms_txpwr_max_cch ); + + if(poll_type_i EQ CGRLC_POLL_RES_NB) + { + mphp_polling_response_req->poll_resp_type = POLL_RESP_NB_CS1; + memset( mphp_polling_response_req->poll_data, + 0x2b, + sizeof(mphp_polling_response_req->poll_data) ); + mphp_polling_response_req->poll_data[23] = 0 ; /* Byte is not used, set to 0 for test purposes */ + + /* code without CCD, air message buffer is used by other service*/ + mphp_polling_response_req->poll_data[0] = 0x40 | grr_data->r_bit; + mphp_polling_response_req->poll_data[1] = 0x04 |((UBYTE)(grr_data->db.ms_id.new_tlli>>30)); + mphp_polling_response_req->poll_data[2] = ((UBYTE)(grr_data->db.ms_id.new_tlli>>22)); + mphp_polling_response_req->poll_data[3] = ((UBYTE)(grr_data->db.ms_id.new_tlli>>14)); + mphp_polling_response_req->poll_data[4] = ((UBYTE)(grr_data->db.ms_id.new_tlli>>06)); + mphp_polling_response_req->poll_data[5] = ((UBYTE)(grr_data->db.ms_id.new_tlli<<2)) + ctrl_ack_i; + + /* + * get TA from paxket uplink/downlink assignment + */ + if(grr_data->ta_params.ta_value EQ 0xFF) + { + MCAST( d_ul_assign, D_UL_ASSIGN ); + MCAST( d_dl_assign, D_DL_ASSIGN); + + if(( d_dl_assign->msg_type EQ D_DL_ASSIGN_c) AND + d_dl_assign->pta.v_ta_value) + + { + mphp_polling_response_req->ta_index = d_dl_assign->pta.ta_value; + } + else if(( d_ul_assign->msg_type EQ D_UL_ASSIGN_c) AND + d_ul_assign->pta.v_ta_value) + { + mphp_polling_response_req->ta_index = d_ul_assign->pta.ta_value; + } + else + { + TRACE_ERROR("NO TA IN MPHP_POLLING_REQ"); + TRACE_EVENT_P5("msg_typ=%d, v_pta_dl=%d v_pta_ul=%d v_ptai_dl=%d v_ptai_ul=%d" + ,d_ul_assign->msg_type + ,d_dl_assign->pta.v_ta_value + ,d_ul_assign->pta.v_ta_value + ,d_dl_assign->pta.v_ta_index_tn + ,d_ul_assign->pta.v_ta_index_tn); + } + + } + else + { + mphp_polling_response_req->ta_index = grr_data->ta_params.ta_value; + TRACE_EVENT_P1("valid ta in database at sending MPHP_POLLING_RES_REQ ta=%d",grr_data->ta_params.ta_value); + } + + TRACE_BINDUMP + ( hCommGRR, TC_USER4, + cl_rlcmac_get_msg_name + ( ( UBYTE )( mphp_polling_response_req->poll_data[1] >> 2 ), RLC_MAC_ROUTE_UL ), + mphp_polling_response_req->poll_data, MAX_L2_FRAME_SIZE ); /*lint !e569*/ + } + else + { + USHORT data; + + /* + * initalize channel request data array + */ + memset( mphp_polling_response_req->poll_data, + 0, + sizeof(mphp_polling_response_req->poll_data) ); + + /* + * format is four access bursts + */ + if(psc_db->gprs_cell_opt.ab_type EQ AB_8_BIT) + { + /* + * 8 Bit access burst + */ + mphp_polling_response_req->poll_resp_type = POLL_RESP_AB_8_BIT; + data =0x0000; + data|=0x7f; + /*TRACE_EVENT_P1("POLL_RESP_8BIT_AB: FN %Ld", mphp_polling_response_req->fn);*/ + } + else + { + /* + * 11 Bit access burst + */ + + mphp_polling_response_req->poll_resp_type = POLL_RESP_AB_11_BIT; + data = (0x07<<8); + data|=0xe7; + + data = grr_convert_11bit_2_etsi(data); + /*TRACE_EVENT_P1("POLL_RESP_11BIT_AB: FN %Ld", mphp_polling_response_req->fn);*/ + } + + mphp_polling_response_req->poll_data[0]= (UBYTE)(data & 0x00ff); + mphp_polling_response_req->poll_data[1]= (UBYTE)((data & 0xff00) >> 8); + + TRACE_BINDUMP + ( hCommGRR, TC_USER4, + cl_rlcmac_get_msg_name( U_MSG_TYPE_CHANNEL_REQ_c, RLC_MAC_ROUTE_UL ), + mphp_polling_response_req->poll_data, + RLC_MAC_MAX_LEN_CHANNEL_REQ ); /*lint !e569*/ + } + + PSEND( hCommL1, mphp_polling_response_req ); + +} /* tc_send_polling_res() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_send_single_block ++------------------------------------------------------------------------------ +| Description : The function tc_send_single_block() sends the primitive +| MPHP_SINGLE_BLOCK_REQ with measurement report. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_send_single_block ( void ) +{ + MCAST(d_ul_assign,D_UL_ASSIGN); + T_MPHP_SINGLE_BLOCK_REQ * ptr2prim; + + TRACE_FUNCTION( "tc_send_single_block" ); + + ptr2prim = tc_get_send_nb_prim_and_set_freq( ); + + ptr2prim->assign_id = 0; + ptr2prim->purpose = SINGLE_BLOCK_TRANSFER_UL; + ptr2prim->pc_meas_chan = psc_db->g_pwr_par.pc_meas_chan; + ptr2prim->burst_type = ( psc_db->gprs_cell_opt.ab_type EQ AB_8_BIT ) + ? AB_8_BIT : AB_11_BIT; + /* timing advance */ + if (d_ul_assign->pta.v_ta_value) + { + ptr2prim->p_timing_advance.ta_value = d_ul_assign->pta.ta_value; + } + else + { + ptr2prim->p_timing_advance.ta_value = 0xff; + } + + if(d_ul_assign->pta.v_ta_index_tn) + { + ptr2prim->p_timing_advance.ta_index = d_ul_assign->pta.ta_index_tn.ta_index; + } + else + { + ptr2prim->p_timing_advance.ta_index = 0xff; + } + + /* trainings sequence */ + ptr2prim->tsc = d_ul_assign->freq_par.tsc; + + /* handle TBF starting time (is always present in single block allocation) */ + if(d_ul_assign->sin_alloc.tbf_s_time.v_abs) + { + ptr2prim->p_tbf_start.tbf_start_present = 1; + ptr2prim->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ul_assign->sin_alloc.tbf_s_time.abs); + if(grr_check_if_tbf_start_is_elapsed ( ptr2prim->p_tbf_start.fn, grr_data->ul_fn)) + { /* SZML-TC/077: drop message, enter pim */ + TRACE_ERROR("TBF Starting time is ELAPSED in single block allocation!"); + TRACE_EVENT_P2("CPAP SBR TBF ST ELAPSED st=%ld c_fn=%ld ", ptr2prim->p_tbf_start.fn,grr_data->ul_fn); + } + } + else if (d_ul_assign->sin_alloc.tbf_s_time.v_rel) + { + ptr2prim->p_tbf_start.tbf_start_present = 1; + /* + * For the relative position set d_ul_assign->sin_alloc.tbf_s_time.rel-1, because grr_data->fn is + * received from mphp_data_ind. This fn is the current fn, and not the received fn. + */ + ptr2prim->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn, + (USHORT)(d_ul_assign->sin_alloc.tbf_s_time.rel)); + } + else + { + TRACE_ERROR("TBF Starting time is missing in single block allocation!"); + /* SZML-TC/078: drop message, enter pim ! */ + } + + /* timeslot number */ + ptr2prim->tn=d_ul_assign->sin_alloc.tn; + + /* put measurement report into buffer */ + tc_cpy_ctrl_blk_to_buffer( ptr2prim->l2_frame ); + + sig_tc_meas_update_pch( ); + + TRACE_BINDUMP + ( hCommGRR, TC_USER4, + cl_rlcmac_get_msg_name + ( ( UBYTE )( ptr2prim->l2_frame[1] >> 2 ), RLC_MAC_ROUTE_UL ), + ptr2prim->l2_frame, MAX_L2_FRAME_SIZE ); /*lint !e569*/ + + PSEND(hCommL1,ptr2prim); +} /* tc_send_single_block() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_send_resource_request_p ++------------------------------------------------------------------------------ +| Description : The function tc_send_resource_request_p() sends the primitive +| MPHP_SINGLE_BLOCK_REQ with Packet Resource Request for +| two phase access due to reception of airmessage packet uplink +| assignment. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_send_resource_request_p ( void ) +{ + MCAST(d_ul_assign,D_UL_ASSIGN); + + T_MPHP_SINGLE_BLOCK_REQ * ptr2prim; + + TRACE_FUNCTION( "tc_send_resource_request_p" ); + + + ptr2prim = tc_get_send_nb_prim_and_set_freq( ); + + /* + * mark that single block is because of two phase access procedure + */ + ptr2prim->assign_id = 0; + ptr2prim->purpose = TWO_PHASE_ACESS; + ptr2prim->pc_meas_chan = psc_db->g_pwr_par.pc_meas_chan; + ptr2prim->burst_type = (psc_db->gprs_cell_opt.ab_type EQ AB_8_BIT) + ?AB_8_BIT + :AB_11_BIT; + + if (d_ul_assign->pta.v_ta_value) + { + ptr2prim->p_timing_advance.ta_value = d_ul_assign->pta.ta_value; + } + else + { + ptr2prim->p_timing_advance.ta_value = 0xff; + } + + if(d_ul_assign->pta.v_ta_index_tn) + { + ptr2prim->p_timing_advance.ta_index =d_ul_assign->pta.ta_index_tn.ta_index; + } + else + { + ptr2prim->p_timing_advance.ta_index =0xff; + } + + /* + * trainings sequence + */ + ptr2prim->tsc = d_ul_assign->freq_par.tsc; + + + /* + * handle TBF starting time + * is always present in single block allocation + */ + if(d_ul_assign->sin_alloc.tbf_s_time.v_abs) + { + ptr2prim->p_tbf_start.tbf_start_present = 1; + ptr2prim->p_tbf_start.fn = grr_decode_tbf_start_abs(&d_ul_assign->sin_alloc.tbf_s_time.abs); + if(grr_check_if_tbf_start_is_elapsed ( ptr2prim->p_tbf_start.fn, grr_data->ul_fn)) + { /* SZML-TC/079 */ + TRACE_ERROR("TBF Starting time is ELAPSED in single block allocation!"); + TRACE_EVENT_P2("CPAP SBR TBF ST ELAPSED st=%ld c_fn=%ld ", ptr2prim->p_tbf_start.fn,grr_data->ul_fn); + } + TRACE_EVENT_P5("res_req fn_out:%ld fn_in:%d %d %d data->fn:%ld", + ptr2prim->p_tbf_start.fn, + d_ul_assign->sin_alloc.tbf_s_time.abs.t1, + d_ul_assign->sin_alloc.tbf_s_time.abs.t2, + d_ul_assign->sin_alloc.tbf_s_time.abs.t3, + grr_data->dl_fn); + } + else if (d_ul_assign->sin_alloc.tbf_s_time.v_rel) + { + ptr2prim->p_tbf_start.tbf_start_present = 1; + /* + * For the relative position set d_ul_assign->sin_alloc.tbf_s_time.rel-1, because grr_data->fn is + * received from mphp_data_ind. This fn is the current fn, and not the received fn. + */ + ptr2prim->p_tbf_start.fn = grr_decode_tbf_start_rel(grr_data->dl_fn, + (USHORT)(d_ul_assign->sin_alloc.tbf_s_time.rel)); + TRACE_EVENT_P3("REL: ST_TIME for PRR: fn_i=%ld rel=%ld fn_out=%ld" + ,grr_data->dl_fn + ,d_ul_assign->sin_alloc.tbf_s_time.rel + ,ptr2prim->p_tbf_start.fn); + } + else + { + TRACE_ERROR("TBF Starting time is missing in single block allocation!"); + } + + ptr2prim->tn = d_ul_assign->sin_alloc.tn; + + { + T_U_RESOURCE_REQ resource_req; + + tc_build_res_req( &resource_req, + R_BUILD_2PHASE_ACCESS, + SRC_TBF_INFO_UL_ASSIGN ); + + grr_encode_ul_ctrl_block( ptr2prim->l2_frame, ( UBYTE* )&resource_req ); + } + + sig_tc_meas_update_pch( ); + + TRACE_BINDUMP + ( hCommGRR, TC_USER4, + cl_rlcmac_get_msg_name + ( ( UBYTE )( ptr2prim->l2_frame[1] >> 2 ), RLC_MAC_ROUTE_UL ), + ptr2prim->l2_frame, MAX_L2_FRAME_SIZE ); /*lint !e569*/ + + PSEND(hCommL1,ptr2prim); + + return; + +} /* tc_send_resource_request_p() */ + + +/* ++------------------------------------------------------------------------------ +| Function : tc_handle_ra_con ++------------------------------------------------------------------------------ +| Description : The function tc_handle_ra_con() checks wheather there is to send +| another Packet Access Request or not. +| +| Parameters : void ++------------------------------------------------------------------------------ +*/ +GLOBAL T_HANDLE_RA_CON tc_handle_ra_con ( void ) +{ + T_HANDLE_RA_CON result; + UBYTE max_retrans; + TRACE_FUNCTION( "tc_handle_ra_con" ); + + + /* + * stop T3186 becauce packet access request was sent + */ + + + /* + * get current max. retransmissson value + */ + max_retrans + = max_retrans_table[psc_db->prach.max_retrans[grr_data->uplink_tbf.prio]]; + + if(grr_data->tc.n_acc_req >= max_retrans + 1) + { + result = H_RA_CON_STOP_REQ; + vsi_t_start(GRR_handle,T3170,tc_get_t3170_value()); + vsi_t_stop(GRR_handle,T3186); + } + else + { + result = H_RA_CON_CONTINUE; + } + + + return(result); + +} /* tc_handle_ra_con() */ + + + + + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_init ++------------------------------------------------------------------------------ +| Description : The function tc_init() initialize the TC data structure. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_init ( void ) +{ + UBYTE i; + + TRACE_FUNCTION( "tc_init" ); + + /* + * set some values + */ + grr_data->tc.disable_callback_func = NULL; + grr_data->tc.disable_class = CGRLC_DISABLE_CLASS_CR; + grr_data->tbf_type = CGRLC_TBF_MODE_NULL; + grr_data->tc.dcch_present = FALSE; + grr_data->tc.v_freq_set = FALSE; + + /* + * values for fixed alloc + */ + grr_data->tc.fa_ctrl.fa_type = FA_NO_CURRENT; + grr_data->tc.fa_ctrl.repeat_alloc = FALSE; + grr_data->tc.fa_ctrl.ts_overr = 0; + + grr_data->tc.num_of_rels_running = 0; + + /* initialize the relevant data for uplink control block */ + grr_data->tc.v_sb_without_tbf = FALSE; + + grr_data->tc.ul_ctrl_blk.seq[0] = MAX_CTRL_BLK_NUM; + + for( i = 0; i < MAX_CTRL_BLK_NUM; i++ ) + { + grr_data->tc.ul_ctrl_blk.blk[i].state = BLK_STATE_NONE; + grr_data->tc.ul_ctrl_blk.blk[i].owner = CGRLC_BLK_OWNER_NONE; + } + + grr_data->tc.two_2p_w_4_tbf_con = TRUE; + + + grr_data->tc.two_2p_w_4_tbf_con = TRUE; + + /* + * Initialise service name (uses define SERVICE_NAME_* in GRR.H); + */ + + INIT_STATE(TC,TC_ACCESS_DISABLED); + /* + * initialize primitive queue + */ + + grr_data->tc.p_assign = NULL; + + grr_data->uplink_tbf.ts_mask = 0; + grr_data->uplink_tbf.ts_usage = 0; + grr_data->downlink_tbf.ts_mask = 0; + grr_data->downlink_tbf.ts_usage = 0; + grr_data->tc.n_acc_req = 0; + +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + grr_data->tc.tbf_est_pacch = FALSE; +#endif + +} /* tc_init() */ + + + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_handle_error_pim ++------------------------------------------------------------------------------ +| Description : The function tc_handle_error_pim() ... +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_handle_error_pim ( void ) +{ + TRACE_FUNCTION( "tc_handle_error_pim" ); + TRACE_EVENT( "tc_handle_error_pim" ); + + if( grr_data->tc.v_sb_without_tbf ) + { + tc_set_stop_ctrl_blk( FALSE, CGRLC_BLK_OWNER_NONE, 0 ); + + tc_cgrlc_access_status_req(); + } + else + { + tc_cgrlc_ul_tbf_res ( CGRLC_TBF_MODE_ESTABLISHMENT_FAILURE, CGRLC_PRIM_STATUS_ONE ); + } + +} /* tc_handle_error_pim() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_handle_error_ra ++------------------------------------------------------------------------------ +| Description : The function tc_handle_error_ra() handles actions related +| to errors that leads to randam access procedure +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_handle_error_ra ( void ) +{ + TRACE_FUNCTION( "tc_handle_error_ra" ); + + + /* + * - called in case of contention resulution failed in RU + * - t3168 expires contention resulution failed in 2P-Access + * - If the mobile station has been assigned more PDCHs than it supports according + * to its MS multislot class, the mobile station shall reinitiate the packet access + * procedure unless it has already been repeated 4 times. In that + * case, TBF failure has occurred. + */ + + /* + * cancel access procedure if running + */ + if(grr_is_pbcch_present() +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + AND !grr_data->tc.tbf_est_pacch +#endif + ) + { + tc_send_ra_stop_req(); + } + + /* + * Kill TBF if running + */ + tc_abort_tbf(grr_data->tbf_type); + + SET_STATE(TC,TC_PIM); + + + +} /* tc_handle_error_ra() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_activate_tbf ++------------------------------------------------------------------------------ +| Description : The function tc_activate_tbf() set the assigned TBF +| into the data structures +| +| Parameters : tbf_type_i - type of TBF to deactivate +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_activate_tbf ( T_TBF_TYPE tbf_type_i ) +{ + TRACE_FUNCTION( "tc_activate_tbf" ); + + /* + * Reset of n_acc_req_procedures because of the fact that number of + * access procedures during pacet access procedures must not considered in + * a error with random access occured during running TBF. + */ + /* grr_data->tc.n_acc_req_procedures = 0;*/ + + switch( tbf_type_i ) + { + + case CGRLC_TBF_MODE_UL: + switch( grr_data->tbf_type ) + { + case CGRLC_TBF_MODE_DL: + grr_data->tbf_type = CGRLC_TBF_MODE_DL_UL; + break; + case CGRLC_TBF_MODE_NULL: +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + case CGRLC_TBF_MODE_2PA: +#endif + grr_data->tbf_type = CGRLC_TBF_MODE_UL; + break; + default: + break; + } + break; + + case CGRLC_TBF_MODE_DL: + switch( grr_data->tbf_type ) + { + case CGRLC_TBF_MODE_UL: + grr_data->tbf_type = CGRLC_TBF_MODE_DL_UL; + break; + case CGRLC_TBF_MODE_NULL: + grr_data->tbf_type = CGRLC_TBF_MODE_DL; + break; + default: + break; + } + break; + case CGRLC_TBF_MODE_DL_UL: + switch( grr_data->tbf_type ) + { + case CGRLC_TBF_MODE_UL: + case CGRLC_TBF_MODE_DL: + case CGRLC_TBF_MODE_DL_UL: + grr_data->tbf_type = CGRLC_TBF_MODE_DL_UL; + break; + default: + { + TRACE_ERROR("FATAL ERROR: tc_activate_tbf called with wrong tbf_type"); + } + break; + } + break; +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + case CGRLC_TBF_MODE_2PA: + switch( grr_data->tbf_type ) + { + case CGRLC_TBF_MODE_UL: + if (grr_data->tc.tbf_est_pacch) + { + grr_data->tbf_type = CGRLC_TBF_MODE_2PA; + } + else + { + TRACE_ERROR("FATAL ERROR: tc_activate_tbf called with wrong tbf_type"); + } + break; + + default: + TRACE_ERROR("FATAL ERROR: tc_activate_tbf called with wrong tbf_type:CGRLC_TBF_MODE_2PA"); + break; + } + break; +#endif + default: + { + TRACE_ERROR("FATAL ERROR: tc_activate_tbf called with wrong tbf_type"); + } + break; + } /* switch (tbf_type_i) */ + + +} /* tc_activate_tbf() */ + + +/* ++------------------------------------------------------------------------------ +| Function : tc_deactivate_tbf ++------------------------------------------------------------------------------ +| Description : The function tc_deactivate_tbf() removes a TBF logical from TC +| end estimates how to continue. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_deactivate_tbf ( T_TBF_TYPE tbf_i ) +{ + TRACE_FUNCTION( "tc_deactivate_tbf" ); + +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + if((tbf_i EQ CGRLC_TBF_MODE_UL) OR + (tbf_i EQ CGRLC_TBF_MODE_2PA )) + { + grr_data->tc.tbf_est_pacch = FALSE; + } +#endif + + switch( grr_data->tbf_type ) + { + + case CGRLC_TBF_MODE_DL_UL: + switch( tbf_i ) + { + case CGRLC_TBF_MODE_UL: + grr_data->tbf_type = CGRLC_TBF_MODE_DL; + break; + case CGRLC_TBF_MODE_DL: + grr_data->tbf_type = CGRLC_TBF_MODE_UL; + break; + case CGRLC_TBF_MODE_DL_UL: + grr_data->tbf_type = CGRLC_TBF_MODE_NULL; + break; + } + break; + + case CGRLC_TBF_MODE_DL: + case CGRLC_TBF_MODE_UL: +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + case CGRLC_TBF_MODE_2PA: +#endif + grr_data->tbf_type = CGRLC_TBF_MODE_NULL; + break; + + default: + break; + } + + switch( grr_data->tbf_type ) + { + case CGRLC_TBF_MODE_DL: + SET_STATE(TC,TC_TBF_ACTIVE); + /* + * downlink tbf is running --> TC_TBF_ACTIVE + */ + break; + + case CGRLC_TBF_MODE_UL: + /* + * uplink tbf is running, no state change required + */ + break; + + case CGRLC_TBF_MODE_NULL: + SET_STATE(TC,TC_PIM); + /* + * no tbf is running, enter TC_PIM + */ + break; + + default: + break; + } + + +} /* tc_deactivate_tbf() */ + + +/* ++------------------------------------------------------------------------------ +| Function : tc_start_timer_t3172 ++------------------------------------------------------------------------------ +| Description : The function tc_start_timer_t3172() +| SZML-TC/085 this timer start +| caused p access reject will be done +| with cell reselection procedures +| +| Parameters : none +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_start_timer_t3172 ( ULONG t3172_value_i ) +{ + + if(t3172_value_i > 10000) + { + TRACE_EVENT_P1( "T3172 start %d s", (t3172_value_i/1000)); + } + else + { + TRACE_EVENT_P1( "T3172 start %d ms", t3172_value_i); + } + vsi_t_start(GRR_handle,T3172_1,t3172_value_i); + +} /* tc_start_timer_t3172() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_handle_tbf_start +|------------------------------------------------------------------------------ +| Description : The function tc_handle_tbf_start() handles the TBF-Starting- +| Time in a Packet Uplink Assignment. +| +| Parameters : tbf_type - type of tbf to be handled, +| tbf_wait - pointer to variable to store the calculated timmer +| value ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_handle_tbf_start( T_TBF_TYPE tbf_type ) +{ + TRACE_FUNCTION( "tc_handle_tbf_start" ); + + + tc_send_assign_req(tbf_type); + tc_activate_tbf(tbf_type); + + if((tbf_type EQ CGRLC_TBF_MODE_UL)) + { + vsi_t_stop(GRR_handle,T3162); + vsi_t_stop(GRR_handle,T3168); + vsi_t_stop(GRR_handle,T3170); + vsi_t_stop(GRR_handle,T3186); + + tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL); + } + else if(tbf_type EQ CGRLC_TBF_MODE_DL) + { + tc_cgrlc_dl_tbf_req(); + if(grr_data->tc.v_sb_without_tbf EQ TRUE) + { + /*When Single Block is request for Measurement Report + but network has sent the DL assignment, then this measurement report + is sent to GRLC to be sent as normal control block*/ + tc_send_control_msg_to_grlc(); + grr_data->tc.v_sb_without_tbf = FALSE; + } + } + else if(tbf_type EQ CGRLC_TBF_MODE_DL_UL) + { + vsi_t_stop(GRR_handle,T3168); + tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_UL,CGRLC_PRIM_STATUS_NULL); + tc_cgrlc_dl_tbf_req(); + } +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + else if(tbf_type EQ CGRLC_TBF_MODE_2PA) + { + tc_cgrlc_ul_tbf_res(CGRLC_TBF_MODE_2PA,CGRLC_PRIM_STATUS_NULL); + } +#endif +} /* tc_handle_tbf_start() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_prepare_handle_tbf_start +|------------------------------------------------------------------------------ +| Description : +| +| Parameters : ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_prepare_handle_tbf_start ( T_TBF_TYPE tbf_type, + UBYTE new_state, + UBYTE old_state ) +{ + MCAST( p_d_dl_assign, D_DL_ASSIGN ); + + TRACE_FUNCTION( "tc_prepare_handle_tbf_start" ); + + if( grr_is_pbcch_present( ) AND + ( + old_state EQ TC_PIM OR + old_state EQ TC_WAIT_ASSIGN OR + old_state EQ TC_WAIT_2P_ASSIGN OR + old_state EQ TC_POLLING OR + old_state EQ TC_WAIT_STOP_TASK_CNF + ) + ) + { + UBYTE ccch_read; + + if( p_d_dl_assign->msg_type EQ D_DL_ASSIGN ) + { + ccch_read = ( p_d_dl_assign->pda_trnc_grp.v_tbf_s_time ? DONT_STOP_CCCH : STOP_CCCH ); + } + else + { + MCAST( p_d_ul_assign, D_UL_ASSIGN ); + + if( ( p_d_ul_assign->v_dyn_alloc_p AND + p_d_ul_assign->dyn_alloc_p.v_tbf_s_time ) OR + p_d_ul_assign->v_sin_alloc OR + p_d_ul_assign->v_f_alloc_ul ) + { + ccch_read = DONT_STOP_CCCH; + } + else + { + ccch_read = STOP_CCCH; + } + } + + grr_data->tc.last_eval_assign.ccch_read = ccch_read; + grr_data->tc.last_eval_assign.tbf_type = tbf_type; + grr_data->tc.last_eval_assign.state = new_state; + + SET_STATE( TC, TC_WAIT_STOP_TASK_CNF ); + + tc_malloc_assign( ); + if(old_state NEQ TC_WAIT_STOP_TASK_CNF) + { + sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ASSIGNED, ccch_read ); + } + } + else + { + tc_handle_tbf_start( tbf_type ); + +#ifdef _TARGET_ + + if( p_d_dl_assign->msg_type EQ D_DL_ASSIGN AND + grr_data->downlink_tbf.tbf_start_fn NEQ 0xFFFFFFFF ) + { + sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ACCESS, TASK_STOP_DUMMY_VALUE ); + } + +#endif + + } +} /* tc_prepare_handle_tbf_start() */ +/* ++------------------------------------------------------------------------------ +| Function : tc_set_fa_bitmap ++------------------------------------------------------------------------------ +| Description : sets fixed allocation bitmap for requested allocation after +| receiving a repeat allocation with ts_override +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL USHORT tc_set_fa_bitmap( UBYTE ts_mask, T_FIX_ALLOC* ptr_alloc) +{ + UBYTE i; + USHORT tx_slots=0; + TRACE_FUNCTION( "tc_set_fa_bitmap" ); + + if (ts_mask) + { + /* + * add new time slots to current allocation + */ + for(i=0;i<grr_data->tc.fa_ctrl.current_alloc.alloc.size_bitmap;i++) + { + ptr_alloc->alloc.bitmap[i] = grr_data->tc.fa_ctrl.current_alloc.alloc.bitmap[i] | ts_mask; + } + } + + return (tx_slots); + +} /* tc_set_fa_bitmap() */ + + +/* ++------------------------------------------------------------------------------ +| Function : tc_send_ul_repeat_alloc_req ++------------------------------------------------------------------------------ +| Description : send the primitive MPHP_REPEAT_UL_FIXED_ALLOC_REQ +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_send_ul_repeat_alloc_req( void) +{ + PALLOC(ptr_2prim,MPHP_REPEAT_UL_FIXED_ALLOC_REQ); + + TRACE_FUNCTION( "tc_send_ul_repeat_alloc_req" ); + + ptr_2prim->repeat_alloc = grr_data->tc.fa_ctrl.repeat_alloc; + ptr_2prim->ts_override = grr_data->tc.fa_ctrl.ts_overr; + + if(grr_data->tc.fa_ctrl.repeat_alloc) + { + ptr_2prim->p_tbf_start.tbf_start_present = 1; + ptr_2prim->p_tbf_start.fn = grr_data->tc.fa_ctrl.current_alloc.alloc_start_fn; + } + else + { + ptr_2prim->p_tbf_start.tbf_start_present = 0; + ptr_2prim->p_tbf_start.fn = 0xffffffff; + } + PSEND(hCommL1,ptr_2prim); + +} /* tc_send_ul_repeat_alloc_req() */ + + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_eval_ts_reconf ++------------------------------------------------------------------------------ +| Description : The function tc_eval_ts_reconf() evaluates a +| Packet Timeslot reconfigure. +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL T_EVAL_TS_RECONFIG tc_eval_ts_reconf ( void ) +{ + MCAST(d_ts_reconfig,D_TS_RECONFIG); /* T_D_TS_RECONFIG */ + T_EVAL_TS_RECONFIG result = E_TS_IGNORE; + UBYTE tx_slots; + UBYTE i,mask; + + T_GRR_STORE_TYPE grr_store_type = GRR_STORE_TYPE_NONE; + + TRACE_FUNCTION( "tc_eval_ts_reconf" ); + + grr_data->downlink_tbf.ctrl_ack_bit = 0; + +#ifdef REL99 + /* This function is called only when TBF is active. Handling abnormal case + * 8.7 While a TBF is in progress, if a mobile station receives a + * PACKET UPLINK ASSIGNMENT, PACKET UPLINK ACK/NACK or PACKET TIMESLOT RECONFIGURE + * message with message escape bit indicating EGPRS (resp. GPRS) contents whereas + * the current TBF mode is GPRS (resp. EGPRS), the mobile station shall ignore the + * message. + */ + if(d_ts_reconfig->egprs_flag) + { + TRACE_ERROR( " EGPRS TBF received in TS_RECONFIGURE " ); + return E_TS_IGNORE; + } +#endif + + switch(grr_data->tbf_type) + { + case CGRLC_TBF_MODE_UL: + /* + * reassignment of uplink and downlink assignment + */ + grr_data->downlink_tbf.mac_mode = grr_data->uplink_tbf.mac_mode; + grr_data->downlink_tbf.t3192 = FALSE; /* indicates if t3192 is running*/ + grr_data->downlink_tbf.rlc_mode = d_ts_reconfig->dl_rlc_mode; + + if(d_ts_reconfig->v_dl_tfi EQ 0) + { + TRACE_ERROR( "No downlnik assignment in TS_RECONFIGURE " ); + result = E_TS_RECONFIG_ERROR_RA; + return result; + } + if((d_ts_reconfig->v_dyn_alloc_ts EQ 1) AND + grr_data->uplink_tbf.mac_mode EQ FIXED_ALLOCATION) + { + TRACE_ERROR( "fixed alloc expected but dynamic alloc received" ); + result = E_TS_RECONFIG_ERROR_RA; + return result; + } + if(d_ts_reconfig->v_f_alloc_re EQ 1 AND + grr_data->uplink_tbf.mac_mode EQ DYNAMIC_ALLOCATION) + { + TRACE_ERROR( "dynamic alloc expected but fixed alloc received" ); + result = E_TS_RECONFIG_ERROR_RA; + return result; + } + result = E_TS_UL_REASSIG_NEW_DL; + break; + case CGRLC_TBF_MODE_DL: + grr_data->uplink_tbf.ti = 0; /* contention resolution NOT required */ + if(d_ts_reconfig->v_dyn_alloc_ts) + { + if(d_ts_reconfig->dyn_alloc_ts.xdyn_alloc) + grr_data->uplink_tbf.mac_mode =EDA; + else + grr_data->uplink_tbf.mac_mode =DA; + } + else if(d_ts_reconfig->v_f_alloc_re) + { + grr_data->uplink_tbf.mac_mode = FA; + } + /* + * downlink tbf active, + * assignment of uplink and downlink reassignment + */ + if(d_ts_reconfig->v_ul_tfi EQ 0) + { + TRACE_ERROR( "No uplnik tfi in TS_RECONFIGURE" ); + result = E_TS_RECONFIG_ERROR_RA; + return result; + } + if ((grr_data->downlink_tbf.rlc_mode NEQ d_ts_reconfig->dl_rlc_mode) AND !d_ts_reconfig->ctrl_ack) + { + TRACE_ERROR("Diff rlc mode in TS_RECONFIGURE..msg rejected..aborting"); + result = E_TS_RECONFIG_ERROR_RA; + return result; + } + grr_data->downlink_tbf.rlc_mode = d_ts_reconfig->dl_rlc_mode; + result = E_TS_NEW_UL_DL_REASSIG; + break; + case CGRLC_TBF_MODE_DL_UL: + + if((d_ts_reconfig->v_dyn_alloc_ts EQ 1) AND + grr_data->uplink_tbf.mac_mode EQ FIXED_ALLOCATION) + { + TRACE_ERROR( "fixed alloc expected but dynamic alloc received" ); + result = E_TS_RECONFIG_ERROR_RA; + return result; + } + if(d_ts_reconfig->v_f_alloc_re EQ 1 AND + grr_data->uplink_tbf.mac_mode EQ DYNAMIC_ALLOCATION) + { + TRACE_ERROR( "dynamic alloc expected but fixed alloc received" ); + result = E_TS_RECONFIG_ERROR_RA; + return result; + } + if ((grr_data->downlink_tbf.rlc_mode NEQ d_ts_reconfig->dl_rlc_mode) AND !d_ts_reconfig->ctrl_ack) + { + TRACE_ERROR("Diff rlc mode in TS_RECONFIGURE..msg rejected..aborting"); + result = E_TS_RECONFIG_ERROR_RA; + return result; + } + grr_data->downlink_tbf.rlc_mode = d_ts_reconfig->dl_rlc_mode; + result = E_TS_UL_REASSIG_DL_REASSIG; + break; + default: + { + TRACE_ERROR( " tc_eval_ts_reconf unexpected" ); + return E_TS_IGNORE; + } + } + + /* + * set DOWNLINK data base + */ + + grr_data->downlink_tbf.ts_usage = d_ts_reconfig->dl_tn_alloc; + grr_data->downlink_tbf.nts = grr_calc_nr_of_set_bits(grr_data->downlink_tbf.ts_usage); + + if(d_ts_reconfig->ctrl_ack) + { + if(grr_data->downlink_tbf.t3192) + { + grr_data->downlink_tbf.ctrl_ack_bit= 1; + grr_data->downlink_tbf.t3192 = FALSE; + } + else + { + result = E_TS_RECONFIG_ERROR_RA; + TRACE_EVENT("TS_RECONF INVALID->error_ra, ctrl ack bit set but t3192 is not running"); + return result; + } + } + + /* + * set UPLINK data base + */ + grr_data->uplink_tbf.cs_mode = d_ts_reconfig->chan_coding_cmd; + grr_data->uplink_tbf.tlli_cs_mode = 1; + grr_data->uplink_tbf.polling_bit = 0xFF; + grr_data->uplink_tbf.ti = 0; + + /* + * set glob parameters + */ + + if(d_ts_reconfig->v_freq_par) + { + /* SZML-TC/091 */ + /* + * here is also to consider a possiblely existing dl_tbf slot ussage:SZML-TC/092 + */ + } + if(d_ts_reconfig->v_dyn_alloc_ts) + { + tx_slots = 0; + grr_data->uplink_tbf.ts_usage = 0; + if(d_ts_reconfig->dyn_alloc_ts.v_tn_alloc) + { + for(i = 0,mask = 0x80;i < 8;i++) + { + if(d_ts_reconfig->dyn_alloc_ts.tn_alloc[i].v_usf) + { + grr_data->uplink_tbf.ts_usage |= mask; + tx_slots++; + } + mask >>= 1; + } + } + else if(d_ts_reconfig->dyn_alloc_ts.v_tn_alloc_pwr) + { + for(i = 0,mask = 0x80;i < 8;i++) + { + if(d_ts_reconfig->dyn_alloc_ts.tn_alloc_pwr.usf_array[i].v_usf_g) + { + grr_data->uplink_tbf.ts_usage |= mask; + tx_slots++; + } + mask >>= 1; + } + + grr_store_type = GRR_STORE_TYPE_TN_ALLOC_PWR; + } + grr_data->uplink_tbf.nts = tx_slots; + } + else if(d_ts_reconfig->v_f_alloc_re) + { + grr_data->uplink_tbf.ts_usage = 0; + tx_slots=0; + if(d_ts_reconfig->f_alloc_re.v_ul_ts_alloc) + { + grr_data->uplink_tbf.ts_usage = d_ts_reconfig->f_alloc_re.ul_ts_alloc; + /*calculate number of timeslots*/ + tx_slots = grr_calc_nr_of_set_bits(grr_data->uplink_tbf.ts_usage); + } + else if(d_ts_reconfig->f_alloc_re.v_pwr_par) + { + for(i = 0,mask = 0x80;i < 8;i++) + { + if(d_ts_reconfig->f_alloc_re.pwr_par.gamma_tn[i].v_gamma) + { + grr_data->uplink_tbf.ts_usage |= mask; + tx_slots++; + } + mask >>= 1; + } + + grr_store_type = GRR_STORE_TYPE_PWR_PAR; + } + grr_data->uplink_tbf.nts = tx_slots; + } + else + { + TRACE_ERROR ("Packet Timeslot Reconfigure without allocation type - corrupt airmessage!"); + } + + if( !handle_ms_cap(UL_DL_ASSIGNMENT) ) + { + result = E_TS_RECONFIG_ERROR_RA; + TRACE_EVENT("tc_eval_.. will return E_TS_RECONFIG_ERROR_RA (ms class error)"); + } + + if( tc_check_and_save_freq( ) EQ FALSE ) + { + result = E_TS_RECONFIG_ERROR_RA; + TRACE_EVENT("tc_eval_.. will return E_TS_RECONFIG_ERROR_RA (frequencies wrong)"); + } + + if( result NEQ E_TS_RECONFIG_ERROR_RA AND + result NEQ E_TS_IGNORE ) + { + switch( grr_store_type ) + { + case GRR_STORE_TYPE_TN_ALLOC_PWR: + grr_store_type_tn_alloc_pwr( &d_ts_reconfig->dyn_alloc_ts.tn_alloc_pwr ); + break; + + case GRR_STORE_TYPE_PWR_PAR: + grr_store_type_pwr_par( &d_ts_reconfig->f_alloc_re.pwr_par, FALSE ); + break; + + default: + /* do nothing */ + break; + } + } + + return result; +} /* tc_eval_ts_reconf() */ + + + + + + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_stop_timer_t3172 ++------------------------------------------------------------------------------ +| Description : The function tc_stop_timer_t3172() +| SZML-TC/094 this timer start +| caused p access reject will be done +| with cell reselection procedures +| +| Parameters : none +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_stop_timer_t3172 ( void ) +{ + TRACE_FUNCTION( "tc_stop_timer_t3172" ); + + vsi_t_stop(GRR_handle,T3172_1); + +} /* tc_stop_timer_t3172() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_close_gaps_in_ctrl_blk_seq ++------------------------------------------------------------------------------ +| Description : The function tc_close_gaps_in_ctrl_blk_seq reorders the queue +| holding the order which is used to identify the next control +| block to sent. +| +| Parameters : index - at this index the reordering starts +| ++------------------------------------------------------------------------------ +*/ +LOCAL void tc_close_gaps_in_ctrl_blk_seq ( UBYTE index ) +{ + TRACE_FUNCTION( "tc_close_gaps_in_ctrl_blk_seq" ); + + while( index < MAX_CTRL_BLK_NUM AND + grr_data->tc.ul_ctrl_blk.seq[index] NEQ MAX_CTRL_BLK_NUM ) + { + grr_data->tc.ul_ctrl_blk.seq[index-1] = grr_data->tc.ul_ctrl_blk.seq[index]; + + index++; + } + + grr_data->tc.ul_ctrl_blk.seq[index-1] = MAX_CTRL_BLK_NUM; + +} /* tc_close_gaps_in_ctrl_blk_seq() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_store_ctrl_blk ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL BOOL tc_store_ctrl_blk ( T_BLK_OWNER blk_owner, void *blk_struct ) +{ + UBYTE i; /* used for counting */ + BOOL result = FALSE; /* indicates whether control block is */ + /* stored successfully or not */ + T_BLK_INDEX blk_index; /* index to the control block buffer */ + + TRACE_FUNCTION( "tc_store_ctrl_msg" ); + + /* + * we have to find a free buffer for the control block which is + * indicated by the index to the control block buffer + */ + blk_index = MAX_CTRL_BLK_NUM; + + switch( blk_owner ) + { + case( CGRLC_BLK_OWNER_CTRL ): + if( grr_data->tc.ul_ctrl_blk.blk[BLK_INDEX_CTRL].state EQ BLK_STATE_NONE ) + { + blk_index = BLK_INDEX_CTRL; + } + break; + + case( CGRLC_BLK_OWNER_CS ): + if( grr_data->tc.ul_ctrl_blk.blk[BLK_INDEX_CS].state EQ BLK_STATE_NONE ) + { + blk_index = BLK_INDEX_CS; + } + break; + + case( CGRLC_BLK_OWNER_TM ): + if( grr_data->tc.ul_ctrl_blk.blk[BLK_INDEX_TC].state EQ BLK_STATE_NONE ) + { + blk_index = BLK_INDEX_TC; + } + break; + + case( CGRLC_BLK_OWNER_MEAS ): + + blk_index = BLK_INDEX_MEAS; + + while( blk_index < MAX_CTRL_BLK_NUM AND + grr_data->tc.ul_ctrl_blk.blk[blk_index].state NEQ BLK_STATE_NONE ) + { + blk_index++; + } + break; + + default: + /* do nothing */ + break; + } + + /* + * check whether the control block buffer is free, + */ + if( blk_index < MAX_CTRL_BLK_NUM ) + { + /* + * check the queue holding the order which is used to identify the next + * control block to send + */ + i = 0; + + while( i < MAX_CTRL_BLK_NUM AND + grr_data->tc.ul_ctrl_blk.seq[i] NEQ MAX_CTRL_BLK_NUM ) + { + i++; + } + + /* + * check whether there is a free entry in the order queue, + * in case the check fails, there is something wrong with the concept + */ + if( i < MAX_CTRL_BLK_NUM ) + { + /* + * store the control block data and state in the queues + */ + grr_encode_ul_ctrl_block + ( ( UBYTE* )&grr_data->tc.ul_ctrl_blk.blk[blk_index].data[0], + ( UBYTE* )blk_struct ); + + grr_data->tc.ul_ctrl_blk.blk[blk_index].state = BLK_STATE_ALLOCATED; + grr_data->tc.ul_ctrl_blk.blk[blk_index].owner = blk_owner; + grr_data->tc.ul_ctrl_blk.seq[i] = blk_index; + + if( i < MAX_CTRL_BLK_NUM - 1 ) + { + grr_data->tc.ul_ctrl_blk.seq[i+1] = MAX_CTRL_BLK_NUM; + } + + result = TRUE; + } + else + { + TRACE_ERROR( "tc_store_ctrl_blk: no free entry in queue found" ); + } + } + + if( result EQ FALSE ) + { + if( blk_owner EQ CGRLC_BLK_OWNER_MEAS ) + { + TRACE_EVENT( "tc_store_ctrl_blk: no table entry allocated" ); + } + else + { + TRACE_ERROR( "tc_store_ctrl_blk: no table entry allocated" ); + } + } + + return( result ); + +} /* tc_store_ctrl_blk() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_cancel_ctrl_blk ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL BOOL tc_cancel_ctrl_blk ( T_BLK_OWNER blk_owner ) +{ + BOOL result = FALSE; + UBYTE i = 0; + UBYTE blk_index = grr_data->tc.ul_ctrl_blk.seq[i]; + + TRACE_FUNCTION( "tc_cancel_ctrl_blk" ); + + + while( blk_index NEQ MAX_CTRL_BLK_NUM AND + result EQ FALSE ) + { + if( grr_data->tc.ul_ctrl_blk.blk[blk_index].owner EQ blk_owner AND + grr_data->tc.ul_ctrl_blk.blk[blk_index].state EQ BLK_STATE_ALLOCATED ) + { + /* + * mark the entry in the queue as free + */ + grr_data->tc.ul_ctrl_blk.blk[blk_index].state = BLK_STATE_NONE; + grr_data->tc.ul_ctrl_blk.blk[blk_index].owner = CGRLC_BLK_OWNER_NONE; + + tc_close_gaps_in_ctrl_blk_seq( (UBYTE)( i + 1 ) ); + + /* + * notify owner of the control block, TC always runs in unacknowledged mode + */ + if( blk_owner NEQ CGRLC_BLK_OWNER_TM ) + { + sig_tc_ctrl_control_block_result( blk_owner, FALSE ); + } + + result = TRUE; + } + + i++; + if( i < MAX_CTRL_BLK_NUM ) + { + blk_index = grr_data->tc.ul_ctrl_blk.seq[i]; + } + else + { + blk_index = MAX_CTRL_BLK_NUM; + } + } + + if( result EQ FALSE ) + { + TRACE_EVENT( "tc_cancel_ctrl_blk: no block found" ); + } + + return( result ); + +} /* tc_cancel_ctrl_blk() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_set_start_ctrl_blk ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL UBYTE* tc_set_start_ctrl_blk ( UBYTE *index ) +{ + UBYTE i = 0; + T_BLK_INDEX blk_index = MAX_CTRL_BLK_NUM; + + TRACE_FUNCTION( "tc_set_start_ctrl_blk" ); + + while( i < MAX_CTRL_BLK_NUM AND + grr_data->tc.ul_ctrl_blk.seq[i] NEQ MAX_CTRL_BLK_NUM AND + blk_index EQ MAX_CTRL_BLK_NUM ) + { + blk_index = grr_data->tc.ul_ctrl_blk.seq[i]; + + if( grr_data->tc.ul_ctrl_blk.blk[blk_index].state EQ BLK_STATE_ALLOCATED ) + { + grr_data->tc.ul_ctrl_blk.blk[blk_index].state = BLK_STATE_SENT_REQ; + + /* + * the control block was encoded without having correct information + * about the value of the R bit. So we have to set the correct value now. + */ + grr_data->tc.ul_ctrl_blk.blk[blk_index].data[0] = + grr_get_ul_ctrl_block_header( grr_data->r_bit ); + } + else + { + blk_index = MAX_CTRL_BLK_NUM; + } + + i++; + } + + *index = blk_index; + + return( blk_index EQ MAX_CTRL_BLK_NUM ? + NULL : grr_data->tc.ul_ctrl_blk.blk[blk_index].data ); + +} /* tc_set_start_ctrl_blk() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_set_stop_ctrl_blk ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL T_BLK_INDEX tc_set_stop_ctrl_blk + ( BOOL is_tx_success, T_BLK_OWNER srch_owner, T_BLK_INDEX start_index ) +{ + T_BLK_INDEX blk_index = grr_data->tc.ul_ctrl_blk.seq[start_index]; + T_BLK_INDEX nxt_index; + + TRACE_FUNCTION( "tc_set_stop_ctrl_blk" ); + + if( blk_index < MAX_CTRL_BLK_NUM ) + { + T_BLK_OWNER blk_owner = grr_data->tc.ul_ctrl_blk.blk[blk_index].owner; + + if( srch_owner EQ CGRLC_BLK_OWNER_NONE OR + srch_owner EQ blk_owner ) + { + /* + * mark the entry in the queue as free + */ + grr_data->tc.ul_ctrl_blk.blk[blk_index].state = BLK_STATE_NONE; + grr_data->tc.ul_ctrl_blk.blk[blk_index].owner = CGRLC_BLK_OWNER_NONE; + + tc_close_gaps_in_ctrl_blk_seq( 1 ); + + /* + * notify owner of the control block, TC always runs in unacknowledged mode + */ + if( blk_owner NEQ CGRLC_BLK_OWNER_TM ) + { + sig_tc_ctrl_control_block_result( blk_owner, is_tx_success ); + } + + nxt_index = start_index; + } + else + { + nxt_index = start_index + 1; + } + } + else + { + nxt_index = MAX_CTRL_BLK_NUM; + } + + return( nxt_index ); + +} /* tc_set_stop_ctrl_blk() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_set_stop_tc_ctrl_blk ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_set_stop_tc_ctrl_blk ( void ) +{ + T_BLK_INDEX start_index = 0; + + TRACE_FUNCTION( "tc_set_stop_tc_ctrl_blk" ); + + while + ( + ( start_index = tc_set_stop_ctrl_blk( FALSE, CGRLC_BLK_OWNER_TM, start_index ) ) + NEQ MAX_CTRL_BLK_NUM + ){}; +} /* tc_set_stop_tc_ctrl_blk() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_set_stop_all_ctrl_blk ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_set_stop_all_ctrl_blk ( void ) +{ + T_BLK_INDEX start_index = 0; + + TRACE_FUNCTION( "tc_set_stop_all_ctrl_blk" ); + + while + ( + ( start_index = tc_set_stop_ctrl_blk( FALSE, + CGRLC_BLK_OWNER_NONE, + start_index ) ) NEQ MAX_CTRL_BLK_NUM + ){}; +} /* tc_set_stop_all_ctrl_blk() */ + + +/* ++------------------------------------------------------------------------------ +| Function : tc_check_access_is_needed ++------------------------------------------------------------------------------ +| Description : The function tc_check_access_is_needed () .... +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_check_access_is_needed ( T_CHECK_ACCESS_CAUSE cause ) +{ + TRACE_FUNCTION( "tc_check_access_is_needed " ); + + if( ((grr_t_status( T3172_1 ) > 0) OR (grr_t_status( T3170 ) > 0) ) AND + (grr_t_status( T3176 ) EQ 0)) + { + if( cause EQ CAC_T3170_EXPIRED ) + { + sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_IDLE, TASK_STOP_DUMMY_VALUE ); + } + + TRACE_EVENT_P3("ACCESS_REJ RUNNING t3170=%d t3172=%d t3176=%d",grr_t_status( T3170 ) + ,grr_t_status( T3172_1 ) + ,grr_t_status( T3176 )); + return; + } + + switch(grr_data->tbf_type) + { + case CGRLC_TBF_MODE_NULL: + if(grr_data->tc.num_of_rels_running) + { + TRACE_EVENT_P1("WAIT FOR %d REL CON ", grr_data->tc.num_of_rels_running); + return; + } + SET_STATE( TC, TC_WAIT_STOP_TASK_CNF ); + sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_ACCESS, TASK_STOP_DUMMY_VALUE ); + + + break; + case CGRLC_TBF_MODE_DL: + case CGRLC_TBF_MODE_UL: + case CGRLC_TBF_MODE_DL_UL: +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + case CGRLC_TBF_MODE_2PA: +#endif + break; + default: + TRACE_ERROR("unknown tbf type during uplink access"); + break; + } +} /* tc_check_access_is_needed */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_stop_normal_burst_req ++------------------------------------------------------------------------------ +| Description : this function sends the primitive MPHP_STOP_SINGLE_BLOCK_REQ +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_stop_normal_burst_req ( void ) +{ + TRACE_FUNCTION( "tc_stop_normal_burst_req" ); + + { + PALLOC(mphp_stop_single_block_req,MPHP_STOP_SINGLE_BLOCK_REQ); + PSEND(hCommL1,mphp_stop_single_block_req); + } +} /* tc_stop_normal_burst_req() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_malloc_assign ++------------------------------------------------------------------------------ +| Description : The function tc_malloc_assign() .... +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_malloc_assign ( void ) +{ + MCAST( p_d_dl_assign, D_DL_ASSIGN ); + + TRACE_FUNCTION( "tc_malloc_assign" ); + + if( grr_data->tc.p_assign EQ NULL ) + { + if( p_d_dl_assign->msg_type EQ D_DL_ASSIGN ) + { + MALLOC( grr_data->tc.p_assign, sizeof( T_D_DL_ASSIGN ) ); + } + else + { + MALLOC( grr_data->tc.p_assign, sizeof( T_D_UL_ASSIGN ) ); + } + } + else + { + TRACE_ERROR( "tc_malloc_assign: fatal error, memory reallocation not implemented" ); + } + + if( p_d_dl_assign->msg_type EQ D_DL_ASSIGN ) + { + *grr_data->tc.p_assign = *( ( T_D_DL_ASSIGN * )_decodedMsg ); + } + else + { + *( ( T_D_UL_ASSIGN * )grr_data->tc.p_assign ) = *( ( T_D_UL_ASSIGN * )_decodedMsg ); + } +} /* tc_malloc_assign() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_mfree_assign ++------------------------------------------------------------------------------ +| Description : The function tc_mfree_assign() .... +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_mfree_assign ( BOOL restore_data ) +{ + TRACE_FUNCTION( "tc_mfree_assign" ); + + if( grr_data->tc.p_assign NEQ NULL ) + { + if( restore_data ) + { + if( grr_data->tc.p_assign->msg_type EQ D_DL_ASSIGN ) + { + *( ( T_D_DL_ASSIGN * )_decodedMsg ) = *grr_data->tc.p_assign; + } + else + { + *( ( T_D_UL_ASSIGN * )_decodedMsg ) = *( ( T_D_UL_ASSIGN * )grr_data->tc.p_assign ); + } + } + + MFREE( grr_data->tc.p_assign ); + grr_data->tc.p_assign = NULL; + } + else + { + TRACE_ERROR( "tc_mfree_assign: fatal error, no memory allocated" ); + } +} /* tc_mfree_assign() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_prepare_send_tbf_release_req ++------------------------------------------------------------------------------ +| Description : The function tc_prepare_send_tbf_release_req() .... +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +LOCAL void tc_prepare_send_tbf_release_req( T_TBF_TYPE tbf_type ) +{ + TRACE_FUNCTION( "tc_prepare_send_tbf_release_req" ); + + if( grr_is_pbcch_present( ) AND tbf_type EQ grr_data->tbf_type ) + { + grr_data->tc.last_tbf_type = tbf_type; + + grr_data->tc.num_of_rels_running++; + + sig_tc_ctrl_set_pckt_mode( GLBL_PCKT_MODE_RELEASED, TASK_STOP_DUMMY_VALUE ); + } + else + { + tc_send_tbf_release_req( tbf_type, TRUE ); + } +} /* tc_prepare_send_tbf_release_req() */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_send_tbf_release_req ++------------------------------------------------------------------------------ +| Description : The function tc_send_tbf_release_req() .... +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_send_tbf_release_req( T_TBF_TYPE tbf_type, BOOL is_synchron ) +{ + UBYTE rel_req_tbf_type; + UBYTE transid; + + TRACE_FUNCTION( "tc_send_tbf_release_req" ); + + switch( tbf_type ) + { + case CGRLC_TBF_MODE_UL: rel_req_tbf_type = UL_ASSIGNMENT; break; + case CGRLC_TBF_MODE_DL: rel_req_tbf_type = DL_ASSIGNMENT; break; + case CGRLC_TBF_MODE_DL_UL: rel_req_tbf_type = UL_DL_ASSIGNMENT; break; +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + case CGRLC_TBF_MODE_2PA: rel_req_tbf_type = UL_TP_ACCESS; break; +#endif + + default: + TRACE_ERROR( "tc_send_tbf_release_req: unknown tbf type" ); + return; + } + + { + PALLOC(mphp_tbf_release_req,MPHP_TBF_RELEASE_REQ); + mphp_tbf_release_req->tbf_type = rel_req_tbf_type; + PSEND(hCommL1,mphp_tbf_release_req); + + if( is_synchron ) + { + grr_data->tc.num_of_rels_running++; + } + } + + switch(rel_req_tbf_type) + { + case UL_ASSIGNMENT: +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + case UL_TP_ACCESS: +#endif + memset(&grr_data->uplink_tbf,0xEE,sizeof(T_UL_TBF)); + grr_data->test_mode = CGRLC_NO_TEST_MODE; + break; + case DL_ASSIGNMENT: + transid = grr_data->downlink_tbf.trans_id; + memset(&grr_data->downlink_tbf,0xEE,sizeof(T_DL_TBF)); + grr_data->downlink_tbf.trans_id = transid; + break; + case UL_DL_ASSIGNMENT: + transid = grr_data->downlink_tbf.trans_id; + memset(&grr_data->uplink_tbf,0xEE,sizeof(T_UL_TBF)); + memset(&grr_data->downlink_tbf,0xEE,sizeof(T_DL_TBF)); + grr_data->test_mode = CGRLC_NO_TEST_MODE; + grr_data->downlink_tbf.trans_id = transid; + break; + } + + + +} /* tc_send_tbf_release_req() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_get_t3170_value ++------------------------------------------------------------------------------ +| Description : The function tc_get_t3170_value() calculates T3170 and returns it +| +| Parameters : return T_TIME +| ++------------------------------------------------------------------------------ +*/ +GLOBAL T_TIME tc_get_t3170_value(void) +{ + T_TIME t3170_value; + + t3170_value = s_table[psc_db->prach.s_prach]; + + if(S_VALUE_RESERVED EQ t3170_value) + t3170_value = 0; + + t3170_value *= 2; + t3170_value += tx_int_table[psc_db->prach.tx_int]; + /* T3170 value = TX_INT + 2 * S from prach control parameters */ + /* see gsm 04.60 13.1 */ + t3170_value *= 5; /* 1 tdma frame ~ 5ms */ + TRACE_EVENT_P1("T3170: %ld", t3170_value); + return t3170_value; +} + + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_call_disable_callback_func ++------------------------------------------------------------------------------ +| Description : +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_call_disable_callback_func ( void ) +{ + if( grr_data->tc.disable_callback_func NEQ NULL ) + { + T_TC_DISABLE_CALLBACK_FUNC disable_callback_func; + + TRACE_EVENT( "Call disable_callback_func after TBF release" ); + + disable_callback_func = grr_data->tc.disable_callback_func; + grr_data->tc.disable_callback_func = NULL; + + disable_callback_func( ); + } +} /* tc_call_disable_callback_func */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_set_freq ++------------------------------------------------------------------------------ +| Description : This function allocates a primitve depending on the hopping status +| and sets the frequency parameter of T_MPHP_ASSIGNMENT_REQ +| +| Parameters : void +| ++------------------------------------------------------------------------------ +*/ +GLOBAL T_MPHP_ASSIGNMENT_REQ * tc_set_freq ( void ) +{ + PALLOC( ptr2prim, MPHP_ASSIGNMENT_REQ ); + + TRACE_FUNCTION( "tc_set_freq" ); + + memset( ptr2prim, 0, sizeof( T_MPHP_ASSIGNMENT_REQ ) ); + + ptr2prim->tsc = grr_data->tc.freq_set.tsc; + + grr_set_freq_par( &ptr2prim->p_frequency_par ); + + return( ptr2prim ); +}/* tc_set_freq */ + +/* ++------------------------------------------------------------------------------ +| Function : tc_cgrlc_disable_req ++------------------------------------------------------------------------------ +| Description : This function allocates sends the the primtive CGRLC_DISABLE_REQ +| to GRLC +| +| Parameters : prim_st - indicates if a primitive shall be deleted or not +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void tc_cgrlc_disable_req ( UBYTE prim_st ) +{ + PALLOC(cgrlc_disable_req,CGRLC_DISABLE_REQ); /*T_CGRLC_DISABLE_REQ*/ + + TRACE_FUNCTION( "tc_cgrlc_disable_req" ); + + cgrlc_disable_req->disable_class = grr_data->tc.disable_class; + cgrlc_disable_req->prim_status = prim_st; + + PSEND(hCommGRLC,cgrlc_disable_req); + +}/* tc_cgrlc_disable_req */ + + +/* ++------------------------------------------------------------------------------ +| Function : tc_cgrlc_ul_tbf_res ++------------------------------------------------------------------------------ +| Description : This function +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ + +GLOBAL void tc_cgrlc_ul_tbf_res ( UBYTE tbf_mode, UBYTE prim_status ) +{ + PALLOC(cgrlc_ul_tbf_res,CGRLC_UL_TBF_RES); /*T_CGRLC_UL_TBF_RES*/ + + TRACE_FUNCTION( "tc_cgrlc_ul_tbf_res" ); + + cgrlc_ul_tbf_res->starting_time = grr_data->uplink_tbf.tbf_start_fn; + cgrlc_ul_tbf_res->tbf_mode = tbf_mode; + cgrlc_ul_tbf_res->prim_status = prim_status; + cgrlc_ul_tbf_res->polling_bit = grr_data->uplink_tbf.polling_bit; + cgrlc_ul_tbf_res->cs_mode = grr_data->uplink_tbf.cs_mode; + cgrlc_ul_tbf_res->mac_mode = grr_data->uplink_tbf.mac_mode; + cgrlc_ul_tbf_res->nts_max = grr_data->uplink_tbf.nts; + cgrlc_ul_tbf_res->rlc_db_granted= grr_data->uplink_tbf.rlc_db_granted; + + if(grr_data->uplink_tbf.ts_usage) + { + cgrlc_ul_tbf_res->tn_mask = grr_data->uplink_tbf.ts_usage; + } + else + { + cgrlc_ul_tbf_res->tn_mask = grr_data->uplink_tbf.ts_mask; + TRACE_EVENT("UL tn mask passed to grlc instead of ts_usage"); + } + + if(grr_data->uplink_tbf.st_tfi EQ 0xFF) + cgrlc_ul_tbf_res->tfi = grr_data->uplink_tbf.tfi; + else + cgrlc_ul_tbf_res->tfi = grr_data->uplink_tbf.st_tfi; + + cgrlc_ul_tbf_res->ti = grr_data->uplink_tbf.ti; + cgrlc_ul_tbf_res->bs_cv_max = psc_db->gprs_cell_opt.bs_cv_max; + cgrlc_ul_tbf_res->tlli_cs_mode = grr_data->uplink_tbf.tlli_cs_mode; + cgrlc_ul_tbf_res->r_bit = grr_data->r_bit; + + if(cgrlc_ul_tbf_res->mac_mode EQ FA) + { + cgrlc_ul_tbf_res->fix_alloc_struct.bitmap_len = grr_data->tc.fa_ctrl.current_alloc.alloc.size_bitmap; + cgrlc_ul_tbf_res->fix_alloc_struct.end_fn = grr_data->tc.fa_ctrl.current_alloc.alloc_end_fn; + cgrlc_ul_tbf_res->fix_alloc_struct.final_alloc = grr_data->tc.fa_ctrl.current_alloc.final_alloc; + memcpy (cgrlc_ul_tbf_res->fix_alloc_struct.bitmap_array, + grr_data->tc.fa_ctrl.current_alloc.alloc.bitmap, + MAX_ALLOC_BITMAP); + } + + grr_prcs_pwr_ctrl ( &cgrlc_ul_tbf_res->pwr_ctrl, FALSE ); + + /*Reset the GRR database for parameters which are used only once*/ + grr_data->uplink_tbf.polling_bit=0xFF; + + PSEND(hCommGRLC,cgrlc_ul_tbf_res); + +}/* tc_cgrlc_ul_tbf_res */ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_cgrlc_access_status_req ++------------------------------------------------------------------------------ +| Description : This function +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ + +GLOBAL void tc_cgrlc_access_status_req ( void ) +{ + PALLOC(cgrlc_access_status_req,CGRLC_ACCESS_STATUS_REQ); /*T_CGRLC_ACCESS_STATUS_REQ*/ + + TRACE_FUNCTION( "tc_cgrlc_access_status_req" ); + + PSEND(hCommGRLC,cgrlc_access_status_req); + +}/* tc_cgrlc_access_status_req*/ + + +/* ++------------------------------------------------------------------------------ +| Function : tc_send_control_msg_to_grlc ++------------------------------------------------------------------------------ +| Description : This function +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ + +GLOBAL void tc_send_control_msg_to_grlc ( void ) +{ + UBYTE i= 0; + + TRACE_FUNCTION( "tc_send_control_msg_to_grlc" ); + + + while( i < MAX_CTRL_BLK_NUM AND + grr_data->tc.ul_ctrl_blk.seq[i] NEQ MAX_CTRL_BLK_NUM ) + { + if( grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].state + EQ BLK_STATE_ALLOCATED ) + { + PALLOC(cgrlc_data_req,CGRLC_DATA_REQ); /* T_CGRLC_DATA_REQ */ + + + cgrlc_data_req->blk_owner = grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].owner; + + memcpy(cgrlc_data_req->data_array,grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].data,23); + + PSEND(hCommGRLC,cgrlc_data_req); + + /* remove control block */ + + tc_cancel_ctrl_blk(grr_data->tc.ul_ctrl_blk.blk[grr_data->tc.ul_ctrl_blk.seq[i]].owner); + } + } + + +}/* tc_send_control_msg_to_grlc*/ + +/* ++------------------------------------------------------------------------------ +| Function : tc_cgrlc_dl_tbf_req ++------------------------------------------------------------------------------ +| Description : This function +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ + +GLOBAL void tc_cgrlc_dl_tbf_req ( void ) +{ + PALLOC(cgrlc_dl_tbf_req,CGRLC_DL_TBF_REQ); /*T_CGRLC_DL_TBF_REQ*/ + + + TRACE_FUNCTION( "tc_cgrlc_dl_tbf_req" ); + + grr_data->downlink_tbf.trans_id++; + + cgrlc_dl_tbf_req->starting_time = grr_data->downlink_tbf.tbf_start_fn; + cgrlc_dl_tbf_req->rlc_mode = grr_data->downlink_tbf.rlc_mode; + cgrlc_dl_tbf_req->mac_mode = grr_data->downlink_tbf.mac_mode; + cgrlc_dl_tbf_req->polling_bit = grr_data->downlink_tbf.polling_bit; + cgrlc_dl_tbf_req->nts_max = grr_data->downlink_tbf.nts; + + if(grr_data->downlink_tbf.ts_usage) + { + cgrlc_dl_tbf_req->tn_mask = grr_data->downlink_tbf.ts_usage; + grr_data->downlink_tbf.ts_mask = grr_data->downlink_tbf.ts_usage; /* set before starting time is elapsed */ + } + else + { + cgrlc_dl_tbf_req->tn_mask = grr_data->downlink_tbf.ts_mask; + TRACE_EVENT("DL tn mask passed to grlc instead of ts_usage"); + } + + + if(grr_data->downlink_tbf.st_tfi EQ 0xFF) + cgrlc_dl_tbf_req->tfi = grr_data->downlink_tbf.tfi; + else + cgrlc_dl_tbf_req->tfi = grr_data->downlink_tbf.st_tfi; + + cgrlc_dl_tbf_req->t3192_val = psc_db->gprs_cell_opt.t3192; + cgrlc_dl_tbf_req->ctrl_ack_bit = grr_data->downlink_tbf.ctrl_ack_bit; + + grr_prcs_pwr_ctrl ( &cgrlc_dl_tbf_req->pwr_ctrl, FALSE ); + + /*Reset the GRR database for parameters which are used only once*/ + grr_data->downlink_tbf.ctrl_ack_bit=0; + grr_data->downlink_tbf.polling_bit=0xFF; + + PSEND(hCommGRLC,cgrlc_dl_tbf_req); + + +}/* tc_cgrlc_dl_tbf_req*/ + + +/* ++------------------------------------------------------------------------------ +| Function : tc_cgrlc_tbf_rel_res ++------------------------------------------------------------------------------ +| Description : This function +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ + +GLOBAL void tc_cgrlc_tbf_rel_res ( UBYTE tbf_type ) +{ + PALLOC(cgrlc_tbf_rel_res,CGRLC_TBF_REL_RES); + + TRACE_FUNCTION( "tc_cgrlc_tbf_rel_res" ); + + switch( tbf_type ) + { + case DL_ASSIGNMENT: cgrlc_tbf_rel_res->tbf_mode = CGRLC_TBF_MODE_DL; break; + case UL_ASSIGNMENT: cgrlc_tbf_rel_res->tbf_mode = CGRLC_TBF_MODE_UL; break; + case UL_DL_ASSIGNMENT: cgrlc_tbf_rel_res->tbf_mode = CGRLC_TBF_MODE_DL_UL; break; +#if defined REL99 AND defined TI_PS_FF_TBF_EST_PACCH + case UL_TP_ACCESS: cgrlc_tbf_rel_res->tbf_mode = CGRLC_TBF_MODE_2PA; break; +#endif + } + + PSEND(hCommGRLC,cgrlc_tbf_rel_res); + +}/* tc_cgrlc_tbf_rel_res*/ + + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_cgrlc_tbf_rel_req ++------------------------------------------------------------------------------ +| Description : This function +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ + +GLOBAL void tc_cgrlc_tbf_rel_req ( UBYTE tbf_type, UBYTE rel_cause, ULONG rel_fn ) +{ + PALLOC(cgrlc_tbf_rel_req,CGRLC_TBF_REL_REQ); /*T_CGRLC_TBF_REL_REQ*/ + + TRACE_FUNCTION( "tc_cgrlc_tbf_rel_req" ); + + cgrlc_tbf_rel_req->tbf_mode = tbf_type; + cgrlc_tbf_rel_req->tbf_rel_cause = rel_cause; + cgrlc_tbf_rel_req->rel_fn = rel_fn; + + PSEND(hCommGRLC,cgrlc_tbf_rel_req); + +}/* tc_cgrlc_tbf_rel_req*/ + + + +/* ++------------------------------------------------------------------------------ +| Function : tc_cgrlc_enable_req ++------------------------------------------------------------------------------ +| Description : This function sends the primitive cgrlc_enable_req to GRLC +| +| Parameters : queue_mode - indicates the queue mode +| cu_cause - indicates if cell update is required or not +| ++------------------------------------------------------------------------------ +*/ + +GLOBAL void tc_cgrlc_enable_req ( UBYTE queue_mode, + UBYTE cu_cause, + BOOL cell_has_changed, + UBYTE enable_cause ) +{ + + PALLOC(cgrlc_enable_req,CGRLC_ENABLE_REQ); /*T_CGRLC_ENABLE_REQ*/ + + TRACE_FUNCTION( "tc_cgrlc_enable_req" ); + + cgrlc_enable_req->enable_cause = enable_cause; + cgrlc_enable_req->queue_mode = queue_mode; + cgrlc_enable_req->cu_cause = cu_cause; /* cell update request will be handled sig_ctrl_tc_enable_grlc */ + /*************Burst type handling********************************/ + cgrlc_enable_req->burst_type = psc_db->gprs_cell_opt.ctrl_ack_type; + cgrlc_enable_req->ab_type = psc_db->gprs_cell_opt.ab_type; + + /*************Counter N3102 handling*****************************/ + cgrlc_enable_req->v_pan_struct = psc_db->gprs_cell_opt.v_pan_struct; + cgrlc_enable_req->pan_struct.inc = psc_db->gprs_cell_opt.pan_struct.inc; + cgrlc_enable_req->pan_struct.dec = psc_db->gprs_cell_opt.pan_struct.dec; + if(cell_has_changed) + cgrlc_enable_req->pan_struct.pmax = (psc_db->gprs_cell_opt.pan_struct.pmax + 1 ) *4; + else + cgrlc_enable_req->pan_struct.pmax = CGRLC_NO_UPDATE_N3102; + + cgrlc_enable_req->ul_tlli = grr_data->db.ms_id.new_tlli; + cgrlc_enable_req->dl_tlli = grr_data->db.ms_id.received_tlli; + + cgrlc_enable_req->t3168_val = psc_db->gprs_cell_opt.t3168; + + if(grr_is_pbcch_present()) + + { + cgrlc_enable_req->change_mark = psc_db->psi2_params.psi2_change_mark; + if(grr_data->ms.access_ctrl_class & ~psc_db->prach.ac_class) + { + cgrlc_enable_req->ac_class = CGRLC_PCCCH_AC_ALLOWED; + } + else + { + cgrlc_enable_req->ac_class = CGRLC_PCCCH_AC_NOT_ALLOWED; + TRACE_EVENT_P3("ACCESS NOT ALLOWED PBCCH: ms_acc=%d prach_ac=%d tc_state=%d" + ,grr_data->ms.access_ctrl_class + ,psc_db->prach.ac_class + ,grr_data->tc.state); + } + } + else + { + cgrlc_enable_req->change_mark = psc_db->psi13_params.si13_change_mark; + if(grr_data->ms.access_ctrl_class & ~psc_db->prach.ac_class) + { + cgrlc_enable_req->ac_class = psc_db->net_ctrl.priority_access_thr; + } + else + { + cgrlc_enable_req->ac_class = CGRLC_PCCCH_AC_NOT_ALLOWED; + TRACE_EVENT_P3("ACCESS NOT ALLOWED CCCH: ms_acc=%d prach_ac=%d tc_state=%d" + ,grr_data->ms.access_ctrl_class + ,psc_db->prach.ac_class + ,grr_data->tc.state); + } + } + +#ifdef REL99 + cgrlc_enable_req->pfi_support = psc_db->gprs_cell_opt.gprs_ext_bits.gprs_ext_info.pfc_feature_mode; + cgrlc_enable_req->nw_rel = psc_db->network_rel; /*Network Release Order*/ +#endif + + PSEND(hCommGRLC,cgrlc_enable_req); + +}/* tc_cgrlc_enable_req*/ + +/* ++------------------------------------------------------------------------------ +| Function : grr_convert_11bit_2_etsi ++------------------------------------------------------------------------------ +| Description : Converts the 11 bit access burst value into ETSI format +| +| Parameters : In: eleven bit value +| Out: converted eleven bit +| ++------------------------------------------------------------------------------ +*/ +LOCAL USHORT grr_convert_11bit_2_etsi ( USHORT eleven_bit ) +{ + USHORT etsi11bit; + USHORT dummy1 = 0, dummy2 = 0; + + TRACE_FUNCTION( "grr_convert_11bit_2_etsi" ); + + /* + * 11 Bit access burst + * b: bit + * b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 + * should be sent to the network -according 04.60 and 0404- in the + * following 16-bit format: + * 0 0 0 0 0 b2 b1 b0 b10 b9 b8 b7 b6 b5 b4 b3 + */ + + /* + * get b2 b1 b0 + */ + dummy1 = 0x0007 & eleven_bit; + + /* + * shift it 8 bits to left + */ + dummy1 = ( dummy1 << 8 ); + + /* + * get b10 b9 b8 b7 b6 b5 b4 b3 + */ + dummy2 = 0xFFF8 & eleven_bit; + + /* + * shift it 3 bits to right + */ + dummy2 = ( dummy2 >> 3 ); + + /* + * compose dummy1 and dummy2 to the target 16-bit format + */ + etsi11bit = dummy1 | dummy2; + + return etsi11bit; + +} /* grr_convert_11bit_2_etsi() */