Context Navigation

close Warning: Can't use blame annotator:
No changeset 2 in the repository

bsettop_tuner.c

Last change on this file was 76, checked in by megakiss, 10 years ago
1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
Property svn:executable set to ``*
File size: 39.0 KB

Rev	Line
	1	/***************************************************************************
	2	* Copyright (c) 2003-2010, Broadcom Corporation
	3	* All Rights Reserved
	4	* Confidential Property of Broadcom Corporation
	5	*
	6	* THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
	7	* AGREEMENT BETWEEN THE USER AND BROADCOM. YOU HAVE NO RIGHT TO USE OR
	8	* EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
	9	*
	10	* $brcm_Workfile: bsettop_tuner.c $
	11	* $brcm_Revision: 41 $
	12	* $brcm_Date: 6/10/10 6:29p $
	13	*
	14	* Module Description:
	15	*
	16	* Revision History:
	17	*
	18	* $brcm_Log: /BSEAV/api/src/nexus/bsettop_tuner.c $
	19	*
	20	* 41 6/10/10 6:29p mward
	21	* SW7125-35: Use the spectrum settings in btuner_tune_qam().
	22	*
	23	* 40 6/7/10 9:53a erickson
	24	* SW7550-236: back out btuner_tune_ofdm #if 0. this needs to be fixed in
	25	* lower levels.
	26	*
	27	* 39 6/4/10 11:16a erickson
	28	* SW7550-236: merge
	29	*
	30	* Tuner_Hack/SW7550-236/2 5/21/10 3:02p pinglong
	31	* SW7550-236: move the postRsBer calculation to info_status.cpp
	32	*
	33	* Tuner_Hack/SW7550-236/1 4/21/10 9:49p pinglong
	34	* SW7550-236: It's not right for some item for status page of brutus.
	35	*
	36	* Tuner_Hack/3 3/18/10 3:18p farshidf
	37	* SW7550-38: update the SNR settings
	38	*
	39	* Tuner_Hack/2 2/5/10 2:24p VISHK
	40	* CR7550-115 :7550 QAM/DVB-C support in Settop and Brutus.
	41	*
	42	* Tuner_Hack/1 12/22/09 2:48p farshidf
	43	* SW7550-38: Hack the code so it does not send a new acquire if not
	44	* locked
	45	*
	46	* 38 1/4/10 6:59p mward
	47	* SW7125-156: Corrected QAM SNR estimate calculation.
	48	*
	49	* 37 12/11/09 4:57p mphillip
	50	* SW7550-112: Merge 7550 changes to main branch
	51	*
	52	* Refsw_7550/1 11/23/09 2:41p chengli
	53	* SW7550-64: fill field mode in NEXUS_FrontendOfdmSettings
	54	*
	55	* 36 12/9/09 12:04p gmohile
	56	* SW7408-1 : Add 7408 support
	57	*
	58	* 35 7/8/09 6:49a erickson
	59	* PR56607: call NEXUS_StopCallbacks before NEXUS_Frontend_Untune. This
	60	* ensures that no callbacks will come from Frontend after btuner has
	61	* been freed. call NEXUS_StartCallbacks before every
	62	* NEXUS_Frontend_TuneXxx function as well.
	63	*
	64	* 34 6/29/09 6:39p vishk
	65	* PR 56070: BCM31xx: Need to read dsChannelPower
	66	*
	67	* 33 5/1/09 9:53a katrep
	68	* PR43490: Fixed crash at brutus quit,during bstream_close for 656/i2S
	69	* tuning
	70	*
	71	* 32 4/16/09 11:28a vishk
	72	* PR 46431: Add support for BCM3117, BCM3114, and BCM3112
	73	*
	74	* 31 3/5/09 11:51a prasadv
	75	* PR52808: OOB SNR should be in unit of 1/100 dB
	76	*
	77	* 30 3/5/09 10:44a prasadv
	78	* PR52808: correct SNR value for display
	79	*
	80	* 29 3/3/09 1:04p vishk
	81	* PR 46431: ADS PI, Add support for BCM3117, BCM3114, and BCM3112. Making
	82	* enums consistent.
	83	*
	84	* 28 2/11/09 10:30a anilmm
	85	* PR47842: Correct BER calculation for qam
	86	*
	87	* 27 2/5/09 6:03p katrep
	88	* PR43490: fixed kernel crash during 656/i2s input during get soft
	89	* decisions api call
	90	*
	91	* 26 1/8/09 11:27a katrep
	92	* PR48985: Fixed compiler warning
	93	*
	94	* 25 12/18/08 9:29p agin
	95	* PR49983: Incorrect channel status reported for power, BER, SNR for
	96	* 97335 AST.
	97	*
	98	* 24 11/15/08 7:10a agin
	99	* PR48985: Support LDPC and Turbo at the same time.
	100	*
	101	* 23 9/23/08 9:16a jgarrett
	102	* PR 46513: Merging 97459 support to mainline
	103	*
	104	* 22 9/8/08 7:10p katrep
	105	* PR36068: Increase OFDM lock timeout value
	106	*
	107	* 21 8/5/08 12:05p vishk
	108	* PR 45270: Asset/Seg-Fault in bsettop_tuner.c:340 when input source
	109	* removed post btuner_close()
	110	*
	111	* 20 7/30/08 8:15p shyam
	112	* PR43426 : Fix compile warnings
	113	*
	114	* 19 7/17/08 4:49p shyam
	115	* PR43426 : Add 7043 656 Encode support
	116	*
	117	* PR44830/2 7/15/08 6:16p anilmm
	118	* PR44830: Merge from main branch
	119	*
	120	* PR44830/1 7/15/08 6:10p anilmm
	121	* PR44830: Add settop api to nexus support for BCM97459
	122	*
	123	* 18 7/9/08 4:10p katrep
	124	* PR43490: Add support 656/i2s tuning using analog tune api.
	125	*
	126	* 17 7/1/08 10:59a agin
	127	* PR44448: Fix SNR reporting problem.
	128	*
	129	* 16 5/22/08 3:43p jgarrett
	130	* PR 42054: Fixing 8psk for 450x
	131	*
	132	* 15 5/22/08 9:03a jgarrett
	133	* PR 42945: Converting SNR units
	134	*
	135	* 14 4/24/08 3:34p jrubio
	136	* PR42054: add diseqc code and status check workaround PR42052
	137	*
	138	* 13 4/3/08 5:42p jgarrett
	139	* PR 41312: Setting callback events
	140	*
	141	* 12 4/1/08 9:19a erickson
	142	* PR36068: fix compilation error
	143	*
	144	* 11 3/31/08 7:49p katrep
	145	* PR36068: Fixed the ofdm setting conversion from settop api to nexus
	146	*
	147	* 10 3/25/08 12:50p jgarrett
	148	* PR 40835: Grouping soft decisions for efficiency
	149	*
	150	* 9 3/25/08 10:59a erickson
	151	* PR36068: fix
	152	*
	153	* 8 3/25/08 10:10a erickson
	154	* PR36068: added analog tuner
	155	*
	156	* 7 3/17/08 5:40p katrep
	157	* PR36068:Add ofdm support
	158	*
	159	* 6 3/12/08 5:31p katrep
	160	* PR40489:Do not set if freq for 8VSB. Let the nexus layer set the
	161	* correct values
	162	*
	163	* 5 2/19/08 9:59a jgarrett
	164	* PR 36068: Updating tuner api
	165	*
	166	* 4 2/4/08 10:00a erickson
	167	* PR36068: update
	168	*
	169	* 3 11/27/07 11:15p erickson
	170	* PR36068: add vsb
	171	*
	172	* 2 10/16/07 12:35p erickson
	173	* PR36068: brutus up over settop api/nexus
	174	*
	175	***************************************************************************/
	176	#include "bsettop_impl.h"
	177
	178	#if B_HAS_ANALOG
	179	#include "nexus_composite_input.h"
	180	#include "nexus_component_input.h"
	181	#include "nexus_svideo_input.h"
	182	#endif
	183
	184	#if B_HAS_TRANSCODE
	185	#include "nexus_transcoder_vdec.h"
	186	#endif
	187	#include "nexus_core_utils.h"
	188
	189	BDBG_MODULE(tuner);
	190
	191	BDBG_OBJECT_ID(btuner);
	192
	193	struct btuner {
	194	BDBG_OBJECT(btuner)
	195	#if NEXUS_HAS_FRONTEND
	196	NEXUS_FrontendHandle nTuner;
	197	#endif
	198	bsettop_callback lock_callback;
	199	void *callback_context;
	200	B_EventHandle lockEvent, waitEvent;
	201	b_event_id_t lockEventId;
	202	bband_t band;
	203	struct {
	204	struct bstream stream;
	205	btuner_analog_params params;
	206	} analog;
	207	};
	208
	209	#if NEXUS_HAS_FRONTEND
	210	static void btuner_p_lock_handler(void *context);
	211	#endif
	212
	213	void btuner_p_init(void)
	214	{
	215	/* Register the tuners with the bconfig interface */
	216	bconfig_p_set_tuners();
	217	}
	218
	219	bband_t b_get_inband(btuner_t tuner)
	220	{
	221	if (tuner) return tuner->band;
	222	else return NULL;
	223	}
	224
	225	btuner_t btuner_open(bobject_t tuner_id)
	226	{
	227	#if NEXUS_HAS_FRONTEND
	228	btuner_t tuner;
	229	unsigned index;
	230	NEXUS_PlatformConfiguration platformConfig;
	231	NEXUS_FrontendUserParameters userParams;
	232
	233
	234	BDBG_MSG(("btuner_open: %d", B_ID_GET_INDEX(tuner_id)));
	235
	236	/* The Settop API tuner code depends on the reference platform "GetConfiguration" API for
	237	frontend detection and instance management. See 97400 or related platforms for API and implementation. */
	238	NEXUS_Platform_GetConfiguration(&platformConfig);
	239
	240	index = B_ID_GET_INDEX(tuner_id);
	241
	242	#if B_HAS_EXTERNAL_ANALOG
	243	/* tuner numbber 7 has special meaning,
	244	need to make this dynamic */
	245	if(index==7)
	246	{
	247	tuner = BKNI_Malloc(sizeof(*tuner));
	248	BKNI_Memset(tuner, 0, sizeof(*tuner));
	249	BDBG_OBJECT_SET(tuner, btuner);
	250	return tuner;
	251	}
	252	#endif
	253	#if B_HAS_TRANSCODE
	254	if (index >= NEXUS_MAX_FRONTENDS && index < NEXUS_MAX_FRONTENDS+B_MAX_ENCODES)
	255	{
	256	tuner = BKNI_Malloc(sizeof(*tuner));
	257	BKNI_Memset(tuner, 0, sizeof(*tuner));
	258	BDBG_OBJECT_SET(tuner, btuner);
	259	return tuner;
	260	}
	261	else
	262	#endif
	263
	264	if (index >= NEXUS_MAX_FRONTENDS \|\| !platformConfig.frontend[index]) {
	265	BDBG_ERR(("tuner %d not available", index));
	266	return NULL;
	267	}
	268
	269	tuner = BKNI_Malloc(sizeof(*tuner));
	270	BKNI_Memset(tuner, 0, sizeof(*tuner));
	271	BDBG_OBJECT_SET(tuner, btuner);
	272	tuner->nTuner = platformConfig.frontend[index];
	273	tuner->lockEvent = B_Event_Create(NULL);
	274	if ( NULL == tuner->lockEvent )
	275	{
	276	BSETTOP_ERROR(berr_external_error);
	277	goto error;
	278	}
	279	tuner->waitEvent = B_Event_Create(NULL);
	280	if ( NULL == tuner->waitEvent )
	281	{
	282	BSETTOP_ERROR(berr_external_error);
	283	goto error;
	284	}
	285	tuner->lockEventId = b_event_register(tuner->lockEvent, btuner_p_lock_handler, tuner);
	286	if ( NULL == tuner->lockEventId )
	287	{
	288	BSETTOP_ERROR(berr_external_error);
	289	goto error;
	290	}
	291
	292	NEXUS_Frontend_GetUserParameters(tuner->nTuner, &userParams);
	293	tuner->band = &g_bands[userParams.param1]; /* Platform initializes this to input band, our default mapping is ibN->pbN */
	294
	295	return tuner;
	296
	297	error:
	298	btuner_close(tuner);
	299	#else
	300	BSTD_UNUSED(tuner_id);
	301	#endif
	302
	303	return NULL;
	304	}
	305
	306	void btuner_close(btuner_t tuner)
	307	{
	308	#if NEXUS_HAS_FRONTEND
	309	BDBG_OBJECT_ASSERT(tuner, btuner);
	310
	311	if(tuner->nTuner)
	312	{
	313	NEXUS_StopCallbacks(tuner->nTuner);
	314	NEXUS_Frontend_Untune(tuner->nTuner);
	315	}
	316
	317	if ( NULL != tuner->lockEventId )
	318	{
	319	b_event_unregister(tuner->lockEventId);
	320	}
	321	if ( NULL != tuner->lockEvent )
	322	{
	323	B_Event_Destroy(tuner->lockEvent);
	324	}
	325	if ( NULL != tuner->waitEvent )
	326	{
	327	B_Event_Destroy(tuner->waitEvent);
	328	}
	329
	330	BDBG_OBJECT_UNSET(tuner, btuner);
	331	BKNI_Free(tuner);
	332	#else
	333	BSTD_UNUSED(tuner);
	334	#endif
	335	}
	336
	337	void btuner_qam_us_params_init(btuner_qam_us_params *us_param, btuner_t tuner)
	338	{
	339	BSTD_UNUSED(tuner);
	340	BKNI_Memset(us_param, 0, sizeof(*us_param));
	341	us_param->mode = btuner_qam_us_mode_dvs178;
	342	us_param->symbol_rate = 128000;
	343	us_param->power_level = 0;
	344	}
	345
	346	void btuner_qam_params_init(btuner_qam_params *qam, btuner_t tuner)
	347	{
	348	BSTD_UNUSED(tuner);
	349	BKNI_Memset(qam, 0, sizeof(*qam));
	350	qam->mode = 64;
	351	qam->symbol_rate = 5056941;
	352	qam->annex = btuner_qam_annex_b;
	353	qam->spectrum = btuner_qam_spectral_inversion_auto;
	354	qam->wait_for_lock = true;
	355	qam->auto_acquire = false;
	356	qam->bandwidth = btuner_qam_bandwidth_6Mhz;
	357	qam->enable_power_measurement = true;
	358	}
	359
	360	void
	361	btuner_sds_params_init(btuner_sds_params *sds, btuner_t tuner)
	362	{
	363	#if NEXUS_HAS_FRONTEND
	364	NEXUS_FrontendSatelliteSettings satSettings;
	365	BSTD_UNUSED(tuner);
	366	BKNI_Memset(sds, 0, sizeof(*sds));
	367
	368	NEXUS_Frontend_GetDefaultSatelliteSettings(&satSettings);
	369	sds->mode = btuner_sds_mode_qpsk_dvb;
	370	sds->carrier_offset = satSettings.carrierOffset;
	371	sds->symbol_rate =satSettings.symbolRate;
	372	sds->spinv = satSettings.spectralInversion;
	373	sds->search_range = satSettings.searchRange;
	374	sds->diseqc_polarity = 13;
	375	sds->wait_for_lock = false;
	376	sds->ldpc_pilot = satSettings.ldpcPilot;
	377	sds->ldpc_pilot_pll = satSettings.ldpcPilotPll;
	378	sds->coderate.bits_per_symbol = satSettings.codeRate.bitsPerSymbol;
	379	sds->coderate.denom = satSettings.codeRate.denominator;
	380	sds->coderate.num = satSettings.codeRate.numerator;
	381	sds->diseqc_tone = false;
	382	#else
	383	BSTD_UNUSED(tuner);
	384	BKNI_Memset(sds, 0, sizeof(*sds));
	385	#endif
	386
	387	}
	388
	389	void
	390	btuner_vsb_params_init(btuner_vsb_params *vsb, btuner_t tuner)
	391	{
	392	BSTD_UNUSED(tuner);
	393	BKNI_Memset(vsb, 0, sizeof(*vsb));
	394	vsb->mode = btuner_vsb_mode_vsb8;
	395	vsb->symbol_rate = 5381119;
	396	vsb->wait_for_lock = true;
	397	}
	398
	399	void
	400	btuner_analog_params_init(btuner_analog_params *analog, btuner_t tuner)
	401	{
	402	BSTD_UNUSED(tuner);
	403	BKNI_Memset(analog, 0, sizeof(*analog));
	404	analog->video_format = bvideo_format_ntsc;
	405	analog->audio_rate = 48000;
	406	analog->btsc_mode = boutput_rf_btsc_mode_stereo;
	407	analog->comb_filter = true;
	408	analog->colorspace = btuner_analog_colorspace_yprpb;
	409	}
	410
	411	void btuner_ofdm_params_init( btuner_ofdm_params *ofdm, btuner_t tuner )
	412	{
	413	BSTD_UNUSED(tuner);
	414	BKNI_Memset(ofdm, 0, sizeof(*ofdm));
	415	ofdm->bandwidth = btuner_ofdm_bandwidth_8Mhz;
	416	ofdm->wait_for_lock = true;
	417	}
	418
	419	/* Must be static allocation. Settop API doesn't have btuner_linein_close. */
	420	#define MAX_LINEINPUTS 8
	421	struct btuner_linein g_lineinputs[MAX_LINEINPUTS];
	422
	423	btuner_linein_t btuner_linein_open(bobject_t id)
	424	{
	425	#if B_HAS_ANALOG \|\| B_HAS_TRANSCODE
	426	NEXUS_PlatformConfiguration platformConfig;
	427	unsigned index = B_ID_GET_INDEX(id);
	428	btuner_linein_t linein;
	429
	430	#if B_HAS_TRANSCODE
	431	if (index >= MAX_LINEINPUTS+B_MAX_ENCODES) {
	432	#else
	433	if (index >= MAX_LINEINPUTS) {
	434	#endif
	435	BSETTOP_ERROR(berr_not_supported);
	436	return NULL;
	437	}
	438
	439	linein = &g_lineinputs[index];
	440	BKNI_Memset(linein, 0, sizeof(*linein));
	441
	442	NEXUS_Platform_GetConfiguration(&platformConfig);
	443
	444	switch (index) {
	445	#if B_HAS_ANALOG
	446	case 0: linein->composite = platformConfig.inputs.composite[0]; break;
	447	case 1: linein->composite = platformConfig.inputs.composite[1]; break;
	448	case 2: linein->composite = platformConfig.inputs.composite[2]; break;
	449	case 3: linein->composite = platformConfig.inputs.composite[3]; break;
	450	case 4: linein->svideo = platformConfig.inputs.svideo[0]; break;
	451	case 5: linein->svideo = platformConfig.inputs.svideo[1]; break;
	452	case 6: linein->component = platformConfig.inputs.component[0]; break;
	453	case 7: linein->component = platformConfig.inputs.component[1]; break;
	454	#endif
	455	#if B_HAS_TRANSCODE
	456	case 8 : linein->vdec7043DeviceNo = 0 ; break ;
	457	case 9 : linein->vdec7043DeviceNo = 1 ; break ;
	458	#endif
	459	default:
	460	BSETTOP_ERROR(berr_not_supported); return NULL;
	461	}
	462
	463	return linein;
	464	#else
	465	BSTD_UNUSED(id);
	466	BSETTOP_ERROR(berr_not_supported);
	467	return NULL;
	468	#endif
	469	}
	470
	471	#if NEXUS_HAS_FRONTEND
	472	static void btuner_p_lock_callback(void *context, int param)
	473	{
	474	btuner_t tuner = (btuner_t)context;
	475	BDBG_OBJECT_ASSERT(tuner, btuner);
	476	BSTD_UNUSED(param);
	477	BDBG_MSG((" LOCK CALLBACK"));
	478
	479	/* Reset FEC counters */
	480	NEXUS_Frontend_ResetStatus(tuner->nTuner);
	481
	482	B_Event_Set(tuner->lockEvent);
	483	B_Event_Set(tuner->waitEvent);
	484	}
	485
	486	static void btuner_p_lock_handler(void *context)
	487	{
	488	btuner_t tuner = context;
	489	BDBG_OBJECT_ASSERT(tuner, btuner);
	490	if (tuner->lock_callback) {
	491	b_unlock();
	492	(*tuner->lock_callback)(tuner->callback_context);
	493	b_lock();
	494	}
	495	}
	496	#endif
	497
	498	bband_t btuner_tune_qam(btuner_t tuner, unsigned freq, const btuner_qam_params *params)
	499	{
	500	#if NEXUS_HAS_FRONTEND
	501	NEXUS_FrontendQamSettings settings;
	502	NEXUS_Error rc;
	503
	504	BDBG_OBJECT_ASSERT(tuner, btuner);
	505	BDBG_MSG(("QAM freq %d,symbol rate %d",freq,params->symbol_rate));
	506
	507	b_lock2idle();
	508
	509	NEXUS_Frontend_GetDefaultQamSettings(&settings);
	510	switch(params->annex)
	511	{
	512	case btuner_qam_annex_a:
	513	settings.annex = NEXUS_FrontendQamAnnex_eA;
	514	break;
	515	case btuner_qam_annex_b:
	516	settings.annex = NEXUS_FrontendQamAnnex_eB;
	517	break;
	518	default:
	519	BDBG_WRN(("unsupported annex %d,using annexB",params->annex));
	520	settings.annex = NEXUS_FrontendQamAnnex_eB;
	521	}
	522
	523	switch(params->mode)
	524	{
	525	case btuner_qam_mode_16:
	526	settings.mode = NEXUS_FrontendQamMode_e16;
	527	break;
	528	case btuner_qam_mode_32:
	529	settings.mode = NEXUS_FrontendQamMode_e32;
	530	break;
	531	case btuner_qam_mode_64:
	532	settings.mode = NEXUS_FrontendQamMode_e64;
	533	break;
	534	case btuner_qam_mode_128:
	535	settings.mode = NEXUS_FrontendQamMode_e128;
	536	break;
	537	case btuner_qam_mode_256:
	538	settings.mode = NEXUS_FrontendQamMode_e256;
	539	break;
	540	case btuner_qam_mode_1024:
	541	settings.mode = NEXUS_FrontendQamMode_e1024;
	542	break;
	543	default:
	544	BDBG_ERR(("unsupported QAM %d",params->mode));
	545	}
	546	switch (params->spectrum)
	547	{
	548	case btuner_qam_spectral_inversion_auto:
	549	settings.spectralInversion = NEXUS_FrontendQamSpectralInversion_eNormal;
	550	settings.spectrumMode = NEXUS_FrontendQamSpectrumMode_eAuto;
	551	break;
	552	case btuner_qam_spectral_inversion_noinverted:
	553	settings.spectralInversion = NEXUS_FrontendQamSpectralInversion_eNormal;
	554	settings.spectrumMode = NEXUS_FrontendQamSpectrumMode_eManual;
	555	break;
	556	case btuner_qam_spectral_inversion_inverted:
	557	settings.spectralInversion = NEXUS_FrontendQamSpectralInversion_eInverted;
	558	settings.spectrumMode = NEXUS_FrontendQamSpectrumMode_eManual;
	559	break;
	560	default:
	561	BDBG_ERR(("unsupported QAM spectrum setting %d",params->spectrum));
	562	}
	563	settings.frequency = freq;
	564	settings.symbolRate = params->symbol_rate;
	565	settings.autoAcquire = params->auto_acquire;
	566	settings.bandwidth = params->bandwidth;
	567	settings.enablePowerMeasurement = params->enable_power_measurement;
	568	tuner->lock_callback = params->lock_callback;
	569	tuner->callback_context = params->callback_context;
	570	settings.lockCallback.callback = btuner_p_lock_callback;
	571	settings.lockCallback.context = tuner;
	572
	573	NEXUS_StartCallbacks(tuner->nTuner);
	574	B_Event_Reset(tuner->waitEvent);
	575	rc = NEXUS_Frontend_TuneQam(tuner->nTuner, &settings);
	576	b_idle2lock();
	577	if (rc) {BERR_TRACE(rc);return NULL;}
	578
	579	if (params->wait_for_lock) {
	580	b_unlock();
	581	rc = B_Event_Wait(tuner->waitEvent, 5000);
	582	b_lock();
	583	if (rc) {BERR_TRACE(rc);return NULL;}
	584	}
	585
	586	return tuner->band;
	587	#else
	588	BSTD_UNUSED(tuner);
	589	BSTD_UNUSED(freq);
	590	BSTD_UNUSED(params);
	591	return NULL;
	592	#endif
	593	}
	594
	595	bresult btuner_tune_oob(btuner_t tuner, unsigned freq, const btuner_qam_params *params)
	596	{
	597	#if NEXUS_HAS_FRONTEND
	598	NEXUS_FrontendOutOfBandSettings settings;
	599	NEXUS_Error rc;
	600
	601	BDBG_OBJECT_ASSERT(tuner, btuner);
	602	BDBG_MSG(("OOB freq %d,symbol rate %d",freq,params->symbol_rate));
	603
	604	b_lock2idle();
	605
	606	NEXUS_Frontend_GetDefaultOutOfBandSettings(&settings);
	607	switch(params->annex)
	608	{
	609	case btuner_qam_oob_annex_a:
	610	settings.mode = NEXUS_FrontendOutOfBandMode_eDvs167Qpsk;
	611	break;
	612	case btuner_qam_oob_dvs178:
	613	settings.mode = NEXUS_FrontendOutOfBandMode_eDvs178Qpsk;
	614	break;
	615	case btuner_qam_oob_pod_annex_a:
	616	settings.mode = NEXUS_FrontendOutOfBandMode_ePod_Dvs167Qpsk;
	617	break;
	618	case btuner_qam_oob_pod_dvs178:
	619	settings.mode = NEXUS_FrontendOutOfBandMode_ePod_Dvs178Qpsk;
	620	break;
	621	default:
	622	BDBG_WRN(("unsupported annex %d",params->annex));
	623	return BSETTOP_ERROR(berr_invalid_parameter);
	624	}
	625
	626	switch (params->spectrum) {
	627	case btuner_qam_spectral_inversion_auto:
	628	settings.spectrum = NEXUS_FrontendOutOfBandSpectrum_eAuto;
	629	break;
	630	case btuner_qam_spectral_inversion_inverted:
	631	settings.spectrum = NEXUS_FrontendOutOfBandSpectrum_eInverted;
	632	break;
	633	case btuner_qam_spectral_inversion_noinverted:
	634	settings.spectrum = NEXUS_FrontendOutOfBandSpectrum_eNonInverted;
	635	break;
	636	default:
	637	BDBG_WRN(("unsupported spectrum %d",params->spectrum));
	638	return BSETTOP_ERROR(berr_invalid_parameter);
	639	}
	640	settings.frequency = freq;
	641	settings.symbolRate = params->symbol_rate;
	642
	643	tuner->lock_callback = params->lock_callback;
	644	tuner->callback_context = params->callback_context;
	645	settings.lockCallback.callback = btuner_p_lock_callback;
	646	settings.lockCallback.context = tuner;
	647
	648	NEXUS_StartCallbacks(tuner->nTuner);
	649	B_Event_Reset(tuner->waitEvent);
	650	rc = NEXUS_Frontend_TuneOutOfBand(tuner->nTuner, &settings);
	651	b_idle2lock();
	652	if (rc) {BERR_TRACE(rc);return berr_external_error;}
	653
	654	/* OOB always waits for lock*/
	655	if ( 1 /params->wait_for_lock/)
	656	{
	657	b_unlock();
	658	rc = B_Event_Wait(tuner->waitEvent, 1000);
	659	b_lock();
	660	if (rc) {BERR_TRACE(rc);return berr_not_available;}
	661	}
	662
	663	return b_ok;
	664	#else
	665	BSTD_UNUSED(tuner);
	666	BSTD_UNUSED(freq);
	667	BSTD_UNUSED(params);
	668	return b_ok;
	669	#endif
	670	}
	671
	672	bresult btuner_tune_qam_us(btuner_t tuner, unsigned freq, const btuner_qam_us_params *params)
	673	{
	674	#if NEXUS_HAS_FRONTEND
	675	NEXUS_FrontendUpstreamSettings settings;
	676	NEXUS_Error rc;
	677
	678	BDBG_OBJECT_ASSERT(tuner, btuner);
	679	BDBG_MSG(("OOB Upstream freq %d,symbol rate %d",freq,params->symbol_rate));
	680
	681	b_lock2idle();
	682
	683	NEXUS_Frontend_GetDefaultUpstreamSettings(&settings);
	684
	685
	686	switch (params->mode) {
	687	case btuner_qam_us_mode_annexa:
	688	settings.mode = NEXUS_FrontendUpstreamMode_eAnnexA;
	689	break;
	690	case btuner_qam_us_mode_dvs178:
	691	settings.mode = NEXUS_FrontendUpstreamMode_eDvs178;
	692	break;
	693	case btuner_qam_us_mode_pod_annexa :
	694	settings.mode = NEXUS_FrontendUpstreamMode_ePodAnnexA;
	695	break;
	696	case btuner_qam_us_mode_pod_dvs178:
	697	settings.mode = NEXUS_FrontendUpstreamMode_ePodDvs178;
	698	break;
	699	case btuner_qam_us_mode_docsis:
	700	settings.mode = NEXUS_FrontendUpstreamMode_eDocsis;
	701	break;
	702	default:
	703	return BSETTOP_ERROR(berr_not_supported);
	704	}
	705
	706	settings.frequency = freq;
	707	settings.symbolRate = params->symbol_rate;
	708	settings.powerLevel = params->power_level;
	709
	710	NEXUS_StartCallbacks(tuner->nTuner);
	711	B_Event_Reset(tuner->waitEvent);
	712	rc = NEXUS_Frontend_TuneUpstream(tuner->nTuner, &settings);
	713	b_idle2lock();
	714	if (rc) {BERR_TRACE(rc);return berr_external_error;}
	715
	716	return b_ok;
	717	#else
	718	BSTD_UNUSED(tuner);
	719	BSTD_UNUSED(freq);
	720	BSTD_UNUSED(params);
	721	return b_ok;
	722	#endif
	723	}
	724
	725	#if NEXUS_HAS_FRONTEND
	726	static void btuner_get_diseqc_reply(void *context, int param)
	727	{
	728	uint8_t rcvBuf[3];
	729	size_t replyLen;
	730	NEXUS_FrontendDiseqcMessageStatus status;
	731	btuner_t tuner = (btuner_t)context;
	732
	733	BSTD_UNUSED(param);
	734
	735	NEXUS_Frontend_GetDiseqcReply(tuner->nTuner, &status, &rcvBuf[0], sizeof(rcvBuf), &replyLen);
	736
	737	if (status == NEXUS_FrontendDiseqcMessageStatus_eSuccess)
	738	{
	739	size_t i;
	740	for (i=0; i<replyLen; i++)
	741	{
	742	BDBG_WRN(("%d 0x%02x\n", i, *(rcvBuf+i)));
	743	}
	744	}
	745	else
	746	{
	747	BDBG_ERR(("btuner_get_diseqc_reply, status=%d", status));
	748	}
	749	}
	750	#endif
	751
	752	bband_t btuner_tune_sds(btuner_t tuner, unsigned freq, const btuner_sds_params *params)
	753	{
	754	#if NEXUS_HAS_FRONTEND
	755	NEXUS_FrontendSatelliteSettings satSettings;
	756	NEXUS_FrontendDiseqcSettings diseqcSettings;
	757	NEXUS_Error rc;
	758	int i=1;
	759	NEXUS_FrontendSatelliteStatus satStatus;
	760
	761	BDBG_OBJECT_ASSERT(tuner, btuner);
	762
	763	b_lock2idle();
	764
	765	BKNI_Memset(&diseqcSettings,0,sizeof(NEXUS_FrontendDiseqcSettings));
	766	NEXUS_Frontend_GetDiseqcSettings(tuner->nTuner, &diseqcSettings);
	767	diseqcSettings.toneEnabled = params->diseqc_tone;
	768	diseqcSettings.voltage = (params->diseqc_polarity == btuner_sds_diseqc_polarity_13v)?NEXUS_FrontendDiseqcVoltage_e13v:NEXUS_FrontendDiseqcVoltage_e18v;
	769	NEXUS_Frontend_SetDiseqcSettings(tuner->nTuner, &diseqcSettings);
	770
	771	#if 0
	772	/* Example of sending and receiving disecq message */
	773	{
	774	const uint8_t sendBuf[3] = {0xe2, 0x00, 0x04};
	775	NEXUS_CallbackDesc send_disecq_msg_cb_desc;
	776	send_disecq_msg_cb_desc.callback = btuner_get_diseqc_reply;
	777	send_disecq_msg_cb_desc.context = tuner;
	778	NEXUS_Frontend_SendDiseqcMessage(tuner->nTuner, &sendBuf[0], 3, &send_disecq_msg_cb_desc);
	779	}
	780	#else
	781	BSTD_UNUSED(btuner_get_diseqc_reply);
	782	#endif
	783
	784	NEXUS_Frontend_GetDefaultSatelliteSettings(&satSettings);
	785	satSettings.carrierOffset = params->carrier_offset;
	786	satSettings.codeRate.bitsPerSymbol = params->coderate.bits_per_symbol;
	787	satSettings.codeRate.denominator = params->coderate.denom;
	788	satSettings.codeRate.numerator = params->coderate.num;
	789	satSettings.frequency = freq;
	790	satSettings.ldpcPilot = params->ldpc_pilot;
	791	if(satSettings.ldpcPilot)
	792	satSettings.ldpcPilotPll = params->ldpc_pilot_pll;
	793	satSettings.mode = b_sdsmode2nexus(params->mode);
	794
	795	satSettings.searchRange = params->search_range;
	796	satSettings.spectralInversion = params->spinv;
	797	satSettings.symbolRate = params->symbol_rate;
	798
	799
	800	tuner->lock_callback = params->lock_callback;
	801	tuner->callback_context = params->callback_context;
	802	satSettings.lockCallback.callback = btuner_p_lock_callback;
	803	satSettings.lockCallback.context = tuner;
	804
	805	NEXUS_StartCallbacks(tuner->nTuner);
	806	B_Event_Reset(tuner->waitEvent);
	807	rc = NEXUS_Frontend_TuneSatellite(tuner->nTuner, &satSettings);
	808	b_idle2lock();
	809	if (rc) {BERR_TRACE(rc);return NULL;}
	810
	811	/* Wait for up to 1 sec for tune */
	812	for (i= 0; i < 20; i++)
	813	{
	814	BKNI_Memset(&satStatus, 0, sizeof(NEXUS_FrontendSatelliteStatus));
	815	NEXUS_Frontend_GetSatelliteStatus(tuner->nTuner, &satStatus);
	816	BDBG_MSG(("Sat Status locked %d",(int)satStatus.demodLocked));
	817	if(satStatus.demodLocked)
	818	break;
	819	else
	820	BKNI_Sleep(50);
	821	}
	822
	823	#if 0 /* PR42052: Callback not triggered by AST PI*/
	824	if (params->wait_for_lock)
	825	{
	826	b_unlock();
	827	rc = B_Event_Wait(tuner->waitEvent, 1000);
	828	b_lock();
	829	if (rc) {BERR_TRACE(rc);return NULL;}
	830	}
	831	#endif
	832
	833	return tuner->band;
	834	#else
	835	BSTD_UNUSED(tuner);
	836	BSTD_UNUSED(freq);
	837	BSTD_UNUSED(params);
	838	return NULL;
	839	#endif
	840	}
	841
	842	bband_t btuner_tune_vsb(btuner_t tuner, unsigned freq, const btuner_vsb_params *params)
	843	{
	844	#if NEXUS_HAS_FRONTEND
	845	NEXUS_FrontendVsbSettings settings;
	846	NEXUS_Error rc;
	847
	848	BDBG_OBJECT_ASSERT(tuner, btuner);
	849
	850	b_lock2idle();
	851
	852	NEXUS_Frontend_GetDefaultVsbSettings(&settings);
	853	settings.mode = (params->mode == 8) ? NEXUS_FrontendVsbMode_e8 : NEXUS_FrontendVsbMode_e16;
	854	settings.frequency = freq;
	855	settings.ifFrequency = params->if_freq;
	856	settings.symbolRate = params->symbol_rate;
	857	settings.ifFrequencyOffset = params->if_freq_offset;
	858	settings.symbolRateOffset = params->symbol_rate_offset;
	859	settings.ntscOffset = params->ntsc_offset;
	860
	861	tuner->lock_callback = params->lock_callback;
	862	tuner->callback_context = params->callback_context;
	863	settings.lockCallback.callback = btuner_p_lock_callback;
	864	settings.lockCallback.context = tuner;
	865
	866	NEXUS_StartCallbacks(tuner->nTuner);
	867	B_Event_Reset(tuner->waitEvent);
	868	rc = NEXUS_Frontend_TuneVsb(tuner->nTuner, &settings);
	869	b_idle2lock();
	870	if (rc) {BERR_TRACE(rc);return NULL;}
	871
	872	if (params->wait_for_lock) {
	873	b_unlock();
	874	rc = B_Event_Wait(tuner->waitEvent, 1000);
	875	b_lock();
	876	if (rc) {BERR_TRACE(rc);return NULL;}
	877	}
	878
	879	return tuner->band;
	880	#else
	881	BSTD_UNUSED(tuner);
	882	BSTD_UNUSED(freq);
	883	BSTD_UNUSED(params);
	884	return NULL;
	885	#endif
	886	}
	887
	888	#if B_HAS_ANALOG
	889	bresult btuner_p_set_analog_input(NEXUS_AnalogVideoDecoderHandle analogVideoDecoder, btuner_t tuner, btuner_linein_t linein)
	890	{
	891	NEXUS_Error rc;
	892	NEXUS_AnalogVideoDecoderSettings analogVideoDecoderSettings;
	893	BDBG_MSG(("btuner_p_set_analog_input %p %p %p", analogVideoDecoder, tuner, linein));
	894	if (linein) {
	895	if (linein->composite) {
	896	NEXUS_AnalogVideoDecoder_GetDefaultSettingsForVideoInput(NEXUS_CompositeInput_GetConnector(linein->composite), &analogVideoDecoderSettings);
	897	}
	898	else if (linein->component) {
	899	NEXUS_AnalogVideoDecoder_GetDefaultSettingsForVideoInput(NEXUS_ComponentInput_GetConnector(linein->component), &analogVideoDecoderSettings);
	900	}
	901	else if (linein->svideo) {
	902	NEXUS_AnalogVideoDecoder_GetDefaultSettingsForVideoInput(NEXUS_SvideoInput_GetConnector(linein->svideo), &analogVideoDecoderSettings);
	903	}
	904	else {
	905	return BERR_TRACE(berr_not_available);
	906	}
	907	}
	908	else if (tuner->nTuner) {
	909	NEXUS_AnalogVideoDecoder_GetDefaultSettingsForVideoInput(NEXUS_Frontend_GetAnalogVideoConnector(tuner->nTuner), &analogVideoDecoderSettings);
	910	}
	911	else {
	912	return BERR_TRACE(berr_not_available);
	913	}
	914
	915	rc = NEXUS_AnalogVideoDecoder_SetSettings(analogVideoDecoder, &analogVideoDecoderSettings);
	916	if (rc) return BERR_TRACE(rc);
	917	return 0;
	918	}
	919	#endif
	920
	921	bstream_t btuner_tune_rf(btuner_t tuner, unsigned carrierfreq, const btuner_analog_params *params)
	922	{
	923	#if B_HAS_ANALOG \|\| B_HAS_EXTERNAL_ANALOG
	924	bstream_t stream = &tuner->analog.stream;
	925	BKNI_Memset(stream, 0, sizeof(tuner->analog.stream));
	926	BDBG_OBJECT_SET(stream, bstream);
	927	stream->producer.tuner = tuner;
	928	BDBG_MSG(("freq=%d",carrierfreq));
	929	stream->producer.linein = NULL;
	930	BSTD_UNUSED(carrierfreq); /* TODO */
	931	tuner->analog.params = *params;
	932	tuner->analog.stream.static_alloc=true;
	933	return &tuner->analog.stream;
	934	#else
	935	BSTD_UNUSED(tuner);
	936	BSTD_UNUSED(carrierfreq);
	937	BSTD_UNUSED(params);
	938	BSETTOP_ERROR(berr_not_supported);
	939	return NULL;
	940	#endif
	941	}
	942
	943	bstream_t btuner_tune_linein(btuner_t tuner, btuner_linein_t linein, const btuner_analog_params *params)
	944	{
	945	#if B_HAS_ANALOG \|\| B_HAS_TRANSCODE
	946	bstream_t stream = &tuner->analog.stream;
	947	BKNI_Memset(&tuner->analog.stream, 0, sizeof(tuner->analog.stream));
	948	BDBG_OBJECT_SET(stream, bstream);
	949
	950	stream->producer.tuner = tuner;
	951	stream->producer.linein = linein;
	952	tuner->analog.params = *params;
	953
	954	#if B_HAS_TRANSCODE
	955	{
	956	NEXUS_Transcoder_VdecSettings vdecSettings ;
	957	NEXUS_Transcoder_ConfigureVdec(linein->vdec7043DeviceNo, &vdecSettings ) ;
	958	}
	959	#endif
	960
	961	return stream;
	962
	963	#else
	964	BSTD_UNUSED(tuner);
	965	BSTD_UNUSED(linein);
	966	BSTD_UNUSED(params);
	967	BSETTOP_ERROR(berr_not_supported);
	968	return NULL;
	969	#endif
	970	}
	971
	972	bband_t btuner_tune_ofdm( btuner_t tuner, unsigned freq, const btuner_ofdm_params* params )
	973	{
	974	#if NEXUS_HAS_FRONTEND
	975	NEXUS_FrontendOfdmSettings settings;
	976	NEXUS_Error rc;
	977
	978	BDBG_OBJECT_ASSERT(tuner, btuner);
	979
	980	BDBG_MSG(("OFDM freq %d,bw=%dMhz,cci %s,pri %s, mode %s", freq,params->bandwidth,
	981	params->cci_mode==btuner_ofdm_cci_mode_none?"off":"auto",params->priority==btuner_ofdm_priority_high?"high":"low",
	982	params->mode==btuner_ofdm_mode_dvbt?"dvbt":"isdbt"));
	983
	984	b_lock2idle();
	985
	986	NEXUS_Frontend_GetDefaultOfdmSettings(&settings);
	987
	988	settings.bandwidth = params->bandwidth-5;
	989	settings.cciMode = params->cci_mode;
	990	settings.frequency = freq;
	991	settings.priority = params->priority;
	992	settings.mode = params->mode;
	993
	994	tuner->lock_callback = params->lock_callback;
	995	tuner->callback_context = params->callback_context;
	996	settings.lockCallback.callback = btuner_p_lock_callback;
	997	settings.lockCallback.context = tuner;
	998
	999	NEXUS_StartCallbacks(tuner->nTuner);
	1000	B_Event_Reset(tuner->waitEvent);
	1001	rc = NEXUS_Frontend_TuneOfdm(tuner->nTuner, &settings);
	1002	b_idle2lock();
	1003	if (rc) {BERR_TRACE(rc);return NULL;}
	1004
	1005	if (params->wait_for_lock) {
	1006	b_unlock();
	1007	rc = B_Event_Wait(tuner->waitEvent, 2500);
	1008	b_lock();
	1009	if (rc) {BERR_TRACE(rc);return NULL;}
	1010	}
	1011
	1012	return tuner->band;
	1013	#else
	1014	BSTD_UNUSED(tuner);
	1015	BSTD_UNUSED(freq);
	1016	BSTD_UNUSED(params);
	1017	return NULL;
	1018	#endif
	1019
	1020	}
	1021
	1022	bresult btuner_get_analog_status(btuner_t tuner, btuner_analog_status *status)
	1023	{
	1024	#if B_HAS_TRANSCODE
	1025	BDBG_OBJECT_ASSERT(tuner, btuner);
	1026	BSTD_UNUSED(status);
	1027	return b_ok ;
	1028	#else
	1029	BDBG_OBJECT_ASSERT(tuner, btuner);
	1030	BSTD_UNUSED(status);
	1031	return BSETTOP_ERROR(berr_not_supported);
	1032	#endif
	1033	}
	1034
	1035	bresult btuner_get_qam_status(btuner_t tuner, btuner_qam_status *status)
	1036	{
	1037	#if NEXUS_HAS_FRONTEND
	1038	NEXUS_FrontendQamStatus nStatus;
	1039	NEXUS_FrontendOutOfBandStatus nStatus_oob;
	1040	NEXUS_FrontendCapabilities caps;
	1041	NEXUS_Error rc;
	1042	BDBG_OBJECT_ASSERT(tuner, btuner);
	1043
	1044	BKNI_Memset(status, 0, sizeof(*status));
	1045
	1046	NEXUS_Frontend_GetCapabilities(tuner->nTuner, &caps);
	1047
	1048	b_lock2idle();
	1049	if (caps.qam)
	1050	{
	1051	NEXUS_Frontend_ResetStatus(tuner->nTuner);
	1052	BKNI_Sleep(100);
	1053	rc = NEXUS_Frontend_GetQamStatus(tuner->nTuner, &nStatus);
	1054	}
	1055	else
	1056	rc = NEXUS_Frontend_GetOutOfBandStatus(tuner->nTuner, &nStatus_oob);
	1057	b_idle2lock();
	1058	if (rc) return BERR_TRACE(rc);
	1059
	1060	if (caps.qam)
	1061	{
	1062	status->ext_agc_level = nStatus.rfAgcLevel;
	1063	status->fec_corr_cnt = nStatus.fecCorrected;
	1064	status->fec_lock = nStatus.fecLock;
	1065	status->fec_uncorr_cnt = nStatus.fecUncorrected;
	1066	status->freq_er2 = nStatus.carrierPhaseOffset/1000;
	1067	status->freq_err = nStatus.carrierFreqOffset/1000;
	1068	status->int_agc_level = nStatus.ifAgcLevel;
	1069	status->qam_lock = nStatus.receiverLock;
	1070	status->snr_estimate = (nStatus.snrEstimate * 256)/100;
	1071	status->symbol_rate = nStatus.symbolRate;
	1072	status->ber_estimate = nStatus.berEstimate;
	1073	status->dsChannelPower = nStatus.dsChannelPower;
	1074	status->mainTap = nStatus.mainTap;
	1075	status->equalizerGain = nStatus.equalizerGain;
	1076	status->postRsBer = nStatus.postRsBer;
	1077	status->postRsBerElapsedTime = nStatus.postRsBerElapsedTime;
	1078	status->dsChannelPower = nStatus.dsChannelPower;
	1079	status->fec_clean_cnt = nStatus.fecClean;
	1080	status->annex = nStatus.settings.annex;
	1081	}
	1082	else
	1083	{
	1084	status->ext_agc_level = nStatus_oob.agcExtLevel;
	1085	status->fec_corr_cnt = nStatus_oob.correctedCount;
	1086	status->fec_lock = nStatus_oob.isFecLocked;
	1087	status->fec_uncorr_cnt = nStatus_oob.uncorrectedCount;
	1088	status->freq_er2 = nStatus_oob.carrierPhaseOffset/1000;
	1089	status->freq_err = nStatus_oob.carrierFreqOffset/1000;
	1090	status->int_agc_level = nStatus_oob.agcIntLevel;
	1091	status->qam_lock = nStatus_oob.isQamLocked;
	1092	status->snr_estimate = (nStatus_oob.snrEstimate*256)/100;
	1093	status->symbol_rate = nStatus_oob.symbolRate;
	1094	}
	1095
	1096	return 0;
	1097	#else
	1098	BSTD_UNUSED(tuner);
	1099	BKNI_Memset(status, 0, sizeof(*status));
	1100	return BSETTOP_ERROR(berr_not_supported);
	1101	#endif
	1102	}
	1103
	1104	bresult btuner_get_qam_us_status(btuner_t tuner, btuner_qam_us_status *status)
	1105	{
	1106	#if NEXUS_HAS_FRONTEND
	1107	NEXUS_FrontendUpstreamStatus nStatus;
	1108	NEXUS_Error rc;
	1109	BDBG_OBJECT_ASSERT(tuner, btuner);
	1110
	1111	BKNI_Memset(status, 0, sizeof(*status));
	1112
	1113	b_lock2idle();
	1114	rc = NEXUS_Frontend_GetUpstreamStatus(tuner->nTuner, &nStatus);
	1115	b_idle2lock();
	1116	if (rc) return BERR_TRACE(rc);
	1117
	1118	switch (nStatus.mode) {
	1119	case NEXUS_FrontendUpstreamMode_ePodAnnexA:
	1120	status->mode = btuner_qam_us_mode_pod_annexa;
	1121	break;
	1122	case NEXUS_FrontendUpstreamMode_ePodDvs178:
	1123	status->mode = btuner_qam_us_mode_pod_dvs178;
	1124	break;
	1125	case NEXUS_FrontendUpstreamMode_eAnnexA :
	1126	status->mode = btuner_qam_us_mode_annexa;
	1127	break;
	1128	case NEXUS_FrontendUpstreamMode_eDvs178:
	1129	status->mode = btuner_qam_us_mode_dvs178;
	1130	break;
	1131	case NEXUS_FrontendUpstreamMode_eDocsis:
	1132	status->mode = btuner_qam_us_mode_docsis;
	1133	break;
	1134	default:
	1135	return BSETTOP_ERROR(berr_invalid_parameter);
	1136	}
	1137
	1138	status->power_level = nStatus.powerLevel;
	1139	status->symbol_rate = nStatus.symbolRate;
	1140	status->freq = nStatus.frequency;
	1141
	1142	return b_ok;
	1143	#else
	1144	BSTD_UNUSED(tuner);
	1145	BKNI_Memset(status, 0, sizeof(*status));
	1146	return BSETTOP_ERROR(berr_not_supported);
	1147	#endif
	1148	}
	1149
	1150	bresult btuner_get_sds_status(btuner_t tuner, btuner_sds_status *status)
	1151	{
	1152	#if NEXUS_HAS_FRONTEND
	1153	NEXUS_FrontendSatelliteStatus nStatus;
	1154	NEXUS_Error rc;
	1155	BDBG_OBJECT_ASSERT(tuner, btuner);
	1156
	1157	BKNI_Memset(status, 0, sizeof(*status));
	1158
	1159	b_lock2idle();
	1160	rc = NEXUS_Frontend_GetSatelliteStatus(tuner->nTuner, &nStatus);
	1161	b_idle2lock();
	1162	if (rc) return BERR_TRACE(rc);
	1163
	1164	status->pre_viterbi_error_count = nStatus.preViterbiErrorCount;
	1165	status->ber_errors = nStatus.berErrors;
	1166	status->ber_estimate = nStatus.berEstimate;
	1167	status->bert_locked = nStatus.bertLocked;
	1168	status->carrier_error = nStatus.carrierError;
	1169	status->sample_frequency = nStatus.sampleClock;
	1170	status->coderate.bits_per_symbol = nStatus.codeRate.bitsPerSymbol;
	1171	status->coderate.denom = nStatus.codeRate.denominator;
	1172	status->coderate.num = nStatus.codeRate.numerator;
	1173	status->fec_phase = nStatus.fecPhase;
	1174	status->lnaStatus.int_config = nStatus.lnaStatus.intConfig;
	1175	status->lnaStatus.ext_config = nStatus.lnaStatus.extConfig;
	1176	status->lnaStatus.version = nStatus.lnaStatus.version;
	1177	status->lnaStatus.agc0 = nStatus.lnaStatus.agc0;
	1178	status->lnaStatus.agc1 = nStatus.lnaStatus.agc1;
	1179	status->tuner_freq = nStatus.settings.frequency;
	1180	status->channel = nStatus.channel;
	1181	status->if_agc = nStatus.ifAgc;
	1182	status->rf_agc = nStatus.rfAgc;
	1183	status->output_bit_rate = nStatus.outputBitRate;
	1184	status->fec_corr = nStatus.fecCorrected;
	1185	status->fec_uncorr = nStatus.fecUncorrected;
	1186	status->fec_clean = nStatus.fecClean;
	1187	status->rs_locked = nStatus.demodLocked;
	1188	status->vit_locked = nStatus.demodLocked;
	1189	/* status->rs_uncorr = nStatus. */
	1190	/* status->sample_frequency = */
	1191	status->snr_estimate = (nStatus.snrEstimate * 256)/100;
	1192	status->spectral_inversion = nStatus.spectralInversion;
	1193	/* status->vit_locked = nStatus. */
	1194	/* status-> */
	1195
	1196	return 0;
	1197	#else
	1198	BSTD_UNUSED(tuner);
	1199	BKNI_Memset(status, 0, sizeof(*status));
	1200	return BSETTOP_ERROR(berr_not_supported);
	1201	#endif
	1202	}
	1203
	1204	bresult btuner_get_vsb_status(btuner_t tuner, btuner_vsb_status *status)
	1205	{
	1206	#if NEXUS_HAS_FRONTEND
	1207	NEXUS_FrontendVsbStatus nStatus;
	1208	NEXUS_Error rc;
	1209	BDBG_OBJECT_ASSERT(tuner, btuner);
	1210
	1211	BKNI_Memset(status, 0, sizeof(*status));
	1212
	1213	b_lock2idle();
	1214	rc = NEXUS_Frontend_GetVsbStatus(tuner->nTuner, &nStatus);
	1215	b_idle2lock();
	1216	if (rc) return BERR_TRACE(rc);
	1217
	1218	status->mode = nStatus.settings.mode;
	1219	status->receiver_lock = nStatus.receiverLock;
	1220	status->fec_lock = nStatus.fecLock;
	1221	status->opll_lock = nStatus.opllLock;
	1222	status->symbol_rate = nStatus.symbolRate;
	1223	status->symbol_rate_offset = nStatus.settings.symbolRateOffset;
	1224	status->symbol_rate_error = nStatus.symbolRateError;
	1225	status->if_freq = nStatus.ifFrequency;
	1226	status->if_freq_offset = nStatus.settings.ifFrequencyOffset;
	1227	status->if_freq_error = nStatus.ifFrequencyError;
	1228	status->ntsc_offset = nStatus.settings.ntscOffset;
	1229	status->ntsc_error = 0;
	1230	status->int_agc_level = nStatus.ifAgcLevel;
	1231	status->ext_agc_level = nStatus.rfAgcLevel;
	1232	status->snr_estimate = (nStatus.snrEstimate * 256)/100;
	1233	status->blk_corr = nStatus.fecCorrected;
	1234	status->blk_uncorr = nStatus.fecUncorrected;
	1235	status->err_corr = nStatus.bitErrCorrected;
	1236
	1237	return 0;
	1238	#else
	1239	BSTD_UNUSED(tuner);
	1240	BKNI_Memset(status, 0, sizeof(*status));
	1241	return BSETTOP_ERROR(berr_not_supported);
	1242	#endif
	1243
	1244	}
	1245
	1246	bresult btuner_get_soft_decisions(btuner_t tuner, btuner_soft_decision *data, size_t length)
	1247	{
	1248	#if B_HAS_EXTERNAL_ANALOG \|\| !NEXUS_HAS_FRONTEND
	1249	BSTD_UNUSED(tuner);
	1250	BSTD_UNUSED(data);
	1251	BSTD_UNUSED(length);
	1252	return b_ok;
	1253	#else
	1254	unsigned i;
	1255	NEXUS_Error rc;
	1256	NEXUS_FrontendSoftDecision *pSoftDecisions;
	1257
	1258	BDBG_OBJECT_ASSERT(tuner, btuner);
	1259
	1260	BDBG_MSG(("Reading %d soft decisions", length));
	1261
	1262	pSoftDecisions = BKNI_Malloc(length*sizeof(NEXUS_FrontendSoftDecision));
	1263	if ( NULL == pSoftDecisions )
	1264	{
	1265	return BSETTOP_ERROR(berr_out_of_memory);
	1266	}
	1267
	1268	b_lock2idle();
	1269	rc = NEXUS_Frontend_GetSoftDecisions(tuner->nTuner, pSoftDecisions, length);
	1270	b_idle2lock();
	1271	if ( rc )
	1272	{
	1273	BKNI_Memset(data, 0, length*sizeof(btuner_soft_decision));
	1274	BKNI_Free(pSoftDecisions);
	1275	return BSETTOP_ERROR(berr_external_error);
	1276	}
	1277
	1278	for ( i = 0; i < length; i++ )
	1279	{
	1280	data[i].i = pSoftDecisions[i].i;
	1281	data[i].q = pSoftDecisions[i].q;
	1282	}
	1283
	1284	BKNI_Free(pSoftDecisions);
	1285	return b_ok;
	1286	#endif
	1287	}
	1288
	1289	bresult btuner_get_ofdm_status( btuner_t tuner, btuner_ofdm_status *status )
	1290	{
	1291	#if NEXUS_HAS_FRONTEND
	1292	NEXUS_FrontendOfdmStatus nStatus;
	1293	NEXUS_Error rc;
	1294	BDBG_OBJECT_ASSERT(tuner, btuner);
	1295
	1296	BKNI_Memset(status, 0, sizeof(*status));
	1297
	1298	rc = NEXUS_Frontend_GetOfdmStatus(tuner->nTuner, &nStatus);
	1299	if (rc) return BERR_TRACE(rc);
	1300
	1301	status->acq_count = nStatus.reacquireCount;
	1302	status->blk_clean = nStatus.fecCleanBlocks;
	1303	status->blk_corr = nStatus.fecCorrectedBlocks;
	1304	status->blk_uncorr = nStatus.fecUncorrectedBlocks;
	1305	status->carrier_offset = nStatus.carrierOffset;
	1306	status->fec_lock = nStatus.fecLock;
	1307	status->receiver_lock = nStatus.receiverLock;
	1308	status->snr = (nStatus.snr/100);
	1309	status->timing_offset = nStatus.timingOffset;
	1310
	1311	return 0;
	1312	#else
	1313	BSTD_UNUSED(tuner);
	1314	BKNI_Memset(status, 0, sizeof(*status));
	1315	return BSETTOP_ERROR(berr_not_supported);
	1316	#endif
	1317	}
	1318

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: svn/newcon3bcm2_21bu/BSEAV/api/src/nexus/bsettop_tuner.c

Download in other formats: