source: svn/newcon3bcm2_21bu/BSEAV/api/src/nexus/bsettop_cablecard.c @ 22

/***************************************************************************
 *     Copyright (c) 2002-2009, Broadcom Corporation
 *     All Rights Reserved
 *     Confidential Property of Broadcom Corporation
 *
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Workfile: bsettop_cablecard.c $
 * $brcm_Revision: 7 $
 * $brcm_Date: 1/16/09 10:19a $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log: /BSEAV/api/src/nexus/bsettop_cablecard.c $
 * 
 * 7   1/16/09 10:19a haisongw
 * PR51117: Transport stream routing for MCard Interface incorrect
 *
 * 6   1/15/09 3:47p haisongw
 * PR51129: Remove SPOD support
 *
 * 5   1/14/09 3:47p anilmm
 * PR51117:  Incorrect transport stream routing for MCard interface
 *
 * 4   10/14/08 10:58p anilmm
 * PR44830:  Adjust naming convention
 *
 * 3   9/23/08 9:16a jgarrett
 * PR 46513: Merging 97459 support to mainline
 *
 * PR44830/2   7/28/08 7:19p anilmm
 * PR44830: Remove unnecessary handle passed into GetDefaultSettings
 *
 * PR44830/1   7/15/08 8:16p anilmm
 * PR44830: add full cablecard support, fill in stubs
 *
 * 2   3/25/08 10:13a jgarrett
 * PR 40857: Adding stubs for thunk layer
 *
 * 1   10/15/07 2:35p erickson
 * PR36068: initial
 *
 * 2   1/3/07 11:30a vsilyaev
 * PR26393: 7401C0/C1 SPOD XPT interface support
 *
 * PROD_TRINITY_REFSW_Devel/4   1/2/07 5:35p haisongw
 * PR26393: 7401C0/C1 SPOD XPT interface support
 *
 * PROD_TRINITY_REFSW_Devel/3   12/29/06 4:05p haisongw
 * PR26393: 7401C0/C1 SPOD XPT interface support
 *
 * PROD_TRINITY_REFSW_Devel/2   12/27/06 4:48p haisongw
 * PR26258: add cablecard support in Settop API kernel mode
 *
 * PROD_TRINITY_REFSW_Devel/1   12/19/06 3:27p haisongw
 * PR26258: add cablecard support in Settop API kernel mode
 *
 ****************************************************************************/
#include "bsettop_impl.h"
#include "bsettop_cablecard.h"
#include "nexus_mpod.h"

BDBG_MODULE(cablecard);


#define B_MAX_CABLECARDS        1
#define MAX_CABLECARD_ROUTE     6

BDBG_OBJECT_ID(bcablecard);

#if defined(MPOD_SUPPORT)

extern bband_t b_get_inband(btuner_t tuner);

struct bcablecard {
    BDBG_OBJECT(bcablecard)
    bcablecard_settings settings;
        NEXUS_MpodHandle mpod;
        NEXUS_MpodInputHandle mpod_input[MAX_CABLECARD_ROUTE];
};


static void b_reset_mpod_route(NEXUS_MpodHandle mpod)
{
        NEXUS_MpodInputSettings settings;
        unsigned pr_band;
        NEXUS_MpodInputHandle mpod_input;

        NEXUS_MpodInput_GetDefaultSettings(&settings);
        settings.bandType = NEXUS_MpodBandType_eParserBand;
        settings.allPass = false;

        for ( pr_band = 0; pr_band < MAX_CABLECARD_ROUTE; pr_band++)
        {
                settings.band.parserBand = (NEXUS_ParserBand)pr_band;
                mpod_input = NEXUS_MpodInput_Open(mpod, &settings);
                NEXUS_MpodInput_Close(mpod_input);
        }
}

