1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94 #ifndef _VIF_C_
95 #define _VIF_C_
96
97 //-------------------------------------------------------------------------------------------------
98 // Include Files
99 //-------------------------------------------------------------------------------------------------
100 // Common Definition
101 #ifdef MSOS_TYPE_LINUX_KERNEL
102 #include <linux/string.h>
103 #else
104 #include <string.h>
105 #endif
106 #include "MsCommon.h"
107 #include "MsVersion.h"
108 #include "MsIRQ.h"
109 #include "drvXC_IOPort.h"
110 #include "apiXC.h"
111 //#if !defined (MSOS_TYPE_NOS)
112 #include "MsOS.h"
113 //#endif
114
115 #include "MsTypes.h"
116 #ifndef MSOS_TYPE_LINUX_KERNEL
117 #include <stdio.h>
118 #endif
119 #include "../../utopia_core/utopia_dapi.h"
120 #include "../../utopia_core/utopia.h"
121 #include "../../utopia_core/utopia_driver_id.h"
122
123 // Internal Definition
124 #include "halVIF.h"
125 #include "halVIF_Customer.h"
126 #include "regVIF.h"
127 #include "VIF.h"
128
129 //-------------------------------------------------------------------------------------------------
130 // Driver Compiler Options
131 //-------------------------------------------------------------------------------------------------
132
133 //-------------------------------------------------------------------------------------------------
134 // Local Defines
135 //-------------------------------------------------------------------------------------------------
136 //****************************************************************************
137 // VIF lib Changelist
138 //****************************************************************************
139 #define MSIF_VIF_LIB_CODE {'V','I','F','_'}
140 #define MSIF_VIF_LIBVER {'1','8'}
141 #define MSIF_VIF_BUILDNUM {'4','8'}
142 #define MSIF_VIF_CHANGELIST {'0','1','4','9','7','8','2','3'}
143 #define MSIF_VIF_DASH {'_'}
144 #define MSIF_VIF_DATE {'1','6','0','9','1','9'} // yymmdd
145
146 #define VIF_DRV_VERSION /* Character String for DRV/API version */ \
147 MSIF_TAG, /* 'MSIF' */ \
148 MSIF_CLASS, /* '00' */ \
149 MSIF_CUS, /* 0x0000 */ \
150 MSIF_MOD, /* 0x0000 */ \
151 MSIF_CHIP, \
152 MSIF_CPU, \
153 MSIF_VIF_LIB_CODE, /* IP__ */ \
154 MSIF_VIF_LIBVER, /* 0.0 ~ Z.Z */ \
155 MSIF_VIF_BUILDNUM, /* 00 ~ 99 */ \
156 MSIF_VIF_CHANGELIST, /* CL# */ \
157 MSIF_OS
158
159 const U8 VIF_Version1[] = {'V','I','F', '_', '_'};
160 const U8 VIF_Version2[] = {CHIP_TYPE};
161 const U8 VIF_Version3[] = MSIF_VIF_DASH;
162 const U8 VIF_Version4[] = MSIF_VIF_LIBVER;
163 const U8 VIF_Version5[] = MSIF_VIF_DASH;
164 const U8 VIF_Version6[] = MSIF_VIF_BUILDNUM;
165 const U8 VIF_Version7[] = MSIF_VIF_DASH;
166 const U8 VIF_Version8[] = MSIF_VIF_DATE;
167 const U8 VIF_Version9[] = MSIF_VIF_DASH;
168 const U8 VIF_VersionA[] = MSIF_VIF_CHANGELIST;
169
170 #define DRVVIFDBG(x) //x
171
172 //-------------------------------------------------------------------------------------------------
173 // extern function
174 //-------------------------------------------------------------------------------------------------
175 #define DRV_VIF_GetSystemTime() MsOS_GetSystemTime()
176
177 //-------------------------------------------------------------------------------------------------
178 // Local Variables
179 //-------------------------------------------------------------------------------------------------
180 static MSIF_Version _drv_vif_version = {
181 .DDI = { VIF_DRV_VERSION },
182 };
183
184 VIFInitialIn VIFInitialIn_inst;
185 VIFUserFilter sVIFUserFilter;
186 //VIFNotchA1A2 sVIFNotchA1A2;
187 //VIFSOS1112 sVIFSOS1112;
188 //VIFSOS33 sVIFSOS33;
189 //DWORD dwVIFPara;
190 VIFSoundSystem gVIFSoundSystem;
191 VIFSTRParameter sVIFSTRInfo;
192
193 BOOL bEnableUsrSteadyAgcK;
194 U8 u8UsrSteadyAgcK;
195 BOOL bEnableUsrNonSteadyAgcK;
196 U8 u8UsrNonSteadyAgcK;
197 BOOL bIsATV = FALSE;
198
199 #define VIF_debug(x) //x
200
201 //-------------------------------------------------------------------------------------------------
202 // Enum
203 //-------------------------------------------------------------------------------------------------
204
205 typedef enum
206 {
207 VIF_POOL_ID_VIF = 0,
208 } eVIFPoolID;
209
210
VIFRegisterToUtopia(void)211 void VIFRegisterToUtopia(void)
212 {
213 // 1. deal with module
214 void* pUtopiaModule = NULL;
215 UtopiaModuleCreate(MODULE_VIF, 8, &pUtopiaModule);
216 UtopiaModuleRegister(pUtopiaModule);
217 UtopiaModuleSetupFunctionPtr(pUtopiaModule, (FUtopiaOpen)VIFOpen, (FUtopiaClose)VIFClose, (FUtopiaIOctl)VIFIoctl);
218
219 // Utopia2K STR
220 #if defined(MSOS_TYPE_LINUX_KERNEL)
221 UtopiaModuleSetupSTRFunctionPtr(pUtopiaModule,(FUtopiaSTR)VIFStr);
222 //UtopiaModuleSetSTRPrivate(pUtopiaModule, STRPrivateDataSize);
223 #endif
224
225 }
226
VIFOpen(void ** ppInstance,MS_U32 u32ModuleVersion,void * pAttribute)227 MS_U32 VIFOpen(void** ppInstance, MS_U32 u32ModuleVersion, void* pAttribute)
228 {
229 printf("\n[VIF INFO] VIF open \n");
230
231 VIF_INSTANT_PRIVATE *pVifPri = NULL;
232 UtopiaInstanceCreate(sizeof(VIF_INSTANT_PRIVATE), ppInstance);
233 UtopiaInstanceGetPrivate(*ppInstance, (void*)&pVifPri);
234
235 pVifPri->fpVIFVersion = VIF_Version;
236 pVifPri->fpVIFSetClock = VIF_SetClock;
237 pVifPri->fpVIFInit = VIF_Init;
238 pVifPri->fpVIFExit = VIF_Exit;
239 pVifPri->fpVIFReset = VIF_Reset;
240 pVifPri->fpVIFHandler = VIF_Handler;
241 pVifPri->fpVIFSetSoundSystem = VIF_SetSoundSystem;
242 pVifPri->fpVIFSetIfFreq = VIF_SetIfFreq;
243 pVifPri->fpVIFCRFOE = VIF_Read_CR_FOE;
244 pVifPri->fpVIFLOCKSTATUS = VIF_Read_CR_LOCK_STATUS;
245 pVifPri->fpVIFBypassDBBAudioFilter = VIF_BypassDBBAudioFilter;
246 pVifPri->fpVIFSetFreqBand = VIF_SetFreqBand;
247
248 pVifPri->fpVIFGetInputLevelIndicator = VIF_GetInputLevelIndicator;
249 pVifPri->fpVIFSetParameter = VIF_SetParameter;
250 pVifPri->fpVIFShiftClk = VIF_ShiftClk;
251 pVifPri->fpVIFSetPowerState = VIF_SetPowerState;
252 pVifPri->fpVIFWriteByte = VIF_WriteByte;
253 pVifPri->fpVIFReadBtye = VIF_ReadByte;
254
255 //return TRUE;
256 return UTOPIA_STATUS_SUCCESS;
257 }
258
VIFIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)259 MS_U32 VIFIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
260 {
261 BOOL bEnable = 0;
262 BYTE u8Value;
263 //WORD u16Value;
264 //DWORD u32Value;
265 DWORD u32Ret = 0;
266 //WORD u16PowerState = 0;
267 VIFSoundSystem SoundSystem;
268 IfFrequencyType IfFreqType;
269 FrequencyBand FreqBand;
270 PVIF_COPYTOUSER pCopyToUser;
271
272 PVIF_INIT pINITParam = NULL;
273 PVIF_SETREGVALUE pSetRegValue = NULL;
274 PVIF_SETPARA pSetGroupParam = NULL;
275
276 void* pModule = NULL;
277 VIF_INSTANT_PRIVATE* psVIFInstPri = NULL;
278 UtopiaInstanceGetPrivate(pInstance, (void*)&psVIFInstPri);
279 UtopiaInstanceGetModule(pInstance, &pModule);
280
281 switch(u32Cmd)
282 {
283 case Drv_CMD_VIF_Version:
284 VIF_debug(printf("Drv_CMD_VIF_Version\n"));
285 (psVIFInstPri->fpVIFVersion)();
286 break;
287 case Drv_CMD_VIF_SetClock:
288 VIF_debug(printf("Drv_CMD_VIF_SetClock s\n"));
289 bEnable = *(BOOL *)pArgs;
290 (psVIFInstPri->fpVIFSetClock)(bEnable);
291 break;
292 case Drv_CMD_VIF_Init:
293 VIF_debug(printf("Drv_CMD_VIF_Init \n"));
294 pINITParam = (PVIF_INIT)pArgs;
295 (psVIFInstPri->fpVIFInit)(pINITParam->pVIF_InitData, pINITParam->u32InitDataLen);
296 break;
297 case Drv_CMD_VIF_Exit:
298 VIF_debug(printf("Drv_CMD_VIF_Exit \n"));
299 (psVIFInstPri->fpVIFExit)();
300 break;
301 case Drv_CMD_VIF_Reset:
302 VIF_debug(printf("Drv_CMD_VIF_Reset \n"));
303 (psVIFInstPri->fpVIFReset)();
304 break;
305 case Drv_CMD_VIF_Handler:
306 VIF_debug(printf("Drv_CMD_VIF_Handler \n"));
307 bEnable = *(BOOL *)pArgs;
308 (psVIFInstPri->fpVIFHandler)(bEnable);
309 break;
310 case Drv_CMD_VIF_SetSoundSystem:
311 VIF_debug(printf("Drv_CMD_VIF_SetSoundSystem \n"));
312 SoundSystem = *(VIFSoundSystem *)pArgs;
313 (psVIFInstPri->fpVIFSetSoundSystem)(SoundSystem);
314 break;
315 case Drv_CMD_VIF_SetIfFreq:
316 VIF_debug(printf("Drv_CMD_VIF_SetIfFreq \n"));
317 IfFreqType = *(IfFrequencyType *)pArgs;
318 (psVIFInstPri->fpVIFSetIfFreq)(IfFreqType);
319 break;
320 case Drv_CMD_VIF_Read_CR_FOE:
321 VIF_debug(printf("Drv_CMD_VIF_Read_CR_FOE \n"));
322 pCopyToUser = (PVIF_COPYTOUSER)pArgs;
323 u32Ret = (psVIFInstPri->fpVIFCRFOE)();
324 pCopyToUser->u8Value = (BYTE)u32Ret;
325 break;
326 case Drv_CMD_VIF_Read_CR_LOCK_STATUS:
327 VIF_debug(printf("Drv_CMD_VIF_Read_CR_LOCK_STATUS \n"));
328 pCopyToUser = (PVIF_COPYTOUSER)pArgs;
329 u32Ret = (psVIFInstPri->fpVIFLOCKSTATUS)();
330 pCopyToUser->u8Value = (BYTE)u32Ret;
331 break;
332 case Drv_CMD_VIF_BypassDBBAudioFilter:
333 VIF_debug(printf("Drv_CMD_VIF_BypassDBBAudioFilter \n"));
334 bEnable = *(BOOL *)pArgs;
335 (psVIFInstPri->fpVIFBypassDBBAudioFilter)(bEnable);
336 break;
337 case Drv_CMD_VIF_SetFreqBand:
338 VIF_debug(printf("Drv_CMD_VIF_SetFreqBand \n"));
339 FreqBand = *(FrequencyBand *)pArgs;
340 (psVIFInstPri->fpVIFSetFreqBand)(FreqBand);
341 break;
342 case Drv_CMD_VIF_GetInputLevelIndicator:
343 VIF_debug(printf("Drv_CMD_VIF_GetInputLevelIndicator \n"));
344 pCopyToUser = (PVIF_COPYTOUSER)pArgs;
345 u32Ret = (psVIFInstPri->fpVIFGetInputLevelIndicator)();
346 pCopyToUser->bEnable = (BOOL)u32Ret;
347 break;
348 case Drv_CMD_VIF_SetParameter:
349 VIF_debug(printf("Drv_CMD_VIF_SetParameter \n"));
350 pSetGroupParam = (PVIF_SETPARA)pArgs;
351 u32Ret = (psVIFInstPri->fpVIFSetParameter)(pSetGroupParam->ParaGroup, pSetGroupParam->pVIF_Para, pSetGroupParam->u32DataLen);
352 pSetGroupParam->bRet = (BOOL)u32Ret;
353 break;
354 case Drv_CMD_VIF_ShiftClk:
355 VIF_debug(printf("Drv_CMD_VIF_ShiftClk \n"));
356 u8Value = *(BYTE *)pArgs;
357 (psVIFInstPri->fpVIFShiftClk)(u8Value);
358 break;
359 case Drv_CMD_VIF_SetPowerState:
360 VIF_debug(printf("Drv_CMD_VIF_SetPowerState \n"));
361 pCopyToUser = (PVIF_COPYTOUSER)pArgs;
362 u32Ret = (psVIFInstPri->fpVIFSetPowerState)(pCopyToUser->u16PowerState);
363 pCopyToUser->u32Value = (MS_U32)u32Ret;
364 break;
365 case Drv_CMD_VIF_WriteByte:
366 VIF_debug(printf("Drv_CMD_VIF_WriteByte \n"));
367 pSetRegValue = (PVIF_SETREGVALUE)pArgs;
368 (psVIFInstPri->fpVIFWriteByte)(pSetRegValue->u32Addr, pSetRegValue->u8Value);
369 break;
370 case Drv_CMD_VIF_ReadByte:
371 VIF_debug(printf("Drv_CMD_VIF_ReadByte \n"));
372 pSetRegValue = (PVIF_SETREGVALUE)pArgs;
373 u32Ret = (psVIFInstPri->fpVIFReadBtye)(pSetRegValue->u32Addr);
374 pSetRegValue->u8Value = (U8)u32Ret;
375 break;
376 default:
377 break;
378 }
379
380 return UTOPIA_STATUS_SUCCESS;
381 }
382
VIFClose(void * pInstance)383 MS_U32 VIFClose(void* pInstance)
384 {
385 UtopiaInstanceDelete(pInstance);
386
387 return TRUE;
388 }
389
VIFStr(MS_U32 u32PowerState,void * pModule)390 MS_U32 VIFStr(MS_U32 u32PowerState, void* pModule)
391 {
392 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
393 MS_U32 u32Ret = 0;
394
395 //UtopiaModuleGetSTRPrivate(pModule, (void**));
396
397 if (u32PowerState == E_POWER_SUSPEND)
398 {
399 /* Please Implement Module Suspend Flow Here. */
400 u32Ret = VIF_SetPowerState(E_POWER_SUSPEND);
401
402 if(u32Ret == 0)
403 u32Return = UTOPIA_STATUS_SUCCESS;//SUSPEND_OK;
404 }
405 else if (u32PowerState == E_POWER_RESUME)
406 {
407 /* Please Implement Module Resume Flow Here. */
408 u32Ret = VIF_SetPowerState(E_POWER_RESUME);
409
410 if(u32Ret == 0)
411 u32Return = UTOPIA_STATUS_SUCCESS;//RESUME_OK;
412 #if defined(MSOS_TYPE_LINUX_KERNEL)
413 UtopiaStrSendCondition("vif", u32PowerState, 0);
414 #endif
415 }
416 else
417 {
418 printf("\r\n ====== [VIFStr] Unknown Power State ====== \n");
419 u32Return = UTOPIA_STATUS_FAIL;
420 }
421
422 return u32Return;
423 }
424
425 //-------------------------------------------------------------------------------------------------
426 // Local VIF functions
427 //-------------------------------------------------------------------------------------------------
428
VIF_WriteByteMask(U32 u32Reg,U8 u8Val,U8 u8Mask)429 void VIF_WriteByteMask(U32 u32Reg, U8 u8Val, U8 u8Mask)
430 {
431 HAL_VIF_WriteByteMask(u32Reg, u8Val, u8Mask);
432 }
433
VIF_WriteBit(U32 u32Reg,BOOL bEnable,U8 u8Mask)434 void VIF_WriteBit(U32 u32Reg, BOOL bEnable, U8 u8Mask)
435 {
436 HAL_VIF_WriteBit(u32Reg, bEnable, u8Mask);
437 }
438
VIF_WriteByte(U32 u32Reg,U8 u8Val)439 void VIF_WriteByte(U32 u32Reg, U8 u8Val )
440 {
441 HAL_VIF_WriteByte(u32Reg, u8Val);
442 }
443
VIF_ReadByte(U32 u32Reg)444 U8 VIF_ReadByte(U32 u32Reg )
445 {
446 return HAL_VIF_ReadByte(u32Reg);
447 }
448
449 /***********************************************************************************
450 Subject: printf version number
451 Function: DRV_VIF_Version
452 Parmeter:
453 Return:
454 Remark:
455 ************************************************************************************/
VIF_MSIFVersion(MSIF_Version ** mVersion)456 void VIF_MSIFVersion(MSIF_Version** mVersion)
457 {
458 *mVersion = &_drv_vif_version;
459 }
460
VIF_Version(void)461 void VIF_Version(void)
462 {
463 U8 sVersion[30]={0x00};
464 // VIF version
465 #ifdef _2_DIGIT_CHIP_TYPE_
466 memcpy(sVersion, VIF_Version1, 5);
467 memcpy(sVersion+5, VIF_Version2, 2);
468 memcpy(sVersion+7, VIF_Version3, 1);
469 memcpy(sVersion+8, VIF_Version4, 2);
470 memcpy(sVersion+10, VIF_Version5, 1);
471 memcpy(sVersion+11, VIF_Version6, 2);
472 memcpy(sVersion+13, VIF_Version7, 1);
473 memcpy(sVersion+14, VIF_Version8, 6);
474 memcpy(sVersion+20, VIF_Version9, 1);
475 memcpy(sVersion+21, VIF_VersionA, 8);
476 #else
477 memcpy(sVersion, VIF_Version1, 5);
478 memcpy(sVersion+5, VIF_Version2, 1);
479 memcpy(sVersion+6, VIF_Version3, 1);
480 memcpy(sVersion+7, VIF_Version4, 2);
481 memcpy(sVersion+9, VIF_Version5, 1);
482 memcpy(sVersion+10, VIF_Version6, 2);
483 memcpy(sVersion+12, VIF_Version7, 1);
484 memcpy(sVersion+13, VIF_Version8, 6);
485 memcpy(sVersion+19, VIF_Version9, 1);
486 memcpy(sVersion+20, VIF_VersionA, 8);
487 #endif
488
489 printf("\r\n[VIF Version]: ");
490 printf("%s\r\n",sVersion);
491 }
492
493 /***********************************************************************************
494 Subject: read register
495 Function: MDrv_1210_Read_CR_FOE
496 Parmeter:
497 Return:
498 Remark:
499 ************************************************************************************/
VIF_Read_CR_FOE(void)500 U8 VIF_Read_CR_FOE(void)
501 {
502 //DRVVIFDBG(printf("\r\nDRV_VIF_Read_CR_FOE()"));
503 return msVifReadCRFOE();
504 }
505 /***********************************************************************************
506 Subject: read register
507 Function: MDrv_1210_Read_CR_LOCK_STATUS
508 Parmeter:
509 Return:
510 Remark:
511 ************************************************************************************/
VIF_Read_CR_LOCK_STATUS(void)512 U8 VIF_Read_CR_LOCK_STATUS(void)
513 {
514 //DRVVIFDBG(printf("\r\nDRV_VIF_Read_CR_LOCK_STATUS()"));
515 return msVifReadLockStatus();
516 }
517
VIF_SetClock(BOOL bEnable)518 void VIF_SetClock(BOOL bEnable)
519 {
520 DRVVIFDBG(printf("\r\nDRV_VIF_SetClock %d",bEnable));
521 HAL_VIF_SetClock(bEnable);
522 }
523
VIF_Init(VIFInitialIn * pVIF_InitData,DWORD u32InitDataLen)524 void VIF_Init(VIFInitialIn * pVIF_InitData, DWORD u32InitDataLen)
525 {
526 U32 u32StartTime = DRV_VIF_GetSystemTime();
527 U32 u32TopTime = sizeof(U32) -1;
528 U32 u32DiffTime = 0;
529
530 DRVVIFDBG(printf("\r\nDRV_VIF_Init"));
531
532 if(DRV_VIF_GetSystemTime() >= u32StartTime)
533 {
534 while (DRV_VIF_GetSystemTime() -u32StartTime < 3)
535 {
536 // do nothing;
537 }
538 }
539 else
540 {
541 u32DiffTime = u32TopTime - u32StartTime;
542 while((DRV_VIF_GetSystemTime() + u32DiffTime) < 3)
543 {
544 // do nothing;
545 }
546 }
547
548 HAL_VIF_RegInit(); // !! any register access should be after this function
549
550 if ( sizeof(VIFInitialIn_inst) == u32InitDataLen)
551 {
552 memcpy(&VIFInitialIn_inst, pVIF_InitData, u32InitDataLen);
553
554 VIFInitialIn_inst.VifFreqBand = (BYTE)(VIF_ReadByte(VIF_RF_RESERVED_1+2))/*g_FreqBand*/;
555
556 bEnableUsrSteadyAgcK = FALSE;
557 u8UsrSteadyAgcK = 0;
558 bEnableUsrNonSteadyAgcK = FALSE;
559 u8UsrNonSteadyAgcK = 0;
560 bIsATV = TRUE;
561 }
562 else
563 {
564 printf("\r\nERROR DRV_VIF init data size FAILE!!");
565 return;
566 }
567
568 if (VIFInitialIn_inst.VifReserve & _BIT2)
569 {
570 printf("\r\n------------Start of VIF lib para-----------");
571 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifTop);// = VIF_TOP;
572 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifIfBaseFreq);// = VIF_IF_BASE_FREQ;
573 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifTunerStepSize);// = VIF_TUNER_STEP_SIZE;
574 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSawArch);//=VIF_SAW_ARCH;
575 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifVgaMaximum);// = VIF_VGA_MAXIMUM;
576 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifVgaMinimum);// = VIF_VGA_MINIMUM;
577 printf("\r\n %x",(WORD)VIFInitialIn_inst.GainDistributionThr);// = GAIN_DISTRIBUTION_THR;
578 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifAgcVgaBase);//=VIF_AGC_VGA_BASE;
579 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifAgcVgaOffs);//=VIF_AGC_VGA_OFFS;
580 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifAgcRefNegative);// = VIF_AGC_REF_NEGATIVE;
581 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifAgcRefPositive);// = VIF_AGC_REF_POSITIVE;
582 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifDagc1Ref);// = VIF_DAGC1_REF;
583 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifDagc2Ref);// = VIF_DAGC2_REF;
584 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifDagc1GainOv);//=VIF_DAGC1_GAIN_OV;
585 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifDagc2GainOv);//=VIF_DAGC2_GAIN_OV;
586 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrKf1);//=VIF_CR_KF1;
587 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrKp1);//=VIF_CR_KP1;
588 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrKi1);//=VIF_CR_KI1;
589 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrKp2);//=VIF_CR_KP2;
590 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrKi2);//=VIF_CR_KI2;
591 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrKp);// = VIF_CR_KP;
592 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrKi);// = VIF_CR_KI;
593 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrLockThr);// = VIF_CR_LOCK_THR;
594 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrThr);//= VIF_CR_THR;
595 printf("\r\n %x",(WORD)((VIFInitialIn_inst.VifCrLockNum>>16)&0x0000FFFF));//=VIF_CR_LOCK_NUM;
596 printf("%x",(WORD) (VIFInitialIn_inst.VifCrLockNum&0x0000FFFF));//=VIF_CR_LOCK_NUM;
597 printf("\r\n %x",(WORD)((VIFInitialIn_inst.VifCrUnlockNum>>16)&0x0000FFFF));//=VIF_CR_UNLOCK_NUM;
598 printf("%x",(WORD) (VIFInitialIn_inst.VifCrUnlockNum&0x0000FFFF));
599 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrPdErrMax);//=VIF_CR_PD_ERR_MAX;
600 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrLockLeakySel);//=VIF_CR_LOCK_LEAKY_SEL;
601 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrPdX2);//=VIF_CR_PD_X2;
602 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrLpfSel);//=VIF_CR_LPF_SEL;
603 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrPdModeSel);//=VIF_CR_PD_MODE_SEL;
604 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrKpKiAdjust);//=VIF_CR_KP_KI_ADJUST;
605 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrKpKiAdjustGear);//=VIF_CR_KP_KI_ADJUST_GEAR;
606 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrKpKiAdjustThr1);//=VIF_CR_KP_KI_ADJUST_THR1;
607 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrKpKiAdjustThr2);//=VIF_CR_KP_KI_ADJUST_THR2;
608 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrKpKiAdjustThr3);//=VIF_CR_KP_KI_ADJUST_THR3;
609 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifDynamicTopAdjust);//=VIF_DYNAMIC_TOP_ADJUST;
610 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifDynamicTopMin);//=VIF_DYNAMIC_TOP_MIN;
611 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifAmHumDetection);//=VIF_AM_HUM_DETECTION;
612 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainClampSel);//=VIF_CLAMPGAIN_CLAMP_SEL;
613 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainSyncbottRef);//=VIF_CLAMPGAIN_SYNCBOTT_REF;
614 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainSyncheightRef);//=VIF_CLAMPGAIN_SYNCHEIGHT_REF;
615 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainKc);//=VIF_CLAMPGAIN_KC;
616 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainKg);//=VIF_CLAMPGAIN_KG;
617 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainClampOren);//=VIF_CLAMPGAIN_CLAMP_OREN;
618 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainGainOren);//=VIF_CLAMPGAIN_GAIN_OREN;
619 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainClampOvNegative);//=VIF_CLAMPGAIN_CLAMP_OV_NEGATIVE;
620 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainGainOvNegative);//=VIF_CLAMPGAIN_GAIN_OV_NEGATIVE;
621 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainClampOvPositive);//=VIF_CLAMPGAIN_CLAMP_OV_POSITIVE;
622 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainGainOvPositive);//=VIF_CLAMPGAIN_GAIN_OV_POSITIVE;
623 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainClampMin);//=VIF_CLAMPGAIN_CLAMP_MIN;
624 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainClampMax);//=VIF_CLAMPGAIN_CLAMP_MAX;
625 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainGainMin);//=VIF_CLAMPGAIN_GAIN_MIN;
626 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainGainMax);//=VIF_CLAMPGAIN_GAIN_MAX;
627 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifClampgainPorchCnt);//=VIF_CLAMPGAIN_PORCH_CNT;
628 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterB_VHF_L);//=VIF_PEAKING_FILTER_B_VHF_L;
629 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterB_VHF_L);//=VIF_YC_DELAY_FILTER_B_VHF_L;
630 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterB_VHF_L);//=VIF_GROUP_DELAY_FILTER_B_VHF_L;
631 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterGH_VHF_L);//=VIF_PEAKING_FILTER_GH_VHF_L;
632 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterGH_VHF_L);//=VIF_YC_DELAY_FILTER_GH_VHF_L;
633 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterGH_VHF_L);//=VIF_GROUP_DELAY_FILTER_GH_VHF_L;
634 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterDK_VHF_L);//=VIF_PEAKING_FILTER_DK_VHF_L;
635 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterDK_VHF_L);//=VIF_YC_DELAY_FILTER_DK_VHF_L;
636 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterDK_VHF_L);//=VIF_GROUP_DELAY_FILTER_DK_VHF_L;
637 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterI_VHF_L);//=VIF_PEAKING_FILTER_I_VHF_L;
638 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterI_VHF_L);//=VIF_YC_DELAY_FILTER_I_VHF_L;
639 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterI_VHF_L);//=VIF_GROUP_DELAY_FILTER_I_VHF_L;
640 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterL_VHF_L);//=VIF_PEAKING_FILTER_L_VHF_L;
641 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterL_VHF_L);//=VIF_YC_DELAY_FILTER_L_VHF_L;
642 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterL_VHF_L);//=VIF_GROUP_DELAY_FILTER_L_VHF_L;
643 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterLL_VHF_L);//=VIF_PEAKING_FILTER_LL_VHF_L;
644 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterLL_VHF_L);//=VIF_YC_DELAY_FILTER_LL_VHF_L;
645 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterLL_VHF_L);//=VIF_GROUP_DELAY_FILTER_LL_VHF_L;
646 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterMN_VHF_L);//=VIF_PEAKING_FILTER_MN_VHF_L;
647 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterMN_VHF_L);//=VIF_YC_DELAY_FILTER_MN_VHF_L;
648 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterMN_VHF_L);//=VIF_GROUP_DELAY_FILTER_MN_VHF_L;
649 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterB_VHF_H);//=VIF_PEAKING_FILTER_B_VHF_H;
650 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterB_VHF_H);//=VIF_YC_DELAY_FILTER_B_VHF_H;
651 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterB_VHF_H);//=VIF_GROUP_DELAY_FILTER_B_VHF_H;
652 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterGH_VHF_H);//=VIF_PEAKING_FILTER_GH_VHF_H;
653 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterGH_VHF_H);//=VIF_YC_DELAY_FILTER_GH_VHF_H;
654 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterGH_VHF_H);//=VIF_GROUP_DELAY_FILTER_GH_VHF_H;
655 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterDK_VHF_H);//=VIF_PEAKING_FILTER_DK_VHF_H;
656 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterDK_VHF_H);//=VIF_YC_DELAY_FILTER_DK_VHF_H;
657 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterDK_VHF_H);//=VIF_GROUP_DELAY_FILTER_DK_VHF_H;
658 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterI_VHF_H);//=VIF_PEAKING_FILTER_I_VHF_H;
659 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterI_VHF_H);//=VIF_YC_DELAY_FILTER_I_VHF_H;
660 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterI_VHF_H);//=VIF_GROUP_DELAY_FILTER_I_VHF_H;
661 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterL_VHF_H);//=VIF_PEAKING_FILTER_L_VHF_H;
662 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterL_VHF_H);//=VIF_YC_DELAY_FILTER_L_VHF_H;
663 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterL_VHF_H);//=VIF_GROUP_DELAY_FILTER_L_VHF_H;
664 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterLL_VHF_H);//=VIF_PEAKING_FILTER_LL_VHF_H;
665 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterLL_VHF_H);//=VIF_YC_DELAY_FILTER_LL_VHF_H;
666 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterLL_VHF_H);//=VIF_GROUP_DELAY_FILTER_LL_VHF_H;
667 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterMN_VHF_H);//=VIF_PEAKING_FILTER_MN_VHF_H;
668 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterMN_VHF_H);//=VIF_YC_DELAY_FILTER_MN_VHF_H;
669 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterMN_VHF_H);//=VIF_GROUP_DELAY_FILTER_MN_VHF_H;
670 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterB_UHF);//=VIF_PEAKING_FILTER_B_UHF;
671 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterB_UHF);//=VIF_YC_DELAY_FILTER_B_UHF;
672 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterB_UHF);//=VIF_GROUP_DELAY_FILTER_B_UHF;
673 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterGH_UHF);//=VIF_PEAKING_FILTER_GH_UHF;
674 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterGH_UHF);//=VIF_YC_DELAY_FILTER_GH_UHF;
675 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterGH_UHF);//=VIF_GROUP_DELAY_FILTER_GH_UHF;
676 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterDK_UHF);//=VIF_PEAKING_FILTER_DK_UHF;
677 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterDK_UHF);//=VIF_YC_DELAY_FILTER_DK_UHF;
678 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterDK_UHF);//=VIF_GROUP_DELAY_FILTER_DK_UHF;
679 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterI_UHF);//=VIF_PEAKING_FILTER_I_UHF;
680 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterI_UHF);//=VIF_YC_DELAY_FILTER_I_UHF;
681 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterI_UHF);//=VIF_GROUP_DELAY_FILTER_I_UHF;
682 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterL_UHF);//=VIF_PEAKING_FILTER_L_UHF;
683 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterL_UHF);//=VIF_YC_DELAY_FILTER_L_UHF;
684 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterL_UHF);//=VIF_GROUP_DELAY_FILTER_L_UHF;
685 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterLL_UHF);//=VIF_PEAKING_FILTER_LL_UHF;
686 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterLL_UHF);//=VIF_YC_DELAY_FILTER_LL_UHF;
687 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterLL_UHF);//=VIF_GROUP_DELAY_FILTER_LL_UHF;
688 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifPeakingFilterMN_UHF);//=VIF_PEAKING_FILTER_MN_UHF;
689 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifYcDelayFilterMN_UHF);//=VIF_YC_DELAY_FILTER_MN_UHF;
690 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifGroupDelayFilterMN_UHF);//=VIF_GROUP_DELAY_FILTER_MN_UHF;
691 printf("\r\n %x",(WORD)VIFInitialIn_inst.ChinaDescramblerBox);// = CHINA_DESCRAMBLER_BOX;
692 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifDelayReduce);//= VIF_DELAY_REDUCE;
693 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifOverModulation);//=VIF_OVER_MODULATION;
694 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifOverModulationDetect);
695 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifACIDetect);
696 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifACIAGCREF);
697 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifADCOverflowAGCREF);
698 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifChanelScanAGCREF);
699 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifACIDetTHR1);
700 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifACIDetTHR2);
701 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifACIDetTHR3);
702 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifACIDetTHR4);
703 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifFreqBand);// = FREQ_VHF_L; // should be changed when setting tuner freq
704 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos21FilterC0);//= VIF_SOS21_FILTER_C0;
705 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos21FilterC1);//= VIF_SOS21_FILTER_C1;
706 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos21FilterC2);//= VIF_SOS21_FILTER_C2;
707 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos21FilterC3);//= VIF_SOS21_FILTER_C3;
708 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos21FilterC4);//= VIF_SOS21_FILTER_C4;
709 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos22FilterC0);//= VIF_SOS22_FILTER_C0;
710 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos22FilterC1);//= VIF_SOS22_FILTER_C1;
711 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos22FilterC2);//= VIF_SOS22_FILTER_C2;
712 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos22FilterC3);//= VIF_SOS22_FILTER_C3;
713 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos22FilterC4);//= VIF_SOS22_FILTER_C4;
714 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos31FilterC0);//= VIF_SOS31_FILTER_C0;
715 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos31FilterC1);//= VIF_SOS31_FILTER_C1;
716 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos31FilterC2);//= VIF_SOS31_FILTER_C2;
717 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos31FilterC3);//= VIF_SOS31_FILTER_C3;
718 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos31FilterC4);//= VIF_SOS31_FILTER_C4;
719 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos32FilterC0);//= VIF_SOS32_FILTER_C0;
720 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos32FilterC1);//= VIF_SOS32_FILTER_C1;
721 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos32FilterC2);//= VIF_SOS32_FILTER_C2;
722 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos32FilterC3);//= VIF_SOS32_FILTER_C3;
723 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifSos32FilterC4);//= VIF_SOS32_FILTER_C4;
724 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifTunerType);
725 printf("\r\n %x",(WORD)((VIFInitialIn_inst.VifCrRate_B>>16)&0x0000FFFF));
726 printf("%x",(WORD)(VIFInitialIn_inst.VifCrRate_B&0x0000FFFF));
727 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrInvert_B);
728 printf("\r\n %x",(WORD)((VIFInitialIn_inst.VifCrRate_GH>>16)&0x0000FFFF));
729 printf("%x",(WORD)(VIFInitialIn_inst.VifCrRate_GH&0x0000FFFF));
730 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrInvert_GH);
731 printf("\r\n %x",(WORD)((VIFInitialIn_inst.VifCrRate_DK>>16)&0x0000FFFF));
732 printf("%x",(WORD)(VIFInitialIn_inst.VifCrRate_DK&0x0000FFFF));
733 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrInvert_DK);
734 printf("\r\n %x",(WORD)((VIFInitialIn_inst.VifCrRate_I>>16)&0x0000FFFF));
735 printf("%x",(WORD)(VIFInitialIn_inst.VifCrRate_I&0x0000FFFF));
736 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrInvert_I);
737 printf("\r\n %x",(WORD)((VIFInitialIn_inst.VifCrRate_L>>16)&0x0000FFFF));
738 printf("%x",(WORD)(VIFInitialIn_inst.VifCrRate_L&0x0000FFFF));
739 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrInvert_L);
740 printf("\r\n %x",(WORD)((VIFInitialIn_inst.VifCrRate_LL>>16)&0x0000FFFF));
741 printf("%x",(WORD)(VIFInitialIn_inst.VifCrRate_LL&0x0000FFFF));
742 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrInvert_LL);
743 printf("\r\n %x",(WORD)((VIFInitialIn_inst.VifCrRate_MN>>16)&0x0000FFFF));
744 printf("%x",(WORD)(VIFInitialIn_inst.VifCrRate_MN&0x0000FFFF));
745 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifCrInvert_MN);
746 printf("\r\n %x",(WORD)VIFInitialIn_inst.VifReserve);
747 printf("\r\n------------End of VIF lib para-----------");
748 }
749
750 msVifAdcInitial();
751
752 if (VIFInitialIn_inst.VifIfBaseFreq == IF_FREQ_45_75)
753 msVifSetIfFreq(IF_FREQ_4575);
754 else if (VIFInitialIn_inst.VifIfBaseFreq == IF_FREQ_38_00)
755 msVifSetIfFreq(IF_FREQ_3800);
756 else
757 msVifSetIfFreq(IF_FREQ_3890);
758
759 msVifSetSoundSystem(VIF_SOUND_DK2);//initial
760 msVifTopAdjust();
761 msVifInitial();
762 }
763
VIF_Exit(void)764 void VIF_Exit(void)
765 {
766 msVifExit();
767 bIsATV = FALSE;
768 }
769
VIF_Reset(void)770 void VIF_Reset(void)
771 {
772 msVifInitial();
773 }
774
VIF_Handler(BOOL bAutoScan)775 void VIF_Handler(BOOL bAutoScan)
776 {
777 msVifHandler(bAutoScan);
778 }
779
VIF_SetSoundSystem(VIFSoundSystem ucSoundSystem)780 void VIF_SetSoundSystem(VIFSoundSystem ucSoundSystem)
781 {
782 DRVVIFDBG(printf("DRV_VIF_SetSoundSystem ucSoundSystem=%d\n",ucSoundSystem));
783 gVIFSoundSystem = ucSoundSystem;
784 msVifSetSoundSystem(ucSoundSystem);
785 }
786
VIF_SetIfFreq(IfFrequencyType u16IfFreq)787 void VIF_SetIfFreq(IfFrequencyType u16IfFreq)
788 {
789 DRVVIFDBG(printf("DRV_VIF_SetIfFreq() u16IfFreq=%d\n",u16IfFreq));
790 msVifSetIfFreq(u16IfFreq);
791 }
792
VIF_BypassDBBAudioFilter(BOOL bEnable)793 void VIF_BypassDBBAudioFilter(BOOL bEnable)
794 {
795 DRVVIFDBG(printf("DRV_VIF_BypassDBBAudioFilter() bEnableq=%d\n",bEnable));
796 HAL_VIF_BypassDBBAudioFilter(bEnable);
797 }
798
VIF_SetFreqBand(FrequencyBand u8FreqBand)799 void VIF_SetFreqBand(FrequencyBand u8FreqBand)
800 {
801 DRVVIFDBG(printf("DRV_VIF_SetFreqBand() u8FreqBand=%d\n",u8FreqBand));
802 VIFInitialIn_inst.VifFreqBand = u8FreqBand;
803
804 //g_FreqBand = u8FreqBand; // 0x1121_D4
805 VIF_WriteByte(VIF_RF_RESERVED_1+2, u8FreqBand);
806 }
807
VIF_GetInputLevelIndicator(void)808 BOOL VIF_GetInputLevelIndicator(void)
809 {
810 DRVVIFDBG(printf("DRV_VIF_GetInputLevelIndicator() \n"));
811 return HAL_VIF_GetInputLevelIndicator();
812 }
813
VIF_CopyFilter(BYTE i)814 void VIF_CopyFilter(BYTE i)
815 {
816 if (i==1) // set peaking
817 {
818 VIFInitialIn_inst.VifSos21FilterC0=sVIFUserFilter.VifSos21FilterC0;
819 VIFInitialIn_inst.VifSos21FilterC1=sVIFUserFilter.VifSos21FilterC1;
820 VIFInitialIn_inst.VifSos21FilterC2=sVIFUserFilter.VifSos21FilterC2;
821 VIFInitialIn_inst.VifSos21FilterC3=sVIFUserFilter.VifSos21FilterC3;
822 VIFInitialIn_inst.VifSos21FilterC4=sVIFUserFilter.VifSos21FilterC4;
823 }
824 else if (i==2) // set YC
825 {
826 VIFInitialIn_inst.VifSos22FilterC0=sVIFUserFilter.VifSos22FilterC0;
827 VIFInitialIn_inst.VifSos22FilterC1=sVIFUserFilter.VifSos22FilterC1;
828 VIFInitialIn_inst.VifSos22FilterC2=sVIFUserFilter.VifSos22FilterC2;
829 VIFInitialIn_inst.VifSos22FilterC3=sVIFUserFilter.VifSos22FilterC3;
830 VIFInitialIn_inst.VifSos22FilterC4=sVIFUserFilter.VifSos22FilterC4;
831 }
832 else if (i==3) // set group delay
833 {
834 VIFInitialIn_inst.VifSos31FilterC0=sVIFUserFilter.VifSos31FilterC0;
835 VIFInitialIn_inst.VifSos31FilterC1=sVIFUserFilter.VifSos31FilterC1;
836 VIFInitialIn_inst.VifSos31FilterC2=sVIFUserFilter.VifSos31FilterC2;
837 VIFInitialIn_inst.VifSos31FilterC3=sVIFUserFilter.VifSos31FilterC3;
838 VIFInitialIn_inst.VifSos31FilterC4=sVIFUserFilter.VifSos31FilterC4;
839 VIFInitialIn_inst.VifSos32FilterC0=sVIFUserFilter.VifSos32FilterC0;
840 VIFInitialIn_inst.VifSos32FilterC1=sVIFUserFilter.VifSos32FilterC1;
841 VIFInitialIn_inst.VifSos32FilterC2=sVIFUserFilter.VifSos32FilterC2;
842 VIFInitialIn_inst.VifSos32FilterC3=sVIFUserFilter.VifSos32FilterC3;
843 VIFInitialIn_inst.VifSos32FilterC4=sVIFUserFilter.VifSos32FilterC4;
844 /*
845 sVIFSOS33.Vif_SOS_33_C0=sVIFUserFilter.VifSos33FilterC0;
846 sVIFSOS33.Vif_SOS_33_C1=sVIFUserFilter.VifSos33FilterC1;
847 sVIFSOS33.Vif_SOS_33_C2=sVIFUserFilter.VifSos33FilterC2;
848 sVIFSOS33.Vif_SOS_33_C3=sVIFUserFilter.VifSos33FilterC3;
849 sVIFSOS33.Vif_SOS_33_C4=sVIFUserFilter.VifSos33FilterC4;
850 */
851 }
852 }
853
VIF_SetParameter(VIF_PARA_GROUP paraGroup,void * pVIF_Para,DWORD u32DataLen)854 BOOL VIF_SetParameter(VIF_PARA_GROUP paraGroup, void * pVIF_Para, DWORD u32DataLen)
855 {
856 static VIFNotchA1A2 sVIFNotchA1A2 = {0};
857 static VIFSOS1112 sVIFSOS1112 = {0};
858 static DWORD dwVIFPara = 0;
859
860 DRVVIFDBG(printf("DRV_VIF_SetParameter() \n"));
861
862 switch (paraGroup)
863 {
864 case VIF_PARA_USER_FILTER:
865 if ( sizeof(VIFUserFilter) == u32DataLen)
866 {
867 memcpy(&sVIFUserFilter, (VIFUserFilter *) pVIF_Para, u32DataLen);
868
869 // check if need to update user define peaking filter
870 if ((sVIFUserFilter.VifUserPeakingFilterSelect>=PK_START) &&
871 (sVIFUserFilter.VifUserPeakingFilterSelect<=PK_END))
872 {
873 VIF_CopyFilter(1);
874
875 if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_B_VHF_L)
876 VIFInitialIn_inst.VifPeakingFilterB_VHF_L = 0x80;
877 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_GH_VHF_L)
878 VIFInitialIn_inst.VifPeakingFilterGH_VHF_L = 0x80;
879 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_DK_VHF_L)
880 VIFInitialIn_inst.VifPeakingFilterDK_VHF_L = 0x80;
881 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_I_VHF_L)
882 VIFInitialIn_inst.VifPeakingFilterI_VHF_L = 0x80;
883 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_L_VHF_L)
884 VIFInitialIn_inst.VifPeakingFilterL_VHF_L = 0x80;
885 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_LL_VHF_L)
886 VIFInitialIn_inst.VifPeakingFilterLL_VHF_L = 0x80;
887 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_MN_VHF_L)
888 VIFInitialIn_inst.VifPeakingFilterMN_VHF_L = 0x80;
889 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_B_VHF_H)
890 VIFInitialIn_inst.VifPeakingFilterB_VHF_H = 0x80;
891 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_GH_VHF_H)
892 VIFInitialIn_inst.VifPeakingFilterGH_VHF_H = 0x80;
893 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_DK_VHF_H)
894 VIFInitialIn_inst.VifPeakingFilterDK_VHF_H = 0x80;
895 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_I_VHF_H)
896 VIFInitialIn_inst.VifPeakingFilterI_VHF_H = 0x80;
897 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_L_VHF_H)
898 VIFInitialIn_inst.VifPeakingFilterL_VHF_H = 0x80;
899 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_LL_VHF_H)
900 VIFInitialIn_inst.VifPeakingFilterLL_VHF_H = 0x80;
901 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_MN_VHF_H)
902 VIFInitialIn_inst.VifPeakingFilterMN_VHF_H = 0x80;
903 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_B_UHF)
904 VIFInitialIn_inst.VifPeakingFilterB_UHF = 0x80;
905 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_GH_UHF)
906 VIFInitialIn_inst.VifPeakingFilterGH_UHF = 0x80;
907 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_DK_UHF)
908 VIFInitialIn_inst.VifPeakingFilterDK_UHF = 0x80;
909 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_I_UHF)
910 VIFInitialIn_inst.VifPeakingFilterI_UHF = 0x80;
911 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_L_UHF)
912 VIFInitialIn_inst.VifPeakingFilterL_UHF = 0x80;
913 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_LL_UHF)
914 VIFInitialIn_inst.VifPeakingFilterLL_UHF = 0x80;
915 else if (sVIFUserFilter.VifUserPeakingFilterSelect==PK_MN_UHF)
916 VIFInitialIn_inst.VifPeakingFilterMN_UHF = 0x80;
917 }
918
919 // check if need to update user define YC filter
920 if ((sVIFUserFilter.VifUserYcDelayFilterSelect>=YC_START) &&
921 (sVIFUserFilter.VifUserYcDelayFilterSelect<=YC_END))
922 {
923 VIF_CopyFilter(2);
924
925 if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_B_VHF_L)
926 VIFInitialIn_inst.VifYcDelayFilterB_VHF_L = 0x80;
927 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_GH_VHF_L)
928 VIFInitialIn_inst.VifYcDelayFilterGH_VHF_L = 0x80;
929 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_DK_VHF_L)
930 VIFInitialIn_inst.VifYcDelayFilterDK_VHF_L = 0x80;
931 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_I_VHF_L)
932 VIFInitialIn_inst.VifYcDelayFilterI_VHF_L = 0x80;
933 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_L_VHF_L)
934 VIFInitialIn_inst.VifYcDelayFilterL_VHF_L = 0x80;
935 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_LL_VHF_L)
936 VIFInitialIn_inst.VifYcDelayFilterLL_VHF_L = 0x80;
937 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_MN_VHF_L)
938 VIFInitialIn_inst.VifYcDelayFilterMN_VHF_L = 0x80;
939 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_B_VHF_H)
940 VIFInitialIn_inst.VifYcDelayFilterB_VHF_H = 0x80;
941 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_GH_VHF_H)
942 VIFInitialIn_inst.VifYcDelayFilterGH_VHF_H = 0x80;
943 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_DK_VHF_H)
944 VIFInitialIn_inst.VifYcDelayFilterDK_VHF_H = 0x80;
945 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_I_VHF_H)
946 VIFInitialIn_inst.VifYcDelayFilterI_VHF_H = 0x80;
947 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_L_VHF_H)
948 VIFInitialIn_inst.VifYcDelayFilterL_VHF_H = 0x80;
949 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_LL_VHF_H)
950 VIFInitialIn_inst.VifYcDelayFilterLL_VHF_H = 0x80;
951 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_MN_VHF_H)
952 VIFInitialIn_inst.VifYcDelayFilterMN_VHF_H = 0x80;
953 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_B_UHF)
954 VIFInitialIn_inst.VifYcDelayFilterB_UHF = 0x80;
955 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_GH_UHF)
956 VIFInitialIn_inst.VifYcDelayFilterGH_UHF = 0x80;
957 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_DK_UHF)
958 VIFInitialIn_inst.VifYcDelayFilterDK_UHF = 0x80;
959 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_I_UHF)
960 VIFInitialIn_inst.VifYcDelayFilterI_UHF = 0x80;
961 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_L_UHF)
962 VIFInitialIn_inst.VifYcDelayFilterL_UHF = 0x80;
963 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_LL_UHF)
964 VIFInitialIn_inst.VifYcDelayFilterLL_UHF = 0x80;
965 else if (sVIFUserFilter.VifUserYcDelayFilterSelect==YC_MN_UHF)
966 VIFInitialIn_inst.VifYcDelayFilterMN_UHF = 0x80;
967 }
968
969 // check if need to update user define Group delay filter
970 if ((sVIFUserFilter.VifUserGroupDelayFilterSelect>=GP_START) &&
971 (sVIFUserFilter.VifUserGroupDelayFilterSelect<=GP_END))
972 {
973 VIF_CopyFilter(3);
974
975 if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_B_VHF_L)
976 VIFInitialIn_inst.VifGroupDelayFilterB_VHF_L = 0x80;
977 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_GH_VHF_L)
978 VIFInitialIn_inst.VifGroupDelayFilterGH_VHF_L = 0x80;
979 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_DK_VHF_L)
980 VIFInitialIn_inst.VifGroupDelayFilterDK_VHF_L = 0x80;
981 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_I_VHF_L)
982 VIFInitialIn_inst.VifGroupDelayFilterI_VHF_L = 0x80;
983 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_L_VHF_L)
984 VIFInitialIn_inst.VifGroupDelayFilterL_VHF_L = 0x80;
985 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_LL_VHF_L)
986 VIFInitialIn_inst.VifGroupDelayFilterLL_VHF_L = 0x80;
987 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_MN_VHF_L)
988 VIFInitialIn_inst.VifGroupDelayFilterMN_VHF_L = 0x80;
989 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_B_VHF_H)
990 VIFInitialIn_inst.VifGroupDelayFilterB_VHF_H = 0x80;
991 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_GH_VHF_H)
992 VIFInitialIn_inst.VifGroupDelayFilterGH_VHF_H = 0x80;
993 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_DK_VHF_H)
994 VIFInitialIn_inst.VifGroupDelayFilterDK_VHF_H = 0x80;
995 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_I_VHF_H)
996 VIFInitialIn_inst.VifGroupDelayFilterI_VHF_H = 0x80;
997 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_L_VHF_H)
998 VIFInitialIn_inst.VifGroupDelayFilterL_VHF_H = 0x80;
999 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_LL_VHF_H)
1000 VIFInitialIn_inst.VifGroupDelayFilterLL_VHF_H = 0x80;
1001 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_MN_VHF_H)
1002 VIFInitialIn_inst.VifGroupDelayFilterMN_VHF_H = 0x80;
1003 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_B_UHF)
1004 VIFInitialIn_inst.VifGroupDelayFilterB_UHF = 0x80;
1005 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_GH_UHF)
1006 VIFInitialIn_inst.VifGroupDelayFilterGH_UHF = 0x80;
1007 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_DK_UHF)
1008 VIFInitialIn_inst.VifGroupDelayFilterDK_UHF = 0x80;
1009 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_I_UHF)
1010 VIFInitialIn_inst.VifGroupDelayFilterI_UHF = 0x80;
1011 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_L_UHF)
1012 VIFInitialIn_inst.VifGroupDelayFilterL_UHF = 0x80;
1013 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_LL_UHF)
1014 VIFInitialIn_inst.VifGroupDelayFilterLL_UHF = 0x80;
1015 else if (sVIFUserFilter.VifUserGroupDelayFilterSelect==GP_MN_UHF)
1016 VIFInitialIn_inst.VifGroupDelayFilterMN_UHF = 0x80;
1017 }
1018 }
1019 else
1020 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_USER_FILTER");
1021 break;
1022
1023 case VIF_PARA_TOP:
1024 if ( sizeof(DWORD) == u32DataLen)
1025 {
1026 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1027 VIFInitialIn_inst.VifTop = (U8) dwVIFPara;
1028 msVifTopAdjust();
1029 }
1030 else
1031 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_TOP");
1032 break;
1033
1034 case VIF_PARA_LEAKY_SEL:
1035 if ( sizeof(DWORD) == u32DataLen)
1036 {
1037 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1038 VIFInitialIn_inst.VifCrLockLeakySel = ((U8) dwVIFPara==0) ? FALSE:TRUE;
1039 VIF_WriteBit(LOCK_LEAKY_FF_SEL, VIFInitialIn_inst.VifCrLockLeakySel, _BIT0);
1040 }
1041 else
1042 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_LEAKY_SEL");
1043 break;
1044
1045 case VIF_PARA_K_SEL:
1046 if ( sizeof(DWORD) == u32DataLen)
1047 {
1048 BOOL K_select;
1049 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1050 K_select = ((U8) dwVIFPara==0) ? FALSE:TRUE;
1051 VIF_WriteBit(CR_K_SEL, K_select, _BIT6);
1052 }
1053 else
1054 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_K_SEL");
1055 break;
1056
1057 case VIF_PARA_GET_VERSION:
1058 if ( 30 == u32DataLen)
1059 {
1060 U8 sVersion[30]={0x00};
1061 // VIF version
1062 #ifdef _2_DIGIT_CHIP_TYPE_
1063 memcpy(sVersion, VIF_Version1, 5);
1064 memcpy(sVersion+5, VIF_Version2, 2);
1065 memcpy(sVersion+7, VIF_Version3, 1);
1066 memcpy(sVersion+8, VIF_Version4, 2);
1067 memcpy(sVersion+10, VIF_Version5, 1);
1068 memcpy(sVersion+11, VIF_Version6, 2);
1069 memcpy(sVersion+13, VIF_Version7, 1);
1070 memcpy(sVersion+14, VIF_Version8, 6);
1071 memcpy(sVersion+20, VIF_Version9, 1);
1072 memcpy(sVersion+21, VIF_VersionA, 8);
1073 #else
1074 memcpy(sVersion, VIF_Version1, 5);
1075 memcpy(sVersion+5, VIF_Version2, 1);
1076 memcpy(sVersion+6, VIF_Version3, 1);
1077 memcpy(sVersion+7, VIF_Version4, 2);
1078 memcpy(sVersion+9, VIF_Version5, 1);
1079 memcpy(sVersion+10, VIF_Version6, 2);
1080 memcpy(sVersion+12, VIF_Version7, 1);
1081 memcpy(sVersion+13, VIF_Version8, 6);
1082 memcpy(sVersion+19, VIF_Version9, 1);
1083 memcpy(sVersion+20, VIF_VersionA, 8);
1084 #endif
1085 memcpy(pVIF_Para ,sVersion,30);
1086 }
1087 else
1088 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_GET_VERSION");
1089 break;
1090
1091 case VIF_PARA_SET_BYPASS_PEAKING_SOS21:
1092 if ( sizeof(DWORD) == u32DataLen)
1093 {
1094 BOOL bBypassSOS21;
1095 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1096 bBypassSOS21 = ((U8) dwVIFPara==0) ? FALSE:TRUE;
1097 VIF_WriteBit(BYPASS_SOS21, bBypassSOS21, _BIT2);
1098 }
1099 else
1100 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_BYPASS_FILTER");
1101 break;
1102
1103 case VIF_PARA_GET_PGA2_LEVEL:
1104 if ( sizeof(BYTE) == u32DataLen)
1105 {
1106 BYTE u8Pga2;
1107 u8Pga2= VIF_ReadByte(AGC_PGA2C) & 0x1F;
1108 memcpy(pVIF_Para, &u8Pga2, u32DataLen);
1109 }
1110 else
1111 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_GET_PGA2_LEVEL");
1112 break;
1113
1114 case VIF_PARA_GET_IF:
1115 if ( sizeof(WORD) == u32DataLen)
1116 {
1117 U16 u16FreqType;// = g_FreqType;
1118
1119 u16FreqType = (U16)(VIF_ReadByte(VIF_RF_RESERVED_1));
1120 memcpy(pVIF_Para, &u16FreqType, u32DataLen);
1121 }
1122 else
1123 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_GET_IF");
1124 break;
1125
1126 case VIF_PARA_GET_K_SEL:
1127 if ( sizeof(BYTE) == u32DataLen)
1128 {
1129 U8 K_select;
1130
1131 if ((VIF_ReadByte(CR_K_SEL) & _BIT6)!=0)
1132 K_select=1;
1133 else
1134 K_select=0;
1135
1136 memcpy(pVIF_Para, &K_select,1);
1137 }
1138 else
1139 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_GET_K_SEL");
1140 break;
1141
1142 case VIF_PARA_SET_HW_KPKI:
1143 if ( sizeof(DWORD) == u32DataLen)
1144 {
1145 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1146 VIF_WriteByte(CR_KP1_HW, (U8) dwVIFPara);
1147 }
1148 else
1149 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_HW_KPKI");
1150 break;
1151
1152 case VIF_PARA_SET_TAGC_ODMODE:
1153 if ( sizeof(DWORD) == u32DataLen)
1154 {
1155 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1156
1157 if ((U8) dwVIFPara==0)
1158 {
1159 VIF_WriteBit(TAGC_ODMODE, FALSE, _BIT1);
1160 VIF_WriteBit(TAGC_ODMODE, FALSE, _BIT5);
1161 }
1162 else if ((U8) dwVIFPara==1) // RF AGC OD MODE
1163 {
1164 VIF_WriteBit(TAGC_ODMODE, TRUE, _BIT1);
1165 }
1166 else if ((U8) dwVIFPara==2) // IF AGC OD MODE
1167 {
1168 VIF_WriteBit(TAGC_ODMODE, TRUE, _BIT5);
1169 }
1170 else if ((U8) dwVIFPara==3)
1171 {
1172 VIF_WriteBit(TAGC_ODMODE, TRUE, _BIT1);
1173 VIF_WriteBit(TAGC_ODMODE, TRUE, _BIT5);
1174 }
1175 }
1176 else
1177 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_TAGC_ODMODE");
1178 break;
1179
1180 case VIF_PARA_SET_NOTCH_A1A2:
1181 if ( sizeof(VIFNotchA1A2) == u32DataLen)
1182 {
1183 memcpy(&sVIFNotchA1A2, (VIFNotchA1A2 *) pVIF_Para, u32DataLen);
1184
1185 if(strcmp(CHIP_TYPE, EDEN) < 0)
1186 {
1187 VIF_WriteByte(N_A1_C0_L, (U8) (sVIFNotchA1A2.Vif_N_A1_C0 & 0x00FF));
1188 VIF_WriteByte(N_A1_C0_H, (U8) ((sVIFNotchA1A2.Vif_N_A1_C0>>8) & 0x00FF));
1189 VIF_WriteByte(N_A1_C1_L, (U8) (sVIFNotchA1A2.Vif_N_A1_C1 & 0x00FF));
1190 VIF_WriteByte(N_A1_C1_H, (U8) ((sVIFNotchA1A2.Vif_N_A1_C1>>8) & 0x00FF));
1191 VIF_WriteByte(N_A1_C2_L, (U8) (sVIFNotchA1A2.Vif_N_A1_C2 & 0x00FF));
1192 VIF_WriteByte(N_A1_C2_H, (U8) ((sVIFNotchA1A2.Vif_N_A1_C2>>8) & 0x00FF));
1193 VIF_WriteByte(N_A2_C0_L, (U8) (sVIFNotchA1A2.Vif_N_A2_C0 & 0x00FF));
1194 VIF_WriteByte(N_A2_C0_H, (U8) ((sVIFNotchA1A2.Vif_N_A2_C0>>8) & 0x00FF));
1195 VIF_WriteByte(N_A2_C1_L, (U8) (sVIFNotchA1A2.Vif_N_A2_C1 & 0x00FF));
1196 VIF_WriteByte(N_A2_C1_H, (U8) ((sVIFNotchA1A2.Vif_N_A2_C1>>8) & 0x00FF));
1197 VIF_WriteByte(N_A2_C2_L, (U8) (sVIFNotchA1A2.Vif_N_A2_C2 & 0x00FF));
1198 VIF_WriteByte(N_A2_C2_H, (U8) ((sVIFNotchA1A2.Vif_N_A2_C2>>8) & 0x00FF));
1199 }
1200 else
1201 {
1202 if((VIFInitialIn_inst.ChinaDescramblerBox >= 2)&&(VIFInitialIn_inst.ChinaDescramblerBox != 7))
1203 {
1204 VIF_WriteByte(N_A1_C0_L, (U8) (sVIFNotchA1A2.Vif_N_A1_C0 & 0x00FF));
1205 VIF_WriteByte(N_A1_C0_H, (U8) ((sVIFNotchA1A2.Vif_N_A1_C0>>8) & 0x00FF));
1206 VIF_WriteByte(N_A1_C1_L, (U8) (sVIFNotchA1A2.Vif_N_A1_C1 & 0x00FF));
1207 VIF_WriteByte(N_A1_C1_H, (U8) ((sVIFNotchA1A2.Vif_N_A1_C1>>8) & 0x00FF));
1208 VIF_WriteByte(N_A1_C2_L, (U8) (sVIFNotchA1A2.Vif_N_A1_C2 & 0x00FF));
1209 VIF_WriteByte(N_A1_C2_H, (U8) ((sVIFNotchA1A2.Vif_N_A1_C2>>8) & 0x00FF));
1210 VIF_WriteByte(N_A2_C0_L, (U8) (sVIFNotchA1A2.Vif_N_A2_C0 & 0x00FF));
1211 VIF_WriteByte(N_A2_C0_H, (U8) ((sVIFNotchA1A2.Vif_N_A2_C0>>8) & 0x00FF));
1212 VIF_WriteByte(N_A2_C1_L, (U8) (sVIFNotchA1A2.Vif_N_A2_C1 & 0x00FF));
1213 VIF_WriteByte(N_A2_C1_H, (U8) ((sVIFNotchA1A2.Vif_N_A2_C1>>8) & 0x00FF));
1214 VIF_WriteByte(N_A2_C2_L, (U8) (sVIFNotchA1A2.Vif_N_A2_C2 & 0x00FF));
1215 VIF_WriteByte(N_A2_C2_H, (U8) ((sVIFNotchA1A2.Vif_N_A2_C2>>8) & 0x00FF));
1216 }
1217 }
1218 }
1219 else
1220 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_NOTCH_A1A2");
1221 break;
1222
1223 case VIF_PARA_SET_SOS_1112:
1224 if( sizeof(VIFSOS1112) == u32DataLen)
1225 {
1226 memcpy(&sVIFSOS1112, (VIFSOS1112 *) pVIF_Para, u32DataLen);
1227
1228 VIF_WriteByte(SOS11_C0_L, (U8) (sVIFSOS1112.Vif_SOS_11_C0 & 0x00FF));
1229 VIF_WriteByte(SOS11_C0_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C0>>8) & 0x00FF));
1230 VIF_WriteByte(SOS11_C1_L, (U8) (sVIFSOS1112.Vif_SOS_11_C1 & 0x00FF));
1231 VIF_WriteByte(SOS11_C1_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C1>>8) & 0x00FF));
1232 VIF_WriteByte(SOS11_C2_L, (U8) (sVIFSOS1112.Vif_SOS_11_C2 & 0x00FF));
1233 VIF_WriteByte(SOS11_C2_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C2>>8) & 0x00FF));
1234 VIF_WriteByte(SOS11_C3_L, (U8) (sVIFSOS1112.Vif_SOS_11_C3 & 0x00FF));
1235 VIF_WriteByte(SOS11_C3_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C3>>8) & 0x00FF));
1236 VIF_WriteByte(SOS11_C4_L, (U8) (sVIFSOS1112.Vif_SOS_11_C4 & 0x00FF));
1237 VIF_WriteByte(SOS11_C4_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C4>>8) & 0x00FF));
1238
1239 if(strcmp(CHIP_TYPE, EDEN) < 0)
1240 {
1241 VIF_WriteByte(SOS12_C0_L, (U8) (sVIFSOS1112.Vif_SOS_12_C0 & 0x00FF));
1242 VIF_WriteByte(SOS12_C0_H, (U8) ((sVIFSOS1112.Vif_SOS_12_C0>>8) & 0x00FF));
1243 VIF_WriteByte(SOS12_C1_L, (U8) (sVIFSOS1112.Vif_SOS_12_C1 & 0x00FF));
1244 VIF_WriteByte(SOS12_C1_H, (U8) ((sVIFSOS1112.Vif_SOS_12_C1>>8) & 0x00FF));
1245 VIF_WriteByte(SOS12_C2_L, (U8) (sVIFSOS1112.Vif_SOS_12_C2 & 0x00FF));
1246 VIF_WriteByte(SOS12_C2_H, (U8) ((sVIFSOS1112.Vif_SOS_12_C2>>8) & 0x00FF));
1247 VIF_WriteByte(SOS12_C3_L, (U8) (sVIFSOS1112.Vif_SOS_12_C3 & 0x00FF));
1248 VIF_WriteByte(SOS12_C3_H, (U8) ((sVIFSOS1112.Vif_SOS_12_C3>>8) & 0x00FF));
1249 VIF_WriteByte(SOS12_C4_L, (U8) (sVIFSOS1112.Vif_SOS_12_C4 & 0x00FF));
1250 VIF_WriteByte(SOS12_C4_H, (U8) ((sVIFSOS1112.Vif_SOS_12_C4>>8) & 0x00FF));
1251 }
1252 else
1253 {
1254 if((VIFInitialIn_inst.ChinaDescramblerBox >= 2)&&(VIFInitialIn_inst.ChinaDescramblerBox != 7))
1255 {
1256 VIF_WriteByte(SOS12_C0_L, (U8) (sVIFSOS1112.Vif_SOS_12_C0 & 0x00FF));
1257 VIF_WriteByte(SOS12_C0_H, (U8) ((sVIFSOS1112.Vif_SOS_12_C0>>8) & 0x00FF));
1258 VIF_WriteByte(SOS12_C1_L, (U8) (sVIFSOS1112.Vif_SOS_12_C1 & 0x00FF));
1259 VIF_WriteByte(SOS12_C1_H, (U8) ((sVIFSOS1112.Vif_SOS_12_C1>>8) & 0x00FF));
1260 VIF_WriteByte(SOS12_C2_L, (U8) (sVIFSOS1112.Vif_SOS_12_C2 & 0x00FF));
1261 VIF_WriteByte(SOS12_C2_H, (U8) ((sVIFSOS1112.Vif_SOS_12_C2>>8) & 0x00FF));
1262 VIF_WriteByte(SOS12_C3_L, (U8) (sVIFSOS1112.Vif_SOS_12_C3 & 0x00FF));
1263 VIF_WriteByte(SOS12_C3_H, (U8) ((sVIFSOS1112.Vif_SOS_12_C3>>8) & 0x00FF));
1264 VIF_WriteByte(SOS12_C4_L, (U8) (sVIFSOS1112.Vif_SOS_12_C4 & 0x00FF));
1265 VIF_WriteByte(SOS12_C4_H, (U8) ((sVIFSOS1112.Vif_SOS_12_C4>>8) & 0x00FF));
1266 }
1267 else if(VIFInitialIn_inst.ChinaDescramblerBox == 0)
1268 {
1269 if(strcmp(CHIP_TYPE, MADISON) >= 0)
1270 {
1271 VIF_WriteByte(N_A1_C0_L, (U8) (sVIFSOS1112.Vif_SOS_11_C0 & 0x00FF));
1272 VIF_WriteByte(N_A1_C0_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C0 >>8) & 0x00FF));
1273 VIF_WriteByte(N_A1_C1_L, (U8) (sVIFSOS1112.Vif_SOS_11_C1 & 0x00FF));
1274 VIF_WriteByte(N_A1_C1_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C1 >>8) & 0x00FF));
1275 VIF_WriteByte(N_A1_C2_L, (U8) (sVIFSOS1112.Vif_SOS_11_C3 & 0x00FF));
1276 VIF_WriteByte(N_A1_C2_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C3 >>8) & 0x00FF));
1277
1278 VIF_WriteByte(N_A2_C0_L, (U8) (sVIFSOS1112.Vif_SOS_11_C0 & 0x00FF));
1279 VIF_WriteByte(N_A2_C0_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C0 >>8) & 0x00FF));
1280 VIF_WriteByte(N_A2_C1_L, (U8) (sVIFSOS1112.Vif_SOS_11_C1 & 0x00FF));
1281 VIF_WriteByte(N_A2_C1_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C1 >>8) & 0x00FF));
1282 VIF_WriteByte(N_A2_C2_L, (U8) (sVIFSOS1112.Vif_SOS_11_C3 & 0x00FF));
1283 VIF_WriteByte(N_A2_C2_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C3 >>8) & 0x00FF));
1284
1285 VIF_WriteByte(SOS12_C0_L, (U8) (sVIFSOS1112.Vif_SOS_11_C0 & 0x00FF));
1286 VIF_WriteByte(SOS12_C0_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C0>>8) & 0x00FF));
1287 VIF_WriteByte(SOS12_C1_L, (U8) (sVIFSOS1112.Vif_SOS_11_C1 & 0x00FF));
1288 VIF_WriteByte(SOS12_C1_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C1>>8) & 0x00FF));
1289 VIF_WriteByte(SOS12_C2_L, (U8) (sVIFSOS1112.Vif_SOS_11_C2 & 0x00FF));
1290 VIF_WriteByte(SOS12_C2_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C2>>8) & 0x00FF));
1291 VIF_WriteByte(SOS12_C3_L, (U8) (sVIFSOS1112.Vif_SOS_11_C3 & 0x00FF));
1292 VIF_WriteByte(SOS12_C3_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C3>>8) & 0x00FF));
1293 VIF_WriteByte(SOS12_C4_L, (U8) (sVIFSOS1112.Vif_SOS_11_C4 & 0x00FF));
1294 VIF_WriteByte(SOS12_C4_H, (U8) ((sVIFSOS1112.Vif_SOS_11_C4>>8) & 0x00FF));
1295 }
1296 }
1297 }
1298 }
1299 else
1300 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_SOS_1112");
1301 break;
1302
1303 case VIF_PARA_GET_PD_INV:
1304 if ( sizeof(BYTE) == u32DataLen)
1305 {
1306 U8 pd_inv;
1307
1308 pd_inv=HAL_VIF_GetCrPDInverse();
1309
1310 memcpy(pVIF_Para, &pd_inv,1);
1311 }
1312 else
1313 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_GET_PD_INV");
1314 break;
1315
1316 case VIF_PARA_SET_PD_INV:
1317 if ( sizeof(DWORD) == u32DataLen)
1318 {
1319 // if in overmodulation, do NOT diable inverse Qpart
1320 if ((VIF_ReadByte(ZERO_DETECT) & _BIT4)==0)
1321 {
1322 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1323
1324 if ((U8) dwVIFPara==1)
1325 {
1326 HAL_VIF_SetCrPDInverse(TRUE);
1327 }
1328 else
1329 {
1330 HAL_VIF_SetCrPDInverse(FALSE);
1331 }
1332 }
1333 }
1334 else
1335 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_PD_INV");
1336 break;
1337
1338 case VIF_PARA_GET_VGA:
1339 if ( sizeof(WORD) == u32DataLen)
1340 {
1341 U16 u16Vga;
1342 u16Vga= (U16)(VIF_ReadByte(AGC_VGA))+ (U16)(VIF_ReadByte(AGC_VGA+1)<<8) ;
1343 memcpy(pVIF_Para, &u16Vga, u32DataLen);
1344 }
1345 else
1346 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_GET_VGA");
1347 break;
1348
1349 case VIF_PARA_SET_CLAMPGAIN_GAIN_OV_POS:
1350 if ( sizeof(DWORD) == u32DataLen)
1351 {
1352 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1353
1354 VIFInitialIn_inst.VifClampgainGainOvPositive = (U16)dwVIFPara;
1355 VIF_WriteByte(CLAMPGAIN_GAIN_OVERWRITE, dwVIFPara&0x000000FF); // clampgain gain overwrite value
1356 VIF_WriteByteMask(CLAMPGAIN_GAIN_OVERWRITE+1, dwVIFPara>>8, 0x07);
1357 }
1358 else
1359 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_CLAMPGAIN_GAIN_OV_POS");
1360 break;
1361
1362 case VIF_PARA_SET_CLAMPGAIN_GAIN_OV_NEG:
1363 if ( sizeof(DWORD) == u32DataLen)
1364 {
1365 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1366
1367 VIFInitialIn_inst.VifClampgainGainOvNegative = (U16)dwVIFPara;
1368 VIF_WriteByte(CLAMPGAIN_GAIN_OVERWRITE, dwVIFPara&0x000000FF); // clampgain gain overwrite value
1369 VIF_WriteByteMask(CLAMPGAIN_GAIN_OVERWRITE+1, dwVIFPara>>8, 0x07);
1370 }
1371 else
1372 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_CLAMPGAIN_GAIN_OV_NEG");
1373 break;
1374
1375 case VIF_PARA_SET_AGC_K:
1376 if ( sizeof(DWORD) == u32DataLen)
1377 {
1378 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1379
1380 if (((dwVIFPara>>24)&0x00000001)==1)
1381 {
1382 bEnableUsrSteadyAgcK = TRUE;
1383 u8UsrSteadyAgcK = (dwVIFPara>>16)&0x00000007;
1384 }
1385 else
1386 {
1387 bEnableUsrSteadyAgcK = FALSE;
1388 u8UsrSteadyAgcK = 0;
1389 }
1390
1391 if (((dwVIFPara>>8)&0x00000001)==1)
1392 {
1393 bEnableUsrNonSteadyAgcK = TRUE;
1394 u8UsrNonSteadyAgcK = dwVIFPara&0x00000007;
1395 }
1396 else
1397 {
1398 bEnableUsrNonSteadyAgcK = FALSE;
1399 u8UsrNonSteadyAgcK = 0;
1400 }
1401 }
1402 else
1403 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_AGC_K");
1404 break;
1405 case VIF_PARA_SET_AGC_REF:
1406 if ( sizeof(DWORD) == u32DataLen)
1407 {
1408 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1409
1410 VIFInitialIn_inst.VifAgcRefNegative = (U16)dwVIFPara;
1411 VIFInitialIn_inst.VifAgcRefPositive = (U16)dwVIFPara;
1412 VIF_WriteByte(AGC_REF, dwVIFPara&0x000000FF);
1413 }
1414 else
1415 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_AGC_REF");
1416 break;
1417
1418 case VIF_PARA_SET_IF_RATE_FM:
1419 if ( sizeof(DWORD) == u32DataLen)
1420 {
1421 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1422
1423 VIF_WriteByte(IF_RATE, (BYTE)(dwVIFPara & 0x000000FF));
1424 VIF_WriteByte(IF_RATE+1 , (BYTE)((dwVIFPara >> 8) & 0x000000FF));
1425 VIF_WriteByteMask(IF_RATE+2, (BYTE)((dwVIFPara >> 16) & 0x000000FF), 0x3F);
1426 }
1427 else
1428 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_IF_RATE_FM");
1429 break;
1430
1431 case VIF_PARA_SET_CR_RATE_FM:
1432 if ( sizeof(DWORD) == u32DataLen)
1433 {
1434 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1435
1436 VIF_WriteByte(CR_RATE, (BYTE)(dwVIFPara & 0x000000FF));
1437 VIF_WriteByte(CR_RATE+1 , (BYTE)((dwVIFPara >> 8) & 0x000000FF));
1438 VIF_WriteByteMask(CR_RATE+2, (BYTE)((dwVIFPara >> 16) & 0x000000FF), 0x1F);
1439 VIF_WriteBit(CR_RATE_INV, 0, _BIT0);
1440 }
1441 else
1442 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_CR_RATE_FM");
1443 break;
1444
1445 case VIF_PARA_SET_DESCRAMBLERBOX_DELAY:
1446 if( sizeof(DWORD) == u32DataLen)
1447 {
1448 DWORD VifDelayNumTemp;
1449
1450 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1451
1452 U8 u8IsADC48MHz = VIF_ReadByte(0x122F6)&0x10;
1453
1454 // VifShiftClk : 0x1121_D3
1455 BYTE u8VifShiftClk = VIF_ReadByte(VIF_RF_RESERVED_1+1);
1456
1457 if((strcmp(CHIP_TYPE, EULER) == 0) ||(strcmp(CHIP_TYPE, NIKE) == 0) ||(strcmp(CHIP_TYPE, EIFFEL) == 0))
1458 {
1459 if(VIFInitialIn_inst.ChinaDescramblerBox == 7)
1460 {
1461 if(u8VifShiftClk/*g_VifShiftClk*/ == 1)
1462 {
1463 VifDelayNumTemp = dwVIFPara;
1464 VifDelayNumTemp = (VifDelayNumTemp * 1992) >> 11;
1465 VIF_WriteByte(0x123F4, (BYTE)(VifDelayNumTemp & 0x000000FF)); // DAGC1_DLY_NUM
1466 VIF_WriteByteMask(0x123F5, (BYTE)((VifDelayNumTemp >> 8) & 0x000000FF), 0x1F);
1467 }
1468 else if(u8VifShiftClk/*g_VifShiftClk*/ == 2)
1469 {
1470 VifDelayNumTemp = dwVIFPara;
1471 VifDelayNumTemp = (VifDelayNumTemp * 2105) >> 11;
1472 VIF_WriteByte(0x123F4, (BYTE)(VifDelayNumTemp & 0x000000FF)); // DAGC1_DLY_NUM
1473 VIF_WriteByteMask(0x123F5, (BYTE)((VifDelayNumTemp >> 8) & 0x000000FF), 0x1F);
1474 }
1475 else
1476 {
1477 VIF_WriteByte(0x123F4, (BYTE)(dwVIFPara & 0x000000FF)); // DAGC1_DLY_NUM
1478 VIF_WriteByteMask(0x123F5, (BYTE)((dwVIFPara >> 8) & 0x000000FF), 0x1F);
1479 }
1480
1481 VIF_WriteBit(0x123F5, 1, _BIT7); // DAGC1_DLY_EN
1482 VIF_WriteByteMask(VIFDAC_OUT_SEL, 0x04, 0x07); // 0: cvbs output; 4: debug bus
1483 VIF_WriteBit(DEBUG2_EN, 1, _BIT7); // select debug2 data
1484 VIF_WriteByteMask(DEBUG_MODULE, 0x00, 0x0F); // select filter debug bus
1485 VIF_WriteByte(DEBUG_PORT, 0x8D); // selsect CVBS output after DAGC1 filter
1486
1487 if(strcmp(CHIP_TYPE, NIKE) == 0)
1488 VIF_WriteBit(DAGC2_DL_BYPASS, 1, _BIT3);
1489 }
1490 }
1491 else if(strcmp(CHIP_TYPE, EINSTEIN) >= 0)
1492 {
1493 if(VIFInitialIn_inst.ChinaDescramblerBox == 0)
1494 {
1495 if((u8VifShiftClk/*g_VifShiftClk*/ == 1)&&(u8IsADC48MHz == 0))
1496 {
1497 VifDelayNumTemp = dwVIFPara;
1498 VifDelayNumTemp = (VifDelayNumTemp * 1992) >> 11;
1499
1500 if(strcmp(CHIP_TYPE, MUJI) == 0)
1501 VifDelayNumTemp = VifDelayNumTemp + 0x00000409; // offset = 24.6us
1502 else
1503 VifDelayNumTemp = VifDelayNumTemp + 0x00000751; // offset = 44.6us
1504
1505 VIF_WriteByte(0x12124, (BYTE)(VifDelayNumTemp & 0x000000FF)); // DAC_DLY_NUM
1506 VIF_WriteByteMask(0x12125, (BYTE)((VifDelayNumTemp >> 8) & 0x000000FF), 0x0F);
1507 }
1508 else if((u8VifShiftClk/*g_VifShiftClk*/ == 2)&&(u8IsADC48MHz == 0))
1509 {
1510 VifDelayNumTemp = dwVIFPara;
1511 VifDelayNumTemp = (VifDelayNumTemp * 2105) >> 11;
1512
1513 if(strcmp(CHIP_TYPE, MUJI) == 0)
1514 VifDelayNumTemp = VifDelayNumTemp + 0x0000068A; // offset = 37.7us
1515 else
1516 VifDelayNumTemp = VifDelayNumTemp + 0x00000330; // offset = 18.4us
1517
1518 VIF_WriteByte(0x12124, (BYTE)(VifDelayNumTemp & 0x000000FF)); // DAC_DLY_NUM
1519 VIF_WriteByteMask(0x12125, (BYTE)((VifDelayNumTemp >> 8) & 0x000000FF), 0x0F);
1520 }
1521 else
1522 {
1523 VIF_WriteByte(0x12124, (BYTE)(dwVIFPara & 0x000000FF)); // DAC_DLY_NUM
1524 VIF_WriteByteMask(0x12125, (BYTE)((dwVIFPara >> 8) & 0x000000FF), 0x0F);
1525 }
1526
1527 VIF_WriteBit(0x12125, 0, _BIT7); //DAC_DLY not bypass
1528 VIF_WriteByteMask(VIFDAC_OUT_SEL, 0x00, 0x07); // 0: cvbs output; 4: debug bus
1529 VIF_WriteBit(DEBUG2_EN, 0, _BIT7); // not select debug2 data
1530 }
1531 }
1532 }
1533 else
1534 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_DESCRAMBLERBOX_DELAY");
1535 break;
1536
1537 case VIF_PARA_SET_SSC_ENABLE:
1538 if( sizeof(DWORD) == u32DataLen)
1539 {
1540 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1541
1542 if((dwVIFPara&0x00000001) != 0)
1543 VIF_WriteBit(0x120A1, 1, _BIT0);
1544 else
1545 VIF_WriteBit(0x120A1, 0, _BIT0);
1546 }
1547 else
1548 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_SSC_ENABLE");
1549 break;
1550
1551 case VIF_PARA_SET_DISABLE_ADAGC:
1552 if ( sizeof(DWORD) == u32DataLen)
1553 {
1554 BOOL bDisableAdagc;
1555 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1556 bDisableAdagc = ((U8) dwVIFPara==0) ? FALSE:TRUE;
1557 VIF_WriteBit(ADAGC_BYPASS, bDisableAdagc, _BIT1);
1558 VIF_WriteBit(ADAGC_ENABLE, !bDisableAdagc, _BIT0);
1559 }
1560 else
1561 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_DISABLE_ADAGC");
1562 break;
1563
1564 case VIF_PARA_SET_ENABLE_SOS33:
1565 if ( sizeof(DWORD) == u32DataLen)
1566 {
1567 BOOL bEnableSOS33;
1568 memcpy(&dwVIFPara, (DWORD *) pVIF_Para, u32DataLen);
1569 bEnableSOS33 = ((U8) dwVIFPara==0) ? FALSE:TRUE;
1570 VIF_WriteBit(0x1220A, !bEnableSOS33, _BIT6);
1571 }
1572 else
1573 printf("\r\nERROR!! vif parameter copy failed with wrong size: VIF_PARA_SET_ENABLE_SOS33");
1574 break;
1575
1576 default:
1577 break;
1578 }
1579 return TRUE;
1580 }
1581
VIF_ShiftClk(BYTE VifShiftClk)1582 void VIF_ShiftClk(BYTE VifShiftClk)
1583 {
1584 DRVVIFDBG(printf("DRV_VIF_ShiftClk() VifShiftClk=%d\n",VifShiftClk));
1585 #ifdef _2_DIGIT_CHIP_TYPE_
1586 msVifShiftClk(VifShiftClk);
1587 #endif
1588 }
1589
VIF_GetSTRParameter(void)1590 void VIF_GetSTRParameter(void)
1591 {
1592 //printf("\r\n ======== VIF_GetSTRParameter ========= \n");
1593
1594 sVIFSTRInfo.Vif_Clamp_L = VIF_ReadByte(CLAMPGAIN_CLAMP_OVERWRITE);
1595 sVIFSTRInfo.Vif_Clamp_H = VIF_ReadByte(CLAMPGAIN_CLAMP_OVERWRITE+1);
1596 sVIFSTRInfo.Vif_Clamp_Gain_L = VIF_ReadByte(CLAMPGAIN_GAIN_OVERWRITE);
1597 sVIFSTRInfo.Vif_Clamp_Gain_H = VIF_ReadByte(CLAMPGAIN_GAIN_OVERWRITE+1);
1598
1599 sVIFSTRInfo.Vif_Cr_Rate_1 = VIF_ReadByte(CR_RATE);
1600 sVIFSTRInfo.Vif_Cr_Rate_2 = VIF_ReadByte(CR_RATE+1);
1601 sVIFSTRInfo.Vif_Cr_Rate_3 = VIF_ReadByte(CR_RATE+2);
1602 sVIFSTRInfo.Vif_Cr_Rate_Inv = VIF_ReadByte(CR_RATE_INV);
1603
1604 sVIFSTRInfo.Vif_N_A1_C0_L = VIF_ReadByte(N_A1_C0_L);
1605 sVIFSTRInfo.Vif_N_A1_C0_H = VIF_ReadByte(N_A1_C0_H);
1606 sVIFSTRInfo.Vif_N_A1_C1_L = VIF_ReadByte(N_A1_C1_L);
1607 sVIFSTRInfo.Vif_N_A1_C1_H = VIF_ReadByte(N_A1_C1_H);
1608 sVIFSTRInfo.Vif_N_A1_C2_L = VIF_ReadByte(N_A1_C2_L);
1609 sVIFSTRInfo.Vif_N_A1_C2_H = VIF_ReadByte(N_A1_C2_H);
1610
1611 sVIFSTRInfo.Vif_N_A2_C0_L = VIF_ReadByte(N_A2_C0_L);
1612 sVIFSTRInfo.Vif_N_A2_C0_H = VIF_ReadByte(N_A2_C0_H);
1613 sVIFSTRInfo.Vif_N_A2_C1_L = VIF_ReadByte(N_A2_C1_L);
1614 sVIFSTRInfo.Vif_N_A2_C1_H = VIF_ReadByte(N_A2_C1_H);
1615 sVIFSTRInfo.Vif_N_A2_C2_L = VIF_ReadByte(N_A2_C2_L);
1616 sVIFSTRInfo.Vif_N_A2_C2_H = VIF_ReadByte(N_A2_C2_H);
1617
1618 sVIFSTRInfo.Vif_SOS_11_C0_L = VIF_ReadByte(SOS11_C0_L);
1619 sVIFSTRInfo.Vif_SOS_11_C0_H = VIF_ReadByte(SOS11_C0_H);
1620 sVIFSTRInfo.Vif_SOS_11_C1_L = VIF_ReadByte(SOS11_C1_L);
1621 sVIFSTRInfo.Vif_SOS_11_C1_H = VIF_ReadByte(SOS11_C1_H);
1622 sVIFSTRInfo.Vif_SOS_11_C2_L = VIF_ReadByte(SOS11_C2_L);
1623 sVIFSTRInfo.Vif_SOS_11_C2_H = VIF_ReadByte(SOS11_C2_H);
1624 sVIFSTRInfo.Vif_SOS_11_C3_L = VIF_ReadByte(SOS11_C3_L);
1625 sVIFSTRInfo.Vif_SOS_11_C3_H = VIF_ReadByte(SOS11_C3_H);
1626 sVIFSTRInfo.Vif_SOS_11_C4_L = VIF_ReadByte(SOS11_C4_L);
1627 sVIFSTRInfo.Vif_SOS_11_C4_H = VIF_ReadByte(SOS11_C4_H);
1628
1629 sVIFSTRInfo.Vif_SOS_12_C0_L = VIF_ReadByte(SOS12_C0_L);
1630 sVIFSTRInfo.Vif_SOS_12_C0_H = VIF_ReadByte(SOS12_C0_H);
1631 sVIFSTRInfo.Vif_SOS_12_C1_L = VIF_ReadByte(SOS12_C1_L);
1632 sVIFSTRInfo.Vif_SOS_12_C1_H = VIF_ReadByte(SOS12_C1_H);
1633 sVIFSTRInfo.Vif_SOS_12_C2_L = VIF_ReadByte(SOS12_C2_L);
1634 sVIFSTRInfo.Vif_SOS_12_C2_H = VIF_ReadByte(SOS12_C2_H);
1635 sVIFSTRInfo.Vif_SOS_12_C3_L = VIF_ReadByte(SOS12_C3_L);
1636 sVIFSTRInfo.Vif_SOS_12_C3_H = VIF_ReadByte(SOS12_C3_H);
1637 sVIFSTRInfo.Vif_SOS_12_C4_L = VIF_ReadByte(SOS12_C4_L);
1638 sVIFSTRInfo.Vif_SOS_12_C4_H = VIF_ReadByte(SOS12_C4_H);
1639
1640 sVIFSTRInfo.VifSos21FilterC0_L = VIF_ReadByte(SOS21_C0_L);
1641 sVIFSTRInfo.VifSos21FilterC0_H = VIF_ReadByte(SOS21_C0_H);
1642 sVIFSTRInfo.VifSos21FilterC1_L = VIF_ReadByte(SOS21_C1_L);
1643 sVIFSTRInfo.VifSos21FilterC1_H = VIF_ReadByte(SOS21_C1_H);
1644 sVIFSTRInfo.VifSos21FilterC2_L = VIF_ReadByte(SOS21_C2_L);
1645 sVIFSTRInfo.VifSos21FilterC2_H = VIF_ReadByte(SOS21_C2_H);
1646 sVIFSTRInfo.VifSos21FilterC3_L = VIF_ReadByte(SOS21_C3_L);
1647 sVIFSTRInfo.VifSos21FilterC3_H = VIF_ReadByte(SOS21_C3_H);
1648 sVIFSTRInfo.VifSos21FilterC4_L = VIF_ReadByte(SOS21_C4_L);
1649 sVIFSTRInfo.VifSos21FilterC4_H = VIF_ReadByte(SOS21_C4_H);
1650
1651 sVIFSTRInfo.VifSos22FilterC0_L = VIF_ReadByte(SOS22_C0_L);
1652 sVIFSTRInfo.VifSos22FilterC0_H = VIF_ReadByte(SOS22_C0_H);
1653 sVIFSTRInfo.VifSos22FilterC1_L= VIF_ReadByte(SOS22_C1_L);
1654 sVIFSTRInfo.VifSos22FilterC1_H = VIF_ReadByte(SOS22_C1_H);
1655 sVIFSTRInfo.VifSos22FilterC2_L = VIF_ReadByte(SOS22_C2_L);
1656 sVIFSTRInfo.VifSos22FilterC2_H = VIF_ReadByte(SOS22_C2_H);
1657 sVIFSTRInfo.VifSos22FilterC3_L = VIF_ReadByte(SOS22_C3_L);
1658 sVIFSTRInfo.VifSos22FilterC3_H = VIF_ReadByte(SOS22_C3_H);
1659 sVIFSTRInfo.VifSos22FilterC4_L = VIF_ReadByte(SOS22_C4_L);
1660 sVIFSTRInfo.VifSos22FilterC4_H = VIF_ReadByte(SOS22_C4_H);
1661
1662 sVIFSTRInfo.VifSos31FilterC0_L = VIF_ReadByte(SOS31_C0_L);
1663 sVIFSTRInfo.VifSos31FilterC0_H = VIF_ReadByte(SOS31_C0_H);
1664 sVIFSTRInfo.VifSos31FilterC1_L = VIF_ReadByte(SOS31_C1_L);
1665 sVIFSTRInfo.VifSos31FilterC1_H = VIF_ReadByte(SOS31_C1_H);
1666 sVIFSTRInfo.VifSos31FilterC2_L = VIF_ReadByte(SOS31_C2_L);
1667 sVIFSTRInfo.VifSos31FilterC2_H = VIF_ReadByte(SOS31_C2_H);
1668 sVIFSTRInfo.VifSos31FilterC3_L = VIF_ReadByte(SOS31_C3_L);
1669 sVIFSTRInfo.VifSos31FilterC3_H = VIF_ReadByte(SOS31_C3_H);
1670 sVIFSTRInfo.VifSos31FilterC4_L = VIF_ReadByte(SOS31_C4_L);
1671 sVIFSTRInfo.VifSos31FilterC4_H = VIF_ReadByte(SOS31_C4_H);
1672
1673 sVIFSTRInfo.VifSos32FilterC0_L = VIF_ReadByte(SOS32_C0_L);
1674 sVIFSTRInfo.VifSos32FilterC0_H = VIF_ReadByte(SOS32_C0_H);
1675 sVIFSTRInfo.VifSos32FilterC1_L = VIF_ReadByte(SOS32_C1_L);
1676 sVIFSTRInfo.VifSos32FilterC1_H = VIF_ReadByte(SOS32_C1_H);
1677 sVIFSTRInfo.VifSos32FilterC2_L = VIF_ReadByte(SOS32_C2_L);
1678 sVIFSTRInfo.VifSos32FilterC2_H = VIF_ReadByte(SOS32_C2_H);
1679 sVIFSTRInfo.VifSos32FilterC3_L = VIF_ReadByte(SOS32_C3_L);
1680 sVIFSTRInfo.VifSos32FilterC3_H = VIF_ReadByte(SOS32_C3_H);
1681 sVIFSTRInfo.VifSos32FilterC4_L = VIF_ReadByte(SOS32_C4_L);
1682 sVIFSTRInfo.VifSos32FilterC4_H = VIF_ReadByte(SOS32_C4_H);
1683
1684 sVIFSTRInfo.Vif_Agc_Ref = VIF_ReadByte(AGC_REF);
1685 sVIFSTRInfo.Vif_CR_K_Sel = VIF_ReadByte(CR_K_SEL);
1686 sVIFSTRInfo.Vif_CR_KpKi = VIF_ReadByte(CR_KP_SW);
1687 }
1688
VIF_SetPowerState(EN_POWER_MODE u16PowerState)1689 MS_U32 VIF_SetPowerState(EN_POWER_MODE u16PowerState)
1690 {
1691 MS_U32 u32Return = 1;
1692
1693 if(bIsATV == TRUE)
1694 {
1695 if(u16PowerState == E_POWER_RESUME) // RESUME
1696 {
1697 VIF_Init(&VIFInitialIn_inst, sizeof(VIFInitialIn_inst));
1698
1699 if((gVIFSoundSystem == VIF_SOUND_L)||(gVIFSoundSystem == VIF_SOUND_LL))
1700 {
1701 VIF_SetSoundSystem(gVIFSoundSystem);
1702 VIF_Reset();
1703 }
1704
1705 VIF_SetSoundSystem(gVIFSoundSystem);
1706
1707 VIF_WriteByte(CLAMPGAIN_CLAMP_OVERWRITE, sVIFSTRInfo.Vif_Clamp_L);
1708 VIF_WriteByte(CLAMPGAIN_CLAMP_OVERWRITE+1, sVIFSTRInfo.Vif_Clamp_H);
1709 VIF_WriteByte(CLAMPGAIN_GAIN_OVERWRITE, sVIFSTRInfo.Vif_Clamp_Gain_L);
1710 VIF_WriteByte(CLAMPGAIN_GAIN_OVERWRITE+1, sVIFSTRInfo.Vif_Clamp_Gain_H);
1711
1712 VIF_WriteByte(CR_RATE, sVIFSTRInfo.Vif_Cr_Rate_1);
1713 VIF_WriteByte(CR_RATE+1, sVIFSTRInfo.Vif_Cr_Rate_2);
1714 VIF_WriteByte(CR_RATE+2, sVIFSTRInfo.Vif_Cr_Rate_3);
1715 VIF_WriteByte(CR_RATE_INV, sVIFSTRInfo.Vif_Cr_Rate_Inv);
1716
1717 VIF_WriteByte(N_A1_C0_L, sVIFSTRInfo.Vif_N_A1_C0_L);
1718 VIF_WriteByte(N_A1_C0_H, sVIFSTRInfo.Vif_N_A1_C0_H);
1719 VIF_WriteByte(N_A1_C1_L, sVIFSTRInfo.Vif_N_A1_C1_L);
1720 VIF_WriteByte(N_A1_C1_H, sVIFSTRInfo.Vif_N_A1_C1_H);
1721 VIF_WriteByte(N_A1_C2_L, sVIFSTRInfo.Vif_N_A1_C2_L);
1722 VIF_WriteByte(N_A1_C2_H, sVIFSTRInfo.Vif_N_A1_C2_H);
1723
1724 VIF_WriteByte(N_A2_C0_L, sVIFSTRInfo.Vif_N_A2_C0_L);
1725 VIF_WriteByte(N_A2_C0_H, sVIFSTRInfo.Vif_N_A2_C0_H);
1726 VIF_WriteByte(N_A2_C1_L, sVIFSTRInfo.Vif_N_A2_C1_L);
1727 VIF_WriteByte(N_A2_C1_H, sVIFSTRInfo.Vif_N_A2_C1_H);
1728 VIF_WriteByte(N_A2_C2_L, sVIFSTRInfo.Vif_N_A2_C2_L);
1729 VIF_WriteByte(N_A2_C2_H, sVIFSTRInfo.Vif_N_A2_C2_H);
1730
1731 VIF_WriteByte(SOS11_C0_L, sVIFSTRInfo.Vif_SOS_11_C0_L);
1732 VIF_WriteByte(SOS11_C0_H, sVIFSTRInfo.Vif_SOS_11_C0_H);
1733 VIF_WriteByte(SOS11_C1_L, sVIFSTRInfo.Vif_SOS_11_C1_L);
1734 VIF_WriteByte(SOS11_C1_H, sVIFSTRInfo.Vif_SOS_11_C1_H);
1735 VIF_WriteByte(SOS11_C2_L, sVIFSTRInfo.Vif_SOS_11_C2_L);
1736 VIF_WriteByte(SOS11_C2_H, sVIFSTRInfo.Vif_SOS_11_C2_H);
1737 VIF_WriteByte(SOS11_C3_L, sVIFSTRInfo.Vif_SOS_11_C3_L);
1738 VIF_WriteByte(SOS11_C3_H, sVIFSTRInfo.Vif_SOS_11_C3_H);
1739 VIF_WriteByte(SOS11_C4_L, sVIFSTRInfo.Vif_SOS_11_C4_L);
1740 VIF_WriteByte(SOS11_C4_H, sVIFSTRInfo.Vif_SOS_11_C4_H);
1741
1742 VIF_WriteByte(SOS12_C0_L, sVIFSTRInfo.Vif_SOS_12_C0_L);
1743 VIF_WriteByte(SOS12_C0_H, sVIFSTRInfo.Vif_SOS_12_C0_H);
1744 VIF_WriteByte(SOS12_C1_L, sVIFSTRInfo.Vif_SOS_12_C1_L);
1745 VIF_WriteByte(SOS12_C1_H, sVIFSTRInfo.Vif_SOS_12_C1_H);
1746 VIF_WriteByte(SOS12_C2_L, sVIFSTRInfo.Vif_SOS_12_C2_L);
1747 VIF_WriteByte(SOS12_C2_H, sVIFSTRInfo.Vif_SOS_12_C2_H);
1748 VIF_WriteByte(SOS12_C3_L, sVIFSTRInfo.Vif_SOS_12_C3_L);
1749 VIF_WriteByte(SOS12_C3_H, sVIFSTRInfo.Vif_SOS_12_C3_H);
1750 VIF_WriteByte(SOS12_C4_L, sVIFSTRInfo.Vif_SOS_12_C4_L);
1751 VIF_WriteByte(SOS12_C4_H, sVIFSTRInfo.Vif_SOS_12_C4_H);
1752
1753 VIF_WriteByte(SOS21_C0_L, sVIFSTRInfo.VifSos21FilterC0_L);
1754 VIF_WriteByte(SOS21_C0_H, sVIFSTRInfo.VifSos21FilterC0_H);
1755 VIF_WriteByte(SOS21_C1_L, sVIFSTRInfo.VifSos21FilterC1_L);
1756 VIF_WriteByte(SOS21_C1_H, sVIFSTRInfo.VifSos21FilterC1_H);
1757 VIF_WriteByte(SOS21_C2_L, sVIFSTRInfo.VifSos21FilterC2_L);
1758 VIF_WriteByte(SOS21_C2_H, sVIFSTRInfo.VifSos21FilterC2_H);
1759 VIF_WriteByte(SOS21_C3_L, sVIFSTRInfo.VifSos21FilterC3_L);
1760 VIF_WriteByte(SOS21_C3_H, sVIFSTRInfo.VifSos21FilterC3_H);
1761 VIF_WriteByte(SOS21_C4_L, sVIFSTRInfo.VifSos21FilterC4_L);
1762 VIF_WriteByte(SOS21_C4_H, sVIFSTRInfo.VifSos21FilterC4_H);
1763
1764 VIF_WriteByte(SOS22_C0_L, sVIFSTRInfo.VifSos22FilterC0_L);
1765 VIF_WriteByte(SOS22_C0_H, sVIFSTRInfo.VifSos22FilterC0_H);
1766 VIF_WriteByte(SOS22_C1_L, sVIFSTRInfo.VifSos22FilterC1_L);
1767 VIF_WriteByte(SOS22_C1_H, sVIFSTRInfo.VifSos22FilterC1_H);
1768 VIF_WriteByte(SOS22_C2_L, sVIFSTRInfo.VifSos22FilterC2_L);
1769 VIF_WriteByte(SOS22_C2_H, sVIFSTRInfo.VifSos22FilterC2_H);
1770 VIF_WriteByte(SOS22_C3_L, sVIFSTRInfo.VifSos22FilterC3_L);
1771 VIF_WriteByte(SOS22_C3_H, sVIFSTRInfo.VifSos22FilterC3_H);
1772 VIF_WriteByte(SOS22_C4_L, sVIFSTRInfo.VifSos22FilterC4_L);
1773 VIF_WriteByte(SOS22_C4_H, sVIFSTRInfo.VifSos22FilterC4_H);
1774
1775 VIF_WriteByte(SOS31_C0_L, sVIFSTRInfo.VifSos31FilterC0_L);
1776 VIF_WriteByte(SOS31_C0_H, sVIFSTRInfo.VifSos31FilterC0_H);
1777 VIF_WriteByte(SOS31_C1_L, sVIFSTRInfo.VifSos31FilterC1_L);
1778 VIF_WriteByte(SOS31_C1_H, sVIFSTRInfo.VifSos31FilterC1_H);
1779 VIF_WriteByte(SOS31_C2_L, sVIFSTRInfo.VifSos31FilterC2_L);
1780 VIF_WriteByte(SOS31_C2_H, sVIFSTRInfo.VifSos31FilterC2_H);
1781 VIF_WriteByte(SOS31_C3_L, sVIFSTRInfo.VifSos31FilterC3_L);
1782 VIF_WriteByte(SOS31_C3_H, sVIFSTRInfo.VifSos31FilterC3_H);
1783 VIF_WriteByte(SOS31_C4_L, sVIFSTRInfo.VifSos31FilterC4_L);
1784 VIF_WriteByte(SOS31_C4_H, sVIFSTRInfo.VifSos31FilterC4_H);
1785
1786 VIF_WriteByte(SOS32_C0_L, sVIFSTRInfo.VifSos32FilterC0_L);
1787 VIF_WriteByte(SOS32_C0_H, sVIFSTRInfo.VifSos32FilterC0_H);
1788 VIF_WriteByte(SOS32_C1_L, sVIFSTRInfo.VifSos32FilterC1_L);
1789 VIF_WriteByte(SOS32_C1_H, sVIFSTRInfo.VifSos32FilterC1_H);
1790 VIF_WriteByte(SOS32_C2_L, sVIFSTRInfo.VifSos32FilterC2_L);
1791 VIF_WriteByte(SOS32_C2_H, sVIFSTRInfo.VifSos32FilterC2_H);
1792 VIF_WriteByte(SOS32_C3_L, sVIFSTRInfo.VifSos32FilterC3_L);
1793 VIF_WriteByte(SOS32_C3_H, sVIFSTRInfo.VifSos32FilterC3_H);
1794 VIF_WriteByte(SOS32_C4_L, sVIFSTRInfo.VifSos32FilterC4_L);
1795 VIF_WriteByte(SOS32_C4_H, sVIFSTRInfo.VifSos32FilterC4_H);
1796
1797 VIF_WriteByte(AGC_REF, sVIFSTRInfo.Vif_Agc_Ref);
1798 VIF_WriteByte(CR_K_SEL, sVIFSTRInfo.Vif_CR_K_Sel);
1799 VIF_WriteByte(CR_KP_SW, sVIFSTRInfo.Vif_CR_KpKi);
1800
1801 //printf("\r\n ======== VIF_SetPowerState_Resume ========= \n");
1802
1803 u32Return = 0; //RESUME_OK;
1804 }
1805 else if(u16PowerState == E_POWER_SUSPEND)
1806 {
1807 VIF_GetSTRParameter();
1808
1809 //printf("\r\n ======== VIF_SetPowerState_Suspend ========= \n");
1810
1811 u32Return = 0; //SUSPEND_OK;
1812 }
1813 else
1814 {
1815 printf("\r\n ====== [VIF_SetPowerState] Uknown Power State ====== \n");
1816 u32Return = 1;
1817 }
1818 }
1819 else
1820 {
1821 printf("\r\n ====== VIF don't need to Suspend/Resume at Non-ATV mode ====== \r\n");
1822 u32Return = 0;
1823 }
1824
1825 return u32Return;
1826 }
1827
1828 #endif //_VIF_C_
1829
1830