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 #define DRV_SC_SCALING_C
95
96 #ifdef MSOS_TYPE_LINUX_KERNEL
97 #include <linux/string.h>
98 #else
99 #include <string.h>
100 #endif
101 #include "UFO.h"
102 // Common Definition
103 #include "MsCommon.h"
104 #include "MsOS.h"
105 #include "mhal_xc_chip_config.h"
106 #include "utopia.h"
107 #include "utopia_dapi.h"
108
109 //#include "Debug.h"
110 #include "drvXC_IOPort.h"
111 #include "apiXC.h"
112 #include "apiXC_Adc.h"
113 #include "apiXC_Auto.h"
114 #include "drv_sc_display.h"
115 #include "drv_sc_isr.h"
116 #include "apiXC_PCMonitor.h"
117 #include "apiXC_ModeParse.h"
118 #include "drvXC_HDMI_if.h"
119 #include "mvideo_context.h"
120 #include "drv_sc_ip.h"
121 #if (LD_ENABLE==1)
122 #include "mdrv_ld.h"
123 #include "mdrv_ldalgo.h"
124 #endif
125 #include "drv_sc_mux.h"
126 #include "mdrv_sc_3d.h"
127 #include "drv_sc_menuload.h"
128 #include "drvXC_ADC_Internal.h"
129 #include "mhal_sc.h"
130 #if FRC_INSIDE
131 #include "mdrv_frc.h"
132 #include "mhal_frc.h"
133 #endif
134 #include "XC_private.h"
135 #include "apiXC_v2.h"
136 #include "mhal_ip.h"
137 #include "mhal_hdmi.h"
138
139 #include "mhal_pip.h"
140 #include "halCHIP.h"
141 #include "drv_sc_scaling.h"
142 #include "xc_Analog_Reg.h"
143 #include "xc_hwreg_utility2.h"
144 #include "mdrv_sc_dynamicscaling.h"
145 #include "mhal_dynamicscaling.h"
146 #include "hwreg_pm_sleep.h"
147 #if (defined (ANDROID))
148 #include "drvPQ.h"
149 #endif
150 //////////////////////////Remove when drvpq change us Mscommon.h /////////////
151 #define E_XRULE_HSD 0
152 #define E_XRULE_VSD 1
153 #define E_XRULE_HSP 2
154 #define E_XRULE_VSP 3
155 #define E_XRULE_CSC 4
156 #define E_XRULE_NUM 5
157
158 #define E_GRULE_NR 0
159 #define E_GRULE_NUM 1
160
161 #define RFBL_Y8M4_Pixel_Bits 12
162
163 #define PIP_SUPPORTED (MAX_WINDOW_NUM > 1)
164
165 #define WIDTH_4K2K (3840)
166 #define WIDTH_4K2K_OFFSET (10)
167
168 #define DUAL_DUMMYDATA_SIZE (4)
169 #define DUAL_GARDBAND_SIZE (32)
170
171 #ifndef SUPPORT_DUAL_MIU_MIRROR_SWAP_IPM
172 #define SUPPORT_DUAL_MIU_MIRROR_SWAP_IPM FALSE
173 #endif
174
175 typedef enum
176 {
177 E_DRVSC_FBNUM = 0,
178 }DRV_SC_SRCINFO ;
179
180 extern PQ_Function_Info s_PQ_Function_Info[MAX_XC_DEVICE_NUM];
181
182 /******************************************************************************/
183 /* Local */
184 /* ****************************************************************************/
185
186 #define MS_IPM_BASE0(win) (pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[(win)] / BYTE_PER_WORD )
187 #define MS_IPM_BASE1(win) ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[(win)] + (pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[(win)]/2)) / BYTE_PER_WORD)
188 #define MS_FRCM_BASE0(win) (pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[(win)] / BYTE_PER_WORD )
189 #define MS_FRCM_BASE1(win) ((pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[(win)] + (pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[(win)]/2)) / BYTE_PER_WORD)
190
191 #define MS_IPM_DUAL_MIU_BASE0(win) (pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBaseAddr0[(win)] / BYTE_PER_WORD )
192 #define MS_IPM_DUAL_MIU_BASE1(win) ((pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBaseAddr0[(win)] + (pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBaseAddr0[(win)]/2)) / BYTE_PER_WORD)
193
194
195 #define VFREQDELTA 10
196 #define MAX_1P_MODE_CLK 320000000 //(300*1024*1024) // max 1p mode clk value
197 #define MVOP_H_BLANKING 300
198 #define MVOP_V_BLANKING 45
199
200 #ifdef UFO_XC_SUPPORT_2STEP_SCALING
201 MS_BOOL bIsSupport2StepScaling;
202 #endif
203 /******************************************************************************/
204 /* Functions */
205 /******************************************************************************/
206
207 extern MS_BOOL MDrv_VD_IsSyncLocked(void);
208 extern void MDrv_PQDS_Update_PanelID(void *, MS_U16);
209
MDrv_XC_WBankReset(void * pInstance,MS_BOOL bIsFRCM,SCALER_WIN eWindow)210 MS_BOOL MDrv_XC_WBankReset(void *pInstance, MS_BOOL bIsFRCM, SCALER_WIN eWindow)
211 {
212 #if _FIELD_PACKING_MODE_SUPPORTED //new SCMI mech
213 MS_U32 u32Reg = 0;
214 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
215 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
216
217 if (bIsFRCM)
218 {
219 if(eWindow ==MAIN_WINDOW )
220 {
221 u32Reg = REG_SC_BK32_05_L;
222 }
223 else
224 {
225 u32Reg = REG_SC_BK32_45_L;
226 }
227 }
228 else
229 {
230 if(eWindow ==MAIN_WINDOW )
231 {
232 u32Reg = REG_SC_BK12_05_L;
233 }
234 else
235 {
236 u32Reg = REG_SC_BK12_45_L;
237 }
238 }
239
240 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32Reg, BIT(7), BIT(7) );
241 MsOS_DelayTask(1);
242 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32Reg, 0, BIT(7) );
243 MsOS_DelayTask(1);
244
245 #endif
246 return TRUE;
247 }
248
MDrv_SC_set_write_limit(void * pInstance,MS_PHY u32WritelimitAddrBase,SCALER_WIN eWindow)249 void MDrv_SC_set_write_limit(void *pInstance, MS_PHY u32WritelimitAddrBase, SCALER_WIN eWindow)
250 {
251 Hal_SC_set_write_limit(pInstance, u32WritelimitAddrBase, eWindow);
252
253 }
MDrv_SC_set_dual_write_limit(void * pInstance,MS_PHY u32WritelimitAddrBase,SCALER_WIN eWindow)254 void MDrv_SC_set_dual_write_limit(void *pInstance, MS_PHY u32WritelimitAddrBase, SCALER_WIN eWindow)
255 {
256 #ifdef UFO_XC_SUPPORT_DUAL_MIU
257 Hal_SC_set_dual_write_limit(pInstance, u32WritelimitAddrBase, eWindow);
258 #endif
259 }
260
MDrv_SC_CheckMuteStatusByRegister(void * pInstance,SCALER_WIN eWindow)261 MS_BOOL MDrv_SC_CheckMuteStatusByRegister(void *pInstance, SCALER_WIN eWindow)
262 {
263 return Hal_SC_CheckMuteStatusByRegister(pInstance, eWindow);
264 }
265
MDrv_SC_SetPQHSDFlag(void * pInstance,MS_BOOL bEnable)266 void MDrv_SC_SetPQHSDFlag(void *pInstance, MS_BOOL bEnable)
267 {
268 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
269 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
270 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
271 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
272 pXCResourcePrivate->stdrvXC_Scaling._bPQSetHPreScalingratio = bEnable;
273 }
274
MDrv_SC_GetPQHSDFlag(void * pInstance)275 MS_BOOL MDrv_SC_GetPQHSDFlag(void *pInstance)
276 {
277 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
278 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
279 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
280 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
281 return pXCResourcePrivate->stdrvXC_Scaling._bPQSetHPreScalingratio;
282 }
283
284 #if (ENABLE_OPM_WRITE_SUPPORTED)
_MDrv_SC_set_opm_write_limit(void * pInstance,MS_BOOL bEnable,MS_BOOL bFlag,MS_PHY u32OPWlimitAddr,SCALER_WIN eWindow)285 void _MDrv_SC_set_opm_write_limit(void *pInstance, MS_BOOL bEnable, MS_BOOL bFlag, MS_PHY u32OPWlimitAddr, SCALER_WIN eWindow)
286 {
287 // Only support address of Main_Window
288 if (eWindow != MAIN_WINDOW )
289 {
290 return;
291 }
292 u32OPWlimitAddr |= (bEnable?F2_OPW_WRITE_LIMIT_EN:0) | (bFlag?F2_OPW_WRITE_LIMIT_MIN:0);
293
294 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
295 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
296
297 SC_W4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK12_5E_L, u32OPWlimitAddr);
298 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK0D_38_L, (bEnable?BIT(2):0),BIT(2)); //OPW memory address limit enable, refer to F2 memory limit from BK0D_40/BK0D_42
299 }
_MDrv_SC_set_dual_opm_write_limit(void * pInstance,MS_BOOL bEnable,MS_BOOL bFlag,MS_PHY u32OPWlimitAddr,SCALER_WIN eWindow)300 void _MDrv_SC_set_dual_opm_write_limit(void *pInstance, MS_BOOL bEnable, MS_BOOL bFlag, MS_PHY u32OPWlimitAddr, SCALER_WIN eWindow)
301 {
302 // Only support address of Main_Window
303 if (eWindow != MAIN_WINDOW )
304 {
305 return;
306 }
307 u32OPWlimitAddr |= (bEnable?F2_OPW_WRITE_LIMIT_EN:0) | (bFlag?F2_OPW_WRITE_LIMIT_MIN:0);
308
309 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
310 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
311 //OPM write limit share the same min/max baseAddress setting with IPM
312 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK0D_38_L, (bEnable?BIT(6):0),BIT(6)); //OPW memory address limit enable, refer to F2 memory limit from BK0D_48/BK0D_4d
313 }
314
315 #endif
316
MDrv_SC_set_opm_write_limit(void * pInstance,MS_BOOL bEnable,MS_BOOL bFlag,MS_PHY u32OPWlimitAddr,SCALER_WIN eWindow)317 void MDrv_SC_set_opm_write_limit(void *pInstance, MS_BOOL bEnable, MS_BOOL bFlag, MS_PHY u32OPWlimitAddr, SCALER_WIN eWindow)
318 {
319 #if (ENABLE_OPM_WRITE_SUPPORTED)
320 _MDrv_SC_set_opm_write_limit(pInstance, bEnable, bFlag, u32OPWlimitAddr, eWindow);
321 //Note: Hal_SC_set_opm_write_limit() is deprecated. use _MDrv_SC_set_opm_write_limit() instead.
322 #endif //(ENABLE_OPM_WRITE_SUPPORTED)
323 }
324
MDrv_SC_set_dual_opm_write_limit(void * pInstance,MS_BOOL bEnable,MS_BOOL bFlag,MS_PHY u32OPWlimitAddr,SCALER_WIN eWindow)325 void MDrv_SC_set_dual_opm_write_limit(void *pInstance, MS_BOOL bEnable, MS_BOOL bFlag, MS_PHY u32OPWlimitAddr, SCALER_WIN eWindow)
326 {
327 #ifdef UFO_XC_SUPPORT_DUAL_MIU
328 #if (ENABLE_OPM_WRITE_SUPPORTED)
329 _MDrv_SC_set_dual_opm_write_limit(pInstance, bEnable, bFlag, u32OPWlimitAddr, eWindow);
330 //Note: Hal_SC_set_opm_write_limit() is deprecated. use _MDrv_SC_set_opm_write_limit() instead.
331 #endif //(ENABLE_OPM_WRITE_SUPPORTED)
332 #endif
333 }
334
MDrv_SC_set_frcm_write_limit(void * pInstance,MS_BOOL bEnable,MS_PHY u32FRCMLimitBase,SCALER_WIN eWindow)335 void MDrv_SC_set_frcm_write_limit(void *pInstance, MS_BOOL bEnable, MS_PHY u32FRCMLimitBase, SCALER_WIN eWindow)
336 {
337 #if (HW_DESIGN_4K2K_VER == 4)
338 if(eWindow == MAIN_WINDOW)
339 u32FRCMLimitBase |= (bEnable?F2_FRCM_WRITE_LIMIT_EN:0);
340 else if(eWindow == SUB_WINDOW)
341 u32FRCMLimitBase |= (bEnable?F1_FRCM_WRITE_LIMIT_EN:0);
342
343
344 Hal_SC_set_frcm_write_limit(pInstance, u32FRCMLimitBase, eWindow);
345 #endif
346 }
347
348 //-----------------------------------------------------------------------------------------------------------
349 /// When the muteType is enabled, the vsync will be skipped and the registers will be written directly
350 /// @param enMuteType \b IN: the mute type could be MainWindow, SubWindow and Panel
351 /// @param bIsForceWrite \b IN: Force write or not
352 //-----------------------------------------------------------------------------------------------------------
MDrv_SC_SetForceWrite(EN_MUTE_TYPE enMuteType,MS_BOOL bForceWrite)353 void MDrv_SC_SetForceWrite( EN_MUTE_TYPE enMuteType, MS_BOOL bForceWrite)
354 {
355 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
356 UtopiaResourceGetPrivate(g_pXCResource[E_XC_POOL_ID_INTERNAL_VARIABLE],(void**)(&pXCResourcePrivate));
357 if(enMuteType == E_MAIN_WINDOW_MUTE)
358 {
359 pXCResourcePrivate->stdrvXC_Scaling._bMainWinSkipWaitOutputVsync = bForceWrite;
360 }
361 else if(enMuteType == E_SUB_WINDOW_MUTE)
362 {
363 pXCResourcePrivate->stdrvXC_Scaling._bSubWinSkipWaitOutputVsync = bForceWrite;
364 }
365 else if(enMuteType == E_PANEL_MUTE)
366 {
367 pXCResourcePrivate->stdrvXC_Scaling._bPanelSkipWaitOutputVsync = bForceWrite;
368 }
369 else
370 {
371 MS_ASSERT(0);
372 }
373 }
374
375
376 //-------------------------------------------------------------------------------------------------
377 // Skip Wait Vsync
378 /// @param eWindow \b IN: Enable
379 /// @param Skip wait Vsync \b IN: Disable wait Vsync
380 //-------------------------------------------------------------------------------------------------
MDrv_SC_SetSkipWaitVsync(void * pInstance,MS_BOOL eWindow,MS_BOOL bIsSkipWaitVsyn)381 void MDrv_SC_SetSkipWaitVsync(void *pInstance, MS_BOOL eWindow,MS_BOOL bIsSkipWaitVsyn)
382 {
383 EN_MUTE_TYPE enMuteType = E_MAIN_WINDOW_MUTE;
384 switch(eWindow)
385 {
386 case MAIN_WINDOW:
387 enMuteType = E_MAIN_WINDOW_MUTE;
388 break;
389 case SUB_WINDOW:
390 enMuteType = E_SUB_WINDOW_MUTE;
391 break;
392 default:
393 break;
394 }
395 MDrv_SC_SetForceWrite(enMuteType, bIsSkipWaitVsyn);
396 }
397
MDrv_SC_GetForceWrite(EN_MUTE_TYPE enMuteType)398 MS_BOOL MDrv_SC_GetForceWrite( EN_MUTE_TYPE enMuteType)
399 {
400 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
401 UtopiaResourceGetPrivate(g_pXCResource[E_XC_POOL_ID_INTERNAL_VARIABLE],(void**)(&pXCResourcePrivate));
402 if(enMuteType == E_MAIN_WINDOW_MUTE)
403 {
404 return pXCResourcePrivate->stdrvXC_Scaling._bMainWinSkipWaitOutputVsync;
405 }
406 else if(enMuteType == E_SUB_WINDOW_MUTE)
407 {
408 return pXCResourcePrivate->stdrvXC_Scaling._bSubWinSkipWaitOutputVsync;
409 }
410 else if(enMuteType == E_PANEL_MUTE)
411 {
412 return pXCResourcePrivate->stdrvXC_Scaling._bPanelSkipWaitOutputVsync;
413 }
414 else
415 {
416 MS_ASSERT(0);
417 return FALSE;
418 }
419 }
420
MDrv_SC_GetSkipWaitVsync(void * pInstance,MS_BOOL bScalerWin)421 MS_BOOL MDrv_SC_GetSkipWaitVsync(void *pInstance, MS_BOOL bScalerWin)
422 {
423 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
424 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
425 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
426 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
427 if(bScalerWin == MAIN_WINDOW)
428 {
429 return pXCResourcePrivate->stdrvXC_Scaling._bMainWinSkipWaitOutputVsync;
430 }
431 else
432 {
433 return pXCResourcePrivate->stdrvXC_Scaling._bSubWinSkipWaitOutputVsync;
434 }
435 }
436
437 //-------------------------------------------------------------------------------------------------
438 /// Set XC CMA Heap ID
439 /// @param u8CMAHeapID \b IN: CMA Heap ID
440 /// @param eWindow \b IN: which window we are going to set
441 //-------------------------------------------------------------------------------------------------
MDrv_SC_SetCMAHeapID(void * pInstance,MS_U8 u8CMAHeapID,SCALER_WIN eWindow)442 void MDrv_SC_SetCMAHeapID(void *pInstance, MS_U8 u8CMAHeapID,SCALER_WIN eWindow)
443 {
444 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
445 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
446 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
447 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
448 gSrcInfo[eWindow].u8CMAHeapID = u8CMAHeapID;
449 }
450
MDrv_SC_sw_db(void * pInstance,P_SC_SWDB_INFO pDBreg,SCALER_WIN eWindow)451 void MDrv_SC_sw_db(void *pInstance, P_SC_SWDB_INFO pDBreg, SCALER_WIN eWindow )
452 {
453 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
454 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
455 // Set ficlk -> sw_db for prevent garbage when no Vpre-scaling down
456 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
457 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
458
459 if ( !gSrcInfo[eWindow].bPreV_ScalingDown )
460 {
461 Hal_SC_set_ficlk(pInstance, FALSE, eWindow );
462 }
463
464 if ((MDrv_XC_MLoad_GetStatus(pInstance) == E_MLOAD_ENABLED)
465 && (!MDrv_SC_CheckMuteStatusByRegister(pInstance, eWindow)))
466 {
467 Hal_SC_sw_db_burst(pInstance, pDBreg, eWindow );
468 }
469 else
470 {
471 if((!MDrv_SC_CheckMuteStatusByRegister(pInstance, eWindow))&&(!MDrv_SC_GetSkipWaitVsync(pInstance, eWindow)))
472 {
473 MDrv_XC_wait_output_vsync(pInstance, 2, 200, eWindow);
474 }
475 Hal_SC_sw_db(pInstance, pDBreg, eWindow );
476 }
477
478 // Set sw_db -> ficlk for prevent garbage when Vpre-scaling down
479 if ( gSrcInfo[eWindow].bPreV_ScalingDown )
480 {
481 Hal_SC_set_ficlk(pInstance, TRUE, eWindow );
482 }
483
484 }
485
MDrv_SC_dual_sw_db(void * pInstance,P_SC_SWDB_INFO pMainDBreg,P_SC_SWDB_INFO pSubDBreg)486 void MDrv_SC_dual_sw_db(void *pInstance, P_SC_SWDB_INFO pMainDBreg, P_SC_SWDB_INFO pSubDBreg)
487 {
488 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
489 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
490 // Set ficlk -> sw_db for prevent garbage when no Vpre-scaling down
491 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
492 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
493
494 if ( !gSrcInfo[MAIN_WINDOW].bPreV_ScalingDown )
495 {
496 Hal_SC_set_ficlk(pInstance, FALSE, MAIN_WINDOW );
497 }
498 if ( !gSrcInfo[SUB_WINDOW].bPreV_ScalingDown )
499 {
500 Hal_SC_set_ficlk(pInstance, FALSE, SUB_WINDOW );
501 }
502
503 if ((MDrv_XC_MLoad_GetStatus(pInstance) == E_MLOAD_ENABLED) && (!MDrv_SC_GetForceWrite(E_MAIN_WINDOW_MUTE)) && (!MDrv_SC_GetForceWrite(E_SUB_WINDOW_MUTE)) && (!MDrv_SC_GetForceWrite(E_PANEL_MUTE)) )
504 {
505 Hal_SC_dual_sw_db_burst(pInstance, pMainDBreg, pSubDBreg );
506 }
507 else
508 {
509 if((!MDrv_SC_GetForceWrite(E_MAIN_WINDOW_MUTE)) && (!MDrv_SC_GetForceWrite(E_PANEL_MUTE)))
510 {
511 MDrv_XC_wait_output_vsync(pInstance, 2, 200, MAIN_WINDOW);
512 }
513 Hal_SC_sw_db(pInstance, pMainDBreg, MAIN_WINDOW );
514
515 if((!MDrv_SC_GetForceWrite(E_SUB_WINDOW_MUTE)) && (!MDrv_SC_GetForceWrite(E_PANEL_MUTE)))
516 {
517 MDrv_XC_wait_output_vsync(pInstance, 2, 200, SUB_WINDOW);
518 }
519 Hal_SC_sw_db(pInstance, pMainDBreg, SUB_WINDOW );
520 }
521
522 // Set sw_db -> ficlk for prevent garbage when Vpre-scaling down
523 if ( gSrcInfo[MAIN_WINDOW].bPreV_ScalingDown )
524 {
525 Hal_SC_set_ficlk(pInstance, TRUE, MAIN_WINDOW );
526 }
527 if ( gSrcInfo[SUB_WINDOW].bPreV_ScalingDown )
528 {
529 Hal_SC_set_ficlk(pInstance, TRUE, SUB_WINDOW );
530 }
531
532 }
533
534
MApi_SWDS_Fire_U2(void * pInstance,SCALER_WIN eWindow)535 void MApi_SWDS_Fire_U2(void *pInstance, SCALER_WIN eWindow )
536 {
537 MS_U32 ActiveSWClearEn = 0;
538 MS_U32 u32SW_Reset_Enable = 0;
539 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
540 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
541 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
542 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
543 #if ((HW_DESIGN_4K2K_VER == 4)||(HW_DESIGN_4K2K_VER == 6)||(HW_DESIGN_4K2K_VER == 7))
544 _DS_ENTRY(pInstance);
545 if(eWindow == MAIN_WINDOW)
546 {
547 if(pXCResourcePrivate->sthal_SC.bDynamicScalingEnable)
548 {
549 pXCResourcePrivate->sthal_SC.u8DynamicScalingNextIndex[MAIN_WINDOW] = pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex_Ring[MAIN_WINDOW];
550 }
551 }
552 PSTXC_DS_CMDCNT.u16CMDCNT_IPM =0;
553 PSTXC_DS_CMDCNT.u16CMDCNT_IPS =0;
554 PSTXC_DS_CMDCNT.u16CMDCNT_OPM =0;
555 PSTXC_DS_CMDCNT.u16CMDCNT_OPS =0;
556 //ActiveSWClearEn enable in first DS IP command ;
557 u32SW_Reset_Enable = 0x4000; // bit14: reg_ds_active_sw_clr_en,set ds_activating cleared by SW
558 ActiveSWClearEn = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_17_L, 0xFFFF);
559 ActiveSWClearEn |= u32SW_Reset_Enable;
560
561 Hal_SC_WriteSWDSCommand(pInstance,MAIN_WINDOW,REG_SC_BK1F_17_L,(MS_U16)(ActiveSWClearEn),DS_IP,DS_XC,&PSTXC_DS_CMDCNT);
562
563 Hal_SC_Add_NullCommand(pInstance, MAIN_WINDOW, DS_IP, &PSTXC_DS_CMDCNT);
564 if(!((gSrcInfo[MAIN_WINDOW].bR_FBL) || (gSrcInfo[MAIN_WINDOW].bFBL)))
565 {
566 Hal_SC_Add_NullCommand(pInstance, MAIN_WINDOW, DS_OP, &PSTXC_DS_CMDCNT);
567 }
568 MDrv_SWDS_Fire(pInstance,eWindow);
569 _DS_RETURN(pInstance);
570 #endif
571 }
572
MApi_SWDS_Fire(SCALER_WIN eWindow)573 void MApi_SWDS_Fire(SCALER_WIN eWindow )
574 {
575 if (pu32XCInst == NULL)
576 {
577 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
578 return;
579 }
580
581 stXC_SWDS_FIRE XCArgs;
582 XCArgs.eWindow = eWindow;
583
584 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SWDS_FIRE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
585 {
586 printf("Obtain XC engine fail\n");
587 return;
588 }
589 else
590 {
591 return;
592 }
593 }
594
595 #if ((HW_DESIGN_4K2K_VER == 4)||(HW_DESIGN_4K2K_VER == 6)||(HW_DESIGN_4K2K_VER == 7))
596 #if ((defined (ANDROID) || defined(MSOS_TYPE_LINUX_KERNEL)) && defined(UFO_XC_DS_PQ))
597 extern void _MDrv_PQ_Load_DS_Table(void* pInstance,PQ_WIN eWindow,MS_U32 V_Size, MS_U32 H_Size);
598 #endif
MDrv_SWDS_AddCmd(void * pInstance,P_SC_SWDB_INFO pDBreg,SCALER_WIN eWindow)599 void MDrv_SWDS_AddCmd(void *pInstance, P_SC_SWDB_INFO pDBreg, SCALER_WIN eWindow )
600 {
601 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
602 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
603 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
604 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
605 #if ((defined (ANDROID) || defined(MSOS_TYPE_LINUX_KERNEL)) && defined(UFO_XC_DS_PQ))
606 /// To prevent Mutex lock for XC >> PQ >> XC
607 _XC_RETURN(pInstance);
608 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
609
610 MDrv_PQDS_Update_PanelID(pInstance, pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width);
611 _MDrv_PQ_Load_DS_Table(pInstance,eWindow,pDBreg->u16V_CapSize,pDBreg->u16H_CapSize);
612
613 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
614 _XC_ENTRY(pInstance);
615 #endif
616
617
618 Hal_SC_SWDS_AddCmd(pInstance,pDBreg, eWindow);
619 }
620
MDrv_SWDS_Fire(void * pInstance,SCALER_WIN eWindow)621 void MDrv_SWDS_Fire(void *pInstance, SCALER_WIN eWindow )
622 {
623 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
624 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
625 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
626 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
627
628 #if (SUPPORT_KERNEL_DS == 1)
629 MDrv_XC_FireSWDSIndex(pInstance, eWindow);
630 #else
631 Hal_SC_SWDS_Fire(pInstance, eWindow);
632 #endif
633 }
634
635 #endif
636
MDrv_XC_VIP_Peaking_Setting(void * pInstance,SCALER_WIN eWindow)637 void MDrv_XC_VIP_Peaking_Setting(void *pInstance, SCALER_WIN eWindow)
638 {
639 Hal_SC_VIP_Peaking_Setting(pInstance, eWindow);
640 }
641
MDrv_XC_DTVPatch(void * pInstance,SCALER_WIN eWindow)642 void MDrv_XC_DTVPatch(void *pInstance, SCALER_WIN eWindow)
643 {
644 #if (HW_DESIGN_4K2K_VER == 4)
645 MHal_XC_DTVPatch(pInstance,eWindow);
646 #endif
647 }
648
MDrv_XC_init_fbn_win(void * pInstance,SCALER_WIN eWindow)649 void MDrv_XC_init_fbn_win(void *pInstance, SCALER_WIN eWindow)
650 {
651 SC_SWDB_INFO SWDBreg;
652 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
653 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
654 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
655 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
656
657 memset(&SWDBreg, 0, sizeof(SC_SWDB_INFO));
658 SWDBreg.u32H_PreScalingRatio = 0x0;
659 SWDBreg.u32V_PreScalingRatio = 0x0;
660 SWDBreg.u32H_PostScalingRatio = 0x0;
661 SWDBreg.u32V_PostScalingRatio = 0x0;
662 SWDBreg.u16VLen = 0x240;
663 #if (HW_DESIGN_4K2K_VER == 4)
664 SWDBreg.u16FRCMVLen = 0x240;
665 #endif
666 if(eWindow == MAIN_WINDOW)
667 {
668 SWDBreg.u16VWritelimit = 0x240 | F2_V_WRITE_LIMIT_EN;
669 #if (HW_DESIGN_4K2K_VER == 4)
670 SWDBreg.u16VFRCMWritelimit = 0x240 | F2_V_WRITE_LIMIT_EN;
671 #endif
672 }
673 else
674 {
675 SWDBreg.u16VWritelimit = 0x240 | F1_V_WRITE_LIMIT_EN;
676 #if (HW_DESIGN_4K2K_VER == 4)
677 SWDBreg.u16VFRCMWritelimit = 0x240 | F1_V_WRITE_LIMIT_EN;
678 #endif
679 }
680
681 SWDBreg.u16LBOffset = 0x0;
682 SWDBreg.u16DispOffset = 0x0;
683 if(eWindow == MAIN_WINDOW)
684 {
685 SWDBreg.u16DNROffset = 0x400;
686 SWDBreg.u16OPMOffset = 0x400;
687 SWDBreg.u16DNRFetch = 0x2D0;
688 SWDBreg.u16OPMFetch = 0x2D0;
689 #if (HW_DESIGN_4K2K_VER == 4)
690 SWDBreg.u16FRCM_WOffset = 0x400;
691 SWDBreg.u16FRCM_ROffset = 0x400;
692 SWDBreg.u16FRCM_WFetch = 0x2D0;
693 SWDBreg.u16FRCM_RFetch = 0x2D0;
694 #endif
695 #ifdef UFO_XC_SUPPORT_DUAL_MIU
696 SWDBreg.u16DualDNROffset = 0x400;
697 SWDBreg.u16DualOPMOffset = 0x400;
698 SWDBreg.u16DualDNRFetch = 0x2D0;
699 SWDBreg.u16DualOPMFetch = 0x2D0;
700 #endif
701 }
702 else
703 {
704 SWDBreg.u16DNROffset = 0x80;
705 SWDBreg.u16OPMOffset = 0x80;
706 SWDBreg.u16DNRFetch = 0x80;
707 SWDBreg.u16OPMFetch = 0x80;
708 #if (HW_DESIGN_4K2K_VER == 4)
709 SWDBreg.u16FRCM_WOffset = 0x80;
710 SWDBreg.u16FRCM_ROffset = 0x80;
711 SWDBreg.u16FRCM_WFetch = 0x80;
712 SWDBreg.u16FRCM_RFetch = 0x80;
713 #endif
714 #ifdef UFO_XC_SUPPORT_DUAL_MIU
715 SWDBreg.u16DualDNROffset = 0x80;
716 SWDBreg.u16DualOPMOffset = 0x80;
717 SWDBreg.u16DualDNRFetch = 0x80;
718 SWDBreg.u16DualOPMFetch = 0x80;
719 #endif
720
721 }
722
723 // Attention! Writelimit base also set in MDrv_SC_set_mirror for upper layer usage.
724 if (IsVMirrorMode(eWindow))
725 {
726 SWDBreg.u32OPMBase0 = pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] / BYTE_PER_WORD;
727 SWDBreg.u32OPMBase1 = (pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]/2) / BYTE_PER_WORD;
728 SWDBreg.u32OPMBase2 = 0;
729 SWDBreg.u32DNRBase0 = SWDBreg.u32OPMBase0 + SWDBreg.u16DNROffset * (SWDBreg.u16VLen-1) * 3 / BYTE_PER_WORD;
730 SWDBreg.u32DNRBase1 = SWDBreg.u32OPMBase1 + SWDBreg.u16DNROffset * (SWDBreg.u16VLen-1) * 3 / BYTE_PER_WORD;
731 SWDBreg.u32DNRBase2 = SWDBreg.u32OPMBase2;
732 if(eWindow == MAIN_WINDOW)
733 SWDBreg.u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow]) / BYTE_PER_WORD - 1) | (F2_WRITE_LIMIT_EN | F2_WRITE_LIMIT_MIN);
734 else
735 SWDBreg.u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow]) / BYTE_PER_WORD - 1) | (F1_WRITE_LIMIT_EN | F1_WRITE_LIMIT_MIN);
736 #if (HW_DESIGN_4K2K_VER == 4)
737 SWDBreg.u32FRCM_RBase0 = pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow] / BYTE_PER_WORD;
738 SWDBreg.u32FRCM_RBase1 = (pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow]/2) / BYTE_PER_WORD;
739 SWDBreg.u32FRCM_RBase2 = 0;
740 SWDBreg.u32FRCM_WBase0 = SWDBreg.u32FRCM_RBase0 + SWDBreg.u16FRCM_WOffset * (SWDBreg.u16FRCMVLen-1) * 3 / BYTE_PER_WORD;
741 SWDBreg.u32FRCM_WBase1 = SWDBreg.u32FRCM_RBase1 + SWDBreg.u16FRCM_WOffset * (SWDBreg.u16FRCMVLen-1) * 3 / BYTE_PER_WORD;
742 SWDBreg.u32FRCM_WBase2 = SWDBreg.u32FRCM_RBase2;
743 if(eWindow == MAIN_WINDOW)
744 SWDBreg.u32FRCMWritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow]) / BYTE_PER_WORD - 1) | (F2_WRITE_LIMIT_EN | F2_WRITE_LIMIT_MIN);
745 else
746 SWDBreg.u32FRCMWritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow]) / BYTE_PER_WORD - 1) | (F1_WRITE_LIMIT_EN | F1_WRITE_LIMIT_MIN);
747 #endif
748 #ifdef UFO_XC_SUPPORT_DUAL_MIU
749 SWDBreg.u32DualOPMBase0 = pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBaseAddr0[eWindow] / BYTE_PER_WORD;
750 SWDBreg.u32DualOPMBase1 = (pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBufSize[eWindow]/2) / BYTE_PER_WORD;
751 SWDBreg.u32DualOPMBase2 = 0;
752 SWDBreg.u32DualDNRBase0 = SWDBreg.u32DualOPMBase0 + SWDBreg.u16DualDNROffset * (SWDBreg.u16VLen-1) * 3 / BYTE_PER_WORD;
753 SWDBreg.u32DualDNRBase1 = SWDBreg.u32DualOPMBase1 + SWDBreg.u16DualDNROffset * (SWDBreg.u16VLen-1) * 3 / BYTE_PER_WORD;
754 SWDBreg.u32DualDNRBase2 = SWDBreg.u32DualOPMBase2;
755 if(eWindow == MAIN_WINDOW)
756 SWDBreg.u32DualWritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBaseAddr0[eWindow]) / BYTE_PER_WORD - 1) | (F2_WRITE_LIMIT_EN | F2_WRITE_LIMIT_MIN);
757 else
758 SWDBreg.u32DualWritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBaseAddr0[eWindow]) / BYTE_PER_WORD - 1) | (F1_WRITE_LIMIT_EN | F1_WRITE_LIMIT_MIN);
759 #endif
760 }
761 else
762 {
763 SWDBreg.u32DNRBase0 = SWDBreg.u32OPMBase0 =
764 SWDBreg.u32DNRBase1 = SWDBreg.u32OPMBase1 =
765 SWDBreg.u32DNRBase2 = SWDBreg.u32OPMBase2 = MS_IPM_BASE0(eWindow);
766 if(eWindow == MAIN_WINDOW)
767 SWDBreg.u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow])
768 / BYTE_PER_WORD - 1) | F2_WRITE_LIMIT_EN;
769 else
770 SWDBreg.u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow])
771 / BYTE_PER_WORD - 1) | F1_WRITE_LIMIT_EN;
772 #if (HW_DESIGN_4K2K_VER == 4)
773 SWDBreg.u32FRCM_WBase0 = SWDBreg.u32FRCM_RBase0 =
774 SWDBreg.u32FRCM_WBase1 = SWDBreg.u32FRCM_RBase1 =
775 SWDBreg.u32FRCM_WBase2 = SWDBreg.u32FRCM_RBase2 = MS_FRCM_BASE0(eWindow);
776 if(eWindow == MAIN_WINDOW)
777 SWDBreg.u32FRCMWritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow])
778 / BYTE_PER_WORD - 1) | F2_WRITE_LIMIT_EN;
779 else
780 SWDBreg.u32FRCMWritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow])
781 / BYTE_PER_WORD - 1) | F1_WRITE_LIMIT_EN;
782 #endif
783 #ifdef UFO_XC_SUPPORT_DUAL_MIU
784 SWDBreg.u32DualDNRBase0 = SWDBreg.u32DualOPMBase0 =
785 SWDBreg.u32DualDNRBase1 = SWDBreg.u32DualOPMBase1 =
786 SWDBreg.u32DualDNRBase2 = SWDBreg.u32DualOPMBase2 = MS_IPM_DUAL_MIU_BASE0(eWindow);
787 if(eWindow == MAIN_WINDOW)
788 SWDBreg.u32DualWritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow])
789 / BYTE_PER_WORD - 1) | F2_WRITE_LIMIT_EN;
790 else
791 SWDBreg.u32DualWritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow])
792 / BYTE_PER_WORD - 1) | F1_WRITE_LIMIT_EN;
793 #endif
794 }
795
796 // printf("@@#@@[%s][%d]SWDBreg.u32DNRBase0[%d]=%lx\n", __FUNCTION__, __LINE__, eWindow, SWDBreg.u32DNRBase0);
797 // printf("@@#@@[%s][%d]SWDBreg.u32OPMBase0[%d]=%lx\n", __FUNCTION__, __LINE__, eWindow, SWDBreg.u32OPMBase0);
798 // printf("@@#@@[%s][%d]SWDBreg.u32WritelimitBase[%d]=%lx\n", __FUNCTION__, __LINE__, eWindow, SWDBreg.u32WritelimitBase);
799
800 // printf("@@#@@[%s][%d]SWDBreg.u32FRCM_RBase0[%d]=%lx\n", __FUNCTION__, __LINE__, eWindow, SWDBreg.u32FRCM_RBase0);
801 // printf("@@#@@[%s][%d]SWDBreg.u32FRCM_WBase0[%d]=%lx\n", __FUNCTION__, __LINE__, eWindow, SWDBreg.u32FRCM_WBase0);
802 // printf("@@#@@[%s][%d]SWDBreg.u32FRCMWritelimitBase[%d]=%lx\n", __FUNCTION__, __LINE__, eWindow, SWDBreg.u32FRCMWritelimitBase);
803
804 MDrv_SC_set_write_limit(pInstance, SWDBreg.u32WritelimitBase, eWindow);
805 #if (HW_DESIGN_4K2K_VER == 4)
806 MDrv_SC_set_frcm_write_limit(pInstance, ENABLE, SWDBreg.u32FRCMWritelimitBase, eWindow);
807 #endif
808 #ifdef UFO_XC_SUPPORT_DUAL_MIU
809 MDrv_SC_set_dual_write_limit(pInstance, SWDBreg.u32DualWritelimitBase, eWindow);
810 #endif
811
812
813 #if (ENABLE_OPM_WRITE_SUPPORTED)
814 MS_PHY u32OPWLimitBase = 0x00;
815 u32OPWLimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) ;
816 MDrv_SC_set_opm_write_limit(pInstance, ENABLE, 0 , u32OPWLimitBase , eWindow);
817 #ifdef UFO_XC_SUPPORT_DUAL_MIU
818 u32OPWLimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBufSize[eWindow]) / BYTE_PER_WORD - 1) ;
819 MDrv_SC_set_dual_opm_write_limit(pInstance, ENABLE, 0 , u32OPWLimitBase , eWindow);
820 #endif
821 #endif
822
823 SWDBreg.u16H_CapStart = 0x1;
824 SWDBreg.u16H_CapSize = 0x10;
825 SWDBreg.u16V_CapStart = 0x1;
826 SWDBreg.u16V_CapSize = 0x10;
827 if(eWindow == MAIN_WINDOW)
828 {
829 SWDBreg.u16H_DisStart = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16HStart;
830 SWDBreg.u16H_DisEnd = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16HStart + pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width - 1;
831 SWDBreg.u16V_DisStart = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart;
832 SWDBreg.u16V_DisEnd = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart + pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height - 1;
833 }
834 else
835 {
836 SWDBreg.u16H_DisStart = 0;
837 SWDBreg.u16H_DisEnd = 0xFFF;
838 SWDBreg.u16V_DisStart = 0;
839 SWDBreg.u16V_DisEnd = 0xFFF;
840 }
841 MDrv_SC_sw_db(pInstance, &SWDBreg, eWindow);
842 memcpy(&(gSrcInfo[eWindow].stDispWin), &(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo), sizeof(MS_WINDOW_TYPE));
843 }
844
845 //-------------------------------------------------------------------------------------------------
846 /// Enable or disable scaler memory read/write request
847 /// @param bEnable \b IN: TURE=Enable memory request of 'eType'; FALSE= Disable memory request of 'eType'
848 /// @param eType \b IN: @ref E_XC_MEMORY_REQUEST_TYPE
849 /// @param eWindow \b IN: @ref SCALER_WIN
850 /// @return @ref E_APIXC_ReturnValue
851 //-------------------------------------------------------------------------------------------------
MDrv_XC_SetScalerMemoryRequest(void * pInstance,MS_BOOL bEnable,E_XC_MEMORY_REQUEST_TYPE eRequestType,SCALER_WIN eWindow)852 E_APIXC_ReturnValue MDrv_XC_SetScalerMemoryRequest(void *pInstance, MS_BOOL bEnable, E_XC_MEMORY_REQUEST_TYPE eRequestType, SCALER_WIN eWindow)
853 {
854 E_APIXC_ReturnValue eRet = E_APIXC_RET_OK;
855 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
856 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
857 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
858 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
859 switch(eRequestType)
860 {
861 case E_XC_MEMORY_IP_READ_REQUEST:
862 Hal_SC_IP_Memory_Read_Request(pInstance, bEnable, eWindow);
863 break;
864 case E_XC_MEMORY_IP_WRITE_REQUEST:
865 gSrcInfo[eWindow].Status2.bIPMemWriteRequestDisabled = !bEnable;
866 if(!((eWindow == SUB_WINDOW) &&
867 (bEnable == TRUE)&&
868 (gSrcInfo[eWindow].bBluescreenEnabled == TRUE)))
869 {
870 //Sub window use disable IP memory request to disable input source
871 //So, if bBluescreenEnabled = TRUE, need skip enable SUB IP_Memory_Write
872 Hal_SC_IP_Memory_Write_Request(pInstance, bEnable, eWindow);
873 }
874 break;
875 case E_XC_MEMORY_OP_READ_REQUEST:
876 MDrv_XC_EnableWindow(pInstance, bEnable, eWindow);//Enable/Disable window to ctrl OP read
877 break;
878 case E_XC_MEMORY_OP_WRITE_REQUEST:
879 Hal_SC_OP_Memory_Write_Request(pInstance, bEnable, eWindow);//When disable sub window, OPW also stopped
880 break;
881 default:
882 eRet = E_APIXC_RET_FAIL_ENUM_NOT_SUPPORT;
883 break;
884 }
885 return eRet;
886 }
887
MApi_XC_SetScalerMemoryRequest_U2(void * pInstance,MS_BOOL bEnable,E_XC_MEMORY_REQUEST_TYPE eRequestType,SCALER_WIN eWindow)888 E_APIXC_ReturnValue MApi_XC_SetScalerMemoryRequest_U2(void* pInstance, MS_BOOL bEnable, E_XC_MEMORY_REQUEST_TYPE eRequestType, SCALER_WIN eWindow)
889 {
890 E_APIXC_ReturnValue eReturn = E_APIXC_RET_FAIL;
891 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
892 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
893 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
894 _XC_ENTRY(pInstance);
895 eReturn = MDrv_XC_SetScalerMemoryRequest(pInstance, bEnable, eRequestType, eWindow);
896 _XC_RETURN(pInstance);
897 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
898 return eReturn;
899 }
900
MApi_XC_SetScalerMemoryRequest(MS_BOOL bEnable,E_XC_MEMORY_REQUEST_TYPE eRequestType,SCALER_WIN eWindow)901 E_APIXC_ReturnValue MApi_XC_SetScalerMemoryRequest(MS_BOOL bEnable, E_XC_MEMORY_REQUEST_TYPE eRequestType, SCALER_WIN eWindow)
902 {
903 if (pu32XCInst == NULL)
904 {
905 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
906 return E_APIXC_RET_FAIL;
907 }
908
909 stXC_SET_SCALER_MEMORY_REQUEST XCArgs;
910 XCArgs.bEnable = bEnable;
911 XCArgs.eRequestType = eRequestType;
912 XCArgs.eWindow = eWindow;
913 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
914
915 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_SCALER_MEMORY_REQUEST, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
916 {
917 printf("Obtain XC engine fail\n");
918 return E_APIXC_RET_FAIL;
919 }
920 else
921 {
922 return XCArgs.eReturnValue;
923 }
924 }
925
926 //Obsolte function, do not use it any more
MApi_XC_SetMemoryWriteRequest_U2(void * pInstance,MS_BOOL bEnable)927 E_APIXC_ReturnValue MApi_XC_SetMemoryWriteRequest_U2(void* pInstance, MS_BOOL bEnable)
928 {
929 E_APIXC_ReturnValue eReturn = E_APIXC_RET_FAIL;
930 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
931 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
932 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
933 _XC_ENTRY(pInstance);
934 eReturn = MDrv_XC_SetScalerMemoryRequest(pInstance, bEnable, E_XC_MEMORY_IP_WRITE_REQUEST, MAIN_WINDOW);
935 _XC_RETURN(pInstance);
936 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
937 return eReturn;
938
939 }
940
MApi_XC_SetMemoryWriteRequest(MS_BOOL bEnable)941 E_APIXC_ReturnValue MApi_XC_SetMemoryWriteRequest(MS_BOOL bEnable)
942 {
943 if (pu32XCInst == NULL)
944 {
945 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
946 return E_APIXC_RET_FAIL;
947 }
948
949 stXC_SET_MEMORY_WRITE_REQUEST XCArgs;
950 XCArgs.bEnable = bEnable;
951 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
952
953 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_MEMORY_WRITE_REQUEST, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
954 {
955 printf("Obtain XC engine fail\n");
956 return E_APIXC_RET_FAIL;
957 }
958 else
959 {
960 return XCArgs.eReturnValue;
961 }
962 }
963
964 //-------------------------------------------------------------------------------------------------
965 /// Set DNR base0 address
966 /// @param u32FBAddress \b IN: the framebuffer address
967 /// @param u32FBSize \b IN: the framebuffer size
968 //-------------------------------------------------------------------------------------------------
MApi_XC_SetFrameBufferAddress_U2(void * pInstance,MS_PHY u32FBAddress,MS_PHY u32FBSize,SCALER_WIN eWindow)969 void MApi_XC_SetFrameBufferAddress_U2(void* pInstance, MS_PHY u32FBAddress, MS_PHY u32FBSize, SCALER_WIN eWindow)
970 {
971 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
972 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
973 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
974 _XC_ENTRY(pInstance);
975 MDrv_XC_SetFrameBufferAddress(pInstance, u32FBAddress, u32FBSize, eWindow);
976 _XC_RETURN(pInstance);
977 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
978 }
979
MApi_XC_SetFrameBufferAddress(MS_PHY u32FBAddress,MS_PHY u32FBSize,SCALER_WIN eWindow)980 void MApi_XC_SetFrameBufferAddress(MS_PHY u32FBAddress, MS_PHY u32FBSize, SCALER_WIN eWindow)
981 {
982 if (pu32XCInst == NULL)
983 {
984 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
985 return;
986 }
987
988 stXC_SET_FRAMEBUFFER_ADDRESS XCArgs;
989 XCArgs.u32FBAddress = u32FBAddress;
990 XCArgs.u32FBSize = u32FBSize;
991 XCArgs.eWindow = eWindow;
992
993 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_FRAMEBUFFER_ADDRESS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
994 {
995 printf("Obtain XC engine fail\n");
996 return;
997 }
998 else
999 {
1000 return;
1001 }
1002 }
1003
1004 //-------------------------------------------------------------------------------------------------
1005 /// Set DNR base0 address
1006 /// @param u32FBAddress \b IN: the framebuffer address
1007 /// @param u32FBSize \b IN: the framebuffer size
1008 //-------------------------------------------------------------------------------------------------
MApi_XC_SetFRCMFrameBufferAddress_U2(void * pInstance,MS_PHY u32FBAddress,MS_PHY u32FBSize,SCALER_WIN eWindow)1009 void MApi_XC_SetFRCMFrameBufferAddress_U2(void* pInstance, MS_PHY u32FBAddress, MS_PHY u32FBSize, SCALER_WIN eWindow)
1010 {
1011 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1012 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1013 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1014 _XC_ENTRY(pInstance);
1015 MDrv_XC_SetFRCMFrameBufferAddress(pInstance, u32FBAddress, u32FBSize, eWindow);
1016 _XC_RETURN(pInstance);
1017 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1018 }
1019
MApi_XC_SetFRCMFrameBufferAddress(MS_PHY u32FBAddress,MS_PHY u32FBSize,SCALER_WIN eWindow)1020 void MApi_XC_SetFRCMFrameBufferAddress(MS_PHY u32FBAddress, MS_PHY u32FBSize, SCALER_WIN eWindow)
1021 {
1022 if (pu32XCInst == NULL)
1023 {
1024 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1025 return;
1026 }
1027
1028 stXC_SET_FRAMEBUFFER_ADDRESS XCArgs;
1029 XCArgs.u32FBAddress = u32FBAddress;
1030 XCArgs.u32FBSize = u32FBSize;
1031 XCArgs.eWindow = eWindow;
1032
1033 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_FRCM_FRAMEBUFFER_ADDRESS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1034 {
1035 printf("Obtain XC engine fail\n");
1036 return;
1037 }
1038 else
1039 {
1040 return;
1041 }
1042 }
1043
MDrv_XC_EnableMiuDualMode(void * pInstance,MS_BOOL bEnable,MS_U32 u32LeftFactor,MS_U32 u32RightFactor,SCALER_WIN eWindow)1044 MS_BOOL MDrv_XC_EnableMiuDualMode(void* pInstance, MS_BOOL bEnable, MS_U32 u32LeftFactor, MS_U32 u32RightFactor, SCALER_WIN eWindow)
1045 {
1046 #ifdef UFO_XC_SUPPORT_DUAL_MIU
1047 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1048 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1049 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1050 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1051 gSrcInfo[eWindow].Status2.stMiuDualModCfg.bEnableMiuDualMod = bEnable;
1052 gSrcInfo[eWindow].Status2.stMiuDualModCfg.u32LeftFactor = u32LeftFactor;
1053 gSrcInfo[eWindow].Status2.stMiuDualModCfg.u32RightFactor = u32RightFactor;
1054 #else
1055 return FALSE;
1056 #endif
1057 return TRUE;
1058 }
1059
MDrv_XC_SetFrameBufferAddressSilently(void * pInstance,MS_PHY u32FBAddress,MS_PHY u32FBSize,SCALER_WIN eWindow)1060 void MDrv_XC_SetFrameBufferAddressSilently(void *pInstance, MS_PHY u32FBAddress, MS_PHY u32FBSize, SCALER_WIN eWindow)
1061 {
1062 MS_U8 u8MIUSel = E_CHIP_MIU_0;
1063 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1064 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1065 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1066 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1067 pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] = u32FBAddress;
1068 pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow] = u32FBSize;
1069
1070 if(eWindow == MAIN_WINDOW)
1071 {
1072 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Main_FB_Start_Addr = u32FBAddress;
1073 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Main_FB_Size = u32FBSize;
1074 #if defined (__aarch64__)
1075 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Main_FB_Start_Addr=%lx\n",u32FBAddress);
1076 #else
1077 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Main_FB_Start_Addr=%tx\n",(ptrdiff_t)u32FBAddress);
1078 #endif
1079 }
1080 else
1081 {
1082 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Sub_FB_Start_Addr = u32FBAddress;
1083 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Sub_FB_Size = u32FBSize;
1084 #if defined (__aarch64__)
1085 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Sub_FB_Start_Addr=%lx\n",u32FBAddress);
1086 #else
1087 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Sub_FB_Start_Addr=%tx\n",(ptrdiff_t)u32FBAddress);
1088 #endif
1089 }
1090
1091 _phy_to_miu_offset(u8MIUSel, u32FBAddress, u32FBAddress);
1092 UNUSED(u8MIUSel);
1093 MHal_XC_SetDNRBufAddress(pInstance, u32FBAddress ,eWindow);
1094 MHal_XC_SetDNRBufSize(pInstance, u32FBSize ,eWindow) ;
1095
1096 }
1097
MDrv_XC_SetFRCMFrameBufferAddressSilently(void * pInstance,MS_PHY u32FBAddress,MS_PHY u32FBSize,SCALER_WIN eWindow)1098 void MDrv_XC_SetFRCMFrameBufferAddressSilently(void *pInstance, MS_PHY u32FBAddress, MS_PHY u32FBSize, SCALER_WIN eWindow)
1099 {
1100 #if (HW_DESIGN_4K2K_VER == 4)
1101 MS_U8 u8MIUSel = E_CHIP_MIU_0;
1102
1103 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1104 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1105 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1106 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1107
1108 _phy_to_miu_offset(u8MIUSel, u32FBAddress, u32FBAddress);
1109 UNUSED(u8MIUSel);
1110
1111 pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow] = u32FBAddress;
1112 pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow] = u32FBSize;
1113
1114 if(eWindow == MAIN_WINDOW)
1115 {
1116 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Main_FRCM_FB_Start_Addr = u32FBAddress;
1117 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Main_FRCM_FB_Size = u32FBSize;
1118 #if defined (__aarch64__)
1119 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"u32Main_FRCM_FB_Start_Addr=%lx\n",u32FBAddress);
1120 #else
1121 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"u32Main_FRCM_FB_Start_Addr=%tx\n",(ptrdiff_t)u32FBAddress);
1122 #endif
1123 }
1124 else
1125 {
1126 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Sub_FRCM_FB_Start_Addr = u32FBAddress;
1127 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Sub_FRCM_FB_Size = u32FBSize;
1128 #if defined (__aarch64__)
1129 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"u32Sub_FRCM_FB_Start_Addr=%lx\n",u32FBAddress);
1130 #else
1131 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"u32Sub_FRCM_FB_Start_Addr=%tx\n",(ptrdiff_t)u32FBAddress);
1132 #endif
1133 }
1134 MHal_XC_SetFRCMBufAddress(pInstance, u32FBAddress ,eWindow);
1135 MHal_XC_SetFRCMBufSize(pInstance, u32FBSize ,eWindow) ;
1136
1137 MS_PHY u32FRCMLimitBase = 0x00;
1138 u32FRCMLimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow]) / BYTE_PER_WORD - 1) ;
1139 MDrv_SC_set_frcm_write_limit(pInstance, ENABLE, u32FRCMLimitBase , eWindow);
1140 #endif
1141 }
1142
MDrv_XC_SetFrameBufferAddress(void * pInstance,MS_PHY u32FBAddress,MS_PHY u32FBSize,SCALER_WIN eWindow)1143 void MDrv_XC_SetFrameBufferAddress(void *pInstance, MS_PHY u32FBAddress, MS_PHY u32FBSize, SCALER_WIN eWindow)
1144 {
1145 MS_U8 u8MIUSel = E_CHIP_MIU_0;
1146 MS_BOOL bNeedRestore = FALSE;
1147
1148 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1149 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1150
1151 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
1152 MS_BOOL bNeedChangeInstance = FALSE;
1153 void *pInstanceTmp = NULL;
1154 // change instance to sc1 instance if ewindow is main and using sc1 as sub
1155 if ((psXCInstPri->u32DeviceID != 1) && (eWindow == SUB_WINDOW))
1156 {
1157 pInstanceTmp = pInstance; // store instance 0
1158 pInstance = g_pDevice1Instance; //switch to instance 1
1159 eWindow = MAIN_WINDOW;
1160 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1161 bNeedChangeInstance = TRUE; // mark instance had change
1162 }
1163 #endif
1164
1165
1166 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1167 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1168
1169 if((pXCResourcePrivate->stdrvXC_Scaling._au32PreFBAddress[eWindow] == u32FBAddress)
1170 && (pXCResourcePrivate->stdrvXC_Scaling._au32PreFBSize[eWindow] == u32FBSize))
1171 {
1172 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
1173 if (bNeedChangeInstance == TRUE)
1174 {
1175 pInstance = pInstanceTmp; // restore instance 0
1176 }
1177 #endif
1178 return;
1179 }
1180
1181 pXCResourcePrivate->stdrvXC_Scaling._au32PreFBAddress[eWindow] = u32FBAddress;
1182 pXCResourcePrivate->stdrvXC_Scaling._au32PreFBSize[eWindow] = u32FBSize;
1183
1184 if (Hal_SC_Is_InputSource_Disable(pInstance, eWindow)==0)
1185 {
1186
1187 bNeedRestore = TRUE;
1188 MDrv_XC_DisableInputSource(pInstance, TRUE, eWindow);
1189 //XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"input source (Window:%d) must be disabled before set frame buffer address. Ex:when video play, you can¡¦t use this function. \n",eWindow);
1190 }
1191
1192 //remove the offset
1193 _phy_to_miu_offset(u8MIUSel, u32FBAddress, u32FBAddress);
1194
1195 pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] = u32FBAddress;
1196 pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow] = u32FBSize;
1197
1198 Hal_SC_Enable_MiuMask(pInstance);
1199
1200 Hal_SC_set_freezeimg(pInstance, ENABLE, eWindow);
1201 Hal_SC_set_miusel(pInstance, u8MIUSel);
1202
1203 if (IsVMirrorMode(eWindow))
1204 {
1205 Hal_SC_set_memoryaddress(pInstance,
1206 u32FBAddress+ u32FBSize-1-0x100000, u32FBAddress+ u32FBSize-1-0x100000, u32FBAddress+ u32FBSize-1-0x100000,
1207 u32FBAddress+ u32FBSize-1-0x100000, u32FBAddress+ u32FBSize-1-0x100000, u32FBAddress+ u32FBSize-1-0x100000, eWindow);
1208 }
1209 else
1210 {
1211 Hal_SC_set_memoryaddress(pInstance,
1212 u32FBAddress, u32FBAddress, u32FBAddress,
1213 u32FBAddress, u32FBAddress, u32FBAddress, eWindow);
1214 }
1215 MDrv_SC_set_mirrorEx(pInstance, gSrcInfo[eWindow].Status2.eMirrorMode, eWindow); // set write limit address
1216
1217
1218 #if (ENABLE_OPM_WRITE_SUPPORTED)
1219 MS_PHY u32OPWLimitBase = 0x00;
1220
1221 u32OPWLimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) ;
1222 MDrv_SC_set_opm_write_limit(pInstance, ENABLE, 0 , u32OPWLimitBase , eWindow);
1223 #endif
1224
1225
1226 Hal_SC_set_freezeimg(pInstance, DISABLE, eWindow);
1227
1228 Hal_SC_Disable_MiuMask(pInstance);
1229
1230 if(eWindow == MAIN_WINDOW)
1231 {
1232 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Main_FB_Start_Addr = pXCResourcePrivate->stdrvXC_Scaling._au32PreFBAddress[eWindow];
1233 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Main_FB_Size = pXCResourcePrivate->stdrvXC_Scaling._au32PreFBSize[eWindow];
1234 #if defined (__aarch64__)
1235 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Change Main_FB_Start_Addr=%lx, Size=%lx\n", u32FBAddress, u32FBSize);
1236 #else
1237 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Change Main_FB_Start_Addr=%tx, Size=%tx\n", (ptrdiff_t)u32FBAddress, (ptrdiff_t)u32FBSize);
1238 #endif
1239 }
1240 else
1241 {
1242 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Sub_FB_Start_Addr = pXCResourcePrivate->stdrvXC_Scaling._au32PreFBAddress[eWindow];
1243 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Sub_FB_Size = pXCResourcePrivate->stdrvXC_Scaling._au32PreFBSize[eWindow];
1244 #if defined (__aarch64__)
1245 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Change Sub_FB_Start_Addr=%lx, Size=%lx\n", u32FBAddress, u32FBSize);
1246 #else
1247 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Change Sub_FB_Start_Addr=%tx, Size=%tx\n", (ptrdiff_t)u32FBAddress, (ptrdiff_t)u32FBSize);
1248 #endif
1249 }
1250
1251 MHal_XC_SetDNRBufAddress(pInstance, u32FBAddress ,eWindow);
1252 MHal_XC_SetDNRBufSize(pInstance, u32FBSize ,eWindow) ;
1253
1254 #if ((HW_DESIGN_4K2K_VER == 4)||(HW_DESIGN_4K2K_VER == 6))
1255 MS_PHY u32WLimitBase = 0x00;
1256 if (eWindow == MAIN_WINDOW)
1257 u32WLimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) | F2_WRITE_LIMIT_EN;
1258 else
1259 u32WLimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) | F1_WRITE_LIMIT_EN;
1260
1261 MDrv_SC_set_write_limit(pInstance, u32WLimitBase , eWindow);
1262 #endif
1263
1264 if(MAIN_WINDOW == eWindow)
1265 {
1266 //Main window
1267 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_07_L, 0, BIT(4) |BIT(5) |BIT(6));
1268 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_07_L, 0, BIT(7));
1269 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_07_L, BIT(7), BIT(7));
1270 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_07_L, 0, BIT(7));
1271 }
1272 else
1273 {
1274 //Sub window
1275 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_47_L, BIT(4), BIT(4) |BIT(5) |BIT(6));
1276 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_47_L, 0, BIT(7));
1277 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_47_L, BIT(7), BIT(7));
1278 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_47_L, 0, BIT(7));
1279 }
1280
1281 if (bNeedRestore == TRUE)
1282 {
1283 bNeedRestore = FALSE;
1284 MDrv_XC_DisableInputSource(pInstance, FALSE, eWindow);
1285 }
1286 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
1287 if (bNeedChangeInstance == TRUE)
1288 {
1289 pInstance = pInstanceTmp; // restore instance 0
1290 }
1291 #endif
1292 }
1293
MDrv_XC_SetDualFrameBufferAddress(void * pInstance,MS_PHY u32FBAddress,MS_PHY u32FBSize,SCALER_WIN eWindow)1294 MS_BOOL MDrv_XC_SetDualFrameBufferAddress(void *pInstance, MS_PHY u32FBAddress, MS_PHY u32FBSize, SCALER_WIN eWindow)
1295 {
1296 MS_BOOL bRet = FALSE;
1297 #ifdef UFO_XC_SUPPORT_DUAL_MIU
1298 MS_U8 u8MIUSel = E_CHIP_MIU_0;
1299 MS_BOOL bNeedRestore = FALSE;
1300
1301 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1302 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1303
1304 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1305 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1306 #if (HW_DESIGN_4K2K_VER == 6)
1307 if (eWindow == SUB_WINDOW)
1308 {
1309 return bRet;
1310 }
1311 #endif
1312 if((pXCResourcePrivate->stdrvXC_Scaling._u32PreDualFBAddress[eWindow] == u32FBAddress)
1313 && (pXCResourcePrivate->stdrvXC_Scaling._u32PreDualFBSize[eWindow] == u32FBSize))
1314 {
1315 return FALSE;
1316 }
1317 pXCResourcePrivate->stdrvXC_Scaling._u32PreDualFBAddress[eWindow] = u32FBAddress;
1318 pXCResourcePrivate->stdrvXC_Scaling._u32PreDualFBSize[eWindow] = u32FBSize;
1319
1320 if (Hal_SC_Is_InputSource_Disable(pInstance, eWindow)==0)
1321 {
1322
1323 bNeedRestore = TRUE;
1324 MDrv_XC_DisableInputSource(pInstance, TRUE, eWindow);
1325 //XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"input source (Window:%d) must be disabled before set frame buffer address. Ex:when video play, you can¡¦t use this function. \n",eWindow);
1326 }
1327
1328 //remove the offset
1329 _phy_to_miu_offset(u8MIUSel, u32FBAddress, u32FBAddress);
1330
1331 pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBaseAddr0[eWindow] = u32FBAddress;
1332 pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBufSize[eWindow] = u32FBSize;
1333
1334 Hal_SC_Enable_MiuMask(pInstance);
1335
1336 Hal_SC_set_freezeimg(pInstance, ENABLE, eWindow);
1337 Hal_SC_set_dual_miusel(pInstance, u8MIUSel);
1338
1339 if (IsVMirrorMode(eWindow))
1340 {
1341 Hal_SC_set_dual_memoryaddress(pInstance,
1342 u32FBAddress+ u32FBSize-1-0x100000, u32FBAddress+ u32FBSize-1-0x100000, u32FBAddress+ u32FBSize-1-0x100000,
1343 u32FBAddress+ u32FBSize-1-0x100000, u32FBAddress+ u32FBSize-1-0x100000, u32FBAddress+ u32FBSize-1-0x100000, eWindow);
1344 }
1345 else
1346 {
1347 Hal_SC_set_dual_memoryaddress(pInstance,
1348 u32FBAddress, u32FBAddress, u32FBAddress,
1349 u32FBAddress, u32FBAddress, u32FBAddress, eWindow);
1350 }
1351 //FIXME: Richard.Deng check support dual miu
1352 MDrv_SC_set_mirrorEx(pInstance, gSrcInfo[eWindow].Status2.eMirrorMode, eWindow); // set write limit address
1353
1354
1355 #if (ENABLE_OPM_WRITE_SUPPORTED)
1356 MS_PHY u32OPWLimitBase = 0x00;
1357
1358 u32OPWLimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBufSize[eWindow]) / BYTE_PER_WORD - 1) ;
1359 MDrv_SC_set_dual_opm_write_limit(pInstance, ENABLE, 0 , u32OPWLimitBase , eWindow);
1360 #endif
1361
1362
1363 Hal_SC_set_freezeimg(pInstance, DISABLE, eWindow);
1364
1365 Hal_SC_Disable_MiuMask(pInstance);
1366 //Monet default use cma, this will be opened for no cma dual case
1367 #if 0
1368 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Dual_FB_Start_Addr[eWindow] = pXCResourcePrivate->stdrvXC_Scaling._u32PreDualFBAddress[eWindow];
1369 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Dual_FB_Size[eWindow] = pXCResourcePrivate->stdrvXC_Scaling._u32PreDualFBSize[eWindow];
1370 #endif
1371 #if defined (__aarch64__)
1372 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Change Dual_FB_Start_Addr[%d] =%lx, Size=%lx\n", eWindow, u32FBAddress, u32FBSize);
1373 #else
1374 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Change Dual_FB_Start_Addr[%d] =%llx, Size=%llx\n", eWindow, u32FBAddress, u32FBSize);
1375 #endif
1376
1377 MHal_XC_SetDualDNRBufAddress(pInstance, u32FBAddress ,eWindow);
1378 MHal_XC_SetDualDNRBufSize(pInstance, u32FBSize ,eWindow) ;
1379
1380 #if (HW_DESIGN_4K2K_VER == 6)
1381 MS_PHY u32WLimitBase = 0x00;
1382 u32WLimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBufSize[eWindow]) / BYTE_PER_WORD - 1) | F2_WRITE_LIMIT_EN ;
1383 MDrv_SC_set_dual_write_limit(pInstance, u32WLimitBase , eWindow);
1384 #endif
1385
1386 if (bNeedRestore == TRUE)
1387 {
1388 bNeedRestore = FALSE;
1389 MDrv_XC_DisableInputSource(pInstance, FALSE, eWindow);
1390 }
1391 bRet = TRUE;
1392 #endif
1393 return bRet;
1394 }
1395
MDrv_XC_SetFRCMFrameBufferAddress(void * pInstance,MS_PHY u32FBAddress,MS_PHY u32FBSize,SCALER_WIN eWindow)1396 void MDrv_XC_SetFRCMFrameBufferAddress(void *pInstance, MS_PHY u32FBAddress, MS_PHY u32FBSize, SCALER_WIN eWindow)
1397 {
1398 MS_U8 u8MIUSel = E_CHIP_MIU_0;
1399 MS_BOOL bNeedRestore = FALSE;
1400
1401 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1402 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1403
1404 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1405 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1406 // is need to do for str?
1407 #if 0
1408 if((pXCResourcePrivate->stdrvXC_Scaling._au32PreFBAddress[eWindow] == u32FBAddress)
1409 && (pXCResourcePrivate->stdrvXC_Scaling._au32PreFBSize[eWindow] == u32FBSize))
1410 {
1411 return;
1412 }
1413
1414 pXCResourcePrivate->stdrvXC_Scaling._au32PreFBAddress[eWindow] = u32FBAddress;
1415 pXCResourcePrivate->stdrvXC_Scaling._au32PreFBSize[eWindow] = u32FBSize;
1416 #endif
1417 MS_PHY u32PreFBAddress = u32FBAddress;
1418 MS_PHY u32PreFBSize = u32FBSize;
1419
1420 if (Hal_SC_Is_InputSource_Disable(pInstance, eWindow)==0)
1421 {
1422
1423 bNeedRestore = TRUE;
1424 MDrv_XC_DisableInputSource(pInstance, TRUE, eWindow);
1425 //XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"input source (Window:%d) must be disabled before set frame buffer address. Ex:when video play, you can¡¦t use this function. \n",eWindow);
1426 }
1427
1428 //remove the offset
1429 _phy_to_miu_offset(u8MIUSel, u32FBAddress, u32FBAddress);
1430
1431 pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow] = u32FBAddress;
1432 pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow] = u32FBSize;
1433
1434 Hal_SC_Enable_MiuMask(pInstance);
1435
1436 Hal_SC_set_frcm_freezeimg(pInstance, ENABLE, eWindow);
1437 Hal_SC_set_miusel(pInstance, u8MIUSel);
1438
1439 if (IsVMirrorMode(eWindow))
1440 {
1441 Hal_SC_set_frcm_memoryaddress(pInstance,
1442 u32FBAddress+ u32FBSize-1-0x100000, u32FBAddress+ u32FBSize-1-0x100000, u32FBAddress+ u32FBSize-1-0x100000,
1443 u32FBAddress+ u32FBSize-1-0x100000, u32FBAddress+ u32FBSize-1-0x100000, u32FBAddress+ u32FBSize-1-0x100000, eWindow);
1444 }
1445 else
1446 {
1447 Hal_SC_set_frcm_memoryaddress(pInstance,
1448 u32FBAddress, u32FBAddress, u32FBAddress,
1449 u32FBAddress, u32FBAddress, u32FBAddress, eWindow);
1450 }
1451 MDrv_SC_set_mirrorEx(pInstance, gSrcInfo[eWindow].Status2.eMirrorMode, eWindow); // set write limit address
1452
1453 #if (HW_DESIGN_4K2K_VER == 4)
1454 MHal_XC_SetFRCMBufAddress(pInstance, u32FBAddress ,eWindow);
1455 MHal_XC_SetFRCMBufSize(pInstance, u32FBSize ,eWindow) ;
1456 #endif
1457
1458 #if (HW_DESIGN_4K2K_VER == 4)
1459 MS_PHY u32FRCMLimitBase = 0x00;
1460
1461 u32FRCMLimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow]) / BYTE_PER_WORD - 1) ;
1462 MDrv_SC_set_frcm_write_limit(pInstance, ENABLE, u32FRCMLimitBase , eWindow);
1463 #endif
1464
1465 Hal_SC_set_frcm_freezeimg(pInstance, DISABLE, eWindow);
1466
1467 Hal_SC_Disable_MiuMask(pInstance);
1468
1469 if(eWindow == MAIN_WINDOW)
1470 {
1471 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Main_FRCM_FB_Start_Addr = u32PreFBAddress;
1472 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Main_FRCM_FB_Size = u32PreFBSize;
1473 #if defined (__aarch64__)
1474 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Change Main_FB_Start_Addr=%lx, Size=%lx\n", u32FBAddress, u32FBSize);
1475 #else
1476 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Change Main_FB_Start_Addr=%tx, Size=%tx\n", (ptrdiff_t)u32FBAddress, (ptrdiff_t)u32FBSize);
1477 #endif
1478 }
1479 else
1480 {
1481 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Sub_FRCM_FB_Start_Addr = u32PreFBAddress;
1482 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Sub_FRCM_FB_Size = u32PreFBSize;
1483 #if defined (__aarch64__)
1484 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Change Sub_FB_Start_Addr=%lx, Size=%lx\n", u32FBAddress, u32FBSize);
1485 #else
1486 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Change Sub_FB_Start_Addr=%tx, Size=%tx\n", (ptrdiff_t)u32FBAddress, (ptrdiff_t)u32FBSize);
1487 #endif
1488 }
1489
1490
1491 if(MAIN_WINDOW == eWindow)
1492 {
1493 //Main window
1494 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK32_07_L, BIT(4), BIT(4) |BIT(5) |BIT(6));
1495 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK32_07_L, 0, BIT(7));
1496 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK32_07_L, BIT(7), BIT(7));
1497 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK32_07_L, 0, BIT(7));
1498 }
1499 else
1500 {
1501 //Sub window
1502 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK32_47_L, BIT(4), BIT(4) |BIT(5) |BIT(6));
1503 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK32_47_L, 0, BIT(7));
1504 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK32_47_L, BIT(7), BIT(7));
1505 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK32_47_L, 0, BIT(7));
1506 }
1507
1508 if (bNeedRestore == TRUE)
1509 {
1510 bNeedRestore = FALSE;
1511 MDrv_XC_DisableInputSource(pInstance, FALSE, eWindow);
1512 }
1513 }
1514
MApi_XC_IsFrameBufferEnoughForCusScaling_U2(void * pInstance,XC_SETWIN_INFO * pstXC_SetWin_Info,SCALER_WIN eWindow)1515 MS_BOOL MApi_XC_IsFrameBufferEnoughForCusScaling_U2(void* pInstance, XC_SETWIN_INFO *pstXC_SetWin_Info, SCALER_WIN eWindow)
1516 {
1517 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1518 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1519 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1520
1521 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1522 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1523 //DTV max u8BitsPerPixel is 24. And here only consider 2 frame mode.
1524 if ((MS_PHY)pstXC_SetWin_Info->u16PreVCusScalingDst *
1525 (MS_PHY)pstXC_SetWin_Info->u16PreHCusScalingDst * 24 * 2 > pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow] * 8)
1526 {
1527 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1528 return FALSE;
1529 }
1530 else
1531 {
1532 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1533 return TRUE;
1534 }
1535 }
1536
MApi_XC_IsFrameBufferEnoughForCusScaling(XC_SETWIN_INFO * pstXC_SetWin_Info,SCALER_WIN eWindow)1537 MS_BOOL MApi_XC_IsFrameBufferEnoughForCusScaling(XC_SETWIN_INFO *pstXC_SetWin_Info, SCALER_WIN eWindow)
1538 {
1539 if (pu32XCInst == NULL)
1540 {
1541 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1542 return FALSE;
1543 }
1544
1545 stXC_CHECK_FRAMEBUFFER_ENOUGH_FOR_CUSSCALING XCArgs;
1546 XCArgs.pstXC_SetWin_Info = pstXC_SetWin_Info;
1547 XCArgs.eWindow = eWindow;
1548 XCArgs.bReturnValue = FALSE;
1549
1550 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_CHECK_FRAMEBUFFER_ENOUGH_FOR_CUSSCALING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1551 {
1552 printf("Obtain XC engine fail\n");
1553 return FALSE;
1554 }
1555 else
1556 {
1557 return XCArgs.bReturnValue;
1558 }
1559 }
1560
MDrv_SC_set_fbl(void * pInstance,MS_BOOL bEn)1561 void MDrv_SC_set_fbl(void *pInstance, MS_BOOL bEn)
1562 {
1563 Hal_SC_set_fbl(pInstance, bEn);
1564 }
1565
MDrv_SC_get_fbl(void * pInstance)1566 MS_BOOL MDrv_SC_get_fbl(void *pInstance)
1567 {
1568 return Hal_SC_get_fbl(pInstance);
1569 }
1570
1571
1572 /******************************************************************************/
1573 ///Set Capture window (Input window) information.
1574 ///@param pstWindow \b IN
1575 ///- pointer to window information
1576 /******************************************************************************/
MDrv_sc_set_capture_window(void * pInstance,SCALER_WIN eWindow)1577 void MDrv_sc_set_capture_window(void *pInstance, SCALER_WIN eWindow)
1578 {
1579 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1580 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1581 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1582 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1583 // HDMI HV mode uses DE by pass, so capture win should be set as full range
1584 if( ( IsSrcTypeHDMI( gSrcInfo[eWindow].enInputSourceType ) ) && (MDrv_XC_GetHdmiSyncMode(pInstance) == HDMI_SYNC_HV) )
1585 {
1586 // Capture win must keep full range in HV mode
1587 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_CapStart = 0xC;
1588 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16H_CapStart = 0xC;
1589 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_CapSize = 0x1FFF;
1590 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16H_CapSize = 0x1FFF;
1591 }
1592 else
1593 {
1594 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_CapStart = gSrcInfo[eWindow].stCapWin.y;
1595 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16H_CapStart = gSrcInfo[eWindow].stCapWin.x;
1596 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_CapSize = gSrcInfo[eWindow].stCapWin.height;
1597 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16H_CapSize = gSrcInfo[eWindow].stCapWin.width;
1598
1599 // In Force Interlace mode, upper layer does not know we already change the V capture size.
1600 // So we correct it here.
1601 if (MDrv_SC_GetInterlaceInPModeStatus(pInstance, eWindow)
1602 && (MDrv_XC_GetForceiSupportType(pInstance) == ForceI_SW))
1603 {
1604 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_CapStart = (pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_CapStart+1) * 2;
1605 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_CapSize <<=1;
1606 }
1607 }
1608
1609 }
1610
1611
1612 /******************************************************************************/
1613 ///Set output display window size
1614 ///@param pstWindow \b IN
1615 ///- pointer to window information
1616 /******************************************************************************/
MDrv_SC_set_display_window(void * pInstance,SCALER_WIN eWindow)1617 void MDrv_SC_set_display_window(void *pInstance, SCALER_WIN eWindow)
1618 {
1619 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1620 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1621 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1622 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1623 if(gSrcInfo[eWindow].bDisplayNineLattice)
1624 {
1625 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16H_DisStart = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16HStart;
1626 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16H_DisEnd = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16HStart +pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width-1;
1627 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_DisStart = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart;
1628 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_DisEnd = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart + pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height-1;
1629 }
1630 else
1631 {
1632 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16H_DisStart = gSrcInfo[eWindow].stDispWin.x;
1633
1634 if ( gSrcInfo[eWindow].stDispWin.width == 0 )
1635 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16H_DisEnd = gSrcInfo[eWindow].stDispWin.x;
1636 else
1637 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16H_DisEnd = gSrcInfo[eWindow].stDispWin.x + gSrcInfo[eWindow].stDispWin.width - 1;
1638
1639 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_DisStart = gSrcInfo[eWindow].stDispWin.y;
1640
1641 if ( gSrcInfo[eWindow].stDispWin.height == 0 )
1642 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_DisEnd = gSrcInfo[eWindow].stDispWin.y;
1643 else
1644 {
1645 #ifndef DISABLE_3D_FUNCTION
1646 //dualview case handling
1647 if( MDrv_SC_3D_Is_LR_Sbs2Line(pInstance) &&
1648 (E_XC_3D_INPUT_MODE_NONE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow)) &&
1649 (MAIN_WINDOW == eWindow))
1650 {
1651 if(IsVMirrorMode(eWindow) )
1652 {
1653 if(gSrcInfo[eWindow].stDispWin.y >= gSrcInfo[eWindow].stDispWin.height)
1654 {
1655 gSrcInfo[eWindow].stDispWin.y -= gSrcInfo[eWindow].stDispWin.height;
1656 }
1657 else
1658 {
1659 gSrcInfo[eWindow].stDispWin.y = 0;
1660 }
1661 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_DisStart = gSrcInfo[eWindow].stDispWin.y;
1662 }
1663 //main window need set to fullscreen to prevent show garbage when atv mirror channel change
1664 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_DisEnd = gSrcInfo[eWindow].stDispWin.y + gSrcInfo[eWindow].stDispWin.height * 2 - 1;
1665 }
1666 else
1667 #endif
1668 {
1669 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16V_DisEnd = gSrcInfo[eWindow].stDispWin.y + gSrcInfo[eWindow].stDispWin.height - 1;
1670 }
1671 }
1672 }
1673 }
1674
1675
1676 /******************************************************************************/
1677 ///Fill display window according to panel
1678 /******************************************************************************/
1679
MDrv_SC_set_std_display_window(void * pInstance,SCALER_WIN eWindow)1680 void MDrv_SC_set_std_display_window(void *pInstance, SCALER_WIN eWindow)
1681 {
1682 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1683 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1684 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1685 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1686 gSrcInfo[eWindow].stDispWin.x = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16HStart;
1687 gSrcInfo[eWindow].stDispWin.y = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart;
1688 gSrcInfo[eWindow].stDispWin.width = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width;
1689 gSrcInfo[eWindow].stDispWin.height = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height;
1690 }
1691
1692 //////////////////////////////////////////////////////////////////
1693 // Compute ScaledCropWin according to CropWin and prescaling ratio
1694 // parameter:
1695 // [IN/OUT] pSrcInfo->stCropWin
1696 // [IN/OUT] pSrcInfo->stScaledCropWin
1697 // [IN] pSrcInfo->u16H_CapSize
1698 // [IN] pSrcInfo->u16H_SizeAfterPreScaling
1699 // [IN] pSrcInfo->u16V_CapSize
1700 // [IN] pSrcInfo->u16V_SizeAfterPreScaling
1701 //
MDrv_SC_set_crop_window(void * pInstance,XC_InternalStatus * pSrcInfo,SCALER_WIN eWindow)1702 void MDrv_SC_set_crop_window(void *pInstance, XC_InternalStatus *pSrcInfo, SCALER_WIN eWindow)
1703 {
1704 MS_WINDOW_TYPE *pCropWin = &pSrcInfo->stCropWin;
1705
1706 // for Compression mode
1707 MS_BOOL bopm_lcnt_inv = FALSE;
1708 MS_U8 u8ScaledCropY = 0;
1709 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1710 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1711 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1712 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1713 if(pSrcInfo->stCapWin.width == 0 || pSrcInfo->stCapWin.height == 0)
1714 {
1715 printf("XC CapWin is error ! (Width=%d,Height=%d)\n",pSrcInfo->stCapWin.width,pSrcInfo->stCapWin.height);
1716 return;
1717 }
1718
1719 if(!pSrcInfo->bDisplayNineLattice) // need refine for dircet display
1720 {
1721 gSrcInfo[eWindow].ScaledCropWin.x = (MS_U16)((MS_U32)pCropWin->x * pSrcInfo->u16H_SizeAfterPreScaling / pSrcInfo->stCapWin.width);
1722 gSrcInfo[eWindow].ScaledCropWin.width = (MS_U16)( ( (MS_U32)pCropWin->width * pSrcInfo->u16H_SizeAfterPreScaling + ( pSrcInfo->stCapWin.width / 2 ) ) / pSrcInfo->stCapWin.width);
1723
1724 gSrcInfo[eWindow].ScaledCropWin.y = (MS_U16)( (MS_U32) pCropWin->y * pSrcInfo->u16V_SizeAfterPreScaling / pSrcInfo->stCapWin.height);
1725 gSrcInfo[eWindow].ScaledCropWin.height= (MS_U16)( ( (MS_U32)pCropWin->height * pSrcInfo->u16V_SizeAfterPreScaling + ( pSrcInfo->stCapWin.height / 2 ) ) / pSrcInfo->stCapWin.height);
1726 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"W=%u, W PSD=%u\n", pSrcInfo->stCapWin.width , pSrcInfo->u16H_SizeAfterPreScaling);
1727 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Scaled crop[1] x,y,w,h=%u,%u,%u,%u\n",gSrcInfo[eWindow].ScaledCropWin.x, gSrcInfo[eWindow].ScaledCropWin.y, gSrcInfo[eWindow].ScaledCropWin.width, gSrcInfo[eWindow].ScaledCropWin.height);
1728
1729 // Scaled crop win may introduce imprecise calculation result, which may lead to pre and post scaling both working
1730 // When driver do auto fit, we only want one of pre and post working
1731 // Here we ensure only pre scaling is working
1732 // This may conflict with 3D, need refine later
1733 #if (HW_DESIGN_3D_VER >= 2)
1734 #ifndef DISABLE_3D_FUNCTION
1735 if(MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow) == E_XC_3D_INPUT_MODE_NONE)
1736 #endif
1737 {
1738 //HW version 1's display window is 1/2 of panel's display width in output side by side case.
1739 //so not into here. but HW version >1's display width is same with the panel.
1740 if((gSrcInfo[eWindow].ScaledCropWin.width != pSrcInfo->stDispWin.width) &&
1741 (pXCResourcePrivate->stdrvXC_Scaling._bHAutoFitPrescalingEna == TRUE))
1742 {
1743 //XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Force change ScaledCropWin.width: %u->%u\n", gSrcInfo[eWindow].ScaledCropWin.width, pSrcInfo->stDispWin.width);
1744 gSrcInfo[eWindow].ScaledCropWin.width = pSrcInfo->stDispWin.width;
1745 }
1746
1747 if((gSrcInfo[eWindow].ScaledCropWin.height != pSrcInfo->stDispWin.height) &&
1748 (pXCResourcePrivate->stdrvXC_Scaling._bVAutoFitPrescalingEna == TRUE))
1749 {
1750 //XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Force change ScaledCropWin.height: %u->%u\n", gSrcInfo[eWindow].ScaledCropWin.height, pSrcInfo->stDispWin.height);
1751 gSrcInfo[eWindow].ScaledCropWin.height= pSrcInfo->stDispWin.height;
1752 }
1753 }
1754 #endif
1755 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Scaled crop[2] x,y,w,h=%u,%u,%u,%u\n",gSrcInfo[eWindow].ScaledCropWin.x, gSrcInfo[eWindow].ScaledCropWin.y, gSrcInfo[eWindow].ScaledCropWin.width, gSrcInfo[eWindow].ScaledCropWin.height);
1756
1757 #ifdef ENABLE_SCALING_WO_MUTE
1758 // For H scaling down to too small size, there is HW limitation only support 16x H scaling down
1759 MDrv_SC_Adjust_H_Crop(pInstance, eWindow);
1760 #endif
1761
1762 u8ScaledCropY = gSrcInfo[eWindow].ScaledCropWin.y;
1763
1764 // Error handling.
1765 if (IsVMirrorMode(eWindow))//Error handling for mirror case
1766 {
1767 #ifndef DISABLE_3D_FUNCTION
1768 MDrv_SC_3D_AdjustMirrorCrop(pInstance, pSrcInfo,eWindow);
1769 #endif
1770 }
1771 else//Error handling for Non-mirror case
1772 {
1773 if(!MDrv_XC_Is_SupportSWDS(pInstance))
1774 {
1775 if( pSrcInfo->u16H_SizeAfterPreScaling < (gSrcInfo[eWindow].ScaledCropWin.width + gSrcInfo[eWindow].ScaledCropWin.x) )
1776 {
1777 if(gSrcInfo[eWindow].ScaledCropWin.width <= pSrcInfo->u16H_SizeAfterPreScaling)
1778 {
1779 gSrcInfo[eWindow].ScaledCropWin.x = (pSrcInfo->u16H_SizeAfterPreScaling - gSrcInfo[eWindow].ScaledCropWin.width);
1780 }
1781 else
1782 {
1783 gSrcInfo[eWindow].ScaledCropWin.x = 0;
1784 gSrcInfo[eWindow].ScaledCropWin.width = pSrcInfo->u16H_SizeAfterPreScaling;
1785 }
1786 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Scaled crop[2.c] Force x=%u, width=%u\n",gSrcInfo[eWindow].ScaledCropWin.x, gSrcInfo[eWindow].ScaledCropWin.width);
1787 }
1788 }
1789
1790 #if (HW_DESIGN_4K2K_VER == 4)
1791 if(gSrcInfo[eWindow].bInterlace
1792 &&
1793 (((psXCInstPri->u32DeviceID == 0) && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_LEGACY_MODE))
1794 ||(psXCInstPri->u32DeviceID == 1)))
1795 #else
1796 // for interlace, keep y in multiple of 2
1797 if(gSrcInfo[eWindow].bInterlace)
1798 #endif
1799 {
1800 gSrcInfo[eWindow].ScaledCropWin.y = (gSrcInfo[eWindow].ScaledCropWin.y + 1) & ~0x1;
1801 gSrcInfo[eWindow].ScaledCropWin.height = gSrcInfo[eWindow].ScaledCropWin.height & ~0x1;
1802 }
1803
1804 if(!MDrv_XC_Is_SupportSWDS(pInstance))
1805 {
1806 if( pSrcInfo->u16V_SizeAfterPreScaling < (gSrcInfo[eWindow].ScaledCropWin.height + gSrcInfo[eWindow].ScaledCropWin.y) )
1807 {
1808 if(gSrcInfo[eWindow].ScaledCropWin.height <= pSrcInfo->u16V_SizeAfterPreScaling)
1809 {
1810 gSrcInfo[eWindow].ScaledCropWin.y = (pSrcInfo->u16V_SizeAfterPreScaling - gSrcInfo[eWindow].ScaledCropWin.height) & ~0x1;
1811 }
1812 else
1813 {
1814 gSrcInfo[eWindow].ScaledCropWin.height = pSrcInfo->u16V_SizeAfterPreScaling;
1815 }
1816 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Scaled crop[2.d] Force y=%u, height=%u\n",gSrcInfo[eWindow].ScaledCropWin.y, gSrcInfo[eWindow].ScaledCropWin.height);
1817 }
1818 }
1819 }
1820
1821 #if (HW_DESIGN_4K2K_VER == 4)
1822 if(gSrcInfo[eWindow].bInterlace
1823 &&
1824 (((psXCInstPri->u32DeviceID == 0) && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_LEGACY_MODE))
1825 ||(psXCInstPri->u32DeviceID == 1)))
1826 #else
1827 if(gSrcInfo[eWindow].bInterlace)
1828 #endif
1829 {
1830 gSrcInfo[eWindow].ScaledCropWin.height = gSrcInfo[eWindow].ScaledCropWin.height & ~0x1;
1831 }
1832
1833 #ifdef SUPPORT_BWD
1834 //For BWR: XC write memory using YUV420, ScaledCropWin.y/ScaledCropWin.heigh need 2 align.
1835 if ((IS_INPUT_TOP_BOTTOM(eWindow) || IS_INPUT_LINE_ALTERNATIVE(eWindow) || IS_INPUT_FRAME_PACKING(eWindow))
1836 && (!IS_OUTPUT_MODE_NONE()))
1837 {
1838 // 3D case: SN have crop.Y/2 as L/R view
1839 gSrcInfo[eWindow].ScaledCropWin.y = (gSrcInfo[eWindow].ScaledCropWin.y + 1) & ~0x1;
1840 // 3D case: crop.Height/2 need to do in utopia
1841 gSrcInfo[eWindow].ScaledCropWin.height = gSrcInfo[eWindow].ScaledCropWin.height & ~0x3;
1842
1843 if(!MDrv_XC_Is_SupportSWDS(pInstance))
1844 {
1845 // check crop.height out of window.
1846 if( pSrcInfo->u16V_SizeAfterPreScaling < (gSrcInfo[eWindow].ScaledCropWin.height + gSrcInfo[eWindow].ScaledCropWin.y) )
1847 {
1848 gSrcInfo[eWindow].ScaledCropWin.height -=4;
1849 }
1850 }
1851 }
1852 else
1853 {
1854 // For no-3D, just need crop.y and crop.height 2 align.
1855 gSrcInfo[eWindow].ScaledCropWin.y = (gSrcInfo[eWindow].ScaledCropWin.y + 1) & ~0x1;
1856 gSrcInfo[eWindow].ScaledCropWin.height = gSrcInfo[eWindow].ScaledCropWin.height & ~0x1;
1857 if(!MDrv_XC_Is_SupportSWDS(pInstance))
1858 {
1859 // check crop.height out of window.
1860 if( pSrcInfo->u16V_SizeAfterPreScaling < (gSrcInfo[eWindow].ScaledCropWin.height + gSrcInfo[eWindow].ScaledCropWin.y) )
1861 {
1862 gSrcInfo[eWindow].ScaledCropWin.height -= 2;
1863 }
1864 }
1865 }
1866 #endif
1867
1868 #if (HW_DESIGN_4K2K_VER == 4)
1869 if(MDrv_XC_Is_SupportSWDS(pInstance))
1870 {
1871 if(MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow) )
1872 {
1873 pSrcInfo->u16FRCMV_Length = pSrcInfo->u16V_SizeAfterPreScaling;
1874 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCMVLen = pSrcInfo->u16FRCMV_Length;
1875 }
1876 }
1877 #endif
1878
1879 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Scaled crop[3] x,y,w,h=%u,%u,%u,%u\n",gSrcInfo[eWindow].ScaledCropWin.x, gSrcInfo[eWindow].ScaledCropWin.y, gSrcInfo[eWindow].ScaledCropWin.width, gSrcInfo[eWindow].ScaledCropWin.height);
1880 #ifndef DISABLE_3D_FUNCTION
1881 MDrv_SC_3D_Disable_Crop(pInstance, pSrcInfo, eWindow);
1882 #endif
1883 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Scaled crop[4] x,y,w,h=%u,%u,%u,%u\n",pSrcInfo->ScaledCropWin.x, pSrcInfo->ScaledCropWin.y, pSrcInfo->ScaledCropWin.width, pSrcInfo->ScaledCropWin.height);
1884 }
1885
1886 // for Compression mode control
1887 //new compression algorithm port from toshiba
1888 //to do:DS+compression mode haven't been tested
1889 #if (HW_DESIGN_4K2K_VER == 4)
1890 if(gSrcInfo[eWindow].bInterlace
1891 &&
1892 (((psXCInstPri->u32DeviceID == 0) && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_LEGACY_MODE))
1893 ||(psXCInstPri->u32DeviceID == 1)))
1894 #else
1895 if(gSrcInfo[eWindow].bInterlace)
1896 #endif
1897 {
1898 if(IsVMirrorMode(eWindow))
1899 {
1900 if ((u8ScaledCropY/2)%2)
1901 {
1902 if ((gSrcInfo[eWindow].ScaledCropWin.height/2)%2)
1903 {
1904 bopm_lcnt_inv = TRUE;
1905 }
1906 else
1907 {
1908 bopm_lcnt_inv = FALSE;
1909 }
1910 }
1911 else
1912 {
1913 if ((gSrcInfo[eWindow].ScaledCropWin.height/2)%2)
1914 {
1915 bopm_lcnt_inv = FALSE;
1916 }
1917 else
1918 {
1919 bopm_lcnt_inv = TRUE;
1920 }
1921 }
1922 }
1923 else
1924 {
1925 if ((gSrcInfo[eWindow].ScaledCropWin.y/2)%2)
1926 {
1927 bopm_lcnt_inv = TRUE;
1928 }
1929 else
1930 {
1931 bopm_lcnt_inv = FALSE;
1932 }
1933 }
1934 }
1935 else
1936 {
1937 if(IsVMirrorMode(eWindow))
1938 {
1939 if (u8ScaledCropY%2)
1940 {
1941 if (gSrcInfo[eWindow].ScaledCropWin.height%2)
1942 {
1943 bopm_lcnt_inv = TRUE;
1944 }
1945 else
1946 {
1947 bopm_lcnt_inv = FALSE;
1948 }
1949 }
1950 else
1951 {
1952 if (gSrcInfo[eWindow].ScaledCropWin.height%2)
1953 {
1954 bopm_lcnt_inv = FALSE;
1955 }
1956 else
1957 {
1958 bopm_lcnt_inv = TRUE;
1959 }
1960 }
1961 }
1962 else
1963 {
1964 if(gSrcInfo[eWindow].ScaledCropWin.y%2)
1965 {
1966 bopm_lcnt_inv = TRUE;
1967 }
1968 else
1969 {
1970 bopm_lcnt_inv = FALSE;
1971 }
1972 }
1973 }
1974 //Hal_SC_sw_lcnt_en(pInstance, bLcnt_en, eWindow);
1975 //Hal_SC_set_sw_lcnt(pInstance, bLcnt, eWindow);
1976 //// Change to use menuload and set it by sw_db_burst
1977 if(1)
1978 {
1979 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.bOpmLcntInv_En = bopm_lcnt_inv;
1980 }
1981 else
1982 {
1983 Hal_SC_set_opm_lcnt_inv(pInstance, bopm_lcnt_inv, eWindow);
1984
1985 //monaco/muji 3D mode need control sub for some output format, or else the edge of object in the image may shake
1986 #if (HW_DESIGN_4K2K_VER == 4)
1987 E_XC_3D_OUTPUT_MODE e3DOutputFormat = MDrv_XC_Get_3D_Output_Mode(pInstance);
1988 if((e3DOutputFormat == E_XC_3D_OUTPUT_LINE_ALTERNATIVE)
1989 || (e3DOutputFormat == E_XC_3D_OUTPUT_TOP_BOTTOM) || (e3DOutputFormat == E_XC_3D_OUTPUT_TOP_BOTTOM_HW)
1990 || (e3DOutputFormat == E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF) || (e3DOutputFormat == E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF_HW)
1991 || (e3DOutputFormat == E_XC_3D_OUTPUT_FRAME_PACKING))
1992 {
1993 Hal_SC_set_opm_lcnt_inv(pInstance, bopm_lcnt_inv, SUB_WINDOW);
1994 }
1995 #endif
1996 }
1997 }
1998
MDrv_SC_GetAutoPrescalingDst(XC_InternalStatus * pSrcInfo,MS_BOOL bHorizontal)1999 MS_U16 MDrv_SC_GetAutoPrescalingDst(XC_InternalStatus *pSrcInfo, MS_BOOL bHorizontal)
2000 {
2001 MS_U16 u16ScaleDst;
2002 if(bHorizontal)
2003 {
2004 if ( pSrcInfo->stCropWin.width == 0 )
2005 {
2006 u16ScaleDst = 32;
2007 }
2008 else if (pSrcInfo->stCropWin.width > pSrcInfo->stDispWin.width)
2009 {
2010 u16ScaleDst = (( (MS_U32)pSrcInfo->stCapWin.width * pSrcInfo->stDispWin.width + ( pSrcInfo->stCropWin.width / 2 ) ) / pSrcInfo->stCropWin.width);
2011 }
2012 else
2013 {
2014 u16ScaleDst = pSrcInfo->stCapWin.width;
2015 }
2016
2017 if((pSrcInfo->stCapWin.width <= (WIDTH_4K2K - WIDTH_4K2K_OFFSET)) && (u16ScaleDst > SCALER_LINE_BUFFER_MAX))
2018 {
2019 u16ScaleDst = SCALER_LINE_BUFFER_MAX;
2020 }
2021 }
2022 else
2023 {
2024 if (pSrcInfo->stCropWin.height == 0) // error handling
2025 {
2026 u16ScaleDst = 32;
2027 }
2028 else
2029 {
2030 if( !pSrcInfo->bInterlace)
2031 {
2032 // Progressive
2033 // Pre-scaling to specific size. This formula will make sure driver only use one of Presacling or PostScaling
2034 if (pSrcInfo->stCropWin.height > pSrcInfo->stDispWin.height)
2035 {
2036 u16ScaleDst = ( (MS_U32)pSrcInfo->stCapWin.height * pSrcInfo->stDispWin.height + ( pSrcInfo->stCropWin.height / 2 ) ) / pSrcInfo->stCropWin.height;
2037 }
2038 else
2039 {
2040 u16ScaleDst = pSrcInfo->stCapWin.height;
2041 }
2042
2043 }
2044 else
2045 {
2046 // Interlace
2047 u16ScaleDst = (pSrcInfo->stCapWin.height / 2);
2048 }
2049 }
2050 }
2051 return u16ScaleDst;
2052 }
2053
2054 // 1. mirror+freerun (P mode. eg 25p,30p), at least 3 frames (interlace mode have no this limitation)
2055 // 2. mirror (24p, and not 1:1, 1:2 FRC), at least 3 frames
2056 // 3. mirror+uc (24p, and not 1:1, 1:2 FRC), at least 4 frames
2057 // 4. non-mirror+uc (P mode), at least 3 frames (interlace mode only need 4 field, eg. 25_4R_MC)
2058 // 5. sub win (no matter mirror or not), at least 3 frames
2059 // 6. we also have this limitation, but we don't cover PQ for it:
2060 // mirror+uc(I mode), at least 6 fields (currently, have no 6 fields MC madi, so use 25_6R_MC(8 fields) instead)
MDrv_XC_AdjustPrescalingForFrameNum(void * pInstance,XC_InternalStatus * pSrcInfo,SCALER_WIN eWindow)2061 void MDrv_XC_AdjustPrescalingForFrameNum(void *pInstance, XC_InternalStatus *pSrcInfo, SCALER_WIN eWindow)
2062 {
2063 MS_U16 u16FrameCount = 0;
2064 MS_U8 u8Alignment = OFFSET_PIXEL_ALIGNMENT - 1;
2065 SC_FRC_SETTING astCurFRCTable[MAX_FRC_TABLE_INDEX];
2066 MS_U16 u16H_SizeAfterPreScalingAlign = 0;
2067
2068 memset(astCurFRCTable, 0, sizeof(SC_FRC_SETTING)*MAX_FRC_TABLE_INDEX);
2069 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2070 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2071 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2072 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2073 MDrv_SC_GetCurrentFRCTable(astCurFRCTable);
2074
2075 if(pSrcInfo == NULL)
2076 {
2077 MS_ASSERT(0);
2078 return;
2079 }
2080 u16H_SizeAfterPreScalingAlign = (pSrcInfo->u16H_SizeAfterPreScaling + OFFSET_PIXEL_ALIGNMENT - 1) & ~(OFFSET_PIXEL_ALIGNMENT-1);
2081 #if (HW_DESIGN_4K2K_VER == 5)
2082 if(SC_R2BYTEMSK(0, REG_SC_BK20_01_L, 0x1) == 0)
2083 {
2084 // Clippers MVOP directly bypass to HVSP
2085 // Not using XC FB
2086 return;
2087 }
2088 #endif
2089 #if (HW_DESIGN_4K2K_VER == 7)
2090 if(Hal_SC_get_fbl(pInstance))
2091 {
2092 // HW_DESIGN_4K2K_VER == 7(Kano), 4K2K input must force FBL
2093 // So do not use XC FB
2094 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"HW_DESIGN_4K2K_VER == 7, 4K2K in, do not set XC FB\n");
2095 return;
2096 }
2097 #endif
2098
2099 #ifndef DISABLE_3D_FUNCTION
2100 if(MDrv_SC_3D_IsDoubleAlign(pInstance))
2101 {
2102 u8Alignment = 2 * OFFSET_PIXEL_ALIGNMENT - 1;
2103 }
2104 #endif
2105 //when mirror, need use 3 or more frames mode for 24p video
2106 #ifdef UFO_XC_FB_LEVEL
2107 if(IsVMirrorMode(eWindow)
2108 && (pSrcInfo->eFBLevel == E_XC_FB_LEVEL_FB)
2109 && (!pSrcInfo->bInterlace)
2110 )
2111 #else
2112 if(IsVMirrorMode(eWindow) && (!pSrcInfo->bFBL)
2113 && (!pSrcInfo->bR_FBL) && (!pSrcInfo->bInterlace))
2114 #endif
2115 {
2116 if(MDrv_SC_IsForceFreerun(pInstance)) //when mirror+freerun, all progresive video timing need go 3 frame mode
2117 {
2118 #if (HW_DESIGN_3D_VER > 2)
2119 #ifndef DISABLE_3D_FUNCTION
2120 if(E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
2121 {
2122 u16FrameCount = 6; //per cc, input 3d:framealternative will double data at dnr
2123 }
2124 else
2125 #endif
2126 #endif
2127 {
2128 u16FrameCount = 3;
2129 }
2130
2131 MS_U32 u32TempWidth = MDrv_XC_GetAvailableSize(pInstance, MAIN_WINDOW,
2132 u16FrameCount,
2133 pSrcInfo->u16V_SizeAfterPreScaling);
2134 if((u16H_SizeAfterPreScalingAlign > u32TempWidth)&&(u32TempWidth!=0))
2135 {
2136 pSrcInfo->u16H_SizeAfterPreScaling = u32TempWidth & ~u8Alignment;
2137 }
2138 }
2139 else if((pSrcInfo->u16InputVFreq > 235) && (pSrcInfo->u16InputVFreq < 245))
2140 {
2141 if((astCurFRCTable[1].u8FRC_Out % astCurFRCTable[1].u8FRC_In) != 0)// not 1:1,1:2 frc
2142 {
2143 #if (HW_DESIGN_3D_VER > 2)
2144 #ifndef DISABLE_3D_FUNCTION
2145 if(E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
2146 {
2147 u16FrameCount = 6; //per cc, input 3d:framealternative will double data at dnr
2148 }
2149 else
2150 #endif
2151 #endif
2152 {
2153 u16FrameCount = 3;
2154 }
2155
2156 MS_U32 u32TempWidth = MDrv_XC_GetAvailableSize(pInstance, MAIN_WINDOW,
2157 u16FrameCount,
2158 pSrcInfo->u16V_SizeAfterPreScaling);
2159 if((u16H_SizeAfterPreScalingAlign > u32TempWidth)&&(u32TempWidth!=0))
2160 {
2161 pSrcInfo->u16H_SizeAfterPreScaling = u32TempWidth & ~u8Alignment;
2162 }
2163 }
2164 }
2165 }
2166
2167 //when pip/pop + no mirror, need use 3 or more frames mode(for interlace, 6 fields or above)
2168 //when pip/pop + mirror, need use 4 or more frames mode(for interlace, 8 fields or above)
2169 if((eWindow == SUB_WINDOW)
2170 #ifndef DISABLE_3D_FUNCTION
2171 && (MDrv_XC_Get_3D_Output_Mode(pInstance) == E_XC_3D_OUTPUT_MODE_NONE)
2172 #endif
2173 )
2174 {
2175 if(IsVMirrorMode(eWindow))
2176 {
2177 u16FrameCount = 4;
2178 }
2179 else
2180 {
2181 u16FrameCount = 3;
2182 }
2183
2184 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"force to %u or more frame mode for pip/pop\n", u16FrameCount);
2185 {
2186 MS_U32 u32TempWidth = MDrv_XC_GetAvailableSize(pInstance, SUB_WINDOW,
2187 u16FrameCount,
2188 pSrcInfo->u16V_SizeAfterPreScaling);
2189 if((u16H_SizeAfterPreScalingAlign > u32TempWidth)&&(u32TempWidth!=0))
2190 {
2191 pSrcInfo->u16H_SizeAfterPreScaling = u32TempWidth & ~u8Alignment;
2192 }
2193 }
2194 }
2195
2196 if(!MDrv_XC_Get_OPWriteOffEnable(pInstance, eWindow))
2197 {
2198 if((!IsVMirrorMode(eWindow)) && (!pSrcInfo->bInterlace))
2199 {
2200 //UC case, p mode need at least 3 frame mode
2201 u16FrameCount = 3;
2202
2203 MS_U32 u32TempWidth = MDrv_XC_GetAvailableSize(pInstance, MAIN_WINDOW,
2204 u16FrameCount,
2205 pSrcInfo->u16V_SizeAfterPreScaling);
2206 if((u16H_SizeAfterPreScalingAlign > u32TempWidth)&&(u32TempWidth!=0))
2207 {
2208 pSrcInfo->u16H_SizeAfterPreScaling = u32TempWidth & ~(OFFSET_PIXEL_ALIGNMENT -1);
2209 printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
2210 printf("!!Warning: Driver do more H-prescaling to keep 3 frame mode for UC!!\n");
2211 printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
2212 }
2213 }
2214 else if(IsVMirrorMode(eWindow) && (!pSrcInfo->bInterlace)
2215 && (pSrcInfo->u16InputVFreq > 235) && (pSrcInfo->u16InputVFreq < 245)
2216 && ((astCurFRCTable[1].u8FRC_Out % astCurFRCTable[1].u8FRC_In) != 0))
2217 {
2218 //24p mirror UC case, need at least 4 frame number to avoid tearing
2219 if(MDrv_SC_GetScmiV1Speical4frame(pInstance, MDrv_XC_GetPQSuggestedFrameNum(pInstance, eWindow)))
2220 {
2221 u16FrameCount = 8;//a7p 4 frame mode: store 8 frame in memory actually
2222 }
2223 else
2224 {
2225 u16FrameCount = 4;
2226 }
2227
2228 MS_U32 u32TempWidth = MDrv_XC_GetAvailableSize(pInstance, MAIN_WINDOW,
2229 u16FrameCount,
2230 pSrcInfo->u16V_SizeAfterPreScaling);
2231 if((u16H_SizeAfterPreScalingAlign > u32TempWidth)&&(u32TempWidth!=0))
2232 {
2233 pSrcInfo->u16H_SizeAfterPreScaling = u32TempWidth & ~(OFFSET_PIXEL_ALIGNMENT -1);
2234 printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
2235 printf("!!Warning: Driver do more H-prescaling to keep 4 frame mode for UC 24p mirror!!\n");
2236 printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
2237 }
2238 }
2239 }
2240
2241 //if input vfreq > panel can support vfreq, need go 3 or more frame mode, or else it will be tearing
2242 if(((pSrcInfo->u16InputVFreq > 600 + VFREQDELTA) && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16DefaultVFreq <= 600))
2243 || ((pSrcInfo->u16InputVFreq > 1200 + VFREQDELTA) && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16DefaultVFreq <= 1200)))
2244 {
2245 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"force to 3 or more frame mode for input vfreq > panel default vfreq\n");
2246 {
2247 MS_U32 u32TempWidth = MDrv_XC_GetAvailableSize(pInstance, eWindow,
2248 3,
2249 pSrcInfo->u16V_SizeAfterPreScaling);
2250 if((u16H_SizeAfterPreScalingAlign > u32TempWidth)&&(u32TempWidth!=0))
2251 {
2252 pSrcInfo->u16H_SizeAfterPreScaling = u32TempWidth & ~u8Alignment;
2253 }
2254 }
2255 }
2256 #if LOCK_FREQ_ONLY_WITHOUT_LOCK_PHASE
2257
2258 // only lock frequancy, video tearing in 2 frame mode, change to 3 frame mode in 3D mode for RD'advice
2259 if(MDrv_XC_FPLL_IsSupportLockFreqOnly(pInstance) && (!pSrcInfo->bInterlace))
2260 {
2261 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"force to 3 or more frame mode for only lock freq in 3D mode\n");
2262
2263 MS_U32 u32TempWidth = MDrv_XC_GetAvailableSize(pInstance, eWindow,
2264 3,
2265 pSrcInfo->u16V_SizeAfterPreScaling);
2266 if(u16H_SizeAfterPreScalingAlign > u32TempWidth)
2267 {
2268 pSrcInfo->u16H_SizeAfterPreScaling = u32TempWidth & ~u8Alignment;
2269 }
2270 }
2271 #endif
2272 // make sure at least 2 frame buffer can fit-in the mmap, specially for small xc buffer size, like 6M
2273 // we need to prescaling H for it.
2274 {
2275 #ifdef ENABLE_RFBL_Y8M4_SUPPORTED
2276
2277 if(gSrcInfo[eWindow].u8BitPerPixel == RFBL_Y8M4_Pixel_Bits) //RFBL_Y8M4 mode
2278 {
2279 u16FrameCount = 1;
2280 }
2281 else
2282 {
2283 u16FrameCount = 2;
2284 }
2285 #else
2286
2287 #if (HW_DESIGN_4K2K_VER == 7) //Kano Patch
2288 //Set the frame is 4 on Kano XC1 with Rx in, because FRC case
2289 if((E_XC_DEVICE1 == psXCInstPri->u32DeviceID)&&
2290 (IsSrcTypeHDMI(gSrcInfo[eWindow].enInputSourceType)
2291 || IsSrcTypeDTV(gSrcInfo[eWindow].enInputSourceType)
2292 || IsSrcTypeStorage(gSrcInfo[eWindow].enInputSourceType)))
2293 {
2294 u16FrameCount = 4;
2295 }
2296 else
2297 {
2298 u16FrameCount = 2;
2299 }
2300 #else
2301 u16FrameCount = 2;
2302 #endif
2303 #endif
2304
2305
2306 MS_U32 u32TempWidth = MDrv_XC_GetAvailableSize(pInstance, eWindow,
2307 u16FrameCount,
2308 pSrcInfo->u16V_SizeAfterPreScaling);
2309 #ifdef UFO_XC_FB_LEVEL
2310 if((u16H_SizeAfterPreScalingAlign > u32TempWidth) && (gSrcInfo[eWindow].eFBLevel == E_XC_FB_LEVEL_FB))
2311 #else
2312 if((u16H_SizeAfterPreScalingAlign > u32TempWidth) && !gSrcInfo[eWindow].bFBL)
2313 #endif
2314 {
2315 if(u32TempWidth!=0)
2316 pSrcInfo->u16H_SizeAfterPreScaling = u32TempWidth & ~u8Alignment;
2317 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"prescaling H to (%u), to make sure 2 frames can be fit in xc buffer size\n",
2318 pSrcInfo->u16H_SizeAfterPreScaling);
2319 }
2320 }
2321 }
2322
2323 extern MS_BOOL MApi_PNL_GetOutputInterlaceTiming(void);
2324
2325 #ifdef UFO_XC_SUPPORT_HDMI_DOWNSCALE_OUTPUT_POLICY
2326 //DS HDMI policy
2327 //Base on HDMI policy, do pre-scaling to reduce video quality
2328 #define Min(x, y) x<y ? x:y
_Mdrv_XC_PolicyMapping(MS_U16 u16CodedWidth,MS_U32 u32HDMIPolicyInfo)2329 static MS_U8 _Mdrv_XC_PolicyMapping(MS_U16 u16CodedWidth, MS_U32 u32HDMIPolicyInfo)
2330 {
2331 MS_U8 u8Policy = 0;
2332 if(u16CodedWidth >= 3840) //4K2K
2333 {
2334 u8Policy = (MS_U8)((u32HDMIPolicyInfo & 0xff000000) >> 24);
2335 }
2336 else if(u16CodedWidth >= 1920) //FHD
2337 {
2338 u8Policy = (MS_U8)((u32HDMIPolicyInfo & 0x00ff0000) >> 16);
2339 }
2340 else if(u16CodedWidth >= 1280) //HD
2341 {
2342 u8Policy = (MS_U8)((u32HDMIPolicyInfo & 0x0000ff00) >> 8);
2343 }
2344 else //SD
2345 {
2346 u8Policy = (MS_U8)((u32HDMIPolicyInfo & 0x000000ff));
2347 }
2348 return u8Policy;
2349 }
2350
_Mdrv_XC_HPreScalingPolicy(MS_U8 u8Policy,MS_U16 u16HSizeAfterPreScaling)2351 static MS_U16 _Mdrv_XC_HPreScalingPolicy(MS_U8 u8Policy, MS_U16 u16HSizeAfterPreScaling)
2352 {
2353 MS_U16 u16HPreScaling = u16HSizeAfterPreScaling;
2354 switch(u8Policy)
2355 {
2356 case 0: //Do nothing
2357 case 1: //Blue Screen
2358 break;
2359 case 2: //SD
2360 u16HPreScaling = Min(u16HSizeAfterPreScaling, 720);
2361 break;
2362 case 3: //HD
2363 u16HPreScaling = Min(u16HSizeAfterPreScaling, 1280);
2364 break;
2365 case 4: //FHD
2366 u16HPreScaling = Min(u16HSizeAfterPreScaling, 1920);
2367 break;
2368 case 5: //4K2K
2369 u16HPreScaling = Min(u16HSizeAfterPreScaling, 3840);
2370 break;
2371 default:
2372 printf("no this policy type\n");
2373 }
2374 return u16HPreScaling;
2375 }
2376
_Mdrv_XC_VPreScalingPolicy(MS_U8 u8Policy,MS_U16 u16VSizeAfterPreScaling)2377 static MS_U16 _Mdrv_XC_VPreScalingPolicy(MS_U8 u8Policy, MS_U16 u16VSizeAfterPreScaling)
2378 {
2379 MS_U16 u16VPreScaling = u16VSizeAfterPreScaling;
2380 switch(u8Policy)
2381 {
2382 case 0: //Do nothing
2383 case 1: //Blue Screen
2384 break;
2385 case 2: //SD
2386 u16VPreScaling = Min(u16VSizeAfterPreScaling, 576);
2387 break;
2388 case 3: //HD
2389 u16VPreScaling = Min(u16VSizeAfterPreScaling, 720);
2390 break;
2391 case 4: //FHD
2392 u16VPreScaling = Min(u16VSizeAfterPreScaling, 1080);
2393 break;
2394 case 5: //4K2K
2395 u16VPreScaling = Min(u16VSizeAfterPreScaling, 2160);
2396 break;
2397 default:
2398 printf("no this policy type\n");
2399 }
2400 return u16VPreScaling;
2401 }
2402 #endif
2403
MDrv_SC_set_prescaling_ratio(void * pInstance,INPUT_SOURCE_TYPE_t enInputSourceType,XC_InternalStatus * pSrcInfo,SCALER_WIN eWindow)2404 void MDrv_SC_set_prescaling_ratio(void *pInstance, INPUT_SOURCE_TYPE_t enInputSourceType, XC_InternalStatus *pSrcInfo, SCALER_WIN eWindow)
2405 {
2406 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2407 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2408 MS_U32 u32TmpPre=0;
2409 MS_U16 u16ScaleSrc = 0, u16ScaleDst = 0;
2410 MS_BOOL bEnPreDown = 0, bAdvMode = 0 , bBilinearMode = 0, bPQSupportBilinear = 0;
2411 MS_BOOL bInterlace = pSrcInfo->bInterlace;
2412 MS_U16 u16SrcHWidth = 0;
2413 MS_BOOL bForcePreVScalingDown = FALSE;
2414 MS_BOOL bForcePreHScalingDown = FALSE;
2415 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
2416 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2417 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2418 MS_U32 bFixPreVRatio = 0;//FALSE;
2419 MS_U16 u16AutoPrescalingDst = 0;
2420 MS_BOOL bHSDSkipInQmap = FALSE;
2421 MS_U64 u64_result = 0;
2422
2423 #ifdef UFO_XC_SUPPORT_HDMI_DOWNSCALE_OUTPUT_POLICY
2424 //DS HDMI policy
2425 MS_U8 u8Policy;
2426 MS_U32 u32HDMIPolicyInfo;
2427 #endif
2428
2429 // PQ related.
2430 PQ_HSD_SAMPLING_INFO stHSDSamplingInfo = {0,0};
2431 MS_U32 _u32HSD_Ratio[9] = {0x100000, 0x120000, 0x140000, 0x160000, 0x180000, 0x1A0000, 0x1C0000, 0x1E0000, 0x200000};
2432 MS_U32 _u32HSD_Out[9] = {1000, 888, 800, 728, 666, 616, 572, 534, 500};
2433
2434 pXCResourcePrivate->stdrvXC_Scaling._bVAutoFitPrescalingEna = FALSE;
2435 pXCResourcePrivate->stdrvXC_Scaling._bHAutoFitPrescalingEna = FALSE;
2436 pXCResourcePrivate->stdrvXC_Scaling._bHSizeChangedManually = FALSE;
2437
2438 // check HW limitation of post-scaling and return TRUE/FALSE flag of force H/V pre-scaling.
2439 Hal_XC_IsForcePrescaling(pInstance, pSrcInfo, &bForcePreVScalingDown, &bForcePreHScalingDown, eWindow);
2440
2441 if ((eWindow == SUB_WINDOW) &&
2442 #ifndef DISABLE_3D_FUNCTION
2443 (MDrv_XC_Get_3D_Output_Mode(pInstance)==E_XC_3D_OUTPUT_MODE_NONE) &&
2444 #endif
2445 bInterlace &&
2446 (pSrcInfo->stCapWin.height > 1000) &&
2447 (pSrcInfo->stCapWin.height > 2*(pSrcInfo->stDispWin.height)))
2448 {
2449 // very special case: for PIP 1080i V scaling down < 50% case,
2450 // per COLOr team request, just VSD 50% at HD sub case at pre-scaling for better quality
2451 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "SUB + 1080i + scaling<0.5 case, ForcePreVScalingDown \n");
2452 bForcePreVScalingDown = TRUE;
2453 bFixPreVRatio = 2;
2454 }
2455
2456 #ifdef UFO_XC_SUPPORT_HDMI_DOWNSCALE_OUTPUT_POLICY
2457 u32HDMIPolicyInfo = Hal_SC_get_HDMIpolicy(pInstance);
2458 u8Policy = _Mdrv_XC_PolicyMapping(pSrcInfo->stCapWin.width, u32HDMIPolicyInfo);
2459
2460 if(u8Policy != 0)
2461 {
2462 if(u8Policy == 1)
2463 {
2464 Hal_SC_set_main_black_screen(pInstance, TRUE);
2465 }
2466 else
2467 {
2468 Hal_SC_set_main_black_screen(pInstance, FALSE);
2469 }
2470 }
2471 #endif
2472 //-----------------------------------------
2473 // Vertical
2474 //-----------------------------------------
2475 if (pSrcInfo->Status2.bPreVCusScaling == TRUE)
2476 {
2477 if((MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)))
2478 {
2479 // If 4k resolution scaling down to less than original height, force V pre-scaling
2480 #ifdef UFO_XC_FB_LEVEL
2481 if(((pSrcInfo->stCapWin.height >= 2160) && (pSrcInfo->stCropWin.height >= 2160) && (pSrcInfo->stDispWin.height< pSrcInfo->stCapWin.height))
2482 && ((gSrcInfo[eWindow].eFBLevel == E_XC_FB_LEVEL_FB)
2483 || !(gSrcInfo[MAIN_WINDOW].Status2.bMVOPHSKMode) || !(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height < 2160))
2484 )
2485 #else
2486 if(((pSrcInfo->stCapWin.height >= 2160) && (pSrcInfo->stCropWin.height >= 2160) && (pSrcInfo->stDispWin.height< pSrcInfo->stCapWin.height)) && !(((gSrcInfo[eWindow].bFBL) || (gSrcInfo[eWindow].bR_FBL)) && gSrcInfo[MAIN_WINDOW].Status2.bMVOPHSKMode && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height < 2160)))
2487 #endif
2488 {
2489 u16ScaleSrc = pSrcInfo->stCapWin.height;
2490 u16ScaleDst = pSrcInfo->stDispWin.height;
2491 }
2492 #ifdef VDEC_4K2K_PATCH_MODIFY_INFO
2493 else if((pSrcInfo->stCapWin.height >= 2160 && (pSrcInfo->stDispWin.height< pSrcInfo->stCapWin.height)) && ((gSrcInfo[eWindow].bFBL) || (gSrcInfo[eWindow].bR_FBL)) && gSrcInfo[MAIN_WINDOW].Status2.bMVOPHSKMode && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height < 2160))
2494 {
2495 u16ScaleSrc = pSrcInfo->stCapWin.height;
2496 u16ScaleDst = pSrcInfo->stDispWin.height;
2497 }
2498 #endif
2499 else
2500 {
2501 u16ScaleSrc = pSrcInfo->stCapWin.height;
2502 u16ScaleDst = pSrcInfo->stCapWin.height;//disable vertical prescaling
2503 #ifdef VIDEO_4K_I_PATCH
2504 if((pSrcInfo->stCapWin.height > VIDEO_4K_I_BIG_HEIGHT)&(pSrcInfo->bInterlace))
2505 {
2506 u16ScaleDst = (pSrcInfo->stDispWin.height);
2507 }
2508 #endif
2509 }
2510 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "[%s,%5d] [DS] [PRE] eWindow[%u] VSrc=%u, VDst=%u, bBilinear=%u \n",__func__,__LINE__,eWindow , u16ScaleSrc, u16ScaleDst, bBilinearMode);
2511 }
2512 else
2513 {
2514 u16ScaleSrc = pSrcInfo->Status2.u16PreVCusScalingSrc;
2515 u16ScaleDst = pSrcInfo->Status2.u16PreVCusScalingDst;
2516 // Error handling for Refined Capture Height not same as Customer Requested Prescaling V Source size
2517 // For MFTEVENTFT-19684
2518 if ((pSrcInfo->Status2.u16PreVCusScalingSrc != pSrcInfo->stCapWin.height) && (pSrcInfo->Status2.u16PreVCusScalingSrc - pSrcInfo->stCapWin.height == 2))
2519 {
2520 u16ScaleSrc = pSrcInfo->stCapWin.height;
2521 }
2522
2523 // Napoli FHD MM dual decode with DS PSD issue patch
2524 if(!pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Pnl_Misc.FRCInfo.bFRC &&
2525 MDrv_XC_Is_SubWindowEanble(pInstance) &&
2526 (eWindow == MAIN_WINDOW) &&
2527 ((pSrcInfo->stDispWin.width == pSrcInfo->stCropWin.width/2) &&
2528 (pSrcInfo->stDispWin.height == pSrcInfo->stCropWin.height/2))
2529 )
2530 {
2531 u16ScaleDst = pSrcInfo->stDispWin.height;
2532 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "[PRE]eWindow[%u] DualDecode PATCH: VSrc=%u, VDst=%u\n",eWindow , u16ScaleSrc, u16ScaleDst);
2533 }
2534 }
2535 }
2536 else
2537 {
2538 if(MDrv_XC_Is_SupportSWDS(pInstance) && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)))
2539 {
2540 // If 4k resolution scaling down to less than original height, force V pre-scaling
2541 #ifdef UFO_XC_FB_LEVEL
2542 if((pSrcInfo->stCapWin.height >= 2160 && (pSrcInfo->stDispWin.height< pSrcInfo->stCapWin.height))
2543 && ((gSrcInfo[eWindow].eFBLevel == E_XC_FB_LEVEL_FB)
2544 || !(gSrcInfo[MAIN_WINDOW].Status2.bMVOPHSKMode) || !(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height < 2160))
2545 )
2546 #else
2547 if((pSrcInfo->stCapWin.height >= 2160 && (pSrcInfo->stDispWin.height< pSrcInfo->stCapWin.height)) && !(((gSrcInfo[eWindow].bFBL) || (gSrcInfo[eWindow].bR_FBL)) && gSrcInfo[MAIN_WINDOW].Status2.bMVOPHSKMode && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height < 2160)))
2548 #endif
2549 {
2550 u16ScaleSrc = pSrcInfo->stCapWin.height;
2551 u16ScaleDst = pSrcInfo->stDispWin.height;
2552 }
2553 else
2554 {
2555 u16ScaleSrc = pSrcInfo->stCapWin.height;
2556 u16ScaleDst = pSrcInfo->stCapWin.height;//disable vertical prescaling
2557 }
2558
2559 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "[%s,%5d] [DS] [PRE] eWindow[%u] VSrc=%u, VDst=%u, bBilinear=%u \n",__func__,__LINE__,eWindow , u16ScaleSrc, u16ScaleDst, bBilinearMode);
2560 }
2561 else
2562 {
2563 // Put full image into memory as default
2564 u16ScaleSrc = u16ScaleDst = pSrcInfo->stCapWin.height;
2565
2566 #ifdef UFO_XC_FB_LEVEL
2567 if (pSrcInfo->eFBLevel == E_XC_FB_LEVEL_FB)
2568 #else
2569 if (!pSrcInfo->bFBL )
2570 #endif
2571 {
2572 // Nine Lattice case
2573 if(pSrcInfo->bDisplayNineLattice)
2574 {
2575 u16ScaleDst = pSrcInfo->stDispWin.height;
2576 }
2577 else
2578 {
2579 if (bForcePreVScalingDown)
2580 {
2581 u16ScaleDst = MDrv_SC_GetAutoPrescalingDst(pSrcInfo, FALSE);
2582 if(!pSrcInfo->bInterlace)
2583 {
2584 pXCResourcePrivate->stdrvXC_Scaling._bVAutoFitPrescalingEna = TRUE;
2585 }
2586 }
2587
2588 }
2589 #ifndef DISABLE_3D_FUNCTION
2590 // Adjust for 3D
2591 u16ScaleDst = MDrv_SC_3D_Adjust_PreVerDstSize(pInstance, enInputSourceType, pSrcInfo, u16ScaleDst, eWindow);
2592 #endif
2593 }
2594 }
2595 }
2596
2597 #ifdef UFO_XC_SUPPORT_HDMI_DOWNSCALE_OUTPUT_POLICY
2598 if(u8Policy != 0)
2599 {
2600 u16ScaleDst = _Mdrv_XC_VPreScalingPolicy(u8Policy, u16ScaleDst);
2601 }
2602 #endif
2603
2604 #if SUPPORT_SEAMLESS_ZAPPING
2605 if( bInterlace || Hal_SC_IsPX2MemFormat(pInstance, eWindow))
2606 #else
2607 if( bInterlace )
2608 #endif
2609 {
2610 if (u16ScaleDst % 2 )
2611 {
2612 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"==============================================================\n");
2613 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"======= Pre-scaling V size have to align 2 !!!!!!!!===========\n");
2614 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"==============================================================\n");
2615
2616 u16ScaleDst = ( u16ScaleDst + 1) & ~0x1;
2617 if(u16ScaleDst > pSrcInfo->stCapWin.height)
2618 {
2619 u16ScaleDst -= 2; //Prescaling size must in range of capture window
2620 }
2621 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "[%s,%5d] New Dst After refined [%u]\n",__func__,__LINE__,u16ScaleDst);
2622 }
2623 }
2624
2625
2626 // Check prescaling status. Set bPreScalingRatioChanged as true only when source/dest is different with previous source/dest
2627 // We must update this information before pre-scaling filter.
2628 //(1. We can skip pre-scaling filter update. 2. We can decide which method we can use for load registers. DS or Menuload.)
2629 if ( (pXCResourcePrivate->stdrvXC_Scaling._u16VScaleSrc[eWindow] != u16ScaleSrc) || (pXCResourcePrivate->stdrvXC_Scaling._u16VScaleDst[eWindow] != u16ScaleDst) )
2630 {
2631 pSrcInfo->bPreScalingRatioChanged = TRUE;
2632
2633 pXCResourcePrivate->stdrvXC_Scaling._u16VScaleSrc[eWindow] = u16ScaleSrc;
2634 pXCResourcePrivate->stdrvXC_Scaling._u16VScaleDst[eWindow] = u16ScaleDst;
2635
2636 }
2637 else
2638 {
2639 pSrcInfo->bPreScalingRatioChanged = FALSE;
2640 }
2641
2642 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR); //K3_PQ
2643 //#ifdef ENABLE_TV_SC2_PQ
2644 if (psXCInstPri->u32DeviceID == PQ_XC_ID_0)
2645 //#endif
2646 {
2647 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl)
2648 {
2649 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
2650 s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl((psXCInstPri->u32DeviceID == 1)?PQ_SUB_WINDOW:PQ_MAIN_WINDOW,
2651 E_PQ_IOCTL_PREVSD_BILINEAR,
2652 (void *)&bPQSupportBilinear,
2653 sizeof(bPQSupportBilinear));
2654 #else
2655 s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl((PQ_WIN)eWindow,
2656 E_PQ_IOCTL_PREVSD_BILINEAR,
2657 (void *)&bPQSupportBilinear,
2658 sizeof(bPQSupportBilinear));
2659 #endif
2660 }
2661 }
2662 #ifdef ENABLE_TV_SC2_PQ
2663 else if (psXCInstPri->u32DeviceID == PQ_XC_ID_1)
2664 {
2665 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl_ex)
2666 {
2667 s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl_ex(psXCInstPri->u32DeviceID, (PQ_WIN)eWindow,
2668 E_PQ_IOCTL_PREVSD_BILINEAR,
2669 (void *)&bPQSupportBilinear,
2670 sizeof(bPQSupportBilinear));
2671 }
2672 }
2673 #endif
2674
2675 //#ifdef ENABLE_TV_SC2_PQ
2676 if (psXCInstPri->u32DeviceID == PQ_XC_ID_0 || psXCInstPri->u32DeviceID == PQ_XC_ID_1)
2677 //#endif
2678 {
2679 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable && !MDrv_XC_Is_SupportSWDS(pInstance))
2680 {
2681 // dump prescaling filter
2682 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
2683 bBilinearMode = s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable((psXCInstPri->u32DeviceID == 1)?PQ_SUB_WINDOW:PQ_MAIN_WINDOW,
2684 E_XRULE_VSD,
2685 (u16ScaleSrc != u16ScaleDst ? TRUE : FALSE),
2686 bInterlace,
2687 pSrcInfo->bMemYUVFmt,
2688 u16ScaleSrc,
2689 u16ScaleDst);
2690 #else
2691 bBilinearMode = s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable((PQ_WIN)eWindow,
2692 E_XRULE_VSD,
2693 (u16ScaleSrc != u16ScaleDst ? TRUE : FALSE),
2694 bInterlace,
2695 pSrcInfo->bMemYUVFmt,
2696 u16ScaleSrc,
2697 u16ScaleDst);
2698 #endif
2699 }
2700 else
2701 {
2702 bBilinearMode = 0;
2703 }
2704 }
2705 #ifdef ENABLE_TV_SC2_PQ
2706 else if (psXCInstPri->u32DeviceID == PQ_XC_ID_1)
2707 {
2708 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable_ex)
2709 {
2710 // dump prescaling filter
2711 bBilinearMode = s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable_ex(psXCInstPri->u32DeviceID, (PQ_WIN)eWindow,
2712 E_XRULE_VSD,
2713 (u16ScaleSrc != u16ScaleDst ? TRUE : FALSE),
2714 bInterlace,
2715 pSrcInfo->bMemYUVFmt,
2716 u16ScaleSrc,
2717 u16ScaleDst);
2718 }
2719 else
2720 {
2721 bBilinearMode = 0;
2722 }
2723 }
2724 #endif
2725
2726 if(bPQSupportBilinear == 0)
2727 bBilinearMode = 0;
2728 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR); //K3_PQ
2729
2730 _XC_ENTRY(pInstance);
2731
2732 #ifdef UFO_XC_FB_LEVEL
2733 if(((pSrcInfo->eFBLevel == E_XC_FB_LEVEL_FBL) || (pSrcInfo->bR_FBL == E_XC_FB_LEVEL_RFBL_DI))
2734 && pSrcInfo->bInterlace
2735 )
2736 #else
2737 if (pSrcInfo->bFBL && pSrcInfo->bInterlace)
2738 #endif
2739 {
2740 //HAL_SC_Enable_VInitFactor(FALSE,eWindow);//Let AP layer to decide enable/dsiable for FBL interlace
2741 HAL_SC_Set_VInitFactorOne(pInstance, 0x0,eWindow);
2742 }
2743 else
2744 {
2745 HAL_SC_Enable_VInitFactor(pInstance, FALSE,eWindow);
2746 HAL_SC_Set_VInitFactorOne(pInstance, 0x0,eWindow);
2747 }
2748
2749 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PRE]eWindow[%u] VSrc=%u, VDst=%u, bBilinear=%u\n",eWindow , u16ScaleSrc, u16ScaleDst, bBilinearMode);
2750
2751 if (u16ScaleSrc > u16ScaleDst) //pre scaling only support scaling down
2752 {
2753 MS_U32 u32Value;
2754 #ifndef DISABLE_3D_FUNCTION
2755 if(MDrv_SC_3D_AdjustPreVerSrcForFramepacking(pInstance, eWindow))
2756 {
2757 if(bBilinearMode)
2758 {
2759 if (u16ScaleDst == 0 )
2760 u32TmpPre = 0;
2761 else
2762 #ifdef MSOS_TYPE_LINUX_KERNEL
2763 {
2764 V_PreScalingDownRatioBilinear(u16ScaleSrc+1, u16ScaleDst);
2765 u32TmpPre = (MS_U32)u64_result;
2766 }
2767 #else
2768 u32TmpPre = V_PreScalingDownRatioBilinear(u16ScaleSrc+1, u16ScaleDst);
2769 #endif
2770 }
2771 else
2772 {
2773 #ifdef MSOS_TYPE_LINUX_KERNEL
2774 V_PreScalingDownRatio(u16ScaleSrc+1, u16ScaleDst);
2775 u32TmpPre = (MS_U32)u64_result;
2776 #else
2777 u32TmpPre = V_PreScalingDownRatio(u16ScaleSrc+1, u16ScaleDst);
2778 #endif
2779 }
2780 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "3D: special handle for 1080P double HD case, u16ScaleSrc+1=%u, u16ScaleDst=%u\n", u16ScaleSrc+1, u16ScaleDst);
2781 }
2782 else
2783 #endif
2784 {
2785 if(bBilinearMode)
2786 {
2787 if (u16ScaleDst == 0 )
2788 u32TmpPre = 0;
2789 else
2790 {
2791 if (bFixPreVRatio != 0)
2792 {
2793 //When the V Scaling Down Mode is Bilinear mode
2794 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PRE]eWindow[%u] VSrc=%u, VDst=%u, bBilinear=%u\n",eWindow , u16ScaleSrc, u16ScaleDst, bBilinearMode);
2795 u32TmpPre = (MS_U32)bFixPreVRatio*1048576UL;
2796 //u16ScaleDst = ( ( (u16ScaleSrc -1) * 1048576UL ) / (u32TmpPre - 1) ) ;
2797 u64_result = (MS_U64)(u16ScaleSrc -1) * 1048576UL;
2798 do_div(u64_result,(u32TmpPre - 1));
2799 u16ScaleDst = u64_result;
2800 #if SUPPORT_SEAMLESS_ZAPPING
2801 if( bInterlace || Hal_SC_IsPX2MemFormat(pInstance, eWindow))
2802 #else
2803 if( bInterlace )
2804 #endif
2805 {
2806 if (u16ScaleDst % 2 )
2807 {
2808 //Pre-scaling V size have to align 2
2809 u16ScaleDst = ( u16ScaleDst + 1) & ~0x1;
2810 }
2811 }
2812 }
2813 else
2814 {
2815 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PRE]eWindow[%u] VSrc=%u, VDst=%u, bBilinear=%u\n",eWindow , u16ScaleSrc, u16ScaleDst, bBilinearMode);
2816 #ifdef MSOS_TYPE_LINUX_KERNEL
2817 V_PreScalingDownRatioBilinear(u16ScaleSrc, u16ScaleDst);
2818 u32TmpPre = (MS_U32)u64_result;
2819 #else
2820 u32TmpPre = V_PreScalingDownRatioBilinear(u16ScaleSrc, u16ScaleDst);
2821 #endif
2822 }
2823 }
2824 }
2825 else
2826 {
2827 if (u16ScaleSrc == 0)
2828 u32TmpPre = 0;
2829 else
2830 {
2831 if (bFixPreVRatio != 0)
2832 {
2833 //When the V Scaling Down Mode is CB mode
2834 u64_result = 1048576ul;
2835 do_div(u64_result,bFixPreVRatio);
2836 //u32TmpPre = 1048576ul/bFixPreVRatio;
2837 u32TmpPre = u64_result;
2838 //u16ScaleDst = ( ( (u32TmpPre -1) *u16ScaleSrc)/1048576ul);
2839 u64_result = (MS_U64)(u32TmpPre -1) *u16ScaleSrc;
2840 do_div(u64_result,1048576ul);
2841 u16ScaleDst = u64_result;
2842 #if SUPPORT_SEAMLESS_ZAPPING
2843 if( bInterlace || Hal_SC_IsPX2MemFormat(pInstance, eWindow))
2844 #else
2845 if( bInterlace )
2846 #endif
2847 {
2848 if (u16ScaleDst % 2 )
2849 {
2850 //Pre-scaling V size have to align 2
2851 u16ScaleDst = ( u16ScaleDst + 1) & ~0x1;
2852 }
2853 }
2854 }
2855 else
2856 {
2857 #ifdef MSOS_TYPE_LINUX_KERNEL
2858 V_PreScalingDownRatio(u16ScaleSrc, u16ScaleDst);;
2859 u32TmpPre = (MS_U32)u64_result;
2860 #else
2861 u32TmpPre = V_PreScalingDownRatio(u16ScaleSrc, u16ScaleDst);
2862 #endif
2863 }
2864 }
2865 }
2866 }
2867 u32TmpPre &= 0xFFFFFFL;
2868
2869 // Enable Bilinear mode.
2870 if (bBilinearMode)
2871 {
2872 u32TmpPre |= 0x40000000L;
2873 }
2874
2875 u32TmpPre |= 0x80000000L;
2876
2877 pSrcInfo->bPreV_ScalingDown = TRUE;
2878
2879 // Error checking
2880 if (u16ScaleSrc == 0)
2881 u32Value = 0;
2882 else
2883 u32Value = (MS_U32)u16ScaleDst * 0x80000 / u16ScaleSrc;
2884
2885 // if SC1 is interlace out, two init factor mode is used for P2I.
2886 // so can not use in this case
2887 if(E_XC_DEVICE0 == psXCInstPri->u32DeviceID)
2888 {
2889 HAL_SC_Set_VInitFactorTwo(pInstance, u32Value,eWindow);
2890 }
2891 #if (XC_DEVICE1_IS_INTERLACE_OUT == 0)
2892 else if(E_XC_DEVICE1 == psXCInstPri->u32DeviceID)
2893 {
2894 HAL_SC_Set_VInitFactorTwo(pInstance, u32Value,eWindow);
2895 }
2896 #endif
2897
2898
2899 HAL_SC_Set_vsd_output_line_count(pInstance, DISABLE,u16ScaleDst,eWindow);
2900 HAL_SC_Set_vsd_input_line_count(pInstance, DISABLE,FALSE,0,eWindow);
2901
2902 }
2903 else
2904 {
2905 pXCResourcePrivate->stdrvXC_Scaling._bVAutoFitPrescalingEna = FALSE;
2906 if ((eWindow == SUB_WINDOW)
2907 #ifndef DISABLE_3D_FUNCTION
2908 &&(MDrv_XC_Get_3D_Output_Mode(pInstance)==E_XC_3D_OUTPUT_MODE_NONE)
2909 #endif
2910 )
2911 {
2912 u32TmpPre = Hal_SC_CheckSubWinPreScaling(u16ScaleDst,pSrcInfo->bInterlace);
2913
2914 if(u32TmpPre == 0)
2915 {
2916 pSrcInfo->bPreV_ScalingDown = FALSE;
2917 }
2918 else
2919 {
2920 pSrcInfo->bPreV_ScalingDown = TRUE;
2921 }
2922 }
2923 else
2924 {
2925 u16ScaleDst = u16ScaleSrc;
2926 u32TmpPre = 0;
2927 pSrcInfo->bPreV_ScalingDown = FALSE;
2928 HAL_SC_Set_vsd_output_line_count(pInstance, DISABLE,u16ScaleDst,eWindow);
2929 HAL_SC_Set_vsd_input_line_count(pInstance, DISABLE,FALSE,0,eWindow);
2930
2931 }
2932 // SC1 two init factor mode is used for P2I
2933 // so can not use in this case
2934 if(E_XC_DEVICE0 == psXCInstPri->u32DeviceID)
2935 {
2936 HAL_SC_Set_VInitFactorTwo(pInstance, 0x80000, eWindow);
2937 }
2938 #if (XC_DEVICE1_IS_INTERLACE_OUT == 0)
2939 else if(E_XC_DEVICE1 == psXCInstPri->u32DeviceID)
2940 {
2941 HAL_SC_Set_VInitFactorTwo(pInstance, 0x80000, eWindow);
2942 }
2943 #endif
2944 }
2945
2946 _XC_RETURN(pInstance);
2947
2948 //store prescaling info here ( Why using u16PreVCusScalingSrc and u16PreVCusScalingDst??)
2949 pSrcInfo->Status2.u16PreVCusScalingSrc = u16ScaleSrc;
2950 pSrcInfo->Status2.u16PreVCusScalingDst = u16ScaleDst;
2951 pSrcInfo->u16V_SizeAfterPreScaling = u16ScaleDst;
2952 pSrcInfo->u16V_Length = pSrcInfo->u16V_SizeAfterPreScaling;
2953
2954 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "[%s,%5d] [DS] u16V_Length:%d \n",__func__,__LINE__,pSrcInfo->u16V_Length);
2955 #if (HW_DESIGN_4K2K_VER == 4)
2956 pSrcInfo->u16FRCMV_Length = pSrcInfo->u16V_Length;
2957 #endif
2958 #ifndef DISABLE_3D_FUNCTION
2959 if (((MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow) != E_XC_3D_INPUT_MODE_NONE)
2960 && (MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow) != E_XC_3D_INPUT_NORMAL_2D_HW))
2961 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
2962 || (Hal_SC_3D_IsDualViewMode(pInstance, eWindow))
2963 #endif
2964 )//hw 2d->3d is not related with sub window, so skip it.
2965 {
2966 MDrv_SC_3D_Adjust_FillLBMode(pInstance, eWindow);
2967 }
2968
2969 MDrv_SC_3D_SetWriteMemory(pInstance, eWindow);
2970 MDrv_SC_3D_CloneMainSettings(pInstance, pSrcInfo, eWindow);
2971 MDrv_SC_3D_Adjust_PreVLength(pInstance, enInputSourceType, pSrcInfo, eWindow);
2972 #endif
2973 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32V_PreScalingRatio = u32TmpPre;
2974
2975 //-----------------------------------------
2976 // Horizontal
2977 // HSD rule: Framecount ensure > 3D scaling > customer scaling > QMap HSD sampling > auto fit
2978 //-----------------------------------------
2979
2980 // Note!! Formula: FHD - If (H Crop size /2 ) > ( H display size ), Must-do H pre-scaling down.
2981
2982 if (pSrcInfo->bDisplayNineLattice)
2983 {
2984 u16SrcHWidth = pSrcInfo->stCapWin.width;
2985 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stDispWin.width;
2986 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Nine Lattice: eWindow[%u] HSrc=%u, HDst=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
2987 }
2988 else
2989 {
2990 //for prevent Src == Dst, HCusScaling = TRUE case
2991 if(pSrcInfo->Status2.u16PreHCusScalingSrc == pSrcInfo->Status2.u16PreHCusScalingDst
2992 && (!IsSrcTypeDTV(enInputSourceType)))
2993 //DTV do not execute that only for reduceing side effect. Academically,all source do not execute.
2994 {
2995 pSrcInfo->Status2.bPreHCusScaling = FALSE;
2996 }
2997
2998 // Custimize
2999 if(pSrcInfo->Status2.bPreHCusScaling)
3000 {
3001 u16SrcHWidth = pSrcInfo->Status2.u16PreHCusScalingSrc;
3002
3003 // If 4k resolution scaling down to less than original width, force H pre-scaling
3004 if(((pSrcInfo->stCapWin.width >= 3840) && (pSrcInfo->stCropWin.width >= 3840) && (pSrcInfo->stDispWin.width< pSrcInfo->stCapWin.width)) && !(((gSrcInfo[eWindow].bFBL) || (gSrcInfo[eWindow].bR_FBL)) && gSrcInfo[MAIN_WINDOW].Status2.bMVOPHSKMode && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width < 3840)))
3005 {
3006 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stDispWin.width;
3007 }
3008 else
3009 {
3010 if (u16SrcHWidth > pSrcInfo->Status2.u16PreHCusScalingDst)
3011 {
3012 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->Status2.u16PreHCusScalingDst;
3013 }
3014 else
3015 {
3016 pSrcInfo->u16H_SizeAfterPreScaling = u16SrcHWidth;
3017 }
3018 #ifndef DISABLE_3D_FUNCTION
3019 MDrv_SC_3D_Adjust_PreHorDstSize(pInstance, enInputSourceType, pSrcInfo, eWindow);
3020 #endif
3021 MDrv_XC_AdjustPrescalingForFrameNum(pInstance, pSrcInfo, eWindow);
3022 // 3d adjust may make the pre h dst bigger than cus_pre_H, we need adjust it again.
3023 if (pSrcInfo->u16H_SizeAfterPreScaling > pSrcInfo->Status2.u16PreHCusScalingDst)
3024 {
3025 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->Status2.u16PreHCusScalingDst;
3026 }
3027 }
3028 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Customer H scaling: eWindow[%u] HSrc=%u, HDst=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
3029
3030 }
3031 else
3032 {
3033 if(MDrv_XC_Is_SupportSWDS(pInstance) && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)))
3034 {
3035 u16SrcHWidth = pSrcInfo->stCapWin.width;
3036
3037 // If 4k resolution scaling down to less than original height, force V pre-scaling
3038 #ifdef UFO_XC_FB_LEVEL
3039 if((pSrcInfo->stCapWin.height >= 2160 && (pSrcInfo->stDispWin.height< pSrcInfo->stCapWin.height))
3040 && ((gSrcInfo[eWindow].eFBLevel == E_XC_FB_LEVEL_FB)
3041 || !gSrcInfo[MAIN_WINDOW].Status2.bMVOPHSKMode
3042 || !(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height < 2160))
3043 )
3044 #else
3045 if((pSrcInfo->stCapWin.height >= 2160 && (pSrcInfo->stDispWin.height< pSrcInfo->stCapWin.height)) && !(((gSrcInfo[eWindow].bFBL) || (gSrcInfo[eWindow].bR_FBL)) && gSrcInfo[MAIN_WINDOW].Status2.bMVOPHSKMode && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height < 2160)))
3046 #endif
3047 {
3048 // Need to force H pre-scaling if already V pre-scaling
3049 // Force H pre-scaling down to less than 1280px
3050 if(pSrcInfo->stDispWin.width > 1280)
3051 {
3052 pSrcInfo->u16H_SizeAfterPreScaling = 1280;
3053 }
3054 else
3055 {
3056 if(pSrcInfo->stCapWin.width > pSrcInfo->stDispWin.width)
3057 {
3058 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stDispWin.width;
3059
3060 }
3061 else
3062 {
3063 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stDispWin.width;
3064 }
3065 }
3066 }
3067 else
3068 {
3069 if(!(gSrcInfo[MAIN_WINDOW].Status2.bMVOPHSKMode && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width < 3840)))
3070 {
3071 if(pSrcInfo->stCapWin.width*6 > pSrcInfo->stDispWin.width*10)
3072 {
3073 pSrcInfo->u16H_SizeAfterPreScaling = (pSrcInfo->stCapWin.width/4 + 1) & ~0x01;
3074 }
3075 else
3076 {
3077 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stCapWin.width;//disable horizontal prescaling
3078 }
3079 }
3080 else
3081 {
3082 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stCapWin.width;//disable horizontal prescaling
3083 }
3084 }
3085 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] eWindow[%u] HSrc=%u, HDst=%u\n",__func__,__LINE__, eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
3086 }
3087 else
3088 {
3089 u16SrcHWidth = pSrcInfo->stCapWin.width;
3090 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stCapWin.width;
3091
3092 // this DTV flow don't obey the HSD rule, but HDuplicate won't affect QMap non-prescaling case,
3093 // because the HDuplicate condition is no bigger than 704, refer to MVOP_AutoGenMPEGTiming()
3094 // need to refine later
3095 if(IsSrcTypeDTV(enInputSourceType) && pSrcInfo->bHDuplicate) // for better quality
3096 {
3097 MS_U16 capwidth = pSrcInfo->stCapWin.width / 2;
3098 if(eWindow == SUB_WINDOW)
3099 {
3100 if (capwidth > pSrcInfo->stDispWin.width && pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width < 1800)
3101 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stCapWin.width;
3102 else if(capwidth > pSrcInfo->stDispWin.width)
3103 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stDispWin.width;
3104 }
3105 else
3106 {
3107 pSrcInfo->u16H_SizeAfterPreScaling = capwidth;
3108 }
3109 pXCResourcePrivate->stdrvXC_Scaling._bHSizeChangedManually = TRUE;
3110 }
3111 //!!NOTE START:
3112 //if QMAP support HSD Sampling, this item need to disable and the scaling size will control by QMAP
3113 //If we want to follow the HSD rule, we cannot enable ENABLE_YPBPR_PRESCALING_TO_ORIGINAL and
3114 // ENABLE_VD_PRESCALING_TO_DOT75
3115 #if (ENABLE_YPBPR_PRESCALING_TO_ORIGINAL)
3116 else if(IsSrcTypeYPbPr(enInputSourceType) && pSrcInfo->bHDuplicate)
3117 {
3118 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stCapWin.width / 2;
3119 pXCResourcePrivate->stdrvXC_Scaling._bHSizeChangedManually = TRUE;
3120 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"ENABLE_YPBPR_PRESCALING_TO_ORIGINAL: eWindow[%u] HSrc=%u, HDst=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
3121 }
3122 #endif
3123 //!!NOTE END
3124 #if (ENABLE_VD_PRESCALING_TO_DOT75)
3125 else if(IsSrcTypeDigitalVD(enInputSourceType))
3126 {
3127
3128 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stCapWin.width * 3 / 4;
3129 pXCResourcePrivate->stdrvXC_Scaling._bHSizeChangedManually = TRUE;
3130 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"ENABLE_VD_PRESCALING_TO_DOT75: eWindow[%u] HSrc=%u, HDst=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
3131 }
3132 #endif
3133 else
3134 {
3135 // H scaling controlled by Qmap.
3136 // #ifdef ENABLE_TV_SC2_PQ
3137 if (psXCInstPri->u32DeviceID == PQ_XC_ID_0)
3138 // #endif
3139 {
3140 if((eWindow == MAIN_WINDOW) && (s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl != NULL))
3141 {
3142 MS_BOOL bHSDRet = FALSE;
3143 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
3144 bHSDRet = s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl((psXCInstPri->u32DeviceID == 1)?PQ_SUB_WINDOW:PQ_MAIN_WINDOW, E_PQ_IOCTL_HSD_SAMPLING, &stHSDSamplingInfo, sizeof(PQ_HSD_SAMPLING_INFO));
3145 #else
3146 bHSDRet = s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl((PQ_WIN)eWindow, E_PQ_IOCTL_HSD_SAMPLING, &stHSDSamplingInfo, sizeof(PQ_HSD_SAMPLING_INFO));
3147 #endif
3148 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"stHSDSamplingInfo.u32ratio=%tu,bHSDRet=%x\n", (ptrdiff_t)stHSDSamplingInfo.u32ratio, bHSDRet);
3149 // Using ratio from Qmap only in acceptable post-scaling
3150 if(stHSDSamplingInfo.u32ratio && bHSDRet == TRUE)
3151 {
3152 switch(stHSDSamplingInfo.u32ratio)
3153 {
3154 default:
3155 case 1000:
3156 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 0;
3157 break;
3158
3159 case 875:
3160 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 1;
3161 break;
3162
3163 case 750:
3164 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 2;
3165 break;
3166
3167 case 625:
3168 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 3;
3169 break;
3170
3171 case 500:
3172 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 4;
3173 break;
3174
3175 case 375:
3176 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 5;
3177 break;
3178
3179 case 250:
3180 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 6;
3181 break;
3182
3183 case 125:
3184 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 7;
3185 break;
3186
3187 case 1:
3188 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 8;
3189 break;
3190 }
3191 pSrcInfo->u16H_SizeAfterPreScaling = (MS_U16)(((MS_U32)pSrcInfo->stCapWin.width * _u32HSD_Out[pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx])/1000);
3192 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"pSrcInfo->u16H_SizeAfterPreScaling=%u\n", pSrcInfo->u16H_SizeAfterPreScaling);
3193 MDrv_SC_SetPQHSDFlag(pInstance, TRUE);
3194 }
3195 else
3196 {
3197 //cannot retrieve HSD_Sampling or HSD_Y and HSD_C is true in skip rule
3198 //then we should use HSDRule to dump hsd_y, hsd_c
3199 bHSDSkipInQmap = TRUE;
3200 }
3201 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"PQ HSD_SAMPLING: eWindow[%u] HSrc=%u, HDst=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
3202
3203 }
3204 }
3205 #ifdef ENABLE_TV_SC2_PQ
3206 else if (psXCInstPri->u32DeviceID == PQ_XC_ID_1)
3207 {
3208 if((eWindow == MAIN_WINDOW) && (s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl_ex != NULL))
3209 {
3210 MS_BOOL bHSDRet = FALSE;
3211 bHSDRet = s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl_ex(psXCInstPri->u32DeviceID, (PQ_WIN)eWindow, E_PQ_IOCTL_HSD_SAMPLING, &stHSDSamplingInfo, sizeof(PQ_HSD_SAMPLING_INFO));
3212
3213 // Using ratio from Qmap only in acceptable post-scaling
3214 if(stHSDSamplingInfo.u32ratio && bHSDRet == TRUE)
3215 {
3216 switch(stHSDSamplingInfo.u32ratio)
3217 {
3218 default:
3219 case 1000:
3220 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 0;
3221 break;
3222
3223 case 875:
3224 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 1;
3225 break;
3226
3227 case 750:
3228 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 2;
3229 break;
3230
3231 case 625:
3232 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 3;
3233 break;
3234
3235 case 500:
3236 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 4;
3237 break;
3238
3239 case 375:
3240 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 5;
3241 break;
3242
3243 case 250:
3244 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 6;
3245 break;
3246
3247 case 125:
3248 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 7;
3249 break;
3250
3251 case 1:
3252 pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx = 8;
3253 break;
3254 }
3255 pSrcInfo->u16H_SizeAfterPreScaling = (MS_U16)(((MS_U32)pSrcInfo->stCapWin.width * _u32HSD_Out[pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx])/1000);
3256 MDrv_SC_SetPQHSDFlag(pInstance, TRUE);
3257 }
3258 else
3259 {
3260 //cannot retrieve HSD_Sampling or HSD_Y and HSD_C is true in skip rule
3261 //then we should use HSDRule to dump hsd_y, hsd_c
3262 bHSDSkipInQmap = TRUE;
3263 }
3264
3265 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"PQ HSD_SAMPLING: eWindow[%u] HSrc=%u, HDst=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
3266
3267 }
3268 }
3269 #endif
3270
3271 // Scaling donw only when special case.
3272 if ((!MDrv_SC_GetPQHSDFlag(pInstance))&& bForcePreHScalingDown)
3273 {
3274 pSrcInfo->u16H_SizeAfterPreScaling = MDrv_SC_GetAutoPrescalingDst(pSrcInfo, TRUE);
3275 u16AutoPrescalingDst = pSrcInfo->u16H_SizeAfterPreScaling;
3276 pXCResourcePrivate->stdrvXC_Scaling._bHAutoFitPrescalingEna = TRUE;
3277 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Driver logic, auto fit: eWindow[%u] HSrc=%u, HDst=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
3278 }
3279
3280 if (eWindow == SUB_WINDOW )
3281 {
3282 // Notice!!!! Sub win only have 960 pixels.
3283 // If we use 1280 pixel for Sub Win, Main win has 1280 pixels remain. (Total line buffer : 1920 + 960 )
3284 #if (HW_DESIGN_3D_VER == 4)
3285 if(!((MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow)==E_XC_3D_INPUT_FRAME_PACKING)&&
3286 (MDrv_XC_Get_3D_Output_Mode(pInstance)==E_XC_3D_OUTPUT_TOP_BOTTOM)))
3287 #endif
3288 {
3289 if ( pSrcInfo->u16H_SizeAfterPreScaling > SUB_MST_LINE_BFF_MAX )
3290 {
3291 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PRE] SUB LINE BFF LIMIT : HSrc=%u, HDst=%lu\n",pSrcInfo->u16H_SizeAfterPreScaling, SUB_MST_LINE_BFF_MAX);
3292 pSrcInfo->u16H_SizeAfterPreScaling = SUB_MST_LINE_BFF_MAX ;
3293 }
3294 // Avoid Post HSD in PIP/POP case
3295 if(pSrcInfo->u16H_SizeAfterPreScaling >= pSrcInfo->stDispWin.width)
3296 {
3297 #if FRC_INSIDE
3298 if( (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Pnl_Misc.FRCInfo.bFRC) &&
3299 ((pSrcInfo->stCropWin.x != 0) || (pSrcInfo->stCropWin.width != pSrcInfo->stCapWin.width)))
3300 {
3301 // Consider Crop case, the post HSD clk is not enough for FRC enable case
3302 pSrcInfo->u16H_SizeAfterPreScaling = ((pSrcInfo->stCapWin.width*pSrcInfo->stDispWin.width)+(pSrcInfo->stCropWin.width/2))/pSrcInfo->stCropWin.width;
3303 }
3304 else
3305 #endif
3306 {
3307 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stDispWin.width;
3308 }
3309 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"To avoid Post HSD, HDst=%u\n",pSrcInfo->u16H_SizeAfterPreScaling);
3310 }
3311 }
3312 }
3313 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PRE]Force Prescaling Down : %d _bPQSetPreScalingrate : %d \n",bForcePreHScalingDown, MDrv_SC_GetPQHSDFlag(pInstance));
3314 }
3315
3316 MS_U16 u16OriHSize = pSrcInfo->u16H_SizeAfterPreScaling;
3317 #ifndef DISABLE_3D_FUNCTION
3318 MDrv_SC_3D_Adjust_PreHorDstSize(pInstance, enInputSourceType, pSrcInfo, eWindow);
3319 #endif
3320 MDrv_XC_AdjustPrescalingForFrameNum(pInstance, pSrcInfo, eWindow);
3321
3322 if(u16OriHSize != pSrcInfo->u16H_SizeAfterPreScaling)
3323 {
3324 pXCResourcePrivate->stdrvXC_Scaling._bHSizeChangedManually = TRUE;
3325 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"xc: 3D has changed the H prescaling setting, need to skip PQ HSD_Sampling/HSD_Y/HSD_C loading\n");
3326 }
3327
3328 //for 4096 input case, force prescaling to display window width
3329 if((pSrcInfo->u16H_SizeAfterPreScaling > WIDTH_4K2K)
3330 && (pSrcInfo->u16H_SizeAfterPreScaling > pSrcInfo->stDispWin.width))
3331 {
3332 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stDispWin.width;
3333 }
3334 }
3335 }
3336 }
3337
3338 #ifdef UFO_XC_SUPPORT_HDMI_DOWNSCALE_OUTPUT_POLICY
3339 if(u8Policy != 0)
3340 {
3341 pSrcInfo->u16H_SizeAfterPreScaling = _Mdrv_XC_HPreScalingPolicy(u8Policy, pSrcInfo->u16H_SizeAfterPreScaling);
3342 }
3343 #endif
3344 //Setting Line Buffer Start offset for Sub Win
3345 if(pSrcInfo->u16H_SizeAfterPreScaling & BIT(0))
3346 {
3347 //YUV422, h size must be even to prevent showing of garbage at the end of line
3348 if(pSrcInfo->u16H_SizeAfterPreScaling < pSrcInfo->stCapWin.width)
3349 {
3350 if(MDrv_SC_GetPQHSDFlag(pInstance) == TRUE)
3351 {
3352 pSrcInfo->u16H_SizeAfterPreScaling = (pSrcInfo->u16H_SizeAfterPreScaling - 1) & ~0x1;
3353 }
3354 else
3355 {
3356 pSrcInfo->u16H_SizeAfterPreScaling = (pSrcInfo->u16H_SizeAfterPreScaling + 1) & ~0x1;
3357 }
3358 }
3359 else
3360 {
3361 pSrcInfo->u16H_SizeAfterPreScaling = u16SrcHWidth;
3362 }
3363 }
3364
3365 _XC_ENTRY(pInstance);
3366 if(eWindow==MAIN_WINDOW)
3367 {
3368 #if (HW_DESIGN_3D_VER == 4)
3369
3370 if((MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow)==E_XC_3D_INPUT_FRAME_PACKING)&&
3371 (MDrv_XC_Get_3D_Output_Mode(pInstance)==E_XC_3D_OUTPUT_TOP_BOTTOM))
3372 HAL_SC_SetSubLineBufferOffset(pInstance, 0x00);
3373 else
3374 {
3375 // Main-it-on-top is enabled.
3376 if ( pXCResourcePrivate->stdrvXC_MVideo_Context.bMainIsOnTop )
3377 {
3378 // If Top window (a window on the top) turn on 8 line (reg_di8lb_en_f2), HW will enable reg_di8lb_en_f1 together internally(HW¼g¦º).
3379 // That means we only have 1920 pixels line buffer (the total length of 8 line UCNR line buffer is 1920 only.) for two windows.
3380 // For convenience, we separate 1920 to both window. 960 pixel for each.
3381 if ( !MDrv_XC_Get_OPWriteOffEnable(pInstance, eWindow) )
3382 {
3383 if (pSrcInfo->u16H_SizeAfterPreScaling > 960)
3384 {
3385 pSrcInfo->u16H_SizeAfterPreScaling = 960;
3386 }
3387 // When Main-is-top set. Main Line buffer is blong to sub window.
3388 HAL_SC_SetMainLineBufferOffset(pInstance, 0x3C0);
3389 // When Main-is-top set. Sub Line buffer is blong to Main window.
3390 HAL_SC_SetSubLineBufferOffset(pInstance, 0x00);
3391 }
3392 }
3393 else
3394 {
3395 HAL_SC_SetMainLineBufferOffset(pInstance, 0x00);
3396 HAL_SC_SetSubLineBufferOffset(pInstance, SCALER_LINE_BUFFER_MAX + SUB_MAIN_LINEOFFSET_GUARD_BAND);
3397 }
3398 }
3399 #else
3400 // Main-is-on-top is enabled.
3401 if ( pXCResourcePrivate->stdrvXC_MVideo_Context.bMainIsOnTop )
3402 {
3403 // If Top window (a window on the top) turn on 8 line (reg_di8lb_en_f2), HW will enable reg_di8lb_en_f1 together internally(HW¼g¦º).
3404 // That means we only have 1920 pixels line buffer (the total length of 8 line UCNR line buffer is 1920 only.) for two windows.
3405 // For convenience, we separate 1920 to both window. 960 pixel for each.
3406 if ( !MDrv_XC_Get_OPWriteOffEnable(pInstance, eWindow) )
3407 {
3408 if (pSrcInfo->u16H_SizeAfterPreScaling > 960)
3409 {
3410 pSrcInfo->u16H_SizeAfterPreScaling = 960;
3411 }
3412 // When Main-is-top set. Main Line buffer is blong to sub window.
3413 HAL_SC_SetMainLineBufferOffset(pInstance, 0x3C0);
3414 // When Main-is-top set. Sub Line buffer is blong to Main window.
3415 HAL_SC_SetSubLineBufferOffset(pInstance, 0x00);
3416 }
3417 }
3418 else
3419 {
3420 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
3421 //FIX ME:why need this?
3422 if (psXCInstPri->u32DeviceID == 0)
3423 #endif
3424 {
3425 HAL_SC_SetMainLineBufferOffset(pInstance, 0x00);
3426 }
3427 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
3428 else
3429 {
3430 HAL_SC_SetMainLineBufferOffset(pInstance, 0x01);
3431 }
3432 #endif
3433 HAL_SC_SetSubLineBufferOffset(pInstance, SCALER_LINE_BUFFER_MAX + SUB_MAIN_LINEOFFSET_GUARD_BAND);
3434 }
3435 #endif
3436 }
3437 else // eWindow == SUB_WINDOW
3438 {
3439 // POP case
3440 if ((gSrcInfo[MAIN_WINDOW].stDispWin.width == pSrcInfo->stDispWin.width)
3441 && (gSrcInfo[MAIN_WINDOW].stDispWin.width + pSrcInfo->stDispWin.width == pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width))
3442 {
3443 // UCNR on
3444 if ( !MDrv_XC_Get_OPWriteOffEnable(pInstance, MAIN_WINDOW) )
3445 {
3446 // reg_di8lb_en_f2 ON and it is in POP mode
3447 // For old chip:
3448 // - main and sub share 1920 pixel line buffer in length
3449 // - each window has 1920/2 = 960 = 0x3C0, sub window starts at MST_LINE_BFF_MAX/2
3450 // For new chip: like Nike, Napoli
3451 // - main and sub share 1920 + 960 pixel line buffer in length
3452 // - sub window starts at 1920 = MST_LINE_BFF_MAX/2
3453 HAL_SC_SetMainLineBufferOffset(pInstance, 0x000);
3454 HAL_SC_SetSubLineBufferOffset(pInstance, MST_LINE_BFF_MAX/2);
3455 }
3456 }
3457 else
3458 {
3459 HAL_SC_SetMainLineBufferOffset(pInstance, 0x00);
3460 HAL_SC_SetSubLineBufferOffset(pInstance, SCALER_LINE_BUFFER_MAX + SUB_MAIN_LINEOFFSET_GUARD_BAND);
3461 }
3462 }
3463 #ifndef DISABLE_3D_FUNCTION
3464 #if (HW_DESIGN_3D_VER <= 1)
3465 MDrv_SC_3D_Adjust_SubLineBufferOffset(pInstance, enInputSourceType, pSrcInfo, eWindow);
3466 #endif
3467 #endif
3468 _XC_RETURN(pInstance);
3469
3470 if(u16AutoPrescalingDst != pSrcInfo->u16H_SizeAfterPreScaling)
3471 {
3472 pXCResourcePrivate->stdrvXC_Scaling._bHAutoFitPrescalingEna = FALSE;
3473 }
3474
3475 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"eWindow[%u] HSrc=%u, HDst=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
3476
3477 // Check prescaling status. Set bPreScalingRatioChanged as true only when src != dest.
3478 // We update this information before pre-scaling filter.
3479 if ( (pXCResourcePrivate->stdrvXC_Scaling._u16HScaleSrc[eWindow] != u16SrcHWidth) || (pXCResourcePrivate->stdrvXC_Scaling._u16HScaleDst[eWindow] != pSrcInfo->u16H_SizeAfterPreScaling) )
3480 {
3481 gSrcInfo[eWindow].bPreScalingRatioChanged = TRUE;
3482
3483 pXCResourcePrivate->stdrvXC_Scaling._u16HScaleSrc[eWindow] = u16SrcHWidth;
3484 pXCResourcePrivate->stdrvXC_Scaling._u16HScaleDst[eWindow] = pSrcInfo->u16H_SizeAfterPreScaling;
3485 }
3486 else
3487 {
3488 gSrcInfo[eWindow].bPreScalingRatioChanged |= FALSE;
3489 }
3490 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3491
3492 // below cases should dump HSDRule:
3493 // 1. hsd_y, hsd_c skip rule true
3494 // 2. customer scaling
3495 // 3. manually change h pre size
3496 if((bHSDSkipInQmap == TRUE)
3497 ||(gSrcInfo[eWindow].bHCusScaling)
3498 ||(gSrcInfo[eWindow].Status2.bPreHCusScaling)
3499 ||(MDrv_XC_GetHSizeChangeManuallyFlag(pInstance,eWindow)))
3500 {
3501
3502 //#ifdef ENABLE_TV_SC2_PQ
3503 if (psXCInstPri->u32DeviceID == PQ_XC_ID_0 || psXCInstPri->u32DeviceID == PQ_XC_ID_1)
3504 //#endif
3505 {
3506 if( (s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable == NULL)|| MDrv_XC_Is_SupportSWDS(pInstance))
3507 {
3508 bAdvMode = 0;
3509 }
3510 else
3511 {
3512 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
3513 bAdvMode =
3514 s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable((psXCInstPri->u32DeviceID == 1)?PQ_SUB_WINDOW:PQ_MAIN_WINDOW,
3515 E_XRULE_HSD,
3516 pSrcInfo->bPreV_ScalingDown,
3517 bInterlace,
3518 pSrcInfo->bMemYUVFmt,
3519 u16SrcHWidth,
3520 pSrcInfo->u16H_SizeAfterPreScaling);
3521 #else
3522 bAdvMode =
3523 s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable((PQ_WIN)eWindow,
3524 E_XRULE_HSD,
3525 pSrcInfo->bPreV_ScalingDown,
3526 bInterlace,
3527 pSrcInfo->bMemYUVFmt,
3528 u16SrcHWidth,
3529 pSrcInfo->u16H_SizeAfterPreScaling);
3530 #endif
3531 }
3532 }
3533 #ifdef ENABLE_TV_SC2_PQ
3534 else if (psXCInstPri->u32DeviceID == PQ_XC_ID_1)
3535 {
3536 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable_ex == NULL)
3537 {
3538 bAdvMode = 0;
3539 }
3540 else
3541 {
3542 bAdvMode =
3543 s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable_ex(psXCInstPri->u32DeviceID, (PQ_WIN)eWindow,
3544 E_XRULE_HSD,
3545 pSrcInfo->bPreV_ScalingDown,
3546 bInterlace,
3547 pSrcInfo->bMemYUVFmt,
3548 u16SrcHWidth,
3549 pSrcInfo->u16H_SizeAfterPreScaling);
3550 }
3551 }
3552 #endif
3553 }
3554
3555 //if customer scaling case, ratio and filter is decided by Customer and Xrule
3556 //if not customer and PQ HSD sampling case, ratio and filter is decided by PQ
3557 //if not customer and not PQ HSD sampling case, ratio and filter is decided by driver autofit and Xrule
3558 //Note: if HSD_Y, HSD_C is in PQ skip rule, and the skip is Y, the driver logic will be very carefully.
3559 //we should treat it as "none PQ setting HSD sampling" case.
3560 //because HSD filter is related with bAdvMode, which are paired.
3561 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3562 if((MDrv_SC_GetPQHSDFlag(pInstance)) && (!pSrcInfo->Status2.bPreHCusScaling) && (!pXCResourcePrivate->stdrvXC_Scaling._bHSizeChangedManually))
3563 {
3564 bAdvMode = stHSDSamplingInfo.bADVMode;
3565 }
3566
3567
3568 // Dixon, FixMe, subwindow 960 no pre-scaling down can't use ADV mode
3569 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
3570 if((eWindow == MAIN_WINDOW) && (psXCInstPri->u32DeviceID == PQ_XC_ID_1))
3571 #else
3572 if(eWindow == SUB_WINDOW)
3573 #endif
3574 {
3575 bAdvMode = FALSE;
3576 }
3577
3578 //printf("bEnPreDown=%u, bAdvMode=%u\n", (MS_U16)bEnPreDown, (MS_U16)bAdvMode);
3579 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PRE]eWindow[%u] HSrc=%u, HDst=%u, bAdvMode=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling, bAdvMode);
3580
3581 if (u16SrcHWidth > pSrcInfo->u16H_SizeAfterPreScaling)
3582 {
3583 MS_U16 u16div = 1;
3584
3585 #ifndef SUPPORT_4K2K_PHOTO_ZOOM
3586 // To avoid overflow when do H_PreScalingDownRatioAdv/H_PreScalingDownRatioAdv_No_Minus1
3587 if(u16SrcHWidth > 4096)
3588 {
3589 while(1)
3590 {
3591 MS_U16 u16ret;
3592
3593 u16div <<= 1;
3594
3595 if (u16div == 0)
3596 {
3597 u16div = 1;
3598 break;
3599 }
3600
3601 u16ret = u16SrcHWidth/u16div;
3602
3603 if(u16ret == 0)
3604 {
3605 u16div = 1;
3606 break;
3607 }
3608 else if(u16ret< 4096 && u16ret > pSrcInfo->u16H_SizeAfterPreScaling)
3609 {
3610 break;
3611 }
3612 }
3613 }
3614 #endif
3615
3616 if((MDrv_SC_GetPQHSDFlag(pInstance)) && (!pSrcInfo->Status2.bPreHCusScaling) && (!pXCResourcePrivate->stdrvXC_Scaling._bHSizeChangedManually))
3617 {
3618 //PQ set HPrescaling case, don't use bAdvMode
3619 u32TmpPre = _u32HSD_Ratio[pXCResourcePrivate->stdrvXC_Scaling._u8HSD_Idx];
3620 }
3621 else
3622 {
3623 if (bAdvMode)
3624 { // enable prescaling fitler
3625 #ifdef MSOS_TYPE_LINUX_KERNEL
3626 H_PreScalingDownRatioAdv((u16SrcHWidth/u16div), pSrcInfo->u16H_SizeAfterPreScaling);
3627 u32TmpPre = (MS_U32) (u64_result * u16div);
3628 #else
3629 u32TmpPre = (H_PreScalingDownRatioAdv((u16SrcHWidth/u16div), pSrcInfo->u16H_SizeAfterPreScaling)) * u16div;
3630 #endif
3631 }
3632 else
3633 { // disable prescaling filter, use cb mode scaling ratio
3634 if (u16SrcHWidth == 0 )
3635 u32TmpPre = 0;
3636 else
3637 #ifdef MSOS_TYPE_LINUX_KERNEL
3638 {
3639 H_PreScalingDownRatio(u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
3640 u32TmpPre = (MS_U32)u64_result;
3641 }
3642 #else
3643 u32TmpPre = (H_PreScalingDownRatio(u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling));
3644 #endif
3645 }
3646 }
3647 bEnPreDown = 1;
3648 u32TmpPre &= 0x7FFFFFL;
3649 }
3650 else
3651 {
3652 pXCResourcePrivate->stdrvXC_Scaling._bHAutoFitPrescalingEna = FALSE;
3653 pSrcInfo->u16H_SizeAfterPreScaling = u16SrcHWidth;
3654
3655 if(bAdvMode)
3656 {
3657 bEnPreDown = 1;
3658 u32TmpPre = 0x100000L;
3659 }
3660 else
3661 {
3662 bEnPreDown = 0;
3663 u32TmpPre = 0x100000L;
3664 }
3665
3666 // Dixon, FixMe, subwindow 960 no pre-scaling down can't turn on scaling and set ratio to 1
3667 if(eWindow==SUB_WINDOW)
3668 bEnPreDown = 0;
3669
3670 // Note: Patch Start --this patch is only for A3 HW issue!!
3671 #ifdef HW_DISABLE_HSD
3672 // To fix ATV pink issue, we should turn off pre-hscaling, if it is unnescerry to scaling
3673 bEnPreDown = 0;
3674 u32TmpPre = 0x00L;
3675 #endif
3676 // Note: Patch End --
3677
3678 }
3679 //store prescaling info here
3680 pSrcInfo->Status2.u16PreHCusScalingSrc = u16SrcHWidth;
3681 pSrcInfo->Status2.u16PreHCusScalingDst = pSrcInfo->u16H_SizeAfterPreScaling;
3682
3683 if (bEnPreDown)
3684 {
3685 if(bAdvMode)
3686 {
3687 u32TmpPre |= 0x40000000L;
3688 }
3689
3690 u32TmpPre |= 0x80000000L;
3691 }
3692
3693 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32H_PreScalingRatio = u32TmpPre;
3694 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCMVLen = pSrcInfo->u16FRCMV_Length;
3695 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PRE]HRatio=0x%tx, VRatio=0x%tx, u16V_Length = %u\n",
3696 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32H_PreScalingRatio,
3697 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32V_PreScalingRatio,
3698 pSrcInfo->u16V_Length);
3699 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3700 }
3701
MDrv_SC_set_postscaling_ratio(void * pInstance,XC_InternalStatus * pSrcInfo,SCALER_WIN eWindow)3702 void MDrv_SC_set_postscaling_ratio(void *pInstance, XC_InternalStatus *pSrcInfo, SCALER_WIN eWindow)
3703 {
3704 #define MAX_PST_SCALING_DOWN_PERCENTAGE_FCLK170M (80)
3705 #ifdef MSOS_TYPE_LINUX_KERNEL
3706 MS_U64 u64_result = 0;
3707 #endif
3708 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3709 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3710 MS_U32 u32TmpPost=0;
3711 MS_U16 u16ScaleSrc, u16ScaleDst;
3712 MS_BOOL bInterlace = pSrcInfo->bInterlace, bPstScalingDownCheck;
3713 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3714 //Check pst scaling limit for FULL HD panel, and currently only check FULL HD input
3715
3716 MS_BOOL bIsInterlace = FALSE;
3717 bIsInterlace = MApi_PNL_GetOutputInterlaceTiming();
3718
3719 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3720 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3721 if(E_XC_DEVICE0 == psXCInstPri->u32DeviceID)
3722 {
3723 bPstScalingDownCheck = ((MDrv_ReadByte(REG_CKG_FCLK) & CKG_FCLK_MASK) == CKG_FCLK_170MHZ) ?
3724 (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width == 1920 && pSrcInfo->ScaledCropWin.width > 1280) : FALSE;
3725 }
3726 #if (HW_DESIGN_4K2K_VER == 4)
3727 else if(E_XC_DEVICE1 == psXCInstPri->u32DeviceID)
3728 {
3729 bPstScalingDownCheck = ((MDrv_ReadByte(REG_CKG_S2_FCLK) & CKG_S2_FCLK_MASK) == CKG_S2_FCLK_172MHZ) ?
3730 (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width == 1920 && pSrcInfo->ScaledCropWin.width > 1280) : FALSE;
3731 }
3732 #endif
3733 else
3734 {
3735 /// others
3736 bPstScalingDownCheck = FALSE;
3737 }
3738 //-----------------------------------------
3739 // Horizontal
3740 //-----------------------------------------
3741 if (pSrcInfo->bHCusScaling == FALSE)
3742 {
3743 u16ScaleSrc = pSrcInfo->ScaledCropWin.width;
3744 u16ScaleDst = pSrcInfo->stDispWin.width;
3745 #ifndef DISABLE_3D_FUNCTION
3746 u16ScaleSrc = MDrv_SC_3D_Adjust_PostHorSrcSize(pInstance, pSrcInfo, u16ScaleSrc, eWindow);
3747
3748 u16ScaleDst = MDrv_SC_3D_Adjust_PostHorDstSize(pInstance, pSrcInfo, u16ScaleDst, eWindow);
3749 #endif
3750 }
3751 else
3752 {
3753 u16ScaleSrc = pSrcInfo->u16HCusScalingSrc;
3754 u16ScaleDst = pSrcInfo->u16HCusScalingDst;
3755 //make sure crop window in the range of window after prescaling
3756 if((u16ScaleSrc > pSrcInfo->u16H_SizeAfterPreScaling) ||
3757 (u16ScaleSrc + pSrcInfo->ScaledCropWin.x > pSrcInfo->u16H_SizeAfterPreScaling))
3758 {
3759 MS_U16 u16PstScaledWidth;
3760 u16PstScaledWidth = (MS_U32)(u16ScaleDst*(pSrcInfo->u16H_SizeAfterPreScaling - pSrcInfo->ScaledCropWin.x))/u16ScaleSrc;
3761 //Check if the scaled content can full fill the display window, otherwise garbage will show out.
3762 if(u16PstScaledWidth < pSrcInfo->stDispWin.width)
3763 {
3764 if(u16ScaleSrc > pSrcInfo->u16H_SizeAfterPreScaling)
3765 {
3766 u16ScaleSrc = pSrcInfo->u16H_SizeAfterPreScaling & ~0x01;
3767 pSrcInfo->ScaledCropWin.x = 0;
3768 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PST]Limit ScaledCropWin.x to x=%u, HScaleSrc to: Src=%u\n", pSrcInfo->ScaledCropWin.x, u16ScaleSrc);
3769 }
3770 else
3771 {
3772 pSrcInfo->ScaledCropWin.x = (pSrcInfo->u16H_SizeAfterPreScaling - u16ScaleSrc) & ~0x01;
3773 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PST]Limit ScaledCropWin.x to x=%u\n", pSrcInfo->ScaledCropWin.x);
3774 }
3775 }
3776 }
3777 }
3778 if(pSrcInfo->bDisplayNineLattice)
3779 {
3780 // nine lattice disable post scaling
3781 u16ScaleSrc = u16ScaleDst = 1920;
3782 }
3783 //store pst scaling info here
3784 pSrcInfo->u16HCusScalingSrc = u16ScaleSrc;
3785 pSrcInfo->u16HCusScalingDst = u16ScaleDst;
3786 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PST]HSrc=%u, HDst=%u\n", u16ScaleSrc, u16ScaleDst);
3787
3788 if(bPstScalingDownCheck)
3789 {
3790 if((u16ScaleDst < u16ScaleSrc) && (u16ScaleSrc*MAX_PST_SCALING_DOWN_PERCENTAGE_FCLK170M/100) > u16ScaleDst)
3791 {
3792 MS_ASSERT(0);
3793 printf("[PST]!!!!!! ALERT: This FCLK can not support H PST scaling down too much[%u -> %u] !!!!!! \n", u16ScaleSrc, u16ScaleDst);
3794 }
3795 }
3796
3797 if (u16ScaleDst != u16ScaleSrc)
3798 {
3799 #ifdef MSOS_TYPE_LINUX_KERNEL
3800 H_PostScalingRatio(u16ScaleSrc, u16ScaleDst);
3801 u32TmpPost = (MS_U32)u64_result;
3802 #else
3803 u32TmpPost = H_PostScalingRatio(u16ScaleSrc, u16ScaleDst);
3804 #endif
3805
3806 #ifdef XC_SUPPORT_2STEP_SCALING
3807 if(MDrv_ReadByte(REG_CHIP_REVISION) >= 1)//Monet U02 fix .
3808 {
3809 #ifdef UFO_XC_SUPPORT_2STEP_SCALING
3810 if(bIsSupport2StepScaling)
3811 {
3812 u32TmpPost = u32TmpPost *2;
3813 }
3814 #endif
3815 }
3816 #endif
3817
3818 u32TmpPost &= 0xFFFFFFL;
3819 #if 1//( CHIP_FAMILY_TYPE == CHIP_FAMILY_S4LE )
3820 u32TmpPost |= 0x1000000L;
3821 #else
3822 u32TmpPost |= 0x800000L;
3823 #endif
3824 }
3825 else
3826 {
3827 u32TmpPost = 0x100000L;
3828 }
3829
3830 if(MHal_XC_Check_Bypass(pInstance,E_XC_BYPASS_HVSP) == FALSE)
3831 {
3832 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR); //K3_PQ
3833 //#ifdef ENABLE_TV_SC2_PQ
3834 if (psXCInstPri->u32DeviceID == PQ_XC_ID_0 || psXCInstPri->u32DeviceID == PQ_XC_ID_1)
3835 //#endif
3836 {
3837 if (s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable != NULL)
3838 {
3839 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
3840 s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable((psXCInstPri->u32DeviceID == 1)?PQ_SUB_WINDOW:PQ_MAIN_WINDOW,
3841 E_XRULE_HSP,
3842 pSrcInfo->bPreV_ScalingDown,
3843 bInterlace,
3844 pSrcInfo->bMemYUVFmt,
3845 u16ScaleSrc,
3846 u16ScaleDst);
3847 #else
3848 s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable((PQ_WIN)eWindow,
3849 E_XRULE_HSP,
3850 pSrcInfo->bPreV_ScalingDown,
3851 bInterlace,
3852 pSrcInfo->bMemYUVFmt,
3853 u16ScaleSrc,
3854 u16ScaleDst);
3855 #endif
3856 }
3857 }
3858 #ifdef ENABLE_TV_SC2_PQ
3859 else if (psXCInstPri->u32DeviceID == PQ_XC_ID_1)
3860 {
3861 if (s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable_ex != NULL)
3862 {
3863 s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable_ex(psXCInstPri->u32DeviceID, (PQ_WIN)eWindow,
3864 E_XRULE_HSP,
3865 pSrcInfo->bPreV_ScalingDown,
3866 bInterlace,
3867 pSrcInfo->bMemYUVFmt,
3868 u16ScaleSrc,
3869 u16ScaleDst);
3870 }
3871 }
3872 #endif
3873 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR); //K3_PQ
3874 }
3875 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32H_PostScalingRatio = u32TmpPost;
3876
3877 //-----------------------------------------
3878 // Vertical
3879 //-----------------------------------------
3880 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PST]VCusScaling=%s\n",pSrcInfo->bVCusScaling ? "TRUE":"FALSE");
3881 if (pSrcInfo->bVCusScaling == FALSE)
3882 {
3883 u16ScaleSrc = pSrcInfo->ScaledCropWin.height;
3884 u16ScaleDst = pSrcInfo->stDispWin.height;
3885 #ifndef DISABLE_3D_FUNCTION
3886 u16ScaleSrc = MDrv_SC_3D_Adjust_PostVerSrcSize(pInstance, pSrcInfo, u16ScaleSrc, eWindow);
3887 #endif
3888 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PST]VSrc=%u, VDst=%u, eDeInterlaceMode=%u, bFBL=%u, bInterlace=%u\n", u16ScaleSrc, u16ScaleDst, pSrcInfo->eDeInterlaceMode, pSrcInfo->bFBL, bInterlace)
3889 }
3890 else
3891 {
3892 u16ScaleSrc = pSrcInfo->u16VCusScalingSrc;
3893 u16ScaleDst = pSrcInfo->u16VCusScalingDst;
3894 //make sure crop window in the range of window after prescaling
3895 if((u16ScaleSrc > pSrcInfo->u16V_SizeAfterPreScaling) ||
3896 (u16ScaleSrc + pSrcInfo->ScaledCropWin.y > pSrcInfo->u16V_SizeAfterPreScaling))
3897 {
3898 MS_U16 u16PstScaledHeight;
3899 u16PstScaledHeight = (MS_U32)(u16ScaleDst*(pSrcInfo->u16V_SizeAfterPreScaling - pSrcInfo->ScaledCropWin.y))/u16ScaleSrc;
3900 //Check if the scaled content can full fill the display window, otherwise garbage will show out.
3901 if(u16PstScaledHeight < pSrcInfo->stDispWin.height)
3902 {
3903 if(u16ScaleSrc > pSrcInfo->u16V_SizeAfterPreScaling)
3904 {
3905 u16ScaleSrc = pSrcInfo->u16V_SizeAfterPreScaling & ~0x01;
3906 pSrcInfo->ScaledCropWin.y = 0;
3907 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PST]Limit ScaledCropWin.y to y=%u, VScaleSrc to: Src=%u\n", pSrcInfo->ScaledCropWin.y, u16ScaleSrc);
3908 }
3909 else
3910 {
3911 pSrcInfo->ScaledCropWin.y = (pSrcInfo->u16V_SizeAfterPreScaling - u16ScaleSrc) & ~0x01;
3912 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PST]Limit ScaledCropWin.y to y=%u\n", pSrcInfo->ScaledCropWin.y);
3913 }
3914 }
3915 }
3916 }
3917
3918 if(pSrcInfo->bDisplayNineLattice)
3919 {
3920 // nine lattice disable post scaling
3921 u16ScaleSrc = u16ScaleDst = 1080;
3922 }
3923
3924 #ifdef ENABLE_SCALING_WO_MUTE
3925 MS_U16 u16TmpSrc = MDrv_SC_Cal_Skip_OPM_line(pInstance, eWindow, u16ScaleSrc, u16ScaleDst, pSrcInfo);
3926 #endif
3927
3928 //store pst scaling info here
3929 pSrcInfo->u16VCusScalingSrc = u16ScaleSrc;
3930 pSrcInfo->u16VCusScalingDst = u16ScaleDst;
3931 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PST]VSrc=%u, VDst=%u, eDeInterlaceMode=%u, bFBL=%u, bInterlace=%u\n", u16ScaleSrc, u16ScaleDst, pSrcInfo->eDeInterlaceMode, pSrcInfo->bFBL, bInterlace);
3932 if(bPstScalingDownCheck)
3933 {
3934 if((u16ScaleDst < u16ScaleSrc) && (u16ScaleSrc*MAX_PST_SCALING_DOWN_PERCENTAGE_FCLK170M/100) > u16ScaleDst)
3935 {
3936 MS_ASSERT(0);
3937 printf("[PST]!!!!!! ALERT: This FCLK can not support V PST scaling down too much[%u -> %u] !!!!!! \n", u16ScaleSrc, u16ScaleDst);
3938 }
3939 }
3940 if (u16ScaleSrc == u16ScaleDst)
3941 {
3942 if( !(MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow))) //!DS
3943 {
3944 if( bInterlace && (pSrcInfo->eDeInterlaceMode <= MS_DEINT_2DDI_BOB) )
3945 {
3946 // no need to do V post scaling
3947 if( !(MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)))
3948 {
3949 if ( (u16ScaleDst-1) == 0 )
3950 u32TmpPost = 0;
3951 else
3952 {
3953 #ifdef ENABLE_SCALING_WO_MUTE
3954 #ifdef MSOS_TYPE_LINUX_KERNEL
3955 V_PostScalingRatio(u16TmpSrc/2, u16ScaleDst);;
3956 u32TmpPost = (MS_U32)u64_result;
3957 #else
3958 u32TmpPost = V_PostScalingRatio(u16TmpSrc/2, u16ScaleDst);
3959 #endif
3960 #else
3961 u16ScaleSrc /= 2;
3962 #ifdef MSOS_TYPE_LINUX_KERNEL
3963 V_PostScalingRatio(u16ScaleSrc, u16ScaleDst);;
3964 u32TmpPost = (MS_U32)u64_result;
3965 #else
3966 u32TmpPost = V_PostScalingRatio(u16ScaleSrc, u16ScaleDst);
3967 #endif
3968 #endif
3969 }
3970 }
3971 }
3972 else
3973 {
3974 u32TmpPost = 0x100000L;
3975 }
3976 }
3977 else//DS
3978 {
3979 u32TmpPost = 0x100000L;
3980 }
3981 }
3982 else
3983 {
3984 if( !(MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow))) //!DS
3985 {
3986 // for T2, 25/27 mode input line is full lines, BOB mode is half lines
3987 if( bInterlace && (pSrcInfo->eDeInterlaceMode <= MS_DEINT_2DDI_BOB))
3988 {
3989 if ( (u16ScaleDst-1) == 0)
3990 u32TmpPost = 0 ;
3991 else
3992 {
3993 #ifdef ENABLE_SCALING_WO_MUTE
3994 u32TmpPost = V_PostScalingRatio(u16TmpSrc/2, u16ScaleDst);
3995 #else
3996 u16ScaleSrc /= 2;
3997 if(psXCInstPri->u32DeviceID == 1 && XC_DEVICE1_IS_INTERLACE_OUT)
3998 {
3999 #ifdef MSOS_TYPE_LINUX_KERNEL
4000 V_PostScalingRatio_P2I(u16ScaleSrc, u16ScaleDst);
4001 u32TmpPost = (MS_U32)u64_result;
4002 #else
4003 u32TmpPost = V_PostScalingRatio_P2I(u16ScaleSrc, u16ScaleDst);
4004 #endif
4005 }
4006 else if (bIsInterlace == TRUE)
4007 {
4008 #ifdef MSOS_TYPE_LINUX_KERNEL
4009 V_PostScalingRatio_P2I(u16ScaleSrc, u16ScaleDst);
4010 u32TmpPost = (MS_U32)u64_result;
4011 #else
4012 u32TmpPost = V_PostScalingRatio_P2I(u16ScaleSrc, u16ScaleDst);
4013 #endif
4014 }
4015 else
4016 {
4017 #ifdef MSOS_TYPE_LINUX_KERNEL
4018 V_PostScalingRatio(u16ScaleSrc, u16ScaleDst);
4019 u32TmpPost = (MS_U32)u64_result;
4020 #else
4021 u32TmpPost = V_PostScalingRatio(u16ScaleSrc, u16ScaleDst);
4022 #endif
4023 }
4024 #endif
4025 }
4026 }
4027 else
4028 {
4029 if ( (u16ScaleDst-1) == 0)
4030 u32TmpPost = 0 ;
4031 else
4032 {
4033 if(psXCInstPri->u32DeviceID == 1 && XC_DEVICE1_IS_INTERLACE_OUT)
4034 {
4035 #ifdef MSOS_TYPE_LINUX_KERNEL
4036 V_PostScalingRatio_P2I(u16ScaleSrc, u16ScaleDst);
4037 u32TmpPost = (MS_U32)u64_result;
4038 #else
4039 u32TmpPost = V_PostScalingRatio_P2I(u16ScaleSrc, u16ScaleDst);
4040 #endif
4041 }
4042 else if (bIsInterlace == TRUE)
4043 {
4044 #ifdef MSOS_TYPE_LINUX_KERNEL
4045 V_PostScalingRatio_P2I(u16ScaleSrc, u16ScaleDst);
4046 u32TmpPost = (MS_U32)u64_result;
4047 #else
4048 u32TmpPost = V_PostScalingRatio_P2I(u16ScaleSrc, u16ScaleDst);
4049 #endif
4050 }
4051 else
4052 {
4053 #ifdef ENABLE_SCALING_WO_MUTE
4054 #ifdef MSOS_TYPE_LINUX_KERNEL
4055 V_PostScalingRatio(u16TmpSrc, u16ScaleDst);
4056 u32TmpPost = (MS_U32)u64_result;
4057 #else
4058 u32TmpPost = V_PostScalingRatio(u16TmpSrc, u16ScaleDst);
4059 #endif
4060 #else
4061 #ifdef MSOS_TYPE_LINUX_KERNEL
4062 V_PostScalingRatio(u16ScaleSrc, u16ScaleDst);
4063 u32TmpPost = (MS_U32)u64_result;
4064 #else
4065 u32TmpPost = V_PostScalingRatio(u16ScaleSrc, u16ScaleDst);
4066 #endif
4067 #endif
4068 }
4069 }
4070 }
4071 }
4072 else //DS
4073 {
4074 if ( (u16ScaleDst-1) == 0)
4075 u32TmpPost = 0 ;
4076 else
4077 {
4078 if(psXCInstPri->u32DeviceID == 1 && XC_DEVICE1_IS_INTERLACE_OUT)
4079 {
4080 #ifdef MSOS_TYPE_LINUX_KERNEL
4081 V_PostScalingRatio_P2I(u16ScaleSrc, u16ScaleDst);
4082 u32TmpPost = (MS_U32)u64_result;
4083 #else
4084 u32TmpPost = V_PostScalingRatio_P2I(u16ScaleSrc, u16ScaleDst);
4085 #endif
4086 }
4087 else if (bIsInterlace == TRUE)
4088 {
4089 #ifdef MSOS_TYPE_LINUX_KERNEL
4090 V_PostScalingRatio_P2I(u16ScaleSrc, u16ScaleDst);
4091 u32TmpPost = (MS_U32)u64_result;
4092 #else
4093 u32TmpPost = V_PostScalingRatio_P2I(u16ScaleSrc, u16ScaleDst);
4094 #endif
4095 }
4096 else
4097 {
4098 #ifdef ENABLE_SCALING_WO_MUTE
4099 #ifdef MSOS_TYPE_LINUX_KERNEL
4100 V_PostScalingRatio(u16TmpSrc, u16ScaleDst);
4101 u32TmpPost = (MS_U32)u64_result;
4102 #else
4103 u32TmpPost = V_PostScalingRatio(u16TmpSrc, u16ScaleDst);
4104 #endif
4105 #else
4106 #ifdef MSOS_TYPE_LINUX_KERNEL
4107 V_PostScalingRatio(u16ScaleSrc, u16ScaleDst);
4108 u32TmpPost = (MS_U32)u64_result;
4109 #else
4110 u32TmpPost = V_PostScalingRatio(u16ScaleSrc, u16ScaleDst);
4111 #endif
4112 #endif
4113 }
4114 }
4115 }
4116 }
4117
4118 #ifdef XC_SUPPORT_2STEP_SCALING
4119 if(MDrv_ReadByte(REG_CHIP_REVISION) >= 1)//Monet U02 fix .
4120 {
4121 #ifdef UFO_XC_SUPPORT_2STEP_SCALING
4122 if(bIsSupport2StepScaling)
4123 {
4124 u32TmpPost = u32TmpPost *2;
4125 }
4126 #endif
4127 }
4128 #endif
4129
4130 u32TmpPost &= 0xFFFFFFL; //scaling factor support 24bits
4131
4132 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR); //K3_PQ
4133 if(MHal_XC_Check_Bypass(pInstance,E_XC_BYPASS_HVSP) == FALSE)
4134 {
4135 //#ifdef ENABLE_TV_SC2_PQ
4136 if (psXCInstPri->u32DeviceID == PQ_XC_ID_0 || psXCInstPri->u32DeviceID == PQ_XC_ID_1)
4137 //#endif
4138 {
4139 if (s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable != NULL)
4140 {
4141 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
4142 s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable((psXCInstPri->u32DeviceID == 1)?PQ_SUB_WINDOW:PQ_MAIN_WINDOW,
4143 E_XRULE_VSP,
4144 pSrcInfo->bPreV_ScalingDown,
4145 bInterlace,
4146 pSrcInfo->bMemYUVFmt,
4147 u16ScaleSrc,
4148 u16ScaleDst);
4149 #else
4150 s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable((PQ_WIN)eWindow,
4151 E_XRULE_VSP,
4152 pSrcInfo->bPreV_ScalingDown,
4153 bInterlace,
4154 pSrcInfo->bMemYUVFmt,
4155 u16ScaleSrc,
4156 u16ScaleDst);
4157 #endif
4158 }
4159 }
4160 #ifdef ENABLE_TV_SC2_PQ
4161 else if (psXCInstPri->u32DeviceID == PQ_XC_ID_1)
4162 {
4163 if (s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable_ex != NULL)
4164 {
4165 s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_load_scalingtable_ex(psXCInstPri->u32DeviceID, (PQ_WIN)eWindow,
4166 E_XRULE_VSP,
4167 pSrcInfo->bPreV_ScalingDown,
4168 bInterlace,
4169 pSrcInfo->bMemYUVFmt,
4170 u16ScaleSrc,
4171 u16ScaleDst);
4172 }
4173 }
4174 #endif
4175 }
4176 // Set two init factor mode here to do P2I for Kaiser SC1
4177 if(E_XC_DEVICE1 == psXCInstPri->u32DeviceID && XC_DEVICE1_IS_INTERLACE_OUT)
4178 {
4179 HAL_SC_Set_VInitFactorTwo(pInstance, (u32TmpPost/2), eWindow);
4180 HAL_SC_Enable_VInitFactor(pInstance, TRUE, eWindow);
4181
4182 // Field inverse in NTSC output mode
4183 if(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height == 480)
4184 {
4185 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK23_13_L, 0x0002, 0x0002);
4186 }
4187 else
4188 {
4189 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK23_13_L, 0x0000, 0x0002);
4190 }
4191 }
4192 else if (bIsInterlace == TRUE)
4193 {
4194 HAL_SC_Set_VInitFactorTwo(pInstance, u32TmpPost/2, eWindow);
4195 HAL_SC_Enable_VInitFactor(pInstance, TRUE, eWindow);
4196 }
4197
4198 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR); //K3_PQ
4199 if (u32TmpPost != 0x100000L)
4200 #if 1//( CHIP_FAMILY_TYPE == CHIP_FAMILY_S4LE )
4201 u32TmpPost |= 0x1000000L;
4202 #else
4203 u32TmpPost |= 0x800000L;
4204 #endif
4205
4206 pSrcInfo->u16V_Length = u16ScaleSrc;
4207
4208 #ifdef VIDEO_4K_I_PATCH
4209 if((pSrcInfo->stCapWin.height > VIDEO_4K_I_BIG_HEIGHT)&&(gSrcInfo[eWindow].bInterlace == TRUE))
4210 {
4211 pSrcInfo->u16V_Length -=2;
4212 }
4213 #endif
4214
4215 #ifndef DISABLE_3D_FUNCTION
4216 MDrv_SC_3D_Adjust_PostVLength(pInstance, pSrcInfo, eWindow);
4217 #endif
4218 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32V_PostScalingRatio = u32TmpPost;
4219 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[PST]HRatio=0x%tx, VRatio=0x%tx, u16V_Length=%u\n",
4220 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32H_PostScalingRatio,
4221 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32V_PostScalingRatio,
4222 u16ScaleSrc);
4223 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
4224 }
4225
4226
4227 // for mirror mode and dynamic scaling store u32BaseOffset
MDrv_SC_set_DNRBaseOffset(void * pInstance,SCALER_WIN eWindow,MS_PHY u32BaseOffset)4228 void MDrv_SC_set_DNRBaseOffset(void *pInstance, SCALER_WIN eWindow,MS_PHY u32BaseOffset)
4229 {
4230 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4231 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4232 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4233 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4234 pXCResourcePrivate->stdrvXC_Scaling.u32DNRBaseOffset[eWindow] = u32BaseOffset * BYTE_PER_WORD;
4235 }
4236
MDrv_SC_get_DNRBaseOffset(void * pInstance,SCALER_WIN eWindow)4237 MS_PHY MDrv_SC_get_DNRBaseOffset(void* pInstance, SCALER_WIN eWindow)
4238 {
4239 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4240 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4241 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4242 MS_PHY u32Return = 0;
4243 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
4244 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4245 u32Return = pXCResourcePrivate->stdrvXC_Scaling.u32DNRBaseOffset[eWindow];
4246 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
4247 return u32Return;
4248 }
4249
MDrv_SC_set_FRCMBaseOffset(void * pInstance,SCALER_WIN eWindow,MS_PHY u32BaseOffset)4250 void MDrv_SC_set_FRCMBaseOffset(void *pInstance, SCALER_WIN eWindow,MS_PHY u32BaseOffset)
4251 {
4252 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4253 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4254 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4255 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4256 pXCResourcePrivate->stdrvXC_Scaling.u32FRCMBaseOffset[eWindow] = u32BaseOffset * BYTE_PER_WORD;
4257 }
4258
MDrv_SC_get_FRCMBaseOffset(void * pInstance,SCALER_WIN eWindow)4259 MS_PHY MDrv_SC_get_FRCMBaseOffset(void* pInstance, SCALER_WIN eWindow)
4260 {
4261 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4262 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4263 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4264 MS_PHY u32Return = 0;
4265 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
4266 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4267 u32Return = pXCResourcePrivate->stdrvXC_Scaling.u32FRCMBaseOffset[eWindow];
4268 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
4269 return u32Return;
4270 }
4271
MApi_XC_Get_DNRBaseOffset_U2(void * pInstance,SCALER_WIN eWindow)4272 MS_PHY MApi_XC_Get_DNRBaseOffset_U2(void* pInstance, SCALER_WIN eWindow)
4273 {
4274 return MDrv_SC_get_DNRBaseOffset(pInstance, eWindow);
4275 }
4276
MApi_XC_Get_DNRBaseOffset(SCALER_WIN eWindow)4277 MS_PHY MApi_XC_Get_DNRBaseOffset(SCALER_WIN eWindow)
4278 {
4279 if (pu32XCInst == NULL)
4280 {
4281 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4282 return 0;
4283 }
4284
4285 stXC_GET_DNR_BASEOFFSET XCArgs;
4286 XCArgs.eWindow = eWindow;
4287 XCArgs.u32ReturnValue = 0;
4288
4289 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_DNR_BASEOFFSET, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4290 {
4291 printf("Obtain XC engine fail\n");
4292 return 0;
4293 }
4294 else
4295 {
4296 return XCArgs.u32ReturnValue;
4297 }
4298 }
4299
MDrv_XC_Get_FRCM_W_BaseAddr(void * pInstance,MS_U8 u8id,SCALER_WIN eWindow)4300 MS_PHY MDrv_XC_Get_FRCM_W_BaseAddr(void *pInstance,MS_U8 u8id,SCALER_WIN eWindow)
4301 {
4302 MS_PHY Addr = 0;
4303 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4304 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4305 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4306 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4307 #if (HW_DESIGN_4K2K_VER == 4)
4308 Addr = Hal_SC_Get_FRCMBaseAddr(pInstance, u8id,eWindow);
4309 #else
4310 Addr = 0;
4311 #endif
4312 return Addr;
4313 }
4314
4315 /******************************************************************************/
4316 /* Frame number related */
4317 /* ****************************************************************************/
_Mdrv_XC_Refine_FrameNum_Rule(void * pInstance,SCALER_WIN eWindow,MS_U32 u32Framesize,MS_U32 u32DNRBufSize,XC_FRAME_STORE_NUMBER * pFrameStoreNumber,MS_BOOL * pbLinearMode,MS_BOOL bInterlace,XC_FRAME_STORE_NUMBER enPQSuggestedFrameNum)4318 static void _Mdrv_XC_Refine_FrameNum_Rule(void *pInstance, SCALER_WIN eWindow,
4319 MS_U32 u32Framesize,
4320 MS_U32 u32DNRBufSize,
4321 XC_FRAME_STORE_NUMBER *pFrameStoreNumber,
4322 MS_BOOL *pbLinearMode,
4323 MS_BOOL bInterlace,
4324 XC_FRAME_STORE_NUMBER enPQSuggestedFrameNum)
4325 {
4326 if((pFrameStoreNumber == NULL) || (pbLinearMode == NULL))
4327 {
4328 MS_ASSERT(0);
4329 return;
4330 }
4331 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4332 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4333 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4334 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4335 switch( enPQSuggestedFrameNum )
4336 {
4337 case IMAGE_STORE_13_FRAMES:
4338 if ((u32Framesize*13) < u32DNRBufSize )
4339 {
4340 *pFrameStoreNumber = IMAGE_STORE_13_FRAMES;
4341 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*13 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4342 }
4343 break;
4344
4345 case IMAGE_STORE_12_FRAMES:
4346 if ((u32Framesize*12) < u32DNRBufSize )
4347 {
4348 *pFrameStoreNumber = IMAGE_STORE_12_FRAMES;
4349 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*12 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4350 }
4351 break;
4352
4353 case IMAGE_STORE_11_FRAMES:
4354 if ((u32Framesize*11) < u32DNRBufSize )
4355 {
4356 *pFrameStoreNumber = IMAGE_STORE_11_FRAMES;
4357 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*11 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4358 }
4359 break;
4360
4361 case IMAGE_STORE_10_FRAMES:
4362 if ((u32Framesize*10) < u32DNRBufSize )
4363 {
4364 *pFrameStoreNumber = IMAGE_STORE_10_FRAMES;
4365 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*10 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4366 }
4367 break;
4368
4369 case IMAGE_STORE_9_FRAMES:
4370 if ((u32Framesize*9) < u32DNRBufSize )
4371 {
4372 *pFrameStoreNumber = IMAGE_STORE_9_FRAMES;
4373 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*9 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4374 }
4375 break;
4376
4377 case IMAGE_STORE_8_FRAMES:
4378 if ((u32Framesize*8) < u32DNRBufSize )
4379 {
4380 *pFrameStoreNumber = IMAGE_STORE_8_FRAMES;
4381 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*8 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4382 }
4383 break;
4384
4385 case IMAGE_STORE_7_FRAMES:
4386 if ((u32Framesize*7) < u32DNRBufSize )
4387 {
4388 *pFrameStoreNumber = IMAGE_STORE_7_FRAMES;
4389 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*7 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4390 }
4391 break;
4392
4393 case IMAGE_STORE_6_FRAMES:
4394 if ((u32Framesize*6) < u32DNRBufSize )
4395 {
4396 *pFrameStoreNumber = IMAGE_STORE_6_FRAMES;
4397 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*6 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4398 }
4399 break;
4400
4401 case IMAGE_STORE_5_FRAMES:
4402 if ((u32Framesize*5) < u32DNRBufSize )
4403 {
4404 *pFrameStoreNumber = IMAGE_STORE_5_FRAMES;
4405 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*5 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4406 }
4407 break;
4408
4409 case IMAGE_STORE_4_FRAMES:
4410 if(MDrv_SC_GetScmiV1Speical4frame(pInstance, enPQSuggestedFrameNum) && ((u32Framesize*8) < u32DNRBufSize ))
4411 {
4412 *pFrameStoreNumber = IMAGE_STORE_4_FRAMES;
4413 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*8 < %td for Special4Frame\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4414 }
4415 else if ((u32Framesize*4) < u32DNRBufSize )
4416 {
4417 *pFrameStoreNumber = IMAGE_STORE_4_FRAMES;
4418 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*4 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4419 }
4420 #if (_3FRAME_BUFFER_PMODE_SUPPORTED)
4421 else if ((u32Framesize*3) < u32DNRBufSize )
4422 {
4423 *pFrameStoreNumber = IMAGE_STORE_3_FRAMES;
4424 #if (_LINEAR_ADDRESS_MODE_SUPPORTED)
4425 *pbLinearMode = TRUE;
4426 #endif
4427 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*3 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4428 }
4429 #endif
4430 break;
4431
4432 case IMAGE_STORE_3_FRAMES:
4433 #if (_3FRAME_BUFFER_PMODE_SUPPORTED)
4434 if ((u32Framesize*3) < u32DNRBufSize )
4435 {
4436 *pFrameStoreNumber = IMAGE_STORE_3_FRAMES;
4437 #if (_LINEAR_ADDRESS_MODE_SUPPORTED)
4438 *pbLinearMode = TRUE;
4439 #endif
4440 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*3 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4441 }
4442 #endif
4443 break;
4444
4445 case IMAGE_STORE_2_FRAMES:
4446 if ((u32Framesize*2) < u32DNRBufSize )
4447 {
4448 *pFrameStoreNumber = IMAGE_STORE_2_FRAMES;
4449 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*2 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4450 }
4451 break;
4452
4453 #if (ENABLE_16_FIELD_SUPPORTED)
4454 case IMAGE_STORE_6_FIELDS:
4455 if ((u32Framesize*3) < u32DNRBufSize )
4456 {
4457 *pFrameStoreNumber = IMAGE_STORE_6_FIELDS;
4458 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"ENABLE_8_FIELD_SUPPORTED %d \n",ENABLE_16_FIELD_SUPPORTED);
4459 }
4460 break;
4461
4462 case IMAGE_STORE_8_FIELDS:
4463 if ((u32Framesize*4) < u32DNRBufSize )
4464 {
4465 *pFrameStoreNumber = IMAGE_STORE_8_FIELDS;
4466 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"ENABLE_8_FIELD_SUPPORTED %d \n",ENABLE_16_FIELD_SUPPORTED);
4467 }
4468 break;
4469
4470 case IMAGE_STORE_12_FIELDS:
4471 if ((u32Framesize*6) < u32DNRBufSize )
4472 {
4473 *pFrameStoreNumber = IMAGE_STORE_12_FIELDS;
4474 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"ENABLE_12_FIELD_SUPPORTED %d \n",ENABLE_16_FIELD_SUPPORTED);
4475 }
4476 break;
4477
4478 case IMAGE_STORE_14_FIELDS:
4479 if ((u32Framesize*7) < u32DNRBufSize )
4480 {
4481 *pFrameStoreNumber = IMAGE_STORE_14_FIELDS;
4482 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"ENABLE_14_FIELD_SUPPORTED %d \n",ENABLE_16_FIELD_SUPPORTED);
4483 }
4484 break;
4485
4486 case IMAGE_STORE_16_FIELDS:
4487 if ((u32Framesize*8) < u32DNRBufSize )
4488 {
4489 *pFrameStoreNumber = IMAGE_STORE_16_FIELDS;
4490 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"ENABLE_16_FIELD_SUPPORTED %d \n",ENABLE_16_FIELD_SUPPORTED);
4491 }
4492 break;
4493 #endif
4494
4495 default:
4496 break;
4497 }
4498
4499 //final protect handling:
4500 //mirror and sub window: progressive: 4 frame mode; interlace: 8 field mode
4501 //sub window: progressive: 3 frame mode; interlace: 6 field mode
4502 //input vfreq > panel supported vfreq: progressive: 3 frame mode; interlace: 6 field mode
4503 //mirror: progressive: 3 frame mode; interlace: not care
4504 if(IsVMirrorMode(eWindow)
4505 && (eWindow == SUB_WINDOW)
4506 && (u32Framesize * 4 <= u32DNRBufSize))
4507 {
4508 if(bInterlace)
4509 {
4510 #if (ENABLE_16_FIELD_SUPPORTED)
4511 if(*pFrameStoreNumber < IMAGE_STORE_8_FIELDS)
4512 {
4513 *pFrameStoreNumber = IMAGE_STORE_8_FIELDS;
4514 }
4515 #endif
4516 }
4517 else
4518 {
4519 #if (_4FRAME_BUFFER_PMODE_SUPPORTED)
4520 if(*pFrameStoreNumber < IMAGE_STORE_4_FRAMES)
4521 {
4522 *pFrameStoreNumber = IMAGE_STORE_4_FRAMES;
4523 }
4524 #endif
4525 }
4526 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*4 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4527 }
4528 else if((( eWindow == SUB_WINDOW)
4529 || ((gSrcInfo[eWindow].u16InputVFreq > 600 + VFREQDELTA)
4530 && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16DefaultVFreq <= 600))
4531 || ((gSrcInfo[eWindow].u16InputVFreq > 1200 + VFREQDELTA)
4532 && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16DefaultVFreq <= 1200)))
4533 && (u32Framesize*3 < u32DNRBufSize))
4534 {
4535 if(bInterlace)
4536 {
4537 #if (HW_DESIGN_4K2K_VER != 4)
4538 #if (ENABLE_16_FIELD_SUPPORTED)
4539 if(*pFrameStoreNumber < IMAGE_STORE_6_FIELDS)
4540 {
4541 *pFrameStoreNumber = IMAGE_STORE_6_FIELDS;
4542 }
4543 #endif
4544 #endif
4545 }
4546 else
4547 {
4548 #if (_3FRAME_BUFFER_PMODE_SUPPORTED)
4549 if(*pFrameStoreNumber < IMAGE_STORE_3_FRAMES)
4550 {
4551 // 3 frame mode need to be set as linear mode.
4552 #if (_LINEAR_ADDRESS_MODE_SUPPORTED)
4553 *pbLinearMode = TRUE;
4554 #endif
4555 *pFrameStoreNumber = IMAGE_STORE_3_FRAMES;
4556 }
4557 #endif
4558 }
4559 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*3 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4560 }
4561 else if((IsVMirrorMode(eWindow)
4562 #if LOCK_FREQ_ONLY_WITHOUT_LOCK_PHASE
4563 || (MDrv_XC_FPLL_IsSupportLockFreqOnly(pInstance))
4564 #endif
4565 )
4566 && (u32Framesize*3 < u32DNRBufSize)
4567 && (!bInterlace))
4568 {
4569 #if (_3FRAME_BUFFER_PMODE_SUPPORTED)
4570 if(*pFrameStoreNumber < IMAGE_STORE_3_FRAMES)
4571 {
4572 // 3 frame mode need to be set as linear mode.
4573 #if (_LINEAR_ADDRESS_MODE_SUPPORTED)
4574 *pbLinearMode = TRUE;
4575 #endif
4576 *pFrameStoreNumber = IMAGE_STORE_3_FRAMES;
4577 }
4578 #endif
4579 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%td*3 < %td\n", (ptrdiff_t)u32Framesize, (ptrdiff_t)u32DNRBufSize );
4580 }
4581
4582 if((bInterlace!=TRUE)&&(enPQSuggestedFrameNum == IMAGE_STORE_2_FRAMES))
4583 {
4584 if(u32Framesize*3 <= u32DNRBufSize)
4585 {
4586 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%ld*3 < %ld\n",(long int)u32Framesize,(long int)u32DNRBufSize );
4587 }
4588 else
4589 {
4590 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"%ld*3 > %ld\n",(long int)u32Framesize,(long int)u32DNRBufSize );
4591 }
4592
4593 if(u32Framesize*3 <= u32DNRBufSize)
4594 {
4595
4596 #if (_3FRAME_BUFFER_PMODE_SUPPORTED)
4597 if(*pFrameStoreNumber < IMAGE_STORE_3_FRAMES)
4598 {
4599 // 3 frame mode need to be set as linear mode.
4600 #if (_LINEAR_ADDRESS_MODE_SUPPORTED)
4601 *pbLinearMode = TRUE;
4602 #endif
4603 *pFrameStoreNumber = IMAGE_STORE_3_FRAMES;
4604 }
4605 #endif
4606 }
4607 }
4608
4609 #if _FIELD_PACKING_MODE_SUPPORTED
4610 if(enPQSuggestedFrameNum != *pFrameStoreNumber )
4611 {
4612 printf("Note: enPQSuggestedFrameNum(%u) != *pFrameStoreNumber(%u)\n", enPQSuggestedFrameNum,*pFrameStoreNumber);
4613 }
4614 #endif
4615 }
4616
4617 /// Decide best frame buffer number used.
_Mdrv_XC_Refine_FrameNum(void * pInstance,MS_BOOL * pbLinearMode,XC_FRAME_STORE_NUMBER * pFrameStoreNumber,MS_BOOL bInterlace,MS_U32 u32Framesize,MS_U32 u32DNRBufSize,SCALER_WIN eWindow)4618 static void _Mdrv_XC_Refine_FrameNum(void *pInstance, MS_BOOL *pbLinearMode,
4619 XC_FRAME_STORE_NUMBER *pFrameStoreNumber,
4620 MS_BOOL bInterlace,
4621 MS_U32 u32Framesize,
4622 MS_U32 u32DNRBufSize,
4623 SCALER_WIN eWindow)
4624 {
4625 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4626 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4627 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4628 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4629
4630 MS_U32 u32Dynamic_scale_size = (MS_U32)gSrcInfo[eWindow].Status2.u16VirtualBox_Width*
4631 gSrcInfo[eWindow].Status2.u16VirtualBox_Height*
4632 gSrcInfo[eWindow].u8BitPerPixel / 8 ;
4633
4634 XC_FRAME_STORE_NUMBER enPQSuggestedFrameNum = MDrv_XC_GetPQSuggestedFrameNum(pInstance, eWindow);
4635
4636 if(pXCResourcePrivate->stdrvXC_MVideo.bUseDdr4DramForXc)
4637 {
4638 if((enPQSuggestedFrameNum >= IMAGE_STORE_2_FRAMES)&&(enPQSuggestedFrameNum <= IMAGE_STORE_13_FRAMES))
4639 {
4640 switch(enPQSuggestedFrameNum)
4641 {
4642 case IMAGE_STORE_2_FRAMES:
4643 case IMAGE_STORE_3_FRAMES:
4644 enPQSuggestedFrameNum = IMAGE_STORE_3_FRAMES;
4645 break;
4646 case IMAGE_STORE_4_FRAMES:
4647 case IMAGE_STORE_5_FRAMES:
4648 enPQSuggestedFrameNum = IMAGE_STORE_5_FRAMES;
4649 break;
4650 case IMAGE_STORE_6_FRAMES:
4651 case IMAGE_STORE_7_FRAMES:
4652 enPQSuggestedFrameNum = IMAGE_STORE_7_FRAMES;
4653 break;
4654 case IMAGE_STORE_8_FRAMES:
4655 case IMAGE_STORE_9_FRAMES:
4656 enPQSuggestedFrameNum = IMAGE_STORE_9_FRAMES;
4657 break;
4658 case IMAGE_STORE_10_FRAMES:
4659 case IMAGE_STORE_11_FRAMES:
4660 enPQSuggestedFrameNum = IMAGE_STORE_11_FRAMES;
4661 break;
4662 case IMAGE_STORE_12_FRAMES:
4663 case IMAGE_STORE_13_FRAMES:
4664 enPQSuggestedFrameNum = IMAGE_STORE_13_FRAMES;
4665 break;
4666 default:
4667 enPQSuggestedFrameNum = IMAGE_STORE_3_FRAMES;
4668 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] invlid Frame num,set defualt value:3 frames\n",__func__,__LINE__);
4669 break;
4670 }
4671 }
4672
4673 }
4674
4675 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] u32Framesize:%td u32DNRBufSize:%td \n",__func__,__LINE__, (ptrdiff_t)u32Framesize,(ptrdiff_t)u32DNRBufSize);
4676 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] u32Dynamic_scale_size:%td enPQSuggestedFrameNum:%d \n",__func__,__LINE__, (ptrdiff_t)u32Dynamic_scale_size,enPQSuggestedFrameNum);
4677
4678 if((pbLinearMode == NULL) || (pFrameStoreNumber == NULL))
4679 {
4680 MS_ASSERT(0);
4681 return;
4682 }
4683
4684 *pbLinearMode = FALSE;
4685
4686 if(bInterlace)
4687 {
4688 *pFrameStoreNumber = IMAGE_STORE_4_FIELDS;
4689 }
4690 else
4691 {
4692 if(pXCResourcePrivate->stdrvXC_MVideo.bUseDdr4DramForXc)
4693 {
4694 *pFrameStoreNumber = IMAGE_STORE_3_FRAMES;
4695 }
4696 else
4697 {
4698 *pFrameStoreNumber = IMAGE_STORE_2_FRAMES;
4699 }
4700 }
4701
4702 if((MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)) && (eWindow == MAIN_WINDOW))
4703 {
4704 if(bInterlace )
4705 {
4706 _Mdrv_XC_Refine_FrameNum_Rule(pInstance, eWindow,
4707 u32Framesize,
4708 u32DNRBufSize,
4709 pFrameStoreNumber,
4710 pbLinearMode,
4711 bInterlace,
4712 enPQSuggestedFrameNum);
4713 }
4714 else
4715 {
4716 #if SUPPORT_SEAMLESS_ZAPPING /// for SeamlessZapping
4717 if(Hal_SC_GetSeamlessZappingStatus(pInstance, eWindow))
4718 {
4719 _Mdrv_XC_Refine_FrameNum_Rule(pInstance, eWindow,
4720 u32Framesize,
4721 u32DNRBufSize,
4722 pFrameStoreNumber,
4723 pbLinearMode,
4724 bInterlace,
4725 enPQSuggestedFrameNum);
4726 }
4727 else
4728 #endif
4729 if(pXCResourcePrivate->stdrvXC_MVideo.bUseDdr4DramForXc)
4730 {
4731 if((u32Dynamic_scale_size*5<u32DNRBufSize) && (! MDrv_SC_GetScmiV1Speical4frame(pInstance, enPQSuggestedFrameNum)))
4732 {
4733 #ifdef UFO_XC_SUPPORT_3D_DS
4734 if (IS_INPUT_FRAME_ALTERNATIVE(eWindow))
4735 {
4736 *pFrameStoreNumber = IMAGE_STORE_3_FRAMES;
4737 }
4738 else
4739 #endif
4740 {
4741 *pFrameStoreNumber = IMAGE_STORE_5_FRAMES;
4742 }
4743 }
4744 else if((u32Dynamic_scale_size*10<u32DNRBufSize) && (MDrv_SC_GetScmiV1Speical4frame(pInstance, enPQSuggestedFrameNum)))
4745 {//special 4 frame mode(store 8 frame in memory)
4746 *pFrameStoreNumber = IMAGE_STORE_5_FRAMES;
4747 }
4748 #if (_3FRAME_BUFFER_PMODE_SUPPORTED)
4749 else if(u32Dynamic_scale_size*4 < u32DNRBufSize)
4750 {
4751 *pFrameStoreNumber = IMAGE_STORE_3_FRAMES;
4752 #if (_LINEAR_ADDRESS_MODE_SUPPORTED)
4753 *pbLinearMode = TRUE;
4754 #endif
4755 }
4756 #endif
4757 else
4758 {
4759 *pFrameStoreNumber = IMAGE_STORE_3_FRAMES;
4760 }
4761 }
4762 else
4763 {
4764 #if (_4FRAME_BUFFER_PMODE_SUPPORTED)
4765 if((u32Dynamic_scale_size*4<u32DNRBufSize) && (! MDrv_SC_GetScmiV1Speical4frame(pInstance, enPQSuggestedFrameNum)))
4766 {
4767 #ifdef UFO_XC_SUPPORT_3D_DS
4768 if (IS_INPUT_FRAME_ALTERNATIVE(eWindow))
4769 {
4770 *pFrameStoreNumber = IMAGE_STORE_2_FRAMES;
4771 }
4772 else
4773 #endif
4774 {
4775 *pFrameStoreNumber = IMAGE_STORE_4_FRAMES;
4776 }
4777 }
4778 else if((u32Dynamic_scale_size*8<u32DNRBufSize) && (MDrv_SC_GetScmiV1Speical4frame(pInstance, enPQSuggestedFrameNum)))
4779 {//special 4 frame mode(store 8 frame in memory)
4780 *pFrameStoreNumber = IMAGE_STORE_4_FRAMES;
4781 }
4782 #if (_3FRAME_BUFFER_PMODE_SUPPORTED)
4783 else if(u32Dynamic_scale_size*3 < u32DNRBufSize)
4784 {
4785 *pFrameStoreNumber = IMAGE_STORE_3_FRAMES;
4786 #if (_LINEAR_ADDRESS_MODE_SUPPORTED)
4787 *pbLinearMode = TRUE;
4788 #endif
4789 }
4790 #endif
4791 else
4792 #endif
4793 {
4794 *pFrameStoreNumber = IMAGE_STORE_2_FRAMES;
4795 }
4796 }
4797 }
4798 }
4799 else
4800 {
4801 _Mdrv_XC_Refine_FrameNum_Rule(pInstance, eWindow,
4802 u32Framesize,
4803 u32DNRBufSize,
4804 pFrameStoreNumber,
4805 pbLinearMode,
4806 bInterlace,
4807 enPQSuggestedFrameNum);
4808
4809 #ifndef DISABLE_3D_FUNCTION
4810 // Adjust frame mode by 3D content
4811 *pFrameStoreNumber = MDrv_SC_3D_Adjust_FrameNum(pInstance, *pFrameStoreNumber, eWindow);
4812 #endif
4813 }
4814
4815 if(*pFrameStoreNumber != IMAGE_STORE_3_FRAMES)
4816 {
4817 *pbLinearMode = FALSE;
4818 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "if it's not 3 frame mode, linear mode should also be closed\n");
4819 }
4820
4821 #if (HW_DESIGN_4K2K_VER == 7) //Kano Patch
4822 if((psXCInstPri->u32DeviceID==0) && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_IPMUX_HDR_MODE))
4823 {
4824 //For Kano HDR design case, HDR is for FB mode and FRC in XC, so it need 3 frame or 6 fieldto FRC
4825 if(bInterlace && *pFrameStoreNumber < IMAGE_STORE_6_FIELDS)
4826 {
4827 *pFrameStoreNumber = IMAGE_STORE_6_FIELDS;
4828 }
4829 else if(bInterlace == FALSE && *pFrameStoreNumber < IMAGE_STORE_3_FRAMES)
4830 {
4831 *pFrameStoreNumber = IMAGE_STORE_3_FRAMES;
4832 }
4833 }
4834 //Set the frame is 4 on Kano XC1 with Rx in, because FRC case
4835 else if((psXCInstPri->u32DeviceID==1) &&
4836 (IsSrcTypeHDMI(gSrcInfo[eWindow].enInputSourceType)
4837 || IsSrcTypeDTV(gSrcInfo[eWindow].enInputSourceType)
4838 || IsSrcTypeStorage(gSrcInfo[eWindow].enInputSourceType)))
4839 {
4840 if(bInterlace)
4841 {
4842 *pFrameStoreNumber = IMAGE_STORE_8_FIELDS;
4843 }
4844 else
4845 {
4846 *pFrameStoreNumber = IMAGE_STORE_4_FRAMES;
4847 }
4848 }
4849
4850 //This is Kano SW patch for release
4851 //I mode must do FRC in XC, so need 6 field
4852 #ifdef HW_DESIGN_HDR_VER
4853 #if (HW_DESIGN_HDR_VER == 0)
4854 if(psXCInstPri->u32DeviceID==0 && ((pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_IPMUX_HDR_MODE) == 0))
4855 {
4856 if((bInterlace == TRUE) && (*pFrameStoreNumber < IMAGE_STORE_6_FIELDS))
4857 {
4858 *pFrameStoreNumber = IMAGE_STORE_6_FIELDS;
4859 }
4860 //Kano SWDS case do not to set 4 frames
4861 //Need only 2 Frame now
4862 if((bInterlace == FALSE) && (*pFrameStoreNumber > IMAGE_STORE_2_FRAMES) && (MDrv_XC_GetDynamicScalingStatus(pInstance)))
4863 {
4864 *pFrameStoreNumber = IMAGE_STORE_2_FRAMES;
4865 }
4866 }
4867 #endif
4868 #endif
4869 #endif
4870
4871 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"pFrameStoreNumber: %d , corresponding factor is: %u\n",
4872 *pFrameStoreNumber, MDrv_XC_TransFrameNumToFactor(pInstance, *pFrameStoreNumber, *pbLinearMode, _FIELD_PACKING_MODE_SUPPORTED));
4873 }
4874
4875 #if (HW_DESIGN_4K2K_VER == 4)
4876 /// Decide best FRCM frame buffer number used.
_Mdrv_XC_Refine_FRCMFrameNum(void * pInstance,MS_BOOL * pbLinearMode,XC_FRAME_STORE_NUMBER * pFRCMFrameStoreNumber,MS_U32 u32Framesize,MS_U32 u32FRCMBufSize,SCALER_WIN eWindow)4877 static void _Mdrv_XC_Refine_FRCMFrameNum(void *pInstance, MS_BOOL *pbLinearMode,
4878 XC_FRAME_STORE_NUMBER *pFRCMFrameStoreNumber,
4879 MS_U32 u32Framesize,
4880 MS_U32 u32FRCMBufSize,
4881 SCALER_WIN eWindow)
4882 {
4883 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4884 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4885 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4886 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4887
4888 MS_U32 u32Dynamic_scale_size = (MS_U32)gSrcInfo[eWindow].Status2.u16VirtualBox_Width*
4889 gSrcInfo[eWindow].Status2.u16VirtualBox_Height*
4890 gSrcInfo[eWindow].u8BitPerPixel / 8 ;
4891
4892 XC_FRAME_STORE_NUMBER enPQSuggestedFrameNum = MDrv_XC_GetPQSuggestedFRCMFrameNum(pInstance, eWindow);
4893
4894 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] u32Dynamic_scale_size:%td enPQSuggestedFrameNum:%d \n",__func__,__LINE__, (ptrdiff_t)u32Dynamic_scale_size,enPQSuggestedFrameNum);
4895
4896 if((pbLinearMode == NULL) || (pFRCMFrameStoreNumber == NULL))
4897 {
4898 MS_ASSERT(0);
4899 return;
4900 }
4901
4902 *pbLinearMode = FALSE;
4903
4904 *pFRCMFrameStoreNumber = IMAGE_STORE_2_FRAMES;
4905
4906 if((MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)) && (eWindow == MAIN_WINDOW))
4907 {
4908 if (u32Dynamic_scale_size*4<u32FRCMBufSize)
4909 {
4910 *pFRCMFrameStoreNumber = IMAGE_STORE_4_FRAMES;
4911 }
4912 #if (_3FRAME_BUFFER_PMODE_SUPPORTED)
4913 else if(u32Dynamic_scale_size*3 < u32FRCMBufSize)
4914 {
4915 *pFRCMFrameStoreNumber = IMAGE_STORE_3_FRAMES;
4916 #if (_LINEAR_ADDRESS_MODE_SUPPORTED)
4917 *pbLinearMode = TRUE;
4918 #endif
4919 }
4920 #endif
4921 else
4922 {
4923 *pFRCMFrameStoreNumber = IMAGE_STORE_2_FRAMES;
4924 }
4925 }
4926 else
4927 {
4928 _Mdrv_XC_Refine_FrameNum_Rule(pInstance, eWindow,
4929 u32Framesize,
4930 u32FRCMBufSize,
4931 pFRCMFrameStoreNumber,
4932 pbLinearMode,
4933 FALSE,
4934 enPQSuggestedFrameNum);
4935
4936 #ifndef DISABLE_3D_FUNCTION
4937 // Adjust frame mode by 3D content
4938 *pFRCMFrameStoreNumber = MDrv_SC_3D_Adjust_FrameNum(pInstance, *pFRCMFrameStoreNumber, eWindow);
4939 #endif
4940 }
4941
4942 if(*pFRCMFrameStoreNumber != IMAGE_STORE_3_FRAMES)
4943 {
4944 *pbLinearMode = FALSE;
4945 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "if it's not 3 frame mode, linear mode should also be closed\n");
4946 }
4947
4948 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"pFRCMFrameStoreNumber: %d , corresponding factor is: %u\n",
4949 *pFRCMFrameStoreNumber, MDrv_XC_TransFrameNumToFactor(pInstance, *pFRCMFrameStoreNumber, *pbLinearMode, _FIELD_PACKING_MODE_SUPPORTED));
4950 }
4951 #endif
4952
4953 //save current frame number factor into static var
MDrv_XC_Save_FrameNumFactor(void * pInstance,SCALER_WIN eWindow,MS_U8 u8FrameNum)4954 void MDrv_XC_Save_FrameNumFactor(void *pInstance, SCALER_WIN eWindow, MS_U8 u8FrameNum)
4955 {
4956 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4957 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4958 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4959 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4960 pXCResourcePrivate->stdrvXC_Scaling._au8StoreFrameNumFactor[eWindow] = u8FrameNum;
4961 }
4962
4963 #if (HW_DESIGN_4K2K_VER == 4)
4964 //save current frcm frame number factor into static var
MDrv_XC_Save_FRCMFrameNumFactor(void * pInstance,SCALER_WIN eWindow,MS_U8 u8FrameNum)4965 void MDrv_XC_Save_FRCMFrameNumFactor(void *pInstance, SCALER_WIN eWindow, MS_U8 u8FrameNum)
4966 {
4967 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4968 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4969 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4970 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4971 pXCResourcePrivate->stdrvXC_Scaling._u8StoreFRCMFrameNumFactor[eWindow] = u8FrameNum;
4972 }
4973 #endif
4974
4975 //get stored scm frame number factor from static var
MApi_XC_Get_FrameNumFactor_U2(void * pInstance,SCALER_WIN eWindow)4976 MS_U8 MApi_XC_Get_FrameNumFactor_U2(void* pInstance, SCALER_WIN eWindow)
4977 {
4978 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4979 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4980 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4981 MS_U8 u8Return = FALSE;
4982 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
4983 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4984 u8Return = pXCResourcePrivate->stdrvXC_Scaling._au8StoreFrameNumFactor[eWindow];
4985 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
4986 return u8Return;
4987 }
4988
MApi_XC_Get_FrameNumFactor(SCALER_WIN eWindow)4989 MS_U8 MApi_XC_Get_FrameNumFactor(SCALER_WIN eWindow)
4990 {
4991 if (pu32XCInst == NULL)
4992 {
4993 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4994 return 0;
4995 }
4996
4997 stXC_GET_FRAMENUM_FACTOR XCArgs;
4998 XCArgs.eWindow = eWindow;
4999 XCArgs.u8ReturnValue = 0;
5000
5001 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_FRAMENUM_FACTOR, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5002 {
5003 printf("Obtain XC engine fail\n");
5004 return 0;
5005 }
5006 else
5007 {
5008 return XCArgs.u8ReturnValue;
5009 }
5010 }
5011
5012 //get stored frcm frame number factor from static var
MApi_XC_Get_FRCM_FrameNum_U2(void * pInstance,SCALER_WIN eWindow)5013 MS_U8 MApi_XC_Get_FRCM_FrameNum_U2(void* pInstance, SCALER_WIN eWindow)
5014 {
5015 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5016 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5017 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5018 MS_U8 u8Return = FALSE;
5019 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
5020 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5021 #if (HW_DESIGN_4K2K_VER == 4)
5022 u8Return = pXCResourcePrivate->stdrvXC_Scaling._u8StoreFRCMFrameNumFactor[eWindow];
5023 #endif
5024 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
5025 return u8Return;
5026 }
5027
MApi_XC_Get_FRCMFrameNum(SCALER_WIN eWindow)5028 MS_U8 MApi_XC_Get_FRCMFrameNum(SCALER_WIN eWindow)
5029 {
5030 if (pu32XCInst == NULL)
5031 {
5032 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5033 return 0;
5034 }
5035
5036 stXC_GET_FRCM_FRAMENUM XCArgs;
5037 XCArgs.eWindow = eWindow;
5038 XCArgs.u8ReturnValue = 0;
5039
5040 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_FRCM_FRAMENUM, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5041 {
5042 printf("Obtain XC engine fail\n");
5043 return 0;
5044 }
5045 else
5046 {
5047 return XCArgs.u8ReturnValue;
5048 }
5049 }
5050
5051 #if _FIELD_PACKING_MODE_SUPPORTED
_MDrv_XC_Get_FrameNumFromReg(void * pInstance,SCALER_WIN eWindow)5052 static MS_U16 _MDrv_XC_Get_FrameNumFromReg(void *pInstance, SCALER_WIN eWindow)
5053 {
5054 MS_U16 u16FrameCount = 0;
5055
5056 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5057 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5058
5059 if(eWindow == MAIN_WINDOW)
5060 {
5061 u16FrameCount = 0x1F & SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK12_19_L);
5062 }
5063 else
5064 {
5065 u16FrameCount = 0x1F & SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK12_59_L);
5066 }
5067
5068 return u16FrameCount;
5069 }
5070
5071 #if (HW_DESIGN_4K2K_VER == 4)
_MDrv_XC_Get_FRCMFrameNumFromReg(void * pInstance,SCALER_WIN eWindow)5072 static MS_U16 _MDrv_XC_Get_FRCMFrameNumFromReg(void *pInstance, SCALER_WIN eWindow)
5073 {
5074 MS_U16 u16FRCMFrameCount = 0;
5075
5076 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5077 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5078
5079 if(eWindow == MAIN_WINDOW)
5080 {
5081 u16FRCMFrameCount = 0x1F & SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK32_19_L);
5082 }
5083 else
5084 {
5085 u16FRCMFrameCount = 0x1F & SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK32_59_L);
5086 }
5087
5088 return u16FRCMFrameCount;
5089 }
5090 #endif
5091 #endif
5092
MDrv_XC_GetPQSuggestedFrameNum(void * pInstance,SCALER_WIN eWindow)5093 XC_FRAME_STORE_NUMBER MDrv_XC_GetPQSuggestedFrameNum(void *pInstance, SCALER_WIN eWindow)
5094 {
5095 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5096 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5097 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5098 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5099 #if _FIELD_PACKING_MODE_SUPPORTED
5100
5101 MS_U16 u16FrameCount = 0x00;
5102
5103 #ifdef K3_U2
5104 if(E_XC_DEVICE0 == psXCInstPri->u32DeviceID) // SC0
5105 {
5106 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl)
5107 {
5108 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
5109 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl((psXCInstPri->u32DeviceID == 1)?PQ_SUB_WINDOW:PQ_MAIN_WINDOW, E_PQ_IOCTL_PQ_SUGGESTED_FRAMENUM, (void *)&u16FrameCount, sizeof(u16FrameCount)) == FALSE)
5110 #else
5111 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl((PQ_WIN)eWindow, E_PQ_IOCTL_PQ_SUGGESTED_FRAMENUM, (void *)&u16FrameCount, sizeof(u16FrameCount)) == FALSE)
5112 #endif
5113 {
5114 u16FrameCount = _MDrv_XC_Get_FrameNumFromReg(pInstance, eWindow);
5115
5116 if(u16FrameCount == 0)
5117 {
5118 u16FrameCount = 2;
5119 }
5120 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Alert: cannot get frameCount from IOCTL, eWindow=%u! Fall back to original method\n", eWindow);
5121 }
5122 }
5123 else
5124 {
5125 u16FrameCount = _MDrv_XC_Get_FrameNumFromReg(pInstance, eWindow);
5126
5127 if(u16FrameCount == 0)
5128 {
5129 u16FrameCount = 2;
5130 }
5131 printf("Alert: cannot get frameCount from IOCTL, eWindow=%u! Fall back to original frame mode\n", eWindow);
5132 }
5133
5134 if(Hal_SC_IsPX2MemFormat(pInstance, eWindow))
5135 {
5136 u16FrameCount /= 2;
5137 }
5138 }
5139 else // SC1
5140 {
5141 if(gSrcInfo[eWindow].bInterlace)
5142 {
5143 u16FrameCount = 8;
5144 }
5145 else
5146 {
5147 u16FrameCount = 4;
5148 }
5149 }
5150 #else
5151 #ifdef ENABLE_TV_SC2_PQ
5152 if ( (psXCInstPri->u32DeviceID == PQ_XC_ID_0)
5153 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
5154 ||(psXCInstPri->u32DeviceID == PQ_XC_ID_1)
5155 #endif
5156 )
5157 #endif
5158 {
5159 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl)
5160 {
5161 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
5162 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl((psXCInstPri->u32DeviceID == 1)?PQ_SUB_WINDOW:PQ_MAIN_WINDOW, E_PQ_IOCTL_PQ_SUGGESTED_FRAMENUM, (void *)&u16FrameCount, sizeof(u16FrameCount)) == FALSE)
5163 #else
5164 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl((PQ_WIN)eWindow, E_PQ_IOCTL_PQ_SUGGESTED_FRAMENUM, (void *)&u16FrameCount, sizeof(u16FrameCount)) == FALSE)
5165 #endif
5166 {
5167 u16FrameCount = _MDrv_XC_Get_FrameNumFromReg(pInstance, eWindow);
5168
5169 if(u16FrameCount == 0)
5170 {
5171 u16FrameCount = 2;
5172 }
5173 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Alert: cannot get frameCount from IOCTL, eWindow=%u! Fall back to original method\n", eWindow);
5174 }
5175 }
5176 else
5177 {
5178 u16FrameCount = _MDrv_XC_Get_FrameNumFromReg(pInstance, eWindow);
5179
5180 if(u16FrameCount == 0)
5181 {
5182 u16FrameCount = 2;
5183 }
5184 printf("Alert: cannot get frameCount from IOCTL, eWindow=%u! Fall back to original frame mode\n", eWindow);
5185 }
5186 }
5187 #ifdef ENABLE_TV_SC2_PQ
5188 else if (psXCInstPri->u32DeviceID == PQ_XC_ID_1)
5189 {
5190 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl_ex)
5191 {
5192 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl_ex(psXCInstPri->u32DeviceID, (PQ_WIN)eWindow, E_PQ_IOCTL_PQ_SUGGESTED_FRAMENUM, (void *)&u16FrameCount, sizeof(u16FrameCount)) == FALSE)
5193 {
5194 u16FrameCount = _MDrv_XC_Get_FrameNumFromReg(pInstance, eWindow);
5195
5196 if(u16FrameCount == 0)
5197 {
5198 u16FrameCount = 2;
5199 }
5200 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Alert: cannot get frameCount from IOCTL, eWindow=%u! Fall back to original method\n", eWindow);
5201 }
5202 }
5203 else
5204 {
5205 u16FrameCount = _MDrv_XC_Get_FrameNumFromReg(pInstance, eWindow);
5206
5207 if(u16FrameCount == 0)
5208 {
5209 u16FrameCount = 2;
5210 }
5211 printf("Alert: cannot get frameCount from IOCTL, eWindow=%u! Fall back to original frame mode\n", eWindow);
5212 }
5213 }
5214 #else
5215 #if (HW_DESIGN_4K2K_VER == 7) //Kano Patch
5216 if (psXCInstPri->u32DeviceID == PQ_XC_ID_1)
5217 {
5218 if(gSrcInfo[eWindow].bInterlace)
5219 {
5220 u16FrameCount = 8;
5221 }
5222 else
5223 {
5224 u16FrameCount = 4;
5225 }
5226 }
5227 #endif
5228 #endif
5229 #endif
5230
5231 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "MDrv_XC_GetPQSuggestedFrameNum(%u) get %u frame count\n", eWindow, u16FrameCount);
5232
5233 return MDrv_XC_TransFactorToFrameNum(pInstance, eWindow, u16FrameCount);
5234 #else
5235 return Hal_SC_GetFrameStoreMode(pInstance, eWindow);
5236 #endif
5237 }
5238 #if (HW_DESIGN_4K2K_VER == 4)
MDrv_XC_TransFactorToFRCMFrameNum(void * pInstance,SCALER_WIN eWindow,MS_U8 u8FrameNumFactor)5239 XC_FRAME_STORE_NUMBER MDrv_XC_TransFactorToFRCMFrameNum(void *pInstance, SCALER_WIN eWindow, MS_U8 u8FrameNumFactor)
5240 {
5241 #if _FIELD_PACKING_MODE_SUPPORTED
5242 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5243 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5244 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5245 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5246 switch(u8FrameNumFactor) // Get field type.
5247 {
5248 default:
5249 return IMAGE_STORE_2_FRAMES;
5250 case 3:
5251 return IMAGE_STORE_3_FRAMES;
5252 case 4:
5253 return IMAGE_STORE_4_FRAMES;
5254 case 6:
5255 return IMAGE_STORE_6_FRAMES;
5256 case 8:
5257 return IMAGE_STORE_8_FRAMES;
5258 case 10:
5259 return IMAGE_STORE_10_FRAMES;
5260 case 12:
5261 return IMAGE_STORE_12_FRAMES;
5262 }
5263 #else
5264 return IMAGE_STORE_UNDEFINE;
5265 #endif
5266 }
5267
MDrv_XC_GetPQSuggestedFRCMFrameNum(void * pInstance,SCALER_WIN eWindow)5268 XC_FRAME_STORE_NUMBER MDrv_XC_GetPQSuggestedFRCMFrameNum(void *pInstance, SCALER_WIN eWindow)
5269 {
5270 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5271 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5272 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5273 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5274 MS_U16 u16FrameCount = 0x00;
5275
5276 #ifdef ENABLE_TV_SC2_PQ
5277 if ( (psXCInstPri->u32DeviceID == PQ_XC_ID_0)
5278 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
5279 ||(psXCInstPri->u32DeviceID == PQ_XC_ID_1)
5280 #endif
5281 )
5282 #endif
5283 {
5284 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl)
5285 {
5286 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
5287 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl((psXCInstPri->u32DeviceID == 1)?PQ_SUB_WINDOW:PQ_MAIN_WINDOW, E_PQ_IOCTL_PQ_SUGGESTED_FRCMFRAMENUM, (void *)&u16FrameCount, sizeof(u16FrameCount)) == FALSE)
5288 #else
5289 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl((PQ_WIN)eWindow, E_PQ_IOCTL_PQ_SUGGESTED_FRCMFRAMENUM, (void *)&u16FrameCount, sizeof(u16FrameCount)) == FALSE)
5290 #endif
5291 {
5292 if ( (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_SAVE_MEM_MODE)
5293 &&( IsSrcTypeStorage(gSrcInfo[eWindow].enInputSourceType)
5294 ||IsSrcTypeDTV(gSrcInfo[eWindow].enInputSourceType)))
5295 {
5296 if (gSrcInfo[eWindow].stCapWin.width>=XC_4K2K_WIDTH_MIN)
5297 {
5298 u16FrameCount = 2;
5299 }
5300 else if ((gSrcInfo[eWindow].stCapWin.width > 1900) && (gSrcInfo[eWindow].stCapWin.height > 2100) && (gSrcInfo[eWindow].stCapWin.height < 2200))
5301 {
5302 u16FrameCount = 4;
5303 }
5304 else if((gSrcInfo[eWindow].bInterlace && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow) )))
5305 {
5306 u16FrameCount = 4;
5307 }
5308 else
5309 {
5310 u16FrameCount = 3;
5311 }
5312 }
5313 else
5314 {
5315 u16FrameCount = 4;
5316 }
5317 #if 0
5318 u16FrameCount = _MDrv_XC_Get_FRCMFrameNumFromReg(pInstance, eWindow);
5319
5320 if(u16FrameCount == 0)
5321 {
5322 u16FrameCount = 2;
5323 }
5324 #endif
5325 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Alert: cannot get frameCount from IOCTL, eWindow=%u! Fall back to original method\n", eWindow);
5326 }
5327 }
5328 else
5329 {
5330 u16FrameCount = _MDrv_XC_Get_FRCMFrameNumFromReg(pInstance, eWindow);
5331
5332 if(u16FrameCount == 0)
5333 {
5334 u16FrameCount = 4;
5335 }
5336 printf("Alert: cannot get frameCount from IOCTL, eWindow=%u! Fall back to original frame mode\n", eWindow);
5337 }
5338 }
5339 #ifdef ENABLE_TV_SC2_PQ
5340 else if (psXCInstPri->u32DeviceID == PQ_XC_ID_1)
5341 {
5342 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl_ex)
5343 {
5344 if(s_PQ_Function_Info[psXCInstPri->u32DeviceID].pq_ioctl_ex(psXCInstPri->u32DeviceID, (PQ_WIN)eWindow, E_PQ_IOCTL_PQ_SUGGESTED_FRCMFRAMENUM, (void *)&u16FrameCount, sizeof(u16FrameCount)) == FALSE)
5345 {
5346 // temp patch wait PQ ready
5347 u16FrameCount = 4;
5348 #if 0
5349 u16FrameCount = _MDrv_XC_Get_FRCMFrameNumFromReg(pInstance, eWindow);
5350
5351 if(u16FrameCount == 0)
5352 {
5353 u16FrameCount = 2;
5354 }
5355 #endif
5356 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Alert: cannot get frameCount from IOCTL, eWindow=%u! Fall back to original method\n", eWindow);
5357 }
5358 }
5359 else
5360 {
5361 u16FrameCount = _MDrv_XC_Get_FRCMFrameNumFromReg(pInstance, eWindow);
5362
5363 if(u16FrameCount == 0)
5364 {
5365 u16FrameCount = 4;
5366 }
5367 printf("Alert: cannot get frameCount from IOCTL, eWindow=%u! Fall back to original frame mode\n", eWindow);
5368 }
5369 }
5370 #endif
5371 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "MDrv_XC_GetPQSuggestedFrameNum(%u) get %u frame count\n", eWindow, u16FrameCount);
5372
5373 return MDrv_XC_TransFactorToFRCMFrameNum(pInstance, eWindow, u16FrameCount);
5374 }
5375 #endif
5376
_MDrv_XC_Set_FrameNum(void * pInstance,SCALER_WIN eWindow,MS_BOOL bIsFRCMBuff,XC_FRAME_STORE_NUMBER enFBType,MS_BOOL bInterlace)5377 static void _MDrv_XC_Set_FrameNum(void *pInstance, SCALER_WIN eWindow, MS_BOOL bIsFRCMBuff, XC_FRAME_STORE_NUMBER enFBType, MS_BOOL bInterlace)
5378 {
5379 #if _FIELD_PACKING_MODE_SUPPORTED
5380 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5381 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5382 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5383 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5384 MS_U8 u8FrameCount = 2;
5385 MS_U32 u32Reg = 0;
5386 u8FrameCount = MDrv_XC_TransFrameNumToFactor(pInstance, enFBType, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
5387 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "bIsFRCMBuff(%u) enFBType = %u \n", bIsFRCMBuff, enFBType);
5388 // If memory format is PX2 progressive mode, frame count need to set doubled
5389 #if SUPPORT_SEAMLESS_ZAPPING
5390 if(Hal_SC_IsPX2MemFormat(pInstance, eWindow)) // SC0
5391 {
5392 u8FrameCount *= 2;
5393 }
5394 #endif
5395 if (bIsFRCMBuff)
5396 {
5397 if( eWindow == MAIN_WINDOW )
5398 {
5399 u32Reg = REG_SC_BK32_19_L;
5400 }
5401 else
5402 {
5403 u32Reg = REG_SC_BK32_59_L;
5404 }
5405 }
5406 else
5407 {
5408 if( eWindow == MAIN_WINDOW )
5409 {
5410 u32Reg = REG_SC_BK12_19_L;
5411 }
5412 else
5413 {
5414 u32Reg = REG_SC_BK12_59_L;
5415 }
5416 }
5417
5418 #ifdef K3_U2
5419 if (MDrv_XC_MLoad_GetStatus(pInstance) == E_MLOAD_ENABLED)
5420 {
5421 _MLOAD_ENTRY(pInstance);
5422 MDrv_XC_MLoad_WriteCmd(pInstance, u32Reg, u8FrameCount , BITMASK(4:0) );
5423 MDrv_XC_MLoad_Fire(pInstance, TRUE);
5424 _MLOAD_RETURN(pInstance);
5425 }
5426 else
5427 #endif
5428 {
5429 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32Reg, u8FrameCount , BITMASK(4:0) );
5430 }
5431 #else
5432 HAL_SC_Set_FB_Num(pInstance, eWindow, enFBType, bInterlace);
5433 #endif
5434 }
5435
MDrv_XC_TransFactorToFrameNum(void * pInstance,SCALER_WIN eWindow,MS_U8 u8FrameNumFactor)5436 XC_FRAME_STORE_NUMBER MDrv_XC_TransFactorToFrameNum(void *pInstance, SCALER_WIN eWindow, MS_U8 u8FrameNumFactor)
5437 {
5438 #if _FIELD_PACKING_MODE_SUPPORTED
5439 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5440 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5441 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5442 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5443 switch( u8FrameNumFactor) // Get field type.
5444 {
5445 default:
5446 if (gSrcInfo[eWindow].bInterlace)
5447 {
5448 return IMAGE_STORE_4_FIELDS;
5449 }
5450 else
5451 {
5452 return IMAGE_STORE_2_FRAMES;
5453 }
5454 case 3:
5455 return IMAGE_STORE_3_FRAMES;
5456 case 4:
5457 if (gSrcInfo[eWindow].bInterlace)
5458 {
5459 return IMAGE_STORE_4_FIELDS;
5460 }
5461 else
5462 {
5463 return IMAGE_STORE_4_FRAMES;
5464 }
5465 case 5:
5466 return IMAGE_STORE_5_FRAMES;
5467 case 6:
5468 if (gSrcInfo[eWindow].bInterlace)
5469 {
5470 return IMAGE_STORE_6_FIELDS;
5471 }
5472 else
5473 {
5474 return IMAGE_STORE_6_FRAMES;
5475 }
5476 case 8:
5477 if (gSrcInfo[eWindow].bInterlace)
5478 {
5479 return IMAGE_STORE_8_FIELDS;
5480 }
5481 else
5482 {
5483 return IMAGE_STORE_8_FRAMES;
5484 }
5485 case 10:
5486 if (gSrcInfo[eWindow].bInterlace)
5487 {
5488 return IMAGE_STORE_10_FIELDS;
5489 }
5490 else
5491 {
5492 return IMAGE_STORE_10_FRAMES;
5493 }
5494 case 12:
5495 if (gSrcInfo[eWindow].bInterlace)
5496 {
5497 return IMAGE_STORE_12_FIELDS;
5498 }
5499 else
5500 {
5501 return IMAGE_STORE_12_FRAMES;
5502 }
5503 case 14:
5504 return IMAGE_STORE_14_FIELDS;
5505 case 16:
5506 return IMAGE_STORE_16_FIELDS;
5507
5508 }
5509 #else
5510 return IMAGE_STORE_UNDEFINE;
5511 #endif
5512 }
5513
MDrv_XC_TransFrameNumToFactor(void * pInstance,XC_FRAME_STORE_NUMBER eFrameStoreNumber,MS_BOOL bLinearMode,MS_BOOL bFieldPackingMode)5514 MS_U8 MDrv_XC_TransFrameNumToFactor(void *pInstance, XC_FRAME_STORE_NUMBER eFrameStoreNumber, MS_BOOL bLinearMode, MS_BOOL bFieldPackingMode)
5515 {
5516 MS_U8 u8Factor = 0;
5517
5518 switch(eFrameStoreNumber)
5519 {
5520 #if ENABLE_16_FIELD_SUPPORTED
5521 case IMAGE_STORE_6_FIELDS:
5522
5523 if(bFieldPackingMode)
5524 {
5525 u8Factor = 6;
5526 }
5527 else
5528 {
5529 u8Factor = 3;
5530 }
5531 break;
5532
5533 case IMAGE_STORE_8_FIELDS:
5534
5535 if(bFieldPackingMode)
5536 {
5537 u8Factor = 8;
5538 }
5539 else
5540 {
5541 u8Factor = 4;
5542 }
5543
5544 break;
5545
5546 case IMAGE_STORE_10_FIELDS:
5547
5548 if(bFieldPackingMode)
5549 {
5550 u8Factor = 10;
5551 }
5552 else
5553 {
5554 u8Factor = 5;
5555 }
5556
5557 break;
5558
5559 case IMAGE_STORE_12_FIELDS:
5560
5561 if(bFieldPackingMode)
5562 {
5563 u8Factor = 12;
5564 }
5565 else
5566 {
5567 u8Factor = 6;
5568 }
5569
5570 break;
5571 case IMAGE_STORE_14_FIELDS:
5572
5573 if(bFieldPackingMode)
5574 {
5575 u8Factor = 14;
5576 }
5577 else
5578 {
5579 u8Factor = 7;
5580 }
5581
5582 break;
5583 case IMAGE_STORE_16_FIELDS:
5584
5585 if(bFieldPackingMode)
5586 {
5587 u8Factor = 16;
5588 }
5589 else
5590 {
5591 u8Factor = 8;
5592 }
5593
5594 break;
5595 #endif
5596
5597 case IMAGE_STORE_3_FRAMES:
5598
5599 if (bLinearMode)
5600 {
5601 u8Factor = 1;
5602 }
5603 else
5604 {
5605 // Put all field together.
5606 if(bFieldPackingMode)
5607 {
5608 u8Factor = 3;
5609 }
5610 else
5611 {
5612 u8Factor = 2;
5613 }
5614 }
5615
5616 break;
5617
5618 case IMAGE_STORE_4_FRAMES:
5619
5620 if (bLinearMode)
5621 {
5622 u8Factor = 1;
5623 }
5624 else
5625 {
5626 // Put all field together.
5627 if(bFieldPackingMode)
5628 {
5629 u8Factor = 4;
5630 }
5631 else
5632 {
5633 if(MDrv_SC_GetScmiV1Speical4frame(pInstance, IMAGE_STORE_4_FRAMES))
5634 {
5635 u8Factor = 4;
5636 }
5637 else
5638 {
5639 u8Factor = 2;
5640 }
5641 }
5642 }
5643
5644 break;
5645 case IMAGE_STORE_5_FRAMES:
5646
5647 if (bLinearMode)
5648 {
5649 u8Factor = 1;
5650 }
5651 else
5652 {
5653 // Put all field together.
5654 if(bFieldPackingMode)
5655 {
5656 u8Factor = 5;
5657 }
5658 else
5659 {
5660 u8Factor = 2;
5661 }
5662 }
5663
5664 break;
5665 case IMAGE_STORE_6_FRAMES:
5666
5667 if (bLinearMode)
5668 {
5669 u8Factor = 1;
5670 }
5671 else
5672 {
5673 // Put all field together.
5674 if(bFieldPackingMode)
5675 {
5676 u8Factor = 6;
5677 }
5678 else
5679 {
5680 u8Factor = 2;
5681 }
5682 }
5683
5684 break;
5685 case IMAGE_STORE_7_FRAMES:
5686
5687 if (bLinearMode)
5688 {
5689 u8Factor = 1;
5690 }
5691 else
5692 {
5693 // Put all field together.
5694 if(bFieldPackingMode)
5695 {
5696 u8Factor = 7;
5697 }
5698 else
5699 {
5700 u8Factor = 2;
5701 }
5702 }
5703
5704 break;
5705
5706 case IMAGE_STORE_8_FRAMES:
5707
5708 if (bLinearMode)
5709 {
5710 u8Factor = 1;
5711 }
5712 else
5713 {
5714 if(bFieldPackingMode)
5715 {
5716 u8Factor = 8;
5717 }
5718 else
5719 {
5720 u8Factor = 4;
5721 }
5722 }
5723 break;
5724
5725 case IMAGE_STORE_9_FRAMES:
5726
5727 if (bLinearMode)
5728 {
5729 u8Factor = 1;
5730 }
5731 else
5732 {
5733 // Put all field together.
5734 if(bFieldPackingMode)
5735 {
5736 u8Factor = 9;
5737 }
5738 else
5739 {
5740 u8Factor = 4;
5741 }
5742 }
5743
5744 break;
5745
5746 case IMAGE_STORE_10_FRAMES:
5747
5748 if (bLinearMode)
5749 {
5750 u8Factor = 1;
5751 }
5752 else
5753 {
5754 // Put all field together.
5755 if(bFieldPackingMode)
5756 {
5757 u8Factor = 10;
5758 }
5759 else
5760 {
5761 u8Factor = 2;
5762 }
5763 }
5764
5765 break;
5766
5767 case IMAGE_STORE_11_FRAMES:
5768
5769 if (bLinearMode)
5770 {
5771 u8Factor = 1;
5772 }
5773 else
5774 {
5775 // Put all field together.
5776 if(bFieldPackingMode)
5777 {
5778 u8Factor = 11;
5779 }
5780 else
5781 {
5782 u8Factor = 2;
5783 }
5784 }
5785
5786 break;
5787
5788 case IMAGE_STORE_12_FRAMES:
5789
5790 if (bLinearMode)
5791 {
5792 u8Factor = 1;
5793 }
5794 else
5795 {
5796 // Put all field together.
5797 if(bFieldPackingMode)
5798 {
5799 u8Factor = 12;
5800 }
5801 else
5802 {
5803 u8Factor = 2;
5804 }
5805 }
5806
5807 break;
5808
5809 case IMAGE_STORE_13_FRAMES:
5810
5811 if (bLinearMode)
5812 {
5813 u8Factor = 1;
5814 }
5815 else
5816 {
5817 // Put all field together.
5818 if(bFieldPackingMode)
5819 {
5820 u8Factor = 13;
5821 }
5822 else
5823 {
5824 u8Factor = 2;
5825 }
5826 }
5827
5828 break;
5829
5830 case IMAGE_STORE_4_FIELDS:
5831 if (bLinearMode)
5832 {
5833 u8Factor = 1;
5834 }
5835 else
5836 {
5837 // Put all field together.
5838 if(bFieldPackingMode)
5839 {
5840 u8Factor = 4;
5841 }
5842 else
5843 {
5844 u8Factor = 2;
5845 }
5846 }
5847 break;
5848
5849 case IMAGE_STORE_2_FIELDS:
5850 if (bLinearMode)
5851 {
5852 u8Factor = 1;
5853 }
5854 else
5855 {
5856 // Put all field together.
5857 if(bFieldPackingMode)
5858 {
5859 u8Factor = 2;
5860 }
5861 else
5862 {
5863 u8Factor = 1;
5864 }
5865 }
5866 break;
5867
5868 case IMAGE_STORE_2_FRAMES:
5869 default:
5870 if (bLinearMode)
5871 {
5872 u8Factor = 1;
5873 }
5874 else
5875 {
5876 // 2 frame mode is same for packet or non packet mode
5877 u8Factor = 2;
5878 }
5879 break;
5880 }
5881
5882 return u8Factor;
5883 }
5884
MDrv_SC_set_ipmsetting(void * pInstance,XC_InternalStatus * pSrcInfo,SCALER_WIN eWindow)5885 void MDrv_SC_set_ipmsetting(void *pInstance, XC_InternalStatus *pSrcInfo, SCALER_WIN eWindow)
5886 {
5887 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5888 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5889 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5890 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5891
5892 gSrcInfo[eWindow].u16IPMFetch = pSrcInfo->u16H_SizeAfterPreScaling;
5893 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"===================================================\n");
5894 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=> u16DNRFetch=%d \n",gSrcInfo[eWindow].u16IPMFetch);
5895 //#if (HW_IPM_FETCH_ALIGNMENT==FALSE)
5896 if (pSrcInfo->bMemFmt422)
5897 gSrcInfo[eWindow].u16IPMFetch = (gSrcInfo[eWindow].u16IPMFetch + (OFFSET_PIXEL_ALIGNMENT - 1)) & ~(OFFSET_PIXEL_ALIGNMENT - 1);
5898 //#endif
5899 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC," %d \n",gSrcInfo[eWindow].u16IPMFetch);
5900
5901 if(eWindow == MAIN_WINDOW)
5902 {
5903 if (gSrcInfo[MAIN_WINDOW].u16IPMFetch > MST_LINE_BFF_MAX)
5904 {
5905 gSrcInfo[MAIN_WINDOW].u16IPMFetch = MST_LINE_BFF_MAX;
5906 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Re-assign IPM fetch as %lu due to HW limitation \n", MST_LINE_BFF_MAX);
5907 }
5908 }
5909 else
5910 {
5911 #if (HW_DESIGN_3D_VER < 2)
5912 #ifndef DISABLE_3D_FUNCTION
5913 if(MDrv_SC_3D_IsIPMFetchNoLimitCase(pInstance, eWindow))
5914 {
5915 //no any limits
5916 }
5917 else if((E_XC_3D_OUTPUT_TOP_BOTTOM == MDrv_XC_Get_3D_Output_Mode(pInstance))
5918 || (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF == MDrv_XC_Get_3D_Output_Mode(pInstance))
5919 || (E_XC_3D_OUTPUT_TOP_BOTTOM_HW == MDrv_XC_Get_3D_Output_Mode(pInstance))
5920 || (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF_HW == MDrv_XC_Get_3D_Output_Mode(pInstance))
5921 )
5922 {
5923 if(gSrcInfo[SUB_WINDOW].u16IPMFetch > MS_3D_LINE_BFF_MAX)
5924 {
5925 gSrcInfo[SUB_WINDOW].u16IPMFetch = MS_3D_LINE_BFF_MAX;
5926 }
5927 }
5928 else
5929 #endif
5930 if (gSrcInfo[SUB_WINDOW].u16IPMFetch > SUB_MST_LINE_BFF_MAX)
5931 #else
5932 #ifndef DISABLE_3D_FUNCTION
5933
5934 if((E_XC_3D_PANEL_NONE == MDrv_XC_Get_3D_Panel_Type(pInstance))
5935 &&(gSrcInfo[SUB_WINDOW].u16IPMFetch > SUB_MST_LINE_BFF_MAX))
5936 #endif
5937 {
5938
5939 #if (PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB == 0)
5940 //Normal PIP case
5941 gSrcInfo[SUB_WINDOW].u16IPMFetch = SUB_MST_LINE_BFF_MAX;
5942 #endif
5943 }
5944 #endif
5945 }
5946 }
5947
MDrv_SC_set_dnrsetting(void * pInstance,XC_InternalStatus * pSrcInfo,MS_BOOL bIsConnectOPM,MS_PHY * pu32OneLineOffset,MS_BOOL bDoMirror,SCALER_WIN eWindow)5948 void MDrv_SC_set_dnrsetting(void *pInstance, XC_InternalStatus *pSrcInfo, MS_BOOL bIsConnectOPM, MS_PHY* pu32OneLineOffset, MS_BOOL bDoMirror, SCALER_WIN eWindow)
5949 {
5950 MS_U16 u16V_Writelimit;
5951 MS_PHY u32Offset, u32DNRBase0, u32DNRBase1, u32DNRBase2, u32WritelimitBase=0;
5952 MS_PHY u32OPMBase0, u32OPMBase1, u32OPMBase2;
5953 MS_BOOL bInterlace = pSrcInfo->bInterlace;
5954 MS_U16 u16AlignWidth = 0;
5955 MS_PHY u32BaseOffset = 0, u32Framesize;
5956 MS_PHY u32BaseAddr, u32BuffSize;
5957 MS_PHY u32OneLineOffset = 0;
5958 MS_U8 u8BytesPer2Pixel = pSrcInfo->u8BitPerPixel * 2 / 8;
5959 MS_U16 u16DNROffset = 0;
5960 MS_U8 u8FrameNum = 0;
5961 MS_U16 u16H_SizeAfterPreScaling = pSrcInfo->u16H_SizeAfterPreScaling;
5962 MS_U16 u16DNROffsetFor3D = 0;
5963 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5964 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5965 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5966 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5967 if (bIsConnectOPM)
5968 {
5969 u32BaseAddr = MS_IPM_BASE0(eWindow);
5970 u32BuffSize = pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow];
5971 }
5972 else
5973 {
5974 u32BaseAddr = MS_FRCM_BASE0(eWindow);
5975 u32BuffSize = pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow];
5976 }
5977
5978 if(pSrcInfo->bDisplayNineLattice)
5979 {
5980 u16DNROffset = (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width + OFFSET_PIXEL_ALIGNMENT - 1) & ~(OFFSET_PIXEL_ALIGNMENT-1); //TODO: T3 should be 32 alignment
5981 }
5982 else
5983 {
5984 if(MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow))
5985 {
5986 u16DNROffset = (gSrcInfo[eWindow].Status2.u16VirtualBox_Width + OFFSET_PIXEL_ALIGNMENT - 1) & ~(OFFSET_PIXEL_ALIGNMENT-1);
5987 }
5988 else
5989 {
5990 u16DNROffset = (gSrcInfo[eWindow].u16IPMFetch + OFFSET_PIXEL_ALIGNMENT - 1) & ~(OFFSET_PIXEL_ALIGNMENT-1); //TODO: T3 should be 32 alignment
5991 }
5992 }
5993
5994 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u16DNROffset=%u\n",u16DNROffset);
5995 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC," %d\n",(int)gSrcInfo[eWindow].u16IPMFetch);
5996 if (bDoMirror)
5997 {
5998 #if (HW_IPM_FETCH_ALIGNMENT==FALSE)
5999 Mdrv_SC_set_frcm_pre_align_pixel(pInstance, FALSE, 0, eWindow);
6000 if (IsHMirrorMode(eWindow))
6001 {
6002 u16AlignWidth = u16DNROffset - gSrcInfo[eWindow].u16IPMFetch;
6003 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"align width = %d\n", u16AlignWidth);
6004
6005 // the hardware alignment in OPM > IPM case, it will get more data for alignment
6006 // disable it in the nine lattice mode
6007 if(pSrcInfo->bDisplayNineLattice)
6008 {
6009 Hal_SC_set_pre_align_pixel(pInstance, FALSE, u16AlignWidth, eWindow);//M10/J2: insert alignment pixel at end
6010 }
6011 else
6012 {
6013 //these chips: they need sw to decide prealign or not.
6014 //here set to TRUE, then hw will prealign u16AlignWidth
6015 //if here is FALSE, hw won't do prealign
6016
6017 //to fix H/W bugs, OPM need to be aligned.
6018 //so do not use pre-align. use OPM line buffer offset instead.
6019 Hal_SC_set_pre_align_pixel(pInstance, FALSE, 0, eWindow);
6020 }
6021 }
6022 #else
6023 if (IsHMirrorMode(eWindow))
6024 {
6025 //M10, J2, A2 and later chip, HW will auto insert pixel to alignment u16IPMFetch
6026 //below u16AlignWidth is used for CBCR swap control
6027 #ifdef K3_U2
6028 if (pSrcInfo->bMemFmt422)
6029 u16AlignWidth = u16DNROffset - pSrcInfo->u16H_SizeAfterPreScaling;
6030 else
6031 u16AlignWidth = u16DNROffset - gSrcInfo[eWindow].u16IPMFetch;;
6032 #endif
6033 // the hardware alignment in OPM > IPM case, it will get more data for alignment
6034 // disable it in the nine lattice mode
6035 if(pSrcInfo->bDisplayNineLattice)
6036 {
6037 Hal_SC_set_pre_align_pixel(pInstance, FALSE, u16AlignWidth, eWindow);//M10/J2: insert alignment pixel at end
6038 }
6039 else
6040 {
6041 //these chips: when sw set it to TRUE, then hw will do the prealign.
6042 //because hw can calculate by itself, even for the alignwidth==0 case,
6043 //so sw don't need to worry about it, just set it to TRUE.
6044 Hal_SC_set_pre_align_pixel(pInstance, TRUE, u16AlignWidth, eWindow);//M10/J2: insert alignment pixel at start
6045 }
6046 }
6047 #endif
6048 else
6049 {
6050 u16AlignWidth = 0;
6051 Hal_SC_set_pre_align_pixel(pInstance, FALSE, u16AlignWidth, eWindow);//M10/J2: insert alignment pixel at end
6052 }
6053 }
6054 else
6055 {
6056 u16AlignWidth = 0;
6057 Hal_SC_set_pre_align_pixel(pInstance, FALSE, u16AlignWidth, eWindow);//M10/J2: insert alignment pixel at end
6058 u16AlignWidth = u16DNROffset - gSrcInfo[eWindow].u16IPMFetch;
6059 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"align width in frcm = %d\n", u16AlignWidth);
6060 if (IsHMirrorMode(eWindow))
6061 {
6062 Mdrv_SC_set_frcm_pre_align_pixel(pInstance, TRUE, u16AlignWidth, eWindow);
6063 }
6064 else
6065 {
6066 Mdrv_SC_set_frcm_pre_align_pixel(pInstance, FALSE, 0, eWindow);
6067 }
6068 }
6069
6070 #ifndef DISABLE_3D_FUNCTION
6071 if((E_XC_3D_INPUT_SIDE_BY_SIDE_FULL == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
6072 || (E_XC_3D_INPUT_SIDE_BY_SIDE_HALF == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
6073 || (E_XC_3D_INPUT_CHECK_BORAD == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
6074 || (E_XC_3D_INPUT_SIDE_BY_SIDE_HALF_INTERLACE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
6075 || (E_XC_3D_INPUT_SIDE_BY_SIDE_HALF_INTERLACE_OPT == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
6076 || (E_XC_3D_INPUT_PIXEL_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow)))
6077 {
6078 u16AlignWidth /= 2; //opm fetch actual align size
6079 u16H_SizeAfterPreScaling /= 2; //actual prescaling hsize
6080 }
6081 #endif
6082
6083 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"align width = %d\n", u16AlignWidth);
6084 // alignwidth must be even, other color will be wrong and need to
6085 // use cb cr swap to correct it.
6086 if((u16AlignWidth & 0x01) && (HAL_SC_get_memory_bit_fmt(pInstance, eWindow) == 0))
6087 {
6088 Hal_SC_set_422_cbcr_swap(pInstance, ENABLE, eWindow);
6089 }
6090 else
6091 {
6092 Hal_SC_set_422_cbcr_swap(pInstance, DISABLE, eWindow);
6093 }
6094
6095 if(pSrcInfo->bDisplayNineLattice)
6096 {
6097 pSrcInfo->u16V_Length = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height;
6098 }
6099
6100 u16DNROffsetFor3D = u16DNROffset;
6101 #ifndef DISABLE_3D_FUNCTION
6102 MDrv_SC_3D_Adjust_DNROffset(pInstance, &u16DNROffsetFor3D,&u16DNROffset, eWindow);
6103 #endif
6104
6105 if(MDrv_XC_Is_SupportSWDS(pInstance) && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)))
6106 {
6107 u32Framesize = gSrcInfo[eWindow].Status2.u16VirtualBox_Height * (MS_U32)u16DNROffset * (MS_U32)u8BytesPer2Pixel/2;
6108 }
6109 else
6110 {
6111 u32Framesize = (MS_U32)pSrcInfo->u16V_SizeAfterPreScaling * (MS_U32)u16DNROffset * (MS_U32)u8BytesPer2Pixel/2;
6112 }
6113
6114 #ifndef DISABLE_3D_FUNCTION
6115 #if (HW_DESIGN_3D_VER >= 2)
6116 if((E_XC_3D_INPUT_FRAME_PACKING == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
6117 && ((pSrcInfo->stCapWin.height == DOUBLEHD_1080X2I_VSIZE)
6118 #if ((HW_DESIGN_3D_VER == 3) && (HW_DESIGN_4K2K_VER == 7))
6119 || (pSrcInfo->stCapWin.height == DOUBLEHD_576X2I_VSIZE)
6120 || (pSrcInfo->stCapWin.height == DOUBLEHD_480X2I_VSIZE)
6121 #endif
6122 ))
6123 {
6124 //special case, hw will use field size 540 as deinterlace size
6125 u32Framesize /= 2;
6126 }
6127 #if (HW_DESIGN_3D_VER > 2)
6128 else if(E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
6129 {//per designer, input 3d:framealternative will double data at dnr
6130 u32Framesize *= 2;
6131 }
6132 #endif
6133 #endif
6134 #endif
6135
6136 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>Framesize(%d)= VSizeAfterPreSD(%d) * DNROffset(%d) * BytesPer2Pixel(%d)/2\n",(int)u32Framesize,pSrcInfo->u16V_SizeAfterPreScaling,u16DNROffset,u8BytesPer2Pixel);
6137
6138 #ifdef UFO_XC_FB_LEVEL
6139 if((pSrcInfo->eFBLevel == E_XC_FB_LEVEL_FB) && (u32Framesize * 2 > u32BuffSize))
6140 #else
6141 if((!pSrcInfo->bFBL)
6142 && (!pSrcInfo->bR_FBL)
6143 && (u32Framesize * 2 > u32BuffSize))
6144 #endif
6145 {
6146 //this case should always not be happened
6147 printf("Attention! Scaler DNR Buffer is not enough for this timing, eWindow=%u!\n", eWindow);
6148 }
6149
6150 // enable 4 frame mode if input is progressive & frame buffer is enough
6151 // , regardless the input source and timing because 4 frame mode is better in avoid tearing
6152 //
6153 if(pSrcInfo->bDisplayNineLattice)
6154 {
6155 #if (_LINEAR_ADDRESS_MODE_SUPPORTED)
6156 gSrcInfo[eWindow].bLinearMode = TRUE;
6157 Hal_SC_set_linearmem_mode(ENABLE,MAIN_WINDOW);
6158 #endif
6159 }
6160 else
6161 {
6162 XC_FRAME_STORE_NUMBER enLastFBNum = gSrcInfo[eWindow].Status2.eFrameStoreNumber;
6163
6164 /*Update Frame buffer usage status and memory linear mode*/
6165 // MDrv_XC_GetPQSuggestedFrameNum(eWindow) is the frame count that PQ want to set
6166 // gSrcInfo[eWindow].Status2.eFrameStoreNumber is the frame count that sw code(_Mdrv_SC_CalcFBNum)
6167 // decides according to frame size and other condition
6168 if (bIsConnectOPM)
6169 {
6170 _Mdrv_XC_Refine_FrameNum(pInstance, &gSrcInfo[eWindow].bLinearMode,
6171 &gSrcInfo[eWindow].Status2.eFrameStoreNumber,
6172 bInterlace,
6173 u32Framesize,
6174 u32BuffSize,
6175 eWindow);
6176 _MDrv_XC_Set_FrameNum(pInstance, eWindow, FALSE, gSrcInfo[eWindow].Status2.eFrameStoreNumber,bInterlace);
6177 }
6178 #if (HW_DESIGN_4K2K_VER == 4)
6179 else
6180 {
6181 _Mdrv_XC_Refine_FRCMFrameNum(pInstance, &gSrcInfo[eWindow].bLinearMode,
6182 &gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber,
6183 u32Framesize,
6184 u32BuffSize,
6185 eWindow);
6186 gSrcInfo[eWindow].Status2.eFrameStoreNumber = gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber;
6187 _MDrv_XC_Set_FrameNum(pInstance, eWindow, FALSE, gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber,bInterlace);
6188 _MDrv_XC_Set_FrameNum(pInstance, eWindow, TRUE, gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber,bInterlace);
6189 }
6190 #endif
6191
6192 if (!IsVMirrorMode(eWindow))
6193 {
6194 if (gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_2_FRAMES)
6195 {
6196 // 3/4 value is suggested by designer, it is a experimental value.
6197 MS_U16 u16SwitchCnt = gSrcInfo[eWindow].stCapWin.height * 3 / 4;
6198 MDrv_SC_EnableReadBankSwitchControl(pInstance, ENABLE, u16SwitchCnt, eWindow);
6199 }
6200 else
6201 {
6202 MDrv_SC_EnableReadBankSwitchControl(pInstance, DISABLE, 0, eWindow);
6203 }
6204 }
6205 else
6206 {
6207 if (bDoMirror)
6208 {
6209 MDrv_SC_EnableReadBankSwitchControl(pInstance, DISABLE, 0, eWindow);
6210 }
6211 }
6212
6213 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"gSrcInfo[eWindow].bLinearMode %d \n",gSrcInfo[eWindow].bLinearMode);
6214 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"FrameMode %d \n",gSrcInfo[eWindow].Status2.eFrameStoreNumber);
6215
6216 // Set memory frame buffer setting.
6217 if (bIsConnectOPM)
6218 {
6219 #if (HW_DESIGN_4K2K_VER == 4)
6220 if (psXCInstPri->u32DeviceID == 0)
6221 {
6222 if (eWindow == MAIN_WINDOW)
6223 {
6224 if(MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow) )
6225 {
6226 MDrv_SC_SwitchIPMWriteBank(pInstance, FALSE, E_XC_IPM_CONNETC_MAIN_OPM);
6227 }
6228 else
6229 {
6230 MDrv_SC_SwitchIPMWriteBank(pInstance, TRUE, E_XC_IPM_CONNETC_MAIN_OPM);
6231 }
6232 }
6233 else
6234 {
6235 MDrv_SC_SwitchIPMWriteBank(pInstance, TRUE, E_XC_IPM_CONNETC_SUB_OPM);
6236 }
6237 }
6238 #endif
6239 }
6240 else
6241 {
6242 #if (HW_DESIGN_4K2K_VER == 4)
6243 if (psXCInstPri->u32DeviceID == 0)
6244 {
6245 if (eWindow == MAIN_WINDOW)
6246 {
6247 if(MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow) )
6248 {
6249 MDrv_SC_SwitchIPMWriteBank(pInstance, FALSE, E_XC_IPM_CONNETC_MAIN_FRCM);
6250 }
6251 else
6252 {
6253 MDrv_SC_SwitchIPMWriteBank(pInstance, TRUE, E_XC_IPM_CONNETC_MAIN_FRCM);
6254 }
6255 }
6256 else
6257 {
6258 MDrv_SC_SwitchIPMWriteBank(pInstance, TRUE, E_XC_IPM_CONNETC_SUB_FRCM);
6259 }
6260 }
6261 #endif
6262 }
6263
6264 // to avoid mm play photo garbage, because of big changing FB number
6265 if((enLastFBNum != gSrcInfo[eWindow].Status2.eFrameStoreNumber) && (TRUE == MDrv_XC_Get_SCMI_Type()))
6266 {
6267 MDrv_XC_WBankReset(pInstance, FALSE, eWindow);
6268 }
6269
6270 #if (_LINEAR_ADDRESS_MODE_SUPPORTED)
6271 // Set linear mode
6272 if (gSrcInfo[eWindow].bLinearMode)
6273 {
6274 Hal_SC_set_linearmem_mode(ENABLE,eWindow);
6275 }
6276 else
6277 {
6278 Hal_SC_set_linearmem_mode(DISABLE,eWindow);
6279 }
6280 #endif
6281 // if support _FIELD_PACKING_MODE_SUPPORTED, it will control by QMAP(J2/A5/A6/A3)
6282 #if(!_FIELD_PACKING_MODE_SUPPORTED)
6283 // avoid tearing problem when we can not do frame lock
6284 if(pSrcInfo->bRWBankAuto)
6285 {
6286 #if (HW_DESIGN_3D_VER == 1)
6287 //this 3d method need special wr bank mapping
6288 if(((E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
6289 && (E_XC_3D_OUTPUT_TOP_BOTTOM == MDrv_XC_Get_3D_Output_Mode(pInstance)))
6290 || ((E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
6291 && (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF == MDrv_XC_Get_3D_Output_Mode(pInstance)))
6292 )
6293 {
6294 if(eWindow == MAIN_WINDOW)
6295 {
6296 Hal_SC_set_wr_bank_mapping(pInstance, 0x01, eWindow);
6297 }
6298 else
6299 {
6300 Hal_SC_set_wr_bank_mapping(pInstance, 0x00, eWindow);
6301 }
6302 }
6303 else
6304 #endif
6305 // Set read/write bank as larger than 0x01 if frame count >= 3
6306 if (( gSrcInfo[eWindow].Status2.eFrameStoreNumber >= IMAGE_STORE_3_FRAMES)&&
6307 gSrcInfo[eWindow].Status2.eFrameStoreNumber <= IMAGE_STORE_10_FRAMES)
6308 {
6309 if(SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_04_L, BIT(4)) != 0)
6310 Hal_SC_set_wr_bank_mapping(pInstance, 0x00, eWindow);
6311 else
6312 Hal_SC_set_wr_bank_mapping(pInstance, 0x01, eWindow);
6313 }
6314 else // Interlace
6315 {
6316 //For 25_4R_MC mode only
6317 if((!MDrv_XC_Get_OPWriteOffEnable(pInstance, eWindow)) && (gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_4_FIELDS)
6318 && (!MDrv_SC_IsForceFreerun(pInstance)))
6319 {
6320 Hal_SC_set_wr_bank_mapping(pInstance, 0x02, eWindow);
6321 }
6322 else
6323 {
6324 Hal_SC_set_wr_bank_mapping(pInstance, 0x00, eWindow);
6325 }
6326 }
6327 }
6328 #endif
6329 }
6330
6331 //u32Offset = (MS_U32)pSrcInfo->u16V_Length * (MS_U32)u16DNROffset * (MS_U32)u8BytesPer2Pixel/2;
6332 //fix u32DNRBase1 at SCALER_DNR_BUF_LEN/2 for not using blue-screen at channel change in ATV
6333
6334 if( gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_3_FRAMES )
6335 u32Offset = u32BuffSize/3;
6336 else
6337 u32Offset = u32BuffSize/2;
6338
6339 #if defined (__aarch64__)
6340 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u32Offset :%lu, DNRBufSize=%lu\n", u32Offset, u32BuffSize);
6341 #else
6342 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u32Offset :%tu, DNRBufSize=%tu\n", (ptrdiff_t)u32Offset, (ptrdiff_t)u32BuffSize);
6343 #endif
6344
6345 u8FrameNum = MDrv_XC_TransFrameNumToFactor(pInstance, gSrcInfo[eWindow].Status2.eFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
6346
6347 u32DNRBase0 = u32BaseAddr;//MS_IPM_BASE0(eWindow);
6348 #if SUPPORT_2_FRAME_MIRROR
6349 MS_U32 u32pitch = 0;
6350
6351 if( (gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_2_FRAMES) && (!gSrcInfo[eWindow].bInterlace) )
6352 {
6353 u32pitch = ( ( (MS_U32)(pSrcInfo->u8BitPerPixel/8) * (MS_U32)gSrcInfo[eWindow].u16IPMFetch * (MS_U32)u8FrameNum * (MS_U32)(pSrcInfo->u16V_SizeAfterPreScaling - 1) ) / (MS_U32)BYTE_PER_WORD);//Pitch = Byte_per_pix*align(fetch)*2*(height-1)/byte_per_miu_word
6354 u32DNRBase1 = u32DNRBase0 + u32pitch;
6355 }
6356
6357 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u32pitch:%x u32DNRBase1:%x \n",(int)u32pitch,(int)u32DNRBase1);
6358 #else
6359 u32DNRBase1 = u32BaseAddr+ (( u32Offset/BYTE_PER_WORD + 0x01) & ~0x01L);
6360
6361 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>MAIN DNRBase1[%x]= MS_IPM_BASE0[%u]=(%x) + ((u32Offset[%x]/%d + 0x01) & ~0x01L)\n",(int)u32DNRBase1, eWindow,(int)u32BaseAddr,(int)u32Offset, BYTE_PER_WORD);
6362 #endif
6363
6364 #ifndef DISABLE_3D_FUNCTION
6365 MDrv_SC_3D_Adjust_DNRBase(pInstance,
6366 &u32DNRBase0,
6367 &u32DNRBase1,
6368 eWindow);
6369 #endif
6370
6371 if( gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_3_FRAMES )
6372 u32DNRBase2 = u32DNRBase1 + (( u32Offset/BYTE_PER_WORD + 0x01) & ~0x01L);
6373 else
6374 u32DNRBase2 = u32DNRBase0;
6375
6376 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>DNRBase2[%x])\n", (int)u32DNRBase2);
6377 #if 1
6378 if(pSrcInfo->bDisplayNineLattice)
6379 {
6380 u32OPMBase1 = u32OPMBase0 = u32OPMBase2 = u32DNRBase0;
6381 }
6382 else
6383 {
6384 u32OPMBase0 = u32DNRBase0;
6385 u32OPMBase1 = u32DNRBase1;
6386 u32OPMBase2 = u32DNRBase2;
6387 #ifndef DISABLE_3D_FUNCTION
6388 MDrv_SC_3D_Adjust_OPMBase(pInstance,
6389 &u32OPMBase0,
6390 &u32OPMBase1,
6391 &u32OPMBase2,
6392 u32Offset,
6393 eWindow);
6394 #endif
6395
6396 }
6397 if (bIsConnectOPM)
6398 {
6399 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase0 = u32OPMBase0;
6400 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase1 = u32OPMBase1;
6401 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase2 = u32OPMBase2;
6402 }
6403 else
6404 {
6405 #if (HW_DESIGN_4K2K_VER == 4)
6406 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase0 = u32OPMBase0;
6407 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase1 = u32OPMBase1;
6408 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase2 = u32OPMBase2;
6409 #endif
6410 }
6411 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>u32OPMBase0[%x]= MS_IPM_BASE0[%u][%x] => ",(int)u32OPMBase0, eWindow, (int)u32BaseAddr);
6412 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u32OPMBase1[%x]= u32IPMBase1[%x] \n",(int)u32OPMBase1,(int)u32DNRBase1);
6413 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u32OPMBase2[%x] \n",(int)u32OPMBase2);
6414 #endif
6415
6416 // Cal DNR V write limit
6417 if(pSrcInfo->bDisplayNineLattice)
6418 {
6419 u16V_Writelimit = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height;
6420 }
6421 else
6422 {
6423 u16V_Writelimit = pSrcInfo->stCapWin.height;
6424 }
6425
6426 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=> u16V_Writelimit:%d \n",u16V_Writelimit);
6427 if( bInterlace )
6428 u16V_Writelimit = (u16V_Writelimit+1) / 2;
6429 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=> i=%d, u16V_Writelimit[%d]= (u16V_Writelimit+1) / 2\n",bInterlace,u16V_Writelimit);
6430 // Cal DNR write limit
6431 #if 1//( CHIP_FAMILY_TYPE == CHIP_FAMILY_S4LE )
6432
6433 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"preview =>WritelimitBase[%u][%x] = (MS_IPM_BASE0[%u]=%x) + (((u32Offset[%x] + 0xF) & ~0xFL) * 3 / BYTE_PER_WORD)\n",eWindow,(int)u32WritelimitBase, eWindow, (int)u32BaseAddr,(int)u32Offset);
6434
6435 if(gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_3_FRAMES)
6436 u32WritelimitBase = (u32BaseAddr) + (((u32Offset + 0xF) & ~0xFL) * 3 / BYTE_PER_WORD);
6437 else
6438 u32WritelimitBase = (u32BaseAddr) + (((u32Offset + 0xF) & ~0xFL) * 2 / BYTE_PER_WORD);
6439
6440 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>WritelimitBase[%x] = (MS_IPM_BASE0[%u]=%x) + (((u32Offset[%x] + 0xF) & ~0xFL) * 2 / BYTE_PER_WORD)\n",(int)u32WritelimitBase,eWindow,(int)u32BaseAddr,(int)u32Offset);
6441 u32WritelimitBase = (eWindow == MAIN_WINDOW) ? (u32WritelimitBase - 1) | F2_WRITE_LIMIT_EN : (u32WritelimitBase - 1) | F1_WRITE_LIMIT_EN;
6442 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=> u32WritelimitBase[%x] = (u32WritelimitBase - 1) | 0x2000000\n",(int)u32WritelimitBase);
6443 #else
6444 u32WritelimitBase = MS_DNR_F2_BASE0 + ((u32Offset/8 + 0x01) & ~0x01L) * 2;
6445 u32WritelimitBase = (u32WritelimitBase - 1);
6446 #endif
6447 if (bDoMirror)
6448 {
6449 if (IsVMirrorMode(eWindow))
6450 {
6451 if(!pSrcInfo->bDisplayNineLattice)
6452 {
6453 MS_U16 u16V_SizeAfterPreScaling = pSrcInfo->u16V_SizeAfterPreScaling;
6454 MS_U16 u16DNROffsetTemp = u16DNROffset;
6455 MS_U16 u16Ratio = 1;
6456 MS_BOOL bMirrorBufferOverflow = FALSE;
6457
6458 if(MDrv_XC_GetDynamicScalingStatus(pInstance)
6459 #ifdef K3_U2
6460 && (eWindow == MAIN_WINDOW)
6461 #if SUPPORT_SEAMLESS_ZAPPING
6462 && (pXCResourcePrivate->sthal_SC.bSeamlessZappingEnable[eWindow] == FALSE)
6463 #endif
6464 #endif
6465 )
6466 {
6467 //only for mm ds go into ficlk patch: gSrcInfo[eWindow].Status2.u16PreVCusScalingDst
6468 //is one(progressive) or two lines(interlace) less than gSrcInfo[eWindow].Status2.u16PreVCusScalingSrc
6469 u16V_SizeAfterPreScaling = gSrcInfo[eWindow].Status2.u16PreVCusScalingSrc;
6470 }
6471
6472 #ifndef DISABLE_3D_FUNCTION
6473 MDrv_SC_3D_Adjust_MirrorDNROffset(pInstance, pSrcInfo, &u16V_SizeAfterPreScaling, &u16DNROffsetTemp, &u16Ratio, eWindow);
6474 #endif
6475 //base_offset = (frame_line_cnt -2) * line_offset * (N-bits/pix)/64-bits
6476 u32OneLineOffset = u8FrameNum * (MS_PHY)u16Ratio * (MS_U32)u16DNROffsetTemp * (MS_U32)u8BytesPer2Pixel/2/BYTE_PER_WORD;
6477
6478 #if SUPPORT_SEAMLESS_ZAPPING
6479 if( bInterlace || Hal_SC_IsPX2MemFormat(pInstance, eWindow))
6480 #else
6481 if( bInterlace )
6482 #endif
6483 {
6484 if(MDrv_XC_Is_SupportSWDS(pInstance) && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)))
6485 {
6486 u32BaseOffset = (MS_PHY)gSrcInfo[eWindow].Status2.u16VirtualBox_Width * (MS_PHY)((gSrcInfo[eWindow].Status2.u16VirtualBox_Height-1)/2) * (MS_PHY)u8BytesPer2Pixel/2/BYTE_PER_WORD * u8FrameNum;
6487 }
6488 else
6489 {
6490 MS_U16 u16Offset;
6491 //u16Offset = u16DNROffsetTemp * MDrv_XC_TransFrameNumToFactor(pInstance, gSrcInfo[eWindow].Status2.eFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED) / 2;
6492 u16Offset = u16DNROffsetTemp * u8FrameNum / 2;
6493 u32BaseOffset = (MS_PHY)(u16V_SizeAfterPreScaling-2) * (MS_PHY)u16Ratio * (MS_PHY)u16Offset * (MS_PHY)u8BytesPer2Pixel/2/BYTE_PER_WORD;
6494 }
6495 }
6496 else
6497 {
6498 if(MDrv_XC_Is_SupportSWDS(pInstance) && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)))
6499 {
6500 u32BaseOffset = (MS_PHY)gSrcInfo[eWindow].Status2.u16VirtualBox_Width * (MS_PHY)(gSrcInfo[eWindow].Status2.u16VirtualBox_Height -1) * (MS_PHY)u8BytesPer2Pixel/2/BYTE_PER_WORD * u8FrameNum;
6501 }
6502 else
6503 {
6504 //Progressived mode, non-linear address
6505 //base_offset = (frame_line_cnt -2) * line_offset * (N-bits/pix)/64-bits
6506 u32BaseOffset = (MS_PHY)((MS_PHY)u16Ratio * u8FrameNum*(u16V_SizeAfterPreScaling-1)) * (MS_PHY)u16DNROffsetTemp * (MS_PHY)u8BytesPer2Pixel/2/BYTE_PER_WORD;
6507 }
6508 }
6509
6510 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>u16Ratio[%u] * u8FrameNum[%u] *(u16V_SizeAfterPreScaling-1)[%u]*u16DNROffsetTemp[%u]*u8BytesPer2Pixel[%u]\n",
6511 u16Ratio,u8FrameNum,(u16V_SizeAfterPreScaling-1),u16DNROffsetTemp,u8BytesPer2Pixel);
6512
6513 if (bIsConnectOPM)
6514 MDrv_SC_set_DNRBaseOffset(pInstance, eWindow,u32BaseOffset);
6515 else
6516 MDrv_SC_set_FRCMBaseOffset(pInstance, eWindow,u32BaseOffset);
6517 u32DNRBase0 += u32BaseOffset;
6518
6519 //to avoid set dnr base1 out of scaler dnr memory when 2 frame mode
6520 if((u32DNRBase1 + u32BaseOffset) <= (u32BaseAddr + u32BuffSize/BYTE_PER_WORD - u32OneLineOffset))
6521 {
6522 u32DNRBase1 += u32BaseOffset;
6523 }
6524
6525 if((u32DNRBase2 + u32BaseOffset) <= (u32BaseAddr + u32BuffSize/BYTE_PER_WORD - u32OneLineOffset))
6526 {
6527 u32DNRBase2 += u32BaseOffset;
6528 }
6529
6530 if(MDrv_XC_Get_SCMI_Type())
6531 {
6532 // field packing mode, only dnrbase0 is used
6533 if((u32DNRBase0 < u32BaseOffset) || (u32DNRBase0 - u32BaseOffset < u32BaseAddr))
6534 {
6535 bMirrorBufferOverflow = TRUE;
6536 }
6537 }
6538 else //not field packing mode
6539 {
6540 if(gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_2_FRAMES)
6541 {
6542 // 2 frame mode, only dnrbase0 is used
6543 if((u32DNRBase0 < u32BaseOffset) || (u32DNRBase0 - u32BaseOffset < u32BaseAddr))
6544 {
6545 bMirrorBufferOverflow = TRUE;
6546 }
6547 }
6548 else if(gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_3_FRAMES)
6549 {
6550 // 3 frame mode, dnrbase0, dnrbase1, dnrbase2 is used
6551 if((u32DNRBase0 < u32BaseOffset)
6552 || (u32DNRBase1 < u32BaseOffset)
6553 || (u32DNRBase2 < u32BaseOffset)
6554 || (u32DNRBase0 - u32BaseOffset < u32BaseAddr)
6555 || (u32DNRBase1 - u32BaseOffset < u32BaseAddr)
6556 || (u32DNRBase2 - u32BaseOffset < u32BaseAddr))
6557 {
6558 bMirrorBufferOverflow = TRUE;
6559 }
6560 }
6561 else
6562 {
6563 //other frame mode, dnr base0, dnr base1 is used
6564 if((u32DNRBase0 < u32BaseOffset)
6565 || (u32DNRBase1 < u32BaseOffset)
6566 || (u32DNRBase0 - u32BaseOffset < u32BaseAddr)
6567 || (u32DNRBase1 - u32BaseOffset < u32BaseAddr))
6568 {
6569 bMirrorBufferOverflow = TRUE;
6570 }
6571 }
6572 }
6573
6574 if(bMirrorBufferOverflow)
6575 {
6576 printf("[%s,%5d] Attention! Scaler memory is overflow!\n",__FUNCTION__,__LINE__);
6577 MS_ASSERT(0);
6578 }
6579 }
6580
6581 u32WritelimitBase = u32BaseAddr - 1;
6582
6583 if(eWindow == MAIN_WINDOW)
6584 u32WritelimitBase= u32WritelimitBase | F2_WRITE_LIMIT_EN | F2_WRITE_LIMIT_MIN;
6585 else
6586 u32WritelimitBase= u32WritelimitBase | F1_WRITE_LIMIT_EN | F1_WRITE_LIMIT_MIN;
6587 }
6588 }
6589
6590 //store FrameNum
6591 MDrv_XC_Save_FrameNumFactor(pInstance, eWindow,
6592 MDrv_XC_TransFrameNumToFactor(pInstance, gSrcInfo[eWindow].Status2.eFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED));
6593
6594 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16VLen = pSrcInfo->u16V_Length;
6595 if(eWindow == MAIN_WINDOW)
6596 {
6597 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16VWritelimit = u16V_Writelimit | F2_V_WRITE_LIMIT_EN;
6598
6599 //DS need set FRCM_W limit here
6600 if(MDrv_XC_Is_SupportSWDS(pInstance) && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)))
6601 {
6602 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16VFRCMWritelimit = u16V_Writelimit | F2_V_WRITE_LIMIT_EN;
6603 }
6604 }
6605 else
6606 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16VWritelimit = u16V_Writelimit | F1_V_WRITE_LIMIT_EN;
6607
6608 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32WritelimitBase = u32WritelimitBase;
6609
6610 #if (HW_DESIGN_4K2K_VER == 4)
6611 static MS_PHY u32PreviousWritelimitBase = 0;
6612 /// need to check the IPM write base, if it used the monaco 4K mode, the IPM need to change to frcm base!
6613 if(u32WritelimitBase != u32PreviousWritelimitBase)
6614 MDrv_SC_set_write_limit(pInstance, u32WritelimitBase, eWindow);
6615 u32PreviousWritelimitBase = u32WritelimitBase;
6616 #endif
6617
6618 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DNROffset = u16DNROffset;
6619 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DNRFetch = gSrcInfo[eWindow].u16IPMFetch;
6620
6621 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase0 = u32DNRBase0;
6622 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase1 = u32DNRBase1;
6623 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase2 = u32DNRBase2;
6624 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMOffset = u16DNROffset;
6625 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16AlignWidth = u16AlignWidth;
6626 #if (HW_DESIGN_4K2K_VER == 4)
6627 if ((psXCInstPri->u32DeviceID==0) && !(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_LEGACY_MODE))
6628 {
6629 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_ROffset = u16DNROffset;
6630 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_WOffset = u16DNROffset;
6631 }
6632 #endif
6633 pSrcInfo->u32IPMBase0 = u32DNRBase0 * BYTE_PER_WORD;
6634 pSrcInfo->u32IPMBase1 = u32DNRBase1 * BYTE_PER_WORD;
6635 pSrcInfo->u32IPMBase2 = u32DNRBase2 * BYTE_PER_WORD;
6636 pSrcInfo->u16IPMOffset = u16DNROffset;
6637 *pu32OneLineOffset = u32OneLineOffset;
6638
6639 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final DNR Offset/Fetch=0x%x, 0x%x, OPM Offset=0x%x, V_Length=0x%x\n",
6640 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DNROffset,
6641 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DNRFetch,
6642 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMOffset,
6643 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16VLen
6644 );
6645 #if defined (__aarch64__)
6646 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final u32DNRBase0/1/2=0x%lx, 0x%lx, 0x%lx\n",
6647 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase0,
6648 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase1,
6649 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase2
6650 );
6651 #else
6652 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final u32DNRBase0/1/2=0x%tx, 0x%tx, 0x%tx\n",
6653 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase0,
6654 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase1,
6655 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase2
6656 );
6657 #endif
6658 #if (HW_DESIGN_4K2K_VER == 4)
6659 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC," Final u16FRCM_ROffset = 0x%x u16FRCM_WOffset = 0x%x\n",
6660 (int)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_ROffset,
6661 (int)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_WOffset);
6662 #endif
6663 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"---------------------------------------------------\n");
6664 }
6665
MDrv_SC_set_opmsetting(void * pInstance,XC_InternalStatus * pSrcInfo,MS_BOOL bDoMirror,MS_BOOL bDoCrop,MS_U32 u32OneLineOffset,SCALER_WIN eWindow)6666 void MDrv_SC_set_opmsetting(void *pInstance, XC_InternalStatus *pSrcInfo, MS_BOOL bDoMirror, MS_BOOL bDoCrop, MS_U32 u32OneLineOffset, SCALER_WIN eWindow)
6667 {
6668 MS_U16 u16LBOffset, u16DispOffset, u16OPMFetch, u16OPMFetchAlignment;
6669 MS_PHY u32OPMBase0, u32OPMBase1, u32OPMBase2, u32OPMCropOffset =0, u32OPMPixelOffset;
6670 MS_BOOL bInterlace = pSrcInfo->bInterlace;
6671 MS_U32 u32Framesize;
6672 MS_U8 u8BytesPer2Pixel = pSrcInfo->u8BitPerPixel * 2 / 8;
6673 MS_U16 u16DNROffsetFor3D = 0;
6674 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
6675 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
6676 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
6677 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
6678 MS_U16 u16DNROffset = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DNROffset;
6679 u16DNROffsetFor3D = u16DNROffset;
6680
6681 if(MDrv_XC_Is_SupportSWDS(pInstance) && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)))
6682 {
6683 u32Framesize = gSrcInfo[eWindow].Status2.u16VirtualBox_Height * (MS_U32)u16DNROffset * (MS_U32)u8BytesPer2Pixel/2;
6684 }
6685 else
6686 {
6687 u32Framesize = (MS_U32)pSrcInfo->u16V_SizeAfterPreScaling * (MS_U32)u16DNROffset * (MS_U32)u8BytesPer2Pixel/2;
6688 }
6689
6690 #ifndef DISABLE_3D_FUNCTION
6691 MDrv_SC_3D_Adjust_DNROffset(pInstance, &u16DNROffsetFor3D,&u16DNROffset, eWindow);
6692
6693 #if (HW_DESIGN_3D_VER >= 2)
6694 if((E_XC_3D_INPUT_FRAME_PACKING == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
6695 && ((pSrcInfo->stCapWin.height == DOUBLEHD_1080X2I_VSIZE)
6696 #if ((HW_DESIGN_3D_VER == 3) && (HW_DESIGN_4K2K_VER == 7))
6697 || (pSrcInfo->stCapWin.height == DOUBLEHD_576X2I_VSIZE)
6698 || (pSrcInfo->stCapWin.height == DOUBLEHD_480X2I_VSIZE)
6699 #endif
6700 ))
6701 {
6702 //special case, hw will use field size 540 as deinterlace size
6703 u32Framesize /= 2;
6704 }
6705 #if (HW_DESIGN_3D_VER > 2)
6706 else if(E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
6707 {//per designer, input 3d:framealternative will double data at dnr
6708 u32Framesize *= 2;
6709 }
6710 #endif
6711 #endif
6712 #endif
6713
6714 u32OPMBase0 = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase0;
6715 u32OPMBase1 = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase1;
6716 u32OPMBase2 = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase2;
6717 /////////////////////////////////////////////////
6718 // Set OPM Memeory Settings //
6719 /////////////////////////////////////////////////
6720
6721 // Cal OPM Base address
6722
6723 // compute address offset for cropping
6724 // cropping shift h unit: 16 pixel
6725 // v unit: 2 line(for interlace), 1 line(for progressive)
6726 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop info: (x,y)=(%d,%d),(width,height)=(%d,%d), interlaced = %d\n",
6727 gSrcInfo[eWindow].ScaledCropWin.x, gSrcInfo[eWindow].ScaledCropWin.y,
6728 gSrcInfo[eWindow].ScaledCropWin.width, gSrcInfo[eWindow].ScaledCropWin.height,
6729 bInterlace);
6730
6731 if(pSrcInfo->bDisplayNineLattice)
6732 {
6733 if (IsVMirrorMode(eWindow) && bDoMirror)
6734 {
6735 if(gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_8_FIELDS)
6736 {
6737 u32OPMPixelOffset = (MS_PHY)(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height
6738 - (gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))*u16DNROffset;
6739 }
6740 else if( bInterlace )
6741 {
6742 u32OPMPixelOffset = (MS_PHY)((pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height
6743 - (gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))/2)*u16DNROffset;
6744 }
6745 else
6746 {
6747 u32OPMPixelOffset = (MS_PHY)(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height
6748 - (gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))*u16DNROffset;
6749 }
6750 u32OPMPixelOffset += (MS_PHY)(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width
6751 - (gSrcInfo[eWindow].stDispWin.x - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16HStart + gSrcInfo[eWindow].stDispWin.width));
6752 }
6753 else
6754 {
6755 if(gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_8_FIELDS)
6756 {
6757 u32OPMPixelOffset = (MS_PHY)((gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))*u16DNROffset;
6758 }
6759 else if( bInterlace )
6760 {
6761 u32OPMPixelOffset = (MS_PHY)((gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart)/2)*u16DNROffset;
6762 }
6763 else
6764 {
6765 u32OPMPixelOffset = (MS_PHY)((gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))*u16DNROffset;
6766 }
6767 u32OPMPixelOffset += (MS_PHY)(gSrcInfo[eWindow].stDispWin.x - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16HStart);
6768 }
6769 }
6770 else
6771 {
6772 if (bDoCrop)
6773 {
6774 #if SUPPORT_SEAMLESS_ZAPPING
6775 if( bInterlace || Hal_SC_IsPX2MemFormat(pInstance, eWindow))
6776 #else
6777 if( bInterlace )
6778 #endif
6779 {
6780 u32OPMPixelOffset = (MS_PHY)(gSrcInfo[eWindow].ScaledCropWin.y/2) * u16DNROffsetFor3D;
6781 }
6782 else
6783 {
6784 u32OPMPixelOffset = (MS_PHY)((gSrcInfo[eWindow].ScaledCropWin.y) * u16DNROffsetFor3D);
6785 }
6786 u32OPMPixelOffset += (MS_PHY)(gSrcInfo[eWindow].ScaledCropWin.x);
6787 }
6788 else
6789 {
6790 u32OPMPixelOffset = 0;
6791 }
6792
6793 #if (HW_IPM_FETCH_ALIGNMENT==FALSE)
6794 if (IsVMirrorMode(eWindow) && bDoMirror)
6795 {
6796 u32OPMPixelOffset += pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16AlignWidth;
6797 }
6798 #else
6799 if (IsVMirrorMode(eWindow) && pSrcInfo->bMemFmt422 && bDoMirror)
6800 {
6801 u32OPMPixelOffset += (u16DNROffset - pSrcInfo->u16H_SizeAfterPreScaling);
6802 }
6803 #endif
6804 }
6805
6806 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop total offset pixel counts %td\n",(ptrdiff_t)u32OPMPixelOffset);
6807 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop info: (x,y)=(%d,%d),(width,height)=(%d,%d), interlaced = %d\n",
6808 gSrcInfo[eWindow].ScaledCropWin.x, gSrcInfo[eWindow].ScaledCropWin.y,
6809 gSrcInfo[eWindow].ScaledCropWin.width, gSrcInfo[eWindow].ScaledCropWin.height,
6810 bInterlace);
6811
6812 // calculate LB offset
6813 u16LBOffset = u32OPMPixelOffset % OFFSET_PIXEL_ALIGNMENT; // these pixels rely on line buffer offset
6814 gSrcInfo[eWindow].Status2.u16LBOffset = u16LBOffset;
6815 u32OPMPixelOffset -= u16LBOffset; // these pixels rely on base offset
6816
6817 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"LB offset %d, Pixel offset %d Alighment: %d bytes \n", u16LBOffset, (int)u32OPMPixelOffset,OFFSET_PIXEL_ALIGNMENT);
6818
6819 // calcuate OPM offset
6820 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"eFrameStoreNumber %d\n", (gSrcInfo[eWindow].Status2.eFrameStoreNumber));
6821 u32OPMPixelOffset *= MDrv_XC_TransFrameNumToFactor(pInstance, gSrcInfo[eWindow].Status2.eFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
6822 #ifdef K3_U2
6823 if(Hal_SC_IsPX2MemFormat(pInstance, eWindow))
6824 {
6825 u32OPMPixelOffset *= 2;
6826 }
6827 #endif
6828 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"bLinearMode = %s\n",gSrcInfo[eWindow].bLinearMode ?("TRUE"):("FALSE"));
6829 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop total offset pixel counts for field/frame %td (eFrameStoreNumber: %d)\n", (ptrdiff_t)u32OPMPixelOffset, gSrcInfo[eWindow].Status2.eFrameStoreNumber);
6830
6831 if(u32OPMPixelOffset != 0)
6832 {
6833 MS_U8 u8BytesPer2PixelTemp = u8BytesPer2Pixel;
6834 #ifndef DISABLE_3D_FUNCTION
6835 MDrv_SC_3D_Adjust_BytesPer2Pixel(pInstance, &u8BytesPer2PixelTemp,eWindow);
6836 #endif
6837 u32OPMCropOffset = u32OPMPixelOffset * u8BytesPer2PixelTemp / 2 / BYTE_PER_WORD;
6838 #ifdef _FIELD_PACKING_MODE_SUPPORTED_MULTIPLE_TEMP
6839 //Attention, this is for temp solve crop address offset error in Kappa. Remove this if Kappa code flow has refined.
6840 printf("[Kappa_temp_patch] u32OPMCropOffset*=2\n");
6841 u32OPMCropOffset *= 2;
6842 #endif
6843 }
6844
6845 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"f.LineBuf offset %d, OPMOffset 0x%tx\n", u16LBOffset, (ptrdiff_t)u32OPMCropOffset);
6846
6847 //KT: T3 PIP HW issue, When SUB ON, the HW operation will decrease "u16LBOffset" 2 times.
6848 MS_U16 CropWinWidthTemp = 0;
6849 if (bDoCrop)
6850 {
6851 CropWinWidthTemp = gSrcInfo[eWindow].ScaledCropWin.width;
6852 }
6853 else
6854 {
6855 CropWinWidthTemp = gSrcInfo[eWindow].u16H_SizeAfterPreScaling;
6856 }
6857 #ifndef DISABLE_3D_FUNCTION
6858 MDrv_SC_3D_Adjust_CropWinWidth(pInstance, &CropWinWidthTemp,eWindow);
6859 #endif
6860 u16OPMFetch = CropWinWidthTemp + u16LBOffset; // using LBOffset still need to add some points to avoid generating garbage
6861
6862 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"[%s,%5d] u16OPMFetch:%d \n", __func__,__LINE__,u16OPMFetch);
6863
6864 if(pSrcInfo->bDisplayNineLattice) // for display ninelattice no line buffer offset
6865 {
6866 u16LBOffset = u16DispOffset=0;
6867 u16OPMFetch = (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width + 1) & ~0x1;
6868 #ifdef K3_U2
6869 u16OPMFetch += HW_PIP_BUG_SW_PATCH_FETCH_INCREASE; // - For HW Bug in PIP when the gap between H-end of sub window and H-end of main window is too small
6870 #endif
6871 }
6872 else
6873 {
6874 // IPM offset / IPM fetch /OPM offset: All project --> 32pix align
6875 // OPM fetch:
6876 // Janus /T7 --> 32pix align
6877 // Others ( T8/T9/T12/T13/m10/J2 ) --> 2pix align
6878 #ifndef DISABLE_3D_FUNCTION
6879 MS_U16 u16HShift = 0;
6880 #endif
6881 MS_U16 u16tempOPM;
6882 if((u16LBOffset & 0x1) != 0)
6883 {
6884 //HW issue for OPM fetch&422to444: when lboffset not even, OPM should add 2 to avoid right line garbage.
6885 //if box chip need define HW_OPM_FETCH_NEEDPLUS2
6886 #ifdef HW_OPM_FETCH_NEEDPLUS2
6887 u16tempOPM = (( u16OPMFetch + 1 ) & ~1) + 2;
6888 #else
6889 u16tempOPM = (( u16OPMFetch + 1 ) & ~1);
6890 #endif
6891 if (!bDoCrop || (u16tempOPM > pSrcInfo->u16H_SizeAfterPreScaling - (gSrcInfo[eWindow].ScaledCropWin.x - u16LBOffset)))
6892 {
6893 u16LBOffset--;//Overflow, set lb offset even and alignment OPM
6894 u16OPMFetch = u16OPMFetch & ~1; //Make even directly, since lb offset has minus 1
6895 }
6896 else
6897 {
6898 u16OPMFetch = u16tempOPM;
6899 }
6900 }
6901 else if((u16OPMFetch != gSrcInfo[eWindow].u16IPMFetch)
6902 #ifndef DISABLE_3D_FUNCTION
6903 && (E_XC_3D_OUTPUT_MODE_NONE == MDrv_XC_Get_3D_Output_Mode(pInstance))
6904 #endif
6905 )
6906 {
6907 //UCDi need grab six more pixels, not 3D case.(a7p need 6 more, others need 2 more)
6908 u16tempOPM = (( u16OPMFetch + 1 ) & ~1) + 6;
6909 if (!bDoCrop || (u16tempOPM > pSrcInfo->u16H_SizeAfterPreScaling - (gSrcInfo[eWindow].ScaledCropWin.x - u16LBOffset)))
6910 {
6911 u16OPMFetch = u16OPMFetch & ~1;
6912 }
6913 else
6914 {
6915 u16OPMFetch = u16tempOPM;
6916 }
6917 }
6918 else
6919 {
6920 u16OPMFetch = ( u16OPMFetch + 1 ) & ~1; // pixels alignment
6921 }
6922 #ifdef K3_U2
6923 u16OPMFetch += HW_PIP_BUG_SW_PATCH_FETCH_INCREASE; // - For HW Bug in PIP when the gap between H-end of sub window and H-end of main window is too small
6924 #endif
6925 if (!pSrcInfo->bMemFmt422)
6926 {
6927 u16OPMFetchAlignment = (u16OPMFetch + (OFFSET_PIXEL_ALIGNMENT - 1)) & ~(OFFSET_PIXEL_ALIGNMENT - 1);
6928 if (bDoCrop)
6929 {
6930 //HW issue for OPM fetch when OP write enable, OPM Fetch have to offset pixels alignment avoid green garbage .
6931 if (pSrcInfo->u16H_SizeAfterPreScaling >= (u16OPMFetchAlignment+gSrcInfo[eWindow].ScaledCropWin.x - u16LBOffset))
6932 {
6933 u16OPMFetch = u16OPMFetchAlignment;
6934 }
6935 else
6936 {
6937 //Overflow, set the OPM Fetch to the max data area .
6938 u16OPMFetch = pSrcInfo->u16H_SizeAfterPreScaling - gSrcInfo[eWindow].ScaledCropWin.x + u16LBOffset;
6939 u16OPMFetch = u16OPMFetch & ~1;
6940 }
6941 }
6942 else
6943 {
6944 u16OPMFetch = u16OPMFetch & ~1;
6945 }
6946 }
6947 else
6948 {
6949 if(2200>=u16OPMFetch) //Nike 4k2k opm fetch can't do ALIGNMENT
6950 u16OPMFetch = (u16OPMFetch + (OFFSET_PIXEL_ALIGNMENT - 1)) & ~(OFFSET_PIXEL_ALIGNMENT - 1);
6951 }
6952 #ifndef DISABLE_3D_FUNCTION
6953 if(MDrv_SC_3D_Is2Dto3DCase(pInstance, MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow), MDrv_XC_Get_3D_Output_Mode(pInstance)))
6954 {
6955 u16HShift = MDrv_XC_Get_3D_HShift(pInstance);
6956 if ((u16OPMFetch + u16HShift) > gSrcInfo[eWindow].u16IPMFetch)
6957 {
6958 if(gSrcInfo[eWindow].u16IPMFetch > u16HShift)
6959 {
6960 //opmfetch need align although ipmfetch may not need align
6961 u16OPMFetch = ( gSrcInfo[eWindow].u16IPMFetch - u16HShift + 1 ) & ~1;
6962 }
6963 else
6964 {
6965 u16OPMFetch = 0;
6966 }
6967 }
6968 }
6969 else
6970 #endif
6971 {
6972 if(u16OPMFetch > pSrcInfo->u16H_SizeAfterPreScaling - (gSrcInfo[eWindow].ScaledCropWin.x - u16LBOffset))
6973 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"!!!Alert OPMFetch(%u) Overflowed, check crop setting!!!\n", u16OPMFetch);
6974 }
6975 }
6976
6977 #ifdef K3_U2
6978 // - For HW Bug in PIP when the gap between H-end of sub window and H-end of main window is too small
6979 if(eWindow == MAIN_WINDOW)
6980 {
6981 if (u16OPMFetch > MST_LINE_BFF_MAX)
6982 {
6983 u16OPMFetch = MST_LINE_BFF_MAX;
6984 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Re-assign OPM fetch as %lu due to HW limitation \n", MST_LINE_BFF_MAX);
6985 }
6986 }
6987 else
6988 {
6989 if(u16OPMFetch > SUB_MST_LINE_BFF_MAX)
6990 {
6991 u16OPMFetch = SUB_MST_LINE_BFF_MAX;
6992 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Re-assign OPM fetch as %lu due to HW limitation \n", SUB_MST_LINE_BFF_MAX);
6993 }
6994 }
6995 #endif
6996
6997 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"f1. u16OPMFetch after alignment %d, lboffset %d \n", u16OPMFetch, u16LBOffset);
6998 //printf("1.SC Crop width=0x%x, LBOffset=0x%x\n", gSrcInfo[eWindow].ScaledCropWin.width, u16LBOffset);
6999 u16DispOffset = 0;
7000
7001 //printf("cropy=%u,cropx=%u,dnroffset=%u,bp2p=%bu\n", _stScaledCropWin.y, _stScaledCropWin.x, u16DNROffset, u8BytesPer2Pixel);
7002 //printf("2.OPM Crop Offset=0x%lx, LBOffset=0x%x\n", u32OPMCropOffset, u16LBOffset);
7003
7004 // adjsut OPMBase address for cropping
7005 if(pSrcInfo ->bDisplayNineLattice)
7006 {
7007 // for linear mode set all base address the same
7008 u32OPMBase0 += u32OPMCropOffset;
7009 //u32DNRBase1 += u32OPMCropOffset;
7010 //u32OPMBase2 += u32OPMCropOffset;
7011 u32OPMBase2 = u32OPMBase1 = u32OPMBase0;
7012 //printf("--u32DNRBase0 %lx\n",u32DNRBase0);
7013 }
7014 else
7015 {
7016 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"h.=> u32OPMBase0,1=%x,%x -> +u32OPMCropOffset[%x] =",(int)u32OPMBase0,(int)u32OPMBase1,(int)u32OPMCropOffset);
7017 u32OPMBase0 += u32OPMCropOffset;
7018 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"0:%x \n",(int)u32OPMBase0);
7019 u32OPMBase1 += u32OPMCropOffset;
7020 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"1:%x \n",(int)u32OPMBase1);
7021 u32OPMBase2 += u32OPMCropOffset;
7022 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"2:%x \n",(int)u32OPMBase2);
7023 }
7024
7025 #if SUPPORT_2_FRAME_MIRROR
7026
7027 MS_S32 s32cropshift_base0 = 0;
7028 MS_S32 s32cropshift_base1 = 0;
7029 MS_U32 u32LBOffset_mirror = 0;
7030 if (bDoCrop)
7031 {
7032 s32cropshift_base0 = gSrcInfo[eWindow].ScaledCropWin.y * (MS_S32) (u16DNROffsetFor3D) + gSrcInfo[eWindow].ScaledCropWin.x;
7033 s32cropshift_base1 = - gSrcInfo[eWindow].ScaledCropWin.y * (MS_S32) (u16DNROffsetFor3D) + gSrcInfo[eWindow].ScaledCropWin.x;
7034 u32LBOffset_mirror = gSrcInfo[eWindow].ScaledCropWin.x % OFFSET_PIXEL_ALIGNMENT;
7035 }
7036
7037 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"[SUPPORT_2_FRAME_MIRROR] u32LBOffset:%d \n",u32LBOffset_mirror);
7038
7039 s32cropshift_base0 = ( s32cropshift_base0 - u32LBOffset_mirror ) * (MS_U32) MDrv_XC_TransFrameNumToFactor(gSrcInfo[eWindow].Status2.eFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
7040 s32cropshift_base1 = ( s32cropshift_base1 - u32LBOffset_mirror ) * (MS_U32) MDrv_XC_TransFrameNumToFactor(gSrcInfo[eWindow].Status2.eFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
7041
7042 s32cropshift_base0 = ( s32cropshift_base0 * (MS_U32)(pSrcInfo->u8BitPerPixel/8) ) / (MS_U32)(BYTE_PER_WORD);
7043 s32cropshift_base1 = ( s32cropshift_base1 * (MS_U32)(pSrcInfo->u8BitPerPixel/8) ) / (MS_U32)(BYTE_PER_WORD);
7044
7045 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"[SUPPORT_2_FRAME_MIRROR] s32cropshift_base0:%d s32cropshift_base1:%d \n", s32cropshift_base0,s32cropshift_base1);
7046
7047 if( (gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_2_FRAMES) && (!gSrcInfo[eWindow].bInterlace) )
7048 {
7049 u32OPMBase0 = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase0 + s32cropshift_base0;
7050 u32OPMBase1 = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase1 + s32cropshift_base1;
7051 }
7052
7053 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"[SUPPORT_2_FRAME_MIRROR] u32DNRBase0:%x u32DNRBase1:%x \n", (int)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase0,(int)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase1);
7054 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"[SUPPORT_2_FRAME_MIRROR] u32OPMBase0:%x u32OPMBase1:%x \n", (int)u32OPMBase0,(int)u32OPMBase1);
7055
7056 #endif
7057 if (bDoCrop)
7058 {
7059 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16LBOffset = u16LBOffset;
7060 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DispOffset = u16DispOffset;
7061 }
7062 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase0 = u32OPMBase0;
7063 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase1 = u32OPMBase1;
7064 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase2 = u32OPMBase2;
7065 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMFetch = u16OPMFetch;
7066
7067 #if defined (__aarch64__)
7068 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final OPM Fetch=0x%x, u32OPMBase0/1/2=0x%lx, 0x%lx, 0x%lx\n",
7069 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMFetch,
7070 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase0,
7071 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase1,
7072 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase2);
7073 #else
7074 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final OPM Fetch=0x%x, u32OPMBase0/1/2=0x%tx, 0x%tx, 0x%tx\n",
7075 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMFetch,
7076 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase0,
7077 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase1,
7078 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase2);
7079
7080 #endif
7081 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"---------------------------------------------------\n");
7082 }
7083
MDrv_SC_set_frcmwsetting(void * pInstance,XC_InternalStatus * pSrcInfo,MS_PHY * pu32OneLineOffset,SCALER_WIN eWindow)7084 void MDrv_SC_set_frcmwsetting(void *pInstance, XC_InternalStatus *pSrcInfo, MS_PHY* pu32OneLineOffset, SCALER_WIN eWindow)
7085 {
7086 #if (HW_DESIGN_4K2K_VER == 4)
7087 MS_U16 u16V_FRCMWritelimit;
7088 MS_PHY u32Offset, u32FRCM_WBase0, u32FRCM_WBase1, u32FRCM_WBase2, u32WritelimitBase=0;
7089 MS_PHY u32OneLineOffset = 0;
7090 MS_U16 u16AlignWidth=0;
7091 MS_PHY u32BaseOffset = 0;
7092 MS_PHY u32Framesize;
7093 MS_U8 u8BytesPer2Pixel = pSrcInfo->u8BitPerPixel * 2 / 8;
7094 MS_U16 u16FRCM_WOffset = 0;
7095 MS_U8 u8FrameNum = 0;
7096 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
7097 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
7098 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
7099 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
7100
7101 /////////////////////////////////////////////////
7102 // Set FRCM_W Memeory Settings //
7103 /////////////////////////////////////////////////
7104 // FRCM_W Fetch/Offset = OPM Fetch/Offset
7105 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_WFetch = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMFetch;
7106 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_WOffset = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMOffset;
7107 //gSrcInfo[eWindow].u16IPMFetch = pSrcInfo->u16H_SizeAfterPreScaling;
7108 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"===================================================\n");
7109 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=> u16DNRFetch=%d ->",(int)gSrcInfo[eWindow].u16IPMFetch);
7110
7111 if(pSrcInfo->bDisplayNineLattice)
7112 {
7113 u16FRCM_WOffset = (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width + OFFSET_PIXEL_ALIGNMENT - 1) & ~(OFFSET_PIXEL_ALIGNMENT-1); //TODO: T3 should be 32 alignment
7114 }
7115 else
7116 {
7117 if(MDrv_XC_Is_SupportSWDS(pInstance) && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)))
7118 {
7119 u16FRCM_WOffset = (gSrcInfo[eWindow].Status2.u16VirtualBox_Width + OFFSET_PIXEL_ALIGNMENT - 1) & ~(OFFSET_PIXEL_ALIGNMENT-1);
7120 }
7121 else
7122 {
7123 u16FRCM_WOffset = (pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DNROffset + OFFSET_PIXEL_ALIGNMENT - 1) & ~(OFFSET_PIXEL_ALIGNMENT-1); //TODO: T3 should be 32 alignment
7124 }
7125 }
7126
7127 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u16FRCM_WFetch=%u u16FRCM_WOffset=%u\n",pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_WFetch,u16FRCM_WOffset);
7128
7129 if(pSrcInfo->bDisplayNineLattice)
7130 {
7131 pSrcInfo->u16FRCMV_Length = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height;
7132 }
7133
7134 if(MDrv_XC_Is_SupportSWDS(pInstance) && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)))
7135 {
7136 u32Framesize = gSrcInfo[eWindow].Status2.u16VirtualBox_Height * (MS_U32)u16FRCM_WOffset * (MS_U32)u8BytesPer2Pixel/2;
7137 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>Framesize(%d)= VirtualBox_Height(%d) * u16FRCM_WOffset(%d) * BytesPer2Pixel(%d)/2\n",(int)u32Framesize,gSrcInfo[eWindow].Status2.u16VirtualBox_Height,u16FRCM_WOffset,u8BytesPer2Pixel);
7138 }
7139 else
7140 {
7141 u32Framesize = (MS_U32)pSrcInfo->u16V_SizeAfterPreScaling * (MS_U32)u16FRCM_WOffset * (MS_U32)u8BytesPer2Pixel/2;
7142 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>Framesize(%d)= VSizeAfterPreSD(%d) * u16FRCM_WOffset(%d) * BytesPer2Pixel(%d)/2\n",(int)u32Framesize,pSrcInfo->u16V_SizeAfterPreScaling,u16FRCM_WOffset,u8BytesPer2Pixel);
7143 }
7144
7145 #ifndef DISABLE_3D_FUNCTION
7146 #if (HW_DESIGN_3D_VER >= 2)
7147 if((E_XC_3D_INPUT_FRAME_PACKING == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
7148 && (pSrcInfo->stCapWin.height == DOUBLEHD_1080X2I_VSIZE))
7149 {
7150 //special case, hw will use field size 540 as deinterlace size
7151 u32Framesize /= 2;
7152 }
7153 #if (HW_DESIGN_3D_VER > 2)
7154 else if(E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
7155 {//per designer, input 3d:framealternative will double data at dnr
7156 u32Framesize *= 2;
7157 }
7158 #endif
7159 #endif
7160 #endif
7161
7162 #ifdef UFO_XC_FB_LEVEL
7163 if((pSrcInfo->eFBLevel == E_XC_FB_LEVEL_FB)
7164 && (u32Framesize * 2 > pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow])
7165 )
7166 #else
7167 if((!pSrcInfo->bFBL)
7168 && (!pSrcInfo->bR_FBL)
7169 && (u32Framesize * 2 > pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow]))
7170 #endif
7171 {
7172 //this case should always not be happened
7173 printf("Attention! Scaler FRCM Buffer is not enough for this timing, eWindow=%u!\n", eWindow);
7174 }
7175
7176 // enable 4 frame mode if input is progressive & frame buffer is enough
7177 // , regardless the input source and timing because 4 frame mode is better in avoid tearing
7178 //
7179 if(pSrcInfo->bDisplayNineLattice)
7180 {
7181 #if (_LINEAR_ADDRESS_MODE_SUPPORTED)
7182 gSrcInfo[eWindow].bLinearMode = TRUE;
7183 Hal_SC_set_linearmem_mode(ENABLE,MAIN_WINDOW);
7184 #endif
7185 }
7186 else
7187 {
7188 XC_FRAME_STORE_NUMBER enLastFBNum = gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber;
7189
7190 /*Update Frame buffer usage status and memory linear mode*/
7191 // MDrv_XC_GetPQSuggestedFrameNum(eWindow) is the frame count that PQ want to set
7192 // gSrcInfo[eWindow].Status2.eFrameStoreNumber is the frame count that sw code(_Mdrv_SC_CalcFBNum)
7193 // decides according to frame size and other condition
7194 _Mdrv_XC_Refine_FRCMFrameNum(pInstance, &gSrcInfo[eWindow].bLinearMode,
7195 &gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber,
7196 u32Framesize,
7197 pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow],
7198 eWindow);
7199
7200 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"gSrcInfo[eWindow].bLinearMode %d \n",gSrcInfo[eWindow].bLinearMode);
7201 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"FrameMode %d \n",gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber);
7202
7203 if (pSrcInfo->bInterlace && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow) ))
7204 {
7205 // hw limition, interlace mode and open ds, scm and frcm frame number need same
7206 if (gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber > gSrcInfo[eWindow].Status2.eFrameStoreNumber)
7207 {
7208 printf("[MDrv_SC_set_frcmwsetting] Waring!!! eFRCMFrameStoreNumber > eFrameStoreNumber!\n");
7209 gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber = gSrcInfo[eWindow].Status2.eFrameStoreNumber;
7210 _MDrv_XC_Set_FrameNum(pInstance, eWindow, FALSE, gSrcInfo[eWindow].Status2.eFrameStoreNumber, pSrcInfo->bInterlace);
7211 }
7212 else if (gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber < gSrcInfo[eWindow].Status2.eFrameStoreNumber)
7213 {
7214 printf("[MDrv_SC_set_frcmwsetting] Waring!!! eFRCMFrameStoreNumber < eFrameStoreNumber!\n");
7215 gSrcInfo[eWindow].Status2.eFrameStoreNumber = gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber;
7216 }
7217 }
7218 // Set memory frame buffer setting.
7219 _MDrv_XC_Set_FrameNum(pInstance, eWindow, TRUE, gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber, FALSE);
7220
7221 //store FrameNum
7222 MDrv_XC_Save_FRCMFrameNumFactor(pInstance, eWindow,
7223 MDrv_XC_TransFrameNumToFactor(pInstance, gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED));
7224
7225 // to avoid mm play photo garbage, because of big changing FB number
7226 if((enLastFBNum != gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber) && (TRUE == MDrv_XC_Get_SCMI_Type()))
7227 {
7228 MDrv_XC_WBankReset(pInstance, TRUE, eWindow);
7229 }
7230
7231 // if support _FIELD_PACKING_MODE_SUPPORTED, it will control by QMAP(J2/A5/A6/A3)
7232 #if(!_FIELD_PACKING_MODE_SUPPORTED)
7233 // avoid tearing problem when we can not do frame lock
7234 if(pSrcInfo->bRWBankAuto)
7235 {
7236 #if (HW_DESIGN_3D_VER == 1)
7237 //this 3d method need special wr bank mapping
7238 if(((E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
7239 && (E_XC_3D_OUTPUT_TOP_BOTTOM == MDrv_XC_Get_3D_Output_Mode(pInstance)))
7240 || ((E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
7241 && (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF == MDrv_XC_Get_3D_Output_Mode(pInstance)))
7242 )
7243 {
7244 if(eWindow == MAIN_WINDOW)
7245 {
7246 Hal_SC_set_frcm_wr_bank_mapping(pInstance, 0x01, eWindow);
7247 }
7248 else
7249 {
7250 Hal_SC_set_frcm_wr_bank_mapping(pInstance, 0x00, eWindow);
7251 }
7252 }
7253 else
7254 #endif
7255 // Set read/write bank as larger than 0x01 if frame count >= 3
7256 if (( gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber >= IMAGE_STORE_3_FRAMES)&&
7257 gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber <= IMAGE_STORE_10_FRAMES)
7258 {
7259 if(SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK32_04_L, BIT(4)) != 0)
7260 Hal_SC_set_frcm_wr_bank_mapping(pInstance, 0x00, eWindow);
7261 else
7262 Hal_SC_set_frcm_wr_bank_mapping(pInstance, 0x01, eWindow);
7263 }
7264 else // Interlace
7265 {
7266 //For 25_4R_MC mode only
7267 if((!MDrv_XC_Get_OPWriteOffEnable(pInstance, eWindow)) && (gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber == IMAGE_STORE_4_FIELDS)
7268 && (!MDrv_SC_IsForceFreerun(pInstance)))
7269 {
7270 Hal_SC_set_frcm_wr_bank_mapping(pInstance, 0x02, eWindow);
7271 }
7272 else
7273 {
7274 Hal_SC_set_frcm_wr_bank_mapping(pInstance, 0x00, eWindow);
7275 }
7276 }
7277 }
7278 #endif
7279 }
7280
7281 //u32Offset = (MS_U32)pSrcInfo->u16V_Length * (MS_U32)u16DNROffset * (MS_U32)u8BytesPer2Pixel/2;
7282 //fix u32DNRBase1 at SCALER_DNR_BUF_LEN/2 for not using blue-screen at channel change in ATV
7283
7284 if( gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber == IMAGE_STORE_3_FRAMES)
7285 u32Offset = pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow]/3;
7286 else
7287 u32Offset = pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow]/2;
7288 #if defined (__aarch64__)
7289 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u32Offset :%lu, DNRBufSize=%lu\n", u32Offset, pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]);
7290 #else
7291 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u32Offset :%tu, DNRBufSize=%tu\n", (ptrdiff_t)u32Offset, (ptrdiff_t)pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]);
7292 #endif
7293
7294 u8FrameNum = MDrv_XC_TransFrameNumToFactor(pInstance, gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
7295
7296 u32FRCM_WBase0 = MS_FRCM_BASE0(eWindow);
7297 #if SUPPORT_2_FRAME_MIRROR
7298 MS_U32 u32pitch = 0;
7299
7300 if (gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber == IMAGE_STORE_2_FRAMES)
7301 {
7302 u32pitch = ( ( (MS_U32)(pSrcInfo->u8BitPerPixel/8) * (MS_U32)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_WFetch * (MS_U32)u8FrameNum * (MS_U32)(pSrcInfo->u16V_SizeAfterPreScaling - 1) ) / (MS_U32)BYTE_PER_WORD);//Pitch = Byte_per_pix*align(fetch)*2*(height-1)/byte_per_miu_word
7303 u32FRCM_WBase1 = u32FRCM_WBase0 + u32pitch;
7304 }
7305
7306 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u32pitch:%x u32DNRBase1:%x \n",(int)u32pitch,(int)u32DNRBase1);
7307 #else
7308 u32FRCM_WBase1 = MS_FRCM_BASE0(eWindow) + (( u32Offset/BYTE_PER_WORD + 0x01) & ~0x01L);
7309 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>MAIN u32FRCM_WBase1[%x]= MS_FRCM_BASE0[%u]=(%x) + ((u32Offset[%x]/%d + 0x01) & ~0x01L)\n",(int)u32FRCM_WBase1, eWindow,(int)MS_FRCM_BASE0(eWindow),(int)u32Offset, BYTE_PER_WORD);
7310 #endif
7311
7312 if( gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber == IMAGE_STORE_3_FRAMES)
7313 u32FRCM_WBase2 = u32FRCM_WBase1 + (( u32Offset/BYTE_PER_WORD + 0x01) & ~0x01L);
7314 else
7315 u32FRCM_WBase2 = u32FRCM_WBase0;
7316
7317 if(pSrcInfo->bDisplayNineLattice)
7318 {
7319 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase0 = u32FRCM_WBase0;
7320 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase1 = u32FRCM_WBase0;
7321 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase2 = u32FRCM_WBase0;
7322 }
7323 else
7324 {
7325 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase0 = u32FRCM_WBase0;
7326 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase1 = u32FRCM_WBase1;
7327 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase2 = u32FRCM_WBase2;
7328 }
7329
7330 // Cal FRCM V write limit
7331 if(pSrcInfo->bDisplayNineLattice)
7332 {
7333 u16V_FRCMWritelimit = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height;
7334 }
7335 else
7336 {
7337 u16V_FRCMWritelimit = pSrcInfo->stCapWin.height;
7338 }
7339
7340 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=> u16V_Writelimit[%d]= u16V_CapSize=%d \n",u16V_FRCMWritelimit,pSrcInfo->stCapWin.height);
7341 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=> u16V_Writelimit[%d]= (u16V_Writelimit+1) / 2\n",u16V_FRCMWritelimit);
7342 // Cal FRCM write limit
7343 #if 1//( CHIP_FAMILY_TYPE == CHIP_FAMILY_S4LE )
7344
7345 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"preview =>WritelimitBase[%u][%x] = (MS_FRCM_BASE0[%u]=%x) + (((u32Offset[%x] + 0xF) & ~0xFL) * 3 / BYTE_PER_WORD)\n",eWindow,(int)u32WritelimitBase, eWindow, (int)MS_FRCM_BASE0(eWindow) ,(int)u32Offset);
7346
7347 if(gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber == IMAGE_STORE_3_FRAMES)
7348 u32WritelimitBase = (MS_FRCM_BASE0(eWindow)) + (((u32Offset + 0xF) & ~0xFL) * 3 / BYTE_PER_WORD);
7349 else
7350 u32WritelimitBase = (MS_FRCM_BASE0(eWindow)) + (((u32Offset + 0xF) & ~0xFL) * 2 / BYTE_PER_WORD);
7351
7352 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>WritelimitBase[%x] = (MS_FRCM_BASE0[%u]=%x) + (((u32Offset[%x] + 0xF) & ~0xFL) * 2 / BYTE_PER_WORD)\n",(int)u32WritelimitBase,eWindow,(int)MS_FRCM_BASE0(eWindow),(int)u32Offset);
7353 u32WritelimitBase = (eWindow == MAIN_WINDOW) ? (u32WritelimitBase - 1) | F2_WRITE_LIMIT_EN : (u32WritelimitBase - 1) | F1_WRITE_LIMIT_EN;
7354 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=> u32WritelimitBase[%x] = (u32WritelimitBase - 1) | 0x2000000\n",(int)u32WritelimitBase);
7355 #else
7356 u32WritelimitBase = MS_DNR_F2_BASE0 + ((u32Offset/8 + 0x01) & ~0x01L) * 2;
7357 u32WritelimitBase = (u32WritelimitBase - 1);
7358 #endif
7359
7360 if (IsVMirrorMode(eWindow))
7361 {
7362 if(!pSrcInfo->bDisplayNineLattice)
7363 {
7364 MS_U16 u16V_SizeAfterPreScaling = pSrcInfo->u16V_SizeAfterPreScaling;
7365 MS_U16 u16FRCM_WOffsetTemp = u16FRCM_WOffset;
7366 MS_U16 u16Ratio = 1;
7367 MS_BOOL bMirrorBufferOverflow = FALSE;
7368 // DS how do it?
7369 #if 0
7370 if(MDrv_XC_GetDynamicScalingStatus(pInstance)
7371 #ifdef K3_U2
7372 && (eWindow == MAIN_WINDOW)
7373 #if SUPPORT_SEAMLESS_ZAPPING
7374 && (pXCResourcePrivate->sthal_SC.bSeamlessZappingEnable[eWindow] == FALSE)
7375 #endif
7376 #endif
7377 )
7378 {
7379 //only for mm ds go into ficlk patch: gSrcInfo[eWindow].Status2.u16PreVCusScalingDst
7380 //is one(progressive) or two lines(interlace) less than gSrcInfo[eWindow].Status2.u16PreVCusScalingSrc
7381 u16V_SizeAfterPreScaling = gSrcInfo[eWindow].Status2.u16PreVCusScalingSrc;
7382 }
7383 #endif
7384
7385 #ifndef DISABLE_3D_FUNCTION
7386 MDrv_SC_3D_Adjust_MirrorDNROffset(pInstance, pSrcInfo, &u16V_SizeAfterPreScaling, &u16FRCM_WOffsetTemp, &u16Ratio, eWindow);
7387 #endif
7388 //base_offset = (frame_line_cnt -2) * line_offset * (N-bits/pix)/64-bits
7389 u32OneLineOffset = u8FrameNum * (MS_U32)u16Ratio * (MS_U32)u16FRCM_WOffsetTemp * (MS_U32)u8BytesPer2Pixel/2/BYTE_PER_WORD;
7390
7391 //Progressived mode, non-linear address
7392 //base_offset = (frame_line_cnt -2) * line_offset * (N-bits/pix)/64-bits
7393 u32BaseOffset = (MS_U32)((MS_U32)u16Ratio * u8FrameNum*(u16V_SizeAfterPreScaling-1)) * (MS_U32)u16FRCM_WOffsetTemp * (MS_U32)u8BytesPer2Pixel/2/BYTE_PER_WORD;
7394
7395 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>u16Ratio[%u] * u8FrameNum[%u] *(u16V_SizeAfterPreScaling-1)[%u]*u16FRCM_WOffsetTemp[%u]*u8BytesPer2Pixel[%u]\n",
7396 u16Ratio,u8FrameNum,(u16V_SizeAfterPreScaling-1),u16FRCM_WOffsetTemp,u8BytesPer2Pixel);
7397
7398 MDrv_SC_set_FRCMBaseOffset(pInstance, eWindow,u32BaseOffset);
7399
7400 u32FRCM_WBase0 += u32BaseOffset;
7401
7402 //to avoid set dnr base1 out of scaler dnr memory when 2 frame mode
7403 if((u32FRCM_WBase1 + u32BaseOffset) <= (MS_FRCM_BASE0(eWindow) + pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow]/BYTE_PER_WORD - u32OneLineOffset))
7404 {
7405 u32FRCM_WBase1 += u32BaseOffset;
7406 }
7407
7408 if((u32FRCM_WBase2 + u32BaseOffset) <= (MS_FRCM_BASE0(eWindow) + pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow]/BYTE_PER_WORD - u32OneLineOffset))
7409 {
7410 u32FRCM_WBase2+= u32BaseOffset;
7411 }
7412
7413 if(MDrv_XC_Get_SCMI_Type())
7414 {
7415 // field packing mode, only dnrbase0 is used
7416 if((u32FRCM_WBase0 < u32BaseOffset) || (u32FRCM_WBase0 - u32BaseOffset < MS_FRCM_BASE0(eWindow)))
7417 {
7418 bMirrorBufferOverflow = TRUE;
7419 }
7420 }
7421 else //not field packing mode
7422 {
7423 if(gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber == IMAGE_STORE_2_FRAMES)
7424 {
7425 // 2 frame mode, only dnrbase0 is used
7426 if((u32FRCM_WBase0 < u32BaseOffset) || (u32FRCM_WBase0 - u32BaseOffset < MS_FRCM_BASE0(eWindow)))
7427 {
7428 bMirrorBufferOverflow = TRUE;
7429 }
7430 }
7431 else if(gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber == IMAGE_STORE_3_FRAMES)
7432 {
7433 // 3 frame mode, dnrbase0, dnrbase1, dnrbase2 is used
7434 if((u32FRCM_WBase0 < u32BaseOffset)
7435 || (u32FRCM_WBase1 < u32BaseOffset)
7436 || (u32FRCM_WBase2 < u32BaseOffset)
7437 || (u32FRCM_WBase0 - u32BaseOffset < MS_FRCM_BASE0(eWindow))
7438 || (u32FRCM_WBase1 - u32BaseOffset < MS_FRCM_BASE0(eWindow))
7439 || (u32FRCM_WBase2 - u32BaseOffset < MS_FRCM_BASE0(eWindow)))
7440 {
7441 bMirrorBufferOverflow = TRUE;
7442 }
7443 }
7444 else
7445 {
7446 //other frame mode, dnr base0, dnr base1 is used
7447 if((u32FRCM_WBase0< u32BaseOffset)
7448 || (u32FRCM_WBase1 < u32BaseOffset)
7449 || (u32FRCM_WBase0- u32BaseOffset < MS_FRCM_BASE0(eWindow))
7450 || (u32FRCM_WBase1 - u32BaseOffset < MS_FRCM_BASE0(eWindow)))
7451 {
7452 bMirrorBufferOverflow = TRUE;
7453 }
7454 }
7455 }
7456
7457 if(bMirrorBufferOverflow)
7458 {
7459 printf("[%s,%5d] Attention! Scaler memory is overflow!\n",__FUNCTION__,__LINE__);
7460 MS_ASSERT(0);
7461 }
7462 }
7463
7464 u32WritelimitBase = MS_FRCM_BASE0(eWindow) - 1;
7465
7466 if(eWindow == MAIN_WINDOW)
7467 u32WritelimitBase= u32WritelimitBase | F2_WRITE_LIMIT_EN | F2_WRITE_LIMIT_MIN;
7468 else
7469 u32WritelimitBase= u32WritelimitBase | F1_WRITE_LIMIT_EN | F1_WRITE_LIMIT_MIN;
7470 }
7471
7472 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCMVLen = pSrcInfo->u16FRCMV_Length;
7473 if(eWindow == MAIN_WINDOW)
7474 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16VFRCMWritelimit = u16V_FRCMWritelimit | F2_V_WRITE_LIMIT_EN;
7475 else
7476 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16VFRCMWritelimit = u16V_FRCMWritelimit | F1_V_WRITE_LIMIT_EN;
7477
7478 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCMWritelimitBase = u32WritelimitBase;
7479 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_WOffset = u16FRCM_WOffset;
7480 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_WFetch = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMFetch;;
7481
7482 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_WBase0 = u32FRCM_WBase0;
7483 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_WBase1 = u32FRCM_WBase1;
7484 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_WBase2 = u32FRCM_WBase2;
7485 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16AlignWidth = u16AlignWidth;
7486 *pu32OneLineOffset = u32OneLineOffset;
7487
7488 //-----------------------------------------------------------------
7489 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final FRCM_W Offset/Fetch=0x%x, 0x%x, FRCM_R Offset=0x%x, FRCM_VLen=%d\n",
7490 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_WOffset,
7491 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_WFetch,
7492 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_ROffset,
7493 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCMVLen
7494 );
7495 #if defined (__aarch64__)
7496 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final u32FRCM_WBase0/1/2=0x%lx, 0x%lx, 0x%lx\n",
7497 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_WBase0,
7498 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_WBase1,
7499 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_WBase2
7500 );
7501 #else
7502 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final u32FRCM_WBase0/1/2=0x%tx, 0x%tx, 0x%tx\n",
7503 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_WBase0,
7504 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_WBase1,
7505 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_WBase2
7506 );
7507 #endif
7508 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"---------------------------------------------------\n");
7509 #endif
7510 }
7511
MDrv_SC_set_frcmrsetting(void * pInstance,XC_InternalStatus * pSrcInfo,MS_PHY u32OneLineOffset,SCALER_WIN eWindow)7512 void MDrv_SC_set_frcmrsetting(void *pInstance, XC_InternalStatus *pSrcInfo, MS_PHY u32OneLineOffset, SCALER_WIN eWindow)
7513 {
7514 #if (HW_DESIGN_4K2K_VER == 4)
7515 MS_U16 u16LBOffset, u16DispOffset, u16FRCM_RFetch, u16FRC_RFetchAlignment;
7516 MS_PHY u32FRCM_RBase0, u32FRCM_RBase1, u32FRCM_RBase2, u32FRCM_RCropOffset =0, u32FRCM_RPixelOffset;
7517 MS_U16 u16AlignWidth=0;
7518 MS_PHY u32BaseOffset = 0;
7519 MS_PHY u32Framesize;
7520 MS_U8 u8BytesPer2Pixel = pSrcInfo->u8BitPerPixel * 2 / 8;
7521 MS_U16 u16FRCM_ROffset = 0;
7522 MS_U8 u8FrameNum = 0;
7523 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
7524 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
7525 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
7526 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
7527 u16FRCM_ROffset = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DNROffset;
7528 u32FRCM_RBase0 = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase0;
7529 u32FRCM_RBase1 = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase1;
7530 u32FRCM_RBase2 = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase2;
7531
7532 u32BaseOffset = pXCResourcePrivate->stdrvXC_Scaling.u32FRCMBaseOffset[eWindow];
7533
7534 if(MDrv_XC_Is_SupportSWDS(pInstance) && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)))
7535 {
7536 u32Framesize = gSrcInfo[eWindow].Status2.u16VirtualBox_Height * (MS_U32)u16FRCM_ROffset * (MS_U32)u8BytesPer2Pixel/2;
7537 }
7538 else
7539 {
7540 u32Framesize = (MS_U32)pSrcInfo->u16V_SizeAfterPreScaling * (MS_U32)u16FRCM_ROffset * (MS_U32)u8BytesPer2Pixel/2;
7541 }
7542
7543 #ifndef DISABLE_3D_FUNCTION
7544 #if (HW_DESIGN_3D_VER >= 2)
7545 if((E_XC_3D_INPUT_FRAME_PACKING == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
7546 && (pSrcInfo->stCapWin.height == DOUBLEHD_1080X2I_VSIZE))
7547 {
7548 //special case, hw will use field size 540 as deinterlace size
7549 u32Framesize /= 2;
7550 }
7551 #if (HW_DESIGN_3D_VER > 2)
7552 else if(E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
7553 {//per designer, input 3d:framealternative will double data at dnr
7554 u32Framesize *= 2;
7555 }
7556 #endif
7557 #endif
7558 #endif
7559
7560 u8FrameNum = MDrv_XC_TransFrameNumToFactor(pInstance, gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
7561 /////////////////////////////////////////////////
7562 // Set FRCM_R Memeory Settings //
7563 /////////////////////////////////////////////////
7564
7565 // Cal FRCM_R Base address
7566
7567 // compute address offset for cropping
7568 // cropping shift h unit: 16 pixel
7569 // v unit: 2 line(for interlace), 1 line(for progressive)
7570 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop info: (x,y)=(%d,%d),(width,height)=(%d,%d), FRCM always progressive\n",
7571 gSrcInfo[eWindow].ScaledCropWin.x, gSrcInfo[eWindow].ScaledCropWin.y,
7572 gSrcInfo[eWindow].ScaledCropWin.width, gSrcInfo[eWindow].ScaledCropWin.height
7573 );
7574
7575 // how to do?
7576 #if 0
7577 if(pSrcInfo->bDisplayNineLattice)
7578 {
7579 if (IsVMirrorMode(eWindow))
7580 {
7581 if(gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_8_FIELDS)
7582 {
7583 u32OPMPixelOffset = (MS_U32)(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height
7584 - (gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))*u16DNROffset;
7585 }
7586 else if( bInterlace )
7587 {
7588 u32OPMPixelOffset = (MS_U32)((pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height
7589 - (gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))/2)*u16DNROffset;
7590 }
7591 else
7592 {
7593 u32OPMPixelOffset = (MS_U32)(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height
7594 - (gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))*u16DNROffset;
7595 }
7596 u32OPMPixelOffset += (MS_U32)(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width
7597 - (gSrcInfo[eWindow].stDispWin.x - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16HStart + gSrcInfo[eWindow].stDispWin.width));
7598 }
7599 else
7600 {
7601 if(gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_8_FIELDS)
7602 {
7603 u32OPMPixelOffset = (MS_U32)((gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))*u16DNROffset;
7604 }
7605 else if( bInterlace )
7606 {
7607 u32OPMPixelOffset = (MS_U32)((gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart)/2)*u16DNROffset;
7608 }
7609 else
7610 {
7611 u32OPMPixelOffset = (MS_U32)((gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))*u16DNROffset;
7612 }
7613 u32OPMPixelOffset += (MS_U32)(gSrcInfo[eWindow].stDispWin.x - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16HStart);
7614 }
7615 }
7616 else
7617 #endif
7618 {
7619 #ifndef DISABLE_3D_FUNCTION
7620 MS_U16 u16FRCM_ROffset3D = u16FRCM_ROffset;
7621 MDrv_SC_3D_Adjust_DNROffset(pInstance, &u16FRCM_ROffset3D,&u16FRCM_ROffset, eWindow);
7622 #endif
7623
7624 if (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow))
7625 {
7626 MS_U32 u32FRCM_Mirror_offset;
7627 u32FRCM_RPixelOffset = (MS_U32) ((gSrcInfo[eWindow].ScaledCropWin.y) * gSrcInfo[eWindow].Status2.u16VirtualBox_Width);
7628 u32FRCM_RPixelOffset += (MS_U32)(gSrcInfo[eWindow].ScaledCropWin.x);
7629
7630 switch(gSrcInfo[(eWindow)].Status2.eMirrorMode)
7631 {
7632 case MIRROR_H_ONLY:
7633 u32FRCM_Mirror_offset = (MS_U32)(gSrcInfo[eWindow].Status2.u16VirtualBox_Width - pSrcInfo->u16H_SizeAfterPreScaling);
7634 break;
7635 case MIRROR_V_ONLY:
7636 u32FRCM_Mirror_offset = (MS_U32) ((gSrcInfo[eWindow].Status2.u16VirtualBox_Height - pSrcInfo->u16V_SizeAfterPreScaling) * gSrcInfo[eWindow].Status2.u16VirtualBox_Width);
7637 break;
7638 case MIRROR_HV:
7639 u32FRCM_Mirror_offset = (MS_U32) ((gSrcInfo[eWindow].Status2.u16VirtualBox_Height - pSrcInfo->u16V_SizeAfterPreScaling) * gSrcInfo[eWindow].Status2.u16VirtualBox_Width);
7640 u32FRCM_Mirror_offset += (MS_U32)(gSrcInfo[eWindow].Status2.u16VirtualBox_Width - pSrcInfo->u16H_SizeAfterPreScaling);
7641 break;
7642 default:
7643 u32FRCM_Mirror_offset = 0;
7644 break;
7645 }
7646 u32FRCM_RPixelOffset += u32FRCM_Mirror_offset;
7647 }
7648 else
7649 {
7650 u32FRCM_RPixelOffset = (MS_U32)((gSrcInfo[eWindow].ScaledCropWin.y) * u16FRCM_ROffset3D);
7651 u32FRCM_RPixelOffset += (MS_U32)(gSrcInfo[eWindow].ScaledCropWin.x);
7652
7653 if (IsHMirrorMode(eWindow) && pSrcInfo->bMemFmt422)
7654 {
7655 #ifndef DISABLE_3D_FUNCTION
7656 MDrv_SC_3D_Adjust_PixelOffset(pInstance, pSrcInfo,&u32FRCM_RPixelOffset,&u16FRCM_ROffset,&u16FRCM_ROffset3D, TRUE, eWindow);
7657 #else
7658 u32FRCM_RPixelOffset += (u16FRCM_ROffset - pSrcInfo->u16H_SizeAfterPreScaling);
7659 #endif
7660 }
7661 }
7662 }
7663
7664 #if defined (__aarch64__)
7665 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop total offset pixel counts %ld\n",u32FRCM_RPixelOffset);
7666 #else
7667 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop total offset pixel counts %td\n",(ptrdiff_t)u32FRCM_RPixelOffset);
7668 #endif
7669
7670 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop info: (x,y)=(%d,%d),(width,height)=(%d,%d)\n",
7671 gSrcInfo[eWindow].ScaledCropWin.x, gSrcInfo[eWindow].ScaledCropWin.y,
7672 gSrcInfo[eWindow].ScaledCropWin.width, gSrcInfo[eWindow].ScaledCropWin.height
7673 );
7674 // calculate LB offset
7675 u16LBOffset = u32FRCM_RPixelOffset % OFFSET_PIXEL_ALIGNMENT; // these pixels rely on line buffer offset
7676 // line buffer need to check.
7677 gSrcInfo[eWindow].Status2.u16LBOffset = u16LBOffset;
7678 u32FRCM_RPixelOffset -= u16LBOffset; // these pixels rely on base offset
7679
7680 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"LB offset %d, Pixel offset %d Alighment: %d bytes \n", u16LBOffset, (int)u32FRCM_RPixelOffset,OFFSET_PIXEL_ALIGNMENT);
7681
7682 // calcuate FRCM_R offset
7683 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"eFRCMFrameStoreNumber %d\n", (gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber));
7684
7685 u32FRCM_RPixelOffset *= MDrv_XC_TransFrameNumToFactor(pInstance, gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
7686 #ifdef K3_U2
7687 if(Hal_SC_IsPX2MemFormat(pInstance, eWindow))
7688 {
7689 u32FRCM_RPixelOffset *= 2;
7690 }
7691 #endif
7692 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"bLinearMode = %s\n",gSrcInfo[eWindow].bLinearMode ?("TRUE"):("FALSE"));
7693 #if defined (__aarch64__)
7694 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop total offset pixel counts for field/frame %ld (eFRCMFrameStoreNumber: %d)\n", u32FRCM_RPixelOffset, gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber);
7695 #else
7696 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop total offset pixel counts for field/frame %td (eFRCMFrameStoreNumber: %d)\n", (ptrdiff_t)u32FRCM_RPixelOffset, gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber);
7697 #endif
7698
7699 if(u32FRCM_RPixelOffset != 0)
7700 {
7701 MS_U8 u8BytesPer2PixelTemp = u8BytesPer2Pixel;
7702 #ifndef DISABLE_3D_FUNCTION
7703 MDrv_SC_3D_Adjust_BytesPer2Pixel(pInstance, &u8BytesPer2PixelTemp,eWindow);
7704 #endif
7705 u32FRCM_RCropOffset = u32FRCM_RPixelOffset * u8BytesPer2PixelTemp / 2 / BYTE_PER_WORD;
7706 #ifdef _FIELD_PACKING_MODE_SUPPORTED_MULTIPLE_TEMP
7707 //Attention, this is for temp solve crop address offset error in Kappa. Remove this if Kappa code flow has refined.
7708 printf("[Kappa_temp_patch] u32FRCM_RCropOffset*=2\n");
7709 u32FRCM_RCropOffset *= 2;
7710 #endif
7711 }
7712
7713
7714 #if defined (__aarch64__)
7715 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"f.LineBuf offset %d, u32FRCM_RCropOffset 0x%lx\n", u16LBOffset, u32FRCM_RCropOffset);
7716 #else
7717 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"f.LineBuf offset %d, u32FRCM_RCropOffset 0x%tx\n", u16LBOffset, (ptrdiff_t)u32FRCM_RCropOffset);
7718 #endif
7719
7720 //KT: T3 PIP HW issue, When SUB ON, the HW operation will decrease "u16LBOffset" 2 times.
7721
7722 MS_U16 CropWinWidthTemp = gSrcInfo[eWindow].ScaledCropWin.width;
7723 #ifndef DISABLE_3D_FUNCTION
7724 MDrv_SC_3D_Adjust_CropWinWidth(pInstance, &CropWinWidthTemp,eWindow);
7725 #endif
7726 u16FRCM_RFetch = CropWinWidthTemp + u16LBOffset; // using LBOffset still need to add some points to avoid generating garbage
7727
7728 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u16FRCM_RFetch:%d \n", u16FRCM_RFetch);
7729
7730 if(pSrcInfo->bDisplayNineLattice) // for display ninelattice no line buffer offset
7731 {
7732 u16LBOffset = u16DispOffset=0;
7733 u16FRCM_RFetch = (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width + 1) & ~0x1;
7734 #ifdef K3_U2
7735 u16FRCM_RFetch += HW_PIP_BUG_SW_PATCH_FETCH_INCREASE; // - For HW Bug in PIP when the gap between H-end of sub window and H-end of main window is too small
7736 #endif
7737 }
7738 else
7739 {
7740 // IPM offset / IPM fetch /OPM offset: All project --> 32pix align
7741 // OPM fetch:
7742 // Janus /T7 --> 32pix align
7743 // Others ( T8/T9/T12/T13/m10/J2 ) --> 2pix align
7744 MS_U16 u16tempFRCM_R;
7745
7746 if((u16LBOffset & 0x1) != 0)
7747 {
7748 //HW issue for OPM fetch&422to444: when lboffset not even, OPM should add 2 to avoid right line garbage
7749 u16tempFRCM_R = (( u16FRCM_RFetch + 1 ) & ~1) + 2;
7750 if(u16tempFRCM_R > pSrcInfo->u16H_SizeAfterPreScaling - (gSrcInfo[eWindow].ScaledCropWin.x - u16LBOffset))
7751 {
7752 u16LBOffset--;//Overflow, set lb offset even and alignment OPM
7753 u16FRCM_RFetch = u16FRCM_RFetch & ~1; //Make even directly, since lb offset has minus 1
7754 }
7755 else
7756 {
7757 u16FRCM_RFetch = u16tempFRCM_R;
7758 }
7759 }
7760 else if((u16FRCM_RFetch != gSrcInfo[eWindow].u16IPMFetch) && (E_XC_3D_OUTPUT_MODE_NONE == MDrv_XC_Get_3D_Output_Mode(pInstance)))
7761 {
7762 //UCDi need grab six more pixels, not 3D case.(a7p need 6 more, others need 2 more)
7763 u16tempFRCM_R = (( u16FRCM_RFetch + 1 ) & ~1) + 6;
7764 if(u16tempFRCM_R > pSrcInfo->u16H_SizeAfterPreScaling - (gSrcInfo[eWindow].ScaledCropWin.x - u16LBOffset))
7765 {
7766 u16FRCM_RFetch = u16FRCM_RFetch & ~1;
7767 }
7768 else
7769 {
7770 u16FRCM_RFetch = u16tempFRCM_R;
7771 }
7772 }
7773 else
7774 {
7775 u16FRCM_RFetch = ( u16FRCM_RFetch + 1 ) & ~1; // pixels alignment
7776 }
7777 #ifdef K3_U2
7778 u16FRCM_RFetch += HW_PIP_BUG_SW_PATCH_FETCH_INCREASE; // - For HW Bug in PIP when the gap between H-end of sub window and H-end of main window is too small
7779 #endif
7780 if (!pSrcInfo->bMemFmt422)
7781 {
7782 u16FRC_RFetchAlignment = (u16FRCM_RFetch + (OFFSET_PIXEL_ALIGNMENT - 1)) & ~(OFFSET_PIXEL_ALIGNMENT - 1);
7783 //HW issue for OPM fetch when OP write enable, OPM Fetch have to offset pixels alignment avoid green garbage .
7784 if(pSrcInfo->u16H_SizeAfterPreScaling >= (u16FRC_RFetchAlignment+gSrcInfo[eWindow].ScaledCropWin.x - u16LBOffset))
7785 {
7786 u16FRCM_RFetch = u16FRC_RFetchAlignment;
7787 }
7788 else
7789 {
7790 //Overflow, set the OPM Fetch to the max data area .
7791 u16FRCM_RFetch = pSrcInfo->u16H_SizeAfterPreScaling - gSrcInfo[eWindow].ScaledCropWin.x + u16LBOffset;
7792 u16FRCM_RFetch = u16FRCM_RFetch & ~1;
7793 }
7794 }
7795 else
7796 {
7797 if(2200>=u16FRCM_RFetch) //Nike 4k2k opm fetch can't do ALIGNMENT
7798 {
7799 #ifdef OPMFETCH_PIXEL_ALIGNMENT
7800 u16FRCM_RFetch = (u16FRCM_RFetch + (OPMFETCH_PIXEL_ALIGNMENT - 1)) & ~(OPMFETCH_PIXEL_ALIGNMENT - 1);
7801 #else
7802 u16FRCM_RFetch = (u16FRCM_RFetch + (OFFSET_PIXEL_ALIGNMENT - 1)) & ~(OFFSET_PIXEL_ALIGNMENT - 1);
7803 #endif
7804 }
7805 }
7806
7807 #ifndef DISABLE_3D_FUNCTION
7808 if(MDrv_SC_3D_Is2Dto3DCase(pInstance, MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow), MDrv_XC_Get_3D_Output_Mode(pInstance)))
7809 {
7810 MS_U16 u16HShift = MDrv_XC_Get_3D_HShift(pInstance);
7811 if ((u16FRCM_RFetch + u16HShift) > gSrcInfo[eWindow].u16IPMFetch)
7812 {
7813 if(gSrcInfo[eWindow].u16IPMFetch > u16HShift)
7814 {
7815 //opmfetch need align although ipmfetch may not need align
7816 u16FRCM_RFetch = ( gSrcInfo[eWindow].u16IPMFetch - u16HShift + 1 ) & ~1;
7817 }
7818 else
7819 {
7820 u16FRCM_RFetch = 0;
7821 }
7822 }
7823 }
7824 else
7825 #endif
7826 {
7827 if(u16FRCM_RFetch > pSrcInfo->u16H_SizeAfterPreScaling - (gSrcInfo[eWindow].ScaledCropWin.x - u16LBOffset))
7828 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"!!!Alert u16FRCM_RFetch(%u) Overflowed, check crop setting!!!\n", u16FRCM_RFetch);
7829 }
7830 }
7831
7832 #ifdef K3_U2
7833 // - For HW Bug in PIP when the gap between H-end of sub window and H-end of main window is too small
7834 if(eWindow == MAIN_WINDOW)
7835 {
7836 if (u16FRCM_RFetch > MST_LINE_BFF_MAX)
7837 {
7838 u16FRCM_RFetch = MST_LINE_BFF_MAX;
7839 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Re-assign OPM fetch as %lu due to HW limitation \n", MST_LINE_BFF_MAX);
7840 }
7841 }
7842 else
7843 {
7844 if(u16FRCM_RFetch > SUB_MST_LINE_BFF_MAX)
7845 {
7846 u16FRCM_RFetch = SUB_MST_LINE_BFF_MAX;
7847 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Re-assign OPM fetch as %lu due to HW limitation \n", SUB_MST_LINE_BFF_MAX);
7848 }
7849 }
7850 #endif
7851
7852 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"f1. u16FRCM_RFetch after alignment %d, lboffset %d \n", u16FRCM_RFetch, u16LBOffset);
7853 //printf("1.SC Crop width=0x%x, LBOffset=0x%x\n", gSrcInfo[eWindow].ScaledCropWin.width, u16LBOffset);
7854 u16DispOffset = 0;
7855
7856 //printf("cropy=%u,cropx=%u,dnroffset=%u,bp2p=%bu\n", _stScaledCropWin.y, _stScaledCropWin.x, u16DNROffset, u8BytesPer2Pixel);
7857 //printf("2.OPM Crop Offset=0x%lx, LBOffset=0x%x\n", u32OPMCropOffset, u16LBOffset);
7858
7859 // adjsut OPMBase address for cropping
7860 if(pSrcInfo ->bDisplayNineLattice)
7861 {
7862 // for linear mode set all base address the same
7863 u32FRCM_RBase0 += u32FRCM_RCropOffset;
7864 //u32DNRBase1 += u32OPMCropOffset;
7865 //u32OPMBase2 += u32OPMCropOffset;
7866 u32FRCM_RBase2 = u32FRCM_RBase1 = u32FRCM_RBase0;
7867 //printf("--u32DNRBase0 %lx\n",u32DNRBase0);
7868 }
7869 else
7870 {
7871 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"h.=> u32FRCM_RBase0,1=%x,%x -> +u32FRCM_RCropOffset[%x] =",(int)u32FRCM_RBase0,(int)u32FRCM_RBase1,(int)u32FRCM_RCropOffset);
7872 u32FRCM_RBase0 += u32FRCM_RCropOffset;
7873 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"0:%x \n",(int)u32FRCM_RBase0);
7874 u32FRCM_RBase1 += u32FRCM_RCropOffset;
7875 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"1:%x \n",(int)u32FRCM_RBase1);
7876 u32FRCM_RBase2 += u32FRCM_RCropOffset;
7877 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"2:%x \n",(int)u32FRCM_RBase2);
7878 }
7879
7880 #if SUPPORT_2_FRAME_MIRROR
7881
7882 MS_S32 s32cropshift_base0;
7883 MS_S32 s32cropshift_base1;
7884 MS_U32 u32LBOffset_mirror;
7885
7886 s32cropshift_base0 = gSrcInfo[eWindow].ScaledCropWin.y * (MS_S32) (pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_WOffset) + gSrcInfo[eWindow].ScaledCropWin.x;
7887 s32cropshift_base1 = - gSrcInfo[eWindow].ScaledCropWin.y * (MS_S32) (pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_WOffset) + gSrcInfo[eWindow].ScaledCropWin.x;
7888
7889 u32LBOffset_mirror = gSrcInfo[eWindow].ScaledCropWin.x % OFFSET_PIXEL_ALIGNMENT;
7890
7891 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"[SUPPORT_2_FRAME_MIRROR] u32LBOffset:%d \n",u32LBOffset_mirror);
7892
7893 s32cropshift_base0 = ( s32cropshift_base0 - u32LBOffset_mirror ) * (MS_U32) MDrv_XC_TransFrameNumToFactor(gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
7894 s32cropshift_base1 = ( s32cropshift_base1 - u32LBOffset_mirror ) * (MS_U32) MDrv_XC_TransFrameNumToFactor(gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
7895
7896 s32cropshift_base0 = ( s32cropshift_base0 * (MS_U32)(pSrcInfo->u8BitPerPixel/8) ) / (MS_U32)(BYTE_PER_WORD);
7897 s32cropshift_base1 = ( s32cropshift_base1 * (MS_U32)(pSrcInfo->u8BitPerPixel/8) ) / (MS_U32)(BYTE_PER_WORD);
7898
7899 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"[SUPPORT_2_FRAME_MIRROR] s32cropshift_base0:%d s32cropshift_base1:%d \n", s32cropshift_base0,s32cropshift_base1);
7900
7901 if (gSrcInfo[eWindow].Status2.eFRCMFrameStoreNumber == IMAGE_STORE_2_FRAMES)
7902 {
7903 u32FRCM_RBase0 = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_WBase0 + s32cropshift_base0;
7904 u32FRCM_RBase1 = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_WBase1 + s32cropshift_base1;
7905 }
7906
7907 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"[SUPPORT_2_FRAME_MIRROR] u32FRCM_RBase0:%x u32FRCM_RBase1:%x \n", (int)u32FRCM_RBase0,(int)u32FRCM_RBase1);
7908
7909 #endif
7910
7911 //-----------------------------------------------------------------
7912 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16LBOffset = u16LBOffset;
7913 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DispOffset = u16DispOffset;
7914
7915
7916 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase0 = u32FRCM_RBase0;
7917 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase1 = u32FRCM_RBase1;
7918 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase2 = u32FRCM_RBase2;
7919 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_RFetch = u16FRCM_RFetch;
7920 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16AlignWidth = u16AlignWidth;
7921 //-----------------------------------------------------------------
7922 #if defined (__aarch64__)
7923 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final FRCM_R Fetch=0x%x, u32FRCM_RBase0/1/2=0x%lx, 0x%lx, 0x%lx\n",
7924 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_RFetch,
7925 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase0,
7926 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase1,
7927 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase2);
7928 #else
7929 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final FRCM_R Fetch=0x%x, u32FRCM_RBase0/1/2=0x%tx, 0x%tx, 0x%tx\n",
7930 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16FRCM_RFetch,
7931 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase0,
7932 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase1,
7933 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32FRCM_RBase2);
7934 #endif
7935 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"---------------------------------------------------\n");
7936 #endif
7937 }
7938
7939 /******************************************************************************/
7940 ///This function will calculate:
7941 // [DNR]
7942 // DNROffset, DNRFetch, DNRBase1, u32WritelimitBase
7943 // [OPM]
7944 // OPMFetch, OPMBase0, OPMBase1, LBOffset
7945 // [OP1]
7946 // u16VLen
7947 /******************************************************************************/
MDrv_SC_set_frcm_fetch_number_limit(void * pInstance,XC_InternalStatus * pSrcInfo,SCALER_WIN eWindow)7948 void MDrv_SC_set_frcm_fetch_number_limit(void *pInstance, XC_InternalStatus *pSrcInfo, SCALER_WIN eWindow)
7949 {
7950 MS_PHY u32OneLineOffset = 0;
7951 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
7952 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
7953 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
7954 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
7955
7956 MDrv_SC_set_ipmsetting(pInstance, pSrcInfo, eWindow);
7957 #if (HW_DESIGN_4K2K_VER != 4)
7958 MDrv_SC_set_dnrsetting(pInstance, pSrcInfo, TRUE, &u32OneLineOffset, TRUE, eWindow);
7959 MDrv_SC_set_opmsetting(pInstance, pSrcInfo, TRUE, TRUE, u32OneLineOffset, eWindow);
7960 #else
7961 if (eWindow == MAIN_WINDOW)
7962 {
7963 MDrv_SC_SwitchFRCMWriteBank(pInstance, FALSE, E_XC_IPM_CONNETC_MAIN_OPM);
7964 }
7965 else
7966 {
7967 MDrv_SC_SwitchFRCMWriteBank(pInstance, FALSE, E_XC_IPM_CONNETC_SUB_OPM);
7968 }
7969 if (((psXCInstPri->u32DeviceID == 0) && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_LEGACY_MODE))
7970 ||(psXCInstPri->u32DeviceID == 1))
7971 {
7972 MDrv_SC_set_dnrsetting(pInstance, pSrcInfo, TRUE, &u32OneLineOffset, TRUE, eWindow);
7973 MDrv_SC_set_opmsetting(pInstance, pSrcInfo, TRUE, TRUE, u32OneLineOffset, eWindow);
7974 }
7975 else if (IS_INPUT_4K2K(eWindow)||IS_INPUT_4K1K(eWindow)
7976 ||((pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_SAVE_MEM_MODE)&&(gSrcInfo[eWindow].stCapWin.width > 1900)&&(gSrcInfo[eWindow].stCapWin.height>2100)&&(gSrcInfo[eWindow].stCapWin.height<2200)))
7977 {
7978 if ((eWindow == MAIN_WINDOW)&&(MDrv_ReadByte(REG_CHIP_REVISION) < 2)&&(MDrv_XC_GetDynamicScalingStatus(pInstance)||MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow) ))//Monaco U03 fix .
7979 {
7980 MDrv_SC_SwitchFRCMWriteBank(pInstance, TRUE, E_XC_IPM_CONNETC_MAIN_FRCM);
7981 }
7982
7983 if (gSrcInfo[eWindow].enPreStreamFlow != E_XC_DIRECT_FRCM)
7984 {
7985 MDrv_SC_set_mirrorEx(pInstance, gSrcInfo[eWindow].Status2.eMirrorMode, eWindow);
7986 gSrcInfo[eWindow].enPreStreamFlow = E_XC_DIRECT_FRCM;
7987 }
7988 MDrv_SC_set_dnrsetting(pInstance, pSrcInfo, FALSE, &u32OneLineOffset, TRUE, eWindow);
7989 MDrv_SC_set_frcmrsetting(pInstance, pSrcInfo, u32OneLineOffset, eWindow);
7990 }
7991 // for DS VB size 4k2k p mode-> bypass mode
7992 else if(((gSrcInfo[eWindow].Status2.u16VirtualBox_Width >= 0xF00) && (gSrcInfo[eWindow].Status2.u16VirtualBox_Height>= 0x870))
7993 && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow) )&& (!gSrcInfo[eWindow].bInterlace))
7994 {
7995 if ( (eWindow == MAIN_WINDOW) && (MDrv_ReadByte(REG_CHIP_REVISION) < 2 ))//Monaco U03 fix .
7996 {
7997 MDrv_SC_SwitchFRCMWriteBank(pInstance, TRUE, E_XC_IPM_CONNETC_MAIN_FRCM);
7998 }
7999 MDrv_SC_set_dnrsetting(pInstance, pSrcInfo, FALSE, &u32OneLineOffset, TRUE, eWindow);
8000 MDrv_SC_set_frcmrsetting(pInstance, pSrcInfo, u32OneLineOffset, eWindow);
8001 }
8002 else//DS i mode -> monaco mode
8003 {
8004 if (eWindow == MAIN_WINDOW && (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow) ) && (MDrv_ReadByte(REG_CHIP_REVISION) < 2 ))//Monaco U03 fix .
8005 {
8006 MDrv_SC_SwitchFRCMWriteBank(pInstance, TRUE, E_XC_IPM_CONNETC_MAIN_FRCM);
8007 }
8008 if (gSrcInfo[eWindow].enPreStreamFlow != E_XC_SCM_TO_FRCM)
8009 {
8010 MDrv_SC_set_mirrorEx(pInstance, gSrcInfo[eWindow].Status2.eMirrorMode, eWindow);
8011 gSrcInfo[eWindow].enPreStreamFlow = E_XC_SCM_TO_FRCM;
8012 }
8013 MDrv_SC_set_dnrsetting(pInstance, pSrcInfo, TRUE, &u32OneLineOffset, FALSE, eWindow);
8014 MDrv_SC_set_opmsetting(pInstance, pSrcInfo, FALSE, FALSE, u32OneLineOffset, eWindow);
8015 MDrv_SC_set_frcmwsetting(pInstance, pSrcInfo, &u32OneLineOffset, eWindow);
8016 MDrv_SC_set_frcmrsetting(pInstance, pSrcInfo, u32OneLineOffset, eWindow);
8017 }
8018 #endif
8019
8020 #ifndef DISABLE_3D_FUNCTION
8021 MDrv_SC_3D_Adjust_FetchOffset(pInstance, pSrcInfo, eWindow);
8022 #endif
8023
8024 #ifdef ENABLE_SCALING_WO_MUTE
8025 MDrv_SC_Adjust_Skip_OPM_line(pInstance, eWindow);
8026 #endif
8027 }
8028
8029 /******************************************************************************/
8030 ///This function will calculate:
8031 // [DNR]
8032 // DNROffset, DNRFetch, DNRBase1, u32WritelimitBase
8033 // [OPM]
8034 // OPMFetch, OPMBase0, OPMBase1, LBOffset
8035 // [OP1]
8036 // u16VLen
8037 // bBwdEnable: Weather caculator fetch/offset for bwd
8038 // bIsLeftFactor: Under miu dual mode
8039 // TRUE call for Left side calc, FALSE call for right side calc
8040 /******************************************************************************/
_MDrv_SC_set_fetch_number_limit_impl(void * pInstance,XC_InternalStatus * pSrcInfo,MS_U8 u8BitPerPixel,MS_BOOL bBwdEnable,MS_BOOL bIsLeftFactor,SCALER_WIN eWindow)8041 static void _MDrv_SC_set_fetch_number_limit_impl(void *pInstance, XC_InternalStatus *pSrcInfo, MS_U8 u8BitPerPixel, MS_BOOL bBwdEnable, MS_BOOL bIsLeftFactor, SCALER_WIN eWindow)
8042 {
8043 MS_U16 u16V_Writelimit, u16LBOffset, u16DispOffset, u16OPMFetch, u16OPMFetchAlignment;
8044 MS_PHY u32Offset, u32DNRBase0, u32DNRBase1, u32DNRBase2, u32WritelimitBase=0;
8045 MS_PHY u32OPMBase0, u32OPMBase1, u32OPMBase2, u32OPMCropOffset =0, u32OPMPixelOffset;
8046 MS_BOOL bInterlace = pSrcInfo->bInterlace;
8047 MS_U16 u16AlignWidth = 0;
8048 MS_PHY u32BaseOffset = 0;
8049 MS_PHY u32Framesize;
8050 MS_U8 u8BytesPer2Pixel = u8BitPerPixel * 2 / 8;
8051 MS_U16 u16DNROffset = 0;
8052 MS_PHY u32OneLineOffset = 0;
8053 MS_U8 u8FrameNum = 0;
8054 MS_U16 u16H_SizeAfterPreScaling = pSrcInfo->u16H_SizeAfterPreScaling;
8055 MS_U16 u16DNROffsetFor3D = 0;
8056 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
8057 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
8058 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
8059 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
8060 //TODO: buffer addr for sub win
8061 //printf("MDrv_SC_set_fetch_number_limit %d \n",u8BytesPer2Pixel );
8062 /////////////////////////////////////////////////
8063 // Set DNR Memeory Settings //
8064 /////////////////////////////////////////////////
8065 // Cal DNR Fetch/Offset
8066 MS_U16 *pu16IPMFetch = NULL;
8067 MS_PHY u32MsIPMBase0 = 0;
8068 MS_PHY u32DNRBufSize[MAX_WINDOW];
8069 memset(&u32DNRBufSize, 0, sizeof(u32DNRBufSize));
8070 #ifdef SUPPORT_BWD
8071 E_XC_BWR_MEM_CFG_BPP_TYPE eBPPType = E_XC_BWR_MEM_CFG_BPP_24;
8072 #endif
8073 #ifdef UFO_XC_SUPPORT_DUAL_MIU
8074 MS_U32 u32LeftFactor = 0;
8075 MS_U32 u32RightFactor = 0;
8076
8077 if (IsEnableDualMode(eWindow))
8078 {
8079 #if (SUPPORT_DUAL_MIU_MIRROR_SWAP_IPM == TRUE)
8080 // Miu dual mode just Mirror Case need swap IPM. And disable dual must not swap IPM.
8081 // So, add IPM write limit in this function.
8082 if (IsHMirrorMode(eWindow))
8083 {
8084 if(bIsLeftFactor == TRUE)
8085 {
8086 u32MsIPMBase0 = MS_IPM_DUAL_MIU_BASE0(eWindow);
8087 Hal_SC_AdjustIpmWriteLimite(pInstance, TRUE, TRUE, eWindow);
8088 }
8089 else
8090 {
8091 u32MsIPMBase0 = MS_IPM_BASE0(eWindow);
8092 Hal_SC_AdjustIpmWriteLimite(pInstance, FALSE, TRUE, eWindow);
8093 }
8094 }
8095 else
8096 {
8097 if(bIsLeftFactor == TRUE)
8098 {
8099 u32MsIPMBase0 = MS_IPM_BASE0(eWindow);
8100 Hal_SC_AdjustIpmWriteLimite(pInstance, TRUE, FALSE, eWindow);
8101 }
8102 else
8103 {
8104 u32MsIPMBase0 = MS_IPM_DUAL_MIU_BASE0(eWindow);
8105 Hal_SC_AdjustIpmWriteLimite(pInstance, FALSE, FALSE, eWindow);
8106 }
8107 }
8108 #else
8109 if(bIsLeftFactor == FALSE)
8110 {
8111 u32MsIPMBase0 = MS_IPM_DUAL_MIU_BASE0(eWindow);
8112 }
8113 else
8114 {
8115 u32MsIPMBase0 = MS_IPM_BASE0(eWindow);
8116 }
8117 #endif
8118 }
8119 else
8120 #endif
8121 {
8122 u32MsIPMBase0 = MS_IPM_BASE0(eWindow);
8123 #ifdef UFO_XC_SUPPORT_DUAL_MIU // Monet & Manhattan
8124 #if (SUPPORT_DUAL_MIU_MIRROR_SWAP_IPM == TRUE) // Just Manhattan
8125 Hal_SC_AdjustIpmWriteLimite(pInstance, TRUE, FALSE, eWindow);
8126 #endif
8127 #endif
8128 }
8129
8130 //To avoid pu16IPMFetch do not entry any condition and Dereferencing null pointer
8131 //We set a init point here
8132 pu16IPMFetch = &gSrcInfo[eWindow].u16IPMFetch;
8133 if (bIsLeftFactor == TRUE)
8134 {
8135 u32DNRBufSize[eWindow] = pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow];
8136 pu16IPMFetch = &gSrcInfo[eWindow].u16IPMFetch;
8137 }
8138 #ifdef UFO_XC_SUPPORT_DUAL_MIU
8139 else //if (IsEnableDualMode(eWindow))
8140 {
8141 u32DNRBufSize[eWindow] = pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBufSize[eWindow];
8142 pu16IPMFetch = &gSrcInfo[eWindow].Status2.u16DualMiuIPMFetch;
8143 }
8144 #endif
8145 *pu16IPMFetch = pSrcInfo->u16H_SizeAfterPreScaling;
8146 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"===================================================\n");
8147 if (bIsLeftFactor == TRUE)
8148 {
8149 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u16DNRFetch=%d ->",(int)*pu16IPMFetch);
8150 }
8151 else
8152 {
8153 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u16DualMiuDNRFetch=%d ->",(int)*pu16IPMFetch);
8154 }
8155 //#if (HW_IPM_FETCH_ALIGNMENT==FALSE)
8156 if ((pSrcInfo->bMemFmt422)
8157 #ifdef UFO_XC_SUPPORT_DUAL_MIU
8158 && (!IsEnableDualMode(eWindow))
8159 #endif
8160 )
8161 *pu16IPMFetch = (*pu16IPMFetch + (OFFSET_PIXEL_ALIGNMENT - 1)) & ~(OFFSET_PIXEL_ALIGNMENT - 1);
8162 //#endif
8163 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC," %d \n",(int)*pu16IPMFetch);
8164 MS_U16 *pu16IPMFetchTmp = NULL;
8165 if(eWindow == MAIN_WINDOW)
8166 {
8167 pu16IPMFetchTmp = &gSrcInfo[MAIN_WINDOW].u16IPMFetch;
8168 #ifdef UFO_XC_SUPPORT_DUAL_MIU
8169 if (bIsLeftFactor == FALSE)
8170 {
8171 pu16IPMFetchTmp = &gSrcInfo[MAIN_WINDOW].Status2.u16DualMiuIPMFetch;
8172 }
8173 #endif
8174 if (*pu16IPMFetchTmp > MST_LINE_BFF_MAX)
8175 {
8176 *pu16IPMFetchTmp = MST_LINE_BFF_MAX;
8177 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Re-assign IPM fetch as %lu due to HW limitation \n", MST_LINE_BFF_MAX);
8178 }
8179 }
8180 else
8181 {
8182 pu16IPMFetchTmp = &gSrcInfo[SUB_WINDOW].u16IPMFetch;
8183 #ifdef UFO_XC_SUPPORT_DUAL_MIU
8184 if (bIsLeftFactor == FALSE)
8185 {
8186 pu16IPMFetchTmp = &gSrcInfo[SUB_WINDOW].Status2.u16DualMiuIPMFetch;
8187 }
8188 #endif
8189 #if (HW_DESIGN_3D_VER < 2)
8190 #ifndef DISABLE_3D_FUNCTION
8191 if(MDrv_SC_3D_IsIPMFetchNoLimitCase(pInstance, eWindow))
8192 {
8193 //no any limits
8194 }
8195 else if((E_XC_3D_OUTPUT_TOP_BOTTOM == MDrv_XC_Get_3D_Output_Mode(pInstance))
8196 || (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF == MDrv_XC_Get_3D_Output_Mode(pInstance))
8197 || (E_XC_3D_OUTPUT_TOP_BOTTOM_HW == MDrv_XC_Get_3D_Output_Mode(pInstance))
8198 || (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF_HW == MDrv_XC_Get_3D_Output_Mode(pInstance))
8199 )
8200 {
8201 if(*pu16IPMFetchTmp > MS_3D_LINE_BFF_MAX)
8202 {
8203 *pu16IPMFetchTmp = MS_3D_LINE_BFF_MAX;
8204 }
8205 }
8206 else
8207 #endif
8208 if (*pu16IPMFetchTmp > SUB_MST_LINE_BFF_MAX)
8209 #else
8210 #ifndef DISABLE_3D_FUNCTION
8211 if((E_XC_3D_PANEL_NONE == MDrv_XC_Get_3D_Panel_Type(pInstance))
8212 &&(*pu16IPMFetchTmp > SUB_MST_LINE_BFF_MAX))
8213 #endif
8214 {
8215 #if (PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB == 0)
8216 //Normal PIP case
8217 *pu16IPMFetchTmp = SUB_MST_LINE_BFF_MAX;
8218 #endif
8219 }
8220 #endif
8221 }
8222 #ifdef UFO_XC_SUPPORT_DUAL_MIU
8223 // Double check Dual enable
8224 if (IsEnableDualMode(eWindow))
8225 {
8226 u32LeftFactor = pSrcInfo->Status2.stMiuDualModCfg.u32LeftFactor;
8227 u32RightFactor = pSrcInfo->Status2.stMiuDualModCfg.u32RightFactor;
8228 MS_U16 u16IPMFetchTotal = *pu16IPMFetch;
8229
8230 if (IsHMirrorMode(eWindow))
8231 {
8232 *pu16IPMFetch = u16IPMFetchTotal*u32RightFactor /(u32RightFactor + u32LeftFactor);
8233 *pu16IPMFetch = (*pu16IPMFetch + (OFFSET_PIXEL_ALIGNMENT*2 - 1)) & ~(OFFSET_PIXEL_ALIGNMENT*2 - 1);
8234 gSrcInfo[eWindow].u16IPMFetch = u16IPMFetchTotal - *pu16IPMFetch;
8235 gSrcInfo[eWindow].Status2.u16DualMiuIPMFetch = *pu16IPMFetch;
8236 }
8237 else
8238 {
8239 // No mirror, Calc Left Side firstly.
8240 *pu16IPMFetch = u16IPMFetchTotal*u32LeftFactor /(u32RightFactor + u32LeftFactor);
8241 *pu16IPMFetch = (*pu16IPMFetch + (OFFSET_PIXEL_ALIGNMENT*2 - 1)) & ~(OFFSET_PIXEL_ALIGNMENT*2 - 1);
8242 gSrcInfo[eWindow].u16IPMFetch = *pu16IPMFetch;
8243 gSrcInfo[eWindow].Status2.u16DualMiuIPMFetch = u16IPMFetchTotal - *pu16IPMFetch;
8244 }
8245 }
8246 #endif
8247
8248 //printf("==>NineLattice = %x, bMirror = %x\n", pSrcInfo->bDisplayNineLattice,IsVMirrorMode(eWindow));
8249
8250 if(pSrcInfo->bDisplayNineLattice)
8251 {
8252 u16DNROffset = (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width + OFFSET_PIXEL_ALIGNMENT - 1) & ~(OFFSET_PIXEL_ALIGNMENT-1); //TODO: T3 should be 32 alignment
8253 }
8254 else
8255 {
8256 if((MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow)) &&
8257 (!IsSrcTypeHDMI(gSrcInfo[eWindow].enInputSourceType)))
8258 {
8259 u16DNROffset = (gSrcInfo[eWindow].Status2.u16VirtualBox_Width + OFFSET_PIXEL_ALIGNMENT - 1) & ~(OFFSET_PIXEL_ALIGNMENT-1);
8260 #ifdef UFO_XC_SUPPORT_DUAL_MIU
8261 #ifdef XC_DUAL_MIU_SUPPORT_DS
8262 // EnableDS: u16DNROffset equals u16VirtualBox_Width, so for dual miu need devided dnr_offset for left and right view.
8263 if (IsEnableDualMode(eWindow))
8264 {
8265 MS_U16 u16OffsetTotal = u16DNROffset;
8266 // Mirror, Calc Left Side firstly.
8267 if (IsHMirrorMode(eWindow))
8268 {
8269 u16DNROffset = u16DNROffset*u32RightFactor /(u32RightFactor + u32LeftFactor);
8270 u16DNROffset = (u16DNROffset + (OFFSET_PIXEL_ALIGNMENT*2 - 1)) & ~(OFFSET_PIXEL_ALIGNMENT*2 - 1);
8271 if (bIsLeftFactor == TRUE)
8272 {
8273 u16DNROffset = u16OffsetTotal - u16DNROffset;
8274 }
8275 }
8276 else // No mirror, Calc Left Side firstly.
8277 {
8278 u16DNROffset = u16DNROffset*u32LeftFactor /(u32RightFactor + u32LeftFactor);
8279 u16DNROffset = (u16DNROffset + (OFFSET_PIXEL_ALIGNMENT*2 - 1)) & ~(OFFSET_PIXEL_ALIGNMENT*2 - 1);
8280 if (bIsLeftFactor == FALSE)
8281 {
8282 u16DNROffset = u16OffsetTotal - u16DNROffset;
8283 }
8284 }
8285 }
8286 #endif
8287 #endif
8288
8289 }
8290 else
8291 {
8292 u16DNROffset = (*pu16IPMFetch + OFFSET_PIXEL_ALIGNMENT - 1) & ~(OFFSET_PIXEL_ALIGNMENT-1); //TODO: T3 should be 32 alignment
8293 }
8294 }
8295
8296 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u16DNROffset=%u\n",u16DNROffset);
8297 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC," %d\n",(int)*pu16IPMFetch);
8298 #if (HW_IPM_FETCH_ALIGNMENT==FALSE)
8299 if (IsHMirrorMode(eWindow))
8300 {
8301 u16AlignWidth = u16DNROffset - *pu16IPMFetch;
8302 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"align width = %d\n", u16AlignWidth);
8303
8304 // the hardware alignment in OPM > IPM case, it will get more data for alignment
8305 // disable it in the nine lattice mode
8306 if(pSrcInfo->bDisplayNineLattice)
8307 {
8308 Hal_SC_set_pre_align_pixel(pInstance, FALSE, u16AlignWidth, eWindow);//M10/J2: insert alignment pixel at end
8309 }
8310 else
8311 {
8312 //these chips: they need sw to decide prealign or not.
8313 //here set to TRUE, then hw will prealign u16AlignWidth
8314 //if here is FALSE, hw won't do prealign
8315
8316 //to fix H/W bugs, OPM need to be aligned.
8317 //so do not use pre-align. use OPM line buffer offset instead.
8318 Hal_SC_set_pre_align_pixel(pInstance, FALSE, 0, eWindow);
8319 }
8320 }
8321 #else
8322 if (IsHMirrorMode(eWindow))
8323 {
8324 //M10, J2, A2 and later chip, HW will auto insert pixel to alignment u16IPMFetch
8325 //below u16AlignWidth is used for CBCR swap control
8326 #ifdef K3_U2
8327 if (pSrcInfo->bMemFmt422)
8328 u16AlignWidth = u16DNROffset - pSrcInfo->u16H_SizeAfterPreScaling;
8329 else
8330 u16AlignWidth = u16DNROffset - *pu16IPMFetch;;
8331 #endif
8332 // the hardware alignment in OPM > IPM case, it will get more data for alignment
8333 // disable it in the nine lattice mode
8334 if(pSrcInfo->bDisplayNineLattice)
8335 {
8336 Hal_SC_set_pre_align_pixel(pInstance, FALSE, u16AlignWidth, eWindow);//M10/J2: insert alignment pixel at end
8337 }
8338 else
8339 {
8340 //these chips: when sw set it to TRUE, then hw will do the prealign.
8341 //because hw can calculate by itself, even for the alignwidth==0 case,
8342 //so sw don't need to worry about it, just set it to TRUE.
8343 Hal_SC_set_pre_align_pixel(pInstance, TRUE, u16AlignWidth, eWindow);//M10/J2: insert alignment pixel at start
8344 }
8345 }
8346 #endif
8347 else
8348 {
8349 u16AlignWidth = 0;
8350 Hal_SC_set_pre_align_pixel(pInstance, FALSE, u16AlignWidth, eWindow);//M10/J2: insert alignment pixel at end
8351 }
8352
8353 #ifndef DISABLE_3D_FUNCTION
8354 if((E_XC_3D_INPUT_SIDE_BY_SIDE_FULL == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
8355 || (E_XC_3D_INPUT_SIDE_BY_SIDE_HALF == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
8356 || (E_XC_3D_INPUT_CHECK_BORAD == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
8357 || (E_XC_3D_INPUT_SIDE_BY_SIDE_HALF_INTERLACE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
8358 || (E_XC_3D_INPUT_SIDE_BY_SIDE_HALF_INTERLACE_OPT == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
8359 || (E_XC_3D_INPUT_PIXEL_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow)))
8360 {
8361 u16AlignWidth /= 2; //opm fetch actual align size
8362 u16H_SizeAfterPreScaling /= 2; //actual prescaling hsize
8363 }
8364 #endif
8365
8366 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"align width = %d\n", u16AlignWidth);
8367 // alignwidth must be even, other color will be wrong and need to
8368 // use cb cr swap to correct it.
8369 if((u16AlignWidth & 0x01) && (HAL_SC_get_memory_bit_fmt(pInstance, eWindow) == 0))
8370 {
8371 Hal_SC_set_422_cbcr_swap(pInstance, ENABLE, eWindow);
8372 }
8373 else
8374 {
8375 Hal_SC_set_422_cbcr_swap(pInstance, DISABLE, eWindow);
8376 }
8377
8378 if(pSrcInfo->bDisplayNineLattice)
8379 {
8380 pSrcInfo->u16V_Length = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height;
8381 }
8382
8383 u16DNROffsetFor3D = u16DNROffset;
8384 #ifndef DISABLE_3D_FUNCTION
8385 MDrv_SC_3D_Adjust_DNROffset(pInstance, &u16DNROffsetFor3D,&u16DNROffset, eWindow);
8386 #endif
8387
8388 u32Framesize = (MS_U32)pSrcInfo->u16V_SizeAfterPreScaling * (MS_U32)u16DNROffset * (MS_U32)u8BytesPer2Pixel/2;
8389
8390 #ifndef DISABLE_3D_FUNCTION
8391 #if (HW_DESIGN_3D_VER >= 2)
8392 if((E_XC_3D_INPUT_FRAME_PACKING == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
8393 && ((pSrcInfo->stCapWin.height == DOUBLEHD_1080X2I_VSIZE)
8394 #if ((HW_DESIGN_3D_VER == 3) && (HW_DESIGN_4K2K_VER == 7))
8395 || (pSrcInfo->stCapWin.height == DOUBLEHD_576X2I_VSIZE)
8396 || (pSrcInfo->stCapWin.height == DOUBLEHD_480X2I_VSIZE)
8397 #endif
8398 ))
8399 {
8400 //special case, hw will use field size 540 as deinterlace size
8401 u32Framesize /= 2;
8402 }
8403 #if (HW_DESIGN_3D_VER > 2)
8404 else if(E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
8405 {//per designer, input 3d:framealternative will double data at dnr
8406 u32Framesize *= 2;
8407 }
8408 #endif
8409 #endif
8410 #endif
8411
8412 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>Framesize(%d)= VSizeAfterPreSD(%d) * DNROffset(%d) * BytesPer2Pixel(%d)/2\n",(int)u32Framesize,pSrcInfo->u16V_SizeAfterPreScaling,u16DNROffset,u8BytesPer2Pixel);
8413
8414 #ifdef UFO_XC_FB_LEVEL
8415 if((pSrcInfo->eFBLevel == E_XC_FB_LEVEL_FB)
8416 && (u32Framesize * 2 > u32DNRBufSize[eWindow])
8417 )
8418 #else
8419 if((!pSrcInfo->bFBL)
8420 && (!pSrcInfo->bR_FBL)
8421 && (u32Framesize * 2 > u32DNRBufSize[eWindow]))
8422 #endif
8423 {
8424 //this case should always not be happened
8425 printf("Attention! Scaler DNR Buffer is not enough for this timing, eWindow=%u!\n", eWindow);
8426 }
8427
8428 // enable 4 frame mode if input is progressive & frame buffer is enough
8429 // , regardless the input source and timing because 4 frame mode is better in avoid tearing
8430 //
8431 if(pSrcInfo->bDisplayNineLattice)
8432 {
8433 #if (_LINEAR_ADDRESS_MODE_SUPPORTED)
8434 gSrcInfo[eWindow].bLinearMode = TRUE;
8435 Hal_SC_set_linearmem_mode(ENABLE,MAIN_WINDOW);
8436 #endif
8437 }
8438 else
8439 {
8440 XC_FRAME_STORE_NUMBER enLastFBNum = gSrcInfo[eWindow].Status2.eFrameStoreNumber;
8441
8442 /*Update Frame buffer usage status and memory linear mode*/
8443 // MDrv_XC_GetPQSuggestedFrameNum(eWindow) is the frame count that PQ want to set
8444 // gSrcInfo[eWindow].Status2.eFrameStoreNumber is the frame count that sw code(_Mdrv_SC_CalcFBNum)
8445 // decides according to frame size and other condition
8446 _Mdrv_XC_Refine_FrameNum(pInstance, &gSrcInfo[eWindow].bLinearMode,
8447 &gSrcInfo[eWindow].Status2.eFrameStoreNumber,
8448 bInterlace,
8449 u32Framesize,
8450 u32DNRBufSize[eWindow],
8451 eWindow);
8452
8453 #ifdef ENABLE_RFBL_Y8M4_SUPPORTED
8454 if(SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_04_L, BIT(3)))
8455 {
8456 gSrcInfo[eWindow].Status2.eFrameStoreNumber = IMAGE_STORE_2_FIELDS;
8457 }
8458 #endif
8459
8460 if (!IsVMirrorMode(eWindow))
8461 {
8462 if (gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_2_FRAMES)
8463 {
8464 // 3/4 value is suggested by designer, it is a experimental value.
8465 MS_U16 u16SwitchCnt = gSrcInfo[eWindow].stCapWin.height * 3 / 4;
8466 MDrv_SC_EnableReadBankSwitchControl(pInstance, ENABLE, u16SwitchCnt, eWindow);
8467 }
8468 else
8469 {
8470 MDrv_SC_EnableReadBankSwitchControl(pInstance, DISABLE, 0, eWindow);
8471 }
8472 }
8473 else
8474 {
8475 MDrv_SC_EnableReadBankSwitchControl(pInstance, DISABLE, 0, eWindow);
8476 }
8477
8478 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"gSrcInfo[eWindow].bLinearMode %d \n",gSrcInfo[eWindow].bLinearMode);
8479 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"FrameMode %d \n",gSrcInfo[eWindow].Status2.eFrameStoreNumber);
8480
8481 // Set memory frame buffer setting.
8482 _MDrv_XC_Set_FrameNum(pInstance, eWindow, FALSE, gSrcInfo[eWindow].Status2.eFrameStoreNumber,bInterlace);
8483
8484 // to avoid mm play photo garbage, because of big changing FB number
8485 if((enLastFBNum != gSrcInfo[eWindow].Status2.eFrameStoreNumber) && (TRUE == MDrv_XC_Get_SCMI_Type()))
8486 {
8487 MDrv_XC_WBankReset(pInstance, FALSE, eWindow);
8488 }
8489
8490 #if (_LINEAR_ADDRESS_MODE_SUPPORTED)
8491 // Set linear mode
8492 if (gSrcInfo[eWindow].bLinearMode)
8493 {
8494 Hal_SC_set_linearmem_mode(ENABLE,eWindow);
8495 }
8496 else
8497 {
8498 Hal_SC_set_linearmem_mode(DISABLE,eWindow);
8499 }
8500 #endif
8501 // if support _FIELD_PACKING_MODE_SUPPORTED, it will control by QMAP(J2/A5/A6/A3)
8502 #if(!_FIELD_PACKING_MODE_SUPPORTED)
8503 // avoid tearing problem when we can not do frame lock
8504 if(pSrcInfo->bRWBankAuto)
8505 {
8506 #if (HW_DESIGN_3D_VER == 1)
8507 //this 3d method need special wr bank mapping
8508 if(((E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
8509 && (E_XC_3D_OUTPUT_TOP_BOTTOM == MDrv_XC_Get_3D_Output_Mode(pInstance)))
8510 || ((E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow))
8511 && (E_XC_3D_OUTPUT_SIDE_BY_SIDE_HALF == MDrv_XC_Get_3D_Output_Mode(pInstance)))
8512 )
8513 {
8514 if(eWindow == MAIN_WINDOW)
8515 {
8516 Hal_SC_set_wr_bank_mapping(pInstance, 0x01, eWindow);
8517 }
8518 else
8519 {
8520 Hal_SC_set_wr_bank_mapping(pInstance, 0x00, eWindow);
8521 }
8522 }
8523 else
8524 #endif
8525 // Set read/write bank as larger than 0x01 if frame count >= 3
8526 if (( gSrcInfo[eWindow].Status2.eFrameStoreNumber >= IMAGE_STORE_3_FRAMES)&&
8527 gSrcInfo[eWindow].Status2.eFrameStoreNumber <= IMAGE_STORE_10_FRAMES)
8528 {
8529 if(SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_04_L, BIT(4)) != 0)
8530 Hal_SC_set_wr_bank_mapping(pInstance, 0x00, eWindow);
8531 else
8532 Hal_SC_set_wr_bank_mapping(pInstance, 0x01, eWindow);
8533 }
8534 else // Interlace
8535 {
8536 //For 25_4R_MC mode only
8537 if((!MDrv_XC_Get_OPWriteOffEnable(pInstance, eWindow)) && (gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_4_FIELDS)
8538 && (!MDrv_SC_IsForceFreerun(pInstance)))
8539 {
8540 Hal_SC_set_wr_bank_mapping(pInstance, 0x02, eWindow);
8541 }
8542 else
8543 {
8544 Hal_SC_set_wr_bank_mapping(pInstance, 0x00, eWindow);
8545 }
8546 }
8547 }
8548 #endif
8549 }
8550
8551 //u32Offset = (MS_U32)pSrcInfo->u16V_Length * (MS_U32)u16DNROffset * (MS_U32)u8BytesPer2Pixel/2;
8552 //fix u32DNRBase1 at SCALER_DNR_BUF_LEN/2 for not using blue-screen at channel change in ATV
8553
8554 if( gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_3_FRAMES )
8555 u32Offset = u32DNRBufSize[eWindow]/3;
8556 else
8557 u32Offset = u32DNRBufSize[eWindow]/2;
8558 #if defined (__aarch64__)
8559 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u32Offset :%lu, DNRBufSize=%lu\n", u32Offset, u32DNRBufSize[eWindow]);
8560 #else
8561 #endif
8562
8563 u8FrameNum = MDrv_XC_TransFrameNumToFactor(pInstance, gSrcInfo[eWindow].Status2.eFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
8564 u32DNRBase0 = u32MsIPMBase0;
8565
8566 #if SUPPORT_2_FRAME_MIRROR
8567 MS_U32 u32pitch = 0;
8568
8569 if( (gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_2_FRAMES) && (!gSrcInfo[eWindow].bInterlace) )
8570 {
8571 u32pitch = ( ( (MS_U32)(u8BitPerPixel/8) * (MS_U32)*pu16IPMFetch * (MS_U32)u8FrameNum * (MS_U32)(pSrcInfo->u16V_SizeAfterPreScaling - 1) ) / (MS_U32)BYTE_PER_WORD);//Pitch = Byte_per_pix*align(fetch)*2*(height-1)/byte_per_miu_word
8572 u32DNRBase1 = u32DNRBase0 + u32pitch;
8573 }
8574
8575 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u32pitch:%x u32DNRBase1:%x \n",(int)u32pitch,(int)u32DNRBase1);
8576 #else
8577 u32DNRBase1 = u32MsIPMBase0 + (( u32Offset/BYTE_PER_WORD + 0x01) & ~0x01L);
8578
8579 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>MAIN DNRBase1[%x]= MS_IPM_BASE0[%u]=(%x) + ((u32Offset[%x]/%d + 0x01) & ~0x01L)\n",(int)u32DNRBase1, eWindow,(int)u32MsIPMBase0,(int)u32Offset, BYTE_PER_WORD);
8580 #endif
8581
8582 #ifndef DISABLE_3D_FUNCTION
8583 MDrv_SC_3D_Adjust_DNRBase(pInstance,
8584 &u32DNRBase0,
8585 &u32DNRBase1,
8586 eWindow);
8587 #endif
8588
8589 if( gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_3_FRAMES )
8590 u32DNRBase2 = u32DNRBase1 + (( u32Offset/BYTE_PER_WORD + 0x01) & ~0x01L);
8591 else
8592 u32DNRBase2 = u32DNRBase0;
8593
8594 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>DNRBase2[%x])\n", (int)u32DNRBase2);
8595
8596 if(pSrcInfo->bDisplayNineLattice)
8597 {
8598 u32OPMBase1 = u32OPMBase0 = u32OPMBase2 = u32DNRBase0;
8599 }
8600 else
8601 {
8602 u32OPMBase0 = u32DNRBase0;
8603 u32OPMBase1 = u32DNRBase1;
8604 u32OPMBase2 = u32DNRBase2;
8605 #ifndef DISABLE_3D_FUNCTION
8606 MDrv_SC_3D_Adjust_OPMBase(pInstance,
8607 &u32OPMBase0,
8608 &u32OPMBase1,
8609 &u32OPMBase2,
8610 u32Offset,
8611 eWindow);
8612 #endif
8613 }
8614
8615 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>u32OPMBase0[%x]= MS_IPM_BASE0[%u][%x] => ",(int)u32OPMBase0, eWindow, (int)u32MsIPMBase0);
8616 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u32OPMBase1[%x]= u32IPMBase1[%x] \n",(int)u32OPMBase1,(int)u32DNRBase1);
8617 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"u32OPMBase2[%x] \n",(int)u32OPMBase2);
8618
8619 // Cal DNR V write limit
8620 if(pSrcInfo->bDisplayNineLattice)
8621 {
8622 u16V_Writelimit = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height;
8623 }
8624 else
8625 {
8626 u16V_Writelimit = pSrcInfo->stCapWin.height;
8627 }
8628
8629 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=> u16V_Writelimit[%d]= u16V_CapSize=%d \n",u16V_Writelimit,pSrcInfo->stCapWin.height);
8630 if( bInterlace )
8631 u16V_Writelimit = (u16V_Writelimit+1) / 2;
8632 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=> i=%d, u16V_Writelimit[%d]= (u16V_Writelimit+1) / 2\n",bInterlace,u16V_Writelimit);
8633 // Cal DNR write limit
8634 #if 1//( CHIP_FAMILY_TYPE == CHIP_FAMILY_S4LE )
8635
8636 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"preview =>WritelimitBase[%u][%x] = (MS_IPM_BASE0[%u]=%x) + (((u32Offset[%x] + 0xF) & ~0xFL) * 3 / BYTE_PER_WORD)\n",eWindow,(int)u32WritelimitBase, eWindow, (int)u32MsIPMBase0 ,(int)u32Offset);
8637
8638 if(gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_3_FRAMES)
8639 {
8640 u32WritelimitBase = (u32MsIPMBase0) + (((u32Offset + 0xF) & ~0xFL) * 3 / BYTE_PER_WORD);
8641 }
8642 else
8643 {
8644 u32WritelimitBase = (u32MsIPMBase0) + (((u32Offset + 0xF) & ~0xFL) * 2 / BYTE_PER_WORD);
8645 }
8646 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>WritelimitBase[%x] = (MS_IPM_BASE0[%u]=%x) + (((u32Offset[%x] + 0xF) & ~0xFL) * 2 / BYTE_PER_WORD)\n",(int)u32WritelimitBase,eWindow,(int)u32MsIPMBase0,(int)u32Offset);
8647 u32WritelimitBase = (eWindow == MAIN_WINDOW) ? (u32WritelimitBase - 1) | F2_WRITE_LIMIT_EN : (u32WritelimitBase - 1) | F1_WRITE_LIMIT_EN;
8648 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=> u32WritelimitBase[%x] = (u32WritelimitBase - 1) | 0x2000000\n",(int)u32WritelimitBase);
8649 #else
8650 u32WritelimitBase = MS_DNR_F2_BASE0 + ((u32Offset/8 + 0x01) & ~0x01L) * 2;
8651 u32WritelimitBase = (u32WritelimitBase - 1);
8652 #endif
8653
8654 if (IsVMirrorMode(eWindow))
8655 {
8656 if(!pSrcInfo->bDisplayNineLattice)
8657 {
8658 MS_U16 u16V_SizeAfterPreScaling = pSrcInfo->u16V_SizeAfterPreScaling;
8659 MS_U16 u16DNROffsetTemp = u16DNROffset;
8660 MS_U16 u16Ratio = 1;
8661 MS_BOOL bMirrorBufferOverflow = FALSE;
8662
8663 if(MDrv_XC_GetDynamicScalingStatus(pInstance)
8664 #ifdef K3_U2
8665 && (eWindow == MAIN_WINDOW)
8666 #if SUPPORT_SEAMLESS_ZAPPING
8667 && (pXCResourcePrivate->sthal_SC.bSeamlessZappingEnable[eWindow] == FALSE)
8668 #endif
8669 #endif
8670 )
8671 {
8672 //only for mm ds go into ficlk patch: gSrcInfo[eWindow].Status2.u16PreVCusScalingDst
8673 //is one(progressive) or two lines(interlace) less than gSrcInfo[eWindow].Status2.u16PreVCusScalingSrc
8674 u16V_SizeAfterPreScaling = gSrcInfo[eWindow].Status2.u16PreVCusScalingSrc;
8675 }
8676
8677 #ifndef DISABLE_3D_FUNCTION
8678 MDrv_SC_3D_Adjust_MirrorDNROffset(pInstance, pSrcInfo, &u16V_SizeAfterPreScaling, &u16DNROffsetTemp, &u16Ratio, eWindow);
8679 #endif
8680 //base_offset = (frame_line_cnt -2) * line_offset * (N-bits/pix)/64-bits
8681 u32OneLineOffset = u8FrameNum * (MS_U32)u16Ratio * (MS_U32)u16DNROffsetTemp * (MS_U32)u8BytesPer2Pixel/2/BYTE_PER_WORD;
8682
8683 #if SUPPORT_SEAMLESS_ZAPPING
8684 if( bInterlace || Hal_SC_IsPX2MemFormat(pInstance, eWindow))
8685 #else
8686 if( bInterlace )
8687 #endif
8688 {
8689 MS_U16 u16Offset;
8690 u16Offset = u16DNROffsetTemp * MDrv_XC_TransFrameNumToFactor(pInstance, gSrcInfo[eWindow].Status2.eFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED) / 2;
8691
8692 u32BaseOffset = (MS_U32)(u16V_SizeAfterPreScaling-2) * (MS_U32)u16Ratio * (MS_U32)u16Offset * (MS_U32)u8BytesPer2Pixel/2/BYTE_PER_WORD;
8693 }
8694 else
8695 {
8696 //Progressived mode, non-linear address
8697 //base_offset = (frame_line_cnt -2) * line_offset * (N-bits/pix)/64-bits
8698 u32BaseOffset = (MS_U32)((MS_U32)u16Ratio * u8FrameNum*(u16V_SizeAfterPreScaling-1)) * (MS_U32)u16DNROffsetTemp * (MS_U32)u8BytesPer2Pixel/2/BYTE_PER_WORD;
8699 }
8700
8701 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"=>u16Ratio[%u] * u8FrameNum[%u] *(u16V_SizeAfterPreScaling-1)[%u]*u16DNROffsetTemp[%u]*u8BytesPer2Pixel[%u]\n",
8702 u16Ratio,u8FrameNum,(u16V_SizeAfterPreScaling-1),u16DNROffsetTemp,u8BytesPer2Pixel);
8703
8704
8705 MDrv_SC_set_DNRBaseOffset(pInstance, eWindow,u32BaseOffset);
8706
8707 u32DNRBase0 += u32BaseOffset;
8708
8709 //to avoid set dnr base1 out of scaler dnr memory when 2 frame mode
8710 if((u32DNRBase1 + u32BaseOffset) <= (u32MsIPMBase0 + u32DNRBufSize[eWindow]/BYTE_PER_WORD - u32OneLineOffset))
8711 {
8712 u32DNRBase1 += u32BaseOffset;
8713 }
8714
8715 if((u32DNRBase2 + u32BaseOffset) <= (u32MsIPMBase0 + u32DNRBufSize[eWindow]/BYTE_PER_WORD - u32OneLineOffset))
8716 {
8717 u32DNRBase2 += u32BaseOffset;
8718 }
8719
8720 if(MDrv_XC_Get_SCMI_Type())
8721 {
8722 // field packing mode, only dnrbase0 is used
8723 if((u32DNRBase0 < u32BaseOffset) || (u32DNRBase0 - u32BaseOffset < u32MsIPMBase0))
8724 {
8725 bMirrorBufferOverflow = TRUE;
8726 }
8727 }
8728 else //not field packing mode
8729 {
8730 if(gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_2_FRAMES)
8731 {
8732 // 2 frame mode, only dnrbase0 is used
8733 if((u32DNRBase0 < u32BaseOffset) || (u32DNRBase0 - u32BaseOffset < u32MsIPMBase0))
8734 {
8735 bMirrorBufferOverflow = TRUE;
8736 }
8737 }
8738 else if(gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_3_FRAMES)
8739 {
8740 // 3 frame mode, dnrbase0, dnrbase1, dnrbase2 is used
8741 if((u32DNRBase0 < u32BaseOffset)
8742 || (u32DNRBase1 < u32BaseOffset)
8743 || (u32DNRBase2 < u32BaseOffset)
8744 || (u32DNRBase0 - u32BaseOffset < u32MsIPMBase0)
8745 || (u32DNRBase1 - u32BaseOffset < u32MsIPMBase0)
8746 || (u32DNRBase2 - u32BaseOffset < u32MsIPMBase0))
8747 {
8748 bMirrorBufferOverflow = TRUE;
8749 }
8750 }
8751 else
8752 {
8753 //other frame mode, dnr base0, dnr base1 is used
8754 if((u32DNRBase0 < u32BaseOffset)
8755 || (u32DNRBase1 < u32BaseOffset)
8756 || (u32DNRBase0 - u32BaseOffset < u32MsIPMBase0)
8757 || (u32DNRBase1 - u32BaseOffset < u32MsIPMBase0))
8758 {
8759 bMirrorBufferOverflow = TRUE;
8760 }
8761 }
8762 }
8763
8764 if(bMirrorBufferOverflow)
8765 {
8766 printf("[%s,%5d] Attention! Scaler memory is overflow!\n",__FUNCTION__,__LINE__);
8767 MS_ASSERT(0);
8768 }
8769 }
8770
8771 u32WritelimitBase = u32MsIPMBase0 - 1;
8772
8773 if(eWindow == MAIN_WINDOW)
8774 u32WritelimitBase= u32WritelimitBase | F2_WRITE_LIMIT_EN | F2_WRITE_LIMIT_MIN;
8775 else
8776 u32WritelimitBase= u32WritelimitBase | F1_WRITE_LIMIT_EN | F1_WRITE_LIMIT_MIN;
8777 }
8778
8779 //store FrameNum
8780 MDrv_XC_Save_FrameNumFactor(pInstance, eWindow,
8781 MDrv_XC_TransFrameNumToFactor(pInstance, gSrcInfo[eWindow].Status2.eFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED));
8782
8783 /////////////////////////////////////////////////
8784 // Set OPM Memeory Settings //
8785 /////////////////////////////////////////////////
8786
8787 // Cal OPM Base address
8788
8789 // compute address offset for cropping
8790 // cropping shift h unit: 16 pixel
8791 // v unit: 2 line(for interlace), 1 line(for progressive)
8792 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop info: (x,y)=(%d,%d),(width,height)=(%d,%d), interlaced = %d\n",
8793 gSrcInfo[eWindow].ScaledCropWin.x, gSrcInfo[eWindow].ScaledCropWin.y,
8794 gSrcInfo[eWindow].ScaledCropWin.width, gSrcInfo[eWindow].ScaledCropWin.height,
8795 bInterlace);
8796
8797 if(pSrcInfo->bDisplayNineLattice)
8798 {
8799 if (IsVMirrorMode(eWindow))
8800 {
8801 if(gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_8_FIELDS)
8802 {
8803 u32OPMPixelOffset = (MS_U32)(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height
8804 - (gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))*u16DNROffset;
8805 }
8806 else if( bInterlace )
8807 {
8808 u32OPMPixelOffset = (MS_U32)((pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height
8809 - (gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))/2)*u16DNROffset;
8810 }
8811 else
8812 {
8813 u32OPMPixelOffset = (MS_U32)(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height
8814 - (gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))*u16DNROffset;
8815 }
8816 u32OPMPixelOffset += (MS_U32)(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width
8817 - (gSrcInfo[eWindow].stDispWin.x - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16HStart + gSrcInfo[eWindow].stDispWin.width));
8818 }
8819 else
8820 {
8821 if(gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_8_FIELDS)
8822 {
8823 u32OPMPixelOffset = (MS_U32)((gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))*u16DNROffset;
8824 }
8825 else if( bInterlace )
8826 {
8827 u32OPMPixelOffset = (MS_U32)((gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart)/2)*u16DNROffset;
8828 }
8829 else
8830 {
8831 u32OPMPixelOffset = (MS_U32)((gSrcInfo[eWindow].stDispWin.y - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16VStart))*u16DNROffset;
8832 }
8833 u32OPMPixelOffset += (MS_U32)(gSrcInfo[eWindow].stDispWin.x - pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16HStart);
8834 }
8835 }
8836 else
8837 {
8838 #if SUPPORT_SEAMLESS_ZAPPING
8839 if( bInterlace || Hal_SC_IsPX2MemFormat(pInstance, eWindow))
8840 #else
8841 if( bInterlace )
8842 #endif
8843 #ifdef SUPPORT_BWD
8844 {
8845 if (bBwdEnable == TRUE) // Designer request: CropWin.y must be even number when BWR enable
8846 {
8847 MS_U16 u16CropY = gSrcInfo[eWindow].ScaledCropWin.y;
8848 u16CropY &= ~0x1;
8849 u32OPMPixelOffset = (MS_PHY)(u16CropY/2) * u16DNROffsetFor3D;
8850 }
8851 else
8852 {
8853 u32OPMPixelOffset = (MS_PHY)(gSrcInfo[eWindow].ScaledCropWin.y/2) * u16DNROffsetFor3D;
8854 }
8855 }
8856 #else
8857 {
8858 u32OPMPixelOffset = (MS_PHY)(gSrcInfo[eWindow].ScaledCropWin.y/2) * u16DNROffsetFor3D;
8859 }
8860 #endif
8861 else
8862 #ifdef SUPPORT_BWD
8863 {
8864 if (bBwdEnable == TRUE) // Designer request: CropWin.y must be even number when BWR enable
8865 {
8866 MS_U16 u16CropY = gSrcInfo[eWindow].ScaledCropWin.y;
8867 u16CropY &= ~0x1;
8868 u32OPMPixelOffset = (MS_PHY)((u16CropY) * u16DNROffsetFor3D);
8869 }
8870 else
8871 {
8872 u32OPMPixelOffset = (MS_PHY)((gSrcInfo[eWindow].ScaledCropWin.y) * u16DNROffsetFor3D);
8873 }
8874 }
8875 #else
8876 {
8877 u32OPMPixelOffset = (MS_PHY)((gSrcInfo[eWindow].ScaledCropWin.y) * u16DNROffsetFor3D);
8878 }
8879 #endif
8880 #ifdef UFO_XC_SUPPORT_DUAL_MIU
8881 if (IsEnableDualMode(eWindow))
8882 {
8883 MS_U16 u16CropRight = 0;
8884 if (IsHMirrorMode(eWindow)) // H Mirror orignal crop.Left is display crop.Right
8885 {
8886 u16CropRight = (pSrcInfo->u16H_SizeAfterPreScaling - gSrcInfo[eWindow].ScaledCropWin.x - gSrcInfo[eWindow].ScaledCropWin.width);
8887 if (u16CropRight < gSrcInfo[eWindow].Status2.u16DualMiuIPMFetch)
8888 {
8889 if (bIsLeftFactor == TRUE)
8890 {
8891 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC, "Mirror dual case: OPM1 need get valid data at edge, pixelOffset is 0.\n");
8892 }
8893 else
8894 {
8895 // u32OPMPixlOffSetLeft = (MS_U32)u16CropRight;
8896 if(IS_INPUT_SIDE_BY_SIDE_HALF(eWindow)
8897 || IS_INPUT_CHECK_BOARD(eWindow)
8898 || IS_INPUT_PIXEL_ALTERNATIVE(eWindow)
8899 || IS_INPUT_SIDE_BY_SIDE_HALF_INTERLACE(eWindow)
8900 || IS_INPUT_SIDE_BY_SIDE_HALF_INTERLACE_OPT(eWindow)
8901 || IS_INPUT_SIDE_BY_SIDE_FULL(eWindow))
8902 {
8903 u32OPMPixelOffset += (MS_PHY)u16CropRight/2;
8904 }
8905 else
8906 {
8907 u32OPMPixelOffset += (MS_PHY)u16CropRight;
8908 }
8909 //u32OPMPixelOffset += (MS_U32)u16CropRight;
8910 }
8911 }
8912 else // Orignal video crop all right side.
8913 {
8914 if (bIsLeftFactor == TRUE)
8915 {
8916 // u32OPMPixlOffSetRight = (MS_U32)(u16CropRight - gSrcInfo[eWindow].u16DualMiuIPMOffset);
8917 u32OPMPixelOffset += (MS_PHY)(u16CropRight - gSrcInfo[eWindow].Status2.u16DualMiuIPMFetch);
8918 }
8919 else
8920 {
8921 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC, "Mirror dual case: OPM0 need get guardband data, pixelOffset is 0.\n");
8922 }
8923 }
8924 }
8925 else
8926 {
8927 if (gSrcInfo[eWindow].ScaledCropWin.x > gSrcInfo[eWindow].u16IPMFetch) // OPM all Left side data was cropped
8928 {
8929 if (bIsLeftFactor == TRUE)
8930 {
8931 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC, "NO mirror dual case: OPM all Left side data was cropped, OPM0 pixelOffset is 0.\n");
8932 }
8933 else
8934 {
8935 //Note: u32OPMPixlOffSetRight = (MS_U32)(gSrcInfo[eWindow].ScaledCropWin.x - gSrcInfo[eWindow].u16IPMOffset);
8936 u32OPMPixelOffset += (MS_PHY)(gSrcInfo[eWindow].ScaledCropWin.x - gSrcInfo[eWindow].u16IPMOffset);
8937 }
8938 }
8939 else
8940 {
8941 if (bIsLeftFactor == TRUE)
8942 {
8943 //u32OPMPixlOffSetLeft = (MS_U32)(gSrcInfo[eWindow].ScaledCropWin.x);
8944 if(IS_INPUT_SIDE_BY_SIDE_HALF(eWindow)
8945 || IS_INPUT_CHECK_BOARD(eWindow)
8946 || IS_INPUT_PIXEL_ALTERNATIVE(eWindow)
8947 || IS_INPUT_SIDE_BY_SIDE_HALF_INTERLACE(eWindow)
8948 || IS_INPUT_SIDE_BY_SIDE_HALF_INTERLACE_OPT(eWindow)
8949 || IS_INPUT_SIDE_BY_SIDE_FULL(eWindow))
8950 {
8951 u32OPMPixelOffset += (MS_PHY)(gSrcInfo[eWindow].ScaledCropWin.x)/2;
8952 }
8953 else
8954 {
8955 u32OPMPixelOffset += (MS_PHY)(gSrcInfo[eWindow].ScaledCropWin.x);
8956 }
8957 }
8958 else
8959 {
8960 // u32OPMPixlOffSetRight = 0;
8961 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC, "NO mirror dual case: OPM1 pixel offset is 0.\n");
8962 }
8963 }
8964 }
8965 }
8966 else
8967 #endif
8968 {
8969 u32OPMPixelOffset += (MS_PHY)(gSrcInfo[eWindow].ScaledCropWin.x);
8970 }
8971
8972 #if (HW_IPM_FETCH_ALIGNMENT==FALSE)
8973 if (IsHMirrorMode(eWindow))
8974 {
8975 u32OPMPixelOffset += u16AlignWidth;
8976 }
8977 #else
8978 if (IsHMirrorMode(eWindow) && pSrcInfo->bMemFmt422)
8979 {
8980 #ifndef DISABLE_3D_FUNCTION
8981 MDrv_SC_3D_Adjust_PixelOffset(pInstance, pSrcInfo,&u32OPMPixelOffset,&u16DNROffset,&u16DNROffsetFor3D, bIsLeftFactor, eWindow);
8982 #else
8983 u32OPMPixelOffset += (MS_PHY)(u16DNROffset - pSrcInfo->u16H_SizeAfterPreScaling);
8984 #endif
8985 }
8986 #endif
8987 }
8988
8989 #if defined (__aarch64__)
8990 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop total offset pixel counts %ld\n",u32OPMPixelOffset);
8991 #else
8992 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop total offset pixel counts %td\n",(ptrdiff_t)u32OPMPixelOffset);
8993 #endif
8994 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop info: (x,y)=(%d,%d),(width,height)=(%d,%d), interlaced = %d\n",
8995 gSrcInfo[eWindow].ScaledCropWin.x, gSrcInfo[eWindow].ScaledCropWin.y,
8996 gSrcInfo[eWindow].ScaledCropWin.width, gSrcInfo[eWindow].ScaledCropWin.height,
8997 bInterlace);
8998 #ifdef UFO_XC_SUPPORT_DUAL_MIU
8999 if ((IsEnableDualMode(eWindow)) &&
9000 (IS_INPUT_SIDE_BY_SIDE_HALF(eWindow)
9001 || IS_INPUT_CHECK_BOARD(eWindow)
9002 || IS_INPUT_PIXEL_ALTERNATIVE(eWindow)
9003 || IS_INPUT_SIDE_BY_SIDE_HALF_INTERLACE(eWindow)
9004 || IS_INPUT_SIDE_BY_SIDE_HALF_INTERLACE_OPT(eWindow)
9005 || IS_INPUT_SIDE_BY_SIDE_FULL(eWindow)
9006 )
9007 )
9008 {
9009 if (bIsLeftFactor == TRUE)
9010 {
9011 // calculate LB offset
9012 u16LBOffset = u32OPMPixelOffset % (OFFSET_PIXEL_ALIGNMENT*2); // these pixels rely on line buffer offset
9013 }
9014 else
9015 {
9016 // calculate LB offset
9017 u16LBOffset = u32OPMPixelOffset % OFFSET_PIXEL_ALIGNMENT; // these pixels rely on line buffer offset
9018 }
9019 }
9020 else
9021 #endif
9022 // calculate LB offset
9023 u16LBOffset = u32OPMPixelOffset % OFFSET_PIXEL_ALIGNMENT; // these pixels rely on line buffer offset
9024 gSrcInfo[eWindow].Status2.u16LBOffset = u16LBOffset;
9025 u32OPMPixelOffset -= u16LBOffset; // these pixels rely on base offset
9026
9027 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"LB offset %d, Pixel offset %d Alighment: %d bytes \n", u16LBOffset, (int)u32OPMPixelOffset,OFFSET_PIXEL_ALIGNMENT);
9028
9029 // calcuate OPM offset
9030 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"eFrameStoreNumber %d\n", (gSrcInfo[eWindow].Status2.eFrameStoreNumber));
9031 u32OPMPixelOffset *= MDrv_XC_TransFrameNumToFactor(pInstance, gSrcInfo[eWindow].Status2.eFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
9032 #ifdef K3_U2
9033 if(Hal_SC_IsPX2MemFormat(pInstance, eWindow))
9034 {
9035 u32OPMPixelOffset *= 2;
9036 }
9037 #endif
9038 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"bLinearMode = %s\n",gSrcInfo[eWindow].bLinearMode ?("TRUE"):("FALSE"));
9039 #if defined (__aarch64__)
9040 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop total offset pixel counts for field/frame %ld (eFrameStoreNumber: %d)\n", u32OPMPixelOffset, gSrcInfo[eWindow].Status2.eFrameStoreNumber);
9041 #else
9042 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Crop total offset pixel counts for field/frame %td (eFrameStoreNumber: %d)\n", (ptrdiff_t)u32OPMPixelOffset, gSrcInfo[eWindow].Status2.eFrameStoreNumber);
9043 #endif
9044 if(u32OPMPixelOffset != 0)
9045 {
9046 MS_U8 u8BytesPer2PixelTemp = u8BytesPer2Pixel;
9047 #ifndef DISABLE_3D_FUNCTION
9048 MDrv_SC_3D_Adjust_BytesPer2Pixel(pInstance, &u8BytesPer2PixelTemp,eWindow);
9049 #endif
9050 u32OPMCropOffset = u32OPMPixelOffset * u8BytesPer2PixelTemp / 2 / BYTE_PER_WORD;
9051 #ifdef _FIELD_PACKING_MODE_SUPPORTED_MULTIPLE_TEMP
9052 //Attention, this is for temp solve crop address offset error in Kappa. Remove this if Kappa code flow has refined.
9053 printf("[Kappa_temp_patch] u32OPMCropOffset*=2\n");
9054 u32OPMCropOffset *= 2;
9055 #endif
9056 }
9057
9058 #if defined (__aarch64__)
9059 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"f.LineBuf offset %d, OPMOffset 0x%lx\n", u16LBOffset, u32OPMCropOffset);
9060 #else
9061 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"f.LineBuf offset %d, OPMOffset 0x%tx\n", u16LBOffset, (ptrdiff_t)u32OPMCropOffset);
9062 #endif
9063 //KT: T3 PIP HW issue, When SUB ON, the HW operation will decrease "u16LBOffset" 2 times.
9064
9065 MS_U16 CropWinWidthTemp = gSrcInfo[eWindow].ScaledCropWin.width;
9066 #ifndef DISABLE_3D_FUNCTION
9067 MDrv_SC_3D_Adjust_CropWinWidth(pInstance, &CropWinWidthTemp,eWindow);
9068 #endif
9069 u16OPMFetch = CropWinWidthTemp + u16LBOffset; // using LBOffset still need to add some points to avoid generating garbage
9070
9071
9072 if(pSrcInfo->bDisplayNineLattice) // for display ninelattice no line buffer offset
9073 {
9074 u16LBOffset = u16DispOffset=0;
9075 u16OPMFetch = (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width + 1) & ~0x1;
9076 #ifdef K3_U2
9077 u16OPMFetch += HW_PIP_BUG_SW_PATCH_FETCH_INCREASE; // - For HW Bug in PIP when the gap between H-end of sub window and H-end of main window is too small
9078 #endif
9079 }
9080 else
9081 {
9082 // IPM offset / IPM fetch /OPM offset: All project --> 32pix align
9083 // OPM fetch:
9084 // Janus /T7 --> 32pix align
9085 // Others ( T8/T9/T12/T13/m10/J2 ) --> 2pix align
9086 #ifndef DISABLE_3D_FUNCTION
9087 MS_U16 u16HShift = 0;
9088 #endif
9089 MS_U16 u16tempOPM;
9090 if((u16LBOffset & 0x1) != 0)
9091 {
9092 //HW issue for OPM fetch&422to444: when lboffset not even, OPM should add 2 to avoid right line garbage
9093 u16tempOPM = (( u16OPMFetch + 1 ) & ~1) + 2;
9094 if(u16tempOPM > pSrcInfo->u16H_SizeAfterPreScaling - (gSrcInfo[eWindow].ScaledCropWin.x - u16LBOffset))
9095 {
9096 u16LBOffset--;//Overflow, set lb offset even and alignment OPM
9097 u16OPMFetch = u16OPMFetch & ~1; //Make even directly, since lb offset has minus 1
9098 }
9099 else
9100 {
9101 u16OPMFetch = u16tempOPM;
9102 }
9103 }
9104 else if((u16OPMFetch != *pu16IPMFetch)
9105 #ifndef DISABLE_3D_FUNCTION
9106 && (E_XC_3D_OUTPUT_MODE_NONE == MDrv_XC_Get_3D_Output_Mode(pInstance))
9107 #endif
9108 )
9109 {
9110 //UCDi need grab six more pixels, not 3D case.(a7p need 6 more, others need 2 more)
9111 u16tempOPM = (( u16OPMFetch + 1 ) & ~1) + 6;
9112 if(u16tempOPM > pSrcInfo->u16H_SizeAfterPreScaling - (gSrcInfo[eWindow].ScaledCropWin.x - u16LBOffset))
9113 {
9114 u16OPMFetch = u16OPMFetch & ~1;
9115 }
9116 else
9117 {
9118 u16OPMFetch = u16tempOPM;
9119 }
9120 }
9121 else
9122 {
9123 u16OPMFetch = ( u16OPMFetch + 1 ) & ~1; // pixels alignment
9124 }
9125 #ifdef K3_U2
9126 u16OPMFetch += HW_PIP_BUG_SW_PATCH_FETCH_INCREASE; // - For HW Bug in PIP when the gap between H-end of sub window and H-end of main window is too small
9127 #endif
9128 if (!pSrcInfo->bMemFmt422)
9129 {
9130 u16OPMFetchAlignment = (u16OPMFetch + (OFFSET_PIXEL_ALIGNMENT - 1)) & ~(OFFSET_PIXEL_ALIGNMENT - 1);
9131 //HW issue for OPM fetch when OP write enable, OPM Fetch have to offset pixels alignment avoid green garbage .
9132 if(pSrcInfo->u16H_SizeAfterPreScaling >= (u16OPMFetchAlignment+gSrcInfo[eWindow].ScaledCropWin.x - u16LBOffset))
9133 {
9134 u16OPMFetch = u16OPMFetchAlignment;
9135 }
9136 else
9137 {
9138 //Overflow, set the OPM Fetch to the max data area .
9139 u16OPMFetch = pSrcInfo->u16H_SizeAfterPreScaling - gSrcInfo[eWindow].ScaledCropWin.x + u16LBOffset;
9140 u16OPMFetch = u16OPMFetch & ~1;
9141 }
9142 }
9143 else
9144 {
9145 if(2200>=u16OPMFetch) //Nike 4k2k opm fetch can't do ALIGNMENT
9146 {
9147 #ifdef OPMFETCH_PIXEL_ALIGNMENT
9148 u16OPMFetch = (u16OPMFetch + (OPMFETCH_PIXEL_ALIGNMENT - 1)) & ~(OPMFETCH_PIXEL_ALIGNMENT - 1);
9149 #else
9150 u16OPMFetch = (u16OPMFetch + (OFFSET_PIXEL_ALIGNMENT - 1)) & ~(OFFSET_PIXEL_ALIGNMENT - 1);
9151 #endif
9152 }
9153 }
9154 #ifndef DISABLE_3D_FUNCTION
9155 if(MDrv_SC_3D_Is2Dto3DCase(pInstance, MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow), MDrv_XC_Get_3D_Output_Mode(pInstance)))
9156 {
9157 u16HShift = MDrv_XC_Get_3D_HShift(pInstance);
9158 if ((u16OPMFetch + u16HShift) > *pu16IPMFetch)
9159 {
9160 if(*pu16IPMFetch > u16HShift)
9161 {
9162 //opmfetch need align although ipmfetch may not need align
9163 u16OPMFetch = ( *pu16IPMFetch - u16HShift + 1 ) & ~1;
9164 }
9165 else
9166 {
9167 u16OPMFetch = 0;
9168 }
9169 }
9170 }
9171 else
9172 #endif
9173 {
9174 if(u16OPMFetch > pSrcInfo->u16H_SizeAfterPreScaling - (gSrcInfo[eWindow].ScaledCropWin.x - u16LBOffset))
9175 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"!!!Alert OPMFetch(%u) Overflowed, check crop setting!!!\n", u16OPMFetch);
9176 }
9177 }
9178
9179 #ifdef K3_U2
9180 // - For HW Bug in PIP when the gap between H-end of sub window and H-end of main window is too small
9181 if(eWindow == MAIN_WINDOW)
9182 {
9183 if (u16OPMFetch > MST_LINE_BFF_MAX)
9184 {
9185 u16OPMFetch = MST_LINE_BFF_MAX;
9186 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Re-assign OPM fetch as %lu due to HW limitation \n", MST_LINE_BFF_MAX);
9187 }
9188 }
9189 else
9190 {
9191 if(u16OPMFetch > SUB_MST_LINE_BFF_MAX)
9192 {
9193 u16OPMFetch = SUB_MST_LINE_BFF_MAX;
9194 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Re-assign OPM fetch as %lu due to HW limitation \n", SUB_MST_LINE_BFF_MAX);
9195 }
9196 }
9197 #endif
9198
9199 #ifdef UFO_XC_SUPPORT_DUAL_MIU
9200 if (IsEnableDualMode(eWindow))
9201 {
9202 MS_U16 u16OPMFetchTmp = u16OPMFetch;
9203 MS_U16 u16OPMCropRight = 0;
9204 MS_U16 u16OPMCropLeft = 0;
9205 MS_U16 u16OPMOffsetLeft = 0;
9206 MS_U16 u16OPMOffsetRight = 0;
9207
9208 if (IsHMirrorMode(eWindow))
9209 {
9210 // Video Right edge position
9211 u16OPMCropRight = pSrcInfo->ScaledCropWin.x;
9212 u16OPMCropLeft = pSrcInfo->u16H_SizeAfterPreScaling - pSrcInfo->ScaledCropWin.width - pSrcInfo->ScaledCropWin.x;
9213 u16OPMOffsetLeft = gSrcInfo[eWindow].Status2.u16DualMiuIPMFetch;
9214 u16OPMOffsetRight = gSrcInfo[eWindow].u16IPMFetch;
9215 }
9216 else
9217 {
9218 u16OPMCropRight = pSrcInfo->u16H_SizeAfterPreScaling - pSrcInfo->ScaledCropWin.width - pSrcInfo->ScaledCropWin.x;
9219 u16OPMCropLeft = pSrcInfo->ScaledCropWin.x;
9220 u16OPMOffsetLeft = gSrcInfo[eWindow].u16IPMFetch;
9221 u16OPMOffsetRight = gSrcInfo[eWindow].Status2.u16DualMiuIPMFetch;
9222 }
9223
9224 //FIXME: Get more a garbage point, OPM Right fetch 2 align
9225 if (u16OPMOffsetRight > u16OPMCropRight) // OPM Crop.right at Right side
9226 {
9227 if (u16OPMCropLeft > u16OPMOffsetLeft) // OPM all Left side data was cropped
9228 {
9229 if (bIsLeftFactor == TRUE)
9230 {
9231 u16OPMFetch = OFFSET_PIXEL_ALIGNMENT;
9232 //Need linebuffer Offset skip dummy data.
9233 //Fixme: This should in hal just for monet
9234 u16LBOffset = u16OPMFetch; /// This is wrong
9235 }
9236 else // OPM Right side
9237 {
9238 u16OPMFetch = pSrcInfo->ScaledCropWin.width;
9239 u16OPMFetch = (u16OPMFetchTmp + 1) & 0xfffe;
9240 }
9241 }
9242 else // OPM Left/right side have valid data after crop
9243 {
9244 u16OPMFetchTmp = u16OPMOffsetRight - u16OPMCropRight;
9245 if (bIsLeftFactor == TRUE)
9246 {
9247 u16OPMFetch = pSrcInfo->ScaledCropWin.width - u16OPMFetchTmp;
9248 if(IS_INPUT_SIDE_BY_SIDE_HALF(eWindow)
9249 || IS_INPUT_CHECK_BOARD(eWindow)
9250 || IS_INPUT_PIXEL_ALTERNATIVE(eWindow)
9251 || IS_INPUT_SIDE_BY_SIDE_HALF_INTERLACE(eWindow)
9252 || IS_INPUT_SIDE_BY_SIDE_HALF_INTERLACE_OPT(eWindow)
9253 || IS_INPUT_SIDE_BY_SIDE_FULL(eWindow))
9254 {
9255 u16OPMFetch = (u16OPMFetch + (OFFSET_PIXEL_ALIGNMENT*2 - 1)) & ~(OFFSET_PIXEL_ALIGNMENT*2 - 1);
9256 }
9257 else
9258 {
9259 u16OPMFetch = (u16OPMFetch + (OFFSET_PIXEL_ALIGNMENT - 1)) & ~(OFFSET_PIXEL_ALIGNMENT - 1);
9260 }
9261 }
9262 else // OPM Right side
9263 {
9264 u16OPMFetch = (u16OPMFetchTmp + 1) & 0xfffe;
9265 }
9266 }
9267 }
9268 else if (u16OPMOffsetRight == u16OPMCropRight) // OPM Crop.right at Dual Edge
9269 {
9270 if (bIsLeftFactor == TRUE) //OPM left side
9271 {
9272 u16OPMFetch = pSrcInfo->ScaledCropWin.width;
9273 u16OPMFetch = (u16OPMFetch + (OFFSET_PIXEL_ALIGNMENT - 1)) & ~(OFFSET_PIXEL_ALIGNMENT - 1);
9274 }
9275 else // OPM Right side
9276 {
9277 u16OPMFetch = DUAL_DUMMYDATA_SIZE;
9278 }
9279 }
9280 else // OPM Crop.right in Left side
9281 {
9282 if (bIsLeftFactor == TRUE)
9283 {
9284 if (u16OPMCropRight >= (u16OPMOffsetRight + DUAL_GARDBAND_SIZE)) // Video right edge have enough
9285 {
9286 u16OPMFetch = pSrcInfo->ScaledCropWin.width + DUAL_GARDBAND_SIZE;
9287 }
9288 else // Video right edge have no enough dual gardband
9289 {
9290 u16OPMFetch = pSrcInfo->ScaledCropWin.width + (u16OPMCropRight - u16OPMOffsetRight);
9291 }
9292 u16OPMFetch = (u16OPMFetch + (OFFSET_PIXEL_ALIGNMENT - 1)) & ~(OFFSET_PIXEL_ALIGNMENT - 1);
9293 }
9294 else
9295 {
9296 u16OPMFetch = DUAL_DUMMYDATA_SIZE;
9297 }
9298 }
9299 MDrv_SC_3D_Adjust_DualOPMFetch(pInstance, &u16OPMFetch, eWindow);
9300 }
9301 #endif
9302
9303 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"f1. u16OPMFetch after alignment %d, lboffset %d \n", u16OPMFetch, u16LBOffset);
9304 //printf("1.SC Crop width=0x%x, LBOffset=0x%x\n", gSrcInfo[eWindow].ScaledCropWin.width, u16LBOffset);
9305 u16DispOffset = 0;
9306
9307 //printf("cropy=%u,cropx=%u,dnroffset=%u,bp2p=%bu\n", _stScaledCropWin.y, _stScaledCropWin.x, u16DNROffset, u8BytesPer2Pixel);
9308 //printf("2.OPM Crop Offset=0x%lx, LBOffset=0x%x\n", u32OPMCropOffset, u16LBOffset);
9309
9310 // adjsut OPMBase address for cropping
9311 if(pSrcInfo ->bDisplayNineLattice)
9312 {
9313 // for linear mode set all base address the same
9314 u32OPMBase0 += u32OPMCropOffset;
9315 //u32DNRBase1 += u32OPMCropOffset;
9316 //u32OPMBase2 += u32OPMCropOffset;
9317 u32DNRBase2 = u32DNRBase1 = u32DNRBase0;
9318 //printf("--u32DNRBase0 %lx\n",u32DNRBase0);
9319 }
9320 else
9321 {
9322 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"h.=> u32OPMBase0,1=%x,%x -> +u32OPMCropOffset[%x] =",(int)u32OPMBase0,(int)u32OPMBase1,(int)u32OPMCropOffset);
9323 u32OPMBase0 += u32OPMCropOffset;
9324 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"0:%x \n",(int)u32OPMBase0);
9325 u32OPMBase1 += u32OPMCropOffset;
9326 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"1:%x \n",(int)u32OPMBase1);
9327 u32OPMBase2 += u32OPMCropOffset;
9328 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"2:%x \n",(int)u32OPMBase2);
9329 }
9330
9331 #if SUPPORT_2_FRAME_MIRROR
9332
9333 MS_S32 s32cropshift_base0;
9334 MS_S32 s32cropshift_base1;
9335 MS_U32 u32LBOffset_mirror;
9336 #ifdef SUPPORT_BWD
9337 if (bBwdEnable == TRUE) // Designer request: CropWin.y must be even number when BWR enable
9338 {
9339 MS_U16 u16CropY = gSrcInfo[eWindow].ScaledCropWin.y;
9340 u16CropY &= ~0x1;
9341 s32cropshift_base0 = u16CropY * (MS_S32) (u16DNROffsetFor3D) + gSrcInfo[eWindow].ScaledCropWin.x;
9342 s32cropshift_base1 = - u16CropY * (MS_S32) (u16DNROffsetFor3D) + gSrcInfo[eWindow].ScaledCropWin.x;
9343 }
9344 else
9345 #endif
9346 {
9347 s32cropshift_base0 = gSrcInfo[eWindow].ScaledCropWin.y * (MS_S32) (u16DNROffsetFor3D) + gSrcInfo[eWindow].ScaledCropWin.x;
9348 s32cropshift_base1 = - gSrcInfo[eWindow].ScaledCropWin.y * (MS_S32) (u16DNROffsetFor3D) + gSrcInfo[eWindow].ScaledCropWin.x;
9349 }
9350
9351 u32LBOffset_mirror = gSrcInfo[eWindow].ScaledCropWin.x % OFFSET_PIXEL_ALIGNMENT;
9352
9353 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"[SUPPORT_2_FRAME_MIRROR] u32LBOffset:%d \n",u32LBOffset_mirror);
9354
9355 s32cropshift_base0 = ( s32cropshift_base0 - u32LBOffset_mirror ) * (MS_U32) MDrv_XC_TransFrameNumToFactor(gSrcInfo[eWindow].Status2.eFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
9356 s32cropshift_base1 = ( s32cropshift_base1 - u32LBOffset_mirror ) * (MS_U32) MDrv_XC_TransFrameNumToFactor(gSrcInfo[eWindow].Status2.eFrameStoreNumber, gSrcInfo[eWindow].bLinearMode, _FIELD_PACKING_MODE_SUPPORTED);
9357
9358 s32cropshift_base0 = ( s32cropshift_base0 * (MS_U32)(u8BitPerPixel/8) ) / (MS_U32)(BYTE_PER_WORD);
9359 s32cropshift_base1 = ( s32cropshift_base1 * (MS_U32)(u8BitPerPixel/8) ) / (MS_U32)(BYTE_PER_WORD);
9360
9361 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"[SUPPORT_2_FRAME_MIRROR] s32cropshift_base0:%d s32cropshift_base1:%d \n", s32cropshift_base0,s32cropshift_base1);
9362
9363 if( (gSrcInfo[eWindow].Status2.eFrameStoreNumber == IMAGE_STORE_2_FRAMES) && (!gSrcInfo[eWindow].bInterlace) )
9364 {
9365 u32OPMBase0 = u32DNRBase0 + s32cropshift_base0;
9366 u32OPMBase1 = u32DNRBase1 + s32cropshift_base1;
9367 }
9368
9369 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"[SUPPORT_2_FRAME_MIRROR] u32DNRBase0:%x u32DNRBase1:%x \n", (int)u32DNRBase0,(int)u32DNRBase1);
9370 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"[SUPPORT_2_FRAME_MIRROR] u32OPMBase0:%x u32OPMBase1:%x \n", (int)u32OPMBase0,(int)u32OPMBase1);
9371
9372 #endif
9373
9374 #if 0
9375 if(!pSrcInfo ->bDisplayNineLattice)
9376 {
9377 pSrcInfo->u16V_Length = pSrcInfo->u16V_Length - (gSrcInfo[eWindow].ScaledCropWin.y);
9378 }
9379 #endif
9380
9381 //-----------------------------------------------------------------
9382 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16VLen = pSrcInfo->u16V_Length;
9383 if(eWindow == MAIN_WINDOW)
9384 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16VWritelimit = u16V_Writelimit | F2_V_WRITE_LIMIT_EN;
9385 else
9386 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16VWritelimit = u16V_Writelimit | F1_V_WRITE_LIMIT_EN;
9387 //Fixme: Need add software patch for dual miu crop window.
9388 #ifdef UFO_XC_SUPPORT_DUAL_MIU
9389 if (bIsLeftFactor == FALSE)
9390 {
9391 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualWritelimitBase = u32WritelimitBase;
9392 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DualDNROffset = u16DNROffset;
9393 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DualDNRFetch = *pu16IPMFetch;
9394 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DualLBOffset = u16LBOffset;
9395 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DualDispOffset = u16DispOffset;
9396 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualDNRBase0 = u32DNRBase0;
9397 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualDNRBase1 = u32DNRBase1;
9398 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualDNRBase2 = u32DNRBase2;
9399 if (IsHMirrorMode(eWindow) && IsEnableDualMode(eWindow))
9400 {
9401 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase0 = u32OPMBase0;
9402 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase1 = u32OPMBase1;
9403 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase2 = u32OPMBase2;
9404 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMOffset = u16DNROffset;
9405 }
9406 else
9407 {
9408 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualOPMBase0 = u32OPMBase0;
9409 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualOPMBase1 = u32OPMBase1;
9410 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualOPMBase2 = u32OPMBase2;
9411 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DualOPMOffset = u16DNROffset;
9412 }
9413 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DualOPMFetch = u16OPMFetch;
9414 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DualAlignWidth = u16AlignWidth;
9415 }
9416 else
9417 #endif
9418 {
9419 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32WritelimitBase = u32WritelimitBase;
9420 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DNROffset = u16DNROffset;
9421 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DNRFetch = *pu16IPMFetch;
9422 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16LBOffset = u16LBOffset;
9423 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DispOffset = u16DispOffset;
9424 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase0 = u32DNRBase0;
9425 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase1 = u32DNRBase1;
9426 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase2 = u32DNRBase2;
9427 #ifdef UFO_XC_SUPPORT_DUAL_MIU
9428 if (IsHMirrorMode(eWindow) && IsEnableDualMode(eWindow))
9429 {
9430 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualOPMBase0 = u32OPMBase0;
9431 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualOPMBase1 = u32OPMBase1;
9432 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualOPMBase2 = u32OPMBase2;
9433 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DualOPMOffset = u16DNROffset;
9434 }
9435 else
9436 #endif
9437 {
9438 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase0 = u32OPMBase0;
9439 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase1 = u32OPMBase1;
9440 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase2 = u32OPMBase2;
9441 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMOffset = u16DNROffset;
9442 }
9443 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMFetch = u16OPMFetch;
9444 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16AlignWidth = u16AlignWidth;
9445 }
9446
9447 #ifdef SUPPORT_BWD
9448 if(bBwdEnable)
9449 {
9450 if(u8BitPerPixel == BIT_PER_PIX_VAULE_16)
9451 {
9452 eBPPType = E_XC_BWR_MEM_CFG_BPP_16;
9453 }
9454 else if(u8BitPerPixel == BIT_PER_PIX_VAULE_20)
9455 {
9456 eBPPType = E_XC_BWR_MEM_CFG_BPP_20;
9457 }
9458 else if(u8BitPerPixel == BIT_PER_PIX_VAULE_24)
9459 {
9460 eBPPType = E_XC_BWR_MEM_CFG_BPP_24;
9461 }
9462 #ifdef UFO_XC_SUPPORT_DUAL_MIU
9463 if(bIsLeftFactor == TRUE)
9464 {
9465 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_DNRBase0 = u32DNRBase0;
9466 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_DNRBase1 = u32DNRBase1;
9467 if (IsHMirrorMode(eWindow) && IsEnableDualMode(eWindow))
9468 {
9469 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Right_OPMBase0 = u32OPMBase0;
9470 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Right_OPMBase1 = u32OPMBase1;
9471 }
9472 else
9473 {
9474 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_OPMBase0 = u32OPMBase0;
9475 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_OPMBase1 = u32OPMBase1;
9476 }
9477 //printf("eBPPType: %d u32BWR_Miu_Left_DNRBase0: 0x%x.\n", eBPPType, pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_DNRBase0);
9478 //printf("eBPPType: %d u32BWR_Miu_Left_OPMBase0: 0x%x.\n", eBPPType, pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_OPMBase0);
9479
9480 }
9481 else
9482 {
9483 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Right_DNRBase0 = u32DNRBase0;
9484 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Right_DNRBase1 = u32DNRBase1;
9485 if (IsHMirrorMode(eWindow) && IsEnableDualMode(eWindow))
9486 {
9487 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_OPMBase0 = u32OPMBase0;
9488 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_OPMBase1 = u32OPMBase1;
9489 }
9490 else
9491 {
9492 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Right_OPMBase0 = u32OPMBase0;
9493 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Right_OPMBase1 = u32OPMBase1;
9494 }
9495 //printf("eBPPType: %d u32BWR_Miu_Right_DNRBase0: 0x%x.\n", eBPPType, pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Right_DNRBase0);
9496 //printf("eBPPType: %d u32BWR_Miu_Right_OPMBase0: 0x%x.\n", eBPPType, pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Right_OPMBase0);
9497 }
9498 #else
9499 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_DNRBase0 = u32DNRBase0;
9500 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_DNRBase1 = u32DNRBase1;
9501 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_OPMBase0 = u32OPMBase0;
9502 pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_OPMBase1 = u32OPMBase1;
9503 //printf("eBPPType: %d u32BWR_Miu_Left_DNRBase0: 0x%x.\n", eBPPType, pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_DNRBase0);
9504 //printf("eBPPType: %d u32BWR_Miu_Left_OPMBase0: 0x%x.\n", eBPPType, pSrcInfo->Status2.stBWRBase[eBPPType].u32BWR_Miu_Left_OPMBase0);
9505 #endif
9506 }
9507 #endif
9508
9509 #ifdef UFO_XC_SUPPORT_DUAL_MIU
9510 if (bIsLeftFactor == FALSE)
9511 {
9512 pSrcInfo->Status2.u32DualMiuDNRBase0 = u32DNRBase0 * BYTE_PER_WORD;
9513 pSrcInfo->Status2.u32DualMiuDNRBase1 = u32DNRBase1 * BYTE_PER_WORD;
9514 pSrcInfo->Status2.u32DualMiuDNRBase2 = u32DNRBase2 * BYTE_PER_WORD;
9515 pSrcInfo->Status2.u16DualMiuDNROffset = u16DNROffset;
9516 pSrcInfo->Status2.u16DualMiuIPMFetch = *pu16IPMFetch;
9517 }
9518 else
9519 #endif
9520 {
9521 pSrcInfo->u32IPMBase0 = u32DNRBase0 * BYTE_PER_WORD;
9522 pSrcInfo->u32IPMBase1 = u32DNRBase1 * BYTE_PER_WORD;
9523 pSrcInfo->u32IPMBase2 = u32DNRBase2 * BYTE_PER_WORD;
9524 pSrcInfo->u16IPMOffset = u16DNROffset;
9525 }
9526
9527
9528 #ifndef DISABLE_3D_FUNCTION
9529 MDrv_SC_3D_Adjust_FetchOffset(pInstance, pSrcInfo, eWindow);
9530 #endif
9531
9532 #ifdef ENABLE_SCALING_WO_MUTE
9533 MDrv_SC_Adjust_Skip_OPM_line(pInstance, eWindow);
9534 #endif
9535 //-----------------------------------------------------------------
9536 #ifdef UFO_XC_SUPPORT_DUAL_MIU
9537 if (bIsLeftFactor == FALSE)
9538 {
9539 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final Dual DNR Offset/Fetch=0x%x, 0x%x, OPM Offset/Fetch=0x%x, 0x%x, V_Length=0x%x\n",
9540 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DualDNROffset,
9541 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DualDNRFetch,
9542 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DualOPMOffset,
9543 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DualOPMFetch,
9544 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16VLen);
9545 #if defined (__aarch64__)
9546 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final Dual u32DNRBase0/1/2=0x%lx, 0x%lx, 0x%lx, u32OPMBase0/1/2=0x%lx, 0x%lx, 0x%lx\n",
9547 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualDNRBase0,
9548 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualDNRBase1,
9549 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualDNRBase2,
9550 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualOPMBase0,
9551 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualOPMBase1,
9552 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualOPMBase2);
9553 #else
9554 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final Dual u32DNRBase0/1/2=0x%tx, 0x%tx, 0x%tx, u32OPMBase0/1/2=0x%tx, 0x%tx, 0x%tx\n",
9555 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualDNRBase0,
9556 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualDNRBase1,
9557 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualDNRBase2,
9558 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualOPMBase0,
9559 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualOPMBase1,
9560 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DualOPMBase2);
9561
9562 #endif
9563 }
9564 else
9565 #endif
9566 {
9567 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final DNR Offset/Fetch=0x%x, 0x%x, OPM Offset/Fetch=0x%x, 0x%x, V_Length=0x%x\n",
9568 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DNROffset,
9569 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16DNRFetch,
9570 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMOffset,
9571 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMFetch,
9572 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16VLen);
9573 #if defined (__aarch64__)
9574 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final u32DNRBase0/1/2=0x%lx, 0x%lx, 0x%lx, u32OPMBase0/1/2=0x%lx, 0x%lx, 0x%lx\n",
9575 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase0,
9576 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase1,
9577 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase2,
9578 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase0,
9579 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase1,
9580 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase2);
9581 #else
9582 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"Final u32DNRBase0/1/2=0x%tx, 0x%tx, 0x%tx, u32OPMBase0/1/2=0x%tx, 0x%tx, 0x%tx\n",
9583 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase0,
9584 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase1,
9585 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32DNRBase2,
9586 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase0,
9587 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase1,
9588 (ptrdiff_t)pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32OPMBase2);
9589 #endif
9590 }
9591 XC_LOG_TRACE(XC_DGBLEVEL_CROPCALC,"---------------------------------------------------\n");
9592 }
9593
MDrv_SC_set_fetch_number_limit(void * pInstance,XC_InternalStatus * pSrcInfo,SCALER_WIN eWindow)9594 void MDrv_SC_set_fetch_number_limit(void *pInstance, XC_InternalStatus *pSrcInfo, SCALER_WIN eWindow)
9595 {
9596 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
9597 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
9598 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
9599 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
9600 #ifdef SUPPORT_BWD
9601 #ifdef UFO_XC_SUPPORT_DUAL_MIU
9602 if (IsEnableDualMode(eWindow))
9603 {
9604 _MDrv_SC_set_fetch_number_limit_impl(pInstance, &gSrcInfo[eWindow], BIT_PER_PIX_VAULE_16, TRUE, TRUE, eWindow );
9605 _MDrv_SC_set_fetch_number_limit_impl(pInstance, &gSrcInfo[eWindow], BIT_PER_PIX_VAULE_16, TRUE, FALSE, eWindow );
9606 _MDrv_SC_set_fetch_number_limit_impl(pInstance, &gSrcInfo[eWindow], BIT_PER_PIX_VAULE_20, TRUE, TRUE, eWindow );
9607 _MDrv_SC_set_fetch_number_limit_impl(pInstance, &gSrcInfo[eWindow], BIT_PER_PIX_VAULE_20, TRUE, FALSE, eWindow );
9608 _MDrv_SC_set_fetch_number_limit_impl(pInstance, &gSrcInfo[eWindow], BIT_PER_PIX_VAULE_24, TRUE, TRUE, eWindow );
9609 _MDrv_SC_set_fetch_number_limit_impl(pInstance, &gSrcInfo[eWindow], BIT_PER_PIX_VAULE_24, TRUE, FALSE, eWindow );
9610 }
9611 else
9612 #endif
9613 {
9614 _MDrv_SC_set_fetch_number_limit_impl(pInstance, &gSrcInfo[eWindow], BIT_PER_PIX_VAULE_16, TRUE, TRUE, eWindow );
9615 _MDrv_SC_set_fetch_number_limit_impl(pInstance, &gSrcInfo[eWindow], BIT_PER_PIX_VAULE_20, TRUE, TRUE, eWindow );
9616 _MDrv_SC_set_fetch_number_limit_impl(pInstance, &gSrcInfo[eWindow], BIT_PER_PIX_VAULE_24, TRUE, TRUE, eWindow );
9617 }
9618 #endif
9619 _MDrv_SC_set_fetch_number_limit_impl(pInstance, &gSrcInfo[eWindow], gSrcInfo[eWindow].u8BitPerPixel, FALSE, TRUE, eWindow );
9620
9621 #ifdef UFO_XC_SUPPORT_DUAL_MIU
9622 if (IsEnableDualMode(eWindow))
9623 {
9624 _MDrv_SC_set_fetch_number_limit_impl(pInstance, &gSrcInfo[eWindow], gSrcInfo[eWindow].u8BitPerPixel, FALSE, FALSE, eWindow );
9625 }
9626 #endif
9627 }
9628
MDrv_SC_set_shift_line(void * pInstance,MS_BOOL bFBL,MS_DEINTERLACE_MODE eDeInterlaceMode,SCALER_WIN eWindow)9629 void MDrv_SC_set_shift_line(void *pInstance, MS_BOOL bFBL, MS_DEINTERLACE_MODE eDeInterlaceMode, SCALER_WIN eWindow)
9630 {
9631 MS_U8 u8Val;
9632
9633 if(!bFBL)
9634 { // FB
9635 u8Val = 0x0;
9636 }
9637 else
9638 { // FBL
9639 if((MS_DEINT_2DDI_BOB == eDeInterlaceMode) || (MS_DEINT_2DDI_AVG == eDeInterlaceMode))
9640 u8Val = 0x0;
9641 else
9642 u8Val = 0x2;
9643 }
9644
9645 Hal_SC_set_shiftline(pInstance, u8Val, eWindow );
9646 }
9647
MDrv_XC_EnableMirrorModeEx(void * pInstance,MirrorMode_t eMirrorMode,SCALER_WIN eWindow)9648 MS_BOOL MDrv_XC_EnableMirrorModeEx(void *pInstance, MirrorMode_t eMirrorMode, SCALER_WIN eWindow)
9649 {
9650 MS_BOOL bRet = FALSE;
9651 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
9652 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
9653 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
9654 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
9655
9656 #if (PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB == 1)
9657 MS_BOOL bNeedRestore = FALSE;
9658 #endif
9659
9660 switch (eMirrorMode)
9661 {
9662 case MIRROR_NORMAL:
9663 case MIRROR_H_ONLY:
9664 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.bMirror = FALSE;
9665 bRet = TRUE;
9666 break;
9667 case MIRROR_V_ONLY:
9668 case MIRROR_HV:
9669 pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.bMirror = TRUE;
9670 bRet = TRUE;
9671 break;
9672 default:
9673 printf("Unsupport MirrorMode Type\n ");
9674 eMirrorMode = MIRROR_NORMAL;
9675 bRet = FALSE;
9676 break;
9677 }
9678 gSrcInfo[eWindow].Status2.eMirrorMode = eMirrorMode;
9679
9680 #if (PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB == 1)
9681 if((psXCInstPri->u32DeviceID == E_XC_DEVICE1) && (Hal_SC_Is_InputSource_Disable(pInstance, eWindow) == FALSE))
9682 {
9683 bNeedRestore = TRUE;
9684 }
9685 #endif
9686
9687 MDrv_XC_DisableInputSource(pInstance, TRUE, eWindow);
9688 MDrv_SC_set_mirrorEx(pInstance, eMirrorMode, eWindow);
9689
9690 #if (PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB == 1)
9691 if((psXCInstPri->u32DeviceID == E_XC_DEVICE1) && bNeedRestore)
9692 {
9693 bNeedRestore = FALSE;
9694 MDrv_XC_DisableInputSource(pInstance, FALSE, eWindow);
9695 }
9696 #endif
9697
9698 return bRet;
9699 }
9700
MDrv_SC_set_mirror(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)9701 void MDrv_SC_set_mirror(void *pInstance, MS_BOOL bEnable, SCALER_WIN eWindow)
9702 {
9703 MS_PHY u32WritelimitBase;
9704 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
9705 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
9706 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
9707 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
9708
9709 #if (HW_DESIGN_4K2K_VER != 4)
9710 if ( bEnable )
9711 {
9712 // Set Limit at top of frame buffer
9713 //limit_min :(0: Maximum 1: Minimum)
9714 if(eWindow == MAIN_WINDOW)
9715 u32WritelimitBase = (MS_IPM_BASE0(eWindow) - 1) | F2_WRITE_LIMIT_EN | F2_WRITE_LIMIT_MIN;
9716 else
9717 u32WritelimitBase = (MS_IPM_BASE0(eWindow) - 1) | F1_WRITE_LIMIT_EN | F1_WRITE_LIMIT_MIN;
9718 }
9719 else
9720 {
9721 // Set limit at bottom of frame buffer
9722 if(eWindow == MAIN_WINDOW)
9723 u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) | F2_WRITE_LIMIT_EN;
9724 else
9725 u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) | F1_WRITE_LIMIT_EN;
9726 }
9727 Hal_SC_set_write_limit(pInstance, u32WritelimitBase, eWindow);
9728 Hal_SC_set_mirror(pInstance, bEnable, eWindow );
9729 #else
9730 if (
9731 (((psXCInstPri->u32DeviceID == 0) && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_LEGACY_MODE))
9732 ||(psXCInstPri->u32DeviceID == 1))
9733 || (IS_INPUT_4K2K(eWindow))
9734 )
9735 {
9736 if ( bEnable )
9737 {
9738 // Set Limit at top of frame buffer
9739 //limit_min :(0: Maximum 1: Minimum)
9740 if(eWindow == MAIN_WINDOW)
9741 u32WritelimitBase = (MS_IPM_BASE0(eWindow) - 1) | F2_WRITE_LIMIT_EN | F2_WRITE_LIMIT_MIN;
9742 else
9743 u32WritelimitBase = (MS_IPM_BASE0(eWindow) - 1) | F1_WRITE_LIMIT_EN | F1_WRITE_LIMIT_MIN;
9744 }
9745 else
9746 {
9747 // Set limit at bottom of frame buffer
9748 if(eWindow == MAIN_WINDOW)
9749 u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) | F2_WRITE_LIMIT_EN;
9750 else
9751 u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) | F1_WRITE_LIMIT_EN;
9752 }
9753 Hal_SC_set_write_limit(pInstance, u32WritelimitBase, eWindow);
9754 Hal_SC_set_mirror(pInstance, bEnable, eWindow );
9755 }
9756 else
9757 {
9758 if ( bEnable )
9759 {
9760 // Set Limit at top of frame buffer
9761 //limit_min :(0: Maximum 1: Minimum)
9762 if(eWindow == MAIN_WINDOW)
9763 u32WritelimitBase = (MS_FRCM_BASE0(eWindow) - 1) | F2_WRITE_LIMIT_EN | F2_WRITE_LIMIT_MIN;
9764 else
9765 u32WritelimitBase = (MS_FRCM_BASE0(eWindow) - 1) | F1_WRITE_LIMIT_EN | F1_WRITE_LIMIT_MIN;
9766 }
9767 else
9768 {
9769 // Set limit at bottom of frame buffer
9770 if(eWindow == MAIN_WINDOW)
9771 u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow]) / BYTE_PER_WORD - 1) | F2_WRITE_LIMIT_EN;
9772 else
9773 u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow]) / BYTE_PER_WORD - 1) | F1_WRITE_LIMIT_EN;
9774 }
9775 Hal_SC_set_frcm_write_limit(pInstance, u32WritelimitBase, eWindow);
9776 Hal_SC_set_frcm_mirror(pInstance, bEnable, eWindow );
9777 if (gSrcInfo[eWindow].bMemYUVFmt)
9778 {
9779 if (bEnable)
9780 {
9781 MDrv_SC_set_frcm_cbcr_swap(pInstance, TRUE, eWindow);
9782 }
9783 else
9784 {
9785 MDrv_SC_set_frcm_cbcr_swap(pInstance, FALSE, eWindow);
9786 }
9787 }
9788 }
9789 #endif
9790 }
9791
_MDrv_SC_Set_Mirror(void * pInstance,MirrorMode_t eMirrorMode,SCALER_WIN eWindow)9792 static void _MDrv_SC_Set_Mirror(void *pInstance, MirrorMode_t eMirrorMode, SCALER_WIN eWindow)
9793 {
9794 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
9795 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
9796 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
9797 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
9798 MS_U32 u32MirrorReg;
9799
9800 #if (HW_DESIGN_4K2K_VER != 4)
9801 if(eWindow == MAIN_WINDOW)
9802 {
9803 u32MirrorReg = REG_SC_BK12_03_L;
9804 }
9805 else
9806 {
9807 u32MirrorReg = REG_SC_BK12_43_L;
9808 }
9809 #else
9810 if (
9811 (((psXCInstPri->u32DeviceID == 0) && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_LEGACY_MODE))
9812 ||(psXCInstPri->u32DeviceID == 1))
9813 ||(IS_INPUT_4K2K(eWindow))
9814 )
9815 {
9816 if(eWindow == MAIN_WINDOW)
9817 {
9818 u32MirrorReg = REG_SC_BK12_03_L;
9819 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK32_03_L, 0, BIT(12));
9820 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK32_03_L, 0, BIT(13));
9821 }
9822 else
9823 {
9824 u32MirrorReg = REG_SC_BK12_43_L;
9825 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK32_43_L, 0, BIT(12));
9826 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK32_43_L, 0, BIT(13));
9827 }
9828 }
9829 else
9830 {
9831 if(eWindow == MAIN_WINDOW)
9832 {
9833 u32MirrorReg = REG_SC_BK32_03_L;
9834 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_03_L, 0, BIT(12));
9835 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_03_L, 0, BIT(13));
9836 }
9837 else
9838 {
9839 u32MirrorReg = REG_SC_BK32_43_L;
9840 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_43_L, 0, BIT(12));
9841 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_43_L, 0, BIT(13));
9842 }
9843 }
9844 #endif
9845
9846 if (eMirrorMode == MIRROR_NORMAL)
9847 {
9848 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32MirrorReg, 0, BIT(12));
9849 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32MirrorReg, 0, BIT(13));
9850 MDrv_SC_set_frcm_cbcr_swap(pInstance, FALSE, eWindow);
9851 }
9852 else if (eMirrorMode == MIRROR_H_ONLY)
9853 {
9854 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32MirrorReg, BIT(12), BIT(12));
9855 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32MirrorReg, 0, BIT(13));
9856 if (!IS_INPUT_4K2K(eWindow))
9857 {
9858 if (gSrcInfo[eWindow].bMemYUVFmt)
9859 {
9860 MDrv_SC_set_frcm_cbcr_swap(pInstance, TRUE, eWindow);
9861 }
9862 }
9863 }
9864 else if (eMirrorMode == MIRROR_V_ONLY)
9865 {
9866 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32MirrorReg, 0, BIT(12));
9867 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32MirrorReg, BIT(13), BIT(13));
9868 MDrv_SC_set_frcm_cbcr_swap(pInstance, FALSE, eWindow);
9869
9870 #if SUPPORT_2_FRAME_MIRROR
9871 SC_W2BYTEMSK(u32MirrorReg, 0, BIT(13)); //disable original V mirror
9872 #endif
9873 }
9874 else// MIRROR_HV
9875 {
9876 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32MirrorReg, (BIT(12)|BIT(13)), (BIT(12)|BIT(13)));
9877 if (!IS_INPUT_4K2K(eWindow))
9878 {
9879 if (gSrcInfo[eWindow].bMemYUVFmt)
9880 {
9881 MDrv_SC_set_frcm_cbcr_swap(pInstance, TRUE, eWindow);
9882 }
9883 }
9884 #if SUPPORT_2_FRAME_MIRROR
9885 SC_W2BYTEMSK(u32MirrorReg, 0, BIT(13)); //disable original V mirror
9886 #endif
9887 }
9888
9889 }
9890
MDrv_SC_set_mirrorEx(void * pInstance,MirrorMode_t eMirrorMode,SCALER_WIN eWindow)9891 void MDrv_SC_set_mirrorEx(void *pInstance, MirrorMode_t eMirrorMode, SCALER_WIN eWindow)
9892 {
9893 MS_PHY u32WritelimitBase = 0;
9894 #if (HW_DESIGN_4K2K_VER == 4)
9895 MS_PHY u32FRCMWritelimitBase = 0;
9896 #endif
9897 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
9898 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
9899 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
9900 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
9901
9902 #if (HW_DESIGN_4K2K_VER != 4)
9903 if ( (eMirrorMode == MIRROR_HV) || (eMirrorMode == MIRROR_V_ONLY) )
9904 {
9905 // Set Limit at top of frame buffer
9906 //limit_min :(0: Maximum 1: Minimum)
9907 if(eWindow == MAIN_WINDOW)
9908 u32WritelimitBase = (MS_IPM_BASE0(eWindow) - 1) | F2_WRITE_LIMIT_EN | F2_WRITE_LIMIT_MIN;
9909 else
9910 u32WritelimitBase = (MS_IPM_BASE0(eWindow) - 1) | F1_WRITE_LIMIT_EN | F1_WRITE_LIMIT_MIN;
9911 }
9912 else // NORMAL or H_MIRROR case
9913 {
9914 // Set limit at bottom of frame buffer
9915 if(eWindow == MAIN_WINDOW)
9916 u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) | F2_WRITE_LIMIT_EN;
9917 else
9918 u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) | F1_WRITE_LIMIT_EN;
9919 }
9920 Hal_SC_set_write_limit(pInstance, u32WritelimitBase, eWindow);
9921 _MDrv_SC_Set_Mirror(pInstance, eMirrorMode, eWindow);
9922 #else
9923 if (
9924 (((psXCInstPri->u32DeviceID == 0) && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_LEGACY_MODE))
9925 ||(psXCInstPri->u32DeviceID == 1))
9926 ||(IS_INPUT_4K2K(eWindow))
9927 )
9928 {
9929 if ( (eMirrorMode == MIRROR_HV) || (eMirrorMode == MIRROR_V_ONLY) )
9930 {
9931 // Set Limit at top of frame buffer
9932 //limit_min :(0: Maximum 1: Minimum)
9933 if(eWindow == MAIN_WINDOW)
9934 u32WritelimitBase = (MS_IPM_BASE0(eWindow) - 1) | F2_WRITE_LIMIT_EN | F2_WRITE_LIMIT_MIN;
9935 else
9936 u32WritelimitBase = (MS_IPM_BASE0(eWindow) - 1) | F1_WRITE_LIMIT_EN | F1_WRITE_LIMIT_MIN;
9937 }
9938 else // NORMAL or H_MIRROR case
9939 {
9940 // Set limit at bottom of frame buffer
9941 if(eWindow == MAIN_WINDOW)
9942 u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) | F2_WRITE_LIMIT_EN;
9943 else
9944 u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) | F1_WRITE_LIMIT_EN;
9945 }
9946 Hal_SC_set_write_limit(pInstance, u32WritelimitBase, eWindow);
9947 _MDrv_SC_Set_Mirror(pInstance, eMirrorMode, eWindow);
9948 }
9949 else
9950 {
9951
9952 if ( (eMirrorMode == MIRROR_HV) || (eMirrorMode == MIRROR_V_ONLY) )
9953 {
9954 // Set Limit at top of frame buffer
9955 //limit_min :(0: Maximum 1: Minimum)
9956 if(eWindow == MAIN_WINDOW)
9957 {
9958 u32WritelimitBase = (MS_IPM_BASE0(eWindow) - 1) | F2_WRITE_LIMIT_EN;
9959 u32FRCMWritelimitBase = (MS_FRCM_BASE0(eWindow) - 1) | F2_FRCM_WRITE_LIMIT_EN;
9960 }
9961 else
9962 {
9963 u32WritelimitBase = (MS_IPM_BASE0(eWindow) - 1) | F1_WRITE_LIMIT_EN;
9964 u32FRCMWritelimitBase = (MS_FRCM_BASE1(eWindow) - 1) | F1_FRCM_WRITE_LIMIT_EN;
9965
9966 }
9967 }
9968 else // NORMAL or H_MIRROR case
9969 {
9970 // Set limit at bottom of frame buffer
9971 if(eWindow == MAIN_WINDOW)
9972 {
9973 u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) | F2_WRITE_LIMIT_EN;
9974 u32FRCMWritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow]) / BYTE_PER_WORD - 1) | F2_FRCM_WRITE_LIMIT_EN;
9975 }
9976 else
9977 {
9978 u32WritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32DNRBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow]) / BYTE_PER_WORD - 1) | F1_WRITE_LIMIT_EN;
9979 u32FRCMWritelimitBase = ((pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBaseAddr0[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow]) / BYTE_PER_WORD - 1) | F1_FRCM_WRITE_LIMIT_EN;
9980 }
9981 }
9982
9983 Hal_SC_set_write_limit(pInstance, u32WritelimitBase, eWindow);
9984 /// the following can be ignored
9985 //Hal_SC_set_frcm_write_limit(pInstance, u32FRCMWritelimitBase, eWindow);
9986 _MDrv_SC_Set_Mirror(pInstance, eMirrorMode, eWindow);
9987 }
9988 #endif
9989 }
9990
MDrv_XC_FilLineBuffer(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)9991 void MDrv_XC_FilLineBuffer(void *pInstance, MS_BOOL bEnable, SCALER_WIN eWindow)
9992 {
9993 HAL_SC_FillLineBuffer(pInstance, bEnable, eWindow);
9994 }
9995
MDrv_XC_GetHSizeChangeManuallyFlag(void * pInstance,SCALER_WIN eWindow)9996 MS_BOOL MDrv_XC_GetHSizeChangeManuallyFlag(void *pInstance, SCALER_WIN eWindow)
9997 {
9998 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
9999 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10000 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10001 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10002 return pXCResourcePrivate->stdrvXC_Scaling._bHSizeChangedManually;
10003 }
10004
MDrv_XC_GetIPMBase(void * pInstance,MS_U8 num,SCALER_WIN eWindow)10005 MS_PHY MDrv_XC_GetIPMBase(void *pInstance, MS_U8 num, SCALER_WIN eWindow)
10006 {
10007 MS_PHY Addr = 0;
10008 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10009 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10010 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10011 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10012 if (num == 0)
10013 {
10014 Addr = MS_IPM_BASE0(eWindow);
10015 }
10016 else if (num == 1)
10017 {
10018 Addr = MS_IPM_BASE1(eWindow);
10019 }
10020 return Addr;
10021 }
10022
MDrv_XC_GetDNRBufSize(void * pInstance,SCALER_WIN eWindow)10023 MS_U32 MDrv_XC_GetDNRBufSize(void *pInstance, SCALER_WIN eWindow)
10024 {
10025 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10026 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10027 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10028 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10029 return pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow];
10030 }
10031
MDrv_XC_SetDNRBufSize(void * pInstance,MS_U32 u32DNRBufSize,SCALER_WIN eWindow)10032 void MDrv_XC_SetDNRBufSize(void *pInstance, MS_U32 u32DNRBufSize, SCALER_WIN eWindow)
10033 {
10034 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10035 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10036 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10037 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10038 pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow] = u32DNRBufSize;
10039 }
10040
MDrv_XC_GetDualIPMBase(void * pInstance,MS_U8 num,SCALER_WIN eWindow)10041 MS_PHY MDrv_XC_GetDualIPMBase(void *pInstance, MS_U8 num, SCALER_WIN eWindow)
10042 {
10043 #ifdef UFO_XC_SUPPORT_DUAL_MIU
10044 MS_PHY Addr = 0;
10045 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10046 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10047 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10048 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10049 if (num == 0)
10050 {
10051 Addr = MS_IPM_DUAL_MIU_BASE0(eWindow);
10052 }
10053 else if (num == 1)
10054 {
10055 Addr = MS_IPM_DUAL_MIU_BASE1(eWindow);
10056 }
10057 return Addr;
10058 #else
10059 return 0;
10060 #endif
10061 }
10062
MDrv_XC_GetDualDNRBufSize(void * pInstance,SCALER_WIN eWindow)10063 MS_U32 MDrv_XC_GetDualDNRBufSize(void *pInstance, SCALER_WIN eWindow)
10064 {
10065 #ifdef UFO_XC_SUPPORT_DUAL_MIU
10066 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10067 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10068 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10069 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10070 return pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBufSize[eWindow];
10071 #else
10072 return 0;
10073 #endif
10074 }
10075
MDrv_XC_SetDualDNRBufSize(void * pInstance,MS_U32 u32DNRBufSize,SCALER_WIN eWindow)10076 void MDrv_XC_SetDualDNRBufSize(void *pInstance, MS_U32 u32DNRBufSize, SCALER_WIN eWindow)
10077 {
10078 #ifdef UFO_XC_SUPPORT_DUAL_MIU
10079 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10080 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10081 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10082 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10083 pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBufSize[eWindow] = u32DNRBufSize;
10084 #endif
10085 }
10086
10087
10088 // calc width or height based on existed dnr buffer and byte/pixel
MDrv_XC_GetAvailableSize(void * pInstance,SCALER_WIN eWindow,MS_U8 u8FBNum,MS_U32 u32InputSize)10089 MS_U32 MDrv_XC_GetAvailableSize(void *pInstance, SCALER_WIN eWindow, MS_U8 u8FBNum, MS_U32 u32InputSize)
10090 {
10091 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10092 MS_U32 u32FrameBuffSize = 0;
10093 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10094 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10095 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10096 if(u8FBNum == 0)
10097 {
10098 printf("[%s,%5d] the u8FBNum cannot be zero\n",__FUNCTION__,__LINE__);
10099 return 0;
10100 }
10101
10102 if(u32InputSize == 0)
10103 {
10104 printf("[%s,%5d] the u32InputSize cannot be zero\n",__FUNCTION__,__LINE__);
10105 return 0;
10106 }
10107
10108 if(gSrcInfo[eWindow].u8BitPerPixel == 0)
10109 {
10110 printf("[%s,%5d] the u8BitPerPixel cannot be zero\n",__FUNCTION__,__LINE__);
10111 return 0;
10112 }
10113
10114 #if (HW_DESIGN_4K2K_VER == 4)
10115 if((!(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_LEGACY_MODE)
10116 &&(IS_INPUT_4K2K(eWindow)))
10117 ||((E_XC_3D_INPUT_FRAME_ALTERNATIVE == MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow)) && (!(gSrcInfo[eWindow].bInterlace))))
10118 {
10119 u32FrameBuffSize = pXCResourcePrivate->stdrvXC_Scaling._u32FRCMBufSize[eWindow];
10120 }
10121 else
10122 #endif
10123 {
10124 #ifdef UFO_XC_SUPPORT_DUAL_MIU
10125 if (IsEnableDualMode(eWindow))
10126 {
10127 u32FrameBuffSize = pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow] + pXCResourcePrivate->stdrvXC_Scaling._u32DualMiuDNRBufSize[eWindow];
10128 }
10129 else
10130 #endif
10131 {
10132 u32FrameBuffSize = pXCResourcePrivate->stdrvXC_Scaling._u32DNRBufSize[eWindow];
10133 }
10134 }
10135
10136 return (u32FrameBuffSize * 8 / u8FBNum / gSrcInfo[eWindow].u8BitPerPixel / u32InputSize);
10137 }
10138
MApi_XC_GetAvailableSize_U2(void * pInstance,SCALER_WIN eWindow,MS_U8 u8FBNum,MS_U32 u32InputSize)10139 MS_U32 MApi_XC_GetAvailableSize_U2(void* pInstance, SCALER_WIN eWindow, MS_U8 u8FBNum, MS_U32 u32InputSize)
10140 {
10141 MS_U32 u32Return = 0;
10142 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10143 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10144 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
10145 u32Return = MDrv_XC_GetAvailableSize(pInstance, eWindow, u8FBNum, u32InputSize);
10146 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
10147 return u32Return;
10148 }
10149
MApi_XC_GetAvailableSize(SCALER_WIN eWindow,MS_U8 u8FBNum,MS_U32 u32InputSize)10150 MS_U32 MApi_XC_GetAvailableSize(SCALER_WIN eWindow, MS_U8 u8FBNum, MS_U32 u32InputSize)
10151 {
10152 if (pu32XCInst == NULL)
10153 {
10154 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
10155 return 0;
10156 }
10157
10158 stXC_GET_AVAILABLE_SIZE XCArgs;
10159 XCArgs.eWindow = eWindow;
10160 XCArgs.u8FBNum = u8FBNum;
10161 XCArgs.u32InputSize = u32InputSize;
10162 XCArgs.u32ReturnValue = 0;
10163
10164 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_AVAILABLE_SIZE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
10165 {
10166 printf("Obtain XC engine fail\n");
10167 return 0;
10168 }
10169 else
10170 {
10171 return XCArgs.u32ReturnValue;
10172 }
10173 }
10174
MDrv_SC_Set_pre_align_pixel(void * pInstance,MS_BOOL bEnable,MS_U16 pixels,SCALER_WIN eWindow)10175 void MDrv_SC_Set_pre_align_pixel(void *pInstance, MS_BOOL bEnable, MS_U16 pixels, SCALER_WIN eWindow)
10176 {
10177 Hal_SC_set_pre_align_pixel(pInstance, bEnable, pixels, eWindow );
10178 }
10179
MDrv_SC_ClearScalingFactorForInternalCalib(void * pInstance)10180 void MDrv_SC_ClearScalingFactorForInternalCalib(void *pInstance)
10181 {
10182 Hal_XC_ClearScalingFactorForInternalCalib(pInstance);
10183 }
10184
MDrv_SC_Enable_PreScaling(void * pInstance,MS_BOOL bHSDEnable,MS_BOOL bVSDEnable,SCALER_WIN eWindow)10185 void MDrv_SC_Enable_PreScaling(void *pInstance, MS_BOOL bHSDEnable, MS_BOOL bVSDEnable, SCALER_WIN eWindow)
10186 {
10187 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10188 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10189 if(eWindow==MAIN_WINDOW)
10190 {
10191 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_05_L, bHSDEnable<<15, BIT(15));
10192 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_09_L, bVSDEnable<<15, BIT(15));
10193 }
10194 else
10195 {
10196 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK04_05_L, bHSDEnable<<15, BIT(15));
10197 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK04_09_L, bVSDEnable<<15, BIT(15));
10198 }
10199 }
10200
MDrv_SC_Enable_PostScaling(void * pInstance,MS_BOOL bHSPEnable,MS_BOOL bVSPEnable,SCALER_WIN eWindow)10201 void MDrv_SC_Enable_PostScaling(void *pInstance, MS_BOOL bHSPEnable, MS_BOOL bVSPEnable, SCALER_WIN eWindow)
10202 {
10203 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10204 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10205 if(eWindow == MAIN_WINDOW)
10206 {
10207 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK23_08_L, bHSPEnable<<8, BIT(8));
10208 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK23_0A_L, bVSPEnable<<8, BIT(8));
10209 }
10210 else
10211 {
10212 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK23_28_L, bHSPEnable<<8, BIT(8));
10213 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK23_2A_L, bVSPEnable<<8, BIT(8));
10214 }
10215 }
10216
MDrv_SC_SetFullRangeCapture(void * pInstance,SCALER_WIN eWindow)10217 void MDrv_SC_SetFullRangeCapture(void *pInstance, SCALER_WIN eWindow)
10218 {
10219 Hal_SC_ip_set_capture_v_start(pInstance, 0x06,eWindow);
10220 Hal_SC_ip_set_capture_h_start(pInstance, 0x06,eWindow);
10221 Hal_SC_ip_set_capture_v_size(pInstance, 0x1FFF,eWindow);
10222 Hal_SC_ip_set_capture_h_size(pInstance, 0x1FFF,eWindow);
10223 }
10224
MDrv_SC_GetScmiV1Speical4frame(void * pInstance,XC_FRAME_STORE_NUMBER enStoreNum)10225 MS_BOOL MDrv_SC_GetScmiV1Speical4frame(void *pInstance, XC_FRAME_STORE_NUMBER enStoreNum)
10226 {
10227 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10228 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10229 return (enStoreNum == IMAGE_STORE_4_FRAMES) && ((SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK12_04_L) & BIT(6)) != 0);
10230 }
10231
10232
10233 //-------------------------------------------------------------------------------------------------
10234 /// Set two initial factors mode to improve quality in FBL
10235 /// @param bEnable \b IN: enable or disable two initial factors mode
10236 /// @param eWindow \b IN: @ref SCALER_WIN
10237 //-------------------------------------------------------------------------------------------------
MApi_XC_Enable_TwoInitFactor_U2(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)10238 MS_BOOL MApi_XC_Enable_TwoInitFactor_U2(void* pInstance, MS_BOOL bEnable, SCALER_WIN eWindow)
10239 {
10240 MS_BOOL bRet = FALSE;
10241 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10242 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10243 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
10244 _XC_ENTRY(pInstance);
10245 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10246 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10247 if(bEnable)
10248 {
10249 #ifdef UFO_XC_FB_LEVEL
10250 if(((gSrcInfo[MAIN_WINDOW].eFBLevel == E_XC_FB_LEVEL_FBL) || (gSrcInfo[MAIN_WINDOW].eFBLevel == E_XC_FB_LEVEL_RFBL_DI))
10251 && gSrcInfo[MAIN_WINDOW].bInterlace
10252 )
10253 #else
10254 if(gSrcInfo[MAIN_WINDOW].bFBL && gSrcInfo[MAIN_WINDOW].bInterlace)
10255 #endif
10256 {
10257 HAL_SC_Enable_VInitFactor(pInstance, TRUE, eWindow);
10258 bRet = TRUE;
10259 }
10260 }
10261 else
10262 {
10263 HAL_SC_Enable_VInitFactor(pInstance, FALSE, eWindow);
10264 bRet = TRUE;
10265 }
10266
10267 _XC_RETURN(pInstance);
10268 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
10269 return bRet;
10270 }
10271
MApi_XC_Enable_TwoInitFactor(MS_BOOL bEnable,SCALER_WIN eWindow)10272 MS_BOOL MApi_XC_Enable_TwoInitFactor(MS_BOOL bEnable, SCALER_WIN eWindow)
10273 {
10274 if (pu32XCInst == NULL)
10275 {
10276 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
10277 return FALSE;
10278 }
10279
10280 stXC_SET_2INITFACTOR_ENABLE XCArgs;
10281 XCArgs.bEnable = bEnable;
10282 XCArgs.eWindow = eWindow;
10283 XCArgs.bReturnValue = FALSE;
10284
10285 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_2INITFACTOR_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
10286 {
10287 printf("Obtain XC engine fail\n");
10288 return FALSE;
10289 }
10290 else
10291 {
10292 return XCArgs.bReturnValue;
10293 }
10294 }
10295
MDrv_XC_GetUCEnabled(void * pInstance,SCALER_WIN eWindow)10296 MS_BOOL MDrv_XC_GetUCEnabled(void *pInstance, SCALER_WIN eWindow)
10297 {
10298 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10299 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10300 MS_BOOL bUCEnabled = FALSE;
10301
10302 if (eWindow == MAIN_WINDOW)
10303 {
10304 bUCEnabled = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2A_02_L, 0x8000) >> 15;
10305 }
10306 else
10307 {
10308 bUCEnabled = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2A_02_L, 0x2000) >> 13;
10309 }
10310
10311 return bUCEnabled;
10312 }
10313
MApi_XC_GetUCEnabled_U2(void * pInstance,SCALER_WIN eWindow)10314 MS_BOOL MApi_XC_GetUCEnabled_U2(void* pInstance, SCALER_WIN eWindow)
10315 {
10316 MS_BOOL bUCEnabled;
10317
10318 _XC_ENTRY(pInstance);
10319 bUCEnabled = MDrv_XC_GetUCEnabled(pInstance, eWindow);
10320 _XC_RETURN(pInstance);
10321
10322 return bUCEnabled;
10323 }
10324
MApi_XC_GetUCEnabled(SCALER_WIN eWindow)10325 MS_BOOL MApi_XC_GetUCEnabled(SCALER_WIN eWindow)
10326 {
10327 if (pu32XCInst == NULL)
10328 {
10329 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
10330 return FALSE;
10331 }
10332
10333 stXC_CHECK_UC_ENABLED XCArgs;
10334 XCArgs.eWindow = eWindow;
10335 XCArgs.bReturnValue = FALSE;
10336
10337 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_CHECK_UC_ENABLED, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
10338 {
10339 printf("Obtain XC engine fail\n");
10340 return FALSE;
10341 }
10342 else
10343 {
10344 return XCArgs.bReturnValue;
10345 }
10346 }
10347
MApi_XC_SetWRBankMappingNum_U2(void * pInstance,MS_U8 u8Val,SCALER_WIN eWindow)10348 void MApi_XC_SetWRBankMappingNum_U2(void* pInstance, MS_U8 u8Val, SCALER_WIN eWindow)
10349 {
10350 _XC_ENTRY(pInstance);
10351 Hal_SC_set_wr_bank_mapping_num(pInstance, u8Val, eWindow);
10352 _XC_RETURN(pInstance);
10353 }
10354
MApi_XC_SetWRBankMappingNum(MS_U8 u8Val,SCALER_WIN eWindow)10355 void MApi_XC_SetWRBankMappingNum(MS_U8 u8Val, SCALER_WIN eWindow)
10356 {
10357 if (pu32XCInst == NULL)
10358 {
10359 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
10360 return;
10361 }
10362
10363 stXC_SET_RWBANK_MAPPING_NUM XCArgs;
10364 XCArgs.u8Val = u8Val;
10365 XCArgs.eWindow = eWindow;
10366
10367 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_RWBANK_MAPPING_NUM, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
10368 {
10369 printf("Obtain XC engine fail\n");
10370 return;
10371 }
10372 else
10373 {
10374 return;
10375 }
10376 }
10377
MApi_XC_GetWRBankMappingNum_U2(void * pInstance,SCALER_WIN eWindow)10378 MS_U8 MApi_XC_GetWRBankMappingNum_U2(void* pInstance, SCALER_WIN eWindow)
10379 {
10380 MS_U8 u8WRBankMappingNum = 0;
10381
10382 //_XC_ENTRY(pInstance);
10383 u8WRBankMappingNum = Hal_SC_Get_WR_Bank_Mapping_Num(pInstance, eWindow);
10384 //_XC_RETURN(pInstance);
10385 return u8WRBankMappingNum;
10386 }
10387
MApi_XC_GetWRBankMappingNum(SCALER_WIN eWindow)10388 MS_U8 MApi_XC_GetWRBankMappingNum(SCALER_WIN eWindow)
10389 {
10390 if (pu32XCInst == NULL)
10391 {
10392 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
10393 return 0;
10394 }
10395
10396 stXC_GET_RWBANK_MAPPING_NUM XCArgs;
10397 XCArgs.eWindow = eWindow;
10398 XCArgs.u8ReturnValue = 0;
10399
10400 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_RWBANK_MAPPING_NUM, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
10401 {
10402 printf("Obtain XC engine fail\n");
10403 return 0;
10404 }
10405 else
10406 {
10407 return XCArgs.u8ReturnValue;
10408 }
10409 }
10410
MApi_XC_GetWRBankMappingNumForZap_U2(void * pInstance,SCALER_WIN eWindow)10411 MS_U8 MApi_XC_GetWRBankMappingNumForZap_U2(void* pInstance, SCALER_WIN eWindow)
10412 {
10413 MS_U8 u8WRBankMappingNum = 0;
10414 XC_ApiStatus stXCStatus;
10415 memset(&stXCStatus, 0, sizeof(XC_ApiStatus));
10416
10417 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10418 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10419 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
10420 _XC_ENTRY(pInstance);
10421 if (MDrv_XC_GetStatus(pInstance, &stXCStatus, eWindow))
10422 {
10423 MS_BOOL bInterlace = stXCStatus.bInterlace;
10424 MS_BOOL bUCEnabled = MDrv_XC_GetUCEnabled(pInstance, eWindow);
10425
10426 u8WRBankMappingNum = Hal_SC_Get_WR_Bank_Mapping_Num(pInstance, eWindow);
10427
10428 if (bUCEnabled)
10429 {
10430 if (bInterlace)
10431 {
10432 u8WRBankMappingNum += 2;
10433 }
10434 else
10435 {
10436 u8WRBankMappingNum = 3;
10437 }
10438 }
10439 }
10440 else
10441 {
10442 printf("[%s]:get status fail!\n",__FUNCTION__);
10443 }
10444 _XC_RETURN(pInstance);
10445 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
10446 return u8WRBankMappingNum;
10447 }
10448
MApi_XC_GetWRBankMappingNumForZap(SCALER_WIN eWindow)10449 MS_U8 MApi_XC_GetWRBankMappingNumForZap(SCALER_WIN eWindow)
10450 {
10451 if (pu32XCInst == NULL)
10452 {
10453 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
10454 return 0;
10455 }
10456
10457 stXC_GET_RWBANK_MAPPING_NUM_FOR_ZAP XCArgs;
10458 XCArgs.eWindow = eWindow;
10459 XCArgs.u8ReturnValue = 0;
10460
10461 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_RWBANK_MAPPING_NUM_FOR_ZAP, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
10462 {
10463 printf("Obtain XC engine fail\n");
10464 return 0;
10465 }
10466 else
10467 {
10468 return XCArgs.u8ReturnValue;
10469 }
10470 }
10471
MApi_XC_SetBOBMode_U2(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)10472 MS_BOOL MApi_XC_SetBOBMode_U2(void* pInstance, MS_BOOL bEnable, SCALER_WIN eWindow)
10473 {
10474 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10475 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10476 MS_BOOL bRet = FALSE;
10477 XC_ApiStatus stXCStatus;
10478 memset(&stXCStatus, 0, sizeof(XC_ApiStatus));
10479
10480 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
10481 _XC_ENTRY(pInstance);
10482 if (MDrv_XC_GetStatus(pInstance, &stXCStatus, eWindow))
10483 {
10484 MS_BOOL bInterlace = stXCStatus.bInterlace;
10485
10486 if (eWindow == MAIN_WINDOW)
10487 {
10488 if (bInterlace && bEnable)
10489 {
10490 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK22_78_L, 0x008F, 0x00FF);
10491 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK22_79_L, 0x008F, 0x00FF);
10492 }
10493 else
10494 {
10495 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK22_78_L, 0, 0x00FF);
10496 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK22_79_L, 0, 0x00FF);
10497 }
10498 }
10499 else
10500 {
10501 if (bInterlace && bEnable)
10502 {
10503 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK22_78_L, 0x8F00, 0xFF00);
10504 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK22_79_L, 0x8F00, 0xFF00);
10505 }
10506 else
10507 {
10508 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK22_78_L, 0, 0xFF00);
10509 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK22_79_L, 0, 0xFF00);
10510 }
10511 }
10512 bRet = TRUE;
10513 }
10514 else
10515 {
10516 printf("[%s]:get status fail!\n",__FUNCTION__);
10517 bRet = FALSE;
10518 }
10519 _XC_RETURN(pInstance);
10520 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
10521 return bRet;
10522 }
10523
MApi_XC_SetBOBMode(MS_BOOL bEnable,SCALER_WIN eWindow)10524 MS_BOOL MApi_XC_SetBOBMode(MS_BOOL bEnable, SCALER_WIN eWindow)
10525 {
10526 if (pu32XCInst == NULL)
10527 {
10528 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
10529 return FALSE;
10530 }
10531
10532 stXC_SET_BOBMODE XCArgs;
10533 XCArgs.bEnable = bEnable;
10534 XCArgs.eWindow = eWindow;
10535 XCArgs.bReturnValue = FALSE;
10536
10537 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_BOBMODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
10538 {
10539 printf("Obtain XC engine fail\n");
10540 return FALSE;
10541 }
10542 else
10543 {
10544 return XCArgs.bReturnValue;
10545 }
10546 }
10547
MApi_XC_SetForceReadBank_U2(void * pInstance,MS_BOOL bEnable,MS_U8 u8Bank,SCALER_WIN eWindow)10548 void MApi_XC_SetForceReadBank_U2(void* pInstance, MS_BOOL bEnable, MS_U8 u8Bank, SCALER_WIN eWindow)
10549 {
10550 _XC_ENTRY(pInstance);
10551 MHal_XC_SetForceReadBank(pInstance, bEnable, u8Bank, eWindow);
10552 _XC_RETURN(pInstance);
10553 }
10554
MApi_XC_SetForceReadBank(MS_BOOL bEnable,MS_U8 u8Bank,SCALER_WIN eWindow)10555 void MApi_XC_SetForceReadBank(MS_BOOL bEnable, MS_U8 u8Bank, SCALER_WIN eWindow)
10556 {
10557 if (pu32XCInst == NULL)
10558 {
10559 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
10560 return;
10561 }
10562
10563 stXC_SET_FORCE_READBANK XCArgs;
10564 XCArgs.bEnable = bEnable;
10565 XCArgs.u8Bank = u8Bank;
10566 XCArgs.eWindow = eWindow;
10567
10568 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_FORCE_READBANK, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
10569 {
10570 printf("Obtain XC engine fail\n");
10571 return;
10572 }
10573 else
10574 {
10575 return;
10576 }
10577 }
10578
MDrv_XC_SetForceCurrentReadBank(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)10579 void MDrv_XC_SetForceCurrentReadBank(void* pInstance, MS_BOOL bEnable, SCALER_WIN eWindow)
10580 {
10581 MHal_XC_SetForceCurrentReadBank(pInstance, bEnable, eWindow);
10582 }
10583
MDrv_SC_Adjust_Prescaling_Ratio(void * pInstance,SCALER_WIN eWindow)10584 void MDrv_SC_Adjust_Prescaling_Ratio(void *pInstance, SCALER_WIN eWindow)
10585 {
10586 #ifdef ENABLE_SCALING_WO_MUTE
10587 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10588 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10589 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10590 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10591
10592 //***************************************************************************
10593 // special SWDS setwindow
10594 if (((MDrv_XC_Get_3D_Output_Mode(pInstance) == E_XC_3D_OUTPUT_MODE_NONE) ||
10595 (MDrv_XC_Get_3D_Output_Mode(pInstance) == E_XC_3D_OUTPUT_FRAME_L) ||
10596 (MDrv_XC_Get_3D_Output_Mode(pInstance) == E_XC_3D_OUTPUT_FRAME_R)))
10597 {
10598 if (FALSE == gSrcInfo[eWindow].Status2.bPreHCusScaling)
10599 {
10600 gSrcInfo[eWindow].Status2.bPreHCusScaling = TRUE;
10601 gSrcInfo[eWindow].Status2.u16PreHCusScalingSrc = gSrcInfo[eWindow].stCapWin.width;
10602 gSrcInfo[eWindow].Status2.u16PreHCusScalingDst = gSrcInfo[eWindow].stCapWin.width;
10603 }
10604
10605 if (FALSE == gSrcInfo[eWindow].Status2.bPreVCusScaling)
10606 {
10607 gSrcInfo[eWindow].Status2.bPreVCusScaling = TRUE;
10608 gSrcInfo[eWindow].Status2.u16PreVCusScalingSrc = gSrcInfo[eWindow].stCapWin.height;
10609 gSrcInfo[eWindow].Status2.u16PreVCusScalingDst = gSrcInfo[eWindow].stCapWin.height;
10610 }
10611 }
10612 //****************************************************************************
10613 #endif
10614 }
10615
MDrv_SC_Cal_Skip_OPM_line(void * pInstance,SCALER_WIN eWindow,MS_U16 u16Src,MS_U16 u16Dst,XC_InternalStatus * pSrcInfo)10616 MS_U16 MDrv_SC_Cal_Skip_OPM_line(void *pInstance, SCALER_WIN eWindow, MS_U16 u16Src, MS_U16 u16Dst, XC_InternalStatus *pSrcInfo)
10617 {
10618 #ifdef ENABLE_SCALING_WO_MUTE
10619 //***************************************************************************
10620 // special SWDS setwindow
10621 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10622 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10623 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10624 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10625 #define V_THRESHOLD 85 // 0.88x
10626 #define V_THRESHOLD_SD_PANEL 40 // 0.4x
10627 #define V_THRESHOLD_SD_PANEL_SD_SOURCE 20 // 0.2x
10628 #define V_THRESHOLD_Sub 60 // 0.6x
10629
10630 MS_U16 u16TmpCropScaledSrc = u16Src;
10631 MS_U16 u16TmpSrc = u16Src;
10632 MS_U16 u16V_Threshold = 100;
10633
10634 //printf("\033[0;31m [%s][%d] u16ScaleSrc: %d \033[0m\n", __FUNCTION__, __LINE__, u16ScaleSrc);
10635 //printf("\033[0;31m [%s][%d] u16ScaleDst: %d \033[0m\n", __FUNCTION__, __LINE__, u16ScaleDst);
10636 if ((MAIN_WINDOW == eWindow) &&
10637 ((MDrv_XC_Get_3D_Output_Mode(pInstance) == E_XC_3D_OUTPUT_MODE_NONE) ||
10638 (MDrv_XC_Get_3D_Output_Mode(pInstance) == E_XC_3D_OUTPUT_FRAME_L) ||
10639 (MDrv_XC_Get_3D_Output_Mode(pInstance) == E_XC_3D_OUTPUT_FRAME_R)))
10640 {
10641 MS_U16 u16VactSpace=0;
10642 if(MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow) == E_XC_3D_INPUT_FRAME_PACKING)
10643 {
10644 MDrv_SC_3D_GetFP_Info(pInstance, pSrcInfo, &u16TmpCropScaledSrc, &u16VactSpace
10645 , (pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u32V_PreScalingRatio & BIT(31))>>31);
10646 }
10647 }
10648
10649 u16TmpSrc = u16TmpCropScaledSrc;
10650
10651 if( (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width > 1900)
10652 && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height > 1000) ) // For FullHD panel
10653 {
10654 if (MAIN_WINDOW == eWindow)
10655 u16V_Threshold = V_THRESHOLD;
10656 else
10657 u16V_Threshold = V_THRESHOLD_Sub;
10658 }
10659 else
10660 {
10661 if (pSrcInfo->stCapWin.width < 900 && pSrcInfo->stCapWin.height < 700)
10662 u16V_Threshold = V_THRESHOLD_SD_PANEL_SD_SOURCE;
10663 else
10664 u16V_Threshold = V_THRESHOLD_SD_PANEL;
10665 }
10666
10667
10668 pXCResourcePrivate->stdrvXC_Scaling._u8OPMFetchRatio[eWindow] = 1;
10669 if ((MDrv_XC_Get_3D_Output_Mode(pInstance) == E_XC_3D_OUTPUT_MODE_NONE) ||
10670 (MDrv_XC_Get_3D_Output_Mode(pInstance) == E_XC_3D_OUTPUT_FRAME_L) ||
10671 (MDrv_XC_Get_3D_Output_Mode(pInstance) == E_XC_3D_OUTPUT_FRAME_R))
10672 {
10673 while((u16TmpSrc * u16V_Threshold) > (u16Dst * 100))
10674 {
10675 pXCResourcePrivate->stdrvXC_Scaling._u8OPMFetchRatio[eWindow]++;
10676
10677 if (pXCResourcePrivate->stdrvXC_Scaling._u8OPMFetchRatio[eWindow] > 4)
10678 {
10679 pXCResourcePrivate->stdrvXC_Scaling._u8OPMFetchRatio[eWindow] = 4;
10680 break;
10681 }
10682
10683 u16TmpSrc = u16TmpCropScaledSrc/pXCResourcePrivate->stdrvXC_Scaling._u8OPMFetchRatio[eWindow] -2 ;
10684 }
10685 }
10686
10687 //printf("\033[0;31m [%s][%d] u8OPMFetchRatio: %d \033[0m\n", __FUNCTION__, __LINE__, g_u8OPMFetchRatio);
10688 //printf("\033[0;31m [%s][%d] u16TmpSrc: %d \033[0m\n", __FUNCTION__, __LINE__, u16TmpSrc);
10689
10690 return u16TmpSrc;
10691
10692 #else
10693
10694 return 0;
10695
10696 #endif
10697 //****************************************************************************
10698 }
10699
MDrv_SC_Adjust_H_Crop(void * pInstance,SCALER_WIN eWindow)10700 void MDrv_SC_Adjust_H_Crop(void *pInstance, SCALER_WIN eWindow)
10701 {
10702 #ifdef ENABLE_SCALING_WO_MUTE
10703 //*********************************************
10704 // For H scaling down to too small size, there is HW limitation only support 16x H scaling down
10705 #define H_PostScaledLimit 16
10706 #define H_CropShift 64
10707 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10708 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10709 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10710 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10711
10712 while ((gSrcInfo[eWindow].ScaledCropWin.width > H_PostScaledLimit)
10713 && ((gSrcInfo[eWindow].ScaledCropWin.width / H_PostScaledLimit) > gSrcInfo[eWindow].stDispWin.width))
10714 {
10715
10716 //printf("\033[0;31m [%s][%d] Need Crop CASE!!!!! \033[0m\n", __FUNCTION__, __LINE__);
10717 //printf("\033[0;31m [%s][%d] gSrcInfo[eWindow].ScaledCropWin.x: %d \033[0m\n", __FUNCTION__, __LINE__, gSrcInfo[eWindow].ScaledCropWin.x);
10718 //printf("\033[0;31m [%s][%d] gSrcInfo[eWindow].ScaledCropWin.width: %d \033[0m\n", __FUNCTION__, __LINE__, gSrcInfo[eWindow].ScaledCropWin.width);
10719
10720 gSrcInfo[eWindow].ScaledCropWin.x += H_CropShift;
10721
10722 if (gSrcInfo[eWindow].ScaledCropWin.width < H_CropShift * 2)
10723 {
10724 gSrcInfo[eWindow].ScaledCropWin.width = H_CropShift * 2;
10725 break;
10726 }
10727
10728 gSrcInfo[eWindow].ScaledCropWin.width -= H_CropShift * 2;
10729
10730 //printf("\033[0;31m [%s][%d] NEW .ScaledCropWin.x: %d \033[0m\n", __FUNCTION__, __LINE__, gSrcInfo[eWindow].ScaledCropWin.x);
10731 //printf("\033[0;31m [%s][%d] NEW ScaledCropWin.width: %d \033[0m\n", __FUNCTION__, __LINE__, gSrcInfo[eWindow].ScaledCropWin.width);
10732 }
10733 //*********************************************
10734
10735 #endif
10736 }
10737
MDrv_SC_Adjust_Skip_OPM_line(void * pInstance,SCALER_WIN eWindow)10738 void MDrv_SC_Adjust_Skip_OPM_line(void *pInstance, SCALER_WIN eWindow)
10739 {
10740 #ifdef ENABLE_SCALING_WO_MUTE
10741 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10742 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10743 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10744 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10745 if (((MDrv_XC_Get_3D_Output_Mode(pInstance) == E_XC_3D_OUTPUT_MODE_NONE) ||
10746 (MDrv_XC_Get_3D_Output_Mode(pInstance) == E_XC_3D_OUTPUT_FRAME_L) ||
10747 (MDrv_XC_Get_3D_Output_Mode(pInstance) == E_XC_3D_OUTPUT_FRAME_R)))
10748 {
10749 // adjust OPM offset to make HW skip line
10750 pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMOffset = pXCResourcePrivate->stdrvXC_MVideo_Context.stDBreg.u16OPMOffset
10751 * pXCResourcePrivate->stdrvXC_Scaling._u8OPMFetchRatio[eWindow];
10752 }
10753 #endif
10754 }
10755
MDrv_SC_Enable_LegacyMode(void * pInstance,MS_BOOL bEnable)10756 void MDrv_SC_Enable_LegacyMode(void *pInstance, MS_BOOL bEnable)
10757 {
10758 HAL_SC_EnableLegacyMode(pInstance, bEnable);
10759 }
10760
MDrv_SC_SwitchIPMWriteBank(void * pInstance,MS_BOOL bEnable,E_XC_IPM_CONNECT_ID eIPMConnect)10761 void MDrv_SC_SwitchIPMWriteBank(void *pInstance, MS_BOOL bEnable, E_XC_IPM_CONNECT_ID eIPMConnect)
10762 {
10763 #if (HW_DESIGN_4K2K_VER == 4)
10764 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10765 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10766
10767 if (E_XC_IPM_CONNETC_MAIN_FRCM == eIPMConnect || E_XC_IPM_CONNETC_MAIN_OPM == eIPMConnect)
10768 {
10769 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK11_07_L, eIPMConnect<<0, 0x03);
10770 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK11_07_L, (bEnable? BIT(3):0), BIT(3));
10771 }
10772 else
10773 {
10774 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK11_47_L, eIPMConnect<<0, 0x03);
10775 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK11_47_L, (bEnable? BIT(3):0), BIT(3));
10776 }
10777 #endif
10778 }
10779
MDrv_SC_SwitchFRCMWriteBank(void * pInstance,MS_BOOL bEnable,E_XC_FRCMW_CONNECT_ID eFRCMConnect)10780 void MDrv_SC_SwitchFRCMWriteBank(void *pInstance, MS_BOOL bEnable, E_XC_FRCMW_CONNECT_ID eFRCMConnect)
10781 {
10782 #if (HW_DESIGN_4K2K_VER == 4)
10783 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10784 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10785
10786 if (E_XC_FRCMW_CONNETC_MAIN_SCM == eFRCMConnect || E_XC_FRCMW_CONNETC_MAIN_FRCM == eFRCMConnect)
10787 {
10788 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK31_07_L, eFRCMConnect<<0, 0x03);
10789 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK31_07_L, (bEnable? BIT(3):0), BIT(3));
10790 }
10791 else
10792 {
10793 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK31_47_L, eFRCMConnect<<0, 0x03);
10794 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK31_47_L, (bEnable? BIT(3):0), BIT(3));
10795 }
10796 #endif
10797 }
_MDrv_SC_check_2p_mode(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)10798 static MS_BOOL _MDrv_SC_check_2p_mode(void *pInstance, MS_BOOL bEnable,SCALER_WIN eWindow)
10799 {
10800 #if ((HW_DESIGN_4K2K_VER == 4)||(HW_DESIGN_4K2K_VER == 6))
10801 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
10802 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
10803 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
10804 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
10805
10806 MS_U16 u16Width, u16Height = 0;
10807
10808 MS_U32 u32Vfreqx10 = 0;
10809
10810 MS_BOOL bstatus = FALSE;
10811 #if (PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB == 0)
10812 if(psXCInstPri->u32DeviceID == 0x00)
10813 #endif
10814 {
10815 if(eWindow == MAIN_WINDOW)
10816 {
10817 #if 0
10818 if(!MDrv_XC_Is_SupportSWDS(pInstance))
10819 {
10820 u16Width = gSrcInfo[eWindow].stCapWin.width;
10821 u16Height = gSrcInfo[eWindow].stCapWin.height;
10822 }
10823 else
10824 {
10825 u16Width = gSrcInfo[eWindow].Status2.u16VirtualBox_Width;
10826 u16Height = gSrcInfo[eWindow].Status2.u16VirtualBox_Height;
10827 }
10828 #endif
10829
10830 if(MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow) )
10831 {
10832 u16Width = gSrcInfo[eWindow].Status2.u16VirtualBox_Width;
10833 u16Height = gSrcInfo[eWindow].Status2.u16VirtualBox_Height;
10834 }
10835 else
10836 {
10837 u16Width = gSrcInfo[eWindow].stCapWin.width;
10838 u16Height = gSrcInfo[eWindow].stCapWin.height;
10839 }
10840 if(gSrcInfo[eWindow].bInterlace)
10841 {
10842 u32Vfreqx10 = gSrcInfo[eWindow].u16InputVFreq/2; //Change field rate to frame rate
10843 }
10844 else
10845 {
10846 u32Vfreqx10 = gSrcInfo[eWindow].u16InputVFreq;
10847 }
10848 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"u16Width=%u,u16Height=%u,u32Vfreqx10=%tu\n",u16Width, u16Height,(ptrdiff_t)u32Vfreqx10);
10849
10850 #if (HW_DESIGN_4K2K_VER == 4)
10851 if((u16Width >= 0xF00)&&(u16Height >= 0x870)&&(u32Vfreqx10 >= 330)&&
10852 ((gSrcInfo[eWindow].enInputSourceType == INPUT_SOURCE_STORAGE)||(gSrcInfo[eWindow].enInputSourceType == INPUT_SOURCE_STORAGE2)
10853 ||(gSrcInfo[eWindow].enInputSourceType == INPUT_SOURCE_DTV)||(gSrcInfo[eWindow].enInputSourceType == INPUT_SOURCE_DTV2)))
10854 {
10855 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_07_L, BIT(15), BIT(15));
10856 }
10857 else if((u16Width >= 0xF00)&&(u16Height >= 0x870)&&(u32Vfreqx10 >= 230) && bEnable)
10858 {
10859 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_07_L, BIT(15), BIT(15));
10860 }
10861 //monaco mm DS VB size always be 4k2k , mvop timing is 4k2k , Vfreqx10 >= 330 -> 2p mode
10862 else if ( (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow) ) &&
10863 (gSrcInfo[eWindow].Status2.u16VirtualBox_Width >= 0xF00) && (gSrcInfo[eWindow].Status2.u16VirtualBox_Height>= 0x870)&&(u32Vfreqx10 >= 330) )
10864 {
10865 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_07_L, BIT(15), BIT(15));
10866 }
10867 else
10868 {
10869 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_07_L, 0x00, BIT(15));
10870 }
10871 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, bEnable? BIT(15):0x00, BIT(15));
10872 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_61_L, bEnable? (BIT(1)|BIT(0)):0x00, BIT(1)|BIT(0)); // [0] 2p 422 [1] 2p 422 auto mode
10873 #endif
10874
10875 #if (HW_DESIGN_4K2K_VER == 6)
10876
10877 if((psXCInstPri->u32DeviceID == E_XC_DEVICE1)&&(((MS_U32)(u16Width)*(MS_U32)(u16Height)*(u32Vfreqx10/10)) >= MAX_1P_MODE_CLK))//ip clk >= 300Mhz, SC1 will be setted avg mode
10878 {
10879 Hal_SC_Set_2pmode(pInstance,TRUE,TRUE,FALSE,eWindow);
10880 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_07_L, 0x0 , BIT(15));
10881 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, 0x0 , BIT(15));
10882 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, BIT(14), BIT(14));
10883 gSrcInfo[eWindow].stCapWin.width = gSrcInfo[eWindow].stCapWin.width/2;
10884 if(gSrcInfo[eWindow].Status2.bPreHCusScaling == TRUE)
10885 {
10886 gSrcInfo[eWindow].Status2.u16PreHCusScalingSrc = gSrcInfo[eWindow].Status2.u16PreHCusScalingSrc/2;
10887 }
10888 return TRUE;
10889 }
10890
10891 MS_U32 u32InputCLK = 0;
10892
10893 if (IsSrcTypeDTV(gSrcInfo[eWindow].enInputSourceType) || IsSrcTypeStorage(gSrcInfo[eWindow].enInputSourceType))
10894 u32InputCLK = (MS_U32)(u16Width+MVOP_H_BLANKING)*(MS_U32)(u16Height+MVOP_V_BLANKING)*(u32Vfreqx10/10);
10895 else
10896 u32InputCLK = (MS_U32)(u16Width)*(MS_U32)(u16Height)*(u32Vfreqx10/10);
10897
10898 if(IsSrcTypeHDMI(gSrcInfo[eWindow].enInputSourceType) &&bEnable)//HDMI always 2p mode
10899 {
10900 if((u16Width >= 0xF00)&&(u16Height >= 0x870)&&(u32Vfreqx10 >= 230))//real 2p mode
10901 {
10902 #ifdef UFO_XC_FB_LEVEL
10903 if((gSrcInfo[eWindow].eFBLevel == E_XC_FB_LEVEL_FBL)
10904 || (gSrcInfo[eWindow].eFBLevel == E_XC_FB_LEVEL_RFBL_DI)
10905 )
10906 #else
10907 if(gSrcInfo[eWindow].bR_FBL)
10908 #endif
10909 {
10910 Hal_SC_Set_2pmode(pInstance,TRUE,TRUE,TRUE,eWindow);
10911 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, BIT(15), BIT(15));
10912 }
10913 else
10914 {
10915 Hal_SC_Set_2pmode(pInstance,TRUE,TRUE,FALSE,eWindow);
10916 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, BIT(15), BIT(15));
10917 }
10918 }
10919 else
10920 {
10921 Hal_SC_Set_2pmode(pInstance,TRUE,FALSE,FALSE,eWindow);
10922 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, BIT(15), BIT(15));
10923 }
10924 }
10925 else if(u32InputCLK >= MAX_1P_MODE_CLK)//ip clk >= 300Mhz,will be setted 2p mode.op clk>= ip clk,will be also setted 2p mode.
10926 {
10927 #ifdef UFO_XC_FB_LEVEL
10928 if((gSrcInfo[eWindow].eFBLevel == E_XC_FB_LEVEL_FBL)
10929 || (gSrcInfo[eWindow].eFBLevel == E_XC_FB_LEVEL_RFBL_DI)
10930 )
10931 #else
10932 if(gSrcInfo[eWindow].bR_FBL)
10933 #endif
10934 {
10935 Hal_SC_Set_2pmode(pInstance,TRUE,TRUE,TRUE,eWindow);//ip,reg_opm_2p_mode,reg_bypass_all_2p_f2
10936 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, BIT(15), BIT(15));
10937 }
10938 else
10939 {
10940 Hal_SC_Set_2pmode(pInstance,TRUE,TRUE,FALSE,eWindow);
10941 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, BIT(15), BIT(15));
10942 }
10943 }
10944 else
10945 {
10946 if ((u16Width*u16Height*60 >= MAX_1P_MODE_CLK)) // 60 => MAX opm frame rate
10947 {
10948 #ifdef UFO_XC_FB_LEVEL
10949 if((gSrcInfo[eWindow].eFBLevel == E_XC_FB_LEVEL_FBL)
10950 || (gSrcInfo[eWindow].eFBLevel == E_XC_FB_LEVEL_RFBL_DI)
10951 )
10952 #else
10953 if(gSrcInfo[eWindow].bR_FBL)
10954 #endif
10955 {
10956 if(gSrcInfo[MAIN_WINDOW].Status2.bMVOPHSKMode)//HSK mdoe need always enable 2p mode
10957 {
10958 Hal_SC_Set_2pmode(pInstance,TRUE,TRUE,TRUE,eWindow);
10959 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, BIT(15), BIT(15));
10960 }
10961 else
10962 {
10963 Hal_SC_Set_2pmode(pInstance,FALSE,TRUE,TRUE,eWindow);
10964 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, 0x0, BIT(15));
10965 }
10966 }
10967 else
10968 {
10969 if(gSrcInfo[MAIN_WINDOW].Status2.bMVOPHSKMode)//HSK mdoe need always enable 2p mode
10970 {
10971 Hal_SC_Set_2pmode(pInstance,TRUE,TRUE,FALSE,eWindow);
10972 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, BIT(15), BIT(15));
10973 }
10974 else
10975 {
10976 Hal_SC_Set_2pmode(pInstance,FALSE,TRUE,FALSE,eWindow);
10977 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, 0x0, BIT(15));
10978 }
10979 }
10980 }
10981 else
10982 {
10983 if(gSrcInfo[MAIN_WINDOW].Status2.bMVOPHSKMode)//HSK mdoe need always enable 2p mode
10984 {
10985 Hal_SC_Set_2pmode(pInstance,TRUE,FALSE,FALSE,eWindow);
10986 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, BIT(15), BIT(15));
10987 }
10988 else
10989 {
10990 //enable op 2p mode will bypass uc.
10991 //2k2k,can not enable op 2p mode under 2d,because we are not sure whether to enable uc in the future.
10992 //4k1k always need enable op 2p mode.it will not enable uc.
10993 if(IS_INPUT_4K1K(eWindow) || (IS_INPUT_2K2K(eWindow) &&
10994 (E_XC_3D_INPUT_MODE_NONE != MDrv_XC_Get_3D_Input_Mode(pInstance, eWindow)) ))
10995 {
10996 Hal_SC_Set_2pmode(pInstance,FALSE,TRUE,FALSE,eWindow);
10997 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, 0x0, BIT(15));
10998 }
10999 else
11000 {
11001 Hal_SC_Set_2pmode(pInstance,FALSE,FALSE,FALSE,eWindow);
11002 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, 0x0, BIT(15));
11003 }
11004 }
11005 }
11006 }
11007 #endif
11008 //SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, bEnable? BIT(15):0x00, BIT(15));
11009 //SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_61_L, bEnable? (BIT(1)|BIT(0)):0x00, BIT(1)|BIT(0)); // [0] 2p 422 [1] 2p 422 auto mode
11010
11011 bstatus = TRUE;
11012 }
11013 else if(eWindow == SUB_WINDOW)
11014 {
11015 u16Width = gSrcInfo[eWindow].stCapWin.width;
11016 u16Height = gSrcInfo[eWindow].stCapWin.height;
11017 u32Vfreqx10 = gSrcInfo[eWindow].u16InputVFreq;
11018
11019 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"u16Width=%u,u16Height=%u,u32Vfreqx10=%tu\n",u16Width, u16Height,(ptrdiff_t)u32Vfreqx10);
11020
11021 if((u16Width >= 0xF00)&&(u16Height >= 0x870)&&(u32Vfreqx10 >= 330))
11022 {
11023 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK03_07_L, BIT(15), BIT(15));
11024 }
11025 else
11026 {
11027 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK03_07_L, 0x00, BIT(15));
11028 }
11029
11030 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK04_0A_L, bEnable?BIT(15):0x00, BIT(15));
11031 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK03_61_L, bEnable? (BIT(1)|BIT(0)):0x00, BIT(1)|BIT(0)); // [0] 2p 422 [1] 2p 422 auto mode
11032
11033 if(bEnable)
11034 {
11035 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK42_02_L, BIT(14), BIT(14)); // patch
11036 }
11037 else
11038 {
11039 #ifdef UFO_XC_FB_LEVEL
11040 if(gSrcInfo[SUB_WINDOW].eFBLevel == E_XC_FB_LEVEL_FB)//FIXME
11041 #else
11042 if(!gSrcInfo[SUB_WINDOW].bFBL)
11043 #endif
11044 {
11045 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK42_02_L, 0x00, BIT(14));
11046 }
11047 }
11048
11049 bstatus = TRUE;
11050 }
11051 else
11052 {
11053 printf("Please check the MAX window number!!\n");
11054 }
11055 }
11056
11057 #if (PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB == 1)
11058
11059 //Subwindow converts hdmi422 to hdmi444 only at HDMIRX or IP1
11060 //If Dolby HDR is supported, HDMIRx would bypass the 422to444 convert.
11061 //then scaler should take the responsibility to convert 422 to 444.
11062 if( (psXCInstPri->u32DeviceID == 0x1) && (eWindow == MAIN_WINDOW))
11063 {
11064 if(!(R2BYTE(REG_PM_EFUSE_08_L)&BIT(6))) //Detect if support DolbyHDR from efuse.
11065 {
11066 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_61_L, (BIT(0)|BIT(1)),(BIT(0)|BIT(1))); //enable 422 to 444 convert
11067 }
11068 }
11069 #endif
11070
11071 return bstatus;
11072 #elif (HW_DESIGN_4K2K_VER == 7)
11073 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
11074 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
11075 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
11076 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
11077
11078 if(psXCInstPri->u32DeviceID == 0x00)
11079 {
11080 if(eWindow == MAIN_WINDOW)
11081 {
11082 if(IsSrcTypeHDMI(gSrcInfo[eWindow].enInputSourceType) && bEnable)//HDMI always 2p mode
11083 {
11084 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_61_L, BIT(0), BIT(2)|BIT(1)|BIT(0)); // [0] 2p 422 [1] 2p 422 auto mode [2] 2p 422 manual value
11085 }
11086 else
11087 {
11088 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_61_L, 0x0000, BIT(2)|BIT(1)|BIT(0)); // [0] 2p 422 [1] 2p 422 auto mode [2] 2p 422 manual value
11089 }
11090 }
11091 else if(eWindow == SUB_WINDOW)
11092 {
11093 if(IsSrcTypeHDMI(gSrcInfo[eWindow].enInputSourceType) && bEnable)//HDMI always 2p mode
11094 {
11095 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK03_61_L, BIT(0), BIT(2)|BIT(1)|BIT(0)); // [0] 2p 422 [1] 2p 422 auto mode [2] 2p 422 manual value
11096 }
11097 else
11098 {
11099 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK03_61_L, 0x0000, BIT(2)|BIT(1)|BIT(0)); // [0] 2p 422 [1] 2p 422 auto mode [2] 2p 422 manual value
11100 }
11101 }
11102 }
11103 else if(psXCInstPri->u32DeviceID == 0x01)
11104 {
11105 if(eWindow == MAIN_WINDOW)
11106 {
11107 MS_U16 u16Width, u16Height = 0;
11108 MS_U32 u32Vfreqx10 = 0;
11109
11110 if(!MDrv_XC_Is_SupportSWDS(pInstance))
11111 {
11112 u16Width = gSrcInfo[eWindow].stCapWin.width;
11113 u16Height = gSrcInfo[eWindow].stCapWin.height;
11114 }
11115 else
11116 {
11117 u16Width = gSrcInfo[eWindow].Status2.u16VirtualBox_Width;
11118 u16Height = gSrcInfo[eWindow].Status2.u16VirtualBox_Height;
11119 }
11120
11121 u32Vfreqx10 = gSrcInfo[eWindow].u16InputVFreq;
11122
11123 if(IsSrcTypeHDMI(gSrcInfo[eWindow].enInputSourceType))//HDMI always 2p mode
11124 {
11125 if((u16Width >= 0xF00)&&(u16Height >= 0x870)&&(u32Vfreqx10 >= 330))
11126 {
11127 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, BIT(14), BIT(15)|BIT(14));
11128 }
11129 else
11130 {
11131 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, BIT(15), BIT(15)|BIT(14));
11132 }
11133 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_07_L, BIT(15), BIT(15));
11134
11135 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_61_L, BIT(0), BIT(2)|BIT(1)|BIT(0)); // [0] 2p 422 [1] 2p 422 auto mode [2] 2p 422 manual value
11136 }
11137 else if(IsSrcTypeDTV(gSrcInfo[eWindow].enInputSourceType) || IsSrcTypeStorage(gSrcInfo[eWindow].enInputSourceType)) // MVOP always 2p mode
11138 {
11139 if((u16Width >= 0xF00)&&(u16Height >= 0x870)&&(u32Vfreqx10 >= 330))
11140 {
11141 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, BIT(14), BIT(15)|BIT(14));
11142 }
11143 else
11144 {
11145 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, BIT(15), BIT(15)|BIT(14));
11146 }
11147 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_07_L, BIT(15), BIT(15));
11148
11149 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_61_L, 0x0000, BIT(2)|BIT(1)|BIT(0)); // [0] 2p 422 [1] 2p 422 auto mode [2] 2p 422 manual value
11150 }
11151 else
11152 {
11153 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_0A_L, 0x0000, BIT(15)|BIT(14));
11154 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_07_L, 0x0000, BIT(15));
11155
11156 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_61_L, 0x0000, BIT(2)|BIT(1)|BIT(0)); // [0] 2p 422 [1] 2p 422 auto mode [2] 2p 422 manual value
11157 }
11158 }
11159 }
11160 return TRUE;
11161 #else
11162 return 0;
11163 #endif
11164 }
11165
MDrv_SC_set_2p_mode(void * pInstance,XC_SETWIN_INFO * pstXC_SetWin_Info,SCALER_WIN eWindow)11166 void MDrv_SC_set_2p_mode(void *pInstance, XC_SETWIN_INFO *pstXC_SetWin_Info, SCALER_WIN eWindow)
11167 {
11168 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
11169 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
11170 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
11171 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
11172
11173 if(((pstXC_SetWin_Info->enInputSourceType >= INPUT_SOURCE_HDMI)&&(pstXC_SetWin_Info->enInputSourceType <= INPUT_SOURCE_HDMI_MAX))||
11174 ((pstXC_SetWin_Info->enInputSourceType >= INPUT_SOURCE_DVI)&&(pstXC_SetWin_Info->enInputSourceType <= INPUT_SOURCE_DVI_MAX)))
11175 {
11176 #if SUPPORT_HDMI20
11177 if(Hal_HDMI_CheckHDMI20_Setting(MDrv_XC_Mux_GetHDMIPort(pInstance, pstXC_SetWin_Info->enInputSourceType)))
11178 {
11179 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"HDMI is 2P mode\n");
11180
11181 //SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK40_03_L,0x0000); // [7] reg_spt_2p_oe_en [0] reg_spt_420_en
11182
11183 if(!_MDrv_SC_check_2p_mode(pInstance,ENABLE,eWindow))
11184 printf("Please check the Scaler ID and eWindow\n");
11185 }
11186 else
11187 {
11188 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"HDMI is 1P mode\n");
11189
11190 ///SUPPORT_HDMI20_420
11191 /// patch for HDMI2.0 4K2K@420, It should not support P2P mode
11192 if((pstXC_SetWin_Info->stCapWin.width >= 0x780)
11193 &&(pstXC_SetWin_Info->stCapWin.height >= 0x870)
11194 &&(pstXC_SetWin_Info->u16InputVFreq >= 490))
11195 {
11196 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"HDMI is 4K 420 \n");
11197 if(!_MDrv_SC_check_2p_mode(pInstance,ENABLE,eWindow))
11198 printf("Please check the Scaler ID and eWindow\n");
11199 }
11200 else
11201 {
11202 if(!_MDrv_SC_check_2p_mode(pInstance,DISABLE,eWindow))
11203 printf("Please check the Scaler ID and eWindow\n");
11204 }
11205 }
11206 #endif
11207 }
11208 else if((pstXC_SetWin_Info->enInputSourceType == INPUT_SOURCE_STORAGE)||(pstXC_SetWin_Info->enInputSourceType == INPUT_SOURCE_STORAGE2)
11209 ||(pstXC_SetWin_Info->enInputSourceType == INPUT_SOURCE_DTV)||(pstXC_SetWin_Info->enInputSourceType == INPUT_SOURCE_DTV2))
11210 {
11211 if((pstXC_SetWin_Info->stCapWin.width >= 0xF00)
11212 &&(pstXC_SetWin_Info->stCapWin.height >= 0x870)
11213 &&(pstXC_SetWin_Info->u16InputVFreq >= 330))
11214 {
11215 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"MVOP is 2P mode\n");
11216
11217 if(!_MDrv_SC_check_2p_mode(pInstance,ENABLE,eWindow))
11218 printf("Please check the Scaler ID and eWindow\n");
11219 }
11220 //monaco mm DS VB size always be 4k2k , mvop timing is 4k2k , 2p mode
11221 else if ( (MDrv_XC_GetDynamicScalingStatus(pInstance) || MDrv_XC_Is_DSForceIndexEnabled(pInstance, eWindow) ) &&
11222 (gSrcInfo[eWindow].Status2.u16VirtualBox_Width >= 0xF00) && (gSrcInfo[eWindow].Status2.u16VirtualBox_Height>= 0x870)&&(pstXC_SetWin_Info->u16InputVFreq >= 330) )
11223 {
11224 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"MVOP is 2P mode\n");
11225 if(!_MDrv_SC_check_2p_mode(pInstance,ENABLE,eWindow))
11226 printf("Please check the Scaler ID and eWindow\n");
11227 }
11228 else
11229 {
11230 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"MVOP is 1P mode\n");
11231 if(!_MDrv_SC_check_2p_mode(pInstance,DISABLE,eWindow))
11232 printf("Please check the Scaler ID and eWindow\n");
11233 }
11234 }
11235 else
11236 {
11237 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"Other soure is 1P mode\n");
11238 if(!_MDrv_SC_check_2p_mode(pInstance,DISABLE,eWindow))
11239 printf("Please check the Scaler ID and eWindow\n");
11240 }
11241 }
11242
MDrv_SC_set_frcm_cbcr_swap(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)11243 void MDrv_SC_set_frcm_cbcr_swap(void *pInstance, MS_BOOL bEnable, SCALER_WIN eWindow)
11244 {
11245 #if (HW_DESIGN_4K2K_VER == 4)
11246 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
11247 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
11248
11249 if (bEnable == FALSE)
11250 {
11251 if(eWindow == MAIN_WINDOW)
11252 {
11253 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK31_19_L, (0), BIT(0));
11254 }
11255 else
11256 {
11257 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK31_59_L, (0), BIT(0));
11258 }
11259 }
11260 else
11261 {
11262 // FRCM mirror: BK32_03[12](main), BK32_43[12](sub)
11263 // FRCM cbcy swap: BK31_19[0](main),BK31_59[0](sub)
11264 // Bypass CE(compression): BK33_01[0](main),BK33_01[1](sub), 0: ENABLE CE; 1: disable CE
11265 // --------------------------------------------------------------------------------------------
11266 // | regs | not h_mirror | h_mirror without compression | h_mirror with compression |
11267 // | BK32_03[12] | 0 | 1 | 1 |
11268 // | BK33_01[0] | 0 or 1 | 1 | 0 |
11269 // | BK31_19[0] | 0 | 1 | 0 |
11270 // --------------------------------------------------------------------------------------------
11271 if(eWindow == MAIN_WINDOW)
11272 {
11273 if (SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK33_01_L, BIT(0)) != 0)
11274 {
11275 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK31_19_L, BIT(0), BIT(0));
11276 }
11277 else
11278 {
11279 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK31_19_L, 0, BIT(0));
11280 }
11281 }
11282 else
11283 {
11284 if (SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK33_01_L, BIT(1)) != 0)
11285 {
11286 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK31_59_L, BIT(0), BIT(0));
11287 }
11288 else
11289 {
11290 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK31_59_L, 0, BIT(0));
11291 }
11292 }
11293 }
11294 #endif
11295 }
11296
MDrv_XC_MemControl_Switch_Method_By_Vcnt(void * pInstance,MS_BOOL bEnable,MS_U16 u16Vcnt)11297 MS_BOOL MDrv_XC_MemControl_Switch_Method_By_Vcnt(void *pInstance, MS_BOOL bEnable, MS_U16 u16Vcnt)
11298 {
11299 #if (HW_DESIGN_4K2K_VER == 4)
11300 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
11301 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
11302 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_44_L, bEnable?BIT(15):0x0, BIT(15)); // Memory control Switch Method by Vcnt enable
11303 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_44_L, u16Vcnt, 0x1FFF); // Memory control Switch Method by Vcnt
11304 #endif
11305 return TRUE;
11306 }
11307
MDrv_XC_edclk_pd_control(void * pInstance,MS_BOOL bEnable,MS_U16 u16ControlStart,MS_U16 u16ControlEnd)11308 MS_BOOL MDrv_XC_edclk_pd_control(void *pInstance, MS_BOOL bEnable, MS_U16 u16ControlStart, MS_U16 u16ControlEnd)
11309 {
11310 #if (HW_DESIGN_4K2K_VER == 4)
11311 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
11312 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
11313 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_45_L, bEnable?BIT(15):0x0, BIT(15)); // edclk pd control enable
11314 if (bEnable)
11315 {
11316 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_45_L, u16ControlStart, 0x1FFF); // edclk pd control start
11317 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_47_L, u16ControlEnd, 0x1FFF); // edclk pd control end
11318 }
11319 #endif
11320 return TRUE;
11321 }
11322
11323
Mdrv_SC_set_frcm_pre_align_pixel(void * pInstance,MS_BOOL bEnable,MS_U16 pixels,SCALER_WIN eWindow)11324 void Mdrv_SC_set_frcm_pre_align_pixel(void *pInstance, MS_BOOL bEnable, MS_U16 pixels, SCALER_WIN eWindow)
11325 {
11326 #if (HW_DESIGN_4K2K_VER == 4)
11327 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
11328 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
11329 UNUSED(pixels);
11330
11331 if (bEnable)
11332 {
11333 if ( eWindow == MAIN_WINDOW )
11334 {
11335 // Enable frcm pre align pixel for mirror mode.
11336 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK48_2A_L, BIT(15), BIT(15));
11337 }
11338 else
11339 {
11340 // Enable frcm pre align pixel for mirror mode.
11341 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK48_6A_L, BIT(15), BIT(15));
11342 }
11343
11344 }
11345 else
11346 {
11347 if ( eWindow == MAIN_WINDOW )
11348 {
11349 // Disable frcm pre align pixel for mirror mode.
11350 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK48_2A_L, 0x00 , BIT(15));
11351 }
11352 else
11353 {
11354 // Disable frcm pre align pixel for mirror mode.
11355 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK48_6A_L, 0x00 , BIT(15));
11356 }
11357 }
11358 #endif
11359 }
11360
11361 #ifdef SUPPORT_BWD
MDrv_SC_setBwdConfig(void * pInstance,E_XC_BWD_CONFIG_TYPE eType,void * pstParam,SCALER_WIN eWindow)11362 MS_BOOL MDrv_SC_setBwdConfig(void *pInstance, E_XC_BWD_CONFIG_TYPE eType, void *pstParam, SCALER_WIN eWindow)
11363 {
11364 MS_BOOL bResult = FALSE;
11365 switch (eType)
11366 {
11367 case E_XC_BWD_UPDATE_BWR_CONFIG:
11368 {
11369 if((MDrv_XC_MLoad_GetStatus(pInstance) == E_MLOAD_ENABLED) && (!MDrv_SC_GetSkipWaitVsync(pInstance, eWindow)))
11370 {
11371 _MLOAD_ENTRY(pInstance);
11372 bResult = HAL_SC_set_bwr_config_burst(pInstance, pstParam, eWindow);
11373 _MLOAD_RETURN(pInstance);
11374 }
11375 else
11376 {
11377 bResult = HAL_SC_set_bwr_config(pInstance, pstParam, eWindow);
11378 }
11379 break;
11380 }
11381 default:
11382 bResult = FALSE;
11383 break;
11384 }
11385 return bResult;
11386 }
11387 #endif
11388
11389
MDrv_XC_SetIsSupport2StepScalingFlag(MS_BOOL bEnable)11390 void MDrv_XC_SetIsSupport2StepScalingFlag(MS_BOOL bEnable)
11391 {
11392 #ifdef UFO_XC_SUPPORT_2STEP_SCALING
11393 bIsSupport2StepScaling = bEnable;
11394 #endif
11395 }
11396
MDrv_XC_IsSupport2StepScaling(void)11397 MS_BOOL MDrv_XC_IsSupport2StepScaling(void)
11398 {
11399 #ifdef UFO_XC_SUPPORT_2STEP_SCALING
11400 return bIsSupport2StepScaling;
11401 #else
11402 return FALSE;
11403 #endif
11404 }
11405
MDrv_XC_GetPQPathStatus(void * pInstance,E_XC_PQ_Path_Type ePqPathType,MS_U16 u16Width,MS_U16 u16Height)11406 MS_BOOL MDrv_XC_GetPQPathStatus(void* pInstance, E_XC_PQ_Path_Type ePqPathType, MS_U16 u16Width, MS_U16 u16Height)
11407 {
11408 #ifdef UFO_XC_PQ_PATH
11409 return MHal_XC_GetPQPathStatus(pInstance, ePqPathType, u16Width, u16Height);
11410 #else
11411 return FALSE;
11412 #endif
11413 }
11414