Context Navigation

tmbslTDA182I4.c

Last change on this file was 76, checked in by megakiss, 10 years ago
1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
Property svn:executable set to ``*
File size: 181.9 KB

Line
1	/*
2	Copyright (C) 2010 NXP B.V., All Rights Reserved.
3	This source code and any compilation or derivative thereof is the proprietary
4	information of NXP B.V. and is confidential in nature. Under no circumstances
5	is this software to be exposed to or placed under an Open Source License of
6	any type without the expressed written permission of NXP B.V.
7	*
8	* \file tmbslTDA182I4.c
9	*
10	* %version: CFR_FEAP#39 %
11	*
12	* \date %modify_time%
13	*
14	* \author David LEGENDRE
15	* Michael VANNIER
16	*
17	* \brief Describe briefly the purpose of this file.
18	*
19	* REFERENCE DOCUMENTS :
20	* TDA182I4_Driver_User_Guide.pdf
21	*
22	* TVFE SW Arch V4 Template: Author Christophe CAZETTES
23	*
24	* \section info Change Information
25	*
26	*/
27	/***************ES2 ***************/
28
29	/============================================================================/
30	/* Standard include files: */
31	/============================================================================/
32	#include "tmNxTypes.h"
33	#include "tmCompId.h"
34	#include "tmFrontEnd.h"
35	#include "tmbslFrontEndTypes.h"
36
37	/============================================================================/
38	/* Project include files: */
39	/============================================================================/
40	#include "tmbslTDA182I4.h"
41
42	#include "tmbslTDA182I4_RegDef.h"
43	#include "tmbslTDA182I4_Local.h"
44	#include "tmbslTDA182I4_Instance.h"
45	#include "tmbslTDA182I4_InstanceCustom.h"
46
47
48	/============================================================================/
49	/* Static internal functions: */
50	/============================================================================/
51	static tmErrorCode_t
52	iTDA182I4_SetLLPowerState(pTDA182I4Object_t pObj, TDA182I4PowerState_t powerState);
53
54	static tmErrorCode_t
55	iTDA182I4_OverrideBandsplit(pTDA182I4Object_t pObj);
56
57	static tmErrorCode_t
58	iTDA182I4_OverrideICP(pTDA182I4Object_t pObj, UInt32 freq);
59
60	static tmErrorCode_t
61	iTDA182I4_OverrideWireless(pTDA182I4Object_t pObj);
62
63	tmErrorCode_t
64	iTDA182I4_CalculatePostDivAndPrescaler(UInt32 LO, Bool growingOrder, UInt8* PostDiv, UInt8* Prescaler);
65
66	static tmErrorCode_t
67	iTDA182I4_FindPostDivAndPrescalerWithBetterMargin(UInt32 LO, UInt8* PostDiv, UInt8* Prescaler);
68
69	tmErrorCode_t
70	iTDA182I4_CalculateNIntKInt(UInt32 LO, UInt8 PostDiv, UInt8 Prescaler, UInt32* NInt, UInt32* KInt);
71
72	static tmErrorCode_t
73	iTDA182I4_SetPLL(pTDA182I4Object_t pObj);
74
75	tmErrorCode_t
76	iTDA182I4_GetRSSI(
77	pTDA182I4Object_t pObj, /* I: Driver object */
78	UInt8* puValue /* O: RSSI value */
79	);
80
81	tmErrorCode_t
82	iTDA182I4_SetIRcal(pTDA182I4Object_t pObj);
83
84
85	/============================================================================/
86	/* Static variables: */
87	/============================================================================/
88	typedef struct _TDA182I4_PostDivPrescalerTableDef_
89	{
90	UInt32 LO_max;
91	UInt32 LO_min;
92	UInt8 Prescaler;
93	UInt8 PostDiv;
94	} TDA182I4_PostDivPrescalerTableDef;
95
96	/* Table that maps LO vs Prescaler & PostDiv values */
97	static TDA182I4_PostDivPrescalerTableDef PostDivPrescalerTable[35] =
98	{
99	/* PostDiv 1 */
100	{1080000, 882000, 7, 1},
101	{882001, 771750, 8, 1},
102	{784000, 686000, 9, 1},
103	{705600, 617400, 10, 1},
104	{641454, 561272, 11, 1},
105	{587999, 514499, 12, 1},
106	{542768, 474922, 13, 1},
107	/* PostDiv 2 */
108	{503998, 440998, 7, 2},
109	{440999, 385873, 8, 2},
110	{391998, 342998, 9, 2},
111	{352798, 308698, 10, 2},
112	{320725, 280634, 11, 2},
113	{293997, 257247, 12, 2},
114	{271381, 237458, 13, 2},
115	/* PostDiv 4 */
116	{251996, 220496, 7, 4},
117	{220497, 192934, 8, 4},
118	{195996, 171496, 9, 4},
119	{176396, 154346, 10, 4},
120	{160360, 140315, 11, 4},
121	{146996, 128621, 12, 4},
122	{135688, 118727, 13, 4},
123	/* PostDiv 8 */
124	{125996, 110246, 7, 8},
125	{110247, 96465, 8, 8},
126	{97996, 85746, 9, 8},
127	{88196, 77171, 10, 8},
128	{80178, 70155, 11, 8},
129	{73496, 64309, 12, 8},
130	{67842, 59361, 13, 8},
131	/* PostDiv 16 */
132	{62996, 55121, 7, 16},
133	{55122, 48230, 8, 16},
134	{48996, 42871, 9, 16},
135	{44096, 38584, 10, 16},
136	{40087, 35076, 11, 16},
137	{36746, 32152, 12, 16},
138	{33919, 29679, 13, 16}
139	};
140
141	typedef struct _TDA182I4_PldFreqCorrectionTableDef_
142	{
143	UInt16 Freq; /* Mhz * 10 */
144	Int16 Correction; /* in 1/2 dB * 10 */
145	} TDA182I4_PldFreqCorrectionTableDef;
146
147	#define PldRfCorrection_length 126
148	static TDA182I4_PldFreqCorrectionTableDef PldRFCorrection[PldRfCorrection_length] = { \
149	/* format { from freq, correction 1/2 step} */
150	{ 0, 0 }, \
151	{ 430, 102 }, \
152	{ 602, 96 }, \
153	{ 773, 92 }, \
154	{ 945, 88 }, \
155	{ 1117, 82 }, \
156	{ 1288, 78 }, \
157	{ 1460, 84 }, \
158	{ 1504, 88 }, \
159	{ 1549, 94 }, \
160	{ 1593, 98 }, \
161	{ 1637, 102 }, \
162	{ 1682, 106 }, \
163	{ 1726, 86 }, \
164	{ 1934, 82 }, \
165	{ 2143, 76 }, \
166	{ 2351, 82 }, \
167	{ 2382, 88 }, \
168	{ 2412, 92 }, \
169	{ 2443, 90 }, \
170	{ 2522, 94 }, \
171	{ 2600, 100 }, \
172	{ 2679, 104 }, \
173	{ 2757, 108 }, \
174	{ 2836, 114 }, \
175	{ 2914, 90 }, \
176	{ 3200, 104 }, \
177	{ 3508, 98 }, \
178	{ 3590, 94 }, \
179	{ 3672, 96 }, \
180	{ 3692, 90 }, \
181	{ 3713, 86 }, \
182	{ 3733, 80 }, \
183	{ 3753, 56 }, \
184	{ 3845, 62 }, \
185	{ 3937, 66 }, \
186	{ 4030, 72 }, \
187	{ 4122, 76 }, \
188	{ 4214, 80 }, \
189	{ 4306, 102 }, \
190	{ 4399, 106 }, \
191	{ 4491, 84 }, \
192	{ 4573, 90 }, \
193	{ 4654, 94 }, \
194	{ 4736, 78 }, \
195	{ 5351, 82 }, \
196	{ 5415, 86 }, \
197	{ 5479, 90 }, \
198	{ 5543, 96 }, \
199	{ 5607, 76 }, \
200	{ 5627, 56 }, \
201	{ 5699, 54 }, \
202	{ 5771, 44 }, \
203	{ 6007, 40 }, \
204	{ 6242, 52 }, \
205	{ 6483, 48 }, \
206	{ 6723, 42 }, \
207	{ 6964, 38 }, \
208	{ 7204, 66 }, \
209	{ 7450, 52 }, \
210	{ 7691, 56 }, \
211	{ 7931, 30 }, \
212	{ 8113, 26 }, \
213	{ 8295, 22 }, \
214	{ 8476, 18 }, \
215	{ 8685, 22 }, \
216	{ 8712, 28 }, \
217	{ 8738, 32 }, \
218	{ 8765, 38 }, \
219	{ 8792, 50 }, \
220	{ 8818, 46 }, \
221	{ 8844, 40 }, \
222	{ 8870, 36 }, \
223	{ 8896, 32 }, \
224	{ 8923, 28 }, \
225	{ 8949, 22 }, \
226	{ 8975, 18 }, \
227	{ 9001, 14 }, \
228	{ 9027, 22 }, \
229	{ 9043, 18 }, \
230	{ 9060, 12 }, \
231	{ 9076, 8 }, \
232	{ 9093, 4 }, \
233	{ 9109, -2 }, \
234	{ 9125, -6 }, \
235	{ 9142, -12 }, \
236	{ 9158, -16 }, \
237	{ 9175, -20 }, \
238	{ 9191, -26 }, \
239	{ 9207, -30 }, \
240	{ 9224, -36 }, \
241	{ 9240, -40 }, \
242	{ 9257, -44 }, \
243	{ 9273, -54 }, \
244	{ 9293, -58 }, \
245	{ 9313, -62 }, \
246	{ 9333, -68 }, \
247	{ 9353, -72 }, \
248	{ 9373, -78 }, \
249	{ 9393, -82 }, \
250	{ 9413, -88 }, \
251	{ 9433, -92 }, \
252	{ 9453, -98 }, \
253	{ 9473, -102 }, \
254	{ 9493, -108 }, \
255	{ 9513, -112 }, \
256	{ 9533, -116 }, \
257	{ 9553, -122 }, \
258	{ 9573, -126 }, \
259	{ 9593, -132 }, \
260	{ 9613, -136 }, \
261	{ 9633, -142 }, \
262	{ 9653, -146 }, \
263	{ 9673, -152 }, \
264	{ 9693, -158 }, \
265	{ 9723, -162 }, \
266	{ 9752, -168 }, \
267	{ 9782, -172 }, \
268	{ 9812, -178 }, \
269	{ 9842, -182 }, \
270	{ 9871, -188 }, \
271	{ 9901, -192 }, \
272	{ 9931, -198 }, \
273	{ 9961, -202 }, \
274	{ 9990, -208 }, \
275	{ 10020, -210 } \
276	};
277	typedef struct _TDA182I4_PldRfAgcCorrectionTableDef_
278	{
279	UInt16 RfAgc; /* 0 ... 511 */
280	Int8 Correction_22; /* in 1/2 dB * 10 */
281	Int8 Correction_no22; /* in 1/2 dB * 10 */
282	} TDA182I4_PldRfAgcCorrectionTableDef;
283
284	#define PldRfAgcCorrection_length 54
285	static TDA182I4_PldRfAgcCorrectionTableDef PldRfAgcCorrection[PldRfAgcCorrection_length] = { \
286	/* format { from RfAgc, 1/2 step correction AGC1 = 22dB,1/2 step Correction AGC1 not 22dB } */
287	{ 0, -36 , -50 }, \
288	{ 115, -38 , -48 }, \
289	{ 120, -36 , -46 }, \
290	{ 125, -36 , -42 }, \
291	{ 130, -32 , -40 }, \
292	{ 135, -30 , -40 }, \
293	{ 140, -28 , -38 }, \
294	{ 150, -26 , -38 }, \
295	{ 155, -26 , -40 }, \
296	{ 165, -24 , -38 }, \
297	{ 170, -22 , -38 }, \
298	{ 180, -20 , -38 }, \
299	{ 190, -18 , -38 }, \
300	{ 195, -18 , -36 }, \
301	{ 200, -18 , -34 }, \
302	{ 205, -16 , -34 }, \
303	{ 210, -16 , -30 }, \
304	{ 215, -14 , -26 }, \
305	{ 220, -14 , -22 }, \
306	{ 225, -14 , -18 }, \
307	{ 230, -12 , -18 }, \
308	{ 235, -12 , -16 }, \
309	{ 240, -10 , -14 }, \
310	{ 245, -8 , -10 }, \
311	{ 250, -6 , -6 }, \
312	{ 255, -4 , -4 }, \
313	{ 260, 0 , -2 }, \
314	{ 265, 2 , -2 }, \
315	{ 270, 4 , 2 }, \
316	{ 275, 6 , 4 }, \
317	{ 280, 8 , 6 }, \
318	{ 285, 10 , 8 }, \
319	{ 295, 12 , 10 }, \
320	{ 305, 14 , 12 }, \
321	{ 310, 12 , 12 }, \
322	{ 320, 10 , 10 }, \
323	{ 325, 8 , 10 }, \
324	{ 335, 8 , 8 }, \
325	{ 365, 10 , 8 }, \
326	{ 370, 10 , 10 }, \
327	{ 385, 8 , 10 }, \
328	{ 390, 8 , 8 }, \
329	{ 400, 6 , 6 }, \
330	{ 405, 4 , 4 }, \
331	{ 410, 2 , 2 }, \
332	{ 420, 2 , 0 }, \
333	{ 425, 0 , 0 }, \
334	{ 430, 2 , 2 }, \
335	{ 440, 0 , 0 }, \
336	{ 450, -2 , -2 }, \
337	{ 460, 0 , 0 }, \
338	{ 470, -2 , -2 }, \
339	{ 480, 0 , 0 }, \
340	{ 495, 2 , 0 }, \
341	};
342
343	/* Middle of VCO frequency excursion : VCOmin + (VCOmax - VCOmin)/2 in KHz */
344	#define TDA182I4_MIDDLE_FVCO_RANGE ((705600 - 617400) / 2 + 617400)
345
346	/============================================================================/
347	/* Exported functions: */
348	/============================================================================/
349
350	/============================================================================/
351	/* FUNCTION: tmbslTDA182I4_Open: */
352	/* */
353	/* DESCRIPTION: Opens driver setup environment. */
354	/* */
355	/* RETURN: TM_OK if no error */
356	/* */
357	/============================================================================/
358	tmErrorCode_t
359	tmbslTDA182I4_Open(
360	tmUnitSelect_t tUnit, /* I: FrontEnd unit number */
361	tmbslFrontEndDependency_t* psSrvFunc /* I: setup parameters */
362	)
363	{
364	pTDA182I4Object_t pObj = Null;
365	tmErrorCode_t err = TM_OK;
366
367	/* Test parameter(s) */
368	if(psSrvFunc == Null)
369	{
370	err = TDA182I4_ERR_BAD_PARAMETER;
371	}
372
373	if(err == TM_OK)
374	{
375	/* Get a driver instance */
376	err = iTDA182I4_GetInstance(tUnit, &pObj);
377	}
378
379	/* Check driver instance state */
380	if(err == TM_OK \|\| err == TDA182I4_ERR_ERR_NO_INSTANCES)
381	{
382	if(P_OBJ_VALID && pObj->init == True)
383	{
384	err = TDA182I4_ERR_ALREADY_SETUP;
385	}
386	else
387	{
388	if(P_OBJ_VALID == False)
389	{
390	/* Try to allocate an instance of the driver */
391	err = iTDA182I4_AllocInstance(tUnit, &pObj);
392	if(err != TM_OK \|\| pObj == Null)
393	{
394	err = TDA182I4_ERR_ERR_NO_INSTANCES;
395	}
396	}
397
398	if(err == TM_OK)
399	{
400	/* Initialize the Object by default values */
401	P_SIO = P_FUNC_SIO(psSrvFunc);
402	P_STIME = P_FUNC_STIME(psSrvFunc);
403	P_SDEBUG = P_FUNC_SDEBUG(psSrvFunc);
404
405	#ifdef _TVFE_IMPLEMENT_MUTEX
406	if( P_FUNC_SMUTEX_OPEN_VALID(psSrvFunc)
407	&& P_FUNC_SMUTEX_CLOSE_VALID(psSrvFunc)
408	&& P_FUNC_SMUTEX_ACQUIRE_VALID(psSrvFunc)
409	&& P_FUNC_SMUTEX_RELEASE_VALID(psSrvFunc) )
410	{
411	P_SMUTEX = psSrvFunc->sMutex;
412
413	err = P_SMUTEX_OPEN(&P_MUTEX);
414	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "Mutex_Open(0x%08X) failed.", tUnit));
415	}
416	#endif
417
418	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_Open(0x%08X)", tUnit);
419
420	if(err == TM_OK)
421	{
422	pObj->init = True;
423	}
424	}
425	}
426	}
427
428	return err;
429	}
430
431	/============================================================================/
432	/* FUNCTION: tmbslTDA182I4_Close: */
433	/* */
434	/* DESCRIPTION: Closes driver setup environment. */
435	/* */
436	/* RETURN: TM_OK if no error */
437	/* */
438	/============================================================================/
439	tmErrorCode_t
440	tmbslTDA182I4_Close(
441	tmUnitSelect_t tUnit /* I: FrontEnd unit number */
442	)
443	{
444	pTDA182I4Object_t pObj = Null;
445	tmErrorCode_t err = TM_OK;
446
447	/* Get a driver instance */
448	err = iTDA182I4_GetInstance(tUnit, &pObj);
449
450	if(err == TM_OK)
451	{
452	#ifdef _TVFE_IMPLEMENT_MUTEX
453	/* Try to acquire driver mutex */
454	err = iTDA182I4_MutexAcquire(pObj, TDA182I4_MUTEX_TIMEOUT);
455
456	if(err == TM_OK)
457	{
458	#endif
459	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_Close(0x%08X)", tUnit);
460
461	#ifdef _TVFE_IMPLEMENT_MUTEX
462	P_SMUTEX_ACQUIRE = Null;
463
464	/* Release driver mutex */
465	(void)iTDA182I4_MutexRelease(pObj);
466
467	if(P_SMUTEX_CLOSE_VALID && P_MUTEX_VALID)
468	{
469	err = P_SMUTEX_CLOSE(P_MUTEX);
470	}
471
472	P_SMUTEX_OPEN = Null;
473	P_SMUTEX_CLOSE = Null;
474	P_SMUTEX_RELEASE = Null;
475
476	P_MUTEX = Null;
477	}
478	#endif
479
480	err = iTDA182I4_DeAllocInstance(pObj);
481	}
482
483	return err;
484	}
485
486	/============================================================================/
487	/* FUNCTION: tmbslTDA182I4_GetSWVersion: */
488	/* */
489	/* DESCRIPTION: Gets the versions of the driver. */
490	/* */
491	/* RETURN: TM_OK */
492	/* */
493	/============================================================================/
494	tmErrorCode_t
495	tmbslTDA182I4_GetSWVersion(
496	ptmSWVersion_t pSWVersion /* I: Receives SW Version */
497	)
498	{
499	pSWVersion->compatibilityNr = TDA182I4_COMP_NUM;
500	pSWVersion->majorVersionNr = TDA182I4_MAJOR_VER;
501	pSWVersion->minorVersionNr = TDA182I4_MINOR_VER;
502
503	return TM_OK;
504	}
505
506	/============================================================================/
507	/* FUNCTION: tmbslTDA182I4_GetSWSettingsVersion: */
508	/* */
509	/* DESCRIPTION: Returns the version of the driver settings. */
510	/* */
511	/* RETURN: TM_OK */
512	/* */
513	/============================================================================/
514	tmErrorCode_t
515	tmbslTDA182I4_GetSWSettingsVersion(
516	ptmSWSettingsVersion_t pSWSettingsVersion /* O: Receives SW Settings Version */
517	)
518	{
519	pSWSettingsVersion->customerNr = TDA182I4_SETTINGS_CUSTOMER_NUM;
520	pSWSettingsVersion->projectNr = TDA182I4_SETTINGS_PROJECT_NUM;
521	pSWSettingsVersion->majorVersionNr = TDA182I4_SETTINGS_MAJOR_VER;
522	pSWSettingsVersion->minorVersionNr = TDA182I4_SETTINGS_MINOR_VER;
523
524	return TM_OK;
525	}
526
527	/============================================================================/
528	/* FUNCTION: tmbslTDA182I4_CheckHWVersion: */
529	/* */
530	/* DESCRIPTION: Checks TDA182I4 HW Version. */
531	/* */
532	/* RETURN: TM_OK */
533	/* */
534	/============================================================================/
535	tmErrorCode_t
536	tmbslTDA182I4_CheckHWVersion(
537	tmUnitSelect_t tUnit /* I: Unit number */
538	)
539	{
540	pTDA182I4Object_t pObj = Null;
541	tmErrorCode_t err = TM_OK;
542	UInt16 uIdentity = 0;
543	UInt8 ID_byte_1 = 0;
544	UInt8 ID_byte_2 = 0;
545	UInt8 majorRevision = 0;
546	UInt8 minorRevision = 0;
547
548	/* Get a driver instance */
549	err = iTDA182I4_GetInstance(tUnit, &pObj);
550
551	_MUTEX_ACQUIRE(TDA182I4)
552
553	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_CheckHWVersion(0x%08X)", tUnit);
554
555	err = iTDA182I4_ReadRegMap(pObj, gTDA182I4_Reg_ID_byte_1.Address, TDA182I4_REG_DATA_LEN(gTDA182I4_Reg_ID_byte_1__Ident_1, gTDA182I4_Reg_ID_byte_3));
556	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_ReadRegMap(0x%08X) failed.", tUnit));
557
558	if(err == TM_OK)
559	{
560	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_ID_byte_1__Ident_1, &ID_byte_1, Bus_None);
561	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", tUnit));
562	}
563
564	if(err == TM_OK)
565	{
566	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_ID_byte_2__Ident_2, &ID_byte_2, Bus_None);
567	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", tUnit));
568	}
569
570	if(err == TM_OK)
571	{
572	/* Construct Identity */
573	uIdentity = (ID_byte_1 << 8) \| ID_byte_2;
574
575	if ((uIdentity == 18274) \|\| (uIdentity == 18214))
576	{
577	/* TDA182I4 found. Check Major & Minor Revision */
578	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_ID_byte_3__Major_rev, &majorRevision, Bus_None);
579	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", tUnit));
580
581	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_ID_byte_3__Minor_rev, &minorRevision, Bus_None);
582	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", tUnit));
583
584	}
585	else
586	{
587	err = TDA182I4_ERR_BAD_VERSION;
588	}
589	}
590
591	_MUTEX_RELEASE(TDA182I4)
592
593	return err;
594	}
595
596	/============================================================================/
597	/* FUNCTION: tmbslTDA182I4_SetPowerState */
598	/* */
599	/* DESCRIPTION: Sets the power state. */
600	/* */
601	/* RETURN: TM_OK if no error */
602	/* */
603	/============================================================================/
604	tmErrorCode_t
605	tmbslTDA182I4_SetPowerState(
606	tmUnitSelect_t tUnit, /* I: Unit number */
607	tmPowerState_t powerState /* I: Power state */
608	)
609	{
610	pTDA182I4Object_t pObj = Null;
611	tmErrorCode_t err = TM_OK;
612
613	/* Get a driver instance */
614	err = iTDA182I4_GetInstance(tUnit, &pObj);
615
616	_MUTEX_ACQUIRE(TDA182I4)
617
618	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_SetPowerState(0x%08X)", tUnit);
619
620	if(powerState>=tmPowerMax)
621	{
622	err = TDA182I4_ERR_BAD_PARAMETER;
623	}
624
625	if(err == TM_OK)
626	{
627	if(pObj->mapLLPowerState[powerState] != pObj->curLLPowerState)
628	{
629	if(powerState == tmPowerOn)
630	err = iTDA182I4_SetLLPowerState(pObj, pObj->mapLLPowerState[powerState]);
631	else /janzy@20120911/
632	err = iTDA182I4_SetLLPowerState(pObj, TDA182I4_PowerStandbyWithLtOnWithXtalOn);
633	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_SetLLPowerState(0x%08X, %d) failed.", tUnit, (int)pObj->mapLLPowerState[powerState]));
634
635	if(err == TM_OK)
636	{
637	/* Store power state in driver instance */
638	pObj->curPowerState = powerState;
639	}
640	}
641	}
642
643	_MUTEX_RELEASE(TDA182I4)
644
645	return err;
646	}
647
648	/============================================================================/
649	/* FUNCTION: tmbslTDA182I4_GetPowerState: */
650	/* */
651	/* DESCRIPTION: Gets the power state. */
652	/* */
653	/* RETURN: TM_OK if no error */
654	/* */
655	/============================================================================/
656	tmErrorCode_t
657	tmbslTDA182I4_GetPowerState(
658	tmUnitSelect_t tUnit, /* I: Unit number */
659	tmPowerState_t* pPowerState /* O: Power state */
660	)
661	{
662	pTDA182I4Object_t pObj = Null;
663	tmErrorCode_t err = TM_OK;
664
665	/* Get a driver instance */
666	err = iTDA182I4_GetInstance(tUnit, &pObj);
667
668	_MUTEX_ACQUIRE(TDA182I4)
669
670	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_GetPowerState(0x%08X)", tUnit);
671
672	/* Test parameter(s) */
673	if(pPowerState == Null)
674	{
675	err = TDA182I4_ERR_BAD_PARAMETER;
676	}
677
678	if(err == TM_OK)
679	{
680	*pPowerState = pObj->curPowerState;
681	}
682
683	_MUTEX_RELEASE(TDA182I4)
684
685	return err;
686	}
687
688	/============================================================================/
689	/* FUNCTION: tmbslTDA182I4_SetLLPowerState */
690	/* */
691	/* DESCRIPTION: Sets the power state. */
692	/* */
693	/* RETURN: TM_OK if no error */
694	/* */
695	/============================================================================/
696	tmErrorCode_t
697	tmbslTDA182I4_SetLLPowerState(
698	tmUnitSelect_t tUnit, /* I: Unit number */
699	TDA182I4PowerState_t powerState /* I: Power state of TDA182I4 */
700	)
701	{
702	pTDA182I4Object_t pObj = Null;
703	tmErrorCode_t err = TM_OK;
704
705	/* Get a driver instance */
706	err = iTDA182I4_GetInstance(tUnit, &pObj);
707
708	_MUTEX_ACQUIRE(TDA182I4)
709
710	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_SetLLPowerState(0x%08X)", tUnit);
711
712	pObj->curPowerState = tmPowerMax;
713
714	err = iTDA182I4_SetLLPowerState(pObj, powerState);
715	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_SetLLPowerState(0x%08X, %d) failed.", tUnit, (int)powerState));
716
717	_MUTEX_RELEASE(TDA182I4)
718
719	return err;
720	}
721
722	/============================================================================/
723	/* FUNCTION: tmbslTDA182I4_GetLLPowerState */
724	/* */
725	/* DESCRIPTION: Gets the power state. */
726	/* */
727	/* RETURN: TM_OK if no error */
728	/* */
729	/============================================================================/
730	tmErrorCode_t
731	tmbslTDA182I4_GetLLPowerState(
732	tmUnitSelect_t tUnit, /* I: Unit number */
733	TDA182I4PowerState_t* pPowerState /* O: Power state of TDA182I4 */
734	)
735	{
736	pTDA182I4Object_t pObj = Null;
737	tmErrorCode_t err = TM_OK;
738	UInt8 uValue = 0;
739
740
741	/* Get a driver instance */
742	err = iTDA182I4_GetInstance(tUnit, &pObj);
743
744	_MUTEX_ACQUIRE(TDA182I4)
745
746	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_GetLLPowerState(0x%08X)", tUnit);
747
748	/* Test parameter(s) */
749	if(pPowerState == Null)
750	{
751	err = TDA182I4_ERR_BAD_PARAMETER;
752	}
753
754	if(err == TM_OK)
755	{
756	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Power_state_byte_2__power_state_mode, &uValue, Bus_RW);
757	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", tUnit));
758	}
759
760	if(err == TM_OK)
761	{
762	switch (uValue)
763	{
764	case TDA182I4_power_state_mode_NORMAL_MODE_VALUE_0:
765	*pPowerState = TDA182I4_PowerNormalMode;
766	break;
767	case TDA182I4_power_state_mode_STDBY_PLUS16M_VALUE_1:
768	*pPowerState = TDA182I4_PowerStandbyWithXtalOn;
769	break;
770	case TDA182I4_power_state_mode_STDBY_PLUS16M_PLUS_LT_VALUE_2:
771	*pPowerState = TDA182I4_PowerStandbyWithLtOnWithXtalOn;
772	break;
773	case TDA182I4_power_state_mode_STDBY_PLUS16M_PLUS_PLL_VALUE_3:
774	*pPowerState = TDA182I4_PowerStandbyWithPllOnWithXtalOn;
775	break;
776	case TDA182I4_power_state_mode_STDBY_PLUS_16M_PLUS_LT_PLUS_PLL_VALUE_4:
777	*pPowerState = TDA182I4_PowerStandbyWithLtOnWithPllOnWithXtalOn;
778	break;
779	default :
780	err = TDA182I4_ERR_NOT_SUPPORTED;
781	break;
782	}
783
784	}
785
786	_MUTEX_RELEASE(TDA182I4)
787
788	return err;
789	}
790
791	/============================================================================/
792	/* FUNCTION: tmbslTDA182I4_SetGpio */
793	/* */
794	/* DESCRIPTION: Sets the GPIOs. */
795	/* */
796	/* RETURN: TM_OK if no error */
797	/* */
798	/============================================================================/
799	tmErrorCode_t
800	tmbslTDA182I4_SetGpio(
801	tmUnitSelect_t tUnit, /* I: Unit number */
802	UInt8 bNumber, /* I: Number of the GPIO to set */
803	Bool bActive /* I: GPIO enabled/disabled */
804	)
805	{
806	pTDA182I4Object_t pObj = Null;
807	tmErrorCode_t err = TM_OK;
808
809	/* Get a driver instance */
810	err = iTDA182I4_GetInstance(tUnit, &pObj);
811
812	_MUTEX_ACQUIRE(TDA182I4)
813
814	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_SetGpio(0x%08X)", tUnit);
815
816	if(err == TM_OK)
817	{
818	switch (bNumber)
819	{
820	case 1:
821	/* Set GPIO n? */
822	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Gpio_ctrl_byte__GPIO1, (bActive==True)?1:0, Bus_RW);
823	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
824	break;
825
826	case 2:
827	/* Set GPIO n? */
828	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Gpio_ctrl_byte__GPIO2, (bActive==True)?1:0, Bus_RW);
829	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
830	break;
831
832	default:
833	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "tmbslTDA182I4_SetGpio(0x%08X) invalid GPIO number.", tUnit));
834	break;
835	}
836	}
837
838	_MUTEX_RELEASE(TDA182I4)
839
840	return err;
841	}
842
843	/============================================================================/
844	/* FUNCTION: tmbslTDA182I4_SetStandardMode */
845	/* */
846	/* DESCRIPTION: Sets the standard mode. */
847	/* */
848	/* RETURN: TM_OK if no error */
849	/* */
850	/============================================================================/
851	tmErrorCode_t
852	tmbslTDA182I4_SetStandardMode(
853	tmUnitSelect_t tUnit, /* I: Unit number */
854	TDA182I4StandardMode_t StandardMode /* I: Standard mode of this device */
855	)
856	{
857	pTDA182I4Object_t pObj = Null;
858	tmErrorCode_t err = TM_OK;
859	pTDA182I4StdCoefficients prevPStandard = Null;
860
861	/* Get a driver instance */
862	err = iTDA182I4_GetInstance(tUnit, &pObj);
863
864	_MUTEX_ACQUIRE(TDA182I4)
865
866	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_SetStandardMode(0x%08X)", tUnit);
867
868	/* Check if Hw is ready to operate */
869	err = iTDA182I4_CheckHwState(pObj, TDA182I4_HwStateCaller_SetStd);
870	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_CheckHwState(0x%08X) failed.", pObj->tUnitW));
871
872	if(err == TM_OK)
873	{
874	/* Store standard mode */
875	pObj->StandardMode = StandardMode;
876
877	/* Reset standard map pointer */
878	prevPStandard = pObj->pStandard;
879	pObj->pStandard = Null;
880
881	if(pObj->StandardMode>TDA182I4_StandardMode_Unknown && pObj->StandardMode<TDA182I4_StandardMode_Max)
882	{
883	pObj->pStandard = &pObj->Std_Array[pObj->StandardMode - 1];
884
885	/****************************************************************/
886	/* DVB-T/T2 FEF Settings */
887	/****************************************************************/
888	if (( pObj->StandardMode >= TDA182I4_DVBT_1_7MHz ) && ( pObj->StandardMode <= TDA182I4_DVBT_10MHz ) && (pObj->bFefEnable) )
889	{
890	/* Set AGCs_Up_step */
891	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC2_byte_1__AGCs_Up_step, 0x01, Bus_None);
892	/* Set PD_Ovld */
893	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Vsync_Mgt_byte__PD_Ovld, 0x01, Bus_None);
894	/* Set PD_Ovld_RF */
895	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Vsync_Mgt_byte__PD_Ovld_RF, 0x01, Bus_None);
896	}
897	else
898	{
899	/* Set AGCs_Up_step */
900	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC2_byte_1__AGCs_Up_step, 0x03, Bus_None);
901	/* Set PD_Ovld */
902	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Vsync_Mgt_byte__PD_Ovld, 0x00, Bus_None);
903
904	/******************************************************************/
905	/* For all SECAM standards, enable PD Overload RF (register 0x2A) */
906	/******************************************************************/
907	if ( pObj->bCenelecMargin &&
908	(
909	(pObj->StandardMode == TDA182I4_ANLG_DK) \|\|
910	(pObj->StandardMode == TDA182I4_ANLG_L) \|\|
911	(pObj->StandardMode == TDA182I4_ANLG_LL)
912	) )
913	{
914	/* Set PD_Ovld_RF */
915	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Vsync_Mgt_byte__PD_Ovld_RF, 0x01, Bus_None);
916	}
917	else
918	{
919	/* Set PD_Ovld_RF */
920	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Vsync_Mgt_byte__PD_Ovld_RF, 0x00, Bus_None);
921	}
922	}
923
924	/****************************************************************/
925	/* IF SELECTIVITY Settings */
926	/****************************************************************/
927
928	/* Set LPFc */
929	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_Byte_1__LP_Fc, pObj->pStandard->LPF, Bus_None);
930	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
931
932	/* Set LPFc Offset */
933	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_Byte_1__IF_LPF_Offset,(UInt8)(pObj->pStandard->LPF_Offset >>4), Bus_None);
934	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
935
936	/* Set sign */
937	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_Byte_1__IF_LPF_sign, (UInt8)(pObj->pStandard->LPF_Offset & 0x0f), Bus_None);
938	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
939
940
941
942	if(err == TM_OK)
943	{
944	/* Enable/disable HPF */
945	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_Byte_2__IF_HP_Enable,(UInt8)(pObj->pStandard->HPF & 0x0f), Bus_None);
946	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
947
948	/* Set IF HPF */
949	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_Byte_2__IF_HP_Fc, (UInt8)(pObj->pStandard->HPF >> 4), Bus_None);
950	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
951	}
952
953	/* Set HPFc Offset */
954	if(err == TM_OK)
955	{
956	/* Set offset */
957	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_Byte_2__IF_HPF_Offset, (UInt8)(pObj->pStandard->HPF_Offset >>4), Bus_None);
958	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
959
960	/* Set sign */
961	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_Byte_2__IF_HPF_sign, (UInt8)(pObj->pStandard->HPF_Offset & 0x0f), Bus_None);
962	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
963	}
964
965	if(err == TM_OK)
966	{
967	/* Set IF notch to RSSI */
968	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_AGC_byte__IFnotchToRSSI, pObj->pStandard->IFnotchToRSSI, Bus_None);
969	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
970	}
971	if(err == TM_OK)
972	{
973	/* Set IF Notch */
974	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_Byte_3__IF_Notch_Enable, pObj->pStandard->IF_Notch_Enable, Bus_None);
975	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
976	}
977	/* Set IF_Notch_Freq */
978	if(err == TM_OK)
979	{
980	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_Byte_3__IF_Notch_Freq, pObj->pStandard->IF_Notch_Freq, Bus_None);
981	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
982	}
983
984	/* Set IF_Notch Offset */
985	if(err == TM_OK)
986	{
987	/* Set offset */
988	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_Byte_3__IF_Notch_Offset, (UInt8)(pObj->pStandard->IF_Notch_Offset >>4), Bus_None);
989	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
990
991	/* Set sign */
992	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_Byte_3__IF_Notch_sign, (UInt8)(pObj->pStandard->IF_Notch_Offset & 0x0f), Bus_None);
993	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
994	}
995	/****************************************************************/
996	/* AGC TOP Settings */
997	/****************************************************************/
998
999	if(err == TM_OK)
1000	{
1001	/* Set AGC1 TOP I2C DN/UP */
1002	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_1__AGC1_Top, pObj->pStandard->AGC1_TOP_I2C_DN_UP, Bus_None);
1003	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1004	}
1005
1006	if(err == TM_OK)
1007	{
1008	/* Set AGC1_Top_Strategy */
1009	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_1__AGC1_Top_Strategy, pObj->pStandard->AGC1_TOP_STRATEGY, Bus_None);
1010	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1011	}
1012	if(err == TM_OK)
1013	{
1014	/* Set LNA_zin */
1015	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_2__LNA_Zin, pObj->pStandard->LNA_Zin, Bus_None);
1016	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1017	}
1018	if(err == TM_OK)
1019	{
1020	/* Set RFAGC_Peak_Val */
1021	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_AGC_byte_2__RFAGC_Peak_Val, pObj->pStandard->RFAGC_Peak_Val, Bus_None);
1022	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1023	}
1024	if(err == TM_OK)
1025	{
1026	/* SetRFAGC_Adapt_TOP_ovld */
1027	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_AGC_byte_2__RFAGC_Adapt_TOP_ovld, pObj->pStandard->RFAGC_Adapt_TOP_ovld, Bus_None);
1028	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1029	}
1030	if(err == TM_OK)
1031	{
1032	/* Set RFAGC_det_mode */
1033	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_AGC_byte_2__RFAGC_det_mode, pObj->pStandard->RFAGC_det_mode, Bus_None);
1034	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1035	}
1036	if(err == TM_OK)
1037	{
1038	/* Set AGC3 RF AGC Top */
1039	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_AGC_byte_1__RFAGC_Top, pObj->pStandard->AGC3_TOP_I2C, Bus_None);
1040	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1041	}
1042
1043	if(err == TM_OK)
1044	{
1045	/* Set AGC3 Adapt TOP */
1046	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_AGC_byte_1__RFAGC_Adapt_TOP, pObj->pStandard->AGC3_Adapt_TOP, Bus_None);
1047	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1048	}
1049
1050	if(err == TM_OK)
1051	{
1052	/* Set AGC4 TOP DN/UP */
1053	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IR_Mixer_byte_1__IR_Mixer_Top, pObj->pStandard->AGC4_TOP_DN_UP, Bus_None);
1054	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1055	}
1056	if(err == TM_OK)
1057	{
1058	/* Set DC_Notch_IF_PPF */
1059	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IR_Mixer_byte_2__DC_Notch, pObj->pStandard->DC_Notch_IF_PPF, Bus_None);
1060	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1061	}
1062
1063	if(err == TM_OK)
1064	{
1065	/* Set AGC5 TOP DN/UP */
1066	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC5_byte_1__AGC5_TOP, pObj->pStandard->AGC5_TOP_DN_UP, Bus_None);
1067	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1068	}
1069
1070	if(err == TM_OK)
1071	{
1072	/* Set RSSI HP FC */
1073	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC5_byte_1__RSSI_HP_Fc, pObj->pStandard->RSSI_HP_FC, Bus_None);
1074	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1075	}
1076
1077	if(err == TM_OK)
1078	{
1079	/* Set AGC5 HP FC */
1080	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC5_byte_1__AGC5_HP_Fc, pObj->pStandard->AGC5_HP_FC, Bus_None);
1081	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1082	}
1083
1084	if(err == TM_OK)
1085	{
1086	/* Set AGC3_Top_Adapt_Algorithm */
1087	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_AGC_byte_1__PD_AGC_Adapt35, ((pObj->pStandard->AGC3_Top_Adapt_Algorithm) >> 1) & 0x1, Bus_None);
1088	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1089
1090	if(err == TM_OK)
1091	{
1092	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_AGC_byte_1__PD_AGC_Adapt34, (pObj->pStandard->AGC3_Top_Adapt_Algorithm) & 0x1, Bus_None);
1093	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1094	}
1095	}
1096
1097	if(err == TM_OK)
1098	{
1099	/* Set AGC Overload TOP */
1100	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Vsync_Mgt_byte__AGC_Ovld_TOP, pObj->pStandard->AGC_Overload_TOP, Bus_None);
1101	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1102	}
1103
1104	if(err == TM_OK)
1105	{
1106	/* Set RF atten 3dB */
1107	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_W_Filter_byte__RF_Atten_3dB, pObj->pStandard->RF_Atten_3dB, Bus_None);
1108	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1109	}
1110
1111	if(err == TM_OK)
1112	{
1113	/* Set IF Output Level */
1114	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_AGC_byte__IF_level, pObj->pStandard->IF_Output_Level, Bus_None);
1115	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1116	}
1117
1118	if(err == TM_OK)
1119	{
1120	/* Set S2D gain */
1121	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IR_Mixer_byte_1__S2D_Gain, pObj->pStandard->S2D_Gain, Bus_None);
1122	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1123	}
1124
1125	if(err == TM_OK)
1126	{
1127	/* Set Negative modulation */
1128	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Vsync_byte__Neg_Modulation, pObj->pStandard->Negative_Modulation, Bus_None);
1129	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1130	}
1131
1132	/****************************************************************/
1133	/* GSK Settings */
1134	/****************************************************************/
1135
1136	if(err == TM_OK)
1137	{
1138	/* Set AGCK Time Constant */
1139	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGCK_byte_1__AGCK_Mode, pObj->pStandard->AGCK_Time_Constant, Bus_None);
1140	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1141	}
1142
1143	/****************************************************************/
1144	/* H3H5 Settings */
1145	/****************************************************************/
1146
1147	if(err == TM_OK)
1148	{
1149	/* Set VHF_III_Mode */
1150	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_W_Filter_byte__VHF_III_mode, pObj->pStandard->VHF_III_Mode, Bus_None);
1151	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1152	}
1153
1154	/****************************************************************/
1155	/* IF Settings */
1156	/****************************************************************/
1157
1158	if(err == TM_OK)
1159	{
1160	/* Set IF */
1161	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IF_Frequency_byte__IF_Freq, (UInt8)((pObj->pStandard->IF - pObj->pStandard->CF_Offset)/50000), Bus_None);
1162	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1163	}
1164	if(err == TM_OK)
1165	{
1166	err = iTDA182I4_PowerSavingMode(pObj, pObj->pStandard->PowerSavingMode);
1167	}
1168
1169	/* Blocks final writting */
1170	if(err == TM_OK)
1171	{
1172	/* Write AGC1_byte_1 (0x0D) to IF_Frequency_byte (0x1C) Registers */
1173	err = iTDA182I4_WriteRegMap(pObj, gTDA182I4_Reg_AGC1_byte_1.Address, TDA182I4_REG_DATA_LEN(gTDA182I4_Reg_AGC1_byte_1, gTDA182I4_Reg_IF_Frequency_byte));
1174	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_WriteRegMap(0x%08X) failed.", pObj->tUnitW));
1175	}
1176	if(err == TM_OK)
1177	{
1178	/* Write gTDA182I4_Reg_Adapt_Top_byte (0x28) to gTDA182I4_Reg_IR_Mixer_byte_2 (0x2B) Registers */
1179	err = iTDA182I4_WriteRegMap(pObj, gTDA182I4_Reg_Adapt_Top_byte.Address, TDA182I4_REG_DATA_LEN(gTDA182I4_Reg_Adapt_Top_byte, gTDA182I4_Reg_IR_Mixer_byte_2));
1180	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_WriteRegMap(0x%08X) failed.", pObj->tUnitW));
1181	}
1182	if(err == TM_OK)
1183	{
1184	/* Set RSSI_Cap_Val */
1185	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RSSI_byte_2__RSSI_Cap_Val, pObj->pStandard->RSSI_Cap_Val, Bus_None);
1186	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1187	}
1188	if(err == TM_OK)
1189	{
1190	/* Set RSSI_Cap_Val */
1191	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RSSI_byte_2__RSSI_Ck_Speed, pObj->pStandard->RSSI_Ck_Speed, Bus_NoRead);
1192	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1193	}
1194
1195	}
1196
1197	/* Update driver state machine */
1198	pObj->eHwState = TDA182I4_HwState_SetStdDone;
1199	}
1200
1201	_MUTEX_RELEASE(TDA182I4)
1202
1203	return err;
1204	}
1205
1206	/============================================================================/
1207	/* FUNCTION: tmbslTDA182I4_GetStandardMode */
1208	/* */
1209	/* DESCRIPTION: Gets the standard mode. */
1210	/* */
1211	/* RETURN: TM_OK if no error */
1212	/* */
1213	/============================================================================/
1214	tmErrorCode_t
1215	tmbslTDA182I4_GetStandardMode(
1216	tmUnitSelect_t tUnit, /* I: Unit number */
1217	TDA182I4StandardMode_t pStandardMode / O: Standard mode of this device */
1218	)
1219	{
1220	pTDA182I4Object_t pObj = Null;
1221	tmErrorCode_t err = TM_OK;
1222
1223	/* Get a driver instance */
1224	err = iTDA182I4_GetInstance(tUnit, &pObj);
1225
1226	_MUTEX_ACQUIRE(TDA182I4)
1227
1228	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_GetStandardMode(0x%08X)", tUnit);
1229
1230	if(pStandardMode == Null)
1231	{
1232	err = TDA182I4_ERR_BAD_PARAMETER;
1233	}
1234
1235	if(err == TM_OK)
1236	{
1237	/* Get standard mode */
1238	*pStandardMode = pObj->StandardMode;
1239	}
1240
1241	_MUTEX_RELEASE(TDA182I4)
1242
1243	return err;
1244	}
1245
1246	/============================================================================/
1247	/* FUNCTION: tmbslTDA182I4_SetRF: */
1248	/* */
1249	/* DESCRIPTION: Tunes to a RF. */
1250	/* */
1251	/* RETURN: TM_OK */
1252	/* */
1253	/============================================================================/
1254	tmErrorCode_t
1255	tmbslTDA182I4_SetRF(
1256	tmUnitSelect_t tUnit, /* I: Unit number */
1257	UInt32 uRF /* I: RF frequency in hertz */
1258	)
1259	{
1260	pTDA182I4Object_t pObj = Null;
1261	tmErrorCode_t err = TM_OK;
1262
1263	/* Get a driver instance */
1264	err = iTDA182I4_GetInstance(tUnit, &pObj);
1265
1266	_MUTEX_ACQUIRE(TDA182I4)
1267
1268	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_SetRF(0x%08X)", tUnit);
1269
1270	/* Test parameter(s) */
1271	if( pObj->StandardMode<=TDA182I4_StandardMode_Unknown
1272	\|\| pObj->StandardMode>=TDA182I4_StandardMode_Max
1273	\|\| pObj->pStandard == Null)
1274	{
1275	err = TDA182I4_ERR_STD_NOT_SET;
1276	}
1277
1278	if(err == TM_OK)
1279	{
1280	/* Check if Hw is ready to operate */
1281	err = iTDA182I4_CheckHwState(pObj, TDA182I4_HwStateCaller_SetRF);
1282	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_CheckHwState(0x%08X) failed.", pObj->tUnitW));
1283	}
1284	if(err == TM_OK)
1285	{
1286	pObj->uRF = uRF;
1287	pObj->uProgRF = pObj->uRF + pObj->pStandard->CF_Offset;
1288
1289	err = iTDA182I4_SetRF(pObj);
1290	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_SetRF(0x%08X) failed.", tUnit));
1291
1292	if(err == TM_OK)
1293	{
1294	/* Update driver state machine */
1295	pObj->eHwState = TDA182I4_HwState_SetRFDone;
1296	}
1297	}
1298
1299	_MUTEX_RELEASE(TDA182I4)
1300
1301	return err;
1302	}
1303
1304	/============================================================================/
1305	/* FUNCTION: tmbslTDA182I4_GetRF: */
1306	/* */
1307	/* DESCRIPTION: Gets tuned RF. */
1308	/* */
1309	/* RETURN: TM_OK */
1310	/* */
1311	/============================================================================/
1312	tmErrorCode_t
1313	tmbslTDA182I4_GetRF(
1314	tmUnitSelect_t tUnit, /* I: Unit number */
1315	UInt32* puRF /* O: RF frequency in hertz */
1316	)
1317	{
1318	pTDA182I4Object_t pObj = Null;
1319	tmErrorCode_t err = TM_OK;
1320
1321	/* Get a driver instance */
1322	err = iTDA182I4_GetInstance(tUnit, &pObj);
1323
1324	_MUTEX_ACQUIRE(TDA182I4)
1325
1326	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_GetRF(0x%08X)", tUnit);
1327
1328	if(puRF == Null)
1329	{
1330	err = TDA182I4_ERR_BAD_PARAMETER;
1331	}
1332
1333	if(err == TM_OK)
1334	{
1335	/* Get RF */
1336	*puRF = pObj->uRF;
1337	}
1338
1339	_MUTEX_RELEASE(TDA182I4)
1340
1341	return err;
1342	}
1343
1344	/============================================================================/
1345	/* FUNCTION: tmbslTDA182I4_HwInit: */
1346	/* */
1347	/* DESCRIPTION: Initializes TDA182I4 Hardware. */
1348	/* */
1349	/* RETURN: TM_OK if no error */
1350	/* */
1351	/============================================================================/
1352	tmErrorCode_t
1353	tmbslTDA182I4_HwInit(
1354	tmUnitSelect_t tUnit /* I: Unit number */
1355	)
1356	{
1357	pTDA182I4Object_t pObj = Null;
1358	tmErrorCode_t err = TM_OK;
1359	UInt8 uVal;
1360	UInt32 counter = 10; /* Wait I2C ready */
1361
1362	/* Get a driver instance */
1363	err = iTDA182I4_GetInstance(tUnit, &pObj);
1364
1365	_MUTEX_ACQUIRE(TDA182I4)
1366
1367	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_HwInit(0x%08X)", tUnit);
1368
1369	/* Reset standard mode & Hw State */
1370	pObj->StandardMode = TDA182I4_StandardMode_Max;
1371	pObj->eHwState = TDA182I4_HwState_InitNotDone;
1372
1373	//software init
1374	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_Force_Soft_Reset, 0x01, Bus_RW);
1375	bos_sleep(10);
1376	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_Soft_Reset, 0x01, Bus_RW);
1377	bos_sleep(10);
1378
1379	while(counter > 0)
1380	{
1381	/* Read all bytes */
1382	err = iTDA182I4_ReadRegMap(pObj, 0x00, TDA182I4_REG_MAP_NB_BYTES);
1383	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_ReadRegMap(0x%08X) failed.", tUnit));
1384
1385	if(err==TM_OK)
1386	{
1387	/* IC I2C responds */
1388	break;
1389	}
1390
1391	if(counter)
1392	{
1393	/* Decrease the counter */
1394	counter--;
1395
1396	/* Wait for a step of 1ms */
1397	err = iTDA182I4_Wait(pObj, 1);
1398	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Wait(0x%08X) failed.", pObj->tUnitW));
1399	}
1400	}
1401	if(err == TM_OK)
1402	{
1403	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Reference_Byte__Xtout_Amp, &uVal, Bus_None);
1404	if(uVal!=pObj->curXTOutAmp)
1405	{
1406	/* XTOUT Amplitude */
1407	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Reference_Byte__Xtout_Amp, pObj->curXTOutAmp, Bus_NoRead);
1408	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1409	}
1410	}
1411
1412	/****************************************************/
1413	/* Change POR values */
1414	/****************************************************/
1415	if(err == TM_OK)
1416	{
1417	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_AGC1_byte_2__LNA_Range, &uVal, Bus_None);
1418	/* LNA gain range */
1419	if(uVal!=pObj->curLNA_Range)
1420	{
1421	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_2__LNA_Range, pObj->curLNA_Range, Bus_NoRead);
1422	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1423	}
1424	}
1425	if(err == TM_OK)
1426	{ /* Ovld_Tcst -> 0.2ms */
1427	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_AGC_byte_3__RFAGC_Ovld_Tcst, 0x01, Bus_None);
1428	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1429	}
1430	if(err == TM_OK)
1431	{ /* nber_up -> 0 nber_do -> 8 */
1432	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_AGC_byte_3__RFAGC_Ovld_nb, 0x03, Bus_NoRead);
1433	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1434	}
1435	if(err == TM_OK)
1436	{
1437	/* smooth_cc -> 0 ( Tuner in single, STO not used ) else 1 (Tuner in dual, STO used ) */
1438	uVal = (pObj->TunerModeInUse & TDA182I4_Mode_STO_Used ) ? 1: 0;
1439	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_smooth_cc_byte_1__smooth_cc, uVal, Bus_None);
1440	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1441	}
1442	if(err == TM_OK)
1443	{
1444	/* switch_smooth_t_cst */
1445	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_smooth_cc_byte_1__switch_smooth_t_cst, 0x05, Bus_NoRead);
1446	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1447	}
1448	if(err == TM_OK)
1449	{
1450	/* PD_RF_BUF_LTO -> 1 ( Tuner in single, STO not used ) else 0 (Tuner in dual, STO used ) */
1451	uVal = (pObj->TunerModeInUse & TDA182I4_Mode_STO_Used \|\| pObj->TunerModeInUse & TDA182I4_Mode_LTO_Used ) ? 0: 1;
1452	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_1__PD_RF_BUF_LTO, uVal, Bus_None);
1453	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1454	}
1455	if(err == TM_OK)
1456	{
1457	/* PD_LT -> TDA18274 or TDA1814 slave : 1 else 0 */
1458	uVal = (pObj->TunerModeInUse & TDA182I4_Mode_LTO_Used ) ? 0: 1;
1459	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_1__PD_LT, uVal, Bus_NoRead);
1460	}
1461	if(err == TM_OK)
1462	{
1463	/* AGC1_Do_step -> 2.044 ms */
1464	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_3__AGC1_Do_step, 0x01, Bus_None);
1465	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1466	}
1467	if(err == TM_OK)
1468	{
1469	/* activate AGC1_rst_do_enable */
1470	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_4__AGC1_rst_do_enable, 0x01, Bus_None);
1471	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1472	}
1473	if(err == TM_OK)
1474	{
1475	/* Write AGC1_byte_3 (0x2E) & AGC1_byte_4 (0x2F) Registers */
1476	err = iTDA182I4_WriteRegMap(pObj, gTDA182I4_Reg_AGC1_byte_3.Address, 0x02);
1477	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_WriteRegMap(0x%08X) failed.", pObj->tUnitW));
1478	}
1479	/* all Cprog to code 1 */
1480	if(err == TM_OK)
1481	{
1482	/* RF_Cal_byte_1 */
1483	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_Cal_byte_1, 0x55, Bus_None);
1484	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1485	/* RF_Cal_byte_2 */
1486	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_Cal_byte_3, 0x55, Bus_None);
1487	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1488	/* RF_Cal_byte_3 */
1489	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_Cal_byte_2, 0x55, Bus_None);
1490	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1491	}
1492	if(err == TM_OK)
1493	{
1494	/* Write RF_Cal_byte_1 (0x33) to gTDA182I4_Reg_RF_Cal_byte_3 (0x35) Registers */
1495	err = iTDA182I4_WriteRegMap(pObj, gTDA182I4_Reg_RF_Cal_byte_1.Address, TDA182I4_REG_DATA_LEN(gTDA182I4_Reg_RF_Cal_byte_1, gTDA182I4_Reg_RF_Cal_byte_3));
1496	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_WriteRegMap(0x%08X) failed.", pObj->tUnitW));
1497	}
1498	if(err == TM_OK)
1499	{
1500	/* PD_Udld -> 1 for LTE */
1501	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Vsync_Mgt_byte__PD_Udld, 0x01, Bus_NoRead);
1502	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1503	}
1504	if(err == TM_OK)
1505	{ /* Set PLL calc in auto */
1506	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_5__N_K_correct_manual, 0x00, Bus_None);
1507	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1508	}
1509	if(err == TM_OK)
1510	{
1511	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_5__LO_Calc_Disable, 0x00, Bus_None);
1512	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1513	}
1514	if(err == TM_OK)
1515	{
1516	/* LOSetAll =2 --> synchronisation with register only. */
1517	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_5__LO_SetAll, 0x02, Bus_NoRead);
1518	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1519	}
1520	if(err == TM_OK)
1521	{
1522	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Charge_pump_byte__ICP, 0x02, Bus_NoRead);
1523	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1524	}
1525	if(err == TM_OK)
1526	{
1527	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RC_Cal_byte_1__RC_Cal_Offset, TDA182I4_RC_Cal_Offset, Bus_NoRead);
1528	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1529	}
1530
1531	/* wake-up tuner */
1532	if(err == TM_OK)
1533	{
1534	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_state_byte_2__power_state_mode, TDA182I4_PowerNormalMode, Bus_NoRead);
1535	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1536	}
1537
1538	if(err == TM_OK)
1539	{
1540	pObj->curPowerState = tmPowerOn;
1541
1542	if(err == TM_OK)
1543	{
1544	/* Set IRQ_clear */
1545	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IRQ_clear, TDA182I4_IRQ_Global\|TDA182I4_IRQ_HwInit, Bus_NoRead);
1546	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1547	}
1548	/* Launch tuner calibration */
1549
1550	/* Set state machine and Launch it */
1551	if(err == TM_OK)
1552	{
1553	err = iTDA182I4_SetMSM(pObj, TDA182I4_MSM_HwInit, True);
1554	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_SetMSM(0x%08X, TDA182I4_MSM_HwInit) failed.", pObj->tUnitW));
1555	}
1556
1557	/* Inform that init phase has started */
1558	if(err == TM_OK)
1559	{
1560	pObj->eHwState = TDA182I4_HwState_InitPending;
1561	}
1562
1563	if(err == TM_OK)
1564	{
1565	/* State reached after 600 ms max */
1566	err = iTDA182I4_WaitIRQ(pObj, 600 * 100, 10, TDA182I4_IRQ_HwInit);
1567	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_WaitIRQ(0x%08X) failed.", tUnit));
1568	}
1569
1570	/* Run Software IRcal : copy Mid IRcal ti High IRcal */
1571	if(err == TM_OK)
1572	{
1573	err = iTDA182I4_SetIRcal(pObj);
1574	}
1575
1576	if(err == TM_OK && pObj->eHwState == TDA182I4_HwState_InitPending)
1577	{
1578	pObj->eHwState = TDA182I4_HwState_InitDone;
1579	}
1580	else
1581	{
1582	pObj->eHwState = TDA182I4_HwState_InitNotDone;
1583	}
1584	/* put Tuner in stand-by */
1585	if(err == TM_OK)
1586	{
1587	/* Set digital clock mode to 16 Mhz before entering standby */
1588	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Reference_Byte__Dig_Clock, 0x02, Bus_NoRead);
1589	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1590	}
1591	if(err == TM_OK)
1592	{
1593	if ( pObj->TunerModeInUse & TDA182I4_Mode_STO_Used )
1594	{
1595	/* Set power state to stdby default 16Mhz ( XTOUT on , LT/LNA on , PLL off) */
1596	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_state_byte_2__power_state_mode, TDA182I4_PowerStandbyWithLtOnWithXtalOn, Bus_NoRead);
1597	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1598	if(err == TM_OK)
1599	{
1600	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_2__AGC1_FastStbyLT_Enable, 0x00, Bus_NoRead);
1601	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1602	}
1603	if(err == TM_OK)
1604	{
1605	/* Disable PD_LNA */
1606	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_1__PD_LNA, 0x00, Bus_NoRead);
1607	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1608	}
1609	}
1610	else
1611	{
1612	/* Set power state to stdby default 16Mhz ( XTOUT on , LT/LNA off , PLL off) */
1613	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_state_byte_2__power_state_mode, TDA182I4_PowerStandbyWithXtalOn, Bus_NoRead);
1614	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
1615	}
1616
1617	}
1618	if(err == TM_OK)
1619	{
1620	pObj->curPowerState = tmPowerStandby;
1621	}
1622
1623	}
1624
1625	_MUTEX_RELEASE(TDA182I4)
1626
1627	return err;
1628	}
1629
1630	/============================================================================/
1631	/* FUNCTION: tmbslTDA182I4_GetIF: */
1632	/* */
1633	/* DESCRIPTION: Gets programmed IF. */
1634	/* */
1635	/* RETURN: TM_OK if no error */
1636	/* */
1637	/============================================================================/
1638	tmErrorCode_t
1639	tmbslTDA182I4_GetIF(
1640	tmUnitSelect_t tUnit, /* I: Unit number */
1641	UInt32* puIF /* O: IF Frequency in hertz */
1642	)
1643	{
1644	pTDA182I4Object_t pObj = Null;
1645	tmErrorCode_t err = TM_OK;
1646
1647	/* Get a driver instance */
1648	err = iTDA182I4_GetInstance(tUnit, &pObj);
1649
1650	_MUTEX_ACQUIRE(TDA182I4)
1651
1652	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_GetIF(0x%08X)", tUnit);
1653
1654	/* Test parameter(s) */
1655	if( pObj->StandardMode<=TDA182I4_StandardMode_Unknown
1656	\|\| pObj->StandardMode>=TDA182I4_StandardMode_Max
1657	\|\| pObj->pStandard == Null
1658	\|\| puIF == Null)
1659	{
1660	err = TDA182I4_ERR_BAD_PARAMETER;
1661	}
1662
1663	if(err == TM_OK)
1664	{
1665	*puIF = pObj->pStandard->IF - pObj->pStandard->CF_Offset;
1666	}
1667
1668	_MUTEX_RELEASE(TDA182I4)
1669
1670	return err;
1671	}
1672
1673	/============================================================================/
1674	/* FUNCTION: tmbslTDA182I4_GetCF_Offset: */
1675	/* */
1676	/* DESCRIPTION: Gets CF Offset. */
1677	/* */
1678	/* RETURN: TM_OK if no error */
1679	/* */
1680	/============================================================================/
1681	tmErrorCode_t
1682	tmbslTDA182I4_GetCF_Offset(
1683	tmUnitSelect_t tUnit, /* I: Unit number */
1684	UInt32* puOffset /* O: Center frequency offset in hertz */
1685	)
1686	{
1687	pTDA182I4Object_t pObj = Null;
1688	tmErrorCode_t err = TM_OK;
1689
1690	/* Get a driver instance */
1691	err = iTDA182I4_GetInstance(tUnit, &pObj);
1692
1693	_MUTEX_ACQUIRE(TDA182I4)
1694
1695	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_GetCF_Offset(0x%08X)", tUnit);
1696
1697	/* Test parameter(s) */
1698	if( pObj->StandardMode<=TDA182I4_StandardMode_Unknown
1699	\|\| pObj->StandardMode>=TDA182I4_StandardMode_Max
1700	\|\| pObj->pStandard == Null
1701	\|\| puOffset == Null)
1702	{
1703	err = TDA182I4_ERR_BAD_PARAMETER;
1704	}
1705
1706	if(err == TM_OK)
1707	{
1708	*puOffset = pObj->pStandard->CF_Offset;
1709	}
1710
1711	_MUTEX_RELEASE(TDA182I4)
1712
1713	return err;
1714	}
1715
1716	/============================================================================/
1717	/* FUNCTION: tmbslTDA182I4_GetLockStatus: */
1718	/* */
1719	/* DESCRIPTION: Gets PLL Lock Status. */
1720	/* */
1721	/* RETURN: TM_OK if no error */
1722	/* */
1723	/============================================================================/
1724	tmErrorCode_t
1725	tmbslTDA182I4_GetLockStatus(
1726	tmUnitSelect_t tUnit, /* I: Unit number */
1727	tmbslFrontEndState_t* pLockStatus /* O: PLL Lock status */
1728	)
1729	{
1730	pTDA182I4Object_t pObj = Null;
1731	tmErrorCode_t err = TM_OK;
1732	UInt8 uValue = 0, uValueLO = 0;
1733
1734	/* Get a driver instance */
1735	err = iTDA182I4_GetInstance(tUnit, &pObj);
1736
1737	_MUTEX_ACQUIRE(TDA182I4)
1738
1739	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_GetLockStatus(0x%08X)", tUnit);
1740
1741	if( pLockStatus == Null )
1742	{
1743	err = TDA182I4_ERR_BAD_PARAMETER;
1744	}
1745
1746	if(err == TM_OK)
1747	{
1748	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Power_state_byte_1__LO_Lock, &uValueLO, Bus_RW);
1749	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
1750
1751	if(err == TM_OK)
1752	{
1753	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_IRQ_status__IRQ_status, &uValue, Bus_RW);
1754	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
1755	}
1756
1757	if(err == TM_OK)
1758	{
1759	uValue = uValue & uValueLO;
1760
1761	*pLockStatus = (uValue)? tmbslFrontEndStateLocked : tmbslFrontEndStateNotLocked;
1762	}
1763	else
1764	{
1765	*pLockStatus = tmbslFrontEndStateUnknown;
1766	}
1767	}
1768
1769	_MUTEX_RELEASE(TDA182I4)
1770
1771	return err;
1772	}
1773
1774	/============================================================================/
1775	/* FUNCTION: tmbslTDA182I4_GetAgcStatus: */
1776	/* */
1777	/* DESCRIPTION: Gets AGC Status. (Lock and/or set to Max) */
1778	/* */
1779	/* RETURN: TM_OK if no error */
1780	/* */
1781	/============================================================================/
1782	tmErrorCode_t
1783	tmbslTDA182I4_GetAgcStatus(
1784	tmUnitSelect_t tUnit, /* I: Unit number */
1785	Bool* pbAgcLock, /* O: AGC Lock status */
1786	Bool* pbAgcMax /* O: AGC Max status */
1787	)
1788	{
1789	pTDA182I4Object_t pObj = Null;
1790	tmErrorCode_t err = TM_OK;
1791	UInt8 uAgcMax = 0, uAgcLock = 0;
1792
1793	/* Get a driver instance */
1794	err = iTDA182I4_GetInstance(tUnit, &pObj);
1795
1796	_MUTEX_ACQUIRE(TDA182I4)
1797
1798	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_GetAgcStatus(0x%08X)", tUnit);
1799
1800	if( (pbAgcLock == Null) \|\| (pbAgcMax == Null) )
1801	{
1802	err = TDA182I4_ERR_BAD_PARAMETER;
1803	}
1804
1805	if(err == TM_OK)
1806	{
1807	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Power_state_byte_1__AGCs_Max, &uAgcMax, Bus_RW);
1808	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
1809
1810	if(err == TM_OK)
1811	{
1812	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Power_state_byte_1__AGCs_Lock, &uAgcLock, Bus_None);
1813	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
1814	}
1815
1816	if(err == TM_OK)
1817	{
1818	*pbAgcMax = (uAgcMax)? True : False;
1819	*pbAgcLock = (uAgcLock)? True : False;
1820	}
1821	else
1822	{
1823	pbAgcMax = pbAgcLock = False;
1824	}
1825	}
1826
1827	_MUTEX_RELEASE(TDA182I4)
1828
1829	return err;
1830	}
1831
1832	/============================================================================/
1833	/* FUNCTION: tmbslTDA182I4_GetPowerLevel: */
1834	/* */
1835	/* DESCRIPTION: Gets HW Power Level. 1/2 steps dBµV */
1836	/* */
1837	/* RETURN: TM_OK if no error */
1838	/* */
1839	/* NOTES: */
1840	/* */
1841	/============================================================================/
1842	tmErrorCode_t
1843	tmbslTDA182I4_GetPowerLevel
1844	(
1845	tmUnitSelect_t tUnit, /* I: Unit number */
1846	UInt8* pPowerLevel /* O: Power Level in 1/2 steps dBµV */
1847	)
1848	{
1849	pTDA182I4Object_t pObj = Null;
1850	tmErrorCode_t err = TM_OK;
1851	UInt8 index = 0;
1852	Int16 PldErr = 0;
1853	Int16 PldErrRound = 0;
1854	UInt16 uProgRF = 0; /* Mhz * 10 */
1855	UInt16 uRfAgc = 0;
1856	UInt8 uAGC1 = 0;
1857
1858	/* Get a driver instance */
1859	err = iTDA182I4_GetInstance(tUnit, &pObj);
1860
1861	_MUTEX_ACQUIRE(TDA182I4)
1862
1863	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_GetPowerLevel(0x%08X)", tUnit);
1864
1865	/* Test parameter(s) */
1866	if( pPowerLevel == Null \|\|
1867	pObj->StandardMode<=TDA182I4_StandardMode_Unknown \|\|
1868	pObj->StandardMode>=TDA182I4_StandardMode_Max \|\|
1869	pObj->pStandard == Null)
1870	{
1871	err = TDA182I4_ERR_BAD_PARAMETER;
1872	}
1873
1874	if(err == TM_OK)
1875	{
1876	*pPowerLevel = 0;
1877
1878	/* Read Power Level */
1879	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Power_Level_byte_1__Power_Level_, pPowerLevel, Bus_RW);
1880	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", tUnit));
1881	}
1882	if (err == TM_OK)
1883	{
1884	uProgRF = (UInt16) (pObj->uProgRF / 100000); /* from Hz to Mhz10 /
1885	index = PldRfCorrection_length;
1886	/* retreive correction fct( RF) */
1887	do {
1888	index = index -1;
1889	} while ( uProgRF < PldRFCorrection[index].Freq ) ;
1890	PldErr = PldRFCorrection[index].Correction;
1891	}
1892	if (err == TM_OK)
1893	{
1894	/* retreive correction fct( RfAgc, AGC1) */
1895	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_RFAGCs_Gain_byte_5__RFAGC_Read_K_8, &index, Bus_RW);
1896	uRfAgc = uRfAgc + ( index << 8);
1897	}
1898	if (err == TM_OK)
1899	{
1900	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_RFAGCs_Gain_byte_6__RFAGC_Read_K, &index, Bus_RW);
1901	uRfAgc = uRfAgc + index;
1902	}
1903	if (err == TM_OK)
1904	{
1905	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_RFAGCs_Gain_byte_3__AGC1_Gain_Read, &uAGC1, Bus_RW);
1906	}
1907
1908	if (err == TM_OK)
1909	{
1910	index = PldRfAgcCorrection_length;
1911	do {
1912	index = index -1;
1913	} while ( uRfAgc < PldRfAgcCorrection[index].RfAgc ) ;
1914	PldErr = PldErr + ( uAGC1 == 11 ? PldRfAgcCorrection[index].Correction_22: PldRfAgcCorrection[index].Correction_no22 ) ;
1915	}
1916
1917	/* -0.3 dB offset correction due to modulation */
1918	PldErr = PldErr - 6;
1919
1920	/* from PldErr in 1/2 step 10 convert and round to 1/2 step /
1921	PldErrRound = PldErr / 10;
1922	if (PldErr > 0)
1923	{
1924	PldErrRound = ((PldErr - (PldErrRound * 10) > 5) ? PldErrRound +1 : PldErrRound) ;
1925	}
1926	else
1927	{
1928	PldErrRound = (((PldErrRound * 10) - PldErr > 5) ? PldErrRound -1 : PldErrRound) ;
1929	}
1930
1931	pPowerLevel = pPowerLevel - (Int8) PldErrRound;
1932
1933	_MUTEX_RELEASE(TDA182I4)
1934
1935	return err;
1936	}
1937
1938	/============================================================================/
1939	/* FUNCTION: tmbslTDA182I4_SetInternalVsync: */
1940	/* */
1941	/* DESCRIPTION: Enables or disable the internal VSYNC */
1942	/* */
1943	/* RETURN: TM_OK if no error */
1944	/* */
1945	/* NOTES: */
1946	/* */
1947	/============================================================================/
1948	tmErrorCode_t
1949	tmbslTDA182I4_SetInternalVsync(
1950	tmUnitSelect_t tUnit, /* I: Unit number */
1951	Bool bEnabled /* I: Enable of disable the internal VSYNC */
1952	)
1953	{
1954	pTDA182I4Object_t pObj = Null;
1955	tmErrorCode_t err = TM_OK;
1956
1957	/* Get a driver instance */
1958	err = iTDA182I4_GetInstance(tUnit, &pObj);
1959
1960	_MUTEX_ACQUIRE(TDA182I4)
1961
1962	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_SetInternalVsync(0x%08X)", tUnit);
1963
1964	if(err == TM_OK)
1965	{
1966	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Vsync_byte__vsync_Int, ((bEnabled == True) ? 1 : 0), Bus_RW);
1967	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", tUnit));
1968	}
1969
1970	_MUTEX_RELEASE(TDA182I4)
1971
1972	return err;
1973	}
1974
1975	/============================================================================/
1976	/* FUNCTION: tmbslTDA182I4_GetInternalVsync: */
1977	/* */
1978	/* DESCRIPTION: Get the current status of the internal VSYNC */
1979	/* */
1980	/* RETURN: TM_OK if no error */
1981	/* */
1982	/* NOTES: */
1983	/* */
1984	/============================================================================/
1985	tmErrorCode_t
1986	tmbslTDA182I4_GetInternalVsync(
1987	tmUnitSelect_t tUnit, /* I: Unit number */
1988	Bool* pbEnabled /* O: current status of the internal VSYNC */
1989	)
1990	{
1991	pTDA182I4Object_t pObj = Null;
1992	tmErrorCode_t err = TM_OK;
1993	UInt8 uValue;
1994
1995	/* Get a driver instance */
1996	err = iTDA182I4_GetInstance(tUnit, &pObj);
1997
1998	_MUTEX_ACQUIRE(TDA182I4)
1999
2000	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_SetInternalVsync(0x%08X)", tUnit);
2001
2002	if(pbEnabled == Null)
2003	{
2004	err = TDA182I4_ERR_BAD_PARAMETER;
2005	}
2006
2007	if(err == TM_OK)
2008	{
2009	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Vsync_byte__vsync_Int, &uValue, Bus_RW);
2010	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", tUnit));
2011	}
2012
2013	if(err == TM_OK)
2014	{
2015	if (uValue == 1)
2016	{
2017	*pbEnabled = True;
2018	}
2019	else
2020	{
2021	*pbEnabled = False;
2022	}
2023	}
2024
2025	_MUTEX_RELEASE(TDA182I4)
2026
2027	return err;
2028	}
2029
2030	/============================================================================/
2031	/* FUNCTION: tmbslTDA182I4_SetPllManual: */
2032	/* */
2033	/* DESCRIPTION: Sets bOverridePLL flag. */
2034	/* */
2035	/* RETURN: TM_OK if no error */
2036	/* */
2037	/============================================================================/
2038	tmErrorCode_t
2039	tmbslTDA182I4_SetPllManual(
2040	tmUnitSelect_t tUnit, /* I: Unit number */
2041	Bool bOverridePLL /* I: Determine if we need to put PLL in manual mode in SetRF */
2042	)
2043	{
2044	pTDA182I4Object_t pObj = Null;
2045	tmErrorCode_t err = TM_OK;
2046
2047	/* Get a driver instance */
2048	err = iTDA182I4_GetInstance(tUnit, &pObj);
2049
2050	_MUTEX_ACQUIRE(TDA182I4)
2051
2052	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_SetPllManual(0x%08X)", tUnit);
2053
2054	pObj->bOverridePLL = bOverridePLL;
2055
2056	_MUTEX_RELEASE(TDA182I4)
2057
2058	return err;
2059	}
2060
2061	/============================================================================/
2062	/* FUNCTION: tmbslTDA182I4_GetPllManual: */
2063	/* */
2064	/* DESCRIPTION: Gets bOverridePLL flag. */
2065	/* */
2066	/* RETURN: TM_OK if no error */
2067	/* */
2068	/============================================================================/
2069	tmErrorCode_t
2070	tmbslTDA182I4_GetPllManual(
2071	tmUnitSelect_t tUnit, /* I: Unit number */
2072	Bool* pbOverridePLL /* O: Determine if we need to put PLL in manual mode in SetRF */
2073	)
2074	{
2075	pTDA182I4Object_t pObj = Null;
2076	tmErrorCode_t err = TM_OK;
2077
2078	/* Get a driver instance */
2079	err = iTDA182I4_GetInstance(tUnit, &pObj);
2080
2081	_MUTEX_ACQUIRE(TDA182I4)
2082
2083	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_GetPllManual(0x%08X)", tUnit);
2084
2085	if(pbOverridePLL == Null)
2086	{
2087	err = TDA182I4_ERR_BAD_PARAMETER;
2088	}
2089
2090	if(err == TM_OK)
2091	{
2092	*pbOverridePLL = pObj->bOverridePLL;
2093	}
2094
2095	_MUTEX_RELEASE(TDA182I4)
2096
2097	return err;
2098	}
2099
2100	/============================================================================/
2101	/* FUNCTION: tmbslTDA182I4_GetIRQ: */
2102	/* */
2103	/* DESCRIPTION: Gets IRQ status. */
2104	/* */
2105	/* RETURN: TM_OK if no error */
2106	/* */
2107	/============================================================================/
2108	tmErrorCode_t
2109	tmbslTDA182I4_GetIRQ(
2110	tmUnitSelect_t tUnit /* I: Unit number */,
2111	Bool* pbIRQ /* O: IRQ triggered */
2112	)
2113	{
2114	pTDA182I4Object_t pObj = Null;
2115	tmErrorCode_t err = TM_OK;
2116	UInt8 uValue = 0;
2117
2118	/* Get a driver instance */
2119	err = iTDA182I4_GetInstance(tUnit, &pObj);
2120
2121	_MUTEX_ACQUIRE(TDA182I4)
2122
2123	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_GetIRQ(0x%08X)", tUnit);
2124
2125	if(pbIRQ == Null)
2126	{
2127	err = TDA182I4_ERR_BAD_PARAMETER;
2128	}
2129
2130	if(err == TM_OK)
2131	{
2132	*pbIRQ = 0;
2133
2134	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_IRQ_status__IRQ_status, &uValue, Bus_RW);
2135	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
2136
2137	if(err == TM_OK)
2138	{
2139	*pbIRQ = uValue;
2140	}
2141	}
2142
2143	_MUTEX_RELEASE(TDA182I4)
2144
2145	return err;
2146	}
2147
2148	/============================================================================/
2149	/* FUNCTION: tmbslTDA182I4_WaitIRQ: */
2150	/* */
2151	/* DESCRIPTION: Waits for the IRQ to raise. */
2152	/* */
2153	/* RETURN: TM_OK if no error */
2154	/* */
2155	/============================================================================/
2156	tmErrorCode_t
2157	tmbslTDA182I4_WaitIRQ(
2158	tmUnitSelect_t tUnit, /* I: Unit number */
2159	UInt32 timeOut, /* I: timeOut for IRQ wait */
2160	UInt32 waitStep, /* I: wait step */
2161	UInt8 irqStatus /* I: IRQs to wait */
2162	)
2163	{
2164	pTDA182I4Object_t pObj = Null;
2165	tmErrorCode_t err = TM_OK;
2166
2167	/* Get a driver instance */
2168	err = iTDA182I4_GetInstance(tUnit, &pObj);
2169
2170	_MUTEX_ACQUIRE(TDA182I4)
2171
2172	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_WaitIRQ(0x%08X)", tUnit);
2173
2174	err = iTDA182I4_WaitIRQ(pObj, timeOut, waitStep, irqStatus);
2175	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_WaitIRQ(0x%08X) failed.", tUnit));
2176
2177	_MUTEX_RELEASE(TDA182I4)
2178
2179	return err;
2180	}
2181
2182	/============================================================================/
2183	/* FUNCTION: tmbslTDA182I4_GetXtalCal_End: */
2184	/* */
2185	/* DESCRIPTION: Gets XtalCal_End status. */
2186	/* */
2187	/* RETURN: TM_OK if no error */
2188	/* */
2189	/============================================================================/
2190	tmErrorCode_t
2191	tmbslTDA182I4_GetXtalCal_End(
2192	tmUnitSelect_t tUnit /* I: Unit number */,
2193	Bool* pbXtalCal_End /* O: XtalCal_End triggered */
2194	)
2195	{
2196	pTDA182I4Object_t pObj = Null;
2197	tmErrorCode_t err = TM_OK;
2198	UInt8 uValue = 0;
2199
2200	/* Get a driver instance */
2201	err = iTDA182I4_GetInstance(tUnit, &pObj);
2202
2203	_MUTEX_ACQUIRE(TDA182I4)
2204
2205	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_GetXtalCal_End(0x%08X)", tUnit);
2206
2207	if(pbXtalCal_End == Null)
2208	{
2209	err = TDA182I4_ERR_BAD_PARAMETER;
2210	}
2211
2212	if(err == TM_OK)
2213	{
2214	*pbXtalCal_End = 0;
2215
2216	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_IRQ_status__XtalCal_End, &uValue, Bus_RW);
2217	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
2218
2219	if(err == TM_OK)
2220	{
2221	*pbXtalCal_End = uValue;
2222	}
2223	}
2224
2225	_MUTEX_RELEASE(TDA182I4)
2226
2227	return err;
2228	}
2229
2230	/============================================================================/
2231	/* FUNCTION: tmbslTDA182I4_SetFineRF: */
2232	/* */
2233	/* DESCRIPTION: Fine tunes RF with given step. */
2234	/* (tmbslTDA182I4_SetRF must be called before calling this API) */
2235	/* RETURN: TM_OK if no error */
2236	/* */
2237	/============================================================================/
2238	tmErrorCode_t
2239	tmbslTDA182I4_SetFineRF(
2240	tmUnitSelect_t tUnit, /* I: Unit number */
2241	Int8 step /* I: step (-1, +1) */
2242	)
2243	{
2244	pTDA182I4Object_t pObj = Null;
2245	tmErrorCode_t err = TM_OK;
2246
2247	/* LO wanted = RF wanted + IF in KHz */
2248	UInt32 LO = 0;
2249
2250	/* PostDiv */
2251	UInt8 PostDiv = 0;
2252	UInt8 LOPostDiv = 0;
2253
2254	/* Prescaler */
2255	UInt8 Prescaler = 0;
2256
2257	/* Algorithm that calculates N, K */
2258	UInt32 N_int = 0;
2259	UInt32 K_int = 0;
2260
2261	UInt8 i = 0;
2262
2263	/* Get a driver instance */
2264	err = iTDA182I4_GetInstance(tUnit, &pObj);
2265
2266	_MUTEX_ACQUIRE(TDA182I4)
2267
2268	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_SetFineRF(0x%08X)", tUnit);
2269
2270	/* Test parameter(s) */
2271	if( pObj->StandardMode<=TDA182I4_StandardMode_Unknown
2272	\|\| pObj->StandardMode>=TDA182I4_StandardMode_Max
2273	\|\| pObj->pStandard == Null)
2274	{
2275	err = TDA182I4_ERR_STD_NOT_SET;
2276	}
2277
2278	if(err == TM_OK)
2279	{
2280	/* Check if Hw is ready to operate */
2281	err = iTDA182I4_CheckHwState(pObj, TDA182I4_HwStateCaller_SetFineRF);
2282	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_CheckHwState(0x%08X) failed.", pObj->tUnitW));
2283	}
2284
2285	if(err == TM_OK)
2286	{
2287	/* Write the offset into 4 equal steps of 15.625 KHz = 62.5 KHz*/
2288	for (i=0; i < 4; i++)
2289	{
2290	/* Calculate wanted LO = RF + IF */
2291	pObj->uRF += step*15625;
2292	pObj->uProgRF += step*15625;
2293	LO = (pObj->uRF + pObj->pStandard->IF)/1000;
2294
2295	/* Don't touch on Prescaler and PostDiv programmed during setRF */
2296	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Main_Post_Divider_byte__LOPostDiv, &LOPostDiv, Bus_RW);
2297	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
2298
2299	if(err == TM_OK)
2300	{
2301	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Main_Post_Divider_byte__LOPresc, &Prescaler, Bus_None);
2302	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
2303	}
2304
2305	if (err == TM_OK)
2306	{
2307	/* Decode PostDiv */
2308	switch(LOPostDiv)
2309	{
2310	case 1:
2311	PostDiv = 1;
2312	break;
2313	case 2:
2314	PostDiv = 2;
2315	break;
2316	case 3:
2317	PostDiv = 4;
2318	break;
2319	case 4:
2320	PostDiv = 8;
2321	break;
2322	case 5:
2323	PostDiv = 16;
2324	break;
2325	default:
2326	err = TDA182I4_ERR_BAD_PARAMETER;
2327	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "tmbslTDA182I4_SetFineRF(0x%08X) LO_PostDiv value is wrong.", tUnit));
2328	break;
2329	}
2330
2331	/* Calculate N & K values of the PLL */
2332	err = iTDA182I4_CalculateNIntKInt(LO, PostDiv, Prescaler, &N_int, &K_int);
2333
2334	/* Affect registers */
2335	if(err == TM_OK)
2336	{
2337	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_4__LO_Frac_0, (UInt8)(K_int & 0xFF), Bus_None);
2338	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2339	}
2340
2341	if(err == TM_OK)
2342	{
2343	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_3__LO_Frac_1, (UInt8)((K_int >> 8) & 0xFF), Bus_None);
2344	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2345	}
2346
2347	if(err == TM_OK)
2348	{
2349	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_2__LO_Frac_2, (UInt8)((K_int >> 16) & 0xFF), Bus_None);
2350	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2351	}
2352
2353	if(err == TM_OK)
2354	{
2355	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_1__LO_Int, (UInt8)(N_int & 0xFF), Bus_None);
2356	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2357	}
2358
2359	if(err == TM_OK)
2360	{
2361	/* Force manual selection mode : 0x7 at @0x56 */
2362	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_5__N_K_correct_manual, 0x01, Bus_None);
2363	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2364
2365	if(err == TM_OK)
2366	{
2367	/* Force manual selection mode : 0x7 at @0x56 */
2368	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_5__LO_Calc_Disable, 0x01, Bus_None);
2369	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2370	}
2371	}
2372
2373	/* Set the new PLL values */
2374	if(err == TM_OK)
2375	{
2376	/* Write bytes Sigma_delta_byte_1 (0x52) to Sigma_delta_byte_5 (0x56) */
2377	err = iTDA182I4_WriteRegMap(pObj, gTDA182I4_Reg_Sigma_delta_byte_1.Address, TDA182I4_REG_DATA_LEN(gTDA182I4_Reg_Sigma_delta_byte_1, gTDA182I4_Reg_Sigma_delta_byte_5));
2378	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2379	}
2380	}
2381	}
2382
2383	/* Update driver state machine */
2384	pObj->eHwState = TDA182I4_HwState_SetFineRFDone;
2385	}
2386
2387	_MUTEX_RELEASE(TDA182I4)
2388
2389	return err;
2390	}
2391
2392	/============================================================================/
2393	/* FUNCTION: tmbslTDA182I4_Write */
2394	/* */
2395	/* DESCRIPTION: Writes in TDA182I4 hardware */
2396	/* */
2397	/* RETURN: TM_OK if no error */
2398	/* */
2399	/* NOTES: */
2400	/* */
2401	/============================================================================/
2402	tmErrorCode_t
2403	tmbslTDA182I4_Write(
2404	tmUnitSelect_t tUnit, /* I: Unit number */
2405	const TDA182I4_BitField_t* pBitField, /* I: Bitfield structure */
2406	UInt8 uData, /* I: Data to write */
2407	tmbslFrontEndBusAccess_t eBusAccess /* I: Access to bus */
2408	)
2409	{
2410	pTDA182I4Object_t pObj = Null;
2411	tmErrorCode_t err = TM_OK;
2412
2413	/* Get a driver instance */
2414	err = iTDA182I4_GetInstance(tUnit, &pObj);
2415
2416	_MUTEX_ACQUIRE(TDA182I4)
2417
2418	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_Write(0x%08X)", tUnit);
2419
2420	err = iTDA182I4_Write(pObj, pBitField, uData, eBusAccess);
2421	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2422
2423	_MUTEX_RELEASE(TDA182I4)
2424
2425	return err;
2426	}
2427
2428	/============================================================================/
2429	/* FUNCTION: tmbslTDA182I4_Read */
2430	/* */
2431	/* DESCRIPTION: Reads in TDA182I4 hardware */
2432	/* */
2433	/* RETURN: TM_OK if no error */
2434	/* */
2435	/* NOTES: */
2436	/* */
2437	/============================================================================/
2438	tmErrorCode_t
2439	tmbslTDA182I4_Read(
2440	tmUnitSelect_t tUnit, /* I: Unit number */
2441	const TDA182I4_BitField_t* pBitField, /* I: Bitfield structure */
2442	UInt8* puData, /* I: Data to read */
2443	tmbslFrontEndBusAccess_t eBusAccess /* I: Access to bus */
2444	)
2445	{
2446	pTDA182I4Object_t pObj = Null;
2447	tmErrorCode_t err = TM_OK;
2448
2449	/* Get a driver instance */
2450	err = iTDA182I4_GetInstance(tUnit, &pObj);
2451
2452	_MUTEX_ACQUIRE(TDA182I4)
2453
2454	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_Read(0x%08X)", tUnit);
2455
2456	err = iTDA182I4_Read(pObj, pBitField, puData, eBusAccess);
2457	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
2458
2459	_MUTEX_RELEASE(TDA182I4)
2460
2461	return err;
2462	}
2463	/============================================================================/
2464	/* FUNCTION: tmbslTDA182I4_SetFEF */
2465	/* */
2466	/* DESCRIPTION: Activate/desactive FEF settings DVB-T2 in */
2467	/* tmbslTDA182I4_SetStandard() API */
2468	/* */
2469	/* RETURN: TM_OK if no error */
2470	/* */
2471	/* NOTES: */
2472	/* */
2473	/============================================================================/
2474	tmErrorCode_t
2475	tmbslTDA182I4_SetFEF(
2476	tmUnitSelect_t tUnit, /* I: Unit number */
2477	Bool bFefEnable /* Activate/desactivate FEF settings for DVB-T/T2 */
2478	)
2479	{
2480	pTDA182I4Object_t pObj = Null;
2481	tmErrorCode_t err = TM_OK;
2482
2483	/* Get a driver instance */
2484	err = iTDA182I4_GetInstance(tUnit, &pObj);
2485
2486	_MUTEX_ACQUIRE(TDA182I4)
2487
2488	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_SetFEF(0x%08X)", tUnit);
2489
2490	pObj->bFefEnable = bFefEnable;
2491
2492	_MUTEX_RELEASE(TDA182I4)
2493
2494	return err;
2495	}
2496	/============================================================================/
2497	/* FUNCTION: tmbslTDA182I4_GetFEF */
2498	/* */
2499	/* DESCRIPTION: get status Activate/desactive FEF settings DVB-T2 in */
2500	/* tmbslTDA182I4_SetStandard() API */
2501	/* */
2502	/* RETURN: TM_OK if no error */
2503	/* */
2504	/* NOTES: */
2505	/* */
2506	/============================================================================/
2507	tmErrorCode_t
2508	tmbslTDA182I4_GetFEF(
2509	tmUnitSelect_t tUnit, /* I: Unit number */
2510	Bool* bFefEnable /* get FEF settings for DVB-T/T2 status*/
2511	)
2512	{
2513	pTDA182I4Object_t pObj = Null;
2514	tmErrorCode_t err = TM_OK;
2515
2516	/* Get a driver instance */
2517	err = iTDA182I4_GetInstance(tUnit, &pObj);
2518
2519	_MUTEX_ACQUIRE(TDA182I4)
2520
2521	tmDBGPRINTEx(DEBUGLVL_INOUT, "tmbslTDA182I4_GetFEF(0x%08X)", tUnit);
2522
2523	*bFefEnable = pObj->bFefEnable;
2524
2525	_MUTEX_RELEASE(TDA182I4)
2526
2527	return err;
2528	}
2529	/============================================================================/
2530	/* Internal functions: */
2531	/============================================================================/
2532
2533	/============================================================================/
2534	/* FUNCTION: iTDA182I4_CheckHwState */
2535	/* */
2536	/* DESCRIPTION: Checks if Hw is ready to operate. */
2537	/* */
2538	/* RETURN: TM_OK if no error */
2539	/* */
2540	/============================================================================/
2541	tmErrorCode_t
2542	iTDA182I4_CheckHwState(
2543	pTDA182I4Object_t pObj, /* I: Driver object */
2544	TDA182I4HwStateCaller_t caller /* I: Caller API */
2545	)
2546	{
2547	tmErrorCode_t err = TM_OK;
2548
2549	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_CheckHwState(0x%08X)", pObj->tUnitW);
2550
2551	switch(pObj->eHwState)
2552	{
2553	case TDA182I4_HwState_InitNotDone:
2554	switch(caller)
2555	{
2556	case TDA182I4_HwStateCaller_SetPower:
2557	break;
2558
2559	default:
2560	err = TDA182I4_ERR_NOT_INITIALIZED;
2561	break;
2562	}
2563	break;
2564
2565	case TDA182I4_HwState_InitDone:
2566	switch(caller)
2567	{
2568	case TDA182I4_HwStateCaller_SetRF:
2569	case TDA182I4_HwStateCaller_SetFineRF:
2570	/* SetStandardMode API must be called before calling SetRF and SetFineRF */
2571	err = TDA182I4_ERR_STD_NOT_SET;
2572	break;
2573
2574	default:
2575	break;
2576	}
2577	break;
2578
2579	case TDA182I4_HwState_SetStdDone:
2580	switch(caller)
2581	{
2582	case TDA182I4_HwStateCaller_SetFineRF:
2583	/* SetRF API must be called before calling SetFineRF */
2584	err = TDA182I4_ERR_RF_NOT_SET;
2585	break;
2586
2587	default:
2588	break;
2589	}
2590	break;
2591
2592	case TDA182I4_HwState_SetRFDone:
2593	case TDA182I4_HwState_SetFineRFDone:
2594	break;
2595
2596	case TDA182I4_HwState_InitPending:
2597	err = TDA182I4_ERR_NOT_READY;
2598	break;
2599	default:
2600	err = TDA182I4_ERR_NOT_READY;
2601	break;
2602	}
2603
2604	return err;
2605	}
2606
2607	/============================================================================/
2608	/* FUNCTION: iTDA182I4_CheckCalcPLL */
2609	/* */
2610	/* DESCRIPTION: Checks if CalcPLL Algo is enabled. Enable it if not. */
2611	/* */
2612	/* RETURN: TM_OK if no error */
2613	/* */
2614	/============================================================================/
2615	tmErrorCode_t
2616	iTDA182I4_CheckCalcPLL(
2617	pTDA182I4Object_t pObj /* I: Driver object */
2618	)
2619	{
2620	tmErrorCode_t err = TM_OK;
2621	UInt8 uValue = 0;
2622
2623	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_CheckCalcPLL(0x%08X)", pObj->tUnitW);
2624
2625	/* Check if Calc_PLL algorithm is in automatic mode */
2626	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Sigma_delta_byte_5__LO_Calc_Disable, &uValue, Bus_None);
2627	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
2628
2629	if(err == TM_OK && uValue != 0x00)
2630	{
2631	/* Enable Calc_PLL algorithm by putting PLL in automatic mode */
2632	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_5__N_K_correct_manual, 0x00, Bus_None);
2633	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2634
2635	if(err == TM_OK)
2636	{
2637	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_5__LO_Calc_Disable, 0x00, Bus_NoRead);
2638	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2639	}
2640	}
2641
2642	return err;
2643	}
2644
2645	/============================================================================/
2646	/* FUNCTION: iTDA182I4_SetLLPowerState */
2647	/* */
2648	/* DESCRIPTION: Sets the power state. */
2649	/* */
2650	/* RETURN: TM_OK if no error */
2651	/* */
2652	/============================================================================/
2653	static tmErrorCode_t
2654	iTDA182I4_SetLLPowerState(
2655	pTDA182I4Object_t pObj, /* I: Driver object */
2656	TDA182I4PowerState_t powerState /* I: Power state of TDA182I4 */
2657	)
2658	{
2659	tmErrorCode_t err = TM_OK;
2660	UInt8 uValue = 0;
2661	UInt8 counter =0;
2662
2663	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_SetLLPowerState(0x%08X)", pObj->tUnitW);
2664
2665	if(err == TM_OK)
2666	{
2667	/* Check if Hw is ready to operate */
2668	err = iTDA182I4_CheckHwState(pObj, TDA182I4_HwStateCaller_SetPower);
2669	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_CheckHwState(0x%08X) failed.", pObj->tUnitW));
2670	}
2671
2672	if(err == TM_OK)
2673	{
2674	switch(powerState)
2675	{
2676	case TDA182I4_PowerNormalMode:
2677	if(err == TM_OK)
2678	{
2679	/LT_smooth_t_cst -> 6 /
2680	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_2__LT_smooth_t_cst, 0x06, Bus_None);
2681	/LT_smooth_t__fast -> 1 /
2682	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_2__LT_smooth_t_cst_fast, 0x01, Bus_NoRead);
2683	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2684	}
2685	if(err == TM_OK)
2686	{
2687	/* AGC1_smooth_t_cst -> 6 */
2688	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_4__AGC1_smooth_t_cst, 0x06, Bus_None);
2689	/* AGC1_smooth_t_cst_fast -> 1 */
2690	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_4__AGC1_smooth_t_cst_fast, 0x01, Bus_NoRead);
2691	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2692	}
2693	if(err == TM_OK)
2694	{
2695	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_state_byte_2__power_state_mode, powerState, Bus_NoRead);
2696	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2697	}
2698	if(err == TM_OK)
2699	{
2700	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_AGC1_byte_1__PD_LNA, &uValue, Bus_None);
2701	if (uValue==1)
2702	{
2703	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_1__PD_LNA, 0x00, Bus_NoRead);
2704	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2705	}
2706	}
2707	if (pObj->TunerModeInUse & TDA182I4_Mode_STO_Used )
2708	{
2709	if(err == TM_OK)
2710	{
2711	err = iTDA182I4_Wait(pObj, 100);
2712	}
2713	if(err == TM_OK)
2714	{
2715	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_1__PD_VCO, 0x00, Bus_NoRead);
2716	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2717	}
2718	if(err == TM_OK)
2719	{
2720	err = iTDA182I4_Wait(pObj, 100);
2721	}
2722	if(err == TM_OK)
2723	{
2724	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_1__PD_Synthe, 0x00, Bus_NoRead);
2725	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2726	}
2727	if(err == TM_OK)
2728	{
2729	err = iTDA182I4_Wait(pObj, 100);
2730	}
2731	if(err == TM_OK)
2732	{
2733	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_2__PDRF_filter, 0x00, Bus_NoRead);
2734	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2735	}
2736	if(err == TM_OK)
2737	{
2738	err = iTDA182I4_Wait(pObj, 100);
2739	}
2740	if(err == TM_OK)
2741	{
2742	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_2__PD_STOB_IF, 0x00, Bus_NoRead);
2743	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2744	}
2745	if(err == TM_OK)
2746	{
2747	err = iTDA182I4_Wait(pObj, 100);
2748	}
2749	}
2750	if(err == TM_OK)
2751	{
2752	/* Set digital clock mode to sub-LO if normal mode is entered */
2753	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Reference_Byte__Dig_Clock, 0x03, Bus_NoRead);
2754	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2755	}
2756	if(err == TM_OK)
2757	{
2758	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_2__AGC1_FastStbyLT_Enable, 0x00, Bus_NoRead);
2759	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2760	}
2761
2762	break;
2763	case TDA182I4_PowerStandbyWithXtalOn:
2764	case TDA182I4_PowerStandbyWithPllOnWithXtalOn:
2765	if(err == TM_OK)
2766	{
2767	/* AGC1_smooth_t_cst -> 0 */
2768	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_4__AGC1_smooth_t_cst, 0x00, Bus_None);
2769	/* AGC1_smooth_t_cst_fast -> 0 */
2770	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_4__AGC1_smooth_t_cst_fast, 0x00, Bus_NoRead);
2771	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2772	}
2773	if(err == TM_OK)
2774	{
2775	/* LT_smooth_t_cst -> 0 */
2776	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_2__LT_smooth_t_cst, 0x00, Bus_None);
2777	/* LT_smooth_t_cst_fast -> 0 */
2778	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_2__LT_smooth_t_cst_fast, 0x00, Bus_NoRead);
2779	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2780	}
2781	if(err == TM_OK)
2782	{
2783	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_3__AGC1_loop_off, 0x01, Bus_NoRead);
2784	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2785	}
2786	counter = 10;
2787	while(counter > 0)
2788	{
2789	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_AGC1_Top_byte__AGC1_Smooth_Transition_ON, &uValue, Bus_RW);
2790	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
2791	if(err == TM_OK)
2792	{
2793	if (uValue==0) break;
2794	}
2795	if(err == TM_OK)
2796	{
2797	err = iTDA182I4_Wait(pObj, 10);
2798	}
2799	counter = counter -1;
2800	}
2801	if(err == TM_OK)
2802	{
2803	/* remove Glitch Antenna leakage : Force LNA to -11dB before PD_LNA acitvation*/
2804	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_3__AGC1_Gain, 0x00, Bus_None); /* -11dB */
2805	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_3__Force_AGC1_gain, 0x01, Bus_NoRead); /* Force LNA */
2806	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2807	}
2808	if(err == TM_OK)
2809	{
2810	/* Set digital clock mode to 16 Mhz before entering standby */
2811	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Reference_Byte__Dig_Clock, 0x02, Bus_NoRead);
2812	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2813	}
2814	if(err == TM_OK)
2815	{
2816	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_1__PD_LNA, 0x01, Bus_NoRead); /* power off LNA */
2817	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2818	}
2819	if(err == TM_OK)
2820	{
2821	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_state_byte_2__power_state_mode, powerState, Bus_NoRead);
2822	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2823	}
2824	if(err == TM_OK) /* AGC1 gain init to improve antenna leakage */
2825	{ /* save LNA_gain range */
2826	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_AGC1_byte_2__LNA_Range, &uValue, Bus_None);
2827	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2828	}
2829	if(err == TM_OK)
2830	{
2831	/* write dummy value 3 */
2832	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_2__LNA_Range, 0x03, Bus_None);
2833	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2834
2835	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_2__AGC1_FastStbyLT_Enable, 0x01, Bus_NoRead);
2836	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2837	}
2838	if(err == TM_OK)
2839	{ /* restore LNA_gain range */
2840	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_2__LNA_Range, uValue, Bus_NoRead);
2841	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2842	}
2843	if(err == TM_OK)
2844	{
2845	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_3__AGC1_loop_off, 0x00, Bus_None);
2846	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_3__Force_AGC1_gain, 0x00, Bus_NoRead); /* Free LNA */
2847	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2848	}
2849	if(err == TM_OK)
2850	{
2851	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Power_Down_byte_1__PD_VCO, &uValue, Bus_None);
2852	if (uValue==1)
2853	{
2854	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_1__PD_VCO, 0x00, Bus_None);
2855	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_1__PD_Synthe, 0x00, Bus_NoRead);
2856	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2857	}
2858	}
2859
2860	break;
2861	case TDA182I4_PowerStandbyWithLtOnWithXtalOn:
2862	if(err == TM_OK)
2863	{
2864	/LT_smooth_t_cst -> 6 /
2865	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_2__LT_smooth_t_cst, 0x06, Bus_None);
2866	/LT_smooth_t__fast -> 1 /
2867	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_2__LT_smooth_t_cst_fast, 0x01, Bus_NoRead);
2868	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2869	}
2870	if(err == TM_OK)
2871	{
2872	/* AGC1_smooth_t_cst -> 6 */
2873	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_4__AGC1_smooth_t_cst, 0x06, Bus_None);
2874	/* AGC1_smooth_t_cst_fast -> 1 */
2875	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_4__AGC1_smooth_t_cst_fast, 0x01, Bus_NoRead);
2876	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2877	}
2878	if(err == TM_OK)
2879	{
2880	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_3__Force_AGC1_gain, 0x00, Bus_NoRead); /* Free LNA */
2881	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2882	}
2883	if (pObj->TunerModeInUse & TDA182I4_Mode_STO_Used )
2884	{
2885	if(err == TM_OK)
2886	{
2887	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_2__PD_STOB_IF, 0x01, Bus_NoRead);
2888	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2889	}
2890	if(err == TM_OK)
2891	{
2892	err = iTDA182I4_Wait(pObj, 100);
2893	}
2894	if(err == TM_OK)
2895	{
2896	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_2__PDRF_filter, 0x01, Bus_NoRead);
2897	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2898	}
2899	if(err == TM_OK)
2900	{
2901	err = iTDA182I4_Wait(pObj, 100);
2902	}
2903	}
2904	if(err == TM_OK)
2905	{
2906	/* Set digital clock mode to 16 Mhz before entering standby */
2907	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Reference_Byte__Dig_Clock, 0x02, Bus_RW);
2908	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2909	}
2910	if (pObj->TunerModeInUse & TDA182I4_Mode_STO_Used )
2911	{
2912	if(err == TM_OK)
2913	{
2914	err = iTDA182I4_Wait(pObj, 100);
2915	}
2916	if(err == TM_OK)
2917	{
2918	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_1__PD_VCO, 0x01, Bus_NoRead);
2919	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2920	}
2921	if(err == TM_OK)
2922	{
2923	err = iTDA182I4_Wait(pObj, 100);
2924	}
2925	if(err == TM_OK)
2926	{
2927	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_1__PD_Synthe, 0x01, Bus_NoRead);
2928	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2929	}
2930	if(err == TM_OK)
2931	{
2932	err = iTDA182I4_Wait(pObj, 100);
2933	}
2934	}
2935	if(err == TM_OK)
2936	{
2937	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_state_byte_2__power_state_mode, powerState, Bus_RW);
2938	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2939	}
2940	if(err == TM_OK)
2941	{
2942	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_2__AGC1_FastStbyLT_Enable, 0x00, Bus_RW);
2943	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2944	}
2945	if(err == TM_OK)
2946	{
2947	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_AGC1_byte_1__PD_LNA, &uValue, Bus_None);
2948	if (uValue==1)
2949	{
2950	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_1__PD_LNA, 0x00, Bus_NoRead); /* power on LNA */
2951	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2952	}
2953	}
2954	break;
2955	case TDA182I4_PowerStandbyWithLtOnWithPllOnWithXtalOn:
2956	if(err == TM_OK)
2957	{
2958	/LT_smooth_t_cst -> 6 /
2959	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_2__LT_smooth_t_cst, 0x06, Bus_None);
2960	/LT_smooth_t__fast -> 1 /
2961	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_2__LT_smooth_t_cst_fast, 0x01, Bus_NoRead);
2962	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2963	}
2964	if(err == TM_OK)
2965	{
2966	/* AGC1_smooth_t_cst -> 6 */
2967	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_4__AGC1_smooth_t_cst, 0x06, Bus_None);
2968	/* AGC1_smooth_t_cst_fast -> 1 */
2969	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_4__AGC1_smooth_t_cst_fast, 0x01, Bus_NoRead);
2970	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2971	}
2972	if(err == TM_OK)
2973	{
2974	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_3__Force_AGC1_gain, 0x00, Bus_NoRead); /* Free LNA */
2975	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2976	}
2977	if (pObj->TunerModeInUse & TDA182I4_Mode_STO_Used )
2978	{
2979	if(err == TM_OK)
2980	{
2981	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_2__PD_STOB_IF, 0x01, Bus_NoRead);
2982	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2983	}
2984	if(err == TM_OK)
2985	{
2986	err = iTDA182I4_Wait(pObj, 100);
2987	}
2988	if(err == TM_OK)
2989	{
2990	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_2__PDRF_filter, 0x01, Bus_NoRead);
2991	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
2992	}
2993	if(err == TM_OK)
2994	{
2995	err = iTDA182I4_Wait(pObj, 100);
2996	}
2997	if(err == TM_OK)
2998	{
2999	/* Set digital clock mode to 16 Mhz before entering standby */
3000	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Reference_Byte__Dig_Clock, 0x02, Bus_NoRead);
3001	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3002	}
3003	if(err == TM_OK)
3004	{
3005	err = iTDA182I4_Wait(pObj, 100);
3006	}
3007	if(err == TM_OK)
3008	{
3009	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Power_Down_byte_1__PD_VCO, &uValue, Bus_None);
3010	if (uValue==1)
3011	{
3012	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_1__PD_VCO, 0x00, Bus_None);
3013	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_Down_byte_1__PD_Synthe, 0x00, Bus_NoRead);
3014	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3015	}
3016	}
3017	}
3018	else
3019	{
3020	if(err == TM_OK)
3021	{
3022	/* Set digital clock mode to 16 Mhz before entering standby */
3023	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Reference_Byte__Dig_Clock, 0x02, Bus_NoRead);
3024	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3025	}
3026	}
3027	if(err == TM_OK)
3028	{
3029	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Power_state_byte_2__power_state_mode, powerState, Bus_NoRead);
3030	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3031	}
3032	if(err == TM_OK)
3033	{
3034	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_2__AGC1_FastStbyLT_Enable, 0x00, Bus_NoRead);
3035	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3036	}
3037	if(err == TM_OK)
3038	{
3039	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_AGC1_byte_1__PD_LNA, &uValue, Bus_None);
3040	if (uValue==1)
3041	{
3042	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_1__PD_LNA, 0x00, Bus_NoRead); /* power on LNA */
3043	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3044	}
3045	}
3046	break;
3047
3048
3049	default:
3050	err = TM_ERR_BAD_PARAMETER;
3051	break;
3052	}
3053
3054	if(err == TM_OK)
3055	{
3056	/* Store low-level power state in driver instance */
3057	pObj->curLLPowerState = powerState;
3058	}
3059	}
3060
3061	return err;
3062	}
3063
3064
3065	/============================================================================/
3066	/* FUNCTION: iTDA182I4_SetRF: */
3067	/* */
3068	/* DESCRIPTION: Tunes to a RF. */
3069	/* */
3070	/* RETURN: TM_OK */
3071	/* */
3072	/============================================================================/
3073	tmErrorCode_t
3074	iTDA182I4_SetRF(
3075	pTDA182I4Object_t pObj /* I: Driver object */
3076	)
3077	{
3078	tmErrorCode_t err = TM_OK;
3079
3080	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_SetRF(0x%08X)", pObj->tUnitW);
3081
3082	if(pObj->curPowerState != tmPowerOn)
3083	{
3084	/* Set power state ON */
3085	err = iTDA182I4_SetLLPowerState(pObj, TDA182I4_PowerNormalMode);
3086	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_SetLLPowerState(0x%08X, PowerNormalMode) failed.", pObj->tUnitW));
3087	}
3088
3089	if(err == TM_OK)
3090	{
3091	pObj->curPowerState = tmPowerOn;
3092
3093	/* Setting Bandsplit parameters */
3094	err = iTDA182I4_OverrideBandsplit(pObj);
3095	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_OverrideBandsplit(0x%08X) failed.", pObj->tUnitW));
3096	}
3097
3098	if ((pObj->bCenelecMargin) &&
3099	/******************************/
3100	/* Optimization of CENELEC */
3101	/******************************/
3102	/* Check if we are set in one of the analog standards */
3103	(
3104	(pObj->StandardMode == TDA182I4_ANLG_MN) \|\|
3105	(pObj->StandardMode == TDA182I4_ANLG_B) \|\|
3106	(pObj->StandardMode == TDA182I4_ANLG_GH) \|\|
3107	(pObj->StandardMode == TDA182I4_ANLG_I) \|\|
3108	(pObj->StandardMode == TDA182I4_ANLG_DK) \|\|
3109	(pObj->StandardMode == TDA182I4_ANLG_L) \|\|
3110	(pObj->StandardMode == TDA182I4_ANLG_LL)
3111	))
3112	{
3113	/* Set AGC3 RF AGC Top */
3114	if(err == TM_OK)
3115	{
3116	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_AGC_byte_1__RFAGC_Top, TDA182I4_AGC3_TOP_I2C_96dBuV, Bus_None);
3117	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3118	}
3119
3120	/* Set AGC3 Adapt TOP to step_0 */
3121	if(err == TM_OK)
3122	{
3123	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_AGC_byte_1__RFAGC_Adapt_TOP, TDA182I4_AGC3_Adapt_TOP_0_Step, Bus_None);
3124	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3125	}
3126	if(err == TM_OK)
3127	{
3128	if (pObj->uRF <= 480768000)
3129	{
3130	/* Set AGC1_Top_Strategy */
3131	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_1__AGC1_Top_Strategy, TDA182I4_AGC1_TOP_STRATEGY_1, Bus_None);
3132	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3133
3134	/* Set AGC1 TOP I2C DN/UP */
3135	if(err == TM_OK)
3136	{
3137	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_1__AGC1_Top, TDA182I4_AGC1_TOP_I2C_DN_UP_d95_u89dBuV, Bus_NoRead);
3138	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3139	}
3140	}
3141	else if (pObj->uRF <= 866000000)
3142	{
3143	/* Set AGC1_Top_Strategy */
3144	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_1__AGC1_Top_Strategy, TDA182I4_AGC1_TOP_STRATEGY_2, Bus_None);
3145	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3146
3147	/* Set AGC1 TOP I2C DN/UP */
3148	if(err == TM_OK)
3149	{
3150	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_1__AGC1_Top, TDA182I4_AGC1_TOP_I2C_DN_UP_d90_u84wdBuV, Bus_NoRead);
3151	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3152	}
3153	}
3154	}
3155	}
3156
3157	/******************************/
3158	/* End */
3159	/******************************/
3160
3161	if(err == TM_OK)
3162	{
3163	/* Set RF frequency */
3164	err = iTDA182I4_SetRF_Freq(pObj, pObj->uProgRF);
3165	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_SetRF_Freq(0x%08X) failed.", pObj->tUnitW));
3166	}
3167
3168	/* Bypass ROM settings for wireless filters */
3169	if(err == TM_OK)
3170	{
3171	err = iTDA182I4_OverrideWireless(pObj);
3172	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_OverrideWireless(0x%08X) failed.", pObj->tUnitW));
3173	}
3174
3175	if ((pObj->bHalfRfImmunity) &&
3176	/******************************/
3177	/* Optimization of 1/2 & 2 RF */
3178	/******************************/
3179	/* Check if we are set in one of the analog standards */
3180	(
3181	(pObj->StandardMode == TDA182I4_ANLG_MN) \|\|
3182	(pObj->StandardMode == TDA182I4_ANLG_B) \|\|
3183	(pObj->StandardMode == TDA182I4_ANLG_GH) \|\|
3184	(pObj->StandardMode == TDA182I4_ANLG_I) \|\|
3185	(pObj->StandardMode == TDA182I4_ANLG_DK) \|\|
3186	(pObj->StandardMode == TDA182I4_ANLG_L) \|\|
3187	(pObj->StandardMode == TDA182I4_ANLG_LL)
3188	))
3189	{
3190	/* Wait for 300ms so that AGCs are well settled */
3191	err = iTDA182I4_Wait(pObj,300); /* 200 fast AGC1 + 100 AGC3 convergence */
3192	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Wait(0x%08X) failed.", pObj->tUnitW));
3193
3194	if(err == TM_OK)
3195	{
3196	UInt8 agc1GainRead;
3197	UInt16 agc3GainRead;
3198
3199	/* Read AGC1 & AGC3 gain */
3200	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_RFAGCs_Gain_byte_3__AGC1_Gain_Read, &agc1GainRead, Bus_NoWrite);
3201	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
3202
3203	if(err == TM_OK)
3204	{
3205	UInt8 uValue1, uValue2;
3206
3207	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_RFAGCs_Gain_byte_5__RFAGC_Read_K_8, &uValue1, Bus_NoWrite);
3208	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
3209
3210	if(err == TM_OK)
3211	{
3212	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_RFAGCs_Gain_byte_6__RFAGC_Read_K, &uValue2, Bus_NoWrite);
3213	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
3214
3215	if(err == TM_OK)
3216	{
3217	agc3GainRead = ((uValue1 << 8) & 0xFF00) \| uValue2;
3218	}
3219	}
3220	}
3221
3222	if(err == TM_OK)
3223	{
3224	if (
3225	/* AGC3 Gain max */
3226	(agc3GainRead >= 170) &&
3227	/* AGC1 Gain below 13dB */
3228	(agc1GainRead <= 8)
3229	)
3230	{
3231	/* Set AGC1 TOP to 85/79 */
3232	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_AGC1_byte_1__AGC1_Top, TDA182I4_AGC1_TOP_I2C_DN_UP_d85_u79dBuV, Bus_RW);
3233	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3234	}
3235	}
3236	}
3237	}
3238
3239	/******************************/
3240	/* End */
3241	/******************************/
3242
3243	return err;
3244	}
3245
3246	/============================================================================/
3247	/* FUNCTION: iTDA182I4_SetRF_Freq */
3248	/* */
3249	/* DESCRIPTION: Sets Tuner Frequency registers. */
3250	/* */
3251	/* RETURN: TM_OK if no error */
3252	/* */
3253	/============================================================================/
3254	tmErrorCode_t
3255	iTDA182I4_SetRF_Freq(
3256	pTDA182I4Object_t pObj, /* I: Driver object */
3257	UInt32 uRF /* I: Wanted frequency */
3258	)
3259	{
3260	tmErrorCode_t err = TM_OK;
3261	UInt32 uRFLocal = 0;
3262
3263	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_SetRF_Freq(0x%08X)", pObj->tUnitW);
3264
3265	/* Set RF */
3266	uRFLocal = (uRF + 500) / 1000;
3267
3268	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_Frequency_byte_1__RF_Freq_1, (UInt8)((uRFLocal & 0x00FF0000) >> 16), Bus_None);
3269	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3270
3271	if(err == TM_OK)
3272	{
3273	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_Frequency_byte_2__RF_Freq_2, (UInt8)((uRFLocal & 0x0000FF00) >> 8), Bus_None);
3274	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3275	}
3276	if(err == TM_OK)
3277	{
3278	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_RF_Frequency_byte_3__RF_Freq_3, (UInt8)(uRFLocal & 0x000000FF), Bus_None);
3279	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3280	}
3281	if(err == TM_OK)
3282	{
3283	err = iTDA182I4_WriteRegMap(pObj, gTDA182I4_Reg_RF_Frequency_byte_1.Address, TDA182I4_REG_DATA_LEN(gTDA182I4_Reg_RF_Frequency_byte_1, gTDA182I4_Reg_RF_Frequency_byte_3));
3284	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_WriteRegMap(0x%08X) failed.", pObj->tUnitW));
3285	}
3286	if(err == TM_OK)
3287	{
3288	/* Set IRQ_clear */
3289	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IRQ_clear, TDA182I4_IRQ_Global\|TDA182I4_IRQ_SetRF, Bus_NoRead);
3290	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3291	}
3292	if(err == TM_OK) /* <> value max ? */
3293	{
3294	/* Set ICP to Max*/
3295	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Charge_pump_byte__ICP, 0x00, Bus_NoRead);
3296	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3297	}
3298	if(err == TM_OK )
3299	{
3300	if (pObj->bOverridePLL) /* or standard dependant */
3301	{
3302	/* Override the calculated PLL to get the best margin in case fine tuning is used */
3303	/* which means set the PLL in manuel mode that provides the best occurence of LO tuning (+-2 MHz) */
3304	/* without touching PostDiv and Prescaler */
3305
3306	if(err == TM_OK)
3307	{
3308	err = iTDA182I4_SetPLL(pObj);
3309	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_SetPLL failed.", pObj->tUnitW));
3310	}
3311	if(err == TM_OK)
3312	{
3313	err = iTDA182I4_Wait(pObj, 0x03); /* PLL convergence */
3314	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Wait failed.", pObj->tUnitW));
3315	}
3316	if(err == TM_OK)
3317	{
3318	err = iTDA182I4_SetMSM(pObj, TDA182I4_MSM_RF_CAL_AV, True);
3319	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_SetMSM(0x%08X, TDA182I4_MSM_RF_CAL_AV) failed.", pObj->tUnitW));
3320	if(err == TM_OK)
3321	{
3322	/* Wait for IRQ to trigger */
3323	err = iTDA182I4_WaitIRQ(pObj, 500, 10, TDA182I4_IRQ_MSM_RFCal);
3324	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_WaitIRQ(0x%08X, 50, 5, TDA182I4_IRQ_SetRF) failed.", pObj->tUnitW));
3325	}
3326	}
3327	}
3328	else
3329	{
3330	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_5__N_K_correct_manual, 0x00, Bus_None);
3331	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3332	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_5__LO_Calc_Disable, 0x00, Bus_NoRead);
3333	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3334	if(err == TM_OK)
3335	{
3336	err = iTDA182I4_SetMSM(pObj, TDA182I4_MSM_SetRF, True);
3337	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_SetMSM(0x%08X, TDA182I4_MSM_SetRF) failed.", pObj->tUnitW));
3338	}
3339	if(err == TM_OK)
3340	{
3341	/* Wait for IRQ to trigger */
3342	err = iTDA182I4_WaitIRQ(pObj, 500, 10, TDA182I4_IRQ_SetRF);
3343	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_WaitIRQ(0x%08X, 50, 5, TDA182I4_IRQ_SetRF) failed.", pObj->tUnitW));
3344	}
3345	}
3346	}
3347	if(err == TM_OK)
3348	{
3349	err = iTDA182I4_Wait(pObj, 0x03); /* ensure PLL convergence with ICP max*/
3350	}
3351	if(err == TM_OK)
3352	{
3353	/* Override ICP */
3354	err = iTDA182I4_OverrideICP(pObj, pObj->uProgRF);
3355	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_OverrideICP(0x%08X) failed.", pObj->tUnitW));
3356	}
3357
3358
3359	return err;
3360	}
3361
3362	/============================================================================/
3363	/* FUNCTION: iTDA182I4_OverrideICP */
3364	/* */
3365	/* DESCRIPTION: Overrides ICP. */
3366	/* */
3367	/* RETURN: TM_OK if no error */
3368	/* */
3369	/============================================================================/
3370	static tmErrorCode_t
3371	iTDA182I4_OverrideICP(
3372	pTDA182I4Object_t pObj, /* I: Driver object */
3373	UInt32 uRF /* I: Wanted frequency */
3374	)
3375	{
3376	tmErrorCode_t err = TM_OK;
3377	UInt32 uIF = 0;
3378	UInt8 ProgIF = 0;
3379	UInt8 LOPostdiv = 0;
3380	UInt8 LOPrescaler = 0;
3381	UInt32 FVCO = 0;
3382	UInt8 ICP = 0;
3383	UInt8 uPrevICP = 0;
3384
3385	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_OverrideICP(0x%08X)", pObj->tUnitW);
3386
3387	/*
3388	if fvco<6552 MHz ==> icp = 150?(register = 01b)
3389	if fvco<6860 MHz ==> icp = 300?(register = 10b)
3390	500µA elsewhere (register 00b)
3391
3392
3393
3394	Reminder : fvco = postdivpresc(RFfreq+IFfreq)
3395	*/
3396
3397	/* Read PostDiv et Prescaler */
3398	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Main_Post_Divider_byte, &LOPostdiv, Bus_RW);
3399	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
3400
3401	if(err == TM_OK)
3402	{
3403	/* PostDiv */
3404	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Main_Post_Divider_byte__LOPostDiv, &LOPostdiv, Bus_NoRead);
3405	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
3406
3407	if(err == TM_OK)
3408	{
3409	/* Prescaler */
3410	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Main_Post_Divider_byte__LOPresc, &LOPrescaler, Bus_NoRead);
3411	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
3412	}
3413
3414	if(err == TM_OK)
3415	{
3416	/* IF */
3417	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_IF_Frequency_byte__IF_Freq, &ProgIF, Bus_NoRead);
3418	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
3419	}
3420
3421	if(err == TM_OK)
3422	{
3423	/* Decode IF */
3424	uIF = ProgIF*50000;
3425
3426	/* Decode PostDiv */
3427	switch(LOPostdiv)
3428	{
3429	case 1:
3430	LOPostdiv = 1;
3431	break;
3432	case 2:
3433	LOPostdiv = 2;
3434	break;
3435	case 3:
3436	LOPostdiv = 4;
3437	break;
3438	case 4:
3439	LOPostdiv = 8;
3440	break;
3441	case 5:
3442	LOPostdiv = 16;
3443	break;
3444	default:
3445	err = TDA182I4_ERR_BAD_PARAMETER;
3446	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_OverrideICP(0x%08X) LOPostDiv value is wrong.", pObj->tUnitW));
3447	break;
3448	}
3449	}
3450	if(err == TM_OK)
3451	{
3452	/* Calculate FVCO in MHz*/
3453	FVCO = LOPostdiv * LOPrescaler * ((uRF + uIF) / 1000000);
3454
3455	/* Set correct ICP */
3456
3457	if(FVCO < 6552)
3458	{
3459	/* Set ICP to 01 (= 150)*/
3460	ICP = 0x01;
3461	}
3462	else if(FVCO < 6860)
3463	{
3464	/* Set ICP to 10 (= 300)*/
3465	ICP = 0x02;
3466	}
3467	else
3468	{
3469	/* Set ICP to 00 (= 500)*/
3470	ICP = 0x00;
3471	}
3472
3473	if(err == TM_OK)
3474	{
3475	/* Get ICP */
3476	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Charge_pump_byte__ICP, &uPrevICP, Bus_None);
3477	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
3478	}
3479
3480	if(uPrevICP != ICP )
3481	{
3482	/* Set ICP new value */
3483	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Charge_pump_byte__ICP, ICP, Bus_NoRead);
3484	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3485	}
3486	}
3487	}
3488
3489	return err;
3490	}
3491
3492	/============================================================================/
3493	/* FUNCTION: iTDA182I4_OverrideBandsplit */
3494	/* */
3495	/* DESCRIPTION: Overrides Bandsplit settings. */
3496	/* */
3497	/* RETURN: TM_OK if no error */
3498	/* */
3499	/============================================================================/
3500	static tmErrorCode_t
3501	iTDA182I4_OverrideBandsplit(
3502	pTDA182I4Object_t pObj /* I: Driver object */
3503	)
3504	{
3505	tmErrorCode_t err = TM_OK;
3506	UInt8 Bandsplit = 0;
3507	UInt8 uPrevPSM_Bandsplit_Filter = 0;
3508	UInt8 PSM_Bandsplit_Filter = 0;
3509
3510	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_OverrideBandsplit(0x%08X)", pObj->tUnitW);
3511
3512	/* Setting PSM bandsplit at -3.9 mA for some RF frequencies */
3513
3514	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_Bandsplit_Filter_byte__IM2_Filter_SubBand, &Bandsplit, Bus_None);
3515	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
3516
3517	if(err == TM_OK)
3518	{
3519	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_PowerSavingMode_byte_1__PSM_IM2_Filter, &uPrevPSM_Bandsplit_Filter, Bus_None);
3520	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
3521	}
3522
3523	if(err == TM_OK)
3524	{
3525	switch(Bandsplit)
3526	{
3527	default:
3528	case 0:
3529	/* LPF0?35.7MHz/LPF1?10.4MHz/HPF0?31.6MHz*/
3530	if(pObj->uProgRF < 135700000)
3531	{
3532	/* Set PSM bandsplit at -3.9 mA */
3533	PSM_Bandsplit_Filter = 0x03;
3534	}
3535	else
3536	{
3537	/* Set PSM bandsplit at nominal */
3538	PSM_Bandsplit_Filter = 0x02;
3539	}
3540	break;
3541
3542	case 1:
3543	/* LPF0?41.8MHz/LPF1?22.7MHz/HPF0?56.2MHz */
3544	if(pObj->uProgRF < 141800000)
3545	{
3546	/* Set PSM bandsplit at -3.9 mA */
3547	PSM_Bandsplit_Filter = 0x03;
3548	}
3549	else
3550	{
3551	/* Set PSM bandsplit at nominal */
3552	PSM_Bandsplit_Filter = 0x02;
3553	}
3554	break;
3555
3556	case 2:
3557	/* LPF0?48.0MHz/LPF1?35.0MHz/HPF0?80.8MHz */
3558	if(pObj->uProgRF < 148000000)
3559	{
3560	/* Set PSM bandsplit at -3.9 mA */
3561	PSM_Bandsplit_Filter = 0x03;
3562	}
3563	else
3564	{
3565	/* Set PSM bandsplit at nominal */
3566	PSM_Bandsplit_Filter = 0x02;
3567	}
3568	break;
3569
3570	case 3:
3571	/* LPF0?54.1MHz/LPF1?47.3MHz/HPF0?05.3MHz */
3572	if(pObj->uProgRF < 154100000)
3573	{
3574	/* Set PSM bandsplit at -3.9 mA */
3575	PSM_Bandsplit_Filter = 0x03;
3576	}
3577	else
3578	{
3579	/* Set PSM bandsplit at nominal */
3580	PSM_Bandsplit_Filter = 0x02;
3581	}
3582	break;
3583	}
3584
3585	if(uPrevPSM_Bandsplit_Filter != PSM_Bandsplit_Filter)
3586	{
3587	/* Write PSM bandsplit */
3588	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_PowerSavingMode_byte_1__PSM_IM2_Filter, PSM_Bandsplit_Filter, Bus_NoRead);
3589	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3590	}
3591	}
3592
3593	return err;
3594	}
3595
3596	/============================================================================/
3597	/* FUNCTION: iTDA182I4_OverrideWireless */
3598	/* */
3599	/* DESCRIPTION: Overrides Wireless settings. */
3600	/* */
3601	/* RETURN: TM_OK if no error */
3602	/* */
3603	/============================================================================/
3604	static tmErrorCode_t
3605	iTDA182I4_OverrideWireless(
3606	pTDA182I4Object_t pObj /* I: Driver object */
3607	)
3608	{
3609	tmErrorCode_t err = TM_OK;
3610	UInt8 uPrevW_Filter_byte = 0;
3611	UInt8 uW_Filter_byte = 0;
3612	UInt8 W_Filter = 0;
3613	UInt8 W_Filter_Bypass = 0;
3614	UInt8 W_Filter_Offset = 0;
3615
3616	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_OverrideWireless(0x%08X)", pObj->tUnitW);
3617
3618	/* Bypass ROM for wireless filters */
3619	/* WF7 = 1.7GHz - 1.98GHz */
3620	/* WF8 = 1.98GHz - 2.1GHz */
3621	/* WF9 = 2.1GHz - 2.4GHz */
3622	/* For all frequencies requiring WF7 and WF8, add -8% shift */
3623	/* For all frequencies requiring WF9, change to WF8 and add +4% shift */
3624
3625	/* Check for filter WF9 */
3626	if(
3627	((pObj->uProgRF > 474000000) && (pObj->uProgRF < 536000000)) \|\|
3628	((pObj->uProgRF > 794000000) && (pObj->uProgRF < 866000000))
3629	)
3630	{
3631	/* ROM is selecting WF9 */
3632
3633	/* Bypass to WF8 */
3634	W_Filter_Bypass = 0x01;
3635	W_Filter = 0x01;
3636
3637	/* Apply +4% shift */
3638	W_Filter_Offset = 0x00;
3639	}
3640	else
3641	{
3642	/* Let ROM do the job */
3643	W_Filter_Bypass = 0x00;
3644	W_Filter = 0x00;
3645
3646	/* Check for filter WF7 & WF8 */
3647	if(
3648	((pObj->uProgRF > 336000000) && (pObj->uProgRF < 431000000)) \|\|
3649	((pObj->uProgRF > 563500000) && (pObj->uProgRF < 721000000))
3650	)
3651	{
3652	/* ROM is selecting WF7 or WF8 */
3653
3654	/* Apply -8% shift */
3655	W_Filter_Offset = 0x03;
3656	}
3657	else
3658	{
3659	/* Nominal */
3660	W_Filter_Offset = 0x01;
3661	}
3662	}
3663
3664	/* Read current W_Filter_byte */
3665	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_W_Filter_byte, &uPrevW_Filter_byte, Bus_None);
3666	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
3667
3668	if(err == TM_OK)
3669	{
3670	/* Set Wireless Filter Bypass */
3671	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_W_Filter_byte__W_Filter_Bypass, W_Filter_Bypass, Bus_None);
3672	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3673
3674	if(err == TM_OK)
3675	{
3676	/* Set Wireless Filter */
3677	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_W_Filter_byte__W_Filter, W_Filter, Bus_None);
3678	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3679	}
3680
3681	if(err == TM_OK)
3682	{
3683	/* Set Wireless Filter Offset */
3684	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_W_Filter_byte__W_Filter_Offset, W_Filter_Offset, Bus_None);
3685	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3686	}
3687
3688	if(err == TM_OK)
3689	{
3690	/* Set Wireless filters ON */
3691	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_W_Filter_byte__W_Filter_Enable, 0x01, Bus_None);
3692	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3693	}
3694
3695	if(err == TM_OK)
3696	{
3697	/* Read above-modified W_Filter_byte */
3698	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_W_Filter_byte, &uW_Filter_byte, Bus_None);
3699	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
3700	}
3701
3702	if(err == TM_OK && uPrevW_Filter_byte != uW_Filter_byte)
3703	{
3704	/* W_Filter_byte changed: Update it */
3705	err = iTDA182I4_WriteRegMap(pObj, gTDA182I4_Reg_W_Filter_byte.Address, 1);
3706	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_WriteRegMap(0x%08X) failed.", pObj->tUnitW));
3707	}
3708	}
3709
3710	return err;
3711	}
3712
3713	/============================================================================/
3714	/* FUNCTION: iTDA182I4_SetPLL */
3715	/* */
3716	/* DESCRIPTION: Set the PLL in manual mode */
3717	/* */
3718	/* RETURN: TM_OK if no error */
3719	/* */
3720	/* NOTES: */
3721	/* */
3722	/============================================================================/
3723	static tmErrorCode_t
3724	iTDA182I4_SetPLL(
3725	pTDA182I4Object_t pObj /* I: Driver object */
3726	)
3727	{
3728	tmErrorCode_t err = TM_OK;
3729
3730	/* LO wanted = RF wanted + IF in KHz */
3731	UInt32 LO = 0;
3732	UInt8 uProgIF = 0;
3733
3734	/* Algorithm that calculates PostDiv */
3735	UInt8 PostDiv = 0; /* absolute value */
3736	UInt8 LOPostDiv = 0; /* register value */
3737
3738	/* Algorithm that calculates Prescaler */
3739	UInt8 Prescaler = 0;
3740
3741	/* Algorithm that calculates N, K */
3742	UInt32 N_int = 0;
3743	UInt32 K_int = 0;
3744
3745	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_SetPLL(0x%08X)", pObj->tUnitW);
3746
3747	/* Calculate wanted LO = RF + IF in Hz */
3748	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_IF_Frequency_byte__IF_Freq, &uProgIF, Bus_None);
3749	LO = (pObj->uProgRF /1000) + (uProgIF*50);
3750
3751	/* Calculate the best PostDiv and Prescaler : the ones that provide the best margin */
3752	/* in case of fine tuning +-2 MHz */
3753	err = iTDA182I4_FindPostDivAndPrescalerWithBetterMargin(LO, &PostDiv, &Prescaler);
3754
3755	if (err == TM_OK)
3756	{
3757	/* Program the PLL only if valid values are found, in that case err == TM_OK */
3758
3759	/* Decode PostDiv */
3760	switch(PostDiv)
3761	{
3762	case 1:
3763	LOPostDiv = 1;
3764	break;
3765	case 2:
3766	LOPostDiv = 2;
3767	break;
3768	case 4:
3769	LOPostDiv = 3;
3770	break;
3771	case 8:
3772	LOPostDiv = 4;
3773	break;
3774	case 16:
3775	LOPostDiv = 5;
3776	break;
3777	default:
3778	err = TDA182I4_ERR_BAD_PARAMETER;
3779	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_SetPLL(0x%08X) *PostDiv value is wrong.", pObj->tUnitW));
3780	break;
3781	}
3782
3783	/* Affect register map without writing into IC */
3784	if(err == TM_OK)
3785	{
3786	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Main_Post_Divider_byte__LOPostDiv, LOPostDiv, Bus_None);
3787	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3788	}
3789
3790	if(err == TM_OK)
3791	{
3792	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Main_Post_Divider_byte__LOPresc, Prescaler, Bus_None);
3793	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3794	}
3795
3796	if(err == TM_OK)
3797	{
3798	/* Calculate N & K values of the PLL */
3799	err = iTDA182I4_CalculateNIntKInt(LO, PostDiv, Prescaler, &N_int, &K_int);
3800
3801	/* Affect registers map without writing to IC */
3802	if(err == TM_OK)
3803	{
3804	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_4__LO_Frac_0, (UInt8)(K_int & 0xFF), Bus_None);
3805	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3806	}
3807
3808	if(err == TM_OK)
3809	{
3810	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_3__LO_Frac_1, (UInt8)((K_int >> 8) & 0xFF), Bus_None);
3811	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3812	}
3813
3814	if(err == TM_OK)
3815	{
3816	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_2__LO_Frac_2, (UInt8)((K_int >> 16) & 0xFF), Bus_None);
3817	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3818	}
3819
3820	if(err == TM_OK)
3821	{
3822	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_1__LO_Int, (UInt8)(N_int & 0xFF), Bus_None);
3823	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3824	}
3825
3826	if(err == TM_OK)
3827	{
3828	/* Force manual selection mode : 0x3 at @0x56 */
3829	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_5__N_K_correct_manual, 0x01, Bus_None);
3830	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3831
3832	if(err == TM_OK)
3833	{
3834	/* Force manual selection mode : 0x3 at @0x56 */
3835	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_Sigma_delta_byte_5__LO_Calc_Disable, 0x01, Bus_None);
3836	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3837	}
3838	}
3839
3840	if(err == TM_OK)
3841	{
3842	/* Write bytes Main_Post_Divider_byte (0x51) to Sigma_delta_byte_5 (0x56) */
3843	err = iTDA182I4_WriteRegMap(pObj, gTDA182I4_Reg_Main_Post_Divider_byte.Address, TDA182I4_REG_DATA_LEN(gTDA182I4_Reg_Main_Post_Divider_byte, gTDA182I4_Reg_Sigma_delta_byte_5));
3844	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
3845	}
3846	}
3847	}
3848
3849	return err;
3850	}
3851
3852	/============================================================================/
3853	/* FUNCTION: iTDA182I4_CalculatePostDivAndPrescaler */
3854	/* */
3855	/* DESCRIPTION: Calculate PostDiv and Prescaler by starting from lowest value */
3856	/* of LO or not */
3857	/* LO must be passed in Hz */
3858	/* */
3859	/* RETURN: TM_OK if no error */
3860	/* */
3861	/* NOTES: */
3862	/* */
3863	/============================================================================/
3864	static tmErrorCode_t
3865	iTDA182I4_FindPostDivAndPrescalerWithBetterMargin(
3866	UInt32 LO, /* In kHz */
3867	UInt8* PostDiv, /* Directly the value to set in the register */
3868	UInt8* Prescaler /* Directly the value to set in the register */
3869	)
3870	{
3871	/* Initialize to error in case no valuable values are found */
3872	tmErrorCode_t err = TM_OK;
3873
3874	UInt8 PostDivGrowing;
3875	UInt8 PrescalerGrowing;
3876	UInt8 PostDivDecreasing;
3877	UInt8 PrescalerDecreasing;
3878	UInt32 FCVOGrowing = 0;
3879	UInt32 DistanceFCVOGrowing = 0;
3880	UInt32 FVCODecreasing = 0;
3881	UInt32 DistanceFVCODecreasing = 0;
3882
3883	/* Get the 2 possible values for PostDiv & Prescaler to find the one
3884	which provides the better margin on LO */
3885	err = iTDA182I4_CalculatePostDivAndPrescaler(LO, True, &PostDivGrowing, &PrescalerGrowing);
3886	if (err == TM_OK)
3887	{
3888	/* Calculate corresponding FVCO value in kHz */
3889	FCVOGrowing = LO * PrescalerGrowing * PostDivGrowing;
3890	}
3891
3892	err = iTDA182I4_CalculatePostDivAndPrescaler(LO, False, &PostDivDecreasing, &PrescalerDecreasing);
3893	if (err == TM_OK)
3894	{
3895	/* Calculate corresponding FVCO value in kHz */
3896	FVCODecreasing = LO * PrescalerDecreasing * PostDivDecreasing;
3897	}
3898
3899	/* Now take the values that are providing the better margin, the goal is +-2 MHz on LO */
3900	/* So take the point that is the nearest of (FVCOmax - FVCOmin)/2 = 6391,875 MHz */
3901	if (FCVOGrowing != 0)
3902	{
3903	if (FCVOGrowing >= TDA182I4_MIDDLE_FVCO_RANGE)
3904	{
3905	DistanceFCVOGrowing = FCVOGrowing - TDA182I4_MIDDLE_FVCO_RANGE;
3906	}
3907	else
3908	{
3909	DistanceFCVOGrowing = TDA182I4_MIDDLE_FVCO_RANGE - FCVOGrowing;
3910	}
3911	}
3912
3913	if (FVCODecreasing != 0)
3914	{
3915	if (FVCODecreasing >= TDA182I4_MIDDLE_FVCO_RANGE)
3916	{
3917	DistanceFVCODecreasing = FVCODecreasing - TDA182I4_MIDDLE_FVCO_RANGE;
3918	}
3919	else
3920	{
3921	DistanceFVCODecreasing = TDA182I4_MIDDLE_FVCO_RANGE - FVCODecreasing;
3922	}
3923	}
3924
3925	if (FCVOGrowing == 0)
3926	{
3927	if (FVCODecreasing == 0)
3928	{
3929	/* No value at all are found */
3930	err = TDA182I4_ERR_BAD_PARAMETER;
3931	}
3932	else
3933	{
3934	/* No value in growing mode, so take the decreasing ones */
3935	*PostDiv = PostDivDecreasing;
3936	*Prescaler = PrescalerDecreasing;
3937	}
3938	}
3939	else
3940	{
3941	if (FVCODecreasing == 0)
3942	{
3943	/* No value in decreasing mode, so take the growing ones */
3944	*PostDiv = PostDivGrowing;
3945	*Prescaler = PrescalerGrowing;
3946	}
3947	else
3948	{
3949	/* Find the value which are the nearest of the middle of VCO range */
3950	if (DistanceFCVOGrowing <= DistanceFVCODecreasing)
3951	{
3952	*PostDiv = PostDivGrowing;
3953	*Prescaler = PrescalerGrowing;
3954	}
3955	else
3956	{
3957	*PostDiv = PostDivDecreasing;
3958	*Prescaler = PrescalerDecreasing;
3959	}
3960	}
3961	}
3962
3963	return err;
3964	}
3965
3966	/============================================================================/
3967	/* FUNCTION: iTDA182I4_CalculateNIntKInt */
3968	/* */
3969	/* DESCRIPTION: Calculate PLL N & K values */
3970	/* */
3971	/* RETURN: TM_OK if no error */
3972	/* */
3973	/* NOTES: */
3974	/* */
3975	/============================================================================/
3976	tmErrorCode_t
3977	iTDA182I4_CalculateNIntKInt(
3978	UInt32 LO,
3979	UInt8 PostDiv,
3980	UInt8 Prescaler,
3981	UInt32* NInt,
3982	UInt32* KInt
3983	)
3984	{
3985	tmErrorCode_t err = TM_OK;
3986
3987	/* Algorithm that calculates N_K */
3988	UInt32 FVCO = 0;
3989	UInt32 N_K_prog = 0;
3990
3991	/* Algorithm that calculates N, K corrected */
3992	UInt32 Nprime = 0;
3993	UInt32 KforceK0_1 = 0;
3994	UInt32 K2msb = 0;
3995	UInt32 N0 = 0;
3996	UInt32 Nm1 = 0;
3997
3998	/* Calculate N_K_Prog */
3999	FVCO = LO * Prescaler * PostDiv;
4000	N_K_prog = (FVCO * 128) / 125;
4001
4002	/* Calculate N & K corrected values */
4003	Nprime = N_K_prog & 0xFF0000;
4004
4005	/* Force LSB to 1 */
4006	KforceK0_1 = 2*(((N_K_prog - Nprime) << 7) / 2) + 1;
4007
4008	/* Check MSB bit around 2 */
4009	K2msb = KforceK0_1 >> 21;
4010	if (K2msb < 1)
4011	{
4012	N0 = 1;
4013	}
4014	else
4015	{
4016	if (K2msb >= 3)
4017	{
4018	N0 = 1;
4019	}
4020	else
4021	{
4022	N0 = 0;
4023	}
4024	}
4025	if (K2msb < 1)
4026	{
4027	Nm1 = 1;
4028	}
4029	else
4030	{
4031	Nm1 = 0;
4032	}
4033
4034	/* Calculate N */
4035	NInt = (2 ((Nprime >> 16) - Nm1) + N0) - 128;
4036
4037	/* Calculate K */
4038	if (K2msb < 1)
4039	{
4040	*KInt = KforceK0_1 + (2 << 21);
4041	}
4042	else
4043	{
4044	if (K2msb >= 3)
4045	{
4046	*KInt = KforceK0_1 - (2 << 21);
4047	}
4048	else
4049	{
4050	*KInt = KforceK0_1;
4051	}
4052	}
4053
4054	/* Force last 7 bits of K_int to 0x5D, as the IC is doing for spurs optimization */
4055	*KInt &= 0xFFFFFF80;
4056	*KInt \|= 0x5D;
4057
4058	return err;
4059	}
4060
4061	/============================================================================/
4062	/* FUNCTION: iTDA182I4_CalculatePostDivAndPrescaler */
4063	/* */
4064	/* DESCRIPTION: Calculate PostDiv and Prescaler by starting from lowest value */
4065	/* of LO or not */
4066	/* LO must be passed in Hz */
4067	/* */
4068	/* RETURN: TM_OK if no error */
4069	/* */
4070	/* NOTES: */
4071	/* */
4072	/============================================================================/
4073	tmErrorCode_t
4074	iTDA182I4_CalculatePostDivAndPrescaler(
4075	UInt32 LO, /* In Hz */
4076	Bool growingOrder, /* Start from LO = 32 MHz or LO = 1008 MHz */
4077	UInt8* PostDiv, /* Absolute value */
4078	UInt8* Prescaler /* Absolute value */
4079	)
4080	{
4081	tmErrorCode_t err = TM_OK;
4082	Int8 index;
4083	Int8 sizeTable = sizeof(PostDivPrescalerTable) / sizeof(TDA182I4_PostDivPrescalerTableDef);
4084
4085	if (growingOrder == True)
4086	{
4087	/* Start from LO = 32 MHz */
4088	for (index = (sizeTable - 1); index >= 0; index--)
4089	{
4090	if (
4091	(LO > PostDivPrescalerTable[index].LO_min) &&
4092	(LO < PostDivPrescalerTable[index].LO_max)
4093	)
4094	{
4095	/* We are at correct index in the table */
4096	break;
4097	}
4098	}
4099	}
4100	else
4101	{
4102	/* Start from LO = 1008000 KHz */
4103	for (index = 0; index < sizeTable; index++)
4104	{
4105	if (
4106	(LO > PostDivPrescalerTable[index].LO_min) &&
4107	(LO < PostDivPrescalerTable[index].LO_max)
4108	)
4109	{
4110	/* We are at correct index in the table */
4111	break;
4112	}
4113	}
4114	}
4115
4116	if ((index == -1) \|\| (index == sizeTable))
4117	{
4118	err = TDA182I4_ERR_BAD_PARAMETER;
4119	}
4120	else
4121	{
4122	/* Write Prescaler */
4123	*Prescaler = PostDivPrescalerTable[index].Prescaler;
4124
4125	/* Decode PostDiv */
4126	*PostDiv = PostDivPrescalerTable[index].PostDiv;
4127	}
4128
4129	return err;
4130	}
4131
4132	/============================================================================/
4133	/* FUNCTION: iTDA182I4_SetMSM */
4134	/* */
4135	/* DESCRIPTION: Set the MSM bit(s). */
4136	/* */
4137	/* RETURN: TM_OK if no error */
4138	/* */
4139	/* NOTES: */
4140	/* */
4141	/============================================================================/
4142	tmErrorCode_t
4143	iTDA182I4_SetMSM(
4144	pTDA182I4Object_t pObj, /* I: Driver object */
4145	UInt8 uValue, /* I: Item value */
4146	Bool bLaunch /* I: Launch MSM */
4147	)
4148	{
4149	tmErrorCode_t err = TM_OK;
4150
4151	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_SetMSM(0x%08X)", pObj->tUnitW);
4152
4153	/* Set state machine and Launch it */
4154	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_MSM_byte_1, uValue, Bus_None);
4155	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
4156
4157	if(err == TM_OK && bLaunch)
4158	{
4159	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_MSM_byte_2__MSM_Launch, 0x01, Bus_None);
4160	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
4161	}
4162
4163	if(err == TM_OK)
4164	{
4165	err = iTDA182I4_WriteRegMap(pObj, gTDA182I4_Reg_MSM_byte_1.Address, bLaunch?0x02:0x01);
4166	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_WriteRegMap(0x%08X) failed.", pObj->tUnitW));
4167	}
4168
4169	if(err == TM_OK && bLaunch)
4170	{
4171	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_MSM_byte_2__MSM_Launch, 0x00, Bus_None);
4172	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
4173	}
4174
4175	return err;
4176	}
4177
4178	/============================================================================/
4179	/* FUNCTION: iTDA182I4_WaitIRQ */
4180	/* */
4181	/* DESCRIPTION: Wait the IRQ to trigger */
4182	/* */
4183	/* RETURN: TM_OK if no error */
4184	/* */
4185	/* NOTES: */
4186	/* */
4187	/============================================================================/
4188	tmErrorCode_t
4189	iTDA182I4_WaitIRQ(
4190	pTDA182I4Object_t pObj, /* I: Driver object */
4191	UInt32 timeOut, /* I: timeout */
4192	UInt32 waitStep, /* I: wait step */
4193	UInt8 irqStatus /* I: IRQs to wait */
4194	)
4195	{
4196	tmErrorCode_t err = TM_OK;
4197	UInt32 counter = timeOut/waitStep; /* Wait max timeOut/waitStep ms */
4198	UInt8 uIRQ = 0;
4199	UInt8 uIRQStatus = 0;
4200	Bool bIRQTriggered = False;
4201	UInt32 uTimeMeasure = 0;
4202
4203	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_WaitIRQ(0x%08X)", pObj->tUnitW);
4204
4205	while(err == TM_OK && (counter--)>0)
4206	{
4207	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_IRQ_status__IRQ_status, &uIRQ, Bus_RW);
4208	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
4209
4210	if(err == TM_OK && uIRQ == 1)
4211	{
4212	bIRQTriggered = True;
4213	}
4214
4215	if(bIRQTriggered)
4216	{
4217	/* IRQ triggered => Exit */
4218	break;
4219	}
4220
4221	if(err == TM_OK && irqStatus != 0x00)
4222	{
4223	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_IRQ_status, &uIRQStatus, Bus_None);
4224	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
4225
4226	if(irqStatus == uIRQStatus)
4227	{
4228	bIRQTriggered = True;
4229	}
4230	}
4231
4232	if(counter)
4233	{
4234	uTimeMeasure++;
4235	err = iTDA182I4_Wait(pObj, waitStep);
4236	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Wait(0x%08X) failed.", pObj->tUnitW));
4237	}
4238	}
4239
4240	if(err == TM_OK && bIRQTriggered == False)
4241	{
4242	err = TDA182I4_ERR_NOT_READY;
4243	}
4244	printf("iTDA182I4_WaitIRQ : %d ms\| err = %d\n", uTimeMeasure * waitStep, err);
4245	return err;
4246	}
4247
4248	/============================================================================/
4249	/* FUNCTION: iTDA182I4_Write */
4250	/* */
4251	/* DESCRIPTION: Writes in TDA182I4 hardware */
4252	/* */
4253	/* RETURN: TM_OK if no error */
4254	/* */
4255	/* NOTES: */
4256	/* */
4257	/============================================================================/
4258	tmErrorCode_t
4259	iTDA182I4_Write(
4260	pTDA182I4Object_t pObj, /* I: Driver object */
4261	const TDA182I4_BitField_t* pBitField, /* I: Bitfield structure */
4262	UInt8 uData, /* I: Data to write */
4263	tmbslFrontEndBusAccess_t eBusAccess /* I: Access to bus */
4264	)
4265	{
4266	tmErrorCode_t err = TM_OK;
4267	UInt8 RegAddr = 0;
4268	UInt32 DataLen = 1;
4269	UInt8 RegData = 0;
4270	pUInt8 pRegData = Null;
4271	UInt32 RegMask = 0;
4272
4273	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_Write(0x%08X)", pObj->tUnitW);
4274
4275	if(pBitField == Null)
4276	{
4277	err = TDA182I4_ERR_BAD_PARAMETER;
4278	}
4279
4280	if(err == TM_OK)
4281	{
4282	/* Set Register Address */
4283	RegAddr = pBitField->Address;
4284
4285	if(RegAddr < TDA182I4_REG_MAP_NB_BYTES)
4286	{
4287	pRegData = (UInt8 *)(&(pObj->RegMap)) + RegAddr;
4288	}
4289	else
4290	{
4291	pRegData = &RegData;
4292	}
4293
4294	if( (eBusAccess&Bus_NoRead) == False && P_SIO_READ_VALID)
4295	{
4296	/* Read data from TDA182I4 */
4297	err = P_SIO_READ(pObj->tUnitW, TDA182I4_REG_ADD_SZ, &RegAddr, DataLen, pRegData);
4298	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "IO_Read(0x%08X, 1, 0x%02X, %d) failed.", pObj->tUnitW, RegAddr, DataLen));
4299	}
4300
4301	if(err == TM_OK)
4302	{
4303	RegMask = ( (1 << pBitField->WidthInBits) - 1);
4304	/* Limit uData to WidthInBits */
4305	uData &= RegMask;
4306
4307	/* Set Data */
4308	RegMask = RegMask << pBitField->PositionInBits;
4309	*pRegData &= (UInt8)(~RegMask);
4310	*pRegData \|= uData << pBitField->PositionInBits;
4311
4312	if( (eBusAccess&Bus_NoWrite) == False && P_SIO_WRITE_VALID)
4313	{
4314	/* Write data to TDA182I4 */
4315	err = P_SIO_WRITE(pObj->tUnitW, TDA182I4_REG_ADD_SZ, &RegAddr, DataLen, pRegData);
4316	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "IO_Write(0x%08X, 1, 0x%02X, %d) failed.", pObj->tUnitW, RegAddr, DataLen));
4317	}
4318	}
4319	}
4320
4321	return err;
4322	}
4323
4324	/============================================================================/
4325	/* FUNCTION: iTDA182I4_Read */
4326	/* */
4327	/* DESCRIPTION: Reads in TDA182I4 hardware */
4328	/* */
4329	/* RETURN: TM_OK if no error */
4330	/* */
4331	/* NOTES: */
4332	/* */
4333	/============================================================================/
4334	tmErrorCode_t
4335	iTDA182I4_Read(
4336	pTDA182I4Object_t pObj, /* I: Driver object */
4337	const TDA182I4_BitField_t* pBitField, /* I: Bitfield structure */
4338	UInt8* puData, /* I: Data to read */
4339	tmbslFrontEndBusAccess_t eBusAccess /* I: Access to bus */
4340	)
4341	{
4342	tmErrorCode_t err = TM_OK;
4343	UInt8 RegAddr = 0;
4344	UInt32 DataLen = 1;
4345	UInt8 RegData = 0;
4346	pUInt8 pRegData = Null;
4347	UInt32 RegMask = 0;
4348
4349	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_Read(0x%08X)", pObj->tUnitW);
4350
4351	if(pBitField == Null)
4352	{
4353	err = TDA182I4_ERR_BAD_PARAMETER;
4354	}
4355
4356	if(err == TM_OK)
4357	{
4358	/* Set Register Address */
4359	RegAddr = pBitField->Address;
4360
4361	if(RegAddr < TDA182I4_REG_MAP_NB_BYTES)
4362	{
4363	pRegData = (UInt8 *)(&(pObj->RegMap)) + RegAddr;
4364	}
4365	else
4366	{
4367	pRegData = &RegData;
4368	}
4369
4370	if( (eBusAccess&Bus_NoRead) == False && P_SIO_READ_VALID)
4371	{
4372	/* Read data from TDA182I4 */
4373	err = P_SIO_READ(pObj->tUnitW, TDA182I4_REG_ADD_SZ, &RegAddr, DataLen, pRegData);
4374	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "IO_Read(0x%08X, 1, 0x%02X, %d) failed.", pObj->tUnitW, RegAddr, DataLen));
4375	}
4376
4377	if(err == TM_OK && puData != Null)
4378	{
4379	/* Copy Raw Data */
4380	puData = pRegData;
4381
4382	/* Get Data */
4383	RegMask = ( (1 << pBitField->WidthInBits) - 1) << pBitField->PositionInBits;
4384	*puData &= (UInt8)RegMask;
4385	puData = (puData) >> pBitField->PositionInBits;
4386	}
4387	}
4388
4389	return err;
4390	}
4391
4392	/============================================================================/
4393	/* FUNCTION: iTDA182I4_WriteRegMap */
4394	/* */
4395	/* DESCRIPTION: Writes driver RegMap cached data to TDA182I4 hardware. */
4396	/* */
4397	/* RETURN: TM_OK if no error */
4398	/* */
4399	/* NOTES: */
4400	/* */
4401	/============================================================================/
4402	tmErrorCode_t
4403	iTDA182I4_WriteRegMap(
4404	pTDA182I4Object_t pObj, /* I: Driver object */
4405	UInt8 uAddress, /* I: Data to write */
4406	UInt32 uWriteLen /* I: Number of data to write */
4407	)
4408	{
4409	tmErrorCode_t err = TM_OK;
4410	pUInt8 pRegData = Null;
4411	int i;
4412
4413	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_WriteRegMap(0x%08X)", pObj->tUnitW);
4414
4415	if( uAddress < TDA182I4_REG_MAP_NB_BYTES &&
4416	(uAddress + uWriteLen) <= TDA182I4_REG_MAP_NB_BYTES )
4417	{
4418	pRegData = (UInt8 *)(&(pObj->RegMap)) + uAddress;
4419	}
4420	else
4421	{
4422	err = TDA182I4_ERR_BAD_PARAMETER;
4423	}
4424
4425	if(err == TM_OK && P_SIO_WRITE_VALID)
4426	{
4427	/* Write data to TDA182I4 */
4428	/RLQ/
4429	//err = P_SIO_WRITE(pObj->tUnitW, TDA182I4_REG_ADD_SZ, &uAddress, uWriteLen, pRegData);
4430	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "IO_Write(0x%08X, 1, 0x%02X, %d) failed.", pObj->tUnitW, uAddress, uWriteLen));
4431	for (i = 0; i < uWriteLen; i++, uAddress++, pRegData++) {
4432	err = P_SIO_WRITE(pObj->tUnitW, TDA182I4_REG_ADD_SZ, &uAddress, 1, pRegData);
4433	if (TM_OK != err) {
4434	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_WriteRegMap(err=0x%x)", err);
4435	}
4436	}
4437	}
4438
4439	return err;
4440	}
4441
4442	/============================================================================/
4443	/* FUNCTION: iTDA182I4_ReadRegMap */
4444	/* */
4445	/* DESCRIPTION: Reads driver RegMap cached data from TDA182I4 hardware. */
4446	/* */
4447	/* RETURN: TM_OK if no error */
4448	/* */
4449	/* NOTES: */
4450	/* */
4451	/============================================================================/
4452	tmErrorCode_t
4453	iTDA182I4_ReadRegMap(
4454	pTDA182I4Object_t pObj, /* I: Driver object */
4455	UInt8 uAddress, /* I: Data to read */
4456	UInt32 uReadLen /* I: Number of data to read */
4457	)
4458	{
4459	tmErrorCode_t err = TM_OK;
4460	pUInt8 pRegData = Null;
4461	int i;
4462
4463	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_ReadRegMap(0x%08X)", pObj->tUnitW);
4464
4465	if( uAddress < TDA182I4_REG_MAP_NB_BYTES &&
4466	(uAddress + uReadLen) <= TDA182I4_REG_MAP_NB_BYTES )
4467	{
4468	pRegData = (UInt8 *)(&(pObj->RegMap)) + uAddress;
4469	}
4470	else
4471	{
4472	err = TDA182I4_ERR_BAD_PARAMETER;
4473	}
4474
4475	if(err == TM_OK && P_SIO_READ_VALID)
4476	{
4477	/* Read data from TDA182I4 */
4478	//err = P_SIO_READ(pObj->tUnitW, TDA182I4_REG_ADD_SZ, &uAddress, uReadLen, pRegData);
4479	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "IO_Read(0x%08X, 1, 0x%02X, %d) failed.", pObj->tUnitW, uAddress, uReadLen));
4480	for (i = 0; i < uReadLen; i++, uAddress++, pRegData++) {
4481	err = P_SIO_READ(pObj->tUnitW, TDA182I4_REG_ADD_SZ, &uAddress, 1, pRegData);
4482	if (TM_OK != err) {
4483	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_ReadRegMap(err=0x%x)", err);
4484	}
4485	}
4486	}
4487
4488	return err;
4489	}
4490
4491	/============================================================================/
4492	/* FUNCTION: iTDA182I4_Wait */
4493	/* */
4494	/* DESCRIPTION: Waits for requested time. */
4495	/* */
4496	/* RETURN: TM_OK if no error */
4497	/* */
4498	/============================================================================/
4499	tmErrorCode_t
4500	iTDA182I4_Wait(
4501	pTDA182I4Object_t pObj, /* I: Driver object */
4502	UInt32 Time /* I: time to wait for */
4503	)
4504	{
4505	tmErrorCode_t err = TDA182I4_ERR_NULL_CONTROLFUNC;
4506
4507	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_Wait(0x%08X)", pObj->tUnitW);
4508
4509	if(P_STIME_WAIT_VALID)
4510	{
4511	/* Wait Time ms */
4512	err = P_STIME_WAIT(pObj->tUnitW, Time);
4513	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "TIME_Wait(0x%08X, %d) failed.", pObj->tUnitW, Time));
4514	}
4515
4516	return err;
4517	}
4518
4519	/============================================================================/
4520	/* FUNCTION: iTDA182I4_PowerSavingMode */
4521	/* */
4522	/* DESCRIPTION: set registers according the PowerSavingMode */
4523	/* */
4524	/* RETURN: TM_OK if no error */
4525	/* */
4526	/============================================================================/
4527	tmErrorCode_t
4528	iTDA182I4_PowerSavingMode(
4529	pTDA182I4Object_t pObj, /* I: Driver object */
4530	TDA182I4PowerSavingMode_t PowerSavingMode /* I: time to wait for */
4531	)
4532	{
4533	tmErrorCode_t err = TDA182I4_ERR_NULL_CONTROLFUNC;
4534
4535	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_Wait(0x%08X)", pObj->tUnitW);
4536
4537	if (PowerSavingMode == TDA182I4PowerSavingMode_normal )
4538	{
4539	/* PowerSavingMode nominal */
4540	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_PowerSavingMode_byte_1, 0x7C, Bus_None);
4541	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_PowerSavingMode_byte_2, 0x94, Bus_None);
4542	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_PowerSavingMode_byte_3, 0x55, Bus_None);
4543	}
4544	else
4545	{
4546	/* PowerSavingMode low */
4547	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_PowerSavingMode_byte_1, 0x3C, Bus_None);
4548	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_PowerSavingMode_byte_2, 0xBF, Bus_None);
4549	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_PowerSavingMode_byte_3, 0xA9, Bus_None);
4550	}
4551	if(err == TM_OK)
4552	{
4553	/* Write gTDA182I4_Reg_PowerSavingMode_byte_1 (0x23) to gTDA182I4_Reg_PowerSavingMode_byte_4 (0x26) Registers */
4554	err = iTDA182I4_WriteRegMap(pObj, gTDA182I4_Reg_PowerSavingMode_byte_1.Address, TDA182I4_REG_DATA_LEN(gTDA182I4_Reg_PowerSavingMode_byte_1, gTDA182I4_Reg_PowerSavingMode_byte_4));
4555	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_WriteRegMap(0x%08X) failed.", pObj->tUnitW));
4556	}
4557	if(err == TM_OK)
4558	{
4559	pObj->curPowerSavingMode = PowerSavingMode;
4560	}
4561
4562
4563	return err;
4564	}
4565
4566	/============================================================================/
4567	/* FUNCTION: iTDA182I4_GetRSSI */
4568	/* */
4569	/* DESCRIPTION: Reads RSSI. */
4570	/* */
4571	/* RETURN: TM_OK if no error */
4572	/* */
4573	/============================================================================/
4574	tmErrorCode_t
4575	iTDA182I4_GetRSSI(
4576	pTDA182I4Object_t pObj, /* I: Driver object */
4577	UInt8* puValue /* O: RSSI value */
4578	)
4579	{
4580	tmErrorCode_t err = TM_OK;
4581
4582	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_GetRSSI(0x%08X)", pObj->tUnitW);
4583
4584	*puValue = 0;
4585
4586	/* Set IRQ_clear*/
4587	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IRQ_clear, TDA182I4_IRQ_Global\|TDA182I4_IRQ_GetPowerLevel, Bus_NoRead);
4588	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Write(0x%08X) failed.", pObj->tUnitW));
4589
4590	if(err == TM_OK)
4591	{
4592	/* Set state machine and Launch it */
4593	err = iTDA182I4_SetMSM(pObj, TDA182I4_MSM_GetPowerLevel, True);
4594	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_SetMSM(0x%08X, TDA182I4_MSM_GetPowerLevel) failed.", pObj->tUnitW));
4595	}
4596
4597	if(err == TM_OK)
4598	{
4599	err = iTDA182I4_WaitIRQ(pObj, 700, 1, TDA182I4_IRQ_GetPowerLevel);
4600	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_WaitIRQ(0x%08X) failed.", pObj->tUnitW));
4601	}
4602
4603	if(err == TM_OK)
4604	{
4605	/* Read Power_Level_byte */
4606	err = iTDA182I4_Read(pObj, &gTDA182I4_Reg_RSSI_byte_1__RSSI, puValue, Bus_RW);
4607	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "iTDA182I4_Read(0x%08X) failed.", pObj->tUnitW));
4608
4609	if(err != TM_OK)
4610	{
4611	err = TDA182I4_ERR_HW_FAILED;
4612	}
4613	}
4614
4615	return err;
4616	}
4617	/============================================================================/
4618	/* FUNCTION: iTDA182I4_SetIRcal */
4619	/* */
4620	/* DESCRIPTION: owerwrite IRcal High with Mid IRcal */
4621	/* */
4622	/* RETURN: TM_OK if no error */
4623	/* */
4624	/============================================================================/
4625	tmErrorCode_t
4626	iTDA182I4_SetIRcal(
4627	pTDA182I4Object_t pObj /* I: Driver object */
4628	)
4629	{
4630	tmErrorCode_t err = TM_OK;
4631	UInt8 IR_Mixer_Gain_loop, IR_RxPtr_loop, uRx_Read;
4632	UInt8 RegAddr = 0x6B;
4633
4634	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_SetIRcal(0x%08X)", pObj->tUnitW);
4635
4636	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IR_Cal_byte_5__Mixer_Gain_Bypass, 0X01 , Bus_None);
4637
4638	for (IR_Mixer_Gain_loop = 0; IR_Mixer_Gain_loop <5;IR_Mixer_Gain_loop++ )
4639	{
4640	for (IR_RxPtr_loop = 0; IR_RxPtr_loop <4; IR_RxPtr_loop++ )
4641	{
4642	if(err == TM_OK)
4643	{
4644	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IR_Cal_byte_5__IR_Mixer_Gain, IR_Mixer_Gain_loop , Bus_None);
4645	}
4646	if(err == TM_OK)
4647	{
4648	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IR_Cal_byte_5__IR_RxPtr, IR_RxPtr_loop , Bus_None);
4649	}
4650	if(err == TM_OK)
4651	{
4652	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IR_Cal_byte_5__IR_FreqPtr, 0x2 , Bus_NoRead); /* Mid value */
4653	}
4654	if(err == TM_OK)
4655	{
4656	err = P_SIO_READ(pObj->tUnitW, 0x01, &RegAddr, 1, &uRx_Read); /* read 0x6D */
4657	}
4658	if(err == TM_OK)
4659	{
4660	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IR_Cal_byte_5__IR_FreqPtr, 0x3 , Bus_NoRead); /* High value */
4661	}
4662	if(err == TM_OK)
4663	{
4664	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IR_Cal_byte_6__Rx_Force, 0x01 , Bus_None);
4665	}
4666	if(err == TM_OK)
4667	{
4668	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IR_Cal_byte_6__Rx_bp, uRx_Read , Bus_NoRead);
4669	}
4670	if(err == TM_OK)
4671	{
4672	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IR_Cal_byte_6__Rx_Force, 0x00 , Bus_NoRead);
4673	}
4674	}
4675	}
4676	if(err == TM_OK)
4677	{
4678	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_IR_Cal_byte_5__Mixer_Gain_Bypass, 0X00 , Bus_NoRead);
4679	}
4680
4681	return err;
4682	}
4683	#ifdef _TVFE_IMPLEMENT_MUTEX
4684
4685	/============================================================================/
4686	/* FUNCTION: iTDA182I4_MutexAcquire: */
4687	/* */
4688	/* DESCRIPTION: Acquires driver mutex. */
4689	/* */
4690	/* RETURN: TM_OK if no error */
4691	/* */
4692	/* NOTES: */
4693	/============================================================================/
4694	tmErrorCode_t
4695	iTDA182I4_MutexAcquire(
4696	pTDA182I4Object_t pObj,
4697	UInt32 timeOut
4698	)
4699	{
4700	tmErrorCode_t err = TDA182I4_ERR_NULL_CONTROLFUNC;
4701
4702	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_MutexAcquire(0x%08X)", pObj->tUnitW);
4703
4704	if(P_SMUTEX_ACQUIRE_VALID && P_MUTEX_VALID)
4705	{
4706	err = P_SMUTEX_ACQUIRE(P_MUTEX, timeOut);
4707	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "Mutex_Acquire(0x%08X, %d) failed.", pObj->tUnitW, timeOut));
4708	}
4709
4710	return err;
4711	}
4712
4713	/============================================================================/
4714	/* FUNCTION: iTDA182I4_MutexRelease: */
4715	/* */
4716	/* DESCRIPTION: Releases driver mutex. */
4717	/* */
4718	/* RETURN: TM_OK if no error */
4719	/* */
4720	/* NOTES: */
4721	/============================================================================/
4722	tmErrorCode_t
4723	iTDA182I4_MutexRelease(
4724	pTDA182I4Object_t pObj
4725	)
4726	{
4727	tmErrorCode_t err = TDA182I4_ERR_NULL_CONTROLFUNC;
4728
4729	tmDBGPRINTEx(DEBUGLVL_INOUT, "iTDA182I4_MutexRelease(0x%08X)", pObj->tUnitW);
4730
4731	if(P_SMUTEX_RELEASE_VALID && P_MUTEX_VALID)
4732	{
4733	err = P_SMUTEX_RELEASE(P_MUTEX);
4734	tmASSERTExT(err, TM_OK, (DEBUGLVL_ERROR, "Mutex_Release(0x%08X) failed.", pObj->tUnitW));
4735	}
4736
4737	return err;
4738	}
4739	#endif
4740
4741
4742	/============================================================================/
4743	/janzy@20120914 ,add function(aov_tmbslTDA182I4_LTOEnable)/
4744	/============================================================================/
4745	tmErrorCode_t aov_tmbslTDA182I4_LTOEnable( tmUnitSelect_t tUnit /* I: Unit number */)
4746	{
4747	pTDA182I4Object_t pObj = Null;
4748	tmErrorCode_t err = TM_OK;
4749	UInt8 uVal;
4750	UInt32 counter = 10; /* Wait I2C ready */
4751
4752	/* Get a driver instance */
4753	err = iTDA182I4_GetInstance(tUnit, &pObj);
4754
4755	_MUTEX_ACQUIRE(TDA182I4)
4756
4757	uVal = 0;
4758	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_1__PD_LT, uVal, Bus_NoRead);
4759
4760	uVal = 0;
4761	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_1__PD_RF_BUF_LTO, uVal, Bus_NoRead);
4762
4763	_MUTEX_RELEASE(TDA182I4)
4764
4765	return err;
4766	}
4767
4768	tmErrorCode_t aov_tmbslTDA182I4_LTODisable( tmUnitSelect_t tUnit /* I: Unit number */)
4769	{
4770	pTDA182I4Object_t pObj = Null;
4771	tmErrorCode_t err = TM_OK;
4772	UInt8 uVal;
4773	UInt32 counter = 10; /* Wait I2C ready */
4774
4775	/* Get a driver instance */
4776	err = iTDA182I4_GetInstance(tUnit, &pObj);
4777
4778	_MUTEX_ACQUIRE(TDA182I4)
4779
4780	uVal = 1;
4781	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_1__PD_LT, uVal, Bus_NoRead);
4782
4783	uVal = 1;
4784	err = iTDA182I4_Write(pObj, &gTDA182I4_Reg_LT_byte_1__PD_RF_BUF_LTO, uVal, Bus_NoRead);
4785
4786	_MUTEX_RELEASE(TDA182I4)
4787
4788	return err;
4789	}
4790	//RLQ
4791	//int printf(const char *format, ...);
4792
4793	void aov_tmbslTDA182I4_dbg_test(unsigned int max)
4794	{
4795	tmErrorCode_t err = TM_OK;
4796	pTDA182I4Object_t pObj = Null;
4797	TDA182I4_BitField_t test = { 0x07, 0x00, 0x08, 0x00 };
4798	UInt8 puData;
4799	int i,j;
4800
4801	iTDA182I4_GetInstance(0, &pObj);
4802
4803	printf(" ");
4804
4805	for( j = 0 ; j < 16 ; j++ )
4806	{
4807
4808	if(j<0x10) printf("0%X ",j);
4809	else printf("%X ",j);
4810	if( (j == 3)\|\|(j==7)\|\|(j==11))
4811	printf(" ");
4812	}
4813	printf("\n -----------------------------------------------------\n");
4814
4815	_MUTEX_ACQUIRE(TDA182I4)
4816	for(i = 0 ; i < 0x100 ; i+=16 )
4817	{
4818	if(i<0x10) printf("[ 0%X ] ",i);
4819	else printf("[ %X ] ",i);
4820	for( j = 0 ; j < 16 ; j++ )
4821	{
4822	test.Address = i+j;
4823	if(test.Address >max)
4824	{
4825	printf("\n");
4826	printf(" -----------------------------------------------------\n");
4827	goto Tend;
4828	}
4829	iTDA182I4_Read(pObj, &test, &puData, Bus_NoWrite);
4830
4831	if(puData<0x10) printf("0%X ",puData);
4832	else printf("%X ",puData);
4833	if( (j == 3)\|\|(j==7)\|\|(j==11))
4834	printf(" ");
4835	}
4836	printf("\n");
4837	if( (i % 0x40) == 0x30)
4838	printf(" -----------------------------------------------------\n");
4839	}
4840
4841	Tend:
4842	/RLQ,avoid compiler complaining about "label at end of compound statement" /
4843	i = 0;
4844	_MUTEX_RELEASE(TDA182I4)
4845	}

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

Context Navigation

source: svn/newcon3bcm2_21bu/dta/src/settop_api/NXP_TDA182I4/tmbslTDA182I4/tmbslTDA182I4.c

Download in other formats: