FreeCalypso > hg > fc-selenite
diff src/cs/layer1/p_cfile/l1p_cmpl.c @ 0:b6a5e36de839
src/cs: initial import from Magnetite
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sun, 15 Jul 2018 04:39:26 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/p_cfile/l1p_cmpl.c Sun Jul 15 04:39:26 2018 +0000 @@ -0,0 +1,3886 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1P_CMPL.C + * + * Filename l1p_cmpl.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +#define L1P_CMPL_C + +//#pragma DUPLICATE_FOR_INTERNAL_RAM_START + +#include "l1_macro.h" +#include "l1_confg.h" + +#if L1_GPRS +#if (CODE_VERSION == SIMULATION) + #include <string.h> + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + #include "l1_time.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_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.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 + #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_trace.h" + #if L2_L3_SIMUL + #include "l2_l3.h" + #include "hw_debug.h" + #endif + + #include "l1p_cons.h" + #include "l1p_msgt.h" + #include "l1p_deft.h" + #include "l1p_vare.h" + #include "l1p_sign.h" + + #if TESTMODE + #include "l1tm_msgty.h" + #include "l1tm_signa.h" + #endif + + #include "macs_def.h" + #include "macs_cst.h" + + #include "sim_cons.h" + #include "sim_def.h" + extern T_hw FAR hw; + +#else + #include <string.h> + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + #include "l1_time.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_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.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 + #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_trace.h" + + #if L2_L3_SIMUL + #include "l2_l3.h" + #include "hw_debug.h" + #endif + + #include "l1p_cons.h" + #include "l1p_msgt.h" + #include "l1p_deft.h" + #include "l1p_vare.h" + #include "l1p_sign.h" + + #if TESTMODE + #include "l1tm_msgty.h" + #include "l1tm_signa.h" + #endif + + #include "macs_def.h" + #include "macs_cst.h" +#endif + +#if(RF_FAM == 61) + #include "l1_rf61.h" + #include "tpudrv61.h" +#endif + +#include "l1_ctl.h" + +/*-------------------------------------------------------*/ +/* Prototypes of external functions used in this file. */ +/*-------------------------------------------------------*/ +void l1dmacro_synchro (UWORD32 when, UWORD32 value); +void l1dmacro_offset (UWORD32 offset_value, WORD32 relative_time); +void l1dmacro_rx_synth (UWORD16 arfcn); +void l1dmacro_agc (UWORD16 arfcn,WORD8 gain, UWORD8 lna + #if (RF_FAM == 61) + ,UWORD8 if_ctl + #endif + ); +#if (L1_MADC_ON == 1) +#if (RF_FAM == 61) +void l1dmacro_rx_nb (UWORD16 arfcn, UWORD8 adc_active, UWORD8 csf_filter_choice +#if (NEW_SNR_THRESHOLD == 1) + ,UWORD8 saic_flag +#endif /* NEW_SNR_THRESHOLD */ + ); +#endif /* RF_FAM == 61*/ +#else /* L1_MADC_ON == 1*/ +void l1dmacro_rx_nb (UWORD16 arfcn); +#endif /* L1_MADC_ON == 1*/ + +void l1dmacro_afc (UWORD16 afc_value, UWORD8 win_id); +#if (RF_FAM == 61) + void l1dtpu_serv_rx_nb (UWORD16 radio_freq, WORD8 agc, UWORD8 lna_off, + UWORD32 synchro_serv,UWORD32 new_offset,BOOL change_offset, + UWORD8 adc_active, UWORD8 csf_filter_choice, + UWORD8 if_ctl +#if (NEW_SNR_THRESHOLD == 1) + ,UWORD8 saic_flag +#endif /* NEW_SNR_THRESHOLD */ + ); + + void l1pdtpu_serv_rx_nb (UWORD16 radio_freq, WORD8 agc, BOOL lna_off, + UWORD8 rx_id, UWORD32 offset_serv, UWORD8 num_rx, + UWORD8 rx_group_id, BOOL rx_done_flag, + UWORD8 adc_active, UWORD8 csf_filter_choice, + UWORD8 if_ctl +#if (NEW_SNR_THRESHOLD == 1) + ,UWORD8 saic_flag +#endif /* NEW_SNR_THRESHOLD */ + ); +#endif /* RF_FAM == 61*/ +#if(RF_FAM != 61) +void l1dtpu_serv_rx_nb (UWORD16 radio_freq, WORD8 agc, UWORD8 lna_off, + UWORD32 synchro_serv,UWORD32 new_offset,BOOL change_offset, UWORD8 adc_active); + +void l1pdtpu_serv_rx_nb (UWORD16 radio_freq, WORD8 agc, BOOL lna_off, + UWORD8 rx_id, UWORD32 offset_serv, UWORD8 num_rx, + UWORD8 rx_group_id, BOOL rx_done_flag,UWORD8 adc_active); +#endif +void l1pdtpu_serv_tx (UWORD16 radio_freq, UWORD8 timing_advance, + UWORD32 offset_serv, UWORD8 tx_id, UWORD8 num_tx, + UWORD8 tx_group_id, UWORD8 switch_flag, BOOL burst_type, + BOOL rx_flag,UWORD8 adc_active); +UWORD8 l1pdtpu_interf_meas (UWORD16 radio_freq, + WORD8 agc, + UWORD8 lna_off, + UWORD8 meas_bitmap, + UWORD32 offset_serv, + UWORD16 win_id, + UWORD8 synchro_ts + #if(RF_FAM == 61) + ,UWORD8 if_ctl + #endif + ); + +void l1s_read_l3frm (UWORD8 pwr_level, API *info_address, UWORD32 task_rx); +void l1ps_macs_read (UWORD8 pr_table[8]); +void l1ps_macs_ctrl (void); +#if TESTMODE + void l1ps_tmode_macs_ctrl (void); +#endif +void l1pddsp_transfer_mslot_power (UWORD8 *txpwr, UWORD16 radio_freq, UWORD8 ul_bitmap); + +void l1pddsp_single_tx_block (UWORD8 burst_nb, UWORD8 *data, UWORD8 tsc, + UWORD16 radio_freq); +void l1pddsp_idle_prach_data (BOOL polling, UWORD8 cs_type, UWORD16 channel_request_data, + UWORD8 bsic, UWORD16 radio_freq); +void l1pddsp_idle_prach_power (UWORD8 txpwr, UWORD16 radio_freq, UWORD8 ts); +#if FF_L1_IT_DSP_USF +void l1pddsp_idle_rx_nb (UWORD8 burst_nb, UWORD8 tsq, UWORD16 radio_freq, + UWORD8 timeslot_no, BOOL ptcch_dl, BOOL usf_interrupt); +#else +void l1pddsp_idle_rx_nb (UWORD8 burst_nb, UWORD8 tsq, UWORD16 radio_freq, + UWORD8 timeslot_no, BOOL ptcch_dl); +#endif + +void l1pddsp_ul_ptcch_data (UWORD8 cs_type, UWORD16 channel_request_data, UWORD8 bsic, UWORD16 radio_freq, UWORD8 timeslot_no); +void l1ps_tcr_ctrl (UWORD8 pm_position); +void l1pd_afc (void); +void l1pddsp_interf_meas_ctrl (UWORD8 nb_meas_req); +void l1pddsp_meas_ctrl (UWORD8 nbmeas, UWORD8 pm_pos); +void maca_power_control (UWORD8 assignment_id, BOOL crc_error, WORD8 bcch_level, UWORD16 *radio_freq, WORD8 *burst_level, UWORD8 *pch); +WORD16 l1s_encode_rxlev (UWORD8 inlevel); + +void l1pctl_pagc_ctrl (WORD8 *agc, UWORD8 *lna_off, UWORD16 radio_freq,UWORD8 serving_cell); +UWORD8 l1pctl_pagc_read (UWORD8 pm, UWORD16 radio_freq); +void l1pctl_transfer_agc_ctrl (WORD8 *agc, UWORD8 *lna_off, UWORD16 radio_freq); +void l1pctl_npc_agc_read (UWORD8 calibrated_IL[8], + T_DB_DSP_TO_MCU_GPRS *pdsp_db_r_ptr, + T_NDB_MCU_DSP_GPRS *pdsp_ndb_ptr); +void l1pctl_dpcma_agc_read (UWORD8 calibrated_IL[8], + T_DB_DSP_TO_MCU_GPRS *pdsp_db_r_ptr, + T_NDB_MCU_DSP_GPRS *pdsp_ndb_ptr, + UWORD8 pr_table[8]); +void l1pctl_dpcmb_agc_read (UWORD8 calibrated_IL[8], + T_DB_DSP_TO_MCU_GPRS *pdsp_db_r_ptr, + T_NDB_MCU_DSP_GPRS *pdsp_ndb_ptr, + UWORD8 pr_table[8]); +void l1ps_macs_header_decoding (UWORD8 rx_no, UWORD8 *tfi_result, UWORD8 *pr); +void l1ps_update_read_set_parameters(void); +void l1ps_bcch_meas_ctrl (UWORD8 ts); + +//#pragma DUPLICATE_FOR_INTERNAL_RAM_END + + +/*-------------------------------------------------------*/ +/* l1ps_ctrl_single() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* */ +/* Input parameters: */ +/* ----------------- */ +/* */ +/* Input parameters from globals: */ +/* ------------------------------ */ +/* */ +/* Modified parameters from globals: */ +/* --------------------------------- */ +/* */ +/*-------------------------------------------------------*/ +void l1ps_ctrl_single(UWORD8 task, UWORD8 burst_id) +{ + UWORD16 radio_freq; + T_INPUT_LEVEL *IL_info_ptr; + #if (RF_FAM == 61) + UWORD16 dco_algo_ctl_nb = 0; + UWORD8 if_ctl = 0; + UWORD8 if_threshold = C_IF_ZERO_LOW_THRESHOLD_GPRS; + // By default we choose the hardware filter + UWORD8 csf_filter_choice = L1_SAIC_HARDWARE_FILTER; + #endif + #if (NEW_SNR_THRESHOLD == 1) + UWORD8 saic_flag=0; + #endif /* NEW_SNR_THRESHOLD */ + // needs to be defined for maca_power_control() function call + #define DL_pwr_ctrl l1pa_l1ps_com.transfer.dl_pwr_ctrl + + if((l1a_l1s_com.l1s_en_task[task] == TASK_ENABLED) && + !(l1a_l1s_com.task_param[task] == SEMAPHORE_SET)) + // Check the task semaphore. The control body is executed only + // when the task semaphore is 0. This semaphore can be set to + // 1 whenever L1A makes some changes to the task parameters. + { + // Catch ARFCN. + // ************* + + // Get ARFCN to be used for current control. + radio_freq = l1a_l1s_com.dedic_set.radio_freq; + + // Traces and debug. + // ****************** + + #if (TRACE_TYPE==5) && FLOWCHART + trace_flowchart_dsp_tpu(dltsk_trace[task].name); + if(burst_id == BURST_1) trace_flowchart_dsptx(dltsk_trace[task].name); + #endif + + #if (TRACE_TYPE!=0) + if (l1pa_l1ps_com.transfer.single_block.activity & (SINGLE_DL | SINGLE_UL)) // trace only if a window is programmed + trace_fct(CST_L1PS_CTRL_SINGLE, radio_freq); + #endif + + l1s_dsp_com.dsp_db_w_ptr->d_debug = (l1s.debug_time + 2) ; + + /**************************************************************************/ + /* Program DSP for mulstislot operation... */ + /**************************************************************************/ + /*===============*/ + /* Downlink */ + /*===============*/ + if(l1pa_l1ps_com.transfer.single_block.activity & SINGLE_DL) + { + // Programs DSP. + #if FF_L1_IT_DSP_USF + l1pddsp_idle_rx_nb(burst_id, + l1pa_l1ps_com.transfer.aset->tsc, + radio_freq, + 0, + FALSE, + FALSE); + #else + l1pddsp_idle_rx_nb(burst_id, + l1pa_l1ps_com.transfer.aset->tsc, + radio_freq, + 0, + FALSE); + #endif + + // Flag DSP programmation. + // Set "CTRL_RX" flag in the controle flag registers. + l1s.dsp_ctrl_reg |= CTRL_RX; + } + + /*===============*/ + /* Uplink */ + /*===============*/ + if(l1pa_l1ps_com.transfer.single_block.activity & SINGLE_UL) + { + // Pgme DSP for Single block TX on TS=3. + l1pddsp_single_tx_block (burst_id, + l1pa_l1ps_com.transfer.single_block.data_array, + l1pa_l1ps_com.transfer.aset->tsc, + radio_freq); + + // TXPWR control needs to take into account ALPHA, GAMMA and C values, not only TXPWR MAX + // => maca_power_control() needs to be called + // Initialization of txpwr control values for all time slots + { + UWORD8 txpwr[8]; + UWORD8 i; + + // Call Uplink Transmit Power level algorithm +#if 0 /* LoCosto version */ + maca_power_control(l1pa_l1ps_com.transfer.aset->assignment_id, +#else /* TCS211 reconstruction */ + maca_power_control(DL_pwr_ctrl.assignment_id, +#endif + DL_pwr_ctrl.crc_error, + DL_pwr_ctrl.bcch_level, + DL_pwr_ctrl.radio_freq_tbl, + DL_pwr_ctrl.burst_level, + txpwr); + + for(i = 0; i < 8; i++) + { + l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr[i] = txpwr[i]; + } + } + + // Pgme DSP for Transmit power on TS=3. + l1pddsp_transfer_mslot_power(l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr, radio_freq, 0x80 >> 3); + + // Flag DSP programmation. + // Set "CTRL_TX" flag in the controle flag registers. + l1s.dsp_ctrl_reg |= CTRL_TX; + } + + /**************************************************************************/ + /* Program TPU for single slot operation... */ + /**************************************************************************/ + + /*===============*/ + /* Downlink */ + /*===============*/ + if(l1pa_l1ps_com.transfer.single_block.activity & SINGLE_DL) + { + WORD8 agc; + UWORD8 lna_off; + + // Update AGC + l1pctl_transfer_agc_ctrl(&agc, &lna_off, radio_freq); + + + #if (RF_FAM == 61) + // Locosto DCO + + cust_get_if_dco_ctl_algo(&dco_algo_ctl_nb, &if_ctl, (UWORD8) L1_IL_VALID, + l1a_l1s_com.Scell_used_IL.input_level , + radio_freq, if_threshold); + l1ddsp_load_dco_ctl_algo_nb(dco_algo_ctl_nb); + + #if (L1_SAIC != 0) + // If SAIC is enabled, call the low level SAIC control function + // NOTE: l1a_l1s_com.Scell_used_IL.input_level is updated within + // the l1pctl_transfer_agc_ctrl above + csf_filter_choice = l1ctl_saic(l1a_l1s_com.Scell_used_IL.input_level,l1a_l1s_com.mode + #if (NEW_SNR_THRESHOLD == 1) + ,task + ,&saic_flag + #endif + ); + #endif + + // tpu pgm... + l1pdtpu_serv_rx_nb(radio_freq, + agc, + lna_off, + 0, + l1s.tpu_offset, + 1, + 1, + TRUE, + INACTIVE, + csf_filter_choice, + if_ctl + #if (NEW_SNR_THRESHOLD == 1) + ,saic_flag + #endif /* NEW_SNR_THRESHOLD */ + ); + #endif /* RF_FAM == 61*/ + #if (RF_FAM != 61) + // tpu pgm... + #if (L1_SAIC != 0) + // If SAIC is enabled, call the low level SAIC control function + // NOTE: l1a_l1s_com.Scell_used_IL.input_level is updated within + // the l1pctl_transfer_agc_ctrl above + l1ctl_saic(l1a_l1s_com.Scell_used_IL.input_level,l1a_l1s_com.mode + #if (NEW_SNR_THRESHOLD == 1) + ,task + #endif + ); + #endif + + + l1pdtpu_serv_rx_nb(radio_freq, + agc, + lna_off, + 0, + l1s.tpu_offset, + 1, + 1, + TRUE, + INACTIVE); + #endif + + // Set tpu window identifier for Synthesizer and + // according to last RX group position. + l1s.tpu_win = l1_config.params.rx_synth_load_split + RX_SPLIT_TABLE[0]; + + // Flag TPU programmation. + // Set "CTRL_RX" flag in the controle flag registers. + l1s.tpu_ctrl_reg |= CTRL_RX; + } + + /*===============*/ + /* Uplink */ + /*===============*/ + if(l1pa_l1ps_com.transfer.single_block.activity & SINGLE_UL) + { + // Program single block UL slot. + // ****************************** + l1pdtpu_serv_tx(radio_freq, + l1pa_l1ps_com.transfer.aset->packet_ta.ta, + l1s.tpu_offset, + 3, + 1, + 1, + 0, + TX_NB_BURST, + l1pa_l1ps_com.transfer.single_block.activity & SINGLE_DL, + INACTIVE); + + // Set tpu window identifier for Synthesizer and + // according to last TX group position. + l1s.tpu_win =(UWORD16)( (l1_config.params.rx_synth_load_split) + + ((UWORD16)3 * BP_SPLIT) + l1_config.params.tx_nb_load_split); + + // Flag TPU programmation. + // Set "CTRL_TX" flag in the controle flag registers. + l1s.tpu_ctrl_reg |= CTRL_TX; + + #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + RTTL1_FILL_UL_NB(task, l1pa_l1ps_com.transfer.aset->packet_ta.ta, l1s.applied_txpwr) + #endif + } + + /*===============*/ + /* General */ + /*===============*/ + if(burst_id == BURST_4) + { + // Single block UL is now complete, reset its activity flag. + l1pa_l1ps_com.transfer.single_block.activity &= SINGLE_UL_MASK; + + if(l1pa_l1ps_com.transfer.aset->allocated_tbf == SINGLE_BLOCK_DL) + { + // Single block UL is now complete. + l1pa_l1ps_com.transfer.single_block.activity &= SINGLE_DL_MASK; + } + } + } // End if(task enabled and semaphore false) + + else + // When the task is aborted, we must continue to make dummy + // DSP programming to avoid communication mismatch due + // to C/W/R pipelining. + { + // Flag dummy DSP programmation. + // Set "CTRL_TX" flag in the controle flag registers. + l1s.dsp_ctrl_reg |= CTRL_TX; + } +} + +/*-------------------------------------------------------*/ +/* l1ps_ctrl_prach() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* */ +/* Input parameters: */ +/* ----------------- */ +/* */ +/* Input parameters from globals: */ +/* ------------------------------ */ +/* */ +/* Modified parameters from globals: */ +/* --------------------------------- */ +/* */ +/*-------------------------------------------------------*/ +void l1ps_ctrl_prach(UWORD8 task, UWORD8 burst_id) +{ + UWORD16 radio_freq; + UWORD8 txpwr; + UWORD8 adc_active = INACTIVE; + + // Get ARFCN to be used for current control. + // ****************************************** + + radio_freq = l1pa_l1ps_com.p_idle_param.radio_freq; + + // Get TXPWR value + txpwr = l1s.applied_txpwr; + + // Traces and debug. + // ****************** + + #if (TRACE_TYPE!=0) + trace_fct(CST_L1S_CTRL_RACH, radio_freq); + #endif + + #if (TRACE_TYPE==5) && FLOWCHART + trace_flowchart_dsp_tpu(dltsk_trace[task].name); + #endif + + #if FF_L1_IT_DSP_USF + // Whenever the USF status is unknown then the PRACH control execution + // has to be postponed until DSP USF interrupt fires. + if (l1ps_macs_com.usf_status != USF_AWAITED) + { + #endif // FF_L1_IT_DSP_USF + + l1s_dsp_com.dsp_db_w_ptr->d_debug = (l1s.debug_time + 2) ; + + #if FF_L1_IT_DSP_USF + // TPU and DSP have to be programmed for transmission only if the USF is + // good otherwise this is not a valid opportunity. If there was no USF + // uncertainty then the test is void. + if ( (l1ps_macs_com.usf_status != USF_IT_DSP) + || (((l1ps_dsp_com.pdsp_ndb_ptr->d_usf_updated_gprs >> ((7-0)*2)) & 0x0003) == USF_GOOD)) + { + // Flags PRACH burst was controlled to TPU/DSP (not cancelled due to USF) + l1pa_l1ps_com.pra_info.prach_controlled = TRUE; + #endif // FF_L1_IT_DSP_USF + + #if (CODE_VERSION!=SIMULATION) + #if (TRACE_TYPE==2 ) || (TRACE_TYPE==3) + L1_trace_string("PRA"); + #endif + #endif + + // Programs DSP for required task. + // ******************************** + { + UWORD8 cs_type; + + if (l1pa_l1ps_com.access_burst_type == ACC_BURST_8) + cs_type = CS_PAB8_TYPE; + else + cs_type = CS_PAB11_TYPE; + + // ACCESS PRACH dsp control. + l1pddsp_idle_prach_data(FALSE, + cs_type, + l1pa_l1ps_com.pra_info.channel_request_data, + l1a_l1s_com.Scell_info.bsic, + radio_freq); + } + + l1pddsp_idle_prach_power(txpwr, + radio_freq, + 3); + + // ADC measurement + // *************** + + // check if during the RACH an ADC measurement must be performed + if (l1a_l1s_com.adc_mode & ADC_EACH_RACH) // perform ADC on each burst + adc_active = ACTIVE; + + // Programs TPU for required task. + // ******************************** + + // tpu pgm... + l1dtpu_serv_tx_ra(radio_freq, l1s.tpu_offset, txpwr, adc_active); + + // Set tpu window identifier for Power meas if any. + l1s.tpu_win = (3 * BP_SPLIT) + l1_config.params.tx_ra_load_split + l1_config.params.rx_synth_load_split; + + // Store frame number to report to L3 + l1pa_l1ps_com.pra_info.fn_to_report = l1s.next_time.fn; + + #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + RTTL1_FILL_UL_AB(task,txpwr) + #endif + + // Flag DSP and TPU programmation. + // ******************************** + + // Set "CTRL_TX" flag in the controle flag register. + l1s.tpu_ctrl_reg |= CTRL_PRACH; + l1s.dsp_ctrl_reg |= CTRL_TX; + + #if FF_L1_IT_DSP_USF + }// if ((l1ps_macs_com.usf_status != USF_IT_DSP) || USF_GOOD) + else + { + // PRACH has been cancelled because USF not FREE. Hence Read is skipped. + l1pa_l1ps_com.pra_info.prach_controlled = FALSE; + } + #endif + + #if FF_L1_IT_DSP_USF + } // if (l1ps_macs_com.usf_status != USF_AWAITED) + #endif +} + +/*-------------------------------------------------------*/ +/* l1ps_ctrl_poll() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* */ +/* Input parameters: */ +/* ----------------- */ +/* */ +/* Input parameters from globals: */ +/* ------------------------------ */ +/* */ +/* Modified parameters from globals: */ +/* --------------------------------- */ +/* */ +/*-------------------------------------------------------*/ +void l1ps_ctrl_poll(UWORD8 task, UWORD8 burst_id) +{ + UWORD16 radio_freq; + + // Get ARFCN to be used for current control. + // ****************************************** + if(l1a_l1s_com.l1s_en_task[SINGLE] == TASK_ENABLED) + radio_freq = l1a_l1s_com.dedic_set.radio_freq; + else + radio_freq = l1pa_l1ps_com.p_idle_param.radio_freq; + + // Traces and debug. + // ****************** + + #if (TRACE_TYPE!=0) + trace_fct(CST_L1PS_CTRL_POLL, radio_freq); + #endif + + #if (TRACE_TYPE==5) && FLOWCHART + trace_flowchart_dsp_tpu(dltsk_trace[task].name); + #endif + + l1s_dsp_com.dsp_db_w_ptr->d_debug = (l1s.debug_time + 2) ; + + #if (CODE_VERSION!=SIMULATION) + #if (TRACE_TYPE==2 ) || (TRACE_TYPE==3) + L1_trace_string("PRA"); + #endif + #endif + + // Programs DSP for required task. + // ******************************** + { + UWORD8 cs_type; + + cs_type = l1pa_l1ps_com.poll_info.pol_resp_type; + + if ((cs_type == CS_PAB8_TYPE) || (cs_type == CS_PAB11_TYPE)) + { + // IDLE POLLING PRACH dsp control. + l1pddsp_idle_prach_data(TRUE, + cs_type, + l1pa_l1ps_com.poll_info.chan_req.prach_data[0], + l1a_l1s_com.Scell_info.bsic, + radio_freq); + + l1pddsp_idle_prach_power(l1s.applied_txpwr, + radio_freq, + 3); + + // Programs TPU for required task. + // ******************************** + // tpu pgm... + l1dtpu_serv_tx_ra(radio_freq, l1s.tpu_offset, l1s.applied_txpwr,INACTIVE); + + #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + RTTL1_FILL_UL_AB(task,l1s.applied_txpwr) + #endif + } + else + { + UWORD8 tsc; + + if(l1a_l1s_com.l1s_en_task[SINGLE] == TASK_ENABLED) + tsc = l1pa_l1ps_com.transfer.aset->tsc; + else + tsc = l1pa_l1ps_com.pccch.packet_chn_desc.tsc; + + // Pgm DSP for Poll Response TX NB on TS=3. + l1pddsp_single_tx_block (burst_id, + l1pa_l1ps_com.poll_info.chan_req.cs1_data, + tsc, + radio_freq); + + // Pgm DSP for Transmit power. + l1pddsp_transfer_mslot_power(l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr, radio_freq, 0x80>>3); + + // Programs TPU for required task. + // ******************************** + // tpu pgm... + l1dtpu_serv_tx_nb(radio_freq, + l1pa_l1ps_com.poll_info.timing_advance, + l1s.tpu_offset, + l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr[3],INACTIVE); + + #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + RTTL1_FILL_UL_NB(task, l1pa_l1ps_com.poll_info.timing_advance, l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr[3]) + #endif + } + } + + + // Set tpu window identifier for Power meas if any. + l1s.tpu_win = (3 * BP_SPLIT) + l1_config.params.tx_nb_load_split + l1_config.params.rx_synth_load_split; + + // Store frame number to report to L3 + if (burst_id == BURST_4) + l1pa_l1ps_com.poll_info.fn_to_report = l1s.next_time.fn; + + // Flag DSP and TPU programmation. + // ******************************** + + // Set "CTRL_TX" flag in the controle flag register. + l1s.tpu_ctrl_reg |= CTRL_TX; + l1s.dsp_ctrl_reg |= CTRL_TX; +} + + +#if (MOVE_IN_INTERNAL_RAM == 0) // Must be followed by the pragma used to duplicate the funtion in internal RAM +//#pragma DUPLICATE_FOR_INTERNAL_RAM_START + +/*-------------------------------------------------------*/ +/* l1s_ctrl_pdtch() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: This is the control function for Multislot Rx/Tx */ +/* ------------ */ +/* */ +/* Input parameters: */ +/* ----------------- */ +/* */ +/* Input parameters from globals: */ +/* ------------------------------ */ +/* */ +/* Modified parameters from globals: */ + +/*-------------------------------------------------------*/ +void l1ps_ctrl_pdtch(UWORD8 task, UWORD8 burst_id) +{ + if((l1a_l1s_com.l1s_en_task[task] == TASK_ENABLED) && + !(l1a_l1s_com.task_param[task] == SEMAPHORE_SET)) + // Check the task semaphore. The control body is executed only + // when the task semaphore is 0. This semaphore can be set to + // 1 whenever L1A makes some changes to the task parameters. + { + UWORD16 radio_freq; + #if (RF_FAM == 61) + // By default we choose the hardware filter + UWORD8 csf_filter_choice = L1_SAIC_HARDWARE_FILTER; + #endif + #if (NEW_SNR_THRESHOLD == 1) + UWORD8 saic_flag=0; + #endif /* NEW_SNR_THRESHOLD */ + // Traces and debug. + // ****************** + + #if (TRACE_TYPE==5) && FLOWCHART + trace_flowchart_dsp_tpu(dltsk_trace[PDTCH].name); + #endif + + l1s_dsp_com.dsp_db_w_ptr->d_debug = (l1s.debug_time + 2) ; + + // Catch channel description and ARFCN. + // ************************************* + + // Get ARFCN to be used for current control. This ARFCN comes from + // the HOPPING algorithm called just before calling this function. + radio_freq = l1a_l1s_com.dedic_set.radio_freq; + + #if (TRACE_TYPE==5) // in simulation trace only one time by frame + trace_fct(CST_L1PS_CTRL_PDTCH, radio_freq); + #endif + + /**************************************************************************/ + /* Program DSP for mulstislot operation... */ + /**************************************************************************/ + { + UWORD8 tx_allocation; + + #if TESTMODE + if (l1_config.TestMode && (l1_config.tmode.tx_params.burst_data == 11)) + // Call dummy MACS for CMU200 loopback mode + l1ps_tmode_macs_ctrl(); + else + #endif + { + // Call MACS for Medium control, DATA control and RLC-MACS management + l1ps_macs_ctrl(); + } + + #if FF_L1_IT_DSP_USF + if (l1ps_macs_com.usf_status != USF_AWAITED) + { + #endif + // Compute tx_allocation mixing NB and RA allocations. + tx_allocation = l1ps_macs_com.tx_nb_allocation | l1ps_macs_com.tx_prach_allocation; + + // Pgme TXPWR only if any UL. + if(tx_allocation) + { + // Pgme DSP for Transmit power. + // !!! Warning: This function must be called before l1pdtpu_serv_tx() + // !!! a_ctrl_abb_gprs is partly overwritten by l1pdtpu_serv_tx() + l1pddsp_transfer_mslot_power(l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr, radio_freq, tx_allocation); + } + #if FF_L1_IT_DSP_USF + } + #endif + } + + + /**************************************************************************/ + /* Program TPU for mulstislot operation... */ + /**************************************************************************/ + { + WORD8 ts = 0; + UWORD8 rx_group_id = 0; + UWORD8 tx_group_id = 0; + BOOL pwr_programmed = FALSE; + UWORD8 bit_mask = 0x80; + WORD8 agc; + UWORD8 lna_off; + BOOL rx_done_flag; + BOOL adc_done = FALSE; + UWORD8 adc_active = INACTIVE; + + #if (RF_FAM == 61) + UWORD16 dco_algo_ctl_nb = 0; + UWORD16 dco_algo_ctl_pw = 0; + UWORD8 if_ctl =0; //omaps00090550; + UWORD8 tot_num_rx = 0; + UWORD8 if_threshold = C_IF_ZERO_LOW_THRESHOLD_GPRS; + #endif + + // AGC and LNA_OFF processing + //--------------------------- + + #if FF_L1_IT_DSP_USF + #if L1_EDA + if (l1ps_macs_com.usf_status != USF_AWAITED) + #else + if (l1ps_macs_com.usf_status != USF_IT_DSP) + #endif + #endif + // Same AGC is used for all timeslots + l1pctl_transfer_agc_ctrl(&agc, &lna_off, radio_freq); + + #if (L1_SAIC != 0) + // If SAIC is enabled, call the low level SAIC control function + // NOTE: l1a_l1s_com.Scell_used_IL.input_level is updated within + // the l1pctl_transfer_agc_ctrl above + csf_filter_choice = l1ctl_saic(l1a_l1s_com.Scell_used_IL.input_level,l1a_l1s_com.mode + #if (NEW_SNR_THRESHOLD == 1) + ,task + ,&saic_flag + #endif + ); + #endif + + while(ts < 8) + { + + #if FF_L1_IT_DSP_USF + #if L1_EDA + //Depending on USF status got from DSP, RX allocation may change after + //receiving the USF interrupt due to USF status updates + if ((l1ps_macs_com.rx_allocation & bit_mask) + && (l1ps_macs_com.usf_status != USF_AWAITED)) + #else + if ((l1ps_macs_com.rx_allocation & bit_mask) + && (l1ps_macs_com.usf_status != USF_IT_DSP)) + #endif + #else + if(l1ps_macs_com.rx_allocation & bit_mask) + #endif + { + // We have detected the 1st RX slot number for a new RX group. + + UWORD8 rx_id = ts; // Save 1st RX timeslot number. + UWORD8 num_rx = 1; // 1 RX in the RX group for the moment. + + // Increment the RX group ID. + rx_group_id++; + + #if (RF_FAM == 61) + //Increment the total number of RX slots + tot_num_rx++; + #endif + + // Increment TS. + ts++; + + // Jump on next timeslot to keep looking for contiguous RX slots. + bit_mask >>= 1; + + // Look for more contiguous RX slots. + while((l1ps_macs_com.rx_allocation & bit_mask) && (ts < 8)) + { + ts++; + num_rx++; + #if (RF_FAM == 61) + tot_num_rx++; + #endif + bit_mask >>= 1; + } + + // Check if more RX bursts follow + if((l1ps_macs_com.rx_allocation << (ts+1)) & 0xFF) + rx_done_flag = FALSE; + else + rx_done_flag = TRUE; + + #if (RF_FAM == 61) // Locosto DCO + if(rx_group_id == 1) + { + cust_get_if_dco_ctl_algo(&dco_algo_ctl_nb, &if_ctl, (UWORD8) L1_IL_VALID, + l1a_l1s_com.Scell_used_IL.input_level, radio_freq,if_threshold); + } + + if(rx_done_flag == TRUE) + { + //dco_algo_ctl has 0000 00ZL + dco_algo_ctl_nb *= 0x55; // replicate 0000 00zL as ZLZL ZLZL + // ZLZLZLZL >> 2*(4-tot_num_rx) where i is the tot_num_rx would produce the + // desired dco_algo_ctl_nb For Eg if tot_num_rx is 2 the desired pattern is + // 0000 ZLZL + dco_algo_ctl_nb = dco_algo_ctl_nb >> (2*( 4 - tot_num_rx)); + l1ddsp_load_dco_ctl_algo_nb(dco_algo_ctl_nb); + } + #endif + // ADC measurement + // *************** + if (adc_done == FALSE) + { + // check if during the PDTCH burst an ADC measurement must be performed + if (l1a_l1s_com.adc_mode & ADC_NEXT_TRAFFIC_DL) // perform ADC only one time + { + adc_active = ACTIVE; + adc_done = TRUE; + l1a_l1s_com.adc_mode &= ADC_MASK_RESET_TRAFFIC; // reset in order to have only one ADC measurement in Traffic + } + else + if (l1a_l1s_com.adc_mode & ADC_EACH_TRAFFIC_DL) // perform ADC on each period bloc + if (l1s.actual_time.fn_mod104 == 10) //periodic with each PDTCH burst in frame 11 (frame with the lowest CPU load) + if ((++l1a_l1s_com.adc_cpt)>=l1a_l1s_com.adc_traffic_period) // wait for the period + { + adc_active = ACTIVE; + adc_done = TRUE; + l1a_l1s_com.adc_cpt = 0; + } + } + + // update the TPU with the new TOA if necessary + if (rx_group_id == 1) // only if synchro performed + l1ctl_update_TPU_with_toa(); + + #if (TRACE_TYPE!=0) && (TRACE_TYPE!=5) + trace_fct(CST_L1PS_CTRL_PDTCH_DL_BURST0 + burst_id, radio_freq); + #endif + + // Program RX scenario. + l1pdtpu_serv_rx_nb(radio_freq, + agc, + lna_off, + rx_id, + l1s.tpu_offset, + num_rx, + rx_group_id, + rx_done_flag,adc_active + #if (RF_FAM == 61) + ,csf_filter_choice + ,if_ctl + #endif + #if (NEW_SNR_THRESHOLD == 1) + ,saic_flag + #endif + ); + + adc_active = INACTIVE; // ADC performed only on the first RX burst + + // Set tpu window identifier for Synthesizer and + // according to last RX group position. + l1s.tpu_win = (l1_config.params.rx_synth_load_split) + + ((UWORD16)rx_id * BP_SPLIT) + RX_SPLIT_TABLE[num_rx-1]; + + + // Set "CTRL_RX" flag in the controle flag registers. + l1s.tpu_ctrl_reg |= CTRL_RX; + l1s.dsp_ctrl_reg |= CTRL_RX; + } + + else + #if FF_L1_IT_DSP_USF + if ((l1ps_macs_com.tx_nb_allocation & bit_mask) + && (l1ps_macs_com.usf_status != USF_AWAITED)) + #else + if(l1ps_macs_com.tx_nb_allocation & bit_mask) + #endif + { + // We have detected the 1st TX NB slot number for a new TX group. + + UWORD8 tx_id = ts; // Save 1st TX timeslot number. + UWORD8 num_tx = 1; // 1 RX in the TX group for the moment. + UWORD8 switch_flag; + + // Increment the TX group ID. + tx_group_id++; + + // Increment TS. + ts++; + + // Jump on next timeslot to keep looking for contiguous TX slots. + bit_mask >>= 1; + + // Look for more contiguous TX slots. + while((l1ps_macs_com.tx_nb_allocation & bit_mask) && (ts < 8)) + { + ts++; + num_tx++; + bit_mask >>= 1; + } + + // Detect special case: TX NB followed by PRACH. + if(l1ps_macs_com.tx_prach_allocation & bit_mask) + { + switch_flag = 1; + } + else + { + switch_flag = 0; + } + + #if (TRACE_TYPE!=0) && (TRACE_TYPE!=5) + trace_fct(CST_L1PS_CTRL_PDTCH_UL, radio_freq); + #endif + + // Program TN NB scenario. + l1pdtpu_serv_tx(radio_freq, + l1pa_l1ps_com.transfer.aset->packet_ta.ta, + l1s.tpu_offset, + tx_id, + num_tx, + tx_group_id, + switch_flag, + 0, // Driver called for Normal Burst. + TRUE,INACTIVE);// Flag RX in same frame as TX + + // Set tpu window identifier for Synthesizer and + // according to last TX group position. + // TX offset = tx_id * BP_SPLIT + // TX load = (num_tx-1) * BP_SPLIT + l1_config.params.tx_load_split + l1s.tpu_win = (l1_config.params.rx_synth_load_split) + + ((UWORD16)tx_id * BP_SPLIT) + + ((UWORD16)(num_tx -1) * BP_SPLIT) + + l1_config.params.tx_nb_load_split; + + // Set "CTRL_TX" flag in the controle flag registers. + l1s.tpu_ctrl_reg |= CTRL_TX; + l1s.dsp_ctrl_reg |= CTRL_TX; + } + + else + #if FF_L1_IT_DSP_USF + if ((l1ps_macs_com.tx_prach_allocation & bit_mask) + && (l1ps_macs_com.usf_status != USF_AWAITED)) + #else + if(l1ps_macs_com.tx_prach_allocation & bit_mask) + #endif + { + // We have detected a TX RA. + + UWORD8 switch_flag; + + // Increment the TX group ID. + tx_group_id++; + + // Jump on next timeslot. + bit_mask >>= 1; + + // Detect special case: PRACH followed by TX NB. + if(l1ps_macs_com.tx_nb_allocation & bit_mask) + { + switch_flag = 1; + } + // Detect special case: PRACH followed by PRACH + else if (l1ps_macs_com.tx_prach_allocation & bit_mask) + { + // Solution with DSP patch supporting PRACH|PRACH + switch_flag = 2; + } + else + { + switch_flag = 0; + } + + #if (TRACE_TYPE!=0) && (TRACE_TYPE!=5) + trace_fct(CST_L1PS_CTRL_PDTCH_RA, radio_freq); + #endif + + // Program TX RA scenario. + l1pdtpu_serv_tx(radio_freq, + l1pa_l1ps_com.transfer.aset->packet_ta.ta, + l1s.tpu_offset, + ts, + 1, // Driver is called for each PRACH. + tx_group_id, + switch_flag, + TX_RA_BURST, // Driver called for PRACH Burst. + TRUE,INACTIVE); // Flag RX in same frame as TX + + // Set tpu window identifier for Synthesizer and + // according to last TX group position. + // TX offset = ts * BP_SPLIT + // TX load = l1_config.params.tx_nb_load_split + // original value of TX load (RACH) replaced by TX NB to take into account TX_NB|PRACH with max. TA + l1s.tpu_win = (l1_config.params.rx_synth_load_split) + + ((UWORD16)ts * BP_SPLIT) + + l1_config.params.tx_nb_load_split; + + + // Increment TS. + ts++; + + // Set "CTRL_TX" flag in the controle flag registers. + l1s.tpu_ctrl_reg |= CTRL_TX; + l1s.dsp_ctrl_reg |= CTRL_TX; + } + + else + #if FF_L1_IT_DSP_USF + if ((l1ps_macs_com.pwr_allocation & bit_mask) + && (pwr_programmed == 0) + && (l1ps_macs_com.usf_status != USF_AWAITED)) + #else + if((l1ps_macs_com.pwr_allocation & bit_mask) && (pwr_programmed == 0)) + #endif + { + // We have detected a PWR allocation and no PWR programmed in current frame. + if((l1pa_l1ps_com.transfer.aset->pc_meas_chan == FALSE) && + ((l1s.actual_time.t2 == 1) || (l1s.actual_time.t2 == 9) + || (l1s.actual_time.t2 == 18))) + { + #if (TRACE_TYPE!=0) && (TRACE_TYPE!=5) + trace_fct(CST_CTRL_PC_MEAS_CHAN, (UWORD32)(-1)); + #endif + + // Measurement on the beacon (PC_MEAS_CHAN = 0) + l1ps_bcch_meas_ctrl(ts); + } + else + if(l1pa_l1ps_com.l1ps_en_meas & P_TCRMS_MEAS) + { + // Neighbour Measurement CTRL Phase + + // Note: Test on l1s.forbid_meas can't be done from the fact that at this + // level, l1s.forbid_meas is not set. + // l1ps_ctrl_pdtch is called before CTRL of FB26/SB26/SBCNF26. + if(!((l1s.actual_time.t2 == 23) && + ((l1s.task_status[FB26].current_status != INACTIVE) || + (l1s.task_status[SB26].current_status != INACTIVE) || + (l1s.task_status[SBCNF26].current_status != INACTIVE)))&& + !(l1pa_l1ps_com.tcr_freq_list.new_list_present && + ((l1pa_l1ps_com.tcr_freq_list.cres_meas_report == 0) || + (l1pa_l1ps_com.tcr_freq_list.cres_meas_report == 103)))) + { + if(!(l1pa_l1ps_com.meas_param & P_TCRMS_MEAS)) + { + #if (TRACE_TYPE!=0) && (TRACE_TYPE!=5) + trace_fct(CST_CTRL_TCR_MEAS_1, (UWORD32)(-1)); + #endif + + l1ps_tcr_ctrl((UWORD8)ts); + } + } + } // End of CTRL PDTCH phase + + // Increment TS. + ts++; + + // Flag that a PWR as been programmed for current frame. + pwr_programmed = TRUE; + + // Jump on next timeslot. + bit_mask >>= 1; + + // Call PWR control function + + } + + else + { + // Increment TS. + ts++; + + // Jump on next timeslot. + bit_mask >>= 1; + } + + } // End of "while(ts < 8)" + + #if FF_L1_IT_DSP_USF + if (l1ps_macs_com.usf_status != USF_AWAITED) + #endif + // Update of AFC + l1pd_afc(); + } + } // End if(task enabled and semaphore false) + + else + // When the task is aborted, we must continue to make dummy + // DSP programming to avoid communication mismatch due + // to C/W/R pipelining. + { + #if (TRACE_TYPE!=0) && (TRACE_TYPE!=5) + trace_fct(CST_L1PS_CTRL_PDTCH_DUMMY, (UWORD32)(-1)); + #endif + + // Flag dummy DSP programmation. + // Set "CTRL_TX" flag in the controle flag registers. + l1s.dsp_ctrl_reg |= CTRL_TX; + } + +} +//#pragma DUPLICATE_FOR_INTERNAL_RAM_END +#endif // MOVE_IN_INTERNAL_RAM + + +/*-------------------------------------------------------*/ +/* l1s_read_single() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* */ +/* Input parameters: */ +/* ----------------- */ +/* */ +/* Input parameters from globals: */ +/* ------------------------------ */ +/* */ +/* Modified parameters from globals: */ +/* --------------------------------- */ +/* */ +/*-------------------------------------------------------*/ +void l1ps_read_single(UWORD8 task, UWORD8 burst_id) +{ + if((l1a_l1s_com.l1s_en_task[task] == TASK_ENABLED) && + !(l1a_l1s_com.task_param[task] == SEMAPHORE_SET)) + // Check the task semaphore. The control body is executed only + // when the task semaphore is 0. This semaphore can be set to + // 1 whenever L1A makes some changes to the task parameters. + { + // Read param updating... + if (l1ps.read_param.new_set == TRUE) + { + // If it's the first Read phase of the block (first of the new TBF) + if (burst_id == BURST_1) + { + // Update the "read_param" structure + l1ps_update_read_set_parameters(); + } + } + + /*--------------------------------------------------------*/ + /* READ TRANSMIT TASK RESULTS... */ + /*--------------------------------------------------------*/ + + l1_check_com_mismatch(task); + + // check PM error only in case of downlink single block + if(l1ps.read_param.allocated_tbf == SINGLE_BLOCK_DL) + { + UWORD32 pm; + pm = (l1ps_dsp_com.pdsp_db_r_ptr->a_burst_pm_gprs[0] & 0xffff) >> 5; + l1_check_pm_error(pm,task); + } + + + // Two phase access: downlink PDCH reading + if((l1ps.read_param.allocated_tbf == TWO_PHASE_ACCESS)&& + (l1ps_dsp_com.pdsp_db_r_ptr->d_task_d_gprs & (0x80 >> 0))) + { + UWORD8 IL_for_rxlev[8]; + UWORD8 pr_table[8]; + + if (burst_id == BURST_4) + l1ps_macs_header_decoding(0, &(IL_for_rxlev[0]), &(pr_table[0])); + + // Update AGC and extract IL for RXLEV + //------------------------------------ + if (l1ps.read_param.dl_pwr_ctl.p0 == 255) + { + // No power control mode AGC algorithm + l1pctl_npc_agc_read(IL_for_rxlev, l1ps_dsp_com.pdsp_db_r_ptr, l1ps_dsp_com.pdsp_ndb_ptr); + } + else + { + // Downlink power control AGC algorithms + if (l1pa_l1ps_com.transfer.aset->dl_pwr_ctl.bts_pwr_ctl_mode == 0) + { + // BTS Power control mode A + l1pctl_dpcma_agc_read(IL_for_rxlev, l1ps_dsp_com.pdsp_db_r_ptr, l1ps_dsp_com.pdsp_ndb_ptr, pr_table); + } + else + { + // BTS power control mode B + l1pctl_dpcmb_agc_read(IL_for_rxlev, l1ps_dsp_com.pdsp_db_r_ptr, l1ps_dsp_com.pdsp_ndb_ptr, pr_table); + } + } // End of "AGC algorithm" + } + + #if (TRACE_TYPE!=0) && (TRACE_TYPE !=5) + trace_fct(CST_L1PS_READ_SINGLE, l1a_l1s_com.Scell_info.radio_freq); + #endif + + // Read downlink DATA block from MCU/DSP interface. + // ************************************************* + if(burst_id == BURST_4) + { + xSignalHeaderRec *msg; + + #if (TRACE_TYPE==5) // in simulation trace only the 4th burst + trace_fct(CST_L1PS_READ_SINGLE, l1a_l1s_com.Scell_info.radio_freq); + #endif + + if(l1ps.read_param.allocated_tbf == TWO_PHASE_ACCESS) + // 2 phase ACCESS. + { + if((l1ps_dsp_com.pdsp_db_r_ptr->d_task_u_gprs & (0x80 >> 3)) && + (l1s.task_status[POLL].current_status == INACTIVE)) + // UL block sent... + { + // Send confirmation msg to L3/MACA. + msg = os_alloc_sig(sizeof(T_MPHP_SINGLE_BLOCK_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + + // Return "Single block" purpose. + ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->purpose = + l1pa_l1ps_com.transfer.aset->assignment_command; + ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->assignment_id = + l1pa_l1ps_com.transfer.aset->assignment_id; + + // Return status and CRC error (CRC error not applicable). + ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->status = SINGLE_UL_DONE; + ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->dl_error_flag = 0; + + // MSG is sent to L1A to stop PCCCH or CCCH/BCCH reading. + msg->SignalCode = L1P_SINGLE_BLOCK_CON; + os_send_sig(msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + + if(l1ps_dsp_com.pdsp_db_r_ptr->d_task_d_gprs & (0x80 >> 0)) + // DL block received... + { + UWORD16 pwr_level; + +#if (L1_FF_MULTIBAND == 1) + UWORD16 operative_radio_freq; +#endif /*(L1_FF_MULTIBAND == 1)*/ + + // this bloc doesn't compute the burst input level, so the last_input_level is used. + +#if (L1_FF_MULTIBAND == 0) + + pwr_level = l1a_l1s_com.last_input_level[l1a_l1s_com.Scell_info.radio_freq].input_level; + +#else // L1_FF_MULTIBAND = 1 below + + operative_radio_freq = + l1_multiband_radio_freq_convert_into_operative_radio_freq(l1a_l1s_com.Scell_info.radio_freq); + pwr_level = l1a_l1s_com.last_input_level[operative_radio_freq].input_level; + +#endif // #if (L1_FF_MULTIBAND == 0) else + + + // Read L3 frame block and send msg to L1A. + l1s_read_l3frm(pwr_level, &(l1ps_dsp_com.pdsp_ndb_ptr->a_dd_gprs[0][0]), task); + } + } + else + { + // SYNCHRO task is not schedule if we are in the specific case: + // L1A is touching SYNCHRO parameters (tn_difference, dl_tn and dsp_scheduler_mode) + // and leave L1A to go in HISR (L1S) in middle of the update (cf. BUG1339) + if(l1a_l1s_com.task_param[SYNCHRO] == SEMAPHORE_RESET) + { + //---------------- + // Synchro back + //---------------- + // Save the "timeslot difference" between new and old configuration + // in "tn_difference". + // tn_difference -> loaded with the number of timeslot to shift. + // dl_tn -> loaded with the new timeslot. + l1a_l1s_com.tn_difference += l1pa_l1ps_com.transfer.single_block.dl_tn_to_restore - + l1a_l1s_com.dl_tn; + l1a_l1s_com.dl_tn = l1pa_l1ps_com.transfer.single_block.dl_tn_to_restore; + + // Select DSP Scheduler used in packet Idle (can be CCCH or PCCCH). + if((l1a_l1s_com.l1s_en_task[ALLC] == TASK_ENABLED) + || (l1a_l1s_com.l1s_en_task[NP] == TASK_ENABLED) + || (l1a_l1s_com.l1s_en_task[EP] == TASK_ENABLED)) + { + // We are in CS Idle on CCCH. + l1a_l1s_com.dsp_scheduler_mode = GSM_SCHEDULER; + } + + // Enable SYNCHRO task. + l1a_l1s_com.l1s_en_task[SYNCHRO] = TASK_ENABLED; + } + + //------------------ + // Confirmation msg + //------------------ + // Common part... + { + // Send confirmation msg to L3/MACA. + msg = os_alloc_sig(sizeof(T_MPHP_SINGLE_BLOCK_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + + + ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->purpose = + l1pa_l1ps_com.transfer.aset->assignment_command; + ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->assignment_id = + l1pa_l1ps_com.transfer.aset->assignment_id; + + msg->SignalCode = L1P_SINGLE_BLOCK_CON; + + // Disable SINGLE task. + l1s.task_status[task].current_status = INACTIVE; + l1a_l1s_com.l1s_en_task[task] = TASK_DISABLED; + } + + // Differentiated part... + + if(l1pa_l1ps_com.transfer.aset->allocated_tbf == SINGLE_BLOCK_UL) + // SINGLE UL task is complete. + { + // Return status and CRC error (CRC error not applicable). + ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->status = SINGLE_UL_DONE; + ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->dl_error_flag = 0; + } + else + if(l1ps.read_param.allocated_tbf == SINGLE_BLOCK_DL) + // SINGLE DL task is complete. + { + API *info_address; + UWORD32 i,j; + UWORD32 word32; + + info_address = &(l1ps_dsp_com.pdsp_ndb_ptr->a_dd_gprs[0][0]); + + // Return status and CRC error + ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->status = SINGLE_DL_DONE; + ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->dl_error_flag = ((*info_address & 0x0100) >> 8); + + // Download data from API to message. + + // Get 24 bytes info. from DSP: CS1 meaningful block is of size 12 UWORD16 data. + // !!! WARNING: word32 type is for compatibility with chipset == 0. + // Can be word16 if only chipset == 2 is used. + for (j=0, i=0; i<12; i++) + { + word32 = info_address[4 + i]; // Get info word, rem: skip info. header. + ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->data_array[j++] = (word32 & 0x000000ff); + ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->data_array[j++] = (word32 & 0x0000ff00) >> 8; + } + } + + // send message... + os_send_sig(msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + } // End else (!TWO_PHASE_ACCESS) + } + + // Set flag used to change the read page at the end of "l1_synch". + l1s_dsp_com.dsp_r_page_used = TRUE; + + } // End if(task enabled and semaphore false) + + else + // When the task is aborted, we must continue to make dummy + // DSP/TPU programming to avoid communication mismatch due + // to C/W/R pipelining. Dummy MCU/DSP reading is also done. + { + // Set flag used to change the read page at the end of "l1_synch". + l1s_dsp_com.dsp_r_page_used = TRUE; + } +} + +#if (MOVE_IN_INTERNAL_RAM == 0) // Must be followed by the pragma used to duplicate the funtion in internal RAM +//#pragma DUPLICATE_FOR_INTERNAL_RAM_START + +/*-------------------------------------------------------*/ +/* l1ps_read_pdtch() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* */ +/* Input parameters: */ +/* ----------------- */ +/* */ +/* Input parameters from globals: */ +/* ------------------------------ */ +/* */ +/* Modified parameters from globals: */ +/* --------------------------------- */ +/* */ +/*-------------------------------------------------------*/ +void l1ps_read_pdtch(UWORD8 task, UWORD8 burst_id) +{ + if((l1a_l1s_com.l1s_en_task[task] == TASK_ENABLED) && + !(l1a_l1s_com.task_param[task] == SEMAPHORE_SET)) + // Check the task semaphore. The control body is executed only + // when the task semaphore is 0. This semaphore can be set to + // 1 whenever L1A makes some changes to the task parameters. + { + BOOL beacon; + T_INPUT_LEVEL *IL_info_ptr; + UWORD16 radio_freq; + WORD8 ts = 0; + UWORD8 bit_mask = 0x80; + WORD8 bcch_level; + UWORD8 rx_no = 0; + BOOL first_valid_block = TRUE; + BOOL crc_error = TRUE; + UWORD8 i; + UWORD32 best_snr = 0; + UWORD32 best_angle = 0; + UWORD32 best_pm = 0; + UWORD8 IL_for_rxlev[8], pr_table[8]; + WORD16 best_rxlev_accu = 0; + + + static BOOL crc_error_tbl[8] = {TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE}; + static WORD16 rxlev_accu[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + static WORD8 burst_level[4] = {(WORD8)0x80, (WORD8)0x80, (WORD8)0x80, (WORD8)0x80}; + static UWORD16 radio_freq_tbl[4]; + static UWORD32 toa_val[4] = {0, 0, 0, 0}; + static UWORD32 snr_val[4] = {0, 0, 0, 0}; + + #if TESTMODE + xSignalHeaderRec *msg; + static UWORD32 tm_pm_fullres = 0; + static UWORD32 tm_snr = 0; + static UWORD32 tm_toa = 0; + static WORD16 tm_angle = 0; + #endif + + + #define burst_number l1ps_dsp_com.pdsp_db_r_ptr->d_burst_nb_gprs + #define DL_pwr_ctrl l1pa_l1ps_com.transfer.dl_pwr_ctrl + + // Read parameters updating + // ************************* + + // *********** + // * WARNING * + // *********** + + // Because of the STI implementation, the parameters under the "l1pa_l1ps_com.transfer.aset" + // structure mustn't be used in the Read PDTCH functions + // This is due to the following case that may happen: + // + // C|W R | + // |C W R | + // | C W R| TBF 1 + // | C W|R <--------------------------- (2) This "read phase" must use the TBF 1 parameters while "aset" has already been updated + //---------------------- so the read_param structure is used + // | C|W R <------------------------- (3) The read_param is updated with TBF 2 parameters + // | |C W R at the beguining of the first Read of TBF 2 + // | | C W R TBF 2 so when (l1ps.read_param.new_set = TRUE and burst_id = BURST_1) + // | | C W R + // ^ + // (1) TBF 2 starting time detected on this frame (no SYNCHRO change needed between TBF1 and TBF 2) + // --> aset parameters updated to TBF 2 + // --> l1ps.read_param.new_set set to TRUE + + // If a new TBF has been enabled... + if (l1ps.read_param.new_set == TRUE) + { + // If it's the first Read phase of the block (first of the new TBF) + if (burst_id == BURST_1) + { + // Update the "read_param" structure + l1ps_update_read_set_parameters(); + } + } + + // Traces and debug. + // ****************** + + l1_check_com_mismatch(task); + + radio_freq = l1a_l1s_com.dedic_set.radio_freq_dd; + + if(l1ps.read_param.pc_meas_chan) + { + radio_freq_tbl[burst_number] = radio_freq; + } + else + { + radio_freq_tbl[burst_number] = l1a_l1s_com.Scell_info.radio_freq; + } + + if (radio_freq == l1a_l1s_com.Scell_info.radio_freq) + { + beacon=1; + IL_info_ptr = &l1a_l1s_com.Scell_info.traffic_meas_beacon; + } + else + { + beacon=0; + IL_info_ptr = &l1a_l1s_com.Scell_info.traffic_meas; + } + + // Call maca_power_control() in order to get TXPWR value + if(l1ps_dsp_com.pdsp_db_r_ptr->d_burst_nb_gprs == 2) + { + UWORD8 txpwr[8]; + UWORD8 i; + + // Due to the CWR pipeleine, maca_power_control() has to be called before the + // CTRL of the first PDTCH i.e. in l1ps_ctrl_pdtch(). It means that crc_error, + // radio_freq_tbl[], burst_level[] and bcch_level information are stored on + // burst4 of READ phase ("l1ps_ctrl_pdtch()") to be used on burst4 of CTRL phase. + + // Call Uplink Transmit Power level algorithm +#if 0 /* LoCosto version */ + maca_power_control(l1ps.read_param.assignment_id, +#else /* TCS211 reconstruction */ + maca_power_control(DL_pwr_ctrl.assignment_id, +#endif + DL_pwr_ctrl.crc_error, + DL_pwr_ctrl.bcch_level, + DL_pwr_ctrl.radio_freq_tbl, + DL_pwr_ctrl.burst_level, + txpwr); + + #if TESTMODE + if(!l1_config.TestMode) + #endif + { + for(i = 0; i < 8; i++) + { + l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr[i] = txpwr[i]; + } + } + } + + + if(l1ps_dsp_com.pdsp_db_r_ptr->d_burst_nb_gprs == 3) + /*---------------------------------------------------*/ + /* Complete PDTCH DL block has been processed by DSP */ + /*---------------------------------------------------*/ + { + #if (TRACE_TYPE == 5) // in simulation trace only the latest burst + trace_fct(CST_L1PS_READ_PDTCH, radio_freq); + #endif + + // Call MACS... + l1ps_macs_read(pr_table); + } + + // Update AGC and extract IL for RXLEV + //------------------------------------ + if (l1ps.read_param.dl_pwr_ctl.p0 == 255) + { + // No power control mode AGC algorithm + l1pctl_npc_agc_read(IL_for_rxlev, l1ps_dsp_com.pdsp_db_r_ptr, l1ps_dsp_com.pdsp_ndb_ptr); + } + else + { + // Downlink power control AGC algorithms + if (l1ps.read_param.dl_pwr_ctl.bts_pwr_ctl_mode == 0) + { + // BTS Power control mode A + l1pctl_dpcma_agc_read(IL_for_rxlev, l1ps_dsp_com.pdsp_db_r_ptr, l1ps_dsp_com.pdsp_ndb_ptr, pr_table); + } + else + { + // BTS power control mode B + l1pctl_dpcmb_agc_read(IL_for_rxlev, l1ps_dsp_com.pdsp_db_r_ptr, l1ps_dsp_com.pdsp_ndb_ptr, pr_table); + } + } // End of "AGC algorithm" + + // TOA algorithm is called with toa/snr pair from last block (N-1) + // Feed TOA histogram with values from good bursts (crc_error = FALSE) + // otherwise input snr = 0. + #if (TOA_ALGO != 0) + // Good block, TOA from TS=0 + #if (TOA_ALGO == 2) + if(l1s.toa_var.toa_snr_mask == 0) + #else + if(l1s.toa_snr_mask == 0) + #endif + { + #if (TOA_ALGO == 2) + { + UWORD32 snr_temp; + snr_temp = (crc_error_tbl[0] == FALSE) ? snr_val[burst_id] : 0; + l1s.toa_var.toa_shift = l1ctl_toa(TOA_RUN, l1a_l1s_com.mode, snr_temp, toa_val[burst_id]); + } + #else + { + /* FreeCalypso TCS211 reconstruction */ + if (crc_error_tbl[0] == FALSE) + { + l1s.toa_shift = l1ctl_toa(TOA_RUN, l1a_l1s_com.mode, + snr_val[burst_id], toa_val[burst_id], + &l1s.toa_update, &l1s.toa_period_count + #if (FF_L1_FAST_DECODING == 1) + ,0 + #endif + ); + } + else + { + l1s.toa_shift = l1ctl_toa(TOA_RUN, l1a_l1s_com.mode, + 0, toa_val[burst_id], + &l1s.toa_update, &l1s.toa_period_count + #if (FF_L1_FAST_DECODING == 1) + ,0 + #endif + ); + } + } + #endif + } + #endif + + /*---------------------------------------------------*/ + /* Read burst demodulation info for control algos */ + /* Use all burst results to feed the algos. */ + /*---------------------------------------------------*/ + while(ts < 8) + { + if(l1ps_dsp_com.pdsp_db_r_ptr->d_task_d_gprs & bit_mask) + { + UWORD32 toa; + UWORD32 pm; + UWORD32 angle; + UWORD32 snr; + WORD8 rxlev; + + // Read control results and feed control algorithms. + // ************************************************** + + // Read control information. + toa = l1ps_dsp_com.pdsp_db_r_ptr->a_burst_toa_gprs[ts] & 0xffff; + pm = (l1ps_dsp_com.pdsp_db_r_ptr->a_burst_pm_gprs[ts] & 0xffff)>>5; + angle = l1ps_dsp_com.pdsp_db_r_ptr->a_burst_angle_gprs[ts] & 0xffff; + snr = l1ps_dsp_com.pdsp_db_r_ptr->a_burst_snr_gprs[ts] & 0xffff; + + #if (TRACE_TYPE != 0) && (TRACE_TYPE != 5) // for debug trace all bursts + trace_fct(CST_L1PS_READ_PDTCH_BURST, (UWORD32)(-1)); + #endif + + l1_check_pm_error(pm,task); + + #if TESTMODE + // Test mode stats + if (l1_config.TestMode) + { + if (bit_mask & l1_config.tmode.stats_config.stat_gprs_slots) + { + tm_pm_fullres += (l1ps_dsp_com.pdsp_db_r_ptr->a_burst_pm_gprs[ts] & 0xffff); + tm_snr += snr; + tm_toa += toa; + tm_angle += (WORD16) angle; // signed + } + } + #endif + + #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + RTTL1_FILL_DL_BURST(angle, snr, l1s.afc, task, pm, toa, IL_for_rxlev[ts]) + #endif + #if 0 //(TRACE_TYPE == 1) || (TRACE_TYPE == 4) // TCS211 reconstruction + l1_trace_burst_param(angle, snr, l1s.afc, task, pm, toa, IL_for_rxlev[ts]); + #endif + #if (BURST_PARAM_LOG_ENABLE == 1) + l1_log_burst_param(angle, snr, l1s.afc, task, pm, toa, IL_for_rxlev[ts]); + #endif + + //Look for the pairs angle, snr with the maximum snr + if (snr > best_snr) + { + best_snr = snr; + best_angle = angle; + best_pm = pm; + } + + // store toa value from first TS + if (ts==0) + { + toa_val[burst_id] = toa; + snr_val[burst_id] = snr; + } + + // Store Received Signal Level to be used in Uplink Transmit Power Algorithm. + + // Compute RXLEV + rxlev = l1s_encode_rxlev(IL_for_rxlev[ts]); + + // Find first correct PDTCH, save RXLEV and CRC + if(!crc_error_tbl[ts] && first_valid_block) + { + if(l1ps.read_param.pc_meas_chan) + { + burst_level[burst_number] = rxlev; + } + else + { + burst_level[burst_number] = (WORD8)0x80; + } + + // Measures on first valid block have been performed. Reset flag. + first_valid_block = FALSE; + + // Save crc_error + crc_error = crc_error_tbl[ts]; + + } // End of measurements storage + + // If All PDTCH are incorrect (bad CRC) save RXLEV and CRC of the best PDTCH + if(first_valid_block) + { + rxlev_accu[ts] += rxlev; + + if(rxlev_accu[ts] > best_rxlev_accu) + { + best_rxlev_accu = rxlev_accu[ts]; + crc_error = crc_error_tbl[ts]; + + if(l1ps.read_param.pc_meas_chan) + { + burst_level[burst_number] = rxlev; + } + else + { + burst_level[burst_number] = (WORD8)0x80; + } + } + } + + // Determine first valid block to be used in next radio block + if(l1ps_dsp_com.pdsp_db_r_ptr->d_burst_nb_gprs == 3) + /*---------------------------------------------------*/ + /* Complete PDTCH DL block has been processed by DSP */ + /*---------------------------------------------------*/ + { + crc_error_tbl[ts] = ((l1ps_dsp_com.pdsp_ndb_ptr->a_dd_gprs[rx_no][0] & 0x0100) >> 8); + + // Increment Rx burst number + rx_no++; + } + + #if TRACE_TYPE==3 + stats_samples_nb(toa,pm,angle,snr,burst_id,task); + #endif + + } // End of if(l1ps_dsp_com.pdsp_db_r_ptr->d_task_d_gprs & bit_mask) + + // Increment timeslot + ts++; + + // Shift Mask. + bit_mask >>= 1; + + } // End of while(ts < 8) + + // AFC control algorithm is called with values retrieved from + // burst with max. snr + // AFC algorithm is called on bursts 0 and 2: this is sufficient to + // have a correct behavior and this permits to gain CPU + // Update AFC: Call AFC control function (KALMAN filter). + #if AFC_ALGO + #if TESTMODE + if (l1_config.afc_enable) + #endif + { + if((burst_id == 0) || (burst_id == 2)) + #if (VCXO_ALGO == 0) + l1s.afc = l1ctl_afc(AFC_CLOSED_LOOP, &l1s.afc_frame_count, (WORD16)best_angle, best_snr, radio_freq); + #else + l1s.afc = l1ctl_afc(AFC_CLOSED_LOOP, &l1s.afc_frame_count, (WORD16)best_angle, best_snr, radio_freq,l1a_l1s_com.mode); + #endif + } + #endif + + #if (TRACE_TYPE == 1)||(TRACE_TYPE == 4) + if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_CONDENSED_PDTCH) + { + if ((l1pa_l1ps_com.tcr_freq_list.ms_ctrl_dd != 0) || + ((l1ps.pc_meas_chan_ctrl == TRUE) && + ((l1s.actual_time.t2 == 3) || (l1s.actual_time.t2 == 11) || + (l1s.actual_time.t2 == 20)))) + trace_info.pdtch_trace.blk_status |= 0x80 >> burst_id; + } + #endif + + if(l1ps_dsp_com.pdsp_db_r_ptr->d_burst_nb_gprs == 3) + /*---------------------------------------------------*/ + /* Complete PDTCH DL block has been processed by DSP */ + /*---------------------------------------------------*/ + { + + l1pa_l1ps_com.transfer.dl_pwr_ctrl.crc_error = crc_error; + /* + * FreeCalypso TCS211 reconstruction: the following line + * has been taken from the TSM30 source. + */ + l1pa_l1ps_com.transfer.dl_pwr_ctrl.assignment_id = l1ps.read_param.assignment_id; + + if(l1ps.read_param.pc_meas_chan) + { + + // Due to the CWR pipeleine, maca_power_control() has to be called before the + // CTRL of the first PDTCH i.e. in l1ps_ctrl_pdtch(). It means that crc_error, + // radio_freq_tbl[], burst_level[] and bcch_level information are stored on + // burst4 of READ phase to be used on burst4 of CTRL phase. + + l1pa_l1ps_com.transfer.dl_pwr_ctrl.bcch_level = (WORD8)0x80; + + for(i = 0; i < 4; i++) + { + l1pa_l1ps_com.transfer.dl_pwr_ctrl.radio_freq_tbl[i] = radio_freq_tbl[i]; + l1pa_l1ps_com.transfer.dl_pwr_ctrl.burst_level[i] = burst_level[i]; + } + + } + else + { + // Measures have been performed on BCCH Serving Cell. "burst_level" table is + // not applicable. + + // Download measures made on BCCH Serving Cell. + l1pa_l1ps_com.transfer.dl_pwr_ctrl.bcch_level = l1pa_l1ps_com.tcr_freq_list.beacon_meas; + + for(i = 0; i < 4; i++) + { + l1pa_l1ps_com.transfer.dl_pwr_ctrl.radio_freq_tbl[i] = radio_freq_tbl[i]; + l1pa_l1ps_com.transfer.dl_pwr_ctrl.burst_level[i] = (WORD8)0x80; + } + + // Measures on BCCH Serving Cell are only performed every 40ms while + // maca_power_control() is called every 20ms. "beacon_meas" must then + // be set to invalid (0x80) until next Serving Cell measure. + l1pa_l1ps_com.tcr_freq_list.beacon_meas = (WORD8)0x80; + + } + + #if TESTMODE + // Test mode stats + if (l1_config.TestMode) + { + // Allocate result message. + msg = os_alloc_sig(sizeof(T_TMODE_PDTCH_INFO)); + DEBUGMSG(status,NU_ALLOC_ERR) + msg->SignalCode = TMODE_PDTCH_INFO; + + ((T_TMODE_PDTCH_INFO *)(msg->SigP))->pm_fullres = tm_pm_fullres; // F26.6 + ((T_TMODE_PDTCH_INFO *)(msg->SigP))->snr = tm_snr; + ((T_TMODE_PDTCH_INFO *)(msg->SigP))->toa = tm_toa; + ((T_TMODE_PDTCH_INFO *)(msg->SigP))->angle = tm_angle; // signed + for (i=0;i<8;i++) + ((T_TMODE_PDTCH_INFO *)(msg->SigP))->crc_error_tbl[i] = crc_error_tbl[i]; + + // send TMODE_TCH_INFO message... + os_send_sig(msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + // reset static TM variables for stats collection + tm_pm_fullres = 0; + tm_snr = 0; + tm_toa = 0; + tm_angle = 0; + } + #endif + } + + } //end of test "if((en_task) && !(task_param))" + + // End of task -> task must become INACTIVE. + // PDTCH can be pipelined and therefore must stay active if + // it has already reentered the flow. + if(burst_id == BURST_4) + { + if(l1s.task_status[task].current_status == RE_ENTERED) + l1s.task_status[task].current_status = ACTIVE; + else + l1s.task_status[task].current_status = INACTIVE; + } + + #if 0 /* FreeCalypso TCS211 reconstruction */ + l1ddsp_read_iq_dump(task); + #endif + // Flag the use of the MCU/DSP dual page read interface. + // ****************************************************** + + // Set flag used to change the read page at the end of "l1_synch". + l1s_dsp_com.dsp_r_page_used = TRUE; +} +//#pragma DUPLICATE_FOR_INTERNAL_RAM_END +#endif // MOVE_IN_INTERNAL_RAM + +/*-------------------------------------------------------*/ +/* l1ps_read_pra_result() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : */ +/*-------------------------------------------------------*/ +void l1ps_read_pra_result(UWORD8 task, UWORD8 burst_id) +{ + /*--------------------------------------------------------*/ + /* READ TRANSMIT TASK RESULTS... */ + /*--------------------------------------------------------*/ + + /*---------------------------------------------------*/ + /* Packet Access task. */ + /*---------------------------------------------------*/ + // Rem: confirmation message is sent at "CTRL" to be able to give FN%42432. + BOOL confirm_flag = TRUE; // Default is: confirmation message is sent. + + // Desactivate the PRACH task. + l1s.task_status[task].current_status = INACTIVE; + + l1_check_com_mismatch(task); + + + #if (TRACE_TYPE!=0) + trace_fct(CST_L1PS_READ_PRA, l1pa_l1ps_com.p_idle_param.radio_freq); + #endif + + #if FF_L1_IT_DSP_USF + // Check PRACH was controlled + if (l1pa_l1ps_com.pra_info.prach_controlled) + { + #endif + + // Check USF in case of Dynamic Allocation. + if(l1pa_l1ps_com.pra_info.prach_alloc != FIX_PRACH_ALLOC) + { + API cs_type = l1ps_dsp_com.pdsp_ndb_ptr->a_du_gprs[0][0]; + + if(cs_type != CS_NONE_TYPE) + confirm_flag = FALSE; + } + + if (confirm_flag == TRUE) + { + // Send confirmation msg to L1A. + // ****************************** + // For ACCESS phase, a confirmation msg is sent to L1A. + xSignalHeaderRec *msg; + + // send L1C_RA_DONE to L1A... + msg = os_alloc_sig(sizeof(T_MPHP_RA_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + + ((T_MPHP_RA_CON *)(msg->SigP))->fn = l1pa_l1ps_com.pra_info.fn_to_report; + ((T_MPHP_RA_CON *)(msg->SigP))->channel_request_data = l1pa_l1ps_com.pra_info.channel_request_data; + msg->SignalCode = L1P_RA_DONE; + + os_send_sig(msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + } + + // Set flag used to change the read page at the end of "l1_synch". + l1s_dsp_com.dsp_r_page_used = TRUE; + + #if FF_L1_IT_DSP_USF + } // if (l1pa_l1ps_com.pra_info.prach_controlled) + #endif +} + +/*-------------------------------------------------------*/ +/* l1ps_read_poll_result() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : */ +/*-------------------------------------------------------*/ +void l1ps_read_poll_result(UWORD8 task, UWORD8 burst_id) +{ + /*--------------------------------------------------------*/ + /* READ TRANSMIT TASK RESULTS... */ + /*--------------------------------------------------------*/ + + l1_check_com_mismatch(task); + + #if (TRACE_TYPE!=0) && (TRACE_TYPE!=5) // in debug trace all reads + trace_fct(CST_L1PS_READ_POLL, l1pa_l1ps_com.p_idle_param.radio_freq); + #endif + + /*--------------------------------------------------------*/ + /* POLL task (4xPRACH) upon packet queueing notification. */ + /*--------------------------------------------------------*/ + + // Deactivate the PRACH task. + if(burst_id == BURST_4) + { + // POLL is a 'one shot' task --> disable task + l1a_l1s_com.l1s_en_task[task] = TASK_DISABLED; + + l1s.task_status[task].current_status = INACTIVE; + + #if (TRACE_TYPE==5) // in simulation trace only the latest burst + trace_fct(CST_L1PS_READ_POLL, l1pa_l1ps_com.p_idle_param.radio_freq); + #endif + + // Send confirmation msg to L1A. + // ****************************** + // For PACKET POLLING, a confirmation msg is sent to L1A. + { + xSignalHeaderRec *msg; + + // send L1C_RA_DONE to L1A... + msg = os_alloc_sig(sizeof(T_MPHP_POLLING_IND)); + DEBUGMSG(status,NU_ALLOC_ERR) + + ((T_MPHP_POLLING_IND *)(msg->SigP))->fn = l1pa_l1ps_com.poll_info.fn_to_report; + msg->SignalCode = L1P_POLL_DONE; + + os_send_sig(msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + #if 0 /* FreeCalypso TCS211 reconstruction */ + l1ddsp_read_iq_dump(task); + #endif + // Set flag used to change the read page at the end of "l1_synch". + l1s_dsp_com.dsp_r_page_used = TRUE; +} + +#if !((MOVE_IN_INTERNAL_RAM == 1) && (GSM_IDLE_RAM !=0)) // MOVE TO INTERNAL MEM IN CASE GSM_IDLE_RAM enabled +//#pragma GSM_IDLE_DUPLICATE_FOR_INTERNAL_RAM_START // KEEP IN EXTERNAL MEM otherwise + +/*-------------------------------------------------------*/ +/* l1ps_ctrl_snb_dl() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* This function is a "COMPLEX" function used by the L1S */ +/* packet serving cell normal burst reading tasks: PNP, */ +/* PEP, PALLC. This function is the control function for */ +/* reading a normal burst on the packet serving cell. */ +/* It programs the DSP and the TPU for reading a */ +/* normal burst. This function flags the reading of the */ +/* Packet Normal paging burst which flag is used in */ +/* measurement manager procedure. */ +/* Here below is a summary of the execution: */ +/* */ +/* - If SEMAPHORE(task) is low. */ +/* - Catch ARFCN and set CIPHERING reduced frame */ +/* number. */ +/* - Traces and debug. */ +/* - Programs DSP for required task. */ +/* - Programs TPU for required task. */ +/* - Flag the reading of a Packet Normal Paging */ +/* burst. */ +/* - Flag DSP and TPU programmation. */ +/* */ +/* Input parameters: */ +/* ----------------- */ +/* "l1a_l1s_com.task_param" */ +/* task semaphore bit register. Used to skip */ +/* the body of this function if L1A has changed or */ +/* is changing some of the task parameters. */ +/* */ +/* "task" */ +/* PNP, Packet Normal paging reading task. */ +/* PEP, Packet Extended paging reading task. */ +/* PALLC, All Packet serving cell PCCCH reading task. */ +/* */ +/* "burst_id" */ +/* BURST_1, 1st burst of the task. */ +/* BURST_2, 2nd burst of the task. */ +/* BURST_3, 3rd burst of the task. */ +/* BURST_4, 4th burst of the task. */ +/* */ +/* Input parameters from globals: */ +/* ------------------------------ */ +/* "l1a_l1s_com.Scell_info" */ +/* Serving cell information structure. */ +/* .radio_freq, serving cell beacon frequency. */ +/* */ +/* "l1s.afc" */ +/* current AFC value to be applied for the given task. */ +/* */ +/* "l1s.tpu_offset" */ +/* value for the TPU SYNCHRO and OFFSET registers */ +/* for current serving cell setting. It is used here */ +/* to refresh the TPU SYNCHRO and OFFSET registers */ +/* with a corrected (time tracking of the serving) */ +/* value prior to reading a serving cell normal burst. */ +/* */ +/* Modified parameters from globals: */ +/* --------------------------------- */ +/* "pnp_ctrl" */ +/* Flag set when a packet normal paging burst reading */ +/* is controled. This flag is used by the packet */ +/* measurement manager procedure, at the end of L1S, */ +/* in order to scheduling the neighbor cell */ +/* measurements. */ +/* -> set to 1. */ +/* */ +/* */ +/* "l1s.tpu_ctrl_reg" */ +/* bit register used to know at the end of L1S if */ +/* something has been programmed on the MCU/TPU com. */ +/* This is used mainly to swap then the com. page at */ +/* the end of a control frame. */ +/* -> set CTRL_RX bit in the register. */ +/* */ +/* "l1s.dsp_ctrl_reg" */ +/* bit register used to know at the end of L1S if */ +/* something has been programmed on the MCU/DSP com. */ +/* This is used mainly to swap then the com. page at */ +/* the end of a control frame. */ +/* -> set CTRL_RX bit in the register. */ +/* */ +/*-------------------------------------------------------*/ +void l1ps_ctrl_snb_dl(UWORD8 task, UWORD8 burst_id) +{ + UWORD16 Scell_radio_freq; + UWORD8 tsc; + WORD8 agc; + UWORD8 lna_off; + UWORD8 adc_active = INACTIVE; + #if (RF_FAM == 61) + UWORD16 dco_algo_ctl_nb = 0; + UWORD8 if_ctl = 0; + UWORD8 if_threshold = C_IF_ZERO_LOW_THRESHOLD_GPRS; + // By default we choose the hardware filter + UWORD8 csf_filter_choice = L1_SAIC_HARDWARE_FILTER; + #endif + + #if (NEW_SNR_THRESHOLD == 1) + UWORD8 saic_flag = 0; + #endif /* NEW_SNR_THRESHOLD */ + + +#if (FF_L1_FAST_DECODING == 1) + BOOL fast_decoding_authorized = FALSE; + + if ( (burst_id == BURST_1) && (l1a_apihisr_com.fast_decoding.status == C_FAST_DECODING_FORBIDDEN) ) + { + l1a_apihisr_com.fast_decoding.status = C_FAST_DECODING_NONE; + } + + fast_decoding_authorized = l1s_check_fast_decoding_authorized(task); + + if ( fast_decoding_authorized && l1s_check_deferred_control(task,burst_id) ) + { + /* Control is deferred until the upcoming fast decoding IT */ + return; + } /* if (fast_decoding_authorized)*/ + + /* In all other cases, control must be performed now. */ +#endif /* FF_L1_FAST_DECODING == 1 */ + + if(!(l1a_l1s_com.task_param[task] == SEMAPHORE_SET)) + // Check the task semaphore. The control body is executed only + // when the task semaphore is 0. This semaphore can be set to + // 1 whenever L1A makes some changes to the task parameters. + { + Scell_radio_freq = l1a_l1s_com.Scell_info.radio_freq; + + // Catch training sequence code from serving cell BCC (part of BSIC). + tsc = l1pa_l1ps_com.pccch.packet_chn_desc.tsc; + + // Packet PAGC Algorithm + // ********************** + + // for PCCCH serving blocks (PPCH, PEPCH, all PCCCH) we use + // PAGC algorithm. Reference is serving cell. + l1pctl_pagc_ctrl(&agc, &lna_off, l1pa_l1ps_com.p_idle_param.radio_freq,TRUE); + + #if(RF_FAM == 61) // Locosto DCO + cust_get_if_dco_ctl_algo(&dco_algo_ctl_nb, &if_ctl, (UWORD8) L1_IL_VALID , + l1a_l1s_com.Scell_used_IL.input_level, + l1pa_l1ps_com.p_idle_param.radio_freq, if_threshold); + l1ddsp_load_dco_ctl_algo_nb(dco_algo_ctl_nb); + #endif + + #if (L1_SAIC != 0) + // If SAIC is enabled, call the low level SAIC control function + // NOTE: l1a_l1s_com.Scell_used_IL.input_level is updated within + // the function l1pctl_pagc_ctrl + csf_filter_choice = l1ctl_saic(l1a_l1s_com.Scell_used_IL.input_level,l1a_l1s_com.mode + #if (NEW_SNR_THRESHOLD == 1) + ,task + ,&saic_flag + #endif + ); + #endif + + // Debug. + // ****************** + + l1s_dsp_com.dsp_db_w_ptr->d_debug = (l1s.debug_time + 2) ; +#if (FF_L1_FAST_DECODING == 1) + l1ddsp_load_fast_dec_task(task,burst_id); +#endif + + // Programs DSP Rx Packet Idle burst, still on Timeslot number = 0 + // due to previous synchro. + #if FF_L1_IT_DSP_USF + { + BOOL usf_it = FALSE; + + // Force IT USF interrupt during PCCCH reorg for Fast USF usage during + // Packet Access. Switch to PA could happen any time during PCCCH reorg. + // Only relevant for RBN%3 = 0 and 1 + if (l1a_l1s_com.l1s_en_task[PALLC] == TASK_ENABLED) + { + if (/*(l1s.next_time.fn_mod13 >= 0) && omaps00090550*/(l1s.next_time.fn_mod13 <= 7)) + usf_it = TRUE; + } + + l1pddsp_idle_rx_nb(burst_id, tsc, l1pa_l1ps_com.p_idle_param.radio_freq, 0, FALSE, usf_it); + } + #else + l1pddsp_idle_rx_nb(burst_id, tsc, l1pa_l1ps_com.p_idle_param.radio_freq, 0, FALSE); + #endif + + // ADC measurement + // *************** + // check if during the 1st burst of the bloc an ADC measurement must be performed + if ((burst_id == BURST_1) && (task == PNP)) + { + if (l1a_l1s_com.l1s_en_task[PALLC] == TASK_DISABLED) // no reorg mode + { + if (l1a_l1s_com.adc_mode & ADC_NEXT_NORM_PAGING) // perform ADC only one time + { + adc_active = ACTIVE; + l1a_l1s_com.adc_mode &= ADC_MASK_RESET_IDLE; // reset in order to have only one ADC measurement in Idle + } + else + { + if (l1a_l1s_com.adc_mode & ADC_EACH_NORM_PAGING) // perform ADC on each "period" x bloc + if ((++l1a_l1s_com.adc_cpt)>=l1a_l1s_com.adc_idle_period) // wait for the period + { + adc_active = ACTIVE; + l1a_l1s_com.adc_cpt = 0; + } + } + } + else // ADC measurement in reorg mode + { + if (l1a_l1s_com.adc_mode & ADC_NEXT_NORM_PAGING_REORG) // perform ADC only one time + { + adc_active = ACTIVE; + l1a_l1s_com.adc_mode &= ADC_MASK_RESET_IDLE; // reset in order to have only one ADC measurement in Idle + } + else + { + if (l1a_l1s_com.adc_mode & ADC_EACH_NORM_PAGING_REORG) // perform ADC on each "period" x bloc + if ((++l1a_l1s_com.adc_cpt)>=l1a_l1s_com.adc_idle_period) // wait for the period + { + adc_active = ACTIVE; + l1a_l1s_com.adc_cpt = 0; + } + } + } + } + + #if (TRACE_TYPE!=0) && (TRACE_TYPE!=5) + trace_fct(CST_L1PS_CTRL_SNB_DL, -1); + #endif + + // Programs TPU for required task. + // ******************************** + + // update the TPU with the new TOA if necessary + l1ctl_update_TPU_with_toa(); + + // tpu pgm... + l1dtpu_serv_rx_nb(l1pa_l1ps_com.p_idle_param.radio_freq, + agc, + lna_off, + l1s.tpu_offset, + l1s.tpu_offset, + FALSE,adc_active + #if (RF_FAM == 61) + ,csf_filter_choice + ,if_ctl + #endif + #if (NEW_SNR_THRESHOLD == 1) + ,saic_flag + #endif /* NEW_SNR_THRESHOLD */ + ); + + // Increment tpu window identifier. + l1s.tpu_win += (l1_config.params.rx_synth_load_split + RX_LOAD); + } + + // Flag the reading of a Normal Packet Paging burst. + // ************************************************* + + // Set PNP controlled flag, used in l1s_meas_manager() to generate measurement only + // if we are not receiving a PPCH. + if((task == PNP) || (task == PEP) || (task == PALLC)) + l1pa_l1ps_com.cr_freq_list.pnp_ctrl = burst_id + 1; + + + // Flag DSP and TPU programmation. + // ******************************** + + // Set "CTRL_RX" flag in the controle flag register. + l1s.tpu_ctrl_reg |= CTRL_RX; + l1s.dsp_ctrl_reg |= CTRL_RX; + +} // end of procedure + +/*-------------------------------------------------------*/ +/* l1ps_read_nb_dl() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* This function is a "COMPLEX" function used by the L1S */ +/* tasks: PNP,PEP,PALLC. */ +/* */ +/* Here is a summary of the execution: */ +/* */ +/* - If SEMAPHORE(task) is low and task still enabled. */ +/* - Traces and debug. */ +/* - Read control results and feed control algo. */ +/* - Read DL DATA block from MCU/DSP interface. */ +/* - Disactivate task. */ +/* - Flag the use of the MCU/DSP dual page read */ +/* interface. */ +/* */ +/* Input parameters: */ +/* ----------------- */ +/* "task" */ +/* PNP, Packet Normal paging reading task. */ +/* PEP, Packet Extended paging reading task. */ +/* PALLC, All packet serving cell PCCCH reading task. */ +/* */ +/* "burst_id" */ +/* BURST_1, 1st burst of the task. */ +/* BURST_2, 2nd burst of the task. */ +/* BURST_3, 3rd burst of the task. */ +/* BURST_4, 4th burst of the task. */ +/* */ +/* Input parameters from globals: */ +/* ------------------------------ */ +/* "l1pa_l1ps_com.task_param[NBR_DL_L1S_TASKS]" */ +/* packet task semaphore table. Used to skip */ +/* the body of this function if L1A has changed or */ +/* is changing some of the task parameters. */ +/* */ +/* "l1a_l1s_com.l1s_en_task[NBR_DL_L1S_TASKS]" */ +/* L1S task enable. */ +/* */ +/* Modified parameters from globals: */ +/* --------------------------------- */ +/* "l1s.task_status[task].current_status" */ +/* current task status. It must be reset (INACTIVE) */ +/* when the task is completed. */ +/* -> disactivate task. */ +/* */ +/* "l1s_dsp_com.dsp_r_page_used" */ +/* Flag used by the function which closes L1S */ +/* execution ("l1s_end_manager()") to know if the */ +/* MCU/DSP read page must be switched. */ +/* -> Set to 1. */ +/* */ +/* Use of MCU/DSP interface: */ +/* ------------------------- */ +/* "l1s_dsp_com.dsp_ndb_ptr" */ +/* pointer to the non double buffered part (NDB) of */ +/* the MCU/DSP interface. This part is R/W for both */ +/* DSP and MCU. */ +/* */ +/* "l1s_dsp_com.dsp_db_r_ptr" */ +/* pointer to the double buffered part (DB) of the */ +/* MCU/DSP interface. This pointer points to the READ */ +/* page. */ +/* */ +/*-------------------------------------------------------*/ +void l1ps_read_nb_dl(UWORD8 task, UWORD8 burst_id) +{ + UWORD32 toa=0; //omaps00090550 + UWORD32 pm=0; //omaps00090550; + UWORD32 angle =0; //omaps00090550 + UWORD32 snr =0; //omaps00090550 + BOOL en_task; + BOOL task_param; + UWORD16 scell_radio_freq; + static UWORD16 pwr_level; + +#if (FF_L1_FAST_DECODING == 1) + UWORD8 skipped_bursts = 0; + BOOL fast_decoding_authorized = l1s_check_fast_decoding_authorized(task); + BOOL fast_decoded = (l1a_apihisr_com.fast_decoding.status == C_FAST_DECODING_COMPLETE); + if (fast_decoded) + { + skipped_bursts = BURST_4 - burst_id; + } +#endif /* if (FF_L1_FAST_DECODING == 1) */ + + /*--------------------------------------------------------*/ + /* READ SERVING CELL RECEIVE TASK RESULTS... */ + /*--------------------------------------------------------*/ + /* Rem: only a partial result is present in the mcu<-dsp */ + /* communication buffer. The DATA BLOCK content itself is */ + /* in the last comm. (BURST_4) */ + /*--------------------------------------------------------*/ + // Get "enable" task flag and "synchro semaphore" for current task. + en_task = l1a_l1s_com.l1s_en_task[task]; + task_param = l1a_l1s_com.task_param[task]; + + if((en_task) && !(task_param)) + // Check the task semaphore and the task enable bit. The reading + // task body is executed only when the task semaphore is 0 and the + // task is still enabled. + // The semaphore can be set to 1 whenever L1A makes some changes + // to the task parameters. The task can be disabled by L1A. + { + // Traces and debug. + // ****************** + l1_check_com_mismatch(task); + + // Read control results and feed control algorithms. + // ************************************************** + if ((task != PBCCHN_TRAN) && (task != PBCCHN_IDLE)) + { + // From the fact that PBCCHS can be read in CS mode, + // Idle mode and Packet Idle mode, a check on the current active DSP scheduler mode + // has to be performed. + // Read control information. + // We keep compatibility with (chipset == 0) imply mask with 0xffff. + // If only (chipset == 2) is used, mask can be removed. + if (l1a_l1s_com.dsp_scheduler_mode == GSM_SCHEDULER) + { + toa = l1s_dsp_com.dsp_db_r_ptr->a_serv_demod[D_TOA] & 0xffff; + pm = (l1s_dsp_com.dsp_db_r_ptr->a_serv_demod[D_PM] & 0xffff) >> 5; + angle = l1s_dsp_com.dsp_db_r_ptr->a_serv_demod[D_ANGLE] & 0xffff; + snr = l1s_dsp_com.dsp_db_r_ptr->a_serv_demod[D_SNR] & 0xffff; + } + else + { + toa = l1ps_dsp_com.pdsp_db_r_ptr->a_burst_toa_gprs[0] & 0xffff; + pm = (l1ps_dsp_com.pdsp_db_r_ptr->a_burst_pm_gprs[0] & 0xffff)>>5; + angle = l1ps_dsp_com.pdsp_db_r_ptr->a_burst_angle_gprs[0] & 0xffff; + snr = l1ps_dsp_com.pdsp_db_r_ptr->a_burst_snr_gprs[0] & 0xffff; + } + + #if (TRACE_TYPE!=0) && (TRACE_TYPE!=5) + trace_fct(CST_L1PS_READ_NB_DL, -1); + #endif + + l1_check_pm_error(pm,task); + + // Update AGC: Call PAGC algorithm + l1a_l1s_com.Scell_IL_for_rxlev = l1pctl_pagc_read((UWORD8)pm, l1pa_l1ps_com.p_idle_param.radio_freq_dd); + +#if (FF_L1_FAST_DECODING == 1) + if (skipped_bursts>0) + { + l1ctl_pagc_missing_bursts(skipped_bursts); + } +#endif /* if (FF_L1_FAST_DECODING == 1) */ + + // Update AFC: Call AFC control function (KALMAN filter). + #if AFC_ALGO + { + WORD16 old_afc = l1s.afc; + WORD16 old_count= l1s.afc_frame_count; + + scell_radio_freq = l1a_l1s_com.Scell_info.radio_freq; + #if (VCXO_ALGO==0) + l1s.afc = l1ctl_afc(AFC_CLOSED_LOOP, &l1s.afc_frame_count, (WORD16)angle, snr, scell_radio_freq); + #else + l1s.afc = l1ctl_afc(AFC_CLOSED_LOOP, &l1s.afc_frame_count, (WORD16)angle, snr, scell_radio_freq,l1a_l1s_com.mode); + #endif + #if L2_L3_SIMUL + #if (DEBUG_TRACE == BUFFER_TRACE_AFC_OPEN) + buffer_trace (4,(WORD16)angle,old_count,old_afc,l1s.afc); + #endif + #endif + } + #endif + + // Feed TOA histogram only when the TOA result is used in the task CTRL function + if (task != PBCCHS) + { + //Feed TOA histogram. + #if (TOA_ALGO != 0) + #if (TOA_ALGO == 2) + if(l1s.toa_var.toa_snr_mask == 0) + #else + if(l1s.toa_snr_mask == 0) + #endif + { + #if (TOA_ALGO == 2) + UWORD32 snr_temp; + snr_temp = (l1a_l1s_com.Scell_IL_for_rxlev < IL_FOR_RXLEV_SNR) ? snr: 0; + l1s.toa_var.toa_shift = l1ctl_toa(TOA_RUN, l1a_l1s_com.mode, snr_temp, toa); + #else + /* FreeCalypso TCS211 reconstruction */ + if (l1a_l1s_com.Scell_IL_for_rxlev < IL_FOR_RXLEV_SNR) + { + l1s.toa_shift = l1ctl_toa(TOA_RUN, l1a_l1s_com.mode, snr, toa, + &l1s.toa_update, + &l1s.toa_period_count + #if (FF_L1_FAST_DECODING == 1) + ,0 + #endif + ); + } + else + { + l1s.toa_shift = l1ctl_toa(TOA_RUN, l1a_l1s_com.mode, 0, toa, + &l1s.toa_update, + &l1s.toa_period_count + #if (FF_L1_FAST_DECODING == 1) + ,0 + #endif + ); + } + #endif + } + #endif + } + } + + #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + RTTL1_FILL_DL_BURST(angle, snr, l1s.afc, task, pm, toa, l1a_l1s_com.Scell_IL_for_rxlev + l1a_l1s_com.Scell_info.pb) + #endif + #if 0 //(TRACE_TYPE == 1) || (TRACE_TYPE == 4) // TCS211 reconstruction + l1_trace_burst_param(angle, snr, l1s.afc, task, pm, toa, l1a_l1s_com.Scell_IL_for_rxlev + l1a_l1s_com.Scell_info.pb); + #endif + #if (BURST_PARAM_LOG_ENABLE == 1) + l1_log_burst_param(angle, snr, l1s.afc, task, pm, toa, l1a_l1s_com.Scell_IL_for_rxlev + l1a_l1s_com.Scell_info.pb); + #endif + // compute the Data bloc Power. + // ****************************** + if(burst_id == BURST_1) + pwr_level = 0; + + // add the burst power + pwr_level += l1a_l1s_com.Scell_IL_for_rxlev; + + + // Read downlink DATA block from MCU/DSP interface. + // ************************************************* + #if (FF_L1_FAST_DECODING == 1) + /* Perform the reporting if + - Burst is the 4th one (whether CRC is ok or not) + - Fast decoding enabled and CRC already ok + */ + if ( (burst_id == BURST_4) || fast_decoded ) + #else /* #if (FF_L1_FAST_DECODING == 1) */ + if(burst_id == BURST_4) + #endif /* FF_L1_FAST_DECODING */ + { + #if (TRACE_TYPE==2 ) || (TRACE_TYPE==3) + uart_trace(task); + #endif +#if (FF_L1_FAST_DECODING == 1) + /* Data power block = pwr_level / (nb of bursts)*/ + pwr_level = pwr_level / (burst_id + 1); +#else /* #if (FF_L1_FAST_DECODING == 1) */ + // the data power bloc = pwr_level/4. + pwr_level = pwr_level >> 2; +#endif /* #if (FF_L1_FAST_DECODING == 1) #else*/ + + // Read L3 frame block and send msg to L1A. +#if (FF_L1_FAST_DECODING == 1) + if(!fast_decoding_authorized) + { + /* When fast decoding wasn't used, burst_id is undefined (for the trace) */ + l1a_l1s_com.last_fast_decoding = 0; + } + else + { + l1a_l1s_com.last_fast_decoding = burst_id + 1; + } +#endif /* #if (FF_L1_FAST_DECODING == 1) */ + + // Read L3 frame block and send msg to L1A. + if (l1a_l1s_com.dsp_scheduler_mode == GSM_SCHEDULER) + l1s_read_l3frm(pwr_level,&(l1s_dsp_com.dsp_ndb_ptr->a_cd[0]), task); + else + l1s_read_l3frm(pwr_level,&(l1ps_dsp_com.pdsp_ndb_ptr->a_dd_gprs[0][0]), task); + + } // End if... + + } //end of test "if((en_task) && !(task_param))" + + // Disactivate task. + // ****************** + + // End of task -> task must become INACTIVE. + // Rem: some TASKS (PALLC, PNP (with SPLIT > M)) can be pipelined and therefore + // must stay active if they have already reentered the flow. +#if (FF_L1_FAST_DECODING == 1) + /*------------------------------------------------------*/ + /* Perform the reporting if */ + /* - Burst is the 4th one (whether CRC is ok or not) */ + /* - Fast decoding enabled and CRC already ok */ + /*------------------------------------------------------*/ + if ( (burst_id == BURST_4) || fast_decoded ) +#else /* #if (FF_L1_FAST_DECODING == 1) */ + if(burst_id == BURST_4) +#endif /* #if (FF_L1_FAST_DECODING == 1) #else*/ + { +#if (FF_L1_FAST_DECODING == 1) + if(task == PNP) + { + if (l1a_apihisr_com.fast_decoding.contiguous_decoding == TRUE) + { + /* A new block has started, a new fast API IT is expected */ + l1a_apihisr_com.fast_decoding.contiguous_decoding = FALSE; + l1a_apihisr_com.fast_decoding.status = C_FAST_DECODING_AWAITED; + } + else if(task == l1a_apihisr_com.fast_decoding.task) + { + /* Reset decoding status */ + l1a_apihisr_com.fast_decoding.status = C_FAST_DECODING_NONE; + } + } /*task == PNP */ +#endif /* #if (FF_L1_FAST_DECODING == 1) */ + if(l1s.task_status[task].current_status == RE_ENTERED) + l1s.task_status[task].current_status = ACTIVE; + else + l1s.task_status[task].current_status = INACTIVE; +#if (FF_L1_FAST_DECODING == 1) + if (burst_id != BURST_4) + { + l1s_clean_mftab(task, burst_id + 3); + if(l1s.frame_count == (4 -burst_id)) + { + l1s.frame_count = 1; + } + } +#endif /* #if (FF_L1_FAST_DECODING == 1) */ + } + + #if 0 /* FreeCalypso TCS211 reconstruction */ + l1ddsp_read_iq_dump(task); + #endif + // Flag the use of the MCU/DSP dual page read interface. + // ****************************************************** + + // Set flag used to change the read page at the end of "l1_synch". + l1s_dsp_com.dsp_r_page_used = TRUE; + +} // end of procedure + +//#pragma GSM_IDLE_DUPLICATE_FOR_INTERNAL_RAM_END // KEEP IN EXTERNAL MEM otherwise +#endif +/*-------------------------------------------------------*/ +/* l1ps_ctrl_pbcch() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* This function is a "COMPLEX" function used by the L1S */ +/* tasks: neighbor cell PBCCH. */ +/* This function is the control function */ +/* for reading a PBCCH burst on the neighbor cell. */ +/* This control function: */ +/* a) shifts the OFFSET register to match the normal */ +/* burst received task with the PBCCH timeslot number.*/ +/* */ +/* b) programs a normal burst reading and restores the */ +/* OFFSET to the serving cell timeslot. On the last */ +/* control (4th burst), the SYNCHRO/OFFSET registers */ +/* are shifted back to the normal idle mode PCCH */ +/* reading setting. Here is a summary of the */ +/* execution: */ +/* */ +/* - If SEMAPHORE(task) is low. */ +/* - Traces and debug. */ +/* - Programs DSP for PBCCH task, reading 1 burst. */ +/* - Programs TPU for PBCCH task, reading 1 burst. */ +/* - Shift TPU SYNCHRO/OFFSET registers back to the */ +/* PACKET PAGING TASK timeslot. */ +/* - Flag DSP and TPU programmation. */ +/* */ +/* Input parameters: */ +/* ----------------- */ +/* "task" */ +/* PBCCH_TRA or PBCCH_IDLE or PBCCHS */ +/* Serving Cell PBCCH reading task. */ +/* */ +/* Input parameters from globals: */ +/* ------------------------------ */ +/* "l1pa_l1ps_com.pbcch " */ +/* Neigh/serv Cell PBCCH description structure. */ +/* */ +/* "l1a_l1s_com.Scell_info.radio_freq" */ +/* BSIC of the serving cell. It is used here to pass */ +/* the training sequence number (part of BSIC) to the */ +/* DSP. */ +/* */ +/* "l1a_l1s_com.offset_tn0" */ +/* value to load in the OFFSET register to shift then */ +/* any receive task to the timeslot 0 of the neighbor */ +/* cell or PBCCH timeslot number . */ +/* */ +/* "l1s.tpu_offset" */ +/* value for the TPU SYNCHRO and OFFSET registers */ +/* for current serving cell setting. It is used here */ +/* at the end of the PBCCH task controls to restore */ +/* the SYNCHRO/OFFSET registers to the normal setting */ +/* in idle mode. */ +/* */ +/* Modified parameters from globals: */ +/* --------------------------------- */ +/* "l1s.actual_time, l1s.next_time" */ +/* frame number and derived numbers for current frame */ +/* and next frame. */ +/* -> update to cope with side effect due to synchro. */ +/* changes/restores. */ +/* */ +/* "l1s.tpu_ctrl_reg" */ +/* bit register used to know at the end of L1S if */ +/* something has been programmed on the MCU/TPU com. */ +/* This is used mainly to swap then the com. page at */ +/* the end of a control frame. */ +/* -> set CTRL_RX bit in the register. */ +/* */ +/* "l1s.dsp_ctrl_reg" */ +/* bit register used to know at the end of L1S if */ +/* something has been programmed on the MCU/DSP com. */ +/* This is used mainly to swap then the com. page at */ +/* the end of a control frame. */ +/* -> set CTRL_RX bit in the register. */ +/* */ +/*-------------------------------------------------------*/ +void l1ps_ctrl_pbcch(UWORD8 task, UWORD8 burst_id) +{ + UWORD16 rx_radio_freq; + UWORD32 offset_pbcch; + WORD8 agc; + UWORD8 lna_off; + UWORD32 dsp_task; + UWORD8 tsc; + UWORD8 serving_cell; + #if (RF_FAM == 61) + UWORD16 dco_algo_ctl_nb=0; + UWORD8 if_ctl = 0; + UWORD8 if_threshold = C_IF_ZERO_LOW_THRESHOLD_GPRS; + // By default we choose the hardware filter + UWORD8 csf_filter_choice = L1_SAIC_HARDWARE_FILTER; + #endif + #if (NEW_SNR_THRESHOLD == 1) + UWORD8 saic_flag=0; + #endif /* NEW_SNR_THRESHOLD */ + static WORD32 new_tpu_offset; + static BOOL change_synchro; + + #define PbcchS l1pa_l1ps_com.pbcchs + #define PbcchN l1pa_l1ps_com.pbcchn + + #if (CODE_VERSION == SIMULATION) + UWORD32 tpu_w_page; + + if (hw.tpu_r_page==0) + tpu_w_page=1; + else + tpu_w_page=0; + + hw.rx_id[tpu_w_page][0]=0; + hw.num_rx[tpu_w_page][0]=1; + hw.rx_group_id[tpu_w_page]=1; + #endif + + if (task == PBCCHS) + { + tsc = PbcchS.packet_chn_desc.tsc; + offset_pbcch = (PbcchS.tn_pbcch * TN_WIDTH); + serving_cell = TRUE; + } + else + { + tsc = PbcchN.packet_chn_desc.tsc; + offset_pbcch = PbcchN.time_alignmt; + serving_cell = FALSE; + } + + if((l1a_l1s_com.l1s_en_task[task] == TASK_ENABLED) && + !(l1a_l1s_com.task_param[task] == SEMAPHORE_SET)) + // Check the task semaphore. The control body is executed only + // when the task semaphore is 0. This semaphore can be set to + // 1 whenever L1A makes some changes to the task parameters. + { + // Get ARFCN to be used for current control. Output of the hopping algorithm. + rx_radio_freq = l1pa_l1ps_com.p_idle_param.radio_freq; + + // Traces and debug. + // ****************** + + #if (TRACE_TYPE==5) && FLOWCHART + trace_flowchart_dsp_tpu(dltsk_trace[task].name); + #endif + + #if (TRACE_TYPE!=0) + if (task == PBCCHS) + trace_fct(CST_L1PS_CTRL_PBCCHS, l1a_l1s_com.Scell_info.radio_freq); + else + trace_fct(CST_L1PS_CTRL_PBCCHN, PbcchN.bcch_carrier); + #endif + + l1s_dsp_com.dsp_db_w_ptr->d_debug = (l1s.debug_time + 2) ; + + // Programs DSP for PBCCHN task according to the DSP scheduler used + // ***************************************************************** + switch(l1a_l1s_com.dsp_scheduler_mode) + { + // dsp pgm is made using GSM scheduler... + case GSM_SCHEDULER: + dsp_task = l1s_swap_iq_dl(rx_radio_freq, task); + + // dsp pgm... + l1ddsp_load_rx_task(dsp_task,burst_id,tsc); + break; + + // dsp pgm is made using GPRS scheduler... + case GPRS_SCHEDULER: + #if FF_L1_IT_DSP_USF + l1pddsp_idle_rx_nb(burst_id,tsc,rx_radio_freq,0,FALSE,FALSE); + #else + l1pddsp_idle_rx_nb(burst_id,tsc,rx_radio_freq,0,FALSE); + #endif + break; + } + + // Check if "Synchro" change is needed. + // ************************************* + // If so the synchro is changed by 4 timeslots. + if(burst_id == BURST_1) + { + if (task == PBCCHS) + change_synchro = PbcchS.change_synchro; + else + change_synchro = PbcchN.change_synchro; + + if(change_synchro) + { + // compute TPU offset for "current timeslot + 4 timeslot" + new_tpu_offset = l1s.tpu_offset + (4 * TN_WIDTH); + + if(new_tpu_offset >= TPU_CLOCK_RANGE) + new_tpu_offset -= TPU_CLOCK_RANGE; + + // Slide synchro to match current timeslot + 4 timeslot. + l1dmacro_synchro(SWITCH_TIME, new_tpu_offset); + } + else + { + new_tpu_offset = l1s.tpu_offset; + } + } + + // TPU pgm... + //----------- + offset_pbcch += new_tpu_offset; + if (offset_pbcch >= TPU_CLOCK_RANGE) + offset_pbcch -= TPU_CLOCK_RANGE; + + // add for debug TPU simu + #if (CODE_VERSION == SIMULATION) + if (task == PBCCHS) // PBCCH serving, compute Ts related to the L1 synchro on the serving + hw.rx_id[tpu_w_page][0]=((TPU_CLOCK_RANGE-new_tpu_offset+offset_pbcch)%TPU_CLOCK_RANGE)/TN_WIDTH; + else // PBCCH Neighbor -> special value for PBCCHN detection in the DSP task + hw.rx_id[tpu_w_page][0]=10; + #endif + + // agc is set with the input_level computed from PAGC algo + l1pctl_pagc_ctrl(&agc, &lna_off, rx_radio_freq, serving_cell); + +#if(RF_FAM == 61) // Locosto DCO + cust_get_if_dco_ctl_algo(&dco_algo_ctl_nb, &if_ctl, (UWORD8) L1_IL_VALID , + l1a_l1s_com.Scell_used_IL.input_level , rx_radio_freq, if_threshold); + l1ddsp_load_dco_ctl_algo_nb(dco_algo_ctl_nb); +#endif + + #if (L1_SAIC != 0) + // If SAIC is enabled, call the low level SAIC control function + // NOTE: l1a_l1s_com.Scell_used_IL.input_level is updated within + // l1pctl_pagc_ctrl + if(task == PBCCHS) + { + // Call SAIC only for PBCCHS, not for PBCCHN_TRAN or PBCCHN_IDLE + csf_filter_choice = l1ctl_saic(l1a_l1s_com.Scell_used_IL.input_level,l1a_l1s_com.mode + #if (NEW_SNR_THRESHOLD == 1) + ,task + ,&saic_flag + #endif + ); + } +#endif + + l1dmacro_offset (offset_pbcch, l1_config.params.rx_change_offset_time); // Slide offset to cope with PBCCHN in the new sychro. + l1dmacro_rx_synth(rx_radio_freq); // load SYNTH. + l1dmacro_agc (rx_radio_freq,agc, lna_off + #if(RF_FAM == 61) + ,if_ctl + #endif + ); // load AGC. +#if (L1_MADC_ON == 1) +#if (RF_FAM == 61) + l1dmacro_rx_nb (rx_radio_freq,INACTIVE, csf_filter_choice +#if (NEW_SNR_THRESHOLD == 1) + ,saic_flag +#endif /* NEW_SNR_THRESHOLD */ + ); // RX window for NB. +#endif /* RF_FAM == 61*/ +#else /* L1_MADC_ON == 1*/ + l1dmacro_rx_nb (rx_radio_freq); // RX window for NB. +#endif + + if (task == PBCCHS) + { + #if ((ANLG_FAM == 1) || (ANLG_FAM == 2) || (ANLG_FAM == 3)) + l1ddsp_load_afc(l1s.afc); // Loading the afc value in DB,Flag the presence of a new afc value to send + #endif + #if (RF_FAM == 61) + l1dtpu_load_afc(l1s.afc); + #endif + } + l1dmacro_offset (new_tpu_offset, IMM); // Restore offset. + } // End if(task enabled and semaphore false) + + // Remark: + //-------- + // When the task is aborted, we must continue to make dummy + // DSP programming to avoid communication mismatch due + // to C/W/R pipelining. + + // We must also ensure the Synchro back since synchro change has surely be done + // in the 1st CTRL phase. + + // Shift TPU SYNCHRO/OFFSET registers back to the default timeslot (normally PCCCH one). + // ************************************************************************************** + // When the PBCCHN or PBCCHS reading control is completed , + // the SYNCHRO/OFFSET registers are shifted back to the normal idle + // setting used for PCCH reading on the serving cell. + // Check if "Synchro" change was needed. + // If so the synchro is changed to recover normal synchro. + if(burst_id == BURST_4) + { + if(change_synchro) + { + // Slide synchro back to mach current serving timeslot. + l1dmacro_synchro(SWITCH_TIME, l1s.tpu_offset); + + // Increment frame number. + l1s.actual_time = l1s.next_time; + l1s.next_time = l1s.next_plus_time; + l1s_increment_time(&(l1s.next_plus_time), 1); // Increment "next_plus time". + + l1s.tpu_ctrl_reg |= CTRL_SYCB; + l1s.dsp_ctrl_reg |= CTRL_SYNC; + + #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + trace_fct(CST_L1S_ADJUST_TIME, -1); + #endif + } + } + + // Flag DSP and TPU programmation. + // ******************************** + + // Set "CTRL_RX" flag in the controle flag register. + l1s.tpu_ctrl_reg |= CTRL_RX; + l1s.dsp_ctrl_reg |= CTRL_RX; + + // This task is not compatible with Neigh. Measurement. Store task length + // in "forbid_meas" to indicate when the task will last. + if((burst_id == BURST_1) && (task != PBCCHN_IDLE)) + { + // In PBCCHN_IDLE task, l1s.forbid_meas is set by the AGC ctrl + l1s.forbid_meas = TASK_ROM_MFTAB[task].size; + } +} + +#if (MOVE_IN_INTERNAL_RAM == 0) // Must be followed by the pragma used to duplicate the funtion in internal RAM +//#pragma DUPLICATE_FOR_INTERNAL_RAM_START + +/*-------------------------------------------------------*/ +/* l1ps_ctrl_ptcch() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* */ +/* Input parameters: */ +/* ----------------- */ +/* */ +/* Input parameters from globals: */ +/* ------------------------------ */ +/* */ +/* Modified parameters from globals: */ +/* --------------------------------- */ +/* */ +/*-------------------------------------------------------*/ +void l1ps_ctrl_ptcch(UWORD8 param1, UWORD8 param2) +{ + UWORD16 radio_freq; + UWORD8 burst_nb; + #if (RF_FAM == 61) + UWORD16 dco_algo_ctl_nb = 0; + UWORD8 if_ctl = 0; + UWORD8 if_threshold = C_IF_ZERO_LOW_THRESHOLD_GPRS; + #endif + #if (NEW_SNR_THRESHOLD == 1) + UWORD8 saic_flag=0; + #endif /* NEW_SNR_THRESHOLD*/ + + if(!(l1a_l1s_com.task_param[PTCCH] == SEMAPHORE_SET)) + // Check the task semaphore. The control body is executed only + // when the task semaphore is 0. This semaphore can be set to + // 1 whenever L1A makes some changes to the task parameters. + { + WORD8 ts; + + radio_freq = l1pa_l1ps_com.transfer.ptcch.radio_freq; + + // Traces and debug. + // ****************** + #if (TRACE_TYPE!=0) + if(l1pa_l1ps_com.transfer.ptcch.activity && (PTCCH_DL || PTCCH_UL ) == 0) // trace only if a window is programmed. + trace_fct(CST_L1PS_CTRL_PTCCH_EMPTY, radio_freq); + #endif + + #if (TRACE_TYPE==5) && FLOWCHART + trace_flowchart_dsp_tpu(dltsk_trace[PTCCH].name); + #endif + + l1s_dsp_com.dsp_db_w_ptr->d_debug = (l1s.debug_time + 2) ; + + switch (l1s.next_time.fn_mod104) + { + case 12: burst_nb=0; break; + case 38: burst_nb=1; break; + case 64: burst_nb=2; break; + case 90: burst_nb=3; break; + default: burst_nb=0; break; + } + + // Compute timeslot number referenced to current camp timeslot. + ts = l1pa_l1ps_com.transfer.aset->packet_ta.ta_tn - l1a_l1s_com.dl_tn; + if(ts < 0) ts += 8; + else if(ts >= 8) ts -= 8; + + if(l1pa_l1ps_com.transfer.ptcch.activity & PTCCH_DL) + // PTCCH DL activity bit is set: PTCCH DL programmation is required. + { + #if (TRACE_TYPE!=0) + trace_fct(CST_L1PS_CTRL_PTCCH_DL_BURST0 + burst_nb, radio_freq); + #endif + + // Programs DSP for PTCCH/DL. + // *************************** + { + #if FF_L1_IT_DSP_USF + l1pddsp_idle_rx_nb(burst_nb, + l1pa_l1ps_com.transfer.aset->tsc, + radio_freq, + ts, + TRUE, + FALSE); + #else + l1pddsp_idle_rx_nb(burst_nb, + l1pa_l1ps_com.transfer.aset->tsc, + radio_freq, + ts, + TRUE); + #endif + } + + + // Programs TPU for PTCCH/DL task. + // ******************************** + { + WORD8 agc; + UWORD8 lna_off; + + // AGC updating + //------------- + l1pctl_pagc_ctrl(&agc, &lna_off, radio_freq,TRUE); + + #if(RF_FAM == 61) // Locosto DCO + cust_get_if_dco_ctl_algo(&dco_algo_ctl_nb, &if_ctl, (UWORD8) L1_IL_VALID, + l1a_l1s_com.Scell_used_IL.input_level , radio_freq, if_threshold); + l1ddsp_load_dco_ctl_algo_nb(dco_algo_ctl_nb); + #endif + + #if (L1_SAIC != 0) + // If SAIC is enabled, call the low level SAIC control function + // NOTE: l1a_l1s_com.Scell_used_IL.input_level is updated within + // the function l1pctl_pagc_ctrl + l1ctl_saic(l1a_l1s_com.Scell_used_IL.input_level,l1a_l1s_com.mode + #if (NEW_SNR_THRESHOLD == 1) + ,PTCCH + ,&saic_flag + #endif + ); + #endif + + // Compute timeslot number referenced to current camp timeslot. + // Rem: COULD BE DONE ASYNCHRONOUSLY changing ta_tn definition!!! + ts = l1pa_l1ps_com.transfer.aset->packet_ta.ta_tn - l1a_l1s_com.dl_tn; + if(ts < 0) ts += 8; + else if(ts >= 8) ts -= 8; + + // Program RX Normal Burst scenario. + l1pdtpu_serv_rx_nb(radio_freq, + agc, + lna_off, + ts, + l1s.tpu_offset, + 1, + 1, + TRUE,INACTIVE + #if(RF_FAM == 61) + ,L1_SAIC_HARDWARE_FILTER + ,if_ctl + #endif + #if (NEW_SNR_THRESHOLD == 1) + ,saic_flag + #endif /* NEW_SNR_THRESHOLD */ + ); + + // Set "CTRL_RX" flag in the controle flag registers. + l1s.tpu_ctrl_reg |= CTRL_RX; + l1s.dsp_ctrl_reg |= CTRL_RX; + } + } + + if(l1pa_l1ps_com.transfer.ptcch.activity & PTCCH_UL) + // PTCCH UL activity bit is set: PTCCH UL programmation required. + { + UWORD8 adc_active = INACTIVE; + + #if (TRACE_TYPE!=0) + trace_fct(CST_L1PS_CTRL_PTCCH_UL, radio_freq); + #endif + + // Programs DSP for PTCCH/UL. + // *************************** + { + UWORD8 cs_type; + UWORD16 ptcch_ul_data; + + // Access burst type ? + if (l1pa_l1ps_com.access_burst_type == ACC_BURST_8) + { + // PRACH 8 bits: data = (0111 1111)b + cs_type = CS_PAB8_TYPE; + ptcch_ul_data = 0x7F; + } + else + { + // PRACH 11 bits: data = (111 1111 1111)b + cs_type = CS_PAB11_TYPE; + ptcch_ul_data = 0x7FF; + } + + // "As" IDLE POLLING PRACH dsp control. + l1pddsp_ul_ptcch_data(cs_type, + ptcch_ul_data, + l1a_l1s_com.Scell_info.bsic, + radio_freq, + ts+3); + + l1pddsp_idle_prach_power(l1s.applied_txpwr, + radio_freq, + ts+3); + } + + // ADC measurement + // *************** + { + // check if during the SACCH burst an ADC measurement must be performed + if (l1a_l1s_com.adc_mode & ADC_NEXT_TRAFFIC_UL) // perform ADC only one time + { + adc_active = ACTIVE; + l1a_l1s_com.adc_mode &= ADC_MASK_RESET_TRAFFIC; // reset in order to have only one ADC measurement in Traffic + } + else + if (l1a_l1s_com.adc_mode & ADC_EACH_TRAFFIC_UL) // perform ADC on each period bloc + if ((++l1a_l1s_com.adc_cpt)>=l1a_l1s_com.adc_traffic_period) // wait for the period + { + adc_active = ACTIVE; + l1a_l1s_com.adc_cpt = 0; + } + } + // Programs TPU for PTCCH/UL task. + // ******************************** + { + // Program TX RA scenario. + l1pdtpu_serv_tx(radio_freq, + 0, // TA=0. + l1s.tpu_offset, + ts+3, // tx_id. + 1, // 1 PRACH. + 1, // tx_group_id. + 0, // No switch NB->RA + 1, // Driver called for PRACH Burst. + l1pa_l1ps_com.transfer.ptcch.activity & PTCCH_DL,adc_active); + // Flag RX in same frame as TX + } + + // PTCCH/UL has been executed, + // -> PTCCH/DL is then requested for schedule. + // -> PTCCH/UL activity flag must be reset. + l1pa_l1ps_com.transfer.ptcch.request_dl = TRUE; + l1pa_l1ps_com.transfer.ptcch.activity ^= PTCCH_UL; + + // Set "CTRL_TX" flag in the controle flag register. + l1s.tpu_ctrl_reg |= CTRL_TX; + l1s.dsp_ctrl_reg |= CTRL_TX; + + #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + RTTL1_FILL_UL_AB(PTCCH,l1s.applied_txpwr) + #endif + + } // End of PTCCH UL programmation + } // End of if(...semaphore...) + + // This task is not compatible with Neigh. Measurement. Store task length + // in "forbid_meas" to indicate when the task will last. + l1s.forbid_meas = TASK_ROM_MFTAB[PTCCH].size; +} +//#pragma DUPLICATE_FOR_INTERNAL_RAM_END +#endif // MOVE_IN_INTERNAL_RAM + + +#if (MOVE_IN_INTERNAL_RAM == 0) // Must be followed by the pragma used to duplicate the funtion in internal RAM +//#pragma DUPLICATE_FOR_INTERNAL_RAM_START + +/*-------------------------------------------------------*/ +/* l1s_read_ptcch() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* */ +/* Input parameters: */ +/* ----------------- */ +/* */ +/* Input parameters from globals: */ +/* ------------------------------ */ +/* */ +/* Modified parameters from globals: */ +/* --------------------------------- */ +/* */ +/*-------------------------------------------------------*/ +void l1ps_read_ptcch(UWORD8 param1, UWORD8 param2) +{ + // Traces and debug. + // ****************** + + l1_check_com_mismatch(PTCCH); + + if(l1pa_l1ps_com.transfer.ptcch.activity & PTCCH_DL) + // PTCCH/DL has been executed, + { + UWORD32 pm; + WORD8 ts; + + // Compute timeslot number referenced to current camp timeslot. + ts = l1pa_l1ps_com.transfer.aset->packet_ta.ta_tn - l1a_l1s_com.dl_tn; + if(ts < 0) ts += 8; + else if(ts >= 8) ts -= 8; + + #if (TRACE_TYPE!=0) + trace_fct(CST_L1PS_READ_PTCCH_DL, l1pa_l1ps_com.transfer.ptcch.radio_freq); + #endif + + // Read control results and feed control algorithms. + // ************************************************** + + // Read control information. + pm = (l1ps_dsp_com.pdsp_db_r_ptr->a_burst_pm_gprs[ts] & 0xffff) >> 5; + l1_check_pm_error(pm,PTCCH); + + if(l1s.actual_time.fn_mod104 == 91) + // Read PTCCH/DL data block from DSP/MCU interface, a_dd_md_gprs[]. + { + BOOL crc; + UWORD8 ordered_ta; + + crc = (l1ps_dsp_com.pdsp_ndb_ptr->a_dd_md_gprs[0] & 0x0100) >> 8; + + if(!crc) + // Block correct, we extract new TA... + { + UWORD8 word_position = 4+ (l1pa_l1ps_com.transfer.aset->packet_ta.ta_index >> 1); + UWORD8 byte_position = l1pa_l1ps_com.transfer.aset->packet_ta.ta_index & 0x01; + + // Download ordered TA... + // IF byte_position + // Upper byte contains TA... + // ELSE + // Lower byte contains TA... + // (see GSM04.04) + + ordered_ta = (l1ps_dsp_com.pdsp_ndb_ptr->a_dd_md_gprs[word_position] >> (8*byte_position)) & 0x7f; + + if (ordered_ta < 64) + { + // PTCCH/DL contains a valid TA for MS: update TA + l1pa_l1ps_com.transfer.aset->packet_ta.ta = ordered_ta; + + // PTCCH/DL activity bit must reset when new TA has been successfully received. + l1pa_l1ps_com.transfer.ptcch.activity ^= PTCCH_DL; + } + } + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4)) + if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_DL_PTCCH) + // whatever the value is, trace it + { + Trace_dl_ptcch(ordered_ta, + crc, + l1pa_l1ps_com.transfer.aset->packet_ta.ta_index, + l1pa_l1ps_com.transfer.aset->packet_ta.ta_tn, + l1ps_dsp_com.pdsp_ndb_ptr->a_dd_md_gprs[4], + l1ps_dsp_com.pdsp_ndb_ptr->a_dd_md_gprs[5], + l1ps_dsp_com.pdsp_ndb_ptr->a_dd_md_gprs[6], + l1ps_dsp_com.pdsp_ndb_ptr->a_dd_md_gprs[7], + l1ps_dsp_com.pdsp_ndb_ptr->a_dd_md_gprs[8], + l1ps_dsp_com.pdsp_ndb_ptr->a_dd_md_gprs[9], + l1ps_dsp_com.pdsp_ndb_ptr->a_dd_md_gprs[10], + l1ps_dsp_com.pdsp_ndb_ptr->a_dd_md_gprs[11]); + } + #endif + + #if (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + RTTL1_FILL_DL_PTCCH(crc, ordered_ta) // Replace with ordered TA + #endif + + // Reset CS type. + l1ps_dsp_com.pdsp_ndb_ptr->a_dd_md_gprs[0] = CS_NONE_TYPE; + } + } + else + { + #if (TRACE_TYPE!=0) + trace_fct(CST_L1PS_READ_PTCCH_UL, l1pa_l1ps_com.transfer.ptcch.radio_freq); + #endif + } + + // Set flag used to change the read page at the end of "l1_synch". + l1s_dsp_com.dsp_r_page_used = TRUE; + + // End of task -> task must become INACTIVE. + l1s.task_status[PTCCH].current_status = INACTIVE; +} +//#pragma DUPLICATE_FOR_INTERNAL_RAM_END +#endif // MOVE_IN_INTERNAL_RAM + + +#if (MOVE_IN_INTERNAL_RAM == 0) // Must be followed by the pragma used to duplicate the funtion in internal RAM +//#pragma DUPLICATE_FOR_INTERNAL_RAM_START + +/*-------------------------------------------------------*/ +/* l1ps_ctrl_itmeas() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* This function is a "COMPLEX" function used by the L1S */ +/* task ITMEAS. */ +/* This function is the control function for measuring */ +/* the signal strength on several specified timeslots (on*/ +/* which it's possible according to the multi-slot class)*/ +/* of an indicated carrier. */ +/* It programs the DSP and the TPU for doing these */ +/* measurements */ +/* Here below is a summary of the execution: */ +/* */ +/* - If SEMAPHORE(task) is low. */ +/* - Traces and debug. */ +/* - Determines on which timeslots measurements can */ +/* be done */ +/* - Programs DSP for required task. */ +/* - Programs TPU for required task. */ +/* - Flag DSP and TPU programmation. */ +/* */ +/* Input parameters: */ +/* ----------------- */ +/* */ +/* Input parameters from globals: */ +/* ------------------------------ */ +/* "l1pa_l1ps_com.itmeas" */ +/* Interference measurement parameters structure */ +/* */ +/* "l1a_l1s_com.dl_tn" */ +/* Timeslot on which L1 is synchronized */ +/* */ +/* "l1pa_l1ps_com.transfer.aset->multislot_class" */ +/* Multi-slot class in Packet transfer */ +/* */ +/* Modified parameters from globals: */ +/* --------------------------------- */ +/* */ +/* "l1s.tpu_ctrl_reg" */ +/* bit register used to know at the end of L1S if */ +/* something has been programmed on the MCU/TPU com. */ +/* This is used mainly to swap then the com. page at */ +/* the end of a control frame. */ +/* -> set CTRL_RX bit in the register. */ +/* */ +/* "l1s.dsp_ctrl_reg" */ +/* bit register used to know at the end of L1S if */ +/* something has been programmed on the MCU/DSP com. */ +/* This is used mainly to swap then the com. page at */ +/* the end of a control frame. */ +/* -> set CTRL_RX bit in the register. */ +/*-------------------------------------------------------*/ +void l1ps_ctrl_itmeas(UWORD8 param1, UWORD8 param2) +{ + +#if (RF_FAM == 61) + UWORD16 dco_algo_ctl_pw = 0; + UWORD8 if_ctl = 0; + UWORD8 if_threshold = C_IF_ZERO_LOW_THRESHOLD_GPRS; + UWORD8 ts = 0; +#endif + + // Traces and debug. + // ****************** + + #if (TRACE_TYPE==5) + trace_fct(CST_L1PS_CTRL_ITMEAS, l1pa_l1ps_com.itmeas.radio_freq); + #endif + + // Timeslots selection + // ******************** + + // Packet transfer mode <-> PDTCH task enabled: condition to check !!!! + //--------------------- + + // Timeslots already selected in l1p_asyn.c + + // Packet idle mode + //----------------- + if (l1a_l1s_com.l1s_en_task[PDTCH] == TASK_DISABLED) + { + // If a RX has been programmed on this frame + if (l1s.dsp_ctrl_reg & CTRL_RX) + { + // The pre-processed bitmap with Rx taken into account is taken + l1pa_l1ps_com.itmeas.meas_bitmap = l1pa_l1ps_com.itmeas.idle_tn_rx; + } + else + { + // The pre-processed bitmap without Rx taken into account is taken + l1pa_l1ps_com.itmeas.meas_bitmap = l1pa_l1ps_com.itmeas.idle_tn_no_rx; + } + + } // End if 'packet idle mode' + + l1pa_l1ps_com.itmeas.dsp_r_page_switch_req = FALSE; + + // If some measurements can be done + if (l1pa_l1ps_com.itmeas.meas_bitmap != 0) + { + UWORD8 nbmeas; + + // DSP read page switched or not during the ITMEAS read phase ? + + if (l1s.dsp_ctrl_reg == NO_CTRL) + { + // A control task hasn't already been done in this frame --> Read page switch + l1pa_l1ps_com.itmeas.dsp_r_page_switch_req = TRUE; + } + + // Traces and debug. + // ****************** + #if (TRACE_TYPE!=0) && (TRACE_TYPE!=5) + trace_fct(CST_L1PS_CTRL_ITMEAS, l1pa_l1ps_com.itmeas.radio_freq); + #endif + + +#if(RF_FAM == 61) // Locosto DCO + #if (PWMEAS_IF_MODE_FORCE == 0) + cust_get_if_dco_ctl_algo(&dco_algo_ctl_pw, &if_ctl, (UWORD8) L1_IL_INVALID , + 0, l1pa_l1ps_com.itmeas.radio_freq, if_threshold); + #else + if_ctl = IF_120KHZ_DSP; + dco_algo_ctl_pw = DCO_IF_0KHZ; + #endif + + + +#endif + + // Program TPU + // ************ +#if (RF_FAM != 61) + nbmeas = l1pdtpu_interf_meas(l1pa_l1ps_com.itmeas.radio_freq, + l1_config.params.high_agc, + 0, + l1pa_l1ps_com.itmeas.meas_bitmap, + l1s.tpu_offset, + l1s.tpu_win, + l1a_l1s_com.dl_tn); +#endif + +#if (RF_FAM == 61) + nbmeas = l1pdtpu_interf_meas(l1pa_l1ps_com.itmeas.radio_freq, + l1_config.params.high_agc, + 0, + l1pa_l1ps_com.itmeas.meas_bitmap, + l1s.tpu_offset, + l1s.tpu_win, + l1a_l1s_com.dl_tn, + if_ctl); +#endif + + + // Program DSP + // ************ + + l1pddsp_interf_meas_ctrl(nbmeas); + +#if(RF_FAM == 61) // TBD + // Reproduce the DCO control for all the power measurement + dco_algo_ctl_pw = dco_algo_ctl_pw * 0x55; // Replicate ZLZLZLZL + dco_algo_ctl_pw = dco_algo_ctl_pw >> (2*(4 - nbmeas)); // reduce to ZLs of Nbr + if(l1s.tcr_prog_done==1) + { + dco_algo_ctl_pw=((dco_algo_ctl_pw<<2)|(l1s_dsp_com.dsp_db_common_w_ptr->d_dco_algo_ctrl_pw&0x3)); + } + l1ddsp_load_dco_ctl_algo_pw(dco_algo_ctl_pw); + // of Meas Programmed +#endif + // Flag DSP and TPU programmation. + // ******************************** + + // Set "CTRL_RX" flag in the controle flag register. + l1s.tpu_ctrl_reg |= CTRL_MS; + l1s.dsp_ctrl_reg |= CTRL_MS; + + } // End if 'nbmeas != 0' + + // This task is not compatible with Neigh. Measurement. Store task length + // in "forbid_meas" to indicate when the task will last. + // Rem: Only FB51 task starts from this ctrl function. + l1s.forbid_meas = TASK_ROM_MFTAB[ITMEAS].size; +} +//#pragma DUPLICATE_FOR_INTERNAL_RAM_END +#endif // MOVE_IN_INTERNAL_RAM + + +#if (MOVE_IN_INTERNAL_RAM == 0) // Must be followed by the pragma used to duplicate the funtion in internal RAM +//#pragma DUPLICATE_FOR_INTERNAL_RAM_START + +/*-------------------------------------------------------*/ +/* l1ps_read_itmeas() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* */ +/* This function is a "COMPLEX" function used for the */ +/* L1S ITMEAS task. */ +/* */ +/* Here is a summary of the execution: */ +/* */ +/* - If SEMAPHORE(task) is low and task still enabled. */ +/* - Traces and debug. */ +/* - Read interference measurement results in NDB */ +/* - Fill and send reporting message */ +/* - Disactivate task. */ +/* - Flag the use of the MCU/DSP dual page read */ +/* interface if needed. */ +/* */ +/* Input parameters: */ +/* ----------------- */ +/* */ +/* Input parameters from globals: */ +/* ------------------------------ */ +/* "l1pa_l1ps_com.itmeas" */ +/* Interference measurement parameters structure */ +/* */ +/* Modified parameters from globals: */ +/* --------------------------------- */ +/* "l1s.task_status[task].current_status" */ +/* current task status. It must be reset (INACTIVE) */ +/* when the task is completed. */ +/* -> disactivate task. */ +/* */ +/* "l1s_dsp_com.dsp_r_page_used" */ +/* Flag used by the function which closes L1S */ +/* execution ("l1s_end_manager()") to know if the */ +/* MCU/DSP read page must be switched. */ +/* -> Set to 1 only if no other task was controlled */ +/* in the same frame as ITMEAS */ +/* */ +/* Use of MCU/DSP interface: */ +/* ------------------------- */ +/* "l1s_dsp_com.dsp_ndb_ptr" */ +/* pointer to the non double buffered part (NDB) of */ +/* the MCU/DSP interface. This part is R/W for both */ +/* DSP and MCU. */ +/*-------------------------------------------------------*/ +void l1ps_read_itmeas(UWORD8 param1, UWORD8 param2) +{ + xSignalHeaderRec *msg; + UWORD8 i; + WORD8 delta1_freq, delta2_freq; + UWORD16 g_magic; + + if(!(l1a_l1s_com.task_param[ITMEAS]) && + (l1a_l1s_com.l1s_en_task[ITMEAS])) + { + // Traces and debug. + // ****************** + + #if (TRACE_TYPE!=0) + trace_fct(CST_L1PS_READ_ITMEAS, l1pa_l1ps_com.itmeas.radio_freq); + #endif + + // Allocate result message. + // ************************ + + msg = os_alloc_sig(sizeof(T_L1P_ITMEAS_IND)); + DEBUGMSG(status,NU_ALLOC_ERR) + + // Fill msg signal code + msg->SignalCode = L1P_ITMEAS_IND; + + // Fill msg contents + // ****************** + + ((T_L1P_ITMEAS_IND *)(msg->SigP))->fn = l1s.actual_time.fn; + // Report measurement bitmap + ((T_L1P_ITMEAS_IND *)(msg->SigP))->meas_bitmap = l1pa_l1ps_com.itmeas.meas_bitmap; + + // Read result from DSP + g_magic = l1ctl_get_g_magic(l1pa_l1ps_com.itmeas.radio_freq); + delta1_freq = l1ctl_encode_delta1(l1pa_l1ps_com.itmeas.radio_freq); + delta2_freq = l1ctl_encode_delta2(l1pa_l1ps_com.itmeas.radio_freq); + + for (i = 0; i < 8; i++) + { + UWORD8 pm; + WORD16 IL_for_rxlev; + + pm = (l1ps_dsp_com.pdsp_ndb_ptr->a_interf_meas_gprs[i] & 0xffff) >> 5; + + // IL processing + if (pm == 0) + { + ((T_L1P_ITMEAS_IND *)(msg->SigP))->rxlev[i] = (WORD8)0x80; + } + else + { + IL_for_rxlev = -(pm - (l1_config.params.high_agc << 1) - g_magic) - delta1_freq - delta2_freq; + + + ((T_L1P_ITMEAS_IND *)(msg->SigP))->rxlev[i] = l1s_encode_rxlev(IL_for_rxlev); + } + } + + // If the Read phase is done during fn_mod26 = 13 --> measurements have been done + // during a PTCCH frame + if (l1s.actual_time.t2 == 13) + { + ((T_L1P_ITMEAS_IND *)(msg->SigP))->position = PTCCH_FRAME; + } + else // Measurements done during a search frame + { + ((T_L1P_ITMEAS_IND *)(msg->SigP))->position = SEARCH_FRAME; + } + + // send message... + os_send_sig(msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + // ITMEAS is a 'one shot' task --> disable task + l1a_l1s_com.l1s_en_task[ITMEAS] = TASK_DISABLED; + } // End if "task enabled and semaphore false" + + // End of task -> task must become INACTIVE. + l1s.task_status[ITMEAS].current_status = INACTIVE; + + // Switch DSP read page if needed + if(l1pa_l1ps_com.itmeas.dsp_r_page_switch_req) + { + // Set flag used to change the read page at the end of "l1_synch". + l1s_dsp_com.dsp_r_page_used = TRUE; + } +} + +//#pragma DUPLICATE_FOR_INTERNAL_RAM_END +#endif // MOVE_IN_INTERNAL_RAM + +//#pragma DUPLICATE_FOR_INTERNAL_RAM_START +#endif +//#pragma DUPLICATE_FOR_INTERNAL_RAM_END