Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

S5H1411.c @ 22

Last change on this file since 22 was 22, checked in by phkim, 11 years ago
phkim newcon3sk 를 kctv 로 브랜치 함
Property svn:executable set to ``*
File size: 45.6 KB

Line
1	/**
2	SFILE***************************************************************
3	* FILE NAME : 1411x.cpp
4	* AUTHOR : SOC Development Center, Channel Development Team,
5	* Channel.cs
6	* MODERATOR :
7	* ISSUED To :
8	* ISSUED Day : OCTOBER 4,2007
9	* VERSION : 2.05
10	* Init.Version : Initialization 2.04
11	* FILE DESCRIPTION: S5H1411 VSB/QAM Porting Code
12	* ABBREVIATION : Update Sec_1411xInitialize Driver
13	* Copyright (c) 2006~2007 Samsung Electronics, Inc.
14	* All rights reserved.
15	*
16	* This software is the confidential and proprietary information
17	* of Samsung Electronics, Inc("Confidential Information"). You
18	* Shall not disclose such Confidential Information and shall use
19	* it only in accordance with the terms of the license agreement
20	* you entered into SAMSUNG.
21	*************************************************************EFILE/
22
23	#include "DHL_OSAL.h"
24	#include "DHL_DEV_Priv.h"
25
26	#include <math.h>
27
28	#include "S5H1411.h"
29
30	/********************************************************************
31	MACRO CONSTANT DEFINITIONS
32	********************************************************************/
33	#define OK 0
34	#define IIC_1411x_TOP_RegId 0x72
35	#define IIC_1411x_QAM_RegId 0x74
36
37
38
39	/********************************************************************
40	MACRO FUNCTION DEFINITIONS
41	********************************************************************/
42	/********************************************************************
43	TYPE DEFINITION
44	********************************************************************/
45
46
47
48
49	/********************************************************************
50	EXTERN VARIABLES & FUNCTION PROTOTYPES DECLARATIONS
51	********************************************************************/
52	/********************************************************************
53	GLOBAL VARIABLES DEFINITIONS & FUNCTION PROTOTYPE DECLARATIONS
54	********************************************************************/
55
56
57	/********************************************************************
58	STATIC VARIABLES DEFINITIONS & FUNCTION PROTOTYPE DECLARATIONS
59	********************************************************************/
60	static int pChargePumpValue;
61	static int VSB_Mode;
62
63	DATA32 Sec_1411xGetMode(void);
64	///////////////// ///////////////// ///////////////////
65	///////////////// I2C Engine////////// ////////////////
66	///////////////// ///////////////// ///////////////////
67
68	/* ************************************************************************ */
69	/* */
70	/* This function should be implemented by customers */
71	/* */
72	/* ************************************************************************ */
73
74	#if 1
75
76	/*
77	void I2cStop()
78	{
79	return 1;
80	}
81
82	void I2cStart()
83	{
84	return 1;
85	}
86	*/
87	I2C_STATUS WritetoTuner(I2C_STATUS nb_bytes_to_send, DATA08 *bytes_to_send)
88	{
89
90	return 1;
91	}
92
93
94
95	I2C_STATUS I2cWriteOneRegister(int Id, int Address , int Data)
96	{
97
98
99	DHL_RESULT dhr = DHL_OK;
100	//SSdtReturn_t nRet = SSDT_ERR_NO;
101	DATA16 chip_addr = Id;
102	DATA08 sub_addr = Address;
103	DATA08 data[2];
104
105	data[0]=(Data>>8) & 0xff;
106	data[1]=Data & 0xff;
107
108	dhr = dhl_i2c_write2(0,chip_addr,sub_addr,data,2);
109
110	if(dhr != DHL_OK)
111	{
112	DHL_OS_Printf("\|%s\| fail to write demod(chip_addr:0x%x).\n",
113	__FUNCTION__, Id);
114	return 1;
115	}
116	else
117	{
118	return 0;
119	}
120
121
122	}
123
124
125
126	I2C_STATUS I2cReadOneRegister(int Id, int Address)
127	{
128	DHL_RESULT dhr = DHL_OK;
129	I2C_STATUS chip_addr = Id;
130	DATA08 sub_addr = Address;
131	DATA08 dummy[2]={0};
132
133	dhr = dhl_i2c_read2(0,chip_addr,sub_addr,dummy,2);
134
135	if(dhr != DHL_OK)
136	{
137	DHL_OS_Printf("\|%s\| fail to read demod(chip_addr:0x%x).\n",
138	__FUNCTION__, Id);
139	}
140
141	return (I2C_STATUS)(((unsigned int)dummy[0] << 8) \| dummy[1]);
142
143	}
144
145	#endif
146
147	/* *************************************************************** */
148	/* */
149	/* CODE PROVIDED BY Channel Team */
150	/* */
151	/* *************************************************************** */
152
153	///////////////// ///////////////// ///////////////////
154	///////////////// SEMCO Tuner Function ////////////////
155	///////////////// ///////////////// ///////////////////
156
157	/**************************************************************************************************************************
158	* RF TUNING FUNCTION
159	* Tuning Formula : calcFreq = ((chFreq + 44) / 50) * 1000;
160	* calcFreq is the LO(local oscillator) setting vaule to convert the RF signal to IF signal.
161	* Regardless of analogue signals and digital signals, the LO setting value is the same. For example,
162	* For DTV Tuning, RF Freq. = 57MHz, IF Center. Freq=44MHz, calcFreq = ((57+44)/50)*1000= 2020.
163	* For NTSC Tuning, RF Freq(Picture Freq.) = 55.25MHz, IF Picture Freq.=45.75MHz,calcFreq=
164	* ((55.25+45.75)/50*1000 = 2020. Accordingly, DTV and analogue channels can be tuned with the
165	* same scheme.
166	**************************************************************************************************************************/
167	DATA32 SEMCOxTune(double chFreq)
168	{
169	int j;
170	DATA_DOUBLE calcFreq;
171	I2C_STATUS calcBuff;
172	I2C_STATUS tunerData[6];
173	I2C_STATUS pChargePumpValue;
174	///////////////////////////////////////////////////////////////////////////////////////////////
175	//// Making Charge Pump Current
176	//// To optimize the phase noise performance, the "pChargePumpValue" needs to be set
177	//// differently according to a channel frequency
178	///////////////////////////////////////////////////////////////////////////////////////////////
179
180	if ((chFreq>36.0) && (chFreq<=170.0))
181	{
182	if ((chFreq>48.0) && (chFreq<=100.0))
183	pChargePumpValue = 2;
184	else if ((chFreq>100.0) && (chFreq<=112.0))
185	pChargePumpValue = 3;
186	else if ((chFreq>112.0) && (chFreq<=132.0))
187	pChargePumpValue = 4;
188	else if ((chFreq>132.0) && (chFreq<=140.0))
189	pChargePumpValue = 5;
190	else if ((chFreq>140.0) && (chFreq<=170.0))
191	pChargePumpValue = 6;
192
193	pChargePumpValue = (pChargePumpValue << 5) \| 0x01;
194	}
195	else if ((chFreq>170.0) && (chFreq<=469.0))
196	{
197	if ((chFreq>169.0) && (chFreq<=180.0))
198	pChargePumpValue = 1;
199	else if ((chFreq>180.0) && (chFreq<=252.0))
200	pChargePumpValue = 2;
201	else if ((chFreq>252.0) && (chFreq<=360.0))
202	pChargePumpValue = 3;
203	else if ((chFreq>360.0) && (chFreq<=404.0))
204	pChargePumpValue = 4;
205	else if ((chFreq>404.0) && (chFreq<=428.0))
206	pChargePumpValue = 5;
207	else if ((chFreq>428.0) && (chFreq<=440.0))
208	pChargePumpValue = 6;
209	else if ((chFreq>440.0) && (chFreq<=469.0))
210	pChargePumpValue = 7;
211
212	pChargePumpValue = (pChargePumpValue << 5) \| 0x02;
213
214	}
215	else if ((chFreq>469.0) && (chFreq<=864.0))
216	{
217	if ((chFreq>469.0) && (chFreq<=560.0))
218	pChargePumpValue = 3;
219	else if ((chFreq>560.0) && (chFreq<=632.0))
220	pChargePumpValue = 4;
221	else if ((chFreq>632.0) && (chFreq<=708.0))
222	pChargePumpValue = 5;
223	else if ((chFreq>708.0) && (chFreq<=824.0))
224	pChargePumpValue = 6;
225	else if ((chFreq>824.0) && (chFreq<=864.0))
226	pChargePumpValue = 7;
227
228	pChargePumpValue = (pChargePumpValue << 5) \| 0x08;
229	}
230	else
231	{
232	pChargePumpValue = 1;
233	}
234
235	////////////////////////////////////////////////////////////////////////////////////////////
236	////// Making chFreq. to Tune //////
237	////////////////////////////////////////////////////////////////////////////////////////////
238	calcFreq = ((chFreq + 44) / 50) * 1000;
239	calcBuff = (int)calcFreq;
240
241
242	tunerData[0] = 0xc2 ; //Semco Tuner ID
243	tunerData[1] = (calcBuff >> 8) & 0x00FF;
244	tunerData[2] = (calcBuff) & 0x00FF;
245	tunerData[3] = 0xc3;
246	tunerData[4] = pChargePumpValue;
247	if(!Sec_1411xGetMode()) //VSB mode
248	{
249	tunerData[5] = 0x81;
250	}
251	else //QAM mode
252	{
253	tunerData[5] = 0x82;
254	}
255	for( j=0; j<6; j++)
256	{
257	WritetoTuner(6,tunerData); //physical channel tune
258	}
259	}
260
261	/*********************************************************************************************************
262	* S5H1411 Initialization Driver
263	* Conditions:
264	* Version:Init_Air 2.04
265	* Description:
266	* This function is called to initialize the register values.
267	* This function must be called once to run the system properly.
268	* After this function is called, the VSB mode is set as a default.
269	**********************************************************************************************************/
270	I2C_STATUS Sec_1411xInitialize(void)
271	{
272	I2C_STATUS result = OK;
273	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00 , 0x0071);
274	//result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x08 , 0x0047);
275	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x08 , 0x15);
276	//default -> ATSC test
277	// result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x38 , 0xe614);
278	// result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x39 , 0x1d72);
279
280
281	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x1C , 0x0400);
282	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x1E , 0x0370);
283	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x1F , 0x342c);
284	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x24 , 0x0231);
285	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x25 , 0x1011);
286	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x26 , 0x0f07);
287	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x27 , 0x0F04);
288	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x28 , 0x070f);
289	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x29 , 0x2820);
290	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x2A , 0x102e);
291	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x2B , 0x0220);
292	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x2E , 0x0d0e);
293	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x2F , 0x1013);
294	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x31 , 0x171b);
295	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x32 , 0x0e0f);
296	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x33 , 0x0f10);
297	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x34 , 0x170e);
298	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x35 , 0x4b10);
299	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x36 , 0x0f17);
300	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x3C , 0x1577);
301	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x3D , 0x081A);
302	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x3E , 0x77ee);
303	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x40 , 0x1e09);
304	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x41 , 0x0f0c);
305	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x42 , 0x1f10);
306	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x4D , 0x0509);
307	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x4E , 0x0a00);
308	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x50 , 0x0000);
309	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x5B , 0x0000);
310	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x5C , 0x0008);
311	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x57 , 0x1101);
312	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x65 , 0x007c);
313	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x68 , 0x0512);
314	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x69 , 0x0258);
315	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x70 , 0x0004);
316	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x71 , 0x0007);
317	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x76 , 0x00a9);
318	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x78 , 0x3141);
319	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x7A , 0x3141);
320	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB3 , 0x8003);
321	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB5 , 0xa6bb);
322	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB6 , 0x0609);
323	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB7 , 0x2f06);
324	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB8 , 0x003f);
325	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB9 , 0x2700);
326	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xBA , 0xfac8);
327	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xBE , 0x1003);
328	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xBF , 0x103F);
329	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xCE , 0x2000);
330	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xCF , 0x0800);
331	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD0 , 0x0800);
332	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD1 , 0x0400);
333	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD2 , 0x0800);
334	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD3 , 0x2000);
335	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD4 , 0x3000);
336	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xDB , 0x4a9b);
337	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xDC , 0x1000);
338	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xDE , 0x0001);
339	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xDF , 0x0000);
340	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xE3 , 0x0301);
341	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0xF3 , 0x0000);
342	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0xF3 , 0x0001);
343	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x08 , 0x0600);
344	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x18 , 0x4201);
345	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x1E , 0x6476);
346	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x21 , 0x0830);
347	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x0C , 0x5679);
348	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x0D , 0x579b);
349	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x24 , 0x0102);
350	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x31 , 0x7488);
351	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x32 , 0x0a08);
352	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x3D , 0x8689);
353	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x41 , 0x0f98);
354	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x49 , 0x0048);
355	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x57 , 0x2012);
356	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x5D , 0x7676);
357	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x04 , 0x0400);
358	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x58 , 0x00c0);
359	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x5B , 0x0100);
360	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xF7 , 0x0000);
361	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xF7 , 0x0001);
362
363	return result;
364
365	}
366
367	/*********************************************************************************************************
368	* S5H1411 Soft reset Driver
369	* Conditions: When a channel is changed or LNA is on/off, this function is called.
370	* Description:
371	* This function is called in order to reset all software conditions.
372	* But it does not reset register values.
373
374	* Addr: 0xf7
375	* Value: 0x00 -> Chip Reset Start
376	* Value: 0x01 -> Chip Reset End
377	**********************************************************************************************************/
378	I2C_STATUS Sec_1411xSoftReset(void)
379	{
380	DATA32 result = OK;
381	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf7, 0x0000);
382	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf7, 0x0001);
383	return result;
384	}
385
386	/*********************************************************************************************************
387	* S5H1411 Register Value reset Driver
388	* Conditions: This function is called when the system needs initialization.
389	* Description:
390	* A register value is reset following this call.
391	* The system needs to call initialization function to be run properly after this function is called.
392	* Addr: 0xf3
393	* Value:
394	* Following this call, a register value of the 0xf3 is changed from '0x01' to '0x00'.
395	* After that the value is back to '0x01' automatically.
396	**********************************************************************************************************/
397	I2C_STATUS Sec_1411xRegReset(void)
398	{
399	DATA32 result = OK;
400	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf3, 0x0000);
401	return result;
402	}
403
404	/*********************************************************************************************************
405	* S5H1411 Repeater Control Driver
406	* Conditions:
407	* Description:
408	* This function is used to set the bypass mode or normal mode. (Repeater Enable or Disable)
409	* In the bypass mode, the host PC controls a channel chip first and the channel chip controls
410	* a tuner using GPIO.
411	* Addr: 0xf5
412	* Value: 0x00 -> Tuner by pass close (Repeater Disable) ? Default mode
413	* Value: 0x01 -> Tuner by pass open (Repeater Enable)
414	**********************************************************************************************************/
415	I2C_STATUS Sec_1411xRepeaterEnable(void)
416	{
417	DATA32 result = OK;
418	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf5, 0x0001);
419	return result;
420	}
421	I2C_STATUS Sec_1411xRepeaterDisable(void)
422	{
423	DATA32 result = OK;
424	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf5, 0x0000);
425	return result;
426	}
427
428	/*********************************************************************************************************
429	* S5H1411 VSB, QAM mode change Driver
430	* Conditions:
431	* Description: These functions set an 8-VSB & QAM (64/256) mode
432	* Addr: 0xf6
433	* Value: 0x00 -> VSB mode (Default)
434	* Value: 0x01 -> QAM mode
435	* Addr: 0x16
436	* Value: 0x1101 -> QAM (Detect 64/256 qam automatically)
437	* Value: 0x1100 -> QAM (Detect 64/256 qam manually)
438	* Addr: 0x17
439	* Value: 0x0101 -> 64 QAM (Manual mode)
440	* Value: 0x0111 -> 256 QAM (Manual mode)
441	**********************************************************************************************************/
442	I2C_STATUS Sec_1411xVsbMode(void)
443	{
444	DATA32 result = OK;
445	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00, 0x0071);
446	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf6, 0x0000);
447	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xcd, 0x00f1);
448	Sec_1411xSoftReset();
449	return result;
450	}
451	I2C_STATUS Sec_1411xQamMode(void)
452	{
453	DATA32 result = OK;
454	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00, 0x0171);
455	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf6, 0x0001);
456	result \|= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x16, 0x1101);
457	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xcd, 0x00f0);
458	Sec_1411xSoftReset();
459	return result;
460	}
461
462	I2C_STATUS Sec_1411x64QamMode(void)
463	{
464	DATA32 result = OK;
465	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00, 0x0171);
466	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf6, 0x0001);
467	result \|= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x16, 0x1100);
468	result \|= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x17, 0x0101);
469	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xcd, 0x00f0);
470	Sec_1411xSoftReset();
471	return result;
472	}
473
474	I2C_STATUS Sec_1411x256QamMode(void)
475	{
476	DATA32 result = OK;
477	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00, 0x0171);
478	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf6, 0x0001);
479	result \|= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x16, 0x1100);
480	result \|= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x17, 0x0111);
481	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xcd, 0x00f0);
482	Sec_1411xSoftReset();
483	return result;
484	}
485	/*********************************************************************************************************
486	* S5H1411 Get Mode Driver
487	* Conditions:
488	* Description: This function get a mode(VSB/QAM) of S5H1411.
489	* Addr: 0xf6
490	* Value: 0x00 -> VSB mode (Default)
491	* Value: 0x01 -> QAM mode
492	**********************************************************************************************************/
493	DATA32 Sec_1411xGetMode(void)
494	{
495	DATA32 mode;
496	mode = I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xf6);
497	return mode;
498
499	}
500
501	/*********************************************************************************************************
502	* S5H1411 Get QAM Mode Driver
503	* Conditions:
504	* Description: This function get a QAM mode(64/256).
505	* Addr: 0xf0
506	* Value: 0x01 -> 256QAM mode
507	* Value: 0x00 -> 64QAM mode
508	**********************************************************************************************************/
509	DATA32 Sec_1411xGetQAMMode(void)
510	{
511	DATA32 qam_mode;
512	qam_mode = I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xf0) & 0x0001;
513	return qam_mode;
514	}
515
516	/****************************************************************************************************
517	* S5H1411 Sleep mode change Driver
518	* Conditions:
519	* Description:
520	* The software-based power down function is as follows.
521	* This function is called in order to set a sleep on mode or sleep off mode.
522
523	* Addr: 0xf4
524	* Value: 0x01 -> Sleep mode
525	* Value: 0x00 -> Running mode ? Default mode
526	****************************************************************************************************/
527	I2C_STATUS Sec_1411xSleepOn(void)
528	{
529	DATA32 result = OK;
530	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf4,0x01);
531	return result;
532	}
533	I2C_STATUS Sec_1411xSleepOff(void)
534	{
535	DATA32 result = OK;
536	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf4,0x00);
537	Sec_1411xSoftReset();
538	return result;
539	}
540
541	/****************************************************************************************************
542	* S5H1411 VSB Sync Lock Check Driver
543	* Conditions: VSB mode
544	* Description: This function is used to check whether the sync detector is lock or not in VSB mode.
545	* Addr: 0x5e
546	* Value: [0] bit -> 1:Lock , 0: Unlock
547
548	****************************************************************************************************/
549	DATA32 Sec_1411xSyncLock(void)
550	{
551	DATA32 sync_lock;
552	sync_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0x5e)) & 0x0001;
553	return sync_lock;
554	}
555
556	/****************************************************************************************************
557	* S5H1411 VSB Equalizer Lock Check Driver
558	* Conditions: VSB mode
559	* Description: This function is used to check whether the equalizer is lock or not in VSB mode.
560	* Addr: 0xf2
561	* Value: [13] bit -> 1:Lock , 0: Unlock
562
563	****************************************************************************************************/
564	DATA32 Sec_1411xVsbEqLock(void)
565	{
566	DATA32 eq_lock;
567	eq_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf2) >> 13) & 0x0001;
568	return eq_lock;
569	}
570
571	/****************************************************************************************************
572	* S5H1411 VSB Fec Lock Check Driver
573	* Conditions: VSB mode
574	* Description: This function is used to check whether the FEC is lock or not in VSB mode.
575	* Addr: 0xf2
576	* Value: [12] bit -> 1:Lock , 0: Unlock
577
578	****************************************************************************************************/
579	DATA32 Sec_1411xVSBFecLock(void)
580	{
581	DATA32 fec_lock;
582	fec_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf2) >> 12) & 0x0001;
583	return fec_lock;
584	}
585
586	/****************************************************************************************************
587	* S5H1411 QAM Fec Lock Check Driver
588	* Conditions: QAM mode
589	* Description: This function is used to check whether the FEC is lock or not in QAM mode.
590	* Addr: 0xf0
591	* Value: [4] bit -> 1:Lock , 0: Unlock
592
593	****************************************************************************************************/
594	DATA32 Sec_1411xQAMFec_Lock(void)
595	{
596	DATA32 fec_lock;
597	fec_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf0) >> 4) & 0x0001;
598	return fec_lock;
599	}
600
601	/****************************************************************************************************
602	* S5H1411 QAM Equalizer Lock Check Driver
603	* Conditions: QAM mode
604	* Description: This function is used to check whether the FEC is lock or not in QAM mode.
605	* Addr: 0xf0
606	* Value: [8] bit -> 1:Lock , 0: Unlock
607
608	****************************************************************************************************/
609	DATA32 Sec_1411xQAMEq_Lock(void)
610	{
611	DATA32 eq_lock;
612	eq_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf0) >> 8) & 0x0001;
613	return eq_lock;
614	}
615
616	/****************************************************************************************************
617	* S5H1411 VSB/QAM Master Lock Check Driver
618	* Conditions: VSB/QAM mode
619	* Description: This function is used to check whether the channel chip is lock or not in VSB/QAM mode.
620	* Addr: 0xf2
621	* Value: 15bit -> 1:Lock , 0: Unlock
622
623	****************************************************************************************************/
624	DATA32 Sec_1411xVsbQAM_Master_Lock(void)
625	{
626	DATA32 master_lock;
627	master_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf2)>>15) & 0x0001; //0x1 --> Master lock, 0x0 --> Master Unlock
628	return master_lock;
629	}
630
631	/**************************************************************************
632	* S5H1411 VSB SNR value(Signal Quality) Check Driver
633	* Conditions:
634	* Description :
635	* This function lets the user's application software read a value
636	* that is related to the SNR through the SNR Look Up Table in VSB mode.
637	* Addr : 0xf2
638	* Value: [9:0]
639	/**************************************************************************/
640	DATA_DOUBLE SnrLookUpTable(int SnrRead)
641	{
642	DATA_DOUBLE SnrLookUP;
643	if (SnrRead > 0x39f )SnrLookUP = 30 ;
644	else if(SnrRead > 0x39b) SnrLookUP = 29.5 ;
645	else if(SnrRead > 0x397) SnrLookUP = 29 ;
646	else if(SnrRead > 0x394) SnrLookUP = 28.5 ;
647	else if(SnrRead > 0x38f) SnrLookUP = 28.0 ;
648	else if(SnrRead > 0x38b) SnrLookUP = 27.5 ;
649	else if(SnrRead > 0x387) SnrLookUP = 27.0 ;
650	else if(SnrRead > 0x382) SnrLookUP = 26.5 ;
651	else if(SnrRead > 0x37d) SnrLookUP = 26.0 ;
652	else if(SnrRead > 0x377) SnrLookUP = 25.5 ;
653	else if(SnrRead > 0x370) SnrLookUP = 25.0 ;
654	else if(SnrRead > 0x36a) SnrLookUP = 24.5 ;
655	else if(SnrRead > 0x364) SnrLookUP = 24.0 ;
656	else if(SnrRead > 0x35b) SnrLookUP = 23.5 ;
657	else if(SnrRead > 0x353) SnrLookUP = 23.0 ;
658	else if(SnrRead > 0x349) SnrLookUP = 22.5 ;
659	else if(SnrRead > 0x340) SnrLookUP = 22.0 ;
660	else if(SnrRead > 0x337) SnrLookUP = 21.5 ;
661	else if(SnrRead > 0x327) SnrLookUP = 21.0 ;
662	else if(SnrRead > 0x31b) SnrLookUP = 20.5 ;
663	else if(SnrRead > 0x310) SnrLookUP = 20.0 ;
664	else if(SnrRead > 0x302) SnrLookUP = 19.5 ;
665	else if(SnrRead > 0x2f3) SnrLookUP = 19.0 ;
666	else if(SnrRead > 0x2e4) SnrLookUP = 18.5 ;
667	else if(SnrRead > 0x2d7) SnrLookUP = 18.0 ;
668	else if(SnrRead > 0x2cd) SnrLookUP = 17.5 ;
669	else if(SnrRead > 0x2bb) SnrLookUP = 17.0 ;
670	else if(SnrRead > 0x2a9) SnrLookUP = 16.5 ;
671	else if(SnrRead > 0x29e) SnrLookUP = 16.0 ;
672	else if(SnrRead > 0x284) SnrLookUP = 15.5 ;
673	else if(SnrRead > 0x27a) SnrLookUP = 15.0 ;
674	else if(SnrRead > 0x260) SnrLookUP = 14.5 ;
675	else if(SnrRead > 0x23a) SnrLookUP = 14.0 ;
676	else if(SnrRead > 0x224) SnrLookUP = 13.5 ;
677	else if(SnrRead > 0x213) SnrLookUP = 13.0 ;
678	else if(SnrRead > 0x204) SnrLookUP = 12.5 ;
679	else if(SnrRead > 0x1fe) SnrLookUP = 12.0 ;
680	else SnrLookUP = 0 ;
681	return SnrLookUP;
682	}
683	DATA_DOUBLE Sec_1411xVsbSnrResultCheck(void)
684	{
685	DATA32 value;
686	DATA_DOUBLE SnrValue;
687	value = I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf2);
688	value = (value & 0x3ff);
689	SnrValue = SnrLookUpTable(value);
690	return SnrValue;
691	}
692
693	/*********************************************************************************************************
694	* S5H1411 VSB Pre BER Count Check Driver
695	* Conditions:
696	* Description:
697	* Error count value before TCM decoder
698	* This function is used to check pre BER count.
699	* Addr: 0xca
700	* Value: [15:0]
701	**********************************************************************************************************/
702	DATA_DOUBLE Sec_1411xPreBer(void)
703	{
704	DATA_DOUBLE pre_ber;
705	pre_ber = (I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xca)) / 65534;
706	return pre_ber;
707
708	}
709
710	/*********************************************************************************************************
711	* S5H1411 VSB Post BER Count Check Driver
712	* Conditions:
713	* Description:
714	* Error count value after TCM decoder
715	* This function is used to check post BER count.
716	* Addr: 0xcb
717	* Value: [15:0]
718	**********************************************************************************************************/
719	DATA_DOUBLE Sec_1411xPostBer(void)
720	{
721	DATA_DOUBLE post_ber;
722	post_ber = (I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xcb)) / 65536;
723	return post_ber;
724
725	}
726
727	/*********************************************************************************************************
728	* S5H1411 VSB Packet Error Check Driver
729	* Conditions:
730	* Description:
731	* Error count value after RS decoder
732	* This function is used to count the packet error.
733	* Addr: 0xc9
734	* Value: [15:0]
735	**********************************************************************************************************/
736	DATA32 S5H1411x_UncorrectableError(void)
737	{
738	DATA32 unc_err;
739	unc_err = I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xc9);
740	return unc_err;
741	}
742
743	/*******************************************************************************************************************************
744	* S5H1411 TS Mode Set
745	* Conditions:
746	* Description:Through changing this register,it can control the MPEG data mode as parall or serial mode
747	* Addr: 0xbd
748	* Value: [8]:1 ? MPEG data are sent out as a byte.
749	* Value: [8]:0 ? MPEG data are sent out bit by bit serially.
750	*******************************************************************************************************************************/
751	DATA32 TS_Serial_Set()
752	{
753	DATA32 result;
754
755	result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbd,0x1101);
756
757	return (result);
758	}
759
760	DATA32 TS_Parallel_Set()
761	{
762	DATA32 result;
763
764	result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbd,0x1001);
765
766	return (result);
767	}
768
769	/*******************************************************************************************************************************
770	* S5H1411 MPEG Output Timing Mode Set
771	* Conditions:
772	* Description:Through changing this register,it can control the MPEG timing mode.Refer to the datasheet document.
773	* Addr: 0xbe
774	* Value: [13:12]:00 - continous and inverting clk.
775	* Value: [13:12]:01 - continous and non-inverting clk.
776	* Value: [13:12]:10 - non-continous and inverting clk.
777	* Value: [13:12]:11 - non-continous and non-inverting clk.
778	*******************************************************************************************************************************/
779	DATA32 Cont_Invert_Set()
780	{
781	DATA32 result;
782
783	result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbe,0x0003);
784
785	return (result);
786	}
787
788	DATA32 Cont_Non_Invert_Set()
789	{
790	DATA32 result;
791
792	result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbe,0x1003);
793
794	return (result);
795	}
796	DATA32 Non_Cont_Invert_Set()
797	{
798	DATA32 result;
799
800	result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbe,0x2003);
801
802	return (result);
803	}
804
805	DATA32 Non_Cont_Non_Invert_Set()
806	{
807	DATA32 result;
808
809	result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbe,0x3003);
810
811	return (result);
812	}
813	/*********************************************************************************************************
814	* S5H1411 QAM SNR value(Signal Strength) Check Driver
815	* Conditions:
816	* Description
817	* This function lets the user's application software read a value that is related to the SNR through
818	* the SNR Look Up Table in QAM mode.
819
820	* Addr : 0xf1
821	* Value: [15:0]
822	**********************************************************************************************************/
823	DATA_DOUBLE Qam64SnrLookUpTable(int SnrRead)
824	{
825	DATA_DOUBLE SnrLookUP;
826	if (SnrRead< 0xaf0 ) SnrLookUP = 30 ;
827	else if(SnrRead < 0xd80 ) SnrLookUP = 29 ;
828	else if(SnrRead < 0x10a0 ) SnrLookUP = 28 ;
829	else if(SnrRead < 0x14b5 ) SnrLookUP = 27 ;
830	else if(SnrRead < 0x1590 ) SnrLookUP = 26.8 ;
831	else if(SnrRead < 0x1680 ) SnrLookUP = 26.6 ;
832	else if(SnrRead < 0x17b0 ) SnrLookUP = 26.4 ;
833	else if(SnrRead < 0x18c0 ) SnrLookUP = 26.2 ;
834	else if(SnrRead < 0x19b0 ) SnrLookUP = 26 ;
835	else if(SnrRead < 0x1ad0 ) SnrLookUP = 25.8 ;
836	else if(SnrRead < 0x1d00 ) SnrLookUP = 25.6 ;
837	else if(SnrRead < 0x1da0 ) SnrLookUP = 25.4 ;
838	else if(SnrRead < 0x1ef0 ) SnrLookUP = 25.2 ;
839	else if(SnrRead < 0x2050 ) SnrLookUP = 25 ;
840	else if(SnrRead < 0x20f0 ) SnrLookUP = 24.9 ;
841	else if(SnrRead < 0x21d0 ) SnrLookUP = 24.8 ;
842	else if(SnrRead < 0x22b0 ) SnrLookUP = 24.7 ;
843	else if(SnrRead < 0x23a0 ) SnrLookUP = 24.6 ;
844	else if(SnrRead < 0x2470 ) SnrLookUP = 24.5 ;
845	else if(SnrRead < 0x24f0 ) SnrLookUP = 24.4 ;
846	else if(SnrRead < 0x25a0 ) SnrLookUP = 24.3 ;
847	else if(SnrRead < 0x26c0 ) SnrLookUP = 24.2 ;
848	else if(SnrRead < 0x27b0 ) SnrLookUP = 24.1 ;
849	else if(SnrRead < 0x28d0 ) SnrLookUP = 24 ;
850	else if(SnrRead < 0x29b0 ) SnrLookUP = 23.9 ;
851	else if(SnrRead < 0x2ad0 ) SnrLookUP = 23.8 ;
852	else if(SnrRead < 0x2ba0 ) SnrLookUP = 23.7 ;
853	else if(SnrRead < 0x2c80 ) SnrLookUP = 23.6 ;
854	else if(SnrRead < 0x2d20 ) SnrLookUP = 23.5 ;
855	else if(SnrRead < 0x2e00 ) SnrLookUP = 23.4 ;
856	else if(SnrRead < 0x2f10 ) SnrLookUP = 23.3 ;
857	else if(SnrRead < 0x3050 ) SnrLookUP = 23.2 ;
858	else if(SnrRead < 0x3190 ) SnrLookUP = 23.1 ;
859	else if(SnrRead < 0x3300 ) SnrLookUP = 23 ;
860	else if(SnrRead < 0x3340 ) SnrLookUP = 22.9 ;
861	else if(SnrRead < 0x3200 ) SnrLookUP = 22.8 ;
862	else if(SnrRead < 0x3550 ) SnrLookUP = 22.7 ;
863	else if(SnrRead < 0x3610 ) SnrLookUP = 22.6 ;
864	else if(SnrRead < 0x3600 ) SnrLookUP = 22.5 ;
865	else if(SnrRead < 0x3700 ) SnrLookUP = 22.4 ;
866	else if(SnrRead < 0x3800 ) SnrLookUP = 22.3 ;
867	else if(SnrRead < 0x3920 ) SnrLookUP = 22.2 ;
868	else if(SnrRead < 0x3a20 ) SnrLookUP = 22.1 ;
869	else if(SnrRead < 0x3b30 ) SnrLookUP = 22 ;
870	else if(SnrRead < 0x3d00 ) SnrLookUP = 21.9 ;
871	else if(SnrRead < 0x3e00 ) SnrLookUP = 21.8 ;
872	else if(SnrRead < 0x4000 ) SnrLookUP = 21.7 ;
873	else if(SnrRead < 0x4100 ) SnrLookUP = 21.6 ;
874	else if(SnrRead < 0x4300 ) SnrLookUP = 21.5 ;
875	else if(SnrRead < 0x4400 ) SnrLookUP = 21.4 ;
876	else if(SnrRead < 0x4600 ) SnrLookUP = 21.3 ;
877	else if(SnrRead < 0x4700 ) SnrLookUP = 21.2 ;
878	else if(SnrRead < 0x4800 ) SnrLookUP = 21.1 ;
879	else if(SnrRead < 0x4a00 ) SnrLookUP = 21 ;
880	else if(SnrRead < 0x4b00 ) SnrLookUP = 20.9 ;
881	else if(SnrRead < 0x4d00 ) SnrLookUP = 20.8 ;
882	else if(SnrRead < 0x4f00 ) SnrLookUP = 20.7 ;
883	else if(SnrRead < 0x5050 ) SnrLookUP = 20.6 ;
884	else if(SnrRead < 0x5200 ) SnrLookUP = 20.5 ;
885	else if(SnrRead < 0x53c0 ) SnrLookUP = 20.4 ;
886	else if(SnrRead < 0x5450 ) SnrLookUP = 20.3 ;
887	else if(SnrRead < 0x5650 ) SnrLookUP = 20.2 ;
888	else if(SnrRead < 0x5820 ) SnrLookUP = 20.1 ;
889	else if(SnrRead < 0x6000 ) SnrLookUP = 20 ;
890	else SnrLookUP = 0;
891	return SnrLookUP;
892	}
893
894	DATA_DOUBLE Qam256SnrLookUpTable(int SnrRead)
895	{
896	DATA_DOUBLE SnrLookUP;
897	if (SnrRead < 0x970 ) SnrLookUP = 40 ;
898	else if(SnrRead < 0xa90 ) SnrLookUP = 39 ;
899	else if(SnrRead < 0xb90 ) SnrLookUP = 38 ;
900	else if(SnrRead < 0xd90 ) SnrLookUP = 37 ;
901	else if(SnrRead < 0xff0 ) SnrLookUP = 36 ;
902	else if(SnrRead < 0x1240) SnrLookUP = 35 ;
903	else if(SnrRead < 0x1345) SnrLookUP = 34.8 ;
904	else if(SnrRead < 0x13c0) SnrLookUP = 34.6 ;
905	else if(SnrRead < 0x14c0) SnrLookUP = 34.4 ;
906	else if(SnrRead < 0x1500) SnrLookUP = 34.2 ;
907	else if(SnrRead < 0x1610) SnrLookUP = 34 ;
908	else if(SnrRead < 0x1700) SnrLookUP = 33.8 ;
909	else if(SnrRead < 0x1800) SnrLookUP = 33.6 ;
910	else if(SnrRead < 0x18b0) SnrLookUP = 33.4 ;
911	else if(SnrRead < 0x1900) SnrLookUP = 33.2 ;
912	else if(SnrRead < 0x1ab0) SnrLookUP = 33 ;
913	else if(SnrRead < 0x1bc0) SnrLookUP = 32.8 ;
914	else if(SnrRead < 0x1cb0) SnrLookUP = 32.6 ;
915	else if(SnrRead < 0x1db0) SnrLookUP = 32.4 ;
916	else if(SnrRead < 0x1eb0) SnrLookUP = 32.2 ;
917	else if(SnrRead < 0x2030) SnrLookUP = 32 ;
918	else if(SnrRead < 0x2200) SnrLookUP = 31.8 ;
919	else if(SnrRead < 0x2280) SnrLookUP = 31.6 ;
920	else if(SnrRead < 0x2410) SnrLookUP = 31.4 ;
921	else if(SnrRead < 0x25b0) SnrLookUP = 31.2 ;
922	else if(SnrRead < 0x27a0) SnrLookUP = 31 ;
923	else if(SnrRead < 0x2840) SnrLookUP = 30.8 ;
924	else if(SnrRead < 0x29d0) SnrLookUP = 30.6 ;
925	else if(SnrRead < 0x2b10) SnrLookUP = 30.4 ;
926	else if(SnrRead < 0x2d30) SnrLookUP = 30.2 ;
927	else if(SnrRead < 0x2f20) SnrLookUP = 30 ;
928	else if(SnrRead < 0x30c0) SnrLookUP = 29.8 ;
929	else if(SnrRead < 0x3260) SnrLookUP = 29.7 ;
930	else if(SnrRead < 0x32c0) SnrLookUP = 29.6 ;
931	else if(SnrRead < 0x3300) SnrLookUP = 29.5 ;
932	else if(SnrRead < 0x33b0) SnrLookUP = 29.4 ;
933	else if(SnrRead < 0x34b0) SnrLookUP = 29.3 ;
934	else if(SnrRead < 0x35a0) SnrLookUP = 29.2 ;
935	else if(SnrRead < 0x3650) SnrLookUP = 29.1 ;
936	else if(SnrRead < 0x3800) SnrLookUP = 29 ;
937	else if(SnrRead < 0x3900) SnrLookUP = 28.9 ;
938	else if(SnrRead < 0x3a50) SnrLookUP = 28.8 ;
939	else if(SnrRead < 0x3b30) SnrLookUP = 28.7 ;
940	else if(SnrRead < 0x3cb0) SnrLookUP = 28.6 ;
941	else if(SnrRead < 0x3e20) SnrLookUP = 28.5 ;
942	else if(SnrRead < 0x3fa0) SnrLookUP = 28.4 ;
943	else if(SnrRead < 0x40a0) SnrLookUP = 28.3 ;
944	else if(SnrRead < 0x41c0) SnrLookUP = 28.2 ;
945	else if(SnrRead < 0x42f0) SnrLookUP = 28.1 ;
946	else if(SnrRead < 0x44a0) SnrLookUP = 28 ;
947	else if(SnrRead < 0x4600) SnrLookUP = 27.9 ;
948	else if(SnrRead < 0x47b0) SnrLookUP = 27.8 ;
949	else if(SnrRead < 0x4900) SnrLookUP = 27.7 ;
950	else if(SnrRead < 0x4a00) SnrLookUP = 27.6 ;
951	else if(SnrRead < 0x4ba0) SnrLookUP = 27.5 ;
952	else if(SnrRead < 0x4d00) SnrLookUP = 27.4 ;
953	else if(SnrRead < 0x4f00) SnrLookUP = 27.3 ;
954	else if(SnrRead < 0x5000) SnrLookUP = 27.2 ;
955	else if(SnrRead < 0x51f0) SnrLookUP = 27.1 ;
956	else if(SnrRead < 0x53a0) SnrLookUP = 27 ;
957	else if(SnrRead < 0x5520) SnrLookUP = 26.9 ;
958	else if(SnrRead < 0x5700) SnrLookUP = 26.8 ;
959	else if(SnrRead < 0x5800) SnrLookUP = 26.7 ;
960	else if(SnrRead < 0x5a00) SnrLookUP = 26.6 ;
961	else if(SnrRead < 0x5c00) SnrLookUP = 26.5 ;
962	else if(SnrRead < 0x5d00) SnrLookUP = 26.4 ;
963	else if(SnrRead < 0x5f00) SnrLookUP = 26.3 ;
964	else if(SnrRead < 0x6000) SnrLookUP = 26.2 ;
965	else if(SnrRead < 0x6200) SnrLookUP = 26.1 ;
966	else if(SnrRead < 0x6400) SnrLookUP = 26 ;
967	else SnrLookUP = 0;
968	return SnrLookUP;
969	}
970
971	DATA_DOUBLE Sec_1411xQamSnrResultCheck(void)
972	{
973	DATA32 mse;
974	DATA32 qam_mode;
975	DATA_DOUBLE SnrValue=0;
976
977	qam_mode = Sec_1411xGetQAMMode();
978	mse = I2cReadOneRegister(IIC_1411x_TOP_RegId , 0x00f1);
979
980	switch(qam_mode){
981	case 0:
982	SnrValue = Qam64SnrLookUpTable(mse);
983	break;
984	case 1:
985	SnrValue = Qam256SnrLookUpTable(mse);
986	break;
987	}
988
989	return SnrValue;
990	}
991
992	/*******************************************************************************************************************************
993	* S5H1411 Get Auto Frequency OffSet Driver
994	* Conditions:VSB mode
995	* Description:This function get a auto-frequency control offset
996	* Addr: 0x47,0x48
997	*******************************************************************************************************************************/
998	DATA_DOUBLE Sec_1411xAutoFreqOffset(void){
999	DATA32 afc_loop;
1000	DATA_DOUBLE constant;
1001	DATA_DOUBLE result_afc;
1002	DATA32 sign_afc;
1003	afc_loop = ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x47)<<16 ) \| ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x48) );
1004	sign_afc = (unsigned int)afc_loop>>23;
1005	constant = (double)21.52*(double)pow(10,3);
1006
1007	if(sign_afc)
1008	{
1009	result_afc = -((afc_loop^0xffffff)+1)(double)pow(2,-27)constant;
1010	}
1011	else
1012	{
1013	result_afc = (afc_loop)(double)pow(2,-27)constant;
1014	}
1015	return result_afc;
1016	}
1017
1018	/*******************************************************************************************************************************
1019	* S5H1411 Get Carrier Frequency OffSet Driver
1020	* Conditions:VSB mode
1021	* Description:This function get a fine carrier recovery offset.
1022	* Addr: 0x49,0x4a
1023	*******************************************************************************************************************************/
1024	DATA_DOUBLE Sec_1411xCRFreqOffset(void){
1025	DATA32 cr_loop;
1026	DATA_DOUBLE result_cr,constant;
1027	DATA32 sign_cr;
1028	cr_loop =( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x49)<<16 ) \| ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x4a));
1029	sign_cr = (unsigned int)cr_loop>>23;
1030	constant = (double)21.52*(double)pow(10,3);
1031
1032	if(sign_cr)
1033	{
1034	result_cr = -( ( (cr_loop)^0xffffff)+1)(double)pow(2,-27)constant;
1035	}
1036	else
1037	{
1038	result_cr = (cr_loop)(double)pow(2,-27)constant;
1039	}
1040	return result_cr;
1041	}
1042
1043	/*******************************************************************************************************************************
1044	* S5H1411 Get Symbol Timing OffSet Driver
1045	* Conditions:VSB mode
1046	* Description:This function get a timing offset.
1047	* Addr: 0x4b,0x4c
1048	*******************************************************************************************************************************/
1049	DATA_DOUBLE Sec_1411xVSBSTROffset(void){
1050	DATA32 str_loop;
1051	DATA_DOUBLE result_str,constant;
1052	DATA32 sign_str;
1053	str_loop = ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x4b)<<16 ) \| ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x4c));
1054	sign_str = (unsigned int)str_loop>>23;
1055	constant = (double)21.52*(double)pow(10,6)/(double)24.69;
1056
1057	if(sign_str)
1058	{
1059	result_str = -((str_loop^0xffffff)+1)(double)pow(2,-29)constant;
1060	}
1061	else
1062	{
1063	result_str = (str_loop)(double)pow(2,-29)constant;
1064	}
1065	return result_str;
1066	}
1067
1068	/*******************************************************************************************************************************
1069	* S5H1411 Get PTL Frequency OffSet Driver
1070	* Conditions:QAM mode
1071	* Description:This function get a auto-frequency control offset
1072	* Addr: 0x61,0x62
1073	*******************************************************************************************************************************/
1074	DATA_DOUBLE Sec_1411xPTLFreqOffset(void){
1075	DATA32 ptl_offset1,ptl_offset2;
1076	DATA_DOUBLE ptl_KHz;
1077	DATA_DOUBLE sym_rate;
1078	DATA_DOUBLE ad_rate = 24690000.0;
1079	if( Sec_1411xGetQAMMode())
1080	sym_rate = 5360537.0;
1081	else
1082	sym_rate = 5056941.0;
1083
1084	ptl_offset1 = I2cReadOneRegister(IIC_1411x_QAM_RegId,0x61);
1085	ptl_offset2 = I2cReadOneRegister(IIC_1411x_QAM_RegId,0x62);
1086	if(ptl_offset1>>15) ptl_offset1 = -1*((ptl_offset1^0xffff) + 1);
1087	else ptl_offset1 = ptl_offset1;
1088	if(ptl_offset2>>15) ptl_offset2 = -1*((ptl_offset2^0xffff) + 1);
1089	else ptl_offset2 = ptl_offset2;
1090	ptl_KHz = ((double)ptl_offset1sym_rate + (double)ptl_offset2ad_rate)/((double)0x8000)*0.001;
1091	return ptl_KHz;
1092	}
1093
1094	/*******************************************************************************************************************************
1095	* S5H1411 Get Symbol Timing OffSet Driver
1096	* Conditions:QAM mode
1097	* Description:This function get a timing offset.
1098	* Addr: 0x3a
1099	*******************************************************************************************************************************/
1100	DATA_DOUBLE Sec_1411xQAMSTROffset(void){
1101
1102	DATA32 str;
1103	DATA_DOUBLE str_ppm;
1104	DATA_DOUBLE ad_rate = 24690000.0;
1105	DATA_DOUBLE sym_rate;
1106	if( Sec_1411xGetQAMMode())
1107	sym_rate = 5360537.0;
1108	else
1109	sym_rate = 5056941.0;
1110	str = I2cReadOneRegister(IIC_1411x_QAM_RegId,0x3a);
1111	if(str>>15) str = -1*((str^0xffff) + 1);
1112	else str = str;
1113	str_ppm = 2.0sym_rate((double)str/(double)0x80000)/ad_rate*1000000.0;
1114	return str_ppm;
1115	}
1116	/*******************************************************************************************************************************
1117	* S5H1411 VSB playback stream driver
1118	* Conditions: Should be set only in VSB mode
1119	* Description: When the a74 captured stream is playing back continuously, this driver
1120	* improve the performance in VSB mode. This function should be called periodically.
1121	* Addr: 0x65
1122	* Value: [0]:1 --> Calculated SNR from PN sequence.
1123	* Value: [0]:0 --> SNR
1124	*******************************************************************************************************************************/
1125	I2C_STATUS PlayBack_StreamDriver()
1126	{
1127	#define EQ_SNR_THR 500
1128	int Eq_tcm_snr = 0;
1129	int Eq_snr_tr_est = 0;
1130	int Eq_threshold;
1131
1132	Eq_tcm_snr = I2cReadOneRegister(0x32, 0x9e)&0x3ff; //eq_tcm_snr.
1133	Eq_snr_tr_est = I2cReadOneRegister(0x32, 0x9f)&0x3ff; //EQ snr estimation during training sequence
1134
1135	Eq_threshold=Eq_tcm_snr-Eq_snr_tr_est;
1136
1137	if( !Sec_1411xGetMode() ) // VSB mode
1138	{
1139	if( Sec_1411xVsbEqLock()) // EQ lock
1140	{
1141	if(Eq_threshold>EQ_SNR_THR)
1142	{
1143	I2cWriteOneRegister(0x32, 0x65, 0x7d);
1144	return OK;
1145	}
1146	else
1147	{
1148	I2cWriteOneRegister(0x32, 0x65, 0x7c);
1149	return OK;
1150	}
1151	} //if Eq lock
1152	else{
1153	I2cWriteOneRegister(0x32, 0x65, 0x7c);
1154	return OK;
1155	}
1156	} //if VSB
1157	else{
1158	return OK;
1159	}
1160	}
1161
1162
1163	void set_demods(DATA16 chip_addr,DATA16 addr, DATA08 data)
1164	{
1165	I2cWriteOneRegister(chip_addr,addr, data);
1166	DHL_OS_Printf("0x%x = 0x%x\n", addr, data);
1167	}
1168
1169	void get_demods(DATA16 chip_addr,DATA16 addr)
1170	{
1171	DATA16 data;
1172
1173	data = I2cReadOneRegister(chip_addr,addr);
1174
1175	DHL_OS_Printf("0x%x = 0x%x\n", addr, data);
1176	}
1177
1178

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

Context Navigation

source: svn/newcon3bcm2_21bu/dst/dhl/src/devices/S5H1411/S5H1411.c @ 22

Download in other formats: