source: svn/newcon3bcm2_21bu/nexus/modules/audio/7552/src/nexus_audio_module.c

/***************************************************************************
*     (c)2004-2011 Broadcom Corporation
*
*  This program is the proprietary software of Broadcom Corporation and/or its licensors,
*  and may only be used, duplicated, modified or distributed pursuant to the terms and
*  conditions of a separate, written license agreement executed between you and Broadcom
*  (an "Authorized License").  Except as set forth in an Authorized License, Broadcom grants
*  no license (express or implied), right to use, or waiver of any kind with respect to the
*  Software, and Broadcom expressly reserves all rights in and to the Software and all
*  intellectual property rights therein.  IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU
*  HAVE NO RIGHT TO USE THIS SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY
*  NOTIFY BROADCOM AND DISCONTINUE ALL USE OF THE SOFTWARE.
*
*  Except as expressly set forth in the Authorized License,
*
*  1.     This program, including its structure, sequence and organization, constitutes the valuable trade
*  secrets of Broadcom, and you shall use all reasonable efforts to protect the confidentiality thereof,
*  and to use this information only in connection with your use of Broadcom integrated circuit products.
*
*  2.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
*  AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, REPRESENTATIONS OR
*  WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO
*  THE SOFTWARE.  BROADCOM SPECIFICALLY DISCLAIMS ANY AND ALL IMPLIED WARRANTIES
*  OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE,
*  LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION
*  OR CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING OUT OF
*  USE OR PERFORMANCE OF THE SOFTWARE.
*
*  3.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM OR ITS
*  LICENSORS BE LIABLE FOR (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR
*  EXEMPLARY DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO YOUR
*  USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM HAS BEEN ADVISED OF
*  THE POSSIBILITY OF SUCH DAMAGES; OR (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT
*  ACTUALLY PAID FOR THE SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE
*  LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF
*  ANY LIMITED REMEDY.
*
* $brcm_Workfile: nexus_audio_module.c $
* $brcm_Revision: 25 $
* $brcm_Date: 12/20/11 4:13p $
*
* API Description:
*   API name: Audio Module
*    Top-Level Audio Module APIs
*
* Revision History:
*
* $brcm_Log: /nexus/modules/audio/7422/src/nexus_audio_module.c $
* 
* 25   12/20/11 4:13p jgarrett
* SW7425-1018: Adding initial A/85 implementation
* 
* 24   12/14/11 4:52p jgarrett
* SW7425-1950: Consolidating audio codec conversion routines into core
*  module
* 
* 23   11/21/11 2:48p jgarrett
* SW7425-1406: Adding Vorbis audio support
* 
* VORBIS_DEVEL/2   11/16/11 1:51p jgarrett
* SW7425-1406: Merging latest main branch changes
* 
* 22   11/3/11 6:53p jgarrett
* SW7422-400: Enabling audio debug logs on 40nm APE chips
* 
* VORBIS_DEVEL/1   10/4/11 3:53p jgarrett
* SW7425-1406: Adding Vorbis support
* 
* 21   9/27/11 4:36p jgarrett
* SW7408-304: Destroying IMG context on shutdown
*
* 20   8/18/11 5:51p jgarrett
* SWDTV-6306: Merge DTV APE changes to main branch
*
* Nexus_APE_Integration/2   8/10/11 5:17p jgarrett
* SWDTV-6306: Enabling implicit capture to DSP instead of FMM by default
*  for DTV
*
* Nexus_APE_Integration/1   8/10/11 5:16p jgarrett
* SWDTV-6306: Adding implicit capture to DSP instead of FMM for DTV
*
* 19   8/4/11 7:33p mphillip
* SW7422-404: Update audio region verification code
*
* 18   7/21/11 4:13p gmohile
* SW7125-1014 : Rework power management
*
* SW7125-1014/1   7/20/11 4:37p gmohile
* SW7125-1014 : Rework power management
*
* 17   7/1/11 4:03p jgarrett
* SW7231-274: Adding optional audio firmware heap
*
* 16   7/1/11 9:59a jgarrett
* SW7405-5072: Adding WMA TS Support
*
* 15   6/27/11 5:42p jgarrett
* SW7231-97: Enabling DtsLegacy
*
* 14   6/24/11 11:38a gmohile
* SW7231-128 : Add BDSP standby
*
* 13   6/20/11 5:42p jgarrett
* SW7425-409: Merging VP6 support to main branch
*
* SW7425-409/2   6/8/11 6:58p jgarrett
* SW7425-409: Fixing linker issue if DSP video decoder extension is not
*  defined
*
* SW7425-409/1   6/6/11 7:23p jgarrett
* SW7425-409: Adding init hooks for VDE
*
* 12   5/13/11 5:17p gmohile
* SW7231-128 : Add Standby support
*
* 11   4/19/11 6:07p jgarrett
* SW7425-386: Enabling control of audio memory allocation
*
* 10   4/19/11 5:32p jgarrett
* SW7422-408: Adding additional codecs
*
* 9   4/18/11 10:14p gskerl
* SW7425-364: Added BAPE_Pll_EnableExternalMclk() API to APE, then called
*  it from NEXUS_AudioModule_EnableExternalMclk()
*
* 8   3/23/11 6:28p jgarrett
* SW7422-352: adding HDMI input support to nexus
*
* 7   2/22/11 5:30p jgarrett
* SW7422-146: Fixing build errors
*
* 6   1/19/11 3:01p jgarrett
* SW7422-146: Initial decode/passthrough of ac3
*
* 5   1/13/11 5:25p jgarrett
* SW7422-146: Adding encoder hooks
*
* 4   1/10/11 5:21p jgarrett
* SW7422-146: Fixing module comments
*
* 3   1/10/11 5:19p jgarrett
* SW7422-146: Adding ramp step APIs
*
* 2   1/10/11 4:20p jgarrett
* SW7422-146: Adding missing module-level routines
*
* 1   12/17/10 3:56p jgarrett
* SW7422-146: Adding initial nexus on APE for 7422
*
***************************************************************************/
#include "nexus_audio_module.h"
#define RAAGA_DEBUG_LOG_CHANGES 1
#include "bdsp_raaga.h"
#ifdef NEXUS_SECURITY_AUDIO_VERIFICATION
#include "nexus_audio_decoder_security.h"
#endif

