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
95 #define _MDRV_PQ_C_
96
97 #ifdef MSOS_TYPE_LINUX
98 #include <pthread.h>
99 #endif
100
101 #if !defined(MSOS_TYPE_LINUX_KERNEL)
102 #include "string.h"
103 #include "stdio.h"
104 #include <sys/stat.h>
105 #define do_div(x,y) ((x)/=(y))
106 #else
107 #include <linux/string.h>
108 #include <asm/div64.h>
109 #include <linux/fs.h>
110 #include <linux/vmalloc.h>
111 #include <linux/err.h>
112 #include <asm/uaccess.h>
113 #endif
114
115 #include "MsCommon.h"
116 //#include "MsVersion.h"
117 #include "MsOS.h"
118 #include "MsTypes.h"
119 #include "utopia.h"
120 #include "utopia_dapi.h"
121
122 #include "hwreg_utility2.h"
123 #include "color_reg.h"
124
125 #include "drvXC_IOPort.h"
126 #include "apiXC.h"
127 #include "apiXC_v2.h"
128 #include "apiXC_Ace.h"
129 #include "drvMVOP.h"
130 #include "drvSYS.h"
131
132 #include "drvPQ_Define.h"
133 #include "drvPQ_Declare.h"
134 #include "drvPQ.h"
135 #include "drvPQ_cus.h"
136 #include "drvPQ_Datatypes.h"
137 #include "mhal_pq.h"
138 #include "mhal_pq_cus.h"
139 #include "drvPQ_Bin.h"
140 #include "apiPNL.h"
141
142 #include "QualityMode.h"
143 #include "PQ_private.h"
144 #include "apiPQ_v2.h"
145 #include "mhal_pq_adaptive.h"
146 #include "drvSYS.h"
147
148 #ifndef UNUSED //to avoid compile warnings...
149 #define UNUSED(var) (void)((var) = (var))
150 #endif
151
152 #ifndef PQ_HAL_EWINDOW_PARAM
153 #define PQ_HAL_EWINDOW_PARAM 0
154 #endif
155
156 #ifndef PQ_DISABLE_UC_FOR_PREVSD
157 #define PQ_DISABLE_UC_FOR_PREVSD 0
158 #endif
159
160 #ifndef PQ_DISABLE_UC_FOR_PIP
161 #define PQ_DISABLE_UC_FOR_PIP 0
162 #endif
163
164 #ifndef PQ_GRULE_SLZ_ENABLE
165 #define PQ_GRULE_SLZ_ENABLE 0
166 #endif
167
168 #ifndef PQ_DDR_SELECT_VER
169 #define PQ_DDR_SELECT_VER 1
170 #endif
171
172 #ifndef PQ_BW_4K2KPIP_SUPPORT
173 #define PQ_BW_4K2KPIP_SUPPORT 1
174 #endif
175
176 #ifndef PQ_SUPPORT_SUB_POSTCCS
177 #define PQ_SUPPORT_SUB_POSTCCS 1
178 #endif
179
180 #ifndef PQ_SUPPORT_SUB_DHD
181 #define PQ_SUPPORT_SUB_DHD 1
182 #endif
183
184 #ifndef PQ_GRULE_3D_ENABLE
185 #define PQ_GRULE_3D_ENABLE 0
186 #endif
187
188 /********************************************************************************
189 // PQ_IOCTL_SET_UC_FEATURE is flag for set UCNR During SetWin(if enable this switch please sync CL641359)
190 // and please check PQ excel skipRule(UC_CTL/UCDi/MADi_EODiW/MADi_SSTMADi_Motion need skip)item to prevent to set UCNR twice
191 **********************************************************************************/
192 #ifndef PQ_IOCTL_SET_UC_FEATURE
193 #define PQ_IOCTL_SET_UC_FEATURE 0
194 #endif
195
196 #ifndef Y2Y_709_601_VERSION
197 #define Y2Y_709_601_VERSION 0
198 #endif
199
200 #ifndef REG_CHIP_EXECUTOR_DUMMY
201 #define REG_CHIP_EXECUTOR_DUMMY 0
202 #endif
203 #ifndef REG_CHIP_EXECUTOR_KEY_DUMMY
204 #define REG_CHIP_EXECUTOR_KEY_DUMMY 0
205 #endif
206
207 #ifndef REG_CHIP_EXECUTOR_KEY
208 #define REG_CHIP_EXECUTOR_KEY 0
209 #endif
210
211 #ifndef PQ_SUPPORT_ADAPTIVE_VERSION
212 #define PQ_SUPPORT_ADAPTIVE_VERSION FALSE
213 #endif
214
215 #ifndef PQ_DEMO_MODE_ENABLE
216 #define PQ_DEMO_MODE_ENABLE 0
217 #endif
218
219 #ifndef PQ_SCALER_GAMMA_ENABLE
220 #define PQ_SCALER_GAMMA_ENABLE 0
221 #endif
222
223 #ifndef PQ_P_MODE8_3FRAME_MODE_ENABLE
224 #define PQ_P_MODE8_3FRAME_MODE_ENABLE 0
225 #endif
226
227 #define PQ_ADAPTIVE_INVALID_VERSION (0xFFFFFFFF)
228
229 static MSIF_Version _drv_pq_version = {
230 .DDI = { PQ_DRV_VERSION },
231 };
232
233 MS_U16 _u16PQSrcType[PQ_MAX_WINDOW];
234 MS_U16 _u16PQSrcType_UFSC[PQ_MAX_WINDOW];
235 #if (ENABLE_PQ_BIN_CF)
236 MS_U16 _u16PQSrcType_CF[PQ_MAX_WINDOW];
237 #endif
238 MS_U16 _u16LastPQSrcType[PQ_MAX_WINDOW] = {0xffff,0xffff};
239 MS_BOOL _bSkipDuplicateSetting = FALSE;
240 MS_U16 _u16PQSrcType_DBK_Detect[PQ_MAX_WINDOW]; //For Auto_DBK SW driver used
241
242 static PQ_INPUT_SOURCE_TYPE _enInputSourceType[PQ_MAX_WINDOW];
243 static MS_BOOL _bColorRange0_255[PQ_MAX_WINDOW];
244 static MS_BOOL _bGameModeOn[PQ_MAX_WINDOW];
245 static MS_U8 _u8RWmappingNum[PQ_MAX_WINDOW];
246 static PQ_YUV_STD _enYUVStandard[PQ_MAX_WINDOW];
247 MS_BOOL _bRWNumIsReset[PQ_MAX_WINDOW];
248 static MS_U16 _u16SRAM1 = PQ_BIN_IP_NULL;
249 static MS_U16 _u16SRAM2 = PQ_BIN_IP_NULL;
250 static MS_BOOL _bNeedRestoreWRBankMappingNum = FALSE;
251
252 MS_BOOL _bCustomerMainPQEn = FALSE ;
253 MS_BOOL _bCustomerSubPQEn = FALSE ;
254 MS_BOOL _bUFSCPQEn = FALSE;
255 #if (ENABLE_PQ_BIN_CF)
256 MS_BOOL _bCFMainPQEn = FALSE;
257 MS_BOOL _bCFSubPQEn = FALSE;
258 #endif
259
260 //whether current status is Point-to-point mode
261 static MS_BOOL _bPointToPointMode = FALSE;
262 static MS_BOOL _bPqBypassMode = FALSE;
263 //whether current status is Dualview display mode
264 MS_BOOL _bDualViewEnable = FALSE;
265
266 //whether current status is in force video mode
267 static MS_BOOL _bForceVideoInputMode[PQ_MAX_WINDOW] = {FALSE, FALSE};
268
269 // Enable/Disable P2P force to do CSC
270 MS_BOOL _bP2pForceToDoCsc = FALSE;
271
272 /// Soc output color format
273 PQ_COLOR_FORMAT _enOutputColorFmt = E_PQ_COLOR_YUV444;
274
275 MS_U16 _u16PQDbgSwitch = FALSE;
276 //MS_U16 _u16PQDbgSwitch = PQ_DBG_PQTAB | PQ_DBG_SRULE | PQ_DBG_CSCRULE | PQ_DBG_GRULE | PQ_DBG_BW | PQ_DBG_MADI | PQ_DBG_INFO | PQ_DBG_IOCTL | PQ_DBG_P2P;
277 MS_BOOL _bDS_En = FALSE;
278 static MS_BOOL _bDMSV12L_PQConfigEn = FALSE; //this flag is coming from PQ file
279 #if PQ_EN_DMS_SW_CTRL
280 static MS_BOOL _bDMSV12L_PIPEn = TRUE; //TRUE: it's not PIP/POP; FALSE: PIP/POP case want to disable DMS12L
281 #endif
282 MS_U16 _u16RW_Method = 0;
283
284 static MS_U16 _u16PQDelyaTime = 0;
285 static MS_U16 _u16PQSuggestedFrameNum[PQ_MAX_WINDOW];
286 static MS_BOOL _bSensioMode = FALSE;
287 static MS_U8 u8PQDelayCount = 0;
288 static MS_BOOL _bFrameBuffLess = FALSE;
289
290 static MS_PQ_INFO _info = {.u16Input_Src_Num = 128, .u8IP_Num = 217,};
291 static MS_PQ_Status _status = {.bIsInitialized = FALSE, .bIsRunning = FALSE, };
292 static MS_PQ_RFBL_INFO _stRFBL_Info = {.bEnable = FALSE, .bFilm = FALSE , .u8MADiType = 0, };
293 BW_INFO_t bw_info;
294
295
296 MS_BOOL gbPQBinEnable = 0;
297 MS_PQBin_Header_Info stPQBinHeaderInfo[MAX_PQ_BIN_NUM];
298 extern MS_PQTextBin_Header_Info stPQTextBinHeaderInfo[MAX_PQ_TEXT_BIN_NUM];
299 extern MS_BOOL gbEnablePQTextBin;
300
301 MS_S32 _PQ_Mutex = -1;
302
303 static EN_POWER_MODE _enPrevPowerState = E_POWER_SUSPEND;
304
305
306 #ifdef MSOS_TYPE_LINUX
307 pthread_mutex_t _PQ_MLoad_Mutex;
308 #endif
309
310
311
312 #define PQ_BIN_CUSTOMER_PANEL_INDEX 0
313 #define PQ_BIN_UFSC_PANEL_INDEX 0
314 #if (ENABLE_PQ_BIN_CF)
315 #define PQ_BIN_CF_PANEL_INDEX 0
316 #endif
317 #define PQ_IS_4K_INPUT(HSize,Vsize) (((HSize) > 3000) && ((Vsize) >= 1050)) //Load 4k2k PQ mode if input is 4k2k or 4k1k.
318
319 MS_PQ_Hdmi_Info _stHDMI_Info[PQ_MAX_WINDOW];
320 MS_PQ_Vd_Info _stVD_Info[PQ_MAX_WINDOW];
321 MS_PQ_Mode_Info _stMode_Info[PQ_MAX_WINDOW];
322 MS_U8 _u8ModeIndex[PQ_MAX_WINDOW];
323 MS_PQ_MuliMedia_Info _stMultiMedia_Info[PQ_MAX_WINDOW];
324 MS_PQ_Dtv_Info _stDTV_Info[PQ_MAX_WINDOW];
325 MS_PQ_Init_Info _stPQ_Info;
326 MS_BOOL _gbMemfmt422[PQ_MAX_WINDOW]={1, 1};
327 MS_U16 _gu16SetMemfmt_Madi[PQ_MAX_WINDOW]={0xFFFF, 0xFFFF};
328 MS_U16 _gu16SetMemfmt_Madi_Motion[PQ_MAX_WINDOW]={0xFFFF, 0xFFFF};
329
330 MS_BOOL _gIsSrcHDMode[PQ_MAX_WINDOW];
331 PQ_FOURCE_COLOR_FMT _gForceColorFmt[PQ_MAX_WINDOW];
332 MS_BOOL _gIs3D_En = 0;
333 MS_BOOL _bBypassModeOn[PQ_MAX_WINDOW]={0, 0};
334 MS_BOOL _gIsEnable8LBMode = FALSE;
335
336 MS_S32 _s32LastPQIPMADiMain = -1;
337 MS_S32 _s32LastPQIPMemFormatMain = -1;
338 MS_S32 _s32LastPQIPHSDYMain = -1;
339 MS_S32 _s32LastPQIPHSDCMain = -1;
340 MS_S32 _s32LastPQIPMADiSub = -1;
341 MS_S32 _s32LastPQIPMemFormatSub = -1;
342 MS_S32 _s32LastPQIPMADiMotMain = -1;
343 MS_S32 _s32LastPQIPMADiMotSub = -1;
344
345 static MS_U16 _upLayerConfig = 0;
346
347 #if PQ_UC_CTL
348 static MS_U16 _u16MADi_DFK_Current[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
349 static MS_U16 _u16MADi_SST_Current[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
350 static MS_U16 _u16MADi_EODiW_Current[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
351 static MS_U16 _u16UCNR_Current[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
352 static MS_U16 _u16UCDi_Current[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
353 static MS_U16 _u16UCCTL_Current[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
354 static MS_U16 _u16SwDriver_Current[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
355 static MS_U16 _u16PostCCS_Current[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
356 static MS_U16 _u16DHD_Current[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
357
358 #endif
359
360 extern MS_BOOL _gIsMVC4kx1k;
361 PQ_DISPLAY_TYPE _enPQDisplayType = PQ_DISPLAY_ONE;
362 #if !defined(MSOS_TYPE_LINUX_KERNEL)
363 extern void MApi_XC_Set_OPWriteOffEnableToReg(MS_BOOL bEnable, SCALER_WIN eWindow) __attribute__((weak));
364 #endif
365 extern MS_U16 QM_InputSourceToIndex(void* pInstance, PQ_WIN eWindow, MS_U8 enInputSourceType);
366 extern MS_U16 QM_InputSourceToIndex_UFSC(void* pInstance,PQ_WIN eWindow, MS_U8 enInputSourceType);
367 #if (ENABLE_PQ_BIN_CF)
368 extern MS_U16 QM_InputSourceToIndex_CF(void* pInstance,PQ_WIN eWindow, MS_U8 enInputSourceType);
369 #endif
370 #ifdef UFO_XC_PQ_SUPPORT_SWMOTION
371 static MS_U8 u8BK22_78_L = 0x00;
372 static MS_U8 u8BK22_78_H = 0x00;
373 static MS_U8 u8BK22_79_L = 0x00;
374 static MS_U8 u8BK22_79_H = 0x00;
375
376 //////////////////////////////////////////////////////////////////
377 // set MADi force Y/C motion enable bit
378 // function:
379 // SAVE/RESTORE/SET
380 //
381 #define SAVE_FORCE_YC_MOTION_ENABLE(pInstance,bMainWin) \
382 do{ \
383 if(bMainWin)\
384 {\
385 u8BK22_78_L = Hal_PQ_get_force_y_motion(pInstance,bMainWin); \
386 u8BK22_79_L = Hal_PQ_get_force_c_motion(pInstance,bMainWin);\
387 }\
388 else\
389 {\
390 u8BK22_78_H = Hal_PQ_get_force_y_motion(pInstance,bMainWin); \
391 u8BK22_79_H = Hal_PQ_get_force_c_motion(pInstance,bMainWin);\
392 }\
393 } while(0)
394
395 #define SAVE_FORCE_Y_MOTION_ENABLE(pInstance,bMainWin) \
396 do{ \
397 if(bMainWin)\
398 {\
399 u8BK22_78_L = Hal_PQ_get_force_y_motion(pInstance,bMainWin); \
400 }\
401 else\
402 {\
403 u8BK22_78_H = Hal_PQ_get_force_y_motion(pInstance,bMainWin); \
404 }\
405 } while(0)
406
407 #define SAVE_FORCE_C_MOTION_ENABLE(pInstance,bMainWin) \
408 do{ \
409 if(bMainWin)\
410 {\
411 u8BK22_79_L = Hal_PQ_get_force_c_motion(pInstance,bMainWin);\
412 }\
413 else\
414 {\
415 u8BK22_79_H = Hal_PQ_get_force_c_motion(pInstance,bMainWin);\
416 }\
417 } while(0)
418
419 #define RESTORE_FORCE_YC_MOTION_ENABLE(pInstance,bMainWin) \
420 do{ \
421 if(bMainWin)\
422 {\
423 Hal_PQ_set_force_y_motion(pInstance, 1, (MS_U16)u8BK22_78_L);\
424 Hal_PQ_set_force_c_motion(pInstance, 1, (MS_U16)u8BK22_79_L);\
425 }\
426 else\
427 {\
428 Hal_PQ_set_force_y_motion(pInstance, 0, (((MS_U16)u8BK22_78_H)<<8));\
429 Hal_PQ_set_force_c_motion(pInstance, 0, (((MS_U16)u8BK22_79_H))<<8);\
430 }\
431 } while(0)
432
433 #define RESTORE_FORCE_Y_MOTION_ENABLE(pInstance,bMainWin) \
434 do{ \
435 if(bMainWin)\
436 {\
437 Hal_PQ_set_force_y_motion(pInstance, TRUE, (MS_U16)u8BK22_78_L);\
438 }\
439 else\
440 {\
441 Hal_PQ_set_force_y_motion(pInstance, FALSE, (((MS_U16)u8BK22_78_H)<<8));\
442 }\
443 } while(0)
444
445 #define RESTORE_FORCE_C_MOTION_ENABLE(pInstance,bMainWin) \
446 do{ \
447 if(bMainWin)\
448 {\
449 Hal_PQ_set_force_c_motion(pInstance, TRUE, (MS_U16)u8BK22_79_L);\
450 }\
451 else\
452 {\
453 Hal_PQ_set_force_c_motion(pInstance, FALSE, (((MS_U16)u8BK22_79_H))<<8);\
454 }\
455 } while(0)
456 #endif
457 //////////////////////////////////////////////////////////////////
458 // PQ Patch
459 MS_BOOL _bOSD_On = FALSE;
460
461 MS_BOOL bSetFrameCount = TRUE;
462
463 #if 0 //def _PDEBUG
464 #define PTH_PQ_RET_CHK(_pf_) \
465 ({ \
466 int r = _pf_; \
467 if (r != 0 && r != ETIMEDOUT) \
468 fprintf(stderr, "[PTHREAD] %s: %d: %s: %s\n", __FILE__, __LINE__, #_pf_, strerror(r)); \
469 r; \
470 })
471 #else
472 #define PTH_PQ_RET_CHK(_pf_) //_pf_
473 #endif
474
475
476 #ifdef MSOS_TYPE_LINUX
477 #define PQ_MLOAD_ENTRY() PTH_PQ_RET_CHK(pthread_mutex_lock(&_PQ_MLoad_Mutex))
478 #define PQ_MLOAD_RETURN() PTH_PQ_RET_CHK(pthread_mutex_unlock(&_PQ_MLoad_Mutex))
479 #else
480 #define PQ_MLOAD_ENTRY()
481 #define PQ_MLOAD_RETURN()
482 #endif
483
484 #ifndef PQ_VIP_RGBCMY_CTL_VER2
485 #define PQ_VIP_RGBCMY_CTL_VER2 0
486 #endif
487
488 //////////////////////////////////////////////////////////////////
489 // OS related
490 //
491 //
492 #define XC_PQ_WAIT_MUTEX (TICK_PER_ONE_MS * 50) // 50 ms
493
494 //#define TRACE_DBG
495 /*
496 // Mutex & Lock
497 static MS_S32 _s32XC_PQMutex = -1;
498
499
500 #define XC_PQ_ENTRY() { if (_s32XC_PQMutex < 0) { return E_XC_ACE_FAIL; } \
501 if(OS_OBTAIN_MUTEX(_s32XC_PQMutex, XC_PQ_WAIT_MUTEX) == FALSE) return E_XC_ACE_OBTAIN_MUTEX_FAIL; }
502
503 #define XC_PQ_RETURN(_ret) { OS_RELEASE_MUTEX(_s32XC_PQMutex); return _ret; }
504 */
505
506 //////////////////////////////////////////////////////////////////
507
508 #define PQ_FILE_NAME_LENGTH 128
509 #define IsVBY1_16LANE(x) (((x)== E_XC_PNL_LPLL_VBY1_10BIT_16LANE)||((x)== E_XC_PNL_LPLL_VBY1_8BIT_16LANE))
510
511 char pm_PQBinFilePathName[PQ_FILE_NAME_LENGTH] = {0};
512 const char DefaltPath_Ini[] = "/config/pq/";
513 const char CustomerPath_Ini[] = "/Customer/pq/";
514 const char MainBinName[] = "Main.bin";
515 const char MainExBinName[] = "Main_Ex.bin";
516 const char MainColorBinName[]= "Main_Color.bin";
517 const char UFSCBinName[]= "UFSC.bin";
518 const char SubBinName[] = "Sub.bin";
519 const char SubExBinName[] = "Sub_Ex.bin";
520 const char SubColorBinName[] = "Sub_Color.bin";
521 #if (ENABLE_PQ_BIN_CF)
522 const char MainCFBinName[]= "Main_CF.bin";
523 const char SubCFBinName[]= "Sub_CF.bin";
524 #endif
525
526 void* g_pPQResource[E_PQ_DEVICE_ID_MAX];
527 static MS_U16 MDrv_PQ_GetXRuleIPNum(void* pInstance,PQ_WIN eWindow, MS_U16 u16XRuleType);
528 static MS_BOOL _MDrv_PQ_LoadScalingTable(void* pInstance,PQ_WIN eWindow,MS_U8 eXRuleType,MS_U8 u8XRuleIP,MS_BOOL bPreV_ScalingDown,MS_BOOL bInterlace,MS_BOOL bColorSpaceYUV,MS_U16 u16InputSize,MS_U16 u16SizeAfterScaling);
529 static MS_U16 MDrv_PQ_GetXRuleIPIndex(void* pInstance,PQ_WIN eWindow, MS_U16 u16XRuleType, MS_U16 u16XRuleIP);
530 static MS_U16 MDrv_PQ_GetXRuleTableIndex(void* pInstance,PQ_WIN eWindow, MS_U16 u16XRuleType, MS_U16 u16XRuleIdx, MS_U16 u16XRuleIP);
531 static void _MDrv_PQ_EnableRequest_FrameBufferLess(MS_BOOL bEnable, PQ_WIN eWindow);
532 static MS_BOOL _MDrv_PQ_SetGRuleStatus(void *pInstance,PQ_WIN eWindow, MS_U16 u16GruleType, MS_U16 u16PQ_GroupIdx);
533 #if (PQ_GRULE_GAME_MODE_ENABLE == 1)
534 static MS_BOOL _MDrv_PQ_LoadGameModeTable(void* pInstance, PQ_WIN eWindow, MS_U16 u16PQ_GameMode_Idx);
535 #endif
536 #if defined(PQ_GRULE_HDR_ENABLE) && (PQ_GRULE_HDR_ENABLE == 1)
537 static MS_BOOL _MDrv_PQ_LoadHDRModeTable(PQ_WIN eWindow, MS_U16 u16GRuleLevelIndex);
538 #endif
539 #if (defined (UFO_XC_DS_PQ))
540 extern MS_BOOL _gIsNetworkMM;
541 extern MS_BOOL MApi_XC_Is_SupportSWDS(void);
542 extern void MDrv_PQBin_DS_GetTable(void* pInstance,PQ_WIN eWindow, MS_U16 u16TabIdx, MS_U16 u16PQIPIdx, PQ_ENGINE_TYPE ePQEngineType);
543
544 MS_BOOL imode_PQDS = FALSE;
MDrv_PQ_set_imode_PQDS(MS_BOOL imode)545 void MDrv_PQ_set_imode_PQDS(MS_BOOL imode)
546 {
547 imode_PQDS = imode;
548 }
MDrv_PQ_GetGRule_TableIndex_PQDS(void * pInstance,PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16PQ_NRIdx,MS_U16 u16GRuleIPIndex)549 MS_U16 MDrv_PQ_GetGRule_TableIndex_PQDS(void* pInstance,PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16PQ_NRIdx, MS_U16 u16GRuleIPIndex)
550 {
551 MS_U16 u16Ret = 0;
552 if(eWindow == PQ_MAIN_WINDOW)
553 {
554 if(gbPQBinEnable)
555 {
556 #ifndef MSOS_TYPE_LINUX_KERNEL
557 if(_gIsNetworkMM)
558 {
559 _u16PQSrcType[eWindow] = QM_NetWork_4K2K_DS_Main;
560 }
561 else
562 {
563 if(!imode_PQDS)
564 {
565 _u16PQSrcType[eWindow] = QM_MM_4K2K_DS_Main;
566 }
567 else
568 {
569 _u16PQSrcType[eWindow] = QM_Multimedia_video_HD_interlace_Main;
570 }
571 }
572 #endif
573 u16Ret = (MS_U8) MDrv_PQBin_GetGRule_TableIndex(pInstance,u16GRuleType,
574 _u16PQSrcType[eWindow],
575 u16PQ_NRIdx,
576 u16GRuleIPIndex,
577 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
578 }
579 else
580 {
581 u16Ret = MDrv_PQ_GetGRule_TableIndex_(MAIN,pInstance, (MS_U8)u16GRuleType, _u16PQSrcType[eWindow], (MS_U8)u16PQ_NRIdx, (MS_U8)u16GRuleIPIndex);
582 }
583 }
584 #if (PQ_ENABLE_PIP)
585 else if(eWindow == PQ_SUB_WINDOW)
586 {
587 if(gbPQBinEnable)
588 {
589 u16Ret = (MS_U8) MDrv_PQBin_GetGRule_TableIndex(pInstance,u16GRuleType,
590 _u16PQSrcType[eWindow],
591 u16PQ_NRIdx,
592 u16GRuleIPIndex,
593 &stPQBinHeaderInfo[PQ_BIN_STD_SUB]);
594 }
595 else
596 {
597 u16Ret = MDrv_PQ_GetGRule_TableIndex_(SUB,pInstance, (MS_U8)u16GRuleType, _u16PQSrcType[eWindow], (MS_U8)u16PQ_NRIdx, (MS_U8)u16GRuleIPIndex);
598 }
599 }
600 #endif
601 else
602 {
603 MS_ASSERT(0);
604 }
605
606 return u16Ret;
607 }
608
_MDrv_PQ_LoadDSModeTable(void * pInstance,SCALER_WIN eWindow,MS_U16 u16PQ_GameMode_Idx,PQ_ENGINE_TYPE ePQEngineType)609 MS_BOOL _MDrv_PQ_LoadDSModeTable(void* pInstance, SCALER_WIN eWindow, MS_U16 u16PQ_GameMode_Idx, PQ_ENGINE_TYPE ePQEngineType)
610 {
611 MS_U16 i, u16IPIdx=0, u16TabIdx=0;
612
613 if(eWindow == SUB_WINDOW)
614 {
615 return FALSE;
616 }
617
618 switch(ePQEngineType)
619 {
620 case PQ_XC0_STD:
621 if (u16PQ_GameMode_Idx > PQ_GRULE_DS_PARAMETERS_LVL_NUM_Main)
622 {
623 MS_ASSERT(0);
624 return FALSE;
625 }
626
627 for(i=0; i<PQ_GRULE_DS_PARAMETERS_IP_NUM_Main; i++)
628 {
629 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_U2(pInstance, eWindow, PQ_GRule_DS_PARAMETERS_Main, i);
630
631 if (u16PQ_GameMode_Idx == PQ_GRULE_DS_PARAMETERS_NUM_Main) // see it as default
632 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance, eWindow, u16IPIdx);
633 else
634 u16TabIdx = MDrv_PQ_GetGRule_TableIndex_PQDS(pInstance,eWindow, PQ_GRule_DS_PARAMETERS_Main, u16PQ_GameMode_Idx, i);
635
636 //XC_PRINTF("\033[1;32m[%s:%d]u16PQ_GameModeIdx = %d,u16IPIdx = %d,u16TabIdx = %d\033[m\n",__FUNCTION__,__LINE__,u16PQ_GameMode_Idx,u16IPIdx,u16TabIdx);
637 MDrv_PQBin_DS_GetTable(pInstance,eWindow, u16TabIdx, u16IPIdx,PQ_XC0_STD);
638 }
639 break;
640 case PQ_XC0_UFSC:
641 #if defined(PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE) && PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE
642
643 _u16PQSrcType_UFSC[eWindow]= QM_InputSourceToIndex_UFSC(pInstance,eWindow, _enInputSourceType[eWindow]);
644
645 if (u16PQ_GameMode_Idx > PQ_GRULE_DS_PARAMETERS_LVL_NUM_UFSC)
646 {
647 MS_ASSERT(0);
648 return FALSE;
649 }
650 for(i=0; i<PQ_GRULE_DS_PARAMETERS_IP_NUM_UFSC; i++)
651 {
652 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_Ex_U2(pInstance, eWindow, PQ_GRule_DS_PARAMETERS_UFSC, i, PQ_XC0_UFSC);
653
654 if (u16PQ_GameMode_Idx == PQ_GRULE_DS_PARAMETERS_NUM_UFSC) // see it as default
655 u16TabIdx = MDrv_PQ_GetTableIndex_Ex_U2(pInstance, eWindow, u16IPIdx, PQ_XC0_UFSC);
656 else
657 u16TabIdx = MDrv_PQ_GetGRule_TableIndex_Ex_U2(pInstance,eWindow, PQ_GRule_DS_PARAMETERS_UFSC, u16PQ_GameMode_Idx, i, PQ_XC0_UFSC);
658
659 //XC_PRINTF("\033[1;32m[%s:%d]u16PQ_GameModeIdx = %d,u16IPIdx = %d,u16TabIdx = %d\033[m\n",__FUNCTION__,__LINE__,u16PQ_GameMode_Idx,u16IPIdx,u16TabIdx);
660 MDrv_PQBin_DS_GetTable(pInstance,eWindow, u16TabIdx, u16IPIdx,PQ_XC0_UFSC);
661 }
662 #endif
663 break;
664 default:
665 break;
666 }
667 //MDrv_PQ_LoadScalingTable_U2
668 return TRUE;
669 }
_MDrv_PQ_Load_DS_Table(void * pInstance,PQ_WIN eWindow,MS_U32 V_Size,MS_U32 H_Size)670 void _MDrv_PQ_Load_DS_Table(void* pInstance,PQ_WIN eWindow,MS_U32 V_Size, MS_U32 H_Size)
671 {
672 MS_U16 u16PQ_GameModeIdx = 0;
673 #if defined(PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE) && PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE
674 MS_U16 u16PQ_GameModeUFSCIdx = 0;
675 #endif
676 if(V_Size >=2160)
677 {
678 u16PQ_GameModeIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DS_PARAMETERS_Main, PQ_GRule_Lvl_DS_PARAMETERS_4K_Main);
679 #if defined(PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE) && PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE
680 u16PQ_GameModeUFSCIdx = MDrv_PQ_GetGRule_LevelIndex_Ex_U2(pInstance, eWindow, PQ_GRule_DS_PARAMETERS_UFSC, PQ_GRule_Lvl_DS_PARAMETERS_4K_UFSC,PQ_XC0_UFSC);
681 #endif
682 }else if( (V_Size < 2160) && (V_Size >= 720) )
683 {
684 u16PQ_GameModeIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DS_PARAMETERS_Main, PQ_GRule_Lvl_DS_PARAMETERS_FHD_Main);
685 #if defined(PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE) && PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE
686 u16PQ_GameModeUFSCIdx = MDrv_PQ_GetGRule_LevelIndex_Ex_U2(pInstance, eWindow, PQ_GRule_DS_PARAMETERS_UFSC, PQ_GRule_Lvl_DS_PARAMETERS_FHD_UFSC,PQ_XC0_UFSC);
687 #endif
688 }else if( (V_Size < 720) && (V_Size >= 480) )
689 {
690 u16PQ_GameModeIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DS_PARAMETERS_Main, PQ_GRule_Lvl_DS_PARAMETERS_SD_Main);
691 #if defined(PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE) && PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE
692 u16PQ_GameModeUFSCIdx = MDrv_PQ_GetGRule_LevelIndex_Ex_U2(pInstance, eWindow, PQ_GRule_DS_PARAMETERS_UFSC, PQ_GRule_Lvl_DS_PARAMETERS_SD_UFSC,PQ_XC0_UFSC);
693 #endif
694 }
695 else
696 {
697 u16PQ_GameModeIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DS_PARAMETERS_Main, PQ_GRule_Lvl_DS_PARAMETERS_L_SD_Main);
698 #if defined(PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE) && PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE
699 u16PQ_GameModeUFSCIdx = MDrv_PQ_GetGRule_LevelIndex_Ex_U2(pInstance, eWindow, PQ_GRule_DS_PARAMETERS_UFSC, PQ_GRule_Lvl_DS_PARAMETERS_L_SD_UFSC,PQ_XC0_UFSC);
700 #endif
701 }
702 //XC_PRINTF("\033[1;32m[%s:%d]DS-PQ = %d [%d:%d]\033[m\n",__FUNCTION__,__LINE__,u16PQ_GameModeIdx,V_Size,H_Size);
703 _MDrv_PQ_LoadDSModeTable(pInstance,eWindow,u16PQ_GameModeIdx,PQ_XC0_STD);
704 #if defined(PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE) && PQ_GRULE_UFSC_DS_PARAMETERS_ENABLE
705 _MDrv_PQ_LoadDSModeTable(pInstance,eWindow,u16PQ_GameModeIdx,PQ_XC0_UFSC);
706 #endif
707 }
708 #endif
709
MDrv_PQ_Get_Semaphore(void * pInstance,E_PQ_POOL_ID eID_TYPE)710 MS_U32 MDrv_PQ_Get_Semaphore(void *pInstance,E_PQ_POOL_ID eID_TYPE)
711 {
712 E_PQ_POOL_ID eID=eID_TYPE;
713 PQ_INSTANCE_PRIVATE *psPQInstPri = NULL;
714 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
715
716 if(pInstance == NULL)
717 {
718 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
719 return u32Return;
720 }
721 else
722 {
723 UtopiaInstanceGetPrivate(pInstance, (void**)&psPQInstPri);
724 }
725
726 #if 0 // for Debug. It is important to check the tid
727 pid_t tid;
728 tid = syscall(SYS_gettid);
729 printf("tid = (%d)\n",tid);
730 #endif
731
732 void* pModule = NULL;
733 UtopiaInstanceGetModule(pInstance, &pModule);
734
735 if(UtopiaResourceObtain(pModule, eID, &g_pPQResource[eID]) != UTOPIA_STATUS_SUCCESS)
736 {
737 printf("UtopiaResourceObtain fail\n");
738 return UTOPIA_STATUS_ERR_RESOURCE;
739 }
740 u32Return = UTOPIA_STATUS_SUCCESS;
741 return u32Return;
742 }
743
MDrv_PQ_Release_Semaphore(void * pInstance,E_PQ_POOL_ID eID_TYPE)744 MS_U32 MDrv_PQ_Release_Semaphore(void *pInstance,E_PQ_POOL_ID eID_TYPE)
745 {
746 E_PQ_POOL_ID eID=eID_TYPE;
747 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
748 PQ_INSTANCE_PRIVATE *psPQInstPri = NULL;
749
750 if(pInstance == NULL)
751 {
752 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
753 return u32Return;
754 }
755 else
756 {
757 UtopiaInstanceGetPrivate(pInstance, (void**)&psPQInstPri);
758 }
759 #if 0 // for Debug. It is important to check the tid
760 pid_t tid;
761 tid = syscall(SYS_gettid);
762 printf("tid = (%d)\n",tid);
763 #endif
764
765 u32Return = UtopiaResourceRelease(g_pPQResource[eID]);
766 return u32Return;
767 }
768
Open_PQ_Bin(MS_U8 * pName)769 MS_U8 * Open_PQ_Bin(MS_U8 * pName)
770 {
771 long lFileSize;
772 MS_U32 u32Rst;
773 const char * Name;
774 MS_U8 *pu8Buffer;
775
776 Name = (const char *)pName;
777 #if !defined(MSOS_TYPE_LINUX_KERNEL)
778 FILE * pFile = NULL;
779 int fd;
780 struct stat fileStat;
781
782 pFile = fopen(Name, "rb");
783 if(pFile == NULL)
784 {
785 printf("Open %s Failed\n", pName);
786 return NULL;
787 }
788
789 fd = fileno(pFile);
790 if((fstat(fd, &fileStat) != 0))
791 {
792 printf("get file stat %s Failed\n", pName);
793 return NULL;
794 }
795 lFileSize = fileStat.st_size;
796
797 if (lFileSize <= 0)
798 {
799 fclose(pFile);
800 return NULL;
801 }
802
803 pu8Buffer = (MS_U8*) malloc(lFileSize);
804 if(pu8Buffer == NULL)
805 {
806 printf("out of memory \n");
807 fclose(pFile);
808 return NULL;
809 }
810
811 u32Rst = fread(pu8Buffer, 1, lFileSize, pFile);
812 if(u32Rst != (MS_U32)lFileSize)
813 {
814 printf("Read Main.bin Error %d %ld\n", u32Rst, lFileSize);
815 free(pu8Buffer);
816 fclose(pFile);
817 return NULL;
818 }
819
820 fclose(pFile);
821 #else
822 struct file *pFile = NULL;
823
824 mm_segment_t cur_mm_seg;
825 pFile = filp_open(Name, O_RDONLY, 0);
826 if(pFile == NULL)
827 {
828 printk("Open %s Failed\n", pName);
829
830 return NULL;
831 }
832 vfs_llseek(pFile, 0, SEEK_END);
833 lFileSize = pFile->f_pos;
834 if (lFileSize <= 0)
835 {
836 filp_close(pFile, NULL);
837
838 return NULL;
839 }
840 loff_t pos = vfs_llseek(pFile, 0, SEEK_SET);
841 pu8Buffer = (MS_U8*)vmalloc(lFileSize);
842
843 if(pu8Buffer == NULL)
844 {
845 printk("out of memory \n");
846 filp_close(pFile, NULL);
847
848 return NULL;
849 }
850 cur_mm_seg = get_fs();
851 set_fs(KERNEL_DS);
852 u32Rst = vfs_read(pFile, pu8Buffer, lFileSize, &pos);
853 set_fs(cur_mm_seg);
854 if(u32Rst != (MS_U32)lFileSize)
855 {
856 printk("Read Main.bin Error %d %ld\n", u32Rst, lFileSize);
857 vfree(pu8Buffer);
858 filp_close(pFile, NULL);
859
860 return NULL;
861 }
862
863 filp_close(pFile, NULL);
864
865 #endif
866
867 return pu8Buffer;
868
869 }
870
871
872 #if !defined(MSOS_TYPE_LINUX_KERNEL)
_MDrv_PQ_LoadPQBin(void * pInstance,MS_PQ_Init_Info * pstPQInitInfo)873 void _MDrv_PQ_LoadPQBin(void* pInstance,MS_PQ_Init_Info *pstPQInitInfo)
874 {
875 PQ_INSTANCE_PRIVATE *psPQInstPri = NULL;
876 UtopiaInstanceGetPrivate(pInstance, (void**)&psPQInstPri);
877 PQ_RESOURCE_PRIVATE* pPQResourcePrivate = NULL;
878 MDrv_PQ_Get_Semaphore(pInstance,E_PQ_POOL_ID_INTERNAL);
879 UtopiaResourceGetPrivate(g_pPQResource[E_PQ_DEVICE_ID_0],(void**)(&pPQResourcePrivate));
880
881 if (MDrv_SYS_GetChipType() == E_SYS_CHIP_STB)
882 {
883 pstPQInitInfo->u8PQBinCnt = 0;
884 pstPQInitInfo->u8PQTextBinCnt = 0;
885 pstPQInitInfo->u8PQBinCustomerCnt = 0;
886 }
887 else
888 {
889 #if(ENABLE_PQ_BIN)
890 MS_PQ_CAP_INFO stPQCaps;
891 MS_U8 *pu8MainBuf= NULL, *pu8MainExBuf= NULL;
892
893 char DefaltPath[PQ_FILE_NAME_LENGTH]={0};
894 char CustomerPath[PQ_FILE_NAME_LENGTH]={0};
895 char IniPath[PQ_FILE_NAME_LENGTH]={0};
896
897 ///// SET PQ BIN PATH
898 if(pPQResourcePrivate->stPQBin_Path.pm_PQ_DEFAULT_PATH[0] !=NULL) //Set DefaltPath
899 {
900 strncpy(DefaltPath,pPQResourcePrivate->stPQBin_Path.pm_PQ_DEFAULT_PATH,PQ_FILE_PATH_LENGTH);
901 }
902 else
903 {
904 strncpy(DefaltPath,DefaltPath_Ini,strlen(DefaltPath_Ini));
905 }
906
907 if(pPQResourcePrivate->stPQBin_Path.pm_PQ_CUSTOMER_PATH[0] !=NULL) //Set CustomerPath
908 {
909 strncpy(CustomerPath,pPQResourcePrivate->stPQBin_Path.pm_PQ_CUSTOMER_PATH,PQ_FILE_PATH_LENGTH);
910 }
911 else
912 {
913 strncpy(CustomerPath,CustomerPath_Ini,strlen(CustomerPath_Ini));
914 }
915
916 if(pPQResourcePrivate->stPQBin_Path.pm_PQ_INI_PATH[0] !=NULL) //Set IniPath
917 {
918 strncpy(IniPath,pPQResourcePrivate->stPQBin_Path.pm_PQ_INI_PATH,PQ_FILE_PATH_LENGTH);
919 }
920
921
922
923 FILE *pFile = NULL;
924
925 // if Main.bin exists in /Customer/pq, read it
926 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
927 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
928 strncat(pm_PQBinFilePathName, MainBinName, strlen(MainBinName));
929 pFile = fopen(pm_PQBinFilePathName, "r");
930 if(pFile == NULL)
931 {
932 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
933 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
934 strncat(pm_PQBinFilePathName, MainBinName, strlen(MainBinName));
935 pFile = fopen(pm_PQBinFilePathName, "r");
936 if(pFile == NULL)
937 {
938 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
939 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
940 strncat(pm_PQBinFilePathName, MainBinName, strlen(MainBinName));
941 pFile = fopen(pm_PQBinFilePathName, "r");
942 }
943 if (pFile != NULL)
944 {
945 fclose(pFile);
946 pFile = NULL;
947 pu8MainBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
948 }
949 else
950 {
951 pFile = NULL;
952 }
953 }
954 else
955 {
956 // read from /Customer/pq
957 fclose(pFile);
958 pFile = NULL;
959 pu8MainBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
960 }
961 printf("Load PQ bin file, PQ_BIN_STD_MAIN path [%s]\n", pm_PQBinFilePathName);
962
963 // if Main_Ex.bin exists in /Customer/pq, read it
964 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
965 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
966 strncat(pm_PQBinFilePathName, MainExBinName, strlen(MainExBinName));
967 pFile = fopen(pm_PQBinFilePathName, "r");
968 if(pFile == NULL)
969 {
970 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
971 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
972 strncat(pm_PQBinFilePathName, MainExBinName, strlen(MainExBinName));
973 pFile = fopen(pm_PQBinFilePathName, "r");
974 if(pFile == NULL)
975 {
976 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
977 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
978 strncat(pm_PQBinFilePathName, MainExBinName, strlen(MainExBinName));
979 pFile = fopen(pm_PQBinFilePathName, "r");
980 }
981 if (pFile != NULL)
982 {
983 fclose(pFile);
984 pFile = NULL;
985 pu8MainExBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
986 }
987 else
988 {
989 pFile = NULL;
990 }
991 }
992 else
993 {
994 // read from /Customer/pq
995 fclose(pFile);
996 pFile = NULL;
997 pu8MainExBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
998 }
999 printf("Load PQ bin file, PQ_BIN_EXT_MAIN path [%s]\n", pm_PQBinFilePathName);
1000
1001 if(pu8MainBuf && pu8MainExBuf)
1002 {
1003 pstPQInitInfo->u8PQBinCnt = 2;
1004 pstPQInitInfo->stPQBinInfo[0].u8PQID = (MS_U8) PQ_BIN_STD_MAIN;
1005 pstPQInitInfo->stPQBinInfo[0].PQBin_PhyAddr = (MS_PHYADDR) pu8MainBuf;
1006 pstPQInitInfo->stPQBinInfo[1].u8PQID = (MS_U8) PQ_BIN_EXT_MAIN;
1007 pstPQInitInfo->stPQBinInfo[1].PQBin_PhyAddr = (MS_PHYADDR)pu8MainExBuf;
1008 }
1009 else
1010 {
1011 pstPQInitInfo->u8PQBinCnt = 0;
1012
1013 }
1014
1015 MS_U8 *pu8MainCustomerBuf = NULL;
1016 pstPQInitInfo->u8PQBinCustomerCnt = 0 ;
1017 // if Main_Color.bin exists in /Customer/pq, read it
1018 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1019 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1020 strncat(pm_PQBinFilePathName, MainColorBinName, strlen(MainColorBinName));
1021 pFile = fopen(pm_PQBinFilePathName, "r");
1022 if(pFile == NULL)
1023 {
1024 // read from default path
1025 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1026 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
1027 strncat(pm_PQBinFilePathName, MainColorBinName, strlen(MainColorBinName));
1028 pFile = fopen(pm_PQBinFilePathName, "r");
1029 if (pFile != NULL)
1030 {
1031 fclose(pFile);
1032 pFile = NULL;
1033 pu8MainCustomerBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1034 }
1035 }
1036 else
1037 {
1038 // read from /Customer/pq
1039 fclose(pFile);
1040 pFile = NULL;
1041 pu8MainCustomerBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1042 }
1043 printf("Load PQ bin file, PQ_BIN_CUSTOMER_MAIN path [%s]\n", pm_PQBinFilePathName);
1044
1045 if(pu8MainCustomerBuf)
1046 {
1047 pstPQInitInfo->u8PQBinCustomerCnt = 1;
1048 pstPQInitInfo->stPQBinInfo[4].u8PQID = (MS_U8) PQ_BIN_CUSTOMER_MAIN;
1049 pstPQInitInfo->stPQBinInfo[4].PQBin_PhyAddr = (MS_PHYADDR) pu8MainCustomerBuf;
1050 }
1051 else
1052 {
1053 pstPQInitInfo->u8PQBinCustomerCnt = 0;
1054
1055 }
1056
1057 //Skip USFC now, which may cause kernel panic, wait PQ Driver complated.
1058
1059 MS_U8 *pu8UFSCBuf = NULL;
1060 pstPQInitInfo->u8PQBinUFSCCnt = 0;
1061 // if UFSC.bin exists in /Customer/pq, read it
1062 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1063 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1064 strncat(pm_PQBinFilePathName, UFSCBinName, strlen(UFSCBinName));
1065 pFile = fopen(pm_PQBinFilePathName, "r");
1066 if(pFile == NULL)
1067 {
1068 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1069 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
1070 strncat(pm_PQBinFilePathName, UFSCBinName, strlen(UFSCBinName));
1071 pFile = fopen(pm_PQBinFilePathName, "r");
1072 if(pFile == NULL)
1073 {
1074 // read from default path
1075 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1076 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
1077 strncat(pm_PQBinFilePathName, UFSCBinName, strlen(UFSCBinName));
1078 pFile = fopen(pm_PQBinFilePathName, "r");
1079 }
1080 if (pFile != NULL)
1081 {
1082 fclose(pFile);
1083 pFile = NULL;
1084 pu8UFSCBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1085 }
1086 else
1087 {
1088 pFile = NULL;
1089 }
1090 }
1091 else
1092 {
1093 // read from /Customer/pq
1094 fclose(pFile);
1095 pFile = NULL;
1096 pu8UFSCBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1097 }
1098
1099 if(pu8UFSCBuf)
1100 {
1101 printf("Load PQ bin file, PQ_BIN_UFSC path [%s]\n", pm_PQBinFilePathName);
1102 pstPQInitInfo->u8PQBinUFSCCnt = 1;
1103 pstPQInitInfo->stPQBinInfo[6].u8PQID = (MS_U8) PQ_BIN_UFSC;
1104 pstPQInitInfo->stPQBinInfo[6].PQBin_PhyAddr = (MS_PHYADDR) pu8UFSCBuf;
1105 }
1106 else
1107 {
1108 pstPQInitInfo->u8PQBinUFSCCnt = 0;
1109 XC_INITMISC sXC_Init_Misc;
1110 memset(&sXC_Init_Misc, 0, sizeof(XC_INITMISC));
1111 MApi_XC_GetMISCStatus(&sXC_Init_Misc);
1112 sXC_Init_Misc.u32MISC_B |= E_XC_INIT_MISC_B_SKIP_SR;
1113 MApi_XC_Init_MISC(&sXC_Init_Misc, sizeof(XC_INITMISC));
1114 }
1115 #if (ENABLE_PQ_BIN_CF)
1116 // load Main CF Qmap bin
1117
1118 MS_U8 *pu8MainCFBuf = NULL;
1119 pstPQInitInfo->u8PQBinCFCnt = 0;
1120 // if Main_CF.bin exists in /Customer/pq, read it
1121 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1122 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1123 strncat(pm_PQBinFilePathName, MainCFBinName, strlen(MainCFBinName));
1124 pFile = fopen(pm_PQBinFilePathName, "r");
1125 if(pFile == NULL)
1126 {
1127 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1128 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
1129 strncat(pm_PQBinFilePathName, MainCFBinName, strlen(MainCFBinName));
1130 pFile = fopen(pm_PQBinFilePathName, "r");
1131 if(pFile == NULL)
1132 {
1133 // read from default path
1134 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1135 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
1136 strncat(pm_PQBinFilePathName, MainCFBinName, strlen(MainCFBinName));
1137 pFile = fopen(pm_PQBinFilePathName, "r");
1138 }
1139 if (pFile != NULL)
1140 {
1141 fclose(pFile);
1142 pFile = NULL;
1143 pu8MainCFBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1144 }
1145 else
1146 {
1147 pFile = NULL;
1148 }
1149 }
1150 else
1151 {
1152 // read from /Customer/pq
1153 fclose(pFile);
1154 pFile = NULL;
1155 pu8MainCFBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1156 }
1157
1158 if(pu8MainCFBuf)
1159 {
1160 printf("Load PQ bin file, PQ_BIN_CF_MAIN path [%s]\n", pm_PQBinFilePathName);
1161 pstPQInitInfo->u8PQBinCFCnt = 1;
1162 pstPQInitInfo->stPQBinInfo[7].u8PQID = (MS_U8) PQ_BIN_CF_MAIN;
1163 pstPQInitInfo->stPQBinInfo[7].PQBin_PhyAddr = (MS_PHYADDR) pu8MainCFBuf;
1164 }
1165 #endif
1166 if(MDrv_PQ_GetCaps(&stPQCaps))
1167 {
1168 if(stPQCaps.b3DVideo_Supported || stPQCaps.bPIP_Supported)
1169 {
1170 MS_U8 *pu8SubBuf= NULL, *pu8SubExBuf= NULL ;
1171
1172 // check if Sub.bin exists in /Customer/pq/
1173 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1174 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1175 strncat(pm_PQBinFilePathName, SubBinName, strlen(SubBinName));
1176 pFile = fopen(pm_PQBinFilePathName, "r");
1177 if(pFile == NULL)
1178 {
1179 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1180 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
1181 strncat(pm_PQBinFilePathName, SubBinName, strlen(SubBinName));
1182 pFile = fopen(pm_PQBinFilePathName, "r");
1183 if(pFile == NULL)
1184 {
1185 // read from default path
1186 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1187 strncpy(pm_PQBinFilePathName,DefaltPath,strlen(DefaltPath));
1188 strncat(pm_PQBinFilePathName,SubBinName,strlen(SubBinName));
1189 pFile = fopen(pm_PQBinFilePathName, "r");
1190 }
1191 if (pFile != NULL)
1192 {
1193 fclose(pFile);
1194 pFile = NULL;
1195 pu8SubBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1196 }
1197 else
1198 {
1199 pFile = NULL;
1200 }
1201 }
1202 else
1203 {
1204 // read from /Customer/pq
1205 fclose(pFile);
1206 pFile = NULL;
1207 pu8SubBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1208 }
1209 printf("Load PQ bin file, PQ_BIN_STD_SUB path [%s]\n", pm_PQBinFilePathName);
1210
1211 // check if Sub_Ex.bin exists in /Customer/pq/
1212 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1213 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1214 strncat(pm_PQBinFilePathName, SubExBinName, strlen(SubExBinName));
1215 pFile = fopen(pm_PQBinFilePathName, "r");
1216 if(pFile == NULL)
1217 {
1218 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1219 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
1220 strncat(pm_PQBinFilePathName, SubExBinName, strlen(SubExBinName));
1221 pFile = fopen(pm_PQBinFilePathName, "r");
1222 if(pFile == NULL)
1223 {
1224 // read from default path
1225 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1226 strncpy(pm_PQBinFilePathName,DefaltPath,strlen(DefaltPath));
1227 strncat(pm_PQBinFilePathName,SubExBinName,strlen(SubExBinName));
1228 pFile = fopen(pm_PQBinFilePathName, "r");
1229 }
1230 if (pFile != NULL)
1231 {
1232 fclose(pFile);
1233 pFile = NULL;
1234 pu8SubExBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1235 }
1236 else
1237 {
1238 pFile = NULL;
1239 }
1240 }
1241 else
1242 {
1243 // read from /Customer/pq
1244 fclose(pFile);
1245 pFile = NULL;
1246 pu8SubExBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1247 }
1248 printf("Load PQ bin file, PQ_BIN_EXT_SUB path [%s]\n", pm_PQBinFilePathName);
1249
1250 if(pu8SubBuf && pu8SubExBuf)
1251 {
1252 pstPQInitInfo->u8PQBinCnt = 4;
1253 pstPQInitInfo->stPQBinInfo[2].u8PQID = (MS_U8) PQ_BIN_STD_SUB;
1254 pstPQInitInfo->stPQBinInfo[2].PQBin_PhyAddr = (MS_PHYADDR) pu8SubBuf;
1255 pstPQInitInfo->stPQBinInfo[3].u8PQID = (MS_U8) PQ_BIN_EXT_SUB;
1256 pstPQInitInfo->stPQBinInfo[3].PQBin_PhyAddr = (MS_PHYADDR)pu8SubExBuf;
1257 }
1258
1259 MS_U8 *pu8SubCustomerBuf = NULL;
1260 // check if Sub_Color.bin exists in /Customer/pq/
1261 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1262 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1263 strncat(pm_PQBinFilePathName, SubColorBinName, strlen(SubColorBinName));
1264 pFile = fopen(pm_PQBinFilePathName, "r");
1265 if(pFile == NULL)
1266 {
1267 // read from default path
1268 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1269 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
1270 strncat(pm_PQBinFilePathName, SubColorBinName, strlen(SubColorBinName));
1271 pFile = fopen(pm_PQBinFilePathName, "r");
1272 if (pFile != NULL)
1273 {
1274 fclose(pFile);
1275 pFile = NULL;
1276 pu8SubCustomerBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1277 }
1278 }
1279 else
1280 {
1281 // read from /Customer/pq
1282 fclose(pFile);
1283 pFile = NULL;
1284 pu8SubCustomerBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1285 }
1286
1287 if(pu8MainCustomerBuf && pu8SubCustomerBuf)
1288 {
1289 printf("Load PQ bin file, PQ_BIN_CUSTOMER_SUB path [%s]\n", pm_PQBinFilePathName);
1290 pstPQInitInfo->u8PQBinCustomerCnt = 2;
1291 pstPQInitInfo->stPQBinInfo[5].u8PQID = (MS_U8) PQ_BIN_CUSTOMER_SUB;
1292 pstPQInitInfo->stPQBinInfo[5].PQBin_PhyAddr = (MS_PHYADDR) pu8SubCustomerBuf;
1293 }
1294 }
1295 #if (ENABLE_PQ_BIN_CF)
1296 // load Sub CF Qmap bin
1297
1298 MS_U8 *pu8SubCFBuf = NULL;
1299 // if Sub_CF.bin exists in /Customer/pq, read it
1300 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1301 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1302 strncat(pm_PQBinFilePathName, SubCFBinName, strlen(SubCFBinName));
1303 pFile = fopen(pm_PQBinFilePathName, "r");
1304 if(pFile == NULL)
1305 {
1306 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1307 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
1308 strncat(pm_PQBinFilePathName, SubCFBinName, strlen(SubCFBinName));
1309 pFile = fopen(pm_PQBinFilePathName, "r");
1310 if(pFile == NULL)
1311 {
1312 // read from default path
1313 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1314 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
1315 strncat(pm_PQBinFilePathName, SubCFBinName, strlen(SubCFBinName));
1316 pFile = fopen(pm_PQBinFilePathName, "r");
1317 }
1318 if (pFile != NULL)
1319 {
1320 fclose(pFile);
1321 pFile = NULL;
1322 pu8SubCFBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1323 }
1324 else
1325 {
1326 pFile = NULL;
1327 }
1328 }
1329 else
1330 {
1331 // read from /Customer/pq
1332 fclose(pFile);
1333 pFile = NULL;
1334 pu8SubCFBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1335 }
1336
1337 if(pu8SubCFBuf)
1338 {
1339 printf("Load PQ bin file, PQ_BIN_CF_SUB path [%s]\n", pm_PQBinFilePathName);
1340 pstPQInitInfo->u8PQBinCFCnt = 2;
1341 pstPQInitInfo->stPQBinInfo[8].u8PQID = (MS_U8) PQ_BIN_CF_SUB;
1342 pstPQInitInfo->stPQBinInfo[8].PQBin_PhyAddr = (MS_PHYADDR) pu8SubCFBuf;
1343 }
1344 #endif
1345 }
1346 #else
1347 pstPQInitInfo->u8PQBinCnt = 0;
1348 pstPQInitInfo->u8PQTextBinCnt = 0;
1349 pstPQInitInfo->u8PQBinCustomerCnt = 0;
1350 pstPQInitInfo->u8PQBinUFSCCnt = 0;
1351 #if (ENABLE_PQ_BIN_CF)
1352 pstPQInitInfo->u8PQBinCFCnt = 0;
1353 #endif
1354
1355 #endif
1356 }
1357 MDrv_PQ_Release_Semaphore(pInstance,E_PQ_POOL_ID_INTERNAL);
1358 }
1359 #else
_MDrv_PQ_LoadPQBin(void * pInstance,MS_PQ_Init_Info * pstPQInitInfo)1360 void _MDrv_PQ_LoadPQBin(void* pInstance,MS_PQ_Init_Info *pstPQInitInfo)
1361 {
1362 PQ_INSTANCE_PRIVATE *psPQInstPri = NULL;
1363 UtopiaInstanceGetPrivate(pInstance, (void**)&psPQInstPri);
1364 PQ_RESOURCE_PRIVATE* pPQResourcePrivate = NULL;
1365 MDrv_PQ_Get_Semaphore(pInstance,E_PQ_POOL_ID_INTERNAL);
1366 UtopiaResourceGetPrivate(g_pPQResource[E_PQ_DEVICE_ID_0],(void**)(&pPQResourcePrivate));
1367
1368 /*if (MDrv_SYS_GetChipType() == E_SYS_CHIP_STB)
1369 {
1370 pstPQInitInfo->u8PQBinCnt = 0;
1371 pstPQInitInfo->u8PQTextBinCnt = 0;
1372 pstPQInitInfo->u8PQBinCustomerCnt = 0;
1373 }
1374 else //TV case
1375 */
1376 {
1377 #if(ENABLE_PQ_BIN)
1378 MS_PQ_CAP_INFO stPQCaps;
1379 MS_U8 *pu8MainBuf = NULL, *pu8MainExBuf = NULL;
1380
1381 char DefaltPath[PQ_FILE_NAME_LENGTH]={0};
1382 char CustomerPath[PQ_FILE_NAME_LENGTH]={0};
1383 char IniPath[PQ_FILE_NAME_LENGTH]={0};
1384
1385 ///// SET PQ BIN PATH
1386 if(pPQResourcePrivate->stPQBin_Path.pm_PQ_DEFAULT_PATH[0] !=NULL) //Set DefaltPath
1387 {
1388 strncpy(DefaltPath,pPQResourcePrivate->stPQBin_Path.pm_PQ_DEFAULT_PATH,PQ_FILE_PATH_LENGTH);
1389 }
1390 else
1391 {
1392 strncpy(DefaltPath,DefaltPath_Ini,strlen(DefaltPath_Ini));
1393 }
1394
1395 if(pPQResourcePrivate->stPQBin_Path.pm_PQ_CUSTOMER_PATH[0] !=NULL) //Set CustomerPath
1396 {
1397 strncpy(CustomerPath,pPQResourcePrivate->stPQBin_Path.pm_PQ_CUSTOMER_PATH,PQ_FILE_PATH_LENGTH);
1398 }
1399 else
1400 {
1401 strncpy(CustomerPath,CustomerPath_Ini,strlen(CustomerPath_Ini));
1402 }
1403 if(pPQResourcePrivate->stPQBin_Path.pm_PQ_INI_PATH[0] !=NULL) //Set IniPath
1404 {
1405 strncpy(IniPath,pPQResourcePrivate->stPQBin_Path.pm_PQ_INI_PATH,PQ_FILE_PATH_LENGTH);
1406 }
1407
1408 struct file *pFile = NULL;
1409
1410 // if Main.bin exists in /Customer/pq, read it
1411 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1412 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1413 strncat(pm_PQBinFilePathName, MainBinName, strlen(MainBinName));
1414 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1415
1416 if(IS_ERR(pFile))
1417 {
1418 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1419 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
1420 strncat(pm_PQBinFilePathName, MainBinName, strlen(MainBinName));
1421 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1422 if(IS_ERR(pFile))
1423 {
1424 // read from default path
1425 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1426 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
1427 strncat(pm_PQBinFilePathName, MainBinName, strlen(MainBinName));
1428 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1429 }
1430 if(IS_ERR(pFile))
1431 {
1432 pFile = NULL;
1433 }
1434 else
1435 {
1436 filp_close(pFile, NULL);
1437 pFile = NULL;
1438 pu8MainBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1439 }
1440
1441 }
1442 else
1443 {
1444 // read from /Customer/pq
1445 filp_close(pFile, NULL);
1446 pFile = NULL;
1447 pu8MainBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1448 }
1449 printf( "Load PQ bin file, PQ_BIN_STD_MAIN path [%s]\n", pm_PQBinFilePathName);
1450
1451 // if Main_Ex.bin exists in /Customer/pq, read it
1452 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1453 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1454 strncat(pm_PQBinFilePathName, MainExBinName, strlen(MainExBinName));
1455 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1456 if(IS_ERR(pFile))
1457 {
1458 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1459 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
1460 strncat(pm_PQBinFilePathName, MainExBinName, strlen(MainExBinName));
1461 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1462 if(IS_ERR(pFile))
1463 {
1464 // read from default path
1465 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1466 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
1467 strncat(pm_PQBinFilePathName, MainExBinName, strlen(MainExBinName));
1468 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1469 }
1470 if(IS_ERR(pFile))
1471 {
1472 pFile = NULL;
1473 }
1474 else
1475 {
1476 filp_close(pFile, NULL);
1477 pFile = NULL;
1478 pu8MainExBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1479 }
1480 }
1481 else
1482 {
1483 // read from /Customer/pq
1484 filp_close(pFile, NULL);
1485 pFile = NULL;
1486 pu8MainExBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1487 }
1488
1489 if(pu8MainBuf && pu8MainExBuf)
1490 {
1491 printk("Load PQ bin file, PQ_BIN_EXT_MAIN path [%s]\n", pm_PQBinFilePathName);
1492
1493 pstPQInitInfo->u8PQBinCnt = 2;
1494 pstPQInitInfo->stPQBinInfo[0].u8PQID = (MS_U8) PQ_BIN_STD_MAIN;
1495 pstPQInitInfo->stPQBinInfo[0].PQBin_PhyAddr = (MS_PHYADDR) pu8MainBuf;
1496
1497 pstPQInitInfo->stPQBinInfo[1].u8PQID = (MS_U8) PQ_BIN_EXT_MAIN;
1498 pstPQInitInfo->stPQBinInfo[1].PQBin_PhyAddr = (MS_PHYADDR)pu8MainExBuf;
1499
1500 }
1501 else
1502 {
1503 printk("!! Error Load PQ bin file, PQ_BIN_EXT_MAIN path [%s]\n", pm_PQBinFilePathName);
1504 pstPQInitInfo->u8PQBinCnt = 0;
1505 }
1506
1507 MS_U8 *pu8MainCustomerBuf = NULL;
1508 pstPQInitInfo->u8PQBinCustomerCnt = 0 ;
1509 // if Main_Color.bin exists in /Customer/pq, read it
1510 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1511 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1512 strncat(pm_PQBinFilePathName, MainColorBinName, strlen(MainColorBinName));
1513 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1514 if(IS_ERR(pFile))
1515 {
1516 // read from default path
1517 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1518 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
1519 strncat(pm_PQBinFilePathName, MainColorBinName, strlen(MainColorBinName));
1520
1521 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1522 if (!IS_ERR(pFile))
1523 {
1524
1525 filp_close(pFile, NULL);
1526 pFile = NULL;
1527 pu8MainCustomerBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1528 }
1529 else
1530 {
1531 pFile = NULL;
1532 }
1533 }
1534 else
1535 {
1536 // read from /Customer/pq
1537 filp_close(pFile, NULL);
1538 pFile = NULL;
1539 pu8MainCustomerBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1540 }
1541
1542 if(pu8MainCustomerBuf)
1543 {
1544 printk("Load PQ bin file, PQ_BIN_CUSTOMER_MAIN path [%s]\n", pm_PQBinFilePathName);
1545 pstPQInitInfo->u8PQBinCustomerCnt = 1;
1546 pstPQInitInfo->stPQBinInfo[4].u8PQID = (MS_U8) PQ_BIN_CUSTOMER_MAIN;
1547 pstPQInitInfo->stPQBinInfo[4].PQBin_PhyAddr = (MS_PHYADDR) pu8MainCustomerBuf;
1548 }
1549 else
1550 {
1551 pstPQInitInfo->u8PQBinCustomerCnt = 0;
1552 printk( "!!Error Load PQ bin file, PQ_BIN_CUSTOMER_MAIN path [%s]\n", pm_PQBinFilePathName);
1553 }
1554
1555 //Skip USFC now, which may cause kernel panic, wait PQ Driver complated.
1556 MS_U8 *pu8UFSCBuf = NULL;
1557 pstPQInitInfo->u8PQBinUFSCCnt = 0;
1558 // if UFSC.bin exists in /Customer/pq, read it
1559 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1560 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1561 strncat(pm_PQBinFilePathName, UFSCBinName, strlen(UFSCBinName));
1562 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1563 if(IS_ERR(pFile))
1564 {
1565 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1566 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
1567 strncat(pm_PQBinFilePathName, UFSCBinName, strlen(UFSCBinName));
1568 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1569 if(IS_ERR(pFile))
1570 {
1571 // read from default path
1572 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1573 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
1574 strncat(pm_PQBinFilePathName, UFSCBinName, strlen(UFSCBinName));
1575 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1576 }
1577 if(IS_ERR(pFile))
1578 {
1579 pFile = NULL;
1580 }
1581 else
1582 {
1583 filp_close(pFile, NULL);
1584 pFile = NULL;
1585 pu8UFSCBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1586 }
1587 }
1588 else
1589 {
1590 // read from /Customer/pq
1591 filp_close(pFile, NULL);
1592 pFile = NULL;
1593 pu8UFSCBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1594 }
1595
1596 if(pu8UFSCBuf)
1597 {
1598 printk("Load PQ bin file, PQ_BIN_UFSC path [%s]\n", pm_PQBinFilePathName);
1599 pstPQInitInfo->u8PQBinUFSCCnt = 1;
1600 pstPQInitInfo->stPQBinInfo[6].u8PQID = (MS_U8) PQ_BIN_UFSC;
1601 pstPQInitInfo->stPQBinInfo[6].PQBin_PhyAddr = (MS_PHYADDR) pu8UFSCBuf;
1602 }
1603 else
1604 {
1605 //pstPQInitInfo->u8PQBinUFSCCnt = 0;
1606
1607 XC_INITMISC sXC_Init_Misc;
1608 memset(&sXC_Init_Misc, 0, sizeof(XC_INITMISC));
1609 MApi_XC_GetMISCStatus(&sXC_Init_Misc);
1610 sXC_Init_Misc.u32MISC_B |= E_XC_INIT_MISC_B_SKIP_SR;
1611 MApi_XC_Init_MISC(&sXC_Init_Misc, sizeof(XC_INITMISC));
1612 }
1613 #if (ENABLE_PQ_BIN_CF)
1614 MS_U8 *pu8MainCFBuf = NULL;
1615 pstPQInitInfo->u8PQBinCFCnt = 0;
1616 // if CF_MAIN.bin exists in /Customer/pq, read it
1617 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1618 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1619 strncat(pm_PQBinFilePathName, MainCFBinName, strlen(MainCFBinName));
1620 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1621 if(IS_ERR(pFile))
1622 {
1623 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1624 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
1625 strncat(pm_PQBinFilePathName, MainCFBinName, strlen(MainCFBinName));
1626 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1627 if(IS_ERR(pFile))
1628 {
1629 // read from default path
1630 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1631 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
1632 strncat(pm_PQBinFilePathName, MainCFBinName, strlen(MainCFBinName));
1633 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1634 }
1635 if(IS_ERR(pFile))
1636 {
1637 pFile = NULL;
1638 }
1639 else
1640 {
1641 filp_close(pFile, NULL);
1642 pFile = NULL;
1643 pu8MainCFBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1644 }
1645 }
1646 else
1647 {
1648 // read from /Customer/pq
1649 filp_close(pFile, NULL);
1650 pFile = NULL;
1651 pu8MainCFBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1652 }
1653
1654 if(pu8MainCFBuf)
1655 {
1656 printk("Load PQ bin file, PQ_BIN_CF_MAIN path [%s]\n", pm_PQBinFilePathName);
1657 pstPQInitInfo->u8PQBinCFCnt = 1;
1658 pstPQInitInfo->stPQBinInfo[7].u8PQID = (MS_U8) PQ_BIN_CF_MAIN;
1659 pstPQInitInfo->stPQBinInfo[7].PQBin_PhyAddr = (MS_PHYADDR) pu8MainCFBuf;
1660 }
1661 #endif
1662 if(MDrv_PQ_GetCaps(&stPQCaps))
1663 {
1664 if(stPQCaps.b3DVideo_Supported || stPQCaps.bPIP_Supported)
1665 {
1666 MS_U8 *pu8SubBuf = NULL, *pu8SubExBuf = NULL;
1667
1668 // check if Sub.bin exists in /Customer/pq/
1669 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1670 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1671 strncat(pm_PQBinFilePathName, SubBinName, strlen(SubBinName));
1672 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1673 if(IS_ERR(pFile))
1674 {
1675 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1676 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
1677 strncat(pm_PQBinFilePathName, SubBinName, strlen(SubBinName));
1678 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1679 if(IS_ERR(pFile))
1680 {
1681 // read from default path
1682 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1683 strncpy(pm_PQBinFilePathName,DefaltPath,strlen(DefaltPath));
1684 strncat(pm_PQBinFilePathName,SubBinName,strlen(SubBinName));
1685 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1686 }
1687 if(IS_ERR(pFile))
1688 {
1689 pFile = NULL;
1690 }
1691 else
1692 {
1693 filp_close(pFile, NULL);
1694 pFile = NULL;
1695 pu8SubBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1696 }
1697
1698 }
1699 else
1700 {
1701 // read from /Customer/pq
1702 filp_close(pFile, NULL);
1703 pFile = NULL;
1704 pu8SubBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1705 }
1706 printk("Load PQ bin file, PQ_BIN_STD_SUB path [%s]\n", pm_PQBinFilePathName);
1707
1708 // check if Sub_Ex.bin exists in /Customer/pq/
1709 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1710 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1711 strncat(pm_PQBinFilePathName, SubExBinName, strlen(SubExBinName));
1712 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1713 if(IS_ERR(pFile))
1714 {
1715 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1716 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
1717 strncat(pm_PQBinFilePathName, SubExBinName, strlen(SubExBinName));
1718 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1719 if(IS_ERR(pFile))
1720 {
1721 // read from default path
1722 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1723 strncpy(pm_PQBinFilePathName,DefaltPath,strlen(DefaltPath));
1724 strncat(pm_PQBinFilePathName,SubExBinName,strlen(SubExBinName));
1725 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1726 }
1727 if(IS_ERR(pFile))
1728 {
1729 pFile = NULL;
1730 }
1731 else
1732 {
1733 filp_close(pFile, NULL);
1734 pFile = NULL;
1735 pu8SubExBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1736 }
1737
1738 }
1739 else
1740 {
1741 // read from /Customer/pq
1742 filp_close(pFile, NULL);
1743 pFile = NULL;
1744 pu8SubExBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1745 }
1746 printf("Load PQ bin file, PQ_BIN_EXT_SUB path [%s]\n", pm_PQBinFilePathName);
1747
1748 if(pu8SubBuf && pu8SubExBuf)
1749 {
1750 pstPQInitInfo->u8PQBinCnt = 4;
1751 pstPQInitInfo->stPQBinInfo[2].u8PQID = (MS_U8) PQ_BIN_STD_SUB;
1752 pstPQInitInfo->stPQBinInfo[2].PQBin_PhyAddr = (MS_PHYADDR) pu8SubBuf;
1753 pstPQInitInfo->stPQBinInfo[3].u8PQID = (MS_U8) PQ_BIN_EXT_SUB;
1754 pstPQInitInfo->stPQBinInfo[3].PQBin_PhyAddr = (MS_PHYADDR)pu8SubExBuf;
1755 }
1756 else
1757 {
1758 pstPQInitInfo->u8PQBinCnt = 0;
1759 }
1760
1761 MS_U8 *pu8SubCustomerBuf = NULL;
1762 // check if Sub_Color.bin exists in /Customer/pq/
1763 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1764 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1765 strncat(pm_PQBinFilePathName, SubColorBinName, strlen(SubColorBinName));
1766 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1767 if(IS_ERR(pFile))
1768 {
1769 // read from default path
1770 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1771 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
1772 strncat(pm_PQBinFilePathName, SubColorBinName, strlen(SubColorBinName));
1773 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1774 if (!IS_ERR(pFile))
1775 {
1776 filp_close(pFile, NULL);
1777 pFile = NULL;
1778 pu8SubCustomerBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1779 }
1780 else
1781 {
1782 pFile = NULL;
1783 }
1784 }
1785 else
1786 {
1787 // read from /Customer/pq
1788 filp_close(pFile, NULL);
1789 pFile = NULL;
1790 pu8SubCustomerBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1791 }
1792
1793 if(pu8MainCustomerBuf && pu8SubCustomerBuf)
1794 {
1795 printk("Load PQ bin file, PQ_BIN_CUSTOMER_SUB path [%s]\n", pm_PQBinFilePathName);
1796 pstPQInitInfo->u8PQBinCustomerCnt = 2;
1797 pstPQInitInfo->stPQBinInfo[5].u8PQID = (MS_U8) PQ_BIN_CUSTOMER_SUB;
1798 pstPQInitInfo->stPQBinInfo[5].PQBin_PhyAddr = (MS_PHYADDR) pu8SubCustomerBuf;
1799 }
1800 else
1801 {
1802 pstPQInitInfo->u8PQBinCustomerCnt = 0;
1803 printf( " !!Error Load PQ bin file, PQ_BIN_CUSTOMER_MAIN path [%s]\n", pm_PQBinFilePathName);
1804 }
1805 }
1806 #if (ENABLE_PQ_BIN_CF)
1807 MS_U8 *pu8SubCFBuf = NULL;
1808 // if Sub_CF.bin exists in /Customer/pq, read it
1809 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1810 strncpy(pm_PQBinFilePathName, CustomerPath, strlen(CustomerPath));
1811 strncat(pm_PQBinFilePathName, SubCFBinName, strlen(SubCFBinName));
1812 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1813 if(IS_ERR(pFile))
1814 {
1815 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1816 strncpy(pm_PQBinFilePathName, IniPath, strlen(IniPath));
1817 strncat(pm_PQBinFilePathName, SubCFBinName, strlen(SubCFBinName));
1818 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1819 if(IS_ERR(pFile))
1820 {
1821 // read from default path
1822 memset(pm_PQBinFilePathName, 0, PQ_FILE_NAME_LENGTH);
1823 strncpy(pm_PQBinFilePathName, DefaltPath, strlen(DefaltPath));
1824 strncat(pm_PQBinFilePathName, SubCFBinName, strlen(SubCFBinName));
1825 pFile = filp_open(pm_PQBinFilePathName, O_RDONLY, 0);
1826 }
1827 if(IS_ERR(pFile))
1828 {
1829 pFile = NULL;
1830 }
1831 else
1832 {
1833 filp_close(pFile, NULL);
1834 pFile = NULL;
1835 pu8SubCFBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1836 }
1837 }
1838 else
1839 {
1840 // read from /Customer/pq
1841 filp_close(pFile, NULL);
1842 pFile = NULL;
1843 pu8SubCFBuf = Open_PQ_Bin((MS_U8 *)pm_PQBinFilePathName);
1844 }
1845
1846 if(pu8SubCFBuf)
1847 {
1848 printk("Load PQ bin file, PQ_BIN_CF_SUB path [%s]\n", pm_PQBinFilePathName);
1849 pstPQInitInfo->u8PQBinCFCnt = 2;
1850 pstPQInitInfo->stPQBinInfo[8].u8PQID = (MS_U8) PQ_BIN_CF_SUB;
1851 pstPQInitInfo->stPQBinInfo[8].PQBin_PhyAddr = (MS_PHYADDR) pu8SubCFBuf;
1852 }
1853 #endif
1854 }
1855 #else
1856 pstPQInitInfo->u8PQBinCnt = 0;
1857 pstPQInitInfo->u8PQTextBinCnt = 0;
1858 pstPQInitInfo->u8PQBinCustomerCnt = 0;
1859 pstPQInitInfo->u8PQBinUFSCCnt = 0;
1860 #if (ENABLE_PQ_BIN_CF)
1861 pstPQInitInfo->u8PQBinCFCnt = 0;
1862 #endif
1863 #endif
1864 }
1865 MDrv_PQ_Release_Semaphore(pInstance,E_PQ_POOL_ID_INTERNAL);
1866 }
1867 #endif
1868
MDrv_PQ_Init_U2(void * pInstance,MS_PQ_Init_Info * pstPQInitInfo)1869 void MDrv_PQ_Init_U2(void* pInstance,MS_PQ_Init_Info *pstPQInitInfo)
1870 {
1871 #if (defined(MSOS_TYPE_LINUX_KERNEL) && defined(UFO_XC_DS_PQ))
1872 if(MApi_XC_Is_SupportSWDS())
1873 {
1874 printf("Mdrv_PQ_Init for PQ-DS, ignore!\n");
1875 return;
1876 }
1877 #endif
1878
1879 #if (defined(MSOS_TYPE_LINUX_KERNEL))
1880 //Because _status.bIsInitialized is Global variable,
1881 //In linux kernel driver only one instance.
1882 //We must return here to avoid re-init write other global variable to init value
1883 if(_status.bIsInitialized == TRUE)
1884 {
1885 printk("_status.bIsInitialized %d, return.\033[0m\n",__FUNCTION__,__LINE__,_status.bIsInitialized);
1886 return;
1887 }
1888 #endif
1889
1890 PQTABLE_INFO PQTableInfo;
1891 MS_U8 i;
1892 MS_U8 u8ID;
1893
1894 _s32LastPQIPMADiMain = -1;
1895 _s32LastPQIPMemFormatMain = -1;
1896 _s32LastPQIPHSDYMain = -1;
1897 _s32LastPQIPHSDCMain = -1;
1898 _s32LastPQIPMADiSub = -1;
1899 _s32LastPQIPMemFormatSub = -1;
1900 _s32LastPQIPMADiMotMain = -1;
1901 _s32LastPQIPMADiMotSub = -1;
1902
1903 _bCustomerMainPQEn = FALSE ;
1904 _bCustomerSubPQEn = FALSE ;
1905 _bUFSCPQEn = FALSE;
1906 _u16LastPQSrcType[PQ_MAIN_WINDOW] = 0xFFFF;
1907 _u16LastPQSrcType[PQ_SUB_WINDOW] = 0xFFFF;
1908 _bNeedRestoreWRBankMappingNum = FALSE;
1909
1910 _PQ_Mutex = MsOS_CreateMutex(E_MSOS_FIFO, "_XC_Mutex", MSOS_PROCESS_SHARED);
1911
1912 if(_PQ_Mutex == -1)
1913 {
1914 (printf("[MAPI PQ][%06d] create mutex fail\n", __LINE__));
1915 return;
1916 }
1917
1918 #ifdef UFO_XC_PQ_SUPPORT_INITVAR_INTO_SHAREMEMORY
1919 PQ_INSTANCE_PRIVATE *psPQInstPri = NULL;
1920 UtopiaInstanceGetPrivate(pInstance, (void**)&psPQInstPri);
1921 PQ_RESOURCE_PRIVATE* pPQResourcePrivate = NULL;
1922 MDrv_PQ_Get_Semaphore(pInstance,E_PQ_POOL_ID_INTERNAL);
1923 UtopiaResourceGetPrivate(g_pPQResource[E_PQ_DEVICE_ID_0],(void**)(&pPQResourcePrivate));
1924
1925 memcpy(&pPQResourcePrivate->PQ_InitInfo, pstPQInitInfo, sizeof(MS_PQ_Init_Info));
1926
1927 MDrv_PQ_Release_Semaphore(pInstance,E_PQ_POOL_ID_INTERNAL);
1928 #endif
1929
1930 memset(&PQTableInfo, 0, sizeof(PQTableInfo));
1931
1932 #ifdef MSOS_TYPE_LINUX
1933 #if(ENABLE_PQ_MLOAD)
1934 PTH_PQ_RET_CHK(pthread_mutexattr_t attr);
1935 PTH_PQ_RET_CHK(pthread_mutexattr_init(&attr));
1936 PTH_PQ_RET_CHK(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE));
1937 PTH_PQ_RET_CHK(pthread_mutex_init(&_PQ_MLoad_Mutex, &attr));
1938 #endif
1939 #endif
1940
1941 _status.bIsInitialized = TRUE;
1942 _status.bIsRunning = TRUE;
1943
1944 _MDrv_PQ_LoadPQBin(pInstance,pstPQInitInfo);
1945
1946 //pstPQInitInfo->u8PQTextBinCnt = 0;
1947 if(pstPQInitInfo->u8PQTextBinCnt)
1948 {
1949 gbEnablePQTextBin = 1;
1950 for(i = 0; i < pstPQInitInfo->u8PQTextBinCnt; i++)
1951 {
1952 u8ID = pstPQInitInfo->stPQTextBinInfo[i].u8PQID;
1953 stPQTextBinHeaderInfo[u8ID].u8BinID = pstPQInitInfo->stPQTextBinInfo[i].u8PQID;
1954 #ifndef MSOS_TYPE_LINUX
1955 stPQTextBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQTextBinInfo[i].PQBin_PhyAddr);
1956 //This is just for NonOS , Linux kernel driver shouldn't in this case, so marked here.
1957 //stPQTextBinHeaderInfo[u8ID].u32BinStartAddress = MS_PA2KSEG0(pstPQInitInfo->stPQTextBinInfo[i].PQBin_PhyAddr);
1958 #else
1959 stPQTextBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQTextBinInfo[i].PQBin_PhyAddr);
1960 #endif
1961 MDrv_PQTextBin_Parsing(pInstance,&stPQTextBinHeaderInfo[u8ID]);
1962 }
1963 }
1964 else
1965 {
1966 //printf("NonPQBin_Text !!\n");
1967 gbEnablePQTextBin = 0;
1968 }
1969 //pstPQInitInfo->u8PQBinCnt = 0;
1970 if(pstPQInitInfo->u8PQBinCnt)
1971 {
1972 gbPQBinEnable = 1;
1973 MDrv_PQ_Init_DisplayType_U2(pInstance, pstPQInitInfo->u16PnlWidth, PQ_BIN_DISPLAY_ONE);
1974 //because main and sub's common table may be different,
1975 //so we will take main's common table as correct one.
1976 //so here load sub first and then use main's overwrite sub's
1977 //Sub first
1978 for(i = 2; i < pstPQInitInfo->u8PQBinCnt; i++)
1979 {
1980 u8ID = pstPQInitInfo->stPQBinInfo[i].u8PQID;
1981 stPQBinHeaderInfo[u8ID].u8BinID = (MS_U8)pstPQInitInfo->stPQBinInfo[i].u8PQID;
1982 #ifndef MSOS_TYPE_LINUX
1983 stPQBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQBinInfo[i].PQBin_PhyAddr);
1984 //stPQBinHeaderInfo[u8ID].u32BinStartAddress = MS_PA2KSEG0(pstPQInitInfo->stPQBinInfo[i].PQBin_PhyAddr);
1985 #else
1986 stPQBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQBinInfo[i].PQBin_PhyAddr);
1987 #endif
1988 MDrv_PQBin_Parsing(pInstance,&stPQBinHeaderInfo[u8ID]);
1989 #if (defined(UFO_XC_DS_PQ))
1990 if(!MApi_XC_Is_SupportSWDS())
1991 {
1992 #endif
1993 MDrv_PQBin_LoadCommTable(pInstance,MDrv_PQBin_GetPanelIdx(pInstance), &stPQBinHeaderInfo[u8ID]);
1994 #if (defined(UFO_XC_DS_PQ))
1995 }
1996 #endif
1997 }
1998
1999 if(pstPQInitInfo->u8PQBinCustomerCnt == 2)
2000 {
2001 u8ID = pstPQInitInfo->stPQBinInfo[5].u8PQID;
2002 stPQBinHeaderInfo[u8ID].u8BinID = (MS_U8)pstPQInitInfo->stPQBinInfo[5].u8PQID;
2003 #ifndef MSOS_TYPE_LINUX
2004 stPQBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQBinInfo[5].PQBin_PhyAddr);
2005 // stPQBinHeaderInfo[u8ID].u32BinStartAddress = MS_PA2KSEG0(pstPQInitInfo->stPQBinInfo[5].PQBin_PhyAddr);
2006 #else
2007 stPQBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQBinInfo[5].PQBin_PhyAddr);
2008 #endif
2009 MDrv_PQBin_Parsing(pInstance,&stPQBinHeaderInfo[u8ID]);
2010 #if (defined(UFO_XC_DS_PQ))
2011 if(!MApi_XC_Is_SupportSWDS())
2012 {
2013 #endif
2014 MDrv_PQBin_LoadCommTable(pInstance,PQ_BIN_CUSTOMER_PANEL_INDEX, &stPQBinHeaderInfo[u8ID]);
2015 #if (defined(UFO_XC_DS_PQ))
2016 }
2017 #endif
2018 _bCustomerSubPQEn = TRUE ;
2019 }
2020
2021
2022 //Main second
2023 for(i = 0; i < ((pstPQInitInfo->u8PQBinCnt <= 2) ? pstPQInitInfo->u8PQBinCnt : 2); i++)
2024 {
2025 u8ID = pstPQInitInfo->stPQBinInfo[i].u8PQID;
2026 stPQBinHeaderInfo[u8ID].u8BinID = (MS_U8)pstPQInitInfo->stPQBinInfo[i].u8PQID;
2027 #ifndef MSOS_TYPE_LINUX
2028 stPQBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQBinInfo[i].PQBin_PhyAddr);
2029 // stPQBinHeaderInfo[u8ID].u32BinStartAddress = MS_PA2KSEG0(pstPQInitInfo->stPQBinInfo[i].PQBin_PhyAddr);
2030 #else
2031 stPQBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQBinInfo[i].PQBin_PhyAddr);
2032 #endif
2033 MDrv_PQBin_Parsing(pInstance,&stPQBinHeaderInfo[u8ID]);
2034 #if (defined(UFO_XC_DS_PQ))
2035 if(!MApi_XC_Is_SupportSWDS())
2036 {
2037 #endif
2038 MDrv_PQBin_LoadCommTable(pInstance,MDrv_PQBin_GetPanelIdx(pInstance), &stPQBinHeaderInfo[u8ID]);
2039 #if (defined(UFO_XC_DS_PQ))
2040 }
2041 #endif
2042 }
2043
2044 if(pstPQInitInfo->u8PQBinCustomerCnt >= 1)
2045 {
2046 u8ID = pstPQInitInfo->stPQBinInfo[4].u8PQID;
2047 stPQBinHeaderInfo[u8ID].u8BinID = (MS_U8)pstPQInitInfo->stPQBinInfo[4].u8PQID;
2048 #ifndef MSOS_TYPE_LINUX
2049 stPQBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQBinInfo[4].PQBin_PhyAddr);
2050 //stPQBinHeaderInfo[u8ID].u32BinStartAddress = MS_PA2KSEG0(pstPQInitInfo->stPQBinInfo[4].PQBin_PhyAddr);
2051 #else
2052 stPQBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQBinInfo[4].PQBin_PhyAddr);
2053 #endif
2054 MDrv_PQBin_Parsing(pInstance,&stPQBinHeaderInfo[u8ID]);
2055 #if (defined(UFO_XC_DS_PQ))
2056 if(!MApi_XC_Is_SupportSWDS())
2057 {
2058 #endif
2059 MDrv_PQBin_LoadCommTable(pInstance,PQ_BIN_CUSTOMER_PANEL_INDEX, &stPQBinHeaderInfo[u8ID]);
2060 #if (defined(UFO_XC_DS_PQ))
2061 }
2062 #endif
2063 _bCustomerMainPQEn = TRUE ;
2064 }
2065
2066 //UFSC
2067 if(pstPQInitInfo->u8PQBinUFSCCnt == 1)
2068 {
2069 u8ID = pstPQInitInfo->stPQBinInfo[6].u8PQID;
2070 stPQBinHeaderInfo[u8ID].u8BinID = (MS_U8)pstPQInitInfo->stPQBinInfo[6].u8PQID;
2071 #ifndef MSOS_TYPE_LINUX
2072 stPQBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQBinInfo[6].PQBin_PhyAddr);
2073 //stPQBinHeaderInfo[u8ID].u32BinStartAddress = MS_PA2KSEG0(pstPQInitInfo->stPQBinInfo[6].PQBin_PhyAddr);
2074 #else
2075 stPQBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQBinInfo[6].PQBin_PhyAddr);
2076 #endif
2077 MDrv_PQBin_Parsing(pInstance, &stPQBinHeaderInfo[u8ID]);
2078 #if (defined(UFO_XC_DS_PQ))
2079 if(!MApi_XC_Is_SupportSWDS())
2080 {
2081 #endif
2082 MDrv_PQBin_LoadCommTable(pInstance, PQ_BIN_UFSC_PANEL_INDEX, &stPQBinHeaderInfo[u8ID]);
2083 #if (defined(UFO_XC_DS_PQ))
2084 }
2085 #endif
2086
2087 _bUFSCPQEn = TRUE ;
2088 }
2089 #if (ENABLE_PQ_BIN_CF)
2090 //CF
2091 if(pstPQInitInfo->u8PQBinCFCnt >= 1)
2092 {
2093 _bCFMainPQEn = TRUE ;
2094
2095 if(pstPQInitInfo->u8PQBinCFCnt > 1)
2096 _bCFSubPQEn = TRUE ;
2097
2098 for(i = 7; i < ((pstPQInitInfo->u8PQBinCFCnt <= 2) ? 7+pstPQInitInfo->u8PQBinCFCnt : 9); i++)
2099 {
2100 u8ID = pstPQInitInfo->stPQBinInfo[i].u8PQID;
2101 stPQBinHeaderInfo[u8ID].u8BinID = (MS_U8)pstPQInitInfo->stPQBinInfo[i].u8PQID;
2102 #ifndef MSOS_TYPE_LINUX
2103 stPQBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQBinInfo[i].PQBin_PhyAddr);
2104 //stPQBinHeaderInfo[u8ID].u32BinStartAddress = MS_PA2KSEG0(pstPQInitInfo->stPQBinInfo[i].PQBin_PhyAddr);
2105 #else
2106 stPQBinHeaderInfo[u8ID].u32BinStartAddress = /*MS_PA2KSEG0*/(pstPQInitInfo->stPQBinInfo[i].PQBin_PhyAddr);
2107 #endif
2108 MDrv_PQBin_Parsing(pInstance,&stPQBinHeaderInfo[u8ID]);
2109 #if (defined(UFO_XC_DS_PQ))
2110 if(!MApi_XC_Is_SupportSWDS())
2111 {
2112 #endif
2113 MDrv_PQBin_LoadCommTable(pInstance,PQ_BIN_CF_PANEL_INDEX, &stPQBinHeaderInfo[u8ID]);
2114 #if (defined(UFO_XC_DS_PQ))
2115 }
2116 #endif
2117
2118 }
2119 }
2120 #endif
2121 }
2122 else
2123 {
2124 //printf("NonPQBin !! \n");
2125 gbPQBinEnable = 0;
2126 MDrv_PQ_Init_DisplayType_U2(pInstance, pstPQInitInfo->u16PnlWidth, PQ_DISPLAY_ONE);
2127
2128 #if(ENABLE_PQ_LOAD_TABLE_INFO)
2129 MDrv_PQ_PreInitLoadTableInfo(MAIN,pInstance);
2130 MDrv_PQ_PreInitLoadTableInfo(MAINEX,pInstance);
2131
2132 #if PQ_ENABLE_PIP
2133 MDrv_PQ_PreInitLoadTableInfo(SUB,pInstance);
2134 MDrv_PQ_PreInitLoadTableInfo(SUBEX,pInstance);
2135 #endif
2136
2137 #endif
2138 }
2139 #if PQ_ENABLE_PIP
2140 //dump sub c_sram3, c_sram4 to avoid garbage when enable pip, add these two into skip rule
2141 #if (defined(UFO_XC_DS_PQ))
2142 if(!MApi_XC_Is_SupportSWDS())
2143 {
2144 #endif
2145
2146 #ifdef PQ_PIP_C_SRAM_HW_WITH_SAME_INTERFACE
2147 //If 4 c_sram with sram read/write interface(HW artitecture)
2148 //We can not write c_sram1 when c_sram3 is reading(using)
2149 //HW suggest load all c_sram when PQ initialize
2150 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_C_SRAM1_C121_Main, PQ_IP_C_SRAM1_Main);
2151 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_C_SRAM2_C2121_Main, PQ_IP_C_SRAM2_Main);
2152 #endif
2153 MDrv_PQ_LoadTable_U2(pInstance,PQ_SUB_WINDOW, PQ_IP_C_SRAM3_C121_Sub, PQ_IP_C_SRAM3_Sub);
2154 MDrv_PQ_LoadTable_U2(pInstance,PQ_SUB_WINDOW, PQ_IP_C_SRAM4_C2121_Sub, PQ_IP_C_SRAM4_Sub);
2155 #if (defined(UFO_XC_DS_PQ))
2156 }
2157 #endif
2158 #endif
2159
2160
2161 #if 1
2162 // Set BK12 [40] [1:0] = b'11 to enable hw double buffer write
2163 // at blanking area for changing memory format by L_BK_SCMI(0x02)
2164 // this register is added after T2 U04
2165 Hal_PQ_set_memfmt_doublebuffer(pInstance,ENABLE);
2166
2167 memcpy(&_stPQ_Info, pstPQInitInfo, sizeof(MS_PQ_Init_Info));
2168
2169 memset(&bw_info, 0x00, sizeof(bw_info));
2170 bw_info.bDDR2 = pstPQInitInfo->bDDR2;
2171 bw_info.u32DDRFreq = pstPQInitInfo->u32DDRFreq;
2172 bw_info.u8BusWidth = pstPQInitInfo->u8BusWidth;
2173 bw_info.u16output_vtotal = pstPQInitInfo->u16Pnl_vtotal;
2174 bw_info.u16output_hsize = pstPQInitInfo->u16PnlWidth;
2175 bw_info.u16OSD_hsize = pstPQInitInfo->u16OSD_hsize;
2176 bw_info.u32Miu0MemSize = pstPQInitInfo->u32miu0em_size;
2177 bw_info.u32Miu1MemSize = pstPQInitInfo->u32miu1em_size;
2178
2179 for(i = 0; i < PQ_MAX_WINDOW; i++)
2180 {
2181 _bColorRange0_255[i] = TRUE;
2182 _bGameModeOn[i] = FALSE;
2183 _u8RWmappingNum[i] = 0;
2184 _bRWNumIsReset[i] = TRUE;
2185 _u16PQSuggestedFrameNum[i] = 0;
2186 }
2187 #endif
2188 #if 0//defined(ANDROID) && defined(UFO_XC_DS_PQ)
2189 if(MApi_XC_Is_SupportSWDS())
2190 {
2191 //PQ_Function_Info* function_Info = NULL;
2192 PQ_Function_Info function_Info;
2193 memset(&function_Info, 0, sizeof(function_Info));
2194 MS_U32 u32InitDataLen = 0;
2195 function_Info.pq_deside_srctype = MDrv_PQ_DesideSrcType;
2196 //function_Info.pq_disable_filmmode = MDrv_PQ_DisableFilmMode;
2197 function_Info.pq_load_scalingtable = MDrv_PQ_LoadScalingTable;
2198 //function_Info.pq_set_420upsampling = MDrv_PQ_Set420upsampling;
2199 //function_Info.pq_set_csc = MDrv_PQ_SetCSC;
2200 //function_Info.pq_set_memformat = MDrv_PQ_SetMemFormat;
2201 function_Info.pq_set_modeInfo = MDrv_PQ_Set_ModeInfo;
2202 function_Info.pq_get_memyuvfmt = MDrv_PQ_Get_MemYUVFmt;
2203 #if(PQ_ENABLE_IOCTL)
2204 //function_Info.pq_ioctl = MDrv_PQ_IOCTL;
2205 #endif
2206 MApi_XC_PQ_LoadFunction(&function_Info, u32InitDataLen);
2207 }
2208 #endif
2209
2210
2211
2212 }
2213 #if (defined (ANDROID) && defined (UFO_XC_DS_PQ))
2214 extern void* pu32XCInst;
2215 #endif
MDrv_PQ_Init(MS_PQ_Init_Info * pstPQInitInfo)2216 void MDrv_PQ_Init(MS_PQ_Init_Info *pstPQInitInfo)
2217 {
2218 #ifdef TRACE_DBG
2219 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2220 //return;
2221 #endif
2222 #if (defined (ANDROID) && defined (UFO_XC_DS_PQ))
2223 if (pu32XCInst == NULL)
2224 {
2225 if(UtopiaOpen(MODULE_XC, &pu32XCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2226 {
2227 printf("UtopiaOpen XC failed\n");
2228 return;
2229 }
2230 }
2231 static XC_INITMISC tmp_Init_Misc;
2232 stXC_GET_MISC_STATUS XCArgs1;
2233 XCArgs1.pXC_Init_Misc = &tmp_Init_Misc;
2234 XCArgs1.eReturnValue = E_APIXC_RET_FAIL;
2235
2236 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_MISC_STATUS, (void*)&XCArgs1) != UTOPIA_STATUS_SUCCESS)
2237 {
2238 printf("Obtain XC engine fail\n");
2239 return;
2240 }
2241
2242 if(!(tmp_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_IS_ANDROID))
2243 {
2244 tmp_Init_Misc.u32MISC_A |= E_XC_INIT_MISC_A_IS_ANDROID;
2245
2246 stXC_INIT_MISC XCArgs2;
2247 XCArgs2.pXC_Init_Misc = &tmp_Init_Misc;
2248 XCArgs2.u32InitMiscDataLen = sizeof(XC_INITMISC);
2249 XCArgs2.eReturnValue = E_APIXC_RET_FAIL;
2250
2251 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_INIT_MISC, (void*)&XCArgs2) != UTOPIA_STATUS_SUCCESS)
2252 {
2253 printf("Obtain XC engine fail\n");
2254 return;
2255 }
2256 }
2257 #endif
2258 if (pu32PQInst == NULL)
2259 {
2260 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2261 {
2262 printf("UtopiaOpen PQ failed\n");
2263 return ;
2264 }
2265 printf("\33[1;33m[MARCOS](%s %d) OPEN FINE\33[m\n", __FUNCTION__, __LINE__);
2266 }
2267
2268 stPQ_INIT PQArgs;
2269 PQArgs.pstPQInitInfo = pstPQInitInfo;
2270
2271 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_INIT, (void*)&PQArgs) != 0)
2272 {
2273 printf("Obtain PQ engine fail\n");
2274 return ;
2275 }
2276 else
2277 {
2278 #if (defined (ANDROID) && defined (UFO_XC_DS_PQ))
2279 stXC_GET_MISC_STATUS XCArgs3;
2280 XCArgs3.pXC_Init_Misc = &tmp_Init_Misc;
2281 XCArgs3.eReturnValue = E_APIXC_RET_FAIL;
2282
2283 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_MISC_STATUS, (void*)&XCArgs3) != UTOPIA_STATUS_SUCCESS)
2284 {
2285 printf("Obtain XC engine fail\n");
2286 return;
2287 }
2288
2289 if(tmp_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_IS_ANDROID)
2290 {
2291 tmp_Init_Misc.u32MISC_A = tmp_Init_Misc.u32MISC_A & (~E_XC_INIT_MISC_A_IS_ANDROID);
2292 stXC_INIT_MISC XCArgs4;
2293 XCArgs4.pXC_Init_Misc = &tmp_Init_Misc;
2294 XCArgs4.u32InitMiscDataLen = sizeof(XC_INITMISC);
2295 XCArgs4.eReturnValue = E_APIXC_RET_FAIL;
2296
2297 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_INIT_MISC, (void*)&XCArgs4) != UTOPIA_STATUS_SUCCESS)
2298 {
2299 printf("Obtain XC engine fail\n");
2300 return;
2301 }
2302 }
2303 #endif
2304 return ;
2305 }
2306 }
2307
MDrv_PQ_GetConfig_U2(void * pInstance,MS_PQ_Init_Info * pstPQInitInfo)2308 MS_BOOL MDrv_PQ_GetConfig_U2(void* pInstance, MS_PQ_Init_Info *pstPQInitInfo)
2309 {
2310 #ifdef UFO_XC_PQ_SUPPORT_INITVAR_INTO_SHAREMEMORY
2311 PQ_INSTANCE_PRIVATE *psPQInstPri = NULL;
2312 UtopiaInstanceGetPrivate(pInstance, (void**)&psPQInstPri);
2313 PQ_RESOURCE_PRIVATE* pPQResourcePrivate = NULL;
2314 if(_status.bIsInitialized == TRUE)
2315 {
2316 MDrv_PQ_Get_Semaphore(pInstance,E_PQ_POOL_ID_INTERNAL);
2317 UtopiaResourceGetPrivate(g_pPQResource[E_PQ_DEVICE_ID_0],(void**)(&pPQResourcePrivate));
2318
2319 memcpy(pstPQInitInfo, &pPQResourcePrivate->PQ_InitInfo, sizeof(MS_PQ_Init_Info));
2320
2321 MDrv_PQ_Release_Semaphore(pInstance,E_PQ_POOL_ID_INTERNAL);
2322
2323 return E_PQ_RET_OK;
2324 }
2325 else
2326 {
2327 return E_PQ_RET_FAIL;
2328 }
2329 #else
2330 return E_PQ_RET_FAIL;
2331 #endif
2332 }
2333
MDrv_PQ_GetConfig(MS_PQ_Init_Info * pstPQInitInfo)2334 MS_BOOL MDrv_PQ_GetConfig(MS_PQ_Init_Info *pstPQInitInfo)
2335 {
2336 if (pu32PQInst == NULL)
2337 {
2338 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2339 {
2340 printf("UtopiaOpen PQ failed\n");
2341 return FALSE;
2342 }
2343 }
2344
2345 stPQ_GetConfig PQArgs;
2346 PQArgs.pstPQInitInfo = pstPQInitInfo;
2347 PQArgs.eRet = E_PQ_RET_FAIL;
2348
2349 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GETCONFIG, (void*)&PQArgs) != 0)
2350 {
2351 printf("PQ engine GET_CONFIG Ioctl fail\n");
2352 return E_PQ_RET_FAIL;
2353 }
2354
2355 if(E_PQ_RET_OK == PQArgs.eRet)
2356 {
2357 return TRUE;
2358 }
2359 else
2360 {
2361 return FALSE;
2362 }
2363 }
2364
MDrv_PQ_Exit_U2(void * pInstance)2365 MS_BOOL MDrv_PQ_Exit_U2(void* pInstance)
2366 {
2367 return true;
2368 }
MDrv_PQ_Exit(void)2369 MS_BOOL MDrv_PQ_Exit(void)
2370 {
2371 #ifdef TRACE_DBG
2372 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2373 #endif
2374 if (pu32PQInst == NULL)
2375 {
2376 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2377 return FALSE;
2378 }
2379
2380 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_EXIT, NULL) != 0)
2381 {
2382 printf("Obtain PQ engine fail\n");
2383 return FALSE;
2384 }
2385 else
2386 {
2387 return TRUE;
2388 }
2389 }
2390
2391 static const MS_S16 S16DACColorCorrectionMatrix[32] =
2392 {
2393 0x0400, 0x0000, 0x0000, 0x0000, 0x0400, 0x0000, 0x0000, 0x0000,
2394 0x0400, -0x02E6, 0x0288, -0x05BB, 0x07A4, -0x062C, 0x06F3, -0x073C,
2395 -0x0024, 0x01BF, 0x07EF, -0x0116, 0x01EE, 0x052C, -0x03BB, 0x00B1,
2396 -0x0831, 0x0100, -0x0000, 0x0000, -0x0000, 0x0000, 0x0000, 0x0000,
2397 };
2398
MDrv_PQ_SetPowerState_U2(void * pInstance,EN_POWER_MODE enPowerState)2399 MS_U32 MDrv_PQ_SetPowerState_U2(void* pInstance,EN_POWER_MODE enPowerState)
2400 {
2401 MS_U32 u32Ret = E_PQ_RET_FAIL;
2402 MS_U8 i = 0;
2403 MS_U8 u8ID = 0;
2404
2405 if (enPowerState == E_POWER_SUSPEND)
2406 {
2407 MDrv_PQ_Str_Reset_Sram_Table(MAIN,pInstance);
2408 _enPrevPowerState = enPowerState;
2409 SC_BK_RESTORE_MUTEX; //while STR,PQ get chacne to lock mutex without return it. THerefore, force return before suspend.
2410 u32Ret = E_PQ_RET_OK;
2411 }
2412 else if (enPowerState == E_POWER_RESUME)
2413 {
2414 _enPrevPowerState = enPowerState;
2415
2416 _s32LastPQIPMADiMain = -1;
2417 _s32LastPQIPMemFormatMain = -1;
2418 _s32LastPQIPHSDYMain = -1;
2419 _s32LastPQIPHSDCMain = -1;
2420 _s32LastPQIPMADiSub = -1;
2421 _s32LastPQIPMemFormatSub = -1;
2422 _s32LastPQIPMADiMotMain = -1;
2423 _s32LastPQIPMADiMotSub = -1;
2424
2425 _u16LastPQSrcType[PQ_MAIN_WINDOW] = 0xFFFF;
2426 _u16LastPQSrcType[PQ_SUB_WINDOW] = 0xFFFF;
2427
2428 if(_stPQ_Info.u8PQBinCnt)
2429 {
2430 //Sub first
2431 for(i = 2; i < _stPQ_Info.u8PQBinCnt; i++)
2432 {
2433 u8ID = _stPQ_Info.stPQBinInfo[i].u8PQID;
2434 MDrv_PQBin_LoadCommTable(pInstance,MDrv_PQBin_GetPanelIdx(pInstance), &stPQBinHeaderInfo[u8ID]);
2435 }
2436 if(_stPQ_Info.u8PQBinCustomerCnt == 2)
2437 {
2438 u8ID = _stPQ_Info.stPQBinInfo[5].u8PQID;
2439 MDrv_PQBin_LoadCommTable(pInstance,PQ_BIN_CUSTOMER_PANEL_INDEX, &stPQBinHeaderInfo[u8ID]);
2440 }
2441
2442 //Main second
2443 for(i = 0; i < ((_stPQ_Info.u8PQBinCnt <= 2) ? _stPQ_Info.u8PQBinCnt : 2); i++)
2444 {
2445 u8ID = _stPQ_Info.stPQBinInfo[i].u8PQID;
2446 MDrv_PQBin_LoadCommTable(pInstance,MDrv_PQBin_GetPanelIdx(pInstance), &stPQBinHeaderInfo[u8ID]);
2447 }
2448
2449 if(_stPQ_Info.u8PQBinCustomerCnt >= 1)
2450 {
2451 u8ID = _stPQ_Info.stPQBinInfo[4].u8PQID;
2452 MDrv_PQBin_LoadCommTable(pInstance,PQ_BIN_CUSTOMER_PANEL_INDEX, &stPQBinHeaderInfo[u8ID]);
2453 }
2454
2455 //UFSC
2456 if(_stPQ_Info.u8PQBinUFSCCnt == 1)
2457 {
2458 u8ID = _stPQ_Info.stPQBinInfo[6].u8PQID;
2459 MDrv_PQBin_LoadCommTable(pInstance, PQ_BIN_UFSC_PANEL_INDEX, &stPQBinHeaderInfo[u8ID]);
2460 }
2461 }
2462 else
2463 {
2464 #if PQ_ENABLE_PIP
2465 MDrv_PQ_LoadCommTable_(SUB,pInstance);
2466 #if (ENABLE_PQ_EX)
2467 MDrv_PQ_LoadCommTable_(SUBEX,pInstance);
2468 #endif
2469 #endif
2470 MDrv_PQ_LoadCommTable_(MAIN,pInstance);
2471 #if (ENABLE_PQ_EX)
2472 MDrv_PQ_LoadCommTable_(MAINEX,pInstance);
2473 #endif
2474 }
2475
2476 #if PQ_ENABLE_PIP
2477 //dump sub c_sram3, c_sram4 to avoid garbage when enable pip, add these two into skip rule
2478 MDrv_PQ_LoadTable_U2(pInstance,PQ_SUB_WINDOW, PQ_IP_C_SRAM3_C121_Sub, PQ_IP_C_SRAM3_Sub);
2479 MDrv_PQ_LoadTable_U2(pInstance,PQ_SUB_WINDOW, PQ_IP_C_SRAM4_C2121_Sub, PQ_IP_C_SRAM4_Sub);
2480 #endif
2481
2482 // Set BK12 [40] [1:0] = b'11 to enable hw double buffer write
2483 // at blanking area for changing memory format by L_BK_SCMI(0x02)
2484 // this register is added after T2 U04
2485 Hal_PQ_set_memfmt_doublebuffer(pInstance,ENABLE);
2486
2487 //common bw table
2488 MDrv_BW_LoadInitTable();
2489 u32Ret = E_PQ_RET_OK;
2490 }
2491 else
2492 {
2493 printf("[%s,%5d]Do Nothing: %u\n",__FUNCTION__,__LINE__,enPowerState);
2494 u32Ret = E_PQ_RET_FAIL;
2495 }
2496 return u32Ret;
2497 }
2498
MDrv_PQ_SetPowerState(EN_POWER_MODE enPowerState)2499 MS_U32 MDrv_PQ_SetPowerState(EN_POWER_MODE enPowerState)
2500 {
2501 #ifdef TRACE_DBG
2502 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2503 #endif
2504 if (pu32PQInst == NULL)
2505 {
2506 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2507 return FALSE;
2508 }
2509
2510 stPQ_SetPowerState PQArgs;
2511 PQArgs.enPowerState = enPowerState;
2512 PQArgs.u32Ret = 0;
2513 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_POWER_STATE, (void*)&PQArgs) != 0)
2514 {
2515 printf("Obtain PQ engine fail\n");
2516 return 0;
2517 }
2518 else
2519 {
2520 return PQArgs.u32Ret;
2521 }
2522 }
2523
MDrv_PQ_GetIPNum_U2(void * pInstance,PQ_WIN eWindow)2524 MS_U16 MDrv_PQ_GetIPNum_U2(void* pInstance,PQ_WIN eWindow)
2525 {
2526 if(eWindow == PQ_MAIN_WINDOW)
2527 {
2528 if(gbPQBinEnable)
2529 {
2530 return MDrv_PQBin_GetIPNum(pInstance,&stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
2531 }
2532 else
2533 {
2534 return MDrv_PQ_GetIPNum_(MAIN,pInstance);
2535 }
2536 }
2537
2538 #if (PQ_ENABLE_PIP)
2539 if(eWindow == PQ_SUB_WINDOW)
2540 {
2541 if(gbPQBinEnable)
2542 {
2543 return MDrv_PQBin_GetIPNum(pInstance,&stPQBinHeaderInfo[PQ_BIN_STD_SUB]);
2544 }
2545 else
2546 {
2547 return MDrv_PQ_GetIPNum_(SUB,pInstance);
2548 }
2549 }
2550 #endif
2551
2552 else
2553 {
2554 MS_ASSERT(0);
2555 return 0xFFFF;
2556 }
2557 }
MDrv_PQ_GetIPNum(PQ_WIN eWindow)2558 MS_U16 MDrv_PQ_GetIPNum(PQ_WIN eWindow)
2559 {
2560 #ifdef TRACE_DBG
2561 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2562 #endif
2563 if (pu32PQInst == NULL)
2564 {
2565 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2566 return FALSE;
2567 }
2568
2569 stPQ_GetIPNum PQArgs;
2570 PQArgs.eWindow = eWindow;
2571 PQArgs.u16Ret = 0;
2572 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_IP_NUM, (void*)&PQArgs) != 0)
2573 {
2574 printf("Obtain PQ engine fail\n");
2575 return 0;
2576 }
2577 else
2578 {
2579 return PQArgs.u16Ret;
2580 }
2581 }
2582
MDrv_PQ_GetTableNum_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16PQIPIdx)2583 MS_U16 MDrv_PQ_GetTableNum_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16PQIPIdx)
2584 {
2585 if(eWindow == PQ_MAIN_WINDOW)
2586 {
2587 if(gbPQBinEnable)
2588 {
2589 return MDrv_PQBin_GetTableNum(pInstance,u16PQIPIdx, &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
2590 }
2591 else
2592 {
2593 return MDrv_PQ_GetTableNum_(MAIN,pInstance, (MS_U8)u16PQIPIdx);
2594 }
2595 }
2596 #if (PQ_ENABLE_PIP)
2597 if(eWindow == PQ_SUB_WINDOW)
2598 {
2599 if(gbPQBinEnable)
2600 {
2601 return MDrv_PQBin_GetTableNum(pInstance,u16PQIPIdx, &stPQBinHeaderInfo[PQ_BIN_STD_SUB]);
2602 }
2603 else
2604 {
2605 return MDrv_PQ_GetTableNum_(SUB,pInstance, (MS_U8)u16PQIPIdx);
2606 }
2607 }
2608 #endif
2609 else
2610 {
2611 MS_ASSERT(0);
2612 return 0xFFFF;
2613 }
2614 }
MDrv_PQ_GetTableNum(PQ_WIN eWindow,MS_U16 u16PQIPIdx)2615 MS_U16 MDrv_PQ_GetTableNum(PQ_WIN eWindow, MS_U16 u16PQIPIdx)
2616 {
2617 #ifdef TRACE_DBG
2618 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2619 #endif
2620 if (pu32PQInst == NULL)
2621 {
2622 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2623 return FALSE;
2624 }
2625
2626 stPQ_GetTableNum PQArgs;
2627 PQArgs.eWindow = eWindow;
2628 PQArgs.u16PQIPIdx = u16PQIPIdx;
2629 PQArgs.u16Ret = 0;
2630 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_TABLE_NUM, (void*)&PQArgs) != 0)
2631 {
2632 printf("Obtain PQ engine fail\n");
2633 return 0;
2634 }
2635 else
2636 {
2637 return PQArgs.u16Ret;
2638 }
2639 }
2640
MDrv_PQ_GetCurrentTableIndex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16PQIPIdx)2641 MS_U16 MDrv_PQ_GetCurrentTableIndex_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16PQIPIdx)
2642 {
2643 if(eWindow == PQ_MAIN_WINDOW)
2644 {
2645 if(gbPQBinEnable)
2646 {
2647 return MDrv_PQBin_GetCurrentTableIndex(pInstance,MDrv_PQBin_GetPanelIdx(pInstance), u16PQIPIdx);
2648 }
2649 else
2650 {
2651 return MDrv_PQ_GetCurrentTableIndex_(MAIN,pInstance, (MS_U8)u16PQIPIdx);
2652 }
2653 }
2654 #if (PQ_ENABLE_PIP)
2655 if(eWindow == PQ_SUB_WINDOW)
2656 {
2657 if(gbPQBinEnable)
2658 {
2659 return MDrv_PQBin_GetCurrentTableIndex(pInstance,MDrv_PQBin_GetPanelIdx(pInstance), u16PQIPIdx);
2660 }
2661 else
2662 {
2663 return MDrv_PQ_GetCurrentTableIndex_(SUB,pInstance, (MS_U8)u16PQIPIdx);
2664 }
2665 }
2666 #endif
2667 else
2668 {
2669 MS_ASSERT(0);
2670 return 0xFFFF;
2671 }
2672 }
MDrv_PQ_GetCurrentTableIndex(PQ_WIN eWindow,MS_U16 u16PQIPIdx)2673 MS_U16 MDrv_PQ_GetCurrentTableIndex(PQ_WIN eWindow, MS_U16 u16PQIPIdx)
2674 {
2675 #ifdef TRACE_DBG
2676 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2677 #endif
2678 if (pu32PQInst == NULL)
2679 {
2680 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2681 return FALSE;
2682 }
2683
2684 stPQ_GetCurrentTableIndex PQArgs;
2685 PQArgs.eWindow = eWindow;
2686 PQArgs.u16PQIPIdx = u16PQIPIdx;
2687 PQArgs.u16Ret = 0;
2688 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_CURRENT_TABLE_INDEX, (void*)&PQArgs) != 0)
2689 {
2690 printf("Obtain PQ engine fail\n");
2691 return 0;
2692 }
2693 else
2694 {
2695 return PQArgs.u16Ret;
2696 }
2697 }
2698 //Get main page setting from u16IPIdx(column), according to current input source type(row)
MDrv_PQ_GetTableIndex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16IPIdx)2699 MS_U16 MDrv_PQ_GetTableIndex_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16IPIdx)
2700 {
2701 MS_U8 u16TabIdx = 0;
2702
2703 if(eWindow == PQ_MAIN_WINDOW)
2704 {
2705 if(gbPQBinEnable)
2706 {
2707 u16TabIdx = MDrv_PQBin_GetTableIndex(pInstance,_u16PQSrcType[eWindow],
2708 u16IPIdx,
2709 MDrv_PQBin_GetPanelIdx(pInstance),
2710 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
2711 }
2712 else
2713 {
2714 u16TabIdx = MDrv_PQ_GetTableIndex_(MAIN,pInstance, _u16PQSrcType[eWindow], (MS_U8)u16IPIdx);
2715 }
2716 }
2717 #if (PQ_ENABLE_PIP)
2718 else if(eWindow == PQ_SUB_WINDOW)
2719 {
2720 if(gbPQBinEnable)
2721 {
2722 u16TabIdx = MDrv_PQBin_GetTableIndex(pInstance,_u16PQSrcType[eWindow],
2723 u16IPIdx,
2724 MDrv_PQBin_GetPanelIdx(pInstance),
2725 &stPQBinHeaderInfo[PQ_BIN_STD_SUB]);
2726 }
2727 else
2728 {
2729 u16TabIdx = MDrv_PQ_GetTableIndex_(SUB,pInstance, _u16PQSrcType[eWindow], (MS_U8)u16IPIdx);
2730 }
2731 }
2732 #endif
2733 else
2734 {
2735 MS_ASSERT(0);
2736 }
2737 return u16TabIdx;
2738 }
MDrv_PQ_GetTableIndex(PQ_WIN eWindow,MS_U16 u16IPIdx)2739 MS_U16 MDrv_PQ_GetTableIndex(PQ_WIN eWindow, MS_U16 u16IPIdx)
2740 {
2741 #ifdef TRACE_DBG
2742 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2743 #endif
2744 if (pu32PQInst == NULL)
2745 {
2746 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2747 return FALSE;
2748 }
2749
2750 stPQ_GetTableIndex PQArgs;
2751 PQArgs.eWindow = eWindow;
2752 PQArgs.u16PQIPIdx = u16IPIdx;
2753 PQArgs.u16Ret = 0;
2754 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_TABLE_INDEX, (void*)&PQArgs) != 0)
2755 {
2756 printf("Obtain PQ engine fail\n");
2757 return 0;
2758 }
2759 else
2760 {
2761 return PQArgs.u16Ret;
2762 }
2763 }
2764
2765
2766 //Get main page setting from u16IPIdx(column), according to current input source type(row) by ePQEngineType
MDrv_PQ_GetTableIndex_Ex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16IPIdx,PQ_ENGINE_TYPE ePQEngineType)2767 MS_U16 MDrv_PQ_GetTableIndex_Ex_U2(void *pInstance,PQ_WIN eWindow, MS_U16 u16IPIdx, PQ_ENGINE_TYPE ePQEngineType)
2768 {
2769 MS_U16 u16TabIdx = PQ_BIN_IP_NULL, u16SrcIdx = 0;
2770 MS_U8 u8PanelIdx = 0;
2771 PQ_BIN_TYPE enPQBinType = MAX_PQ_BIN_NUM;
2772
2773 if (eWindow == PQ_MAIN_WINDOW)
2774 {
2775 switch (ePQEngineType)
2776 {
2777 case PQ_XC0_STD:
2778 u16SrcIdx = _u16PQSrcType[eWindow];
2779 if (gbPQBinEnable)
2780 {
2781 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
2782 enPQBinType = PQ_BIN_STD_MAIN;
2783 }
2784 else
2785 {
2786 u16TabIdx = MDrv_PQ_GetTableIndex_(MAIN,pInstance, u16SrcIdx, (MS_U8)u16IPIdx);
2787 }
2788 break;
2789 case PQ_XC0_EXT:
2790 if (gbPQBinEnable)
2791 {
2792 u16SrcIdx = _u16PQSrcType[eWindow];
2793 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
2794 enPQBinType = PQ_BIN_EXT_MAIN;
2795 }
2796 break;
2797 case PQ_XC0_CUSTOMER:
2798 if (_bCustomerMainPQEn)
2799 {
2800 u16SrcIdx = _u16PQSrcType[eWindow];
2801 u8PanelIdx = PQ_BIN_CUSTOMER_PANEL_INDEX;
2802 enPQBinType = PQ_BIN_CUSTOMER_MAIN;
2803 }
2804 break;
2805 case PQ_XC0_UFSC:
2806 if (_bUFSCPQEn)
2807 {
2808 u16SrcIdx = _u16PQSrcType_UFSC[eWindow];
2809 u8PanelIdx = MDrv_PQBin_GetPanelIdx_UFSC(pInstance);
2810 enPQBinType = PQ_BIN_UFSC;
2811 }
2812 break;
2813 default:
2814 break;
2815 }
2816 }
2817 #if (PQ_ENABLE_PIP)
2818 else if (eWindow == PQ_SUB_WINDOW)
2819 {
2820 switch (ePQEngineType)
2821 {
2822 case PQ_XC0_STD:
2823 u16SrcIdx = _u16PQSrcType[eWindow];
2824 if (gbPQBinEnable)
2825 {
2826 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
2827 enPQBinType = PQ_BIN_STD_SUB;
2828 }
2829 else
2830 {
2831 u16TabIdx = MDrv_PQ_GetTableIndex_(SUB,pInstance, u16SrcIdx, (MS_U8)u16IPIdx);
2832 }
2833 break;
2834 case PQ_XC0_EXT:
2835 if (gbPQBinEnable)
2836 {
2837 u16SrcIdx = _u16PQSrcType[eWindow];
2838 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
2839 enPQBinType = PQ_BIN_EXT_SUB;
2840 }
2841 break;
2842 case PQ_XC0_CUSTOMER:
2843 if (_bCustomerSubPQEn)
2844 {
2845 u16SrcIdx = _u16PQSrcType[eWindow];
2846 u8PanelIdx = PQ_BIN_CUSTOMER_PANEL_INDEX;
2847 enPQBinType = PQ_BIN_CUSTOMER_SUB;
2848 }
2849 break;
2850 case PQ_XC0_UFSC:
2851 break;
2852 default:
2853 break;
2854 }
2855
2856 }
2857 #endif
2858 else
2859 {
2860 MS_ASSERT(0);
2861 }
2862
2863 if (enPQBinType != MAX_PQ_BIN_NUM)
2864 {
2865 u16TabIdx = MDrv_PQBin_GetTableIndex(pInstance,
2866 u16SrcIdx,
2867 u16IPIdx,
2868 u8PanelIdx,
2869 &stPQBinHeaderInfo[enPQBinType]);
2870 }
2871
2872 return u16TabIdx;
2873 }
2874
2875 //Get main page setting from u16IPIdx(column), according to current input source type(row) by ePQEngineType
MDrv_PQ_GetTableIndex_Ex(PQ_WIN eWindow,MS_U16 u16IPIdx,PQ_ENGINE_TYPE ePQEngineType)2876 MS_U16 MDrv_PQ_GetTableIndex_Ex(PQ_WIN eWindow, MS_U16 u16IPIdx, PQ_ENGINE_TYPE ePQEngineType)
2877 {
2878 #ifdef TRACE_DBG
2879 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2880 #endif
2881 if (pu32PQInst == NULL)
2882 {
2883 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2884 return FALSE;
2885 }
2886
2887 stPQ_GetTableIndex_Ex PQArgs;
2888 PQArgs.eWindow = eWindow;
2889 PQArgs.u16IPIdx = u16IPIdx;
2890 PQArgs.ePQEngineType = ePQEngineType;
2891 PQArgs.u16Ret = 0;
2892 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_TABLE_INDEX_EX, (void*)&PQArgs) != 0)
2893 {
2894 printf("Obtain PQ engine fail\n");
2895 return 0;
2896 }
2897 else
2898 {
2899 return PQArgs.u16Ret;
2900 }
2901 }
2902
2903 //Get main page setting from u16IPIdx(column), according to current input source type(row)
MDrv_PQ_GetCustomerTableIndex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16IPIdx)2904 MS_U16 MDrv_PQ_GetCustomerTableIndex_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16IPIdx)
2905 {
2906 MS_U8 u16TabIdx = 0;
2907
2908 if(eWindow == PQ_MAIN_WINDOW)
2909 {
2910 if(gbPQBinEnable)
2911 {
2912 u16TabIdx = MDrv_PQBin_GetTableIndex(pInstance,_u16PQSrcType[eWindow],
2913 u16IPIdx,
2914 PQ_BIN_CUSTOMER_PANEL_INDEX,
2915 &stPQBinHeaderInfo[PQ_BIN_CUSTOMER_MAIN]);
2916 }
2917 }
2918 #if (PQ_ENABLE_PIP)
2919 else if(eWindow == PQ_SUB_WINDOW)
2920 {
2921 if(gbPQBinEnable)
2922 {
2923 u16TabIdx = MDrv_PQBin_GetTableIndex(pInstance,_u16PQSrcType[eWindow],
2924 u16IPIdx,
2925 PQ_BIN_CUSTOMER_PANEL_INDEX,
2926 &stPQBinHeaderInfo[PQ_BIN_CUSTOMER_SUB]);
2927 }
2928 }
2929 #endif
2930 else
2931 {
2932 MS_ASSERT(0);
2933 }
2934 return u16TabIdx;
2935 }
2936
MDrv_PQ_GetCustomerTableIndex(PQ_WIN eWindow,MS_U16 u16IPIdx)2937 MS_U16 MDrv_PQ_GetCustomerTableIndex(PQ_WIN eWindow, MS_U16 u16IPIdx)
2938 {
2939 #ifdef TRACE_DBG
2940 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2941 #endif
2942 if (pu32PQInst == NULL)
2943 {
2944 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2945 return FALSE;
2946 }
2947
2948 stPQ_GetCustomerTableIndex PQArgs;
2949 PQArgs.eWindow = eWindow;
2950 PQArgs.u16PQIPIdx = u16IPIdx;
2951 PQArgs.u16Ret = 0;
2952 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_CUSTOMER_TABLE_INDEX, (void*)&PQArgs) != 0)
2953 {
2954 printf("Obtain PQ engine fail\n");
2955 return 0;
2956 }
2957 else
2958 {
2959 return PQArgs.u16Ret;
2960 }
2961 }
MDrv_PQ_GetXRuleIPIndex(void * pInstance,PQ_WIN eWindow,MS_U16 u16XRuleType,MS_U16 u16XRuleIP)2962 static MS_U16 MDrv_PQ_GetXRuleIPIndex(void* pInstance,PQ_WIN eWindow, MS_U16 u16XRuleType, MS_U16 u16XRuleIP)
2963 //MS_U16 MDrv_PQ_GetXRuleIPIndex_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16XRuleType, MS_U16 u16XRuleIP)
2964 {
2965 MS_U8 u16IPIdx = 0;
2966 if(eWindow == PQ_MAIN_WINDOW)
2967 {
2968 if(gbPQBinEnable)
2969 {
2970 u16IPIdx = MDrv_PQBin_GetXRuleIPIndex(pInstance,u16XRuleType,
2971 u16XRuleIP,
2972 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
2973 }
2974 else
2975 {
2976 u16IPIdx = MDrv_PQ_GetXRuleIPIndex_(MAIN,pInstance, (MS_U8)u16XRuleType, (MS_U8)u16XRuleIP);
2977 }
2978 }
2979 #if (PQ_ENABLE_PIP)
2980 else if(eWindow == PQ_SUB_WINDOW)
2981 {
2982 if(gbPQBinEnable)
2983 {
2984 u16IPIdx = MDrv_PQBin_GetXRuleIPIndex(pInstance,u16XRuleType,
2985 u16XRuleIP,
2986 &stPQBinHeaderInfo[PQ_BIN_STD_SUB]);
2987 }
2988 else
2989 {
2990 u16IPIdx = MDrv_PQ_GetXRuleIPIndex_(SUB,pInstance, (MS_U8)u16XRuleType, (MS_U8)u16XRuleIP);
2991 }
2992 }
2993 #endif
2994 else
2995 {
2996 MS_ASSERT(0);
2997 }
2998 return u16IPIdx;
2999 }
3000 //static MS_U16 MDrv_PQ_GetXRuleIPIndex(PQ_WIN eWindow, MS_U16 u16XRuleType, MS_U16 u16XRuleIP)
3001 //{
3002 //#ifdef TRACE_DBG
3003 // printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3004 //#endif
3005 // if (pu32PQInst == NULL)
3006 // {
3007 // printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3008 // return FALSE;
3009 // }
3010 //
3011 // stPQ_GetXRuleIPIndex PQArgs;
3012 // PQArgs.eWindow = eWindow;
3013 // PQArgs.u16XRuleType = u16XRuleType;
3014 // PQArgs.u16XRuleIP = u16XRuleIP;
3015 // PQArgs.u16Ret = 0;
3016 // if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_XRULE_IP_INDEX, (void*)&PQArgs) != 0)
3017 // {
3018 // printf("Obtain PQ engine fail\n");
3019 // return 0;
3020 // }
3021 // else
3022 // {
3023 // return PQArgs.u16Ret;
3024 // }
3025 //}
3026
MDrv_PQ_GetXRuleTableIndex(void * pInstance,PQ_WIN eWindow,MS_U16 u16XRuleType,MS_U16 u16XRuleIdx,MS_U16 u16XRuleIP)3027 static MS_U16 MDrv_PQ_GetXRuleTableIndex(void* pInstance,PQ_WIN eWindow, MS_U16 u16XRuleType, MS_U16 u16XRuleIdx, MS_U16 u16XRuleIP)
3028 //MS_U16 MDrv_PQ_GetXRuleTableIndex_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16XRuleType, MS_U16 u16XRuleIdx, MS_U16 u16XRuleIP)
3029 {
3030 MS_U16 u16TabIdx = 0;
3031
3032 if(eWindow == PQ_MAIN_WINDOW)
3033 {
3034 if(gbPQBinEnable)
3035 {
3036 u16TabIdx = MDrv_PQBin_GetXRuleTableIndex(pInstance,u16XRuleType,
3037 u16XRuleIdx,
3038 u16XRuleIP,
3039 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
3040 }
3041 else
3042 {
3043 u16TabIdx = MDrv_PQ_GetXRuleTableIndex_(MAIN,pInstance, (MS_U8)u16XRuleType, (MS_U8)u16XRuleIdx, (MS_U8)u16XRuleIP);
3044 }
3045 }
3046 #if (PQ_ENABLE_PIP)
3047 else if(eWindow == PQ_SUB_WINDOW)
3048 {
3049 if(gbPQBinEnable)
3050 {
3051 u16TabIdx = MDrv_PQBin_GetXRuleTableIndex(pInstance,u16XRuleType,
3052 u16XRuleIdx,
3053 u16XRuleIP,
3054 &stPQBinHeaderInfo[PQ_BIN_STD_SUB]);
3055 }
3056 else
3057 {
3058 u16TabIdx = MDrv_PQ_GetXRuleTableIndex_(SUB,pInstance, (MS_U8)u16XRuleType, (MS_U8)u16XRuleIdx, (MS_U8)u16XRuleIP);
3059 }
3060 }
3061 #endif
3062 else
3063 {
3064 MS_ASSERT(0);
3065 }
3066 return u16TabIdx;
3067 }
3068 //static MS_U16 MDrv_PQ_GetXRuleTableIndex(PQ_WIN eWindow, MS_U16 u16XRuleType, MS_U16 u16XRuleIdx, MS_U16 u16XRuleIP)
3069 //{
3070 //#ifdef TRACE_DBG
3071 // printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3072 //#endif
3073 // if (pu32PQInst == NULL)
3074 // {
3075 // printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3076 // return FALSE;
3077 // }
3078 //
3079 // stPQ_GetXRuleTableIndex PQArgs;
3080 // PQArgs.eWindow = eWindow;
3081 // PQArgs.u16XRuleType = u16XRuleType;
3082 // PQArgs.u16XRuleIdx = u16XRuleIdx;
3083 // PQArgs.u16XRuleIP = u16XRuleIP;
3084 // PQArgs.u16Ret = 0;
3085 // if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_XRULE_TABLE_INDEX, (void*)&PQArgs) != 0)
3086 // {
3087 // printf("Obtain PQ engine fail\n");
3088 // return 0;
3089 // }
3090 // else
3091 // {
3092 // return PQArgs.u16Ret;
3093 // }
3094 //}
3095
MDrv_PQ_GetXRuleIPNum(void * pInstance,PQ_WIN eWindow,MS_U16 u16XRuleType)3096 static MS_U16 MDrv_PQ_GetXRuleIPNum(void* pInstance,PQ_WIN eWindow, MS_U16 u16XRuleType)
3097 //MS_U16 MDrv_PQ_GetXRuleIPNum_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16XRuleType)
3098 {
3099 MS_U16 u16IPNum = 0;
3100 if(eWindow == PQ_MAIN_WINDOW)
3101 {
3102 if(gbPQBinEnable)
3103 {
3104 u16IPNum = MDrv_PQBin_GetXRuleIPNum(pInstance,u16XRuleType,
3105 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
3106 }
3107 else
3108 {
3109 u16IPNum = MDrv_PQ_GetXRuleIPNum_(MAIN,pInstance, (MS_U8)u16XRuleType);
3110 }
3111 }
3112 #if (PQ_ENABLE_PIP)
3113 else if(eWindow == PQ_SUB_WINDOW)
3114 {
3115 if(gbPQBinEnable)
3116 {
3117 u16IPNum = MDrv_PQBin_GetXRuleIPNum(pInstance,u16XRuleType,
3118 &stPQBinHeaderInfo[PQ_BIN_STD_SUB]);
3119 }
3120 else
3121 {
3122 u16IPNum = MDrv_PQ_GetXRuleIPNum_(SUB,pInstance, (MS_U8)u16XRuleType);
3123 }
3124 }
3125 #endif
3126 else
3127 {
3128 MS_ASSERT(0);
3129 }
3130 return u16IPNum;
3131 }
3132 //static MS_U16 MDrv_PQ_GetXRuleIPNum(PQ_WIN eWindow, MS_U16 u16XRuleType)
3133 //{
3134 //#ifdef TRACE_DBG
3135 // printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3136 //#endif
3137 // if (pu32PQInst == NULL)
3138 // {
3139 // printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3140 // return FALSE;
3141 // }
3142 //
3143 // stPQ_GetXRuleIPNum PQArgs;
3144 // PQArgs.eWindow = eWindow;
3145 // PQArgs.u16XRuleType = u16XRuleType;
3146 // PQArgs.u16Ret = 0;
3147 // if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_XRULE_IP_NUM, (void*)&PQArgs) != 0)
3148 // {
3149 // printf("Obtain PQ engine fail\n");
3150 // return 0;
3151 // }
3152 // else
3153 // {
3154 // return PQArgs.u16Ret;
3155 // }
3156 //}
MDrv_PQ_LoadTableData_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16TabIdx,MS_U16 u16PQIPIdx,MS_U8 * pTable,MS_U16 u16TableSize)3157 void MDrv_PQ_LoadTableData_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16TabIdx, MS_U16 u16PQIPIdx, MS_U8 *pTable, MS_U16 u16TableSize)
3158 {
3159 if(eWindow == PQ_MAIN_WINDOW)
3160 {
3161 if(gbPQBinEnable)
3162 {
3163 MDrv_PQBin_LoadTableData(pInstance,MDrv_PQBin_GetPanelIdx(pInstance),
3164 u16TabIdx,
3165 u16PQIPIdx,
3166 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN],
3167 pTable,
3168 u16TableSize);
3169 }
3170 else
3171 {
3172 MDrv_PQ_LoadTableData_(MAIN,pInstance, (MS_U8)u16TabIdx, (MS_U8)u16PQIPIdx, pTable, u16TableSize);
3173 }
3174 }
3175 #if (PQ_ENABLE_PIP)
3176 else if(eWindow == PQ_SUB_WINDOW)
3177 {
3178 if(gbPQBinEnable)
3179 {
3180 MDrv_PQBin_LoadTableData(pInstance,MDrv_PQBin_GetPanelIdx(pInstance),
3181 u16TabIdx,
3182 u16PQIPIdx,
3183 &stPQBinHeaderInfo[PQ_BIN_STD_SUB],
3184 pTable,
3185 u16TableSize);
3186 }
3187 else
3188 {
3189 MDrv_PQ_LoadTableData_(SUB,pInstance, (MS_U8)u16TabIdx, (MS_U8)u16PQIPIdx, pTable, u16TableSize);
3190 }
3191 }
3192 #endif
3193 else
3194 {
3195 MS_ASSERT(0);
3196 }
3197 }
MDrv_PQ_LoadTableData(PQ_WIN eWindow,MS_U16 u16TabIdx,MS_U16 u16PQIPIdx,MS_U8 * pTable,MS_U16 u16TableSize)3198 void MDrv_PQ_LoadTableData(PQ_WIN eWindow, MS_U16 u16TabIdx, MS_U16 u16PQIPIdx, MS_U8 *pTable, MS_U16 u16TableSize)
3199 {
3200 #ifdef TRACE_DBG
3201 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3202 #endif
3203 if (pu32PQInst == NULL)
3204 {
3205 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3206 return ;
3207 }
3208
3209 stPQ_LoadTableData PQArgs;
3210 PQArgs.eWindow = eWindow;
3211 PQArgs.u16TabIdx = u16TabIdx;
3212 PQArgs.u16PQIPIdx = u16PQIPIdx;
3213 PQArgs.pTable = pTable;
3214 PQArgs.u16TableSize = u16TableSize;
3215 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_TABLE_DATA, (void*)&PQArgs) != 0)
3216 {
3217 printf("Obtain PQ engine fail\n");
3218 return;
3219 }
3220 else
3221 {
3222 return;
3223 }
3224 }
3225
MDrv_PQ_CloneTable_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16TabIdx,MS_U16 u16PQMainIPIdx,MS_U16 u16PQSubIPIdx)3226 void MDrv_PQ_CloneTable_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16TabIdx, MS_U16 u16PQMainIPIdx, MS_U16 u16PQSubIPIdx)
3227 {
3228 if(eWindow == PQ_MAIN_WINDOW)
3229 {
3230 if(gbPQBinEnable)
3231 {
3232 MDrv_PQBin_CloneTable(pInstance,MDrv_PQBin_GetPanelIdx(pInstance),
3233 u16TabIdx,
3234 u16PQMainIPIdx,
3235 u16PQSubIPIdx,
3236 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
3237 }
3238 else
3239 {
3240 MDrv_PQ_CloneTable_(MAIN,pInstance, (MS_U8)u16TabIdx, (MS_U8)u16PQMainIPIdx, (MS_U8)u16PQSubIPIdx);
3241 }
3242 }
3243 #if (PQ_ENABLE_PIP)
3244 else if(eWindow == PQ_SUB_WINDOW)
3245 {
3246 //not support sub
3247 MS_ASSERT(0);
3248 }
3249 #endif
3250 else
3251 {
3252 MS_ASSERT(0);
3253 }
3254 }
MDrv_PQ_CloneTable(PQ_WIN eWindow,MS_U16 u16TabIdx,MS_U16 u16PQMainIPIdx,MS_U16 u16PQSubIPIdx)3255 void MDrv_PQ_CloneTable(PQ_WIN eWindow, MS_U16 u16TabIdx, MS_U16 u16PQMainIPIdx, MS_U16 u16PQSubIPIdx)
3256 {
3257 #ifdef TRACE_DBG
3258 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3259 #endif
3260 if (pu32PQInst == NULL)
3261 {
3262 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3263 return ;
3264 }
3265
3266 stPQ_CloneTable PQArgs;
3267 PQArgs.eWindow = eWindow;
3268 PQArgs.u16TabIdx = u16TabIdx;
3269 PQArgs.u16PQMainIPIdx = u16PQMainIPIdx;
3270 PQArgs.u16PQSubIPIdx = u16PQSubIPIdx;
3271 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_CLONE_TABLE, (void*)&PQArgs) != 0)
3272 {
3273 printf("Obtain PQ engine fail\n");
3274 return;
3275 }
3276 else
3277 {
3278 return;
3279 }
3280 }
3281
MDrv_PQ_LoadTable_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16TabIdx,MS_U16 u16PQIPIdx)3282 void MDrv_PQ_LoadTable_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16TabIdx, MS_U16 u16PQIPIdx)
3283 {
3284 if(eWindow == PQ_MAIN_WINDOW)
3285 {
3286 switch (u16PQIPIdx)
3287 {
3288 case PQ_IP_MADi_Main:
3289 if (_s32LastPQIPMADiMain == (MS_S32)u16TabIdx)
3290 {
3291 return;
3292 }
3293 _s32LastPQIPMADiMain = u16TabIdx;
3294
3295 break;
3296 #if (PQ_MADI_DFK == 1)
3297 case PQ_IP_MADi_Motion_Main:
3298 if (_s32LastPQIPMADiMotMain == (MS_S32)u16TabIdx)
3299 {
3300 return;
3301 }
3302 _s32LastPQIPMADiMotMain = u16TabIdx;
3303
3304 break;
3305 #endif
3306 case PQ_IP_MemFormat_Main:
3307 if (_s32LastPQIPMemFormatMain == (MS_S32)u16TabIdx)
3308 {
3309 return;
3310 }
3311 _s32LastPQIPMemFormatMain = u16TabIdx;
3312 break;
3313 case PQ_IP_HSD_Y_Main:
3314 if (_s32LastPQIPHSDYMain == (MS_S32)u16TabIdx)
3315 {
3316 return;
3317 }
3318 _s32LastPQIPHSDYMain = u16TabIdx;
3319 break;
3320 case PQ_IP_HSD_C_Main:
3321 if (_s32LastPQIPHSDCMain == (MS_S32)u16TabIdx)
3322 {
3323 return;
3324 }
3325 _s32LastPQIPHSDCMain = u16TabIdx;
3326 break;
3327 default:
3328 break;
3329 }
3330 if(gbPQBinEnable)
3331 {
3332 MDrv_PQBin_LoadTable(pInstance,MDrv_PQBin_GetPanelIdx(pInstance),
3333 u16TabIdx,
3334 u16PQIPIdx,
3335 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN],eWindow);
3336 }
3337 else
3338 {
3339 MDrv_PQ_LoadTable_(MAIN,pInstance, (MS_U8)u16TabIdx, (MS_U8)u16PQIPIdx);
3340 }
3341 }
3342 #if (PQ_ENABLE_PIP)
3343 else if(eWindow == PQ_SUB_WINDOW)
3344 {
3345 switch (u16PQIPIdx)
3346 {
3347 case PQ_IP_MADi_Sub:
3348 if (_s32LastPQIPMADiSub == (MS_S32)u16TabIdx)
3349 {
3350 return;
3351 }
3352 _s32LastPQIPMADiSub = u16TabIdx;
3353 break;
3354 case PQ_IP_MADi_Motion_Sub:
3355 if (_s32LastPQIPMADiMotSub == (MS_S32)u16TabIdx)
3356 {
3357 return;
3358 }
3359 _s32LastPQIPMADiMotSub = u16TabIdx;
3360 break;
3361 case PQ_IP_MemFormat_Sub:
3362 if (_s32LastPQIPMemFormatSub == (MS_S32)u16TabIdx)
3363 {
3364 return;
3365 }
3366 _s32LastPQIPMemFormatSub = u16TabIdx;
3367 break;
3368 default:
3369 break;
3370 }
3371 if(gbPQBinEnable)
3372 {
3373 MDrv_PQBin_LoadTable(pInstance,MDrv_PQBin_GetPanelIdx(pInstance),
3374 u16TabIdx,
3375 u16PQIPIdx,
3376 &stPQBinHeaderInfo[PQ_BIN_STD_SUB],eWindow);
3377 }
3378 else
3379 {
3380 MDrv_PQ_LoadTable_(SUB,pInstance, (MS_U8)u16TabIdx, (MS_U8)u16PQIPIdx);
3381 }
3382 }
3383 #endif
3384 else
3385 {
3386 MS_ASSERT(0);
3387 }
3388 }
MDrv_PQ_LoadTable(PQ_WIN eWindow,MS_U16 u16TabIdx,MS_U16 u16PQIPIdx)3389 void MDrv_PQ_LoadTable(PQ_WIN eWindow, MS_U16 u16TabIdx, MS_U16 u16PQIPIdx)
3390 {
3391 #ifdef TRACE_DBG
3392 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3393 #endif
3394 if (pu32PQInst == NULL)
3395 {
3396 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3397 return ;
3398 }
3399
3400 stPQ_LoadTable PQArgs;
3401 PQArgs.eWindow = eWindow;
3402 PQArgs.u16TabIdx = u16TabIdx;
3403 PQArgs.u16PQIPIdx = u16PQIPIdx;
3404 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_TABLE, (void*)&PQArgs) != 0)
3405 {
3406 printf("Obtain PQ engine fail\n");
3407 return;
3408 }
3409 else
3410 {
3411 return;
3412 }
3413 }
3414
MDrv_PQ_LoadCustomerTable_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16TabIdx,MS_U16 u16PQIPIdx)3415 void MDrv_PQ_LoadCustomerTable_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16TabIdx, MS_U16 u16PQIPIdx)
3416 {
3417 if(eWindow == PQ_MAIN_WINDOW)
3418 {
3419 if(gbPQBinEnable)
3420 {
3421
3422 MDrv_PQBin_LoadTable(pInstance,PQ_BIN_CUSTOMER_PANEL_INDEX,
3423 u16TabIdx,
3424 u16PQIPIdx,
3425 &stPQBinHeaderInfo[PQ_BIN_CUSTOMER_MAIN],eWindow);
3426 }
3427 else
3428 {
3429 MDrv_PQ_LoadTable_(MAIN,pInstance, (MS_U8)u16TabIdx, (MS_U8)u16PQIPIdx);
3430 }
3431 }
3432 #if (PQ_ENABLE_PIP)
3433 else if(eWindow == PQ_SUB_WINDOW)
3434 {
3435 if(gbPQBinEnable)
3436 {
3437
3438 MDrv_PQBin_LoadTable(pInstance,PQ_BIN_CUSTOMER_PANEL_INDEX,
3439 u16TabIdx,
3440 u16PQIPIdx,
3441 &stPQBinHeaderInfo[PQ_BIN_CUSTOMER_SUB],eWindow);
3442 }
3443 else
3444 {
3445 MDrv_PQ_LoadTable_(SUB,pInstance, (MS_U8)u16TabIdx, (MS_U8)u16PQIPIdx);
3446 }
3447 }
3448 #endif
3449 else
3450 {
3451 MS_ASSERT(0);
3452 }
3453 }
MDrv_PQ_LoadCustomerTable(PQ_WIN eWindow,MS_U16 u16TabIdx,MS_U16 u16PQIPIdx)3454 void MDrv_PQ_LoadCustomerTable(PQ_WIN eWindow, MS_U16 u16TabIdx, MS_U16 u16PQIPIdx)
3455 {
3456 #ifdef TRACE_DBG
3457 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3458 #endif
3459 if (pu32PQInst == NULL)
3460 {
3461 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3462 return ;
3463 }
3464
3465 stPQ_LoadCustomerTable PQArgs;
3466 PQArgs.eWindow = eWindow;
3467 PQArgs.u16TabIdx = u16TabIdx;
3468 PQArgs.u16PQIPIdx = u16PQIPIdx;
3469 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_CUSTOMER_TABLE, (void*)&PQArgs) != 0)
3470 {
3471 printf("Obtain PQ engine fail\n");
3472 return;
3473 }
3474 else
3475 {
3476 return;
3477 }
3478 }
3479
MDrv_PQ_LoadTable_Ex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16TabIdx,MS_U16 u16PQIPIdx,PQ_ENGINE_TYPE ePQEngineType)3480 void MDrv_PQ_LoadTable_Ex_U2(void *pInstance,PQ_WIN eWindow, MS_U16 u16TabIdx, MS_U16 u16PQIPIdx, PQ_ENGINE_TYPE ePQEngineType)
3481 {
3482 MS_U8 u8PanelIdx = 0;
3483 PQ_BIN_TYPE enPQBinType = MAX_PQ_BIN_NUM;
3484
3485 if (eWindow == PQ_MAIN_WINDOW)
3486 {
3487 switch (ePQEngineType)
3488 {
3489 case PQ_XC0_STD:
3490 switch (u16PQIPIdx)
3491 {
3492 case PQ_IP_MADi_Main:
3493 if (_s32LastPQIPMADiMain == (MS_S32)u16TabIdx)
3494 {
3495 return;
3496 }
3497 _s32LastPQIPMADiMain = u16TabIdx;
3498 break;
3499 #if (PQ_MADI_DFK == 1)
3500 case PQ_IP_MADi_Motion_Main:
3501 if (_s32LastPQIPMADiMotMain == (MS_S32)u16TabIdx)
3502 {
3503 return;
3504 }
3505 _s32LastPQIPMADiMotMain = u16TabIdx;
3506 break;
3507 #endif
3508 case PQ_IP_MemFormat_Main:
3509 if (_s32LastPQIPMemFormatMain == (MS_S32)u16TabIdx)
3510 {
3511 return;
3512 }
3513 _s32LastPQIPMemFormatMain = u16TabIdx;
3514 break;
3515 case PQ_IP_HSD_Y_Main:
3516 if (_s32LastPQIPHSDYMain == (MS_S32)u16TabIdx)
3517 {
3518 return;
3519 }
3520 _s32LastPQIPHSDYMain = u16TabIdx;
3521 break;
3522 case PQ_IP_HSD_C_Main:
3523 if (_s32LastPQIPHSDCMain == (MS_S32)u16TabIdx)
3524 {
3525 return;
3526 }
3527 _s32LastPQIPHSDCMain = u16TabIdx;
3528 break;
3529 default:
3530 break;
3531 }
3532 if (gbPQBinEnable)
3533 {
3534 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
3535 enPQBinType = PQ_BIN_STD_MAIN;
3536 }
3537 else
3538 {
3539 MDrv_PQ_LoadTable_(MAIN, pInstance,(MS_U8)u16TabIdx, (MS_U8)u16PQIPIdx);
3540 }
3541 break;
3542 case PQ_XC0_EXT:
3543 if (gbPQBinEnable)
3544 {
3545 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
3546 enPQBinType = PQ_BIN_EXT_MAIN;
3547 }
3548 break;
3549 case PQ_XC0_CUSTOMER:
3550 if (_bCustomerMainPQEn)
3551 {
3552 u8PanelIdx = PQ_BIN_CUSTOMER_PANEL_INDEX;
3553 enPQBinType = PQ_BIN_CUSTOMER_MAIN;
3554 }
3555 break;
3556 case PQ_XC0_UFSC:
3557 if (_bUFSCPQEn)
3558 {
3559 u8PanelIdx = PQ_BIN_UFSC_PANEL_INDEX;
3560 enPQBinType = PQ_BIN_UFSC;
3561 }
3562 break;
3563 default:
3564 break;
3565 }
3566 }
3567 #if (PQ_ENABLE_PIP)
3568 else if (eWindow == PQ_SUB_WINDOW)
3569 {
3570 switch (ePQEngineType)
3571 {
3572 case PQ_XC0_STD:
3573 switch (u16PQIPIdx)
3574 {
3575 case PQ_IP_MADi_Sub:
3576 if (_s32LastPQIPMADiSub == (MS_S32)u16TabIdx)
3577 {
3578 return;
3579 }
3580 _s32LastPQIPMADiSub = u16TabIdx;
3581 break;
3582 case PQ_IP_MADi_Motion_Sub:
3583 if (_s32LastPQIPMADiMotSub == (MS_S32)u16TabIdx)
3584 {
3585 return;
3586 }
3587 _s32LastPQIPMADiMotSub = u16TabIdx;
3588 break;
3589 case PQ_IP_MemFormat_Sub:
3590 if (_s32LastPQIPMemFormatSub == (MS_S32)u16TabIdx)
3591 {
3592 return;
3593 }
3594 _s32LastPQIPMemFormatSub = u16TabIdx;
3595 break;
3596 default:
3597 break;
3598 }
3599 if (gbPQBinEnable)
3600 {
3601 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
3602 enPQBinType = PQ_BIN_STD_SUB;
3603 }
3604 else
3605 {
3606 MDrv_PQ_LoadTable_(SUB,pInstance, (MS_U8)u16TabIdx, (MS_U8)u16PQIPIdx);
3607 }
3608 break;
3609 case PQ_XC0_EXT:
3610 if (gbPQBinEnable)
3611 {
3612 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
3613 enPQBinType = PQ_BIN_EXT_SUB;
3614 }
3615 break;
3616 case PQ_XC0_CUSTOMER:
3617 if (_bCustomerSubPQEn)
3618 {
3619 u8PanelIdx = PQ_BIN_CUSTOMER_PANEL_INDEX;
3620 enPQBinType = PQ_BIN_CUSTOMER_SUB;
3621 }
3622 break;
3623 case PQ_XC0_UFSC:
3624 break;
3625 default:
3626 break;
3627 }
3628
3629 }
3630 #endif
3631 else
3632 {
3633 MS_ASSERT(0);
3634 }
3635
3636 if (enPQBinType != MAX_PQ_BIN_NUM)
3637 {
3638 MDrv_PQBin_LoadTable(pInstance,
3639 u8PanelIdx,
3640 u16TabIdx,
3641 u16PQIPIdx,
3642 &stPQBinHeaderInfo[enPQBinType],eWindow);
3643 }
3644 }
3645
MDrv_PQ_LoadTable_Ex(PQ_WIN eWindow,MS_U16 u16TabIdx,MS_U16 u16PQIPIdx,PQ_ENGINE_TYPE ePQEngineType)3646 void MDrv_PQ_LoadTable_Ex(PQ_WIN eWindow, MS_U16 u16TabIdx, MS_U16 u16PQIPIdx, PQ_ENGINE_TYPE ePQEngineType)
3647 {
3648 #ifdef TRACE_DBG
3649 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3650 #endif
3651 if (pu32PQInst == NULL)
3652 {
3653 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3654 return ;
3655 }
3656
3657 stPQ_LoadTable_Ex PQArgs;
3658 PQArgs.eWindow = eWindow;
3659 PQArgs.u16TabIdx = u16TabIdx;
3660 PQArgs.u16PQIPIdx = u16PQIPIdx;
3661 PQArgs.u16PQIPIdx = ePQEngineType;
3662 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_TABLE_EX, (void*)&PQArgs) != 0)
3663 {
3664 printf("Obtain PQ engine fail\n");
3665 }
3666 }
3667
MDrv_PQ_CheckSettings_U2(void * pInstance,PQ_WIN eWindow)3668 void MDrv_PQ_CheckSettings_U2(void* pInstance,PQ_WIN eWindow)
3669 {
3670 if(eWindow == PQ_MAIN_WINDOW)
3671 {
3672 if(gbPQBinEnable)
3673 {
3674 //ToDo MAINEX
3675 MDrv_PQBin_CheckCommTable(pInstance,MDrv_PQBin_GetPanelIdx(pInstance),
3676 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
3677
3678 MDrv_PQBin_CheckTableBySrcType(pInstance,_u16PQSrcType[eWindow],
3679 PQ_BIN_IP_ALL,
3680 MDrv_PQBin_GetPanelIdx(pInstance),
3681 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN],
3682 eWindow);
3683 }
3684 else
3685 {
3686 #if(ENABLE_PQ_EX)
3687 MDrv_PQ_CheckCommTable_(MAINEX,pInstance);
3688 MDrv_PQ_CheckTableBySrcType_(MAINEX,pInstance, _u16PQSrcType[eWindow], PQ_IP_ALL);
3689 #endif
3690 MDrv_PQ_CheckCommTable_(MAIN,pInstance);
3691 MDrv_PQ_CheckTableBySrcType_(MAIN,pInstance, _u16PQSrcType[eWindow], PQ_IP_ALL);
3692 }
3693 }
3694 #if (PQ_ENABLE_PIP)
3695 else if(eWindow == PQ_SUB_WINDOW)
3696 {
3697 if(gbPQBinEnable)
3698 {
3699 //ToDo SUBEX
3700 MDrv_PQBin_CheckCommTable(pInstance,MDrv_PQBin_GetPanelIdx(pInstance),
3701 &stPQBinHeaderInfo[PQ_BIN_STD_SUB]);
3702
3703 MDrv_PQBin_CheckTableBySrcType(pInstance,_u16PQSrcType[eWindow],
3704 PQ_BIN_IP_ALL,
3705 MDrv_PQBin_GetPanelIdx(pInstance),
3706 &stPQBinHeaderInfo[PQ_BIN_STD_SUB],
3707 eWindow);
3708 }
3709 else
3710 {
3711 #if(ENABLE_PQ_EX)
3712 MDrv_PQ_CheckCommTable_(SUBEX,pInstance);
3713 MDrv_PQ_CheckTableBySrcType_(SUBEX,pInstance, _u16PQSrcType[eWindow], PQ_IP_ALL);
3714 #endif
3715 MDrv_PQ_CheckCommTable_(SUB,pInstance);
3716 MDrv_PQ_CheckTableBySrcType_(SUB,pInstance, _u16PQSrcType[eWindow], PQ_IP_ALL);
3717 }
3718 }
3719 #endif
3720 else
3721 {
3722 MS_ASSERT(0);
3723 }
3724 }
MDrv_PQ_CheckSettings(PQ_WIN eWindow)3725 void MDrv_PQ_CheckSettings(PQ_WIN eWindow)
3726 {
3727 #ifdef TRACE_DBG
3728 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3729 #endif
3730 if (pu32PQInst == NULL)
3731 {
3732 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3733 return ;
3734 }
3735
3736 stPQ_CheckSettings PQArgs;
3737 PQArgs.eWindow = eWindow;
3738 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_CHECK_SETTINGS, (void*)&PQArgs) != 0)
3739 {
3740 printf("Obtain PQ engine fail\n");
3741 return;
3742 }
3743 else
3744 {
3745 return;
3746 }
3747 }
3748
3749
3750 #if(ENABLE_PQ_MLOAD)
MDrv_PQ_Set_MLoadEn_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bEn)3751 void MDrv_PQ_Set_MLoadEn_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bEn)
3752 {
3753 if(MApi_XC_MLoad_GetStatus() != E_MLOAD_ENABLED)
3754 {
3755 bEn = FALSE;
3756 }
3757
3758 if(bEn)
3759 {
3760 PQ_MLOAD_ENTRY();
3761 }
3762
3763 if(eWindow == PQ_MAIN_WINDOW)
3764 {
3765 if(gbPQBinEnable)
3766 {
3767 MDrv_PQBin_Set_MLoadEn(pInstance,bEn);
3768 }
3769 else
3770 {
3771 MDrv_PQ_Set_MLoadEn_(MAIN,pInstance, bEn);
3772 }
3773
3774 }
3775 #if (PQ_ENABLE_PIP)
3776 else if(eWindow == PQ_SUB_WINDOW)
3777 {
3778 if(gbPQBinEnable)
3779 {
3780 MDrv_PQBin_Set_MLoadEn(pInstance,bEn);
3781 }
3782 else
3783 {
3784 MDrv_PQ_Set_MLoadEn_(SUB,pInstance, bEn);
3785 }
3786 }
3787 #endif
3788 else
3789 {
3790 MS_ASSERT(0);
3791 }
3792
3793
3794 if(bEn == FALSE)
3795 {
3796 PQ_MLOAD_RETURN();
3797 }
3798 }
MDrv_PQ_Set_MLoadEn(PQ_WIN eWindow,MS_BOOL bEn)3799 void MDrv_PQ_Set_MLoadEn(PQ_WIN eWindow, MS_BOOL bEn)
3800 {
3801 #ifdef TRACE_DBG
3802 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3803 #endif
3804 if (pu32PQInst == NULL)
3805 {
3806 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3807 return ;
3808 }
3809
3810 stPQ_Set_MLoadEn PQArgs;
3811 PQArgs.eWindow = eWindow;
3812 PQArgs.bEn = bEn;
3813 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_MLOAD_EN, (void*)&PQArgs) != 0)
3814 {
3815 printf("Obtain PQ engine fail\n");
3816 return;
3817 }
3818 else
3819 {
3820 return;
3821 }
3822 }
3823 #endif
3824
MDrv_PQ_SkipDuplicatedSetting_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bSkip)3825 MS_BOOL MDrv_PQ_SkipDuplicatedSetting_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bSkip)
3826 {
3827 UNUSED(eWindow);
3828 _bSkipDuplicateSetting = bSkip;
3829 return TRUE;
3830 }
MDrv_PQ_SkipDuplicatedSetting(PQ_WIN eWindow,MS_BOOL bSkip)3831 MS_BOOL MDrv_PQ_SkipDuplicatedSetting(PQ_WIN eWindow, MS_BOOL bSkip)
3832 {
3833 #ifdef TRACE_DBG
3834 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3835 //return FALSE;
3836 #endif
3837 if (pu32PQInst == NULL)
3838 {
3839 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3840 return FALSE;
3841 }
3842
3843 stPQ_SkipDuplicatedSetting PQArgs;
3844 PQArgs.eWindow = eWindow;
3845 PQArgs.bSkip = bSkip;
3846 PQArgs.bReturnValue = FALSE;
3847 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SKIP_DUPLICATED_SETTING, (void*)&PQArgs) != 0)
3848 {
3849 printf("Obtain PQ engine fail\n");
3850 return FALSE;
3851 }
3852 else
3853 {
3854 return PQArgs.bReturnValue;
3855 }
3856 }
3857
MDrv_PQ_GetSkipDuplicatedSettingStatus_U2(void * pInstance,PQ_WIN eWindow)3858 MS_BOOL MDrv_PQ_GetSkipDuplicatedSettingStatus_U2(void* pInstance,PQ_WIN eWindow)
3859 {
3860 UNUSED(eWindow);
3861 return _bSkipDuplicateSetting;
3862 }
MDrv_PQ_GetSkipDuplicatedSettingStatus(PQ_WIN eWindow)3863 MS_BOOL MDrv_PQ_GetSkipDuplicatedSettingStatus(PQ_WIN eWindow)
3864 {
3865 #ifdef TRACE_DBG
3866 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3867 #endif
3868 if (pu32PQInst == NULL)
3869 {
3870 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3871 return FALSE;
3872 }
3873
3874 stPQ_GetSkipDuplicatedSettingStatus PQArgs;
3875 PQArgs.eWindow = eWindow;
3876 PQArgs.bReturnValue = FALSE;
3877 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_SKIP_DUPLICATED_SETTING_STATUS, (void*)&PQArgs) != 0)
3878 {
3879 printf("Obtain PQ engine fail\n");
3880 return FALSE;
3881 }
3882 else
3883 {
3884 return PQArgs.bReturnValue;
3885 }
3886 }
3887
3888 #if (PQ_FRCM_CBCR_SWAP_BY_SW == 1)
MDrv_PQ_SetFrcmCbCrSwap_U2(void * pInstance,PQ_WIN eWindow)3889 void MDrv_PQ_SetFrcmCbCrSwap_U2(void* pInstance,PQ_WIN eWindow)
3890 {
3891 // FRCM mirror: BK32_03[12](main), BK32_43[12](sub)
3892 // FRCM cbcy swap: BK31_19[0](main),BK31_59[0](sub)
3893 // Bypass CE(compression): BK33_01[0](main),BK33_01[1](sub), 0: ENABLE CE; 1: disable CE
3894 // --------------------------------------------------------------------------------------------
3895 // | regs | not h_mirror | h_mirror without compression | h_mirror with compression |
3896 // | BK32_03[12] | 0 | 1 | 1 |
3897 // | BK33_01[0] | 0 or 1 | 1 | 0 |
3898 // | BK31_19[0] | 0 | 1 | 0 |
3899 // --------------------------------------------------------------------------------------------
3900
3901 if(eWindow == PQ_MAIN_WINDOW)
3902 {
3903 if (MApi_XC_R2BYTEMSK(REG_SC_BK32_03_L, BIT(12)) == 0)
3904 {
3905 MApi_XC_W2BYTEMSK(REG_SC_BK31_19_L, 0, BIT(0));
3906 }
3907 else
3908 {
3909 if (MApi_XC_R2BYTEMSK(REG_SC_BK33_01_L, BIT(0)) != 0)
3910 {
3911 MApi_XC_W2BYTEMSK(REG_SC_BK31_19_L, BIT(0), BIT(0));
3912 }
3913 else
3914 {
3915 MApi_XC_W2BYTEMSK(REG_SC_BK31_19_L, 0, BIT(0));
3916 }
3917 }
3918 }
3919 else
3920 {
3921 if (MApi_XC_R2BYTEMSK(REG_SC_BK32_43_L, BIT(12)) == 0)
3922 {
3923 MApi_XC_W2BYTEMSK(REG_SC_BK31_59_L, 0, BIT(0));
3924 }
3925 else
3926 {
3927 if (MApi_XC_R2BYTEMSK(REG_SC_BK33_01_L, BIT(1)) != 0)
3928 {
3929 MApi_XC_W2BYTEMSK(REG_SC_BK31_59_L, BIT(0), BIT(0));
3930 }
3931 else
3932 {
3933 MApi_XC_W2BYTEMSK(REG_SC_BK31_59_L, 0, BIT(0));
3934 }
3935 }
3936 }
3937 }
MDrv_PQ_SetFrcmCbCrSwap(PQ_WIN eWindow)3938 void MDrv_PQ_SetFrcmCbCrSwap(PQ_WIN eWindow)
3939 {
3940 #ifdef TRACE_DBG
3941 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3942 #endif
3943 if (pu32PQInst == NULL)
3944 {
3945 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3946 return ;
3947 }
3948
3949 stPQ_SetFrcmCbCrSwap PQArgs;
3950 PQArgs.eWindow = eWindow;
3951 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_FRCM_CB_CR_SWAP, (void*)&PQArgs) != 0)
3952 {
3953 printf("Obtain PQ engine fail\n");
3954 return;
3955 }
3956 else
3957 {
3958 return;
3959 }
3960 }
3961 #endif
3962
MDrv_PQ_LoadSettings_U2(void * pInstance,PQ_WIN eWindow)3963 void MDrv_PQ_LoadSettings_U2(void* pInstance,PQ_WIN eWindow)
3964 {
3965 if((_u16LastPQSrcType[eWindow] == _u16PQSrcType[eWindow]) && _bSkipDuplicateSetting)
3966 {
3967 PQTAB_DBG(printf("\t !!!!!!!!Skip PQ,[PQ timming = %d, eWindow = %d]\n",_u16PQSrcType[eWindow],eWindow));
3968 return;
3969 }
3970
3971 _u16LastPQSrcType[eWindow] = _u16PQSrcType[eWindow];
3972
3973 if(eWindow == PQ_MAIN_WINDOW)
3974 {
3975 //load swdriver here before all the others PQ settings.
3976 //Pls don't add swDriver in to skip rule, otherwise below code cannot set swDriver.
3977 MDrv_PQ_LoadTable_U2(pInstance, eWindow, MDrv_PQ_GetTableIndex_U2(pInstance, eWindow, PQ_IP_SwDriver_Main), PQ_IP_SwDriver_Main);
3978
3979 if(gbPQBinEnable)
3980 {
3981
3982 MDrv_PQBin_LoadTableBySrcType(pInstance,_u16PQSrcType[eWindow],
3983 PQ_BIN_IP_ALL,
3984 MDrv_PQBin_GetPanelIdx(pInstance),
3985 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN],
3986 eWindow);
3987
3988 MDrv_PQBin_LoadTableBySrcType(pInstance,_u16PQSrcType[eWindow],
3989 PQ_BIN_IP_ALL,
3990 MDrv_PQBin_GetPanelIdx(pInstance),
3991 &stPQBinHeaderInfo[PQ_BIN_EXT_MAIN],
3992 eWindow);
3993
3994 }
3995 else
3996 {
3997 PQTAB_DBG(printf("MAIN table\n"));
3998 MDrv_PQ_LoadTableBySrcType_(MAIN,pInstance, _u16PQSrcType[eWindow], PQ_IP_ALL);
3999 #if(ENABLE_PQ_EX == 1)
4000 PQTAB_DBG(printf("MAINEX table\n"));
4001 MDrv_PQ_LoadTableBySrcType_(MAINEX,pInstance, _u16PQSrcType[eWindow], PQ_IP_ALL);
4002 #endif
4003 PQTAB_DBG(printf("...done\n"));
4004 }
4005
4006 if(_gIsMVC4kx1k == TRUE)
4007 {
4008 #if PQ_LCE_CTL_FOR_MVC4KX1K
4009 MDrv_PQ_LoadTable_U2(pInstance, PQ_MAIN_WINDOW, PQ_IP_VIP_LCE_OFF_Main, PQ_IP_VIP_LCE_Main);
4010 #endif
4011 #if PQ_DLC_CTL_FOR_MVC4KX1K
4012 MDrv_PQ_LoadTable_U2(pInstance, PQ_MAIN_WINDOW, PQ_IP_VIP_DLC_OFF_Main, PQ_IP_VIP_DLC_Main);
4013 #endif
4014 }
4015
4016 }
4017 #if (PQ_ENABLE_PIP)
4018 else if(eWindow == PQ_SUB_WINDOW)
4019 {
4020 if(gbPQBinEnable)
4021 {
4022 MDrv_PQBin_LoadTableBySrcType(pInstance,_u16PQSrcType[eWindow],
4023 PQ_BIN_IP_ALL,
4024 MDrv_PQBin_GetPanelIdx(pInstance),
4025 &stPQBinHeaderInfo[PQ_BIN_STD_SUB],
4026 eWindow);
4027
4028 MDrv_PQBin_LoadTableBySrcType(pInstance,_u16PQSrcType[eWindow],
4029 PQ_BIN_IP_ALL,
4030 MDrv_PQBin_GetPanelIdx(pInstance),
4031 &stPQBinHeaderInfo[PQ_BIN_EXT_SUB],
4032 eWindow);
4033 }
4034 else
4035 {
4036 PQTAB_DBG(printf("SUB table\n"));
4037 MDrv_PQ_LoadTableBySrcType_(SUB,pInstance, _u16PQSrcType[eWindow], PQ_IP_ALL);
4038 #if(ENABLE_PQ_EX == 1)
4039 PQTAB_DBG(printf("SUB MAINEX table\n"));
4040 MDrv_PQ_LoadTableBySrcType_(SUBEX,pInstance, _u16PQSrcType[eWindow], PQ_IP_ALL);
4041 #endif
4042 PQTAB_DBG(printf("...done\n"));
4043 }
4044 }
4045 #endif
4046 else
4047 {
4048 MS_ASSERT(0);
4049 }
4050
4051 #if (PQ_IOCTL_SET_UC_FEATURE == 0)
4052 MDrv_PQ_IOCTL((PQ_WIN)eWindow,
4053 E_IOCTL_SET_UCFEATURE,
4054 NULL,
4055 NULL);
4056 #endif
4057
4058 #if(ENABLE_PQ_LOAD_TABLE_INFO)
4059 if(eWindow == PQ_MAIN_WINDOW)
4060 {
4061 MDRV_PQ_PrintLoadTableInfo(PQ_LOAD_TABLE_MAIN);
4062 MDRV_PQ_PrintLoadTableInfo(PQ_LOAD_TABLE_MAIN_EX);
4063 }
4064 #if PQ_ENABLE_PIP
4065 else if(eWindow == PQ_SUB_WINDOW)
4066 {
4067 MDRV_PQ_PrintLoadTableInfo(PQ_LOAD_TABLE_SUB);
4068 MDRV_PQ_PrintLoadTableInfo(PQ_LOAD_TABLE_SUB_EX);
4069 }
4070 #endif
4071 else
4072 {
4073 MS_ASSERT(0);
4074 }
4075 #endif
4076 #if (PQ_FRCM_CBCR_SWAP_BY_SW == 1)
4077 MDrv_PQ_SetFrcmCbCrSwap_U2(pInstance, eWindow);
4078 #endif
4079
4080 #ifdef PQ_DISABLE_BYPASS_MODE2_BY_SW
4081 if(MApi_XC_R2BYTE(REG_CHIP_REVISION) < 1)//Monaco U02 fix .
4082 {
4083 MApi_XC_W2BYTEMSK(REG_SC_BK12_44_L, 0x00, BIT(4)); //Disable bypass mode2, for sub video I mode flicker issue
4084 }
4085 #endif
4086
4087 }
MDrv_PQ_LoadSettings(PQ_WIN eWindow)4088 void MDrv_PQ_LoadSettings(PQ_WIN eWindow)
4089 {
4090 #ifdef TRACE_DBG
4091 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4092 #endif
4093 if (pu32PQInst == NULL)
4094 {
4095 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4096 return ;
4097 }
4098
4099 stPQ_LoadSettings PQArgs;
4100 PQArgs.eWindow = eWindow;
4101 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_SETTINGS, (void*)&PQArgs) != 0)
4102 {
4103 printf("Obtain PQ engine fail\n");
4104 return;
4105 }
4106 else
4107 {
4108 return;
4109 }
4110 }
4111
MDrv_PQ_LoadCustomerSettings_U2(void * pInstance,PQ_WIN eWindow)4112 void MDrv_PQ_LoadCustomerSettings_U2(void* pInstance,PQ_WIN eWindow)
4113 {
4114 if(eWindow == PQ_MAIN_WINDOW)
4115 {
4116 if(gbPQBinEnable)
4117 {
4118
4119 MDrv_PQBin_LoadTableBySrcType(pInstance,_u16PQSrcType[eWindow],
4120 PQ_BIN_IP_ALL,
4121 PQ_BIN_CUSTOMER_PANEL_INDEX,
4122 &stPQBinHeaderInfo[PQ_BIN_CUSTOMER_MAIN],
4123 eWindow);
4124
4125 }
4126 }
4127 #if (PQ_ENABLE_PIP)
4128 else if(eWindow == PQ_SUB_WINDOW)
4129 {
4130 if(gbPQBinEnable)
4131 {
4132 MDrv_PQBin_LoadTableBySrcType(pInstance,_u16PQSrcType[eWindow],
4133 PQ_BIN_IP_ALL,
4134 PQ_BIN_CUSTOMER_PANEL_INDEX,
4135 &stPQBinHeaderInfo[PQ_BIN_CUSTOMER_SUB],
4136 eWindow);
4137 }
4138 }
4139 #endif
4140 else
4141 {
4142 MS_ASSERT(0);
4143 }
4144 }
MDrv_PQ_LoadCustomerSettings(PQ_WIN eWindow)4145 void MDrv_PQ_LoadCustomerSettings(PQ_WIN eWindow)
4146 {
4147 #ifdef TRACE_DBG
4148 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4149 #endif
4150 if (pu32PQInst == NULL)
4151 {
4152 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4153 return ;
4154 }
4155
4156 stPQ_LoadCustomerSettings PQArgs;
4157 PQArgs.eWindow = eWindow;
4158 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_CUSTONER_SETTINGS, (void*)&PQArgs) != 0)
4159 {
4160 printf("Obtain PQ engine fail\n");
4161 return;
4162 }
4163 else
4164 {
4165 return;
4166 }
4167 }
4168
MDrv_PQ_Set_DTVInfo_U2(void * pInstance,PQ_WIN eWindow,MS_PQ_Dtv_Info * pstPQDTVInfo)4169 void MDrv_PQ_Set_DTVInfo_U2(void* pInstance,PQ_WIN eWindow, MS_PQ_Dtv_Info *pstPQDTVInfo)
4170 {
4171 memcpy(&_stDTV_Info[eWindow], pstPQDTVInfo, sizeof(MS_PQ_Dtv_Info));
4172
4173 PQINFO_DBG(printf("PQ DTV Info:Win=%u, type=%u\n", eWindow, _stDTV_Info[eWindow].eType));
4174 }
MDrv_PQ_Set_DTVInfo(PQ_WIN eWindow,MS_PQ_Dtv_Info * pstPQDTVInfo)4175 void MDrv_PQ_Set_DTVInfo(PQ_WIN eWindow, MS_PQ_Dtv_Info *pstPQDTVInfo)
4176 {
4177 #ifdef TRACE_DBG
4178 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4179 #endif
4180 if (pu32PQInst == NULL)
4181 {
4182 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4183 return ;
4184 }
4185
4186 stPQ_Set_DTVInfo PQArgs;
4187 PQArgs.eWindow = eWindow;
4188 PQArgs.pstPQDTVInfo = pstPQDTVInfo;
4189 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_DTVINFO, (void*)&PQArgs) != 0)
4190 {
4191 printf("Obtain PQ engine fail\n");
4192 return;
4193 }
4194 else
4195 {
4196 return;
4197 }
4198 }
4199
MDrv_PQ_Set_MultiMediaInfo_U2(void * pInstance,PQ_WIN eWindow,MS_PQ_MuliMedia_Info * pstPQMMInfo)4200 void MDrv_PQ_Set_MultiMediaInfo_U2(void* pInstance,PQ_WIN eWindow, MS_PQ_MuliMedia_Info *pstPQMMInfo)
4201 {
4202 memcpy(&_stMultiMedia_Info[eWindow], pstPQMMInfo, sizeof(MS_PQ_MuliMedia_Info));
4203 PQINFO_DBG(printf("PQ MM Info:Win=%u, type=%u\n", eWindow, _stMultiMedia_Info[eWindow].eType));
4204 }
MDrv_PQ_Set_MultiMediaInfo(PQ_WIN eWindow,MS_PQ_MuliMedia_Info * pstPQMMInfo)4205 void MDrv_PQ_Set_MultiMediaInfo(PQ_WIN eWindow, MS_PQ_MuliMedia_Info *pstPQMMInfo)
4206 {
4207 #ifdef TRACE_DBG
4208 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4209 #endif
4210 if (pu32PQInst == NULL)
4211 {
4212 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4213 return ;
4214 }
4215
4216 stPQ_Set_MultiMediaInfo PQArgs;
4217 PQArgs.eWindow = eWindow;
4218 PQArgs.pstPQMMInfo = pstPQMMInfo;
4219 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_MULTIMEDIAINFO, (void*)&PQArgs) != 0)
4220 {
4221 printf("Obtain PQ engine fail\n");
4222 return;
4223 }
4224 else
4225 {
4226 return;
4227 }
4228 }
4229
MDrv_PQ_Set_VDInfo_U2(void * pInstance,PQ_WIN eWindow,MS_PQ_Vd_Info * pstPQVDInfo)4230 void MDrv_PQ_Set_VDInfo_U2(void* pInstance,PQ_WIN eWindow, MS_PQ_Vd_Info *pstPQVDInfo)
4231 {
4232 memcpy(&_stVD_Info[eWindow], pstPQVDInfo, sizeof(MS_PQ_Vd_Info));
4233
4234 PQINFO_DBG(printf("PQ VD Info:Win=%u, SigType=%u, bSCARTRGB=%u, VIFIn=%u\n",
4235 eWindow,
4236 _stVD_Info[eWindow].enVideoStandard,
4237 _stVD_Info[eWindow].bIsSCART_RGB,
4238 _stVD_Info[eWindow].bIsVIFIN));
4239
4240 }
MDrv_PQ_Set_VDInfo(PQ_WIN eWindow,MS_PQ_Vd_Info * pstPQVDInfo)4241 void MDrv_PQ_Set_VDInfo(PQ_WIN eWindow, MS_PQ_Vd_Info *pstPQVDInfo)
4242 {
4243 #ifdef TRACE_DBG
4244 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4245 #endif
4246 if (pu32PQInst == NULL)
4247 {
4248 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4249 return ;
4250 }
4251
4252 stPQ_Set_VDInfo PQArgs;
4253 PQArgs.eWindow = eWindow;
4254 PQArgs.pstPQVDInfo = pstPQVDInfo;
4255 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_VDINFO, (void*)&PQArgs) != 0)
4256 {
4257 printf("Obtain PQ engine fail\n");
4258 return;
4259 }
4260 else
4261 {
4262 return;
4263 }
4264 }
4265
MDrv_PQ_Set_ModeInfo_U2(void * pInstance,PQ_WIN eWindow,PQ_INPUT_SOURCE_TYPE enInputSourceType,MS_PQ_Mode_Info * pstPQModeInfo)4266 void MDrv_PQ_Set_ModeInfo_U2(void* pInstance,PQ_WIN eWindow, PQ_INPUT_SOURCE_TYPE enInputSourceType, MS_PQ_Mode_Info *pstPQModeInfo)
4267 {
4268
4269 memcpy(&_stMode_Info[eWindow], pstPQModeInfo, sizeof(MS_PQ_Mode_Info));
4270
4271 //printf("PQ Set Mode Info: %s, Src=%x\n", (eWindow)?("SubWin"):("MainWin"), enInputSourceType);
4272
4273 if(QM_IsSourceYPbPr(enInputSourceType))
4274 {
4275 if(((QM_H_Size_Check_x1(pstPQModeInfo->u16input_hsize, 720)) ||
4276 (QM_H_Size_Check_x2(pstPQModeInfo->u16input_hsize, 720)) ||
4277 (QM_H_Size_Check_x4(pstPQModeInfo->u16input_hsize, 720)) ||
4278 (QM_H_Size_Check_x8(pstPQModeInfo->u16input_hsize, 720))) &&
4279 (pstPQModeInfo->u16input_vsize < 500) &&
4280 (pstPQModeInfo->u16input_vfreq < 650))
4281 {
4282 _u8ModeIndex[eWindow] = (pstPQModeInfo->bInterlace) ?
4283 PQ_MD_720x480_60I :
4284 PQ_MD_720x480_60P;
4285
4286 }
4287 else if(((QM_H_Size_Check_x1(pstPQModeInfo->u16input_hsize, 720)) ||
4288 (QM_H_Size_Check_x2(pstPQModeInfo->u16input_hsize, 720)) ||
4289 (QM_H_Size_Check_x4(pstPQModeInfo->u16input_hsize, 720)) ||
4290 (QM_H_Size_Check_x8(pstPQModeInfo->u16input_hsize, 720))) &&
4291 (pstPQModeInfo->u16input_vsize < 600) &&
4292 (pstPQModeInfo->u16input_vfreq < 550))
4293 {
4294 _u8ModeIndex[eWindow] = (pstPQModeInfo->bInterlace) ?
4295 PQ_MD_720x576_50I :
4296 PQ_MD_720x576_50P;
4297 }
4298 else if(((QM_H_Size_Check_x1(pstPQModeInfo->u16input_hsize, 1280)) ||
4299 (QM_H_Size_Check_x2(pstPQModeInfo->u16input_hsize, 1280)) ||
4300 (QM_H_Size_Check_x4(pstPQModeInfo->u16input_hsize, 1280)) ||
4301 (QM_H_Size_Check_x8(pstPQModeInfo->u16input_hsize, 1280))) &&
4302 (pstPQModeInfo->u16input_vsize < 800) &&
4303 (pstPQModeInfo->bInterlace == FALSE))
4304 {
4305 _u8ModeIndex[eWindow] = (pstPQModeInfo->u16input_vfreq < 550) ?
4306 PQ_MD_1280x720_50P :
4307 PQ_MD_1280x720_60P;
4308
4309 }
4310 else if(((QM_H_Size_Check_x1(pstPQModeInfo->u16input_hsize, 1920)) ||
4311 (QM_H_Size_Check_x2(pstPQModeInfo->u16input_hsize, 1920)) ||
4312 (QM_H_Size_Check_x4(pstPQModeInfo->u16input_hsize, 1920)) ||
4313 (QM_H_Size_Check_x8(pstPQModeInfo->u16input_hsize, 1920))) &&
4314 (pstPQModeInfo->u16input_vsize < 1100))
4315 {
4316 if(pstPQModeInfo->bInterlace)
4317 {
4318 _u8ModeIndex[eWindow] = (pstPQModeInfo->u16input_vfreq < 550) ?
4319 PQ_MD_1920x1080_50I :
4320 PQ_MD_1920x1080_60I;
4321 }
4322 else
4323 {
4324 _u8ModeIndex[eWindow] = (pstPQModeInfo->u16input_vfreq < 245) ? PQ_MD_1920x1080_24P :
4325 (pstPQModeInfo->u16input_vfreq < 270) ? PQ_MD_1920x1080_25P :
4326 (pstPQModeInfo->u16input_vfreq < 350) ? PQ_MD_1920x1080_30P :
4327 (pstPQModeInfo->u16input_vfreq < 550) ? PQ_MD_1920x1080_50P :
4328 PQ_MD_1920x1080_60P;
4329
4330 }
4331 }
4332 else
4333 {
4334 _u8ModeIndex[eWindow] = PQ_MD_720x576_50I;
4335 }
4336 }
4337 else if(QM_IsSourceHDMI(enInputSourceType))
4338 {
4339 if((pstPQModeInfo->u16input_hsize < 1500) &&
4340 (pstPQModeInfo->u16input_vsize < 500) &&
4341 (pstPQModeInfo->u16input_vfreq < 650))
4342 {
4343 _u8ModeIndex[eWindow] = (pstPQModeInfo->bInterlace) ?
4344 PQ_MD_720x480_60I :
4345 PQ_MD_720x480_60P;
4346
4347 }
4348 else if((pstPQModeInfo->u16input_hsize < 1500) &&
4349 (pstPQModeInfo->u16input_vsize < 600) &&
4350 (pstPQModeInfo->u16input_vfreq < 550))
4351 {
4352 _u8ModeIndex[eWindow] = (pstPQModeInfo->bInterlace) ?
4353 PQ_MD_720x576_50I :
4354 PQ_MD_720x576_50P;
4355 }
4356 else if((pstPQModeInfo->u16input_hsize < 1300) &&
4357 (pstPQModeInfo->u16input_vsize < 800) &&
4358 (pstPQModeInfo->bInterlace == FALSE))
4359 {
4360 _u8ModeIndex[eWindow] = (pstPQModeInfo->u16input_vfreq < 550) ?
4361 PQ_MD_1280x720_50P :
4362 PQ_MD_1280x720_60P;
4363
4364 }
4365 else if((pstPQModeInfo->u16input_hsize < 1930) &&
4366 (pstPQModeInfo->u16input_vsize < 1100))
4367 {
4368 if(pstPQModeInfo->bInterlace)
4369 {
4370 _u8ModeIndex[eWindow] = (pstPQModeInfo->u16input_vfreq < 550) ?
4371 PQ_MD_1920x1080_50I :
4372 PQ_MD_1920x1080_60I;
4373 }
4374 else
4375 {
4376 _u8ModeIndex[eWindow] = (pstPQModeInfo->u16input_vfreq < 245) ? PQ_MD_1920x1080_24P :
4377 (pstPQModeInfo->u16input_vfreq < 270) ? PQ_MD_1920x1080_25P :
4378 (pstPQModeInfo->u16input_vfreq < 350) ? PQ_MD_1920x1080_30P :
4379 (pstPQModeInfo->u16input_vfreq < 550) ? PQ_MD_1920x1080_50P :
4380 PQ_MD_1920x1080_60P;
4381
4382 }
4383 }
4384 else if(pstPQModeInfo->u16input_hsize < 1350 &&
4385 pstPQModeInfo->u16input_vsize < 1550)
4386 {
4387 //special handle 1280X1470p
4388 {
4389 _u8ModeIndex[eWindow] = (pstPQModeInfo->u16input_vfreq < 550) ? PQ_MD_1280x720_50P :
4390 PQ_MD_1280x720_60P;
4391 }
4392 }
4393 else if(pstPQModeInfo->u16input_hsize < 1930 &&
4394 pstPQModeInfo->u16input_vsize < 2300)
4395 {
4396 //special handle 1920X2205p
4397 if(pstPQModeInfo->bInterlace)
4398 {
4399 _u8ModeIndex[eWindow] = (pstPQModeInfo->u16input_vfreq < 550) ?
4400 PQ_MD_1920x1080_50I :
4401 PQ_MD_1920x1080_60I;
4402 }
4403 else
4404 {
4405 _u8ModeIndex[eWindow] = (pstPQModeInfo->u16input_vfreq < 250) ? PQ_MD_1920x1080_24P :
4406 (pstPQModeInfo->u16input_vfreq < 350) ? PQ_MD_1920x1080_30P :
4407 (pstPQModeInfo->u16input_vfreq < 550) ? PQ_MD_1920x1080_50P :
4408 PQ_MD_1920x1080_60P;
4409
4410 }
4411 }
4412 else
4413 {
4414 _u8ModeIndex[eWindow] = PQ_MD_1920x1080_60P;
4415 }
4416 }
4417 else
4418 {
4419 _u8ModeIndex[eWindow] = PQ_MD_Num;
4420 }
4421
4422 if(QM_IsSourceYPbPr(enInputSourceType) || QM_IsSourceHDMI(enInputSourceType))
4423 {
4424 if(_u8ModeIndex[eWindow] <= (MS_U8)PQ_MD_720x576_50P)
4425 _gIsSrcHDMode[eWindow] = 0;
4426 else
4427 _gIsSrcHDMode[eWindow] = 1;
4428
4429 }
4430 else if(QM_IsSourceVD(enInputSourceType))
4431 {
4432 _gIsSrcHDMode[eWindow] = 0;
4433 }
4434 else
4435 {
4436 if(pstPQModeInfo->u16input_hsize >= 1200)
4437 _gIsSrcHDMode[eWindow] = 1;
4438 else
4439 _gIsSrcHDMode[eWindow] = 0;
4440 }
4441
4442 PQINFO_DBG(
4443 printf("PQ ModeInfo:%d input(%d, %d), disp(%d, %d), ModeIdx=%d, FBL=%u, Interlace=%u, InV=%u, OutV=%u, inVtt=%u\n",
4444 eWindow,
4445 _stMode_Info[eWindow].u16input_hsize,
4446 _stMode_Info[eWindow].u16input_vsize,
4447 _stMode_Info[eWindow].u16display_hsize,
4448 _stMode_Info[eWindow].u16display_vsize,
4449 _u8ModeIndex[eWindow],
4450 _stMode_Info[eWindow].bFBL,
4451 _stMode_Info[eWindow].bInterlace,
4452 _stMode_Info[eWindow].u16input_vfreq,
4453 _stMode_Info[eWindow].u16ouput_vfreq,
4454 _stMode_Info[eWindow].u16input_vtotal);
4455 );
4456 }
MDrv_PQ_Set_ModeInfo(PQ_WIN eWindow,PQ_INPUT_SOURCE_TYPE enInputSourceType,MS_PQ_Mode_Info * pstPQModeInfo)4457 void MDrv_PQ_Set_ModeInfo(PQ_WIN eWindow, PQ_INPUT_SOURCE_TYPE enInputSourceType, MS_PQ_Mode_Info *pstPQModeInfo)
4458 {
4459 if (pu32PQInst == NULL)
4460 {
4461 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4462 {
4463 printf("UtopiaOpen PQ failed\n");
4464 return;
4465 }
4466 }
4467
4468 stPQ_Set_ModeInfo PQArgs;
4469 PQArgs.eWindow = eWindow;
4470 PQArgs.enInputSourceType = enInputSourceType;
4471 PQArgs.pstPQModeInfo = pstPQModeInfo;
4472 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_MODEINFO, (void*)&PQArgs) != 0)
4473 {
4474 printf("Obtain PQ engine fail\n");
4475 return;
4476 }
4477 else
4478 {
4479 return;
4480 }
4481 }
4482
MDrv_PQ_SetHDMIInfo_U2(void * pInstance,PQ_WIN eWindow,const MS_PQ_Hdmi_Info * const pstPQHDMIInfo)4483 void MDrv_PQ_SetHDMIInfo_U2(void* pInstance,PQ_WIN eWindow, const MS_PQ_Hdmi_Info* const pstPQHDMIInfo)
4484 {
4485 _stHDMI_Info[eWindow].bIsHDMI = pstPQHDMIInfo->bIsHDMI;
4486 _stHDMI_Info[eWindow].enColorFmt = pstPQHDMIInfo->enColorFmt;
4487
4488 PQINFO_DBG(printf("PQ HDMI, bHDMI=%u, colorfmt=%u\n",
4489 _stHDMI_Info[eWindow].bIsHDMI,
4490 _stHDMI_Info[eWindow].enColorFmt));
4491 }
MDrv_PQ_SetHDMIInfo(PQ_WIN eWindow,const MS_PQ_Hdmi_Info * const pstPQHDMIInfo)4492 void MDrv_PQ_SetHDMIInfo(PQ_WIN eWindow, const MS_PQ_Hdmi_Info* const pstPQHDMIInfo)
4493 {
4494 #ifdef TRACE_DBG
4495 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4496 #endif
4497 if (pu32PQInst == NULL)
4498 {
4499 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4500 return ;
4501 }
4502
4503 stPQ_SetHDMIInfo PQArgs;
4504 PQArgs.eWindow = eWindow;
4505 PQArgs.pstPQHDMIInfo.bIsHDMI = pstPQHDMIInfo->bIsHDMI;
4506 PQArgs.pstPQHDMIInfo.bIsHDMIPC = pstPQHDMIInfo->bIsHDMIPC;
4507 PQArgs.pstPQHDMIInfo.enColorFmt = pstPQHDMIInfo->enColorFmt;
4508 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_HDMIINFO, (void*)&PQArgs) != 0)
4509 {
4510 printf("Obtain PQ engine fail\n");
4511 return;
4512 }
4513 else
4514 {
4515 return;
4516 }
4517 }
4518
MDrv_PQ_SetHDMI_PC_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bIsTrue)4519 void MDrv_PQ_SetHDMI_PC_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bIsTrue)
4520 {
4521 _stHDMI_Info[eWindow].bIsHDMIPC = bIsTrue;
4522 }
MDrv_PQ_SetHDMI_PC(PQ_WIN eWindow,MS_BOOL bIsTrue)4523 void MDrv_PQ_SetHDMI_PC(PQ_WIN eWindow, MS_BOOL bIsTrue)
4524 {
4525 #ifdef TRACE_DBG
4526 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4527 #endif
4528 if (pu32PQInst == NULL)
4529 {
4530 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4531 return ;
4532 }
4533
4534 stPQ_SetHDMI_PC PQArgs;
4535 PQArgs.eWindow = eWindow;
4536 PQArgs.bIsTrue = bIsTrue;
4537 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_HDMI_PC, (void*)&PQArgs) != 0)
4538 {
4539 printf("Obtain PQ engine fail\n");
4540 return;
4541 }
4542 else
4543 {
4544 return;
4545 }
4546 }
4547
MDrv_PQ_GetHDMI_PC_Status_U2(void * pInstance,PQ_WIN eWindow)4548 MS_BOOL MDrv_PQ_GetHDMI_PC_Status_U2(void* pInstance,PQ_WIN eWindow)
4549 {
4550 return _stHDMI_Info[eWindow].bIsHDMIPC;
4551 }
MDrv_PQ_GetHDMI_PC_Status(PQ_WIN eWindow)4552 MS_BOOL MDrv_PQ_GetHDMI_PC_Status(PQ_WIN eWindow)
4553 {
4554 #ifdef TRACE_DBG
4555 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4556 #endif
4557 if (pu32PQInst == NULL)
4558 {
4559 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4560 return FALSE;
4561 }
4562
4563 stPQ_GetHDMI_PC_Status PQArgs;
4564 PQArgs.eWindow = eWindow;
4565 PQArgs.bReturnValue = FALSE;
4566 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_HDMI_PC_STATUS, (void*)&PQArgs) != 0)
4567 {
4568 printf("Obtain PQ engine fail\n");
4569 return FALSE;
4570 }
4571 else
4572 {
4573 return PQArgs.bReturnValue;
4574 }
4575 }
4576
MDrv_PQ_DesideSrcType_U2(void * pInstance,PQ_WIN eWindow,PQ_INPUT_SOURCE_TYPE enInputSourceType)4577 void MDrv_PQ_DesideSrcType_U2(void* pInstance,PQ_WIN eWindow, PQ_INPUT_SOURCE_TYPE enInputSourceType)
4578 {
4579
4580 _enInputSourceType[eWindow] = enInputSourceType;
4581 _u16PQSrcType[eWindow] = QM_InputSourceToIndex(pInstance, eWindow, enInputSourceType);
4582 _u16PQSrcType_DBK_Detect[eWindow] = _u16PQSrcType[eWindow]; //For Auto_DBK SW driver used
4583 PQTAB_DBG(printf("[PQ_DesideSrcType] window=%u, enInputSrcType=%u, SrcType=%u\n",
4584 eWindow, enInputSourceType, _u16PQSrcType[eWindow]));
4585
4586 #if(ENABLE_PQ_LOAD_TABLE_INFO)
4587
4588 if(eWindow == PQ_MAIN_WINDOW)
4589 {
4590 if(gbPQBinEnable)
4591 {
4592
4593 }
4594 else
4595 {
4596 MDrv_PQ_Set_LoadTableInfo_SrcType(MAIN,pInstance, _u16PQSrcType[eWindow]);
4597 MDrv_PQ_Set_LoadTableInfo_SrcType(MAINEX,pInstance, _u16PQSrcType[eWindow]);
4598 }
4599 }
4600 #if PQ_ENABLE_PIP
4601 else if(eWindow == PQ_SUB_WINDOW)
4602 {
4603 if(gbPQBinEnable)
4604 {
4605
4606 }
4607 else
4608 {
4609 MDrv_PQ_Set_LoadTableInfo_SrcType(SUB,pInstance, _u16PQSrcType[eWindow]);
4610 MDrv_PQ_Set_LoadTableInfo_SrcType(SUBEX,pInstance, _u16PQSrcType[eWindow]);
4611 }
4612 }
4613 #endif
4614
4615 #endif //#if(ENABLE_PQ_LOAD_TABLE_INFO)
4616
4617 }
MDrv_PQ_DesideSrcType(PQ_WIN eWindow,PQ_INPUT_SOURCE_TYPE enInputSourceType)4618 void MDrv_PQ_DesideSrcType(PQ_WIN eWindow, PQ_INPUT_SOURCE_TYPE enInputSourceType)
4619 {
4620 if (pu32PQInst == NULL)
4621 {
4622 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4623 {
4624 printf("UtopiaOpen PQ failed\n");
4625 return;
4626 }
4627 }
4628
4629 stPQ_DesideSrcType PQArgs;
4630 PQArgs.eWindow = eWindow;
4631 PQArgs.enInputSourceType = enInputSourceType;
4632 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_DESIDE_SRC_TYPE, (void*)&PQArgs) != 0)
4633 {
4634 printf("Obtain PQ engine fail\n");
4635 return;
4636 }
4637 else
4638 {
4639 return;
4640 }
4641 }
4642
MDrv_PQ_GetInputSourceType_U2(void * pInstance,PQ_WIN eWindow)4643 PQ_INPUT_SOURCE_TYPE MDrv_PQ_GetInputSourceType_U2(void* pInstance,PQ_WIN eWindow)
4644 {
4645 return _enInputSourceType[eWindow];
4646 }
MDrv_PQ_GetInputSourceType(PQ_WIN eWindow)4647 PQ_INPUT_SOURCE_TYPE MDrv_PQ_GetInputSourceType(PQ_WIN eWindow)
4648 {
4649 #ifdef TRACE_DBG
4650 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4651 #endif
4652 if (pu32PQInst == NULL)
4653 {
4654 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4655 return FALSE;
4656 }
4657
4658 stPQ_GetInputSourceType PQArgs;
4659 PQArgs.eWindow = eWindow;
4660 PQArgs.bReturnValue = PQ_INPUT_SOURCE_NONE;
4661 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_INPUTSOURCE_TYPE, (void*)&PQArgs) != 0)
4662 {
4663 printf("Obtain PQ engine fail\n");
4664 return PQ_INPUT_SOURCE_NONE;
4665 }
4666 else
4667 {
4668 return PQArgs.bReturnValue;
4669 }
4670 }
4671
MDrv_PQ_GetSrcType_U2(void * pInstance,PQ_WIN eWindow)4672 MS_U16 MDrv_PQ_GetSrcType_U2(void* pInstance,PQ_WIN eWindow)
4673 {
4674 return _u16PQSrcType[eWindow];
4675 }
MDrv_PQ_GetSrcType(PQ_WIN eWindow)4676 MS_U16 MDrv_PQ_GetSrcType(PQ_WIN eWindow)
4677 {
4678 #ifdef TRACE_DBG
4679 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4680 #endif
4681 if (pu32PQInst == NULL)
4682 {
4683 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4684 return FALSE;
4685 }
4686
4687 stPQ_GetSrcType PQArgs;
4688 PQArgs.eWindow = eWindow;
4689 PQArgs.u16Ret = 0;
4690 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_SRC_TYPE, (void*)&PQArgs) != 0)
4691 {
4692 printf("Obtain PQ engine fail\n");
4693 return 0;
4694 }
4695 else
4696 {
4697 return PQArgs.u16Ret;
4698 }
4699 }
4700
4701
MDrv_PQ_GetDelayTimeByMemc_U2(void * pInstance,SCALER_WIN eWindow,MS_U32 u32MemcFrameDelay)4702 MS_U16 MDrv_PQ_GetDelayTimeByMemc_U2(void* pInstance, SCALER_WIN eWindow, MS_U32 u32MemcFrameDelay)
4703 {
4704 MS_U8 u8FrameNum=0;
4705 MS_U8 u8WRBankMappingNum=0;
4706 MS_U8 u8PQDelayCountNum=u8PQDelayCount;
4707
4708 u8FrameNum = MApi_XC_Get_FrameNumFactor(eWindow);
4709 u8WRBankMappingNum = MApi_XC_GetWRBankMappingNum(eWindow);
4710
4711
4712 if(u8FrameNum > (u8PQDelayCount +u8WRBankMappingNum ))
4713 {
4714 u8PQDelayCountNum = u8PQDelayCount +u8WRBankMappingNum;
4715 }
4716 else
4717 {
4718 u8PQDelayCountNum = u8FrameNum;
4719 }
4720
4721 XC_INITMISC sXC_Init_Misc;
4722 memset(&sXC_Init_Misc, 0, sizeof(XC_INITMISC));
4723 MApi_XC_GetMISCStatus(&sXC_Init_Misc);
4724
4725 if ((QM_GetInputVFreq(eWindow) != 0) && (QM_GetInputVFreq(eWindow) != 1))
4726 {
4727
4728 if ( sXC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_FRC_INSIDE)
4729 {
4730 _u16PQDelyaTime = (u8PQDelayCountNum + u32MemcFrameDelay) * ((10000 + (QM_GetInputVFreq(eWindow)/2))/QM_GetInputVFreq(eWindow)); // frame duration is (1 second/input V freq)
4731
4732 }
4733 else
4734 {
4735 _u16PQDelyaTime = u8PQDelayCountNum * ((10000 + (QM_GetInputVFreq(eWindow)/2))/QM_GetInputVFreq(eWindow)); // frame duration is (1 second/input V freq)
4736 }
4737 }
4738 else
4739 {
4740 _u16PQDelyaTime = u8PQDelayCountNum * 20; // default keep original rule, use 20ms as frame duration
4741 }
4742 return _u16PQDelyaTime;
4743 }
4744
MDrv_PQ_GetDelayTimeByMemc(SCALER_WIN eWindow,MS_U32 u32MemcFrameDelay)4745 MS_U16 MDrv_PQ_GetDelayTimeByMemc(SCALER_WIN eWindow, MS_U32 u32MemcFrameDelay)
4746 {
4747 #ifdef TRACE_DBG
4748 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4749 #endif
4750 if (pu32PQInst == NULL)
4751 {
4752 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4753 return FALSE;
4754 }
4755
4756 stPQ_GetDelayTimeByMemc PQArgs;
4757 PQArgs.eWindow = eWindow;
4758 PQArgs.u32MemcFrameDelay = u32MemcFrameDelay;
4759 PQArgs.u16Ret = 0;
4760 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_DELAY_TIME_BY_MEMC, (void*)&PQArgs) != 0)
4761 {
4762 printf("Obtain PQ engine fail\n");
4763 return 0;
4764 }
4765 else
4766 {
4767 return PQArgs.u16Ret;
4768 }
4769 }
4770
MDrv_PQ_GetDelayTime_U2(void * pInstance,SCALER_WIN eWindow)4771 MS_U16 MDrv_PQ_GetDelayTime_U2(void* pInstance,SCALER_WIN eWindow)
4772 {
4773 MS_U8 u8FrameNum=0;
4774 MS_U8 u8WRBankMappingNum=0;
4775 MS_U8 u8PQDelayCountNum=u8PQDelayCount;
4776
4777 u8FrameNum = MApi_XC_Get_FrameNumFactor(eWindow);
4778 u8WRBankMappingNum = MApi_XC_GetWRBankMappingNum(eWindow);
4779
4780 if(u8FrameNum > (u8PQDelayCount +u8WRBankMappingNum ))
4781 {
4782 u8PQDelayCountNum = u8PQDelayCount +u8WRBankMappingNum;
4783 }
4784 else
4785 {
4786 u8PQDelayCountNum = u8FrameNum;
4787 }
4788
4789 //Because write memory not just in vsync blanking, so we add one vsync time for avoid garbage.
4790 u8PQDelayCountNum += 1;
4791
4792 XC_INITMISC sXC_Init_Misc;
4793 memset(&sXC_Init_Misc, 0, sizeof(XC_INITMISC));
4794 MApi_XC_GetMISCStatus(&sXC_Init_Misc);
4795
4796 XC_ApiStatusEx sXC_ApiStatusEx;
4797 memset(&sXC_ApiStatusEx, 0, sizeof(XC_ApiStatusEx));
4798 sXC_ApiStatusEx.u16ApiStatusEX_Length = sizeof(XC_ApiStatusEx);
4799 sXC_ApiStatusEx.u32ApiStatusEx_Version = API_STATUS_EX_VERSION;
4800 MApi_XC_GetStatusEx(&sXC_ApiStatusEx, eWindow);
4801
4802 MS_BOOL bIs120Hz = FALSE;
4803 if(sXC_ApiStatusEx.u32ApiStatusEx_Version >= 9)
4804 {
4805 bIs120Hz = IsVBY1_16LANE(sXC_ApiStatusEx.u16PanelInterfaceType);
4806 }
4807
4808 if ((QM_GetInputVFreq(eWindow) != 0) && (QM_GetInputVFreq(eWindow) != 1))
4809 {
4810 if (( sXC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_FRC_INSIDE) &&(sXC_ApiStatusEx.bFRCEnabled == true)&&(bIs120Hz != TRUE))
4811 {
4812 _u16PQDelyaTime = (u8PQDelayCountNum + 5) * ((10000 + (QM_GetInputVFreq(eWindow)/2))/QM_GetInputVFreq(eWindow)); // frame duration is (1 second/input V freq)
4813 }
4814 else
4815 {
4816 _u16PQDelyaTime = u8PQDelayCountNum * ((10000 + (QM_GetInputVFreq(eWindow)/2))/QM_GetInputVFreq(eWindow)); // frame duration is (1 second/input V freq)
4817 }
4818 }
4819 else
4820 _u16PQDelyaTime = u8PQDelayCountNum * 20; // default keep original rule, use 20ms as frame duration
4821
4822 return _u16PQDelyaTime;
4823 }
MDrv_PQ_GetDelayTime(SCALER_WIN eWindow)4824 MS_U16 MDrv_PQ_GetDelayTime(SCALER_WIN eWindow)
4825 {
4826 #ifdef TRACE_DBG
4827 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4828 #endif
4829 if (pu32PQInst == NULL)
4830 {
4831 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4832 return FALSE;
4833 }
4834
4835 stPQ_GetDelayTime PQArgs;
4836 PQArgs.eWindow=eWindow;
4837 PQArgs.u16Ret = 0;
4838 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_DELAY_TIME, (void*)&PQArgs) != 0)
4839 {
4840 printf("Obtain PQ engine fail\n");
4841 return 0;
4842 }
4843 else
4844 {
4845 return PQArgs.u16Ret;
4846 }
4847 }
MDrv_PQ_GetQmapExecutor_U2(void * pInstance,MS_PQ_FUNCTION_TYPE eFunctionType)4848 MS_PQ_EXECUTOR MDrv_PQ_GetQmapExecutor_U2(void* pInstance,MS_PQ_FUNCTION_TYPE eFunctionType)
4849 {
4850 MS_PQ_EXECUTOR enChipExecutor = EN_PQ_EXECUTOR_SOC;
4851
4852 if( REG_CHIP_EXECUTOR_DUMMY != 0)
4853 {
4854 MS_U8 u8ExecutorDummy = (MS_U8)MApi_XC_R2BYTEMSK(REG_CHIP_EXECUTOR_DUMMY, 0xFF);
4855 MS_U8 u8ExecutorKeyDummy = (MS_U8)MApi_XC_R2BYTEMSK(REG_CHIP_EXECUTOR_KEY_DUMMY, 0xFF);
4856
4857 if(u8ExecutorKeyDummy==REG_CHIP_EXECUTOR_KEY)
4858 {
4859 switch (eFunctionType)
4860 {
4861 case EN_PQ_ACE:
4862 {
4863 if(u8ExecutorDummy && BIT(0))
4864 enChipExecutor= EN_PQ_EXECUTOR_BACKEND;
4865 break;
4866 }
4867 case EN_PQ_COLOR_TEMPERATURE:
4868 {
4869 if(u8ExecutorDummy && BIT(1))
4870 enChipExecutor= EN_PQ_EXECUTOR_BACKEND;
4871 break;
4872 }
4873 case EN_PQ_NOISE_REDUCTION:
4874 {
4875 if(u8ExecutorDummy && BIT(2))
4876 enChipExecutor= EN_PQ_EXECUTOR_BACKEND;
4877 break;
4878 }
4879 case EN_PQ_MPEG_NOISE_REDUCTION:
4880 {
4881 if(u8ExecutorDummy && BIT(3))
4882 enChipExecutor= EN_PQ_EXECUTOR_BACKEND;
4883 break;
4884 }
4885 case EN_PQ_DYNAMIC_CONTRAST:
4886 {
4887 if(u8ExecutorDummy && BIT(4))
4888 enChipExecutor= EN_PQ_EXECUTOR_BACKEND;
4889 break;
4890 }
4891 default:
4892 enChipExecutor= EN_PQ_NONE;
4893 break;
4894 }
4895 }
4896 }
4897 return enChipExecutor;
4898 }
MDrv_PQ_GetQmapExecutor(MS_PQ_FUNCTION_TYPE eFunctionType)4899 MS_PQ_EXECUTOR MDrv_PQ_GetQmapExecutor(MS_PQ_FUNCTION_TYPE eFunctionType)
4900 {
4901 #ifdef TRACE_DBG
4902 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4903 #endif
4904 if (pu32PQInst == NULL)
4905 {
4906 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4907 return FALSE;
4908 }
4909
4910 stPQ_GetQmapExecutor PQArgs;
4911 PQArgs.bReturnValue = EN_PQ_NONE;
4912 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_QMAP_EXECUTOR, (void*)&PQArgs) != 0)
4913 {
4914 printf("Obtain PQ engine fail\n");
4915 return EN_PQ_NONE;
4916 }
4917 else
4918 {
4919 return PQArgs.bReturnValue;
4920 }
4921 }
4922 // if not HSD case, ignore return value
_MDrv_PQ_LoadScalingTable(void * pInstance,PQ_WIN eWindow,MS_U8 eXRuleType,MS_U8 u8XRuleIP,MS_BOOL bPreV_ScalingDown,MS_BOOL bInterlace,MS_BOOL bColorSpaceYUV,MS_U16 u16InputSize,MS_U16 u16SizeAfterScaling)4923 static MS_BOOL _MDrv_PQ_LoadScalingTable(
4924 void* pInstance,
4925 PQ_WIN eWindow,
4926 MS_U8 eXRuleType,
4927 MS_U8 u8XRuleIP,
4928 MS_BOOL bPreV_ScalingDown,
4929 MS_BOOL bInterlace,
4930 MS_BOOL bColorSpaceYUV,
4931 MS_U16 u16InputSize,
4932 MS_U16 u16SizeAfterScaling)
4933 {
4934 MS_U32 u32Ratio;
4935 MS_U16 u16IPIdx;
4936 #if PQ_ENABLE_PIP
4937 MS_U16 u16SFilter = 0;
4938 #endif
4939
4940 MS_U16 u16TabIdx = gbPQBinEnable == 0 ? PQ_IP_NULL : PQ_BIN_IP_NULL;
4941 MS_U8 u8XRuleIdx = 0xFF;
4942
4943 if(u16InputSize == 0)
4944 u32Ratio = 2000;
4945 else
4946 u32Ratio = ((MS_U32) u16SizeAfterScaling * 1000) / u16InputSize;
4947
4948 u16IPIdx = MDrv_PQ_GetXRuleIPIndex(pInstance, eWindow, eXRuleType, u8XRuleIP);
4949 SRULE_DBG(printf("SRuleIP=%d, IPIdx=%d, input=%d, output=%d, ratio=%td, ",
4950 (MS_U16)u8XRuleIP, (MS_U16)u16IPIdx,
4951 u16InputSize, u16SizeAfterScaling,(ptrdiff_t) u32Ratio));
4952
4953 if(bPreV_ScalingDown && bInterlace)
4954 {
4955 u8XRuleIdx = PQ_HSDRule_PreV_ScalingDown_Interlace_Main;
4956 u16TabIdx = MDrv_PQ_GetXRuleTableIndex(pInstance, eWindow, (MS_U16)eXRuleType, (MS_U16)u8XRuleIdx, (MS_U16)u8XRuleIP);
4957 }
4958 else if(bPreV_ScalingDown && (!bInterlace))
4959 {
4960 u8XRuleIdx = PQ_HSDRule_PreV_ScalingDown_Progressive_Main;
4961 u16TabIdx = MDrv_PQ_GetXRuleTableIndex(pInstance, eWindow, (MS_U16)eXRuleType, (MS_U16)u8XRuleIdx, (MS_U16)u8XRuleIP);
4962 }
4963
4964
4965 if(((gbPQBinEnable == 0) && (u16TabIdx != PQ_IP_NULL)) ||
4966 ((gbPQBinEnable == 1) && (u16TabIdx != PQ_BIN_IP_NULL)))
4967 {
4968
4969 SRULE_DBG(printf("u8XRuleIdx: PreV down, interlace:%u", bInterlace));
4970 SRULE_DBG(printf("(a)tabidx=%u\n", (MS_U16)u16TabIdx));
4971 }
4972
4973 if(((gbPQBinEnable == 1) && (u16TabIdx == PQ_BIN_IP_NULL)) ||
4974 ((gbPQBinEnable == 0) && (u16TabIdx == PQ_IP_NULL)))
4975 {
4976 if(u32Ratio > 1000)
4977 {
4978 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance, eWindow, u16IPIdx);
4979 SRULE_DBG(printf("u8XRuleIdx: >x1, "));
4980 SRULE_DBG(printf("(c)tabidx=%u\n", (MS_U16)u16TabIdx));
4981 }
4982 else
4983 {
4984 if(bColorSpaceYUV)
4985 {
4986 if(u32Ratio == 1000)
4987 u8XRuleIdx = PQ_HSDRule_ScalingDown_10x_YUV_Main;
4988 else if(u32Ratio >= 900)
4989 u8XRuleIdx = PQ_HSDRule_ScalingDown_09x_YUV_Main;
4990 else if(u32Ratio >= 800)
4991 u8XRuleIdx = PQ_HSDRule_ScalingDown_08x_YUV_Main;
4992 else if(u32Ratio >= 700)
4993 u8XRuleIdx = PQ_HSDRule_ScalingDown_07x_YUV_Main;
4994 else if(u32Ratio >= 600)
4995 u8XRuleIdx = PQ_HSDRule_ScalingDown_06x_YUV_Main;
4996 else if(u32Ratio >= 500)
4997 u8XRuleIdx = PQ_HSDRule_ScalingDown_05x_YUV_Main;
4998 else if(u32Ratio >= 400)
4999 u8XRuleIdx = PQ_HSDRule_ScalingDown_04x_YUV_Main;
5000 else if(u32Ratio >= 300)
5001 u8XRuleIdx = PQ_HSDRule_ScalingDown_03x_YUV_Main;
5002 else if(u32Ratio >= 200)
5003 u8XRuleIdx = PQ_HSDRule_ScalingDown_02x_YUV_Main;
5004 else if(u32Ratio >= 100)
5005 u8XRuleIdx = PQ_HSDRule_ScalingDown_01x_YUV_Main;
5006 else
5007 u8XRuleIdx = PQ_HSDRule_ScalingDown_00x_YUV_Main;
5008 }
5009 else
5010 {
5011 if(u32Ratio == 1000)
5012 u8XRuleIdx = PQ_HSDRule_ScalingDown_10x_RGB_Main;
5013 else if(u32Ratio >= 900)
5014 u8XRuleIdx = PQ_HSDRule_ScalingDown_09x_RGB_Main;
5015 else if(u32Ratio >= 800)
5016 u8XRuleIdx = PQ_HSDRule_ScalingDown_08x_RGB_Main;
5017 else if(u32Ratio >= 700)
5018 u8XRuleIdx = PQ_HSDRule_ScalingDown_07x_RGB_Main;
5019 else if(u32Ratio >= 600)
5020 u8XRuleIdx = PQ_HSDRule_ScalingDown_06x_RGB_Main;
5021 else if(u32Ratio >= 500)
5022 u8XRuleIdx = PQ_HSDRule_ScalingDown_05x_RGB_Main;
5023 else if(u32Ratio >= 400)
5024 u8XRuleIdx = PQ_HSDRule_ScalingDown_04x_RGB_Main;
5025 else if(u32Ratio >= 300)
5026 u8XRuleIdx = PQ_HSDRule_ScalingDown_03x_RGB_Main;
5027 else if(u32Ratio >= 200)
5028 u8XRuleIdx = PQ_HSDRule_ScalingDown_02x_RGB_Main;
5029 else if(u32Ratio >= 100)
5030 u8XRuleIdx = PQ_HSDRule_ScalingDown_01x_RGB_Main;
5031 else
5032 u8XRuleIdx = PQ_HSDRule_ScalingDown_00x_RGB_Main;
5033 }
5034
5035 SRULE_DBG(printf("u8XRuleIdx=%u, ", (MS_U16)u8XRuleIdx));
5036 if(u8XRuleIdx == 0xFF)
5037 {
5038 MS_ASSERT(0);
5039 return 1;
5040 }
5041
5042 u16TabIdx = MDrv_PQ_GetXRuleTableIndex(pInstance, eWindow, (MS_U16)eXRuleType, (MS_U16)u8XRuleIdx, (MS_U16)u8XRuleIP);
5043 if(((gbPQBinEnable == 1) && (u16TabIdx == PQ_BIN_IP_NULL)) ||
5044 ((gbPQBinEnable == 0) && (u16TabIdx == PQ_IP_NULL)))
5045 {
5046 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance, eWindow, u16IPIdx);
5047 SRULE_DBG(printf("(d)tabidx=%u\n", u16TabIdx));
5048 }
5049 else
5050 {
5051 SRULE_DBG(printf("(e)tabidx=%u\n", u16TabIdx));
5052 }
5053 }
5054 }
5055 if(MApi_XC_Is_SupportSWDS() == FALSE)
5056 {
5057 #if PQ_EN_DMS_SW_CTRL
5058 if((u16IPIdx == PQ_IP_DMS_V_12L_Main) && (PQ_MAIN_WINDOW == eWindow))
5059 {
5060 if(u16TabIdx == PQ_IP_DMS_V_12L_OFF_Main)
5061 {
5062 _bDMSV12L_PQConfigEn = FALSE;
5063 }
5064 else
5065 {
5066 _bDMSV12L_PQConfigEn = TRUE;
5067 }
5068 }
5069
5070 // App will call halt_subwin to disconnet sub window.
5071 // It will casue PQ display type to be PQ_DISPLAY_ONE.
5072 // But, sub window is still on and DMS_LV_12 will be set
5073 // to On in HSD rulee for main window.
5074 // For fix this issue, we need to check sub window wheter
5075 // on or off to descide DMS_LV_12 off or on.
5076
5077 //Disable DMS_V12_L
5078 // 1.VSD : V prescaling, 2. PIP, 3. FBL
5079 if((((eXRuleType == E_XRULE_VSD)&&(bPreV_ScalingDown))
5080 ||(_stMode_Info[eWindow].bFBL)
5081 || (E_XC_3D_INPUT_MODE_NONE != MApi_XC_Get_3D_Input_Mode(MAIN_WINDOW))
5082 #if PQ_ENABLE_PIP
5083 || (PQ_SUB_WINDOW == eWindow)
5084 || ((PQ_MAIN_WINDOW == eWindow) && (_bDMSV12L_PIPEn == FALSE))
5085 #endif
5086 )
5087 &&
5088 ((PQ_IP_DMS_V_12L_Main == MDrv_PQ_GetXRuleIPIndex(pInstance, eWindow, eXRuleType, u8XRuleIP))
5089 //#if PQ_ENABLE_PIP
5090 // || (PQ_IP_DMS_V_12L_Sub == MDrv_PQ_GetXRuleIPIndex(pInstance, eWindow, eXRuleType, u8XRuleIP))
5091 //#endif
5092 )
5093 )
5094 {
5095 //Disable De-Mosquito
5096 u16TabIdx = PQ_IP_DMS_V_12L_OFF_Main;
5097 u16IPIdx = PQ_IP_DMS_V_12L_Main;
5098 eWindow = PQ_MAIN_WINDOW;
5099 }
5100 #endif
5101 #if PQ_ENABLE_PIP
5102 if(((u16IPIdx == PQ_IP_SRAM3_Sub) || (u16IPIdx == PQ_IP_SRAM4_Sub) ) &&(PQ_SUB_WINDOW == eWindow)
5103 &&((E_XC_3D_OUTPUT_LINE_ALTERNATIVE == MApi_XC_Get_3D_Output_Mode())
5104 || (E_XC_3D_OUTPUT_TOP_BOTTOM == MApi_XC_Get_3D_Output_Mode())
5105 || (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF == MApi_XC_Get_3D_Output_Mode())
5106 || (E_XC_3D_OUTPUT_TOP_BOTTOM_HW == MApi_XC_Get_3D_Output_Mode())
5107 || (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF_HW == MApi_XC_Get_3D_Output_Mode())))
5108 {
5109 u16SFilter = MApi_XC_R2BYTE(REG_SC_BK23_0B_L);
5110 MApi_XC_W2BYTEMSK(REG_SC_BK23_0B_L, 0x0303 , 0xFFFF );
5111 }
5112 #endif
5113 }
5114 #if (defined (UFO_XC_DS_PQ))
5115 if(MApi_XC_Is_SupportSWDS() == TRUE)
5116 {
5117 //XC_PRINTF("\033[1;32m[%s:%d]u16PQ_GameModeIdx = %d,u16IPIdx = %d,u16TabIdx = %d\033[m\n",__FUNCTION__,__LINE__,u16PQ_GameMode_Idx,u16IPIdx,u16TabIdx);
5118 if(eWindow == PQ_MAIN_WINDOW)
5119 {
5120 switch (u16IPIdx)
5121 {
5122 case PQ_IP_MADi_Main:
5123 if (_s32LastPQIPMADiMain == (MS_S32)u16TabIdx)
5124 {
5125 return FALSE;
5126 }
5127 _s32LastPQIPMADiMain = u16TabIdx;
5128
5129 break;
5130 #if (PQ_MADI_DFK == 1)
5131 case PQ_IP_MADi_Motion_Main:
5132 if (_s32LastPQIPMADiMotMain == (MS_S32)u16TabIdx)
5133 {
5134 return FALSE;
5135 }
5136 _s32LastPQIPMADiMotMain = u16TabIdx;
5137
5138 break;
5139 #endif
5140 case PQ_IP_MemFormat_Main:
5141 if (_s32LastPQIPMemFormatMain == (MS_S32)u16TabIdx)
5142 {
5143 return FALSE;
5144 }
5145 _s32LastPQIPMemFormatMain = u16TabIdx;
5146 break;
5147 case PQ_IP_HSD_Y_Main:
5148 if (_s32LastPQIPHSDYMain == (MS_S32)u16TabIdx)
5149 {
5150 return FALSE;
5151 }
5152 _s32LastPQIPHSDYMain = u16TabIdx;
5153 break;
5154 case PQ_IP_HSD_C_Main:
5155 if (_s32LastPQIPHSDCMain == (MS_S32)u16TabIdx)
5156 {
5157 return FALSE;
5158 }
5159 _s32LastPQIPHSDCMain = u16TabIdx;
5160 break;
5161 default:
5162 break;
5163 }
5164 MDrv_PQBin_DS_GetTable(pInstance,eWindow, u16TabIdx, u16IPIdx,PQ_XC0_STD); //Only Main has X rule
5165 }
5166 }
5167 else
5168 #endif
5169 {
5170 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, u16IPIdx);
5171 }
5172
5173 if(PQ_MAIN_WINDOW == eWindow)
5174 {
5175 switch (u16IPIdx)
5176 {
5177 case PQ_IP_SRAM1_Main:
5178 _u16SRAM1 = u16TabIdx;
5179 break;
5180
5181 case PQ_IP_SRAM2_Main:
5182 _u16SRAM2 = u16TabIdx;
5183 break;
5184
5185 default:
5186 break;
5187 }
5188 }
5189
5190 #if PQ_ENABLE_PIP
5191 if(MApi_XC_Is_SupportSWDS() == FALSE)
5192 {
5193 if(((u16IPIdx == PQ_IP_SRAM3_Sub) || (u16IPIdx == PQ_IP_SRAM4_Sub)) &&(PQ_SUB_WINDOW == eWindow)
5194 &&((E_XC_3D_OUTPUT_LINE_ALTERNATIVE == MApi_XC_Get_3D_Output_Mode())
5195 || (E_XC_3D_OUTPUT_TOP_BOTTOM == MApi_XC_Get_3D_Output_Mode())
5196 || (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF == MApi_XC_Get_3D_Output_Mode())
5197 || (E_XC_3D_OUTPUT_TOP_BOTTOM_HW == MApi_XC_Get_3D_Output_Mode())
5198 || (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF_HW == MApi_XC_Get_3D_Output_Mode())))
5199 {
5200 MApi_XC_W2BYTEMSK(REG_SC_BK23_0B_L, u16SFilter , 0xFFFF );
5201 }
5202 }
5203 #endif
5204
5205 if(eXRuleType == E_XRULE_VSD)
5206 return (u16TabIdx == PQ_IP_VSD_Bilinear_Main) ; // PreVSDMode: 0:Cb, 1:Bilinear
5207 else
5208 return (u16TabIdx != PQ_IP_HSD_Y_CB_Main); // PreHSDMode - 0:Cb, 1:Adv
5209
5210 }
5211
MDrv_PQ_LoadScalingTable_U2(void * pInstance,PQ_WIN eWindow,MS_U8 eXRuleType,MS_BOOL bPreV_ScalingDown,MS_BOOL bInterlace,MS_BOOL bColorSpaceYUV,MS_U16 u16InputSize,MS_U16 u16SizeAfterScaling)5212 MS_BOOL MDrv_PQ_LoadScalingTable_U2(void* pInstance,
5213 PQ_WIN eWindow,
5214 MS_U8 eXRuleType,
5215 MS_BOOL bPreV_ScalingDown,
5216 MS_BOOL bInterlace,
5217 MS_BOOL bColorSpaceYUV,
5218 MS_U16 u16InputSize,
5219 MS_U16 u16SizeAfterScaling)
5220 {
5221 MS_BOOL bRet = 0; // default is CB mode
5222 MS_U16 i;
5223
5224 if(eXRuleType > 3)
5225 MS_ASSERT(0);
5226
5227 SRULE_DBG(printf("[PQ_LoadScalingTable] HSD/VSD/HSP/VSP:%u\n", (MS_U16)eXRuleType));
5228
5229 #if (defined (UFO_XC_DS_PQ))//PQ DS not support pre scaling
5230 if(MApi_XC_Is_SupportSWDS() == TRUE)
5231 {
5232 if((eXRuleType == E_XRULE_HSD)||(eXRuleType== E_XRULE_VSD))
5233 {
5234 return bRet;
5235 }
5236 }
5237 #endif
5238
5239 if(MApi_XC_Is_SupportSWDS() == FALSE)
5240 {
5241 #if (ENABLE_PQ_MLOAD)
5242 if(eXRuleType == E_XRULE_HSD)
5243 {
5244 MDrv_PQ_Set_MLoadEn(eWindow, TRUE);
5245 }
5246 #endif
5247 }
5248
5249 for(i = 0; i < MDrv_PQ_GetXRuleIPNum(pInstance, eWindow, (MS_U16)eXRuleType); i++)
5250 {
5251 MS_BOOL bSDMode;
5252 bSDMode = _MDrv_PQ_LoadScalingTable(pInstance,
5253 eWindow,
5254 eXRuleType,
5255 i,
5256 bPreV_ScalingDown,
5257 bInterlace,
5258 bColorSpaceYUV,
5259 u16InputSize,
5260 u16SizeAfterScaling);
5261 bRet |= (bSDMode << (1 * i));
5262 }
5263
5264 if(MApi_XC_Is_SupportSWDS() == FALSE)
5265 {
5266 #if (ENABLE_PQ_MLOAD)
5267 if(eXRuleType == E_XRULE_HSD)
5268 {
5269 MDrv_PQ_Set_MLoadEn(eWindow, FALSE);
5270 }
5271 #endif
5272 }
5273
5274 if(eXRuleType == E_XRULE_VSD)
5275 {
5276 bRet &= 0x01;
5277 }
5278 #if 0
5279 //121 filter
5280 if(((MApi_XC_Get_3D_Output_Mode() == E_XC_3D_OUTPUT_LINE_ALTERNATIVE) ||
5281 (MApi_XC_Get_3D_Output_Mode() == E_XC_3D_OUTPUT_TOP_BOTTOM) ||
5282 (MApi_XC_Get_3D_Output_Mode() == E_XC_3D_OUTPUT_TOP_BOTTOM_HW)) &&
5283 (MApi_XC_Get_3D_HW_Version() > 0)&&
5284 (MDrv_PQ_Get_SensioMode() == TRUE))
5285 {
5286 if((u16InputSize >= u16SizeAfterScaling) && (eXRuleType == E_XRULE_VSP))
5287 {
5288 //if post V down, we will load 121 filter, and when it's post scaling case
5289 //reload 121 filter's VSP_Y=SRAM_1_4Tap, VSP_C=C_SRAM_1,
5290 // SRAM1=InvSinc4Tc4p4Fc50Apass01Astop55, C_SRAM1=C121 for main-win
5291 //reload 121 filter's VSP_Y=SRAM_3_4Tap, VSP_C=C_SRAM_3,
5292 // SRAM3=InvSinc4Tc4p4Fc50Apass01Astop55, C_SRAM3=C121 for sub-win
5293 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VSP_Y_SRAM_1_4Tap_Main, PQ_IP_VSP_Y_Main);
5294 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VSP_C_C_SRAM_1_Main, PQ_IP_VSP_C_Main);
5295 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_SRAM1_InvSinc4Tc4p4Fc50Apass01Astop55_Main, PQ_IP_SRAM1_Main);
5296 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_C_SRAM1_C121_Main, PQ_IP_C_SRAM1_Main);
5297
5298 MDrv_PQ_LoadTable_U2(pInstance,PQ_SUB_WINDOW, PQ_IP_VSP_Y_SRAM_3_4Tap_Sub, PQ_IP_VSP_Y_Sub);
5299 MDrv_PQ_LoadTable_U2(pInstance,PQ_SUB_WINDOW, PQ_IP_VSP_C_C_SRAM_3_Sub, PQ_IP_VSP_C_Sub);
5300 MDrv_PQ_LoadTable_U2(pInstance,PQ_SUB_WINDOW, PQ_IP_SRAM3_InvSinc4Tc4p4Fc50Apass01Astop55_Sub, PQ_IP_SRAM3_Sub);
5301 MDrv_PQ_LoadTable_U2(pInstance,PQ_SUB_WINDOW, PQ_IP_C_SRAM3_C121_Sub, PQ_IP_C_SRAM3_Sub);
5302 }
5303 }
5304 #endif
5305
5306 return bRet;
5307 }
MDrv_PQ_LoadScalingTable(PQ_WIN eWindow,MS_U8 eXRuleType,MS_BOOL bPreV_ScalingDown,MS_BOOL bInterlace,MS_BOOL bColorSpaceYUV,MS_U16 u16InputSize,MS_U16 u16SizeAfterScaling)5308 MS_BOOL MDrv_PQ_LoadScalingTable(PQ_WIN eWindow,
5309 MS_U8 eXRuleType,
5310 MS_BOOL bPreV_ScalingDown,
5311 MS_BOOL bInterlace,
5312 MS_BOOL bColorSpaceYUV,
5313 MS_U16 u16InputSize,
5314 MS_U16 u16SizeAfterScaling)
5315 {
5316 if (pu32PQInst == NULL)
5317 {
5318 if(UtopiaOpen(MODULE_PQ, &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
5319 {
5320 printf("UtopiaOpen PQ failed\n");
5321 return FALSE;
5322 }
5323 }
5324
5325 stPQ_LoadScalingTable PQArgs;
5326 PQArgs.eWindow = eWindow;
5327 PQArgs.eXRuleType = eXRuleType;
5328 PQArgs.bPreV_ScalingDown = bPreV_ScalingDown;
5329 PQArgs.bInterlace = bInterlace;
5330 PQArgs.bColorSpaceYUV = bColorSpaceYUV;
5331 PQArgs.u16InputSize = u16InputSize;
5332 PQArgs.u16SizeAfterScaling = u16SizeAfterScaling;
5333 PQArgs.bReturnValue = FALSE;
5334 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_SCALING_TABLE, (void*)&PQArgs) != 0)
5335 {
5336 printf("Obtain PQ engine fail\n");
5337 return FALSE;
5338 }
5339 else
5340 {
5341 return PQArgs.bReturnValue;
5342 }
5343 }
5344
5345 //////////////////////////////////////////////////////////////////
5346 // set photo YUV standard
5347 //////////////////////////////////////////////////////////////////
MDrv_PQ_SetPhotoYUVStandard_U2(void * pInstance,PQ_WIN eWindow,PQ_YUV_STD enStd)5348 void MDrv_PQ_SetPhotoYUVStandard_U2(void* pInstance,PQ_WIN eWindow, PQ_YUV_STD enStd)
5349 {
5350 _enYUVStandard[eWindow] = enStd;
5351 }
MDrv_PQ_SetPhotoYUVStandard(PQ_WIN eWindow,PQ_YUV_STD enStd)5352 void MDrv_PQ_SetPhotoYUVStandard(PQ_WIN eWindow, PQ_YUV_STD enStd)
5353 {
5354 #ifdef TRACE_DBG
5355 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
5356 //return;
5357 #endif
5358 if (pu32PQInst == NULL)
5359 {
5360 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
5361 {
5362 printf("UtopiaOpen PQ failed\n");
5363 return;
5364 }
5365 }
5366
5367 stPQ_SetPhotoYUVStandard PQArgs;
5368 PQArgs.eWindow = eWindow;
5369 PQArgs.enStd = enStd;
5370 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_PHOTO_YUV_STD, (void*)&PQArgs) != 0)
5371 {
5372 printf("Obtain PQ engine fail\n");
5373 return;
5374 }
5375 else
5376 {
5377 return;
5378 }
5379 }
5380 //////////////////////////////////////////////////////////////////
5381 // set color range of input source and take effect immediately
5382 //
MDrv_PQ_SetColorRange_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bColorRange0_255)5383 void MDrv_PQ_SetColorRange_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bColorRange0_255)
5384 {
5385 _bColorRange0_255[PQ_MAIN_WINDOW] = bColorRange0_255;
5386 _bColorRange0_255[PQ_SUB_WINDOW] = bColorRange0_255;
5387 MDrv_PQ_SetCSC_U2(pInstance, eWindow, _gForceColorFmt[eWindow]);
5388 }
MDrv_PQ_SetColorRange(PQ_WIN eWindow,MS_BOOL bColorRange0_255)5389 void MDrv_PQ_SetColorRange(PQ_WIN eWindow, MS_BOOL bColorRange0_255)
5390 {
5391 #ifdef TRACE_DBG
5392 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
5393 //return;
5394 #endif
5395 if (pu32PQInst == NULL)
5396 {
5397 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
5398 {
5399 printf("UtopiaOpen PQ failed\n");
5400 return;
5401 }
5402 }
5403
5404 stPQ_SetColorRange PQArgs;
5405 PQArgs.eWindow = eWindow;
5406 PQArgs.bColorRange0_255 = bColorRange0_255;
5407 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_COLOR_RANGE, (void*)&PQArgs) != 0)
5408 {
5409 printf("Obtain PQ engine fail\n");
5410 return;
5411 }
5412 else
5413 {
5414 return;
5415 }
5416 }
5417
MDrv_PQ_Get_CSC_XRuleIdx_U2(void * pInstance,MS_BOOL * pbInputColorSpaceRGB,MS_U16 * pu16DoCSC,PQ_WIN eWindow,PQ_FOURCE_COLOR_FMT enForceColor,MS_BOOL bLoadPQTable)5418 MS_BOOL MDrv_PQ_Get_CSC_XRuleIdx_U2(void* pInstance,MS_BOOL *pbInputColorSpaceRGB,
5419 MS_U16 * pu16DoCSC,
5420 PQ_WIN eWindow,
5421 PQ_FOURCE_COLOR_FMT enForceColor,
5422 MS_BOOL bLoadPQTable)
5423 {
5424 MS_U16 u16XRuleIdx = 0, u16XRuleIP = 0;
5425 MS_U16 u16IPIdx = 0, u16TabIdx = 0;
5426 MS_U16 eXRuleType = E_XRULE_CSC;
5427 MS_BOOL bInputTypeVideo = FALSE;
5428 MS_BOOL bInputResolutionHD = _gIsSrcHDMode[eWindow];
5429
5430 _gForceColorFmt[eWindow] = enForceColor;
5431
5432 #if ENABLE_VGA_EIA_TIMING
5433 if ((QM_IsSourceVGA(_enInputSourceType[eWindow]) ||
5434 QM_IsSourceDVI_HDMIPC(_enInputSourceType[eWindow], eWindow)) && !QM_IsInterlaced(eWindow))
5435 #else
5436 if(QM_IsSourceVGA(_enInputSourceType[eWindow]) ||
5437 (QM_IsSourceDVI_HDMIPC(_enInputSourceType[eWindow], eWindow) && !QM_IsInterlaced(eWindow)))
5438 #endif
5439 {
5440 CSCRULE_DBG(printf("PC mode\n"));
5441 bInputTypeVideo = FALSE;
5442
5443 #if (PQ_ENABLE_PIP == 1)
5444 if((eWindow == PQ_SUB_WINDOW) && MDrv_PQ_GetVGASubCaseForceTo422Mode_U2(pInstance))
5445 {
5446 printf("[%s][%d] VGA in sub video case, force PC mode to video mode \n", __FUNCTION__, __LINE__);
5447 bInputTypeVideo = TRUE;
5448 }
5449 #endif
5450 }
5451 else
5452 {
5453 CSCRULE_DBG(printf("VIDEO mode\n"));
5454 bInputTypeVideo = TRUE;
5455 }
5456
5457 if(MDrv_PQ_IsForceVideoInputMode_U2(pInstance, eWindow) == TRUE)
5458 {
5459 CSCRULE_DBG(printf("Force VIDEO mode\n"));
5460 bInputTypeVideo = TRUE;
5461 }
5462
5463 if( QM_IsSourceVGA(_enInputSourceType[eWindow]) ||
5464 (QM_IsSourceDVI_HDMIPC(_enInputSourceType[eWindow],eWindow)) ||
5465 (QM_IsSourceHDMI_Video(_enInputSourceType[eWindow],eWindow) && (QM_HDMIPC_COLORRGB(eWindow))) )
5466 {
5467 CSCRULE_DBG(printf("Input RGB\n"));
5468 (*pbInputColorSpaceRGB) = TRUE;
5469 }
5470 else
5471 {
5472 CSCRULE_DBG(printf("Input YUV\n"));
5473 (*pbInputColorSpaceRGB) = FALSE;
5474 }
5475
5476 CSCRULE_DBG(printf("VIDEO mode=%u, FourColor=%u, HD%u, InputRGB=%u, _bColorRange0_255=%u\n", bInputTypeVideo, enForceColor, bInputResolutionHD, *pbInputColorSpaceRGB, _bColorRange0_255[eWindow]));
5477 if (bInputTypeVideo)
5478 {
5479 if (*pbInputColorSpaceRGB)
5480 {
5481 if (eWindow == PQ_MAIN_WINDOW)
5482 {
5483 if (bInputResolutionHD == FALSE)
5484 {
5485 if (_bColorRange0_255[eWindow])
5486 {
5487 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5488 PQ_CSCRule_Video_YUV_SD_Main : // fource to RGB and input is RGB, hence no need change
5489 PQ_CSCRule_Video_RGB_SD_0_255_Main;
5490 }
5491 else // bInputDataRange16_235
5492 {
5493 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5494 PQ_CSCRule_Video_YUV_SD_Main :
5495 PQ_CSCRule_Video_RGB_SD_16_235_Main;
5496 }
5497 }
5498 else // InputResolutionHD
5499 {
5500 if (_bColorRange0_255[eWindow])
5501 {
5502 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5503 PQ_CSCRule_Video_YUV_HD_Main :
5504 PQ_CSCRule_Video_RGB_HD_0_255_Main;
5505 }
5506 else // bInputDataRange16_235
5507 {
5508 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5509 PQ_CSCRule_Video_YUV_HD_Main :
5510 PQ_CSCRule_Video_RGB_HD_16_235_Main;
5511 }
5512 }
5513 }
5514 #if PQ_ENABLE_PIP
5515 else
5516 {
5517 if (bInputResolutionHD == FALSE)
5518 {
5519 if (_bColorRange0_255[eWindow])
5520 {
5521 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5522 PQ_CSCRule_Video_YUV_SD_Sub : // fource to RGB and input is RGB, hence no need change
5523 PQ_CSCRule_Video_RGB_SD_0_255_Sub;
5524 }
5525 else // bInputDataRange16_235
5526 {
5527 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5528 PQ_CSCRule_Video_YUV_SD_Sub :
5529 PQ_CSCRule_Video_RGB_SD_16_235_Sub;
5530 }
5531 }
5532 else // InputResolutionHD
5533 {
5534 if (_bColorRange0_255[eWindow])
5535 {
5536 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5537 PQ_CSCRule_Video_YUV_HD_Sub :
5538 PQ_CSCRule_Video_RGB_HD_0_255_Sub;
5539 }
5540 else // bInputDataRange16_235
5541 {
5542 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5543 PQ_CSCRule_Video_YUV_HD_Sub :
5544 PQ_CSCRule_Video_RGB_HD_16_235_Sub;
5545 }
5546 }
5547 }
5548 #endif
5549 }
5550 else // InputColorSpaceYUV
5551 {
5552 if(enForceColor == PQ_FOURCE_COLOR_RGB )
5553 {
5554 if(_bP2pForceToDoCsc == FALSE)
5555 {
5556 //MS_ASSERT(0);
5557 }
5558 PQTAB_DBG(printf("InputColorSpace is YUV, Force Color Space is RGB!!!\n"));
5559 }
5560
5561 if (eWindow == PQ_MAIN_WINDOW)
5562 {
5563 if (bInputResolutionHD == FALSE)
5564 {
5565 u16XRuleIdx = PQ_CSCRule_Video_YUV_SD_Main;
5566 }
5567 else // InputResolutionHD
5568 {
5569 u16XRuleIdx = PQ_CSCRule_Video_YUV_HD_Main;
5570 }
5571 }
5572 #if PQ_ENABLE_PIP
5573 else
5574 {
5575 if (bInputResolutionHD == FALSE)
5576 {
5577 u16XRuleIdx = PQ_CSCRule_Video_YUV_SD_Sub;
5578 }
5579 else // InputResolutionHD
5580 {
5581 u16XRuleIdx = PQ_CSCRule_Video_YUV_HD_Sub;
5582 }
5583 }
5584 #endif
5585 }
5586 }
5587 else // InputTypePC
5588 {
5589 if (*pbInputColorSpaceRGB)
5590 {
5591 if (eWindow == PQ_MAIN_WINDOW)
5592 {
5593 if (bInputResolutionHD == FALSE)
5594 {
5595 if (_bColorRange0_255[eWindow])
5596 {
5597 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5598 PQ_CSCRule_PC_YUV_SD_Main :
5599 PQ_CSCRule_PC_RGB_SD_0_255_Main;
5600 }
5601 else // bInputDataRange16_235
5602 {
5603 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5604 PQ_CSCRule_PC_YUV_SD_Main :
5605 PQ_CSCRule_PC_RGB_SD_16_235_Main;
5606 }
5607 }
5608 else // InputResolutionHD
5609 {
5610 if (_bColorRange0_255[eWindow])
5611 {
5612 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5613 PQ_CSCRule_PC_YUV_HD_Main :
5614 PQ_CSCRule_PC_RGB_HD_0_255_Main;
5615 }
5616 else // bInputDataRange16_235
5617 {
5618 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5619 PQ_CSCRule_PC_YUV_HD_Main :
5620 PQ_CSCRule_PC_RGB_HD_16_235_Main;
5621 }
5622 }
5623 }
5624 #if PQ_ENABLE_PIP
5625 else
5626 {
5627 if (bInputResolutionHD == FALSE)
5628 {
5629 if (_bColorRange0_255[eWindow])
5630 {
5631 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5632 PQ_CSCRule_PC_YUV_SD_Sub :
5633 PQ_CSCRule_PC_RGB_SD_0_255_Sub;
5634 }
5635 else // bInputDataRange16_235
5636 {
5637 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5638 PQ_CSCRule_PC_YUV_SD_Sub :
5639 PQ_CSCRule_PC_RGB_SD_16_235_Sub;
5640 }
5641 }
5642 else // InputResolutionHD
5643 {
5644 if (_bColorRange0_255[eWindow])
5645 {
5646 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5647 PQ_CSCRule_PC_YUV_HD_Sub :
5648 PQ_CSCRule_PC_RGB_HD_0_255_Sub;
5649 }
5650 else // bInputDataRange16_235
5651 {
5652 u16XRuleIdx = enForceColor == PQ_FOURCE_COLOR_RGB ?
5653 PQ_CSCRule_PC_YUV_HD_Sub :
5654 PQ_CSCRule_PC_RGB_HD_16_235_Sub;
5655 }
5656 }
5657 }
5658 #endif
5659 }
5660 else // InputColorSpaceYUV
5661 {
5662 if(enForceColor == PQ_FOURCE_COLOR_RGB )
5663 {
5664 if(_bP2pForceToDoCsc == FALSE)
5665 {
5666 //MS_ASSERT(0);
5667 }
5668 PQTAB_DBG(printf("InputColorSpace is YUV, Force Color Space is RGB!!!\n"));
5669 }
5670
5671 if(eWindow == PQ_MAIN_WINDOW)
5672 {
5673 if (bInputResolutionHD == FALSE)
5674 {
5675 u16XRuleIdx = PQ_CSCRule_PC_YUV_SD_Main;
5676 }
5677 else // InputResolutionHD
5678 {
5679 u16XRuleIdx = PQ_CSCRule_PC_YUV_HD_Main;
5680 }
5681 }
5682 #if PQ_ENABLE_PIP
5683 else
5684 {
5685 if (bInputResolutionHD == FALSE)
5686 {
5687 u16XRuleIdx = PQ_CSCRule_PC_YUV_SD_Sub;
5688 }
5689 else // InputResolutionHD
5690 {
5691 u16XRuleIdx = PQ_CSCRule_PC_YUV_HD_Sub;
5692 }
5693 }
5694 #endif
5695 }
5696 }
5697
5698 for(u16XRuleIP=0; u16XRuleIP<MDrv_PQ_GetXRuleIPNum(pInstance, eWindow, eXRuleType); u16XRuleIP++)
5699 {
5700 u16IPIdx = MDrv_PQ_GetXRuleIPIndex(pInstance, eWindow, eXRuleType, u16XRuleIP);
5701 u16TabIdx = MDrv_PQ_GetXRuleTableIndex(pInstance, eWindow, eXRuleType, u16XRuleIdx, u16XRuleIP);
5702 //for ptp, no csc
5703 if(MDrv_PQ_Get_PointToPoint_U2(pInstance, eWindow))
5704 {
5705 if(_bP2pForceToDoCsc == FALSE)
5706 {
5707 u16TabIdx = 0x00; //PQ_IP_CSC_OFF_Main and PQ_IP_VIP_CSC_OFF_Main
5708 }
5709 CSCRULE_DBG(printf("PointToPoint \n"));
5710 }
5711 CSCRULE_DBG(printf("u16XRuleIdx:%u, u16XRuleIP=%u, IPIdx=%u, TabIdx=%u\n", u16XRuleIdx, u16XRuleIP, u16IPIdx, u16TabIdx));
5712
5713 if(bLoadPQTable)
5714 {
5715 #ifdef PQ_CFD_INFO
5716 #else
5717 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, u16IPIdx);
5718 #endif
5719 //if(u16XRuleIP==0)
5720 // MDrv_PQ_LoadTable_U2(pInstance,eWindow, 0, 6);
5721 //else if(u16XRuleIP==1)
5722 // MDrv_PQ_LoadTable_U2(pInstance,eWindow, 5, 122);
5723 //else
5724 // MDrv_PQ_LoadTable_U2(pInstance,eWindow, u16TabIdx, u16IPIdx);
5725 }
5726
5727 if(u16TabIdx)
5728 {
5729 #if PQ_HAL_EWINDOW_PARAM
5730 if(u16IPIdx == Hal_PQ_get_csc_ip_idx(pInstance,MS_CSC_IP_CSC,eWindow))
5731 #else
5732 if(u16IPIdx == Hal_PQ_get_csc_ip_idx(pInstance,MS_CSC_IP_CSC))
5733 #endif
5734 {
5735 (*pu16DoCSC) |= 0x1;
5736 }
5737 #if PQ_HAL_EWINDOW_PARAM
5738 else if(u16IPIdx == Hal_PQ_get_csc_ip_idx(pInstance,MS_CSC_IP_VIP_CSC,eWindow))
5739 #else
5740 else if(u16IPIdx == Hal_PQ_get_csc_ip_idx(pInstance,MS_CSC_IP_VIP_CSC))
5741 #endif
5742 {
5743 (*pu16DoCSC) |= 0x02;
5744 }
5745 else
5746 {
5747 (*pu16DoCSC) |= 0x00;
5748 }
5749 }
5750 }
5751 return true;
5752 }
MDrv_PQ_Get_CSC_XRuleIdx(MS_BOOL * pbInputColorSpaceRGB,MS_U16 * pu16DoCSC,PQ_WIN eWindow,PQ_FOURCE_COLOR_FMT enForceColor,MS_BOOL bLoadPQTable)5753 MS_BOOL MDrv_PQ_Get_CSC_XRuleIdx(MS_BOOL *pbInputColorSpaceRGB,
5754 MS_U16 * pu16DoCSC,
5755 PQ_WIN eWindow,
5756 PQ_FOURCE_COLOR_FMT enForceColor,
5757 MS_BOOL bLoadPQTable)
5758 {
5759 #ifdef TRACE_DBG
5760 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
5761 #endif
5762 if (pu32PQInst == NULL)
5763 {
5764 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
5765 return FALSE;
5766 }
5767
5768 stPQ_Get_CSC_XRuleIdx PQArgs;
5769 PQArgs.pbInputColorSpaceRGB = pbInputColorSpaceRGB;
5770 PQArgs.pu16DoCSC = pu16DoCSC;
5771 PQArgs.eWindow = eWindow;
5772 PQArgs.enForceColor = enForceColor;
5773 PQArgs.bLoadPQTable = bLoadPQTable;
5774 PQArgs.bReturnValue = FALSE;
5775 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_CSC_XRULEIDX, (void*)&PQArgs) != 0)
5776 {
5777 printf("Obtain PQ engine fail\n");
5778 return FALSE;
5779 }
5780 else
5781 {
5782 return PQArgs.bReturnValue;
5783 }
5784 }
5785
5786 //////////////////////////////////////////////////////////////////
5787 // get memory color format
5788 // Note: return true if CSC is TRUE
5789 // this case is for video rgb csc case
5790 // return:
5791 // TRUE: use YUV color space, by front-end csc
5792 // FALSE: otherwise
MDrv_PQ_Get_MemYUVFmt_U2(void * pInstance,PQ_WIN eWindow,PQ_FOURCE_COLOR_FMT enForceColor)5793 MS_BOOL MDrv_PQ_Get_MemYUVFmt_U2(void* pInstance,PQ_WIN eWindow, PQ_FOURCE_COLOR_FMT enForceColor)
5794 {
5795 MS_U16 u16DoCSC = 0;
5796 MS_BOOL bInputColorSpaceRGB;
5797 MS_BOOL bMemYUV;
5798
5799 MDrv_PQ_Get_CSC_XRuleIdx_U2(pInstance, &bInputColorSpaceRGB, &u16DoCSC, eWindow, enForceColor, FALSE);
5800
5801 if(bInputColorSpaceRGB)
5802 {
5803 if(u16DoCSC & 0x01)
5804 {
5805 bMemYUV = TRUE;
5806 }
5807 else
5808 {
5809 bMemYUV = FALSE;
5810 }
5811 }
5812 else
5813 {
5814 bMemYUV = TRUE;
5815 }
5816
5817 return bMemYUV;
5818 }
MDrv_PQ_Get_MemYUVFmt(PQ_WIN eWindow,PQ_FOURCE_COLOR_FMT enForceColor)5819 MS_BOOL MDrv_PQ_Get_MemYUVFmt(PQ_WIN eWindow, PQ_FOURCE_COLOR_FMT enForceColor)
5820 {
5821 if (pu32PQInst == NULL)
5822 {
5823 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
5824 {
5825 printf("UtopiaOpen PQ failed\n");
5826 return PQ_DEINT_OFF;
5827 }
5828 }
5829
5830 stPQ_Get_MemYUVFmt PQArgs;
5831 PQArgs.eWindow = eWindow;
5832 PQArgs.enForceColor = enForceColor;
5833 PQArgs.bReturnValue = FALSE;
5834 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_MEM_YUVFMT, (void*)&PQArgs) != 0)
5835 {
5836 printf("Obtain PQ engine fail\n");
5837 return FALSE;
5838 }
5839 else
5840 {
5841 return PQArgs.bReturnValue;
5842 }
5843 }
5844
5845
5846 //////////////////////////////////////////////////////////////////
5847 // do color space conversion from RGB to YUV according to input sourcce and context
5848 // Note: return true if CSC or VIP_CSC is TRUE
5849 // this case is for (video rgb and pc rgb) csc case
5850 // return:
5851 // TRUE: use YUV color space, for front-end and back-end csc both
5852 // FALSE: otherwise
5853 //
MDrv_PQ_SetCSC_U2(void * pInstance,PQ_WIN eWindow,PQ_FOURCE_COLOR_FMT enForceColor)5854 MS_BOOL MDrv_PQ_SetCSC_U2(void* pInstance,PQ_WIN eWindow, PQ_FOURCE_COLOR_FMT enForceColor)
5855 {
5856 MS_U16 u16DoCSC = 0;
5857 MS_BOOL bInputColorSpaceRGB;
5858
5859
5860 MDrv_PQ_Get_CSC_XRuleIdx_U2(pInstance, &bInputColorSpaceRGB, &u16DoCSC, eWindow, enForceColor, TRUE);
5861
5862 u16DoCSC = (u16DoCSC != 0);
5863 if ((bInputColorSpaceRGB && u16DoCSC) || (!bInputColorSpaceRGB))
5864 {
5865 return TRUE; // use YUV space
5866 }
5867 else
5868 {
5869 return FALSE; // use RGB space
5870 }
5871 }
MDrv_PQ_SetCSC(PQ_WIN eWindow,PQ_FOURCE_COLOR_FMT enForceColor)5872 MS_BOOL MDrv_PQ_SetCSC(PQ_WIN eWindow, PQ_FOURCE_COLOR_FMT enForceColor)
5873 {
5874 if (pu32PQInst == NULL)
5875 {
5876 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
5877 {
5878 printf("UtopiaOpen PQ failed\n");
5879 return FALSE;
5880 }
5881 }
5882
5883 stPQ_SetCSC PQArgs;
5884 PQArgs.eWindow = eWindow;
5885 PQArgs.enForceColor = enForceColor;
5886 PQArgs.bReturnValue = FALSE;
5887 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_CSC, (void*)&PQArgs) != 0)
5888 {
5889 printf("Obtain PQ engine fail\n");
5890 return FALSE;
5891 }
5892 else
5893 {
5894 return PQArgs.bReturnValue;
5895 }
5896 }
5897
5898 #if (PQ_XRULE_DB_ENABLE == 1)
MDrv_PQ_Set_DBRule_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16MADi_Idx)5899 void MDrv_PQ_Set_DBRule_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16MADi_Idx)
5900 {
5901 MS_U16 eXRuleType = E_XRULE_CSC;
5902 MS_U16 u16XRuleIdx, u16XRuleIP;
5903 MS_U16 u16IPIdx, u16TabIdx;
5904
5905 eXRuleType = (_stMode_Info[eWindow].u16input_vfreq > 550) ? E_XRULE_DB_NTSC : E_XRULE_DB_PAL;
5906
5907 if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_24_4R) == u16MADi_Idx)
5908 {
5909 u16XRuleIdx = PQ_DBRule_NTSC_24_4R_Main;
5910 }
5911 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_24_2R) == u16MADi_Idx)
5912 {
5913 u16XRuleIdx = PQ_DBRule_NTSC_24_2R_Main;
5914 }
5915 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_4R_MC) == u16MADi_Idx)
5916 {
5917 u16XRuleIdx = PQ_DBRule_NTSC_25_4R_MC_Main;
5918 }
5919 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_4R) == u16MADi_Idx)
5920 {
5921 u16XRuleIdx = PQ_DBRule_NTSC_25_4R_Main;
5922 }
5923 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_2R) == u16MADi_Idx)
5924 {
5925 u16XRuleIdx = PQ_DBRule_NTSC_25_2R_Main;
5926 }
5927 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_27_4R) == u16MADi_Idx)
5928 {
5929 u16XRuleIdx = PQ_DBRule_NTSC_27_4R_Main;
5930 }
5931 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_27_2R) == u16MADi_Idx)
5932 {
5933 u16XRuleIdx = PQ_DBRule_NTSC_27_2R_Main;
5934 }
5935 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE8) == u16MADi_Idx)
5936 {
5937 u16XRuleIdx = PQ_DBRule_NTSC_P_MODE8_Main;
5938 }
5939 #if (PQ_P_MODE8_3FRAME_MODE_ENABLE == 1)
5940 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE8_3Frame) == u16MADi_Idx)
5941 {
5942 u16XRuleIdx = PQ_DBRule_NTSC_P_MODE8_Main;
5943 }
5944 #endif
5945
5946 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE10) == u16MADi_Idx)
5947 {
5948 u16XRuleIdx = PQ_DBRule_NTSC_P_MODE10_Main;
5949 }
5950 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MOT8) == u16MADi_Idx)
5951 {
5952 u16XRuleIdx = PQ_DBRule_NTSC_P_MODE_MOT8_Main;
5953 }
5954 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MOT10) == u16MADi_Idx)
5955 {
5956 u16XRuleIdx = PQ_DBRule_NTSC_P_MODE_MOT10_Main;
5957 }
5958 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_24_4R_880) == u16MADi_Idx)
5959 {
5960 u16XRuleIdx = PQ_DBRule_NTSC_24_4R_880_Main;
5961 }
5962 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_24_2R_880) == u16MADi_Idx)
5963 {
5964 u16XRuleIdx = PQ_DBRule_NTSC_24_2R_880_Main;
5965 }
5966 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_6R_MC) == u16MADi_Idx)
5967 {
5968 u16XRuleIdx = PQ_DBRule_NTSC_25_6R_MC_Main;
5969 }
5970 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_14F_6R_MC) == u16MADi_Idx) //Add New MADi mode
5971 {
5972 u16XRuleIdx = PQ_DBRule_NTSC_25_14F_6R_MC_Main;
5973 }
5974 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_4R_MC_NW) == u16MADi_Idx)
5975 {
5976 u16XRuleIdx = PQ_DBRule_NTSC_25_4R_MC_NW_Main;
5977 }
5978 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_6R_MC_NW) == u16MADi_Idx)
5979 {
5980 u16XRuleIdx = PQ_DBRule_NTSC_25_6R_MC_NW_Main;
5981 }
5982 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_4R_884) == u16MADi_Idx)
5983 {
5984 u16XRuleIdx = PQ_DBRule_NTSC_25_4R_884_Main;
5985 }
5986 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_2R_884) == u16MADi_Idx)
5987 {
5988 u16XRuleIdx = PQ_DBRule_NTSC_25_2R_884_Main;
5989 }
5990 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_4R_880) == u16MADi_Idx)
5991 {
5992 u16XRuleIdx = PQ_DBRule_NTSC_24_4R_880_Main;
5993 }
5994 else if(Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_2R_880) == u16MADi_Idx)
5995 {
5996 u16XRuleIdx = PQ_DBRule_NTSC_24_2R_880_Main;
5997 }
5998 else
5999 {
6000 u16XRuleIdx = 0xFF;
6001 }
6002
6003 for(u16XRuleIP = 0; u16XRuleIP < MDrv_PQ_GetXRuleIPNum(pInstance, eWindow, eXRuleType); u16XRuleIP++)
6004 {
6005 if(u16XRuleIdx == 0xFF)
6006 continue;
6007
6008 u16IPIdx = MDrv_PQ_GetXRuleIPIndex(pInstance, eWindow, eXRuleType, u16XRuleIP);
6009 u16TabIdx = MDrv_PQ_GetXRuleTableIndex(pInstance, eWindow, eXRuleType, u16XRuleIdx, u16XRuleIP);
6010 //(printf("u16XRuleIdx:%u, u16XRuleIP=%u, IPIdx=%u, TabIdx=%u\n", u16XRuleIdx, u16XRuleIP, u16IPIdx, u16TabIdx));
6011
6012 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, u16IPIdx);
6013 }
6014 }
MDrv_PQ_Set_DBRule(PQ_WIN eWindow,MS_U16 u16MADi_Idx)6015 void MDrv_PQ_Set_DBRule(PQ_WIN eWindow, MS_U16 u16MADi_Idx)
6016 {
6017 #ifdef TRACE_DBG
6018 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
6019 #endif
6020 if (pu32PQInst == NULL)
6021 {
6022 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
6023 return ;
6024 }
6025
6026 stPQ_Set_DBRule PQArgs;
6027 PQArgs.eWindow = eWindow;
6028 PQArgs.u16MADi_Idx = u16MADi_Idx;
6029 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_DBRULE, (void*)&PQArgs) != 0)
6030 {
6031 printf("Obtain PQ engine fail\n");
6032 return;
6033 }
6034 else
6035 {
6036 return;
6037 }
6038 }
6039 #endif
6040
MDrv_PQ_EnableMADIForce_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bFullMotion)6041 void MDrv_PQ_EnableMADIForce_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bFullMotion)
6042 {
6043 #if PQ_ENABLE_FORCE_MADI
6044 if(bFullMotion)
6045 {
6046 if(PQ_MAIN_WINDOW == eWindow)
6047 {
6048 MDrv_PQ_LoadTable_U2(pInstance, eWindow, PQ_IP_MADi_Force_YC_FullMotion_Main, PQ_IP_MADi_Force_Main);
6049 }
6050 //#if (ENABLE_LITE_SN == 0)
6051 else if( (PQ_SUB_WINDOW == eWindow) && ( _upLayerConfig & E_PQ_MISC_A_LITESN_ENABLE ) )
6052 {
6053 MDrv_PQ_LoadTable_U2(pInstance, eWindow, PQ_IP_MADi_Force_YC_FullMotion_Sub, PQ_IP_MADi_Force_Sub);
6054 }
6055 //#endif
6056 }
6057 else
6058 {
6059 if(PQ_MAIN_WINDOW == eWindow)
6060 {
6061 MDrv_PQ_LoadTable_U2(pInstance, eWindow, PQ_IP_MADi_Force_YC_FullStill_Main, PQ_IP_MADi_Force_Main);
6062 }
6063 //#if (ENABLE_LITE_SN == 0)
6064 else if( (PQ_SUB_WINDOW == eWindow) && ( _upLayerConfig & E_PQ_MISC_A_LITESN_ENABLE ) )
6065 {
6066 MDrv_PQ_LoadTable_U2(pInstance, eWindow, PQ_IP_MADi_Force_YC_FullStill_Sub, PQ_IP_MADi_Force_Sub);
6067 }
6068 //#endif
6069 }
6070 #else
6071 UNUSED(eWindow);
6072 UNUSED(bFullMotion);
6073 #endif
6074 }
MDrv_PQ_EnableMADIForce(PQ_WIN eWindow,MS_BOOL bFullMotion)6075 void MDrv_PQ_EnableMADIForce(PQ_WIN eWindow, MS_BOOL bFullMotion)
6076 {
6077 #ifdef TRACE_DBG
6078 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
6079 #endif
6080 if (pu32PQInst == NULL)
6081 {
6082 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
6083 return ;
6084 }
6085
6086 stPQ_EnableMADIForce PQArgs;
6087 PQArgs.eWindow = eWindow;
6088 PQArgs.bFullMotion = bFullMotion;
6089 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_ENABLE_MADI_FORCE, (void*)&PQArgs) != 0)
6090 {
6091 printf("Obtain PQ engine fail\n");
6092 return;
6093 }
6094 else
6095 {
6096 return;
6097 }
6098 }
6099
MDrv_PQ_ReduceBW_ForPVR_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bPVR_On)6100 void MDrv_PQ_ReduceBW_ForPVR_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bPVR_On)
6101 {
6102 UNUSED(eWindow);
6103 UNUSED(bPVR_On);
6104 }
MDrv_PQ_ReduceBW_ForPVR(PQ_WIN eWindow,MS_BOOL bPVR_On)6105 void MDrv_PQ_ReduceBW_ForPVR(PQ_WIN eWindow, MS_BOOL bPVR_On)
6106 {
6107 #ifdef TRACE_DBG
6108 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
6109 #endif
6110 if (pu32PQInst == NULL)
6111 {
6112 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
6113 return ;
6114 }
6115
6116 stPQ_ReduceBW_ForPVR PQArgs;
6117 PQArgs.eWindow = eWindow;
6118 PQArgs.bPVR_On = bPVR_On;
6119 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_REDUCE_BW_FOR_PVR, (void*)&PQArgs) != 0)
6120 {
6121 printf("Obtain PQ engine fail\n");
6122 return;
6123 }
6124 else
6125 {
6126 return;
6127 }
6128 }
6129
_MDrv_PQ_Set_MVOP_UVShift(MS_BOOL bEnable)6130 void _MDrv_PQ_Set_MVOP_UVShift(MS_BOOL bEnable)
6131 {
6132 MS_U8 regval;
6133
6134 regval = MApi_XC_ReadByte(VOP_MPG_JPG_SWITCH);
6135
6136 if(((regval & 0x10) == 0x10) && ((regval & 0x3) == 0x2))
6137 {
6138 // 422 with MCU control mode
6139 if(bEnable)
6140 {
6141 MS_ASSERT(0);
6142 }
6143 }
6144
6145 // output 420 and interlace
6146 //[IP - Sheet] : Main Page --- 420CUP
6147 //[Project] : Titania2
6148 //[Description]: Chroma artifacts when 420to422 is applied duplicate method.
6149 //[Root cause]: Apply 420to422 average algorithm to all DTV input cases.
6150 //The average algorithm must cooperate with MVOP.
6151 MApi_XC_WriteByteMask(VOP_UV_SHIFT, (bEnable) ? 1 : 0, 0x3);
6152 }
6153
MDrv_PQ_Set420upsampling_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bFBL,MS_BOOL bPreV_ScalingDown,MS_U16 u16V_CropStart)6154 void MDrv_PQ_Set420upsampling_U2(void* pInstance,
6155 PQ_WIN eWindow,
6156 MS_BOOL bFBL,
6157 MS_BOOL bPreV_ScalingDown,
6158 MS_U16 u16V_CropStart)
6159 {
6160 MS_U16 u16TabIdx;
6161
6162 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance, eWindow, PQ_IP_420CUP_Main);
6163
6164 PQTAB_DBG(printf("[PQ_Set420upsampling]: SrcType:%u, FBL:%u, PreV down:%u, V_CropStart:%u, u8TabIdx=%u, ",
6165 _u16PQSrcType[eWindow], bFBL, bPreV_ScalingDown, u16V_CropStart, u16TabIdx));
6166
6167 #if PQ_HAL_EWINDOW_PARAM
6168 if((u16TabIdx == Hal_PQ_get_420_cup_idx(pInstance,MS_420_CUP_ON, eWindow)) && (!bPreV_ScalingDown) && (!bFBL))
6169 #else
6170 if((u16TabIdx == Hal_PQ_get_420_cup_idx(pInstance,MS_420_CUP_ON)) && (!bPreV_ScalingDown) && (!bFBL))
6171 #endif
6172 {
6173 PQTAB_DBG(printf("UVShift: on\n"));
6174 _MDrv_PQ_Set_MVOP_UVShift(ENABLE);
6175 #if PQ_HAL_EWINDOW_PARAM
6176 MDrv_PQ_LoadTable_U2(pInstance,
6177 eWindow, Hal_PQ_get_420_cup_idx(pInstance,MS_420_CUP_ON, eWindow),
6178 eWindow == PQ_MAIN_WINDOW? PQ_IP_420CUP_Main:PQ_IP_420CUP_Sub);
6179 #else
6180 MDrv_PQ_LoadTable_U2(pInstance, eWindow, Hal_PQ_get_420_cup_idx(pInstance,MS_420_CUP_ON), PQ_IP_420CUP_Main);
6181 #endif
6182 }
6183 else // P mode should not do UV shift
6184 {
6185 PQTAB_DBG(printf("UVShift: off\n"));
6186 _MDrv_PQ_Set_MVOP_UVShift(DISABLE);
6187 #if PQ_HAL_EWINDOW_PARAM
6188 MDrv_PQ_LoadTable_U2(pInstance,
6189 eWindow, Hal_PQ_get_420_cup_idx(pInstance,MS_420_CUP_OFF, eWindow),
6190 eWindow == PQ_MAIN_WINDOW? PQ_IP_420CUP_Main:PQ_IP_420CUP_Sub);
6191 #else
6192 MDrv_PQ_LoadTable_U2(pInstance, eWindow, Hal_PQ_get_420_cup_idx(pInstance,MS_420_CUP_OFF), PQ_IP_420CUP_Main);
6193 #endif
6194 }
6195
6196 if((u16V_CropStart & 0x3) == 0) // crop lines are multiple of 4
6197 Hal_PQ_set_420upSample(pInstance,0x6666);
6198 else if((u16V_CropStart & 0x1) == 0) // crop lines are multiple of 2
6199 Hal_PQ_set_420upSample(pInstance,0x9999);
6200 // else
6201 // MS_ASSERT(0);
6202 }
MDrv_PQ_Set420upsampling(PQ_WIN eWindow,MS_BOOL bFBL,MS_BOOL bPreV_ScalingDown,MS_U16 u16V_CropStart)6203 void MDrv_PQ_Set420upsampling(PQ_WIN eWindow,
6204 MS_BOOL bFBL,
6205 MS_BOOL bPreV_ScalingDown,
6206 MS_U16 u16V_CropStart)
6207 {
6208 if (pu32PQInst == NULL)
6209 {
6210 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
6211 {
6212 printf("UtopiaOpen PQ failed\n");
6213 return;
6214 }
6215 }
6216
6217 stPQ_Set420upsampling PQArgs;
6218 PQArgs.eWindow = eWindow;
6219 PQArgs.bFBL = bFBL;
6220 PQArgs.bPreV_ScalingDown = bPreV_ScalingDown;
6221 PQArgs.u16V_CropStart = u16V_CropStart;
6222 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_420UP_SAMPLEING, (void*)&PQArgs) != 0)
6223 {
6224 printf("Obtain PQ engine fail\n");
6225 return;
6226 }
6227 else
6228 {
6229 return;
6230 }
6231 }
6232
MDrv_PQ_SetFilmMode_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bEnable)6233 void MDrv_PQ_SetFilmMode_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bEnable)
6234 {
6235 MS_U16 u16TabIdx;
6236
6237 PQTAB_DBG(printf("[PQ_SetFilmMode]: PQTabType=%u, enable=%u\n", eWindow, bEnable));
6238
6239 if(bEnable)
6240 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance, eWindow, PQ_IP_Film32_Main);
6241 else
6242 u16TabIdx = PQ_IP_Film32_OFF_Main;
6243
6244 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, PQ_IP_Film32_Main);
6245
6246 if(bEnable)
6247 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance, eWindow, PQ_IP_Film22_Main);
6248 else
6249 u16TabIdx = PQ_IP_Film22_OFF_Main;
6250
6251 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, PQ_IP_Film22_Main);
6252 }
MDrv_PQ_SetFilmMode(PQ_WIN eWindow,MS_BOOL bEnable)6253 void MDrv_PQ_SetFilmMode(PQ_WIN eWindow, MS_BOOL bEnable)
6254 {
6255 #ifdef TRACE_DBG
6256 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
6257 #endif
6258 if (pu32PQInst == NULL)
6259 {
6260 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
6261 return ;
6262 }
6263
6264 stPQ_SetFilmMode PQArgs;
6265 PQArgs.eWindow = eWindow;
6266 PQArgs.bEnable = bEnable;
6267 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_FILEMODE, (void*)&PQArgs) != 0)
6268 {
6269 printf("Obtain PQ engine fail\n");
6270 return;
6271 }
6272 else
6273 {
6274 return;
6275 }
6276 }
6277
6278
MDrv_PQ_SetNonLinearScaling_U2(void * pInstance,PQ_WIN eWindow,MS_U8 u8Level,MS_BOOL bEnable)6279 void MDrv_PQ_SetNonLinearScaling_U2(void* pInstance,PQ_WIN eWindow, MS_U8 u8Level, MS_BOOL bEnable)
6280 {
6281 MS_U16 u16TabIdx;
6282 PQTAB_DBG(printf("[PQ_SetNonLinearScaling]: Level=%u, enable=%u\n", u8Level, bEnable));
6283
6284 if(eWindow == PQ_SUB_WINDOW)
6285 {
6286 //sub window don't need nonLinear scaling
6287 return;
6288 }
6289
6290 if(bEnable)
6291 {
6292 switch(_stPQ_Info.u16PnlWidth)
6293 {
6294 case 3840:
6295 switch(u8Level)
6296 {
6297 case 2:
6298 u16TabIdx = Hal_PQ_get_hnonlinear_idx(pInstance,MS_HNONLINEAR_3840_2);
6299 break;
6300 case 1:
6301 u16TabIdx = Hal_PQ_get_hnonlinear_idx(pInstance,MS_HNONLINEAR_3840_1);
6302 break;
6303 case 0:
6304 default:
6305 u16TabIdx = Hal_PQ_get_hnonlinear_idx(pInstance,MS_HNONLINEAR_3840_0);
6306 break;
6307 }
6308 break;
6309 case 1920:
6310 switch(u8Level)
6311 {
6312 case 2:
6313 u16TabIdx = Hal_PQ_get_hnonlinear_idx(pInstance,MS_HNONLINEAR_1920_2);
6314 break;
6315 case 1:
6316 u16TabIdx = Hal_PQ_get_hnonlinear_idx(pInstance,MS_HNONLINEAR_1920_1);
6317 break;
6318 case 0:
6319 default:
6320 u16TabIdx = Hal_PQ_get_hnonlinear_idx(pInstance,MS_HNONLINEAR_1920_0);
6321 break;
6322 }
6323 break;
6324 case 1680:
6325 u16TabIdx = Hal_PQ_get_hnonlinear_idx(pInstance,MS_HNONLINEAR_1680);
6326 break;
6327 case 1440:
6328 u16TabIdx = Hal_PQ_get_hnonlinear_idx(pInstance,MS_HNONLINEAR_1440);
6329 break;
6330 case 1366:
6331 switch(u8Level)
6332 {
6333 case 2:
6334 u16TabIdx = Hal_PQ_get_hnonlinear_idx(pInstance,MS_HNONLINEAR_1366_2);
6335 break;
6336 case 1:
6337 u16TabIdx = Hal_PQ_get_hnonlinear_idx(pInstance,MS_HNONLINEAR_1366_1);
6338 break;
6339 case 0:
6340 default:
6341 u16TabIdx = Hal_PQ_get_hnonlinear_idx(pInstance,MS_HNONLINEAR_1366_0);
6342 break;
6343
6344 }
6345 break;
6346 default:
6347 u16TabIdx = Hal_PQ_get_hnonlinear_idx(pInstance,MS_HNONLINEAR_OFF);
6348 break;
6349
6350 break;
6351 }
6352 }
6353 else
6354 {
6355 u16TabIdx = Hal_PQ_get_hnonlinear_idx(pInstance,MS_HNONLINEAR_OFF);
6356 }
6357 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, PQ_IP_HnonLinear_Main);
6358 }
MDrv_PQ_SetNonLinearScaling(PQ_WIN eWindow,MS_U8 u8Level,MS_BOOL bEnable)6359 void MDrv_PQ_SetNonLinearScaling(PQ_WIN eWindow, MS_U8 u8Level, MS_BOOL bEnable)
6360 {
6361 #ifdef TRACE_DBG
6362 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
6363 #endif
6364 if (pu32PQInst == NULL)
6365 {
6366 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
6367 return ;
6368 }
6369
6370 stPQ_SetNonLinearScaling PQArgs;
6371 PQArgs.eWindow = eWindow;
6372 PQArgs.u8Level = u8Level;
6373 PQArgs.bEnable = bEnable;
6374 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_NONLINEAR_SCALING, (void*)&PQArgs) != 0)
6375 {
6376 printf("Obtain PQ engine fail\n");
6377 return;
6378 }
6379 else
6380 {
6381 return;
6382 }
6383 }
6384
_MDrv_PQ_CloneSram(void * pInstance)6385 void _MDrv_PQ_CloneSram(void *pInstance)
6386 {
6387 MS_U16 u16CSRAM1 = MDrv_PQ_GetTableIndex_U2(pInstance, PQ_MAIN_WINDOW, PQ_IP_C_SRAM1_Main);
6388 MS_U16 u16CSRAM2 = MDrv_PQ_GetTableIndex_U2(pInstance, PQ_MAIN_WINDOW, PQ_IP_C_SRAM2_Main);
6389
6390 if(gbPQBinEnable)
6391 {
6392 MS_PQBin_IP_Table_Info stTableInfo;
6393 memset(&stTableInfo, 0, sizeof(MS_PQBin_IP_Table_Info));
6394
6395 MDrv_PQBin_GetTable(pInstance,MDrv_PQBin_GetPanelIdx(pInstance),
6396 _u16SRAM1,
6397 PQ_IP_SRAM1_Main,
6398 &stTableInfo,
6399 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
6400 stTableInfo.u16TableType = PQ_TABTYPE_SRAM3;
6401 MDrv_PQBin_DumpTable(pInstance,&stTableInfo);
6402
6403 MDrv_PQBin_GetTable(pInstance,MDrv_PQBin_GetPanelIdx(pInstance),
6404 _u16SRAM2,
6405 PQ_IP_SRAM2_Main,
6406 &stTableInfo,
6407 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
6408 stTableInfo.u16TableType = PQ_TABTYPE_SRAM4;
6409 MDrv_PQBin_DumpTable(pInstance,&stTableInfo);
6410
6411 MDrv_PQBin_GetTable(pInstance,MDrv_PQBin_GetPanelIdx(pInstance),
6412 u16CSRAM1,
6413 PQ_IP_C_SRAM1_Main,
6414 &stTableInfo,
6415 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
6416 stTableInfo.u16TableType = PQ_TABTYPE_C_SRAM3;
6417 MDrv_PQBin_DumpTable(pInstance,&stTableInfo);
6418
6419 MDrv_PQBin_GetTable(pInstance,MDrv_PQBin_GetPanelIdx(pInstance),
6420 u16CSRAM2,
6421 PQ_IP_C_SRAM2_Main,
6422 &stTableInfo,
6423 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
6424 stTableInfo.u16TableType = PQ_TABTYPE_C_SRAM4;
6425 MDrv_PQBin_DumpTable(pInstance,&stTableInfo);
6426 }
6427 else
6428 {
6429 EN_IP_Info stIpInfo;
6430 memset(&stIpInfo, 0, sizeof(EN_IP_Info));
6431 stIpInfo = MDrv_PQ_GetTable_(MAIN,pInstance, _u16SRAM1, PQ_IP_SRAM1_Main);
6432 Hal_PQ_set_y_sram_table(pInstance,SC_FILTER_Y_SRAM3, (void *)((char *)&stIpInfo.pIPTable[stIpInfo.u8TabIdx * Hal_PQ_get_sram_size(pInstance,SC_FILTER_Y_SRAM1)]));
6433
6434 stIpInfo = MDrv_PQ_GetTable_(MAIN,pInstance, _u16SRAM2, PQ_IP_SRAM2_Main);
6435 Hal_PQ_set_y_sram_table(pInstance,SC_FILTER_Y_SRAM4, (void *)((char *)&stIpInfo.pIPTable[stIpInfo.u8TabIdx * Hal_PQ_get_sram_size(pInstance,SC_FILTER_Y_SRAM2)]));
6436
6437 stIpInfo = MDrv_PQ_GetTable_(MAIN,pInstance, u16CSRAM1, PQ_IP_C_SRAM1_Main);
6438 Hal_PQ_set_c_sram_table(pInstance,SC_FILTER_C_SRAM3, (void *)((char *)&stIpInfo.pIPTable[stIpInfo.u8TabIdx * Hal_PQ_get_sram_size(pInstance,SC_FILTER_C_SRAM1)]));
6439
6440 stIpInfo = MDrv_PQ_GetTable_(MAIN,pInstance, u16CSRAM2, PQ_IP_C_SRAM2_Main);
6441 Hal_PQ_set_c_sram_table(pInstance,SC_FILTER_C_SRAM4, (void *)((char *)&stIpInfo.pIPTable[stIpInfo.u8TabIdx * Hal_PQ_get_sram_size(pInstance,SC_FILTER_C_SRAM2)]));
6442 }
6443 }
6444
MDrv_PQ_3DCloneforPIP_U2(void * pInstance,MS_BOOL bIpSync)6445 void MDrv_PQ_3DCloneforPIP_U2(void* pInstance,MS_BOOL bIpSync)
6446 {
6447 MVOP_Handle stHdl = { E_MVOP_MODULE_MAIN };
6448 MS_BOOL bEnAltOutputState = FALSE;
6449
6450 if (E_MVOP_OK == MDrv_MVOP_GetCommand(&stHdl, E_MVOP_CMD_GET_3DLR_ALT_OUT, &bEnAltOutputState, sizeof(bEnAltOutputState)))
6451 {
6452 //printf("%s Get3DLRAltOutput=0x%x\n", __FUNCTION__, bEnAltOutputState);
6453 }
6454 else
6455 {
6456 //printf("Fail to query E_MVOP_CMD_GET_3DLR_ALT_OUT!!\n");
6457 }
6458
6459 if((E_XC_3D_OUTPUT_LINE_ALTERNATIVE == MApi_XC_Get_3D_Output_Mode())
6460 || (E_XC_3D_OUTPUT_TOP_BOTTOM == MApi_XC_Get_3D_Output_Mode())
6461 || (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF == MApi_XC_Get_3D_Output_Mode())
6462 || (E_XC_3D_OUTPUT_TOP_BOTTOM_HW == MApi_XC_Get_3D_Output_Mode())
6463 || (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF_HW == MApi_XC_Get_3D_Output_Mode())
6464 || (E_XC_3D_OUTPUT_LEFT_LEFT == MApi_XC_Get_3D_Output_Mode())
6465 || (E_XC_3D_OUTPUT_RIGHT_RIGHT == MApi_XC_Get_3D_Output_Mode())
6466 || (E_XC_3D_OUTPUT_TOP_TOP == MApi_XC_Get_3D_Output_Mode())
6467 || (E_XC_3D_OUTPUT_BOTTOM_BOTTOM == MApi_XC_Get_3D_Output_Mode()))
6468 {
6469 _MDrv_PQ_CloneSram(pInstance);
6470 #if PQ_QM_3D_CLONE_ENABLE
6471 MDrv_PQ_3D_CloneWindow(E_PQ_3DTYPE_XC, PQ_MAIN_WINDOW);
6472 #else
6473 MApi_XC_ACE_3DClonePQMap(E_ACE_WEAVETYPE_NONE);
6474 #endif
6475
6476 _s32LastPQIPMADiSub = -1;
6477 _s32LastPQIPMemFormatSub = -1;
6478 _u16LastPQSrcType[PQ_SUB_WINDOW] = 0xFFFF;
6479
6480 //printf("3D:confirm to clone main/sub win\n");
6481
6482 if((MApi_XC_Get_3D_HW_Version() < 2) && bIpSync)
6483 {
6484 MApi_XC_3DMainSub_IPSync();
6485 //printf("3D:confirm to do main/sub win sync\n");
6486 }
6487 }
6488 else if(((E_XC_3D_INPUT_TOP_BOTTOM == MApi_XC_Get_3D_Input_Mode(MAIN_WINDOW)) && (E_XC_3D_OUTPUT_FRAME_ALTERNATIVE == MApi_XC_Get_3D_Output_Mode()))
6489 || ((E_XC_3D_INPUT_NORMAL_2D == MApi_XC_Get_3D_Input_Mode(MAIN_WINDOW)) && (E_XC_3D_OUTPUT_FRAME_ALTERNATIVE == MApi_XC_Get_3D_Output_Mode())))
6490 {
6491 if(MApi_XC_Get_3D_HW_Version() < 2)
6492 {
6493 MDrv_PQ_EnableMADIForce(PQ_MAIN_WINDOW, TRUE);
6494 #if PQ_MADI_DFK
6495 MDrv_PQ_LoadTable_U2(pInstance, PQ_MAIN_WINDOW, PQ_IP_MADi_DFK_OFF_Main, PQ_IP_MADi_DFK_Main);
6496 #endif
6497 MDrv_PQ_LoadTable_U2(pInstance, PQ_MAIN_WINDOW, PQ_IP_EODi_OFF_Main, PQ_IP_EODi_Main);
6498 }
6499 }
6500 else if(MApi_XC_IsCurrentFrameBufferLessMode() && bEnAltOutputState)
6501 {
6502 MApi_XC_ACE_3DClonePQMap(E_ACE_WEAVETYPE_H);
6503 }
6504 MApi_XC_3D_PostPQSetting(MAIN_WINDOW);
6505
6506 #if(PQ_GRULE_3D_ENABLE == 1)
6507 if(E_XC_3D_OUTPUT_MODE_NONE != MApi_XC_Get_3D_Output_Mode())
6508 {
6509 MDrv_PQ_SetGRuleStatus(PQ_MAIN_WINDOW, PQ_GRule_3D_Main, PQ_GRule_3D_On_Main);
6510 }
6511 else
6512 {
6513 MDrv_PQ_SetGRuleStatus(PQ_MAIN_WINDOW, PQ_GRule_3D_Main, PQ_GRule_3D_Off_Main);
6514 }
6515 #endif
6516 }
MDrv_PQ_3DCloneforPIP(MS_BOOL bIpSync)6517 void MDrv_PQ_3DCloneforPIP(MS_BOOL bIpSync)
6518 {
6519 #ifdef TRACE_DBG
6520 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
6521 #endif
6522 if (pu32PQInst == NULL)
6523 {
6524 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
6525 return ;
6526 }
6527
6528 stPQ_3DCloneforPIP PQArgs;
6529 PQArgs.bIpSync = bIpSync;
6530 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_3D_CLONE_FOR_PIP, (void*)&PQArgs) != 0)
6531 {
6532 printf("Obtain PQ engine fail\n");
6533 return;
6534 }
6535 else
6536 {
6537 return;
6538 }
6539 }
6540
MDrv_PQ_DisableFilmMode_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bOn)6541 void MDrv_PQ_DisableFilmMode_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bOn)
6542 {
6543 if(bOn)
6544 {
6545 MDrv_PQ_SetFilmMode_U2(pInstance, eWindow, DISABLE);
6546 }
6547 else
6548 {
6549 MDrv_PQ_SetFilmMode_U2(pInstance, eWindow, ENABLE);
6550 }
6551 }
MDrv_PQ_DisableFilmMode(PQ_WIN eWindow,MS_BOOL bOn)6552 void MDrv_PQ_DisableFilmMode(PQ_WIN eWindow, MS_BOOL bOn)
6553 {
6554 if (pu32PQInst == NULL)
6555 {
6556 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
6557 {
6558 printf("UtopiaOpen PQ failed\n");
6559 return;
6560 }
6561 }
6562
6563 stPQ_DisableFilmMode PQArgs;
6564 PQArgs.eWindow = eWindow;
6565 PQArgs.bOn = bOn;
6566 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_DISABLE_FILEMODE, (void*)&PQArgs) != 0)
6567 {
6568 printf("Obtain PQ engine fail\n");
6569 return;
6570 }
6571 else
6572 {
6573 return;
6574 }
6575 }
6576 #if (PQ_GRULE_GAME_MODE_ENABLE == 1)
_MDrv_PQ_LoadGameModeTable(void * pInstance,PQ_WIN eWindow,MS_U16 u16PQ_GameMode_Idx)6577 static MS_BOOL _MDrv_PQ_LoadGameModeTable(void* pInstance, PQ_WIN eWindow, MS_U16 u16PQ_GameMode_Idx)
6578 {
6579 MS_U16 i, u16IPIdx=0, u16TabIdx=0;
6580
6581 if(eWindow == PQ_SUB_WINDOW)
6582 {
6583 return FALSE;
6584 }
6585
6586 if (u16PQ_GameMode_Idx > PQ_GRULE_GAME_MODE_LVL_NUM_Main)
6587 {
6588 MS_ASSERT(0);
6589 return FALSE;
6590 }
6591 #if(ENABLE_PQ_MLOAD == 1)
6592 MDrv_PQ_Set_MLoadEn(eWindow, TRUE);
6593 #endif
6594
6595 for(i=0; i<PQ_GRULE_GAME_MODE_IP_NUM_Main; i++)
6596 {
6597 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_U2(pInstance, eWindow, PQ_GRule_GAME_MODE_Main, i);
6598
6599 if (u16PQ_GameMode_Idx == PQ_GRULE_GAME_MODE_NUM_Main) // see it as default
6600 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance, eWindow, u16IPIdx);
6601 else
6602 u16TabIdx = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_GAME_MODE_Main, u16PQ_GameMode_Idx, i);
6603
6604 PQGRULE_DBG(printf("[GameMode]SRC: %u, u16PQ_GameMode_Idx: %u, GameModeIPIdx:%u, IPIdx:%u, u8TabIdx:%u\n",
6605 _u16PQSrcType[eWindow], u16PQ_GameMode_Idx, i, u16IPIdx, u16TabIdx));
6606
6607 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, u16IPIdx);
6608 }
6609 #if(ENABLE_PQ_MLOAD == 1)
6610 MDrv_PQ_Set_MLoadEn(eWindow, FALSE);
6611 #endif
6612 return TRUE;
6613 }
6614 #endif
6615 //void _MDrv_PQ_LoadPTPTable(PQ_WIN eWindow, MS_U16 u16PQ_PTP_Idx);
6616
6617 #if defined(PQ_GRULE_HDR_ENABLE) && (PQ_GRULE_HDR_ENABLE == 1)
_MDrv_PQ_LoadHDRModeTable(PQ_WIN eWindow,MS_U16 u16GRuleLevelIndex)6618 static MS_BOOL _MDrv_PQ_LoadHDRModeTable(PQ_WIN eWindow, MS_U16 u16GRuleLevelIndex)
6619 {
6620 MS_U16 i, u16IPIdx=0, u16TabIdx=0;
6621 MS_U16 u16PQ_HDRMode_Idx=0;
6622
6623 if(eWindow == PQ_SUB_WINDOW)
6624 {
6625 return FALSE;
6626 }
6627
6628 u16PQ_HDRMode_Idx = MDrv_PQ_GetGRule_LevelIndex(eWindow, PQ_GRule_HDR_Main, u16GRuleLevelIndex);
6629
6630 if (u16PQ_HDRMode_Idx > PQ_GRULE_HDR_NUM_Main)
6631 {
6632 MS_ASSERT(0);
6633 return FALSE;
6634 }
6635 #if(ENABLE_PQ_MLOAD == 1)
6636 MDrv_PQ_Set_MLoadEn(eWindow, TRUE);
6637 #endif
6638
6639 for(i=0; i<PQ_GRULE_HDR_IP_NUM_Main; i++)
6640 {
6641 u16IPIdx = MDrv_PQ_GetGRule_IPIndex(eWindow, PQ_GRule_HDR_Main, i);
6642
6643 if (u16PQ_HDRMode_Idx == PQ_GRULE_HDR_NUM_Main) // see it as default
6644 u16TabIdx = MDrv_PQ_GetTableIndex(eWindow, u16IPIdx);
6645 else
6646 u16TabIdx = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_HDR_Main, u16PQ_HDRMode_Idx, i);
6647
6648 PQGRULE_DBG(printf("[HDRMode]SRC: %u, u16PQ_HDRMode_Idx: %u, HDRModeIPIdx:%u, IPIdx:%u, u8TabIdx:%u\n",
6649 _u16PQSrcType[eWindow], u16PQ_HDRMode_Idx, i, u16IPIdx, u16TabIdx));
6650
6651 MDrv_PQ_LoadTable(eWindow, u16TabIdx, u16IPIdx);
6652 }
6653 #if(ENABLE_PQ_MLOAD == 1)
6654 MDrv_PQ_Set_MLoadEn(eWindow, FALSE);
6655 #endif
6656
6657 #if defined(PQ_GRULE_UFSC_HDR_ENABLE) && (PQ_GRULE_UFSC_HDR_ENABLE == 1)
6658 u16PQ_HDRMode_Idx = MDrv_PQ_GetGRule_LevelIndex_Ex(eWindow, PQ_GRule_HDR_UFSC,u16GRuleLevelIndex, PQ_XC0_UFSC);
6659
6660 if(u16PQ_HDRMode_Idx > PQ_GRULE_HDR_NUM_UFSC)
6661 {
6662 MS_ASSERT(0);
6663 return FALSE;
6664 }
6665
6666 for(i = 0; i < PQ_GRULE_HDR_IP_NUM_UFSC; i++)
6667 {
6668 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_Ex(eWindow, PQ_GRule_HDR_UFSC, i, PQ_XC0_UFSC);
6669
6670 if(u16PQ_HDRMode_Idx == PQ_GRULE_HDR_NUM_UFSC) // see it as default
6671 u16TabIdx = MDrv_PQ_GetTableIndex_Ex(eWindow, u16TabIdx, PQ_XC0_UFSC);
6672 else
6673 u16TabIdx = MDrv_PQ_GetGRule_TableIndex_Ex(eWindow, PQ_GRule_HDR_UFSC, u16PQ_HDRMode_Idx, i,PQ_XC0_UFSC);
6674
6675 PQGRULE_DBG(printf("[DC]SRC: %u, DC: %u, DCIPIdx:%u, IPIdx:%u, u16TabIdx:%u\n",
6676 _u16PQSrcType[eWindow], u16PQ_HDRMode_Idx, i, u16IPIdx, u16TabIdx));
6677
6678 MDrv_PQ_LoadTable_Ex(eWindow, u16TabIdx, u16IPIdx, PQ_XC0_UFSC);
6679 }
6680 #endif
6681
6682 return TRUE;
6683 }
6684 #endif
6685
MDrv_PQ_EnableHDRMode(PQ_WIN eWindow,MS_U16 u16GRuleLevelIndex)6686 MS_BOOL MDrv_PQ_EnableHDRMode(PQ_WIN eWindow ,MS_U16 u16GRuleLevelIndex)
6687 {
6688 UNUSED(eWindow);
6689 UNUSED(u16GRuleLevelIndex);
6690
6691 #if defined(PQ_GRULE_HDR_ENABLE) && (PQ_GRULE_HDR_ENABLE == 1)
6692 _MDrv_PQ_LoadHDRModeTable(eWindow, u16GRuleLevelIndex);
6693 #endif
6694 return TRUE;
6695 }
6696
MDrv_PQ_DisableUCFeature_U2(void * pInstance,PQ_WIN eWindow)6697 MS_BOOL MDrv_PQ_DisableUCFeature_U2(void* pInstance,PQ_WIN eWindow)
6698 {
6699 MS_BOOL bRet = FALSE;
6700 UNUSED(eWindow);
6701 #if (PQ_GRULE_GAME_MODE_ENABLE == 1)
6702 PQGRULE_DBG(printf("[PQ_LoadGameModeTable] "));
6703 MS_U16 u16PQ_GameModeIdx;
6704
6705 if(eWindow == PQ_SUB_WINDOW)
6706 {
6707 return FALSE;
6708 }
6709 PQMADi_DBG(printf("Disable UC feature by loading Game mode Grule\n");)
6710
6711 u16PQ_GameModeIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_GAME_MODE_Main, PQ_GRule_Lvl_GAME_MODE_On_Main);
6712 bRet = _MDrv_PQ_LoadGameModeTable(pInstance, eWindow, u16PQ_GameModeIdx);
6713
6714 if(_gIsEnable8LBMode)
6715 {
6716 MDrv_PQBin_Enable8LBMode(pInstance,TRUE);
6717 if(MApi_XC_Set_OPWriteOffEnableToReg)
6718 {
6719 MApi_XC_Set_OPWriteOffEnableToReg(ENABLE, MAIN_WINDOW); //default
6720 }
6721 }
6722
6723 #else
6724 #if PQ_UC_CTL
6725 bRet = MDrv_PQ_SetUCFeature(PQ_MAIN_WINDOW,
6726 0xFFFF,
6727 0xFFFF,
6728 PQ_IP_MADi_DFK_DFK1_Main,
6729 PQ_IP_MADi_SST_SST3_Main,
6730 PQ_IP_MADi_EODiW_OFF_Main,
6731 PQ_IP_UCNR_OFF_Main,
6732 PQ_IP_UCDi_OFF_Main,
6733 PQ_IP_UC_CTL_OFF_Main,
6734 0xFFFF,
6735 0xFFFF,
6736 0xFFFF
6737 );
6738 #endif
6739 #endif
6740 return bRet;
6741 }
MDrv_PQ_DisableUCFeature(PQ_WIN eWindow)6742 MS_BOOL MDrv_PQ_DisableUCFeature(PQ_WIN eWindow)
6743 {
6744 #ifdef TRACE_DBG
6745 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
6746 #endif
6747 if (pu32PQInst == NULL)
6748 {
6749 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
6750 return FALSE;
6751 }
6752
6753 stPQ_DisableUCFeature PQArgs;
6754 PQArgs.eWindow = eWindow;
6755 PQArgs.bReturnValue = FALSE;
6756 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_DISABLE_UC_FEATURE, (void*)&PQArgs) != 0)
6757 {
6758 printf("Obtain PQ engine fail\n");
6759 return FALSE;
6760 }
6761 else
6762 {
6763 return PQArgs.bReturnValue;
6764 }
6765 }
6766
6767
MDrv_PQ_GetCurrentUCFeature_U2(void * pInstance,PQ_WIN eWindow,MS_U16 * pu16TabIdx_MADi,MS_U16 * pu16TabIdx_MADi_Mot,MS_U16 * pu16TabIdx_MADi_DFK,MS_U16 * pu16TabIdx_MADi_SST,MS_U16 * pu16TabIdx_MADi_EODiW,MS_U16 * pu16TabIdx_UCNR,MS_U16 * pu16TabIdx_UCDi,MS_U16 * pu16TabIdx_UCCTL,MS_U16 * pu16TabIdx_SwDriver,MS_U16 * pu16TabIdx_PostCCS,MS_U16 * pu16TabIdx_DHD)6768 MS_BOOL MDrv_PQ_GetCurrentUCFeature_U2(void* pInstance,
6769 PQ_WIN eWindow,
6770 MS_U16 *pu16TabIdx_MADi,
6771 MS_U16 *pu16TabIdx_MADi_Mot,
6772 MS_U16 *pu16TabIdx_MADi_DFK,
6773 MS_U16 *pu16TabIdx_MADi_SST,
6774 MS_U16 *pu16TabIdx_MADi_EODiW,
6775 MS_U16 *pu16TabIdx_UCNR,
6776 MS_U16 *pu16TabIdx_UCDi,
6777 MS_U16 *pu16TabIdx_UCCTL,
6778 MS_U16 *pu16TabIdx_SwDriver,
6779 MS_U16 *pu16TabIdx_PostCCS,
6780 MS_U16 *pu16TabIdx_DHD
6781 )
6782 {
6783 if( (pu16TabIdx_MADi_DFK == NULL)
6784 ||(pu16TabIdx_MADi_SST == NULL)
6785 ||(pu16TabIdx_MADi_EODiW == NULL)
6786 ||(pu16TabIdx_UCDi == NULL)
6787 ||(pu16TabIdx_UCCTL == NULL)
6788 ||(pu16TabIdx_UCNR == NULL)
6789 )
6790 {
6791 printf("MDrv_PQ_GetCurrentUCFeature(), don't pass in NULL pointer!");
6792 return FALSE;
6793 }
6794 #if PQ_UC_CTL
6795
6796 *pu16TabIdx_MADi = (eWindow==PQ_MAIN_WINDOW)?_s32LastPQIPMADiMain:_s32LastPQIPMADiSub;
6797 *pu16TabIdx_MADi_Mot = (eWindow==PQ_MAIN_WINDOW)?_s32LastPQIPMADiMotMain:_s32LastPQIPMADiMotSub;
6798 *pu16TabIdx_MADi_DFK = _u16MADi_DFK_Current[eWindow];
6799 *pu16TabIdx_MADi_SST = _u16MADi_SST_Current[eWindow];
6800 *pu16TabIdx_MADi_EODiW = _u16MADi_EODiW_Current[eWindow];
6801 *pu16TabIdx_UCDi = _u16UCDi_Current[eWindow];
6802 *pu16TabIdx_UCCTL = _u16UCCTL_Current[eWindow];
6803 *pu16TabIdx_UCNR = _u16UCNR_Current[eWindow];
6804 *pu16TabIdx_SwDriver = _u16SwDriver_Current[eWindow];
6805 *pu16TabIdx_PostCCS = _u16PostCCS_Current[eWindow];
6806 *pu16TabIdx_DHD = _u16DHD_Current[eWindow];
6807 PQMADi_DBG(printf("MDrv_PQ_GetCurrentUCFeature(%u, %u, %u,%u,%u,%u,%u,%u,%u,%u,%u)\n",
6808 *pu16TabIdx_MADi,
6809 *pu16TabIdx_MADi_Mot,
6810 *pu16TabIdx_MADi_DFK,
6811 *pu16TabIdx_MADi_SST,
6812 *pu16TabIdx_MADi_EODiW,
6813 *pu16TabIdx_UCNR,
6814 *pu16TabIdx_UCDi,
6815 *pu16TabIdx_UCCTL,
6816 *pu16TabIdx_SwDriver,
6817 *pu16TabIdx_PostCCS,
6818 *pu16TabIdx_DHD));
6819
6820 return TRUE;
6821 #else
6822 return FALSE;
6823 #endif
6824 }
MDrv_PQ_GetCurrentUCFeature(PQ_WIN eWindow,MS_U16 * pu16TabIdx_MADi,MS_U16 * pu16TabIdx_MADi_Mot,MS_U16 * pu16TabIdx_MADi_DFK,MS_U16 * pu16TabIdx_MADi_SST,MS_U16 * pu16TabIdx_MADi_EODiW,MS_U16 * pu16TabIdx_UCNR,MS_U16 * pu16TabIdx_UCDi,MS_U16 * pu16TabIdx_UCCTL,MS_U16 * pu16TabIdx_SwDriver,MS_U16 * pu16TabIdx_PostCCS,MS_U16 * pu16TabIdx_DHD)6825 MS_BOOL MDrv_PQ_GetCurrentUCFeature(PQ_WIN eWindow,
6826 MS_U16 *pu16TabIdx_MADi,
6827 MS_U16 *pu16TabIdx_MADi_Mot,
6828 MS_U16 *pu16TabIdx_MADi_DFK,
6829 MS_U16 *pu16TabIdx_MADi_SST,
6830 MS_U16 *pu16TabIdx_MADi_EODiW,
6831 MS_U16 *pu16TabIdx_UCNR,
6832 MS_U16 *pu16TabIdx_UCDi,
6833 MS_U16 *pu16TabIdx_UCCTL,
6834 MS_U16 *pu16TabIdx_SwDriver,
6835 MS_U16 *pu16TabIdx_PostCCS,
6836 MS_U16 *pu16TabIdx_DHD
6837 )
6838 {
6839 #ifdef TRACE_DBG
6840 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
6841 #endif
6842 if (pu32PQInst == NULL)
6843 {
6844 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
6845 return FALSE;
6846 }
6847
6848 stPQ_GetCurrentUCFeature PQArgs;
6849 PQArgs.eWindow = eWindow;
6850 PQArgs.pu16TabIdx_MADi = pu16TabIdx_MADi;
6851 PQArgs.pu16TabIdx_MADi_Mot = pu16TabIdx_MADi_Mot;
6852 PQArgs.pu16TabIdx_MADi_DFK = pu16TabIdx_MADi_DFK;
6853 PQArgs.pu16TabIdx_MADi_SST = pu16TabIdx_MADi_SST;
6854 PQArgs.pu16TabIdx_MADi_EODiW = pu16TabIdx_MADi_EODiW;
6855 PQArgs.pu16TabIdx_UCNR = pu16TabIdx_UCNR;
6856 PQArgs.pu16TabIdx_UCDi = pu16TabIdx_UCDi;
6857 PQArgs.pu16TabIdx_UCCTL = pu16TabIdx_UCCTL;
6858 PQArgs.pu16TabIdx_SwDriver =pu16TabIdx_SwDriver ;
6859 PQArgs.pu16TabIdx_PostCCS =pu16TabIdx_PostCCS ;
6860 PQArgs.pu16TabIdx_DHD =pu16TabIdx_DHD ;
6861 PQArgs.bReturnValue = FALSE;
6862 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_CURRENT_UC_FEATURE, (void*)&PQArgs) != 0)
6863 {
6864 printf("Obtain PQ engine fail\n");
6865 return FALSE;
6866 }
6867 else
6868 {
6869 return PQArgs.bReturnValue;
6870 }
6871 }
6872
MDrv_PQ_GetUCFeatureFromPQ_U2(void * pInstance,PQ_WIN eWindow,MS_U16 * pu16TabIdx_MADi_DFK,MS_U16 * pu16TabIdx_MADi_SST,MS_U16 * pu16TabIdx_MADi_EODiW,MS_U16 * pu16TabIdx_UCNR,MS_U16 * pu16TabIdx_UCDi,MS_U16 * pu16TabIdx_UCCTL,MS_U16 * pu16TabIdx_SwDriver,MS_U16 * pu16TabIdx_PostCCS,MS_U16 * pu16TabIdx_DHD)6873 MS_BOOL MDrv_PQ_GetUCFeatureFromPQ_U2(void* pInstance,
6874 PQ_WIN eWindow,
6875 MS_U16 *pu16TabIdx_MADi_DFK,
6876 MS_U16 *pu16TabIdx_MADi_SST,
6877 MS_U16 *pu16TabIdx_MADi_EODiW,
6878 MS_U16 *pu16TabIdx_UCNR,
6879 MS_U16 *pu16TabIdx_UCDi,
6880 MS_U16 *pu16TabIdx_UCCTL,
6881 MS_U16 *pu16TabIdx_SwDriver,
6882 MS_U16 *pu16TabIdx_PostCCS,
6883 MS_U16 *pu16TabIdx_DHD)
6884 {
6885 if( (pu16TabIdx_MADi_DFK == NULL)
6886 ||(pu16TabIdx_MADi_SST == NULL)
6887 ||(pu16TabIdx_MADi_EODiW == NULL)
6888 ||(pu16TabIdx_UCDi == NULL)
6889 ||(pu16TabIdx_UCCTL == NULL)
6890 ||(pu16TabIdx_UCNR == NULL)
6891 ||(pu16TabIdx_SwDriver == NULL)
6892 ||(pu16TabIdx_PostCCS == NULL)
6893 ||(pu16TabIdx_DHD == NULL)
6894 )
6895 {
6896 printf(" \r\n MDrv_PQ_GetUCFeatureFromPQ , don't pass in NULL pointer!");
6897 return FALSE;
6898 }
6899
6900 *pu16TabIdx_MADi_DFK =0xFFFF;
6901 *pu16TabIdx_MADi_SST = 0xFFFF;
6902 *pu16TabIdx_MADi_EODiW = 0xFFFF;
6903 *pu16TabIdx_UCNR = 0xFFFF;
6904 *pu16TabIdx_UCDi = 0xFFFF;
6905 *pu16TabIdx_UCCTL = 0xFFFF;
6906 *pu16TabIdx_SwDriver = 0xFFFF;
6907 *pu16TabIdx_PostCCS = 0xFFFF;
6908 *pu16TabIdx_DHD = 0xFFFF;
6909 #if PQ_UC_CTL
6910
6911 #if (PQ_GRULE_DDR_SELECT_ENABLE == 1)
6912 #if (PQ_DDR_SELECT_VER == 1)
6913 //do nothing, because ddr select rule has no uc item in version1
6914 #elif (PQ_DDR_SELECT_VER == 2)
6915 MS_U16 u16PQ_DDRSELIdx = 0;
6916
6917 if(bw_info.bDDR2 == FALSE) // DDR 3
6918 {
6919 if(MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW) != MIRROR_NORMAL)
6920 {
6921 PQMADi_DBG(printf("MDrv_PQ_GetDDRMirrorSelectInfo: DDR3 mirror\n"));
6922 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_DDR3_Mirror_Main);
6923 }
6924 else
6925 {
6926 PQMADi_DBG(printf("MDrv_PQ_GetDDRMirrorSelectInfo: DDR3 non-mirror\n"));
6927 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_DDR3_Main);
6928 }
6929 }
6930 else // DDR 2
6931 {
6932 if(MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW) != MIRROR_NORMAL)
6933 {
6934 PQMADi_DBG(printf("MDrv_PQ_GetDDRMirrorSelectInfo: DDR2 mirror\n"));
6935 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_DDR2_Mirror_Main);
6936 }
6937 else
6938 {
6939 PQMADi_DBG(printf("MDrv_PQ_GetDDRMirrorSelectInfo: DDR2 non-mirror\n"));
6940 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_DDR2_Main);
6941 }
6942 }
6943 *pu16TabIdx_MADi_DFK = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_DDR_SELECT_Main, u16PQ_DDRSELIdx, 2);
6944 *pu16TabIdx_MADi_SST = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_DDR_SELECT_Main, u16PQ_DDRSELIdx, 3);
6945 *pu16TabIdx_MADi_EODiW = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_DDR_SELECT_Main, u16PQ_DDRSELIdx, 4);
6946 *pu16TabIdx_UCCTL = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_DDR_SELECT_Main, u16PQ_DDRSELIdx, 5);
6947 #endif
6948 #else //DDR select disable
6949 if(eWindow == PQ_MAIN_WINDOW)
6950 {
6951 *pu16TabIdx_MADi_DFK = MDrv_PQ_GetTableIndex_U2(pInstance, eWindow, PQ_IP_MADi_DFK_Main); //y MADi_DFK ip
6952 *pu16TabIdx_MADi_SST = MDrv_PQ_GetTableIndex_U2(pInstance, eWindow, PQ_IP_MADi_SST_Main); //y MADi_SST ip
6953 *pu16TabIdx_MADi_EODiW = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_MADi_EODiW_Main); //y MADi_EODiW ip
6954
6955 *pu16TabIdx_UCDi = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_UCDi_Main); //y UCDi ip
6956 *pu16TabIdx_UCCTL = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_UC_CTL_Main); //y UCCTL ip
6957 }
6958 #if PQ_ENABLE_PIP
6959 else
6960 {
6961 *pu16TabIdx_MADi_DFK = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_MADi_DFK_Sub); // MADi_DFK ip
6962 *pu16TabIdx_MADi_SST = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_MADi_SST_Sub); // MADi_SST ip
6963 }
6964 #endif
6965
6966
6967 //printf("$$[%s]:%d, %s, u16TabIdx_UCCTL=%u\n", __FUNCTION__, __LINE__, eWindow?"SUB":"MAIN", *pu16TabIdx_UCCTL);
6968 #endif
6969
6970 #if (PQ_GRULE_GAME_MODE_ENABLE == 1)
6971 if(eWindow == PQ_MAIN_WINDOW)
6972 {
6973 *pu16TabIdx_SwDriver = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_SwDriver_Main);
6974 *pu16TabIdx_PostCCS = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_PostCCS_Main);
6975 *pu16TabIdx_DHD = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_DHD_Main);
6976 }
6977 #if PQ_ENABLE_PIP
6978 else
6979 {
6980 *pu16TabIdx_SwDriver = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_SwDriver_Sub);
6981 #if PQ_SUPPORT_SUB_POSTCCS
6982 *pu16TabIdx_PostCCS = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_PostCCS_Sub);
6983 #endif
6984
6985 #if PQ_SUPPORT_SUB_DHD
6986 *pu16TabIdx_DHD = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_DHD_Sub);
6987 #endif
6988 }
6989 #endif
6990 #endif
6991
6992 #if (PQ_GRULE_SLZ_ENABLE == 1)
6993 MS_U16 u16PQ_SLZIdx = 0;
6994 MS_BOOL bSeamlessZappingEnable;
6995
6996 if(MApi_XC_GetSeamlessZappingStatus(eWindow, &bSeamlessZappingEnable) == E_APIXC_RET_OK)
6997 {
6998 if(bSeamlessZappingEnable)
6999 {
7000 if(eWindow == PQ_MAIN_WINDOW)
7001 {
7002 u16PQ_SLZIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_SLZ_Main, PQ_GRule_Lvl_SLZ_On_Main);
7003 PQMADi_DBG(printf("MDrv_PQ_GetUCFeatureFromPQ: Main LSZ =%u\n", u16PQ_SLZIdx));
7004 *pu16TabIdx_MADi_DFK = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_SLZ_Main, u16PQ_SLZIdx, 2); //y MADi_DFK ip
7005 *pu16TabIdx_MADi_SST = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_SLZ_Main, u16PQ_SLZIdx, 3); //y MADi_SST ip
7006 *pu16TabIdx_MADi_EODiW = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_SLZ_Main, u16PQ_SLZIdx, 4); //y MADi_EODiW ip
7007
7008 *pu16TabIdx_UCDi = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_SLZ_Main, u16PQ_SLZIdx, 5); //y UCDi ip
7009 *pu16TabIdx_UCCTL = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_SLZ_Main, u16PQ_SLZIdx, 6); //y UCCTL ip
7010 }
7011 #if PQ_ENABLE_PIP
7012 else
7013 {
7014 u16PQ_SLZIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_SLZ_Sub, PQ_GRule_Lvl_SLZ_On_Sub);
7015 PQMADi_DBG(printf("MDrv_PQ_GetUCFeatureFromPQ: Sub LSZ =%u\n", u16PQ_SLZIdx));
7016 *pu16TabIdx_MADi_DFK = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_SLZ_Sub, u16PQ_SLZIdx, 2); // MADi_DFK ip
7017 *pu16TabIdx_MADi_SST = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_SLZ_Sub, u16PQ_SLZIdx, 3); // MADi_SST ip
7018 }
7019 #endif
7020 }
7021 else
7022 {
7023 //it's not slz case
7024 }
7025 }
7026 else
7027 {
7028 printf("MApi_XC_GetStatusEx () version is incorrect at %s %d, the code's purpose is not fulfilled.\n",__FILE__,(int)__LINE__);
7029 }
7030
7031 //printf("$$[%s]:%d, %s, u16TabIdx_UCCTL=%u\n", __FUNCTION__, __LINE__, eWindow?"SUB":"MAIN", *pu16TabIdx_UCCTL);
7032
7033 UNUSED(pu16TabIdx_UCNR);
7034 #else
7035 UNUSED(pu16TabIdx_UCNR);
7036 UNUSED(pu16TabIdx_UCDi);
7037 UNUSED(pu16TabIdx_UCCTL);
7038 UNUSED(pu16TabIdx_MADi_DFK);
7039 UNUSED(pu16TabIdx_MADi_SST);
7040 UNUSED(pu16TabIdx_MADi_EODiW);
7041 UNUSED(pu16TabIdx_SwDriver);
7042 UNUSED(pu16TabIdx_PostCCS);
7043 UNUSED(pu16TabIdx_DHD);
7044 #endif
7045
7046 #endif
7047 PQMADi_DBG(printf("MDrv_PQ_GetUCFeatureFromPQ(%u,%u,%u,%u,%u,%u,%u,%u,%u)\n",*pu16TabIdx_MADi_DFK,
7048 *pu16TabIdx_MADi_SST,
7049 *pu16TabIdx_MADi_EODiW,
7050 *pu16TabIdx_UCNR,
7051 *pu16TabIdx_UCDi,
7052 *pu16TabIdx_UCCTL,
7053 *pu16TabIdx_SwDriver,
7054 *pu16TabIdx_PostCCS,
7055 *pu16TabIdx_DHD));
7056 return TRUE;
7057 }
7058
MDrv_PQ_GetUCFeatureFromPQ(PQ_WIN eWindow,MS_U16 * pu16TabIdx_MADi_DFK,MS_U16 * pu16TabIdx_MADi_SST,MS_U16 * pu16TabIdx_MADi_EODiW,MS_U16 * pu16TabIdx_UCNR,MS_U16 * pu16TabIdx_UCDi,MS_U16 * pu16TabIdx_UCCTL,MS_U16 * pu16TabIdx_SwDriver,MS_U16 * pu16TabIdx_PostCCS,MS_U16 * pu16TabIdx_DHD)7059 MS_BOOL MDrv_PQ_GetUCFeatureFromPQ(PQ_WIN eWindow,
7060 MS_U16 *pu16TabIdx_MADi_DFK,
7061 MS_U16 *pu16TabIdx_MADi_SST,
7062 MS_U16 *pu16TabIdx_MADi_EODiW,
7063 MS_U16 *pu16TabIdx_UCNR,
7064 MS_U16 *pu16TabIdx_UCDi,
7065 MS_U16 *pu16TabIdx_UCCTL,
7066 MS_U16 *pu16TabIdx_SwDriver,
7067 MS_U16 *pu16TabIdx_PostCCS,
7068 MS_U16 *pu16TabIdx_DHD)
7069 {
7070 #ifdef TRACE_DBG
7071 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7072 #endif
7073 if (pu32PQInst == NULL)
7074 {
7075 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7076 return FALSE;
7077 }
7078
7079 stPQ_GetUCFeatureFromPQ PQArgs;
7080 PQArgs.eWindow = eWindow;
7081 PQArgs.pu16TabIdx_MADi_DFK = pu16TabIdx_MADi_DFK;
7082 PQArgs.pu16TabIdx_MADi_SST = pu16TabIdx_MADi_SST;
7083 PQArgs.pu16TabIdx_MADi_EODiW = pu16TabIdx_MADi_EODiW;
7084 PQArgs.pu16TabIdx_UCNR = pu16TabIdx_UCNR;
7085 PQArgs.pu16TabIdx_UCDi = pu16TabIdx_UCDi;
7086 PQArgs.pu16TabIdx_UCCTL = pu16TabIdx_UCCTL;
7087 PQArgs.pu16TabIdx_SwDriver =pu16TabIdx_SwDriver ;
7088 PQArgs.pu16TabIdx_PostCCS =pu16TabIdx_PostCCS ;
7089 PQArgs.pu16TabIdx_DHD =pu16TabIdx_DHD ;
7090 PQArgs.bReturnValue = FALSE;
7091 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_UC_FEATURE_FROM_PQ, (void*)&PQArgs) != 0)
7092 {
7093 printf("Obtain PQ engine fail\n");
7094 return FALSE;
7095 }
7096 else
7097 {
7098 return PQArgs.bReturnValue;
7099 }
7100 }
7101
7102 #if(PQ_GRULE_GAME_MODE_ENABLE == 1)
MDrv_PQ_EnableUCFeature_U2(void * pInstance,PQ_WIN eWindow)7103 MS_BOOL MDrv_PQ_EnableUCFeature_U2(void* pInstance,PQ_WIN eWindow)
7104 {
7105 MS_BOOL bRet = TRUE;
7106 MS_U8 i = 0 ;
7107 MS_U16 u16IPIdx = 0xFFFF;
7108 MS_U16 u16IPTabIdx_Mode = 0xFFFF;
7109 MS_U16 u16TabIdx_UCCTL= 0xFFFF;
7110
7111 #if(ENABLE_PQ_MLOAD == 1)
7112 MDrv_PQ_Set_MLoadEn(eWindow, TRUE);
7113 #endif
7114 if(eWindow == PQ_MAIN_WINDOW)
7115 {
7116 #if (PQ_GRULE_DDR_SELECT_ENABLE == 1)
7117 #if (PQ_DDR_SELECT_VER == 1)
7118 //do nothing, because ddr select rule has no uc item in version1
7119 #elif (PQ_DDR_SELECT_VER == 2)
7120 MS_U16 u16PQ_DDRSELIdx = 0;
7121 MS_U16 u16TabIdx_MADi_DFK_DDR = 0xFFFF;
7122 MS_U16 u16TabIdx_MADi_SST_DDR = 0xFFFF;
7123 MS_U16 u16TabIdx_MADi_EODiW_DDR = 0xFFFF;
7124 MS_U16 u16TabIdx_UCCTL_DDR = 0xFFFF;
7125 if(bw_info.bDDR2 == FALSE) // DDR 3
7126 {
7127 if(MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW) != MIRROR_NORMAL)
7128 {
7129 PQMADi_DBG(printf("MDrv_PQ_GetDDRMirrorSelectInfo: DDR3 mirror\n"));
7130 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_DDR3_Mirror_Main);
7131 }
7132 else
7133 {
7134 PQMADi_DBG(printf("MDrv_PQ_GetDDRMirrorSelectInfo: DDR3 non-mirror\n"));
7135 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_DDR3_Main);
7136 }
7137 }
7138 else // DDR 2
7139 {
7140 if(MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW) != MIRROR_NORMAL)
7141 {
7142 PQMADi_DBG(printf("MDrv_PQ_GetDDRMirrorSelectInfo: DDR2 mirror\n"));
7143 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_DDR2_Mirror_Main);
7144 }
7145 else
7146 {
7147 PQMADi_DBG(printf("MDrv_PQ_GetDDRMirrorSelectInfo: DDR2 non-mirror\n"));
7148 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_DDR2_Main);
7149 }
7150 }
7151
7152 u16TabIdx_MADi_DFK_DDR = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_DDR_SELECT_Main, u16PQ_DDRSELIdx, 2);
7153 u16TabIdx_MADi_SST_DDR = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_DDR_SELECT_Main, u16PQ_DDRSELIdx, 3);
7154 u16TabIdx_MADi_EODiW_DDR = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_DDR_SELECT_Main, u16PQ_DDRSELIdx, 4);
7155 u16TabIdx_UCCTL_DDR = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_DDR_SELECT_Main, u16PQ_DDRSELIdx, 5);
7156 #endif
7157 #endif
7158 for(i=0; i<PQ_GRULE_GAME_MODE_IP_NUM_Main; i++)
7159 {
7160 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_U2(pInstance, PQ_MAIN_WINDOW, PQ_GRule_GAME_MODE_Main, i);
7161 if(u16IPIdx == PQ_IP_MADi_Main)
7162 {
7163 u16IPTabIdx_Mode =_gu16SetMemfmt_Madi[eWindow];
7164 }
7165 else if(u16IPIdx == PQ_IP_MADi_Motion_Main)
7166 {
7167 u16IPTabIdx_Mode = _gu16SetMemfmt_Madi_Motion[eWindow] ;
7168 }
7169 #if (PQ_GRULE_DDR_SELECT_ENABLE == 1)
7170 #if (PQ_DDR_SELECT_VER == 1)
7171 //do nothing, because ddr select rule has no uc item in version1
7172 #elif (PQ_DDR_SELECT_VER == 2)
7173 else if (u16IPIdx == PQ_IP_MADi_DFK_Main)
7174 {
7175 u16IPTabIdx_Mode = u16TabIdx_MADi_DFK_DDR;
7176 }
7177 else if (u16IPIdx == PQ_IP_MADi_SST_Main)
7178 {
7179 u16IPTabIdx_Mode = u16TabIdx_MADi_SST_DDR;
7180 }
7181 else if (u16IPIdx == PQ_IP_MADi_EODiW_Main)
7182 {
7183 u16IPTabIdx_Mode = u16TabIdx_MADi_EODiW_DDR;
7184 }
7185 else if (u16IPIdx == PQ_IP_UC_CTL_Main)
7186 {
7187 u16IPTabIdx_Mode = u16TabIdx_UCCTL_DDR;
7188 }
7189 #endif
7190 #endif
7191 else
7192 {
7193 u16IPTabIdx_Mode = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, u16IPIdx);
7194 }
7195
7196 PQGRULE_DBG(printf("[UC FEATURE]SRC: %u, uc feature IPIdx:%u, IPIdx:%u, u8TabIdx:%u\n",
7197 _u16PQSrcType[eWindow], i, u16IPIdx, u16IPTabIdx_Mode));
7198 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16IPTabIdx_Mode, u16IPIdx);
7199
7200 if (u16IPIdx == PQ_IP_UC_CTL_Main)
7201 {
7202 u16TabIdx_UCCTL = u16IPTabIdx_Mode;
7203 }
7204 }
7205 if(_gIsEnable8LBMode)
7206 {
7207 if(u16TabIdx_UCCTL == PQ_IP_UC_CTL_OFF_Main)
7208 {
7209 if(MApi_XC_Set_OPWriteOffEnableToReg)
7210 {
7211 MApi_XC_Set_OPWriteOffEnableToReg(ENABLE, MAIN_WINDOW);
7212 }
7213 }
7214 else
7215 {
7216 if(MApi_XC_Set_OPWriteOffEnableToReg)
7217 {
7218 MApi_XC_Set_OPWriteOffEnableToReg(DISABLE, MAIN_WINDOW);
7219 }
7220 }
7221 }
7222 }
7223 #if(PQ_ENABLE_PIP == 1)
7224 else // Sub Window
7225 {
7226 // Sub wibndow not support UC Feature, Do Nothing
7227 }
7228 #endif
7229 if(_gIsEnable8LBMode)
7230 {
7231 MDrv_PQBin_Enable8LBMode(pInstance,TRUE);
7232 }
7233
7234 #if(ENABLE_PQ_MLOAD == 1)
7235 MDrv_PQ_Set_MLoadEn(eWindow, FALSE);
7236 #endif
7237 return bRet;
7238 }
MDrv_PQ_EnableUCFeature(PQ_WIN eWindow)7239 MS_BOOL MDrv_PQ_EnableUCFeature(PQ_WIN eWindow)
7240 {
7241 #ifdef TRACE_DBG
7242 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7243 #endif
7244 if (pu32PQInst == NULL)
7245 {
7246 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7247 return FALSE;
7248 }
7249
7250 stPQ_EnableUCFeature PQArgs;
7251 PQArgs.eWindow = eWindow;
7252 PQArgs.bReturnValue = FALSE;
7253 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_ENABLE_UC_FEATURE, (void*)&PQArgs) != 0)
7254 {
7255 printf("Obtain PQ engine fail\n");
7256 return FALSE;
7257 }
7258 else
7259 {
7260 return PQArgs.bReturnValue;
7261 }
7262 }
7263 #endif
7264
7265
MDrv_PQ_SetUCFeature_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16TabIdx_MADi,MS_U16 u16TabIdx_MADi_Mot,MS_U16 u16TabIdx_MADi_DFK,MS_U16 u16TabIdx_MADi_SST,MS_U16 u16TabIdx_MADi_EODiW,MS_U16 u16TabIdx_UCNR,MS_U16 u16TabIdx_UCDi,MS_U16 u16TabIdx_UCCTL,MS_U16 u16TabIdx_SwDriver,MS_U16 u16TabIdx_PostCCS,MS_U16 u16TabIdx_DHD)7266 MS_BOOL MDrv_PQ_SetUCFeature_U2(void* pInstance,
7267 PQ_WIN eWindow,
7268 MS_U16 u16TabIdx_MADi,
7269 MS_U16 u16TabIdx_MADi_Mot,
7270 MS_U16 u16TabIdx_MADi_DFK,
7271 MS_U16 u16TabIdx_MADi_SST,
7272 MS_U16 u16TabIdx_MADi_EODiW,
7273 MS_U16 u16TabIdx_UCNR,
7274 MS_U16 u16TabIdx_UCDi,
7275 MS_U16 u16TabIdx_UCCTL,
7276 MS_U16 u16TabIdx_SwDriver,
7277 MS_U16 u16TabIdx_PostCCS,
7278 MS_U16 u16TabIdx_DHD
7279 )
7280 {
7281 MS_BOOL bRet = TRUE;
7282 #if PQ_UC_CTL
7283
7284 #if(ENABLE_PQ_MLOAD)
7285 MDrv_PQ_Set_MLoadEn(eWindow, TRUE);
7286 #endif
7287
7288 PQMADi_DBG(printf("MDrv_PQ_SetUCFeature(%u, %u, %u,%u,%u,%u,%u,%u,%u,%u,%u)\n",
7289 u16TabIdx_MADi,
7290 u16TabIdx_MADi_Mot,
7291 u16TabIdx_MADi_DFK,
7292 u16TabIdx_MADi_SST,
7293 u16TabIdx_MADi_EODiW,
7294 u16TabIdx_UCNR,
7295 u16TabIdx_UCDi,
7296 u16TabIdx_UCCTL,
7297 u16TabIdx_SwDriver,
7298 u16TabIdx_PostCCS,
7299 u16TabIdx_DHD));
7300
7301 //no need to store madi, madi_mot here, because MDrv_PQ_LoadTable_U2(pInstance,) has store it.
7302 _u16MADi_DFK_Current[eWindow] = u16TabIdx_MADi_DFK;
7303 _u16MADi_SST_Current[eWindow] = u16TabIdx_MADi_SST;
7304 _u16MADi_EODiW_Current[eWindow] = u16TabIdx_MADi_EODiW;
7305 _u16UCDi_Current[eWindow] = u16TabIdx_UCDi;
7306 _u16UCCTL_Current[eWindow] = u16TabIdx_UCCTL;
7307 _u16UCNR_Current[eWindow] = u16TabIdx_UCNR;
7308 _u16SwDriver_Current[eWindow] = u16TabIdx_SwDriver;
7309 _u16PostCCS_Current[eWindow] = u16TabIdx_PostCCS;
7310 _u16DHD_Current[eWindow] = u16TabIdx_DHD;
7311
7312 if(eWindow == PQ_MAIN_WINDOW)
7313 {
7314 if(0xFFFF != u16TabIdx_MADi)
7315 {
7316 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_MADi, PQ_IP_MADi_Main);
7317 }
7318
7319 #if (PQ_MADI_DFK == 1)
7320 if(0xFFFF != u16TabIdx_MADi_Mot)
7321 {
7322 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_MADi_Mot, PQ_IP_MADi_Motion_Main);
7323 }
7324 #endif
7325
7326 if(0xFFFF != u16TabIdx_MADi_DFK)
7327 {
7328 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_MADi_DFK, PQ_IP_MADi_DFK_Main);
7329 }
7330
7331 if(0xFFFF != u16TabIdx_MADi_SST)
7332 {
7333 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_MADi_SST, PQ_IP_MADi_SST_Main);
7334 }
7335
7336 if(0xFFFF != u16TabIdx_MADi_EODiW)
7337 {
7338 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_MADi_EODiW, PQ_IP_MADi_EODiW_Main);
7339 }
7340
7341 if(0xFFFF != u16TabIdx_UCNR)
7342 {
7343 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_UCNR, PQ_IP_UCNR_Main);
7344 }
7345
7346 if(0xFFFF != u16TabIdx_UCDi)
7347 {
7348 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_UCDi, PQ_IP_UCDi_Main);
7349 }
7350
7351 if(0xFFFF != u16TabIdx_UCCTL)
7352 {
7353 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_UCCTL, PQ_IP_UC_CTL_Main);
7354 }
7355
7356 if(0xFFFF != u16TabIdx_SwDriver)
7357 {
7358 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_SwDriver, PQ_IP_SwDriver_Main);
7359 }
7360
7361 if(0xFFFF != u16TabIdx_PostCCS)
7362 {
7363 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_PostCCS, PQ_IP_PostCCS_Main);
7364 }
7365
7366 if(0xFFFF != u16TabIdx_DHD)
7367 {
7368 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_DHD, PQ_IP_DHD_Main);
7369 }
7370
7371 if(_gIsEnable8LBMode)
7372 {
7373 if(u16TabIdx_UCCTL == PQ_IP_UC_CTL_OFF_Main)
7374 {
7375 if(MApi_XC_Set_OPWriteOffEnableToReg)
7376 {
7377 MApi_XC_Set_OPWriteOffEnableToReg(ENABLE, MAIN_WINDOW);
7378 }
7379 }
7380 else
7381 {
7382 if(MApi_XC_Set_OPWriteOffEnableToReg)
7383 {
7384 MApi_XC_Set_OPWriteOffEnableToReg(DISABLE, MAIN_WINDOW);
7385 }
7386 }
7387 }
7388 }
7389 #if(PQ_ENABLE_PIP)
7390 else
7391 {
7392 if(0xFFFF != u16TabIdx_MADi)
7393 {
7394 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_MADi, PQ_IP_MADi_Sub);
7395 }
7396
7397 if(0xFFFF != u16TabIdx_MADi_Mot)
7398 {
7399 MDrv_PQ_LoadTable_U2(pInstance,eWindow, u16TabIdx_MADi_Mot, PQ_IP_MADi_Motion_Sub);
7400 }
7401
7402 if(0xFFFF != u16TabIdx_MADi_DFK)
7403 {
7404 MDrv_PQ_LoadTable_U2(pInstance,eWindow, u16TabIdx_MADi_DFK, PQ_IP_MADi_DFK_Sub);
7405 }
7406
7407 if(0xFFFF != u16TabIdx_MADi_SST)
7408 {
7409 MDrv_PQ_LoadTable_U2(pInstance,eWindow, u16TabIdx_MADi_SST, PQ_IP_MADi_SST_Sub);
7410 }
7411
7412 if(0xFFFF != u16TabIdx_SwDriver)
7413 {
7414 MDrv_PQ_LoadTable_U2(pInstance,eWindow, u16TabIdx_SwDriver, PQ_IP_SwDriver_Sub);
7415 }
7416
7417 #if PQ_SUPPORT_SUB_POSTCCS
7418 if(0xFFFF != u16TabIdx_PostCCS)
7419 {
7420 MDrv_PQ_LoadTable_U2(pInstance,eWindow, u16TabIdx_PostCCS, PQ_IP_PostCCS_Sub);
7421 }
7422 #endif
7423
7424 #if PQ_SUPPORT_SUB_DHD
7425 if(0xFFFF != u16TabIdx_DHD)
7426 {
7427 MDrv_PQ_LoadTable_U2(pInstance,eWindow, u16TabIdx_DHD, PQ_IP_DHD_Sub);
7428 }
7429 #endif
7430 }
7431 #endif
7432
7433 if(_gIsEnable8LBMode)
7434 {
7435 MDrv_PQBin_Enable8LBMode(pInstance,TRUE);
7436 }
7437
7438 #if(ENABLE_PQ_MLOAD)
7439 MDrv_PQ_Set_MLoadEn(eWindow, FALSE);
7440 #endif
7441
7442 bRet = TRUE;
7443
7444 #if (PQ_GRULE_GAME_MODE_ENABLE == 0)
7445 //adjust wrbankmapping for special madi mode such as:25_4R_MC
7446 if((u16TabIdx_UCNR == PQ_IP_UCNR_OFF_Main)
7447 && (u16TabIdx_UCDi == PQ_IP_UCDi_OFF_Main)
7448 && (u16TabIdx_UCCTL == PQ_IP_UC_CTL_OFF_Main))
7449 {
7450 if(MApi_XC_GetWRBankMappingNum(eWindow) == 0x0)
7451 {
7452 if(_stMode_Info[eWindow].bInterlace)
7453 {
7454 MApi_XC_SetWRBankMappingNum(0x2, eWindow);
7455 }
7456 else
7457 {
7458 MApi_XC_SetWRBankMappingNum(0x1, eWindow);
7459 }
7460 _bNeedRestoreWRBankMappingNum = TRUE;
7461 }
7462 }
7463 else if(_bNeedRestoreWRBankMappingNum)
7464 {
7465 MApi_XC_SetWRBankMappingNum(0x0, eWindow);
7466 _bNeedRestoreWRBankMappingNum = FALSE;
7467 }
7468 #endif
7469
7470 #else
7471 bRet = FALSE;
7472 #endif
7473 return bRet;
7474 }
MDrv_PQ_SetUCFeature(PQ_WIN eWindow,MS_U16 u16TabIdx_MADi,MS_U16 u16TabIdx_MADi_Mot,MS_U16 u16TabIdx_MADi_DFK,MS_U16 u16TabIdx_MADi_SST,MS_U16 u16TabIdx_MADi_EODiW,MS_U16 u16TabIdx_UCNR,MS_U16 u16TabIdx_UCDi,MS_U16 u16TabIdx_UCCTL,MS_U16 u16TabIdx_SwDriver,MS_U16 u16TabIdx_PostCCS,MS_U16 u16TabIdx_DHD)7475 MS_BOOL MDrv_PQ_SetUCFeature(PQ_WIN eWindow,
7476 MS_U16 u16TabIdx_MADi,
7477 MS_U16 u16TabIdx_MADi_Mot,
7478 MS_U16 u16TabIdx_MADi_DFK,
7479 MS_U16 u16TabIdx_MADi_SST,
7480 MS_U16 u16TabIdx_MADi_EODiW,
7481 MS_U16 u16TabIdx_UCNR,
7482 MS_U16 u16TabIdx_UCDi,
7483 MS_U16 u16TabIdx_UCCTL,
7484 MS_U16 u16TabIdx_SwDriver,
7485 MS_U16 u16TabIdx_PostCCS,
7486 MS_U16 u16TabIdx_DHD
7487 )
7488 {
7489 #ifdef TRACE_DBG
7490 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7491 #endif
7492 if (pu32PQInst == NULL)
7493 {
7494 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7495 return FALSE;
7496 }
7497
7498 stPQ_SetUCFeature PQArgs;
7499 PQArgs.eWindow = eWindow;
7500 PQArgs.pu16TabIdx_MADi = u16TabIdx_MADi;
7501 PQArgs.pu16TabIdx_MADi_Mot = u16TabIdx_MADi_Mot;
7502 PQArgs.pu16TabIdx_MADi_DFK = u16TabIdx_MADi_DFK;
7503 PQArgs.pu16TabIdx_MADi_SST = u16TabIdx_MADi_SST;
7504 PQArgs.pu16TabIdx_MADi_EODiW = u16TabIdx_MADi_EODiW;
7505 PQArgs.pu16TabIdx_UCNR = u16TabIdx_UCNR;
7506 PQArgs.pu16TabIdx_UCDi = u16TabIdx_UCDi;
7507 PQArgs.pu16TabIdx_UCCTL = u16TabIdx_UCCTL;
7508 PQArgs.pu16TabIdx_SwDriver =u16TabIdx_SwDriver ;
7509 PQArgs.pu16TabIdx_PostCCS =u16TabIdx_PostCCS ;
7510 PQArgs.pu16TabIdx_DHD =u16TabIdx_DHD ;
7511 PQArgs.bReturnValue = FALSE;
7512 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_UC_FEATURE, (void*)&PQArgs) != 0)
7513 {
7514 printf("Obtain PQ engine fail\n");
7515 return FALSE;
7516 }
7517 else
7518 {
7519 return PQArgs.bReturnValue;
7520 }
7521 }
7522
MDrv_PQ_SetDMSV12L_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bEnable)7523 MS_BOOL MDrv_PQ_SetDMSV12L_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bEnable)
7524 {
7525 #ifdef UFO_XC_PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
7526 MS_U32 u32IsSupportSC1PIP = 0;
7527 if (MApi_XC_GetChipCaps(E_XC_SUPPORT_PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB, &u32IsSupportSC1PIP, sizeof(MS_U32)) != E_APIXC_RET_OK)
7528 {
7529 printf("[%s][%d] MApi_XC_GetChipCaps return fail!\n",__FUNCTION__,__LINE__);
7530 return FALSE;
7531 }
7532
7533 if (u32IsSupportSC1PIP == 1)
7534 {
7535 // this is not need to control 12 line mode when sc1 as pip
7536 return TRUE;
7537 }
7538 #endif
7539
7540 #if PQ_EN_DMS_SW_CTRL
7541 MS_U16 u16TabIdx, u16IPIdx;
7542
7543 if(bEnable == TRUE)
7544 {
7545 u16TabIdx = PQ_IP_DMS_V_12L_ON_Main;
7546 }
7547 else
7548 {
7549 u16TabIdx = PQ_IP_DMS_V_12L_OFF_Main;
7550 }
7551 u16IPIdx = PQ_IP_DMS_V_12L_Main;
7552 eWindow = PQ_MAIN_WINDOW;
7553
7554 #if(ENABLE_PQ_MLOAD)
7555 MDrv_PQ_Set_MLoadEn(eWindow, TRUE);
7556 #endif
7557
7558 MDrv_PQ_LoadTable_U2(pInstance,eWindow, u16TabIdx, u16IPIdx);
7559
7560 #if(ENABLE_PQ_MLOAD)
7561 MDrv_PQ_Set_MLoadEn(eWindow, FALSE);
7562 #endif
7563 _bDMSV12L_PIPEn = bEnable;
7564
7565 #else
7566 UNUSED(eWindow);
7567 UNUSED(bEnable);
7568 #endif
7569
7570 return TRUE;
7571 }
MDrv_PQ_SetDMSV12L(PQ_WIN eWindow,MS_BOOL bEnable)7572 MS_BOOL MDrv_PQ_SetDMSV12L(PQ_WIN eWindow, MS_BOOL bEnable)
7573 {
7574 #ifdef TRACE_DBG
7575 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7576 #endif
7577 if (pu32PQInst == NULL)
7578 {
7579 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7580 return FALSE;
7581 }
7582
7583 stPQ_SetDMSV12L PQArgs;
7584 PQArgs.eWindow = eWindow;
7585 PQArgs.bEnable = bEnable;
7586 PQArgs.bReturnValue = FALSE;
7587 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_DMSV12L, (void*)&PQArgs) != 0)
7588 {
7589 printf("Obtain PQ engine fail\n");
7590 return FALSE;
7591 }
7592 else
7593 {
7594 return PQArgs.bReturnValue;
7595 }
7596 }
7597
MDrv_PQ_GetDMSV12LFromXRuleTable_U2(void * pInstance,PQ_WIN eWindow)7598 MS_BOOL MDrv_PQ_GetDMSV12LFromXRuleTable_U2(void* pInstance,PQ_WIN eWindow)
7599 {
7600 UNUSED(eWindow);
7601
7602 return _bDMSV12L_PQConfigEn;
7603 }
MDrv_PQ_GetDMSV12LFromXRuleTable(PQ_WIN eWindow)7604 MS_BOOL MDrv_PQ_GetDMSV12LFromXRuleTable(PQ_WIN eWindow)
7605 {
7606 #ifdef TRACE_DBG
7607 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7608 #endif
7609 if (pu32PQInst == NULL)
7610 {
7611 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7612 return FALSE;
7613 }
7614
7615 stPQ_GetDMSV12LFromXRuleTable PQArgs;
7616 PQArgs.eWindow = eWindow;
7617 PQArgs.bReturnValue = FALSE;
7618 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_DMSV12L_FROM_XRULE_TABLE, (void*)&PQArgs) != 0)
7619 {
7620 printf("Obtain PQ engine fail\n");
7621 return FALSE;
7622 }
7623 else
7624 {
7625 return PQArgs.bReturnValue;
7626 }
7627 }
7628
MDrv_PQ_GetLibVer_U2(void * pInstance,const MSIF_Version ** ppVersion)7629 E_DRVPQ_ReturnValue MDrv_PQ_GetLibVer_U2(void* pInstance,const MSIF_Version **ppVersion)
7630 {
7631 if(ppVersion == NULL)
7632 {
7633 return E_DRVPQ_RET_FAIL;
7634 }
7635
7636 *ppVersion = &_drv_pq_version;
7637 return E_DRVPQ_RET_OK;
7638 }
MDrv_PQ_GetLibVer(const MSIF_Version ** ppVersion)7639 E_DRVPQ_ReturnValue MDrv_PQ_GetLibVer(const MSIF_Version **ppVersion)
7640 {
7641 #ifdef TRACE_DBG
7642 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7643 #endif
7644 if (pu32PQInst == NULL)
7645 {
7646 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7647 return FALSE;
7648 }
7649
7650 stPQ_GetLibVer PQArgs;
7651 PQArgs.ppVersion = ppVersion;
7652 PQArgs.bReturnValue = E_DRVPQ_RET_FAIL;
7653 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_LIB_VER, (void*)&PQArgs) != 0)
7654 {
7655 printf("Obtain PQ engine fail\n");
7656 return E_DRVPQ_RET_FAIL;
7657 }
7658 else
7659 {
7660 return PQArgs.bReturnValue;
7661 }
7662 }
7663
7664
MDrv_PQ_GetInfo_U2(void * pInstance,MS_PQ_INFO * pInfo)7665 PQ_ReturnValue MDrv_PQ_GetInfo_U2(void* pInstance,MS_PQ_INFO *pInfo)
7666 {
7667 memcpy((void*)pInfo, (void*)&_info, sizeof(MS_PQ_INFO));
7668 return E_PQ_RET_OK;
7669 }
MDrv_PQ_GetInfo(MS_PQ_INFO * pInfo)7670 PQ_ReturnValue MDrv_PQ_GetInfo(MS_PQ_INFO *pInfo)
7671 {
7672 #ifdef TRACE_DBG
7673 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7674 #endif
7675 if (pu32PQInst == NULL)
7676 {
7677 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7678 return FALSE;
7679 }
7680
7681 stPQ_GetInfo PQArgs;
7682 PQArgs.pInfo = pInfo;
7683 PQArgs.bReturnValue = E_PQ_RET_FAIL;
7684 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_INFO, (void*)&PQArgs) != 0)
7685 {
7686 printf("Obtain PQ engine fail\n");
7687 return E_PQ_RET_FAIL;
7688 }
7689 else
7690 {
7691 return PQArgs.bReturnValue;
7692 }
7693 }
7694
MDrv_PQ_GetStatus_U2(void * pInstance,MS_PQ_Status * pStatus)7695 MS_BOOL MDrv_PQ_GetStatus_U2(void* pInstance,MS_PQ_Status *pStatus)
7696 {
7697 memcpy((void*)pStatus, (void*)&_status, sizeof(MS_PQ_Status));
7698 return FALSE;
7699 }
MDrv_PQ_GetStatus(MS_PQ_Status * pStatus)7700 MS_BOOL MDrv_PQ_GetStatus(MS_PQ_Status *pStatus)
7701 {
7702 #ifdef TRACE_DBG
7703 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7704 #endif
7705 if (pu32PQInst == NULL)
7706 {
7707 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7708 return FALSE;
7709 }
7710
7711 stPQ_GetStatus PQArgs;
7712 PQArgs.pStatus = pStatus;
7713 PQArgs.bReturnValue = FALSE;
7714 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_STATUS, (void*)&PQArgs) != 0)
7715 {
7716 printf("Obtain PQ engine fail\n");
7717 return FALSE;
7718 }
7719 else
7720 {
7721 return PQArgs.bReturnValue;
7722 }
7723 }
7724
MDrv_PQ_SetDbgLevel_U2(void * pInstance,MS_U16 u16DbgSwitch)7725 MS_BOOL MDrv_PQ_SetDbgLevel_U2(void* pInstance,MS_U16 u16DbgSwitch)
7726 {
7727 _u16PQDbgSwitch = u16DbgSwitch;
7728 return TRUE;
7729 }
MDrv_PQ_SetDbgLevel(MS_U16 u16DbgSwitch)7730 MS_BOOL MDrv_PQ_SetDbgLevel(MS_U16 u16DbgSwitch)
7731 {
7732 #ifdef TRACE_DBG
7733 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7734 //return FALSE;
7735 #endif
7736 if (pu32PQInst == NULL)
7737 {
7738 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7739 return FALSE;
7740 }
7741
7742 stPQ_SetDbgLevel PQArgs;
7743 PQArgs.u16DbgSwitch = u16DbgSwitch;
7744 PQArgs.bReturnValue = FALSE;
7745 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_DBGLEVEL, (void*)&PQArgs) != 0)
7746 {
7747 printf("Obtain PQ engine fail\n");
7748 return FALSE;
7749 }
7750 else
7751 {
7752 return PQArgs.bReturnValue;
7753 }
7754 }
7755
MDrv_PQ_MADiForceMotionC_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bEnable)7756 void MDrv_PQ_MADiForceMotionC_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bEnable)
7757 {
7758 MS_U16 u16DataC = 0;
7759 u16DataC = Hal_PQ_get_force_c_motion(pInstance,eWindow == PQ_MAIN_WINDOW);
7760
7761 if(eWindow == PQ_SUB_WINDOW)
7762 {
7763 u16DataC <<= 8;
7764 }
7765
7766 if(bEnable)
7767 {
7768 u16DataC |= (eWindow == PQ_MAIN_WINDOW ? 0x0080 : 0x8000);
7769 }
7770 else
7771 {
7772 u16DataC &= (eWindow == PQ_MAIN_WINDOW ? 0x000F : 0x0F00);
7773 }
7774 Hal_PQ_set_force_c_motion(pInstance,eWindow == PQ_MAIN_WINDOW, u16DataC);
7775
7776 }
MDrv_PQ_MADiForceMotionC(PQ_WIN eWindow,MS_BOOL bEnable)7777 void MDrv_PQ_MADiForceMotionC(PQ_WIN eWindow, MS_BOOL bEnable)
7778 {
7779 #ifdef TRACE_DBG
7780 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7781 #endif
7782 if (pu32PQInst == NULL)
7783 {
7784 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7785 return ;
7786 }
7787
7788 stPQ_MADiForceMotionC PQArgs;
7789 PQArgs.eWindow = eWindow;
7790 PQArgs.bEnable = bEnable;
7791 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_MADI_FORCE_MOTIONC, (void*)&PQArgs) != 0)
7792 {
7793 printf("Obtain PQ engine fail\n");
7794 return;
7795 }
7796 else
7797 {
7798 return;
7799 }
7800 }
7801
7802 #ifdef UFO_XC_PQ_SUPPORT_SWMOTION
MDrv_PQ_MADiForceMotion_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bEnableY,MS_U16 u16DataY,MS_BOOL bEnableC,MS_U16 u16DataC)7803 void MDrv_PQ_MADiForceMotion_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bEnableY, MS_U16 u16DataY,
7804 MS_BOOL bEnableC, MS_U16 u16DataC)
7805 {
7806 // Y
7807 if (bEnableY)
7808 {
7809 SAVE_FORCE_Y_MOTION_ENABLE(pInstance, eWindow == PQ_MAIN_WINDOW);
7810 if (eWindow == PQ_SUB_WINDOW)
7811 {
7812 u16DataY <<= 8;
7813 }
7814 u16DataY |= (eWindow == PQ_MAIN_WINDOW ? 0x0080 : 0x8000);
7815 Hal_PQ_set_force_y_motion(pInstance, eWindow == PQ_MAIN_WINDOW, u16DataY);
7816 }
7817 else
7818 {
7819 RESTORE_FORCE_Y_MOTION_ENABLE(pInstance, eWindow == PQ_MAIN_WINDOW);
7820 }
7821
7822 // C
7823 if (bEnableC)
7824 {
7825 SAVE_FORCE_C_MOTION_ENABLE(pInstance, eWindow == PQ_MAIN_WINDOW);
7826 if (eWindow == PQ_SUB_WINDOW)
7827 {
7828 u16DataC <<= 8;
7829 }
7830 u16DataC |= (eWindow == PQ_MAIN_WINDOW ? 0x0080 : 0x8000);
7831 Hal_PQ_set_force_c_motion(pInstance, eWindow == PQ_MAIN_WINDOW, u16DataC);
7832 }
7833 else
7834 {
7835 RESTORE_FORCE_C_MOTION_ENABLE(pInstance, eWindow == PQ_MAIN_WINDOW);
7836 }
7837 }
7838
7839
MDrv_PQ_MADiForceMotion(PQ_WIN eWindow,MS_BOOL bEnableY,MS_U16 u16DataY,MS_BOOL bEnableC,MS_U16 u16DataC)7840 void MDrv_PQ_MADiForceMotion(PQ_WIN eWindow, MS_BOOL bEnableY, MS_U16 u16DataY,
7841 MS_BOOL bEnableC, MS_U16 u16DataC)
7842 {
7843 #ifdef TRACE_DBG
7844 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7845 #endif
7846 if (pu32PQInst == NULL)
7847 {
7848 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7849 return ;
7850 }
7851
7852 stPQ_MADiForceMotion PQArgs;
7853 PQArgs.eWindow = eWindow;
7854 PQArgs.bEnableY = bEnableY;
7855 PQArgs.u16DataY = u16DataY;
7856 PQArgs.bEnableC = bEnableC;
7857 PQArgs.u16DataC = u16DataC;
7858 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_MADI_FORCE_MOTION, (void*)&PQArgs) != 0)
7859 {
7860 printf("Obtain PQ engine fail\n");
7861 return;
7862 }
7863 else
7864 {
7865 return;
7866 }
7867 }
7868 #endif
7869
MDrv_PQ_MADiForceMotionY_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bEnable)7870 void MDrv_PQ_MADiForceMotionY_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bEnable)
7871 {
7872 MS_U16 u16Data = 0;
7873
7874 u16Data = Hal_PQ_get_force_y_motion(pInstance,eWindow == PQ_MAIN_WINDOW);
7875
7876 if(eWindow == PQ_SUB_WINDOW)
7877 {
7878 u16Data <<= 8;
7879 }
7880 if(bEnable)
7881 {
7882 u16Data |= (eWindow == PQ_MAIN_WINDOW ? 0x0080 : 0x8000);
7883 }
7884 else
7885 {
7886 u16Data &= (eWindow == PQ_MAIN_WINDOW ? 0x003F : 0x3F00);
7887 }
7888
7889 Hal_PQ_set_force_y_motion(pInstance,eWindow == PQ_MAIN_WINDOW, u16Data);
7890 }
MDrv_PQ_MADiForceMotionY(PQ_WIN eWindow,MS_BOOL bEnable)7891 void MDrv_PQ_MADiForceMotionY(PQ_WIN eWindow, MS_BOOL bEnable)
7892 {
7893 #ifdef TRACE_DBG
7894 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7895 #endif
7896 if (pu32PQInst == NULL)
7897 {
7898 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7899 return ;
7900 }
7901
7902 stPQ_MADiForceMotionY PQArgs;
7903 PQArgs.eWindow = eWindow;
7904 PQArgs.bEnable = bEnable;
7905 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_MADI_FORCE_MOTIONY, (void*)&PQArgs) != 0)
7906 {
7907 printf("Obtain PQ engine fail\n");
7908 return;
7909 }
7910 else
7911 {
7912 return;
7913 }
7914 }
7915
MDrv_PQ_SetRFblMode_U2(void * pInstance,MS_BOOL bEnable,MS_BOOL bFilm)7916 void MDrv_PQ_SetRFblMode_U2(void* pInstance,MS_BOOL bEnable, MS_BOOL bFilm)
7917 {
7918 _stRFBL_Info.bEnable = bEnable;
7919 _stRFBL_Info.bFilm = bFilm;
7920
7921 if(!bEnable) //default mode
7922 {
7923 MDrv_PQ_MADiForceMotionY_U2(pInstance,PQ_MAIN_WINDOW, FALSE);
7924 MDrv_PQ_MADiForceMotionC_U2(pInstance,PQ_MAIN_WINDOW, FALSE);
7925
7926 _stRFBL_Info.u8MADiType = MS_MADI_24_2R;
7927 //printf("[%s]-[%d] : Y/C motion : ( 0 , 0 ) \n", __FUNCTION__, __LINE__);
7928 }
7929 else
7930 {
7931 _stRFBL_Info.u8MADiType = (bFilm) ? (MS_U8)MS_MADI_24_RFBL_FILM : (MS_U8)MS_MADI_24_RFBL_NFILM;
7932 MDrv_PQ_MADiForceMotionY_U2(pInstance,PQ_MAIN_WINDOW, FALSE);
7933 MDrv_PQ_MADiForceMotionC_U2(pInstance,PQ_MAIN_WINDOW, (!bFilm));
7934
7935 //printf("[%s]-[%d] : Y/C motion : ( 0 , %d) \n", __FUNCTION__, __LINE__,(!bFilm));
7936 }
7937 }
MDrv_PQ_SetRFblMode(MS_BOOL bEnable,MS_BOOL bFilm)7938 void MDrv_PQ_SetRFblMode(MS_BOOL bEnable, MS_BOOL bFilm)
7939 {
7940 #ifdef TRACE_DBG
7941 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7942 #endif
7943 if (pu32PQInst == NULL)
7944 {
7945 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7946 return ;
7947 }
7948
7949 stPQ_SetRFblMode PQArgs;
7950 PQArgs.bEnable = bEnable;
7951 PQArgs.bFilm = bFilm;
7952 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_RFBL_MODE, (void*)&PQArgs) != 0)
7953 {
7954 printf("Obtain PQ engine fail\n");
7955 return;
7956 }
7957 else
7958 {
7959 return;
7960 }
7961 }
7962
MDrv_PQ_GetRFblMode_U2(void * pInstance,MS_PQ_RFBL_INFO * pstInfo)7963 void MDrv_PQ_GetRFblMode_U2(void* pInstance,MS_PQ_RFBL_INFO * pstInfo)
7964 {
7965 memcpy(pstInfo, &_stRFBL_Info, sizeof(MS_PQ_RFBL_INFO));
7966 return;
7967 }
MDrv_PQ_GetRFblMode(MS_PQ_RFBL_INFO * pstInfo)7968 void MDrv_PQ_GetRFblMode(MS_PQ_RFBL_INFO * pstInfo)
7969 {
7970 #ifdef TRACE_DBG
7971 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
7972 #endif
7973 if (pu32PQInst == NULL)
7974 {
7975 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
7976 return ;
7977 }
7978
7979 stPQ_GetRFblMode PQArgs;
7980 PQArgs.pstInfo = pstInfo;
7981 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_RFBL_MODE, (void*)&PQArgs) != 0)
7982 {
7983 printf("Obtain PQ engine fail\n");
7984 return;
7985 }
7986 else
7987 {
7988 return;
7989 }
7990 }
7991
7992 #if (PQ_ENABLE_VD_SAMPLING)
7993
MDrv_PQ_Get_VDSampling_Info_U2(void * pInstance,PQ_WIN eWindow,PQ_INPUT_SOURCE_TYPE enInputSourceType,PQ_VIDEOSTANDARD_TYPE eStandard,MS_PQ_VD_Sampling_Info * pInfo)7994 MS_BOOL MDrv_PQ_Get_VDSampling_Info_U2(void* pInstance,PQ_WIN eWindow, PQ_INPUT_SOURCE_TYPE enInputSourceType, PQ_VIDEOSTANDARD_TYPE eStandard, MS_PQ_VD_Sampling_Info *pInfo)
7995 {
7996 PQ_VIDEOSTANDARD_TYPE eCurStandard = _stVD_Info[eWindow].enVideoStandard;
7997 MS_U16 u16CurSrc = _u16PQSrcType[eWindow];
7998 MS_U16 u16TableIdx;
7999 #if PQ_HAL_EWINDOW_PARAM
8000 MS_U16 u16IPIdx = Hal_PQ_get_ip_idx(pInstance,MS_PQ_IP_VD_SAMPLING, eWindow);
8001 #else
8002 MS_U16 u16IPIdx = Hal_PQ_get_ip_idx(pInstance,MS_PQ_IP_VD_SAMPLING);
8003 #endif
8004 MS_U8 u8SampleTable[10];
8005
8006 memset(u8SampleTable, 0, sizeof(u8SampleTable));
8007
8008 PQINFO_DBG(printf("[PQ] GetVDSampling: win:%d, src:%d, standard:%d, PQIP=%x\n", eWindow, enInputSourceType, eStandard, u16IPIdx));
8009 if((((enInputSourceType >= PQ_INPUT_SOURCE_TV) && (enInputSourceType <= PQ_INPUT_SOURCE_SVIDEO))||(enInputSourceType == PQ_INPUT_SOURCE_SCART)) &&
8010 (eStandard < E_PQ_VIDEOSTANDARD_NOTSTANDARD) &&
8011 (u16IPIdx != 0xFFFF))
8012 {
8013 _stVD_Info[eWindow].enVideoStandard = eStandard;
8014 _u16PQSrcType[eWindow] = QM_InputSourceToIndex(pInstance, eWindow, enInputSourceType);
8015
8016
8017
8018 u16TableIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, u16IPIdx);
8019 PQINFO_DBG(printf("[PQ] VDSampling: TableIdx=%d\n", u16TableIdx));
8020
8021 if(((gbPQBinEnable == 1) && (u16TableIdx == PQ_BIN_IP_NULL))
8022 || ((gbPQBinEnable == 0) && (u16TableIdx == PQ_IP_NULL)))
8023 {
8024 pInfo->eType = PQ_VD_SAMPLING_OFF;
8025 }
8026 else
8027 {
8028 MDrv_PQ_LoadTableData_U2(pInstance, eWindow, u16TableIdx, u16IPIdx, u8SampleTable, 10);
8029 pInfo->u16Vstart = ((MS_U16)u8SampleTable[0]) | (((MS_U16)u8SampleTable[1])<<8);
8030 pInfo->u16Hstart = ((MS_U16)u8SampleTable[2]) | (((MS_U16)u8SampleTable[3])<<8);
8031 pInfo->u16Hsize = ((MS_U16)u8SampleTable[4]) | (((MS_U16)u8SampleTable[5]) << 8);
8032 pInfo->u16Vsize = ((MS_U16)u8SampleTable[6]) | (((MS_U16)u8SampleTable[7]) << 8);
8033 pInfo->u16Htt = ((MS_U16)u8SampleTable[8]) | (((MS_U16)u8SampleTable[9]) << 8);
8034 pInfo->eType = PQ_VD_SAMPLING_ON;
8035
8036 PQINFO_DBG(printf("VD x:%x, y:%x, w:%x, h:%x, Htt=%x \n",
8037 pInfo->u16Hstart, pInfo->u16Vstart, pInfo->u16Hsize, pInfo->u16Vsize, pInfo->u16Htt));
8038 }
8039
8040 _stVD_Info[eWindow].enVideoStandard = eCurStandard;
8041 _u16PQSrcType[eWindow] = u16CurSrc;
8042 }
8043 else
8044 {
8045 pInfo->eType = PQ_VD_SAMPLING_OFF;
8046 }
8047 return TRUE;
8048 }
MDrv_PQ_Get_VDSampling_Info(PQ_WIN eWindow,PQ_INPUT_SOURCE_TYPE enInputSourceType,PQ_VIDEOSTANDARD_TYPE eStandard,MS_PQ_VD_Sampling_Info * pInfo)8049 MS_BOOL MDrv_PQ_Get_VDSampling_Info(PQ_WIN eWindow, PQ_INPUT_SOURCE_TYPE enInputSourceType, PQ_VIDEOSTANDARD_TYPE eStandard, MS_PQ_VD_Sampling_Info *pInfo)
8050 {
8051 #ifdef TRACE_DBG
8052 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
8053 #endif
8054 if (pu32PQInst == NULL)
8055 {
8056 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
8057 {
8058 printf("UtopiaOpen PQ failed\n");
8059 return FALSE;
8060 }
8061 }
8062
8063 stPQ_Get_VDSampling_Info PQArgs;
8064 PQArgs.eWindow = eWindow;
8065 PQArgs.enInputSourceType = enInputSourceType;
8066 PQArgs.eStandard = eStandard;
8067 PQArgs.pInfo = pInfo;
8068 PQArgs.bReturnValue = FALSE;
8069 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_VDSAMPLING_INFO, (void*)&PQArgs) != 0)
8070 {
8071 printf("Obtain PQ engine fail\n");
8072 return FALSE;
8073 }
8074 else
8075 {
8076 return PQArgs.bReturnValue;
8077 }
8078 }
8079
8080 #endif
8081
8082
_MDrv_PQ_Get_HSDSampling(void * pInstance,PQ_WIN eWindow,MS_U32 * pu32ratio,MS_BOOL * bADVMode)8083 MS_BOOL _MDrv_PQ_Get_HSDSampling(void *pInstance,PQ_WIN eWindow, MS_U32 *pu32ratio, MS_BOOL *bADVMode)
8084 {
8085 #if PQ_HAL_EWINDOW_PARAM
8086 MS_U16 u16IPIdx = Hal_PQ_get_ip_idx(pInstance,MS_PQ_IP_HSD_SAMPLING, eWindow);
8087 #else
8088 MS_U16 u16IPIdx = Hal_PQ_get_ip_idx(pInstance,MS_PQ_IP_HSD_SAMPLING);
8089 #endif
8090 MS_U16 u16TableIdx;
8091 MS_BOOL bret = TRUE;
8092
8093 if(u16IPIdx != 0xFFFF)
8094 {
8095 u16TableIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, u16IPIdx);
8096 }
8097 else
8098 {
8099 u16TableIdx = (gbPQBinEnable) ? PQ_BIN_IP_NULL : PQ_IP_NULL;
8100 }
8101
8102
8103 if(((gbPQBinEnable == 1) && (u16TableIdx == PQ_BIN_IP_NULL)) ||
8104 ((gbPQBinEnable == 0) && (u16TableIdx == PQ_IP_NULL)))
8105 {
8106 *pu32ratio = 0;
8107 bret = FALSE;
8108 }
8109 else if( (( gbPQBinEnable == 1) &&
8110 (( MDrv_PQBin_GetSkipRule(pInstance,PQ_IP_HSD_Y_Main, &stPQBinHeaderInfo[PQ_BIN_STD_MAIN])) ||
8111 ( MDrv_PQBin_GetSkipRule(pInstance,PQ_IP_HSD_C_Main, &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]))) )
8112 ||
8113 (( gbPQBinEnable == 1) &&
8114 ((MST_SkipRule_IP_Main[PQ_IP_HSD_Y_Main] == 1) || (MST_SkipRule_IP_Main[PQ_IP_HSD_C_Main] == 1))))
8115 {
8116 SRULE_DBG(printf("HSD_Y, HSD_C is True in SKipRule, driver consider HSDSampling is not defined in QMap.\n"));
8117 *pu32ratio = 0;
8118 bret = FALSE;
8119 }
8120 else
8121 {
8122 #if PQ_NEW_HSD_SAMPLING_TYPE
8123 #if PQ_HAL_EWINDOW_PARAM
8124 if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_000, eWindow))
8125 #else
8126 if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_000))
8127 #endif
8128 {
8129 *pu32ratio = 1000;
8130 }
8131 #if PQ_HAL_EWINDOW_PARAM
8132 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_125, eWindow))
8133 #else
8134 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_125))
8135 #endif
8136 {
8137 *pu32ratio = 875;
8138 }
8139 #if PQ_HAL_EWINDOW_PARAM
8140 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_250, eWindow))
8141 #else
8142 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_250))
8143 #endif
8144 {
8145 *pu32ratio = 750;
8146 }
8147 #if PQ_HAL_EWINDOW_PARAM
8148 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_375, eWindow))
8149 #else
8150 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_375))
8151 #endif
8152 {
8153 *pu32ratio = 625;
8154 }
8155 #if PQ_HAL_EWINDOW_PARAM
8156 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_500, eWindow))
8157 #else
8158 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_500))
8159 #endif
8160 {
8161 *pu32ratio = 500;
8162 }
8163 #if PQ_HAL_EWINDOW_PARAM
8164 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_625, eWindow))
8165 #else
8166 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_625))
8167 #endif
8168 {
8169 *pu32ratio = 375;
8170 }
8171 #if PQ_HAL_EWINDOW_PARAM
8172 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_750, eWindow))
8173 #else
8174 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_750))
8175 #endif
8176 {
8177 *pu32ratio = 250;
8178 }
8179 #if PQ_HAL_EWINDOW_PARAM
8180 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_875, eWindow))
8181 #else
8182 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_1_875))
8183 #endif
8184 {
8185 *pu32ratio = 125;
8186 }
8187 #if PQ_HAL_EWINDOW_PARAM
8188 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_2_000, eWindow))
8189 #else
8190 else if(u16TableIdx == Hal_PQ_get_hsd_sampling_idx(pInstance,MS_HSD_SAMPLING_Div_2_000))
8191 #endif
8192 {
8193 *pu32ratio = 1;
8194 }
8195 else
8196 #endif
8197 {
8198 *pu32ratio = 0;
8199 }
8200
8201 bret = TRUE;
8202 }
8203
8204 // Load HSD_Y & HSD_C
8205 if(bret)
8206 {
8207 MS_U16 u16HSD_Y_idx, u16HSD_C_idx;
8208
8209 u16HSD_Y_idx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_HSD_Y_Main);
8210 MDrv_PQ_LoadTable_U2(pInstance,eWindow, u16HSD_Y_idx, PQ_IP_HSD_Y_Main);
8211
8212 u16HSD_C_idx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_HSD_C_Main);
8213 MDrv_PQ_LoadTable_U2(pInstance,eWindow, u16HSD_C_idx, PQ_IP_HSD_C_Main);
8214
8215 SRULE_DBG(printf("HSD_Y:%d, HSD_C:%d\n", u16HSD_Y_idx, u16HSD_C_idx));
8216
8217 *bADVMode = ((u16HSD_Y_idx == PQ_IP_HSD_Y_CB_Main) &&
8218 (u16HSD_C_idx == PQ_IP_HSD_C_CB_Main)) ? FALSE : TRUE;
8219 }
8220 else
8221 {
8222 *bADVMode = FALSE;
8223 }
8224
8225
8226 SRULE_DBG(printf("[PQ] GetHSDSampling, IPIdx=%d, Table=%d, ratio=%td ret=%d\n", u16IPIdx, u16TableIdx, (ptrdiff_t) *pu32ratio, bret));
8227
8228 return bret;
8229 }
8230
8231 //get_figure
MDrv_PQ_IOCTL_U2(void * pInstance,PQ_WIN eWindow,MS_U32 u32Flag,void * pBuf,MS_U32 u32BufSize)8232 MS_BOOL MDrv_PQ_IOCTL_U2(void* pInstance,PQ_WIN eWindow, MS_U32 u32Flag, void *pBuf, MS_U32 u32BufSize)
8233 {
8234 MS_BOOL bret = TRUE;
8235
8236 switch(u32Flag)
8237 {
8238 case E_IOCTL_HSD_SAMPLING:
8239 {
8240 if(u32BufSize == sizeof(PQ_HSD_SAMPLING_INFO))
8241 {
8242 MS_U32 u32ratio;
8243 MS_BOOL bADVMode;
8244
8245 bret = _MDrv_PQ_Get_HSDSampling(pInstance,eWindow, &u32ratio, &bADVMode);
8246 ((PQ_HSD_SAMPLING_INFO *)pBuf)->u32ratio = u32ratio;
8247 ((PQ_HSD_SAMPLING_INFO *)pBuf)->bADVMode = bADVMode;
8248 //printf("ratio %lx, bADVmode=%d\n\n",((PQ_HSD_SAMPLING_INFO *)pBuf)->u32ratio, ((PQ_HSD_SAMPLING_INFO *)pBuf)->bADVMode);
8249 }
8250 else
8251 {
8252 //printf("Size is not correct, in=%ld, %d\n", u32BufSize, sizeof(PQ_HSD_SAMPLING_INFO));
8253 ((PQ_HSD_SAMPLING_INFO *)pBuf)->u32ratio = 0;
8254 ((PQ_HSD_SAMPLING_INFO *)pBuf)->bADVMode = 0;
8255 bret = FALSE;
8256 }
8257 break;
8258 }
8259
8260 case E_IOCTL_PREVSD_BILINEAR:
8261 bret = TRUE;
8262 *((MS_BOOL *)pBuf) = TRUE;
8263 break;
8264
8265 case E_IOCTL_ADC_SAMPLING:
8266 if(u32BufSize == sizeof(PQ_ADC_SAMPLING_INFO))
8267 {
8268
8269 PQ_INPUT_SOURCE_TYPE enInputSrc = ((PQ_ADC_SAMPLING_INFO *)pBuf)->enPQSourceType;
8270 MS_PQ_Mode_Info *pModeInfo = &(((PQ_ADC_SAMPLING_INFO *)pBuf)->stPQModeInfo);
8271 MS_PQ_ADC_SAMPLING_TYPE enADCSamplingType = MDrv_PQ_Get_ADCSampling_Info(eWindow, enInputSrc, pModeInfo);
8272
8273 if((enADCSamplingType == E_PQ_ADC_SAMPLING_NOT_SUPPORT) || (enADCSamplingType == E_PQ_ADC_SAMPLING_NONE))
8274 {
8275 ((PQ_ADC_SAMPLING_INFO *)pBuf)->u16ratio = 1;
8276 bret = FALSE;
8277 }
8278 else
8279 {
8280 ((PQ_ADC_SAMPLING_INFO *)pBuf)->u16ratio = (MS_U16)enADCSamplingType;
8281 bret = TRUE;
8282 }
8283 }
8284 else
8285 {
8286 bret = FALSE;
8287 ((PQ_ADC_SAMPLING_INFO *)pBuf)->u16ratio = 1;
8288 }
8289 break;
8290 case E_IOCTL_RFBL_CTRL:
8291 //printf("IOCTL %lx\n", u32Flag);
8292 #if PQ_ENABLE_RFBL
8293 bret = MDrv_PQ_Get_RFBL_Info(eWindow);
8294 #else
8295 bret = FALSE;
8296 #endif
8297 UNUSED(pBuf);
8298 UNUSED(u32BufSize);
8299 break;
8300
8301 case E_IOCTL_PQ_SUGGESTED_FRAMENUM:
8302 {
8303 if(u32BufSize == sizeof(MS_U16))
8304 {
8305 *((MS_U16 *)pBuf) = _u16PQSuggestedFrameNum[eWindow];
8306 bret = TRUE;
8307 }
8308 else
8309 {
8310 *((MS_U16 *)pBuf) = 0;
8311 bret = FALSE;
8312 }
8313 break;
8314 }
8315 case E_IOCTL_SET_UCFEATURE:
8316 {
8317 #if PQ_UC_CTL
8318 #if(PQ_GRULE_GAME_MODE_ENABLE == 0)
8319 MS_U16 u16MADi_DFK_ToSet[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
8320 MS_U16 u16MADi_SST_ToSet[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
8321 MS_U16 u16MADi_EODiW_ToSet[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
8322 MS_U16 u16UCNR_ToSet[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
8323 MS_U16 u16UCDi_ToSet[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
8324 MS_U16 u16UCCTL_ToSet[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
8325 MS_U16 u16PostCCS_ToSet[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
8326 MS_U16 u16SwDriver_ToSet[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
8327 MS_U16 u16DHD_ToSet[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
8328 #endif
8329 MS_BOOL bDisableUCFeature = FALSE;
8330
8331 if(u32BufSize == sizeof(MS_BOOL))
8332 {
8333 _gIsEnable8LBMode = *((MS_BOOL *)pBuf);
8334 }
8335 else
8336 {
8337 _gIsEnable8LBMode = FALSE;
8338 }
8339 #if (PQ_DISABLE_UC_FOR_PREVSD)
8340 XC_ApiStatus stXCApiStatus;
8341 memset(&stXCApiStatus, 0, sizeof(XC_ApiStatus));
8342 if (MApi_XC_GetStatus(&stXCApiStatus, MAIN_WINDOW) == FALSE)
8343 {
8344 printf("MApi_XC_GetStatus failed.\n");
8345 }
8346 if(stXCApiStatus.bPreV_ScalingDown)
8347 {
8348 bDisableUCFeature = TRUE;
8349 }
8350 else
8351 #endif
8352 if(MApi_SC_IsForceFreerun() || MApi_XC_IsCurrentFrameBufferLessMode())//can not support ucnr when freerun or fbl
8353 {
8354 bDisableUCFeature = TRUE;
8355 }
8356 else if((((E_XC_3D_OUTPUT_LINE_ALTERNATIVE == MApi_XC_Get_3D_Output_Mode())
8357 || (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF == MApi_XC_Get_3D_Output_Mode())
8358 || (E_XC_3D_OUTPUT_TOP_BOTTOM == MApi_XC_Get_3D_Output_Mode())
8359 || (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF_HW == MApi_XC_Get_3D_Output_Mode())
8360 || (E_XC_3D_OUTPUT_TOP_BOTTOM_HW == MApi_XC_Get_3D_Output_Mode())
8361 || (E_XC_3D_OUTPUT_FRAME_R == MApi_XC_Get_3D_Output_Mode())
8362 || (E_XC_3D_OUTPUT_FRAME_L == MApi_XC_Get_3D_Output_Mode())
8363 )&& (1 <= MApi_XC_Get_3D_HW_Version()))
8364 || ((MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)&& (5 == MApi_XC_Get_3D_HW_Version()))//monaco 3d disable uc
8365 ) // 3d version >=2 && using sub window
8366 {
8367 bDisableUCFeature = TRUE;
8368 }
8369 #if PQ_DISABLE_UC_FOR_PIP
8370 else if(MApi_XC_Is_SubWindowEanble()
8371 || _enPQDisplayType != PQ_DISPLAY_ONE) //disable ucnr when sub window bit is setting(pip/pop)
8372 {
8373 bDisableUCFeature = TRUE;
8374 }
8375 else if(eWindow == PQ_SUB_WINDOW)//sub window need disable ucnr for dual view/travelingmode enable sub window bit after setwindow
8376 {
8377 bDisableUCFeature = TRUE;
8378 }
8379 #endif
8380 PQMADi_DBG(printf("E_IOCTL_SET_UCFEATURE: Disable UC=%u\n", bDisableUCFeature));
8381 if(bDisableUCFeature == TRUE)
8382 {
8383 MDrv_PQ_DisableUCFeature(PQ_MAIN_WINDOW);
8384 }
8385 else
8386 {
8387 #if(PQ_GRULE_GAME_MODE_ENABLE == 1)
8388 MDrv_PQ_EnableUCFeature_U2(pInstance, eWindow);
8389 #else
8390 MDrv_PQ_GetUCFeatureFromPQ(eWindow, &u16MADi_DFK_ToSet[eWindow], &u16MADi_SST_ToSet[eWindow], &u16MADi_EODiW_ToSet[eWindow],
8391 &u16UCNR_ToSet[eWindow], &u16UCDi_ToSet[eWindow], &u16UCCTL_ToSet[eWindow],
8392 &u16SwDriver_ToSet[eWindow], &u16PostCCS_ToSet[eWindow], &u16DHD_ToSet[eWindow]);
8393 #if PQ_DISABLE_UC_FOR_PIP
8394 MDrv_PQ_SetUCFeature(eWindow, _gu16SetMemfmt_Madi[eWindow], _gu16SetMemfmt_Madi_Motion[eWindow], u16MADi_DFK_ToSet[eWindow],
8395 u16MADi_SST_ToSet[eWindow], u16MADi_EODiW_ToSet[eWindow], u16UCNR_ToSet[eWindow], u16UCDi_ToSet[eWindow],
8396 u16UCCTL_ToSet[eWindow], u16SwDriver_ToSet[eWindow], u16PostCCS_ToSet[eWindow], u16DHD_ToSet[eWindow]);
8397 #else
8398 if(eWindow == PQ_SUB_WINDOW)
8399 {
8400 //no need to set madi/madi_mot again, because setmemformat has done it. so here pass 0xffff in
8401 MDrv_PQ_SetUCFeature(eWindow, 0xFFFF, 0xFFFF, u16MADi_DFK_ToSet[eWindow],
8402 u16MADi_SST_ToSet[eWindow], u16MADi_EODiW_ToSet[eWindow], u16UCNR_ToSet[eWindow], u16UCDi_ToSet[eWindow],
8403 u16UCCTL_ToSet[eWindow], u16SwDriver_ToSet[eWindow], u16PostCCS_ToSet[eWindow], u16DHD_ToSet[eWindow]);
8404 }
8405 else
8406 {
8407 MDrv_PQ_SetUCFeature(eWindow, _s32LastPQIPMADiMain, _s32LastPQIPMADiMotMain, u16MADi_DFK_ToSet[eWindow],
8408 u16MADi_SST_ToSet[eWindow], u16MADi_EODiW_ToSet[eWindow], u16UCNR_ToSet[eWindow], u16UCDi_ToSet[eWindow],
8409 u16UCCTL_ToSet[eWindow], u16SwDriver_ToSet[eWindow], u16PostCCS_ToSet[eWindow], u16DHD_ToSet[eWindow]);
8410 }
8411 #endif
8412 #endif
8413 }
8414 #endif
8415 break;
8416 }
8417 default:
8418 printf("unknown IOCTL %tx\n", (ptrdiff_t) u32Flag);
8419 UNUSED(pBuf);
8420 UNUSED(u32BufSize);
8421 bret = FALSE;
8422 break;
8423 }
8424
8425 //printf("[PQ] IOCTL : win:%x, Flag=%08lx, size=%ld, ret:%x\n", eWindow, u32Flag, u32BufSize, bret);
8426
8427 return bret;
8428 }
MDrv_PQ_IOCTL(PQ_WIN eWindow,MS_U32 u32Flag,void * pBuf,MS_U32 u32BufSize)8429 MS_BOOL MDrv_PQ_IOCTL(PQ_WIN eWindow, MS_U32 u32Flag, void *pBuf, MS_U32 u32BufSize)
8430 {
8431 if (pu32PQInst == NULL)
8432 {
8433 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
8434 {
8435 printf("UtopiaOpen PQ failed\n");
8436 return FALSE;
8437 }
8438 }
8439
8440 stPQ_INTER_IOCTL PQArgs;
8441 PQArgs.eWindow = eWindow;
8442 PQArgs.u32Flag = u32Flag;
8443 PQArgs.pBuf = pBuf;
8444 PQArgs.u32BufSize = u32BufSize;
8445 PQArgs.bReturnValue = FALSE;
8446 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_INTER_IOCTL, (void*)&PQArgs) != 0)
8447 {
8448 printf("Obtain PQ engine fail\n");
8449 return FALSE;
8450 }
8451 else
8452 {
8453 return PQArgs.bReturnValue;
8454 }
8455 }
8456
8457
MDrv_PQ_Get_ADCSampling_Info_U2(void * pInstance,PQ_WIN eWindow,PQ_INPUT_SOURCE_TYPE enInputSourceType,MS_PQ_Mode_Info * pstPQModeInfo)8458 MS_PQ_ADC_SAMPLING_TYPE MDrv_PQ_Get_ADCSampling_Info_U2(void* pInstance,PQ_WIN eWindow, PQ_INPUT_SOURCE_TYPE enInputSourceType, MS_PQ_Mode_Info *pstPQModeInfo)
8459 {
8460 MS_PQ_ADC_SAMPLING_TYPE enRetType;
8461 MS_U16 u16PQSrcType;
8462 MS_U16 u16TableIdx;
8463 MS_PQ_Mode_Info stModeInfo;
8464
8465 u16PQSrcType = _u16PQSrcType[eWindow];
8466 memcpy(&stModeInfo, &_stMode_Info[eWindow], sizeof(MS_PQ_Mode_Info));
8467
8468 MDrv_PQ_Set_ModeInfo_U2(pInstance, eWindow, enInputSourceType, pstPQModeInfo);
8469 _u16PQSrcType[eWindow] = QM_InputSourceToIndex(pInstance, eWindow, enInputSourceType);
8470
8471 #if PQ_HAL_EWINDOW_PARAM
8472 if(Hal_PQ_get_ip_idx(pInstance,MS_PQ_IP_ADC_SAMPLING, eWindow) == 0xFFFF)
8473 #else
8474 if(Hal_PQ_get_ip_idx(pInstance,MS_PQ_IP_ADC_SAMPLING) == 0xFFFF)
8475 #endif
8476 {
8477 return E_PQ_ADC_SAMPLING_NOT_SUPPORT;
8478 }
8479
8480 #if PQ_HAL_EWINDOW_PARAM
8481 u16TableIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, Hal_PQ_get_ip_idx(pInstance,MS_PQ_IP_ADC_SAMPLING, eWindow));
8482 #else
8483 u16TableIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, Hal_PQ_get_ip_idx(pInstance,MS_PQ_IP_ADC_SAMPLING));
8484 #endif
8485
8486 #if PQ_HAL_EWINDOW_PARAM
8487 if(u16TableIdx == Hal_PQ_get_adc_sampling_idx(pInstance,MS_ADC_SAMPLING_X_1,eWindow))
8488 #else
8489 if(u16TableIdx == Hal_PQ_get_adc_sampling_idx(pInstance,MS_ADC_SAMPLING_X_1))
8490 #endif
8491 {
8492 enRetType = E_PQ_ADC_SAMPLING_X_1;
8493 }
8494 #if PQ_HAL_EWINDOW_PARAM
8495 else if(u16TableIdx == Hal_PQ_get_adc_sampling_idx(pInstance,MS_ADC_SAMPLING_X_2,eWindow))
8496 #else
8497 else if(u16TableIdx == Hal_PQ_get_adc_sampling_idx(pInstance,MS_ADC_SAMPLING_X_2))
8498 #endif
8499 {
8500 enRetType = E_PQ_ADC_SAMPLING_X_2;
8501 }
8502 #if PQ_HAL_EWINDOW_PARAM
8503 else if(u16TableIdx == Hal_PQ_get_adc_sampling_idx(pInstance,MS_ADC_SAMPLING_X_4,eWindow))
8504 #else
8505 else if(u16TableIdx == Hal_PQ_get_adc_sampling_idx(pInstance,MS_ADC_SAMPLING_X_4))
8506 #endif
8507 {
8508 enRetType = E_PQ_ADC_SAMPLING_X_4;
8509 }
8510 else
8511 {
8512 enRetType = E_PQ_ADC_SAMPLING_NONE;
8513 }
8514
8515 memcpy(&_stMode_Info[eWindow], &stModeInfo, sizeof(MS_PQ_Mode_Info));
8516 _u16PQSrcType[eWindow] = u16PQSrcType;
8517
8518 return enRetType;
8519 }
MDrv_PQ_Get_ADCSampling_Info(PQ_WIN eWindow,PQ_INPUT_SOURCE_TYPE enInputSourceType,MS_PQ_Mode_Info * pstPQModeInfo)8520 MS_PQ_ADC_SAMPLING_TYPE MDrv_PQ_Get_ADCSampling_Info(PQ_WIN eWindow, PQ_INPUT_SOURCE_TYPE enInputSourceType, MS_PQ_Mode_Info *pstPQModeInfo)
8521 {
8522 #ifdef TRACE_DBG
8523 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
8524 #endif
8525 if (pu32PQInst == NULL)
8526 {
8527 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
8528 return FALSE;
8529 }
8530
8531 stPQ_Get_ADCSampling_Info PQArgs;
8532 PQArgs.eWindow = eWindow;
8533 PQArgs.enInputSourceType = enInputSourceType;
8534 PQArgs.pstPQModeInfo = pstPQModeInfo;
8535 PQArgs.bReturnValue = E_PQ_ADC_SAMPLING_NONE;
8536 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_ADC_SAMPLING_INTO, (void*)&PQArgs) != 0)
8537 {
8538 printf("Obtain PQ engine fail\n");
8539 return E_PQ_ADC_SAMPLING_NONE;
8540 }
8541 else
8542 {
8543 return PQArgs.bReturnValue;
8544 }
8545 }
8546
MDrv_PQ_Set3D_OnOff_U2(void * pInstance,MS_BOOL bEn)8547 MS_BOOL MDrv_PQ_Set3D_OnOff_U2(void* pInstance,MS_BOOL bEn)
8548 {
8549 _gIs3D_En = bEn;
8550 return TRUE;
8551 }
MDrv_PQ_Set3D_OnOff(MS_BOOL bEn)8552 MS_BOOL MDrv_PQ_Set3D_OnOff(MS_BOOL bEn)
8553 {
8554 #ifdef TRACE_DBG
8555 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
8556 #endif
8557 if (pu32PQInst == NULL)
8558 {
8559 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
8560 return FALSE;
8561 }
8562
8563 stPQ_Set3D_OnOff PQArgs;
8564 PQArgs.bEn = bEn;
8565 PQArgs.bReturnValue = FALSE;
8566 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_3D_ONOFF, (void*)&PQArgs) != 0)
8567 {
8568 printf("Obtain PQ engine fail\n");
8569 return FALSE;
8570 }
8571 else
8572 {
8573 return PQArgs.bReturnValue;
8574 }
8575 }
8576
MDrv_PQ_GetCaps_U2(void * pInstance,MS_PQ_CAP_INFO * pInfo)8577 MS_BOOL MDrv_PQ_GetCaps_U2(void* pInstance,MS_PQ_CAP_INFO *pInfo)
8578 {
8579 MS_BOOL bRet = TRUE;
8580 #if(PQ_ENABLE_PIP)
8581 const XC_ApiInfo* pXC_ApiInfo = MApi_XC_GetInfo();
8582 if (pXC_ApiInfo != NULL)
8583 {
8584 pInfo->bPIP_Supported = ((pXC_ApiInfo->u8MaxWindowNum) >= 2) ? TRUE : FALSE;
8585 }
8586 else
8587 {
8588 pInfo->bPIP_Supported = FALSE;
8589 bRet = FALSE;
8590 }
8591 #else
8592 pInfo->bPIP_Supported = FALSE;
8593 #endif
8594
8595 #if(PQ_ENABLE_3D_VIDEO)
8596 pInfo->b3DVideo_Supported = TRUE;
8597 #else
8598 pInfo->b3DVideo_Supported = FALSE;
8599 #endif
8600
8601 if(pInfo->bPIP_Supported)
8602 {
8603 pInfo->b4K2KPIP_Supported = PQ_BW_4K2KPIP_SUPPORT;
8604 }
8605 else
8606 {
8607 pInfo->b4K2KPIP_Supported = FALSE;
8608 }
8609
8610 return bRet;
8611 }
MDrv_PQ_GetCaps(MS_PQ_CAP_INFO * pInfo)8612 MS_BOOL MDrv_PQ_GetCaps(MS_PQ_CAP_INFO *pInfo)
8613 {
8614 #ifdef TRACE_DBG
8615 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
8616 //return FALSE;
8617 #endif
8618 if (pu32PQInst == NULL)
8619 {
8620 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
8621 {
8622 printf("UtopiaOpen PQ failed\n");
8623 return FALSE;
8624 }
8625 }
8626
8627 stPQ_GetCaps PQArgs;
8628 PQArgs.pInfo = pInfo;
8629 PQArgs.bReturnValue = FALSE;
8630 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_CAPS, (void*)&PQArgs) != 0)
8631 {
8632 printf("Obtain PQ engine fail\n");
8633 return FALSE;
8634 }
8635 else
8636 {
8637 return PQArgs.bReturnValue;
8638 }
8639 }
8640
MDRV_PQ_PrintLoadTableInfo_U2(void * pInstance,MS_PQ_PQLOADTABLE_WIN enPQWin)8641 void MDRV_PQ_PrintLoadTableInfo_U2(void* pInstance,MS_PQ_PQLOADTABLE_WIN enPQWin)
8642 {
8643 #if(ENABLE_PQ_LOAD_TABLE_INFO)
8644
8645 MS_U16 u16IPIdx;
8646 MS_U8 u8TabIdx;
8647
8648 if(enPQWin == PQ_LOAD_TABLE_MAIN)
8649 printf("[TableInfo::Main] \n");
8650 else if(enPQWin == PQ_LOAD_TABLE_MAIN_EX)
8651 printf("[TableInfo::Main Ex] \n");
8652 else if(enPQWin == PQ_LOAD_TABLE_SUB)
8653 printf("[TableInfo::SUB] \n");
8654 else if(enPQWin == PQ_LOAD_TABLE_SUB_EX)
8655 printf("[TableInfo::SUB Ex] \n");
8656 else
8657 return;
8658
8659 for(u16IPIdx = 0; u16IPIdx < PQ_IP_NUM_Main; ++ u16IPIdx)
8660 {
8661 printf(" %u(%s)=", u16IPIdx, MDrv_PQ_GetIPName(u16IPIdx)); // IP Name
8662
8663 if(enPQWin == PQ_LOAD_TABLE_MAIN)
8664 {
8665 u8TabIdx = MDrv_PQ_Get_LoadTableInfo_IP_Tab(MAIN,pInstance, u16IPIdx);
8666 if(u8TabIdx == 0xFF)
8667 printf("_____\n");
8668 else
8669 printf("%u(%s)\n", u8TabIdx, MDrv_PQ_GetTableName(u16IPIdx, u8TabIdx));
8670 }
8671 else if(enPQWin == PQ_LOAD_TABLE_MAIN_EX)
8672 {
8673 u8TabIdx = MDrv_PQ_Get_LoadTableInfo_IP_Tab(MAINEX,pInstance, u16IPIdx);
8674 if(u8TabIdx == 0xFF)
8675 printf("_____\n");
8676 else
8677 printf("Tab%u\n", u8TabIdx);
8678 }
8679
8680 #if PQ_ENABLE_PIP
8681 else if(enPQWin == PQ_LOAD_TABLE_SUB)
8682 {
8683 u8TabIdx = MDrv_PQ_Get_LoadTableInfo_IP_Tab(SUB,pInstance, u16IPIdx);
8684 if(u8TabIdx == 0xFF)
8685 printf("_____\n");
8686 else
8687 printf("%u(%s)\n", u8TabIdx, MDrv_PQ_GetTableName(u16IPIdx, u8TabIdx));
8688 }
8689 else if(enPQWin == PQ_LOAD_TABLE_SUB_EX)
8690 {
8691 u8TabIdx = MDrv_PQ_Get_LoadTableInfo_IP_Tab(SUBEX,pInstance, u16IPIdx);
8692 if(u8TabIdx == 0xFF)
8693 printf("_____\n");
8694 else
8695 printf("Tab%u\n", u8TabIdx);
8696
8697 }
8698 #endif
8699 else
8700 {
8701 }
8702 }
8703 #else
8704 UNUSED(enPQWin);
8705 #endif
8706 }
MDRV_PQ_PrintLoadTableInfo(MS_PQ_PQLOADTABLE_WIN enPQWin)8707 void MDRV_PQ_PrintLoadTableInfo(MS_PQ_PQLOADTABLE_WIN enPQWin)
8708 {
8709 #ifdef TRACE_DBG
8710 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
8711 #endif
8712 if (pu32PQInst == NULL)
8713 {
8714 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
8715 return ;
8716 }
8717
8718 stPQ_PrintLoadTableInfo PQArgs;
8719 PQArgs.enPQWin = enPQWin;
8720 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_PRINT_LOADTABLE_INFO, (void*)&PQArgs) != 0)
8721 {
8722 printf("Obtain PQ engine fail\n");
8723 return;
8724 }
8725 else
8726 {
8727 return;
8728 }
8729 }
8730
MDrv_PQ_SetDS_OnOFF_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bEn)8731 MS_BOOL MDrv_PQ_SetDS_OnOFF_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bEn)
8732 {
8733 //store the original value
8734 _u16RW_Method = Hal_PQ_get_rw_method(pInstance,eWindow == PQ_MAIN_WINDOW ? TRUE : FALSE);
8735 if(bEn)
8736 {
8737 _bDS_En = TRUE;
8738 }
8739 else
8740 {
8741 _bDS_En = FALSE;
8742 Hal_PQ_set_rw_method(pInstance,eWindow == PQ_MAIN_WINDOW ? TRUE : FALSE, _u16RW_Method);
8743 }
8744
8745 return TRUE;
8746 }
MDrv_PQ_SetDS_OnOFF(PQ_WIN eWindow,MS_BOOL bEn)8747 MS_BOOL MDrv_PQ_SetDS_OnOFF(PQ_WIN eWindow, MS_BOOL bEn)
8748 {
8749 #ifdef TRACE_DBG
8750 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
8751 #endif
8752 if (pu32PQInst == NULL)
8753 {
8754 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
8755 return FALSE;
8756 }
8757
8758 stPQ_SetDS_OnOFF PQArgs;
8759 PQArgs.eWindow = eWindow;
8760 PQArgs.bEn = bEn;
8761 PQArgs.bReturnValue = FALSE;
8762 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SETDS_ONOFF, (void*)&PQArgs) != 0)
8763 {
8764 printf("Obtain PQ engine fail\n");
8765 return FALSE;
8766 }
8767 else
8768 {
8769 return PQArgs.bReturnValue;
8770 }
8771 }
8772
MDrv_PQ_Get_RFBL_Info_U2(void * pInstance,PQ_WIN eWindow)8773 MS_BOOL MDrv_PQ_Get_RFBL_Info_U2(void* pInstance,PQ_WIN eWindow)
8774 {
8775 //useless
8776 UNUSED(eWindow);
8777 return FALSE;
8778 }
MDrv_PQ_Get_RFBL_Info(PQ_WIN eWindow)8779 MS_BOOL MDrv_PQ_Get_RFBL_Info(PQ_WIN eWindow)
8780 {
8781 #ifdef TRACE_DBG
8782 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
8783 #endif
8784 if (pu32PQInst == NULL)
8785 {
8786 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
8787 return FALSE;
8788 }
8789
8790 stPQ_Get_RFBL_Info PQArgs;
8791 PQArgs.eWindow = eWindow;
8792 PQArgs.bReturnValue = FALSE;
8793 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_RFBL_INFO, (void*)&PQArgs) != 0)
8794 {
8795 printf("Obtain PQ engine fail\n");
8796 return FALSE;
8797 }
8798 else
8799 {
8800 return PQArgs.bReturnValue;
8801 }
8802 }
8803
8804
MDrv_PQ_CheckHDMode_U2(void * pInstance,PQ_WIN eWindow)8805 MS_BOOL MDrv_PQ_CheckHDMode_U2(void* pInstance,PQ_WIN eWindow)
8806 {
8807 return _gIsSrcHDMode[eWindow];
8808 }
MDrv_PQ_CheckHDMode(PQ_WIN eWindow)8809 MS_BOOL MDrv_PQ_CheckHDMode(PQ_WIN eWindow)
8810 {
8811 #ifdef TRACE_DBG
8812 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
8813 #endif
8814 if (pu32PQInst == NULL)
8815 {
8816 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
8817 return FALSE;
8818 }
8819
8820 stPQ_CheckHDMode PQArgs;
8821 PQArgs.eWindow = eWindow;
8822 PQArgs.bReturnValue = FALSE;
8823 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_CHECK_HD_MODE, (void*)&PQArgs) != 0)
8824 {
8825 printf("Obtain PQ engine fail\n");
8826 return FALSE;
8827 }
8828 else
8829 {
8830 return PQArgs.bReturnValue;
8831 }
8832 }
8833
8834 //for Super Resolution interlace and SD mode detected use
MDrv_PQ_Get_Interlace_SD_mode_U2(void * pInstance)8835 MS_BOOL MDrv_PQ_Get_Interlace_SD_mode_U2(void* pInstance)
8836 {
8837 if(QM_IsInterlaced(PQ_MAIN_WINDOW) && (QM_GetInputHSize(PQ_MAIN_WINDOW) < 1500))
8838 {
8839 return TRUE;
8840 }
8841 else
8842 {
8843 return FALSE;
8844 }
8845 }
MDrv_PQ_Get_Interlace_SD_mode(void)8846 MS_BOOL MDrv_PQ_Get_Interlace_SD_mode(void)
8847 {
8848 #ifdef TRACE_DBG
8849 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
8850 #endif
8851 if (pu32PQInst == NULL)
8852 {
8853 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
8854 return FALSE;
8855 }
8856
8857 stPQ_Get_Interlace_SD_mode PQArgs;
8858 PQArgs.bReturnValue = FALSE;
8859 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_INTERLACE_SD_MODE, (void*)&PQArgs) != 0)
8860 {
8861 printf("Obtain PQ engine fail\n");
8862 return FALSE;
8863 }
8864 else
8865 {
8866 return PQArgs.bReturnValue;
8867 }
8868 }
8869
MDrv_PQ_SetDualViewState_U2(void * pInstance,MS_BOOL bEnable)8870 MS_BOOL MDrv_PQ_SetDualViewState_U2(void* pInstance,MS_BOOL bEnable)
8871 {
8872 _bDualViewEnable = bEnable;
8873 MDrv_PQ_ForceVideoInputMode(bEnable, PQ_MAIN_WINDOW);
8874 MDrv_PQ_ForceVideoInputMode(bEnable, PQ_SUB_WINDOW);
8875 return TRUE;
8876 }
MDrv_PQ_SetDualViewState(MS_BOOL bEnable)8877 MS_BOOL MDrv_PQ_SetDualViewState(MS_BOOL bEnable)
8878 {
8879 #ifdef TRACE_DBG
8880 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
8881 #endif
8882 if (pu32PQInst == NULL)
8883 {
8884 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
8885 return FALSE;
8886 }
8887
8888 stPQ_SetDualViewState PQArgs;
8889 PQArgs.bEnable = bEnable;
8890 PQArgs.bReturnValue = FALSE;
8891 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_DUAL_VIEW_STATE, (void*)&PQArgs) != 0)
8892 {
8893 printf("Obtain PQ engine fail\n");
8894 return FALSE;
8895 }
8896 else
8897 {
8898 return PQArgs.bReturnValue;
8899 }
8900 }
8901
MDrv_PQ_GetVGASubCaseForceTo422Mode_U2(void * pInstance)8902 MS_BOOL MDrv_PQ_GetVGASubCaseForceTo422Mode_U2(void* pInstance)
8903 {
8904 return PQ_VGASubCaseForceTo422Mode;
8905 }
MDrv_PQ_GetVGASubCaseForceTo422Mode(void)8906 MS_BOOL MDrv_PQ_GetVGASubCaseForceTo422Mode(void)
8907 {
8908 #ifdef TRACE_DBG
8909 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
8910 #endif
8911 if (pu32PQInst == NULL)
8912 {
8913 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
8914 return FALSE;
8915 }
8916
8917 stPQ_GetVGASubCaseForceTo422Mode PQArgs;
8918 PQArgs.bReturnValue = FALSE;
8919 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_VGASUBCASE_FORCETO_422MODE, (void*)&PQArgs) != 0)
8920 {
8921 printf("Obtain PQ engine fail\n");
8922 return FALSE;
8923 }
8924 else
8925 {
8926 return PQArgs.bReturnValue;
8927 }
8928 }
8929
MDrv_PQ_GetDualViewState_U2(void * pInstance)8930 MS_BOOL MDrv_PQ_GetDualViewState_U2(void* pInstance)
8931 {
8932 return _bDualViewEnable;
8933 }
MDrv_PQ_GetDualViewState(void)8934 MS_BOOL MDrv_PQ_GetDualViewState(void)
8935 {
8936 #ifdef TRACE_DBG
8937 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
8938 #endif
8939 if (pu32PQInst == NULL)
8940 {
8941 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
8942 return FALSE;
8943 }
8944
8945 stPQ_GetDualViewState PQArgs;
8946 PQArgs.bReturnValue = FALSE;
8947 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_DUAL_VIEW_STATE, (void*)&PQArgs) != 0)
8948 {
8949 printf("Obtain PQ engine fail\n");
8950 return FALSE;
8951 }
8952 else
8953 {
8954 return PQArgs.bReturnValue;
8955 }
8956 }
8957
8958 //Is Force Input to do IP_CSC
MDrv_PQ_ForceVideoInputMode_U2(void * pInstance,MS_BOOL bEnable,PQ_WIN eWindow)8959 MS_BOOL MDrv_PQ_ForceVideoInputMode_U2(void* pInstance,MS_BOOL bEnable, PQ_WIN eWindow)
8960 {
8961 _bForceVideoInputMode[eWindow] = bEnable;
8962 return TRUE;
8963 }
MDrv_PQ_ForceVideoInputMode(MS_BOOL bEnable,PQ_WIN eWindow)8964 MS_BOOL MDrv_PQ_ForceVideoInputMode(MS_BOOL bEnable, PQ_WIN eWindow)
8965 {
8966 #ifdef TRACE_DBG
8967 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
8968 #endif
8969 if (pu32PQInst == NULL)
8970 {
8971 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
8972 return FALSE;
8973 }
8974
8975 stPQ_ForceVideoInputMode PQArgs;
8976 PQArgs.bEnable = bEnable;
8977 PQArgs.eWindow = eWindow;
8978 PQArgs.bReturnValue = FALSE;
8979 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_FORCE_VIDEO_INPUT_MODE, (void*)&PQArgs) != 0)
8980 {
8981 printf("Obtain PQ engine fail\n");
8982 return FALSE;
8983 }
8984 else
8985 {
8986 return PQArgs.bReturnValue;
8987 }
8988 }
8989
8990 //Force Input to do IP_CSC
MDrv_PQ_IsForceVideoInputMode_U2(void * pInstance,PQ_WIN eWindow)8991 MS_BOOL MDrv_PQ_IsForceVideoInputMode_U2(void* pInstance,PQ_WIN eWindow)
8992 {
8993 if(_bForceVideoInputMode[eWindow])
8994 {
8995 return TRUE;
8996 }
8997 else
8998 {
8999 return FALSE;
9000 }
9001 }
MDrv_PQ_IsForceVideoInputMode(PQ_WIN eWindow)9002 MS_BOOL MDrv_PQ_IsForceVideoInputMode(PQ_WIN eWindow)
9003 {
9004 #ifdef TRACE_DBG
9005 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9006 #endif
9007 if (pu32PQInst == NULL)
9008 {
9009 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9010 return FALSE;
9011 }
9012
9013 stPQ_IsForceVideoInputMode PQArgs;
9014 PQArgs.eWindow = eWindow;
9015 PQArgs.bReturnValue = FALSE;
9016 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_IS_FORCE_VIDEO_INPUTMODE, (void*)&PQArgs) != 0)
9017 {
9018 printf("Obtain PQ engine fail\n");
9019 return FALSE;
9020 }
9021 else
9022 {
9023 return PQArgs.bReturnValue;
9024 }
9025 }
9026
MDrv_PQ_Set_PointToPoint_U2(void * pInstance,XC_SETWIN_INFO * pstXC_SetWin_Info,MS_BOOL bEnable,PQ_WIN eWindow)9027 MS_BOOL MDrv_PQ_Set_PointToPoint_U2(void* pInstance,XC_SETWIN_INFO *pstXC_SetWin_Info,
9028 MS_BOOL bEnable,
9029 PQ_WIN eWindow)
9030 {
9031 //sub window don't support point to point
9032 if(eWindow == PQ_SUB_WINDOW)
9033 {
9034 return FALSE;
9035 }
9036
9037 if(bEnable)
9038 {
9039 //Center the display window
9040 if(g_IPanel.Width() >= pstXC_SetWin_Info->stCropWin.width)
9041 {
9042 pstXC_SetWin_Info->stDispWin.x = (g_IPanel.Width() - pstXC_SetWin_Info->stCropWin.width)/2;
9043 pstXC_SetWin_Info->stDispWin.width = pstXC_SetWin_Info->stCropWin.width;
9044 }
9045 else
9046 {
9047 pstXC_SetWin_Info->stDispWin.x = 0;
9048 pstXC_SetWin_Info->stDispWin.width = g_IPanel.Width();
9049 }
9050
9051 if(g_IPanel.Height() >= pstXC_SetWin_Info->stCropWin.height)
9052 {
9053 pstXC_SetWin_Info->stDispWin.y = (g_IPanel.Height() - pstXC_SetWin_Info->stCropWin.height)/2;
9054 pstXC_SetWin_Info->stDispWin.height = pstXC_SetWin_Info->stCropWin.height;
9055 }
9056 else
9057 {
9058 pstXC_SetWin_Info->stDispWin.y = 0;
9059 pstXC_SetWin_Info->stDispWin.height = g_IPanel.Height();
9060 }
9061
9062 //RGB HDMI, DVI, VGA
9063 if((((IsSrcTypeHDMI(pstXC_SetWin_Info->enInputSourceType)) && (_stHDMI_Info[eWindow].bIsHDMI == TRUE) && (QM_HDMIPC_COLORRGB(PQ_MAIN_WINDOW))) ||
9064 ((IsSrcTypeHDMI(pstXC_SetWin_Info->enInputSourceType)) && (_stHDMI_Info[eWindow].bIsHDMI == FALSE) && (QM_HDMIPC_COLORRGB(PQ_MAIN_WINDOW))) ||
9065 (IsSrcTypeVga(pstXC_SetWin_Info->enInputSourceType))) &&
9066 (!pstXC_SetWin_Info->bInterlace))
9067 {
9068 if(_bP2pForceToDoCsc && _enOutputColorFmt == E_PQ_COLOR_YUV444)
9069 {
9070 MApi_XC_EnableForceRGBin(FALSE, MAIN_WINDOW);
9071 }
9072 else
9073 {
9074 MApi_XC_EnableForceRGBin(TRUE, MAIN_WINDOW);
9075 }
9076 }
9077 //MApi_XC_Set_MemFmtEx(E_MS_XC_MEM_FMT_444, eWindow);
9078 MApi_XC_Set_MemFmtEx(E_MS_XC_MEM_FMT_444, eWindow);
9079 }
9080 else
9081 {
9082 MApi_XC_EnableForceRGBin(FALSE, MAIN_WINDOW);
9083 //MApi_XC_Set_MemFmtEx(E_MS_XC_MEM_FMT_AUTO, eWindow);
9084 MApi_XC_Set_MemFmtEx(E_MS_XC_MEM_FMT_AUTO, eWindow);
9085 }
9086
9087 PQP2P_DBG(printf("[MDrv_PQ_Set_PointToPoint] True or False: %u\n",bEnable);)
9088 _bPointToPointMode = bEnable;
9089
9090 return TRUE;
9091 }
MDrv_PQ_Set_PointToPoint(XC_SETWIN_INFO * pstXC_SetWin_Info,MS_BOOL bEnable,PQ_WIN eWindow)9092 MS_BOOL MDrv_PQ_Set_PointToPoint(XC_SETWIN_INFO *pstXC_SetWin_Info,
9093 MS_BOOL bEnable,
9094 PQ_WIN eWindow)
9095 {
9096 #ifdef TRACE_DBG
9097 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9098 #endif
9099 if (pu32PQInst == NULL)
9100 {
9101 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9102 return FALSE;
9103 }
9104
9105 stPQ_Set_PointToPoint PQArgs;
9106 PQArgs.pstXC_SetWin_Info = pstXC_SetWin_Info;
9107 PQArgs.bEnable = bEnable;
9108 PQArgs.eWindow = eWindow;
9109 PQArgs.bReturnValue = FALSE;
9110 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_POINT2POINT, (void*)&PQArgs) != 0)
9111 {
9112 printf("Obtain PQ engine fail\n");
9113 return FALSE;
9114 }
9115 else
9116 {
9117 return PQArgs.bReturnValue;
9118 }
9119 }
9120
MDrv_PQ_Get_PointToPoint_U2(void * pInstance,PQ_WIN eWindow)9121 MS_BOOL MDrv_PQ_Get_PointToPoint_U2(void* pInstance,PQ_WIN eWindow)
9122 {
9123 //Only Main window support point to point
9124 if(eWindow == PQ_MAIN_WINDOW)
9125 {
9126 return _bPointToPointMode;
9127 }
9128 else
9129 {
9130 return FALSE;
9131 }
9132 }
MDrv_PQ_Get_PointToPoint(PQ_WIN eWindow)9133 MS_BOOL MDrv_PQ_Get_PointToPoint(PQ_WIN eWindow)
9134 {
9135 #ifdef TRACE_DBG
9136 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9137 #endif
9138 if (pu32PQInst == NULL)
9139 {
9140 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9141 return FALSE;
9142 }
9143
9144 stPQ_Get_PointToPoint PQArgs;
9145 PQArgs.eWindow = eWindow;
9146 PQArgs.bReturnValue = FALSE;
9147 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_POINT2POINT, (void*)&PQArgs) != 0)
9148 {
9149 printf("Obtain PQ engine fail\n");
9150 return FALSE;
9151 }
9152 else
9153 {
9154 return PQArgs.bReturnValue;
9155 }
9156 }
9157
MDrv_PQ_Set_PqBypass_U2(void * pInstance,XC_SETWIN_INFO * pstXC_SetWin_Info,MS_BOOL bEnable,PQ_WIN eWindow)9158 MS_BOOL MDrv_PQ_Set_PqBypass_U2(void* pInstance,XC_SETWIN_INFO *pstXC_SetWin_Info,
9159 MS_BOOL bEnable,
9160 PQ_WIN eWindow)
9161 {
9162 //sub window don't support PQ bypass
9163 if(eWindow == PQ_SUB_WINDOW)
9164 {
9165 return FALSE;
9166 }
9167
9168 if(bEnable)
9169 {
9170 //RGB HDMI, DVI, VGA
9171 if((((IsSrcTypeHDMI(pstXC_SetWin_Info->enInputSourceType)) && (_stHDMI_Info[eWindow].bIsHDMI == TRUE) && (QM_HDMIPC_COLORRGB(PQ_MAIN_WINDOW))) ||
9172 ((IsSrcTypeHDMI(pstXC_SetWin_Info->enInputSourceType)) && (_stHDMI_Info[eWindow].bIsHDMI == FALSE) && (QM_HDMIPC_COLORRGB(PQ_MAIN_WINDOW))) ||
9173 (IsSrcTypeVga(pstXC_SetWin_Info->enInputSourceType))) &&
9174 (!pstXC_SetWin_Info->bInterlace))
9175 {
9176 MApi_XC_EnableForceRGBin(TRUE, MAIN_WINDOW);
9177 }
9178 //MApi_XC_Set_MemFmtEx(E_MS_XC_MEM_FMT_444, eWindow);
9179 MApi_XC_Set_MemFmtEx(E_MS_XC_MEM_FMT_444, eWindow);
9180 }
9181 else
9182 {
9183 MApi_XC_EnableForceRGBin(FALSE, MAIN_WINDOW);
9184 //MApi_XC_Set_MemFmtEx(E_MS_XC_MEM_FMT_AUTO, eWindow);
9185 MApi_XC_Set_MemFmtEx(E_MS_XC_MEM_FMT_AUTO, eWindow);
9186 }
9187
9188 printf("[MDrv_PQ_Set_PqBypass] True or False: %u\n",bEnable);
9189 _bPqBypassMode = bEnable;
9190
9191 return TRUE;
9192 }
9193
MDrv_PQ_Set_PqBypass(XC_SETWIN_INFO * pstXC_SetWin_Info,MS_BOOL bEnable,PQ_WIN eWindow)9194 MS_BOOL MDrv_PQ_Set_PqBypass(XC_SETWIN_INFO *pstXC_SetWin_Info,
9195 MS_BOOL bEnable,
9196 PQ_WIN eWindow)
9197 {
9198 #ifdef TRACE_DBG
9199 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9200 #endif
9201 if (pu32PQInst == NULL)
9202 {
9203 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9204 return FALSE;
9205 }
9206
9207 stPQ_Set_PqBypass PQArgs;
9208 PQArgs.pstXC_SetWin_Info = pstXC_SetWin_Info;
9209 PQArgs.bEnable = bEnable;
9210 PQArgs.eWindow = eWindow;
9211 PQArgs.bReturnValue = FALSE;
9212 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_PQBYPASS, (void*)&PQArgs) != 0)
9213 {
9214 printf("Obtain PQ engine fail\n");
9215 return FALSE;
9216 }
9217 else
9218 {
9219 return PQArgs.bReturnValue;
9220 }
9221 }
9222
MDrv_PQ_Get_PqBypass_U2(void * pInstance,PQ_WIN eWindow)9223 MS_BOOL MDrv_PQ_Get_PqBypass_U2(void* pInstance,PQ_WIN eWindow)
9224 {
9225 //Only Main window support PQ bypass
9226 if(eWindow == PQ_MAIN_WINDOW)
9227 {
9228 return _bPqBypassMode;
9229 }
9230 else
9231 {
9232 return FALSE;
9233 }
9234 }
9235
MDrv_PQ_Get_PqBypass(PQ_WIN eWindow)9236 MS_BOOL MDrv_PQ_Get_PqBypass(PQ_WIN eWindow)
9237 {
9238 #ifdef TRACE_DBG
9239 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9240 #endif
9241 if (pu32PQInst == NULL)
9242 {
9243 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9244 return FALSE;
9245 }
9246
9247 stPQ_Get_PqBypass PQArgs;
9248 PQArgs.eWindow = eWindow;
9249 PQArgs.bReturnValue = FALSE;
9250 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_POINT2POINT, (void*)&PQArgs) != 0)
9251 {
9252 printf("Obtain PQ engine fail\n");
9253 return FALSE;
9254 }
9255 else
9256 {
9257 return PQArgs.bReturnValue;
9258 }
9259 }
9260
MDrv_PQ_Update_MemFormat_U2(void * pInstance)9261 MS_BOOL MDrv_PQ_Update_MemFormat_U2(void* pInstance)
9262 {
9263 MS_U8 u8BitPerPixel = 0;
9264 MDrv_PQ_SetMemFormat(
9265 PQ_MAIN_WINDOW,
9266 _gbMemfmt422[PQ_MAIN_WINDOW],
9267 _stMode_Info[PQ_MAIN_WINDOW].bFBL,
9268 &u8BitPerPixel);
9269
9270 return TRUE;
9271 }
MDrv_PQ_Update_MemFormat(void)9272 MS_BOOL MDrv_PQ_Update_MemFormat(void)
9273 {
9274 #ifdef TRACE_DBG
9275 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9276 #endif
9277 if (pu32PQInst == NULL)
9278 {
9279 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9280 return FALSE;
9281 }
9282
9283 stPQ_Update_MemFormat PQArgs;
9284 PQArgs.bReturnValue = FALSE;
9285 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_UPDATE_MEMFORMAT, (void*)&PQArgs) != 0)
9286 {
9287 printf("Obtain PQ engine fail\n");
9288 return FALSE;
9289 }
9290 else
9291 {
9292 return PQArgs.bReturnValue;
9293 }
9294 }
9295
MDrv_PQ_GetHsize_U2(void * pInstance,PQ_WIN enPQWin)9296 MS_U16 MDrv_PQ_GetHsize_U2(void* pInstance,PQ_WIN enPQWin)
9297 {
9298 return _stMode_Info[enPQWin].u16input_hsize;
9299 }
MDrv_PQ_GetHsize(PQ_WIN enPQWin)9300 MS_U16 MDrv_PQ_GetHsize(PQ_WIN enPQWin)
9301 {
9302 #ifdef TRACE_DBG
9303 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9304 #endif
9305 if (pu32PQInst == NULL)
9306 {
9307 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9308 return FALSE;
9309 }
9310
9311 stPQ_GetHsize PQArgs;
9312 PQArgs.enPQWin = enPQWin;
9313 PQArgs.u16Ret = 0;
9314 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_HSIZE, (void*)&PQArgs) != 0)
9315 {
9316 printf("Obtain PQ engine fail\n");
9317 return 0;
9318 }
9319 else
9320 {
9321 return PQArgs.u16Ret;
9322 }
9323 }
9324
MDrv_PQ_GetVsize_U2(void * pInstance,PQ_WIN enPQWin)9325 MS_U16 MDrv_PQ_GetVsize_U2(void* pInstance,PQ_WIN enPQWin)
9326 {
9327 return _stMode_Info[enPQWin].u16input_vsize;
9328 }
MDrv_PQ_GetVsize(PQ_WIN enPQWin)9329 MS_U16 MDrv_PQ_GetVsize(PQ_WIN enPQWin)
9330 {
9331 #ifdef TRACE_DBG
9332 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9333 #endif
9334 if (pu32PQInst == NULL)
9335 {
9336 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
9337 {
9338 printf("UtopiaOpen PQ failed\n");
9339 return FALSE;
9340 }
9341 }
9342
9343 stPQ_GetVsize PQArgs;
9344 PQArgs.enPQWin = enPQWin;
9345 PQArgs.u16Ret = 0;
9346 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_VSIZE, (void*)&PQArgs) != 0)
9347 {
9348 printf("Obtain PQ engine fail\n");
9349 return 0;
9350 }
9351 else
9352 {
9353 return PQArgs.u16Ret;
9354 }
9355 }
9356
MDrv_PQ_IsInterlace_U2(void * pInstance,PQ_WIN enPQWin)9357 MS_BOOL MDrv_PQ_IsInterlace_U2(void* pInstance,PQ_WIN enPQWin)
9358 {
9359 return _stMode_Info[enPQWin].bInterlace;
9360 }
MDrv_PQ_IsInterlace(PQ_WIN enPQWin)9361 MS_BOOL MDrv_PQ_IsInterlace(PQ_WIN enPQWin)
9362 {
9363 #ifdef TRACE_DBG
9364 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9365 #endif
9366 if (pu32PQInst == NULL)
9367 {
9368 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9369 return FALSE;
9370 }
9371
9372 stPQ_IsInterlace PQArgs;
9373 PQArgs.enPQWin = enPQWin;
9374 PQArgs.bReturnValue = FALSE;
9375 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_IS_INTERLACE, (void*)&PQArgs) != 0)
9376 {
9377 printf("Obtain PQ engine fail\n");
9378 return FALSE;
9379 }
9380 else
9381 {
9382 return PQArgs.bReturnValue;
9383 }
9384 }
9385
MDrv_PQ_LOW_3dQuality_U2(void * pInstance,MS_BOOL bEnable)9386 MS_BOOL MDrv_PQ_LOW_3dQuality_U2(void* pInstance,MS_BOOL bEnable)
9387 {
9388 if(bEnable)
9389 {
9390 #if PQ_VIP_CTL
9391 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_Peaking_band_AV_NTSC_Main, PQ_IP_VIP_Peaking_band_Main);
9392 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_VNMR_S2_Main, PQ_IP_VIP_VNMR_Main);
9393 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_VLPF_coef1_0x6_Main, PQ_IP_VIP_VLPF_coef1_Main);
9394 #endif
9395 }
9396 else
9397 {
9398 #if PQ_VIP_CTL
9399 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, MDrv_PQ_GetTableIndex_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_Peaking_band_Main), PQ_IP_VIP_Peaking_band_Main);
9400 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, MDrv_PQ_GetTableIndex_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_VNMR_Main), PQ_IP_VIP_VNMR_Main);
9401 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, MDrv_PQ_GetTableIndex_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_VLPF_coef1_Main), PQ_IP_VIP_VLPF_coef1_Main);
9402 #endif
9403 }
9404 return TRUE;
9405 }
MDrv_PQ_LOW_3dQuality(MS_BOOL bEnable)9406 MS_BOOL MDrv_PQ_LOW_3dQuality(MS_BOOL bEnable)
9407 {
9408 #ifdef TRACE_DBG
9409 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9410 #endif
9411 if (pu32PQInst == NULL)
9412 {
9413 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9414 return FALSE;
9415 }
9416
9417 stPQ_LOW_3dQuality PQArgs;
9418 PQArgs.bEnable = bEnable;
9419 PQArgs.bReturnValue = FALSE;
9420 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOW_3D_QUALITY, (void*)&PQArgs) != 0)
9421 {
9422 printf("Obtain PQ engine fail\n");
9423 return FALSE;
9424 }
9425 else
9426 {
9427 return PQArgs.bReturnValue;
9428 }
9429 }
9430
MDrv_PQ_MWE_SetEnhanceQuality_U2(void * pInstance)9431 MS_BOOL MDrv_PQ_MWE_SetEnhanceQuality_U2(void* pInstance)
9432 {
9433 #if PQ_VIP_RGBCMY_CTL
9434 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_R_INC_3_Main, PQ_IP_VIP_ICC_R_Main);
9435 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_G_INC_8_Main, PQ_IP_VIP_ICC_G_Main);
9436 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_B_INC_6_Main, PQ_IP_VIP_ICC_B_Main);
9437 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_C_INC_6_Main, PQ_IP_VIP_ICC_C_Main);
9438 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_M_INC_6_Main, PQ_IP_VIP_ICC_M_Main);
9439 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_Y_INC_7_Main, PQ_IP_VIP_ICC_Y_Main);
9440 #elif PQ_VIP_RGBCMY_CTL_VER2
9441 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_SETTING_Enhance_6Color_Main, PQ_IP_VIP_ICC_SETTING_Main);
9442 #endif
9443 return TRUE;
9444 }
MDrv_PQ_MWE_SetEnhanceQuality(void)9445 MS_BOOL MDrv_PQ_MWE_SetEnhanceQuality(void)
9446 {
9447 #ifdef TRACE_DBG
9448 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9449 #endif
9450 if (pu32PQInst == NULL)
9451 {
9452 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9453 return FALSE;
9454 }
9455
9456 stPQ_MWE_SetEnhanceQuality PQArgs;
9457 PQArgs.bReturnValue = FALSE;
9458 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_MWE_SET_ENHANCE_QUALITY, (void*)&PQArgs) != 0)
9459 {
9460 printf("Obtain PQ engine fail\n");
9461 return FALSE;
9462 }
9463 else
9464 {
9465 return PQArgs.bReturnValue;
9466 }
9467 }
9468
MDrv_PQ_MWE_RestoreEnhanceQuality_U2(void * pInstance)9469 MS_BOOL MDrv_PQ_MWE_RestoreEnhanceQuality_U2(void* pInstance)
9470 {
9471 #if PQ_VIP_RGBCMY_CTL
9472 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, MDrv_PQ_GetTableIndex_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_R_Main), PQ_IP_VIP_ICC_R_Main);
9473 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, MDrv_PQ_GetTableIndex_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_G_Main), PQ_IP_VIP_ICC_G_Main);
9474 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, MDrv_PQ_GetTableIndex_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_B_Main), PQ_IP_VIP_ICC_B_Main);
9475 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, MDrv_PQ_GetTableIndex_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_C_Main), PQ_IP_VIP_ICC_C_Main);
9476 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, MDrv_PQ_GetTableIndex_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_M_Main), PQ_IP_VIP_ICC_M_Main);
9477 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, MDrv_PQ_GetTableIndex_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_Y_Main), PQ_IP_VIP_ICC_Y_Main);
9478 #elif PQ_VIP_RGBCMY_CTL_VER2
9479 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, MDrv_PQ_GetTableIndex_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_SETTING_Main), PQ_IP_VIP_ICC_SETTING_Main);
9480 #endif
9481 return TRUE;
9482 }
MDrv_PQ_MWE_RestoreEnhanceQuality(void)9483 MS_BOOL MDrv_PQ_MWE_RestoreEnhanceQuality(void)
9484 {
9485 #ifdef TRACE_DBG
9486 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9487 #endif
9488 if (pu32PQInst == NULL)
9489 {
9490 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9491 return FALSE;
9492 }
9493
9494 stPQ_MWE_RestoreEnhanceQuality PQArgs;
9495 PQArgs.bReturnValue = FALSE;
9496 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_MWE_RESTORE_ENHANCE_QUALITY, (void*)&PQArgs) != 0)
9497 {
9498 printf("Obtain PQ engine fail\n");
9499 return FALSE;
9500 }
9501 else
9502 {
9503 return PQArgs.bReturnValue;
9504 }
9505 }
9506
MDrv_PQ_MWE_RestoreOffQuality_U2(void * pInstance)9507 MS_BOOL MDrv_PQ_MWE_RestoreOffQuality_U2(void* pInstance)
9508 {
9509 #if PQ_VIP_CTL
9510 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_ON_Main, PQ_IP_VIP_ICC_Main);
9511 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_IBC_ON_Main, PQ_IP_VIP_IBC_Main);
9512 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_IHC_ON_Main, PQ_IP_VIP_IHC_Main);
9513 #endif
9514 return TRUE;
9515 }
MDrv_PQ_MWE_RestoreOffQuality(void)9516 MS_BOOL MDrv_PQ_MWE_RestoreOffQuality(void)
9517 {
9518 #ifdef TRACE_DBG
9519 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9520 #endif
9521 if (pu32PQInst == NULL)
9522 {
9523 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9524 return FALSE;
9525 }
9526
9527 stPQ_MWE_RestoreOffQuality PQArgs;
9528 PQArgs.bReturnValue = FALSE;
9529 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_MWE_RESTORE_OFF_QUALITY, (void*)&PQArgs) != 0)
9530 {
9531 printf("Obtain PQ engine fail\n");
9532 return FALSE;
9533 }
9534 else
9535 {
9536 return PQArgs.bReturnValue;
9537 }
9538 }
9539
MDrv_PQ_Demo_CloneWindow_U2(void * pInstance,PQ_WIN eWindow,MS_U8 u8Mode)9540 MS_BOOL MDrv_PQ_Demo_CloneWindow_U2(void* pInstance, PQ_WIN eWindow, MS_U8 u8Mode)
9541 {
9542 #if (PQ_DEMO_MODE_ENABLE == 1)
9543 if(u8Mode >= PQ_IP_MWE_diff_no_comm_NUMS_Main)
9544 {
9545 printf("%s %d: Not support the PQ Mode:%d\n",__FUNCTION__,__LINE__,u8Mode);
9546 return FALSE;
9547 }
9548
9549 #if (PQ_QM_MWE_CLONE_VER1 == 1)
9550 MDrv_PQ_CloneTable_U2(pInstance, eWindow, PQ_IP_MWE_Clone_main_no_comm_OFF_Main, PQ_IP_MWE_Clone_main_no_comm_Main, PQ_IP_MWE_Clone_sub_no_comm_Main);
9551 MApi_XC_ACE_SetMWELoadFromPQ(TRUE);
9552 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u8Mode, PQ_IP_MWE_diff_no_comm_Main);
9553 #elif (PQ_QM_MWE_CLONE_VER2 == 1)
9554 MDrv_PQ_CloneTable(pInstance, eWindow, PQ_IP_Clone_main_no_comm_OFF_Main, PQ_IP_Clone_main_no_comm_Main, PQ_IP_Clone_sub_no_comm_Main);
9555 MApi_XC_ACE_SetMWELoadFromPQ(TRUE);
9556 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u8Mode, PQ_IP_MWE_diff_no_comm_Main);
9557 #else
9558 UNUSED(eWindow);
9559 #endif
9560 #endif
9561 return TRUE;
9562 }
9563
MDrv_PQ_Demo_CloneWindow(PQ_WIN eWindow,MS_U8 u8Mode)9564 MS_BOOL MDrv_PQ_Demo_CloneWindow(PQ_WIN eWindow, MS_U8 u8Mode)
9565 {
9566 #ifdef TRACE_DBG
9567 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9568 #endif
9569 if (pu32PQInst == NULL)
9570 {
9571 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9572 return FALSE;
9573 }
9574
9575 stPQ_Demo_CloneWindow PQArgs;
9576 PQArgs.eWindow = eWindow;
9577 PQArgs.u8Mode = u8Mode;
9578 PQArgs.bRet = FALSE;
9579 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_DEMO_CLONE_WINDOW, (void*)&PQArgs) != 0)
9580 {
9581 printf("Obtain PQ engine fail\n");
9582 return FALSE;
9583 }
9584 else
9585 {
9586 return PQArgs.bRet;
9587 }
9588 }
9589
MDrv_PQ_EnableScalerGamma_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bEnable)9590 void MDrv_PQ_EnableScalerGamma_U2(void* pInstance, PQ_WIN eWindow, MS_BOOL bEnable)
9591 {
9592 #if (PQ_SCALER_GAMMA_ENABLE == 1)
9593 PQ_IP_Gamma_Group_Main ePQIPGamma;
9594 ePQIPGamma = (bEnable == TRUE)?PQ_IP_Gamma_ON_Main:PQ_IP_Gamma_OFF_Main;
9595 printf("%s :enable gamma: %d \n",__FUNCTION__,ePQIPGamma);
9596 MDrv_PQ_LoadTable_U2(pInstance, PQ_MAIN_WINDOW, ePQIPGamma, PQ_IP_Gamma_Main);
9597 #endif
9598 }
MDrv_PQ_EnableScalerGamma(PQ_WIN eWindow,MS_BOOL bEnable)9599 void MDrv_PQ_EnableScalerGamma(PQ_WIN eWindow, MS_BOOL bEnable)
9600 {
9601 #ifdef TRACE_DBG
9602 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9603 #endif
9604 if (pu32PQInst == NULL)
9605 {
9606 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9607 }
9608
9609 stPQ_EnableScalerGamma PQArgs;
9610 PQArgs.eWindow = eWindow;
9611 PQArgs.bEnable = bEnable;
9612 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_ENABLE_SCALER_GAMMA, (void*)&PQArgs) != 0)
9613 {
9614 printf("Obtain PQ engine fail\n");
9615 }
9616 }
MDrv_PQ_SetGammaTbl_U2(void * pInstance,APIPNL_GAMMA_TYPE enGammType,MS_U8 ** pu8GammTable,APIPNL_GAMMA_MAPPEING_MODE enGammaMappingMode)9617 void MDrv_PQ_SetGammaTbl_U2(void* pInstance, APIPNL_GAMMA_TYPE enGammType, MS_U8 **pu8GammTable, APIPNL_GAMMA_MAPPEING_MODE enGammaMappingMode)
9618 {
9619 g_IPanel.SetGammaTbl(enGammType, pu8GammTable, enGammaMappingMode);
9620 }
MDrv_PQ_SetGammaTbl(APIPNL_GAMMA_TYPE enGammType,MS_U8 ** pu8GammTable,APIPNL_GAMMA_MAPPEING_MODE enGammaMappingMode)9621 void MDrv_PQ_SetGammaTbl(APIPNL_GAMMA_TYPE enGammType, MS_U8 **pu8GammTable, APIPNL_GAMMA_MAPPEING_MODE enGammaMappingMode)
9622 {
9623 #ifdef TRACE_DBG
9624 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9625 #endif
9626 if (pu32PQInst == NULL)
9627 {
9628 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9629 }
9630
9631 stPQ_SetGammaTbl PQArgs;
9632 PQArgs.pu8GammTable = pu8GammTable;
9633 PQArgs.enGammaMappingMode = enGammaMappingMode;
9634 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_GAMMA_TBl, (void*)&PQArgs) != 0)
9635 {
9636 printf("Obtain PQ engine fail\n");
9637 }
9638 }
9639
MDrv_PQ_MWE_SetOffQuality_U2(void * pInstance)9640 MS_BOOL MDrv_PQ_MWE_SetOffQuality_U2(void* pInstance)
9641 {
9642 #if PQ_VIP_CTL
9643 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_ICC_OFF_Main, PQ_IP_VIP_ICC_Main);
9644 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_IBC_OFF_Main, PQ_IP_VIP_IBC_Main);
9645 MDrv_PQ_LoadTable_U2(pInstance,PQ_MAIN_WINDOW, PQ_IP_VIP_IHC_OFF_Main, PQ_IP_VIP_IHC_Main);
9646 #endif
9647 return TRUE;
9648 }
MDrv_PQ_MWE_SetOffQuality(void)9649 MS_BOOL MDrv_PQ_MWE_SetOffQuality(void)
9650 {
9651 #ifdef TRACE_DBG
9652 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9653 #endif
9654 if (pu32PQInst == NULL)
9655 {
9656 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9657 return FALSE;
9658 }
9659
9660 stPQ_MWE_SetOffQuality PQArgs;
9661 PQArgs.bReturnValue = FALSE;
9662 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_MWE_SET_OFF_QUALITY, (void*)&PQArgs) != 0)
9663 {
9664 printf("Obtain PQ engine fail\n");
9665 return FALSE;
9666 }
9667 else
9668 {
9669 return PQArgs.bReturnValue;
9670 }
9671 }
9672
MDrv_PQ_MWE_CloneWindow_U2(void * pInstance,PQ_WIN eWindow)9673 void MDrv_PQ_MWE_CloneWindow_U2(void* pInstance,PQ_WIN eWindow)
9674 {
9675 #if (PQ_QM_MWE_CLONE_VER1 == 1)
9676 MDrv_PQ_CloneTable(eWindow, PQ_IP_MWE_Clone_main_no_comm_OFF_Main, PQ_IP_MWE_Clone_main_no_comm_Main, PQ_IP_MWE_Clone_sub_no_comm_Main);
9677 MApi_XC_ACE_SetMWELoadFromPQ(TRUE);
9678 MDrv_PQ_LoadTable_U2(pInstance,eWindow, PQ_IP_MWE_diff_no_comm_ON_Main, PQ_IP_MWE_diff_no_comm_Main);
9679 #elif (PQ_QM_MWE_CLONE_VER2 == 1)
9680 MDrv_PQ_CloneTable(eWindow, PQ_IP_Clone_main_no_comm_OFF_Main, PQ_IP_Clone_main_no_comm_Main, PQ_IP_Clone_sub_no_comm_Main);
9681 MApi_XC_ACE_SetMWELoadFromPQ(TRUE);
9682 MDrv_PQ_LoadTable_U2(pInstance,eWindow, PQ_IP_MWE_diff_no_comm_ON_Main, PQ_IP_MWE_diff_no_comm_Main);
9683 #else
9684 UNUSED(eWindow);
9685 #endif
9686 }
MDrv_PQ_MWE_CloneWindow(PQ_WIN eWindow)9687 void MDrv_PQ_MWE_CloneWindow(PQ_WIN eWindow)
9688 {
9689 #ifdef TRACE_DBG
9690 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9691 #endif
9692 if (pu32PQInst == NULL)
9693 {
9694 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9695 return ;
9696 }
9697
9698 stPQ_MWE_CloneWindow PQArgs;
9699 PQArgs.eWindow = eWindow;
9700 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_MWE_CLONE_WINDOW, (void*)&PQArgs) != 0)
9701 {
9702 printf("Obtain PQ engine fail\n");
9703 return;
9704 }
9705 else
9706 {
9707 return;
9708 }
9709 }
9710
MDrv_PQ_3D_SettingForLBL_U2(void * pInstance,PQ_WIN eWindow)9711 MS_BOOL MDrv_PQ_3D_SettingForLBL_U2(void* pInstance,PQ_WIN eWindow)
9712 {
9713 #if PQ_QM_3D_CLONE_ENABLE
9714 MDrv_PQ_LoadTable_U2(pInstance,eWindow, PQ_IP_3DSettingForLBL_no_comm_ON_Main, PQ_IP_3DSettingForLBL_no_comm_Main);
9715 return TRUE;
9716 #else
9717 UNUSED(eWindow);
9718 return FALSE;
9719 #endif
9720 }
MDrv_PQ_3D_SettingForLBL(PQ_WIN eWindow)9721 MS_BOOL MDrv_PQ_3D_SettingForLBL(PQ_WIN eWindow)
9722 {
9723 #ifdef TRACE_DBG
9724 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9725 #endif
9726 if (pu32PQInst == NULL)
9727 {
9728 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9729 return FALSE;
9730 }
9731
9732 stPQ_3D_SettingForLBL PQArgs;
9733 PQArgs.eWindow = eWindow;
9734 PQArgs.bReturnValue = FALSE;
9735 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_3D_SETTING_FOR_LBL, (void*)&PQArgs) != 0)
9736 {
9737 printf("Obtain PQ engine fail\n");
9738 return FALSE;
9739 }
9740 else
9741 {
9742 return PQArgs.bReturnValue;
9743 }
9744 }
9745
MDrv_PQ_3D_CloneWindow_U2(void * pInstance,PQ_3DTYPE enPQ3DType,PQ_WIN eWindow)9746 void MDrv_PQ_3D_CloneWindow_U2(void* pInstance,PQ_3DTYPE enPQ3DType, PQ_WIN eWindow)
9747 {
9748 #if PQ_QM_3D_CLONE_ENABLE
9749 if(E_PQ_3DTYPE_XC == enPQ3DType)
9750 {
9751 MDrv_PQ_CloneTable(eWindow, PQ_IP_Clone_main_no_comm_OFF_Main, PQ_IP_Clone_main_no_comm_Main, PQ_IP_Clone_sub_no_comm_Main);
9752 if(((MApi_XC_Get_3D_HW_Version() >= 2) && (E_XC_3D_OUTPUT_LINE_ALTERNATIVE == MApi_XC_Get_3D_Output_Mode()))
9753 || ((MApi_XC_Get_3D_HW_Version() < 2) && (E_XC_3D_OUTPUT_TOP_BOTTOM == MApi_XC_Get_3D_Output_Mode())
9754 && MApi_XC_3D_Is_LR_Sbs2Line()))
9755 {
9756 MDrv_PQ_3D_SettingForLBL(eWindow);
9757 }
9758 }
9759 else
9760 {
9761 printf("[%s %d]Attention: not support clone this PQ 3D type:%u from qmap!\n", __FILE__, (int)__LINE__, enPQ3DType);
9762 }
9763 #else
9764 UNUSED(enPQ3DType);
9765 UNUSED(eWindow);
9766 #endif
9767 }
MDrv_PQ_3D_CloneWindow(PQ_3DTYPE enPQ3DType,PQ_WIN eWindow)9768 void MDrv_PQ_3D_CloneWindow(PQ_3DTYPE enPQ3DType, PQ_WIN eWindow)
9769 {
9770 #ifdef TRACE_DBG
9771 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9772 #endif
9773 if (pu32PQInst == NULL)
9774 {
9775 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9776 return ;
9777 }
9778
9779 stPQ_3D_CloneWindow PQArgs;
9780 PQArgs.enPQ3DType = enPQ3DType;
9781 PQArgs.eWindow = eWindow;
9782 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_3D_CLONE_WINDOW, (void*)&PQArgs) != 0)
9783 {
9784 printf("Obtain PQ engine fail\n");
9785 return;
9786 }
9787 else
9788 {
9789 return;
9790 }
9791 }
9792
MDrv_PQ_Get_SensioMode_U2(void * pInstance)9793 MS_BOOL MDrv_PQ_Get_SensioMode_U2(void* pInstance)
9794 {
9795 return _bSensioMode;
9796 }
MDrv_PQ_Get_SensioMode(void)9797 MS_BOOL MDrv_PQ_Get_SensioMode(void)
9798 {
9799 #ifdef TRACE_DBG
9800 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9801 #endif
9802 if (pu32PQInst == NULL)
9803 {
9804 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9805 return FALSE;
9806 }
9807
9808 stPQ_Get_SensioMode PQArgs;
9809 PQArgs.bReturnValue = FALSE;
9810 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_SENSIOMODE, (void*)&PQArgs) != 0)
9811 {
9812 printf("Obtain PQ engine fail\n");
9813 return FALSE;
9814 }
9815 else
9816 {
9817 return PQArgs.bReturnValue;
9818 }
9819 }
9820
MDrv_PQ_Set_SensioMode_U2(void * pInstance,MS_BOOL bEnable)9821 void MDrv_PQ_Set_SensioMode_U2(void* pInstance,MS_BOOL bEnable)
9822 {
9823 _bSensioMode= bEnable;
9824 }
MDrv_PQ_Set_SensioMode(MS_BOOL bEnable)9825 void MDrv_PQ_Set_SensioMode(MS_BOOL bEnable)
9826 {
9827 #ifdef TRACE_DBG
9828 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9829 #endif
9830 if (pu32PQInst == NULL)
9831 {
9832 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9833 return ;
9834 }
9835
9836 stPQ_Set_SensioMode PQArgs;
9837 PQArgs.bEnable = bEnable;
9838 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_SENSIOMODE, (void*)&PQArgs) != 0)
9839 {
9840 printf("Obtain PQ engine fail\n");
9841 return;
9842 }
9843 else
9844 {
9845 return;
9846 }
9847 }
9848
9849 #ifndef MirrorYpbpr1080iNoiseReduce
9850 #define MirrorYpbpr1080iNoiseReduce 0
9851 #endif
9852
MDrv_PQ_Set_DIPF_U2(void * pInstance)9853 void MDrv_PQ_Set_DIPF_U2(void* pInstance)
9854 {
9855 #if MirrorYpbpr1080iNoiseReduce
9856 if(MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW) != MIRROR_NORMAL)
9857 {
9858 //Mirror
9859 MApi_XC_W2BYTEMSK(REG_SC_BK22_20_L, (MS_U16)0x0800, 0x0800 );
9860 }
9861 else
9862 {
9863 //Non_Mirror
9864 MApi_XC_W2BYTEMSK(REG_SC_BK22_20_L, (MS_U16)0x0000, 0x0800 );
9865 }
9866 #endif
9867 }
MDrv_PQ_Set_DIPF(void)9868 void MDrv_PQ_Set_DIPF(void)
9869 {
9870 #ifdef TRACE_DBG
9871 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9872 #endif
9873 if (pu32PQInst == NULL)
9874 {
9875 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9876 return ;
9877 }
9878
9879 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_DIPF, NULL) != 0)
9880 {
9881 printf("Obtain PQ engine fail\n");
9882 return;
9883 }
9884 else
9885 {
9886 return;
9887 }
9888 }
9889
MDrv_PQ_SetSelectCSC_U2(void * pInstance,MS_U16 u16selection,PQ_WIN eWindow)9890 void MDrv_PQ_SetSelectCSC_U2(void* pInstance,MS_U16 u16selection, PQ_WIN eWindow)
9891 {
9892 HAL_PQ_set_SelectCSC(pInstance,u16selection, (eWindow == PQ_MAIN_WINDOW ? TRUE : FALSE));
9893 }
MDrv_PQ_SetSelectCSC(MS_U16 u16selection,PQ_WIN eWindow)9894 void MDrv_PQ_SetSelectCSC(MS_U16 u16selection, PQ_WIN eWindow)
9895 {
9896 #ifdef TRACE_DBG
9897 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9898 #endif
9899 if (pu32PQInst == NULL)
9900 {
9901 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9902 return ;
9903 }
9904
9905 stPQ_SetSelectCSC PQArgs;
9906 PQArgs.u16selection = u16selection;
9907 PQArgs.eWindow = eWindow;
9908 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_SELECT_CSC, (void*)&PQArgs) != 0)
9909 {
9910 printf("Obtain PQ engine fail\n");
9911 return;
9912 }
9913 else
9914 {
9915 return;
9916 }
9917 }
9918
MDrv_PQ_GetR2YEqSelect_U2(void * pInstance,PQ_WIN eWindow)9919 MS_BOOL MDrv_PQ_GetR2YEqSelect_U2(void* pInstance,PQ_WIN eWindow)
9920 {
9921 #if (Y2Y_709_601_VERSION == 0)
9922 if(PQ_MAIN_WINDOW == eWindow)
9923 {
9924 return ((MApi_XC_R2BYTEMSK(REG_SC_BK18_6F_L, BIT(2)) == 0)? FALSE : TRUE);
9925 }
9926 else
9927 {
9928 return ((MApi_XC_R2BYTEMSK(REG_SC_BK18_6F_L, BIT(6)) == 0)? FALSE : TRUE);
9929 }
9930 #elif (Y2Y_709_601_VERSION == 1)
9931
9932 MS_BOOL bIs709to601 = FALSE;
9933 if(PQ_MAIN_WINDOW == eWindow)
9934 {
9935 if ((MApi_XC_R2BYTEMSK(REG_SC_BK18_06_L, 0x0001) == 0x0001) &&
9936 (MApi_XC_R2BYTEMSK(REG_SC_BK18_0A_L, 0x00F0) == 0x00C0))
9937 {
9938 bIs709to601 = TRUE;
9939 }
9940 }
9941 else
9942 {
9943 if ((MApi_XC_R2BYTEMSK(REG_SC_BK18_76_L, 0x0001) == 0x0001) &&
9944 (MApi_XC_R2BYTEMSK(REG_SC_BK18_7A_L, 0x00F0) == 0x00C0))
9945 {
9946 bIs709to601 = TRUE;
9947 }
9948 }
9949 return bIs709to601;
9950
9951 #endif
9952 }
MDrv_PQ_GetR2YEqSelect(PQ_WIN eWindow)9953 MS_BOOL MDrv_PQ_GetR2YEqSelect(PQ_WIN eWindow)
9954 {
9955 #ifdef TRACE_DBG
9956 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
9957 #endif
9958 if (pu32PQInst == NULL)
9959 {
9960 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
9961 return FALSE;
9962 }
9963
9964 stPQ_GetR2YEqSelect PQArgs;
9965 PQArgs.eWindow = eWindow;
9966 PQArgs.bReturnValue = FALSE;
9967 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_R2YEQ_SELECT, (void*)&PQArgs) != 0)
9968 {
9969 printf("Obtain PQ engine fail\n");
9970 return FALSE;
9971 }
9972 else
9973 {
9974 return PQArgs.bReturnValue;
9975 }
9976 }
9977
MDrv_PQ_GetMemFmtInGeneral_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bMemFmt422,MS_U16 * pu16TabIdx_MemFormat,MS_U16 * pu16TabIdx_444To422,MS_U16 * pu16TabIdx_422To444)9978 MS_BOOL MDrv_PQ_GetMemFmtInGeneral_U2(void* pInstance,
9979 PQ_WIN eWindow,
9980 MS_BOOL bMemFmt422,
9981 MS_U16 *pu16TabIdx_MemFormat,
9982 MS_U16 *pu16TabIdx_444To422,
9983 MS_U16 *pu16TabIdx_422To444
9984 )
9985 {
9986 if(bMemFmt422)
9987 {
9988 if(eWindow == PQ_MAIN_WINDOW)
9989 {
9990 *pu16TabIdx_MemFormat = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_MemFormat_Main);
9991
9992 if ( _upLayerConfig & E_PQ_MISC_A_HDMITX_ENABLE )
9993 *pu16TabIdx_444To422 = PQ_IP_444To422_OFF_Main;
9994 else
9995 *pu16TabIdx_444To422 = PQ_IP_444To422_ON_Main;
9996
9997 #if PQ_HAL_EWINDOW_PARAM
9998 *pu16TabIdx_422To444 = Hal_PQ_get_422To444_idx(pInstance,(MS_422To444_TYPE)Hal_PQ_get_422To444_mode(pInstance,bMemFmt422), PQ_MAIN_WINDOW);
9999 #else
10000 *pu16TabIdx_422To444 = Hal_PQ_get_422To444_idx(pInstance,(MS_422To444_TYPE)Hal_PQ_get_422To444_mode(pInstance,bMemFmt422));
10001 #endif
10002 }
10003 #if PQ_ENABLE_PIP
10004 else
10005 {
10006 *pu16TabIdx_MemFormat = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_MemFormat_Sub);
10007
10008 if ( _upLayerConfig & E_PQ_MISC_A_HDMITX_ENABLE )
10009 *pu16TabIdx_444To422 = PQ_IP_444To422_OFF_Sub;
10010 else
10011 *pu16TabIdx_444To422 = PQ_IP_444To422_ON_Sub;
10012
10013 #if PQ_HAL_EWINDOW_PARAM
10014 *pu16TabIdx_422To444 = Hal_PQ_get_422To444_idx(pInstance,(MS_422To444_TYPE)Hal_PQ_get_422To444_mode(pInstance,bMemFmt422), PQ_SUB_WINDOW);
10015 #else
10016 *pu16TabIdx_422To444 = Hal_PQ_get_422To444_idx(pInstance,(MS_422To444_TYPE)Hal_PQ_get_422To444_mode(pInstance,bMemFmt422));
10017 #endif
10018 }
10019 #endif
10020 }
10021 else
10022 {
10023 // use 444_10BIT mode only if < 1440x1080
10024 // frame buffer 1920x1080x3x2 == 1440x1080x4x2
10025 // also bandwidth not enough for 1920x1080 444_10BIT
10026 if(eWindow == PQ_MAIN_WINDOW)
10027 {
10028 *pu16TabIdx_MemFormat = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_MemFormat_Main);
10029 *pu16TabIdx_444To422 = PQ_IP_444To422_OFF_Main;
10030 #if PQ_HAL_EWINDOW_PARAM
10031 *pu16TabIdx_422To444 = Hal_PQ_get_422To444_idx(pInstance,(MS_422To444_TYPE)Hal_PQ_get_422To444_mode(pInstance,bMemFmt422), PQ_MAIN_WINDOW);
10032 #else
10033 *pu16TabIdx_422To444 = Hal_PQ_get_422To444_idx(pInstance,(MS_422To444_TYPE)Hal_PQ_get_422To444_mode(pInstance,bMemFmt422));
10034 #endif
10035 }
10036 #if PQ_ENABLE_PIP
10037 else
10038 {
10039 *pu16TabIdx_MemFormat = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_MemFormat_Sub);
10040 *pu16TabIdx_444To422 = PQ_IP_444To422_OFF_Sub;
10041 #if PQ_HAL_EWINDOW_PARAM
10042 *pu16TabIdx_422To444 = Hal_PQ_get_422To444_idx(pInstance,(MS_422To444_TYPE)Hal_PQ_get_422To444_mode(pInstance,bMemFmt422), PQ_SUB_WINDOW);
10043 #else
10044 *pu16TabIdx_422To444 = Hal_PQ_get_422To444_idx(pInstance,(MS_422To444_TYPE)Hal_PQ_get_422To444_mode(pInstance,bMemFmt422));
10045 #endif
10046 }
10047 #endif
10048 }
10049
10050 return TRUE;
10051 }
MDrv_PQ_GetMemFmtInGeneral(PQ_WIN eWindow,MS_BOOL bMemFmt422,MS_U16 * pu16TabIdx_MemFormat,MS_U16 * pu16TabIdx_444To422,MS_U16 * pu16TabIdx_422To444)10052 MS_BOOL MDrv_PQ_GetMemFmtInGeneral(PQ_WIN eWindow,
10053 MS_BOOL bMemFmt422,
10054 MS_U16 *pu16TabIdx_MemFormat,
10055 MS_U16 *pu16TabIdx_444To422,
10056 MS_U16 *pu16TabIdx_422To444
10057 )
10058 {
10059 #ifdef TRACE_DBG
10060 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
10061 #endif
10062 if (pu32PQInst == NULL)
10063 {
10064 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
10065 return FALSE;
10066 }
10067
10068 stPQ_GetMemFmtInGeneral PQArgs;
10069 PQArgs.eWindow = eWindow;
10070 PQArgs.bMemFmt422 = bMemFmt422;
10071 PQArgs.pu16TabIdx_MemFormat = pu16TabIdx_MemFormat;
10072 PQArgs.pu16TabIdx_444To422 = pu16TabIdx_444To422;
10073 PQArgs.pu16TabIdx_422To444 = pu16TabIdx_422To444;
10074 PQArgs.bReturnValue = FALSE;
10075 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_MEMFMT_IN_GENERAL, (void*)&PQArgs) != 0)
10076 {
10077 printf("Obtain PQ engine fail\n");
10078 return FALSE;
10079 }
10080 else
10081 {
10082 return PQArgs.bReturnValue;
10083 }
10084 }
10085
10086
MDrv_PQ_GetMADiForRFBL_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bFBL,MS_U16 * pu16TabIdx_MADi_Motion,MS_U16 * pu16TabIdx_MADi)10087 MS_BOOL MDrv_PQ_GetMADiForRFBL_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bFBL, MS_U16 *pu16TabIdx_MADi_Motion, MS_U16 *pu16TabIdx_MADi)
10088 {
10089 UNUSED(pu16TabIdx_MADi_Motion);
10090 if((_stRFBL_Info.bEnable)&&(!bFBL))
10091 {
10092 *pu16TabIdx_MADi = Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, (MS_MADI_TYPE)_stRFBL_Info.u8MADiType);
10093 if(!_stMode_Info[eWindow].bInterlace)
10094 {
10095 *pu16TabIdx_MADi = Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE8_NO_MIU);
10096
10097 if(eWindow == PQ_MAIN_WINDOW)
10098 {
10099 MDrv_PQ_MADiForceMotionY_U2(pInstance,PQ_MAIN_WINDOW, FALSE);
10100 MDrv_PQ_MADiForceMotionC_U2(pInstance,PQ_MAIN_WINDOW, FALSE);
10101 }
10102 else
10103 {
10104 MDrv_PQ_MADiForceMotionY_U2(pInstance,PQ_SUB_WINDOW, FALSE);
10105 MDrv_PQ_MADiForceMotionC_U2(pInstance,PQ_SUB_WINDOW, FALSE);
10106 }
10107 //printf("[%s]-[%d] : disable Y/C motion\n", __FUNCTION__, __LINE__);
10108 }
10109 //printf("[%s]-[%d] : u16TabIdx_MADi = %d\n",__FUNCTION__,__LINE__,u16TabIdx_MADi);
10110 }
10111
10112 return TRUE;
10113 }
MDrv_PQ_GetMADiForRFBL(PQ_WIN eWindow,MS_BOOL bFBL,MS_U16 * pu16TabIdx_MADi_Motion,MS_U16 * pu16TabIdx_MADi)10114 MS_BOOL MDrv_PQ_GetMADiForRFBL(PQ_WIN eWindow, MS_BOOL bFBL, MS_U16 *pu16TabIdx_MADi_Motion, MS_U16 *pu16TabIdx_MADi)
10115 {
10116 #ifdef TRACE_DBG
10117 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
10118 #endif
10119 if (pu32PQInst == NULL)
10120 {
10121 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
10122 return FALSE;
10123 }
10124
10125 stPQ_GetMADiForRFBL PQArgs;
10126 PQArgs.eWindow = eWindow;
10127 PQArgs.bFBL = bFBL;
10128 PQArgs.pu16TabIdx_MADi_Motion = pu16TabIdx_MADi_Motion;
10129 PQArgs.pu16TabIdx_MADi = pu16TabIdx_MADi;
10130 PQArgs.bReturnValue = FALSE;
10131 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_MADI_FOR_RFBL, (void*)&PQArgs) != 0)
10132 {
10133 printf("Obtain PQ engine fail\n");
10134 return FALSE;
10135 }
10136 else
10137 {
10138 return PQArgs.bReturnValue;
10139 }
10140 }
10141
MDrv_PQ_Patch2Rto4RForFieldPackingMode_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16TabIdx_MADi)10142 MS_BOOL MDrv_PQ_Patch2Rto4RForFieldPackingMode_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16TabIdx_MADi)
10143 {
10144 #if PQ_GRULE_OSD_BW_ENABLE
10145 // Patch: in OSD turn off case, when 2R-->4R, J2, M10 with new OPM system will flash(4R-->2R is OK)
10146 // we need to set 4R first, and wait some time, and do other MAdi setting, the flash will be ok.
10147 // which is only for non-OS platform patch, since OS platform won't turn off OSD for DFB system.
10148 // Only FieldPackingMode need this solution
10149 if(eWindow == PQ_MAIN_WINDOW)
10150 {
10151 if((MApi_XC_IsFieldPackingModeSupported() &&
10152 (_stMode_Info[eWindow].u16input_hsize>=1280)&&
10153 (_stMode_Info[eWindow].u16input_vsize>=720) &&
10154 (!_bOSD_On)) &&
10155 ( (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,TRUE, MS_MADI_24_4R))
10156 || (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,TRUE, MS_MADI_25_4R))
10157 || (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,TRUE, MS_MADI_26_4R))
10158 || (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,TRUE, MS_MADI_27_4R))
10159 #if PQ_MADI_88X_MODE
10160 || (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,TRUE, MS_MADI_24_4R_880))
10161 || (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,TRUE, MS_MADI_25_4R_880))
10162 || (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,TRUE, MS_MADI_25_4R_884))
10163 #endif
10164 ))
10165 {
10166 //set to 4R first,
10167 MApi_XC_W2BYTEMSK(REG_SC_BK12_03_L, 0 , 0x0002 );
10168 //delay
10169 MApi_XC_WaitOutputVSync(1, 90, MAIN_WINDOW);
10170 }
10171 }
10172 #else
10173 UNUSED(eWindow);
10174 UNUSED(u16TabIdx_MADi);
10175 #endif
10176 return TRUE;
10177 }
MDrv_PQ_Patch2Rto4RForFieldPackingMode(PQ_WIN eWindow,MS_U16 u16TabIdx_MADi)10178 MS_BOOL MDrv_PQ_Patch2Rto4RForFieldPackingMode(PQ_WIN eWindow, MS_U16 u16TabIdx_MADi)
10179 {
10180 #ifdef TRACE_DBG
10181 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
10182 #endif
10183 if (pu32PQInst == NULL)
10184 {
10185 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
10186 return FALSE;
10187 }
10188
10189 stPQ_Patch2Rto4RForFieldPackingMode PQArgs;
10190 PQArgs.eWindow = eWindow;
10191 PQArgs.u16TabIdx_MADi = u16TabIdx_MADi;
10192 PQArgs.bReturnValue = FALSE;
10193 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_PATCH2RTO4R_FOR_FIELDPACKINGMODE, (void*)&PQArgs) != 0)
10194 {
10195 printf("Obtain PQ engine fail\n");
10196 return FALSE;
10197 }
10198 else
10199 {
10200 return PQArgs.bReturnValue;
10201 }
10202 }
10203
_MDrv_PQ_EnableRequest_FrameBufferLess(MS_BOOL bEnable,PQ_WIN eWindow)10204 static void _MDrv_PQ_EnableRequest_FrameBufferLess(MS_BOOL bEnable, PQ_WIN eWindow)
10205 {
10206 if (eWindow == PQ_MAIN_WINDOW)
10207 {
10208 MApi_XC_EnableRequest_FrameBufferLess(bEnable);
10209 }
10210 else
10211 {
10212 PQMADi_DBG(printf("%s %d, sub have no FLB mode!\n",__FUNCTION__,__LINE__));
10213 }
10214 }
10215
MDrv_PQ_SetFrameBuffMode(MS_BOOL bFrameBuffLess)10216 void MDrv_PQ_SetFrameBuffMode(MS_BOOL bFrameBuffLess)
10217 {
10218 stPQ_SetFrameBuffMode PQArgs;
10219
10220 if (pu32PQInst == NULL)
10221 {
10222 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
10223 return FALSE;
10224 }
10225
10226 PQArgs.bFrameBuffLess = bFrameBuffLess;
10227 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_FRAMEBUFF_MODE, (void*)&PQArgs) != 0)
10228 {
10229 printf("Obtain PQ engine fail\n");
10230 return;
10231 }
10232 else
10233 {
10234 return;
10235 }
10236 }
MDrv_PQ_SetFrameBuffMode_U2(void * pInstance,MS_BOOL bFrameBuffLess)10237 void MDrv_PQ_SetFrameBuffMode_U2(void* pInstance,MS_BOOL bFrameBuffLess)
10238 {
10239 _bFrameBuffLess = bFrameBuffLess;
10240 }
MDrv_PQ_GetBPPInfoFromMADi_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bMemFmt422,MS_U16 u16TabIdx_MADi,MS_U16 u16TabIdx_MemFormat,MS_U8 * pu8BitsPerPixel,PQ_DEINTERLACE_MODE * peDeInterlaceMode,MS_U8 * pu8FrameCount)10241 MS_BOOL MDrv_PQ_GetBPPInfoFromMADi_U2(void* pInstance,
10242 PQ_WIN eWindow,
10243 MS_BOOL bMemFmt422,
10244 MS_U16 u16TabIdx_MADi,
10245 MS_U16 u16TabIdx_MemFormat,
10246 MS_U8 *pu8BitsPerPixel,
10247 PQ_DEINTERLACE_MODE *peDeInterlaceMode,
10248 MS_U8 *pu8FrameCount
10249 )
10250 {
10251 _u16PQDelyaTime= 0;
10252
10253 MApi_XC_EnableRequest_FrameBufferLess(_bFrameBuffLess);
10254 PQMADi_DBG(printf("[PQ] MADI: DISABLE RFBL\n"));
10255
10256 if(bMemFmt422)
10257 {
10258 // decide bits/pixel and deinterlace mode flag
10259 if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_24_4R))
10260 {
10261 *pu8BitsPerPixel = 20;
10262 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10263 u8PQDelayCount = 3;
10264 PQMADi_DBG(printf("24_4R PQ_DEINT_3DDI_HISTORY \n"));
10265 }
10266 else if( (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_24_2R)) ||
10267 (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_24_2R_880)))
10268 {
10269 *pu8BitsPerPixel = 20;
10270 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10271 u8PQDelayCount = 3;
10272 PQMADi_DBG(printf("24_2R PQ_DEINT_3DDI_HISTORY\n"));
10273 }
10274 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_4R))
10275 {
10276 *pu8BitsPerPixel = 24;
10277 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10278 u8PQDelayCount = 3;
10279 PQMADi_DBG(printf("25 4R PQ_DEINT_3DDI_HISTORY\n"));
10280 }
10281 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_25_4R_720i_Main))
10282 {
10283 *pu8BitsPerPixel = 24;
10284 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10285 u8PQDelayCount = 3;
10286 PQMADi_DBG(printf("25 4R 720i PQ_DEINT_3DDI_HISTORY\n"));
10287 }
10288 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_4R_MC))
10289 {
10290 *pu8BitsPerPixel = 24;
10291 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10292 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10293 u8PQDelayCount = 3;
10294 PQMADi_DBG(printf("25 4R MC_PQ_DEINT_3DDI_HISTORY\n"));
10295
10296 if(MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW) != MIRROR_NORMAL)
10297 {
10298 printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
10299 printf("!!Error: Cannot set MS_MADI_25_4R_MC(4 fields mode) for Mirror(at least 6 fields). Fix your PQ excel!!\n");
10300 printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
10301 }
10302 }
10303 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_25_4R_M_MC))
10304 {
10305 *pu8BitsPerPixel = 24;
10306 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10307 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10308 u8PQDelayCount = 3;
10309 PQMADi_DBG(printf("25 4R M MC_PQ_DEINT_3DDI_HISTORY\n"));
10310 MirrorMode_t enVideoMirror = MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW);
10311 if((enVideoMirror == MIRROR_HV) || (enVideoMirror == MIRROR_V_ONLY))
10312 {
10313 printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
10314 printf("!!Error: Cannot set MS_MADi_25_4R_M_MC(4 fields mode) for Mirror(at least 6 fields). Fix your PQ excel!!\n");
10315 printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
10316 }
10317 }
10318 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_25_6F_4R_MC))
10319 {
10320 *pu8BitsPerPixel = 24;
10321 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10322 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10323 u8PQDelayCount = 3;
10324 *pu8FrameCount = 6;
10325 PQMADi_DBG(printf("25 6F 4R MC_PQ_DEINT_3DDI_HISTORY\n"));
10326
10327 }
10328 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_6R_MC))
10329 {
10330 *pu8BitsPerPixel = 24;
10331 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10332 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10333 *pu8FrameCount = 8;
10334 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10335 PQMADi_DBG(printf("25 6R MC_PQ_DEINT_3DDI_HISTORY\n"));
10336 }
10337 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_14F_6R_MC)) //Add New MADi mode
10338 {
10339 *pu8BitsPerPixel = 24;
10340 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10341 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10342 *pu8FrameCount = 14;
10343 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10344 PQMADi_DBG(printf("25 14F 6R MC_PQ_DEINT_3DDI_HISTORY\n"));
10345 }
10346 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_14F_8R_MC))
10347 {
10348 *pu8BitsPerPixel = 24;
10349 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10350 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10351 *pu8FrameCount = 14;
10352 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10353 PQMADi_DBG(printf("25 14F 8R MC_PQ_DEINT_3DDI_HISTORY\n"));
10354 }
10355 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_12F_8R_MC))
10356 {
10357 *pu8BitsPerPixel = 24;
10358 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10359 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10360 *pu8FrameCount = 12;
10361 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10362 PQMADi_DBG(printf("25 12F 8R MC_PQ_DEINT_3DDI_HISTORY\n"));
10363 }
10364 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_16F_8R_MC))
10365 {
10366 *pu8BitsPerPixel = 24;
10367 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10368 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10369 *pu8FrameCount = 16;
10370 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10371 PQMADi_DBG(printf("25 16F 8R MC_PQ_DEINT_3DDI_HISTORY\n"));
10372 }
10373 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_16F_6R_MC))
10374 {
10375 *pu8BitsPerPixel = 24;
10376 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10377 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10378 *pu8FrameCount = 16;
10379 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10380 PQMADi_DBG(printf("25 16F 6R MC_PQ_DEINT_3DDI_HISTORY\n"));
10381 }
10382 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_25_16F_8R_M_MC))
10383 {
10384 *pu8BitsPerPixel = 24;
10385 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10386 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10387 *pu8FrameCount = 16;
10388 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10389 PQMADi_DBG(printf("25 16F 8R M MC_PQ_DEINT_3DDI_HISTORY\n"));
10390 }
10391 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_6R_MC_NW))
10392 {
10393 *pu8BitsPerPixel = 24;
10394 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10395 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10396 *pu8FrameCount = 8;
10397 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10398 PQMADi_DBG(printf("25 6R MC_PQ_DEINT_3DDI_HISTORY\n"));
10399 }
10400 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_6R_FilmPreDet))
10401 {
10402 *pu8BitsPerPixel = 24;
10403 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10404 *pu8FrameCount = 8;
10405 u8PQDelayCount = 3;
10406 PQMADi_DBG(printf("25 6R FilmPreDet_PQ_DEINT_3DDI_HISTORY\n"));
10407 }
10408 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_6R_FilmPreDet_PAL))
10409 {
10410 *pu8BitsPerPixel = 24;
10411 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10412 *pu8FrameCount = 8;
10413 u8PQDelayCount = 3;
10414 PQMADi_DBG(printf("25 6R FilmPreDet PAL_PQ_DEINT_3DDI_HISTORY\n"));
10415 }
10416 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_24_6R_FilmPreDet))
10417 {
10418 *pu8BitsPerPixel = 20;
10419 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10420 *pu8FrameCount = 8;
10421 u8PQDelayCount = 3;
10422 PQMADi_DBG(printf("24 6R FilmPreDet_PQ_DEINT_3DDI_HISTORY\n"));
10423 }
10424 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_24_6R_FilmPreDet_PAL))
10425 {
10426 *pu8BitsPerPixel = 20;
10427 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10428 *pu8FrameCount = 8;
10429 u8PQDelayCount = 3;
10430 PQMADi_DBG(printf("24 6R FilmPreDet PAL_PQ_DEINT_3DDI_HISTORY\n"));
10431 }
10432 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_8F_4R_MC))
10433 {
10434 *pu8BitsPerPixel = 24;
10435 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10436 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10437 *pu8FrameCount = 8;
10438 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10439 PQMADi_DBG(printf("25 8F 4R MC_PQ_DEINT_3DDI_HISTORY\n"));
10440 }
10441 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_25_8F_8R_MC))
10442 {
10443 *pu8BitsPerPixel = 24;
10444 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10445 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10446 *pu8FrameCount = 8;
10447 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10448 PQMADi_DBG(printf("25 8F 8R MC_PQ_DEINT_3DDI_HISTORY\n"));
10449 }
10450 #if PQ_ENABLE_RFBL
10451 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_RFBL_2D)) // Need to ReDefine
10452 {
10453 *pu8BitsPerPixel = 24;
10454 u8PQDelayCount = 3;
10455 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10456 MApi_XC_EnableRequest_FrameBufferLess(ENABLE);
10457 PQMADi_DBG(printf("[PQ] MADI: ENABLE RFBL: MS_MADI_RFBL_2D\n"));
10458 }
10459 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_RFBL_25D)) // Need to ReDefine
10460 {
10461 *pu8BitsPerPixel = 24;
10462 u8PQDelayCount = 3;
10463 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10464 MApi_XC_EnableRequest_FrameBufferLess(ENABLE);
10465 PQMADi_DBG(printf("[PQ] MADI: ENABLE RFBL: MS_MADI_RFBL_25D\n"));
10466 }
10467 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_RFBL_3D)) // Need to ReDefine
10468 {
10469 *pu8BitsPerPixel = 24;
10470 u8PQDelayCount = 3;
10471 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10472 MApi_XC_EnableRequest_FrameBufferLess(ENABLE);
10473 PQMADi_DBG(printf("[PQ] MADI: ENABLE RFBL: MS_MADI_RFBL_3D\n"));
10474 }
10475 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_RFBL_P_MODE8_MOT)) // Need to ReDefine
10476 {
10477 *pu8BitsPerPixel = 24;
10478 u8PQDelayCount = 3;
10479 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10480 _MDrv_PQ_EnableRequest_FrameBufferLess(ENABLE, eWindow);
10481 PQMADi_DBG(printf("[PQ] MADI: ENABLE RFBL: MS_MADI_RFBL_P_MODE8_MOT\n"));
10482 }
10483 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_RFBL_P_MODE10_MOT)) // Need to ReDefine
10484 {
10485 *pu8BitsPerPixel = 24;
10486 u8PQDelayCount = 3;
10487 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10488 _MDrv_PQ_EnableRequest_FrameBufferLess(ENABLE, eWindow);
10489 PQMADi_DBG(printf("[PQ] MADI: ENABLE RFBL: MS_MADI_RFBL_P_MODE10_MOT\n"));
10490 }
10491 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_RFBL_3D_YC))
10492 {
10493 *pu8BitsPerPixel = 24;
10494 u8PQDelayCount = 3;
10495 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10496 MApi_XC_EnableRequest_FrameBufferLess(ENABLE);
10497 PQMADi_DBG(printf("[PQ] MADI: ENABLE RFBL: MS_MADI_RFBL_3D_YC\n"));
10498 }
10499 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_RFBL_3D_FILM))
10500 {
10501 *pu8BitsPerPixel = 24;
10502 u8PQDelayCount = 3;
10503 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10504 MApi_XC_EnableRequest_FrameBufferLess(ENABLE);
10505 PQMADi_DBG(printf("[PQ] MADI: ENABLE RFBL: MS_MADI_RFBL_3D_FILM\n"));
10506 }
10507 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_RFBL_MC))
10508 {
10509 *pu8BitsPerPixel = 24;
10510 u8PQDelayCount = 6;
10511 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10512 MApi_XC_EnableRequest_FrameBufferLess(ENABLE);
10513 PQMADi_DBG(printf("[PQ] MADI: ENABLE RFBL: MS_MADI_RFBL_MC\n"));
10514 }
10515 #endif
10516 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_2R))
10517 {
10518 *pu8BitsPerPixel = 24;
10519 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10520 u8PQDelayCount = 3;
10521 PQMADi_DBG(printf("25 2 PQ_DEINT_3DDI_HISTORY\n"));
10522 }
10523 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_26_4R))
10524 {
10525 *pu8BitsPerPixel = 20;
10526 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10527 u8PQDelayCount = 3;
10528 PQMADi_DBG(printf("26 4 PQ_DEINT_3DDI_HISTORY\n"));
10529 }
10530 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_26_2R))
10531 {
10532 *pu8BitsPerPixel = 20;
10533 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10534 u8PQDelayCount = 3;
10535 PQMADi_DBG(printf("26 2 PQ_DEINT_3DDI_HISTORY\n"));
10536 }
10537 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_27_4R))
10538 {
10539 *pu8BitsPerPixel = 16;
10540 *peDeInterlaceMode = PQ_DEINT_3DDI;
10541 u8PQDelayCount = 3;
10542 PQMADi_DBG(printf("27 4 PQ_DEINT_3DDI\n"));
10543 }
10544 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_27_2R))
10545 {
10546 *pu8BitsPerPixel = 16;
10547 *peDeInterlaceMode = PQ_DEINT_3DDI;
10548 u8PQDelayCount = 3;
10549 PQMADi_DBG(printf("27 2 PQ_DEINT_3DDI\n"));
10550 }
10551 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE8))
10552 {
10553 *pu8BitsPerPixel = 16;
10554 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10555 u8PQDelayCount = 2;
10556 PQMADi_DBG(printf("P 8 PQ_DEINT_2DDI_BOB\n"));
10557
10558 if ( _upLayerConfig & E_PQ_MISC_A_HDMITX_ENABLE )
10559 {
10560 // HDMITX uses freerun
10561 // and when in some special case like 29.97fps in, 30fps out
10562 // sometimes we can see tearing because it is not locked yet.
10563 // so at least 3 frames is needed.
10564 *pu8FrameCount = 3;
10565 }else
10566 {
10567 if(MApi_XC_GetIPAutoNoSignal((SCALER_WIN)eWindow)==ENABLE)
10568 {
10569 *pu8FrameCount = 3;
10570 }
10571 else
10572 {
10573 *pu8FrameCount = 2;
10574 }
10575 }
10576 }
10577 #if (PQ_P_MODE8_3FRAME_MODE_ENABLE == 1)
10578 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx((eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE8_3Frame))
10579 {
10580 *pu8BitsPerPixel = 16;
10581 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10582 u8PQDelayCount = 3;
10583 PQMADi_DBG(printf("P 8 PQ_DEINT_2DDI_BOB\n"));
10584 *pu8FrameCount = 3;
10585 }
10586 #endif
10587 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE10))
10588 {
10589 *pu8BitsPerPixel = 20;
10590 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10591 u8PQDelayCount = 2;
10592 PQMADi_DBG(printf("P 10 PQ_DEINT_2DDI_BOB\n"));
10593
10594 if ( _upLayerConfig & E_PQ_MISC_A_HDMITX_ENABLE )
10595 {
10596 // HDMITX uses freerun
10597 // and when in some special case like 29.97fps in, 30fps out
10598 // sometimes we can see tearing because it is not locked yet.
10599 // so at least 3 frames is needed.
10600 *pu8FrameCount = 3;
10601 }else
10602 {
10603 if(MApi_XC_GetIPAutoNoSignal((SCALER_WIN)eWindow)==ENABLE)
10604 {
10605 *pu8FrameCount = 3;
10606 }
10607 else
10608 {
10609 *pu8FrameCount = 2;
10610 }
10611 }
10612 }
10613 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MOT8))
10614 {
10615 *pu8BitsPerPixel = 20;
10616 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10617 u8PQDelayCount = 2;
10618 PQMADi_DBG(printf("P M 8 PQ_DEINT_2DDI_BOB\n"));
10619
10620 if ( _upLayerConfig & E_PQ_MISC_A_HDMITX_ENABLE )
10621 {
10622 // HDMITX uses freerun
10623 // and when in some special case like 29.97fps in, 30fps out
10624 // sometimes we can see tearing because it is not locked yet.
10625 // so at least 3 frames is needed.
10626 *pu8FrameCount = 3;
10627 }
10628 else
10629 {
10630 if(MApi_XC_GetIPAutoNoSignal((SCALER_WIN)eWindow)==ENABLE)
10631 {
10632 *pu8FrameCount = 3;
10633 }
10634 else
10635 {
10636 *pu8FrameCount = 2;
10637 }
10638 }
10639 }
10640 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MOT10))
10641 {
10642 *pu8BitsPerPixel = 24;
10643 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10644 u8PQDelayCount = 2;
10645 PQMADi_DBG(printf("P M 10 PQ_DEINT_2DDI_BOB\n"));
10646
10647 if ( _upLayerConfig & E_PQ_MISC_A_HDMITX_ENABLE )
10648 {
10649 // HDMITX uses freerun
10650 // and when in some special case like 29.97fps in, 30fps out
10651 // sometimes we can see tearing because it is not locked yet.
10652 // so at least 3 frames is needed.
10653 *pu8FrameCount = 3;
10654 }else
10655 {
10656 if(MApi_XC_GetIPAutoNoSignal((SCALER_WIN)eWindow)==ENABLE)
10657 {
10658 *pu8FrameCount = 3;
10659 }
10660 else
10661 {
10662 *pu8FrameCount = 2;
10663 }
10664 }
10665 }
10666 #if PQ_ENABLE_RFBL
10667 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_24_RFBL_FILM))
10668 {
10669 *pu8BitsPerPixel = 12;
10670 u8PQDelayCount = 3;
10671 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10672 PQMADi_DBG(printf("24 RFBL FILM PQ_DEINT_3DDI_HISTORY\n"));
10673 MApi_XC_EnableRequest_FrameBufferLess(ENABLE);
10674 PQMADi_DBG(printf("[PQ] MADI: ENABLE RFBL: MS_MADI_24_RFBL_FILM\n"));
10675 }
10676 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_24_RFBL_NFILM))
10677 {
10678 *pu8BitsPerPixel = 12;
10679 u8PQDelayCount = 3;
10680 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10681 PQMADi_DBG(printf("24 RFBL NFILM PQ_DEINT_3DDI_HISTORY\n"));
10682 MApi_XC_EnableRequest_FrameBufferLess(ENABLE);
10683 PQMADi_DBG(printf("[PQ] MADI: ENABLE RFBL: MS_MADI_24_RFBL_NFILM\n"));
10684 }
10685 #endif
10686 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_FBL_DNR))
10687 {
10688 *pu8BitsPerPixel = 16;
10689 u8PQDelayCount = 3;
10690 *peDeInterlaceMode = PQ_DEINT_2DDI_AVG;
10691 PQMADi_DBG(printf("FBL DNR PQ_DEINT_2DDI_AVG\n"));
10692 }
10693 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_FBL_MIU))
10694 {
10695 *pu8BitsPerPixel = 16;
10696 u8PQDelayCount = 3;
10697 *peDeInterlaceMode = PQ_DEINT_2DDI_AVG;
10698 PQMADi_DBG(printf("FBL MIU PQ_DEINT_2DDI_AVG\n"));
10699 }
10700 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE8_NO_MIU))
10701 {
10702 *pu8BitsPerPixel = 16;
10703 u8PQDelayCount = 2;
10704 *peDeInterlaceMode = PQ_DEINT_2DDI_AVG;
10705 PQMADi_DBG(printf("P 8 NO MIU PQ_DEINT_2DDI_AVG\n"));
10706 }
10707 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MOT10_8Frame))
10708 {
10709 *pu8BitsPerPixel = 24;
10710 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10711 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10712 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10713 PQMADi_DBG(printf("P M 10 8Frame PQ_DEINT_2DDI_BOB\n"));
10714 *pu8FrameCount = 8;
10715 }
10716 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MOT10_4Frame))
10717 {
10718 *pu8BitsPerPixel = 24;
10719 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10720 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10721 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10722 PQMADi_DBG(printf("P M 10 4Frame PQ_DEINT_2DDI_BOB\n"));
10723 }
10724 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MC_3Frame))
10725 {
10726 *pu8BitsPerPixel = 24;
10727 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10728 MApi_XC_Set_OPWriteOffEnable(DISABLE,MAIN_WINDOW);
10729 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10730 PQMADi_DBG(printf("P MC 3Frame PQ_DEINT_2DDI_BOB\n"));
10731 *pu8FrameCount = 3;
10732 if((MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW) != MIRROR_NORMAL) &&
10733 (QM_GetInputVFreq(eWindow) > 235) && (QM_GetInputVFreq(eWindow) < 245))
10734 {
10735 printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
10736 printf("!!Error: Cannot set MS_MADI_P_MODE_MC_3Frame for mirror 24p(at least 4 frame number). Fix your PQ excel!!\n");
10737 printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
10738 }
10739 }
10740 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MC_4Frame))
10741 {
10742 *pu8BitsPerPixel = 24;
10743 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10744 MApi_XC_Set_OPWriteOffEnable(DISABLE,MAIN_WINDOW);
10745 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10746 PQMADi_DBG(printf("P MC 4Frame PQ_DEINT_2DDI_BOB\n"));
10747 *pu8FrameCount = 4;
10748 }
10749 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE_MC_4Frame_Yonly_Main))
10750 {
10751 *pu8BitsPerPixel = 24;
10752 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10753 MApi_XC_Set_OPWriteOffEnable(DISABLE,MAIN_WINDOW);
10754 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10755 PQMADi_DBG(printf("P MC 4Frame Yonly Main PQ_DEINT_2DDI_BOB\n"));
10756 *pu8FrameCount = 4;
10757 }
10758 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MC_5Frame))
10759 {
10760 *pu8BitsPerPixel = 24;
10761 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10762 MApi_XC_Set_OPWriteOffEnable(DISABLE,MAIN_WINDOW);
10763 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10764 PQMADi_DBG(printf("P MC 5Frame PQ_DEINT_2DDI_BOB\n"));
10765 *pu8FrameCount = 5;
10766 }
10767 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MC_6Frame))
10768 {
10769 *pu8BitsPerPixel = 24;
10770 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10771 MApi_XC_Set_OPWriteOffEnable(DISABLE,MAIN_WINDOW);
10772 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10773 PQMADi_DBG(printf("P MC 6Frame PQ_DEINT_2DDI_BOB\n"));
10774 *pu8FrameCount = 6;
10775 }
10776 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MC_6Frame_6R))
10777 {
10778 *pu8BitsPerPixel = 24;
10779 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10780 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10781 MApi_XC_Set_OPWriteOffEnable(DISABLE,MAIN_WINDOW);
10782 PQMADi_DBG(printf("P MC 6Frame 6R PQ_DEINT_2DDI_BOB\n"));
10783 *pu8FrameCount = 6;
10784 }
10785 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MC_8Frame_6R))
10786 {
10787 *pu8BitsPerPixel = 24;
10788 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10789 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10790 MApi_XC_Set_OPWriteOffEnable(DISABLE,MAIN_WINDOW);
10791 PQMADi_DBG(printf("P MC 8Frame 6R PQ_DEINT_2DDI_BOB\n"));
10792 *pu8FrameCount = 8;
10793 }
10794 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MC_12Frame_8R))
10795 {
10796 *pu8BitsPerPixel = 24;
10797 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10798 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10799 MApi_XC_Set_OPWriteOffEnable(DISABLE,MAIN_WINDOW);
10800 PQMADi_DBG(printf("P MC 12Frame 8R PQ_DEINT_2DDI_BOB\n"));
10801 *pu8FrameCount = 12;
10802 }
10803 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE_MC_12Frame_8R_M))
10804 {
10805 *pu8BitsPerPixel = 24;
10806 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10807 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10808 MApi_XC_Set_OPWriteOffEnable(DISABLE,MAIN_WINDOW);
10809 PQMADi_DBG(printf("P MC 12Frame 8R M PQ_DEINT_2DDI_BOB\n"));
10810 *pu8FrameCount = 12;
10811 }
10812 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE_MC_8Frame_8R_M))
10813 {
10814 *pu8BitsPerPixel = 24;
10815 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10816 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10817 MApi_XC_Set_OPWriteOffEnable(DISABLE,MAIN_WINDOW);
10818 PQMADi_DBG(printf("P MC 8Frame 8R M PQ_DEINT_2DDI_BOB\n"));
10819 *pu8FrameCount = 8;
10820 }
10821 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_MC_16Frame_8R))
10822 {
10823 *pu8BitsPerPixel = 24;
10824 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10825 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10826 MApi_XC_Set_OPWriteOffEnable(DISABLE,MAIN_WINDOW);
10827 PQMADi_DBG(printf("P MC 16Frame 8R PQ_DEINT_2DDI_BOB\n"));
10828 *pu8FrameCount = 16;
10829 }
10830 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_N_MC_12Frame_8R))
10831 {
10832 *pu8BitsPerPixel = 24;
10833 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10834 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10835 MApi_XC_Set_OPWriteOffEnable(DISABLE,MAIN_WINDOW);
10836 PQMADi_DBG(printf("P M N MC 12 8Frame PQ_DEINT_2DDI_BOB\n"));
10837 *pu8FrameCount = 12;
10838 }
10839 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE_P_MC_12Frame_8R))
10840 {
10841 *pu8BitsPerPixel = 24;
10842 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10843 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10844 MApi_XC_Set_OPWriteOffEnable(DISABLE,MAIN_WINDOW);
10845 PQMADi_DBG(printf("P M P MC 12 8Frame PQ_DEINT_2DDI_BOB\n"));
10846 *pu8FrameCount = 12;
10847 }
10848 #if PQ_ENABLE_RFBL
10849 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_RFBL_P_MODE10_MOT))
10850 {
10851 *pu8BitsPerPixel = 24;
10852 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10853 u8PQDelayCount = 2;
10854 PQMADi_DBG(printf("RFBL P M 10 PQ_DEINT_2DDI_BOB\n"));
10855 *pu8FrameCount = 2;
10856 MApi_XC_EnableRequest_FrameBufferLess(ENABLE);
10857 PQMADi_DBG(printf("[PQ] MADI: ENABLE RFBL: MS_MADI_RFBL_P_MODE10_MOT\n"));
10858 }
10859 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_RFBL_P_MODE8_MOT))
10860 {
10861 *pu8BitsPerPixel = 24;
10862 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10863 u8PQDelayCount = 2;
10864 PQMADi_DBG(printf("RFBL P M 8 PQ_DEINT_2DDI_BOB\n"));
10865 *pu8FrameCount = 2;
10866 MApi_XC_EnableRequest_FrameBufferLess(ENABLE);
10867 PQMADi_DBG(printf("[PQ] MADI: ENABLE RFBL: MS_MADI_RFBL_P_MODE8_MOT\n"));
10868 }
10869 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_RFBL_P_MODE_MC))
10870 {
10871 *pu8BitsPerPixel = 24;
10872 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10873 u8PQDelayCount = 6;
10874 PQMADi_DBG(printf("RFBL P M MC PQ_DEINT_2DDI_BOB\n"));
10875 *pu8FrameCount = 2;
10876 MApi_XC_EnableRequest_FrameBufferLess(ENABLE);
10877 PQMADi_DBG(printf("[PQ] MADI: ENABLE RFBL: MS_MADI_RFBL_P_MODE_MC\n"));
10878 }
10879 #endif
10880 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_6F_4R_MC_I))
10881 {
10882 *pu8BitsPerPixel = 24;
10883 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10884 u8PQDelayCount = 6;
10885 PQMADi_DBG(printf("I 25 4R MC_PQ_DEINT_3DDI_HISTORY\n"));
10886 //#if (STB_ENABLE == 0)
10887 // MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10888 // *pu8FrameCount = 8;
10889 //#else
10890 *pu8FrameCount = 6;
10891 //#endif
10892 }
10893 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_6F_4R_MC_P))
10894 {
10895 *pu8BitsPerPixel = 24;
10896 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10897 u8PQDelayCount = 6;
10898 PQMADi_DBG(printf("P 25 4R MC_PQ_DEINT_3DDI_HISTORY\n"));
10899 //#if (STB_ENABLE == 0)
10900 // MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10901 // *pu8FrameCount = 8;
10902 //#else
10903 *pu8FrameCount = 6;
10904 //#endif
10905 }
10906 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_25_4R_I))
10907 {
10908 *pu8BitsPerPixel = 24;
10909 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10910 u8PQDelayCount = 3;
10911 PQMADi_DBG(printf("I 25 4R PQ_DEINT_3DDI_HISTORY\n"));
10912 *pu8FrameCount = 6;
10913 }
10914 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_25_4R_P))
10915 {
10916 *pu8BitsPerPixel = 24;
10917 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10918 u8PQDelayCount = 3;
10919 PQMADi_DBG(printf("P 25 4R PQ_DEINT_3DDI_HISTORY\n"));
10920 *pu8FrameCount = 6;
10921 }
10922 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_25_16F_6R_M_MC))
10923 {
10924 *pu8BitsPerPixel = 24;
10925 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10926 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10927 *pu8FrameCount = 16;
10928 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10929 PQMADi_DBG(printf("25 16F 6R M MC_PQ_DEINT_3DDI_HISTORY\n"));
10930 }
10931 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE_MC_M_4F))
10932 {
10933 *pu8BitsPerPixel = 24;
10934 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10935 MApi_XC_Set_OPWriteOffEnable(DISABLE, MAIN_WINDOW);
10936 u8PQDelayCount = 6; //When MC mode and read/write bank mapping mode set 2, have to delay 125 ms .
10937 PQMADi_DBG(printf("P MC M 4Frame PQ_DEINT_2DDI_BOB\n"));
10938 *pu8FrameCount = 4;
10939 }
10940 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE8_M))
10941 {
10942 *pu8BitsPerPixel = 20;
10943 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10944 u8PQDelayCount = 3;
10945 printf("dirk 24_2R MS_MADi_P_MODE8_M\n");
10946 }
10947 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE10_M))
10948 {
10949 *pu8BitsPerPixel = 20;
10950 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10951 u8PQDelayCount = 2;
10952 PQMADi_DBG(printf("P 10 M PQ_DEINT_2DDI_BOB\n"));
10953
10954 if ( _upLayerConfig & E_PQ_MISC_A_HDMITX_ENABLE )
10955 {
10956 // HDMITX uses freerun
10957 // and when in some special case like 29.97fps in, 30fps out
10958 // sometimes we can see tearing because it is not locked yet.
10959 // so at least 3 frames is needed.
10960 *pu8FrameCount = 3;
10961 }
10962 else
10963 {
10964 if(MApi_XC_GetIPAutoNoSignal((SCALER_WIN)eWindow)==ENABLE)
10965 {
10966 *pu8FrameCount = 3;
10967 }
10968 else
10969 {
10970 *pu8FrameCount = 2;
10971 }
10972 }
10973 }
10974 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_25_4R_M))
10975 {
10976 *pu8BitsPerPixel = 24;
10977 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
10978 u8PQDelayCount = 3;
10979 PQMADi_DBG(printf("25 4R M PQ_DEINT_3DDI_HISTORY\n"));
10980 }
10981 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE_MOT10_M))
10982 {
10983 *pu8BitsPerPixel = 24;
10984 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
10985 u8PQDelayCount = 2;
10986 PQMADi_DBG(printf("P Mot 10 M PQ_DEINT_2DDI_BOB\n"));
10987
10988 if ( _upLayerConfig & E_PQ_MISC_A_HDMITX_ENABLE )
10989 {
10990 // HDMITX uses freerun
10991 // and when in some special case like 29.97fps in, 30fps out
10992 // sometimes we can see tearing because it is not locked yet.
10993 // so at least 3 frames is needed.
10994 *pu8FrameCount = 3;
10995 }else
10996 {
10997 if(MApi_XC_GetIPAutoNoSignal((SCALER_WIN)eWindow)==ENABLE)
10998 {
10999 *pu8FrameCount = 3;
11000 }
11001 else
11002 {
11003 *pu8FrameCount = 2;
11004 }
11005 }
11006 }
11007 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE_MOT10_M_4K))
11008 {
11009 *pu8BitsPerPixel = 24;
11010 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
11011 u8PQDelayCount = 2;
11012 PQMADi_DBG(printf("P Mot 10 M 4K PQ_DEINT_2DDI_BOB\n"));
11013
11014 if ( _upLayerConfig & E_PQ_MISC_A_HDMITX_ENABLE )
11015 {
11016 // HDMITX uses freerun
11017 // and when in some special case like 29.97fps in, 30fps out
11018 // sometimes we can see tearing because it is not locked yet.
11019 // so at least 3 frames is needed.
11020 *pu8FrameCount = 3;
11021 }
11022 else
11023 {
11024 if(MApi_XC_GetIPAutoNoSignal((SCALER_WIN)eWindow)==ENABLE)
11025 {
11026 *pu8FrameCount = 3;
11027 }
11028 else
11029 {
11030 *pu8FrameCount = 2;
11031 }
11032 }
11033 }
11034 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE_MOT8_M))
11035 {
11036 *pu8BitsPerPixel = 20;
11037 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
11038 u8PQDelayCount = 2;
11039 PQMADi_DBG(printf("P M 8 PQ_DEINT_2DDI_BOB\n"));
11040
11041 if ( _upLayerConfig & E_PQ_MISC_A_HDMITX_ENABLE )
11042 {
11043 // HDMITX uses freerun
11044 // and when in some special case like 29.97fps in, 30fps out
11045 // sometimes we can see tearing because it is not locked yet.
11046 // so at least 3 frames is needed.
11047 *pu8FrameCount = 3;
11048 }
11049 else
11050 {
11051 if(MApi_XC_GetIPAutoNoSignal((SCALER_WIN)eWindow)==ENABLE)
11052 {
11053 *pu8FrameCount = 3;
11054 }
11055 else
11056 {
11057 *pu8FrameCount = 2;
11058 }
11059 }
11060 }
11061 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_24_8F_4R_M_MC))
11062 {
11063 *pu8BitsPerPixel = 20;
11064 *peDeInterlaceMode = PQ_DEINT_3DDI_HISTORY;
11065 u8PQDelayCount = 3;
11066 *pu8FrameCount = 4;
11067 printf("24 8F 4R M MC PQ_DEINT_3DDI_HISTORY 4frame\n");
11068 }
11069 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance, (eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE_MOT10_NR_Yonly_M))
11070 {
11071 *pu8BitsPerPixel = 24;
11072 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
11073 u8PQDelayCount = 2;
11074 PQMADi_DBG(printf("P Mot 10 M PQ_DEINT_2DDI_BOB MS_MADi_P_MODE_MOT10_NR_Yonly_M\n"));
11075
11076 if(_upLayerConfig & E_PQ_MISC_A_HDMITX_ENABLE )
11077 {
11078 // HDMITX uses freerun
11079 // and when in some special case like 29.97fps in, 30fps out
11080 // sometimes we can see tearing because it is not locked yet.
11081 // so at least 3 frames is needed.
11082 *pu8FrameCount = 3;
11083 }
11084 else
11085 {
11086 if(MApi_XC_GetIPAutoNoSignal((SCALER_WIN)eWindow)==ENABLE)
11087 {
11088 *pu8FrameCount = 3;
11089 }
11090 else
11091 {
11092 *pu8FrameCount = 2;
11093 }
11094 }
11095 }
11096 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE_MOT10_NO_DNR))
11097 {
11098 *pu8BitsPerPixel = 24;
11099 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
11100 u8PQDelayCount = 2;
11101 PQMADi_DBG(printf("P Mot 10 M PQ_DEINT_2DDI_BOB MS_MADi_P_MODE_MOT10_NO_DNR\n"));
11102
11103 if(MApi_XC_GetIPAutoNoSignal((SCALER_WIN)eWindow)==ENABLE)
11104 {
11105 *pu8FrameCount = 3;
11106 }
11107 else
11108 {
11109 *pu8FrameCount = 2;
11110 }
11111
11112 }
11113 else
11114 {
11115 MS_ASSERT(0);
11116 PQMADi_DBG(printf("None\n"));
11117 }
11118
11119 }
11120 else
11121 {
11122 //in order to disable user mode,
11123 if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE8_444))
11124 {
11125 *pu8BitsPerPixel = 24;
11126 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
11127 u8PQDelayCount = 2;
11128 PQMADi_DBG(printf("P 8 444 PQ_DEINT_2DDI_BOB\n"));
11129 *pu8FrameCount = 2;
11130 }
11131 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE8_M_444))
11132 {
11133 *pu8BitsPerPixel = 24;
11134 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
11135 u8PQDelayCount = 2;
11136 PQMADi_DBG(printf("P MODE8 M 444 PQ_DEINT_2DDI_BOB\n"));
11137 *pu8FrameCount = 2;
11138 }
11139 else if(u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE10_444))
11140 {
11141 *pu8BitsPerPixel = 30;
11142 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
11143 u8PQDelayCount = 2;
11144 PQMADi_DBG(printf("P 10 444 PQ_DEINT_2DDI_BOB\n"));
11145 *pu8FrameCount = 2;
11146 }
11147 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE10_M_444))
11148 {
11149 *pu8BitsPerPixel = 30;
11150 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
11151 u8PQDelayCount = 2;
11152 PQMADi_DBG(printf("P 10 M 444 PQ_DEINT_2DDI_BOB\n"));
11153 *pu8FrameCount = 2;
11154 }
11155 else if (u16TabIdx_MADi == Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADi_P_MODE10_M_444_4K))
11156 {
11157 *pu8BitsPerPixel = 30;
11158 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
11159 u8PQDelayCount = 2;
11160 PQMADi_DBG(printf("P 10 M 444 4K PQ_DEINT_2DDI_BOB\n"));
11161 *pu8FrameCount = 2;
11162 }
11163 if((u16TabIdx_MemFormat == PQ_IP_MemFormat_444_10BIT_Main)
11164 #if PQ_ENABLE_PIP
11165 ||(u16TabIdx_MemFormat == PQ_IP_MemFormat_444_10BIT_Sub)
11166 #endif
11167 )
11168 {
11169 *pu8BitsPerPixel = 32;
11170 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
11171 PQMADi_DBG(printf("PQ_IP_MemFormat_444_10BIT\n"));
11172
11173 if(MApi_XC_GetIPAutoNoSignal((SCALER_WIN)eWindow)==ENABLE)
11174 {
11175 *pu8FrameCount = 3;
11176 u8PQDelayCount = 3;
11177
11178 }
11179 else
11180 {
11181 *pu8FrameCount = 2;
11182 u8PQDelayCount = 2;
11183 }
11184 }
11185 else if((u16TabIdx_MemFormat == PQ_IP_MemFormat_444_8BIT_Main)
11186 #if PQ_ENABLE_PIP
11187 ||(u16TabIdx_MemFormat == PQ_IP_MemFormat_444_8BIT_Sub)
11188 #endif
11189 )
11190 {
11191 *pu8BitsPerPixel = 24;
11192 *peDeInterlaceMode = PQ_DEINT_2DDI_BOB;
11193 PQMADi_DBG(printf("PQ_IP_MemFormat_444_8BIT\n"));
11194
11195 if(MApi_XC_GetIPAutoNoSignal((SCALER_WIN)eWindow)==ENABLE)
11196 {
11197 *pu8FrameCount = 3;
11198 u8PQDelayCount = 3;
11199 }
11200 else
11201 {
11202 *pu8FrameCount = 2;
11203 u8PQDelayCount = 2;
11204 }
11205 }
11206 else
11207 {
11208 *pu8BitsPerPixel = 24;
11209 PQMADi_DBG(printf("PQ_IP_MemFormat_422MF_Main\n"));
11210 *pu8FrameCount = 2;
11211 }
11212
11213 #if (PQ_GRULE_GAME_MODE_ENABLE == 0)
11214 if(MApi_XC_GetUCEnabled((SCALER_WIN)eWindow)) //if on need disable.
11215 {
11216 MDrv_PQ_DisableUCFeature(PQ_MAIN_WINDOW);
11217 }
11218 #endif
11219 }
11220
11221 if ((QM_GetInputVFreq(eWindow) != 0) && (QM_GetInputVFreq(eWindow) != 1))
11222 _u16PQDelyaTime = u8PQDelayCount * ((10000 + (QM_GetInputVFreq(eWindow)/2))/QM_GetInputVFreq(eWindow)); // frame duration is (1 second/input V freq)
11223 else
11224 _u16PQDelyaTime = u8PQDelayCount * 20; // default keep original rule, use 20ms as frame duration
11225
11226 MApi_XC_EnableRequest_FrameBufferLess(_bFrameBuffLess);
11227
11228 return TRUE;
11229 }
MDrv_PQ_GetBPPInfoFromMADi(PQ_WIN eWindow,MS_BOOL bMemFmt422,MS_U16 u16TabIdx_MADi,MS_U16 u16TabIdx_MemFormat,MS_U8 * pu8BitsPerPixel,PQ_DEINTERLACE_MODE * peDeInterlaceMode,MS_U8 * pu8FrameCount)11230 MS_BOOL MDrv_PQ_GetBPPInfoFromMADi(PQ_WIN eWindow,
11231 MS_BOOL bMemFmt422,
11232 MS_U16 u16TabIdx_MADi,
11233 MS_U16 u16TabIdx_MemFormat,
11234 MS_U8 *pu8BitsPerPixel,
11235 PQ_DEINTERLACE_MODE *peDeInterlaceMode,
11236 MS_U8 *pu8FrameCount
11237 )
11238 {
11239 #ifdef TRACE_DBG
11240 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
11241 #endif
11242 if (pu32PQInst == NULL)
11243 {
11244 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
11245 return FALSE;
11246 }
11247
11248 stPQ_GetBPPInfoFromMADi PQArgs;
11249 PQArgs.eWindow = eWindow;
11250 PQArgs.bMemFmt422 = bMemFmt422;
11251 PQArgs.u16TabIdx_MADi = u16TabIdx_MADi;
11252 PQArgs.u16TabIdx_MemFormat = u16TabIdx_MemFormat;
11253 PQArgs.pu8BitsPerPixel = pu8BitsPerPixel;
11254 PQArgs.peDeInterlaceMode = peDeInterlaceMode;
11255 PQArgs.pu8FrameCount = pu8FrameCount;
11256 PQArgs.bReturnValue = FALSE;
11257 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_BPPINFO_FROM_MADI, (void*)&PQArgs) != 0)
11258 {
11259 printf("Obtain PQ engine fail\n");
11260 return FALSE;
11261 }
11262 else
11263 {
11264 return PQArgs.bReturnValue;
11265 }
11266 }
11267
MDrv_PQ_ChangeMemConfigFor3D_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bMemFmt422,MS_U16 * pu16TabIdx_MemFormat,MS_U16 * pu16TabIdx_444To422,MS_U16 * pu16TabIdx_422To444,MS_U8 * pu8BitsPerPixel,MS_U16 * pu16TabIdx_MADi_Motion,MS_U16 * pu16TabIdx_MADi)11268 MS_BOOL MDrv_PQ_ChangeMemConfigFor3D_U2(void* pInstance,
11269 PQ_WIN eWindow,
11270 MS_BOOL bMemFmt422,
11271 MS_U16 *pu16TabIdx_MemFormat,
11272 MS_U16 *pu16TabIdx_444To422,
11273 MS_U16 *pu16TabIdx_422To444,
11274 MS_U8 *pu8BitsPerPixel,
11275 MS_U16 *pu16TabIdx_MADi_Motion,
11276 MS_U16 *pu16TabIdx_MADi
11277 )
11278 {
11279 UNUSED(pu16TabIdx_MADi_Motion);
11280 if(eWindow == PQ_MAIN_WINDOW)
11281 {
11282 //reduce mem size, put it into 16M, 2 frame mode.
11283 if((MApi_XC_Get_3D_Input_Mode((SCALER_WIN)eWindow) == E_XC_3D_INPUT_FRAME_PACKING)
11284 && (MApi_XC_Get_3D_Output_Mode() == E_XC_3D_OUTPUT_FRAME_ALTERNATIVE)
11285 && (_stMode_Info[eWindow].u16input_hsize == 1920)
11286 && (_stMode_Info[eWindow].u16input_vsize == 2205))
11287 {
11288 #if PQ_EN_UCNR_3D_MADI
11289 *pu16TabIdx_MADi = Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE8_2BYTE_3D);
11290 #else
11291 *pu16TabIdx_MADi = Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE8_444);
11292 #endif
11293 *pu8BitsPerPixel = 16;
11294
11295 // DVI is 444 input, we need to conver it to 422, otherwise DVI will use 32 bpp instead, not 16
11296 // because 444 format combine to the setting of pu16TabIdx_MemFormat
11297 if(!bMemFmt422)
11298 {
11299 //PQ_IP_MemFormat_Main 422
11300 *pu16TabIdx_MemFormat = PQ_IP_MemFormat_422MF_Main;
11301 *pu16TabIdx_444To422 = PQ_IP_444To422_ON_Main;
11302 //PQ_IP_422To444_Main on
11303 *pu16TabIdx_422To444 = PQ_IP_422To444_ON_Main;
11304 PQBW_DBG(printf("3D: force 422, 444to422 and 422to444 ON\n");)
11305 }
11306
11307 printf("3D: modify progressive memory fmt for 1080p framepacking\n");
11308 }
11309
11310 if(MApi_XC_Get_3D_HW_Version() < 2)
11311 {
11312 //PQ main page maybe MADi mode to 8 field mode, but it cannot do madi for line by line output.
11313 //so we force it back to normal 25_2R like mode.
11314 if(((MApi_XC_Get_3D_Output_Mode() == E_XC_3D_OUTPUT_TOP_BOTTOM) && (TRUE == _stMode_Info[eWindow].bInterlace))
11315 || ((MApi_XC_Get_3D_Output_Mode() == E_XC_3D_OUTPUT_TOP_BOTTOM_HW) && (TRUE == _stMode_Info[eWindow].bInterlace)))
11316 {
11317 // we must use MS_MADI_25_4R or 2R to avoid MC madi mode for dnr offset calcuation problem.
11318 if(TRUE == _stMode_Info[eWindow].bInterlace)
11319 {
11320 if((_stMode_Info[eWindow].u16input_vsize >= 900) &&
11321 (_stMode_Info[eWindow].u16input_hsize >= 1440) &&
11322 (bw_info.u32Miu1MemSize==0))// 1ddr case, should save bw
11323 {
11324 *pu16TabIdx_MADi = Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_2R);
11325 PQBW_DBG(printf("3D: force to 25_2R\n");)
11326 }
11327 else
11328 {
11329 *pu16TabIdx_MADi = Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_4R);
11330 PQBW_DBG(printf("3D: force to 25_4R\n");)
11331 }
11332 if(eWindow == PQ_MAIN_WINDOW)
11333 {
11334 MApi_XC_Set_OPWriteOffEnable(ENABLE, MAIN_WINDOW); //default
11335 }
11336 else
11337 {
11338 PQINFO_DBG(printf("No need to enable OP write with sub window, it would change main window setting \n"));
11339 }
11340 }
11341
11342 //Madi do line by line must use 422 format
11343 if(!bMemFmt422)
11344 {
11345 //PQ_IP_MemFormat_Main 422
11346 *pu16TabIdx_MemFormat = PQ_IP_MemFormat_422MF_Main;
11347 *pu16TabIdx_444To422 = PQ_IP_444To422_ON_Main;
11348 //PQ_IP_422To444_Main on
11349 *pu16TabIdx_422To444 = PQ_IP_422To444_ON_Main;
11350 PQBW_DBG(printf("3D: force 422, 444to422 and 422to444 ON\n");)
11351 }
11352
11353 // we can only process 422 format for E_XC_3D_INPUT_TOP_BOTTOM.
11354 // so, if it's 444 format, we have to force it to be 422 and the u8BitsPerPixel is also changed to 24.
11355 *pu8BitsPerPixel = 24;
11356 PQBW_DBG(printf("3D:force u8BitsPerPixel to 24\n");)
11357 }
11358
11359 //frame alterntive must use bob mode
11360 if((E_XC_3D_OUTPUT_FRAME_ALTERNATIVE_NOFRC == MApi_XC_Get_3D_Output_Mode()) ||
11361 (E_XC_3D_OUTPUT_FRAME_ALTERNATIVE == MApi_XC_Get_3D_Output_Mode()))
11362 {
11363 MDrv_PQ_EnableMADIForce(PQ_MAIN_WINDOW, TRUE);
11364 #if PQ_MADI_DFK
11365 MDrv_PQ_LoadTable_U2(pInstance,eWindow, PQ_IP_MADi_DFK_OFF_Main, PQ_IP_MADi_DFK_Main);
11366 #endif
11367 MDrv_PQ_LoadTable_U2(pInstance,eWindow, PQ_IP_EODi_OFF_Main, PQ_IP_EODi_Main);
11368 }
11369 //line by line must use weave mode
11370 else if(E_XC_3D_OUTPUT_LINE_ALTERNATIVE == MApi_XC_Get_3D_Output_Mode())
11371 {
11372 MDrv_PQ_EnableMADIForce(eWindow, FALSE);
11373 }
11374
11375 #if 0
11376 //None 3D case: by Ethan.Lee, saveing memory size for 1920x1200
11377 if ((MApi_XC_Get_3D_Input_Mode((SCALER_WIN)eWindow) == E_XC_3D_INPUT_MODE_NONE) &&
11378 (MApi_XC_Get_3D_Output_Mode()== E_XC_3D_OUTPUT_MODE_NONE) )
11379 {
11380 // Saving memory size for 1920x1200P HDMI 20110421EL
11381 if ( (_stMode_Info[eWindow].u16input_vsize > 1100) && (QM_IsSourceHDMI_Video(_enInputSourceType[eWindow], eWindow)))
11382 {
11383 *pu16TabIdx_MADi = Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_P_MODE8_444);
11384 *pu8BitsPerPixel = 16;
11385 if(!bMemFmt422)
11386 {
11387 //PQ_IP_MemFormat_Main 422
11388 *pu16TabIdx_MemFormat = PQ_IP_MemFormat_422MF_Main;
11389 *pu16TabIdx_444To422 = PQ_IP_444To422_ON_Main;
11390 //PQ_IP_422To444_Main on
11391 *pu16TabIdx_422To444 = PQ_IP_422To444_ON_Main;
11392 PQBW_DBG(printf("3D: force 422, 444to422 and 422to444 ON\n");)
11393 }
11394 }
11395 }
11396 #endif
11397 }
11398
11399 //Frame packing interlace must use 25_2R for
11400 // A. Madi for line by line output for old 3D engine. Or,
11401 // B. better quality. (P mode will shaking a little)
11402 if(((MApi_XC_Get_3D_Input_Mode((SCALER_WIN)eWindow) == E_XC_3D_INPUT_FRAME_PACKING) && (MApi_XC_Get_3D_Output_Mode() == E_XC_3D_OUTPUT_FRAME_L) && (_stMode_Info[eWindow].u16input_vsize == 2228))
11403 || ((MApi_XC_Get_3D_Input_Mode((SCALER_WIN)eWindow) == E_XC_3D_INPUT_FRAME_PACKING) && (MApi_XC_Get_3D_Output_Mode() == E_XC_3D_OUTPUT_FRAME_R) && (_stMode_Info[eWindow].u16input_vsize == 2228))
11404 || ((MApi_XC_Get_3D_Input_Mode((SCALER_WIN)eWindow) == E_XC_3D_INPUT_FRAME_PACKING) && (MApi_XC_Get_3D_Output_Mode() == E_XC_3D_OUTPUT_TOP_BOTTOM) && (_stMode_Info[eWindow].u16input_vsize == 2228))
11405 || ((MApi_XC_Get_3D_Input_Mode((SCALER_WIN)eWindow) == E_XC_3D_INPUT_FRAME_PACKING) && (MApi_XC_Get_3D_Output_Mode() == E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF) && (_stMode_Info[eWindow].u16input_vsize == 2228))
11406 || ((MApi_XC_Get_3D_Input_Mode((SCALER_WIN)eWindow) == E_XC_3D_INPUT_FRAME_PACKING) && (MApi_XC_Get_3D_Output_Mode() == E_XC_3D_OUTPUT_LINE_ALTERNATIVE) && (_stMode_Info[eWindow].u16input_vsize == 2228))
11407 || ((MApi_XC_Get_3D_Input_Mode((SCALER_WIN)eWindow) == E_XC_3D_INPUT_FRAME_PACKING) && (MApi_XC_Get_3D_Output_Mode() == E_XC_3D_OUTPUT_FRAME_ALTERNATIVE) && (_stMode_Info[eWindow].u16input_vsize == 2228))
11408 )
11409 {
11410 //framepacking interlace 1080i
11411 *pu16TabIdx_MADi = Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, MS_MADI_25_2R);
11412 _stMode_Info[eWindow].bInterlace = TRUE;
11413 *pu8BitsPerPixel = 24;
11414
11415 PQBW_DBG(printf("3D: force to 25_2R\n");)
11416 }
11417 }
11418 return TRUE;
11419 }
MDrv_PQ_ChangeMemConfigFor3D(PQ_WIN eWindow,MS_BOOL bMemFmt422,MS_U16 * pu16TabIdx_MemFormat,MS_U16 * pu16TabIdx_444To422,MS_U16 * pu16TabIdx_422To444,MS_U8 * pu8BitsPerPixel,MS_U16 * pu16TabIdx_MADi_Motion,MS_U16 * pu16TabIdx_MADi)11420 MS_BOOL MDrv_PQ_ChangeMemConfigFor3D(PQ_WIN eWindow,
11421 MS_BOOL bMemFmt422,
11422 MS_U16 *pu16TabIdx_MemFormat,
11423 MS_U16 *pu16TabIdx_444To422,
11424 MS_U16 *pu16TabIdx_422To444,
11425 MS_U8 *pu8BitsPerPixel,
11426 MS_U16 *pu16TabIdx_MADi_Motion,
11427 MS_U16 *pu16TabIdx_MADi
11428 )
11429 {
11430 #ifdef TRACE_DBG
11431 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
11432 #endif
11433 if (pu32PQInst == NULL)
11434 {
11435 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
11436 return FALSE;
11437 }
11438
11439 stPQ_ChangeMemConfigFor3D PQArgs;
11440 PQArgs.eWindow = eWindow;
11441 PQArgs.bMemFmt422 = bMemFmt422;
11442 PQArgs.pu16TabIdx_MemFormat = pu16TabIdx_MemFormat;
11443 PQArgs.pu16TabIdx_444To422 = pu16TabIdx_444To422;
11444 PQArgs.pu16TabIdx_422To444 = pu16TabIdx_422To444;
11445 PQArgs.pu8BitsPerPixel = pu8BitsPerPixel;
11446 PQArgs.pu16TabIdx_MADi_Motion = pu16TabIdx_MADi_Motion;
11447 PQArgs.pu16TabIdx_MADi = pu16TabIdx_MADi;
11448 PQArgs.bReturnValue = FALSE;
11449 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_CHANGE_MEMCONFIG_FOR3D, (void*)&PQArgs) != 0)
11450 {
11451 printf("Obtain PQ engine fail\n");
11452 return FALSE;
11453 }
11454 else
11455 {
11456 return PQArgs.bReturnValue;
11457 }
11458 }
11459
MDrv_PQ_ForceBPPForDynamicMemFmt_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bMemFmt422,MS_U8 * pu8BitsPerPixel)11460 MS_BOOL MDrv_PQ_ForceBPPForDynamicMemFmt_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bMemFmt422, MS_U8 *pu8BitsPerPixel)
11461 {
11462 //force Memory FMT and use the same pixel number to avoid the garbage when memory mode is changed.
11463 if(bMemFmt422)
11464 {
11465 MS_U16 u16MemFMT= 0;
11466
11467 if(!_stMode_Info[eWindow].bInterlace)
11468 {
11469 // for dynamically memory format changing, we need to keep it as 24 bits
11470 if(SUPPORT_DYNAMIC_MEM_FMT)//STB could be false
11471 {
11472 //Please refer to "MDrv_PQ_ChangeMemConfigFor3D"
11473 //reduce mem size, put it into 16M, 2 frame mode.
11474 if(!((MApi_XC_Get_3D_Input_Mode((SCALER_WIN)eWindow) == E_XC_3D_INPUT_FRAME_PACKING)
11475 && (MApi_XC_Get_3D_Output_Mode() == E_XC_3D_OUTPUT_FRAME_ALTERNATIVE)
11476 && (_stMode_Info[eWindow].u16input_hsize == 1920)
11477 && (_stMode_Info[eWindow].u16input_vsize == 2205)))
11478 *pu8BitsPerPixel = 24;
11479 }
11480 }
11481
11482 if (eWindow == PQ_MAIN_WINDOW)
11483 {
11484 u16MemFMT = MApi_XC_R2BYTEMSK(REG_SC_BK12_02_L, 0xFF);
11485 }
11486 else
11487 {
11488 u16MemFMT = MApi_XC_R2BYTEMSK(REG_SC_BK12_42_L, 0xFF);
11489 }
11490 if((u16MemFMT == 0xBB) || (u16MemFMT == 0xAA) || (u16MemFMT == 0x99) || (u16MemFMT == 0x88))
11491 {
11492 *pu8BitsPerPixel = 24;
11493 }
11494 else if((u16MemFMT == 0x55) || (u16MemFMT == 0x66) || (u16MemFMT == 0x44))
11495 {
11496 *pu8BitsPerPixel = 20;
11497 }
11498 else
11499 {
11500 //decide by original setting
11501 }
11502 }
11503 return TRUE;
11504 }
MDrv_PQ_ForceBPPForDynamicMemFmt(PQ_WIN eWindow,MS_BOOL bMemFmt422,MS_U8 * pu8BitsPerPixel)11505 MS_BOOL MDrv_PQ_ForceBPPForDynamicMemFmt(PQ_WIN eWindow, MS_BOOL bMemFmt422, MS_U8 *pu8BitsPerPixel)
11506 {
11507 #ifdef TRACE_DBG
11508 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
11509 #endif
11510 if (pu32PQInst == NULL)
11511 {
11512 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
11513 return FALSE;
11514 }
11515
11516 stPQ_ForceBPPForDynamicMemFmt PQArgs;
11517 PQArgs.eWindow = eWindow;
11518 PQArgs.bMemFmt422 = bMemFmt422;
11519 PQArgs.pu8BitsPerPixel = pu8BitsPerPixel;
11520 PQArgs.bReturnValue = FALSE;
11521 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_FORCE_BPP_FOR_DYNAMIC_MEMFMT, (void*)&PQArgs) != 0)
11522 {
11523 printf("Obtain PQ engine fail\n");
11524 return FALSE;
11525 }
11526 else
11527 {
11528 return PQArgs.bReturnValue;
11529 }
11530 }
11531
MDrv_PQ_SuggestFrameNum_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16TabIdx_MADi,MS_U8 u8FrameCount)11532 MS_BOOL MDrv_PQ_SuggestFrameNum_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16TabIdx_MADi, MS_U8 u8FrameCount)
11533 {
11534 //the chips, who are older than SCMI_V2, set frame count reg by Qmap.
11535 //the chips, who are SCMI_V2, the frame count is suggested by Qmap, but sw code judge and replace the value.
11536 // and then, set to hw reg
11537 //note: SUPPORT_SCMI_V2 is corresponding withe utopia flag: _FIELD_PACKING_MODE_SUPPORTED
11538 // we can remove SUPPORT_SCMI_V2 later
11539 if(MApi_XC_IsFieldPackingModeSupported())
11540 {
11541 //Set Frame number
11542 UNUSED(u16TabIdx_MADi);
11543 if(bSetFrameCount )
11544 {
11545 _u16PQSuggestedFrameNum[eWindow] = u8FrameCount;
11546 PQMADi_DBG(printf("[%s %d] _u16PQSuggestedFrameNum[%u] = %u\n", __FILE__, (int)__LINE__, eWindow, u8FrameCount));
11547 }
11548 }
11549 return TRUE;
11550 }
MDrv_PQ_SuggestFrameNum(PQ_WIN eWindow,MS_U16 u16TabIdx_MADi,MS_U8 u8FrameCount)11551 MS_BOOL MDrv_PQ_SuggestFrameNum(PQ_WIN eWindow, MS_U16 u16TabIdx_MADi, MS_U8 u8FrameCount)
11552 {
11553 #ifdef TRACE_DBG
11554 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
11555 #endif
11556 if (pu32PQInst == NULL)
11557 {
11558 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
11559 return FALSE;
11560 }
11561
11562 stPQ_SuggestFrameNum PQArgs;
11563 PQArgs.eWindow = eWindow;
11564 PQArgs.u16TabIdx_MADi = u16TabIdx_MADi;
11565 PQArgs.u8FrameCount = u8FrameCount;
11566 PQArgs.bReturnValue = FALSE;
11567 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SUGGEST_FRAMENUM, (void*)&PQArgs) != 0)
11568 {
11569 printf("Obtain PQ engine fail\n");
11570 return FALSE;
11571 }
11572 else
11573 {
11574 return PQArgs.bReturnValue;
11575 }
11576 }
11577
MDrv_PQ_SetGameMode_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bEnable)11578 MS_BOOL MDrv_PQ_SetGameMode_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bEnable)
11579 {
11580 #if PQ_UC_CTL
11581 #if(PQ_GRULE_GAME_MODE_ENABLE == 0)
11582 static MS_U16 _u16TabIdx_MADi_DFK_Gamemode[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
11583 static MS_U16 _u16TabIdx_MADi_SST_Gamemode[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
11584 static MS_U16 _u16TabIdx_MADi_EODiW_Gamemode[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
11585 static MS_U16 _u16TabIdx_UCNR_Gamemode[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
11586 static MS_U16 _u16TabIdx_UCDi_Gamemode[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
11587 static MS_U16 _u16TabIdx_UCCTL_Gamemode[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
11588 static MS_U16 _u16TabIdx_MADi_Gamemode[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
11589 static MS_U16 _u16TabIdx_MADi_Mot_Gamemode[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
11590 static MS_U16 _u16TabIdx_SwDriver_Gamemode[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
11591 static MS_U16 _u16TabIdx_PostCCS_Gamemode[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
11592 static MS_U16 _u16TabIdx_DHD_Gamemode[PQ_MAX_WINDOW] = {0xFFFF, 0xFFFF};
11593 #endif
11594 #endif
11595 if (eWindow >= PQ_MAX_WINDOW)
11596 return FALSE;
11597
11598 #if(ENABLE_PQ_MLOAD == 0)
11599 printf("*** [Game mode] please enable PQ Mload \n");
11600 #endif
11601
11602 PQMADi_DBG(printf("MDrv_PQ_SetGameMode() bEnable: %u\n", bEnable));
11603
11604 #if (PQ_GRULE_GAME_MODE_ENABLE == 0)
11605 MS_U8 u8RWmappingNum = 0;
11606 #endif
11607 _bGameModeOn[eWindow] = bEnable;
11608
11609 if(bEnable)
11610 {
11611 #if (PQ_GRULE_GAME_MODE_ENABLE == 0)
11612 if(_bRWNumIsReset[eWindow])
11613 {
11614 _u8RWmappingNum[eWindow] = MApi_XC_GetWRBankMappingNum(eWindow);
11615 _bRWNumIsReset[eWindow] = FALSE;
11616 }
11617
11618 // set the R/W bank mapping
11619 if (_stMode_Info[eWindow].bInterlace
11620 && (_stMode_Info[eWindow].u16input_vtotal <= 750)
11621 && (QM_IsSourceYPbPr(_enInputSourceType[eWindow]) || QM_IsSourceSV(_enInputSourceType[eWindow]) || QM_IsSourceAV(_enInputSourceType[eWindow])))
11622 {
11623 u8RWmappingNum = 0x01;
11624 }
11625 else
11626 {
11627 u8RWmappingNum = _u8RWmappingNum[eWindow];
11628 }
11629 #endif
11630
11631 #if PQ_UC_CTL
11632 #if(PQ_GRULE_GAME_MODE_ENABLE == 0)
11633 MDrv_PQ_GetCurrentUCFeature( eWindow,
11634 &_u16TabIdx_MADi_Gamemode[eWindow],
11635 &_u16TabIdx_MADi_Mot_Gamemode[eWindow],
11636 &_u16TabIdx_MADi_DFK_Gamemode[eWindow],
11637 &_u16TabIdx_MADi_SST_Gamemode[eWindow],
11638 &_u16TabIdx_MADi_EODiW_Gamemode[eWindow],
11639 &_u16TabIdx_UCNR_Gamemode[eWindow],
11640 &_u16TabIdx_UCDi_Gamemode[eWindow],
11641 &_u16TabIdx_UCCTL_Gamemode[eWindow],
11642 &_u16TabIdx_SwDriver_Gamemode[eWindow],
11643 &_u16TabIdx_PostCCS_Gamemode[eWindow],
11644 &_u16TabIdx_DHD_Gamemode[eWindow]
11645 );
11646 #endif
11647 MDrv_PQ_DisableUCFeature(eWindow);
11648 #endif
11649 }
11650 else
11651 {
11652 #if (PQ_GRULE_GAME_MODE_ENABLE == 0)
11653 // Restore original value
11654 u8RWmappingNum = _u8RWmappingNum[eWindow];
11655 #endif
11656
11657 #if PQ_UC_CTL
11658 #if(PQ_GRULE_GAME_MODE_ENABLE == 1)
11659 MDrv_PQ_EnableUCFeature_U2(pInstance, eWindow);
11660 #else
11661 MDrv_PQ_SetUCFeature(eWindow,
11662 _u16TabIdx_MADi_Gamemode[eWindow],
11663 _u16TabIdx_MADi_Mot_Gamemode[eWindow],
11664 _u16TabIdx_MADi_DFK_Gamemode[eWindow],
11665 _u16TabIdx_MADi_SST_Gamemode[eWindow],
11666 _u16TabIdx_MADi_EODiW_Gamemode[eWindow],
11667 _u16TabIdx_UCNR_Gamemode[eWindow],
11668 _u16TabIdx_UCDi_Gamemode[eWindow],
11669 _u16TabIdx_UCCTL_Gamemode[eWindow],
11670 _u16TabIdx_SwDriver_Gamemode[eWindow],
11671 _u16TabIdx_PostCCS_Gamemode[eWindow],
11672 _u16TabIdx_DHD_Gamemode[eWindow]
11673 );
11674 #endif
11675 #endif
11676 }
11677
11678 #if (PQ_GRULE_GAME_MODE_ENABLE == 0)
11679 MApi_XC_SetWRBankMappingNum(u8RWmappingNum,eWindow);
11680 #endif
11681 return TRUE;
11682 }
MDrv_PQ_SetGameMode(PQ_WIN eWindow,MS_BOOL bEnable)11683 MS_BOOL MDrv_PQ_SetGameMode(PQ_WIN eWindow, MS_BOOL bEnable)
11684 {
11685 #ifdef TRACE_DBG
11686 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
11687 #endif
11688 if (pu32PQInst == NULL)
11689 {
11690 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
11691 return FALSE;
11692 }
11693
11694 stPQ_SetGameMode PQArgs;
11695 PQArgs.eWindow = eWindow;
11696 PQArgs.bEnable = bEnable;
11697 PQArgs.bReturnValue = FALSE;
11698 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_GAMEMODE, (void*)&PQArgs) != 0)
11699 {
11700 printf("Obtain PQ engine fail\n");
11701 return FALSE;
11702 }
11703 else
11704 {
11705 return PQArgs.bReturnValue;
11706 }
11707 }
11708
11709
MDrv_PQ_GetGameMode_Status_U2(void * pInstance,PQ_WIN eWindow)11710 MS_BOOL MDrv_PQ_GetGameMode_Status_U2(void* pInstance,PQ_WIN eWindow)
11711 {
11712 if (eWindow >= PQ_MAX_WINDOW)
11713 return FALSE;
11714 else
11715 return _bGameModeOn[eWindow];
11716 }
MDrv_PQ_GetGameMode_Status(PQ_WIN eWindow)11717 MS_BOOL MDrv_PQ_GetGameMode_Status(PQ_WIN eWindow)
11718 {
11719 #ifdef TRACE_DBG
11720 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
11721 #endif
11722 if (pu32PQInst == NULL)
11723 {
11724 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
11725 return FALSE;
11726 }
11727
11728 stPQ_GetGameMode_Status PQArgs;
11729 PQArgs.eWindow = eWindow;
11730 PQArgs.bReturnValue = FALSE;
11731 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_GAMEMODE_STATUS, (void*)&PQArgs) != 0)
11732 {
11733 printf("Obtain PQ engine fail\n");
11734 return FALSE;
11735 }
11736 else
11737 {
11738 return PQArgs.bReturnValue;
11739 }
11740 }
11741
MDrv_PQ_SetBypassMode_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bEnable)11742 MS_BOOL MDrv_PQ_SetBypassMode_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bEnable)
11743 {
11744 if (eWindow >= PQ_MAX_WINDOW)
11745 return FALSE;
11746
11747 _bBypassModeOn[eWindow] = bEnable;
11748 return TRUE;
11749 }
MDrv_PQ_SetBypassMode(PQ_WIN eWindow,MS_BOOL bEnable)11750 MS_BOOL MDrv_PQ_SetBypassMode(PQ_WIN eWindow, MS_BOOL bEnable)
11751 {
11752 #ifdef TRACE_DBG
11753 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
11754 #endif
11755 if (pu32PQInst == NULL)
11756 {
11757 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
11758 return FALSE;
11759 }
11760
11761 stPQ_SetBypassMode PQArgs;
11762 PQArgs.eWindow = eWindow;
11763 PQArgs.bEnable = bEnable;
11764 PQArgs.bReturnValue = FALSE;
11765 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_BYPASS_MODE, (void*)&PQArgs) != 0)
11766 {
11767 printf("Obtain PQ engine fail\n");
11768 return FALSE;
11769 }
11770 else
11771 {
11772 return PQArgs.bReturnValue;
11773 }
11774 }
11775
MDrv_PQ_GetBypassModeStatus_U2(void * pInstance,PQ_WIN eWindow)11776 MS_BOOL MDrv_PQ_GetBypassModeStatus_U2(void* pInstance,PQ_WIN eWindow)
11777 {
11778 if (eWindow >= PQ_MAX_WINDOW)
11779 return FALSE;
11780 else
11781 return _bBypassModeOn[eWindow];
11782 }
MDrv_PQ_GetBypassModeStatus(PQ_WIN eWindow)11783 MS_BOOL MDrv_PQ_GetBypassModeStatus(PQ_WIN eWindow)
11784 {
11785 #ifdef TRACE_DBG
11786 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
11787 #endif
11788 if (pu32PQInst == NULL)
11789 {
11790 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
11791 return FALSE;
11792 }
11793
11794 stPQ_GetBypassModeStatus PQArgs;
11795 PQArgs.eWindow = eWindow;
11796 PQArgs.bReturnValue = FALSE;
11797 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_BYPASS_MODE_STATUS, (void*)&PQArgs) != 0)
11798 {
11799 printf("Obtain PQ engine fail\n");
11800 return FALSE;
11801 }
11802 else
11803 {
11804 return PQArgs.bReturnValue;
11805 }
11806 }
11807
MDrv_PQ_GetVersion_U2(void * pInstance,PQ_WIN eWindow)11808 char* MDrv_PQ_GetVersion_U2(void* pInstance,PQ_WIN eWindow)
11809 {
11810 if(gbPQBinEnable == 1)
11811 {
11812 char* PQ_Version;
11813
11814 if(PQ_MAIN_WINDOW == eWindow)
11815 {
11816 PQ_Version = stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u8Version;
11817 }
11818 else
11819 {
11820 PQ_Version = stPQBinHeaderInfo[PQ_BIN_STD_SUB].u8Version;
11821 }
11822 return PQ_Version;
11823 }
11824 else
11825 {
11826 return NULL;
11827
11828 }
11829 }
MDrv_PQ_GetVersion(PQ_WIN eWindow)11830 char* MDrv_PQ_GetVersion(PQ_WIN eWindow)
11831 {
11832 #ifdef TRACE_DBG
11833 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
11834 #endif
11835 if (pu32PQInst == NULL)
11836 {
11837 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
11838 return FALSE;
11839 }
11840
11841 stPQ_GetVersion PQArgs;
11842 PQArgs.eWindow = eWindow;
11843 PQArgs.u8Ret = NULL;
11844 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_VERSION, (void*)&PQArgs) != 0)
11845 {
11846 printf("Obtain PQ engine fail\n");
11847 return NULL;
11848 }
11849 else
11850 {
11851 return PQArgs.u8Ret;
11852 }
11853 }
MDrv_PQ_Cus_GetVersion_U2(void * pInstance,PQ_WIN eWindow)11854 char* MDrv_PQ_Cus_GetVersion_U2(void *pInstance,PQ_WIN eWindow)
11855 {
11856 if(_bCustomerMainPQEn == 1)
11857 {
11858 char* Cus_PQ_Version = NULL;
11859
11860 if(PQ_MAIN_WINDOW == eWindow)
11861 {
11862 Cus_PQ_Version = stPQBinHeaderInfo[PQ_BIN_CUSTOMER_MAIN].u8Version;
11863 }
11864 else
11865 {
11866 if(_bCustomerSubPQEn == 1)
11867 {
11868 Cus_PQ_Version = stPQBinHeaderInfo[PQ_BIN_CUSTOMER_SUB].u8Version;
11869 }
11870 }
11871 return Cus_PQ_Version;
11872 }
11873 else
11874 {
11875 return NULL;
11876 }
11877 }
MDrv_PQ_Cus_GetVersion(PQ_WIN eWindow)11878 char* MDrv_PQ_Cus_GetVersion(PQ_WIN eWindow)
11879 {
11880 #ifdef TRACE_DBG
11881 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
11882 #endif
11883 if (pu32PQInst == NULL)
11884 {
11885 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
11886 return FALSE;
11887 }
11888
11889 stPQ_Cus_GetVersion PQArgs;
11890 PQArgs.eWindow = eWindow;
11891 PQArgs.u8Ret = NULL;
11892 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_CUS_GET_VERSION, (void*)&PQArgs) != 0)
11893 {
11894 printf("Obtain PQ engine fail\n");
11895 return NULL;
11896 }
11897 else
11898 {
11899 return PQArgs.u8Ret;
11900 }
11901 }
_MDrv_PQ_SetGRuleStatus(void * pInstance,PQ_WIN eWindow,MS_U16 u16GruleType,MS_U16 u16PQ_GroupIdx)11902 static MS_BOOL _MDrv_PQ_SetGRuleStatus(void *pInstance,PQ_WIN eWindow, MS_U16 u16GruleType, MS_U16 u16PQ_GroupIdx)
11903 {
11904 PQ_BIN_TYPE enPQBinTypeMain = PQ_BIN_STD_MAIN;
11905 #if (PQ_ENABLE_PIP)
11906 PQ_BIN_TYPE enPQBinTypeSub = PQ_BIN_STD_SUB;
11907 #endif
11908
11909 if(gbPQBinEnable)
11910 {
11911 MS_U16 i, u16IPIdx = 0, u16TabIdx = 0, u16GroupNum = 0, u16IPNum = 0;
11912
11913 if(eWindow == PQ_MAIN_WINDOW)
11914 {
11915 if(u16GruleType >= stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u16GRule_RuleNum)
11916 {
11917 if(_bCustomerMainPQEn)
11918 {
11919 printf("(%s, %d)GRuleType(%u) is bigger than STD PQ's(%u), so consider it as CUSTOMER PQ's GRule Type\n",
11920 __FUNCTION__, __LINE__, u16GruleType, stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u16GRule_RuleNum);
11921 u16GruleType = u16GruleType - stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u16GRule_RuleNum;
11922 enPQBinTypeMain = PQ_BIN_CUSTOMER_MAIN;
11923 if(u16GruleType >= stPQBinHeaderInfo[PQ_BIN_CUSTOMER_MAIN].u16GRule_RuleNum)
11924 {
11925 printf("CustomerPQ: =ERROR!!!=%s, %d, =%d, out of %d, =\n", __FUNCTION__, __LINE__, u16GruleType, stPQBinHeaderInfo[PQ_BIN_CUSTOMER_MAIN].u16GRule_RuleNum);
11926 return FALSE;
11927 }
11928 }
11929 else
11930 {
11931 printf("=ERROR!!!=%s, %d, =%d, out of %d, =\n", __FUNCTION__, __LINE__, u16GruleType, stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u16GRule_RuleNum);
11932 return FALSE;
11933 }
11934 }
11935 u16GroupNum = MDrv_PQBin_GetGRule_GroupNum(pInstance,u16GruleType, &stPQBinHeaderInfo[enPQBinTypeMain]);
11936 u16IPNum = MDrv_PQBin_GetGRule_IPNum(pInstance,u16GruleType, &stPQBinHeaderInfo[enPQBinTypeMain]);
11937 }
11938 #if (PQ_ENABLE_PIP)
11939 else if(eWindow == PQ_SUB_WINDOW)
11940 {
11941 if(_bCustomerSubPQEn)
11942 {
11943 printf("(%s, %d)GRuleType(%u) is bigger than STD PQ's(%u), so consider it as CUSTOMER PQ's GRule Type\n",
11944 __FUNCTION__, __LINE__, u16GruleType, stPQBinHeaderInfo[PQ_BIN_STD_SUB].u16GRule_RuleNum);
11945 u16GruleType = u16GruleType - stPQBinHeaderInfo[PQ_BIN_STD_SUB].u16GRule_RuleNum;
11946 enPQBinTypeSub = PQ_BIN_CUSTOMER_SUB;
11947 if(u16GruleType >= stPQBinHeaderInfo[PQ_BIN_CUSTOMER_SUB].u16GRule_RuleNum)
11948 {
11949 printf("CustomerPQ: ERROR!!!=%s, %d, =%d, out of %d, =\n", __FUNCTION__, __LINE__, u16GruleType, stPQBinHeaderInfo[PQ_BIN_CUSTOMER_SUB].u16GRule_RuleNum);
11950 return 0;
11951 }
11952 }
11953 else
11954 {
11955 printf("=ERROR!!!=%s, %d, =%d, out of %d, =\n", __FUNCTION__, __LINE__, u16GruleType, stPQBinHeaderInfo[PQ_BIN_STD_SUB].u16GRule_RuleNum);
11956 return FALSE;
11957 }
11958 u16GroupNum = MDrv_PQBin_GetGRule_GroupNum(pInstance,u16GruleType, &stPQBinHeaderInfo[enPQBinTypeSub]);
11959 u16IPNum = MDrv_PQBin_GetGRule_IPNum(pInstance,u16GruleType, &stPQBinHeaderInfo[enPQBinTypeSub]);
11960 }
11961 #endif
11962
11963 if ((PQ_BIN_IP_NULL == u16GroupNum) || (PQ_BIN_IP_NULL == u16IPNum))
11964 {
11965 return FALSE;
11966 }
11967
11968 if(u16PQ_GroupIdx >= u16GroupNum)
11969 {
11970 printf("=ERROR!!!=%s, %d, u16PQ_GroupIdx:%d, out of range:%d=\n", __FUNCTION__, __LINE__, u16PQ_GroupIdx, u16GroupNum);
11971 return FALSE;
11972 }
11973
11974 if(((_bCustomerMainPQEn) && (enPQBinTypeMain == PQ_BIN_CUSTOMER_MAIN))
11975 #if (PQ_ENABLE_PIP)
11976 || ((_bCustomerSubPQEn) && (enPQBinTypeSub == PQ_BIN_CUSTOMER_SUB))
11977 #endif
11978 )
11979 {
11980 for(i = 0; i < u16IPNum; i++)
11981 {
11982 u16IPIdx = MDrv_PQ_GetCustomerGRule_IPIndex(eWindow, u16GruleType, i);
11983
11984 if(u16PQ_GroupIdx == u16GroupNum) // see it as default
11985 {
11986 u16TabIdx = MDrv_PQ_GetCustomerTableIndex(eWindow, u16TabIdx);
11987 }
11988 else
11989 {
11990 u16TabIdx = MDrv_PQ_GetGRule_CustomerTableIndex(eWindow, u16GruleType, u16PQ_GroupIdx, i);
11991 }
11992 PQGRULE_DBG(printf("[DC]SRC: %u, DC: %u, DCIPIdx:%u, IPIdx:%u, u16TabIdx:%u\n",
11993 _u16PQSrcType[eWindow], u16PQ_GroupIdx, i, u16IPIdx, u16TabIdx));
11994 MDrv_PQ_LoadCustomerTable(eWindow, u16TabIdx, u16IPIdx);
11995 }
11996 }
11997 else
11998 {
11999 for(i = 0; i < u16IPNum; i++)
12000 {
12001 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_U2(pInstance, eWindow, u16GruleType, i);
12002
12003 if(u16PQ_GroupIdx == u16GroupNum) // see it as default
12004 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, u16TabIdx);
12005 else
12006 u16TabIdx = MDrv_PQ_GetGRule_TableIndex(eWindow, u16GruleType, u16PQ_GroupIdx, i);
12007
12008 PQGRULE_DBG(printf("[DC]SRC: %u, DC: %u, DCIPIdx:%u, IPIdx:%u, u16TabIdx:%u\n",
12009 _u16PQSrcType[eWindow], u16PQ_GroupIdx, i, u16IPIdx, u16TabIdx));
12010 MDrv_PQ_LoadTable_U2(pInstance,eWindow, u16TabIdx, u16IPIdx);
12011 }
12012 }
12013 return TRUE;
12014 }
12015 else
12016 {
12017 return FALSE;
12018 }
12019 }
12020
MDrv_PQ_SetGRuleStatus_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16GruleType,MS_U16 u16GruleStatus)12021 MS_BOOL MDrv_PQ_SetGRuleStatus_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16GruleType, MS_U16 u16GruleStatus)
12022 {
12023 MS_U16 u16PQ_CurLvlIdx = 0;
12024 u16PQ_CurLvlIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, u16GruleType, u16GruleStatus);
12025
12026 return _MDrv_PQ_SetGRuleStatus(pInstance,eWindow, u16GruleType, u16PQ_CurLvlIdx);
12027 }
MDrv_PQ_SetGRuleStatus(PQ_WIN eWindow,MS_U16 u16GruleType,MS_U16 u16GruleStatus)12028 MS_BOOL MDrv_PQ_SetGRuleStatus(PQ_WIN eWindow, MS_U16 u16GruleType, MS_U16 u16GruleStatus)
12029 {
12030 #ifdef TRACE_DBG
12031 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
12032 #endif
12033 if (pu32PQInst == NULL)
12034 {
12035 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
12036 return FALSE;
12037 }
12038
12039 stPQ_SetGRuleStatus PQArgs;
12040 PQArgs.eWindow = eWindow;
12041 PQArgs.u16GruleType = u16GruleType;
12042 PQArgs.u16GruleStatus = u16GruleStatus;
12043 PQArgs.bReturnValue = FALSE;
12044 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_GRULE_STATUS, (void*)&PQArgs) != 0)
12045 {
12046 printf("Obtain PQ engine fail\n");
12047 return FALSE;
12048 }
12049 else
12050 {
12051 return PQArgs.bReturnValue;
12052 }
12053 }
12054
MDrv_PQ_GetGRule_LvlNum_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16GRuleType)12055 MS_U16 MDrv_PQ_GetGRule_LvlNum_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16GRuleType)
12056 {
12057 MS_U16 u16Ret = 0;
12058
12059 PQ_BIN_TYPE enPQBinTypeMain = PQ_BIN_STD_MAIN;
12060 #if (PQ_ENABLE_PIP)
12061 PQ_BIN_TYPE enPQBinTypeSub = PQ_BIN_STD_SUB;
12062 #endif
12063
12064 if(gbPQBinEnable)
12065 {
12066 MS_U16 u16PanelIdx = 0;
12067 if(eWindow == PQ_MAIN_WINDOW)
12068 {
12069 if(u16GRuleType >= stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u16GRule_RuleNum)
12070 {
12071 if(_bCustomerMainPQEn)
12072 {
12073 PQGRULE_DBG(printf("(%s, %d)GRuleType(%u) is bigger than STD PQ's(%u), so consider it as CUSTOMER PQ's GRule Type\n",
12074 __FUNCTION__, __LINE__, u16GRuleType, stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u16GRule_RuleNum));
12075 u16GRuleType = u16GRuleType - stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u16GRule_RuleNum;
12076 enPQBinTypeMain = PQ_BIN_CUSTOMER_MAIN;
12077 u16PanelIdx = PQ_BIN_CUSTOMER_PANEL_INDEX;
12078 if(u16GRuleType >= stPQBinHeaderInfo[PQ_BIN_CUSTOMER_MAIN].u16GRule_RuleNum)
12079 {
12080 printf("CustomerPQ: =ERROR!!!=%s, %d, =%d, out of %d, =\n", __FUNCTION__, __LINE__, u16GRuleType, stPQBinHeaderInfo[PQ_BIN_CUSTOMER_MAIN].u16GRule_RuleNum);
12081 return 0;
12082 }
12083 }
12084 else
12085 {
12086 printf("=ERROR!!!=%s, %d, =%d, out of %d, =\n", __FUNCTION__, __LINE__, u16GRuleType, stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u16GRule_RuleNum);
12087 return 0;
12088 }
12089 }
12090 else
12091 {
12092 u16PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
12093 }
12094
12095 u16Ret = MDrv_PQBin_GetGRule_LvlNum(pInstance,u16PanelIdx, u16GRuleType, &stPQBinHeaderInfo[enPQBinTypeMain]);
12096 }
12097 #if (PQ_ENABLE_PIP)
12098 else if(eWindow == PQ_SUB_WINDOW)
12099 {
12100 if(u16GRuleType >= stPQBinHeaderInfo[PQ_BIN_STD_SUB].u16GRule_RuleNum)
12101 {
12102 if(_bCustomerSubPQEn)
12103 {
12104 PQGRULE_DBG(printf("(%s, %d)GRuleType(%u) is bigger than STD PQ's(%u), so consider it as CUSTOMER PQ's GRule Type\n",
12105 __FUNCTION__, __LINE__, u16GRuleType, stPQBinHeaderInfo[PQ_BIN_STD_SUB].u16GRule_RuleNum));
12106 u16GRuleType = u16GRuleType - stPQBinHeaderInfo[PQ_BIN_STD_SUB].u16GRule_RuleNum;
12107 enPQBinTypeSub = PQ_BIN_CUSTOMER_SUB;
12108 u16PanelIdx = PQ_BIN_CUSTOMER_PANEL_INDEX;
12109 if(u16GRuleType >= stPQBinHeaderInfo[PQ_BIN_CUSTOMER_SUB].u16GRule_RuleNum)
12110 {
12111 printf("CustomerPQ: =ERROR!!!=%s, %d, =%d, out of %d, =\n", __FUNCTION__, __LINE__, u16GRuleType, stPQBinHeaderInfo[PQ_BIN_CUSTOMER_SUB].u16GRule_RuleNum);
12112 return 0;
12113 }
12114 }
12115 else
12116 {
12117 printf("=ERROR!!!=%s, %d, =%d, out of %d, =\n", __FUNCTION__, __LINE__, u16GRuleType, stPQBinHeaderInfo[PQ_BIN_STD_SUB].u16GRule_RuleNum);
12118 return 0;
12119 }
12120 }
12121 else
12122 {
12123 u16PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
12124 }
12125
12126 u16Ret = MDrv_PQBin_GetGRule_LvlNum(pInstance,u16PanelIdx, u16GRuleType, &stPQBinHeaderInfo[enPQBinTypeSub]);
12127 }
12128 #endif
12129 else
12130 {
12131 printf("=Error=%s, %d, =Not support case \n", __FUNCTION__, __LINE__);
12132 }
12133
12134 if (PQ_BIN_IP_NULL == u16Ret)
12135 {
12136 return 0;
12137 }
12138 }
12139 return u16Ret;
12140 }
MDrv_PQ_GetGRule_LvlNum(PQ_WIN eWindow,MS_U16 u16GRuleType)12141 MS_U16 MDrv_PQ_GetGRule_LvlNum(PQ_WIN eWindow, MS_U16 u16GRuleType)
12142 {
12143 #ifdef TRACE_DBG
12144 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
12145 #endif
12146 if (pu32PQInst == NULL)
12147 {
12148 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
12149 return FALSE;
12150 }
12151
12152 stPQ_GetGRule_LvlNum PQArgs;
12153 PQArgs.eWindow = eWindow;
12154 PQArgs.u16GRuleType = u16GRuleType;
12155 PQArgs.u16Ret = 0;
12156 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_GRULE_LV1NUM, (void*)&PQArgs) != 0)
12157 {
12158 printf("Obtain PQ engine fail\n");
12159 return 0;
12160 }
12161 else
12162 {
12163 return PQArgs.u16Ret;
12164 }
12165 }
12166
MDrv_PQ_GetGRule_LvlNum_Ex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16GRuleType,PQ_ENGINE_TYPE ePQEngineType)12167 MS_U16 MDrv_PQ_GetGRule_LvlNum_Ex_U2(void *pInstance,PQ_WIN eWindow, MS_U16 u16GRuleType, PQ_ENGINE_TYPE ePQEngineType)
12168 {
12169 MS_U16 u16Ret = PQ_BIN_IP_NULL;
12170 MS_U8 u8PanelIdx = 0;
12171 PQ_BIN_TYPE enPQBinType = MAX_PQ_BIN_NUM;
12172
12173 if (eWindow == PQ_MAIN_WINDOW)
12174 {
12175 switch (ePQEngineType)
12176 {
12177 case PQ_XC0_STD:
12178 if (gbPQBinEnable)
12179 {
12180 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
12181 enPQBinType = PQ_BIN_STD_MAIN;
12182 }
12183 break;
12184 case PQ_XC0_EXT:
12185 if (gbPQBinEnable)
12186 {
12187 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
12188 enPQBinType = PQ_BIN_EXT_MAIN;
12189 }
12190 break;
12191 case PQ_XC0_CUSTOMER:
12192 if (_bCustomerMainPQEn)
12193 {
12194 u8PanelIdx = PQ_BIN_CUSTOMER_PANEL_INDEX;
12195 enPQBinType = PQ_BIN_CUSTOMER_MAIN;
12196 }
12197 break;
12198 case PQ_XC0_UFSC:
12199 if (_bUFSCPQEn)
12200 {
12201 u8PanelIdx = PQ_BIN_UFSC_PANEL_INDEX;
12202 enPQBinType = PQ_BIN_UFSC;
12203 }
12204 break;
12205 default:
12206 break;
12207 }
12208 }
12209 #if (PQ_ENABLE_PIP)
12210 else if (eWindow == PQ_SUB_WINDOW)
12211 {
12212 switch (ePQEngineType)
12213 {
12214 case PQ_XC0_STD:
12215 if (gbPQBinEnable)
12216 {
12217 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
12218 enPQBinType = PQ_BIN_STD_SUB;
12219 }
12220 break;
12221 case PQ_XC0_EXT:
12222 if (gbPQBinEnable)
12223 {
12224 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
12225 enPQBinType = PQ_BIN_EXT_SUB;
12226 }
12227 break;
12228 case PQ_XC0_CUSTOMER:
12229 if (_bCustomerSubPQEn)
12230 {
12231 u8PanelIdx = PQ_BIN_CUSTOMER_PANEL_INDEX;
12232 enPQBinType = PQ_BIN_CUSTOMER_SUB;
12233 }
12234 break;
12235 case PQ_XC0_UFSC:
12236 break;
12237 default:
12238 break;
12239 }
12240
12241 }
12242 #endif
12243 else
12244 {
12245 MS_ASSERT(0);
12246 }
12247
12248 if (enPQBinType != MAX_PQ_BIN_NUM)
12249 {
12250 if(u16GRuleType >= stPQBinHeaderInfo[enPQBinType].u16GRule_RuleNum)
12251 {
12252 printf("[PQ ERROR] %s:%d\nenPQBinType = %d, u16GruleType = %d out of %d\n", __FUNCTION__, __LINE__, enPQBinType, u16GRuleType, stPQBinHeaderInfo[enPQBinType].u16GRule_RuleNum);
12253 }
12254 else
12255 {
12256 u16Ret = MDrv_PQBin_GetGRule_LvlNum(pInstance,u8PanelIdx, u16GRuleType, &stPQBinHeaderInfo[enPQBinType]);
12257 }
12258 }
12259
12260 return u16Ret;
12261 }
12262
MDrv_PQ_GetGRule_LvlNum_Ex(PQ_WIN eWindow,MS_U16 u16GRuleType,PQ_ENGINE_TYPE ePQEngineType)12263 MS_U16 MDrv_PQ_GetGRule_LvlNum_Ex(PQ_WIN eWindow, MS_U16 u16GRuleType, PQ_ENGINE_TYPE ePQEngineType)
12264 {
12265 #ifdef TRACE_DBG
12266 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
12267 #endif
12268 if (pu32PQInst == NULL)
12269 {
12270 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
12271 return FALSE;
12272 }
12273
12274 stPQ_GetGRule_LvlNum_Ex PQArgs;
12275 PQArgs.eWindow = eWindow;
12276 PQArgs.u16GRuleType = u16GRuleType;
12277 PQArgs.ePQEngineType = ePQEngineType;
12278 PQArgs.u16Ret = 0;
12279 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_GRULE_LV1NUM_EX, (void*)&PQArgs) != 0)
12280 {
12281 printf("Obtain PQ engine fail\n");
12282 return 0;
12283 }
12284 else
12285 {
12286 return PQArgs.u16Ret;
12287 }
12288 }
12289
MDrv_PQ_GetGRule_GRuleNum_U2(void * pInstance,PQ_WIN eWindow)12290 MS_U16 MDrv_PQ_GetGRule_GRuleNum_U2(void* pInstance,PQ_WIN eWindow)
12291 {
12292 MS_U16 u16Ret = 0;
12293
12294 if(gbPQBinEnable)
12295 {
12296 if(eWindow == PQ_MAIN_WINDOW)
12297 {
12298 u16Ret = stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u16GRule_RuleNum;
12299 }
12300 #if (PQ_ENABLE_PIP)
12301 else if(eWindow == PQ_SUB_WINDOW)
12302 {
12303 u16Ret = stPQBinHeaderInfo[PQ_BIN_STD_SUB].u16GRule_RuleNum;
12304 }
12305 else
12306 {
12307 printf("=Error=%s, %d, =Not support case \n", __FUNCTION__, __LINE__);
12308 }
12309 #endif
12310 }
12311
12312 return u16Ret;
12313 }
MDrv_PQ_GetGRule_GRuleNum(PQ_WIN eWindow)12314 MS_U16 MDrv_PQ_GetGRule_GRuleNum(PQ_WIN eWindow)
12315 {
12316 #ifdef TRACE_DBG
12317 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
12318 #endif
12319 if (pu32PQInst == NULL)
12320 {
12321 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
12322 return FALSE;
12323 }
12324
12325 stPQ_GetGRule_GRuleNum PQArgs;
12326 PQArgs.eWindow = eWindow;
12327 PQArgs.u16Ret = 0;
12328 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_GRULE_GRULENUM, (void*)&PQArgs) != 0)
12329 {
12330 printf("Obtain PQ engine fail\n");
12331 return 0;
12332 }
12333 else
12334 {
12335 return PQArgs.u16Ret;
12336 }
12337 }
12338
MDrv_PQ_GetGRule_LevelIndex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16GRuleLevelIndex)12339 MS_U16 MDrv_PQ_GetGRule_LevelIndex_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16GRuleLevelIndex)
12340 {
12341 MS_U16 u16Ret = 0;
12342 PQ_BIN_TYPE enPQBinTypeMain = PQ_BIN_STD_MAIN;
12343 #if (PQ_ENABLE_PIP)
12344 PQ_BIN_TYPE enPQBinTypeSub = PQ_BIN_STD_SUB;
12345 #endif
12346 MS_U16 u16PanelIdx = 0;
12347 if(eWindow == PQ_MAIN_WINDOW)
12348 {
12349
12350 if(gbPQBinEnable)
12351 {
12352
12353 if(u16GRuleType >= stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u16GRule_RuleNum)
12354 {
12355 if(_bCustomerMainPQEn)
12356 {
12357 PQGRULE_DBG(printf("(%s, %d)GRuleType(%u) is bigger than STD PQ's(%u), so consider it as CUSTOMER PQ's GRule Type\n",
12358 __FUNCTION__, __LINE__, u16GRuleType, stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u16GRule_RuleNum));
12359 u16GRuleType = u16GRuleType - stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u16GRule_RuleNum;
12360 enPQBinTypeMain = PQ_BIN_CUSTOMER_MAIN;
12361 u16PanelIdx = PQ_BIN_CUSTOMER_PANEL_INDEX;
12362 if(u16GRuleType >= stPQBinHeaderInfo[PQ_BIN_CUSTOMER_MAIN].u16GRule_RuleNum)
12363 {
12364 printf("CustomerPQ: =ERROR!!!=%s, %d, =%d, out of %d, =\n", __FUNCTION__, __LINE__, u16GRuleType, stPQBinHeaderInfo[PQ_BIN_CUSTOMER_MAIN].u16GRule_RuleNum);
12365 return 0;
12366 }
12367 }
12368 else
12369 {
12370 printf("=ERROR!!!=%s, %d, =%d, out of %d, =\n", __FUNCTION__, __LINE__, u16GRuleType, stPQBinHeaderInfo[PQ_BIN_STD_MAIN].u16GRule_RuleNum);
12371 return 0;
12372 }
12373 }
12374 else
12375 {
12376 u16PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
12377 }
12378
12379 u16Ret = (MS_U8) MDrv_PQBin_GetGRule_LevelIndex(pInstance,u16PanelIdx,
12380 u16GRuleType,
12381 u16GRuleLevelIndex,
12382 &stPQBinHeaderInfo[enPQBinTypeMain]);
12383 }
12384 else
12385 {
12386 u16Ret = MDrv_PQ_GetGRule_LevelIndex_(MAIN,pInstance, (MS_U8)u16GRuleType, (MS_U8)u16GRuleLevelIndex);
12387 }
12388 }
12389 #if (PQ_ENABLE_PIP)
12390 else if(eWindow == PQ_SUB_WINDOW)
12391 {
12392 if(gbPQBinEnable)
12393 {
12394 if(u16GRuleType >= stPQBinHeaderInfo[PQ_BIN_STD_SUB].u16GRule_RuleNum)
12395 {
12396 if(_bCustomerSubPQEn)
12397 {
12398 PQGRULE_DBG(printf("(%s, %d)GRuleType(%u) is bigger than STD PQ's(%u), so consider it as CUSTOMER PQ's GRule Type\n",
12399 __FUNCTION__, __LINE__, u16GRuleType, stPQBinHeaderInfo[PQ_BIN_STD_SUB].u16GRule_RuleNum));
12400 u16GRuleType = u16GRuleType - stPQBinHeaderInfo[PQ_BIN_STD_SUB].u16GRule_RuleNum;
12401 enPQBinTypeSub = PQ_BIN_CUSTOMER_SUB;
12402 u16PanelIdx = PQ_BIN_CUSTOMER_PANEL_INDEX;
12403 if(u16GRuleType >= stPQBinHeaderInfo[PQ_BIN_CUSTOMER_SUB].u16GRule_RuleNum)
12404 {
12405 printf("CustomerPQ: =ERROR!!!=%s, %d, =%d, out of %d, =\n", __FUNCTION__, __LINE__, u16GRuleType, stPQBinHeaderInfo[PQ_BIN_CUSTOMER_SUB].u16GRule_RuleNum);
12406 return 0;
12407 }
12408 }
12409 else
12410 {
12411 printf("=ERROR!!!=%s, %d, =%d, out of %d, =\n", __FUNCTION__, __LINE__, u16GRuleType, stPQBinHeaderInfo[PQ_BIN_STD_SUB].u16GRule_RuleNum);
12412 return 0;
12413 }
12414 }
12415 else
12416 {
12417 u16PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
12418 }
12419
12420 u16Ret = (MS_U8) MDrv_PQBin_GetGRule_LevelIndex(pInstance,u16PanelIdx,
12421 u16GRuleType,
12422 u16GRuleLevelIndex,
12423 &stPQBinHeaderInfo[enPQBinTypeSub]);
12424 }
12425 else
12426 {
12427 u16Ret = MDrv_PQ_GetGRule_LevelIndex_(SUB,pInstance, (MS_U8)u16GRuleType, (MS_U8)u16GRuleLevelIndex);
12428 }
12429 }
12430 #endif
12431 else
12432 {
12433 MS_ASSERT(0);
12434 }
12435 return u16Ret;
12436 }
MDrv_PQ_GetGRule_LevelIndex(PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16GRuleLevelIndex)12437 MS_U16 MDrv_PQ_GetGRule_LevelIndex(PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16GRuleLevelIndex)
12438 {
12439 #ifdef TRACE_DBG
12440 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
12441 #endif
12442 if (pu32PQInst == NULL)
12443 {
12444 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
12445 return FALSE;
12446 }
12447
12448 stPQ_GetGRule_LevelIndex PQArgs;
12449 PQArgs.eWindow = eWindow;
12450 PQArgs.u16GRuleType = u16GRuleType;
12451 PQArgs.u16GRuleLevelIndex = u16GRuleLevelIndex;
12452 PQArgs.u16Ret = 0;
12453 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_GRULE_LEVELINDEX, (void*)&PQArgs) != 0)
12454 {
12455 printf("Obtain PQ engine fail\n");
12456 return 0;
12457 }
12458 else
12459 {
12460 return PQArgs.u16Ret;
12461 }
12462 }
12463
MDrv_PQ_GetGRule_LevelIndex_Ex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16GRuleLevelIndex,PQ_ENGINE_TYPE ePQEngineType)12464 MS_U16 MDrv_PQ_GetGRule_LevelIndex_Ex_U2(void *pInstance,PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16GRuleLevelIndex, PQ_ENGINE_TYPE ePQEngineType)
12465 {
12466 MS_U16 u16Ret = PQ_BIN_IP_NULL;
12467 MS_U8 u8PanelIdx = 0;
12468 PQ_BIN_TYPE enPQBinType = MAX_PQ_BIN_NUM;
12469
12470 if (eWindow == PQ_MAIN_WINDOW)
12471 {
12472 switch (ePQEngineType)
12473 {
12474 case PQ_XC0_STD:
12475 if (gbPQBinEnable)
12476 {
12477 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
12478 enPQBinType = PQ_BIN_STD_MAIN;
12479 }
12480 else
12481 {
12482 u16Ret = MDrv_PQ_GetGRule_LevelIndex_(MAIN, pInstance,(MS_U8)u16GRuleType, (MS_U8)u16GRuleLevelIndex);
12483 }
12484 break;
12485 case PQ_XC0_EXT:
12486 if (gbPQBinEnable)
12487 {
12488 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
12489 enPQBinType = PQ_BIN_EXT_MAIN;
12490 }
12491 break;
12492 case PQ_XC0_CUSTOMER:
12493 if (_bCustomerMainPQEn)
12494 {
12495 u8PanelIdx = PQ_BIN_CUSTOMER_PANEL_INDEX;
12496 enPQBinType = PQ_BIN_CUSTOMER_MAIN;
12497 }
12498 break;
12499 case PQ_XC0_UFSC:
12500 if (_bUFSCPQEn)
12501 {
12502 u8PanelIdx = MDrv_PQBin_GetPanelIdx_UFSC(pInstance);
12503 enPQBinType = PQ_BIN_UFSC;
12504 }
12505 break;
12506 default:
12507 break;
12508 }
12509 }
12510 #if (PQ_ENABLE_PIP)
12511 else if (eWindow == PQ_SUB_WINDOW)
12512 {
12513 switch (ePQEngineType)
12514 {
12515 case PQ_XC0_STD:
12516 if (gbPQBinEnable)
12517 {
12518 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
12519 enPQBinType = PQ_BIN_STD_SUB;
12520 }
12521 else
12522 {
12523 u16Ret = MDrv_PQ_GetGRule_LevelIndex_(SUB, pInstance,(MS_U8)u16GRuleType, (MS_U8)u16GRuleLevelIndex);
12524 }
12525 break;
12526 case PQ_XC0_EXT:
12527 if (gbPQBinEnable)
12528 {
12529 u8PanelIdx = MDrv_PQBin_GetPanelIdx(pInstance);
12530 enPQBinType = PQ_BIN_EXT_SUB;
12531 }
12532 break;
12533 case PQ_XC0_CUSTOMER:
12534 if (_bCustomerSubPQEn)
12535 {
12536 u8PanelIdx = PQ_BIN_CUSTOMER_PANEL_INDEX;
12537 enPQBinType = PQ_BIN_CUSTOMER_SUB;
12538 }
12539 break;
12540 case PQ_XC0_UFSC:
12541 break;
12542 default:
12543 break;
12544 }
12545
12546 }
12547 #endif
12548 else
12549 {
12550 MS_ASSERT(0);
12551 }
12552
12553 if (enPQBinType != MAX_PQ_BIN_NUM)
12554 {
12555 if(u16GRuleType >= stPQBinHeaderInfo[enPQBinType].u16GRule_RuleNum)
12556 {
12557 printf("[PQ ERROR] %s:%d\nenPQBinType = %d, u16GruleType = %d out of %d\n", __FUNCTION__, __LINE__, enPQBinType, u16GRuleType, stPQBinHeaderInfo[enPQBinType].u16GRule_RuleNum);
12558 }
12559 else
12560 {
12561 u16Ret = MDrv_PQBin_GetGRule_LevelIndex(pInstance,
12562 u8PanelIdx,
12563 u16GRuleType,
12564 u16GRuleLevelIndex,
12565 &stPQBinHeaderInfo[enPQBinType]);
12566 }
12567 }
12568
12569 return u16Ret;
12570 }
12571
MDrv_PQ_GetGRule_LevelIndex_Ex(PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16GRuleLevelIndex,PQ_ENGINE_TYPE ePQEngineType)12572 MS_U16 MDrv_PQ_GetGRule_LevelIndex_Ex(PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16GRuleLevelIndex, PQ_ENGINE_TYPE ePQEngineType)
12573 {
12574 #ifdef TRACE_DBG
12575 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
12576 #endif
12577 if (pu32PQInst == NULL)
12578 {
12579 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
12580 return FALSE;
12581 }
12582
12583 stPQ_GetGRule_LevelIndex_Ex PQArgs;
12584 PQArgs.eWindow = eWindow;
12585 PQArgs.u16GRuleType = u16GRuleType;
12586 PQArgs.u16GRuleLevelIndex = u16GRuleLevelIndex;
12587 PQArgs.ePQEngineType = ePQEngineType;
12588 PQArgs.u16Ret = 0;
12589 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_GRULE_LEVELINDEX_EX, (void*)&PQArgs) != 0)
12590 {
12591 printf("Obtain PQ engine fail\n");
12592 return 0;
12593 }
12594 else
12595 {
12596 return PQArgs.u16Ret;
12597 }
12598 }
12599
MDrv_PQ_GetGRule_IPIndex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16GRuleIPIndex)12600 MS_U16 MDrv_PQ_GetGRule_IPIndex_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16GRuleIPIndex)
12601 {
12602 MS_U16 u16Ret = 0;
12603 if(eWindow == PQ_MAIN_WINDOW)
12604 {
12605 if(gbPQBinEnable)
12606 {
12607 u16Ret = MDrv_PQBin_GetGRule_IPIndex(pInstance,u16GRuleType,
12608 u16GRuleIPIndex,
12609 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
12610 }
12611 else
12612 {
12613 u16Ret = MDrv_PQ_GetGRule_IPIndex_(MAIN,pInstance, (MS_U8)u16GRuleType, (MS_U8)u16GRuleIPIndex);
12614 }
12615 }
12616 #if (PQ_ENABLE_PIP)
12617 else if(eWindow == PQ_SUB_WINDOW)
12618 {
12619 if(gbPQBinEnable)
12620 {
12621 u16Ret = MDrv_PQBin_GetGRule_IPIndex(pInstance,u16GRuleType,
12622 u16GRuleIPIndex,
12623 &stPQBinHeaderInfo[PQ_BIN_STD_SUB]);
12624 }
12625 else
12626 {
12627 u16Ret = MDrv_PQ_GetGRule_IPIndex_(SUB,pInstance, (MS_U8)u16GRuleType, (MS_U8)u16GRuleIPIndex);
12628 }
12629 }
12630 #endif
12631 else
12632 {
12633 MS_ASSERT(0);
12634 }
12635
12636 return u16Ret;
12637 }
MDrv_PQ_GetGRule_IPIndex(PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16GRuleIPIndex)12638 MS_U16 MDrv_PQ_GetGRule_IPIndex(PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16GRuleIPIndex)
12639 {
12640 #ifdef TRACE_DBG
12641 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
12642 #endif
12643 if (pu32PQInst == NULL)
12644 {
12645 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
12646 return FALSE;
12647 }
12648
12649 stPQ_GetGRule_IPIndex PQArgs;
12650 PQArgs.eWindow = eWindow;
12651 PQArgs.u16GRuleType = u16GRuleType;
12652 PQArgs.u16GRuleIPIndex = u16GRuleIPIndex;
12653 PQArgs.u16Ret = 0;
12654 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_GRULE_IPINDEX, (void*)&PQArgs) != 0)
12655 {
12656 printf("Obtain PQ engine fail\n");
12657 return 0;
12658 }
12659 else
12660 {
12661 return PQArgs.u16Ret;
12662 }
12663 }
12664
MDrv_PQ_GetGRule_IPIndex_Ex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16GRuleIPIndex,PQ_ENGINE_TYPE ePQEngineType)12665 MS_U16 MDrv_PQ_GetGRule_IPIndex_Ex_U2(void *pInstance,PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16GRuleIPIndex, PQ_ENGINE_TYPE ePQEngineType)
12666 {
12667 MS_U16 u16Ret = PQ_BIN_IP_NULL;
12668 PQ_BIN_TYPE enPQBinType = MAX_PQ_BIN_NUM;
12669
12670 if (eWindow == PQ_MAIN_WINDOW)
12671 {
12672 switch (ePQEngineType)
12673 {
12674 case PQ_XC0_STD:
12675 if (gbPQBinEnable)
12676 {
12677 enPQBinType = PQ_BIN_STD_MAIN;
12678 }
12679 else
12680 {
12681 u16Ret = MDrv_PQ_GetGRule_IPIndex_(MAIN,pInstance, (MS_U8)u16GRuleType, (MS_U8)u16GRuleIPIndex);
12682 }
12683 break;
12684 case PQ_XC0_EXT:
12685 if (gbPQBinEnable)
12686 {
12687 enPQBinType = PQ_BIN_EXT_MAIN;
12688 }
12689 break;
12690 case PQ_XC0_CUSTOMER:
12691 if (_bCustomerMainPQEn)
12692 {
12693 enPQBinType = PQ_BIN_CUSTOMER_MAIN;
12694 }
12695 break;
12696 case PQ_XC0_UFSC:
12697 if (_bUFSCPQEn)
12698 {
12699 enPQBinType = PQ_BIN_UFSC;
12700 }
12701 break;
12702 default:
12703 break;
12704 }
12705 }
12706 #if (PQ_ENABLE_PIP)
12707 else if (eWindow == PQ_SUB_WINDOW)
12708 {
12709 switch (ePQEngineType)
12710 {
12711 case PQ_XC0_STD:
12712 if (gbPQBinEnable)
12713 {
12714 enPQBinType = PQ_BIN_STD_SUB;
12715 }
12716 else
12717 {
12718 u16Ret = MDrv_PQ_GetGRule_IPIndex_(SUB,pInstance, (MS_U8)u16GRuleType, (MS_U8)u16GRuleIPIndex);
12719 }
12720 break;
12721 case PQ_XC0_EXT:
12722 if (gbPQBinEnable)
12723 {
12724 enPQBinType = PQ_BIN_EXT_SUB;
12725 }
12726 break;
12727 case PQ_XC0_CUSTOMER:
12728 if (_bCustomerSubPQEn)
12729 {
12730 enPQBinType = PQ_BIN_CUSTOMER_SUB;
12731 }
12732 break;
12733 case PQ_XC0_UFSC:
12734 break;
12735 default:
12736 break;
12737 }
12738
12739 }
12740 #endif
12741 else
12742 {
12743 MS_ASSERT(0);
12744 }
12745
12746 if (enPQBinType != MAX_PQ_BIN_NUM)
12747 {
12748 u16Ret = MDrv_PQBin_GetGRule_IPIndex(pInstance,
12749 u16GRuleType,
12750 u16GRuleIPIndex,
12751 &stPQBinHeaderInfo[enPQBinType]);
12752 }
12753
12754 return u16Ret;
12755 }
12756
MDrv_PQ_GetGRule_IPIndex_Ex(PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16GRuleIPIndex,PQ_ENGINE_TYPE ePQEngineType)12757 MS_U16 MDrv_PQ_GetGRule_IPIndex_Ex(PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16GRuleIPIndex, PQ_ENGINE_TYPE ePQEngineType)
12758 {
12759 #ifdef TRACE_DBG
12760 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
12761 #endif
12762 if (pu32PQInst == NULL)
12763 {
12764 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
12765 return FALSE;
12766 }
12767
12768 stPQ_GetGRule_IPIndex_Ex PQArgs;
12769 PQArgs.eWindow = eWindow;
12770 PQArgs.u16GRuleType = u16GRuleType;
12771 PQArgs.u16GRuleIPIndex = u16GRuleIPIndex;
12772 PQArgs.ePQEngineType = ePQEngineType;
12773 PQArgs.u16Ret = 0;
12774 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_GRULE_IPINDEX_EX, (void*)&PQArgs) != 0)
12775 {
12776 printf("Obtain PQ engine fail\n");
12777 return 0;
12778 }
12779 else
12780 {
12781 return PQArgs.u16Ret;
12782 }
12783 }
12784
MDrv_PQ_GetGRule_TableIndex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16PQ_NRIdx,MS_U16 u16GRuleIPIndex)12785 MS_U16 MDrv_PQ_GetGRule_TableIndex_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16PQ_NRIdx, MS_U16 u16GRuleIPIndex)
12786 {
12787 MS_U16 u16Ret = 0;
12788 if(eWindow == PQ_MAIN_WINDOW)
12789 {
12790 if(gbPQBinEnable)
12791 {
12792 u16Ret = (MS_U8) MDrv_PQBin_GetGRule_TableIndex(pInstance,u16GRuleType,
12793 _u16PQSrcType[eWindow],
12794 u16PQ_NRIdx,
12795 u16GRuleIPIndex,
12796 &stPQBinHeaderInfo[PQ_BIN_STD_MAIN]);
12797 }
12798 else
12799 {
12800 u16Ret = MDrv_PQ_GetGRule_TableIndex_(MAIN,pInstance, (MS_U8)u16GRuleType, _u16PQSrcType[eWindow], (MS_U8)u16PQ_NRIdx, (MS_U8)u16GRuleIPIndex);
12801 }
12802 }
12803 #if (PQ_ENABLE_PIP)
12804 else if(eWindow == PQ_SUB_WINDOW)
12805 {
12806 if(gbPQBinEnable)
12807 {
12808 u16Ret = (MS_U8) MDrv_PQBin_GetGRule_TableIndex(pInstance,u16GRuleType,
12809 _u16PQSrcType[eWindow],
12810 u16PQ_NRIdx,
12811 u16GRuleIPIndex,
12812 &stPQBinHeaderInfo[PQ_BIN_STD_SUB]);
12813 }
12814 else
12815 {
12816 u16Ret = MDrv_PQ_GetGRule_TableIndex_(SUB,pInstance, (MS_U8)u16GRuleType, _u16PQSrcType[eWindow], (MS_U8)u16PQ_NRIdx, (MS_U8)u16GRuleIPIndex);
12817 }
12818 }
12819 #endif
12820 else
12821 {
12822 MS_ASSERT(0);
12823 }
12824
12825 return u16Ret;
12826 }
MDrv_PQ_GetGRule_TableIndex(PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16PQ_NRIdx,MS_U16 u16GRuleIPIndex)12827 MS_U16 MDrv_PQ_GetGRule_TableIndex(PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16PQ_NRIdx, MS_U16 u16GRuleIPIndex)
12828 {
12829 #ifdef TRACE_DBG
12830 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
12831 #endif
12832 if (pu32PQInst == NULL)
12833 {
12834 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
12835 {
12836 printf("UtopiaOpen PQ failed\n");
12837 return FALSE;
12838 }
12839 }
12840
12841 stPQ_GetGRule_TableIndex PQArgs;
12842 PQArgs.eWindow = eWindow;
12843 PQArgs.u16GRuleType = u16GRuleType;
12844 PQArgs.u16PQ_NRIdx = u16PQ_NRIdx;
12845 PQArgs.u16GRuleIPIndex = u16GRuleIPIndex;
12846 PQArgs.u16Ret = 0;
12847 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_GRULE_TABLEINDEX, (void*)&PQArgs) != 0)
12848 {
12849 printf("Obtain PQ engine fail\n");
12850 return 0;
12851 }
12852 else
12853 {
12854 return PQArgs.u16Ret;
12855 }
12856 }
12857
MDrv_PQ_GetGRule_TableIndex_Ex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16PQ_NRIdx,MS_U16 u16GRuleIPIndex,PQ_ENGINE_TYPE ePQEngineType)12858 MS_U16 MDrv_PQ_GetGRule_TableIndex_Ex_U2(void *pInstance,PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16PQ_NRIdx, MS_U16 u16GRuleIPIndex, PQ_ENGINE_TYPE ePQEngineType)
12859 {
12860 MS_U16 u16Ret = PQ_BIN_IP_NULL, u16SrcIdx = 0;
12861 PQ_BIN_TYPE enPQBinType = MAX_PQ_BIN_NUM;
12862
12863 if (eWindow == PQ_MAIN_WINDOW)
12864 {
12865 switch (ePQEngineType)
12866 {
12867 case PQ_XC0_STD:
12868 u16SrcIdx = _u16PQSrcType[eWindow];
12869 if (gbPQBinEnable)
12870 {
12871 enPQBinType = PQ_BIN_STD_MAIN;
12872 }
12873 else
12874 {
12875 u16Ret = MDrv_PQ_GetGRule_TableIndex_(MAIN, pInstance,(MS_U8)u16GRuleType, u16SrcIdx, (MS_U8)u16PQ_NRIdx, (MS_U8)u16GRuleIPIndex);
12876 }
12877 break;
12878 case PQ_XC0_EXT:
12879 if (gbPQBinEnable)
12880 {
12881 u16SrcIdx = _u16PQSrcType[eWindow];
12882 enPQBinType = PQ_BIN_EXT_MAIN;
12883 }
12884 break;
12885 case PQ_XC0_CUSTOMER:
12886 if (_bCustomerMainPQEn)
12887 {
12888 u16SrcIdx = _u16PQSrcType[eWindow];
12889 enPQBinType = PQ_BIN_CUSTOMER_MAIN;
12890 }
12891 break;
12892 case PQ_XC0_UFSC:
12893 if (_bUFSCPQEn)
12894 {
12895 u16SrcIdx = _u16PQSrcType_UFSC[eWindow];
12896 enPQBinType = PQ_BIN_UFSC;
12897 }
12898 break;
12899 default:
12900 break;
12901 }
12902 }
12903 #if (PQ_ENABLE_PIP)
12904 else if (eWindow == PQ_SUB_WINDOW)
12905 {
12906 switch (ePQEngineType)
12907 {
12908 case PQ_XC0_STD:
12909 u16SrcIdx = _u16PQSrcType[eWindow];
12910 if (gbPQBinEnable)
12911 {
12912 enPQBinType = PQ_BIN_STD_SUB;
12913 }
12914 else
12915 {
12916 u16Ret = MDrv_PQ_GetGRule_TableIndex_(SUB,pInstance, (MS_U8)u16GRuleType, u16SrcIdx, (MS_U8)u16PQ_NRIdx, (MS_U8)u16GRuleIPIndex);
12917 }
12918 break;
12919 case PQ_XC0_EXT:
12920 if (gbPQBinEnable)
12921 {
12922 u16SrcIdx = _u16PQSrcType[eWindow];
12923 enPQBinType = PQ_BIN_EXT_SUB;
12924 }
12925 break;
12926 case PQ_XC0_CUSTOMER:
12927 if (_bCustomerSubPQEn)
12928 {
12929 u16SrcIdx = _u16PQSrcType[eWindow];
12930 enPQBinType = PQ_BIN_CUSTOMER_SUB;
12931 }
12932 break;
12933 case PQ_XC0_UFSC:
12934 break;
12935 default:
12936 break;
12937 }
12938
12939 }
12940 #endif
12941 else
12942 {
12943 MS_ASSERT(0);
12944 }
12945
12946 if (enPQBinType != MAX_PQ_BIN_NUM)
12947 {
12948 u16Ret = MDrv_PQBin_GetGRule_TableIndex(pInstance,
12949 u16GRuleType,
12950 u16SrcIdx,
12951 u16PQ_NRIdx,
12952 u16GRuleIPIndex,
12953 &stPQBinHeaderInfo[enPQBinType]);
12954 }
12955
12956 return u16Ret;
12957 }
12958
MDrv_PQ_GetGRule_TableIndex_Ex(PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16PQ_NRIdx,MS_U16 u16GRuleIPIndex,PQ_ENGINE_TYPE ePQEngineType)12959 MS_U16 MDrv_PQ_GetGRule_TableIndex_Ex(PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16PQ_NRIdx, MS_U16 u16GRuleIPIndex, PQ_ENGINE_TYPE ePQEngineType)
12960 {
12961 #ifdef TRACE_DBG
12962 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
12963 #endif
12964 if (pu32PQInst == NULL)
12965 {
12966 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
12967 {
12968 printf("UtopiaOpen PQ failed\n");
12969 return FALSE;
12970 }
12971 }
12972
12973 stPQ_GetGRule_TableIndex_Ex PQArgs;
12974 PQArgs.eWindow = eWindow;
12975 PQArgs.u16GRuleType = u16GRuleType;
12976 PQArgs.u16PQ_NRIdx = u16PQ_NRIdx;
12977 PQArgs.u16GRuleIPIndex = u16GRuleIPIndex;
12978 PQArgs.ePQEngineType = ePQEngineType;
12979 PQArgs.u16Ret = 0;
12980 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_GRULE_TABLEINDEX_EX, (void*)&PQArgs) != 0)
12981 {
12982 printf("Obtain PQ engine fail\n");
12983 return 0;
12984 }
12985 else
12986 {
12987 return PQArgs.u16Ret;
12988 }
12989 }
12990
MDrv_PQ_GetCustomerGRule_IPIndex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16GRuleIPIndex)12991 MS_U16 MDrv_PQ_GetCustomerGRule_IPIndex_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16GRuleIPIndex)
12992 {
12993 if(_bCustomerMainPQEn || _bCustomerSubPQEn)
12994 {
12995 MS_U16 u16Ret = 0;
12996 if(eWindow == PQ_MAIN_WINDOW)
12997 {
12998 if(gbPQBinEnable)
12999 {
13000 u16Ret = MDrv_PQBin_GetGRule_IPIndex(pInstance,u16GRuleType,
13001 u16GRuleIPIndex,
13002 &stPQBinHeaderInfo[PQ_BIN_CUSTOMER_MAIN]);
13003 }
13004 }
13005 #if (PQ_ENABLE_PIP)
13006 else if(eWindow == PQ_SUB_WINDOW)
13007 {
13008 if(gbPQBinEnable)
13009 {
13010 u16Ret = MDrv_PQBin_GetGRule_IPIndex(pInstance,u16GRuleType,
13011 u16GRuleIPIndex,
13012 &stPQBinHeaderInfo[PQ_BIN_CUSTOMER_SUB]);
13013 }
13014 }
13015 #endif
13016 else
13017 {
13018 MS_ASSERT(0);
13019 }
13020
13021 return u16Ret;
13022 }
13023 else
13024 {
13025 MS_ASSERT(0);
13026 return 0;
13027 }
13028 }
MDrv_PQ_GetCustomerGRule_IPIndex(PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16GRuleIPIndex)13029 MS_U16 MDrv_PQ_GetCustomerGRule_IPIndex(PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16GRuleIPIndex)
13030 {
13031 #ifdef TRACE_DBG
13032 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
13033 #endif
13034 if (pu32PQInst == NULL)
13035 {
13036 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
13037 return FALSE;
13038 }
13039
13040 stPQ_GetCustomerGRule_IPIndex PQArgs;
13041 PQArgs.eWindow = eWindow;
13042 PQArgs.u16GRuleType = u16GRuleType;
13043 PQArgs.u16GRuleIPIndex = u16GRuleIPIndex;
13044 PQArgs.u16Ret = 0;
13045 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_CUSTOMERGRULE_IPINDEX, (void*)&PQArgs) != 0)
13046 {
13047 printf("Obtain PQ engine fail\n");
13048 return 0;
13049 }
13050 else
13051 {
13052 return PQArgs.u16Ret;
13053 }
13054 }
13055
13056
MDrv_PQ_GetGRule_CustomerTableIndex_U2(void * pInstance,PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16PQ_NRIdx,MS_U16 u16GRuleIPIndex)13057 MS_U16 MDrv_PQ_GetGRule_CustomerTableIndex_U2(void* pInstance,PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16PQ_NRIdx, MS_U16 u16GRuleIPIndex)
13058 {
13059 if(_bCustomerMainPQEn || _bCustomerSubPQEn)
13060 {
13061 MS_U16 u16Ret = 0;
13062 if(eWindow == PQ_MAIN_WINDOW)
13063 {
13064 if(gbPQBinEnable)
13065 {
13066 u16Ret = (MS_U8) MDrv_PQBin_GetGRule_TableIndex(pInstance,u16GRuleType,
13067 _u16PQSrcType[eWindow],
13068 u16PQ_NRIdx,
13069 u16GRuleIPIndex,
13070 &stPQBinHeaderInfo[PQ_BIN_CUSTOMER_MAIN]);
13071 }
13072 else
13073 {
13074 u16Ret = MDrv_PQ_GetGRule_TableIndex_(MAIN,pInstance, (MS_U8)u16GRuleType, _u16PQSrcType[eWindow], (MS_U8)u16PQ_NRIdx, (MS_U8)u16GRuleIPIndex);
13075 }
13076 }
13077 #if (PQ_ENABLE_PIP)
13078 else if(eWindow == PQ_SUB_WINDOW)
13079 {
13080 if(gbPQBinEnable)
13081 {
13082 u16Ret = (MS_U8) MDrv_PQBin_GetGRule_TableIndex(pInstance,u16GRuleType,
13083 _u16PQSrcType[eWindow],
13084 u16PQ_NRIdx,
13085 u16GRuleIPIndex,
13086 &stPQBinHeaderInfo[PQ_BIN_CUSTOMER_SUB]);
13087 }
13088 else
13089 {
13090 u16Ret = MDrv_PQ_GetGRule_TableIndex_(SUB,pInstance, (MS_U8)u16GRuleType, _u16PQSrcType[eWindow], (MS_U8)u16PQ_NRIdx, (MS_U8)u16GRuleIPIndex);
13091 }
13092 }
13093 #endif
13094 else
13095 {
13096 MS_ASSERT(0);
13097 }
13098
13099 return u16Ret;
13100 }
13101 else
13102 {
13103 return 0;
13104 }
13105 }
MDrv_PQ_GetGRule_CustomerTableIndex(PQ_WIN eWindow,MS_U16 u16GRuleType,MS_U16 u16PQ_NRIdx,MS_U16 u16GRuleIPIndex)13106 MS_U16 MDrv_PQ_GetGRule_CustomerTableIndex(PQ_WIN eWindow, MS_U16 u16GRuleType, MS_U16 u16PQ_NRIdx, MS_U16 u16GRuleIPIndex)
13107 {
13108 #ifdef TRACE_DBG
13109 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
13110 #endif
13111 if (pu32PQInst == NULL)
13112 {
13113 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
13114 return FALSE;
13115 }
13116
13117 stPQ_GetGRule_CustomerTableIndex PQArgs;
13118 PQArgs.eWindow = eWindow;
13119 PQArgs.u16GRuleType = u16GRuleType;
13120 PQArgs.u16PQ_NRIdx = u16PQ_NRIdx;
13121 PQArgs.u16GRuleIPIndex = u16GRuleIPIndex;
13122 PQArgs.u16Ret = 0;
13123 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_CUSTOMERGRULE_TABLEINDEX, (void*)&PQArgs) != 0)
13124 {
13125 printf("Obtain PQ engine fail\n");
13126 return 0;
13127 }
13128 else
13129 {
13130 return PQArgs.u16Ret;
13131 }
13132 }
13133
MDrv_PQ_Set_xvYCC_MatrixCoefficient_U2(void * pInstance,MS_U64 u64Red_x,MS_U64 u64Red_y,MS_U64 u64Green_x,MS_U64 u64Green_y,MS_U64 u64Blue_x,MS_U64 u64Blue_y,MS_U64 u64White_x,MS_U64 u64White_y,PQ_WIN eWindow)13134 MS_BOOL MDrv_PQ_Set_xvYCC_MatrixCoefficient_U2(void* pInstance,
13135 MS_U64 u64Red_x, MS_U64 u64Red_y,
13136 MS_U64 u64Green_x, MS_U64 u64Green_y,
13137 MS_U64 u64Blue_x, MS_U64 u64Blue_y,
13138 MS_U64 u64White_x, MS_U64 u64White_y,
13139 PQ_WIN eWindow)
13140 {
13141 MS_U32 u32idx, s32H_idx,u32V_idx, u32cnt;
13142 MS_U64 s64Mat[3][ 3] = { {0},{0},{0}};
13143 MS_S64 s64sRGBMat[3][3];
13144 MS_S64 s64RGB3x3[ 3][ 3];
13145 MS_S32 s32RGB3x3[ 3][ 3];
13146 MS_U32 __attribute__((__unused__))u32data_invalid[ 9];
13147 MS_S32 s32fix_value; //format s2.10
13148 MS_S64 dbUp_value, dbDown_value;
13149 MS_S64 dbHistogramSum[3];
13150 MS_S64 dbMaxHistogramSum;
13151
13152 if (eWindow >= PQ_MAX_WINDOW)
13153 {
13154 printf("Invalid window type, please check ! \n");
13155 return FALSE;
13156 }
13157
13158 for(u32idx=0; u32idx<9; u32idx++)
13159 {
13160 u32data_invalid[ u32idx] = 0;
13161 }
13162
13163 // calculation inverse Matrix Mat[3][3]
13164 // u32data_invalid is used when the inverse of matrix is not existed
13165 // for (1,1)
13166 dbUp_value = (MS_S64)(u64White_y*(-u64Blue_y + u64Green_x*u64Blue_y + u64Green_y - u64Blue_x*u64Green_y) ) ;
13167 dbDown_value = (MS_S64)(-u64Green_x*u64White_y + u64Blue_x*u64White_y + u64Green_x*u64Blue_y - u64Blue_y*u64White_x + u64Green_y*u64White_x - u64Blue_x*u64Green_y);
13168 if( dbDown_value ==0)\
13169 {
13170 u32data_invalid[ 0] = 1;
13171 }
13172 else
13173 {
13174 u32data_invalid[ 0] =0;
13175 s64Mat[ 0][ 0] = do_div(dbUp_value,dbDown_value);
13176 }
13177
13178 // for (1,2)
13179 dbUp_value = (MS_S64)(u64White_y*(u64Green_x*u64Blue_y -u64Green_x + u64Blue_x - u64Blue_x*u64Green_y)) ;
13180 dbDown_value = (MS_S64)(-u64Green_x*u64White_y + u64Blue_x*u64White_y + u64Green_x*u64Blue_y - u64Blue_y*u64White_x + u64Green_y*u64White_x - u64Blue_x*u64Green_y);
13181 if( dbDown_value ==0)
13182 {
13183 u32data_invalid[ 1] = 1;
13184 }
13185 else
13186 {
13187 u32data_invalid[ 1] =0;
13188 s64Mat[ 0][ 1] = do_div(dbUp_value,dbDown_value);
13189 }
13190
13191 // for (1,3)
13192 dbUp_value = (MS_S64) ( u64White_y* ( u64Green_x*u64Blue_y - u64Blue_x*u64Green_y) ) ;
13193 dbDown_value = (MS_S64) ( -u64Green_x*u64White_y + u64Blue_x*u64White_y + u64Green_x*u64Blue_y - u64Blue_y*u64White_x + u64Green_y*u64White_x - u64Blue_x*u64Green_y);
13194 if( dbDown_value ==0)
13195 {
13196 u32data_invalid[ 2] = 1;
13197 }
13198 else
13199 {
13200 u32data_invalid[ 2] =0;
13201 s64Mat[ 0][ 2] = do_div(dbUp_value,dbDown_value);
13202 }
13203
13204 // for (2,1)
13205 dbUp_value = (MS_S64) ( u64White_y* ( u64Red_y - u64Red_y*u64Blue_x - u64Blue_y + u64Red_x*u64Blue_y) ) ;
13206 dbDown_value = (MS_S64) ( u64Red_y*u64White_x + u64Red_x*u64Blue_y - u64Red_y*u64Blue_x - u64Blue_y*u64White_x + u64Blue_x*u64White_y - u64Red_x*u64White_y) ;
13207 if( dbDown_value ==0)
13208 {
13209 u32data_invalid[ 3] = 1;
13210 }
13211 else
13212 {
13213 u32data_invalid[ 3] =0;
13214 s64Mat[ 1][ 0] = do_div(dbUp_value,dbDown_value);
13215 }
13216
13217 // for (2,2)
13218 dbUp_value = (MS_S64) ( u64White_y* ( u64Red_x*u64Blue_y - u64Red_x + u64Blue_x - u64Red_y*u64Blue_x) ) ;
13219 dbDown_value = (MS_S64) ( u64Red_y*u64White_x + u64Red_x*u64Blue_y - u64Red_y*u64Blue_x - u64Blue_y*u64White_x + u64Blue_x*u64White_y - u64Red_x*u64White_y) ;
13220 if( dbDown_value ==0)
13221 {
13222 u32data_invalid[ 4] = 1;
13223 }
13224 else
13225 {
13226 u32data_invalid[ 4] =0;
13227 s64Mat[ 1][ 1] = do_div(dbUp_value,dbDown_value);
13228 }
13229
13230 // for (2,3)
13231 dbUp_value = (MS_S64) ( u64White_y* ( u64Red_x*u64Blue_y - u64Red_y*u64Blue_x) ) ;
13232 dbDown_value = (MS_S64) ( u64Red_y*u64White_x + u64Red_x*u64Blue_y - u64Red_y*u64Blue_x - u64Blue_y*u64White_x + u64Blue_x*u64White_y - u64Red_x*u64White_y) ;
13233 if( dbDown_value ==0)
13234 {
13235 u32data_invalid[ 5] = 1;
13236 }
13237 else
13238 {
13239 u32data_invalid[ 5] =0;
13240 s64Mat[ 1][ 2] = do_div(dbUp_value,dbDown_value);
13241 }
13242
13243 // for (3,1)
13244 dbUp_value = (MS_S64) ( u64White_y* ( u64Red_x*u64Green_y + u64Red_y - u64Green_y -u64Green_x*u64Red_y) ) ;
13245 dbDown_value = (MS_S64) ( -u64Green_x*u64Red_y + u64Red_y*u64White_x -u64Green_y*u64White_x -u64Red_x*u64White_y + u64Red_x*u64Green_y + u64Green_x*u64White_y) ;
13246 if( dbDown_value ==0)
13247 {
13248 u32data_invalid[ 6] = 1;
13249 }
13250 else
13251 {
13252 u32data_invalid[ 6] =0;
13253 s64Mat[ 2][ 0] = do_div(dbUp_value,dbDown_value);
13254 }
13255
13256 // for (3,2)
13257 dbUp_value = (MS_S64) ( u64White_y* ( -u64Red_x + u64Red_x*u64Green_y + u64Green_x - u64Green_x*u64Red_y) ) ;
13258 dbDown_value = (MS_S64) ( -u64Green_x*u64Red_y + u64Red_y*u64White_x -u64Green_y*u64White_x -u64Red_x*u64White_y + u64Red_x*u64Green_y + u64Green_x*u64White_y) ;
13259 if( dbDown_value ==0)
13260 {
13261 u32data_invalid[ 7] = 1;
13262 }
13263 else
13264 {
13265 u32data_invalid[ 7] =0;
13266 s64Mat[ 2][ 1] = do_div(dbUp_value,dbDown_value);
13267 }
13268
13269 // for (3,3)
13270 dbUp_value = (MS_S64) ( u64White_y* ( u64Red_x*u64Green_y - u64Green_x*u64Red_y) ) ;
13271 dbDown_value = (MS_S64) ( -u64Green_x*u64Red_y + u64Red_y*u64White_x -u64Green_y*u64White_x -u64Red_x*u64White_y + u64Red_x*u64Green_y + u64Green_x*u64White_y) ;
13272 if( dbDown_value ==0)
13273 {
13274 u32data_invalid[ 8] = 1;
13275 }
13276 else
13277 {
13278 u32data_invalid[ 8] =0;
13279 s64Mat[ 2][ 2] = do_div(dbUp_value,dbDown_value);
13280 }
13281
13282 #if 0 // this is used for debugging matrix
13283 int k = 0, o=0;
13284 for(k=0;k<3;k++)
13285 {
13286 for (o=0;o<3;o++)
13287 {
13288 printf("Mat[%d][%d] = %f\n",k,o,flMat[k][o]);
13289 }
13290 }
13291 #endif
13292
13293 //sRGB Matrix
13294 s64sRGBMat[0][0]= 412390;//0.412390799;
13295 s64sRGBMat[0][1]= 357584;//0.357584339;
13296 s64sRGBMat[0][2]= 180480;//0.180480788;
13297 s64sRGBMat[1][0]= 212639;//0.212639006;
13298 s64sRGBMat[1][1]= 715168;//0.715168679;
13299 s64sRGBMat[1][2]= 72192; //0.072192315;
13300 s64sRGBMat[2][0]= 19330; //0.019330819;
13301 s64sRGBMat[2][1]= 119194;//0.11919478;
13302 s64sRGBMat[2][2]= 950532;//0.950532152;
13303 //--------------------------------------------------------------------
13304
13305 // RGB2XYZ * Mat( XYZ2RGB)
13306 for( u32V_idx =0; u32V_idx<3; u32V_idx++)
13307 {
13308 dbHistogramSum[u32V_idx]=0;
13309 for( s32H_idx=0; s32H_idx<3; s32H_idx++)
13310 {
13311 MS_U64 s32Sum=0;
13312 for( u32cnt=0; u32cnt<3; u32cnt++)
13313 {
13314 s32Sum += s64Mat[ u32V_idx][ u32cnt] * s64sRGBMat[ u32cnt][ s32H_idx];
13315 }
13316
13317 s64RGB3x3[ u32V_idx][ s32H_idx] = s32Sum;
13318
13319 //printf("rgb3x3[%ld][%ld] = %f\n",u32V_idx,s32H_idx,flRGB3x3[u32V_idx][s32H_idx]);
13320
13321 dbHistogramSum[u32V_idx]=dbHistogramSum[u32V_idx]+s32Sum;
13322 }
13323 }
13324
13325
13326
13327 //Normalize
13328 dbMaxHistogramSum=0;
13329 for( u32V_idx =0; u32V_idx<3; u32V_idx++)
13330 {
13331 if (dbHistogramSum[u32V_idx]>=dbMaxHistogramSum)
13332 {
13333 dbMaxHistogramSum=dbHistogramSum[u32V_idx];
13334 }
13335
13336 }
13337
13338 MS_S64 s64_tmp=0;
13339 //convert to s2.10 format
13340 for( u32V_idx =0; u32V_idx<3; u32V_idx++)
13341 {
13342 for( s32H_idx=0; s32H_idx<3; s32H_idx++)
13343 {
13344 s64_tmp = (MS_S64) s64RGB3x3[u32V_idx][s32H_idx];
13345 do_div(s64_tmp,(dbMaxHistogramSum*ENLARGE_GATE));
13346 s64RGB3x3[u32V_idx][s32H_idx]=s64_tmp;
13347
13348 //MS_S64 round_value;
13349 //if (s64RGB3x3[u32V_idx][s32H_idx]>=0)
13350 //{
13351 // round_value= s64RGB3x3[u32V_idx][s32H_idx] *1024 + 0.5;
13352 //}
13353 //else
13354 //{
13355 // round_value= s64RGB3x3[u32V_idx][s32H_idx] *1024 - 0.5;
13356 //}
13357
13358 s32fix_value = (MS_S32)(s64RGB3x3[u32V_idx][s32H_idx]);
13359 MS_U32 abs_fix =(MS_U32) abs(s64RGB3x3[u32V_idx][s32H_idx]);
13360
13361 if( (abs_fix !=0) && (s32fix_value<0) )
13362 {
13363 MS_S32 sbits = 1<<12;
13364 s32RGB3x3[u32V_idx][ s32H_idx] = sbits + abs_fix ;
13365 }
13366 else
13367 {
13368 s32RGB3x3[ u32V_idx][ s32H_idx] = s32fix_value;
13369 }
13370
13371 //printf("s32RGB3x3[%ld][%ld] = %ld\n",u32V_idx,s32H_idx,s32RGB3x3[u32V_idx][s32H_idx]);
13372
13373 // convert signed matrix of s2.10 format to 2's complement for negative value
13374 MS_U32 u32current_value = s32RGB3x3[u32V_idx][s32H_idx] & 0xFFF; // remove carry bit
13375 if((s32RGB3x3[u32V_idx][s32H_idx] >> 12) == TRUE) // it is negative
13376 {
13377 s32RGB3x3[u32V_idx][s32H_idx] = ((~u32current_value)& 0x1FFF )+1;
13378 }
13379 }
13380 }
13381
13382 Hal_PQ_set_xvycc_matrix_coefficient(pInstance,s32RGB3x3, eWindow == PQ_MAIN_WINDOW ? TRUE : FALSE);
13383 return TRUE;
13384 }
MDrv_PQ_Set_xvYCC_MatrixCoefficient(MS_U64 u64Red_x,MS_U64 u64Red_y,MS_U64 u64Green_x,MS_U64 u64Green_y,MS_U64 u64Blue_x,MS_U64 u64Blue_y,MS_U64 u64White_x,MS_U64 u64White_y,PQ_WIN eWindow)13385 MS_BOOL MDrv_PQ_Set_xvYCC_MatrixCoefficient(MS_U64 u64Red_x, MS_U64 u64Red_y,
13386 MS_U64 u64Green_x, MS_U64 u64Green_y,
13387 MS_U64 u64Blue_x, MS_U64 u64Blue_y,
13388 MS_U64 u64White_x, MS_U64 u64White_y,
13389 PQ_WIN eWindow)
13390 {
13391 #ifdef TRACE_DBG
13392 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
13393 #endif
13394 if (pu32PQInst == NULL)
13395 {
13396 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
13397 return FALSE;
13398 }
13399
13400 stPQ_Set_xvYCC_MatrixCoefficient PQArgs;
13401 PQArgs.u64Red_x = u64Red_x;
13402 PQArgs.u64Red_y = u64Red_y;
13403 PQArgs.u64Green_x = u64Green_x;
13404 PQArgs.u64Green_y = u64Green_y;
13405 PQArgs.u64Blue_x = u64Blue_x;
13406 PQArgs.u64Blue_y = u64Blue_y;
13407 PQArgs.u64White_x = u64White_x;
13408 PQArgs.u64White_y = u64White_y;
13409 PQArgs.eWindow = eWindow;
13410 PQArgs.bReturnValue = FALSE;
13411 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_XVYCC_MATRIXCOEFFICIENT, (void*)&PQArgs) != 0)
13412 {
13413 printf("Obtain PQ engine fail\n");
13414 return FALSE;
13415 }
13416 else
13417 {
13418 return PQArgs.bReturnValue;
13419 }
13420 }
13421
MDrv_PQ_Set_xvYCC_MatrixEnable_U2(void * pInstance,MS_BOOL bEnable,PQ_WIN eWindow)13422 MS_BOOL MDrv_PQ_Set_xvYCC_MatrixEnable_U2(void* pInstance,MS_BOOL bEnable, PQ_WIN eWindow)
13423 {
13424 if (eWindow >= PQ_MAX_WINDOW)
13425 {
13426 printf("Invalid window type, please check ! \n");
13427 return FALSE;
13428 }
13429
13430 Hal_PQ_set_xvycc_matrix_enable(pInstance,bEnable, eWindow == PQ_MAIN_WINDOW ? TRUE : FALSE);
13431 return TRUE;
13432 }
MDrv_PQ_Set_xvYCC_MatrixEnable(MS_BOOL bEnable,PQ_WIN eWindow)13433 MS_BOOL MDrv_PQ_Set_xvYCC_MatrixEnable(MS_BOOL bEnable, PQ_WIN eWindow)
13434 {
13435 #ifdef TRACE_DBG
13436 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
13437 #endif
13438 if (pu32PQInst == NULL)
13439 {
13440 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
13441 return FALSE;
13442 }
13443
13444 stPQ_Set_xvYCC_MatrixEnable PQArgs;
13445 PQArgs.bEnable = bEnable;
13446 PQArgs.eWindow = eWindow;
13447 PQArgs.bReturnValue = FALSE;
13448 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_XVYCC_MATRIXENABLE, (void*)&PQArgs) != 0)
13449 {
13450 printf("Obtain PQ engine fail\n");
13451 return FALSE;
13452 }
13453 else
13454 {
13455 return PQArgs.bReturnValue;
13456 }
13457 }
13458
MDrv_PQ_Get_DNR_Whole_Reg_U2(void * pInstance,PQ_WIN eWindow)13459 MS_U16 MDrv_PQ_Get_DNR_Whole_Reg_U2(void* pInstance,PQ_WIN eWindow)
13460 {
13461 return 0;//Hal_PQ_get_dnr_whole_reg(eWindow);
13462 }
13463
MDrv_PQ_Get_DNR_Whole_Reg(PQ_WIN eWindow)13464 MS_U16 MDrv_PQ_Get_DNR_Whole_Reg(PQ_WIN eWindow)
13465 {
13466 #ifdef TRACE_DBG
13467 printf("\33[1;33m(%s %d)\33[m\n", __FUNCTION__, __LINE__);
13468 #endif
13469 if (pu32PQInst == NULL)
13470 {
13471 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
13472 return FALSE;
13473 }
13474
13475 stPQ_GetDnrWholeReg PQArgs;
13476 PQArgs.eWindow = eWindow;
13477 PQArgs.u16Ret = 0;
13478 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_DNR_WHOLE_REG, (void*)&PQArgs) != 0)
13479 {
13480 printf("Obtain PQ engine fail\n");
13481 return 0;
13482 }
13483 else
13484 {
13485 return PQArgs.u16Ret;
13486 }
13487 }
13488
MDrv_PQ_Up_Layer_Set_Config_U2(void * pInstance,MS_U16 uplayerSetting,PQ_MISC_GROUP group)13489 MS_BOOL MDrv_PQ_Up_Layer_Set_Config_U2(void* pInstance,MS_U16 uplayerSetting, PQ_MISC_GROUP group)
13490 {
13491 switch(group)
13492 {
13493 case E_PQ_GROUP_A:
13494 _upLayerConfig = uplayerSetting;
13495 break;
13496 //case E_PQ_GROUP_B: ....
13497 default:
13498 return FALSE;
13499 break;
13500 }
13501 return TRUE;
13502 }
13503
MDrv_PQ_Up_Layer_Set_Config(MS_U16 uplayerSetting,PQ_MISC_GROUP group)13504 MS_BOOL MDrv_PQ_Up_Layer_Set_Config(MS_U16 uplayerSetting, PQ_MISC_GROUP group)
13505 {
13506 #ifdef TRACE_DBG
13507 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
13508 #endif
13509 if (pu32PQInst == NULL)
13510 {
13511 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
13512 return FALSE;
13513 }
13514
13515 stPQ_Up_Layer_Set_Config PQArgs;
13516 PQArgs.uplayerSetting = uplayerSetting;
13517 PQArgs.bReturnValue = FALSE;
13518 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_UP_LAYER_SET_CONFIG, (void*)&PQArgs) != 0)
13519 {
13520 printf("Obtain PQ engine fail\n");
13521 return FALSE;
13522 }
13523 else
13524 {
13525 return PQArgs.bReturnValue;
13526 }
13527 }
13528
_MDrv_PQ_GET_DEVICE_NUM(void)13529 MS_U32 _MDrv_PQ_GET_DEVICE_NUM(void)
13530 {
13531 return PQ_SUPPORT_DEVICE_NUM;
13532 }
MDrv_PQ_Ex_GetVersion_U2(void * pInstance,PQ_WIN eWindow)13533 char* MDrv_PQ_Ex_GetVersion_U2(void* pInstance,PQ_WIN eWindow)
13534 {
13535 if(gbPQBinEnable == 1)
13536 {
13537 char* Ex_PQ_Version;
13538
13539 if(PQ_MAIN_WINDOW == eWindow)
13540 {
13541 Ex_PQ_Version = stPQBinHeaderInfo[PQ_BIN_EXT_MAIN].u8Version;
13542 }
13543 else
13544 {
13545 Ex_PQ_Version = stPQBinHeaderInfo[PQ_BIN_EXT_SUB].u8Version;
13546 }
13547 return Ex_PQ_Version;
13548 }
13549 else
13550 {
13551 return NULL;
13552 }
13553 }
MDrv_PQ_Ex_GetVersion(PQ_WIN eWindow)13554 char* MDrv_PQ_Ex_GetVersion(PQ_WIN eWindow)
13555 {
13556 #ifdef TRACE_DBG
13557 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
13558 #endif
13559 if (pu32PQInst == NULL)
13560 {
13561 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
13562 return NULL;
13563 }
13564
13565 stPQ_Ex_GetVersion PQArgs;
13566 PQArgs.eWindow = eWindow;
13567 PQArgs.bReturnValue = NULL;
13568 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_EX_GET_VERSION, (void*)&PQArgs) != 0)
13569 {
13570 printf("Obtain PQ engine fail\n");
13571 return NULL;
13572 }
13573 else
13574 {
13575 return PQArgs.bReturnValue;
13576 }
13577 }
13578
MDrv_PQ_GetAdaptiveVersion_U2(void * pInstance,PQ_WIN eWindow)13579 MS_U32 MDrv_PQ_GetAdaptiveVersion_U2(void* pInstance,PQ_WIN eWindow)
13580 {
13581 MS_U32 PQ_Adaptive_Version = PQ_ADAPTIVE_INVALID_VERSION;
13582 #if (PQ_SUPPORT_ADAPTIVE_VERSION)
13583 PQ_Adaptive_Version = Get_PQ_Adaptive_Version();
13584 #else
13585 PQ_Adaptive_Version = PQ_ADAPTIVE_INVALID_VERSION;
13586 #endif
13587 return PQ_Adaptive_Version;
13588 }
MDrv_PQ_GetAdaptiveVersion(PQ_WIN eWindow)13589 MS_U32 MDrv_PQ_GetAdaptiveVersion(PQ_WIN eWindow)
13590 {
13591 #ifdef TRACE_DBG
13592 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
13593 #endif
13594 if (pu32PQInst == NULL)
13595 {
13596 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
13597 return NULL;
13598 }
13599
13600 stPQ_GetAdaptiveVersion PQArgs;
13601 PQArgs.eWindow = eWindow;
13602 PQArgs.bReturnValue = 0;
13603 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_ADAPTVIE_VERSION, (void*)&PQArgs) != 0)
13604 {
13605 printf("Obtain PQ engine fail\n");
13606 return NULL;
13607 }
13608 else
13609 {
13610 return PQArgs.bReturnValue;
13611 }
13612 }
MDrv_PQ_LoadUFSCSettings_U2(void * pInstance,PQ_WIN eWindow)13613 void MDrv_PQ_LoadUFSCSettings_U2(void *pInstance,PQ_WIN eWindow)
13614 {
13615 if(_bUFSCPQEn && (eWindow == PQ_MAIN_WINDOW))
13616 {
13617 _u16PQSrcType_UFSC[eWindow] = QM_InputSourceToIndex_UFSC(pInstance,eWindow, _enInputSourceType[eWindow]);
13618 MDrv_PQBin_LoadTableBySrcType(pInstance,_u16PQSrcType_UFSC[eWindow],
13619 PQ_BIN_IP_ALL,
13620 MDrv_PQBin_GetPanelIdx_UFSC(pInstance),
13621 &stPQBinHeaderInfo[PQ_BIN_UFSC],
13622 eWindow);
13623 }
13624 }
13625
MDrv_PQ_LoadUFSCSettings(PQ_WIN eWindow)13626 void MDrv_PQ_LoadUFSCSettings(PQ_WIN eWindow)
13627 {
13628 #ifdef TRACE_DBG
13629 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
13630 #endif
13631 if (pu32PQInst == NULL)
13632 {
13633 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
13634 return ;
13635 }
13636
13637 stPQ_LoadUFSCSettings PQArgs;
13638 PQArgs.eWindow = eWindow;
13639 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_UFSC_SETTING, (void*)&PQArgs) != 0)
13640 {
13641 printf("Obtain PQ engine fail\n");
13642 return ;
13643 }
13644 else
13645 {
13646 return ;
13647 }
13648 }
13649 #if (ENABLE_PQ_BIN_CF)
MDrv_PQ_LoadCFSettings_U2(void * pInstance,PQ_WIN eWindow)13650 void MDrv_PQ_LoadCFSettings_U2(void *pInstance,PQ_WIN eWindow)
13651 {
13652 if(_bCFMainPQEn && (eWindow == PQ_MAIN_WINDOW))
13653 {
13654 _u16PQSrcType_CF[eWindow] = QM_InputSourceToIndex_CF(pInstance,eWindow, _enInputSourceType[eWindow]);
13655 MDrv_PQBin_LoadTableBySrcType(pInstance,_u16PQSrcType_CF[eWindow],
13656 PQ_BIN_IP_ALL,
13657 PQ_BIN_CF_PANEL_INDEX,
13658 &stPQBinHeaderInfo[PQ_BIN_CF_MAIN],
13659 eWindow);
13660 }
13661 #if (PQ_ENABLE_PIP)
13662 else if(_bCFSubPQEn &&(eWindow == PQ_SUB_WINDOW))
13663 {
13664 _u16PQSrcType_CF[eWindow] = QM_InputSourceToIndex_CF(pInstance,eWindow, _enInputSourceType[eWindow]);
13665 MDrv_PQBin_LoadTableBySrcType(pInstance,_u16PQSrcType_CF[eWindow],
13666 PQ_BIN_IP_ALL,
13667 PQ_BIN_CF_PANEL_INDEX,
13668 &stPQBinHeaderInfo[PQ_BIN_CF_SUB],
13669 eWindow);
13670 }
13671 #endif
13672 else
13673 {
13674 printf("NO CF QMAP!!!");
13675 }
13676 }
13677
MDrv_PQ_LoadCFSettings(PQ_WIN eWindow)13678 void MDrv_PQ_LoadCFSettings(PQ_WIN eWindow)
13679 {
13680 #ifdef TRACE_DBG
13681 printf("\33[1;33m(%s %d)\33[m\n", __FUNCTION__, __LINE__);
13682 #endif
13683 if (pu32PQInst == NULL)
13684 {
13685 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
13686 return ;
13687 }
13688
13689 stPQ_LoadCFSettings PQArgs;
13690 PQArgs.eWindow = eWindow;
13691 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_CF_SETTING, (void*)&PQArgs) != 0)
13692 {
13693 printf("Obtain PQ engine fail\n");
13694 return ;
13695 }
13696 else
13697 {
13698 return ;
13699 }
13700 }
13701 #endif
13702
MDrv_PQ_SetP2pForceToDoCsc(MS_BOOL bEnable)13703 void MDrv_PQ_SetP2pForceToDoCsc(MS_BOOL bEnable)
13704 {
13705 printf("[%s:%d] bEnable=%d\n", __FUNCTION__, __LINE__, bEnable);
13706 _bP2pForceToDoCsc = bEnable;
13707 }
13708
MDrv_PQ_SetOutputColorFormat(PQ_COLOR_FORMAT enColorFmt)13709 void MDrv_PQ_SetOutputColorFormat(PQ_COLOR_FORMAT enColorFmt)
13710 {
13711 printf("[%s:%d] enColorFmt=%d\n", __FUNCTION__, __LINE__, enColorFmt);
13712 _enOutputColorFmt = enColorFmt;
13713 }
13714
MDrv_PQ_GetPQPathStatus(E_PQ_Path_Type ePqPathType,MS_U16 u16Width,MS_U16 u16Height)13715 MS_BOOL MDrv_PQ_GetPQPathStatus(E_PQ_Path_Type ePqPathType, MS_U16 u16Width, MS_U16 u16Height)
13716 {
13717 #ifdef UFO_XC_PQ_PATH
13718 return MApi_XC_GetPQPathStatus((E_XC_PQ_Path_Type)ePqPathType, u16Width, u16Height);
13719 #else
13720 return PQ_IS_4K_INPUT(u16Width, u16Height);
13721 #endif
13722 }
13723
MDrv_PQ_SetPQBinPath_U2(void * pInstance,PQ_BIN_PATH ePqBinPath,MS_U8 u8size,char * b_PQBinFilePath)13724 void MDrv_PQ_SetPQBinPath_U2(void* pInstance,PQ_BIN_PATH ePqBinPath,MS_U8 u8size,char* b_PQBinFilePath)
13725 {
13726 PQ_INSTANCE_PRIVATE *psPQInstPri = NULL;
13727 UtopiaInstanceGetPrivate(pInstance, (void**)&psPQInstPri);
13728 PQ_RESOURCE_PRIVATE* pPQResourcePrivate = NULL;
13729 MDrv_PQ_Get_Semaphore(pInstance,E_PQ_POOL_ID_INTERNAL);
13730 UtopiaResourceGetPrivate(g_pPQResource[E_PQ_DEVICE_ID_0],(void**)(&pPQResourcePrivate));
13731
13732 if(b_PQBinFilePath == NULL)
13733 {
13734 printf("ERROR!! NULL BIN PATH!!!!!\n");
13735 }
13736 else
13737 {
13738 switch(ePqBinPath)
13739 {
13740 case E_PQ_BIN_PATH_CUSTOMER:
13741 {
13742 memset(pPQResourcePrivate->stPQBin_Path.pm_PQ_CUSTOMER_PATH,0,PQ_FILE_PATH_LENGTH);
13743 strncpy(pPQResourcePrivate->stPQBin_Path.pm_PQ_CUSTOMER_PATH,b_PQBinFilePath,PQ_FILE_PATH_LENGTH - 1);
13744 break;
13745 }
13746 case E_PQ_BIN_PATH_DEFAULT:
13747 {
13748 memset(pPQResourcePrivate->stPQBin_Path.pm_PQ_DEFAULT_PATH,0,PQ_FILE_PATH_LENGTH);
13749 strncpy(pPQResourcePrivate->stPQBin_Path.pm_PQ_DEFAULT_PATH,b_PQBinFilePath,PQ_FILE_PATH_LENGTH - 1);
13750 break;
13751 }
13752 case E_PQ_BIN_PATH_INI:
13753 {
13754 memset(pPQResourcePrivate->stPQBin_Path.pm_PQ_INI_PATH,0,PQ_FILE_PATH_LENGTH);
13755 strncpy(pPQResourcePrivate->stPQBin_Path.pm_PQ_INI_PATH,b_PQBinFilePath,PQ_FILE_PATH_LENGTH - 1);
13756 break;
13757 }
13758 case E_PQ_BIN_PATH_BANDWIDTH:
13759 {
13760 memset(pPQResourcePrivate->stPQBin_Path.pm_PQ_BANDWIDTH_PATH,0,PQ_FILE_PATH_LENGTH);
13761 strncpy(pPQResourcePrivate->stPQBin_Path.pm_PQ_BANDWIDTH_PATH,b_PQBinFilePath,PQ_FILE_PATH_LENGTH - 1);
13762 break;
13763 }
13764 default:
13765 printf("ERROR!! SET WRONG PQ_BIN_PATH TYPE!!!!!\n");
13766 break;
13767
13768 }
13769 }
13770 MDrv_PQ_Release_Semaphore(pInstance,E_PQ_POOL_ID_INTERNAL);
13771 }
MDrv_PQ_SetPQBinPath(PQ_BIN_PATH ePqBinPath,MS_U8 u8size,char * b_PQBinFilePath)13772 void MDrv_PQ_SetPQBinPath(PQ_BIN_PATH ePqBinPath,MS_U8 u8size,char* b_PQBinFilePath)
13773 {
13774 #ifdef TRACE_DBG
13775 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
13776 //return;
13777 #endif
13778 if (pu32PQInst == NULL)
13779 {
13780 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
13781 {
13782 printf("UtopiaOpen PQ failed\n");
13783 return ;
13784 }
13785 printf("\33[1;33m[MARCOS](%s %d) OPEN FINE\33[m\n", __FUNCTION__, __LINE__);
13786 }
13787
13788 stPQ_SetPQBinPath PQArgs;
13789 PQArgs.ePqBinPath = ePqBinPath;
13790 PQArgs.u8size = u8size;
13791 PQArgs.b_PQBinFilePath = b_PQBinFilePath;
13792 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_PQBIN_PATH, (void*)&PQArgs) != 0)
13793 {
13794 printf("Obtain PQ engine fail\n");
13795 return ;
13796 }
13797 }
13798
13799 EXPORT_SYMBOL(MDrv_PQ_SetCSC);
13800 EXPORT_SYMBOL(MDrv_PQ_Init);
13801 EXPORT_SYMBOL(MDrv_PQ_DesideSrcType);
13802 EXPORT_SYMBOL(MDrv_PQ_SetMemFormat);
13803
13804 EXPORT_SYMBOL(MDrv_PQ_Exit);
13805 EXPORT_SYMBOL(MDrv_PQ_LoadScalingTable);
13806 EXPORT_SYMBOL(MDrv_PQ_IOCTL);
13807 EXPORT_SYMBOL(MDrv_PQ_DisableFilmMode);
13808
13809 EXPORT_SYMBOL(MDrv_PQ_Set420upsampling);
13810 EXPORT_SYMBOL(MDrv_PQ_Get_MemYUVFmt);
13811
13812 EXPORT_SYMBOL(MDrv_PQ_Set_ModeInfo);
13813
13814 EXPORT_SYMBOL(MDrv_PQ_LoadSettings);
13815 EXPORT_SYMBOL(MDrv_PQ_SkipDuplicatedSetting);
13816 EXPORT_SYMBOL(MDrv_PQ_IsForceVideoInputMode);
13817 EXPORT_SYMBOL(MDrv_PQ_LoadCustomerSettings);
13818 EXPORT_SYMBOL(MDrv_PQ_EnableScalerGamma);
13819 EXPORT_SYMBOL(MDrv_PQ_GetDelayTime);
13820 EXPORT_SYMBOL(MDrv_PQ_Set_MultiMediaInfo);
13821 EXPORT_SYMBOL(MDrv_PQ_SetFrameBuffMode);
13822
13823