view chipsetsw/layer1/tm_cfile/l1tm_async.c @ 227:19f9395bb274

l1tm_func.c: l1tm_mode_set() reconstructed
author Mychaela Falconia <falcon@freecalypso.org>
date Sun, 15 Jan 2017 01:07:58 +0000
parents a4899cf67fd1
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