1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94 #ifndef DISABLE_DIP_FUNCTION
95
96 #define DRV_SC_DIPSCALING_C
97
98 #ifdef MSOS_TYPE_LINUX_KERNEL
99 #include <linux/string.h>
100 #else
101 #include <string.h>
102 #endif
103 // Common Definition
104 #include "MsCommon.h"
105 #include "MsOS.h"
106 #include "mhal_xc_chip_config.h"
107 #include "utopia.h"
108 // Internal Definition
109 #include "drvXC_IOPort.h"
110 #include "apiXC.h"
111 #include "apiXC_DWIN.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 #include "halCHIP.h"
122 #include "drv_sc_scaling.h"
123 #include "xc_Analog_Reg.h"
124 #if (LD_ENABLE==1)
125 #include "mdrv_ld.h"
126 #include "mdrv_ldalgo.h"
127 #endif
128 #include "mdrv_sc_3d.h"
129 #include "drv_sc_menuload.h"
130 #include "drvXC_ADC_Internal.h"
131 #include "mdrv_frc.h"
132 #include "mhal_frc.h"
133 #include "mhal_sc.h"
134 #include "mhal_dynamicscaling.h"
135 #include "XC_private.h"
136 #include "apiXC_v2.h"
137 #include "drvXC_HDMI_Internal.h"
138
139 #include "hwreg_ipmux.h"
140
141 #include "drv_sc_mux.h"
142 #include "drv_sc_DIP_scaling.h"
143 #include "mdrv_sc_dynamicscaling.h"
144 #include "drvscaler_nr.h"
145 #include "drvMMIO.h"
146
147 //Add for A5
148 #include "mhal_dip.h"
149
150 // Tobe refined
151 #include "xc_hwreg_utility2.h"
152 #include "mhal_mux.h"
153 #include "mhal_hdmi.h"
154 #include "mhal_ip.h"
155 #include "mhal_menuload.h"
156 #ifdef UTOPIA_V2
157 #include "XC_DWIN_private.h"
158 #include "utopia_dapi.h"
159 #endif
160 #ifdef MSOS_TYPE_LINUX_KERNEL
161 #include <asm/div64.h>
162 #else
163 #define do_div(x,y) ((x)/=(y))
164 #endif
165
166 //////////////////////////Remove when drvpq change us Mscommon.h /////////////
167 //#define E_XRULE_VSD 1
168
169 //#define PIP_SUPPORTED (MAX_WINDOW_NUM > 1)
170
171 #if 0
172 typedef enum
173 {
174 E_DRVSC_FBNUM = 0,
175 }DRV_SC_SRCINFO ;
176 #endif
177
178 //extern PQ_Function_Info s_PQ_Function_Info;
179 ///////////////////////////////////////
180
181 #define msg_video(x) //x
182 /******************************************************************************/
183 /* Local */
184 /* ****************************************************************************/
185 MS_XC_MEM_FMT s_DIPeMemFmt[MAX_DIP_WINDOW] = {E_MS_XC_MEM_FMT_AUTO};
186 #ifdef UTOPIA_V2
187 #define g_DIPSrcInfo pDipResPri->g_DIPSrcInfo
188 #endif
189
190 // Debug Log
191 #include "ULog.h"
192 MS_U32 u32DIPDbgLevel_drv;
193
194 // Debug Logs, level form low(INFO) to high(FATAL, always show)
195 // Function information, ex function entry
196 #define DIP_D_INFO(x, args...) if(u32DIPDbgLevel_drv >= E_XC_DIP_Debug_Level_HIGH){ULOGI("DIP DRV", x, ##args);}
197 // Warning, illegal paramter but can be self fixed in functions
198 #define DIP_D_WARN(x, args...) if(u32DIPDbgLevel_drv >= E_XC_DIP_Debug_Level_HIGH){ULOGW("DIP DRV", x, ##args);}
199 // Need debug, illegal paramter.
200 #define DIP_D_DBUG(x, args...) if(u32DIPDbgLevel_drv >= E_XC_DIP_Debug_Level_MED){ULOGD("DIP DRV", x, ##args);}
201 // Error, function will be terminated but system not crash
202 #define DIP_D_ERR(x, args...) if(u32DIPDbgLevel_drv >= E_XC_DIP_Debug_Level_LOW){ULOGE("DIP DRV", x, ##args);}
203 // Critical, system crash. (ex. assert)
204 #define DIP_D_FATAL(x, args...) if(u32DIPDbgLevel_drv >= E_XC_DIP_Debug_Level_LOW){ULOGF("DIP DRV", x, ##args);}
205
206 /******************************************************************************/
207 /* Functions */
208 /******************************************************************************/
MDrv_XC_DIP_CMDQBegin(void * pInstance,SCALER_DIP_WIN eWindow)209 static void MDrv_XC_DIP_CMDQBegin(void* pInstance,SCALER_DIP_WIN eWindow)
210 {
211 HAL_XC_DIP_CMDQBegin(pInstance,eWindow);
212 }
213
MDrv_XC_DIP_CMDQEnd(void * pInstance,SCALER_DIP_WIN eWindow)214 static void MDrv_XC_DIP_CMDQEnd(void* pInstance,SCALER_DIP_WIN eWindow)
215 {
216 HAL_XC_DIP_CMDQEnd(pInstance,eWindow);
217 }
218
MDrv_XC_DIP_CMDQ_SetAction(void * pInstance,EN_XC_DIP_CMDQ_ACTION eAction,SCALER_DIP_WIN eWindow)219 void MDrv_XC_DIP_CMDQ_SetAction(void* pInstance, EN_XC_DIP_CMDQ_ACTION eAction, SCALER_DIP_WIN eWindow)
220 {
221 _XC_ENTRY(pInstance);
222
223 switch (eAction)
224 {
225 case E_XC_DIP_CMDQ_BEGIN:
226 MDrv_XC_DIP_CMDQBegin(pInstance, eWindow);
227 break;
228
229 case E_XC_DIP_CMDQ_END:
230 MDrv_XC_DIP_CMDQEnd(pInstance, eWindow);
231 break;
232
233 default:
234 printf("[Warnning] %s, Line:%d, eWindow:%d Error Action Item:%d\n",
235 __FUNCTION__, __LINE__, eWindow, eAction);
236 break;
237 }
238
239 _XC_RETURN(pInstance);
240 }
241
MDrv_XC_DIP_CMDQ_SetOperations(void * pInstance,cmd_mload_utopia_interface * pOps,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)242 void MDrv_XC_DIP_CMDQ_SetOperations(void* pInstance, cmd_mload_utopia_interface *pOps, MS_BOOL bEnable, SCALER_DIP_WIN eWindow)
243 {
244 _XC_ENTRY(pInstance);
245 HAL_XC_DIP_CMDQ_SetOperations(pInstance, pOps, bEnable, eWindow);
246 _XC_RETURN(pInstance);
247 }
248
MDrv_XC_DIP_SWReset(void * pInstance,SCALER_DIP_WIN eWindow)249 void MDrv_XC_DIP_SWReset(void* pInstance,SCALER_DIP_WIN eWindow)
250 {
251 _XC_ENTRY(pInstance);
252 HAL_XC_DIP_SWReset(pInstance, eWindow);
253 _XC_RETURN(pInstance);
254 }
MDrv_XC_DIP_Init(void * pInstance,SCALER_DIP_WIN eWindow)255 void MDrv_XC_DIP_Init(void* pInstance,SCALER_DIP_WIN eWindow)
256 {
257 //check the mutex init
258 //shoud init XC befor DWIN init.
259 if (_XC_Mutex == -1)
260 {
261 msg_video(DIP_D_ERR("[MAPI DWIN][%06d] Should call XC init first.\n", __LINE__));
262 return;
263 }
264
265 // init DWIN address if use NR
266 MDrv_XC_DWIN_DisableInputSource(pInstance,ENABLE, eWindow);
267
268 MDrv_XC_DWIN_init_swdb(pInstance,eWindow);
269
270 MDrv_XC_DWIN_Disable_IPM_ReadWriteRequest(pInstance,ENABLE, eWindow);
271
272 MDrv_XC_DWIN_EnableIPAutoCoast(pInstance,ENABLE, eWindow);
273
274 HAL_XC_DIP_Init(pInstance, eWindow);
275 }
276
MDrv_XC_DWIN_init_swdb(void * pInstance,SCALER_DIP_WIN eWindow)277 void MDrv_XC_DWIN_init_swdb(void* pInstance,SCALER_DIP_WIN eWindow)
278 {
279 SC_DIP_SWDB_INFO SWDBreg;
280
281 SWDBreg.u32H_PreScalingRatio = 0x0;
282 SWDBreg.u32V_PreScalingRatio = 0x0;
283 SWDBreg.u16H_CapStart = 0x1;
284 SWDBreg.u16H_CapSize = 0x10;
285 SWDBreg.u16V_CapStart = 0x1;
286 SWDBreg.u16V_CapSize = 0x10;
287
288 MDrv_XC_DWIN_sw_db(pInstance,&SWDBreg, eWindow);
289
290 }
291
MDrv_XC_DWIN_sw_db(void * pInstance,P_SC_DIP_SWDB_INFO pDBreg,SCALER_DIP_WIN eWindow)292 void MDrv_XC_DWIN_sw_db(void* pInstance,P_SC_DIP_SWDB_INFO pDBreg, SCALER_DIP_WIN eWindow )
293 {
294 // Set ficlk -> sw_db for prevent garbage when no Vpre-scaling down
295 #if 0
296 if ((MDrv_XC_MLoad_GetStatus(pInstance) == E_MLOAD_ENABLED) && (!MDrv_SC_GetSkipWaitVsync(eWindow)) )
297 {
298 Hal_SC_DWIN_sw_db_burst(pInstance, pDBreg, eWindow );
299 }
300 else
301 #endif
302 {
303 _XC_ENTRY(pInstance);
304 Hal_SC_DWIN_sw_db( pInstance, pDBreg, eWindow );
305 _XC_RETURN(pInstance);
306 }
307 }
308
MDrv_XC_DWIN_SetInputSource(void * pInstance,INPUT_SOURCE_TYPE_t enInputSourceType,SCALER_DIP_WIN eWindow)309 void MDrv_XC_DWIN_SetInputSource(void* pInstance,INPUT_SOURCE_TYPE_t enInputSourceType, SCALER_DIP_WIN eWindow)
310 {
311 static INPUT_SOURCE_TYPE_t enOldDWINInputSrc = INPUT_SOURCE_NONE;
312
313 if(enOldDWINInputSrc == enInputSourceType)
314 {
315 //printf("MApi_XC_SetInputSource[Win %u] return because old src %d -> %d\n", eWindow, enOldInputSrc[eWindow], enInputSourceType);
316 return;
317 }
318 else
319 {
320 enOldDWINInputSrc = enInputSourceType;
321 }
322
323 MS_U8 u8InputSrcSel, u8SyncSel, u8VideoSel=0, u8isYPbPr;
324
325 #ifdef UTOPIA_V2
326 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
327 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
328 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
329 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
330 #endif
331 #if SUPPORT_IP_HDMI_FOR_HV_MODE
332 _XC_ENTRY(pInstance);
333 // Should disable "pixel repetition" for other source
334 if(!(IsSrcTypeHDMI(enInputSourceType) || IsSrcTypeDVI(enInputSourceType)))
335 {
336 Hal_SC_DWIN_set_fir_down_sample_divider(pInstance, DISABLE, 0x00, eWindow); //Reset Pixel repetition, when switch hv mode
337 }
338 _XC_RETURN(pInstance);
339 #endif
340 if(IsSrcTypeVga(enInputSourceType))
341 {
342 u8InputSrcSel = IP_ANALOG1;
343 u8SyncSel = (AUTO_DETECT << 1) | CSYNC;
344 u8isYPbPr = FALSE;
345 //MApi_XC_ADC_SwitchSource(1); // Force ADC to reset after source switch
346 }
347 else if(IsSrcTypeYPbPr(enInputSourceType))
348 {
349 u8InputSrcSel = IP_ANALOG1;
350 u8SyncSel = (SYNC_ON_GREEN << 1) | SOG;
351 u8isYPbPr = TRUE;
352 //MApi_XC_ADC_SwitchSource(1); // Force ADC to reset after source switch
353 }
354 else if(IsSrcTypeHDMI(enInputSourceType))
355 {
356 #if SUPPORT_IP_HDMI_FOR_HV_MODE
357 u8InputSrcSel = IP_HDMI;
358 u8VideoSel = IP_HDMI;
359 u8SyncSel = (AUTO_DETECT << 1) | CSYNC;
360 #else
361 if( MDrv_XC_GetHdmiSyncMode(pInstance) == HDMI_SYNC_DE)
362 {
363 u8InputSrcSel = IP_HDMI;
364 u8VideoSel = IP_HDMI;
365 u8SyncSel = (AUTO_DETECT << 1) | CSYNC;
366 }
367 else
368 {
369 u8InputSrcSel = IP_VIDEO;
370 u8VideoSel = IP_MST_VD_A;
371 u8SyncSel = (AUTO_DETECT << 1) | CSYNC;
372 }
373 #endif
374 u8isYPbPr = TRUE;
375
376 }
377 else if(IsSrcTypeDigitalVD(enInputSourceType))
378 {
379 u8InputSrcSel = IP_VIDEO;
380 u8VideoSel = IP_MST_VD_A;
381 u8SyncSel = (AUTO_DETECT << 1) | CSYNC;
382 u8isYPbPr = TRUE;
383 }
384 #ifdef __EXTVD
385 else if(IsUseExtVDPort(enInputPortType))
386 {
387 u8InputSrcSel = IP_VIDEO;
388 u8VideoSel = IP_CCIR656_A;
389 u8SyncSel = (AUTO_DETECT << 1) | CSYNC;
390 u8isYPbPr = TRUE;
391 }
392 #endif
393 else if(IsSrcTypeDTV(enInputSourceType) || (IsSrcTypeStorage(enInputSourceType)))
394 {
395 u8InputSrcSel = IP_VIDEO;
396 u8VideoSel = IP_MST_VD_A;
397 u8SyncSel = (AUTO_DETECT << 1) | CSYNC;
398 u8isYPbPr = TRUE;
399 }
400 else if(IsSrcTypeCapture(enInputSourceType))
401 {
402 u8InputSrcSel = IP_DVI;
403 u8SyncSel = (AUTO_DETECT << 1) | CSYNC;
404 u8isYPbPr = FALSE;
405 }
406 else
407 {
408 //printf("Unknow Input Type \n");
409 return;
410 }
411 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
412 _XC_ENTRY(pInstance);
413 Hal_SC_DWIN_SetInputSource( pInstance, u8InputSrcSel, u8SyncSel, u8VideoSel, u8isYPbPr, eWindow);
414 if(IsSrcTypeVga(enInputSourceType))
415 {
416 Hal_SC_DWIN_set_image_wrap( pInstance, DISABLE, DISABLE, eWindow );
417 }
418 else
419 {
420 Hal_SC_DWIN_set_image_wrap( pInstance, ENABLE, ENABLE, eWindow );
421 }
422
423 Hal_SC_DWIN_set_de_bypass_mode(pInstance, DISABLE, eWindow); // fix HDMI <-> component switch problems
424
425 if(IsSrcTypeVga(enInputSourceType))
426 {
427 Hal_SC_DWIN_set_input_sync_reference_edge( pInstance, LEADING_EDGE, TAILING_EDGE, eWindow );
428 Hal_SC_DWIN_set_input_vsync_delay( pInstance, DELAY_QUARTER_HSYNC, eWindow );
429 Hal_SC_DWIN_set_de_only_mode( pInstance, DISABLE, eWindow );
430 Hal_SC_DWIN_set_input_10bit( pInstance, ENABLE, eWindow );
431
432 Hal_SC_DWIN_set_coast_input( pInstance, PC_SOURCE, eWindow );
433 Hal_SC_DWIN_set_ms_filter(pInstance, ENABLE, 0, eWindow);
434 Hal_SC_DWIN_set_coast_window( pInstance, 0x0C, 0x0C, eWindow );
435 Hal_SC_DWIN_set_input_sync_sample_mode( pInstance, NORMAL_MODE, eWindow );
436 Hal_SC_DWIN_set_post_glitch_removal( pInstance, DISABLE, 0x00, eWindow );
437 }
438 else if(IsSrcTypeYPbPr(enInputSourceType))
439 {
440 Hal_SC_DWIN_set_input_sync_reference_edge( pInstance, LEADING_EDGE, TAILING_EDGE, eWindow );
441 Hal_SC_DWIN_set_input_vsync_delay( pInstance, NO_DELAY, eWindow );
442 Hal_SC_DWIN_set_ms_filter(pInstance, ENABLE, 0, eWindow);
443 Hal_SC_DWIN_set_de_only_mode( pInstance, DISABLE, eWindow );
444 Hal_SC_DWIN_set_input_10bit( pInstance, ENABLE, eWindow );
445
446 Hal_SC_DWIN_set_coast_input( pInstance, COMPONENT_VIDEO, eWindow);
447 Hal_SC_DWIN_set_coast_window( pInstance, 0x0C, 0x0C, eWindow );
448 Hal_SC_DWIN_set_input_sync_sample_mode( pInstance, GLITCH_REMOVAL, eWindow );
449 Hal_SC_DWIN_set_post_glitch_removal( pInstance, ENABLE, 0x01, eWindow );
450 }
451 else if(IsSrcTypeHDMI(enInputSourceType))
452 {
453 Hal_SC_DWIN_set_input_sync_reference_edge( pInstance, LEADING_EDGE, TAILING_EDGE, eWindow );
454 Hal_SC_DWIN_set_input_vsync_delay( pInstance, DELAY_QUARTER_HSYNC, eWindow );
455
456 if( MDrv_XC_GetHdmiSyncMode(pInstance) == HDMI_SYNC_DE)
457 {
458 Hal_SC_DWIN_set_input_vsync_delay( pInstance, DELAY_QUARTER_HSYNC, eWindow );
459 Hal_SC_DWIN_set_de_only_mode( pInstance, ENABLE, eWindow );
460 Hal_SC_DWIN_set_de_bypass_mode(pInstance, DISABLE, eWindow);
461 Hal_SC_DWIN_set_input_sync_sample_mode( pInstance, NORMAL_MODE, eWindow );
462 Hal_SC_DWIN_set_post_glitch_removal( pInstance, ENABLE, 0x07, eWindow );
463 //Hal_HDMI_Set_YUV422to444_Bypass(TRUE);
464 }
465 else
466 {
467 Hal_SC_DWIN_set_input_vsync_delay( pInstance, NO_DELAY, eWindow );
468 Hal_SC_DWIN_set_de_only_mode( pInstance, DISABLE, eWindow );
469 // Use DE as capture window
470 Hal_SC_DWIN_set_de_bypass_mode(pInstance, ENABLE, eWindow);
471 // Disable scaling for get correct DE.
472 //MDrv_SC_Enable_PreScaling(FALSE, FALSE, eWindow);
473 // Set full range capture size for de-bypass mode
474 //MDrv_SC_SetFullRangeCapture(eWindow);
475
476 Hal_SC_DWIN_set_input_sync_sample_mode( pInstance, GLITCH_REMOVAL, eWindow );
477 Hal_SC_DWIN_set_post_glitch_removal( pInstance, ENABLE, 0x01, eWindow );
478 //al_HDMI_Set_YUV422to444_Bypass(FALSE);
479 }
480
481 Hal_SC_DWIN_set_input_10bit( pInstance, ENABLE, eWindow );
482
483 Hal_SC_DWIN_set_ms_filter(pInstance, DISABLE, 0, eWindow);
484
485 //MDrv_SC_ip_set_coast_input( PC_SOURCE, eWindow );
486 Hal_SC_DWIN_set_ms_filter(pInstance, DISABLE, 0, eWindow);
487 //MDrv_SC_ip_set_coast_window( 0x0C, 0x0C, eWindow );
488 Hal_SC_DWIN_set_input_sync_sample_mode( pInstance, NORMAL_MODE, eWindow );
489 Hal_SC_DWIN_set_post_glitch_removal( pInstance, ENABLE, 0x07, eWindow );
490 }
491 else if(IsSrcTypeDigitalVD(enInputSourceType)
492 #ifdef __EXTVD
493 | IsUseExtVDPort(enInputPortType)
494 #endif
495 )
496 {
497 Hal_SC_DWIN_set_input_sync_reference_edge( pInstance, TAILING_EDGE, TAILING_EDGE, eWindow );
498 Hal_SC_DWIN_set_input_vsync_delay( pInstance, DELAY_QUARTER_HSYNC, eWindow );
499 Hal_SC_DWIN_set_de_only_mode( pInstance, DISABLE, eWindow );
500
501 #ifdef __EXTVD
502 if(IsUseExtVDPort(enInputPortType))
503 {
504 Hal_SC_DWIN_set_input_10bit( pInstance, DISABLE, eWindow );
505
506 //MDrv_WriteByte(BK_SELECT_00, REG_BANK_IP1F2);
507 //MDrv_WriteByte(L_BK_IP1F2(0x08), (MDrv_ReadByte(L_BK_IP1F2(0x08)) & 0x7F));
508 //u16tmp = SC_R2BYTE(REG_SC_BK01_08_L);
509 //SC_W2BYTEMSK(REG_SC_BK01_08_L, u16tmp & 0x007F, 0x00FF);
510 }
511 else
512 #endif
513
514 {
515 Hal_SC_DWIN_set_input_10bit( pInstance, ENABLE, eWindow );
516 }
517 //MDrv_SC_ip_set_coast_input( PC_SOURCE, eWindow );
518 Hal_SC_DWIN_set_ms_filter(pInstance, DISABLE, 0, eWindow);
519 //MDrv_SC_ip_set_coast_window( 0x0C, 0x0C, eWindow );
520 Hal_SC_DWIN_set_input_sync_sample_mode( pInstance, NORMAL_MODE, eWindow );
521 Hal_SC_DWIN_set_post_glitch_removal( pInstance, DISABLE, 0x00, eWindow );
522 }
523 else if(IsSrcTypeCapture(enInputSourceType))
524 {
525 Hal_SC_DWIN_set_input_sync_reference_edge( pInstance, LEADING_EDGE, TAILING_EDGE, eWindow );
526 Hal_SC_DWIN_set_input_vsync_delay( pInstance, DELAY_QUARTER_HSYNC, eWindow );
527 Hal_SC_DWIN_set_de_only_mode( pInstance, DISABLE, eWindow );
528 Hal_SC_DWIN_set_input_10bit( pInstance, ENABLE, eWindow );
529
530 Hal_SC_DWIN_set_input_sync_sample_mode( pInstance, GLITCH_REMOVAL, eWindow );
531 Hal_SC_DWIN_set_post_glitch_removal( pInstance, ENABLE, 0x01, eWindow );
532 }
533 else //DTV
534 {
535 //set HSYNC reference to leading edge, the capature start will be 1/2 Hsync when input source is from DC0/DC1
536 Hal_SC_DWIN_set_input_sync_reference_edge( pInstance, LEADING_EDGE, TAILING_EDGE, eWindow );
537 Hal_SC_DWIN_set_input_vsync_delay( pInstance, DELAY_QUARTER_HSYNC, eWindow );
538 Hal_SC_DWIN_set_de_only_mode( pInstance, DISABLE, eWindow );
539 Hal_SC_DWIN_set_input_10bit( pInstance, ENABLE, eWindow );
540
541 //MDrv_SC_ip_set_coast_input( PC_SOURCE, eWindow );
542 Hal_SC_DWIN_set_ms_filter(pInstance, DISABLE, 0, eWindow);
543 //MDrv_SC_ip_set_coast_window( 0x0C, 0x0C, eWindow );
544 Hal_SC_DWIN_set_input_sync_sample_mode( pInstance, NORMAL_MODE, eWindow );
545 Hal_SC_DWIN_set_post_glitch_removal( pInstance, DISABLE, 0x00, eWindow );
546 }
547
548 // set h0027 [2] : true to enable DE only mode Glitch Protect for position
549 // to fix HDMI 720P YUV422 HStart error & HDE lack of 1
550 if (IsSrcTypeHDMI(enInputSourceType))
551 Hal_SC_DWIN_set_DE_Mode_Glitch(pInstance, 0x24, eWindow); // VSync glitch removal with line less than 2(DE only)
552 else
553 Hal_SC_DWIN_set_DE_Mode_Glitch(pInstance, 0x04, eWindow); // CHANNEL_ATTRIBUTE function control
554 MDrv_XC_DWIN_Scaler_Field_Detect(pInstance,enInputSourceType, GOPDWIN_SCAN_MODE_AUTO, eWindow );
555 g_DIPSrcInfo[eWindow].enInputSourceType = enInputSourceType;
556 _XC_RETURN(pInstance);
557 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
558 }
559
MDrv_XC_DWIN_GetInputSource(void * pInstance,INPUT_SOURCE_TYPE_t * enInputSourceType,SCALER_DIP_WIN eWindow)560 void MDrv_XC_DWIN_GetInputSource(void* pInstance,INPUT_SOURCE_TYPE_t *enInputSourceType, SCALER_DIP_WIN eWindow)
561 {
562 #ifdef UTOPIA_V2
563 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
564 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
565 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
566 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
567 #endif
568 switch(eWindow)
569 {
570 case DIP_WINDOW :
571 *enInputSourceType = g_DIPSrcInfo[DIP_WINDOW].enInputSourceType;
572 break;
573 default :
574 *enInputSourceType = INPUT_SOURCE_NONE;
575 break;
576 }
577 }
578
MDrv_XC_DWIN_DisableInputSource(void * pInstance,MS_BOOL bDisable,SCALER_DIP_WIN eWindow)579 void MDrv_XC_DWIN_DisableInputSource(void* pInstance, MS_BOOL bDisable, SCALER_DIP_WIN eWindow)
580 {
581 _XC_ENTRY(pInstance);
582
583 #if 0
584 if ((MDrv_XC_MLoad_GetStatus(pInstance) == E_MLOAD_ENABLED) && (!MDrv_SC_GetSkipWaitVsync(eWindow) ) )
585 {
586 _MLOAD_ENTRY(pInstance);
587
588 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK33_02_L, (bDisable ? BIT(7):0), BIT(7));
589
590 MDrv_XC_MLoad_Fire(pInstance, TRUE);
591 _MLOAD_RETURN(pInstance);
592 }
593 else
594 #endif
595 {
596 Hal_SC_DWIN_DisableInputSource(pInstance, bDisable, eWindow);
597 }
598 _XC_RETURN(pInstance);
599 }
600
MDrv_XC_DWIN_SetFrameBufferAddress(void * pInstance,MS_PHY u64FBAddress,MS_PHY u64FBSize,SCALER_DIP_WIN eWindow)601 void MDrv_XC_DWIN_SetFrameBufferAddress(void* pInstance,MS_PHY u64FBAddress, MS_PHY u64FBSize, SCALER_DIP_WIN eWindow)
602 {
603
604 }
605
MDrv_XC_DWIN_set_capture_v_start(void * pInstance,MS_U16 u16Vstart,SCALER_DIP_WIN eWindow)606 void MDrv_XC_DWIN_set_capture_v_start(void* pInstance,MS_U16 u16Vstart , SCALER_DIP_WIN eWindow)
607 {
608 #ifdef UTOPIA_V2
609 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
610 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
611 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
612 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
613 #endif
614 g_DIPSrcInfo[eWindow].stCapWin.y = u16Vstart;
615 _XC_ENTRY(pInstance);
616 Hal_SC_DWIN_set_capture_v_start( pInstance, u16Vstart, eWindow);
617 _XC_RETURN(pInstance);
618 }
619
MDrv_XC_DWIN_set_capture_h_start(void * pInstance,MS_U16 u16Vstart,SCALER_DIP_WIN eWindow)620 void MDrv_XC_DWIN_set_capture_h_start(void* pInstance,MS_U16 u16Vstart , SCALER_DIP_WIN eWindow)
621 {
622 #ifdef UTOPIA_V2
623 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
624 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
625 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
626 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
627 #endif
628 g_DIPSrcInfo[eWindow].stCapWin.x = u16Vstart;
629 _XC_ENTRY(pInstance);
630 Hal_SC_DWIN_set_capture_h_start( pInstance, u16Vstart, eWindow);
631 _XC_RETURN(pInstance);
632 }
633
MDrv_XC_DWIN_set_capture_v_size(void * pInstance,MS_U16 u16Vsize,SCALER_DIP_WIN eWindow)634 void MDrv_XC_DWIN_set_capture_v_size(void* pInstance,MS_U16 u16Vsize , SCALER_DIP_WIN eWindow)
635 {
636 #ifdef UTOPIA_V2
637 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
638 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
639 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
640 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
641 #endif
642 g_DIPSrcInfo[eWindow].stCapWin.height = u16Vsize;
643 _XC_ENTRY(pInstance);
644 Hal_SC_DWIN_set_capture_v_size( pInstance, u16Vsize, eWindow);
645 _XC_RETURN(pInstance);
646 }
647
MDrv_XC_DWIN_set_capture_h_size(void * pInstance,MS_U16 u16Hsize,SCALER_DIP_WIN eWindow)648 void MDrv_XC_DWIN_set_capture_h_size(void* pInstance,MS_U16 u16Hsize , SCALER_DIP_WIN eWindow)
649 {
650 #ifdef UTOPIA_V2
651 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
652 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
653 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
654 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
655 #endif
656 g_DIPSrcInfo[eWindow].stCapWin.width = u16Hsize;
657 _XC_ENTRY(pInstance);
658 Hal_SC_DWIN_set_capture_h_size( pInstance, u16Hsize, eWindow);
659 _XC_RETURN(pInstance);
660 }
661
MDrv_XC_DWIN_get_capture_window(void * pInstance,MS_WINDOW_TYPE * capture_win,SCALER_DIP_WIN eWindow)662 void MDrv_XC_DWIN_get_capture_window(void* pInstance,MS_WINDOW_TYPE* capture_win,SCALER_DIP_WIN eWindow)
663 {
664 _XC_ENTRY(pInstance);
665 Hal_SC_DWIN_get_capture_window(pInstance, capture_win, eWindow);
666 _XC_RETURN(pInstance);
667 }
668
669 /******************************************************************************/
670 ///Set Capture window (Input window) information.
671 ///@param pstWindow \b IN
672 ///- pointer to window information
673 /******************************************************************************/
MDrv_XC_DWIN_set_capture_window(void * pInstance,SCALER_DIP_WIN eWindow)674 void MDrv_XC_DWIN_set_capture_window(void* pInstance,SCALER_DIP_WIN eWindow)
675 {
676 #ifdef UTOPIA_V2
677 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
678 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
679 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
680 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
681 #endif
682 // HDMI HV mode uses DE by pass, so capture win should be set as full range
683 #if 0 //DIP do not need this, only XC_IP1/2 need this
684 if(0)//( ( IsSrcTypeHDMI( g_DIPSrcInfo[eWindow].enInputSourceType ) ) && (MDrv_XC_GetHdmiSyncMode(pInstance) == HDMI_SYNC_HV) )
685 {
686 // Capture win must keep full range in HV mode
687 stDIP_DBreg.u16V_CapStart = 0xC;
688 stDIP_DBreg.u16H_CapStart = 0xC;
689 stDIP_DBreg.u16V_CapSize = 0x1FFF;
690 stDIP_DBreg.u16H_CapSize = 0x1FFF;
691 }
692 else
693 #endif
694 if(g_DIPSrcInfo[eWindow].bInterlace)
695 {
696 //For interlace, set clip window V Pos/Size= field Pos/Size
697 stDIP_DBreg[eWindow].u16V_CapStart = (g_DIPSrcInfo[eWindow].stCapWin.y)>>1;
698 stDIP_DBreg[eWindow].u16H_CapStart = g_DIPSrcInfo[eWindow].stCapWin.x;
699 stDIP_DBreg[eWindow].u16V_CapSize = (g_DIPSrcInfo[eWindow].stCapWin.height)>>1;
700 stDIP_DBreg[eWindow].u16H_CapSize = g_DIPSrcInfo[eWindow].stCapWin.width;
701 }
702 else
703 {
704 stDIP_DBreg[eWindow].u16V_CapStart = g_DIPSrcInfo[eWindow].stCapWin.y;
705 stDIP_DBreg[eWindow].u16H_CapStart = g_DIPSrcInfo[eWindow].stCapWin.x;
706 stDIP_DBreg[eWindow].u16V_CapSize = g_DIPSrcInfo[eWindow].stCapWin.height;
707 stDIP_DBreg[eWindow].u16H_CapSize = g_DIPSrcInfo[eWindow].stCapWin.width;
708 }
709 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"Set DIP ClipWin x:%u, y:%u, w:%u, h:%u\n", stDIP_DBreg[eWindow].u16H_CapStart, stDIP_DBreg[eWindow].u16H_CapSize, stDIP_DBreg[eWindow].u16V_CapStart, stDIP_DBreg[eWindow].u16V_CapSize);
710 }
711
MDrv_XC_DWIN_get_DE_Window(void * pInstance,MS_WINDOW_TYPE * psWin,SCALER_DIP_WIN eWindow)712 void MDrv_XC_DWIN_get_DE_Window(void* pInstance,MS_WINDOW_TYPE* psWin, SCALER_DIP_WIN eWindow)
713 {
714 _XC_ENTRY(pInstance);
715 Hal_SC_DWIN_get_de_window(pInstance, psWin, eWindow);
716 _XC_RETURN(pInstance);
717 }
718
MDrv_XC_DWIN_EnableR2YCSC(void * pInstance,MS_BOOL benable,SCALER_DIP_WIN eWindow)719 void MDrv_XC_DWIN_EnableR2YCSC(void* pInstance,MS_BOOL benable, SCALER_DIP_WIN eWindow)
720 {
721 _XC_ENTRY(pInstance);
722 Hal_SC_DWIN_EnableR2YCSC( pInstance, benable, eWindow);
723 _XC_RETURN(pInstance);
724 }
725
MDrv_XC_DWIN_set_delayline(void * pInstance,MS_U8 u8DelayLines,SCALER_DIP_WIN eWindow)726 void MDrv_XC_DWIN_set_delayline(void* pInstance,MS_U8 u8DelayLines, SCALER_DIP_WIN eWindow )
727 {
728 _XC_ENTRY(pInstance);
729 Hal_SC_DWIN_set_delayline(pInstance, u8DelayLines,eWindow);
730 _XC_RETURN(pInstance);
731 }
732
MDrv_XC_DWIN_set_prescaling_ratio(void * pInstance,INPUT_SOURCE_TYPE_t enInputSourceType,XC_DIP_InternalStatus * pSrcInfo,SCALER_DIP_WIN eWindow)733 void MDrv_XC_DWIN_set_prescaling_ratio(void* pInstance,INPUT_SOURCE_TYPE_t enInputSourceType, XC_DIP_InternalStatus *pSrcInfo, SCALER_DIP_WIN eWindow)
734 {
735 MS_U32 u32TmpPre;
736 MS_U16 u16ScaleSrc = 0, u16ScaleDst = 0;
737 MS_BOOL bEnPreDown = 0;
738 MS_BOOL bInterlace = pSrcInfo->bInterlace;
739 MS_U16 u16SrcHWidth = 0;
740 MS_U64 u64_result = 0;
741
742 // Store Pre-scaling source / dest size of previouse
743 static MS_U16 _u16HScaleSrc[MAX_DIP_WINDOW] = {0} ,_u16HScaleDst[MAX_DIP_WINDOW] = {0};
744 static MS_U16 _u16VScaleSrc[MAX_DIP_WINDOW] = {0} ,_u16VScaleDst[MAX_DIP_WINDOW] = {0};
745
746 //-----------------------------------------
747 // Vertical
748 //-----------------------------------------
749 if (pSrcInfo->bPreVCusScaling == TRUE)
750 {
751 u16ScaleSrc = pSrcInfo->u16PreVCusScalingSrc;
752 u16ScaleDst = pSrcInfo->u16PreVCusScalingDst;
753 }
754 else
755 {
756 // Put full image into memory as default
757 //u16ScaleSrc = u16ScaleDst = pSrcInfo->stCapWin.height;
758 // for DIP do pre scaling no post scaling.
759 u16ScaleSrc = pSrcInfo->stCapWin.height;
760 u16ScaleDst = pSrcInfo->stCapWin.height;
761 }
762
763
764 if( bInterlace )
765 {
766 if (u16ScaleDst % 2 )
767 {
768 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"==============================================================\n");
769 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"======= Pre-scaling V size have to align 2 !!!!!!!!===========\n");
770 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"==============================================================\n");
771 MS_ASSERT(0);
772 u16ScaleDst = ( u16ScaleDst + 1) & ~0x1;
773 }
774 }
775
776
777 // Check prescaling status. Set bPreScalingRatioChanged as true only when source/dest is different with previous source/dest
778 // We must update this information before pre-scaling filter.
779 //(1. We can skip pre-scaling filter update. 2. We can decide which method we can use for load registers. DS or Menuload.)
780 if ( (_u16VScaleSrc[eWindow] != u16ScaleSrc) || (_u16VScaleDst[eWindow] != u16ScaleDst) )
781 {
782
783 _u16VScaleSrc[eWindow] = u16ScaleSrc;
784 _u16VScaleDst[eWindow] = u16ScaleDst;
785
786 }
787 else
788 {
789 }
790
791 _XC_ENTRY(pInstance);
792
793 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"[PRE]eWindow[%u] VSrc=%u, VDst=%u\n",eWindow , u16ScaleSrc, u16ScaleDst);
794
795 if (u16ScaleSrc > u16ScaleDst) //pre scaling only support scaling down
796 {
797 //MS_U32 u32Value = 0;
798
799 if (u16ScaleSrc == 0)
800 {
801 u32TmpPre = 0;
802 }
803 else
804 {
805 u32TmpPre = V_PreScalingDownRatioDIP(u16ScaleSrc, u16ScaleDst);
806 }
807
808 u32TmpPre &= 0xFFFFFFL;
809
810 u32TmpPre |= 0x80000000L;
811
812 #if 0
813 // Error checking
814 if (u16ScaleSrc == 0)
815 u32Value = 0;
816 else
817 u32Value = (MS_U32)u16ScaleDst * 0x80000 / u16ScaleSrc;
818 #endif
819 //HAL_SC_Set_VInitFactorTwo(u32Value,eWindow);
820 Hal_SC_DWIN_Set_vsd_output_line_count(pInstance, DISABLE, u16ScaleDst, eWindow);
821 Hal_SC_DWIN_Set_vsd_input_line_count(pInstance, DISABLE, FALSE, 0, eWindow);
822
823 }
824 else // no pre-V scaling case
825 {
826 u16ScaleSrc = pSrcInfo->u16PreVCusScalingSrc;
827 u16ScaleDst = pSrcInfo->u16PreVCusScalingDst;
828 u32TmpPre = 0;
829 Hal_SC_DWIN_Set_vsd_output_line_count(pInstance, DISABLE, u16ScaleDst, eWindow);
830 Hal_SC_DWIN_Set_vsd_input_line_count(pInstance, DISABLE, FALSE, 0, eWindow);
831 //HAL_SC_Set_VInitFactorTwo(0x80000,eWindow);
832 }
833
834 _XC_RETURN(pInstance);
835
836 //store prescaling info here ( Why using u16PreVCusScalingSrc and u16PreVCusScalingDst??)
837 pSrcInfo->u16PreVCusScalingSrc = u16ScaleSrc;
838 pSrcInfo->u16PreVCusScalingDst = u16ScaleDst;
839 pSrcInfo->u16V_SizeAfterPreScaling = u16ScaleDst;
840
841 stDIP_DBreg[eWindow].u32V_PreScalingRatio = u32TmpPre;
842
843 //-----------------------------------------
844 // Horizontal
845 // HSD rule: 3D scaling > customer scaling > QMap HSD sampling > auto fit
846 //-----------------------------------------
847
848 // Note!! Formula: FHD - If (H Crop size /2 ) > ( H display size ), Must-do H pre-scaling down.
849
850 {
851 // Custimize
852 if(pSrcInfo->bPreHCusScaling)
853 {
854 u16SrcHWidth = pSrcInfo->u16PreHCusScalingSrc;
855 if (u16SrcHWidth > pSrcInfo->u16PreHCusScalingDst)
856 {
857 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->u16PreHCusScalingDst;
858 }
859 else
860 {
861 pSrcInfo->u16H_SizeAfterPreScaling = u16SrcHWidth;
862 }
863 //MDrv_SC_3D_Adjust_PreHorDstSize(enInputSourceType, pSrcInfo, eWindow);
864 // 3d adjust may make the pre h dst bigger than cus_pre_H, we need adjust it again.
865 if (pSrcInfo->u16H_SizeAfterPreScaling > pSrcInfo->u16PreHCusScalingDst)
866 {
867 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->u16PreHCusScalingDst;
868 }
869 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"Customer H scaling: eWindow[%u] HSrc=%u, HDst=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
870 }
871 else
872 {
873 u16SrcHWidth = pSrcInfo->stCapWin.width;
874 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->stCapWin.width;
875
876 // this DTV flow don't obey the HSD rule, but HDuplicate won't affect QMap non-prescaling case,
877 // because the HDuplicate condition is no bigger than 704, refer to MVOP_AutoGenMPEGTiming()
878 // need to refine later
879 if(IsSrcTypeDTV(enInputSourceType) && pSrcInfo->bHDuplicate) // for better quality
880 {
881 MS_U16 capwidth = 0;
882
883 u64_result = pSrcInfo->stCapWin.width;
884 do_div(u64_result,2);
885 capwidth = u64_result;
886 {
887 pSrcInfo->u16H_SizeAfterPreScaling = capwidth;
888 }
889 }
890 //!!NOTE START:
891 //if QMAP support HSD Sampling, this item need to disable and the scaling size will control by QMAP
892 //If we want to follow the HSD rule, we cannot enable ENABLE_YPBPR_PRESCALING_TO_ORIGINAL and
893 // ENABLE_VD_PRESCALING_TO_DOT75
894 #if (ENABLE_YPBPR_PRESCALING_TO_ORIGINAL)
895 else if(IsSrcTypeYPbPr(enInputSourceType) && pSrcInfo->bHDuplicate)
896 {
897 u64_result = pSrcInfo->stCapWin.width;
898 do_div(u64_result,2);
899 pSrcInfo->u16H_SizeAfterPreScaling = u64_result;
900 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"ENABLE_YPBPR_PRESCALING_TO_ORIGINAL: eWindow[%u] HSrc=%u, HDst=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
901 }
902 #endif
903 //!!NOTE END
904 #if (ENABLE_VD_PRESCALING_TO_DOT75)
905 else if(IsSrcTypeDigitalVD(enInputSourceType))
906 {
907 u64_result = pSrcInfo->stCapWin.width* 3 ;
908 do_div(u64_result,4);
909 pSrcInfo->u16H_SizeAfterPreScaling = u64_result;
910 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"ENABLE_VD_PRESCALING_TO_DOT75: eWindow[%u] HSrc=%u, HDst=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
911 }
912 #endif
913 else
914 {
915 // H scaling controlled by Qmap.
916 // XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"[PRE]Force Prescaling Down : %d _bPQSetPreScalingrate : %d \n",bForcePreHScalingDown, MDrv_SC_GetPQHSDFlag());
917 }
918 }
919 }
920 //Setting Line Buffer Start offset for Sub Win
921
922 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"eWindow[%u] HSrc=%u, HDst=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
923
924 if(pSrcInfo->u16H_SizeAfterPreScaling & BIT(0))
925 {
926 //YUV422, h size must be even to prevent showing of garbage at the end of line
927 if(pSrcInfo->u16H_SizeAfterPreScaling < pSrcInfo->stCapWin.width)
928 {
929 if(MDrv_SC_GetPQHSDFlag(pInstance) == TRUE)
930 {
931 pSrcInfo->u16H_SizeAfterPreScaling = (pSrcInfo->u16H_SizeAfterPreScaling - 1) & ~0x1;
932 }
933 else
934 {
935 pSrcInfo->u16H_SizeAfterPreScaling = (pSrcInfo->u16H_SizeAfterPreScaling + 1) & ~0x1;
936 }
937 }
938 else
939 {
940 pSrcInfo->u16H_SizeAfterPreScaling = u16SrcHWidth;
941 }
942 }
943
944 // Check prescaling status. Set bPreScalingRatioChanged as true only when src != dest.
945 // We update this information before pre-scaling filter.
946 if ( (_u16HScaleSrc[eWindow] != u16SrcHWidth) || (_u16HScaleDst[eWindow] != pSrcInfo->u16H_SizeAfterPreScaling) )
947 {
948
949 _u16HScaleSrc[eWindow] = u16SrcHWidth;
950 _u16HScaleDst[eWindow] = pSrcInfo->u16H_SizeAfterPreScaling;
951 }
952 else
953 {
954 }
955
956 //printf("bEnPreDown=%u, bAdvMode=%u\n", (MS_U16)bEnPreDown, (MS_U16)bAdvMode);
957 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"[PRE]eWindow[%u] HSrc=%u, HDst=%u\n", eWindow, u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling);
958
959 if (u16SrcHWidth > pSrcInfo->u16H_SizeAfterPreScaling)
960 {
961 MS_U16 u16div = 1;
962
963 // To avoid overflow when do H_PreScalingDownRatioAdv/H_PreScalingDownRatioAdv_No_Minus1
964 if(u16SrcHWidth > 4096)
965 {
966 while(1)
967 {
968 MS_U16 u16ret;
969
970 u16div <<= 1;
971
972 if (u16div == 0)
973 {
974 break;
975 }
976
977 u16ret = u16SrcHWidth/u16div;
978
979 if(u16ret == 0)
980 {
981 u16div = 1;
982 break;
983 }
984 else if(u16ret< 4096 && u16ret > pSrcInfo->u16H_SizeAfterPreScaling)
985 {
986 break;
987 }
988 }
989 }
990
991 // disable prescaling filter, use cb mode scaling ratio
992 if (u16SrcHWidth == 0 )
993 u32TmpPre = 0;
994 else
995 u32TmpPre = (H_PreScalingDownRatioDIP(u16SrcHWidth, pSrcInfo->u16H_SizeAfterPreScaling));
996
997 bEnPreDown = 1;
998 u32TmpPre &= 0x7FFFFFL;
999 }
1000 else
1001 {
1002 pSrcInfo->u16H_SizeAfterPreScaling = pSrcInfo->u16PreHCusScalingDst;
1003 {
1004 bEnPreDown = 0;
1005 u32TmpPre = 0x100000L;
1006 }
1007
1008 }
1009 //store prescaling info here
1010 pSrcInfo->u16PreHCusScalingSrc = u16SrcHWidth;
1011 pSrcInfo->u16PreHCusScalingDst = pSrcInfo->u16H_SizeAfterPreScaling;
1012
1013 if (bEnPreDown)
1014 {
1015 u32TmpPre |= 0x80000000L;
1016 }
1017
1018 stDIP_DBreg[eWindow].u32H_PreScalingRatio = u32TmpPre;
1019
1020 }
1021
_Mdrv_XC_DWIN_CalcFBNum(void * pInstance,MS_BOOL * pIsLinearMode,XC_FRAME_STORE_NUMBER * pFrameStoreNumber,MS_BOOL bInterlace,MS_PHY u64Framesize,MS_PHY u64DNRBufSize,SCALER_DIP_WIN eWindow)1022 void _Mdrv_XC_DWIN_CalcFBNum(void* pInstance,MS_BOOL *pIsLinearMode,
1023 XC_FRAME_STORE_NUMBER *pFrameStoreNumber,
1024 MS_BOOL bInterlace,
1025 MS_PHY u64Framesize,
1026 MS_PHY u64DNRBufSize,
1027 SCALER_DIP_WIN eWindow)
1028 {
1029 // For DWIN debg mode, use 4 frame for I mode, and 2 frame for P mode
1030 if(bInterlace)
1031 {
1032 *pFrameStoreNumber = IMAGE_STORE_4_FIELDS;
1033 }
1034 else
1035 {
1036 *pFrameStoreNumber = IMAGE_STORE_2_FRAMES;
1037 }
1038
1039 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"u8BestFBNum %d \n",*pFrameStoreNumber);
1040
1041 }
1042 // for mirror mode and dynamic scaling store u32BaseOffset
1043
MDrv_XC_DWIN_set_storeFrameNUM(void * pInstance,SCALER_DIP_WIN eWindow,MS_U8 u8FrameNum)1044 void MDrv_XC_DWIN_set_storeFrameNUM(void* pInstance,SCALER_DIP_WIN eWindow,MS_U8 u8FrameNum)
1045 {
1046
1047 }
1048
1049 /******************************************************************************/
1050 ///This function will calculate:
1051 // [DNR]
1052 // DNROffset, DNRFetch, DNRBase1, u32WritelimitBase
1053 // [OPM]
1054 // OPMFetch, OPMBase0, OPMBase1, LBOffset
1055 // [OP1]
1056 // u16VLen
1057 /******************************************************************************/
MDrv_XC_DWIN_set_fetch_number_limit(void * pInstance,XC_DIP_InternalStatus * pSrcInfo,SCALER_DIP_WIN eWindow)1058 void MDrv_XC_DWIN_set_fetch_number_limit(void* pInstance,XC_DIP_InternalStatus *pSrcInfo, SCALER_DIP_WIN eWindow)
1059 {
1060
1061 /////////////////////////////////////////////////
1062 // Set DNR Memeory Settings //
1063 /////////////////////////////////////////////////
1064 // Cal DNR Fetch/Offset
1065 stDIP_DBreg[eWindow].u16DNRFetch = pSrcInfo->u16H_SizeAfterPreScaling;
1066 stDIP_DBreg[eWindow].u16DNROffset = (stDIP_DBreg[eWindow].u16DNRFetch + OFFSET_PIXEL_ALIGNMENT - 1) & ~(OFFSET_PIXEL_ALIGNMENT-1); //TODO: T3 should be 32 alignment;
1067
1068 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"u16DNRFetch=%u\n",stDIP_DBreg[eWindow].u16DNRFetch);
1069 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"u16DNROffset=%u\n",stDIP_DBreg[eWindow].u16DNROffset);
1070
1071 }
MDrv_XC_DWIN_EnableIPAutoCoast(void * pInstance,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1072 void MDrv_XC_DWIN_EnableIPAutoCoast(void* pInstance,MS_BOOL bEnable, SCALER_DIP_WIN eWindow)
1073 {
1074 _XC_ENTRY(pInstance);
1075 Hal_SC_DWIN_EnableIPAutoCoast(pInstance, bEnable, eWindow);
1076 _XC_RETURN(pInstance);
1077 }
1078
MDrv_XC_DWIN_Scaler_Field_Detect(void * pInstance,INPUT_SOURCE_TYPE_t enInputSrcType,EN_XC_DWIN_SCAN_TYPE enScanType,SCALER_DIP_WIN eWindow)1079 void MDrv_XC_DWIN_Scaler_Field_Detect(void* pInstance,INPUT_SOURCE_TYPE_t enInputSrcType, EN_XC_DWIN_SCAN_TYPE enScanType, SCALER_DIP_WIN eWindow)
1080 {
1081
1082 MS_U8 reg_IP1F2_1D = 0;
1083 MS_U8 reg_IP1F2_23 = 0;
1084 MS_U16 reg_IP1F2_21 = 0;
1085 //MS_U16 u16Vtt = 0;
1086
1087 // Note:
1088 // IP1F2_1D[13]: Enable auto no signal filter mode.
1089 // This functionality is to improve timing detection stability.
1090
1091 if(IsSrcTypeDigitalVD(enInputSrcType))
1092 {
1093 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "VD \n");
1094 reg_IP1F2_1D = 0xA1;
1095 reg_IP1F2_21 = 0x0403;
1096 reg_IP1F2_23 = 0x30;
1097 }
1098 else if(IsSrcTypeDTV(enInputSrcType) || IsSrcTypeStorage(enInputSrcType))
1099 {
1100 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "DTV ");
1101 if (enScanType == GOPDWIN_SCAN_MODE_INTERLACE)
1102 {
1103 reg_IP1F2_1D = 0xA1;
1104 reg_IP1F2_21 = 0x0403;
1105 reg_IP1F2_23 = 0x30;
1106 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "-> Interlace\n");
1107 }
1108 else
1109 {
1110 reg_IP1F2_1D = 0x21;
1111 reg_IP1F2_21 = 0x0400;
1112 reg_IP1F2_23 = 0x00;
1113 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "-> Progressive\n");
1114 }
1115 }
1116 else if (IsSrcTypeHDMI(enInputSrcType))
1117 {
1118
1119 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "HDMI ");
1120 if (enScanType == GOPDWIN_SCAN_MODE_INTERLACE)
1121 {
1122 reg_IP1F2_1D = 0x21;
1123 reg_IP1F2_21 = 0x0003; // enable DE -> no field invert, disable DE -> use field invert
1124 reg_IP1F2_23 = 0x20;
1125 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "-> Interlace\n");
1126 }
1127 else
1128 {
1129 reg_IP1F2_1D = 0x21;
1130 reg_IP1F2_21 = 0x0000;
1131 reg_IP1F2_23 = 0x00;
1132 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "-> Progressive\n");
1133 }
1134
1135 reg_IP1F2_21 |= BIT(12);
1136
1137 if( (MDrv_XC_GetHdmiSyncMode(pInstance) == HDMI_SYNC_HV)
1138 &&(enScanType == GOPDWIN_SCAN_MODE_INTERLACE) )
1139 {
1140 MS_U16 u16Cur_IP1F2_21Val = SC_R2BYTE(0,REG_SC_BK01_21_L);
1141 if( u16Cur_IP1F2_21Val&0xC000 )
1142 {
1143 if( reg_IP1F2_21&BIT(8) )
1144 {
1145 reg_IP1F2_21 &= ~BIT(8);
1146 }
1147 else
1148 {
1149 reg_IP1F2_21 |= BIT(8);
1150 }
1151 //printf("daniel_test patch REG_SC_BK01_21_L: FieldInvert\n");
1152 }
1153 else
1154 {
1155 }
1156 }
1157
1158 }
1159 else if(IsSrcTypeVga(enInputSrcType))
1160 {
1161 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "DSUB ");
1162 if (enScanType == GOPDWIN_SCAN_MODE_INTERLACE)
1163 {
1164 reg_IP1F2_1D = 0x21;
1165 reg_IP1F2_21 = 0x0103;
1166 reg_IP1F2_23 = 0x10;
1167 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "-> Interlace\n");
1168 }
1169 else
1170 {
1171 reg_IP1F2_1D = 0x21;
1172 reg_IP1F2_21 = 0x0000;
1173 reg_IP1F2_23 = 0x00;
1174 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "-> Progressive\n");
1175 }
1176 }
1177 else // YPbPr
1178 {
1179 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW, "YPbPr ");
1180
1181 if(MDrv_XC_ip_GetEuroHdtvStatus(pInstance, MAIN_WINDOW) == EURO_AUS_HDTV_NORMAL)
1182 {
1183 reg_IP1F2_21 = 0x0100;
1184 }
1185 else
1186 {
1187 reg_IP1F2_21 = 0x0000;
1188 }
1189 reg_IP1F2_1D = 0xA1;
1190 reg_IP1F2_23 = 0x08; //0x20 // Vtt will use "IP1F2_23 * 16" as lower bound.
1191 }
1192 Hal_SC_DWIN_setfield(pInstance, reg_IP1F2_1D, reg_IP1F2_21, reg_IP1F2_23, eWindow);
1193 }
1194
MDrv_XC_DWIN_Disable_IPM_ReadWriteRequest(void * pInstance,MS_BOOL bDisable,SCALER_DIP_WIN eWindow)1195 void MDrv_XC_DWIN_Disable_IPM_ReadWriteRequest(void* pInstance,MS_BOOL bDisable, SCALER_DIP_WIN eWindow)
1196 {
1197 _XC_ENTRY(pInstance);
1198 Hal_SC_DWIN_Disable_IPM_ReadWriteRequest(pInstance, bDisable, eWindow);
1199 _XC_RETURN(pInstance);
1200 }
MDrv_XC_DWIN_SetMode(void * pInstance,INPUT_SOURCE_TYPE_t enInputSourceType,XC_DIP_InternalStatus * pSrcInfo,SCALER_DIP_WIN eWindow)1201 void MDrv_XC_DWIN_SetMode(void* pInstance,INPUT_SOURCE_TYPE_t enInputSourceType, XC_DIP_InternalStatus *pSrcInfo, SCALER_DIP_WIN eWindow )
1202 {
1203 MS_BOOL bInterlace = pSrcInfo->bInterlace;
1204 #ifdef UTOPIA_V2
1205 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
1206 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
1207 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
1208 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
1209 #endif
1210 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1211 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1212 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1213 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1214 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1215 //MS_BOOL bUseYUVSpace;
1216 //MS_U8 interlace_type;
1217 //----------------------------------------------------
1218 // Setup Memory format
1219 //----------------------------------------------------
1220 if(s_DIPeMemFmt[eWindow] == E_MS_XC_MEM_FMT_AUTO)
1221 {
1222 if(!bInterlace &&
1223 ((IsSrcTypeHDMI(enInputSourceType) && !pXCResourcePrivate->stdrv_HDMI.enStatus_info.b_St_HDMI_Mode) || // DVI plugged into HDMI connector
1224 IsSrcTypeVga(enInputSourceType) ) )
1225 { // always keep memory foramt to 444 for corresponding to Y/C post-scaling filter
1226 pSrcInfo->bMemFmt422 = FALSE;
1227 }
1228 else
1229 { // if input source is 422, HW will convert to 444 automatically
1230 pSrcInfo->bMemFmt422 = TRUE;
1231 }
1232 }
1233 else
1234 {
1235 if(s_DIPeMemFmt[eWindow] == E_MS_XC_MEM_FMT_422)
1236 pSrcInfo->bMemFmt422 = TRUE;
1237 else
1238 pSrcInfo->bMemFmt422 = FALSE;
1239 }
1240
1241 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1242 msg_video(DIP_D_INFO("MemFmt422=%u\n", (MS_U16)pSrcInfo->bMemFmt422));
1243
1244 #if 0
1245 if(s_PQ_Function_Info.pq_get_memyuvfmt == NULL)
1246 pSrcInfo->bMemYUVFmt = TRUE;
1247 else
1248 pSrcInfo->bMemYUVFmt = s_PQ_Function_Info.pq_get_memyuvfmt(eWindow == DIP_SUB_WINDOW ? PQ_SUB_WINDOW : PQ_MAIN_WINDOW,
1249 g_DIPSrcInfo[eWindow].bForceRGBin == ENABLE ? PQ_FOURCE_COLOR_RGB : PQ_FOURCE_COLOR_DEFAULT);
1250 #endif
1251 _XC_ENTRY(pInstance);
1252 //-------------------------------------------
1253 // Set De-interlaced mode and Memory format
1254 //-------------------------------------------
1255 //printf("==> Set PQ MEMORY Mode: %d\n", eWindow);
1256
1257 // copy MADI mode from IP1
1258 MS_U16 u16MADImode = SC_R2BYTE(0,REG_SC_BK12_01_L);
1259 SC_W2BYTE(0,REG_SC_BK35_01_L, u16MADImode);
1260
1261 //pSrcInfo->bInterlace = SC_R2BYTEMSK(REG_SC_BK33_1E_L, BIT(11)) >> 11;
1262 //pSrcInfo->bInterlace = (pSrcInfo->bInterlace || (SC_R2BYTEMSK(REG_SC_BK35_01_L, BIT(10)) >> 10));
1263
1264 if (IsSrcTypeVga(enInputSourceType))
1265 {
1266 SC_W2BYTEMSK(0, REG_SC_BK35_02_L, 0x311 , BITMASK(9:0) );
1267 }
1268 else
1269 {
1270 SC_W2BYTEMSK(0, REG_SC_BK35_02_L, 0x3BB , BITMASK(9:0) );
1271 }
1272 _XC_RETURN(pInstance);
1273 //printf("DI mode =%x, bitPerPixel=%d\n",pSrcInfo->eDeInterlaceMode, pSrcInfo->u8BitPerPixel);
1274 // Setup delay line
1275 MDrv_XC_DWIN_set_delayline( pInstance,pSrcInfo->u8DelayLines, eWindow ); // set delay line for trigger point, for 2DDI
1276
1277 }
1278
1279
1280
1281 //#define _NOP_(_loop) { volatile int i; for (i=0; i<(_loop); i++); }
1282
1283
_Mdrv_XC_DIP_CopySetWinInfo(void * pInstance,XC_SETWIN_INFO * pstXC_SetWin_Info,SCALER_DIP_WIN eWindow)1284 static MS_BOOL _Mdrv_XC_DIP_CopySetWinInfo(void* pInstance,XC_SETWIN_INFO *pstXC_SetWin_Info, SCALER_DIP_WIN eWindow)
1285 {
1286 #ifdef UTOPIA_V2
1287 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
1288 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
1289 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
1290 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
1291 #endif
1292 if(pstXC_SetWin_Info == NULL)
1293 {
1294 return FALSE;
1295 }
1296 g_DIPSrcInfo[eWindow].enInputSourceType = pstXC_SetWin_Info->enInputSourceType;
1297
1298 g_DIPSrcInfo[eWindow].stCapWin.x = pstXC_SetWin_Info->stCapWin.x;
1299 g_DIPSrcInfo[eWindow].stCapWin.y = pstXC_SetWin_Info->stCapWin.y;
1300 g_DIPSrcInfo[eWindow].stCapWin.width = pstXC_SetWin_Info->stCapWin.width;
1301 g_DIPSrcInfo[eWindow].stCapWin.height = pstXC_SetWin_Info->stCapWin.height;
1302
1303 g_DIPSrcInfo[eWindow].bInterlace = pstXC_SetWin_Info->bInterlace;
1304 g_DIPSrcInfo[eWindow].bHDuplicate = pstXC_SetWin_Info->bHDuplicate;
1305 g_DIPSrcInfo[eWindow].bHCusScaling = pstXC_SetWin_Info->bHCusScaling;
1306 g_DIPSrcInfo[eWindow].u16HCusScalingSrc = pstXC_SetWin_Info->u16HCusScalingSrc;
1307 g_DIPSrcInfo[eWindow].u16HCusScalingDst = pstXC_SetWin_Info->u16HCusScalingDst;
1308 g_DIPSrcInfo[eWindow].bVCusScaling = pstXC_SetWin_Info->bVCusScaling;
1309 g_DIPSrcInfo[eWindow].u16VCusScalingSrc = pstXC_SetWin_Info->u16VCusScalingSrc;
1310 g_DIPSrcInfo[eWindow].u16VCusScalingDst = pstXC_SetWin_Info->u16VCusScalingDst;
1311
1312 return TRUE;
1313 }
1314
1315 //=============== DIP =====================//
MDrv_XC_DIP_SetWindow(void * pInstance,XC_SETWIN_INFO * pstXC_SetWin_Info,MS_U32 u32InitDataLen,SCALER_DIP_WIN eWindow)1316 void MDrv_XC_DIP_SetWindow(void* pInstance,XC_SETWIN_INFO *pstXC_SetWin_Info, MS_U32 u32InitDataLen, SCALER_DIP_WIN eWindow)
1317 {
1318 #ifdef UTOPIA_V2
1319 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
1320 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
1321 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
1322 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
1323 #endif
1324 //MDrv_SC_SetPQHSDFlag(FALSE); //Reset variable
1325 // we've to support interface changed without re-compile user application
1326 // please specify new added interface default value here
1327
1328 HAL_XC_DIP_2P_Width_Check(pInstance, pstXC_SetWin_Info, eWindow);
1329
1330 #ifndef MSOS_TYPE_LINUX_KERNEL
1331 if(u32InitDataLen != sizeof(XC_SETWIN_INFO))
1332 {
1333 // customer application different version with our driver
1334 // start from customized pre H/V scaling
1335 g_DIPSrcInfo[eWindow].bPreHCusScaling = FALSE;
1336 g_DIPSrcInfo[eWindow].bPreVCusScaling = FALSE;
1337 }
1338 else
1339 #endif
1340 {
1341 g_DIPSrcInfo[eWindow].bPreHCusScaling = pstXC_SetWin_Info->bPreHCusScaling;
1342 g_DIPSrcInfo[eWindow].u16PreHCusScalingSrc = pstXC_SetWin_Info->u16PreHCusScalingSrc;
1343 g_DIPSrcInfo[eWindow].u16PreHCusScalingDst = pstXC_SetWin_Info->u16PreHCusScalingDst;
1344
1345 if(g_DIPSrcInfo[eWindow].u16PreHCusScalingDst > g_DIPSrcInfo[eWindow].u16PreHCusScalingSrc)
1346 {
1347 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"H can't do pre scaling up, change to auto prescaling\n");
1348 g_DIPSrcInfo[eWindow].bPreHCusScaling = FALSE;
1349 }
1350
1351 if (g_DIPSrcInfo[eWindow].bPreHCusScaling)
1352 {
1353 if (g_DIPSrcInfo[eWindow].u16PreHCusScalingSrc == 0 || g_DIPSrcInfo[eWindow].u16PreHCusScalingDst == 0)
1354 {
1355 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"PreHCus Src or Dst can not be 0 \n");
1356
1357 return;
1358 }
1359 }
1360
1361 g_DIPSrcInfo[eWindow].bPreVCusScaling = pstXC_SetWin_Info->bPreVCusScaling;
1362 g_DIPSrcInfo[eWindow].u16PreVCusScalingSrc = pstXC_SetWin_Info->u16PreVCusScalingSrc;
1363 g_DIPSrcInfo[eWindow].u16PreVCusScalingDst = pstXC_SetWin_Info->u16PreVCusScalingDst;
1364
1365 if(g_DIPSrcInfo[eWindow].u16PreVCusScalingDst > g_DIPSrcInfo[eWindow].u16PreVCusScalingSrc)
1366 {
1367 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"V can't do pre scaling up, change to auto prescaling\n");
1368 g_DIPSrcInfo[eWindow].bPreVCusScaling = FALSE;
1369 }
1370
1371 if (g_DIPSrcInfo[eWindow].bPreVCusScaling)
1372 {
1373 if (g_DIPSrcInfo[eWindow].u16PreVCusScalingSrc == 0 || g_DIPSrcInfo[eWindow].u16PreVCusScalingDst == 0 )
1374 {
1375 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"PreVCus Src or Dst can not be 0 \n");
1376
1377 return;
1378 }
1379 }
1380 }
1381
1382 // copy user data to internal data
1383 // here is a patch first, will remove after seperate Internal XC status with set window information
1384 //u32CopyLen = sizeof(XC_SETWIN_INFO) - (sizeof(MS_BOOL)*2) - (sizeof(MS_U16)*4);
1385 //memcpy(&g_DIPSrcInfo[eWindow], pstXC_SetWin_Info, u32CopyLen);
1386 //do not use this copy command, strongly depend on structure definition
1387 _Mdrv_XC_DIP_CopySetWinInfo(pInstance,pstXC_SetWin_Info, eWindow);
1388
1389 // assert check
1390 MS_ASSERT((g_DIPSrcInfo[eWindow].bHCusScaling==TRUE)?((g_DIPSrcInfo[eWindow].u16HCusScalingSrc!=0)&&(g_DIPSrcInfo[eWindow].u16HCusScalingDst!=0)):1);
1391 MS_ASSERT((g_DIPSrcInfo[eWindow].bVCusScaling==TRUE)?((g_DIPSrcInfo[eWindow].u16VCusScalingSrc!=0)&&(g_DIPSrcInfo[eWindow].u16VCusScalingDst!=0)):1);
1392 MS_ASSERT((g_DIPSrcInfo[eWindow].bPreHCusScaling==TRUE)?((g_DIPSrcInfo[eWindow].u16PreHCusScalingSrc!=0)&&(g_DIPSrcInfo[eWindow].u16PreHCusScalingDst!=0)):1);
1393 MS_ASSERT((g_DIPSrcInfo[eWindow].bPreVCusScaling==TRUE)?((g_DIPSrcInfo[eWindow].u16PreVCusScalingSrc!=0)&&(g_DIPSrcInfo[eWindow].u16PreVCusScalingDst!=0)):1);
1394
1395 // dump debug msg
1396 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"============= SetWindow Start (Window : %u, src: %u) =============\n",eWindow, g_DIPSrcInfo[eWindow].enInputSourceType);
1397 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"CapWin x: %4u y: %4u w: %4u h: %4u \n",g_DIPSrcInfo[eWindow].stCapWin.x, g_DIPSrcInfo[eWindow].stCapWin.y, g_DIPSrcInfo[eWindow].stCapWin.width, g_DIPSrcInfo[eWindow].stCapWin.height);
1398 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"H/V total = (%u, %u), VFreq = %u\n", pstXC_SetWin_Info->u16DefaultHtotal, pstXC_SetWin_Info->u16InputVTotal, pstXC_SetWin_Info->u16InputVFreq);
1399 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"Interlace/Hdup = %u/%u\n", pstXC_SetWin_Info->bInterlace, pstXC_SetWin_Info->bHDuplicate);
1400 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"Pre H cus scaling %u (%u -> %u)\n", g_DIPSrcInfo[eWindow].bPreHCusScaling, g_DIPSrcInfo[eWindow].u16PreHCusScalingSrc, g_DIPSrcInfo[eWindow].u16PreHCusScalingDst);
1401 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"Pre V cus scaling %u (%u -> %u)\n", g_DIPSrcInfo[eWindow].bPreVCusScaling, g_DIPSrcInfo[eWindow].u16PreVCusScalingSrc, g_DIPSrcInfo[eWindow].u16PreVCusScalingDst);
1402 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"Post H cus scaling %u (%u -> %u)\n", g_DIPSrcInfo[eWindow].bHCusScaling, g_DIPSrcInfo[eWindow].u16HCusScalingSrc, g_DIPSrcInfo[eWindow].u16HCusScalingDst);
1403 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"Post V cus scaling %u (%u -> %u)\n", g_DIPSrcInfo[eWindow].bVCusScaling, g_DIPSrcInfo[eWindow].u16VCusScalingSrc, g_DIPSrcInfo[eWindow].u16VCusScalingDst);
1404
1405 // Capture width & height can not be 0 !!
1406 if ((0 == g_DIPSrcInfo[eWindow].stCapWin.width) || (0 == g_DIPSrcInfo[eWindow].stCapWin.height))
1407 {
1408 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"Cap/Crop/Disp width or height can not be 0 \n");
1409
1410 return;
1411 }
1412
1413 //MDrv_XC_DWIN_SetMode(pInstance,g_DIPSrcInfo[eWindow].enInputSourceType, &g_DIPSrcInfo[eWindow], eWindow);
1414
1415 MDrv_XC_DWIN_set_prescaling_ratio(pInstance,g_DIPSrcInfo[eWindow].enInputSourceType, &g_DIPSrcInfo[eWindow], eWindow );
1416
1417 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"CapWin x: %4u y: %4u w: %4u h: %4u \n",g_DIPSrcInfo[eWindow].stCapWin.x, g_DIPSrcInfo[eWindow].stCapWin.y, g_DIPSrcInfo[eWindow].stCapWin.width, g_DIPSrcInfo[eWindow].stCapWin.height);
1418
1419 // FIXME: direct use variable instead of stDBreg?
1420
1421 MDrv_XC_DWIN_set_fetch_number_limit(pInstance,&g_DIPSrcInfo[eWindow], eWindow );
1422
1423 MDrv_XC_DWIN_set_capture_window(pInstance,eWindow );
1424
1425 MDrv_XC_DWIN_sw_db(pInstance,&stDIP_DBreg[eWindow], eWindow );
1426
1427 XC_LOG_TRACE(XC_DBGLEVEL_DWIN_SETWINDOW,"============= SetWindow Done (Window : %u, src: %u) =============\n",eWindow, g_DIPSrcInfo[eWindow].enInputSourceType);
1428
1429
1430 }
MDrv_XC_DIP_SetFRC(void * pInstance,MS_BOOL bEnable,MS_U16 u16In,MS_U16 u16Out,SCALER_DIP_WIN eWindow)1431 void MDrv_XC_DIP_SetFRC(void* pInstance,MS_BOOL bEnable,MS_U16 u16In,MS_U16 u16Out,SCALER_DIP_WIN eWindow)
1432 {
1433 _XC_ENTRY(pInstance);
1434 HAL_XC_DIP_SetFRC(pInstance, bEnable,u16In,u16Out,eWindow);
1435 _XC_RETURN(pInstance);
1436 }
MDrv_XC_DIP_EnableCaptureStream(void * pInstance,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1437 void MDrv_XC_DIP_EnableCaptureStream(void* pInstance,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)
1438 {
1439 _XC_ENTRY(pInstance);
1440 if(bEnable)
1441 {
1442 HAL_XC_DIP_SWReset(pInstance, eWindow);//Reset HW before DIP enable to avoid garbage
1443 HAL_XC_DIP_EnableCaptureStream(pInstance, bEnable,eWindow);
1444 }
1445 else
1446 {
1447 MS_U16 u16IntrStus = 0;
1448 HAL_XC_DIP_EnableCaptureStream(pInstance, bEnable,eWindow);
1449 //Auto clear status to zero
1450 u16IntrStus = HAL_XC_DIP_GetIntrStatus(pInstance, eWindow);
1451 HAL_XC_DIP_ClearIntr(pInstance, u16IntrStus,eWindow);
1452 HAL_XC_DIP_SWReset(pInstance, eWindow);//Reset after disable dip to avoid get old temproary info
1453 }
1454 _XC_RETURN(pInstance);
1455 }
1456 #define XC_DIP_CAP_TIMEOUT_CNT 100
MDrv_XC_DIP_CaptureOneFrame(void * pInstance,SCALER_DIP_WIN eWindow)1457 void MDrv_XC_DIP_CaptureOneFrame(void* pInstance,SCALER_DIP_WIN eWindow)
1458 {
1459 MS_U16 regval = 0;
1460 MS_U16 u16Count = 0;
1461 //_XC_ENTRY(pInstance);
1462 HAL_XC_DIP_SWReset(pInstance, eWindow);//Reset HW before DIP enable to avoid garbage
1463 HAL_XC_DIP_CpatureOneFrame2(pInstance, eWindow);
1464 //_XC_RETURN(pInstance);
1465 do{
1466 regval = HAL_XC_DIP_GetIntrStatus(pInstance, eWindow);
1467 if(regval > 0x0)
1468 break;
1469 u16Count++;
1470 MsOS_DelayTask(1);
1471 }while(u16Count < XC_DIP_CAP_TIMEOUT_CNT);
1472 }
MDrv_XC_DIP_CaptureOneFrame2(void * pInstance,SCALER_DIP_WIN eWindow)1473 void MDrv_XC_DIP_CaptureOneFrame2(void* pInstance,SCALER_DIP_WIN eWindow)
1474 {
1475 //_XC_ENTRY(pInstance);
1476 HAL_XC_DIP_SWReset(pInstance, eWindow);//Reset HW before DIP enable to avoid garbage
1477 HAL_XC_DIP_CpatureOneFrame2(pInstance, eWindow);
1478 //_XC_RETURN(pInstance);
1479 }
MDrv_XC_DIP_SetWinProperty(void * pInstance,ST_XC_DIP_WINPROPERTY * pstDIPWinProperty,SCALER_DIP_WIN eWindow)1480 void MDrv_XC_DIP_SetWinProperty(void* pInstance,ST_XC_DIP_WINPROPERTY *pstDIPWinProperty, SCALER_DIP_WIN eWindow)
1481
1482 {
1483 MS_U8 i=0,u8MIUSel=0,u8IsIntlacW=0, u8BufCnt=0;
1484 MS_U16 u16Width=0,u16LineOft=0, u16Height=0, u16Bpp=0,u16NewWidth=0,u16NewLineOft=0,u16NewHeight=0;
1485 MS_PHY u64BufEnd=0, u64BufStart=0, u64TotalLen=0,u64YLen=0,u64CLen=0,u64Offset=0;
1486 MS_PHY u64_result = 0;
1487 EN_DRV_XC_DWIN_DATA_FMT fmt=XC_DWIN_DATA_FMT_MAX;
1488 EN_XC_DWIN_SCAN_TYPE enScan=GOPDWIN_SCAN_MODE_MAX;
1489 SCALER_DIP_SOURCE_TYPE enSource=MAX_SCALER_DIP_SOURCE_NUM;
1490 MS_BOOL bPIP = FALSE;
1491 MS_BOOL b2P_Enable =FALSE;
1492 #ifdef UTOPIA_V2
1493 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
1494 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
1495 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
1496 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
1497 #endif
1498 if(pstDIPWinProperty != NULL)
1499 {
1500 g_DIPSrcInfo[eWindow].enDIPSourceType = pstDIPWinProperty->enSource;
1501 }
1502
1503 //check bucnt
1504 if( (pstDIPWinProperty == NULL)
1505 ||(pstDIPWinProperty->u8BufCnt > MAX_BUFF_CNT)
1506 ||(pstDIPWinProperty->u32BufEnd == pstDIPWinProperty->u32BufStart)
1507 ||(pstDIPWinProperty->u16Width == 0)
1508 ||(pstDIPWinProperty->u16Height== 0))
1509 {
1510 DIP_D_ERR("[%s:%d] Clear Buffer info\n",__FUNCTION__,__LINE__);
1511 memset(&g_DIPSrcInfo[eWindow].stBufInfo, 0, sizeof(XC_DIP_BUFFER_INFO));
1512 return;
1513 }
1514
1515 //width alignment check
1516 fmt = HAL_XC_DIP_GetDataFmt(pInstance, eWindow);
1517 if(fmt == XC_DWIN_DATA_FMT_MAX)
1518 {
1519 return;
1520 }
1521
1522 u8BufCnt = pstDIPWinProperty->u8BufCnt;
1523 u16Width = pstDIPWinProperty->u16Width;
1524 u16Height = pstDIPWinProperty->u16Height;
1525 u64BufStart= pstDIPWinProperty->u32BufStart;
1526 u64BufEnd = pstDIPWinProperty->u32BufEnd;
1527 enSource = pstDIPWinProperty->enSource;
1528
1529 u16Bpp = HAL_XC_DIP_GetBPP(pInstance, fmt,eWindow);
1530 if( pstDIPWinProperty->u16Pitch == 0 )
1531 {
1532 u16LineOft = u16Width;
1533 }
1534 else
1535 {
1536 //if( (fmt == XC_DWIN_DATA_FMT_YUV420) || (fmt == XC_DWIN_DATA_FMT_YUV420_H265)|| (fmt == XC_DWIN_DATA_FMT_YUV420_H265_10BITS)|| (fmt == XC_DWIN_DATA_FMT_YUV420_PLANER)|| (fmt == XC_DWIN_DATA_FMT_YUV420_SEMI_PLANER))
1537 //{
1538 // u64_result = (MS_PHY)(pstDIPWinProperty->u16Pitch*2);
1539 // do_div(u64_result,3);
1540 // u16LineOft = u64_result;
1541 //}
1542 //else
1543 {
1544 u64_result = (MS_PHY)(pstDIPWinProperty->u16Pitch);
1545 do_div(u64_result,u16Bpp);
1546 u16LineOft = u64_result;
1547 }
1548
1549 if(u16LineOft < u16Width)
1550 {
1551 DIP_D_ERR("[%s:%d] Pitch is not correct\n",__FUNCTION__,__LINE__);
1552 return;
1553 }
1554 }
1555
1556 if( (fmt == XC_DWIN_DATA_FMT_YUV420) || (fmt == XC_DWIN_DATA_FMT_YUV420_H265) || (fmt == XC_DWIN_DATA_FMT_YUV420_H265_10BITS))
1557 {
1558 u16NewWidth = ALIGN_CHECK(u16Width,DIP_HVD_TILE_BLOCK_H);
1559 u16NewLineOft = ALIGN_CHECK(u16LineOft,DIP_HVD_TILE_BLOCK_H);
1560 }
1561 else
1562 {
1563 u64_result = HAL_XC_DIP_GetBusSize(pInstance, eWindow);
1564 do_div(u64_result,u16Bpp);
1565 u16NewWidth = ALIGN_CHECK(u16Width,u64_result);
1566 u16NewLineOft = ALIGN_CHECK(u16LineOft,u64_result);
1567 }
1568 //if is interlace mode
1569 enScan = HAL_XC_DIP_GetSourceScanType(pInstance, eWindow);
1570 if(enScan == GOPDWIN_SCAN_MODE_MAX)
1571 return;
1572 if(enScan == GOPDWIN_SCAN_MODE_INTERLACE)
1573 {
1574 u64_result = u16Height;
1575 do_div(u64_result,2);
1576 u16NewHeight = u64_result;
1577 }
1578 else
1579 u16NewHeight = u16Height;
1580
1581 //buffer size check
1582 // offset unit : pixel
1583 if( (fmt == XC_DWIN_DATA_FMT_YUV420) || (fmt == XC_DWIN_DATA_FMT_YUV420_H265) || (fmt == XC_DWIN_DATA_FMT_YUV420_H265_10BITS) || (fmt == XC_DWIN_DATA_FMT_YUV420_PLANER) || (fmt == XC_DWIN_DATA_FMT_YUV420_SEMI_PLANER))
1584 {
1585 if( (fmt == XC_DWIN_DATA_FMT_YUV420) || (fmt == XC_DWIN_DATA_FMT_YUV420_H265) || (fmt == XC_DWIN_DATA_FMT_YUV420_H265_10BITS))
1586 {
1587 //Tile Y block is 16X32
1588 u64YLen = u16NewLineOft*ALIGN_CHECK(u16NewHeight,DIP_HVD_TILE_BLOCK_V);
1589 //Tile C block is 16X64
1590 u64_result = u16NewLineOft*ALIGN_CHECK(u16NewHeight,DIP_HVD_TILE_BLOCK_V*2);
1591 do_div(u64_result,2);
1592 u64CLen = u64_result;
1593 }
1594 else
1595 {
1596 u64YLen = (MS_PHY)u16NewLineOft*u16NewHeight;
1597 u64_result = (MS_PHY)u16NewLineOft*u16NewHeight;
1598 do_div(u64_result,2);
1599 u64CLen = u64_result;
1600 }
1601 u64Offset = u64YLen+u64CLen;
1602 if(u8BufCnt == AUTO_BUFF_CNT)
1603 {
1604 u64_result = u64BufEnd - u64BufStart;
1605 do_div(u64_result,(u64Offset*u16Bpp));
1606 //u8BufCnt = (u64BufEnd - u64BufStart)/(u64Offset*u16Bpp);
1607 u8BufCnt = u64_result;
1608 u64TotalLen = u8BufCnt*u64Offset*u16Bpp;
1609 }
1610 else
1611 {
1612 u64TotalLen = u8BufCnt*u64Offset*u16Bpp;
1613 }
1614 for(i=0;i<u8BufCnt;i++)
1615 {
1616 g_DIPSrcInfo[eWindow].stBufInfo.u64DIP_YBuf[i] = u64BufStart+u64Offset*i;
1617 g_DIPSrcInfo[eWindow].stBufInfo.u64DIP_CBuf[i] = u64BufStart+u64YLen+u64Offset*i;
1618 }
1619 }
1620 else
1621 {
1622 u64Offset = (MS_PHY)u16NewLineOft*u16NewHeight;
1623 if(u8BufCnt == AUTO_BUFF_CNT)
1624 {
1625 u64_result = u64BufEnd - u64BufStart;
1626 do_div(u64_result,(u64Offset*u16Bpp));
1627 //u8BufCnt = (u64BufEnd - u64BufStart)/(u64Offset*u16Bpp);
1628 u8BufCnt = u64_result;
1629 u64TotalLen = u8BufCnt*u64Offset*u16Bpp;
1630 }
1631 else
1632 {
1633 u64TotalLen = u8BufCnt*u64Offset*u16Bpp;
1634 }
1635 for(i=0;i<u8BufCnt;i++)
1636 {
1637 g_DIPSrcInfo[eWindow].stBufInfo.u64DIP_YBuf[i] = u64BufStart+u64Offset*i*u16Bpp;
1638 if( (fmt == XC_DWIN_DATA_FMT_YC422) )
1639 g_DIPSrcInfo[eWindow].stBufInfo.u64DIP_CBuf[i] = u64BufStart+u64Offset*(i*u16Bpp+1);
1640 }
1641 }
1642 g_DIPSrcInfo[eWindow].stBufInfo.u8DIP_BufCnt = u8BufCnt;
1643 //if is deinterlace mode
1644 u8IsIntlacW = HAL_XC_DIP_GetInterlaceWrite(pInstance, eWindow);
1645 if(u8IsIntlacW)
1646 {
1647 u64TotalLen *=2;
1648 u64Offset *=2;
1649 }
1650 if( u64TotalLen > (u64BufEnd - u64BufStart))
1651 {
1652 u64BufEnd = u64TotalLen + u64BufStart;
1653 #if defined (__aarch64__)
1654 DIP_D_DBUG("[%s:%d] Buffer size is not correct,need = %lx\n",__FUNCTION__,__LINE__,u64TotalLen);
1655 #else
1656 DIP_D_DBUG("[%s:%d] Buffer size is not correct,need = %tx\n",__FUNCTION__,__LINE__,(ptrdiff_t)u64TotalLen);
1657 #endif
1658 }
1659
1660 _phy_to_miu_offset(u8MIUSel, u64BufStart, u64BufStart);
1661 _phy_to_miu_offset(u8MIUSel, u64BufEnd, u64BufEnd);
1662
1663 b2P_Enable = MApi_XC_GetDynamicScalingStatus();
1664 _XC_ENTRY(pInstance);
1665 HAL_XC_DIP_SetMiuSel(pInstance, u8MIUSel,eWindow);
1666 HAL_XC_DIP_SetBase0(pInstance, u64BufStart,u64BufEnd,eWindow);
1667
1668 //check if is Sub PIP or POP
1669 if(enSource == SCALER_DIP_SOURCE_TYPE_OP_SUB)
1670 {
1671 MS_WINDOW_TYPE stDisp[MAX_WINDOW];
1672
1673 MDrv_XC_get_dispwin_from_reg(pInstance, MAIN_WINDOW, &stDisp[MAIN_WINDOW]);
1674 MDrv_XC_get_dispwin_from_reg(pInstance, SUB_WINDOW, &stDisp[SUB_WINDOW]);
1675
1676 if ( ((stDisp[MAIN_WINDOW].x + stDisp[MAIN_WINDOW].width) >= (stDisp[SUB_WINDOW].x + stDisp[SUB_WINDOW].width)) && (stDisp[MAIN_WINDOW].x <= stDisp[SUB_WINDOW].x) )
1677 {
1678 bPIP = TRUE;
1679 }
1680
1681 }
1682
1683 //set clock and mux
1684 HAL_XC_DIP_MuxDispatch(pInstance, enSource,eWindow);
1685
1686 //set win property
1687 HAL_XC_DIP_SetWinProperty(pInstance, u8BufCnt,u16NewWidth,u16NewLineOft,u16NewHeight,u64Offset,enSource,bPIP,b2P_Enable, eWindow);
1688 if( (fmt == XC_DWIN_DATA_FMT_YUV420) || (fmt == XC_DWIN_DATA_FMT_YUV420_H265) || (fmt == XC_DWIN_DATA_FMT_YUV420_H265_10BITS) || (fmt == XC_DWIN_DATA_FMT_YUV420_PLANER) || (fmt == XC_DWIN_DATA_FMT_YUV420_SEMI_PLANER) )
1689 {
1690 HAL_XC_DIP_SetBase1(pInstance, u64BufStart+u64YLen,u64BufEnd,eWindow);
1691 HAL_XC_DIP_SetWinProperty1(pInstance, u64Offset,eWindow);
1692 }
1693 else if( (fmt == XC_DWIN_DATA_FMT_YC422) )
1694 {
1695 HAL_XC_DIP_SetBase1(pInstance, u64BufStart+u64Offset,u64BufEnd,eWindow);
1696 HAL_XC_DIP_SetWinProperty1(pInstance, u64Offset,eWindow);
1697 }
1698
1699 _XC_RETURN(pInstance);
1700
1701 }
MDrv_XC_DIP_GetBufferInfo(void * pInstance,SCALER_DIP_WIN eWindow)1702 BUFFER_INFO MDrv_XC_DIP_GetBufferInfo(void* pInstance,SCALER_DIP_WIN eWindow)
1703 {
1704 MS_U8 i;
1705 BUFFER_INFO BufInfo;
1706 #ifdef UTOPIA_V2
1707 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
1708 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
1709 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
1710 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
1711 #endif
1712 BufInfo.u8BufCnt = g_DIPSrcInfo[eWindow].stBufInfo.u8DIP_BufCnt;
1713 for(i =0;i<BufInfo.u8BufCnt;i++)
1714 {
1715 BufInfo.u32YBuf[i] = g_DIPSrcInfo[eWindow].stBufInfo.u64DIP_YBuf[i];
1716 BufInfo.u32CBuf[i] = g_DIPSrcInfo[eWindow].stBufInfo.u64DIP_CBuf[i];
1717 }
1718 return BufInfo;
1719 }
MDrv_XC_DIP_GetIntrStatus(void * pInstance,SCALER_DIP_WIN eWindow)1720 MS_U16 MDrv_XC_DIP_GetIntrStatus(void* pInstance,SCALER_DIP_WIN eWindow)
1721 {
1722 MS_U16 regval =0;
1723 regval = HAL_XC_DIP_GetIntrStatus(pInstance, eWindow);
1724 return regval;
1725 }
MDrv_XC_DIP_SelectSourceScanType(void * pInstance,EN_XC_DWIN_SCAN_TYPE enScan,SCALER_DIP_WIN eWindow)1726 void MDrv_XC_DIP_SelectSourceScanType(void* pInstance,EN_XC_DWIN_SCAN_TYPE enScan,SCALER_DIP_WIN eWindow)
1727 {
1728 _XC_ENTRY(pInstance);
1729 HAL_XC_DIP_SelectSourceScanType(pInstance, enScan,eWindow);
1730 _XC_RETURN(pInstance);
1731 }
MDrv_XC_DIP_SetInterlaceWrite(void * pInstance,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1732 void MDrv_XC_DIP_SetInterlaceWrite(void* pInstance,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)
1733 {
1734 _XC_ENTRY(pInstance);
1735 HAL_XC_DIP_SetInterlaceWrite(pInstance, bEnable,eWindow);
1736 _XC_RETURN(pInstance);
1737 }
MDrv_XC_DIP_SetY2R(void * pInstance,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1738 void MDrv_XC_DIP_SetY2R(void* pInstance,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)
1739 {
1740 _XC_ENTRY(pInstance);
1741 HAL_XC_DIP_SetY2R(pInstance, bEnable,eWindow);
1742 _XC_RETURN(pInstance);
1743 }
MDrv_XC_DIP_SetDataFmt(void * pInstance,EN_DRV_XC_DWIN_DATA_FMT fmt,SCALER_DIP_WIN eWindow)1744 void MDrv_XC_DIP_SetDataFmt(void* pInstance,EN_DRV_XC_DWIN_DATA_FMT fmt,SCALER_DIP_WIN eWindow)
1745 {
1746 _XC_ENTRY(pInstance);
1747 HAL_XC_DIP_SetDataFmt(pInstance, fmt,eWindow);
1748 _XC_RETURN(pInstance);
1749 }
MDrv_XC_DIP_SetAlphaValue(void * pInstance,MS_U8 u8AlphaVal,SCALER_DIP_WIN eWindow)1750 void MDrv_XC_DIP_SetAlphaValue(void* pInstance,MS_U8 u8AlphaVal,SCALER_DIP_WIN eWindow)
1751 {
1752 _XC_ENTRY(pInstance);
1753 HAL_XC_DIP_SetAlphaValue(pInstance, u8AlphaVal,eWindow);
1754 _XC_RETURN(pInstance);
1755 }
MDrv_XC_DIP_SetUVSwap(void * pInstance,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1756 void MDrv_XC_DIP_SetUVSwap(void* pInstance,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)
1757 {
1758 _XC_ENTRY(pInstance);
1759 HAL_XC_DIP_SetUVSwap(pInstance, bEnable,eWindow);
1760 _XC_RETURN(pInstance);
1761 }
MDrv_XC_DIP_SetYCSwap(void * pInstance,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1762 void MDrv_XC_DIP_SetYCSwap(void* pInstance,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)
1763 {
1764 _XC_ENTRY(pInstance);
1765 HAL_XC_DIP_SetYCSwap(pInstance, bEnable,eWindow);
1766 _XC_RETURN(pInstance);
1767 }
MDrv_XC_DIP_SetRGBSwap(void * pInstance,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1768 void MDrv_XC_DIP_SetRGBSwap(void* pInstance,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)
1769 {
1770 _XC_ENTRY(pInstance);
1771 HAL_XC_DIP_SetRGBSwap(pInstance, bEnable,eWindow);
1772 _XC_RETURN(pInstance);
1773 }
MDrv_XC_DIP_EnableIntr(void * pInstance,MS_U16 u8mask,MS_BOOL bEnable,SCALER_DIP_WIN eWindow)1774 void MDrv_XC_DIP_EnableIntr(void* pInstance,MS_U16 u8mask, MS_BOOL bEnable,SCALER_DIP_WIN eWindow)
1775 {
1776 _XC_ENTRY(pInstance);
1777 HAL_XC_DIP_EnableIntr(pInstance, u8mask, bEnable,eWindow);
1778 _XC_RETURN(pInstance);
1779 }
MDrv_XC_DIP_ClearIntr(void * pInstance,MS_U16 u16mask,SCALER_DIP_WIN eWindow)1780 void MDrv_XC_DIP_ClearIntr(void* pInstance,MS_U16 u16mask,SCALER_DIP_WIN eWindow)
1781 {
1782 HAL_XC_DIP_ClearIntr(pInstance, u16mask,eWindow);
1783 }
MDrv_XC_DIP_SetOutputCapture(void * pInstance,MS_BOOL bEnable,EN_XC_DIP_OP_CAPTURE eOpCapture,SCALER_DIP_WIN eWindow)1784 void MDrv_XC_DIP_SetOutputCapture(void* pInstance,MS_BOOL bEnable,EN_XC_DIP_OP_CAPTURE eOpCapture,SCALER_DIP_WIN eWindow)
1785 {
1786 _XC_ENTRY(pInstance);
1787 HAL_XC_DIP_SetOutputCapture(pInstance, bEnable,eOpCapture,eWindow);
1788 _XC_RETURN(pInstance);
1789 }
MDrv_XC_DIP_SetMirror(void * pInstance,MS_BOOL bHMirror,MS_BOOL bVMirror,SCALER_DIP_WIN eWindow)1790 void MDrv_XC_DIP_SetMirror(void* pInstance,MS_BOOL bHMirror,MS_BOOL bVMirror,SCALER_DIP_WIN eWindow)
1791 {
1792 _XC_ENTRY(pInstance);
1793 HAL_XC_DIP_SetMirror(pInstance, bHMirror,bVMirror,eWindow);
1794 _XC_RETURN(pInstance);
1795 }
MDrv_XC_DIP_SetDIPRProperty(void * pInstance,ST_XC_DIPR_PROPERTY * pstDIPRProperty,SCALER_DIP_WIN eWindow)1796 void MDrv_XC_DIP_SetDIPRProperty(void* pInstance,ST_XC_DIPR_PROPERTY *pstDIPRProperty, SCALER_DIP_WIN eWindow)
1797 {
1798 MS_U8 u8MIUSel = 0,u8MIUSelTMP = 0;
1799 MS_U16 u16Bpp = 0,u16Width = 0,u16LineOft = 0;
1800 EN_DRV_XC_DWIN_DATA_FMT fmt = 0;
1801 MS_U64 u64_result = 0;
1802
1803 _XC_ENTRY(pInstance);
1804 //Transfer pitch to lineoffset
1805 u16Bpp = HAL_XC_DIP_GetBPP(pInstance, (EN_DRV_XC_DWIN_DATA_FMT)(pstDIPRProperty->enDataFmt),eWindow);
1806 if( pstDIPRProperty->u16Pitch == 0 )
1807 {
1808 u16LineOft = u16Width;
1809 }
1810 else
1811 {
1812 fmt = (EN_DRV_XC_DWIN_DATA_FMT)(pstDIPRProperty->enDataFmt);
1813 //if( (fmt == XC_DWIN_DATA_FMT_YUV420) || (fmt == XC_DWIN_DATA_FMT_YUV420_H265) || (fmt == XC_DWIN_DATA_FMT_YUV420_H265_10BITS))
1814 //{
1815 // u64_result = (MS_PHY)(pstDIPRProperty->u16Pitch*2);
1816 // do_div(u64_result,3);
1817 // u16LineOft = u64_result;
1818 //}
1819 //else
1820 {
1821 u64_result = (MS_PHY)(pstDIPRProperty->u16Pitch);
1822 do_div(u64_result,u16Bpp);
1823 u16LineOft = u64_result;
1824 }
1825
1826 if(u16LineOft < u16Width)
1827 {
1828 DIP_D_ERR("[%s:%d] Pitch is not correct\n",__FUNCTION__,__LINE__);
1829 return;
1830 }
1831 }
1832 pstDIPRProperty->u16Pitch = u16LineOft;
1833
1834 //DIPr = DIPw MIU selection, so change DIPW MIU selection
1835 _phy_to_miu_offset(u8MIUSel, pstDIPRProperty->u32YBufAddr, pstDIPRProperty->u32YBufAddr);
1836 _phy_to_miu_offset(u8MIUSelTMP, pstDIPRProperty->u32CBufAddr, pstDIPRProperty->u32CBufAddr);
1837 _phy_to_miu_offset(u8MIUSelTMP, pstDIPRProperty->u32YBufAddr10Bits, pstDIPRProperty->u32YBufAddr10Bits);
1838 _phy_to_miu_offset(u8MIUSelTMP, pstDIPRProperty->u32CBufAddr10Bits, pstDIPRProperty->u32CBufAddr10Bits);
1839 HAL_XC_DIP_SetDIPRMiuSel(pInstance, u8MIUSel,eWindow);
1840 HAL_XC_DIP_SetDIPRProperty(pInstance, pstDIPRProperty,eWindow);
1841 _XC_RETURN(pInstance);
1842 }
1843
MDrv_XC_DIP_SetDIPRProperty_EX(void * pInstance,ST_XC_DIPR_PROPERTY_EX * pstDIPRProperty_ex,SCALER_DIP_WIN eWindow)1844 void MDrv_XC_DIP_SetDIPRProperty_EX(void* pInstance,ST_XC_DIPR_PROPERTY_EX *pstDIPRProperty_ex, SCALER_DIP_WIN eWindow)
1845 {
1846 MS_U8 u8MIUSel = 0,u8MIUSelTMP = 0;
1847 MS_U16 u16Bpp = 0,u16Width = 0,u16LineOft = 0;
1848 EN_DRV_XC_DWIN_DATA_FMT enfmt = 0;
1849 MS_U64 u64_result = 0;
1850
1851 _XC_ENTRY(pInstance);
1852 //Transfer pitch to lineoffset
1853 u16Bpp = HAL_XC_DIP_GetBPP(pInstance, (EN_DRV_XC_DWIN_DATA_FMT)(pstDIPRProperty_ex->stDIPRProperty.enDataFmt),eWindow);
1854 if( pstDIPRProperty_ex->stDIPRProperty.u16Pitch == 0 )
1855 {
1856 u16LineOft = u16Width;
1857 }
1858 else
1859 {
1860 enfmt = (EN_DRV_XC_DWIN_DATA_FMT)(pstDIPRProperty_ex->stDIPRProperty.enDataFmt);
1861 //if( (enfmt == XC_DWIN_DATA_FMT_YUV420) || (enfmt == XC_DWIN_DATA_FMT_YUV420_H265) || (enfmt == XC_DWIN_DATA_FMT_YUV420_H265_10BITS))
1862 //{
1863 // u64_result = (pstDIPRProperty_ex->stDIPRProperty.u16Pitch*2);
1864 // do_div(u64_result,3);
1865 // u16LineOft = u64_result;
1866 //}
1867 //else
1868 {
1869 u64_result = (pstDIPRProperty_ex->stDIPRProperty.u16Pitch);
1870 do_div(u64_result,u16Bpp);
1871 u16LineOft = u64_result;
1872 }
1873
1874 if(u16LineOft < u16Width)
1875 {
1876 DIP_D_ERR("[%s:%d] Pitch is not correct\n",__FUNCTION__,__LINE__);
1877 return;
1878 }
1879 }
1880 pstDIPRProperty_ex->stDIPRProperty.u16Pitch = u16LineOft;
1881
1882 //DIPr = DIPw MIU selection, so change DIPW MIU selection
1883 _phy_to_miu_offset(u8MIUSel, pstDIPRProperty_ex->stDIPRProperty.u32YBufAddr, pstDIPRProperty_ex->stDIPRProperty.u32YBufAddr);
1884 _phy_to_miu_offset(u8MIUSelTMP, pstDIPRProperty_ex->stDIPRProperty.u32CBufAddr, pstDIPRProperty_ex->stDIPRProperty.u32CBufAddr);
1885 _phy_to_miu_offset(u8MIUSelTMP, pstDIPRProperty_ex->stDIPRProperty.u32YBufAddr10Bits, pstDIPRProperty_ex->stDIPRProperty.u32YBufAddr10Bits);
1886 _phy_to_miu_offset(u8MIUSelTMP, pstDIPRProperty_ex->stDIPRProperty.u32CBufAddr10Bits, pstDIPRProperty_ex->stDIPRProperty.u32CBufAddr10Bits);
1887 HAL_XC_DIP_SetDIPRMiuSel(pInstance, u8MIUSel,eWindow);
1888 HAL_XC_DIP_SetDIPRProperty(pInstance, &pstDIPRProperty_ex->stDIPRProperty,eWindow);
1889 HAL_XC_DIP_SetDIPRProperty_MFDEC(pInstance, pstDIPRProperty_ex->stDIPR_MFDecInfo,eWindow);
1890 HAL_XC_DIP_SetDIPRProperty_DI(pInstance, &pstDIPRProperty_ex->stDIPRProperty, &pstDIPRProperty_ex->stDIPR3DDISetting,eWindow);
1891 _XC_RETURN(pInstance);
1892 }
1893
MDrv_XC_DIP_SetRotation(void * pInstance,MS_BOOL bRotation,EN_XC_DIP_ROTATION eRoDirection,SCALER_DIP_WIN eTmpWindow)1894 void MDrv_XC_DIP_SetRotation(void* pInstance,MS_BOOL bRotation,EN_XC_DIP_ROTATION eRoDirection,SCALER_DIP_WIN eTmpWindow)
1895 {
1896 #ifdef UTOPIA_V2
1897 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
1898 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
1899 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
1900 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
1901 #endif
1902 _XC_ENTRY(pInstance);
1903 HAL_XC_DIP_Rotation(pInstance, bRotation,eRoDirection,g_DIPSrcInfo[eTmpWindow].stBufInfo.u64DIP_YBuf[0],eTmpWindow);
1904 _XC_RETURN(pInstance);
1905 }
1906
MDrv_XC_DIP_SetHVSP(void * pInstance,MS_BOOL bSelect,SCALER_DIP_WIN eWindow)1907 MS_BOOL MDrv_XC_DIP_SetHVSP(void* pInstance,MS_BOOL bSelect, SCALER_DIP_WIN eWindow)
1908 {
1909 #ifdef UTOPIA_V2
1910 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
1911 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
1912 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
1913 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
1914 #endif
1915 MS_BOOL bResource = FALSE;
1916
1917 _XC_ENTRY(pInstance);
1918 bResource = HAL_XC_DIP_SetHVSP(pInstance,bSelect,eWindow);
1919 _XC_RETURN(pInstance);
1920
1921 return bResource;
1922 }
1923
MDrv_XC_DIP_Set420TileBlock(void * pInstance,EN_XC_DIP_TILE_BLOCK eTileBlock,SCALER_DIP_WIN eWindow)1924 MS_BOOL MDrv_XC_DIP_Set420TileBlock(void* pInstance,EN_XC_DIP_TILE_BLOCK eTileBlock,SCALER_DIP_WIN eWindow)
1925 {
1926 #ifdef UTOPIA_V2
1927 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
1928 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
1929 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
1930 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
1931 #endif
1932 MS_BOOL bSupport = FALSE;
1933
1934 _XC_ENTRY(pInstance);
1935 bSupport = HAL_XC_DIP_Set420TileBlock(pInstance,eTileBlock,eWindow);
1936 _XC_RETURN(pInstance);
1937
1938 return bSupport;
1939 }
1940
MDrv_XC_DIP_SetPinpon(void * pInstance,MS_BOOL bPinpon,MS_PHY u64PinponAddr,SCALER_DIP_WIN eWindow)1941 void MDrv_XC_DIP_SetPinpon(void* pInstance,MS_BOOL bPinpon,MS_PHY u64PinponAddr,SCALER_DIP_WIN eWindow)
1942 {
1943 #ifdef UTOPIA_V2
1944 DIP_INSTANCE_PRIVATE* pDipPri = NULL;
1945 DIP_SHARE_RESOURCE_PRIVATE* pDipResPri = NULL;
1946 UtopiaInstanceGetPrivate(pInstance, (void*)&pDipPri);
1947 UtopiaResourceGetPrivate(pDipPri->pShareResource,(void*)&(pDipResPri));
1948 #endif
1949 MS_PHY u64_result;
1950 _XC_ENTRY(pInstance);
1951 if(bPinpon == TRUE)
1952 {
1953 MS_U16 u16Bpp = 0;
1954 EN_DRV_XC_DWIN_DATA_FMT fmt;
1955 fmt = HAL_XC_DIP_GetDataFmt(pInstance, eWindow);
1956 u16Bpp = HAL_XC_DIP_GetBPP(pInstance, fmt,eWindow);
1957 u64_result = u64PinponAddr - g_DIPSrcInfo[eWindow].stBufInfo.u64DIP_YBuf[0];
1958 do_div(u64_result,u16Bpp);
1959 //HAL_XC_DIP_SetPinpon(pInstance, bPinpon,u64PinponAddr,(u64PinponAddr - g_DIPSrcInfo[eWindow].stBufInfo.u64DIP_YBuf[0])/u16Bpp,eWindow);
1960 HAL_XC_DIP_SetPinpon(pInstance, bPinpon,u64PinponAddr,u64_result,eWindow);
1961 }
1962 else
1963 {
1964 HAL_XC_DIP_SWReset(pInstance, eWindow);
1965 }
1966 _XC_RETURN(pInstance);
1967 }
1968
MDrv_XC_DIP_InterruptAttach(void * pInstance,InterruptCb pIntCb,SCALER_DIP_WIN eWindow)1969 void MDrv_XC_DIP_InterruptAttach(void* pInstance,InterruptCb pIntCb,SCALER_DIP_WIN eWindow)
1970 {
1971 _XC_ENTRY(pInstance);
1972 HAL_XC_DIP_InterruptAttach(pInstance, pIntCb,eWindow);
1973 _XC_RETURN(pInstance);
1974 }
MDrv_XC_DIP_InterruptDetach(void * pInstance,SCALER_DIP_WIN eWindow)1975 void MDrv_XC_DIP_InterruptDetach(void* pInstance,SCALER_DIP_WIN eWindow)
1976 {
1977 _XC_ENTRY(pInstance);
1978 HAL_XC_DIP_InterruptDetach(pInstance, eWindow);
1979 _XC_RETURN(pInstance);
1980 }
1981
MDrv_XC_DIP_SetBdgLevel(EN_XC_DIP_DEBUG_LEVEL level)1982 void MDrv_XC_DIP_SetBdgLevel(EN_XC_DIP_DEBUG_LEVEL level)
1983 {
1984 u32DIPDbgLevel_drv = level;
1985 }
1986
1987 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
MDrv_XC_DIP_Read_Info(MS_U64 * u64ReqHdl,SCALER_DIP_WIN eWindow)1988 static void MDrv_XC_DIP_Read_Info(MS_U64* u64ReqHdl,SCALER_DIP_WIN eWindow)
1989 {
1990 MS_U16 u16DIPInit=0;
1991 MS_U16 u16DIPREnable=0;
1992
1993 MS_PHY phyOutYAdress=0;
1994 MS_PHY phyOutCAdress=0;
1995 MS_U8 u8OutputMiu=0;
1996 MS_U16 u16OutputWidth=0;
1997 MS_U16 u16OutputHeight=0;
1998 MS_U16 u16OutputPitch=0;
1999
2000 char string_OutputFormat[10];
2001 char string_OutputTileFormat[8];
2002
2003 MS_U16 u16Clip_H_Start=0;
2004 MS_U16 u16Clip_H_End=0;
2005 MS_U16 u16Clip_V_Start=0;
2006 MS_U16 u16Clip_V_End=0;
2007 MS_U16 u16HMirror=0;
2008 MS_U16 u16VMirror=0;
2009
2010 MS_U16 u16H_Scaling_Enable=0;
2011 MS_U32 u32H_Scaling_Ratio=0;
2012 MS_U16 u16V_Scaling_Enable=0;
2013 MS_U32 u32V_Scaling_Ratio=0;
2014
2015 MS_PHY phyInputYAdress=0;
2016 MS_PHY phyInputCAdress=0;
2017 MS_U8 u8InputMiu=0;
2018
2019 MS_U16 u16InputWidth=0;
2020 MS_U16 u16InputHeight=0;
2021 MS_U16 u16InputPitch=0;
2022
2023 char string_InputFormat[10];
2024 char string_InputTileFormat[8];
2025
2026 MS_U16 u16tmp=0;
2027 MS_U16 u16tmp2=0;
2028 MS_U16 u16BusSize = 0;
2029
2030 char DIP_format_YUV422[] = "YUV422";
2031 char DIP_format_RGB565[] = "RGB565";
2032 char DIP_format_ARGB8888[] = "ARGB8888";
2033 char DIP_format_YUV420[] = "YUV420";
2034
2035 char DIP_tile_format_Linear[] = "Linear";
2036 char DIP_tile_format_16x32[] = "16x32";
2037 char DIP_tile_format_32x16[] = "32x16";
2038 char DIP_tile_format_32x32[] = "32x32";
2039
2040 if( eWindow == DIP_WINDOW )
2041 {
2042 //Check DIP initialized or not
2043 u16DIPInit = SC_R2BYTEMSK(0, REG_SC_BK36_01_L, BIT(6));
2044 if(u16DIPInit == 0 )
2045 {
2046 MdbPrint(u64ReqHdl,"DIP%d Not Initialized\n",eWindow);
2047 return;
2048 }
2049 u16BusSize = HAL_XC_DIP_GetBusSize(NULL, eWindow);
2050
2051 //DIP capture from
2052 u16DIPREnable = SC_R2BYTEMSK(0, REG_SC_BK34_7F_L, BIT(6));
2053
2054 //DIPW address/miu
2055 phyOutYAdress = SC_R4BYTE(0, REG_SC_BK36_10_L) * u16BusSize;
2056 phyOutCAdress = SC_R4BYTE(0, REG_SC_BK36_20_L) * u16BusSize;
2057 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_02_L, BIT(13)) >> 13;
2058 u16tmp2 = SC_R2BYTEMSK(0, REG_SC_BK36_07_L, BIT(15)) >> 15;
2059 u8OutputMiu= u16tmp | (u16tmp2<<1);
2060
2061 //DIPW width/height/pitch
2062 u16OutputWidth = SC_R2BYTE(0, REG_SC_BK36_1F_L);
2063 u16OutputHeight = SC_R2BYTE(0, REG_SC_BK36_2F_L);
2064 u16OutputPitch = SC_R2BYTE(0, REG_SC_BK36_2F_L);
2065
2066 //DIPW format/tile format
2067 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_01_L, BMASK(5:4)) >> 4;
2068 if(u16tmp == 0)
2069 {
2070 strcpy(string_OutputFormat, DIP_format_YUV422);
2071 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2072 }
2073 else if(u16tmp == 1)
2074 {
2075 strcpy(string_OutputFormat, DIP_format_RGB565);
2076 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2077 }
2078 else if(u16tmp == 2)
2079 {
2080 strcpy(string_OutputFormat, DIP_format_ARGB8888);
2081 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2082 }
2083 else
2084 {
2085 strcpy(string_OutputFormat, DIP_format_YUV420);
2086 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_7E_L, BIT(14));
2087 if(u16tmp != 0)
2088 {
2089 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2090 }
2091 else
2092 {
2093 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(12));
2094 u16tmp2 = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(14));
2095 if((u16tmp==0)&&(u16tmp2==0))
2096 {
2097 strcpy(string_OutputTileFormat, DIP_tile_format_16x32);
2098 }
2099 else if((u16tmp!=0)&&(u16tmp2==0))
2100 {
2101 strcpy(string_OutputTileFormat, DIP_tile_format_32x16);
2102 }
2103 else if((u16tmp==0)&&(u16tmp2!=0))
2104 {
2105 strcpy(string_OutputTileFormat, DIP_tile_format_32x32);
2106 }
2107 else
2108 {
2109 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2110 }
2111 }
2112 }
2113 //clip window info
2114 u16Clip_H_Start = SC_R2BYTE(0, REG_SC_BK34_61_L);
2115 u16Clip_H_End = SC_R2BYTE(0, REG_SC_BK34_62_L);
2116 u16Clip_V_Start = SC_R2BYTE(0, REG_SC_BK34_63_L);
2117 u16Clip_V_End = SC_R2BYTE(0, REG_SC_BK34_63_L);
2118
2119 //HV Mirror status
2120 u16HMirror = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(9)) >> 9;
2121 u16VMirror = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(10)) >> 10;
2122
2123 //HV scaling enable/ratio
2124 HAL_XC_DIP_Check_Scale(u64ReqHdl, &u16H_Scaling_Enable,&u32H_Scaling_Ratio,&u16V_Scaling_Enable,&u32V_Scaling_Ratio,eWindow);
2125
2126 //DIPR address/miu
2127 phyInputYAdress = SC_R4BYTE(0, REG_SC_BK36_78_L) * u16BusSize;
2128 phyInputCAdress = SC_R4BYTE(0, REG_SC_BK36_78_L) * u16BusSize;
2129 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_7D_L, BIT(15)) >> 15;
2130 u16tmp2 = SC_R2BYTEMSK(0, REG_SC_BK36_7C_L, BIT(14)) >> 14;
2131 u8InputMiu= u16tmp | (u16tmp2<<1);
2132
2133 //DIPR width/height/pitch
2134 u16InputWidth = SC_R2BYTE(0, REG_SC_BK36_27_L);
2135 u16InputHeight = SC_R2BYTE(0, REG_SC_BK36_37_L);
2136 u16InputPitch = SC_R2BYTE(0, REG_SC_BK36_74_L);
2137
2138 //DIPR format/tile format
2139 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_7D_L, BMASK(7:6)) >> 6;
2140 if(u16tmp == 0)
2141 {
2142 strcpy(string_InputFormat, DIP_format_YUV422);
2143 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2144 }
2145 else if(u16tmp == 1)
2146 {
2147 strcpy(string_InputFormat, DIP_format_RGB565);
2148 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2149 }
2150 else if(u16tmp == 2)
2151 {
2152 strcpy(string_InputFormat, DIP_format_ARGB8888);
2153 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2154 }
2155 else
2156 {
2157 strcpy(string_InputFormat, DIP_format_YUV420);
2158 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_7E_L, BIT(14));
2159 if(u16tmp != 0)
2160 {
2161 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2162 }
2163 else
2164 {
2165 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(13));
2166 u16tmp2 = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(15));
2167 if((u16tmp==0)&&(u16tmp2==0))
2168 {
2169 strcpy(string_InputTileFormat, DIP_tile_format_16x32);
2170 }
2171 else if((u16tmp!=0)&&(u16tmp2==0))
2172 {
2173 strcpy(string_InputTileFormat, DIP_tile_format_32x16);
2174 }
2175 else if((u16tmp==0)&&(u16tmp2!=0))
2176 {
2177 strcpy(string_InputTileFormat, DIP_tile_format_32x32);
2178 }
2179 else
2180 {
2181 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2182 }
2183 }
2184 }
2185 }
2186 else if( eWindow == DWIN0_WINDOW )
2187 {
2188 //Check DIP initialized or not
2189 u16DIPInit = SC_R2BYTEMSK(0, REG_SC_BK3B_01_L, BIT(6));
2190 if(u16DIPInit == 0 )
2191 {
2192 MdbPrint(u64ReqHdl,"DIP%d Not Initialized\n",eWindow);
2193 return;
2194 }
2195 u16BusSize = HAL_XC_DIP_GetBusSize(NULL, eWindow);
2196
2197 //DIP capture from
2198 u16DIPREnable = SC_R2BYTEMSK(0, REG_SC_BK3B_73_L, BIT(6));
2199
2200 //DIPW address/miu
2201 phyOutYAdress = SC_R4BYTE(0, REG_SC_BK3B_10_L) * u16BusSize;
2202 phyOutCAdress = SC_R4BYTE(0, REG_SC_BK3B_20_L) * u16BusSize;
2203 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK3B_02_L, BIT(13)) >> 13;
2204 u16tmp2 = SC_R2BYTEMSK(0, REG_SC_BK3B_07_L, BIT(15)) >> 15;
2205 u8OutputMiu= u16tmp | (u16tmp2<<1);
2206
2207 //DIPW width/height/pitch
2208 u16OutputWidth = SC_R2BYTE(0, REG_SC_BK3B_1F_L);
2209 u16OutputHeight = SC_R2BYTE(0, REG_SC_BK3B_2F_L);
2210 u16OutputPitch = SC_R2BYTE(0, REG_SC_BK3B_2F_L);
2211
2212 //DIPW format/tile format
2213 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK3B_01_L, BMASK(5:4)) >> 4;
2214 if(u16tmp == 0)
2215 {
2216 strcpy(string_OutputFormat, DIP_format_YUV422);
2217 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2218 }
2219 else if(u16tmp == 1)
2220 {
2221 strcpy(string_OutputFormat, DIP_format_RGB565);
2222 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2223 }
2224 else if(u16tmp == 2)
2225 {
2226 strcpy(string_OutputFormat, DIP_format_ARGB8888);
2227 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2228 }
2229 else
2230 {
2231 strcpy(string_OutputFormat, DIP_format_YUV420);
2232 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_7E_L, BIT(14));
2233 if(u16tmp != 0)
2234 {
2235 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2236 }
2237 else
2238 {
2239 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(12));
2240 u16tmp2 = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(14));
2241 if((u16tmp==0)&&(u16tmp2==0))
2242 {
2243 strcpy(string_OutputTileFormat, DIP_tile_format_16x32);
2244 }
2245 else if((u16tmp!=0)&&(u16tmp2==0))
2246 {
2247 strcpy(string_OutputTileFormat, DIP_tile_format_32x16);
2248 }
2249 else if((u16tmp==0)&&(u16tmp2!=0))
2250 {
2251 strcpy(string_OutputTileFormat, DIP_tile_format_32x32);
2252 }
2253 else
2254 {
2255 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2256 }
2257 }
2258 }
2259 //clip window info
2260 u16Clip_H_Start = SC_R2BYTE(0, REG_SC_BK3B_63_L);
2261 u16Clip_H_End = SC_R2BYTE(0, REG_SC_BK3B_64_L);
2262 u16Clip_V_Start = SC_R2BYTE(0, REG_SC_BK3B_65_L);
2263 u16Clip_V_End = SC_R2BYTE(0, REG_SC_BK3B_66_L);
2264
2265 //HV Mirror status
2266 u16HMirror = SC_R2BYTEMSK(0, REG_SC_BK3B_0B_L, BIT(9)) >> 9;
2267 u16VMirror = SC_R2BYTEMSK(0, REG_SC_BK3B_0B_L, BIT(10)) >> 10;
2268
2269 //HV scaling enable/ratio
2270 HAL_XC_DIP_Check_Scale(u64ReqHdl, &u16H_Scaling_Enable,&u32H_Scaling_Ratio,&u16V_Scaling_Enable,&u32V_Scaling_Ratio,eWindow);
2271
2272 //DIPR address/miu
2273 phyInputYAdress = SC_R4BYTE(0, REG_SC_BK36_78_L) * u16BusSize;
2274 phyInputCAdress = SC_R4BYTE(0, REG_SC_BK36_78_L) * u16BusSize;
2275 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_7D_L, BIT(15)) >> 15;
2276 u16tmp2 = SC_R2BYTEMSK(0, REG_SC_BK36_7C_L, BIT(14)) >> 14;
2277 u8InputMiu= u16tmp | (u16tmp2<<1);
2278
2279 //DIPR width/height/pitch
2280 u16InputWidth = SC_R2BYTE(0, REG_SC_BK36_27_L);
2281 u16InputHeight = SC_R2BYTE(0, REG_SC_BK36_37_L);
2282 u16InputPitch = SC_R2BYTE(0, REG_SC_BK36_74_L);
2283
2284 //DIPR format/tile format
2285 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_7D_L, BMASK(7:6)) >> 6;
2286 if(u16tmp == 0)
2287 {
2288 strcpy(string_InputFormat, DIP_format_YUV422);
2289 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2290 }
2291 else if(u16tmp == 1)
2292 {
2293 strcpy(string_InputFormat, DIP_format_RGB565);
2294 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2295 }
2296 else if(u16tmp == 2)
2297 {
2298 strcpy(string_InputFormat, DIP_format_ARGB8888);
2299 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2300 }
2301 else
2302 {
2303 strcpy(string_InputFormat, DIP_format_YUV420);
2304 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_7E_L, BIT(14));
2305 if(u16tmp != 0)
2306 {
2307 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2308 }
2309 else
2310 {
2311 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(13));
2312 u16tmp2 = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(15));
2313 if((u16tmp==0)&&(u16tmp2==0))
2314 {
2315 strcpy(string_InputTileFormat, DIP_tile_format_16x32);
2316 }
2317 else if((u16tmp!=0)&&(u16tmp2==0))
2318 {
2319 strcpy(string_InputTileFormat, DIP_tile_format_32x16);
2320 }
2321 else if((u16tmp==0)&&(u16tmp2!=0))
2322 {
2323 strcpy(string_InputTileFormat, DIP_tile_format_32x32);
2324 }
2325 else
2326 {
2327 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2328 }
2329 }
2330 }
2331 }
2332 else if( eWindow == DWIN1_WINDOW )
2333 {
2334 //Check DIP initialized or not
2335 u16DIPInit = SC_R2BYTEMSK(0, REG_SC_BK3C_01_L, BIT(6));
2336 if(u16DIPInit == 0 )
2337 {
2338 MdbPrint(u64ReqHdl,"DIP%d Not Initialized\n",eWindow);
2339 return;
2340 }
2341 u16BusSize = HAL_XC_DIP_GetBusSize(NULL, eWindow);
2342
2343 //DIP capture from
2344 u16DIPREnable = SC_R2BYTEMSK(0, REG_SC_BK3C_73_L, BIT(6));
2345
2346 //DIPW address/miu
2347 phyOutYAdress = SC_R4BYTE(0, REG_SC_BK3C_10_L) * u16BusSize;
2348 phyOutCAdress = SC_R4BYTE(0, REG_SC_BK3C_20_L) * u16BusSize;
2349 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK3C_02_L, BIT(13)) >> 13;
2350 u16tmp2 = SC_R2BYTEMSK(0, REG_SC_BK3C_07_L, BIT(15)) >> 15;
2351 u8OutputMiu= u16tmp | (u16tmp2<<1);
2352
2353 //DIPW width/height/pitch
2354 u16OutputWidth = SC_R2BYTE(0, REG_SC_BK3C_1F_L);
2355 u16OutputHeight = SC_R2BYTE(0, REG_SC_BK3C_2F_L);
2356 u16OutputPitch = SC_R2BYTE(0, REG_SC_BK3C_2F_L);
2357
2358 //DIPW format/tile format
2359 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK3C_01_L, BMASK(5:4)) >> 4;
2360 if(u16tmp == 0)
2361 {
2362 strcpy(string_OutputFormat, DIP_format_YUV422);
2363 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2364 }
2365 else if(u16tmp == 1)
2366 {
2367 strcpy(string_OutputFormat, DIP_format_RGB565);
2368 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2369 }
2370 else if(u16tmp == 2)
2371 {
2372 strcpy(string_OutputFormat, DIP_format_ARGB8888);
2373 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2374 }
2375 else
2376 {
2377 strcpy(string_OutputFormat, DIP_format_YUV420);
2378 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_7E_L, BIT(14));
2379 if(u16tmp != 0)
2380 {
2381 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2382 }
2383 else
2384 {
2385 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(12));
2386 u16tmp2 = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(14));
2387 if((u16tmp==0)&&(u16tmp2==0))
2388 {
2389 strcpy(string_OutputTileFormat, DIP_tile_format_16x32);
2390 }
2391 else if((u16tmp!=0)&&(u16tmp2==0))
2392 {
2393 strcpy(string_OutputTileFormat, DIP_tile_format_32x16);
2394 }
2395 else if((u16tmp==0)&&(u16tmp2!=0))
2396 {
2397 strcpy(string_OutputTileFormat, DIP_tile_format_32x32);
2398 }
2399 else
2400 {
2401 strcpy(string_OutputTileFormat, DIP_tile_format_Linear);
2402 }
2403 }
2404 }
2405 //clip window info
2406 u16Clip_H_Start = SC_R2BYTE(0, REG_SC_BK3C_63_L);
2407 u16Clip_H_End = SC_R2BYTE(0, REG_SC_BK3C_64_L);
2408 u16Clip_V_Start = SC_R2BYTE(0, REG_SC_BK3C_65_L);
2409 u16Clip_V_End = SC_R2BYTE(0, REG_SC_BK3C_66_L);
2410
2411 //HV Mirror status
2412 u16HMirror = SC_R2BYTEMSK(0, REG_SC_BK3C_0B_L, BIT(9)) >> 9;
2413 u16VMirror = SC_R2BYTEMSK(0, REG_SC_BK3C_0B_L, BIT(10)) >> 10;
2414
2415 //HV scaling enable/ratio
2416 HAL_XC_DIP_Check_Scale(u64ReqHdl, &u16H_Scaling_Enable,&u32H_Scaling_Ratio,&u16V_Scaling_Enable,&u32V_Scaling_Ratio,eWindow);
2417
2418 //DIPR address/miu
2419 phyInputYAdress = SC_R4BYTE(0, REG_SC_BK36_78_L) * u16BusSize;
2420 phyInputCAdress = SC_R4BYTE(0, REG_SC_BK36_78_L) * u16BusSize;
2421 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_7D_L, BIT(15)) >> 15;
2422 u16tmp2 = SC_R2BYTEMSK(0, REG_SC_BK36_7C_L, BIT(14)) >> 14;
2423 u8InputMiu= u16tmp | (u16tmp2<<1);
2424
2425 //DIPR width/height/pitch
2426 u16InputWidth = SC_R2BYTE(0, REG_SC_BK36_27_L);
2427 u16InputHeight = SC_R2BYTE(0, REG_SC_BK36_37_L);
2428 u16InputPitch = SC_R2BYTE(0, REG_SC_BK36_74_L);
2429
2430 //DIPR format/tile format
2431 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_7D_L, BMASK(7:6)) >> 6;
2432 if(u16tmp == 0)
2433 {
2434 strcpy(string_InputFormat, DIP_format_YUV422);
2435 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2436 }
2437 else if(u16tmp == 1)
2438 {
2439 strcpy(string_InputFormat, DIP_format_RGB565);
2440 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2441 }
2442 else if(u16tmp == 2)
2443 {
2444 strcpy(string_InputFormat, DIP_format_ARGB8888);
2445 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2446 }
2447 else
2448 {
2449 strcpy(string_InputFormat, DIP_format_YUV420);
2450 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_7E_L, BIT(14));
2451 if(u16tmp != 0)
2452 {
2453 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2454 }
2455 else
2456 {
2457 u16tmp = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(13));
2458 u16tmp2 = SC_R2BYTEMSK(0, REG_SC_BK36_0B_L, BIT(15));
2459 if((u16tmp==0)&&(u16tmp2==0))
2460 {
2461 strcpy(string_InputTileFormat, DIP_tile_format_16x32);
2462 }
2463 else if((u16tmp!=0)&&(u16tmp2==0))
2464 {
2465 strcpy(string_InputTileFormat, DIP_tile_format_32x16);
2466 }
2467 else if((u16tmp==0)&&(u16tmp2!=0))
2468 {
2469 strcpy(string_InputTileFormat, DIP_tile_format_32x32);
2470 }
2471 else
2472 {
2473 strcpy(string_InputTileFormat, DIP_tile_format_Linear);
2474 }
2475 }
2476 }
2477 }
2478 else
2479 {
2480 MdbPrint(u64ReqHdl,"SCALER_DIP_WIN does not support\n");
2481 return;
2482 }
2483
2484 MdbPrint(u64ReqHdl,"Capture from:%s\n",(u16DIPREnable?"DRAM":"XC"));
2485 MdbPrint(u64ReqHdl,"Output Y address=0x%x\n",phyOutYAdress);
2486 MdbPrint(u64ReqHdl,"Output C address=0x%x\n",phyOutCAdress);
2487 MdbPrint(u64ReqHdl,"Output Miu=%d\n",u8OutputMiu);
2488 MdbPrint(u64ReqHdl,"Output Width(pixel)=%d\n",u16OutputWidth);
2489 MdbPrint(u64ReqHdl,"Output Height(pixel)=%d\n",u16OutputHeight);
2490 MdbPrint(u64ReqHdl,"Output Pitch(pixel)=%d\n",u16OutputPitch);
2491 MdbPrint(u64ReqHdl,"Output Format:%s\n",string_OutputFormat);
2492 MdbPrint(u64ReqHdl,"Output Tile Format:%s\n",string_OutputFormat);
2493 MdbPrint(u64ReqHdl,"Clip Window H Start=%d\n",u16Clip_H_Start);
2494 MdbPrint(u64ReqHdl,"Clip Window H End=%d\n",u16Clip_H_End);
2495 MdbPrint(u64ReqHdl,"Clip Window V Start=%d\n",u16Clip_V_Start);
2496 MdbPrint(u64ReqHdl,"Clip Window V End=%d\n",u16Clip_V_End);
2497 MdbPrint(u64ReqHdl,"H Mirror=%s\n",(u16HMirror?"TRUE":"FALSE"));
2498 MdbPrint(u64ReqHdl,"H Mirror=%s\n",(u16VMirror?"TRUE":"FALSE"));
2499 MdbPrint(u64ReqHdl,"H Scaling Enable=%s\n",(u16H_Scaling_Enable?"TRUE":"FALSE"));
2500 MdbPrint(u64ReqHdl,"H Scaling Ratio=0x%x\n",u32H_Scaling_Ratio);
2501 MdbPrint(u64ReqHdl,"V Scaling Enable=%s\n",(u16V_Scaling_Enable?"TRUE":"FALSE"));
2502 MdbPrint(u64ReqHdl,"V Scaling Ratio=0x%x\n",u32V_Scaling_Ratio);
2503 if(u16DIPREnable != 0)
2504 {
2505 MdbPrint(u64ReqHdl,"Input Y Address=0x%x\n",phyInputYAdress);
2506 MdbPrint(u64ReqHdl,"Input C Address=0x%x\n",phyInputCAdress);
2507 MdbPrint(u64ReqHdl,"Input Miu=%d\n",u8InputMiu);
2508 MdbPrint(u64ReqHdl,"Input_Width(pixel)=%d\n",u16InputWidth);
2509 MdbPrint(u64ReqHdl,"Input_Height(pixel)=%d\n",u16InputHeight);
2510 MdbPrint(u64ReqHdl,"Input_Pitch(pixel)=%d\n",u16InputPitch);
2511 MdbPrint(u64ReqHdl,"Input_Format=%s\n",string_InputTileFormat);
2512 MdbPrint(u64ReqHdl,"Input_Tile_Format=%s\n",string_InputTileFormat);
2513 }
2514 }
2515
2516
MDrv_XC_DIP_Mdb_Cmdline(MS_U64 * u64ReqHdl,MS_U32 u32CmdSize,char * pcCmdLine)2517 void MDrv_XC_DIP_Mdb_Cmdline(MS_U64* u64ReqHdl,MS_U32 u32CmdSize,char *pcCmdLine)
2518 {
2519
2520 }
2521
MDrv_XC_DIP_Mdb_GetInfo(MS_U64 * u64ReqHdl)2522 void MDrv_XC_DIP_Mdb_GetInfo(MS_U64* u64ReqHdl)
2523 {
2524 MS_U8 u8dipIndex = 0;
2525 MS_U32 u32DipChipCaps = 0;
2526 MS_U8 u8dipTotal = 0;
2527
2528 HAL_XC_DIP_Check_Clock(u64ReqHdl, DIP_WINDOW);
2529
2530 for(u8dipIndex=0;u8dipIndex<MAX_DIP_WINDOW;u8dipIndex++)
2531 {
2532 DIP_CHIP_CAP(u8dipIndex,u32DipChipCaps);
2533 if((u32DipChipCaps&DIP_CAP_EXIST) != 0)
2534 {
2535 MdbPrint(u64ReqHdl,"--------- MStar DIP%d Info ---------\n",u8dipIndex);
2536 MDrv_XC_DIP_Read_Info(u64ReqHdl, (SCALER_DIP_WIN)u8dipIndex);
2537 u8dipTotal++;
2538 }
2539 }
2540
2541 MdbPrint(u64ReqHdl,"Chip Support Total %d DIP\n",u8dipTotal);
2542 }
2543 #endif
MDrv_XC_DIP_ConfigPipe_U2(void * pInstance,MS_U32 u32PipeID,MS_U32 u32SecureDMA,MS_U32 u32OperationMode)2544 MS_U32 MDrv_XC_DIP_ConfigPipe_U2(void* pInstance,MS_U32 u32PipeID, MS_U32 u32SecureDMA, MS_U32 u32OperationMode)
2545 {
2546 if(u32OperationMode == XC_DIP_OPMODE_DISABLE)
2547 {
2548 HAL_XC_DIP_Enable(pInstance,TRUE);
2549 }
2550 else if(u32OperationMode == XC_DIP_OPMODE_ENABLE)
2551 {
2552 HAL_XC_DIP_Enable(pInstance,FALSE);
2553 }
2554 return 0;
2555 }
2556
2557 #endif
2558 //=============== DIP =====================//
2559
2560
2561