/********************************************************************************
 * Enhanced TestMode (ETM)
 * @file	etm_audio.c (Support for AUDIO commands)
 *
 * @author	Kim T. Peteren (ktp@ti.com)
 * @version 0.8
 *

 *
 * History:
 *
 * 	Date       	Modification
 *  ------------------------------------
 *  16/06/2003	Creation
 *  30/06/2003  Small cleanup in func. etm_audio_write, etm_audio_saveload and
 *              etm_aud_wait_for_aud_event is updated and renamed
 *  12/08/2003  The func. etm_audio_write has been updated regarding the AEC struct.
 *  14/08/2003  The func. etm_audio_read has been updated regarding the AEC struct.
 *  17/03/2004  Modified the event handling, events revceived from the Audio SWE. 
 *              Integrated event callback function, etm_audio_callback().
 *
 * (C) Copyright 2003 by Texas Instruments Incorporated, All Rights Reserved
 *********************************************************************************/


#include "etm/etm.h"
#include "etm/etm_api.h"
#include "etm/etm_trace.h"
#include "etm/etm_env.h" // Need because use of T_ETM_ENV_CTRL_BLK 
#include "etm/etm_audio_err.h" // Privat Audio error codes for PC and Target 

#include "etm/etm_trace.h"
#include "audio/audio_api.h"

#include "rv/rv_general.h"
#include "spi/spi_drv.h" // used for codec read/write

#include "memif/mem.h"
#include <string.h>


/******************************************************************************
 * Globals
 *****************************************************************************/

// Version of the ETM AUDIO module
//const uint16 etm_audio_revision = (1<<12) | (0x1);

extern T_ETM_ENV_CTRL_BLK *etm_env_ctrl_blk;

static int etm_audio_event_status = 0;


/******************************************************************************
 * Internal prototypes 
 *****************************************************************************/

int etm_audio(uint8 *indata, int insize);
T_RV_HDR *etm_audio_wait_for_event(UINT16 msg_id_expected);
T_ETM_PKT *etm_audio_setup(uint8 fid, uint8 cfg_data);
void etm_audio_callback(void *event_from_audio);


/******************************************************************************
 * Register the Audio Module to the ETM database 
 *****************************************************************************/

int etm_audio_init(void)
{
    int result; 

    result = etm_register("AUDIO", ETM_AUDIO, 0, 0, etm_audio);
    return result;    
}


/******************************************************************************
 * Audio Full Access Read Function
 *****************************************************************************/

int etm_audio_read(T_ETM_PKT *pkt, uint8 *buf)
{
    int result, size = 0, size_tmp, i;
    uint8 param;
    T_AUDIO_FULL_ACCESS_READ audio;
    T_AUDIO_AEC_CFG *aec_parameter = NULL;
    void *parameter = NULL;
    
    param = *buf;
    if ((result = etm_pkt_put8(pkt, param)) < 0) 
        return result;

    tr_etm(TgTrAudio, "ETM AUDIO: _audio_read: param(%d)", param);
   
    audio.variable_indentifier = param;
    audio.data = (T_AUDIO_FULL_ACCESS_READ *) &pkt->data[2]; //data[0] = fid
                                                             //data[1] = parameter/identifier
    
    if ((result = audio_full_access_read(&audio)) != AUDIO_OK){
        tr_etm(TgTrAudio, "ETM AUDIO: _audio_read: ERROR(%d)", result);
        if (result == AUDIO_ERROR) 
            return ETM_INVAL;         // Invalid audio parameter
        else
            return ETM_AUDIO_FATAL;
    }

    switch (param) {
    case AUDIO_PATH_USED:
        size = sizeof(T_AUDIO_VOICE_PATH_SETTING);
        break;
    case AUDIO_MICROPHONE_MODE:
    case AUDIO_MICROPHONE_GAIN:
    case AUDIO_MICROPHONE_EXTRA_GAIN:
    case AUDIO_MICROPHONE_OUTPUT_BIAS:
    case AUDIO_MICROPHONE_SPEAKER_LOOP_SIDETONE:
        size = sizeof(INT8);                         
        break;
    case AUDIO_MICROPHONE_SPEAKER_LOOP_AEC:
        size = sizeof(T_AUDIO_AEC_CFG);              
      
        aec_parameter = (T_AUDIO_AEC_CFG *) &pkt->data[2];

        etm_pkt_put16(pkt, aec_parameter->aec_enable);                  // 1
#if (L1_NEW_AEC)
        etm_pkt_put16(pkt, aec_parameter->continuous_filtering);        // 2
        etm_pkt_put16(pkt, aec_parameter->granularity_attenuation);     // 3
        etm_pkt_put16(pkt, aec_parameter->smoothing_coefficient);       // 4
        etm_pkt_put16(pkt, aec_parameter->max_echo_suppression_level);  // 5
        etm_pkt_put16(pkt, aec_parameter->vad_factor);                  // 6
        etm_pkt_put16(pkt, aec_parameter->absolute_threshold);          // 7
        etm_pkt_put16(pkt, aec_parameter->factor_asd_filtering);        // 8
        etm_pkt_put16(pkt, aec_parameter->factor_asd_muting);           // 9
        etm_pkt_put16(pkt, aec_parameter->aec_visibility);              //10
#else
        etm_pkt_put16(pkt, aec_parameter->aec_mode);                    // 2
        etm_pkt_put16(pkt, aec_parameter->echo_suppression_level);      // 3
#endif // end of (L1_NEW_AEC)
        etm_pkt_put16(pkt, aec_parameter->noise_suppression_enable);    // 4 or 11
        etm_pkt_put16(pkt, aec_parameter->noise_suppression_level);     // 5 or 12
        break;
    case AUDIO_MICROPHONE_FIR:
    case AUDIO_SPEAKER_FIR:
        size = sizeof(T_AUDIO_FIR_COEF);             
        break;
    case AUDIO_SPEAKER_MODE:
    case AUDIO_SPEAKER_GAIN:
    case AUDIO_SPEAKER_FILTER:
    case AUDIO_SPEAKER_BUZZER_STATE:
        size = sizeof(INT8);                         
        break;
    case AUDIO_SPEAKER_VOLUME_LEVEL:
        size = sizeof(T_AUDIO_SPEAKER_LEVEL);        
        break;
    default:
        size = ETM_INVAL;                            
    }

    pkt->size += size;
    return ETM_OK;
}

 
/******************************************************************************
 * Audio Full Access Write Function
 *****************************************************************************/

int etm_audio_write(T_ETM_PKT *pkt, uint8 *buf)
{
    T_RV_HDR *msg = NULL;
    T_RV_RETURN return_path;
    T_AUDIO_FULL_ACCESS_WRITE audio;
    T_AUDIO_AEC_CFG *aec_parameter = NULL;
    void *parameter = NULL;
    int result = ETM_OK, i;
    uint8 param;

    param = *buf++;
    if ((result = etm_pkt_put8(pkt, param)) < ETM_OK) {
        return result;
    } 

    tr_etm(TgTrAudio, "ETM AUDIO: _audio_write: param(%d)", param);

    return_path.addr_id        = NULL; //etm_env_ctrl_blk->addr_id;
    return_path.callback_func  = etm_audio_callback;

    audio.variable_indentifier = param;
    audio.data = buf;

    switch (param) {
    case AUDIO_MICROPHONE_SPEAKER_LOOP_AEC:
        tr_etm(TgTrAudio, "ETM AUDIO: _audio_write: AUDIO_MICROPHONE_SPEAKER_LOOP_AEC"); // RemoveMe
        aec_parameter = etm_malloc (sizeof(T_AUDIO_AEC_CFG));
        
        aec_parameter->aec_enable =                 etm_get16(buf); buf += 2;// 1
#if (L1_NEW_AEC)
        if (etm_get16(buf))  // 2
            aec_parameter->continuous_filtering = TRUE;
         else
            aec_parameter->continuous_filtering = FALSE;
        buf += 2;
        aec_parameter->granularity_attenuation =    etm_get16(buf); buf += 2;// 3
        aec_parameter->smoothing_coefficient =      etm_get16(buf); buf += 2;// 4
        aec_parameter->max_echo_suppression_level = etm_get16(buf); buf += 2;// 5
        aec_parameter->vad_factor =                 etm_get16(buf); buf += 2;// 6
        aec_parameter->absolute_threshold =         etm_get16(buf); buf += 2;// 7
        aec_parameter->factor_asd_filtering =       etm_get16(buf); buf += 2;// 8
        aec_parameter->factor_asd_muting =          etm_get16(buf); buf += 2;// 9
        aec_parameter->aec_visibility =             etm_get16(buf); buf += 2;// 10
#else
        aec_parameter->aec_mode =                   etm_get16(buf); buf += 2;// 2
        aec_parameter->echo_suppression_level =     etm_get16(buf); buf += 2;// 3
#endif // end of (L1_NEW_AEC)
#if (L1_ANR == 0)
        aec_parameter->noise_suppression_enable =   etm_get16(buf); buf += 2;// 4 or 11
        aec_parameter->noise_suppression_level =    etm_get16(buf); // 5 or 12
#endif // end of (L1_ANR)
        audio.data = aec_parameter;
        break;
    case AUDIO_MICROPHONE_FIR:
    case AUDIO_SPEAKER_FIR:
        tr_etm(TgTrAudio, "ETM AUDIO: _audio_write: AUDIO_MICROPHONE/SPEAKER_FIR [%d]", 
               sizeof(T_AUDIO_FIR_COEF)/2); // RemoveMe

        parameter = etm_malloc (sizeof(T_AUDIO_FIR_COEF));
        // Write coeffient values
        for (i=0; i <= (sizeof(T_AUDIO_FIR_COEF)/2); i++) {
            ((T_AUDIO_FIR_COEF *) parameter)->coefficient[i]  = etm_get16(buf);  buf += 2;
        }
        audio.data = parameter;
        break;
    }

    if ((result = audio_full_access_write(&audio, return_path)) != AUDIO_OK) {
        tr_etm(TgTrAudio, "ETM AUDIO: _audio_write: ERROR(%d)", result);
        if (result == AUDIO_ERROR) 
            result = ETM_INVAL;         // Invalid audio parameter
        else
            result = ETM_AUDIO_FATAL;
    }

    // Wait for recv. of event: AUDIO_FULL_ACCESS_WRITE_DONE
    rvf_wait(0xffff, 100); // Timeout 100 ticks
    tr_etm(TgTrAudio, "ETM AUDIO: _audio_write: STATUS(%d)", etm_audio_event_status);

    if (parameter != NULL) {
        etm_free(parameter);
        parameter = NULL;
    }

    if (aec_parameter != NULL) {
        etm_free(aec_parameter);    
        aec_parameter = NULL;
    }

    if (etm_audio_event_status != 0) {
        etm_audio_event_status = 0;
        result = ETM_AUDIO_FATAL;
    }

    return result;
}

/******************************************************************************
 * Audio Save and Load cfg file Function
 *****************************************************************************/

int etm_audio_saveload(T_ETM_PKT *pkt, uint8 saveload, void *buf, int size)
{
    T_RV_HDR *msg;
    T_AUDIO_MODE_SAVE audio_s;
    T_AUDIO_MODE_LOAD audio_l;
    T_RV_RETURN return_path;
    int result = ETM_OK; 
    int error, event;
    
    return_path.addr_id        = etm_env_ctrl_blk->addr_id;
    return_path.callback_func  = NULL;

    switch(saveload) {
    case 'S':
        memcpy(audio_s.audio_mode_filename, buf, size);
        result = audio_mode_save(&audio_s, return_path); 
        break;
    case 'L':
        memcpy(audio_l.audio_mode_filename, buf, size);
        result = audio_mode_load(&audio_l, return_path); 
        break;
    default:
        tr_etm(TgTrAudio, "ETM AUDIO: _audio_saveload: FAILED"); 
        break;
    }
    
    rvf_wait(0xffff, 100); // Timeout 100 ticks
    tr_etm(TgTrAudio, "ETM AUDIO: _audio_saveload: STATUS(%d)", etm_audio_event_status);

    if (etm_audio_event_status != 0) {
        etm_audio_event_status = 0;
        return ETM_AUDIO_FATAL;
    }

    if (result != AUDIO_OK)
        return ETM_AUDIO_FATAL;

    return result;
}


/******************************************************************************
 * ETM AUDIO callback functio
 *****************************************************************************/

void etm_audio_callback(void *event_from_audio)
{
    tr_etm(TgTrEtmLow,"ETM: AUDIO: _audio_callback: recv. event (0x%x)", 
           ((T_RV_HDR *) event_from_audio)->msg_id);
    
    switch (((T_RV_HDR *) event_from_audio)->msg_id)
    {
    case AUDIO_FULL_ACCESS_WRITE_DONE:
        tr_etm(TgTrAudio, "ETM AUDIO: _audio_callback: recv. event AUDIO_FULL_ACCESS_WRITE_DONE");
        etm_audio_event_status = ((T_AUDIO_FULL_ACCESS_WRITE_DONE *) event_from_audio)->status;
        break;
    case AUDIO_MODE_SAVE_DONE:
        tr_etm(TgTrAudio, "ETM AUDIO: _audio_callback: recv. event AUDIO_MODE_SAVE_DONE");
        etm_audio_event_status = ((T_AUDIO_SAVE_DONE *) event_from_audio)->status;
        break;
    case AUDIO_MODE_LOAD_DONE:
        tr_etm(TgTrAudio, "ETM AUDIO: _audio_callback: recv. event AUDIO_MODE_LOAD_DONE");
        etm_audio_event_status = ((T_AUDIO_LOAD_DONE *) event_from_audio)->status;
        break;
    }
    
    if (event_from_audio != NULL) {
//        etm_free(event_from_audio); 
        event_from_audio = NULL;
    }
}


/******************************************************************************
 * ETM AUDIO Moudle - Main Task
 *****************************************************************************/

// AUDIO packet structure for audio read/write and codec read/write: 
// |fid(8)|param(8)|--data(W)--| and for audio save/load |fid|--data(W)--|

int etm_audio(uint8 *indata, int insize)
{
    int error = ETM_OK;
    uint8 fid;
    T_ETM_PKT *pkt = NULL;  

    fid = *indata++;   
       
    tr_etm(TgTrAudio, "ETM AUDIO: _audio: fid(%c) param(%d) recv. size(%d)", 
           fid, *indata, insize); 

    /* Create TestMode return Packet */
    if ((pkt = (T_ETM_PKT *) etm_malloc(sizeof(T_ETM_PKT))) == NULL) {
        return ETM_NOMEM;
    }
    
    // Init. of return packet
    pkt->mid     = ETM_AUDIO;
    pkt->status  = ETM_OK;
    pkt->size    = 0;
    pkt->index   = 0;
    etm_pkt_put8(pkt, fid);
    
    if (error == ETM_OK) {
        switch (fid) {
        case 'R':
            error = etm_audio_read(pkt, indata);                  
            break;
        case 'W':
            error = etm_audio_write(pkt, indata); 
            break;
        case 'S':
        case 'L': 
            error = etm_audio_saveload(pkt, fid, indata, insize);  
            break;
        default:
            tr_etm(TgTrAudio, "ETM AUDIO: _audio: fid(%c) - ERROR ", fid);
            error = ETM_NOSYS;                                
            break;
        }
    }
    
    if (error < 0) {
        tr_etm(TgTrAudio,"ETM AUDIO: _audio: ERROR(%d)", error); 
        pkt->status = -error;

    }

    etm_pkt_send(pkt);
    etm_free(pkt);

    return ETM_OK;
}