FreeCalypso > hg > fc-tourmaline
view src/g23m-gprs/grr/grr_tcf.c @ 268:f2e52cab0a73
abb_inth.c: check all interrupt causes, not just one
The original code used if - else if - else if etc constructs, thus
the first detected interrupt was the only one handled. However,
Iota ITSTATREG is a clear-on-read register, thus if we only handle
the first detected interrupt and skip checking the others, then the
other interrupts will be lost, if more than one interrupt happened
to occur in one ABB interrupt handling cycle - a form of rare race
condition. Change the code to check all interrupts that were read
in this cycle.
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sun, 13 Jun 2021 18:17:53 +0000 |
| parents | fa8dc04885d8 |
| children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : GPRS (8441) | Modul : GRR +----------------------------------------------------------------------------- | Copyright 2002 Texas Instruments Berlin, AG | All rights reserved. | | This file is confidential and a trade secret of Texas | Instruments Berlin, AG | The receipt of or possession of this file does not convey | any rights to reproduce or disclose its contents or to | manufacture, use, or sell anything it may describe, in | whole, or in part, without the specific written consent of | Texas Instruments Berlin, AG. +----------------------------------------------------------------------------- | Purpose : This module implements 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() */