Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

Cas2BRoutines.c @ 2

Last change on this file since 2 was 2, checked in by phkim, 11 years ago

1.phkim

revision copy newcon3sk r27

File size: 107.6 KB

Line
1	/*
2	* $Id: Cas2BRoutines.c,v 1.1 2011/07/08 03:43:59 megakiss Exp $
3	* $Revision: 1.1 $
4	* $DateTime: 2005/08/24 19:03:17 $
5	* $Change: 28028 $
6	* $Author: megakiss $
7	*/
8
9	//#include <stdio.h>
10	#include "dsthalcommon.h"
11
12	#include "dsthalcfg.h"
13	#include "Cas2BRoutines.h"
14	#include "IicComm.h"
15	#include "SnrCalcTable.h"
16	#include "TunerDTT7611.h"
17	#include "TdquTuner.h"//ZhongYang
18	#include "TunerDTT7612.h"
19	#include "DTT7600Tuner.h"
20	#include "TD6650TTuner.h" //kiki
21	#include "TunerFQD1236.h"
22	#include "ThomsonT2000Tuner.h"
23	#include "Cas2BGeneralDefinitions.h" //kiki
24	#include "XC3028.h"
25	#include "VP13HRTuner.h"
26	#include "Cas2BInitBuffers.h"
27	#include "TunerFQD1236.h"
28
29	extern UINT32 gdhlExtDbgLvl;
30
31	#if (NIMTN_TYPE==NIMTN_DTT7611)
32	#define SUPPORT_TUNER_DTT7611 1
33	#define SUPPORT_TUNER_TDQU 0
34	#elif (NIMTN_TYPE==NIMTN_TDQU)
35	#define SUPPORT_TUNER_DTT7611 0
36	#define SUPPORT_TUNER_TDQU 1
37	#else
38	#error You shall define NIMTN_TYPE.
39	#endif
40
41	#if 0
42	#define SUPPORT_TUNER_DTT7611 1
43	#define SUPPORT_TUNER_SN761662 0
44	#define SUPPORT_TUNER_DTT7612 0
45	#define SUPPORT_TUNER_THOMSON_T_2000 0
46	#define SUPPORT_TUNER_PHILIPS_TD6650T 0
47	#define SUPPORT_TUNER_XCEIVE_XC3028 0
48	#define SUPPORT_TUNER_DTT760x 0
49	#define SUPPORT_TUNER_MT2121 0
50	#define SUPPORT_TUNER_TDQU 0
51	#endif
52	#if NIMTN_TYPE==NIMTN_DTT7611
53
54	extern int DTT7611_DTV_AGC, DTT7611_NTSC_AGC;
55	extern CAS_2B_TYPE_RECEIVER_MODE g_Ntsc_Mode;
56	#endif
57
58	#if NIMTN_TYPE==NIMTN_FQD1236
59	int SetTunerFQD1236(TYPE_TUNER_SET_OPTION TunerSet, void* pvTunerSet,
60	CHANNEL_TABLE_TYPE iChannelTable,TYPE_TUNERFQD1236_REF_DIVIDER_RATIO iRefDividerRatio ,
61	TYPE_TUNERFQD1236_AGC iAgc,TYPE_TUNER_AGC_MODE iAgcMode,
62	CHARGE_PUMP iChargePump, TYPE_TUNERFQD1236_AGC_TIME_CONSTANT iAgcTimeConstant );
63	#endif
64
65	unsigned int __stdcall SetChannel(CAS_2B_TUNER_PARAMETERS stTunerParameters,unsigned short usDelay,CAS_2B_CHANNEL_CHANGE_PARAMETERS* pstChannelChangeParameters)
66	{
67	ERROR_TYPE iError;
68
69	if (0) {
70	; /* Just to make the following #if's work correctly */
71	}
72	#if NIMTN_TYPE==NIMTN_DTT7611
73	#if SUPPORT_TUNER_DTT7611
74	else if(TUNER_DTT7611 == stTunerParameters.iTunerType){
75
76	iError = (ERROR_TYPE)SetTunerDTT7611(stTunerParameters.iTunerSet, &stTunerParameters.ulSetValue,
77	stTunerParameters.iChannelTableType,
78	TUNERDTT7611_REF_DIVIDER_RATIO_62_5,/default value/
79	pstChannelChangeParameters->iReceiverMode == g_Ntsc_Mode ? /TUNERDTT7612_AGC_96/(TYPE_TUNERDTT7612_AGC)DTT7611_NTSC_AGC :
80	(TYPE_TUNERDTT7612_AGC)DTT7611_DTV_AGC,
81	stTunerParameters.iAgcMode,
82	(CHARGE_PUMP)TUNERDTT7611_CHARGE_PUMP_60,/default value/
83	TUNERDTT7611_AGC_TIME_CONSTANT_2_SEC);/default value/
84
85	if(CAS_2B_API_SUCCESS != iError)
86	return iError;
87
88	}
89	#endif
90	#endif//#if NIMTN_TYPE==NIMTN_DTT7611
91	#if NIMTN_TYPE==NIMTN_DTT7612
92	#if SUPPORT_TUNER_DTT7612
93	else if(TUNER_DTT7612 == stTunerParameters.iTunerType){
94
95	iError = (ERROR_TYPE)SetTunerDTT7612(stTunerParameters.iTunerSet, &stTunerParameters.ulSetValue,
96	stTunerParameters.iChannelTableType,
97	TUNERDTT7612_REF_DIVIDER_RATIO_62_5,/default value/
98	TUNERDTT7611_AGC_93,/default value/
99	stTunerParameters.iAgcMode,
100	(CHARGE_PUMP)TUNERDTT7612_CHARGE_PUMP_60,/default value/
101	TUNERDTT7612_AGC_TIME_CONSTANT_2_SEC);/default value/
102
103	if(CAS_2B_API_SUCCESS != iError)
104	return iError;
105
106	}
107	#endif
108	#endif//#if NIMTN_TYPE==NIMTN_DTT7612
109	#if NIMTN_TYPE==NIMTN_T2000
110	#if SUPPORT_TUNER_THOMSON_T_2000
111	else if(TUNER_THOMSON_T_2000 == stTunerParameters.iTunerType){
112
113	iError = (ERROR_TYPE)SetTunerThomsonT2000(stTunerParameters.iTunerSet, &stTunerParameters.ulSetValue,
114	TUNER_THOMSON_T2000_INTERNAL_AGC,
115	(TYPE_TUNER_THOMSON_T2000_INPUT_SELECTION)stTunerParameters.iInputSelection,
116	THOMSON_T2000_REF_DIVIDER_RATIO_62_5,
117	(TYPE_TUNER_THOMSON_T2000_MODE)stTunerParameters.iAgcMode
118	);
119
120	if(CAS_2B_API_SUCCESS != iError)
121	return iError;
122
123	}
124	#endif
125	#endif//#if NIMTN_TYPE==NIMTN_T2000
126	#if NIMTN_TYPE==NIMTN_TD6650T
127	#if SUPPORT_TUNER_PHILIPS_TD6650T
128	else if(TUNER_PHILIPS_TD6650T == stTunerParameters.iTunerType){
129
130	iError = (ERROR_TYPE)SetTunerTD6650T(stTunerParameters.iTunerSet, &stTunerParameters.ulSetValue,
131	stTunerParameters.iChannelTableType,
132	TD6650T_REF_DIVIDER_RATIO_62_5 ,
133	TD6650T_AGC_TOP_124,
134	TD6650T_ATC_2_SEC);
135	if(CAS_2B_API_SUCCESS != iError)
136	return iError;
137
138	}
139	#endif
140	#endif//#if NIMTN_TYPE==NIMTN_TD6650T
141	#if NIMTN_TYPE==NIMTN_XC3028
142	#if SUPPORT_TUNER_XCEIVE_XC3028
143	else if(TUNER_XCEIVE_XC3028 == stTunerParameters.iTunerType){
144
145	iError = (ERROR_TYPE)SetTunerXC3028(stTunerParameters.iTunerSet, &stTunerParameters.ulSetValue,stTunerParameters.bLoadFirmware,stTunerParameters.iFirmwareMode);
146	if(CAS_2B_API_SUCCESS != iError)
147	return iError;
148
149	}
150	#endif
151	#endif//#if NIMTN_TYPE==NIMTN_XC3028
152	#if SUPPORT_TUNER_DTT760x
153	else if(TUNER_DTT760x == stTunerParameters.iTunerType){
154	iError = (ERROR_TYPE)SetTunerDTT760xATSC(stTunerParameters.iTunerSet, &(stTunerParameters.ulSetValue),
155	stTunerParameters.iChannelTableType,
156	TUNERDTT760xATSC_REF_DIVIDER_RATIO_62_5,/default value/
157	TUNERDTT760xATSC_AGC_94,/default value/
158	stTunerParameters.iAgcMode,
159	TUNERDTT760xATSC_CHARGE_PUMP_60,/default value/
160	TUNERDTT760xATSC_AGC_TIME_CONSTANT_2_SEC);
161	if(CAS_2B_API_SUCCESS != iError)
162	return iError;
163	}
164	#endif
165	#if NIMTN_TYPE==NIMTN_MT2121
166	#if SUPPORT_TUNER_MT2121
167	else if(TUNER_MT2121 == stTunerParameters.iTunerType){
168	iError = (ERROR_TYPE)SetTunerMT2121(stTunerParameters.iTunerSet, stTunerParameters.ulSetValue,
169	stTunerParameters.iChannelTableType,
170	TUNER_MT2121_REF_DIVIDER_RATIO_62_5);
171	if(CAS_2B_API_SUCCESS != iError)
172	return iError;
173	}
174	#endif
175	#endif//#if NIMTN_TYPE==NIMTN_MT2121
176	#if NIMTN_TYPE==NIMTN_TDQU
177	#if SUPPORT_TUNER_TDQU
178	else if(TUNER_TDQU == stTunerParameters.iTunerType){
179	iError = (ERROR_TYPE)SetTunerTdqu(stTunerParameters.iTunerSet, stTunerParameters.ulSetValue,
180	stTunerParameters.iChannelTableType,
181	TUNER_TDQU_REF_DIVIDER_RATIO_62_5,TUNER_TDQU_CHARGE_PUMP_70,TUNER_TDQU_AGST_0);
182	if(CAS_2B_API_SUCCESS != iError)
183	return iError;
184	}
185	#endif
186	#endif
187	#if NIMTN_TYPE==NIMTN_FQD1236
188	#if SUPPORT_TUNER_SN761662
189	else if(TUNER_SN761662 == stTunerParameters.iTunerType){
190	iError = (ERROR_TYPE)SetTunerSN761662(stTunerParameters.iTunerSet, stTunerParameters.ulSetValue,
191	stTunerParameters.iChannelTableType,
192	SN761662TUNER_REF_DIVIDER_RATIO_50, SN761662TUNER_ATC_900NS, SN761662TUNER_CP_350, TYPE_SN761662TUNER_IFOSW_IFOUT1_DISABLE_IFOUT2_ENABLE, EN_TYPE_SN761662TUNER_AGC_TOP_LEVEL_0_111_LEVEL_1_106, TYPE_SN761662TUNER_RFAGC_SHIFT_XTALOUT_CONTROL_IFOUT_1_OUTPUT_DISABLE);
193	if(CAS_2B_API_SUCCESS != iError)
194	return iError;
195	}
196	#endif
197	#endif
198	#if SUPPORT_TUNER_VP13HR
199	else if(TUNER_VP13HR == stTunerParameters.iTunerType){
200	iError = (ERROR_TYPE)SetTunerVP13HR(stTunerParameters.iTunerSet, stTunerParameters.ulSetValue,
201	stTunerParameters.iChannelTableType,
202	TUNER_VP13HR_REF_DIVIDER_RATIO_62_5, stTunerParameters.bIsFMTrapOn, stTunerParameters.bIsAFTReq);
203	if(CAS_2B_API_SUCCESS != iError)
204	return iError;
205	}
206	#endif
207
208	else{
209	DHL_DbgPrintf(gdhlExtDbgLvl,DHLDBG_EXT,"SetChannel: Unsupported tuner type");
210	return CAS_2B_UNDEFINED_TUNER_TYPE;
211	}
212
213	//if the pstChannelChangeParameters argument is NULL it means that we send only
214	//the tuner PLL frequency
215	if(NULL == pstChannelChangeParameters)
216	return CAS_2B_API_SUCCESS;
217
218	OS_mDelay( usDelay );
219
220	//send the cascade2B DSP channel change
221	return Cas2BChannelChange(*pstChannelChangeParameters);
222	}
223
224	unsigned int __stdcall Cas2BChannelChange(CAS_2B_CHANNEL_CHANGE_PARAMETERS stChannelChangeParameters )
225	{
226	unsigned int uiSendByte = 0,uiRes;
227	unsigned char ucSend[3];
228
229	if((stChannelChangeParameters.iReceiverMode < CAS_2B_RECEIVER_MODE_VSB_8_TR) \|\| (stChannelChangeParameters.iReceiverMode > CAS_2B_RECEIVER_MODE_POWER_DOWN))
230	return UNDEFINED_RECEIVER_MODE;
231
232
233
234
235
236	uiSendByte = 0x8000;//bit 15 always On
237	if((stChannelChangeParameters.iReceiverMode >= CAS_2B_RECEIVER_MODE_VSB_8_TR)&&
238	(stChannelChangeParameters.iReceiverMode <= CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT)){
239	//SeT Channel Change data
240
241	if((stChannelChangeParameters.iCarrierAcquisition != CARRIER_ACQUISITION_NORMAL) && (stChannelChangeParameters.iCarrierAcquisition != CARRIER_ACQUISITION_WIDE))
242	return UNDEFINED_CARRIER_ACQUISITION_TYPE;
243
244	if(CARRIER_ACQUISITION_WIDE == stChannelChangeParameters.iCarrierAcquisition)
245	uiSendByte \|= 0x200;
246
247	if((stChannelChangeParameters.iNtscSignalDetection != NORMAL_VSB) && (stChannelChangeParameters.iNtscSignalDetection != NTSC_SIGNAL_DETECTION))
248	return UNDEFINED_NTSC_SIGNAL_DETECTION;
249	if(NTSC_SIGNAL_DETECTION == stChannelChangeParameters.iNtscSignalDetection)
250	uiSendByte \|= 0x400;
251	}
252
253	if(CAS_2B_RECEIVER_MODE_VSB_8_TR == stChannelChangeParameters.iReceiverMode){
254	if((stChannelChangeParameters.iInverseSpectrum != INVERSE_SPECTRUM_ON) && (stChannelChangeParameters.iInverseSpectrum != INVERSE_SPECTRUM_OFF))
255	return UNDEFINED_INVERSE_SPECTRUM_TYPE;
256	if(INVERSE_SPECTRUM_ON == stChannelChangeParameters.iInverseSpectrum )
257	uiSendByte \|= 0x100;
258
259	}
260
261	//set the 8 lsb bits
262	switch(stChannelChangeParameters.iReceiverMode){
263	case CAS_2B_RECEIVER_MODE_VSB_8_TR:
264	uiSendByte \|= VSB_8_TR_MODE_NUMBER;
265	break;
266	case CAS_2B_RECEIVER_MODE_ITUB_64:
267	uiSendByte \|= ITUB_QAM_64_MODE_NUMBER;
268	break;
269	case CAS_2B_RECEIVER_MODE_ITUB_256:
270	uiSendByte \|= ITUB_QAM_256_MODE_NUMBER;
271	break;
272	case CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT:
273	uiSendByte \|= 0x2f;
274	break;
275	case CAS_2B_RECEIVER_MODE_AUDIO_US_BTSC:
276	uiSendByte \|= 0x30;
277	break;
278	case CAS_2B_RECEIVER_MODE_AUDIO_A2_KOREA:
279	uiSendByte \|= 0x31;
280	break;
281	case CAS_2B_RECEIVER_MODE_AUDIO_RADIO_FM:
282	uiSendByte \|= 0x32;
283	break;
284	case CAS_2B_RECEIVER_MODE_POWER_DOWN:
285	uiSendByte \|= 0xff;
286	break;
287
288	}//end of switch block he 8 lsb bits
289
290
291	ucSend[1] = (char)(uiSendByte>> 8);
292	ucSend[2] = (char)(uiSendByte);
293
294	uiRes = SendToAddress(2, ucSend, 2);
295	if (IIC_COM_SUCCESS != uiRes )
296	return uiRes;
297
298	return CAS_2B_API_SUCCESS;
299	}
300
301	LOCK_STATUS __stdcall IsLocked(int * piError)
302	{
303	unsigned short usReceivedWord = 0;
304	usReceivedWord = ReceiveTransmitRegisterValue( 0,piError);
305	if(IIC_COM_SUCCESS != *piError){
306	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
307	return UNDEFINED_LOCK_STATUS;
308	}
309
310	*piError = (int) CAS_2B_API_SUCCESS;
311	//now musk bit 8 to get the lock status
312	if((0x100 & usReceivedWord) == 0x100)
313	return LOCKED;
314	else
315	return UNLOCKED;
316	}
317
318	LOCK_STATUS __stdcall IsFECLocked(int * piError)
319	{
320	unsigned short usReceivedWord = 0;
321	usReceivedWord = ReceiveTransmitRegisterValue( 0,piError);
322	if(IIC_COM_SUCCESS != *piError){
323	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
324	return UNDEFINED_LOCK_STATUS;
325	}
326
327	*piError = (int) CAS_2B_API_SUCCESS;
328	//now musk bit 9 to get the lock status
329	if((0x200 & usReceivedWord) == 0x200)
330	return LOCKED;
331	else
332	return UNLOCKED;
333	}
334
335	BOOLEAN __stdcall IsNtscChannelDetected(int * piError)
336	{
337	unsigned short usReceivedWord = 0;
338	usReceivedWord = ReceiveTransmitRegisterValue( 0,piError);
339	if(IIC_COM_SUCCESS != *piError){
340	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
341	return FALSE;
342	}
343
344	*piError = (int) CAS_2B_API_SUCCESS;
345	//now musk bit 14 to get the NTSC lock status
346	if((0x4000 & usReceivedWord) == 0x4000)
347	return TRUE;
348	else
349	return FALSE;
350
351	}
352
353
354	unsigned char __stdcall GetMode(int * piError)
355	{
356	unsigned short usReceivedWord = 0;
357	usReceivedWord = ReceiveTransmitRegisterValue( 0,piError);
358	if(IIC_COM_SUCCESS != *piError){
359	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
360	return 0;
361	}
362
363	*piError = (int) CAS_2B_API_SUCCESS;
364	//now musk bit 8 to get the mode
365	return (0xff & usReceivedWord);
366	}
367
368	CAS_2B_TYPE_RECEIVER_MODE GetReceiveMode(int *piError)
369	{
370	unsigned char ucReceiverMode;
371	ucReceiverMode = GetMode(piError);
372
373	if (ucReceiverMode == 0x06 ) {
374	//OS_DbgPrintf("CAS_2B_RECEIVER_MODE_VSB_8_TR \n");
375	return CAS_2B_RECEIVER_MODE_VSB_8_TR;
376	}
377	else if (ucReceiverMode == 0x23){
378	//OS_DbgPrintf("CAS_2B_RECEIVER_MODE_ITUB_64 \n");
379	return CAS_2B_RECEIVER_MODE_ITUB_64;
380	}
381	else if (ucReceiverMode == 0x25){
382	//OS_DbgPrintf("CAS_2B_RECEIVER_MODE_ITUB_256 \n");
383	return CAS_2B_RECEIVER_MODE_ITUB_256;
384	}
385	else{
386	//OS_DbgPrintf("CAS_2B_RECEIVER_MODE_VSB_8_TR(0x%x)\n",(int)ucReceiverMode);
387	return CAS_2B_RECEIVER_MODE_ITUB_256;//default
388	}
389	}
390
391	unsigned char __stdcall GetRfInverseSpectrum(int * piError)
392	{
393	unsigned short usReceivedWord = 0;
394	usReceivedWord = ReceiveTransmitRegisterValue( 0,piError);
395	if(IIC_COM_SUCCESS != *piError){
396	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
397	return 0;
398	}
399
400	//now musk bit 15 to get the rf Inverse spectrum status
401	if(0x8000 & usReceivedWord)
402	return 1;
403	else
404	return 0;
405
406	}
407
408	NUMERATOR_DENOMINATOR __stdcall GetSymbolRateFrequencyOffset(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,int * piError)
409	{
410	unsigned short usReceivedWord = 0;
411	short sReceivedWord;
412	NUMERATOR_DENOMINATOR stResult;
413
414	stResult.Denominator.ulDenominator = 1;
415	stResult.Numerator.ulNumerator = 0;
416
417	//
418	// Auto DetectÀÌ¸é, Receiver Mode¸¦ Á÷Á¢ ¾òÀ½.
419	//
420	if ( iReceiverMode==CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT ) {
421	iReceiverMode=GetReceiveMode(piError);
422	if(IIC_COM_SUCCESS != *piError){
423	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
424	return stResult;
425	}
426	}
427
428	usReceivedWord = ReceiveTransmitRegisterValue( 3,piError);
429	if(IIC_COM_SUCCESS != *piError){
430	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
431	return stResult;
432	}
433
434	if(usReceivedWord > 0x7fff)
435	sReceivedWord = usReceivedWord - 0x10000;
436	else
437	sReceivedWord = usReceivedWord;
438
439	if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode){// x/32767
440	stResult.Denominator.lDenominator = 10000;
441	stResult.Numerator.lNumerator = (sReceivedWord* 8211);
442
443	}
444	else if(CAS_2B_RECEIVER_MODE_ITUB_64 == iReceiverMode){
445	stResult.Denominator.lDenominator = 100000;
446	stResult.Numerator.lNumerator = 77167* sReceivedWord;// 10^6 * x *4096
447	}
448	else if(CAS_2B_RECEIVER_MODE_ITUB_256 == iReceiverMode){
449	stResult.Denominator.lDenominator = 100000;
450	stResult.Numerator.lNumerator = 81794* sReceivedWord;
451	}
452	else{
453	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
454	return stResult;
455	}
456
457	*piError = CAS_2B_API_SUCCESS;
458	return stResult;
459	}
460
461	TYPE_ITUB_DE_INTERLEAVER_MODE __stdcall GetDiMode(int * piError)
462	{
463	unsigned short usReceivedWord = 0;
464
465	usReceivedWord = ReceiveTransmitRegisterValue( 0,piError);
466	if(IIC_COM_SUCCESS != *piError){
467	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
468	return((TYPE_ITUB_DE_INTERLEAVER_MODE)0);
469	}
470
471	usReceivedWord = (usReceivedWord & 0x3c00) >> 10;
472	switch(usReceivedWord){
473	case 0:
474	case 1:
475	return ITUB_DE_INTERLEAVER_MODE_128_1;
476	// break;
477	case 2:
478	return ITUB_DE_INTERLEAVER_MODE_128_2;
479	// break;
480	case 3:
481	return ITUB_DE_INTERLEAVER_MODE_64_2;
482	// break;
483	case 4:
484	return ITUB_DE_INTERLEAVER_MODE_128_2;
485	// break;
486	case 5:
487	return ITUB_DE_INTERLEAVER_MODE_32_4;
488	// break;
489	case 6:
490	return ITUB_DE_INTERLEAVER_MODE_128_4;
491	// break;
492	case 7:
493	return ITUB_DE_INTERLEAVER_MODE_16_8;
494	// break;
495	case 9:
496	return ITUB_DE_INTERLEAVER_MODE_8_16;
497	// break;
498	default:
499	*piError = UNDEFINED_ITUB_DE_INTERLEAVER_MODE;
500	return((TYPE_ITUB_DE_INTERLEAVER_MODE)0);
501	}
502
503	}
504
505	unsigned short __stdcall GetSnrAfterEqualization(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,int * piError)
506	{
507	unsigned short usReceivedWord = 0;
508	unsigned short usK=0;
509	int iLogResult,iSNRResult;
510
511	//
512	// Auto DetectÀÌ¸é, Receiver Mode¸¦ Á÷Á¢ ¾òÀ½.
513	//
514	if ( iReceiverMode==CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT ) {
515	iReceiverMode=GetReceiveMode(piError);
516	if(IIC_COM_SUCCESS != *piError){
517	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
518	return 0;
519	}
520	}
521
522	if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode){
523
524	//calculate the K value
525	//get transmit register 0
526	usReceivedWord = ReceiveTransmitRegisterValue(0,piError);
527	if(IIC_COM_SUCCESS != *piError){
528	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
529	return 0;
530	}
531	//mask for bit 12 that holds the NTSC rejection filter Status
532	if((0x1000 & usReceivedWord) == 0x1000) //0n
533	usK = 3;
534	else // off
535	usK = 0;
536
537	}
538
539	//get the snr value
540
541	usReceivedWord = ReceiveTransmitRegisterValue(2,piError);
542	if(IIC_COM_SUCCESS != *piError){
543	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
544	return 0;
545	}
546
547	//mask the received data 15 lsb bits
548	if(0 == usReceivedWord){
549	*piError = (int) RECEIVED_ZERO_SNR_VALUE_FROM_THE_CASCADE;
550	return 0;
551	}
552
553
554	iLogResult = CalcLog(usReceivedWord);
555
556	if((CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode)){
557	iSNRResult = VSB_ADD_TO_LOG - iLogResult - usK;
558	}
559	else if(CAS_2B_RECEIVER_MODE_ITUB_64 == iReceiverMode)
560	iSNRResult = ITUB_QAM_64_ADD_TO_LOG - iLogResult;
561	else if(CAS_2B_RECEIVER_MODE_ITUB_256 == iReceiverMode)
562	iSNRResult = ITUB_QAM_256_ADD_TO_LOG - iLogResult;
563	else{
564	*piError = SNR_IS_CALCULATED_ONLY_FOR_VSB_AND_ITUB;
565	return 0;
566	}
567
568	return iSNRResult;
569	}
570
571	NUMERATOR_DENOMINATOR __stdcall GetPer(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,int * piError)
572	{
573	// unsigned short usReceivedWord = 0;
574	NUMERATOR_DENOMINATOR stResult;
575	int iBerFailedTransmitRegiterNumber;
576
577	stResult.Denominator.ulDenominator = 1;
578	stResult.Numerator.ulNumerator = 0;
579
580	if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode)
581	iBerFailedTransmitRegiterNumber = 13;
582	else if((CAS_2B_RECEIVER_MODE_ITUB_64 == iReceiverMode) \|\| (CAS_2B_RECEIVER_MODE_ITUB_256 == iReceiverMode)\|\| (CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT == iReceiverMode))
583	iBerFailedTransmitRegiterNumber = 11;
584	else{
585	*piError = UNDEFINED_RECEIVER_MODE;
586	return stResult;
587	}
588
589	stResult.Numerator.usNumerator = ReceiveTransmitRegisterValue(iBerFailedTransmitRegiterNumber,piError);
590	if(IIC_COM_SUCCESS != *piError){
591	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
592	return stResult;
593	}
594
595	stResult.Denominator.usDenominator = ReceiveTransmitRegisterValue(14,piError);
596	if(IIC_COM_SUCCESS != *piError){
597	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
598	return stResult;
599	}
600
601
602	*piError = CAS_2B_API_SUCCESS;
603	return stResult;
604	}
605
606	NUMERATOR_DENOMINATOR __stdcall GetBer(int * piError)
607	{
608	unsigned short usBERCorrected,usBERFailed,usBERLimit;
609	NUMERATOR_DENOMINATOR stResult;
610
611	stResult.Denominator.ulDenominator = 1;
612	stResult.Numerator.ulNumerator = 0;
613
614	usBERCorrected = ReceiveTransmitRegisterValue(13,piError);
615	if(IIC_COM_SUCCESS != *piError){
616	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
617	return stResult;
618	}
619
620	usBERFailed = ReceiveTransmitRegisterValue(11,piError);
621	if(IIC_COM_SUCCESS != *piError){
622	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
623	return stResult;
624	}
625
626	usBERLimit = ReceiveTransmitRegisterValue(14,piError);
627	if(IIC_COM_SUCCESS != *piError){
628	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
629	return stResult;
630	}
631
632	*piError = CAS_2B_API_SUCCESS;
633	stResult.Numerator.ulNumerator = usBERCorrected + 47usBERFailed;
634	stResult.Denominator.ulDenominator = 7122 usBERLimit;
635
636	return stResult;
637
638	}
639
640	unsigned char Get1SecSer(int * piError)
641	{
642	unsigned short usReceivedWord;
643
644	usReceivedWord = ReceiveTransmitRegisterValue(1,piError);
645	if(IIC_COM_SUCCESS != *piError){
646	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
647	return 0;
648	}
649
650	return (unsigned char)(usReceivedWord & 0xff);
651
652	}
653
654
655	unsigned char Get10SecSer(int * piError)
656	{
657	unsigned short usReceivedWord;
658
659	usReceivedWord = ReceiveTransmitRegisterValue(1,piError);
660	if(IIC_COM_SUCCESS != *piError){
661	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
662	return 0;
663	}
664
665	return (unsigned char)((usReceivedWord & 0xff00) >> 8);
666
667	}
668
669
670
671
672	unsigned int __stdcall GetEqualizerFeedForwardTaps(unsigned short* pusaReceivedFfTaps)
673	{
674	if(NULL == pusaReceivedFfTaps)
675	return FUNCTION_RECEIVED_NULL_PARAMETER;
676
677	return ReceiveVector(2,pusaReceivedFfTaps,96);
678
679
680	}
681
682	unsigned int __stdcall GetEqualizerFeedBackTaps(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,unsigned short* pusaReceivedFbTaps)
683	{
684	unsigned short usVectorLength;
685	if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode)
686	usVectorLength = 384;
687	else if((CAS_2B_RECEIVER_MODE_ITUB_64 == iReceiverMode) \|\| (CAS_2B_RECEIVER_MODE_ITUB_256 == iReceiverMode)\|\| (CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT == iReceiverMode))
688	usVectorLength = 96;
689	else{
690	return UNDEFINED_RECEIVER_MODE;
691	}
692
693	if(NULL == pusaReceivedFbTaps)
694	return FUNCTION_RECEIVED_NULL_PARAMETER;
695
696	return ReceiveVector(3,pusaReceivedFbTaps,usVectorLength);
697
698
699	}
700
701	unsigned int __stdcall GetConstellationSamples(unsigned short usNumberOfConstellationSamples,unsigned short* pusaConstellationSamples)
702	{
703	if(NULL == pusaConstellationSamples)
704	return FUNCTION_RECEIVED_NULL_PARAMETER;
705
706	if(0 == usNumberOfConstellationSamples)
707	return CAS_2B_API_SUCCESS;
708
709	if(usNumberOfConstellationSamples > 4096)
710	usNumberOfConstellationSamples = 4096;
711
712	return ReceiveVector(5,pusaConstellationSamples,usNumberOfConstellationSamples);
713
714	}
715
716	unsigned int __stdcall SendVsbMessage(TYPE_VSB_CHANNEL_CONDITION iVsbChannelCondition,TYPE_VSB_NTSC_REJECTION_FILTER iVsbNtscRegectionFilter,TYPE_MPEG_OUTPUT_MODE iMpegOutputMode,TYPE_TUNER_PHASE_NOISE iTunerPhaseNoise)
717	{
718	unsigned char ucaSendData[3];
719	unsigned short usSendData = 0;
720
721
722	if(VSB_CHANNEL_CONDITION_STATIC == iVsbChannelCondition)
723	usSendData = 1;
724	else if(VSB_CHANNEL_CONDITION_DYNAMIC == iVsbChannelCondition)
725	usSendData = 2;
726	else if(VSB_CHANNEL_CONDITION_FAST_DYNAMIC == iVsbChannelCondition)
727	usSendData = 3;
728	else if(VSB_CHANNEL_CONDITION_AUTO != iVsbChannelCondition)
729	return UNDEFINED_CHANNEL_CONDITION;
730
731
732	if(VSB_NTSC_REJECTION_FILTER_OFF == iVsbNtscRegectionFilter)
733	usSendData \|= 0x4;
734	else if(VSB_NTSC_REJECTION_FILTER_ON == iVsbNtscRegectionFilter)
735	usSendData \|= 0xc;
736	else if(VSB_NTSC_REJECTION_FILTER_AUTO != iVsbNtscRegectionFilter)
737	return UNDEFINED_NTSC_REJECTION_FILTER;
738
739	if(MPEG_OUTPUT_MODE_CONTROLED_BY_PRM_PINS == iMpegOutputMode)
740	usSendData \|= 0x00;
741	else if(MPEG_OUTPUT_MODE_PARALLEL == iMpegOutputMode)
742	usSendData \|= 0x20;
743	else if(MPEG_OUTPUT_MODE_SERIAL == iMpegOutputMode)
744	usSendData \|= 0x60;
745	else
746	return UNDEFINED_MPEG_SERIAL_OUTPUT_MODE;
747
748
749	if(TUNER_PHASE_NOISE_HIGH == iTunerPhaseNoise)
750	usSendData \|= 0x40;
751	else if(TUNER_PHASE_NOISE_NORMAL != iTunerPhaseNoise)
752	return UNDEFINED_TUNER_PHASE_NOISE;
753
754
755	ucaSendData[1] = (unsigned char)(usSendData >> 8);
756	ucaSendData[2] = (unsigned char)usSendData;
757
758	return SendToReceive(1, ucaSendData, 2);
759
760	}
761
762
763	unsigned int __stdcall SendItubMessage(TYPE_ITUB_DE_INTERLEAVER_MODE iItubDeInterlieverMode,TYPE_MPEG_OUTPUT_MODE iMpegOutputMode,TYPE_TUNER_PHASE_NOISE iTunerPhaseNoise)
764	{
765	unsigned char ucaSendData[3];
766	unsigned short usSendData = 0;
767
768	if(ITUB_DE_INTERLEAVER_MODE_AUTOMATIC == iItubDeInterlieverMode)
769	usSendData = 0xf;
770	else if(ITUB_DE_INTERLEAVER_MODE_128_1 == iItubDeInterlieverMode)
771	usSendData = 0x1;
772	else if(ITUB_DE_INTERLEAVER_MODE_128_2 == iItubDeInterlieverMode)
773	usSendData = 0x2;
774	else if(ITUB_DE_INTERLEAVER_MODE_64_2 == iItubDeInterlieverMode)
775	usSendData = 0x3;
776	else if(ITUB_DE_INTERLEAVER_MODE_128_3 == iItubDeInterlieverMode)
777	usSendData = 0x4;
778	else if(ITUB_DE_INTERLEAVER_MODE_32_4 == iItubDeInterlieverMode)
779	usSendData = 0x5;
780	else if(ITUB_DE_INTERLEAVER_MODE_128_4 == iItubDeInterlieverMode)
781	usSendData = 0x6;
782	else if(ITUB_DE_INTERLEAVER_MODE_16_8 == iItubDeInterlieverMode)
783	usSendData = 0x7;
784	else if(ITUB_DE_INTERLEAVER_MODE_8_16 == iItubDeInterlieverMode)
785	usSendData = 0x9;
786	else
787	return UNDEFINED_ITUB_DE_INTERLEAVER_MODE;
788
789
790	if(MPEG_OUTPUT_MODE_CONTROLED_BY_PRM_PINS == iMpegOutputMode)
791	usSendData \|= 0x00;
792	else if(MPEG_OUTPUT_MODE_PARALLEL == iMpegOutputMode)
793	usSendData \|= 0x20;
794	else if(MPEG_OUTPUT_MODE_SERIAL == iMpegOutputMode)
795	usSendData \|= 0x60;
796	else
797	return UNDEFINED_MPEG_SERIAL_OUTPUT_MODE;
798
799
800	if(TUNER_PHASE_NOISE_HIGH == iTunerPhaseNoise)
801	usSendData \|= 0x40;
802	else if(TUNER_PHASE_NOISE_NORMAL != iTunerPhaseNoise)
803	return UNDEFINED_TUNER_PHASE_NOISE;
804
805
806	ucaSendData[1] = (unsigned char)(usSendData >> 8);
807	ucaSendData[2] = (unsigned char)usSendData;
808
809	return SendToReceive(1, ucaSendData, 2);
810
811	}
812
813	NUMERATOR_DENOMINATOR __stdcall GetAgcIfCommand(int * piError)
814	{
815	unsigned short usReceivedWord = 0;
816	NUMERATOR_DENOMINATOR stResult;
817
818	stResult.Numerator.lNumerator = 0;
819	stResult.Denominator.lDenominator = 32768;
820
821	//receive the AGC IF Command value from transmit register 5
822	usReceivedWord = ReceiveTransmitRegisterValue(5,piError);
823	if(IIC_COM_SUCCESS != *piError){
824	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
825	return stResult;
826	}
827
828	if(usReceivedWord > 0x7fff)
829	stResult.Numerator.lNumerator = usReceivedWord - 0x10000;
830	else
831	stResult.Numerator.lNumerator = usReceivedWord ;
832	return stResult;
833
834	}
835
836	NUMERATOR_DENOMINATOR __stdcall GetAGCSensor(int * piError)
837	{
838	NUMERATOR_DENOMINATOR stResult;
839	unsigned short usReceivedWord = 0;
840	stResult.Numerator.lNumerator = 0;
841	stResult.Denominator.lDenominator = 32768;
842
843	usReceivedWord = ReceiveTransmitRegisterValue(6,piError);
844	if(IIC_COM_SUCCESS != *piError){
845	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
846	return stResult;
847	}
848
849	if(usReceivedWord > 0x7fff)
850	stResult.Numerator.lNumerator = usReceivedWord - 0x10000;
851	else
852	stResult.Numerator.lNumerator = usReceivedWord ;
853
854	return stResult;
855	}
856
857
858	CAS_2B_CODE_VERSION __stdcall GetDSPFirmwareVersion(int * piError)
859	{
860	CAS_2B_CODE_VERSION stCodeVersion;
861	*piError = ReceiveVector(1,stCodeVersion.usaVector,6);
862	return stCodeVersion;
863	}
864
865	unsigned char __stdcall GetHardwareVersion(int * piError)
866	{
867	if(0 != SendHostControl(0xc0,0x0)){
868	*piError = SEND_HOST_CONTROL_FUNCTION_FAILED;
869	return 0;
870	}
871
872	return ReceiveByteOfData((unsigned int *)piError);
873
874	}
875
876	long __stdcall GetCarrierOffset(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,int * piError)
877	{
878	unsigned short usReceivedWord = 0;
879	long lTmp=0;
880	short sReceivedData;
881
882	//read the transmit 4 register value
883	usReceivedWord = ReceiveTransmitRegisterValue(4,piError);
884	if(IIC_COM_SUCCESS != *piError){
885	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
886	return 0;
887	}
888
889	if(usReceivedWord > 0x7fff)
890	sReceivedData = usReceivedWord - 0x10000;
891	else
892	sReceivedData = usReceivedWord;
893
894	//
895	// Auto DetectÀÌ¸é, Receiver Mode¸¦ Á÷Á¢ ¾òÀ½.
896	//
897	if ( iReceiverMode==CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT ) {
898	iReceiverMode=GetReceiveMode(piError);
899	if(IIC_COM_SUCCESS != *piError){
900	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
901	return 0;
902	}
903	}
904
905	if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode)
906	lTmp = sReceivedData * VSB_CARRIER_OFFSET_MULTIPLIER + (sReceivedData*VSB_CARRIER_OFFSET_FLOATING_POINT_MULTIPLIER)/VSB_CARRIER_OFFSET_FLOATING_POINT_DIVIDER;
907	else if(CAS_2B_RECEIVER_MODE_ITUB_64 == iReceiverMode)
908	lTmp = sReceivedData * ITUB_QAM_64_CARRIER_OFFSET_MULTIPLIER + (sReceivedData*ITUB_QAM_64_CARRIER_OFFSET_FLOATING_POINT_MULTIPLIER)/ITUB_QAM_64_CARRIER_FLOATING_POINT_DIVIDER;
909	else if(CAS_2B_RECEIVER_MODE_ITUB_256 == iReceiverMode)
910	lTmp = sReceivedData * ITUB_QAM_256_CARRIER_OFFSET_MULTIPLIER + (sReceivedData*ITUB_QAM_256_CARRIER_OFFSET_FLOATING_POINT_MULTIPLIER)/ITUB_QAM_256_CARRIER_FLOATING_POINT_DIVIDER;
911
912	//now round the number to Khz
913	if(lTmp > 0)
914	lTmp = ((lTmp + 555)*1000)/1000;
915	else
916	lTmp = ((lTmp - 555)*1000)/1000;
917
918
919	return (lTmp/1000);
920	}
921
922	long __stdcall GetNtscCarrierOffset(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,int * piError)
923	{
924	unsigned short usReceivedWord = 0;
925	long lTmp = 0;
926	short sReceivedData;
927	int iTransmitIndex = 0;
928
929	if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode)//for backward compatibility - it works only for VSB
930	iTransmitIndex = 12;
931
932	//read the transmit 12 register value
933	usReceivedWord = ReceiveTransmitRegisterValue(iTransmitIndex,piError);
934	if(IIC_COM_SUCCESS != *piError){
935	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
936	return 0;
937	}
938
939	if(usReceivedWord > 0x7fff)
940	sReceivedData = usReceivedWord - 0x10000;
941	else
942	sReceivedData = usReceivedWord;
943
944	if(CAS_2B_RECEIVER_MODE_VSB_8_TR == iReceiverMode)//for backward compatibility - it works only for VSB
945	lTmp = sReceivedData * VSB_CARRIER_OFFSET_MULTIPLIER + (sReceivedData*VSB_CARRIER_OFFSET_FLOATING_POINT_MULTIPLIER)/VSB_CARRIER_OFFSET_FLOATING_POINT_DIVIDER;
946
947	//now round the number to Khz
948	if(lTmp > 0)
949	lTmp = ((lTmp + 555)*1000)/1000;
950	else
951	lTmp = ((lTmp - 555)*1000)/1000;
952
953
954	return (lTmp/1000);
955	}
956
957	CHECKSUM_STATUS __stdcall GetChecksumFlag(int *piError)
958	{
959	unsigned char ucCheckumResult = 0;
960	if(0 != SendHostControl(0xb0,0x0)){
961	*piError = SEND_HOST_CONTROL_FUNCTION_FAILED;
962	return ((CHECKSUM_STATUS)0);
963	}
964
965	ucCheckumResult = ReceiveByteOfData((unsigned int *)piError);
966	if(ucCheckumResult)
967	return CHECKSUM_STATUS_CORRECT;
968	else
969	return CHECKSUM_STATUS_INCORRECT;
970
971	}
972
973	unsigned short __stdcall GetStatusReg(int *piError)
974	{
975	unsigned short statReg = 0;
976	if(0 != SendHostControl(0xD0,0x0)){
977	*piError = SEND_HOST_CONTROL_FUNCTION_FAILED;
978	return ((CHECKSUM_STATUS)0);
979	}
980
981	statReg = ReceiveWordOfData((unsigned int *)piError);
982	return statReg;
983	}
984
985	unsigned short __stdcall GetChecksum(int *piError)
986	{
987	unsigned short statReg = 0;
988	if(0 != SendHostControl(0xA0,0x0)){
989	*piError = SEND_HOST_CONTROL_FUNCTION_FAILED;
990	return ((CHECKSUM_STATUS)0);
991	}
992
993	statReg = ReceiveWordOfData((unsigned int *)piError);
994	return statReg;
995	}
996
997	unsigned int __stdcall ResetChecksum()
998	{
999	// unsigned char ucCheckumResult = 0;
1000	//reset the checksum register
1001	if(0 != SendHostControl(0x81,0x0))
1002	return SEND_HOST_CONTROL_FUNCTION_FAILED;
1003
1004	//set checksum meckanism to normal opration
1005	return SendHostControl(0x80,0x0);
1006	}
1007
1008	#if SUPPORT_TUNER_DTT760x
1009	int SetTunerDTT760xATSC(TYPE_TUNERDTT760xATSC_SET_OPTION TunerSet, void* pvTunerSet,
1010	CHANNEL_TABLE_TYPE iChannelTable,
1011	TYPE_TUNERDTT760xATSC_REF_DIVIDER_RATIO iRefDividerRatio,
1012	TYPE_TUNERDTT760xATSC_AGC iAgc,
1013	BOOLEAN bUseExternalAgc ,
1014	TYPE_TUNERDTT760xATSC_CHARGE_PUMP iChargePump,
1015	TYPE_TUNERDTT760xATSC_AGC_TIME_CONSTANT iAgcTimeConstant )
1016	{
1017	unsigned int uiAgc,uiChargePump,uiAgcTimeConstant;
1018	int iRes;
1019
1020	if((TUNERDTT760xATSC_REF_DIVIDER_RATIO_31_25 != iRefDividerRatio) && (TUNERDTT760xATSC_REF_DIVIDER_RATIO_50 != iRefDividerRatio)&&
1021	(TUNERDTT760xATSC_REF_DIVIDER_RATIO_62_5 != iRefDividerRatio) && (TUNERDTT760xATSC_REF_DIVIDER_RATIO_166_7 != iRefDividerRatio))
1022	return CASCADE_UNDEFINED_TUNER_DTT760xATSC_REF_DIVIDER_RATIO_TYPE;
1023
1024	if(TUNERDTT760xATSC_AGC_91 == iAgc)
1025	uiAgc = 91;
1026	else if(TUNERDTT760xATSC_AGC_94 == iAgc)
1027	uiAgc = 94;
1028	else if(TUNERDTT760xATSC_AGC_97 == iAgc)
1029	uiAgc = 97;
1030	else if(TUNERDTT760xATSC_AGC_100 == iAgc)
1031	uiAgc = 100;
1032	else if(TUNERDTT760xATSC_AGC_103 == iAgc)
1033	uiAgc = 103;
1034	else if(TUNERDTT760xATSC_AGC_106 == iAgc)
1035	uiAgc = 106;
1036	else
1037	return CASCADE_UNDEFINED_TUNER_DTT760xATSC_AGC_TYPE;
1038
1039	if(TUNERDTT760xATSC_CHARGE_PUMP_60 == iChargePump)
1040	uiChargePump = 60;
1041	else if(TUNERDTT760xATSC_CHARGE_PUMP_280 == iChargePump)
1042	uiChargePump = 280;
1043	else
1044	return CASCADE_UNDEFINED_TUNER_DTT760xATSC_CHRGE_PUMP_TYPE;
1045
1046	if(TUNERDTT760xATSC_AGC_TIME_CONSTANT_50_MS == iAgcTimeConstant)
1047	uiAgcTimeConstant = 50;
1048	else if(TUNERDTT760xATSC_AGC_TIME_CONSTANT_2_SEC == iAgcTimeConstant)
1049	uiAgcTimeConstant = 2;
1050	else
1051	return CASCADE_UNDEFINED_TUNER_DTT760xATSC_AGC_TIME_CONSTANT_TYPE;
1052
1053	if( TUNERDTT760xATSC_SET_CHANNEL == TunerSet)
1054	iRes = TunerDTT760xATSCSendChannel(((unsigned long)pvTunerSet), iChannelTable,iRefDividerRatio,uiAgc, bUseExternalAgc,uiChargePump, uiAgcTimeConstant);
1055	else if( TUNERDTT760xATSC_SET_CENTER_FREQUENCY_KHZ == TunerSet)
1056	iRes = TunerDTT760xATSCSendFreq(((unsigned long)pvTunerSet),iRefDividerRatio,uiAgc, bUseExternalAgc,uiChargePump, uiAgcTimeConstant);
1057	else if( TUNERDTT760xATSC_SET_PIC_CARRIER_KHZ == TunerSet)
1058	iRes = TunerDTT760xATSCSendPicCarrier(((unsigned long)pvTunerSet),iRefDividerRatio,uiAgc, bUseExternalAgc,uiChargePump, uiAgcTimeConstant);
1059	else
1060	return CASCADE_UNDEFINED_TUNER_DTT760xATSC_SET_OPTION_TYPE;
1061
1062	switch(iRes){
1063	case TUNER_DTT760xATSC_SUCCESS:
1064	return CAS_2B_API_SUCCESS;
1065	case TUNER_DTT760xATSC_CHANNEL_OUT_OF_RANGE:
1066	return CASCADE_TUNER_DTT760xATSC_CHANNEL_OUT_OF_RANGE;
1067	case TUNER_DTT760xATSC_N_VALU_OUT_OF_RANGE:
1068	return CASCADE_TUNER_DTT760xATSC_N_VALUE_OUT_OF_RANGE;
1069	case TUNER_DTT760xATSC_SEND_CONTROL_DATA_FAILED:
1070	case TUNER_DTT760xATSC_BEFORE_SEND_BYTES_FAILED:
1071	case TUNER_DTT760xATSC_AFTER_SEND_BYTES_FAILED:
1072	return CASCADE_TUNER_DTT760xATSC_SEND_CONTROL_DATA_FAILED;
1073	case TUNER_DTT760xATSC_FREQUENCY_VALUE_OUT_OF_RANGE:
1074	return CASCADE_TUNER_DTT760xATSC_FREQUENCY_VALUE_OUT_OF_RANGE;
1075	case TUNER_DTT760xATSC_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY:
1076	return CASCADE_TUNER_DTT760xATSC_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY;
1077	default:
1078	return CASCADE_TUNER_DTT760xATSC_GENERAL_FAILIUR;
1079	}
1080	}
1081	#endif /* SUPPORT_TUNER_DTT760x */
1082	#if NIMTN_TYPE==NIMTN_DTT7611
1083	#if SUPPORT_TUNER_DTT7611
1084	int __stdcall SetTunerDTT7611(TYPE_TUNER_SET_OPTION TunerSet, void* pvTunerSet,
1085	CHANNEL_TABLE_TYPE iChannelTable,
1086	TYPE_TUNERDTT7611_REF_DIVIDER_RATIO iRefDividerRatio ,
1087	TYPE_TUNERDTT7611_AGC iAgc,
1088	TYPE_TUNER_AGC_MODE iAgcMode,
1089	CHARGE_PUMP iChargePump,
1090	TYPE_TUNERDTT7611_AGC_TIME_CONSTANT iAgcTimeConstant )
1091	{
1092	unsigned int uiAgc,uiChargePump,uiAgcTimeConstant,uiAgcMode;
1093	int iRes;
1094
1095	if((TUNERDTT7611_REF_DIVIDER_RATIO_31_25 != iRefDividerRatio) &&
1096	(TUNERDTT7611_REF_DIVIDER_RATIO_50 != iRefDividerRatio) &&
1097	(TUNERDTT7611_REF_DIVIDER_RATIO_62_5 != iRefDividerRatio) &&
1098	(TUNERDTT7611_REF_DIVIDER_RATIO_166_7 != iRefDividerRatio))
1099	return CAS_2B_UNDEFINED_TUNER_DTT761X_REF_DIVIDER_RATIO_TYPE;
1100
1101	if(TUNERDTT7611_AGC_102_A == iAgc)
1102	uiAgc = 0;
1103	else if(TUNERDTT7611_AGC_102_B == iAgc)
1104	uiAgc = 1;
1105	else if(TUNERDTT7611_AGC_99 == iAgc)
1106	uiAgc = 2;
1107	else if(TUNERDTT7611_AGC_96 == iAgc)
1108	uiAgc = 3;
1109	else if(TUNERDTT7611_AGC_93 == iAgc)
1110	uiAgc = 4;
1111	else if(TUNERDTT7611_AGC_90 == iAgc)
1112	uiAgc = 5;
1113	else if(TUNERDTT7611_AGC_WIDE_BAND_OFF == iAgc)
1114	uiAgc = 6;
1115	else
1116	return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_TYPE;
1117
1118	if(TUNERDTT7611_CHARGE_PUMP_60 == iChargePump)
1119	uiChargePump = 60;
1120	else if(TUNERDTT7611_CHARGE_PUMP_280 == iChargePump)
1121	uiChargePump = 280;
1122	else
1123	return CAS_2B_UNDEFINED_TUNER_DTT761X_CHRGE_PUMP_TYPE;
1124
1125	if(TUNERDTT7611_AGC_TIME_CONSTANT_50_MS == iAgcTimeConstant)
1126	uiAgcTimeConstant = 50;
1127	else if(TUNERDTT7611_AGC_TIME_CONSTANT_2_SEC == iAgcTimeConstant)
1128	uiAgcTimeConstant = 2;
1129	else
1130	return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_TIME_CONSTANT_TYPE;
1131
1132	if(TUNER_AGC_MODE_INTERNAL_DIGITAL == iAgcMode )
1133	uiAgcMode = 1;
1134	else if(TUNER_AGC_MODE_INTERNAL_ANALOG == iAgcMode)
1135	uiAgcMode = 2;
1136	else
1137	return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_MODE_TYPE;
1138
1139	if( TUNER_SET_CHANNEL == TunerSet)
1140	iRes = TunerDTT7611SendChannel(((unsigned long)pvTunerSet),iChannelTable,iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant);
1141	else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet)
1142	iRes = TunerDTT7611SendFreq(((unsigned long)pvTunerSet),iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant);
1143	else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet)
1144	iRes = TunerDTT7611SendPicCarrier(((unsigned long)pvTunerSet),iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant);
1145	else
1146	return CAS_2B_UNDEFINED_TUNER_DTT761X_SET_OPTION_TYPE;
1147
1148	switch(iRes){
1149	case DTT7611_SUCCESS:
1150	return CAS_2B_API_SUCCESS;
1151	case DTT7611_CHANNEL_OUT_OF_RANGE:
1152	return CAS_2B_TUNER_DTT761X_CHANNEL_OUT_OF_RANGE;
1153	case DTT7611_COULD_NOT_SET_N:
1154	return CAS_2B_TUNER_DTT761X_N_VALUE_OUT_OF_RANGE;
1155	case DTT7611_SEND_CONTROL_DATA_FAILED:
1156	case DTT7611_BEFORE_SEND_BYTES_FAILED:
1157	case DTT7611_AFTER_SEND_BYTES_FAILED:
1158	return CAS_2B_TUNER_DTT761X_SEND_CONTROL_DATA_FAILED;
1159	case DTT7611_FREQUENCY_VALUE_OUT_OF_RANGE:
1160	return CAS_2B_TUNER_DTT761X_FREQUENCY_VALUE_OUT_OF_RANGE;
1161	case DTT7611_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY:
1162	return CAS_2B_TUNER_DTT761X_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY;
1163	default:
1164	return CAS_2B_TUNER_DTT761X_GENERAL_FAILIUR;
1165	}
1166	}
1167	#endif /* SUPPORT_TUNER_DTT7611 */
1168	#endif
1169	#if NIMTN_TYPE==NIMTN_DTT7612
1170	#if SUPPORT_TUNER_DTT7612
1171	int __stdcall SetTunerDTT7612(TYPE_TUNER_SET_OPTION TunerSet, void* pvTunerSet,
1172	CHANNEL_TABLE_TYPE iChannelTable,
1173	TYPE_TUNERDTT7612_REF_DIVIDER_RATIO iRefDividerRatio ,
1174	TYPE_TUNERDTT7612_AGC iAgc,
1175	TYPE_TUNER_AGC_MODE iAgcMode,
1176	CHARGE_PUMP iChargePump,
1177	TYPE_TUNERDTT7612_AGC_TIME_CONSTANT iAgcTimeConstant )
1178	{
1179	unsigned int uiAgc,uiChargePump,uiAgcTimeConstant,uiAgcMode;
1180	int iRes;
1181
1182	if((TUNERDTT7612_REF_DIVIDER_RATIO_31_25 != iRefDividerRatio) &&
1183	(TUNERDTT7612_REF_DIVIDER_RATIO_50 != iRefDividerRatio) &&
1184	(TUNERDTT7612_REF_DIVIDER_RATIO_62_5 != iRefDividerRatio) &&
1185	(TUNERDTT7612_REF_DIVIDER_RATIO_166_7 != iRefDividerRatio))
1186	return CAS_2B_UNDEFINED_TUNER_DTT761X_REF_DIVIDER_RATIO_TYPE;
1187
1188	if(TUNERDTT7612_AGC_102_A == iAgc)
1189	uiAgc = 0;
1190	else if(TUNERDTT7612_AGC_102_B == iAgc)
1191	uiAgc = 1;
1192	else if(TUNERDTT7612_AGC_99 == iAgc)
1193	uiAgc = 2;
1194	else if(TUNERDTT7612_AGC_96 == iAgc)
1195	uiAgc = 3;
1196	else if(TUNERDTT7612_AGC_93 == iAgc)
1197	uiAgc = 4;
1198	else if(TUNERDTT7612_AGC_90 == iAgc)
1199	uiAgc = 5;
1200	else if(TUNERDTT7612_AGC_WIDE_BAND_OFF == iAgc)
1201	uiAgc = 6;
1202	else
1203	return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_TYPE;
1204
1205	if(TUNERDTT7612_CHARGE_PUMP_60 == iChargePump)
1206	uiChargePump = 60;
1207	else if(TUNERDTT7612_CHARGE_PUMP_280 == iChargePump)
1208	uiChargePump = 280;
1209	else
1210	return CAS_2B_UNDEFINED_TUNER_DTT761X_CHRGE_PUMP_TYPE;
1211
1212	if(TUNERDTT7612_AGC_TIME_CONSTANT_50_MS == iAgcTimeConstant)
1213	uiAgcTimeConstant = 50;
1214	else if(TUNERDTT7612_AGC_TIME_CONSTANT_2_SEC == iAgcTimeConstant)
1215	uiAgcTimeConstant = 2;
1216	else
1217	return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_TIME_CONSTANT_TYPE;
1218
1219	if(TUNER_AGC_MODE_INTERNAL_DIGITAL == iAgcMode )
1220	uiAgcMode = 1;
1221	else if(TUNER_AGC_MODE_INTERNAL_ANALOG == iAgcMode)
1222	uiAgcMode = 2;
1223	else
1224	return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_MODE_TYPE;
1225
1226	if( TUNER_SET_CHANNEL == TunerSet)
1227	iRes = TunerDTT7612SendChannel(((unsigned long)pvTunerSet),iChannelTable,iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant);
1228	else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet)
1229	iRes = TunerDTT7612SendFreq(((unsigned long)pvTunerSet),iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant);
1230	else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet)
1231	iRes = TunerDTT7612SendPicCarrier(((unsigned long)pvTunerSet),iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant);
1232	else
1233	return CAS_2B_UNDEFINED_TUNER_DTT761X_SET_OPTION_TYPE;
1234
1235	switch(iRes){
1236	case DTT7612_SUCCESS:
1237	return CAS_2B_API_SUCCESS;
1238	case DTT7612_CHANNEL_OUT_OF_RANGE:
1239	return CAS_2B_TUNER_DTT761X_CHANNEL_OUT_OF_RANGE;
1240	case DTT7612_COULD_NOT_SET_N:
1241	return CAS_2B_TUNER_DTT761X_N_VALUE_OUT_OF_RANGE;
1242	case DTT7612_SEND_CONTROL_DATA_FAILED:
1243	case DTT7612_BEFORE_SEND_BYTES_FAILED:
1244	case DTT7612_AFTER_SEND_BYTES_FAILED:
1245	return CAS_2B_TUNER_DTT761X_SEND_CONTROL_DATA_FAILED;
1246	case DTT7612_FREQUENCY_VALUE_OUT_OF_RANGE:
1247	return CAS_2B_TUNER_DTT761X_FREQUENCY_VALUE_OUT_OF_RANGE;
1248	case DTT7612_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY:
1249	return CAS_2B_TUNER_DTT761X_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY;
1250	default:
1251	return CAS_2B_TUNER_DTT761X_GENERAL_FAILIUR;
1252	}
1253	}
1254	#endif
1255	#endif//#if NIMTN_TYPE==NIMTN_DTT7612
1256	#if NIMTN_TYPE==NIMTN_T2000
1257	#if SUPPORT_TUNER_THOMSON_T_2000
1258	int __stdcall SetTunerThomsonT2000( TYPE_TUNER_THOMSON_T2000_SET_OPTION iTunerSet, void* pvTunerSet,
1259	TYPE_TUNER_THOMSON_T2000_AGC_SELECTION iAgcSelection,
1260	TYPE_TUNER_THOMSON_T2000_INPUT_SELECTION iInput,
1261	TYPE_THOMSON_T2000_REF_DIVIDER_RATIO iRefDividerRatio,
1262	TYPE_TUNER_THOMSON_T2000_MODE iMode
1263	)
1264	{
1265	int iError;
1266	unsigned long ulRefDividerRatio = 1;
1267	switch(iRefDividerRatio){
1268	case THOMSON_T2000_REF_DIVIDER_RATIO_166_6:
1269	ulRefDividerRatio = 166600;
1270	break;
1271	case THOMSON_T2000_REF_DIVIDER_RATIO_62_5:
1272	ulRefDividerRatio = 62500;
1273	break;
1274	case THOMSON_T2000_REF_DIVIDER_RATIO_50:
1275	ulRefDividerRatio = 50000;
1276	break;
1277	default:
1278	return TUNER_THOMSON_T2000_UNDEFINED_REF_DIVIDER_RATIO;
1279	}
1280
1281	if(TUNER_THOMSON_T2000_SET_CHANNEL == iTunerSet)
1282	iError = TunerThomsonT2000SendChannel((unsigned long) pvTunerSet,iAgcSelection,iInput,ulRefDividerRatio,iMode);
1283	else if(TUNER_THOMSON_T2000_SET_PIC_CARRIER == iTunerSet)
1284	iError = TunerThomsonT2000SendPicCarrier((unsigned long) pvTunerSet,iAgcSelection,iInput,ulRefDividerRatio,iMode);
1285	else if(TUNER_THOMSON_T2000_SET_CENTER_FREQUENCY == iTunerSet)
1286	iError = TunerThomsonT2000SendCenterFreq((unsigned long) pvTunerSet,iAgcSelection,iInput,ulRefDividerRatio,iMode);
1287
1288	switch(iError){
1289	case THOMSON_T2000_SEND_CONTROL_DATA_SUCCESS:
1290	return CAS_2B_API_SUCCESS;
1291	case THOMSON_T2000_SEND_CONTROL_DATA_FAILED:
1292	return TUNER_THOMSON_T2000_SEND_CONTROL_DATA_FAILED;
1293	case THOMSON_T2000_UNDEFINED_AGC_SELECTION:
1294	return TUNER_THOMSON_T2000_UNDEFINED_AGC_SELECTION;
1295	case THOMSON_T2000_UNDEFINED_INPUT:
1296	return TUNER_THOMSON_T2000_UNDEFINED_INPUT;
1297	case THOMSON_T2000_UNDEFINED_MODE:
1298	return TUNER_THOMSON_T2000_UNDEFINED_MODE;
1299	default:
1300	return TUNER_THOMSON_T2000_SEND_CONTROL_DATA_FAILED;
1301	}
1302	}
1303	#endif /* SUPPORT_TUNER_THOMSON_T_2000 */
1304	#endif//#if NIMTN_TYPE==NIMTN_T2000
1305	#if NIMTN_TYPE==NIMTN_TD6650T
1306	#if SUPPORT_TUNER_PHILIPS_TD6650T
1307	int __stdcall SetTunerTD6650T(TYPE_TUNER_SET_OPTION TunerSet, void* pvTunerSet,
1308	CHANNEL_TABLE_TYPE iChannelTable,
1309	TYPE_TD6650T_REF_DIVIDER_RATIO iReferenceDividerRatio ,
1310	TYPE_TD6650T_AGC_TOP iAGCTakeOverPoint,
1311	TYPE_TD6650T_ATC iAtc)
1312	{
1313	int iRes;
1314
1315	if((TD6650T_REF_DIVIDER_RATIO_62_5 != iReferenceDividerRatio) &&
1316	(TD6650T_REF_DIVIDER_RATIO_142_86 != iReferenceDividerRatio) &&
1317	(TD6650T_REF_DIVIDER_RATIO_166_67 != iReferenceDividerRatio) &&
1318	(TD6650T_REF_DIVIDER_RATIO_50 != iReferenceDividerRatio)&&
1319	(TD6650T_REF_DIVIDER_RATIO_125 != iReferenceDividerRatio))
1320	return CAS_2B_UNDEFINED_TUNER_TD6650T_REF_DIVIDER_RATIO_TYPE;
1321
1322	if((TD6650T_AGC_TOP_124 != iAGCTakeOverPoint)&&
1323	(TD6650T_AGC_TOP_121 != iAGCTakeOverPoint)&&
1324	(TD6650T_AGC_TOP_118 != iAGCTakeOverPoint)&&
1325	(TD6650T_AGC_TOP_115 != iAGCTakeOverPoint)&&
1326	(TD6650T_AGC_TOP_112 != iAGCTakeOverPoint)&&
1327	(TD6650T_AGC_TOP_109 != iAGCTakeOverPoint))
1328	return CAS_2B_UNDEFINED_TUNER_TD6650T_AGC_TYPE;
1329
1330	if((TD6650T_ATC_2_SEC != iAtc)&&
1331	(TD6650T_ATC_50_MSEC != iAtc))
1332	return CAS_2B_UNDEFINED_TUNER_TD6650T_AGC_TIME_CONSTANT_TYPE;
1333
1334	if( TUNER_SET_CHANNEL == TunerSet)
1335	iRes = TD6650TSendChannel(((unsigned long)pvTunerSet),iChannelTable,iReferenceDividerRatio,iAGCTakeOverPoint, iAtc);
1336	else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet)
1337	iRes = TD6650TSendFreq(((unsigned long)pvTunerSet),iChannelTable,iReferenceDividerRatio,iAGCTakeOverPoint, iAtc);
1338	else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet)
1339	iRes = TD6650TSendPicCarrier(((unsigned long)pvTunerSet),iChannelTable,iReferenceDividerRatio,iAGCTakeOverPoint, iAtc);
1340	else
1341	return CAS_2B_UNDEFINED_TUNER_TD6650T_SET_OPTION_TYPE;
1342
1343	switch(iRes){
1344	case TD6650T_SUCCESS:
1345	return CAS_2B_API_SUCCESS;
1346	case TD6650T_FREQUENCY_VALUE_OUT_OF_RANGE:
1347	return CAS_2B_TUNER_TD6650T_FREQUENCY_VALUE_OUT_OF_RANGE;
1348	case TD6650T_BEFORE_SEND_BYTES_FAILED:
1349	return CAS_2B_TUNER_TD6650T_BEFORE_SEND_BYTES_FAILED;
1350	case TD6650T_AFTER_SEND_BYTES_FAILED:
1351	return CAS_2B_TUNER_TD6650T_AFTER_SEND_BYTES_FAILED;
1352	case TD6650T_SEND_CONTROL_DATA_FAILED:
1353	return CAS_2B_TUNER_TD6650T_SEND_CONTROL_DATA_FAILED;
1354	default:
1355	return CAS_2B_TUNER_TD6650T_GENERAL_FAILIUR;
1356	}
1357	}
1358	#endif
1359	#endif
1360	#if NIMTN_TYPE==NIMTN_XC3028
1361	#if SUPPORT_TUNER_XCEIVE_XC3028
1362	int __stdcall SetTunerXC3028(TYPE_TUNER_SET_OPTION TunerSet, void* pvTunerSet,BOOLEAN bLoadFirmware,TYPE_TUNER_FIRMAWARE_MODE iFirmwareMode)
1363	{
1364	int iRes;
1365
1366	if( TUNER_SET_CHANNEL == TunerSet)
1367	iRes = TunerXC3028SendChannel(((unsigned long)pvTunerSet),bLoadFirmware,iFirmwareMode);
1368	else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet)
1369	iRes = TunerXC3028SendCenterFreq(((unsigned long)pvTunerSet),bLoadFirmware,iFirmwareMode);
1370	else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet)
1371	iRes = TunerXC3028SendPicCarrier(((unsigned long)pvTunerSet),bLoadFirmware,iFirmwareMode);
1372	else
1373	return CAS_2B_UNDEFINED_TUNER_XC3028_SET_OPTION_TYPE;
1374
1375	switch(iRes){
1376	case XC3028_SUCCESS:
1377	return CAS_2B_API_SUCCESS;
1378	case XC3028_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY:
1379	return CAS_2B_TUNER_XC3028_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY;
1380	case XC3028_FIRMWARE_MODE_NOT_DEFINED:
1381	return CAS_2B_TUNER_XC3028_FIRMWARE_MODE_NOT_DEFINED;
1382	case XC3028_COMMUNICATION_ERROR:
1383	return CAS_2B_TUNER_XC3028_COMMUNICATION_ERROR;
1384	case XC3028_DSP_MODE_NOT_DEFINED:
1385	return CAS_2B_TUNER_XC3028_DSP_MODE_NOT_DEFINED;
1386	default:
1387	return CAS_2B_TUNER_XC3028_GENERAL_FAILIUR;
1388	}
1389
1390	}
1391	#endif /* SUPPORT_TUNER_XCEIVE_XC3028 */
1392	#endif//#if NIMTN_TYPE==NIMTN_XC3028
1393	#if NIMTN_TYPE==NIMTN_MT2121
1394	#if SUPPORT_TUNER_MT2121
1395	int __stdcall SetTunerMT2121(TYPE_TUNER_SET_OPTION TunerSet, unsigned long ulTunerSet,
1396	CHANNEL_TABLE_TYPE iChannelTable,
1397	TYPE_TUNER_MT2121_REF_DIVIDER_RATIO iReferenceDividerRatio)
1398	{
1399	int iRes;
1400
1401	if( TUNER_SET_CHANNEL == TunerSet)
1402	iRes = TunerMt2121SendChannel(ulTunerSet,iChannelTable,iReferenceDividerRatio);
1403	else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet)
1404	iRes = TunerMt2121SendCenterFrequency(ulTunerSet,iChannelTable,iReferenceDividerRatio);
1405	else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet)
1406	iRes = TunerMt2121SendPicCarrier(ulTunerSet,iChannelTable,iReferenceDividerRatio);
1407	else
1408	return CAS_2B_UNDEFINED_TUNER_MT2121_SET_OPTION_TYPE;
1409
1410	switch(iRes){
1411	case MT2121_SUCCESS:
1412	return CAS_2B_API_SUCCESS;
1413	case MT2121_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY:
1414	return CAS_2B_TUNER_MT2121_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY;
1415	case MT2121_BEFORE_SEND_BYTES_FAILED:
1416	case MT2121_AFTER_SEND_BYTES_FAILED:
1417	case MT2121_SEND_CONTROL_DATA_FAILED:
1418	return CAS_2B_TUNER_MT2121_COMMUNICATION_ERROR;
1419	default:
1420	return CAS_2B_TUNER_MT2121_GENERAL_FAILIUR;
1421	}
1422	}
1423	#endif
1424	#endif //#if NIMTN_TYPE==NIMTN_MT2121
1425	#if NIMTN_TYPE==NIMTN_TDQU
1426	#if SUPPORT_TUNER_TDQU
1427	int __stdcall SetTunerTdqu(TYPE_TUNER_SET_OPTION TunerSet, unsigned long ulTunerSet,
1428	CHANNEL_TABLE_TYPE iChannelTable,
1429	TYPE_TUNER_TDQU_REF_DIVIDER_RATIO iReferenceDividerRatio,TYPE_TUNER_TDQU_CHARGE_PUMP iChargePump,TYPE_TUNER_TDQU_AGST iAgst)
1430	{
1431	int iRes;
1432	if( TUNER_SET_CHANNEL == TunerSet)
1433	iRes = TunerTdquSendChannel(ulTunerSet,iChannelTable,iReferenceDividerRatio,iChargePump,iAgst);
1434	else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet)
1435	iRes = TunerTdquSendCenterFrequency(ulTunerSet, iReferenceDividerRatio, iChargePump, iAgst);
1436	else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet)
1437	iRes = TunerTdquSendPicCarrier( ulTunerSet,iReferenceDividerRatio, iChargePump, iAgst);
1438	else
1439	return CAS_2B_UNDEFINED_TUNER_SET_OPTION_TYPE;
1440
1441	switch(iRes)
1442	{
1443	case TDQU_SUCCESS:
1444	return CAS_2B_API_SUCCESS;
1445	case TDQU_BEFORE_SEND_BYTES_FAILED:
1446	case TDQU_AFTER_SEND_BYTES_FAILED:
1447	case TDQU_SEND_CONTROL_DATA_FAILED:
1448	return CAS_2B_TUNER_TDQU_COMMUNICATION_ERROR;
1449	case TDQU_N_CALCULATION_FAILED:
1450	case TDQU_UNDEFINED_REFERENCE_DIVIDER_RATIO:
1451	case TDQU_UNDEFINED_CHURGE_PUMP:
1452	case TDQU_UNDEFINED_AGST:
1453	case TDQU_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY:
1454	return CAS_2B_TUNER_TDQU_PARAMETER_ERROR;
1455	default:
1456	return CAS_2B_TUNER_TDQU_GENERAL_FAILIUR;
1457	}
1458
1459	}
1460	#endif /* SUPPORT_TUNER_TDQU */
1461
1462	#endif
1463	#if NIMTN_TYPE==NIMTN_FQD1236
1464	int SetTunerFQD1236(TYPE_TUNER_SET_OPTION TunerSet, void* pvTunerSet,
1465	CHANNEL_TABLE_TYPE iChannelTable,
1466	TYPE_TUNERFQD1236_REF_DIVIDER_RATIO iRefDividerRatio ,
1467	TYPE_TUNERFQD1236_AGC iAgc,
1468	TYPE_TUNER_AGC_MODE iAgcMode,
1469	CHARGE_PUMP iChargePump,
1470	TYPE_TUNERFQD1236_AGC_TIME_CONSTANT iAgcTimeConstant )
1471	{
1472	unsigned int uiAgc,uiChargePump,uiAgcTimeConstant,uiAgcMode;
1473	int iRes;
1474
1475	if((TUNERFQD1236_REF_DIVIDER_RATIO_31_25 != iRefDividerRatio) &&
1476	(TUNERFQD1236_REF_DIVIDER_RATIO_50 != iRefDividerRatio) &&
1477	(TUNERFQD1236_REF_DIVIDER_RATIO_62_5 != iRefDividerRatio) &&
1478	(TUNERFQD1236_REF_DIVIDER_RATIO_166_7 != iRefDividerRatio))
1479	return CAS_2B_UNDEFINED_TUNER_DTT761X_REF_DIVIDER_RATIO_TYPE;
1480
1481	if(TUNERFQD1236_AGC_115_A == iAgc)
1482	uiAgc = 0;
1483	else if(TUNERFQD1236_AGC_115_B == iAgc)
1484	uiAgc = 1;
1485	else if(TUNERFQD1236_AGC_112 == iAgc)
1486	uiAgc = 2;
1487	else if(TUNERFQD1236_AGC_109 == iAgc)
1488	uiAgc = 3;
1489	else if(TUNERFQD1236_AGC_106== iAgc)
1490	uiAgc = 4;
1491	else if(TUNERFQD1236_AGC_103 == iAgc)
1492	uiAgc = 5;
1493	else if(TUNERFQD1236_AGC_EXTERNAL_AGC == iAgc)
1494	uiAgc = 6;
1495	else if (TUNERFQD1236_AGC_DISABLED == iAgc)
1496	uiAgc = 7;
1497	else
1498	return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_TYPE;
1499
1500	if(TUNERFQD1236_CHARGE_PUMP_50 == iChargePump)
1501	uiChargePump = 50;
1502	else if(TUNERFQD1236_CHARGE_PUMP_250 == iChargePump)
1503	uiChargePump = 250;
1504	else
1505	return CAS_2B_UNDEFINED_TUNER_DTT761X_CHRGE_PUMP_TYPE;
1506
1507	if(TUNERFQD1236_AGC_TIME_CONSTANT_50_MS == iAgcTimeConstant)
1508	uiAgcTimeConstant = 50;
1509	else if(TUNERFQD1236_AGC_TIME_CONSTANT_2_SEC == iAgcTimeConstant)
1510	uiAgcTimeConstant = 2;
1511	else
1512	return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_TIME_CONSTANT_TYPE;
1513
1514	if(TUNER_AGC_MODE_INTERNAL_DIGITAL == iAgcMode )
1515	uiAgcMode = 1;
1516	else if(TUNER_AGC_MODE_INTERNAL_ANALOG == iAgcMode)
1517	uiAgcMode = 2;
1518	else
1519	return CAS_2B_UNDEFINED_TUNER_DTT761X_AGC_MODE_TYPE;
1520
1521	if( TUNER_SET_CHANNEL == TunerSet)
1522	iRes = TunerFQD1236SendCnannel(((unsigned long)pvTunerSet),iChannelTable,iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant);
1523	else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet)
1524	iRes = TunerFQD1236SendFreq(((unsigned long)pvTunerSet),iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant);
1525	else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet)
1526	iRes = TunerFQD1236SendPicCarrier(((unsigned long)pvTunerSet),iRefDividerRatio,uiAgc, uiAgcMode,uiChargePump, uiAgcTimeConstant);
1527	else
1528	return CAS_2B_UNDEFINED_TUNER_DTT761X_SET_OPTION_TYPE;
1529
1530	switch(iRes){
1531	case FQD1236_SUCCESS:
1532	return CAS_2B_API_SUCCESS;
1533	case FQD1236_CHANNEL_OUT_OF_RANGE:
1534	return CAS_2B_TUNER_DTT761X_CHANNEL_OUT_OF_RANGE;
1535	case FQD1236_COULD_NOT_SET_N:
1536	return CAS_2B_TUNER_DTT761X_N_VALUE_OUT_OF_RANGE;
1537	case FQD1236_SEND_CONTROL_DATA_FAILED:
1538	case FQD1236_BEFORE_SEND_BYTES_FAILED:
1539	case FQD1236_AFTER_SEND_BYTES_FAILED:
1540	return CAS_2B_TUNER_DTT761X_SEND_CONTROL_DATA_FAILED;
1541	case FQD1236_FREQUENCY_VALUE_OUT_OF_RANGE:
1542	return CAS_2B_TUNER_DTT761X_FREQUENCY_VALUE_OUT_OF_RANGE;
1543	case FQD1236_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY:
1544	return CAS_2B_TUNER_DTT761X_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY;
1545	default:
1546	return CAS_2B_TUNER_DTT761X_GENERAL_FAILIUR;
1547	}
1548	}
1549	#endif
1550	#if SUPPORT_TUNER_SN761662
1551	int __stdcall SetTunerSN761662(TYPE_TUNER_SET_OPTION TunerSet, unsigned long ulTunerSet,
1552	CHANNEL_TABLE_TYPE iChannelTable,
1553	TYPE_SN761662TUNER_REF_DIVIDER_RATIO iRefDividerRatio,TYPE_SN761662TUNER_ATC iATC, TYPE_SN761662TUNER_CP iCP,TYPE_SN761662TUNER_IFOSW iIFOSW,TYPE_SN761662TUNER_AGC_TOP_LEVEL_0_LEVEL_1 iAGCTop, TYPE_SN761662TUNER_RFAGC_SHIFT_XTALOUT_CONTROL iRFAGCShiftXtalOut)
1554	{
1555	int iRes;
1556	if( TUNER_SET_CHANNEL == TunerSet)
1557	iRes = TunerSN761662SendChannel(ulTunerSet, iChannelTable, iRefDividerRatio, iATC, iCP, iIFOSW, iAGCTop, iRFAGCShiftXtalOut);
1558	else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet)
1559	iRes = TunerSN761662SendFreq(ulTunerSet, iRefDividerRatio, iATC, iCP, iIFOSW, iAGCTop, iRFAGCShiftXtalOut);
1560	else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet)
1561	iRes = TunerSN761662SendPicCarrier(ulTunerSet,iRefDividerRatio, iATC, iCP, iIFOSW, iAGCTop, iRFAGCShiftXtalOut);
1562	else
1563	return CAS_2B_UNDEFINED_TUNER_SET_OPTION_TYPE;
1564
1565	switch(iRes)
1566	{
1567	case SN761662_SUCCESS:
1568	return CAS_2B_API_SUCCESS;
1569	case SN761662_BEFORE_SEND_BYTES_FAILED:
1570	case SN761662_AFTER_SEND_BYTES_FAILED:
1571	case SN761662_SEND_CONTROL_DATA_FAILED:
1572	return CAS_2B_TUNER_SN761662_COMMUNICATION_ERROR;
1573	case SN761662_INCORRECT_RFAGC_SHIFT_XTALOUT_CONTROL:
1574	case SN761662_INCORRECT_IFOSW:
1575	case SN761662_INCORRECT_ATC:
1576	case SN761662_INCORRECT_REF_DIVIDER_RATIO:
1577	case SN761662_FREQUENCY_VALUE_OUT_OF_RANGE:
1578	case SN761662_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY:
1579	return CAS_2B_TUNER_SN761662_PARAMETER_ERROR;
1580	default:
1581	return CAS_2B_TUNER_SN761662_GENERAL_FAILIUR;
1582	}
1583
1584	}
1585	#endif /* SUPPORT_TUNER_SN761662 */
1586
1587	#if SUPPORT_TUNER_VP13HR
1588	int __stdcall SetTunerVP13HR(TYPE_TUNER_SET_OPTION TunerSet, unsigned long ulTunerSet,
1589	CHANNEL_TABLE_TYPE iChannelTable,
1590	TYPE_TUNER_VP13HR_REF_DIVIDER_RATIO iRefDividerRatio, BOOLEAN bIsFMTrap, BOOLEAN bIsAFTReq)
1591	{
1592	int iRes;
1593	if( TUNER_SET_CHANNEL == TunerSet)
1594	iRes = TunerVP13HRSendChannel(ulTunerSet, iChannelTable, iRefDividerRatio, FALSE, bIsAFTReq);
1595	else if( TUNER_SET_CENTER_FREQUENCY_KHZ == TunerSet)
1596	if (bIsAFTReq)
1597	iRes = TunerVP13HRAFT(ulTunerSet,iRefDividerRatio, bIsFMTrap);
1598	else
1599	iRes = TunerVP13HRSendCenterFrequency(ulTunerSet, iRefDividerRatio, bIsFMTrap);
1600	else if( TUNER_SET_PIC_CARRIER_KHZ == TunerSet)
1601	iRes = TunerVP13HRSendPicCarrier(ulTunerSet, iRefDividerRatio, FALSE, bIsAFTReq);
1602	else
1603	return CAS_2B_UNDEFINED_TUNER_SET_OPTION_TYPE;
1604
1605	switch(iRes)
1606	{
1607	case VP13HR_SUCCESS:
1608	return CAS_2B_API_SUCCESS;
1609	case VP13HR_BEFORE_SEND_BYTES_FAILED:
1610	case VP13HR_AFTER_SEND_BYTES_FAILED:
1611	case VP13HR_SEND_CONTROL_DATA_FAILED:
1612	return CAS_2B_TUNER_VP13HR_COMMUNICATION_ERROR;
1613	case VP13HR_N_CALCULATION_FAILED:
1614	case VP13HR_UNDEFINED_REFERENCE_DIVIDER_RATIO:
1615	case VP13HR_CHANNEL_DOES_NOT_FIT_ANY_FREQUENCY:
1616	return CAS_2B_TUNER_VP13HR_PARAMETER_ERROR;
1617	default:
1618	return CAS_2B_TUNER_VP13HR_GENERAL_FAILIUR;
1619	}
1620
1621	}
1622	#endif
1623
1624	int __stdcall SendCodeAndData(unsigned char * pucCodeToSend,unsigned long ulCodeBufferSize,unsigned char * pucDataToSend,unsigned long ulDataBufferSize)
1625	{
1626	unsigned long ulFileLengthInBytes = 0;
1627	unsigned char * pucBuffer = NULL;
1628	int iSize,i,iError;
1629	CHECKSUM_STATUS iCheckSumStatus;
1630	CAS_2B_CODE_VERSION stCodeVersion;
1631	unsigned char puc2BCodeBuffer = (unsigned char )0;
1632	unsigned char puc2BDataBuffer = (unsigned char )0;
1633	int i2BCodeSize = 0, i2BDataSize = 0;
1634
1635	if((NULL == pucCodeToSend) \|\| (NULL == pucDataToSend))
1636	return FUNCTION_RECEIVED_NULL_PARAMETER;
1637
1638	if(CAS_2B_API_SUCCESS != ResetChecksum()) {
1639	DHL_DbgPrintf(0,DHLDBG_EXT, "ERROR: line=%d\n", __LINE__);
1640	return RESET_CHECKSUM_FUNCTION_FAILED;
1641	}
1642
1643	//first file that is sent is the code file and then the data file
1644	for(i =0;i<2;i++){
1645
1646	if(0 == i){
1647	iSize = 4; // code size
1648	ulFileLengthInBytes = ulCodeBufferSize;
1649	pucBuffer = pucCodeToSend;
1650	}
1651	else{
1652	iSize = 2; //data size
1653	ulFileLengthInBytes = ulDataBufferSize;
1654	pucBuffer = pucDataToSend;
1655	}
1656
1657
1658	if ((((ulFileLengthInBytes10)/iSize) - ((ulFileLengthInBytes/iSize)10)) != 0 ) {
1659	return FILE_SIZE_CAN_NOT_BE_DIVIDED_BY_DATA_SIZE;
1660	}
1661
1662
1663	//add the sub address
1664	if(0 == i)//code file
1665	pucBuffer[0] = 0x7e;
1666	else//data file
1667	pucBuffer[0] = 0x7d;
1668
1669	if(IIC_COM_SUCCESS != OrenIicTransmit(CASCADE_WRITE_ADDRESS,pucBuffer, (int)ulFileLengthInBytes+1)){
1670	return CAS_2B_API_SEND_CODE_AND_DATA_FUNCTION_FAILED;
1671	}
1672	}//for(int i =0;i<2;i++)
1673
1674	iCheckSumStatus = GetChecksumFlag(&iError);
1675	if((IIC_COM_SUCCESS != iError) \|\|(iCheckSumStatus != CHECKSUM_STATUS_CORRECT))
1676	return CHECKSUM_IS_INCORRECT;
1677
1678	//send run flag to see if the code suites Cas2C.
1679	if(CAS_2B_SEND_RUN_FLAG_FUNCTION_FAILED == SendCas2BRunFlag()){
1680	return CAS_2B_SEND_RUN_FLAG_FUNCTION_FAILED;
1681	}
1682
1683
1684	stCodeVersion = GetDSPFirmwareVersion(&iError);
1685
1686	if(iError != IIC_COM_SUCCESS){
1687	DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR, LINE=%d, iError=%d\n", __LINE__, iError);
1688	return CAS_2B_API_SEND_CODE_AND_DATA_FUNCTION_FAILED;
1689	}
1690
1691	//check if the code suites Cas2C - if 3 first digits are 0 we need to switch code to Cas2B
1692	if((stCodeVersion.usaVector[0] & 0xFFF0) != 0)
1693	return CAS_2B_API_SUCCESS;
1694
1695
1696	if(stCodeVersion.usaVector[0] == 0x0001){
1697	puc2BCodeBuffer = Cas2BNim03CodeBuffer;
1698	i2BCodeSize = iCas2BNim03CodeBufferSize;
1699	puc2BDataBuffer = Cas2BNim03DataBuffer;
1700	i2BDataSize = iCas2BNim03DataBufferSize;
1701	}
1702	else if(stCodeVersion.usaVector[0] == 0x0002){
1703	puc2BCodeBuffer = Cas2BDoubleDeckerCodeBuffer;
1704	i2BCodeSize = iCas2BDoubleDeckerCodeBufferSize;
1705	puc2BDataBuffer = Cas2BDoubleDeckerDataBuffer;
1706	i2BDataSize = iCas2BDoubleDeckerDataBufferSize;
1707	}
1708	else if(stCodeVersion.usaVector[0] == 0x0003){
1709	puc2BCodeBuffer = Cas2BXceiveCodeBuffer;
1710	i2BCodeSize = iCas2BXceiveCodeBufferSize;
1711	puc2BDataBuffer = Cas2BXceiveDataBuffer;
1712	i2BDataSize = iCas2BXceiveDataBufferSize;
1713	}
1714
1715	//Reset checksum
1716	if(CAS_2B_API_SUCCESS != ResetChecksum())
1717	return RESET_CHECKSUM_FUNCTION_FAILED;
1718
1719
1720	//Send code buffer
1721	if(IIC_COM_SUCCESS != OrenIicTransmit(CASCADE_WRITE_ADDRESS, puc2BCodeBuffer, i2BCodeSize)){
1722	DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR, LINE=%d\n", __LINE__);
1723	return CAS_2B_API_SEND_CODE_AND_DATA_FUNCTION_FAILED;
1724	}
1725
1726	//Send data buffer
1727	if(IIC_COM_SUCCESS != OrenIicTransmit(CASCADE_WRITE_ADDRESS, puc2BDataBuffer, i2BDataSize)){
1728	DHL_DbgPrintf(0,DHLDBG_EXT,"ERROR, LINE=%d\n", __LINE__);
1729	return CAS_2B_API_SEND_CODE_AND_DATA_FUNCTION_FAILED;
1730	}
1731
1732	iCheckSumStatus = GetChecksumFlag(&iError);
1733	if((IIC_COM_SUCCESS != iError) \|\|(iCheckSumStatus != CHECKSUM_STATUS_CORRECT))
1734	return CHECKSUM_IS_INCORRECT;
1735
1736
1737	return CAS_2B_API_SUCCESS;
1738	}
1739
1740	int __stdcall SendCas2BRunFlag()
1741	{
1742	if (IIC_COM_SUCCESS != SendRunFlag()) {
1743	return CAS_2B_SEND_RUN_FLAG_FUNCTION_FAILED;
1744	}
1745	else
1746	return CAS_2B_API_SUCCESS;
1747	}
1748
1749
1750	int __stdcall SetReceiveRegister(unsigned char usReceiveRegisterNumber,unsigned short usReceiveRegisterValue)
1751	{
1752	unsigned char ucaSend[3];
1753
1754
1755	if(usReceiveRegisterNumber > 7)
1756	return CAS_2B_ILLIGAL_RECEIVE_REGISTER_NUMBER;
1757
1758	//send the data to the appropriate receive index
1759	ucaSend[1] = (char)(usReceiveRegisterValue >> 8);
1760	ucaSend[2] = (char)(usReceiveRegisterValue);
1761
1762	if (IIC_COM_SUCCESS != SendToReceive(usReceiveRegisterNumber, ucaSend, 2) )
1763	return CAS_2B_SET_RECEIVE_REGISTER_FUNCTION_FAILED;
1764	else
1765	return CAS_2B_API_SUCCESS;
1766
1767	}
1768
1769	unsigned short __stdcall GetTransmitRegisterValue(unsigned char ucTransmitRegiterNumber,int * piError)
1770	{
1771	unsigned short usReceivedWord = 0;
1772	usReceivedWord = ReceiveTransmitRegisterValue( 0,piError);
1773	if(IIC_COM_SUCCESS != *piError){
1774	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
1775	return 0;
1776	}
1777
1778	return usReceivedWord;
1779	}
1780
1781	#if SUPPORT_TUNER_DTT7611 \|\| SUPPORT_TUNER_DTT7612
1782	unsigned int __stdcall PerformChannelScan(CAS_2B_CHANNEL_SCAN_PARAMETERS stChannelScanParameters, CAS_2B_CHANNEL_SCAN_RESULT pstaChannelScanResults,unsigned long pulaInputFrequenciesTable)
1783	{
1784
1785	TYPE_CHANNEL_SCAN_RECEIVER_MODE_PRIORITY iaReceiverModePriority[2];
1786	int iPriorityIndex;
1787	CAS_2B_CHANNEL_CHANGE_PARAMETERS stChannelChangeParameters;
1788	CAS_2B_TUNER_PARAMETERS stTunerParameters;
1789	REF_DIVIDER_RATIO iRefDividerRatio=REF_DIVIDER_RATIO_31_25;
1790	unsigned long ulTmpFrequency /* ,ulWait */;
1791	unsigned int uiTmpChannelNumber=0,uiChannelIndex=0;
1792	LOCK_TYPE iLockType;
1793
1794	/*
1795	int iaTunerCarrierOffset[] = {-12, -37, -62, -87, -112,
1796	-137, -162, -187, 187, 162,
1797	137, 112, 87, 62, -37,
1798	12};
1799	*/
1800	uiChannelIndex = 0;
1801	//first check that the parameters are valid
1802	if(NULL == pstaChannelScanResults)
1803	return FUNCTION_RECEIVED_NULL_PARAMETER;
1804
1805	if((stChannelScanParameters.iTunerType < TUNER_DTT7611) \|\| (stChannelScanParameters.iTunerType > TUNER_DTT7612))
1806	return CAS_2B_UNDEFINED_TUNER_TYPE;
1807
1808	if((stChannelScanParameters.iReceiverModeFirstPriority < CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_VSB) \|\| (stChannelScanParameters.iReceiverModeFirstPriority > CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_ITUB)){
1809	return ILLIGAL_FIRST_MODE_PRIORITY_MODE;
1810	}
1811	else{//the first priority is ok
1812	if((stChannelScanParameters.iReceiverModeSecondPriority < CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_NONE) \|\| (stChannelScanParameters.iReceiverModeSecondPriority > CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_ITUB)){
1813	return ILLIGAL_SECOND_MODE_PRIORITY_MODE;
1814	}
1815
1816	if(stChannelScanParameters.iReceiverModeSecondPriority == stChannelScanParameters.iReceiverModeFirstPriority)
1817	return TWO_PRIORITIES_HAVE_THE_SAME_RECEIVER_MODE;
1818
1819	}
1820
1821
1822
1823	if(SCAN_ACCORDING_TO_TABLE == stChannelScanParameters.iChannelScanFrequencyOption){
1824	switch(stChannelScanParameters.iChannelTableType){
1825	case NA_TERRESTRIAL:
1826	if(76 != stChannelScanParameters.usResultsBufferSize)
1827	return RESULT_BUFFER_SIZE_IS_NOT_BIG_ENOUGH;
1828	break;
1829	case NA_CATV:
1830	case IRC:
1831	case HRC:
1832	if(135 != stChannelScanParameters.usResultsBufferSize)
1833	return RESULT_BUFFER_SIZE_IS_NOT_BIG_ENOUGH;
1834	break;
1835	default:
1836	return UNDEFINED_CHANNEL_TABLE_TYPE;
1837
1838	}
1839
1840	if((stChannelScanParameters.iChannelTableType == NA_CATV) \|\| (stChannelScanParameters.iChannelTableType == IRC))
1841	uiTmpChannelNumber = 1;
1842	else// NA_TERRESTRIAL or HRC
1843	uiTmpChannelNumber = 2;
1844
1845	#if SUPPORT_TUNER_DTT7611
1846	if(stChannelScanParameters.iTunerType == TUNER_DTT7611)
1847	ulTmpFrequency = TunerDTT7611GetFrequency(uiTmpChannelNumber,stChannelScanParameters.iChannelTableType);
1848	#endif
1849
1850	#if SUPPORT_TUNER_DTT7612
1851	if(stChannelScanParameters.iTunerType == TUNER_DTT7612)
1852	ulTmpFrequency = TunerDTT7612GetFrequency(uiTmpChannelNumber,stChannelScanParameters.iChannelTableType);
1853	#endif
1854	}
1855	else if(SCAN_ACCORDING_TO_FREQUENCY == stChannelScanParameters.iChannelScanFrequencyOption){
1856	if(stChannelScanParameters.ulStartFrequency >= stChannelScanParameters.ulEndFrequency)
1857	return START_FREQUENCY_IS_BIGGER_THAN_END_FREQUENCY;
1858
1859	ulTmpFrequency = stChannelScanParameters.ulStartFrequency;
1860
1861	if(stChannelScanParameters.usResultsBufferSize < (unsigned int)((stChannelScanParameters.ulEndFrequency - stChannelScanParameters.ulStartFrequency)/stChannelScanParameters.ulStepSize))
1862	return RESULT_BUFFER_SIZE_IS_NOT_BIG_ENOUGH;
1863	}
1864	else if(SCAN_ACCORDING_TO_INPUT_TABLE == stChannelScanParameters.iChannelScanFrequencyOption){
1865
1866	ulTmpFrequency = stChannelScanParameters.ulStartFrequency;
1867
1868	if(stChannelScanParameters.usResultsBufferSize < stChannelScanParameters.usInputFrequencyTableSize)
1869	return RESULT_BUFFER_SIZE_IS_NOT_BIG_ENOUGH;
1870
1871	ulTmpFrequency = pulaInputFrequenciesTable[uiChannelIndex];
1872	}
1873
1874
1875	iaReceiverModePriority[0] = stChannelScanParameters.iReceiverModeFirstPriority;
1876	iaReceiverModePriority[1] = stChannelScanParameters.iReceiverModeSecondPriority;
1877
1878	iLockType = LOCK_TYPE_UNLOCKED;
1879
1880	while(1){
1881	pstaChannelScanResults[uiChannelIndex].ulFrequency = ulTmpFrequency;
1882	pstaChannelScanResults[uiChannelIndex].iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_UNLOCKED;
1883
1884	for(iPriorityIndex = 0 ; iPriorityIndex < 2; iPriorityIndex++){
1885	if(CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_NONE == iaReceiverModePriority[iPriorityIndex])
1886	break;
1887
1888
1889	stChannelChangeParameters.iCarrierAcquisition = stChannelScanParameters.iCarrierAcquisition;
1890	stChannelChangeParameters.iInverseSpectrum = INVERSE_SPECTRUM_OFF;
1891
1892	if(CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_VSB == iaReceiverModePriority[iPriorityIndex]){
1893	stChannelChangeParameters.iReceiverMode = CAS_2B_RECEIVER_MODE_VSB_8_TR;
1894	stTunerParameters.iAgcMode = TUNER_AGC_MODE_INTERNAL_DIGITAL;
1895	iRefDividerRatio = REF_DIVIDER_RATIO_62_5;
1896	if(stChannelScanParameters.bNtscCheck)
1897	stChannelChangeParameters.iNtscSignalDetection = NTSC_SIGNAL_DETECTION;
1898	else
1899	stChannelChangeParameters.iNtscSignalDetection = NORMAL_VSB;
1900	}
1901
1902	if(CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_ITUB == iaReceiverModePriority[iPriorityIndex]){
1903	stChannelChangeParameters.iReceiverMode = CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT;
1904	stTunerParameters.iAgcMode = TUNER_AGC_MODE_INTERNAL_DIGITAL;
1905	iRefDividerRatio = REF_DIVIDER_RATIO_62_5;
1906	if(stChannelScanParameters.bNtscCheck)
1907	stChannelChangeParameters.iNtscSignalDetection = NTSC_SIGNAL_DETECTION;
1908	else
1909	stChannelChangeParameters.iNtscSignalDetection = NORMAL_VSB;
1910	}
1911
1912	#if SUPPORT_TUNER_DTT7611
1913	//set the tuner frequency
1914	if(TUNER_DTT7611 == stChannelScanParameters.iTunerType){
1915	if(CAS_2B_API_SUCCESS != SetTunerDTT7611(TUNER_SET_CENTER_FREQUENCY_KHZ, &ulTmpFrequency,
1916	stChannelScanParameters.iChannelTableType,
1917	(TYPE_TUNERDTT7611_REF_DIVIDER_RATIO)iRefDividerRatio,
1918	TUNERDTT7611_AGC_96,
1919	stTunerParameters.iAgcMode,
1920	CHARGE_PUMP_60,
1921	TUNERDTT7611_AGC_TIME_CONSTANT_2_SEC))
1922	return SEND_TUNER_FREQUENCY_FAILED;
1923
1924	}
1925	#endif
1926	#if SUPPORT_TUNER_DTT7612
1927	if(TUNER_DTT7612 == stChannelScanParameters.iTunerType){
1928	if(CAS_2B_API_SUCCESS != SetTunerDTT7612(TUNER_SET_CENTER_FREQUENCY_KHZ, &ulTmpFrequency,
1929	stChannelScanParameters.iChannelTableType,
1930	(TYPE_TUNERDTT7612_REF_DIVIDER_RATIO)iRefDividerRatio,
1931	TUNERDTT7612_AGC_96,
1932	stTunerParameters.iAgcMode,
1933	CHARGE_PUMP_60,
1934	TUNERDTT7612_AGC_TIME_CONSTANT_2_SEC))
1935	return SEND_TUNER_FREQUENCY_FAILED;
1936	}
1937	#endif
1938
1939	if(TRUE == stChannelScanParameters.bPerformCascadeChannelChange){
1940	//wait the tuner delay
1941	OS_Delay(stChannelScanParameters.ulDelay/11000);
1942
1943	//send the cascade channel change only if it is needed
1944	if(CAS_2B_API_SUCCESS != Cas2BChannelChange(stChannelChangeParameters)){
1945	break;
1946	}
1947	}
1948
1949	OS_Delay(stChannelScanParameters.ulDelay/11000);
1950
1951	//check the chip is locked. if the chip is locked
1952	//dont try all the ulNumberOfTries
1953	iLockType = CheckIfLocked(stChannelScanParameters.ulNumberOfTries,stChannelScanParameters.bNtscCheck,10);
1954	if(LOCK_TYPE_UNLOCKED != iLockType){
1955	OS_Delay(stChannelScanParameters.ulDelay/11000);
1956
1957	GetChipData(iaReceiverModePriority[iPriorityIndex],iLockType,&pstaChannelScanResults[uiChannelIndex]);
1958	break;//from iPriorityIndex
1959	}
1960	else{//not locked
1961	continue;
1962	}
1963
1964	}//for(iPriorityIndex
1965
1966
1967	uiChannelIndex++;
1968	if(SCAN_ACCORDING_TO_TABLE == stChannelScanParameters.iChannelScanFrequencyOption){
1969	uiTmpChannelNumber++;
1970
1971	if((NA_TERRESTRIAL == stChannelScanParameters.iChannelTableType)&&(uiChannelIndex > 75))
1972	return CAS_2B_API_SUCCESS;
1973	else if(uiChannelIndex > 134)
1974	return CAS_2B_API_SUCCESS;
1975
1976	#if SUPPORT_TUNER_DTT7611
1977	if(stChannelScanParameters.iTunerType == TUNER_DTT7611)
1978	ulTmpFrequency = TunerDTT7611GetFrequency(uiTmpChannelNumber,stChannelScanParameters.iChannelTableType);
1979	#endif
1980
1981	#if SUPPORT_TUNER_DTT7612
1982	if(stChannelScanParameters.iTunerType == TUNER_DTT7612)
1983	ulTmpFrequency = TunerDTT7612GetFrequency(uiTmpChannelNumber,stChannelScanParameters.iChannelTableType);
1984	#endif
1985	}
1986	else if(SCAN_ACCORDING_TO_FREQUENCY == stChannelScanParameters.iChannelScanFrequencyOption){
1987	ulTmpFrequency+= stChannelScanParameters.ulStepSize;
1988	if(ulTmpFrequency > stChannelScanParameters.ulEndFrequency)
1989	return CAS_2B_API_SUCCESS;
1990	}
1991	else if(SCAN_ACCORDING_TO_INPUT_TABLE == stChannelScanParameters.iChannelScanFrequencyOption){
1992	if(uiChannelIndex == stChannelScanParameters.usInputFrequencyTableSize)
1993	return CAS_2B_API_SUCCESS;
1994
1995	ulTmpFrequency = pulaInputFrequenciesTable[uiChannelIndex];
1996
1997	}
1998
1999
2000	}//while(1)
2001
2002	// return CAS_2B_API_SUCCESS;
2003	}
2004	#endif /* SUPPORT_TUNER_DTT7611 \|\| SUPPORT_TUNER_DTT7612 */
2005
2006	unsigned char GetSignalQuality(CAS_2B_TYPE_RECEIVER_MODE iReceiverMode,int * piError)
2007	{
2008	unsigned char ucSnrMin,ucSnrMax,ucSnrValue,ucSignalQuality,ucSNRSignalQuality;
2009	unsigned char ucSERSignalQuality,uc1SecSERValue, uc10SecSERValue;
2010
2011	LOCK_STATUS iLockStatus;
2012
2013	//
2014	// Auto DetectÀÌ¸é, Receiver Mode¸¦ Á÷Á¢ ¾òÀ½.
2015	//
2016	if ( iReceiverMode==CAS_2B_RECEIVER_MODE_ITUB_AUTO_DETECT ) {
2017	iReceiverMode=GetReceiveMode(piError);
2018	if(IIC_COM_SUCCESS != *piError){
2019	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2020	return 0;
2021	}
2022	}
2023
2024	if((iReceiverMode != CAS_2B_RECEIVER_MODE_VSB_8_TR)&& (iReceiverMode != CAS_2B_RECEIVER_MODE_ITUB_64) && (iReceiverMode != CAS_2B_RECEIVER_MODE_ITUB_256)){
2025	*piError = UNDEFINED_RECEIVER_MODE;
2026	return 0;
2027	}
2028
2029	if(NULL == piError){
2030	*piError = FUNCTION_RECEIVED_NULL_PARAMETER;
2031	return 0;
2032	}
2033
2034	ucSnrValue = (unsigned char)GetSnrAfterEqualization(iReceiverMode,piError);
2035	if(CAS_2B_API_SUCCESS != *piError)
2036	return 0;
2037
2038
2039	uc1SecSERValue = Get1SecSer(piError);
2040	if(CAS_2B_API_SUCCESS != *piError)
2041	return 0;
2042
2043	uc10SecSERValue = Get10SecSer(piError);
2044	if(CAS_2B_API_SUCCESS != *piError)
2045	return 0;
2046
2047	iLockStatus = IsLocked(piError);
2048	if(CAS_2B_API_SUCCESS != *piError)
2049	return 0;
2050
2051	ucSignalQuality = 0;
2052	switch(iReceiverMode) {
2053	case CAS_2B_RECEIVER_MODE_ITUB_64:
2054	ucSnrMin = 20;
2055	ucSnrMax = 30;
2056	break;
2057	case CAS_2B_RECEIVER_MODE_ITUB_256:
2058	ucSnrMin = 25;
2059	ucSnrMax = 35;
2060	break;
2061	case CAS_2B_RECEIVER_MODE_VSB_8_TR:
2062	ucSnrMin = 10;
2063	ucSnrMax = 30;
2064	break;
2065	default:
2066	// like VSB
2067	ucSnrMin = 0;
2068	ucSnrMax = 30;
2069	}
2070
2071
2072
2073	//signal quality
2074	if(UNLOCKED == iLockStatus){
2075	ucSignalQuality = 0;
2076	}
2077	else{
2078	//Calculate Signal quality based on SNR
2079	ucSNRSignalQuality = ((ucSnrValue - ucSnrMin)*100)/(ucSnrMax-ucSnrMin);
2080
2081	ucSERSignalQuality = 100 - ((100*uc1SecSERValue)/50);
2082
2083	if(ucSNRSignalQuality < ucSERSignalQuality)
2084	ucSignalQuality = ucSNRSignalQuality;
2085	else
2086	ucSignalQuality = ucSERSignalQuality;
2087
2088	}
2089
2090	if(ucSignalQuality > 100)
2091	ucSignalQuality = 100;
2092
2093	return ucSignalQuality;
2094	}
2095
2096	#if 0 /* 9/27/05 - GetSignalStrength() now returns more accurate Signal strength */
2097	unsigned long GetSignalStrength(int * piError, TYPE_AGC_AMPLIFIER iAGCAmplifierType)
2098	{
2099	NUMERATOR_DENOMINATOR stAGCSensor,stIFAGCCommand;
2100	unsigned long ulSignalStrength;
2101	int iReceivedWord, iEqualizerMode;
2102
2103	if(NULL == piError){
2104	*piError = FUNCTION_RECEIVED_NULL_PARAMETER;
2105	return 0;
2106	}
2107
2108	stIFAGCCommand = GetAgcIfCommand(piError);
2109	if(CAS_2B_API_SUCCESS != *piError)
2110	return 0;
2111
2112	stAGCSensor = GetAGCSensor(piError);
2113	if(CAS_2B_API_SUCCESS != *piError)
2114	return 0;
2115
2116
2117	if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_UPC3217){
2118	if(stIFAGCCommand.Numerator.lNumerator >= 20613 /AGC IF command value >= 0.62/){
2119	ulSignalStrength = (unsigned long)(388 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 176;
2120	}
2121	if(stIFAGCCommand.Numerator.lNumerator < 20613 && stIFAGCCommand.Numerator.lNumerator >= 13434/if(dIfAGCCommandVal < 0.62 && dIfAGCCommandVal >= 0.41)/){
2122	ulSignalStrength = (unsigned long)(225 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 71;
2123	}
2124	if(stIFAGCCommand.Numerator.lNumerator < 13434/if(dIfAGCCommandVal < 0.41)/){
2125	ulSignalStrength = (unsigned long)(((stAGCSensor.Numerator.lNumerator - 3277) /4915)*20) ;
2126	}
2127	}
2128
2129	if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_UPC3219){
2130	if(stIFAGCCommand.Numerator.lNumerator >= 13107 /AGC IF command value >= 0.4/){
2131	ulSignalStrength = (unsigned long)(268 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 43;
2132	}
2133	if(stIFAGCCommand.Numerator.lNumerator < 13107 && stIFAGCCommand.Numerator.lNumerator >= 4915/if(dIfAGCCommandVal < 0.4 && dIfAGCCommandVal >= 0.15)/){
2134	ulSignalStrength = (unsigned long)(180 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 7;
2135	}
2136	if(stIFAGCCommand.Numerator.lNumerator < 4915/if(dIfAGCCommandVal < 0.15)/){
2137	ulSignalStrength = (unsigned long)(((stAGCSensor.Numerator.lNumerator - 3277) /4915)*20);//
2138	}
2139	}
2140
2141	if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_UPC3221){
2142	if(stIFAGCCommand.Numerator.lNumerator >= 6553 /AGC IF command value >= 0.2/){
2143	ulSignalStrength = (unsigned long)(175 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 12;
2144	}
2145	if(stIFAGCCommand.Numerator.lNumerator < 4915/if(dIfAGCCommandVal < 0.2)/){
2146	ulSignalStrength = (unsigned long)(((stAGCSensor.Numerator.lNumerator - 3277) /4915)*20);//
2147	}
2148	}
2149
2150	if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_L06){
2151	//receive Tx 10
2152	iReceivedWord = ReceiveTransmitRegisterValue(10,piError);
2153	iEqualizerMode = (iReceivedWord & 0x0030) >> 4;
2154	if(iEqualizerMode == 0){
2155	if(stIFAGCCommand.Numerator.lNumerator >= 20970 /AGC IF command value >= 0.64/){
2156	ulSignalStrength = (unsigned long)(181 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 36;
2157	}
2158	if(stIFAGCCommand.Numerator.lNumerator < 20970 && stIFAGCCommand.Numerator.lNumerator >= 18350/if(dIfAGCCommandVal < 0.64 && dIfAGCCommandVal >= 0.56)/){
2159	ulSignalStrength = (unsigned long)(166 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 26;
2160	}
2161	if(stIFAGCCommand.Numerator.lNumerator < 18350 && stIFAGCCommand.Numerator.lNumerator >= 17366/if(dIfAGCCommandVal < 0.56 && dIfAGCCommandVal >= 0.53)/){
2162	ulSignalStrength = (unsigned long)(333 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 121;
2163	}
2164	if(stIFAGCCommand.Numerator.lNumerator < 17366 && stIFAGCCommand.Numerator.lNumerator >= 15072/if(dIfAGCCommandVal < 0.53 && dIfAGCCommandVal >= 0.46)/){
2165	ulSignalStrength = (unsigned long)(214 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 58;
2166	}
2167	if(stIFAGCCommand.Numerator.lNumerator < 15072 && stIFAGCCommand.Numerator.lNumerator >= 10813/if(dIfAGCCommandVal < 0.46 && dIfAGCCommandVal >= 0.33)/){
2168	ulSignalStrength = (unsigned long)(115 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 13;
2169	}
2170	if(stIFAGCCommand.Numerator.lNumerator < 10813 && stIFAGCCommand.Numerator.lNumerator >= 7208/if(dIfAGCCommandVal < 0.33 && dIfAGCCommandVal >= 0.22)/){
2171	ulSignalStrength = (unsigned long)(115 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 13;
2172	}
2173	if(stIFAGCCommand.Numerator.lNumerator < 7208/if(dIfAGCCommandVal < 0.22)/){
2174	if(stAGCSensor.Numerator.lNumerator < 2950)/if(dAGCSensor < 0.09)/
2175	ulSignalStrength = 0;
2176	else
2177	ulSignalStrength = (unsigned long)(181 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 16;
2178	}
2179
2180	}
2181
2182	else{
2183
2184	if(stIFAGCCommand.Numerator.lNumerator >= 20315 /AGC IF command value >= 0.62/){
2185	ulSignalStrength = (unsigned long)(200 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 44;
2186	}
2187	if(stIFAGCCommand.Numerator.lNumerator < 20315 && stIFAGCCommand.Numerator.lNumerator >= 17038/if(dIfAGCCommandVal < 0.62 && dIfAGCCommandVal >= 0.52)/){
2188	ulSignalStrength = (unsigned long)(166 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 23;
2189	}
2190	if(stIFAGCCommand.Numerator.lNumerator < 17038 && stIFAGCCommand.Numerator.lNumerator >= 13106/if(dIfAGCCommandVal < 0.52 && dIfAGCCommandVal >= 0.4)/){
2191	ulSignalStrength = (unsigned long)(115 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 5;
2192	}
2193	if(stIFAGCCommand.Numerator.lNumerator < 13106 && stIFAGCCommand.Numerator.lNumerator >= 8191/if(dIfAGCCommandVal < 0.4 && dIfAGCCommandVal >= 0.25)/){
2194	ulSignalStrength = (unsigned long)(200 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 30;
2195	}
2196	if(stIFAGCCommand.Numerator.lNumerator < 8191/if(dIfAGCCommandVal < 0.25)/){
2197	if(stAGCSensor.Numerator.lNumerator < 2950)/if(dAGCSensor < 0.09)/
2198	ulSignalStrength = 0;
2199	else
2200	ulSignalStrength = (unsigned long)(133 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 12;
2201	}
2202	}
2203	}
2204
2205
2206
2207	if(ulSignalStrength > 100)
2208	ulSignalStrength = 100;
2209	return ulSignalStrength;
2210
2211	}
2212	#else
2213	unsigned long GetSignalStrength(int * piError, TYPE_AGC_AMPLIFIER iAGCAmplifierType)
2214	{
2215	NUMERATOR_DENOMINATOR stAGCSensor,stIFAGCCommand;
2216	unsigned long ulSignalStrength = 0;
2217	int iReceivedWord, iEqualizerMode;
2218
2219	if(NULL == piError){
2220	*piError = FUNCTION_RECEIVED_NULL_PARAMETER;
2221	return 0;
2222	}
2223
2224
2225	//receive Tx 10
2226	iReceivedWord = ReceiveTransmitRegisterValue(10,piError);
2227	if(CAS_2B_API_SUCCESS != *piError)
2228	return 0;
2229	//Get the equalizer mode
2230	iEqualizerMode = (iReceivedWord & 0x0030) >> 4;
2231	DHL_DbgPrintf(gdhlExtDbgLvl,DHLDBG_EXT,"iEqualizerMode = %x\n", (int)iEqualizerMode);
2232
2233	stIFAGCCommand = GetAgcIfCommand(piError);
2234	if(CAS_2B_API_SUCCESS != *piError)
2235	return 0;
2236
2237	stAGCSensor = GetAGCSensor(piError);
2238	if(CAS_2B_API_SUCCESS != *piError)
2239	return 0;
2240
2241	if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_UPC3217){
2242	if(iEqualizerMode == 0){
2243	if(stIFAGCCommand.Numerator.lNumerator >= 20609 /AGC IF command value >= 0.69/){
2244	ulSignalStrength = (unsigned long)(500 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 265;
2245	}
2246	if(stIFAGCCommand.Numerator.lNumerator < 20609 && stIFAGCCommand.Numerator.lNumerator >= 21298/if(dIfAGCCommandVal < 0.69 && dIfAGCCommandVal >= 0.65)/){
2247	ulSignalStrength = (unsigned long)(375 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 179;
2248	}
2249	if(stIFAGCCommand.Numerator.lNumerator < 21298 && stIFAGCCommand.Numerator.lNumerator >= 19987/if(dIfAGCCommandVal < 0.65 && dIfAGCCommandVal >= 0.61)/){
2250	ulSignalStrength = (unsigned long)(500 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 260;
2251	}
2252	if(stIFAGCCommand.Numerator.lNumerator < 19987 && stIFAGCCommand.Numerator.lNumerator >= 17694/if(dIfAGCCommandVal < 0.61 && dIfAGCCommandVal >= 0.54)/){
2253	ulSignalStrength = (unsigned long)(285 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 129;
2254	}
2255	if(stIFAGCCommand.Numerator.lNumerator < 17694 && stIFAGCCommand.Numerator.lNumerator >= 11796/if(dIfAGCCommandVal < 0.54 && dIfAGCCommandVal >= 0.36)/){
2256	ulSignalStrength = (unsigned long)(28 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 10;
2257	}
2258	if(stIFAGCCommand.Numerator.lNumerator < 11796/if(dIfAGCCommandVal < 0.36)/){
2259	if(stAGCSensor.Numerator.lNumerator < 2950)/if(dAGCSensor < 0.09)/
2260	ulSignalStrength = 0;
2261	else
2262	ulSignalStrength = (unsigned long)(200 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 18;
2263	}
2264	}
2265	else{
2266	if(stIFAGCCommand.Numerator.lNumerator >= 22281 /AGC IF command value >= 0.68/){
2267	ulSignalStrength = (unsigned long)(500 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 260;
2268	}
2269	if(stIFAGCCommand.Numerator.lNumerator < 22281 && stIFAGCCommand.Numerator.lNumerator >= 20970/if(dIfAGCCommandVal < 0.68 && dIfAGCCommandVal >= 0.64)/){
2270	ulSignalStrength = (unsigned long)(375 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 175;
2271	}
2272	if(stIFAGCCommand.Numerator.lNumerator < 20970 && stIFAGCCommand.Numerator.lNumerator >= 19660/if(dIfAGCCommandVal < 0.64 && dIfAGCCommandVal >= 0.6)/){
2273	ulSignalStrength = (unsigned long)(500 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 255;
2274	}
2275	if(stIFAGCCommand.Numerator.lNumerator < 19660 && stIFAGCCommand.Numerator.lNumerator >= 17366/if(dIfAGCCommandVal < 0.6 && dIfAGCCommandVal >= 0.53)/){
2276	ulSignalStrength = (unsigned long)(285 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 126;
2277	}
2278	if(stIFAGCCommand.Numerator.lNumerator < 17366 && stIFAGCCommand.Numerator.lNumerator >= 13106/if(dIfAGCCommandVal < 0.53 && dIfAGCCommandVal >= 0.4)/){
2279	ulSignalStrength = (unsigned long)(38 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 5;
2280	}
2281	if(stIFAGCCommand.Numerator.lNumerator < 13106/if(dIfAGCCommandVal < 0.4)/){
2282	if(stAGCSensor.Numerator.lNumerator < 2950)/if(dAGCSensor < 0.09)/
2283	ulSignalStrength = 0;
2284	else
2285	ulSignalStrength = (unsigned long)(133 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 13;
2286	}
2287	}
2288	}
2289
2290	if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_UPC3219){
2291	if(iEqualizerMode == 0){
2292	if(stIFAGCCommand.Numerator.lNumerator >= 15400 /AGC IF command value >= 0.47/){
2293	ulSignalStrength = (unsigned long)(222 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 22;
2294	}
2295	if(stIFAGCCommand.Numerator.lNumerator < 15400 && stIFAGCCommand.Numerator.lNumerator >= 13434/if(dIfAGCCommandVal < 0.47 && dIfAGCCommandVal >= 0.41)/){
2296	ulSignalStrength = (unsigned long)(250 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 37;
2297	}
2298	if(stIFAGCCommand.Numerator.lNumerator < 13434 && stIFAGCCommand.Numerator.lNumerator >= 10813/if(dIfAGCCommandVal < 0.31 && dIfAGCCommandVal >= 0.33)/){
2299	ulSignalStrength = (unsigned long)(250 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 37;
2300	}
2301	if(stIFAGCCommand.Numerator.lNumerator < 10813 && stIFAGCCommand.Numerator.lNumerator >= 6225/if(dIfAGCCommandVal < 0.33 && dIfAGCCommandVal >= 0.19)/){
2302	ulSignalStrength = (unsigned long)(142 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 2;
2303	}
2304	if(stIFAGCCommand.Numerator.lNumerator < 6225 && stIFAGCCommand.Numerator.lNumerator >= 3932/if(dIfAGCCommandVal < 0.19 && dIfAGCCommandVal >= 0.12)/){
2305	ulSignalStrength = (unsigned long)(71 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 12;
2306	}
2307	if(stIFAGCCommand.Numerator.lNumerator < 3932/if(dIfAGCCommandVal < 0.12)/){
2308	if(stAGCSensor.Numerator.lNumerator < 2950)/if(dAGCSensor < 0.09)/
2309	ulSignalStrength = 0;
2310	else
2311	ulSignalStrength = (unsigned long)(200 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 18;
2312	}
2313	}
2314	else{
2315	if(stIFAGCCommand.Numerator.lNumerator >= 15072 /AGC IF command value >= 0.46/){
2316	ulSignalStrength = (unsigned long)(222 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 22;
2317	}
2318	if(stIFAGCCommand.Numerator.lNumerator < 15072 && stIFAGCCommand.Numerator.lNumerator >= 12779/if(dIfAGCCommandVal < 0.46 && dIfAGCCommandVal >= 0.39)/){
2319	ulSignalStrength = (unsigned long)(214 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 18;
2320	}
2321	if(stIFAGCCommand.Numerator.lNumerator < 12779 && stIFAGCCommand.Numerator.lNumerator >= 9830/if(dIfAGCCommandVal < 0.39 && dIfAGCCommandVal >= 0.3)/){
2322	ulSignalStrength = (unsigned long)(222 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 21;
2323	}
2324	if(stIFAGCCommand.Numerator.lNumerator < 9830 && stIFAGCCommand.Numerator.lNumerator >= 4915/if(dIfAGCCommandVal < 0.3 && dIfAGCCommandVal >= 0.15)/){
2325	ulSignalStrength = (unsigned long)(133 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 5;
2326	}
2327	if(stIFAGCCommand.Numerator.lNumerator < 4915 && stIFAGCCommand.Numerator.lNumerator >= 2293/if(dIfAGCCommandVal < 0.15 && dIfAGCCommandVal >= 0.07)/){
2328	ulSignalStrength = (unsigned long)(62 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 16;
2329	}
2330	if(stIFAGCCommand.Numerator.lNumerator < 2293/if(dIfAGCCommandVal < 0.07)/){
2331	if(stAGCSensor.Numerator.lNumerator < 2950)/if(dAGCSensor < 0.09)/
2332	ulSignalStrength = 0;
2333	else
2334	ulSignalStrength = (unsigned long)(133 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 13;
2335	}
2336	}
2337	}
2338
2339	if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_UPC3221){
2340	if(iEqualizerMode == 0){
2341	if(stIFAGCCommand.Numerator.lNumerator >= 17694 /AGC IF command value >= 0.54/){
2342	ulSignalStrength = (unsigned long)(142 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 7;
2343	}
2344	if(stIFAGCCommand.Numerator.lNumerator < 17694 && stIFAGCCommand.Numerator.lNumerator >= 15072/if(dIfAGCCommandVal < 0.54 && dIfAGCCommandVal >= 0.46)/){
2345	ulSignalStrength = (unsigned long)(187 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 21;
2346	}
2347	if(stIFAGCCommand.Numerator.lNumerator < 15072 && stIFAGCCommand.Numerator.lNumerator >= 12780/if(dIfAGCCommandVal < 0.46 && dIfAGCCommandVal >= 0.39)/){
2348	ulSignalStrength = (unsigned long)(285 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 66;
2349	}
2350	if(stIFAGCCommand.Numerator.lNumerator < 9502 && stIFAGCCommand.Numerator.lNumerator >= 3276/if(dIfAGCCommandVal < 0.39 && dIfAGCCommandVal >= 0.29)/){
2351	ulSignalStrength = (unsigned long)(200 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 33;
2352	}
2353	if(stIFAGCCommand.Numerator.lNumerator < 9502 && stIFAGCCommand.Numerator.lNumerator >= 3276/if(dIfAGCCommandVal < 0.29 && dIfAGCCommandVal >= 0.1)/){
2354	ulSignalStrength = (unsigned long)(26 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 17;
2355	}
2356	if(stIFAGCCommand.Numerator.lNumerator < 3276/if(dIfAGCCommandVal < 0.1)/){
2357	if(stAGCSensor.Numerator.lNumerator < 2950)/if(dAGCSensor < 0.09)/
2358	ulSignalStrength = 0;
2359	else
2360	ulSignalStrength = (unsigned long)(200 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 18;
2361	}
2362	}
2363	else{
2364	if(stIFAGCCommand.Numerator.lNumerator >= 16711 /AGC IF command value >= 0.51/){
2365	ulSignalStrength = (unsigned long)(143 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 7;
2366	}
2367	if(stIFAGCCommand.Numerator.lNumerator < 16711 && stIFAGCCommand.Numerator.lNumerator >= 14417/if(dIfAGCCommandVal < 0.51 && dIfAGCCommandVal >= 0.44)/){
2368	ulSignalStrength = (unsigned long)(214 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 29;
2369	}
2370	if(stIFAGCCommand.Numerator.lNumerator < 14417 && stIFAGCCommand.Numerator.lNumerator >= 12451/if(dIfAGCCommandVal < 0.44 && dIfAGCCommandVal >= 0.38)/){
2371	ulSignalStrength = (unsigned long)(333 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 81;
2372	}
2373	if(stIFAGCCommand.Numerator.lNumerator < 12451 && stIFAGCCommand.Numerator.lNumerator >= 8519/if(dIfAGCCommandVal < 0.38 && dIfAGCCommandVal >= 0.26)/){
2374	ulSignalStrength = (unsigned long)(166 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 18;
2375	}
2376	if(stIFAGCCommand.Numerator.lNumerator < 8519 && stIFAGCCommand.Numerator.lNumerator >= 4915/if(dIfAGCCommandVal < 0.26 && dIfAGCCommandVal >= 0.15)/){
2377	ulSignalStrength = (unsigned long)(50 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator + 13;
2378	}
2379	if(stIFAGCCommand.Numerator.lNumerator < 4915/if(dIfAGCCommandVal < 0.15)/){
2380	if(stAGCSensor.Numerator.lNumerator < 2950)/if(dAGCSensor < 0.09)/
2381	ulSignalStrength = 0;
2382	else
2383	ulSignalStrength = (unsigned long)(133 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 13;
2384	}
2385	}
2386	}
2387
2388	if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_L06){
2389	if(iEqualizerMode == 0){
2390	if(stIFAGCCommand.Numerator.lNumerator >= 20970 /AGC IF command value >= 0.64/){
2391	ulSignalStrength = (unsigned long)(181 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 36;
2392	}
2393	if(stIFAGCCommand.Numerator.lNumerator < 20970 && stIFAGCCommand.Numerator.lNumerator >= 18350/if(dIfAGCCommandVal < 0.64 && dIfAGCCommandVal >= 0.56)/){
2394	ulSignalStrength = (unsigned long)(166 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 26;
2395	}
2396	if(stIFAGCCommand.Numerator.lNumerator < 18350 && stIFAGCCommand.Numerator.lNumerator >= 17366/if(dIfAGCCommandVal < 0.56 && dIfAGCCommandVal >= 0.53)/){
2397	ulSignalStrength = (unsigned long)(333 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 121;
2398	}
2399	if(stIFAGCCommand.Numerator.lNumerator < 17366 && stIFAGCCommand.Numerator.lNumerator >= 15072/if(dIfAGCCommandVal < 0.53 && dIfAGCCommandVal >= 0.46)/){
2400	ulSignalStrength = (unsigned long)(214 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 58;
2401	}
2402	if(stIFAGCCommand.Numerator.lNumerator < 15072 && stIFAGCCommand.Numerator.lNumerator >= 10813/if(dIfAGCCommandVal < 0.46 && dIfAGCCommandVal >= 0.33)/){
2403	ulSignalStrength = (unsigned long)(115 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 13;
2404	}
2405	if(stIFAGCCommand.Numerator.lNumerator < 10813 && stIFAGCCommand.Numerator.lNumerator >= 7208/if(dIfAGCCommandVal < 0.33 && dIfAGCCommandVal >= 0.22)/){
2406	ulSignalStrength = (unsigned long)(115 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 13;
2407	}
2408	if(stIFAGCCommand.Numerator.lNumerator < 7208/if(dIfAGCCommandVal < 0.22)/){
2409	if(stAGCSensor.Numerator.lNumerator < 2950)/if(dAGCSensor < 0.09)/
2410	ulSignalStrength = 0;
2411	else
2412	ulSignalStrength = (unsigned long)(181 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 16;
2413	}
2414
2415	}
2416
2417	else{
2418
2419	if(stIFAGCCommand.Numerator.lNumerator >= 20315 /AGC IF command value >= 0.62/){
2420	ulSignalStrength = (unsigned long)(200 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 44;
2421	}
2422	if(stIFAGCCommand.Numerator.lNumerator < 20315 && stIFAGCCommand.Numerator.lNumerator >= 17038/if(dIfAGCCommandVal < 0.62 && dIfAGCCommandVal >= 0.52)/){
2423	ulSignalStrength = (unsigned long)(166 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 23;
2424	}
2425	if(stIFAGCCommand.Numerator.lNumerator < 17038 && stIFAGCCommand.Numerator.lNumerator >= 13106/if(dIfAGCCommandVal < 0.52 && dIfAGCCommandVal >= 0.4)/){
2426	ulSignalStrength = (unsigned long)(115 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 5;
2427	}
2428	if(stIFAGCCommand.Numerator.lNumerator < 13106 && stIFAGCCommand.Numerator.lNumerator >= 8191/if(dIfAGCCommandVal < 0.4 && dIfAGCCommandVal >= 0.25)/){
2429	ulSignalStrength = (unsigned long)(200 * stIFAGCCommand.Numerator.lNumerator) / stIFAGCCommand.Denominator.lDenominator - 30;
2430	}
2431	if(stIFAGCCommand.Numerator.lNumerator < 8191/if(dIfAGCCommandVal < 0.25)/){
2432	if(stAGCSensor.Numerator.lNumerator < 2950)/if(dAGCSensor < 0.09)/
2433	ulSignalStrength = 0;
2434	else
2435	ulSignalStrength = (unsigned long)(133 * stAGCSensor.Numerator.lNumerator) / stAGCSensor.Denominator.lDenominator - 12;
2436	}
2437	}
2438	}
2439
2440	if(iAGCAmplifierType == TYPE_AGC_AMPLIFIER_DDM40){
2441	ulSignalStrength = (stIFAGCCommand.Numerator.lNumerator * 150) / stAGCSensor.Denominator.lDenominator;
2442	}
2443
2444	if(ulSignalStrength > 100)
2445	ulSignalStrength = 100;
2446	return ulSignalStrength;
2447
2448	}
2449
2450	#endif
2451
2452
2453	unsigned int __stdcall Cas2BOOBChannelChange(CAS_2B_OOB_CHANNEL_CHANGE_PARAMETERS stOOBChannelChangeParameters)
2454	{
2455	unsigned short usReceive6 = 0;
2456	unsigned char cSend[3];
2457	int iRes;
2458	if(stOOBChannelChangeParameters.ulSetValue > 130000 \|\| stOOBChannelChangeParameters.ulSetValue < 70000){
2459	return OOB_FREQ_OUT_OF_RANGE;
2460	}
2461
2462	usReceive6 \|= 0x8000;//FDC CC flag
2463	usReceive6 \|= ((stOOBChannelChangeParameters.bIsPowerDown ? 0:1) << 12);
2464	usReceive6 \|= (stOOBChannelChangeParameters.iFDCMode << 13);
2465	iRes = ((stOOBChannelChangeParameters.ulSetValue + 44000)*1024/25000 - 4096);
2466	if(iRes > 4095){
2467	return OOB_FREQ_OUT_OF_RANGE;
2468	}
2469
2470	usReceive6 \|= iRes;
2471
2472
2473	cSend[1] = (char)(usReceive6 >> 8);
2474	cSend[2] = (char)(usReceive6);
2475
2476	if (IIC_COM_SUCCESS != SendToReceive(6, cSend, 2)){
2477	return CAS_2B_SET_RECEIVE_REGISTER_FUNCTION_FAILED;
2478	}
2479
2480	return CAS_2B_API_SUCCESS;
2481	}
2482
2483
2484	LOCK_STATUS __stdcall IsOOBLocked(int * piError)
2485	{
2486	unsigned short usReceivedWord = 0;
2487	usReceivedWord = ReceiveTransmitRegisterValue(18,piError);
2488	if(IIC_COM_SUCCESS != *piError){
2489	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2490	return UNDEFINED_LOCK_STATUS;
2491	}
2492
2493	*piError = (int) CAS_2B_API_SUCCESS;
2494	//now musk bit 2 to get the lock status
2495	if((0x04 & usReceivedWord))
2496	return LOCKED;
2497	else
2498	return UNLOCKED;
2499
2500	}
2501
2502
2503	NUMERATOR_DENOMINATOR __stdcall GetOOBAgcIfCommand(int * piError)
2504	{
2505	unsigned short usReceivedWord = 0;
2506	NUMERATOR_DENOMINATOR stResult;
2507
2508	stResult.Numerator.lNumerator = 0;
2509	stResult.Denominator.lDenominator = 256;
2510
2511	//receive the AGC IF Command value from transmit register 21
2512	usReceivedWord = ReceiveTransmitRegisterValue(21,piError);
2513	usReceivedWord >>=8;
2514	if(IIC_COM_SUCCESS != *piError){
2515	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2516	return stResult;
2517	}
2518	stResult.Numerator.lNumerator = usReceivedWord ;
2519	return stResult;
2520
2521	}
2522
2523
2524	long __stdcall GetOOBCarrierOffset(TYPE_FDC_MODE iFDCMode, int * piError)
2525	{
2526	unsigned short usReceivedWord = 0;
2527	long lTmp;
2528	short sReceivedData;
2529
2530	//read the transmit 20 register value
2531	usReceivedWord = ReceiveTransmitRegisterValue(20,piError);
2532	if(IIC_COM_SUCCESS != *piError){
2533	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2534	return 0;
2535	}
2536
2537	if(usReceivedWord > 0x7fff)
2538	sReceivedData = usReceivedWord - 0x10000;
2539	else
2540	sReceivedData = usReceivedWord;
2541
2542	lTmp = sReceivedData * OOB_25_CARRIER_OFFSET_MULTIPLIER + (sReceivedData*OOB_25_CARRIER_OFFSET_FLOATING_POINT_MULTIPLIER)/OOB_25_CARRIER_FLOATING_POINT_DIVIDER ;
2543
2544	//now round the number to Khz
2545	if(lTmp > 0)
2546	lTmp = ((lTmp + 555)*1000)/1000;
2547	else
2548	lTmp = ((lTmp - 555)*1000)/1000;
2549
2550
2551	return (lTmp/1000);
2552	}
2553
2554
2555
2556	unsigned short __stdcall GetOOBSnr(int * piError)
2557	{
2558	unsigned short usReceivedWord = 0;
2559	int iLogResult,iSNRResult;
2560
2561	//get the snr value
2562	usReceivedWord = ReceiveTransmitRegisterValue(18,piError);
2563	//bits 6-15
2564	usReceivedWord = ((usReceivedWord & 0xffc0) >> 6);
2565	if(IIC_COM_SUCCESS != *piError){
2566	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2567	return 0;
2568	}
2569
2570	//mask the received data 15 lsb bits
2571	if(0 == usReceivedWord){
2572	*piError = (int) RECEIVED_ZERO_SNR_VALUE_FROM_THE_CASCADE;
2573	return 0;
2574	}
2575
2576
2577	iLogResult = CalcLog(usReceivedWord);
2578	iSNRResult = OOB_ADD_TO_LOG - iLogResult;
2579
2580	return iSNRResult;
2581	}
2582
2583
2584
2585	TYPE_AUDIO_CHANNEL_STATE __stdcall GetAudioChannelState(TYPE_AUDIO_CHANNEL iAudioChannel,int * piError)
2586	{
2587	unsigned short usReceivedWord;
2588	usReceivedWord = ReceiveTransmitRegisterValue(0,piError);
2589	if(IIC_COM_SUCCESS != *piError){
2590	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2591	return AUDIO_CHANNEL_STATE_UNDEFINED;
2592	}
2593
2594	*piError = CAS_2B_API_SUCCESS;
2595	if(AUDIO_CHANNEL_LEFT == iAudioChannel){
2596	usReceivedWord = (usReceivedWord & 0x700) >> 8;
2597	}
2598	else{//AUDIO_CHANNEL_RIGHT
2599	usReceivedWord = (usReceivedWord & 0x3800) >> 11;
2600	}
2601
2602	switch(usReceivedWord){
2603	case 0:
2604	return AUDIO_CHANNEL_STATE_MONO;
2605	case 1:
2606	return AUDIO_CHANNEL_STATE_LEFT;
2607	case 2:
2608	return AUDIO_CHANNEL_STATE_RIGHT;
2609	case 3:
2610	return AUDIO_CHANNEL_STATE_MONO_2;
2611	case 5:
2612	case 6:
2613	case 7:
2614	return AUDIO_CHANNEL_STATE_MUTE;
2615	default:
2616	*piError = RECEIVED_UNDEFINED_AUDIO_CHANNEL_STATE;
2617	return AUDIO_CHANNEL_STATE_UNDEFINED;
2618	}
2619	}
2620
2621	BOOLEAN __stdcall IsStereoDetected(int * piError)
2622	{
2623	unsigned short usReceivedWord;
2624	usReceivedWord = ReceiveTransmitRegisterValue(0,piError);
2625	if(IIC_COM_SUCCESS != *piError){
2626	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2627	return FALSE;
2628	}
2629
2630	*piError = CAS_2B_API_SUCCESS;
2631	//get bit 14
2632	usReceivedWord = (usReceivedWord & 0x4000) >> 14;
2633
2634	if(1== usReceivedWord)
2635	return TRUE;
2636	else
2637	return FALSE;
2638
2639	}
2640
2641	BOOLEAN __stdcall IsBilingualSapDetected(int * piError)
2642	{
2643	unsigned short usReceivedWord;
2644	usReceivedWord = ReceiveTransmitRegisterValue(0,piError);
2645	if(IIC_COM_SUCCESS != *piError){
2646	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2647	return FALSE;
2648	}
2649
2650	*piError = CAS_2B_API_SUCCESS;
2651	//get bit 15
2652	usReceivedWord = (usReceivedWord & 0x8000) >> 15;
2653
2654	if(1== usReceivedWord)
2655	return TRUE;
2656	else
2657	return FALSE;
2658	}
2659
2660	TYPE_AUDIO_DEVIATION_MODE __stdcall GetDeviationSensitivityMode(int * piError)
2661	{
2662	unsigned short usReceivedWord;
2663	usReceivedWord = ReceiveTransmitRegisterValue(7,piError);
2664	if(IIC_COM_SUCCESS != *piError){
2665	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2666	return AUDIO_DEVIATION_UNDEFINED;
2667	}
2668
2669	*piError = CAS_2B_API_SUCCESS;
2670	//get bits 11
2671	usReceivedWord = (usReceivedWord & 0x0800) >> 11;
2672	if(usReceivedWord == 0)
2673	return AUDIO_DEVIATION_NORMAL;
2674	else
2675	return AUDIO_DEVIATION_HIGH_DEVIATION;
2676
2677	}
2678
2679	TYPE_AUDIO_STANDARD __stdcall GetAudioStandard(int * piError)
2680	{
2681	unsigned short usReceivedWord;
2682	usReceivedWord = ReceiveTransmitRegisterValue(0,piError);
2683	if(IIC_COM_SUCCESS != *piError){
2684	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2685	return AUDIO_STANDARD_UNDEFINED;
2686	}
2687
2688	*piError = CAS_2B_API_SUCCESS;
2689	//get bits 0-7
2690	usReceivedWord = (usReceivedWord & 0x00ff);
2691	switch(usReceivedWord){
2692	case 30:
2693	return AUDIO_STANDARD_BTSC;
2694	case 31:
2695	return AUDIO_STANDARD_KOREA;
2696	case 32:
2697	return AUDIO_STANDARD_RADIO_FM;
2698	default:
2699	*piError = (int) RECEIVED_UNDEFINED_AUDIO_STANDARD;
2700	return AUDIO_STANDARD_UNDEFINED;
2701	}
2702	}
2703
2704	TYPE_AUDIO_MASTER_SLAVE_MODE __stdcall GetMasterSlaveMode(int * piError)
2705	{
2706	unsigned short usReceivedWord;
2707	usReceivedWord = ReceiveTransmitRegisterValue(7,piError);
2708	if(IIC_COM_SUCCESS != *piError){
2709	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2710	return TYPE_AUDIO_UNDEFINED_MASTER_SLAVE_MODE;
2711	}
2712
2713	*piError = CAS_2B_API_SUCCESS;
2714	//get bits 13
2715	if((usReceivedWord & 0x2000)== 0x2000)
2716	return TYPE_AUDIO_MASTER_MODE;
2717	else
2718	return TYPE_AUDIO_SLAVE_MODE;
2719
2720	}
2721
2722	TYPE_SCL_TO_WS_RATIO __stdcall GetSclToWsRatio(int * piError)
2723	{
2724	unsigned short usReceivedWord;
2725	usReceivedWord = ReceiveTransmitRegisterValue(8,piError);
2726	if(IIC_COM_SUCCESS != *piError){
2727	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2728	return TYPE_SCL_TO_WS_RATIO_UNDEFINED;
2729	}
2730
2731	*piError = CAS_2B_API_SUCCESS;
2732	//get bits 8,9
2733	switch((usReceivedWord & 0x0300) >> 8){
2734	case 0:
2735	return TYPE_SCL_TO_WS_RATIO_32;
2736	case 1:
2737	return TYPE_SCL_TO_WS_RATIO_48;
2738	case 2:
2739	return TYPE_SCL_TO_WS_RATIO_64;
2740	default:
2741	return TYPE_SCL_TO_WS_RATIO_UNDEFINED;
2742	}
2743	}
2744
2745
2746	TYPE_IIS_OUT_RATE __stdcall GetIISOuputRate(int * piError)
2747	{
2748	unsigned short usReceivedWord;
2749	usReceivedWord = ReceiveTransmitRegisterValue(8,piError);
2750	if(IIC_COM_SUCCESS != *piError){
2751	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2752	return TYPE_IIS_OUT_RATE_UNDEFINED;
2753	}
2754
2755	*piError = CAS_2B_API_SUCCESS;
2756	//get bits 10, 11, 12
2757	switch((usReceivedWord & 0x1c00) >> 10){
2758	case 0:
2759	return TYPE_IIS_OUT_RATE_48;
2760	case 1:
2761	return TYPE_IIS_OUT_RATE_96;
2762	case 2:
2763	return TYPE_IIS_OUT_RATE_44_1;
2764	case 3:
2765	return TYPE_IIS_OUT_RATE_88_2;
2766	case 4:
2767	return TYPE_IIS_OUT_RATE_32;
2768	default:
2769	return TYPE_IIS_OUT_RATE_UNDEFINED;
2770	}
2771	}
2772
2773	TYPE_IIS_MODE __stdcall GetIISMode(int * piError)
2774	{
2775	unsigned short usReceivedWord;
2776	usReceivedWord = ReceiveTransmitRegisterValue(8,piError);
2777	if(IIC_COM_SUCCESS != *piError){
2778	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2779	return TYPE_IIS_MODE_UNDEFINED;
2780	}
2781
2782	*piError = CAS_2B_API_SUCCESS;
2783	//get bits 13,14
2784	switch((usReceivedWord & 0x6000) >> 13){
2785	case 0:
2786	return TYPE_IIS_MODE_IIS;
2787	case 1:
2788	return TYPE_IIS_MODE_LJ;
2789	case 2:
2790	return TYPE_IIS_MODE_RJ;
2791	default:
2792	return TYPE_IIS_MODE_UNDEFINED;
2793	}
2794	}
2795
2796
2797	NUMERATOR_DENOMINATOR __stdcall GetSoundCh1AGC(int * piError)
2798	{
2799	unsigned short usReceivedWord = 0;
2800	NUMERATOR_DENOMINATOR stResult;
2801
2802	stResult.Numerator.lNumerator = 0;
2803	stResult.Denominator.lDenominator = 1024;
2804
2805	usReceivedWord = ReceiveTransmitRegisterValue(2,piError);
2806	if(IIC_COM_SUCCESS != *piError){
2807	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2808	return stResult;
2809	}
2810	stResult.Numerator.lNumerator = (usReceivedWord & 0x3ff);
2811	return stResult;
2812	}
2813
2814	NUMERATOR_DENOMINATOR __stdcall GetSoundLeftOutputGain(int * piError)
2815	{
2816	unsigned short usReceivedWord = 0;
2817	NUMERATOR_DENOMINATOR stResult;
2818
2819	stResult.Numerator.lNumerator = 0;
2820	stResult.Denominator.lDenominator = 64;
2821
2822	usReceivedWord = ReceiveTransmitRegisterValue(1,piError);
2823	if(IIC_COM_SUCCESS != *piError){
2824	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2825	return stResult;
2826	}
2827	stResult.Numerator.lNumerator = (usReceivedWord & 0xff);
2828	return stResult;
2829	}
2830
2831	NUMERATOR_DENOMINATOR __stdcall GetSoundRightOutputGain(int * piError)
2832	{
2833	unsigned short usReceivedWord = 0;
2834	NUMERATOR_DENOMINATOR stResult;
2835
2836	stResult.Numerator.lNumerator = 0;
2837	stResult.Denominator.lDenominator = 64;
2838
2839	usReceivedWord = ReceiveTransmitRegisterValue(1,piError);
2840	if(IIC_COM_SUCCESS != *piError){
2841	*piError = (int) RECEIVE_TRANSMIT_REGISTER_VALUE_FUNCTION_FAILED;
2842	return stResult;
2843	}
2844	stResult.Numerator.lNumerator = (usReceivedWord & 0xff00 >> 8);
2845	return stResult;
2846	}
2847
2848
2849	int __stdcall SendAudioMessage(unsigned char ucReceiveRegisterNumber, CAS_2B_AUDIO_MESSAGE_PARAMETERS stAudiomessageParameters)
2850	{
2851
2852	unsigned char ucaSendData[3];
2853	unsigned short usSendData = 0;
2854
2855	switch(ucReceiveRegisterNumber){
2856	//receiev 1;
2857	case 1:
2858	if(TRUE == stAudiomessageParameters.bAudioLeftChannelMute)
2859	usSendData = 0x1;
2860
2861	if(TRUE == stAudiomessageParameters.bAudioRightChannelMute)
2862	usSendData \|= 0x2;
2863
2864	if(TRUE == stAudiomessageParameters.bAudioForcedMonoMode)
2865	usSendData \|= 0x4;
2866
2867	if(AUDIO_NR_SWITCH_SAP == stAudiomessageParameters.iNRSwithch)
2868	usSendData \|= 0x8;
2869
2870	usSendData \|= stAudiomessageParameters.iStereoMode << 4;
2871
2872	if(AUDIO_BILINGUAL_MODE_MONO2_MONO2 == stAudiomessageParameters.iBilingualMode)
2873	usSendData \|= 0x40;
2874
2875	if(TRUE == stAudiomessageParameters.bDeEmphasisOn)
2876	usSendData \|= 0x400;
2877
2878	if(TRUE == stAudiomessageParameters.bDbxOn)
2879	usSendData \|= 0x800;
2880
2881	usSendData \|= stAudiomessageParameters.iHighDeviationMode << 13;
2882
2883	if(TRUE == stAudiomessageParameters.bCh1PllPiIntegratorReset)
2884	usSendData \|= 0x4000;
2885
2886	if(TRUE == stAudiomessageParameters.bCh2PllPiIntegratorReset)
2887	usSendData \|= 0x8000;
2888	break;
2889
2890	//receiev 2
2891	case 2:
2892	usSendData = stAudiomessageParameters.usLeftOutputGain;
2893	usSendData \|= stAudiomessageParameters.usRightOutputGain << 8;
2894	break;
2895
2896	//receiev 3
2897	case 3:
2898	usSendData \|= stAudiomessageParameters.iSclToWsDivisionFactor << 8;
2899
2900	usSendData \|= stAudiomessageParameters.iIisOutRate << 10;
2901
2902	usSendData \|= stAudiomessageParameters.iIisMode << 13;
2903
2904	if(TYPE_AUDIO_MASTER_MODE == stAudiomessageParameters.iMasterSlaveMode)
2905	usSendData \|= 0x8000;
2906	break;
2907	default:
2908	return RECEIVE_REGISTER_NUMBER_OUT_OF_RANGE;
2909
2910	}
2911
2912	ucaSendData[1] = (unsigned char)(usSendData >> 8);
2913	ucaSendData[2] = (unsigned char)usSendData;
2914
2915	return SendToReceive(ucReceiveRegisterNumber, ucaSendData, 2);
2916	}
2917
2918	void __stdcall InitAudioMessageStructToDefault(CAS_2B_AUDIO_MESSAGE_PARAMETERS* pstAudiomessageParameters)
2919	{
2920	if(NULL == pstAudiomessageParameters)
2921	return;
2922
2923	//for receive 1
2924	pstAudiomessageParameters->bAudioLeftChannelMute = FALSE;
2925	pstAudiomessageParameters->bAudioRightChannelMute = FALSE;
2926	pstAudiomessageParameters->bAudioForcedMonoMode = FALSE;
2927	pstAudiomessageParameters->iNRSwithch = AUDIO_NR_SWITCH_STEREO;
2928	pstAudiomessageParameters->iStereoMode = AUDIO_STEREO_MODE_LEFT_RIGHT;
2929	pstAudiomessageParameters->iBilingualMode = AUDIO_BILINGUAL_MODE_MONO2_MONO2;
2930	pstAudiomessageParameters->bDeEmphasisOn = TRUE;
2931	pstAudiomessageParameters->bDbxOn = TRUE;
2932	pstAudiomessageParameters->iHighDeviationMode = AUDIO_DEVIATION_NORMAL;
2933	pstAudiomessageParameters->bCh1PllPiIntegratorReset = FALSE;
2934	pstAudiomessageParameters->bCh2PllPiIntegratorReset = FALSE;
2935	//for receive 2
2936	pstAudiomessageParameters->usLeftOutputGain = 65;
2937	pstAudiomessageParameters->usRightOutputGain = 65;
2938	//for receieve 3
2939	pstAudiomessageParameters->iSclToWsDivisionFactor = TYPE_SCL_TO_WS_RATIO_64;
2940	pstAudiomessageParameters->iIisOutRate = TYPE_IIS_OUT_RATE_48;
2941	pstAudiomessageParameters->iIisMode = TYPE_IIS_MODE_LJ;
2942	pstAudiomessageParameters->iMasterSlaveMode = TYPE_AUDIO_SLAVE_MODE;
2943
2944	}
2945
2946
2947	//*************************************************************************
2948	///for internal use
2949	unsigned char _stdcall CalcLog(unsigned short usReceivedWord)
2950	{
2951	unsigned char ucResult = 1, ucValueToLog;
2952	ucValueToLog = (unsigned char)usReceivedWord;
2953	if(usReceivedWord > 10000){
2954	ucValueToLog = usReceivedWord / 1000;
2955	ucResult = 60; //3 * 20
2956	}
2957	else if(usReceivedWord > 100){
2958	ucValueToLog = usReceivedWord / 100;
2959	ucResult = 40; // 2 * 20;
2960	}
2961	ucResult += GetLogFromTable(ucValueToLog);
2962	return ucResult;
2963	}
2964
2965	unsigned char _stdcall GetLogFromTable(unsigned char ucValueToLog)
2966	{
2967	return ucLogValuesFrom1To100[ucValueToLog];
2968	}
2969
2970
2971	int __stdcall GetChipData(TYPE_CHANNEL_SCAN_RECEIVER_MODE_PRIORITY iReceiverModePriority,LOCK_TYPE iLockType,CAS_2B_CHANNEL_SCAN_RESULT* pstChannelScanResult)
2972	{
2973
2974	unsigned char ucTmp;
2975	int iError;
2976
2977	CAS_2B_TYPE_RECEIVER_MODE iReceiverMode = CAS_2B_RECEIVER_MODE_VSB_8_TR;
2978
2979	if((LOCK_TYPE_DIGITAL_AND_ANALOG == iLockType)\|\|(LOCK_TYPE_ANALOG == iLockType))
2980	pstChannelScanResult->bNtscSignalDetected = TRUE;
2981	else
2982	pstChannelScanResult->bNtscSignalDetected = FALSE;
2983
2984	if(CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_VSB == iReceiverModePriority){
2985	if(LOCK_TYPE_ANALOG == iLockType){
2986	pstChannelScanResult->iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_LOCK_NTSC;
2987	iReceiverMode = CAS_2B_RECEIVER_MODE_VSB_8_TR;
2988	}
2989	else{
2990	//get the mode
2991	ucTmp = GetMode(&iError);
2992	if(iError != CAS_2B_API_SUCCESS)
2993	return iError;
2994
2995	if(0x6 == ucTmp){
2996	pstChannelScanResult->iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_LOCK_VSB_8_TR;
2997	iReceiverMode = CAS_2B_RECEIVER_MODE_VSB_8_TR;
2998	}
2999	else if(0x5 == ucTmp){
3000	pstChannelScanResult->iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_LOCK_VSB_16;
3001	iReceiverMode = CAS_2B_RECEIVER_MODE_VSB_8_TR;
3002	}
3003	else
3004	return UNDEFINED_RECEIVER_MODE;
3005
3006	}
3007	}
3008	else if(CHANNEL_SCAN_RECEIVER_MODE_PRIORITY_ITUB == iReceiverModePriority ){
3009	if(LOCK_TYPE_ANALOG == iLockType){
3010	pstChannelScanResult->iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_LOCK_NTSC;
3011	iReceiverMode = CAS_2B_RECEIVER_MODE_ITUB_256;
3012	}
3013	else{
3014	//get the mode
3015	ucTmp = GetMode(&iError);
3016	if(iError != CAS_2B_API_SUCCESS)
3017	return iError;
3018
3019	if(0x23 == ucTmp){
3020	pstChannelScanResult->iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_LOCK_ITUB_64;
3021	iReceiverMode = CAS_2B_RECEIVER_MODE_ITUB_64;
3022	}
3023	else if(0x25 == ucTmp){
3024	pstChannelScanResult->iReceiverModeLock = CHANNEL_SCAN_RECEIVER_MODE_LOCK_ITUB_256;
3025	iReceiverMode = CAS_2B_RECEIVER_MODE_ITUB_256;
3026	}
3027	else
3028	return UNDEFINED_RECEIVER_MODE;
3029
3030	//get the DI mode command
3031	pstChannelScanResult->iDiMode = GetDiMode(&iError);
3032	if(iError != CAS_2B_API_SUCCESS)
3033	return iError;
3034	}
3035	}
3036
3037
3038	//get the carrier offset
3039	if((LOCK_TYPE_DIGITAL_AND_ANALOG == iLockType)\|\|(LOCK_TYPE_DIGITAL == iLockType)){
3040	pstChannelScanResult->lCarrierOffset = GetCarrierOffset(iReceiverMode,&iError);
3041	if(iError != CAS_2B_API_SUCCESS)
3042	return iError;
3043	}
3044
3045	if((LOCK_TYPE_DIGITAL_AND_ANALOG == iLockType)\|\|(LOCK_TYPE_ANALOG == iLockType)){
3046	pstChannelScanResult->lNtscCarrierOffset = GetNtscCarrierOffset(iReceiverMode,&iError);
3047	if(iError != CAS_2B_API_SUCCESS)
3048	return iError;
3049	}
3050
3051
3052	if((LOCK_TYPE_DIGITAL_AND_ANALOG == iLockType)\|\|(LOCK_TYPE_DIGITAL == iLockType)){
3053	//get the SNR after equalization
3054	pstChannelScanResult->usSnr = GetSnrAfterEqualization(iReceiverMode,&iError);
3055	if(iError != CAS_2B_API_SUCCESS)
3056	return iError;
3057
3058	//get the AGC IF command
3059	pstChannelScanResult->stAgcIfCommand = GetAgcIfCommand(&iError);
3060	if(iError != CAS_2B_API_SUCCESS)
3061	return iError;
3062
3063	//get the Inverse spectrum command
3064	ucTmp = GetRfInverseSpectrum(&iError);
3065	if(iError != CAS_2B_API_SUCCESS)
3066	return iError;
3067
3068	if(1 == ucTmp)
3069	pstChannelScanResult->bRfInverseSpectrum = TRUE;
3070	else
3071	pstChannelScanResult->bRfInverseSpectrum = FALSE;
3072
3073	//get the Symbol rate freq
3074	pstChannelScanResult->stSymbolRateoffset = GetSymbolRateFrequencyOffset(iReceiverMode,&iError);
3075	if(iError != CAS_2B_API_SUCCESS)
3076	return iError;
3077	}
3078
3079	return TRUE;
3080	}
3081	/*
3082	LOCK_TYPE __stdcall CheckIfLocked(unsigned long ulNumberOfTries,BOOLEAN bWithNtscCheck)
3083	{
3084	int iError;
3085	LOCK_STATUS iLockStatus;
3086	BOOLEAN bNtscChannelDetected;
3087	while(ulNumberOfTries){
3088	iLockStatus = IsLocked(&iError);
3089	if(CAS_2B_API_SUCCESS != iError){
3090	return LOCK_TYPE_UNLOCKED;
3091	}
3092	if(TRUE == bWithNtscCheck){
3093	bNtscChannelDetected = IsNtscChannelDetected(&iError);
3094	if(CAS_2B_API_SUCCESS != iError){
3095	return LOCK_TYPE_UNLOCKED;
3096	}
3097	}
3098
3099	if(LOCKED == iLockStatus){
3100	if((TRUE == bWithNtscCheck)&&(TRUE == bNtscChannelDetected)){
3101	return LOCK_TYPE_DIGITAL_AND_ANALOG;
3102	}
3103	else
3104	return LOCK_TYPE_DIGITAL;
3105	}
3106	else{
3107	if((TRUE == bWithNtscCheck)&&(TRUE == bNtscChannelDetected))
3108	return LOCK_TYPE_ANALOG;
3109	else
3110	return LOCK_TYPE_UNLOCKED;
3111	}
3112
3113	ulNumberOfTries--;
3114	}
3115
3116	return LOCK_TYPE_UNLOCKED;
3117	}
3118	*/
3119	LOCK_TYPE __stdcall CheckIfLocked(unsigned long ulNumberOfTries,BOOLEAN bWithNtscCheck, unsigned long ulDelay)
3120	{
3121	int iError;
3122	LOCK_STATUS iLockStatus;
3123	BOOLEAN bNtscChannelDetected = 0;
3124	while(ulNumberOfTries){
3125	OS_Delay(10);/* deley */
3126	iLockStatus = IsLocked(&iError);
3127	if(CAS_2B_API_SUCCESS != iError){
3128	return LOCK_TYPE_UNLOCKED;
3129	}
3130	if(TRUE == bWithNtscCheck){
3131	bNtscChannelDetected = IsNtscChannelDetected(&iError);
3132	if(CAS_2B_API_SUCCESS != iError){
3133	if (ulNumberOfTries == 0)
3134	return LOCK_TYPE_UNLOCKED;
3135	}
3136
3137	}
3138
3139	if(LOCKED == iLockStatus){
3140	if((TRUE == bWithNtscCheck)&&(TRUE == bNtscChannelDetected)){
3141	return LOCK_TYPE_DIGITAL_AND_ANALOG;
3142	}
3143	else
3144	return LOCK_TYPE_DIGITAL;
3145
3146	}
3147	else{
3148	if((TRUE == bWithNtscCheck)&&(TRUE == bNtscChannelDetected))
3149	return LOCK_TYPE_ANALOG;
3150	else
3151	if (ulNumberOfTries == 0)
3152	return LOCK_TYPE_UNLOCKED;
3153	}
3154	ulNumberOfTries--;
3155	}
3156
3157	return LOCK_TYPE_UNLOCKED;
3158
3159	}
3160
3161	BOOLEAN BeforeTunerSendBytes()
3162	{
3163	if(IIC_COM_SUCCESS != SendHostControl(0, 0))
3164	return FALSE;
3165	else
3166	return TRUE;
3167	}
3168
3169	BOOLEAN AfterTunerSendBytes()
3170	{
3171	if(IIC_COM_SUCCESS != SendHostControl(0x80, 0))
3172	return FALSE;
3173	else
3174	return TRUE;
3175	}
3176
3177	///for internal use
3178	//*************************************************************************
3179
3180

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

Context Navigation

source: svn/trunk/zas_dstar/devices/Tuner/Oren_Cascade2B/Cas2BRoutines.c @ 2

Download in other formats: