Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

dsthalfe.c @ 22

Last change on this file since 22 was 22, checked in by phkim, 11 years ago
phkim newcon3sk 를 kctv 로 브랜치 함
File size: 101.9 KB

Line
1	/****************************************************************************
2	*_Copyright (c) 2004 Digital Stream Technologies Inc. All Rights Reserved.
3	*
4	* Module: dsthalfe.cpp
5	* Author: Jun-ku Park, hwatk@dstreamtech.com
6	* Description: DST HAL [Front End] Platform/Project Indepedent Sources
7	*
8	* notes: hwatk20050708
9	*
10	* TO DO LIST
11	* - Implement BERT Functions.
12	*
13	***************************************************************************/
14
15	#include <stdio.h>
16	#include <stdlib.h>
17	#include <errno.h>
18	#include <sys/stat.h>
19
20	#include "dsthalcommon.h"
21	#include "dstdddtv.h"
22	#include "dstddaud.h"
23	#include "dstddfe.h"
24	#include "dstddsys.h"
25
26	#ifdef DMALLOC
27	#include <dmalloc.h>
28	#endif
29
30	/******************************************************************************
31	* Global variable declaration
32	******************************************************************************/
33	DST_FE sDSTFE_Tuner[TUNER_MAX-1] = { {0}, {0} };
34	int gdhlFeDbgLvl = 2;
35	int g_AnalogSearchDelay = 1000;
36	int g_PreAudioModeDelay = 200;
37	int g_AftAudioModeDelay = 200;
38
39	/******************************************************************************
40	* Imported variable declaration
41	******************************************************************************/
42	extern DHL_DTV_CONFIG g_dhlav;
43	extern DHL_CAP_CONFIG g_dhlcap;
44	extern DHL_CAP_VideoTiming_t PrevVideoTiming, PrevVideoTimingPIP;
45
46	/******************************************************************************
47	* Imported function declaration
48	******************************************************************************/
49
50
51	/******************************************************************************
52	* Local definitions and typedefs
53	******************************************************************************/
54	#define USE_NTSCCALLBACK 1 // NTSC Call Back »ç¿ë ¿©ºÎ
55	#define USE_DIGITAL_CALLBACK 0 // Digital Callback »ç¿ë ¿©ºÎ
56	#define USE_ANALOGLOCKSTATUS 0
57	#define MDELAY(x) OS_mDelay((x))
58	#define USE_IN_KHZ 0 // Frequency TableÀ» KHz ´ÜÀ§·Î »ç¿ëÇÒ °ÍÀÎÁö
59	// MHz ´ÜÀ§·Î »ç¿ëÇÒ °ÍÀÎÁö ¿©ºÎ
60
61	/******************************************************************************
62	* Local variables declaration
63	******************************************************************************/
64	int g_fe_debug = 0;
65	int g_force_ss = 0;
66	int g_test_weak_interval = 0;
67
68	/******************************************************************************
69	* Local function prototypes
70	******************************************************************************/
71	#if USE_NTSCCALLBACK
72	static DHL_RESULT DHL_FE_NTSCCallbackInit(void);
73	#endif
74	void set_lock(int l);
75
76	#if 0
77	___Frequency_Table__________() {}
78	#endif
79	/* Frequency Conversion Table from HDMB - Tuner.c */
80	#if USE_IN_KHZ /* 2005.05.30 - Frequency Table ¼öÁ¤ */
81	DS_U16 Air_Freq[69+2] = {
82	0, 0, 57, 63, 69, 79, 85,177,183,189,
83	195,201,207,213,473,479,485,491,497,503,
84	509,515,521,527,533,539,545,551,557,563,
85	569,575,581,587,593,599,605,611,617,623,
86	629,635,641,647,653,659,665,671,677,683,
87	689,695,701,707,713,719,725,731,737,743,
88	749,755,761,767,773,779,785,791,797,803,
89	};
90
91	DS_U16 Cable_Freq[160] = {
92	0, 75, 57, 63, 69, 79, 85,177,183,189,
93	195,201,207,213,123,129,135,141,147,153,
94	159,165,171,219,225,231,237,243,249,255,
95	261,267,273,279,285,291,297,303,309,315,
96	321,327,333,339,345,351,357,363,369,375,
97	381,387,393,399,405,411,417,423,429,435,
98	441,447,453,459,465,471,477,483,489,495,
99	501,507,513,519,525,531,537,543,549,555,
100	561,567,573,579,585,591,597,603,609,615,
101	621,627,633,639,645, 93, 99,105,111,117,
102	651,657,663,669,675,681,687,693,699,705,
103	711,717,723,729,735,741,747,753,759,765,
104	771,777,783,789,795,801,807,813,819,825,
105	831,837,843,849,855,861,867,873,879,885,
106	891,897,903,909,915,921,927,933,939,945,
107	951,957,963,969,975,981,987,993,999,
108	};
109
110	DS_U16 Cable_Freq_IRC[160] = {
111	0, 75, 57, 63, 69, 81, 87,177,183,189,
112	195,201,207,213,123,129,135,141,147,153,
113	159,165,171,219,225,231,237,243,249,255,
114	261,267,273,279,285,291,297,303,309,315,
115	321,327,333,339,345,351,357,363,369,375,
116	381,387,393,399,405,411,417,423,429,435,
117	441,447,453,459,465,471,477,483,489,495,
118	501,507,513,519,525,531,537,543,549,555,
119	561,567,573,579,585,591,597,603,609,615,
120	621,627,633,639,645, 93, 99,105,111,117,
121	651,657,663,669,675,681,687,693,699,705,
122	711,717,723,729,735,741,747,753,759,765,
123	771,777,783,789,795,801,807,813,819,825,
124	831,837,843,849,855,861,867,873,879,885,
125	891,897,903,909,915,921,927,933,939,945,
126	951,957,963,969,975,981,987,993,999,
127	};
128
129	DS_U16 Cable_Freq_HRC[160] = {
130	0, 74, 56, 62, 68, 80, 86,176,182,188,
131	194,200,206,212,122,128,134,140,146,152,
132	158,164,170,218,224,230,236,242,248,254,
133	260,266,272,278,284,290,296,302,308,314,
134	320,326,332,338,344,350,356,362,368,374,
135	380,386,392,398,404,410,416,422,428,434,
136	440,446,452,458,464,470,476,482,488,494,
137	500,506,512,518,524,530,536,542,548,554,
138	560,566,572,578,584,590,596,602,608,614,
139	620,626,632,638,644, 92, 98,104,110,116,
140	650,656,662,668,674,680,686,692,698,704,
141	710,716,722,728,734,740,746,752,758,764,
142	770,776,782,788,794,800,806,812,818,824,
143	830,836,842,848,854,860,866,872,878,884,
144	890,896,902,908,914,920,926,932,938,944,
145	950,956,962,968,974,980,986,992,998,
146	};
147	#else
148	DS_U32 Air_Freq[83+2] = {
149	0, 0, 57000, 63000, 69000, 79000, 85000,177000,183000,189000,
150	195000,201000,207000,213000,473000,479000,485000,491000,497000,503000,
151	509000,515000,521000,527000,533000,539000,545000,551000,557000,563000,
152	569000,575000,581000,587000,593000,599000,605000,611000,617000,623000,
153	629000,635000,641000,647000,653000,659000,665000,671000,677000,683000,
154	689000,695000,701000,707000,713000,719000,725000,731000,737000,743000,
155	749000,755000,761000,767000,773000,779000,785000,791000,797000,803000,
156	809000,815000,821000,827000,833000,839000,845000,851000,857000,863000,
157	869000,875000,881000,887000
158	};
159
160	DS_U32 Cable_Freq[160] = {
161	0, 75000, 57000, 63000, 69000, 79000, 85000,177000,183000,189000,
162	195000,201000,207000,213000,123000,129000,135000,141000,147000,153000,
163	159000,165000,171000,219000,225000,231000,237000,243000,249000,255000,
164	261000,267000,273000,279000,285000,291000,297000,303000,309000,315000,
165	321000,327000,333000,339000,345000,351000,357000,363000,369000,375000,
166	381000,387000,393000,399000,405000,411000,417000,423000,429000,435000,
167	441000,447000,453000,459000,465000,471000,477000,483000,489000,495000,
168	501000,507000,513000,519000,525000,531000,537000,543000,549000,555000,
169	561000,567000,573000,579000,585000,591000,597000,603000,609000,615000,
170	621000,627000,633000,639000,645000, 93000, 99000,105000,111000,117000,
171	651000,657000,663000,669000,675000,681000,687000,693000,699000,705000,
172	711000,717000,723000,729000,735000,741000,747000,753000,759000,765000,
173	771000,777000,783000,789000,795000,801000,807000,813000,819000,825000,
174	831000,837000,843000,849000,855000,861000,867000,873000,879000,885000,
175	891000,897000,903000,909000,915000,921000,927000,933000,939000,945000,
176	951000,957000,963000,969000,975000,981000,987000,993000,999000,
177	};
178
179	DS_U32 Cable_Freq_IRC[160] = {
180	0, 75000, 57000, 63000, 69000, 81000, 87000,177000,183000,189000,
181	195000,201000,207000,213000,123000,129000,135000,141000,147000,153000,
182	159000,165000,171000,219000,225000,231000,237000,243000,249000,255000,
183	261000,267000,273000,279000,285000,291000,297000,303000,309000,315000,
184	321000,327000,333000,339000,345000,351000,357000,363000,369000,375000,
185	381000,387000,393000,399000,405000,411000,417000,423000,429000,435000,
186	441000,447000,453000,459000,465000,471000,477000,483000,489000,495000,
187	501000,507000,513000,519000,525000,531000,537000,543000,549000,555000,
188	561000,567000,573000,579000,585000,591000,597000,603000,609000,615000,
189	621000,627000,633000,639000,645000, 93000, 99000,105000,111000,117000,
190	651000,657000,663000,669000,675000,681000,687000,693000,699000,705000,
191	711000,717000,723000,729000,735000,741000,747000,753000,759000,765000,
192	771000,777000,783000,789000,795000,801000,807000,813000,819000,825000,
193	831000,837000,843000,849000,855000,861000,867000,873000,879000,885000,
194	891000,897000,903000,909000,915000,921000,927000,933000,939000,945000,
195	951000,957000,963000,969000,975000,981000,987000,993000,999000
196	};
197
198	DS_U32 Cable_Freq_HRC[160] = {
199	// 0 1 2 3 4 5 6 7 8 9
200	0, 73750, 55750, 61750, 67750, 79750, 85750,175750,181750,187750, // 0~ 9
201	193750,199750,205750,211750,121750,127750,133750,139750,145750,151750, // 10~ 19
202	157750,163750,169750,217750,223750,229750,235750,241750,247750,253750, // 20~ 29
203	259750,265750,271750,277750,283750,289750,295750,301750,307750,313750, // 30~ 39
204	319750,325750,331750,337750,343750,349750,355750,361750,367750,373750, // 40~ 49
205	379750,385750,391750,397750,403750,409750,415750,421750,427750,433750, // 50~ 59
206	439750,445750,451750,457750,463750,469750,475750,481750,487750,493750, // 60~ 69
207	499750,505750,511750,517750,523750,529750,535750,541750,547750,553750, // 70~ 79
208	559750,565750,571750,577750,583750,589750,595750,601750,607750,613750, // 80~ 89
209	619750,625750,631750,637750,643750, 91750, 97750,103750,109750,115750, // 90~ 99
210	649750,655750,661750,667750,673750,679750,685750,691750,697750,703750, // 100~109
211	709750,715750,721750,727750,733750,739750,745750,751750,757750,763750, // 110~119
212	769750,775750,781750,787750,793750,799750,805750,811750,817750,823750, // 120~129
213	829750,835750,841750,847750,853750,859750,865750,871750,877750,884750,
214	890750,896750,902750,908750,914750,920750,926750,932750,938750,944750,
215	950750,956750,962750,968750,974750,980750,986750,992750,998750, // 130~135
216	};
217	#endif
218
219	#if USE_IN_KHZ
220	static DS_U32 ConvertChannelToFrequency( DS_U32 Channel, FreqStandardType FreqStd )
221	{
222	DS_U32 Frequency;
223
224	switch ( FreqStd )
225	{
226	case FREQ_AIR:
227	Frequency = Air_Freq[Channel] * 1000;
228	break;
229	case FREQ_STD:
230	Frequency = Cable_Freq[Channel] * 1000;
231	break;
232	case FREQ_IRC:
233	Frequency = Cable_Freq_IRC[Channel] * 1000;
234	break;
235	case FREQ_HRC:
236	Frequency = Cable_Freq_HRC[Channel] * 1000;
237	break;
238	default:
239	DHL_DbgPrintf( 0, DHLDBG_FE, "Error with Channel = %lu, FreqStd = %d\n", Channel, FreqStd );
240	return 0;
241	}
242
243	return Frequency;
244	}
245	#else
246	static DS_U32 ConvertChannelToFrequency( DS_U32 Channel, FreqStandardType FreqStd )
247	{
248	DS_U32 Frequency;
249
250	switch ( FreqStd )
251	{
252	case FREQ_AIR:
253	Frequency = Air_Freq[Channel];
254	break;
255	case FREQ_STD:
256	Frequency = Cable_Freq[Channel];
257	break;
258	case FREQ_IRC:
259	Frequency = Cable_Freq_IRC[Channel];
260	break;
261	case FREQ_HRC:
262	Frequency = Cable_Freq_HRC[Channel];
263	break;
264	default:
265	DHL_DbgPrintf( 0, DHLDBG_FE, "Error with Channel = %lu, FreqStd = %d\n", Channel, FreqStd );
266	return 0;
267	}
268
269	return Frequency;
270	}
271	#endif
272
273	#if 0
274	___Main_FE_Functions_________()
275	#endif
276	/****************************************************************************
277
278	DHL_RESULT DHL_FE_Init
279	- Summary : Initialize Front End, including Tuner/Demodulator.
280	- Argument : Tuner to use, TunerType { TUNER_FAT, TUNER_FDC }
281	- Returns : DHL_OK on success, DHL_FAIL on failure.
282
283	***************************************************************************/
284	DHL_RESULT DHL_FE_Init( TunerType Tuner )
285	{
286	P_DST_FE pDSTFETuner;
287	int RetVal;
288	int i;
289
290	if ( Tuner >= TUNER_MAX \|\| Tuner <= TUNER_UNKNOWN ) {
291	DHL_DbgPrintf( 0, DHLDBG_FE, "Error : Tuner is unknown!\n" );
292	return DHL_FAIL;
293	}
294
295	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
296	if ( pDSTFETuner->bCurState != TUNERSTATE_UNKNOWN ) {
297	DHL_DbgPrintf( 0, DHLDBG_FE, "Error : Tuner State is unknown!\n" );
298	return DHL_FAIL;
299	}
300
301	pDSTFETuner->bFreqStd = FREQ_AIR; /* Default AIR */
302	pDSTFETuner->bCurDemod = DEMOD_UNKNOWN; /* Default 8VSB */
303	pDSTFETuner->bChannel = 0;
304	pDSTFETuner->uFrequency = 0;
305	pDSTFETuner->bCarrierMute = 0;
306
307	for (i=0; i<(FECALLBACK_MAX-1); i++) {
308	pDSTFETuner->fnFECallback[i] = (P_DHL_FE_CALLBACK)0;
309	pDSTFETuner->FECallbackUserArg[i] = 0;
310	}
311
312	RetVal = DD_FE_Init( Tuner, pDSTFETuner );
313	if ( RetVal != DHL_OK ) {
314	DHL_DbgPrintf( 0, DHLDBG_FE, "Error : DD_FE_Init()\n" );
315	return DHL_FAIL;
316	}
317
318	#if USE_NTSCCALLBACK
319	if ( Tuner == TUNER_FAT )
320	DHL_FE_NTSCCallbackInit();
321	#endif
322
323	pDSTFETuner->bTuner = Tuner;
324	pDSTFETuner->bCurState = TUNERSTATE_INIT;
325	pDSTFETuner->bBERTStarted = _FALSE_; /* FALSE means NOT-STARTED. */
326
327	/* Initialize MUTEX */
328
329
330	return DHL_OK;
331	}
332
333	/****************************************************************************
334
335	DHL_RESULT DHL_FE_SetChannelStandard
336	- Summary : Set Channel Standard for Tuner.
337	- Argument
338	TunerType { TUNER_FAT, TUNER_FDC }
339	FreqStandardType { FREQ_AIR, FREQ_STD, FREQ_IRC, FREQ_IRC }
340	- Returns : DHL_OK on success, DHL_FAIL on failure
341	- Note
342	. Don't use MUTEX.
343
344	***************************************************************************/
345	DHL_RESULT DHL_FE_SetChannelStandard( TunerType Tuner, FreqStandardType FreqStd )
346	{
347	P_DST_FE pDSTFETuner;
348	if ( (Tuner >= TUNER_MAX) \|\| (Tuner <= TUNER_UNKNOWN) ) {
349	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner );
350	return DHL_FAIL;
351	}
352
353	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
354	if ( (pDSTFETuner->bCurState != TUNERSTATE_INIT) && (pDSTFETuner->bCurState != TUNERSTATE_STOP) ) {
355	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: This function should be called in TUNER_INIT, TUNER_STOP\n" );
356	return DHL_FAIL;
357	}
358
359	if ( (FreqStd <= FREQ_UNKNOWN) \|\| FreqStd >= (FREQ_MAX) ) {
360	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Frequency Standard is invalid, %d\n", FreqStd );
361	return DHL_FAIL;
362	}
363
364	pDSTFETuner->bFreqStd = FreqStd;
365	return DHL_OK;
366	}
367
368	/****************************************************************************
369
370	DHL_RESULT DHL_FE_Start
371	- Summary : Set Channel / Frequency on Tuner.
372	- Argument
373	TunerType { TUNER_FAT, TUNER_FDC }
374	ChannelFreq
375	if ( Tuner == TUNER_FAT ) ChannelFreq = Channel
376	else if ( Tuner == TUNER_FDC ) ChannelFreq = Frequency, 1 unit = 1000 Hz
377	Demod { DEMOD_8VSB, DEMOD_64QAM, DEMOD_256QAM, DEMOD_NTSC, DEMOD_ISDBT, DEMOD_ISDBT_MANUAL }
378	bFreq { CHANNEL, FREQ }
379
380	- Returns : DHL_OK on success, DHL_FAIL on failure
381
382	***************************************************************************/
383	DHL_RESULT DHL_FE_Start( TunerType Tuner, DS_U32 ChannelFreq, TunerDemod Demod, TuneType bFreq )
384	{
385	P_DST_FE pDSTFETuner;
386	DHL_RESULT dhlResult = DHL_OK;
387	DS_U32 Frequency = 0;
388
389	if ( Tuner >= TUNER_MAX \|\| Tuner <= TUNER_UNKNOWN )
390	{
391	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner );
392	return DHL_FAIL;
393	}
394	//JFET20050513 \| ADD LOG - for the tuner IF select
395	//FE_SelectTunerIF(Demod);
396
397	if ( Tuner == TUNER_FAT )
398	{
399	if ( (Demod <= DEMOD_UNKNOWN) \|\| (Demod > DEMOD_OFF) )
400	{
401	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Demodulation Type is invalid, %d\n", Demod );
402	return DHL_FAIL_INVALID_PARAM;
403	}
404	if ( bFreq == CHANNEL )
405	{
406	if ( (ChannelFreq < MIN_FAT_CH) \|\| (ChannelFreq > MAX_FAT_CH) )
407	{
408	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Channel is over limited area, %lu\n", ChannelFreq );
409	return DHL_FAIL;
410	}
411	}
412	else
413	{
414	/* Frequency Check is done at lower Tuner Driver */
415
416	}
417	}
418	else
419	{
420	/* FDC Check is not implemented yet */
421	if ( (Demod != DEMOD_MODEA) && (Demod != DEMOD_MODEB) )
422	{
423	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Demodulation Type is invalid, 0x%x\n", Demod );
424	return DHL_FAIL_INVALID_PARAM;
425	}
426	}
427
428	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
429
430	/* Take the MUTEX */
431
432
433
434	if ( pDSTFETuner->bCurState == TUNERSTATE_UNKNOWN )
435	{
436	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is %d\n", pDSTFETuner->bCurState );
437	dhlResult = DHL_FAIL;
438	goto done;
439	}
440
441	if ( (pDSTFETuner->bFreqStd <= FREQ_UNKNOWN) \|\| (pDSTFETuner->bFreqStd >= FREQ_MAX) )
442	{
443	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Frequency Standard is invalid, %d\n", pDSTFETuner->bFreqStd );
444	dhlResult = DHL_FAIL;
445	goto done;
446	}
447	#if 0
448	if ( (Demod == DEMOD_8VSB) && (pDSTFETuner->bFreqStd != FREQ_AIR) )
449	{
450	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Demodulation is 8VSB, but Frequency Standard is not FREQ_AIR!\n" );
451	dhlResult = DHL_FAIL;
452	goto done;
453	}
454	#endif
455
456	/*
457	* Convert Channel to Frequency if bFreq = CHANNEL.
458	*/
459	if ( bFreq == CHANNEL ) {
460	Frequency = ConvertChannelToFrequency( ChannelFreq, pDSTFETuner->bFreqStd );
461	} else {
462	Frequency = ChannelFreq;
463	}
464
465	if ( (Tuner == TUNER_FDC) && (bFreq != FREQ) )
466	{
467	dhlResult = DHL_FAIL;
468	goto done;
469	}
470
471	if ( Tuner == TUNER_FAT )
472	dhlResult = DD_FE_SetChannelFAT( pDSTFETuner, Frequency * 1000, &Demod );
473	else
474	dhlResult = DD_FE_SetChannelFDC( pDSTFETuner, Frequency * 1000, &Demod );
475
476	if ( dhlResult != DHL_OK )
477	goto done;
478
479	pDSTFETuner->bCurState = TUNERSTATE_START;
480	pDSTFETuner->bCurDemod = Demod;
481	pDSTFETuner->uFrequency = Frequency;
482	if ( bFreq == CHANNEL )
483	pDSTFETuner->bChannel = ChannelFreq;
484
485	//
486	// Digital CallbackÀ» »ç¿ëÇÏÁö ¾Ê´Â °æ¿ì, (ÇÏÀ§ FE Driver°¡ Áö¿øÇÏ´Â °æ¿ì)
487	// NTSC Callback Function¸¸À» »ç¿ëÇÏµµ·Ï ÇÔ.
488	//
489	#if USE_NTSCCALLBACK
490	if ( pDSTFETuner->bCurDemod == DEMOD_NTSC )
491	{
492	if ( pDSTFETuner->fnFECallbackNTSC[FECALLBACK_ACQSTART-1] ) {
493	(pDSTFETuner->fnFECallbackNTSC[FECALLBACK_ACQSTART-1])(pDSTFETuner->bTuner, FECALLBACK_ACQSTART, pDSTFETuner->FECallbackNTSCUserArg[FECALLBACK_ACQSTART-1]);
494	}
495
496	if ( g_fe_debug ) {
497	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[FAT] %s Acqusition start.\n", Demod == DEMOD_8VSB ? "8VSB" :
498	Demod == DEMOD_64QAM ? "64QAM" :
499	Demod == DEMOD_256QAM ? "256QAM" :
500	Demod == DEMOD_QAM ? "QAM" :
501	Demod == DEMOD_NTSC ? "NTSC" :
502	Demod == DEMOD_ISDBT ? "ISDB-T" :
503	Demod == DEMOD_ISDBT_MANUAL ? "ISDB-T Manual" :
504	Demod == DEMOD_MODEA ? "MODEA" :
505	Demod == DEMOD_MODEB ? "MODEB" : "Unknown");
506	}
507	}
508	#endif
509
510	#if USE_DIGITAL_CALLBACK
511	if ( pDSTFETuner->bCurDemod != DEMOD_NTSC )
512	{
513	if ( pDSTFETuner->fnFECallback[FECALLBACK_ACQSTART-1] ) {
514	(pDSTFETuner->fnFECallback[FECALLBACK_ACQSTART-1])(pDSTFETuner->bTuner, FECALLBACK_ACQSTART, pDSTFETuner->FECallbackUserArg[FECALLBACK_ACQSTART-1]);
515	}
516
517	if ( g_fe_debug ) {
518	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[FAT] %s Acqusition start.\n", Demod == DEMOD_8VSB ? "8VSB" :
519	Demod == DEMOD_64QAM ? "64QAM" :
520	Demod == DEMOD_256QAM ? "256QAM" :
521	Demod == DEMOD_QAM ? "QAM" :
522	Demod == DEMOD_NTSC ? "NTSC" :
523	Demod == DEMOD_ISDBT ? "ISDB-T" :
524	Demod == DEMOD_ISDBT_MANUAL ? "ISDB-T Manual" :
525	Demod == DEMOD_MODEA ? "MODEA" :
526	Demod == DEMOD_MODEB ? "MODEB" : "Unknown");
527	}
528	}
529	#endif
530
531	//
532	// Monitor Thread Activate´Â Callback Function È£Ãâ ÀÌÈÄ¿¡...
533	//
534	if ( Tuner == TUNER_FAT ) {
535	pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK;
536	pDSTFETuner->bThreadActive = _TRUE_;
537	}
538
539	done:
540	/* Give the MUTEX */
541
542
543	return dhlResult;
544	}
545
546	/****************************************************************************
547
548	DHL_RESULT DHL_FE_Stop
549	- Summary : Stop the Tuner.
550	- Argument
551	TunerType { TUNER_FAT, TUNER_FDC }
552
553	- Returns : DHL_OK on success, DHL_FAIL on failure
554
555	***************************************************************************/
556	DHL_RESULT DHL_FE_Stop( TunerType Tuner )
557	{
558	P_DST_FE pDSTFETuner;
559	DHL_RESULT dhlResult;
560
561	if ( Tuner >= TUNER_MAX \|\| Tuner <= TUNER_UNKNOWN ) {
562	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner );
563	return DHL_FAIL;
564	}
565
566	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
567
568	/* Take the MUTEX */
569
570
571
572	/* State Checking */
573	if ( pDSTFETuner->bCurState != TUNERSTATE_START ) {
574	//DHL_DbgPrintf( 0, DHLDBG_FE, " WARNING: Tuner State is NOT TUNERSTATE_START, %d\n", pDSTFETuner->bCurState );
575	dhlResult = DHL_OK;
576	goto done;
577	}
578
579	/* Call the lower device driver */
580	dhlResult = DD_FE_Stop( pDSTFETuner );
581	if ( dhlResult != DHL_OK )
582	goto done;
583
584	pDSTFETuner->bCurState = TUNERSTATE_STOP;
585	if ( Tuner == TUNER_FAT ) {
586	pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK;
587	pDSTFETuner->bThreadActive = _FALSE_;
588	}
589
590	done:
591	/* Give the MUTEX */
592
593
594	return dhlResult;
595	}
596
597	/****************************************************************************
598
599	DHL_RESULT DHL_FE_Close
600	- Summary
601	Close Front End. (Used to re-initialize FE.)
602	- Argument
603	TunerType { TUNER_FAT, TUNER_FDC }
604	- Returns
605	DHL_OK on success, DHL_FAIL on failure.
606	- Note
607
608	***************************************************************************/
609	DHL_RESULT DHL_FE_Close( TunerType Tuner )
610	{
611	P_DST_FE pDSTFETuner;
612	DHL_RESULT dhlResult = DHL_OK;
613
614	if ( Tuner >= TUNER_MAX \|\| Tuner <= TUNER_UNKNOWN ) {
615	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner );
616	return DHL_FAIL;
617	}
618
619	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
620
621	/* Take the MUTEX */
622
623
624
625	/* State Checking */
626	if ( pDSTFETuner->bCurState == TUNERSTATE_UNKNOWN )
627	{
628	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: This tuner is not initialized or closed already.\n" );
629	dhlResult = DHL_FAIL;
630	goto done;
631	}
632
633	if ( (pDSTFETuner->bCurState == TUNERSTATE_START) \|\| (pDSTFETuner->bCurState == TUNERSTATE_INIT) )
634	{
635	dhlResult = DD_FE_Stop( pDSTFETuner );
636	if ( dhlResult != DHL_OK )
637	goto done;
638	pDSTFETuner->bCurState = TUNERSTATE_STOP;
639	}
640
641	/* Call the lower device driver */
642	dhlResult = DD_FE_Close( pDSTFETuner );
643	if ( dhlResult != DHL_OK )
644	goto done;
645
646	pDSTFETuner->bTuner = TUNER_UNKNOWN;
647	pDSTFETuner->bCurState = TUNERSTATE_UNKNOWN;
648
649	pDSTFETuner->bFreqStd = FREQ_UNKNOWN; /* Default AIR */
650	pDSTFETuner->bCurDemod = DEMOD_UNKNOWN; /* Default 8VSB */
651	pDSTFETuner->bChannel = 0;
652	pDSTFETuner->uFrequency = 0;
653
654	done:
655	/* Give the MUTEX */
656
657
658
659	return dhlResult;
660	}
661
662	/****************************************************************************
663
664	DHL_RESULT DHL_FE_SetCallback
665	- Summary
666	Register/Unregister FE Callback Function.
667	- Argument
668	TunerType { TUNER_FAT, TUNER_FDC }
669	FECallbackSource { FECALLBACK_ACQSTART, FECALLBACK_LOCK, FECALLBACK_UNLOCK }
670	P_DHL_FE_CALLBACK fn, if fn is NULL, then unregister FE callback function.
671	DS_U32 userArg, passed to fn.
672	- Returns : DHL_OK on success, DHL_FAIL on failure
673	- Note
674	typedef void (*P_DHL_FE_CALLBACK)(TunerType Tuner,
675	FECallbackSource eventSource,
676	DS_U32 userArg);
677
678	***************************************************************************/
679	DHL_RESULT DHL_FE_SetCallback( TunerType Tuner, FECallbackSource eventSource,
680	P_DHL_FE_CALLBACK fn, DS_U32 userArg )
681	{
682	DHL_RESULT dhlResult = DHL_OK;
683	P_DST_FE pDSTFETuner;
684
685	if ( (Tuner >= TUNER_MAX) \|\| (Tuner <= TUNER_UNKNOWN) ) {
686	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner );
687	return DHL_FAIL;
688	}
689
690	if ( (eventSource >= FECALLBACK_MAX) \|\| (eventSource <= FECALLBACK_UNKNOWN) ) {
691	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Callback Event Source is invalid, %d\n", eventSource );
692	return DHL_FAIL;
693	}
694
695	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
696
697	/* Take the MUTEX */
698
699
700
701	/* State Checking */
702	if ( (pDSTFETuner->bCurState != TUNERSTATE_INIT) && (pDSTFETuner->bCurState != TUNERSTATE_STOP) ) {
703	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Should be called TUNERSTATE_INIT or TUNERSTATE_STOP, bCurState= %d\n", pDSTFETuner->bCurState );
704	dhlResult = DHL_FAIL;
705	goto done;
706	}
707
708	pDSTFETuner->fnFECallback[eventSource-1] = fn;
709	pDSTFETuner->FECallbackUserArg[eventSource-1] = userArg;
710
711	done:
712	/* Give the MUTEX */
713
714
715
716	return dhlResult;
717	}
718
719	DHL_RESULT DHL_FE_SetCallbackNTSC( TunerType Tuner, FECallbackSource eventSource,
720	P_DHL_FE_CALLBACK fn, DS_U32 userArg )
721	{
722	DHL_RESULT dhlResult = DHL_OK;
723	P_DST_FE pDSTFETuner;
724
725	if ( Tuner != TUNER_FAT ) {
726	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner );
727	return DHL_FAIL;
728	}
729
730	if ( (eventSource >= FECALLBACK_MAX) \|\| (eventSource <= FECALLBACK_UNKNOWN) ) {
731	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Callback Event Source is invalid, %d\n", eventSource );
732	return DHL_FAIL;
733	}
734
735	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
736
737	/* Take the MUTEX */
738
739
740
741	pDSTFETuner->fnFECallbackNTSC[eventSource-1] = fn;
742	pDSTFETuner->FECallbackNTSCUserArg[eventSource-1] = userArg;
743
744	/* Give the MUTEX */
745
746
747
748	return dhlResult;
749	}
750
751	/****************************************************************************
752
753	DHL_RESULT DHL_FE_GetLockStatus
754	- Summary : Get the lock status from tuner.
755	- Argument
756	TunerType { TUNER_FAT, TUNER_FDC }
757	pLockStatus : Lock State loaded into.
758	- Returns : DHL_OK on success, DHL_FAIL on failure
759
760	***************************************************************************/
761	DHL_RESULT DHL_FE_GetLockStatus( TunerType Tuner, DS_U8 *pLockStatus )
762	{
763	P_DST_FE pDSTFETuner = (P_DST_FE)0;
764	DS_U8 LockStatus;
765	DHL_RESULT dhlResult = DHL_OK;
766
767	if ( (Tuner >= TUNER_MAX) \|\| (Tuner <= TUNER_UNKNOWN) ) {
768	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner );
769	return DHL_FAIL;
770	}
771
772	/* Argument Checking */
773	if ( pLockStatus == (DS_U8 *)0 ) {
774	return DHL_FAIL;
775	}
776
777	/* Take the MUTEX */
778
779
780	/* Tuner State Checking */
781	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
782	if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) \|\| (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) {
783	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState );
784	dhlResult = DHL_FAIL;
785	goto done;
786	}
787
788	/* Put invalid on DST_FE information */
789	pDSTFETuner->bLockStatus = -1;
790
791	dhlResult = DD_FE_GetLockStatus( pDSTFETuner, &LockStatus );
792	if ( dhlResult != DHL_OK ) {
793	*pLockStatus = 0;
794	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetLockStatus()\n" );
795	goto done;
796	}
797
798	pDSTFETuner->bLockStatus = LockStatus;
799	*pLockStatus = LockStatus;
800
801	if ( g_force_ss == 1 ) {
802	*pLockStatus= 1;
803	} else if ( g_force_ss == 2 ) {
804	*pLockStatus= 0;
805	}
806
807	done:
808	/* Give the MUTEX */
809
810
811	return dhlResult;
812	}
813
814	/****************************************************************************
815
816	DHL_RESULT DHL_FE_GetModFormat
817	- Summary : Get the modulation format from tuner.
818	- Argument
819	TunerType { TUNER_FAT, TUNER_FDC }
820	pModFormat : Modulation Format
821	- Returns : DHL_OK on success, DHL_FAIL on failure
822
823	***************************************************************************/
824	DHL_RESULT DHL_FE_GetModFormat( TunerType Tuner, TunerDemod *pModFormat )
825	{
826	P_DST_FE pDSTFETuner = (P_DST_FE)0;
827	DHL_RESULT dhlResult = DHL_OK;
828	TunerDemod ModFormat;
829
830	if ( (Tuner >= TUNER_MAX) \|\| (Tuner <= TUNER_UNKNOWN) ) {
831	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner );
832	return DHL_FAIL;
833	}
834
835	/* Argument Checking */
836	if ( pModFormat == (TunerDemod *)0 ) {
837	return DHL_FAIL;
838	}
839
840	/* Take the MUTEX */
841
842
843	/* Tuner State Checking */
844	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
845	if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) \|\| (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) {
846	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState );
847	dhlResult = DHL_FAIL;
848	goto done;
849	}
850
851	/* Put invalid on DST_FE information */
852	//pDSTFETuner->bCurDemod = DEMOD_UNKNOWN;
853	*pModFormat = pDSTFETuner->bCurDemod;
854
855	dhlResult = DD_FE_GetModFormat( pDSTFETuner, &ModFormat );
856	if ( dhlResult != DHL_OK ) {
857	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetLockStatus()\n" );
858	goto done;
859	}
860
861	pDSTFETuner->bCurDemod = ModFormat;
862	*pModFormat = ModFormat;
863
864	done:
865	/* Give the MUTEX */
866
867
868	return dhlResult;
869	}
870
871	/****************************************************************************
872
873	DHL_RESULT DHL_FE_GetSNR
874	- Summary : Calculate the demodulator (Equalizer) SNR from SQI.
875	- Arguments
876	TunerType { TUNER_FAT, TUNER_FDC }
877	pSNR : SNR loaded into.
878	- Returns : DHL_OK on success, DHL_FAIL on failure
879	- Note
880	. Valid only if the tuner is locked.
881
882	***************************************************************************/
883	DHL_RESULT DHL_FE_GetSNR( TunerType Tuner, float *pSNR )
884	{
885	P_DST_FE pDSTFETuner = (P_DST_FE)0;
886	DS_U8 LockStatus;
887	DHL_RESULT dhlResult = DHL_OK;
888	float SNR;
889
890	if ( (Tuner >= TUNER_MAX) \|\| (Tuner <= TUNER_UNKNOWN) ) {
891	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner );
892	return DHL_FAIL;
893	}
894
895	/* Argument Checking */
896	if ( pSNR == (float *)0 ) {
897	return DHL_FAIL;
898	}
899
900	/* Take the MUTEX */
901
902
903	/* Tuner State Checking */
904	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
905	if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) \|\| (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) {
906	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState );
907	dhlResult = DHL_FAIL;
908	goto done;
909	}
910
911	dhlResult = DD_FE_GetLockStatus( pDSTFETuner, &LockStatus );
912	if ( dhlResult != DHL_OK ) {
913	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetLockStatus()\n" );
914	dhlResult = DHL_FAIL;
915	goto done;
916	}
917
918	#if 0 /* hwatk/041109, lockÀÌ ¾ÈµÇ¾îµµ snr °Ë»ç¸¦ ÇÒ ¼ö ÀÖ¾î¾ß ÇÔ.. */
919	if ( LockStatus == 0 )
920	{
921	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner is not locked!\n" );
922	dhlResult = DHL_FAIL;
923	goto done;
924	}
925	#endif
926
927	/* Call the lower device driver */
928	dhlResult = DD_FE_GetSNR( pDSTFETuner, &SNR );
929	if ( dhlResult != DHL_OK ) {
930	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetSNR()\n" );
931	dhlResult = DHL_FAIL;
932	goto done;
933	}
934
935	*pSNR = SNR;
936
937	done:
938	/* Give the MUTEX */
939
940	return dhlResult;
941	}
942
943	/****************************************************************************
944
945	DHL_RESULT DHL_FE_GetTrellisSNR
946	- Summary : Get the Trellis Decoder Output SNR.
947	- Arguments
948	TunerType { TUNER_FAT, TUNER_FDC }
949	pTrellisSNR : Trellis SNR loaded into.
950	- Returns : DHL_OK on success, DHL_FAIL on failure.
951	- Note
952	. Valid only if the tuner is FAT. ???
953	. Valid only if the tuner is locked.
954
955	***************************************************************************/
956	DHL_RESULT DHL_FE_GetTrellisSNR( TunerType Tuner, double *pTrellisSNR )
957	{
958	P_DST_FE pDSTFETuner = (P_DST_FE)0;
959	DS_U8 LockStatus;
960	DHL_RESULT dhlResult = DHL_OK;
961	double TrellisSNR;
962
963	if ( Tuner != TUNER_FAT ) {
964	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: This function is excuted only if TUNER_FAT, Tuner = %d\n", Tuner );
965	return DHL_FAIL;
966	}
967
968	/* Argument Checking */
969	if ( pTrellisSNR == (double *)0 ) {
970	return DHL_FAIL;
971	}
972
973	/* Take the MUTEX */
974
975
976	/* Tuner State Checking */
977	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
978	if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) \|\| (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) {
979	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState );
980	dhlResult = DHL_FAIL;
981	goto done;
982	}
983
984	dhlResult = DD_FE_GetLockStatus( pDSTFETuner, &LockStatus );
985	if ( dhlResult != DHL_OK ) {
986	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetLockStatus()\n" );
987	dhlResult = DHL_FAIL;
988	goto done;
989	}
990
991	if ( LockStatus == 0 )
992	{
993	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner is not locked!\n" );
994	dhlResult = DHL_FAIL;
995	goto done;
996	}
997
998	dhlResult = DD_FE_GetTrellisSNR( pDSTFETuner, &TrellisSNR );
999	if ( dhlResult != DHL_OK ) {
1000	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetTrellisSNR()\n" );
1001	dhlResult = DHL_FAIL;
1002	goto done;
1003	}
1004
1005	pDSTFETuner->dTrellisSNR = TrellisSNR;
1006	*pTrellisSNR = TrellisSNR;
1007
1008	done:
1009	/* Give the MUTEX */
1010	return dhlResult;
1011	}
1012
1013	/****************************************************************************
1014
1015	DHL_RESULT DHL_FE_GetSignalStrength
1016	- Summary : Get the SQI (Signal Quality Indicator) from the Tuner.
1017	- Arguments
1018	TunerType { TUNER_FAT, TUNER_FDC }
1019	pSQI : SQI loaded into
1020	- Returns : DHL_OK on success, DHL_FAIL on failure
1021	- Note
1022	. Can be get the signal strength on both locked and unlocked.
1023	- Locked : From Equalizer SNR.
1024	- Unlocked : From Current AGC Value.
1025
1026	***************************************************************************/
1027	DHL_RESULT DHL_FE_GetSignalStrength( TunerType Tuner, DS_U32 *pSQI )
1028	{
1029	P_DST_FE pDSTFETuner = (P_DST_FE)0;
1030	DHL_RESULT dhlResult = DHL_OK;
1031	DS_U32 SQI;
1032
1033	/* Argument checking */
1034	if ( pSQI == (DS_U32 *)0 ) {
1035	return DHL_FAIL;
1036	}
1037
1038	/* Take the MUTEX */
1039
1040
1041	/* Tuner State Checking */
1042	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1043	if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) \|\| (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) {
1044	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState );
1045	dhlResult = DHL_FAIL;
1046	goto done;
1047	}
1048
1049
1050
1051	dhlResult = DD_FE_GetSignalStrength( pDSTFETuner, &SQI );
1052	if ( dhlResult != DHL_OK ) {
1053	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetSignalStrength()\n" );
1054	goto done;
1055	}
1056
1057	pDSTFETuner->uSQI = SQI;
1058	*pSQI = SQI;
1059
1060	if ( g_force_ss == 1 )
1061	{
1062	*pSQI = 100;
1063	}
1064
1065	done:
1066	/* Give the MUTEX */
1067
1068
1069	return dhlResult;
1070	}
1071
1072	DHL_RESULT DHL_FE_GetSignalPower( TunerType Tuner, DS_U32 *pSQI )
1073	{
1074	P_DST_FE pDSTFETuner = (P_DST_FE)0;
1075	DHL_RESULT dhlResult = DHL_OK;
1076	DS_U32 SQI;
1077
1078	/* Argument checking */
1079	if ( pSQI == (DS_U32 *)0 ) {
1080	return DHL_FAIL;
1081	}
1082
1083	/* Take the MUTEX */
1084
1085
1086	/* Tuner State Checking */
1087	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1088	if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) \|\| (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) {
1089	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState );
1090	dhlResult = DHL_FAIL;
1091	goto done;
1092	}
1093
1094	dhlResult = DD_FE_GetSignalPower( pDSTFETuner, &SQI );
1095	if ( dhlResult != DHL_OK ) {
1096	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetSignalStrength()\n" );
1097	goto done;
1098	}
1099
1100	*pSQI = SQI;
1101
1102	if ( g_force_ss == 1 )
1103	{
1104	*pSQI= 100;
1105	}
1106
1107	done:
1108	/* Give the MUTEX */
1109
1110
1111	return dhlResult;
1112	}
1113
1114	/****************************************************************************
1115
1116	DHL_RESULT DHL_FE_GetEqSNR
1117	- Summary : Calculate the demodulator (Equalizer) SNR from SQI.
1118	- Arguments
1119	TunerType { TUNER_FAT, TUNER_FDC }
1120	pSNR : SNR loaded into.
1121	- Returns : DHL_OK on success, DHL_FAIL on failure
1122	- Note
1123	. Valid only if the tuner is locked.
1124
1125	***************************************************************************/
1126	DHL_RESULT DHL_FE_GetEqSNR( TunerType Tuner, float *pSNR )
1127	{
1128	return DHL_FE_GetSNR( Tuner, pSNR );
1129	}
1130
1131	DS_U32 DHL_FE_GetFrequency( TunerType Tuner )
1132	{
1133	P_DST_FE pDSTFETuner = (P_DST_FE)0;
1134
1135	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1136
1137	return DD_FE_GetFrequency(pDSTFETuner);
1138	}
1139
1140	/****************************************************************************
1141
1142	DHL_RESULT DHL_FE_GetRSError
1143	- Summary
1144	Get the Reed-Solomon Decoder Error Count and calculate
1145	error count per unit second.
1146	- Arguments
1147	TunerType { TUNER_FAT, TUNER_FDC }
1148	pRSErrorCnt : RS Decoder Error Count loaded into.
1149	pRSErrorRate : RS Decoder Error Rate loaded into.
1150	- Returns : DHL_OK on success, DHL_FAIL on failure.
1151	- Note
1152	. Valid only if the tuner is FAT.
1153
1154	***************************************************************************/
1155	DHL_RESULT DHL_FE_GetRSError( TunerType Tuner, DS_U32 pRSErrorCnt, float pRSErrorRate )
1156	{
1157	P_DST_FE pDSTFETuner = (P_DST_FE)0;
1158	DS_U8 LockStatus;
1159	DHL_RESULT dhlResult;
1160	DS_U32 RSErrorCnt;
1161	float RSErrorRate;
1162
1163	if ( Tuner != TUNER_FAT ) {
1164	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: This function is valid only if TUNER_FAT, Tuner = %d\n", Tuner );
1165	return DHL_FAIL;
1166	}
1167
1168	if ( (pRSErrorCnt == (DS_U32 )0) \|\| (pRSErrorRate == (float )0) ) {
1169	return DHL_FAIL;
1170	}
1171
1172	/* Take the MUTEX */
1173
1174
1175	/* Tuner State Checking */
1176	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1177	if ( (pDSTFETuner->bCurState <= TUNERSTATE_UNKNOWN) \|\| (pDSTFETuner->bCurState >= TUNERSTATE_MAX) ) {
1178	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is Invalid, %d\n", pDSTFETuner->bCurState );
1179	dhlResult = DHL_FAIL;
1180	goto done;
1181	}
1182
1183	/* Put invalid on DST_FE information */
1184	pDSTFETuner->uRSErrorCnt = -1;
1185	pDSTFETuner->fRSErrorRate = -1.0f;
1186
1187	/* Call the lower device driver */
1188	dhlResult = DD_FE_GetLockStatus( pDSTFETuner, &LockStatus );
1189	if ( dhlResult != DHL_OK ) {
1190	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetLockStatus()\n" );
1191	goto done;
1192	}
1193
1194	if ( LockStatus == 0 )
1195	{
1196	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner is not locked!\n" );
1197	dhlResult = DHL_FAIL;
1198	goto done;
1199	}
1200
1201	/* Call the lower device driver */
1202	dhlResult = DD_FE_GetRSError( pDSTFETuner, &RSErrorCnt, &RSErrorRate );
1203	if ( dhlResult != DHL_OK ) {
1204	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: DD_FE_GetRSError()\n" );
1205	dhlResult = DHL_FAIL;
1206	goto done;
1207	}
1208
1209	pDSTFETuner->uRSErrorCnt = RSErrorCnt;
1210	*pRSErrorCnt = RSErrorCnt;
1211	pDSTFETuner->fRSErrorRate = RSErrorRate;
1212	*pRSErrorRate = RSErrorRate;
1213
1214	done:
1215	/* Give the MUTEX */
1216
1217
1218	return dhlResult;
1219	}
1220
1221	/****************************************************************************
1222
1223	DHL_RESULT DHL_FE_BERTStart
1224	- Summary :
1225	- Arguments
1226	TunerType { TUNER_FAT, TUNER_FDC }
1227	HdrRm - Header Remove Bytes
1228	{ FEBERT_RM_0, FEBERT_RM_1, FEBERT_RM_3, FEBERT_RM_4 }
1229	Source - Source Selection
1230	{ FEBERT_INPUT_FAT, FEBERT_INPUT_DI,
1231	FEBERT_INPUT_FDC, FEBERT_INPUT_TRELLIS }
1232	PNInv - PN Inversion { FEBERT_INVERTED, FEBERT_NON_INVERTED }
1233	PNSeq - PN Sequence { FEBERT_PN_15, FEBERT_PN_23 }
1234	- Returns : DHL_OK on success, DHL_FAIL on failure
1235	- Note
1236
1237	***************************************************************************/
1238	DHL_RESULT DHL_FE_BERTStart( TunerType Tuner, FEBertRm HdrRm, FEBertSource Source,
1239	FEBertPNInv PNInv, FEBertPNSeq PNSeq)
1240	{
1241	DHL_RESULT dhlResult;
1242	P_DST_FE pDSTFETuner;
1243
1244	/* Tuner Id. Checking */
1245	if ( Tuner >= TUNER_MAX \|\| Tuner <= TUNER_UNKNOWN ) {
1246	DHL_DbgPrintf( 0, DHLDBG_FE, "Error : Tuner is unknown!\n" );
1247	return DHL_FAIL;
1248	}
1249
1250	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1251
1252	/* Is BERT started ? */
1253	if ( pDSTFETuner->bBERTStarted == _TRUE_ ) {
1254	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: BERT is already started.\n" );
1255	return DHL_FAIL;
1256	}
1257
1258	/* Take the MUTEX */
1259
1260
1261	/* Tuner State Checking */
1262	if ( pDSTFETuner->bCurState != TUNERSTATE_START ) {
1263	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is NOT TUNERSTATE_START, %d\n", pDSTFETuner->bCurState );
1264	dhlResult = DHL_FAIL;
1265	goto done;
1266	}
1267
1268	/* Call the lower device driver */
1269	dhlResult = DD_FE_BERTStart( pDSTFETuner, HdrRm, Source, PNInv, PNSeq );
1270	if ( dhlResult != DHL_OK )
1271	goto done;
1272
1273	pDSTFETuner->bBERTStarted = _TRUE_;
1274
1275	done:
1276	/* Give the MUTEX */
1277
1278
1279	return dhlResult;
1280	}
1281
1282	/****************************************************************************
1283
1284	DHL_RESULT DHL_FE_BERTStop
1285	- Summary :
1286	- Arguments
1287	TunerType { TUNER_FAT, TUNER_FDC }
1288	- Returns : DHL_OK on success, DHL_FAIL on failure
1289	- Note
1290
1291	***************************************************************************/
1292	DHL_RESULT DHL_FE_BERTStop( TunerType Tuner )
1293	{
1294	DHL_RESULT dhlResult;
1295	P_DST_FE pDSTFETuner;
1296
1297	/* Tuner Id. Checking */
1298	if ( Tuner >= TUNER_MAX \|\| Tuner <= TUNER_UNKNOWN ) {
1299	DHL_DbgPrintf( 0, DHLDBG_FE, "Error : Tuner is unknown!\n" );
1300	return DHL_FAIL;
1301	}
1302
1303	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1304
1305	/* Is BERT started ? */
1306	if ( pDSTFETuner->bBERTStarted == _FALSE_ ) {
1307	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: BERT is already started.\n" );
1308	return DHL_FAIL;
1309	}
1310
1311	/* Take the MUTEX */
1312
1313
1314	/* Tuner State Checking */
1315	if ( pDSTFETuner->bCurState != TUNERSTATE_START ) {
1316	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is NOT TUNERSTATE_START, %d\n", pDSTFETuner->bCurState );
1317	dhlResult = DHL_FAIL;
1318	goto done;
1319	}
1320
1321	/* Call the lower device driver */
1322	dhlResult = DD_FE_BERTStop( pDSTFETuner );
1323	if ( dhlResult != DHL_OK )
1324	goto done;
1325
1326	pDSTFETuner->bBERTStarted = _TRUE_;
1327
1328	done:
1329	/* Give the MUTEX */
1330
1331
1332	return dhlResult;
1333	}
1334
1335	/****************************************************************************
1336
1337	DHL_RESULT DHL_FE_GetBERT
1338	- Summary :
1339	- Arguments
1340	TunerType { TUNER_FAT, TUNER_FDC }
1341	- Returns : DHL_OK on success, DHL_FAIL on failure
1342	- Note
1343
1344	***************************************************************************/
1345	DHL_RESULT DHL_FE_GetBERT( TunerType Tuner, DS_U32 pErrorCnt, float pErrorRate )
1346	{
1347	DHL_RESULT dhlResult = DHL_OK;
1348	P_DST_FE pDSTFETuner;
1349
1350	/* Tuner Id. Checking */
1351	if ( Tuner >= TUNER_MAX \|\| Tuner <= TUNER_UNKNOWN ) {
1352	DHL_DbgPrintf( 0, DHLDBG_FE, "Error : Tuner is unknown!\n" );
1353	return DHL_FAIL;
1354	}
1355
1356	/* Argument Checking */
1357	if ( (pErrorCnt == (DS_U32 )0) \|\| (pErrorRate == (float )0) ) {
1358	DHL_DbgPrintf( 0, DHLDBG_FE, "Error : Arguments are invalid!,\
1359	pErrorCnt = %lx, pErrorRate = %lx", pErrorCnt, pErrorRate );
1360	return DHL_FAIL_NULL_POINTER;
1361	}
1362
1363	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1364
1365	/* Take the MUTEX */
1366
1367
1368	/* Tuner State Checking */
1369	if ( pDSTFETuner->bCurState != TUNERSTATE_START ) {
1370	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Tuner State is NOT TUNERSTATE_START, %d\n", pDSTFETuner->bCurState );
1371	dhlResult = DHL_FAIL;
1372	goto done;
1373	}
1374
1375	/* Put invalid on DST_FE information */
1376	pDSTFETuner->ulBERTErrorCnt = -1;
1377	pDSTFETuner->dBERTErrorRate = -1.0f;
1378	*pErrorCnt = -1;
1379	*pErrorRate = -1.0f;
1380
1381	/* Call the lower device driver */
1382	dhlResult = DD_FE_GetBERT( pDSTFETuner, pErrorCnt, pErrorRate );
1383	if ( dhlResult != DHL_OK )
1384	goto done;
1385
1386	pDSTFETuner->ulBERTErrorCnt = *pErrorCnt;
1387	pDSTFETuner->dBERTErrorRate = *pErrorRate;
1388
1389	done:
1390	/* Give the MUTEX */
1391
1392
1393	return dhlResult;
1394	}
1395
1396	/****************************************************************************
1397
1398	DHL_RESULT DHL_FE_SetFDCConfig
1399	- Summary : FDC °ü·Ã Data Mode ¼³Á¤
1400	- Arguments
1401	TunerType { TUNER_FAT, TUNER_FDC }
1402	RFFreq FDC Frequency
1403	SymbolRate { FDC_SYMBOL_RATE_772, FDC_SYMBOL_RATE_1024, FDC_SYMBOL_RATE_1544 }
1404	ClockPol { FDC_INVERT_SIGNAL, FDC_NO_INVERT_SIGNAL }
1405	DataPol { FDC_INVERT_SIGNAL, FDC_NO_INVERT_SIGNAL }
1406	DecoderMode { FDC_INVERT_SIGNAL, FDC_NO_INVERT_SIGNAL }
1407	- Returns : DHL_OK on success, DHL_FAIL on failure
1408	- Note
1409
1410	***************************************************************************/
1411	DHL_RESULT DHL_FE_SetFDCConfig( TunerType Tuner, DS_U32 RFFreq, FdcSymbolRate_t SymbolRate,
1412	FdcSignalPolarity_t ClockPol, FdcSignalPolarity_t DataPol,
1413	FdcSignalPolarity_t DecoderMode, DS_U32 RefDivider )
1414	{
1415	P_DST_FE pDSTFETuner;
1416	DHL_RESULT dhlResult = DHL_OK;
1417
1418	if ( Tuner >= TUNER_MAX \|\| Tuner <= TUNER_UNKNOWN ) {
1419	DHL_DbgPrintf( 0, DHLDBG_FE, "Error: Selected Tuner is %d\n", Tuner );
1420	return DHL_FAIL;
1421	}
1422
1423	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1424
1425	/* Take the MUTEX */
1426
1427
1428	/* State Checking */
1429	if ( (pDSTFETuner->bCurState != TUNERSTATE_INIT) && (pDSTFETuner->bCurState != TUNERSTATE_STOP) ) {
1430	DHL_DbgPrintf( 0, DHLDBG_FE, " Error: Should be INIT or STOP, %d\n", pDSTFETuner->bCurState );
1431	dhlResult = DHL_FAIL;
1432	goto done;
1433	}
1434
1435
1436	#if 0
1437	/* ÀÌ ÇÔ¼ö¿¡¼´Â ¼³Á¤¸¸ ÇÏ°í, ½ÇÁ¦ Àû¿ëÀº DD_FE_SetChannelFDC()¿¡¼ ÇÏµµ·Ï ÇÔ.
1438	hwatk - 2004.07.28 */
1439
1440	/* Call the lower device driver */
1441	dhlResult = DD_FE_SetFDCConfig( pDSTFETuner, RFFreq, SymbolRate, ClockPol, DataPol, DecoderMode, RefDivider );
1442	if ( dhlResult != DHL_OK )
1443	goto done;
1444	#endif
1445
1446	pDSTFETuner->uFrequency = RFFreq;
1447	pDSTFETuner->FdcSymbolRate = SymbolRate;
1448	pDSTFETuner->FdcClockPolarity = ClockPol;
1449	pDSTFETuner->FdcDataPolarity = DataPol;
1450	pDSTFETuner->FdcDecoderMode = DecoderMode;
1451	pDSTFETuner->RefDivider = RefDivider;
1452
1453	done:
1454	/* Give the MUTEX */
1455
1456
1457	return dhlResult;
1458	}
1459
1460	DHL_RESULT DHL_FE_CheckAlive( TunerType Tuner )
1461	{
1462	DHL_RESULT dhlResult = DHL_OK;
1463	P_DST_FE pDSTFETuner;
1464	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1465
1466	//JFET_20050125
1467	//Remove the Av drop at qam64 channels
1468	//Tempopary
1469	return DHL_OK;
1470
1471	/* Take the MUTEX */
1472
1473
1474
1475	dhlResult = DD_FE_CheckAlive(pDSTFETuner);
1476	if ( dhlResult != DHL_OK ) {
1477	DHL_DbgPrintf( 0, DHLDBG_FE, " Error: line = %d, dhlResult = 0x%x\n", __LINE__, dhlResult );
1478	}
1479
1480	return dhlResult;
1481	}
1482
1483	DHL_RESULT DHL_FE_SetInput( TunerType Tuner, int Cable )
1484	{
1485	DHL_RESULT dhlResult = DHL_OK;
1486	P_DST_FE pDSTFETuner;
1487	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1488
1489	dhlResult = DD_FE_SetInput( pDSTFETuner, Cable );
1490
1491	return dhlResult;
1492	}
1493
1494	DHL_RESULT DHL_FE_SetGPIOC( TunerType Tuner, int mask, int value )
1495	{
1496	DHL_RESULT dhlResult = DHL_OK;
1497	P_DST_FE pDSTFETuner;
1498	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1499
1500	dhlResult = DD_FE_SetGPIOC( pDSTFETuner, mask, value );
1501
1502	return dhlResult;
1503	}
1504
1505	DHL_RESULT DHL_FE_GetGPIOC( TunerType Tuner, int mask, int *value )
1506	{
1507	DHL_RESULT dhlResult = DHL_OK;
1508	P_DST_FE pDSTFETuner;
1509	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1510
1511	dhlResult = DD_FE_GetGPIOC( pDSTFETuner, mask, value );
1512
1513	return dhlResult;
1514	}
1515
1516	DHL_RESULT DHL_FE_GetAudioMode( TunerType Tuner, FEAudioMode_t audioMode, FEAudioStandard_t audioStandard )
1517	{
1518	DHL_RESULT dhlResult = DHL_OK;
1519	P_DST_FE pDSTFETuner;
1520	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1521
1522	dhlResult = DD_FE_GetAudioMode( audioMode, audioStandard );
1523
1524	return dhlResult;
1525	}
1526
1527	DHL_RESULT DHL_FE_SetAudioMode( TunerType Tuner, FEAudioMode_t audioMode, FEAudioStandard_t audioStandard )
1528	{
1529	DHL_RESULT dhlResult = DHL_OK;
1530	P_DST_FE pDSTFETuner;
1531	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1532
1533	/*
1534	* Just before Audio Mode Change, have to do audio mute.
1535	* (or equivalent function such as Fade Out).
1536	*/
1537	if ( DHL_AUD_IsMainMuted() == _FALSE_ )
1538	{
1539	DD_AUD_VolumeFadeInOut_I2S(0);
1540	if (g_PreAudioModeDelay)
1541	OS_mDelay(g_PreAudioModeDelay);
1542	}
1543
1544	if ( DHL_IsVideoSourceATV(DHL_CAP_GetVideoSrc(0)) == 0 )
1545	{
1546	DHL_DbgPrintf( 0, DHLDBG_FE, " Error: line = %d, Current Mode is Not ATV mode", __LINE__);
1547	dhlResult = DHL_FAIL;
1548	goto done;
1549
1550	}
1551
1552	dhlResult = DD_FE_SetAudioMode( audioMode, audioStandard );
1553	SysASSERT( dhlResult == DHL_OK );
1554
1555	/*
1556	* Just after Audio Mode Change, have to release audio mute.
1557	* (or equivalent function such as Fade In).
1558	*/
1559	if ( DHL_AUD_IsMainMuted() == _FALSE_ )
1560	{
1561	if (g_AftAudioModeDelay)
1562	OS_mDelay(g_AftAudioModeDelay);
1563
1564	DD_AUD_VolumeFadeInOut_I2S(1);
1565	}
1566
1567	done:
1568	return dhlResult;
1569	}
1570
1571	DHL_RESULT DHL_FE_SetCarrierMute( TunerType Tuner, DS_BOOL bEn )
1572	{
1573	DHL_RESULT dhlResult = DHL_OK;
1574	P_DST_FE pDSTFETuner;
1575	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1576
1577	pDSTFETuner->bCarrierMute = bEn;
1578
1579	return dhlResult;
1580	}
1581
1582
1583	DHL_RESULT DHL_FE_SetFrequency( TunerType Tuner, DS_U32 Frequency, TunerDemod Demod )
1584	{
1585	DHL_RESULT dhlResult = DHL_OK;
1586	P_DST_FE pDSTFETuner;
1587
1588	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1589	dhlResult = DD_FE_SetFrequency( pDSTFETuner, Frequency, Demod, 1 );
1590
1591	pDSTFETuner->bCurDemod = Demod;
1592
1593	//
1594	// Digital CallbackÀ» »ç¿ëÇÏÁö ¾Ê´Â °æ¿ì, (ÇÏÀ§ FE Driver°¡ Áö¿øÇÏ´Â °æ¿ì)
1595	// NTSC Callback Function¸¸À» »ç¿ëÇÏµµ·Ï ÇÔ.
1596	//
1597	#if USE_NTSCCALLBACK
1598	if ( pDSTFETuner->bCurDemod == DEMOD_NTSC )
1599	{
1600	if ( pDSTFETuner->fnFECallbackNTSC[FECALLBACK_ACQSTART-1] )
1601	(pDSTFETuner->fnFECallbackNTSC[FECALLBACK_ACQSTART-1])(pDSTFETuner->bTuner, FECALLBACK_ACQSTART, pDSTFETuner->FECallbackNTSCUserArg[FECALLBACK_ACQSTART-1]);
1602
1603	if ( g_fe_debug )
1604	{
1605	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[FAT] %s Acqusition start.\n", Demod == DEMOD_8VSB ? "8VSB" :
1606	Demod == DEMOD_64QAM ? "64QAM" :
1607	Demod == DEMOD_256QAM ? "256QAM" :
1608	Demod == DEMOD_QAM ? "QAM" :
1609	Demod == DEMOD_NTSC ? "NTSC" :
1610	Demod == DEMOD_ISDBT ? "ISDB-T" :
1611	Demod == DEMOD_ISDBT_MANUAL ? "ISDB-T Manual" :
1612	Demod == DEMOD_MODEA ? "MODEA" :
1613	Demod == DEMOD_MODEB ? "MODEB" : "Unknown");
1614	}
1615	}
1616	#endif
1617
1618	#if USE_DIGITAL_CALLBACK
1619	if ( pDSTFETuner->bCurDemod != DEMOD_NTSC )
1620	{
1621	if ( pDSTFETuner->fnFECallback[FECALLBACK_ACQSTART-1] )
1622	(pDSTFETuner->fnFECallback[FECALLBACK_ACQSTART-1])(pDSTFETuner->bTuner, FECALLBACK_ACQSTART, pDSTFETuner->FECallbackUserArg[FECALLBACK_ACQSTART-1]);
1623
1624	if ( g_fe_debug )
1625	{
1626	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[FAT] %s Acqusition start.\n", Demod == DEMOD_8VSB ? "8VSB" :
1627	Demod == DEMOD_64QAM ? "64QAM" :
1628	Demod == DEMOD_256QAM ? "256QAM" :
1629	Demod == DEMOD_QAM ? "QAM" :
1630	Demod == DEMOD_NTSC ? "NTSC" :
1631	Demod == DEMOD_ISDBT ? "ISDB-T" :
1632	Demod == DEMOD_ISDBT_MANUAL ? "ISDB-T Manual" :
1633	Demod == DEMOD_MODEA ? "MODEA" :
1634	Demod == DEMOD_MODEB ? "MODEB" : "Unknown");
1635	}
1636	}
1637	#endif
1638
1639	//
1640	// Monitor Thread Activate´Â Callback Function È£Ãâ ÀÌÈÄ¿¡...
1641	//
1642	if ( Tuner == TUNER_FAT )
1643	{
1644	pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK;
1645	pDSTFETuner->bThreadActive = _TRUE_;
1646	}
1647
1648	return dhlResult;
1649	}
1650
1651	#if 0
1652	___Analog_Tune_Functions___()
1653	#endif
1654
1655	/****************************************************************************
1656
1657	Analog (NTSC) Search/Tune Function
1658
1659	DHL_FE_AnalogFullSearch() Full Search ÇÔ¼ö / TDA9885 ±â¹Ý
1660	DHL_FE_AnalogShortSearch() Short Search ÇÔ¼ö / TDA9885 ±â¹Ý
1661	DHL_FE_FullSearchEx() Full Search ÇÔ¼ö / ORION ±â¹Ý
1662
1663
1664	Sanyo Tuner ¾Ë°í¸®Áò.
1665	1. 450 kHz ´ÜÀ§·Î, 0ÀÎ ÁöÁ¡À» °Ë»ö.
1666	2. 100 kHz ´ÜÀ§·Î °¨¼Ò½ÃÅ°¸ç, Edge ÁöÁ¡À» Ã£À½.
1667	3. 50 khz ´ÜÀ§·Î Áõ°¡½ÃÅ°¸ç, ÃÖÀû ÁÖÆÄ¼ö¸¦ Ã£À½.
1668
1669	****************************************************************************/
1670	typedef union{
1671	struct{
1672	#if 0
1673	unsigned PONR :1;
1674	signed AFC :4; // AFC4, AFC3, AFC2, AFC1
1675	unsigned FMIFL :1;
1676	unsigned VIFL :1;
1677	unsigned AFCWIN :1;
1678	#else
1679	unsigned AFCWIN :1;
1680	unsigned VIFL :1;
1681	unsigned FMIFL :1;
1682	signed AFC :4; // AFC4, AFC3, AFC2, AFC1
1683	unsigned PONR :1;
1684	#endif
1685	} Part; // ±¸Á¶Ã¼ ¸É¹ö Á¢±Ù
1686	DS_U8 Byte; // ¹ÙÀÌÆ® Á¢±Ù
1687	}UTda9885ReadReg;
1688
1689	#define SEARCH_FREQ_STEP_SANYO 125 // 500 kHz
1690	#define SEARCH_FREQ_FINE_STEP1 125 // 125 kHz
1691	#define SEARCH_FREQ_FINE_STEP2 62.50 // 62.50 kHz
1692
1693	/*****************************************************************************
1694
1695	AnalogCheckChannelStart()
1696	AnalogCheckChannel()
1697	AnalogOneChannelSearch()
1698	AnalogSearchEnd()
1699
1700	- Summary: TDA9885 ±â¹ÝÀÇ NTSC Signal ¿©ºÎ °Ë»ç ÇÔ¼ö.
1701
1702	****************************************************************************/
1703	int AnalogIsSignal(DS_U8 afc_status)
1704	{
1705	#if NIMTN_TYPE==NIMTN_U7A06 \|\| NIMTN_TYPE==NIMTN_U7A26
1706
1707	#if 0
1708	DS_U8 lockStatus = 0;
1709	OS_mDelay(100);
1710	DHL_FE_AnalogGetLockStatus( TUNER_FAT, &lockStatus );
1711	if (lockStatus)
1712	return afc_status <= 2;
1713	else
1714	return 0;
1715	#else
1716	return afc_status <= 2;
1717	#endif
1718
1719	#else
1720	return afc_status != 7 && afc_status != 8;
1721	#endif
1722	}
1723
1724	static char AnalogCheckChannelStart( TunerType Tuner, float freq, DS_BOOL (fnCancelCk1)(), DS_BOOL (fnCancelCk2)() )
1725	{
1726	P_DST_FE pDSTFETuner;
1727	DHL_RESULT dhlResult = DHL_OK;
1728	DS_U8 afc_status = 0xFF;
1729	#if NIMTN_TYPE==NIMTN_TDQU \|\| NIMTN_TYPE==NIMTN_U7A06 \|\| NIMTN_TYPE==NIMTN_U7A26
1730	DS_U8 tdaData;
1731	#elif NIMTN_TYPE==NIMTN_TDQU
1732	UTda9885ReadReg tdaData;
1733	#endif
1734	// int retry = 0;
1735
1736	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1737
1738	dhlResult = DD_FE_SetFrequency( pDSTFETuner, (DS_U32)(freq * 1000), DEMOD_NTSC, 1 );
1739	if ( dhlResult != DHL_OK )
1740	{
1741	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__);
1742	goto done;
1743	}
1744
1745	MDELAY(200);
1746
1747	//
1748	// Ã³À½ Æ©´× ÈÄ 200 mSec ±â´Ù¸². (100msec --> 200msec / 2007.04.06 hwatk)
1749	// --> Ã¤³ÎÀÌ BAND°£¿¡ º¯°æµÈ °æ¿ì, TDA9885 Status º¯°æ¿¡ ½Ã°£ÀÌ °É¸².
1750	//
1751	#if NIMTN_TYPE==NIMTN_TDQU
1752
1753	dhlResult = DD_FE_GetTdquReg( pDSTFETuner, (DS_U8 *)&tdaData );
1754	if ( dhlResult != DHL_OK )
1755	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__);
1756	afc_status=tdaData;
1757	#elif NIMTN_TYPE==NIMTN_DTT7611
1758	dhlResult = DD_FE_GetTDA9885Reg( pDSTFETuner, (DS_U8 *)&tdaData );
1759	if ( dhlResult != DHL_OK )
1760	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__);
1761
1762	afc_status = tdaData.Part.AFC;
1763	#elif NIMTN_TYPE==NIMTN_U7A06
1764	do {
1765	OS_mDelay(10);
1766
1767	dhlResult = DD_FE_GetAFCReg( pDSTFETuner, (DS_U8 *)&tdaData );
1768	if ( dhlResult != DHL_OK )
1769	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__);
1770
1771	afc_status = tdaData & 0x7;
1772
1773	// If cancel is raised, then just return with afc_status = unlock (-8).
1774	if ( fnCancelCk1 ) {
1775	if ( fnCancelCk1() ) {
1776	afc_status = 8;
1777	goto done;
1778	}
1779	}
1780	if ( fnCancelCk2 ) {
1781	if ( fnCancelCk2() ) {
1782	afc_status = 8;
1783	goto done;
1784	}
1785	}
1786
1787	} while( !(tdaData & 0x40) );
1788	#elif NIMTN_TYPE==NIMTN_U7A26
1789	do {
1790	OS_mDelay(10);
1791
1792	dhlResult = DD_FE_GetAFCReg( pDSTFETuner, (DS_U8 *)&tdaData );
1793	if ( dhlResult != DHL_OK )
1794	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__);
1795
1796	afc_status = tdaData & 0x7;
1797
1798	// If cancel is raised, then just return with afc_status = unlock (-8).
1799	if ( fnCancelCk1 ) {
1800	if ( fnCancelCk1() ) {
1801	afc_status = 8;
1802	goto done;
1803	}
1804	}
1805	if ( fnCancelCk2 ) {
1806	if ( fnCancelCk2() ) {
1807	afc_status = 8;
1808	goto done;
1809	}
1810	}
1811
1812	} while( !(tdaData & 0x40) );
1813	#endif
1814
1815	done:
1816	return afc_status;
1817	}
1818
1819	static char AnalogCheckChannel( TunerType Tuner, float freq, DS_BOOL (fnCancelCk1)(), DS_BOOL (fnCancelCk2)() )
1820	{
1821	P_DST_FE pDSTFETuner;
1822	DHL_RESULT dhlResult = DHL_OK;
1823	char afc_status;
1824	#if NIMTN_TYPE==NIMTN_TDQU \|\| NIMTN_TYPE==NIMTN_U7A06 \|\| NIMTN_TYPE==NIMTN_U7A26
1825	char tdaData;
1826	#elif NIMTN_TYPE==NIMTN_DTT7611
1827	UTda9885ReadReg tdaData;
1828	#endif
1829	int retry = 0;
1830
1831	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1832
1833	dhlResult = DD_FE_SetFrequency( pDSTFETuner, (DS_U32)(freq * 1000), DEMOD_NTSC, 0 );
1834	if ( dhlResult != DHL_OK )
1835	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__);
1836	#if NIMTN_TYPE==NIMTN_TDQU
1837	dhlResult = DD_FE_GetTdquReg( pDSTFETuner, (DS_U8*)&tdaData );
1838	if ( dhlResult != DHL_OK )
1839	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__);
1840
1841	afc_status =(char) tdaData;
1842	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "++++Tdqu AFT==0x%x\n",afc_status);
1843
1844	#elif NIMTN_TYPE==NIMTN_DTT7611
1845
1846	dhlResult = DD_FE_GetTDA9885Reg( pDSTFETuner, (DS_U8 *)&tdaData );
1847	if ( dhlResult != DHL_OK )
1848	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__);
1849
1850	afc_status = tdaData.Part.AFC;
1851	#elif NIMTN_TYPE==NIMTN_U7A06
1852	retry = 0;
1853	do {
1854	OS_mDelay(10);
1855
1856	dhlResult = DD_FE_GetAFCReg( pDSTFETuner, (DS_U8 *)&tdaData );
1857	if ( dhlResult != DHL_OK )
1858	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__);
1859
1860	afc_status = tdaData & 0x7;
1861
1862	// If cancel is raised, then just return with afc_status = unlock (-8).
1863	if ( fnCancelCk1 ) {
1864	if ( fnCancelCk1() ) {
1865	afc_status = 8;
1866	goto done;
1867	}
1868	}
1869	if ( fnCancelCk2 ) {
1870	if ( fnCancelCk2() ) {
1871	afc_status = 8;
1872	goto done;
1873	}
1874	}
1875	} while( !(tdaData & 0x40) && retry++ < 10 );
1876	#elif NIMTN_TYPE==NIMTN_U7A26
1877	retry = 0;
1878	do {
1879	OS_mDelay(10);
1880
1881	dhlResult = DD_FE_GetAFCReg( pDSTFETuner, (DS_U8 *)&tdaData );
1882	if ( dhlResult != DHL_OK )
1883	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__);
1884
1885	afc_status = tdaData & 0x7;
1886
1887	// If cancel is raised, then just return with afc_status = unlock (-8).
1888	if ( fnCancelCk1 ) {
1889	if ( fnCancelCk1() ) {
1890	afc_status = 8;
1891	goto done;
1892	}
1893	}
1894	if ( fnCancelCk2 ) {
1895	if ( fnCancelCk2() ) {
1896	afc_status = 8;
1897	goto done;
1898	}
1899	}
1900	} while( !(tdaData & 0x40) && retry++ < 10 );
1901	#else
1902	afc_status = 0xFF;
1903
1904	#endif
1905
1906	done:
1907	return afc_status;
1908	}
1909
1910	static int AnalogOneChannelSearchConfirm( TunerType Tuner, float try_freq, float start_freq, float end_freq, DS_U8 afc_status, DS_BOOL (fnCancelCk1)(), DS_BOOL (*fnCancelCk2)() )
1911	{
1912	int bFound = 0;
1913
1914	if (afc_status <=2 ) {
1915	for(try_freq=try_freq-SEARCH_FREQ_FINE_STEP1; try_freq>=start_freq; try_freq-=SEARCH_FREQ_FINE_STEP1) {
1916	afc_status=AnalogCheckChannel(Tuner, *try_freq, fnCancelCk1, fnCancelCk2);
1917	fprintf(stderr,"\|%s\|%d %d\n",__FUNCTION__,__LINE__,(int)*try_freq);
1918	if (afc_status > 3) {
1919	bFound = 1;
1920	break;
1921	}
1922	}
1923
1924	if (bFound) {
1925	for(try_freq=try_freq+SEARCH_FREQ_FINE_STEP2; try_freq<=end_freq; try_freq+=SEARCH_FREQ_FINE_STEP2) {
1926	afc_status=AnalogCheckChannel(Tuner, *try_freq, fnCancelCk1, fnCancelCk2);
1927	if (afc_status < 3) {
1928	// try_freq -= SEARCH_FREQ_FINE_STEP23;
1929	// AnalogCheckChannel(Tuner,*try_freq);
1930	bFound = 1;
1931	break;
1932	}
1933	}
1934	}
1935	}
1936	return bFound;
1937	}
1938
1939
1940	static char AnalogOneChannelSearch_Sanyo( TunerType Tuner, float start_freq, float end_freq, float step_freq, float tune_freq, DS_BOOL (fnCancelCk1)(), DS_BOOL (*fnCancelCk2)() )
1941	{
1942	P_DST_FE pDSTFETuner;
1943	char afc_status;
1944	float freq;
1945	DS_U8 lockStatus;
1946	volatile DS_U32 startTick;
1947	int bFound = 0;
1948
1949	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
1950
1951	/* ¿ì¼± Center Frequency + 250 kHz·Î Ã£À½. */
1952	freq = (start_freq+end_freq)/2;
1953	freq += SEARCH_FREQ_FINE_STEP1*3;
1954	afc_status = AnalogCheckChannelStart(TUNER_FAT, freq, fnCancelCk1, fnCancelCk2);
1955	if( afc_status==0 ) {
1956	// MDELAY 200
1957	startTick = OS_GetTickCount();
1958	do {
1959	MDELAY(10);
1960
1961	// If cancel is raised, then just return with afc_status = unlock (-8).
1962	if ( fnCancelCk1 ) {
1963	if ( fnCancelCk1() ) {
1964	afc_status = 8;
1965	goto done;
1966	}
1967	}
1968	if ( fnCancelCk2 ) {
1969	if ( fnCancelCk2() ) {
1970	afc_status = 8;
1971	goto done;
1972	}
1973	}
1974
1975	} while ( (OS_GetTickCount()-startTick) < 20 );
1976
1977	startTick = OS_GetTickCount();
1978	do {
1979	lockStatus = 0; // Cortez¿¡¼ ¿¡·¯¸¦ ¹ÝÈ¯ÇÏ´Â °æ¿ì, Àç½ÃµµÇÏµµ·Ï 0À¸·Î ¼³Á¤.
1980	DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus );
1981	if ( lockStatus )
1982	goto done;
1983
1984	// If cancel is raised, then just return with afc_status = unlock (-8).
1985	if ( fnCancelCk1 ) {
1986	if ( fnCancelCk1() ) {
1987	afc_status = 8;
1988	goto done;
1989	}
1990	}
1991	if ( fnCancelCk2 ) {
1992	if ( fnCancelCk2() ) {
1993	afc_status = 8;
1994	goto done;
1995	}
1996	}
1997
1998	MDELAY(50);
1999	} while( (OS_GetTickCount()-startTick) < (g_AnalogSearchDelay/10) );
2000	printf("\|%s:%d\| UNLOCK!\n", __FUNCTION__, __LINE__);
2001	}
2002	#if 0
2003	else{
2004	goto done;
2005	}
2006	#endif
2007	/* ¸ø Ã£¾ÒÀ¸¸é, start_freq ~ end_freq·Î Ã£±â ½ÃÀÛÇÏÀÚ. */
2008	for(freq=start_freq; freq<=end_freq; freq+=step_freq) {
2009	afc_status=AnalogCheckChannel(Tuner, freq, fnCancelCk1, fnCancelCk2);
2010	if(afc_status<=0)//&& H_Sync_Status==1)
2011	{
2012	// MDELAY 200
2013	startTick = OS_GetTickCount();
2014	do {
2015	MDELAY(10);
2016
2017	// If cancel is raised, then just return with afc_status = unlock (-8).
2018	if ( fnCancelCk1 ) {
2019	if ( fnCancelCk1() ) {
2020	afc_status = 8;
2021	goto done;
2022	}
2023	}
2024	if ( fnCancelCk2 ) {
2025	if ( fnCancelCk2() ) {
2026	afc_status = 8;
2027	goto done;
2028	}
2029	}
2030	} while ( (OS_GetTickCount()-startTick) < 20 );
2031
2032	startTick = OS_GetTickCount();
2033	do {
2034	lockStatus = 0; // Cortez¿¡¼ ¿¡·¯¸¦ ¹ÝÈ¯ÇÏ´Â °æ¿ì, Àç½ÃµµÇÏµµ·Ï 0À¸·Î ¼³Á¤.
2035	DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus );
2036	if ( lockStatus )
2037	goto done;
2038	// If cancel is raised, then just return with afc_status = unlock (-8).
2039	if ( fnCancelCk1 ) {
2040	if ( fnCancelCk1() ) {
2041	afc_status = 8;
2042	goto done;
2043	}
2044	}
2045	if ( fnCancelCk2 ) {
2046	if ( fnCancelCk2() ) {
2047	afc_status = 8;
2048	goto done;
2049	}
2050	}
2051
2052	MDELAY(50);
2053	} while( (OS_GetTickCount()-startTick) < (g_AnalogSearchDelay/10) );
2054	printf("\|%s:%d\| UNLOCK!\n", __FUNCTION__, __LINE__);
2055	}
2056	}
2057
2058	done:
2059	//static int AnalogOneChannelSearchConfirm( TunerType Tuner, float try_freq, float start_freq, float end_freq, DS_U8 afc_status )
2060	if (lockStatus && afc_status <=0){
2061	bFound = AnalogOneChannelSearchConfirm( Tuner, &freq, start_freq, end_freq, afc_status, fnCancelCk1, fnCancelCk2 );
2062	}
2063
2064	if (bFound)
2065	*tune_freq = freq;
2066	else
2067	*tune_freq = -1;
2068
2069	return afc_status;
2070	}
2071
2072	#if NIMTN_TYPE==NIMTN_TDQU
2073	static char AnalogOneCenterSearch( TunerType Tuner, float start_freq, float end_freq, float step_freq, float tune_freq, DS_BOOL (fnCancelCk1)(), DS_BOOL (*fnCancelCk2)())
2074	{
2075	P_DST_FE pDSTFETuner;
2076	char afc_status = 0;
2077	DS_U8 lockStatus = 0;
2078	float saved_freq = 0;
2079	int state_cnt = 0;
2080	char status = 0;
2081	float freq;
2082
2083	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
2084	/* ¿ì¼± Center Frequency·Î Ã£À½. */
2085	freq = (start_freq+end_freq)/2 + 400; //
2086	afc_status = AnalogCheckChannelStart( TUNER_FAT, freq, fnCancelCk1, fnCancelCk2);
2087	if(afc_status == 0){ // if correct frequency exist near center frequency
2088	for(freq=(start_freq+end_freq)/2 + 400;freq>=start_freq;freq-=step_freq){
2089	afc_status=AnalogCheckChannel(Tuner, freq, fnCancelCk1, fnCancelCk2);
2090	if(status == 0){
2091	if(afc_status >= 2){
2092	state_cnt++;
2093	saved_freq = freq;
2094	status = 1;
2095	}
2096	}else if(status == 1){
2097	if(afc_status == 3){
2098	state_cnt++;
2099	saved_freq = freq;
2100	}else {
2101	status = 2;
2102	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "*check the frequency**\n");
2103	afc_status=AnalogCheckChannelStart(Tuner, saved_freq, fnCancelCk1, fnCancelCk2);
2104	DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus );
2105	if ( lockStatus ) {
2106	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "**Analog Locked **\n");
2107	status = 2;
2108	afc_status = 3;
2109	*tune_freq = saved_freq;
2110	return afc_status;
2111	}else{
2112	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "**Faked Lock Status**\n");
2113	status = 0;
2114	state_cnt = 0;
2115	saved_freq = 0;
2116	afc_status = 0;
2117	*tune_freq = saved_freq;
2118	return afc_status;
2119	}
2120	}
2121	}
2122	}
2123	}else {
2124	afc_status = 0;
2125	saved_freq = 0;
2126	}
2127
2128	if(saved_freq){
2129	*tune_freq = saved_freq;
2130	}else{
2131	*tune_freq = freq;
2132	}
2133	return afc_status;
2134	}
2135
2136
2137	static char AnalogOneChannelSearchX( TunerType Tuner, float start_freq, float end_freq, float step_freq, float tune_freq, DS_BOOL (fnCancelCk1)(), DS_BOOL (*fnCancelCk2)())
2138	{
2139	P_DST_FE pDSTFETuner;
2140	char afc_status = 0;
2141	float saved_freq = 0;
2142	int state_cnt = 0;
2143	DS_U8 lockStatus = 0;
2144	char status = 0;
2145	char bottom = 0;
2146	float freq;
2147	char first = 0;
2148	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
2149	/* ¿ì¼± Center Frequency·Î Ã£À½. */
2150	for(freq=start_freq; freq<=end_freq; freq+=step_freq) {
2151	if(!first){
2152	afc_status=AnalogCheckChannelStart(Tuner, freq, fnCancelCk1, fnCancelCk2);
2153	first = 1;
2154	}else{
2155	afc_status=AnalogCheckChannel(Tuner,freq, fnCancelCk1, fnCancelCk2);
2156	}
2157	if(status == 0){
2158	if(afc_status <= 3){
2159	state_cnt++;
2160	saved_freq = freq;
2161	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "1");
2162	status = 1;
2163	}
2164	}else if(status == 1){
2165	if(afc_status == 2 \|\| afc_status == 1){
2166	bottom = 1;
2167	}
2168	if(afc_status == 0){
2169	afc_status=AnalogCheckChannelStart(Tuner, saved_freq, fnCancelCk1, fnCancelCk2);
2170	MDELAY(200);
2171	DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus );
2172	if ( lockStatus ) {
2173	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "**Analog Locked **\n");
2174	status = 2;
2175	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "2");
2176	afc_status = 3;
2177	goto finish;
2178	// if(afc_status == 3 \|\| afc_status == 4)
2179	// goto done;
2180	}else{
2181	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "**Faked Lock Status**\n");
2182	status = 0;
2183	state_cnt = 0;
2184	bottom = 0;
2185	saved_freq = 0;
2186	bottom = 0;
2187	}
2188	}else if(afc_status == 4){
2189	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "0");
2190	if(bottom){
2191	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "wrong region\n");
2192	bottom = 0;
2193	}
2194	status = 0;
2195	state_cnt = 0;
2196	bottom = 0;
2197	saved_freq = 0;
2198	}else if(afc_status == 3){
2199	if(bottom){
2200	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "wrong region\n");
2201	saved_freq = freq;
2202	bottom = 0;
2203	}
2204	state_cnt = 1;
2205	}
2206	}
2207	}
2208	afc_status = 0;
2209	finish:
2210	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "status count is %d\n",state_cnt);
2211	if(saved_freq){
2212	*tune_freq = saved_freq;
2213	}else{
2214	*tune_freq = freq;
2215	}
2216	return afc_status;
2217	}
2218	#endif
2219	static char AnalogOneChannelSearch( TunerType Tuner, float start_freq, float end_freq, float step_freq, float tune_freq, DS_BOOL (fnCancelCk1)(), DS_BOOL (*fnCancelCk2)() )
2220	{
2221	P_DST_FE pDSTFETuner;
2222	char afc_status;
2223	float freq;
2224	DS_U8 lockStatus;
2225	volatile DS_U32 startTick;
2226
2227	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
2228
2229	/* ¿ì¼± Center Frequency·Î Ã£À½. */
2230	freq = (start_freq+end_freq)/2;
2231	afc_status = AnalogCheckChannelStart(TUNER_FAT, freq, fnCancelCk1, fnCancelCk2);
2232	printf("\|%s:%d\| afc_status=%d\n", __FUNCTION__, __LINE__, afc_status);
2233
2234	/* Ã£¾ÒÀ¸¸é ³ª°¡ÀÚ. */
2235	#if NIMTN_TYPE==NIMTN_TDQU
2236	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "***AnalogOneChannelSearch****afc_status=%d\n",afc_status);
2237	//if(afc_status != 0 && afc_status != 4 )//&& H_Sync_Status==1)
2238	if(afc_status !=5)//afc_status: error
2239	{
2240	lockStatus = 1;
2241	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "**Analog Locked Directly**\n");
2242	lockStatus = 1;
2243	MDELAY(300);
2244	DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus );
2245	if ( lockStatus ) {
2246	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "**Analog Locked by Directly**\n");
2247	// if(afc_status == 3 \|\| afc_status == 4)
2248	// goto done;
2249	}
2250	}
2251
2252	#elif (NIMTN_TYPE==NIMTN_DTT7611)
2253	if(AnalogIsSignal(afc_status)) {
2254	// MDELAY 200
2255	startTick = OS_GetTickCount();
2256	do {
2257	MDELAY(10);
2258
2259	// If cancel is raised, then just return with afc_status = unlock (-8).
2260	if ( fnCancelCk1 ) {
2261	if ( fnCancelCk1() ) {
2262	afc_status = -8;
2263	goto done;
2264	}
2265	}
2266	if ( fnCancelCk2 ) {
2267	if ( fnCancelCk2() ) {
2268	afc_status = -8;
2269	goto done;
2270	}
2271	}
2272
2273	} while ( (OS_GetTickCount()-startTick) < 20 );
2274
2275	startTick = OS_GetTickCount();
2276	do {
2277	lockStatus = 0; // Cortez¿¡¼ ¿¡·¯¸¦ ¹ÝÈ¯ÇÏ´Â °æ¿ì, Àç½ÃµµÇÏµµ·Ï 0À¸·Î ¼³Á¤.
2278	DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus );
2279	if ( lockStatus )
2280	goto done;
2281
2282	// If cancel is raised, then just return with afc_status = unlock (-8).
2283	if ( fnCancelCk1 ) {
2284	if ( fnCancelCk1() ) {
2285	afc_status = -8;
2286	goto done;
2287	}
2288	}
2289	if ( fnCancelCk2 ) {
2290	if ( fnCancelCk2() ) {
2291	afc_status = -8;
2292	goto done;
2293	}
2294	}
2295
2296	MDELAY(50);
2297	} while( (OS_GetTickCount()-startTick) < (g_AnalogSearchDelay/10) );
2298	printf("\|%s:%d\| UNLOCK!\n", __FUNCTION__, __LINE__);
2299	}
2300	#else
2301	if(afc_status==0) {
2302	// MDELAY 200
2303	startTick = OS_GetTickCount();
2304	do {
2305	MDELAY(10);
2306
2307	// If cancel is raised, then just return with afc_status = unlock (-8).
2308	if ( fnCancelCk1 ) {
2309	if ( fnCancelCk1() ) {
2310	afc_status = -8;
2311	goto done;
2312	}
2313	}
2314	if ( fnCancelCk2 ) {
2315	if ( fnCancelCk2() ) {
2316	afc_status = -8;
2317	goto done;
2318	}
2319	}
2320
2321	} while ( (OS_GetTickCount()-startTick) < 20 );
2322
2323	startTick = OS_GetTickCount();
2324	do {
2325	lockStatus = 0; // Cortez¿¡¼ ¿¡·¯¸¦ ¹ÝÈ¯ÇÏ´Â °æ¿ì, Àç½ÃµµÇÏµµ·Ï 0À¸·Î ¼³Á¤.
2326	DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus );
2327	if ( lockStatus )
2328	goto done;
2329
2330	// If cancel is raised, then just return with afc_status = unlock (-8).
2331	if ( fnCancelCk1 ) {
2332	if ( fnCancelCk1() ) {
2333	afc_status = -8;
2334	goto done;
2335	}
2336	}
2337	if ( fnCancelCk2 ) {
2338	if ( fnCancelCk2() ) {
2339	afc_status = -8;
2340	goto done;
2341	}
2342	}
2343
2344	MDELAY(50);
2345	} while( (OS_GetTickCount()-startTick) < (g_AnalogSearchDelay/10) );
2346	printf("\|%s:%d\| UNLOCK!\n", __FUNCTION__, __LINE__);
2347	}
2348
2349	#endif
2350
2351
2352	/* ¸ø Ã£¾ÒÀ¸¸é, start_freq ~ end_freq·Î Ã£±â ½ÃÀÛÇÏÀÚ. */
2353	for(freq=start_freq; freq<=end_freq; freq+=step_freq) {
2354	afc_status=AnalogCheckChannel(Tuner, freq, fnCancelCk1, fnCancelCk2);
2355	#if NIMTN_TYPE==NIMTN_TDQU
2356	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "********Frequency Checking********\n");
2357	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "***AnalogOneChannelSearch****afc_status=%d\n",afc_status);
2358	//if(afc_status !=0 && afc_status != 4)//&& H_Sync_Status==1)
2359	if(afc_status !=5)
2360	{
2361	lockStatus = 1;
2362	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "**Analog Locked by AFT**\n");
2363	MDELAY(300);
2364	DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus );
2365	if ( lockStatus ) {
2366	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "**Analog Locked by AFT**\n");
2367	// if(afc_status == 3 \|\| afc_status == 4)
2368	// goto done;
2369	}
2370	}
2371
2372	#elif (NIMTN_TYPE==NIMTN_DTT7611)
2373	if(AnalogIsSignal(afc_status))//&& H_Sync_Status==1)
2374	{
2375	// MDELAY 200
2376	startTick = OS_GetTickCount();
2377	do {
2378	MDELAY(10);
2379
2380	// If cancel is raised, then just return with afc_status = unlock (-8).
2381	if ( fnCancelCk1 ) {
2382	if ( fnCancelCk1() ) {
2383	afc_status = -8;
2384	goto done;
2385	}
2386	}
2387	if ( fnCancelCk2 ) {
2388	if ( fnCancelCk2() ) {
2389	afc_status = -8;
2390	goto done;
2391	}
2392	}
2393	} while ( (OS_GetTickCount()-startTick) < 20 );
2394
2395	startTick = OS_GetTickCount();
2396	do {
2397	lockStatus = 0; // Cortez¿¡¼ ¿¡·¯¸¦ ¹ÝÈ¯ÇÏ´Â °æ¿ì, Àç½ÃµµÇÏµµ·Ï 0À¸·Î ¼³Á¤.
2398	DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus );
2399	if ( lockStatus )
2400	goto done;
2401
2402	// If cancel is raised, then just return with afc_status = unlock (-8).
2403	if ( fnCancelCk1 ) {
2404	if ( fnCancelCk1() ) {
2405	afc_status = -8;
2406	goto done;
2407	}
2408	}
2409	if ( fnCancelCk2 ) {
2410	if ( fnCancelCk2() ) {
2411	afc_status = -8;
2412	goto done;
2413	}
2414	}
2415
2416	MDELAY(50);
2417	} while( (OS_GetTickCount()-startTick) < (g_AnalogSearchDelay/10) );
2418	printf("\|%s:%d\| UNLOCK!\n", __FUNCTION__, __LINE__);
2419	}
2420	#else
2421	if(afc_status==0)//&& H_Sync_Status==1)
2422	{
2423	// MDELAY 200
2424	startTick = OS_GetTickCount();
2425	do {
2426	MDELAY(10);
2427
2428	// If cancel is raised, then just return with afc_status = unlock (-8).
2429	if ( fnCancelCk1 ) {
2430	if ( fnCancelCk1() ) {
2431	afc_status = -8;
2432	goto done;
2433	}
2434	}
2435	if ( fnCancelCk2 ) {
2436	if ( fnCancelCk2() ) {
2437	afc_status = -8;
2438	goto done;
2439	}
2440	}
2441	} while ( (OS_GetTickCount()-startTick) < 20 );
2442
2443	startTick = OS_GetTickCount();
2444	do {
2445	lockStatus = 0; // Cortez¿¡¼ ¿¡·¯¸¦ ¹ÝÈ¯ÇÏ´Â °æ¿ì, Àç½ÃµµÇÏµµ·Ï 0À¸·Î ¼³Á¤.
2446	DHL_FE_AnalogGetLockStatus( Tuner, &lockStatus );
2447	if ( lockStatus )
2448	goto done;
2449
2450	// If cancel is raised, then just return with afc_status = unlock (-8).
2451	if ( fnCancelCk1 ) {
2452	if ( fnCancelCk1() ) {
2453	afc_status = -8;
2454	goto done;
2455	}
2456	}
2457	if ( fnCancelCk2 ) {
2458	if ( fnCancelCk2() ) {
2459	afc_status = -8;
2460	goto done;
2461	}
2462	}
2463
2464	MDELAY(50);
2465	} while( (OS_GetTickCount()-startTick) < (g_AnalogSearchDelay/10) );
2466	printf("\|%s:%d\| UNLOCK!\n", __FUNCTION__, __LINE__);
2467	}
2468	#endif
2469	}
2470	#if NIMTN_TYPE!=NIMTN_TDQU
2471	done:
2472	#endif
2473	*tune_freq = freq;
2474	return afc_status;
2475	}
2476
2477	static char AnalogSearchEnd(TunerType Tuner, float freq, char afc_status, float *tune_freq)
2478	{
2479	#if NIMTN_TYPE==NIMTN_TDQU
2480	char afc = afc_status;
2481	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "*****AnalogSearchEnd***Afc_Freq=%d\n",afc_status);
2482	#if 0
2483	switch(afc_status)
2484	{
2485	case 0: freq+=162.5; break;
2486	case 1: freq+=112.5; break;
2487	case 2: freq+=62.5; break;
2488	case 4: freq-=62.5; break;
2489	case 3:
2490	return afc_status;
2491	break;
2492
2493	default :
2494	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "Invalid afc_status = %d\n", afc_status );
2495	return afc_status;
2496	}
2497	#endif
2498	afc_status=AnalogCheckChannel(Tuner, freq, fnCancelCk1, fnCancelCk2);
2499	*tune_freq = freq;
2500	return afc;
2501
2502	#elif NIMTN_TYPE==NIMTN_DTT7611
2503	switch(afc_status)
2504	{
2505	// TDA9885 - AFC Status ÂüÁ¶
2506	case 6 : freq+=162.5; break;
2507	case 5 : freq+=137.5; break;
2508	case 4 : freq+=112.5; break;
2509	case 3 : freq+= 87.5; break;
2510	case 2 : freq+= 62.5; break;
2511	case -3 : freq-= 62.5; break;
2512	case -4 : freq-= 87.5; break;
2513	case -5 : freq-=112.5; break;
2514	case -6 : freq-=137.5; break;
2515	case -7 : freq-=162.5; break;
2516
2517	case -1 :
2518	case 0 :
2519	case 1 :
2520	case -2:
2521	return afc_status;
2522	break;
2523
2524	default :
2525	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "Invalid afc_status = %d\n", afc_status );
2526	return afc_status;
2527	}
2528
2529	afc_status=AnalogCheckChannel(Tuner, freq, fnCancelCk1, fnCancelCk2);
2530	*tune_freq = freq;
2531	return afc_status;
2532	#else
2533	return afc_status;
2534	#endif
2535	}
2536
2537	#if 0
2538	static char AnalogSearchEnd_Sanyo(TunerType Tuner, float freq, char afc_status, float *tune_freq)
2539	{
2540	if (afc_status <= 2) {
2541	afc_status=AnalogCheckChannel(Tuner, freq, fnCancelCk1, fnCancelCk2);
2542	*tune_freq = freq;
2543	}
2544
2545	return afc_status;
2546	}
2547	#endif
2548
2549	//
2550	// DHL_FE_AnalogFullSearch()
2551	//
2552	// search_range = 0ÀÎ °æ¿ì, ´ÙÀ½ Range·Î ¼³Á¤ÇÏ¿© Ã£À½.
2553	//
2554	// if AIR
2555	// +/- 2.25MHz
2556	//
2557	// if STD
2558	// Ch 5/6 +/- 3.00MHz
2559	// Others -2.25MHz ~ +2.25MHz
2560	// if HRC
2561	// Ch 5/6 - 3.00MHz ~ + 2.25MHz
2562	// Others -2.25MHz ~ +2.25MHz
2563	// if IRC
2564	// Ch 5/6 - 3.00MHz ~ + 1.75MHz
2565	// Others -2.25MHz ~ +2.25MHz
2566	//
2567	// ** Autoscan µî¿¡¼´Â ²À(!) CVBS Decoder¸¦ Active ½ÃÅ² »óÅÂ¿¡¼ »ç¿ëÇØ¾ß ÇÔ.
2568	//
2569	DHL_RESULT DHL_FE_AnalogFullSearch(TunerType Tuner, DS_U32 channel, DS_S32 offset, TuneType bFreq, float search_range, DS_BOOL (fnCancelCk1)(), DS_BOOL (*fnCancelCk2)() )
2570	{
2571	DHL_RESULT dhlResult = DHL_OK;
2572	P_DST_FE pDSTFETuner;
2573	float try_freq, tune_freq, old_freq;
2574	char afc_status;
2575	float range_low, range_high;
2576	//////// analog full search ½Ã signalÀÌ NTSC¿¡¼ º¯ÇÏÁö ¾Ê´Â °æ¿ì SIGNAL CALLBACKÀ» ¾È¿Ã·ÁÁà ³ë ½Ã±×³¯ÀÌ µÇ´Â ¹®Á¦¶§¹®¿¡ Ãß°¡.
2577	/////////
2578	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
2579
2580	/*
2581	* Convert Channel to Frequency if bFreq == CHANNEL.
2582	*/
2583	if ( bFreq == CHANNEL ) {
2584	try_freq = ConvertChannelToFrequency( channel, pDSTFETuner->bFreqStd );
2585	} else {
2586	try_freq = channel;
2587	}
2588
2589	if ( search_range == 0 ) {
2590	switch( pDSTFETuner->bFreqStd ) {
2591	case FREQ_AIR:
2592	range_low = 2250;
2593	range_high = 2250;
2594	break;
2595
2596	case FREQ_STD:
2597	if ( bFreq == CHANNEL && (channel == 5 \|\| channel == 6) ) {
2598	range_low = 3000;
2599	range_high = 3000;
2600	} else {
2601	range_low = 2250;
2602	range_high = 2250;
2603	}
2604	break;
2605
2606	case FREQ_IRC:
2607	if ( bFreq == CHANNEL && (channel == 5 \|\| channel == 6) ) {
2608	range_low = 3000;
2609	range_high = 1750;
2610	} else {
2611	range_low = 2250;
2612	range_high = 2250;
2613	}
2614	break;
2615
2616	case FREQ_HRC:
2617	if ( bFreq == CHANNEL && (channel == 5 \|\| channel == 6) ) {
2618	range_low = 3000;
2619	range_high = 2250;
2620	} else {
2621	range_low = 2250;
2622	range_high = 2250;
2623	}
2624	break;
2625
2626	default:
2627	DHL_DbgPrintf( 0, DHLDBG_FE, "*** Frequency standards is not initialized!\n");
2628	return DHL_FAIL;
2629	}
2630	} else {
2631	range_low = search_range;
2632	range_high = search_range;
2633	}
2634
2635	old_freq = try_freq;
2636	#if NIMTN_TYPE==NIMTN_TDQU
2637	afc_status=AnalogOneCenterSearch(Tuner, try_freq-range_low, try_freq+range_high, XOCECO_STEP_FREQ, &tune_freq);
2638	if(afc_status == 0){
2639	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "aft search start\n");
2640	afc_status=AnalogOneChannelSearchX(Tuner, try_freq-range_low, try_freq+range_high, XOCECO_STEP_FREQ, &tune_freq);
2641	afc_status=AnalogSearchEnd(Tuner, tune_freq, afc_status, &tune_freq);
2642	}
2643	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "tune : %lf\n old : %lf",tune_freq,old_freq);
2644	if(afc_status == 3){
2645	offset = (DS_S32)((tune_freq-old_freq)1000);
2646	}else{
2647	*offset = -1;
2648	}
2649	#elif NIMTN_TYPE==NIMTN_DTT7611
2650	afc_status=AnalogOneChannelSearch(Tuner, try_freq-range_low, try_freq+range_high, SEARCH_STEP_FREQ, &tune_freq, fnCancelCk1, fnCancelCk2 );
2651	afc_status=AnalogSearchEnd(Tuner, tune_freq, afc_status, &tune_freq);
2652	if( afc_status >= -3 && afc_status <= 2 )/BK(12.15ÃâÀåmerge) <- afc_status < 2/ { // Æ©´× ¼º°ø
2653	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "tune_freq = %f, old_freq = %f\n", tune_freq, old_freq );
2654	offset = (DS_S32)((tune_freq-old_freq)1000); // offset => xxxxx Hz
2655	}
2656	else
2657	{
2658	afc_status=AnalogCheckChannel(Tuner,try_freq, fnCancelCk1, fnCancelCk2);
2659	*offset = -1;
2660	}
2661	#else
2662	// +200 kHz ÁöÁ¡ºÎÅÍ Ã£±â ½ÃÀÛ.
2663	#if 1
2664	tune_freq += SEARCH_FREQ_FINE_STEP1*2;
2665	afc_status=AnalogOneChannelSearch_Sanyo(Tuner, try_freq-range_low, try_freq+range_high, SEARCH_FREQ_STEP_SANYO, &tune_freq, fnCancelCk1, fnCancelCk2 );
2666	//printf("\|%s\| afc_status=%d\n", __FUNCTION__, afc_status);
2667	//afc_status=AnalogSearchEnd_Sanyo(Tuner, tune_freq, afc_status, &tune_freq);
2668	if( afc_status <= 2 && tune_freq != -1 )/BK(12.15ÃâÀåmerge) <- afc_status < 2/ { // Æ©´× ¼º°ø
2669	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "tune_freq = %f, old_freq = %f\n", tune_freq, old_freq );
2670	offset = (DS_S32)((tune_freq-old_freq)1000); // offset => xxxxx Hz
2671	}
2672	else
2673	{
2674	afc_status=AnalogCheckChannel(Tuner,try_freq, fnCancelCk1, fnCancelCk2);
2675	*offset = -1;
2676	}
2677	#else
2678	DHL_FE_SetFrequency( TUNER_FAT, try_freq*1000, DEMOD_NTSC );
2679	afc_status = 1;
2680	if(afc_status != 1){
2681	AnalogOneChannelSearch_Sanyo(Tuner, try_freq-range_low, try_freq+range_high, SEARCH_FREQ_STEP_SANYO, &tune_freq, fnCancelCk1, fnCancelCk2 );
2682	}
2683	tune_freq = old_freq;
2684	#endif
2685	#endif
2686	pDSTFETuner->bCurDemod = DEMOD_NTSC;
2687	pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK;
2688	pDSTFETuner->bThreadActive = _TRUE_;
2689
2690	return dhlResult;
2691	}
2692
2693	#if NIMTN_TYPE==NIMTN_TDQU
2694	DHL_RESULT DHL_FE_AnalogFullSearchXO(TunerType Tuner, DS_U32 channel, DS_S32 *offset, TuneType bFreq, float search_range )
2695	{
2696	DHL_RESULT dhlResult = DHL_OK;
2697	P_DST_FE pDSTFETuner;
2698	float try_freq, tune_freq, old_freq;
2699	char afc_status;
2700	float range_low, range_high;
2701
2702	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
2703
2704	/*
2705	* Convert Channel to Frequency if bFreq == CHANNEL.
2706	*/
2707	if ( bFreq == CHANNEL ) {
2708	try_freq = ConvertChannelToFrequency( channel, pDSTFETuner->bFreqStd );
2709	} else {
2710	try_freq = channel;
2711	}
2712
2713	if ( search_range == 0 ) {
2714	switch( pDSTFETuner->bFreqStd ) {
2715	case FREQ_AIR:
2716	range_low = 2250;
2717	range_high = 2250;
2718	break;
2719
2720	case FREQ_STD:
2721	if ( bFreq == CHANNEL && (channel == 5 \|\| channel == 6) ) {
2722	range_low = 3000;
2723	range_high = 3000;
2724	} else {
2725	range_low = 2250;
2726	range_high = 2250;
2727	}
2728	break;
2729
2730	case FREQ_IRC:
2731	if ( bFreq == CHANNEL && (channel == 5 \|\| channel == 6) ) {
2732	range_low = 3000;
2733	range_high = 1750;
2734	} else {
2735	range_low = 2250;
2736	range_high = 2250;
2737	}
2738	break;
2739
2740	case FREQ_HRC:
2741	if ( bFreq == CHANNEL && (channel == 5 \|\| channel == 6) ) {
2742	range_low = 3000;
2743	range_high = 2250;
2744	} else {
2745	range_low = 2250;
2746	range_high = 2250;
2747	}
2748	break;
2749
2750	default:
2751	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "*** Frequency standards is not initialized!\n");
2752	return DHL_FAIL;
2753	}
2754	} else {
2755	range_low = search_range;
2756	range_high = search_range;
2757	}
2758
2759	old_freq = try_freq;
2760
2761	afc_status=AnalogOneChannelSearchX(Tuner, try_freq-range_low, try_freq+range_high, SEARCH_STEP_FREQ, &tune_freq);
2762	// afc_status=AnalogSearchEnd(Tuner, tune_freq, afc_status, &tune_freq);
2763	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "tune : %lf\n old : %lf",tune_freq,old_freq);
2764	if(afc_status == 3){
2765	offset = (DS_S32)((tune_freq-old_freq)1000);
2766	}else{
2767	*offset = 0;
2768	}
2769
2770	pDSTFETuner->bCurDemod = DEMOD_NTSC;
2771	pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK;
2772	pDSTFETuner->bThreadActive = _TRUE_;
2773
2774	return dhlResult;
2775	}
2776	#endif
2777
2778	DHL_RESULT DHL_FE_AnalogShortSearch(TunerType Tuner, DS_U32 channel, DS_S32 *offset, TuneType bFreq )
2779	{
2780	DHL_RESULT dhlResult = DHL_OK;
2781	P_DST_FE pDSTFETuner;
2782	float try_freq, tune_freq, old_freq;
2783	char afc_status;
2784
2785	pDSTFETuner = &sDSTFE_Tuner[Tuner-1];
2786
2787	/*
2788	* Convert Channel to Frequency if bFreq == CHANNEL.
2789	*/
2790	if ( bFreq == CHANNEL ) {
2791	try_freq = ConvertChannelToFrequency( channel, pDSTFETuner->bFreqStd );
2792	} else {
2793	try_freq = channel;
2794	}
2795
2796	old_freq = try_freq;
2797	afc_status=AnalogOneChannelSearch(Tuner, try_freq-SHORT_SEARCH_HALF_BOUND, try_freq+SHORT_SEARCH_HALF_BOUND, SEARCH_STEP_FREQ, &tune_freq, 0, 0);
2798	afc_status=AnalogSearchEnd(Tuner, tune_freq, afc_status, &tune_freq);
2799
2800	if( afc_status >= -3 && afc_status <= 2 )/BK(12.15ÃâÀåmerge) <- afc_status < 2/
2801	{ // Æ©´× ¼º°ø
2802	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "tune_freq = %f, old_freq = %f\n", tune_freq, old_freq );
2803	offset = (DS_S32)((tune_freq-old_freq)1000); // offset => xxxxx Hz
2804	}
2805	else
2806	*offset = -1;
2807
2808	pDSTFETuner->bCurDemod = DEMOD_NTSC;
2809	pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK;
2810	pDSTFETuner->bThreadActive = _TRUE_;
2811
2812	return dhlResult;
2813	}
2814
2815	/****************************************************************************
2816
2817	DHL_RESULT DHL_FE_AnalogFullSearchEx
2818	- Summary : Full search for NTSC channel.
2819	- Argument
2820	Tuner to use, TunerType { TUNER_FAT, TUNER_FDC }
2821	channel
2822	returns offset in pOffset.
2823	- Returns : DHL_OK on success, DHL_FAIL on failure.
2824
2825
2826	AFT Range (OMEGA Requirements)
2827
2828	Air Channel
2829	All channel +/- 2.25MHz
2830
2831	Cable Channel
2832	if HRC
2833	Ch 5/6 +/- 3.00MHz
2834	Others -2.25MHz ~ +3.00MHz
2835	else
2836	Ch 5/6 +/- 3.00MHz
2837	Others -3.00MHz ~ +2.25MHz
2838
2839	AFT Sequences
2840
2841	ORION AFT ¹®¼ ÂüÁ¶.
2842
2843	E.g.
2844
2845	PHASE1: Center¿¡¼ Low Limit±îÁö Lock ¿©ºÎ °Ë»ç.
2846	PHASE2: AFT High °Ë»ö (°Ë»öµÇ¸é PHASE3À¸·Î)
2847	PHASE3: AFT Low °Ë»ö (°Ë»öµÇ¸é PHASE9À¸·Î)
2848	PHASE9: AFT High °Ë»ö (°Ë»öµÇ¸é PHASE8À¸·Î)
2849	PHASE8: AFT Low °Ë»ö (°Ë»öµÇ¸é END)
2850
2851	***************************************************************************/
2852	//
2853	// AFT Range
2854	//
2855	#define AFT_RANGE_AIR 2250000
2856	#define AFT_RANGE_STD_LOW 3000000
2857	#define AFT_RANGE_STD_HIGH 2250000
2858	#define AFT_RANGE_HRC_LOW 2250000
2859	#define AFT_RANGE_HRC_HIGH 3000000
2860	#define AFT_RANGE_CH5_6 3000000
2861
2862	DHL_RESULT DHL_FE_AnalogFullSearchEx( TunerType Tuner, DS_U32 channel, DS_S32 *pOffset, TuneType bFreq, DS_S32 RangeLow, DS_S32 RangeHigh )
2863	{
2864	DHL_RESULT dhlResult = DHL_OK;
2865
2866	return dhlResult;
2867	}
2868
2869	static int m_ALockMethod = 1;
2870	DHL_RESULT DHL_FE_AnalogGetLockStatus(TunerType Tuner, DS_U8 *lockStatus)
2871	{
2872	DHL_RESULT dhlResult = DHL_OK;
2873	P_DST_FE pDSTFETuner=&sDSTFE_Tuner[Tuner-1];
2874
2875	#if USE_ANALOGLOCKSTATUS
2876	if (m_ALockMethod)
2877	dhlResult = DD_FE_AnalogGetLockStatusEx( pDSTFETuner, lockStatus);
2878	else
2879	dhlResult = DD_FE_AnalogGetLockStatus( pDSTFETuner, lockStatus);
2880	#else
2881	pDSTFETuner = pDSTFETuner;
2882	*lockStatus = 1;
2883	//dhlResult = DHL_FAIL_NOT_IMPLEMENTED;
2884	#endif
2885	return dhlResult;
2886	}
2887
2888	void DHL_FE_SetAnalogLockMethod(int Method)
2889	{
2890	m_ALockMethod = Method;
2891	}
2892
2893	//
2894	// NTSC CallbackÀ» À§ÇÑ Monitor Thread
2895	//
2896
2897	#define FE_THREAD_DELAY 40
2898
2899	void DHL_FE_MonitorThread(DS_U32 arg)
2900	{
2901	DHL_CAP_VIDEO_INPUT mainSrc, subSrc;
2902	P_DST_FE pDSTFETuner;
2903	DS_U8 isLocked;
2904	#if NIMTN_TYPE!=NIMTN_TDQU
2905	int w_count=0, flag=0;
2906	#endif
2907
2908	pDSTFETuner = (P_DST_FE)arg;
2909
2910	while( 1 ) {
2911	#if NIMTN_TYPE!=NIMTN_TDQU
2912	//
2913	// ´ÙÀ½Àº Weak Signal Å×½ºÆ® ¿ëµµ·Î »ç¿ëµÊ.
2914	//
2915	if ( g_test_weak_interval ) {
2916	if ( w_count++ > g_test_weak_interval ) {
2917	flag = flag == 0 ? 2 : 0;
2918	set_lock( flag );
2919	w_count = 0;
2920	}
2921	}
2922	#endif
2923	if ( pDSTFETuner->bThreadActive == _FALSE_ ) {
2924	MDELAY(FE_THREAD_DELAY);
2925	continue;
2926	}
2927
2928	#if !USE_DIGITAL_CALLBACK
2929	if ( pDSTFETuner->bCurDemod != DEMOD_NTSC ) {
2930	pDSTFETuner->bThreadActive = _FALSE_;
2931	pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK;
2932	MDELAY(FE_THREAD_DELAY);
2933	continue;
2934	}
2935	#endif
2936	mainSrc = DHL_CAP_GetVideoSrc(0);
2937	subSrc = DHL_CAP_GetVideoSrc(1);
2938	if ( mainSrc != DHL_CAP_ATV0_VIDEO && subSrc != DHL_CAP_ATV0_VIDEO ) {
2939	MDELAY(FE_THREAD_DELAY);
2940	continue;
2941	}
2942
2943	//
2944	// ATV°¡ Main¿¡ ÀÖÀ»¶§¸¸, NTSC Adaptive NR ½ÇÇà.
2945	//
2946	if ( mainSrc == DHL_CAP_ATV0_VIDEO )
2947	DHL_CAP_SetAdaptiveNR();
2948
2949	/* Get NTSC lock status. */
2950	if ( pDSTFETuner->bCurDemod == DEMOD_NTSC )
2951	DD_FE_AnalogGetLockStatus(pDSTFETuner, &isLocked);
2952	else
2953	DD_FE_GetLockStatus(pDSTFETuner, &isLocked);
2954
2955	//isLocked = 0;
2956
2957	/* Send callback to upper layer. */
2958	if ( isLocked && (pDSTFETuner->NotifyState != FE_SENT_LOCK) ) {
2959	pDSTFETuner->NotifyState = FE_SENT_LOCK;
2960	if ( g_fe_debug ) {
2961	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[FAT] %s Locked.\n", pDSTFETuner->bCurDemod == DEMOD_8VSB ? "8VSB" :
2962	pDSTFETuner->bCurDemod == DEMOD_64QAM ? "64QAM" :
2963	pDSTFETuner->bCurDemod == DEMOD_256QAM ? "256QAM" :
2964	pDSTFETuner->bCurDemod == DEMOD_QAM ? "QAM" :
2965	pDSTFETuner->bCurDemod == DEMOD_NTSC ? "NTSC" :
2966	pDSTFETuner->bCurDemod == DEMOD_ISDBT ? "ISDB-T" :
2967	pDSTFETuner->bCurDemod == DEMOD_ISDBT_MANUAL ? "ISDB-T Manual" :
2968	pDSTFETuner->bCurDemod == DEMOD_MODEA ? "MODEA" :
2969	pDSTFETuner->bCurDemod == DEMOD_MODEB ? "MODEB" : "Unknown");
2970	}
2971	if ( pDSTFETuner->bCurDemod == DEMOD_NTSC ) {
2972	if ( pDSTFETuner->fnFECallbackNTSC[FECALLBACK_LOCK-1] ) {
2973	(pDSTFETuner->fnFECallbackNTSC[FECALLBACK_LOCK-1])(pDSTFETuner->bTuner, FECALLBACK_LOCK, pDSTFETuner->FECallbackUserArg[FECALLBACK_LOCK-1]);
2974	}
2975	} else {
2976	if ( pDSTFETuner->fnFECallback[FECALLBACK_LOCK-1] ) {
2977	(pDSTFETuner->fnFECallback[FECALLBACK_LOCK-1])(pDSTFETuner->bTuner, FECALLBACK_LOCK, pDSTFETuner->FECallbackUserArg[FECALLBACK_LOCK-1]);
2978	}
2979	}
2980	}
2981	else if ( !isLocked && (pDSTFETuner->NotifyState == FE_SENT_LOCK) ) {
2982	pDSTFETuner->NotifyState = FE_SENT_UNLOCK;
2983	if ( g_fe_debug ) {
2984	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[FAT] %s Unlocked.\n", pDSTFETuner->bCurDemod == DEMOD_8VSB ? "8VSB" :
2985	pDSTFETuner->bCurDemod == DEMOD_64QAM ? "64QAM" :
2986	pDSTFETuner->bCurDemod == DEMOD_256QAM ? "256QAM" :
2987	pDSTFETuner->bCurDemod == DEMOD_QAM ? "QAM" :
2988	pDSTFETuner->bCurDemod == DEMOD_NTSC ? "NTSC" :
2989	pDSTFETuner->bCurDemod == DEMOD_ISDBT ? "ISDB-T" :
2990	pDSTFETuner->bCurDemod == DEMOD_ISDBT_MANUAL ? "ISDB-T Manual" :
2991	pDSTFETuner->bCurDemod == DEMOD_MODEA ? "MODEA" :
2992	pDSTFETuner->bCurDemod == DEMOD_MODEB ? "MODEB" : "Unknown");
2993	}
2994
2995	if ( pDSTFETuner->bCurDemod == DEMOD_NTSC ) {
2996	if ( pDSTFETuner->fnFECallbackNTSC[FECALLBACK_UNLOCK-1] ) {
2997	(pDSTFETuner->fnFECallbackNTSC[FECALLBACK_UNLOCK-1])(pDSTFETuner->bTuner, FECALLBACK_UNLOCK, pDSTFETuner->FECallbackNTSCUserArg[FECALLBACK_UNLOCK-1]);
2998	}
2999	} else {
3000	if ( pDSTFETuner->fnFECallback[FECALLBACK_UNLOCK-1] ) {
3001	(pDSTFETuner->fnFECallback[FECALLBACK_UNLOCK-1])(pDSTFETuner->bTuner, FECALLBACK_UNLOCK, pDSTFETuner->FECallbackUserArg[FECALLBACK_UNLOCK-1]);
3002	}
3003	}
3004	}
3005	/*
3006	else {
3007	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "NTSC = %s, NotifyState = %d\n", isLocked ? "Locked" : "Unlocked", pDSTFETuner->NotifyState );
3008	}
3009	*/
3010
3011	MDELAY(FE_THREAD_DELAY);
3012	}
3013	}
3014
3015	#if USE_NTSCCALLBACK
3016	static DHL_RESULT DHL_FE_NTSCCallbackInit(void)
3017	{
3018	DHL_RESULT dhlResult = DHL_OK;
3019	int i;
3020	P_DST_FE pDSTFETuner=&sDSTFE_Tuner[TUNER_FAT-1];
3021
3022	for (i=0; i<(FECALLBACK_MAX-1); i++) {
3023	pDSTFETuner->fnFECallbackNTSC[i] = (P_DHL_FE_CALLBACK)0;
3024	pDSTFETuner->FECallbackNTSCUserArg[i] = 0;
3025	}
3026
3027	pDSTFETuner->NotifyState = FE_WAIT_FOR_LOCK;
3028	pDSTFETuner->bThreadActive = _FALSE_;
3029	pDSTFETuner->feThreadId = OS_SpawnTask( DHL_FE_MonitorThread, "tFEMonitor", 60, 4096, (DS_U32)pDSTFETuner);
3030	if ( pDSTFETuner->feThreadId == 0 )
3031	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: Cannot create FE thread!\n");
3032	else
3033	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "FE Thread ID = 0x%lx\n", pDSTFETuner->feThreadId );
3034
3035	return dhlResult;
3036	}
3037	#endif
3038
3039	void dhl_fe_t_btsc( int Enable )
3040	{
3041	P_DST_FE pDSTFETuner;
3042	pDSTFETuner = &sDSTFE_Tuner[TUNER_FAT-1];
3043
3044	//DD_FE_I2SEnable( pDSTFETuner, Enable );
3045	}
3046
3047	#if 0
3048	___Debugging_Functions___()
3049	#endif
3050
3051	/*************************************************************************
3052
3053	Debugging Functions
3054
3055	*************************************************************************/
3056	void set_am(int am, int as)
3057	{
3058	DHL_RESULT dhlResult = DHL_OK;
3059
3060	DHL_DbgPrintf( 0, DHLDBG_FE, "* Set NTSC Audio Mode *\n");
3061	DHL_DbgPrintf( 0, DHLDBG_FE, " AudioMode = %s (%d)\n",
3062	am == FE_AUDIO_MONO ? "MONO" :
3063	am == FE_AUDIO_STEREO ? "STEREO" :
3064	am == FE_AUDIO_MONO_SAP ? "MONO_SAP" :
3065	am == FE_AUDIO_SAP ? "SAP" : "Unknown", am );
3066	DHL_DbgPrintf( 0, DHLDBG_FE, " AudioStandard = %s (%d)\n",
3067	as == FE_AUDIO_OFF ? "OFF" :
3068	as == FE_AUDIO_BTSC ? "BTSC" :
3069	as == FE_DUALFM ? "DUALFM" :
3070	as == FE_AUTODETECT ? "AUTODETECT" : "Unknown", as );
3071
3072	dhlResult = DHL_FE_SetAudioMode( TUNER_FAT, am, as );
3073	if ( dhlResult == DHL_OK )
3074	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "success.\n");
3075	else
3076	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "failure.\n");
3077	}
3078
3079	void get_am(void)
3080	{
3081	DHL_RESULT dhlResult = DHL_OK;
3082	FEAudioMode_t am;
3083	FEAudioStandard_t as;
3084
3085	dhlResult = DHL_FE_GetAudioMode( TUNER_FAT, &am, &as );
3086	if ( dhlResult == DHL_OK )
3087	DHL_DbgPrintf( 0, DHLDBG_FE, "success.\n");
3088	else
3089	DHL_DbgPrintf( 0, DHLDBG_FE, "failure.\n");
3090
3091	DHL_DbgPrintf( 0, DHLDBG_FE, "* Get NTSC Audio Mode *\n");
3092	DHL_DbgPrintf( 0, DHLDBG_FE, " AudioMode = %s (%d)\n",
3093	am == FE_AUDIO_MONO ? "MONO" :
3094	am == FE_AUDIO_STEREO ? "STEREO" :
3095	am == FE_AUDIO_MONO_SAP ? "MONO_SAP" :
3096	am == FE_AUDIO_SAP ? "SAP" : "Unknown", am );
3097	DHL_DbgPrintf( 0, DHLDBG_FE, " AudioStandard = %s (%d)\n",
3098	as == FE_AUDIO_OFF ? "OFF" :
3099	as == FE_AUDIO_BTSC ? "BTSC" :
3100	as == FE_DUALFM ? "DUALFM" :
3101	as == FE_AUTODETECT ? "AUTODETECT" : "Unknown", as );
3102	}
3103
3104	void tune( DS_U32 Frequency, int Demod )
3105	{
3106	Frequency *= 1000;
3107	#if NIMTN_TYPE==NIMTN_TDQU
3108	DS_U8 lockStatus = 0;
3109	char aft = 0;
3110	#endif
3111	DHL_DbgPrintf( 0, DHLDBG_FE, "tune to %ld\n", Frequency );
3112
3113	switch ( Demod ) {
3114	case DEMOD_8VSB: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to 8VSB\n"); break;
3115	case DEMOD_64QAM: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to QAM64\n"); break;
3116	case DEMOD_256QAM: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to QAM256\n"); break;
3117	case DEMOD_QAM: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to QAM\n"); break;
3118	case DEMOD_NTSC: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to NTSC/BTSC\n"); break;
3119	case DEMOD_ISDBT: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to ISDB-T\n"); break;
3120	case DEMOD_ISDBT_MANUAL: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to ISDB-T Manual\n"); break;
3121	case DEMOD_OFF: DHL_DbgPrintf( 0, DHLDBG_FE, "Demod to OFF\n"); break;
3122	default:
3123	DHL_DbgPrintf( 0, DHLDBG_FE, "Usage: tune [frenInKHz] [demod]\n");
3124	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_8VSB, "8VSB");
3125	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_64QAM, "64QAM");
3126	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_256QAM, "256QAM");
3127	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_QAM, "QAM");
3128	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_NTSC, "NTSC");
3129	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_ISDBT, "ISDB-T");
3130	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_ISDBT_MANUAL, "ISDB-T Manual");
3131	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_OFF, "OFF");
3132	return;
3133	}
3134
3135	DHL_FE_SetFrequency( TUNER_FAT, Frequency, Demod );
3136	#if NIMTN_TYPE==NIMTN_TDQU
3137	DHL_FE_AnalogGetLockStatus( TUNER_FAT, &lockStatus);
3138
3139	aft = AnalogCheckChannelStart( TUNER_FAT, Frequency, fnCancelCk1, fnCancelCk2);
3140	DHL_DbgPrintf( 0, DHLDBG_FE, "H lock status is %d\n",lockStatus);
3141	DHL_DbgPrintf( 0, DHLDBG_FE, "AFT lock status is %d\n",aft);
3142	#endif
3143	}
3144
3145	void isLocked(void)
3146	{
3147	DHL_RESULT dhlResult = DHL_OK;
3148	DS_U8 isLocked;
3149
3150	dhlResult = DHL_FE_GetLockStatus( TUNER_FAT, &isLocked );
3151	if ( dhlResult != DHL_OK ) {
3152	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__);
3153	return;
3154	}
3155
3156	DHL_DbgPrintf( 0, DHLDBG_FE, "FAT is %s\n", isLocked == 1 ? "locked" : isLocked == 0 ? "unlocked" : "unknown" );
3157	}
3158
3159	void gettda()
3160	{
3161	P_DST_FE pDSTFETuner;
3162	UTda9885ReadReg tdaData;
3163
3164	pDSTFETuner = &sDSTFE_Tuner[TUNER_FAT-1];
3165
3166	DD_FE_GetTDA9885Reg( pDSTFETuner, (DS_U8 *)&tdaData );
3167
3168	DHL_DbgPrintf( 0, DHLDBG_FE, "tdaData = 0x%x\n", tdaData.Byte );
3169	DHL_DbgPrintf( 0, DHLDBG_FE, "afc_status = %d\n", tdaData.Part.AFC );
3170	}
3171
3172
3173	int get_analoglock()
3174	{
3175	DS_U8 isLocked;
3176
3177	isLocked = 0;
3178	if ( DHL_FE_AnalogGetLockStatus( TUNER_FAT, &isLocked ) != DHL_OK )
3179	isLocked = 0;
3180
3181	DHL_DbgPrintf( 0, DHLDBG_FE, "analog lock = %d (%s)\n", isLocked, isLocked ? "Locked" : "Unlocked" );
3182
3183	return (int)isLocked;
3184	}
3185
3186	void TestAFT( DS_U32 channel, DS_U32 isCable )
3187	{
3188	DHL_RESULT dhlResult = DHL_OK;
3189	DS_S32 Offset;
3190	P_DST_FE pDSTFETuner = &sDSTFE_Tuner[TUNER_FAT-1];
3191	DS_U32 ori_freq;
3192	DS_U8 lockStatus;
3193	volatile DS_U32 startTick, endTick;
3194
3195	DHL_FE_Stop( TUNER_FAT );
3196
3197	if (!channel && !isCable) {
3198	printf("Usage: %s [channel] [isCable]\n", __FUNCTION__);
3199	printf(" channel: ch #\n");
3200	printf(" isCable: %d: AIR %d:STD %d:HRC %d: IRC\n", FREQ_AIR, FREQ_STD, FREQ_HRC, FREQ_IRC);
3201	return;
3202	}
3203
3204	if ( isCable <= FREQ_UNKNOWN \|\| isCable >= FREQ_MAX )
3205	isCable = FREQ_AIR;
3206
3207	DHL_FE_SetChannelStandard( TUNER_FAT, isCable );
3208
3209	ori_freq = ConvertChannelToFrequency( channel, pDSTFETuner->bFreqStd );
3210	ori_freq *= 1000;
3211
3212	DHL_DbgPrintf( 0, DHLDBG_FE, "Frequency Standard: %s, Freq: %d\n", isCable == FREQ_AIR ? "AIR" : \
3213	isCable == FREQ_STD ? "STD" : \
3214	isCable == FREQ_HRC ? "HRC" : \
3215	isCable == FREQ_IRC ? "IRC" : "Unknown", ori_freq );
3216
3217	startTick = OS_GetTickCount();
3218	dhlResult = DHL_FE_AnalogFullSearch( TUNER_FAT, channel, &Offset, CHANNEL, 0, 0, 0 );
3219	if ( dhlResult != DHL_OK ) {
3220	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: line = %d\n", __LINE__);
3221	return;
3222	}
3223	endTick = OS_GetTickCount();
3224	printf("Elapsed Time: %ld.%ld sec\n", (endTick-startTick)/100, (endTick-startTick)%100);
3225
3226	DHL_FE_GetLockStatus( TUNER_FAT, &lockStatus );
3227	DHL_DbgPrintf( 0, DHLDBG_FE, "Lock Status: %d\n", lockStatus );
3228
3229	DHL_DbgPrintf( 0, DHLDBG_FE, "Original Frequency: %ld\n", ori_freq);
3230	DHL_DbgPrintf( 0, DHLDBG_FE, "New Frequency: %ld (%ld diff)\n", ori_freq + Offset, Offset);
3231	}
3232
3233	DHL_RESULT PrintTunerStatus(void)
3234	{
3235	DHL_RESULT dhlResult = DHL_OK;
3236	DS_U8 LockStatus;
3237	DS_U8 ana_LockStat = 0;
3238	static float SNR;
3239	static float eqSNR;
3240	DS_U32 PWR;
3241	DS_U32 SQI;
3242	DS_U32 RSErr;
3243	float RSErrRate;
3244	TunerDemod Demod;
3245
3246	DHL_FE_GetLockStatus( TUNER_FAT, &LockStatus );
3247	DHL_FE_AnalogGetLockStatus( TUNER_FAT, &ana_LockStat );
3248	DHL_FE_GetSignalStrength( TUNER_FAT, &SQI );
3249	dhlResult = DHL_FE_GetSignalPower( TUNER_FAT, &PWR );
3250	if ( dhlResult != DHL_OK )
3251	PWR = -1;
3252
3253	if ( LockStatus == 1 ) {
3254	dhlResult = DHL_FE_GetSNR( TUNER_FAT, &SNR );
3255	dhlResult = DHL_FE_GetEqSNR( TUNER_FAT, &eqSNR );
3256	dhlResult = DHL_FE_GetRSError( TUNER_FAT, &RSErr, &RSErrRate );
3257	dhlResult = DHL_FE_GetModFormat( TUNER_FAT, &Demod );
3258	} else {
3259	SNR = -1.0f;
3260	eqSNR = SNR;
3261	RSErr = (DS_U32)-1;
3262	RSErrRate = -1.0f;
3263	Demod = DEMOD_UNKNOWN;
3264	}
3265
3266	DHL_DbgPrintf( 0, DHLDBG_FE, " <<< FAT Tuner Status >>>\n" );
3267	DHL_DbgPrintf( 0, DHLDBG_FE, " SQI : %lu\n", SQI );
3268	DHL_DbgPrintf( 0, DHLDBG_FE, " Power : %lu\n", PWR );
3269	DHL_DbgPrintf( 0, DHLDBG_FE, " LockStatus : %u (%s)\n", LockStatus, LockStatus == 1 ? "Locked" : "Unlocked" );
3270	DHL_DbgPrintf( 0, DHLDBG_FE, " Analog Lock: %u (%s)\n", ana_LockStat, ana_LockStat == 1 ? "Locked" : "Unlocked" );
3271	DHL_DbgPrintf( 0, DHLDBG_FE, " SNR : %f (%s)\n", SNR, SNR == -1.0f ? "Invalid" : "Valid" );
3272	DHL_DbgPrintf( 0, DHLDBG_FE, " EQ-SNR : %f (%s)\n", eqSNR, eqSNR == -1.0f ? "Invalid" : "Valid" );
3273	DHL_DbgPrintf( 0, DHLDBG_FE, " RS Err Cnt : %lu(%s)\n", RSErr, RSErr ==(DS_U32) -1 ? "Invalid" : "Valid" );
3274	DHL_DbgPrintf( 0, DHLDBG_FE, " RS Err Cnt : %f(%s)\n", RSErrRate, RSErrRate== -1.0f ? "Invalid" : "Valid" );
3275	DHL_DbgPrintf( 0, DHLDBG_FE, " Modulation : %d(%s)\n", Demod,
3276	(Demod==DEMOD_8VSB) ? "8VSB" :
3277	(Demod==DEMOD_64QAM) ? "64QAM" :
3278	(Demod==DEMOD_256QAM) ? "256QAM" :
3279	(Demod==DEMOD_NTSC) ? "NTSC" :
3280	(Demod==DEMOD_ISDBT) ? "ISDB-T" :
3281	(Demod==DEMOD_ISDBT_MANUAL) ? "ISDB-T Manual" : "UNKNOWN");
3282
3283	#if 0
3284	LockStatus = 0;
3285	dhlResult = DHL_FE_GetLockStatus( TUNER_FDC, &LockStatus );
3286	dhlResult = DHL_FE_GetSignalStrength( TUNER_FDC, &SQI );
3287
3288	if ( LockStatus == 1 ) {
3289	dhlResult = DHL_FE_GetSNR( TUNER_FDC, &SNR );
3290	dhlResult = DHL_FE_GetEqSNR( TUNER_FDC, &eqSNR );
3291	dhlResult = DHL_FE_GetModFormat( TUNER_FDC, &Demod );
3292
3293	// dhlResult = DHL_FE_GetBERT( TUNER_FDC, &bertErrCnt, &bertErrRate );
3294
3295	} else {
3296	SNR = -1.0f;
3297	eqSNR = SNR;
3298	Demod = DEMOD_UNKNOWN;
3299	bertErrCnt = (DS_U32)-1;
3300	bertErrRate = -1.0f;
3301	}
3302
3303	DHL_DbgPrintf( 0, DHLDBG_FE, " <<< FDC Tuner Status >>> \n" );
3304	DHL_DbgPrintf( 0, DHLDBG_FE, " SQI : %lu\n", SQI );
3305	DHL_DbgPrintf( 0, DHLDBG_FE, " LockStatus : %u (%s)\n", LockStatus, LockStatus == 1 ? "Locked" : "Unlocked" );
3306	DHL_DbgPrintf( 0, DHLDBG_FE, " SNR : %f (%s)\n", SNR, SNR == -1.0f ? "Invalid" : "Valid" );
3307	DHL_DbgPrintf( 0, DHLDBG_FE, " Modulation : %d(%s)\n", Demod, (Demod==DEMOD_MODEA) ? "MODEA" : ((Demod==DEMOD_MODEB) ? "MODEB" : "UNKNOWN") );
3308	// DHL_DbgPrintf( 0, DHLDBG_FE, " BERT : %ld (%s)\n", bertErrCnt, bertErrCnt == -1 ? "Invalid" : "Valid" );
3309	#endif
3310	return DHL_OK;
3311	}
3312
3313	void FE_AgingTest(int mod, int count, int cable)
3314	{
3315	TunerDemod demod;
3316	DHL_RESULT dhlResult = DHL_OK;
3317	int curChannel, startChannel, stopChannel;
3318
3319	if ( mod == 0 \|\| mod > 3 ) {
3320	DHL_DbgPrintf( 0, DHLDBG_FE, "Usage: %s [modulationType]\n", __FUNCTION__);
3321	DHL_DbgPrintf( 0, DHLDBG_FE, " modulationType\n");
3322	DHL_DbgPrintf( 0, DHLDBG_FE, " 0:8VSB / 1:64QAM / 2:256QAM / 3:NTSC\n");
3323	return;
3324	}
3325
3326	switch(mod) {
3327	case 1: demod = DEMOD_8VSB; break;
3328	case 2: demod = DEMOD_64QAM; break;
3329	case 3: demod = DEMOD_256QAM; break;
3330	case 4: demod = DEMOD_NTSC; break;
3331	case 5: demod = DEMOD_ISDBT; break;
3332	case 6: demod = DEMOD_ISDBT_MANUAL; break;
3333	default:
3334	demod = DEMOD_8VSB;
3335	}
3336
3337	if ( count <= 0 )
3338	count = 1;
3339
3340	DHL_FE_Stop( TUNER_FAT );
3341	if ( cable == 1 ) {
3342	startChannel = 1;
3343	stopChannel = 135;
3344
3345	DHL_FE_SetChannelStandard( TUNER_FAT, FREQ_STD );
3346	DHL_FE_SetInput(TUNER_FAT, 0);
3347	} else {
3348	startChannel = 2;
3349	stopChannel = 69;
3350
3351	DHL_FE_SetChannelStandard( TUNER_FAT, FREQ_AIR );
3352	DHL_FE_SetInput(TUNER_FAT, 1);
3353	}
3354
3355	while ( count-- ) {
3356	for (curChannel=startChannel; curChannel<=stopChannel; curChannel++) {
3357	dhlResult = DHL_FE_Start( TUNER_FAT, curChannel, demod, CHANNEL );
3358	if ( dhlResult != DHL_OK )
3359	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR, LINE=%d\n", __LINE__);
3360
3361	dhlResult = DHL_FE_Stop( TUNER_FAT );
3362	if ( dhlResult != DHL_OK )
3363	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR, LINE=%d\n", __LINE__);
3364
3365	MDELAY(1000);
3366	}
3367	}
3368	}
3369
3370	static void TestNTSCFunc( TunerType Tuner, FECallbackSource eventSource, DS_U32 userArg )
3371	{
3372	switch(eventSource) {
3373	case FECALLBACK_LOCK:
3374	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[NTSC] Locked. userArg = 0x%lx\n", userArg);
3375	break;
3376
3377	case FECALLBACK_UNLOCK:
3378	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "[NTSC] Unlocked. userArg = 0x%lx\n", userArg);
3379	break;
3380
3381	default:
3382	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "Spurious Signal. eventSource = %d\n", eventSource);
3383	}
3384	}
3385
3386	void installTestNTSCCb(void)
3387	{
3388	DHL_RESULT dhlResult;
3389
3390	DHL_DbgPrintf( gdhlFeDbgLvl, DHLDBG_FE, "Install Test NTSC Callback Function.\n");
3391
3392	dhlResult = DHL_FE_SetCallbackNTSC(TUNER_FAT, FECALLBACK_ACQSTART, TestNTSCFunc, 0x1234 );
3393	if ( dhlResult != DHL_OK )
3394	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: LINE=%d\n", __LINE__);
3395
3396	dhlResult = DHL_FE_SetCallbackNTSC(TUNER_FAT, FECALLBACK_LOCK, TestNTSCFunc, 0x1234 );
3397	if ( dhlResult != DHL_OK )
3398	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: LINE=%d\n", __LINE__);
3399
3400	dhlResult = DHL_FE_SetCallbackNTSC(TUNER_FAT, FECALLBACK_UNLOCK, TestNTSCFunc, 0x4321 );
3401	if ( dhlResult != DHL_OK )
3402	DHL_DbgPrintf( 0, DHLDBG_FE, "ERROR: LINE=%d\n", __LINE__);
3403	}
3404
3405
3406	void check_freq_table(void)
3407	{
3408	DS_U32 freqHRC, freqSTD;
3409	int i, err;
3410
3411	DHL_DbgPrintf( 0, DHLDBG_FE, "Check Frequency Table\n");
3412
3413	err = 0;
3414	for (i=1; i<=135; i++ ) {
3415	freqHRC = Cable_Freq_HRC[i];
3416	freqSTD = Cable_Freq[i];
3417	if ( (freqSTD - freqHRC) != 1250 ) {
3418	DHL_DbgPrintf( 0, DHLDBG_FE, "Ch[%d] HRC = %ld, IRC = %ld\n", i, freqHRC, freqSTD );
3419	err ++;
3420	}
3421	}
3422
3423	if ( !err )
3424	DHL_DbgPrintf( 0, DHLDBG_FE, "Frequency Table is OK\n");
3425	else
3426	DHL_DbgPrintf( 0, DHLDBG_FE, "Frequency Table is INVALID, err cnt = %d\n", err);
3427	}
3428
3429	void set_lock(int l)
3430	{
3431	if ( l == 1 )
3432	DHL_DbgPrintf( 0, DHLDBG_FE, "Force to locked status.\n");
3433	else if ( l == 0 )
3434	DHL_DbgPrintf( 0, DHLDBG_FE, "Reset to normal status.\n");
3435	else
3436	DHL_DbgPrintf( 0, DHLDBG_FE, "Force to unlocked status.\n");
3437
3438	g_force_ss = l;
3439	}
3440
3441	void test_weaksignal(int interval)
3442	{
3443	if (interval)
3444	DHL_DbgPrintf( 0, DHLDBG_FE, "Set weak signal status with %d msec interval.\n", interval);
3445	else
3446	DHL_DbgPrintf( 0, DHLDBG_FE, "Clear weak signal status.\n");
3447
3448	g_test_weak_interval = interval;
3449	}
3450
3451	void test_lockstatus(int n)
3452	{
3453	int i;
3454	DS_U32 SQI;
3455
3456	for (i=0; i<n; i++) {
3457	DHL_DbgPrintf( 0, DHLDBG_FE, "loop %d ... ", i+1);
3458
3459	DHL_FE_GetSignalStrength(TUNER_FAT, &SQI);
3460	DHL_DbgPrintf( 0, DHLDBG_FE, "SQI = %d\n", (int) SQI);
3461	}
3462	}
3463
3464	void test_locktime(int prev_freq, int prev_mod, int freq, int mod, int n)
3465	{
3466	int i;
3467	volatile DS_U32 startTime, elapsedTime, timeOut = 200;
3468	DS_U8 lockStat;
3469
3470	if ( !prev_freq \|\| !prev_mod \|\| !freq \|\| !mod \|\| !n ) {
3471	DHL_DbgPrintf( 0, DHLDBG_FE, "Usage: test_locktime [prev_freq] [prev_demod] [freqInKHz] [demod] [n]\n");
3472	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_8VSB, "8VSB");
3473	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_64QAM, "64QAM");
3474	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_256QAM, "256QAM");
3475	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_QAM, "QAM");
3476	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_NTSC, "NTSC");
3477	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_ISDBT, "ISDB-T");
3478	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_ISDBT_MANUAL, "ISDB-T Manual");
3479	}
3480
3481	for (i=0; i<n; i++) {
3482	tune(prev_freq, prev_mod);
3483	OS_mDelay(500);
3484
3485	startTime = OS_GetTickCount();
3486	tune( freq, mod );
3487
3488	do {
3489	lockStat = 0;
3490	DHL_FE_GetLockStatus( TUNER_FAT, &lockStat );
3491
3492	elapsedTime = OS_GetTickCount() - startTime;
3493	if ( elapsedTime > timeOut )
3494	break;
3495	if ( lockStat )
3496	break;
3497	} while ( 1 );
3498
3499	if (elapsedTime>timeOut)
3500	DHL_DbgPrintf( 0, DHLDBG_FE, "FAILURE: Timeout\n");
3501	if (lockStat)
3502	DHL_DbgPrintf( 0, DHLDBG_FE, "ElapsedTime = %d msec\n", (int)elapsedTime*10);
3503	}
3504	}
3505
3506	void test_locktime1(int freq1, int mod1, int freq2, int mod2, int n)
3507	{
3508	int i;
3509	volatile DS_U32 startTime, elapsedTime, timeOut = 300;
3510	DS_U8 lockStat;
3511	int flag = 0;
3512
3513	if ( !freq1 \|\| !freq2 \|\| !mod1 \|\| !mod2 \|\| !n ) {
3514	DHL_DbgPrintf( 0, DHLDBG_FE, "Usage: test_locktime [freqInKHz_1] [demod_1] [freqInKHz_2] [demod_2] [n]\n");
3515	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_8VSB, "8VSB");
3516	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_64QAM, "64QAM");
3517	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_256QAM, "256QAM");
3518	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_QAM, "QAM");
3519	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_NTSC, "NTSC");
3520	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_ISDBT, "ISDB-T");
3521	DHL_DbgPrintf( 0, DHLDBG_FE, " [demod] = %d for %s\n", DEMOD_ISDBT_MANUAL, "ISDB-T Manual");
3522	}
3523
3524	for (i=0; i<n; i++) {
3525	startTime = OS_GetTickCount();
3526
3527	if ( flag ) {
3528	flag = !flag;
3529	tune( freq1, mod1 );
3530	} else {
3531	flag = !flag;
3532	tune( freq2, mod2 );
3533	}
3534
3535	do {
3536	lockStat = 0;
3537	DHL_FE_GetLockStatus( TUNER_FAT, &lockStat );
3538
3539	elapsedTime = OS_GetTickCount() - startTime;
3540	if ( elapsedTime > timeOut )
3541	break;
3542	if ( lockStat )
3543	break;
3544	} while ( 1 );
3545
3546	if (elapsedTime>timeOut)
3547	DHL_DbgPrintf( 0, DHLDBG_FE, "FAILURE: Timeout\n");
3548	if (lockStat)
3549	DHL_DbgPrintf( 0, DHLDBG_FE, "ElapsedTime = %d msec\n", (int)elapsedTime*10);
3550	}
3551	}
3552
3553	void set_air_freq( int n, int freq )
3554	{
3555	DS_U32 old_freq;
3556
3557	if ( !n \|\| !freq ) {
3558	DHL_DbgPrintf( 0, DHLDBG_FE, "Usage: %s [ch #] [freqInKHz]\n", __FUNCTION__ );
3559	return;
3560	}
3561
3562	old_freq = Air_Freq[n];
3563	Air_Freq[n] = (DS_U32)freq;
3564	DHL_DbgPrintf( 0, DHLDBG_FE, "Old: Air_Freq[%d] = %ld\n", n, old_freq);
3565	DHL_DbgPrintf( 0, DHLDBG_FE, "New: Air_Freq[%d] = %ld\n", n, Air_Freq[n]);
3566	}
3567
3568	void set_am_delay(int b, int a)
3569	{
3570	DHL_DbgPrintf( 0, DHLDBG_FE, "g_PreAudioModeDelay: %d --> %d\n", g_PreAudioModeDelay, b);
3571	DHL_DbgPrintf( 0, DHLDBG_FE, "g_AftAudioModeDelay: %d --> %d\n", g_AftAudioModeDelay, a);
3572
3573	g_PreAudioModeDelay = b;
3574	g_AftAudioModeDelay = a;
3575	}
3576
3577	void set_analog_delay(int d)
3578	{
3579	printf("Analog Full Search delay: %d --> %d\n", g_AnalogSearchDelay, d);
3580	g_AnalogSearchDelay = d;
3581	}
3582
3583	void test_tuner_ch(int std)
3584	{
3585	int i=0;
3586
3587	if (std==0) {
3588	printf("Usage: %s [std] [ch]\n", __FUNCTION__);
3589	printf(" where 1: AIR\n");
3590	printf(" where 2: STD\n");
3591	printf(" where 3: IRC\n");
3592	printf(" where 4: HRC\n");
3593	return;
3594	}
3595
3596	switch(std) {
3597	case 1:
3598	printf("Standard: AIR (2-69)\n");
3599	for (i=2; i<=69; i++) {
3600	tune(Air_Freq[i], 1);
3601	}
3602	break;
3603
3604	case 2:
3605	printf("Standard: STD (1-135)\n");
3606	for (i=1; i<=135; i++) {
3607	tune(Cable_Freq[i], 3);
3608	}
3609	break;
3610
3611	case 3:
3612	printf("Standard: HRC (1-135)\n");
3613	for (i=1; i<=135; i++) {
3614	tune(Cable_Freq_IRC[i], 3);
3615	}
3616	break;
3617
3618	case 4:
3619	printf("Standard: IRC (1-135)\n");
3620	for (i=1; i<=135; i++) {
3621	tune(Cable_Freq_HRC[i], 3);
3622	}
3623	break;
3624	}
3625	}
3626
3627	void test_aft_value(int ch)
3628	{
3629	DS_U32 startFreq, endFreq, stepFreq, curFreq;
3630	DS_U8 tdaData;
3631
3632	if (!ch) {
3633	printf("Usage: %s [ch]\n", __FUNCTION__);
3634	return;
3635	}
3636
3637	startFreq = Cable_Freq[ch] - 2250;
3638	endFreq = Cable_Freq[ch] + 2250;
3639	stepFreq = 50;
3640
3641	for (curFreq=startFreq; curFreq<endFreq; curFreq += stepFreq) {
3642	tune( curFreq, 5 );
3643	OS_mDelay(100);
3644	DD_FE_GetAFCReg( 0, (DS_U8 *)&tdaData );
3645	printf("FREQ[%ld] AFC=%d\n", curFreq, tdaData & 0x7 );
3646	}
3647	}
3648

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

Context Navigation

source: svn/zas_dstar/hal/common/dsthalfe.c @ 22

Download in other formats: