/***************************************************************************
 *     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;
}