BDBG_MODULE(nexus_audio_module);

NEXUS_ModuleHandle g_NEXUS_audioModule;
NEXUS_AudioModuleData g_NEXUS_audioModuleData;

static void NEXUS_AudioModule_Print(void)
{
    BDBG_MSG(("Audio:"));
    #if 0   /* TODO */
    BDBG_MSG((" handles: xpt:%p hdmi in:%p hdmi out:%p fe:%p rap:%p",g_NEXUS_audioModuleData.transport,g_NEXUS_audioModuleData.hdmiInput,g_NEXUS_audioModuleData.hdmiOutput,g_NEXUS_audioModuleData.frontend,g_NEXUS_audioModuleData.hRap));
    BDBG_MSG((" img: ctxt:%p i:%p",g_NEXUS_audioModuleData.img_context,g_NEXUS_audioModuleData.img_interface));
    BDBG_MSG((" settings: wd:%d id:%d hbre:%d maxpb:%d",g_NEXUS_audioModuleData.moduleSettings.watchdogEnabled,g_NEXUS_audioModuleData.moduleSettings.independentDelay,g_NEXUS_audioModuleData.moduleSettings.hbrEnabled,g_NEXUS_audioModuleData.moduleSettings.maximumProcessingBranches));
    #endif
}

void NEXUS_AudioModule_GetDefaultSettings(
    NEXUS_AudioModuleSettings *pSettings    /* [out] */
    )
{
    BAPE_Settings apeSettings;
    BDSP_RaagaSettings raagaSettings;
    unsigned i;

    BKNI_Memset(pSettings, 0, sizeof(NEXUS_AudioModuleSettings));
    BAPE_GetDefaultSettings(&apeSettings);
    pSettings->watchdogEnabled = true;
    pSettings->maxAudioDspTasks = apeSettings.maxDspTasks;
    pSettings->maxIndependentDelay = apeSettings.maxIndependentDelay;
    pSettings->maxPcmSampleRate = apeSettings.maxPcmSampleRate;
    pSettings->hbrEnabled = apeSettings.highBitRateEnabled;
    pSettings->numCompressedBuffers = apeSettings.numCompressedBuffers;
    pSettings->numPcmBuffers = apeSettings.numPcmBuffers;
    pSettings->independentDelay = pSettings->maxIndependentDelay > 0 ? true : false;
#if 0 /* JPF */
    BDBG_CASSERT(NEXUS_AudioLoudnessEquivalenceMode_eNone == (int)BAPE_LoudnessEquivalenceMode_eNone);
    BDBG_CASSERT(NEXUS_AudioLoudnessEquivalenceMode_eAtscA85 == (int)BAPE_LoudnessEquivalenceMode_eAtscA85);
    BDBG_CASSERT(NEXUS_AudioLoudnessEquivalenceMode_eEbuR128 == (int)BAPE_LoudnessEquivalenceMode_eEbuR128);
    BDBG_CASSERT(NEXUS_AudioLoudnessEquivalenceMode_eMax == (int)BAPE_LoudnessEquivalenceMode_eMax);
    pSettings->loudnessMode = (NEXUS_AudioLoudnessEquivalenceMode)apeSettings.loudnessMode;
#endif
    #if NEXUS_DTV_PLATFORM
    pSettings->routeInputsToDsp = true;
    #endif

    BDSP_Raaga_GetDefaultSettings(&raagaSettings);
    for ( i = 0; i < NEXUS_AudioDspDebugType_eMax; i++ )
    {
        pSettings->dspDebugSettings.typeSettings[i].enabled = false;    /* Disable all debug by default */
        pSettings->dspDebugSettings.typeSettings[i].bufferSize = raagaSettings.debugSettings[i].bufferSize;
    }
}

NEXUS_ModuleHandle NEXUS_AudioModule_Init(
    const NEXUS_AudioModuleSettings *pSettings  /* NULL will use default settings */
    )
{
    BERR_Code errCode;
    NEXUS_ModuleSettings moduleSettings;
    BAPE_Settings apeSettings;
    BDSP_RaagaSettings raagaSettings;
    NEXUS_AudioModuleSettings audioModuleSettings;
    BMEM_Heap_Handle fwHeap = g_pCoreHandles->heap[0];
    unsigned i;

    NEXUS_Module_GetDefaultSettings(&moduleSettings);
    moduleSettings.priority = NEXUS_ModulePriority_eLow; /* decoder interface is slow */
    moduleSettings.dbgPrint = NEXUS_AudioModule_Print;
    moduleSettings.dbgModules = "nexus_audio_module";
    g_NEXUS_audioModule = NEXUS_Module_Create("audio", &moduleSettings);

    if ( NULL == g_NEXUS_audioModule )
    {
        errCode=BERR_TRACE(BERR_OS_ERROR);
        goto err_module;
    }

    if ( NULL == pSettings )
    {
        NEXUS_AudioModule_GetDefaultSettings(&audioModuleSettings);
        pSettings = &audioModuleSettings;
    }

    g_NEXUS_audioModuleData.settings = *pSettings;

    BDSP_Raaga_GetDefaultSettings(&raagaSettings);

    #if 1
    {
        static BIMG_Interface imgInterface;
        /* TODO: Connect IMG to DSP interface */
        if ( Nexus_Core_P_Img_Create(NEXUS_CORE_IMG_ID_RAP, &g_NEXUS_audioModuleData.pImageContext, &imgInterface) == NEXUS_SUCCESS )
        {
            BDBG_WRN(("FW download used"));
            raagaSettings.pImageContext = g_NEXUS_audioModuleData.pImageContext;
            raagaSettings.pImageInterface = &imgInterface;
        }
    }
    #endif

    if ( pSettings->firmwareHeap )
    {
        fwHeap = NEXUS_Heap_GetMemHandle(pSettings->firmwareHeap);
        if ( NULL == fwHeap )
        {
            (void)BERR_TRACE(BERR_INVALID_PARAMETER);
            goto err_dsp;
        }
    }
#ifdef NEXUS_SECURITY_AUDIO_VERIFICATION
    NEXUS_Audio_P_EnableFwVerification(&raagaSettings);
#endif

    for ( i = 0; i < NEXUS_AudioDspDebugType_eMax; i++ )
    {
        raagaSettings.debugSettings[i].enabled = pSettings->dspDebugSettings.typeSettings[i].enabled;
        raagaSettings.debugSettings[i].bufferSize = pSettings->dspDebugSettings.typeSettings[i].bufferSize;

        if ( pSettings->dspDebugSettings.typeSettings[i].enabled )
        {
            BDBG_WRN(("Enabling audio FW debug type %u [%s]", i, (i == NEXUS_AudioDspDebugType_eDramMessage)?"DRAM Message":
                                                                 (i == NEXUS_AudioDspDebugType_eUartMessage)?"UART Message":
                                                                 "Core Dump"));
        }
    }

    errCode = BDSP_Raaga_Open(&g_NEXUS_audioModuleData.dspHandle,
                              g_pCoreHandles->chp,
                              g_pCoreHandles->reg,
                              fwHeap,
                              g_pCoreHandles->bint,
                              g_pCoreHandles->tmr,
                              &raagaSettings);
    if ( errCode )
    {
        (void)BERR_TRACE(errCode);
        goto err_dsp;
    }
#ifdef NEXUS_SECURITY_AUDIO_VERIFICATION
    errCode = NEXUS_Audio_P_FwVerification (g_NEXUS_audioModuleData.dspHandle);
    if ( errCode )
    {
        (void)BERR_TRACE(errCode);
        return NULL;
    }
#endif

    BAPE_GetDefaultSettings(&apeSettings);
    apeSettings.maxDspTasks = pSettings->maxAudioDspTasks;
    apeSettings.maxIndependentDelay = pSettings->independentDelay ? pSettings->maxIndependentDelay : 0;
    apeSettings.maxPcmSampleRate = pSettings->maxPcmSampleRate;
    apeSettings.highBitRateEnabled = pSettings->hbrEnabled;
    apeSettings.numCompressedBuffers = pSettings->numCompressedBuffers;
    apeSettings.numPcmBuffers = pSettings->numPcmBuffers;
// JPF    apeSettings.loudnessMode = (BAPE_LoudnessEquivalenceMode)pSettings->loudnessMode;

    if ( NEXUS_GetEnv("audio_ramp_disabled") )
    {
        apeSettings.rampPcmSamples = false;
    }

    errCode = BAPE_Open(&NEXUS_AUDIO_DEVICE_HANDLE,
                        g_pCoreHandles->chp,
                        g_pCoreHandles->reg,
                        g_pCoreHandles->heap[0],
                        g_pCoreHandles->bint,
                        g_pCoreHandles->tmr,
                        g_NEXUS_audioModuleData.dspHandle,
                        &apeSettings);

    if ( errCode )
    {
        (void)BERR_TRACE(errCode);
        goto err_ape;
    }

    errCode = NEXUS_AudioDecoder_P_Init();
    if ( errCode )
    {
        (void)BERR_TRACE(errCode);
        goto err_decoder;
    }

    errCode = NEXUS_AudioInput_P_Init();
    if ( errCode )
    {
        (void)BERR_TRACE(errCode);
        goto err_input;
    }

#if NEXUS_NUM_DSP_VIDEO_DECODERS
    errCode = NEXUS_AudioModule_P_InitDspVideoDecoder();
    if ( errCode )
    {
        (void)BERR_TRACE(errCode);
        goto err_video;
    }
#endif

    return g_NEXUS_audioModule;

#if NEXUS_NUM_DSP_VIDEO_DECODERS
err_video:
    NEXUS_AudioInput_P_Uninit();
#endif
err_input:
    NEXUS_AudioDecoder_P_Uninit();
err_decoder:
    BAPE_Close(NEXUS_AUDIO_DEVICE_HANDLE);
err_ape:
    BDSP_Close(g_NEXUS_audioModuleData.dspHandle);
err_dsp:
    NEXUS_Module_Destroy(g_NEXUS_audioModule);
err_module:
    return NULL;
}

void NEXUS_AudioModule_Uninit(void)
{
#if NEXUS_NUM_DSP_VIDEO_DECODERS
    NEXUS_AudioModule_P_UninitDspVideoDecoder();
#endif
    NEXUS_AudioInput_P_Uninit();
    NEXUS_AudioDecoder_P_Uninit();

    if ( NEXUS_AUDIO_DEVICE_HANDLE )
    {
        BAPE_Close(NEXUS_AUDIO_DEVICE_HANDLE);
    }
    if ( g_NEXUS_audioModuleData.dspHandle )
    {
        BDSP_Close(g_NEXUS_audioModuleData.dspHandle);
    }
#ifdef NEXUS_SECURITY_AUDIO_VERIFICATION
    NEXUS_Audio_P_DisableFwVerification ();
#endif

    if (g_NEXUS_audioModuleData.pImageContext) {
        Nexus_Core_P_Img_Destroy(g_NEXUS_audioModuleData.pImageContext);
    }

    if ( g_NEXUS_audioModule )
    {
        NEXUS_Module_Destroy(g_NEXUS_audioModule);
    }
}

void NEXUS_AudioModule_GetRampStepSettings(
    NEXUS_AudioRampStepSettings *pRampStepSettings      /* [out] ramping step size for scale change for all output ports */
    )
{
    uint32_t val;
    if ( NULL == pRampStepSettings )
    {
        return;
    }
    BAPE_GetOutputVolumeRampStep(NEXUS_AUDIO_DEVICE_HANDLE, &val);
    pRampStepSettings->mixerRampStep = val;
    BAPE_GetSampleRateConverterRampStep(NEXUS_AUDIO_DEVICE_HANDLE, &val);
    pRampStepSettings->srcRampStep = val;
}

NEXUS_Error NEXUS_AudioModule_SetRampStepSettings(
    const NEXUS_AudioRampStepSettings *pRampStepSettings  /* ramping step size for scale change for all output ports */
    )
{
    BERR_Code errCode;

    if ( NULL == pRampStepSettings )
    {
        return BERR_TRACE(BERR_INVALID_PARAMETER);
    }

    errCode = BAPE_SetOutputVolumeRampStep(NEXUS_AUDIO_DEVICE_HANDLE, pRampStepSettings->mixerRampStep);
    if ( errCode )
    {
        return BERR_TRACE(errCode);
    }

    errCode = BAPE_SetSampleRateConverterRampStep(NEXUS_AUDIO_DEVICE_HANDLE, pRampStepSettings->srcRampStep);
    if ( errCode )
    {
        return BERR_TRACE(errCode);
    }

    return BERR_SUCCESS;
}

NEXUS_Error NEXUS_AudioModule_EnableExternalMclk(
    unsigned mclkIndex,
    unsigned pllIndex,
    NEXUS_ExternalMclkRate mclkRate
    )
{
    BERR_Code       errCode;
    BAPE_Pll        bapePll;
    BAPE_MclkRate   bapeMclkRate;

    switch ( pllIndex )
    {
    case 0:
        bapePll = BAPE_Pll_e0;
        break;
    case 1:
        bapePll = BAPE_Pll_e1;
        break;
    case 2:
        bapePll = BAPE_Pll_e2;
        break;

    default:
        BDBG_ERR(("pllIndex:%lu is invalid", pllIndex));
        return BERR_TRACE(BERR_INVALID_PARAMETER);
    }

    switch( mclkRate )
    {
    case NEXUS_ExternalMclkRate_e128Fs:
        bapeMclkRate = BAPE_MclkRate_e128Fs;
        break;

    case NEXUS_ExternalMclkRate_e256Fs:
        bapeMclkRate = BAPE_MclkRate_e256Fs;
        break;

    case NEXUS_ExternalMclkRate_e384Fs:
        bapeMclkRate = BAPE_MclkRate_e384Fs;
        break;

    case NEXUS_ExternalMclkRate_e512Fs:
        bapeMclkRate = BAPE_MclkRate_e512Fs;
        break;

    default:
        BDBG_ERR(("mclkRate:%lu is invalid", mclkRate));
        return BERR_TRACE(BERR_INVALID_PARAMETER);
    }

    errCode = BAPE_Pll_EnableExternalMclk( NEXUS_AUDIO_DEVICE_HANDLE, bapePll, mclkIndex, bapeMclkRate );
    if ( errCode )
    {
        return BERR_TRACE(errCode);
    }
    return BERR_SUCCESS;
}

BAVC_AudioCompressionStd NEXUS_Audio_P_CodecToMagnum(NEXUS_AudioCodec codec)
{
    return NEXUS_P_AudioCodec_ToMagnum(codec);
}

NEXUS_AudioCodec NEXUS_Audio_P_MagnumToCodec(BAVC_AudioCompressionStd codec)
{
    return NEXUS_P_AudioCodec_FromMagnum(codec);
}

NEXUS_Error NEXUS_AudioModule_Standby_priv(
    bool enabled,
    const NEXUS_StandbySettings *pSettings
    )
{
    BERR_Code rc = NEXUS_SUCCESS;

    BSTD_UNUSED(pSettings);

#if NEXUS_POWER_MANAGEMENT
    if(enabled) {
        rc = BAPE_Standby(g_NEXUS_audioModuleData.apeHandle, NULL);
        rc = BDSP_Standby(g_NEXUS_audioModuleData.dspHandle, NULL);
    } else {
        rc = BDSP_Resume(g_NEXUS_audioModuleData.dspHandle);
        rc = BAPE_Resume(g_NEXUS_audioModuleData.apeHandle);
    }
#else
    BSTD_UNUSED(enabled);
#endif

    return rc;
}