Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

__Cas2BRoutines.c @ 44

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

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

Context Navigation

source: svn/zas_dstar/devices/Tuner/Oren_Cascade2B/__Cas2BRoutines.c @ 44

Download in other formats: