source: svn/newcon3bcm2_21bu/nexus/modules/transport/7552/src/nexus_tsmf.c

/***************************************************************************
 *     (c)2003-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_tsmf.c $
 * $brcm_Revision: 5 $
 * $brcm_Date: 11/2/11 11:57a $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log: /nexus/modules/transport/7425/src/nexus_tsmf.c $
 * 
 * 5   11/2/11 11:57a jtna
 * SW7231-391: fix compiler warning
 * 
 * 4   10/31/11 7:49p bandrews
 * SW7231-391: merge to main
 * 
 * SW7420-2078/1   10/25/11 5:22p bandrews
 * SW7231-391: update parser band and timebase implementations to use
 *  handles everywhere, even for legacy enum usage
 * 
 * 3   10/14/11 2:53p jtna
 * SW7425-1189: added NEXUS_TsmfSettings.frontendTsmfIndex. allow change
 *  between auto and semi-auto mode without enable/disable.
 * 
 * 2   10/5/11 1:32p jtna
 * SW7425-1189: fix non-7425 platforms
 * 
 * 1   10/5/11 12:27p jtna
 * SW7425-1189: add transport and frontend TSMF support
 * 
 ***************************************************************************/
#include "nexus_transport_module.h"
#include "nexus_playpump_impl.h"
#if NEXUS_HAS_TSMF
#include "bxpt_tsmf.h"
#endif

BDBG_MODULE(nexus_tsmf);

BDBG_OBJECT_ID(NEXUS_Tsmf);

#if NEXUS_HAS_TSMF
struct NEXUS_Tsmf
{
    BDBG_OBJECT(NEXUS_Tsmf)
    unsigned index;
    NEXUS_TsmfOpenSettings openSettings;
    NEXUS_TsmfSettings settings;
};

void NEXUS_Tsmf_GetDefaultOpenSettings(NEXUS_TsmfOpenSettings *pOpenSettings)
{
    BKNI_Memset(pOpenSettings, 0, sizeof(*pOpenSettings));
}

NEXUS_TsmfHandle NEXUS_Tsmf_Open(unsigned index, const NEXUS_TsmfOpenSettings* pOpenSettings)
{
    NEXUS_Error rc;
    NEXUS_TsmfHandle handle;
    
    handle = BKNI_Malloc(sizeof(*handle));
    if (!handle) {
        rc = BERR_TRACE(NEXUS_OUT_OF_SYSTEM_MEMORY);
        return NULL;
    }

    BKNI_Memset(handle, 0, sizeof(*handle));
    BDBG_OBJECT_SET(handle, NEXUS_Tsmf);

    handle->index = index;
    handle->openSettings = *pOpenSettings;
    
    return handle;
}

void NEXUS_Tsmf_Close(NEXUS_TsmfHandle handle)
{
    BDBG_OBJECT_ASSERT(handle, NEXUS_Tsmf);
    BDBG_OBJECT_DESTROY(handle, NEXUS_Tsmf);
    BKNI_Free(handle);
}

void NEXUS_Tsmf_GetSettings(NEXUS_TsmfHandle handle, NEXUS_TsmfSettings *pSettings)
{
    NEXUS_Error rc;
    unsigned tsmfIndex = handle->index;
    
    BDBG_OBJECT_ASSERT(handle, NEXUS_Tsmf);
    BDBG_ASSERT(NULL != pSettings);   
    
    rc = BXPT_TSMF_GetFldVerifyConfig(pTransport->xpt, tsmfIndex, (BXPT_TSMFFldVerifyConfig *)(&(handle->settings.fieldVerifyConfig)));
    if (rc) {rc = BERR_TRACE(rc);} /* keep going */
    *pSettings = handle->settings;
}

NEXUS_Error NEXUS_Tsmf_SetSettings(NEXUS_TsmfHandle handle, const NEXUS_TsmfSettings *pSettings)
{
    NEXUS_Error rc;
    unsigned tsmfIndex = handle->index;

    BDBG_OBJECT_ASSERT(handle, NEXUS_Tsmf);
    BDBG_ASSERT(pSettings);

    BDBG_CASSERT(sizeof(NEXUS_TsmfFieldVerifyConfig) == sizeof(BXPT_TSMFFldVerifyConfig));
    BDBG_CASSERT(NEXUS_TsmfVersionChangeMode_eFrameChangeVer == (NEXUS_TsmfVersionChangeMode)BXPT_TSMFVersionChgMode_eFrameChgVer);

    rc = BXPT_TSMF_SetFldVerifyConfig(pTransport->xpt, tsmfIndex, (const BXPT_TSMFFldVerifyConfig *)&(pSettings->fieldVerifyConfig));
    if (rc) {rc = BERR_TRACE(rc);} /* keep going */

    if ((pSettings->enabled!=handle->settings.enabled) || (pSettings->semiAutomaticMode!=handle->settings.semiAutomaticMode)) {
        NEXUS_TsmfOpenSettings *pOpenSettings = &handle->openSettings;
        
        if (pSettings->enabled) {
            BXPT_TSMF_InputSel inputSelect;

            /* convert to XPT enum */
            if (pOpenSettings->tsmfSource.playpump) {
                inputSelect = BXPT_TSMF_InputSel_ePB0 + pOpenSettings->tsmfSource.playpump->index;
            }
            else if (pOpenSettings->tsmfSource.remux) {
                if (pOpenSettings->tsmfSource.remux->index > 0) {
                    return BERR_TRACE(NEXUS_NOT_SUPPORTED); /* if HW supports, must extend enum */
                }

                inputSelect = BXPT_TSMF_InputSel_eRMX;
            }
            else {
                NEXUS_ParserBandHandle handle = NULL;

                handle = NEXUS_ParserBand_Resolve_priv(pOpenSettings->tsmfSource.parserBand);
                if (handle)
                {
                    unsigned parserBand = handle->hwIndex;

                    const NEXUS_ParserBandSettings *pParserBandSettings = &pTransport->parserBand[parserBand].settings;
                    /* look up the input band connected to this parser band */
                    if (pParserBandSettings->sourceType != NEXUS_ParserBandSourceType_eInputBand) {
                        BDBG_ERR(("You must connect the parser band to the input band before calling NEXUS_Tsmf_SetSettings"));
                        return BERR_TRACE(NEXUS_INVALID_PARAMETER);
                    }
                    inputSelect = BXPT_TSMF_InputSel_eIB0 + (pParserBandSettings->sourceTypeSettings.inputBand - NEXUS_InputBand_e0);

                    /* specify which TSMF to enable for this parser */
                    rc = BXPT_TSMF_SetParserConfig(pTransport->xpt, parserBand, tsmfIndex, true);
                    if (rc) return BERR_TRACE(rc);
                }
                else {
                    return BERR_TRACE(NEXUS_UNKNOWN);
                }
            }

            /* specify the input source (and other params) to the TSMF */
            if (pSettings->semiAutomaticMode) {
                rc = BXPT_TSMF_EnableSemiAutoMode(pTransport->xpt, inputSelect, tsmfIndex, pSettings->slotMapLo, pSettings->slotMapHi, pSettings->relativeTsNum);
                if (rc) return BERR_TRACE(rc);
            }
            else {
                rc = BXPT_TSMF_EnableAutoMode(pTransport->xpt, inputSelect, tsmfIndex, pSettings->relativeTsNum);
                if (rc) return BERR_TRACE(rc);
            }
        }
        
        else { /* (pSettings->enabled==false) */          
            rc = BXPT_TSMF_DisableTsmf(pTransport->xpt, tsmfIndex);
            if (rc) return BERR_TRACE(rc);

            if (!pOpenSettings->tsmfSource.playpump && !pOpenSettings->tsmfSource.remux) {
                NEXUS_ParserBandHandle handle = NULL;

                handle = NEXUS_ParserBand_Resolve_priv(pOpenSettings->tsmfSource.parserBand);
                if (handle)
                {
                    unsigned parserBand = handle->hwIndex;

                    rc = BXPT_TSMF_SetParserConfig(pTransport->xpt, parserBand, tsmfIndex, false);
                    if (rc) return BERR_TRACE(rc);
                }
            }
        }
    }

    handle->settings = *pSettings;

    return rc;
}
#else /* NEXUS_HAS_TSMF */

void NEXUS_Tsmf_GetDefaultOpenSettings(NEXUS_TsmfOpenSettings *pOpenSettings)
{
    BSTD_UNUSED(pOpenSettings);
}

NEXUS_TsmfHandle NEXUS_Tsmf_Open(unsigned index, const NEXUS_TsmfOpenSettings* pOpenSettings)
{
    BSTD_UNUSED(index);
    BSTD_UNUSED(pOpenSettings);
    return NULL;
}

void NEXUS_Tsmf_Close(NEXUS_TsmfHandle handle)
{
    BSTD_UNUSED(handle);
}

void NEXUS_Tsmf_GetSettings(NEXUS_TsmfHandle handle, NEXUS_TsmfSettings *pSettings)
{
    BSTD_UNUSED(handle);
    BSTD_UNUSED(pSettings);
}

NEXUS_Error NEXUS_Tsmf_SetSettings(NEXUS_TsmfHandle handle, const NEXUS_TsmfSettings *pSettings)
{
    BSTD_UNUSED(handle);
    BSTD_UNUSED(pSettings);
    return 0;
}
#endif