Context Navigation

S5H1411Core.c

Last change on this file was 2, checked in by jglee, 11 years ago
first commit
File size: 42.1 KB

Line
1	/**
2	SFILE***************************************************************
3	* FILE NAME : S5H1411x.cpp
4	* AUTHOR : SOC Development Division, Channel Team, Channel.cs
5	* MODERATOR :
6	* ISSUED To :
7	* ISSUED Day : May 21,2007
8	* VERSION : 1.0
9	* Init.Version : Init 1.0
10	* FILE DESCRIPTION: S5H1411 VSB/QAM Porting Code
11	* ABBREVIATION : Initialize the S5H1411 porting code
12	* Copyright (c) 2006~2007 Samsung Electronics, Inc.
13	* All rights reserved.
14	*
15	* This software is the confidential and proprietary information
16	* of Samsung Electronics, Inc("Confidential Information"). You
17	* Shall not disclose such Confidential Information and shall use
18	* it only in accordance with the terms of the license agreement
19	* you entered into SAMSUNG.
20	*************************************************************EFILE/
21	#include "S5H1411Core.h"
22	#include "math.h"
23
24	#define USE_LARGE_SYMBOL_DEVIATION 0
25
26
27	/* ************************************************************************ */
28	/* */
29	/* This function should be implemented by customers */
30	/* */
31	/* ************************************************************************ */
32	#if 0
33	DS_BOOL I2cStop(){
34	return OK;
35	}
36	DS_BOOL I2cStart(){
37	return OK;
38	}
39	DS_BOOL ByteOut(UCHAR08 InByte){
40	return OK;
41	}
42	DS_BOOL WritetoTuner(UCHAR08 nb_bytes_to_send, UCHAR08 *bytes_to_send){
43	I2cStart();
44	for (int num=0;num<nb_bytes_to_send;num++)
45	{
46	if(!ByteOut(bytes_to_send[num]))
47	return FAIL;
48	}
49	I2cStop();
50	return OK;
51	}
52	#endif
53	DS_BOOL I2cWriteOneRegister(UCHAR08 Id, DS_U16 Address , DS_U16 Data){
54	unsigned char result = 0;
55	result = S5H_IicWriteOneRegister(Id,Address,Data);
56	if(result)
57	return FAIL;
58	return OK;
59	}
60	DS_U16 I2cReadOneRegister(UCHAR08 Id, DS_U16 Address){
61	return S5H_IicReadOneRegister(Id,Address);
62	}
63
64	/* *************************************************************** */
65	/* */
66	/* CODE PROVIDED BY Channel Team */
67	/* */
68	/* *************************************************************** */
69
70	///////////////// ///////////////// ///////////////////
71	///////////////// SEMCO Tuner Function ////////////////
72	///////////////// ///////////////// ///////////////////
73
74	/**************************************************************************************************************************
75	* RF TUNING FUNCTION
76	* Tuning Formula : calcFreq = ((chFreq + 44) / 50) * 1000;
77	* calcFreq is the LO(local oscillator) setting vaule to convert the RF signal to IF signal.
78	* Regardless of analogue signals and digital signals, the LO setting value is the same. For example,
79	* For DTV Tuning, RF Freq. = 57MHz, IF Center. Freq=44MHz, calcFreq = ((57+44)/50)*1000= 2020.
80	* For NTSC Tuning, RF Freq(Picture Freq.) = 55.25MHz, IF Picture Freq.=45.75MHz,calcFreq=
81	* ((55.25+45.75)/50*1000 = 2020. Accordingly, DTV and analogue channels can be tuned with the
82	* same scheme.
83	**************************************************************************************************************************/
84	#if 0
85	DS_U16 SEMCOxTune(double chFreq)
86	{
87	SDBL32 calcFreq;
88	DS_U16 calcBuff;
89	UCHAR08 tunerData[6];
90	UCHAR08 pChargePumpValue;
91	///////////////////////////////////////////////////////////////////////////////////////////////
92	//// Making Charge Pump Current
93	//// To optimize the phase noise performance, the "pChargePumpValue" needs to be set
94	//// differently according to a channel frequency
95	///////////////////////////////////////////////////////////////////////////////////////////////
96
97	if ((chFreq>36.0) && (chFreq<=170.0))
98	{
99	if ((chFreq>48.0) && (chFreq<=100.0))
100	pChargePumpValue = 2;
101	else if ((chFreq>100.0) && (chFreq<=112.0))
102	pChargePumpValue = 3;
103	else if ((chFreq>112.0) && (chFreq<=132.0))
104	pChargePumpValue = 4;
105	else if ((chFreq>132.0) && (chFreq<=140.0))
106	pChargePumpValue = 5;
107	else if ((chFreq>140.0) && (chFreq<=170.0))
108	pChargePumpValue = 6;
109
110	pChargePumpValue = (pChargePumpValue << 5) \| 0x01;
111	}
112	else if ((chFreq>170.0) && (chFreq<=469.0))
113	{
114	if ((chFreq>169.0) && (chFreq<=180.0))
115	pChargePumpValue = 1;
116	else if ((chFreq>180.0) && (chFreq<=252.0))
117	pChargePumpValue = 2;
118	else if ((chFreq>252.0) && (chFreq<=360.0))
119	pChargePumpValue = 3;
120	else if ((chFreq>360.0) && (chFreq<=404.0))
121	pChargePumpValue = 4;
122	else if ((chFreq>404.0) && (chFreq<=428.0))
123	pChargePumpValue = 5;
124	else if ((chFreq>428.0) && (chFreq<=440.0))
125	pChargePumpValue = 6;
126	else if ((chFreq>440.0) && (chFreq<=469.0))
127	pChargePumpValue = 7;
128
129	pChargePumpValue = (pChargePumpValue << 5) \| 0x02;
130
131	}
132	else if ((chFreq>469.0) && (chFreq<=864.0))
133	{
134	if ((chFreq>469.0) && (chFreq<=560.0))
135	pChargePumpValue = 3;
136	else if ((chFreq>560.0) && (chFreq<=632.0))
137	pChargePumpValue = 4;
138	else if ((chFreq>632.0) && (chFreq<=708.0))
139	pChargePumpValue = 5;
140	else if ((chFreq>708.0) && (chFreq<=824.0))
141	pChargePumpValue = 6;
142	else if ((chFreq>824.0) && (chFreq<=864.0))
143	pChargePumpValue = 7;
144
145	pChargePumpValue = (pChargePumpValue << 5) \| 0x08;
146	}
147	else
148	{
149	pChargePumpValue = 1;
150	}
151
152	////////////////////////////////////////////////////////////////////////////////////////////
153	////// Making chFreq. to Tune //////
154	////////////////////////////////////////////////////////////////////////////////////////////
155	calcFreq = ((chFreq + 44) / 50) * 1000;
156	calcBuff = (unsigned int)calcFreq;
157
158
159	tunerData[0] = 0xc2 ; //Semco Tuner ID
160	tunerData[1] = (calcBuff >> 8) & 0x00FF;
161	tunerData[2] = (calcBuff) & 0x00FF;
162	tunerData[3] = 0xc3;
163	tunerData[4] = pChargePumpValue;
164	if(!S5H1411x_GetMode()) //VSB mode
165	{
166	tunerData[5] = 0x81;
167	}
168	else //QAM mode
169	{
170	tunerData[5] = 0x82;
171	}
172
173	if(WritetoTuner(6,tunerData)) //physical channel tune
174	return OK;
175	else
176	return FAIL;
177	}
178	#endif
179	/*********************************************************************************************************
180	* S5H1411 Initialization Driver
181	* Conditions:
182	* Version:Init 1.0
183	* Description:
184	* This function is called to initialize the register values.
185	* This function must be called once to run the system properly.
186	**********************************************************************************************************/
187	DS_BOOL S5H1411x_Initialize(void)
188	{
189	DS_BOOL result = OK;
190	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00 , 0x0071);
191	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x08 , 0x0047);
192	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x1C , 0x0400);
193	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x1E , 0x0370);
194	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x1F , 0x342c);
195	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x24 , 0x0231);
196	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x25 , 0x1011);
197	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x26 , 0x0f07);
198	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x27 , 0x0F04);
199	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x28 , 0x070f);
200	#if USE_LARGE_SYMBOL_DEVIATION
201	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x29 , 0x2840);
202	#else
203	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x29 , 0x2820);
204	#endif
205	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x2A , 0x102e);
206	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x2B , 0x0220);
207	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x2E , 0x0d0e);
208	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x2F , 0x1013);
209	#if USE_LARGE_SYMBOL_DEVIATION
210	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x31 , 0x151b);
211	#else
212	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x31 , 0x171b);
213	#endif
214	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x32 , 0x0e0f);
215	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x33 , 0x0f10);
216	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x34 , 0x170e);
217	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x35 , 0x4b10);
218	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x36 , 0x0f17);
219	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x3C , 0x1577);
220	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x3D , 0x081A);
221	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x3E , 0x77ee);
222	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x40 , 0x1e09);
223	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x41 , 0x0f0c);
224	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x42 , 0x1f10);
225	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x4D , 0x0509);
226	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x4E , 0x0a00);
227	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x50 , 0x0000);
228	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x5B , 0x0000);
229	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x5C , 0x0008);
230	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x57 , 0x1101);
231	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x65 , 0x007c);
232	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x68 , 0x0512);
233	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x69 , 0x0258);
234	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x70 , 0x0004);
235	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x71 , 0x0007);
236	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x76 , 0x00a9);
237	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x78 , 0x3141);
238	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x7A , 0x3141);
239	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB3 , 0x8003);
240	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB5 , 0xa6bb);
241	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB6 , 0x0609);
242	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB7 , 0x2f06);
243	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB8 , 0x003f);
244	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xB9 , 0x2700);
245	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xBA , 0xfac8);
246	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xBE , 0x1003);
247	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xBF , 0x103F);
248	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xCE , 0x2000);
249	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xCF , 0x0800);
250	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD0 , 0x0800);
251	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD1 , 0x0400);
252	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD2 , 0x0800);
253	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD3 , 0x2000);
254	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xD4 , 0x3000);
255	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xDB , 0x4a9b);
256	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xDC , 0x1000);
257	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xDE , 0x0001);
258	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xDF , 0x0000);
259	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xE3 , 0x0301);
260	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0xF3 , 0x0000);
261	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0xF3 , 0x0001);
262	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x08 , 0x0600);
263	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x18 , 0x4201);
264	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x1E , 0x6476);
265	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x21 , 0x0830);
266	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x0C , 0x5679);
267	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x0D , 0x579b);
268	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x24 , 0x0102);
269	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x31 , 0x7488);
270	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x32 , 0x0a08);
271	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x3D , 0x8689);
272	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x41 , 0x0f98);
273	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x49 , 0x0048);
274	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x57 , 0x2012);
275	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x5D , 0x7676);
276	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x04 , 0x0400);
277	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x58 , 0x00c0);
278	result \|=I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x5B , 0x0100);
279	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xF7 , 0x0000);
280	result \|=I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xF7 , 0x0001);
281
282	return result;
283
284	}
285
286	/*********************************************************************************************************
287	* S5H1411 Soft reset Driver
288	* Conditions: When a channel is changed or LNA is on/off, this function is called.
289	* Description:
290	* This function is called in order to clear the buffers of hardware logic.
291	* But it does not reset register values.
292
293	* Addr: 0xf7
294	* Value: 0x00 -> Chip Reset Start
295	* Value: 0x01 -> Chip Reset End
296	**********************************************************************************************************/
297	DS_BOOL S5H1411x_SoftReset(void)
298	{
299	DS_BOOL result = OK;
300	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf7, 0x0000);
301	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf7, 0x0001);
302	return result;
303	}
304
305	/*********************************************************************************************************
306	* S5H1411 Register Value reset Driver
307	* Conditions: This function is called when the system needs initialization.
308	* Description:
309	* A register value is reset after this fucntion is called.
310	* The system needs to call initialization function to be run properly after this function is called.
311	* Addr: 0xf3
312	* Value:
313	* Following this call, a register value of the 0xfa is changed from '0x01' to '0x00'.
314	* After that the value is back to '0x01' automatically.
315	**********************************************************************************************************/
316	DS_BOOL S5H1411x_RegReset(void)
317	{
318	DS_BOOL result = OK;
319	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf3, 0x0000);
320	return result;
321	}
322
323	/*********************************************************************************************************
324	* S5H1411 Repeater Control Driver
325	* Conditions:
326	* Description:
327	* This function is used to set the bypass mode or normal mode. (Repeater Enable or Disable)
328	* In the bypass mode, the host PC controls a channel chip first and the channel chip controls
329	* a tuner using GPIO.
330	* Addr: 0xf5
331	* Value: 0x00 -> Tuner by pass close (Repeater Disable) - Default mode
332	* Value: 0x01 -> Tuner by pass open (Repeater Enable)
333	**********************************************************************************************************/
334	DS_BOOL S5H1411x_RepeaterEnable(void)
335	{
336	DS_BOOL result = OK;
337	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf5, 0x0001);
338	return result;
339	}
340	DS_BOOL S5H1411x_RepeaterDisable(void)
341	{
342	DS_BOOL result = OK;
343	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf5, 0x0000);
344	return result;
345	}
346
347	/*********************************************************************************************************
348	* S5H1411 VSB, QAM mode change Driver
349	* Conditions:
350	* Description: These functions set an 8-VSB & QAM (64/256) mode
351	* Addr: 0xf6
352	* Value: 0x00 -> VSB mode (Default)
353	* Value: 0x01 -> QAM mode
354	* Addr: 0x7f
355	* Value: 0x1110 -> QAM (Detect 64/256 qam automatically)
356	* Value: 0x1100 -> 64 QAM (Manual mode)
357	* Value: 0x1101 -> 256 QAM (Manual mode)
358	**********************************************************************************************************/
359	DS_BOOL S5H1411x_VsbMode(void)
360	{
361	DS_BOOL result = OK;
362	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00, 0x0071);
363	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf6, 0x0000);
364	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xcd, 0x00f1);
365	result \|= S5H1411x_SoftReset();
366	return result;
367	}
368	DS_BOOL S5H1411x_QamMode(void)
369	{
370	DS_BOOL result = OK;
371	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00, 0x0171);
372	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf6, 0x0001);
373	result \|= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x16, 0x1101);
374	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xcd, 0x00f0);
375	result \|= S5H1411x_SoftReset();
376	return result;
377	}
378
379	DS_BOOL S5H1411x_64QamMode(void)
380	{
381	DS_BOOL result = OK;
382	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00, 0x0171);
383	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf6, 0x0001);
384	result \|= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x16, 0x1100);
385	result \|= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x17, 0x0101);
386	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xcd, 0x00f0);
387	result \|= S5H1411x_SoftReset();
388	return result;
389	}
390	DS_BOOL S5H1411x_256QamMode(void)
391	{
392	DS_BOOL result = OK;
393	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0x00, 0x0171);
394	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf6, 0x0001);
395	result \|= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x16, 0x1100);
396	result \|= I2cWriteOneRegister(IIC_1411x_QAM_RegId, 0x17, 0x0111);
397	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xcd, 0x00f0);
398	result \|= S5H1411x_SoftReset();
399	return result;
400	}
401
402	/*********************************************************************************************************
403	* S5H1411 Get Mode Driver
404	* Conditions:
405	* Description: This function get a mode(VSB/QAM) of S5H1411.
406	* Addr: 0xf6
407	* Value: 0x00 -> VSB mode (Default)
408	* Value: 0x01 -> QAM mode
409	**********************************************************************************************************/
410	DS_U16 S5H1411x_GetMode(void)
411	{
412	DS_U16 mode;
413	mode = I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xf6);
414	return mode;
415
416	}
417
418	/*********************************************************************************************************
419	* S5H1411 Get QAM Mode Driver
420	* Conditions:
421	* Description: This function get a QAM mode(64/256).
422	* Addr: 0xf0
423	* Value: 0x01 -> 256QAM mode
424	* Value: 0x00 -> 64QAM mode
425	**********************************************************************************************************/
426	DS_U16 S5H1411x_Get_QAMMode(void)
427	{
428	DS_U16 qam_mode;
429	qam_mode = I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xf0) & 0x0001;
430	return qam_mode;
431	}
432
433	/****************************************************************************************************
434	* S5H1411 Sleep mode change Driver
435	* Conditions: VSB/QAM mode
436	* Description:
437	* The software-based power down function is as follows.
438	* This function is called in order to set a sleep on mode or sleep off mode.
439
440	* Addr: 0xf4
441	* Value: 0x01 -> Sleep mode
442	* Value: 0x00 -> Running mode - Default mode
443	****************************************************************************************************/
444	DS_BOOL S5H1411x_SleepOn(void)
445	{
446	DS_BOOL result = OK;
447	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf4,0x01);
448	return result;
449	}
450	DS_BOOL S5H1411x_SleepOff(void)
451	{
452	DS_BOOL result = OK;
453	result \|= I2cWriteOneRegister(IIC_1411x_TOP_RegId, 0xf4,0x00);
454	result \|= S5H1411x_SoftReset();
455	return result;
456	}
457	/****************************************************************************************************
458	* S5H1411 VSB Sync Lock Check Driver
459	* Conditions: VSB mode
460	* Description: This function is used to check whether the sync detector is lock or not in VSB mode.
461	* Addr: 0x5e
462	* Value: [0] bit -> 1:Lock , 0: Unlock
463
464	****************************************************************************************************/
465	DS_U16 S5H1411x_Vsb_Sync_Lock(void)
466	{
467	DS_U16 sync_lock;
468	sync_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0x5e)) & 0x0001;
469	return sync_lock;
470	}
471
472	/****************************************************************************************************
473	* S5H1411 VSB Equalizer Lock Check Driver
474	* Conditions: VSB mode
475	* Description: This function is used to check whether the equalizer is lock or not in VSB mode.
476	* Addr: 0xf2
477	* Value: [13] bit -> 1:Lock , 0: Unlock
478
479	****************************************************************************************************/
480	DS_U16 S5H1411x_Vsb_Eq_Lock(void)
481	{
482	DS_U16 eq_lock;
483	eq_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf2) >> 13) & 0x0001;
484	return eq_lock;
485	}
486
487	/****************************************************************************************************
488	* S5H1411 VSB Fec Lock Check Driver
489	* Conditions: VSB mode
490	* Description: This function is used to check whether the FEC is lock or not in VSB mode.
491	* Addr: 0xf2
492	* Value: [12] bit -> 1:Lock , 0: Unlock
493
494	****************************************************************************************************/
495	DS_U16 S5H1411x_Vsb_Fec_Lock(void)
496	{
497	DS_U16 fec_lock;
498	fec_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf2) >> 12) & 0x0001;
499	return fec_lock;
500	}
501
502	/****************************************************************************************************
503	* S5H1411 QAM Fec Lock Check Driver
504	* Conditions: QAM mode
505	* Description: This function is used to check whether the FEC is lock or not in QAM mode.
506	* Addr: 0xf0
507	* Value: [4] bit -> 1:Lock , 0: Unlock
508
509	****************************************************************************************************/
510	DS_U16 S5H1411x_QAM_Fec_Lock(void)
511	{
512	DS_U16 fec_lock;
513	fec_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf0) >> 4) & 0x0001;
514	return fec_lock;
515	}
516
517	/****************************************************************************************************
518	* S5H1411 QAM Equalizer Lock Check Driver
519	* Conditions: QAM mode
520	* Description: This function is used to check whether the FEC is lock or not in QAM mode.
521	* Addr: 0xf0
522	* Value: [8] bit -> 1:Lock , 0: Unlock
523
524	****************************************************************************************************/
525	DS_U16 S5H1411x_QAM_Eq_Lock(void)
526	{
527	DS_U16 eq_lock;
528	eq_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf0) >> 8) & 0x0001;
529	return eq_lock;
530	}
531
532	/****************************************************************************************************
533	* S5H1411 VSB/QAM Master Lock Check Driver
534	* Conditions: VSB/QAM mode
535	* Description: This function is used to check whether the channel chip is lock or not in VSB/QAM mode.
536	* Addr: 0xf2
537	* Value: 15bit -> 1:Lock , 0: Unlock
538
539	****************************************************************************************************/
540	DS_U16 S5H1411x_Vsb_QAM_Master_Lock(void)
541	{
542	DS_U16 master_lock;
543	master_lock = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf2)>>15) & 0x0001; //0x1 --> Master lock, 0x0 --> Master Unlock
544	return master_lock;
545	}
546
547	/**************************************************************************
548	* S5H1411 VSB SNR value(Signal Quality) Check Driver
549	* Conditions:
550	* Description :
551	* This function lets the user's application software read a value
552	* that is related to the SNR through the SNR Look Up Table in VSB mode.
553	* Addr : 0xf2
554	* Value: [9:0]
555	**************************************************************************/
556	SDBL32 VSBSnrLookUpTable(int mse)
557	{
558	SDBL32 SnrLookUP;
559	if(mse > 0x3a9 ) SnrLookUP = 30 ;
560	else if(mse > 0x3a7) SnrLookUP = 29.5 ;
561	else if(mse > 0x3a5) SnrLookUP = 29 ;
562	else if(mse > 0x3a2) SnrLookUP = 28.5 ;
563	else if(mse > 0x3a1) SnrLookUP = 28.0 ;
564	else if(mse > 0x39d) SnrLookUP = 27.5 ;
565	else if(mse > 0x399) SnrLookUP = 27.0 ;
566	else if(mse > 0x394) SnrLookUP = 26.5 ;
567	else if(mse > 0x391) SnrLookUP = 26.0 ;
568	else if(mse > 0x38d) SnrLookUP = 25.5 ;
569	else if(mse > 0x38a) SnrLookUP = 25.0 ;
570	else if(mse > 0x385) SnrLookUP = 24.5 ;
571	else if(mse > 0x37f) SnrLookUP = 24.0 ;
572	else if(mse > 0x379) SnrLookUP = 23.5 ;
573	else if(mse > 0x373) SnrLookUP = 23.0 ;
574	else if(mse > 0x36a) SnrLookUP = 22.5 ;
575	else if(mse > 0x364) SnrLookUP = 22.0 ;
576	else if(mse > 0x35c) SnrLookUP = 21.5 ;
577	else if(mse > 0x354) SnrLookUP = 21.0 ;
578	else if(mse > 0x34d) SnrLookUP = 20.5 ;
579	else if(mse > 0x343) SnrLookUP = 20.0 ;
580	else if(mse > 0x33a) SnrLookUP = 19.5 ;
581	else if(mse > 0x330) SnrLookUP = 19.0 ;
582	else if(mse > 0x324) SnrLookUP = 18.5 ;
583	else if(mse > 0x318) SnrLookUP = 18.0 ;
584	else if(mse > 0x30a) SnrLookUP = 17.5 ;
585	else if(mse > 0x2ff) SnrLookUP = 17.0 ;
586	else if(mse > 0x2ef) SnrLookUP = 16.5 ;
587	else if(mse > 0x2e4 )SnrLookUP = 16.0 ;
588	else if(mse > 0x2d0 )SnrLookUP = 15.5 ;
589	else if(mse > 0x2c1 )SnrLookUP = 15.0 ;
590	else if(mse > 0x2b0 )SnrLookUP = 14.5 ;
591	else if(mse > 0x2a0 )SnrLookUP = 14.0 ;
592	else if(mse > 0x28c )SnrLookUP = 13.5 ;
593	else if(mse > 0x279 )SnrLookUP = 13.0 ;
594	else if(mse > 0x267 )SnrLookUP = 12.5 ;
595	else if(mse > 0x23f )SnrLookUP = 12.0 ;
596	else SnrLookUP = 0 ;
597
598	return SnrLookUP;
599
600	}
601	SDBL32 S5H1411x_VsbSnrResultCheck(void)
602	{
603	DS_U16 mse;
604	SDBL32 SnrValue;
605	mse = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0xf2)) & 0x3ff;
606	SnrValue = VSBSnrLookUpTable(mse);
607	return SnrValue;
608	}
609
610	DS_U16 S5H1411x_VsbAGCResultCheck(void)
611	{
612	DS_U16 mse;
613	mse = (I2cReadOneRegister(IIC_1411x_TOP_RegId,0x21));
614	return mse;
615	}
616
617	DS_U16 S5H1411x_QamAGCResultCheck(void)
618	{
619	DS_U16 mse;
620	mse = (I2cReadOneRegister(IIC_1411x_QAM_RegId,0x14));
621	return mse;
622	}
623
624	/*********************************************************************************************************
625	* S5H1411 QAM SNR value(Signal Quality) Check Driver
626	* Conditions:
627	* Description
628	* This function lets the user's application software read a value that is related to the SNR through
629	* the SNR Look Up Table in QAM mode.
630
631	* Addr : 0xf1
632	* Value: [15:0]
633	**********************************************************************************************************/
634	SDBL32 Qam64SnrLookUpTable(int mse)
635	{
636	SDBL32 SnrLookUP;
637	if (mse < 0x7b0 ) SnrLookUP = 30 ;
638	else if(mse < 0x950 ) SnrLookUP = 29 ;
639	else if(mse < 0xb90 ) SnrLookUP = 28 ;
640	else if(mse < 0xe40 ) SnrLookUP = 27 ;
641	else if(mse < 0xf30 ) SnrLookUP = 26.8 ;
642	else if(mse < 0xfd0 ) SnrLookUP = 26.6 ;
643	else if(mse < 0x1060 ) SnrLookUP = 26.4 ;
644	else if(mse < 0x10c0 ) SnrLookUP = 26.2 ;
645	else if(mse < 0x11a0 ) SnrLookUP = 26 ;
646	else if(mse < 0x12c0 ) SnrLookUP = 25.8 ;
647	else if(mse < 0x13c0 ) SnrLookUP = 25.6 ;
648	else if(mse < 0x1440 ) SnrLookUP = 25.4 ;
649	else if(mse < 0x1510 ) SnrLookUP = 25.2 ;
650	else if(mse < 0x1640 ) SnrLookUP = 25 ;
651	else if(mse < 0x1700 ) SnrLookUP = 24.9 ;
652	else if(mse < 0x1780 ) SnrLookUP = 24.8 ;
653	else if(mse < 0x17c0 ) SnrLookUP = 24.7 ;
654	else if(mse < 0x1810 ) SnrLookUP = 24.6 ;
655	else if(mse < 0x1880 ) SnrLookUP = 24.5 ;
656	else if(mse < 0x1900 ) SnrLookUP = 24.4 ;
657	else if(mse < 0x19c0 ) SnrLookUP = 24.3 ;
658	else if(mse < 0x1a80 ) SnrLookUP = 24.2 ;
659	else if(mse < 0x1b10 ) SnrLookUP = 24.1 ;
660	else if(mse < 0x1bb0 ) SnrLookUP = 24 ;
661	else if(mse < 0x1cc0 ) SnrLookUP = 23.9 ;
662	else if(mse < 0x1d40 ) SnrLookUP = 23.8 ;
663	else if(mse < 0x1dff ) SnrLookUP = 23.7 ;
664	else if(mse < 0x1eff ) SnrLookUP = 23.6 ;
665	else if(mse < 0x1f40 ) SnrLookUP = 23.5 ;
666	else if(mse < 0x1fff ) SnrLookUP = 23.4 ;
667	else if(mse < 0x20b0 ) SnrLookUP = 23.3 ;
668	else if(mse < 0x2150 ) SnrLookUP = 23.2 ;
669	else if(mse < 0x2190 ) SnrLookUP = 23.1 ;
670	else if(mse < 0x2200 ) SnrLookUP = 23 ;
671	else if(mse < 0x2380 ) SnrLookUP = 22.9 ;
672	else if(mse < 0x2490 ) SnrLookUP = 22.8 ;
673	else if(mse < 0x2500 ) SnrLookUP = 22.7 ;
674	else if(mse < 0x2600 ) SnrLookUP = 22.6 ;
675	else if(mse < 0x26ff ) SnrLookUP = 22.5 ;
676	else if(mse < 0x2770 ) SnrLookUP = 22.4 ;
677	else if(mse < 0x2820 ) SnrLookUP = 22.3 ;
678	else if(mse < 0x2910 ) SnrLookUP = 22.2 ;
679	else if(mse < 0x2a00 ) SnrLookUP = 22.1 ;
680	else if(mse < 0x2b10 ) SnrLookUP = 22 ;
681	else if(mse < 0x2cb0 ) SnrLookUP = 21.9 ;
682	else if(mse < 0x2d80 ) SnrLookUP = 21.8 ;
683	else if(mse < 0x2ea0 ) SnrLookUP = 21.7 ;
684	else if(mse < 0x2fa0 ) SnrLookUP = 21.6 ;
685	else if(mse < 0x3020 ) SnrLookUP = 21.5 ;
686	else if(mse < 0x3100 ) SnrLookUP = 21.4 ;
687	else if(mse < 0x31d0 ) SnrLookUP = 21.3 ;
688	else if(mse < 0x32ff ) SnrLookUP = 21.2 ;
689	else if(mse < 0x3400 ) SnrLookUP = 21.1 ;
690	else if(mse < 0x35c0 ) SnrLookUP = 21 ;
691	else if(mse < 0x3720 ) SnrLookUP = 20.9 ;
692	else if(mse < 0x3840 ) SnrLookUP = 20.8 ;
693	else if(mse < 0x3940 ) SnrLookUP = 20.7 ;
694	else if(mse < 0x39ff ) SnrLookUP = 20.6 ;
695	else if(mse < 0x3b00 ) SnrLookUP = 20.5 ;
696	else if(mse < 0x3c70 ) SnrLookUP = 20.4 ;
697	else if(mse < 0x3e00 ) SnrLookUP = 20.3 ;
698	else if(mse < 0x3f70 ) SnrLookUP = 20.2 ;
699	else if(mse < 0x4100 ) SnrLookUP = 20.1 ;
700	else if(mse < 0x42b0 ) SnrLookUP = 20 ;
701	else if(mse < 0x42ff ) SnrLookUP = 19.9 ;
702	else if(mse < 0x4330 ) SnrLookUP = 19.8 ;
703	else if(mse < 0x45a0 ) SnrLookUP = 19.7 ;
704	else if(mse < 0x4700 ) SnrLookUP = 19.6 ;
705	else if(mse < 0x4810 ) SnrLookUP = 19.5 ;
706	else if(mse < 0x49a0 ) SnrLookUP = 19.4 ;
707	else if(mse < 0x4b60 ) SnrLookUP = 19.3 ;
708	else if(mse < 0x4d20 ) SnrLookUP = 19.2 ;
709	else if(mse < 0x4e70 ) SnrLookUP = 19.1 ;
710	else if(mse < 0x4f50 ) SnrLookUP = 19 ;
711	else if(mse < 0x5200 ) SnrLookUP = 18.9 ;
712	else if(mse < 0x53ff ) SnrLookUP = 18.8 ;
713	else if(mse < 0x5500 ) SnrLookUP = 18.7 ;
714	else if(mse < 0x5700 ) SnrLookUP = 18.6 ;
715	else if(mse < 0x58d0 ) SnrLookUP = 18.5 ;
716	else if(mse < 0x5ac0 ) SnrLookUP = 18.4 ;
717	else if(mse < 0x5cff ) SnrLookUP = 18.3 ;
718	else if(mse < 0x5ed0 ) SnrLookUP = 18.2 ;
719	else if(mse < 0x60c0 ) SnrLookUP = 18.1 ;
720	else if(mse < 0x6300 ) SnrLookUP = 18 ;
721	else SnrLookUP = 0;
722	return SnrLookUP;
723
724	}
725
726	SDBL32 Qam256SnrLookUpTable(int mse)
727	{
728	SDBL32 SnrLookUP;
729	if (mse < 0x940) SnrLookUP = 40 ;
730	else if(mse < 0xa20) SnrLookUP = 39 ;
731	else if(mse < 0xb00) SnrLookUP = 38 ;
732	else if(mse < 0xc50) SnrLookUP = 37 ;
733	else if(mse < 0xdd0) SnrLookUP = 36 ;
734	else if(mse < 0xf55) SnrLookUP = 35 ;
735	else if(mse < 0xff0) SnrLookUP = 34.8 ;
736	else if(mse < 0x1010) SnrLookUP = 34.6 ;
737	else if(mse < 0x10a0) SnrLookUP = 34.4 ;
738	else if(mse < 0x1100) SnrLookUP = 34.2 ;
739	else if(mse < 0x1150) SnrLookUP = 34 ;
740	else if(mse < 0x11ff) SnrLookUP = 33.8 ;
741	else if(mse < 0x1290) SnrLookUP = 33.6 ;
742	else if(mse < 0x12ff) SnrLookUP = 33.4 ;
743	else if(mse < 0x13b0) SnrLookUP = 33.2 ;
744	else if(mse < 0x1440) SnrLookUP = 33 ;
745	else if(mse < 0x14f0) SnrLookUP = 32.8 ;
746	else if(mse < 0x1520) SnrLookUP = 32.6 ;
747	else if(mse < 0x15ff) SnrLookUP = 32.4 ;
748	else if(mse < 0x1720) SnrLookUP = 32.2 ;
749	else if(mse < 0x17ff) SnrLookUP = 32 ;
750	else if(mse < 0x18b0) SnrLookUP = 31.8 ;
751	else if(mse < 0x1910) SnrLookUP = 31.6 ;
752	else if(mse < 0x1a10) SnrLookUP = 31.4 ;
753	else if(mse < 0x1b20) SnrLookUP = 31.2 ;
754	else if(mse < 0x1c20) SnrLookUP = 31 ;
755	else if(mse < 0x1d10) SnrLookUP = 30.8 ;
756	else if(mse < 0x1f00) SnrLookUP = 30.6 ;
757	else if(mse < 0x2000) SnrLookUP = 30.4 ;
758	else if(mse < 0x2100) SnrLookUP = 30.2 ;
759	else if(mse < 0x21f5) SnrLookUP = 30 ;
760	else if(mse < 0x23a0) SnrLookUP = 29.8 ;
761	else if(mse < 0x2410) SnrLookUP = 29.7 ;
762	else if(mse < 0x24f0) SnrLookUP = 29.6 ;
763	else if(mse < 0x25a0) SnrLookUP = 29.5 ;
764	else if(mse < 0x2600) SnrLookUP = 29.4 ;
765	else if(mse < 0x2650) SnrLookUP = 29.3 ;
766	else if(mse < 0x27a0) SnrLookUP = 29.2 ;
767	else if(mse < 0x2810) SnrLookUP = 29.1 ;
768	else if(mse < 0x2900) SnrLookUP = 29 ;
769	else if(mse < 0x29a0) SnrLookUP = 28.9 ;
770	else if(mse < 0x2a30) SnrLookUP = 28.8 ;
771	else if(mse < 0x2ba0) SnrLookUP = 28.7 ;
772	else if(mse < 0x2c90) SnrLookUP = 28.6 ;
773	else if(mse < 0x2d30) SnrLookUP = 28.5 ;
774	else if(mse < 0x2d90) SnrLookUP = 28.4 ;
775	else if(mse < 0x2e00) SnrLookUP = 28.3 ;
776	else if(mse < 0x3000) SnrLookUP = 28.2 ;
777	else if(mse < 0x3100) SnrLookUP = 28.1 ;
778	else if(mse < 0x3200) SnrLookUP = 28 ;
779	else if(mse < 0x3300) SnrLookUP = 27.9 ;
780	else if(mse < 0x3400) SnrLookUP = 27.8 ;
781	else if(mse < 0x3500) SnrLookUP = 27.7 ;
782	else if(mse < 0x35a0) SnrLookUP = 27.6 ;
783	else if(mse < 0x3630) SnrLookUP = 27.5 ;
784	else if(mse < 0x37c0) SnrLookUP = 27.4 ;
785	else if(mse < 0x3820) SnrLookUP = 27.3 ;
786	else if(mse < 0x3a90) SnrLookUP = 27.2 ;
787	else if(mse < 0x3ba0) SnrLookUP = 27.1 ;
788	else if(mse < 0x3d00) SnrLookUP = 27 ;
789	else if(mse < 0x3fb0) SnrLookUP = 26.9 ;
790	else if(mse < 0x3fa0) SnrLookUP = 26.8 ;
791	else if(mse < 0x4030) SnrLookUP = 26.7 ;
792	else if(mse < 0x41f0) SnrLookUP = 26.6 ;
793	else if(mse < 0x4310) SnrLookUP = 26.5 ;
794	else if(mse < 0x43ff) SnrLookUP = 26.4 ;
795	else if(mse < 0x44a0) SnrLookUP = 26.3 ;
796	else if(mse < 0x47d0) SnrLookUP = 26.2 ;
797	else if(mse < 0x4930) SnrLookUP = 26.1 ;
798	else if(mse < 0x4a50) SnrLookUP = 26 ;
799	else if(mse < 0x4bc0) SnrLookUP = 25.9 ;
800	else if(mse < 0x4da0) SnrLookUP = 25.8 ;
801	else if(mse < 0x4eff) SnrLookUP = 25.7 ;
802	else if(mse < 0x4f00) SnrLookUP = 25.6 ;
803	else if(mse < 0x5050) SnrLookUP = 25.5 ;
804	else if(mse < 0x51c0) SnrLookUP = 25.4 ;
805	else if(mse < 0x53b0) SnrLookUP = 25.3 ;
806	else if(mse < 0x56ff) SnrLookUP = 25.2 ;
807	else if(mse < 0x57ff) SnrLookUP = 25.1 ;
808	else if(mse < 0x59ff) SnrLookUP = 25 ;
809	else if(mse < 0x5bff) SnrLookUP = 24.9 ;
810	else if(mse < 0x5d00) SnrLookUP = 24.8 ;
811	else if(mse < 0x5da0) SnrLookUP = 24.7 ;
812	else if(mse < 0x5f10) SnrLookUP = 24.6 ;
813	else if(mse < 0x6010) SnrLookUP = 24.5 ;
814	else if(mse < 0x6200) SnrLookUP = 24.4 ;
815	else if(mse < 0x63a0) SnrLookUP = 24.3 ;
816	else if(mse < 0x6610) SnrLookUP = 24.2 ;
817	else if(mse < 0x67f0) SnrLookUP = 24.1 ;
818	else if(mse < 0x69d0) SnrLookUP = 24 ;
819	else SnrLookUP = 0;
820
821	return SnrLookUP;
822	}
823
824	SDBL32 S5H1411x_QamSnrResultCheck(void)
825	{
826	DS_U16 mse;
827	UCHAR08 qam_mode;
828	SDBL32 SnrValue=0;
829
830	qam_mode = S5H1411x_Get_QAMMode();
831	mse = I2cReadOneRegister(IIC_1411x_TOP_RegId , 0x00f1);
832
833	switch(qam_mode){
834	case 0:
835	SnrValue = Qam64SnrLookUpTable(mse);
836	break;
837	case 1:
838	SnrValue = Qam256SnrLookUpTable(mse);
839	break;
840	}
841
842	return SnrValue;
843	}
844
845	/*********************************************************************************************************
846	* S5H1411 VSB Pre BER Count Check Driver
847	* Conditions:
848	* Description:
849	* Error count value before TCM decoder
850	* This function is used to check pre BER count.
851	* Addr: 0xca
852	* Value: [15:0]
853	**********************************************************************************************************/
854	SDBL32 S5H1411x_PreBer(void)
855	{
856	SDBL32 pre_ber;
857	pre_ber = (I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xca)) / 65534;
858	return pre_ber;
859
860	}
861
862	/*********************************************************************************************************
863	* S5H1411 VSB Post BER Count Check Driver
864	* Conditions:
865	* Description:
866	* Error count value after TCM decoder
867	* This function is used to check post BER count.
868	* Addr: 0xcb
869	* Value: [15:0]
870	**********************************************************************************************************/
871	SDBL32 S5H1411x_PostBer(void)
872	{
873	SDBL32 post_ber;
874	post_ber = (I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xcb)) / 65536;
875	return post_ber;
876
877	}
878
879	/*********************************************************************************************************
880	* S5H1411 VSB Packet Error Check Driver
881	* Conditions:
882	* Description:
883	* Error count value after RS decoder
884	* This function is used to count the packet error.
885	* Addr: 0xc9
886	* Value: [15:0]
887	**********************************************************************************************************/
888	DS_U16 S5H1411x_UncorrectableError(void)
889	{
890	DS_U16 unc_err;
891	unc_err = I2cReadOneRegister(IIC_1411x_TOP_RegId, 0xc9);
892	return unc_err;
893	}
894
895	/*******************************************************************************************************************************
896	* S5H1411 TS Mode Set
897	* Conditions:
898	* Description:Through changing this register,it can control the MPEG data mode as parall or serial mode
899	* Addr: 0xbd
900	* Value: [8]:1 - MPEG data are sent out as a byte.
901	* Value: [8]:0 - MPEG data are sent out bit by bit serially.
902	*******************************************************************************************************************************/
903
904	DS_BOOL S5H1411x_TS_SerialMode()
905	{
906	DS_BOOL result;
907
908	result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbd,0x1101);
909
910	return result;
911	}
912
913	DS_BOOL S5H1411x_TS_ParallelMode()
914	{
915	DS_BOOL result;
916
917	result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbd,0x1001);
918
919	return result;
920	}
921
922	/*******************************************************************************************************************************
923	* S5H1411 MPEG Output Timing Mode Set
924	* Conditions:
925	* Description:Through changing this register,it can control the MPEG timing mode.Refer to the datasheet document.
926	* Addr: 0xbe
927	* Value: [13:12]:00 - continous and inverting clk.
928	* Value: [13:12]:01 - continous and non-inverting clk.
929	* Value: [13:12]:10 - non-continous and inverting clk.
930	* Value: [13:12]:11 - non-continous and non-inverting clk.
931	*******************************************************************************************************************************/
932	DS_BOOL S5H1411x_Cont_Invert_Set()
933	{
934	DS_BOOL result;
935
936	result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbe,0x0003);
937
938	return result;
939	}
940
941	DS_BOOL S5H1411x_Cont_Non_Invert_Set()
942	{
943	DS_BOOL result;
944
945	result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbe,0x1003);
946
947	return result;
948	}
949	DS_BOOL S5H1411x_Non_Cont_Invert_Set()
950	{
951	DS_BOOL result;
952
953	result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbe,0x2003);
954
955	return result;
956	}
957
958	DS_BOOL S5H1411x_Non_Cont_Non_Invert_Set()
959	{
960	DS_BOOL result;
961
962	result = I2cWriteOneRegister(IIC_1411x_TOP_RegId,0xbe,0x3003);
963
964	return result;
965	}
966
967	/*******************************************************************************************************************************
968	* S5H1411 Get Auto Frequency OffSet Driver
969	* Conditions:VSB mode
970	* Description:This function get a auto-frequency control offset
971	* Addr: 0x47,0x48
972	*******************************************************************************************************************************/
973	SDBL32 S5H1411x_Auto_Freq_Offset(void){
974	DS_U16 afc_loop;
975	SDBL32 constant;
976	SDBL32 result_afc;
977	DS_U16 sign_afc;
978	afc_loop = ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x47)<<16 ) \| ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x48) );
979	sign_afc = (unsigned int)afc_loop>>23;
980	constant = (double)21.52*(double)pow(10,3);
981
982	if(sign_afc)
983	{
984	result_afc = -((afc_loop^0xffffff)+1)(double)pow(2,-27)constant;
985	}
986	else
987	{
988	result_afc = (afc_loop)(double)pow(2,-27)constant;
989	}
990	return result_afc;
991	}
992
993	/*******************************************************************************************************************************
994	* S5H1411 Get Carrier Frequency OffSet Driver
995	* Conditions:VSB mode
996	* Description:This function get a fine carrier recovery offset.
997	* Addr: 0x49,0x4a
998	*******************************************************************************************************************************/
999	SDBL32 S5H1411x_CR_Freq_Offset(void){
1000	DS_U16 cr_loop;
1001	SDBL32 result_cr,constant;
1002	DS_U16 sign_cr;
1003	cr_loop =( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x49)<<16 ) \| ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x4a));
1004	sign_cr = (unsigned int)cr_loop>>23;
1005	constant = (double)21.52*(double)pow(10,3);
1006
1007	if(sign_cr)
1008	{
1009	result_cr = -( ( (cr_loop)^0xffffff)+1)(double)pow(2,-27)constant;
1010	}
1011	else
1012	{
1013	result_cr = (cr_loop)(double)pow(2,-27)constant;
1014	}
1015	return result_cr;
1016	}
1017
1018	/*******************************************************************************************************************************
1019	* S5H1411 Get Symbol Timing OffSet Driver
1020	* Conditions:VSB mode
1021	* Description:This function get a timing offset.
1022	* Addr: 0x4b,0x4c
1023	*******************************************************************************************************************************/
1024	SDBL32 S5H1411x_VSB_STR_Offset(void){
1025	DS_U16 str_loop;
1026	SDBL32 result_str,constant;
1027	DS_U16 sign_str;
1028	str_loop = ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x4b)<<16 ) \| ( I2cReadOneRegister(IIC_1411x_TOP_RegId,0x4c));
1029	sign_str = (unsigned int)str_loop>>23;
1030	constant = (double)21.52*(double)pow(10,6)/(double)24.69;
1031
1032	if(sign_str)
1033	{
1034	result_str = -((str_loop^0xffffff)+1)(double)pow(2,-29)constant;
1035	}
1036	else
1037	{
1038	result_str = (str_loop)(double)pow(2,-29)constant;
1039	}
1040	return result_str;
1041	}
1042
1043	/*******************************************************************************************************************************
1044	* S5H1411 Get PTL Frequency OffSet Driver
1045	* Conditions:QAM mode
1046	* Description:This function get a auto-frequency control offset
1047	* Addr: 0x61,0x62
1048	*******************************************************************************************************************************/
1049	SDBL32 S5H1411x_PTL_Freq_Offset(void){
1050	DS_U16 ptl_offset1,ptl_offset2;
1051	SDBL32 ptl_KHz;
1052	SDBL32 sym_rate;
1053	SDBL32 ad_rate = 24690000.0;
1054	if( S5H1411x_Get_QAMMode())
1055	sym_rate = 5360537.0;
1056	else
1057	sym_rate = 5056941.0;
1058
1059	ptl_offset1 = I2cReadOneRegister(IIC_1411x_QAM_RegId,0x61);
1060	ptl_offset2 = I2cReadOneRegister(IIC_1411x_QAM_RegId,0x62);
1061	if(ptl_offset1>>15) ptl_offset1 = -1*((ptl_offset1^0xffff) + 1);
1062	else ptl_offset1 = ptl_offset1;
1063	if(ptl_offset2>>15) ptl_offset2 = -1*((ptl_offset2^0xffff) + 1);
1064	else ptl_offset2 = ptl_offset2;
1065	ptl_KHz = ((double)ptl_offset1sym_rate + (double)ptl_offset2ad_rate)/((double)0x8000)*0.001;
1066	return ptl_KHz;
1067	}
1068
1069	/*******************************************************************************************************************************
1070	* S5H1411 Get Symbol Timing OffSet Driver
1071	* Conditions:QAM mode
1072	* Description:This function get a timing offset.
1073	* Addr: 0x3a
1074	*******************************************************************************************************************************/
1075	SDBL32 S5H1411x_QAM_STR_Offset(void){
1076
1077	DS_U16 str;
1078	SDBL32 str_ppm;
1079	SDBL32 ad_rate = 24690000.0;
1080	SDBL32 sym_rate;
1081	if( S5H1411x_Get_QAMMode())
1082	sym_rate = 5360537.0;
1083	else
1084	sym_rate = 5056941.0;
1085	str = I2cReadOneRegister(IIC_1411x_QAM_RegId,0x3a);
1086	if(str>>15) str = -1*((str^0xffff) + 1);
1087	else str = str;
1088	str_ppm = 2.0sym_rate((double)str/(double)0x80000)/ad_rate*1000000.0;
1089	return str_ppm;
1090	}
1091	void get_sdm(DS_U8 field,DS_U8 addr)
1092	{
1093	DS_U16 value;
1094
1095	value = I2cReadOneRegister(IIC_1411x_TOP_RegId, addr);
1096	printf("[S5H1411 Reg: 0x%02X] << Value=0x%04X\n", addr, value);
1097	}
1098
1099	void set_sdm(DS_U8 field, DS_U8 addr, DS_U16 value)
1100	{
1101	DS_U16 regValue;
1102
1103	printf("B4 [S5H1411 Reg: 0x%02X] >> Value=0x%04X\n", addr, value);
1104	I2cWriteOneRegister(IIC_1411x_TOP_RegId, addr, value);
1105	regValue = I2cReadOneRegister(IIC_1411x_TOP_RegId, addr);
1106	printf("A4 [S5H1411 Reg: 0x%02X] >> Value=0x%04X\n", addr, regValue);
1107	}
1108
1109	void TunerSet(unsigned char Db1,unsigned char Db2,unsigned char Cb1,unsigned char Bb,unsigned char Cb2_Speed,unsigned char Cb2_Normal,unsigned char t)
1110	{
1111	extern unsigned int U7A26_SendControlData(unsigned char Db1,unsigned char Db2,unsigned char Cb1,unsigned char Bb,unsigned char Cb2_Speed,unsigned char Cb2_Normal,int bNtsc);
1112	U7A26_SendControlData(Db1,Db2,Cb1,Bb,Cb2_Speed,Cb2_Normal,t);
1113	}

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

Context Navigation

source: svn/trunk/zas_dstar/devices/Tuner/S5H1411/S5H1411Core.c

Download in other formats: