FreeCalypso > hg > fc-magnetite
diff src/cs/layer1/cfile/l1_afunc.c @ 69:50a15a54801e
src/cs/layer1: import from tcs211-l1-reconst project
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sat, 01 Oct 2016 23:45:38 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/cfile/l1_afunc.c Sat Oct 01 23:45:38 2016 +0000 @@ -0,0 +1,1166 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1_AFUNC.C + * + * Filename l1_afunc.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +#define L1_AFUNC_C + +#include "l1_macro.h" +#include "l1_confg.h" + +#if (CODE_VERSION == SIMULATION) + #include <string.h> + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + #include "l1_signa.h" + #if TESTMODE + #include "l1tm_defty.h" + #endif + #if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #endif + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif +//ADDED FOR AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + #include "l1_proto.h" + #include "l1_tabs.h" + #include "l1_time.h" + #if L1_GPRS + #include "l1p_cons.h" + #include "l1p_msgt.h" + #include "l1p_deft.h" + #include "l1p_vare.h" + #endif +#else + #include <string.h> + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + #include "l1_signa.h" + #include "l1_time.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + #if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #endif + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//ADDED FOR AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + #include "l1_proto.h" + #include "l1_tabs.h" + #if L1_GPRS + #include "l1p_cons.h" + #include "l1p_msgt.h" + #include "l1p_deft.h" + #include "l1p_vare.h" + #endif +#if (GSM_IDLE_RAM > 1) +#if (OP_L1_STANDALONE == 1) + #include "csmi_simul.h" +#else +#include "csmi/csmi.h" +#endif +#endif +#endif + + +#if (OP_L1_STANDALONE == 1) +#if (ANLG_FAM == 11) +#include "bspTwl3029_Madc.h" +#endif +#endif + +#if (L1_MADC_ON == 1) +#if (OP_L1_STANDALONE == 1) +#if (RF_FAM == 61) +#include "drp_api.h" +#include "l1_rf61.h" +#include <string.h> +extern T_DRP_SRM_API* drp_srm_api; +#endif +#if (ANLG_FAM == 11) +BspTwl3029_MadcResults l1_madc_results; +void l1a_madc_callback(void); +#endif +#endif +#endif //L1_MADC_ON + + + +/*-------------------------------------------------------*/ +/* l1a_reset_ba_list() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* This function resets the BA list content. */ +/* */ +/*-------------------------------------------------------*/ +void l1a_reset_ba_list() +{ + UWORD8 i; + + // Rem: this reset function do not touch the "ba_id", "nbr_carrier" and + // "radio_freq" fields. + + //!!! remove this initialization when BA list handling changed for dedic mode + if(l1a_l1s_com.mode != I_MODE) + { + l1a_l1s_com.ba_list.next_to_ctrl = 0; // Carrier for next power measurement control. + l1a_l1s_com.ba_list.next_to_read = 0; // Carrier for next power measurement result. + l1a_l1s_com.ba_list.first_index = 0; // First BA index measured in current session. + } + + // Reset of "ms_ctrl, ms_ctrl_d, msctrl_dd" is done at L1 startup + // and when SYNCHRO task is executed. + + l1a_l1s_com.ba_list.np_ctrl = 0; // PCH burst number. + + + for(i=0; i<C_BA_PM_MEAS; i++) // 2 measurements / PCH frame... + { + l1a_l1s_com.ba_list.used_il [i] = l1_config.params.il_min; // IL used in CTRL phase for AGC setting. + l1a_l1s_com.ba_list.used_il_d [i] = l1_config.params.il_min; // ... 1 frame delay. + l1a_l1s_com.ba_list.used_il_dd[i] = l1_config.params.il_min; // ... 2 frames delay, used in READ phase. + + l1a_l1s_com.ba_list.used_lna [i] = FALSE; // LNA used in CTRL phase for AGC setting. + l1a_l1s_com.ba_list.used_lna_d [i] = FALSE; // ... 1 frame delay. + l1a_l1s_com.ba_list.used_lna_dd[i] = FALSE; // ... 2 frames delay, used in READ phase. + } + + for(i=0; i<32+1; i++) + { + l1a_l1s_com.ba_list.A[i].acc = 0; // Reset IL accumulation. + } +} + +/*-------------------------------------------------------*/ +/* l1a_reset_full_list() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* This function resets the FULL list content. */ +/* */ +/*-------------------------------------------------------*/ +void l1a_reset_full_list() +{ + UWORD16 i; + + // Init power measurement multi_session process + l1a_l1s_com.full_list.meas_1st_pass_ctrl = 1; // Set 1st pass flag for power measurement session in ctrl. + l1a_l1s_com.full_list.meas_1st_pass_read = 1; // Set 1st pass flag for power measurement session in read. + l1a_l1s_com.full_list.nbr_sat_carrier_ctrl = 0; // Clear number of saturated carrier in ctrl. + l1a_l1s_com.full_list.nbr_sat_carrier_read = 0; // Clear number of saturated carrier in read. + + // Set global parameters for full list measurement. + l1a_l1s_com.full_list.next_to_ctrl = 0; // Set next carrier to control to 1st one. + l1a_l1s_com.full_list.next_to_read = 0; // Set next carrier to control to 1st one. + + // Reset Pipeline + // Note: l1a_l1s_com.full_list.ms_ctrl_d is reset at the end of l1_meas_manager() + l1a_l1s_com.full_list.ms_ctrl_dd = 0; + l1a_l1s_com.full_list.ms_ctrl_d = 0; + + // Reset the FULL LIST. + #if (L1_FF_MULTIBAND == 0) + for(i=0; i<l1_config.std.nbmax_carrier; i++) + #else + for(i=0; i< NBMAX_CARRIER; i++) + #endif + { + l1a_l1s_com.full_list.sat_flag[i] = 0; // Reset sat_flag + } + + #if L1_GPRS + // Reset PPCH burst ctrl indication + l1pa_l1ps_com.cr_freq_list.pnp_ctrl = 0; + #endif +} + +#if ((L1_EOTD == 1) && (L1_EOTD_QBIT_ACC == 1)) +/*-------------------------------------------------------*/ +/* l1a_add_time_delta() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* This function shifts a given cell timing (given as a */ +/* couple [time_alignmt, fn_offset]) by adding */ +/* a specified new time_alignmt offset (+ve or -ve */ +/* between -4999 and +4999 qb) */ +/* to that timing. */ +/* */ +/*-------------------------------------------------------*/ +void l1a_add_time_delta(UWORD32 * time_alignmt, UWORD32 * fn_offset, WORD32 delta) +{ + WORD32 new_time_alignmt = *time_alignmt + delta; + UWORD32 new_fn_offset = *fn_offset; + + if(new_time_alignmt < 0) + { + new_time_alignmt += TPU_CLOCK_RANGE; + new_fn_offset = (new_fn_offset + 1) % MAX_FN; + } + else if(new_time_alignmt >= TPU_CLOCK_RANGE) + { + new_time_alignmt -= TPU_CLOCK_RANGE; + new_fn_offset = (new_fn_offset - 1 + MAX_FN) % MAX_FN; + } + + *time_alignmt = new_time_alignmt; + *fn_offset = new_fn_offset; +} + +/*-------------------------------------------------------*/ +/* l1a_compensate_sync_ind() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* Attempts to modify the time_alignmt and fn_offset */ +/* fields of an MPHC_NCELL_SYNC_IND message based on */ +/* E-OTD cross-correlation information in order to */ +/* post-correct the result. This can be used to form a */ +/* quater-bit alignment with slow drifting neighbours */ +/* */ +/*-------------------------------------------------------*/ +void l1a_compensate_sync_ind(T_MPHC_NCELL_SYNC_IND * msg) +{ + + // This process can only be applied to SBCONF messages + // with good SCH decodes and valid EOTD results. + // + // a_eotd_crosscor [0] [1] [2] [3] [4] [5] [6] [7] [8] + // + // <------ Peak Range -----> + // + // As long as the cross-correlation peak lies in the range + // [1] to [7] then we can examine the slope of the correlation + // points on either side of the peak in order to perform a + // positive or negative QB shift. + + if((msg->sb_flag) && (msg->eotd_data_valid)) + { + WORD16 peak_index = msg->d_eotd_max - msg->d_eotd_first; + + if((peak_index >= 1) && (peak_index <= 7)) + { + UWORD32 a_power[9]; + UWORD32 pre_power, post_power, thresh_power; + UWORD32 i; + WORD32 shift = 0; + + // Calculate the normalised power of the cross-correlation samples + // in a_eotd_crosscor. This could be improved to only calculate + // the terms for [peak_index-1] [peak_index] [peak_index+1] if + // the algorithm proves viable in the long term. + + // Normalised power[i] = real[i]^2 + imag[i]^2 + + for(i=0; i<9; ++i) + { + // + // Awkward looking code to square values as our compiler / assembler + // gets the following construct wrong. Very strange... + // + // UWORD32 real = ... + // real *= real; <-- Assembler allocates registers incorrectly here + // + + UWORD32 real = msg->a_eotd_crosscor[2*i] * msg->a_eotd_crosscor[2*i]; + UWORD32 imag = msg->a_eotd_crosscor[(2*i)+1] * msg->a_eotd_crosscor[(2*i)+1]; + + // Sum of the squares... + + a_power[i] = real + imag; + } + + // By inspection of practical examples, it appears that (peak power/3) + // is a good threshold on which to compare the shape of the slope. + + thresh_power = a_power[peak_index] / 3; + pre_power = a_power[peak_index-1]; + post_power = a_power[peak_index+1]; + + // Decision on whether the gradient of the slope of the crosscor points + // on either side of the peak is large enough to cause a (max) +/- 1QB shift + // to the time_alignmt field. + + if( (pre_power < thresh_power) && (post_power > thresh_power) ) + { + // Right skew on the cross corrrelation - shift time_alignmt + // to be one greater + + shift = 1; + } + else if ( (pre_power > thresh_power) && (post_power < thresh_power) ) + { + // Left skew on the cross correlation - shift time_alignmt + // to be one less + + shift = -1; + } + + l1a_add_time_delta( &(msg->time_alignmt), + &(msg->fn_offset), + shift ); + + } + } +} +#endif + +/*-------------------------------------------------------*/ +/* l1a_add_time_for_nb() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* This function shift a given cell timing (given as a */ +/* couple [time_alignmt, fn_offset]) by adding */ +/* "SB_MARGIN - NB_MARGIN" */ +/* to that timing. */ +/* */ +/*-------------------------------------------------------*/ +void l1a_add_time_for_nb(UWORD32 *time_alignmt, UWORD32 *fn_offset) +{ + // Add "SB_MARGIN - NB_MARGIN" qbit to "fn_offset" and "time_alignmt". + // Pay attention to the modulos. + + *time_alignmt += (SB_MARGIN - NB_MARGIN); + if(*time_alignmt >= TPU_CLOCK_RANGE) + { + *time_alignmt -= TPU_CLOCK_RANGE; + *fn_offset = (*fn_offset + MAX_FN - 1) % MAX_FN; + } +} + +/*-------------------------------------------------------*/ +/* l1a_add_timeslot() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* This function shift a given cell timing (given as a */ +/* couple [time_alignmt, fn_offset]) by adding a number */ +/* of TIMESLOT (given as "tn") to that timing. */ +/* */ +/*-------------------------------------------------------*/ +void l1a_add_timeslot(UWORD32 *time_alignmt, UWORD32 *fn_offset, UWORD8 tn) +{ + // Add "tn" timeslot to "fn_offset" and "time_alignmt". + // Pay attention to the modulos. + + *time_alignmt += tn * BP_DURATION; + if(*time_alignmt >= TPU_CLOCK_RANGE) + { + *time_alignmt -= TPU_CLOCK_RANGE; + *fn_offset = (*fn_offset + MAX_FN - 1) % MAX_FN; + } +} + +/*-------------------------------------------------------*/ +/* l1a_sub_time_for_nb() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* This function shift a given cell timing (given as a */ +/* couple [time_alignmt, fn_offset]) by substacting */ +/* "SB_MARGIN - NB_MARGIN" */ +/* to that timing. */ +/* */ +/*-------------------------------------------------------*/ +void l1a_sub_time_for_nb(UWORD32 *time_alignmt, UWORD32 *fn_offset) +{ + WORD32 new_time_alignmt; + + // Sub "SB_MARGIN - NB_MARGIN" qbit to "fn_offset" and "time_alignmt". + // Pay attention to the modulos. + + new_time_alignmt = *time_alignmt - (SB_MARGIN - NB_MARGIN); + if(new_time_alignmt < 0) + { + new_time_alignmt += TPU_CLOCK_RANGE; + *fn_offset = (*fn_offset + 1) % MAX_FN; + } + *time_alignmt = new_time_alignmt; +} + +/*-------------------------------------------------------*/ +/* l1a_sub_timeslot() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* This function shift a given cell timing (given as a */ +/* couple [time_alignmt, fn_offset]) by substracting a */ +/* number of TIMESLOT (given as "tn") to that timing. */ +/* */ +/*-------------------------------------------------------*/ +void l1a_sub_timeslot(UWORD32 *time_alignmt, UWORD32 *fn_offset, UWORD8 tn) +{ + WORD32 new_time_alignmt; + + // Sub "tn" timeslot to "fn_offset" and "time_alignmt". + // Pay attention to the modulos. + new_time_alignmt = *time_alignmt - (tn * BP_DURATION); + if(new_time_alignmt < 0) + { + new_time_alignmt += TPU_CLOCK_RANGE; + *fn_offset = (*fn_offset + 1) % MAX_FN; + } + *time_alignmt = new_time_alignmt; +} + +/*-------------------------------------------------------*/ +/* l1a_correct_timing() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* */ +/*-------------------------------------------------------*/ +#if (L1_12NEIGH == 1) +void l1a_correct_timing (UWORD8 neigh_id,UWORD32 time_alignmt,UWORD32 fn_offset) +{ + // Save timing information in case of future handovers. + l1a_l1s_com.nsync.list[neigh_id].time_alignmt_mem = time_alignmt; + l1a_l1s_com.nsync.list[neigh_id].fn_offset_mem = fn_offset; + + // Sub the serving cell timeslot number to the Neigh./Serving timing + // difference to format it for L1S use. + l1a_sub_timeslot(&time_alignmt, &fn_offset, l1a_l1s_com.dl_tn); + l1a_sub_time_for_nb(&time_alignmt, &fn_offset); + + // Save neighbor information in the neighbor confirmation cell structure. + l1a_l1s_com.nsync.list[neigh_id].time_alignmt = time_alignmt; + l1a_l1s_com.nsync.list[neigh_id].fn_offset = fn_offset; +} +#endif + +/*-------------------------------------------------------*/ +/* l1a_compute_Eotd_data() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* */ +/*-------------------------------------------------------*/ +#if ((L1_12NEIGH ==1) && (L1_EOTD == 1)) +void l1a_compute_Eotd_data( UWORD8 *first_scell, UWORD8 neigh_id, UWORD32 SignalCode, xSignalHeaderRec *msg) +{ + WORD32 ta_sb_neigh; + UWORD32 fn_sb_neigh; + WORD16 d_eotd_first; + WORD32 toa_correction; + UWORD32 timetag; + + // SB case ..... + if (SignalCode == L1C_SB_INFO) + { + fn_sb_neigh = ((T_L1C_SB_INFO *)(msg->SigP))->fn_sb_neigh; + d_eotd_first= ((T_L1C_SB_INFO *)(msg->SigP))->d_eotd_first; + toa_correction = ((T_L1C_SB_INFO *)(msg->SigP))->toa_correction; + } + // SBCONF case ..... + else + { + fn_sb_neigh = ((T_L1C_SBCONF_INFO *)(msg->SigP))->fn_sb_neigh; + d_eotd_first= ((T_L1C_SBCONF_INFO *)(msg->SigP))->d_eotd_first; + toa_correction = ((T_L1C_SBCONF_INFO *)(msg->SigP))->toa_correction; + } + + // compute the true Serving/Neighbor time difference. + // 1) update time_alignmt with (23bit - d_eotd_first) delta + // 2) Add the serving cell timeslot number to the Serving/Neighbor time difference. + ta_sb_neigh = l1a_l1s_com.nsync.list[neigh_id].time_alignmt; + ta_sb_neigh += (d_eotd_first - (23))*4 + + (l1a_l1s_com.dl_tn * 625); + + // for Serving cell, timetag reference is 0 + if (*first_scell == TRUE) + { + l1a_l1s_com.nsync.fn_sb_serv = fn_sb_neigh; + l1a_l1s_com.nsync.ta_sb_serv = ta_sb_neigh; + + timetag = 0; + } + else + { + UWORD32 delta_fn; + WORD32 delta_qbit; + + delta_fn = (fn_sb_neigh - l1a_l1s_com.nsync.fn_sb_serv + MAX_FN)%MAX_FN; + delta_qbit = ta_sb_neigh - l1a_l1s_com.nsync.ta_sb_serv; + + // Set timetag + timetag = (delta_fn*5000) + (WORD32)(delta_qbit) + toa_correction; + + #if (CODE_VERSION == SIMULATION) + #if (TRACE_TYPE==5) + ((T_MPHC_NCELL_SYNC_IND *)(msg->SigP))->delta_fn = delta_fn; + ((T_MPHC_NCELL_SYNC_IND *)(msg->SigP))->delta_qbit = delta_qbit; + #endif + #endif + } + // Set timetag + ((T_MPHC_NCELL_SYNC_IND *)(msg->SigP))->timetag = timetag; + +} +#endif + +/*-------------------------------------------------------*/ +/* l1a_get_free_dedic_set() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : */ +/*-------------------------------------------------------*/ +T_DEDIC_SET *l1a_get_free_dedic_set() +{ + T_DEDIC_SET *fset; + UWORD8 i; + + // Get free set pointer. + if(l1a_l1s_com.dedic_set.aset == &(l1a_l1s_com.dedic_set.set[0])) + fset = &(l1a_l1s_com.dedic_set.set[1]); + else + fset = &(l1a_l1s_com.dedic_set.set[0]); + + // Clear free set. + fset->achan_ptr = NULL; + fset->chan1.desc.channel_type = INVALID_CHANNEL; + fset->chan1.desc_bef_sti.channel_type = INVALID_CHANNEL; + fset->chan2.desc.channel_type = INVALID_CHANNEL; + fset->chan2.desc_bef_sti.channel_type = INVALID_CHANNEL; + + fset->ma.alist_ptr = NULL; + fset->ma.freq_list.rf_chan_cnt = 0; + fset->ma.freq_list_bef_sti.rf_chan_cnt = 0; + + // Starting time. + fset->serv_sti_fn = -1; + fset->neig_sti_fn = -1; + + // Frequency redefinition flag. + fset->freq_redef_flag = FALSE; + + // Timing Advance + fset->timing_advance = 0; + fset->new_timing_advance = 0; + + // TXPWR + fset->new_target_txpwr = NO_TXPWR; + + // Cell Information + l1a_reset_cell_info(&(fset->cell_desc)); + + // Cipering. + fset->a5mode = 0; // Ciphering OFF. + + // Clear O&M test variables. + fset->dai_mode = 0; // No DAI test. + fset->chan1.tch_loop = 0; // No TCH loop on chan1. + fset->chan2.tch_loop = 0; // No TCH loop on chan2. + + // For handover... + fset->ho_acc = 0; + fset->ho_acc_to_send = 0; + fset->t3124 = 0; + +#if ((REL99 == 1) && (FF_BHO == 1)) + // For blind handover... + fset->report_time_diff = FALSE; + fset->nci = FALSE; + fset->report_time_diff = FALSE; + fset->real_time_difference = 0; + fset->HO_SignalCode = 0; +#endif + + // Reset DPAGC fifo + for(i=0;i<DPAGC_FIFO_LEN;i++) + { + fset->G_all[i] = 200; + fset->G_DTX[i] = 200; + } + + // Reset DTX_ALLOWED field. + fset->dtx_allowed = FALSE; + + #if IDS + // clear ids_mode: default value = speech mode + fset->ids_mode = 0; + #endif + +#if (AMR == 1) + // Clear the AMR ver 1.0 network settings + fset->amr_configuration.noise_suppression_bit = FALSE; + fset->amr_configuration.initial_codec_mode_indicator = FALSE; + fset->amr_configuration.initial_codec_mode = 0; + fset->amr_configuration.active_codec_set = 0; + fset->amr_configuration.threshold[0] = 0; + fset->amr_configuration.threshold[1] = 0; + fset->amr_configuration.threshold[2] = 0; + fset->amr_configuration.hysteresis[0] = 0; + fset->amr_configuration.hysteresis[1] = 0; + fset->amr_configuration.hysteresis[2] = 0; + fset->cmip = C_AMR_CMIP_DEFAULT; +#endif + return(fset); +} + +/*-------------------------------------------------------*/ +/* l1a_fill_bef_sti_param() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : */ +/*-------------------------------------------------------*/ +void l1a_fill_bef_sti_param(T_DEDIC_SET *set_ptr, BOOL start_time_present) +{ + if(start_time_present == TRUE) + // There is a STARTING TIME field... + { + if((set_ptr->ma.freq_list_bef_sti.rf_chan_cnt != 0) || + (set_ptr->chan1.desc_bef_sti.channel_type != INVALID_CHANNEL) || + (set_ptr->chan2.desc_bef_sti.channel_type != INVALID_CHANNEL)) + // There is at least one "bef_sti" parameter given for this channel. + // Other empty parameters must be filled with the according "AFTER STARTING TIME" parameters. + { + // Fill "chan1.desc_bef_sti" + if(set_ptr->chan1.desc_bef_sti.channel_type == INVALID_CHANNEL) + set_ptr->chan1.desc_bef_sti = set_ptr->chan1.desc; + + // Fill "chan2.desc_bef_sti" + if(set_ptr->chan2.desc_bef_sti.channel_type == INVALID_CHANNEL) + set_ptr->chan2.desc_bef_sti = set_ptr->chan2.desc; + + // Fill "freq_list_bef_sti" + if(set_ptr->ma.freq_list_bef_sti.rf_chan_cnt == 0) + set_ptr->ma.freq_list_bef_sti = set_ptr->ma.freq_list; + } + } +} + +/*-------------------------------------------------------*/ +/* l1a_decode_starting_time() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : */ +/*-------------------------------------------------------*/ +WORD32 l1a_decode_starting_time(T_STARTING_TIME coded_starting_time) +{ + WORD32 starting_time; + + if(coded_starting_time.start_time_present == TRUE ) + // A starting time is present. + // --------------------------- + { + WORD32 tp1 = coded_starting_time.start_time.n32; + WORD32 t2 = coded_starting_time.start_time.n26; + WORD32 t3 = coded_starting_time.start_time.n51; + + // Compute STI. + starting_time = 51*((26 + t3 - t2) % 26) + t3 + (51*26*tp1) ; + } + else + { + starting_time = -1; + } + + return(starting_time); +} + +/*-------------------------------------------------------*/ +/* l1a_reset_cell_info() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : */ +/*-------------------------------------------------------*/ +void l1a_reset_cell_info(T_CELL_INFO *cell_info) +{ + cell_info->bsic = 0; + cell_info->fn_offset = 0; + cell_info->time_alignmt = 0; + cell_info->meas.acc = 0; + cell_info->meas.nbr_meas = 0; + cell_info->attempt_count = 0; + cell_info->si_bit_map = 0; + + cell_info->traffic_meas.input_level = l1_config.params.il_min; + cell_info->traffic_meas_beacon.input_level = l1_config.params.il_min; + cell_info->traffic_meas.lna_off = FALSE; + cell_info->traffic_meas_beacon.lna_off = FALSE; + + cell_info->buff_beacon[0] = cell_info->buff_beacon[1] = cell_info->buff_beacon[2] = + cell_info->buff_beacon[3] = l1_config.params.il_min; + + #if L1_GPRS + cell_info->transfer_meas.input_level = l1_config.params.il_min; + cell_info->transfer_meas.lna_off = FALSE; + cell_info->pb = 0; + #endif +} + +/*-------------------------------------------------------*/ +/* l1a_send_confirmation() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : */ +/*-------------------------------------------------------*/ +void l1a_send_confirmation(UWORD32 SignalCode, UWORD8 queue_type) +{ + xSignalHeaderRec *msg; + + msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + msg->SignalCode = (int)SignalCode; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(msg); + #endif + + + #if (OP_L1_STANDALONE == 1) + os_send_sig(msg, queue_type); + #else + os_send_sig(msg, ((T_ENUM_OS_QUEUE)queue_type)); //omaps00090550 + #endif + + + DEBUGMSG(status,NU_SEND_QUEUE_ERR) +} + +/*-------------------------------------------------------*/ +/* l1a_send_result() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : */ +/*-------------------------------------------------------*/ +void l1a_send_result(UWORD32 SignalCode, xSignalHeaderRec *msg, UWORD8 queue) +{ + // Set flag to avoid the FREE(msg) in L1ASYNC. + l1a.l1_msg_forwarded = TRUE; + + msg->SignalCode = (int)SignalCode; + + // May not be necessary -> to check + + #if (GSM_IDLE_RAM > 1) + if (!READ_TRAFFIC_CONT_STATE) + { + CSMI_TrafficControllerOn(); + } + #endif + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(msg); + #endif + + #if (OP_L1_STANDALONE == 1) + os_send_sig(msg, queue); + #else +os_send_sig(msg, ((T_ENUM_OS_QUEUE)queue)); //omaps00090550 + #endif + + + DEBUGMSG(status,NU_SEND_QUEUE_ERR) +} + +/*-------------------------------------------------------*/ +/* l1a_encode_rxqual() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : */ +/*-------------------------------------------------------*/ +UWORD8 l1a_encode_rxqual (UWORD32 inlevel) +{ + enum qual_thr + { + thr_0_2 = 4, + thr_0_4 = 8, + thr_0_8 = 16, + thr_1_6 = 32, + thr_3_2 = 64, + thr_6_4 = 128, + thr_12_8 = 256 + }; + + UWORD8 rxqual; + + if (inlevel < thr_0_2) rxqual = 0; + else + if (inlevel < thr_0_4) rxqual = 1; + else + if (inlevel < thr_0_8) rxqual = 2; + else + if (inlevel < thr_1_6) rxqual = 3; + else + if (inlevel < thr_3_2) rxqual = 4; + else + if (inlevel < thr_6_4) rxqual = 5; + else + if (inlevel < thr_12_8) rxqual = 6; + else rxqual = 7; + + return((UWORD8) rxqual); +} + +/*-------------------------------------------------------*/ +/* l1a_report_failling_ncell_sync() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : */ +/*-------------------------------------------------------*/ +void l1a_report_failling_ncell_sync(UWORD32 SignalCode, UWORD8 neigh_id) +{ + xSignalHeaderRec *msg; + + // Send MPHC_NCELL_SYNC_IND message to L3 with a FAILLURE indication. + msg = os_alloc_sig(sizeof(T_MPHC_NCELL_SYNC_IND)); + DEBUGMSG(status,NU_ALLOC_ERR) + + msg->SignalCode = SignalCode; + ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->sb_flag = FALSE; + ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->radio_freq = l1a_l1s_com.nsync.list[neigh_id].radio_freq; + ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->bsic = 0; + ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->fn_offset = 0; + ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->time_alignmt = 0; + + // For trace/debug only + ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->neigh_id = neigh_id; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(msg); + #endif + + os_send_sig(msg, RRM1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) +} + + +/*-------------------------------------------------------*/ +/* l1a_clip_txpwr() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : */ +/*-------------------------------------------------------*/ +#if (L1_FF_MULTIBAND == 0) + +UWORD8 l1a_clip_txpwr (UWORD8 supplied_txpwr, UWORD16 radio_freq) +{ + #define txpwr_to_compare(pwr) ((pwr<=l1_config.std.txpwr_turning_point)? pwr+32:pwr) + + switch(l1_config.std.id) + { + case GSM: + case GSM_E: + { + // Clip LOW according to powerclass_band1. + if ( supplied_txpwr < MIN_TXPWR_GSM[l1a_l1s_com.powerclass_band1]) + return(MIN_TXPWR_GSM[l1a_l1s_com.powerclass_band1]); + + // Clip HIGH according to GSM spec. 05.05. + if ( supplied_txpwr > l1_config.std.max_txpwr_band1) + return(l1_config.std.max_txpwr_band1); + } + break; + + case PCS1900: + { + // Clip LOW according to powerclass_band1. + if ( txpwr_to_compare(supplied_txpwr) < + txpwr_to_compare(MIN_TXPWR_PCS[l1a_l1s_com.powerclass_band1]) ) + return(MIN_TXPWR_PCS[l1a_l1s_com.powerclass_band1]); + + // Clip HIGH according to GSM spec. 05.05. + if ( txpwr_to_compare(supplied_txpwr) > + txpwr_to_compare(l1_config.std.max_txpwr_band1) ) + return(l1_config.std.max_txpwr_band1); + } + break; + + case DCS1800: + { + // Clip LOW according to powerclass_band1. + if ( txpwr_to_compare(supplied_txpwr) < + txpwr_to_compare(MIN_TXPWR_DCS[l1a_l1s_com.powerclass_band1]) ) + return(MIN_TXPWR_DCS[l1a_l1s_com.powerclass_band1]); + + // Clip HIGH according to GSM spec. 05.05. + if ( txpwr_to_compare(supplied_txpwr) > + txpwr_to_compare(l1_config.std.max_txpwr_band1) ) + return(l1_config.std.max_txpwr_band1); + } + break; + + case GSM850: + { + // Clip LOW according to powerclass_band1. + if ( txpwr_to_compare(supplied_txpwr) < + txpwr_to_compare(MIN_TXPWR_GSM850[l1a_l1s_com.powerclass_band1]) ) + return(MIN_TXPWR_GSM850[l1a_l1s_com.powerclass_band1]); + + // Clip HIGH according to GSM spec. 05.05. + if ( txpwr_to_compare(supplied_txpwr) > + txpwr_to_compare(l1_config.std.max_txpwr_band1) ) + return(l1_config.std.max_txpwr_band1); + } + break; + + case DUAL: + case DUALEXT: + { + // Test which Band is used: GSM or DCS 1800 + if (radio_freq >= l1_config.std.first_radio_freq_band2) + { + // Clip LOW according to powerclass_band1. + if ( txpwr_to_compare(supplied_txpwr) < + txpwr_to_compare(MIN_TXPWR_DCS[l1a_l1s_com.powerclass_band2]) ) + return(MIN_TXPWR_DCS[l1a_l1s_com.powerclass_band2]); + + // Clip HIGH according to GSM spec. 05.05. + if ( txpwr_to_compare(supplied_txpwr) > + txpwr_to_compare(l1_config.std.max_txpwr_band2) ) + return(l1_config.std.max_txpwr_band2); + } + else + { + // Clip LOW according to powerclass_band1. + if ( supplied_txpwr < MIN_TXPWR_GSM[l1a_l1s_com.powerclass_band1]) + return(MIN_TXPWR_GSM[l1a_l1s_com.powerclass_band1]); + + // Clip HIGH according to GSM spec. 05.05. + if ( supplied_txpwr > l1_config.std.max_txpwr_band1) + return(l1_config.std.max_txpwr_band1); + } + } + break; + + + case DUAL_US: + { + // Test which Band is used: GSM 850 or PCS1900 + if (radio_freq >= l1_config.std.first_radio_freq_band2) + { + // Clip LOW according to powerclass_band1. + if ( txpwr_to_compare(supplied_txpwr) < + txpwr_to_compare(MIN_TXPWR_PCS[l1a_l1s_com.powerclass_band2]) ) + return(MIN_TXPWR_PCS[l1a_l1s_com.powerclass_band2]); + + // Clip HIGH according to GSM spec. 05.05. + if ( txpwr_to_compare(supplied_txpwr) > + txpwr_to_compare(l1_config.std.max_txpwr_band2) ) + return(l1_config.std.max_txpwr_band2); + } + else + { + // Clip LOW according to powerclass_band1. + if ( supplied_txpwr < MIN_TXPWR_GSM850[l1a_l1s_com.powerclass_band1]) + return(MIN_TXPWR_GSM850[l1a_l1s_com.powerclass_band1]); + + // Clip HIGH according to GSM spec. 05.05. + if ( supplied_txpwr > l1_config.std.max_txpwr_band1) + return(l1_config.std.max_txpwr_band1); + } + } + break; + + + default: // should never occur + { + return(supplied_txpwr); + } + // omaps00090550 break; + } + return(supplied_txpwr); +} + +#else /*L1_FF_MULTIBAND = 1 below */ + +UWORD8 l1a_clip_txpwr (UWORD8 supplied_txpwr, UWORD16 radio_freq) +{ + + + UWORD8 physical_band_id = 0; + physical_band_id = l1_multiband_radio_freq_convert_into_physical_band_id(radio_freq); + #define txpwr_to_compare(pwr) ((pwr<= multiband_rf[physical_band_id].tx_turning_point)? pwr+32:pwr) + switch(multiband_rf[physical_band_id].gsm_band_identifier) + { + case RF_GSM900: + { + + // Clip LOW according to powerclass_band1. + if ( supplied_txpwr < MIN_TXPWR_GSM[l1a_l1s_com.powerclass[physical_band_id]]) + return(MIN_TXPWR_GSM[l1a_l1s_com.powerclass[physical_band_id]]); + + // Clip HIGH according to GSM spec. 05.05. + if ( supplied_txpwr > multiband_rf[physical_band_id].max_txpwr) + return(multiband_rf[physical_band_id].max_txpwr); + break; + }/*case GSM900*/ + + case RF_PCS1900: + { + // Clip LOW according to powerclass_band1. + if ( txpwr_to_compare(supplied_txpwr) < + txpwr_to_compare(MIN_TXPWR_PCS[l1a_l1s_com.powerclass[physical_band_id]]) ) + return(MIN_TXPWR_PCS[l1a_l1s_com.powerclass[physical_band_id]]); + + // Clip HIGH according to GSM spec. 05.05. + if ( txpwr_to_compare(supplied_txpwr) > + txpwr_to_compare(multiband_rf[physical_band_id].max_txpwr) ) + return(multiband_rf[physical_band_id].max_txpwr); + break; + }/*case PCS1900*/ + + case RF_DCS1800: + { + // Clip LOW according to powerclass_band1. + if ( txpwr_to_compare(supplied_txpwr) < + txpwr_to_compare(MIN_TXPWR_DCS[l1a_l1s_com.powerclass[physical_band_id]]) ) + return(MIN_TXPWR_DCS[l1a_l1s_com.powerclass[physical_band_id]]); + + // Clip HIGH according to GSM spec. 05.05. + if ( txpwr_to_compare(supplied_txpwr) > + txpwr_to_compare(multiband_rf[physical_band_id].max_txpwr) ) + return(multiband_rf[physical_band_id].max_txpwr); + break; + }/*case DCS1800*/ + + case RF_GSM850: + { + // Clip LOW according to powerclass_band1. + if ( txpwr_to_compare(supplied_txpwr) < + txpwr_to_compare(MIN_TXPWR_GSM850[l1a_l1s_com.powerclass[physical_band_id]]) ) + return(MIN_TXPWR_GSM850[l1a_l1s_com.powerclass[physical_band_id]]); + + // Clip HIGH according to GSM spec. 05.05. + if ( txpwr_to_compare(supplied_txpwr) > + txpwr_to_compare(multiband_rf[physical_band_id].max_txpwr) ) + return(multiband_rf[physical_band_id].max_txpwr); + break; + }/*case GSM850*/ + + default: // should never occur + { + l1_multiband_error_handler(); + return(supplied_txpwr); + break; + } /*default*/ + + }/*switch(multiband_rfphysical_band_id].gsm_band_identifier)*/ + return(supplied_txpwr); + +} + +#endif /*L1_FF_MULTIBAND */ + + +//MADC + +#if (L1_MADC_ON == 1) +#if (OP_L1_STANDALONE == 1) +#if (ANLG_FAM == 11) +void l1a_madc_callback(void) +{ + char str[40]; + + + + xSignalHeaderRec *adc_msg; + UWORD16 *adc_result; + UWORD16 *madc_results; + volatile UWORD16 *drp_temp_results; + +#if (RF_FAM == 61) + drp_temp_results =(volatile UWORD16 *) (&drp_srm_api->inout.temperature.output); //omaps00090550 +#endif + +#if 0 + sprintf(str, "Temp Measure %x ", drp_temp_results); + + //L1_trace_string ("Temp Meas\n"); + L1_trace_string(str); +#endif + +#if 0 + int i; + + adc_msg = os_alloc_sig(sizeof(BspTwl3029_MadcResults) + sizeof(UWORD16)); + adc_result = &((BspTwl3029_MadcResults*)(adc_msg->SigP))->adc1; + madc_results =& l1_madc_results.adc1; + + //TEMP_MEAS: DRP +#if (RF_FAM == 61) + drp_temp_results =& (drp_srm_api->inout.temperature.output); +#endif + + //copy the measured values into the the message structure. + memcpy(adc_result,madc_results,11*sizeof(UWORD16));//11 madc + adc_result[11] = *drp_temp_results; // 1 temp meas + /* + for (i=0;i<11;i++) + adc_result[i] = madc_results[i]; + */ + //Send the message + adc_msg->SignalCode = CST_ADC_RESULT; + os_send_sig(adc_msg, RRM1_QUEUE); +#endif +} +#endif // ANLG_FAM == 11 +#endif //OP_L1_STANDALONE +#endif // L1_MADC_ON + +//============================================================================================== +