FreeCalypso > hg > fc-selenite
diff src/cs/layer1/tm_cfile/l1tm_async.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/tm_cfile/l1tm_async.c Sun Jul 15 04:39:26 2018 +0000 @@ -0,0 +1,2761 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1TM_ASYNC.C + * + * Filename l1tm_async.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +#include "l1_macro.h" +#include "l1_confg.h" + +#if TESTMODE + #define L1TM_ASYNC_C + + #include <string.h> + #include <stdlib.h> + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + #include "l1_time.h" + #include "l1_signa.h" + #include "cust_os.h" + + #include "l1tm_defty.h" + + #if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #include "l1audio_signa.h" + #include "l1audio_proto.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 "l1_msgty.h" + #include "l1_varex.h" + #include "l1_proto.h" + + #include "l1tm_msgty.h" + #include "l1tm_signa.h" + #include "l1tm_varex.h" + + #if (L1_STEREOPATH == 1) + #include "sys_dma.h" + #include "l1audio_stereo.h" + #endif + + #if L1_GPRS + #include "l1p_cons.h" + #include "l1p_msgt.h" + #include "l1p_deft.h" + #include "l1p_vare.h" + #include "l1p_sign.h" + #endif + + /* FreeCalypso TCS211 reconstruction */ + #define ETM_PROTOCOL 0 + #define ETM_MODE 0 + +//------------------------------------ +// Prototypes from external functions +//------------------------------------ +#if (OP_L1_STANDALONE == 1) + void etm_core(xSignalHeaderRec *msg); +#endif + + void Cust_tm_init(void); + + void l1tm_stats_fb_confirm (T_TMODE_FB_CON *prim, WORD32 test); + void l1tm_stats_sb_confirm (T_TMODE_NCELL_SYNC_IND *prim, WORD32 test); + void l1tm_stats_bcch_confirm (T_TMODE_BCCHS_CON *prim); + void l1tm_stats_tch_confirm (T_TMODE_TCH_INFO *prim); + void l1tm_stats_mon_confirm (T_TMODE_FB_CON *prim); + void l1tm_stats_full_list_meas_confirm(T_TMODE_RXLEV_REQ *prim); + BOOL l1tm_is_rx_counter_done (void); + void l1tm_reset_rx_state (void); + + void l1tm_rf_param_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_rf_param_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_rf_table_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_rf_table_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_rx_param_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_rx_param_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_tx_param_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_tx_param_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_tx_template_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_tx_template_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + + void l1tm_special_param_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_special_param_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_special_table_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_special_table_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_special_enable (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_rf_enable (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_stats_config_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_stats_config_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_statistics (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_stats_read (T_TM_RETURN *tm_return, WORD16 type, UWORD16 bitmask); + #if (L1_DRP == 1) + void l1tm_drp_sw_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + #endif + + + void l1a_tmode_send_ul_msg (T_TM_RETURN *tm_ret); + UWORD16 l1tm_convert_arfcn2l1ch(UWORD16 arfcn, UWORD8 *error_flag); + void l1tm_fill_burst (UWORD16 pattern, UWORD16 *TM_ul_data); + void l1tm_initialize_var (void); + UWORD16 Convert_l1_radio_freq (SYS_UWORD16 radio_freq); + + void tm_transmit(T_TM_RETURN *tm_ret); + + #if (CODE_VERSION != SIMULATION) + void l1tm_tpu_table_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_tpu_table_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + #endif + + #if L1_GPRS + T_TRANSFER_SET *l1pa_get_free_transfer_set (UWORD8 new_tbf); + T_CRES_LIST_PARAM *l1pa_get_free_cres_list_set(void); + void l1tm_stats_pdtch_confirm (T_TMODE_PDTCH_INFO *prim); + #endif + + + #if (L1_TPU_DEV == 1) + void l1tm_flexi_tpu_table_read(T_TESTMODE_PRIM * prim, T_TM_RETURN * tm_return); + void l1tm_flexi_tpu_table_write(T_TESTMODE_PRIM * prim, T_TM_RETURN * tm_return); + +//Flexi ABB Delay + void l1tm_flexi_abb_read(T_TESTMODE_PRIM * prim, T_TM_RETURN * tm_return); + void l1tm_flexi_abb_write(T_TESTMODE_PRIM * prim, T_TM_RETURN * tm_return); + #endif + +// DRP Calibration + void l1tm_drp_calib_read(T_TESTMODE_PRIM * prim, T_TM_RETURN * tm_return); + void l1tm_drp_calib_write(T_TESTMODE_PRIM * prim, T_TM_RETURN * tm_return); + + // Prototypes from internal functions + //------------------------------------ + void l1a_tmode_fb0_process(xSignalHeaderRec *msg); + void l1a_tmode_fb1_process(xSignalHeaderRec *msg); + void l1a_tmode_sb_process(xSignalHeaderRec *msg); + void l1a_tmode_bcch_reading_process(xSignalHeaderRec *msg); + void l1a_tmode_dedicated_process(xSignalHeaderRec *msg); + void l1a_tmode_access_process(xSignalHeaderRec *msg); + void l1a_tmode_full_list_meas_process(xSignalHeaderRec *msg); + + #if L1_GPRS + void l1a_tmode_transfer_process(xSignalHeaderRec *msg); + #endif + #if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) + void l1a_tmode_audio_stereopath_process(xSignalHeaderRec *msg); + extern void l1tm_stereopath_DMA_handler(SYS_UWORD16 dma_status); + extern void l1tm_stereopath_fill_buffer(void* buffer_address); + extern UWORD16 l1tm_stereopath_get_pattern(UWORD16 sampling_freq, UWORD16 sin_freq_left,UWORD16 sin_freq_right, UWORD8 data_type); + extern void l1a_audio_send_confirmation(UWORD32 SignalCode); + extern void l1_trigger_api_interrupt(void); +#if ( ANLG_FAM == 11) + //Add the two new sampling frequencies in the test mode for Locosto - 12khz and 24 khz + const UWORD16 l1tm_stereopath_sampling_freqs[9] = {8000,11025,12000,16000,22050,24000,32000,44100,48000}; +#else + const UWORD16 l1tm_stereopath_sampling_freqs[8] = {48000,0,44100,32000,22050,16000,11025,8000}; +#endif + const UWORD16 l1tm_stereopath_sin_freqs[4][2] = {{0,0}, + {100,1000}, + {1000,10000}, + {1000,1000}}; // 4 different pattern of two freqs + const UWORD16 l1tm_stereopath_buffer[(480+1)*2]; + + T_STP_DRV_MCU_DSP *stp_drv_ndb = (T_STP_DRV_MCU_DSP *)API_address_dsp2mcu(C_STP_DRV_API_BASE_ADDRESS); + +#if (CODE_VERSION == NOT_SIMULATION) + #pragma DATA_SECTION(TM_stereo_buf,".TM_stereo_buf"); +#endif + +#if (CHIPSET == 15) + #pragma DATA_SECTION(TM_stereo_buf_ext_mem, ".TM_stereo_buf_ext_mem"); +#endif + volatile WORD16 TM_stereo_buf[STEREOPATH_MAX_NB_OF_FRAMES*2]; +#if (CHIPSET == 15) + volatile WORD16 TM_stereo_buf_ext_mem[STEREOPATH_MAX_NB_OF_FRAMES*2]; +#endif + #endif // ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) + +/***********************************************************************/ +/* TESTMODE 3.X */ +/***********************************************************************/ + + // omaps00090550 static UWORD8 tx_param_band=0; // used in tx_param_write/read; default is GSM900 +/*-----------------------------------------------------------*/ +/* l1a_tmode() */ +/*-----------------------------------------------------------*/ +/* Description : State machine controls TestMode processes */ +/* */ +/* Starting messages: TMODE_BCCH_REQ */ +/* TMODE_PM_REQ */ +/* TMODE_FB0_REQ */ +/* TMODE_FB1_REQ */ +/* TMODE_SB_REQ */ +/* */ +/* */ +/* Result messages (input): L1_TMODE_MEAS_REPORT */ +/* L1_SB_INFO */ +/* L1_BCCHS_INFO */ +/* */ +/* Result messages (output): TMODE_PM_CON */ +/* MPH5_NCELL_SB_IND */ +/* */ +/* Reset messages (input): MPH5_STOP_BCCH_READING */ +/* */ +/*-----------------------------------------------------------*/ +void l1a_tmode(xSignalHeaderRec *msg) +{ + T_TESTMODE_PRIM *prim; + T_TM_RETURN tm_ret; + + int SignalCode = msg->SignalCode; + +#if (OP_WCP==1) && (OP_L1_STANDALONE!=1) + // Security check for Operating System platforms (open platforms) + // We forbid TESTMODE if the phone is running with an OS + // so users can not invoke TESTMODE for malicious goals + extern unsigned long GC_RunningWithOs(); + + if(GC_RunningWithOs()) + return; +#endif + + if (SignalCode == TESTMODE_PRIM) + { + // use CID to decide what to do + prim = (T_TESTMODE_PRIM *)(msg->SigP); + + // fill in the cid also named fid in the ETM protocol + tm_ret.cid = prim->cid; + + switch (prim->cid) + { + case TM_INIT: + l1tm_initialize(&tm_ret); + break; + case TM_MODE_SET: + l1tm_mode_set(prim, &tm_ret); + break; + case VERSION_GET: + l1tm_version_get(prim, &tm_ret); + break; + case RF_ENABLE: + l1tm_rf_enable(prim, &tm_ret); + break; + case STATS_READ: + l1tm_statistics(prim, &tm_ret); + break; + case STATS_CONFIG_WRITE: + l1tm_stats_config_write(prim, &tm_ret); + break; + case STATS_CONFIG_READ: + l1tm_stats_config_read(prim, &tm_ret); + break; + case RF_PARAM_WRITE: + l1tm_rf_param_write(prim, &tm_ret); + break; + case RF_PARAM_READ: + l1tm_rf_param_read(prim, &tm_ret); + break; + case RF_TABLE_WRITE: + l1tm_rf_table_write(prim, &tm_ret); + break; + case RF_TABLE_READ: + l1tm_rf_table_read(prim, &tm_ret); + break; + case RX_PARAM_WRITE: + l1tm_rx_param_write(prim, &tm_ret); + break; + case RX_PARAM_READ: + l1tm_rx_param_read(prim, &tm_ret); + break; + case TX_PARAM_WRITE: + l1tm_tx_param_write(prim, &tm_ret); + break; + case TX_PARAM_READ: + l1tm_tx_param_read(prim, &tm_ret); + break; + case TX_TEMPLATE_WRITE: + l1tm_tx_template_write(prim, &tm_ret); + break; + case TX_TEMPLATE_READ: + l1tm_tx_template_read(prim, &tm_ret); + break; + case MEM_WRITE: + l1tm_mem_write(prim, &tm_ret); + break; + case MEM_READ: + l1tm_mem_read(prim, &tm_ret); + break; + case CODEC_WRITE: + l1tm_codec_write(prim, &tm_ret); + break; + case CODEC_READ: + l1tm_codec_read(prim, &tm_ret); + break; + case MISC_PARAM_WRITE: + l1tm_misc_param_write(prim, &tm_ret); + break; + case MISC_PARAM_READ: + l1tm_misc_param_read(prim, &tm_ret); + break; + case MISC_ENABLE: + l1tm_misc_enable(prim, &tm_ret); + break; + case SPECIAL_PARAM_WRITE: + l1tm_special_param_write(prim, &tm_ret); + break; + case SPECIAL_PARAM_READ: + l1tm_special_param_read(prim, &tm_ret); + break; + case SPECIAL_TABLE_WRITE: + l1tm_special_table_write(prim, &tm_ret); + break; + case SPECIAL_TABLE_READ: + l1tm_special_table_read(prim, &tm_ret); + break; + case SPECIAL_ENABLE: + l1tm_special_enable(prim, &tm_ret); + break; + #if (L1_DRP == 1) + case DRP_SW_WRITE: + l1tm_drp_sw_write(prim, &tm_ret); + break; + #endif + #if (CODE_VERSION != SIMULATION) + case TPU_TABLE_WRITE: + l1tm_tpu_table_write(prim, &tm_ret); + break; + case TPU_TABLE_READ: + l1tm_tpu_table_read(prim, &tm_ret); + break; + #endif + case TM_FFS: + l1tm_ffs(prim, &tm_ret); + break; + #if(L1_TPU_DEV == 1) + case FLEXI_TPU_TABLE_WRITE: + l1tm_flexi_tpu_table_write(prim, &tm_ret); + break; + case FLEXI_TPU_TABLE_READ: + l1tm_flexi_tpu_table_read(prim, &tm_ret); + break; + case FLEXI_ABB_WRITE: + l1tm_flexi_abb_write(prim, &tm_ret); + break; + case FLEXI_ABB_READ: + l1tm_flexi_abb_read(prim, &tm_ret); + break; + #endif + #if 0 //(CODE_VERSION != SIMULATION) // FreeCalypso TCS211 reconstruction + case DRP_CALIB_WRITE: + l1tm_drp_calib_write(prim, &tm_ret); + break; + case DRP_CALIB_READ: + l1tm_drp_calib_read(prim, &tm_ret); + break; // TBD for Future Use + #endif // CODE_VERSION + default: + #if (OP_L1_STANDALONE == 1) + etm_core(msg); + return; + #else + tm_ret.size = 0; + #if (ETM_PROTOCOL == 1) + tm_ret.status = -ETM_BADOP; + #else + tm_ret.status = E_BADCID; + #endif + #endif // OP_L1_STANDALONE + break; + } // end of switch + tm_transmit(&tm_ret); + } //end of TESTMODE_PRIM + #if L1_GPRS + else if ( ((SignalCode <= TMODE_PDTCH_INFO) && (SignalCode >= TMODE_RXLEV_REQ)) || (l1tm.tm_msg_received == TRUE) ) + #else + else if ( ((SignalCode <= TMODE_TCH_INFO) && (SignalCode >= TMODE_RXLEV_REQ)) || (l1tm.tm_msg_received == TRUE) ) + #endif + { + #if (CODE_VERSION == SIMULATION) + static BOOL tm_init = FALSE; + + if (! tm_init) + { + Cust_tm_init(); + l1tm_initialize_var(); + l1_config.TestMode = 1; + tm_init=TRUE; + } + #endif + l1a_tmode_fb0_process(msg); + l1a_tmode_fb1_process(msg); + l1a_tmode_sb_process(msg); + l1a_tmode_bcch_reading_process(msg); + l1a_tmode_dedicated_process(msg); + l1a_tmode_access_process(msg); + l1a_tmode_full_list_meas_process(msg); + #if L1_GPRS + l1a_tmode_transfer_process(msg); + #endif + #if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) + l1a_tmode_audio_stereopath_process(msg); + #endif + } //end of not TESTMODE_PRIM +} // end of procedure. + + +/*-------------------------------------------------------*/ +/* l1a_tmode_fb0_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles the 1st */ +/* synchronization with the network in Test Mode. */ +/* */ +/* Starting messages: TMODE_FB0_REQ */ +/* */ +/* Result messages (input): L1C_FB_INFO */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_fb0_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, // Reset state. + WAIT_INIT = 1, // Initial state. + SET_FS_FB_MODE0 = 2, // First Synchro, Setting of 1st FB mode 0. + WAIT_FS_FB_MODE0 = 3 // First Synchro, 1st FB mode 0 state. + }; + + UWORD8 *state = &l1a.state[TMODE_FB0]; + UWORD32 SignalCode = msg->SignalCode; + BOOL done = 0; + +#if (VCXO_ALGO == 1) + #define FS_FB_MODE0_CENTER 1 + #define FS_FB_MODE0_MAX 2 + #define FS_FB_MODE0_MIN 3 + + static WORD16 state_vcxo; + static WORD16 static_attempt_counter; +#endif + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + +#if (VCXO_ALGO == 1) + if(l1_config.params.eeprom_afc == 0) { + // Go to the initial VCXO AFC_INIT algorithm state + state_vcxo = FS_FB_MODE0_CENTER; + static_attempt_counter = 0; + } +#endif + + // Reset tasks used in the process. + l1a_l1s_com.l1s_en_task[FBNEW] = TASK_DISABLED; // in tmode, not ALR + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; + + } + break; + + case WAIT_INIT: + { + if (SignalCode == TMODE_FB0_REQ) + { + #if (CODE_VERSION == SIMULATION) + l1tm_reset_rx_state(); + #endif + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + // Set task semaphores. + l1a_l1s_com.task_param[FBNEW] = SEMAPHORE_SET; // Set "parameter synchro semaphore for FB task. + l1a_l1s_com.task_param[NSYNC] = SEMAPHORE_SET; // Set "parameter synchro semaphore for FB task. + + l1a_l1s_com.nsync.current_list_size = 0; + + // Downlink stuff timeslot is 0 (default in CS) + l1a_l1s_com.dl_tn = 0; + + // Set arfcn + l1a_l1s_com.nsync.list[0].radio_freq =l1_config.tmode.rf_params.bcch_arfcn; + + //Set timing validity for FB no a priori info + l1a_l1s_com.nsync.list[0].timing_validity = 0; + + // Reset offset and time alignment + l1a_l1s_com.nsync.list[0].fn_offset = 0; + l1a_l1s_com.nsync.list[0].time_alignmt = 0; + + // Set functional mode. + l1a_l1s_com.mode = CS_MODE; //Needs to be set for l1ddsp_load_monit_task() + + // Wideband search for FB detection. + l1a_l1s_com.fb_mode = FB_MODE_0; + + // Enable SYNCHRO task to cleanup the MFTAB. + l1a_l1s_com.l1s_en_task[SYNCHRO] = TASK_ENABLED; + + // Initialize AFC control function. + #if AFC_ALGO + if (l1_config.afc_enable) { // l1_config.TestMode MUST == 1 + #if (VCXO_ALGO == 1) + // The TM rfpw 10 parameter has a different meaning when using + // a VCXO. Instead of containing the AFC used for the FB0, which + // is stored in the rftw 9 table now, it tells the TM which "state" must + // be used for the VCXO algorithm + // + switch(l1_config.params.eeprom_afc) { + case 0: // Full VCXO algo + // The AFC_INIT state is controlled by the state machine + // Reset attempt counter + static_attempt_counter = 0; + state_vcxo = FS_FB_MODE0_CENTER; + break; + case FS_FB_MODE0_CENTER * 8: + state_vcxo = FS_FB_MODE0_CENTER; + break; + case FS_FB_MODE0_MIN * 8: + state_vcxo = FS_FB_MODE0_MIN; + break; + case FS_FB_MODE0_MAX * 8: + state_vcxo = FS_FB_MODE0_MAX; + break; + default: + state_vcxo = FS_FB_MODE0_CENTER; + } + #endif + } + #endif + + // Step in state machine + *state = SET_FS_FB_MODE0; + } + else + { + // End of process. + return; + } + } + break; + + case SET_FS_FB_MODE0: + { + // Step in state machine. + *state = WAIT_FS_FB_MODE0; + + // Enable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_PENDING; //Used by l1s_schedule_tasks in l1_sync + + // Enable NSYNC task for FB detection mode 0. + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_ENABLED; + if (l1_config.afc_enable) {// l1_config.TestMode MUST == 1 + #if (VCXO_ALGO == 1) + switch(state_vcxo) { + case FS_FB_MODE0_CENTER: + l1s.afc = l1ctl_afc(AFC_INIT_CENTER, &l1s.afc_frame_count, NULL, 0, l1a_l1s_com.nsync.list[0].radio_freq,l1a_l1s_com.mode); + break; + case FS_FB_MODE0_MIN: + l1s.afc = l1ctl_afc(AFC_INIT_MIN, &l1s.afc_frame_count, NULL, 0, l1a_l1s_com.nsync.list[0].radio_freq,l1a_l1s_com.mode); + break; + case FS_FB_MODE0_MAX: + l1s.afc = l1ctl_afc(AFC_INIT_MAX, &l1s.afc_frame_count, NULL, 0, l1a_l1s_com.nsync.list[0].radio_freq,l1a_l1s_com.mode); + break; + default: + l1s.afc = l1ctl_afc(AFC_INIT_CENTER, &l1s.afc_frame_count, NULL, 0, l1a_l1s_com.nsync.list[0].radio_freq,l1a_l1s_com.mode); + } + #else + l1s.afc = l1ctl_afc(AFC_INIT, &l1s.afc_frame_count, l1_config.params.eeprom_afc, 0, l1a_l1s_com.nsync.list[0].radio_freq); + #endif + } // (l1_config.afc_enable) is TRUE + + // End of process. + end_process = 1; + } + break; + + case WAIT_FS_FB_MODE0: + { + if(SignalCode == L1C_FB_INFO) + // Frequency Burst acquisition result. + //------------------------------------ + { + BOOL fb_found = ((T_L1C_FB_INFO *) (msg->SigP))->fb_flag; + + if (fb_found) + { + // We consider the result of this successfull FB search attempt + // as a good a-priori information for next attempt. + // "fn_offset" is reversed to satisfy its definition, + // fn_offset = Fn_neigh - Fn_serving. + l1a_l1s_com.nsync.list[0].timing_validity = 1; + l1a_l1s_com.nsync.list[0].fn_offset = 51 - l1a_l1s_com.nsync.list[0].fn_offset; + } +#if (VCXO_ALGO == 1) + else + { + if(l1_config.params.eeprom_afc == 0) + { + //- Full VCXO algo + + // Increment "static_attempt_counter". + static_attempt_counter++; + if(static_attempt_counter < 4) + { + // Max number of attemps not reached yet... + // try again with the same VCXO state + *state = SET_FS_FB_MODE0; + // Do not accumulate the statistics yet, just try again + break; + } + else + { + // Max number of attempt is reached... go back to 1st FB mode 0. + // Step in state machine. + static_attempt_counter = 0; + + // Go to the next FS_FB_MODE0_CENTER state (CENTER -> MAX -> MIN) + // After MIN go to CENTER again, which means that the attempt failed + switch(state_vcxo) + { + case FS_FB_MODE0_CENTER: + state_vcxo = FS_FB_MODE0_MAX; + break; + case FS_FB_MODE0_MAX: + state_vcxo = FS_FB_MODE0_MIN; + break; + default: // i.e. case FS_FB_MODE0_MAX: + // The algorithm tried all the AFC_INIT values (CENTER, MAX & MIN) + // but did not detect an FB in any of the attemps for these values: + // The current attempt FAILED => Continue and accumulate the statistics + state_vcxo = FS_FB_MODE0_CENTER; + break; + } + + if (state_vcxo != FS_FB_MODE0_CENTER) + { + *state = SET_FS_FB_MODE0; + // Do not accumulate the statistics yet, just try again with the new + // selected state_vcxo + break; // This breaks from the switch(*state), and thus re-loops thanks to the while(!end_process) + } // (state_vcxo != FS_FB_MODE0_CENTER) + } // (static_attempt_counter >= 4) + } // (l1_config.params.eeprom_afc != 0) + } // (fb_found) is FALSE +#endif + +#if (VCXO_ALGO == 1) + if(l1_config.params.eeprom_afc == 0) + { + // If we got this far, the attempt ended (with a fail or a success) + // So we can go back to the initial state + state_vcxo = FS_FB_MODE0_CENTER; + } +#endif + + //accumulate FB stats + l1tm_stats_fb_confirm( (T_TMODE_FB_CON*) ((T_L1C_FB_INFO *) (msg->SigP)), 0); + + done = l1tm_is_rx_counter_done(); + if (done == 1) + { + // Loop counter expired, stop the test + *state = RESET; + + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + break; // break out of switch + } + *state = SET_FS_FB_MODE0; + } + else if (SignalCode == TMODE_STOP_RX_TX) + // Stop SYNC mode message. + //-------------------------------- + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Step in state machine. + *state = RESET; + + return; + } + else + { + // End of process. + return; + } + } + break; + } + } +} + + +/*-------------------------------------------------------*/ +/* l1a_tmode_fb1_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles the 1st */ +/* synchronization with the network in Test Mode. */ +/* */ +/* Starting messages: TMODE_FB1_REQ */ +/* */ +/* Result messages (input): L1C_FB_INFO */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_fb1_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, // Reset state. + WAIT_INIT = 1, // Initial state. + SET_FS_FB_MODE1 = 2, // First Synchro, Setting of 1st FB mode 1. + WAIT_FS_FB_MODE1 = 3 // First Synchro, FB mode 1 state. + }; + + UWORD8 *state = &l1a.state[TMODE_FB1]; + UWORD32 SignalCode = msg->SignalCode; + BOOL done = 0; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset of tasks used in this process is carried out in WAIT_FS_FBMODE1 state + // Otherwise we would possibly reset the task set by l1a_tmode_fb0_process() + } + break; + + case WAIT_INIT: + { + if (SignalCode == TMODE_FB1_REQ) + { + #if (CODE_VERSION == SIMULATION) + l1tm_reset_rx_state(); + #endif + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + // Set task semaphores. + l1a_l1s_com.task_param[FBNEW] = SEMAPHORE_SET; // Set "parameter synchro semaphore for FB task. + l1a_l1s_com.task_param[NSYNC] = SEMAPHORE_SET; // Set "parameter synchro semaphore for FB task. + + // Downlink stuff timeslot is 0 (default in CS) + l1a_l1s_com.dl_tn = 0; + + // Set arfcn + l1a_l1s_com.nsync.list[0].radio_freq =l1_config.tmode.rf_params.bcch_arfcn; + + // Set functional mode. + l1a_l1s_com.mode = CS_MODE; //Needs to be set for l1ddsp_load_monit_task() + + // Set FB detection mode. + l1a_l1s_com.fb_mode = FB_MODE_1; + + // Step in state machine + *state = SET_FS_FB_MODE1; + } + else + { + // End of process. + return; + } + } + break; + + case SET_FS_FB_MODE1: + { + // Step in state machine. + *state = WAIT_FS_FB_MODE1; + + // Enable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_PENDING; + + // Enable NSYNC task for FB detection mode 1. + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_ENABLED; + + // End of process. + end_process = 1; + } + break; + + case WAIT_FS_FB_MODE1: + { + // Use incoming message. + //---------------------- + if(SignalCode == L1C_FB_INFO) + { + //accumulate FB stats + l1tm_stats_fb_confirm( (T_TMODE_FB_CON*) ((T_L1C_FB_INFO *) (msg->SigP)), 0); + + // increment counter + done = l1tm_is_rx_counter_done(); + + if (done == 1) + { + // Loop counter expired, stop the test + *state = RESET; + + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Reset tasks used in the process. + l1a_l1s_com.l1s_en_task[FBNEW] = TASK_DISABLED; // in tmode, not ALR + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; + + break; // break out of switch + } + + *state = SET_FS_FB_MODE1; + } // end if L1C_FB_INFO + else if (SignalCode == TMODE_STOP_RX_TX) + // Stop SYNC mode message. + //-------------------------------- + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Step in state machine. + *state = RESET; + + return; + } + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + return; + } + } + break; + } + } +} + + +/*-------------------------------------------------------*/ +/* l1a_tmode_sb_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles the 1st */ +/* synchronization with the network in Test Mode. */ +/* */ +/* Starting messages: TMODE_SB_REQ */ +/* */ +/* Result messages (input): L1C_SB_INFO */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_sb_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, // Reset state. + WAIT_INIT = 1, // Initial state. + SET_FS_SB = 2, // Set SB + WAIT_FS_SB = 3, // Wait for SB result + NEW_SYNCHRO = 4 // Camp on cell + }; + + UWORD8 *state = &l1a.state[TMODE_SB]; + UWORD32 SignalCode = msg->SignalCode; + BOOL done = 0; + + static UWORD8 static_bsic; + static UWORD32 static_fn_offset; + static UWORD32 static_time_alignmt; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset of tasks used in this process is carried out in WAIT_FS_SB state + // Otherwise we would possibly reset the NSYNC task set by l1a_tmode_fb0_process() + // or l1a_tmode_fb1_process + } + break; + + case WAIT_INIT: + { + if (SignalCode == TMODE_SB_REQ) + { + #if (CODE_VERSION == SIMULATION) + l1tm_reset_rx_state(); + #endif + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + // Set arfcn + l1a_l1s_com.nsync.list[0].radio_freq =l1_config.tmode.rf_params.bcch_arfcn; + + // Enable NSYNC task for SB detection (SB2). + #if ((REL99 == 1) && ((FF_BHO == 1) || (FF_RTD == 1))) + l1a_l1s_com.nsync.list[0].timing_validity = SB_ACQUISITION_PHASE ; + #else + l1a_l1s_com.nsync.list[0].timing_validity = 3; + #endif + + // Step in state machine + *state = SET_FS_SB; + } + else + { + // End of process. + return; + } + } + break; + + case SET_FS_SB: + { + // Step in state machine. + *state = WAIT_FS_SB; + + // Enable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_PENDING; + + // Enable NSYNC task for SB detection. + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_ENABLED; + + // End of process. + end_process = 1; + } + break; + + case WAIT_FS_SB: + { + // Use incoming message. + //---------------------- + if(SignalCode == L1C_SB_INFO) + { + UWORD8 sb_found = ((T_MPHC_NCELL_SYNC_IND *)(msg->SigP))->sb_flag; + UWORD8 bsic = ((T_MPHC_NCELL_SYNC_IND *)(msg->SigP))->bsic; + + if(sb_found == TRUE) + // SB detection is a success... + //----------------------------- + { + // Save Results. + static_bsic = ((T_MPHC_NCELL_SYNC_IND *)(msg->SigP))->bsic; + static_fn_offset = ((T_MPHC_NCELL_SYNC_IND *)(msg->SigP))->fn_offset; + static_time_alignmt = ((T_MPHC_NCELL_SYNC_IND *)(msg->SigP))->time_alignmt; + } + + l1tm_stats_sb_confirm( (T_TMODE_NCELL_SYNC_IND*) ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP)), 0); + + // if just an SB test, increment counter + // if not done, just stay in this state, schedule a new attempt + done = l1tm_is_rx_counter_done(); + + if (done == 1) + { + // step in state machine + *state = NEW_SYNCHRO; + + // Reset NSYNC task and SB2 task enable flags. + l1a_l1s_com.l1s_en_task[SB2] = TASK_DISABLED; // in tmode, not ALR + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; + + // Save results. + l1a_l1s_com.nsync.list[0].fn_offset = static_fn_offset; + l1a_l1s_com.nsync.list[0].time_alignmt = static_time_alignmt; + + // Correct "ntdma" and "time_alignment" to shift 20 bit to the + // future for Normal Burst reading tasks. + l1a_add_time_for_nb(&l1a_l1s_com.nsync.list[0].time_alignmt, + &l1a_l1s_com.nsync.list[0].fn_offset); + + break; // break out of switch + } + else + // Make a new SB attempt + { + l1a_l1s_com.nsync.list[0].status = NSYNC_PENDING; + + // End of process. + end_process = 1; + } + } + else if (SignalCode == TMODE_STOP_RX_TX) + // Stop SYNC mode message. + //-------------------------------- + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Step in state machine. + *state = RESET; + + end_process = 1; + } + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + end_process = 1; + } + }//End Case WAIT_FS_SB + break; + + case NEW_SYNCHRO: + { + // Reset the Neighbor Cell information structure. + l1a_reset_cell_info(&(l1a_l1s_com.Scell_info)); + + // STILL SAVING TSC WITHIN BSIC !!!!!!!!!!!!!!!! + + // Download ARFCN, timing information and bitmap from the command message. + l1a_l1s_com.Scell_info.radio_freq = l1_config.tmode.rf_params.bcch_arfcn; + l1a_l1s_com.Scell_info.bsic = static_bsic; + l1a_l1s_com.Scell_info.time_alignmt = l1a_l1s_com.nsync.list[0].time_alignmt; + l1a_l1s_com.Scell_info.fn_offset = l1a_l1s_com.nsync.list[0].fn_offset; + + // tn_difference -> loaded with the number of timeslot to shift. + // dl_tn -> loaded with the new timeslot. + l1a_l1s_com.tn_difference = 0 - l1a_l1s_com.dl_tn; + l1a_l1s_com.dl_tn = 0; // Camping on timeslot 0. + + // Layer 1 internal mode is set to IDLE MODE. + l1a_l1s_com.mode = I_MODE; + + // Set flag for toa init. + #if (TOA_ALGO != 0) + l1a_l1s_com.toa_reset = TRUE; + #endif + + // Enable SYNCHRO tasks. + l1a_l1s_com.l1s_en_task[SYNCHRO] = TASK_ENABLED; + + // Step in state machine. + *state = RESET; + + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + } + break; // break out of switch + // omaps00090550 break; + } + } +} + +/*-------------------------------------------------------*/ +/* l1a_tmode_bcch_reading_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles serving cell */ +/* BCCH reading in Test Mode. */ +/* */ +/* This process happens for a TestMode BCCH test, after */ +/* completing FB's and SB's in */ +/* l1a_tmode_initial_network_sync_process, */ +/* and then passing through l1a_tmode_cres_process, */ +/* */ +/* OR */ +/* */ +/* it can also happen for a TestMode TCH with synch */ +/* test where, FB's and SB's have already been detected, */ +/* and 4 BCCH's will be received before moving to the */ +/* TCH and dedicated mode. */ +/* */ +/* */ +/* Starting messages: TMODE_SCELL_NBCCH_REQ */ +/* ------------------ */ +/* */ +/* */ +/* Result messages (input): L1C_BCCHS_INFO */ +/* ------------------------ */ +/* System information data block from L1S. */ +/* */ +/* */ +/* Reset messages (input): TMODE_STOP_SCELL_BCCH_REQ */ +/* ----------------------- */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_bcch_reading_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + NBCCHS_CONFIG = 2, + WAIT_BCCHS_RESULT = 3 + }; + + UWORD8 *state = &l1a.state[TMODE_BCCH]; + UWORD32 SignalCode = msg->SignalCode; + BOOL done = 0; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset CS_MEAS process. + l1a_l1s_com.l1s_en_task[NBCCHS] = TASK_DISABLED; // Clear NBCCHS task enable flag. + //l1a_l1s_com.l1s_en_task[EBCCHS] = TASK_DISABLED; // Clear EBCCHS task enable flag. + } + break; + + case WAIT_INIT: + { + if(SignalCode == TMODE_SCELL_NBCCH_REQ) + { + + #if (CODE_VERSION == SIMULATION) + l1tm_reset_rx_state(); + #endif + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + // Request to read Normal BCCH from serving cell. + l1a_l1s_com.Scell_info.radio_freq = l1_config.tmode.rf_params.bcch_arfcn; + + // Step in state machine. + *state = NBCCHS_CONFIG; + } + + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + return; + } + } + break; + + case NBCCHS_CONFIG: + { + UWORD8 i; + + // Set semaphores for Normal Serving BCCH reading task. + l1a_l1s_com.task_param[NBCCHS] = SEMAPHORE_SET; + + // Download message content. + //-------------------------- + l1a_l1s_com.nbcchs.schedule_array_size = 1; + + for(i=0;i<l1a_l1s_com.nbcchs.schedule_array_size;i++) + { + l1a_l1s_com.nbcchs.schedule_array[i].modulus = 1; + l1a_l1s_com.nbcchs.schedule_array[i].relative_position = 0; + } + + // Enable NBCCHS task. + l1a_l1s_com.l1s_en_task[NBCCHS] = TASK_ENABLED; + + // Step in state machine. + *state = WAIT_BCCHS_RESULT; + + // End of process. + end_process = 1; + } + break; + + case WAIT_BCCHS_RESULT: + { + if(SignalCode == L1C_BCCHS_INFO) + // Serving cell BCCH reading result. + //---------------------------------- + { + // this function takes care of loops management + l1tm_stats_bcch_confirm( (T_TMODE_BCCHS_CON*) ((T_MPHC_DATA_IND *)(msg->SigP)) ); + + done = l1tm_is_rx_counter_done(); + + if (done == 1) + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // This process must be reset. + *state = RESET; + + break; + } + else + { + // End of process. + end_process = 1; + } + } + else if (SignalCode == TMODE_STOP_RX_TX) + // Stop BCCH mode message. + //-------------------------------- + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Step in state machine. + *state = RESET; + + end_process = 1; + } + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + end_process = 1; + } + } + break; + } // end of "switch". + } // end of "while" +} // end of procedure. + +/*-------------------------------------------------------*/ +/* l1a_tmode_dedicated_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles the dedicated*/ +/* mode setup in Test Mode (L1A side). */ +/* */ +/* Starting messages: TMODE_IMMED_ASSIGN_REQ */ +/* */ +/* Subsequent messages: */ +/* */ +/* Result messages (input): L1C_DEDIC_DONE */ +/* */ +/* Result messages (output): */ +/* */ +/* Reset messages (input): TMODE_STOP_RX_TX */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_dedicated_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_MSG = 2 + }; + + T_DEDIC_SET *free_set; + UWORD8 *state = &l1a.state[TMODE_DEDICATED]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + l1a_l1s_com.l1s_en_task[FB26] = TASK_DISABLED; // Reset FB26 task enable flag. + + // Reset D_NMEAS process. + l1a_l1s_com.l1s_en_meas &= D_BAMS_MEAS_MASK; // Reset D_BAMS Measurement enable flag. + l1a.l1a_en_meas[D_NMEAS] &= D_BAMS_MEAS_MASK; + + // Reset L1S dedicated mode manager trigger. + l1a_l1s_com.dedic_set.SignalCode = NULL; + } + break; + + case WAIT_INIT: + { + switch(SignalCode) + // switch on input message. + //------------------------------- + { + case TMODE_IMMED_ASSIGN_REQ: + // Immediate assignement message. + //------------------------------- + { + UWORD8 maio_bef_sti; +#if(L1_FF_MULTIBAND == 1) + UWORD8 operative_radio_freq; +#endif + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + #if (CODE_VERSION == SIMULATION) + l1_config.tmode.rf_params.down_up = ((T_TMODE_IMMED_ASSIGN_REQ*)(msg->SigP))->ul_dl; + l1tm_reset_rx_state(); + l1_config.tmode.stats_config.num_loops = 26; // 0 actually means infinite + #endif + + // save this info for later + if (l1_config.tmode.rf_params.down_up == (TMODE_DOWNLINK|TMODE_UPLINK) && + l1_config.tmode.rf_params.mon_tasks == 1) + { + l1a_l1s_com.nsync.list[0].radio_freq = l1_config.tmode.rf_params.mon_arfcn; + } + + // Get Ptr to the free dedicated parameter set. + // All important fields are initialised. + free_set = l1a_get_free_dedic_set(); + + // Save given dedicated channel parameters from MPHC_IMMED_ASSIGN_REQ msg. + +//======================================================================== + + free_set->chan1.desc.chan_sel.h = 0; // no hopping + + free_set->chan1.desc.chan_sel.rf_channel.single_rf.radio_freq = l1_config.tmode.rf_params.tch_arfcn; + //DON'T: union with radio_freq + //free_set->chan1.desc.chan_sel.rf_channel.hopping_rf.maio=0; + //free_set->chan1.desc.chan_sel.rf_channel.hopping_rf.hsn=0; + + free_set->chan1.desc.channel_type = l1_config.tmode.rf_params.channel_type; + free_set->chan1.desc.subchannel = l1_config.tmode.rf_params.subchannel; + free_set->chan1.desc.timeslot_no = l1_config.tmode.rx_params.slot_num; + free_set->chan1.desc.tsc = l1_config.tmode.tx_params.tsc; + + //Set the loopback mode + // 0: No loopback, 1: Loop A ... 6: Loop F + if(l1_config.tmode.tx_params.burst_data >= 5 && l1_config.tmode.tx_params.burst_data <= 10 && + l1_config.tmode.rf_params.down_up == (TMODE_DOWNLINK | TMODE_UPLINK)) + { + free_set->chan1.tch_loop = l1_config.tmode.tx_params.burst_data - 4; + + // For loop back the channel mode needs to be set to TCH/FS + free_set->chan1.mode = TCH_FS_MODE; + } + else + { + free_set->chan1.tch_loop = 0; // no loopback + + // Rem1: Mode is forced to Signalling Only. + if (l1_config.tmode.rf_params.channel_type == TCH_F) + free_set->chan1.mode = TCH_FS_MODE; + else + free_set->chan1.mode = SIG_ONLY_MODE; + + } +/* +;-------------------------------------------------------------------------- +; channel_desc_1 : +; chan_sel : ( h=FALSE, arfcn=5a ) +; channel_type = 1 (TCHFS) +; subchannel = 0 +; timeslot_no = 0 +; tsc = 5 +; timing_advance = 0 +; frequency_list : +; rf_chan_cnt = 0000 +; rf_chan_no : (0000, 0000, ...(total of 64)... 0000) +; starting_time = +; start_time_present = FALSE +; start_time : +; n32 = +; n51 = +; n26 = +; frequency_list_bef_sti +; rf_chan_cnt = 0000 +; rf_chan_no : (0000, 0000, ...(total of 64)... 0000) +; maio_bef_sti = 0 +; dtx_allowed = FALSE +; bcch_allocation = 0 carriers (...) UNUSED +; ba_id = 0 UNUSED +; pwrc = 5 +;-------------------------------------------------------------------------- +*/ + free_set->ma.freq_list.rf_chan_cnt = 0; + free_set->ma.freq_list.rf_chan_no.A[0] = 0; + free_set->ma.freq_list_bef_sti.rf_chan_cnt = 0; + free_set->ma.freq_list_bef_sti.rf_chan_no.A[0] = 0; //DedicNew + + maio_bef_sti = 0; + + free_set->new_timing_advance = l1_config.tmode.tx_params.timing_advance; + free_set->dtx_allowed = 0; + // New Timing Advance value must be applied on 1st frame of dedic. channel. + free_set->timing_advance = free_set->new_timing_advance; + + l1a_l1s_com.dedic_set.pwrc = l1_config.tmode.tx_params.txpwr; + // l1a_l1s_com.dedic_set.pwrc = 5; // change from TM2! + + // TXPWR command was given in Idle, save it in dedicated mode structure. + free_set->new_target_txpwr = l1s.applied_txpwr = l1_config.tmode.tx_params.txpwr; + + // Serving Cell stays the same. + free_set->cell_desc = l1a_l1s_com.Scell_info; + +#if(L1_FF_MULTIBAND == 0) + + free_set->cell_desc.traffic_meas_beacon + = l1a_l1s_com.last_input_level[l1a_l1s_com.Scell_info.radio_freq - l1_config.std.radio_freq_index_offset]; + free_set->cell_desc.traffic_meas = l1a_l1s_com.last_input_level[l1a_l1s_com.Scell_info.radio_freq - l1_config.std.radio_freq_index_offset]; + +#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); + + free_set->cell_desc.traffic_meas_beacon + = l1a_l1s_com.last_input_level[operative_radio_freq]; + free_set->cell_desc.traffic_meas = l1a_l1s_com.last_input_level[operative_radio_freq]; + +#endif // #if(L1_FF_MULTIBAND == 0) else + + + // Decode the "starting time field", since staying on the same serving + // the same STI fn is saved in both "neig_sti_fn" and "serv_sti_fn". + free_set->neig_sti_fn = -1; //l1a_decode_starting_time(((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->starting_time); + free_set->serv_sti_fn = free_set->neig_sti_fn; + + // Check/Fill "before starting time" fields. + //l1a_fill_bef_sti_param(free_set, ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->starting_time.start_time_present); + + //No hopping channel + + // 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 = free_set->chan1.desc.timeslot_no - l1a_l1s_com.dl_tn; + l1a_l1s_com.dl_tn = free_set->chan1.desc.timeslot_no; // Save new TN id. + + // Set "fset" pointer to the new parameter set. + l1a_l1s_com.dedic_set.fset = free_set; + + // Give new msg code to L1S. //TestMode: use existing L1S primitive name + l1a_l1s_com.dedic_set.SignalCode = MPHC_IMMED_ASSIGN_REQ; + + // step in state machine. + *state = WAIT_MSG; + } + break; + + } // end of "switch(SignalCode)". + // end of process. + end_process = 1; + } + break; + + case WAIT_MSG: + { + switch(SignalCode) + // switch on input message. + //------------------------------- + { + case L1C_DEDIC_DONE: + // Dedicated channel activated. + //----------------------------- + { + // if MON tasks are enabled, set up FB26 and D_BAMS_MEAS tasks now as well + if (l1_config.tmode.rf_params.down_up == (TMODE_DOWNLINK|TMODE_UPLINK) && + l1_config.tmode.rf_params.mon_tasks == 1) + { + l1a_l1s_com.task_param[FB26] = SEMAPHORE_SET; + l1a_l1s_com.l1s_en_task[FB26] = TASK_ENABLED; +#if (L1_12NEIGH ==1) + //Set timing validity for FB no a priori info + l1a_l1s_com.nsync.list[0].timing_validity = 0; + + // Enable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_PENDING; //Used by l1s_schedule_tasks in l1_sync + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_ENABLED; +#endif + } + + if (l1_config.tmode.rx_params.pm_enable) + { + // Reset the BA list structure + l1a_reset_ba_list(); + + // Next measurement report must indicate INVALID. + //meas_valid = FALSE; + + l1a_l1s_com.ba_list.nbr_carrier = 1; + + // l1a_l1s_com.nsync.list[0].radio_freq was set to mon_arfcn above + l1a_l1s_com.ba_list.A[0].radio_freq = l1a_l1s_com.nsync.list[0].radio_freq; + + // Set parameter synchro semaphore for D_BAMS task. + // Enable Dedicated mode BA list measurement task. + l1a_l1s_com.meas_param |= D_BAMS_MEAS; + l1a.l1a_en_meas[D_NMEAS] |= D_BAMS_MEAS; + } + + // keep track of dedicated mode state. + l1tm.tmode_state.dedicated_active = 1; + + // End of process. + end_process = 1; + } + break; + + case TMODE_TCH_INFO: + // TCH result messages. + //----------------------- + { + // Check if RX stats done in TCH + if (l1_config.tmode.rf_params.mon_report == 0) + { + BOOL done; + + // loop and stats management done within this function + l1tm_stats_tch_confirm((T_TMODE_TCH_INFO *) (msg->SigP)); + + done = l1tm_is_rx_counter_done(); + + if (done == 1) + // if done, send stop message + { + l1tm.tmode_state.dedicated_active = 0; + + // Give new msg code to L1S. + l1a_l1s_com.dedic_set.SignalCode = MPHC_STOP_DEDICATED_REQ; + + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + +#if (L1_12NEIGH ==1) + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; //Used by l1s_schedule_tasks in l1_sync +#endif + + // Step in state machine. + *state = RESET; + } + } + + // end of process + end_process = 1; + } + break; + + case L1C_FB_INFO: + // MON result messages. + //----------------------- + { + // Check if RX stats done in Monitor channel + if (l1_config.tmode.rf_params.mon_report == 1) + { + BOOL done; + + // loop and stats management done within this function + l1tm_stats_mon_confirm( (T_TMODE_FB_CON*) ((T_L1C_FB_INFO *) (msg->SigP))); + + done = l1tm_is_rx_counter_done(); + + if (done == 1) + // if done, send stop message + { + l1tm.tmode_state.dedicated_active = 0; + + // Give new msg code to L1S. + l1a_l1s_com.dedic_set.SignalCode = MPHC_STOP_DEDICATED_REQ; + + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + +#if (L1_12NEIGH ==1) + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; //Used by l1s_schedule_tasks in l1_sync +#endif + + // Step in state machine. + *state = RESET; + } + } + + // end of process + end_process = 1; + } + break; + + case TMODE_STOP_RX_TX: + // Release dedicated mode message. + //-------------------------------- + { + l1tm.tmode_state.dedicated_active = 0; + + // Give new msg code to L1S. + l1a_l1s_com.dedic_set.SignalCode = MPHC_STOP_DEDICATED_REQ; + + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + +#if (L1_12NEIGH ==1) + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; //Used by l1s_schedule_tasks in l1_sync +#endif + // Step in state machine. + *state = RESET; + + end_process = 1; + } + break; + + default: + // End of process. + //---------------- + { + end_process = 1; + } + } // end of "switch(SignalCode)". + } + break; + + } // end of "switch". + } // end of "while" +} // end of procedure. + +/*-------------------------------------------------------*/ +/* l1a_tmode_ra_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles the TestMode */ +/* access to the network (IDLE mode). */ +/* */ +/* Starting messages: TMODE_RA_START */ +/* */ +/* Result messages (input): L1C_RA_DONE */ +/* */ +/* Result messages (output): TMODE_RA_DONE */ +/* */ +/* Stop messages (input): TMODE_STOP_RX_TX */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_access_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_RESULT = 2 + }; + + UWORD8 *state = &l1a.state[TMODE_RA]; + UWORD32 SignalCode = msg->SignalCode; + BOOL done = 0; + + while(1) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset RAACC process. + l1a_l1s_com.l1s_en_task[RAACC] = TASK_DISABLED; // Clear RAACC task enable flag. + } + break; + + case WAIT_INIT: + { + if(SignalCode == TMODE_RA_START) + // Configuration message for Access Link. + //--------------------------------------- + { + // Flag msg received + l1tm.tm_msg_received = TRUE; + + l1s.applied_txpwr = l1_config.tmode.tx_params.txpwr; + l1a_l1s_com.ra_info.channel_request = 2; //l1_config.tm_params.channel_request; + + // Initialize rand counter for RAACC process. + l1a_l1s_com.ra_info.rand = 1; + + // rand is random number of frames to wait between each AB transmission. + // In actual L1 code this changes with each burst. + // It is set to 1 here so the test runs fast. + + // also, channel_request is constant in TestMode for all bursts. + // Actual L1 changes channel_request message each time with a different + // random reference. [channel_request = 3 bits for establishment cause + // and 5 bits of random reference] + + // Use 2 multiframes (0.5 seconds) in reading all serving normal bursts + // (like paging reorganization) to refine TOA since we must have the quarter + // bit accuracy for RACH transmission. + + // Delay the start of RACH transmission (by incrementing rand + // counter), only at the start of the test. + + if(l1a_l1s_com.bcch_combined) + { + l1a_l1s_com.ra_info.rand += 54; // Combined: 2 multiframes = 54 slots. + } + else + { + l1a_l1s_com.ra_info.rand += 102; // Not combined: 2 multiframes = 102 slots. + } + + // step in state machine. + *state = WAIT_RESULT; + + // TestMode does not set up full BCCH reading + + // Activate RAACC task (no semaphore for UL tasks). + // TestMode does not enable Paging Reorg and Normal paging tasks. + l1a_l1s_com.l1s_en_task[RAACC] = TASK_ENABLED; + + // Change mode to connection establishment part 1. + l1a_l1s_com.mode = CON_EST_MODE1; // used for toa calc. + } + + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + return; + } + } + break; + + case WAIT_RESULT: + { + if(SignalCode == L1C_RA_DONE) + // Random access acknowledge message. + //----------------------------------- + { + // Change mode to connection establishment part 2. + l1a_l1s_com.mode = CON_EST_MODE2; // used for toa calc. + + //change power level and arfcn on the fly + l1s.applied_txpwr = l1_config.tmode.tx_params.txpwr; +// l1a_l1s_com.Scell_info.radio_freq = l1_config.tmode.rf_params.tch_arfcn; + + done = l1tm_is_rx_counter_done(); + + if (done) + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // No stats, just report end + //tmstats_ra_confirm( (T_TMODE_RA_DONE*) ((T_MPHC_RA_CON *)(msg->SigP)) ); + + *state = RESET; + } + else // there are more loops to do... + { + l1a_l1s_com.ra_info.rand += 10; // 1 chosen/set for quicker test + // Activate RAACC task (no semaphore for UL tasks). + l1a_l1s_com.l1s_en_task[RAACC] = TASK_ENABLED; + // end of process + return; + } + } + + else if(SignalCode == TMODE_STOP_RX_TX) + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // No stats, just report end + //tmstats_ra_confirm( (T_TMODE_RA_DONE*) ((T_MPHC_RA_CON *)(msg->SigP)) ); + *state = RESET; + return; + } + + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + return; + } + } + break; + } // end of "switch". + } // end of "while" +} // end of procedure. + +/*-------------------------------------------------------*/ +/* l1a_tmode_full_list_meas_process() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* This function is a state machine which handles the */ +/* Cell Selection Full List Power Measurement L1/L3 */ +/* interface and it handles the neigbour cell */ +/* measurement process in IDLE mode with FULL list. */ +/* When a message MPHC_RXLEV_REQ is received */ +/* the L1S task FSMS_MEAS is enabled. When this task */ +/* is completed a reporting message L1C_VALID_MEAS_INFO */ +/* is received and forwarded to L3. */ +/* */ +/* Starting messages: MPHC_RXLEV_REQ. */ +/* */ +/* Result messages (input): L1C_VALID_MEAS_INFO */ +/* */ +/* Result messages (output): MPHC_RXLEV_IND */ +/* */ +/* Reset messages (input): none */ +/* */ +/* Stop message (input): MPHC_STOP_RXLEV_REQ */ +/* */ +/* Stop message (output): MPHC_STOP_RXLEV_CON */ +/* */ +/* Rem: */ +/* ---- */ +/* L3 is in charge of the number of pass to follow the */ +/* GSM recommendation. */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_full_list_meas_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_RESULT = 2 + }; + + UWORD8 *state = &l1a.state[TMODE_FULL_MEAS]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset FULL_MEAS process. + l1a_l1s_com.l1s_en_meas &= FSMS_MEAS_MASK; // Clear Cell Selection Measurement enable flag. + } + break; + + case WAIT_INIT: + { + if(SignalCode == TMODE_RXLEV_REQ) + // Request to enter the Cell Selection measurements. + //-------------------------------------------------- + { + UWORD16 i; + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + // Do NOT download info from message + // In TestMode always a full scanning is done, therefore primitive does not send the list + l1a_l1s_com.full_list_ptr=(T_FULL_LIST_MEAS *)((T_TMODE_RXLEV_REQ *)(msg->SigP)); + + // Single power measurement carried out on monitor channel + l1a_l1s_com.full_list_ptr->power_array_size = 1; + l1a_l1s_com.full_list_ptr->power_array[0].radio_freq = l1_config.tmode.rf_params.mon_arfcn; + + // Set "parameter synchro semaphores" + l1a_l1s_com.meas_param |= FSMS_MEAS; + + // Reset the full list structure. + l1a_reset_full_list(); + + // Reset the Input Level (IL) memory table. +#if (L1_FF_MULTIBAND == 1) + for(i=0; i<= NBMAX_CARRIER; i++) +#else + for(i=0; i<=l1_config.std.nbmax_carrier; i++) +#endif + { + l1a_l1s_com.last_input_level[i].input_level = l1_config.params.il_min; + l1a_l1s_com.last_input_level[i].lna_off = 0; + } + + // Enable Cell Selection Full list measurement task. + l1a.l1a_en_meas[TMODE_FULL_MEAS] |= FSMS_MEAS; + + // Step in state machine. + *state = WAIT_RESULT; + } + + // End of process. + end_process = 1; + } + break; + + case WAIT_RESULT: + { + if(SignalCode == L1C_VALID_MEAS_INFO) + // One valid measurement pass has been completed over the full list of carriers. + //------------------------------------------------------------------------------ + { + BOOL done = FALSE; + + //-------------------------------------------------------- + // WE COULD PUT HERE THE CODE TO TRANSLATE IL -> RXLEV !!! + //-------------------------------------------------------- + + l1tm_stats_full_list_meas_confirm((T_TMODE_RXLEV_REQ *)(msg->SigP)); + + done = l1tm_is_rx_counter_done(); + + if (done) + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Reset the machine. + *state = RESET; + } + else + { + // Reset the full list structure. + l1a_reset_full_list(); + + // Enable Cell Selection Full list measurement task. + l1a.l1a_en_meas[TMODE_FULL_MEAS] |= FSMS_MEAS; + + // End of process + end_process = 1; + } + } + + else if (SignalCode == TMODE_STOP_RX_TX) + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Forward result message to L3. + l1a_send_confirmation(TMODE_STOP_RXLEV_CON,RRM1_QUEUE); + // Reset the machine. + *state = RESET; + end_process = 1; + } + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + end_process = 1; + } + } + break; + } // end of "switch". + } // end of "while" +} // end of procedure. + + + #if L1_GPRS + /*-------------------------------------------------------*/ + /* l1pa_tmode_transfer_process() */ + /*-------------------------------------------------------*/ + /* Description: */ + /* ------------ */ + /* */ + /* Starting messages: */ + /* ------------------ */ + /* */ + /* Subsequent messages: */ + /* -------------------- */ + /* */ + /* Result messages (input): */ + /* ------------------------ */ + /* */ + /* Result messages (output): */ + /* ------------------------- */ + /* */ + /* Reset messages (input): */ + /* ----------------------- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_tmode_transfer_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_MSG = 2 + }; + + UWORD8 *state = &l1a.state[TMODE_TRANSFER]; + UWORD32 SignalCode = msg->SignalCode; + + static UWORD8 stat_gprs_slots; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset FB26 task enable flag. + l1a_l1s_com.l1s_en_task[FB26] = TASK_DISABLED; + + // Reset TCR_MEAS process. + l1pa_l1ps_com.l1ps_en_meas &= P_TCRMS_MEAS_MASK; // Disable Neighbour Measurement task. + l1pa.l1pa_en_meas[TCR_MEAS] &= P_TCRMS_MEAS_MASK; // Reset Neighbour Measurement task. + + // Rise transfert parameter semaphore. + l1pa_l1ps_com.transfer.semaphore = TRUE; + } + break; + + case WAIT_INIT: + { + switch(SignalCode) + // switch on input message. + //------------------------- + { + case TMODE_PDTCH_ASSIGN_REQ: + // Assignement message. + //--------------------- + { + static UWORD32 count =0; + + T_TRANSFER_SET *free_set; + UWORD8 assignment_command; + UWORD8 timeslot_alloc; + UWORD8 timeslot; + UWORD32 i; + + count++ ; + + #if (CODE_VERSION == SIMULATION) + l1tm_reset_rx_state(); + #endif + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + // Rise transfert parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + assignment_command = BOTH_TBF; + + // Get Ptr to the free dedicated parameter set. + // All important fields are initialised. + free_set = l1pa_get_free_transfer_set(assignment_command); + + // Download message containt. + free_set->assignment_id = 1; + free_set->assignment_command = assignment_command; + #if (CODE_VERSION == SIMULATION) + free_set->multislot_class = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->multislot_class; + #else + free_set->multislot_class = l1_config.tmode.rf_params.multislot_class; + #endif + free_set->dl_pwr_ctl.p0 = 255; // no power control + free_set->packet_ta.ta = 0; + free_set->packet_ta.ta_index = 255; + free_set->packet_ta.ta_tn = 255; + free_set->tsc = l1_config.tmode.tx_params.tsc; + free_set->freq_param.chan_sel.h = FALSE; // no hopping + free_set->freq_param.chan_sel.rf_channel.single_rf.radio_freq = l1_config.tmode.rf_params.pdtch_arfcn; + free_set->mac_mode = FIX_ALLOC_NO_HALF; // fixed allocation + free_set->tbf_sti.present = TRUE; // STI present + // FreeCalypso TCS211 reconstruction: LoCosto change backed out + #if 0 //(CODE_VERSION == NOT_SIMULATION) + // In order to reduce the latency for the ETM command "rfe 4", make absolute_fn as + // next_time.fn+1. This was originally +100 because of which we had to wait for some + // time before L1 actually starts the TBF. + free_set->tbf_sti.absolute_fn= l1s.next_time.fn + 1; + #else + // In PC simulation, keep the old +100 to keep output logs same as reference + free_set->tbf_sti.absolute_fn= l1s.next_time.fn + 100; // force to current FN+100 + #endif + + free_set->interf_meas_enable = FALSE; // Interference measurements disabled + free_set->pc_meas_chan = TRUE; // No measurement on the beacon (6 per MF52) + + // Allocation of both UL and DL time slots + free_set->dl_tbf_alloc.tfi = 1; // DL TFI ID + free_set->ul_tbf_alloc->tfi = 2; // UL TFI ID + #if (CODE_VERSION == SIMULATION) + free_set->dl_tbf_alloc.timeslot_alloc = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->dl_ts_alloc; + free_set->ul_tbf_alloc->timeslot_alloc = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->ul_ts_alloc; + l1_config.tmode.stats_config.num_loops = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->ul_alloc_length; + l1_config.tmode.rf_params.mon_tasks = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->mon_enable; + l1_config.tmode.rf_params.mon_report = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->mon_enable; + l1_config.tmode.rx_params.pm_enable = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->pm_enable; + #else + free_set->dl_tbf_alloc.timeslot_alloc = l1_config.tmode.rx_params.timeslot_alloc; + free_set->ul_tbf_alloc->timeslot_alloc = l1_config.tmode.tx_params.timeslot_alloc; + #endif + // free_set->ul_tbf_alloc->fixed_alloc.bitmap_length = l1_config.tmode.stats_config.num_loops; + // force to 127 + free_set->ul_tbf_alloc->fixed_alloc.bitmap_length = 127; + + // Init fixed allocation bitmap + for (i=0;i<free_set->ul_tbf_alloc->fixed_alloc.bitmap_length;i++) + free_set->ul_tbf_alloc->fixed_alloc.bitmap[i] = free_set->ul_tbf_alloc->timeslot_alloc; + + free_set->allocated_tbf = BOTH_TBF; + + // Process the downlink TBF first allocated timeslot + timeslot_alloc = free_set->dl_tbf_alloc.timeslot_alloc; + timeslot = 0; + + while((timeslot<7) && !(timeslot_alloc & (0x80>>timeslot))) + { + timeslot++; + } + + free_set->dl_tbf_synchro_timeslot = timeslot; + + // Fill "synchro_timeslot" which will be the frame synchro slot. + free_set->transfer_synchro_timeslot = timeslot; + + // save stats bitmap + stat_gprs_slots = l1_config.tmode.stats_config.stat_gprs_slots; + // Adjust stats bit map + l1_config.tmode.stats_config.stat_gprs_slots <<= timeslot; + + // Process the uplink TBF first allocated timeslot + // Fixed mode: the 1st allocated timeslot is the downlink control + // timeslot allocated by the network, which is a timeslot allocated + // in uplink + timeslot_alloc = free_set->ul_tbf_alloc->timeslot_alloc; + + timeslot = 0; + while((timeslot<7) && !(timeslot_alloc & (0x80>>timeslot))) + { + timeslot++; + } + // if UL synchro TS > DL synchro TS, then fixed alloc ctrl TS is the UL sync TS + // else fixed alloc ctrl TS is the DL sync TS + if (timeslot > free_set->dl_tbf_synchro_timeslot) + free_set->ul_tbf_alloc->fixed_alloc.ctrl_timeslot = timeslot; + else + free_set->ul_tbf_alloc->fixed_alloc.ctrl_timeslot = free_set->dl_tbf_synchro_timeslot; + + free_set->ul_tbf_synchro_timeslot = free_set->ul_tbf_alloc->fixed_alloc.ctrl_timeslot; + + // Init txpwr levels for multi slot TX + // txpwr[index] is calculated according to TX allocation given by MACS + // timeslot contains the first allocated TS in UL + for(i = timeslot; i < 8; i++) + { + l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr[i] + = l1_config.tmode.tx_params.txpwr_gprs[i]; + } + + // Step in state machine. + *state = WAIT_MSG; + + // Store signalcode. + free_set->SignalCode = MPHP_ASSIGNMENT_REQ; + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + + // end of process. + end_process = 1; + } + break; + + default: + // End of process. + //---------------- + { + return; + } + } // end switch(SignalCode) + } // end case WAIT_INIT + case WAIT_MSG: + { + switch(SignalCode) + // switch on input message. + //------------------------- + { + case L1P_TRANSFER_DONE: + // Switch to TRANSFER mode has been done. + { + T_CRES_LIST_PARAM *free_list; + + // Set up TCR_MEAS task, if MON tasks are enabled set up FB26 + if (l1_config.tmode.rf_params.mon_tasks == 1) + { + // Set FB26 task semaphore + l1a_l1s_com.task_param[FB26] = SEMAPHORE_SET; + + // This process always use the first element of "nsync" structure. + l1a_l1s_com.nsync.current_list_size = 0; + // l1a_l1s_com.nsync.list[0].radio_freq was set to mon_arfcn above + l1a_l1s_com.nsync.list[0].radio_freq = l1_config.tmode.rf_params.mon_arfcn; + + // Enable FB detection during packet transfer + l1a_l1s_com.l1s_en_task[FB26] = TASK_ENABLED; +#if (L1_12NEIGH ==1) + //Set timing validity for FB no a priori info + l1a_l1s_com.nsync.list[0].timing_validity = 0; + // Enable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_PENDING; //Used by l1s_schedule_tasks in l1_sync + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_ENABLED; +#endif + } + + if (l1_config.tmode.rx_params.pm_enable) + { + // Set parameter synchro semaphore for P_TCRMS_MEAS task. + l1pa_l1ps_com.meas_param |= P_TCRMS_MEAS; + + // Reset Neighbour Cell measurement parameters. + l1pa_l1ps_com.tcr_freq_list.tcr_next_to_ctrl = 0; + l1pa_l1ps_com.tcr_freq_list.tcr_next_to_read = 0; + + // Get Ptr to the free Neighbour meas list. + // The number of carriers in the list and the list + // identification are initialized. + free_list = l1pa_get_free_cres_list_set(); + + // Download new list within T_CRES_LIST_PARAM structure. + free_list->nb_carrier = 1; + free_list->freq_list[0] = l1_config.tmode.rf_params.mon_arfcn; + + free_list->list_id = 0; + + // Set "flist" with Circuit Swithed BA frequency list parameters + l1pa_l1ps_com.cres_freq_list.alist = free_list; + + // Reset flags. + l1pa_l1ps_com.tcr_freq_list.ms_ctrl = 0; + l1pa_l1ps_com.tcr_freq_list.ms_ctrl_d = 0; + l1pa_l1ps_com.tcr_freq_list.ms_ctrl_dd = 0; + + // Reset measures made on beacon frequency. + l1pa_l1ps_com.tcr_freq_list.beacon_meas = 0; + + // Enable Packet Transfer Neighbour Measurement task. + l1pa.l1pa_en_meas[TCR_MEAS] |= P_TCRMS_MEAS; + } + + // Flag packet transfer mode active + l1tm.tmode_state.packet_transfer_active = TRUE; + + // End of process. + end_process = 1; + } + break; + + case TMODE_PDTCH_INFO: + // TCH result messages. + //----------------------- + { + // Check if RX stats done in PDTCH + if (l1_config.tmode.rf_params.mon_report == 0) + { + BOOL done; + + // loop and stats management done within this function + l1tm_stats_pdtch_confirm((T_TMODE_PDTCH_INFO *) (msg->SigP)); + + done = l1tm_is_rx_counter_done(); + + if (done == 1) + // if done, send stop TBFs + { + // Rise transfer parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + // Enables the TBF release processing in L1S. + l1pa_l1ps_com.transfer.tbf_release_param.tbf_release_cmd = TRUE; + + // Download msg info into L1PA_L1PS_COM. + l1pa_l1ps_com.transfer.tbf_release_param.released_tbf = BOTH_TBF; + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + } + } + + // end of process + end_process = 1; + } + break; + + case L1C_FB_INFO: + // MON result messages. + //----------------------- + { + // Check if RX stats done in Monitor channel + if (l1_config.tmode.rf_params.mon_report == 1) + { + BOOL done; + + // loop and stats management done within this function + l1tm_stats_mon_confirm( (T_TMODE_FB_CON*) ((T_L1C_FB_INFO *) (msg->SigP))); + + done = l1tm_is_rx_counter_done(); + + if (done == 1) + // if done, send stop TBFs + { + // Rise transfer parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + // Enables the TBF release processing in L1S. + l1pa_l1ps_com.transfer.tbf_release_param.tbf_release_cmd = TRUE; + + // Download msg info into L1PA_L1PS_COM. + l1pa_l1ps_com.transfer.tbf_release_param.released_tbf = BOTH_TBF; + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + } + } + + // end of process + end_process = 1; + } + break; + + case TMODE_STOP_RX_TX: + // TBF Release. + //------------- + { + // Rise transfer parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + // Enables the TBF release processing in L1S. + l1pa_l1ps_com.transfer.tbf_release_param.tbf_release_cmd = TRUE; + + // Download msg info into L1PA_L1PS_COM. + l1pa_l1ps_com.transfer.tbf_release_param.released_tbf = BOTH_TBF; + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + + // end of process. + end_process = 1; + } + break; + + case L1P_TBF_RELEASED: + // TBF has been release by L1S. + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Reset transfer active state + l1tm.tmode_state.packet_transfer_active = FALSE; + + // Restore stats bitmap + l1_config.tmode.stats_config.stat_gprs_slots = stat_gprs_slots; + +#if (L1_12NEIGH ==1) + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; //Used by l1s_schedule_tasks in l1_sync +#endif + + // Step in state machine. + *state = RESET; + + // End of process. + end_process = 1; + } + break; + + default: + // End of process. + //---------------- + { + end_process = 1; + } + } // end of switch(SignalCode) + } // end of case WAIT_MSG. + } // end of "switch". + } // end of "while" + } // end of procedure. + #endif + + #if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) + /*----------------------------------------------------------------*/ + /* l1a_tmode_audio_stereopath_process() */ + /*----------------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* stereopath feature. */ + /* */ + /* Starting messages: TMODE_AUDIO_STEREOPATH_DRV_START_REQ */ + /* */ + /* Result messages (input): L1_STEREOPATH_DRV_START_CON */ + /* */ + /* Result messages (output): TMODE_AUDIO_STEREOPATH_DRV_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): TMODE_AUDIO_STEREOPATH_DRV_STOP_REQ */ + /* L1_STEREOPATH_DRV_STOP_CON */ + /* */ + /* Stop message (output): TMODE_AUDIO_STEREOPATH_DRV_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*----------------------------------------------------------------*/ + void l1a_tmode_audio_stereopath_process(xSignalHeaderRec *msg) + { +#if (CODE_VERSION == NOT_SIMULATION) + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3, + WAIT_DSP_STOP = 4 + + }; + + UWORD8 *state = &l1a.state[TMODE_AUDIO_STEREOPATH_DRV_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + static UWORD8 previous_config = 0; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // initialize global variable + l1tm.stereopath.stereopath_source_timeout = 0; + l1tm.stereopath.stereopath_dest_timeout = 0; + l1tm.stereopath.stereopath_drop = 0; + l1tm.stereopath.stereopath_frame = 0; + l1tm.stereopath.stereopath_block = 0; + l1tm.stereopath.stereopath_half_block = 0; + l1tm.stereopath.stereopath_current_sample = 0; + l1tm.stereopath.stereopath_buffer_number = 0; + + // initialize ndb + stp_drv_ndb->d_cport_api_dma_install = 0; + stp_drv_ndb->d_cport_api_dma_channel = 0; + stp_drv_ndb->d_cport_api_dma_rootcause = 0; + + // Init DSP background + l1s_dsp_com.dsp_ndb_ptr->a_background_tasks[C_BGD_STP_DRV] = (API)((C_BGD_STP_DRV<<11) | 1); + if (l1s_dsp_com.dsp_ndb_ptr->d_max_background<(C_BGD_STP_DRV+1)) + l1s_dsp_com.dsp_ndb_ptr->d_max_background=(API)(C_BGD_STP_DRV+1); + + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == TMODE_AUDIO_STEREOPATH_START_REQ) + { + // receive a request to start stereopath + T_TMODE_AUDIO_STEREOPATH_START_REQ* tmode_audio_sp_conf_ptr; + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + /******************************************************************/ + /**************** GET STEREOPATH PARAMETERS ***********************/ + /******************************************************************/ + + if (((T_TMODE_AUDIO_STEREOPATH_START_REQ *)(msg->SigP))->configuration == AUDIO_SP_SELF_CONF) + { + // no use of a predefined configuration, we have to get parameters from the message + tmode_audio_sp_conf_ptr = ((T_TMODE_AUDIO_STEREOPATH_START_REQ *)(msg->SigP)); + } + else + { + UWORD8 conf_index = 0; + + // use of a predefined configuration, we have to get parameters from the constant config + tmode_audio_sp_conf_ptr = (T_TMODE_AUDIO_STEREOPATH_START_REQ *) tmode_audio_sp_conf[conf_index]; + + while ((tmode_audio_sp_conf_ptr != NULL) && (conf_index < NB_MAX_STEREOPATH_CONFIG)) + { + if (tmode_audio_sp_conf_ptr->configuration == ((T_TMODE_AUDIO_STEREOPATH_START_REQ *)(msg->SigP))->configuration) + break; + + tmode_audio_sp_conf_ptr = (T_TMODE_AUDIO_STEREOPATH_START_REQ *) tmode_audio_sp_conf[++conf_index]; + } + } + + if (tmode_audio_sp_conf_ptr == NULL) + { + // unknow configuration identifier --> use message parameters + tmode_audio_sp_conf_ptr = ((T_TMODE_AUDIO_STEREOPATH_START_REQ *)(msg->SigP)); + } + + // Download the stereopath description in the l1a_l1s structure. + l1a_l1s_com.stereopath_drv_task.parameters.sampling_frequency = tmode_audio_sp_conf_ptr->sampling_frequency; + l1a_l1s_com.stereopath_drv_task.parameters.DMA_allocation = tmode_audio_sp_conf_ptr->DMA_allocation; + l1a_l1s_com.stereopath_drv_task.parameters.DMA_channel_number = tmode_audio_sp_conf_ptr->DMA_channel_number; + l1a_l1s_com.stereopath_drv_task.parameters.data_type = tmode_audio_sp_conf_ptr->data_type; + l1a_l1s_com.stereopath_drv_task.parameters.source_port = tmode_audio_sp_conf_ptr->source_port; + l1a_l1s_com.stereopath_drv_task.parameters.element_number = tmode_audio_sp_conf_ptr->element_number; + l1a_l1s_com.stereopath_drv_task.parameters.frame_number = tmode_audio_sp_conf_ptr->frame_number; + l1a_l1s_com.stereopath_drv_task.parameters.mono_stereo = tmode_audio_sp_conf_ptr->mono_stereo; + l1a_l1s_com.stereopath_drv_task.parameters.feature_identifier = AUDIO_SP_TESTS_ID; + + /******************************************************************/ + /**************** CHECK ALLOCATION DSP/MCU ************************/ + /******************************************************************/ + + if (tmode_audio_sp_conf_ptr->DMA_allocation == AUDIO_SP_DMA_ALLOC_MCU) + { + l1a_l1s_com.stereopath_drv_task.parameters.DMA_int_callback_fct = l1tm_stereopath_DMA_handler; + } + else // DMA_allocation == AUDIO_SP_DMA_ALLOC_DSP + { + // Update ndb + stp_drv_ndb->d_cport_api_dma_install = 1; + stp_drv_ndb->d_cport_api_dma_channel = l1a_l1s_com.stereopath_drv_task.parameters.DMA_channel_number; + stp_drv_ndb->d_cport_api_dma_rootcause = 0; + + // start background task + l1s_dsp_com.dsp_ndb_ptr->d_background_enable|=(API)(1<<C_BGD_STP_DRV); + l1_trigger_api_interrupt(); + + l1a_l1s_com.stereopath_drv_task.parameters.DMA_int_callback_fct = f_dma_default_call_back_it; + } + + /******************************************************************/ + /**************** GENERATION OF THE PATTERN ***********************/ + /******************************************************************/ + + // Reservation and generation of the pattern used to fill the buffer + if (tmode_audio_sp_conf_ptr->pattern_identifier != AUDIO_SP_SILENCE_PATTERN) + { + l1tm.stereopath.stereopath_pattern = (WORD8 *)l1tm_stereopath_buffer; + + // if pattern has already been build with the same config (mp3,midi or ext audio) in the current scenario, + // we don't do it again. This is to avoid to have a CPU overload during critical operation such as access or packet transfer + if ((tmode_audio_sp_conf_ptr->configuration == 0) || (tmode_audio_sp_conf_ptr->configuration != previous_config)) + { + previous_config = tmode_audio_sp_conf_ptr->configuration; + l1tm.stereopath.stereopath_nb_samples = l1tm_stereopath_get_pattern(l1tm_stereopath_sampling_freqs[tmode_audio_sp_conf_ptr->sampling_frequency], + l1tm_stereopath_sin_freqs[tmode_audio_sp_conf_ptr->pattern_identifier][0], + l1tm_stereopath_sin_freqs[tmode_audio_sp_conf_ptr->pattern_identifier][1], + tmode_audio_sp_conf_ptr->data_type); + } + } + else + { + // Silence pattern, consider just 2 samples at the value 0 + l1tm.stereopath.stereopath_nb_samples = 2; + + l1tm.stereopath.stereopath_pattern = (WORD8 *)l1tm_stereopath_buffer; + l1tm.stereopath.stereopath_pattern[0] = l1tm.stereopath.stereopath_pattern[1] = + l1tm.stereopath.stereopath_pattern[2] = l1tm.stereopath.stereopath_pattern[3] = 0x0000; + } + + /******************************************************************/ + /**************** GET ADDRESS OF THE BUFFER ***********************/ + /******************************************************************/ +#if (CHIPSET == 15) + if (tmode_audio_sp_conf_ptr->source_port == AUDIO_SP_SOURCE_EMIF) + { + // get an address in internal RAM + l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = (WORD8*) TM_stereo_buf_ext_mem; + } + + + if (tmode_audio_sp_conf_ptr->source_port == AUDIO_SP_SOURCE_IMIF) + { + // get an address in internal RAM + l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = (WORD8*) TM_stereo_buf; + } + + if (tmode_audio_sp_conf_ptr->source_port == AUDIO_SP_SOURCE_API) + { + // Disable DSP trace + l1s_dsp_com.dsp_ndb_ptr->d_debug_trace_type &= 0xfff0; + l1s_dsp_com.dsp_ndb_ptr->d_debug_trace_type |= 0x8000; + + l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = (WORD8*)API_address_dsp2mcu(C_STP_DRV_BUF_API_BASE_ADDRESS); + } +#else + if (tmode_audio_sp_conf_ptr->source_port == AUDIO_SP_SOURCE_IMIF) + { + // get an address in internal RAM + l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = (WORD8*) TM_stereo_buf; + } + else // source_port == AUDIO_SP_SOURCE_API + { + // Disable DSP trace + l1s_dsp_com.dsp_ndb_ptr->d_debug_trace_type &= 0xfff0; + l1s_dsp_com.dsp_ndb_ptr->d_debug_trace_type |= 0x8000; + + l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = (WORD8*)API_address_dsp2mcu(C_STP_DRV_BUF_API_BASE_ADDRESS); + } +#endif + + /******************************************************************/ + /**************** FILL THE 2 FIRST BUFFERS ************************/ + /******************************************************************/ + + l1tm_stereopath_fill_buffer((void*) l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address); + l1tm_stereopath_fill_buffer((void*) l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address); + + // Start the L1S stereopath task + l1a_l1s_com.stereopath_drv_task.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + end_process = 1; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_STEREOPATH_DRV_START_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(TMODE_AUDIO_STEREOPATH_START_CON); + + *state = WAIT_STOP; + } + + // End process + end_process = 1; + } + break; + + case WAIT_STOP: + { + if (SignalCode == TMODE_AUDIO_STEREOPATH_STOP_REQ) + { + if (l1a_l1s_com.stereopath_drv_task.parameters.DMA_allocation == AUDIO_SP_DMA_ALLOC_DSP) + { + // we first need to stop the DSP background task + stp_drv_ndb->d_cport_api_dma_install = 0xFFFF; + l1_trigger_api_interrupt(); + + *state = WAIT_DSP_STOP; + } + else + { + // Stop the L1S stereopath task + l1a_l1s_com.stereopath_drv_task.command.stop = TRUE; + + // End process + end_process = 1; + } + } + else + if (SignalCode == L1_STEREOPATH_DRV_STOP_CON) + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + free(l1tm.stereopath.stereopath_pattern); + + // Send the stop confirmation message + l1a_audio_send_confirmation(TMODE_AUDIO_STEREOPATH_STOP_CON); + + *state = RESET; + } + else + { + // End process + end_process = 1; + } + } + break; + + case WAIT_DSP_STOP: + { + if (stp_drv_ndb->d_cport_api_dma_install == 0) + { + // stop the DSP background task + l1s_dsp_com.dsp_ndb_ptr->d_background_enable&=(API)(~(1<<C_BGD_STP_DRV)); + l1_trigger_api_interrupt(); + + // Stop the L1S stereopath task + l1a_l1s_com.stereopath_drv_task.command.stop = TRUE; + + *state = WAIT_STOP; + + end_process = 1; + } + } + break; + } // switch + } // while(!end_process) +#endif // CODE_VERSION == NOT_SIMULATION + } + #endif // #if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) +#endif