FreeCalypso > hg > fc-magnetite
view src/cs/layer1/tm_cfile/l1tm_async.c @ 534:6c96725718c3
armio.c: C11x GPIO setup properly separated from C139
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Mon, 05 Nov 2018 17:10:06 +0000 |
| parents | b870b6a44d31 |
| children |
line wrap: on
line source
/************* 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