bcablecard_t bcablecard_open(
        bobject_t cablecard_id /* cablecard object id */
        )
{
    bcablecard_t cablecard;
    int index;
    NEXUS_MpodOpenSettings setting;


    BDBG_MSG(("bcablecard_open: %d", B_ID_GET_INDEX(cablecard_id)));

    index = B_ID_GET_INDEX(cablecard_id);
    if (index>=B_MAX_CABLECARDS) {
        BSETTOP_ERROR(berr_invalid_parameter);
        goto error;
    }

    cablecard = BKNI_Malloc(sizeof(struct bcablecard));
    BKNI_Memset(cablecard, 0, sizeof(struct bcablecard));
    BDBG_OBJECT_SET(cablecard, bcablecard);

        if (cablecard == NULL) goto error;

    NEXUS_Mpod_GetDefaultOpenSettings(&setting);
    setting.mpodMode = NEXUS_MpodMode_eMpod;
    setting.bandType = NEXUS_MpodBandType_eParserBand;

        /*TODO:: get platform specific setting from platform layer
          harcoded for 7405 here for the time being*/
        setting.byteSync = 1;
        setting.clockDelay = 1;
        setting.invertClock = 0;

    cablecard->mpod = NEXUS_Mpod_Open(index, &setting);
        if ( cablecard->mpod == NULL)
        {
                BKNI_Free(cablecard);
                goto error;
        }

        b_reset_mpod_route(cablecard->mpod );

    return cablecard;
error:
    return NULL;
}


/*
Summary:
        Close a CableCARD resource.
Description:
        It de-initializes transport interface for cablecard.
*/
void bcablecard_close(
        bcablecard_t cablecard /* handle returned by bcablecard_open */
        )
{
        int i;

        if (NULL != cablecard)
        {
                for (i=0; i<MAX_CABLECARD_ROUTE; i++)
                {
                        if ( NULL != cablecard->mpod_input[i])
                                NEXUS_MpodInput_Close(cablecard->mpod_input[i]);
                }
                NEXUS_Mpod_Close(cablecard->mpod);
                BDBG_OBJECT_UNSET(cablecard, bcablecard);
                BKNI_Free(cablecard);
        }
}


/**
Summary:
Get current CableCARD settings
**/
void bcablecard_get(
        bcablecard_t cablecard,
        bcablecard_settings *settings /* [out] */
        )
{
    if ( NULL != cablecard)
        {
        cablecard->settings.ctrl = bcablecard_physical_control_none;
        *settings = cablecard->settings;
    }
}

/**
Summary:
Set new CableCARD settings
**/
bresult bcablecard_set(
        bcablecard_t cablecard,
        const bcablecard_settings *settings
        )
{
    if ( NULL != cablecard)
        {
            cablecard->settings = *settings;
#if 0
                /*TODO:: add OOB pin tristate control here*/
    switch (cablecard->settings.ctrl) {
        case bcablecard_physical_control_disable_OOB_pins:
        case bcablecard_physical_control_enable_OOB_pins:
            {
                        BRPC_Handle rpc_handle = b_root.tuner.rpc_handle;
                        BERR_Code retVal;
                        BERR_Code retCode = BERR_SUCCESS;
                BRPC_Param_POD_CardApplyPower Param;
                Param.devId = BRPC_DevId_3255_POD;
                                if (cablecard->settings.ctrl == bcablecard_physical_control_disable_OOB_pins)
                    Param.powerMode = DISABLE_POD_OUTPINS;
                                else
                                        Param.powerMode = ENABLE_POD_OUTPINS;
                CHK_RETCODE( retCode, BRPC_CallProc(rpc_handle, BRPC_ProcId_POD_CardApplyPower,
                    (const uint32_t *)&Param, sizeInLong(Param), NULL, 0, &retVal));
                CHK_RETCODE( retCode, retVal );
            }
            break;
        case bcablecard_physical_control_init:
        case bcablecard_physical_control_cardout:
        case bcablecard_physical_control_shutdown:
        case bcablecard_physical_control_applypower:
        case bcablecard_physical_control_applypower_3V:
        case bcablecard_physical_control_applypower_5V:
        case bcablecard_physical_control_resetdone:
                        BDBG_ERR((" unsupported CableCARD Rmagnum %d", cablecard->settings.ctrl));
            break;
        default:
                        break;
    }
#endif
                return b_ok;
        }
        else
        {
                return berr_invalid_parameter;
        }
}

/*
Summary:
   Enable routing tuner's transport output to CableCARD.
Description:
*/
bresult bcablecard_route_add_tuner(
   bcablecard_t cablecard,
   btuner_t tuner /* which btuner's output to be routed to CableCARD */
   )
{

        NEXUS_MpodInputSettings settings;
        unsigned pr_band;

    if (cablecard == NULL || tuner == NULL) return berr_invalid_parameter;

        NEXUS_MpodInput_GetDefaultSettings(&settings);
        settings.bandType = NEXUS_MpodBandType_eParserBand;
        settings.allPass = false;

        pr_band = b_get_parser_band(b_get_inband(tuner));
        settings.band.parserBand = (NEXUS_ParserBand)pr_band;

        if (pr_band >= B_MAX_PARSERS)
        {
            BDBG_WRN((" haven't allocate parseband yet"));
            return b_ok;
        }

        if ( NULL == cablecard->mpod_input[pr_band])
        {
                cablecard->mpod_input[pr_band] = NEXUS_MpodInput_Open(cablecard->mpod, &settings);
                if (cablecard->mpod_input[pr_band] == NULL) return berr_not_available;
        }
        else
        {
                BDBG_WRN((" tuner has already been routed to MPOD"));
        }

    return b_ok;
}

/*
Summary:
   Disable routing tuner's transport output to CableCARD.
Description:
*/
bresult bcablecard_route_remove_tuner(
   bcablecard_t cablecard,
   btuner_t tuner /* which btuner's output NOT to be routed to cablecard */
   )
{
        unsigned pr_band;

    if (cablecard == NULL || tuner == NULL) return berr_invalid_parameter;
        pr_band = b_get_parser_band(b_get_inband(tuner));
        if (pr_band >= B_MAX_PARSERS)
        {
            BDBG_WRN((" haven't allocate parseband yet"));
            return b_ok;
        }

        if ( NULL != cablecard->mpod_input[pr_band])
        {
                NEXUS_MpodInput_Close(cablecard->mpod_input[pr_band]);
                cablecard->mpod_input[pr_band] = NULL;
        }
        else
        {
                BDBG_MSG((" tuner has already been disconnected from MPOD"));
        }
    return b_ok;
}

/*
Summary:
   get settings for the transport route input from tuner to CableCARD
Description:
*/
bresult bcablecard_route_get(
        bcablecard_t cablecard,
        btuner_t tuner, /* tuner's output routed to POD */
        bcablecard_route_settings *settings /*CableCARD route settings*/
        )
{
    unsigned int pr_band;

    if (cablecard == NULL || tuner == NULL) return berr_invalid_parameter;
    pr_band = b_get_parser_band(b_get_inband(tuner));
    settings->band = b_get_inband(tuner);
    settings->ltsid = (pr_band&0x1f);
        return b_ok;
}

#else

bcablecard_t
bcablecard_open(bobject_t cablecard_id)
{
    BSTD_UNUSED(cablecard_id);
    return NULL;
}

void
bcablecard_close(bcablecard_t cablecard)
{
    BSTD_UNUSED(cablecard);
}


void bcablecard_get(bcablecard_t cablecard, bcablecard_settings *settings)
{
    BSTD_UNUSED(cablecard);
    BSTD_UNUSED(settings);
}


bresult bcablecard_set(bcablecard_t cablecard, const bcablecard_settings *settings)
{
    BSTD_UNUSED(cablecard);
    BSTD_UNUSED(settings);
    return berr_not_supported;
}

bresult bcablecard_route_add_tuner(bcablecard_t cablecard,btuner_t tuner)
{
    BSTD_UNUSED(tuner);
    BSTD_UNUSED(cablecard);
    return berr_not_supported;
}

bresult bcablecard_route_remove_tuner(bcablecard_t cablecard,btuner_t tuner)
{
    BSTD_UNUSED(tuner);
    BSTD_UNUSED(cablecard);
    return berr_not_supported;
}
bresult bcablecard_route_get(bcablecard_t cablecard,btuner_t tuner, bcablecard_route_settings *settings)
{
    BSTD_UNUSED(tuner);
    BSTD_UNUSED(cablecard);
    BSTD_UNUSED(settings);
    return berr_not_supported;
}

#endif