fc-selenite: src/cs/layer1/tm_cfile/l1tm

comparison src/cs/layer1/tm_cfile/l1tm_func.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

comparison

equal deleted inserted replaced

--1:000000000000
+:b6a5e36de839
+/************* Revision Controle System Header *************
+*                  GSM Layer 1 software
+* L1TM_FUNC.C
+*
+*        Filename l1tm_func.c
+*  Copyright 2003 (C) Texas Instruments
+*
+************* Revision Controle System Header *************/
+#include "l1_macro.h"
+#include "l1_confg.h"
+#if TESTMODE
+#define L1TM_FUNC_C
+#include <string.h>
+#include <math.h>
+#include "abb.h"
+#include "general.h"
+#include "l1_types.h"
+#include "sys_types.h"
+#include "l1_const.h"
+#include "l1_time.h"
+#include "l1_signa.h"
+#include "l1tm_defty.h"
+#if 0 //(CODE_VERSION != SIMULATION)	// LoCosto-ism
+#include "pld.h"
+#endif
+#if (TRACE_TYPE==1) || (TRACE_TYPE==4) || (TRACE_TYPE==7) || (TRACE_TYPE==0)
+#include "rvt_gen.h"
+extern T_RVT_USER_ID  tm_trace_user_id;
+#endif
+#if (AUDIO_TASK == 1)
+#include "l1audio_const.h"
+#include "l1audio_cust.h"
+#include "l1audio_defty.h"
+#endif
+#if (L1_GTT == 1)
+#include "l1gtt_const.h"
+#include "l1gtt_defty.h"
+#endif
+#if (L1_MP3 == 1)
+#include "l1mp3_defty.h"
+#endif
+#if (L1_MIDI == 1)
+#include "l1midi_defty.h"
+#endif
+#include "l1_defty.h"
+#include "cust_os.h"
+#include "l1_msgty.h"
+#include "l1_varex.h"
+#include "l1_proto.h"
+#include "mem.h"
+#if (CODE_VERSION != SIMULATION)
+#if (RF_FAM == 61)
+#include "tpudrv61.h"
+#include "l1_rf61.h"
+#include "l1tm_tpu61.h"
+#if (DRP_FW_EXT==1)
+#include "l1_drp_inc.h"
+#else
+#include "drp_drive.h"
+#endif
+#endif
+#if (RF_FAM == 60)
+#include "tpudrv60.h"
+#include "l1_rf60.h"
+#include "l1tm_tpu60.h"
+#include "drp_drive.h"
+#endif
+#if (RF_FAM==43)
+#include "tpudrv43.h"
+#include "l1_rf43.h"
+#include "l1tm_tpu43.h"
+#endif
+#if (RF_FAM == 35)
+#include "tpudrv35.h"
+#include "l1_rf35.h"
+#include "l1tm_tpu35.h"
+#endif
+#if (RF_FAM == 12)
+#include "tpudrv12.h"
+#include "l1_rf12.h"
+#include "l1tm_tpu12.h"
+#endif
+#if (RF_FAM == 10)
+#include "tpudrv10.h"
+#include "l1_rf10.h"
+#include "l1tm_tpu10.h"
+#endif
+#if (RF_FAM == 8)
+#include "tpudrv8.h"
+#include "l1_rf8.h"
+#include "l1tm_tpu8.h"
+#endif
+#if (RF_FAM == 2)
+#include "tpudrv2.h"
+#include "l1_rf2.h"
+#include "l1tm_tpu2.h"
+#endif
+#else
+#if (RF_FAM == 2)
+#include "l1_rf2.h"
+#endif
+#endif
+#include <assert.h>
+#include <string.h>
+#include "l1tm_msgty.h"
+#include "l1tm_signa.h"
+#include "l1tm_varex.h"
+#include "l1tm_ver.h"
+#if L1_GPRS
+#include "l1p_cons.h"
+#include "l1p_msgt.h"
+#include "l1p_deft.h"
+#include "l1p_vare.h"
+#include "l1p_sign.h"
+#endif
+#if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1))
+#include "sys_dma.h"
+#endif
+#if(L1_FF_MULTIBAND == 1)
+extern UWORD8 tm_band;
+#endif /*if (L1_FF_MULTIBAND == 1)*/
+// Prototypes from external functions
+//------------------------------------
+UWORD16 Convert_l1_radio_freq(SYS_UWORD16 radio_freq);
+void Cust_tm_rf_param_write        (T_TM_RETURN *tm_return, WORD16 index, UWORD16 value);
+void Cust_tm_rf_param_read         (T_TM_RETURN *tm_return, WORD16 index);
+void Cust_tm_rf_table_write        (T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[]);
+void Cust_tm_rf_table_read         (T_TM_RETURN *tm_return, WORD8 index);
+void Cust_tm_rx_param_write        (T_TM_RETURN *tm_return, WORD16 index, UWORD16 value);
+void Cust_tm_rx_param_read         (T_TM_RETURN *tm_return, WORD16 index);
+void Cust_tm_tx_param_write        (T_TM_RETURN *tm_return, WORD16 index, UWORD16 value, UWORD8 band);
+void Cust_tm_tx_param_read         (T_TM_RETURN *tm_return, WORD16 index, UWORD8 band);
+void Cust_tm_tx_template_write     (T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[]);
+void Cust_tm_tx_template_read      (T_TM_RETURN *tm_return, WORD8 index);
+void Cust_tm_special_param_write   (T_TM_RETURN *tm_return, WORD16 index, UWORD16 value);
+void Cust_tm_special_param_read    (T_TM_RETURN *tm_return, WORD16 index);
+void Cust_tm_special_table_write   (T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[]);
+void Cust_tm_special_table_read    (T_TM_RETURN *tm_return, WORD8 index);
+void Cust_tm_special_enable        (T_TM_RETURN *tm_return, WORD16 action);
+#if (CODE_VERSION != SIMULATION)
+void Cust_tm_tpu_table_write       (T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[]);
+void Cust_tm_tpu_table_read        (T_TM_RETURN *tm_return, WORD8 index);
+#endif
+//------------------------------------
+// Prototypes from external functions
+//------------------------------------
+void Cust_tm_init                   (void);
+void l1tm_reset_rx_state            (void);
+void l1tm_reset_rx_stats            (void);
+#if L1_GPRS
+void l1pa_reset_cr_freq_list      (void);
+#endif
+//------------------------------------
+// Prototypes from internal functions
+//------------------------------------
+void l1tm_initialize_var(void);
+UWORD16 l1tm_convert_arfcn2l1ch(UWORD16 arfcn, UWORD8 *error_flag);
+void l1tm_stats_read(T_TM_RETURN *tm_return, WORD16 type, UWORD16 bitmask);
+void tm_transmit(T_TM_RETURN *tm_ret);
+void l1tm_PRBS1_generate(UWORD16 *TM_ul_data);
+#if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1))
+void l1tm_stereopath_DMA_handler(SYS_UWORD16 dma_status);
+void l1tm_stereopath_fill_buffer(void* buffer_address);
+UWORD16 l1tm_stereopath_get_pattern(UWORD16 sampling_freq, UWORD16 sin_freq_left,UWORD16 sin_freq_right, UWORD8 data_type);
+#endif
+/***********************************************************************/
+/*                           TESTMODE 3.X                              */
+/***********************************************************************/
+static UWORD8 tx_param_band=0;  // used in tx_param_write/read; default is GSM900
+// RF,(ANALOG)or other hardware dependent functions
+// - work done by tmrf.c functions for each product.
+// TestMode functions that modify the state variables
+// within the L1A - may need to allocate space
+// dynamically if this is the first time calling
+// these functions.
+// TestMode functions that start L1A state machines
+// may need to send L1A primitives to change L1A state.
+void l1tm_rf_param_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+tm_return->index = prim->u.tm_params.index;
+tm_return->size = 0;
+switch (prim->u.tm_params.index)
+{
+	  #if (FF_REPEATED_SACCH == 1)
+	      // Repeated SACCH mode
+	   case REPEATED_SACCH_ENA_FLAG:
+	   {
+	    l1_config.repeat_sacch_enable = prim->u.tm_params.value;
+	    #if (ETM_PROTOCOL == 1)
+	            tm_return->status = -ETM_OK;
+	    #else
+	            tm_return->status = E_OK;
+	    #endif
+	          break;
+	      }
+	  #endif /* FF_REPEATED_SACCH */
+	  #if (FF_REPEATED_DL_FACCH == 1)
+	      // Repeated FACCH mode
+	      case REPEATED_FACCHDL_ENA_FLAG:
+	      {
+	          l1_config.repeat_facch_dl_enable = prim->u.tm_params.value;
+	       #if (ETM_PROTOCOL == 1)
+	            tm_return->status = -ETM_OK;
+	       #else
+	            tm_return->status = E_OK;
+	       #endif/*(ETM_PROTOCOL == 1)*/
+	       break;
+	      }
+#endif /* FF_REPEATED_DL_FACCH == 1 */
+case BCCH_ARFCN:
+{
+UWORD16 bcch_arfcn;
+UWORD8  error_flag;
+bcch_arfcn = l1tm_convert_arfcn2l1ch(prim->u.tm_params.value, &error_flag);
+if (error_flag)
+{
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_INVAL;
+#endif
+}
+else
+{
+l1_config.tmode.rf_params.bcch_arfcn = bcch_arfcn;
+// now change on the fly
+// no reason to check dedicated_active flag...
+// we just set these 2 globals for FB/SB/BCCH tests
+l1a_l1s_com.nsync.list[0].radio_freq = l1_config.tmode.rf_params.bcch_arfcn;
+l1a_l1s_com.Scell_info.radio_freq    = l1_config.tmode.rf_params.bcch_arfcn;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+}
+break;
+}
+case TCH_ARFCN:
+{
+T_CHN_SEL *chan_sel;
+UWORD16    tch_arfcn;
+UWORD8     error_flag;
+tch_arfcn = l1tm_convert_arfcn2l1ch(prim->u.tm_params.value, &error_flag);
+if (error_flag)
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_INVAL;
+#endif
+else
+{
+l1_config.tmode.rf_params.tch_arfcn = tch_arfcn;
+// now change on the fly if necessary
+if (l1_config.TestMode && l1tm.tmode_state.dedicated_active)
+{
+chan_sel = &(l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->chan_sel);
+chan_sel->rf_channel.single_rf.radio_freq = l1_config.tmode.rf_params.tch_arfcn;
+}
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+}
+break;
+}
+case MON_ARFCN:
+{
+UWORD16 mon_arfcn;
+UWORD8  error_flag;
+mon_arfcn = l1tm_convert_arfcn2l1ch(prim->u.tm_params.value, &error_flag);
+if (error_flag)
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_INVAL;
+#endif
+else
+{
+l1_config.tmode.rf_params.mon_arfcn = mon_arfcn;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+}
+break;
+}
+#if L1_GPRS
+case PDTCH_ARFCN:
+{
+UWORD16    pdtch_arfcn;
+UWORD8     error_flag;
+pdtch_arfcn = l1tm_convert_arfcn2l1ch(prim->u.tm_params.value, &error_flag);
+if (error_flag)
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_INVAL;
+#endif
+else
+{
+l1_config.tmode.rf_params.pdtch_arfcn = pdtch_arfcn;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+}
+break;
+}
+#endif
+case AFC_ENA_FLAG:
+{
+l1_config.afc_enable = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+case AFC_DAC_VALUE:
+{
+WORD16 afc_value = prim->u.tm_params.value;
+// 13-bit AFC DAC
+#if(RF_FAM != 61)
+if (afc_value<-4096 || afc_value>4095)
+#else
+if (afc_value<-8192 || afc_value>8191)
+#endif
+{
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_INVAL;
+#endif
+break;
+}
+if (!l1_config.afc_enable)
+{
+// write AFC value to AFC DAC ASAP!! AFC DAC will be updated by any RX
+// or TX test.
+l1s.afc = afc_value;
+}
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+#if L1_GPRS
+case MULTISLOT_CLASS:
+{
+UWORD8    multislot_class;
+multislot_class = prim->u.tm_params.value;
+if ((multislot_class < 1) || (multislot_class > 12))
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_INVAL;
+#endif
+else
+{
+l1_config.tmode.rf_params.multislot_class = multislot_class;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+}
+break;
+}
+#endif // end of L1_GPRS
+default:
+{
+Cust_tm_rf_param_write(tm_return,
+prim->u.tm_params.index,
+prim->u.tm_params.value);
+break;
+}
+} // end switch
+}
+UWORD16 l1tm_convert_arfcn2l1ch(UWORD16 arfcn, UWORD8 *error_flag)
+#if (L1_FF_MULTIBAND == 0)
+{
+/*  Here, before we store the channel numbers to the l1_config structure,
+we convert from ETSI to TI channel numbering system.  The GGT
+ALWAYS expects the ETSI numbering system as input and output.
+We need to do the OPPOSITE of what is done in convert_l1_arfcn() in
+tpudrvX.c
+***************************************
+*** convert arfcn's from ETSI to TI ***
+***************************************
+**                                   **
+**     ETSI                 TI       **
+**           0   GSM          174    **
+**    1 -  124   GSM      1 - 124    **
+**  975 - 1023  E-GSM   125 - 173    **
+**  512 -  885   DCS    174 - 548    **
+**                                   **
+***************************************      */
+*error_flag = 0;
+switch (l1_config.std.id)
+{
+case GSM:
+case DCS1800:
+case PCS1900:
+case GSM850:
+break;
+case DUAL:
+if ((arfcn >= 512) && (arfcn <= 885)) arfcn -= 337;
+else if (arfcn > 124) *error_flag = 1; // invalid arfcn
+break;
+case DUALEXT:
+if (arfcn == 0) arfcn = 174;
+else if ((arfcn >= 975) && (arfcn <= 1023)) arfcn -= 850;
+else if ((arfcn >= 512) && (arfcn <= 885))  arfcn -= 337;
+else if ((arfcn >= 1)   && (arfcn <= 124));
+else *error_flag = 1; // invalide arfcn
+break;
+case DUAL_US:  // GSM850:128-251  PCS1900:512-810
+if ((arfcn >= 128) && (arfcn <= 251)) arfcn -= 127;
+else if ((arfcn >= 512) && (arfcn <= 810)) arfcn -= 387;
+else *error_flag = 1; // invalid arfcn
+break;
+default:
+*error_flag = 1; // invalid std.id
+break;
+} // end switch
+return arfcn;
+}
+#else // L1_FF_MULTIBAND = 1 below
+{
+*error_flag=0;
+if(tm_band == RF_PCS1900)
+{
+arfcn = arfcn + 512;
+}
+return(arfcn);
+#if 0
+UWORD16 l1_radio_freq = 0;
+UWORD8 effective_band_id = 0;
+*error_flag = 1;
+for (effective_band_id = 0; effective_band_id < RF_NB_SUBBANDS; effective_band_id ++)
+{
+if( multiband_conversion_data[effective_band_id].physical_band_id == tm_band)
+{
+if( (arfcn - multiband_conversion_data[effective_band_id].first_tpu_radio_freq) < multiband_conversion_data[effective_band_id].nbmax_carrier)
+{
+l1_radio_freq =   arfcn - multiband_conversion_data[effective_band_id].first_tpu_radio_freq + multiband_conversion_data[effective_band_id].first_radio_freq;
+*error_flag = 0;
+return(l1_radio_freq);
+}
+}
+}
+return(l1_radio_freq);
+#endif
+}
+#endif // #if (L1_FF_MULTIBAND == 0) else
+void l1tm_rf_param_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+volatile UWORD16 value;
+tm_return->index = prim->u.tm_params.index;
+switch (prim->u.tm_params.index)
+{
+#if (FF_REPEATED_SACCH == 1 )
+/* Repeated SACCH mode */
+case REPEATED_SACCH_ENA_FLAG:
+{
+value = l1_config.repeat_sacch_enable;
+break;
+}
+#endif /* FF_REPEATED_SACCH */
+#if FF_REPEATED_DL_FACCH
+// Repeated FACCH mode
+case REPEATED_FACCHDL_ENA_FLAG:
+{
+value = l1_config.repeat_facch_dl_enable;
+break;
+}
+#endif /* FF_REPEATED_DL_FACCH */
+case BCCH_ARFCN:
+{
+// return ETSI value for channel number
+value = Convert_l1_radio_freq(l1_config.tmode.rf_params.bcch_arfcn);
+break;
+}
+case TCH_ARFCN:
+{
+// return ETSI value for channel number
+value = Convert_l1_radio_freq(l1_config.tmode.rf_params.tch_arfcn);
+break;
+}
+case MON_ARFCN:
+{
+// return ETSI value for channel number
+value = Convert_l1_radio_freq(l1_config.tmode.rf_params.mon_arfcn);
+break;
+}
+#if L1_GPRS
+case PDTCH_ARFCN:
+{
+// return ETSI value for channel number
+value = Convert_l1_radio_freq(l1_config.tmode.rf_params.pdtch_arfcn);
+break;
+}
+#endif
+case AFC_ENA_FLAG:
+{
+value = l1_config.afc_enable;
+break;
+}
+case AFC_DAC_VALUE:
+{
+value = l1s.afc; // returned as F13.3
+break;
+}
+#if L1_GPRS
+case MULTISLOT_CLASS:
+{
+value = l1_config.tmode.rf_params.multislot_class;
+break;
+}
+#endif
+default:
+{
+Cust_tm_rf_param_read(tm_return, prim->u.tm_params.index);
+return;
+}
+} // end switch
+memcpy(tm_return->result, (UWORD8 *)&value, 2);
+tm_return->size = 2;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+}
+void l1tm_rf_table_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+Cust_tm_rf_table_write(tm_return,
+prim->u.tm_table.index,
+prim->str_len_in_bytes - 1,    // subtract 8-bit index
+prim->u.tm_table.table);
+}
+void l1tm_rf_table_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+Cust_tm_rf_table_read(tm_return, prim->u.tm_table.index);
+}
+void l1tm_rx_param_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+tm_return->index = prim->u.tm_params.index;
+tm_return->size = 0;
+switch (prim->u.tm_params.index)
+{
+case RX_AGC_GAIN:
+{
+WORD8 gain = prim->u.tm_params.value;
+// It is up to the user to write a valid gain,
+// one that falls within the range of gains in the current RF
+// AGC gain can only be controlled in 2dB steps as the bottom bit (bit zero)
+// corresponds to the lna_off bit
+l1_config.tmode.rx_params.agc     = gain & ~0x01;
+l1_config.tmode.rx_params.lna_off = gain &  0x01;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+case RX_TIMESLOT:
+{
+if (prim->u.tm_params.value > 7)
+{
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_INVAL;
+#endif
+break;
+}
+l1_config.tmode.rx_params.slot_num = prim->u.tm_params.value;
+if (l1_config.TestMode && l1tm.tmode_state.dedicated_active)
+{
+// currently CANNOT change RX slot on the fly!
+}
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+case RX_PM_ENABLE:
+{
+l1_config.tmode.rx_params.pm_enable = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+#if L1_GPRS
+case RX_GPRS_SLOTS:
+{
+// At least one DL TS needs to be allocated
+if (!prim->u.tm_params.value)
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_INVAL;
+#endif
+else
+{
+l1_config.tmode.rx_params.timeslot_alloc = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+}
+break;
+}
+case RX_GPRS_CODING:
+{
+UWORD8 coding_scheme;
+coding_scheme = prim->u.tm_params.value;
+if ((coding_scheme < 1) || (coding_scheme > 6) || (coding_scheme == 3))
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_INVAL;
+#endif
+else
+{
+l1_config.tmode.rx_params.coding_scheme = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+}
+break;
+}
+#endif
+case RX_AGC_ENA_FLAG:
+{
+l1_config.agc_enable = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+default:
+{
+Cust_tm_rx_param_write(tm_return,
+prim->u.tm_params.index,
+prim->u.tm_params.value);
+break;
+}
+} // end switch
+}
+void l1tm_rx_param_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+volatile UWORD16 value;
+tm_return->index = prim->u.tm_params.index;
+switch (prim->u.tm_params.index)
+{
+case RX_AGC_GAIN:
+{
+value = l1_config.tmode.rx_params.agc | l1_config.tmode.rx_params.lna_off;
+break;
+}
+case RX_TIMESLOT:
+{
+value = l1_config.tmode.rx_params.slot_num;
+break;
+}
+case RX_AGC_ENA_FLAG:
+{
+value = l1_config.agc_enable;
+break;
+}
+case RX_PM_ENABLE:
+{
+value = l1_config.tmode.rx_params.pm_enable;
+break;
+}
+#if L1_GPRS
+case RX_GPRS_SLOTS:
+{
+value = l1_config.tmode.rx_params.timeslot_alloc;
+break;
+}
+case RX_GPRS_CODING:
+{
+value = l1_config.tmode.rx_params.coding_scheme;
+break;
+}
+#endif
+default:
+{
+Cust_tm_rx_param_read(tm_return, prim->u.tm_params.index);
+return;
+}
+} // end switch
+memcpy(tm_return->result, (UWORD8 *)&value, 2);
+tm_return->size = 2;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+}
+void l1tm_tx_param_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+tm_return->index = prim->u.tm_params.index;
+tm_return->size = 0;
+switch (prim->u.tm_params.index)
+{
+case TX_PWR_LEVEL:
+{
+UWORD8 temp_txpwr, temp_band;
+if (prim->u.tm_params.value < 100)  // GSM900
+{
+temp_txpwr = prim->u.tm_params.value;
+temp_band = 0;
+}
+else if (prim->u.tm_params.value < 200)  // DCS1800
+{
+temp_txpwr = prim->u.tm_params.value - 100;
+temp_band = 1;
+}
+else if (prim->u.tm_params.value < 300)  // PCS1900
+{
+temp_txpwr = prim->u.tm_params.value - 200;
+temp_band = 2;
+}
+else  // force invalid values to return -ETM_INVAL or E_INVAL
+{
+temp_txpwr = 50;
+temp_band = 10;
+}
+// Note that the pwr level is only checked for being within the range [0..31]
+// because all pwr levels should be testable.
+// For subfunctions [TX_APC_DAC..TX_DELAY_DOWN]:
+//     temp_txpwr +   0 ==> GSM900
+//     temp_txpwr + 100 ==> DCS1800
+//     temp_txpwr + 200 ==> PCS1900
+// Changing tx pwr level on the fly while in continuous mode is not supported.
+if (temp_txpwr > 31 || temp_band > 2 ||
+l1_config.tmode.rf_params.tmode_continuous == TM_CONTINUOUS)
+{
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_INVAL;
+#endif
+break;
+}
+l1_config.tmode.tx_params.txpwr = temp_txpwr;
+tx_param_band = temp_band;
+// if in TX mode, change txpwr on the fly
+if ((l1_config.TestMode) &&
+(l1tm.tmode_state.dedicated_active) &&
+(l1_config.tmode.rf_params.down_up & TMODE_UPLINK))
+{
+// this causes 'direct' changing of TXPWR, which is OK in TestMode
+l1a_l1s_com.dedic_set.aset->new_target_txpwr = l1s.applied_txpwr = l1_config.tmode.tx_params.txpwr;
+}
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+case TX_TIMING_ADVANCE:
+{
+l1_config.tmode.tx_params.timing_advance = prim->u.tm_params.value;
+if (l1_config.TestMode && l1tm.tmode_state.dedicated_active)
+{
+// direct changing of Timing Advance
+l1a_l1s_com.dedic_set.aset->new_timing_advance = l1_config.tmode.tx_params.timing_advance;
+// new TA to take effect immediately
+l1a_l1s_com.dedic_set.aset->timing_advance = l1a_l1s_com.dedic_set.aset->new_timing_advance;
+}
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+case TX_PWR_SKIP:
+{
+l1_config.tmode.tx_params.txpwr_skip = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+#if L1_GPRS
+case TX_GPRS_POWER0:
+case TX_GPRS_POWER1:
+case TX_GPRS_POWER2:
+case TX_GPRS_POWER3:
+case TX_GPRS_POWER4:
+case TX_GPRS_POWER5:
+case TX_GPRS_POWER6:
+case TX_GPRS_POWER7:
+{
+l1_config.tmode.tx_params.txpwr_gprs[prim->u.tm_params.index - TX_GPRS_POWER0] = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+case TX_GPRS_SLOTS:
+{
+l1_config.tmode.tx_params.timeslot_alloc = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+case TX_GPRS_CODING:
+{
+UWORD8 coding_scheme;
+coding_scheme = prim->u.tm_params.value;
+if ((coding_scheme < 2) || (coding_scheme > 6) || (coding_scheme == 3))
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_INVAL;
+#endif
+else
+{
+l1_config.tmode.tx_params.coding_scheme = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+}
+break;
+}
+#endif
+default:
+{
+Cust_tm_tx_param_write(tm_return,
+prim->u.tm_params.index,
+prim->u.tm_params.value,
+tx_param_band);
+break;
+}
+} // end switch
+}
+void l1tm_tx_param_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+tm_return->index = prim->u.tm_params.index;
+Cust_tm_tx_param_read(tm_return,
+prim->u.tm_params.index,
+tx_param_band);
+}
+void l1tm_tx_template_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+Cust_tm_tx_template_write(tm_return,
+prim->u.tm_table.index,
+prim->str_len_in_bytes - 1, // subtract 8-bit index
+prim->u.tm_table.table);
+}
+void l1tm_tx_template_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+Cust_tm_tx_template_read(tm_return, prim->u.tm_table.index);
+}
+/* TCS211 function missing in LoCosto, reconstructed from disassembly */
+void l1tm_mode_set(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+switch (prim->u.tm_params.index) {
+case 0:
+l1_config.TestMode = 0;
+tm_return->status = E_OK;
+break;
+case 1:
+l1_config.TestMode = 1;
+l1_config.tx_pwr_code = 1;
+l1_config.pwr_mngt = 0;
+tm_return->status = E_OK;
+Cust_tm_init();
+l1tm_initialize_var();
+break;
+default:
+tm_return->status = E_INVAL;
+}
+tm_return->index = 0;
+tm_return->size = 0;
+}
+/* TCS211 function missing in LoCosto, reconstructed from disassembly */
+void l1tm_version_get(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+UWORD16 revision;
+extern  T_RF rf;
+tm_return->index = prim->u.tm_params.index;
+switch (prim->u.tm_params.index) {
+/* "meat" of this switch statement taken from LoCosto etm_tm3core.c */
+case BBCHIP_MODULE_REV:
+revision = CHIPSET;
+break;
+case CHIPID_MODULE_REV:
+revision = *( (volatile UWORD16 *) (MEM_JTAGID_PART));
+break;
+case CHIPVER_MODULE_REV:
+revision = *( (volatile UWORD16 *) (MEM_JTAGID_VER));
+break;
+case DSPSW_MODULE_REV:
+revision = l1s.version.dsp_code_version;
+break;
+case ANALOGCHIP_MODULE_REV:
+revision = ((ANLG_PG << 7) | ANLG_FAM);
+break;
+case LAYER1_MODULE_REV:
+revision = l1s.version.mcu_tcs_official;
+break;
+case RFDRIVER_MODULE_REV:
+revision = rf.rf_revision;
+break;
+case TM_API_MODULE_REV:
+revision = TMAPIVERSION;
+break;
+case L1_TM_CORE_MODULE_REV:
+revision = l1s.version.mcu_tm_version;
+break;
+case DSP_MODULE_REV:
+revision = DSP;
+break;
+case RF_MODULE_REV:
+revision = ((RF_PA << 10) | (RF_PG << 7) | RF_FAM);
+break;
+default:
+tm_return->status = E_BADINDEX;
+tm_return->size = 0;
+return;
+}
+memcpy(tm_return->result, &revision, sizeof revision);
+tm_return->size = sizeof revision;
+tm_return->status = E_OK;
+}
+/* TCS211 function missing in LoCosto, reconstructed from disassembly */
+void l1tm_mem_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+UWORD8 *mem_ptr;
+UWORD8 num_of_bytes;
+UWORD16 i;
+mem_ptr = (UWORD8 *) prim->u.mem_write.address;
+num_of_bytes = prim->str_len_in_bytes - 4;
+for (i = 0; i < num_of_bytes; i++)
+mem_ptr[i] = prim->u.mem_write.table[i];
+tm_return->size = 0;
+tm_return->index = 0;
+tm_return->status = E_OK;
+}
+/* TCS211 function missing in LoCosto, reconstructed from disassembly */
+void l1tm_mem_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+tm_return->index = 0;
+if (prim->u.mem_read.length > TM_PAYLOAD_UPLINK_SIZE_MAX - 4) {
+tm_return->size = 0;
+tm_return->status = E_BADSIZE;
+return;
+}
+memcpy(tm_return->result, &prim->u.mem_read.length, 4);
+memcpy(tm_return->result + 4, (UWORD8 *) prim->u.mem_read.src,
+prim->u.mem_read.length);
+tm_return->size = prim->u.mem_read.length + 4;
+tm_return->status = E_OK;
+}
+/* TCS211 function missing in LoCosto, reconstructed from disassembly */
+void l1tm_codec_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+UWORD16 page, reg;
+page = (prim->u.tm_params.index >> 5) & 1;
+reg = prim->u.tm_params.index & 0x1F;
+if (!l1_config.TestMode) {
+tm_return->status = E_TESTMODE;
+goto out;
+}
+if (page >= 2 || reg >= 32) {
+tm_return->status = E_INVAL;
+goto out;
+}
+ABB_Write_Register_on_page(page + 1, reg << 1,
+prim->u.tm_params.value & 0x3FF);
+tm_return->status = E_OK;
+out:
+tm_return->index = 0;
+tm_return->size = 0;
+}
+/* TCS211 function missing in LoCosto, reconstructed from disassembly */
+void l1tm_codec_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+UWORD16 page, reg;
+UWORD16 value;
+page = (prim->u.tm_params.index >> 5) & 1;
+reg = prim->u.tm_params.index & 0x1F;
+value = ABB_Read_Register_on_page(page + 1, reg << 1);
+memcpy(tm_return->result, &value, 2);
+tm_return->size = 2;
+tm_return->status = E_OK;
+tm_return->index = 0;
+}
+/* TCS211 function missing in LoCosto, reconstructed from disassembly */
+void l1tm_misc_param_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+tm_return->index = prim->u.tm_params.index;
+tm_return->size = 0;
+switch (prim->u.tm_params.index) {
+case ADC_ENA_FLAG:
+l1_config.adc_enable = prim->u.tm_params.value;
+break;
+default:
+Cust_tm_misc_param_write(tm_return, prim->u.tm_params.index,
+prim->u.tm_params.value);
+return;
+}
+tm_return->status = E_OK;
+}
+/* TCS211 function missing in LoCosto, reconstructed from disassembly */
+void l1tm_misc_param_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+UWORD16 value;
+tm_return->index = prim->u.tm_params.index;
+switch (prim->u.tm_params.index) {
+case ADC_ENA_FLAG:
+value = l1_config.adc_enable;
+break;
+case CURRENT_TM_MODE:
+value = l1_config.TestMode;
+break;
+default:
+Cust_tm_misc_param_read(tm_return, prim->u.tm_params.index);
+return;
+}
+memcpy(tm_return->result, &value, 2);
+tm_return->size = 2;
+tm_return->status = E_OK;
+}
+/* TCS211 function missing in LoCosto, reconstructed from disassembly */
+void l1tm_misc_enable(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+Cust_tm_misc_enable(tm_return, prim->u.tm_params.index);
+}
+void l1tm_special_param_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+Cust_tm_special_param_write(tm_return,
+prim->u.tm_params.index,
+prim->u.tm_params.value);
+}
+void l1tm_special_param_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+Cust_tm_special_param_read(tm_return, prim->u.tm_params.index);
+}
+void l1tm_special_table_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+Cust_tm_special_table_write(tm_return,
+prim->u.tm_table.index,
+prim->str_len_in_bytes - 1,
+prim->u.tm_table.table);
+}
+void l1tm_special_table_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+Cust_tm_special_table_read(tm_return, prim->u.tm_table.index);
+}
+void l1tm_special_enable(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+Cust_tm_special_enable(tm_return, prim->u.tm_params.index);
+}
+/* TCS211 function missing in LoCosto, reconstructed from disassembly */
+void l1tm_initialize(T_TM_RETURN *tm_return)
+{
+Cust_tm_init();
+tm_return->status = E_OK;
+tm_return->size = 0;
+tm_return->index = 0;
+}
+/* TCS211 function missing in LoCosto, reconstructed from disassembly */
+void l1tm_ffs(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+tm_return->size = tm_ffs(tm_return->result, 32, prim->u.ffs.packet,
+prim->str_len_in_bytes);
+tm_return->status = E_OK;
+tm_return->index = 0;
+}
+/*-------------------------------------------------------*/
+/* l1tm_initialize_var()                                 */
+/*-------------------------------------------------------*/
+/* Parameters  :                                         */
+/* -------------                                         */
+/* Return      :                                         */
+/* -------------                                         */
+/* Description :                                         */
+/* -------------                                         */
+/* This routine is used to switch to TestMode by re-     */
+/* initializing the l1a, l1s and l1a_l1s_com global      */
+/* structures. Re-initialization is kept at a minimum.   */
+/*-------------------------------------------------------*/
+void l1tm_initialize_var(void)
+{
+UWORD32 i;
+UWORD8  task_id;
+// L1S tasks management...
+//-----------------------------------------
+for(task_id=0; task_id<NBR_DL_L1S_TASKS; task_id++)
+{
+l1s.task_status[task_id].new_status     = NOT_PENDING;
+l1s.task_status[task_id].current_status = INACTIVE;
+}
+l1s.frame_count = 0;
+l1s.forbid_meas = 0;
+// MFTAB management variables...
+//-----------------------------------------
+l1s.afrm = 0;
+l1s_clear_mftab(l1s.mftab.frmlst);
+// Flag registers for RF task controle...
+//-----------------------------------------
+l1s.tpu_ctrl_reg = 0;
+l1s.dsp_ctrl_reg = 0;
+//++++++++++++++++++++++++++++++++++++++++++
+//  Reset "l1a" structure.
+//++++++++++++++++++++++++++++++++++++++++++
+// Downlink tasks management...
+// Uplink tasks management...
+// Measurement tasks management...
+//-----------------------------------------
+for(i=0; i<NBR_L1A_PROCESSES; i++)
+{
+l1a.l1a_en_meas[i] = 0;
+l1a.state[i]       = 0; // RESET state.
+}
+// Flag for forward/delete message management.
+//---------------------------------------------
+l1a.l1_msg_forwarded = 0;
+//++++++++++++++++++++++++++++++++++++++++++
+//  Reset "l1a_l1s_com" structure.
+//++++++++++++++++++++++++++++++++++++++++++
+l1a_l1s_com.l1a_activity_flag      = TRUE;
+l1a_l1s_com.time_to_next_l1s_task  = 0;
+// sleep management configuration
+//===============================
+l1s.pw_mgr.mode_authorized  = NO_SLEEP;
+// L1S scheduler...
+//====================
+// L1S tasks management...
+//-----------------------------------------
+for(i=0; i<NBR_DL_L1S_TASKS; i++)
+{
+l1a_l1s_com.task_param[i]  = SEMAPHORE_RESET;
+l1a_l1s_com.l1s_en_task[i] = TASK_DISABLED;
+}
+// Measurement tasks management...
+//-----------------------------------------
+l1a_l1s_com.meas_param  = 0;
+l1a_l1s_com.l1s_en_meas = 0;
+#if L1_GPRS
+// Set DSP scheduler mode
+l1a_l1s_com.dsp_scheduler_mode = GSM_SCHEDULER;
+//  Packet measurement: Reset of the frequency list.
+//-------------------------------------------------
+l1pa_reset_cr_freq_list();
+// Initialize active list used in Neighbour Measurement Transfer Process
+l1pa_l1ps_com.cres_freq_list.alist = &(l1pa_l1ps_com.cres_freq_list.list[0]);
+l1pa_l1ps_com.transfer.semaphore = TRUE;
+l1pa_l1ps_com.transfer.aset      = &(l1pa_l1ps_com.transfer.set[0]);
+l1pa_l1ps_com.transfer.fset[0]   = &(l1pa_l1ps_com.transfer.set[1]);
+l1pa_l1ps_com.transfer.fset[1]   = &(l1pa_l1ps_com.transfer.set[2]);
+for(i=0;i<3;i++)
+{
+l1pa_l1ps_com.transfer.set[i].SignalCode                   = 0;
+l1pa_l1ps_com.transfer.set[i].dl_tbf_synchro_timeslot      = 0;
+l1pa_l1ps_com.transfer.set[i].dl_tbf_synchro_timeslot      = 0;
+l1pa_l1ps_com.transfer.set[i].transfer_synchro_timeslot    = 0;
+l1pa_l1ps_com.transfer.set[i].allocated_tbf                = NO_TBF;
+l1pa_l1ps_com.transfer.set[i].assignment_command           = NO_TBF;
+l1pa_l1ps_com.transfer.set[i].multislot_class              = 0;
+l1pa_l1ps_com.transfer.set[i].packet_ta.ta                 = 255;
+l1pa_l1ps_com.transfer.set[i].packet_ta.ta_index           = 255;
+l1pa_l1ps_com.transfer.set[i].packet_ta.ta_tn              = 255;
+l1pa_l1ps_com.transfer.set[i].tsc                          = 0;
+l1pa_l1ps_com.transfer.set[i].freq_param.chan_sel.h        = 0;
+l1pa_l1ps_com.transfer.set[i].freq_param.chan_sel.
+rf_channel.single_rf.radio_freq = 0;
+l1pa_l1ps_com.transfer.set[i].tbf_sti.present              = FALSE;
+l1pa_l1ps_com.transfer.set[i].mac_mode                     = 0;
+l1pa_l1ps_com.transfer.set[i].ul_tbf_alloc->tfi            = 255;
+l1pa_l1ps_com.transfer.set[i].dl_tbf_alloc.tfi             = 255;
+l1pa_l1ps_com.transfer.set[i].dl_pwr_ctl.p0                = 255;
+l1pa_l1ps_com.transfer.set[i].dl_pwr_ctl.bts_pwr_ctl_mode  = 0;
+l1pa_l1ps_com.transfer.set[i].dl_pwr_ctl.pr_mode           = 0;
+}
+#endif
+// Init global test mode variables
+l1tm.tmode_state.dedicated_active = 0;
+#if L1_GPRS
+l1tm.tmode_state.packet_transfer_active = FALSE;
+#endif
+// PRBS seed initialization with a random pattern
+l1tm.tmode_prbs.prbs1_seed = 0x5613;
+}
+void l1tm_rf_enable(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+unsigned SignalCode =0;
+unsigned size = 0;  //omaps00090550
+xSignalHeaderRec *msg;
+UWORD8 send_prim = FALSE;  // Flag to send TestMode primitive...
+// Do not send primitive is the default; change it if necessary
+UWORD8 band;
+tm_return->index = 0;      // don't include index in header
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+// Function only valid in TEST mode
+if (l1_config.TestMode == 0)
+{
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_L1TESTMODE;
+#else
+tm_return->status = E_TESTMODE;
+#endif
+}
+else
+{
+// Reset all statistics
+l1tm_reset_rx_stats();
+// Reset receive state counters, unless already in dedicated mode
+if (!l1tm.tmode_state.dedicated_active)
+l1tm_reset_rx_state();
+// Reset monitor task
+l1_config.tmode.rf_params.mon_report = 0;
+l1_config.tmode.rf_params.mon_tasks  = 0;
+switch (prim->u.tm_params.index)
+{
+// Stop all RX and TX operations
+case STOP_ALL:
+{
+SignalCode = TMODE_STOP_RX_TX;
+size = sizeof(T_TMODE_STOP_RX_TX);
+l1tm.tmode_state.dedicated_active = 0;
+#if (RF_FAM == 61)
+// Reset the APC back to Automatic Mode
+l1ddsp_apc_set_automatic_mode();
+#endif
+#if (RF_FAM == 35)
+pll_tuning.enable=0;
+#endif
+// Reset down_up flag only if not in continuous mode. If in continuous mode, down_up
+// will be reset after the proper TPU scenario is loaded.
+if (l1_config.tmode.rf_params.tmode_continuous != TM_CONTINUOUS)
+	  l1_config.tmode.rf_params.down_up = 0;
+send_prim = TRUE;
+break;
+}
+// RX with or without network synchronization first
+case RX_TCH:
+{
+// if already in UL-only
+if (l1tm.tmode_state.dedicated_active &&
+l1_config.tmode.rf_params.down_up == TMODE_UPLINK)
+{
+// cannot start to RX while already TXing
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_AGAIN;
+#else
+tm_return->status = E_AGAIN;
+#endif
+}
+else
+{
+l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK;
+SignalCode = TMODE_IMMED_ASSIGN_REQ;
+size = sizeof(T_TMODE_IMMED_ASSIGN_REQ);
+send_prim = TRUE;
+}
+break;
+}
+// TX NB's or AB's on TCH with or without network synch. first
+case TX_TCH:
+{
+// Normal burst TX
+if (l1_config.tmode.tx_params.burst_type == 0)
+{
+// if already in DL-only, add UL
+if (l1tm.tmode_state.dedicated_active &&
+l1_config.tmode.rf_params.down_up == TMODE_DOWNLINK)
+{
+l1_config.tmode.rf_params.down_up = (TMODE_DOWNLINK | TMODE_UPLINK);
+}
+else
+{
+l1_config.tmode.rf_params.down_up = TMODE_UPLINK;
+SignalCode = TMODE_IMMED_ASSIGN_REQ;
+size = sizeof(T_TMODE_IMMED_ASSIGN_REQ);
+send_prim = TRUE;
+}
+}
+// AB TX
+else if (l1_config.tmode.tx_params.burst_type == 1)
+{
+// cannot start RACH while already in dedicated mode
+if (l1tm.tmode_state.dedicated_active)
+{
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_AGAIN;
+#else
+tm_return->status = E_AGAIN;
+#endif
+}
+else
+{
+SignalCode = TMODE_RA_START;
+size = sizeof(TMODE_RA_START);
+send_prim = TRUE;
+}
+}
+break;
+}
+// RX & TX on TCH with or without network synch. first
+case RX_TX_TCH:
+{
+// if NB TX
+if (l1_config.tmode.tx_params.burst_type == 0)
+{
+// if already in DL-only, add UL
+if (l1tm.tmode_state.dedicated_active &&
+l1_config.tmode.rf_params.down_up == TMODE_DOWNLINK)
+{
+l1_config.tmode.rf_params.down_up = (TMODE_DOWNLINK | TMODE_UPLINK);
+}
+// else if already in UL-only
+else if (l1tm.tmode_state.dedicated_active &&
+l1_config.tmode.rf_params.down_up == TMODE_UPLINK)
+{
+// cannot start to RX while already TXing
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_AGAIN;
+#else
+tm_return->status = E_AGAIN;
+#endif
+}
+else
+{
+l1_config.tmode.rf_params.down_up = (TMODE_DOWNLINK | TMODE_UPLINK);
+SignalCode = TMODE_IMMED_ASSIGN_REQ;
+size = sizeof(T_TMODE_IMMED_ASSIGN_REQ);
+send_prim = TRUE;
+}
+}
+// else if AB TX
+else if (l1_config.tmode.tx_params.burst_type == 1)
+{
+// Cannot TX RACH and RX simultaneously
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_AGAIN;
+#else
+tm_return->status = E_AGAIN;
+#endif
+}
+break;
+}
+// Continuous (all timeslots) reception on TCH
+case RX_TCH_CONT:
+{
+// if already in UL, DL or UL+DL
+if (l1tm.tmode_state.dedicated_active &&
+l1_config.tmode.rf_params.down_up != 0)
+{
+// cannot start to continously RX while already TXing or RXing
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_AGAIN;
+#else
+tm_return->status = E_AGAIN;
+#endif
+}
+else
+{
+l1_config.tmode.rf_params.tmode_continuous = TM_START_RX_CONTINUOUS;
+l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK;
+SignalCode = TMODE_IMMED_ASSIGN_REQ;
+size = sizeof(T_TMODE_IMMED_ASSIGN_REQ);
+send_prim = TRUE;
+}
+break;
+}
+// continuous (all timeslots) transmission
+case TX_TCH_CONT:
+{
+// PCS 1900 not supported yet.
+#if (L1_FF_MULTIBAND == 0)
+band = ((l1_config.tmode.rf_params.tch_arfcn >= 512) &&
+(l1_config.tmode.rf_params.tch_arfcn <= 885));
+#else
+band = ( ((l1_config.tmode.rf_params.tch_arfcn >= 512) &&
+(l1_config.tmode.rf_params.tch_arfcn <= 885)) ||
+((l1_config.tmode.rf_params.tch_arfcn >= 1024) &&
+(l1_config.tmode.rf_params.tch_arfcn <= 1322)) );
+#endif
+// if already in UL, DL or UL+DL
+if ((l1tm.tmode_state.dedicated_active && l1_config.tmode.rf_params.down_up != 0) ||
+(band == 0 && (l1_config.tmode.tx_params.txpwr < (5 + l1_config.tmode.tx_params.txpwr_skip)))  ||
+(band == 1 && (l1_config.tmode.tx_params.txpwr < (0 + l1_config.tmode.tx_params.txpwr_skip))))
+{
+// cannot start to continously TX while already TXing or RXing
+// or while adc reading are enabled
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_INVAL;
+#endif
+}
+else
+{
+#if (RF_FAM == 61)
+// Set APC in Manual Mode
+l1ddsp_apc_set_manual_mode();
+#endif
+l1_config.tmode.rf_params.tmode_continuous = TM_START_TX_CONTINUOUS;
+l1_config.tmode.rf_params.down_up = TMODE_UPLINK;
+SignalCode = TMODE_IMMED_ASSIGN_REQ;
+size = sizeof(T_TMODE_IMMED_ASSIGN_REQ);
+send_prim = TRUE;
+}
+break;
+}
+// Continuous BCCH
+case BCCH_LOOP:
+{
+SignalCode = TMODE_SCELL_NBCCH_REQ;
+size = sizeof(TMODE_SCELL_NBCCH_REQ);
+send_prim = TRUE;
+break;
+}
+// Continuous SB
+case SB_LOOP:
+{
+SignalCode = TMODE_SB_REQ;
+size = sizeof(T_TMODE_SB_REQ);
+send_prim = TRUE;
+break;
+}
+// Continuous FB1
+case FB1_LOOP:
+{
+SignalCode = TMODE_FB1_REQ;
+size = sizeof(T_TMODE_FB1_REQ);
+send_prim = TRUE;
+break;
+}
+// Continuous FB0
+case FB0_LOOP:
+{
+SignalCode = TMODE_FB0_REQ;
+size = sizeof(T_TMODE_FB0_REQ);
+send_prim = TRUE;
+break;
+}
+// TX + RX + MON on TCH
+case RX_TX_MON_TCH: // Stats collected from TCH Channel.
+case RX_TX_MON:     // Stats collected from MON Channel (except rxlev).
+{
+// Normal burst uplink
+if (l1_config.tmode.tx_params.burst_type == 0)
+{
+// If already in dedicated mode, return error
+if (l1tm.tmode_state.dedicated_active)
+{
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_AGAIN;
+#else
+tm_return->status = E_AGAIN;
+#endif
+}
+else
+{
+l1_config.tmode.rf_params.down_up = (TMODE_DOWNLINK | TMODE_UPLINK);
+l1_config.tmode.rf_params.mon_report = ((prim->u.tm_params.index & 0x08) >> 3);
+l1_config.tmode.rf_params.mon_tasks = 1;  // enable MON tasks
+SignalCode = TMODE_IMMED_ASSIGN_REQ;
+size = sizeof(T_TMODE_IMMED_ASSIGN_REQ);
+send_prim = TRUE;
+}
+}
+// else if Access burst uplink
+else if (l1_config.tmode.tx_params.burst_type == 1)
+{
+// Cannot TX RACH and RX simultaneously
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_AGAIN;
+#else
+tm_return->status = E_AGAIN;
+#endif
+}
+break;
+}
+case SINGLE_PM:
+{
+SignalCode = TMODE_RXLEV_REQ;
+size = sizeof(T_TMODE_RXLEV_REQ);
+send_prim = TRUE;
+break;
+}
+#if L1_GPRS
+// RX & TX on PDTCH with or without network synch. first
+case RX_TX_PDTCH:
+{
+UWORD8 bit_map = 0x80;
+// set uplink + downlink
+if (l1_config.tmode.tx_params.timeslot_alloc)
+l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK | TMODE_UPLINK;
+else
+l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK;
+while (bit_map)
+{
+if (bit_map & l1_config.tmode.stats_config.stat_gprs_slots)
+l1tm.tmode_stats.nb_dl_pdtch_slots ++;
+bit_map>>=1;
+}
+SignalCode = TMODE_PDTCH_ASSIGN_REQ;
+size = sizeof(T_TMODE_PDTCH_ASSIGN_REQ);
+send_prim = TRUE;
+break;
+}
+#endif
+#if L1_GPRS
+// RX & TX on PDTCH, FB on monitor arfcn
+case RX_TX_PDTCH_MON:
+{
+// set uplink + downlink
+if (l1_config.tmode.tx_params.timeslot_alloc)
+l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK | TMODE_UPLINK;
+else
+l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK;
+l1_config.tmode.rf_params.mon_report = 1;  // collect stats from MON channel
+l1_config.tmode.rf_params.mon_tasks  = 1;  // enable MON tasks
+SignalCode = TMODE_PDTCH_ASSIGN_REQ;
+size = sizeof(T_TMODE_PDTCH_ASSIGN_REQ);
+send_prim = TRUE;
+break;
+}
+#endif
+#if (RF_FAM == 35)
+case RX_PLL_TUNING:
+{
+// if already in UL-only
+if (l1tm.tmode_state.dedicated_active &&
+l1_config.tmode.rf_params.down_up == TMODE_UPLINK)
+{
+// cannot start to RX while already TXing
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_AGAIN;
+#else
+tm_return->status = E_AGAIN;
+#endif
+}
+else
+{
+pll_tuning.data[5]   = 0;
+pll_tuning.index     = 0;
+pll_tuning.enable    = 1;
+l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK;
+SignalCode = TMODE_IMMED_ASSIGN_REQ;
+size = sizeof(T_TMODE_IMMED_ASSIGN_REQ);
+send_prim = TRUE;
+}
+break;
+}
+#endif
+default:
+{
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_BADINDEX;
+#endif
+break;
+}
+} //end switch
+} // end of else
+if (send_prim == TRUE)
+{
+// Allocate result message.
+msg = os_alloc_sig(size);
+DEBUGMSG(status,NU_ALLOC_ERR)
+msg->SignalCode = SignalCode;
+os_send_sig(msg, L1C1_QUEUE);
+DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+}
+// always return a 0 in the result[], even if error
+tm_return->result[0] = 0;
+tm_return->size =  1;
+}
+void l1tm_stats_config_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+tm_return->index = prim->u.tm_params.index;
+tm_return->size = 0;
+switch (prim->u.tm_params.index)
+{
+case LOOPS:
+{
+l1_config.tmode.stats_config.num_loops = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+case AUTO_RESULT_LOOPS:
+{
+l1_config.tmode.stats_config.auto_result_loops = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+case AUTO_RESET_LOOPS:
+{
+l1_config.tmode.stats_config.auto_reset_loops = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+case STAT_TYPE:
+{
+l1_config.tmode.stats_config.stat_type = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+case STAT_BITMASK:
+{
+l1_config.tmode.stats_config.stat_bitmask = prim->u.tm_params.value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+#if L1_GPRS
+case STAT_GPRS_SLOTS:
+{
+UWORD8 allocation, value;
+value = prim->u.tm_params.value;
+// Check for mismatch between DL TS allocation and stats bitmap
+allocation = value ^ l1_config.tmode.rx_params.timeslot_alloc;
+if (value & allocation)
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_INVAL;
+#endif
+else
+{
+l1_config.tmode.stats_config.stat_gprs_slots = value;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+}
+break;
+}
+#endif
+default:
+{
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_BADINDEX;
+#endif
+break;
+}
+}  // end switch
+}
+void l1tm_stats_config_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+volatile UWORD16 value;
+tm_return->index = prim->u.tm_params.index;
+switch (prim->u.tm_params.index)
+{
+case LOOPS:
+{
+value = l1_config.tmode.stats_config.num_loops;
+break;
+}
+case AUTO_RESULT_LOOPS:
+{
+value = l1_config.tmode.stats_config.auto_result_loops;
+break;
+}
+case AUTO_RESET_LOOPS:
+{
+value = l1_config.tmode.stats_config.auto_reset_loops;
+break;
+}
+case STAT_TYPE:
+{
+value = l1_config.tmode.stats_config.stat_type;
+break;
+}
+case STAT_BITMASK:
+{
+value = l1_config.tmode.stats_config.stat_bitmask;
+break;
+}
+#if L1_GPRS
+case STAT_GPRS_SLOTS:
+{
+value = l1_config.tmode.stats_config.stat_gprs_slots;
+break;
+}
+#endif
+default:
+{
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_BADINDEX;
+#endif
+tm_return->size = 0;
+return;
+}
+}  // end switch
+memcpy(tm_return->result, (UWORD8 *) &value, 2);
+tm_return->size = 2;
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+}
+void l1tm_statistics(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+l1tm_stats_read(tm_return,
+prim->u.tm_params.index,
+prim->u.tm_params.value);
+}
+#if L1_GPRS
+void l1tm_rlc_uplink(UWORD8 tx, API *ul_data)
+{
+// Cast the ul_data_buffer
+typedef struct
+{
+API a_ul_data[4][29];
+}
+T_A_UL_DATA;
+T_A_UL_DATA *ptr = (T_A_UL_DATA*) ul_data;
+UWORD8 i,j;
+for (j=0; j<tx; j++)
+{
+ptr->a_ul_data[j][0] = l1_config.tmode.tx_params.coding_scheme;
+for (i=0;i<l1_config.tmode.tx_params.rlc_buffer_size;i++)
+ptr->a_ul_data[j][i+1] = l1_config.tmode.tx_params.rlc_buffer[i];
+}
+}
+#endif
+void l1tm_stats_read(T_TM_RETURN *tm_return, WORD16 type, UWORD16 bitmask)
+{
+extern T_L1A_L1S_COM l1a_l1s_com;
+extern T_L1S_GLOBAL l1s;
+volatile UWORD32 utemp = bitmask, temp_U32;
+volatile WORD32  temp = type;
+volatile WORD32  value_signed_int;
+volatile UWORD32 value_unsigned_int;
+volatile UWORD16 value_unsigned_short;
+UWORD8  j, offset=0;  // offset is index of tm_return->result[]
+UWORD16 rssi, len;
+WORD32  count;
+WORD32  runs = l1tm.tmode_stats.loop_count;
+/*
+* FreeCalypso TCS211 reconstruction: the following automatic var
+* is for the BLER code we have conditioned out below.
+*/
+#if 0 //L1_GPRS
+volatile UWORD16 value_array_unsigned_short[4];
+#endif
+// Put type and bitmask in the front of tm_return->result[].
+// Use volatile vars for proper operation of memcpy().
+memcpy(&tm_return->result[offset], (UWORD8 *) &temp, 2);
+offset+=2;
+memcpy(&tm_return->result[offset], (UWORD8 *) &utemp, 2);
+offset+=2;
+switch (type)
+{
+// Accumulated receive burst stats
+case ACCUMULATED_RX_STATS:
+{
+// all stats saved when collected from TCH
+if (l1tm.tmode_state.dedicated_active && (l1_config.tmode.rf_params.mon_report == 0))
+count = l1tm.tmode_stats.loop_count;
+#if L1_GPRS
+else if (l1tm.tmode_state.packet_transfer_active && (l1_config.tmode.rf_params.mon_report == 0))
+{
+// loop_count contains the number of blocks
+// Stats (PM, TOA, SNR, ANGLE) are accumulated over all frames and all time slots
+count = l1tm.tmode_stats.loop_count * l1tm.tmode_stats.nb_dl_pdtch_slots * 4;
+// the count of runs vs. successes is accumulated over all time slots per block
+runs  = l1tm.tmode_stats.loop_count * l1tm.tmode_stats.nb_dl_pdtch_slots;
+}
+#endif
+else count = l1tm.tmode_stats.flag_count; // only PASS stats saved
+if (bitmask & RSSI) // rxlev: RSSI SF12.4 eventually (currently F7.1)
+{
+len = sizeof(l1tm.tmode_stats.rssi_fifo) / sizeof(l1tm.tmode_stats.rssi_fifo[0]);
+rssi = 0;
+for (j=0; j<len; j++)
+rssi += l1tm.tmode_stats.rssi_fifo[j];
+rssi /= len; // F7.1
+memcpy(&tm_return->result[offset], (UWORD8 *) &rssi, 2);
+offset+=2;
+}
+// pm: DSP MEAN power measurement UF10.6
+if (bitmask & DSP_PM)
+{
+if (count)
+value_unsigned_short = l1tm.tmode_stats.pm_sum / count;
+else value_unsigned_short = 0;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_short, 2);
+offset+=2;
+}
+// angle mean
+if (bitmask & ANGLE_MEAN)
+{
+if (count) // non-zero
+value_signed_int = l1tm.tmode_stats.angle_sum / count;
+else value_signed_int = 0;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_signed_int, 4);
+offset+=4;
+}
+// angle variance
+if (bitmask & ANGLE_VAR)
+{
+// VAR[X] = E[X^2] - (E[X])^2
+if (count) // non-zero
+{
+temp_U32 = l1tm.tmode_stats.angle_sum / count;
+value_unsigned_int = l1tm.tmode_stats.angle_sq_sum / count - (temp_U32)*(temp_U32);
+}
+else value_unsigned_int = 0;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4);
+offset+=4;
+}
+// angle minimum
+if (bitmask & ANGLE_MIN)
+{
+value_signed_int = l1tm.tmode_stats.angle_min;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_signed_int, 4);
+offset+=4;
+}
+// angle maximum
+if (bitmask & ANGLE_MAX)
+{
+value_signed_int = l1tm.tmode_stats.angle_max;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_signed_int, 4);
+offset+=4;
+}
+// SNR mean
+if (bitmask & SNR_MEAN)
+{
+if (count) // non-zero
+value_unsigned_int = l1tm.tmode_stats.snr_sum / count;
+else value_unsigned_int = 0;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4);
+offset+=4;
+}
+// SNR variance
+if (bitmask & SNR_VAR)
+{
+if (count) // non-zero
+{
+temp_U32 = l1tm.tmode_stats.snr_sum / count;
+value_unsigned_int = l1tm.tmode_stats.snr_sq_sum / count -
+temp_U32 * temp_U32;
+}
+else
+value_unsigned_int = 0;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4);
+offset+=4;
+}
+// TOA mean
+if (bitmask & TOA_MEAN)
+{
+if (count) // non-zero
+value_unsigned_int = l1tm.tmode_stats.toa_sum / count;
+else value_unsigned_int = 0;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4);
+offset+=4;
+}
+// TOA variance
+if (bitmask & TOA_VAR)
+{
+if (count) // non-zero
+{
+temp_U32 = l1tm.tmode_stats.toa_sum / count;
+value_unsigned_int = l1tm.tmode_stats.toa_sq_sum / count -
+temp_U32 * temp_U32;
+}
+else value_unsigned_int = 0;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4);
+offset+=4;
+}
+// Frame # mod 26*51
+if (bitmask & FRAME_NUMBER)
+{
+value_unsigned_int = l1s.actual_time.fn;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4);
+offset+=4;
+}
+// Tot # of runs executed so far
+if (bitmask & RUNS)
+{
+memcpy(&tm_return->result[offset], (UWORD8 *) &runs, 4);
+offset+=4;
+}
+// Tot # of successes so far
+if (bitmask & SUCCESSES)
+{
+memcpy(&tm_return->result[offset], (UWORD8 *) &l1tm.tmode_stats.flag_count, 4);
+offset+=4;
+}
+// BSIC
+if (bitmask & BSIC)
+{
+value_unsigned_short = l1tm.tmode_stats.bsic;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_short, 2);
+offset+=2;
+}
+/*
+* FreeCalypso TCS211 reconstruction: suspected LoCosto-ism,
+* removing in order to pass compilation.
+*/
+#if 0 //L1_GPRS
+if (bitmask & BLER)
+{
+UWORD8 j;
+if (count) // non-zero
+{
+float bler, remain_part;
+UWORD8  int_part, bitmap_remain;
+int i;
+//compute bler for each block
+for (j=0; j<4; j++)
+{
+bler = ((float) (l1tm.tmode_stats.bler_crc[j] * 100)) / ((float) l1tm.tmode_stats.bler_total_blocks);
+//conversion from floating to fixed format
+int_part = (UWORD8) bler;
+remain_part = bler - (float) int_part;
+bitmap_remain = 0;
+i=5;
+while (i >= 0)
+{
+bitmap_remain |= (UWORD8) (remain_part *2) << i;
+if (((UWORD8) (remain_part *2)) >= 1)
+remain_part = (remain_part * 2) - 1;
+else
+remain_part = (remain_part * 2);
+i--;
+}
+// Reporting the percentage of blocks in error (F10.6)
+value_array_unsigned_short[j] = bitmap_remain | (int_part << 6);
+}
+}
+// Reporting a BLER of 100, if no computation has been done
+else
+{
+for (j=0; j<4; j++)
+value_array_unsigned_short[j] = 100 << 6;
+}
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_array_unsigned_short[0], 8);
+offset+=8;
+	}
+#endif
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+// Most recent receive burst stats
+case MOST_RECENT_RX_STATS:
+{
+// rxlev: RSSI SF12.4 eventually (F7.1 currently)
+if (bitmask & RSSI)
+{
+value_unsigned_short = l1tm.tmode_stats.rssi_recent;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_short, 2);
+offset+=2;
+}
+// pm: most recent DSP power measurement UF10.6
+if (bitmask & DSP_PM)
+{
+memcpy(&tm_return->result[offset], &l1tm.tmode_stats.pm_recent, 2);
+offset+=2;
+}
+// most recent ANGLE value
+if (bitmask & ANGLE_MEAN)
+{
+value_signed_int = l1tm.tmode_stats.angle_recent;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_signed_int, 4);
+offset+=4;
+}
+// doesn't make sense.
+if (bitmask & ANGLE_VAR)
+{
+}
+// doesn't make sense.
+if (bitmask & ANGLE_MIN)
+{
+}
+// doesn't make sense.
+if (bitmask & ANGLE_MAX)
+{
+}
+// most recent SNR value
+if (bitmask & SNR_MEAN)
+{
+value_unsigned_int = l1tm.tmode_stats.snr_recent;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4);
+offset+=4;
+}
+// doesn't make sense.
+if (bitmask & SNR_VAR)
+{
+}
+// most recent TOA value
+if (bitmask & TOA_MEAN)
+{
+value_unsigned_int = l1tm.tmode_stats.toa_recent;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4);
+offset+=4;
+}
+// doesn't make sense.
+if (bitmask & TOA_VAR)
+{
+}
+// Frame # mod 26*51
+if (bitmask & FRAME_NUMBER)
+{
+value_unsigned_int = l1s.actual_time.fn;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4);
+offset+=4;
+}
+// must be '1'
+if (bitmask & RUNS)
+{
+}
+// most recent Success flag
+if (bitmask & SUCCESSES)
+{
+memcpy(&tm_return->result[offset], (UWORD8 *)&l1tm.tmode_stats.flag_recent, 4);
+offset+=4;
+}
+// BSIC
+if (bitmask & BSIC)
+{
+value_unsigned_short = l1tm.tmode_stats.bsic;
+memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_short, 2);
+offset+=2;
+}
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_OK;
+#else
+tm_return->status = E_OK;
+#endif
+break;
+}
+default:
+{
+#if (ETM_PROTOCOL == 1)
+tm_return->status = -ETM_INVAL;
+#else
+tm_return->status = E_BADINDEX;
+#endif
+break;
+}
+}  // end switch
+tm_return->size = offset;
+tm_return->index = 0;  // don't include index in header
+}
+/*-------------------------------------------------------*/
+/* l1tm_fill_burst()                                     */
+/*-------------------------------------------------------*/
+/*                                                       */
+/* Description:  Prepare bursts for transmission in case */
+/* ------------  of UL test                              */
+/*                                                       */
+/* Simulation of IQ Swap does the following mapping:     */
+/*                                                       */
+/*             00 -> 01                                  */
+/*             01 -> 00                                  */
+/*             10 -> 11                                  */
+/*             11 -> 10                                  */
+/*                                                       */
+/*-------------------------------------------------------*/
+#if (L1_FF_MULTIBAND == 1)
+extern const WORD8 rf_subband2band[];
+#endif
+void l1tm_fill_burst (UWORD16 pattern, UWORD16 *TM_ul_data)
+{
+UWORD32 i;
+UWORD8  swap_iq, swap_flag;
+UWORD16 gb_front, gb_end, tb_front, tb_end, even_bits, odd_bits;
+#if (L1_FF_MULTIBAND == 1)
+UWORD8 physical_band_id;
+#endif
+UWORD8 tsc_bits_in_first_word;
+UWORD16 tsc_front_mask,tsc_end_mask;
+extern  T_RF rf;
+// training sequences list......
+UWORD32 tsc[8]=
+{
+0x00970897,
+0x00B778B7,
+0x010EE90E,
+0x011ED11E,
+0x006B906B,
+0x013AC13A,
+0x029F629F,
+0x03BC4BBC
+};
+#if (L1_FF_MULTIBAND == 0)
+if(((l1_config.std.id == DUAL) || (l1_config.std.id == DUALEXT) || (l1_config.std.id == DUAL_US)) &&
+(l1_config.tmode.rf_params.tch_arfcn >= l1_config.std.first_radio_freq_band2))
+{
+swap_iq = l1_config.std.swap_iq_band2;
+}
+else
+{
+swap_iq = l1_config.std.swap_iq_band1;
+}
+#else // L1_FF_MULTIBAND = 1 below
+physical_band_id =
+rf_subband2band[rf_convert_rffreq_to_l1subband(l1_config.tmode.rf_params.tch_arfcn)];
+swap_iq = rf_band[physical_band_id].swap_iq;
+#endif // #if (L1_FF_MULTIBAND == 0) else
+// Swap IQ definitions...
+// 0=No Swap, 1=Swap RX only, 2=Swap TX only, 3=Swap RX and TX
+if (swap_iq & 0x2)
+{
+swap_flag = 1;
+}
+else
+{
+swap_flag = 0;
+}
+//===========================================
+// define uplink patterns
+//===========================================
+if (pattern == 0)       //  0's
+pattern = 0x0000;
+else if (pattern == 1)  //  1's
+pattern = 0xffff;
+else if (pattern == 2)  // 01's
+pattern = 0x5555;
+// first replicate pattern through all buffer
+if ((pattern == 3) || (pattern == 4))
+{
+// fill the uplink burst with PRBS1
+l1tm_PRBS1_generate(TM_ul_data);
+}
+else if ((pattern != 12) && (pattern != 13))
+{
+for (i=0;i<=15;i++)
+TM_ul_data[i] = (pattern << 6);
+}
+//===========================================
+// create front-end guard and tail bits masks
+//===========================================
+// guard bits mask
+gb_front = 0xFFC0 << (10 - rf.tx.guard_bits);  // max. of 10, min. of 2 guard bits allowed
+// check if guard bits > 7
+if (rf.tx.guard_bits > 7)
+{
+// tail bits mask
+tb_front = ~((UWORD16)(0xE000 << (10 - rf.tx.guard_bits))) & 0xFFC0;  // tail bits placed in TM_ul_data[1]  //oamps00090550
+// add tail bits to uplink data
+TM_ul_data[1] = TM_ul_data[1] & tb_front;
+// add guard bits to uplink data
+TM_ul_data[0] = gb_front;
+}
+else
+{
+// tail bits mask
+tb_front = ~((UWORD16)(0xE000 >> rf.tx.guard_bits) )& 0xFFC0;  // 3 tail bits
+// add tail bits to uplink data
+TM_ul_data[0] = (TM_ul_data[0] | gb_front) & tb_front;
+}
+//===========================================
+// create back-end guard and tail bits masks
+//===========================================
+// guard bits mask
+gb_end = (0xFFC0 >> (10 - (12 - rf.tx.guard_bits))) & 0xFFC0;  // max. of 10, min. of 2 guard bits allowed
+// check if guard bits < 5
+if (rf.tx.guard_bits < 5)
+{
+//tail bits mask
+tb_end = ~(UWORD16)((0x01C0 >> (rf.tx.guard_bits - 2))) & 0xFFC0;  // tail bits placed in TM_ul_data[14]
+// add tail bits to uplink data
+TM_ul_data[14] = TM_ul_data[14] & tb_end;
+// add guard bits to uplink data
+TM_ul_data[15] = gb_end;
+}
+else
+{
+// tail bits mask
+tb_end = ~(UWORD16)((0x01C0 << (12 - rf.tx.guard_bits))) & 0xFFC0;  // 3 tail bits
+// add tail bits to uplink data
+TM_ul_data[15] = (TM_ul_data[15] | gb_end) & tb_end;
+}
+//===========================================
+// Insert the training sequence pattern .The location of TSC bits will
+// vary according to the value of guard bits used.
+//===========================================
+if ((pattern == 13)||(pattern==3))
+{
+//   TM_ul_data[6]  = (TM_ul_data[6]  & 0xFE00) | ( (UWORD8) ((tsc[l1_config.tmode.tx_params.tsc]>>24) << 6 ) );   // tsc bits 1-2
+//    TM_ul_data[7]  = (TM_ul_data[7]  & 0x0000) | ( (UWORD8) ((tsc[l1_config.tmode.tx_params.tsc]>>14) << 6 ) );   // tsc bits 3-12
+//   TM_ul_data[8]  = (TM_ul_data[8]  & 0x0000) | ( (UWORD8) ((tsc[l1_config.tmode.tx_params.tsc]>>4 ) << 6 ) );   // tsc bits 13-22
+//   TM_ul_data[9]  = (TM_ul_data[9]  & 0x07C0) | ( (UWORD8) ((tsc[l1_config.tmode.tx_params.tsc]>>0 ) << 12) );   // tsc bits 23-26
+if (rf.tx.guard_bits <4) // TSC will be in [6],[7],[8]
+{
+tsc_bits_in_first_word = 9-rf.tx.guard_bits; // 7 bits when guard is 2, 6 bit when guard is 3
+tsc_front_mask = ((0xFFC0) << tsc_bits_in_first_word); // insert zeros from right
+//tsc_bits_in_last_word = 26 -10 -tsc_bits_in_first_word = (16-tsc_bits_in_first_word)
+tsc_end_mask =  (((0xFFC0) >> (16-tsc_bits_in_first_word)) & 0xFFC0);   //insert zeros from left
+TM_ul_data[6]  = (TM_ul_data[6]  & tsc_front_mask)
+| ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]>>(26-tsc_bits_in_first_word)) << 6 )) & (~tsc_front_mask) );
+TM_ul_data[7]  = (TM_ul_data[7]  & 0x0000)
+| ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]<<(tsc_bits_in_first_word+6))>>16)) & (0xFFC0));   //next 10 bits of TSC
+TM_ul_data[8]  = (TM_ul_data[8]  & tsc_end_mask)
+| ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc] << (tsc_bits_in_first_word+6+10))>>16) )& (~tsc_end_mask));
+}
+else if ((rf.tx.guard_bits >=4) && (rf.tx.guard_bits <9) )// TSC will be in [6],[7],[8],[9]
+{
+tsc_bits_in_first_word = 9-rf.tx.guard_bits; // 5 bits when guard is 4, 1 bit when guard is 8
+tsc_front_mask = ((0xFFC0) << tsc_bits_in_first_word); // insert zeros from right
+//tsc_bits_in_last_word = 26 -10 -10 -tsc_bits_in_first_word = (6-tsc_bits_in_first_word)
+tsc_end_mask =  (((0xFFC0) >> (6-tsc_bits_in_first_word)) & 0xFFC0);   //insert zeros from left
+TM_ul_data[6]  = (TM_ul_data[6]  & tsc_front_mask)
+| ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]>>(26-tsc_bits_in_first_word)) << 6 )) & (~tsc_front_mask) );
+TM_ul_data[7]  = (TM_ul_data[7]  & 0x0000)
+| ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]<<(tsc_bits_in_first_word+6))>>16)) & (0xFFC0)  );   //next 10 bits of TSC
+TM_ul_data[8]  = (TM_ul_data[8]  & 0x0000)
+| ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]<<(tsc_bits_in_first_word+6+10))>>16)) & (0xFFC0) );   //next 10 bits of TSC
+TM_ul_data[9]  = (TM_ul_data[9]  & tsc_end_mask)
+| ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc] << (tsc_bits_in_first_word+6+10+10))>>16) ) & (~tsc_end_mask));
+}
+else   //(rf.tx.guard_bits>=9) : TSC will be in [7],[8],[9],
+{
+tsc_bits_in_first_word = 19-rf.tx.guard_bits; // 10 bits when guard is 9, 9 bits when guard is 10
+tsc_front_mask = ((0xFFC0) << tsc_bits_in_first_word); // insert zeros from right
+//tsc_bits_in_last_word = 26 -10 -tsc_bits_in_first_word = (16-tsc_bits_in_first_word)
+tsc_end_mask =  (((0xFFC0) >> (16-tsc_bits_in_first_word)) & 0xFFC0);   //insert zeros from left
+TM_ul_data[7]  = (TM_ul_data[7]  & tsc_front_mask)
+| ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]>>(26-tsc_bits_in_first_word)) << 6 )) & (~tsc_front_mask) );
+TM_ul_data[8]  = (TM_ul_data[8]  & 0x0000)
+| ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]<<(tsc_bits_in_first_word+6))>>16)) & (0xFFC0)  );   //next 10 bits of TSC
+TM_ul_data[9]  = (TM_ul_data[9]  & tsc_end_mask)
+| ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc] << (tsc_bits_in_first_word+6+10))>>16)) & (~tsc_end_mask));
+}
+}
+// swap uplink data if IQ swap
+if(swap_flag)
+{
+for (i=0;i<=15;i++)
+{
+even_bits = TM_ul_data[i] & 0xAA80;  // keep bits in even positions
+odd_bits  = ~(TM_ul_data[i]) & 0x5540;  // keep and complement bits in odd positions
+TM_ul_data[i] = even_bits | odd_bits;  // swapped uplink data
+}
+}
+}
+void l1a_tmode_send_ul_msg(T_TM_RETURN *tm_ret)
+{
+tm_transmit(tm_ret);
+}
+/*******************************************************************************
+*
+*                             void tm_receive(void *inbuf, int size)
+*
+* Purpose  : Parses TestMode data and copies it directly into TESTMODE_PRIM.
+*            It forwards primitive to L1, except in the case of tm_init() which
+*            gets executed in the CST.
+*
+* Arguments: In : command
+*            Out:
+*
+* Returns  : void
+*
+******************************************************************************/
+void tm_receive(UWORD8 *inbuf, UWORD16 size)
+{
+UWORD8 cksum, cid, error = 0;
+BOOL msg_used=FALSE;
+#if (ETM_PROTOCOL == 1)
+UWORD8 mid = 0;
+#endif
+UWORD8 *pmsg;
+xSignalHeaderRec *msg;
+msg = os_alloc_sig(sizeof(T_TESTMODE_PRIM));
+msg->SignalCode = TESTMODE_PRIM;
+// pmsg will be used to fill up the TestMode primitive with th
+// data, in consecutive order according to the definition of T_TESTMODE_PRIM.
+pmsg = (UWORD8 *)((T_TESTMODE_PRIM *)(msg->SigP));
+#if (ETM_PROTOCOL == 1) // Use of ETM protocol
+#if (OP_L1_STANDALONE == 1)
+// Check MID
+*pmsg++ = mid = *inbuf++;
+if ((mid != ETM_RF) && (mid != ETM_CORE))    // check if coming from ETM RF or ETM CORE DLL
+error = -ETM_PACKET;
+#elif (OP_L1_STANDALONE == 0)
+*pmsg++ = mid = ETM_RF;
+#endif
+// Copy CID/FID
+*pmsg++ = cid = *inbuf++;
+#if (OP_L1_STANDALONE == 1)
+// Copy data payload size (size minus MID byte and checksum byte)
+size -= 2;
+#endif
+*pmsg++ = --size; // Size of TM payload -1 for cid/fid
+// Validate data payload size: check if longer than size of testmode
+// primitive minus cid, str_len_in_bytes, and two holes FIXME: This is a
+// really bad way of doing it!
+if (size > sizeof(T_TESTMODE_PRIM) - 4)
+error = -ETM_PACKET;
+// The CID have been received. The data that follows are part of a
+// unique struct within the union of T_TESTMODE_PRIM, so we now
+// need to align at a 32-bit word boundary.
+*pmsg++ = 0;
+// In a SSA integration the cksum is done in the etm_receive function
+#if (OP_L1_STANDALONE == 1)
+if (!error)
+{
+cksum   = mid;
+cksum  ^= cid;
+while (size--)
+{
+cksum  ^= *inbuf;
+*pmsg++ = *inbuf++;
+}
+if (cksum != *inbuf)
+error = -ETM_PACKET;
+}
+#elif (OP_L1_STANDALONE == 0)
+// Copy payload without cid/fid
+while (size--)
+{
+*pmsg++ = *inbuf++;
+}
+#endif
+// At this point, all the data have been parsed and copied into
+// the TestMode primitive.  Now we send the primitive to L1.
+if (!error)
+{
+os_send_sig(msg, L1C1_QUEUE);
+msg_used=TRUE;
+}
+else
+{
+UWORD8 mymsg[4];
+// on error, return short error message; cid, error, checksum
+mymsg[0] = mid;
+mymsg[1] = cid;         // the payload fid
+mymsg[2] = error;       // status
+mymsg[3] = cid ^ error; // checksum
+#if (TRACE_TYPE==0) || (TRACE_TYPE==1) || (TRACE_TYPE==4) || (TRACE_TYPE==7)
+rvt_send_trace_cpy((T_RVT_BUFFER) mymsg,
+tm_trace_user_id,
+4,
+RVT_BINARY_FORMAT);
+#endif
+}
+#else // end of (ETM_PROTOCOL ==1)
+// Copy CID
+*pmsg++ = cid = *inbuf++;
+// Copy data payload size (size minus CID byte and checksum byte)
+size -= 2;
+*pmsg++ = size;
+// Validate data payload size: check if longer than size of testmode
+// primitive minus cid, str_len_in_bytes, and two holes FIXME: This is a
+// really bad way of doing it!
+if (size > sizeof(T_TESTMODE_PRIM) - 4)
+error = E_PACKET;
+// The CID have been received. The data that follows are part of a
+// unique struct within the union of T_TESTMODE_PRIM, so we now
+// need to align at a 32-bit word boundary.
+pmsg += 2;
+if (!error)
+{
+cksum = cid;
+while (size--)
+{
+cksum  ^= *inbuf;
+*pmsg++ = *inbuf++;
+}
+if (cksum != *inbuf)
+error = E_CHECKSUM;
+}
+// At this point, all the data have been parsed and copied into
+// the TestMode primitive.  Now we send the primitive to L1.
+if (!error)
+{
+os_send_sig(msg, L1C1_QUEUE);
+msg_used=TRUE;
+}
+else
+{
+UWORD8 mymsg[3];
+// on error, return short error message; error, cid/fid, checksum
+mymsg[0] = cid;
+mymsg[1] = error;
+mymsg[2] = cid ^ error; // checksum
+#if (TRACE_TYPE==1) || (TRACE_TYPE==4) || (TRACE_TYPE==7) || (TRACE_TYPE==0)
+rvt_send_trace_cpy((T_RVT_BUFFER) mymsg, tm_trace_user_id,3, RVT_BINARY_FORMAT);
+#endif
+}
+#endif // end of (ETM_PROTOCOL ==0)
+// if the message allocated is not sent to L1A, it has to be deallocated
+if(msg_used==FALSE)
+os_free_sig(msg);
+}
+void tm_transmit(T_TM_RETURN *tm_ret)
+{
+UWORD8 size, cksum;
+UWORD8 *pbuf, *ptmret;
+UWORD8 buf[TM_PAYLOAD_UPLINK_SIZE_MAX + TM_UPLINK_PACKET_OVERHEAD];
+pbuf = &buf[0];
+// move the header
+#if (ETM_PROTOCOL == 1)
+*pbuf++ = tm_ret->mid;
+cksum   = tm_ret->mid;
+*pbuf++ = tm_ret->status;
+cksum  ^= tm_ret->status;
+*pbuf++ = tm_ret->cid;
+cksum  ^= tm_ret->cid;
+// Include index if not equal to zero, and if not an error
+// Exception: in TX_TEMPLATE_READ we always include the index.
+if ((tm_ret->status == -ETM_OK) &&
+(tm_ret->index || tm_ret->cid == TX_TEMPLATE_READ)){
+*pbuf++ = tm_ret->index;
+cksum  ^= tm_ret->index;
+}
+#else
+*pbuf++ = tm_ret->cid;
+*pbuf++ = tm_ret->status;
+cksum = tm_ret->cid ^ tm_ret->status;
+// Include index if not equal to zero, and if not an error
+// Exception: in TX_TEMPLATE_READ we always include the index.
+if ((tm_ret->status == E_OK) &&
+(tm_ret->index || tm_ret->cid == TX_TEMPLATE_READ)){
+*pbuf++ = tm_ret->index;
+cksum  ^= tm_ret->index;
+}
+#endif
+ptmret = (UWORD8 *) &tm_ret->result[0];
+size = tm_ret->size;
+while (size--) {
+*pbuf++ = *ptmret;
+cksum ^= *ptmret++;
+}
+// move the checksum and append it to buf
+*pbuf++ = cksum;
+#if (TRACE_TYPE==1) || (TRACE_TYPE==4) || (TRACE_TYPE==7) || (TRACE_TYPE==0)
+rvt_send_trace_cpy(buf, tm_trace_user_id, pbuf - buf, RVT_BINARY_FORMAT);
+#endif
+}
+#if ((L1_STEREOPATH == 1) && (CODE_VERSION == NOT_SIMULATION) && (OP_L1_STANDALONE == 1))
+/*******************************************************************************
+*
+* UWORD16 l1tm_stereopath_get_pattern(UWORD16 sampling_freq, UWORD16 sin_freq_left,UWORD16 sin_freq_right, UWORD8 data_type)
+*
+* Purpose  : this function is use to get a complete period of a sinusoide depending on
+*            the sinusoide freq (L+R), the sampling freq and the type of samples (S8,S16,S32)
+*
+* Arguments: sampling_freq  : sampling frequency
+*            sin_freq_left  : frequency of the left channel sinusoide
+*            sin_freq_right : frequency of the right channel sinusoide
+*            data_type      : type of samples
+*
+* Returns  : number of elements in the pattern
+*
+******************************************************************************/
+UWORD16 l1tm_stereopath_get_pattern(UWORD16 sampling_freq, UWORD16 sin_freq_left,UWORD16 sin_freq_right, UWORD8 data_type)
+{
+float max_sin_period;
+float my_time;
+UWORD16 i;
+// get the lowest frequency to get the biggest period
+if (sin_freq_left > sin_freq_right)
+{
+max_sin_period =  1 / (float) sin_freq_right;
+}
+else
+{
+max_sin_period =  1 / (float) sin_freq_left;
+}
+my_time = 0;
+i = 0;
+if (data_type == AUDIO_SP_DATA_S8)
+{
+WORD8* my_ptr;
+// cast the steropath_pattern to a pointer on 8 bits samples
+my_ptr = (WORD8*) l1tm.stereopath.stereopath_pattern;
+// fill the pattern while the biggest period is not reached
+while (my_time < max_sin_period)
+{
+my_ptr[i++] = 0x7F * sin(2*3.1416*my_time*sin_freq_left);
+my_ptr[i++] = 0x7F * sin(2*3.1416*my_time*sin_freq_right);
+my_time = i/2/((float) sampling_freq);
+}
+}
+else  // S16
+{
+WORD16* my_ptr;
+// cast the steropath_pattern to a pointer on 16 bits samples
+my_ptr = (WORD16*) l1tm.stereopath.stereopath_pattern;
+// fill the pattern while the biggest period is not reached
+while (my_time < max_sin_period)
+{
+my_ptr[i++] = 0x7FFF * sin(2*3.1416*my_time*sin_freq_left);
+my_ptr[i++] = 0x7FFF * sin(2*3.1416*my_time*sin_freq_right);
+my_time = i/2/((float) sampling_freq);
+}
+}
+return (i);
+}
+/*******************************************************************************
+*
+* void l1tm_stereopath_fill_buffer(void* buffer_address)
+*
+* Purpose  : this function is use to fill a buffer with a predefined pattern
+*
+* Arguments: buffer_address  : address of the buffer to fill
+*
+* Returns  : none
+*
+******************************************************************************/
+void l1tm_stereopath_fill_buffer(void* buffer_address)
+{
+static UWORD16 my_counter = 0;
+UWORD16 copied_samples;
+UWORD16 i;
+if (l1a_l1s_com.stereopath_drv_task.parameters.data_type == AUDIO_SP_DATA_S8)
+{
+WORD8* start_address;
+WORD8* my_ptr;
+// l1tm.stereopath.stereopath_buffer_number is a variable used to know which half of the buffer we have to fill
+if (l1tm.stereopath.stereopath_buffer_number == 0)
+{
+// first half
+start_address = (WORD8*) buffer_address;
+l1tm.stereopath.stereopath_buffer_number = 1;
+}
+else
+{
+// second half, add the frame number to get the half buffer address
+start_address = ((WORD8*) buffer_address) + l1a_l1s_com.stereopath_drv_task.parameters.frame_number;
+l1tm.stereopath.stereopath_buffer_number = 0;
+}
+// copied_samples is the number of samples copied to the half buffer
+copied_samples = 0;
+// cast the steropath_pattern to a pointer on 8 bits samples
+my_ptr = (WORD8*) l1tm.stereopath.stereopath_pattern;
+if (l1a_l1s_com.stereopath_drv_task.parameters.frame_number > l1tm.stereopath.stereopath_nb_samples)
+{
+// size of the half buffer to fill is bigger than the predefined pattern
+// start to fill the buffer with the end of the not complete previous pattern (from current_sample to the last one)
+memcpy(start_address,my_ptr+l1tm.stereopath.stereopath_current_sample,l1tm.stereopath.stereopath_nb_samples-l1tm.stereopath.stereopath_current_sample);
+copied_samples = l1tm.stereopath.stereopath_nb_samples-l1tm.stereopath.stereopath_current_sample;
+// while there is still enough place in the buffer to copy a complete pattern ...
+while (copied_samples<l1a_l1s_com.stereopath_drv_task.parameters.frame_number-l1tm.stereopath.stereopath_nb_samples)
+{
+// ... copy a complete pattern
+memcpy(start_address+copied_samples,my_ptr,l1tm.stereopath.stereopath_nb_samples);
+copied_samples += l1tm.stereopath.stereopath_nb_samples;
+}
+// fill the rest of the buffer with a part of the pattern
+memcpy(start_address+copied_samples,my_ptr,l1a_l1s_com.stereopath_drv_task.parameters.frame_number-copied_samples);
+// save the last pattern sample copied in the buffer for next time (to get a continuous sound)
+l1tm.stereopath.stereopath_current_sample = l1a_l1s_com.stereopath_drv_task.parameters.frame_number-copied_samples;
+}
+else
+{
+// size of the half buffer to fill is smaller than the predefined pattern
+// fill the buffer with a part of the pattern
+memcpy(start_address,my_ptr+l1tm.stereopath.stereopath_current_sample,l1a_l1s_com.stereopath_drv_task.parameters.frame_number);
+// save the last pattern sample copied in the buffer for next time (to get a continuous sound)
+l1tm.stereopath.stereopath_current_sample += l1a_l1s_com.stereopath_drv_task.parameters.frame_number;
+if (l1tm.stereopath.stereopath_current_sample > l1tm.stereopath.stereopath_nb_samples)
+{
+l1tm.stereopath.stereopath_current_sample -= l1tm.stereopath.stereopath_nb_samples;
+}
+}
+}
+else    // S16
+{
+WORD16* start_address;
+WORD16* my_ptr;
+// l1tm.stereopath.stereopath_buffer_number is a variable used to know which half of the buffer we have to fill
+if (l1tm.stereopath.stereopath_buffer_number == 0)
+{
+// first half
+start_address = (WORD16*) buffer_address;
+l1tm.stereopath.stereopath_buffer_number = 1;
+}
+else
+{
+// second half, add the frame number to get the half buffer address
+start_address = ((WORD16*) buffer_address) + l1a_l1s_com.stereopath_drv_task.parameters.frame_number;
+l1tm.stereopath.stereopath_buffer_number = 0;
+}
+// copied_samples is the number of samples copied to the half buffer
+copied_samples = 0;
+// cast the steropath_pattern to a pointer on 16 bits samples
+my_ptr = (WORD16*) l1tm.stereopath.stereopath_pattern;
+if (l1a_l1s_com.stereopath_drv_task.parameters.frame_number > l1tm.stereopath.stereopath_nb_samples)
+{
+// size of the half buffer to fill is bigger than the predefined pattern
+// start to fill the buffer with the end of the not complete previous pattern (from current_sample to the last one)
+memcpy(start_address, my_ptr+l1tm.stereopath.stereopath_current_sample,(l1tm.stereopath.stereopath_nb_samples-l1tm.stereopath.stereopath_current_sample)*2);
+copied_samples = l1tm.stereopath.stereopath_nb_samples-l1tm.stereopath.stereopath_current_sample;
+// while there is still enough place in the buffer to copy a complete pattern ...
+while (copied_samples<l1a_l1s_com.stereopath_drv_task.parameters.frame_number-l1tm.stereopath.stereopath_nb_samples)
+{
+// ... copy a complete pattern
+memcpy(start_address+copied_samples,my_ptr,l1tm.stereopath.stereopath_nb_samples*2);
+copied_samples += l1tm.stereopath.stereopath_nb_samples;
+}
+// fill the rest of the buffer with a part of the pattern
+memcpy(start_address+copied_samples,my_ptr,(l1a_l1s_com.stereopath_drv_task.parameters.frame_number-copied_samples)*2);
+// save the last pattern sample copied in the buffer for next time (to get a continuous sound)
+l1tm.stereopath.stereopath_current_sample = l1a_l1s_com.stereopath_drv_task.parameters.frame_number-copied_samples;
+}
+else
+{
+// size of the half buffer to fill is smaller than the predefined pattern
+// fill the buffer with a part of the pattern
+memcpy(start_address,my_ptr+l1tm.stereopath.stereopath_current_sample,l1a_l1s_com.stereopath_drv_task.parameters.frame_number);
+l1tm.stereopath.stereopath_current_sample += l1a_l1s_com.stereopath_drv_task.parameters.frame_number;
+// save the last pattern sample copied in the buffer for next time (to get a continuous sound)
+if (l1tm.stereopath.stereopath_current_sample > l1tm.stereopath.stereopath_nb_samples)
+{
+l1tm.stereopath.stereopath_current_sample -= l1tm.stereopath.stereopath_nb_samples;
+}
+}
+}
+}
+/*******************************************************************************
+*
+* void l1tm_stereopath_DMA_handler(SYS_UWORD16 dma_status)
+*
+* Purpose  : this function is the stereopath DMA interrupt handler
+*
+* Arguments: dma_status  : type of interrupt
+*
+* Returns  : none
+*
+******************************************************************************/
+void l1tm_stereopath_DMA_handler(SYS_UWORD16 dma_status)
+{
+// stereopath DMA handler, check which type of interrupt it is
+if (F_DMA_COMPARE_CHANNEL_IT_STATUS_BLOCK(dma_status))
+{
+l1tm.stereopath.stereopath_block++;
+// Block --> fill a new buffer
+l1tm_stereopath_fill_buffer((void*) l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address);
+}
+if (F_DMA_COMPARE_CHANNEL_IT_STATUS_HALF_BLOCK(dma_status))
+{
+l1tm.stereopath.stereopath_half_block++;
+// Half Block --> fill a new buffer
+l1tm_stereopath_fill_buffer((void*) l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address);
+}
+if (F_DMA_COMPARE_CHANNEL_IT_STATUS_TIME_OUT_SRC(dma_status))
+l1tm.stereopath.stereopath_source_timeout++;
+if (F_DMA_COMPARE_CHANNEL_IT_STATUS_TIME_OUT_DST(dma_status))
+l1tm.stereopath.stereopath_dest_timeout++;
+if (F_DMA_COMPARE_CHANNEL_IT_STATUS_DROP(dma_status))
+l1tm.stereopath.stereopath_drop++;
+if (F_DMA_COMPARE_CHANNEL_IT_STATUS_FRAME(dma_status))
+l1tm.stereopath.stereopath_frame++;
+}
+#endif
+#if (CODE_VERSION != SIMULATION)
+void l1tm_tpu_table_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+Cust_tm_tpu_table_write(tm_return,
+prim->u.tm_table.index,
+prim->str_len_in_bytes - 1,    // subtract 8-bit index
+prim->u.tm_table.table);
+}
+void l1tm_tpu_table_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return)
+{
+Cust_tm_tpu_table_read(tm_return, prim->u.tm_table.index);
+}
+#endif // (CODE_VERSION != SIMULATION)
+/*------------------------------------------------------------------*/
+/* l1tm_PRBS1_generate()                                            */
+/*------------------------------------------------------------------*/
+/*                                                                  */
+/* Parameters  :         UWORD16 *TM_ul_data                        */
+/* -------------                                                    */
+/*                point to the uplink burts table to be filled      */
+/*                with the PRBS 1 of bits                           */
+/*                                                                  */
+/* Return      :                Void                                */
+/* -------------                                                    */
+/*                                                                  */
+/* Description :                                                    */
+/* -------------                                                    */
+/* This algorithm generates  a Pseudo Random Bit Sequence           */
+/* using a method called method  "Primitive Polynomial Modulo 2"    */
+/* For a sequence length of (2^15-1) we a polynomial of order 15    */
+/* is used, the coefficients are [ 15,  1,  0 ]                     */
+/* The basic idea is to generate the new bit by XORing  all the     */
+/* coefficients  of the polynomial except coeff 0                   */
+/* i.e newbit = ( B15 XOR B1  )                                     */
+/* The following notation must be used for the bit numbering:       */
+/* _______________________________________________________          */
+/*|B16|B15|B14|B13|B12|B11|B10|B9|B8|B7|B6|B5|B4|B3|B2|B1|          */
+/*------------------------------------------------------------------*/
+/*                                                                  */
+/* each word of the uplink buffer needs to be filled by new 10 bits */
+/*------------------------------------------------------------------*/
+void l1tm_PRBS1_generate(UWORD16 *TM_ul_data)
+{
+#define B15_MASK 	0x4000
+#define B1_MASK 	0x0001
+#define MASK_16BITS	0xFFFF
+UWORD16 newbit =0x0000;
+UWORD8 index ,word;
+//generate 16 words to fill Uplink table
+for (word=0;word<16;word++)
+{
+// generate new 10 bits from the sequence
+for (index =0; index< 10;index++)
+{
+// generate new bit , using the "Primitive Polynomial Modulo 2 " method with coeff. ( 15, 1, 0 )
+//XOR bit 15 with bit 1.
+newbit =     (((l1tm.tmode_prbs.prbs1_seed& B15_MASK)>>14)^(l1tm.tmode_prbs.prbs1_seed & B1_MASK));
+// insert new bit in the sequence.
+l1tm.tmode_prbs.prbs1_seed =	(l1tm.tmode_prbs.prbs1_seed << 1) | newbit;
+}
+TM_ul_data[word]=(UWORD16)((l1tm.tmode_prbs.prbs1_seed&MASK_16BITS)<<6);
+}
+}
+#endif // TESTMODE

FreeCalypso > hg > fc-selenite

comparison src/cs/layer1/tm_cfile/l1tm_func.c @ 0:b6a5e36de839