source: svn/trunk/newcon3bcm2_21bu/dta/src/nexus/bsettop_tuner.c @ 2

/***************************************************************************
 *     Copyright (c) 2012, 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:  $
 * $brcm_Revision:  $
 * $brcm_Date: $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log:  $
 *
 ***************************************************************************/

#include "nexus_platform.h"
#include "nexus_frontend.h"
#include "nexus_parser_band.h"

#include "bstd.h"
#include "bkni.h"

#include "bapp_freq_table.h"
#include "bsettop_tuner.h"

#define TUNE_TIMEOUT_MS         200
#define SCAN_TIMEOUT_MS         500

BDBG_MODULE(btuner);

struct btuner
{
        NEXUS_FrontendHandle frontend;
        NEXUS_ParserBand parserBand;
        unsigned int freq_hz;
        bapp_freq_table_type_t fe_type;
        BKNI_EventHandle lockEvent;
        uint32_t timeout;
};

struct btuner s_tuner;

static void bapp_tuner_lock_callback(void *context, int param)
{
        btuner_t tuner = (btuner_t)context;

        BSTD_UNUSED(param);
        BKNI_SetEvent(tuner->lockEvent);
}

#if 0
/*
 * Summary:
 *      Acquisition processing thread
 */
static void ds_task(void *arg)
{
        btuner_t p_tune = (btuner_t)arg;
        BDBG_ASSERT(p_tune);
        BDBG_MSG(("ds_task"));
        
        while (1)
        {
                if (0 == p_tune->freq_hz) {
                        /* if no frequency is given, skip it */
                        bos_sleep(500);
                        continue;
                }
        }       
}
#endif

btuner_t btuner_open(bobject_t tuner_id)
{
        NEXUS_PlatformConfiguration platformConfig;
        NEXUS_FrontendCapabilities capabilities;
        NEXUS_FrontendHandle frontend;

        NEXUS_ParserBandSettings parserBandSettings;
        NEXUS_FrontendUserParameters userParams;
        
        bool found_frontend = false;
        int i;

        BSTD_UNUSED(tuner_id);
        BKNI_Memset(&s_tuner, 0, sizeof(struct btuner));
        s_tuner.timeout = TUNE_TIMEOUT_MS;

        BKNI_CreateEvent(&s_tuner.lockEvent);
        NEXUS_Platform_GetConfiguration(&platformConfig);
        for (i=0; i<NEXUS_MAX_FRONTENDS; i++) {
                frontend = platformConfig.frontend[i];

                if (frontend) {
                        NEXUS_Frontend_GetCapabilities(frontend, &capabilities);
#if 0                   
                        if (capabilities.vsb && (fe_type == eFREQ_TABLE_NTIA_VSB))
                        { /* VSB */
                                found_frontend = true;
                                break;          
                        }
                        else if (capabilities.qam) {
                                found_frontend = true;
                                break;
                        }
#endif
                        if (capabilities.qam) {
                                found_frontend = true;
                                break;
                        }
                }
        }

        if (!found_frontend) 
                return NULL;

//      s_tuner.fe_type = fe_type;
        s_tuner.frontend = frontend;
        s_tuner.parserBand = NEXUS_ParserBand_e0;

        NEXUS_Frontend_GetUserParameters(s_tuner.frontend, &userParams);

        NEXUS_ParserBand_GetSettings(s_tuner.parserBand, &parserBandSettings);
        parserBandSettings.sourceType = NEXUS_ParserBandSourceType_eInputBand;
        parserBandSettings.sourceTypeSettings.inputBand = userParams.param1;
        parserBandSettings.transportType = NEXUS_TransportType_eTs;
        parserBandSettings.maxDataRate = 42*1024*1024;
        NEXUS_ParserBand_SetSettings(s_tuner.parserBand, &parserBandSettings);

        return &s_tuner;
}       

int btuner_tune(btuner_t tuner, unsigned int freq, btuner_params *params)
{
        NEXUS_FrontendQamSettings qamSettings;
        NEXUS_FrontendQamStatus qamStatus;
        bool locked = false;

        NEXUS_Frontend_GetDefaultQamSettings(&qamSettings);
        qamSettings.frequency = freq;
        qamSettings.mode = NEXUS_FrontendQamMode_e256; /*params->qamMode;*/
        qamSettings.annex = (params->fecMode==eFEC_ANNEX_B)?NEXUS_FrontendQamAnnex_eB:NEXUS_FrontendQamAnnex_eA;
        qamSettings.lockCallback.callback = bapp_tuner_lock_callback;
        qamSettings.lockCallback.context = tuner;
        if (NEXUS_Frontend_TuneQam(tuner->frontend, &qamSettings) == BERR_SUCCESS) {
                BKNI_WaitForEvent(tuner->lockEvent, tuner->timeout);
                NEXUS_Frontend_GetQamStatus(tuner->frontend, &qamStatus);
                locked = qamStatus.receiverLock;
        }
        
        if (locked) return 0;
        else return -1; 
}

void btuner_params_init(btuner_params *ds, btuner_t tuner)
{
        BSTD_UNUSED(tuner);
        BKNI_Memset(ds, 0, sizeof(btuner_params));
}

bresult btuner_get_status(btuner_t tuner, btuner_status *status)
{
        NEXUS_FrontendQamStatus qamStatus;

        BDBG_ASSERT(tuner);
        BDBG_ASSERT(status);

        BKNI_Memset(status, 0, sizeof(btuner_status));
        NEXUS_Frontend_GetQamStatus(tuner->frontend, &qamStatus);
        status->freq = qamStatus.settings.frequency;
        status->snr = qamStatus.snrEstimate;
        status->lock = qamStatus.receiverLock;
        status->mode = (btuner_qam_mode)qamStatus.settings.mode;
        status->fecMode = (btuner_fec_mode)qamStatus.settings.annex;

        status->goodRsBlockCount = qamStatus.goodRsBlockCount;
        status->berRawCount = qamStatus.berRawCount;

        status->carrierFreqOffset = qamStatus.carrierFreqOffset;
        status->carrierPhaseOffset = qamStatus.carrierPhaseOffset;
        
        status->rxSymbolRate = qamStatus.symbolRate;
        status->equalizerGain = qamStatus.equalizerGain;
        status->postRsBER = qamStatus.postRsBer;
        status->power = qamStatus.dsChannelPower;
        status->isSpectrumInverted = qamStatus.spectrumInverted;
/*
        status->agcIntLevel = 
        status->agcExtLevel =   
        status->elapsedTimeSec = 
*/
        return b_ok;
}

bresult btuner_get_softdecisions(
        btuner_t tuner,                                 /* tuner handle */
        btuner_softdecision_t *pdes,    /* [out] array of soft decisions */
        size_t length                                   /* number of soft decisions to get */
        )
{
        /* NEXUS_FrontendSoftDecision and btuner_softdecision_t should be match */
        NEXUS_Frontend_GetSoftDecisions(tuner->frontend, (NEXUS_FrontendSoftDecision *)pdes, length);
        return b_ok;
}

bresult btuner_reset_status(btuner_t tuner)
{
        NEXUS_Frontend_ResetStatus(tuner->frontend);
        return b_ok;
}