FreeCalypso > hg > fc-magnetite
changeset 234:b870b6a44d31
l1audio and l1tm reconstructed source imported from tcs211-l1-reconst
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Mon, 20 Mar 2017 00:51:20 +0000 (2017-03-20) |
| parents | 17d79c62e638 |
| children | 53b797cd3c12 |
| files | src/cs/layer1/audio_cfile/l1audio_abb.c src/cs/layer1/audio_cfile/l1audio_afunc.c src/cs/layer1/audio_cfile/l1audio_async.c src/cs/layer1/audio_cfile/l1audio_back.c src/cs/layer1/audio_cfile/l1audio_drive.c src/cs/layer1/audio_cfile/l1audio_func.c src/cs/layer1/audio_cfile/l1audio_init.c src/cs/layer1/audio_cfile/l1audio_sync.c src/cs/layer1/audio_cust0/l1audio_cust.c src/cs/layer1/audio_include/l1audio_proto.h src/cs/layer1/tm_cfile/l1tm_async.c src/cs/layer1/tm_cfile/l1tm_func.c src/cs/layer1/tm_cfile/l1tm_stats.c src/cs/layer1/tm_cust0/l1tm_cust.c src/cs/layer1/tm_cust0/l1tm_tpu12.c |
| diffstat | 15 files changed, 33223 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/audio_cfile/l1audio_abb.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,1014 @@ +/* + * l1audio_abb.c + * + * Control audio + * + * Filename l1audio_abb.c + * Copyright 2003 (C) Texas Instruments + * + * Reference : S820, GACS001 (OMEGA) spec + * + */ + +#include "l1_macro.h" +#include "l1_confg.h" + + +#if (CODE_VERSION == NOT_SIMULATION) + +#if (defined _WINDOWS && (OP_RIV_AUDIO == 1)) + #include "rv_general.h" +#endif + +#if (CODE_VERSION == SIMULATION) + #include <string.h> + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + #include "l1_time.h" + #if TESTMODE + #include "l1tm_defty.h" + #endif + #if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #endif + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + #include "l1_defty.h" + #include "l1_varex.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include <stdio.h> + #include "sim_cfg.h" + #include "sim_cons.h" + #include "sim_def.h" + #include "sim_var.h" + +#else + #include <string.h> + #if (defined _WINDOWS && (OP_RIV_AUDIO == 1)) + #define BOOL_FLAG + #endif +// Triton Audio ON/OFF Changes + + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + #include "l1_time.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + #if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #endif + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #if (RF_FAM == 61) + #include "l1_rf61.h" + #endif + + #include "l1_defty.h" + #include "l1_varex.h" + #include "l1_msgty.h" + #if (OP_RIV_AUDIO == 0) + #include "cust_os.h" + #include "tpudrv.h" + #endif +#endif + +#include "abb.h" + +#include "l1audio_abb.h" + +#if (ANLG_FAM == 11) + #include "types.h" + #include "bspTwl3029_I2c.h" + #include "bspTwl3029_Aud_Map.h" + #include "bspTwl3029_Audio.h" +#endif + +#if (CODE_VERSION == NOT_SIMULATION)&&(L1_AUDIO_MCU_ONOFF == 1)&&(CHIPSET == 15) + void l1_audio_on_off_callback_fn(Uint8 callback_val); +#endif +#include "l1audio_abb.h" + +#if ((CODE_VERSION == NOT_SIMULATION)&&(L1_AUDIO_MCU_ONOFF == 1)&&(OP_L1_STANDALONE == 1)&&(CHIPSET == 12)) + #include "nucleus.h" +#endif + +#if (ANLG_FAM != 11) +extern T_L1S_DSP_COM l1s_dsp_com; +extern void l1_audio_lim_partial_update(); + + +#define MAX_PGA_UL 24 +#define MAX_PGA_DL 12 +#define MAX_VOL_DL 249 + +static UWORD8 ABB_CurrentVolume = 0; + +// Uplink PGA gain is coded on 5 bits, corresponding to -12 dB to +12 dB in 1dB steps +const UWORD8 ABB_uplink_PGA_gain[] = +{ + 0x10, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, + 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x11, 0x12, 0x13, 0x14, 0x15, + 0x16 +}; + +// Downlink volume: mute, -24dB to 0dB in 6dB steps +const UWORD8 ABB_volume_control_gain[] = +{ + 0x05, 0x03, 0x04, 0x00, 0x06, 0x02 +}; + +/* + * FreeCalypso: ABB_Read_DLGain() functions and the ABB_DL_volume_read_gain + * and ABB_DL_PGA_read_gain constant tables it uses are new in the LoCosto + * version of this module (even though the code seems to support classic + * ABBs, not LoCosto/Triton) and do not appear in our TCS211 binary object. + */ + +#define INCLUDE_ABB_READ_DLGAIN 0 + +#if INCLUDE_ABB_READ_DLGAIN +// Downlink volume gain read in unsigned Q15 (in VBDCTRL) +const WORD16 ABB_DL_volume_read_gain[] = +{ + 0x2000 , // 0: -12 dB + 0 , // 1: Mute + 0x8000 , // 2: 0 dB + 0x0800 , // 3: -24 dB + 0x1000 , // 4: -18 dB + 0 , // 5: Mute + 0x4000 , // 6: -6 dB + 0 , // 7: Mute +}; + +// Downlink PGA gain read in unsigned Q15 (in VBDCTRL) +const WORD16 ABB_DL_PGA_read_gain[] = +{ + 0x4026 , // 0: - 6 dB + 0x47FA , // 1: - 5 dB + 0x50C3 , // 2: - 4 dB + 0x5A9D , // 3: - 3 dB + 0x65AC , // 4: - 2 dB + 0x7214 , // 5: - 1 dB + 0x8000 , // 6: 0 dB + 0x8F9E , // 7: 1 dB + 0xA124 , // 8: 2 dB + 0xB4CE , // 9: 3 dB + 0xCADD , // 10: 4 dB + 0xE39E , // 11: 5 dB + 0xFF64 , // 12: 6 dB + 0x4026 , // 13: - 6 dB + 0x4026 , // 14: - 6 dB + 0x4026 , // 15: - 6 dB +}; +#endif /* INCLUDE_ABB_READ_DLGAIN */ + +// Downlink PGA gain is coded on 4 bits, corresponding to -6dB to 6dB in 1dB steps +const UWORD8 ABB_downlink_PGA_gain[] = +{ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, + 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C +}; + +// Side tone level: mute, -23dB to +4dB in 3dB steps +const UWORD8 ABB_sidetone_gain[] = +{ + 0x08, 0x0D, 0x0C, 0x06, 0x02, 0x07, + 0x03, 0x00, 0x04, 0x01, 0x05 +}; + +/* + * ABB_Audio_Config + * + * Configuration of VBCTRL1 register + * + */ +void ABB_Audio_Config (UWORD16 data) +{ +#if (ANLG_FAM == 1) + l1s_dsp_com.dsp_ndb_ptr->d_vbctrl = ABB_L1_WRITE (VBCTRL, data); +#elif ((ANLG_FAM == 2) || (ANLG_FAM == 3) ) + l1s_dsp_com.dsp_ndb_ptr->d_vbctrl1 = ABB_L1_WRITE (VBCTRL1, data); +#endif +} + + +/* + * ABB_Audio_Config_2 + * + * Configuration of VBCTRL2 register + * + */ +void ABB_Audio_Config_2 (UWORD16 data) +{ +#if ((ANLG_FAM == 2) || (ANLG_FAM == 3)) + l1s_dsp_com.dsp_ndb_ptr->d_vbctrl2 = ABB_L1_WRITE (VBCTRL2, data); +#endif +} + + +/* + * ABB_Audio_Control + * + * Configuration of VAUDCTRL register + * + */ +void ABB_Audio_Control (UWORD16 data) +{ +#if (ANLG_FAM == 3) + l1s_dsp_com.dsp_ndb_ptr->d_vaud_cfg = ABB_L1_WRITE (VAUDCTRL, data); +#endif +} + + +/* + * ABB_Audio_On_Off + * + * Configuration of VAUOCTRL register + * + */ +void ABB_Audio_On_Off (UWORD16 data) +{ +#if (ANLG_FAM == 3) + l1s_dsp_com.dsp_ndb_ptr->d_vauo_onoff = ABB_L1_WRITE (VAUOCTRL, data); +#endif +} + + +/* + * ABB_Audio_Volume + * + * Configuration of VAUSCTRL register + * + */ +void ABB_Audio_Volume (UWORD16 data) +{ +#if (ANLG_FAM == 3) + l1s_dsp_com.dsp_ndb_ptr->d_vaus_vol = ABB_L1_WRITE (VAUSCTRL, data); +#endif +} + + +/* + * ABB_Audio_PLL + * + * Configuration of VAUDPLL register + * + */ +void ABB_Audio_PLL (UWORD16 data) +{ +#if (ANLG_FAM == 3) + l1s_dsp_com.dsp_ndb_ptr->d_vaud_pll = ABB_L1_WRITE (VAUDPLL, data); +#endif +} + + +/* + * ABB_Audio_VBPop + * + * Configuration of VBPOP register + * + */ +void ABB_Audio_VBPop (UWORD16 data) +{ +#if (ANLG_FAM == 3) + l1s_dsp_com.dsp_ndb_ptr->d_vbpop = ABB_L1_WRITE (VBPOP, data); +#endif +} + + +/* + * ABB_Audio_Delay_Init + * + * Configuration of the delay initialization for POP noise reduction + * + */ +void ABB_Audio_Delay_Init (UWORD8 delay) +{ +#if (ANLG_FAM == 3) + l1s_dsp_com.dsp_ndb_ptr->d_vau_delay_init = delay; +#endif +} + + +/* + * ABB_CAL_UlVolume + * + * Uplink audio volume calibration + * + * Parameter : pga index - range 0..24 + * + * When this function is called the Mute bit of VBUCTRL is set to zero + */ +void ABB_CAL_UlVolume (UWORD8 pga_index) +{ + UWORD16 index; + API reg_state; + + index = pga_index; + if (index > MAX_PGA_UL) + index = MAX_PGA_UL; //clip + + //mask side tone gain and the mute settings + reg_state = l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl &= 0xF800; + + l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl = reg_state | + ABB_L1_WRITE ( VBUCTRL, + ABB_uplink_PGA_gain[index]); +} + +/* + * ABB_CAL_DlVolume + * + * Downlink audio volume calibration + * + * Parameter : volume - range 0 to 255, pga - range 0-12 + * + */ + +void ABB_CAL_DlVolume (UWORD8 volume_index, UWORD8 pga_index) +{ + UWORD16 volume, pga; + // Remember current volume for subsequent mute commands + ABB_CurrentVolume = volume_index; + + // Normalize volume (0 to 5) + if (volume_index > MAX_VOL_DL) volume_index=MAX_VOL_DL; //clip + + if (volume_index) + volume = (volume_index / 50) + 1; + else + volume = volume_index; + + if (pga_index > MAX_PGA_DL) pga_index=MAX_PGA_DL; //clip + pga = pga_index; + + + l1s_dsp_com.dsp_ndb_ptr->d_vbdctrl = + ABB_L1_WRITE ( VBDCTRL, + (ABB_volume_control_gain[volume] << 4) | + (ABB_downlink_PGA_gain[pga]) ); + + #if (L1_LIMITER == 1) + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_LIM_ENABLE) + l1_audio_lim_partial_update(); + #endif +} + +/* + * ABB_DlVolume + * + * Control Downlink audio volume + * + * Parameter : volume - range 0 to 255 + * + */ + +void ABB_DlVolume (UWORD8 volume_index) +{ + UWORD16 volume; + API reg_state; + + // Remember current volume for subsequent mute commands + ABB_CurrentVolume = volume_index; + + // Normalize volume (0 to 5) + if (volume_index > MAX_VOL_DL) volume_index=MAX_VOL_DL; //clip + + if (volume_index) + volume = (volume_index / 50) + 1; + else + volume = volume_index; + + //mask PGA setting determined during calibration phase + reg_state = l1s_dsp_com.dsp_ndb_ptr->d_vbdctrl &= 0x03c0; + + l1s_dsp_com.dsp_ndb_ptr->d_vbdctrl = reg_state | + ABB_L1_WRITE ( VBDCTRL, + (ABB_volume_control_gain[volume] << 4)); + + #if (L1_LIMITER == 1) + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_LIM_ENABLE) + l1_audio_lim_partial_update(); + #endif +} + +/* + * ABB_DlMute + * + * Mute downlink audio + * + * Parameter : Mute - On or Off + * + */ + +void ABB_DlMute (BOOL mute) +{ + UWORD8 current_volume; + + if (mute) + { + /* + * The current downlink volume must be memorized to avoid + * having 0 as the new current volume. + */ + + current_volume = ABB_CurrentVolume; + ABB_DlVolume (0); + ABB_CurrentVolume = current_volume; + } + else + { + ABB_DlVolume (ABB_CurrentVolume); + } +} + +/* + * ABB_UlMute + * + * Mute uplink audio + * + * Parameter : Mute - On or Off + * + */ + +void ABB_UlMute (BOOL mute) +{ + if (mute) + { + l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl |= + ABB_L1_WRITE ( VBUCTRL, + DXEN); + } + else + { + l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl &= 0x7fff; + l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl |= 0x01; + } + + } + +/* + * ABB_SideTone + * + * Control audio sidetone + * + * Parameter : volume - range 0 to 255 + * nominal is 175 (-5dB) + * + */ + +void ABB_SideTone (UWORD8 volume_index) +{ + UWORD16 side_tone; + API reg_state; + + // Normalize sidetone (0 to 10) + side_tone = volume_index / 25; + + // mask uplink PGA gain and mute settings + reg_state = l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl &= 0x87c0; + + l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl = reg_state | + ABB_L1_WRITE (VBUCTRL, + (ABB_sidetone_gain[side_tone] << 5)); +} + +#if INCLUDE_ABB_READ_DLGAIN +/* + * ABB_Read_DLVolume + * + * Returns the last controlled ABB DL gain in unsigned Q15 format + * This value includes volume and PGA gain. + * + */ +UWORD16 ABB_Read_DLGain() +{ + + UWORD16 volume_index; + UWORD16 pga_index; + + // Read last programmed volume + volume_index = (API)((l1s_dsp_com.dsp_ndb_ptr->d_vbdctrl >> 10) & 0x7); + pga_index = (API)((l1s_dsp_com.dsp_ndb_ptr->d_vbdctrl >> 6) & 0xF); + + // Convert volume into gain (dB) + return((ABB_DL_volume_read_gain[volume_index] * ABB_DL_PGA_read_gain[pga_index]) >> 15); + } +#endif /* INCLUDE_ABB_READ_DLGAIN */ +#endif /* classic ABBs */ + +#if (ANLG_FAM == 11) + // Downlink volume gain read in unsigned Q15 (in VBDCTRL) + const WORD16 L1_audio_abb_DL_volume_read_gain[] = + { + (WORD16)0x2000 , // 0: -12 dB //omaps00090550 + (WORD16)0x0000 , // 1: Mute //omaps00090550 + (WORD16)0x8000 , // 2: 0 dB//omaps00090550 + (WORD16)0x0800 , // 3: -24 dB//omaps00090550 + (WORD16)0x1000 , // 4: -18 dB//omaps00090550 + (WORD16)0x0000 , // 5: Mute//omaps00090550 + (WORD16)0x4000 , // 6: -6 dB//omaps00090550 + (WORD16)0x0000 , // 7: Mute//omaps00090550 + }; + + // Downlink PGA gain read in unsigned Q15 (in VBDCTRL) + const WORD16 L1_audio_abb_DL_PGA_read_gain[] = + { + (WORD16)0x4026 , // 0: - 6 dB//omaps00090550 + (WORD16) 0x47FA , // 1: - 5 dB//omaps00090550 + (WORD16)0x50C3 , // 2: - 4 dB//omaps00090550 + (WORD16)0x5A9D , // 3: - 3 dB//omaps00090550 + (WORD16)0x65AC , // 4: - 2 dB//omaps00090550 + (WORD16)0x7214 , // 5: - 1 dB//omaps00090550 + (WORD16)0x8000 , // 6: 0 dB//omaps00090550 + (WORD16)0x8F9E , // 7: 1 dB//omaps00090550 + (WORD16)0xA124 , // 8: 2 dB//omaps00090550 + (WORD16)0xB4CE , // 9: 3 dB//omaps00090550 + (WORD16)0xCADD , // 10: 4 dB//omaps00090550 + (WORD16)0xE39E , // 11: 5 dB//omaps00090550 + (WORD16)0xFF64 , // 12: 6 dB//omaps00090550 + (WORD16)0x4026 , // 13: - 6 dB//omaps00090550 + (WORD16)0x4026 , // 14: - 6 dB//omaps00090550 + (WORD16)0x4026 , // 15: - 6 dB//omaps00090550 + }; + + UWORD16 l1_audio_abb_Read_DLGain() + { + + UWORD8 volume_index; + UWORD8 pga_index; + UWORD8 vdlgain; + + BspTwl3029_I2c_shadowRegRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_VDLGAIN_OFFSET, + &vdlgain); + + volume_index = ((vdlgain & 0x70) >> 4); // bits 4-6 + pga_index = (vdlgain & 0x0f) ; //bits 0-3 + + // Convert volume into gain (dB) + return((L1_audio_abb_DL_volume_read_gain[volume_index] * L1_audio_abb_DL_PGA_read_gain[pga_index]) >> 15); + } + + void ABB_Audio_On_Off (UWORD16 data) + { + + } +#endif // ANLG_FAM == 11 + +#endif // CODE_VERSION != SIMULATION + +// Triton Audio ON/OFF Changes +#if (CODE_VERSION == SIMULATION)&&(L1_AUDIO_MCU_ONOFF == 1) + +void l1_audio_abb_ul_on_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} +void l1_audio_abb_dl_on_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +void l1_audio_abb_ul_off_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +void l1_audio_abb_dl_off_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +void l1_audio_abb_ul_off_dl_off_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +void l1_audio_abb_ul_off_dl_on_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +void l1_audio_abb_ul_on_dl_off_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +void l1_audio_abb_ul_on_dl_on_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +#endif // SIMULATION && L1_AUDIO_MCU_ONOFF + +// Triton Audio ON/OFF Changes +#if ((CODE_VERSION == NOT_SIMULATION)&&(L1_AUDIO_MCU_ONOFF == 1)&&(OP_L1_STANDALONE == 1)&&(CHIPSET == 12)) + +void(*cb_array[3])(void); +SYS_UWORD16 vauoctrl_status; +extern NU_TIMER l1_audio_abb_ul_timer; +extern NU_TIMER l1_audio_abb_dl_timer; +extern NU_TIMER l1_audio_abb_ul_dl_timer; + +void l1_audio_abb_ul_on_req ( void(*callback_fn)(void) ) +{ + SYS_UWORD16 reg; + reg = ABB_Read_Register_on_page(PAGE1, VBUCTRL); + ABB_Write_Register_on_page(PAGE1, VBUCTRL, reg|0x0200); + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0002); + cb_array[0]=callback_fn; + NU_Control_Timer(&l1_audio_abb_ul_timer, NU_ENABLE_TIMER); +} +void l1_audio_abb_dl_on_req ( void(*callback_fn)(void) ) +{ + vauoctrl_status = ABB_Read_Register_on_page(PAGE1, VAUOCTRL); + ABB_Write_Register_on_page(PAGE1, VAUOCTRL, 0x0000); + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0008); + cb_array[1]=callback_fn; + NU_Control_Timer(&l1_audio_abb_dl_timer, NU_ENABLE_TIMER); +} + +void l1_audio_abb_ul_off_req ( void(*callback_fn)(void) ) +{ + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0001); + callback_fn(); +} + +void l1_audio_abb_dl_off_req ( void(*callback_fn)(void) ) +{ + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0004); + callback_fn(); +} + +void l1_audio_abb_ul_off_dl_off_req ( void(*callback_fn)(void) ) +{ + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0001|0x0004); + callback_fn(); +} + +void l1_audio_abb_ul_off_dl_on_req ( void(*callback_fn)(void) ) +{ + vauoctrl_status = ABB_Read_Register_on_page(PAGE1, VAUOCTRL); + ABB_Write_Register_on_page(PAGE1, VAUOCTRL, 0x0000); + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0008|0x0001); + cb_array[1]=callback_fn; + NU_Control_Timer(&l1_audio_abb_dl_timer, NU_ENABLE_TIMER); +} + +void l1_audio_abb_ul_on_dl_off_req ( void(*callback_fn)(void) ) +{ + SYS_UWORD16 reg; + reg = ABB_Read_Register_on_page(PAGE1, VBUCTRL); + ABB_Write_Register_on_page(PAGE1, VBUCTRL, reg|0x0200); + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0002|0x0004); + cb_array[0]=callback_fn; + NU_Control_Timer(&l1_audio_abb_ul_timer, NU_ENABLE_TIMER); +} + +void l1_audio_abb_ul_on_dl_on_req ( void(*callback_fn)(void) ) +{ + SYS_UWORD16 reg; + reg = ABB_Read_Register_on_page(PAGE1, VBUCTRL); + vauoctrl_status = ABB_Read_Register_on_page(PAGE1, VAUOCTRL); + ABB_Write_Register_on_page(PAGE1, VAUOCTRL, 0x0000); + ABB_Write_Register_on_page(PAGE1, VBUCTRL, reg|0x0200); + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0002|0x0008); + cb_array[2]=callback_fn; + NU_Control_Timer(&l1_audio_abb_ul_dl_timer, NU_ENABLE_TIMER); +} + + +void l1_audio_abb_onoff_timer_expiry(UNSIGNED index) +{ + L1_trace_string("ON OFF Timer Expiry\r\n"); + switch(index) + { + case 0: + { + SYS_UWORD16 reg; + reg = ABB_Read_Register_on_page(PAGE1, VBUCTRL); + ABB_Write_Register_on_page(PAGE1, VBUCTRL, reg&0x01FF); + cb_array[0](); + } + break; + case 1: + { + ABB_Write_Register_on_page(PAGE1, VAUOCTRL, vauoctrl_status); + cb_array[1](); + } + break; + case 2: + { + SYS_UWORD16 reg; + reg = ABB_Read_Register_on_page(PAGE1, VBUCTRL); + ABB_Write_Register_on_page(PAGE1, VBUCTRL, reg&0x01FF); + ABB_Write_Register_on_page(PAGE1, VAUOCTRL, vauoctrl_status); + cb_array[2](); + } + break; + default: + { + while(1); + } + break; + } +} +#endif // SIMULATION && L1_AUDIO_MCU_ONOFF + +// Triton Audio ON/OFF Changes +#if (CODE_VERSION == NOT_SIMULATION)&&(L1_AUDIO_MCU_ONOFF == 1)&&(CHIPSET == 15) + +void(*cb_array[3])(void); +UWORD8 cb_index = 0; + +void l1_audio_abb_ul_on_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_ON, + AUDIO_DOWNLINK_NONE, + ret, OUTEN_NONE); + +} +void l1_audio_abb_dl_on_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_NONE, + AUDIO_DOWNLINK_ON, + ret, OUTEN_NONE); + +} + +void l1_audio_abb_ul_off_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_OFF, + AUDIO_DOWNLINK_NONE, + ret, OUTEN_NONE); + +} + +void l1_audio_abb_dl_off_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + // Configure the outen reg to 0 only when STEREOPATH_DRV_STATE is in IDLE STATE + if(l1s.audio_state[L1S_STEREOPATH_DRV_STATE] == 0) + { + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_NONE, + AUDIO_DOWNLINK_OFF, + ret, OUTEN_DISABLE); + } + else + { + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_NONE, + AUDIO_DOWNLINK_OFF, + ret, OUTEN_ENABLE); + } + +} + +void l1_audio_abb_ul_off_dl_off_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + // Configure the outen reg to 0 only when STEREOPATH_DRV_STATE is in IDLE STATE + if(l1s.audio_state[L1S_STEREOPATH_DRV_STATE] == 0) + { + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_OFF, + AUDIO_DOWNLINK_OFF, + ret, OUTEN_DISABLE); + } + else + { + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_OFF, + AUDIO_DOWNLINK_OFF, + ret, OUTEN_ENABLE); + } + +} + +void l1_audio_abb_ul_off_dl_on_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_OFF, + AUDIO_DOWNLINK_ON, + ret, OUTEN_NONE); +} + +void l1_audio_abb_ul_on_dl_off_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + // Configure the outen reg to 0 only when STEREOPATH_DRV_STATE is in IDLE STATE + if(l1s.audio_state[L1S_STEREOPATH_DRV_STATE] == 0) + { + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_ON, + AUDIO_DOWNLINK_OFF, + ret, OUTEN_DISABLE); + } + else + { + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_ON, + AUDIO_DOWNLINK_OFF, + ret, OUTEN_ENABLE); + } + +} + +void l1_audio_abb_ul_on_dl_on_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_ON, + AUDIO_DOWNLINK_ON, + ret, OUTEN_NONE); +} + + +void l1_audio_on_off_callback_fn(Uint8 callback_val) +{ + cb_array[callback_val](); +} + +#endif // SIMULATION && L1_AUDIO_MCU_ONOFF + +#if (AUDIO_DEBUG == 1) +/*-------------------------------------------------------*/ +/* l1_audio_regs_debug_read */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* */ +/*-------------------------------------------------------*/ +UWORD8 audio_reg_read_status; +BspI2c_TransactionRequest audo_read_i2cIntTransArray[20]; +BspTwl3029_I2C_RegData audio_regs[20]; +UWORD8 audio_regs_cpy[20]; +void l1_audio_reg_debug_read_callback(); +void l1_audio_regs_debug_read() +{ + BspTwl3029_I2C_RegisterInfo i2cRegArray[20]; + BspTwl3029_I2C_RegisterInfo* i2cRegArrayPtr = i2cRegArray; + + BspTwl3029_I2C_Callback callback; + BspTwl3029_I2C_CallbackPtr callbackPtr = &callback; + + callbackPtr->callbackFunc = (BspI2c_TransactionDoneCallback)l1_audio_reg_debug_read_callback; + callbackPtr->callbackVal = (BspI2c_TransactionId)(1); + callbackPtr->i2cTransArrayPtr = (Bsp_Twl3029_I2cTransReqArrayPtr)audo_read_i2cIntTransArray; + + if(audio_reg_read_status==0) + { + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_PWRONSTATUS_OFFSET,&audio_regs[0],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_CTRL1_OFFSET,&audio_regs[1],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_CTRL2_OFFSET,&audio_regs[2],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_CTRL3_OFFSET,&audio_regs[3],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_CTRL4_OFFSET,&audio_regs[4],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_CTRL5_OFFSET,&audio_regs[5],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_CTRL6_OFFSET,&audio_regs[6],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_VULGAIN_OFFSET,&audio_regs[7],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_VDLGAIN_OFFSET,&audio_regs[8],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_OUTEN1_OFFSET,&audio_regs[9],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_OUTEN2_OFFSET,&audio_regs[10],i2cRegArrayPtr++); + i2cRegArrayPtr = i2cRegArray; + BspTwl3029_I2c_regInfoSend(i2cRegArrayPtr,11,callbackPtr, + (BspI2c_TransactionRequest*)callbackPtr->i2cTransArrayPtr); + } +} + +void l1_audio_reg_debug_read_callback() +{ + int i; + audio_reg_read_status=1; + for(i=0;i<20;i++) + { + audio_regs_cpy[i]=audio_regs[i]; + } +} + +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/audio_cfile/l1audio_afunc.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,970 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_AFUNC.C + * + * Filename l1audio_afunc.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ + +#include "l1_macro.h" +#include "l1_confg.h" + +#if (AUDIO_TASK == 1) + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + #include "l1_time.h" + #include "l1_scen.h" + + #include "l1audio_proto.h" + + #else + // Layer1 and debug include files. + + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + #include "cust_os.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_proto.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added from e-smaple for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #if (RF_FAM == 61) + #include "l1_rf61.h" + #endif + + #include "l1_defty.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #include "l1_time.h" + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + + #if (OP_RIV_AUDIO == 1) + #include "rv_general.h" + #include "audio_api.h" + #include "audio_structs_i.h" + #include "audio_var_i.h" + #include "audio_macro_i.h" + #include "audio_const_i.h" + #endif + #endif + + // This macro avoids to duplicate the code. + #if (OP_RIV_AUDIO == 1) + #define AUDIO_MSG (p_message) + #else + #define AUDIO_MSG (msg->SigP) + #endif + + /*-------------------------------------------------------*/ + /* l1a_audio_send_confirmation() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : Signal Code ofthe message */ + /* */ + /* Return : */ + /* */ + /* Description : Send a confirmation message to the MMI */ + /* for an audio task. */ + /* */ + /*-------------------------------------------------------*/ + void l1a_audio_send_confirmation(UWORD32 SignalCode) + { + #if (OP_RIV_AUDIO == 1) + + void *p_message; + T_RVF_MB_STATUS mb_status; //omaps00090550 + + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_RV_HDR), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + /* fill the message id */ + ((T_RV_HDR *)p_message)->msg_id = SignalCode; + + /* send the messsage to the audio entity */ + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + + #else // OP_RIV_AUDIO + + xSignalHeaderRec *msg; + + msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + msg->SignalCode = SignalCode; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(msg); + #endif + + os_send_sig(msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + #endif // OP_RIV_AUDIO + } + +/*-------------------------------------------------------*/ +/* l1a_audio_send_result() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : Send a result message to the MMI. */ +/*-------------------------------------------------------*/ +void l1a_audio_send_result(UWORD32 SignalCode, xSignalHeaderRec *msg, UWORD8 queue) +{ +#if (OP_RIV_AUDIO == 1) + + void *p_message; + T_RVF_MB_STATUS mb_status; //omaps00090550 + + switch (SignalCode) + { + #if (L1_AUDIO_DRIVER == 1) + case AUDIO_DRIVER_NOTIFICATION_MSG: + { + T_AUDIO_DRIVER_SESSION *p_session; + T_RV_RETURN *return_path; + UINT8 channel_id; + + /* get driver session */ + channel_id = ((T_L1_AUDIO_DRIVER_IND *)msg->SigP)->channel_id; + p_session = &(p_audio_gbl_var->audio_driver_session[channel_id]); + return_path = &(p_session->session_req.return_path); + + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_AUDIO_DRIVER_NOTIFICATION), + (T_RVF_BUFFER **) (&p_message)); + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for driver notification",RV_TRACE_LEVEL_ERROR); + return; + } + + /* Fill the message ID + parameters */ + ((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->header.msg_id = SignalCode; + ((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->channel_id = channel_id; + ((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->p_buffer = ((T_L1_AUDIO_DRIVER_IND *)(msg->SigP))->p_buffer; + + /* send answer */ + if (return_path->callback_func == NULL) + rvf_send_msg (return_path->addr_id, p_message); + else + { + (*return_path->callback_func)((void *)(p_message)); + rvf_free_buf((T_RVF_BUFFER *)p_message); + } + + // This return is important because there is another rvf_send_msg at the end of the switch + return; + } +//omaps00090550 break; + #endif + #if (L1_VOICE_MEMO_AMR) + case MMI_VM_AMR_RECORD_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_VM_AMR_RECORD_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_VM_AMR_RECORD_STOP_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_VM_AMR_RECORD_CON *)p_message)->recorded_size = ((T_L1_VM_AMR_RECORD_CON *)(msg->SigP))->recorded_size; + } + break; + #endif + #if (VOICE_MEMO) + case MMI_VM_RECORD_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_VM_RECORD_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + ((T_MMI_VM_RECORD_CON *)p_message)->recorded_size = + ((T_L1_VM_RECORD_CON *)(msg->SigP))->recorded_size; + + break; + } + #endif + #if (L1_PCM_EXTRACTION) + case MMI_PCM_UPLOAD_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_PCM_UPLOAD_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + ((T_MMI_PCM_UPLOAD_STOP_CON *)p_message)->uploaded_size = + ((T_L1_PCM_UPLOAD_STOP_CON *)(msg->SigP))->uploaded_size; + + break; + } + #endif /* L1_PCM_EXTRACTION */ + + #if (SPEECH_RECO) + case MMI_SR_ENROLL_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + /* Fill the message parameter */ + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_ENROLL_STOP_CON *)(msg->SigP))->error_id; + + break; + } + case MMI_SR_UPDATE_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + /* Fill the message parameter */ + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id; + + break; + } + case MMI_SR_RECO_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + /* Fill the message parameter */ + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->best_word_index = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->best_word_score = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_score; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->second_best_word_index = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->second_best_word_score = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_score; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->third_best_word_index = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->third_best_word_score = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_score; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->fourth_best_word_index = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->fourth_best_word_score = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_score; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->d_sr_model_size = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_model_size; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->d_sr_db_level = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_level; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->d_sr_db_noise = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_noise; + + break; + } + + case MMI_SR_UPDATE_CHECK_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + /* Fill the message parameter */ + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->error_id; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->best_word_index = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->best_word_score = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->second_best_word_index = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->second_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->second_best_word_score = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->second_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->third_best_word_index = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->third_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->third_best_word_score = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->third_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->fourth_best_word_index = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->fourth_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->fourth_best_word_score = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->fourth_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->d_sr_model_size = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->d_sr_model_size; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->d_sr_db_level = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->d_sr_db_level; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->d_sr_db_noise = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->d_sr_db_noise; + + break; + } + + #endif /* SPEECH_RECO */ + + + #if (L1_CPORT == 1) + case MMI_CPORT_CONFIGURE_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_CPORT_CONFIGURE_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_CPORT_CONFIGURE_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_CPORT_CONFIGURE_CON *)p_message)->register_id = ((T_L1_CPORT_CONFIGURE_CON *)(msg->SigP))->register_id; + ((T_MMI_CPORT_CONFIGURE_CON *)p_message)->register_value = ((T_L1_CPORT_CONFIGURE_CON *)(msg->SigP))->register_value; + } + break; + #endif + + #if(L1_ANR == 2) + case MMI_AQI_ANR_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_ANR_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_ANR_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_ANR_CON *)p_message)->anr_ul_action = ((T_L1_AQI_ANR_CON *)(msg->SigP))->anr_ul_action; + } + break; + #endif + + #if(L1_IIR == 2) + case MMI_AQI_IIR_DL_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_IIR_DL_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_IIR_DL_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_IIR_DL_CON *)p_message)->iir_dl_action = ((T_L1_AQI_IIR_DL_CON *)(msg->SigP))->iir_dl_action; + } + break; + #endif + + #if(L1_AGC_UL == 1) + case MMI_AQI_AGC_UL_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_AGC_UL_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_AGC_UL_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_AGC_UL_CON *)p_message)->agc_ul_action = ((T_L1_AQI_AGC_UL_CON *)(msg->SigP))->agc_ul_action; + } + break; + #endif + + #if(L1_AGC_DL == 1) + case MMI_AQI_AGC_DL_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_AGC_DL_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_AGC_DL_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_AGC_DL_CON *)p_message)->agc_dl_action = ((T_L1_AQI_AGC_DL_CON *)(msg->SigP))->agc_dl_action; + } + break; + #endif + + #if(L1_WCM == 1) + case MMI_AQI_WCM_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_WCM_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_WCM_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_WCM_CON *)p_message)->wcm_action = ((T_L1_AQI_WCM_CON *)(msg->SigP))->wcm_action; + } + break; + #endif + + + #if(L1_DRC == 1) + case MMI_AQI_DRC_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_DRC_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_DRC_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_DRC_CON *)p_message)->drc_dl_action = ((T_L1_AQI_DRC_CON *)(msg->SigP))->drc_dl_action; + } + break; + #endif + + #if(L1_AEC == 2) + case MMI_AQI_AEC_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_AEC_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_AEC_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_AEC_CON *)p_message)->aec_action = ((T_L1_AQI_AEC_CON *)(msg->SigP))->aec_action; + } + break; + #endif + + +default: + { + AUDIO_SEND_TRACE("AUDIO entity: wrong L1 confirmation message",RV_TRACE_LEVEL_ERROR); + break; + } + } + + /* Fill the message ID */ + ((T_RV_HDR *)p_message)->msg_id = SignalCode; + /* send the messsage to the audio entity */ + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + +#else // OP_RIV_AUDIO + + // Set flag to avoid the FREE(msg) in L1ASYNC. + l1a.l1_msg_forwarded = TRUE; + + msg->SignalCode = SignalCode; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(msg); + #endif + + os_send_sig(msg, queue); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + +#endif // OP_RIV_AUDIO +} + +#if (SPEECH_RECO) + /*-------------------------------------------------------*/ + /* l1_send_sr_background_msg() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : Signal Code ofthe message */ + /* */ + /* Return : */ + /* */ + /* Description : Send a message to the SR background */ + /* task. */ + /* */ + /*-------------------------------------------------------*/ + void l1_send_sr_background_msg(UWORD32 SignalCode) + { + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; //omaps00090550 + #else + xSignalHeaderRec *msg; + #endif + + switch (SignalCode) + { + case L1_SRBACK_SAVE_DATA_REQ: + { + // Allocate the partition + #if (OP_RIV_AUDIO == 1) + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_L1_SRBACK_SAVE_DATA_REQ), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + #else // OP_RIV_AUDIO + msg = os_alloc_sig(sizeof(T_L1_SRBACK_SAVE_DATA_REQ)); + DEBUGMSG(status,NU_ALLOC_ERR) + #endif // OP_RIV_AUDIO + + // Fill the message + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->database_id = l1a_l1s_com.speechreco_task.parameters.database_id; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->model_index = l1a_l1s_com.speechreco_task.parameters.word_index; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->model_RAM_address = l1a_l1s_com.speechreco_task.parameters.model_address; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->speech = l1a_l1s_com.speechreco_task.parameters.speech; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->start_buffer = l1a_l1s_com.speechreco_task.parameters.speech_address; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->stop_buffer = l1a_l1s_com.speechreco_task.parameters.speech_address + SC_SR_MMI_2_L1_SPEECH_SIZE; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->start_address = l1a_l1s_com.speechreco_task.parameters.start_address; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->stop_address = l1a_l1s_com.speechreco_task.parameters.stop_address; + } + break; + + case L1_SRBACK_LOAD_MODEL_REQ: + { + // Allocate the partition + #if (OP_RIV_AUDIO == 1) + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_L1_SRBACK_LOAD_MODEL_REQ), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + #else // OP_RIV_AUDIO + msg = os_alloc_sig(sizeof(T_L1_SRBACK_LOAD_MODEL_REQ)); + DEBUGMSG(status,NU_ALLOC_ERR) + #endif // OP_RIV_AUDIO + + // Fill the message + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(AUDIO_MSG))->database_id = l1a_l1s_com.speechreco_task.parameters.database_id; + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(AUDIO_MSG))->model_index = l1a_l1s_com.speechreco_task.parameters.word_index; + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(AUDIO_MSG))->model_RAM_address = l1a_l1s_com.speechreco_task.parameters.model_address; + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(AUDIO_MSG))->CTO_enable = l1a_l1s_com.speechreco_task.parameters.CTO_algorithm; + } + break; + + case L1_SRBACK_TEMP_SAVE_DATA_REQ: + { + // Allocate the partition + #if (OP_RIV_AUDIO == 1) + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_L1_SRBACK_TEMP_SAVE_DATA_REQ), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + #else // OP_RIV_AUDIO + msg = os_alloc_sig(sizeof(T_L1_SRBACK_TEMP_SAVE_DATA_REQ)); + DEBUGMSG(status,NU_ALLOC_ERR) + #endif // OP_RIV_AUDIO + + // Fill the message + ((T_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(AUDIO_MSG))->model_RAM_address_input = l1a_l1s_com.speechreco_task.parameters.model_address; + ((T_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(AUDIO_MSG))->model_RAM_address_output = l1a_l1s_com.speechreco_task.parameters.model_temp_address; + } + break; + } + + #if (OP_RIV_AUDIO == 1) + /* fill the message id */ + ((T_RV_HDR *)p_message)->msg_id = SignalCode; + + /* send the messsage to the audio entity */ + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + msg->SignalCode = SignalCode; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(msg); + #endif + + os_send_sig(msg, SRBACK_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + } +#endif +#if (MELODY_E2) + /*-------------------------------------------------------*/ + /* l1_send_melody_e2_background_msg() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : Signal Code of the message */ + /* melody ID (0 or 1) */ + /* */ + /* Return : */ + /* */ + /* Description : Send a message to the audio background */ + /* for the melody E2 feature. */ + /* */ + /*-------------------------------------------------------*/ + void l1_send_melody_e2_background_msg(UWORD32 SignalCode, UWORD8 melody_id) + { + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; //omaps00090550 + #else + xSignalHeaderRec *msg; + #endif + + UWORD8 i; + + if ( SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ ) + { + // Allocate the partition + #if (OP_RIV_AUDIO == 1) + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + #else // OP_RIV_AUDIO + msg = os_alloc_sig(sizeof(T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ)); + DEBUGMSG(status,NU_ALLOC_ERR) + #endif // OP_RIV_AUDIO + + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->melody_id = + melody_id; + + if (melody_id == 0) + { + // Load instrument for the melody 0 + // Fill the message + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->number_of_instrument = + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument; + for(i=0; i<SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT; i++) + { + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->waves_table_id[i] = + l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i]; + } + } + if (melody_id == 1) + { + // Load instrument for the melody 1 + // Fill the message + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->number_of_instrument = + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument; + for(i=0; i<SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT; i++) + { + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->waves_table_id[i] = + l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i]; + } + } + } + else + if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ) + { + // Allocate the partition + #if (OP_RIV_AUDIO == 1) + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + #else // OP_RIV_AUDIO + msg = os_alloc_sig(sizeof(T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ)); + DEBUGMSG(status,NU_ALLOC_ERR) + #endif // OP_RIV_AUDIO + + ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->melody_id = + melody_id; + + if (melody_id == 0) + { + ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->number_of_instrument = + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument; + } + else + if (melody_id == 1) + { + ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->number_of_instrument = + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument; + } + } + + #if (OP_RIV_AUDIO == 1) + ((T_RV_HDR *)p_message)->msg_id = SignalCode; + + /* send the messsage to the audio entity */ + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + msg->SignalCode = SignalCode; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(msg); + #endif + + os_send_sig(msg, SRBACK_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + } +#endif // MELODY_E2 + +#endif // AUDIO_TASK
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/audio_cfile/l1audio_async.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,10707 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_ASYNC.C + * + * Filename l1audio_async.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ + +#include "l1_macro.h" +#include "l1_confg.h" + +#if (AUDIO_TASK == 1) + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + #include "cust_os.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + #include "l1audio_proto.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + + + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + #if (L1_DYN_DSP_DWNLD==1) + #include "l1_dyn_dwl_defty.h" + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_signa.h" + #endif + + #include "l1_defty.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + + #include "l1_time.h" + #include "l1_scen.h" + + #else + + // Layer1 and debug include files. + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + #include "cust_os.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + #include "l1audio_proto.h" + + #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 + + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #if (L1_DYN_DSP_DWNLD==1) + #include "l1_dyn_dwl_defty.h" + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_signa.h" + #endif + +#if (RF_FAM == 61) +#include "l1_rf61.h" +#endif + + #include "l1_defty.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #include "l1_time.h" + + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + + #if (OP_RIV_AUDIO == 1) + #include "rv_general.h" + #include "audio_api.h" + #include "audio_structs_i.h" + #include "audio_var_i.h" + #include "audio_macro_i.h" + #include "audio_const_i.h" + #endif + #endif + + #include "l1audio_macro.h" + + #if(L1_DYN_DSP_DWNLD == 1) + #if (TRACE_TYPE == 1) ||(TRACE_TYPE == 4) || (TRACE_TYPE == 5) || (TRACE_TYPE == 7) || (TESTMODE) + #include "l1_trace.h" + #endif + #if(CODE_VERSION == SIMULATION) + extern void trace_fct_simu_dyn_dwnld(CHAR *fct_name); + #endif + #endif + +#if 0 + #if (L1_MP3) + extern T_MP3_MCU_DSP *mp3_ndb;//Mp3-FR + #endif +//#pragma DUPLICATE_FOR_INTERNAL_RAM_END + +#endif +#if ( L1_AAC) +extern UWORD16 a_aac_dma_input_buffer[2][C_AAC_OUTPUT_BUFFER_SIZE]; +extern UWORD8 d_aac_dma_current_buffer_id; + +#endif + +#if (L1_MP3) +extern T_MP3_MCU_DSP *mp3_ndb;//Mp3-FR +#endif + /**************************************/ + /* Prototypes for L1 ASYNCH task */ + /**************************************/ + #if (OP_RIV_AUDIO == 1) + #if (L1_AUDIO_DRIVER == 1) + void l1a_audio_driver_process (xSignalHeaderRec *msg); + #endif + #endif + #if (KEYBEEP) + void l1a_mmi_keybeep_process (xSignalHeaderRec *msg); + #endif + #if (TONE) + void l1a_mmi_tone_process (xSignalHeaderRec *msg); + #endif + #if (L1_CPORT == 1) + void l1a_mmi_cport_process (xSignalHeaderRec *msg); + #endif + #if (MELODY_E1) + void l1a_mmi_melody0_process (xSignalHeaderRec *msg); + void l1a_mmi_melody1_process (xSignalHeaderRec *msg); + #endif + #if (VOICE_MEMO) + void l1a_mmi_vm_playing_proccess (xSignalHeaderRec *msg); + void l1a_mmi_vm_recording_process (xSignalHeaderRec *msg); + #endif + #if (L1_PCM_EXTRACTION) + void l1a_mmi_pcm_download_process (xSignalHeaderRec *msg); + void l1a_mmi_pcm_upload_process (xSignalHeaderRec *msg); + #endif + #if (L1_VOICE_MEMO_AMR) + void l1a_mmi_vm_amr_playing_proccess (xSignalHeaderRec *msg); + void l1a_mmi_vm_amr_recording_process(xSignalHeaderRec *msg); + #endif + #if (SPEECH_RECO) + void l1a_mmi_sr_enroll_process (xSignalHeaderRec *msg); + void l1a_mmi_sr_update_process (xSignalHeaderRec *msg); + void l1a_mmi_sr_reco_process (xSignalHeaderRec *msg); + void l1a_mmi_sr_update_check_process(xSignalHeaderRec *msg); + #endif + #if (AEC == 1) + void l1a_mmi_aec_process (xSignalHeaderRec *msg); + #endif + #if (AEC == 2) + void l1a_mmi_aec_process (xSignalHeaderRec *msg); + #endif + #if (FIR) + void l1a_mmi_fir_process (xSignalHeaderRec *msg); + #endif + #if (AUDIO_MODE) + void l1a_mmi_audio_mode_process (xSignalHeaderRec *msg); + #endif + #if (MELODY_E2) + void l1a_mmi_melody0_e2_process (xSignalHeaderRec *msg); + void l1a_mmi_melody1_e2_process (xSignalHeaderRec *msg); + #endif + #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1) + void l1a_mmi_audio_onoff_process (xSignalHeaderRec *msg); + #endif + #if (L1_EXT_AUDIO_MGT == 1) + void l1a_mmi_ext_audio_mgt_process (xSignalHeaderRec *msg); + #endif + #if (L1_ANR == 1 || L1_ANR == 2) + void l1a_mmi_anr_process (xSignalHeaderRec *msg); + #endif + #if (L1_AGC_UL == 1) + void l1a_mmi_agc_ul_process (xSignalHeaderRec *msg); + #endif + #if (L1_AGC_DL == 1) + void l1a_mmi_agc_dl_process (xSignalHeaderRec *msg); + #endif + #if (L1_IIR == 1 || L1_IIR == 2) + void l1a_mmi_iir_process (xSignalHeaderRec *msg); + #endif + #if (L1_WCM == 1) + void l1a_mmi_wcm_process (xSignalHeaderRec *msg); + #endif +#if (L1_DRC == 1) + void l1a_mmi_drc_process (xSignalHeaderRec *msg); + #endif + #if (L1_LIMITER == 1) + void l1a_mmi_limiter_process (xSignalHeaderRec *msg); + #endif + #if (L1_ES == 1) + void l1a_mmi_es_process (xSignalHeaderRec *msg); + #endif + #if (L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_vocoder_cfg_process(xSignalHeaderRec *msg); + #endif +#if(L1_BT_AUDIO==1) + void l1a_mmi_bt_process(xSignalHeaderRec *msg); +#endif + /**************************************/ + /* External prototypes */ + /**************************************/ + extern UWORD8 copy_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_dst); + extern UWORD8 copy_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_src); + extern UWORD8 Cust_get_pointer (UWORD16 **ptr, UWORD16 *buffer_size, UWORD8 session_id); + #if (MELODY_E2) + extern UWORD8 copy_byte_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_dst); + extern UWORD8 copy_byte_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_src); + #endif + #if (L1_EXT_AUDIO_MGT == 1) + T_MIDI_DMA_PARAM midi_buf; + #if (CODE_VERSION == NOT_SIMULATION) +#pragma DATA_SECTION(midi_buf,".l1s_global") +#endif + extern void l1_ext_audio_mgt_dma_handler(SYS_UWORD16 dma_status); + #endif + #if(L1_BT_AUDIO ==1) + BOOL midi_task_running; + extern T_L1_BT_AUDIO bt_audio; + extern void l1_audio_bt_init(UINT16 media_buf_size); + #endif + + #if (OP_RIV_AUDIO == 1) + #if (L1_AUDIO_DRIVER == 1) + void l1a_audio_driver_process(xSignalHeaderRec *msg) + { + UWORD32 SignalCode = msg->SignalCode; + + if (SignalCode == L1_AUDIO_DRIVER_IND) + l1a_audio_send_result(AUDIO_DRIVER_NOTIFICATION_MSG, msg, MMI_QUEUE); + } + #endif + #endif + + #if (KEYBEEP) + /*-------------------------------------------------------*/ + /* l1a_mmi_keybeep_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* keybeep feature. */ + /* */ + /* Starting messages: MMI_KEYBEEP_START_REQ */ + /* */ + /* Result messages (input): L1_KEYBEEP_START_CON */ + /* */ + /* Result messages (output): MMI_KEYBEEP_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_KEYBEEP_STOP_REQ */ + /* L1_KEYBEEP_STOP_CON */ + /* */ + /* Stop message (output): MMI_KEYBEEP_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_keybeep_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_KEYBEEP_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.keybeep_task.command.start = FALSE; + l1a_l1s_com.keybeep_task.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_KEYBEEP_START_REQ) + { + // Download the keybeep description in the NDB. + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_kt0= ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_k_x1_kt0; + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_kt1= ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_k_x1_kt1; + l1s_dsp_com.dsp_ndb_ptr->d_dur_kb = ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_dur_kb; + + // Start the L1S keybeep task + l1a_l1s_com.keybeep_task.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + // OMPAS00090550 break; + + case WAIT_START_CON: + { + if (SignalCode == L1_KEYBEEP_START_CON) + { + // Disable the start command + l1a_l1s_com.keybeep_task.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_KEYBEEP_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + // ompas00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_KEYBEEP_STOP_REQ) + { + // Stop the L1S keybeep task + l1a_l1s_com.keybeep_task.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_KEYBEEP_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_KEYBEEP_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + // omaps00090550 break; + } // switch + } // while(1) + } + #endif // KEYBEEP + + #if (TONE) + /*-------------------------------------------------------*/ + /* l1a_mmi_tone_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* tone feature. */ + /* */ + /* Starting messages: MMI_TONE_START_REQ */ + /* */ + /* Result messages (input): L1_TONE_START_CON */ + /* */ + /* Result messages (output): MMI_TONE_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_TONE_STOP_REQ */ + /* L1_TONE_STOP_CON */ + /* */ + /* Stop message (output): MMI_TONE_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_tone_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_TONE_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.tone_task.command.start = FALSE; + l1a_l1s_com.tone_task.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_TONE_START_REQ) + { + // Download the tone description in the NDB. + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t0 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t0; + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t1 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t1; + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t2 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t2; + l1s_dsp_com.dsp_ndb_ptr->d_pe_rep = ((T_MMI_TONE_REQ *)(msg->SigP))->d_pe_rep; + l1s_dsp_com.dsp_ndb_ptr->d_pe_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_pe_off; + l1s_dsp_com.dsp_ndb_ptr->d_se_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_se_off; + l1s_dsp_com.dsp_ndb_ptr->d_bu_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_bu_off; + l1s_dsp_com.dsp_ndb_ptr->d_t0_on = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t0_on; + l1s_dsp_com.dsp_ndb_ptr->d_t0_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t0_off; + l1s_dsp_com.dsp_ndb_ptr->d_t1_on = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t1_on; + l1s_dsp_com.dsp_ndb_ptr->d_t1_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t1_off; + l1s_dsp_com.dsp_ndb_ptr->d_t2_on = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t2_on; + l1s_dsp_com.dsp_ndb_ptr->d_t2_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t2_off; + + + // Start the L1S tone task + l1a_l1s_com.tone_task.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + //omaps00090550 break; + + case WAIT_START_CON: + { + if (SignalCode == L1_TONE_START_CON) + { + // Disable the start command + l1a_l1s_com.tone_task.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_TONE_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_TONE_STOP_REQ) + { + // Stop the L1S tone task + l1a_l1s_com.tone_task.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_TONE_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_TONE_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // TONE + + + + + + #if (MELODY_E1) + /*-------------------------------------------------------*/ + /* l1a_mmi_melody0_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* melody 0 feature. */ + /* */ + /* Starting messages: MMI_MELODY0_START_REQ */ + /* */ + /* Result messages (input): L1_MELODY0_START_CON */ + /* */ + /* Result messages (output): MMI_MELODY0_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_MELDOY0_STOP_REQ */ + /* L1_MELODY0_STOP_CON */ + /* */ + /* Stop message (output): MMI_MELODY0_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_melody0_process(xSignalHeaderRec *msg) + { + enum states + { + M0_RESET = 0, + M0_WAIT_START_REQ = 1, + M0_WAIT_START_CON = 2, + M0_WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_MELODY0_STATE]; + UWORD32 SignalCode = msg->SignalCode; + UWORD8 melody_osc, used_osc; + + while(1) + { + switch(*state) + { + case M0_RESET: + { + // Reset the commands: + l1a_l1s_com.melody0_task.command.start = FALSE; + l1a_l1s_com.melody0_task.command.stop = FALSE; + + // Initialize the translation table + for (melody_osc=0; melody_osc<SC_NUMBER_OSCILLATOR; melody_osc++) + l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[melody_osc] = SC_NUMBER_OSCILLATOR; + + *state = M0_WAIT_START_REQ; + } + break; + + case M0_WAIT_START_REQ: + { + if (SignalCode == MMI_MELODY0_START_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.melody0_task.parameters.session_id = ((T_MMI_MELODY_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.melody0_task.parameters.loopback = ((T_MMI_MELODY_REQ *)(msg->SigP))->loopback; + l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap = ((T_MMI_MELODY_REQ *)(msg->SigP))->oscillator_used_bitmap; + + // Initialize the buffer parameters + l1a_l1s_com.melody0_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody0_task.parameters.buffer_size = 0; + l1a_l1s_com.melody0_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_task.parameters.ptr_buf, + &l1a_l1s_com.melody0_task.parameters.buffer_size, + l1a_l1s_com.melody0_task.parameters.session_id); + + // Read the Header of the melody description to have the melody bitmap + l1a_l1s_com.melody0_task.parameters.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1a_l1s_com.melody0_task.parameters.buffer_size, + (UWORD16 **)&l1a_l1s_com.melody0_task.parameters.ptr_buf, + 1, + &l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap); + + l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap = Field(l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap, SC_MELO_OSCILLATOR_USED_MASK, SC_MELO_OSCILLATOR_USED_SHIFT); + + // Build the array of translation between the melody mapping and the oscillators used + used_osc = 0; + melody_osc = 0; + while ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) ) + { + // find the next oscillator available in the melody + while( ((l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap & (0x1<<melody_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) ) + melody_osc++; + + // find the next oscillator available in the oscillator used + while( ((l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & (0x1<<used_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) ) + used_osc++; + + // Fill the translation table + if ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) ) + l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[melody_osc] = used_osc; + melody_osc++; + used_osc++; + } + + // Start the melody 0 L1S task: + l1a_l1s_com.melody0_task.command.start = TRUE; + + *state = M0_WAIT_START_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case M0_WAIT_START_CON: + { + if (SignalCode == L1_MELODY0_START_CON) + { + // Disable the start command + l1a_l1s_com.melody0_task.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_START_CON); + + *state = M0_WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case M0_WAIT_STOP: + { + if (SignalCode == L1_MELODY0_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_STOP_CON); + + *state = M0_RESET; + } + else + if (SignalCode == MMI_MELODY0_STOP_REQ) + { + // Stop the melody 0 L1S task: + l1a_l1s_com.melody0_task.command.stop = TRUE; + + // End process + return; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_melody1_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* melody 1 feature. */ + /* */ + /* Starting messages: MMI_MELODY1_START_REQ */ + /* */ + /* Result messages (input): L1_MELODY1_START_CON */ + /* */ + /* Result messages (output): MMI_MELODY1_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_MELDOY1_STOP_REQ */ + /* L1_MELODY1_STOP_CON */ + /* */ + /* Stop message (output): MMI_MELODY1_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_melody1_process(xSignalHeaderRec *msg) + { + enum states + { + M1_RESET = 0, + M1_WAIT_START_REQ = 1, + M1_WAIT_START_CON = 2, + M1_WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_MELODY1_STATE]; + UWORD32 SignalCode = msg->SignalCode; + UWORD8 melody_osc, used_osc; + + while(1) + { + switch(*state) + { + case M1_RESET: + { + // Reset the commands: + l1a_l1s_com.melody1_task.command.start = FALSE; + l1a_l1s_com.melody1_task.command.stop = FALSE; + + // Initialize the translation table + for (melody_osc=0; melody_osc<SC_NUMBER_OSCILLATOR; melody_osc++) + l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[melody_osc] = SC_NUMBER_OSCILLATOR; + + + *state = M1_WAIT_START_REQ; + } + break; + + case M1_WAIT_START_REQ: + { + if (SignalCode == MMI_MELODY1_START_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.melody1_task.parameters.session_id = ((T_MMI_MELODY_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.melody1_task.parameters.loopback = ((T_MMI_MELODY_REQ *)(msg->SigP))->loopback; + l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap = ((T_MMI_MELODY_REQ *)(msg->SigP))->oscillator_used_bitmap; + + // Initialize the buffer parameters + l1a_l1s_com.melody1_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody1_task.parameters.buffer_size = 0; + l1a_l1s_com.melody1_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_task.parameters.ptr_buf, + &l1a_l1s_com.melody1_task.parameters.buffer_size, + l1a_l1s_com.melody1_task.parameters.session_id); + + // Read the Header of the melody description to have the melody bitmap + l1a_l1s_com.melody1_task.parameters.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1a_l1s_com.melody1_task.parameters.buffer_size, + (UWORD16 **)&l1a_l1s_com.melody1_task.parameters.ptr_buf, + 1, + &l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap); + + l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap = Field(l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap, SC_MELO_OSCILLATOR_USED_MASK, SC_MELO_OSCILLATOR_USED_SHIFT); + // Build the array of translation between the melody maaping and the oscillators used + used_osc = 0; + melody_osc = 0; + while ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) ) + { + // find the next oscillator available in the melody + while( ((l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap & (0x1<<melody_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) ) + melody_osc++; + + // find the next oscillator available in the oscillator used + while( ((l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & (0x1<<used_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) ) + used_osc++; + + // Fill the translation table + if ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) ) + l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[melody_osc] = used_osc; + melody_osc++; + used_osc++; + } + + // Start the melody 1 L1S task: + l1a_l1s_com.melody1_task.command.start = TRUE; + + *state = M1_WAIT_START_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case M1_WAIT_START_CON: + { + if (SignalCode == L1_MELODY1_START_CON) + { + // Disable the start command + l1a_l1s_com.melody1_task.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_START_CON); + + *state = M1_WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + case M1_WAIT_STOP: + { + if (SignalCode == L1_MELODY1_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_STOP_CON); + + *state = M1_RESET; + } + else + if (SignalCode == MMI_MELODY1_STOP_REQ) + { + // Stop the melody 0 L1S task: + l1a_l1s_com.melody1_task.command.stop = TRUE; + + // End process + return; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // MELODY_E1 + +#if (VOICE_MEMO) + /*-------------------------------------------------------*/ + /* l1a_mmi_vm_playing_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* voice memorization playing feature. */ + /* */ + /* Starting messages: MMI_VM_PLAY_START_REQ */ + /* */ + /* Result messages (input): L1_VM_PLAY_START_CON */ + /* */ + /* Result messages (output): MMI_VM_PLAY_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_VM_PLAY_STOP_REQ */ + /* L1_VM_PLAY_STOP_CON */ + /* */ + /* Stop message (output): MMI_VM_PLAY_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_vm_playing_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_VM_PLAY_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.voicememo_task.play.command.start = FALSE; + l1a_l1s_com.voicememo_task.play.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_VM_PLAY_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.voicememo_task.play.parameters.session_id = ((T_MMI_VM_PLAY_REQ *)(msg->SigP))->session_id; + + // Start the L1S voice memo playing task + l1a_l1s_com.voicememo_task.play.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_START_CON: + { + if (SignalCode == L1_VM_PLAY_START_CON) + { + // Reset the start command + l1a_l1s_com.voicememo_task.play.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_VM_PLAY_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_VM_PLAY_STOP_REQ) + { + // Stop the L1S voice memo playing task + l1a_l1s_com.voicememo_task.play.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_VM_PLAY_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_VM_PLAY_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_vm_recording_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* voice memorization recording feature. */ + /* */ + /* Starting messages: MMI_VM_RECORD_START_REQ */ + /* */ + /* Result messages (input): L1_VM_RECORD_START_CON */ + /* */ + /* Result messages (output): MMI_VM_RECORD_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_VM_RECORD_STOP_REQ */ + /* L1_VM_RECORD_STOP_CON */ + /* */ + /* Stop message (output): MMI_VM_RECORD_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_vm_recording_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_VM_RECORD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.voicememo_task.record.command.start = FALSE; + l1a_l1s_com.voicememo_task.record.command.stop = FALSE; + l1a_l1s_com.voicememo_task.record.tone_ul.start = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_VM_RECORD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.voicememo_task.record.parameters.session_id = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.voicememo_task.record.parameters.maximum_size = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->maximum_size; + l1a_l1s_com.voicememo_task.record.parameters.dtx = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->dtx_used; + + // Download UL/DL audio gain to the NDB + l1s_dsp_com.dsp_ndb_ptr->d_shiftul = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->record_coeff_ul; + l1s_dsp_com.dsp_ndb_ptr->d_shiftdl = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->record_coeff_dl; + + // Download the tone description in the NDB. + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t0 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t0; + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t1 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t1; + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t2 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t2; + l1s_dsp_com.dsp_ndb_ptr->d_pe_rep = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_pe_rep; + l1s_dsp_com.dsp_ndb_ptr->d_pe_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_pe_off; + l1s_dsp_com.dsp_ndb_ptr->d_se_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_se_off; + l1s_dsp_com.dsp_ndb_ptr->d_bu_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_bu_off; + l1s_dsp_com.dsp_ndb_ptr->d_t0_on = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t0_on; + l1s_dsp_com.dsp_ndb_ptr->d_t0_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t0_off; + l1s_dsp_com.dsp_ndb_ptr->d_t1_on = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t1_on; + l1s_dsp_com.dsp_ndb_ptr->d_t1_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t1_off; + l1s_dsp_com.dsp_ndb_ptr->d_t2_on = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t2_on; + l1s_dsp_com.dsp_ndb_ptr->d_t2_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t2_off; + + // Start the L1S voice memo recording task + l1a_l1s_com.voicememo_task.record.command.start = TRUE; + + // Start the L1S voice memo tone uplink task + l1a_l1s_com.voicememo_task.record.tone_ul.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_START_CON: + { + if (SignalCode == L1_VM_RECORD_START_CON) + { + // Reset the start command + l1a_l1s_com.voicememo_task.record.tone_ul.start = FALSE; + + // Reset the start command + l1a_l1s_com.voicememo_task.record.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_VM_RECORD_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_VM_RECORD_STOP_REQ) + { + // Stop the L1S voice memo recording task + l1a_l1s_com.voicememo_task.record.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_VM_RECORD_STOP_CON) + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_VM_RECORD_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // VOICE_MEMO + + #if (L1_PCM_EXTRACTION) + #if (L1_DYN_DSP_DWNLD == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_pcm_download_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* PCM download feature. */ + /* */ + /* Starting messages: MMI_PCM_DOWNLOAD_START_REQ */ + /* */ + /* Result messages (input): L1_PCM_DOWNLOAD_START_CON */ + /* */ + /* Result messages (output): MMI_PCM_DOWNLOAD_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_PCM_DOWNLOAD_STOP_REQ */ + /* L1_PCM_DOWNLOAD_STOP_CON */ + /* */ + /* Stop message (output): MMI_PCM_DOWNLOAD_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_pcm_download_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_START_CON = 3, + WAIT_STOP = 4 + }; + + UWORD8 *state = &l1a.state[L1A_PCM_DOWNLOAD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.pcm_task.download.command.start = FALSE; + l1a_l1s_com.pcm_task.download.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_PCM_DOWNLOAD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.pcm_task.download.parameters.session_id = ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.pcm_task.download.parameters.maximum_size = ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->maximum_size; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_ul_gain) << 1); + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |= + ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_dl_gain) << 8); + + if (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE]==GREEN) + { + // Start the L1S PCM download task + l1a_l1s_com.pcm_task.download.command.start = TRUE; + *state = WAIT_START_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"PCM Extraction SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + end_process = 1; + } + break; + + case WAIT_DYN_DWNLD: + { + if((SignalCode==API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE] == GREEN)) + { + // Start the L1S PCM download task + l1a_l1s_com.pcm_task.download.command.start = TRUE; + *state = WAIT_START_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[32]; + sprintf(str,"PCM Extraction SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + // End process + end_process = 1; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_PCM_DOWNLOAD_START_CON) + { + // Reset the start command + l1a_l1s_com.pcm_task.download.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_START_CON); + + *state = WAIT_STOP; + } + + // End process + end_process = 1; + } + break; + + case WAIT_STOP: + { + + UWORD32 maximum_size; + + if (SignalCode == MMI_PCM_DOWNLOAD_STOP_REQ) + { + maximum_size = ((T_MMI_PCM_DOWNLOAD_STOP_REQ *)(msg->SigP))->maximum_size; + if(maximum_size == 0) + { + // Stop the L1S PCM download task + l1a_l1s_com.pcm_task.download.command.stop = TRUE; + } + else + { + l1a_l1s_com.pcm_task.download.parameters.maximum_size = maximum_size; + + } + + // End process + return; + } + else + if (SignalCode == L1_PCM_DOWNLOAD_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(!end_process) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_pcm_upload_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* PCM upload feature. */ + /* */ + /* Starting messages: MMI_PCM_UPLOAD_START_REQ */ + /* */ + /* Result messages (input): L1_PCM_UPLOAD_START_CON */ + /* */ + /* Result messages (output): MMI_PCM_UPLOAD_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_PCM_UPLOAD_STOP_REQ */ + /* L1_PCM_UPLOAD_STOP_CON */ + /* */ + /* Stop message (output): MMI_PCM_UPLOAD_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_pcm_upload_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_START_CON = 3, + WAIT_STOP = 4 + }; + + UWORD8 *state = &l1a.state[L1A_PCM_UPLOAD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.pcm_task.upload.command.start = FALSE; + l1a_l1s_com.pcm_task.upload.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_PCM_UPLOAD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.pcm_task.upload.parameters.session_id = ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.pcm_task.upload.parameters.maximum_size = ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->maximum_size; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_ul_gain) << 1); + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload |= ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_dl_gain) << 8); + + if (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE]==GREEN) + { + // Start the L1S PCM upload task + l1a_l1s_com.pcm_task.upload.command.start = TRUE; + *state = WAIT_START_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"PCM Extraction SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + + + } + + // End process + end_process = 1; + } + break; + + case WAIT_DYN_DWNLD: + { + if((SignalCode==API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE] == GREEN)) + { + // Start the L1S PCM upload task + l1a_l1s_com.pcm_task.upload.command.start = TRUE; + *state = WAIT_START_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[32]; + sprintf(str,"PCM Extraction SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + // End process + end_process = 1; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_PCM_UPLOAD_START_CON) + { + // Reset the start command + l1a_l1s_com.pcm_task.upload.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_PCM_UPLOAD_START_CON); + + *state = WAIT_STOP; + } + + // End process + end_process = 1; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_PCM_UPLOAD_STOP_REQ) + { + // Stop the L1S PCM recording task + l1a_l1s_com.pcm_task.upload.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_PCM_UPLOAD_STOP_CON) + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_PCM_UPLOAD_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(!end_process) + } + +#else /*L1_DYN_DSP_DWNLD == 0 + +// l1a_mmi_pcm_download_process() +// Description: +// This function is a state machine which handles the */ +// PCM download feature. + // Starting messages: MMI_PCM_DOWNLOAD_START_REQ +// Result messages (input): L1_PCM_DOWNLOAD_START_CON + // Result messages (output): MMI_PCM_DOWNLOAD_START_CON +// Reset messages (input): none + // Stop message (input): MMI_PCM_DOWNLOAD_STOP_REQ + //L1_PCM_DOWNLOAD_STOP_CON +// Stop message (output): MMI_PCM_DOWNLOAD_STOP_CON */ + //Rem: */ + + void l1a_mmi_pcm_download_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_PCM_DOWNLOAD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.pcm_task.download.command.start = FALSE; + l1a_l1s_com.pcm_task.download.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_PCM_DOWNLOAD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.pcm_task.download.parameters.session_id = ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.pcm_task.download.parameters.maximum_size = ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->maximum_size; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_ul_gain) << 1); + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |= + ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_dl_gain) << 8); + // Start the L1S PCM download task + l1a_l1s_com.pcm_task.download.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + end_process = 1; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_PCM_DOWNLOAD_START_CON) + { + // Reset the start command + l1a_l1s_com.pcm_task.download.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_START_CON); + + *state = WAIT_STOP; + } + + // End process + end_process = 1; + } + break; + + case WAIT_STOP: + { + + UWORD32 maximum_size; + + if (SignalCode == MMI_PCM_DOWNLOAD_STOP_REQ) + { + maximum_size = ((T_MMI_PCM_DOWNLOAD_STOP_REQ *)(msg->SigP))->maximum_size; + if(maximum_size == 0) + { + // Stop the L1S PCM download task + l1a_l1s_com.pcm_task.download.command.stop = TRUE; + } + else + { + l1a_l1s_com.pcm_task.download.parameters.maximum_size = maximum_size; + + } + + // End process + return; + } + else + if (SignalCode == L1_PCM_DOWNLOAD_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(!end_process) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_pcm_upload_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* PCM upload feature. */ + /* */ + /* Starting messages: MMI_PCM_UPLOAD_START_REQ */ + /* */ + /* Result messages (input): L1_PCM_UPLOAD_START_CON */ + /* */ + /* Result messages (output): MMI_PCM_UPLOAD_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_PCM_UPLOAD_STOP_REQ */ + /* L1_PCM_UPLOAD_STOP_CON */ + /* */ + /* Stop message (output): MMI_PCM_UPLOAD_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_pcm_upload_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_PCM_UPLOAD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.pcm_task.upload.command.start = FALSE; + l1a_l1s_com.pcm_task.upload.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_PCM_UPLOAD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.pcm_task.upload.parameters.session_id = ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.pcm_task.upload.parameters.maximum_size = ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->maximum_size; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_ul_gain) << 1); + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload |= ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_dl_gain) << 8); + + // Start the L1S voice memo recording task + l1a_l1s_com.pcm_task.upload.command.start = TRUE; + + + *state = WAIT_START_CON; + } + + // End process + end_process = 1; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_PCM_UPLOAD_START_CON) + { + // Reset the start command + l1a_l1s_com.pcm_task.upload.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_PCM_UPLOAD_START_CON); + + *state = WAIT_STOP; + } + + // End process + end_process = 1; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_PCM_UPLOAD_STOP_REQ) + { + // Stop the L1S PCM recording task + l1a_l1s_com.pcm_task.upload.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_PCM_UPLOAD_STOP_CON) + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_PCM_UPLOAD_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(!end_process) + } + #endif /* L1_DYN_DSP_DWNLD */ + + #endif /* L1_PCM_EXTRACTION */ + + #if (L1_VOICE_MEMO_AMR) + + #if (L1_DYN_DSP_DWNLD==1) + /*-------------------------------------------------------*/ + /* l1a_mmi_vm_amr_playing_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* voice memorization playing feature. */ + /* */ + /* Starting messages: MMI_VM_AMR_PLAY_START_REQ */ + /* */ + /* Result messages (input): L1_VM_AMR_PLAY_START_CON */ + /* */ + /* Result messages (output): MMI_VM_AMR_PLAY_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_VM_AMR_PLAY_STOP_REQ */ + /* L1_VM_AMR_PLAY_STOP_CON */ + /* */ + /* Stop message (output): MMI_VM_AMR_PLAY_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_vm_amr_playing_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_START_CON = 3, + WAIT_STOP = 4 + #if 0 /* FreeCalypso TCS211 reconstruction */ + VM_AMR_PLAY = 5, + VM_AMR_PAUSE = 6, + VM_AMR_PAUSE_CON = 7, + WAIT_RESUME_CON = 8 + #endif + }; + + UWORD8 *state = &l1a.state[L1A_VM_AMR_PLAY_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.stop = FALSE; + #if 0 /* FreeCalypso TCS211 reconstruction */ + l1a_l1s_com.voicememo_amr_task.play.command.pause = FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.resume = FALSE; + #endif + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if(SignalCode == MMI_VM_AMR_PLAY_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.voicememo_amr_task.play.parameters.session_id = ((T_MMI_VM_AMR_PLAY_REQ *)(msg->SigP))->session_id; + + if (l1a.dyn_dwnld.semaphore_vect[VOICE_PLAY_AMR_SM]==GREEN) + { + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state + // Start the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.start = TRUE; + *state = WAIT_START_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"VOICE PLAY AMR SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + // End process + return; + } +// omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if((SignalCode==API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[VOICE_PLAY_AMR_SM] == GREEN)) + { + // Start the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.start = TRUE; + *state = WAIT_START_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[32]; + sprintf(str,"VOICE PLAY AMR SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_START_CON: + { + if (SignalCode == L1_VM_AMR_PLAY_START_CON) + { + // Reset the start command + l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_VM_AMR_PLAY_STOP_REQ) + { + // Stop the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_VM_AMR_PLAY_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + #if 0 /* FreeCalypso TCS211 reconstruction */ + case VM_AMR_PLAY: + { + switch (SignalCode) + { + case MMI_VM_AMR_PAUSE_REQ: + { + // Stop the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.pause= TRUE; + *state = VM_AMR_PAUSE_CON; + + } + break; + + case MMI_VM_AMR_PLAY_STOP_REQ: + { + // Stop the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.stop = TRUE; + *state=WAIT_STOP; + } + break; + + case L1_VM_AMR_PLAY_STOP_CON: + { + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + *state = RESET; + } + break; + } + return; + } + + case VM_AMR_PAUSE_CON: + { + if(SignalCode==L1_VM_AMR_PAUSE_CON) + { + // Send confirmation to upper layers + l1a_audio_send_confirmation(MMI_VM_AMR_PAUSE_CON); + + // Change state + *state=VM_AMR_PAUSE; + } + else if(SignalCode== L1_VM_AMR_PLAY_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + return; + } // case WAIT_PAUSE_CON + // ************* + // * VM_AMR_PAUSE * + // ************* + case VM_AMR_PAUSE: + { + switch(SignalCode) + { + // * MMI requests VM_AMR resume * + case MMI_VM_AMR_RESUME_REQ: + { + l1a_l1s_com.voicememo_amr_task.play.command.pause= FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.resume=TRUE; + + // Change state + *state=WAIT_RESUME_CON; + + } + break; + // *-----------------------* + // * MMI requests VM_AMR stop * + // *-----------------------* + case MMI_VM_AMR_PLAY_STOP_REQ: + { + // Store stop request in L1A/HISR interface + l1a_l1s_com.voicememo_amr_task.play.command.stop=TRUE; + + // Change state + *state=WAIT_STOP; + + } + break; + case L1_VM_AMR_PLAY_STOP_CON: + { + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + break; + } + return; + } + // case VM_AMR_PAUSE + // ******************* + // * WAIT_RESUME_CON * + // ******************* + case WAIT_RESUME_CON: + { + if(SignalCode==L1_VM_AMR_RESUME_CON) + { + l1a_l1s_com.voicememo_amr_task.play.command.resume=FALSE; + // Send confirmation to upper layers + l1a_audio_send_confirmation(MMI_VM_AMR_RESUME_CON); + + // Change state + *state=VM_AMR_PLAY; + } + return; + } // case WAIT_RESUME_CON + #endif + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_vm_amr_recording_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* voice memorization recording feature. */ + /* */ + /* Starting messages: MMI_VM_AMR_RECORD_START_REQ */ + /* */ + /* Result messages (input): L1_VM_AMR_RECORD_START_CON */ + /* */ + /* Result messages (output): MMI_VM_AMR_RECORD_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_VM_AMR_RECORD_STOP_REQ */ + /* L1_VM_AMR_RECORD_STOP_CON */ + /* */ + /* Stop message (output): MMI_VM_AMR_RECORD_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_vm_amr_recording_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_START_CON = 3, + WAIT_STOP = 4 + }; + + UWORD8 *state = &l1a.state[L1A_VM_AMR_RECORD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE; + l1a_l1s_com.voicememo_amr_task.record.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_VM_AMR_RECORD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.voicememo_amr_task.record.parameters.session_id = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.voicememo_amr_task.record.parameters.maximum_size = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->maximum_size; + l1a_l1s_com.voicememo_amr_task.record.parameters.dtx = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->dtx_used; + l1a_l1s_com.voicememo_amr_task.record.parameters.amr_vocoder = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->amr_vocoder; + + // Download UL/DL audio gain to the NDB + l1s_dsp_com.dsp_ndb_ptr->d_shiftul = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->record_coeff_ul; + + if(l1a.dyn_dwnld.semaphore_vect[VOICE_MEMO_AMR_SM]==GREEN) + { + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state + // Start the L1S voice memo recording task + l1a_l1s_com.voicememo_amr_task.record.command.start = TRUE; + + *state = WAIT_START_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"VOICE MEMO AMR SM blocked \r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[VOICE_MEMO_AMR_SM] == GREEN)) + { + // Start the L1S voice memo recording task + l1a_l1s_com.voicememo_amr_task.record.command.start = TRUE; + *state = WAIT_START_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[32]; + sprintf(str,"VOICE MEMO AMR SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_START_CON: + { + if (SignalCode == L1_VM_AMR_RECORD_START_CON) + { + // Reset the start command + l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_RECORD_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_VM_AMR_RECORD_STOP_REQ) + { + // Stop the L1S voice memo recording task + l1a_l1s_com.voicememo_amr_task.record.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_VM_AMR_RECORD_STOP_CON) + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_VM_AMR_RECORD_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + +#else // L1_DYN_DSP_DWNLD = 0 + + /*-------------------------------------------------------*/ + /* l1a_mmi_vm_amr_playing_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* voice memorization playing feature. */ + /* */ + /* Starting messages: MMI_VM_AMR_PLAY_START_REQ */ + /* */ + /* Result messages (input): L1_VM_AMR_PLAY_START_CON */ + /* */ + /* Result messages (output): MMI_VM_AMR_PLAY_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_VM_AMR_PLAY_STOP_REQ */ + /* L1_VM_AMR_PLAY_STOP_CON */ + /* */ + /* Stop message (output): MMI_VM_AMR_PLAY_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + + void l1a_mmi_vm_amr_playing_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3, + VM_AMR_PLAY = 4, + VM_AMR_PAUSE = 5, + VM_AMR_PAUSE_CON = 6, + WAIT_RESUME_CON = 7 + + }; + + UWORD8 *state = &l1a.state[L1A_VM_AMR_PLAY_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.stop = FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.pause = FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.resume = FALSE; + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_VM_AMR_PLAY_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.voicememo_amr_task.play.parameters.session_id = ((T_MMI_VM_AMR_PLAY_REQ *)(msg->SigP))->session_id; + + // Start the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_VM_AMR_PLAY_START_CON) + { + // Reset the start command + l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_START_CON); + + *state = VM_AMR_PLAY ; + } + + // End process + return; + } + break; + + case WAIT_STOP: + { + if (SignalCode == L1_VM_AMR_PLAY_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + case VM_AMR_PLAY: + { + switch (SignalCode) + { + case MMI_VM_AMR_PAUSE_REQ: + { + // Stop the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.pause= TRUE; + *state = VM_AMR_PAUSE_CON; + + } + break; + case MMI_VM_AMR_PLAY_STOP_REQ: + { + // Stop the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.stop = TRUE; + *state=WAIT_STOP; + + } + break; + case L1_VM_AMR_PLAY_STOP_CON: + { + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + break; + } + return; + } + + case VM_AMR_PAUSE_CON: + { + if(SignalCode==L1_VM_AMR_PAUSE_CON) + { + // Send confirmation to upper layers + l1a_audio_send_confirmation(MMI_VM_AMR_PAUSE_CON); + + // Change state + *state=VM_AMR_PAUSE; + } + else if(SignalCode== L1_VM_AMR_PLAY_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + return; + } // case WAIT_PAUSE_CON + // ************* + // * VM_AMR_PAUSE * + // ************* + case VM_AMR_PAUSE: + { + switch(SignalCode) + { + // * MMI requests VM_AMR resume * + case MMI_VM_AMR_RESUME_REQ: + { + l1a_l1s_com.voicememo_amr_task.play.command.pause= FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.resume=TRUE; + + // Change state + *state=WAIT_RESUME_CON; + + } + break; + // *-----------------------* + // * MMI requests VM_AMR stop * + // *-----------------------* + case MMI_VM_AMR_PLAY_STOP_REQ: + { + // Store stop request in L1A/HISR interface + l1a_l1s_com.voicememo_amr_task.play.command.stop=TRUE; + + // Change state + *state=WAIT_STOP; + + } + break; + case L1_VM_AMR_PLAY_STOP_CON: + { + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + break; + } + return; + } + // case VM_AMR_PAUSE + // ******************* + // * WAIT_RESUME_CON * + // ******************* + case WAIT_RESUME_CON: + { + if(SignalCode==L1_VM_AMR_RESUME_CON) + { + l1a_l1s_com.voicememo_amr_task.play.command.resume=FALSE; + // Send confirmation to upper layers + l1a_audio_send_confirmation(MMI_VM_AMR_RESUME_CON); + + // Change state + *state=VM_AMR_PLAY; + } + return; + } // case WAIT_RESUME_CON + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_vm_amr_recording_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* voice memorization recording feature. */ + /* */ + /* Starting messages: MMI_VM_AMR_RECORD_START_REQ */ + /* */ + /* Result messages (input): L1_VM_AMR_RECORD_START_CON */ + /* */ + /* Result messages (output): MMI_VM_AMR_RECORD_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_VM_AMR_RECORD_STOP_REQ */ + /* L1_VM_AMR_RECORD_STOP_CON */ + /* */ + /* Stop message (output): MMI_VM_AMR_RECORD_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + + void l1a_mmi_vm_amr_recording_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_VM_AMR_RECORD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE; + l1a_l1s_com.voicememo_amr_task.record.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_VM_AMR_RECORD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.voicememo_amr_task.record.parameters.session_id = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.voicememo_amr_task.record.parameters.maximum_size = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->maximum_size; + l1a_l1s_com.voicememo_amr_task.record.parameters.dtx = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->dtx_used; + l1a_l1s_com.voicememo_amr_task.record.parameters.amr_vocoder = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->amr_vocoder; + + // Download UL/DL audio gain to the NDB + l1s_dsp_com.dsp_ndb_ptr->d_shiftul = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->record_coeff_ul; + + // Start the L1S voice memo recording task + l1a_l1s_com.voicememo_amr_task.record.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_VM_AMR_RECORD_START_CON) + { + // Reset the start command + l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_RECORD_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_VM_AMR_RECORD_STOP_REQ) + { + // Stop the L1S voice memo recording task + l1a_l1s_com.voicememo_amr_task.record.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_VM_AMR_RECORD_STOP_CON) + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_VM_AMR_RECORD_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // L1_DYN_DSP_DWNLD + #endif // L1_VOICE_MEMO_AMR + + #if (SPEECH_RECO) + #if(L1_DYN_DSP_DWNLD == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_sr_enroll_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition enrollment feature. */ + /* */ + /* Starting messages: MMI_SR_ENROLL_START_REQ */ + /* */ + /* Result messages (input): L1_SR_ENROLL_START_CON */ + /* */ + /* Result messages (output): MMI_SR_ENROLL_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_ENROLL_STOP_REQ */ + /* L1_SR_ENROLL_STOP_CON */ + /* */ + /* Stop message (output): MMI_SR_ENROLL_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_sr_enroll_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_START_CON = 3, + WAIT_STOP = 4, + WAIT_BACK_TASK_DONE = 5, + WAIT_L1S_STOP = 6, + WAIT_BACK_STOP = 7 + }; + + UWORD8 *state = &l1a.state[L1A_SR_ENROLL_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #else + xSignalHeaderRec *conf_msg; + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.enroll_start = FALSE; + l1a_l1s_com.speechreco_task.command.enroll_stop = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_ENROLL_START_REQ) + { + // Download the message parameters to the parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.word_index = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + l1a_l1s_com.speechreco_task.parameters.speech = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech; + l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech_address; + + if(l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM]==GREEN) + { + + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition enrollment task + l1a_l1s_com.speechreco_task.command.enroll_start = TRUE; + + *state = WAIT_START_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + break; + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN)) + { + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition enrollment task + l1a_l1s_com.speechreco_task.command.enroll_start = TRUE; + *state = WAIT_START_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + break; + case WAIT_START_CON: + { + if (SignalCode == L1_SR_ENROLL_START_CON) + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.enroll_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_ENROLL_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_SR_ENROLL_STOP_REQ) + { + // Stop the speech recognition enroll task + l1a_l1s_com.speechreco_task.command.enroll_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SR_ENROLL_STOP_CON) + { + // There is an error during the acquisition task? + if ( ((T_L1_SR_ENROLL_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task + l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ); + + *state = WAIT_BACK_TASK_DONE; + + // End process + return; + } + else + // There is an error + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_SR_ENROLL_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_TASK_DONE: + { + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the stop confirmation message with no error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_NO_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig( sizeof(T_MMI_SR_ENROLL_STOP_CON) ); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON; + + //Fill the message + ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + + } + else + if (SignalCode == MMI_SR_ENROLL_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + + // End process + return; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON; + + //Fill the message + ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if (SignalCode == L1_SR_ENROLL_STOP_CON) + { + // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON; + + //Fill the message + ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_sr_update_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition update feature. */ + /* */ + /* Starting messages: MMI_SR_UPDATE_START_REQ */ + /* */ + /* Result messages (input): L1_SR_UPDATE_START_CON */ + /* */ + /* Result messages (output): MMI_SR_UPDATE_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_UPDATE_STOP_REQ */ + /* L1_SR_UPDATE_STOP_CON */ + /* */ + /* Stop message (output): MMI_SR_UPDATE_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_sr_update_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_MODEL_LOADED = 3, + WAIT_START_CON = 4, + WAIT_STOP = 5, + WAIT_BACK_TASK_DONE = 6, + WAIT_L1S_STOP = 7, + WAIT_BACK_STOP = 8 + }; + + UWORD8 *state = &l1a.state[L1A_SR_UPDATE_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #else + xSignalHeaderRec *conf_msg; + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.update_stop = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_UPDATE_START_REQ) + { + // Download the message parameters to the parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.word_index = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + l1a_l1s_com.speechreco_task.parameters.speech = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech; + l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech_address; + + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + + if(l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN) + { + + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state + // Start to download the model to the API + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_UPDATE_START_CON); + + *state = WAIT_MODEL_LOADED; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + break; + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN)) + { + // Start to download the model to the API + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_UPDATE_START_CON); + + *state = WAIT_MODEL_LOADED; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + + } + return; + } + break; + case WAIT_MODEL_LOADED: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + else + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + } + else + if (SignalCode == L1_SR_UPDATE_START_CON) + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + + *state = WAIT_STOP; + } + + // End process + return; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SR_UPDATE_STOP_CON) + { + // There is an error during the update task? + if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task + l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ); + + *state = WAIT_BACK_TASK_DONE; + + // End process + return; + } + else + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_SR_UPDATE_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_TASK_DONE: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + else + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an acquisition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_NO_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON) || + (SignalCode == L1_SRBACK_LOAD_MODEL_CON) ) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if (SignalCode == L1_SR_UPDATE_STOP_CON) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_sr_reco_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition reco feature. */ + /* */ + /* Starting messages: MMI_SR_RECO_START_REQ */ + /* */ + /* Result messages (input): L1_SR_RECO_START_CON */ + /* */ + /* Result messages (output): MMI_SR_RECO_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_RECO_STOP_REQ */ + /* L1_SR_RECO_STOP_IND */ + /* */ + /* Stop message (output): MMI_SR_RECO_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_sr_reco_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_RECO_START = 3, + WAIT_RECO_STOP = 4, + LOAD_MODEL = 5, + WAIT_MODEL_LOADED = 6, + WAIT_PROCESSING_STOP = 7, + WAIT_L1S_STOP = 8, + WAIT_BACK_STOP = 9 + }; + + UWORD8 *state = &l1a.state[L1A_SR_RECO_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #else + xSignalHeaderRec *conf_msg; + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.reco_start = FALSE; + l1a_l1s_com.speechreco_task.command.reco_stop = FALSE; + l1a_l1s_com.speechreco_task.command.processing_start = FALSE; + l1a_l1s_com.speechreco_task.command.processing_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_RECO_START_REQ) + { + // Reset the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter = 0; + + // Download the parameters to the l1a_l1s_com.speechreco_task.parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.vocabulary_size = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->vocabulary_size; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + + // The CTO algorithm must be used? + if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO) + { + // Enable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE; + + // Double the vocabulary size + l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1; + } + else + { + // Disable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + } + + if (l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN) + { + + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state + // Start the speech recognition reco task + l1a_l1s_com.speechreco_task.command.reco_start = TRUE; + + *state = WAIT_RECO_START; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + // End process + return; + } + break; + + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN)) + { + // Start the speech recognition reco task + l1a_l1s_com.speechreco_task.command.reco_start = TRUE; + *state = WAIT_RECO_START; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + + } + return; + } + break; + case WAIT_RECO_START: + { + if (SignalCode == L1_SR_RECO_START_CON) + { + // Reset the start command + l1a_l1s_com.speechreco_task.command.reco_start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_RECO_START_CON); + + *state = WAIT_RECO_STOP; + } + // End process + return; + } + break; + + case WAIT_RECO_STOP: + { + if (SignalCode == L1_SR_RECO_STOP_CON) + { + // The acqusition is good or not? + if ( ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + *state = LOAD_MODEL; + } + else + { + // Send the message MMI_SR_RECO_STOP_CON with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // File the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + } + else + if(SignalCode == MMI_SR_RECO_STOP_REQ) + { + // Stop the speech recognition task + l1a_l1s_com.speechreco_task.command.reco_stop = TRUE; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + { + // End process + return; + } + } + break; + + case LOAD_MODEL: + { + // Initialize the background task stop command + l1_srback_com.emergency_stop = FALSE; + + // Start to load the model to the API + l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter; + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Increase the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter++; + + *state = WAIT_MODEL_LOADED; + + // End process + return; + } + break; + + case WAIT_MODEL_LOADED: + { + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Start the DSP processing task + l1a_l1s_com.speechreco_task.command.processing_start = TRUE; + + *state = WAIT_PROCESSING_STOP; + } + else + if (SignalCode == MMI_SR_RECO_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + + // End process + return; + } + break; + + case WAIT_PROCESSING_STOP: + { + if (SignalCode == L1_SR_PROCESSING_STOP_CON) + { + // The processing phase is good or not? + if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + *state = LOAD_MODEL; + } + else + { + // Send the MMI_SR_RECO_STOP_CON message with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // File the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + } + else + if (SignalCode == L1_SR_RECO_STOP_IND) + { + // The CTO algorithm is used? + if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm) + { + // There is an error during the recognition? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // The best word is odd? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 ) + { + // Change the error to tSC_CTO_WORD + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD; + } + else + { + // Devided by 2 the 4 indexes of the best words in the message + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index >>= 1; + } + } + } + // Forward the message in the MMI_SR_RECO_STOP_CON + l1a_audio_send_result(MMI_SR_RECO_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + if (SignalCode == MMI_SR_RECO_STOP_REQ) + { + // Stop the L1S processing task + l1a_l1s_com.speechreco_task.command.processing_stop = TRUE; + + *state = WAIT_L1S_STOP; + + // end process + return; + } + else + { + // end process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if ( (SignalCode == L1_SR_PROCESSING_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_IND) ) + { + // Send the message MMI_SR_RECO_STOP_CON with a bad recognition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // File the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Send the MMI_SR_RECO_STOP_CON with an bad recognition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // Fill the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*---------------------------------------------------------*/ + /* l1a_mmi_sr_update_check_process() */ + /*---------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition update check feature. */ + /* */ + /* Starting messages: MMI_SR_UPDATE_CHECK_START_REQ */ + /* */ + /* Result messages (input): L1_SR_UPDATE_START_CON */ + /* */ + /* Result messages (output): MMI_SR_UPDATE_CHECK_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_UPDATE_CHECK_STOP_REQ */ + /* L1_SR_RECO_STOP_IND */ + /* */ + /* Stop message (output): MMI_SR_UPDATE_CHECK_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*---------------------------------------------------------*/ + void l1a_mmi_sr_update_check_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_MODEL = 3, + WAIT_UPDATE_START = 4, + WAIT_UPDATE_STOP = 5, + WAIT_TEMP_SAVE_DONE = 6, + LOAD_MODEL = 7, + WAIT_MODEL_LOADED = 8, + WAIT_PROCESSING_STOP = 9, + WAIT_SAVE_DONE = 10, + WAIT_L1S_STOP = 11, + WAIT_BACK_STOP = 12 + }; + + UWORD8 *state = &l1a.state[L1A_SR_UPDATE_CHECK_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #define AUDIO_MSG (p_message) + #else + xSignalHeaderRec *conf_msg; + #define AUDIO_MSG (conf_msg->SigP) + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.update_stop = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if(SignalCode == MMI_SR_UPDATE_CHECK_START_REQ) + { + // Download the message parameters to the parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.word_index = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.word_to_check = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + l1a_l1s_com.speechreco_task.parameters.model_temp_address = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->model_address; + l1a_l1s_com.speechreco_task.parameters.speech = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech; + l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech_address; + l1a_l1s_com.speechreco_task.parameters.vocabulary_size = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->vocabulary_size; + + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + + if (l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN) + { + + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state + // Start to download the model to the API + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_UPDATE_CHECK_START_CON); + + *state = WAIT_MODEL; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + break; + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN)) + { + + // Start to download the model to the API + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_UPDATE_CHECK_START_CON); + + *state = WAIT_MODEL; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + + } + return; + } + break; + case WAIT_MODEL: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + else + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_start = TRUE; + + *state = WAIT_UPDATE_START; + } + + // End process + return; + } + break; + + case WAIT_UPDATE_START: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + } + else + if (SignalCode == L1_SR_UPDATE_START_CON) + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + + *state = WAIT_UPDATE_STOP; + } + + // End process + return; + } + break; + + case WAIT_UPDATE_STOP: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SR_UPDATE_STOP_CON) + { + // There is an error during the update task? + if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task + l1_send_sr_background_msg(L1_SRBACK_TEMP_SAVE_DATA_REQ); + + *state = WAIT_TEMP_SAVE_DONE; + + // End process + return; + } + else + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + } + else + { + // End process + return; + } + } + break; + + case WAIT_TEMP_SAVE_DONE: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON) + { + // Reset the command + l1a_l1s_com.speechreco_task.command.processing_start = FALSE; + l1a_l1s_com.speechreco_task.command.processing_stop = FALSE; + + // Reset the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter = 0; + + // The CTO algorithm must be used? + if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO) + { + // Enable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE; + + // Double the vocabulary size + l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1; + } + else + { + // Disable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + } + + *state = LOAD_MODEL; + } + else + { + // End process + return; + } + } + break; + + case LOAD_MODEL: + { + // Initialize the background task stop command + l1_srback_com.emergency_stop = FALSE; + + // Start to load the model to the API + l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter; + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Increase the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter++; + + *state = WAIT_MODEL_LOADED; + + // End process + return; + } + break; + + case WAIT_MODEL_LOADED: + { + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Start the DSP processing task + l1a_l1s_com.speechreco_task.command.processing_start = TRUE; + + *state = WAIT_PROCESSING_STOP; + } + else + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + + // End process + return; + } + break; + + case WAIT_PROCESSING_STOP: + { + if (SignalCode == L1_SR_PROCESSING_STOP_CON) + { + // The processing phase is good or not? + if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + *state = LOAD_MODEL; + } + else + { + // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + // File the message + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + } + else + if (SignalCode == L1_SR_RECO_STOP_IND) + { + // There is an error during the recognition? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // The CTO algorithm is used? + if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm) + { + // The best word is odd? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 ) + { + // Change the error to SC_CTO_WORD + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD; + + // Forward the message in the MMI_SR_RECO_STOP_CON + l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + + // End process + return; + } + else + { + // Devided by 2 the 4 indexes of the best words in the message + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index >>= 1; + } + } + // Is it the good word? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index == + l1a_l1s_com.speechreco_task.parameters.word_to_check ) + { + // Save the message informations in the l1a_l1s_com memory + l1a_l1s_com.speechreco_task.parameters.best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index; + l1a_l1s_com.speechreco_task.parameters.best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_score; + l1a_l1s_com.speechreco_task.parameters.second_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index; + l1a_l1s_com.speechreco_task.parameters.second_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_score; + l1a_l1s_com.speechreco_task.parameters.third_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index; + l1a_l1s_com.speechreco_task.parameters.third_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_score; + l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index; + l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_score; + l1a_l1s_com.speechreco_task.parameters.d_sr_db_level = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_level; + l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_noise; + l1a_l1s_com.speechreco_task.parameters.d_sr_model_size = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_model_size; + + // Reset the stop background task + l1_srback_com.emergency_stop = FALSE; + + // Start the background task to save the model in the database + l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.word_to_check; + l1a_l1s_com.speechreco_task.parameters.model_address = l1a_l1s_com.speechreco_task.parameters.model_temp_address; + l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ); + + *state = WAIT_SAVE_DONE; + + // End process + return; + } + else + { + // Change the error to SC_CHECK_ERROR + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CHECK_ERROR; + } + } + // Forward the message in the MMI_SR_RECO_STOP_CON + l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop the L1S processing task + l1a_l1s_com.speechreco_task.command.processing_stop = TRUE; + + *state = WAIT_L1S_STOP; + + // end process + return; + } + else + { + // end process + return; + } + } + break; + + case WAIT_SAVE_DONE: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + #endif // OP_RIV_AUDIO + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->error_id = SC_NO_ERROR; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_index = l1a_l1s_com.speechreco_task.parameters.best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_score = l1a_l1s_com.speechreco_task.parameters.best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_index = l1a_l1s_com.speechreco_task.parameters.second_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_score = l1a_l1s_com.speechreco_task.parameters.second_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_index = l1a_l1s_com.speechreco_task.parameters.third_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_score = l1a_l1s_com.speechreco_task.parameters.third_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_index = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_score = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_level = l1a_l1s_com.speechreco_task.parameters.d_sr_db_level; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_noise = l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_model_size = l1a_l1s_com.speechreco_task.parameters.d_sr_model_size; + + #if (OP_RIV_AUDIO == 1) + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON) || + (SignalCode == L1_SRBACK_LOAD_MODEL_CON) || + (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON) ) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = SC_CHECK_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if ( (SignalCode == L1_SR_UPDATE_STOP_CON) || + (SignalCode == L1_SR_PROCESSING_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_IND) ) + { + // Send the message MMI_SR_UPDATE_CHECK_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = SC_CHECK_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + + // Undefine message pointer macro. + #undef MSG_AUDIO + + } + #else // L1_DYN_DSP_DWNLD = 0 + /*-------------------------------------------------------*/ + /* l1a_mmi_sr_enroll_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition enrollment feature. */ + /* */ + /* Starting messages: MMI_SR_ENROLL_START_REQ */ + /* */ + /* Result messages (input): L1_SR_ENROLL_START_CON */ + /* */ + /* Result messages (output): MMI_SR_ENROLL_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_ENROLL_STOP_REQ */ + /* L1_SR_ENROLL_STOP_CON */ + /* */ + /* Stop message (output): MMI_SR_ENROLL_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_sr_enroll_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3, + WAIT_BACK_TASK_DONE = 4, + WAIT_L1S_STOP = 5, + WAIT_BACK_STOP = 6 + }; + + UWORD8 *state = &l1a.state[L1A_SR_ENROLL_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #else + xSignalHeaderRec *conf_msg; + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.enroll_start = FALSE; + l1a_l1s_com.speechreco_task.command.enroll_stop = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_ENROLL_START_REQ) + { + // Download the message parameters to the parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.word_index = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + l1a_l1s_com.speechreco_task.parameters.speech = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech; + l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech_address; + + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition enrollment task + l1a_l1s_com.speechreco_task.command.enroll_start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_SR_ENROLL_START_CON) + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.enroll_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_ENROLL_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_SR_ENROLL_STOP_REQ) + { + // Stop the speech recognition enroll task + l1a_l1s_com.speechreco_task.command.enroll_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SR_ENROLL_STOP_CON) + { + // There is an error during the acquisition task? + if ( ((T_L1_SR_ENROLL_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task + l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ); + + *state = WAIT_BACK_TASK_DONE; + + // End process + return; + } + else + // There is an error + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_SR_ENROLL_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_TASK_DONE: + { + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the stop confirmation message with no error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_NO_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig( sizeof(T_MMI_SR_ENROLL_STOP_CON) ); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON; + + //Fill the message + ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + + } + else + if (SignalCode == MMI_SR_ENROLL_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + + // End process + return; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON; + + //Fill the message + ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if (SignalCode == L1_SR_ENROLL_STOP_CON) + { + // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON; + + //Fill the message + ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_sr_update_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition update feature. */ + /* */ + /* Starting messages: MMI_SR_UPDATE_START_REQ */ + /* */ + /* Result messages (input): L1_SR_UPDATE_START_CON */ + /* */ + /* Result messages (output): MMI_SR_UPDATE_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_UPDATE_STOP_REQ */ + /* L1_SR_UPDATE_STOP_CON */ + /* */ + /* Stop message (output): MMI_SR_UPDATE_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_sr_update_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_MODEL_LOADED = 2, + WAIT_START_CON = 3, + WAIT_STOP = 4, + WAIT_BACK_TASK_DONE = 5, + WAIT_L1S_STOP = 6, + WAIT_BACK_STOP = 7 + }; + + UWORD8 *state = &l1a.state[L1A_SR_UPDATE_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #else + xSignalHeaderRec *conf_msg; + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.update_stop = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_UPDATE_START_REQ) + { + // Download the message parameters to the parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.word_index = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + l1a_l1s_com.speechreco_task.parameters.speech = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech; + l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech_address; + + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Start to download the model to the API + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_UPDATE_START_CON); + + *state = WAIT_MODEL_LOADED; + } + + // End process + return; + } + break; + + case WAIT_MODEL_LOADED: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + else + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + } + else + if (SignalCode == L1_SR_UPDATE_START_CON) + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + + *state = WAIT_STOP; + } + + // End process + return; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SR_UPDATE_STOP_CON) + { + // There is an error during the update task? + if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task + l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ); + + *state = WAIT_BACK_TASK_DONE; + + // End process + return; + } + else + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_SR_UPDATE_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_TASK_DONE: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + else + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an acquisition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_NO_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON) || + (SignalCode == L1_SRBACK_LOAD_MODEL_CON) ) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if (SignalCode == L1_SR_UPDATE_STOP_CON) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_sr_reco_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition reco feature. */ + /* */ + /* Starting messages: MMI_SR_RECO_START_REQ */ + /* */ + /* Result messages (input): L1_SR_RECO_START_CON */ + /* */ + /* Result messages (output): MMI_SR_RECO_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_RECO_STOP_REQ */ + /* L1_SR_RECO_STOP_IND */ + /* */ + /* Stop message (output): MMI_SR_RECO_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_sr_reco_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_RECO_START = 2, + WAIT_RECO_STOP = 3, + LOAD_MODEL = 4, + WAIT_MODEL_LOADED = 5, + WAIT_PROCESSING_STOP = 6, + WAIT_L1S_STOP = 7, + WAIT_BACK_STOP = 8 + }; + + UWORD8 *state = &l1a.state[L1A_SR_RECO_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #else + xSignalHeaderRec *conf_msg; + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.reco_start = FALSE; + l1a_l1s_com.speechreco_task.command.reco_stop = FALSE; + l1a_l1s_com.speechreco_task.command.processing_start = FALSE; + l1a_l1s_com.speechreco_task.command.processing_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_RECO_START_REQ) + { + + // Reset the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter = 0; + + // Download the parameters to the l1a_l1s_com.speechreco_task.parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.vocabulary_size = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->vocabulary_size; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + + // The CTO algorithm must be used? + if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO) + { + // Enable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE; + + // Double the vocabulary size + l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1; + } + else + { + // Disable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + } + + // Start the speech recognition reco task + l1a_l1s_com.speechreco_task.command.reco_start = TRUE; + + *state = WAIT_RECO_START; + } + + // End process + return; + } + break; + + + case WAIT_RECO_START: + { + if (SignalCode == L1_SR_RECO_START_CON) + { + // Reset the start command + l1a_l1s_com.speechreco_task.command.reco_start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_RECO_START_CON); + + *state = WAIT_RECO_STOP; + } + // End process + return; + } + break; + + case WAIT_RECO_STOP: + { + if (SignalCode == L1_SR_RECO_STOP_CON) + { + // The acqusition is good or not? + if ( ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + *state = LOAD_MODEL; + } + else + { + // Send the message MMI_SR_RECO_STOP_CON with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // File the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + } + else + if(SignalCode == MMI_SR_RECO_STOP_REQ) + { + // Stop the speech recognition task + l1a_l1s_com.speechreco_task.command.reco_stop = TRUE; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + { + // End process + return; + } + } + break; + + case LOAD_MODEL: + { + // Initialize the background task stop command + l1_srback_com.emergency_stop = FALSE; + + // Start to load the model to the API + l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter; + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Increase the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter++; + + *state = WAIT_MODEL_LOADED; + + // End process + return; + } + break; + + case WAIT_MODEL_LOADED: + { + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Start the DSP processing task + l1a_l1s_com.speechreco_task.command.processing_start = TRUE; + + *state = WAIT_PROCESSING_STOP; + } + else + if (SignalCode == MMI_SR_RECO_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + + // End process + return; + } + break; + + case WAIT_PROCESSING_STOP: + { + if (SignalCode == L1_SR_PROCESSING_STOP_CON) + { + // The processing phase is good or not? + if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + *state = LOAD_MODEL; + } + else + { + // Send the MMI_SR_RECO_STOP_CON message with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // File the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + } + else + if (SignalCode == L1_SR_RECO_STOP_IND) + { + // The CTO algorithm is used? + if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm) + { + // There is an error during the recognition? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // The best word is odd? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 ) + { + // Change the error to tSC_CTO_WORD + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD; + } + else + { + // Devided by 2 the 4 indexes of the best words in the message + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index >>= 1; + } + } + } + // Forward the message in the MMI_SR_RECO_STOP_CON + l1a_audio_send_result(MMI_SR_RECO_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + if (SignalCode == MMI_SR_RECO_STOP_REQ) + { + // Stop the L1S processing task + l1a_l1s_com.speechreco_task.command.processing_stop = TRUE; + + *state = WAIT_L1S_STOP; + + // end process + return; + } + else + { + // end process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if ( (SignalCode == L1_SR_PROCESSING_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_IND) ) + { + // Send the message MMI_SR_RECO_STOP_CON with a bad recognition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // File the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Send the MMI_SR_RECO_STOP_CON with an bad recognition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // Fill the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*---------------------------------------------------------*/ + /* l1a_mmi_sr_update_check_process() */ + /*---------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition update check feature. */ + /* */ + /* Starting messages: MMI_SR_UPDATE_CHECK_START_REQ */ + /* */ + /* Result messages (input): L1_SR_UPDATE_START_CON */ + /* */ + /* Result messages (output): MMI_SR_UPDATE_CHECK_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_UPDATE_CHECK_STOP_REQ */ + /* L1_SR_RECO_STOP_IND */ + /* */ + /* Stop message (output): MMI_SR_UPDATE_CHECK_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*---------------------------------------------------------*/ + void l1a_mmi_sr_update_check_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_MODEL = 2, + WAIT_UPDATE_START = 3, + WAIT_UPDATE_STOP = 4, + WAIT_TEMP_SAVE_DONE = 5, + LOAD_MODEL = 6, + WAIT_MODEL_LOADED = 7, + WAIT_PROCESSING_STOP = 8, + WAIT_SAVE_DONE = 9, + WAIT_L1S_STOP = 10, + WAIT_BACK_STOP = 11 + }; + + UWORD8 *state = &l1a.state[L1A_SR_UPDATE_CHECK_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #define AUDIO_MSG (p_message) + #else + xSignalHeaderRec *conf_msg; + #define AUDIO_MSG (conf_msg->SigP) + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.update_stop = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_START_REQ) + { + // Download the message parameters to the parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.word_index = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.word_to_check = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + l1a_l1s_com.speechreco_task.parameters.model_temp_address = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->model_address; + l1a_l1s_com.speechreco_task.parameters.speech = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech; + l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech_address; + l1a_l1s_com.speechreco_task.parameters.vocabulary_size = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->vocabulary_size; + + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Start to download the model to the API + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_UPDATE_CHECK_START_CON); + + *state = WAIT_MODEL; + } + + // End process + return; + } + break; + + case WAIT_MODEL: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + else + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_start = TRUE; + + *state = WAIT_UPDATE_START; + } + + // End process + return; + } + break; + + case WAIT_UPDATE_START: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + } + else + if (SignalCode == L1_SR_UPDATE_START_CON) + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + + *state = WAIT_UPDATE_STOP; + } + + // End process + return; + } + break; + + case WAIT_UPDATE_STOP: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SR_UPDATE_STOP_CON) + { + // There is an error during the update task? + if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task + l1_send_sr_background_msg(L1_SRBACK_TEMP_SAVE_DATA_REQ); + + *state = WAIT_TEMP_SAVE_DONE; + + // End process + return; + } + else + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + } + else + { + // End process + return; + } + } + break; + + case WAIT_TEMP_SAVE_DONE: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON) + { + // Reset the command + l1a_l1s_com.speechreco_task.command.processing_start = FALSE; + l1a_l1s_com.speechreco_task.command.processing_stop = FALSE; + + // Reset the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter = 0; + + // The CTO algorithm must be used? + if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO) + { + // Enable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE; + + // Double the vocabulary size + l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1; + } + else + { + // Disable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + } + + *state = LOAD_MODEL; + } + else + { + // End process + return; + } + } + break; + + case LOAD_MODEL: + { + // Initialize the background task stop command + l1_srback_com.emergency_stop = FALSE; + + // Start to load the model to the API + l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter; + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Increase the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter++; + + *state = WAIT_MODEL_LOADED; + + // End process + return; + } + break; + + case WAIT_MODEL_LOADED: + { + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Start the DSP processing task + l1a_l1s_com.speechreco_task.command.processing_start = TRUE; + + *state = WAIT_PROCESSING_STOP; + } + else + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + + // End process + return; + } + break; + + case WAIT_PROCESSING_STOP: + { + if (SignalCode == L1_SR_PROCESSING_STOP_CON) + { + // The processing phase is good or not? + if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + *state = LOAD_MODEL; + } + else + { + // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + // File the message + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + } + else + if (SignalCode == L1_SR_RECO_STOP_IND) + { + // There is an error during the recognition? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // The CTO algorithm is used? + if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm) + { + // The best word is odd? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 ) + { + // Change the error to SC_CTO_WORD + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD; + + // Forward the message in the MMI_SR_RECO_STOP_CON + l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + + // End process + return; + } + else + { + // Devided by 2 the 4 indexes of the best words in the message + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index >>= 1; + } + } + // Is it the good word? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index == + l1a_l1s_com.speechreco_task.parameters.word_to_check ) + { + // Save the message informations in the l1a_l1s_com memory + l1a_l1s_com.speechreco_task.parameters.best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index; + l1a_l1s_com.speechreco_task.parameters.best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_score; + l1a_l1s_com.speechreco_task.parameters.second_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index; + l1a_l1s_com.speechreco_task.parameters.second_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_score; + l1a_l1s_com.speechreco_task.parameters.third_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index; + l1a_l1s_com.speechreco_task.parameters.third_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_score; + l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index; + l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_score; + l1a_l1s_com.speechreco_task.parameters.d_sr_db_level = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_level; + l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_noise; + l1a_l1s_com.speechreco_task.parameters.d_sr_model_size = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_model_size; + + // Reset the stop background task + l1_srback_com.emergency_stop = FALSE; + + // Start the background task to save the model in the database + l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.word_to_check; + l1a_l1s_com.speechreco_task.parameters.model_address = l1a_l1s_com.speechreco_task.parameters.model_temp_address; + l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ); + + *state = WAIT_SAVE_DONE; + + // End process + return; + } + else + { + // Change the error to SC_CHECK_ERROR + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CHECK_ERROR; + } + } + // Forward the message in the MMI_SR_RECO_STOP_CON + l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop the L1S processing task + l1a_l1s_com.speechreco_task.command.processing_stop = TRUE; + + *state = WAIT_L1S_STOP; + + // end process + return; + } + else + { + // end process + return; + } + } + break; + + case WAIT_SAVE_DONE: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + #endif // OP_RIV_AUDIO + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->error_id = SC_NO_ERROR; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_index = l1a_l1s_com.speechreco_task.parameters.best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_score = l1a_l1s_com.speechreco_task.parameters.best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_index = l1a_l1s_com.speechreco_task.parameters.second_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_score = l1a_l1s_com.speechreco_task.parameters.second_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_index = l1a_l1s_com.speechreco_task.parameters.third_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_score = l1a_l1s_com.speechreco_task.parameters.third_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_index = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_score = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_level = l1a_l1s_com.speechreco_task.parameters.d_sr_db_level; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_noise = l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_model_size = l1a_l1s_com.speechreco_task.parameters.d_sr_model_size; + + #if (OP_RIV_AUDIO == 1) + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON) || + (SignalCode == L1_SRBACK_LOAD_MODEL_CON) || + (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON) ) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = SC_CHECK_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if ( (SignalCode == L1_SR_UPDATE_STOP_CON) || + (SignalCode == L1_SR_PROCESSING_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_IND) ) + { + // Send the message MMI_SR_UPDATE_CHECK_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = SC_CHECK_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + + // Undefine message pointer macro. + #undef MSG_AUDIO + + } + + #endif // L1_DYN_DSP_DWNLD + #endif // SPEECH_RECO + #if (AEC == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_aec_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* AEC feature. */ + /* */ + /* Starting messages: MMI_AEC_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): MMI_AEC_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ +#if 0 //(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_aec_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_AEC_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_AEC_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_AEC_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.aec_task.command.start = FALSE; + + *state = WAIT_AEC_REQ; + } + break; + + case WAIT_AEC_REQ: + { + if (SignalCode == MMI_AEC_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.aec_task.parameters.aec_control = ((T_MMI_AEC_REQ *)(msg->SigP))->aec_control; + #if (L1_NEW_AEC) + l1a_l1s_com.aec_task.parameters.cont_filter = ((T_MMI_AEC_REQ *)(msg->SigP))->cont_filter; + l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AEC_REQ *)(msg->SigP))->granularity_att; + l1a_l1s_com.aec_task.parameters.coef_smooth = ((T_MMI_AEC_REQ *)(msg->SigP))->coef_smooth; + l1a_l1s_com.aec_task.parameters.es_level_max = ((T_MMI_AEC_REQ *)(msg->SigP))->es_level_max; + l1a_l1s_com.aec_task.parameters.fact_vad = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_vad; + l1a_l1s_com.aec_task.parameters.thrs_abs = ((T_MMI_AEC_REQ *)(msg->SigP))->thrs_abs; + l1a_l1s_com.aec_task.parameters.fact_asd_fil = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_fil; + l1a_l1s_com.aec_task.parameters.fact_asd_mut = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_mut; + #endif + + #if (L1_ANR == 1) + if (l1a_l1s_com.aec_task.parameters.aec_control & 0x0004) + { + // Noise suppression enabled: enable new ANR module for backward compatibility + l1a_l1s_com.aec_task.parameters.aec_control &= ~(0x0104); // Clear noise suppression bits in AEC control + + // Enable L1S ANR task (default settings are used) + l1a_l1s_com.anr_task.parameters.anr_enable = 1; + l1a_l1s_com.anr_task.parameters.min_gain = 0x3313; + l1a_l1s_com.anr_task.parameters.div_factor_shift = -2; + l1a_l1s_com.anr_task.parameters.ns_level = 1; + l1a_l1s_com.anr_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for AEC confirmation and + // ANR confirmation would occur on the same frame + } + else + { + // Noise suppression disabled: disable ANR + l1a_l1s_com.anr_task.parameters.anr_enable = 0; + l1a_l1s_com.anr_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for AEC confirmation and + // ANR confirmation would occur on the same frame + } + #endif + if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // WARNING: The following code must be duplicated in WAIT_DYN_DWNLD state when + // activating the command at L1s level + + // Start the L1S AEC task + l1a_l1s_com.aec_task.command.start = TRUE; + + *state = WAIT_AEC_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AEC SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + break; + case WAIT_DYN_DWNLD: + { + if (SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // Start the L1S AEC task + l1a_l1s_com.aec_task.command.start = TRUE; + + *state = WAIT_AEC_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AEC SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + break; + case WAIT_AEC_CON: + { + if (SignalCode == L1_AEC_CON) + { + // Send the AEC confirmation message + l1a_audio_send_confirmation(MMI_AEC_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } +#else + void l1a_mmi_aec_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_AEC_REQ = 1, + WAIT_AEC_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AEC_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.aec_task.command.start = FALSE; + + *state = WAIT_AEC_REQ; + } + break; + + case WAIT_AEC_REQ: + { + if (SignalCode == MMI_AEC_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.aec_task.parameters.aec_control = ((T_MMI_AEC_REQ *)(msg->SigP))->aec_control; + #if (L1_NEW_AEC) + l1a_l1s_com.aec_task.parameters.cont_filter = ((T_MMI_AEC_REQ *)(msg->SigP))->cont_filter; + l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AEC_REQ *)(msg->SigP))->granularity_att; + l1a_l1s_com.aec_task.parameters.coef_smooth = ((T_MMI_AEC_REQ *)(msg->SigP))->coef_smooth; + l1a_l1s_com.aec_task.parameters.es_level_max = ((T_MMI_AEC_REQ *)(msg->SigP))->es_level_max; + l1a_l1s_com.aec_task.parameters.fact_vad = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_vad; + l1a_l1s_com.aec_task.parameters.thrs_abs = ((T_MMI_AEC_REQ *)(msg->SigP))->thrs_abs; + l1a_l1s_com.aec_task.parameters.fact_asd_fil = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_fil; + l1a_l1s_com.aec_task.parameters.fact_asd_mut = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_mut; + #endif + + #if (L1_ANR == 1) + if (l1a_l1s_com.aec_task.parameters.aec_control & 0x0004) + { + // Noise suppression enabled: enable new ANR module for backward compatibility + l1a_l1s_com.aec_task.parameters.aec_control &= ~(0x0104); // Clear noise suppression bits in AEC control + + // Enable L1S ANR task (default settings are used) + l1a_l1s_com.anr_task.parameters.anr_enable = 1; + l1a_l1s_com.anr_task.parameters.min_gain = 0x3313; + l1a_l1s_com.anr_task.parameters.div_factor_shift = -2; + l1a_l1s_com.anr_task.parameters.ns_level = 1; + l1a_l1s_com.anr_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for AEC confirmation and + // ANR confirmation would occur on the same frame + } + else + { + // Noise suppression disabled: disable ANR + l1a_l1s_com.anr_task.parameters.anr_enable = 0; + l1a_l1s_com.anr_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for AEC confirmation and + // ANR confirmation would occur on the same frame + } + #endif + + // Start the L1S AEC task + l1a_l1s_com.aec_task.command.start = TRUE; + + *state = WAIT_AEC_CON; + } + + // End process + return; + } + break; + + case WAIT_AEC_CON: + { + if (SignalCode == L1_AEC_CON) + { + // Send the AEC confirmation message + l1a_audio_send_confirmation(MMI_AEC_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // L1_DYN_DSP_DWNLD == 1 + #endif // AEC + + #if (AEC == 2) + /*-------------------------------------------------------*/ + /* l1a_mmi_aec_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* AEC feature. */ + /* */ + /* Starting messages: MMI_AEC_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): MMI_AEC_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + #if 0 //(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_aec_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_AEC_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_AEC_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_AEC_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.aec_task.command.start = FALSE; + + *state = WAIT_AEC_REQ; + } + break; + + case WAIT_AEC_REQ: + { + if (SignalCode == MMI_AQI_AEC_REQ) + { + + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.aec_task.aec_control = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_control; + + if(l1a_l1s_com.aec_task.aec_control != L1_AQI_AEC_STOP) + { + + l1a_l1s_com.aec_task.parameters.cont_filter = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.cont_filter; + l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.granularity_att; + l1a_l1s_com.aec_task.parameters.coef_smooth = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.coef_smooth; + l1a_l1s_com.aec_task.parameters.es_level_max = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.es_level_max; + l1a_l1s_com.aec_task.parameters.fact_vad = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_vad; + l1a_l1s_com.aec_task.parameters.thrs_abs = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.thrs_abs; + l1a_l1s_com.aec_task.parameters.fact_asd_fil = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_fil; + l1a_l1s_com.aec_task.parameters.fact_asd_mut = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_mut; + l1a_l1s_com.aec_task.parameters.aec_mode = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.aec_mode; + l1a_l1s_com.aec_task.parameters.mu = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.mu; + l1a_l1s_com.aec_task.parameters.scale_input_ul = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_ul; + l1a_l1s_com.aec_task.parameters.scale_input_dl = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_dl; + l1a_l1s_com.aec_task.parameters.div_dmax = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_dmax; + l1a_l1s_com.aec_task.parameters.div_swap_good = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_good; + l1a_l1s_com.aec_task.parameters.div_swap_bad = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_bad; + l1a_l1s_com.aec_task.parameters.block_init = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_init; +// l1a_l1s_com.aec_task.parameters.block_size = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_size; + + } + + if (l1a.dyn_dwnld.semaphore_vect[AEC_STATE_MACHINE] == GREEN) + { + // WARNING: The following code must be duplicated in WAIT_DYN_DWNLD state when + // activating the command at L1s level + + // Start the L1S AEC task + l1a_l1s_com.aec_task.command.start = TRUE; + + *state = WAIT_AEC_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AEC SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if (SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // Start the L1S AEC task + l1a_l1s_com.aec_task.command.start = TRUE; + + *state = WAIT_AEC_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AEC SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_AEC_CON: + { + if (SignalCode == L1_AQI_AEC_CON) + { + // Send the AEC confirmation message + l1a_audio_send_result(MMI_AQI_AEC_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #else + void l1a_mmi_aec_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_AEC_REQ = 1, + WAIT_AEC_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AEC_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.aec_task.command.start = FALSE; + + *state = WAIT_AEC_REQ; + } + break; + + case WAIT_AEC_REQ: + { + if (SignalCode == MMI_AQI_AEC_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.aec_task.aec_control = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_control; + + if(l1a_l1s_com.aec_task.aec_control != L1_AQI_AEC_STOP) + { + + l1a_l1s_com.aec_task.parameters.cont_filter = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.cont_filter; + l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.granularity_att; + l1a_l1s_com.aec_task.parameters.coef_smooth = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.coef_smooth; + l1a_l1s_com.aec_task.parameters.es_level_max = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.es_level_max; + l1a_l1s_com.aec_task.parameters.fact_vad = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_vad; + l1a_l1s_com.aec_task.parameters.thrs_abs = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.thrs_abs; + l1a_l1s_com.aec_task.parameters.fact_asd_fil = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_fil; + l1a_l1s_com.aec_task.parameters.fact_asd_mut = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_mut; + l1a_l1s_com.aec_task.parameters.aec_mode = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.aec_mode; + l1a_l1s_com.aec_task.parameters.mu = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.mu; + l1a_l1s_com.aec_task.parameters.scale_input_ul = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_ul; + l1a_l1s_com.aec_task.parameters.scale_input_dl = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_dl; + l1a_l1s_com.aec_task.parameters.div_dmax = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_dmax; + l1a_l1s_com.aec_task.parameters.div_swap_good = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_good; + l1a_l1s_com.aec_task.parameters.div_swap_bad = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_bad; + l1a_l1s_com.aec_task.parameters.block_init = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_init; +// l1a_l1s_com.aec_task.parameters.block_size = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_size; + + } + + #if (L1_ANR == 1) + if (l1a_l1s_com.aec_task.aec_control & 0x0004) + { + // Noise suppression enabled: enable new ANR module for backward compatibility + l1a_l1s_com.aec_task.aec_control &= ~(0x0104); // Clear noise suppression bits in AEC control + + // Enable L1S ANR task (default settings are used) + l1a_l1s_com.anr_task.parameters.anr_enable = 1; + l1a_l1s_com.anr_task.parameters.min_gain = 0x3313; + l1a_l1s_com.anr_task.parameters.div_factor_shift = -2; + l1a_l1s_com.anr_task.parameters.ns_level = 1; + l1a_l1s_com.anr_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for AEC confirmation and + // ANR confirmation would occur on the same frame + } + else + { + // Noise suppression disabled: disable ANR + l1a_l1s_com.anr_task.parameters.anr_enable = 0; + l1a_l1s_com.anr_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for AEC confirmation and + // ANR confirmation would occur on the same frame + } + #endif + + // Start the L1S AEC task + l1a_l1s_com.aec_task.command.start = TRUE; + + *state = WAIT_AEC_CON; + } + + // End process + return; + } + break; + + case WAIT_AEC_CON: + { + if (SignalCode == L1_AQI_AEC_CON) + { + // Send the AEC confirmation message + l1a_audio_send_result(MMI_AQI_AEC_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // L1_DYN_DSP_DWNLD == 1 + #endif // AEC == 2 + + + #if (FIR) + /*-------------------------------------------------------*/ + /* l1a_mmi_fir_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* FIR feature. */ + /* */ + /* Starting messages: MMI_AUDIO_FIR_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): MMI_AUDIO_FIR_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_fir_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_FIR_REQ = 1, + WAIT_FIR_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_FIR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.fir_task.command.start = FALSE; + + *state = WAIT_FIR_REQ; + } + break; + + case WAIT_FIR_REQ: + { + if (SignalCode == MMI_AUDIO_FIR_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.fir_task.parameters.fir_loop = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_loop; + l1a_l1s_com.fir_task.parameters.update_fir = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->update_fir; + l1a_l1s_com.fir_task.parameters.fir_ul_coefficient = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_ul_coefficient; + + // we update FIR coefficients even if L1_IIR==1 because in case of loop mode + // this is the old FIR API that is used + l1a_l1s_com.fir_task.parameters.fir_dl_coefficient = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_dl_coefficient; + + #if (L1_IIR == 1) + if (l1a_l1s_com.fir_task.parameters.update_fir & DL_FIR) + { + // FIR DL update enabled: enable new IIR/DL module for backward compatibility + + // Enable L1S IIR task + // Settings tuned to have same behavior as DL FIR + l1a_l1s_com.iir_task.parameters.iir_enable = 1; // Filter always enabled + l1a_l1s_com.iir_task.parameters.nb_iir_blocks = 0; // IIR part disabled + l1a_l1s_com.iir_task.parameters.iir_coefs = 0; + l1a_l1s_com.iir_task.parameters.nb_fir_coefs = 0x1f; + l1a_l1s_com.iir_task.parameters.fir_coefs = (WORD16 *)((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_dl_coefficient; + l1a_l1s_com.iir_task.parameters.input_scaling = 0; + l1a_l1s_com.iir_task.parameters.fir_scaling = 0; + l1a_l1s_com.iir_task.parameters.input_gain_scaling = 0; + l1a_l1s_com.iir_task.parameters.output_gain_scaling = 0; + l1a_l1s_com.iir_task.parameters.output_gain = 0xffff; // Used for IIR using in FIR mode + l1a_l1s_com.iir_task.parameters.feedback = 0; + l1a_l1s_com.iir_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for FIR confirmation and + // there is no chance that upper layer frees the memory used to store + // DL coefficients before L1S copy them into API + } + #endif + + // Start the L1S FIR task + l1a_l1s_com.fir_task.command.start = TRUE; + + *state = WAIT_FIR_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_FIR_CON: + { + if (SignalCode == L1_AUDIO_FIR_CON) + { + // Send the FIR confirmation message + l1a_audio_send_confirmation(MMI_AUDIO_FIR_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // FIR + #if (AUDIO_MODE) + /*-------------------------------------------------------*/ + /* l1a_mmi_audio_mode_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* audio mode features. */ + /* */ + /* Starting messages: MMI_AUDIO_MODE_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): MMI_AUDIO_MODE_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_audio_mode_process (xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_AUDIO_MODE_REQ = 1, + WAIT_AUDIO_MODE_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AUDIO_MODE_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.audio_mode_task.command.start = FALSE; + + *state = WAIT_AUDIO_MODE_REQ; + } + break; + + case WAIT_AUDIO_MODE_REQ: + { + if (SignalCode == MMI_AUDIO_MODE_REQ) + { + switch (((T_MMI_AUDIO_MODE *)(msg->SigP))->audio_mode) + { + case GSM_ONLY: + { + // Set the GSM only mode + l1a_l1s_com.audio_mode_task.parameters.audio_mode = B_GSM_ONLY; + break; + } + case BT_CORDLESS: + { + // Set the bluetooth cordless mode + l1a_l1s_com.audio_mode_task.parameters.audio_mode = B_BT_CORDLESS; + break; + } + case BT_HEADSET: + { + // Set the bluetooth headset mode + l1a_l1s_com.audio_mode_task.parameters.audio_mode = B_BT_HEADSET; + break; + } + default : + { + break; + } + } // switch + + // Start the L1S AUDIO MODE task + l1a_l1s_com.audio_mode_task.command.start = TRUE; + + *state = WAIT_AUDIO_MODE_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_AUDIO_MODE_CON: + { + if (SignalCode == L1_AUDIO_MODE_CON) + { + // Send the AUDIO MODE confirmation message + l1a_audio_send_confirmation(MMI_AUDIO_MODE_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // AUDIO_MODE + #if (MELODY_E2) + #if(L1_DYN_DSP_DWNLD==1) + /*-------------------------------------------------------*/ + /* l1a_mmi_melody0_e2_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* melody 0 format E2 feature. */ + /* */ + /* Starting messages: MMI_MELODY0_E2_START_REQ */ + /* */ + /* Result messages (input): L1_MELODY0_E2_START_CON */ + /* */ + /* Result messages (output): MMI_MELODY0_E2_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_MELDOY0_E2_STOP_REQ */ + /* L1_MELODY0_E2_STOP_CON */ + /* */ + /* Stop message (output): MMI_MELODY0_E2_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_melody0_e2_process(xSignalHeaderRec *msg) + { + enum states + { + M0_RESET = 0, + M0_WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + M0_WAIT_LOAD_INSTRUMENT = 3, + M0_WAIT_STOP = 4, + M0_WAIT_UNLOAD_INSTRUMENT = 5 + }; + + UWORD8 *state = &l1a.state[L1A_MELODY0_E2_STATE], i; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case M0_RESET: + { + // Reset the commands: + l1a_l1s_com.melody0_e2_task.command.start = FALSE; + l1a_l1s_com.melody0_e2_task.command.stop = FALSE; + + *state = M0_WAIT_START_REQ; + } + break; + + case M0_WAIT_START_REQ: + { + if (SignalCode == MMI_MELODY0_E2_START_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.melody0_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.melody0_e2_task.parameters.loopback = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback; + + if(l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE]==GREEN) + { + + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state +#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Disable trace DSP upon E2 MELODY activation + l1_disable_dsp_trace(); +#endif + // Reset the emergency flag + l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = FALSE; + + // Initialize the buffer parameters + l1a_l1s_com.melody0_e2_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody0_e2_task.parameters.buffer_size = 0; + l1a_l1s_com.melody0_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + l1a_l1s_com.melody0_e2_task.parameters.session_id); + + // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit + l1a_l1s_com.melody0_e2_task.parameters.buffer_size <<= 1; + + // Jump the NumberOfOscillator parameter + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + + // Read the Header of the melody description in order to download the time factor + // clean the MSB of the global time factor register + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF; + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i; + + + // Find the number of insturment of the melody (jump the header memory) + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument)); + + for (i=0; i<(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument); i++) + { + // find the beginning of the melody description (after the header field) + // and put it in the buf_ptr buffer + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i])); + } + + // Initialize the size (in byte unit) of the header + l1a_l1s_com.melody0_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument; + + // download the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 0); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_E2_START_CON); + + *state = M0_WAIT_LOAD_INSTRUMENT; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"E20 SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + return; + } + break; + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE] == GREEN)) + { + // Reset the emergency flag + l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = FALSE; + + // Initialize the buffer parameters + l1a_l1s_com.melody0_e2_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody0_e2_task.parameters.buffer_size = 0; + l1a_l1s_com.melody0_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + l1a_l1s_com.melody0_e2_task.parameters.session_id); + + // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit + l1a_l1s_com.melody0_e2_task.parameters.buffer_size <<= 1; + + // Jump the NumberOfOscillator parameter + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + + // Read the Header of the melody description in order to download the time factor + // clean the MSB of the global time factor register + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF; + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i; + + + // Find the number of insturment of the melody (jump the header memory) + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument)); + + for (i=0; i<(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument); i++) + { + // find the beginning of the melody description (after the header field) + // and put it in the buf_ptr buffer + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i])); + } + + // Initialize the size (in byte unit) of the header + l1a_l1s_com.melody0_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument; + + // download the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 0); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_E2_START_CON); + + *state = M0_WAIT_LOAD_INSTRUMENT; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"E20 SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + break; + case M0_WAIT_LOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 ) + { + // The load instrument confirmation message is for the melody 0 + if (l1a_l1s_com.melody0_e2_task.parameters.emergency_stop) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0); + + *state = M0_WAIT_UNLOAD_INSTRUMENT; + + } + else + { + // Start to play the melody0 + l1a_l1s_com.melody0_e2_task.command.start = TRUE; + + *state = M0_WAIT_STOP; + } + } + } + else + if (SignalCode == MMI_MELODY0_E2_STOP_REQ) + { + // Set the emergency flag + l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = TRUE; + } + + // End process + return; + } + break; + + case M0_WAIT_STOP: + { + if (SignalCode == L1_MELODY0_E2_STOP_CON) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0); + + *state = M0_WAIT_UNLOAD_INSTRUMENT; + } + else + if (SignalCode == MMI_MELODY0_E2_STOP_REQ) + { + // Stop the melody 0 L1S task: + l1a_l1s_com.melody0_e2_task.command.stop = TRUE; + } + + // End process + return; + } + break; + + case M0_WAIT_UNLOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 ) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_E2_STOP_CON); +#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Enable trace DSP upon E2 MELODY deactivation + l1_enable_dsp_trace(); +#endif + + *state = M0_RESET; + } + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_melody1_e2_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* melody 1 format E2 feature. */ + /* */ + /* Starting messages: MMI_MELODY1_E2_START_REQ */ + /* */ + /* Result messages (input): L1_MELODY1_E2_START_CON */ + /* */ + /* Result messages (output): MMI_MELODY1_E2_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_MELDOY0_E2_STOP_REQ */ + /* L1_MELODY1_E2_STOP_CON */ + /* */ + /* Stop message (output): MMI_MELODY1_E2_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_melody1_e2_process(xSignalHeaderRec *msg) + { + enum states + { + M1_RESET = 0, + M1_WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + M1_WAIT_LOAD_INSTRUMENT = 3, + M1_WAIT_STOP = 4, + M1_WAIT_UNLOAD_INSTRUMENT = 5 + }; + + UWORD8 *state = &l1a.state[L1A_MELODY1_E2_STATE], i; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case M1_RESET: + { + // Reset the commands: + l1a_l1s_com.melody1_e2_task.command.start = FALSE; + l1a_l1s_com.melody1_e2_task.command.stop = FALSE; + + *state = M1_WAIT_START_REQ; + } + break; + + case M1_WAIT_START_REQ: + { + if (SignalCode == MMI_MELODY1_E2_START_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.melody1_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.melody1_e2_task.parameters.loopback = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback; + + if(l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE] == GREEN) + { + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state +#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Disable trace DSP upon E2 MELODY activation + l1_disable_dsp_trace(); +#endif + // Reset the emergency flag + l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = FALSE; + + // Initialize the buffer parameters + l1a_l1s_com.melody1_e2_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody1_e2_task.parameters.buffer_size = 0; + l1a_l1s_com.melody1_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + l1a_l1s_com.melody1_e2_task.parameters.session_id); + + // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit + l1a_l1s_com.melody1_e2_task.parameters.buffer_size <<= 1; + + // Jump the NumberOfOscillator parameter + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + + // Read the Header of the melody description in order to download the time factor + // clean the MSB of the global time factor register + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF; + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i; + + + // Find the number of insturment of the melody (jump the header memory) + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument)); + + for (i=0; i<(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument); i++) + { + // find the beginning of the melody description (after the header field) + // and put it in the buf_ptr buffer + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i])); + } + + // Initialize the size (in byte unit) of the header + l1a_l1s_com.melody1_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument; + + // download the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 1); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_E2_START_CON); + + *state = M1_WAIT_LOAD_INSTRUMENT; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"E21 SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + // End process + return; + } + break; + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE] == GREEN)) + { +#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Disable trace DSP upon E2 MELODY activation + l1_disable_dsp_trace(); +#endif + // Reset the emergency flag + l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = FALSE; + + // Initialize the buffer parameters + l1a_l1s_com.melody1_e2_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody1_e2_task.parameters.buffer_size = 0; + l1a_l1s_com.melody1_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + l1a_l1s_com.melody1_e2_task.parameters.session_id); + + // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit + l1a_l1s_com.melody1_e2_task.parameters.buffer_size <<= 1; + + // Jump the NumberOfOscillator parameter + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + + // Read the Header of the melody description in order to download the time factor + // clean the MSB of the global time factor register + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF; + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i; + + + // Find the number of insturment of the melody (jump the header memory) + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument)); + + for (i=0; i<(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument); i++) + { + // find the beginning of the melody description (after the header field) + // and put it in the buf_ptr buffer + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i])); + } + + // Initialize the size (in byte unit) of the header + l1a_l1s_com.melody1_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument; + + // download the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 1); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_E2_START_CON); + + *state = M1_WAIT_LOAD_INSTRUMENT; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"E21 SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + break; + case M1_WAIT_LOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 ) + { + // The load instrument confirmation message is for the melody 1 + if (l1a_l1s_com.melody1_e2_task.parameters.emergency_stop) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1); + + *state = M1_WAIT_UNLOAD_INSTRUMENT; + + } + else + { + // Start to play the melody1 + l1a_l1s_com.melody1_e2_task.command.start = TRUE; + + *state = M1_WAIT_STOP; + } + } + } + else + if (SignalCode == MMI_MELODY1_E2_STOP_REQ) + { + // Set the emergency flag + l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = TRUE; + } + + // End process + return; + } + break; + + case M1_WAIT_STOP: + { + if (SignalCode == L1_MELODY1_E2_STOP_CON) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1); + + *state = M1_WAIT_UNLOAD_INSTRUMENT; + } + else + if (SignalCode == MMI_MELODY1_E2_STOP_REQ) + { + // Stop the melody 0 L1S task: + l1a_l1s_com.melody1_e2_task.command.stop = TRUE; + } + + // End process + return; + } + break; + + case M1_WAIT_UNLOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 ) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_E2_STOP_CON); + + *state = M1_RESET; +#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Enable trace DSP upon E2 MELODY deactivation + l1_enable_dsp_trace(); +#endif + } + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + +#else // L1_DYN_DSP_DWNLD = 0 + + /*-------------------------------------------------------*/ + /* l1a_mmi_melody0_e2_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* melody 0 format E2 feature. */ + /* */ + /* Starting messages: MMI_MELODY0_E2_START_REQ */ + /* */ + /* Result messages (input): L1_MELODY0_E2_START_CON */ + /* */ + /* Result messages (output): MMI_MELODY0_E2_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_MELDOY0_E2_STOP_REQ */ + /* L1_MELODY0_E2_STOP_CON */ + /* */ + /* Stop message (output): MMI_MELODY0_E2_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + + void l1a_mmi_melody0_e2_process(xSignalHeaderRec *msg) + { + enum states + { + M0_RESET = 0, + M0_WAIT_START_REQ = 1, + M0_WAIT_LOAD_INSTRUMENT = 2, + M0_WAIT_STOP = 3, + M0_WAIT_UNLOAD_INSTRUMENT = 4 + }; + + UWORD8 *state = &l1a.state[L1A_MELODY0_E2_STATE], i; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case M0_RESET: + { + // Reset the commands: + l1a_l1s_com.melody0_e2_task.command.start = FALSE; + l1a_l1s_com.melody0_e2_task.command.stop = FALSE; + + *state = M0_WAIT_START_REQ; + } + break; + + case M0_WAIT_START_REQ: + { + if (SignalCode == MMI_MELODY0_E2_START_REQ) + { +#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Disable trace DSP upon E2 MELODY activation + l1_disable_dsp_trace(); +#endif + // Download the parameters from the message: + l1a_l1s_com.melody0_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.melody0_e2_task.parameters.loopback = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback; + + // Reset the emergency flag + l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = FALSE; + + // Initialize the buffer parameters + l1a_l1s_com.melody0_e2_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody0_e2_task.parameters.buffer_size = 0; + l1a_l1s_com.melody0_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + l1a_l1s_com.melody0_e2_task.parameters.session_id); + + // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit + l1a_l1s_com.melody0_e2_task.parameters.buffer_size <<= 1; + + // Jump the NumberOfOscillator parameter + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + + // Read the Header of the melody description in order to download the time factor + // clean the MSB of the global time factor register + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF; + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i; + + + // Find the number of insturment of the melody (jump the header memory) + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument)); + + for (i=0; i<(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument); i++) + { + // find the beginning of the melody description (after the header field) + // and put it in the buf_ptr buffer + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i])); + } + + // Initialize the size (in byte unit) of the header + l1a_l1s_com.melody0_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument; + + // download the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 0); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_E2_START_CON); + + *state = M0_WAIT_LOAD_INSTRUMENT; + } + + // End process + return; + } + break; + + case M0_WAIT_LOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 ) + { + // The load instrument confirmation message is for the melody 0 + if (l1a_l1s_com.melody0_e2_task.parameters.emergency_stop) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0); + + *state = M0_WAIT_UNLOAD_INSTRUMENT; + + } + else + { + // Start to play the melody0 + l1a_l1s_com.melody0_e2_task.command.start = TRUE; + + *state = M0_WAIT_STOP; + } + } + } + else + if (SignalCode == MMI_MELODY0_E2_STOP_REQ) + { + // Set the emergency flag + l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = TRUE; + } + + // End process + return; + } + break; + + case M0_WAIT_STOP: + { + if (SignalCode == L1_MELODY0_E2_STOP_CON) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0); + + *state = M0_WAIT_UNLOAD_INSTRUMENT; + } + else + if (SignalCode == MMI_MELODY0_E2_STOP_REQ) + { + // Stop the melody 0 L1S task: + l1a_l1s_com.melody0_e2_task.command.stop = TRUE; + } + + // End process + return; + } + break; + + case M0_WAIT_UNLOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 ) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_E2_STOP_CON); + + *state = M0_RESET; +#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Enable trace DSP upon E2 MELODY deactivation + l1_enable_dsp_trace(); +#endif + } + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_melody1_e2_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* melody 1 format E2 feature. */ + /* */ + /* Starting messages: MMI_MELODY1_E2_START_REQ */ + /* */ + /* Result messages (input): L1_MELODY1_E2_START_CON */ + /* */ + /* Result messages (output): MMI_MELODY1_E2_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_MELDOY0_E2_STOP_REQ */ + /* L1_MELODY1_E2_STOP_CON */ + /* */ + /* Stop message (output): MMI_MELODY1_E2_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_melody1_e2_process(xSignalHeaderRec *msg) + { + enum states + { + M1_RESET = 0, + M1_WAIT_START_REQ = 1, + M1_WAIT_LOAD_INSTRUMENT = 2, + M1_WAIT_STOP = 3, + M1_WAIT_UNLOAD_INSTRUMENT = 4 + }; + + UWORD8 *state = &l1a.state[L1A_MELODY1_E2_STATE], i; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case M1_RESET: + { + // Reset the commands: + l1a_l1s_com.melody1_e2_task.command.start = FALSE; + l1a_l1s_com.melody1_e2_task.command.stop = FALSE; + + *state = M1_WAIT_START_REQ; + } + break; + + case M1_WAIT_START_REQ: + { + if (SignalCode == MMI_MELODY1_E2_START_REQ) + { +#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Disable trace DSP upon E2 MELODY activation + l1_disable_dsp_trace(); +#endif + + // Download the parameters from the message: + l1a_l1s_com.melody1_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.melody1_e2_task.parameters.loopback = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback; + + // Reset the emergency flag + l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = FALSE; + + // Initialize the buffer parameters + l1a_l1s_com.melody1_e2_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody1_e2_task.parameters.buffer_size = 0; + l1a_l1s_com.melody1_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + l1a_l1s_com.melody1_e2_task.parameters.session_id); + + // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit + l1a_l1s_com.melody1_e2_task.parameters.buffer_size <<= 1; + + // Jump the NumberOfOscillator parameter + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + + // Read the Header of the melody description in order to download the time factor + // clean the MSB of the global time factor register + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF; + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i; + + + // Find the number of insturment of the melody (jump the header memory) + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument)); + + for (i=0; i<(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument); i++) + { + // find the beginning of the melody description (after the header field) + // and put it in the buf_ptr buffer + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i])); + } + + // Initialize the size (in byte unit) of the header + l1a_l1s_com.melody1_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument; + + // download the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 1); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_E2_START_CON); + + *state = M1_WAIT_LOAD_INSTRUMENT; + } + + // End process + return; + } + break; + + case M1_WAIT_LOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 ) + { + // The load instrument confirmation message is for the melody 1 + if (l1a_l1s_com.melody1_e2_task.parameters.emergency_stop) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1); + + *state = M1_WAIT_UNLOAD_INSTRUMENT; + + } + else + { + // Start to play the melody1 + l1a_l1s_com.melody1_e2_task.command.start = TRUE; + + *state = M1_WAIT_STOP; + } + } + } + else + if (SignalCode == MMI_MELODY1_E2_STOP_REQ) + { + // Set the emergency flag + l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = TRUE; + } + + // End process + return; + } + break; + + case M1_WAIT_STOP: + { + if (SignalCode == L1_MELODY1_E2_STOP_CON) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1); + + *state = M1_WAIT_UNLOAD_INSTRUMENT; + } + else + if (SignalCode == MMI_MELODY1_E2_STOP_REQ) + { + // Stop the melody 0 L1S task: + l1a_l1s_com.melody1_e2_task.command.stop = TRUE; + } + + // End process + return; + } + break; + + case M1_WAIT_UNLOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 ) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_E2_STOP_CON); + + *state = M1_RESET; +#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Enable trace DSP upon E2 MELODY deactivation + l1_enable_dsp_trace(); +#endif + } + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + #endif // L1_DYN_DSP_DWNLD + #endif // MELODY_E2 + + #if (L1_CPORT == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_cport_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* cport configuration feature. */ + /* */ + /* Starting messages: MMI_CPORT_CONFIGURE_REQ */ + /* */ + /* Result messages (input): L1_CPORT_CONFIGURE_CON */ + /* */ + /* Result messages (output): MMI_CPORT_CONFIGURE_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_cport_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_CPORT_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.cport_task.command.start = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_CPORT_CONFIGURE_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.cport_task.parameters.configuration = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->configuration; + l1a_l1s_com.cport_task.parameters.cpcfr1 = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr1; + l1a_l1s_com.cport_task.parameters.cpcfr2 = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr2; + l1a_l1s_com.cport_task.parameters.cpcfr3 = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr3; + l1a_l1s_com.cport_task.parameters.cpcfr4 = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr4; + l1a_l1s_com.cport_task.parameters.cptctl = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cptctl; + l1a_l1s_com.cport_task.parameters.cptdat = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cptdat; + l1a_l1s_com.cport_task.parameters.cpttaddr = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpttaddr; + l1a_l1s_com.cport_task.parameters.cptvs = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cptvs; + l1a_l1s_com.cport_task.parameters.ctrl = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->ctrl; + + // Start the L1S cport task + l1a_l1s_com.cport_task.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_CPORT_CONFIGURE_CON) + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_CPORT_CONFIGURE_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + break; + + } // switch + } // while(1) + } + #endif // L1_CPORT == 1 + + #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_audio_onoff_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* audio on/off feature. */ + /* */ + /* Starting messages: MMI_AUDIO_ONOFF_REQ */ + /* */ + /* Result messages (input): L1_AUDIO_ONOFF_CON */ + /* */ + /* Result messages (output): MMI_AUDIO_ONOFF_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_audio_onoff_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AUDIO_ONOFF_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.audio_onoff_task.command.start = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_AUDIO_ONOFF_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.audio_onoff_task.parameters.onoff_value = ((T_MMI_AUDIO_ONOFF_REQ *)(msg->SigP))->onoff_value; + + // Start the L1S keybeep task + l1a_l1s_com.audio_onoff_task.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_AUDIO_ONOFF_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_AUDIO_ONOFF_CON); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + #endif + + #if (L1_EXT_MCU_AUDIO_VOICE_ONOFF == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_audio_onoff_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* audio on/off feature. */ + /* */ + /* Starting messages: MMI_AUDIO_ONOFF_REQ */ + /* */ + /* Result messages (input): L1_AUDIO_ONOFF_CON */ + /* */ + /* Result messages (output): MMI_AUDIO_ONOFF_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_audio_onoff_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AUDIO_ONOFF_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.audio_onoff_task.command.start = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_AUDIO_ONOFF_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.audio_onoff_task.parameters.vul_onoff_value = ((T_MMI_AUDIO_ONOFF_REQ *)(msg->SigP))->vul_onoff_value; + l1a_l1s_com.audio_onoff_task.parameters.vdl_onoff_value = ((T_MMI_AUDIO_ONOFF_REQ *)(msg->SigP))->vdl_onoff_value; + // Start the L1S keybeep task + l1a_l1s_com.audio_onoff_task.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_START_CON: + { + if (SignalCode == L1_AUDIO_ONOFF_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_AUDIO_ONOFF_CON); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } + #endif + + + #if (L1_EXT_AUDIO_MGT == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_ext_audio_mgt_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* external audio management feature. */ + /* */ + /* Starting messages: MMI_EXT_AUDIO_MGT_START_REQ */ + /* */ + /* Result messages (input): L1_STEREOPATH_DRV_START_CON */ + /* */ + /* Result messages (output): MMI_EXT_AUDIO_MGT_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_EXT_AUDIO_MGT_STOP_REQ */ + /* L1_STEREOPATH_DRV_STOP_CON */ + /* */ + /* Stop message (output): MMI_EXT_AUDIO_MGT_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_ext_audio_mgt_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_EXT_AUDIO_MGT_STATE]; + UWORD32 SignalCode = msg->SignalCode; + UWORD8 sample_rate; + while(1) + { + switch(*state) + { + case RESET: + { +#if(L1_BT_AUDIO ==1) + midi_task_running=FALSE; +#endif + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_EXT_AUDIO_MGT_START_REQ) + { + // save global variable + l1s.ext_audio_mgt.session_id = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->session_id; + #if(L1_BT_AUDIO ==1) + l1_audio_bt_init(AUDIO_EXT_MIDI_BUFFER_SIZE); + if(bt_audio.connected_status==TRUE) + { + bt_audio.pcmconfig.bitsPerSample=16; + bt_audio.pcmconfig.numChannels =((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->mono_stereo+1; + sample_rate =((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->sampling_frequency; + bt_audio.pcmconfig.sampleRate =l1_ext_audio_get_frequencyrate(sample_rate); + bt_audio.audio_configure_callback(&bt_audio.pcmconfig); + } + #endif + if(bt_audio.connected_status==FALSE) + { + // Download the stereopath description. + l1a_l1s_com.stereopath_drv_task.parameters.sampling_frequency = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->sampling_frequency; + l1a_l1s_com.stereopath_drv_task.parameters.DMA_allocation = AUDIO_SP_DMA_ALLOC_MCU; + l1a_l1s_com.stereopath_drv_task.parameters.DMA_int_callback_fct = l1_ext_audio_mgt_dma_handler; + l1a_l1s_com.stereopath_drv_task.parameters.DMA_channel_number = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->DMA_channel_number; + l1a_l1s_com.stereopath_drv_task.parameters.data_type = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->data_type; + l1a_l1s_com.stereopath_drv_task.parameters.source_port = AUDIO_SP_SOURCE_IMIF; + l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->source_buffer_address; + l1a_l1s_com.stereopath_drv_task.parameters.element_number = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->element_number; + l1a_l1s_com.stereopath_drv_task.parameters.frame_number = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->frame_number; + l1a_l1s_com.stereopath_drv_task.parameters.mono_stereo = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->mono_stereo; + l1a_l1s_com.stereopath_drv_task.parameters.feature_identifier = AUDIO_SP_EXT_AUDIO_ID; + + // Start the L1S stereopath task + l1a_l1s_com.stereopath_drv_task.command.start = TRUE; +#if(L1_BT_AUDIO ==1) + midi_task_running=TRUE; +#endif + + *state = WAIT_START_CON; + } + else + { + l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_START_CON); + + *state = WAIT_STOP; + } + // End process + return; + } + } + // omaps00090550 break; + + case WAIT_START_CON: + { + if (SignalCode == L1_STEREOPATH_DRV_START_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_EXT_AUDIO_MGT_STOP_REQ) + { + if(bt_audio.connected_status==TRUE) + { + + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_STOP_CON); + midi_task_running=FALSE; + *state = RESET; + } + else + { + // Stop the L1S stereopath task + l1a_l1s_com.stereopath_drv_task.command.stop = TRUE; + + // End process + return; + } + } + + if (SignalCode == L1_STEREOPATH_DRV_STOP_CON) + { + + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_STOP_CON); + #if(L1_BT_AUDIO ==1) + midi_task_running=FALSE; + #endif + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // EXT_AUDIO_MGT == 1 + + #if (L1_ANR == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_anr_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* ANR feature. */ + /* */ + /* Starting messages: MMI_ANR_REQ */ + /* */ + /* Result messages (input): L1_ANR_CON */ + /* */ + /* Result messages (output): MMI_ANR_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ +#if(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_anr_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_ANR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.anr_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_ANR_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.anr_task.parameters.anr_enable = ((T_MMI_ANR_REQ *)(msg->SigP))->anr_enable; + l1a_l1s_com.anr_task.parameters.min_gain = ((T_MMI_ANR_REQ *)(msg->SigP))->min_gain; + l1a_l1s_com.anr_task.parameters.div_factor_shift = ((T_MMI_ANR_REQ *)(msg->SigP))->div_factor_shift; + l1a_l1s_com.anr_task.parameters.ns_level = ((T_MMI_ANR_REQ *)(msg->SigP))->ns_level; + + if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD + // when activating the task at L1s level + + // Enable the L1S task + l1a_l1s_com.anr_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"ANR SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + break; + case WAIT_DYN_DWNLD: + { + if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.anr_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"ANR SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_ANR_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_ANR_CON); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#else + void l1a_mmi_anr_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_ANR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.anr_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_ANR_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.anr_task.parameters.anr_enable = ((T_MMI_ANR_REQ *)(msg->SigP))->anr_enable; + l1a_l1s_com.anr_task.parameters.min_gain = ((T_MMI_ANR_REQ *)(msg->SigP))->min_gain; + l1a_l1s_com.anr_task.parameters.div_factor_shift = ((T_MMI_ANR_REQ *)(msg->SigP))->div_factor_shift; + l1a_l1s_com.anr_task.parameters.ns_level = ((T_MMI_ANR_REQ *)(msg->SigP))->ns_level; + + // Enable the L1S task + l1a_l1s_com.anr_task.command.update = TRUE; + + *state = WAIT_CON; + } + // End process + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_ANR_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_ANR_CON); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#endif // L1_DYN_DSP_DWNLD + #endif // L1_ANR +#if (L1_ANR == 2) // ANR 2.13 + /*-------------------------------------------------------*/ + /* l1a_mmi_anr_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* ANR 2.13 feature. */ + /* */ + /* Starting messages: MMI_AQI_ANR_REQ */ + /* */ + /* Result messages (input): L1_AQI_ANR_CON */ + /* */ + /* Result messages (output): MMI_AQI_ANR_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ +#if(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_anr_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_ANR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.anr_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_ANR_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.anr_task.parameters.anr_ul_control = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->anr_ul_control; + l1a_l1s_com.anr_task.parameters.control = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.control; + l1a_l1s_com.anr_task.parameters.ns_level = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.ns_level; + l1a_l1s_com.anr_task.parameters.tone_ene_th = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_ene_th; + l1a_l1s_com.anr_task.parameters.tone_cnt_th = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_cnt_th; + + if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD + // when activating the task at L1s level + + // Enable the L1S task + l1a_l1s_com.anr_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"ANR SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.anr_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"ANR SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_ANR_CON) + { + // Send the confirmation message + l1a_audio_send_result(MMI_AQI_ANR_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } +#else + void l1a_mmi_anr_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_ANR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.anr_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_ANR_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.anr_task.parameters.anr_ul_control = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->anr_ul_control; + l1a_l1s_com.anr_task.parameters.control = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.control; + l1a_l1s_com.anr_task.parameters.ns_level = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.ns_level; + l1a_l1s_com.anr_task.parameters.tone_ene_th = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_ene_th; + l1a_l1s_com.anr_task.parameters.tone_cnt_th = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_cnt_th; + + // Enable the L1S task + l1a_l1s_com.anr_task.command.update = TRUE; + + *state = WAIT_CON; + } + // End process + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_ANR_CON) + { + // Send the confirmation message + l1a_audio_send_result(MMI_AQI_ANR_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#endif // L1_DYN_DSP_DWNLD +#endif // L1_ANR + + #if (L1_IIR == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_iir_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* IIR feature. */ + /* */ + /* Starting messages: MMI_IIR_REQ */ + /* */ + /* Result messages (input): L1_IIR_CON */ + /* */ + /* Result messages (output): MMI_IIR_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_iir_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_IIR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.iir_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_IIR_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.iir_task.parameters.iir_enable = ((T_MMI_IIR_REQ *)(msg->SigP))->iir_enable; + l1a_l1s_com.iir_task.parameters.nb_iir_blocks = ((T_MMI_IIR_REQ *)(msg->SigP))->nb_iir_blocks; + l1a_l1s_com.iir_task.parameters.iir_coefs = ((T_MMI_IIR_REQ *)(msg->SigP))->iir_coefs; + l1a_l1s_com.iir_task.parameters.nb_fir_coefs = ((T_MMI_IIR_REQ *)(msg->SigP))->nb_fir_coefs; + l1a_l1s_com.iir_task.parameters.fir_coefs = ((T_MMI_IIR_REQ *)(msg->SigP))->fir_coefs; + l1a_l1s_com.iir_task.parameters.input_scaling = ((T_MMI_IIR_REQ *)(msg->SigP))->input_scaling; + l1a_l1s_com.iir_task.parameters.fir_scaling = ((T_MMI_IIR_REQ *)(msg->SigP))->fir_scaling; + l1a_l1s_com.iir_task.parameters.input_gain_scaling = ((T_MMI_IIR_REQ *)(msg->SigP))->input_gain_scaling; + l1a_l1s_com.iir_task.parameters.output_gain_scaling = ((T_MMI_IIR_REQ *)(msg->SigP))->output_gain_scaling; + l1a_l1s_com.iir_task.parameters.output_gain = ((T_MMI_IIR_REQ *)(msg->SigP))->output_gain; + l1a_l1s_com.iir_task.parameters.feedback = ((T_MMI_IIR_REQ *)(msg->SigP))->feedback; + + // Enable the L1S task + l1a_l1s_com.iir_task.command.update = TRUE; + + *state = WAIT_CON; + } + + // End process + return; + } + break; + + case WAIT_CON: + { + if (SignalCode == L1_IIR_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_IIR_CON); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + #endif // L1_IIR + + #if (L1_AGC_UL == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_agc_ul_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* AGC UL feature. */ + /* */ + /* Starting messages: MMI_AQI_AGC_UL_REQ */ + /* */ + /* Result messages (input): L1_AQI_AGC_UL_CON */ + /* */ + /* Result messages (output): MMI_AQI_AGC_UL_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ +#if(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_agc_ul_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_AGC_UL_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.agc_ul_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_AGC_UL_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.agc_ul_task.parameters.agc_ul_control = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->agc_ul_control; + l1a_l1s_com.agc_ul_task.parameters.control = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.control; + l1a_l1s_com.agc_ul_task.parameters.frame_size = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.frame_size; + l1a_l1s_com.agc_ul_task.parameters.targeted_level = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.targeted_level; + l1a_l1s_com.agc_ul_task.parameters.signal_up = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_up; + l1a_l1s_com.agc_ul_task.parameters.signal_down = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_down; + l1a_l1s_com.agc_ul_task.parameters.max_scale = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.max_scale; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta_fast = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast; + l1a_l1s_com.agc_ul_task.parameters.gain_intp_flag = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_intp_flag; + + + if (l1a.dyn_dwnld.semaphore_vect[AGC_UL_STATE_MACHINE] == GREEN) + { + // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD + // when activating the task at L1s level + + // Enable the L1S task + l1a_l1s_com.agc_ul_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AGC_UL SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[AGC_UL_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.agc_ul_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AGC_UL SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_AGC_UL_CON) + { + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_AGC_UL_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } +#else + void l1a_mmi_agc_ul_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AGC_UL_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.agc_ul_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_AGC_UL_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.agc_ul_task.parameters.agc_ul_control = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->agc_ul_control; + l1a_l1s_com.agc_ul_task.parameters.control = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.control; + l1a_l1s_com.agc_ul_task.parameters.frame_size = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.frame_size; + l1a_l1s_com.agc_ul_task.parameters.targeted_level = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.targeted_level; + l1a_l1s_com.agc_ul_task.parameters.signal_up = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_up; + l1a_l1s_com.agc_ul_task.parameters.signal_down = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_down; + l1a_l1s_com.agc_ul_task.parameters.max_scale = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.max_scale; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta_fast = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast; + l1a_l1s_com.agc_ul_task.parameters.gain_intp_flag = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_intp_flag; + + // Enable the L1S task + l1a_l1s_com.agc_ul_task.command.update = TRUE; + + *state = WAIT_CON; + } + // End process + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_AGC_UL_CON) + { + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_AGC_UL_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#endif // L1_DYN_DSP_DWNLD + +#endif // L1_AGC_UL + + +#if (L1_AGC_DL == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_agc_dl_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* AGC DL feature. */ + /* */ + /* Starting messages: MMI_AQI_AGC_DL_REQ */ + /* */ + /* Result messages (input): L1_AQI_AGC_DL_CON */ + /* */ + /* Result messages (output): MMI_AQI_AGC_DL_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ +#if(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_agc_dl_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_AGC_DL_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.agc_dl_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_AGC_DL_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.agc_dl_task.parameters.agc_dl_control = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->agc_dl_control; + l1a_l1s_com.agc_dl_task.parameters.control = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.control; + l1a_l1s_com.agc_dl_task.parameters.frame_size = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.frame_size; + l1a_l1s_com.agc_dl_task.parameters.targeted_level = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.targeted_level; + l1a_l1s_com.agc_dl_task.parameters.signal_up = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_up; + l1a_l1s_com.agc_dl_task.parameters.signal_down = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_down; + l1a_l1s_com.agc_dl_task.parameters.max_scale = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.max_scale; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta_fast = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast; + l1a_l1s_com.agc_dl_task.parameters.gain_intp_flag = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_intp_flag; + + + if (l1a.dyn_dwnld.semaphore_vect[AGC_DL_STATE_MACHINE] == GREEN) + { + // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD + // when activating the task at L1s level + + // Enable the L1S task + l1a_l1s_com.agc_dl_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AGC_DL SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[AGC_DL_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.agc_dl_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AGC_DL SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_AGC_DL_CON) + { + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_AGC_DL_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } +#else + void l1a_mmi_agc_dl_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AGC_DL_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.agc_dl_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_AGC_DL_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.agc_dl_task.parameters.agc_dl_control = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->agc_dl_control; + l1a_l1s_com.agc_dl_task.parameters.control = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.control; + l1a_l1s_com.agc_dl_task.parameters.frame_size = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.frame_size; + l1a_l1s_com.agc_dl_task.parameters.targeted_level = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.targeted_level; + l1a_l1s_com.agc_dl_task.parameters.signal_up = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_up; + l1a_l1s_com.agc_dl_task.parameters.signal_down = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_down; + l1a_l1s_com.agc_dl_task.parameters.max_scale = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.max_scale; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta_fast = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast; + l1a_l1s_com.agc_dl_task.parameters.gain_intp_flag = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_intp_flag; + + // Enable the L1S task + l1a_l1s_com.agc_dl_task.command.update = TRUE; + + *state = WAIT_CON; + } + // End process + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_AGC_DL_CON) + { + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_AGC_DL_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#endif // L1_DYN_DSP_DWNLD + +#endif // L1_AGC_DL + + + #if (L1_IIR == 2) + /*-------------------------------------------------------*/ + /* l1a_mmi_iir_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* IIR feature. */ + /* */ + /* Starting messages: MMI_AQI_IIR_DL_REQ */ + /* */ + /* Result messages (input): L1_AQI_IIR_DL_CON */ + /* */ + /* Result messages (output): MMI_AQI_IIR_DL_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_iir_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_IIR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.iir_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_IIR_DL_REQ) + { + l1a.iir_req_msg_ptr = msg; + l1a.l1_msg_forwarded = TRUE; + + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.iir_task.parameters = (T_MMI_AQI_IIR_DL_REQ *) (msg->SigP); + + // Enable the L1S task + l1a_l1s_com.iir_task.command.update = TRUE; + + *state = WAIT_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_CON: + { + if (SignalCode == L1_AQI_IIR_DL_CON) + { + os_free_sig(l1a.iir_req_msg_ptr); + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_IIR_DL_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } + #endif // L1_IIR + + #if (L1_WCM == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_wcm_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* WCM feature. */ + /* */ + /* Starting messages: MMI_AQI_WCM_REQ */ + /* */ + /* Result messages (input): L1_AQI_WCM_CON */ + /* */ + /* Result messages (output): MMI_AQI_WCM_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ + +#if(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_wcm_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_WCM_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.wcm_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_WCM_REQ) + { + l1a.wcm_req_msg_ptr = msg; + l1a.l1_msg_forwarded = TRUE; + + // Load the message into the l1a_l1s_com memory + l1a_l1s_com.wcm_task.parameters = (T_MMI_AQI_WCM_REQ *) (msg->SigP); + + if (l1a.dyn_dwnld.semaphore_vect[WCM_STATE_MACHINE] == GREEN) + { + // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD + // when activating the task at L1s level + + // Enable the L1S task + l1a_l1s_com.wcm_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"WCM SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[WCM_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.wcm_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"WCM SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_WCM_CON) + { + os_free_sig(l1a.wcm_req_msg_ptr); + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_WCM_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } +#else + void l1a_mmi_wcm_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_WCM_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.wcm_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_WCM_REQ) + { + l1a.wcm_req_msg_ptr = msg; + l1a.l1_msg_forwarded = TRUE; + + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.wcm_task.parameters = (T_MMI_AQI_WCM_REQ *) (msg->SigP); + + // Enable the L1S task + l1a_l1s_com.wcm_task.command.update = TRUE; + + *state = WAIT_CON; + } + // End process + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_WCM_CON) + { + os_free_sig(l1a.wcm_req_msg_ptr); + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_WCM_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#endif // L1_DYN_DSP_DWNLD + +#endif // L1_WCM + +#if (L1_DRC == 1) // DRC 1.x +// DRC NDB API +T_DRC_MCU_DSP *drc_ndb; +#if (CODE_VERSION == SIMULATION) + T_DRC_MCU_DSP drc_ndb_sim; +#endif + + /*-------------------------------------------------------*/ + /* l1a_mmi_drc_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* DRC 1.x feature. */ + /* */ + /* Starting messages: MMI_AQI_DRC_REQ */ + /* */ + /* Result messages (input): L1_AQI_DRC_CON */ + /* */ + /* Result messages (output): MMI_AQI_DRC_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ +#if(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_drc_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_DRC_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.drc_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_DRC_REQ) + { + l1a.drc_req_msg_ptr = msg; + l1a.l1_msg_forwarded = TRUE; + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.drc_task.parameters = (T_MMI_AQI_DRC_REQ *) (msg->SigP); + + if (l1a.dyn_dwnld.semaphore_vect[DRC_STATE_MACHINE] == GREEN) + { + // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD + // when activating the task at L1s level + + // Enable the L1S task + l1a_l1s_com.drc_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"DRC SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[DRC_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.drc_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"DRC SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_DRC_CON) + { + os_free_sig(l1a.drc_req_msg_ptr); + // Send the confirmation message + l1a_audio_send_result(MMI_AQI_DRC_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } +#else + void l1a_mmi_drc_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_DRC_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.drc_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_DRC_REQ) + { + l1a.drc_req_msg_ptr = msg; + l1a.l1_msg_forwarded = TRUE; + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.drc_task.parameters = (T_MMI_AQI_DRC_REQ *) (msg->SigP); + + // Enable the L1S task + l1a_l1s_com.drc_task.command.update = TRUE; + + *state = WAIT_CON; + } + // End process + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_DRC_CON) + { + os_free_sig(l1a.drc_req_msg_ptr); + + // Send the confirmation message + l1a_audio_send_result(MMI_AQI_DRC_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#endif // L1_DYN_DSP_DWNLD +#endif // L1_DRC + + #if (L1_LIMITER == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_limiter_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* LIMITER feature. */ + /* */ + /* Starting messages: MMI_LIMITER_REQ */ + /* */ + /* Result messages (input): L1_LIMITER_CON */ + /* */ + /* Result messages (output): MMI_LIMITER_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_limiter_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_LIMITER_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.limiter_task.command.update = FALSE; + l1a_l1s_com.limiter_task.command.partial_update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_LIMITER_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.limiter_task.parameters.limiter_enable = ((T_MMI_LIMITER_REQ *)(msg->SigP))->limiter_enable; + l1a_l1s_com.limiter_task.parameters.block_size = ((T_MMI_LIMITER_REQ *)(msg->SigP))->block_size; + l1a_l1s_com.limiter_task.parameters.slope_update_period = ((T_MMI_LIMITER_REQ *)(msg->SigP))->slope_update_period; + l1a_l1s_com.limiter_task.parameters.nb_fir_coefs = ((T_MMI_LIMITER_REQ *)(msg->SigP))->nb_fir_coefs; + l1a_l1s_com.limiter_task.parameters.filter_coefs = ((T_MMI_LIMITER_REQ *)(msg->SigP))->filter_coefs; + l1a_l1s_com.limiter_task.parameters.thr_low_0 = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_low_0; + l1a_l1s_com.limiter_task.parameters.thr_low_slope = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_low_slope; + l1a_l1s_com.limiter_task.parameters.thr_high_0 = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_high_0; + l1a_l1s_com.limiter_task.parameters.thr_high_slope = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_high_slope; + l1a_l1s_com.limiter_task.parameters.gain_fall = ((T_MMI_LIMITER_REQ *)(msg->SigP))->gain_fall; + l1a_l1s_com.limiter_task.parameters.gain_rise = ((T_MMI_LIMITER_REQ *)(msg->SigP))->gain_rise; + + // Enable the L1S task + l1a_l1s_com.limiter_task.command.update = TRUE; + + *state = WAIT_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_CON: + { + if (SignalCode == L1_LIMITER_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_LIMITER_CON); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } + #endif // L1_LIMITER + + #if (L1_ES == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_es_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* Echo Suppressor feature. */ + /* */ + /* Starting messages: MMI_ES_REQ */ + /* */ + /* Result messages (input): L1_ES_CON */ + /* */ + /* Result messages (output): MMI_ES_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ +#if (L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_es_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_ES_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.es_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_ES_REQ) + { + // Load the message into the l1a_l1s_com memory + l1a_l1s_com.es_task.parameters.es_enable = ((T_MMI_ES_REQ *)(msg->SigP))->es_enable; + l1a_l1s_com.es_task.parameters.es_behavior = ((T_MMI_ES_REQ *)(msg->SigP))->es_behavior; + + if (l1a_l1s_com.es_task.parameters.es_behavior == ES_CUSTOM_PARAM) + { + // Load every parameters from the message + l1a_l1s_com.es_task.parameters.es_config.es_mode = ((T_MMI_ES_REQ *)(msg->SigP))->es_mode; + l1a_l1s_com.es_task.parameters.es_config.es_gain_dl = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_dl; + l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_1 = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_1; + l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_2 = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_2; + l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ls_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ls_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ls_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ls_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ns_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ns_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ns_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ns_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_ne_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_ne_thr; + l1a_l1s_com.es_task.parameters.es_config.ref_ls_pwr = ((T_MMI_ES_REQ *)(msg->SigP))->ref_ls_pwr; + l1a_l1s_com.es_task.parameters.es_config.switching_time = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time; + l1a_l1s_com.es_task.parameters.es_config.switching_time_dt = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time_dt; + l1a_l1s_com.es_task.parameters.es_config.hang_time = ((T_MMI_ES_REQ *)(msg->SigP))->hang_time; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[0] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[0]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[1] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[1]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[2] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[2]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[3] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[3]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[0] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[0]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[1] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[1]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[2] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[2]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[3] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[3]; + } + if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // WARNING: The following code must be copied in the state WAIT_DYN_DWNLD + // when ES task is activated at L1s level + + // Enable the L1S task + l1a_l1s_com.es_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"ES SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if (SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.es_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"ES SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_CON: + { + if (SignalCode == L1_ES_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_ES_CON); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } + +#else + void l1a_mmi_es_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_ES_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.es_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_ES_REQ) + { + // Load the message into the l1a_l1s_com memory + l1a_l1s_com.es_task.parameters.es_enable = ((T_MMI_ES_REQ *)(msg->SigP))->es_enable; + l1a_l1s_com.es_task.parameters.es_behavior = ((T_MMI_ES_REQ *)(msg->SigP))->es_behavior; + + if (l1a_l1s_com.es_task.parameters.es_behavior == ES_CUSTOM_PARAM) + { + // Load every parameters from the message + l1a_l1s_com.es_task.parameters.es_config.es_mode = ((T_MMI_ES_REQ *)(msg->SigP))->es_mode; + l1a_l1s_com.es_task.parameters.es_config.es_gain_dl = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_dl; + l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_1 = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_1; + l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_2 = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_2; + l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ls_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ls_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ls_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ls_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ns_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ns_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ns_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ns_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_ne_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_ne_thr; + l1a_l1s_com.es_task.parameters.es_config.ref_ls_pwr = ((T_MMI_ES_REQ *)(msg->SigP))->ref_ls_pwr; + l1a_l1s_com.es_task.parameters.es_config.switching_time = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time; + l1a_l1s_com.es_task.parameters.es_config.switching_time_dt = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time_dt; + l1a_l1s_com.es_task.parameters.es_config.hang_time = ((T_MMI_ES_REQ *)(msg->SigP))->hang_time; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[0] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[0]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[1] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[1]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[2] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[2]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[3] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[3]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[0] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[0]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[1] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[1]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[2] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[2]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[3] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[3]; + } + + // Enable the L1S task + l1a_l1s_com.es_task.command.update = TRUE; + + *state = WAIT_CON; + } + + // End process + return; + } + break; + + case WAIT_CON: + { + if (SignalCode == L1_ES_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_ES_CON); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + #endif //L1_DYN_DSP_DWNLD + #endif // L1_ES + +// New Vocoder IF process + +#if (L1_VOCODER_IF_CHANGE == 1) + void l1a_mmi_vocoder_cfg_process (xSignalHeaderRec *msg) + { + + BOOL msg_parameter; + + enum states + { + WAIT_REQ = 0, + WAIT_ENABLE_CON = 1, + WAIT_DISABLE_CON = 2 + }; + + enum vocoder_cfg_req + { + VOCODER_DISABLE_REQ = 0, + VOCODER_ENABLE_REQ = 1 + }; + + UWORD8 *state = &l1a.state[L1A_VOCODER_CFG_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while (1) + { + switch(*state) + { + case WAIT_REQ: + { + + // Waiting PS messages.... + + // If SignalCode is an MPHC_STOP_DEDICATED_REQ and vocoders are enabled, they must be stopped automatically + +#if(L1_CHECK_COMPATIBLE == 1) + if (((SignalCode == MPHC_STOP_DEDICATED_REQ) && (l1a.vocoder_state.enabled == TRUE)) || (l1a.vch_auto_disable == TRUE)) +#else + if (((SignalCode == MPHC_STOP_DEDICATED_REQ) && (l1a.vocoder_state.enabled == TRUE))) +#endif + { + // Command vocoder disabling at L1A-L1s interface and set the automatic disable flag to TRUE + l1a_l1s_com.dedic_set.start_vocoder = TCH_VOCODER_DISABLE_COMMAND; + l1a.vocoder_state.automatic_disable = TRUE; + *state = WAIT_DISABLE_CON; +#if(L1_CHECK_COMPATIBLE == 1) + l1a.vch_auto_disable = FALSE; +#endif + } + else if (SignalCode == MMI_TCH_VOCODER_CFG_REQ) + { + // In case the vocoder START or STOP is commanded by PS + + + msg_parameter = ((T_MMI_TCH_VOCODER_CFG_REQ *) (msg->SigP))->vocoder_state; + // If it is an explicit STOP.... + if (msg_parameter == VOCODER_DISABLE_REQ) + { +#if (AUDIO_DEBUG == 1) + trace_info.audio_debug_var.vocoder_enable_status = 0; +#endif + + //... explicitely disable vocoders if they're enabled commanidng the stop at L1A-L1s interface + if (l1a.vocoder_state.enabled == TRUE) + { + l1a_l1s_com.dedic_set.start_vocoder = TCH_VOCODER_DISABLE_COMMAND; + l1a.vocoder_state.automatic_disable = FALSE; + *state = WAIT_DISABLE_CON; + } + else + { + // ...else, if vocoders are already disabled but PS is sending erroneously the request + // send him however the confirmation without doing anything (protection check). + // In case L1 standalone or SIMULATION, confirmation message must be + // sent to MMI mailbox, else with complete PS software the message must be + // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined). + + l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE); + } + } + else if (msg_parameter == VOCODER_ENABLE_REQ) + { +#if (AUDIO_DEBUG == 1) + trace_info.audio_debug_var.vocoder_enable_status = 1; +#endif + // If it is a START + if (l1a.vocoder_state.enabled == FALSE) + { + // Command the start at L1A-L1s interface if vocoders are disabled + l1a_l1s_com.dedic_set.start_vocoder = TCH_VOCODER_ENABLE_COMMAND; + *state = WAIT_ENABLE_CON; + } + else + { + // ...else, if vocoders are already enabled but PS is sending erroneously the request + // send him however the confirmation without doing anything (protection check). + // In case L1 standalone or SIMULATION, confirmation message must be + // sent to MMI mailbox, else with complete PS software the message must be + // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined). + + l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE); + } + } + } + return; + } + // omaps00090550 break; + case WAIT_ENABLE_CON: + { + if (SignalCode == L1_VOCODER_CFG_ENABLE_CON) + { + // when L1s confirms the enabling, forward the confirmation to PS and set the vocoders enabled flag to TRUE + l1a.vocoder_state.enabled = TRUE; + + // in case L1 standalone or SIMULATION, confirmation message must be + // sent to MMI mailbox, else with complete PS software the message must be + // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined). + + l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE); + *state = WAIT_REQ; + } + return; + } + // omaps00090550 break; + case WAIT_DISABLE_CON: + { + if (SignalCode == L1_VOCODER_CFG_DISABLE_CON) + { + // when L1s confirms the disabling, forwards the confirmation to PS and set the vocoders enabled flag to FALSE + l1a.vocoder_state.enabled = FALSE; + *state = WAIT_REQ; + + if (l1a.vocoder_state.automatic_disable == FALSE) + { + // Only in case it is an explicit request to STOP the vocoders (made previously by PS) + // send him the confirmation. + // In case L1 standalone or SIMULATION, confirmation message must be + // sent to MMI mailbox, else with complete PS software the message must be + // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined). + + l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE); + } + else + // Reset automatic disable flag + l1a.vocoder_state.automatic_disable = FALSE; + } + return; + } + // omaps00090550 break; + } + } + + } +#endif // L1_VOCODER_IF_CHANGE == 1 + +#if 0 /* FreeCalypso: LoCosto-ism removed */ + void l1a_mmi_outen_cfg_process (xSignalHeaderRec *msg) + { +#if (OP_RIV_AUDIO == 1) + + UWORD32 SignalCode = msg->SignalCode; + void *p_message; + T_RVF_MB_STATUS mb_status; + + if (SignalCode == MMI_OUTEN_CFG_REQ) + { + l1a_l1s_com.outen_cfg_task.outen1 = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->outen1; + l1a_l1s_com.outen_cfg_task.outen2 = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->outen2; + l1a_l1s_com.outen_cfg_task.outen3 = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->outen3; + l1a_l1s_com.outen_cfg_task.classD = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->classD; + + l1a_l1s_com.outen_cfg_task.command_requested++; + // Send the confirmation message + l1a_audio_send_confirmation(MMI_OUTEN_CFG_CON); + } + else if(SignalCode == MMI_OUTEN_CFG_READ_REQ) + { + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_OUTEN_CFG_READ_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_OUTEN_CFG_READ_CON *)(p_message))->header.msg_id = MMI_OUTEN_CFG_READ_CON; + + // Fill the message parameter + ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->outen1 = l1a_l1s_com.outen_cfg_task.outen1; + ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->outen2 = l1a_l1s_com.outen_cfg_task.outen2; + ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->outen3 = l1a_l1s_com.outen_cfg_task.outen3; + ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->classD = l1a_l1s_com.outen_cfg_task.classD; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId,p_message); + } +#endif /*OP_RIV_AUDIO*/ + } /* end function l1a_mmi_outen_cfg_process */ +#endif + +#if(L1_BT_AUDIO ==1) +void l1a_mmi_bt_process(xSignalHeaderRec *msg) +{ + UWORD32 SignalCode = msg->SignalCode; + + if (SignalCode == MMI_BT_ENABLE_REQ) + bt_audio.connected_status = TRUE; + else if(SignalCode == MMI_BT_DISABLE_REQ) + bt_audio.connected_status = FALSE; + +} +#endif +#endif // AUDIO_TASK +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/audio_cfile/l1audio_back.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,609 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_SRBACK.C + * + * Filename l1audio_back.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ + +#define L1_SRBACK_COM // switch to define the l1_srback_com variable +#define L1_AUDIOBACK_MELODYE2 // switch to define the audio background variable + +#include "l1_macro.h" +#include "l1_confg.h" + +#if (AUDIO_TASK == 1) && (L1_AUDIO_BACKGROUND_TASK) + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added form e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added form e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + + #include "l1_time.h" + #include "l1_scen.h" + + #else + // Layer1 and debug include files. + + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added form e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added form e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #include "l1_time.h" + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + #endif + + /****************************************/ + /* Prototypes for audio background task */ + /****************************************/ + void l1_audio_background_task (UWORD32 argc, void *argv); + #if (SPEECH_RECO) + void srback_CTO_algorithm (API *RAM_address); + void srback_save_model_temp (API *RAM_address_input, UWORD16 *RAM_address_output); + #endif + #if (MELODY_E2 && FIR) + void audio_background_melody_e2_download_instrument_manager(xSignalHeaderRec *msg); + #endif + /**************************************/ + /* External prototypes */ + /**************************************/ + #if (SPEECH_RECO) + extern void Cust_srback_save_model (UWORD8 database, UWORD8 index, API *RAM_address); + extern void Cust_srback_save_speech (UWORD8 database, UWORD8 index, UWORD16 *start_buffer, UWORD16 *stop_buffer, UWORD16 *start_speech, UWORD16 *stop_speech); + extern void Cust_srback_load_model (UWORD8 database, UWORD8 index, API *RAM_address); + #endif + #if (MELODY_E2 && FIR) + extern UWORD16 Cust_audio_melody_E2_load_instrument (UWORD8 customer_instrument_id, + API *API_address, + UWORD16 allowed_size); + #endif + +#if (OP_RIV_AUDIO == 0) + /*--------------------------------------------------------*/ + /* l1_audio_background_task() */ + /*--------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* audio background feature. */ + /* */ + /* Starting messages: L1_SRBACK_SAVE_DATA_REQ */ + /* L1_SRBACK_TEMP_SAVE_DATA_REQ */ + /* L1_SRBACK_LOAD_MODEL_REQ */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): L1_SRBACK_SAVE_DATA_CON */ + /* L1_SRBACK_TEMP_SAVE_DATA_CON */ + /* L1_SRBACK_LOAD_MODEL_CON */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): non */ + /* */ + /* Stop message (output): L1_SRBACK_SAVE_DATA_CON */ + /* L1_SRBACK_TEMP_SAVE_DATA_CON */ + /* L1_SRBACK_LOAD_MODEL_CON */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON */ + /* */ + /* Rem: to stop immeditly the speech reco feature a flag */ + /* ---- is created: l1_srback_com.emergency_stop */ + /* */ + /*--------------------------------------------------------*/ + void l1_audio_background_task(UWORD32 argc, void *argv) + { + xSignalHeaderRec *receive_msg, *confirm_msg; + UWORD8 index; + + while(1) + { + // Wait until a message is receive + receive_msg = os_receive_sig(SRBACK_QUEUE); + + #if (SPEECH_RECO) + if (receive_msg->SignalCode == L1_SRBACK_SAVE_DATA_REQ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the customer function to save the model + Cust_srback_save_model( ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->database_id, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->model_index, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->model_RAM_address ); + } + if ( ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->speech ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the customer function to save the speech from a circular buffer to the database + Cust_srback_save_speech( ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->database_id, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->model_index, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->start_buffer, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->stop_buffer, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->start_address, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->stop_address); + } + } + + // Send the stop confirmation message + confirm_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + confirm_msg->SignalCode = L1_SRBACK_SAVE_DATA_CON; + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } // L1_SRBACK_SAVE_DATA_REQ + else + if (receive_msg->SignalCode == L1_SRBACK_LOAD_MODEL_REQ) + { + if ( ( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->CTO_enable ) == FALSE ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the function to load a model + Cust_srback_load_model( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->database_id, + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_index, + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_RAM_address ); + } + } + else + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Calculate the good index + index = ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_index>>1; + + // Call the function to load a model with the good index + Cust_srback_load_model( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->database_id, + index, + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_RAM_address ); + } + + // The CTO algorithm is used and the model index is odd + if ( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_index & 0x01 ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the function to apply the CTO algorithm to the loaded model + srback_CTO_algorithm( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_RAM_address ); + } + } + } + + // Send the stop confirmation message + confirm_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + confirm_msg->SignalCode = L1_SRBACK_LOAD_MODEL_CON; + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } // L1_SRBACK_LOAD_MODEL_REQ + else + if (receive_msg->SignalCode == L1_SRBACK_TEMP_SAVE_DATA_REQ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the function to save the model in a temporary buffer + srback_save_model_temp( ((T_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(receive_msg->SigP))->model_RAM_address_input, + ((T_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(receive_msg->SigP))->model_RAM_address_output ); + } + + // Send the stop confirmation message + confirm_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + confirm_msg->SignalCode = L1_SRBACK_TEMP_SAVE_DATA_CON; + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } // L1_SRBACK_TEMP_SAVE_DATA_REQ + #endif // SPEECH_RECO + #if (MELODY_E2 && FIR) + if ( (receive_msg->SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ) || + (receive_msg->SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ) ) + { + audio_background_melody_e2_download_instrument_manager(receive_msg); + } // L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ + #endif // MELODY_E2 + + // Deallocate the received message + os_free_sig(receive_msg); + DEBUGMSG(status,NU_ALLOC_ERR) + } // while(1) + } +#endif // OP_RIV_AUDIO + + #if (SPEECH_RECO) + /*-------------------------------------------------------*/ + /* srback_CTO_algorithm() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : RAM_address */ + /* */ + /* Return : none */ + /* */ + /* Description : apply the CTO algorithm to the model. */ + /* */ + /*-------------------------------------------------------*/ + void srback_CTO_algorithm (API *RAM_address) + { + UWORD16 model_size, frame; + UWORD8 frame_size; + + // This alogrithm changes the model: + // |frame 0|frame 1|frame 2|frame 3|frame 4|frame 5|frame 6|frame 7|... + // into a garbage model: + // |0000000|frame 1|0000000|0000000|frame 4|0000000|0000000|frame 7|... + + // look the size of the model in model frame unit (16 words unit) + model_size = *RAM_address++; + + frame = 0; + + while( (frame <= model_size) && + (l1_srback_com.emergency_stop == FALSE) ) + { + if ((frame % 3) == 1) + { + // This frame is kept + RAM_address += SC_SR_MODEL_FRAME_SIZE; + } + else + { + // This frame is set to 0 + frame_size = SC_SR_MODEL_FRAME_SIZE; + while ( (frame_size != 0) && + (l1_srback_com.emergency_stop == FALSE) ) + { + *RAM_address++ = 0; + frame_size--; + } + } + + frame++; + } + } + + /*-------------------------------------------------------*/ + /* srback_CTO_algorithm() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : RAM_address_input */ + /* RAM_address_output */ + /* */ + /* Return : none */ + /* */ + /* Description : apply the CTO algorithm to the model. */ + /* */ + /*-------------------------------------------------------*/ + void srback_save_model_temp (API *RAM_address_input, UWORD16 *RAM_address_output) + { + UWORD16 model_size; + UWORD8 frame_size; + + // look the size of the model in model frame unit (16 words unit) + model_size = *RAM_address_input; + + // save the header of the model + *RAM_address_output++ = *RAM_address_input++; + + while( (model_size != 0) && + (l1_srback_com.emergency_stop == FALSE) ) + { + frame_size = SC_SR_MODEL_FRAME_SIZE; + while ( (frame_size != 0) && + (l1_srback_com.emergency_stop == FALSE) ) + { + *RAM_address_output++ = *RAM_address_input++; + frame_size--; + } + model_size--; + } + } + #endif // SPEECH_RECO + +#if (OP_RIV_AUDIO == 0) + #if (MELODY_E2 && FIR) + /*--------------------------------------------------------*/ + /*audio_background_melody_e2_download_instrument_manager()*/ + /*--------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is used to load/unload the instrument of */ + /* the melodies E2. */ + /* */ + /* Starting messages: */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none. */ + /* */ + /* Stop message (output): */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON */ + /* */ + /* Rem: to stop immediatly the instrument download flags */ + /* ---- is created: */ + /* l1a_l1s_com.melody0_e2_task.parameters.emergency_stop */ + /* l1a_l1s_com.melody1_e2_task.parameters.emergency_stop */ + /* */ + /*--------------------------------------------------------*/ + void audio_background_melody_e2_download_instrument_manager(xSignalHeaderRec *msg) + { + xSignalHeaderRec *confirm_msg; + UWORD8 instrument_number, max_number_of_instrument, instrument_id, id; + UWORD16 size; + UWORD32 address; + + if (msg->SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ) + { + // Load the instrument + + // Init the first address + address = ( ((UWORD32)(l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_wave)) + - SC_AUDIO_MCU_API_BEGIN_ADDRESS ); + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[0] = + (API)( (address>>1) + SC_AUDIO_DSP_API_BEGIN_ADDRESS ); + + // Download the instrument + max_number_of_instrument = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->number_of_instrument; + for(instrument_number=0; instrument_number < max_number_of_instrument ; instrument_number++) + { + // No instrument was previously download + if (audioback_melody_e2.number_of_user[instrument_number] == 0) + { + // load the insturment ID + instrument_id = + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[instrument_number]; + + // Find if this instrument was already downloaded + id = 0; + while ( (id < SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT) && + ((instrument_id != audioback_melody_e2.instrument_id[id]) || + (audioback_melody_e2.number_of_user[id] == 0)) ) + { + id++; + } + + if (id < SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT) + { + // This insturment was already downloaded + // copy the address of this instrument + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[instrument_number] = + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[id]; + + // The size of this instrument is 0 + audioback_melody_e2.instrument_size[instrument_number] = 0; + } + else + { + // Load the customer instrument + size = Cust_audio_melody_E2_load_instrument ( + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[instrument_number], + audioback_melody_e2.API_address, + audioback_melody_e2.allowed_size); + + // Added to stop the L1 in case of download error + if (size == 0) + { + // Send a message to stop the L1 + /* send the stop command to the audio L1 */ + /* allocate the buffer for the message to the L1 */ + confirm_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + + if (confirm_msg != NULL) + { + /* send the stop command to the audio L1 */ + if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(confirm_msg->SigP))->melody_id == 0) + { + confirm_msg->SignalCode = MMI_MELODY0_E2_STOP_REQ; + } + else + { + confirm_msg->SignalCode = MMI_MELODY1_E2_STOP_REQ; + } + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Save the size of this instrument + audioback_melody_e2.instrument_size[instrument_number] = size; + } + + // Update the Cust_audio_melody_E2_load_instrument argument + audioback_melody_e2.API_address += audioback_melody_e2.instrument_size[instrument_number]; + audioback_melody_e2.allowed_size -= audioback_melody_e2.instrument_size[instrument_number]; + + // Put the DSP address to the NDB API for the next instrument + if (instrument_number < SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT-1) + { + address = ( ((UWORD32)(audioback_melody_e2.API_address)) + - SC_AUDIO_MCU_API_BEGIN_ADDRESS ); + + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[instrument_number + 1] = + (API)( (address>>1) + SC_AUDIO_DSP_API_BEGIN_ADDRESS ); + } + + // Save the instrument ID + audioback_melody_e2.instrument_id[instrument_number] = instrument_id; + } + + // Increase the number of user of this instrument number + audioback_melody_e2.number_of_user[instrument_number]++; + } + + // Send the load confirmation message + confirm_msg = os_alloc_sig(sizeof(T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + + // Fill the parameter + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON *)(confirm_msg->SigP))->melody_id = + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id; + + confirm_msg->SignalCode = L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON; + + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + else + if (msg->SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ) + { + // Unload the instrument + max_number_of_instrument = ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->number_of_instrument; + for(instrument_number = max_number_of_instrument; instrument_number > 0 ; instrument_number--) + { + // Decrease the number of user of this instrument number + audioback_melody_e2.number_of_user[instrument_number-1]--; + + // Check if the instrument must be removed + if (audioback_melody_e2.number_of_user[instrument_number-1] == 0) + { + // Increase the size and decrease the pointer to the API with the size + // of the removed instrument + // Update the Cust_audio_melody_E2_load_instrument argument + audioback_melody_e2.API_address -= audioback_melody_e2.instrument_size[instrument_number-1]; + audioback_melody_e2.allowed_size += audioback_melody_e2.instrument_size[instrument_number-1]; + } + } + + // Send the unload confirmation message + confirm_msg = os_alloc_sig(sizeof(T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + + // Fill the paramter + ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON *)(confirm_msg->SigP))->melody_id = + ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id; + + confirm_msg->SignalCode = L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON; + + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + #endif // MELODY_E2 +#endif // OP_RIV_AUDIO +#endif // AUDIO_TASK == 1 && L1_AUDIO_BACKGROUND_TASK
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/audio_cfile/l1audio_drive.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,280 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_DRIVE.C + * + * Filename l1audio_drive.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ + +#include "l1_macro.h" +#include "l1_confg.h" + +#if (AUDIO_TASK == 1) + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + + #include "l1_time.h" + #include "l1_scen.h" + + #else + // Layer1 and debug include files. + + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #include "l1_time.h" + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + #endif + + #include "l1audio_macro.h" + + /**************************************/ + /* Prototypes for L1 SYNCH manager */ + /**************************************/ + void vocoder_mute_dl (BOOL mute); + void vocoder_mute_ul (BOOL mute); + #if (AUDIO_DSP_FEATURES == 1) + void L1_audio_sidetone_write(UWORD16 sidetone_value); + void L1_audio_CAL_DlVolume_write(UWORD16 vol_value); + void L1_audio_CAL_UlVolume_write(UWORD16 vol_value); + void L1_audio_volume_speed_write(UWORD16 volspeed_value); + #endif + + /**************************************/ + /* External prototypes */ + /**************************************/ + + /*-------------------------------------------------------*/ + /* vocoder_mute_dl() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Mute the DL vocoder. */ + /* */ + /*-------------------------------------------------------*/ + void vocoder_mute_dl(BOOL mute) + { + if (mute) + { + // Set the DL vocoder mute bit in the d_tch_mode register + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= (0x01<<14); + } + else + { + // Reset the DL vocoder mute bit in the d_tch_mode register + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(0x01<<14); + } + } + + /*-------------------------------------------------------*/ + /* vocoder_mute_ul() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Mute the UL vocoder. */ + /* */ + /*-------------------------------------------------------*/ + void vocoder_mute_ul(BOOL mute) + { + if (mute) + { + // Set the UL vocoder mute bit in the d_tch_mode register + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= (0x01<<15); + } + else + { + // Reset the UL vocoder mute bit in the d_tch_mode register + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(0x01<<15); + } + } + + #if (AUDIO_DSP_FEATURES == 1) + /*-------------------------------------------------------*/ + /* L1_audio_sidetone_write() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : write sidetone gain in API for DSP */ + /* sidetone process */ + /* */ + /*-------------------------------------------------------*/ + void L1_audio_sidetone_write(UWORD16 sidetone_value) + { + l1s_dsp_com.dsp_ndb_ptr->d_sidetone_level = (API) sidetone_value; + } + + /*-------------------------------------------------------*/ + /* L1_audio_CAL_DlVolume_write() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : write DL gain in API for DSP vol ctrl */ + /* process */ + /* */ + /*-------------------------------------------------------*/ + void L1_audio_CAL_DlVolume_write(UWORD16 vol_value) + { + l1s_dsp_com.dsp_ndb_ptr->d_vol_dl_level = (API) vol_value; + } + + /*-------------------------------------------------------*/ + /* L1_audio_CAL_UlVolume_write() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : write UL gain in API for DSP vol ctrl */ + /* process */ + /* */ + /*-------------------------------------------------------*/ + void L1_audio_CAL_UlVolume_write(UWORD16 vol_value) + { + l1s_dsp_com.dsp_ndb_ptr->d_vol_ul_level = (API) vol_value; + } + + /*-------------------------------------------------------*/ + /* L1_audio_volume_speed_write() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : write volume speed in API for DSP vol */ + /* ctrl process */ + /* */ + /*-------------------------------------------------------*/ + void L1_audio_volume_speed_write(UWORD16 volspeed_value) + { + l1s_dsp_com.dsp_ndb_ptr->d_vol_speed = (API) volspeed_value; + } + + #endif /* DSP_AUDIO_FEAT */ + +#endif // AUDIO_TASK
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/audio_cfile/l1audio_func.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,1313 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_FUNC.C + * + * Filename l1audio_func.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + + +/************************************/ +/* Include files... */ +/************************************/ +#include "nucleus.h" //omaps00090550 +#include "l1_macro.h" + +#include "l1_macro.h" +#include "l1_confg.h" +//#include "l1audio_defty.h" + +#if (AUDIO_TASK == 1) + + #include "l1_types.h" + #include "sys_types.h" + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_abb.h" + #include "l1audio_btapi.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + + #include "l1_time.h" + #include "l1_scen.h" + + #if TESTMODE + #include "l1tm_msgty.h" + #include "l1tm_signa.h" + #include "l1tm_varex.h" + #endif // TESTMODE + + #if (L1_STEREOPATH == 1) + #include "sys_dma.h" + #include "sys_inth.h" + #include "abb.h" + #include "l1audio_stereo.h" + #endif + + #else + // Layer1 and debug include files. + + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_abb.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #include"l1mp3_const.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #include"l1aac_const.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #if TESTMODE + #include "l1tm_msgty.h" + #include "l1tm_signa.h" + #include "l1tm_varex.h" + #endif // TESTMODE + + #if (L1_STEREOPATH == 1) + #include "sys_dma.h" + #include "sys_inth.h" + #include "abb.h" + #include "l1audio_stereo.h" + #endif + + #include "l1_time.h" + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + #endif +#if (OP_RIV_AUDIO == 1) + #include "rv_general.h" + #include "audio_api.h" + #include "audio_structs_i.h" + #include "audio_var_i.h" + #include "audio_macro_i.h" + #include "audio_const_i.h" + #endif + + #include "l1audio_macro.h" + + /**************************************/ + /* Prototypes for L1S audio function */ + /**************************************/ + UWORD8 copy_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_dst); + UWORD8 copy_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_src); + #if (MELODY_E2) + UWORD16 audio_twentyms_to_TDMA_convertion(UWORD16 twentyms_value); + #endif + #if (MELODY_E2) || (L1_VOICE_MEMO_AMR) + UWORD8 copy_byte_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_dst); + UWORD8 copy_byte_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_src); + #endif + #if (L1_VOICE_MEMO_AMR) + UWORD8 copy_byte_data_le_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, API *ptr_dst); + UWORD8 copy_byte_data_le_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, API *ptr_src); + #endif + #if (L1_EXT_AUDIO_MGT == 1) + void l1_ext_audio_mgt_dma_handler(SYS_UWORD16 dma_status); + #endif + #if (L1_IIR == 2) + void l1_audio_iir4x_copy_params(); + #endif + + #if (L1_AGC_UL== 1) + void l1_audio_agc_ul_copy_params(); + #endif + + #if (L1_AGC_DL== 1) + void l1_audio_agc_dl_copy_params(); + #endif + + #if (L1_DRC == 1) + void l1_audio_drc1x_copy_params(); + #endif + +#if(L1_BT_AUDIO ==1)||(L1_WCM ==1) +void l1_audio_manager(UWORD8 *src, UWORD16 size); +void l1_audio_bt_init(UINT16 media_buf_size); +extern void l1mp3_dma_it_handler(SYS_UWORD16 d_dma_channel_it_status); +extern void l1aac_dma_it_handler(SYS_UWORD16 d_dma_channel_it_status); +#endif +#if(L1_BT_AUDIO ==1) +T_L1_BT_AUDIO bt_audio; + +extern T_MP3_DMA_PARAM *mp3_dma; +extern T_AAC_DMA_PARAM *aac_dma; +extern void l1a_bt_audio_noti_process(); +extern UWORD16 pending_dec_req; + +#endif + /**************************************/ + /* External prototypes */ + /**************************************/ + extern UWORD8 Cust_get_pointer (UWORD16 **ptr, UWORD16 *buffer_size, UWORD8 session_id); + + #if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) + extern void l1tm_stereopath_DMA_handler(SYS_UWORD16 dma_status); + #if TESTMODE + extern T_STP_DRV_MCU_DSP *stp_drv_ndb; + #endif + #endif + + #if (L1_EXT_AUDIO_MGT == 1) + extern NU_HISR EXT_AUDIO_MGT_hisr; + extern T_MIDI_DMA_PARAM midi_buf; + #endif + + #if (L1_DRC == 1) + extern T_DRC_MCU_DSP *drc_ndb; + #endif + + /*-------------------------------------------------------*/ + /* copy_data_from_buffer() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : session_id */ + /* buffer_size */ + /* data_size */ + /* ptr_dst */ + /* ptr_src */ + /* */ + /* Return : error_id */ + /* */ + /* Description : */ + /* This function copies the data from the buffer */ + /* (buffer size: buffer_size, start address: ptr_buf) to */ + /* the destination indicated by ptr_dst. The size of the */ + /* data to download is data_size. The session_id */ + /* indicates to the custom flash manager the type of */ + /* data. */ + /* */ + /*-------------------------------------------------------*/ + UWORD8 copy_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_dst) + { + UWORD8 error_id = 0; + + while (data_size != 0) + { + while( (data_size !=0) && (*buffer_size != 0) ) + { + *ptr_dst++ = *(*ptr_buf)++; + data_size--; + (*buffer_size)--; + } + // A new buffer is requested in order to finish to copy the data + if ( data_size != 0) + { + *buffer_size = data_size; + error_id = Cust_get_pointer( ptr_buf, buffer_size, session_id); + + // An error is occured + if (error_id) + return(error_id); + } + } + + return(error_id); + } + + /*-------------------------------------------------------*/ + /* copy_data_to_buffer() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : session_id */ + /* buffer_size */ + /* data_size */ + /* ptr_dst */ + /* ptr_src */ + /* */ + /* Return : error_id */ + /* */ + /* Description : */ + /* This function copies the data to the buffer */ + /* (buffer size: buffer_size, start address: ptr_buf) */ + /* from the source indicated by ptr_src. The size of the */ + /* data to save is data_size. The session_id */ + /* indicates to the custom flash manager the type of */ + /* data. */ + /* */ + /*-------------------------------------------------------*/ + UWORD8 copy_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_src) + { + UWORD8 error_id = 0; + + while (data_size != 0) + { + while( (data_size !=0) && (*buffer_size != 0) ) + { + *(*ptr_buf)++ = *ptr_src++; + data_size--; + (*buffer_size)--; + } + // A new buffer is requested in order to finish to copy the data + if (data_size != 0) + { + *buffer_size = data_size; + error_id = Cust_get_pointer(ptr_buf, buffer_size, session_id); + + // An error is occured + if (error_id) + return(error_id); + } + } + + return(error_id); + } + + #if (MELODY_E2) || (L1_VOICE_MEMO_AMR) + /*-------------------------------------------------------*/ + /* copy_byte_data_from_buffer() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : session_id */ + /* buffer_size */ + /* data_size */ + /* ptr_dst */ + /* ptr_src */ + /* */ + /* Return : error_id */ + /* */ + /* Description : */ + /* This function copies byte per byte the data from */ + /* the buffer (buffer size (in byte): buffer_size, */ + /* start address: ptr_buf) to the destination indicated */ + /* by ptr_dst. The size of the data to download is */ + /* data_size(in byte). The session_id indicates to the */ + /* custom flash manager the type of data. */ + /* */ + /*-------------------------------------------------------*/ + UWORD8 copy_byte_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_dst) + { + UWORD8 error_id = 0; + UWORD16 requested_size; + + while (data_size != 0) + { + while( (data_size !=0) && (*buffer_size != 0) ) + { + *ptr_dst++ = *(*ptr_buf)++; + data_size--; + (*buffer_size)--; + } + // A new buffer is requested in order to finish to copy the data + if ( data_size != 0) + { + // Calculate the size of the data to request in 16-bit word + if (*buffer_size & 0x0001) + { + // The size is a odd value + requested_size = (data_size >> 1) + 1; + } + else + { + // the size is an even value + requested_size = (data_size >> 1); + } + + error_id = Cust_get_pointer( (UWORD16 **)ptr_buf, &requested_size, session_id); + + // An error is occured + if (error_id) + return(error_id); + + *buffer_size = (requested_size << 1); + } + } + + return(error_id); + } + + /*-------------------------------------------------------*/ + /* copy_data_to_buffer() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : session_id */ + /* buffer_size */ + /* data_size */ + /* ptr_dst */ + /* ptr_src */ + /* */ + /* Return : error_id */ + /* */ + /* Description : */ + /* This function copies byte per byte the data to the */ + /* buffer (buffer size in byte: buffer_size, start */ + /* address: ptr_buf) from the source indicated by */ + /* ptr_src. The size in byte of the data to save is */ + /* data_size. The session_id indicates to the custom */ + /* flash manager the type of data. */ + /* */ + /*-------------------------------------------------------*/ + UWORD8 copy_byte_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_src) + { + UWORD8 error_id = 0; + UWORD16 requested_size; + + while (data_size != 0) + { + while( (data_size !=0) && (*buffer_size != 0) ) + { + *(*ptr_buf)++ = *ptr_src++; + data_size--; + (*buffer_size)--; + } + // A new buffer is requested in order to finish to copy the data + if (data_size != 0) + { + // Calculate the size of the data to request in 16-bit word + if (*buffer_size & 0x0001) + { + // The size is a odd value + requested_size = (data_size >> 1) + 1; + } + else + { + // the size is an even value + requested_size = (data_size >> 1); + } + + error_id = Cust_get_pointer((UWORD16 **)ptr_buf, &requested_size, session_id); + + // An error is occured + if (error_id) + return(error_id); + + *buffer_size = (requested_size << 1); + } + } + + return(error_id); + } + #endif //#if (MELODY_E2) || (L1_VOICE_MEMO_AMR) + + #if (MELODY_E2) + + /*-------------------------------------------------------*/ + /* audio_twentyms_to_TDMA_convertion() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : 20ms value */ + /* */ + /* Return : TDMA value */ + /* */ + /* Description : */ + /* This function convert a duration from 20ms unit to */ + /* TDMA unit. */ + /* */ + /*-------------------------------------------------------*/ + UWORD16 audio_twentyms_to_TDMA_convertion(UWORD16 twentyms_value) + { + UWORD16 TDMA_value; + + // 20ms # 4 TDMA + TDMA_value = twentyms_value << 2; + + // Compensation factor: 1 TDMA each 60ms. + TDMA_value += (twentyms_value/3); + + return(TDMA_value); + } + #endif // MELODY_E2 + + #if (L1_VOICE_MEMO_AMR) + /*-------------------------------------------------------*/ + /* copy_byte_data_le_from_buffer() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : session_id */ + /* buffer_size */ + /* data_size */ + /* ptr_dst */ + /* ptr_src */ + /* */ + /* Return : error_id */ + /* */ + /* Description : */ + /* This function copies byte per byte the data from */ + /* the buffer (buffer size (in byte): buffer_size, */ + /* start address: ptr_buf) to the destination indicated */ + /* by ptr_dst. The size of the data to download is */ + /* data_size(in byte). The session_id indicates to the */ + /* custom flash manager the type of data. */ + /* Data in buffer is expected to be big-endian and will */ + /* be copied in order to retrieve little-endian order in */ + /* ptr_dst */ + /* */ + /*-------------------------------------------------------*/ + UWORD8 copy_byte_data_le_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, API *ptr_dst) + { + UWORD8 error_id = 0; + UWORD16 requested_size; + UWORD16 data_size_inv = 0; + UWORD16 temp_uword16; + + while (data_size_inv != data_size) + { + /* we go from 0 to data_size copying to MSB (even numbers) then LSB (odd numbers) of DSP */ + while( (data_size_inv != data_size) && (*buffer_size != 0) ) + { + if (data_size_inv & 0x0001) + { + temp_uword16 |= *(*ptr_buf)++; + *(ptr_dst)++ = temp_uword16; + } + else + { + temp_uword16 = (*(*ptr_buf)++ << 8); + } + data_size_inv++; + (*buffer_size)--; + } + // A new buffer is requested in order to finish to copy the data + if ( data_size_inv != data_size) + { + // Calculate the size of the data to request in 16-bit word + if ((data_size - data_size_inv) & 0x0001) + { + // The size is an odd value + requested_size = ((data_size - data_size_inv) >> 1) + 1; + } + else + { + // the size is an even value + requested_size = ((data_size - data_size_inv) >> 1); + } + + error_id = Cust_get_pointer((UWORD16 **)ptr_buf, &requested_size, session_id); + + // An error is occured + if (error_id) + return(error_id); + + *buffer_size = (requested_size << 1); + } + } + + if (data_size & 0x0001) + { + *(ptr_dst)++ = temp_uword16; + } + + return(error_id); + } + + /*-------------------------------------------------------*/ + /* copy_byte_data_le_to_buffer() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : session_id */ + /* buffer_size */ + /* data_size */ + /* ptr_dst */ + /* ptr_src */ + /* */ + /* Return : error_id */ + /* */ + /* Description : */ + /* This function copies byte per byte the data to the */ + /* buffer (buffer size in byte: buffer_size, start */ + /* address: ptr_buf) from the source indicated by */ + /* ptr_src. The size in byte of the data to save is */ + /* data_size. The session_id indicates to the custom */ + /* flash manager the type of data. */ + /* Data is expected to be little-endian in ptr_src and */ + /* will be copied in order to retrieve big-endian */ + /* order in buffer */ + /* */ + /*-------------------------------------------------------*/ + UWORD8 copy_byte_data_le_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, API *ptr_src) + { + UWORD8 error_id = 0; + UWORD8 data_size_inv = 0; + UWORD16 requested_size; + UWORD16 temp_uword16; + + /* we go from 0 to data_size copying MSB (even numbers) then LSB (odd numbers) from DSP */ + while (data_size_inv != data_size) + { + while( (data_size_inv != data_size) && (*buffer_size != 0) ) + { + /* if data_size_inv is odd, we need the LSB of the DSP word */ + if (data_size_inv & 0x0001) + { + *(*ptr_buf)++ = (UWORD8)(temp_uword16 & 0x00FF); + } + /* if data_size_inv is even, we need the MSB of the DSP word */ + else + { + temp_uword16 = *(ptr_src)++; + *(*ptr_buf)++ = (UWORD8)(temp_uword16 >> 8); + } + data_size_inv++; + (*buffer_size)--; + } + // A new buffer is requested in order to finish to copy the data + if ( data_size_inv != data_size) + { + // Calculate the size of the data to request in 16-bit word + if ((data_size - data_size_inv) & 0x0001) + { + // The size is a odd value + requested_size = ((data_size - data_size_inv) >> 1) + 1; + } + else + { + // the size is an even value + requested_size = ((data_size - data_size_inv) >> 1); + } + + error_id = Cust_get_pointer((UWORD16 **)ptr_buf, &requested_size, session_id); + + // An error occured + if (error_id) + return(error_id); + + *buffer_size = (requested_size << 1); + } + } + + return(error_id); + } + #endif + + #if (L1_STEREOPATH == 1) && (CODE_VERSION == NOT_SIMULATION) + /*-------------------------------------------------------*/ + /* l1_audio_api_handler() */ + /*-------------------------------------------------------*/ + /* Parameters : */ + /* Return : */ + /* Functionality : API int management */ + /*-------------------------------------------------------*/ + void l1_audio_api_handler(void) + { + UWORD16 rootcause; + + if (l1a_l1s_com.stereopath_drv_task.parameters.feature_identifier == AUDIO_SP_TESTS_ID) + { + #if (TESTMODE && (OP_L1_STANDALONE == 1)) + rootcause = stp_drv_ndb->d_cport_api_dma_rootcause; + + l1tm_stereopath_DMA_handler((SYS_UWORD16) rootcause); + #endif + } + } /* l1_audio_api_handler() */ + #endif // (L1_STEREOPATH == 1) && (CODE_VERSION == NOT_SIMULATION) + + #if (L1_EXT_AUDIO_MGT == 1) + /*-------------------------------------------------------*/ + /* l1_ext_audio_mgt_dma_handler() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : dma_status */ + /* */ + /* Return : none */ + /* */ + /* Description : */ + /* This function is used to handle a DMA interrupt */ + /* that will notify to the external midi play process */ + /* that a new buffer is needed. */ + /* */ + /*-------------------------------------------------------*/ + void l1_ext_audio_mgt_dma_handler(SYS_UWORD16 dma_status) + { + NU_Activate_HISR(&EXT_AUDIO_MGT_hisr); // activate external MIDI HISR + } + #endif + + #if (L1_LIMITER == 1) + /*-------------------------------------------------------*/ + /* l1_audio_lim_update_mul_low_high() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : */ + /* ------------- */ + /* This function is used to update mul_low and mul_high */ + /* Limiter parameters in function to volume gain (Q15) */ + /* First the function read the last controlled volume */ + /* in the MCU/DSP API then it processed mul_low[0/1] */ + /* and mul_high[0/1] according to following equations: */ + /* */ + /* thr_low = - thr_low_slope x volume + thr_low_0 */ + /* thr_high = - thr_high_slope x volume + thr_high_0 */ + /* */ + /* mul_low[0] = 32767 / thr_low */ + /* mul_low[1] = 32767 x thr_low */ + /* mul_high[0] = 32767 / thr_high */ + /* mul_high[1] = 32767 x thr_high */ + /*-------------------------------------------------------*/ + void l1_audio_lim_update_mul_low_high() + { +#if (CODE_VERSION != SIMULATION) + #if (ANLG_FAM == 3) + WORD16 volume_q15 = ABB_Read_DLGain(); + #endif + #if (ANLG_FAM == 11) + WORD16 volume_q15 = (WORD16)(l1_audio_abb_Read_DLGain()); + #endif +#else + WORD16 volume_q15 = 0x4000; // -6 dB for example in simulation +#endif + WORD16 thr_low, thr_high; + + /* Process Thr_low */ + thr_low = (- (l1a_l1s_com.limiter_task.parameters.thr_low_slope * volume_q15)>>15) + + l1a_l1s_com.limiter_task.parameters.thr_low_0; +// if (thr_low > 32767) //OMAPS00090550 +// thr_low = 32767; + + /* Process Thr_high */ + thr_high = (- (l1a_l1s_com.limiter_task.parameters.thr_high_slope * volume_q15)>>15) + + l1a_l1s_com.limiter_task.parameters.thr_high_0; +// if (thr_high > 32767) //OMAPS00090550 +// thr_high = 32767; + + /* Process amd store mul_low[0/1] */ + if (thr_low != 0) + l1s_dsp_com.dsp_ndb_ptr->a_lim_mul_low[0] = 32767 / thr_low; // Q0 + else + l1s_dsp_com.dsp_ndb_ptr->a_lim_mul_low[0] = 32767; // should never happen + l1s_dsp_com.dsp_ndb_ptr->a_lim_mul_low[1] = thr_low; // Q15 + + /* Process and store mul_high[0/1] */ + if (thr_high != 0) + l1s_dsp_com.dsp_ndb_ptr->a_lim_mul_high[0] = 32767 / thr_high; // Q0 + else + l1s_dsp_com.dsp_ndb_ptr->a_lim_mul_high[0] = 32767; // should never happen + l1s_dsp_com.dsp_ndb_ptr->a_lim_mul_high[1] = thr_high; // Q15 + } + + /*-------------------------------------------------------*/ + /* l1_audio_lim_update_mul_low_high() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : */ + /* ------------- */ + /* This function MUST be called at each volume change in */ + /* order to request a limiter partial update. */ + /*-------------------------------------------------------*/ + void l1_audio_lim_partial_update() + { + // Set partial update command + l1a_l1s_com.limiter_task.command.partial_update = TRUE; + // Force L1S execution + l1a_l1s_com.time_to_next_l1s_task = 0; + } + #endif // L1_LIMITER == 1 + + + + #if (L1_AGC_UL == 1) + /*-------------------------------------------------------*/ + /* l1_audio_agc_ul_copy_params */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : */ + /* ------------- */ + /* This function is used to copy the AGC UL 1x parameter */ + /* to API memory using a pointer */ + /*-------------------------------------------------------*/ + + void l1_audio_agc_ul_copy_params() + { + + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_control = l1a_l1s_com.agc_ul_task.parameters.control; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_frame_size = l1a_l1s_com.agc_ul_task.parameters.frame_size; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_targeted_level = l1a_l1s_com.agc_ul_task.parameters.targeted_level; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_signal_up = l1a_l1s_com.agc_ul_task.parameters.signal_up; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_signal_down = l1a_l1s_com.agc_ul_task.parameters.signal_down; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_max_scale = l1a_l1s_com.agc_ul_task.parameters.max_scale; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_alpha = l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_alpha_fast = l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha_fast; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_beta = l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_beta_fast = l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta_fast; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_intp_flag = l1a_l1s_com.agc_ul_task.parameters.gain_intp_flag; + + } + #endif + + #if (L1_AGC_DL == 1) + /*-------------------------------------------------------*/ + /* l1_audio_agc_dl_copy_params */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : */ + /* ------------- */ + /* This function is used to copy the AGC DL 1x parameter */ + /* to API memory using a pointer */ + /*-------------------------------------------------------*/ + + void l1_audio_agc_dl_copy_params() + { + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_control = l1a_l1s_com.agc_dl_task.parameters.control; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_frame_size = l1a_l1s_com.agc_dl_task.parameters.frame_size; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_targeted_level = l1a_l1s_com.agc_dl_task.parameters.targeted_level; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_signal_up = l1a_l1s_com.agc_dl_task.parameters.signal_up; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_signal_down = l1a_l1s_com.agc_dl_task.parameters.signal_down; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_max_scale = l1a_l1s_com.agc_dl_task.parameters.max_scale; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_alpha = l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_alpha_fast = l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha_fast; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_beta = l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_beta_fast = l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta_fast; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_intp_flag = l1a_l1s_com.agc_dl_task.parameters.gain_intp_flag; + + } + #endif + + + #if (L1_IIR == 2) + /*-------------------------------------------------------*/ + /* l1_audio_iir4x_copy_params */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : */ + /* ------------- */ + /* This function is used to copy the IIR 4x parameter */ + /* to API memory using a pointer */ + /*-------------------------------------------------------*/ + + void l1_audio_iir4x_copy_params() + { + UWORD8 i; + UWORD8 j; + + // Set IIR parameters + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_control = l1a_l1s_com.iir_task.parameters->parameters.control; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_frame_size = l1a_l1s_com.iir_task.parameters->parameters.frame_size; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_swap = l1a_l1s_com.iir_task.parameters->parameters.fir_swap; + + // Set parameter os FIR part + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_enable = l1a_l1s_com.iir_task.parameters->parameters.fir_filter.fir_enable; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_length = l1a_l1s_com.iir_task.parameters->parameters.fir_filter.fir_length; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_shift = l1a_l1s_com.iir_task.parameters->parameters.fir_filter.fir_shift; + + for (i=0; i < (l1a_l1s_com.iir_task.parameters->parameters.fir_filter.fir_length); i++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_fir_taps[i] = l1a_l1s_com.iir_task.parameters->parameters.fir_filter.fir_taps[i]; + } + + // Set parameters for IIR part + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_enable = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_enable; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_number = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_number; + + // Set parameters for IIR part - SOS 1 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_1 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[0].sos_fact; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_1 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[0].sos_fact_form; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_1[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[0].sos_den[j]; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_1[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[0].sos_num[j]; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_1 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[0].sos_num_form; + + + // Set parameters for IIR part - SOS 2 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_2 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[1].sos_fact; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_2 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[1].sos_fact_form; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_2[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[1].sos_den[j]; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_2[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[1].sos_num[j]; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_2 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[1].sos_num_form; + + + // Set parameters for IIR part - SOS 3 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_3 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[2].sos_fact; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_3 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[2].sos_fact_form; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_3[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[2].sos_den[j]; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_3[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[2].sos_num[j]; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_3 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[2].sos_num_form; + + + // Set parameters for IIR part - SOS 4 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_4 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[3].sos_fact; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_4 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[3].sos_fact_form; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_4[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[3].sos_den[j]; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_4[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[3].sos_num[j]; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_4 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[3].sos_num_form; + + + // Set parameters for IIR part - SOS 5 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_5 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[4].sos_fact; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_5 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[4].sos_fact_form; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_5[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[4].sos_den[j]; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_5[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[4].sos_num[j]; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_5 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[4].sos_num_form; + + + // Set parameters for IIR part - SOS 6 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_6 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[5].sos_fact; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_6 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[5].sos_fact_form; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_6[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[5].sos_den[j]; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_6[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[5].sos_num[j]; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_6 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[5].sos_num_form; + + + + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_gain = l1a_l1s_com.iir_task.parameters->parameters.gain; + + } + + #endif // L1_IIR == 2 + + +#if (L1_DRC == 1) + /*-------------------------------------------------------*/ + /* l1_audio_drc1x_copy_params */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : */ + /* ------------- */ + /* This function is used to copy the DRC 1x parameter */ + /* to API memory using a pointer */ + /*-------------------------------------------------------*/ + + void l1_audio_drc1x_copy_params() + { + UWORD8 i; + + // Set DRC parameters + drc_ndb->d_drc_speech_mode_samp_f = l1a_l1s_com.drc_task.parameters->parameters.speech_mode_samp_f; + drc_ndb->d_drc_num_subbands = l1a_l1s_com.drc_task.parameters->parameters.num_subbands; + drc_ndb->d_drc_frame_len = l1a_l1s_com.drc_task.parameters->parameters.frame_len; + drc_ndb->d_drc_expansion_knee_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.expansion_knee_fb_bs; + drc_ndb->d_drc_expansion_knee_md_hg = l1a_l1s_com.drc_task.parameters->parameters.expansion_knee_md_hg; + drc_ndb->d_drc_expansion_ratio_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.expansion_ratio_fb_bs; + drc_ndb->d_drc_expansion_ratio_md_hg = l1a_l1s_com.drc_task.parameters->parameters.expansion_ratio_md_hg; + drc_ndb->d_drc_max_amplification_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.max_amplification_fb_bs; + drc_ndb->d_drc_max_amplification_md_hg = l1a_l1s_com.drc_task.parameters->parameters.max_amplification_md_hg; + drc_ndb->d_drc_compression_knee_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.compression_knee_fb_bs; + drc_ndb->d_drc_compression_knee_md_hg = l1a_l1s_com.drc_task.parameters->parameters.compression_knee_md_hg; + drc_ndb->d_drc_compression_ratio_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.compression_ratio_fb_bs; + drc_ndb->d_drc_compression_ratio_md_hg = l1a_l1s_com.drc_task.parameters->parameters.compression_ratio_md_hg; + drc_ndb->d_drc_energy_limiting_th_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.energy_limiting_th_fb_bs; + drc_ndb->d_drc_energy_limiting_th_md_hg = l1a_l1s_com.drc_task.parameters->parameters.energy_limiting_th_md_hg; + drc_ndb->d_drc_limiter_threshold_fb = l1a_l1s_com.drc_task.parameters->parameters.limiter_threshold_fb; + drc_ndb->d_drc_limiter_threshold_bs = l1a_l1s_com.drc_task.parameters->parameters.limiter_threshold_bs; + drc_ndb->d_drc_limiter_threshold_md = l1a_l1s_com.drc_task.parameters->parameters.limiter_threshold_md; + drc_ndb->d_drc_limiter_threshold_hg = l1a_l1s_com.drc_task.parameters->parameters.limiter_threshold_hg; + drc_ndb->d_drc_limiter_hangover_spect_preserve = l1a_l1s_com.drc_task.parameters->parameters.limiter_hangover_spect_preserve; + drc_ndb->d_drc_limiter_release_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.limiter_release_fb_bs; + drc_ndb->d_drc_limiter_release_md_hg = l1a_l1s_com.drc_task.parameters->parameters.limiter_release_md_hg; + drc_ndb->d_drc_gain_track_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.gain_track_fb_bs; + drc_ndb->d_drc_gain_track_md_hg = l1a_l1s_com.drc_task.parameters->parameters.gain_track_md_hg; + + for (i=0; i < DRC_LPF_LENGTH; i++) + { + drc_ndb->a_drc_low_pass_filter[i] = l1a_l1s_com.drc_task.parameters->parameters.low_pass_filter[i]; + } + for (i=0; i < DRC_BPF_LENGTH; i++) + { + drc_ndb->a_drc_mid_band_filter[i] = l1a_l1s_com.drc_task.parameters->parameters.mid_band_filter[i]; + } + + } + + #endif // L1_DRC == 1 + +#if(L1_BT_AUDIO == 1) +BOOL L1Audio_InformBtAudioPathState (BOOL connected) +{ + if(connected==bt_audio.connected_status) + return BT_STATUS_OK; + else + return BT_STATUS_ERROR; +} + +void L1Audio_RegisterBthal (L1AudioPcmCallback pcmCallback, L1AudioConfigureCallback configCallback) +{ + bt_audio.audio_configure_callback=configCallback; + bt_audio.audio_pcmblock_callback=pcmCallback; +} +UWORD8 bt_flag=1; + + +L1AudioPcmStatus L1Audio_PullPcmBlock (L1AudioPcmBlock *pcmBlock) +{ + UWORD8 status=0; + if(bt_flag == 0) + { + AUDIO_SEND_TRACE("pull back bef init",RV_TRACE_LEVEL_ERROR); + bt_audio.pcm_data_ready = 0; + // return L1_PCM_PENDING; + } +// AUDIO_SEND_TRACE("pull back called",RV_TRACE_LEVEL_ERROR); + + if(bt_audio.pcm_data_end == 1) + { + AUDIO_SEND_TRACE("abnormal BT request mp3/aac",RV_TRACE_LEVEL_ERROR); + + if(bt_audio.pcmblock.lengthInBytes==2*C_MP3_OUTPUT_BUFFER_SIZE) + l1mp3_dma_it_handler(0); + else if(bt_audio.pcmblock.lengthInBytes==2*C_AAC_OUTPUT_BUFFER_SIZE) + l1aac_dma_it_handler(0); + + bt_audio.pcm_data_end = 0; + bt_audio.pcm_data_ready = 0; + bt_flag = 0; + return L1_PCM_MEDIA_ENDED; + } + + + if(bt_audio.pcm_data_failed==0) + { + if(bt_audio.pcm_data_ready>0) + { + //AUDIO_SEND_TRACE("Data ready for BT-Pull event",RV_TRACE_LEVEL_ERROR); + pcmBlock->pcmBuffer= bt_audio.pcmblock.pcmBuffer; + pcmBlock->lengthInBytes=bt_audio.pcmblock.lengthInBytes; + + bt_audio.pcm_data_ready=0; + + if( bt_audio.pcm_data_end==1) + { + AUDIO_SEND_TRACE("Data ended for BT-Pull event",RV_TRACE_LEVEL_ERROR); + return L1_PCM_MEDIA_ENDED; + } + else + if(bt_audio.pcmblock.lengthInBytes==2*AUDIO_EXT_MIDI_BUFFER_SIZE) + return L1_PCM_READY; + else + status= L1_PCM_READY; + } + else + { + if( bt_audio.pcm_data_end==1) + { + AUDIO_SEND_TRACE("Data ended for BT-Pull event",RV_TRACE_LEVEL_ERROR); + return L1_PCM_MEDIA_ENDED; + } + // AUDIO_SEND_TRACE("Data pending for BT-Pull event",RV_TRACE_LEVEL_ERROR); + bt_audio.pcm_data_pending=1; + status= L1_PCM_PENDING; + } + } + else + { + AUDIO_SEND_TRACE("Data failed for BT-Pull event",RV_TRACE_LEVEL_ERROR); + return L1_PCM_FAILED; + } +if((bt_audio.pcmblock.lengthInBytes==2*C_MP3_OUTPUT_BUFFER_SIZE)&& bt_flag==1) +{ + if(l1a_apihisr_com.mp3.command.stop==TRUE) + { + bt_flag=0; + l1mp3_dma_it_handler(0); + bt_audio.pcm_data_end = 0; + return L1_PCM_MEDIA_ENDED; + } + else + l1mp3_dma_it_handler(0); + +} +else if(bt_audio.pcmblock.lengthInBytes==2*C_AAC_OUTPUT_BUFFER_SIZE&& bt_flag==1) +{ + if(l1a_apihisr_com.aac.command.stop==TRUE) + { + bt_flag=0; + AUDIO_SEND_TRACE("Media ended for BT-Pull event",RV_TRACE_LEVEL_ERROR); + l1aac_dma_it_handler(0); + bt_audio.pcm_data_end = 0; + return L1_PCM_MEDIA_ENDED; + } + else + l1aac_dma_it_handler(0); +} +else if(bt_audio.pcmblock.lengthInBytes==2*AUDIO_EXT_MIDI_BUFFER_SIZE && bt_flag==1) + if( bt_audio.pcm_data_end==1) + { + bt_flag=0; + return L1_PCM_MEDIA_ENDED; + } + else + l1a_bt_audio_noti_process(); +return status; + + +} + +void l1_audio_bt_init(UINT16 media_buf_size) +{ + bt_audio.pcm_data_pending =0; + bt_audio.pcm_data_end =0; + bt_audio.pcm_data_ready =1; + bt_audio.pcm_data_failed =0; + + bt_flag=1; + +if(media_buf_size==C_MP3_OUTPUT_BUFFER_SIZE) +{ + bt_audio.pcmblock.pcmBuffer=(UWORD8 *)&mp3_dma->a_mp3_dma_input_buffer[0][0]; + bt_audio.pcmblock.lengthInBytes=2*media_buf_size; +} +else if(media_buf_size==C_AAC_OUTPUT_BUFFER_SIZE) +{ + bt_audio.pcmblock.pcmBuffer=(UWORD8 *)&aac_dma->a_aac_dma_input_buffer[0][0]; + bt_audio.pcmblock.lengthInBytes=2*media_buf_size; +} +else if(media_buf_size==AUDIO_EXT_MIDI_BUFFER_SIZE) +{ + bt_audio.pcmblock.pcmBuffer=(UWORD8 *)&midi_buf.audio_play_buffer[0]; + bt_audio.pcmblock.lengthInBytes=2*media_buf_size; +} +} +#endif//L1_BT_AUDIO == 1 + +#if(L1_BT_AUDIO==1) ||(L1_WCM==1) +void l1_audio_manager(UWORD8 *src, UWORD16 size) +{ + UWORD16 i ; +#if(L1_BT_AUDIO==1) + bt_audio.pcmblock.pcmBuffer=src; + bt_audio.pcmblock.lengthInBytes=2*size; +#endif + + #if (OP_L1_STANDALONE == 0) + #if 0 + // l1_audio_wcm(src,size); + if( wcm_enable == 1) + { + switch(size) + { + case 2048: + + arm_wcm_module( AAC, (T_SINT16 *)src , &wcm_output[0]); + break; + case 1152: + + arm_wcm_module( MP3, (T_SINT16 *)src , &wcm_output[0]); + break; + + + } + + for (i=0 ; i< size ; i++) + while(size>0) + { + *src++=(API)*wcm_output++; + size--; + } + + /* for (i=0 ; i< size ; i++) + { + *src++ = (UINT8 )wcm_output[i]&0x00ff; + *src++ = (UINT8 )(wcm_output[i] & 0xff00) >> 8; + } + */ + + } + + + #endif + #endif + + #if(L1_BT_AUDIO==1) + if(bt_audio.connected_status==TRUE) + { + if(bt_audio.pcm_data_pending>0) + { + bt_audio.pcm_data_pending = 0; + AUDIO_SEND_TRACE("Pending callback",RV_TRACE_LEVEL_ERROR); + bt_audio.audio_pcmblock_callback(&bt_audio.pcmblock); + + } + else + bt_audio.pcm_data_ready = 1; + } + #endif +} +#endif + +#if 0 /* FreeCalypso: LoCosto function not present in TCS211 */ +UWORD16 l1_ext_audio_get_frequencyrate(UWORD16 frequency_index) +{ + UWORD16 sampling_frequency=0; + + switch(frequency_index) + { + case 1: + sampling_frequency=8000; + break; + case 2: + sampling_frequency=11025; + break; + case 3: + sampling_frequency=16000; + break; + case 4: + sampling_frequency=22050; + break; + case 5: + sampling_frequency=32000; + break; + case 6: + sampling_frequency=44100; + break; + case 7: + sampling_frequency=48000; + break; + } + + // Sampling frequency should never be zero + return sampling_frequency; +} +#endif + +#endif // AUDIO_TASK
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/audio_cfile/l1audio_init.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,685 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_INIT.C + * + * Filename l1audio_init.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ + +#include "l1_macro.h" +#include "l1_confg.h" + + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + #include "l1_time.h" + #include "l1_scen.h" + #else // NOT SIMULATION + + // Layer1 and debug include files. + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + #include "l1_time.h" + + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + #endif // NOT_SIMULATION + +#if (L1_DRC == 1) + extern T_DRC_MCU_DSP *drc_ndb; + #if (CODE_VERSION == SIMULATION) + extern T_DRC_MCU_DSP drc_ndb_sim; + #endif +#endif + +#if(L1_BT_AUDIO ==1) + extern T_L1_BT_AUDIO bt_audio; +#endif + + /**************************************/ + /* Prototypes for L1 initialization */ + /**************************************/ + void l1audio_dsp_init (void); + void l1audio_initialize_var (void); + + /**************************************/ + /* External prototypes */ + /**************************************/ + + /*-------------------------------------------------------*/ + /* l1audio_dsp_init() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Initialize the part of the API */ + /* dedicated to the audio task. */ + /* */ + /*-------------------------------------------------------*/ + void l1audio_dsp_init(void) + { + UWORD8 i, j; + + //----------------------------------- + // AUDIO control words initialization + //----------------------------------- + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init = 0; // MCU/DSP audio task com. register + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status = 0; // MCU/DSP audio task com. register + + #if (KEYBEEP) + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_kt0 = 0; // keybeep variable + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_kt1 = 0; // keybeep variable + l1s_dsp_com.dsp_ndb_ptr->d_dur_kb = 0; // keybeep variable + #endif + + #if ((TONE) || (VOICE_MEMO)) + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t0 = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t1 = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t2 = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_pe_rep = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_pe_off = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_se_off = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_bu_off = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_t0_on = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_t0_off = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_t1_on = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_t1_off = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_t2_on = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_t2_off = 0; // tone variable + + l1s_dsp_com.dsp_ndb_ptr->d_shiftul = 0x100; + l1s_dsp_com.dsp_ndb_ptr->d_shiftdl = 0x100; + #endif // (TONE) || (VOICE_MEMO) + #if (L1_PCM_EXTRACTION) + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = 0; + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = 0; + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_error = 0; + #endif + + // Correction of PR G23M/L1_MCU-SPR-15494 + #if ((CHIPSET == 12) || (CHIPSET == 15)) + #if (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39) + l1s_dsp_com.dsp_ndb_ptr->d_cport_init = 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_ctrl = 0; + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[0] = 0; + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[1] = 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_tcl_tadt = 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_tdat = 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_tvs = 0; + #endif + #endif + + #if (L1_VOICE_MEMO_AMR) + l1s_dsp_com.dsp_ndb_ptr->d_shiftul = 0x100; + #endif // L1_VOICE_MEMO_AMR + + #if (MELODY_E1) + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used = 0; + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_active = 0; + + l1s_dsp_com.dsp_ndb_ptr->a_melo_note0[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note1[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note2[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note3[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note4[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note5[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note6[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note7[0] = SC_END_OSCILLATOR_MASK; + #endif // MELODY_E1 + + // Initialize the FIR as an all band pass + // IMPORTANT NOTE: FIR/DL parameters are also initialized for DSP 36 when L1_IIR == 1 because + // in FIR loop mode, the old FIR API is still used + #if (DSP == 33) || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)// The FIR coefficents are in param memory + l1s_dsp_com.dsp_param_ptr->a_fir31_downlink[0] = 0x4000; + l1s_dsp_com.dsp_param_ptr->a_fir31_uplink[0] = 0x4000; + #else + l1s_dsp_com.dsp_ndb_ptr->a_fir31_downlink[0] = 0x4000; + l1s_dsp_com.dsp_ndb_ptr->a_fir31_uplink[0] = 0x4000; + #endif + + for (i=1; i<MAX_FIR_COEF; i++) + { + #if (DSP == 33) || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)// The FIR coefficents are in param memory + l1s_dsp_com.dsp_param_ptr->a_fir31_downlink[i] = 0; + l1s_dsp_com.dsp_param_ptr->a_fir31_uplink[i] = 0; + #else + l1s_dsp_com.dsp_ndb_ptr->a_fir31_downlink[i] = 0; + l1s_dsp_com.dsp_ndb_ptr->a_fir31_uplink[i] = 0; + #endif + } + #if (DSP == 17) || (DSP == 32) + // start the FIR task + l1s_dsp_com.dsp_ndb_ptr->d_audio_init |= B_FIR_START; + #endif + + #if (L1_IIR == 1) + // IIR enabled by default + // Set the default configuration (all band pass - FIR only mode) + l1s_dsp_com.dsp_ndb_ptr->d_iir_nb_iir_blocks = 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir_nb_fir_coefs = 0x1f; + + l1s_dsp_com.dsp_ndb_ptr->a_iir_fir_coefs[0] = 0x4000; + for (i=1; i < (l1s_dsp_com.dsp_ndb_ptr->d_iir_nb_fir_coefs - 1); i++) + l1s_dsp_com.dsp_ndb_ptr->a_iir_fir_coefs[i] = 0; + + l1s_dsp_com.dsp_ndb_ptr->d_iir_input_scaling = 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir_fir_scaling = 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir_input_gain_scaling = 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir_output_gain_scaling = 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir_output_gain = 0xffff; + l1s_dsp_com.dsp_ndb_ptr->d_iir_feedback = 0; + #endif + + #if (AUDIO_MODE) + // Reset the FIR loopback and the audio mode + l1s_dsp_com.dsp_ndb_ptr->d_audio_init &= ~(B_FIR_LOOP | B_GSM_ONLY | B_BT_HEADSET | B_BT_CORDLESS); + // Set the GSM mode + l1s_dsp_com.dsp_ndb_ptr->d_audio_init |= B_GSM_ONLY; + #else + // Reset the loopback + l1s_dsp_com.dsp_ndb_ptr->d_audio_init &= ~(B_FIR_LOOP); + #endif + + #if (W_A_DSP_SR_BGD) + // Initialize the DSP speech reco background task + + // DSP background enabled for SR. + l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt = (B_DSPBGD_RECO | B_DSPBGD_UPD); + l1s_dsp_com.dsp_ndb_ptr->d_max_background = 7; + + // TEMPORARY: Init DSP background interface for RECO. + if (l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt & B_DSPBGD_RECO) + { + l1s_dsp_com.dsp_ndb_ptr->d_background_enable &= ~(1 << C_BGD_RECOGN); + l1s_dsp_com.dsp_ndb_ptr->d_background_abort &= ~(1 << C_BGD_RECOGN); + l1s_dsp_com.dsp_ndb_ptr->a_background_tasks[C_BGD_RECOGN] = (C_BGD_RECOGN<<11) | 1; + l1s_dsp_com.dsp_ndb_ptr->a_back_task_io[C_BGD_RECOGN] = (API)(0x0000); // Not used by Recognition task. + } + if (l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt & B_DSPBGD_UPD) + { + l1s_dsp_com.dsp_ndb_ptr->d_background_enable &= ~(1 << C_BGD_ALIGN); + l1s_dsp_com.dsp_ndb_ptr->d_background_abort &= ~(1 << C_BGD_ALIGN); + l1s_dsp_com.dsp_ndb_ptr->a_background_tasks[C_BGD_ALIGN] = (C_BGD_ALIGN<<11) | 1; + l1s_dsp_com.dsp_ndb_ptr->a_back_task_io[C_BGD_ALIGN] = (API)(0x0000); // Not used by Alignement task. + } + #elif (DSP == 33) || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39) + // DSP background task through pending task queue + l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt = 0; + #endif + + #if (MELODY_E2) + // Initalize the Audio compressor used for E2 + l1s_dsp_com.dsp_ndb_ptr->d_audio_compressor_ctrl = 0x0401; + + // Initialize the melody E2 variables + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_osc_stop = 0x0000; + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_osc_active = 0x0000; + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore = 0x0000; + for(i=0; i<SC_MELODY_E2_NUMBER_OF_OSCILLATOR; i++) + { + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[i][0] = 0x0000; + } + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = 0x0000; + + for (i=0; i<(SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT); i++) + { + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[i] = 0x0000; + } + + /* FreeCalypso: reconstructed from disassembly of TCS211 object */ + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_deltatime = 0; + + // Reset the flag to know if the DSP melody E2 task runs + l1s.melody_e2.dsp_task = FALSE; + #endif // MELODY_E2 + + #if ((DSP==33) || (DSP == 34) || (DSP==35) || (DSP==36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = NO_MELODY_SELECTED; + #endif + + + #if ((CHIPSET == 4) || (CHIPSET == 12) || (CHIPSET == 15) || ((CHIPSET==10) && (OP_WCP==1))) && ((DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + l1s_dsp_com.dsp_ndb_ptr->d_es_ctrl = 0; // ES control + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = 0; // ANR control + #if (L1_IIR == 1) + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_ENABLE; // IIR control: enabled by default + #else + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = 0; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl = 0; // Limiter control + + #endif + +#if (DSP == 38) || (DSP == 39) + + //----------------------------------- + // AUDIO control words initialization + //----------------------------------- + + l1s_dsp_com.dsp_ndb_ptr->d_es_ctrl = 0; // ES control + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = 0; // ANR control + l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl = 0; // AEC control + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_ctrl = 0; // AGC control + + #if (L1_IIR == 1) + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_ENABLE; // IIR control: enabled by default + #else + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = 0; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl = 0; // Limiter control + l1s_dsp_com.dsp_ndb_ptr->d_drc_dl_ctrl = 0; // DRC control + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_ctrl = 0; // AGC control + l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_ctrl = 0; // WCM control + l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_status = 0; // WCM status + l1s_dsp_com.dsp_ndb_ptr->d_aqi_status = 0; // Initialise the status word + +#if(L1_ANR == 2) + l1s_dsp_com.dsp_ndb_ptr->d_anr_control = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_anr_ns_level = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_anr_tone_ene_th = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_anr_tone_cnt_th = (API) 0; +#endif + +#if(L1_IIR == 2) + // Set IIR parameters + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_control = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_frame_size = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_swap = (API) 0; + + // Set parameter os FIR part + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_enable = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_length = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_shift = (API) 0; + + for (i=0; i < IIR_4X_FIR_MAX_LENGTH; i++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_fir_taps[i] = (API) 0; + } + + // Set parameters for IIR part + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_enable = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_number = (API) 0; + + // Set parameters for IIR part - SOS 1 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_1 = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_1 = (API) 0; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_1[j] = (API) 0; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_1[j] = (API) 0; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_1 = (API) 0; + + // Set parameters for IIR part - SOS 2 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_2 = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_2 = (API) 0; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_2[j] = (API) 0; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_2[j] = (API) 0; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_2 = (API) 0; + + // Set parameters for IIR part - SOS 3 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_3 = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_3 = (API) 0; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_3[j] = (API) 0; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_3[j] = (API) 0; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_3 = (API) 0; + + // Set parameters for IIR part - SOS 4 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_4 = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_4 = (API) 0; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_4[j] = (API) 0; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_4[j] = (API) 0; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_4 = (API) 0; + + // Set parameters for IIR part - SOS 5 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_5 = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_5 = (API) 0; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_5[j] = (API) 0; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_5[j] = (API) 0; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_5 = (API) 0; + + // Set parameters for IIR part - SOS 6 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_6 = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_6 = (API) 0; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_6[j] = (API) 0; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_6[j] = (API) 0; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_6 = (API) 0; + + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_gain = (API) 0; + +#endif + +#if(L1_AGC_UL == 1) + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_control = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_frame_size = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_targeted_level = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_signal_up = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_signal_down = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_max_scale = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_alpha = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_alpha_fast = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_beta = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_beta_fast = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_intp_flag = (API) 0; +#endif + +#if(L1_AGC_DL == 1) + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_control = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_frame_size = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_targeted_level = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_signal_up = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_signal_down = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_max_scale = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_alpha = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_alpha_fast = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_beta = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_beta_fast = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_intp_flag = (API) 0; +#endif + +#if(L1_WCM == 1) + + l1s_dsp_com.dsp_ndb_ptr->d_wcm_mode = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_frame_size = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_num_sub_frames = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_ratio = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_threshold = (API) 0; +#endif + +#endif // DSP 38 + +} + + +#if (AUDIO_TASK == 1) + + /*-------------------------------------------------------*/ + /* l1audio_initialize_var() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Initialize the part of l1a, l1s and */ + /* l1a_l1s_com dedicated to the audio task.*/ + /* */ + /*-------------------------------------------------------*/ + void l1audio_initialize_var(void) + { + UWORD8 i, j; + + // Initialize the state of the L1S maanger... + //-------------------------------------------- + for(i=0; i<NBR_AUDIO_MANAGER; i++) + { + l1s.audio_state[i] = 0; + } + + #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1) + l1a_l1s_com.audio_onoff_task.parameters.onoff_value = FALSE; + #endif + #if 0 /* FreeCalypso TCS211 reconstruction */ + l1a_l1s_com.audio_forced_by_l1s = FALSE; + #endif + + #if (MELODY_E1) + l1s.melody0.oscillator[0] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note0[0]); + l1s.melody0.oscillator[1] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note1[0]); + l1s.melody0.oscillator[2] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note2[0]); + l1s.melody0.oscillator[3] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note3[0]); + l1s.melody0.oscillator[4] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note4[0]); + l1s.melody0.oscillator[5] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note5[0]); + l1s.melody0.oscillator[6] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note6[0]); + l1s.melody0.oscillator[7] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note7[0]); + + l1s.melody1.oscillator[0] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note0[0]); + l1s.melody1.oscillator[1] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note1[0]); + l1s.melody1.oscillator[2] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note2[0]); + l1s.melody1.oscillator[3] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note3[0]); + l1s.melody1.oscillator[4] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note4[0]); + l1s.melody1.oscillator[5] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note5[0]); + l1s.melody1.oscillator[6] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note6[0]); + l1s.melody1.oscillator[7] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note7[0]); + #endif // MELODY_E1 + + #if (MELODY_E2) + // Initialization ofthe audio background melody E2 load insturment variable + audioback_melody_e2.allowed_size = + SC_AUDIO_MELODY_E2_MAX_SIZE_OF_INSTRUMENT; + audioback_melody_e2.API_address = + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_wave; + + for (i=0; i < SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT; i++) + { + audioback_melody_e2.number_of_user[i] = 0; + } + #endif // MELODY_E2 + + #if (L1_STEREOPATH == 1) + // Reset the stereopath L1S commands + l1a_l1s_com.stereopath_drv_task.command.start = FALSE; + l1a_l1s_com.stereopath_drv_task.command.stop = FALSE; + #endif + +// Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request = 0; + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request = 0; + + l1s.audio_on_off_ctl.l1_audio_ul_on2off_hold_time = + L1_AUDIO_ON2OFF_UL_HOLD_TIME; + l1s.audio_on_off_ctl.l1_audio_dl_on2off_hold_time = + L1_AUDIO_ON2OFF_DL_HOLD_TIME; + + l1s.audio_on_off_ctl.l1_audio_ul_action = L1_AUDIO_NO_ACTION; + l1s.audio_on_off_ctl.l1_audio_dl_action = L1_AUDIO_NO_ACTION; + + l1s.audio_on_off_ctl.l1_audio_ul_switched_on = FALSE; + l1s.audio_on_off_ctl.l1_audio_dl_switched_on = FALSE; + + l1s.audio_on_off_ctl.l1_audio_ul_switched_off = TRUE; + l1s.audio_on_off_ctl.l1_audio_dl_switched_off = TRUE; +#endif // L1_AUDIO_MCU_ONOFF + + +#if (L1_DRC == 1) + + // init DRC NDB + drc_ndb = (T_DRC_MCU_DSP *)API_address_dsp2mcu(C_DRC_API_BASE_ADDRESS); + #if (CODE_VERSION == SIMULATION) + { + drc_ndb = &drc_ndb_sim; + } + #endif + + drc_ndb->d_drc_speech_mode_samp_f =(API)0; + drc_ndb->d_drc_num_subbands =(API)0; + drc_ndb->d_drc_frame_len =(API)0; + drc_ndb->d_drc_expansion_knee_fb_bs =(API)0; + drc_ndb->d_drc_expansion_knee_md_hg =(API)0; + drc_ndb->d_drc_expansion_ratio_fb_bs =(API)0; + drc_ndb->d_drc_expansion_ratio_md_hg =(API)0; + drc_ndb->d_drc_max_amplification_fb_bs =(API)0; + drc_ndb->d_drc_max_amplification_md_hg =(API)0; + drc_ndb->d_drc_compression_knee_fb_bs =(API)0; + drc_ndb->d_drc_compression_knee_md_hg =(API)0; + drc_ndb->d_drc_compression_ratio_fb_bs =(API)0; + drc_ndb->d_drc_compression_ratio_md_hg =(API)0; + drc_ndb->d_drc_energy_limiting_th_fb_bs =(API)0; + drc_ndb->d_drc_energy_limiting_th_md_hg =(API)0; + drc_ndb->d_drc_limiter_threshold_fb =(API)0; + drc_ndb->d_drc_limiter_threshold_bs =(API)0; + drc_ndb->d_drc_limiter_threshold_md =(API)0; + drc_ndb->d_drc_limiter_threshold_hg =(API)0; + drc_ndb->d_drc_limiter_hangover_spect_preserve =(API)0; + drc_ndb->d_drc_limiter_release_fb_bs =(API)0; + drc_ndb->d_drc_limiter_release_md_hg =(API)0; + drc_ndb->d_drc_gain_track_fb_bs =(API)0; + drc_ndb->d_drc_gain_track_md_hg =(API)0; + for (j=0; j < DRC_LPF_LENGTH; j++) + { + drc_ndb->a_drc_low_pass_filter[j] = (API)0; + } + for (j=0; j < DRC_BPF_LENGTH; j++) + { + drc_ndb->a_drc_mid_band_filter[j] = (API)0; + } +#endif + +} + +#endif // AUDIO_TASK
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/audio_cfile/l1audio_sync.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,7994 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_SYNC.C + * + * Filename l1audio_sync.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ +#include "l1_macro.h" +#include "l1_confg.h" + +#if (AUDIO_TASK == 1) + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + + #if (L1_MP3 == 1) + #include "l1mp3_const.h" + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_const.h" + #include "l1midi_defty.h" + #endif + + #if (L1_AAC == 1) + #include "l1aac_const.h" + #include "l1aac_defty.h" + #endif + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + #include "l1_time.h" + #include "l1_scen.h" + + #if (L1_STEREOPATH == 1) + #include "sys_dma.h" + #include "abb.h" + #if TESTMODE + #include "l1tm_msgty.h" + #endif + #include "l1audio_stereo.h" + #endif + + #include "mem.h" + + #else + // Layer1 and debug include files. + + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + + #if (L1_MP3 == 1) + #include "l1mp3_const.h" + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_const.h" + #include "l1midi_defty.h" + #endif + + #if (L1_AAC == 1) + #include "l1aac_const.h" + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #include "l1_time.h" + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + + #if (L1_STEREOPATH == 1) + #include "sys_dma.h" + #include "abb.h" + #if TESTMODE + #include "l1tm_msgty.h" + #endif + #include "l1audio_stereo.h" + #endif + + #include "mem.h" + + #endif + + #include "l1audio_macro.h" + #include "l1_trace.h" + +#if (CHIPSET == 15) && (CODE_VERSION != SIMULATION) + #include "bspTwl3029.h" + #include "bspTwl3029_I2c.h" + #include "bspTwl3029_Aud_Map.h" + #include "bspTwl3029_Int_Map.h" +#endif + + /**************************************/ + /* Prototypes for L1 SYNCH manager */ + /**************************************/ + void l1s_audio_manager(void); + #if (KEYBEEP) + void l1s_keybeep_manager(void); + #endif + #if (TONE) + void l1s_tone_manager(void); + #endif + #if (L1_CPORT == 1) + void l1s_cport_manager(void); + #endif + #if (MELODY_E1) + void l1s_melody0_manager(void); + void l1s_melody1_manager(void); + #endif + #if (VOICE_MEMO) + void l1s_vm_play_manager (void); + void l1s_vm_record_manager(void); + void l1s_tone_ul_manager (void); + #endif + #if (L1_PCM_EXTRACTION) + void l1s_pcm_download_manager (void); + void l1s_pcm_upload_manager (void); + #endif + #if (L1_VOICE_MEMO_AMR) + void l1s_vm_amr_play_manager (void); + void l1s_vm_amr_record_manager(void); + #endif + #if (SPEECH_RECO) + void l1s_sr_enroll_manager (void); + void l1s_sr_update_manager (void); + void l1s_sr_reco_manager (void); + void l1s_sr_processing_manager(void); + void l1s_sr_speech_manager (void); + #endif + #if (AEC == 1) + void l1s_aec_manager (void); + #endif + #if (AEC == 2) + void l1s_aec_manager (void); + #endif + #if (FIR) + void l1s_fir_manager (void); + void l1s_fir_set_params (void); + + #endif + #if (AUDIO_MODE) + void l1s_audio_mode_manager (void); + #endif + #if (MELODY_E2) + void l1s_melody0_e2_manager(void); + void l1s_melody1_e2_manager(void); + #endif + #if (L1_MP3 == 1) + void l1s_mp3_manager(void); + #endif + #if (L1_MIDI == 1) + void l1s_midi_manager(void); + #endif + #if (L1_AAC == 1) + void l1s_aac_manager(void); + #endif + #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1) + void l1s_audio_onoff_manager(void); + #endif + #if (L1_EXT_MCU_AUDIO_VOICE_ONOFF == 1) + void l1s_audio_voice_onoff_manager(void); + #endif + #if (L1_STEREOPATH == 1) + void l1s_stereopath_drv_manager(void); + #endif + #if (L1_ANR == 1 || L1_ANR == 2) + void l1s_anr_manager(void); + #endif + #if (L1_IIR == 1 || L1_IIR == 2) + void l1s_iir_manager(void); + #endif + #if (L1_WCM == 1) + void l1s_wcm_manager(void); + #endif + #if (L1_AGC_UL == 1) + void l1s_agc_ul_manager(void); + #endif + #if (L1_AGC_DL == 1) + void l1s_agc_dl_manager(void); + #endif + #if (L1_DRC == 1) + void l1s_drc_manager(void); + #endif + #if (L1_LIMITER == 1) + void l1s_limiter_manager(void); + #endif + #if (L1_ES == 1) + void l1s_es_manager(void); + #endif + + void l1s_audio_it_manager(void); + /**************************************/ + /* External prototypes */ + /**************************************/ + extern UWORD8 copy_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_dst); + extern UWORD8 copy_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_src); + extern UWORD8 Cust_get_pointer (UWORD16 **ptr, UWORD16 *buffer_size, UWORD8 session_id); + #if (MELODY_E2) + extern UWORD16 audio_twentyms_to_TDMA_convertion (UWORD16 twentyms_value); + #endif + #if (MELODY_E2) || (L1_VOICE_MEMO_AMR) + extern UWORD8 copy_byte_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_dst); + extern UWORD8 copy_byte_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_src); + #endif + #if (L1_VOICE_MEMO_AMR) + extern UWORD8 copy_byte_data_le_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, API *ptr_dst); + extern UWORD8 copy_byte_data_le_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, API *ptr_src); + #endif + + #if (L1_LIMITER == 1) + void l1_audio_lim_update_mul_low_high (); + #endif + + #if (L1_AGC_UL == 1) + extern void l1_audio_agc_ul_copy_params(); + #endif + + #if (L1_AGC_DL == 1) + extern void l1_audio_agc_dl_copy_params(); + #endif + + #if (L1_IIR == 2) + extern void l1_audio_iir4x_copy_params(); + #endif + +#if (L1_DRC == 1) + extern void l1_audio_drc1x_copy_params(); + #endif + + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + static void l1s_audio_ul_onoff_manager(); + static void l1s_audio_dl_onoff_manager(); + + void l1_audio_abb_ul_on_callback(void); + void l1_audio_abb_ul_off_callback(void); + void l1_audio_abb_dl_on_callback(void); + void l1_audio_abb_dl_off_callback(void); + void l1_audio_abb_ul_off_dl_off_callback(void); + void l1_audio_abb_ul_off_dl_on_callback(void); + void l1_audio_abb_ul_on_dl_off_callback(void); + void l1_audio_abb_ul_on_dl_on_callback(void); + void l1_audio_ul_onoff_trace(); + void l1_audio_dl_onoff_trace(); +#if (CODE_VERSION != SIMULATION) + BspTwl3029_ReturnCode l1_outen_update(void); +#endif + +#if (CODE_VERSION == SIMULATION) + signed char l1_outen_update(void); +#endif +#endif // L1_AUDIO_MCU_ONOFF + +#if (CODE_VERSION == SIMULATION)&&(L1_AUDIO_MCU_ONOFF == 1) + +// Triton Audio ON/OFF Changes +void l1_audio_abb_ul_on_req ( void(*callback_fn)(void) ); +void l1_audio_abb_dl_on_req ( void(*callback_fn)(void) ); +void l1_audio_abb_ul_off_req ( void(*callback_fn)(void) ); +void l1_audio_abb_dl_off_req ( void(*callback_fn)(void) ); +void l1_audio_abb_ul_off_dl_off_req ( void(*callback_fn)(void) ); +void l1_audio_abb_ul_off_dl_on_req ( void(*callback_fn)(void) ); +void l1_audio_abb_ul_on_dl_off_req ( void(*callback_fn)(void) ); +void l1_audio_abb_ul_on_dl_on_req ( void(*callback_fn)(void) ); + + +#endif + +#if (ANLG_FAM == 11) +//sundi: add the abb_write_done variable for I2C write acknowledgement +//UWORD8 abb_write_done = 0; +#endif + + /*-------------------------------------------------------*/ + /* l1s_audio_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Global manager of the L1S audio task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_audio_manager(void) + { + BOOL l1_audio_it_com = FALSE; + + // Initialize the ITCOM for audio task + l1s.l1_audio_it_com = FALSE; + + #if (KEYBEEP) + // the keybeep task is activated? + if ((l1a_l1s_com.keybeep_task.command.start) || + (l1s.audio_state[L1S_KEYBEEP_STATE] != 0)) + { + l1s_keybeep_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (TONE) + // the tone task is activated? + if ((l1a_l1s_com.tone_task.command.start) || + (l1s.audio_state[L1S_TONE_STATE] != 0)) + { + l1s_tone_manager(); + l1_audio_it_com = TRUE; + } + #endif + + #if (MELODY_E1) + /* FreeCalypso: reconstructed from TCS211 object */ + if (l1s.melody_e2.dsp_task == FALSE) { + // the melody0 task is activated? + if ((l1a_l1s_com.melody0_task.command.start) || + (l1s.audio_state[L1S_MELODY0_STATE] != 0)) + { + l1s_melody0_manager(); + l1_audio_it_com = TRUE; + } + // the melody1 task is activated? + if ((l1a_l1s_com.melody1_task.command.start) || + (l1s.audio_state[L1S_MELODY1_STATE] != 0)) + { + l1s_melody1_manager(); + l1_audio_it_com = TRUE; + } + } + #endif + #if (VOICE_MEMO) + // the voicememo playing task is activated? + if ((l1a_l1s_com.voicememo_task.play.command.start) || + (l1s.audio_state[L1S_VM_PLAY_STATE] != 0)) + { + l1s_vm_play_manager(); + l1_audio_it_com = TRUE; + } + else // voicememo playing task and voice memo recoding task isn't compatible + { + // the voicememo recording task is activated? + if ((l1a_l1s_com.voicememo_task.record.command.start) || + (l1s.audio_state[L1S_VM_RECORD_STATE] != 0)) + { + l1s_vm_record_manager(); + l1_audio_it_com = TRUE; + } + // the voicememo tone uplink task is activated? + if ((l1a_l1s_com.voicememo_task.record.tone_ul.start) || + (l1s.audio_state[L1S_TONE_UL_STATE] != 0)) + { + l1s_tone_ul_manager(); + l1_audio_it_com = TRUE; + } + } + #endif + #if (L1_PCM_EXTRACTION) + // the PCM download task is activated? + if ((l1a_l1s_com.pcm_task.download.command.start) || + (l1s.audio_state[L1S_PCM_DOWNLOAD_STATE] != 0)) + { + l1s_pcm_download_manager(); + l1_audio_it_com = TRUE; + } + // the PCM upload task is activated? + if ((l1a_l1s_com.pcm_task.upload.command.start) || + (l1s.audio_state[L1S_PCM_UPLOAD_STATE] != 0)) + { + l1s_pcm_upload_manager(); + l1_audio_it_com = TRUE; + } + #endif /* L1_PCM_EXTRACTION */ + #if (L1_VOICE_MEMO_AMR) + // the voicememo playing task is activated? + if ((l1a_l1s_com.voicememo_amr_task.play.command.start) || + (l1s.audio_state[L1S_VM_AMR_PLAY_STATE] != 0)) + { + l1s_vm_amr_play_manager(); + l1_audio_it_com = TRUE; + } + else // voicememo playing task and voice memo recoding task isn't compatible + { + // the voicememo recording task is activated? + if ((l1a_l1s_com.voicememo_amr_task.record.command.start) || + (l1s.audio_state[L1S_VM_AMR_RECORD_STATE] != 0)) + { + l1s_vm_amr_record_manager(); + l1_audio_it_com = TRUE; + } + } + #endif + #if (SPEECH_RECO) + // the speech recognition enroll task is activated? + if ((l1a_l1s_com.speechreco_task.command.enroll_start) || + (l1s.audio_state[L1S_SR_ENROLL_STATE] != 0)) + { + l1s_sr_enroll_manager(); + l1_audio_it_com = TRUE; + } + else + // the speech recognition update task is activated? + if ((l1a_l1s_com.speechreco_task.command.update_start) || + (l1s.audio_state[L1S_SR_UPDATE_STATE] != 0)) + { + l1s_sr_update_manager(); + l1_audio_it_com = TRUE; + } + else + // the speech recognition reco task is activated? + if ((l1a_l1s_com.speechreco_task.command.reco_start) || + (l1s.audio_state[L1S_SR_RECO_STATE] != 0)) + { + l1s_sr_reco_manager(); + l1_audio_it_com = TRUE; + } + else + // the speech recognition processing task is activated? + if ((l1a_l1s_com.speechreco_task.command.processing_start) || + (l1s.audio_state[L1S_SR_PROCESSING_STATE] != 0)) + { + l1s_sr_processing_manager(); + l1_audio_it_com = TRUE; + } + // the speech recognition speech recording task is activated? + if ((l1a_l1s_com.speechreco_task.command.speech_start) || + (l1s.audio_state[L1S_SR_SPEECH_STATE] != 0)) + { + l1s_sr_speech_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (AEC == 1) + // the AEC is activated? + if ((l1a_l1s_com.aec_task.command.start) || + (l1s.audio_state[L1S_AEC_STATE] != 0)) + { + l1s_aec_manager(); + // It's not necessary to enable the IT DSP because the + // AEC works with the dedicated speech therefor an IT DSP is + // already requested by the modem + } + #endif + #if (AEC == 2) + // the AEC is activated? + if ((l1a_l1s_com.aec_task.command.start) || + (l1s.audio_state[L1S_AEC_STATE] != 0)) + { + l1s_aec_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (FIR) + // the FIR is activated? + if (l1a_l1s_com.fir_task.command.start) + { + l1s_fir_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (AUDIO_MODE) + // the AUDIO MODE is activated? + if (l1a_l1s_com.audio_mode_task.command.start) + { + l1s_audio_mode_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (MELODY_E2) + // Handling counters + if (l1s.melody_e2.dsp_task == TRUE) + { + l1s.melody_e2.timebase++; + l1s.melody_e2.timebase_mod_60ms++; + if (l1s.melody_e2.timebase_mod_60ms == 13) + l1s.melody_e2.timebase_mod_60ms = 0; + } + else + { + l1s.melody_e2.timebase = 0; + l1s.melody_e2.timebase_mod_60ms = 0; + } + + // Update the oscillator active fields with DSP active oscillators + l1s.melody_e2.global_osc_active = l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_osc_active; + l1s.melody_e2.global_osc_to_start = 0; + + // oscillator active fields can't be updated until dsp has acknowledged new notes + if (l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore == 0) + { + l1s.melody0_e2.oscillator_active &= l1s.melody_e2.global_osc_active; + l1s.melody1_e2.oscillator_active &= l1s.melody_e2.global_osc_active; + } + + // Both states machines are inactive => Start or Stop DSP module + if ( (l1s.audio_state[L1S_MELODY0_E2_STATE] == 0) && + (l1s.audio_state[L1S_MELODY1_E2_STATE] == 0) ) + { + // Start command + DSP module not running => Start DSP module + if( ((l1a_l1s_com.melody0_e2_task.command.start) || + (l1a_l1s_com.melody1_e2_task.command.start)) && + (l1s.melody_e2.dsp_task == FALSE) ) + { + // Set the bit TONE to do the init only at the first start + // of the first melody (in case of 2 melodies) + // Select the melody E2 instead of E1 or tones + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = MELODY_E2_SELECTED; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (B_MELO | B_TONE); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_deltatime = 0; + + // set delta_time as non valid + l1s.melody0_e2.delta_time = 0xFFFF; + l1s.melody1_e2.delta_time = 0xFFFF; + + // Set the flag to confirm that the DSP melody E2 task is started + l1s.melody_e2.dsp_task = TRUE; + } + // No command, DSP module running => Stop DSP module + else + if (l1s.melody_e2.dsp_task) + { + // The 2 melodies are stopped therefore the DSP must be + // stopped so the bit B_MELO must be reset. + + /* FreeCalypso TCS211 reconstruction from disassembly */ + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & (B_MELO | B_TONE)) { + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & (B_MELO|B_TONE))) { + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = MELODY_E2_SELECTED; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (B_MELO | B_TONE); + } + l1_audio_it_com = TRUE; + } else { + l1s.melody_e2.dsp_task = FALSE; + } + /* end of reconstructed section */ + } + } + + // the melody0 task is activated? + if ( (l1a_l1s_com.melody0_e2_task.command.start) || + (l1s.audio_state[L1S_MELODY0_E2_STATE] != 0) ) + { + l1s_melody0_e2_manager(); + l1_audio_it_com = TRUE; + } + // the melody0 task is activated? + if ( (l1a_l1s_com.melody1_e2_task.command.start) || + (l1s.audio_state[L1S_MELODY1_E2_STATE] != 0) ) + { + l1s_melody1_e2_manager(); + l1_audio_it_com = TRUE; + } + + // We updated some oscillators so we must set the semaphore + if (l1s.melody_e2.global_osc_to_start != 0x0000) + { + // Set the melody E2 semaphore + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore = 0x0001; + + // Update delta_time by min_delta_time(melo0, melo1) + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_deltatime = l1s.melody0_e2.delta_time; + if (l1s.melody1_e2.delta_time < l1s.melody0_e2.delta_time) + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_deltatime = l1s.melody1_e2.delta_time; + + l1s.melody0_e2.delta_time = 0xFFFF; + l1s.melody1_e2.delta_time = 0xFFFF; + } + #endif + + #if (L1_MP3 == 1) + if ((l1a_l1s_com.mp3_task.command.start) || + (l1s.audio_state[L1S_MP3_STATE] != 0)) + { + l1s_mp3_manager(); + l1_audio_it_com=TRUE; + } + #endif // L1_MP3 + + #if (L1_AAC == 1) + if ((l1a_l1s_com.aac_task.command.start) || + (l1s.audio_state[L1S_AAC_STATE] != 0)) + { + l1s_aac_manager(); + l1_audio_it_com=TRUE; + } + #endif // L1_AAC + #if (L1_CPORT == 1) + // the Cport task is activated? + if ((l1a_l1s_com.cport_task.command.start) || + (l1s.audio_state[L1S_CPORT_STATE] != 0)) + { + l1s_cport_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1) + // the audio on off task is activated? + if (l1a_l1s_com.audio_onoff_task.command.start || + (l1s.audio_state[L1S_AUDIO_ONOFF_STATE] != 0)) + { + l1s_audio_onoff_manager(); + l1_audio_it_com = TRUE; + } + #endif + + #if (L1_EXT_MCU_AUDIO_VOICE_ONOFF == 1) + // the audio on off task is activated? + if (l1a_l1s_com.audio_onoff_task.command.start || + (l1s.audio_state[L1S_AUDIO_ONOFF_STATE] != 0)) + { + l1s_audio_voice_onoff_manager(); + l1_audio_it_com = TRUE; + } + #endif + + #if (L1_STEREOPATH == 1) + // the Stereopath task is activated? + if ((l1a_l1s_com.stereopath_drv_task.command.start) || + (l1s.audio_state[L1S_STEREOPATH_DRV_STATE] != 0)) + { + l1s_stereopath_drv_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_ANR == 1 || L1_ANR == 2) + // the ANR task is activated? + if (l1a_l1s_com.anr_task.command.update || + (l1s.audio_state[L1S_ANR_STATE] != 0)) + { + l1s_anr_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_IIR == 1 || L1_IIR == 2) + // the IIR task is activated? + if (l1a_l1s_com.iir_task.command.update || + (l1s.audio_state[L1S_IIR_STATE] != 0)) + { + l1s_iir_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_WCM == 1) + // the WCM task is activated? + if (l1a_l1s_com.wcm_task.command.update || + (l1s.audio_state[L1S_WCM_STATE] != 0)) + { + l1s_wcm_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_DRC == 1) + // the DRC task is activated? + if (l1a_l1s_com.drc_task.command.update || + (l1s.audio_state[L1S_DRC_STATE] != 0)) + { + l1s_drc_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_AGC_UL == 1) + // the AGC UL task is activated? + if (l1a_l1s_com.agc_ul_task.command.update || + (l1s.audio_state[L1S_AGC_UL_STATE] != 0)) + { + l1s_agc_ul_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_AGC_DL == 1) + // the AGC DL task is activated? + if (l1a_l1s_com.agc_dl_task.command.update || + (l1s.audio_state[L1S_AGC_DL_STATE] != 0)) + { + l1s_agc_dl_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_LIMITER == 1) + // the LIMITER task is activated? + if (l1a_l1s_com.limiter_task.command.update || + l1a_l1s_com.limiter_task.command.partial_update || + (l1s.audio_state[L1S_LIMITER_STATE] != 0)) + { + l1s_limiter_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_ES == 1) + // the echo suppressor task is activated? + if (l1a_l1s_com.es_task.command.update || + (l1s.audio_state[L1S_ES_STATE] != 0)) + { + l1s_es_manager(); + l1_audio_it_com = TRUE; + } + #endif + +#if 0 /* FreeCalypso: LoCosto-ism not present in TCS211 */ + // the audio It task is activated? + if (l1a_l1s_com.audioIt_task.command.start) + { + l1s_audio_it_manager(); + l1_audio_it_com = TRUE; + } +#endif + + #if (L1_MIDI == 1) + if ((l1a_l1s_com.midi_task.command.start) || + (l1s.audio_state[L1S_MIDI_STATE] != 0)) + { + l1s_midi_manager(); + l1_audio_it_com=TRUE; + } + #endif // L1_MIDI + +#if 0 /* FreeCalypso: LoCosto-ism not present in TCS211 */ + // The audio IT shall be foprwarded to the DSP in case the L1S is forcing the audio + if (l1a_l1s_com.audio_forced_by_l1s == TRUE) + l1_audio_it_com = TRUE; +#endif + + l1s.l1_audio_it_com = l1_audio_it_com; + } + + +#if (L1_AUDIO_MCU_ONOFF == 1) + void l1s_audio_onoff_manager(void) + { + T_L1S_AUDIO_ONOFF_MANAGER *onoff_ctl = &(l1s.audio_on_off_ctl); + + //l1_audio_onoff_entry_sim_log(); +#if (AUDIO_DEBUG == 1) + trace_info.audio_debug_var.ul_state = l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE]; + trace_info.audio_debug_var.dl_state = l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE]; + trace_info.audio_debug_var.ul_onoff_counter = onoff_ctl->l1_audio_switch_on_ul_request; + trace_info.audio_debug_var.dl_onoff_counter = onoff_ctl->l1_audio_switch_on_dl_request; +#endif + + l1s_audio_ul_onoff_manager(); + l1s_audio_dl_onoff_manager(); + + // Call the driver depending on the actions + switch(onoff_ctl->l1_audio_ul_action) + { + case L1_AUDIO_NO_ACTION: + { + switch(onoff_ctl->l1_audio_dl_action) + { + case L1_AUDIO_NO_ACTION: + { + // UL No Action and DL No Action Do nothing + } + break; + case L1_AUDIO_TURN_ON: + { + // UL No Action and DL Turn on + l1_audio_abb_dl_on_req(l1_audio_abb_dl_on_callback); + } + break; + case L1_AUDIO_TURN_OFF: + { + // UL No Action and DL Turn off + l1_audio_abb_dl_off_req(l1_audio_abb_dl_off_callback); + } + break; + default: + { + // Invalid Action send error trace here + } + break; + } // end switch(l1_audio_dl_action) + } + break; + case L1_AUDIO_TURN_ON: + { + switch(onoff_ctl->l1_audio_dl_action) + { + case L1_AUDIO_NO_ACTION: + { + // UL Action ON and DL No Action + l1_audio_abb_ul_on_req(l1_audio_abb_ul_on_callback); + } + break; + case L1_AUDIO_TURN_ON: + { + // UL Action ON and DL Action ON + l1_audio_abb_ul_on_dl_on_req(l1_audio_abb_ul_on_dl_on_callback); + } + break; + case L1_AUDIO_TURN_OFF: + { + // UL Action ON and DL Action OFF + l1_audio_abb_ul_on_dl_off_req(l1_audio_abb_ul_on_dl_off_callback); + } + break; + default: + { + // Invalid Action Send error trace here + } + break; + } // end switch(l1_audio_dl_action) + + } + break; + case L1_AUDIO_TURN_OFF: + { + switch(onoff_ctl->l1_audio_dl_action) + { + case L1_AUDIO_NO_ACTION: + { + // UL Action OFF DL No Action + l1_audio_abb_ul_off_req(l1_audio_abb_ul_off_callback); + } + break; + case L1_AUDIO_TURN_ON: + { + // UL Action OFF DL Action ON + l1_audio_abb_ul_off_dl_on_req(l1_audio_abb_ul_off_dl_on_callback); + } + break; + case L1_AUDIO_TURN_OFF: + { + // UL Action OFF DL Action OFF + l1_audio_abb_ul_off_dl_off_req(l1_audio_abb_ul_off_dl_off_callback); + } + break; + default: + { + } + break; + } // end switch(l1_audio_dl_action) + + } + break; + default: + { + // Invalid Action send error trace here + } + break; + } // end switch(l1_audio_ul_action) + + } // end l1s_audio_triton_onoff_manager() + + static void l1s_audio_ul_onoff_manager() + { + + T_L1S_AUDIO_ONOFF_MANAGER *onoff_ctl = &(l1s.audio_on_off_ctl); + UWORD8 *state = &l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE]; + + onoff_ctl->l1_audio_ul_action = L1_AUDIO_NO_ACTION; + + + if(onoff_ctl->l1_audio_switch_on_ul_request >= 1) + { + // At least one module requires UL audio path to be on + switch(*state) + { + case L1_AUDIO_UL_OFF: + { + // UL audio path is OFF and needs to be started + onoff_ctl->l1_audio_ul_on2off_hold_time = + L1_AUDIO_ON2OFF_UL_HOLD_TIME; + onoff_ctl->l1_audio_ul_action = L1_AUDIO_TURN_ON; + *state = L1_AUDIO_UL_SWITCHON_STARTED; + onoff_ctl->l1_audio_ul_switched_on = FALSE; + onoff_ctl->l1_audio_ul_switched_off = TRUE; + } + break; + case L1_AUDIO_UL_SWITCHON_STARTED: + { + // UL audio path in the process of turning on + // Check if it is turned on, if so change state to UL on + if(onoff_ctl->l1_audio_ul_switched_on == TRUE) + { + onoff_ctl->l1_audio_ul_switched_off = FALSE; + *state = L1_AUDIO_UL_ON; + } + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_UL_ON: + { + // UL audio path is on and some module wants it to be so + // Do nothing essentially except initialize the hold time + onoff_ctl->l1_audio_ul_on2off_hold_time = + L1_AUDIO_ON2OFF_UL_HOLD_TIME; + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_UL_SWITCHOFF_STARTED: + { + // UL is being switched off and some module requests switch on! + // Since the driver is required to maintain the order of requests + // we perform the same actions as in the UL_OFF state + onoff_ctl->l1_audio_ul_on2off_hold_time = + L1_AUDIO_ON2OFF_UL_HOLD_TIME; + onoff_ctl->l1_audio_ul_action = L1_AUDIO_TURN_ON; + *state = L1_AUDIO_UL_SWITCHON_STARTED; + onoff_ctl->l1_audio_ul_switched_on = FALSE; + onoff_ctl->l1_audio_ul_switched_off = TRUE; + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + default: + { + // Invalid state put error trace here + } + break; + } // end switch(l1_audio_ul_state) + + } // end if(l1_audio_switch_on_ul_req >= 1) + else + { + // No module requires UL Audio path to be on + switch(*state) + { + case L1_AUDIO_UL_OFF: + { + // UL audio path is off and all modules want it that way, do nothing + } + break; + case L1_AUDIO_UL_SWITCHON_STARTED: + { + // UL audio path being switched on. Modules want it turned off! + // Allow UL to be turned on, still if modules want it turned off + // we will wait for ON2OFF hold time and turn it off + if(onoff_ctl->l1_audio_ul_switched_on == TRUE) + { + onoff_ctl->l1_audio_ul_switched_off = FALSE; + *state = L1_AUDIO_UL_ON; + } + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_UL_ON: + { + // UL audio path is on and all modules want turn off. We wait + // for the ON2OFF hold time and then actually turn it off + if(onoff_ctl->l1_audio_ul_on2off_hold_time == 0) + { + onoff_ctl->l1_audio_ul_action = L1_AUDIO_TURN_OFF; + *state = L1_AUDIO_UL_SWITCHOFF_STARTED; + onoff_ctl->l1_audio_ul_switched_off = FALSE; + onoff_ctl->l1_audio_ul_switched_on = TRUE; + } + else + onoff_ctl->l1_audio_ul_on2off_hold_time--; + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_UL_SWITCHOFF_STARTED: + { + if(onoff_ctl->l1_audio_ul_switched_off == TRUE) + { + *state = L1_AUDIO_UL_OFF; + } + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + default: + { + // Invalid state send error trace here + } + break; + } // end switch(l1_audio_ul_state) + + } // end if(l1_audio_switch_on_ul_req >= 1)else + +#if (CODE_VERSION == SIMULATION) + l1_audio_ul_onoff_simu_trace(); +#else + l1_audio_ul_onoff_trace(); +#endif + + } // end l1s_audio_ul_onoff_manager() + + static void l1s_audio_dl_onoff_manager() + { + + T_L1S_AUDIO_ONOFF_MANAGER *onoff_ctl = &(l1s.audio_on_off_ctl); + UWORD8 *state = &l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE]; + + onoff_ctl->l1_audio_dl_action = L1_AUDIO_NO_ACTION; + + + if(onoff_ctl->l1_audio_switch_on_dl_request >= 1) + { + // At least one module requires DL audio path to be on + switch(*state) + { + case L1_AUDIO_DL_OFF: + { + // DL audio path is OFF and needs to be started + onoff_ctl->l1_audio_dl_on2off_hold_time = + L1_AUDIO_ON2OFF_DL_HOLD_TIME; + onoff_ctl->l1_audio_dl_action = L1_AUDIO_TURN_ON; + *state = L1_AUDIO_DL_SWITCHON_STARTED; + onoff_ctl->l1_audio_dl_switched_on = FALSE; + onoff_ctl->l1_audio_dl_switched_off = TRUE; + } + break; + case L1_AUDIO_DL_SWITCHON_STARTED: + { + // DL audio path in the process of turning on + // Check if it is turned on, if so change state to DL on + if(onoff_ctl->l1_audio_dl_switched_on == TRUE) + { + onoff_ctl->l1_audio_dl_switched_off = FALSE; + *state = L1_AUDIO_DL_ON; + } + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_DL_ON: + { + + /* OUTEN registers have been updated */ + if(l1a_l1s_com.outen_cfg_task.command_requested != l1a_l1s_com.outen_cfg_task.command_commited) + { + #if (CODE_VERSION != SIMULATION) + l1_outen_update(); + #endif + } + // DL audio path is on and some module wants it to be so + // Do nothing essentially except initialize the hold time + onoff_ctl->l1_audio_dl_on2off_hold_time = + L1_AUDIO_ON2OFF_DL_HOLD_TIME; + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_DL_SWITCHOFF_STARTED: + { + // DL is being switched off and some module requests switch on! + // Since the driver is required to maintain the order of requests + // we perform the same actions as in the DL_OFF state + onoff_ctl->l1_audio_dl_on2off_hold_time = + L1_AUDIO_ON2OFF_DL_HOLD_TIME; + onoff_ctl->l1_audio_dl_action = L1_AUDIO_TURN_ON; + *state = L1_AUDIO_DL_SWITCHON_STARTED; + onoff_ctl->l1_audio_dl_switched_on = FALSE; + onoff_ctl->l1_audio_dl_switched_off = TRUE; + + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + default: + { + // Invalid state put error trace here + } + break; + } // end switch(l1_audio_dl_state) + + } // end if(l1_audio_switch_on_dl_req >= 1) + else + { + // No module requires DL Audio path to be on + switch(*state) + { + case L1_AUDIO_DL_OFF: + { + // DL audio path is off and all modules want it that way, do nothing + } + break; + case L1_AUDIO_DL_SWITCHON_STARTED: + { + // DL audio path being switched on. Modules want it turned off! + // Allow DL to be turned on, still if modules want it turned off + // we will wait for ON2OFF hold time and turn it off + if(onoff_ctl->l1_audio_dl_switched_on == TRUE) + { + onoff_ctl->l1_audio_dl_switched_off = FALSE; + *state = L1_AUDIO_DL_ON; + } + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_DL_ON: + { + // DL audio path is on and all modules want turn off. We wait + // for the ON2OFF hold time and then actually turn it off + if(onoff_ctl->l1_audio_dl_on2off_hold_time == 0) + { + onoff_ctl->l1_audio_dl_action = L1_AUDIO_TURN_OFF; + *state = L1_AUDIO_DL_SWITCHOFF_STARTED; + onoff_ctl->l1_audio_dl_switched_off = FALSE; + onoff_ctl->l1_audio_dl_switched_on = TRUE; + } + else + onoff_ctl->l1_audio_dl_on2off_hold_time--; + + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_DL_SWITCHOFF_STARTED: + { + if(onoff_ctl->l1_audio_dl_switched_off == TRUE) + { + *state = L1_AUDIO_DL_OFF; + } + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + default: + { + // Invalid state send error trace here + } + break; + } // end switch(l1_audio_dl_state) + + } // end if(l1_audio_switch_on_dl_req >= 1)else + +#if (CODE_VERSION == SIMULATION) + l1_audio_dl_onoff_simu_trace(); +#else + l1_audio_dl_onoff_trace(); +#endif + + + } // end l1s_audio_dl_onoff_manager() + +#if (CODE_VERSION == NOT_SIMULATION) +void l1_audio_ul_onoff_trace() +{ + static T_L1_AUDIO_UL_STATE prev_state = L1_INVALID; + UWORD8 *curr_state = &l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE]; + + if(*curr_state != prev_state) + { + prev_state =(T_L1_AUDIO_UL_STATE) *curr_state; + switch(prev_state) + { + case L1_AUDIO_UL_OFF: + { + //L1_trace_string("UL AUDIO OFF\r\n"); + l1_trace_ul_audio_onoff(L1_AUDIO_UL_OFF); + } + break; + case L1_AUDIO_UL_SWITCHON_STARTED: + { + l1_trace_ul_audio_onoff(L1_AUDIO_UL_SWITCHON_STARTED); + } + break; + case L1_AUDIO_UL_ON: + { + l1_trace_ul_audio_onoff(L1_AUDIO_UL_ON); + } + break; + case L1_AUDIO_UL_SWITCHOFF_STARTED: + { + l1_trace_ul_audio_onoff(L1_AUDIO_UL_SWITCHOFF_STARTED); + } + break; + + } // End switch(prev_state) + } // end if(l1s.ul_state == prev_state) + +} + +void l1_audio_dl_onoff_trace() +{ + static T_L1_AUDIO_DL_STATE prev_state = L1_DL_INVALID; + UWORD8 *curr_state = &l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE]; + + if(*curr_state != prev_state) + { + prev_state = (T_L1_AUDIO_DL_STATE) *curr_state; + switch(prev_state) + { + case L1_AUDIO_DL_OFF: + { + l1_trace_dl_audio_onoff(L1_AUDIO_DL_OFF); + } + break; + case L1_AUDIO_DL_SWITCHON_STARTED: + { + l1_trace_dl_audio_onoff(L1_AUDIO_DL_SWITCHON_STARTED); + } + break; + case L1_AUDIO_DL_ON: + { + l1_trace_dl_audio_onoff(L1_AUDIO_DL_ON); + } + break; + case L1_AUDIO_DL_SWITCHOFF_STARTED: + { + l1_trace_dl_audio_onoff(L1_AUDIO_DL_SWITCHOFF_STARTED); + } + break; + + } // End switch(prev_state) + } // end if(l1s.ul_state == prev_state) +} + +#endif // CODE_VERSION == NOT_SIMULATION + + void l1_audio_abb_ul_on_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_ul_switched_on = TRUE; + } + void l1_audio_abb_ul_off_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_ul_switched_off = TRUE; + } + void l1_audio_abb_dl_on_callback(void) + { + l1_outen_update(); + } + void l1_audio_abb_dl_off_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_dl_switched_off = TRUE; + } + void l1_audio_abb_ul_off_dl_off_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_ul_switched_off = TRUE; + l1s.audio_on_off_ctl.l1_audio_dl_switched_off = TRUE; + } + void l1_audio_abb_ul_off_dl_on_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_ul_switched_off = TRUE; + l1_outen_update(); + } + void l1_audio_abb_ul_on_dl_off_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_ul_switched_on = TRUE; + l1s.audio_on_off_ctl.l1_audio_dl_switched_off = TRUE; + } + void l1_audio_abb_ul_on_dl_on_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_ul_switched_on = TRUE; + + l1_outen_update(); + } + + void l1_audio_abb_outen_cfg_callback(UWORD8 argument) + { + (void)(argument); + l1s.audio_on_off_ctl.l1_audio_dl_switched_on = TRUE; + } +#if (CODE_VERSION != SIMULATION) + +BspTwl3029_ReturnCode l1_outen_update(void) +{ + BspTwl3029_ReturnCode returnVal = BSP_TWL3029_RETURN_CODE_FAILURE; + UWORD16 count = 0; + UINT8 triton_classD = 0; + + /* callback function info pointer */ + BspTwl3029_I2C_Callback i2c_callback; + BspTwl3029_I2C_CallbackPtr callbackPtr= &i2c_callback; + + /* I2C array */ + Bsp_Twl3029_I2cTransReqArray i2cTransArray; + Bsp_Twl3029_I2cTransReqArrayPtr i2cTransArrayPtr= &i2cTransArray; + + /* twl3029 I2C reg info struct */ + BspTwl3029_I2C_RegisterInfo regInfo[11] ; + BspTwl3029_I2C_RegisterInfo* regInfoPtr = regInfo; + + BspTwl3029_I2C_RegData tmpAudioHFTest1RegData=0; + BspTwl3029_I2C_RegData tmpCtrl3RegData=0; + + + l1a_l1s_com.outen_cfg_task.command_requested = l1a_l1s_com.outen_cfg_task.command_commited; + + bspTwl3029_Audio_getClassD_mode(&triton_classD); + + returnVal = BspTwl3029_I2c_shadowRegRead(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_CTRL3_OFFSET, + &tmpCtrl3RegData); + returnVal = BspTwl3029_I2c_shadowRegRead(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_HFTEST1_OFFSET, + &tmpAudioHFTest1RegData); + + returnVal = BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN1_OFFSET, + l1a_l1s_com.outen_cfg_task.outen1, regInfoPtr++); + count++; + + returnVal = BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN2_OFFSET, + l1a_l1s_com.outen_cfg_task.outen2, regInfoPtr++); + count++; + + if(l1a_l1s_com.outen_cfg_task.classD == 0x01) // User wants to configure classD + { + if(triton_classD == 0x00) // User wants to switch on and Triton not configured for classD + { + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_CKG_TESTUNLOCK_OFFSET, + 0xb6, regInfoPtr++); + count++; + + + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN3_OFFSET, + l1a_l1s_com.outen_cfg_task.outen3, regInfoPtr++); + count++; + + tmpCtrl3RegData |= 0x80; // AUDIO_CTRL3_SPKDIGON + tmpAudioHFTest1RegData = 0x01; // AUDIO_HFTEST1_SPKALLZB + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_CTRL3_OFFSET, + tmpCtrl3RegData, regInfoPtr++); + count++; + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_HFTEST1_OFFSET, + tmpAudioHFTest1RegData, regInfoPtr++); + count++; + } + } + else if(l1a_l1s_com.outen_cfg_task.classD == 0x00) + { + if(triton_classD != 0x00) // User wants no to classD and Triton configured for classD + { + tmpCtrl3RegData &= 0x7F; // AUDIO_CTRL3_SPKDIGON + tmpAudioHFTest1RegData = 0x00; // AUDIO_HFTEST1_SPKALLZB + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_HFTEST1_OFFSET, + tmpAudioHFTest1RegData, regInfoPtr++); + count++; + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_CTRL3_OFFSET, + tmpCtrl3RegData, regInfoPtr++); + count++; + + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN3_OFFSET, + l1a_l1s_com.outen_cfg_task.outen3, regInfoPtr++); + count++; + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_CKG_TESTUNLOCK_OFFSET, + 0x00, regInfoPtr++); + count++; + + } + else // User no classD & Triton also no classD + { + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN3_OFFSET, + l1a_l1s_com.outen_cfg_task.outen3, regInfoPtr++); + count++; + returnVal = BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN2_OFFSET, + l1a_l1s_com.outen_cfg_task.outen2, regInfoPtr++); + count++; + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN3_OFFSET, + l1a_l1s_com.outen_cfg_task.outen3, regInfoPtr++); + count++; + } + } + + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_POPMAN_OFFSET, + 0x00,regInfoPtr++); + count++; + callbackPtr->callbackFunc = l1_audio_abb_outen_cfg_callback; + callbackPtr->callbackVal = 0; + + if (returnVal != BSP_TWL3029_RETURN_CODE_FAILURE) + { + regInfoPtr = regInfo; + /* now request to I2C manager to write to Triton registers */ + + returnVal = BspTwl3029_I2c_regInfoSend(regInfo,count,callbackPtr, + (BspI2c_TransactionRequest*)i2cTransArrayPtr); + } + + return returnVal; + } /* end function l1s_outen_update */ + + +#endif +#if (CODE_VERSION == SIMULATION) + // This function is written to turn on the flag l1_audio_dl_switched_on during simulation +signed char l1_outen_update(void) + { + l1s.audio_on_off_ctl.l1_audio_dl_switched_on = TRUE; + } +#endif +#endif // L1_AUDIO_MCU_ONOFF + +// END Triton Audio ON/OFF Changes + + + #if (KEYBEEP) + /*-------------------------------------------------------*/ + /* l1s_keybeep_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Keybeep L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_keybeep_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, + WAIT_KEYBEEP_START = 2, + WAIT_KEYBEEP_STOP = 3 +#else + WAIT_KEYBEEP_START = 1, + WAIT_KEYBEEP_STOP = 2 +#endif + }; + + UWORD8 *state = &l1s.audio_state[L1S_KEYBEEP_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + + case IDLE: + { + // Triton Audio ON/OFF Changes +#if(L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = WAIT_AUDIO_ON; +#else + // Start the DSP keybeep task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_KEYBEEP; + *state = WAIT_KEYBEEP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Start the DSP keybeep task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_KEYBEEP; + *state = WAIT_KEYBEEP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case WAIT_KEYBEEP_START: + { + // the DSP acknowledges the L1S start request. + if ((!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_KEYBEEP)) && + (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_KEYBEEP)) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_KEYBEEP_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_KEYBEEP_STOP; + } + } + break; + + case WAIT_KEYBEEP_STOP: + { + // the DSP is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_KEYBEEP)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_KEYBEEP_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + else + // the MMI requests to stop the current keybeep + if (l1a_l1s_com.keybeep_task.command.stop) + { + // Stop the DSP keybeep task + l1s_dsp_com.dsp_ndb_ptr->d_dur_kb = 0; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_KEYBEEP; + + // Disable the stop command + l1a_l1s_com.keybeep_task.command.stop = FALSE; + } + } + break; + } // switch + } + #endif // KEYBEEP + #if (TONE) + /*-------------------------------------------------------*/ + /* l1s_tone_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Tone L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_tone_manager(void) + { + enum states + { + IDLE = 0, +// Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF== 1) + WAIT_AUDIO_ON = 1, + WAIT_TONE_START = 2, + WAIT_TONE_STOP = 3 +#else + WAIT_TONE_START = 1, + WAIT_TONE_STOP = 2 +#endif + }; + + UWORD8 *state = &l1s.audio_state[L1S_TONE_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = WAIT_AUDIO_ON; +#else + // Start the DSP tone task + #if ((DSP == 33) || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = NO_MELODY_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init &= ~(B_MELO); + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_TONE; + + *state = WAIT_TONE_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Start the DSP tone task + #if ((DSP == 33) || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = NO_MELODY_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init &= ~(B_MELO); + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_TONE; + + *state = WAIT_TONE_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case WAIT_TONE_START: + { + // the DSP acknowledges the L1S start request. + if ((!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_TONE)) && + (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_TONE)) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_TONE_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_TONE_STOP; + } + } + break; + + case WAIT_TONE_STOP: + { + // the DSP is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_TONE)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_TONE_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + else + // the MMI requests to stop the current tone + if (l1a_l1s_com.tone_task.command.stop) + { + // Stop the DSP tone task + l1s_dsp_com.dsp_ndb_ptr->d_pe_rep = 0; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_TONE; + + // Disable the stop command + l1a_l1s_com.tone_task.command.stop = FALSE; + } + } + break; + } // switch + } + #endif // TONE + #if (MELODY_E1) + /*-------------------------------------------------------*/ + /* l1s_melody0_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Melody 0 L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_melody0_manager(void) + { + enum states + { + M0_INACTIVE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + M0_WAIT_AUDIO_START = 1, + M0_WAIT_DSP_START = 2, + M0_WAIT_COUNTER_EQUAL_0 = 3, + M0_WAIT_DESCRIPTION_START = 4, + M0_WAIT_END_MELO = 5 +#else + M0_WAIT_DSP_START = 1, + M0_WAIT_COUNTER_EQUAL_0 = 2, + M0_WAIT_DESCRIPTION_START = 3, + M0_WAIT_END_MELO = 4 +#endif + }; + + UWORD8 *state = &l1s.audio_state[L1S_MELODY0_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 i, load_size; + UWORD16 melo_header[2], trash[4]; + API *osc_used; + + switch(*state) + { + case M0_INACTIVE: + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = M0_WAIT_AUDIO_START; +#else + // Initialize the oscilators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody0.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + // Initialize the pointer to the buffer, the buffer size + l1s.melody0.ptr_buf = l1a_l1s_com.melody0_task.parameters.ptr_buf; + l1s.melody0.buffer_size = l1a_l1s_com.melody0_task.parameters.buffer_size; + + // Download the header of the first description of the melody + l1s.melody0.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1s.melody0.buffer_size, + (UWORD16 **)&l1s.melody0.ptr_buf, + 1, + &l1s.melody0.melody_header); + + // Initialize the counter with the first offset time: + l1s.melody0.counter = ( ( Field(l1s.melody0.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + // Enable the oscillator used + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used |= l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap; + + // Start the DSP melody task + #if ((DSP==33) || (DSP == 34) || (DSP==35) || (DSP==36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = MELODY_E1_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (B_TONE | B_MELO); + + *state = M0_WAIT_DSP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; +#if (L1_AUDIO_MCU_ONOFF == 1) + case M0_WAIT_AUDIO_START: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Initialize the oscilators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody0.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + // Initialize the pointer to the buffer, the buffer size + l1s.melody0.ptr_buf = l1a_l1s_com.melody0_task.parameters.ptr_buf; + l1s.melody0.buffer_size = l1a_l1s_com.melody0_task.parameters.buffer_size; + + // Download the header of the first description of the melody + l1s.melody0.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1s.melody0.buffer_size, + (UWORD16 **)&l1s.melody0.ptr_buf, + 1, + &l1s.melody0.melody_header); + + // Initialize the counter with the first offset time: + l1s.melody0.counter = ( ( Field(l1s.melody0.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + // Enable the oscillator used + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used |= l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap; + + // Start the DSP melody task + #if ((DSP==33) || (DSP == 34) || (DSP==35) || (DSP==36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = MELODY_E1_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (B_TONE | B_MELO); + + *state = M0_WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case M0_WAIT_DSP_START: + { + // The DSP is started + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_TONE) ) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_MELODY0_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = M0_WAIT_COUNTER_EQUAL_0; + } + } + break; + + case M0_WAIT_COUNTER_EQUAL_0: + { + // The MMI resquests to stop the current melody 0. + if (l1a_l1s_com.melody0_task.command.stop) + { + // Initialize the oscilators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody0.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + + // Disable the loopback + l1a_l1s_com.melody0_task.parameters.loopback = FALSE; + + // Disable the stop command + l1a_l1s_com.melody0_task.command.stop = FALSE; + + *state = M0_WAIT_END_MELO; + } + else + { + // Decrease the download coundter + l1s.melody0.counter--; + + // The description must be downloaded. + if (l1s.melody0.counter == 0) + { + // Set the oscillator used in the following description + l1s.melody0.oscillator_used_in_desc = Field(l1s.melody0.melody_header, SC_MELO_OSCILLATOR_USED_MASK, SC_MELO_OSCILLATOR_USED_SHIFT); + l1s.melody0.oscillator_started = 0; + + // Download the new description + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (Field(l1s.melody0.oscillator_used_in_desc, (0x01<<i), i)) + { + // This oscillator description must be used. + if (l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[i] != SC_NUMBER_OSCILLATOR) + { + osc_used = l1s.melody0.oscillator[l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[i]]; + l1s.melody0.oscillator_started |= (0x01<<(l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[i])); + } + else + // The oscillator description isn't used and put to the "trash" + { + osc_used = trash; + } + + // Download the two first words of the oscillator description + l1s.melody0.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1s.melody0.buffer_size, + (UWORD16 **)&l1s.melody0.ptr_buf, + 2, + osc_used); + + load_size = 0; + if (Field(*(osc_used+1), SC_MELO_LOAD1_MASK, SC_MELO_LOAD1_SHIFT)) + load_size++; + if (Field(*(osc_used+1), SC_MELO_LOAD2_MASK, SC_MELO_LOAD2_SHIFT)) + load_size++; + + // Download the next word(s) of the oscillator description + l1s.melody0.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1s.melody0.buffer_size, + (UWORD16 **)&l1s.melody0.ptr_buf, + load_size, + osc_used+2); + + // Enable this new description + *osc_used |= 1; + } + } + + *state = M0_WAIT_DESCRIPTION_START; + } + } + } + break; + + case M0_WAIT_DESCRIPTION_START: + { + + // The new description is started or no oscillator of the description was allocated. + if ((l1s.melody0.oscillator_started & l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_active) || + (l1s.melody0.oscillator_started == 0) ) + { + // Download the header of the next description of the melody + l1s.melody0.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1s.melody0.buffer_size, + (UWORD16 **)&l1s.melody0.ptr_buf, + 1, + &l1s.melody0.melody_header); + + // Is it the end of the melody? + if (l1s.melody0.melody_header == 0x0000) + { + *state = M0_WAIT_END_MELO; + #if 0 /* FreeCalypso TCS211 reconstruction */ + // Header is wrong - L1 needs a forcible stop here + #if (CODE_VERSION == SIMULATION) + // l1a_l1s_com.melody1_task.command.stop = TRUE; + #else + l1a_l1s_com.melody1_task.command.stop = TRUE; + #endif + #endif + } + else + { + // Initialize the counter with the next offset time: + l1s.melody0.counter = ( ( Field(l1s.melody0.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + *state = M0_WAIT_COUNTER_EQUAL_0; + } + } + } + break; + + case M0_WAIT_END_MELO: + { + if (l1a_l1s_com.melody0_task.command.stop) + { + // Initialize the oscillators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody0.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + + // Disable the loopback + l1a_l1s_com.melody0_task.parameters.loopback = FALSE; + + // Disable the stop command + l1a_l1s_com.melody0_task.command.stop = FALSE; + + *state = M0_WAIT_END_MELO; + } + else + // All oscillators used are stopped. + if (!( l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_active)) + { + // The melody is in loopback mode? + if (l1a_l1s_com.melody0_task.parameters.loopback) + { + // Reset the buffer description + #if (OP_RIV_AUDIO == 0) + l1s.melody0.ptr_buf = NULL; + #endif + l1s.melody0.buffer_size = 0; + l1s.melody0.error_id = Cust_get_pointer((UWORD16 **)&l1s.melody0.ptr_buf, + &l1s.melody0.buffer_size, + l1a_l1s_com.melody0_task.parameters.session_id); + + // Download the 2 first words of the melody + l1s.melody0.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1s.melody0.buffer_size, + (UWORD16 **)&l1s.melody0.ptr_buf, + 2, + (UWORD16 *)&melo_header); + + // Save the header of the first melody score description + l1s.melody0.melody_header = melo_header[1]; + + // Initialize the counter with the first offset time: + l1s.melody0.counter = ( ( Field(l1s.melody0.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + *state = M0_WAIT_COUNTER_EQUAL_0; + } + else + { + // Disable the oscillator dedicated to this melody + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used &= ~(l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap); + + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_MELODY0_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = M0_INACTIVE; + } + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_melody1_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Melody 1 L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_melody1_manager(void) + { + enum states + { + M1_INACTIVE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + M1_WAIT_AUDIO_START = 1, + M1_WAIT_DSP_START = 2, + M1_WAIT_COUNTER_EQUAL_0 = 3, + M1_WAIT_DESCRIPTION_START = 4, + M1_WAIT_END_MELO = 5 +#else + M1_WAIT_DSP_START = 1, + M1_WAIT_COUNTER_EQUAL_0 = 2, + M1_WAIT_DESCRIPTION_START = 3, + M1_WAIT_END_MELO = 4 +#endif + }; + + UWORD8 *state = &l1s.audio_state[L1S_MELODY1_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 i, load_size; + UWORD16 melo_header[2], trash[4]; + API *osc_used; + + switch(*state) + { + case M1_INACTIVE: + { +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = M1_WAIT_AUDIO_START; +#else + // Initialize the oscilators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody1.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + // Initialize the pointer to the buffer, the buffer size + l1s.melody1.ptr_buf = l1a_l1s_com.melody1_task.parameters.ptr_buf; + l1s.melody1.buffer_size = l1a_l1s_com.melody1_task.parameters.buffer_size; + + // Download the header of the first description of the melody + l1s.melody1.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1s.melody1.buffer_size, + (UWORD16 **)&l1s.melody1.ptr_buf, + 1, + &l1s.melody1.melody_header); + + // Initialize the counter with the first offset time: + l1s.melody1.counter = ( ( Field(l1s.melody1.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + // Enable the oscillator used + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used |= l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap; + + // Start the DSP melody task + #if ((DSP==33) || (DSP == 34) || (DSP==35) || (DSP==36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = MELODY_E1_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (B_TONE | B_MELO); + + *state = M1_WAIT_DSP_START; +#endif + } + break; +#if (L1_AUDIO_MCU_ONOFF == 1) + case M1_WAIT_AUDIO_START: + { + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Initialize the oscilators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody1.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + // Initialize the pointer to the buffer, the buffer size + l1s.melody1.ptr_buf = l1a_l1s_com.melody1_task.parameters.ptr_buf; + l1s.melody1.buffer_size = l1a_l1s_com.melody1_task.parameters.buffer_size; + + // Download the header of the first description of the melody + l1s.melody1.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1s.melody1.buffer_size, + (UWORD16 **)&l1s.melody1.ptr_buf, + 1, + &l1s.melody1.melody_header); + + // Initialize the counter with the first offset time: + l1s.melody1.counter = ( ( Field(l1s.melody1.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + // Enable the oscillator used + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used |= l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap; + + // Start the DSP melody task + #if ((DSP==33) || (DSP == 34) || (DSP==35) || (DSP==36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = MELODY_E1_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (B_TONE | B_MELO); + + *state = M1_WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case M1_WAIT_DSP_START: + { + // The DSP is started + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_TONE) ) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_MELODY1_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = M1_WAIT_COUNTER_EQUAL_0; + } + } + break; + + case M1_WAIT_COUNTER_EQUAL_0: + { + // The MMI resquests to stop the current melody 1. + if (l1a_l1s_com.melody1_task.command.stop) + { + // Initialize the oscilators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody1.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + + // Disable the loopback + l1a_l1s_com.melody1_task.parameters.loopback = FALSE; + + // Disable the stop command + l1a_l1s_com.melody1_task.command.stop = FALSE; + + *state = M1_WAIT_END_MELO; + } + else + { + // Decrease the download coundter + l1s.melody1.counter--; + + // The description must be downloaded. + if (l1s.melody1.counter == 0) + { + // Set the oscillator used in the following description + l1s.melody1.oscillator_used_in_desc = Field(l1s.melody1.melody_header, SC_MELO_OSCILLATOR_USED_MASK, SC_MELO_OSCILLATOR_USED_SHIFT); + l1s.melody1.oscillator_started = 0; + + // Download the new description + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (Field(l1s.melody1.oscillator_used_in_desc, (0x01<<i), i)) + { + // This oscillator description must be used. + if (l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[i] != SC_NUMBER_OSCILLATOR) + { + osc_used = l1s.melody1.oscillator[l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[i]]; + l1s.melody1.oscillator_started |= (0x01<<(l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[i])); + } + else + // The oscillator description isn't used and put to the "trash" + { + osc_used = trash; + } + + // Download the two first words of the oscillator description + l1s.melody1.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1s.melody1.buffer_size, + (UWORD16 **)&l1s.melody1.ptr_buf, + 2, + osc_used); + + load_size = 0; + if (Field(*(osc_used+1), SC_MELO_LOAD1_MASK, SC_MELO_LOAD1_SHIFT)) + load_size++; + if (Field(*(osc_used+1), SC_MELO_LOAD2_MASK, SC_MELO_LOAD2_SHIFT)) + load_size++; + + // Download the next word(s) of the oscillator description + l1s.melody1.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1s.melody1.buffer_size, + (UWORD16 **)&l1s.melody1.ptr_buf, + load_size, + osc_used+2); + + // Enable this new description + *osc_used |= 1; + } + } + + *state = M1_WAIT_DESCRIPTION_START; + } + } + } + break; + + case M1_WAIT_DESCRIPTION_START: + { + // The new description is started or no oscillator of the description was allocated. + if ((l1s.melody1.oscillator_started & l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_active) || + (l1s.melody1.oscillator_started == 0) ) + { + // Download the header of the next description of the melody + l1s.melody1.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1s.melody1.buffer_size, + (UWORD16 **)&l1s.melody1.ptr_buf, + 1, + &l1s.melody1.melody_header); + + // Is it the end of the melody? + if (l1s.melody1.melody_header == 0x0000) + { + *state = M1_WAIT_END_MELO; + #if 0 /* FreeCalypso TCS211 reconstruction */ + /* Header is wrong - L1 needs a forcible stop here */ + #if (CODE_VERSION == SIMULATION) + // l1a_l1s_com.melody1_task.command.stop = TRUE; + #else + l1a_l1s_com.melody1_task.command.stop = TRUE; + #endif + #endif + } + else + { + // Initialize the counter with the next offset time: + l1s.melody1.counter = ( ( Field(l1s.melody1.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + *state = M1_WAIT_COUNTER_EQUAL_0; + } + } + } + break; + + case M1_WAIT_END_MELO: + { + if (l1a_l1s_com.melody1_task.command.stop) + { + // Initialize the oscillators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody1.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + + // Disable the loopback + l1a_l1s_com.melody1_task.parameters.loopback = FALSE; + + // Disable the stop command + l1a_l1s_com.melody1_task.command.stop = FALSE; + + *state = M1_WAIT_END_MELO; + } + else + // All oscillators used are stopped. + if (!( l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_active)) + { + // The melody is in loopback mode? + if (l1a_l1s_com.melody1_task.parameters.loopback) + { + // Reset the pointer to the buffer + #if (OP_RIV_AUDIO == 0) + l1s.melody1.ptr_buf = NULL; + #endif + l1s.melody1.buffer_size = 0; + l1s.melody1.error_id = Cust_get_pointer((UWORD16 **)&l1s.melody1.ptr_buf, + &l1s.melody1.buffer_size, + l1a_l1s_com.melody1_task.parameters.session_id); + + // Download the 2 first words of the first description of the melody + l1s.melody1.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1s.melody1.buffer_size, + (UWORD16 **)&l1s.melody1.ptr_buf, + 2, + (UWORD16 *)&melo_header); + + // Save the header of the first melody score description + l1s.melody1.melody_header = melo_header[1]; + + // Initialize the counter with the first offset time: + l1s.melody1.counter = ( ( Field(l1s.melody1.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + *state = M1_WAIT_COUNTER_EQUAL_0; + } + else + { + // Disable the oscillator dedicated to this melody + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used &= ~(l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap); +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_MELODY1_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = M1_INACTIVE; + } + } + } + break; + } // switch + } + #endif // MELODY_E1 + #if (VOICE_MEMO) + /*-------------------------------------------------------*/ + /* l1s_vm_play_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Voice memo playing L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_vm_play_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, + WAIT_DSP_START = 2, + WAIT_DSP_REQUEST = 3, + WAIT_DSP_STOP = 4 +#else + WAIT_DSP_START = 1, + WAIT_DSP_REQUEST = 2, + WAIT_DSP_STOP = 3 +#endif + }; + + UWORD8 *state = &l1s.audio_state[L1S_VM_PLAY_STATE]; + xSignalHeaderRec *conf_msg; + UWORD16 sample_header; + + switch(*state) + { + case IDLE: + { +#if (L1_AUDIO_MCU_ONOFF == 1) + // Triton Audio ON/OFF Changes + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = WAIT_AUDIO_ON; +#else + // Initialize the buffer parameters + l1s.voicememo.play.ptr_buf = NULL; + l1s.voicememo.play.buffer_size = 0; + l1s.voicememo.play.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo.play.ptr_buf, + &l1s.voicememo.play.buffer_size, + l1a_l1s_com.voicememo_task.play.parameters.session_id); + + // Start the voice memo playing DSP task + #if ((DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // use TCH/FS vocoder + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VM_VOCODER_SELECT); + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_PLAY_START; + + // Determine which a_du buffer is currently used + l1s.voicememo.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + // Download the header of the new speech sample + l1s.voicememo.play.error_id = copy_data_from_buffer (l1a_l1s_com.voicememo_task.play.parameters.session_id, + &l1s.voicememo.play.buffer_size, + (UWORD16 **)&l1s.voicememo.play.ptr_buf, + 1, + &sample_header); + + // Download the data to the a_du_x buffer if the sample isn't a noise sample. + if (sample_header & B_VM_SPEECH) + { + l1s.voicememo.play.error_id = copy_data_from_buffer (l1a_l1s_com.voicememo_task.play.parameters.session_id, + &l1s.voicememo.play.buffer_size, + (UWORD16 **)&l1s.voicememo.play.ptr_buf, + SC_VM_SPEECH_SAMPLE-1, + l1s.voicememo.play.a_du_x+1); + } + // Send the header to the DSP + *l1s.voicememo.play.a_du_x = sample_header; + + *state = WAIT_DSP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Initialize the buffer parameters + l1s.voicememo.play.ptr_buf = NULL; + l1s.voicememo.play.buffer_size = 0; + l1s.voicememo.play.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo.play.ptr_buf, + &l1s.voicememo.play.buffer_size, + l1a_l1s_com.voicememo_task.play.parameters.session_id); + + // Start the voice memo playing DSP task + #if (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39) + // use TCH/FS vocoder + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VM_VOCODER_SELECT); + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_PLAY_START; + + // Determine which a_du buffer is currently used + l1s.voicememo.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + // Download the header of the new speech sample + l1s.voicememo.play.error_id = copy_data_from_buffer (l1a_l1s_com.voicememo_task.play.parameters.session_id, + &l1s.voicememo.play.buffer_size, + (UWORD16 **)&l1s.voicememo.play.ptr_buf, + 1, + &sample_header); + + // Download the data to the a_du_x buffer if the sample isn't a noise sample. + if (sample_header & B_VM_SPEECH) + { + l1s.voicememo.play.error_id = copy_data_from_buffer (l1a_l1s_com.voicememo_task.play.parameters.session_id, + &l1s.voicememo.play.buffer_size, + (UWORD16 **)&l1s.voicememo.play.ptr_buf, + SC_VM_SPEECH_SAMPLE-1, + l1s.voicememo.play.a_du_x+1); + } + // Send the header to the DSP + *l1s.voicememo.play.a_du_x = sample_header; + + *state = WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case WAIT_DSP_START: + { + // The DSP task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_PLAY_ON_GOING) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_PLAY_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_REQUEST; + } + } + break; + + case WAIT_DSP_REQUEST: + { + // The MMI requests to stop the voice memorization playing task + if (l1a_l1s_com.voicememo_task.play.command.stop) + { + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_PLAY_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP needs a new block + { + // Determine which a_du buffer is currently used + l1s.voicememo.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + if (!(*(l1s.voicememo.play.a_du_x) & B_BLOCK_READY)) + { + // Download the header of the new speech sample + l1s.voicememo.play.error_id = copy_data_from_buffer (l1a_l1s_com.voicememo_task.play.parameters.session_id, + &l1s.voicememo.play.buffer_size, + (UWORD16 **)&l1s.voicememo.play.ptr_buf, + 1, + &sample_header); + + // Is it the end of the voice memo data buffer? + if ( sample_header == SC_VM_END_MASK ) + { + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_PLAY_STOP; + + *state = WAIT_DSP_STOP; + } + else + { + // Download the data to the a_du_x buffer if the sample isn't a noise sample. + if (sample_header & B_VM_SPEECH) + { + l1s.voicememo.play.error_id = copy_data_from_buffer (l1a_l1s_com.voicememo_task.play.parameters.session_id, + &l1s.voicememo.play.buffer_size, + (UWORD16 **)&l1s.voicememo.play.ptr_buf, + SC_VM_SPEECH_SAMPLE-1, + l1s.voicememo.play.a_du_x+1); + } + // Send the header to the DSP + *l1s.voicememo.play.a_du_x = sample_header; + } + } + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP voice memorization playing task is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_PLAY_ON_GOING)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_PLAY_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_vm_record_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Voice memo recoding L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_vm_record_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, + WAIT_DSP_START = 2, + WAIT_DSP_SAMPLE = 3, + WAIT_DSP_STOP = 4 +#else + WAIT_DSP_START = 1, + WAIT_DSP_SAMPLE = 2, + WAIT_DSP_STOP = 3 +#endif // L1_AUDIO_MCU_ONOFF + }; + + UWORD8 *state = &l1s.audio_state[L1S_VM_RECORD_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 size; + UWORD16 data; + + switch(*state) + { + case IDLE: + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request++; + *state = WAIT_AUDIO_ON; +#else + // Initialize the buffer parameters + l1s.voicememo.record.ptr_buf = NULL; + l1s.voicememo.record.buffer_size = 0; + l1s.voicememo.record.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo.record.ptr_buf, + &l1s.voicememo.record.buffer_size, + l1a_l1s_com.voicememo_task.record.parameters.session_id); + + // Initialize the size of the Voice memo to record + l1s.voicememo.record.recorded_size = 0; + + // Initialize the DTX mode + if (l1a_l1s_com.voicememo_task.record.parameters.dtx) + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VOICE_MEMO_DTX; + else + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VOICE_MEMO_DTX); + + #if ((DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // use TCH/FS vocoder + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VM_VOCODER_SELECT); + #endif + + // Start the voice memo recording DSP task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_START; + + *state = WAIT_DSP_START; + +#endif // L1_AUDIO_MCU_ONOFF + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE] == L1_AUDIO_UL_ON)) + { + // Initialize the buffer parameters + l1s.voicememo.record.ptr_buf = NULL; + l1s.voicememo.record.buffer_size = 0; + l1s.voicememo.record.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo.record.ptr_buf, + &l1s.voicememo.record.buffer_size, + l1a_l1s_com.voicememo_task.record.parameters.session_id); + + // Initialize the size of the Voice memo to record + l1s.voicememo.record.recorded_size = 0; + + // Initialize the DTX mode + if (l1a_l1s_com.voicememo_task.record.parameters.dtx) + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VOICE_MEMO_DTX; + else + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VOICE_MEMO_DTX); + + #if (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39) + // use TCH/FS vocoder + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VM_VOCODER_SELECT); + #endif + + // Start the voice memo recording DSP task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_START; + + *state = WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case WAIT_DSP_START: + { + // The DSP task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_RECORD_ON_GOING) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_RECORD_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_SAMPLE; + } + } + break; + + case WAIT_DSP_SAMPLE: + { + // The MMI requests to stop the voice memorization recording task + if (l1a_l1s_com.voicememo_task.record.command.stop) + { + // Write the end mask at the end of the voice data RAM buffer + data = SC_VM_END_MASK; + l1s.voicememo.record.error_id = copy_data_to_buffer (l1a_l1s_com.voicememo_task.record.parameters.session_id, + &l1s.voicememo.record.buffer_size, + (UWORD16 **)&l1s.voicememo.record.ptr_buf, + 1, + &data); + + // Increase the recorded size + l1s.voicememo.record.recorded_size++; + + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_STOP; + + // Clear the a_du_x header: + *(l1s.voicememo.record.a_du_x) = 0; + + *state = WAIT_DSP_STOP; + } + else + // The DSP needs a new block + { + // Determine which a_du buffer is currently used + l1s.voicememo.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + // The DSP sends a new block? + if ( (*(l1s.voicememo.record.a_du_x)) & B_BLOCK_READY ) + { + // Check if the block contains a sample of noise or speech + if ( (*(l1s.voicememo.record.a_du_x)) & B_VM_SPEECH ) + size = SC_VM_SPEECH_SAMPLE; + else + size = SC_VM_NOISE_SAMPLE; + + // The maximum allocated size is reached? + if ( (l1s.voicememo.record.recorded_size+size+1) <= l1a_l1s_com.voicememo_task.record.parameters.maximum_size) + { + // Download the data to the a_du_x buffer. + l1s.voicememo.record.error_id = copy_data_to_buffer (l1a_l1s_com.voicememo_task.record.parameters.session_id, + &l1s.voicememo.record.buffer_size, + (UWORD16 **)&l1s.voicememo.record.ptr_buf, + size, + l1s.voicememo.record.a_du_x); + + // Increase the recorded size + l1s.voicememo.record.recorded_size += size; + + // Clear the a_du_x header: + *(l1s.voicememo.record.a_du_x) = 0; + } + else + { + // Write the end mask at the end of the voice data RAM buffer + data = SC_VM_END_MASK; + l1s.voicememo.record.error_id = copy_data_to_buffer (l1a_l1s_com.voicememo_task.record.parameters.session_id, + &l1s.voicememo.record.buffer_size, + (UWORD16 **)&l1s.voicememo.record.ptr_buf, + 1, + &data); + + // Increase the recorded size + l1s.voicememo.record.recorded_size++; + + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_STOP; + + // Clear the a_du_x header: + *(l1s.voicememo.record.a_du_x) = 0; + + *state = WAIT_DSP_STOP; + } + } + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP voice memorization playing task is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_RECORD_ON_GOING)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request--; +#endif // L1_AUDIO_MCU_ONOFF + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_VM_RECORD_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_RECORD_STOP_CON; + //Fill the message + ((T_L1_VM_RECORD_CON *)(conf_msg->SigP))->recorded_size = l1s.voicememo.record.recorded_size; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_tone_ul_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : tone uplink L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_tone_ul_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, + WAIT_DEDIC_SPEECH_MODE = 2, + WAIT_TONE_UL_START = 3, + WAIT_TONE_UL_STOP = 4 +#else + WAIT_DEDIC_SPEECH_MODE = 1, + WAIT_TONE_UL_START = 2, + WAIT_TONE_UL_STOP = 3 +#endif + }; + + UWORD8 *state = &l1s.audio_state[L1S_TONE_UL_STATE]; + + switch(*state) + { + case IDLE: + { +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = WAIT_AUDIO_ON; +#else + // Start the tone uplink task + if (l1a_l1s_com.voicememo_task.record.tone_ul.start) + { + // Set the tone uplink option: + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_TONE_UL; + } + + *state = WAIT_DEDIC_SPEECH_MODE; +#endif + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Start the tone uplink task + if (l1a_l1s_com.voicememo_task.record.tone_ul.start) + { + // Set the tone uplink option: + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_TONE_UL; + } + + *state = WAIT_DEDIC_SPEECH_MODE; + } + } + break; +#endif // (L1_AUDIO_MCU_ONOFF == 1) + + case WAIT_DEDIC_SPEECH_MODE: + { + // The voice memorization task is stopping: + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_VM_TONE_UL)) + { + // Reset the start command + l1a_l1s_com.voicememo_task.record.tone_ul.start = FALSE; +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + *state = IDLE; + } + else + // Dedicated mode speech start? + if (l1a_l1s_com.dedic_set.aset != NULL) + { + #if (AMR == 1) + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_HS_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_EFR_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_FS_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_AFS_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_AHS_MODE) ) + #else + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_HS_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_EFR_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_FS_MODE) ) + #endif + { + + // Start the tone uplink DSP task + #if ((DSP==33) || (DSP == 34) || (DSP==35) || (DSP==36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = NO_MELODY_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init &= ~(B_MELO); + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_TONE; + + *state = WAIT_TONE_UL_START; + } + } + } + break; + + case WAIT_TONE_UL_START: + { + // the tone uplink task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_TONE) + { + *state = WAIT_TONE_UL_STOP; + } + } + break; + + case WAIT_TONE_UL_STOP: + { + // The voice memorization task is stopping: + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_VM_TONE_UL)) + { + // Stop the tone uplink task: + l1s_dsp_com.dsp_ndb_ptr->d_pe_rep = 0; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_TONE; +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + *state = IDLE; + } + else + // The tone uplink task is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_TONE)) + { +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + *state = IDLE; + } + } + break; + } // switch + } + + #endif // VOICE_MEMO + + #if (L1_PCM_EXTRACTION) + /*-------------------------------------------------------*/ + /* l1s_pcm_download_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : PCM download L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_pcm_download_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, +#endif + WAIT_DSP_START = 2, + WAIT_DSP_REQUEST = 3, + WAIT_DSP_STOP = 4 + }; + + UWORD8 *state = &l1s.audio_state[L1S_PCM_DOWNLOAD_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { +#if (L1_AUDIO_MCU_ONOFF == 1) + // Triton Audio ON/OFF Changes + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = WAIT_AUDIO_ON; +#else + // Initialize the buffer parameters + l1s.pcm.download.ptr_buf = NULL; + l1s.pcm.download.buffer_size = 0; + l1s.pcm.download.error_id = Cust_get_pointer((UWORD16 **)&l1s.pcm.download.ptr_buf, + &l1s.pcm.download.buffer_size, + l1a_l1s_com.pcm_task.download.parameters.session_id); + + // Download the PCM samples + l1s.pcm.download.error_id = copy_data_from_buffer (l1a_l1s_com.pcm_task.download.parameters.session_id, + &l1s.pcm.download.buffer_size, + (UWORD16 **)&l1s.pcm.download.ptr_buf, + SC_PCM_DOWNLOAD_SAMPLE, + l1s_dsp_com.dsp_ndb_ptr->a_pcm_api_download); + + // Increase the downloaded size of PCM samples + l1s.pcm.download.downloaded_size = SC_PCM_DOWNLOAD_SAMPLE; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |= (B_PCM_DOWNLOAD_READY); + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_DOWNLOAD_START; + + *state = WAIT_DSP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Initialize the buffer parameters + l1s.pcm.download.ptr_buf = NULL; + l1s.pcm.download.buffer_size = 0; + l1s.pcm.download.error_id = Cust_get_pointer((UWORD16 **)&l1s.pcm.download.ptr_buf, + &l1s.pcm.download.buffer_size, + l1a_l1s_com.pcm_task.download.parameters.session_id); + + // Download the PCM samples + l1s.pcm.download.error_id = copy_data_from_buffer (l1a_l1s_com.pcm_task.download.parameters.session_id, + &l1s.pcm.download.buffer_size, + (UWORD16 **)&l1s.pcm.download.ptr_buf, + SC_PCM_DOWNLOAD_SAMPLE, + l1s_dsp_com.dsp_ndb_ptr->a_pcm_api_download); + + // Increase the downloaded size of PCM samples + l1s.pcm.download.downloaded_size = SC_PCM_DOWNLOAD_SAMPLE; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |= (B_PCM_DOWNLOAD_READY); + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_DOWNLOAD_START; + + *state = WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + + case WAIT_DSP_START: + { + // The DSP task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_PCM_DOWNLOAD_ON_GOING) + { + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_PCM_DOWNLOAD_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_REQUEST; + } + } + break; + + case WAIT_DSP_REQUEST: + { + if (l1a_l1s_com.pcm_task.download.command.stop) + { + // Stop the DSP PCM playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_DOWNLOAD_STOP; + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = 0; + *state = WAIT_DSP_STOP; + } + else + { + // B_PCM_DOWNLOAD_READY is reset if DSP is ready to get new sample + if (!(l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download & B_PCM_DOWNLOAD_READY)) + { + + if(l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_error & B_PCM_DOWNLOAD_ERROR) + { + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_PCM_DSP_error(); + #endif + } /* end if DSP error check - underflow */ + + if ((l1s.pcm.download.downloaded_size + SC_PCM_DOWNLOAD_SAMPLE) <= + l1a_l1s_com.pcm_task.download.parameters.maximum_size) + { + + // Download the data to the a_pcm_api_download buffer + l1s.pcm.download.error_id = copy_data_from_buffer (l1a_l1s_com.pcm_task.download.parameters.session_id, + &l1s.pcm.download.buffer_size, + (UWORD16 **)&l1s.pcm.download.ptr_buf, + SC_PCM_DOWNLOAD_SAMPLE, + l1s_dsp_com.dsp_ndb_ptr->a_pcm_api_download); + // Increase the downloaded size + l1s.pcm.download.downloaded_size += SC_PCM_DOWNLOAD_SAMPLE; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |= (B_PCM_DOWNLOAD_READY); + } /* end if download speech sample*/ + else + { + // Stop the DSP PCM playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_DOWNLOAD_STOP; + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = 0; + *state = WAIT_DSP_STOP; + } /* end else - download buffer size reached */ + } /* end if DSP requested new block */ + } /* end else not download task stop command */ + } + break; + + case WAIT_DSP_STOP: + { + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_PCM_DOWNLOAD_ON_GOING)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_PCM_DOWNLOAD_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_pcm_upload_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : PCM uploading manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_pcm_upload_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, +#endif // L1_AUDIO_MCU_ONOFF + WAIT_DSP_START = 2, + WAIT_DSP_SAMPLE = 3, + WAIT_DSP_STOP = 4 + }; + + UWORD8 *state = &l1s.audio_state[L1S_PCM_UPLOAD_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request++; + *state = WAIT_AUDIO_ON; +#else + // Initialize the buffer parameters + l1s.pcm.upload.ptr_buf = NULL; + l1s.pcm.upload.buffer_size = 0; + l1s.pcm.upload.error_id = Cust_get_pointer((UWORD16 **)&l1s.pcm.upload.ptr_buf, + &l1s.pcm.upload.buffer_size, + l1a_l1s_com.pcm_task.upload.parameters.session_id); + + // Initialize the size of the PCM upload + l1s.pcm.upload.uploaded_size = 0; + + // Start the PCM recording DSP task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_UPLOAD_START; + + *state = WAIT_DSP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE] == L1_AUDIO_UL_ON)) + { + // Initialize the buffer parameters + l1s.pcm.upload.ptr_buf = NULL; + l1s.pcm.upload.buffer_size = 0; + l1s.pcm.upload.error_id = Cust_get_pointer((UWORD16 **)&l1s.pcm.upload.ptr_buf, + &l1s.pcm.upload.buffer_size, + l1a_l1s_com.pcm_task.upload.parameters.session_id); + + // Initialize the size of the PCM upload + l1s.pcm.upload.uploaded_size = 0; + + // Start the PCM recording DSP task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_UPLOAD_START; + + *state = WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + + case WAIT_DSP_START: + { + // The DSP task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_PCM_UPLOAD_ON_GOING) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_PCM_UPLOAD_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_SAMPLE; + } + } + break; + + case WAIT_DSP_SAMPLE: + { + // The MMI requests to stop the PCM recording task + if (l1a_l1s_com.pcm_task.upload.command.stop) + { + // Stop the DSP PCM recording task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_UPLOAD_STOP; + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = 0; + + *state = WAIT_DSP_STOP; + } + else + // The DSP needs a new block + { + + // The DSP sends a new block? + if (l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload & B_PCM_UPLOAD_READY ) + { + + if(l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_error & B_PCM_UPLOAD_ERROR) + { + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_PCM_DSP_error(); + #endif + } /* end if DSP error check - overflow */ + + if ((l1s.pcm.upload.uploaded_size + SC_PCM_UPLOAD_SAMPLE) <= l1a_l1s_com.pcm_task.upload.parameters.maximum_size) + { + // Download the data to the a_pcm_api_upload buffer. + + l1s.pcm.upload.error_id = copy_data_to_buffer (l1a_l1s_com.pcm_task.upload.parameters.session_id, + &l1s.pcm.upload.buffer_size, + (UWORD16 **)&l1s.pcm.upload.ptr_buf, + SC_PCM_UPLOAD_SAMPLE, + l1s_dsp_com.dsp_ndb_ptr->a_pcm_api_upload); + + // Increase the recorded size + l1s.pcm.upload.uploaded_size += SC_PCM_UPLOAD_SAMPLE; + + // Clear the d_pcm_api_upload header + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload &= (~B_PCM_UPLOAD_READY); + } + else + { + // Stop the DSP PCM recording task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_UPLOAD_STOP; + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = 0; + + *state = WAIT_DSP_STOP; + } /* end else maximum uplaod size reached */ + } /* end if DSP sends a new block */ + } /* end else */ + } + break; + + case WAIT_DSP_STOP: + { + // The DSP PCM upload task is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_PCM_UPLOAD_ON_GOING)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request--; +#endif // L1_AUDIO_MCU_ONOFF + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_PCM_UPLOAD_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_PCM_UPLOAD_STOP_CON; + //Fill the message + ((T_L1_PCM_UPLOAD_STOP_CON *)(conf_msg->SigP))->uploaded_size = l1s.pcm.upload.uploaded_size; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + #endif /* L1_PCM_EXTRACTION */ + + #if (L1_VOICE_MEMO_AMR) + /*-------------------------------------------------------*/ + /* l1s_vm_amr_play_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Voice memo amr playing L1S manager task.*/ + /* */ + /*-------------------------------------------------------*/ + void l1s_vm_amr_play_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, + WAIT_DSP_START = 2, + WAIT_DSP_REQUEST = 3, + WAIT_DSP_STOP = 4 +#else + WAIT_DSP_START = 1, + WAIT_DSP_REQUEST = 2, + WAIT_DSP_STOP = 3 +#endif + }; + + UWORD8 *state = &l1s.audio_state[L1S_VM_AMR_PLAY_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 sample_header; + + switch(*state) + { + case IDLE: + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = WAIT_AUDIO_ON; +#else + // Initialize the buffer parameters + l1s.voicememo_amr.play.ptr_buf = NULL; + l1s.voicememo_amr.play.buffer_size = 0; + l1s.voicememo_amr.play.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo_amr.play.ptr_buf, + &l1s.voicememo_amr.play.buffer_size, + l1a_l1s_com.voicememo_amr_task.play.parameters.session_id); + + // Convert the buffer size in bytes unit because VM AMR is defined in byte unit + l1s.voicememo_amr.play.buffer_size <<= 1; + + // Initialize previous sample parameters in order to create ONSET on first SAMPLE + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_NO_DATA; + l1s.voicememo_amr.play.transition_header = 0; + + // Initialize a_du_x + // Determine which a_du buffer is currently used + l1s.voicememo_amr.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo_amr.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + *(l1s.voicememo_amr.play.a_du_x) = 0; + + // Start the voice memo playing DSP task + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VM_VOCODER_SELECT; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_PLAY_START; + + *state = WAIT_DSP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Initialize the buffer parameters + l1s.voicememo_amr.play.ptr_buf = NULL; + l1s.voicememo_amr.play.buffer_size = 0; + l1s.voicememo_amr.play.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo_amr.play.ptr_buf, + &l1s.voicememo_amr.play.buffer_size, + l1a_l1s_com.voicememo_amr_task.play.parameters.session_id); + + // Convert the buffer size in bytes unit because VM AMR is defined in byte unit + l1s.voicememo_amr.play.buffer_size <<= 1; + + // Initialize previous sample parameters in order to create ONSET on first SAMPLE + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_NO_DATA; + l1s.voicememo_amr.play.transition_header = 0; + + // Initialize a_du_x + // Determine which a_du buffer is currently used + l1s.voicememo_amr.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo_amr.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + *(l1s.voicememo_amr.play.a_du_x) = 0; + + // Start the voice memo playing DSP task + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VM_VOCODER_SELECT; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_PLAY_START; + + *state = WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case WAIT_DSP_START: + { + // The DSP task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_AMR_PLAY_ON_GOING) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_AMR_PLAY_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_REQUEST; + } + } + break; + + case WAIT_DSP_REQUEST: + { + // The MMI requests to stop the voice memorization playing task + if (l1a_l1s_com.voicememo_amr_task.play.command.stop) + { + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_PLAY_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP needs a new block ? + { + // Determine which a_du buffer is currently used + l1s.voicememo_amr.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo_amr.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + // B_BLOCK_READY is not set if DSP is ready to get new sample + if (!(*(l1s.voicememo_amr.play.a_du_x) & B_BLOCK_READY)) + { + // Issue: transition from not speech sample to speech sample requires creation of transition ONSET sample + storing temporarily speech header + // We use it on next DSP request => when previous sample was ONSET, header must be taken from transition_header + if (l1s.voicememo_amr.play.previous_type == SC_VM_AMR_ONSET) + { + // we use speech header temprarily stored in transition_header + sample_header = l1s.voicememo_amr.play.transition_header; + } + else + { + // Download the header of the new sample + l1s.voicememo_amr.play.error_id = copy_byte_data_from_buffer (l1a_l1s_com.voicememo_amr_task.play.parameters.session_id, + &l1s.voicememo_amr.play.buffer_size, + (UWORD8 **)&l1s.voicememo_amr.play.ptr_buf, + 1, + &sample_header); + } + + // Is it the end of the voice memo data buffer? + if ( sample_header == SC_VM_AMR_END_MASK ) + { + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_PLAY_STOP; + + *state = WAIT_DSP_STOP; + } + else + { + UWORD8 temp_header; + UWORD8 data_size; + + // Identify AMR sample RX_TX_TYPE + temp_header = sample_header & SC_RX_TX_TYPE_MASK; + switch(temp_header) + { + case SC_VM_AMR_RXTX_SPEECH_GOOD: + case SC_VM_AMR_RXTX_SPEECH_BAD: + { + // Check if previous sample is a non speech sample so we have to create ONSET sample + if ( (l1s.voicememo_amr.play.previous_type == SC_VM_AMR_NOISE)||(l1s.voicememo_amr.play.previous_type == SC_VM_AMR_NO_DATA) ) + { + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_ONSET; + l1s.voicememo_amr.play.transition_header = sample_header; + sample_header = SC_VM_AMR_RXTX_ONSET; + data_size = SC_VM_AMR_ONSET_DATA_SIZE; + } + else + { + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_SPEECH; + + // read channel type to know which vocoder is used (and size of data bits) + temp_header = sample_header & SC_CHAN_TYPE_MASK; + switch(temp_header) + { + case SC_VM_AMR_SPEECH_475: + data_size = SC_VM_AMR_SPEECH_475_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_515: + data_size = SC_VM_AMR_SPEECH_515_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_59: + data_size = SC_VM_AMR_SPEECH_59_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_67: + data_size = SC_VM_AMR_SPEECH_67_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_74: + data_size = SC_VM_AMR_SPEECH_74_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_795: + data_size = SC_VM_AMR_SPEECH_795_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_102: + data_size = SC_VM_AMR_SPEECH_102_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_122: + data_size = SC_VM_AMR_SPEECH_122_DATA_SIZE; + break; + } // switch(temp_header) + } + } + break; + case SC_VM_AMR_RXTX_SID_FIRST: + data_size = SC_VM_AMR_SID_FIRST_DATA_SIZE; + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_NOISE; + break; + case SC_VM_AMR_RXTX_SID_UPDATE: + data_size = SC_VM_AMR_SID_UPDATE_DATA_SIZE; + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_NOISE; + break; + case SC_VM_AMR_RXTX_SID_BAD: + data_size = SC_VM_AMR_SID_BAD_DATA_SIZE; + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_NOISE; + break; + case SC_VM_AMR_RXTX_NO_DATA: + data_size = SC_VM_AMR_NO_DATA_DATA_SIZE; + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_NO_DATA; + break; + default: + // trace error + break; + } + + // if data_size is 0 (SID_FIRST, NO_DATA and ONSET), nothing to copy + if (data_size > 0) + { + // go beyond the 2 DSP words after the header, which are not used in MMS (so a_du_x + 3 in words) + l1s.voicememo_amr.play.error_id = copy_byte_data_le_from_buffer (l1a_l1s_com.voicememo_amr_task.play.parameters.session_id, + &l1s.voicememo_amr.play.buffer_size, + (UWORD8 **)&l1s.voicememo_amr.play.ptr_buf, + data_size, + l1s.voicememo_amr.play.a_du_x + 3); + } + // Send the header to the DSP + *l1s.voicememo_amr.play.a_du_x = (sample_header | B_BLOCK_READY); + } + } + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP voice memorization playing task is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_AMR_PLAY_ON_GOING)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_AMR_PLAY_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_vm_amr_record_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Voice memo amr recoding L1S manager task*/ + /* */ + /*-------------------------------------------------------*/ + void l1s_vm_amr_record_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, + WAIT_DSP_START = 2, + WAIT_DSP_SAMPLE = 3, + WAIT_DSP_STOP = 4 +#else + WAIT_DSP_START = 1, + WAIT_DSP_SAMPLE = 2, + WAIT_DSP_STOP = 3 +#endif + }; + + UWORD8 *state = &l1s.audio_state[L1S_VM_AMR_RECORD_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 sample_header; + + switch(*state) + { + case IDLE: + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request++; + *state = WAIT_AUDIO_ON; +#else + // Initialize the buffer parameters + l1s.voicememo_amr.record.ptr_buf = NULL; + l1s.voicememo_amr.record.buffer_size = 0; + l1s.voicememo_amr.record.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo_amr.record.ptr_buf, + &l1s.voicememo_amr.record.buffer_size, + l1a_l1s_com.voicememo_amr_task.record.parameters.session_id); + + // Convert the buffer size in bytes unit because VM AMR is defined in byte unit + l1s.voicememo_amr.record.buffer_size <<= 1; + + // Initialize the size of the Voice memo to record + l1s.voicememo_amr.record.recorded_size = 0; + + // Initialize the DTX mode + if (l1a_l1s_com.voicememo_amr_task.record.parameters.dtx) + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VOICE_MEMO_DTX; + else + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VOICE_MEMO_DTX); + + // Select AMR vocoder and specified channel type + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VM_VOCODER_SELECT; // AMR voice memo + l1s_dsp_com.dsp_ndb_ptr->d_amms_ul_voc &= ~(SC_CHAN_TYPE_MASK); + l1s_dsp_com.dsp_ndb_ptr->d_amms_ul_voc |= l1a_l1s_com.voicememo_amr_task.record.parameters.amr_vocoder; + +#if 0 /* FreeCalypso: not present in TCS211 object */ + l1s.voicememo_amr.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo_amr.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + *(l1s.voicememo_amr.record.a_du_x) = 0; +#endif + + // Start the voice memo recording DSP task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_RECORD_START; + + *state = WAIT_DSP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE] == L1_AUDIO_UL_ON)) + { + // Initialize the buffer parameters + l1s.voicememo_amr.record.ptr_buf = NULL; + l1s.voicememo_amr.record.buffer_size = 0; + l1s.voicememo_amr.record.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo_amr.record.ptr_buf, + &l1s.voicememo_amr.record.buffer_size, + l1a_l1s_com.voicememo_amr_task.record.parameters.session_id); + + // Convert the buffer size in bytes unit because VM AMR is defined in byte unit + l1s.voicememo_amr.record.buffer_size <<= 1; + + // Initialize the size of the Voice memo to record + l1s.voicememo_amr.record.recorded_size = 0; + + // Initialize the DTX mode + if (l1a_l1s_com.voicememo_amr_task.record.parameters.dtx) + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VOICE_MEMO_DTX; + else + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VOICE_MEMO_DTX); + + // Select AMR vocoder and specified channel type + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VM_VOCODER_SELECT; // AMR voice memo + l1s_dsp_com.dsp_ndb_ptr->d_amms_ul_voc &= ~(SC_CHAN_TYPE_MASK); + l1s_dsp_com.dsp_ndb_ptr->d_amms_ul_voc |= l1a_l1s_com.voicememo_amr_task.record.parameters.amr_vocoder; + + l1s.voicememo_amr.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo_amr.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + *(l1s.voicememo_amr.record.a_du_x) = 0; + + // Start the voice memo recording DSP task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_RECORD_START; + + *state = WAIT_DSP_START; + } + } + break; + +#endif // L1_AUDIO_MCU_ONOFF + + case WAIT_DSP_START: + { + // The DSP task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_AMR_RECORD_ON_GOING) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_AMR_RECORD_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_SAMPLE; + } + } // case WAIT_DSP_START: + break; + + case WAIT_DSP_SAMPLE: + { + // The MMI requests to stop the voice memorization recording task + if (l1a_l1s_com.voicememo_amr_task.record.command.stop) + { + // Write the end mask at the end of the voice data RAM buffer + sample_header = SC_VM_AMR_END_MASK; + l1s.voicememo_amr.record.error_id = copy_byte_data_to_buffer (l1a_l1s_com.voicememo_amr_task.record.parameters.session_id, + &l1s.voicememo_amr.record.buffer_size, + (UWORD8 **)&l1s.voicememo_amr.record.ptr_buf, + 1, + &sample_header); + + // Increase the recorded size + l1s.voicememo_amr.record.recorded_size++; + + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_RECORD_STOP; + + *state = WAIT_DSP_STOP; + } // if (l1a_l1s_com.voicememo_amr_task.record.command.stop) + else + // The DSP sends a new block ? + { + // Determine which a_du buffer is currently used + l1s.voicememo_amr.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo_amr.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + // The DSP sends a new block? + if ( (*(l1s.voicememo_amr.record.a_du_x)) & B_BLOCK_READY ) + { + UWORD8 sample_header, temp_header; + UWORD8 data_size; + + // get RX_TYPE to identify frame (SPEECH_GOOD, SID_FIRST, SID_UPDATE, NO_DATA) + sample_header = (*l1s.voicememo_amr.record.a_du_x & 0x00FF); + temp_header = sample_header & SC_RX_TX_TYPE_MASK; + + // Check if the block contains speech or SID or NO_DATA + switch(temp_header) + { + case SC_VM_AMR_RXTX_SPEECH_GOOD: + { + temp_header = sample_header & SC_CHAN_TYPE_MASK; + switch(temp_header) + { + case SC_VM_AMR_SPEECH_475: + data_size = SC_VM_AMR_SPEECH_475_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_515: + data_size = SC_VM_AMR_SPEECH_515_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_59: + data_size = SC_VM_AMR_SPEECH_59_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_67: + data_size = SC_VM_AMR_SPEECH_67_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_74: + data_size = SC_VM_AMR_SPEECH_74_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_795: + data_size = SC_VM_AMR_SPEECH_795_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_102: + data_size = SC_VM_AMR_SPEECH_102_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_122: + data_size = SC_VM_AMR_SPEECH_122_DATA_SIZE; + break; + } + } // case SC_VM_AMR_RXTX_SPEECH_GOOD: + break; + case SC_VM_AMR_RXTX_SID_FIRST: + data_size = SC_VM_AMR_SID_FIRST_DATA_SIZE; + break; + case SC_VM_AMR_RXTX_SID_UPDATE: + data_size = SC_VM_AMR_SID_UPDATE_DATA_SIZE; + break; + case SC_VM_AMR_RXTX_NO_DATA: + data_size = SC_VM_AMR_NO_DATA_DATA_SIZE; + break; + default: + // trace error + break; + } // switch(temp_header) + + // The maximum allocated size is reached? (need to be able to store header + data + end_mask) + if ( (l1s.voicememo_amr.record.recorded_size+data_size+SC_VM_AMR_HEADER_SIZE+SC_VM_AMR_END_MASK_SIZE) <= l1a_l1s_com.voicememo_amr_task.record.parameters.maximum_size) + { + // Download the header from the a_du_x buffer. + l1s.voicememo_amr.record.error_id = copy_byte_data_to_buffer (l1a_l1s_com.voicememo_amr_task.record.parameters.session_id, + &l1s.voicememo_amr.record.buffer_size, + (UWORD8 **)&l1s.voicememo_amr.record.ptr_buf, + 1, + &sample_header); + + if (data_size > 0) + { + l1s.voicememo_amr.record.error_id = copy_byte_data_le_to_buffer (l1a_l1s_com.voicememo_amr_task.record.parameters.session_id, + &l1s.voicememo_amr.record.buffer_size, + (UWORD8 **)&l1s.voicememo_amr.record.ptr_buf, + data_size, + l1s.voicememo_amr.record.a_du_x + 3); + } + + // Increase the recorded size (header + data_bits) + l1s.voicememo_amr.record.recorded_size += data_size + SC_VM_AMR_HEADER_SIZE; + + // Clear the a_du_x header: + *(l1s.voicememo_amr.record.a_du_x) = 0; + } + else + { + // Write the end mask at the end of the voice data RAM buffer + sample_header = SC_VM_AMR_END_MASK; + l1s.voicememo_amr.record.error_id = copy_byte_data_to_buffer (l1a_l1s_com.voicememo_amr_task.record.parameters.session_id, + &l1s.voicememo_amr.record.buffer_size, + (UWORD8 **)&l1s.voicememo_amr.record.ptr_buf, + 1, + &sample_header); + + // Increase the recorded size + l1s.voicememo_amr.record.recorded_size++; + + // Clear the a_du_x header: + *(l1s.voicememo_amr.record.a_du_x) = 0; + + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_RECORD_STOP; + + *state = WAIT_DSP_STOP; + } + } + } // else of if (l1a_l1s_com.voicememo_amr_task.record.command.stop) + } + break; + + case WAIT_DSP_STOP: + { + // The DSP voice memorization playing task is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_AMR_RECORD_ON_GOING)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request--; +#endif // L1_AUDIO_MCU_ONOFF + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_VM_AMR_RECORD_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_AMR_RECORD_STOP_CON; + //Fill the message + ((T_L1_VM_AMR_RECORD_CON *)(conf_msg->SigP))->recorded_size = l1s.voicememo_amr.record.recorded_size; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch(*state) + } + + #endif // L1_VOICE_MEMO_AMR + + #if (SPEECH_RECO) + /*-------------------------------------------------------*/ + /* l1s_sr_enroll_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : speech recognition enroll */ + /* L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_sr_enroll_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_START = 1, + WAIT_ACQUISITION_STATUS = 2, + WAIT_DSP_STOP = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_SR_ENROLL_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Initialize the status register + l1s_dsp_com.dsp_ndb_ptr->d_sr_status = 0; + + // Disable the DSP bit exact test + l1s_dsp_com.dsp_ndb_ptr->d_sr_bit_exact_test &= 0xff80; + + // Initialize the watchdog timer with the time to acquire a word + l1s.speechreco.time_out = SC_SR_AQUISITION_TIME_OUT; + + // Start the DSP enroll task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_ENROLL; + + *state = WAIT_DSP_START; + } + break; + + case WAIT_DSP_START: + { + // The DSP enroll task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_SR_ENROLL_TASK) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_ENROLL_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_ACQUISITION_STATUS; + } + } + break; + + case WAIT_ACQUISITION_STATUS: + { + // the allowed time isn't out + if (l1s.speechreco.time_out--) + { + // The DSP enroll task ran bad or the MMI stop the enroll task + if ( (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_BAD_ACQUISITION) || + (l1a_l1s_com.speechreco_task.command.enroll_stop) ) + { + // Error: bad acquisition + l1s.speechreco.error = SC_BAD_ACQUISITION; + + // Stop the DSP enroll task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP enroll task ran good + if (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_GOOD_ACQUISITION) + { + // No error + l1s.speechreco.error = SC_NO_ERROR; + + // Stop the DSP enroll task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + else + { + // Error: time is out + l1s.speechreco.error = SC_TIME_OUT; + + // Stop the DSP enroll task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP enroll task is stopped + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & (B_SR_ENROLL_TASK | B_VM_RECORD_ON_GOING)) ) + { + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_ENROLL_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_ENROLL_STOP_CON; + //Fill the message + ((T_L1_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = l1s.speechreco.error; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_sr_update_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : speech recognition update */ + /* L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_sr_update_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_START = 1, + WAIT_ACQUISITION_STATUS = 2, + WAIT_UPDATE_STATUS = 3, + WAIT_DSP_STOP = 4 + }; + + UWORD8 *state = &l1s.audio_state[L1S_SR_UPDATE_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Initialize the status register + l1s_dsp_com.dsp_ndb_ptr->d_sr_status = 0; + + // Disable the DSP bit exact test + l1s_dsp_com.dsp_ndb_ptr->d_sr_bit_exact_test &= 0xff80; + + // Initialize the watchdog timer with the time to acquire a word + l1s.speechreco.time_out = SC_SR_AQUISITION_TIME_OUT; + + // Start the DSP update task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_UPDATE; + + #if (W_A_DSP_SR_BGD) + // Management of DSP tasks in background + if (l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt & B_DSPBGD_UPD) + { + l1s_dsp_com.dsp_ndb_ptr->d_background_enable |= (1 << C_BGD_ALIGN); + } + #endif + + *state = WAIT_DSP_START; + } + break; + + case WAIT_DSP_START: + { + // The DSP update task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_SR_UPDATE_TASK) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_UPDATE_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_ACQUISITION_STATUS; + } + } + break; + + case WAIT_ACQUISITION_STATUS: + { + // the allowed time isn't out + if (l1s.speechreco.time_out--) + { + // The DSP acquisition task ran bad or the MMI stop the update task + if ( (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_BAD_ACQUISITION) || + (l1a_l1s_com.speechreco_task.command.update_stop) ) + { + // Error: bad acquisition + l1s.speechreco.error = SC_BAD_ACQUISITION; + + // Stop the DSP acquisition task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP enroll task ran good + if (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_GOOD_ACQUISITION) + { + // Initialize the watchdog timer with the time to update a word + l1s.speechreco.time_out = SC_SR_UPDATE_TIME_OUT; + + *state = WAIT_UPDATE_STATUS; + } + } + else + { + // Error: time is out + l1s.speechreco.error = SC_TIME_OUT; + + // Stop the DSP acquisition task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + break; + + + case WAIT_UPDATE_STATUS: + { + // the allowed time isn't out + if (l1s.speechreco.time_out--) + { + // The DSP update task ran bad or the MMI stop the update task + if ( (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_BAD_UPDATE) || + (l1a_l1s_com.speechreco_task.command.update_stop) ) + { + // Error: bad update + l1s.speechreco.error = SC_BAD_UPDATE; + + // Stop the DSP update task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP update task ran good + if (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_GOOD_UPDATE) + { + // No error: + l1s.speechreco.error = SC_NO_ERROR; + + // Stop the DSP update task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + else + { + // Error: time is out + l1s.speechreco.error = SC_TIME_OUT; + + // Stop the DSP enroll task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP enroll task is stopped + if ( !( l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & (B_SR_UPDATE_TASK | B_SR_ALIGNMENT_TASK | B_VM_RECORD_ON_GOING) ) ) + { + #if (W_A_DSP_SR_BGD) + // Management of DSP tasks in background + if (l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt & B_DSPBGD_UPD) + { + l1s_dsp_com.dsp_ndb_ptr->d_background_enable &= ~(1 << C_BGD_ALIGN); + } + #endif + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_UPDATE_STOP_CON; + //Fill the message + ((T_L1_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = l1s.speechreco.error; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_sr_reco_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : speech recognition reco acquisition */ + /* L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_sr_reco_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_START = 1, + WAIT_ACQUISITION_STATUS = 2, + WAIT_DSP_STOP = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_SR_RECO_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Initialize the status register + l1s_dsp_com.dsp_ndb_ptr->d_sr_status = 0; + + // Disable the DSP bit exact test + l1s_dsp_com.dsp_ndb_ptr->d_sr_bit_exact_test &= 0xff80; + + // Initialize the watchdog timer with the time to acquire a word + l1s.speechreco.time_out = SC_SR_AQUISITION_TIME_OUT; + + // Start the DSP acquisition reco task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_RECO; + + *state = WAIT_DSP_START; + } + break; + + case WAIT_DSP_START: + { + // The DSP reco task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_SR_RECO_TASK) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_RECO_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_ACQUISITION_STATUS; + } + } + break; + + case WAIT_ACQUISITION_STATUS: + { + // the allowed time isn't out + if (l1s.speechreco.time_out--) + { + // The DSP acquisition reco task ran bad or the MMI stop the acquisition reco task + if ( (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_BAD_ACQUISITION) || + (l1a_l1s_com.speechreco_task.command.reco_stop) ) + { + // Error: bad acquisition + l1s.speechreco.error = SC_BAD_ACQUISITION; + + // Stop the DSP acquisition reco task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP enroll task ran good + if (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_GOOD_ACQUISITION) + { + // No error + l1s.speechreco.error = SC_NO_ERROR; + + // Stop the DSP acquisition reco task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + else + { + // Error: time is out + l1s.speechreco.error = SC_TIME_OUT; + + // Stop the DSP acquisition reco task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP enroll task is stopped + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_SR_RECO_TASK) ) + { + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_RECO_STOP_CON; + //Fill the message + ((T_L1_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = l1s.speechreco.error; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_sr_processing_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : speech recognition reco processing */ + /* L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_sr_processing_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_PROCESSING_STOP = 1, + WAIT_DSP_RESULT = 2, + WAIT_DSP_STOP = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_SR_PROCESSING_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Initialize the status register + l1s_dsp_com.dsp_ndb_ptr->d_sr_status = 0; + + // Disable the DSP bit exact test + l1s_dsp_com.dsp_ndb_ptr->d_sr_bit_exact_test &= 0xff80; + + // Initialize the OOV algorithm + l1s_dsp_com.dsp_ndb_ptr->d_sr_param &= 0x20; + l1s_dsp_com.dsp_ndb_ptr->d_sr_param |= SC_SR_OOV_SFT_THR; + + // Transmit ot the DSP the number of word to compare + l1s_dsp_com.dsp_ndb_ptr->d_sr_nb_words = l1a_l1s_com.speechreco_task.parameters.vocabulary_size; + + // Initialize the watchdog timer with the time to process a word + l1s.speechreco.time_out = SC_SR_PROCESSING_TIME_OUT; + + // Start the DSP processing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_PROCESSING; + + #if (W_A_DSP_SR_BGD) + // Management of DSP tasks in background + if (l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt & B_DSPBGD_RECO) + { + l1s_dsp_com.dsp_ndb_ptr->d_background_enable |= (1 << C_BGD_RECOGN); + } + #endif + + // Reset the start command + l1a_l1s_com.speechreco_task.command.processing_start = FALSE; + + *state = WAIT_DSP_PROCESSING_STOP; + } + break; + + case WAIT_DSP_PROCESSING_STOP: + { + if (l1s.speechreco.time_out--) + { + // The MMI stops the processing task + if (l1a_l1s_com.speechreco_task.command.processing_stop) + { + // Error: bad acquisition + l1s.speechreco.error = SC_BAD_RECOGNITION; + + // Stop the DSP processing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP processing task is stopped + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_SR_PROCESSING_TASK) ) + { + // It was the last model + if (l1a_l1s_com.speechreco_task.parameters.index_counter == l1a_l1s_com.speechreco_task.parameters.vocabulary_size) + { + *state = WAIT_DSP_RESULT; + } + else + { + // Send the stop confirmation message with no error + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_PROCESSING_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_PROCESSING_STOP_CON; + //Fill the message + ((T_L1_SR_PROCESSING_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + } + else + // the allowed time is out + { + // Error: time is out + l1s.speechreco.error = SC_TIME_OUT; + + // Stop the DSP processing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + break; + + case WAIT_DSP_RESULT: + { + + #if (W_A_DSP_SR_BGD) + // Management of DSP tasks in background + if (l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt & B_DSPBGD_RECO) + { + l1s_dsp_com.dsp_ndb_ptr->d_background_enable &= ~(1 << C_BGD_RECOGN); + } + #endif + + // The DSP recognition task was bad + if (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_BAD_ACQUISITION) + { + // Send the stop indication message with an bad recognition error + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_RECO_STOP_IND)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_RECO_STOP_IND; + //Fill the message + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION; + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + else + // The DSP recognition task was good: + { + // Send the stop indication message without any error + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_RECO_STOP_IND)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_RECO_STOP_IND; + //Fill the message + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->error_id = SC_NO_ERROR; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->best_word_index = l1s_dsp_com.dsp_ndb_ptr->a_n_best_words[0]; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->best_word_score = l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[0] | (l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[1] << 16); + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->second_best_word_index = l1s_dsp_com.dsp_ndb_ptr->a_n_best_words[1]; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->second_best_word_score = l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[2] | (l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[3] << 16); + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->third_best_word_index = l1s_dsp_com.dsp_ndb_ptr->a_n_best_words[2]; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->third_best_word_score = l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[4] | (l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[5] << 16); + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->fourth_best_word_index = l1s_dsp_com.dsp_ndb_ptr->a_n_best_words[3]; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->fourth_best_word_score = l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[6] | (l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[7] << 16); + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->d_sr_db_level = l1s_dsp_com.dsp_ndb_ptr->d_sr_db_level; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->d_sr_db_noise = l1s_dsp_com.dsp_ndb_ptr->d_sr_db_noise; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->d_sr_model_size = l1s_dsp_com.dsp_ndb_ptr->d_sr_mod_size; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP processing task is stopped + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_SR_PROCESSING_TASK) ) + { + // Send the stop confirmation message with an error + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_PROCESSING_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_PROCESSING_STOP_CON; + //Fill the message + ((T_L1_SR_PROCESSING_STOP_CON *)(conf_msg->SigP))->error_id = l1s.speechreco.error; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_sr_speech_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : speech recognition speech recording */ + /* L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_sr_speech_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_START = 1, + WAIT_DSP_SAMPLE = 2, + WAIT_DSP_STOP = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_SR_SPEECH_STATE]; + API *a_du_x; + UWORD8 i; + + switch(*state) + { + case IDLE: + { + // Initialize the current pointer + l1s.speechreco.speech_pointer = l1a_l1s_com.speechreco_task.parameters.speech_address; + l1s.speechreco.end_pointer = (UWORD16 *)(l1s.speechreco.speech_pointer + SC_SR_MMI_2_L1_SPEECH_SIZE); + + // Initialize the flag to know if it's the first pass in the circular buffer + l1s.speechreco.first_pass = TRUE; + + // Initialize the status register + l1s_dsp_com.dsp_ndb_ptr->d_sr_status = 0; + + // No DTX mode + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VOICE_MEMO_DTX); + #if ((DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // use TCH/FS vocoder + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VM_VOCODER_SELECT); + #endif + + + // Start the voice memo recodgin DSP task: + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_START; + + *state = WAIT_DSP_START; + } + break; + + case WAIT_DSP_START: + { + // The DSP is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_RECORD_ON_GOING) + { + *state = WAIT_DSP_SAMPLE; + } + } + break; + + case WAIT_DSP_SAMPLE: + { + // A beginning of word is detected + if ( ((l1s_dsp_com.dsp_ndb_ptr->d_sr_status & SC_SR_WORD_MASK) == SC_SR_WORD_BEGINNING) && + (l1s.speechreco.speech_old_status == SC_SR_WORD_SEARCHING) ) + { + // Calculate the address of the beginning of the word + l1a_l1s_com.speechreco_task.parameters.start_address = + l1s.speechreco.speech_pointer - ((SC_SR_SPEECH_WORD_BEGIN_VAD_LATENCY + SC_SR_SPEECH_WORD_BEGIN_MARGIN) * SC_SR_SPEECH_FRAME_SIZE); + if (l1a_l1s_com.speechreco_task.parameters.start_address < l1a_l1s_com.speechreco_task.parameters.speech_address) + { + if (l1s.speechreco.first_pass == FALSE) + { + l1a_l1s_com.speechreco_task.parameters.start_address = l1s.speechreco.end_pointer - + ( l1a_l1s_com.speechreco_task.parameters.speech_address - (l1s.speechreco.speech_pointer - ((SC_SR_SPEECH_WORD_BEGIN_VAD_LATENCY + SC_SR_SPEECH_WORD_BEGIN_MARGIN) * SC_SR_SPEECH_FRAME_SIZE)) ); + } + else + { + l1a_l1s_com.speechreco_task.parameters.start_address = l1a_l1s_com.speechreco_task.parameters.speech_address; + } + } + } + else + // A end of word is detected + if ( ((l1s_dsp_com.dsp_ndb_ptr->d_sr_status & SC_SR_WORD_MASK) == SC_SR_WORD_ENDING) && + (l1s.speechreco.speech_old_status == SC_SR_WORD_ON_GOING) ) + { + // Calculate the address of the end of the word + l1a_l1s_com.speechreco_task.parameters.stop_address = + l1s.speechreco.speech_pointer - ((SC_SR_SPEECH_WORD_END_VAD_LATENCY - SC_SR_SPEECH_WORD_END_MARGIN)* SC_SR_SPEECH_FRAME_SIZE); + if (l1a_l1s_com.speechreco_task.parameters.stop_address < l1a_l1s_com.speechreco_task.parameters.speech_address) + { + l1a_l1s_com.speechreco_task.parameters.stop_address = l1s.speechreco.end_pointer - + ( l1a_l1s_com.speechreco_task.parameters.speech_address - (l1s.speechreco.speech_pointer - ((SC_SR_SPEECH_WORD_END_VAD_LATENCY - SC_SR_SPEECH_WORD_END_MARGIN) * SC_SR_SPEECH_FRAME_SIZE)) ); + } + } + + // Save the current status + l1s.speechreco.speech_old_status = l1s_dsp_com.dsp_ndb_ptr->d_sr_status & SC_SR_WORD_MASK; + + // Determine which a_du buffer is currently used + l1s.speechreco.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.speechreco.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + // The acquisition was good + if (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_GOOD_ACQUISITION) + { + // Stop the voice memorization recording task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The task must be stopped + if ( (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_BAD_ACQUISITION) || + (l1a_l1s_com.speechreco_task.command.speech_stop) || + (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_SR_STOP) ) + { + // Stop the DSP voice memorization recording task: + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP sends a new block + if (l1s.speechreco.a_du_x[0] & B_BLOCK_READY) + { + // Is there enough place in the RAM buffer + if (l1s.speechreco.speech_pointer == l1s.speechreco.end_pointer) + { + // Rewind the current pointer + l1s.speechreco.speech_pointer = l1a_l1s_com.speechreco_task.parameters.speech_address; + + // It isn't the first pass + l1s.speechreco.first_pass = FALSE; + } + + // Download the speech sample from the a_du_x to the RAM buffer + a_du_x = l1s.speechreco.a_du_x; + for(i=0; i < SC_SR_SPEECH_FRAME_SIZE; i++) + { + *(l1s.speechreco.speech_pointer)++ = *a_du_x++; + } + + // Clear the a_du_x header + l1s.speechreco.a_du_x[0] = 0; + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP speech recoding task is stopped + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_RECORD_ON_GOING) ) + { + *state = IDLE; + } + } + break; + } // switch + } + + #endif // SPEECH_RECO + #if (AEC == 1) + /*-------------------------------------------------------*/ + /* l1s_aec_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : AEC L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_aec_manager(void) + { + enum states + { + IDLE = 0, + #if (L1_NEW_AEC) + WAIT_DSP_AVAILABLE = 1, + AEC_VISIBILITY = 2 + #else + WAIT_DSP_AVAILABLE = 1 + #endif + }; + + UWORD8 *state = &l1s.audio_state[L1S_AEC_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Set the d_aec_ctrl register + l1s.aec.aec_control = (l1a_l1s_com.aec_task.parameters.aec_control | B_AEC_ACK); + #if (L1_NEW_AEC) + l1s.aec.aec_visibility = (l1s.aec.aec_control & B_AEC_VISIBILITY) >> SC_AEC_VISIBILITY_SHIFT; + l1s.aec.cont_filter = l1a_l1s_com.aec_task.parameters.cont_filter; + l1s.aec.granularity_att = l1a_l1s_com.aec_task.parameters.granularity_att; + l1s.aec.coef_smooth = l1a_l1s_com.aec_task.parameters.coef_smooth; + l1s.aec.es_level_max = l1a_l1s_com.aec_task.parameters.es_level_max; + l1s.aec.fact_vad = l1a_l1s_com.aec_task.parameters.fact_vad; + l1s.aec.thrs_abs = l1a_l1s_com.aec_task.parameters.thrs_abs; + l1s.aec.fact_asd_fil = l1a_l1s_com.aec_task.parameters.fact_asd_fil; + l1s.aec.fact_asd_mut = l1a_l1s_com.aec_task.parameters.fact_asd_mut; + #endif + + // Reset the start command + l1a_l1s_com.aec_task.command.start = FALSE; + + // Send the AEC confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AEC_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_AVAILABLE; + } + break; + + case WAIT_DSP_AVAILABLE: + { + // the new settings come from the MMI + if (l1a_l1s_com.aec_task.command.start) + { + // Set the d_aec_ctrl register + l1s.aec.aec_control = (l1a_l1s_com.aec_task.parameters.aec_control | B_AEC_ACK); + #if (L1_NEW_AEC) + l1s.aec.aec_visibility = (l1s.aec.aec_control & B_AEC_VISIBILITY) >> SC_AEC_VISIBILITY_SHIFT; + l1s.aec.cont_filter = l1a_l1s_com.aec_task.parameters.cont_filter; + l1s.aec.granularity_att = l1a_l1s_com.aec_task.parameters.granularity_att; + l1s.aec.coef_smooth = l1a_l1s_com.aec_task.parameters.coef_smooth; + l1s.aec.es_level_max = l1a_l1s_com.aec_task.parameters.es_level_max; + l1s.aec.fact_vad = l1a_l1s_com.aec_task.parameters.fact_vad; + l1s.aec.thrs_abs = l1a_l1s_com.aec_task.parameters.thrs_abs; + l1s.aec.fact_asd_fil = l1a_l1s_com.aec_task.parameters.fact_asd_fil; + l1s.aec.fact_asd_mut = l1a_l1s_com.aec_task.parameters.fact_asd_mut; + #endif + + // Reset the start command + l1a_l1s_com.aec_task.command.start = FALSE; + + // Send the AEC confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AEC_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + + // the new settings can be written to the DSP +#if(DSP == 38) || (DSP == 39) + if ( (l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl & B_AEC_ACK) == FALSE ) +#else + if ( (l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl & B_AEC_ACK) == FALSE ) +#endif + { + +#if(DSP == 38) || (DSP == 39) + l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl = l1s.aec.aec_control; +#else + l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl = l1s.aec.aec_control; +#endif + + #if (L1_NEW_AEC) + l1s_dsp_com.dsp_ndb_ptr->d_cont_filter = l1s.aec.cont_filter; + l1s_dsp_com.dsp_ndb_ptr->d_granularity_att = l1s.aec.granularity_att; + l1s_dsp_com.dsp_ndb_ptr->d_coef_smooth = l1s.aec.coef_smooth; + l1s_dsp_com.dsp_ndb_ptr->d_es_level_max = l1s.aec.es_level_max; + l1s_dsp_com.dsp_ndb_ptr->d_fact_vad = l1s.aec.fact_vad; + l1s_dsp_com.dsp_ndb_ptr->d_thrs_abs = l1s.aec.thrs_abs; + l1s_dsp_com.dsp_ndb_ptr->d_fact_asd_fil = l1s.aec.fact_asd_fil; + l1s_dsp_com.dsp_ndb_ptr->d_fact_asd_mut = l1s.aec.fact_asd_mut; + + // AEC visibility allows tracing some AEC internal output values + if (l1s.aec.aec_visibility) + *state = AEC_VISIBILITY; + else + *state = IDLE; + #else + *state = IDLE; + #endif + } + } + break; + + #if (L1_NEW_AEC) + case AEC_VISIBILITY: + { + // the new settings come from the MMI + if (l1a_l1s_com.aec_task.command.start) + { + // Set the d_aec_ctrl register + l1s.aec.aec_control = (l1a_l1s_com.aec_task.parameters.aec_control | B_AEC_ACK); + l1s.aec.aec_visibility = (l1s.aec.aec_control & B_AEC_VISIBILITY) >> SC_AEC_VISIBILITY_SHIFT; + l1s.aec.cont_filter = l1a_l1s_com.aec_task.parameters.cont_filter; + l1s.aec.granularity_att = l1a_l1s_com.aec_task.parameters.granularity_att; + l1s.aec.coef_smooth = l1a_l1s_com.aec_task.parameters.coef_smooth; + l1s.aec.es_level_max = l1a_l1s_com.aec_task.parameters.es_level_max; + l1s.aec.fact_vad = l1a_l1s_com.aec_task.parameters.fact_vad; + l1s.aec.thrs_abs = l1a_l1s_com.aec_task.parameters.thrs_abs; + l1s.aec.fact_asd_fil = l1a_l1s_com.aec_task.parameters.fact_asd_fil; + l1s.aec.fact_asd_mut = l1a_l1s_com.aec_task.parameters.fact_asd_mut; + + // Reset the start command + l1a_l1s_com.aec_task.command.start = FALSE; + + // Send the AEC confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AEC_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_AVAILABLE; + } + + if ( (l1a_l1s_com.dedic_set.aset != NULL) && + ((l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_FS_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_HS_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_EFR_MODE)) ) + { + l1s.aec.visibility_interval--; + + if (l1s.aec.visibility_interval < 0) + { + conf_msg = os_alloc_sig(sizeof(T_L1_AEC_IND)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AEC_IND; + + ((T_L1_AEC_IND *)(conf_msg->SigP))->es_level = l1s_dsp_com.dsp_ndb_ptr->d_es_level_api; + ((T_L1_AEC_IND *)(conf_msg->SigP))->far_end_pow = ( (l1s_dsp_com.dsp_ndb_ptr->d_far_end_pow_h << 16) + | (l1s_dsp_com.dsp_ndb_ptr->d_far_end_pow_l)); + ((T_L1_AEC_IND *)(conf_msg->SigP))->far_end_noise = ( (l1s_dsp_com.dsp_ndb_ptr->d_far_end_noise_h << 16) + | (l1s_dsp_com.dsp_ndb_ptr->d_far_end_noise_l)); + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + // reset delay between 2 traces + l1s.aec.visibility_interval = SC_AEC_VISIBILITY_INTERVAL; + } + } + else + // It forces aec traces when entering dedicated mode + l1s.aec.visibility_interval = 1; + } + break; + #endif + } // switch + } + #endif // AEC + + #if(AEC == 2) + + /*-------------------------------------------------------*/ + /* l1s_aec_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : AEC L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ +void l1s_aec_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_AEC_STATE]; + xSignalHeaderRec *conf_msg; + UWORD16 current_state; + static T_AEC_ACTION l1s_aec_action = L1_AQI_AEC_STOPPED; + static UWORD16 l_aec_ctrl; + + + switch(*state) + { + case IDLE: + { + + current_state = l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & 0x0800; + + if((l1a_l1s_com.aec_task.aec_control == L1_AQI_AEC_START)||(l1a_l1s_com.aec_task.aec_control == L1_AQI_AEC_UPDATE)) + { + if(current_state ) + { + +#if(DSP == 38) || (DSP == 39) + l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl = l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl | 0x0004; +#else + l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl = l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl | 0x0004; +#endif + + l_aec_ctrl = 0x0004; + l1s_aec_action = L1_AQI_AEC_UPDATED; + } + else + { + + +#if(DSP == 38) || (DSP == 39) + l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl = l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl | 0x0001; +#else + l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl = l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl | 0x0001; +#endif + l_aec_ctrl = 0x0001; + l1s_aec_action = L1_AQI_AEC_STARTED; + } + + l1s_dsp_com.dsp_ndb_ptr->d_cont_filter = l1a_l1s_com.aec_task.parameters.cont_filter; + l1s_dsp_com.dsp_ndb_ptr->d_granularity_att = l1a_l1s_com.aec_task.parameters.granularity_att; + l1s_dsp_com.dsp_ndb_ptr->d_coef_smooth = l1a_l1s_com.aec_task.parameters.coef_smooth; + l1s_dsp_com.dsp_ndb_ptr->d_es_level_max = l1a_l1s_com.aec_task.parameters.es_level_max; + l1s_dsp_com.dsp_ndb_ptr->d_fact_vad = l1a_l1s_com.aec_task.parameters.fact_vad; + l1s_dsp_com.dsp_ndb_ptr->d_thrs_abs = l1a_l1s_com.aec_task.parameters.thrs_abs; + l1s_dsp_com.dsp_ndb_ptr->d_fact_asd_fil = l1a_l1s_com.aec_task.parameters.fact_asd_fil; + l1s_dsp_com.dsp_ndb_ptr->d_fact_asd_mut = l1a_l1s_com.aec_task.parameters.fact_asd_mut; + l1s_dsp_com.dsp_ndb_ptr->d_aec_mode = l1a_l1s_com.aec_task.parameters.aec_mode; + l1s_dsp_com.dsp_ndb_ptr->d_mu = l1a_l1s_com.aec_task.parameters.mu; + l1s_dsp_com.dsp_ndb_ptr->d_scale_input_ul = l1a_l1s_com.aec_task.parameters.scale_input_ul; + l1s_dsp_com.dsp_ndb_ptr->d_scale_input_dl = l1a_l1s_com.aec_task.parameters.scale_input_dl; + l1s_dsp_com.dsp_ndb_ptr->d_div_dmax = l1a_l1s_com.aec_task.parameters.div_dmax; + l1s_dsp_com.dsp_ndb_ptr->d_div_swap_good = l1a_l1s_com.aec_task.parameters.div_swap_good; + l1s_dsp_com.dsp_ndb_ptr->d_div_swap_bad = l1a_l1s_com.aec_task.parameters.div_swap_bad; + l1s_dsp_com.dsp_ndb_ptr->d_block_init = l1a_l1s_com.aec_task.parameters.block_init; + + + } + else if(l1a_l1s_com.aec_task.aec_control == L1_AQI_AEC_STOP) + { + if(current_state ) + { +#if(DSP == 38) || (DSP == 39) + l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl = (l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl) | 0x0002; +#else + l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl = (l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl) | 0x0002; +#endif + + l_aec_ctrl = 0x0002; + l1s_aec_action = L1_AQI_AEC_STOPPED; + } + else + { + l1a_l1s_com.aec_task.command.start = FALSE; + + // Send the AEC confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_AQI_AEC_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_AEC_CON; + ((T_L1_AQI_AEC_CON*)(conf_msg->SigP))->aec_action = L1_AQI_AEC_NO_ACTION; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + return; + } + } + + *state = WAIT_DSP_ACK; + + + break; + } + + case WAIT_DSP_ACK: + { + +#if(DSP == 38) || (DSP == 39) + if(((l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl) & (l_aec_ctrl)) == 0) +#else + if(((l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl) & (l_aec_ctrl)) == 0) +#endif + + { + l1a_l1s_com.aec_task.command.start = FALSE; + + // Send the AEC confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_AQI_AEC_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_AEC_CON; + ((T_L1_AQI_AEC_CON*)(conf_msg->SigP))->aec_action = l1s_aec_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + + break; + } + }/* End of switch statement */ +} + + #endif + + #if (FIR) + /*-------------------------------------------------------*/ + /* l1s_fir_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : FIR L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_fir_manager(void) + { + + xSignalHeaderRec *conf_msg; + UWORD8 i; + + // Update the DL FIR? + if (l1a_l1s_com.fir_task.parameters.update_fir & DL_FIR) + { + // Download the DL FIR coefficients to the melody a_fir31_downlink + for (i=0; i<MAX_FIR_COEF; i++) + { + #if (DSP >= 33) // For this DSP code the FIR coefficients are in API param memory + l1s_dsp_com.dsp_param_ptr->a_fir31_downlink[i] = *l1a_l1s_com.fir_task.parameters.fir_dl_coefficient++; + #else + l1s_dsp_com.dsp_ndb_ptr->a_fir31_downlink[i] = *l1a_l1s_com.fir_task.parameters.fir_dl_coefficient++; + #endif + } + } + // Update the UL FIR? + if (l1a_l1s_com.fir_task.parameters.update_fir & UL_FIR) + { + // Download the UL FIR coefficients to the melody a_fir31_uplink + for (i=0; i<MAX_FIR_COEF; i++) + { + #if (DSP >= 33) // For this DSP code the FIR coefficients are in API param memory + l1s_dsp_com.dsp_param_ptr->a_fir31_uplink[i] = *l1a_l1s_com.fir_task.parameters.fir_ul_coefficient++; + #else + l1s_dsp_com.dsp_ndb_ptr->a_fir31_uplink[i] = *l1a_l1s_com.fir_task.parameters.fir_ul_coefficient++; + #endif + } + } + + // Set the FIR loop back: + if (l1a_l1s_com.fir_task.parameters.fir_loop) + { + #if (DSP == 17) || (DSP == 32) + l1s_dsp_com.dsp_ndb_ptr->d_audio_init &= ~(B_FIR_START); + #endif + l1s_dsp_com.dsp_ndb_ptr->d_audio_init |= B_FIR_LOOP; + } + else + { + #if (DSP == 17) || (DSP == 32) + l1s_dsp_com.dsp_ndb_ptr->d_audio_init |= B_FIR_START; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_audio_init &= ~(B_FIR_LOOP); + } + + // Send the FIR confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AUDIO_FIR_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + // Reset the start command + l1a_l1s_com.fir_task.command.start = FALSE; + } + #endif // FIR + #if (AUDIO_MODE) + /*-------------------------------------------------------*/ + /* l1s_audio_mode_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Audio mode L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_audio_mode_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_CONFIRM = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_AUDIO_MODE_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + + // Reset the d_audio_init + l1s_dsp_com.dsp_ndb_ptr->d_audio_init &= ~(B_GSM_ONLY | B_BT_HEADSET | B_BT_CORDLESS); + + // Set the new mode + l1s_dsp_com.dsp_ndb_ptr->d_audio_init + |= l1a_l1s_com.audio_mode_task.parameters.audio_mode; + + *state = WAIT_DSP_CONFIRM; + } + break; + + case WAIT_DSP_CONFIRM: + { + // the DSP acknowledges the new settings. + if ( l1s_dsp_com.dsp_ndb_ptr->d_audio_init == l1s_dsp_com.dsp_ndb_ptr->d_audio_status ) + { + // Send the Audio mode confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AUDIO_MODE_CON; + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + // Reset the start command + l1a_l1s_com.audio_mode_task.command.start = FALSE; + + *state = IDLE; + } + } + break; + } // switch + } + #endif // AUDIO_MODE + #if (MELODY_E2) + /*-------------------------------------------------------*/ + /* l1s_melody0_e2_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Audio melody 0 format E2 L1S manager */ + /* task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_melody0_e2_manager(void) + { + enum states + { + M0_INACTIVE = 0, + M0_ALIGN_40MS_BOUNDARY = 1, + M0_WAIT_COUNTER_EQUAL_0 = 2, + M0_WAIT_END_MELODY = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_MELODY0_E2_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 trash[SC_MELODY_E2_MAXIMUM_HEADER_SIZE+1], oscillator_number, extension_index; + UWORD16 oscillator_not_available; + + switch(*state) + { + case M0_INACTIVE: + { + // Reset the commands: + l1a_l1s_com.melody0_e2_task.command.start = FALSE; + + // Initialize the pointer and size to the new description + l1s.melody0_e2.ptr_buf = l1a_l1s_com.melody0_e2_task.parameters.ptr_buf; + l1s.melody0_e2.buffer_size = l1a_l1s_com.melody0_e2_task.parameters.buffer_size; + + *state = M0_ALIGN_40MS_BOUNDARY; + } + break; + + case M0_ALIGN_40MS_BOUNDARY: + { + // Initialize the counter to the first time + l1s.melody0_e2.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1s.melody0_e2.buffer_size, + (UWORD8 **)&l1s.melody0_e2.ptr_buf, + 1, + (UWORD8 *)(&l1s.melody0_e2.counter)); + + // Save the extension flag + l1s.melody0_e2.extension_flag = Field(l1s.melody0_e2.counter, + SC_MELODY_E2_EXTENSION_FLAG_MASK, + SC_MELODY_E2_EXTENSION_FLAG_SHIFT); + + // Save delta-time in 20ms unit + l1s.melody0_e2.counter = Field(l1s.melody0_e2.counter, + SC_MELODY_E2_DELTA_TIME_MASK, + SC_MELODY_E2_DELTA_TIME_SHIFT); + l1s.melody0_e2.note_start_20ms = l1s.melody0_e2.counter; + + // Adjust note_start on 20ms boundary because global counter could be running for another melody or loopback + // Timebase can be computed as k*60ms + timebase_mod_60ms + l1s.melody0_e2.note_start_20ms += ((l1s.melody_e2.timebase - l1s.melody_e2.timebase_mod_60ms) / 13 * 3); + if (l1s.melody_e2.timebase_mod_60ms < 4) + { + l1s.melody0_e2.note_start_20ms += 1; + } + else if (l1s.melody_e2.timebase_mod_60ms < 8) + { + l1s.melody0_e2.note_start_20ms += 2; + } + else if (l1s.melody_e2.timebase_mod_60ms < 13) + { + l1s.melody0_e2.note_start_20ms += 3; + } + + // Align on 40ms boundary + if ( (l1s.melody0_e2.note_start_20ms & 1) == 1 ) + l1s.melody0_e2.note_start_20ms++; + + // Convert to TDMA + l1s.melody0_e2.counter = audio_twentyms_to_TDMA_convertion(l1s.melody0_e2.note_start_20ms); + + // Compute TDMA to wait (-1 to take into account this TDMA) + l1s.melody0_e2.counter = l1s.melody0_e2.counter - l1s.melody_e2.timebase - 1; + + // Wait to download the first description + *state = M0_WAIT_COUNTER_EQUAL_0; + } // M0_INIT + break; + + case M0_WAIT_COUNTER_EQUAL_0: + { + // Stop command + if (l1a_l1s_com.melody0_e2_task.command.stop) + { + // wait until all the ocillator are stopped + *state = M0_WAIT_END_MELODY; + } + else if (l1s.melody0_e2.counter > 0) + { + // Decrease the counter + l1s.melody0_e2.counter--; + } + else + { + // Wait until the semaphore is set to 0 by the DSP + if (!(l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore & SC_MELODY_E2_SEMAPHORE_MASK)) + { + // Initialize oscillators available, oscillators can be used by the DSP (d_melody_e2_osc_active) + // or by the other melody E2 generator (melody_e2_osc_stop) + oscillator_not_available = + l1s.melody_e2.global_osc_active | l1s.melody_e2.global_osc_to_start; + + // find an available oscillator + oscillator_number = 0; + while( (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) && + (oscillator_not_available & (0x0001<<oscillator_number)) ) + { + oscillator_number++; + } + + // Initialize end of file + l1s.melody0_e2.end_of_file = FALSE; + + // download the description until the delta time is different from 0 + // or end of the melody file + while ( (l1s.melody0_e2.counter == 0) && + (l1s.melody0_e2.end_of_file == FALSE) ) + { + // Download the byte of the note descriptor extension in trash + l1s.melody0_e2.error_id= copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1s.melody0_e2.buffer_size, + (UWORD8 **)&l1s.melody0_e2.ptr_buf, + 2, + &trash[0]); + + // Check end of melody + if ( (trash[0] != 0x00) || (trash[1] != 0x00) ) + { + // It is not the end of melody + + // If an oscillator is available, use it + if (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) + { + // Reset the oscillator description + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][0] = 0x0000; + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][1] = 0x0000; + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][2] = 0x0000; + + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][0] = + trash[0] + (trash[1] << 8); + + // Update the oscillators to start bit field + l1s.melody_e2.global_osc_to_start |= (0x0001<<oscillator_number); + + // Save the oscillator as active for this melody + l1s.melody0_e2.oscillator_active |= (0x0001<<oscillator_number); + + // oscillator is no longer available + oscillator_not_available |= (0x0001<<oscillator_number); + } + + // Download the extensions + extension_index = 1; + while(l1s.melody0_e2.extension_flag) + { + // Download the byte of the note descriptor extension + l1s.melody0_e2.error_id= copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1s.melody0_e2.buffer_size, + (UWORD8 **)&l1s.melody0_e2.ptr_buf, + 2, + &trash[0]); + + // Read the extension flag + l1s.melody0_e2.extension_flag = Field(trash[0], + SC_MELODY_E2_EXTENSION_FLAG_MASK, + SC_MELODY_E2_EXTENSION_FLAG_SHIFT); + + // If an oscillator is available, use it + if (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) + { + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][extension_index] = + trash[0] + (trash[1] << 8); + } + + extension_index++; + } // extension download + + // find next available oscillator + while( (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) && + (oscillator_not_available & (0x0001<<oscillator_number)) ) + { + oscillator_number++; + } + + // Read next delta time + l1s.melody0_e2.error_id= copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1s.melody0_e2.buffer_size, + (UWORD8 **)&l1s.melody0_e2.ptr_buf, + 1, + (UWORD8 *)(&l1s.melody0_e2.counter)); + + // Save the extension flag + l1s.melody0_e2.extension_flag = Field(l1s.melody0_e2.counter, + SC_MELODY_E2_EXTENSION_FLAG_MASK, + SC_MELODY_E2_EXTENSION_FLAG_SHIFT); + + l1s.melody0_e2.counter = Field(l1s.melody0_e2.counter, + SC_MELODY_E2_DELTA_TIME_MASK, + SC_MELODY_E2_DELTA_TIME_SHIFT); + } // if ( (trash[0] != 0x00) || (trash[1] != 0x00) ) + else + { + // it's the end of the melody file + l1s.melody0_e2.end_of_file = TRUE; + } + } // while ( (l1s.melody0_e2.counter == 0) && (l1s.melody0_e2.end_of_file == FALSE) ) + + // Perform TDMA convertion or handle end of file + if (l1s.melody0_e2.end_of_file == FALSE) + { + // Update note start + l1s.melody0_e2.note_start_20ms += l1s.melody0_e2.counter; + + l1s.melody0_e2.delta_time = l1s.melody0_e2.counter; + + // Convert the delta time into TDMA time unit + l1s.melody0_e2.counter = audio_twentyms_to_TDMA_convertion(l1s.melody0_e2.note_start_20ms) + - l1s.melody_e2.timebase; + + // decrease the counter + l1s.melody0_e2.counter--; + + *state = M0_WAIT_COUNTER_EQUAL_0; + } + else + { + l1s.melody0_e2.delta_time = 0xFFFF; + *state = M0_WAIT_END_MELODY; + } + } // semaphore check + } // if (l1a_l1s_com.melody0_e2_task.command.stop) (2nd else) + } // case M0_WAIT_COUNTER_EQUAL_0: + break; + + case M0_WAIT_END_MELODY: + { + if (l1a_l1s_com.melody0_e2_task.command.stop) + { + // Stop immediatly the current melody + // Wait until the semaphore is set to 0 by the DSP to stop the current description + if (!(l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore & SC_MELODY_E2_SEMAPHORE_MASK)) + { + // Stop the oscillator mentionned in the bits field melody0_e2.oscillator_active + for(oscillator_number=0; oscillator_number<SC_MELODY_E2_NUMBER_OF_OSCILLATOR; oscillator_number++) + { + if (l1s.melody0_e2.oscillator_active & (0x0001<<oscillator_number)) + { + // Stop the current oscillator + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_osc_stop |= (0x0001<<oscillator_number); + } + } + // wait until all the oscillator are stopped + l1a_l1s_com.melody0_e2_task.parameters.loopback = FALSE; + l1a_l1s_com.melody0_e2_task.command.stop = FALSE; + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_deltatime = 0xFFFF;// another melody could be running + } // semaphore + } + else if (l1s.melody0_e2.oscillator_active == 0x0000) + { + // all oscillators are stopped + if (l1a_l1s_com.melody0_e2_task.parameters.loopback) + { + // It's the loopback mode + // Reset the pointer to the current melody + #if (OP_RIV_AUDIO == 0) + l1s.melody0_e2.ptr_buf = NULL; + #endif + l1s.melody0_e2.buffer_size = 0; + l1s.melody0_e2.error_id = Cust_get_pointer((UWORD16 **)&l1s.melody0_e2.ptr_buf, + &l1s.melody0_e2.buffer_size, + l1a_l1s_com.melody0_e2_task.parameters.session_id); + + // Jump the header field + l1s.melody0_e2.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1s.melody0_e2.buffer_size, + (UWORD8 **)&l1s.melody0_e2.ptr_buf, + (UWORD16)(l1a_l1s_com.melody0_e2_task.parameters.header_size), + &trash[0]); + + // Wait until the description can be downloaded + *state = M0_ALIGN_40MS_BOUNDARY; + } + else + { + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_MELODY0_E2_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + // Go to inactive mode + *state = M0_INACTIVE; + } + } + break; + } // M0_WAIT_END_MELODY + } // switch + } // l1s_melody0_e2_manager + + /*-------------------------------------------------------*/ + /* l1s_melody1_e2_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Audio melody 0 format E2 L1S manager */ + /* task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_melody1_e2_manager(void) + { + enum states + { + M1_INACTIVE = 0, + M1_ALIGN_40MS_BOUNDARY = 1, + M1_WAIT_COUNTER_EQUAL_0 = 2, + M1_WAIT_END_MELODY = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_MELODY1_E2_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 trash[SC_MELODY_E2_MAXIMUM_HEADER_SIZE+1], oscillator_number, extension_index; + UWORD16 oscillator_not_available; + + switch(*state) + { + case M1_INACTIVE: + { + // Reset the commands: + l1a_l1s_com.melody1_e2_task.command.start = FALSE; + + // Initialize the pointer and size to the new description + l1s.melody1_e2.ptr_buf = l1a_l1s_com.melody1_e2_task.parameters.ptr_buf; + l1s.melody1_e2.buffer_size = l1a_l1s_com.melody1_e2_task.parameters.buffer_size; + + *state = M1_ALIGN_40MS_BOUNDARY; + } + break; + + case M1_ALIGN_40MS_BOUNDARY: + { + // Initialize the counter to the first time + l1s.melody1_e2.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1s.melody1_e2.buffer_size, + (UWORD8 **)&l1s.melody1_e2.ptr_buf, + 1, + (UWORD8 *)(&l1s.melody1_e2.counter)); + + // Save the extension flag + l1s.melody1_e2.extension_flag = Field(l1s.melody1_e2.counter, + SC_MELODY_E2_EXTENSION_FLAG_MASK, + SC_MELODY_E2_EXTENSION_FLAG_SHIFT); + + // Save delta-time in 20ms unit + l1s.melody1_e2.counter = Field(l1s.melody1_e2.counter, + SC_MELODY_E2_DELTA_TIME_MASK, + SC_MELODY_E2_DELTA_TIME_SHIFT); + l1s.melody1_e2.note_start_20ms = l1s.melody1_e2.counter; + + // Adjust note_start on 20ms boundary because global counter could be running for another melody or loopback + // Timebase can be computed as k*60ms + timebase_mod_60ms + l1s.melody1_e2.note_start_20ms += ((l1s.melody_e2.timebase - l1s.melody_e2.timebase_mod_60ms) / 13 * 3); + if (l1s.melody_e2.timebase_mod_60ms < 4) + { + l1s.melody1_e2.note_start_20ms += 1; + } + else if (l1s.melody_e2.timebase_mod_60ms < 8) + { + l1s.melody1_e2.note_start_20ms += 2; + } + else if (l1s.melody_e2.timebase_mod_60ms < 13) + { + l1s.melody1_e2.note_start_20ms += 3; + } + + // Align on 40ms boundary + if ( (l1s.melody1_e2.note_start_20ms & 1) == 1 ) + l1s.melody1_e2.note_start_20ms++; + + // Convert to TDMA + l1s.melody1_e2.counter = audio_twentyms_to_TDMA_convertion(l1s.melody1_e2.note_start_20ms); + + // Compute TDMA to wait (-1 to take into account this TDMA) + l1s.melody1_e2.counter = l1s.melody1_e2.counter - l1s.melody_e2.timebase - 1; + + // Wait to download the first description + *state = M1_WAIT_COUNTER_EQUAL_0; + } // M1_INIT + break; + + case M1_WAIT_COUNTER_EQUAL_0: + { + // Stop command + if (l1a_l1s_com.melody1_e2_task.command.stop) + { + // wait until all the ocillator are stopped + *state = M1_WAIT_END_MELODY; + } + else if (l1s.melody1_e2.counter > 0) + { + // Decrease the counter + l1s.melody1_e2.counter--; + } + else + { + // Wait until the semaphore is set to 0 by the DSP + if (!(l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore & SC_MELODY_E2_SEMAPHORE_MASK)) + { + // Initialize oscillators available, oscillators can be used by the DSP (d_melody_e2_osc_active) + // or by the other melody E2 generator (melody_e2_osc_stop) + oscillator_not_available = + l1s.melody_e2.global_osc_active | l1s.melody_e2.global_osc_to_start; + + // find an available oscillator + oscillator_number = 0; + while( (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) && + (oscillator_not_available & (0x0001<<oscillator_number)) ) + { + oscillator_number++; + } + + // Initialize end of file + l1s.melody1_e2.end_of_file = FALSE; + + // download the description until the delta time is different from 0 + // or end of the melody file + while ( (l1s.melody1_e2.counter == 0) && + (l1s.melody1_e2.end_of_file == FALSE) ) + { + // Download the byte of the note descriptor extension in trash + l1s.melody1_e2.error_id= copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1s.melody1_e2.buffer_size, + (UWORD8 **)&l1s.melody1_e2.ptr_buf, + 2, + &trash[0]); + + // Check end of melody + if ( (trash[0] != 0x00) || (trash[1] != 0x00) ) + { + // It is not the end of melody + + // If an oscillator is available, use it + if (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) + { + // Reset the oscillator description + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][0] = 0x0000; + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][1] = 0x0000; + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][2] = 0x0000; + + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][0] = + trash[0] + (trash[1] << 8); + + // Update the oscillators to start bit field + l1s.melody_e2.global_osc_to_start |= (0x0001<<oscillator_number); + + // Save the oscillator as active for this melody + l1s.melody1_e2.oscillator_active |= (0x0001<<oscillator_number); + + // oscillator is no longer available + oscillator_not_available |= (0x0001<<oscillator_number); + } + + // Download the extensions + extension_index = 1; + while(l1s.melody1_e2.extension_flag) + { + // Download the byte of the note descriptor extension + l1s.melody1_e2.error_id= copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1s.melody1_e2.buffer_size, + (UWORD8 **)&l1s.melody1_e2.ptr_buf, + 2, + &trash[0]); + + // Read the extension flag + l1s.melody1_e2.extension_flag = Field(trash[0], + SC_MELODY_E2_EXTENSION_FLAG_MASK, + SC_MELODY_E2_EXTENSION_FLAG_SHIFT); + + // If an oscillator is available, use it + if (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) + { + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][extension_index] = + trash[0] + (trash[1] << 8); + } + + extension_index++; + } // extension download + + // find next available oscillator + while( (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) && + (oscillator_not_available & (0x0001<<oscillator_number)) ) + { + oscillator_number++; + } + + // Read next delta time + l1s.melody1_e2.error_id= copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1s.melody1_e2.buffer_size, + (UWORD8 **)&l1s.melody1_e2.ptr_buf, + 1, + (UWORD8 *)(&l1s.melody1_e2.counter)); + + // Save the extension flag + l1s.melody1_e2.extension_flag = Field(l1s.melody1_e2.counter, + SC_MELODY_E2_EXTENSION_FLAG_MASK, + SC_MELODY_E2_EXTENSION_FLAG_SHIFT); + + l1s.melody1_e2.counter = Field(l1s.melody1_e2.counter, + SC_MELODY_E2_DELTA_TIME_MASK, + SC_MELODY_E2_DELTA_TIME_SHIFT); + } // if ( (trash[0] != 0x00) || (trash[1] != 0x00) ) + else + { + // it's the end of the melody file + l1s.melody1_e2.end_of_file = TRUE; + } + } // while ( (l1s.melody1_e2.counter == 0) && (l1s.melody1_e2.end_of_file == FALSE) ) + + // Perform TDMA convertion or handle end of file + if (l1s.melody1_e2.end_of_file == FALSE) + { + // Update note start + l1s.melody1_e2.note_start_20ms += l1s.melody1_e2.counter; + + l1s.melody1_e2.delta_time = l1s.melody1_e2.counter; + + // Convert the delta time into TDMA time unit + l1s.melody1_e2.counter = audio_twentyms_to_TDMA_convertion(l1s.melody1_e2.note_start_20ms) + - l1s.melody_e2.timebase; + + // decrease the counter + l1s.melody1_e2.counter--; + + *state = M1_WAIT_COUNTER_EQUAL_0; + } + else + { + l1s.melody1_e2.delta_time = 0xFFFF; + *state = M1_WAIT_END_MELODY; + } + } // semaphore check + } // if (l1a_l1s_com.melody1_e2_task.command.stop) (2nd else) + } // case M1_WAIT_COUNTER_EQUAL_0: + break; + + case M1_WAIT_END_MELODY: + { + if (l1a_l1s_com.melody1_e2_task.command.stop) + { + // Stop immediatly the current melody + // Wait until the semaphore is set to 0 by the DSP to stop the current description + if (!(l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore & SC_MELODY_E2_SEMAPHORE_MASK)) + { + // Stop the oscillator mentionned in the bits field melody1_e2.oscillator_active + for(oscillator_number=0; oscillator_number<SC_MELODY_E2_NUMBER_OF_OSCILLATOR; oscillator_number++) + { + if (l1s.melody1_e2.oscillator_active & (0x0001<<oscillator_number)) + { + // Stop the current oscillator + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_osc_stop |= (0x0001<<oscillator_number); + } + } + // wait until all the oscillator are stopped + l1a_l1s_com.melody1_e2_task.parameters.loopback = FALSE; + l1a_l1s_com.melody1_e2_task.command.stop = FALSE; + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_deltatime = 0xFFFF; // another melody could be running + } // semaphore + } + else if (l1s.melody1_e2.oscillator_active == 0x0000) + { + // all oscillators are stopped + if (l1a_l1s_com.melody1_e2_task.parameters.loopback) + { + // It's the loopback mode + // Reset the pointer to the current melody + #if (OP_RIV_AUDIO == 0) + l1s.melody1_e2.ptr_buf = NULL; + #endif + l1s.melody1_e2.buffer_size = 0; + l1s.melody1_e2.error_id = Cust_get_pointer((UWORD16 **)&l1s.melody1_e2.ptr_buf, + &l1s.melody1_e2.buffer_size, + l1a_l1s_com.melody1_e2_task.parameters.session_id); + + // Jump the header field + l1s.melody1_e2.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1s.melody1_e2.buffer_size, + (UWORD8 **)&l1s.melody1_e2.ptr_buf, + (UWORD16)(l1a_l1s_com.melody1_e2_task.parameters.header_size), + &trash[0]); + + // Wait until the description can be downloaded + *state = M1_ALIGN_40MS_BOUNDARY; + } + else + { + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_MELODY1_E2_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + // Go to inactive mode + *state = M1_INACTIVE; + } + } + break; + } // M1_WAIT_END_MELODY + } // switch + } // l1s_melody1_e2_manager + + #endif // MELODY_E2 + + #if (L1_CPORT == 1) + /*-------------------------------------------------------*/ + /* l1s_cport_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Cport L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_cport_manager(void) + { + enum states + { + IDLE = 0, + WAIT_CPORT_CONF = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_CPORT_STATE]; + xSignalHeaderRec *conf_msg; + API temp_write_var; + + switch(*state) + { + case IDLE: + { + // Check if a cport configuration is not yet in progress in DSP + if (l1s_dsp_com.dsp_ndb_ptr->d_cport_status == (API) (CPORT_R_NONE | CPORT_W_NONE)) + { + // ok, we can start the DSP Cport configuration task + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CTRL) + l1s_dsp_com.dsp_ndb_ptr->d_cport_ctrl = l1a_l1s_com.cport_task.parameters.ctrl; + + if (l1a_l1s_com.cport_task.parameters.configuration & (CPORT_W_CPCFR1 | CPORT_W_CPCFR2)) + { + temp_write_var = 0; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPCFR1) + temp_write_var = l1a_l1s_com.cport_task.parameters.cpcfr1 << 8; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPCFR2) + temp_write_var |= l1a_l1s_com.cport_task.parameters.cpcfr2; + + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[0] = temp_write_var; + } + + + if (l1a_l1s_com.cport_task.parameters.configuration & (CPORT_W_CPCFR3 | CPORT_W_CPCFR4)) + { + temp_write_var = 0; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPCFR3) + temp_write_var = l1a_l1s_com.cport_task.parameters.cpcfr3 << 8; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPCFR4) + temp_write_var |= l1a_l1s_com.cport_task.parameters.cpcfr4; + + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[1] = temp_write_var; + } + + + if (l1a_l1s_com.cport_task.parameters.configuration & (CPORT_W_CPTCTL | CPORT_W_CPTTADDR)) + { + temp_write_var = 0; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPTCTL) + temp_write_var = l1a_l1s_com.cport_task.parameters.cptctl << 8; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPTTADDR) + temp_write_var |= l1a_l1s_com.cport_task.parameters.cpttaddr; + + l1s_dsp_com.dsp_ndb_ptr->d_cport_tcl_tadt = temp_write_var; + } + + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPTDAT) + l1s_dsp_com.dsp_ndb_ptr->d_cport_tdat = l1a_l1s_com.cport_task.parameters.cptdat; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPTVS) + l1s_dsp_com.dsp_ndb_ptr->d_cport_tvs = l1a_l1s_com.cport_task.parameters.cptvs; + + l1s_dsp_com.dsp_ndb_ptr->d_cport_init = l1a_l1s_com.cport_task.parameters.configuration; + + *state = WAIT_CPORT_CONF; + + // Reset the command + l1a_l1s_com.cport_task.command.start = FALSE; + + } + + // else, we do nothing -> check will be done again at next frame + } + break; + + case WAIT_CPORT_CONF: + { + // the DSP acknowledges the L1S start request. + if (l1s_dsp_com.dsp_ndb_ptr->d_cport_init + == l1s_dsp_com.dsp_ndb_ptr->d_cport_status) + { + // task is over + l1s_dsp_com.dsp_ndb_ptr->d_cport_init = (API) (CPORT_R_NONE | CPORT_W_NONE); + l1s_dsp_com.dsp_ndb_ptr->d_cport_ctrl = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[0] = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[1] = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_tcl_tadt = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_tdat = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_tvs = (API) 0; + + // Send the configuration confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_CPORT_CONFIGURE_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_CPORT_CONFIGURE_CON; + + //Fill the message + ((T_L1_CPORT_CONFIGURE_CON *)(conf_msg->SigP))->register_id = (l1s_dsp_com.dsp_ndb_ptr->d_cport_status & CPORT_READ_MASK); + ((T_L1_CPORT_CONFIGURE_CON *)(conf_msg->SigP))->register_value = l1s_dsp_com.dsp_ndb_ptr->d_cport_reg_value; + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + + } // switch + } + #endif // L1_CPORT == 1 + + #if 0 /* FreeCalypso: function not present in TCS211 */ + /*-------------------------------------------------------*/ + /* l1s_audio_it_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Audio it manager */ + /* */ + /*-------------------------------------------------------*/ + void l1s_audio_it_manager(void) + { + // Reset the command : + l1a_l1s_com.audioIt_task.command.start = FALSE; + + // this is an empty state machin only used to generate an + // audio IT to DSP in case another sw entity has changed + // something in the API + } + #endif + + #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1) + /*-------------------------------------------------------*/ + /* l1s_audio_onoff_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : audio on/off L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_audio_onoff_manager(void) + { + enum states + { + IDLE = 0, + WAIT_AUDIO_ONOFF_CON = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_AUDIO_ONOFF_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Disable the start command + l1a_l1s_com.audio_onoff_task.command.start = FALSE; + + // Update the audio on/off value except if the L1S is already forcing it + if ((l1a_l1s_com.audio_onoff_task.parameters.onoff_value == TRUE) && + (l1a_l1s_com.audio_forced_by_l1s == FALSE)) + // l1a_l1s_com.audio_onoff_task.parameters.onoff_value == AUDIO_ON + { + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (API) B_AUDIO_ON_START; + } + else if ((l1a_l1s_com.audio_onoff_task.parameters.onoff_value == FALSE) && + (l1a_l1s_com.audio_forced_by_l1s == FALSE)) + // l1a_l1s_com.audio_onoff_task.parameters.onoff_value == AUDIO_OFF + { + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (API) B_AUDIO_OFF_STOP; + } + + *state = WAIT_AUDIO_ONOFF_CON; + } + break; + + case WAIT_AUDIO_ONOFF_CON: + { + // The L1 has to send the confirmation message even if the request was to disable the audio on/off + // and it is still forced. This confirmation message is only to acknowledge the reception of the message, + // it is not correlated to the state of the audio into the DSP. + + // Allocate memory for confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AUDIO_ONOFF_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + break; + + } // switch + } + #endif + + #if (L1_EXT_MCU_AUDIO_VOICE_ONOFF == 1) + /*-------------------------------------------------------*/ + /* l1s_audio_onoff_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : audio on/off L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_audio_voice_onoff_manager(void) + { + enum states + { + IDLE = 0, + WAIT_AUDIO_ONOFF_CON = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_AUDIO_ONOFF_STATE]; + UWORD8 *ul_state = &l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE]; + UWORD8 *dl_state = &l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE]; + UWORD8 *vul_state = &l1a_l1s_com.audio_onoff_task.parameters.vul_onoff_value; + UWORD8 *vdl_state = &l1a_l1s_com.audio_onoff_task.parameters.vdl_onoff_value; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Disable the start command + l1a_l1s_com.audio_onoff_task.command.start = FALSE; + + // Update the Voice Uplink count + if(l1a_l1s_com.audio_onoff_task.parameters.vul_onoff_value == L1_AUDIO_VOICE_UL_ON) + { + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request++; + } + else if(l1a_l1s_com.audio_onoff_task.parameters.vul_onoff_value == L1_AUDIO_VOICE_UL_OFF ) + { + if(l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request--; + } + + // Update the Voice Downlink count + if(l1a_l1s_com.audio_onoff_task.parameters.vdl_onoff_value == L1_AUDIO_VOICE_DL_ON) + { + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + } + else if(l1a_l1s_com.audio_onoff_task.parameters.vdl_onoff_value == L1_AUDIO_VOICE_DL_OFF) + { + if(l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; + } + + *state = WAIT_AUDIO_ONOFF_CON; + } + break; + + case WAIT_AUDIO_ONOFF_CON: + { + // For Voice Uplink or Downlink switch on is done only after the VUL or VDL is actually switched ON + // For switch off there could be potentially other tasks that use the VUL or VDL and hence a blind + // confirmation is given + if( (((*vul_state == L1_AUDIO_VOICE_UL_ON) && (*ul_state == L1_AUDIO_UL_ON)) || + (*vul_state == L1_AUDIO_VOICE_UL_OFF) || (*vul_state == L1_AUDIO_VOICE_UL_NO_ACTION)) && + (((*vdl_state == L1_AUDIO_VOICE_DL_ON) && (*dl_state == L1_AUDIO_DL_ON)) || + (*vdl_state == L1_AUDIO_VOICE_DL_OFF) || (*vdl_state == L1_AUDIO_VOICE_DL_NO_ACTION))) + { + // The L1 has to send the confirmation message even if the request was to disable the audio on/off + // and it is still forced. This confirmation message is only to acknowledge the reception of the message, + // it is not correlated to the state of the audio into the DSP. + + // Allocate memory for confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AUDIO_ONOFF_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + + } // switch + } + #endif + + #if (L1_STEREOPATH == 1) + /*-------------------------------------------------------*/ + /* l1s_stereopath_drv_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Generic Stereopath L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ +#if (CODE_VERSION == SIMULATION) + void l1s_stereopath_drv_manager(void) + { + enum states + { + IDLE=0, + WAIT_STOP + }; + + xSignalHeaderRec *conf_msg; + + if(l1a_l1s_com.stereopath_drv_task.command.start==TRUE) + { + // reset the command + l1a_l1s_com.stereopath_drv_task.command.start=FALSE; + + // change state + l1s.audio_state[L1S_STEREOPATH_DRV_STATE]=WAIT_STOP; + + // send confirmation to the L1A + conf_msg=os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode=L1_STEREOPATH_DRV_START_CON; + os_send_sig(conf_msg,L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + + if(l1a_l1s_com.stereopath_drv_task.command.stop==TRUE) + { + // reset the command + l1a_l1s_com.stereopath_drv_task.command.stop=FALSE; + + // change state + l1s.audio_state[L1S_STEREOPATH_DRV_STATE]=IDLE; + + // send confirmation to the L1A + conf_msg=os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode=L1_STEREOPATH_DRV_STOP_CON; + os_send_sig(conf_msg,L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } +#else // CODE_VERSION + void l1s_stereopath_drv_manager(void) + { + //sundi: change in the enum values for the ABB states +#if (ANLG_FAM == 11) + enum states + { + IDLE = 0, + ABB_CONFIGURE_DONE = 1, + ABB_START = 2, + ABB_START_DONE = 3, + DMA_CONF = 4, + CPORT_CONF = 5, + CPORT_START = 6, + WAIT_STOP = 7, + CPORT_STOP = 8, + ABB_STOP_DONE = 9, + DMA_STOP = 10, + STOP_CON = 11 + }; +#else + enum states + { + IDLE = 0, + ABB_START = 1, + DMA_CONF = 2, + CPORT_CONF = 3, + CPORT_START = 4, + WAIT_STOP = 5, + CPORT_STOP = 6, + DMA_STOP = 7, + STOP_CON = 8 + }; +#endif + + UWORD8 *state = &l1s.audio_state[L1S_STEREOPATH_DRV_STATE]; + xSignalHeaderRec *conf_msg; + static UWORD16 wait_pll_on_counter = L1S_STEREOPATH_DRV_WAIT_PLL_COUNTER; + + // This is the default parameters structure for a DMA channel + static T_DMA_TYPE_CHANNEL_PARAMETER d_dma_channel_parameter= + { + f_dma_default_call_back_it, // call back function + C_DMA_CHANNEL_2, // channel number + C_DMA_CHANNEL_NOT_SECURED, // channel security + C_DMA_DATA_S16, // data type + C_DMA_IMIF_PORT, // source port + C_DMA_CHANNEL_NOT_PACKED, // source packing + C_DMA_CHANNEL_SINGLE, // source bursting + C_DMA_RHEA_PORT, // destination port + C_DMA_CHANNEL_NOT_PACKED, // destination packing + C_DMA_CHANNEL_SINGLE, // destination bursting + C_DMA_CHANNEL_CPORT_TX, // hw synchro + C_DMA_CHANNEL_PRIORITY_HIGH, // channel priority + C_DMA_CHANNEL_AUTO_INIT_ON, // autoinit option + C_DMA_CHANNEL_FIFO_FLUSH_OFF, // fifo flush option + C_DMA_CHANNEL_ADDR_MODE_POST_INC, // source addressing mode + C_DMA_CHANNEL_ADDR_MODE_CONSTANT, // destination addressing mode + C_DMA_CHANNEL_IT_TIME_OUT_ON, // IT time out control + C_DMA_CHANNEL_IT_DROP_ON, // IT drop control + C_DMA_CHANNEL_IT_FRAME_OFF, // IT frame control + C_DMA_CHANNEL_IT_BLOCK_ON, // IT block control + C_DMA_CHANNEL_IT_HALF_BLOCK_ON, // IT half_block control + 0, // source start address + 0xFFFFD800L, // destination start address + 2, // element number + 0 // frame number + }; + + switch(*state) + { + case IDLE: + { +#if (ANLG_FAM == 11) + //Sundi:Set the abb_write_done variable to 0. This variable gets set in I2C call back fn. + l1s.abb_write_done = 0; +#endif + // Configure the ABB audio part in order to get the correct clock for the Cport + l1s_stereopath_drv_config_ABB(l1a_l1s_com.stereopath_drv_task.parameters.mono_stereo, + l1a_l1s_com.stereopath_drv_task.parameters.sampling_frequency); + +#if (ANLG_FAM == 11) + // Must wait for the PLL to be locked. The value of 1 is subtracted from the standard value + // in order to take care of the extra state added - ABB_CONFIGURE_DONE. + wait_pll_on_counter = L1S_STEREOPATH_DRV_WAIT_PLL_COUNTER - 1; +#else + // Must wait for the PLL to be locked. + wait_pll_on_counter = L1S_STEREOPATH_DRV_WAIT_PLL_COUNTER; + +#endif + + // Reset the command + l1a_l1s_com.stereopath_drv_task.command.start = FALSE; +#if (ANLG_FAM == 11) + //sundi: change the state to ABB_CONFIGURE_DONE to wait for I2C write ACK. + *state = ABB_CONFIGURE_DONE; + +#else + *state = ABB_START; +#endif + } + break; +#if (ANLG_FAM == 11) + //sundi: add the new state + case ABB_CONFIGURE_DONE: + { + //sundi: continue to be in this state till an I2C write ACK comes. + //abb_write_done is set to 1 by the call back function + //that is passed to the I2C write function. + if (l1s.abb_write_done == 1) + { + *state = ABB_START; + + } + } + break; +#endif + case ABB_START: + { + if (wait_pll_on_counter == 0) + { +#if (ANLG_FAM == 11) + //Sundi:Set the abb_write_done variable to 0. This variable gets set in I2C call back fn. + l1s.abb_write_done = 0; +#endif + // PLL is locked, the ABB can be started + l1s_stereopath_drv_start_ABB(); +#if (ANLG_FAM == 11) + //sundi: Change state to ABB_START_DONE + *state = ABB_START_DONE; +#else + *state = DMA_CONF; +#endif + } + else + wait_pll_on_counter--; + } + break; +#if (ANLG_FAM == 11) + //sundi: Add the new state ABB_START_DONE + case ABB_START_DONE: + { + //sundi: continue to be in this state till an I2C write ACK comes. + //abb_write_done is set to 1 by the call back function + //that is passed to the I2C write function. + if (l1s.abb_write_done == 1) + { + *state = DMA_CONF; + + } + } + break; +#endif + // After 1 TDMA frame, DSP has necessarily programmed ABB + case DMA_CONF: + { + // update the DMA defaut parameters structure with received parameters + d_dma_channel_parameter.pf_dma_call_back_address = (T_DMA_CALL_BACK) l1a_l1s_com.stereopath_drv_task.parameters.DMA_int_callback_fct; + d_dma_channel_parameter.d_dma_channel_number = (T_DMA_TYPE_CHANNEL_NUMBER) l1a_l1s_com.stereopath_drv_task.parameters.DMA_channel_number; + d_dma_channel_parameter.d_dma_channel_data_type = (T_DMA_TYPE_CHANNEL_DATA_TYPE) l1a_l1s_com.stereopath_drv_task.parameters.data_type; + d_dma_channel_parameter.d_dma_channel_src_port = (T_DMA_TYPE_CHANNEL_PORT) l1a_l1s_com.stereopath_drv_task.parameters.source_port; + d_dma_channel_parameter.d_dma_channel_src_address = (SYS_UWORD32) l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address; + d_dma_channel_parameter.d_dma_channel_element_number = (SYS_UWORD16) l1a_l1s_com.stereopath_drv_task.parameters.element_number; + d_dma_channel_parameter.d_dma_channel_frame_number = (SYS_UWORD16) l1a_l1s_com.stereopath_drv_task.parameters.frame_number; + + // Configure and start the DMA channel + l1s_stereopath_drv_start_DMA(d_dma_channel_parameter,l1a_l1s_com.stereopath_drv_task.parameters.DMA_allocation); + + // Reset the Cport + l1s_stereopath_drv_reset_CPORT(); + + *state = CPORT_CONF; + + } + break; + + case CPORT_CONF: + { + // Configure the Cport + l1s_stereopath_drv_config_CPORT(); + + *state = CPORT_START; + + } + break; + + case CPORT_START: + { + // Start the Cport + l1s_stereopath_drv_start_CPORT(); + + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_STEREOPATH_DRV_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_STOP; + } + break; + + case WAIT_STOP: + { + /* OUTEN registers have been updated */ + if(l1a_l1s_com.outen_cfg_task.command_requested != l1a_l1s_com.outen_cfg_task.command_commited) + { + l1s_stereopath_callback(L1S_TWL3029_STEROPATH_START); + } + if (l1a_l1s_com.stereopath_drv_task.command.stop) + { + // Stop command received + + // Reset the Cport + l1s_stereopath_drv_reset_CPORT(); + + *state = CPORT_STOP; + + // Disable the stop command + l1a_l1s_com.stereopath_drv_task.command.stop = FALSE; + } + } + break; + + case CPORT_STOP: + { + // Stop the Cport + l1s_stereopath_drv_stop_CPORT(); +#if (ANLG_FAM == 11) + //Set the abb_write_done variable to 0. This variable gets set in I2C call back fn. + l1s.abb_write_done = 0; +#endif + // Stop the ABB + l1s_stereopath_drv_stop_ABB(); +#if (ANLG_FAM == 11) + //sundi: change state to ABB_STOP_DONE + *state = ABB_STOP_DONE; +#else + *state = DMA_STOP; +#endif + } + break; +#if (ANLG_FAM == 11) + //sundi: Add a new state ABB_STOP_DONE + case ABB_STOP_DONE: + { + //sundi:continue to be in this state till an I2C write ACK comes. + //abb_write_done is set to 1 by the call back function + //that is passed to the I2C write function. + if (l1s.abb_write_done == 1) + { + *state = DMA_STOP; + } + } + break; +#endif + case DMA_STOP: + { + // Reset the DMA channel + l1s_stereopath_drv_reset_DMA(d_dma_channel_parameter); + + *state = STOP_CON; + } + break; + + case STOP_CON: + { + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_STEREOPATH_DRV_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR); + + *state = IDLE; + } + break; + + } // switch + } +#endif // CODE_VERSION + #endif // L1_STEREOPATH == 1 + + #if (L1_ANR == 1) + /*-------------------------------------------------------*/ + /* l1s_anr_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : ANR L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_anr_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_ANR_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.anr_task.parameters.anr_enable) + { + // ANR start requested + //-------------------- + + // Set ANR parameters + l1s_dsp_com.dsp_ndb_ptr->d_anr_min_gain = l1a_l1s_com.anr_task.parameters.min_gain; + l1s_dsp_com.dsp_ndb_ptr->d_anr_div_factor_shift = l1a_l1s_com.anr_task.parameters.div_factor_shift; + l1s_dsp_com.dsp_ndb_ptr->d_anr_ns_level = l1a_l1s_com.anr_task.parameters.ns_level; +#if (DSP == 38) || (DSP == 39) + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ANR_UL_STATE) +#else + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ANR_STATE) +#endif + { + // ANR already started: update the DSP ANR module + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = B_ANR_FULL_UPDATE; + + *state = WAIT_DSP_ACK; + } + else + { + // Set ANR constants + l1s_dsp_com.dsp_ndb_ptr->d_anr_vad_thr = C_ANR_VAD_THR; + l1s_dsp_com.dsp_ndb_ptr->d_anr_gamma_slow = C_ANR_GAMMA_SLOW; + l1s_dsp_com.dsp_ndb_ptr->d_anr_gamma_fast = C_ANR_GAMMA_FAST; + l1s_dsp_com.dsp_ndb_ptr->d_anr_gamma_gain_slow = C_ANR_GAMMA_GAIN_SLOW; + l1s_dsp_com.dsp_ndb_ptr->d_anr_gamma_gain_fast = C_ANR_GAMMA_GAIN_FAST; + l1s_dsp_com.dsp_ndb_ptr->d_anr_thr2 = C_ANR_THR2; + l1s_dsp_com.dsp_ndb_ptr->d_anr_thr4 = C_ANR_THR4; + l1s_dsp_com.dsp_ndb_ptr->d_anr_thr5 = C_ANR_THR5; + l1s_dsp_com.dsp_ndb_ptr->d_anr_mean_ratio_thr1 = C_ANR_MEAN_RATIO_THR1; + l1s_dsp_com.dsp_ndb_ptr->d_anr_mean_ratio_thr2 = C_ANR_MEAN_RATIO_THR2; + l1s_dsp_com.dsp_ndb_ptr->d_anr_mean_ratio_thr3 = C_ANR_MEAN_RATIO_THR3; + l1s_dsp_com.dsp_ndb_ptr->d_anr_mean_ratio_thr4 = C_ANR_MEAN_RATIO_THR4; + + // Enable the DSP ANR module + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = B_ANR_ENABLE; + + *state = WAIT_DSP_ACK; + } + } + else // ANR start requested + { + // ANR stop requested + //------------------- +#if (DSP == 38) || (DSP == 39) + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ANR_UL_STATE) +#else + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ANR_STATE) +#endif + { + // Disable the DSP ANR module + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = B_ANR_DISABLE; + + *state = WAIT_DSP_ACK; + } + else + { + // ANR already disabled: confirm + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_ANR_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.anr_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_ANR_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_ANR == 1 + + #if (L1_ANR == 2) + /*-------------------------------------------------------*/ + /* l1s_anr_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : ANR 2.13 L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_anr_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_ANR_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.anr_task.parameters.anr_ul_control == ANR_START || + l1a_l1s_com.anr_task.parameters.anr_ul_control == ANR_UPDATE ) + { + // ANR start or update requested + //------------------------------ + + // Set ANR parameters + l1s_dsp_com.dsp_ndb_ptr->d_anr_control = l1a_l1s_com.anr_task.parameters.control; + l1s_dsp_com.dsp_ndb_ptr->d_anr_ns_level = l1a_l1s_com.anr_task.parameters.ns_level; + l1s_dsp_com.dsp_ndb_ptr->d_anr_tone_ene_th = l1a_l1s_com.anr_task.parameters.tone_ene_th; + l1s_dsp_com.dsp_ndb_ptr->d_anr_tone_cnt_th = l1a_l1s_com.anr_task.parameters.tone_cnt_th; + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ANR_UL_STATE) + { + // ANR already started: update the DSP ANR module + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = B_ANR_FULL_UPDATE; + l1s.anr_ul_action = ANR_UPDATED; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP ANR module + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = B_ANR_ENABLE; + l1s.anr_ul_action = ANR_STARTED; + + *state = WAIT_DSP_ACK; + } + } + + + if (l1a_l1s_com.anr_task.parameters.anr_ul_control == ANR_STOP) + { + // ANR stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ANR_UL_STATE) + { + // Disable the DSP ANR module + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = B_ANR_DISABLE; + l1s.anr_ul_action = ANR_STOPPED; + + *state = WAIT_DSP_ACK; + } + else + { + // ANR already disabled: confirm + // Allocate confirmation message... + l1s.anr_ul_action = ANR_NO_ACTION; + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_ANR_CON; + ((T_L1_AQI_ANR_CON *)(conf_msg->SigP))->anr_ul_action = l1s.anr_ul_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.anr_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_ANR_CON; + ((T_L1_AQI_ANR_CON *)(conf_msg->SigP))->anr_ul_action = l1s.anr_ul_action; + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_ANR == 2 + + #if (L1_IIR == 1) + /*-------------------------------------------------------*/ + /* l1s_iir_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : IIR L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_iir_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_IIR_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.iir_task.parameters.iir_enable) + { + UWORD8 i; + + // IIR start requested + //-------------------- + + // Set IIR parameters + l1s_dsp_com.dsp_ndb_ptr->d_iir_nb_iir_blocks = l1a_l1s_com.iir_task.parameters.nb_iir_blocks; + + for (i=0; i < (l1a_l1s_com.iir_task.parameters.nb_iir_blocks * 8); i++) + l1s_dsp_com.dsp_ndb_ptr->a_iir_iir_coefs[i] = l1a_l1s_com.iir_task.parameters.iir_coefs[i]; + + l1s_dsp_com.dsp_ndb_ptr->d_iir_nb_fir_coefs = l1a_l1s_com.iir_task.parameters.nb_fir_coefs; + + for (i=0; i < l1a_l1s_com.iir_task.parameters.nb_fir_coefs; i++) + l1s_dsp_com.dsp_ndb_ptr->a_iir_fir_coefs[i] = l1a_l1s_com.iir_task.parameters.fir_coefs[i]; + + l1s_dsp_com.dsp_ndb_ptr->d_iir_input_scaling = l1a_l1s_com.iir_task.parameters.input_scaling; + l1s_dsp_com.dsp_ndb_ptr->d_iir_fir_scaling = l1a_l1s_com.iir_task.parameters.fir_scaling; + l1s_dsp_com.dsp_ndb_ptr->d_iir_input_gain_scaling = l1a_l1s_com.iir_task.parameters.input_gain_scaling; + l1s_dsp_com.dsp_ndb_ptr->d_iir_output_gain_scaling = l1a_l1s_com.iir_task.parameters.output_gain_scaling; + l1s_dsp_com.dsp_ndb_ptr->d_iir_output_gain = l1a_l1s_com.iir_task.parameters.output_gain; + l1s_dsp_com.dsp_ndb_ptr->d_iir_feedback = l1a_l1s_com.iir_task.parameters.feedback; + +#if (DSP == 38) || (DSP == 39) + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_IIR_DL_STATE) +#else + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_IIR_STATE) +#endif + { + // IIR already started: update the DSP IIR module + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_FULL_UPDATE; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP IIR module + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_ENABLE; + + *state = WAIT_DSP_ACK; + } + } + else // IIR start requested + { + // IIR stop requested + //------------------- +#if (DSP == 38) || (DSP == 39) + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_IIR_DL_STATE) +#else + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_IIR_STATE) +#endif + { + // Disable the DSP IIR module + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_DISABLE; + + *state = WAIT_DSP_ACK; + } + else + { + // IIR already disabled: confirm + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_IIR_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.iir_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_IIR_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_IIR == 1 + + #if (L1_AGC_UL == 1) + /*-------------------------------------------------------*/ + /* l1s_agc_ul_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : AGC_UL L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_agc_ul_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_AGC_UL_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.agc_ul_task.parameters.agc_ul_control == AGC_START || + l1a_l1s_com.agc_ul_task.parameters.agc_ul_control == AGC_UPDATE) + { + // AGC_UL start or update requested + //--------------------------------- + + // Set AGC UL parameters + + l1_audio_agc_ul_copy_params(); + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_AGC_UL_STATE) + { + // AGC UL already started: update the DSP AGC UL module + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_ctrl = B_AGC_FULL_UPDATE; + l1s.agc_ul_action = AGC_UPDATED; + + *state = WAIT_DSP_ACK; + } + else + { + + // Enable the DSP AGC UL module + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_ctrl = B_AGC_ENABLE; + l1s.agc_ul_action = AGC_STARTED; + + *state = WAIT_DSP_ACK; + } + } + + if (l1a_l1s_com.agc_ul_task.parameters.agc_ul_control == AGC_STOP) + { + // AGC UL stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_AGC_UL_STATE) + { + // Disable the DSP AGC UL module + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_ctrl = B_AGC_DISABLE; + l1s.agc_ul_action = AGC_STOPPED; + + *state = WAIT_DSP_ACK; + } + else + { + // AGC UL already disabled: confirm + // Allocate confirmation message... + l1s.agc_ul_action = AGC_NO_ACTION; + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_AGC_UL_CON; + ((T_L1_AQI_AGC_UL_CON *)(conf_msg->SigP))->agc_ul_action = l1s.agc_ul_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.agc_ul_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_AGC_UL_CON; + ((T_L1_AQI_AGC_UL_CON *)(conf_msg->SigP))->agc_ul_action = l1s.agc_ul_action; + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_AGC_UL == 1 + + + #if (L1_AGC_DL == 1) + /*-------------------------------------------------------*/ + /* l1s_agc_dl_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : AGC DL L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_agc_dl_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_AGC_DL_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.agc_dl_task.parameters.agc_dl_control == AGC_START || + l1a_l1s_com.agc_dl_task.parameters.agc_dl_control == AGC_UPDATE) + { + // AGC DL start or update requested + //--------------------------------- + + // Set AGC DL parameters + + l1_audio_agc_dl_copy_params(); + + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_AGC_DL_STATE) + { + // AGC DL already started: update the DSP AGC DL module + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_ctrl = B_AGC_FULL_UPDATE; + l1s.agc_dl_action = AGC_UPDATED; + + *state = WAIT_DSP_ACK; + } + else + { + + // Enable the DSP AGC DL module + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_ctrl = B_AGC_ENABLE; + l1s.agc_dl_action = AGC_STARTED; + + *state = WAIT_DSP_ACK; + } + } + + if (l1a_l1s_com.agc_dl_task.parameters.agc_dl_control == AGC_STOP) + { + // AGC DL stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_AGC_DL_STATE) + { + // Disable the DSP AGC DL module + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_ctrl = B_AGC_DISABLE; + l1s.agc_dl_action = AGC_STOPPED; + + *state = WAIT_DSP_ACK; + } + else + { + // AGC DL already disabled: confirm + // Allocate confirmation message... + l1s.agc_dl_action = AGC_NO_ACTION; + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_AGC_DL_CON; + ((T_L1_AQI_AGC_DL_CON *)(conf_msg->SigP))->agc_dl_action = l1s.agc_dl_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.agc_dl_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_AGC_DL_CON; + ((T_L1_AQI_AGC_DL_CON *)(conf_msg->SigP))->agc_dl_action = l1s.agc_dl_action; + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_AGC_DL == 1 + +#if (L1_IIR == 2) + /*-------------------------------------------------------*/ + /* l1s_iir_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : IIR L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_iir_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_IIR_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.iir_task.parameters->iir_dl_control == IIR_START || + l1a_l1s_com.iir_task.parameters->iir_dl_control == IIR_UPDATE ) + { + // IIR start or update requested + //------------------------------ + + l1_audio_iir4x_copy_params(); + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_IIR_DL_STATE) + { + // IIR already started: update the DSP IIR module + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_FULL_UPDATE; + l1s.iir_dl_action = IIR_UPDATED; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP IIR module + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_ENABLE; + l1s.iir_dl_action = IIR_STARTED; + + *state = WAIT_DSP_ACK; + } + } + + if (l1a_l1s_com.iir_task.parameters->iir_dl_control == IIR_STOP) + { + // IIR stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_IIR_DL_STATE) + { + // Disable the DSP IIR module + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_DISABLE; + l1s.iir_dl_action = IIR_STOPPED; + + *state = WAIT_DSP_ACK; + } + else + { + // IIR already disabled: confirm + // Allocate confirmation message... + l1s.iir_dl_action = IIR_NO_ACTION; + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_IIR_DL_CON; + ((T_L1_AQI_IIR_DL_CON *)(conf_msg->SigP))->iir_dl_action = l1s.iir_dl_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.iir_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_IIR_DL_CON; + ((T_L1_AQI_IIR_DL_CON *)(conf_msg->SigP))->iir_dl_action = l1s.iir_dl_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_IIR == 2 + + #if (L1_WCM == 1) + /*-------------------------------------------------------*/ + /* l1s_wcm_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : WCM L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_wcm_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_WCM_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.wcm_task.parameters->wcm_control == WCM_START || + l1a_l1s_com.wcm_task.parameters->wcm_control == WCM_UPDATE ) + { + UWORD8 i; + + // WCM start or update requested + //------------------------------ + + l1s_dsp_com.dsp_ndb_ptr->d_wcm_mode = l1a_l1s_com.wcm_task.parameters->parameters.mode; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_frame_size = l1a_l1s_com.wcm_task.parameters->parameters.frame_size; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_num_sub_frames = l1a_l1s_com.wcm_task.parameters->parameters.num_sub_frames; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_ratio = l1a_l1s_com.wcm_task.parameters->parameters.ratio; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_threshold = l1a_l1s_com.wcm_task.parameters->parameters.threshold; + + for (i=0; i < (WCM_1X_GAIN_TABLE_LENGTH); i++) + { + l1s_dsp_com.dsp_ndb_ptr->a_wcm_gain[i] = l1a_l1s_com.wcm_task.parameters->parameters.gain[i]; + } + + if (l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_status & B_WCM_STATE) + { + // WCM already started: update the DSP WCM module + l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_ctrl = B_WCM_FULL_UPDATE; + l1s.wcm_action = WCM_UPDATED; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP WCM module + l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_ctrl = B_WCM_ENABLE; + l1s.wcm_action = WCM_STARTED; + + *state = WAIT_DSP_ACK; + } + } + + if (l1a_l1s_com.wcm_task.parameters->wcm_control == WCM_STOP) + { + // WCM stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_status & B_WCM_STATE) + { + // Disable the DSP WCM module + l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_ctrl = B_WCM_DISABLE; + l1s.wcm_action = WCM_STOPPED; + + *state = WAIT_DSP_ACK; + } + else + { + // WCM already disabled: confirm + // Allocate confirmation message... + l1s.wcm_action = WCM_NO_ACTION; + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_WCM_CON; + ((T_L1_AQI_WCM_CON *)(conf_msg->SigP))->wcm_action = l1s.wcm_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.wcm_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_WCM_CON; + ((T_L1_AQI_WCM_CON *)(conf_msg->SigP))->wcm_action = l1s.wcm_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_WCM == 2 + +#if (L1_DRC == 1) + /*-------------------------------------------------------*/ + /* l1s_drc_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : DRC L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_drc_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_DRC_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.drc_task.parameters->drc_dl_control == DRC_START || + l1a_l1s_com.drc_task.parameters->drc_dl_control == DRC_UPDATE) + { + // DRC start or update requested + //------------------------------ + + l1_audio_drc1x_copy_params(); + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_DRC_DL_STATE) + { + // DRC already started: update the DSP DRC module + l1s_dsp_com.dsp_ndb_ptr->d_drc_dl_ctrl = B_DRC_FULL_UPDATE; + l1s.drc_dl_action = DRC_UPDATED; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP DRC module + l1s_dsp_com.dsp_ndb_ptr->d_drc_dl_ctrl = B_DRC_ENABLE; + l1s.drc_dl_action = DRC_STARTED; + + *state = WAIT_DSP_ACK; + } + } + + if (l1a_l1s_com.drc_task.parameters->drc_dl_control == DRC_STOP) + { + // DRC stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_DRC_DL_STATE) + { + // Disable the DSP DRC module + l1s_dsp_com.dsp_ndb_ptr->d_drc_dl_ctrl = B_DRC_DISABLE; + l1s.drc_dl_action = DRC_STOPPED; + + *state = WAIT_DSP_ACK; + } + else + { + // DRC already disabled: confirm + // Allocate confirmation message... + l1s.drc_dl_action = DRC_NO_ACTION; + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_DRC_CON; + ((T_L1_AQI_DRC_CON *)(conf_msg->SigP))->drc_dl_action = l1s.drc_dl_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.drc_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_drc_dl_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_DRC_CON; + ((T_L1_AQI_DRC_CON *)(conf_msg->SigP))->drc_dl_action = l1s.drc_dl_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_DRC == 1 + + #if (L1_LIMITER == 1) + /*-------------------------------------------------------*/ + /* l1s_limiter_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : LIMITER L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_limiter_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1, + WAIT_PARTIAL_UPDATE = 2 + }; + + UWORD8 *state = &l1s.audio_state[L1S_LIMITER_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + /* LIMITER update command */ + /*------------------------*/ + + if (l1a_l1s_com.limiter_task.command.update) + { + if (l1a_l1s_com.limiter_task.parameters.limiter_enable) + { + UWORD8 i; + + // LIMITER start requested + //------------------------ + + // Set LIMITER parameters + l1s_dsp_com.dsp_ndb_ptr->d_lim_block_size = l1a_l1s_com.limiter_task.parameters.block_size; + l1s_dsp_com.dsp_ndb_ptr->d_lim_slope_update_period = l1a_l1s_com.limiter_task.parameters.slope_update_period; + l1s_dsp_com.dsp_ndb_ptr->d_lim_nb_fir_coefs = l1a_l1s_com.limiter_task.parameters.nb_fir_coefs; + + for (i=0; i < ((l1a_l1s_com.limiter_task.parameters.nb_fir_coefs - 1)>>1) + 1; i++) + l1s_dsp_com.dsp_ndb_ptr->a_lim_filter_coefs[i] = l1a_l1s_com.limiter_task.parameters.filter_coefs[i]; + + l1s_dsp_com.dsp_ndb_ptr->d_lim_gain_fall_q15 = l1a_l1s_com.limiter_task.parameters.gain_fall; + l1s_dsp_com.dsp_ndb_ptr->d_lim_gain_rise_q15 = l1a_l1s_com.limiter_task.parameters.gain_rise; + + // a_lim_mul_low/high computation and update + l1_audio_lim_update_mul_low_high(); + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_LIM_STATE) + { + // LIMITER already started: update the DSP LIMITER module + l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl = B_LIM_FULL_UPDATE; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP LIMITER module + l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl = B_LIM_ENABLE; + + *state = WAIT_DSP_ACK; + } + } + else // LIMITER start requested + { + // LIMITER stop requested + //----------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_LIM_STATE) + { + // Disable the DSP LIMITER module + l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl = B_LIM_DISABLE; + + *state = WAIT_DSP_ACK; + } + else + { + // LIMITER already disabled: confirm + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_LIMITER_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.limiter_task.command.update = FALSE; + } // LIMITER update + + /* LIMITER partial update command */ + /*--------------------------------*/ + + else if (l1a_l1s_com.limiter_task.command.partial_update) + { + // Only update if the module is enabled + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_LIM_STATE) + { + // a_lim_mul_low/high computation and update + l1_audio_lim_update_mul_low_high(); + + // Partial update of the DSP LIMITER module + l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl = B_LIM_UPDATE; + + *state = WAIT_PARTIAL_UPDATE; + } + + // Disable the partial update command + l1a_l1s_com.limiter_task.command.partial_update = FALSE; + } + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_LIMITER_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + + case WAIT_PARTIAL_UPDATE: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl == 0) + { + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_LIMITER == 1 + + #if (L1_ES == 1) + + /*******************************************/ + /* ES configuration tables */ + /*******************************************/ +#pragma DATA_SECTION(default_es_configs,".flashcnst"); +const T_ES_CONFIG default_es_configs[7] = + { + // Behavior 1 + { + (B_ES_UL | B_ES_DL | B_ES_NSF), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_12DB, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_1, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_3DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_15DB, C_ES_ATT_LIN_0DB} + } , + + // Behavior 1a + { + (B_ES_UL | B_ES_DL), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_12DB, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_1A, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_3DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_6DB, C_ES_ATT_LIN_0DB} + } , + + // Behavior 2a + { + (B_ES_UL | B_ES_DL | B_ES_NSF), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_12DB, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_2A, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_5DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_5DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_6DB, C_ES_ATT_LIN_24DB, C_ES_ATT_LIN_0DB} + } , + + // Behavior 2b + { + (B_ES_UL | B_ES_DL | B_ES_CNG), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_10DB, + C_ES_TCL_4DB, + C_ES_TCL_0DB, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_2B, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_8DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_8DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_9DB, C_ES_ATT_LIN_36DB, C_ES_ATT_LIN_0DB} + } , + + // Behavior 2c + { + (B_ES_UL | B_ES_DL | B_ES_CNG), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_M6DB, + C_ES_TCL_M23DB, + C_ES_TCL_0DB, + C_ES_TCL_M6DB, + C_ES_TCL_M3DB, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_2C, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_10DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_10DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_12DB, C_ES_ATT_LIN_48DB, C_ES_ATT_LIN_0DB} + } , + + // Behavior 2c_idle + { + (B_ES_UL | B_ES_DL | B_ES_CNG), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_M6DB, + C_ES_TCL_M23DB, + C_ES_TCL_0DB, + C_ES_TCL_M6DB, + C_ES_TCL_M3DB, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_2C_IDLE, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_10DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_10DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_12DB, C_ES_ATT_LIN_12DB, C_ES_ATT_LIN_48DB, C_ES_ATT_LIN_0DB} + } , + + // Behavior 3 + { + (B_ES_UL | B_ES_DL | B_ES_CNG), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_B3_FE_LS, + C_ES_TCL_B3_DT_LS, + C_ES_TCL_B3_FE_NS, + C_ES_TCL_B3_DT_NS, + C_ES_TCL_B3_NE, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_3, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_16DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_21DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_19DB, C_ES_ATT_LIN_19DB, C_ES_ATT_LIN_66DB, C_ES_ATT_LIN_0DB} + } + }; + + /*-------------------------------------------------------*/ + /* l1s_es_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : ES L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_es_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_ES_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.es_task.parameters.es_enable) + { + const T_ES_CONFIG *es_cfg; + + // ES start requested + //-------------------- + + // Set ES parameters + if (l1a_l1s_com.es_task.parameters.es_behavior == ES_CUSTOM_PARAM) + { + es_cfg = &(l1a_l1s_com.es_task.parameters.es_config); + } + else + { + es_cfg = &(default_es_configs[l1a_l1s_com.es_task.parameters.es_behavior]); + } + + // Set parameters in the API + l1s_dsp_com.dsp_ndb_ptr->d_es_mode = es_cfg->es_mode; + l1s_dsp_com.dsp_ndb_ptr->d_es_gain_dl = es_cfg->es_gain_dl; + l1s_dsp_com.dsp_ndb_ptr->d_es_gain_ul_1 = es_cfg->es_gain_ul_1; + l1s_dsp_com.dsp_ndb_ptr->d_es_gain_ul_2 = es_cfg->es_gain_ul_2; + l1s_dsp_com.dsp_ndb_ptr->d_es_tcl_fe_ls_thr = es_cfg->tcl_fe_ls_thr; + l1s_dsp_com.dsp_ndb_ptr->d_es_tcl_dt_ls_thr = es_cfg->tcl_dt_ls_thr; + l1s_dsp_com.dsp_ndb_ptr->d_es_tcl_fe_ns_thr = es_cfg->tcl_fe_ns_thr; + l1s_dsp_com.dsp_ndb_ptr->d_es_tcl_dt_ns_thr = es_cfg->tcl_dt_ns_thr; + l1s_dsp_com.dsp_ndb_ptr->d_es_tcl_ne_thr = es_cfg->tcl_ne_thr; + l1s_dsp_com.dsp_ndb_ptr->d_es_ref_ls_pwr = es_cfg->ref_ls_pwr; + l1s_dsp_com.dsp_ndb_ptr->d_es_switching_time = es_cfg->switching_time; + l1s_dsp_com.dsp_ndb_ptr->d_es_switching_time_dt = es_cfg->switching_time_dt; + l1s_dsp_com.dsp_ndb_ptr->d_es_hang_time = es_cfg->hang_time; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_dl_vect[0] = es_cfg->gain_lin_dl_vect[0]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_dl_vect[1] = es_cfg->gain_lin_dl_vect[1]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_dl_vect[2] = es_cfg->gain_lin_dl_vect[2]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_dl_vect[3] = es_cfg->gain_lin_dl_vect[3]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_ul_vect[0] = es_cfg->gain_lin_ul_vect[0]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_ul_vect[1] = es_cfg->gain_lin_ul_vect[1]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_ul_vect[2] = es_cfg->gain_lin_ul_vect[2]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_ul_vect[3] = es_cfg->gain_lin_ul_vect[3]; + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ES_STATE) + { + // ES already started: update the DSP ES module + l1s_dsp_com.dsp_ndb_ptr->d_es_ctrl = B_ES_FULL_UPDATE; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP ES module + l1s_dsp_com.dsp_ndb_ptr->d_es_ctrl = B_ES_ENABLE; + + *state = WAIT_DSP_ACK; + } + } + else // ES start requested + { + // ES stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ES_STATE) + { + // Disable the DSP ES module + l1s_dsp_com.dsp_ndb_ptr->d_es_ctrl = B_ES_DISABLE; + + *state = WAIT_DSP_ACK; + } + else + { + // ES already disabled: confirm + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_ES_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.es_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_es_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_ES_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_ES == 1 + +#endif // AUDIO_TASK
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/audio_cust0/l1audio_cust.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,2085 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_CUST.C + * + * Filename l1audio_cust.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ + +#include "l1_macro.h" +#include "l1_confg.h" + +#if (AUDIO_TASK == 1) + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + #include "tc_defs.h" + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + #include "l1audio_signa.h" + + #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 + + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + + #include "l1_time.h" + #include "l1_scen.h" + + #if L1_GPRS + #include "l1p_cons.h" + #include "l1p_msgt.h" + #include "l1p_deft.h" + #include "l1p_vare.h" + #include "l1p_tabs.h" + #include "l1p_macr.h" + #include "l1p_sign.h" + #endif + + #include "sim_cfg.h" + #include "sim_cons.h" + #include "sim_def.h" + #include "sim_var.h" + #include "sim_prot.h" + + #include "audio_sim_cons.h" + #include "audio_sim_def.h" + #include "mmi_simul.h" + #include "audio_sim_var.h" + + #else + // Layer1 and debug include files. + + #include <ctype.h> + #include <string.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + #include "l1audio_signa.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #include "l1_time.h" + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + #if (AUDIO_L1_STANDALONE) + #include "mmi_simul.h" + #endif + + #if (OP_RIV_AUDIO == 1) + #if (MELODY_E1) || (VOICE_MEMO) || (SPEECH_RECO) || (L1_EXT_AUDIO_MGT) || (MELODY_E2) + #include "rv_general.h" + #include "audio_api.h" + #include "audio_structs_i.h" + #include "audio_var_i.h" + #include "audio_ffs_i.h" + #include "audio_const_i.h" + #include "audio_error_hdlr_i.h" + #include "ffs/ffs_api.h" + #include "audio_macro_i.h" + #endif + #endif + + #endif + + #include "l1_trace.h" + //extern void L1_trace_string(char *s); + //extern void L1_trace_char (char s); + + /**************************************/ + /* Prototypes for L1 ASYNCH task */ + /**************************************/ + #if (SPEECH_RECO) + void Cust_srback_save_model (UWORD8 database, UWORD8 index, API *RAM_address); + void Cust_srback_save_speech (UWORD8 database, UWORD8 index, UWORD16 *start_buffer, UWORD16 *stop_buffer, UWORD16 *start_speech, UWORD16 *stop_speech); + void Cust_srback_load_model (UWORD8 database, UWORD8 index, API *RAM_address); + #endif + UWORD8 Cust_get_pointer (UWORD16 **ptr, UWORD16 *buffer_size, UWORD8 session_id); + + #if (L1_EXT_AUDIO_MGT) + void Cust_ext_audio_mgt_hisr(void); + #endif + void l1a_bt_audio_noti_process(void); + + /**************************************/ + /* External prototypes */ + /**************************************/ + #if (OP_RIV_AUDIO == 1) + #if (SPEECH_RECO) + extern void audio_sr_error_trace(UINT8 error_id); + #endif + #endif + + + /***************************************/ + /* Global variables for MP3 management */ + /***************************************/ + #if (L1_MP3 == 1) + UWORD8 mp3_tempbuf_idx; + UWORD16 Cust_get_pointer_mp3_last_buffer_size; + BOOL Cust_get_pointer_mp3_buffer_last; + #endif + + /***************************************/ + /* Global variables for AAC management */ + /***************************************/ + #if (L1_AAC == 1) + UWORD8 aac_tempbuf_idx; + UWORD16 Cust_get_pointer_aac_last_buffer_size; + BOOL Cust_get_pointer_aac_buffer_last; + #endif + + /* + * FreeCalypso TCS211 reconstruction: the following unused trivial + * function has been reconstruction in order to aid the diffing + * of the functions that follow. + */ + void audio_test_callback(void *buffer) + { + rvf_free_buf(buffer); + } + + #if (SPEECH_RECO) + /*-------------------------------------------------------*/ + /* Cust_srback_save_model() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : database */ + /* index */ + /* RAM_address */ + /* */ + /* Return : none */ + /* */ + /* Description : save the model into a database. */ + /* */ + /*-------------------------------------------------------*/ + void Cust_srback_save_model (UWORD8 database, UWORD8 index, API *RAM_address) + { + #if (AUDIO_SIMULATION) || (AUDIO_L1_STANDALONE) + UWORD16 model_size; + UWORD16 *ptr_dst; + UWORD8 frame_size; + + // initialize the pointer to the database + ptr_dst = sr_mmi_database[database][index].model; + + // look the size of the model in model frame unit (16 words unit) + model_size = *RAM_address++; + + // save the header of the model + *ptr_dst++ = model_size; + + while( (model_size != 0) && + (l1_srback_com.emergency_stop == FALSE) ) + { + frame_size = SC_SR_MODEL_FRAME_SIZE; + + while ( (frame_size != 0) && + (l1_srback_com.emergency_stop == FALSE) ) + { + *ptr_dst++ = *RAM_address++; + frame_size--; + } + + model_size--; + } + #endif + + #if (OP_RIV_AUDIO == 1) + T_FFS_FD ffs_fd; + UWORD16 model_size; + UWORD8 i; + char *p_model_path; + + if (p_audio_gbl_var->speech_reco.sr_enroll.state != AUDIO_SR_ENROLL_IDLE) + { + ffs_fd = p_audio_gbl_var->speech_reco.sr_enroll.sr_ffs_fd; + } + else + if (p_audio_gbl_var->speech_reco.sr_update.state != AUDIO_SR_UPDATE_IDLE) + { + /* reach the path of the corresponding model */ + p_model_path = p_audio_gbl_var->speech_reco.sr_update.p_database; + for (i=0; i<index; i++) + { + p_model_path += AUDIO_PATH_NAME_MAX_SIZE; + } + + ffs_fd = ffs_open(p_model_path, + FFS_O_CREATE | FFS_O_WRONLY | FFS_O_TRUNC | FFS_O_APPEND); + if ( ffs_fd <= 0) + { + audio_sr_error_trace(AUDIO_ENTITY_MODEL_NO_SAVED); + return; + } + } + + /* look the size of the model in model frame unit (16 words unit) */ + model_size = ((*RAM_address)<<1); + model_size *= SC_SR_MODEL_FRAME_SIZE; + + /* save the model in flash */ + if (ffs_write(ffs_fd, (void *)RAM_address, model_size) <= EFFS_OK) + { + audio_sr_error_trace(AUDIO_ENTITY_MODEL_NO_SAVED); + } + + /* close the model file flash */ + if (ffs_close(ffs_fd) != EFFS_OK) + { + audio_sr_error_trace(AUDIO_ENTITY_MODEL_NO_SAVED); + } + #endif // OP_RIV_AUDIO + } + + /*-------------------------------------------------------*/ + /* Cust_srback_save_speech() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : database */ + /* index */ + /* start_buffer */ + /* stop_buffer */ + /* start_speech */ + /* stop_speech */ + /* */ + /* Return : none */ + /* */ + /* Description : save the speech from a circular buffer */ + /* to a database. And add the end VM mask */ + /* */ + /*-------------------------------------------------------*/ + void Cust_srback_save_speech (UWORD8 database, UWORD8 index, UWORD16 *start_buffer, UWORD16 *stop_buffer, UWORD16 *start_speech, UWORD16 *stop_speech) + { + #if (AUDIO_SIMULATION) || (AUDIO_L1_STANDALONE) + UWORD16 *ptr_dst; + + // initialize the pointer to the database + ptr_dst = sr_mmi_database[database][index].speech; + + // The speech samples can be in two positions in the circular buffer: + + // Position 1: + // [.............XXXXXXXXXXXXX.............] + // ^ ^ ^ ^ + // | | | | + // start_buffer start_speech stop_speech stop_buffer + if (start_speech < stop_speech) + { + while ( (start_speech < stop_speech) && + (l1_srback_com.emergency_stop == FALSE) ) + { + *ptr_dst++ = *start_speech++; + } + + // Write the end VM mask + *ptr_dst = SC_VM_END_MASK; + } + else + // Position 2: + // [XXXXXXXXXXXX..............XXXXXXXXXXXXX] + // ^ ^ ^ ^ + // | | | | + // start_buffer stop_speech start_speech stop_buffer + { + while ( (start_speech < stop_buffer) && + (l1_srback_com.emergency_stop == FALSE) ) + { + *ptr_dst++ = *start_speech++; + } + + while ( (start_buffer < stop_speech) && + (l1_srback_com.emergency_stop == FALSE) ) + { + *ptr_dst++ = *start_buffer++; + } + + // Write the end VM mask + *ptr_dst = SC_VM_END_MASK; + } + #endif + + #if (OP_RIV_AUDIO == 1) + T_FFS_FD ffs_fd; + UWORD16 speech_size; + char *p_model_path, + sr_speech_path[AUDIO_SR_PATH_NAME_MAX_SIZE]; + UWORD8 i; + + if (p_audio_gbl_var->speech_reco.sr_enroll.state !=AUDIO_SR_ENROLL_IDLE ) + { + ffs_fd = p_audio_gbl_var->speech_reco.sr_enroll.voice_ffs_fd; + } + else + if (p_audio_gbl_var->speech_reco.sr_update.state != AUDIO_SR_UPDATE_IDLE) + { + /* reach the path of the corresponding model */ + p_model_path = p_audio_gbl_var->speech_reco.sr_update.p_database; + for (i=0; i<index; i++) + { + p_model_path += AUDIO_PATH_NAME_MAX_SIZE; + } + + /* build the speech path name */ + speech_size = ( strlen(p_model_path)- 3); + strncpy(sr_speech_path, p_model_path, speech_size); + sr_speech_path[speech_size] = 0; + + ffs_fd = ffs_open(sr_speech_path, + FFS_O_CREATE | FFS_O_WRONLY | FFS_O_TRUNC | FFS_O_APPEND); + if (ffs_fd <= 0) + { + audio_sr_error_trace(AUDIO_ENTITY_SPEECH_NO_SAVED); + return; + } + } + + // The speech samples can be in two positions in the circular buffer: + + // Position 1: + // [.............XXXXXXXXXXXXX.............] + // ^ ^ ^ ^ + // | | | | + // start_buffer start_speech stop_speech stop_buffer + if (start_speech < stop_speech) + { + /* Calculate the size of the speech file */ + speech_size = (stop_speech - start_speech)<<1; + + /* save the model in flash */ + if (ffs_write(ffs_fd, (void *)start_speech, speech_size) <= EFFS_OK) + { + audio_sr_error_trace(AUDIO_ENTITY_SPEECH_NO_SAVED); + } + } + else + // Position 2: + // [XXXXXXXXXXXX..............XXXXXXXXXXXXX] + // ^ ^ ^ ^ + // | | | | + // start_buffer stop_speech start_speech stop_buffer + { + /* Calculate the size of the speech file */ + speech_size = (stop_buffer - start_speech)<<1; + + /* save the model in flash */ + if (ffs_write(ffs_fd, (void *)start_speech, speech_size) <= EFFS_OK) + { + audio_sr_error_trace(AUDIO_ENTITY_SPEECH_NO_SAVED); + } + + /* Calculate the size of the speech file */ + speech_size = (stop_speech - start_buffer)<<1; + + /* save the model in flash */ + if (ffs_write(ffs_fd, (void *)start_speech, speech_size) <= EFFS_OK) + { + audio_sr_error_trace(AUDIO_ENTITY_SPEECH_NO_SAVED); + } + } + // Write the end VM mask + speech_size = SC_VM_END_MASK; + if (ffs_write(ffs_fd, (void *)(&speech_size), 2) <= EFFS_OK) + { + audio_sr_error_trace(AUDIO_ENTITY_MODEL_NO_SAVED); + } + + /* close the speech file flash */ + if (ffs_close(ffs_fd) != EFFS_OK) + { + audio_sr_error_trace(AUDIO_ENTITY_MODEL_NO_SAVED); + } + #endif // OP_RIV_AUDIO + } + + /*-------------------------------------------------------*/ + /* Cust_srback_load_model() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : database */ + /* index */ + /* RAM_address */ + /* */ + /* Return : none */ + /* */ + /* Description : load the model into the API. */ + /* */ + /*-------------------------------------------------------*/ + void Cust_srback_load_model (UWORD8 database, UWORD8 index, API *RAM_address) + { + #if (AUDIO_SIMULATION) || (AUDIO_L1_STANDALONE) + UWORD16 model_size; + UWORD16 *ptr_src; + UWORD8 frame_size; + + // initialize the pointer to the database + ptr_src = sr_mmi_database[database][index].model; + + // look the size of the model in model frame unit (16 words unit) + model_size = *ptr_src++; + + // save the header of the model + *RAM_address++ = model_size; + + while( (model_size != 0) && + (l1_srback_com.emergency_stop == FALSE) ) + { + frame_size = SC_SR_MODEL_FRAME_SIZE; + while ( (frame_size != 0) && + (l1_srback_com.emergency_stop == FALSE) ) + { + *RAM_address++ = *ptr_src++; + frame_size--; + } + model_size--; + } + #endif + + #if (OP_RIV_AUDIO == 1) + char *p_model_path; + T_FFS_FD ffs_fd; + UWORD8 i; + + if (p_audio_gbl_var->speech_reco.sr_reco.state !=AUDIO_SR_RECO_IDLE ) + { + p_model_path = p_audio_gbl_var->speech_reco.sr_reco.p_database; + } + else + if (p_audio_gbl_var->speech_reco.sr_update.state != AUDIO_SR_UPDATE_IDLE) + { + p_model_path = p_audio_gbl_var->speech_reco.sr_update.p_database; + } + + /* reach the path of the corresponding model */ + for (i=0; i<index; i++) + { + p_model_path += AUDIO_PATH_NAME_MAX_SIZE; + } + + /* open the model file flash */ + ffs_fd = ffs_open(p_model_path, FFS_O_RDONLY); + if ( ffs_fd <= 0) + { + audio_sr_error_trace(AUDIO_ENTITY_MODEL_NO_LOAD); + return; + } + + /* download the model to the API buffer */ + if (ffs_read(ffs_fd, (void *)RAM_address, (SC_SR_MODEL_API_SIZE<<1)) <= EFFS_OK) + { + audio_sr_error_trace(AUDIO_ENTITY_MODEL_NO_LOAD); + } + + /* close the model file flash */ + if (ffs_close(ffs_fd) != EFFS_OK) + { + audio_sr_error_trace(AUDIO_ENTITY_MODEL_NO_LOAD); + } + #endif // OP_RIV_AUDIO + } + #endif // SPEECH_RECO + + /*-------------------------------------------------------*/ + /* Cust_get_pointer */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : ptr */ + /* buffer_size */ + /* session_id */ + /* */ + /* Return : error_id : */ + /* DATA_AVAILABLE: 0, no error occured */ + /* SESSION_ERROR: 1, wrong session id */ + /* POINTER_ERROR: 2, wrong ptr */ + /* DATA_AVAIL_ERROR: 3, no more data */ + /* available */ + /* DATA_LAST: 4, last buffer available */ + /* buffer_size */ + /* ptr */ + /* */ + /* Description : */ + /* The L1 calls this function to request new data buffer */ + /* (requested size: buffer_size). This function returns */ + /* the description of the new data buffer */ + /* (start address: ptr and the size: buffer_size) */ + /* Moreover, the L1 indicates the position of the last */ + /* data used via the ptr argument. */ + /* Note that this function can be returns an error. */ + /* */ + /*-------------------------------------------------------*/ + UWORD8 Cust_get_pointer (UWORD16 **ptr, UWORD16 *buffer_size, UWORD8 session_id) + { + #if (AUDIO_SIMULATION) || (AUDIO_L1_STANDALONE) + + UWORD8 database_id, word_index; + + switch (session_id & 0x0F) + { + #if (MELODY_E1) + // Melody E1 0 + case 0: + { + if (*ptr == NULL) + { + *ptr = (UWORD16 *)&melody_0; + *buffer_size = SC_MELODY_0_SCORE_SIZE>>1; + } + else + { + *buffer_size = SC_MELODY_0_SCORE_SIZE>>1; + } + + return(DATA_AVAILABLE); + } +//omaps00090550 break; + + // Melody E1 1 + case 1: + { + if (*ptr == NULL) + { + *ptr = (UWORD16 *)&melody_1; + *buffer_size = SC_MELODY_1_SCORE_SIZE>>1; + } + else + { + *buffer_size = SC_MELODY_1_SCORE_SIZE>>1; + } + + return(DATA_AVAILABLE); + } +//omaps00090550 break; + #endif // MELODY_E1 + #if (VOICE_MEMO) + // Voice memo play + case 2: + { + if (*ptr == NULL) + { + *ptr = (UWORD16 *)&voice_memo_buffer; + *buffer_size = SC_VM_BUFFER_SIZE>>1; + } + else + { + *buffer_size = (SC_VM_BUFFER_SIZE>>1) + 1; + } + + return(DATA_AVAILABLE); + } +//omaps00090550 break; + + // Voice memo record + case 3: + { + if (*ptr == NULL) + { + *ptr = (UWORD16 *)&voice_memo_buffer; + *buffer_size = SC_VM_BUFFER_SIZE>>1; + } + else + { + *buffer_size = (SC_VM_BUFFER_SIZE>>1) + 1; + } + + return(DATA_AVAILABLE); + } +//omaps00090550 break; + #endif // VOICE_MEMO + #if (SPEECH_RECO) + case 4: + { + database_id = 0; + word_index = (session_id & 0xF0)>>4; + *ptr = (UWORD16 *)&(sr_mmi_database[database_id][word_index].speech); + + *buffer_size = SC_SR_MMI_DB_SPEECH_SIZE; + + return(DATA_AVAILABLE); + } + break; + + case 5: + { + database_id = 1; + word_index = (session_id & 0xF0)>>4; + *ptr = (UWORD16 *)&(sr_mmi_database[database_id][word_index].speech); + + *buffer_size = SC_SR_MMI_DB_SPEECH_SIZE; + + return(DATA_AVAILABLE); + } + break; + #endif // SPEECH_RECO + #if (MELODY_E2 && FIR) + // Melody E2 + // Tchaikowski + case 6: + { + if (*ptr == NULL) + { + *ptr = (UWORD16 *)&Tchaikowski_danse_russe; + *buffer_size = TCHAIKOWSKI_DANSE_RUSSE>>1; + } + else + { + *buffer_size = TCHAIKOWSKI_DANSE_RUSSE>>1; + } + + return(DATA_AVAILABLE); + } + break; + + // Small melody + case 7: + { + if (*ptr == NULL) + { + *ptr = (UWORD16 *)&Small_melody_E2; + *buffer_size = SMALL_MELODY_E2>>1; + } + else + { + *buffer_size = SMALL_MELODY_E2>>1; + } + + return(DATA_AVAILABLE); + } + break; + + // CPU load + case 8: + { + if (*ptr == NULL) + { + *ptr = (UWORD16 *)&Cpu_load_E2; + *buffer_size = CPU_LOAD_E2>>1; + } + else + { + *buffer_size = CPU_LOAD_E2>>1; + } + + return(DATA_AVAILABLE); + } + break; + + // USA hymn + case 9: + { + if (*ptr == NULL) + { + *ptr = (UWORD16 *)&Usa_E2; + *buffer_size = USA_E2>>1; + } + else + { + *buffer_size = USA_E2>>1; + } + + return(DATA_AVAILABLE); + } + break; + #endif // MELODY_E2 + #if (L1_VOICE_MEMO_AMR) + // Voice memo amr play + case 10: + { + if (*ptr == NULL) + { + *ptr = (UWORD16 *)&voice_memo_buffer; + *buffer_size = SC_VM_BUFFER_SIZE>>1; + } + else + { + *buffer_size = (SC_VM_BUFFER_SIZE>>1) + 1; + } + + return(DATA_AVAILABLE); + } +//omaps00090550 break; + + // Voice memo record + case 11: + { + if (*ptr == NULL) + { + *ptr = (UWORD16 *)&voice_memo_buffer; + *buffer_size = SC_VM_BUFFER_SIZE>>1; + } + else + { + *buffer_size = (SC_VM_BUFFER_SIZE>>1) + 1; + } + + return(DATA_AVAILABLE); + } +//omaps00090550 break; + #endif // L1_VOICE_MEMO_AMR + + #if (L1_MIDI == 1) + // MIDI + case 12: + { + extern struct MIDI_FILE midi_file; + UWORD8 **ptr_char=(UWORD8 **)ptr; + static UWORD8 *last_ptr; + + if(*ptr_char==NULL) + { + midi_file_offset=0; + *ptr_char=&(midi_file.midi_file_buffer[0]); + last_ptr=*ptr_char; + + // All MIDI file available due to SMF1 format constraints + // For SMF0, *buffer_size should be set to MIDI_BUFFER_SIZE + *buffer_size=midi_file.midi_file_size; + return DATA_LAST; + } + else + { + *buffer_size=MIDI_BUFFER_SIZE; + *ptr_char=last_ptr+MIDI_BUFFER_SIZE; + + // Check if pointer is out of bounds + if(*ptr_char > &(midi_file.midi_file_buffer[0])+midi_file.midi_file_size-1) + { + *ptr_char=&(midi_file.midi_file_buffer[0]); + return DATA_AVAIL_ERROR; + } + + // Check if it's the last valid buffer + if((*ptr_char+*buffer_size) > &(midi_file.midi_file_buffer[0])+midi_file.midi_file_size-1) + { + *buffer_size=MIDI_BUFFER_SIZE-(UWORD16)(*ptr_char+MIDI_BUFFER_SIZE-&(midi_file.midi_file_buffer[0])-midi_file.midi_file_size+1); + + // Update offset in the MIDI file + midi_file_offset+=*ptr_char-last_ptr; + + last_ptr=*ptr_char; + + return DATA_LAST; + } + else + { + // Update offset in the MIDI file + midi_file_offset+=*ptr_char-last_ptr; + + last_ptr=*ptr_char; + + return DATA_AVAILABLE; + } + } + } + #endif // L1_MIDI + +#if L1_PCM_EXTRACTION + case 13: + { + *ptr = (UWORD16 *)&pcm_download_buffer; + *buffer_size = SC_PCM_DOWNLOAD_BUFFER_SIZE; + return DATA_AVAILABLE; + } +//omaps00090550 break; + + case 14: + { + *ptr = (UWORD16 *)&pcm_upload_buffer; + *buffer_size = SC_PCM_UPLOAD_BUFFER_SIZE; + return DATA_AVAILABLE; + } +//omaps00090550 break; +#endif /* L1_PCM_EXTRACTION */ + default: + { + return(SESSION_ERROR); + } +//omaps00090550 break; + } + #endif + + #if (OP_RIV_AUDIO == 1) + + #if (MELODY_E1) || (VOICE_MEMO) || (MELODY_E2) || (L1_VOICE_MEMO_AMR) || (L1_EXT_AUDIO_MGT) + UWORD8 index_l1, *current_ptr_8; + UWORD16 *current_ptr, *size_ptr, *end_ptr; + UWORD32 current, end; + T_AUDIO_FFS_SESSION *p_session; + + #if (L1_AUDIO_DRIVER == 1) + T_AUDIO_DRIVER_SESSION *p_driver_session; + UINT8 channel_id; + xSignalHeaderRec *msg; + + /* special handling for features in driver */ + if ((session_id == AUDIO_VM_AMR_RECORD_SESSION_ID) || + (session_id == AUDIO_VM_AMR_PLAY_SESSION_ID)) + { + channel_id = 0; + /* find active channel_id associated to session_id */ + while ( (channel_id < AUDIO_DRIVER_MAX_CHANNEL)&& + ((p_audio_gbl_var->audio_driver_session[channel_id].session_info.state == AUDIO_DRIVER_CHANNEL_WAIT_INIT)|| + (p_audio_gbl_var->audio_driver_session[channel_id].session_req.session_id != session_id)) ) + { + channel_id++; + } + /* get driver session */ + p_driver_session = &(p_audio_gbl_var->audio_driver_session[channel_id]); + + /* first buffer, index_l1 = 0 */ + if (*ptr == NULL) + { + *ptr = (UWORD16 *)(p_driver_session->session_info.buffer[0].p_start_pointer); + *buffer_size = (p_driver_session->session_info.buffer[0].size >> 1); + + return(DATA_AVAILABLE); + } + /* following buffers */ + else + { + /* prepare notification */ + msg = os_alloc_sig(sizeof(T_L1_AUDIO_DRIVER_IND)); + DEBUGMSG(status,NU_ALLOC_ERR) + msg->SignalCode = L1_AUDIO_DRIVER_IND; + ((T_L1_AUDIO_DRIVER_IND *)msg->SigP)->channel_id = channel_id; + ((T_L1_AUDIO_DRIVER_IND *)msg->SigP)->p_buffer = NULL; + + /* fill message with current buffer for record */ + index_l1 = p_driver_session->session_info.index_l1; + if (session_id == AUDIO_VM_AMR_RECORD_SESSION_ID) + ((T_L1_AUDIO_DRIVER_IND *)msg->SigP)->p_buffer = + (UWORD16 *)p_driver_session->session_info.buffer[index_l1].p_start_pointer; + + /* give new buffer = index_l1++ % nb_buffer */ + p_driver_session->session_info.index_l1++; + if ((p_driver_session->session_info.index_l1) == (p_driver_session->session_req.nb_buffer)) + p_driver_session->session_info.index_l1 =(UINT8)( 0);//omaps + + /* Update new current buffer parameters */ + index_l1 = (UWORD8)(p_driver_session->session_info.index_l1);//oamps + *ptr = (UWORD16 *)(p_driver_session->session_info.buffer[index_l1].p_start_pointer); + *buffer_size = (p_driver_session->session_info.buffer[index_l1].size >> 1); + + // Send confirmation message... + os_send_sig(msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + return (DATA_AVAILABLE); + } + } + /* Other features */ + else + { + #endif // L1_AUDIO_DRIVER + p_session = &(p_audio_gbl_var->audio_ffs_session[session_id]); + + switch (p_session->session_info.cust_get_pointer_state) + { + case AUDIO_CUST_GET_POINTER_INIT: + { + /* the first buffer, the index_l1 is already OK so the index_l1 doesn't change */ + index_l1 = + p_session->session_info.index_l1; + *ptr = + (UWORD16 *)(p_session->session_info.buffer[index_l1].p_start_pointer); + *buffer_size = + (p_session->session_info.buffer[index_l1].size>>1); + + + p_session->session_info.cust_get_pointer_state = + AUDIO_CUST_GET_POINTER_NORMAL; + break; + } + case AUDIO_CUST_GET_POINTER_NORMAL: + { + /* in loopback mode, when the melody restarts, the L1 pointer management is different */ + if ( (*buffer_size == 0) && + (p_session->session_req.loop_mode == TRUE) ) + { + p_session->session_info.cust_get_pointer_state = + AUDIO_CUST_GET_POINTER_LOOP; + break; + } + + /* The index_l1 needs to be changed */ + p_session->session_info.index_l1++; + if (p_session->session_info.index_l1 + == AUDIO_MAX_FFS_BUFFER_PER_SESSION) + { + p_session->session_info.index_l1 = 0; + } + + index_l1 = + p_session->session_info.index_l1; + *ptr = + (UWORD16 *)(p_session->session_info.buffer[index_l1].p_start_pointer); + *buffer_size = + (p_session->session_info.buffer[index_l1].size>>1); + + break; + } + case AUDIO_CUST_GET_POINTER_LOOP: + { + /* in loopback mode, the next melody data is contiguous to the first */ + /* if it's the end of the buffer , we use the next buffer */ + index_l1 = + p_session->session_info.index_l1; + + current_ptr = (UWORD16 *)(*ptr); + current_ptr_8 = (UWORD8 *)(*ptr); + end_ptr = (UWORD16 *)(p_session->session_info.buffer[index_l1].p_stop_pointer); + + if ( current_ptr >= end_ptr ) + { + p_session->session_info.index_l1++; + if (p_session->session_info.index_l1 + == AUDIO_MAX_FFS_BUFFER_PER_SESSION) + { + p_session->session_info.index_l1 = 0; + } + + index_l1 = + p_session->session_info.index_l1; + *ptr = + (UWORD16 *)(p_session->session_info.buffer[index_l1].p_start_pointer); + *buffer_size = + (p_session->session_info.buffer[index_l1].size>>1); + } + else + { + // Realign the pointer to the next 16 bit in case of melody E2 + current = (UWORD32)current_ptr_8; + if (current & 0x01) + { + current_ptr_8++; + *ptr = (UWORD16 *)current_ptr_8; + } + + end = (UWORD32)end_ptr; + current = (UWORD32)current_ptr; + + *buffer_size = (UWORD16)((end-current)>>1); + } + + p_session->session_info.cust_get_pointer_state = + AUDIO_CUST_GET_POINTER_NORMAL; + break; + } + } /* switch(p_session->session_info.cust_get_pointer_state) */ + + return(DATA_AVAILABLE); + #if (L1_AUDIO_DRIVER == 1) + } // added + #endif + #endif // MELODY_E1 || VOICE_MEMO || MELODY_E2 + #endif // OP_RIV_AUDIO + } + +#if (AUDIO_SIMULATION) || (AUDIO_L1_STANDALONE) +/*-------------------------------------------------------*/ +/* Cust_get_next_buffer_status */ +/*-------------------------------------------------------*/ +/* */ +/* Parameters : */ +/* */ +/* Return : */ +/* */ +/* Description : */ +/* */ +/*-------------------------------------------------------*/ +UWORD8 Cust_get_next_buffer_status(void) +{ + return (FALSE); +} + +#endif + +#if (AUDIO_SIMULATION) || (AUDIO_L1_STANDALONE) +/*-------------------------------------------------------*/ +/* Cust_get_pointer_next_buffer */ +/*-------------------------------------------------------*/ +/* */ +/* Parameters : ptr */ +/* buffer_size */ +/* session_id */ +/* */ +/* Return : error_id : */ +/* DATA_AVAILABLE: 0, no error occured */ +/* SESSION_ERROR: 1, wrong session id */ +/* POINTER_ERROR: 2, wrong ptr */ +/* DATA_AVAIL_ERROR: 3, no more data */ +/* available */ +/* DATA_LAST: 4, returned buffer is the */ +/* last */ +/* buffer_size */ +/* ptr */ +/* */ +/* Description : */ +/* This function acts the same as Cust_get_pointer() but */ +/* does not send notification to upper layers to free */ +/* current buffer */ +/* */ +/*-------------------------------------------------------*/ +UWORD8 Cust_get_pointer_next_buffer(UWORD16 **ptr, + UWORD16 *buffer_size, + UWORD8 session_id) +{ +#if (L1_MP3 == 1) + extern UWORD32 mp3_file_size; +#endif +#if (L1_AAC == 1) + extern UWORD32 aac_file_size; +#endif + + switch(session_id&0x0F) + { +#if (L1_MP3 == 1) + case 13: + { + if(*ptr==NULL) + { + // Reset flag + Cust_get_pointer_mp3_buffer_last=FALSE; + + // Set pointer to first buffer with corresponding size + mp3_tempbuf_idx=0; + *ptr=mp3_tempbuf0; + *buffer_size=C_MP3_L1STANDALONE_BUFFER_SIZE; + + Cust_get_pointer_mp3_last_buffer_size=C_MP3_L1STANDALONE_BUFFER_SIZE; + +#if (CODE_VERSION == NOT_SIMULATION) + if(mp3_file_size<C_MP3_L1STANDALONE_BUFFER_SIZE) + { + *buffer_size=(UWORD16)mp3_file_size; + Cust_get_pointer_mp3_buffer_last=TRUE; + return DATA_LAST; + } +#endif + + return DATA_AVAILABLE; + } + else + { + switch(mp3_tempbuf_idx) + { + case 0: + *ptr=mp3_tempbuf1; + break; + + case 1: + *ptr=mp3_tempbuf0; + break; + } + + // Swap buffer index + mp3_tempbuf_idx^=1; + + *buffer_size=Cust_get_pointer_mp3_last_buffer_size; + + if(Cust_get_pointer_mp3_buffer_last==FALSE) + return DATA_AVAILABLE; + else + { + if(l1a_l1s_com.mp3_task.parameters.loopback==TRUE) + Cust_get_pointer_mp3_buffer_last=FALSE; + + return DATA_LAST; + } + } + } +//omaps00090550 break; +#endif // L1_MP3 + +#if (L1_AAC == 1) + case 14: // session id for AAC + { + if(*ptr==NULL) + { + // Reset flag + Cust_get_pointer_aac_buffer_last=FALSE; + + // Set pointer to first buffer with corresponding size + aac_tempbuf_idx=0; + *ptr=aac_tempbuf0; + *buffer_size=C_AAC_L1STANDALONE_BUFFER_SIZE; + + Cust_get_pointer_aac_last_buffer_size=C_AAC_L1STANDALONE_BUFFER_SIZE; + +#if (CODE_VERSION == NOT_SIMULATION) + if(aac_file_size<C_AAC_L1STANDALONE_BUFFER_SIZE) + { + *buffer_size=(UWORD16)aac_file_size; + Cust_get_pointer_aac_buffer_last=TRUE; + return DATA_LAST; + } +#endif + + return DATA_AVAILABLE; + } + else + { + switch(aac_tempbuf_idx) + { + case 0: + *ptr=aac_tempbuf1; + break; + + case 1: + *ptr=aac_tempbuf0; + break; + } + + // Swap buffer index + aac_tempbuf_idx^=1; + + *buffer_size=Cust_get_pointer_aac_last_buffer_size; + + if(Cust_get_pointer_aac_buffer_last==FALSE) + return DATA_AVAILABLE; + else + { + if(l1a_l1s_com.aac_task.parameters.loopback==TRUE) + Cust_get_pointer_aac_buffer_last=FALSE; + + return DATA_LAST; + } + } + } +//omaps00090550 break; +#endif // L1_AAC + + default: + { + return SESSION_ERROR; + } +//omaps00090550 break; + } +} +#endif // (AUDIO_SIMULATION) || (AUDIO_L1_STANDALONE) + + +#if (AUDIO_SIMULATION) || (AUDIO_L1_STANDALONE) +/*------------------------------------------------------------------*/ +/* Cust_get_pointer_notify */ +/*------------------------------------------------------------------*/ +/* */ +/* Parameters : ptr */ +/* session_id */ +/* */ +/* Return : n/a */ +/* */ +/* Description : */ +/* This function sends notification to upper layers to */ +/* fill next buffer. */ +/* This function should be used with Cust_get_pointer_next_buffer() */ +/* */ +/*------------------------------------------------------------------*/ +void Cust_get_pointer_notify(UWORD8 session_id) +{ + switch(session_id&0x0F) + { +#if (L1_MP3 == 1) + case 13: + { +#if (CODE_VERSION == NOT_SIMULATION) + UWORD32 size; + UWORD8 *dst; + extern UWORD32 mp3_file_size; + + // Check if file is ending + if(mp3_file_offset+C_MP3_L1STANDALONE_BUFFER_SIZE > mp3_file_size) + { + size=mp3_file_size-mp3_file_offset; + Cust_get_pointer_mp3_buffer_last=TRUE; + } + else + { + size=C_MP3_L1STANDALONE_BUFFER_SIZE; + Cust_get_pointer_mp3_buffer_last=FALSE; + } + + switch(mp3_tempbuf_idx) + { + case 0: + { + // L1 is working on buffer 0 -> fill buffer 1 + dst=(UWORD8 *)mp3_tempbuf1; + } + break; + + case 1: + { + // L1 is working on buffer 1 -> fill buffer 0 + dst=(UWORD8 *)mp3_tempbuf0; + } + break; + } + + memcpy(dst,(UWORD8 *)mp3_file+mp3_file_offset,size); + + // Update MP3 read offset + mp3_file_offset+=C_MP3_L1STANDALONE_BUFFER_SIZE; + + // Rewind if loopback mode is on + if((l1a_l1s_com.mp3_task.parameters.loopback==TRUE) && + (Cust_get_pointer_mp3_buffer_last==TRUE)) + mp3_file_offset=0; + + // Keep track of buffer size + Cust_get_pointer_mp3_last_buffer_size=(UWORD16)size; + +#else // CODE_VERSION == NOT_SIMULATION + UWORD16 i; + UWORD8 *dst; + switch(mp3_tempbuf_idx) + { + case 0: + dst=(UWORD8 *)mp3_tempbuf1; + break; + case 1: + dst=(UWORD8 *)mp3_tempbuf0; + break; + } + for(i=0; i<C_MP3_L1STANDALONE_BUFFER_SIZE/2; i++) + { + dst[2*i] =0x12; + dst[2*i+1]=0x24; + } +#endif + } + break; +#endif // L1_MP3 + +#if (L1_AAC == 1) + case 14: + { +#if (CODE_VERSION == NOT_SIMULATION) + UWORD32 size; + UWORD8 *dst; + extern UWORD32 aac_file_size; + + // Check if file is ending + if(aac_file_offset+C_AAC_L1STANDALONE_BUFFER_SIZE > aac_file_size) + { + size=aac_file_size-aac_file_offset; + Cust_get_pointer_aac_buffer_last=TRUE; + } + else + { + size=C_AAC_L1STANDALONE_BUFFER_SIZE; + Cust_get_pointer_aac_buffer_last=FALSE; + } + + switch(aac_tempbuf_idx) + { + case 0: + { + // L1 is working on buffer 0 -> fill buffer 1 + dst=(UWORD8 *)aac_tempbuf1; + } + break; + + case 1: + { + // L1 is working on buffer 1 -> fill buffer 0 + dst=(UWORD8 *)aac_tempbuf0; + } + break; + } + + memcpy(dst,(UWORD8 *)aac_file+aac_file_offset,size); + + // Update AAC read offset + aac_file_offset+=C_AAC_L1STANDALONE_BUFFER_SIZE; + + // Rewind if loopback mode is on + if((l1a_l1s_com.aac_task.parameters.loopback==TRUE) && + (Cust_get_pointer_aac_buffer_last==TRUE)) + aac_file_offset=0; + + // Keep track of buffer size + Cust_get_pointer_aac_last_buffer_size=(UWORD16)size; + +#else // CODE_VERSION == NOT_SIMULATION + UWORD16 i; + UWORD8 *dst; + switch(aac_tempbuf_idx) + { + case 0: + dst=(UWORD8 *)aac_tempbuf1; + break; + case 1: + dst=(UWORD8 *)aac_tempbuf0; + break; + } + for(i=0; i<C_AAC_L1STANDALONE_BUFFER_SIZE/2; i++) + { + dst[2*i] =0x10; + dst[2*i+1]=0x20; + } +#endif + } + break; +#endif // L1_AAC + + } // switch(session_id&0x0F) +} +#endif // (AUDIO_SIMULATION) || (AUDIO_L1_STANDALONE) + + + #if (MELODY_E2 && FIR) + /*-------------------------------------------------------*/ + /* Cust_audio_melody_E2_load_instrument */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : customer_instrument_id: */ + /* Identifier of the instrument */ + /* API_address */ + /* address where the insturment */ + /* is downloaded */ + /* allowed_size */ + /* maximum size of the instrument */ + /* */ + /* Return : instrument_size : */ + /* size of the insturment downloaded in */ + /* 16-bit word */ + /* */ + /* Description : */ + /* The audio background task calls this function to */ + /* request to the MMI to download a new instrument */ + /* description at the API_address. */ + /* */ + /*-------------------------------------------------------*/ + UWORD16 Cust_audio_melody_E2_load_instrument (UWORD8 customer_instrument_id, + API *API_address, + UWORD16 allowed_size) + { + #if (AUDIO_SIMULATION) || (AUDIO_L1_STANDALONE) + UWORD16 instrument_size = 0, i, *instrument_ptr; + + // default.lsi file: + // 0 piano31 0x0 + // 1 piano15 0x1 + // 2 pia_811 0x2 + // 3 eba_2536 0x3 + // 4 tsax_255 0x4 + // 5 asax_124 0x5 + // 6 clar_121 0x6 + // 7 clar_130 0x7 + // 8 stdr_515 0x8 + // 9 timp_661 0x9 + // 10 agog_406 0xA + // 11 wood_110 0xB + // 12 vib_3836 0xC + // 13 xylo_120 0xD + // 14 xylo_315 0xE + // 15 xylo_516 0xF + // 16 kali_215 0x10 + // 17 viol_231 0x11 + // 18 viol_215 0x12 + // 19 viol_211 0x13 + // 20 viol_108 0x14 + // 21 flut_436 0x15 + // 22 flut_308 0x16 + // 23 porg_131 0x17 + // 24 acco_211 0x18 + // 25 stng_231 0x19 + // 26 stng_058 0x1A + // 27 ldsa_131 0x1B + // 28 sin7 0x1C + // 29 egu_3036 0x1D + // 30 jgui_215 0x1E + // 31 banj_315 0x1F + // 32 trum_231 0x20 + // 33 tromb31 0x21 + // 34 cho_2116 0x22 + // 35 vooh_331 0x23 + // 36 crc_1210 0x24 + // 37 chc_1210 0x25 + // 38 ohc_1610 0x26 + // 39 lbon_121 0x27 + // 40 esn_0210 0x28 + // 41 crc_0210 0x29 + // 42 ric_0210 0x2A + // 43 bdm_0122 0x2B + // 44 vib_0415 0x2C + // 45 ngu_0343 0x2D + // 46 sgu_0230 0x2E + // 47 xyl_0315 0x2F + + switch (customer_instrument_id) + { + case 0: + // Piano31.mwa + { + instrument_size = MELODY_E2_PIANO31_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_piano31[0]); + break; + } + case 1: + // Piano15.mwa + { + instrument_size = MELODY_E2_PIANO15_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_piano15[0]); + break; + } + case 2: + // Pia_811.mwa + { + instrument_size = MELODY_E2_PIA_811_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_pia_811[0]); + break; + } + case 3: + // eba_2536.mwa + { + instrument_size = MELODY_E2_EBA_2536_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_eba_2536[0]); + break; + } + case 4: + // tsax_255.mwa + { + instrument_size = MELODY_E2_TSAX_255_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_tsax_255[0]); + break; + } + case 5: + // asax_124.mwa + { + instrument_size = MELODY_E2_ASAX_124_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_asax_124[0]); + break; + } + case 6: + // clar_121.mwa + { + instrument_size = MELODY_E2_CLAR_121_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_clar_121[0]); + break; + } + case 7: + // clar_130.mwa + { + instrument_size = MELODY_E2_CLAR_130_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_clar_130[0]); + break; + } + case 8: + // stdr_515.mwa + { + instrument_size = MELODY_E2_STDR_515_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_stdr_515[0]); + break; + } + case 9: + // timp_661.mwa + { + instrument_size = MELODY_E2_TIMP_661_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_timp_661[0]); + break; + } + case 10: + // agog_406.mwa + { + instrument_size = MELODY_E2_AGOG_406_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_agog_406[0]); + break; + } + case 11: + // wood_110.mwa + { + instrument_size = MELODY_E2_WOOD_110_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_wood_110[0]); + break; + } + case 12: + // vib_3836.mwa + { + instrument_size = MELODY_E2_VIB_3836_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_vib_3836[0]); + break; + } + case 13: + // xylo_120.mwa + { + instrument_size = MELODY_E2_XYLO_120_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_xylo_120[0]); + break; + } + case 14: + // xylo_315.mwa + { + instrument_size = MELODY_E2_XYLO_315_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_xylo_315[0]); + break; + } + case 15: + // xylo_516.mwa + { + instrument_size = MELODY_E2_XYLO_516_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_xylo_516[0]); + break; + } + case 16: + // kali_215.mwa + { + instrument_size = MELODY_E2_KALI_215_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_kali_215[0]); + break; + } + case 17: + // viol_231 + { + instrument_size = MELODY_E2_VIOL_231_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_viol_231[0]); + break; + } + case 18: + // viol_215.mwa + { + instrument_size = MELODY_E2_VIOL_215_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_viol_215[0]); + break; + } + case 19: + // viol_211.mwa + { + instrument_size = MELODY_E2_VIOL_211_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_viol_211[0]); + break; + } + case 20: + // viol_108.mwa + { + instrument_size = MELODY_E2_VIOL_108_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_viol_108[0]); + break; + } + case 21: + // flut_436 + { + instrument_size = MELODY_E2_FLUT_436_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_flut_436[0]); + break; + } + case 22: + // flut_308.mwa + { + instrument_size = MELODY_E2_FLUT_308_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_flut_308[0]); + break; + } + case 23: + // porg_131 + { + instrument_size = MELODY_E2_PORG_131_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_porg_131[0]); + break; + } + case 24: + // acco_211.mwa + { + instrument_size = MELODY_E2_ACCO_211_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_acco_211[0]); + break; + } + case 25: + // stng_231 + { + instrument_size = MELODY_E2_STNG_231_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_stng_231[0]); + break; + } + case 26: + // stng_058.mwa + { + instrument_size = MELODY_E2_STNG_058_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_stng_058[0]); + break; + } + case 27: + // ldsa_131 + { + instrument_size = MELODY_E2_LDSA_131_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_ldsa_131[0]); + break; + } + case 28: + // sin7.mwa + { + instrument_size = MELODY_E2_SIN7_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_sin7[0]); + break; + } + case 29: + // Egu_3036.mwa + { + instrument_size = MELODY_E2_EGU_3036_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_egu_3036[0]); + break; + } + case 30: + // Jgui_215.mwa + { + instrument_size = MELODY_E2_JGUI_215_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_jgui_215[0]); + break; + } + case 31: + // Banj_315.mwa + { + instrument_size = MELODY_E2_BANJ_315_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_banj_315[0]); + break; + } + + case 32: + // trum_231 + { + instrument_size = MELODY_E2_TRUM_231_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_trum_231[0]); + break; + } + case 33: + // tromb31 + { + instrument_size = MELODY_E2_TROMB31_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_tromb31[0]); + break; + } + case 34: + // cho_2116 + { + instrument_size = MELODY_E2_CHO_2116_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_cho_2116[0]); + break; + } + case 35: + // vooh_331.mwa + { + instrument_size = MELODY_E2_VOOH_331_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_vooh_331[0]); + break; + } + case 36: + // crc_1210.mwa + { + instrument_size = MELODY_E2_CRC_1210_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_crc_1210[0]); + break; + } + case 37: + // chc_1210.mwa + { + instrument_size = MELODY_E2_CHC_1210_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_chc_1210[0]); + break; + } + case 38: + // ohc_1610 + { + instrument_size = MELODY_E2_OHC_1610_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_ohc_1610[0]); + break; + } + case 39: + // lbon_121 + { + instrument_size = MELODY_E2_LBON_121_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_lbon_121[0]); + break; + } + case 40: + // esn_0210 + { + instrument_size = MELODY_E2_ESN_0210_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_esn_0210[0]); + break; + } + case 41: + // crc_0210 + { + instrument_size = MELODY_E2_CRC_0210_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_crc_0210[0]); + break; + } + case 42: + // ric_0210 + { + instrument_size = MELODY_E2_RIC_0210_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_ric_0210[0]); + break; + } + case 43: + // bdm_0122 + { + instrument_size = MELODY_E2_BDM_0122_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_bdm_0122[0]); + break; + } + case 44: + // vib_0415 + { + instrument_size = MELODY_E2_VIB_0415_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_vib_0415[0]); + break; + } + case 45: + // ngu_0343 + { + instrument_size = MELODY_E2_NGU_0343_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_ngu_0343[0]); + break; + } + case 46: + // sgu_0230 + { + instrument_size = MELODY_E2_SGU_0230_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_sgu_0230[0]); + break; + } + case 47: + // xyl_0315 + { + instrument_size = MELODY_E2_XYL_0315_MWA_SIZE; + instrument_ptr = (UWORD16 *)(&melody_E2_xyl_0315[0]); + break; + } + } + + i = instrument_size; + while ( (i != 0) && + (l1a_l1s_com.melody0_e2_task.parameters.emergency_stop == FALSE) ) + { + *API_address++ = *instrument_ptr++; + i--; + } + + return(instrument_size); + #endif // (AUDIO_SIMULATION) || (AUDIO_L1_STANDALONE) + + #if (OP_RIV_AUDIO == 1) + #ifndef _WINDOWS + T_FFS_FD ffs_fd_1, ffs_fd_2; + T_FFS_STAT stat; + + /* Nb of instruments in the .lsi file */ + INT8 i = 0; + INT16 instrument_id = -1; + + /* basic structure of the .lsi file */ + T_AUDIO_MELODY_E2_ID_NAME file_E2; + + /**** Find the size of the .lsi file ****/ + /* the .lsi file is stores into the flash */ + /* check if the .lsi file exists */ + + ffs_fd_1 = ffs_open(p_audio_gbl_var->melody_E2_load_file_instruments.instrument_file_name, + FFS_O_RDONLY ); + + if (ffs_fd_1 < EFFS_OK) + { + audio_melody_E2_error_trace(AUDIO_ENTITY_LOAD_FILE_INSTR_ERROR); + return (0); + } + + /* find the .mwa file */ + while ( (i < p_audio_gbl_var->melody_E2_load_file_instruments.nb_of_instruments) && + (customer_instrument_id != instrument_id)) + { + /* Load the instruments file from the FFS */ + if ( (ffs_read ( ffs_fd_1, + (&file_E2), + (sizeof(INT8) + AUDIO_PATH_NAME_MAX_SIZE))) < EFFS_OK ) + { + AUDIO_SEND_TRACE("AUDIO MELODY E2: impossible to load the .lsi file", RV_TRACE_LEVEL_ERROR); + + /* Close the file */ + ffs_close(ffs_fd_1); + + return (0); + } + + instrument_id = file_E2.id; + } + /* Close the file */ + ffs_close(ffs_fd_1); + + if (i == p_audio_gbl_var->melody_E2_load_file_instruments.nb_of_instruments) + { + AUDIO_SEND_TRACE("AUDIO MELODY E2: the instrument doesn't exist in the .lsi file", RV_TRACE_LEVEL_ERROR); + + return (0); + } + + /* Open the corresponding .mwa file */ + ffs_fd_2 = ffs_open( file_E2.melody_name, + FFS_O_RDONLY ); + if (ffs_fd_2 < EFFS_OK) + { + AUDIO_SEND_TRACE("AUDIO MELODY E2: impossible to open the .mwa file instruments", RV_TRACE_LEVEL_ERROR); + + /* Close the .mwa file */ + ffs_close(ffs_fd_2); + + return (0); + } + + /* download the instrument description */ + ffs_stat(file_E2.melody_name,&stat); + + /* check if the file contains some data */ + if (stat.size ==0) + { + /* the file doesn't contains data */ + /* an error is generated */ + audio_melody_E2_error_trace(AUDIO_ENTITY_FILE_ERROR); + + /* Close the .mwa file */ + ffs_close(ffs_fd_2); + + return(0); + } + + /* check if there's enough memory in the API for this instrument */ + if (allowed_size < (stat.size>>1)) + { + /* an error is generated */ + audio_melody_E2_error_trace(AUDIO_ERROR_INSTRUMENT_SIZE); + + /* Close the .mwa file */ + ffs_close(ffs_fd_2); + + return(0); + } + + ffs_read ( ffs_fd_2, + (void *)API_address, + stat.size ); + + /* Close the file */ + ffs_close(ffs_fd_2); + + return((stat.size>>1)); + #endif //_WINDOWS + #endif // OP_RIV_AUDIO + } + #endif // MELODY_E2 + + #if (L1_EXT_AUDIO_MGT) + /*-------------------------------------------------------*/ + /* Cust_ext_audio_mgt_hisr */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : none */ + /* */ + /* Return : none */ + /* */ + /* Description : */ + /* handle the DMA interrupt in order to request a new */ + /* buffer */ + /* */ + /*-------------------------------------------------------*/ + void Cust_ext_audio_mgt_hisr() + { + UWORD8 error_id = 0; + UWORD16 requested_size = l1a_l1s_com.stereopath_drv_task.parameters.frame_number*2; + + error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address, + &requested_size, + l1s.ext_audio_mgt.session_id); + + } + #endif + +#if 0 /* FreeCalypso: removing functions not present in TCS211 */ + void l1a_bt_audio_noti_process() + { + UINT8 channel_id=0; + void *p_message = NULL; //omaps00090550 + T_RVF_MB_STATUS mb_status; //omaps00090550 + T_AUDIO_DRIVER_SESSION *p_session; + T_RV_RETURN *return_path; + /* find active channel_id associated to session_id */ + while ( (channel_id < AUDIO_DRIVER_MAX_CHANNEL)&& + ((p_audio_gbl_var->audio_driver_session[channel_id].session_info.state == AUDIO_DRIVER_CHANNEL_WAIT_INIT)|| + (p_audio_gbl_var->audio_driver_session[channel_id].session_req.session_id != AUDIO_EXT_MIDI_SESSION_ID)) ) + { + channel_id++; + } + /* get driver session */ + + p_session = &(p_audio_gbl_var->audio_driver_session[channel_id]); + p_session->session_info.index_l1=1-p_session->session_info.index_l1; + return_path = &(p_session->session_req.return_path); + + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_AUDIO_DRIVER_NOTIFICATION), + (T_RVF_BUFFER **) (&p_message)); + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for driver notification",RV_TRACE_LEVEL_ERROR); + return; + } + + /* Fill the message ID + parameters */ + ((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->header.msg_id = AUDIO_DRIVER_NOTIFICATION_MSG; + ((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->channel_id = channel_id; + ((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->p_buffer = NULL; + + /* send answer */ + if (return_path->callback_func == NULL) + rvf_send_msg (return_path->addr_id, p_message); + else + { + (*return_path->callback_func)((void *)(p_message)); + rvf_free_buf((T_RVF_BUFFER *)p_message); + } + + } +//NAVC start/stop/read energy +// Parameters :d_navc_start_stop_read // 1=start,2=stop,3=read energy +// UWORD32 d_navc_ctrl_status_energy_val +// 0=action not performed,1=action perf, xxx-value +// Description : this function will called to start/stop the NAVC and also to read the energy value during call +//The bit map of d_navc_ctrl_status is as follows. +// Bit 0: Start command: If 1 NAVC start. Set to 1 by MCU , Reset by DSp after module start Bit 1: Stop command : +// If 1 NAVC stop. Set to 1 by MCU , Reset by DSP after module stop. Bit 15: Status: Set and reset by DSP. If 1 +// module is active. If 0 module is not active. + + + UWORD32 Cust_navc_ctrl_status(UWORD8 d_navc_start_stop_read) + { + UWORD32 d_navc_ctrl_status_energy_val=0; + + switch (d_navc_start_stop_read) + { + case 1: /* Start NAVC */ + { + if((l1s_dsp_com.dsp_ndb_ptr->d_navc_ctrl_status & 0x8000)==0)l1s_dsp_com.dsp_ndb_ptr->d_navc_ctrl_status |= 0x01; //check 15th bit and if not active-put the last bit to 1 to start + d_navc_ctrl_status_energy_val=1; //indicates action performed + } + break; + case 2: /* Stop NAVC */ + { + if((l1s_dsp_com.dsp_ndb_ptr->d_navc_ctrl_status & 0x8000)==0x8000)l1s_dsp_com.dsp_ndb_ptr->d_navc_ctrl_status |= 0x02; //check 15th bit and if active-put the last bit to 1 to start + d_navc_ctrl_status_energy_val=1; //indicates action performed + } + break; + case 3: /* NAVC read energy */ + { + if((l1s_dsp_com.dsp_ndb_ptr->d_navc_ctrl_status & 0x8000) == 0x8000)//check 15th bit and if active- read the value-- + { + d_navc_ctrl_status_energy_val = l1s_dsp_com.dsp_ndb_ptr->d_vad_noise_ene_ndb[0]; //MSB part + d_navc_ctrl_status_energy_val= (d_navc_ctrl_status_energy_val<<16)|(l1s_dsp_com.dsp_ndb_ptr->d_vad_noise_ene_ndb[1]); //MSB <<16 | LSB - indicates the energy value + } + } + break; + /*intended fall through */ + default: + break; + + + } +#if (L1_NAVC_TRACE == 1) //to see the NAVC trace + l1_trace_navc(d_navc_start_stop_read,d_navc_ctrl_status_energy_val); +#endif + + return (d_navc_ctrl_status_energy_val); + } +#endif + +#endif // AUDIO_TASK== 1
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/audio_include/l1audio_proto.h Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,27 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_PROTO.H + * + * Filename l1audio_proto.h + * Copyright 2004 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +#if (AUDIO_TASK == 1) + +#ifndef _L1AUDIO_PROTO_H_ +#define _L1AUDIO_PROTO_H_ + +// Functions declared in l1audio_afunc.c +void l1a_audio_send_confirmation(UWORD32 SignalCode); + +void l1a_audio_send_result (UWORD32 SignalCode, xSignalHeaderRec *msg, UWORD8 queue); +#if (SPEECH_RECO) +void l1_send_sr_background_msg (UWORD32 SignalCode); +#endif +#if (MELODY_E2) +void l1_send_melody_e2_background_msg(UWORD32 SignalCode, UWORD8 melody_id); +#endif +#endif // _L1AUDIO_PROTO_H_ + +#endif // AUDIO_TASK
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/tm_cfile/l1tm_async.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,2761 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1TM_ASYNC.C + * + * Filename l1tm_async.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +#include "l1_macro.h" +#include "l1_confg.h" + +#if TESTMODE + #define L1TM_ASYNC_C + + #include <string.h> + #include <stdlib.h> + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + #include "l1_time.h" + #include "l1_signa.h" + #include "cust_os.h" + + #include "l1tm_defty.h" + + #if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #include "l1audio_signa.h" + #include "l1audio_proto.h" + #endif + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + + #include "l1_defty.h" + #include "l1_msgty.h" + #include "l1_varex.h" + #include "l1_proto.h" + + #include "l1tm_msgty.h" + #include "l1tm_signa.h" + #include "l1tm_varex.h" + + #if (L1_STEREOPATH == 1) + #include "sys_dma.h" + #include "l1audio_stereo.h" + #endif + + #if L1_GPRS + #include "l1p_cons.h" + #include "l1p_msgt.h" + #include "l1p_deft.h" + #include "l1p_vare.h" + #include "l1p_sign.h" + #endif + + /* FreeCalypso TCS211 reconstruction */ + #define ETM_PROTOCOL 0 + #define ETM_MODE 0 + +//------------------------------------ +// Prototypes from external functions +//------------------------------------ +#if (OP_L1_STANDALONE == 1) + void etm_core(xSignalHeaderRec *msg); +#endif + + void Cust_tm_init(void); + + void l1tm_stats_fb_confirm (T_TMODE_FB_CON *prim, WORD32 test); + void l1tm_stats_sb_confirm (T_TMODE_NCELL_SYNC_IND *prim, WORD32 test); + void l1tm_stats_bcch_confirm (T_TMODE_BCCHS_CON *prim); + void l1tm_stats_tch_confirm (T_TMODE_TCH_INFO *prim); + void l1tm_stats_mon_confirm (T_TMODE_FB_CON *prim); + void l1tm_stats_full_list_meas_confirm(T_TMODE_RXLEV_REQ *prim); + BOOL l1tm_is_rx_counter_done (void); + void l1tm_reset_rx_state (void); + + void l1tm_rf_param_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_rf_param_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_rf_table_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_rf_table_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_rx_param_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_rx_param_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_tx_param_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_tx_param_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_tx_template_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_tx_template_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + + void l1tm_special_param_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_special_param_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_special_table_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_special_table_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_special_enable (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_rf_enable (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_stats_config_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_stats_config_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_statistics (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_stats_read (T_TM_RETURN *tm_return, WORD16 type, UWORD16 bitmask); + #if (L1_DRP == 1) + void l1tm_drp_sw_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + #endif + + + void l1a_tmode_send_ul_msg (T_TM_RETURN *tm_ret); + UWORD16 l1tm_convert_arfcn2l1ch(UWORD16 arfcn, UWORD8 *error_flag); + void l1tm_fill_burst (UWORD16 pattern, UWORD16 *TM_ul_data); + void l1tm_initialize_var (void); + UWORD16 Convert_l1_radio_freq (SYS_UWORD16 radio_freq); + + void tm_transmit(T_TM_RETURN *tm_ret); + + #if (CODE_VERSION != SIMULATION) + void l1tm_tpu_table_write (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + void l1tm_tpu_table_read (T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return); + #endif + + #if L1_GPRS + T_TRANSFER_SET *l1pa_get_free_transfer_set (UWORD8 new_tbf); + T_CRES_LIST_PARAM *l1pa_get_free_cres_list_set(void); + void l1tm_stats_pdtch_confirm (T_TMODE_PDTCH_INFO *prim); + #endif + + + #if (L1_TPU_DEV == 1) + void l1tm_flexi_tpu_table_read(T_TESTMODE_PRIM * prim, T_TM_RETURN * tm_return); + void l1tm_flexi_tpu_table_write(T_TESTMODE_PRIM * prim, T_TM_RETURN * tm_return); + +//Flexi ABB Delay + void l1tm_flexi_abb_read(T_TESTMODE_PRIM * prim, T_TM_RETURN * tm_return); + void l1tm_flexi_abb_write(T_TESTMODE_PRIM * prim, T_TM_RETURN * tm_return); + #endif + +// DRP Calibration + void l1tm_drp_calib_read(T_TESTMODE_PRIM * prim, T_TM_RETURN * tm_return); + void l1tm_drp_calib_write(T_TESTMODE_PRIM * prim, T_TM_RETURN * tm_return); + + // Prototypes from internal functions + //------------------------------------ + void l1a_tmode_fb0_process(xSignalHeaderRec *msg); + void l1a_tmode_fb1_process(xSignalHeaderRec *msg); + void l1a_tmode_sb_process(xSignalHeaderRec *msg); + void l1a_tmode_bcch_reading_process(xSignalHeaderRec *msg); + void l1a_tmode_dedicated_process(xSignalHeaderRec *msg); + void l1a_tmode_access_process(xSignalHeaderRec *msg); + void l1a_tmode_full_list_meas_process(xSignalHeaderRec *msg); + + #if L1_GPRS + void l1a_tmode_transfer_process(xSignalHeaderRec *msg); + #endif + #if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) + void l1a_tmode_audio_stereopath_process(xSignalHeaderRec *msg); + extern void l1tm_stereopath_DMA_handler(SYS_UWORD16 dma_status); + extern void l1tm_stereopath_fill_buffer(void* buffer_address); + extern UWORD16 l1tm_stereopath_get_pattern(UWORD16 sampling_freq, UWORD16 sin_freq_left,UWORD16 sin_freq_right, UWORD8 data_type); + extern void l1a_audio_send_confirmation(UWORD32 SignalCode); + extern void l1_trigger_api_interrupt(void); +#if ( ANLG_FAM == 11) + //Add the two new sampling frequencies in the test mode for Locosto - 12khz and 24 khz + const UWORD16 l1tm_stereopath_sampling_freqs[9] = {8000,11025,12000,16000,22050,24000,32000,44100,48000}; +#else + const UWORD16 l1tm_stereopath_sampling_freqs[8] = {48000,0,44100,32000,22050,16000,11025,8000}; +#endif + const UWORD16 l1tm_stereopath_sin_freqs[4][2] = {{0,0}, + {100,1000}, + {1000,10000}, + {1000,1000}}; // 4 different pattern of two freqs + const UWORD16 l1tm_stereopath_buffer[(480+1)*2]; + + T_STP_DRV_MCU_DSP *stp_drv_ndb = (T_STP_DRV_MCU_DSP *)API_address_dsp2mcu(C_STP_DRV_API_BASE_ADDRESS); + +#if (CODE_VERSION == NOT_SIMULATION) + #pragma DATA_SECTION(TM_stereo_buf,".TM_stereo_buf"); +#endif + +#if (CHIPSET == 15) + #pragma DATA_SECTION(TM_stereo_buf_ext_mem, ".TM_stereo_buf_ext_mem"); +#endif + volatile WORD16 TM_stereo_buf[STEREOPATH_MAX_NB_OF_FRAMES*2]; +#if (CHIPSET == 15) + volatile WORD16 TM_stereo_buf_ext_mem[STEREOPATH_MAX_NB_OF_FRAMES*2]; +#endif + #endif // ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) + +/***********************************************************************/ +/* TESTMODE 3.X */ +/***********************************************************************/ + + // omaps00090550 static UWORD8 tx_param_band=0; // used in tx_param_write/read; default is GSM900 +/*-----------------------------------------------------------*/ +/* l1a_tmode() */ +/*-----------------------------------------------------------*/ +/* Description : State machine controls TestMode processes */ +/* */ +/* Starting messages: TMODE_BCCH_REQ */ +/* TMODE_PM_REQ */ +/* TMODE_FB0_REQ */ +/* TMODE_FB1_REQ */ +/* TMODE_SB_REQ */ +/* */ +/* */ +/* Result messages (input): L1_TMODE_MEAS_REPORT */ +/* L1_SB_INFO */ +/* L1_BCCHS_INFO */ +/* */ +/* Result messages (output): TMODE_PM_CON */ +/* MPH5_NCELL_SB_IND */ +/* */ +/* Reset messages (input): MPH5_STOP_BCCH_READING */ +/* */ +/*-----------------------------------------------------------*/ +void l1a_tmode(xSignalHeaderRec *msg) +{ + T_TESTMODE_PRIM *prim; + T_TM_RETURN tm_ret; + + int SignalCode = msg->SignalCode; + +#if (OP_WCP==1) && (OP_L1_STANDALONE!=1) + // Security check for Operating System platforms (open platforms) + // We forbid TESTMODE if the phone is running with an OS + // so users can not invoke TESTMODE for malicious goals + extern unsigned long GC_RunningWithOs(); + + if(GC_RunningWithOs()) + return; +#endif + + if (SignalCode == TESTMODE_PRIM) + { + // use CID to decide what to do + prim = (T_TESTMODE_PRIM *)(msg->SigP); + + // fill in the cid also named fid in the ETM protocol + tm_ret.cid = prim->cid; + + switch (prim->cid) + { + case TM_INIT: + l1tm_initialize(&tm_ret); + break; + case TM_MODE_SET: + l1tm_mode_set(prim, &tm_ret); + break; + case VERSION_GET: + l1tm_version_get(prim, &tm_ret); + break; + case RF_ENABLE: + l1tm_rf_enable(prim, &tm_ret); + break; + case STATS_READ: + l1tm_statistics(prim, &tm_ret); + break; + case STATS_CONFIG_WRITE: + l1tm_stats_config_write(prim, &tm_ret); + break; + case STATS_CONFIG_READ: + l1tm_stats_config_read(prim, &tm_ret); + break; + case RF_PARAM_WRITE: + l1tm_rf_param_write(prim, &tm_ret); + break; + case RF_PARAM_READ: + l1tm_rf_param_read(prim, &tm_ret); + break; + case RF_TABLE_WRITE: + l1tm_rf_table_write(prim, &tm_ret); + break; + case RF_TABLE_READ: + l1tm_rf_table_read(prim, &tm_ret); + break; + case RX_PARAM_WRITE: + l1tm_rx_param_write(prim, &tm_ret); + break; + case RX_PARAM_READ: + l1tm_rx_param_read(prim, &tm_ret); + break; + case TX_PARAM_WRITE: + l1tm_tx_param_write(prim, &tm_ret); + break; + case TX_PARAM_READ: + l1tm_tx_param_read(prim, &tm_ret); + break; + case TX_TEMPLATE_WRITE: + l1tm_tx_template_write(prim, &tm_ret); + break; + case TX_TEMPLATE_READ: + l1tm_tx_template_read(prim, &tm_ret); + break; + case MEM_WRITE: + l1tm_mem_write(prim, &tm_ret); + break; + case MEM_READ: + l1tm_mem_read(prim, &tm_ret); + break; + case CODEC_WRITE: + l1tm_codec_write(prim, &tm_ret); + break; + case CODEC_READ: + l1tm_codec_read(prim, &tm_ret); + break; + case MISC_PARAM_WRITE: + l1tm_misc_param_write(prim, &tm_ret); + break; + case MISC_PARAM_READ: + l1tm_misc_param_read(prim, &tm_ret); + break; + case MISC_ENABLE: + l1tm_misc_enable(prim, &tm_ret); + break; + case SPECIAL_PARAM_WRITE: + l1tm_special_param_write(prim, &tm_ret); + break; + case SPECIAL_PARAM_READ: + l1tm_special_param_read(prim, &tm_ret); + break; + case SPECIAL_TABLE_WRITE: + l1tm_special_table_write(prim, &tm_ret); + break; + case SPECIAL_TABLE_READ: + l1tm_special_table_read(prim, &tm_ret); + break; + case SPECIAL_ENABLE: + l1tm_special_enable(prim, &tm_ret); + break; + #if (L1_DRP == 1) + case DRP_SW_WRITE: + l1tm_drp_sw_write(prim, &tm_ret); + break; + #endif + #if (CODE_VERSION != SIMULATION) + case TPU_TABLE_WRITE: + l1tm_tpu_table_write(prim, &tm_ret); + break; + case TPU_TABLE_READ: + l1tm_tpu_table_read(prim, &tm_ret); + break; + #endif + case TM_FFS: + l1tm_ffs(prim, &tm_ret); + break; + #if(L1_TPU_DEV == 1) + case FLEXI_TPU_TABLE_WRITE: + l1tm_flexi_tpu_table_write(prim, &tm_ret); + break; + case FLEXI_TPU_TABLE_READ: + l1tm_flexi_tpu_table_read(prim, &tm_ret); + break; + case FLEXI_ABB_WRITE: + l1tm_flexi_abb_write(prim, &tm_ret); + break; + case FLEXI_ABB_READ: + l1tm_flexi_abb_read(prim, &tm_ret); + break; + #endif + #if 0 //(CODE_VERSION != SIMULATION) // FreeCalypso TCS211 reconstruction + case DRP_CALIB_WRITE: + l1tm_drp_calib_write(prim, &tm_ret); + break; + case DRP_CALIB_READ: + l1tm_drp_calib_read(prim, &tm_ret); + break; // TBD for Future Use + #endif // CODE_VERSION + default: + #if (OP_L1_STANDALONE == 1) + etm_core(msg); + return; + #else + tm_ret.size = 0; + #if (ETM_PROTOCOL == 1) + tm_ret.status = -ETM_BADOP; + #else + tm_ret.status = E_BADCID; + #endif + #endif // OP_L1_STANDALONE + break; + } // end of switch + tm_transmit(&tm_ret); + } //end of TESTMODE_PRIM + #if L1_GPRS + else if ( ((SignalCode <= TMODE_PDTCH_INFO) && (SignalCode >= TMODE_RXLEV_REQ)) || (l1tm.tm_msg_received == TRUE) ) + #else + else if ( ((SignalCode <= TMODE_TCH_INFO) && (SignalCode >= TMODE_RXLEV_REQ)) || (l1tm.tm_msg_received == TRUE) ) + #endif + { + #if (CODE_VERSION == SIMULATION) + static BOOL tm_init = FALSE; + + if (! tm_init) + { + Cust_tm_init(); + l1tm_initialize_var(); + l1_config.TestMode = 1; + tm_init=TRUE; + } + #endif + l1a_tmode_fb0_process(msg); + l1a_tmode_fb1_process(msg); + l1a_tmode_sb_process(msg); + l1a_tmode_bcch_reading_process(msg); + l1a_tmode_dedicated_process(msg); + l1a_tmode_access_process(msg); + l1a_tmode_full_list_meas_process(msg); + #if L1_GPRS + l1a_tmode_transfer_process(msg); + #endif + #if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) + l1a_tmode_audio_stereopath_process(msg); + #endif + } //end of not TESTMODE_PRIM +} // end of procedure. + + +/*-------------------------------------------------------*/ +/* l1a_tmode_fb0_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles the 1st */ +/* synchronization with the network in Test Mode. */ +/* */ +/* Starting messages: TMODE_FB0_REQ */ +/* */ +/* Result messages (input): L1C_FB_INFO */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_fb0_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, // Reset state. + WAIT_INIT = 1, // Initial state. + SET_FS_FB_MODE0 = 2, // First Synchro, Setting of 1st FB mode 0. + WAIT_FS_FB_MODE0 = 3 // First Synchro, 1st FB mode 0 state. + }; + + UWORD8 *state = &l1a.state[TMODE_FB0]; + UWORD32 SignalCode = msg->SignalCode; + BOOL done = 0; + +#if (VCXO_ALGO == 1) + #define FS_FB_MODE0_CENTER 1 + #define FS_FB_MODE0_MAX 2 + #define FS_FB_MODE0_MIN 3 + + static WORD16 state_vcxo; + static WORD16 static_attempt_counter; +#endif + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + +#if (VCXO_ALGO == 1) + if(l1_config.params.eeprom_afc == 0) { + // Go to the initial VCXO AFC_INIT algorithm state + state_vcxo = FS_FB_MODE0_CENTER; + static_attempt_counter = 0; + } +#endif + + // Reset tasks used in the process. + l1a_l1s_com.l1s_en_task[FBNEW] = TASK_DISABLED; // in tmode, not ALR + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; + + } + break; + + case WAIT_INIT: + { + if (SignalCode == TMODE_FB0_REQ) + { + #if (CODE_VERSION == SIMULATION) + l1tm_reset_rx_state(); + #endif + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + // Set task semaphores. + l1a_l1s_com.task_param[FBNEW] = SEMAPHORE_SET; // Set "parameter synchro semaphore for FB task. + l1a_l1s_com.task_param[NSYNC] = SEMAPHORE_SET; // Set "parameter synchro semaphore for FB task. + + l1a_l1s_com.nsync.current_list_size = 0; + + // Downlink stuff timeslot is 0 (default in CS) + l1a_l1s_com.dl_tn = 0; + + // Set arfcn + l1a_l1s_com.nsync.list[0].radio_freq =l1_config.tmode.rf_params.bcch_arfcn; + + //Set timing validity for FB no a priori info + l1a_l1s_com.nsync.list[0].timing_validity = 0; + + // Reset offset and time alignment + l1a_l1s_com.nsync.list[0].fn_offset = 0; + l1a_l1s_com.nsync.list[0].time_alignmt = 0; + + // Set functional mode. + l1a_l1s_com.mode = CS_MODE; //Needs to be set for l1ddsp_load_monit_task() + + // Wideband search for FB detection. + l1a_l1s_com.fb_mode = FB_MODE_0; + + // Enable SYNCHRO task to cleanup the MFTAB. + l1a_l1s_com.l1s_en_task[SYNCHRO] = TASK_ENABLED; + + // Initialize AFC control function. + #if AFC_ALGO + if (l1_config.afc_enable) { // l1_config.TestMode MUST == 1 + #if (VCXO_ALGO == 1) + // The TM rfpw 10 parameter has a different meaning when using + // a VCXO. Instead of containing the AFC used for the FB0, which + // is stored in the rftw 9 table now, it tells the TM which "state" must + // be used for the VCXO algorithm + // + switch(l1_config.params.eeprom_afc) { + case 0: // Full VCXO algo + // The AFC_INIT state is controlled by the state machine + // Reset attempt counter + static_attempt_counter = 0; + state_vcxo = FS_FB_MODE0_CENTER; + break; + case FS_FB_MODE0_CENTER * 8: + state_vcxo = FS_FB_MODE0_CENTER; + break; + case FS_FB_MODE0_MIN * 8: + state_vcxo = FS_FB_MODE0_MIN; + break; + case FS_FB_MODE0_MAX * 8: + state_vcxo = FS_FB_MODE0_MAX; + break; + default: + state_vcxo = FS_FB_MODE0_CENTER; + } + #endif + } + #endif + + // Step in state machine + *state = SET_FS_FB_MODE0; + } + else + { + // End of process. + return; + } + } + break; + + case SET_FS_FB_MODE0: + { + // Step in state machine. + *state = WAIT_FS_FB_MODE0; + + // Enable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_PENDING; //Used by l1s_schedule_tasks in l1_sync + + // Enable NSYNC task for FB detection mode 0. + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_ENABLED; + if (l1_config.afc_enable) {// l1_config.TestMode MUST == 1 + #if (VCXO_ALGO == 1) + switch(state_vcxo) { + case FS_FB_MODE0_CENTER: + l1s.afc = l1ctl_afc(AFC_INIT_CENTER, &l1s.afc_frame_count, NULL, 0, l1a_l1s_com.nsync.list[0].radio_freq,l1a_l1s_com.mode); + break; + case FS_FB_MODE0_MIN: + l1s.afc = l1ctl_afc(AFC_INIT_MIN, &l1s.afc_frame_count, NULL, 0, l1a_l1s_com.nsync.list[0].radio_freq,l1a_l1s_com.mode); + break; + case FS_FB_MODE0_MAX: + l1s.afc = l1ctl_afc(AFC_INIT_MAX, &l1s.afc_frame_count, NULL, 0, l1a_l1s_com.nsync.list[0].radio_freq,l1a_l1s_com.mode); + break; + default: + l1s.afc = l1ctl_afc(AFC_INIT_CENTER, &l1s.afc_frame_count, NULL, 0, l1a_l1s_com.nsync.list[0].radio_freq,l1a_l1s_com.mode); + } + #else + l1s.afc = l1ctl_afc(AFC_INIT, &l1s.afc_frame_count, l1_config.params.eeprom_afc, 0, l1a_l1s_com.nsync.list[0].radio_freq); + #endif + } // (l1_config.afc_enable) is TRUE + + // End of process. + end_process = 1; + } + break; + + case WAIT_FS_FB_MODE0: + { + if(SignalCode == L1C_FB_INFO) + // Frequency Burst acquisition result. + //------------------------------------ + { + BOOL fb_found = ((T_L1C_FB_INFO *) (msg->SigP))->fb_flag; + + if (fb_found) + { + // We consider the result of this successfull FB search attempt + // as a good a-priori information for next attempt. + // "fn_offset" is reversed to satisfy its definition, + // fn_offset = Fn_neigh - Fn_serving. + l1a_l1s_com.nsync.list[0].timing_validity = 1; + l1a_l1s_com.nsync.list[0].fn_offset = 51 - l1a_l1s_com.nsync.list[0].fn_offset; + } +#if (VCXO_ALGO == 1) + else + { + if(l1_config.params.eeprom_afc == 0) + { + //- Full VCXO algo + + // Increment "static_attempt_counter". + static_attempt_counter++; + if(static_attempt_counter < 4) + { + // Max number of attemps not reached yet... + // try again with the same VCXO state + *state = SET_FS_FB_MODE0; + // Do not accumulate the statistics yet, just try again + break; + } + else + { + // Max number of attempt is reached... go back to 1st FB mode 0. + // Step in state machine. + static_attempt_counter = 0; + + // Go to the next FS_FB_MODE0_CENTER state (CENTER -> MAX -> MIN) + // After MIN go to CENTER again, which means that the attempt failed + switch(state_vcxo) + { + case FS_FB_MODE0_CENTER: + state_vcxo = FS_FB_MODE0_MAX; + break; + case FS_FB_MODE0_MAX: + state_vcxo = FS_FB_MODE0_MIN; + break; + default: // i.e. case FS_FB_MODE0_MAX: + // The algorithm tried all the AFC_INIT values (CENTER, MAX & MIN) + // but did not detect an FB in any of the attemps for these values: + // The current attempt FAILED => Continue and accumulate the statistics + state_vcxo = FS_FB_MODE0_CENTER; + break; + } + + if (state_vcxo != FS_FB_MODE0_CENTER) + { + *state = SET_FS_FB_MODE0; + // Do not accumulate the statistics yet, just try again with the new + // selected state_vcxo + break; // This breaks from the switch(*state), and thus re-loops thanks to the while(!end_process) + } // (state_vcxo != FS_FB_MODE0_CENTER) + } // (static_attempt_counter >= 4) + } // (l1_config.params.eeprom_afc != 0) + } // (fb_found) is FALSE +#endif + +#if (VCXO_ALGO == 1) + if(l1_config.params.eeprom_afc == 0) + { + // If we got this far, the attempt ended (with a fail or a success) + // So we can go back to the initial state + state_vcxo = FS_FB_MODE0_CENTER; + } +#endif + + //accumulate FB stats + l1tm_stats_fb_confirm( (T_TMODE_FB_CON*) ((T_L1C_FB_INFO *) (msg->SigP)), 0); + + done = l1tm_is_rx_counter_done(); + if (done == 1) + { + // Loop counter expired, stop the test + *state = RESET; + + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + break; // break out of switch + } + *state = SET_FS_FB_MODE0; + } + else if (SignalCode == TMODE_STOP_RX_TX) + // Stop SYNC mode message. + //-------------------------------- + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Step in state machine. + *state = RESET; + + return; + } + else + { + // End of process. + return; + } + } + break; + } + } +} + + +/*-------------------------------------------------------*/ +/* l1a_tmode_fb1_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles the 1st */ +/* synchronization with the network in Test Mode. */ +/* */ +/* Starting messages: TMODE_FB1_REQ */ +/* */ +/* Result messages (input): L1C_FB_INFO */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_fb1_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, // Reset state. + WAIT_INIT = 1, // Initial state. + SET_FS_FB_MODE1 = 2, // First Synchro, Setting of 1st FB mode 1. + WAIT_FS_FB_MODE1 = 3 // First Synchro, FB mode 1 state. + }; + + UWORD8 *state = &l1a.state[TMODE_FB1]; + UWORD32 SignalCode = msg->SignalCode; + BOOL done = 0; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset of tasks used in this process is carried out in WAIT_FS_FBMODE1 state + // Otherwise we would possibly reset the task set by l1a_tmode_fb0_process() + } + break; + + case WAIT_INIT: + { + if (SignalCode == TMODE_FB1_REQ) + { + #if (CODE_VERSION == SIMULATION) + l1tm_reset_rx_state(); + #endif + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + // Set task semaphores. + l1a_l1s_com.task_param[FBNEW] = SEMAPHORE_SET; // Set "parameter synchro semaphore for FB task. + l1a_l1s_com.task_param[NSYNC] = SEMAPHORE_SET; // Set "parameter synchro semaphore for FB task. + + // Downlink stuff timeslot is 0 (default in CS) + l1a_l1s_com.dl_tn = 0; + + // Set arfcn + l1a_l1s_com.nsync.list[0].radio_freq =l1_config.tmode.rf_params.bcch_arfcn; + + // Set functional mode. + l1a_l1s_com.mode = CS_MODE; //Needs to be set for l1ddsp_load_monit_task() + + // Set FB detection mode. + l1a_l1s_com.fb_mode = FB_MODE_1; + + // Step in state machine + *state = SET_FS_FB_MODE1; + } + else + { + // End of process. + return; + } + } + break; + + case SET_FS_FB_MODE1: + { + // Step in state machine. + *state = WAIT_FS_FB_MODE1; + + // Enable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_PENDING; + + // Enable NSYNC task for FB detection mode 1. + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_ENABLED; + + // End of process. + end_process = 1; + } + break; + + case WAIT_FS_FB_MODE1: + { + // Use incoming message. + //---------------------- + if(SignalCode == L1C_FB_INFO) + { + //accumulate FB stats + l1tm_stats_fb_confirm( (T_TMODE_FB_CON*) ((T_L1C_FB_INFO *) (msg->SigP)), 0); + + // increment counter + done = l1tm_is_rx_counter_done(); + + if (done == 1) + { + // Loop counter expired, stop the test + *state = RESET; + + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Reset tasks used in the process. + l1a_l1s_com.l1s_en_task[FBNEW] = TASK_DISABLED; // in tmode, not ALR + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; + + break; // break out of switch + } + + *state = SET_FS_FB_MODE1; + } // end if L1C_FB_INFO + else if (SignalCode == TMODE_STOP_RX_TX) + // Stop SYNC mode message. + //-------------------------------- + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Step in state machine. + *state = RESET; + + return; + } + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + return; + } + } + break; + } + } +} + + +/*-------------------------------------------------------*/ +/* l1a_tmode_sb_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles the 1st */ +/* synchronization with the network in Test Mode. */ +/* */ +/* Starting messages: TMODE_SB_REQ */ +/* */ +/* Result messages (input): L1C_SB_INFO */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_sb_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, // Reset state. + WAIT_INIT = 1, // Initial state. + SET_FS_SB = 2, // Set SB + WAIT_FS_SB = 3, // Wait for SB result + NEW_SYNCHRO = 4 // Camp on cell + }; + + UWORD8 *state = &l1a.state[TMODE_SB]; + UWORD32 SignalCode = msg->SignalCode; + BOOL done = 0; + + static UWORD8 static_bsic; + static UWORD32 static_fn_offset; + static UWORD32 static_time_alignmt; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset of tasks used in this process is carried out in WAIT_FS_SB state + // Otherwise we would possibly reset the NSYNC task set by l1a_tmode_fb0_process() + // or l1a_tmode_fb1_process + } + break; + + case WAIT_INIT: + { + if (SignalCode == TMODE_SB_REQ) + { + #if (CODE_VERSION == SIMULATION) + l1tm_reset_rx_state(); + #endif + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + // Set arfcn + l1a_l1s_com.nsync.list[0].radio_freq =l1_config.tmode.rf_params.bcch_arfcn; + + // Enable NSYNC task for SB detection (SB2). + #if ((REL99 == 1) && ((FF_BHO == 1) || (FF_RTD == 1))) + l1a_l1s_com.nsync.list[0].timing_validity = SB_ACQUISITION_PHASE ; + #else + l1a_l1s_com.nsync.list[0].timing_validity = 3; + #endif + + // Step in state machine + *state = SET_FS_SB; + } + else + { + // End of process. + return; + } + } + break; + + case SET_FS_SB: + { + // Step in state machine. + *state = WAIT_FS_SB; + + // Enable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_PENDING; + + // Enable NSYNC task for SB detection. + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_ENABLED; + + // End of process. + end_process = 1; + } + break; + + case WAIT_FS_SB: + { + // Use incoming message. + //---------------------- + if(SignalCode == L1C_SB_INFO) + { + UWORD8 sb_found = ((T_MPHC_NCELL_SYNC_IND *)(msg->SigP))->sb_flag; + UWORD8 bsic = ((T_MPHC_NCELL_SYNC_IND *)(msg->SigP))->bsic; + + if(sb_found == TRUE) + // SB detection is a success... + //----------------------------- + { + // Save Results. + static_bsic = ((T_MPHC_NCELL_SYNC_IND *)(msg->SigP))->bsic; + static_fn_offset = ((T_MPHC_NCELL_SYNC_IND *)(msg->SigP))->fn_offset; + static_time_alignmt = ((T_MPHC_NCELL_SYNC_IND *)(msg->SigP))->time_alignmt; + } + + l1tm_stats_sb_confirm( (T_TMODE_NCELL_SYNC_IND*) ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP)), 0); + + // if just an SB test, increment counter + // if not done, just stay in this state, schedule a new attempt + done = l1tm_is_rx_counter_done(); + + if (done == 1) + { + // step in state machine + *state = NEW_SYNCHRO; + + // Reset NSYNC task and SB2 task enable flags. + l1a_l1s_com.l1s_en_task[SB2] = TASK_DISABLED; // in tmode, not ALR + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; + + // Save results. + l1a_l1s_com.nsync.list[0].fn_offset = static_fn_offset; + l1a_l1s_com.nsync.list[0].time_alignmt = static_time_alignmt; + + // Correct "ntdma" and "time_alignment" to shift 20 bit to the + // future for Normal Burst reading tasks. + l1a_add_time_for_nb(&l1a_l1s_com.nsync.list[0].time_alignmt, + &l1a_l1s_com.nsync.list[0].fn_offset); + + break; // break out of switch + } + else + // Make a new SB attempt + { + l1a_l1s_com.nsync.list[0].status = NSYNC_PENDING; + + // End of process. + end_process = 1; + } + } + else if (SignalCode == TMODE_STOP_RX_TX) + // Stop SYNC mode message. + //-------------------------------- + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Step in state machine. + *state = RESET; + + end_process = 1; + } + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + end_process = 1; + } + }//End Case WAIT_FS_SB + break; + + case NEW_SYNCHRO: + { + // Reset the Neighbor Cell information structure. + l1a_reset_cell_info(&(l1a_l1s_com.Scell_info)); + + // STILL SAVING TSC WITHIN BSIC !!!!!!!!!!!!!!!! + + // Download ARFCN, timing information and bitmap from the command message. + l1a_l1s_com.Scell_info.radio_freq = l1_config.tmode.rf_params.bcch_arfcn; + l1a_l1s_com.Scell_info.bsic = static_bsic; + l1a_l1s_com.Scell_info.time_alignmt = l1a_l1s_com.nsync.list[0].time_alignmt; + l1a_l1s_com.Scell_info.fn_offset = l1a_l1s_com.nsync.list[0].fn_offset; + + // tn_difference -> loaded with the number of timeslot to shift. + // dl_tn -> loaded with the new timeslot. + l1a_l1s_com.tn_difference = 0 - l1a_l1s_com.dl_tn; + l1a_l1s_com.dl_tn = 0; // Camping on timeslot 0. + + // Layer 1 internal mode is set to IDLE MODE. + l1a_l1s_com.mode = I_MODE; + + // Set flag for toa init. + #if (TOA_ALGO != 0) + l1a_l1s_com.toa_reset = TRUE; + #endif + + // Enable SYNCHRO tasks. + l1a_l1s_com.l1s_en_task[SYNCHRO] = TASK_ENABLED; + + // Step in state machine. + *state = RESET; + + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + } + break; // break out of switch + // omaps00090550 break; + } + } +} + +/*-------------------------------------------------------*/ +/* l1a_tmode_bcch_reading_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles serving cell */ +/* BCCH reading in Test Mode. */ +/* */ +/* This process happens for a TestMode BCCH test, after */ +/* completing FB's and SB's in */ +/* l1a_tmode_initial_network_sync_process, */ +/* and then passing through l1a_tmode_cres_process, */ +/* */ +/* OR */ +/* */ +/* it can also happen for a TestMode TCH with synch */ +/* test where, FB's and SB's have already been detected, */ +/* and 4 BCCH's will be received before moving to the */ +/* TCH and dedicated mode. */ +/* */ +/* */ +/* Starting messages: TMODE_SCELL_NBCCH_REQ */ +/* ------------------ */ +/* */ +/* */ +/* Result messages (input): L1C_BCCHS_INFO */ +/* ------------------------ */ +/* System information data block from L1S. */ +/* */ +/* */ +/* Reset messages (input): TMODE_STOP_SCELL_BCCH_REQ */ +/* ----------------------- */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_bcch_reading_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + NBCCHS_CONFIG = 2, + WAIT_BCCHS_RESULT = 3 + }; + + UWORD8 *state = &l1a.state[TMODE_BCCH]; + UWORD32 SignalCode = msg->SignalCode; + BOOL done = 0; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset CS_MEAS process. + l1a_l1s_com.l1s_en_task[NBCCHS] = TASK_DISABLED; // Clear NBCCHS task enable flag. + //l1a_l1s_com.l1s_en_task[EBCCHS] = TASK_DISABLED; // Clear EBCCHS task enable flag. + } + break; + + case WAIT_INIT: + { + if(SignalCode == TMODE_SCELL_NBCCH_REQ) + { + + #if (CODE_VERSION == SIMULATION) + l1tm_reset_rx_state(); + #endif + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + // Request to read Normal BCCH from serving cell. + l1a_l1s_com.Scell_info.radio_freq = l1_config.tmode.rf_params.bcch_arfcn; + + // Step in state machine. + *state = NBCCHS_CONFIG; + } + + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + return; + } + } + break; + + case NBCCHS_CONFIG: + { + UWORD8 i; + + // Set semaphores for Normal Serving BCCH reading task. + l1a_l1s_com.task_param[NBCCHS] = SEMAPHORE_SET; + + // Download message content. + //-------------------------- + l1a_l1s_com.nbcchs.schedule_array_size = 1; + + for(i=0;i<l1a_l1s_com.nbcchs.schedule_array_size;i++) + { + l1a_l1s_com.nbcchs.schedule_array[i].modulus = 1; + l1a_l1s_com.nbcchs.schedule_array[i].relative_position = 0; + } + + // Enable NBCCHS task. + l1a_l1s_com.l1s_en_task[NBCCHS] = TASK_ENABLED; + + // Step in state machine. + *state = WAIT_BCCHS_RESULT; + + // End of process. + end_process = 1; + } + break; + + case WAIT_BCCHS_RESULT: + { + if(SignalCode == L1C_BCCHS_INFO) + // Serving cell BCCH reading result. + //---------------------------------- + { + // this function takes care of loops management + l1tm_stats_bcch_confirm( (T_TMODE_BCCHS_CON*) ((T_MPHC_DATA_IND *)(msg->SigP)) ); + + done = l1tm_is_rx_counter_done(); + + if (done == 1) + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // This process must be reset. + *state = RESET; + + break; + } + else + { + // End of process. + end_process = 1; + } + } + else if (SignalCode == TMODE_STOP_RX_TX) + // Stop BCCH mode message. + //-------------------------------- + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Step in state machine. + *state = RESET; + + end_process = 1; + } + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + end_process = 1; + } + } + break; + } // end of "switch". + } // end of "while" +} // end of procedure. + +/*-------------------------------------------------------*/ +/* l1a_tmode_dedicated_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles the dedicated*/ +/* mode setup in Test Mode (L1A side). */ +/* */ +/* Starting messages: TMODE_IMMED_ASSIGN_REQ */ +/* */ +/* Subsequent messages: */ +/* */ +/* Result messages (input): L1C_DEDIC_DONE */ +/* */ +/* Result messages (output): */ +/* */ +/* Reset messages (input): TMODE_STOP_RX_TX */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_dedicated_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_MSG = 2 + }; + + T_DEDIC_SET *free_set; + UWORD8 *state = &l1a.state[TMODE_DEDICATED]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + l1a_l1s_com.l1s_en_task[FB26] = TASK_DISABLED; // Reset FB26 task enable flag. + + // Reset D_NMEAS process. + l1a_l1s_com.l1s_en_meas &= D_BAMS_MEAS_MASK; // Reset D_BAMS Measurement enable flag. + l1a.l1a_en_meas[D_NMEAS] &= D_BAMS_MEAS_MASK; + + // Reset L1S dedicated mode manager trigger. + l1a_l1s_com.dedic_set.SignalCode = NULL; + } + break; + + case WAIT_INIT: + { + switch(SignalCode) + // switch on input message. + //------------------------------- + { + case TMODE_IMMED_ASSIGN_REQ: + // Immediate assignement message. + //------------------------------- + { + UWORD8 maio_bef_sti; +#if(L1_FF_MULTIBAND == 1) + UWORD8 operative_radio_freq; +#endif + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + #if (CODE_VERSION == SIMULATION) + l1_config.tmode.rf_params.down_up = ((T_TMODE_IMMED_ASSIGN_REQ*)(msg->SigP))->ul_dl; + l1tm_reset_rx_state(); + l1_config.tmode.stats_config.num_loops = 26; // 0 actually means infinite + #endif + + // save this info for later + if (l1_config.tmode.rf_params.down_up == (TMODE_DOWNLINK|TMODE_UPLINK) && + l1_config.tmode.rf_params.mon_tasks == 1) + { + l1a_l1s_com.nsync.list[0].radio_freq = l1_config.tmode.rf_params.mon_arfcn; + } + + // Get Ptr to the free dedicated parameter set. + // All important fields are initialised. + free_set = l1a_get_free_dedic_set(); + + // Save given dedicated channel parameters from MPHC_IMMED_ASSIGN_REQ msg. + +//======================================================================== + + free_set->chan1.desc.chan_sel.h = 0; // no hopping + + free_set->chan1.desc.chan_sel.rf_channel.single_rf.radio_freq = l1_config.tmode.rf_params.tch_arfcn; + //DON'T: union with radio_freq + //free_set->chan1.desc.chan_sel.rf_channel.hopping_rf.maio=0; + //free_set->chan1.desc.chan_sel.rf_channel.hopping_rf.hsn=0; + + free_set->chan1.desc.channel_type = l1_config.tmode.rf_params.channel_type; + free_set->chan1.desc.subchannel = l1_config.tmode.rf_params.subchannel; + free_set->chan1.desc.timeslot_no = l1_config.tmode.rx_params.slot_num; + free_set->chan1.desc.tsc = l1_config.tmode.tx_params.tsc; + + //Set the loopback mode + // 0: No loopback, 1: Loop A ... 6: Loop F + if(l1_config.tmode.tx_params.burst_data >= 5 && l1_config.tmode.tx_params.burst_data <= 10 && + l1_config.tmode.rf_params.down_up == (TMODE_DOWNLINK | TMODE_UPLINK)) + { + free_set->chan1.tch_loop = l1_config.tmode.tx_params.burst_data - 4; + + // For loop back the channel mode needs to be set to TCH/FS + free_set->chan1.mode = TCH_FS_MODE; + } + else + { + free_set->chan1.tch_loop = 0; // no loopback + + // Rem1: Mode is forced to Signalling Only. + if (l1_config.tmode.rf_params.channel_type == TCH_F) + free_set->chan1.mode = TCH_FS_MODE; + else + free_set->chan1.mode = SIG_ONLY_MODE; + + } +/* +;-------------------------------------------------------------------------- +; channel_desc_1 : +; chan_sel : ( h=FALSE, arfcn=5a ) +; channel_type = 1 (TCHFS) +; subchannel = 0 +; timeslot_no = 0 +; tsc = 5 +; timing_advance = 0 +; frequency_list : +; rf_chan_cnt = 0000 +; rf_chan_no : (0000, 0000, ...(total of 64)... 0000) +; starting_time = +; start_time_present = FALSE +; start_time : +; n32 = +; n51 = +; n26 = +; frequency_list_bef_sti +; rf_chan_cnt = 0000 +; rf_chan_no : (0000, 0000, ...(total of 64)... 0000) +; maio_bef_sti = 0 +; dtx_allowed = FALSE +; bcch_allocation = 0 carriers (...) UNUSED +; ba_id = 0 UNUSED +; pwrc = 5 +;-------------------------------------------------------------------------- +*/ + free_set->ma.freq_list.rf_chan_cnt = 0; + free_set->ma.freq_list.rf_chan_no.A[0] = 0; + free_set->ma.freq_list_bef_sti.rf_chan_cnt = 0; + free_set->ma.freq_list_bef_sti.rf_chan_no.A[0] = 0; //DedicNew + + maio_bef_sti = 0; + + free_set->new_timing_advance = l1_config.tmode.tx_params.timing_advance; + free_set->dtx_allowed = 0; + // New Timing Advance value must be applied on 1st frame of dedic. channel. + free_set->timing_advance = free_set->new_timing_advance; + + l1a_l1s_com.dedic_set.pwrc = l1_config.tmode.tx_params.txpwr; + // l1a_l1s_com.dedic_set.pwrc = 5; // change from TM2! + + // TXPWR command was given in Idle, save it in dedicated mode structure. + free_set->new_target_txpwr = l1s.applied_txpwr = l1_config.tmode.tx_params.txpwr; + + // Serving Cell stays the same. + free_set->cell_desc = l1a_l1s_com.Scell_info; + +#if(L1_FF_MULTIBAND == 0) + + free_set->cell_desc.traffic_meas_beacon + = l1a_l1s_com.last_input_level[l1a_l1s_com.Scell_info.radio_freq - l1_config.std.radio_freq_index_offset]; + free_set->cell_desc.traffic_meas = l1a_l1s_com.last_input_level[l1a_l1s_com.Scell_info.radio_freq - l1_config.std.radio_freq_index_offset]; + +#else // L1_FF_MULTIBAND = 1 below + + operative_radio_freq = + l1_multiband_radio_freq_convert_into_operative_radio_freq(l1a_l1s_com.Scell_info.radio_freq); + + free_set->cell_desc.traffic_meas_beacon + = l1a_l1s_com.last_input_level[operative_radio_freq]; + free_set->cell_desc.traffic_meas = l1a_l1s_com.last_input_level[operative_radio_freq]; + +#endif // #if(L1_FF_MULTIBAND == 0) else + + + // Decode the "starting time field", since staying on the same serving + // the same STI fn is saved in both "neig_sti_fn" and "serv_sti_fn". + free_set->neig_sti_fn = -1; //l1a_decode_starting_time(((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->starting_time); + free_set->serv_sti_fn = free_set->neig_sti_fn; + + // Check/Fill "before starting time" fields. + //l1a_fill_bef_sti_param(free_set, ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->starting_time.start_time_present); + + //No hopping channel + + // Save the "timeslot difference" between new and old configuration + // in "tn_difference". + // tn_difference -> loaded with the number of timeslot to shift. + // dl_tn -> loaded with the new timeslot. + l1a_l1s_com.tn_difference = free_set->chan1.desc.timeslot_no - l1a_l1s_com.dl_tn; + l1a_l1s_com.dl_tn = free_set->chan1.desc.timeslot_no; // Save new TN id. + + // Set "fset" pointer to the new parameter set. + l1a_l1s_com.dedic_set.fset = free_set; + + // Give new msg code to L1S. //TestMode: use existing L1S primitive name + l1a_l1s_com.dedic_set.SignalCode = MPHC_IMMED_ASSIGN_REQ; + + // step in state machine. + *state = WAIT_MSG; + } + break; + + } // end of "switch(SignalCode)". + // end of process. + end_process = 1; + } + break; + + case WAIT_MSG: + { + switch(SignalCode) + // switch on input message. + //------------------------------- + { + case L1C_DEDIC_DONE: + // Dedicated channel activated. + //----------------------------- + { + // if MON tasks are enabled, set up FB26 and D_BAMS_MEAS tasks now as well + if (l1_config.tmode.rf_params.down_up == (TMODE_DOWNLINK|TMODE_UPLINK) && + l1_config.tmode.rf_params.mon_tasks == 1) + { + l1a_l1s_com.task_param[FB26] = SEMAPHORE_SET; + l1a_l1s_com.l1s_en_task[FB26] = TASK_ENABLED; +#if (L1_12NEIGH ==1) + //Set timing validity for FB no a priori info + l1a_l1s_com.nsync.list[0].timing_validity = 0; + + // Enable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_PENDING; //Used by l1s_schedule_tasks in l1_sync + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_ENABLED; +#endif + } + + if (l1_config.tmode.rx_params.pm_enable) + { + // Reset the BA list structure + l1a_reset_ba_list(); + + // Next measurement report must indicate INVALID. + //meas_valid = FALSE; + + l1a_l1s_com.ba_list.nbr_carrier = 1; + + // l1a_l1s_com.nsync.list[0].radio_freq was set to mon_arfcn above + l1a_l1s_com.ba_list.A[0].radio_freq = l1a_l1s_com.nsync.list[0].radio_freq; + + // Set parameter synchro semaphore for D_BAMS task. + // Enable Dedicated mode BA list measurement task. + l1a_l1s_com.meas_param |= D_BAMS_MEAS; + l1a.l1a_en_meas[D_NMEAS] |= D_BAMS_MEAS; + } + + // keep track of dedicated mode state. + l1tm.tmode_state.dedicated_active = 1; + + // End of process. + end_process = 1; + } + break; + + case TMODE_TCH_INFO: + // TCH result messages. + //----------------------- + { + // Check if RX stats done in TCH + if (l1_config.tmode.rf_params.mon_report == 0) + { + BOOL done; + + // loop and stats management done within this function + l1tm_stats_tch_confirm((T_TMODE_TCH_INFO *) (msg->SigP)); + + done = l1tm_is_rx_counter_done(); + + if (done == 1) + // if done, send stop message + { + l1tm.tmode_state.dedicated_active = 0; + + // Give new msg code to L1S. + l1a_l1s_com.dedic_set.SignalCode = MPHC_STOP_DEDICATED_REQ; + + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + +#if (L1_12NEIGH ==1) + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; //Used by l1s_schedule_tasks in l1_sync +#endif + + // Step in state machine. + *state = RESET; + } + } + + // end of process + end_process = 1; + } + break; + + case L1C_FB_INFO: + // MON result messages. + //----------------------- + { + // Check if RX stats done in Monitor channel + if (l1_config.tmode.rf_params.mon_report == 1) + { + BOOL done; + + // loop and stats management done within this function + l1tm_stats_mon_confirm( (T_TMODE_FB_CON*) ((T_L1C_FB_INFO *) (msg->SigP))); + + done = l1tm_is_rx_counter_done(); + + if (done == 1) + // if done, send stop message + { + l1tm.tmode_state.dedicated_active = 0; + + // Give new msg code to L1S. + l1a_l1s_com.dedic_set.SignalCode = MPHC_STOP_DEDICATED_REQ; + + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + +#if (L1_12NEIGH ==1) + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; //Used by l1s_schedule_tasks in l1_sync +#endif + + // Step in state machine. + *state = RESET; + } + } + + // end of process + end_process = 1; + } + break; + + case TMODE_STOP_RX_TX: + // Release dedicated mode message. + //-------------------------------- + { + l1tm.tmode_state.dedicated_active = 0; + + // Give new msg code to L1S. + l1a_l1s_com.dedic_set.SignalCode = MPHC_STOP_DEDICATED_REQ; + + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + +#if (L1_12NEIGH ==1) + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; //Used by l1s_schedule_tasks in l1_sync +#endif + // Step in state machine. + *state = RESET; + + end_process = 1; + } + break; + + default: + // End of process. + //---------------- + { + end_process = 1; + } + } // end of "switch(SignalCode)". + } + break; + + } // end of "switch". + } // end of "while" +} // end of procedure. + +/*-------------------------------------------------------*/ +/* l1a_tmode_ra_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles the TestMode */ +/* access to the network (IDLE mode). */ +/* */ +/* Starting messages: TMODE_RA_START */ +/* */ +/* Result messages (input): L1C_RA_DONE */ +/* */ +/* Result messages (output): TMODE_RA_DONE */ +/* */ +/* Stop messages (input): TMODE_STOP_RX_TX */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_access_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_RESULT = 2 + }; + + UWORD8 *state = &l1a.state[TMODE_RA]; + UWORD32 SignalCode = msg->SignalCode; + BOOL done = 0; + + while(1) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset RAACC process. + l1a_l1s_com.l1s_en_task[RAACC] = TASK_DISABLED; // Clear RAACC task enable flag. + } + break; + + case WAIT_INIT: + { + if(SignalCode == TMODE_RA_START) + // Configuration message for Access Link. + //--------------------------------------- + { + // Flag msg received + l1tm.tm_msg_received = TRUE; + + l1s.applied_txpwr = l1_config.tmode.tx_params.txpwr; + l1a_l1s_com.ra_info.channel_request = 2; //l1_config.tm_params.channel_request; + + // Initialize rand counter for RAACC process. + l1a_l1s_com.ra_info.rand = 1; + + // rand is random number of frames to wait between each AB transmission. + // In actual L1 code this changes with each burst. + // It is set to 1 here so the test runs fast. + + // also, channel_request is constant in TestMode for all bursts. + // Actual L1 changes channel_request message each time with a different + // random reference. [channel_request = 3 bits for establishment cause + // and 5 bits of random reference] + + // Use 2 multiframes (0.5 seconds) in reading all serving normal bursts + // (like paging reorganization) to refine TOA since we must have the quarter + // bit accuracy for RACH transmission. + + // Delay the start of RACH transmission (by incrementing rand + // counter), only at the start of the test. + + if(l1a_l1s_com.bcch_combined) + { + l1a_l1s_com.ra_info.rand += 54; // Combined: 2 multiframes = 54 slots. + } + else + { + l1a_l1s_com.ra_info.rand += 102; // Not combined: 2 multiframes = 102 slots. + } + + // step in state machine. + *state = WAIT_RESULT; + + // TestMode does not set up full BCCH reading + + // Activate RAACC task (no semaphore for UL tasks). + // TestMode does not enable Paging Reorg and Normal paging tasks. + l1a_l1s_com.l1s_en_task[RAACC] = TASK_ENABLED; + + // Change mode to connection establishment part 1. + l1a_l1s_com.mode = CON_EST_MODE1; // used for toa calc. + } + + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + return; + } + } + break; + + case WAIT_RESULT: + { + if(SignalCode == L1C_RA_DONE) + // Random access acknowledge message. + //----------------------------------- + { + // Change mode to connection establishment part 2. + l1a_l1s_com.mode = CON_EST_MODE2; // used for toa calc. + + //change power level and arfcn on the fly + l1s.applied_txpwr = l1_config.tmode.tx_params.txpwr; +// l1a_l1s_com.Scell_info.radio_freq = l1_config.tmode.rf_params.tch_arfcn; + + done = l1tm_is_rx_counter_done(); + + if (done) + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // No stats, just report end + //tmstats_ra_confirm( (T_TMODE_RA_DONE*) ((T_MPHC_RA_CON *)(msg->SigP)) ); + + *state = RESET; + } + else // there are more loops to do... + { + l1a_l1s_com.ra_info.rand += 10; // 1 chosen/set for quicker test + // Activate RAACC task (no semaphore for UL tasks). + l1a_l1s_com.l1s_en_task[RAACC] = TASK_ENABLED; + // end of process + return; + } + } + + else if(SignalCode == TMODE_STOP_RX_TX) + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // No stats, just report end + //tmstats_ra_confirm( (T_TMODE_RA_DONE*) ((T_MPHC_RA_CON *)(msg->SigP)) ); + *state = RESET; + return; + } + + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + return; + } + } + break; + } // end of "switch". + } // end of "while" +} // end of procedure. + +/*-------------------------------------------------------*/ +/* l1a_tmode_full_list_meas_process() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* This function is a state machine which handles the */ +/* Cell Selection Full List Power Measurement L1/L3 */ +/* interface and it handles the neigbour cell */ +/* measurement process in IDLE mode with FULL list. */ +/* When a message MPHC_RXLEV_REQ is received */ +/* the L1S task FSMS_MEAS is enabled. When this task */ +/* is completed a reporting message L1C_VALID_MEAS_INFO */ +/* is received and forwarded to L3. */ +/* */ +/* Starting messages: MPHC_RXLEV_REQ. */ +/* */ +/* Result messages (input): L1C_VALID_MEAS_INFO */ +/* */ +/* Result messages (output): MPHC_RXLEV_IND */ +/* */ +/* Reset messages (input): none */ +/* */ +/* Stop message (input): MPHC_STOP_RXLEV_REQ */ +/* */ +/* Stop message (output): MPHC_STOP_RXLEV_CON */ +/* */ +/* Rem: */ +/* ---- */ +/* L3 is in charge of the number of pass to follow the */ +/* GSM recommendation. */ +/* */ +/*-------------------------------------------------------*/ +void l1a_tmode_full_list_meas_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_RESULT = 2 + }; + + UWORD8 *state = &l1a.state[TMODE_FULL_MEAS]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset FULL_MEAS process. + l1a_l1s_com.l1s_en_meas &= FSMS_MEAS_MASK; // Clear Cell Selection Measurement enable flag. + } + break; + + case WAIT_INIT: + { + if(SignalCode == TMODE_RXLEV_REQ) + // Request to enter the Cell Selection measurements. + //-------------------------------------------------- + { + UWORD16 i; + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + // Do NOT download info from message + // In TestMode always a full scanning is done, therefore primitive does not send the list + l1a_l1s_com.full_list_ptr=(T_FULL_LIST_MEAS *)((T_TMODE_RXLEV_REQ *)(msg->SigP)); + + // Single power measurement carried out on monitor channel + l1a_l1s_com.full_list_ptr->power_array_size = 1; + l1a_l1s_com.full_list_ptr->power_array[0].radio_freq = l1_config.tmode.rf_params.mon_arfcn; + + // Set "parameter synchro semaphores" + l1a_l1s_com.meas_param |= FSMS_MEAS; + + // Reset the full list structure. + l1a_reset_full_list(); + + // Reset the Input Level (IL) memory table. +#if (L1_FF_MULTIBAND == 1) + for(i=0; i<= NBMAX_CARRIER; i++) +#else + for(i=0; i<=l1_config.std.nbmax_carrier; i++) +#endif + { + l1a_l1s_com.last_input_level[i].input_level = l1_config.params.il_min; + l1a_l1s_com.last_input_level[i].lna_off = 0; + } + + // Enable Cell Selection Full list measurement task. + l1a.l1a_en_meas[TMODE_FULL_MEAS] |= FSMS_MEAS; + + // Step in state machine. + *state = WAIT_RESULT; + } + + // End of process. + end_process = 1; + } + break; + + case WAIT_RESULT: + { + if(SignalCode == L1C_VALID_MEAS_INFO) + // One valid measurement pass has been completed over the full list of carriers. + //------------------------------------------------------------------------------ + { + BOOL done = FALSE; + + //-------------------------------------------------------- + // WE COULD PUT HERE THE CODE TO TRANSLATE IL -> RXLEV !!! + //-------------------------------------------------------- + + l1tm_stats_full_list_meas_confirm((T_TMODE_RXLEV_REQ *)(msg->SigP)); + + done = l1tm_is_rx_counter_done(); + + if (done) + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Reset the machine. + *state = RESET; + } + else + { + // Reset the full list structure. + l1a_reset_full_list(); + + // Enable Cell Selection Full list measurement task. + l1a.l1a_en_meas[TMODE_FULL_MEAS] |= FSMS_MEAS; + + // End of process + end_process = 1; + } + } + + else if (SignalCode == TMODE_STOP_RX_TX) + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Forward result message to L3. + l1a_send_confirmation(TMODE_STOP_RXLEV_CON,RRM1_QUEUE); + // Reset the machine. + *state = RESET; + end_process = 1; + } + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + end_process = 1; + } + } + break; + } // end of "switch". + } // end of "while" +} // end of procedure. + + + #if L1_GPRS + /*-------------------------------------------------------*/ + /* l1pa_tmode_transfer_process() */ + /*-------------------------------------------------------*/ + /* Description: */ + /* ------------ */ + /* */ + /* Starting messages: */ + /* ------------------ */ + /* */ + /* Subsequent messages: */ + /* -------------------- */ + /* */ + /* Result messages (input): */ + /* ------------------------ */ + /* */ + /* Result messages (output): */ + /* ------------------------- */ + /* */ + /* Reset messages (input): */ + /* ----------------------- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_tmode_transfer_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_MSG = 2 + }; + + UWORD8 *state = &l1a.state[TMODE_TRANSFER]; + UWORD32 SignalCode = msg->SignalCode; + + static UWORD8 stat_gprs_slots; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset FB26 task enable flag. + l1a_l1s_com.l1s_en_task[FB26] = TASK_DISABLED; + + // Reset TCR_MEAS process. + l1pa_l1ps_com.l1ps_en_meas &= P_TCRMS_MEAS_MASK; // Disable Neighbour Measurement task. + l1pa.l1pa_en_meas[TCR_MEAS] &= P_TCRMS_MEAS_MASK; // Reset Neighbour Measurement task. + + // Rise transfert parameter semaphore. + l1pa_l1ps_com.transfer.semaphore = TRUE; + } + break; + + case WAIT_INIT: + { + switch(SignalCode) + // switch on input message. + //------------------------- + { + case TMODE_PDTCH_ASSIGN_REQ: + // Assignement message. + //--------------------- + { + static UWORD32 count =0; + + T_TRANSFER_SET *free_set; + UWORD8 assignment_command; + UWORD8 timeslot_alloc; + UWORD8 timeslot; + UWORD32 i; + + count++ ; + + #if (CODE_VERSION == SIMULATION) + l1tm_reset_rx_state(); + #endif + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + // Rise transfert parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + assignment_command = BOTH_TBF; + + // Get Ptr to the free dedicated parameter set. + // All important fields are initialised. + free_set = l1pa_get_free_transfer_set(assignment_command); + + // Download message containt. + free_set->assignment_id = 1; + free_set->assignment_command = assignment_command; + #if (CODE_VERSION == SIMULATION) + free_set->multislot_class = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->multislot_class; + #else + free_set->multislot_class = l1_config.tmode.rf_params.multislot_class; + #endif + free_set->dl_pwr_ctl.p0 = 255; // no power control + free_set->packet_ta.ta = 0; + free_set->packet_ta.ta_index = 255; + free_set->packet_ta.ta_tn = 255; + free_set->tsc = l1_config.tmode.tx_params.tsc; + free_set->freq_param.chan_sel.h = FALSE; // no hopping + free_set->freq_param.chan_sel.rf_channel.single_rf.radio_freq = l1_config.tmode.rf_params.pdtch_arfcn; + free_set->mac_mode = FIX_ALLOC_NO_HALF; // fixed allocation + free_set->tbf_sti.present = TRUE; // STI present + // FreeCalypso TCS211 reconstruction: LoCosto change backed out + #if 0 //(CODE_VERSION == NOT_SIMULATION) + // In order to reduce the latency for the ETM command "rfe 4", make absolute_fn as + // next_time.fn+1. This was originally +100 because of which we had to wait for some + // time before L1 actually starts the TBF. + free_set->tbf_sti.absolute_fn= l1s.next_time.fn + 1; + #else + // In PC simulation, keep the old +100 to keep output logs same as reference + free_set->tbf_sti.absolute_fn= l1s.next_time.fn + 100; // force to current FN+100 + #endif + + free_set->interf_meas_enable = FALSE; // Interference measurements disabled + free_set->pc_meas_chan = TRUE; // No measurement on the beacon (6 per MF52) + + // Allocation of both UL and DL time slots + free_set->dl_tbf_alloc.tfi = 1; // DL TFI ID + free_set->ul_tbf_alloc->tfi = 2; // UL TFI ID + #if (CODE_VERSION == SIMULATION) + free_set->dl_tbf_alloc.timeslot_alloc = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->dl_ts_alloc; + free_set->ul_tbf_alloc->timeslot_alloc = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->ul_ts_alloc; + l1_config.tmode.stats_config.num_loops = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->ul_alloc_length; + l1_config.tmode.rf_params.mon_tasks = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->mon_enable; + l1_config.tmode.rf_params.mon_report = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->mon_enable; + l1_config.tmode.rx_params.pm_enable = ((T_TMODE_PDTCH_ASSIGN_REQ *)(msg->SigP))->pm_enable; + #else + free_set->dl_tbf_alloc.timeslot_alloc = l1_config.tmode.rx_params.timeslot_alloc; + free_set->ul_tbf_alloc->timeslot_alloc = l1_config.tmode.tx_params.timeslot_alloc; + #endif + // free_set->ul_tbf_alloc->fixed_alloc.bitmap_length = l1_config.tmode.stats_config.num_loops; + // force to 127 + free_set->ul_tbf_alloc->fixed_alloc.bitmap_length = 127; + + // Init fixed allocation bitmap + for (i=0;i<free_set->ul_tbf_alloc->fixed_alloc.bitmap_length;i++) + free_set->ul_tbf_alloc->fixed_alloc.bitmap[i] = free_set->ul_tbf_alloc->timeslot_alloc; + + free_set->allocated_tbf = BOTH_TBF; + + // Process the downlink TBF first allocated timeslot + timeslot_alloc = free_set->dl_tbf_alloc.timeslot_alloc; + timeslot = 0; + + while((timeslot<7) && !(timeslot_alloc & (0x80>>timeslot))) + { + timeslot++; + } + + free_set->dl_tbf_synchro_timeslot = timeslot; + + // Fill "synchro_timeslot" which will be the frame synchro slot. + free_set->transfer_synchro_timeslot = timeslot; + + // save stats bitmap + stat_gprs_slots = l1_config.tmode.stats_config.stat_gprs_slots; + // Adjust stats bit map + l1_config.tmode.stats_config.stat_gprs_slots <<= timeslot; + + // Process the uplink TBF first allocated timeslot + // Fixed mode: the 1st allocated timeslot is the downlink control + // timeslot allocated by the network, which is a timeslot allocated + // in uplink + timeslot_alloc = free_set->ul_tbf_alloc->timeslot_alloc; + + timeslot = 0; + while((timeslot<7) && !(timeslot_alloc & (0x80>>timeslot))) + { + timeslot++; + } + // if UL synchro TS > DL synchro TS, then fixed alloc ctrl TS is the UL sync TS + // else fixed alloc ctrl TS is the DL sync TS + if (timeslot > free_set->dl_tbf_synchro_timeslot) + free_set->ul_tbf_alloc->fixed_alloc.ctrl_timeslot = timeslot; + else + free_set->ul_tbf_alloc->fixed_alloc.ctrl_timeslot = free_set->dl_tbf_synchro_timeslot; + + free_set->ul_tbf_synchro_timeslot = free_set->ul_tbf_alloc->fixed_alloc.ctrl_timeslot; + + // Init txpwr levels for multi slot TX + // txpwr[index] is calculated according to TX allocation given by MACS + // timeslot contains the first allocated TS in UL + for(i = timeslot; i < 8; i++) + { + l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr[i] + = l1_config.tmode.tx_params.txpwr_gprs[i]; + } + + // Step in state machine. + *state = WAIT_MSG; + + // Store signalcode. + free_set->SignalCode = MPHP_ASSIGNMENT_REQ; + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + + // end of process. + end_process = 1; + } + break; + + default: + // End of process. + //---------------- + { + return; + } + } // end switch(SignalCode) + } // end case WAIT_INIT + case WAIT_MSG: + { + switch(SignalCode) + // switch on input message. + //------------------------- + { + case L1P_TRANSFER_DONE: + // Switch to TRANSFER mode has been done. + { + T_CRES_LIST_PARAM *free_list; + + // Set up TCR_MEAS task, if MON tasks are enabled set up FB26 + if (l1_config.tmode.rf_params.mon_tasks == 1) + { + // Set FB26 task semaphore + l1a_l1s_com.task_param[FB26] = SEMAPHORE_SET; + + // This process always use the first element of "nsync" structure. + l1a_l1s_com.nsync.current_list_size = 0; + // l1a_l1s_com.nsync.list[0].radio_freq was set to mon_arfcn above + l1a_l1s_com.nsync.list[0].radio_freq = l1_config.tmode.rf_params.mon_arfcn; + + // Enable FB detection during packet transfer + l1a_l1s_com.l1s_en_task[FB26] = TASK_ENABLED; +#if (L1_12NEIGH ==1) + //Set timing validity for FB no a priori info + l1a_l1s_com.nsync.list[0].timing_validity = 0; + // Enable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_PENDING; //Used by l1s_schedule_tasks in l1_sync + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_ENABLED; +#endif + } + + if (l1_config.tmode.rx_params.pm_enable) + { + // Set parameter synchro semaphore for P_TCRMS_MEAS task. + l1pa_l1ps_com.meas_param |= P_TCRMS_MEAS; + + // Reset Neighbour Cell measurement parameters. + l1pa_l1ps_com.tcr_freq_list.tcr_next_to_ctrl = 0; + l1pa_l1ps_com.tcr_freq_list.tcr_next_to_read = 0; + + // Get Ptr to the free Neighbour meas list. + // The number of carriers in the list and the list + // identification are initialized. + free_list = l1pa_get_free_cres_list_set(); + + // Download new list within T_CRES_LIST_PARAM structure. + free_list->nb_carrier = 1; + free_list->freq_list[0] = l1_config.tmode.rf_params.mon_arfcn; + + free_list->list_id = 0; + + // Set "flist" with Circuit Swithed BA frequency list parameters + l1pa_l1ps_com.cres_freq_list.alist = free_list; + + // Reset flags. + l1pa_l1ps_com.tcr_freq_list.ms_ctrl = 0; + l1pa_l1ps_com.tcr_freq_list.ms_ctrl_d = 0; + l1pa_l1ps_com.tcr_freq_list.ms_ctrl_dd = 0; + + // Reset measures made on beacon frequency. + l1pa_l1ps_com.tcr_freq_list.beacon_meas = 0; + + // Enable Packet Transfer Neighbour Measurement task. + l1pa.l1pa_en_meas[TCR_MEAS] |= P_TCRMS_MEAS; + } + + // Flag packet transfer mode active + l1tm.tmode_state.packet_transfer_active = TRUE; + + // End of process. + end_process = 1; + } + break; + + case TMODE_PDTCH_INFO: + // TCH result messages. + //----------------------- + { + // Check if RX stats done in PDTCH + if (l1_config.tmode.rf_params.mon_report == 0) + { + BOOL done; + + // loop and stats management done within this function + l1tm_stats_pdtch_confirm((T_TMODE_PDTCH_INFO *) (msg->SigP)); + + done = l1tm_is_rx_counter_done(); + + if (done == 1) + // if done, send stop TBFs + { + // Rise transfer parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + // Enables the TBF release processing in L1S. + l1pa_l1ps_com.transfer.tbf_release_param.tbf_release_cmd = TRUE; + + // Download msg info into L1PA_L1PS_COM. + l1pa_l1ps_com.transfer.tbf_release_param.released_tbf = BOTH_TBF; + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + } + } + + // end of process + end_process = 1; + } + break; + + case L1C_FB_INFO: + // MON result messages. + //----------------------- + { + // Check if RX stats done in Monitor channel + if (l1_config.tmode.rf_params.mon_report == 1) + { + BOOL done; + + // loop and stats management done within this function + l1tm_stats_mon_confirm( (T_TMODE_FB_CON*) ((T_L1C_FB_INFO *) (msg->SigP))); + + done = l1tm_is_rx_counter_done(); + + if (done == 1) + // if done, send stop TBFs + { + // Rise transfer parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + // Enables the TBF release processing in L1S. + l1pa_l1ps_com.transfer.tbf_release_param.tbf_release_cmd = TRUE; + + // Download msg info into L1PA_L1PS_COM. + l1pa_l1ps_com.transfer.tbf_release_param.released_tbf = BOTH_TBF; + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + } + } + + // end of process + end_process = 1; + } + break; + + case TMODE_STOP_RX_TX: + // TBF Release. + //------------- + { + // Rise transfer parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + // Enables the TBF release processing in L1S. + l1pa_l1ps_com.transfer.tbf_release_param.tbf_release_cmd = TRUE; + + // Download msg info into L1PA_L1PS_COM. + l1pa_l1ps_com.transfer.tbf_release_param.released_tbf = BOTH_TBF; + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + + // end of process. + end_process = 1; + } + break; + + case L1P_TBF_RELEASED: + // TBF has been release by L1S. + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + // Reset transfer active state + l1tm.tmode_state.packet_transfer_active = FALSE; + + // Restore stats bitmap + l1_config.tmode.stats_config.stat_gprs_slots = stat_gprs_slots; + +#if (L1_12NEIGH ==1) + l1a_l1s_com.l1s_en_task[NSYNC] = TASK_DISABLED; + // Disable neighbour sync 0. + l1a_l1s_com.nsync.list[0].status = NSYNC_FREE; //Used by l1s_schedule_tasks in l1_sync +#endif + + // Step in state machine. + *state = RESET; + + // End of process. + end_process = 1; + } + break; + + default: + // End of process. + //---------------- + { + end_process = 1; + } + } // end of switch(SignalCode) + } // end of case WAIT_MSG. + } // end of "switch". + } // end of "while" + } // end of procedure. + #endif + + #if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) + /*----------------------------------------------------------------*/ + /* l1a_tmode_audio_stereopath_process() */ + /*----------------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* stereopath feature. */ + /* */ + /* Starting messages: TMODE_AUDIO_STEREOPATH_DRV_START_REQ */ + /* */ + /* Result messages (input): L1_STEREOPATH_DRV_START_CON */ + /* */ + /* Result messages (output): TMODE_AUDIO_STEREOPATH_DRV_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): TMODE_AUDIO_STEREOPATH_DRV_STOP_REQ */ + /* L1_STEREOPATH_DRV_STOP_CON */ + /* */ + /* Stop message (output): TMODE_AUDIO_STEREOPATH_DRV_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*----------------------------------------------------------------*/ + void l1a_tmode_audio_stereopath_process(xSignalHeaderRec *msg) + { +#if (CODE_VERSION == NOT_SIMULATION) + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3, + WAIT_DSP_STOP = 4 + + }; + + UWORD8 *state = &l1a.state[TMODE_AUDIO_STEREOPATH_DRV_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + static UWORD8 previous_config = 0; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // initialize global variable + l1tm.stereopath.stereopath_source_timeout = 0; + l1tm.stereopath.stereopath_dest_timeout = 0; + l1tm.stereopath.stereopath_drop = 0; + l1tm.stereopath.stereopath_frame = 0; + l1tm.stereopath.stereopath_block = 0; + l1tm.stereopath.stereopath_half_block = 0; + l1tm.stereopath.stereopath_current_sample = 0; + l1tm.stereopath.stereopath_buffer_number = 0; + + // initialize ndb + stp_drv_ndb->d_cport_api_dma_install = 0; + stp_drv_ndb->d_cport_api_dma_channel = 0; + stp_drv_ndb->d_cport_api_dma_rootcause = 0; + + // Init DSP background + l1s_dsp_com.dsp_ndb_ptr->a_background_tasks[C_BGD_STP_DRV] = (API)((C_BGD_STP_DRV<<11) | 1); + if (l1s_dsp_com.dsp_ndb_ptr->d_max_background<(C_BGD_STP_DRV+1)) + l1s_dsp_com.dsp_ndb_ptr->d_max_background=(API)(C_BGD_STP_DRV+1); + + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == TMODE_AUDIO_STEREOPATH_START_REQ) + { + // receive a request to start stereopath + T_TMODE_AUDIO_STEREOPATH_START_REQ* tmode_audio_sp_conf_ptr; + + // Flag msg received + l1tm.tm_msg_received = TRUE; + + /******************************************************************/ + /**************** GET STEREOPATH PARAMETERS ***********************/ + /******************************************************************/ + + if (((T_TMODE_AUDIO_STEREOPATH_START_REQ *)(msg->SigP))->configuration == AUDIO_SP_SELF_CONF) + { + // no use of a predefined configuration, we have to get parameters from the message + tmode_audio_sp_conf_ptr = ((T_TMODE_AUDIO_STEREOPATH_START_REQ *)(msg->SigP)); + } + else + { + UWORD8 conf_index = 0; + + // use of a predefined configuration, we have to get parameters from the constant config + tmode_audio_sp_conf_ptr = (T_TMODE_AUDIO_STEREOPATH_START_REQ *) tmode_audio_sp_conf[conf_index]; + + while ((tmode_audio_sp_conf_ptr != NULL) && (conf_index < NB_MAX_STEREOPATH_CONFIG)) + { + if (tmode_audio_sp_conf_ptr->configuration == ((T_TMODE_AUDIO_STEREOPATH_START_REQ *)(msg->SigP))->configuration) + break; + + tmode_audio_sp_conf_ptr = (T_TMODE_AUDIO_STEREOPATH_START_REQ *) tmode_audio_sp_conf[++conf_index]; + } + } + + if (tmode_audio_sp_conf_ptr == NULL) + { + // unknow configuration identifier --> use message parameters + tmode_audio_sp_conf_ptr = ((T_TMODE_AUDIO_STEREOPATH_START_REQ *)(msg->SigP)); + } + + // Download the stereopath description in the l1a_l1s structure. + l1a_l1s_com.stereopath_drv_task.parameters.sampling_frequency = tmode_audio_sp_conf_ptr->sampling_frequency; + l1a_l1s_com.stereopath_drv_task.parameters.DMA_allocation = tmode_audio_sp_conf_ptr->DMA_allocation; + l1a_l1s_com.stereopath_drv_task.parameters.DMA_channel_number = tmode_audio_sp_conf_ptr->DMA_channel_number; + l1a_l1s_com.stereopath_drv_task.parameters.data_type = tmode_audio_sp_conf_ptr->data_type; + l1a_l1s_com.stereopath_drv_task.parameters.source_port = tmode_audio_sp_conf_ptr->source_port; + l1a_l1s_com.stereopath_drv_task.parameters.element_number = tmode_audio_sp_conf_ptr->element_number; + l1a_l1s_com.stereopath_drv_task.parameters.frame_number = tmode_audio_sp_conf_ptr->frame_number; + l1a_l1s_com.stereopath_drv_task.parameters.mono_stereo = tmode_audio_sp_conf_ptr->mono_stereo; + l1a_l1s_com.stereopath_drv_task.parameters.feature_identifier = AUDIO_SP_TESTS_ID; + + /******************************************************************/ + /**************** CHECK ALLOCATION DSP/MCU ************************/ + /******************************************************************/ + + if (tmode_audio_sp_conf_ptr->DMA_allocation == AUDIO_SP_DMA_ALLOC_MCU) + { + l1a_l1s_com.stereopath_drv_task.parameters.DMA_int_callback_fct = l1tm_stereopath_DMA_handler; + } + else // DMA_allocation == AUDIO_SP_DMA_ALLOC_DSP + { + // Update ndb + stp_drv_ndb->d_cport_api_dma_install = 1; + stp_drv_ndb->d_cport_api_dma_channel = l1a_l1s_com.stereopath_drv_task.parameters.DMA_channel_number; + stp_drv_ndb->d_cport_api_dma_rootcause = 0; + + // start background task + l1s_dsp_com.dsp_ndb_ptr->d_background_enable|=(API)(1<<C_BGD_STP_DRV); + l1_trigger_api_interrupt(); + + l1a_l1s_com.stereopath_drv_task.parameters.DMA_int_callback_fct = f_dma_default_call_back_it; + } + + /******************************************************************/ + /**************** GENERATION OF THE PATTERN ***********************/ + /******************************************************************/ + + // Reservation and generation of the pattern used to fill the buffer + if (tmode_audio_sp_conf_ptr->pattern_identifier != AUDIO_SP_SILENCE_PATTERN) + { + l1tm.stereopath.stereopath_pattern = (WORD8 *)l1tm_stereopath_buffer; + + // if pattern has already been build with the same config (mp3,midi or ext audio) in the current scenario, + // we don't do it again. This is to avoid to have a CPU overload during critical operation such as access or packet transfer + if ((tmode_audio_sp_conf_ptr->configuration == 0) || (tmode_audio_sp_conf_ptr->configuration != previous_config)) + { + previous_config = tmode_audio_sp_conf_ptr->configuration; + l1tm.stereopath.stereopath_nb_samples = l1tm_stereopath_get_pattern(l1tm_stereopath_sampling_freqs[tmode_audio_sp_conf_ptr->sampling_frequency], + l1tm_stereopath_sin_freqs[tmode_audio_sp_conf_ptr->pattern_identifier][0], + l1tm_stereopath_sin_freqs[tmode_audio_sp_conf_ptr->pattern_identifier][1], + tmode_audio_sp_conf_ptr->data_type); + } + } + else + { + // Silence pattern, consider just 2 samples at the value 0 + l1tm.stereopath.stereopath_nb_samples = 2; + + l1tm.stereopath.stereopath_pattern = (WORD8 *)l1tm_stereopath_buffer; + l1tm.stereopath.stereopath_pattern[0] = l1tm.stereopath.stereopath_pattern[1] = + l1tm.stereopath.stereopath_pattern[2] = l1tm.stereopath.stereopath_pattern[3] = 0x0000; + } + + /******************************************************************/ + /**************** GET ADDRESS OF THE BUFFER ***********************/ + /******************************************************************/ +#if (CHIPSET == 15) + if (tmode_audio_sp_conf_ptr->source_port == AUDIO_SP_SOURCE_EMIF) + { + // get an address in internal RAM + l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = (WORD8*) TM_stereo_buf_ext_mem; + } + + + if (tmode_audio_sp_conf_ptr->source_port == AUDIO_SP_SOURCE_IMIF) + { + // get an address in internal RAM + l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = (WORD8*) TM_stereo_buf; + } + + if (tmode_audio_sp_conf_ptr->source_port == AUDIO_SP_SOURCE_API) + { + // Disable DSP trace + l1s_dsp_com.dsp_ndb_ptr->d_debug_trace_type &= 0xfff0; + l1s_dsp_com.dsp_ndb_ptr->d_debug_trace_type |= 0x8000; + + l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = (WORD8*)API_address_dsp2mcu(C_STP_DRV_BUF_API_BASE_ADDRESS); + } +#else + if (tmode_audio_sp_conf_ptr->source_port == AUDIO_SP_SOURCE_IMIF) + { + // get an address in internal RAM + l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = (WORD8*) TM_stereo_buf; + } + else // source_port == AUDIO_SP_SOURCE_API + { + // Disable DSP trace + l1s_dsp_com.dsp_ndb_ptr->d_debug_trace_type &= 0xfff0; + l1s_dsp_com.dsp_ndb_ptr->d_debug_trace_type |= 0x8000; + + l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = (WORD8*)API_address_dsp2mcu(C_STP_DRV_BUF_API_BASE_ADDRESS); + } +#endif + + /******************************************************************/ + /**************** FILL THE 2 FIRST BUFFERS ************************/ + /******************************************************************/ + + l1tm_stereopath_fill_buffer((void*) l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address); + l1tm_stereopath_fill_buffer((void*) l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address); + + // Start the L1S stereopath task + l1a_l1s_com.stereopath_drv_task.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + end_process = 1; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_STEREOPATH_DRV_START_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(TMODE_AUDIO_STEREOPATH_START_CON); + + *state = WAIT_STOP; + } + + // End process + end_process = 1; + } + break; + + case WAIT_STOP: + { + if (SignalCode == TMODE_AUDIO_STEREOPATH_STOP_REQ) + { + if (l1a_l1s_com.stereopath_drv_task.parameters.DMA_allocation == AUDIO_SP_DMA_ALLOC_DSP) + { + // we first need to stop the DSP background task + stp_drv_ndb->d_cport_api_dma_install = 0xFFFF; + l1_trigger_api_interrupt(); + + *state = WAIT_DSP_STOP; + } + else + { + // Stop the L1S stereopath task + l1a_l1s_com.stereopath_drv_task.command.stop = TRUE; + + // End process + end_process = 1; + } + } + else + if (SignalCode == L1_STEREOPATH_DRV_STOP_CON) + { + // Reset TM msg flag + // No new L1S result messages may be received before a new TM command + l1tm.tm_msg_received = FALSE; + + free(l1tm.stereopath.stereopath_pattern); + + // Send the stop confirmation message + l1a_audio_send_confirmation(TMODE_AUDIO_STEREOPATH_STOP_CON); + + *state = RESET; + } + else + { + // End process + end_process = 1; + } + } + break; + + case WAIT_DSP_STOP: + { + if (stp_drv_ndb->d_cport_api_dma_install == 0) + { + // stop the DSP background task + l1s_dsp_com.dsp_ndb_ptr->d_background_enable&=(API)(~(1<<C_BGD_STP_DRV)); + l1_trigger_api_interrupt(); + + // Stop the L1S stereopath task + l1a_l1s_com.stereopath_drv_task.command.stop = TRUE; + + *state = WAIT_STOP; + + end_process = 1; + } + } + break; + } // switch + } // while(!end_process) +#endif // CODE_VERSION == NOT_SIMULATION + } + #endif // #if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/tm_cfile/l1tm_func.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,3092 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1TM_FUNC.C + * + * Filename l1tm_func.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +#include "l1_macro.h" +#include "l1_confg.h" + +#if TESTMODE + #define L1TM_FUNC_C + + #include <string.h> + #include <math.h> + #include "abb.h" + + #include "general.h" + + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + #include "l1_time.h" + #include "l1_signa.h" + + #include "l1tm_defty.h" + + #if 0 //(CODE_VERSION != SIMULATION) // LoCosto-ism + #include "pld.h" + #endif + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) || (TRACE_TYPE==7) || (TRACE_TYPE==0) + #include "rvt_gen.h" + extern T_RVT_USER_ID tm_trace_user_id; + #endif + + #if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #endif + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + #include "l1_proto.h" + + #include "mem.h" + + #if (CODE_VERSION != SIMULATION) + + #if (RF_FAM == 61) + #include "tpudrv61.h" + #include "l1_rf61.h" + #include "l1tm_tpu61.h" + #if (DRP_FW_EXT==1) + #include "l1_drp_inc.h" + #else + #include "drp_drive.h" + #endif + #endif + + #if (RF_FAM == 60) + #include "tpudrv60.h" + #include "l1_rf60.h" + #include "l1tm_tpu60.h" + #include "drp_drive.h" + #endif + + #if (RF_FAM==43) + #include "tpudrv43.h" + #include "l1_rf43.h" + #include "l1tm_tpu43.h" + #endif + #if (RF_FAM == 35) + #include "tpudrv35.h" + #include "l1_rf35.h" + #include "l1tm_tpu35.h" + #endif + + #if (RF_FAM == 12) + #include "tpudrv12.h" + #include "l1_rf12.h" + #include "l1tm_tpu12.h" + #endif + + #if (RF_FAM == 10) + #include "tpudrv10.h" + #include "l1_rf10.h" + #include "l1tm_tpu10.h" + #endif + + #if (RF_FAM == 8) + #include "tpudrv8.h" + #include "l1_rf8.h" + #include "l1tm_tpu8.h" + #endif + + #if (RF_FAM == 2) + #include "tpudrv2.h" + #include "l1_rf2.h" + #include "l1tm_tpu2.h" + #endif + + #else + + #if (RF_FAM == 2) + #include "l1_rf2.h" + #endif + + #endif + + #include <assert.h> + #include <string.h> + + #include "l1tm_msgty.h" + #include "l1tm_signa.h" + #include "l1tm_varex.h" + #include "l1tm_ver.h" + + #if L1_GPRS + #include "l1p_cons.h" + #include "l1p_msgt.h" + #include "l1p_deft.h" + #include "l1p_vare.h" + #include "l1p_sign.h" + #endif + + #if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) + #include "sys_dma.h" + #endif + +#if(L1_FF_MULTIBAND == 1) +extern UWORD8 tm_band; +#endif /*if (L1_FF_MULTIBAND == 1)*/ + + +// Prototypes from external functions +//------------------------------------ +UWORD16 Convert_l1_radio_freq(SYS_UWORD16 radio_freq); + +void Cust_tm_rf_param_write (T_TM_RETURN *tm_return, WORD16 index, UWORD16 value); +void Cust_tm_rf_param_read (T_TM_RETURN *tm_return, WORD16 index); +void Cust_tm_rf_table_write (T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[]); +void Cust_tm_rf_table_read (T_TM_RETURN *tm_return, WORD8 index); +void Cust_tm_rx_param_write (T_TM_RETURN *tm_return, WORD16 index, UWORD16 value); +void Cust_tm_rx_param_read (T_TM_RETURN *tm_return, WORD16 index); +void Cust_tm_tx_param_write (T_TM_RETURN *tm_return, WORD16 index, UWORD16 value, UWORD8 band); +void Cust_tm_tx_param_read (T_TM_RETURN *tm_return, WORD16 index, UWORD8 band); +void Cust_tm_tx_template_write (T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[]); +void Cust_tm_tx_template_read (T_TM_RETURN *tm_return, WORD8 index); +void Cust_tm_special_param_write (T_TM_RETURN *tm_return, WORD16 index, UWORD16 value); +void Cust_tm_special_param_read (T_TM_RETURN *tm_return, WORD16 index); +void Cust_tm_special_table_write (T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[]); +void Cust_tm_special_table_read (T_TM_RETURN *tm_return, WORD8 index); +void Cust_tm_special_enable (T_TM_RETURN *tm_return, WORD16 action); + +#if (CODE_VERSION != SIMULATION) + void Cust_tm_tpu_table_write (T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[]); + void Cust_tm_tpu_table_read (T_TM_RETURN *tm_return, WORD8 index); +#endif + +//------------------------------------ +// Prototypes from external functions +//------------------------------------ + +void Cust_tm_init (void); +void l1tm_reset_rx_state (void); +void l1tm_reset_rx_stats (void); + +#if L1_GPRS + void l1pa_reset_cr_freq_list (void); +#endif + +//------------------------------------ +// Prototypes from internal functions +//------------------------------------ + +void l1tm_initialize_var(void); +UWORD16 l1tm_convert_arfcn2l1ch(UWORD16 arfcn, UWORD8 *error_flag); +void l1tm_stats_read(T_TM_RETURN *tm_return, WORD16 type, UWORD16 bitmask); +void tm_transmit(T_TM_RETURN *tm_ret); +void l1tm_PRBS1_generate(UWORD16 *TM_ul_data); + +#if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) + void l1tm_stereopath_DMA_handler(SYS_UWORD16 dma_status); + void l1tm_stereopath_fill_buffer(void* buffer_address); + UWORD16 l1tm_stereopath_get_pattern(UWORD16 sampling_freq, UWORD16 sin_freq_left,UWORD16 sin_freq_right, UWORD8 data_type); +#endif + +/***********************************************************************/ +/* TESTMODE 3.X */ +/***********************************************************************/ + +static UWORD8 tx_param_band=0; // used in tx_param_write/read; default is GSM900 + + + + +// RF,(ANALOG)or other hardware dependent functions +// - work done by tmrf.c functions for each product. + +// TestMode functions that modify the state variables +// within the L1A - may need to allocate space +// dynamically if this is the first time calling +// these functions. + +// TestMode functions that start L1A state machines +// may need to send L1A primitives to change L1A state. + +void l1tm_rf_param_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + tm_return->index = prim->u.tm_params.index; + tm_return->size = 0; + + switch (prim->u.tm_params.index) + { + #if (FF_REPEATED_SACCH == 1) + // Repeated SACCH mode + case REPEATED_SACCH_ENA_FLAG: + { + l1_config.repeat_sacch_enable = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + #endif /* FF_REPEATED_SACCH */ + + #if (FF_REPEATED_DL_FACCH == 1) + // Repeated FACCH mode + case REPEATED_FACCHDL_ENA_FLAG: + { + l1_config.repeat_facch_dl_enable = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif/*(ETM_PROTOCOL == 1)*/ + + break; + } + #endif /* FF_REPEATED_DL_FACCH == 1 */ + case BCCH_ARFCN: + { + UWORD16 bcch_arfcn; + UWORD8 error_flag; + + bcch_arfcn = l1tm_convert_arfcn2l1ch(prim->u.tm_params.value, &error_flag); + + if (error_flag) + { + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_INVAL; + #endif + } + else + { + l1_config.tmode.rf_params.bcch_arfcn = bcch_arfcn; + + // now change on the fly + // no reason to check dedicated_active flag... + // we just set these 2 globals for FB/SB/BCCH tests + l1a_l1s_com.nsync.list[0].radio_freq = l1_config.tmode.rf_params.bcch_arfcn; + l1a_l1s_com.Scell_info.radio_freq = l1_config.tmode.rf_params.bcch_arfcn; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + } + break; + } + case TCH_ARFCN: + { + T_CHN_SEL *chan_sel; + UWORD16 tch_arfcn; + UWORD8 error_flag; + + tch_arfcn = l1tm_convert_arfcn2l1ch(prim->u.tm_params.value, &error_flag); + + if (error_flag) + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_INVAL; + #endif + else + { + l1_config.tmode.rf_params.tch_arfcn = tch_arfcn; + + // now change on the fly if necessary + if (l1_config.TestMode && l1tm.tmode_state.dedicated_active) + { + chan_sel = &(l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->chan_sel); + chan_sel->rf_channel.single_rf.radio_freq = l1_config.tmode.rf_params.tch_arfcn; + } + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + } + break; + } + case MON_ARFCN: + { + UWORD16 mon_arfcn; + UWORD8 error_flag; + + mon_arfcn = l1tm_convert_arfcn2l1ch(prim->u.tm_params.value, &error_flag); + + if (error_flag) + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_INVAL; + #endif + else + { + l1_config.tmode.rf_params.mon_arfcn = mon_arfcn; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + } + break; + } + #if L1_GPRS + case PDTCH_ARFCN: + { + UWORD16 pdtch_arfcn; + UWORD8 error_flag; + + pdtch_arfcn = l1tm_convert_arfcn2l1ch(prim->u.tm_params.value, &error_flag); + + if (error_flag) + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_INVAL; + #endif + else + { + l1_config.tmode.rf_params.pdtch_arfcn = pdtch_arfcn; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + } + break; + } + #endif + case AFC_ENA_FLAG: + { + l1_config.afc_enable = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + case AFC_DAC_VALUE: + { + WORD16 afc_value = prim->u.tm_params.value; + // 13-bit AFC DAC + #if(RF_FAM != 61) + if (afc_value<-4096 || afc_value>4095) + #else + if (afc_value<-8192 || afc_value>8191) + #endif + { + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_INVAL; + #endif + break; + } + + if (!l1_config.afc_enable) + { + // write AFC value to AFC DAC ASAP!! AFC DAC will be updated by any RX + // or TX test. + l1s.afc = afc_value; + } + + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + #if L1_GPRS + case MULTISLOT_CLASS: + { + UWORD8 multislot_class; + + multislot_class = prim->u.tm_params.value; + + if ((multislot_class < 1) || (multislot_class > 12)) + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_INVAL; + #endif + else + { + l1_config.tmode.rf_params.multislot_class = multislot_class; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + } + break; + } +#endif // end of L1_GPRS + default: + { + Cust_tm_rf_param_write(tm_return, + prim->u.tm_params.index, + prim->u.tm_params.value); + break; + } + } // end switch +} + +UWORD16 l1tm_convert_arfcn2l1ch(UWORD16 arfcn, UWORD8 *error_flag) +#if (L1_FF_MULTIBAND == 0) +{ + /* Here, before we store the channel numbers to the l1_config structure, + we convert from ETSI to TI channel numbering system. The GGT + ALWAYS expects the ETSI numbering system as input and output. + + We need to do the OPPOSITE of what is done in convert_l1_arfcn() in + tpudrvX.c + + *************************************** + *** convert arfcn's from ETSI to TI *** + *************************************** + ** ** + ** ETSI TI ** + ** 0 GSM 174 ** + ** 1 - 124 GSM 1 - 124 ** + ** 975 - 1023 E-GSM 125 - 173 ** + ** 512 - 885 DCS 174 - 548 ** + ** ** + *************************************** */ + + *error_flag = 0; + + switch (l1_config.std.id) + { + case GSM: + case DCS1800: + case PCS1900: + case GSM850: + break; + + case DUAL: + if ((arfcn >= 512) && (arfcn <= 885)) arfcn -= 337; + else if (arfcn > 124) *error_flag = 1; // invalid arfcn + break; + + case DUALEXT: + if (arfcn == 0) arfcn = 174; + else if ((arfcn >= 975) && (arfcn <= 1023)) arfcn -= 850; + else if ((arfcn >= 512) && (arfcn <= 885)) arfcn -= 337; + else if ((arfcn >= 1) && (arfcn <= 124)); + else *error_flag = 1; // invalide arfcn + break; + + case DUAL_US: // GSM850:128-251 PCS1900:512-810 + if ((arfcn >= 128) && (arfcn <= 251)) arfcn -= 127; + else if ((arfcn >= 512) && (arfcn <= 810)) arfcn -= 387; + else *error_flag = 1; // invalid arfcn + break; + + default: + *error_flag = 1; // invalid std.id + break; + } // end switch + return arfcn; +} +#else // L1_FF_MULTIBAND = 1 below + +{ + *error_flag=0; + if(tm_band == RF_PCS1900) + { + arfcn = arfcn + 512; + } + return(arfcn); +#if 0 + UWORD16 l1_radio_freq = 0; + UWORD8 effective_band_id = 0; + *error_flag = 1; + for (effective_band_id = 0; effective_band_id < RF_NB_SUBBANDS; effective_band_id ++) + { + if( multiband_conversion_data[effective_band_id].physical_band_id == tm_band) + { + if( (arfcn - multiband_conversion_data[effective_band_id].first_tpu_radio_freq) < multiband_conversion_data[effective_band_id].nbmax_carrier) + { + l1_radio_freq = arfcn - multiband_conversion_data[effective_band_id].first_tpu_radio_freq + multiband_conversion_data[effective_band_id].first_radio_freq; + *error_flag = 0; + return(l1_radio_freq); + } + } + } + return(l1_radio_freq); +#endif + +} + +#endif // #if (L1_FF_MULTIBAND == 0) else + + +void l1tm_rf_param_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + volatile UWORD16 value; + + tm_return->index = prim->u.tm_params.index; + + switch (prim->u.tm_params.index) + { + #if (FF_REPEATED_SACCH == 1 ) + /* Repeated SACCH mode */ + case REPEATED_SACCH_ENA_FLAG: + { + value = l1_config.repeat_sacch_enable; + break; + } + #endif /* FF_REPEATED_SACCH */ + + #if FF_REPEATED_DL_FACCH + // Repeated FACCH mode + case REPEATED_FACCHDL_ENA_FLAG: + { + value = l1_config.repeat_facch_dl_enable; + break; + } + #endif /* FF_REPEATED_DL_FACCH */ + + + case BCCH_ARFCN: + { + // return ETSI value for channel number + value = Convert_l1_radio_freq(l1_config.tmode.rf_params.bcch_arfcn); + break; + } + case TCH_ARFCN: + { + // return ETSI value for channel number + value = Convert_l1_radio_freq(l1_config.tmode.rf_params.tch_arfcn); + break; + } + case MON_ARFCN: + { + // return ETSI value for channel number + value = Convert_l1_radio_freq(l1_config.tmode.rf_params.mon_arfcn); + break; + } + #if L1_GPRS + case PDTCH_ARFCN: + { + // return ETSI value for channel number + value = Convert_l1_radio_freq(l1_config.tmode.rf_params.pdtch_arfcn); + break; + } + #endif + case AFC_ENA_FLAG: + { + value = l1_config.afc_enable; + break; + } + case AFC_DAC_VALUE: + { + value = l1s.afc; // returned as F13.3 + break; + } + #if L1_GPRS + case MULTISLOT_CLASS: + { + value = l1_config.tmode.rf_params.multislot_class; + break; + } + #endif + default: + { + Cust_tm_rf_param_read(tm_return, prim->u.tm_params.index); + return; + } + } // end switch + + memcpy(tm_return->result, (UWORD8 *)&value, 2); + tm_return->size = 2; +#if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; +#else + tm_return->status = E_OK; +#endif +} + +void l1tm_rf_table_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + Cust_tm_rf_table_write(tm_return, + prim->u.tm_table.index, + prim->str_len_in_bytes - 1, // subtract 8-bit index + prim->u.tm_table.table); +} + +void l1tm_rf_table_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + Cust_tm_rf_table_read(tm_return, prim->u.tm_table.index); +} + +void l1tm_rx_param_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + tm_return->index = prim->u.tm_params.index; + tm_return->size = 0; + + switch (prim->u.tm_params.index) + { + case RX_AGC_GAIN: + { + WORD8 gain = prim->u.tm_params.value; + + // It is up to the user to write a valid gain, + // one that falls within the range of gains in the current RF + // AGC gain can only be controlled in 2dB steps as the bottom bit (bit zero) + // corresponds to the lna_off bit + l1_config.tmode.rx_params.agc = gain & ~0x01; + l1_config.tmode.rx_params.lna_off = gain & 0x01; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + case RX_TIMESLOT: + { + if (prim->u.tm_params.value > 7) + { + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_INVAL; + #endif + break; + } + + l1_config.tmode.rx_params.slot_num = prim->u.tm_params.value; + if (l1_config.TestMode && l1tm.tmode_state.dedicated_active) + { + // currently CANNOT change RX slot on the fly! + } + + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + case RX_PM_ENABLE: + { + l1_config.tmode.rx_params.pm_enable = prim->u.tm_params.value; + + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + #if L1_GPRS + case RX_GPRS_SLOTS: + { + // At least one DL TS needs to be allocated + if (!prim->u.tm_params.value) + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_INVAL; + #endif + else + { + l1_config.tmode.rx_params.timeslot_alloc = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + } + break; + } + case RX_GPRS_CODING: + { + UWORD8 coding_scheme; + + coding_scheme = prim->u.tm_params.value; + if ((coding_scheme < 1) || (coding_scheme > 6) || (coding_scheme == 3)) + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_INVAL; + #endif + else + { + l1_config.tmode.rx_params.coding_scheme = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + } + break; + } + #endif + case RX_AGC_ENA_FLAG: + { + l1_config.agc_enable = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + default: + { + Cust_tm_rx_param_write(tm_return, + prim->u.tm_params.index, + prim->u.tm_params.value); + break; + } + } // end switch +} + +void l1tm_rx_param_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + volatile UWORD16 value; + + tm_return->index = prim->u.tm_params.index; + + switch (prim->u.tm_params.index) + { + case RX_AGC_GAIN: + { + value = l1_config.tmode.rx_params.agc | l1_config.tmode.rx_params.lna_off; + break; + } + case RX_TIMESLOT: + { + value = l1_config.tmode.rx_params.slot_num; + break; + } + case RX_AGC_ENA_FLAG: + { + value = l1_config.agc_enable; + break; + } + case RX_PM_ENABLE: + { + value = l1_config.tmode.rx_params.pm_enable; + break; + } + #if L1_GPRS + case RX_GPRS_SLOTS: + { + value = l1_config.tmode.rx_params.timeslot_alloc; + break; + } + case RX_GPRS_CODING: + { + value = l1_config.tmode.rx_params.coding_scheme; + break; + } + #endif + default: + { + Cust_tm_rx_param_read(tm_return, prim->u.tm_params.index); + return; + } + } // end switch + + memcpy(tm_return->result, (UWORD8 *)&value, 2); + tm_return->size = 2; +#if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; +#else + tm_return->status = E_OK; +#endif +} + +void l1tm_tx_param_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + tm_return->index = prim->u.tm_params.index; + tm_return->size = 0; + + switch (prim->u.tm_params.index) + { + case TX_PWR_LEVEL: + { + UWORD8 temp_txpwr, temp_band; + + if (prim->u.tm_params.value < 100) // GSM900 + { + temp_txpwr = prim->u.tm_params.value; + temp_band = 0; + } + else if (prim->u.tm_params.value < 200) // DCS1800 + { + temp_txpwr = prim->u.tm_params.value - 100; + temp_band = 1; + } + else if (prim->u.tm_params.value < 300) // PCS1900 + { + temp_txpwr = prim->u.tm_params.value - 200; + temp_band = 2; + } + else // force invalid values to return -ETM_INVAL or E_INVAL + { + temp_txpwr = 50; + temp_band = 10; + } + + // Note that the pwr level is only checked for being within the range [0..31] + // because all pwr levels should be testable. + // For subfunctions [TX_APC_DAC..TX_DELAY_DOWN]: + // temp_txpwr + 0 ==> GSM900 + // temp_txpwr + 100 ==> DCS1800 + // temp_txpwr + 200 ==> PCS1900 + + // Changing tx pwr level on the fly while in continuous mode is not supported. + if (temp_txpwr > 31 || temp_band > 2 || + l1_config.tmode.rf_params.tmode_continuous == TM_CONTINUOUS) + { + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_INVAL; + #endif + break; + } + + l1_config.tmode.tx_params.txpwr = temp_txpwr; + tx_param_band = temp_band; + + // if in TX mode, change txpwr on the fly + if ((l1_config.TestMode) && + (l1tm.tmode_state.dedicated_active) && + (l1_config.tmode.rf_params.down_up & TMODE_UPLINK)) + { + // this causes 'direct' changing of TXPWR, which is OK in TestMode + l1a_l1s_com.dedic_set.aset->new_target_txpwr = l1s.applied_txpwr = l1_config.tmode.tx_params.txpwr; + } + + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + case TX_TIMING_ADVANCE: + { + l1_config.tmode.tx_params.timing_advance = prim->u.tm_params.value; + + if (l1_config.TestMode && l1tm.tmode_state.dedicated_active) + { + // direct changing of Timing Advance + l1a_l1s_com.dedic_set.aset->new_timing_advance = l1_config.tmode.tx_params.timing_advance; + // new TA to take effect immediately + l1a_l1s_com.dedic_set.aset->timing_advance = l1a_l1s_com.dedic_set.aset->new_timing_advance; + } + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + case TX_PWR_SKIP: + { + l1_config.tmode.tx_params.txpwr_skip = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + #if L1_GPRS + case TX_GPRS_POWER0: + case TX_GPRS_POWER1: + case TX_GPRS_POWER2: + case TX_GPRS_POWER3: + case TX_GPRS_POWER4: + case TX_GPRS_POWER5: + case TX_GPRS_POWER6: + case TX_GPRS_POWER7: + { + l1_config.tmode.tx_params.txpwr_gprs[prim->u.tm_params.index - TX_GPRS_POWER0] = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + case TX_GPRS_SLOTS: + { + l1_config.tmode.tx_params.timeslot_alloc = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + case TX_GPRS_CODING: + { + UWORD8 coding_scheme; + + coding_scheme = prim->u.tm_params.value; + if ((coding_scheme < 2) || (coding_scheme > 6) || (coding_scheme == 3)) + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_INVAL; + #endif + else + { + l1_config.tmode.tx_params.coding_scheme = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + } + break; + } + #endif + default: + { + Cust_tm_tx_param_write(tm_return, + prim->u.tm_params.index, + prim->u.tm_params.value, + tx_param_band); + break; + } + } // end switch +} + +void l1tm_tx_param_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + tm_return->index = prim->u.tm_params.index; + + Cust_tm_tx_param_read(tm_return, + prim->u.tm_params.index, + tx_param_band); +} + +void l1tm_tx_template_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + Cust_tm_tx_template_write(tm_return, + prim->u.tm_table.index, + prim->str_len_in_bytes - 1, // subtract 8-bit index + prim->u.tm_table.table); +} + +void l1tm_tx_template_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + Cust_tm_tx_template_read(tm_return, prim->u.tm_table.index); +} + +/* TCS211 function missing in LoCosto, reconstructed from disassembly */ +void l1tm_mode_set(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + switch (prim->u.tm_params.index) { + case 0: + l1_config.TestMode = 0; + tm_return->status = E_OK; + break; + case 1: + l1_config.TestMode = 1; + l1_config.tx_pwr_code = 1; + l1_config.pwr_mngt = 0; + tm_return->status = E_OK; + Cust_tm_init(); + l1tm_initialize_var(); + break; + default: + tm_return->status = E_INVAL; + } + tm_return->index = 0; + tm_return->size = 0; +} + +/* TCS211 function missing in LoCosto, reconstructed from disassembly */ +void l1tm_version_get(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + UWORD16 revision; + extern T_RF rf; + + tm_return->index = prim->u.tm_params.index; + + switch (prim->u.tm_params.index) { + /* "meat" of this switch statement taken from LoCosto etm_tm3core.c */ + case BBCHIP_MODULE_REV: + revision = CHIPSET; + break; + case CHIPID_MODULE_REV: + revision = *( (volatile UWORD16 *) (MEM_JTAGID_PART)); + break; + case CHIPVER_MODULE_REV: + revision = *( (volatile UWORD16 *) (MEM_JTAGID_VER)); + break; + case DSPSW_MODULE_REV: + revision = l1s.version.dsp_code_version; + break; + case ANALOGCHIP_MODULE_REV: + revision = ((ANLG_PG << 7) | ANLG_FAM); + break; + case LAYER1_MODULE_REV: + revision = l1s.version.mcu_tcs_official; + break; + case RFDRIVER_MODULE_REV: + revision = rf.rf_revision; + break; + case TM_API_MODULE_REV: + revision = TMAPIVERSION; + break; + case L1_TM_CORE_MODULE_REV: + revision = l1s.version.mcu_tm_version; + break; + case DSP_MODULE_REV: + revision = DSP; + break; + case RF_MODULE_REV: + revision = ((RF_PA << 10) | (RF_PG << 7) | RF_FAM); + break; + default: + tm_return->status = E_BADINDEX; + tm_return->size = 0; + return; + } + memcpy(tm_return->result, &revision, sizeof revision); + tm_return->size = sizeof revision; + tm_return->status = E_OK; +} + +/* TCS211 function missing in LoCosto, reconstructed from disassembly */ +void l1tm_mem_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + UWORD8 *mem_ptr; + UWORD8 num_of_bytes; + UWORD16 i; + + mem_ptr = (UWORD8 *) prim->u.mem_write.address; + num_of_bytes = prim->str_len_in_bytes - 4; + for (i = 0; i < num_of_bytes; i++) + mem_ptr[i] = prim->u.mem_write.table[i]; + tm_return->size = 0; + tm_return->index = 0; + tm_return->status = E_OK; +} + +/* TCS211 function missing in LoCosto, reconstructed from disassembly */ +void l1tm_mem_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + tm_return->index = 0; + if (prim->u.mem_read.length > TM_PAYLOAD_UPLINK_SIZE_MAX - 4) { + tm_return->size = 0; + tm_return->status = E_BADSIZE; + return; + } + memcpy(tm_return->result, &prim->u.mem_read.length, 4); + memcpy(tm_return->result + 4, (UWORD8 *) prim->u.mem_read.src, + prim->u.mem_read.length); + tm_return->size = prim->u.mem_read.length + 4; + tm_return->status = E_OK; +} + +/* TCS211 function missing in LoCosto, reconstructed from disassembly */ +void l1tm_codec_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + UWORD16 page, reg; + + page = (prim->u.tm_params.index >> 5) & 1; + reg = prim->u.tm_params.index & 0x1F; + if (!l1_config.TestMode) { + tm_return->status = E_TESTMODE; + goto out; + } + if (page >= 2 || reg >= 32) { + tm_return->status = E_INVAL; + goto out; + } + ABB_Write_Register_on_page(page + 1, reg << 1, + prim->u.tm_params.value & 0x3FF); + tm_return->status = E_OK; +out: + tm_return->index = 0; + tm_return->size = 0; +} + +/* TCS211 function missing in LoCosto, reconstructed from disassembly */ +void l1tm_codec_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + UWORD16 page, reg; + UWORD16 value; + + page = (prim->u.tm_params.index >> 5) & 1; + reg = prim->u.tm_params.index & 0x1F; + value = ABB_Read_Register_on_page(page + 1, reg << 1); + memcpy(tm_return->result, &value, 2); + tm_return->size = 2; + tm_return->status = E_OK; + tm_return->index = 0; +} + +/* TCS211 function missing in LoCosto, reconstructed from disassembly */ +void l1tm_misc_param_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + tm_return->index = prim->u.tm_params.index; + tm_return->size = 0; + switch (prim->u.tm_params.index) { + case ADC_ENA_FLAG: + l1_config.adc_enable = prim->u.tm_params.value; + break; + default: + Cust_tm_misc_param_write(tm_return, prim->u.tm_params.index, + prim->u.tm_params.value); + return; + } + tm_return->status = E_OK; +} + +/* TCS211 function missing in LoCosto, reconstructed from disassembly */ +void l1tm_misc_param_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + UWORD16 value; + + tm_return->index = prim->u.tm_params.index; + switch (prim->u.tm_params.index) { + case ADC_ENA_FLAG: + value = l1_config.adc_enable; + break; + case CURRENT_TM_MODE: + value = l1_config.TestMode; + break; + default: + Cust_tm_misc_param_read(tm_return, prim->u.tm_params.index); + return; + } + memcpy(tm_return->result, &value, 2); + tm_return->size = 2; + tm_return->status = E_OK; +} + +/* TCS211 function missing in LoCosto, reconstructed from disassembly */ +void l1tm_misc_enable(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + Cust_tm_misc_enable(tm_return, prim->u.tm_params.index); +} + +void l1tm_special_param_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + Cust_tm_special_param_write(tm_return, + prim->u.tm_params.index, + prim->u.tm_params.value); +} + +void l1tm_special_param_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + Cust_tm_special_param_read(tm_return, prim->u.tm_params.index); +} + +void l1tm_special_table_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + Cust_tm_special_table_write(tm_return, + prim->u.tm_table.index, + prim->str_len_in_bytes - 1, + prim->u.tm_table.table); +} + +void l1tm_special_table_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + Cust_tm_special_table_read(tm_return, prim->u.tm_table.index); +} + +void l1tm_special_enable(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + Cust_tm_special_enable(tm_return, prim->u.tm_params.index); +} + +/* TCS211 function missing in LoCosto, reconstructed from disassembly */ +void l1tm_initialize(T_TM_RETURN *tm_return) +{ + Cust_tm_init(); + tm_return->status = E_OK; + tm_return->size = 0; + tm_return->index = 0; +} + +/* TCS211 function missing in LoCosto, reconstructed from disassembly */ +void l1tm_ffs(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + tm_return->size = tm_ffs(tm_return->result, 32, prim->u.ffs.packet, + prim->str_len_in_bytes); + tm_return->status = E_OK; + tm_return->index = 0; +} + +/*-------------------------------------------------------*/ +/* l1tm_initialize_var() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* ------------- */ +/* Return : */ +/* ------------- */ +/* Description : */ +/* ------------- */ +/* This routine is used to switch to TestMode by re- */ +/* initializing the l1a, l1s and l1a_l1s_com global */ +/* structures. Re-initialization is kept at a minimum. */ +/*-------------------------------------------------------*/ +void l1tm_initialize_var(void) +{ + UWORD32 i; + UWORD8 task_id; + + + // L1S tasks management... + //----------------------------------------- + for(task_id=0; task_id<NBR_DL_L1S_TASKS; task_id++) + { + l1s.task_status[task_id].new_status = NOT_PENDING; + l1s.task_status[task_id].current_status = INACTIVE; + } + l1s.frame_count = 0; + l1s.forbid_meas = 0; + + // MFTAB management variables... + //----------------------------------------- + l1s.afrm = 0; + l1s_clear_mftab(l1s.mftab.frmlst); + + // Flag registers for RF task controle... + //----------------------------------------- + l1s.tpu_ctrl_reg = 0; + l1s.dsp_ctrl_reg = 0; + + //++++++++++++++++++++++++++++++++++++++++++ + // Reset "l1a" structure. + //++++++++++++++++++++++++++++++++++++++++++ + + // Downlink tasks management... + // Uplink tasks management... + // Measurement tasks management... + //----------------------------------------- + for(i=0; i<NBR_L1A_PROCESSES; i++) + { + l1a.l1a_en_meas[i] = 0; + l1a.state[i] = 0; // RESET state. + } + + // Flag for forward/delete message management. + //--------------------------------------------- + l1a.l1_msg_forwarded = 0; + + + //++++++++++++++++++++++++++++++++++++++++++ + // Reset "l1a_l1s_com" structure. + //++++++++++++++++++++++++++++++++++++++++++ + + l1a_l1s_com.l1a_activity_flag = TRUE; + l1a_l1s_com.time_to_next_l1s_task = 0; + + + // sleep management configuration + //=============================== + l1s.pw_mgr.mode_authorized = NO_SLEEP; + + // L1S scheduler... + //==================== + + // L1S tasks management... + //----------------------------------------- + for(i=0; i<NBR_DL_L1S_TASKS; i++) + { + l1a_l1s_com.task_param[i] = SEMAPHORE_RESET; + l1a_l1s_com.l1s_en_task[i] = TASK_DISABLED; + } + + // Measurement tasks management... + //----------------------------------------- + l1a_l1s_com.meas_param = 0; + l1a_l1s_com.l1s_en_meas = 0; + + #if L1_GPRS + // Set DSP scheduler mode + l1a_l1s_com.dsp_scheduler_mode = GSM_SCHEDULER; + // Packet measurement: Reset of the frequency list. + //------------------------------------------------- + l1pa_reset_cr_freq_list(); + // Initialize active list used in Neighbour Measurement Transfer Process + l1pa_l1ps_com.cres_freq_list.alist = &(l1pa_l1ps_com.cres_freq_list.list[0]); + + l1pa_l1ps_com.transfer.semaphore = TRUE; + l1pa_l1ps_com.transfer.aset = &(l1pa_l1ps_com.transfer.set[0]); + l1pa_l1ps_com.transfer.fset[0] = &(l1pa_l1ps_com.transfer.set[1]); + l1pa_l1ps_com.transfer.fset[1] = &(l1pa_l1ps_com.transfer.set[2]); + + for(i=0;i<3;i++) + { + l1pa_l1ps_com.transfer.set[i].SignalCode = 0; + l1pa_l1ps_com.transfer.set[i].dl_tbf_synchro_timeslot = 0; + l1pa_l1ps_com.transfer.set[i].dl_tbf_synchro_timeslot = 0; + l1pa_l1ps_com.transfer.set[i].transfer_synchro_timeslot = 0; + l1pa_l1ps_com.transfer.set[i].allocated_tbf = NO_TBF; + l1pa_l1ps_com.transfer.set[i].assignment_command = NO_TBF; + l1pa_l1ps_com.transfer.set[i].multislot_class = 0; + + l1pa_l1ps_com.transfer.set[i].packet_ta.ta = 255; + l1pa_l1ps_com.transfer.set[i].packet_ta.ta_index = 255; + l1pa_l1ps_com.transfer.set[i].packet_ta.ta_tn = 255; + + l1pa_l1ps_com.transfer.set[i].tsc = 0; + + l1pa_l1ps_com.transfer.set[i].freq_param.chan_sel.h = 0; + l1pa_l1ps_com.transfer.set[i].freq_param.chan_sel. + rf_channel.single_rf.radio_freq = 0; + + l1pa_l1ps_com.transfer.set[i].tbf_sti.present = FALSE; + + l1pa_l1ps_com.transfer.set[i].mac_mode = 0; + + l1pa_l1ps_com.transfer.set[i].ul_tbf_alloc->tfi = 255; + l1pa_l1ps_com.transfer.set[i].dl_tbf_alloc.tfi = 255; + + l1pa_l1ps_com.transfer.set[i].dl_pwr_ctl.p0 = 255; + l1pa_l1ps_com.transfer.set[i].dl_pwr_ctl.bts_pwr_ctl_mode = 0; + l1pa_l1ps_com.transfer.set[i].dl_pwr_ctl.pr_mode = 0; + } + #endif + + // Init global test mode variables + l1tm.tmode_state.dedicated_active = 0; + #if L1_GPRS + l1tm.tmode_state.packet_transfer_active = FALSE; + #endif + + // PRBS seed initialization with a random pattern + l1tm.tmode_prbs.prbs1_seed = 0x5613; +} + +void l1tm_rf_enable(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + unsigned SignalCode =0; + unsigned size = 0; //omaps00090550 + xSignalHeaderRec *msg; + UWORD8 send_prim = FALSE; // Flag to send TestMode primitive... + // Do not send primitive is the default; change it if necessary + UWORD8 band; + tm_return->index = 0; // don't include index in header +#if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; +#else + tm_return->status = E_OK; +#endif + + // Function only valid in TEST mode + if (l1_config.TestMode == 0) + { + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_L1TESTMODE; + #else + tm_return->status = E_TESTMODE; + #endif + } + else + { + // Reset all statistics + l1tm_reset_rx_stats(); + + // Reset receive state counters, unless already in dedicated mode + if (!l1tm.tmode_state.dedicated_active) + l1tm_reset_rx_state(); + + // Reset monitor task + l1_config.tmode.rf_params.mon_report = 0; + l1_config.tmode.rf_params.mon_tasks = 0; + + switch (prim->u.tm_params.index) + { + // Stop all RX and TX operations + case STOP_ALL: + { + SignalCode = TMODE_STOP_RX_TX; + size = sizeof(T_TMODE_STOP_RX_TX); + l1tm.tmode_state.dedicated_active = 0; + #if (RF_FAM == 61) + // Reset the APC back to Automatic Mode + l1ddsp_apc_set_automatic_mode(); + #endif + + #if (RF_FAM == 35) + pll_tuning.enable=0; + #endif + // Reset down_up flag only if not in continuous mode. If in continuous mode, down_up + // will be reset after the proper TPU scenario is loaded. + if (l1_config.tmode.rf_params.tmode_continuous != TM_CONTINUOUS) + l1_config.tmode.rf_params.down_up = 0; + send_prim = TRUE; + break; + } + // RX with or without network synchronization first + case RX_TCH: + { + // if already in UL-only + if (l1tm.tmode_state.dedicated_active && + l1_config.tmode.rf_params.down_up == TMODE_UPLINK) + { + // cannot start to RX while already TXing + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_AGAIN; + #else + tm_return->status = E_AGAIN; + #endif + } + else + { + l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK; + SignalCode = TMODE_IMMED_ASSIGN_REQ; + size = sizeof(T_TMODE_IMMED_ASSIGN_REQ); + send_prim = TRUE; + } + break; + } + // TX NB's or AB's on TCH with or without network synch. first + case TX_TCH: + { + // Normal burst TX + if (l1_config.tmode.tx_params.burst_type == 0) + { + // if already in DL-only, add UL + if (l1tm.tmode_state.dedicated_active && + l1_config.tmode.rf_params.down_up == TMODE_DOWNLINK) + { + l1_config.tmode.rf_params.down_up = (TMODE_DOWNLINK | TMODE_UPLINK); + } + else + { + l1_config.tmode.rf_params.down_up = TMODE_UPLINK; + SignalCode = TMODE_IMMED_ASSIGN_REQ; + size = sizeof(T_TMODE_IMMED_ASSIGN_REQ); + send_prim = TRUE; + } + } + // AB TX + else if (l1_config.tmode.tx_params.burst_type == 1) + { + // cannot start RACH while already in dedicated mode + if (l1tm.tmode_state.dedicated_active) + { + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_AGAIN; + #else + tm_return->status = E_AGAIN; + #endif + } + else + { + SignalCode = TMODE_RA_START; + size = sizeof(TMODE_RA_START); + send_prim = TRUE; + } + } + break; + } + // RX & TX on TCH with or without network synch. first + case RX_TX_TCH: + { + // if NB TX + if (l1_config.tmode.tx_params.burst_type == 0) + { + // if already in DL-only, add UL + if (l1tm.tmode_state.dedicated_active && + l1_config.tmode.rf_params.down_up == TMODE_DOWNLINK) + { + l1_config.tmode.rf_params.down_up = (TMODE_DOWNLINK | TMODE_UPLINK); + } + // else if already in UL-only + else if (l1tm.tmode_state.dedicated_active && + l1_config.tmode.rf_params.down_up == TMODE_UPLINK) + { + // cannot start to RX while already TXing + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_AGAIN; + #else + tm_return->status = E_AGAIN; + #endif + } + else + { + l1_config.tmode.rf_params.down_up = (TMODE_DOWNLINK | TMODE_UPLINK); + SignalCode = TMODE_IMMED_ASSIGN_REQ; + size = sizeof(T_TMODE_IMMED_ASSIGN_REQ); + send_prim = TRUE; + } + } + // else if AB TX + else if (l1_config.tmode.tx_params.burst_type == 1) + { + // Cannot TX RACH and RX simultaneously + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_AGAIN; + #else + tm_return->status = E_AGAIN; + #endif + } + break; + } + // Continuous (all timeslots) reception on TCH + case RX_TCH_CONT: + { + // if already in UL, DL or UL+DL + if (l1tm.tmode_state.dedicated_active && + l1_config.tmode.rf_params.down_up != 0) + { + // cannot start to continously RX while already TXing or RXing + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_AGAIN; + #else + tm_return->status = E_AGAIN; + #endif + } + else + { + l1_config.tmode.rf_params.tmode_continuous = TM_START_RX_CONTINUOUS; + l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK; + SignalCode = TMODE_IMMED_ASSIGN_REQ; + size = sizeof(T_TMODE_IMMED_ASSIGN_REQ); + send_prim = TRUE; + } + break; + } + // continuous (all timeslots) transmission + case TX_TCH_CONT: + { + // PCS 1900 not supported yet. +#if (L1_FF_MULTIBAND == 0) + band = ((l1_config.tmode.rf_params.tch_arfcn >= 512) && + (l1_config.tmode.rf_params.tch_arfcn <= 885)); +#else + band = ( ((l1_config.tmode.rf_params.tch_arfcn >= 512) && + (l1_config.tmode.rf_params.tch_arfcn <= 885)) || + ((l1_config.tmode.rf_params.tch_arfcn >= 1024) && + (l1_config.tmode.rf_params.tch_arfcn <= 1322)) ); +#endif + + // if already in UL, DL or UL+DL + if ((l1tm.tmode_state.dedicated_active && l1_config.tmode.rf_params.down_up != 0) || + (band == 0 && (l1_config.tmode.tx_params.txpwr < (5 + l1_config.tmode.tx_params.txpwr_skip))) || + (band == 1 && (l1_config.tmode.tx_params.txpwr < (0 + l1_config.tmode.tx_params.txpwr_skip)))) + { + // cannot start to continously TX while already TXing or RXing + // or while adc reading are enabled + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_INVAL; + #endif + } + else + { + #if (RF_FAM == 61) + // Set APC in Manual Mode + l1ddsp_apc_set_manual_mode(); + #endif + l1_config.tmode.rf_params.tmode_continuous = TM_START_TX_CONTINUOUS; + l1_config.tmode.rf_params.down_up = TMODE_UPLINK; + SignalCode = TMODE_IMMED_ASSIGN_REQ; + size = sizeof(T_TMODE_IMMED_ASSIGN_REQ); + send_prim = TRUE; + } + break; + } + // Continuous BCCH + case BCCH_LOOP: + { + SignalCode = TMODE_SCELL_NBCCH_REQ; + size = sizeof(TMODE_SCELL_NBCCH_REQ); + send_prim = TRUE; + break; + } + // Continuous SB + case SB_LOOP: + { + SignalCode = TMODE_SB_REQ; + size = sizeof(T_TMODE_SB_REQ); + send_prim = TRUE; + break; + } + // Continuous FB1 + case FB1_LOOP: + { + SignalCode = TMODE_FB1_REQ; + size = sizeof(T_TMODE_FB1_REQ); + send_prim = TRUE; + break; + } + // Continuous FB0 + case FB0_LOOP: + { + SignalCode = TMODE_FB0_REQ; + size = sizeof(T_TMODE_FB0_REQ); + send_prim = TRUE; + break; + } + // TX + RX + MON on TCH + case RX_TX_MON_TCH: // Stats collected from TCH Channel. + case RX_TX_MON: // Stats collected from MON Channel (except rxlev). + { + // Normal burst uplink + if (l1_config.tmode.tx_params.burst_type == 0) + { + // If already in dedicated mode, return error + if (l1tm.tmode_state.dedicated_active) + { + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_AGAIN; + #else + tm_return->status = E_AGAIN; + #endif + } + else + { + l1_config.tmode.rf_params.down_up = (TMODE_DOWNLINK | TMODE_UPLINK); + l1_config.tmode.rf_params.mon_report = ((prim->u.tm_params.index & 0x08) >> 3); + l1_config.tmode.rf_params.mon_tasks = 1; // enable MON tasks + SignalCode = TMODE_IMMED_ASSIGN_REQ; + size = sizeof(T_TMODE_IMMED_ASSIGN_REQ); + send_prim = TRUE; + } + } + // else if Access burst uplink + else if (l1_config.tmode.tx_params.burst_type == 1) + { + // Cannot TX RACH and RX simultaneously + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_AGAIN; + #else + tm_return->status = E_AGAIN; + #endif + } + break; + } + case SINGLE_PM: + { + SignalCode = TMODE_RXLEV_REQ; + size = sizeof(T_TMODE_RXLEV_REQ); + send_prim = TRUE; + break; + } + #if L1_GPRS + // RX & TX on PDTCH with or without network synch. first + case RX_TX_PDTCH: + { + UWORD8 bit_map = 0x80; + + // set uplink + downlink + if (l1_config.tmode.tx_params.timeslot_alloc) + l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK | TMODE_UPLINK; + else + l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK; + + while (bit_map) + { + if (bit_map & l1_config.tmode.stats_config.stat_gprs_slots) + l1tm.tmode_stats.nb_dl_pdtch_slots ++; + + bit_map>>=1; + } + + SignalCode = TMODE_PDTCH_ASSIGN_REQ; + size = sizeof(T_TMODE_PDTCH_ASSIGN_REQ); + send_prim = TRUE; + break; + } + #endif + #if L1_GPRS + // RX & TX on PDTCH, FB on monitor arfcn + case RX_TX_PDTCH_MON: + { + // set uplink + downlink + if (l1_config.tmode.tx_params.timeslot_alloc) + l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK | TMODE_UPLINK; + else + l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK; + + l1_config.tmode.rf_params.mon_report = 1; // collect stats from MON channel + l1_config.tmode.rf_params.mon_tasks = 1; // enable MON tasks + + SignalCode = TMODE_PDTCH_ASSIGN_REQ; + size = sizeof(T_TMODE_PDTCH_ASSIGN_REQ); + send_prim = TRUE; + break; + } + #endif + #if (RF_FAM == 35) + case RX_PLL_TUNING: + { + // if already in UL-only + if (l1tm.tmode_state.dedicated_active && + l1_config.tmode.rf_params.down_up == TMODE_UPLINK) + { + // cannot start to RX while already TXing + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_AGAIN; + #else + tm_return->status = E_AGAIN; + #endif + } + else + { + pll_tuning.data[5] = 0; + pll_tuning.index = 0; + + pll_tuning.enable = 1; + + l1_config.tmode.rf_params.down_up = TMODE_DOWNLINK; + SignalCode = TMODE_IMMED_ASSIGN_REQ; + size = sizeof(T_TMODE_IMMED_ASSIGN_REQ); + send_prim = TRUE; + } + break; + } + #endif + default: + { + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_BADINDEX; + #endif + break; + } + } //end switch + } // end of else + + if (send_prim == TRUE) + { + // Allocate result message. + msg = os_alloc_sig(size); + DEBUGMSG(status,NU_ALLOC_ERR) + msg->SignalCode = SignalCode; + os_send_sig(msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + + // always return a 0 in the result[], even if error + tm_return->result[0] = 0; + tm_return->size = 1; +} + + +void l1tm_stats_config_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + tm_return->index = prim->u.tm_params.index; + tm_return->size = 0; + + switch (prim->u.tm_params.index) + { + case LOOPS: + { + l1_config.tmode.stats_config.num_loops = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + case AUTO_RESULT_LOOPS: + { + l1_config.tmode.stats_config.auto_result_loops = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + case AUTO_RESET_LOOPS: + { + l1_config.tmode.stats_config.auto_reset_loops = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + case STAT_TYPE: + { + l1_config.tmode.stats_config.stat_type = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + case STAT_BITMASK: + { + l1_config.tmode.stats_config.stat_bitmask = prim->u.tm_params.value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + #if L1_GPRS + case STAT_GPRS_SLOTS: + { + UWORD8 allocation, value; + + value = prim->u.tm_params.value; + + // Check for mismatch between DL TS allocation and stats bitmap + allocation = value ^ l1_config.tmode.rx_params.timeslot_alloc; + + if (value & allocation) + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_INVAL; + #endif + else + { + l1_config.tmode.stats_config.stat_gprs_slots = value; + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + } + break; + } + #endif + default: + { + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_BADINDEX; + #endif + break; + } + } // end switch +} + +void l1tm_stats_config_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + volatile UWORD16 value; + + tm_return->index = prim->u.tm_params.index; + + switch (prim->u.tm_params.index) + { + case LOOPS: + { + value = l1_config.tmode.stats_config.num_loops; + break; + } + case AUTO_RESULT_LOOPS: + { + value = l1_config.tmode.stats_config.auto_result_loops; + break; + } + case AUTO_RESET_LOOPS: + { + value = l1_config.tmode.stats_config.auto_reset_loops; + break; + } + case STAT_TYPE: + { + value = l1_config.tmode.stats_config.stat_type; + break; + } + case STAT_BITMASK: + { + value = l1_config.tmode.stats_config.stat_bitmask; + break; + } + #if L1_GPRS + case STAT_GPRS_SLOTS: + { + value = l1_config.tmode.stats_config.stat_gprs_slots; + break; + } + #endif + default: + { + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_BADINDEX; + #endif + tm_return->size = 0; + return; + } + } // end switch + + memcpy(tm_return->result, (UWORD8 *) &value, 2); + tm_return->size = 2; +#if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; +#else + tm_return->status = E_OK; +#endif +} + +void l1tm_statistics(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) +{ + l1tm_stats_read(tm_return, + prim->u.tm_params.index, + prim->u.tm_params.value); +} + +#if L1_GPRS +void l1tm_rlc_uplink(UWORD8 tx, API *ul_data) +{ + // Cast the ul_data_buffer + typedef struct + { + API a_ul_data[4][29]; + } + T_A_UL_DATA; + + T_A_UL_DATA *ptr = (T_A_UL_DATA*) ul_data; + UWORD8 i,j; + + for (j=0; j<tx; j++) + { + ptr->a_ul_data[j][0] = l1_config.tmode.tx_params.coding_scheme; + + for (i=0;i<l1_config.tmode.tx_params.rlc_buffer_size;i++) + ptr->a_ul_data[j][i+1] = l1_config.tmode.tx_params.rlc_buffer[i]; + } +} +#endif + +void l1tm_stats_read(T_TM_RETURN *tm_return, WORD16 type, UWORD16 bitmask) +{ + extern T_L1A_L1S_COM l1a_l1s_com; + extern T_L1S_GLOBAL l1s; + volatile UWORD32 utemp = bitmask, temp_U32; + volatile WORD32 temp = type; + volatile WORD32 value_signed_int; + volatile UWORD32 value_unsigned_int; + volatile UWORD16 value_unsigned_short; + UWORD8 j, offset=0; // offset is index of tm_return->result[] + UWORD16 rssi, len; + WORD32 count; + WORD32 runs = l1tm.tmode_stats.loop_count; + + /* + * FreeCalypso TCS211 reconstruction: the following automatic var + * is for the BLER code we have conditioned out below. + */ + #if 0 //L1_GPRS + volatile UWORD16 value_array_unsigned_short[4]; + #endif + + // Put type and bitmask in the front of tm_return->result[]. + // Use volatile vars for proper operation of memcpy(). + memcpy(&tm_return->result[offset], (UWORD8 *) &temp, 2); + offset+=2; + memcpy(&tm_return->result[offset], (UWORD8 *) &utemp, 2); + offset+=2; + + switch (type) + { + // Accumulated receive burst stats + case ACCUMULATED_RX_STATS: + { + // all stats saved when collected from TCH + if (l1tm.tmode_state.dedicated_active && (l1_config.tmode.rf_params.mon_report == 0)) + count = l1tm.tmode_stats.loop_count; + #if L1_GPRS + else if (l1tm.tmode_state.packet_transfer_active && (l1_config.tmode.rf_params.mon_report == 0)) + { + // loop_count contains the number of blocks + // Stats (PM, TOA, SNR, ANGLE) are accumulated over all frames and all time slots + count = l1tm.tmode_stats.loop_count * l1tm.tmode_stats.nb_dl_pdtch_slots * 4; + + // the count of runs vs. successes is accumulated over all time slots per block + runs = l1tm.tmode_stats.loop_count * l1tm.tmode_stats.nb_dl_pdtch_slots; + } + #endif + else count = l1tm.tmode_stats.flag_count; // only PASS stats saved + + if (bitmask & RSSI) // rxlev: RSSI SF12.4 eventually (currently F7.1) + { + len = sizeof(l1tm.tmode_stats.rssi_fifo) / sizeof(l1tm.tmode_stats.rssi_fifo[0]); + rssi = 0; + for (j=0; j<len; j++) + rssi += l1tm.tmode_stats.rssi_fifo[j]; + rssi /= len; // F7.1 + memcpy(&tm_return->result[offset], (UWORD8 *) &rssi, 2); + offset+=2; + } + // pm: DSP MEAN power measurement UF10.6 + if (bitmask & DSP_PM) + { + if (count) + value_unsigned_short = l1tm.tmode_stats.pm_sum / count; + else value_unsigned_short = 0; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_short, 2); + offset+=2; + } + // angle mean + if (bitmask & ANGLE_MEAN) + { + if (count) // non-zero + value_signed_int = l1tm.tmode_stats.angle_sum / count; + else value_signed_int = 0; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_signed_int, 4); + offset+=4; + } + // angle variance + if (bitmask & ANGLE_VAR) + { + // VAR[X] = E[X^2] - (E[X])^2 + if (count) // non-zero + { + temp_U32 = l1tm.tmode_stats.angle_sum / count; + value_unsigned_int = l1tm.tmode_stats.angle_sq_sum / count - (temp_U32)*(temp_U32); + } + else value_unsigned_int = 0; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4); + offset+=4; + } + // angle minimum + if (bitmask & ANGLE_MIN) + { + value_signed_int = l1tm.tmode_stats.angle_min; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_signed_int, 4); + offset+=4; + } + // angle maximum + if (bitmask & ANGLE_MAX) + { + value_signed_int = l1tm.tmode_stats.angle_max; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_signed_int, 4); + offset+=4; + } + // SNR mean + if (bitmask & SNR_MEAN) + { + if (count) // non-zero + value_unsigned_int = l1tm.tmode_stats.snr_sum / count; + else value_unsigned_int = 0; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4); + offset+=4; + } + // SNR variance + if (bitmask & SNR_VAR) + { + if (count) // non-zero + { + temp_U32 = l1tm.tmode_stats.snr_sum / count; + value_unsigned_int = l1tm.tmode_stats.snr_sq_sum / count - + temp_U32 * temp_U32; + } + else + value_unsigned_int = 0; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4); + offset+=4; + } + // TOA mean + if (bitmask & TOA_MEAN) + { + if (count) // non-zero + value_unsigned_int = l1tm.tmode_stats.toa_sum / count; + else value_unsigned_int = 0; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4); + offset+=4; + } + // TOA variance + if (bitmask & TOA_VAR) + { + if (count) // non-zero + { + temp_U32 = l1tm.tmode_stats.toa_sum / count; + value_unsigned_int = l1tm.tmode_stats.toa_sq_sum / count - + temp_U32 * temp_U32; + } + else value_unsigned_int = 0; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4); + offset+=4; + } + // Frame # mod 26*51 + if (bitmask & FRAME_NUMBER) + { + value_unsigned_int = l1s.actual_time.fn; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4); + offset+=4; + } + // Tot # of runs executed so far + if (bitmask & RUNS) + { + memcpy(&tm_return->result[offset], (UWORD8 *) &runs, 4); + offset+=4; + } + // Tot # of successes so far + if (bitmask & SUCCESSES) + { + memcpy(&tm_return->result[offset], (UWORD8 *) &l1tm.tmode_stats.flag_count, 4); + offset+=4; + } + // BSIC + if (bitmask & BSIC) + { + value_unsigned_short = l1tm.tmode_stats.bsic; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_short, 2); + offset+=2; + } + +/* + * FreeCalypso TCS211 reconstruction: suspected LoCosto-ism, + * removing in order to pass compilation. + */ +#if 0 //L1_GPRS + if (bitmask & BLER) + { + UWORD8 j; + if (count) // non-zero + { + float bler, remain_part; + UWORD8 int_part, bitmap_remain; + int i; + + //compute bler for each block + for (j=0; j<4; j++) + { + bler = ((float) (l1tm.tmode_stats.bler_crc[j] * 100)) / ((float) l1tm.tmode_stats.bler_total_blocks); + + //conversion from floating to fixed format + int_part = (UWORD8) bler; + remain_part = bler - (float) int_part; + bitmap_remain = 0; + + i=5; + while (i >= 0) + { + bitmap_remain |= (UWORD8) (remain_part *2) << i; + if (((UWORD8) (remain_part *2)) >= 1) + remain_part = (remain_part * 2) - 1; + else + remain_part = (remain_part * 2); + i--; + } + + // Reporting the percentage of blocks in error (F10.6) + value_array_unsigned_short[j] = bitmap_remain | (int_part << 6); + } + } + // Reporting a BLER of 100, if no computation has been done + else + { + for (j=0; j<4; j++) + value_array_unsigned_short[j] = 100 << 6; + } + memcpy(&tm_return->result[offset], (UWORD8 *) &value_array_unsigned_short[0], 8); + offset+=8; + } +#endif + + + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + // Most recent receive burst stats + case MOST_RECENT_RX_STATS: + { + // rxlev: RSSI SF12.4 eventually (F7.1 currently) + if (bitmask & RSSI) + { + value_unsigned_short = l1tm.tmode_stats.rssi_recent; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_short, 2); + offset+=2; + } + // pm: most recent DSP power measurement UF10.6 + if (bitmask & DSP_PM) + { + memcpy(&tm_return->result[offset], &l1tm.tmode_stats.pm_recent, 2); + offset+=2; + } + // most recent ANGLE value + if (bitmask & ANGLE_MEAN) + { + value_signed_int = l1tm.tmode_stats.angle_recent; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_signed_int, 4); + offset+=4; + } + // doesn't make sense. + if (bitmask & ANGLE_VAR) + { + } + // doesn't make sense. + if (bitmask & ANGLE_MIN) + { + } + // doesn't make sense. + if (bitmask & ANGLE_MAX) + { + } + // most recent SNR value + if (bitmask & SNR_MEAN) + { + value_unsigned_int = l1tm.tmode_stats.snr_recent; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4); + offset+=4; + } + // doesn't make sense. + if (bitmask & SNR_VAR) + { + } + // most recent TOA value + if (bitmask & TOA_MEAN) + { + value_unsigned_int = l1tm.tmode_stats.toa_recent; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4); + offset+=4; + } + // doesn't make sense. + if (bitmask & TOA_VAR) + { + } + // Frame # mod 26*51 + if (bitmask & FRAME_NUMBER) + { + value_unsigned_int = l1s.actual_time.fn; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_int, 4); + offset+=4; + } + // must be '1' + if (bitmask & RUNS) + { + } + // most recent Success flag + if (bitmask & SUCCESSES) + { + memcpy(&tm_return->result[offset], (UWORD8 *)&l1tm.tmode_stats.flag_recent, 4); + offset+=4; + } + // BSIC + if (bitmask & BSIC) + { + value_unsigned_short = l1tm.tmode_stats.bsic; + memcpy(&tm_return->result[offset], (UWORD8 *) &value_unsigned_short, 2); + offset+=2; + } + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_OK; + #else + tm_return->status = E_OK; + #endif + break; + } + default: + { + #if (ETM_PROTOCOL == 1) + tm_return->status = -ETM_INVAL; + #else + tm_return->status = E_BADINDEX; + #endif + break; + } + } // end switch + + tm_return->size = offset; + tm_return->index = 0; // don't include index in header +} + +/*-------------------------------------------------------*/ +/* l1tm_fill_burst() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: Prepare bursts for transmission in case */ +/* ------------ of UL test */ +/* */ +/* Simulation of IQ Swap does the following mapping: */ +/* */ +/* 00 -> 01 */ +/* 01 -> 00 */ +/* 10 -> 11 */ +/* 11 -> 10 */ +/* */ +/*-------------------------------------------------------*/ +#if (L1_FF_MULTIBAND == 1) +extern const WORD8 rf_subband2band[]; +#endif +void l1tm_fill_burst (UWORD16 pattern, UWORD16 *TM_ul_data) +{ + UWORD32 i; + UWORD8 swap_iq, swap_flag; + UWORD16 gb_front, gb_end, tb_front, tb_end, even_bits, odd_bits; +#if (L1_FF_MULTIBAND == 1) + UWORD8 physical_band_id; +#endif + UWORD8 tsc_bits_in_first_word; + UWORD16 tsc_front_mask,tsc_end_mask; + extern T_RF rf; + + // training sequences list...... + UWORD32 tsc[8]= + { + 0x00970897, + 0x00B778B7, + 0x010EE90E, + 0x011ED11E, + 0x006B906B, + 0x013AC13A, + 0x029F629F, + 0x03BC4BBC + }; +#if (L1_FF_MULTIBAND == 0) + + if(((l1_config.std.id == DUAL) || (l1_config.std.id == DUALEXT) || (l1_config.std.id == DUAL_US)) && + (l1_config.tmode.rf_params.tch_arfcn >= l1_config.std.first_radio_freq_band2)) + { + swap_iq = l1_config.std.swap_iq_band2; + } + else + { + swap_iq = l1_config.std.swap_iq_band1; + } + +#else // L1_FF_MULTIBAND = 1 below + + physical_band_id = + rf_subband2band[rf_convert_rffreq_to_l1subband(l1_config.tmode.rf_params.tch_arfcn)]; + + swap_iq = rf_band[physical_band_id].swap_iq; + +#endif // #if (L1_FF_MULTIBAND == 0) else + + // Swap IQ definitions... + // 0=No Swap, 1=Swap RX only, 2=Swap TX only, 3=Swap RX and TX + if (swap_iq & 0x2) + { + swap_flag = 1; + } + else + { + swap_flag = 0; + } + + //=========================================== + // define uplink patterns + //=========================================== + if (pattern == 0) // 0's + pattern = 0x0000; + else if (pattern == 1) // 1's + pattern = 0xffff; + else if (pattern == 2) // 01's + pattern = 0x5555; + + // first replicate pattern through all buffer + if ((pattern == 3) || (pattern == 4)) + { + // fill the uplink burst with PRBS1 + l1tm_PRBS1_generate(TM_ul_data); + } + else if ((pattern != 12) && (pattern != 13)) + { + for (i=0;i<=15;i++) + TM_ul_data[i] = (pattern << 6); + } + + //=========================================== + // create front-end guard and tail bits masks + //=========================================== + // guard bits mask + gb_front = 0xFFC0 << (10 - rf.tx.guard_bits); // max. of 10, min. of 2 guard bits allowed + + // check if guard bits > 7 + if (rf.tx.guard_bits > 7) + { + // tail bits mask + tb_front = ~((UWORD16)(0xE000 << (10 - rf.tx.guard_bits))) & 0xFFC0; // tail bits placed in TM_ul_data[1] //oamps00090550 + // add tail bits to uplink data + TM_ul_data[1] = TM_ul_data[1] & tb_front; + // add guard bits to uplink data + TM_ul_data[0] = gb_front; + } + else + { + // tail bits mask + tb_front = ~((UWORD16)(0xE000 >> rf.tx.guard_bits) )& 0xFFC0; // 3 tail bits + // add tail bits to uplink data + TM_ul_data[0] = (TM_ul_data[0] | gb_front) & tb_front; + } + + //=========================================== + // create back-end guard and tail bits masks + //=========================================== + // guard bits mask + gb_end = (0xFFC0 >> (10 - (12 - rf.tx.guard_bits))) & 0xFFC0; // max. of 10, min. of 2 guard bits allowed + + // check if guard bits < 5 + if (rf.tx.guard_bits < 5) + { + //tail bits mask + tb_end = ~(UWORD16)((0x01C0 >> (rf.tx.guard_bits - 2))) & 0xFFC0; // tail bits placed in TM_ul_data[14] + // add tail bits to uplink data + TM_ul_data[14] = TM_ul_data[14] & tb_end; + // add guard bits to uplink data + TM_ul_data[15] = gb_end; + } + else + { + // tail bits mask + tb_end = ~(UWORD16)((0x01C0 << (12 - rf.tx.guard_bits))) & 0xFFC0; // 3 tail bits + // add tail bits to uplink data + TM_ul_data[15] = (TM_ul_data[15] | gb_end) & tb_end; + } + + //=========================================== + // Insert the training sequence pattern .The location of TSC bits will + // vary according to the value of guard bits used. + //=========================================== + if ((pattern == 13)||(pattern==3)) + { + // TM_ul_data[6] = (TM_ul_data[6] & 0xFE00) | ( (UWORD8) ((tsc[l1_config.tmode.tx_params.tsc]>>24) << 6 ) ); // tsc bits 1-2 + // TM_ul_data[7] = (TM_ul_data[7] & 0x0000) | ( (UWORD8) ((tsc[l1_config.tmode.tx_params.tsc]>>14) << 6 ) ); // tsc bits 3-12 + // TM_ul_data[8] = (TM_ul_data[8] & 0x0000) | ( (UWORD8) ((tsc[l1_config.tmode.tx_params.tsc]>>4 ) << 6 ) ); // tsc bits 13-22 + // TM_ul_data[9] = (TM_ul_data[9] & 0x07C0) | ( (UWORD8) ((tsc[l1_config.tmode.tx_params.tsc]>>0 ) << 12) ); // tsc bits 23-26 + + if (rf.tx.guard_bits <4) // TSC will be in [6],[7],[8] + { + tsc_bits_in_first_word = 9-rf.tx.guard_bits; // 7 bits when guard is 2, 6 bit when guard is 3 + tsc_front_mask = ((0xFFC0) << tsc_bits_in_first_word); // insert zeros from right + //tsc_bits_in_last_word = 26 -10 -tsc_bits_in_first_word = (16-tsc_bits_in_first_word) + tsc_end_mask = (((0xFFC0) >> (16-tsc_bits_in_first_word)) & 0xFFC0); //insert zeros from left + + TM_ul_data[6] = (TM_ul_data[6] & tsc_front_mask) + | ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]>>(26-tsc_bits_in_first_word)) << 6 )) & (~tsc_front_mask) ); + TM_ul_data[7] = (TM_ul_data[7] & 0x0000) + | ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]<<(tsc_bits_in_first_word+6))>>16)) & (0xFFC0)); //next 10 bits of TSC + TM_ul_data[8] = (TM_ul_data[8] & tsc_end_mask) + | ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc] << (tsc_bits_in_first_word+6+10))>>16) )& (~tsc_end_mask)); + } + else if ((rf.tx.guard_bits >=4) && (rf.tx.guard_bits <9) )// TSC will be in [6],[7],[8],[9] + { + tsc_bits_in_first_word = 9-rf.tx.guard_bits; // 5 bits when guard is 4, 1 bit when guard is 8 + tsc_front_mask = ((0xFFC0) << tsc_bits_in_first_word); // insert zeros from right + //tsc_bits_in_last_word = 26 -10 -10 -tsc_bits_in_first_word = (6-tsc_bits_in_first_word) + tsc_end_mask = (((0xFFC0) >> (6-tsc_bits_in_first_word)) & 0xFFC0); //insert zeros from left + + TM_ul_data[6] = (TM_ul_data[6] & tsc_front_mask) + | ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]>>(26-tsc_bits_in_first_word)) << 6 )) & (~tsc_front_mask) ); + TM_ul_data[7] = (TM_ul_data[7] & 0x0000) + | ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]<<(tsc_bits_in_first_word+6))>>16)) & (0xFFC0) ); //next 10 bits of TSC + TM_ul_data[8] = (TM_ul_data[8] & 0x0000) + | ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]<<(tsc_bits_in_first_word+6+10))>>16)) & (0xFFC0) ); //next 10 bits of TSC + TM_ul_data[9] = (TM_ul_data[9] & tsc_end_mask) + | ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc] << (tsc_bits_in_first_word+6+10+10))>>16) ) & (~tsc_end_mask)); + } + else //(rf.tx.guard_bits>=9) : TSC will be in [7],[8],[9], + { + tsc_bits_in_first_word = 19-rf.tx.guard_bits; // 10 bits when guard is 9, 9 bits when guard is 10 + tsc_front_mask = ((0xFFC0) << tsc_bits_in_first_word); // insert zeros from right + //tsc_bits_in_last_word = 26 -10 -tsc_bits_in_first_word = (16-tsc_bits_in_first_word) + tsc_end_mask = (((0xFFC0) >> (16-tsc_bits_in_first_word)) & 0xFFC0); //insert zeros from left + + TM_ul_data[7] = (TM_ul_data[7] & tsc_front_mask) + | ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]>>(26-tsc_bits_in_first_word)) << 6 )) & (~tsc_front_mask) ); + TM_ul_data[8] = (TM_ul_data[8] & 0x0000) + | ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc]<<(tsc_bits_in_first_word+6))>>16)) & (0xFFC0) ); //next 10 bits of TSC + TM_ul_data[9] = (TM_ul_data[9] & tsc_end_mask) + | ( ((UWORD16) ((tsc[l1_config.tmode.tx_params.tsc] << (tsc_bits_in_first_word+6+10))>>16)) & (~tsc_end_mask)); + } + } + + // swap uplink data if IQ swap + if(swap_flag) + { + for (i=0;i<=15;i++) + { + even_bits = TM_ul_data[i] & 0xAA80; // keep bits in even positions + odd_bits = ~(TM_ul_data[i]) & 0x5540; // keep and complement bits in odd positions + TM_ul_data[i] = even_bits | odd_bits; // swapped uplink data + } + } +} + + + +void l1a_tmode_send_ul_msg(T_TM_RETURN *tm_ret) +{ + tm_transmit(tm_ret); +} + +/******************************************************************************* + * + * void tm_receive(void *inbuf, int size) + * + * Purpose : Parses TestMode data and copies it directly into TESTMODE_PRIM. + * It forwards primitive to L1, except in the case of tm_init() which + * gets executed in the CST. + * + * Arguments: In : command + * Out: + * + * Returns : void + * + ******************************************************************************/ + +void tm_receive(UWORD8 *inbuf, UWORD16 size) +{ + UWORD8 cksum, cid, error = 0; + BOOL msg_used=FALSE; + + #if (ETM_PROTOCOL == 1) + UWORD8 mid = 0; + #endif + + UWORD8 *pmsg; + xSignalHeaderRec *msg; + + msg = os_alloc_sig(sizeof(T_TESTMODE_PRIM)); + msg->SignalCode = TESTMODE_PRIM; + + // pmsg will be used to fill up the TestMode primitive with th + // data, in consecutive order according to the definition of T_TESTMODE_PRIM. + pmsg = (UWORD8 *)((T_TESTMODE_PRIM *)(msg->SigP)); + +#if (ETM_PROTOCOL == 1) // Use of ETM protocol + #if (OP_L1_STANDALONE == 1) + // Check MID + *pmsg++ = mid = *inbuf++; + if ((mid != ETM_RF) && (mid != ETM_CORE)) // check if coming from ETM RF or ETM CORE DLL + error = -ETM_PACKET; + #elif (OP_L1_STANDALONE == 0) + *pmsg++ = mid = ETM_RF; + #endif + + // Copy CID/FID + *pmsg++ = cid = *inbuf++; + #if (OP_L1_STANDALONE == 1) + // Copy data payload size (size minus MID byte and checksum byte) + size -= 2; + #endif + *pmsg++ = --size; // Size of TM payload -1 for cid/fid + + // Validate data payload size: check if longer than size of testmode + // primitive minus cid, str_len_in_bytes, and two holes FIXME: This is a + // really bad way of doing it! + if (size > sizeof(T_TESTMODE_PRIM) - 4) + error = -ETM_PACKET; + + // The CID have been received. The data that follows are part of a + // unique struct within the union of T_TESTMODE_PRIM, so we now + // need to align at a 32-bit word boundary. + *pmsg++ = 0; + + // In a SSA integration the cksum is done in the etm_receive function + #if (OP_L1_STANDALONE == 1) + if (!error) + { + cksum = mid; + cksum ^= cid; + + while (size--) + { + cksum ^= *inbuf; + *pmsg++ = *inbuf++; + } + if (cksum != *inbuf) + error = -ETM_PACKET; + } + #elif (OP_L1_STANDALONE == 0) + // Copy payload without cid/fid + while (size--) + { + *pmsg++ = *inbuf++; + } + #endif + + // At this point, all the data have been parsed and copied into + // the TestMode primitive. Now we send the primitive to L1. + if (!error) + { + os_send_sig(msg, L1C1_QUEUE); + msg_used=TRUE; + } + else + { + UWORD8 mymsg[4]; + + // on error, return short error message; cid, error, checksum + mymsg[0] = mid; + mymsg[1] = cid; // the payload fid + mymsg[2] = error; // status + mymsg[3] = cid ^ error; // checksum + + #if (TRACE_TYPE==0) || (TRACE_TYPE==1) || (TRACE_TYPE==4) || (TRACE_TYPE==7) + rvt_send_trace_cpy((T_RVT_BUFFER) mymsg, + tm_trace_user_id, + 4, + RVT_BINARY_FORMAT); + #endif + } + +#else // end of (ETM_PROTOCOL ==1) + + // Copy CID + *pmsg++ = cid = *inbuf++; + // Copy data payload size (size minus CID byte and checksum byte) + size -= 2; + *pmsg++ = size; + + // Validate data payload size: check if longer than size of testmode + // primitive minus cid, str_len_in_bytes, and two holes FIXME: This is a + // really bad way of doing it! + if (size > sizeof(T_TESTMODE_PRIM) - 4) + error = E_PACKET; + + // The CID have been received. The data that follows are part of a + // unique struct within the union of T_TESTMODE_PRIM, so we now + // need to align at a 32-bit word boundary. + pmsg += 2; + + if (!error) + { + cksum = cid; + while (size--) + { + cksum ^= *inbuf; + *pmsg++ = *inbuf++; + } + if (cksum != *inbuf) + error = E_CHECKSUM; + } + + // At this point, all the data have been parsed and copied into + // the TestMode primitive. Now we send the primitive to L1. + if (!error) + { + os_send_sig(msg, L1C1_QUEUE); + msg_used=TRUE; + } + else + { + UWORD8 mymsg[3]; + // on error, return short error message; error, cid/fid, checksum + mymsg[0] = cid; + mymsg[1] = error; + mymsg[2] = cid ^ error; // checksum + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) || (TRACE_TYPE==7) || (TRACE_TYPE==0) + rvt_send_trace_cpy((T_RVT_BUFFER) mymsg, tm_trace_user_id,3, RVT_BINARY_FORMAT); + #endif + } + +#endif // end of (ETM_PROTOCOL ==0) + + // if the message allocated is not sent to L1A, it has to be deallocated + if(msg_used==FALSE) + os_free_sig(msg); +} + +void tm_transmit(T_TM_RETURN *tm_ret) +{ + UWORD8 size, cksum; + UWORD8 *pbuf, *ptmret; + UWORD8 buf[TM_PAYLOAD_UPLINK_SIZE_MAX + TM_UPLINK_PACKET_OVERHEAD]; + + pbuf = &buf[0]; + + // move the header + #if (ETM_PROTOCOL == 1) + *pbuf++ = tm_ret->mid; + cksum = tm_ret->mid; + *pbuf++ = tm_ret->status; + cksum ^= tm_ret->status; + *pbuf++ = tm_ret->cid; + cksum ^= tm_ret->cid; + + // Include index if not equal to zero, and if not an error + // Exception: in TX_TEMPLATE_READ we always include the index. + if ((tm_ret->status == -ETM_OK) && + (tm_ret->index || tm_ret->cid == TX_TEMPLATE_READ)){ + *pbuf++ = tm_ret->index; + cksum ^= tm_ret->index; + } + + #else + *pbuf++ = tm_ret->cid; + *pbuf++ = tm_ret->status; + cksum = tm_ret->cid ^ tm_ret->status; + + // Include index if not equal to zero, and if not an error + // Exception: in TX_TEMPLATE_READ we always include the index. + if ((tm_ret->status == E_OK) && + (tm_ret->index || tm_ret->cid == TX_TEMPLATE_READ)){ + *pbuf++ = tm_ret->index; + cksum ^= tm_ret->index; + } + #endif + + ptmret = (UWORD8 *) &tm_ret->result[0]; + size = tm_ret->size; + while (size--) { + *pbuf++ = *ptmret; + cksum ^= *ptmret++; + } + + // move the checksum and append it to buf + *pbuf++ = cksum; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) || (TRACE_TYPE==7) || (TRACE_TYPE==0) + rvt_send_trace_cpy(buf, tm_trace_user_id, pbuf - buf, RVT_BINARY_FORMAT); + #endif +} + + +#if ((L1_STEREOPATH == 1) && (CODE_VERSION == NOT_SIMULATION) && (OP_L1_STANDALONE == 1)) +/******************************************************************************* + * + * UWORD16 l1tm_stereopath_get_pattern(UWORD16 sampling_freq, UWORD16 sin_freq_left,UWORD16 sin_freq_right, UWORD8 data_type) + * + * Purpose : this function is use to get a complete period of a sinusoide depending on + * the sinusoide freq (L+R), the sampling freq and the type of samples (S8,S16,S32) + * + * Arguments: sampling_freq : sampling frequency + * sin_freq_left : frequency of the left channel sinusoide + * sin_freq_right : frequency of the right channel sinusoide + * data_type : type of samples + * + * Returns : number of elements in the pattern + * + ******************************************************************************/ + + UWORD16 l1tm_stereopath_get_pattern(UWORD16 sampling_freq, UWORD16 sin_freq_left,UWORD16 sin_freq_right, UWORD8 data_type) + { + float max_sin_period; + float my_time; + UWORD16 i; + + // get the lowest frequency to get the biggest period + if (sin_freq_left > sin_freq_right) + { + max_sin_period = 1 / (float) sin_freq_right; + } + else + { + max_sin_period = 1 / (float) sin_freq_left; + } + + my_time = 0; + i = 0; + + if (data_type == AUDIO_SP_DATA_S8) + { + WORD8* my_ptr; + + // cast the steropath_pattern to a pointer on 8 bits samples + my_ptr = (WORD8*) l1tm.stereopath.stereopath_pattern; + + // fill the pattern while the biggest period is not reached + while (my_time < max_sin_period) + { + my_ptr[i++] = 0x7F * sin(2*3.1416*my_time*sin_freq_left); + my_ptr[i++] = 0x7F * sin(2*3.1416*my_time*sin_freq_right); + + my_time = i/2/((float) sampling_freq); + } + } + else // S16 + { + WORD16* my_ptr; + + // cast the steropath_pattern to a pointer on 16 bits samples + my_ptr = (WORD16*) l1tm.stereopath.stereopath_pattern; + + // fill the pattern while the biggest period is not reached + while (my_time < max_sin_period) + { + my_ptr[i++] = 0x7FFF * sin(2*3.1416*my_time*sin_freq_left); + my_ptr[i++] = 0x7FFF * sin(2*3.1416*my_time*sin_freq_right); + + my_time = i/2/((float) sampling_freq); + } + + } + + return (i); + + } + +/******************************************************************************* + * + * void l1tm_stereopath_fill_buffer(void* buffer_address) + * + * Purpose : this function is use to fill a buffer with a predefined pattern + * + * Arguments: buffer_address : address of the buffer to fill + * + * Returns : none + * + ******************************************************************************/ + + void l1tm_stereopath_fill_buffer(void* buffer_address) + { + static UWORD16 my_counter = 0; + UWORD16 copied_samples; + + UWORD16 i; + + + if (l1a_l1s_com.stereopath_drv_task.parameters.data_type == AUDIO_SP_DATA_S8) + { + WORD8* start_address; + WORD8* my_ptr; + + // l1tm.stereopath.stereopath_buffer_number is a variable used to know which half of the buffer we have to fill + if (l1tm.stereopath.stereopath_buffer_number == 0) + { + // first half + start_address = (WORD8*) buffer_address; + l1tm.stereopath.stereopath_buffer_number = 1; + } + else + { + // second half, add the frame number to get the half buffer address + start_address = ((WORD8*) buffer_address) + l1a_l1s_com.stereopath_drv_task.parameters.frame_number; + l1tm.stereopath.stereopath_buffer_number = 0; + } + + // copied_samples is the number of samples copied to the half buffer + copied_samples = 0; + // cast the steropath_pattern to a pointer on 8 bits samples + my_ptr = (WORD8*) l1tm.stereopath.stereopath_pattern; + + if (l1a_l1s_com.stereopath_drv_task.parameters.frame_number > l1tm.stereopath.stereopath_nb_samples) + { + // size of the half buffer to fill is bigger than the predefined pattern + // start to fill the buffer with the end of the not complete previous pattern (from current_sample to the last one) + memcpy(start_address,my_ptr+l1tm.stereopath.stereopath_current_sample,l1tm.stereopath.stereopath_nb_samples-l1tm.stereopath.stereopath_current_sample); + copied_samples = l1tm.stereopath.stereopath_nb_samples-l1tm.stereopath.stereopath_current_sample; + + // while there is still enough place in the buffer to copy a complete pattern ... + while (copied_samples<l1a_l1s_com.stereopath_drv_task.parameters.frame_number-l1tm.stereopath.stereopath_nb_samples) + { + // ... copy a complete pattern + memcpy(start_address+copied_samples,my_ptr,l1tm.stereopath.stereopath_nb_samples); + copied_samples += l1tm.stereopath.stereopath_nb_samples; + } + + // fill the rest of the buffer with a part of the pattern + memcpy(start_address+copied_samples,my_ptr,l1a_l1s_com.stereopath_drv_task.parameters.frame_number-copied_samples); + // save the last pattern sample copied in the buffer for next time (to get a continuous sound) + l1tm.stereopath.stereopath_current_sample = l1a_l1s_com.stereopath_drv_task.parameters.frame_number-copied_samples; + + } + else + { + // size of the half buffer to fill is smaller than the predefined pattern + // fill the buffer with a part of the pattern + memcpy(start_address,my_ptr+l1tm.stereopath.stereopath_current_sample,l1a_l1s_com.stereopath_drv_task.parameters.frame_number); + // save the last pattern sample copied in the buffer for next time (to get a continuous sound) + l1tm.stereopath.stereopath_current_sample += l1a_l1s_com.stereopath_drv_task.parameters.frame_number; + + if (l1tm.stereopath.stereopath_current_sample > l1tm.stereopath.stereopath_nb_samples) + { + l1tm.stereopath.stereopath_current_sample -= l1tm.stereopath.stereopath_nb_samples; + } + } + } + else // S16 + { + WORD16* start_address; + WORD16* my_ptr; + + // l1tm.stereopath.stereopath_buffer_number is a variable used to know which half of the buffer we have to fill + if (l1tm.stereopath.stereopath_buffer_number == 0) + { + // first half + start_address = (WORD16*) buffer_address; + l1tm.stereopath.stereopath_buffer_number = 1; + } + else + { + // second half, add the frame number to get the half buffer address + start_address = ((WORD16*) buffer_address) + l1a_l1s_com.stereopath_drv_task.parameters.frame_number; + l1tm.stereopath.stereopath_buffer_number = 0; + } + + // copied_samples is the number of samples copied to the half buffer + copied_samples = 0; + // cast the steropath_pattern to a pointer on 16 bits samples + my_ptr = (WORD16*) l1tm.stereopath.stereopath_pattern; + + if (l1a_l1s_com.stereopath_drv_task.parameters.frame_number > l1tm.stereopath.stereopath_nb_samples) + { + // size of the half buffer to fill is bigger than the predefined pattern + // start to fill the buffer with the end of the not complete previous pattern (from current_sample to the last one) + memcpy(start_address, my_ptr+l1tm.stereopath.stereopath_current_sample,(l1tm.stereopath.stereopath_nb_samples-l1tm.stereopath.stereopath_current_sample)*2); + copied_samples = l1tm.stereopath.stereopath_nb_samples-l1tm.stereopath.stereopath_current_sample; + + // while there is still enough place in the buffer to copy a complete pattern ... + while (copied_samples<l1a_l1s_com.stereopath_drv_task.parameters.frame_number-l1tm.stereopath.stereopath_nb_samples) + { + // ... copy a complete pattern + memcpy(start_address+copied_samples,my_ptr,l1tm.stereopath.stereopath_nb_samples*2); + copied_samples += l1tm.stereopath.stereopath_nb_samples; + } + + // fill the rest of the buffer with a part of the pattern + memcpy(start_address+copied_samples,my_ptr,(l1a_l1s_com.stereopath_drv_task.parameters.frame_number-copied_samples)*2); + // save the last pattern sample copied in the buffer for next time (to get a continuous sound) + l1tm.stereopath.stereopath_current_sample = l1a_l1s_com.stereopath_drv_task.parameters.frame_number-copied_samples; + + } + else + { + // size of the half buffer to fill is smaller than the predefined pattern + // fill the buffer with a part of the pattern + memcpy(start_address,my_ptr+l1tm.stereopath.stereopath_current_sample,l1a_l1s_com.stereopath_drv_task.parameters.frame_number); + l1tm.stereopath.stereopath_current_sample += l1a_l1s_com.stereopath_drv_task.parameters.frame_number; + + // save the last pattern sample copied in the buffer for next time (to get a continuous sound) + if (l1tm.stereopath.stereopath_current_sample > l1tm.stereopath.stereopath_nb_samples) + { + l1tm.stereopath.stereopath_current_sample -= l1tm.stereopath.stereopath_nb_samples; + } + + } + } + } + +/******************************************************************************* + * + * void l1tm_stereopath_DMA_handler(SYS_UWORD16 dma_status) + * + * Purpose : this function is the stereopath DMA interrupt handler + * + * Arguments: dma_status : type of interrupt + * + * Returns : none + * + ******************************************************************************/ + void l1tm_stereopath_DMA_handler(SYS_UWORD16 dma_status) + { + // stereopath DMA handler, check which type of interrupt it is + if (F_DMA_COMPARE_CHANNEL_IT_STATUS_BLOCK(dma_status)) + { + l1tm.stereopath.stereopath_block++; + // Block --> fill a new buffer + l1tm_stereopath_fill_buffer((void*) l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address); + } + if (F_DMA_COMPARE_CHANNEL_IT_STATUS_HALF_BLOCK(dma_status)) + { + l1tm.stereopath.stereopath_half_block++; + // Half Block --> fill a new buffer + l1tm_stereopath_fill_buffer((void*) l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address); + } + if (F_DMA_COMPARE_CHANNEL_IT_STATUS_TIME_OUT_SRC(dma_status)) + l1tm.stereopath.stereopath_source_timeout++; + if (F_DMA_COMPARE_CHANNEL_IT_STATUS_TIME_OUT_DST(dma_status)) + l1tm.stereopath.stereopath_dest_timeout++; + if (F_DMA_COMPARE_CHANNEL_IT_STATUS_DROP(dma_status)) + l1tm.stereopath.stereopath_drop++; + if (F_DMA_COMPARE_CHANNEL_IT_STATUS_FRAME(dma_status)) + l1tm.stereopath.stereopath_frame++; + } +#endif + + + +#if (CODE_VERSION != SIMULATION) + void l1tm_tpu_table_write(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) + { + Cust_tm_tpu_table_write(tm_return, + prim->u.tm_table.index, + prim->str_len_in_bytes - 1, // subtract 8-bit index + prim->u.tm_table.table); + } + + void l1tm_tpu_table_read(T_TESTMODE_PRIM *prim, T_TM_RETURN *tm_return) + { + Cust_tm_tpu_table_read(tm_return, prim->u.tm_table.index); + } +#endif // (CODE_VERSION != SIMULATION) + + + /*------------------------------------------------------------------*/ + /* l1tm_PRBS1_generate() */ + /*------------------------------------------------------------------*/ + /* */ + /* Parameters : UWORD16 *TM_ul_data */ + /* ------------- */ + /* point to the uplink burts table to be filled */ + /* with the PRBS 1 of bits */ + /* */ + /* Return : Void */ + /* ------------- */ + /* */ + /* Description : */ + /* ------------- */ + /* This algorithm generates a Pseudo Random Bit Sequence */ + /* using a method called method "Primitive Polynomial Modulo 2" */ + /* For a sequence length of (2^15-1) we a polynomial of order 15 */ + /* is used, the coefficients are [ 15, 1, 0 ] */ + /* The basic idea is to generate the new bit by XORing all the */ + /* coefficients of the polynomial except coeff 0 */ + /* i.e newbit = ( B15 XOR B1 ) */ + /* The following notation must be used for the bit numbering: */ + /* _______________________________________________________ */ + /*|B16|B15|B14|B13|B12|B11|B10|B9|B8|B7|B6|B5|B4|B3|B2|B1| */ + /*------------------------------------------------------------------*/ + /* */ + /* each word of the uplink buffer needs to be filled by new 10 bits */ + /*------------------------------------------------------------------*/ + void l1tm_PRBS1_generate(UWORD16 *TM_ul_data) + { + #define B15_MASK 0x4000 + #define B1_MASK 0x0001 + #define MASK_16BITS 0xFFFF + + UWORD16 newbit =0x0000; + UWORD8 index ,word; + + //generate 16 words to fill Uplink table + for (word=0;word<16;word++) + { + // generate new 10 bits from the sequence + for (index =0; index< 10;index++) + { + // generate new bit , using the "Primitive Polynomial Modulo 2 " method with coeff. ( 15, 1, 0 ) + //XOR bit 15 with bit 1. + newbit = (((l1tm.tmode_prbs.prbs1_seed& B15_MASK)>>14)^(l1tm.tmode_prbs.prbs1_seed & B1_MASK)); + // insert new bit in the sequence. + l1tm.tmode_prbs.prbs1_seed = (l1tm.tmode_prbs.prbs1_seed << 1) | newbit; + } + TM_ul_data[word]=(UWORD16)((l1tm.tmode_prbs.prbs1_seed&MASK_16BITS)<<6); + } + } + +#endif // TESTMODE + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/tm_cfile/l1tm_stats.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,404 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1TM_STAT.C + * + * Filename l1tm_stats.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +#include "l1_macro.h" +#include "l1_confg.h" + +#if TESTMODE + + #include <string.h> + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + #include "l1_time.h" + #include "l1_signa.h" + + #include "l1tm_defty.h" + + #if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #endif + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + #include "l1_proto.h" + + #include "l1tm_msgty.h" + #include "l1tm_varex.h" + +/***********************************************************************/ +/* TESTMODE 3.X */ +/***********************************************************************/ + +/* External function prototypes */ +/*------------------------------*/ +void l1tm_stats_read(T_TM_RETURN *tm_return, WORD16 type, UWORD16 bitmask); +void l1a_tmode_send_ul_msg(T_TM_RETURN *tm_ret); + +/* Internal function prototypes */ +/*------------------------------*/ +void l1tm_stats_compute(UWORD32 pm, UWORD32 toa, UWORD32 snr, WORD16 angle); +void l1tm_stats_auto_result_reset_loops(void); +void l1tm_reset_rx_stats(void); + + +void l1tm_stats_fb_confirm (T_TMODE_FB_CON *prim, WORD32 test) +// loop management done in L1A state machine +{ + + l1tm.tmode_stats.loop_count++; + l1tm.tmode_stats.flag_recent = prim->fb_flag; + + if (prim->fb_flag) + { + l1tm.tmode_stats.flag_count++; + } + + if (prim->fb_flag) + // We only save stats from a SUCCESS (including PM) + { + #if (TOA_ALGO == 2) + l1tm_stats_compute(prim->pm_fullres, ((prim->toa)<<2), prim->snr, prim->angle); + #else + l1tm_stats_compute(prim->pm_fullres, prim->toa, prim->snr, prim->angle); + #endif + } + + l1tm_stats_auto_result_reset_loops(); +} + +void l1tm_stats_sb_confirm (T_TMODE_NCELL_SYNC_IND *prim, WORD32 test) +// loop management done in L1A state machine +{ + + l1tm.tmode_stats.loop_count++; + l1tm.tmode_stats.flag_recent = prim->sb_flag; + + if (prim->sb_flag) + { + l1tm.tmode_stats.flag_count++; + l1tm.tmode_stats.bsic = prim->bsic; + } + + if (prim->sb_flag) + // we only save stats from a SUCCESS (including PM) + { + #if (TOA_ALGO == 2) + l1tm_stats_compute(prim->pm_fullres, ((prim->toa)<<2), prim->snr, prim->angle); + #else + l1tm_stats_compute(prim->pm_fullres, prim->toa, prim->snr, prim->angle); + #endif + } + + l1tm_stats_auto_result_reset_loops(); +} + +void l1tm_stats_bcch_confirm (T_TMODE_BCCHS_CON *prim) +// loop management done here after stats management +// (the only stat is pass/fail) +{ + + l1tm.tmode_stats.loop_count++; + + if (prim->error_flag == FALSE) + { + l1tm.tmode_stats.flag_count++; + l1tm.tmode_stats.flag_recent = 1; + l1tm.tmode_stats.bsic = l1a_l1s_com.Scell_info.bsic; + } + else + { + l1tm.tmode_stats.flag_recent = 0; + } + + l1tm_stats_auto_result_reset_loops(); +} + +void l1tm_stats_tch_confirm (T_TMODE_TCH_INFO *prim) +// loop management and stats management done here +{ + + // Update statistics only if downlink task enabled: DL-only or DL+UL + if((l1_config.tmode.rf_params.down_up & TMODE_DOWNLINK) && + l1_config.tmode.rf_params.tmode_continuous == TM_NO_CONTINUOUS) + { + l1tm.tmode_stats.loop_count++; + + // TCH statistics are based on (accumulated) bit errors + // Stats are computed independently from the RXQUAL + // Discard first 2 blocks of TCH => always wrong if start not on block boundary + if (l1tm.tmode_stats.loop_count > 2) + { + l1tm.tmode_stats.qual_acc_full += prim->qual_full; + l1tm.tmode_stats.qual_nbr_meas_full += prim->qual_nbr_meas_full; + // fixed point unsigned F9.7 format + l1tm.tmode_stats.flag_count = (WORD32)(((l1tm.tmode_stats.qual_acc_full * 100)<<8)/(l1tm.tmode_stats.qual_nbr_meas_full)); + } + + l1tm.tmode_stats.flag_recent = 1; + l1tm.tmode_stats.bsic = l1a_l1s_com.Scell_info.bsic; + + l1tm_stats_compute(prim->pm_fullres, prim->toa, prim->snr, prim->angle); + + l1tm_stats_auto_result_reset_loops(); + + } // end if DL-only or DL+UL +} + +void l1tm_stats_mon_confirm (T_TMODE_FB_CON *prim) +// loop management done in L1A state machine +{ + + l1tm.tmode_stats.loop_count++; + l1tm.tmode_stats.flag_recent = prim->fb_flag; + + if (prim->fb_flag) + { + l1tm.tmode_stats.flag_count++; + } + + if (prim->fb_flag) + // we only save stats from a SUCCESS (including PM) + { + l1tm_stats_compute(prim->pm_fullres, prim->toa, prim->snr, prim->angle); + } + + l1tm_stats_auto_result_reset_loops(); +} + +/*void l1tm_stats_ra_confirm (T_TMODE_RA_DONE *prim) +// this function is only called when the RACH test is done +{ + //l1tm.tmode_stats.fn = prim->fn; + + l1tm.tmode_state.dedicated_active = 0; +}*/ + +void l1tm_stats_full_list_meas_confirm(T_TMODE_RXLEV_REQ *prim) +{ + T_TM_RETURN tm_ret; + WORD16 stats_type = 2; // recent stats + UWORD16 stats_bitmask = 0x0003; // for power measurement force rxlev and pm + + + l1tm.tmode_stats.rssi_recent = prim->power_array->accum_power_result; + l1tm_stats_read(&tm_ret, stats_type, stats_bitmask); + // above function sets tm_ret.status, tm_ret.result[], tm_ret.index, tm_ret.size + +#if (ETM_PROTOCOL == 1) + tm_ret.mid = ETM_RF; +#endif + + tm_ret.cid = STATS_READ; + l1a_tmode_send_ul_msg(&tm_ret); +} + +#if L1_GPRS + void l1tm_stats_pdtch_confirm (T_TMODE_PDTCH_INFO *prim) + // loop management and stats management done here +{ + UWORD8 ts; + UWORD8 bit_map = 0x80; + + l1tm.tmode_stats.loop_count++; + l1tm.tmode_stats.bsic = l1a_l1s_com.Scell_info.bsic; + + // count the number of successes over all time slots allocated for stats within one block + for (ts=0;ts<8;ts++) + { + if (bit_map & l1_config.tmode.stats_config.stat_gprs_slots) + { + // if crc_error[ts]=FALSE the block is decoded successfully + if (!prim->crc_error_tbl[ts]) + l1tm.tmode_stats.flag_count ++; + } + bit_map>>=1; + } + + // TM stats are collected over one block (4 frames) + l1tm_stats_compute(prim->pm_fullres, prim->toa, prim->snr, prim->angle); + + l1tm_stats_auto_result_reset_loops(); + +} +#endif + +void l1tm_stats_compute(UWORD32 pm, UWORD32 toa, UWORD32 snr, WORD16 angle) +{ + // PM STATS + l1tm.tmode_stats.pm_recent = pm; + l1tm.tmode_stats.pm_sum += pm; + l1tm.tmode_stats.pm_sq_sum += (pm*pm); + + // TOA STATS + l1tm.tmode_stats.toa_recent = toa; + l1tm.tmode_stats.toa_sum += toa; + l1tm.tmode_stats.toa_sq_sum += (toa*toa); + + // ANGLE STATS + l1tm.tmode_stats.angle_recent = angle; + l1tm.tmode_stats.angle_sum += angle; + l1tm.tmode_stats.angle_sq_sum += (angle*angle); + if (angle < l1tm.tmode_stats.angle_min ) + { + l1tm.tmode_stats.angle_min = angle; + } + if (angle > l1tm.tmode_stats.angle_max ) + { + l1tm.tmode_stats.angle_max = angle; + } + + // SNR STATS + l1tm.tmode_stats.snr_recent = snr; + l1tm.tmode_stats.snr_sum += snr; + l1tm.tmode_stats.snr_sq_sum += (snr*snr); +} + +void l1tm_stats_auto_result_reset_loops(void) +{ + T_TM_RETURN tm_ret; + + if (l1_config.tmode.stats_config.auto_result_loops) + { + if ( (l1tm.tmode_stats.loop_count % l1_config.tmode.stats_config.auto_result_loops) == 0) + // time to report current stats. call l1tm_stats_read + { + l1tm_stats_read(&tm_ret, l1_config.tmode.stats_config.stat_type, l1_config.tmode.stats_config.stat_bitmask); + // above function sets tm_ret.status, tm_ret.result[], tm_ret.index, tm_ret.size + + #if (ETM_PROTOCOL == 1) + tm_ret.mid = ETM_RF; + #endif + + tm_ret.cid = STATS_READ; + l1a_tmode_send_ul_msg(&tm_ret); + } + } + + if (l1_config.tmode.stats_config.auto_reset_loops) + { + if ((l1tm.tmode_stats.loop_count % l1_config.tmode.stats_config.auto_reset_loops) == 0) + // time to reset stats. + { + l1tm_reset_rx_stats(); + // resets stats accumulators and success/runs counters but not master loop counter for task. + } + } +} + +/**************************************************************************** + Function: l1tm_is_rx_counter_done + Input: none + Output: 1 = done; + 0 = not done. + + Checks to see if the RX loop should be stopped, and increments counter. + This counter is used in all RX functions. +*****************************************************************************/ +BOOL l1tm_is_rx_counter_done(void) +// another T_TM_RETURN allocated here for auto acknowledge of rf_enable operation. +// to help save stack we could pass in a pointer to the tm_return structure, +// then save the current values +{ + T_TM_RETURN_ABBREV tm_ret; + + if (l1_config.tmode.stats_config.num_loops != 0) // 0 = infinite loop + { + l1tm.tmode_state.rx_counter++; + if (l1tm.tmode_state.rx_counter >= l1_config.tmode.stats_config.num_loops) + { + // acknowledge end of RF_ENABLE operation + + tm_ret.cid = RF_ENABLE; + tm_ret.index = 0; // No index value is sent + tm_ret.status = E_FINISHED; + + tm_ret.size = 1; + tm_ret.result[0] = 1; + l1a_tmode_send_ul_msg((T_TM_RETURN *) &tm_ret); + + return 1; + } + else + { + return 0; + } + } + else // infinite loop + { + return 0; + } +} + +void l1tm_reset_rx_state(void) +{ + l1tm.tmode_state.rx_counter = 0; + l1tm.tmode_state.num_bcchs = 0; +} + +void l1tm_reset_rx_stats(void) +{ + UWORD32 i; + + l1tm.tmode_stats.toa_sum = 0; + l1tm.tmode_stats.toa_sq_sum = 0; + l1tm.tmode_stats.toa_recent = 0; + l1tm.tmode_stats.rssi_recent = 0; + l1tm.tmode_stats.pm_sum = 0; + l1tm.tmode_stats.pm_sq_sum = 0; + l1tm.tmode_stats.pm_recent = 0; + l1tm.tmode_stats.angle_sum = 0; + l1tm.tmode_stats.angle_sq_sum = 0; + l1tm.tmode_stats.angle_min = +32767; + l1tm.tmode_stats.angle_max = -32768; + l1tm.tmode_stats.angle_recent = 0; + l1tm.tmode_stats.snr_sum = 0; + l1tm.tmode_stats.snr_sq_sum = 0; + l1tm.tmode_stats.snr_recent = 0; + l1tm.tmode_stats.loop_count = 0; + l1tm.tmode_stats.flag_count = 0; + l1tm.tmode_stats.fn = 0; + l1tm.tmode_stats.bsic = 0; + l1tm.tmode_stats.qual_acc_full = 0; + l1tm.tmode_stats.qual_nbr_meas_full = 0; + + for (i=0;i<4;i++) + l1tm.tmode_stats.rssi_fifo[i] = 0; + +#if L1_GPRS + l1tm.tmode_stats.nb_dl_pdtch_slots = 0; +#if 0 /* FreeCalypso TCS211 reconstruction: LoCosto-ism removed */ +// Stats Bler +l1tm.tmode_stats.bler_total_blocks = 0; + for (i=0;i<4;i++) + l1tm.tmode_stats.bler_crc[i] = 0; +#endif +#endif +} + + +#endif +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/tm_cust0/l1tm_cust.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,1190 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1TM_CUST.C + * + * Filename %M% + * Version %I% + * Date %G% + * + ************* Revision Controle System Header *************/ + +#include "l1_confg.h" +#if TESTMODE + +#include "tm_defs.h" +#include "l1_const.h" +#include "l1_types.h" + +#include "l1tm_defty.h" +#include "l1tm_cust.h" + +#if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" +#endif + +#if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" +#endif +#include "l1_defty.h" +#include "l1_msgty.h" +#include "l1_tabs.h" + +#include "l1tm_msgty.h" +#include "l1tm_varex.h" + +#include "abb.h" + +#if (RF==35) + #include "tpudrv35.h" + #include "l1_rf35.h" +#endif + +#if (RF==12) + #include "tpudrv12.h" + #include "l1_rf12.h" +#endif + +#if (RF==10) + #include "tpudrv10.h" + #include "l1_rf10.h" +#endif + +#if (RF==8) + #include "tpudrv8.h" + #include "l1_rf8.h" +#endif + +#if (RF==2) + #include "l1_rf2.h" +#endif + +#include <string.h> + +// Import band configuration from Flash module (need to replace by an access function) +//extern UWORD8 std; +extern T_L1_CONFIG l1_config; +extern T_RF rf; +extern T_RF_BAND rf_band[GSM_BANDS]; +extern UWORD16 AGC_TABLE[AGC_TABLE_SIZE]; +extern T_ADC adc; +extern T_ADCCAL adc_cal; +extern UWORD16 TM_ul_data[16]; //Uplink data to be stored into ABB Uplink buffer +extern T_STD_CONFIG std_config[]; +static UWORD8 tm_band = 0; + +// External function prototypes +void get_cal_from_nvmem (UWORD8 *ptr, UWORD16 len, UWORD8 id); +UWORD8 save_cal_in_nvmem (UWORD8 *ptr, UWORD16 len, UWORD8 id); +void Cust_init_std(void); +void l1_tpu_init_light(void); + +enum { + TM_RF_ID = 0, + TM_ADC_ID = 1 +}; + +typedef signed char effs_t; +// external FFS function prototypes +effs_t ffs_mkdir(const char *pathname); +void config_ffs_write(char type); + +/***********************************************************************/ +/* TESTMODE 4.X */ +/***********************************************************************/ + + +/*----------------------------------------------------------*/ +/* Cust_tm_init() */ +/*----------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : Init default configuration for TM params */ +/*----------------------------------------------------------*/ + +void Cust_tm_init(void) +{ + UWORD32 i; + + l1_config.adc_enable = ADC_ENABLE; // ADC readings enabled + l1_config.agc_enable = AGC_ENABLE; // AGC algo enabled + l1_config.afc_enable = AFC_ENABLE; // AFC algo enabled + l1_config.tmode.rf_params.bcch_arfcn = TM_BCCH_ARFCN; + l1_config.tmode.rf_params.tch_arfcn = TM_TCH_ARFCN; + l1_config.tmode.rf_params.mon_arfcn = TM_MON_ARFCN; + l1_config.tmode.rf_params.channel_type = TM_CHAN_TYPE; // TCH_F + l1_config.tmode.rf_params.subchannel = TM_SUB_CHAN; + l1_config.tmode.rf_params.reload_ramps_flag = 0; + l1_config.tmode.rf_params.tmode_continuous = TM_NO_CONTINUOUS; + l1_config.tmode.rx_params.slot_num = TM_SLOT_NUM; // Time Slot + l1_config.tmode.rx_params.agc = TM_AGC_VALUE; //This may be outside the range of the RF chip used + l1_config.tmode.rx_params.pm_enable = TM_PM_ENABLE; + l1_config.tmode.rx_params.lna_off = TM_LNA_OFF; + l1_config.tmode.rx_params.number_of_measurements = TM_NUM_MEAS; + l1_config.tmode.rx_params.place_of_measurement = TM_WIN_MEAS; + l1_config.tmode.tx_params.txpwr = TM_TXPWR; // Min power level for GSM900 + l1_config.tmode.tx_params.txpwr_skip = TM_TXPWR_SKIP; + l1_config.tmode.tx_params.timing_advance = TM_TA; + l1_config.tmode.tx_params.burst_type = TM_BURST_TYPE; // default is normal up-link burst + l1_config.tmode.tx_params.burst_data = TM_BURST_DATA; // default is all zeros + l1_config.tmode.tx_params.tsc = TM_TSC; // Training Sequence ("BCC" on BSS) + #if (CODE_VERSION != SIMULATION) + l1_config.tmode.stats_config.num_loops = TM_NUM_LOOPS; // 0 actually means infinite + #else + l1_config.tmode.stats_config.num_loops = 4; // 0 actually means infinite + #endif + l1_config.tmode.stats_config.auto_result_loops = TM_AUTO_RESULT_LOOPS; // 0 actually means infinite + l1_config.tmode.stats_config.auto_reset_loops = TM_AUTO_RESET_LOOPS; // 0 actually means infinite + l1_config.tmode.stats_config.stat_type = TM_STAT_TYPE; + l1_config.tmode.stats_config.stat_bitmask = TM_STAT_BITMASK; + + #if (CODE_VERSION != SIMULATION) + // Initialize APCDEL1 register of Omega + ABB_Write_Register_on_page(PAGE0, APCDEL1, (C_APCDEL1 - 0x0004) >> 6); + #endif + + l1tm.tm_msg_received = FALSE; + + for (i=0;i<16;i++) + TM_ul_data[i]=0; + + #if L1_GPRS + l1_config.tmode.rf_params.pdtch_arfcn = TM_PDTCH_ARFCN; + l1_config.tmode.rf_params.multislot_class = TM_MULTISLOT_CLASS; + l1_config.tmode.stats_config.stat_gprs_slots = TM_STAT_GPRS_SLOTS; + l1_config.tmode.rx_params.timeslot_alloc = TM_RX_ALLOCATION; + l1_config.tmode.rx_params.coding_scheme = TM_RX_CODING_SCHEME; + l1_config.tmode.tx_params.timeslot_alloc = TM_TX_ALLOCATION; + l1_config.tmode.tx_params.coding_scheme = TM_TX_CODING_SCHEME; + for (i=0; i<8; i++) + l1_config.tmode.tx_params.txpwr_gprs[i] = TM_TXPWR_GPRS; + + for (i=0; i<27; i++) + l1_config.tmode.tx_params.rlc_buffer[i] = 0; + #endif +} + + +/**********************************************************************/ +/* Test mode functions used for RF calibration */ +/**********************************************************************/ + +void Cust_tm_rf_param_write(T_TM_RETURN *tm_return, WORD16 index, UWORD16 value) +{ + switch (index) + { + case STD_BAND_FLAG: + { + UWORD8 std_temp, band_temp; + + std_temp = value & 0xff; // tm_band = b7..0 of value + band_temp = value >> 8; // band = b15..8 of value + // get define + //if (sizeof(std_config)/sizeof(T_STD_CONFIG) <= std_temp) + if (9 <= std_temp) // std max + { + tm_return->status = E_BADINDEX; + break; + } + else if ( GSM_BANDS <= band_temp) + { + tm_return->status = E_BADINDEX; + break; + } + else if ( BAND_NONE == std_config[std_temp].band[band_temp]) + { + tm_return->status = E_BADINDEX; + break; + } + else + { + l1_config.std.id = std_temp; + tm_band = band_temp; + // update RAM struct with either default or ffs + Cust_init_std(); + l1_tpu_init_light(); + tm_return->status = E_OK; + break; + } + } + + case INITIAL_AFC_DAC: + { + rf.afc.eeprom_afc = (WORD16) value << 3; // shift to put into F13.3 format + l1_config.params.eeprom_afc = rf.afc.eeprom_afc; + + tm_return->status = E_OK; + break; + } + default: + { + tm_return->status = E_BADINDEX; + break; + } + } // end switch +} + +void Cust_tm_rf_param_read(T_TM_RETURN *tm_return, WORD16 index) +{ + volatile UWORD16 value; + + switch (index) + { + case STD_BAND_FLAG: + { + value = ((tm_band << 8) | (l1_config.std.id) ); // return global std, tm_band (intel format) + break; + } + case INITIAL_AFC_DAC: + { + value = rf.afc.eeprom_afc >> 3; // returned as F13.3 + break; + } + default: + { + tm_return->size = 0; + tm_return->status = E_BADINDEX; + return; + } + } // end switch + + memcpy(tm_return->result, (UWORD8 *)&value, 2); + tm_return->size = 2; + tm_return->status = E_OK; +} + +void Cust_tm_rf_table_write(T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[]) +{ + UWORD8 band=0; + + tm_return->index = index; // store index before it gets modified + tm_return->size = 0; + + switch (index) + { + case RX_AGC_TABLE: + { + if (size != sizeof(AGC_TABLE)) + { + tm_return->status = E_BADSIZE; + break; + } + + memcpy(&AGC_TABLE[0], table, size); + tm_return->status = E_OK; + break; + } + case AFC_PARAMS: + { + + #if (VCXO_ALGO == 1) + if (size != 24) // 4 UWORD32 + 4 WORD16 values + #else + if (size != 16) // 4 UWORD32 values + #endif + { + tm_return->status = E_BADSIZE; + break; + } + + memcpy(&rf.afc.psi_sta_inv, table, size); + l1_config.params.psi_sta_inv = rf.afc.psi_sta_inv; + l1_config.params.psi_st = rf.afc.psi_st; + l1_config.params.psi_st_32 = rf.afc.psi_st_32; + l1_config.params.psi_st_inv = rf.afc.psi_st_inv; + + #if (CODE_VERSION == NOT_SIMULATION) + #if (VCXO_ALGO == 1) + l1_config.params.afc_dac_center = rf.afc.dac_center; + l1_config.params.afc_dac_min = rf.afc.dac_min; + l1_config.params.afc_dac_max = rf.afc.dac_max; + l1_config.params.afc_snr_thr = rf.afc.snr_thr; + #endif + #endif + + tm_return->status = E_OK; + break; + } + case RX_AGC_GLOBAL_PARAMS: + { + if (size != 8) // 4 UWORD16 values + { + tm_return->status = E_BADSIZE; + break; + } + + memcpy(&rf.rx.agc.low_agc_noise_thr, table, size); + l1_config.params.low_agc_noise_thr = rf.rx.agc.low_agc_noise_thr; + l1_config.params.high_agc_sat_thr = rf.rx.agc.high_agc_sat_thr; + l1_config.params.low_agc = rf.rx.agc.low_agc; + l1_config.params.high_agc = rf.rx.agc.high_agc; + + tm_return->status = E_OK; + break; + } + case RX_IL_2_AGC_MAX: + { + if (size != sizeof(rf.rx.agc.il2agc_max)) + { + tm_return->status = E_BADSIZE; + break; + } + + memcpy(&rf.rx.agc.il2agc_max[0], table, size); + tm_return->status = E_OK; + break; + } + case RX_IL_2_AGC_PWR: + { + if (size != sizeof(rf.rx.agc.il2agc_pwr)) + { + tm_return->status = E_BADSIZE; + break; + } + + memcpy(&rf.rx.agc.il2agc_pwr[0], table, size); + tm_return->status = E_OK; + break; + } + case RX_IL_2_AGC_AV: + { + if (size != sizeof(rf.rx.agc.il2agc_av)) + { + tm_return->status = E_BADSIZE; + break; + } + + memcpy(&rf.rx.agc.il2agc_av[0], table, size); + tm_return->status = E_OK; + break; + } + case TX_LEVELS: + { + if (size != sizeof(rf_band[tm_band].tx.levels)) + { + tm_return->status = E_BADSIZE; + break; + } + + memcpy(&rf_band[tm_band].tx.levels[0], table, size); + tm_return->status = E_OK; + break; + } + case TX_CAL_CHAN: // generic for all bands + { + if (size != sizeof(rf_band[tm_band].tx.chan_cal_table)) + { + tm_return->status = E_BADSIZE; + break; + } + + memcpy(&rf_band[tm_band].tx.chan_cal_table[0][0], table, size); + tm_return->status = E_OK; + break; + } + case TX_CAL_TEMP: // generic for all bands + { + if (size != sizeof(rf_band[tm_band].tx.temp)) + { + tm_return->status = E_BADSIZE; + break; + } + + memcpy(&rf_band[tm_band].tx.temp[0], table, size); + tm_return->status = E_OK; + break; + } + case RX_CAL_CHAN: // generic for all bands + { + if (size != sizeof(rf_band[tm_band].rx.agc_bands)) + { + tm_return->status = E_BADSIZE; + break; + } + + memcpy(&rf_band[tm_band].rx.agc_bands[0], table, size); + tm_return->status = E_OK; + break; + } + case RX_CAL_TEMP: // generic for all bands + { + if (size != sizeof(rf_band[tm_band].rx.temp)) + { + tm_return->status = E_BADSIZE; + break; + } + + memcpy(&rf_band[tm_band].rx.temp[0], table, size); + tm_return->status = E_OK; + break; + } + case RX_AGC_PARAMS: + { + if (size != sizeof(rf_band[tm_band].rx.rx_cal_params)) + { + tm_return->status = E_BADSIZE; + break; + } + + memcpy(&rf_band[tm_band].rx.rx_cal_params, table, size); + if (tm_band == 0) + { + l1_config.std.g_magic_band1 = rf_band[tm_band].rx.rx_cal_params.g_magic; + l1_config.std.lna_att_band1 = rf_band[tm_band].rx.rx_cal_params.lna_att; + l1_config.std.lna_switch_thr_low_band1 = rf_band[tm_band].rx.rx_cal_params.lna_switch_thr_low; + l1_config.std.lna_switch_thr_high_band1 = rf_band[tm_band].rx.rx_cal_params.lna_switch_thr_high; + } + else if (tm_band == 1) + { + l1_config.std.g_magic_band2 = rf_band[tm_band].rx.rx_cal_params.g_magic; + l1_config.std.lna_att_band2 = rf_band[tm_band].rx.rx_cal_params.lna_att; + l1_config.std.lna_switch_thr_low_band2 = rf_band[tm_band].rx.rx_cal_params.lna_switch_thr_low; + l1_config.std.lna_switch_thr_high_band2 = rf_band[tm_band].rx.rx_cal_params.lna_switch_thr_high; + } + else + { + tm_return->status = E_INVAL; + break; + } + + tm_return->status = E_OK; + break; + } + case TX_CAL_EXTREME: + case RX_CAL_LEVEL: + { + tm_return->status = E_NOSUBSYS; + break; + } + #if L1_GPRS + case RLC_TX_BUFFER_CS1: + case RLC_TX_BUFFER_CS2: + case RLC_TX_BUFFER_CS3: + case RLC_TX_BUFFER_CS4: + { + UWORD8 i, buffer_size; + + tm_return->index = index; // store index before it gets modified + tm_return->size = 0; + + buffer_size = size/2 + size%2; // bytes will be concatenated into UWORD16 + + if (buffer_size > 27) //max. number of data bytes + { + tm_return->status = E_BADSIZE; + break; + } + + // make sure that last byte is zero in case of odd number of bytes + table[size] = 0; + + // init the whole buffer before downloading new data + for (i=0; i<27; i++) + l1_config.tmode.tx_params.rlc_buffer[i] = 0; + + for (i=0; i<buffer_size; i++) + { + l1_config.tmode.tx_params.rlc_buffer[i] = (table[2*i+1] << 8) | table[2*i]; + } + l1_config.tmode.tx_params.rlc_buffer_size = buffer_size; + + tm_return->status = E_OK; + break; + } + #endif + case TX_DATA_BUFFER: + { + UWORD8 i; + + tm_return->index = index; // store index before it gets modified + tm_return->size = 0; + + if (size != 32) // 16 UWORD16 (containing 10 data bits each) + { + tm_return->status = E_BADSIZE; + break; + } + + memcpy(&TM_ul_data, table, size); + + for (i=0; i<16; i++) + { + TM_ul_data[i] = TM_ul_data[i] << 6; + } + + tm_return->status = E_OK; + break; + } + default: + { + tm_return->status = E_BADINDEX; + break; + } + } // end switch +} + +void Cust_tm_rf_table_read(T_TM_RETURN *tm_return, WORD8 index) +{ + switch (index) + { + case RX_AGC_TABLE: + { + tm_return->size = sizeof(AGC_TABLE); + memcpy(tm_return->result, &AGC_TABLE[0], tm_return->size); + break; + } + case AFC_PARAMS: + { + #if (VCXO_ALGO == 1) + tm_return->size = 24; // 4 UWORD32's + 4 WORD16 + #else + tm_return->size = 16; // 4 UWORD32's + #endif + memcpy(tm_return->result, &rf.afc.psi_sta_inv, tm_return->size); + break; + } + case RX_AGC_GLOBAL_PARAMS: + { + tm_return->size = 8; // 4 UWORD16's + memcpy(tm_return->result, &rf.rx.agc.low_agc_noise_thr, tm_return->size); + + break; + } + case RX_IL_2_AGC_MAX: + { + tm_return->size = sizeof(rf.rx.agc.il2agc_max); + memcpy(tm_return->result, &rf.rx.agc.il2agc_max[0], tm_return->size); + break; + } + case RX_IL_2_AGC_PWR: + { + tm_return->size = sizeof(rf.rx.agc.il2agc_pwr); + memcpy(tm_return->result, &rf.rx.agc.il2agc_pwr[0], tm_return->size); + break; + } + case RX_IL_2_AGC_AV: + { + tm_return->size = sizeof(rf.rx.agc.il2agc_av); + memcpy(tm_return->result, &rf.rx.agc.il2agc_av[0], tm_return->size); + break; + } + case TX_LEVELS: + { + tm_return->size = sizeof(rf_band[tm_band].tx.levels); + memcpy(tm_return->result, &rf_band[tm_band].tx.levels[0], tm_return->size); + break; + } + case TX_CAL_CHAN: // generic for all bands + { + tm_return->size = sizeof(rf_band[tm_band].tx.chan_cal_table); + memcpy(tm_return->result, &rf_band[tm_band].tx.chan_cal_table[0][0], tm_return->size); + break; + } + case TX_CAL_TEMP: // generic for all bands + { + tm_return->size = sizeof(rf_band[tm_band].tx.temp); + memcpy(tm_return->result, &rf_band[tm_band].tx.temp[0], tm_return->size); + break; + } + case RX_CAL_CHAN: // generic for all bands + { + tm_return->size = sizeof(rf_band[tm_band].rx.agc_bands); + memcpy(tm_return->result, &rf_band[tm_band].rx.agc_bands[0], tm_return->size); + break; + } + case RX_CAL_TEMP: // generic for all bands + { + tm_return->size = sizeof(rf_band[tm_band].rx.temp); + memcpy(tm_return->result, &rf_band[tm_band].rx.temp[0], tm_return->size); + break; + } + case RX_AGC_PARAMS: + { + // WARNING: sizeof(rf.rx.rx_cal_params[band]) returns 12 because of alignment + tm_return->size = 10; // five UWORD16's + memcpy(tm_return->result, &rf_band[tm_band].rx.rx_cal_params, tm_return->size); + break; + } + case TX_CAL_EXTREME: + case RX_CAL_LEVEL: + { + tm_return->size = 0; + tm_return->status = E_NOSUBSYS; + return; + } + + #if L1_GPRS + case RLC_TX_BUFFER_CS1: + case RLC_TX_BUFFER_CS2: + case RLC_TX_BUFFER_CS3: + case RLC_TX_BUFFER_CS4: + { + tm_return->size = l1_config.tmode.tx_params.rlc_buffer_size * 2; // UWORD16's + memcpy(tm_return->result, &l1_config.tmode.tx_params.rlc_buffer[0], tm_return->size); + break; + } + #endif + + case TX_DATA_BUFFER: + { + UWORD8 i; + for (i=0; i<16; i++) + { + tm_return->result[2*i]=(TM_ul_data[i] >> 6) & 0x00FF; + tm_return->result[2*i+1]=(TM_ul_data[i] >> 14) & 0x0003; + } + + tm_return->size = 32; //16*UWORD16 + break; + } + + #if (RF==35) + case RX_PLL_TUNING_TABLE: + { + tm_return->size = sizeof(pll_tuning); //6*UWORD16 + memcpy(tm_return->result, &pll_tuning, tm_return->size); + pll_tuning.enable = 0; + break; + } + #endif + + default: + { + tm_return->size = 0; + tm_return->status = E_BADINDEX; + return; + } + } // end switch + + tm_return->index = index; + tm_return->status = E_OK; +} + +void Cust_tm_rx_param_write(T_TM_RETURN *tm_return, WORD16 index, UWORD16 value) +{ + switch (index) + { + case RX_FRONT_DELAY: + { + //delay for dual band not implemented yet + rf.tx.prg_tx = value; + l1_config.params.prg_tx_gsm = rf.tx.prg_tx; + l1_config.params.prg_tx_dcs = rf.tx.prg_tx; + + tm_return->status = E_OK; + break; + } + default: + { + tm_return->status = E_BADINDEX; + break; + } + } // end switch +} + +void Cust_tm_rx_param_read(T_TM_RETURN *tm_return, WORD16 index) +{ + volatile UWORD16 value; + + switch (index) + { + case RX_FRONT_DELAY: + { + value = rf.tx.prg_tx; + break; + } + default: + { + tm_return->status = E_BADINDEX; + tm_return->size = 0; + return; + } + } // end switch + + memcpy(tm_return->result, (UWORD8 *)&value, 2); + tm_return->size = 2; + tm_return->status = E_OK; +} + +void Cust_tm_tx_param_write(T_TM_RETURN *tm_return, WORD16 index, UWORD16 value, UWORD8 band) +{ + switch (index) + { + case TX_APC_DAC: + { + // generic for all bands + rf_band[tm_band].tx.levels[l1_config.tmode.tx_params.txpwr].apc = value; + + tm_return->status = E_OK; + break; + } + case TX_RAMP_TEMPLATE: + { + if (value >= sizeof(rf_band[tm_band].tx.ramp_tables)/sizeof(rf_band[tm_band].tx.ramp_tables[0])) // [0..15] + { + tm_return->status = E_INVAL; + break; + } + + // generic for all bands + rf_band[tm_band].tx.levels[l1_config.tmode.tx_params.txpwr].ramp_index = value; + + tm_return->status = E_OK; + l1_config.tmode.rf_params.reload_ramps_flag = 1; + break; + } + case TX_CHAN_CAL_TABLE: + { + if (value >= sizeof(rf_band[tm_band].tx.chan_cal_table)/sizeof(rf_band[tm_band].tx.chan_cal_table[0])) + { + tm_return->status = E_INVAL; + break; + } + + // generic for all bands + rf_band[tm_band].tx.levels[l1_config.tmode.tx_params.txpwr].chan_cal_index = value; + + tm_return->status = E_OK; + + break; + } + case TX_BURST_TYPE: + { + if (value > 1) // [0..1] + { + tm_return->status = E_INVAL; + break; + } + l1_config.tmode.tx_params.burst_type = value; + tm_return->status = E_OK; + break; + } + case TX_BURST_DATA: + { + // range is [0..10], currently we support [0..13] at the moment + if (value > 13) + { + tm_return->status = E_INVAL; + break; + } + l1_config.tmode.tx_params.burst_data = value; + tm_return->status = E_OK; + break; + } + case TX_TRAINING_SEQ: + { + if (value > 7) // [0..7] + { + tm_return->status = E_INVAL; + break; + } + l1_config.tmode.tx_params.tsc = value; + tm_return->status = E_OK; + break; + } + default: + { + tm_return->status = E_BADINDEX; + break; + } + } // end switch +} + +void Cust_tm_tx_param_read(T_TM_RETURN *tm_return, WORD16 index, UWORD8 band) +{ + volatile UWORD16 value; + + switch (index) + { + case TX_PWR_LEVEL: + { + value = l1_config.tmode.tx_params.txpwr; + break; + } + case TX_APC_DAC: + { + value = rf_band[tm_band].tx.levels[l1_config.tmode.tx_params.txpwr].apc; + break; + } + case TX_RAMP_TEMPLATE: + { + value = rf_band[tm_band].tx.levels[l1_config.tmode.tx_params.txpwr].ramp_index; + break; + } + case TX_CHAN_CAL_TABLE: + { + value = rf_band[tm_band].tx.levels[l1_config.tmode.tx_params.txpwr].chan_cal_index; + break; + } + case TX_BURST_TYPE: + { + value = l1_config.tmode.tx_params.burst_type; + break; + } + case TX_BURST_DATA: + { + value = l1_config.tmode.tx_params.burst_data; + break; + } + case TX_TIMING_ADVANCE: + { + value = l1_config.tmode.tx_params.timing_advance; + break; + } + case TX_TRAINING_SEQ: + { + value = l1_config.tmode.tx_params.tsc; + break; + } + case TX_PWR_SKIP: + { + value = l1_config.tmode.tx_params.txpwr_skip; + break; + } + #if L1_GPRS + case TX_GPRS_POWER0: + case TX_GPRS_POWER1: + case TX_GPRS_POWER2: + case TX_GPRS_POWER3: + case TX_GPRS_POWER4: + case TX_GPRS_POWER5: + case TX_GPRS_POWER6: + case TX_GPRS_POWER7: + { + value = l1_config.tmode.tx_params.txpwr_gprs[index - TX_GPRS_POWER0]; + break; + } + case TX_GPRS_SLOTS: + { + value = l1_config.tmode.tx_params.timeslot_alloc; + break; + } + case TX_GPRS_CODING: + { + value = l1_config.tmode.tx_params.coding_scheme; + break; + } + #endif + default: + { + tm_return->status = E_BADINDEX; + tm_return->size = 0; + return; + } + } // end switch + + memcpy(tm_return->result, (UWORD8 *)&value, 2); + tm_return->size = 2; + tm_return->status = E_OK; +} + +void Cust_tm_tx_template_write(T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[]) +{ + if (index >= sizeof(rf_band[tm_band].tx.ramp_tables)/sizeof(T_TX_RAMP)) + { + tm_return->status = E_BADINDEX; + } + else if (size != sizeof(T_TX_RAMP)) + { + // We are writing both the up and down ramps; size must be exact. + tm_return->status = E_BADSIZE; + } + else + { + memcpy(rf_band[tm_band].tx.ramp_tables[index].ramp_up, &table[0], size/2); + memcpy(rf_band[tm_band].tx.ramp_tables[index].ramp_down, &table[size/2], size/2); + tm_return->status = E_OK; + l1_config.tmode.rf_params.reload_ramps_flag = 1; + } + + tm_return->index = index; + tm_return->size = 0; +} + +void Cust_tm_tx_template_read(T_TM_RETURN *tm_return, WORD8 index) +{ + tm_return->index = index; + + if (index >= sizeof(rf_band[tm_band].tx.ramp_tables)/sizeof(T_TX_RAMP)) + { + tm_return->status = E_BADINDEX; + tm_return->size = 0; + return; + } + + memcpy(&tm_return->result[0], rf_band[tm_band].tx.ramp_tables[index].ramp_up, sizeof(rf_band[tm_band].tx.ramp_tables[index].ramp_up)); + memcpy(&tm_return->result[sizeof(rf_band[tm_band].tx.ramp_tables[index].ramp_up)], rf_band[tm_band].tx.ramp_tables[index].ramp_down, sizeof(rf_band[tm_band].tx.ramp_tables[index].ramp_down)); + tm_return->size = sizeof(rf_band[tm_band].tx.ramp_tables[index]); + tm_return->status = E_OK; +} + +void Cust_tm_misc_param_write(T_TM_RETURN *tm_return, WORD16 index, UWORD16 value) +{ + switch (index) + { + case GPIOSTATE0: + case GPIODIR0: + case GPIOSTATE1: + case GPIODIR1: + case GPIOSTATE0P: + case GPIODIR0P: + case GPIOSTATE1P: + case GPIODIR1P: + { + tm_return->status = E_NOSUBSYS; + break; + } + case CONVERTED_ADC0: + case CONVERTED_ADC1: + case CONVERTED_ADC2: + case CONVERTED_ADC3: + case CONVERTED_ADC4: + case CONVERTED_ADC5: + case CONVERTED_ADC6: + case CONVERTED_ADC7: + case CONVERTED_ADC8: + { + adc.converted[index - CONVERTED_ADC0] = value; + tm_return->status = E_OK; + break; + } + + case RAW_ADC0: + case RAW_ADC1: + case RAW_ADC2: + case RAW_ADC3: + case RAW_ADC4: + case RAW_ADC5: + case RAW_ADC6: + case RAW_ADC7: + case RAW_ADC8: + { + adc.raw[index - RAW_ADC0] = value; + tm_return->status = E_OK; + break; + } + + case ADC0_COEFF_A: + case ADC1_COEFF_A: + case ADC2_COEFF_A: + case ADC3_COEFF_A: + case ADC4_COEFF_A: + case ADC5_COEFF_A: + case ADC6_COEFF_A: + case ADC7_COEFF_A: + case ADC8_COEFF_A: + { + adc_cal.a[index - ADC0_COEFF_A] = value; + tm_return->status = E_OK; + break; + } + + case ADC0_COEFF_B: + case ADC1_COEFF_B: + case ADC2_COEFF_B: + case ADC3_COEFF_B: + case ADC4_COEFF_B: + case ADC5_COEFF_B: + case ADC6_COEFF_B: + case ADC7_COEFF_B: + case ADC8_COEFF_B: + { + adc_cal.b[index - ADC0_COEFF_B] = value; + tm_return->status = E_OK; + break; + } + case SLEEP_MODE: + { + tm_return->status = E_NOSUBSYS; + break; + } + default: + { + tm_return->status = E_BADINDEX; + break; + } + } // end switch +} + +void Cust_tm_misc_param_read(T_TM_RETURN *tm_return, WORD16 index) +{ + volatile UWORD16 value; + + switch (index) + { + case GPIOSTATE0: + case GPIODIR0: + case GPIOSTATE1: + case GPIODIR1: + case GPIOSTATE0P: + case GPIODIR0P: + case GPIOSTATE1P: + case GPIODIR1P: + { + tm_return->status = E_NOSUBSYS; + tm_return->size = 0; + return; + } + case CONVERTED_ADC0: + case CONVERTED_ADC1: + case CONVERTED_ADC2: + case CONVERTED_ADC3: + case CONVERTED_ADC4: + case CONVERTED_ADC5: + case CONVERTED_ADC6: + case CONVERTED_ADC7: + case CONVERTED_ADC8: + { + value = adc.converted[index - CONVERTED_ADC0]; + break; + } + case RAW_ADC0: + case RAW_ADC1: + case RAW_ADC2: + case RAW_ADC3: + case RAW_ADC4: + case RAW_ADC5: + case RAW_ADC6: + case RAW_ADC7: + case RAW_ADC8: + { + value = adc.raw[index - RAW_ADC0]; + break; + } + case ADC0_COEFF_A: + case ADC1_COEFF_A: + case ADC2_COEFF_A: + case ADC3_COEFF_A: + case ADC4_COEFF_A: + case ADC5_COEFF_A: + case ADC6_COEFF_A: + case ADC7_COEFF_A: + case ADC8_COEFF_A: + { + value = adc_cal.a[index - ADC0_COEFF_A]; + break; + } + case ADC0_COEFF_B: + case ADC1_COEFF_B: + case ADC2_COEFF_B: + case ADC3_COEFF_B: + case ADC4_COEFF_B: + case ADC5_COEFF_B: + case ADC6_COEFF_B: + case ADC7_COEFF_B: + case ADC8_COEFF_B: + { + value = adc_cal.b[index - ADC0_COEFF_B]; + break; + } + case SLEEP_MODE: + { + tm_return->status = E_NOSUBSYS; + tm_return->size = 0; + return; + } + default: + { + tm_return->status = E_BADINDEX; + tm_return->size = 0; + return; + } + } // end switch + + memcpy(tm_return->result, (UWORD8 *)&value, 2); + tm_return->size = 2; + tm_return->status = E_OK; +} + +void Cust_tm_misc_enable(T_TM_RETURN *tm_return, WORD16 action) +{ + UWORD8 status; + + // FIXME: This enum really should go into testmode header file. + enum ME_CFG_WRITE_E { + CFG_WRITE_MKDIRS = 100, + CFG_WRITE_RF_CAL = 102, + CFG_WRITE_RF_CFG = 103, + CFG_WRITE_TX_CAL = 104, + CFG_WRITE_TX_CFG = 105, + CFG_WRITE_RX_CAL = 106, + CFG_WRITE_RX_CFG = 107, + CFG_WRITE_SYS_CAL = 108, + CFG_WRITE_SYS_CFG = 109 + }; + + tm_return->size = 0; + tm_return->index = action; + tm_return->status = E_OK; + + // FIXME: This code should actually be in misc_enable() + switch(action) + { + case CFG_WRITE_MKDIRS: + ffs_mkdir("/gsm"); + ffs_mkdir("/pcm"); + ffs_mkdir("/sys"); + ffs_mkdir("/mmi"); + ffs_mkdir("/vos"); + ffs_mkdir("/var"); + ffs_mkdir("/gsm/rf"); + ffs_mkdir("/gsm/com"); + ffs_mkdir("/vos/vm"); + ffs_mkdir("/vos/vrm"); + ffs_mkdir("/vos/vrp"); + ffs_mkdir("/var/log"); + ffs_mkdir("/var/tst"); + ffs_mkdir("/gsm/rf/tx"); + ffs_mkdir("/gsm/rf/rx"); + break; + case CFG_WRITE_RF_CAL: config_ffs_write('f'); break; + case CFG_WRITE_RF_CFG: config_ffs_write('F'); break; + case CFG_WRITE_TX_CAL: config_ffs_write('t'); break; + case CFG_WRITE_TX_CFG: config_ffs_write('T'); break; + case CFG_WRITE_RX_CAL: config_ffs_write('r'); break; + case CFG_WRITE_RX_CFG: config_ffs_write('R'); break; + case CFG_WRITE_SYS_CAL: config_ffs_write('s'); break; + case CFG_WRITE_SYS_CFG: config_ffs_write('S'); break; + default: + tm_return->status = E_BADINDEX; + } +} + +void Cust_tm_special_param_write(T_TM_RETURN *tm_return, WORD16 index, UWORD16 value) +{ + tm_return->size = 0; + tm_return->index = index; + tm_return->status = E_NOSYS; +} + +void Cust_tm_special_param_read(T_TM_RETURN *tm_return, WORD16 index) +{ + tm_return->size = 0; + tm_return->index = index; + tm_return->status = E_NOSYS; +} + +void Cust_tm_special_table_write(T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[]) +{ + tm_return->size = 0; + tm_return->index = index; + tm_return->status = E_NOSYS; +} + +void Cust_tm_special_table_read(T_TM_RETURN *tm_return, WORD8 index) +{ + tm_return->size = 0; + tm_return->index = index; + tm_return->status = E_NOSYS; +} + +void Cust_tm_special_enable(T_TM_RETURN *tm_return, WORD16 action) +{ + tm_return->size = 0; + tm_return->index = action; + tm_return->status = E_NOSYS; +} + +#endif // TESTMODE
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/tm_cust0/l1tm_tpu12.c Mon Mar 20 00:51:20 2017 +0000 @@ -0,0 +1,92 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1TM_TPU2.C + * + * Filename %M% + * Version %I% + * Date %G% + * + ************* Revision Controle System Header *************/ +#include "l1_confg.h" + +#if (TESTMODE && (RF==12)) + +#include "tm_defs.h" +#include "l1_const.h" +#include "l1_types.h" + +#include "l1tm_defty.h" +#include "l1tm_cust.h" +#include "l1tm_tpu12.h" + +#if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" +#endif +////////////////////////////henry +#if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" +#endif +/////////////////////////// +#include "l1_defty.h" +#include "l1_msgty.h" +#include "l1_tabs.h" + +#include "l1tm_msgty.h" +#include "l1tm_varex.h" + +#if ((ANLG_FAM == 1) || (ANLG_FAM == 2)) + #include "spi_drv.h" +#endif + +#include "tpudrv12.h" +#include "l1_rf12.h" + + +#include <string.h> + +// Import band configuration from Flash module (need to replace by an access function) + + +// External function prototypes + + +void Cust_tm_tpu_table_write (T_TM_RETURN *tm_return, WORD8 index, UWORD8 size, UWORD8 table[]) +{ +/* + INDICES BETWEEN in [0..63] RANGE ARE RESERVED FOR TI RF MODULE +*/ + + // fill in the cid + tm_return->cid = TPU_TABLE_WRITE; + + switch (index) + { + default: + tm_return->size = 0; + tm_return->status = E_BADINDEX; + break; + } // end of switch +} + +void Cust_tm_tpu_table_read (T_TM_RETURN *tm_return, WORD8 index) +{ +/* + INDICES BETWEEN in [0..63] RANGE ARE RESERVED FOR TI RF MODULE +*/ + + // fill in the cid + tm_return->cid = TPU_TABLE_READ; + + switch (index) + { + default: + tm_return->size = 0; + tm_return->status = E_BADINDEX; + break; + } // end of switch +} + +#endif //TESTMODE