1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94
95 ///////////////////////////////////////////////////////////////////////////////////////////////////
96 /// file Mdrv_sc_ip.c
97 /// @brief Driver Interface
98 /// @author MStar Semiconductor Inc.
99 ///////////////////////////////////////////////////////////////////////////////////////////////////
100 #define _MDRV_SC_IP_C_
101
102 //-------------------------------------------------------------------------------------------------
103 // Include Files
104 //-------------------------------------------------------------------------------------------------
105 // Common Definition
106
107 #ifdef MSOS_TYPE_LINUX_KERNEL
108 #include <linux/string.h>
109 #include <asm/div64.h>
110 #else
111 #include <string.h>
112 #define do_div(x,y) ((x)/=(y))
113 #endif
114
115 #include "MsCommon.h"
116 #include "MsIRQ.h"
117 #include "MsOS.h"
118 #include "mhal_xc_chip_config.h"
119 #include "utopia.h"
120 #include "utopia_dapi.h"
121
122 // Internal Definition
123 #include "drvXC_IOPort.h"
124 #include "xc_Analog_Reg.h"
125 #include "xc_hwreg_utility2.h"
126 #include "apiXC.h"
127 #include "apiXC_Adc.h"
128 #include "apiXC_Auto.h"
129 #include "drv_sc_display.h"
130 #include "drv_sc_isr.h"
131 #include "apiXC_PCMonitor.h"
132 #include "apiXC_ModeParse.h"
133 #include "drvXC_HDMI_if.h"
134 #include "mvideo_context.h"
135 #include "drv_sc_ip.h"
136 #if (LD_ENABLE==1)
137 #include "mdrv_ld.h"
138 #include "mdrv_ldalgo.h"
139 #endif
140 #include "mdrv_sc_3d.h"
141 #include "drv_sc_menuload.h"
142 #include "drvXC_ADC_Internal.h"
143 #include "mhal_sc.h"
144 #if FRC_INSIDE
145 #include "mdrv_frc.h"
146 #include "mhal_frc.h"
147 #endif
148 #include "XC_private.h"
149 #include "apiXC_v2.h"
150 #include "drvXC_HDMI_Internal.h"
151 #include "drv_xc_calibration.h"
152 #include "mhal_menuload.h"
153 #include "drv_sc_scaling.h"
154 #include "drv_sc_mux.h"
155
156 #include "mhal_ip.h"
157 #include "mhal_mux.h"
158 #include "halCHIP.h"
159
160 #ifdef MSOS_TYPE_LINUX
161 #include <assert.h>
162 #else
163 #define assert(b) \
164 do { \
165 if (!(b)){ \
166 printf("assert at [%s][%d] \n", __FUNCTION__, __LINE__); \
167 *((int*)0) = 0; \
168 } \
169 } while(0)
170 #endif
171
172 #ifdef ANDROID
173 #include <cutils/log.h>
174 #ifndef LOGE
175 #define printf(format, args...) ALOGE(format, ##args);
176 #else
177 #define printf(format, args...) LOGE(format, ##args);
178 #endif
179 #endif
180
181 //-------------------------------------------------------------------------------------------------
182 // Driver Compiler Options
183 //-------------------------------------------------------------------------------------------------
184
185
186
187 //-------------------------------------------------------------------------------------------------
188 // Local Defines
189 //-------------------------------------------------------------------------------------------------
190 #define msg_sc_ip(x) //x
191 #define FB_DBG(x) // x
192 #define PCMSG_TIMING(x) //x
193
194 #define ENABLE_DEBUG_CLEAR_FB_BEFORE_CAPTURE 0
195 #if (defined(FPU_SUPPORT) && defined(__arm__) && defined(MSOS_TYPE_LINUX))
196 #define DATA_CONVERT_NEON_OPTIMIZE_ENABLE TRUE
197 #else
198 #define DATA_CONVERT_NEON_OPTIMIZE_ENABLE FALSE
199 #endif
200
201 #define R_CHANNEL_MIN 0x00
202 #define G_CHANNEL_MIN 0x01
203 #define B_CHANNEL_MIN 0x02
204 #define R_CHANNEL_MAX 0x03
205 #define G_CHANNEL_MAX 0x04
206 #define B_CHANNEL_MAX 0x05
207
208 #define HDE_UPPERBOUND_720 1280
209 #define HDE_LOWERBOUND_720 900
210 //-------------------------------------------------------------------------------------------------
211 // Local Structurs
212 //-------------------------------------------------------------------------------------------------
213 typedef struct SC_MEM_YUV444_FMT_s
214 {
215 MS_U32 Cb:10;
216 MS_U32 Y:10;
217 MS_U32 Cr:10;
218 MS_U32 u8Dummy:2; // [31:30] no use
219 } SC_MEM_YUV444_FMT_t, *pSC_MEM_YUV444_FMT_t;
220
221 //-------------------------------------------------------------------------------------------------
222 // Global Variables
223 //-------------------------------------------------------------------------------------------------
224 #ifdef MSOS_TYPE_LINUX_KERNEL
225 //MS_BOOL g_bDoCalibration;
226 #endif
227
228 //-------------------------------------------------------------------------------------------------
229 // Local Variables
230 //-------------------------------------------------------------------------------------------------
231
232
233 //-------------------------------------------------------------------------------------------------
234 // Debug Functions
235 //-------------------------------------------------------------------------------------------------
236
237
238 //-------------------------------------------------------------------------------------------------
239 // Local Functions
240 //-------------------------------------------------------------------------------------------------
241
242
243 //-------------------------------------------------------------------------------------------------
244 // Global Functions
245 //-------------------------------------------------------------------------------------------------
246
247 //-----------------------------------------------------------------------------
248 // IP MUX
249 //-----------------------------------------------------------------------------
MDrv_XC_reset_ip(void * pInstance,SCALER_WIN eWindow)250 void MDrv_XC_reset_ip(void *pInstance, SCALER_WIN eWindow)
251 {
252
253 if( eWindow == MAIN_WINDOW )
254 {
255 Hal_SC_ip_software_reset(pInstance, REST_IP_F2, eWindow);
256 }
257 else
258 {
259 Hal_SC_ip_software_reset(pInstance, REST_IP_F1, eWindow);
260 }
261 }
262
263
264 //-------------------------------------------------------------------------------------------------
265 /// do the software reset for the specific window
266 /// @param u8Reset \b IN: reset IP @ref SOFTWARE_REST_TYPE_t
267 /// @param eWindow \b IN: which window we are going to set
268 //-------------------------------------------------------------------------------------------------
MApi_XC_SoftwareReset_U2(void * pInstance,MS_U8 u8Reset,SCALER_WIN eWindow)269 void MApi_XC_SoftwareReset_U2(void* pInstance, MS_U8 u8Reset, SCALER_WIN eWindow)
270 {
271 _XC_ENTRY(pInstance);
272 MDrv_XC_SoftwareReset(pInstance, u8Reset, eWindow );
273 _XC_RETURN(pInstance);
274 }
275
MApi_XC_SoftwareReset(MS_U8 u8Reset,SCALER_WIN eWindow)276 void MApi_XC_SoftwareReset(MS_U8 u8Reset, SCALER_WIN eWindow)
277 {
278 if (pu32XCInst == NULL)
279 {
280 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
281 return;
282 }
283
284 stXC_SET_SOFTWARE_RESET XCArgs;
285 XCArgs.u8Reset = u8Reset;
286 XCArgs.eWindow = eWindow;
287
288 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_SOFTWARE_RESET, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
289 {
290 printf("Obtain XC engine fail\n");
291 return;
292 }
293 else
294 {
295 return;
296 }
297 }
298
MDrv_XC_SoftwareReset(void * pInstance,MS_U8 u8Reset,SCALER_WIN eWindow)299 void MDrv_XC_SoftwareReset(void *pInstance, MS_U8 u8Reset, SCALER_WIN eWindow)
300 {
301 Hal_SC_ip_software_reset(pInstance, u8Reset, eWindow );
302 }
303
304 /******************************************************************************/
305 /// -This function will return input video source status
306 /// @return Video status
307 /// - BIT0:VSnc polarity bit(0/1 = positive/negative)
308 /// - BIT1:HSync polarity bit(0/1 = positive/negative)
309 /// - BIT2:HSync loss bit
310 /// - BIT3:VSync loss bit
311 /// - BIT4:Interlace mode
312 /// - BIT7:User new mode (Not found in mode table)
313 /******************************************************************************/
MDrv_XC_ip_get_sync_status(void * pInstance,XC_IP_SYNC_STATUS * sXC_Sync_Status,E_MUX_INPUTPORT enInputPort,SCALER_WIN eWindow)314 void MDrv_XC_ip_get_sync_status(void *pInstance, XC_IP_SYNC_STATUS *sXC_Sync_Status, E_MUX_INPUTPORT enInputPort , SCALER_WIN eWindow)
315 {
316 MS_U8 u8DetectStatus;
317 //MS_U16 u16HDE_temp_size,u16HDE_size =0;
318 /* mode detect status */
319 sXC_Sync_Status->u8SyncStatus = 0x00;
320
321 u8DetectStatus = Hal_SC_ip_get_sync_detect_status(pInstance, eWindow);
322 if ( u8DetectStatus & BIT(0) )
323 {
324 sXC_Sync_Status->u8SyncStatus |= XC_MD_VSYNC_POR_BIT;
325 }
326 if ( u8DetectStatus & BIT(1) )
327 {
328 sXC_Sync_Status->u8SyncStatus |= XC_MD_HSYNC_POR_BIT;
329 }
330 if ( u8DetectStatus & BIT(3) )
331 {
332 sXC_Sync_Status->u8SyncStatus |= XC_MD_INTERLACE_BIT;
333 }
334
335 /* HSync */
336 sXC_Sync_Status->u16Hperiod = MDrv_SC_ip_get_horizontalPeriod(pInstance, eWindow);
337 if( (sXC_Sync_Status->u16Hperiod == MST_H_PERIOD_MASK) || (sXC_Sync_Status->u16Hperiod < 10) )
338 {
339 sXC_Sync_Status->u8SyncStatus |= XC_MD_HSYNC_LOSS_BIT;
340 }
341 msg_sc_ip(printf("Hperiod=0x%x\n", sXC_Sync_Status->u16Hperiod));
342
343 /* VSync */
344 sXC_Sync_Status->u16Vtotal = MDrv_SC_ip_get_verticaltotal(pInstance, eWindow);
345 if ( (sXC_Sync_Status->u16Vtotal == MST_V_TOTAL_MASK) || (sXC_Sync_Status->u16Vtotal < 200) )
346 {
347 sXC_Sync_Status->u8SyncStatus |= XC_MD_VSYNC_LOSS_BIT;
348 }
349
350 // Keep original Vtt even we force set interlace
351 if (MDrv_SC_GetInterlaceInPModeStatus(pInstance, eWindow)
352 && (MDrv_XC_GetForceiSupportType(pInstance) == ForceI_SW))
353 {
354 sXC_Sync_Status->u16Vtotal >>= 1;
355 }
356
357 msg_sc_ip(printf("Vtotal=0x%x\n", sXC_Sync_Status->u16Vtotal));
358
359 //MDrv_HDMI_StablePolling();
360
361 if ( IsDVIPort(enInputPort) ) // DVI
362 {
363 if ( MDrv_HDMI_dvi_clock_detect(enInputPort) )
364 sXC_Sync_Status->u8SyncStatus |= XC_MD_SYNC_LOSS;
365
366 Hal_SC_SetHDMI_Spliter(pInstance,sXC_Sync_Status,enInputPort,eWindow);
367 }
368
369 msg_sc_ip(printf("SyncStatus=0x%x\n", sXC_Sync_Status->u8SyncStatus));
370 }
371
372 /********************************************************************************/
373 /* Functions */
374 /********************************************************************************/
375
376 //-------------------------------------------------------------------------------------------------
377 /// This function generates specific timing
378 /// @param timingtype \b IN: the specific timing to generate
379 //-------------------------------------------------------------------------------------------------
MApi_XC_GenSpecificTiming_U2(void * pInstance,XC_Internal_TimingType timingtype)380 void MApi_XC_GenSpecificTiming_U2(void* pInstance, XC_Internal_TimingType timingtype)
381 {
382 _XC_ENTRY(pInstance);
383 MDrv_XC_GenSpecificTiming(pInstance, timingtype);
384 _XC_RETURN(pInstance);
385 }
386
MApi_XC_GenSpecificTiming(XC_Internal_TimingType timingtype)387 void MApi_XC_GenSpecificTiming(XC_Internal_TimingType timingtype)
388 {
389 if (pu32XCInst == NULL)
390 {
391 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
392 return;
393 }
394
395 stXC_SET_GENERATE_SPECIFIC_TIMING XCArgs;
396 XCArgs.timingtype = timingtype;
397
398 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_GENERATE_SPECIFIC_TIMING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
399 {
400 printf("Obtain XC engine fail\n");
401 return;
402 }
403 else
404 {
405 return;
406 }
407 }
408
409 //-------------------------------------------------------------------------------------------------
410 /// This function tells whether it's ip generated timing
411 //-------------------------------------------------------------------------------------------------
MDrv_SC_Check_IP_Gen_Timing(void * pInstance)412 MS_BOOL MDrv_SC_Check_IP_Gen_Timing(void *pInstance)
413 {
414 return Hal_SC_Check_IP_Gen_Timing(pInstance);
415 }
416
417 //-------------------------------------------------------------------------------------------------
418 /// This function initialize IP for internal timing
419 /// @param timingtype \b IN: the specific timing to generate
420 //-------------------------------------------------------------------------------------------------
MApi_XC_InitIPForInternalTiming_U2(void * pInstance,XC_Internal_TimingType timingtype)421 void MApi_XC_InitIPForInternalTiming_U2(void* pInstance, XC_Internal_TimingType timingtype)
422 {
423 _XC_ENTRY(pInstance);
424 MDrv_XC_InitIPForInternalTiming(pInstance, timingtype, MAIN_WINDOW);
425 _XC_RETURN(pInstance);
426 }
427
MApi_XC_InitIPForInternalTiming(XC_Internal_TimingType timingtype)428 void MApi_XC_InitIPForInternalTiming(XC_Internal_TimingType timingtype)
429 {
430 if (pu32XCInst == NULL)
431 {
432 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
433 return;
434 }
435
436 stXC_SET_INIT_IP_FOR_INTERNAL_TIMING XCArgs;
437 XCArgs.timingtype = timingtype;
438
439 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_INIT_IP_FOR_INTERNAL_TIMING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
440 {
441 printf("Obtain XC engine fail\n");
442 return;
443 }
444 else
445 {
446 return;
447 }
448 }
449
450
451 //-------------------------------------------------------------------------------------------------
452 /// This function Gets by-pass mode status:
453 //-------------------------------------------------------------------------------------------------
MDrv_SC_Get_DE_Bypass_Mode(void * pInstance,SCALER_WIN eWindow)454 MS_BOOL MDrv_SC_Get_DE_Bypass_Mode(void *pInstance, SCALER_WIN eWindow)
455 {
456 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
457 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
458
459 //TRUE: HV mdoe, FALSE:DE mode
460 if( eWindow == MAIN_WINDOW )
461 {
462 return ((SC_R2BYTEMSK( psXCInstPri->u32DeviceID, REG_SC_BK01_2F_L, BIT(15) ))? TRUE : FALSE);
463 }
464 else
465 {
466 return ((SC_R2BYTEMSK( psXCInstPri->u32DeviceID, REG_SC_BK03_2F_L, BIT(15) ))? TRUE : FALSE);
467 }
468 }
469
470 //-------------------------------------------------------------------------------------------------
471 /// This function get DE-Bypass Mode
472 /// @param eWindow \b IN: which window(main or sub) to get
473 /// @return @ref MS_BOOL
474 //-------------------------------------------------------------------------------------------------
MApi_XC_GetDEBypassMode_U2(void * pInstance,SCALER_WIN eWindow)475 MS_BOOL MApi_XC_GetDEBypassMode_U2(void* pInstance, SCALER_WIN eWindow)
476 {
477 MS_BOOL bIsDEBypassMode = FALSE;
478 _XC_ENTRY(pInstance);
479 bIsDEBypassMode = MDrv_SC_Get_DE_Bypass_Mode(pInstance, eWindow);
480 _XC_RETURN(pInstance);
481 return bIsDEBypassMode;
482 }
483
MApi_XC_GetDEBypassMode(SCALER_WIN eWindow)484 MS_BOOL MApi_XC_GetDEBypassMode(SCALER_WIN eWindow)
485 {
486 if (pu32XCInst == NULL)
487 {
488 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
489 return FALSE;
490 }
491
492 stXC_GET_DE_BYPASS_MODE XCArgs;
493 XCArgs.eWindow = eWindow;
494 XCArgs.bReturnValue = FALSE;
495
496 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_DE_BYPASS_MODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
497 {
498 printf("Obtain XC engine fail\n");
499 return FALSE;
500 }
501 else
502 {
503 return XCArgs.bReturnValue;
504 }
505 }
506
507 //-------------------------------------------------------------------------------------------------
508 /// This function get DE window
509 /// @param psWin \b OUT: window info to get
510 /// @param eWindow \b IN: which window(main or sub) to get
511 //-------------------------------------------------------------------------------------------------
MDrv_XC_GetDEWindow(void * pInstance,MS_WINDOW_TYPE * psWin,SCALER_WIN eWindow)512 void MDrv_XC_GetDEWindow(void *pInstance, MS_WINDOW_TYPE *psWin, SCALER_WIN eWindow)
513 {
514 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
515 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
516
517 if(MDrv_SC_Get_DE_Bypass_Mode(pInstance, eWindow) == TRUE)
518 {
519 printf("Cannot get DE window under HV mode!! please check your xc lib!\n");
520 }
521
522 psWin->x = Hal_SC_ip_de_hstart_info(pInstance, eWindow);
523 psWin->width = (Hal_SC_ip_de_hend_info(pInstance, eWindow) - psWin->x)+1;
524
525 // In froce interlace mode.
526 // Original size of V DE height => (Hal_SC_ip_de_vend_info(eWindow) - psWin->y)+1;
527 // the "+1" should be *2 also after force interlace mode.
528 if (MDrv_SC_GetInterlaceInPModeStatus(pInstance, eWindow)
529 && (MDrv_XC_GetForceiSupportType(pInstance) == ForceI_SW))
530 {
531 psWin->y = ( Hal_SC_ip_de_vstart_info(pInstance, eWindow) >> 1 ) - 1;
532 // original statement => psWin->height = ( (Hal_SC_ip_de_vend_info(eWindow) >> 1 ) - 1 ) - psWin->y) + 1;
533 // we can reduce to below statement.
534 psWin->height = (Hal_SC_ip_de_vend_info(pInstance, eWindow) >> 1 ) - psWin->y ;
535 }
536 else
537 {
538 psWin->y = Hal_SC_ip_de_vstart_info(pInstance, eWindow);
539 psWin->height = (Hal_SC_ip_de_vend_info(pInstance, eWindow) - psWin->y)+1;//for progresive signal, VDE = BK1_0x14 - BK1_0x12 + 1
540 }
541
542 if (Hal_SC_ip_get_interlace_status(pInstance, eWindow))
543 {
544 if(psWin->height & 1)
545 {
546 psWin->height += 1;//for interlace signal, VDE = BK1_0x14 - BK1_0x12 + 2, so here need add extra 1
547 }
548 }
549 }
550
MApi_XC_GetDEWindow_U2(void * pInstance,MS_WINDOW_TYPE * psWin,SCALER_WIN eWindow)551 void MApi_XC_GetDEWindow_U2(void* pInstance, MS_WINDOW_TYPE *psWin, SCALER_WIN eWindow)
552 {
553 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
554 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
555 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
556 _XC_ENTRY(pInstance);
557 MDrv_XC_GetDEWindow(pInstance, psWin, eWindow);
558 _XC_RETURN(pInstance);
559 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
560 return;
561 }
562
MApi_XC_GetDEWindow(MS_WINDOW_TYPE * psWin,SCALER_WIN eWindow)563 void MApi_XC_GetDEWindow(MS_WINDOW_TYPE *psWin, SCALER_WIN eWindow)
564 {
565 if (pu32XCInst == NULL)
566 {
567 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
568 return;
569 }
570
571 stXC_GET_DE_WINDOW XCArgs;
572 XCArgs.psWin = psWin;
573 XCArgs.eWindow = eWindow;
574
575 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_DE_WINDOW, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
576 {
577 printf("Obtain XC engine fail\n");
578 return;
579 }
580 else
581 {
582 return;
583 }
584 }
585
MDrv_XC_GetDEWidthHeightInDEByPassMode(void * pInstance,MS_U16 * pu16Width,MS_U16 * pu16Height,SCALER_WIN eWindow)586 void MDrv_XC_GetDEWidthHeightInDEByPassMode(void *pInstance, MS_U16* pu16Width, MS_U16* pu16Height, SCALER_WIN eWindow)
587 {
588 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
589 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
590
591 MS_U16 u16HSDEnabled = 0x00, u16VSDEnabled = 0x00;
592 #if (HW_DESIGN_3D_VER >= 2)
593 MS_U16 u16PixSep = 0;
594 #endif
595
596 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
597 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
598 if(MDrv_SC_Get_DE_Bypass_Mode(pInstance, eWindow) != TRUE)
599 {
600 printf("[%s,%5d] Cannot get HV width and height under DE mode!! please check your xc lib!\n", __FUNCTION__,__LINE__);
601 }
602
603 #if (HW_DESIGN_3D_VER >= 2)
604 // 3d pixel sep reg will affect hsd/vsd info
605 u16PixSep = SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK02_6B_L);
606 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_6B_L, 0x0, BIT(0)|BIT(1)|BIT(2));
607 #endif
608
609 if (eWindow == MAIN_WINDOW )
610 {
611 // Backup
612 u16HSDEnabled = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_05_L, BIT(15));
613 u16VSDEnabled = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_09_L, BIT(15));
614
615 //F2 force IP read request disable
616 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_02_L, BIT(14), BIT(14));
617 }
618 else
619 {
620 // Backup
621 u16HSDEnabled = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK04_05_L, BIT(15));
622 u16VSDEnabled = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK04_09_L, BIT(15));
623
624 //F1 force IP read request disable
625 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_42_L, BIT(14), BIT(14));
626 }
627
628 // Disable IPM read/write
629 Hal_SC_IP_Memory_Write_Request(pInstance, DISABLE, eWindow);
630 Hal_SC_IP_Memory_Read_Request(pInstance, DISABLE, eWindow);
631
632 // Disable scaling for get correct DE
633 MDrv_SC_Enable_PreScaling(pInstance, FALSE, FALSE, eWindow);
634
635 //IP2 VSD output line count control enable will make sub V DE size wrong
636 HAL_SC_Set_vsd_output_line_count(pInstance, DISABLE, 0x00, eWindow);
637 //IP2 VSD input line count control enable will make sub v DE size wrong
638 HAL_SC_Set_vsd_input_line_count(pInstance, DISABLE, FALSE, 0x00, eWindow);
639
640 // To update VSD, V capture have to set full range to make sure get all line count
641 MDrv_SC_SetFullRangeCapture(pInstance, eWindow);
642
643 // Need to wait more time to make sure getting correct DE V size
644 MDrv_XC_wait_output_vsync(pInstance, 5, 200, MAIN_WINDOW);
645
646 // Get real DE data after VSD / HSD
647 *pu16Height = Hal_SC_get_vsd_line_count(pInstance, eWindow);
648 *pu16Width = Hal_SC_get_hsd_pixel_count(pInstance, eWindow);
649 // Restore
650 MDrv_SC_Enable_PreScaling(pInstance, u16HSDEnabled>>15, u16VSDEnabled>>15, eWindow);
651
652 // force IP read request enable
653 if (eWindow == MAIN_WINDOW )
654 {
655 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_02_L, 0, BIT(14));
656 }
657 else
658 {
659 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_42_L, 0, BIT(14));
660 }
661
662 #if (HW_DESIGN_3D_VER >= 2)
663 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK02_6B_L, u16PixSep, BIT(0)|BIT(1)|BIT(2));
664 #endif
665
666 // Enable IPM read/write
667 Hal_SC_IP_Memory_Write_Request(pInstance, ENABLE, eWindow);
668 Hal_SC_IP_Memory_Read_Request(pInstance, ENABLE, eWindow);
669
670 if(pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u8SyncStatus& XC_MD_INTERLACE_BIT)
671 {
672 *pu16Height <<= 1; //For interlace, multiply 2 for height
673 }
674 }
675
676 //-------------------------------------------------------------------------------------------------
677 /// This function get DE window in DE ByPass Mode. (T12 / T13 can not support HDMI HV mode. So DE window from BK1 can not be retrieved if set to HV mode.)
678 /// We Bypass pre-scaling and get H/V size from BK2 MDrv_SC_get_vsd_line_count & MDrv_SC_get_hsd_pixel_count.
679 /// Prepare this function for using in the feature.
680 /// @param psWin \b OUT: window info to get
681 /// @param eWindow \b IN: which window(main or sub) to get
682 //-------------------------------------------------------------------------------------------------
MApi_XC_GetDEWidthHeightInDEByPassMode_U2(void * pInstance,MS_U16 * pu16Width,MS_U16 * pu16Height,SCALER_WIN eWindow)683 void MApi_XC_GetDEWidthHeightInDEByPassMode_U2(void* pInstance, MS_U16* pu16Width,MS_U16* pu16Height ,SCALER_WIN eWindow)
684 {
685 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
686 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
687 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
688 _XC_ENTRY(pInstance);
689 MDrv_XC_PCMonitor_GetDEWidthHeightInDEByPassMode(pInstance, pu16Width, pu16Height, eWindow);
690 _XC_RETURN(pInstance);
691 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
692 }
693
MApi_XC_GetDEWidthHeightInDEByPassMode(MS_U16 * pu16Width,MS_U16 * pu16Height,SCALER_WIN eWindow)694 void MApi_XC_GetDEWidthHeightInDEByPassMode(MS_U16* pu16Width,MS_U16* pu16Height ,SCALER_WIN eWindow)
695 {
696 if (pu32XCInst == NULL)
697 {
698 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
699 return;
700 }
701
702 stXC_GET_DE_WIN_WIDTH_HEIGHT_IN_DE_BYPASS_MODE XCArgs;
703 XCArgs.pu16Width = pu16Width;
704 XCArgs.pu16Height = pu16Height;
705 XCArgs.eWindow = eWindow;
706
707 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_DE_WIN_WIDTH_HEIGHT_IN_DE_BYPASS_MODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
708 {
709 printf("Obtain XC engine fail\n");
710 return;
711 }
712 else
713 {
714 return;
715 }
716 }
717
718 //-------------------------------------------------------------------------------------------------
719 /// Get the capture window for specific window
720 /// @param capture_win \b OUT: the window info to get
721 /// @param eWindow \b IN: which window(main or sub) to get
722 //-------------------------------------------------------------------------------------------------
MApi_XC_GetCaptureWindow_U2(void * pInstance,MS_WINDOW_TYPE * capture_win,SCALER_WIN eWindow)723 void MApi_XC_GetCaptureWindow_U2(void* pInstance, MS_WINDOW_TYPE* capture_win, SCALER_WIN eWindow)
724 {
725 _XC_ENTRY(pInstance);
726 MDrv_XC_GetCaptureWindow(pInstance, capture_win, eWindow);
727 _XC_RETURN(pInstance);
728 }
729
MApi_XC_GetCaptureWindow(MS_WINDOW_TYPE * capture_win,SCALER_WIN eWindow)730 void MApi_XC_GetCaptureWindow(MS_WINDOW_TYPE* capture_win, SCALER_WIN eWindow)
731 {
732 if (pu32XCInst == NULL)
733 {
734 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
735 return;
736 }
737
738 stXC_GET_CAPTURE_WINDOW XCArgs;
739 XCArgs.capture_win = capture_win;
740 XCArgs.eWindow = eWindow;
741
742 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_CAPTURE_WINDOW, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
743 {
744 printf("Obtain XC engine fail\n");
745 return;
746 }
747 else
748 {
749 return;
750 }
751 }
752
753 //-------------------------------------------------------------------------------------------------
754 /// Set the Vertical start of capture window for specific window
755 /// @param u16Vstart \b IN: the window info to get
756 /// @param eWindow \b IN: which window(main or sub) to set
757 //-------------------------------------------------------------------------------------------------
MDrv_XC_SetCaptureWindowVstart(void * pInstance,MS_U16 u16Vstart,SCALER_WIN eWindow)758 void MDrv_XC_SetCaptureWindowVstart(void *pInstance, MS_U16 u16Vstart , SCALER_WIN eWindow)
759 {
760 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
761 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
762 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
763 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
764 gSrcInfo[eWindow].stCapWin.y = u16Vstart;
765 Hal_SC_ip_set_capture_v_start(pInstance, u16Vstart, eWindow);
766 }
767
MDrv_XC_SetCaptureWindowVstart_with_Menuload(void * pInstance,MS_U16 u16Vstart,SCALER_WIN eWindow)768 void MDrv_XC_SetCaptureWindowVstart_with_Menuload(void *pInstance, MS_U16 u16Vstart , SCALER_WIN eWindow)
769 {
770 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
771 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
772 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
773 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
774 gSrcInfo[eWindow].stCapWin.y = u16Vstart;
775 Hal_SC_ip_set_capture_v_start_with_Menuload(pInstance, u16Vstart, eWindow);
776 }
777
MApi_XC_SetCaptureWindowVstart_U2(void * pInstance,MS_U16 u16Vstart,SCALER_WIN eWindow)778 void MApi_XC_SetCaptureWindowVstart_U2(void* pInstance, MS_U16 u16Vstart , SCALER_WIN eWindow)
779 {
780 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
781 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
782 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
783 _XC_ENTRY(pInstance);
784 MDrv_XC_SetCaptureWindowVstart_with_Menuload(pInstance, u16Vstart, eWindow);
785 _XC_RETURN(pInstance);
786 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
787 return;
788 }
789
MApi_XC_SetCaptureWindowVstart(MS_U16 u16Vstart,SCALER_WIN eWindow)790 void MApi_XC_SetCaptureWindowVstart(MS_U16 u16Vstart , SCALER_WIN eWindow)
791 {
792 if (pu32XCInst == NULL)
793 {
794 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
795 return;
796 }
797
798 stXC_SET_CAPTURE_WINDOW_VSTART XCArgs;
799 XCArgs.u16Vstart = u16Vstart;
800 XCArgs.eWindow = eWindow;
801
802 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_CAPTURE_WINDOW_VSTART, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
803 {
804 printf("Obtain XC engine fail\n");
805 return;
806 }
807 else
808 {
809 return;
810 }
811 }
812
813 //-------------------------------------------------------------------------------------------------
814 /// Set the horizontal start of capture window for specific window
815 /// @param u16Hstart \b IN: the window info to get
816 /// @param eWindow \b IN: which window(main or sub) to set
817 //-------------------------------------------------------------------------------------------------
MDrv_XC_SetCaptureWindowHstart(void * pInstance,MS_U16 u16Hstart,SCALER_WIN eWindow)818 void MDrv_XC_SetCaptureWindowHstart(void *pInstance, MS_U16 u16Hstart , SCALER_WIN eWindow)
819 {
820 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
821 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
822 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
823 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
824 gSrcInfo[eWindow].stCapWin.x = u16Hstart;
825 Hal_SC_ip_set_capture_h_start(pInstance, u16Hstart, eWindow);
826 }
827
MDrv_XC_SetCaptureWindowHstart_with_Menuload(void * pInstance,MS_U16 u16Hstart,SCALER_WIN eWindow)828 void MDrv_XC_SetCaptureWindowHstart_with_Menuload(void *pInstance, MS_U16 u16Hstart , SCALER_WIN eWindow)
829 {
830 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
831 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
832 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
833 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
834 gSrcInfo[eWindow].stCapWin.x = u16Hstart;
835 Hal_SC_ip_set_capture_h_start_with_Menuload(pInstance, u16Hstart, eWindow);
836 }
837
MApi_XC_SetCaptureWindowHstart_U2(void * pInstance,MS_U16 u16Hstart,SCALER_WIN eWindow)838 void MApi_XC_SetCaptureWindowHstart_U2(void* pInstance, MS_U16 u16Hstart , SCALER_WIN eWindow)
839 {
840 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
841 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
842 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
843 _XC_ENTRY(pInstance);
844 MDrv_XC_SetCaptureWindowHstart_with_Menuload(pInstance, u16Hstart, eWindow);
845 _XC_RETURN(pInstance);
846 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
847 return;
848 }
849
MApi_XC_SetCaptureWindowHstart(MS_U16 u16Hstart,SCALER_WIN eWindow)850 void MApi_XC_SetCaptureWindowHstart(MS_U16 u16Hstart , SCALER_WIN eWindow)
851 {
852 if (pu32XCInst == NULL)
853 {
854 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
855 return;
856 }
857
858 stXC_SET_CAPTURE_WINDOW_HSTART XCArgs;
859 XCArgs.u16Hstart = u16Hstart;
860 XCArgs.eWindow = eWindow;
861
862 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_CAPTURE_WINDOW_HSTART, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
863 {
864 printf("Obtain XC engine fail\n");
865 return;
866 }
867 else
868 {
869 return;
870 }
871 }
872
873 //-------------------------------------------------------------------------------------------------
874 /// Set the Vertical size of capture window for specific window
875 /// @param u16Vsize \b IN: the window info to get
876 /// @param eWindow \b IN: which window(main or sub) to set
877 //-------------------------------------------------------------------------------------------------
MApi_XC_SetCaptureWindowVsize_U2(void * pInstance,MS_U16 u16Vsize,SCALER_WIN eWindow)878 void MApi_XC_SetCaptureWindowVsize_U2(void* pInstance, MS_U16 u16Vsize , SCALER_WIN eWindow)
879 {
880 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
881 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
882 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
883 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
884 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
885 _XC_ENTRY(pInstance);
886 gSrcInfo[eWindow].stCapWin.height = u16Vsize;
887 Hal_SC_ip_set_capture_v_size(pInstance, u16Vsize, eWindow);
888 _XC_RETURN(pInstance);
889 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
890
891 }
892
MApi_XC_SetCaptureWindowVsize(MS_U16 u16Vsize,SCALER_WIN eWindow)893 void MApi_XC_SetCaptureWindowVsize(MS_U16 u16Vsize , SCALER_WIN eWindow)
894 {
895 if (pu32XCInst == NULL)
896 {
897 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
898 return;
899 }
900
901 stXC_SET_CAPTURE_WINDOW_VSIZE XCArgs;
902 XCArgs.u16Vsize = u16Vsize;
903 XCArgs.eWindow = eWindow;
904
905 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_CAPTURE_WINDOW_VSIZE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
906 {
907 printf("Obtain XC engine fail\n");
908 return;
909 }
910 else
911 {
912 return;
913 }
914 }
915
916 //-------------------------------------------------------------------------------------------------
917 /// Set the Horizontal size of capture window for specific window
918 /// @param u16Hsize \b IN: the window info to get
919 /// @param eWindow \b IN: which window(main or sub) to set
920 //-------------------------------------------------------------------------------------------------
MApi_XC_SetCaptureWindowHsize_U2(void * pInstance,MS_U16 u16Hsize,SCALER_WIN eWindow)921 void MApi_XC_SetCaptureWindowHsize_U2(void* pInstance, MS_U16 u16Hsize , SCALER_WIN eWindow)
922 {
923 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
924 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
925 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
926 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
927 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
928 _XC_ENTRY(pInstance);
929 gSrcInfo[eWindow].stCapWin.width = u16Hsize;
930 Hal_SC_ip_set_capture_h_size(pInstance, u16Hsize, eWindow);
931 _XC_RETURN(pInstance);
932 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
933 }
934
MApi_XC_SetCaptureWindowHsize(MS_U16 u16Hsize,SCALER_WIN eWindow)935 void MApi_XC_SetCaptureWindowHsize(MS_U16 u16Hsize , SCALER_WIN eWindow)
936 {
937 if (pu32XCInst == NULL)
938 {
939 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
940 return;
941 }
942
943 stXC_SET_CAPTURE_WINDOW_HSIZE XCArgs;
944 XCArgs.u16Hsize = u16Hsize;
945 XCArgs.eWindow = eWindow;
946
947 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_CAPTURE_WINDOW_HSIZE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
948 {
949 printf("Obtain XC engine fail\n");
950 return;
951 }
952 else
953 {
954 return;
955 }
956 }
957
MDrv_XC_SetCaptureWindow(void * pInstance,MS_WINDOW_TYPE * pstCaptureWin,SCALER_WIN eWindow,MS_BOOL bFire)958 void MDrv_XC_SetCaptureWindow(void *pInstance, MS_WINDOW_TYPE* pstCaptureWin, SCALER_WIN eWindow, MS_BOOL bFire)
959 {
960
961 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
962 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
963 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
964 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
965 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
966
967 EN_MUTE_TYPE enMuteType = E_MAIN_WINDOW_MUTE;
968 switch(eWindow)
969 {
970 case MAIN_WINDOW:
971 enMuteType = E_MAIN_WINDOW_MUTE;
972 break;
973 case SUB_WINDOW:
974 enMuteType = E_SUB_WINDOW_MUTE;
975 break;
976 default:
977 break;
978 }
979
980 if ((MDrv_XC_MLoad_GetStatus(pInstance) == E_MLOAD_ENABLED) && (!MDrv_SC_GetForceWrite(enMuteType)) && (!MDrv_SC_GetForceWrite(E_PANEL_MUTE)))
981 {
982 _MLOAD_ENTRY(pInstance);
983 if(eWindow == MAIN_WINDOW)
984 {
985
986 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK01_04_L, (MS_U16)(pstCaptureWin->y), 0xFFFF);
987 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK01_05_L, (MS_U16)(pstCaptureWin->x), 0xFFFF);
988 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK01_06_L, (MS_U16)(pstCaptureWin->height), 0xFFFF);
989
990 if(SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_07_L, BIT(15)))
991 pstCaptureWin->width |= 0x8000;
992 else
993 pstCaptureWin->width |= 0x0000;
994
995 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK01_07_L, (MS_U16)(pstCaptureWin->width), 0xFFFF);
996 }
997 else if(eWindow == SUB_WINDOW)
998 {
999 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK03_04_L, (MS_U16)(pstCaptureWin->y), 0xFFFF);
1000 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK03_05_L, (MS_U16)(pstCaptureWin->x), 0xFFFF);
1001 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK03_06_L, (MS_U16)(pstCaptureWin->height), 0xFFFF);
1002 if(SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK03_07_L, BIT(15)))
1003 pstCaptureWin->width |= 0x8000;
1004 else
1005 pstCaptureWin->width |= 0x0000;
1006
1007 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK03_07_L, (MS_U16)(pstCaptureWin->width), 0xFFFF);
1008 }
1009 if(bFire == TRUE)
1010 {
1011 if (!MDrv_XC_MLoad_Fire(pInstance, TRUE))
1012 {
1013 printf("Error: Set MLoad Fire Error!!!!\n ");
1014 }
1015 }
1016 _MLOAD_RETURN(pInstance);
1017 }
1018 else
1019 {
1020 Hal_SC_ip_set_capture_h_start(pInstance, pstCaptureWin->x,eWindow);
1021 Hal_SC_ip_set_capture_v_start(pInstance, pstCaptureWin->y,eWindow);
1022 Hal_SC_ip_set_capture_h_size(pInstance, pstCaptureWin->width,eWindow);
1023 Hal_SC_ip_set_capture_v_size(pInstance, pstCaptureWin->height,eWindow);
1024 }
1025 }
1026
1027 //-------------------------------------------------------------------------------------------------
1028 /// enable or disable the Auto Gain for specific window
1029 /// @param u8Enable \b IN: enable or disable
1030 /// @param eWindow \b IN: which window(main or sub) to set
1031 //-------------------------------------------------------------------------------------------------
MApi_XC_AutoGainEnable(void * pInstance,MS_U8 u8Enable,SCALER_WIN eWindow)1032 void MApi_XC_AutoGainEnable(void *pInstance, MS_U8 u8Enable , SCALER_WIN eWindow)
1033 {
1034 _XC_ENTRY(pInstance);
1035 Hal_SC_ip_set_auto_gain_function(pInstance, u8Enable, eWindow);
1036 _XC_RETURN(pInstance);
1037 }
1038
MApi_XC_SetFIRDownSampleDivider(void * pInstance,MS_U8 u8Enable,MS_U16 u16OverSamplingCount,SCALER_WIN eWindow)1039 void MApi_XC_SetFIRDownSampleDivider(void *pInstance, MS_U8 u8Enable , MS_U16 u16OverSamplingCount , SCALER_WIN eWindow )
1040 {
1041 _XC_ENTRY(pInstance);
1042 Hal_SC_ip_set_fir_down_sample_divider(pInstance, u8Enable, u16OverSamplingCount ,eWindow);
1043 _XC_RETURN(pInstance);
1044 }
1045
1046 //-------------------------------------------------------------------------------------------------
MApi_XC_EnableIPAutoNoSignal_U2(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)1047 E_APIXC_ReturnValue MApi_XC_EnableIPAutoNoSignal_U2(void* pInstance, MS_BOOL bEnable, SCALER_WIN eWindow )
1048 {
1049 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1050 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1051 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1052
1053 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1054 _XC_ENTRY(pInstance);
1055 if(Hal_XC_MApi_XC_IPAutoNoSignal_GetCaps())
1056 {
1057 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1058 gSrcInfo[eWindow].bAutoNoSignalEnabled = bEnable;
1059
1060 if(bEnable==DISABLE)
1061 {
1062 Hal_SC_ip_set_IPAutoNoSignal(pInstance, bEnable,eWindow);
1063 }
1064 }
1065 _XC_RETURN(pInstance);
1066 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1067 return E_APIXC_RET_OK;
1068 }
1069
MApi_XC_EnableIPAutoNoSignal(MS_BOOL bEnable,SCALER_WIN eWindow)1070 E_APIXC_ReturnValue MApi_XC_EnableIPAutoNoSignal(MS_BOOL bEnable, SCALER_WIN eWindow )
1071 {
1072 if (pu32XCInst == NULL)
1073 {
1074 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1075 return E_APIXC_RET_FAIL;
1076 }
1077
1078 stXC_SET_IPAUTONOSIGNAL XCArgs;
1079 XCArgs.bEnable = bEnable;
1080 XCArgs.eWindow = eWindow;
1081 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
1082
1083 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_IPAUTONOSIGNAL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1084 {
1085 printf("Obtain XC engine fail\n");
1086 return E_APIXC_RET_FAIL;
1087 }
1088 else
1089 {
1090 return XCArgs.eReturnValue;
1091 }
1092 }
1093
MApi_XC_GetIPAutoNoSignal_U2(void * pInstance,SCALER_WIN eWindow)1094 MS_BOOL MApi_XC_GetIPAutoNoSignal_U2(void* pInstance, SCALER_WIN eWindow )
1095 {
1096 MS_BOOL bReturn = FALSE;
1097 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1098 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1099 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1100 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1101 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1102 bReturn = gSrcInfo[eWindow].bAutoNoSignalEnabled;
1103 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1104 return bReturn;
1105 }
1106
MApi_XC_GetIPAutoNoSignal(SCALER_WIN eWindow)1107 MS_BOOL MApi_XC_GetIPAutoNoSignal(SCALER_WIN eWindow )
1108 {
1109 if (pu32XCInst == NULL)
1110 {
1111 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1112 return FALSE;
1113 }
1114
1115 stXC_GET_IPAUTONOSIGNAL XCArgs;
1116 XCArgs.eWindow = eWindow;
1117 XCArgs.bReturnValue = FALSE;
1118
1119 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_IPAUTONOSIGNAL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1120 {
1121 printf("Obtain XC engine fail\n");
1122 return FALSE;
1123 }
1124 else
1125 {
1126 return XCArgs.bReturnValue;
1127 }
1128 }
1129
MDrv_SC_ForceInterlaceInPMode(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)1130 E_APIXC_ReturnValue MDrv_SC_ForceInterlaceInPMode(void *pInstance, MS_BOOL bEnable, SCALER_WIN eWindow)
1131 {
1132 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1133 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1134 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1135 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1136 _XC_ENTRY(pInstance);
1137
1138 gSrcInfo[eWindow].Status2.bForceInterlaceInPMode = bEnable;
1139
1140 if (MDrv_XC_GetForceiSupportType(pInstance) == ForceI_SW)
1141 {
1142 if (bEnable)
1143 {
1144 if (eWindow == MAIN_WINDOW)
1145 {
1146 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_21_L, BIT(1) | BIT(0), BIT(1) | BIT(0) | BIT(8));
1147 }
1148 else
1149 {
1150 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK03_21_L, BIT(1) | BIT(0), BIT(1) | BIT(0) | BIT(8));
1151 }
1152 }
1153 else
1154 {
1155 if (eWindow == MAIN_WINDOW)
1156 {
1157 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_21_L, 0x00 , BIT(1) | BIT(0));
1158 }
1159 else
1160 {
1161 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK03_21_L, 0x00 , BIT(1) | BIT(0));
1162 }
1163 }
1164 }
1165 else if (MDrv_XC_GetForceiSupportType(pInstance) == ForceI_HW)
1166 {
1167 if(bEnable)
1168 {
1169 // memsyn interlace mode invert
1170 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_05_L, BIT(10), BIT(10));
1171 }
1172 else
1173 {
1174 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_05_L, 0, BIT(10));
1175 }
1176 }
1177 else // ((MDrv_XC_GetForceiSupportType() == ForceI_AUTO))
1178 {
1179 // don't have to set anything, HW will auto do it.
1180 }
1181
1182 _XC_RETURN(pInstance);
1183
1184 return E_APIXC_RET_OK;
1185
1186 }
1187
MDrv_SC_GetInterlaceInPModeStatus(void * pInstance,SCALER_WIN eWindow)1188 MS_BOOL MDrv_SC_GetInterlaceInPModeStatus(void *pInstance, SCALER_WIN eWindow )
1189 {
1190 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1191 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1192 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1193 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1194 return gSrcInfo[eWindow].Status2.bForceInterlaceInPMode;
1195 }
1196
1197 //-------------------------------------------------------------------------------------------------
1198 /// Check whether Auto gain result is ready or not
1199 /// @param eWindow \b IN: which window we are going to query
1200 /// @return @ref MS_BOOL
1201 //-------------------------------------------------------------------------------------------------
MApi_XC_IsAutoGainResultReady(void * pInstance,SCALER_WIN eWindow)1202 MS_BOOL MApi_XC_IsAutoGainResultReady(void *pInstance, SCALER_WIN eWindow)
1203 {
1204 MS_BOOL bAuto_gain;
1205 _XC_ENTRY(pInstance);
1206 bAuto_gain = Hal_SC_ip_is_auto_gain_result_ready(pInstance, eWindow);
1207 _XC_RETURN(pInstance);
1208 return bAuto_gain;// Hal_SC_ip_is_auto_gain_result_ready(eWindow);
1209 }
1210
1211 //-------------------------------------------------------------------------------------------------
1212 /// Get auto gain min value status
1213 /// @param eWindow \b IN: which window we are going to query
1214 /// @return @ref MS_BOOL
1215 //-------------------------------------------------------------------------------------------------
MApi_XC_GetAutoGainMinValueStatus(void * pInstance,SCALER_WIN eWindow)1216 MS_U8 MApi_XC_GetAutoGainMinValueStatus(void *pInstance, SCALER_WIN eWindow)
1217 {
1218 return Hal_SC_ip_auto_gain_min_value_status(pInstance, eWindow);
1219 }
1220
1221 //-------------------------------------------------------------------------------------------------
1222 /// Check whether Auto gain max value result
1223 /// @param eWindow \b IN: which window we are going to query
1224 /// @return @ref MS_BOOL
1225 //-------------------------------------------------------------------------------------------------
MApi_XC_GetAutoGainMaxValueStatus(void * pInstance,SCALER_WIN eWindow)1226 MS_U8 MApi_XC_GetAutoGainMaxValueStatus(void *pInstance, SCALER_WIN eWindow)
1227 {
1228 return Hal_SC_ip_auto_gain_max_value_status(pInstance, eWindow);
1229 }
1230
1231
1232 //-------------------------------------------------------------------------------------------------
1233 /// Get the average data from hardware report
1234 /// @return @ref MS_AUTOADC_TYPE
1235 //-------------------------------------------------------------------------------------------------
MApi_XC_GetAverageDataFromHWReport(void * pInstance)1236 MS_AUTOADC_TYPE MApi_XC_GetAverageDataFromHWReport(void *pInstance)
1237 {
1238 MS_U16 u16MaxR,u16MaxG,u16MaxB;
1239 MS_U16 u16MinR,u16MinG,u16MinB;
1240 MS_AUTOADC_TYPE ptAdcData;
1241 MS_U8 u8AvgCnt;
1242 MS_U8 i;
1243 MS_U8 u8TimeoutCnt = 0;
1244 //MS_U8 u8VSyncTime; // VSync time
1245 //u8VSyncTime = msAPI_Scaler_CalculateVSyncTime(g_wVerticalTotal, g_wHorizontalPeriod); // get VSync time
1246
1247 ptAdcData.u16CH_AVG[0] = ptAdcData.u16CH_AVG[1] = ptAdcData.u16CH_AVG[2] = 0;
1248 u8AvgCnt = 4;
1249 Hal_SC_autogain_enable(pInstance, ENABLE, MAIN_WINDOW); //auto gain enable
1250 msg_sc_ip( printf("check rdy bit\n") );
1251 //MsOS_DelayTask(u8VSyncTime * 3); // wait stable
1252
1253 //Auto Gain Result Ready. #0: Result not ready.
1254
1255 for(i=0; i<u8AvgCnt; i++)
1256 {
1257 for(u8TimeoutCnt = 0; u8TimeoutCnt < 10; u8TimeoutCnt++)
1258 {
1259 while(Hal_SC_autogain_status(pInstance, MAIN_WINDOW) == 1); // skip 1st v blanking
1260 while(Hal_SC_autogain_status(pInstance, MAIN_WINDOW) == 0); // wait until next v blanking
1261 // ATG ready, read min/max RGB
1262 u16MinR = Hal_SC_rgb_average_info(pInstance, R_CHANNEL_MIN, MAIN_WINDOW);
1263 u16MaxR = Hal_SC_rgb_average_info(pInstance, R_CHANNEL_MAX, MAIN_WINDOW);
1264 u16MinG = Hal_SC_rgb_average_info(pInstance, G_CHANNEL_MIN, MAIN_WINDOW);
1265 u16MaxG = Hal_SC_rgb_average_info(pInstance, G_CHANNEL_MAX, MAIN_WINDOW);
1266 u16MinB = Hal_SC_rgb_average_info(pInstance, B_CHANNEL_MIN, MAIN_WINDOW);
1267 u16MaxB = Hal_SC_rgb_average_info(pInstance, B_CHANNEL_MAX, MAIN_WINDOW);
1268
1269 if(Hal_SC_autogain_status(pInstance, MAIN_WINDOW))
1270 {
1271
1272 ptAdcData.u16CH_AVG[0]+=(u16MinR+u16MaxR+1)/2;
1273 ptAdcData.u16CH_AVG[1]+=(u16MinG+u16MaxG+1)/2;
1274 ptAdcData.u16CH_AVG[2]+=(u16MinB+u16MaxB+1)/2;
1275
1276 msg_sc_ip( printf("MAX[%04d,%04d,%04d]\n",u16MaxR,u16MaxG,u16MaxB) );
1277 msg_sc_ip( printf("MIN[%04d,%04d,%04d]\n",u16MinR,u16MinG,u16MinR) );
1278 break;
1279 }
1280 else
1281 {
1282 msg_sc_ip( printf("Avg err, again\n") );
1283 }
1284 }
1285 }
1286 ptAdcData.u16CH_AVG[0] /= u8AvgCnt;
1287 ptAdcData.u16CH_AVG[1] /= u8AvgCnt;
1288 ptAdcData.u16CH_AVG[2] /= u8AvgCnt;
1289
1290 msg_sc_ip( printf("ptAdcData[%04d,%04d,%04d]\n",ptAdcData.u16CH_AVG[0],ptAdcData.u16CH_AVG[1],ptAdcData.u16CH_AVG[2]) );
1291 return ptAdcData;
1292 }
1293
1294 #if DATA_CONVERT_NEON_OPTIMIZE_ENABLE
1295 //ARM Neon Optimize function for XC_FRC buffer data to normal ARGB8888
MDrv_XC_FRC_Rgb888_2_Argb8888_Neon(MS_U32 u32DstAddr,MS_U32 u32SrcAddr,MS_U32 u32PixelNum)1296 void MDrv_XC_FRC_Rgb888_2_Argb8888_Neon(MS_U32 u32DstAddr, MS_U32 u32SrcAddr, MS_U32 u32PixelNum)
1297 {
1298 __asm__ __volatile__(
1299 " LDR R0, %0 \t\n"
1300 " LDR R1, %1 \t\n"
1301 " LDR R2, %2 \t\n"
1302 " VMOV.I8 D3, #0xFF \t\n" //Set A=0xFF
1303 "1: SUB R2, R2, #16 \t\n" //Convert 16 pixel eanch time
1304 "2: VLDR D1, [R1] \t\n" //load G
1305 " VLDR D0, [R1,#16] \t\n" //load B
1306 " VLDR D2, [R1,#32] \t\n" //load R
1307 " VST4.8 {D0,D1,D2,D3}, [R0]! \t\n" //Store 8 pixel's as ARGB8888
1308 " ADD R1, R1, #8 \t\n"
1309 " TST R0, #0x3F \t\n" //if we finished 16 pixel convert ?
1310 " BNE 2b \t\n" //No, jump
1311 " ADD R1, R1, #32 \t\n" //Jump to next 16 pixel
1312 " ORRS R2, R2, #0x0 \t\n" //Is all pixel finished
1313 " BNE 1b \t\n" //No, jump
1314 : :"m"(u32DstAddr), "m"(u32SrcAddr), "m"(u32PixelNum)
1315 :"r0","r1","r2","d0","d1","d2","d3","cc","memory");
1316 }
1317
1318 //ARM Neon Optimize function for XC_FRC buffer data to normal ABGR8888
MDrv_XC_FRC_Rgb888_2_Abgr8888_Neon(MS_VIRT u32DstAddr,MS_VIRT u32SrcAddr,MS_U32 u32PixelNum)1319 void MDrv_XC_FRC_Rgb888_2_Abgr8888_Neon(MS_VIRT u32DstAddr, MS_VIRT u32SrcAddr, MS_U32 u32PixelNum)
1320 {
1321 __asm__ __volatile__(
1322 " LDR R0, %0 \t\n"
1323 " LDR R1, %1 \t\n"
1324 " LDR R2, %2 \t\n"
1325 " VMOV.I8 D3, #0xFF \t\n" //Set A=0xFF
1326 "1: SUB R2, R2, #16 \t\n" //Convert 16 pixel eanch time
1327 "2: VLDR D1, [R1] \t\n" //load G
1328 " VLDR D2, [R1,#16] \t\n" //load B
1329 " VLDR D0, [R1,#32] \t\n" //load R
1330 " VST4.8 {D0,D1,D2,D3}, [R0]! \t\n" //Store 8 pixel's as ABGR8888
1331 " ADD R1, R1, #8 \t\n"
1332 " TST R0, #0x3F \t\n" //if we finished 16 pixel convert ?
1333 " BNE 2b \t\n" //No, jump
1334 " ADD R1, R1, #32 \t\n" //Jump to next 16 pixel
1335 " ORRS R2, R2, #0x0 \t\n" //Is all pixel finished
1336 " BNE 1b \t\n" //No, jump
1337 : :"m"(u32DstAddr), "m"(u32SrcAddr), "m"(u32PixelNum)
1338 :"r0","r1","r2","d0","d1","d2","d3","cc","memory");
1339 }
1340 #endif
1341
MDrv_XC_Access_BufferData(void * pInstance,E_XC_OUTPUTDATA_TYPE eBufType,MS_WINDOW_TYPE * pMemRect,void * pDataBuf,MS_WINDOW_TYPE * pSrcRect,SCALER_WIN eWindow,MS_BOOL bIsReadMode)1342 static void MDrv_XC_Access_BufferData(void *pInstance, E_XC_OUTPUTDATA_TYPE eBufType, MS_WINDOW_TYPE *pMemRect, void *pDataBuf, MS_WINDOW_TYPE *pSrcRect, SCALER_WIN eWindow, MS_BOOL bIsReadMode)
1343 {
1344 if (pDataBuf == NULL)
1345 {
1346 MS_CRITICAL_MSG(printf("Data buffer is NULL! \n"));
1347 return;
1348 }
1349
1350 if ( (eBufType != E_XC_OUTPUTDATA_FRC_RGB8BITS)
1351 &&((pMemRect == NULL) || ((!bIsReadMode) && (pSrcRect == NULL))))
1352 {
1353 MS_CRITICAL_MSG(printf("---%s:%d Data rectangle or memory rectangle is NULL! \n", __FUNCTION__, __LINE__));
1354 return;
1355 }
1356 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1357 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1358
1359 void *pPoint;
1360 volatile MS_PHY pMEM;
1361 volatile MS_U8 *pMEM_temp;
1362
1363 MS_U16 u16LBOffset = 0;
1364 MS_U16 u16PointSize = 0;
1365 MS_U8 u8BytePerTwoPixel = 0;
1366 MS_U16 x, y;
1367 MS_U16 x0, x1, y0, y1;
1368 MS_U8 u8MemFmt = SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK12_02_L) & 0x0F;
1369 MS_U8 u8FieldMode = SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK12_19_L) & 0x07;
1370 MS_U8 u8FieldNum;
1371
1372 MS_BOOL bHmirror, bVmirror;
1373
1374 MS_PHY u32Y_Offset, u32X_Offset;
1375 MS_U8 u8Discardpixels = 0;
1376 MS_U8 u8Offsetpixels = 0;
1377 MS_U8 u8pixels_per_unit = OFFSET_PIXEL_ALIGNMENT;
1378
1379 MS_U16 xRegion, accessStart;
1380 MS_S8 yNext, xNext, accessNext;
1381 MS_U8 u8packinginterlacedshift = 0;
1382 MS_U16 u16YCSeparateOffset = BYTE_PER_WORD;
1383 MS_U8 u8FrameNum;
1384 MS_U32 u32JumpOffset = 0;
1385 MS_U32 u32Accesspixel;
1386 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1387 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1388 SC_FRAMEBUF_INFO_t FBInfo;
1389 SC_MIUSEL_t FBMiuSelInfo;
1390 MS_PHY u32Main_FB_Start_Addr = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Main_FB_Start_Addr;
1391 MS_PHY u32Sub_FB_Start_Addr = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32Sub_FB_Start_Addr;
1392
1393 Hal_SC_get_framebuf_Info(pInstance, &FBInfo, eWindow);
1394 Hal_SC_get_miusel(pInstance, &FBMiuSelInfo);
1395
1396 if(u32Main_FB_Start_Addr >= HAL_MIU1_BASE)
1397 {
1398 u32Main_FB_Start_Addr -= HAL_MIU1_BASE;
1399 }
1400
1401 if(u32Sub_FB_Start_Addr >= HAL_MIU1_BASE)
1402 {
1403 u32Sub_FB_Start_Addr -= HAL_MIU1_BASE;
1404 }
1405
1406
1407 if(eBufType <= E_XC_OUTPUTDATA_4228BITS)
1408 {
1409 if((pMemRect!=NULL) &&
1410 ((pMemRect->x >= gSrcInfo[eWindow].u16H_SizeAfterPreScaling) ||
1411 ((pMemRect->x + pMemRect->width) > gSrcInfo[eWindow].u16H_SizeAfterPreScaling) ||
1412 (pMemRect->y >= gSrcInfo[eWindow].u16V_SizeAfterPreScaling ) ||
1413 ((pMemRect->y + pMemRect->height) > gSrcInfo[eWindow].u16V_SizeAfterPreScaling)))
1414 {
1415 MS_CRITICAL_MSG(printf("---%s:%d invalid parameter!\n", __FUNCTION__, __LINE__));
1416 return;
1417 }
1418 }
1419 else if(eBufType <= E_XC_OUTPUTDATA_FRC_4228BITS)
1420 {
1421 if( (pMemRect!=NULL)
1422 &&( ((pMemRect->x + pMemRect->width) > gSrcInfo[eWindow].Status2.stXCPanelDefaultTiming.u16Width)
1423 ||((pMemRect->y + pMemRect->height) > gSrcInfo[eWindow].Status2.stXCPanelDefaultTiming.u16Height)
1424 ||(pMemRect->x >= gSrcInfo[eWindow].Status2.stXCPanelDefaultTiming.u16Width)
1425 ||(pMemRect->y >= gSrcInfo[eWindow].Status2.stXCPanelDefaultTiming.u16Height)))
1426 {
1427 MS_CRITICAL_MSG(printf("---%s:%d invalid parameter!\n", __FUNCTION__, __LINE__));
1428 return;
1429 }
1430 }
1431
1432 if(eWindow == MAIN_WINDOW)
1433 {
1434 bHmirror = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_03_L, BIT(12)) >> 12;
1435 bVmirror = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_03_L, BIT(13)) >> 13;
1436 }
1437 else
1438 {
1439 bHmirror = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_43_L, BIT(12)) >> 12;
1440 bVmirror = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_43_L, BIT(13)) >> 13;
1441 }
1442
1443 u8FrameNum = FBInfo.u8FBNum;
1444
1445 //F2 select 8-field(0), 10-field(1), 12-field(2), 14-field(3), 16-field(4) mem config
1446 u8FieldNum = 8 + u8FieldMode*2;
1447 if(eBufType == E_XC_OUTPUTDATA_FRC_RGB8BITS)
1448 {
1449 #if 0 //FRC_INSIDE
1450 MS_VIRT *pu32Dstaddr=NULL;
1451 MS_U32 u32PixelNum=0;
1452 MS_VIRT *pu8Srcaddr=NULL;
1453 MS_U8 u8OutputBytePerPixel=4,u8FRCMemBytePerPixel=3, u8ReadBank=0; //read bank=Wbank number - 1;
1454 MS_PHY u32DstPhyAddr = (MS_PHY)pDataBuf;
1455 MS_PHY u32SrcPhyAddr = 0, u32Offset = 0;
1456 if(u32DstPhyAddr==0)
1457 {
1458 printf("---%s:%d Wrong Dst address = %lx\n", __FUNCTION__, __LINE__, (MS_U32)u32DstPhyAddr);
1459 return;
1460 }
1461
1462 if(u32DstPhyAddr >= HAL_MIU1_BASE)
1463 {
1464 u32DstPhyAddr -= HAL_MIU1_BASE;
1465 //Hal_SC_set_miusel(1); //Need implement for XC_FRC
1466 }
1467 else
1468 {
1469 //Hal_SC_set_miusel(0); //Need implement for XC_FRC
1470 }
1471
1472 u32Offset = (gSrcInfo[eWindow].Status2.stXCPanelDefaultTiming.u16Width + FRC_OFFSET_PIXEL_ALIGNMENT - 1) & (~(FRC_OFFSET_PIXEL_ALIGNMENT-1));
1473 if (gSrcInfo[eWindow].Status2.bInFRCMode == FALSE)
1474 {
1475 //Non-FRC case, set FRC_IP to enable capture
1476 //only for FRC image capture function, set to 1 frame mode to save memory
1477 u8FrameNum = 1;
1478 u32PixelNum = gSrcInfo[eWindow].Status2.stXCPanelDefaultTiming.u16Width*
1479 gSrcInfo[eWindow].Status2.stXCPanelDefaultTiming.u16Height*
1480 u8FrameNum;
1481 u32SrcPhyAddr = pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Pnl_Misc.FRCInfo.u32FRC_MEMC_MemAddr;
1482 if((u32SrcPhyAddr==0) || (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Pnl_Misc.FRCInfo.u32FRC_MEMC_MemSize < u32PixelNum*u8FRCMemBytePerPixel))
1483 {
1484 printf("---%s:%d Wrong Src address = %lx, %lx\n", __FUNCTION__, __LINE__, (MS_U32)u32SrcPhyAddr, pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Pnl_Misc.FRCInfo.u32FRC_MEMC_MemSize);
1485 return;
1486 }
1487
1488 if(u32SrcPhyAddr >= HAL_MIU1_BASE)
1489 {
1490 u32SrcPhyAddr -= HAL_MIU1_BASE;
1491 //Hal_SC_set_miusel(1); //Need implement for XC_FRC
1492 }
1493 else
1494 {
1495 //Hal_SC_set_miusel(0); //Need implement for XC_FRC
1496 }
1497
1498 SC_W4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK43_08_L, u32SrcPhyAddr/BYTE_PER_WORD);//ipm_base
1499 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK43_01_L, BIT(11), BIT(11)); //Freeze image first to avoid write a wrong base addr
1500 MDrv_XC_wait_output_vsync(pInstance, 1, DEFAULT_OUTPUT_VSYNC_TIMEOUT, eWindow);//Wait base addr and freeze take effect after vsync
1501
1502 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK40_68_L, 0x5000);// arb
1503 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK40_69_L, 0x0420);
1504 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK40_6A_L, 0x5000);
1505 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK40_6B_L, 0x0420);// arb
1506
1507 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK43_50_L, BIT(15), BIT(15)); //by pass compress mode
1508 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK43_02_L, 0x0311);// mem mode user define enable: [0][4] 444 enable (1:444 0:422),
1509 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK43_19_L, u8FrameNum, 0x1F);
1510 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK43_0E_L, gSrcInfo[eWindow].Status2.stXCPanelDefaultTiming.u16Width);//ipm offset
1511 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK43_0F_L, gSrcInfo[eWindow].Status2.stXCPanelDefaultTiming.u16Width);//ipm fetch
1512 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK43_07_L, 0x88, 0xFF); //enable frc_ipm to miu
1513 }
1514 else
1515 {
1516 u32SrcPhyAddr = SC_R4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK43_08_L)*BYTE_PER_WORD;
1517 u8FrameNum = SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK43_19_L) & 0x1F;
1518 u32PixelNum = gSrcInfo[eWindow].Status2.stXCPanelDefaultTiming.u16Width*
1519 gSrcInfo[eWindow].Status2.stXCPanelDefaultTiming.u16Height*
1520 u8FrameNum;
1521 }
1522
1523 if((u32SrcPhyAddr == 0) || (u32PixelNum == 0))
1524 {
1525 printf("---%s %d:Setting error=%lx,%lx\n", __FUNCTION__, __LINE__, u32SrcPhyAddr, u32PixelNum);
1526 return;
1527 }
1528 UNUSED(u8ReadBank);//Add readbank logic here: read bank=Wbank number - 1
1529 pu32Dstaddr = (MS_VIRT *)MsOS_PA2KSEG1(u32DstPhyAddr);
1530 if(0 == pu32Dstaddr)
1531 {
1532 printf("%s :pu32Dstaddr_1 = 0!!,error!!!\n", __FUNCTION__);
1533 assert(pu32Dstaddr != 0);
1534 }
1535 pu8Srcaddr = (MS_VIRT *)MsOS_PA2KSEG1(u32SrcPhyAddr);
1536 if(0 == pu8Srcaddr)
1537 {
1538 printf("%s :pu8Srcaddr_1 = 0!,error!!!\n", __FUNCTION__);
1539 assert(pu8Srcaddr != 0);
1540 }
1541 #ifdef MSOS_TYPE_LINUX
1542 if(pu8Srcaddr == NULL)
1543 {
1544 if (!MsOS_MPool_Mapping(0, u32SrcPhyAddr, u32PixelNum*u8FRCMemBytePerPixel, 1))
1545 {
1546 printf("---%s:%d error, map fail\n", __FUNCTION__, __LINE__);
1547 return;
1548 }
1549 pu8Srcaddr = (MS_VIRT *)MsOS_PA2KSEG1(u32SrcPhyAddr);
1550 if(0 == pu8Srcaddr)
1551 {
1552 printf("%s :pu8Srcaddr_2 = 0!,error!!!\n", __FUNCTION__);
1553 assert(pu8Srcaddr != 0);
1554 }
1555 }
1556
1557 if(pu32Dstaddr == NULL)
1558 {
1559 if (!MsOS_MPool_Mapping(0, u32DstPhyAddr, u32PixelNum*u8OutputBytePerPixel, 1))
1560 {
1561 printf("---%s:%d error, map fail\n", __FUNCTION__, __LINE__);
1562 return;
1563 }
1564 pu32Dstaddr = (MS_VIRT *)MsOS_PA2KSEG1(u32DstPhyAddr);
1565 if(0 == pu32Dstaddr)
1566 {
1567 printf("%s :pu32Dstaddr_2 = 0!,error!!!\n", __FUNCTION__);
1568 assert(pu32Dstaddr != 0);
1569 }
1570 }
1571 #endif
1572 if((pu32Dstaddr == NULL) || (pu8Srcaddr == NULL))
1573 {
1574 printf("---%s:%d error: Address[%lx,%lx] map fail\n", __FUNCTION__, __LINE__, (MS_U32)pu8Srcaddr, (MS_U32)pu32Dstaddr);
1575 return;
1576 }
1577
1578 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK43_01_L, 0, BIT(11));//Un freeze to start capture
1579 MDrv_XC_wait_output_vsync(pInstance, u8FrameNum+1, (u8FrameNum+1)*DEFAULT_OUTPUT_VSYNC_TIMEOUT, eWindow);//If multi frame, try use u8ReadBank to get data to skip wait vsync
1580 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK43_01_L, BIT(11), BIT(11));//Capture done, re-freeze to do image process
1581 MDrv_XC_wait_output_vsync(pInstance, 1, DEFAULT_OUTPUT_VSYNC_TIMEOUT, eWindow);//Wait freeze take effect after vsync
1582 MsOS_ReadMemory();//Flush memory
1583 #if DATA_CONVERT_NEON_OPTIMIZE_ENABLE
1584 MDrv_XC_FRC_Rgb888_2_Abgr8888_Neon(pu32Dstaddr, pu8Srcaddr, u32PixelNum);
1585 #else
1586 MS_U8 u8R=0, u8G=0, u8B=0;
1587 MS_U32 i=0, j=0, u32ARGB=0;
1588 UNUSED(u8OutputBytePerPixel);
1589 do
1590 {
1591 for(j=0; j<BYTE_PER_WORD; j++)
1592 {
1593 u8G = *(pu8Srcaddr+j);
1594 u8B = *(pu8Srcaddr+BYTE_PER_WORD*u8FrameNum+j);
1595 u8R = *(pu8Srcaddr+BYTE_PER_WORD*(u8FrameNum<<1)+j);
1596 u32ARGB = (0xFF<<24) | (u8R<<16) | (u8G<<8) | (u8B);
1597 *(pu32Dstaddr+j)=u32ARGB;
1598 }
1599 i+=BYTE_PER_WORD;
1600 pu8Srcaddr += BYTE_PER_WORD*3*u8FrameNum; // 3 byte/pixel and FramNum frames
1601 pu32Dstaddr += BYTE_PER_WORD;
1602 }while(i<u32PixelNum);
1603 #endif
1604 MsOS_ReadMemory();
1605 #endif //FRC inside
1606 return;
1607 }
1608
1609 //Non-FRC capture case
1610 MsOS_ReadMemory();
1611 #if (_FIELD_PACKING_MODE_SUPPORTED)
1612 if (FBInfo.bMemFormat422 == TRUE)
1613 {
1614 FB_DBG(printf("source is YUV 422 mode\n"));
1615 u16YCSeparateOffset = u8FrameNum * BYTE_PER_WORD;
1616 u8BytePerTwoPixel = FBInfo.u8BitPerPixel * 2 / 8;
1617
1618 if(4 == u8BytePerTwoPixel)
1619 {
1620 u8pixels_per_unit = OFFSET_PIXEL_ALIGNMENT;
1621
1622 if ( FBInfo.bLinearAddrMode )
1623 u32JumpOffset = 0;
1624 else
1625 u32JumpOffset = BYTE_PER_WORD * (u8FrameNum + u8FrameNum -1);
1626
1627 }
1628 else if(5 == u8BytePerTwoPixel)
1629 {
1630 u8pixels_per_unit = OFFSET_PIXEL_ALIGNMENT;
1631
1632 if ( FBInfo.bLinearAddrMode )
1633 u32JumpOffset = 0;
1634 else
1635 u32JumpOffset = BYTE_PER_WORD * (u8FrameNum * 2 + u8FrameNum -1);
1636 }
1637 else if(6 == u8BytePerTwoPixel)
1638 {
1639 u8pixels_per_unit = OFFSET_PIXEL_ALIGNMENT;
1640
1641 if ( FBInfo.bLinearAddrMode )
1642 u32JumpOffset = 0;
1643 else
1644 u32JumpOffset = BYTE_PER_WORD * (u8FrameNum * 3 + u8FrameNum -1);
1645 }
1646 }
1647 else
1648 {
1649 FB_DBG(printf("source is YUV 444 mode, bit: %u\n", FBInfo.u8BitPerPixel));
1650 if( 1 == u8MemFmt)
1651 u8BytePerTwoPixel = 6;
1652 else
1653 u8BytePerTwoPixel = FBInfo.u8BitPerPixel * 2 / 8;
1654
1655 u16YCSeparateOffset = u8FrameNum * BYTE_PER_WORD;
1656
1657 u8pixels_per_unit = OFFSET_PIXEL_ALIGNMENT/2;
1658
1659 }
1660 #else
1661 if (FBInfo.bMemFormat422 == TRUE)
1662 {
1663 FB_DBG(printf("source is YUV 422 mode\n"));
1664 //we will enable BK12_02[9:8] to keep same memory layout, hence, BytePerPixel is 3
1665 // F0 F0 F2 F2 F0 F0 F2 F2 F0 F0 F2 F2
1666 // Y8/C8 Y8/C8 Y8/C8 Y8/C8 LSB YM4 LSB YM4 Y8/C8 Y8/C8 Y8/C8 Y8/C8=>24bit Y10C10M4
1667 // Y8/C8 Y8/C8 Y8/C8 Y8/C8 LSB XXX LSB XXX Y8/C8 Y8/C8 Y8/C8 Y8/C8=>20bit Y10C10
1668 // Y8/C8 Y8/C8 Y8/C8 Y8/C8 XXX YM4 XXX YM4 Y8/C8 Y8/C8 Y8/C8 Y8/C8=>20bit Y8YC8M4
1669 // Y8/C8 Y8/C8 Y8/C8 Y8/C8 XXX XXX XXX XXX Y8/C8 Y8/C8 Y8/C8 Y8/C8=>16bit Y8C8
1670 u8BytePerTwoPixel = FBInfo.u8BitPerPixel * 2 / 8;
1671
1672 if(15 == u8MemFmt)
1673 {
1674 u16YCSeparateOffset = (u8FieldNum/2) * BYTE_PER_WORD;
1675 u8FrameNum = u8FieldNum/2;
1676 u8BytePerTwoPixel = 6;
1677 u8pixels_per_unit = OFFSET_PIXEL_ALIGNMENT;
1678 if ( FBInfo.bLinearAddrMode )
1679 u32JumpOffset = BYTE_PER_WORD * 2;
1680 else
1681 u32JumpOffset = BYTE_PER_WORD * 2 * (u8FieldNum -1); // (u8FieldNum/2 -1)*2 MIU + u8FieldNum/2 MIU (for LSB) + u8FieldNum/2 MIU (for Motion)
1682 }
1683 else if(4 == u8BytePerTwoPixel)
1684 {
1685 u8pixels_per_unit = OFFSET_PIXEL_ALIGNMENT /2;
1686 if ( FBInfo.bLinearAddrMode )
1687 {
1688 u32JumpOffset = 0;
1689 }
1690 else
1691 {
1692 u32JumpOffset = BYTE_PER_WORD * 2;
1693
1694 if (u8FrameNum >= 4)
1695 u8FrameNum = u8FrameNum / 2 ;
1696 }
1697 }
1698 else if(5 == u8BytePerTwoPixel)
1699 {
1700 u8pixels_per_unit = OFFSET_PIXEL_ALIGNMENT;
1701 if ( FBInfo.bLinearAddrMode )
1702 {
1703 u32JumpOffset = BYTE_PER_WORD;
1704 }
1705 else
1706 {
1707 u32JumpOffset = BYTE_PER_WORD * 4;
1708
1709 if (u8FrameNum >= 4)
1710 u8FrameNum = u8FrameNum / 2 ;
1711 }
1712 }
1713 else if(6 == u8BytePerTwoPixel)
1714 {
1715 u8pixels_per_unit = OFFSET_PIXEL_ALIGNMENT;
1716 if ( FBInfo.bLinearAddrMode )
1717 {
1718 u32JumpOffset = BYTE_PER_WORD * 2;
1719 }
1720 else
1721 {
1722 u32JumpOffset = BYTE_PER_WORD * 6;
1723
1724 if (u8FrameNum >= 4)
1725 u8FrameNum = u8FrameNum / 2 ;
1726 }
1727 }
1728 }
1729 else
1730 {
1731 FB_DBG(printf("source is YUV 444 mode, bit: %u\n", FBInfo.u8BitPerPixel));
1732 u8BytePerTwoPixel = FBInfo.u8BitPerPixel * 2 / 8;
1733
1734 if ( FBInfo.bLinearAddrMode )
1735 u32JumpOffset = 0;
1736 else
1737 u32JumpOffset = BYTE_PER_WORD * 2;
1738
1739 if(32 == FBInfo.u8BitPerPixel)
1740 u8pixels_per_unit = OFFSET_PIXEL_ALIGNMENT/2;
1741 else
1742 u8pixels_per_unit = OFFSET_PIXEL_ALIGNMENT;
1743 }
1744 #endif
1745
1746 if(eBufType == E_XC_OUTPUTDATA_RGB10BITS)
1747 {
1748 u16PointSize = sizeof(MS_PIXEL_32BIT);
1749 }
1750 else if(eBufType == E_XC_OUTPUTDATA_RGB8BITS)
1751 {
1752 u16PointSize = sizeof(MS_PIXEL_24BIT);
1753 }
1754 else if(eBufType == E_XC_OUTPUTDATA_4228BITS)
1755 {
1756 u16PointSize = sizeof(MS_PIXEL_422_8BIT);
1757 }
1758
1759 x0 = pMemRect->x;
1760 x1 = pMemRect->x + pMemRect->width -1;
1761 y0 = pMemRect->y;
1762 y1 = pMemRect->y + pMemRect->height -1;
1763
1764 // calculate the MIU counts need to access for H line
1765 xRegion = x1/u8pixels_per_unit - x0/u8pixels_per_unit + 1;
1766
1767 accessStart = 0;
1768 yNext = 1;
1769 xNext = u8pixels_per_unit;
1770 accessNext = 1;
1771
1772 // for mirror mode calculation
1773 //
1774 // (x0,y0) (x1, y1)
1775 // ----------- mirror mode -----------
1776 // | | -------> | |
1777 // ----------- -----------
1778 // (x1, y1) (x0, y0)
1779 // access from x0 to x1, from y0 to y1, decrease to next point
1780 if (bHmirror)
1781 {
1782 x0 = (gSrcInfo[eWindow].u16H_SizeAfterPreScaling - pMemRect->x) -1;
1783 x1 = gSrcInfo[eWindow].u16H_SizeAfterPreScaling - (pMemRect->x + pMemRect->width);
1784
1785 xRegion = x0/u8pixels_per_unit - x1/u8pixels_per_unit + 1;
1786 accessStart = u8pixels_per_unit -1;
1787 xNext = -1 * u8pixels_per_unit;
1788 accessNext = -1;
1789 }
1790 if (bVmirror)
1791 {
1792 y0 = gSrcInfo[eWindow].u16V_SizeAfterPreScaling - pMemRect->y -1;
1793 y1 = gSrcInfo[eWindow].u16V_SizeAfterPreScaling - (pMemRect->y + pMemRect->height);
1794
1795 yNext = -1;
1796 }
1797
1798 FB_DBG(printf("real region: (%u, %u)-(%u, %d) \n", x0, y0, x1, y1));
1799
1800 u16LBOffset = x0 % u8pixels_per_unit;
1801
1802 pPoint = pDataBuf;
1803
1804 MS_U16 yCount, xCount, accessCount;
1805 for (y = y0, yCount = 0; yCount < pMemRect->height ; y = y + yNext, yCount+=1)
1806 {
1807 if(bIsReadMode)
1808 pPoint = (MS_U8*)pDataBuf + (yCount % pMemRect->height) * pMemRect->width * u16PointSize;
1809 else
1810 pPoint = (MS_U8*)pDataBuf + (yCount % pSrcRect->height) * pSrcRect->width * u16PointSize;
1811
1812 MS_PIXEL_32BIT *pPoint32 = (MS_PIXEL_32BIT*)pPoint;
1813 MS_PIXEL_24BIT *pPoint24 = (MS_PIXEL_24BIT*)pPoint;
1814 MS_PIXEL_422_8BIT *pPoint422_8 = (MS_PIXEL_422_8BIT*)pPoint;
1815
1816 // Y offset
1817 if (gSrcInfo[eWindow].bInterlace)
1818 {
1819 u32Y_Offset = (MS_PHY)y/2 * FBInfo.u16IPMOffset * (MS_U32)u8BytePerTwoPixel/2 * u8FrameNum;
1820
1821 #if (_FIELD_PACKING_MODE_SUPPORTED)
1822 if(eWindow == MAIN_WINDOW)
1823 u32Y_Offset += u32Main_FB_Start_Addr;
1824 else
1825 u32Y_Offset += u32Sub_FB_Start_Addr;
1826
1827 if (y & 0x1)
1828 u8packinginterlacedshift = 0;
1829 else
1830 u8packinginterlacedshift = BYTE_PER_WORD;
1831 #else
1832 if(eWindow == MAIN_WINDOW)
1833 {
1834 if (y & 0x1)
1835 u32Y_Offset += u32Main_FB_Start_Addr;
1836 else
1837 u32Y_Offset += u32Main_FB_Start_Addr + (FBInfo.u32IPMBase1 - FBInfo.u32IPMBase0);
1838 }
1839 else
1840 {
1841 if (y & 0x1)
1842 u32Y_Offset += u32Sub_FB_Start_Addr;
1843 else
1844 u32Y_Offset += u32Sub_FB_Start_Addr + (FBInfo.u32IPMBase1 - FBInfo.u32IPMBase0);
1845 }
1846 #endif
1847 }
1848 else
1849 {
1850 if ( FBInfo.bLinearAddrMode )
1851 u32Y_Offset = (MS_PHY)y * FBInfo.u16IPMOffset * (MS_U32)u8BytePerTwoPixel/2;
1852 else
1853 u32Y_Offset = (MS_PHY)y * FBInfo.u16IPMOffset * (MS_U32)u8BytePerTwoPixel/2 * u8FrameNum;
1854
1855 if(eWindow == MAIN_WINDOW)
1856 u32Y_Offset += u32Main_FB_Start_Addr;
1857 else
1858 u32Y_Offset += u32Sub_FB_Start_Addr;
1859 }
1860
1861 FB_DBG(printf("[1]u32Y_Offset:0x%x, u16IPMOffset:%u, y:%u, u8BytePerTwoPixel:%u, u8FBNum:%u\n",
1862 (int)u32Y_Offset, FBInfo.u16IPMOffset, y, u8BytePerTwoPixel, FBInfo.u8FBNum));
1863
1864 for (x = x0 - u16LBOffset, xCount = 0; xCount < xRegion; x = x + xNext, xCount+=1)
1865 {
1866 // X offset
1867 if(FBInfo.bLinearAddrMode)
1868 u32X_Offset = x * (MS_PHY)u8BytePerTwoPixel/2;
1869 else
1870 u32X_Offset = x * (MS_PHY)u8BytePerTwoPixel/2 * u8FrameNum;
1871
1872 FB_DBG(printf("[2]u32X_Offset=0x%x, align(x)=%u\n", (int)u32X_Offset, x));
1873
1874 pMEM = 0UL + u32Y_Offset + u32X_Offset;
1875
1876 if((eWindow == MAIN_WINDOW)? FBMiuSelInfo.u8MainFBSel : FBMiuSelInfo.u8SubFBSel)
1877 {
1878 pMEM += HAL_MIU1_BASE;
1879 }
1880
1881 FB_DBG(printf("[3]pMEM=0x%x, IPMBase0:0x%x, x:%u, y:%u \n", (int)pMEM, (int)FBInfo.u32IPMBase0, x, y));
1882
1883 pMEM_temp = (MS_U8 *)MS_PA2KSEG1(pMEM);
1884
1885 if (FBInfo.bMemFormat422 == TRUE)
1886 {
1887 if(!bHmirror)
1888 {
1889 // |<----- MIU block--- ---->|<----- MIU block--- ---->|
1890 // 1st x x0 x1
1891 // |<--u8Offsetpixels-->|<-->|<->|<--u8Discardpixels-->|
1892 // 2nd x
1893 // x is at start point of MIU block includes x0, then increase to next start point of MIU block
1894
1895 if(x<x0)
1896 u8Offsetpixels = u16LBOffset;
1897 else
1898 u8Offsetpixels = 0;
1899
1900 if(x+u8pixels_per_unit > x1)
1901 u8Discardpixels = x+u8pixels_per_unit - x1;
1902 else
1903 u8Discardpixels = 0;
1904 }
1905 else
1906 {
1907 // Mirror mode:
1908 // |<----- MIU block--- ---->|<----- MIU block--- ---->|
1909 // x1 1st x x0
1910 // |<--u8Offsetpixels-->|<-->|<--->|<-u8Discardpixels->|
1911 // 2nd x
1912 // x is at start point of MIU block includes x0, then decrease to previous start point of MIU block
1913
1914 if(x<x1)
1915 u8Offsetpixels = x1 - x;
1916 else
1917 u8Offsetpixels = 0;
1918
1919 if(x+u8pixels_per_unit > x0)
1920 u8Discardpixels = x+u8pixels_per_unit - x0;
1921 else
1922 u8Discardpixels = 0;
1923 }
1924
1925 int index = accessStart;
1926 MS_U16 u16WriteModeSrcPoint = 0;
1927 for(accessCount = 0; accessCount < u8pixels_per_unit; index = index + accessNext, accessCount+=1)
1928 {
1929 if((index < u8Offsetpixels) || (index > (u8pixels_per_unit - u8Discardpixels)))
1930 continue;
1931
1932 if(!bIsReadMode)
1933 {
1934 if(!bHmirror)
1935 {
1936 u16WriteModeSrcPoint = (xCount * u8pixels_per_unit + (index - u16LBOffset)) % pSrcRect->width;
1937 }
1938 else
1939 {
1940 u16WriteModeSrcPoint = (xCount * u8pixels_per_unit + (u16LBOffset - index)) % pSrcRect->width;
1941 }
1942 }
1943 #if (_FIELD_PACKING_MODE_SUPPORTED)
1944 if(true)
1945 #else
1946 if(FBInfo.bYCSeparate)
1947 #endif
1948 {
1949 if(index < BYTE_PER_WORD)
1950 {
1951 u32Accesspixel = index;
1952 }
1953 else
1954 {
1955 #if (_FIELD_PACKING_MODE_SUPPORTED)
1956 u32Accesspixel = index + u32JumpOffset;
1957 #else
1958 u32Accesspixel = index + BYTE_PER_WORD + u32JumpOffset;
1959 #endif
1960 }
1961 u32Accesspixel += u8packinginterlacedshift;
1962
1963 if(bIsReadMode)
1964 {
1965 // for get buffer data mode
1966 if(eBufType == E_XC_OUTPUTDATA_RGB10BITS)
1967 {
1968 // source 422 format, output R10G10B10 mode
1969 pPoint32->G_Y = pMEM_temp[u32Accesspixel] << 2;
1970 if (index&0x1)
1971 {
1972 pPoint32->B_Cb = pMEM_temp[u32Accesspixel-1+u16YCSeparateOffset] << 2;
1973 pPoint32->R_Cr = pMEM_temp[u32Accesspixel+u16YCSeparateOffset] << 2;
1974 }
1975 else {
1976 pPoint32->B_Cb = pMEM_temp[u32Accesspixel+u16YCSeparateOffset] << 2;
1977 pPoint32->R_Cr = pMEM_temp[u32Accesspixel+1+u16YCSeparateOffset] << 2;
1978 }
1979 }
1980 else if(eBufType == E_XC_OUTPUTDATA_RGB8BITS)
1981 {
1982 // source 422 format, output R8G8B8 mode
1983 pPoint24->G_Y = pMEM_temp[u32Accesspixel];
1984 if (index&0x1)
1985 {
1986 pPoint24->B_Cb = pMEM_temp[u32Accesspixel-1+u16YCSeparateOffset];
1987 pPoint24->R_Cr = pMEM_temp[u32Accesspixel+u16YCSeparateOffset];
1988 }
1989 else {
1990 pPoint24->B_Cb = pMEM_temp[u32Accesspixel+u16YCSeparateOffset];
1991 pPoint24->R_Cr = pMEM_temp[u32Accesspixel+1+u16YCSeparateOffset];
1992 }
1993 }
1994 else if(eBufType == E_XC_OUTPUTDATA_4228BITS)
1995 {
1996 // source 422 format, output Y8CbCr8 mode
1997 pPoint422_8->u8G_Y = pMEM_temp[u32Accesspixel];
1998 pPoint422_8->u8BR_CbCr = pMEM_temp[u32Accesspixel+u16YCSeparateOffset];
1999 }
2000
2001 }
2002 else
2003 {
2004 // for set buffer data mode
2005 if(eBufType == E_XC_OUTPUTDATA_RGB10BITS)
2006 {
2007 // target 422 format, input 10G10B10 mode
2008 pMEM_temp[u32Accesspixel] = pPoint32[u16WriteModeSrcPoint].G_Y >> 2;
2009 if (index&0x1)
2010 {
2011 pMEM_temp[u32Accesspixel-1+u16YCSeparateOffset] = pPoint32[u16WriteModeSrcPoint].B_Cb >> 2;
2012 pMEM_temp[u32Accesspixel+u16YCSeparateOffset] = pPoint32[u16WriteModeSrcPoint].R_Cr >> 2;
2013 }
2014 else {
2015 pMEM_temp[u32Accesspixel+u16YCSeparateOffset] = pPoint32[u16WriteModeSrcPoint].B_Cb >> 2;
2016 pMEM_temp[u32Accesspixel+1+u16YCSeparateOffset] = pPoint32[u16WriteModeSrcPoint].R_Cr >> 2;
2017 }
2018 }
2019 else if(eBufType == E_XC_OUTPUTDATA_RGB8BITS)
2020 {
2021 // target 422 format, input R8G8B8 mode
2022 pMEM_temp[u32Accesspixel] = pPoint24[u16WriteModeSrcPoint].G_Y;
2023 if (index&0x1)
2024 {
2025 pMEM_temp[u32Accesspixel-1+u16YCSeparateOffset] = pPoint24[u16WriteModeSrcPoint].B_Cb;
2026 pMEM_temp[u32Accesspixel+u16YCSeparateOffset] = pPoint24[u16WriteModeSrcPoint].R_Cr;
2027 }
2028 else {
2029 pMEM_temp[u32Accesspixel+u16YCSeparateOffset] = pPoint24[u16WriteModeSrcPoint].B_Cb;
2030 pMEM_temp[u32Accesspixel+1+u16YCSeparateOffset] = pPoint24[u16WriteModeSrcPoint].R_Cr;
2031 }
2032 }
2033 else if(eBufType == E_XC_OUTPUTDATA_4228BITS)
2034 {
2035 // target 422 format, input Y8CbCr8 mode
2036 pMEM_temp[u32Accesspixel] = pPoint422_8[u16WriteModeSrcPoint].u8G_Y;
2037 pMEM_temp[u32Accesspixel+u16YCSeparateOffset] = pPoint422_8[u16WriteModeSrcPoint].u8BR_CbCr;
2038 }
2039 }
2040 }
2041 else
2042 {
2043 if(index < BYTE_PER_WORD)
2044 {
2045 u32Accesspixel = index*2;
2046 }
2047 else
2048 {
2049 u32Accesspixel = index*2 + u32JumpOffset;
2050 }
2051
2052 if(bIsReadMode)
2053 {
2054 // for get buffer data mode
2055 if(eBufType == E_XC_OUTPUTDATA_RGB10BITS)
2056 {
2057 // source 422 format, output R10G10B10 mode
2058 pPoint32->G_Y = pMEM_temp[u32Accesspixel] << 2;
2059 if (index&0x1) {
2060 pPoint32->B_Cb = pMEM_temp[u32Accesspixel-1] << 2;
2061 pPoint32->R_Cr = pMEM_temp[u32Accesspixel+1] << 2;
2062 }
2063 else {
2064 pPoint32->B_Cb = pMEM_temp[u32Accesspixel+1] << 2;
2065 pPoint32->R_Cr= pMEM_temp[u32Accesspixel+3] << 2;
2066 }
2067 }
2068 else if(eBufType == E_XC_OUTPUTDATA_RGB8BITS)
2069 {
2070 // source 422 format, output R8G8B8 mode
2071 pPoint24->G_Y = pMEM_temp[u32Accesspixel];
2072 if (index&0x1) {
2073 pPoint24->B_Cb = pMEM_temp[u32Accesspixel-1];
2074 pPoint24->R_Cr = pMEM_temp[u32Accesspixel+1];
2075 }
2076 else {
2077 pPoint24->B_Cb = pMEM_temp[u32Accesspixel+1];
2078 pPoint24->R_Cr= pMEM_temp[u32Accesspixel+3];
2079 }
2080 }
2081 else if(eBufType == E_XC_OUTPUTDATA_4228BITS)
2082 {
2083 // source 422 format, output Y8CbCr8 mode
2084 pPoint422_8->u8G_Y = pMEM_temp[u32Accesspixel];
2085 pPoint422_8->u8BR_CbCr = pMEM_temp[u32Accesspixel+1];
2086 }
2087 }
2088 else
2089 {
2090 // for set buffer data mode,
2091 if(eBufType == E_XC_OUTPUTDATA_RGB10BITS)
2092 {
2093 // target 422 format, input R10G10B10 mode
2094 pMEM_temp[u32Accesspixel] = pPoint32[u16WriteModeSrcPoint].G_Y >> 2;
2095 if (index&0x1) {
2096 pMEM_temp[u32Accesspixel-1] = pPoint32[u16WriteModeSrcPoint].B_Cb >> 2;
2097 pMEM_temp[u32Accesspixel+1] = pPoint32[u16WriteModeSrcPoint].R_Cr >> 2;
2098 }
2099 else {
2100 pMEM_temp[u32Accesspixel+1] = pPoint32[u16WriteModeSrcPoint].B_Cb >> 2;
2101 pMEM_temp[u32Accesspixel+3] = pPoint32[u16WriteModeSrcPoint].R_Cr>> 2;
2102 }
2103 }
2104 else if(eBufType == E_XC_OUTPUTDATA_RGB8BITS)
2105 {
2106 // target 422 format, inout R8G8B8 mode
2107 pMEM_temp[u32Accesspixel] = pPoint24[u16WriteModeSrcPoint].G_Y;
2108 if (index&0x1) {
2109 pMEM_temp[u32Accesspixel-1] = pPoint24[u16WriteModeSrcPoint].B_Cb;
2110 pMEM_temp[u32Accesspixel+1] = pPoint24[u16WriteModeSrcPoint].R_Cr;
2111 }
2112 else {
2113 pMEM_temp[u32Accesspixel+1] = pPoint24[u16WriteModeSrcPoint].B_Cb;
2114 pMEM_temp[u32Accesspixel+3] = pPoint24[u16WriteModeSrcPoint].R_Cr;
2115 }
2116 }
2117 else if(eBufType == E_XC_OUTPUTDATA_4228BITS)
2118 {
2119 // target 422 format, input Y8CbCr8 mode
2120 pMEM_temp[u32Accesspixel] = pPoint422_8[u16WriteModeSrcPoint].u8G_Y;
2121 pMEM_temp[u32Accesspixel+1] = pPoint422_8[u16WriteModeSrcPoint].u8BR_CbCr;
2122 }
2123 }
2124 }
2125
2126 if(bIsReadMode)
2127 {
2128 if(eBufType == E_XC_OUTPUTDATA_RGB10BITS)
2129 {
2130 FB_DBG(printf("==> index: %d, R: %d, G:%d, B: %d \n", index, pPoint32->R_Cr, pPoint32->G_Y, pPoint32->B_Cb));
2131 pPoint32++;
2132 }
2133 else if(eBufType == E_XC_OUTPUTDATA_RGB8BITS)
2134 {
2135 FB_DBG(printf("==> index: %d, R: %d, G:%d, B: %d \n", index, pPoint24->R_Cr, pPoint24->G_Y, pPoint24->B_Cb));
2136 pPoint24++;
2137 }
2138 else if(eBufType == E_XC_OUTPUTDATA_4228BITS)
2139 {
2140 FB_DBG(printf("==> index: %d, Y: %d, CbCr:%d \n", index, pPoint422_8->u8G_Y, pPoint422_8->u8BR_CbCr));
2141 pPoint422_8++;
2142 }
2143 }
2144
2145 }
2146
2147 }
2148 else //444 case
2149 {
2150 if(!bHmirror)
2151 {
2152 // |<----- MIU block--- ---->|<----- MIU block--- ---->|
2153 // 1st x x0 x1
2154 // |<--u8Offsetpixels-->|<-->|<->|<--u8Discardpixels-->|
2155 // 2nd x
2156 // x is at start point of MIU block includes x0, then increase to next start point of MIU block
2157
2158 if(x<x0)
2159 u8Offsetpixels = u16LBOffset;
2160 else
2161 u8Offsetpixels = 0;
2162
2163 if(x+u8pixels_per_unit > x1)
2164 u8Discardpixels = x+u8pixels_per_unit - x1;
2165 else
2166 u8Discardpixels = 0;
2167 }
2168 else
2169 {
2170 // Mirror mode:
2171 // |<----- MIU block--- ---->|<----- MIU block--- ---->|
2172 // x1 1st x x0
2173 // |<--u8Offsetpixels-->|<-->|<--->|<-u8Discardpixels->|
2174 // 2nd x
2175 // x is at start point of MIU block includes x0, then decrease to previous start point of MIU block
2176
2177 if(x<x1)
2178 u8Offsetpixels = x1 - x;
2179 else
2180 u8Offsetpixels = 0;
2181
2182 if(x+u8pixels_per_unit > x0)
2183 u8Discardpixels = x+u8pixels_per_unit - x0;
2184 else
2185 u8Discardpixels = 0;
2186 }
2187
2188 int index = accessStart;
2189 MS_U16 u16WriteModeSrcPoint = 0;
2190 for(accessCount = 0; accessCount < u8pixels_per_unit; index = index + accessNext, accessCount+=1)
2191 {
2192 if((index < u8Offsetpixels) || (index > (u8pixels_per_unit - u8Discardpixels)))
2193 continue;
2194
2195 if(!bIsReadMode)
2196 {
2197 if(!bHmirror)
2198 {
2199 u16WriteModeSrcPoint = (xCount * u8pixels_per_unit + (index - u16LBOffset)) % pSrcRect->width;
2200 }
2201 else
2202 {
2203 u16WriteModeSrcPoint = (xCount * u8pixels_per_unit + (u16LBOffset - index)) % pSrcRect->width;
2204 }
2205 }
2206 #if (_FIELD_PACKING_MODE_SUPPORTED)
2207 u32Accesspixel = index;
2208 #else
2209 u32Accesspixel = index*u8BytePerTwoPixel/2;
2210 #endif
2211
2212 #if (_FIELD_PACKING_MODE_SUPPORTED)
2213 if(false)
2214 #else
2215 if(32 == FBInfo.u8BitPerPixel) //10bits
2216 #endif
2217 {
2218 if(u32Accesspixel>= 2*BYTE_PER_WORD)
2219 u32Accesspixel += u32JumpOffset;
2220
2221 if(bIsReadMode)
2222 {
2223 // for get buffer data mode
2224 if(eBufType == E_XC_OUTPUTDATA_RGB10BITS)
2225 {
2226 // source 444 10bits format, output R10G10B10 mode
2227 pPoint32->B_Cb = ( pMEM_temp[u32Accesspixel] ) | ( (pMEM_temp[u32Accesspixel + 1] & 0x03 ) << 8 );
2228 pPoint32->G_Y = ( pMEM_temp[u32Accesspixel+ 1] >> 2 ) | ( (pMEM_temp[u32Accesspixel+ 2] & 0x0F ) << 6 );
2229 pPoint32->R_Cr = ( pMEM_temp[u32Accesspixel+ 2] >> 4 ) | ( (pMEM_temp[u32Accesspixel+ 3] & 0x3F ) << 4 );
2230 }
2231 else if(eBufType == E_XC_OUTPUTDATA_RGB8BITS)
2232 {
2233 // source 444 10bits format, output R8G8B8 mode
2234 pPoint24->B_Cb = (( pMEM_temp[u32Accesspixel] ) | ( (pMEM_temp[u32Accesspixel + 1] & 0x03 ) << 8 )) >> 2;
2235 pPoint24->G_Y = (( pMEM_temp[u32Accesspixel+ 1] >> 2 ) | ( (pMEM_temp[u32Accesspixel+ 2] & 0x0F ) << 6 )) >> 2;
2236 pPoint24->R_Cr = (( pMEM_temp[u32Accesspixel+ 2] >> 4 ) | ( (pMEM_temp[u32Accesspixel+ 3] & 0x3F ) << 4 )) >> 2;
2237 }
2238 }
2239 else
2240 {
2241 // for set buffer data mode
2242 if(eBufType == E_XC_OUTPUTDATA_RGB10BITS)
2243 {
2244 // target 444 10bits format, input R10G10B10 mode
2245 pMEM_temp[u32Accesspixel] = pPoint32[u16WriteModeSrcPoint].B_Cb & 0xFF;
2246 pMEM_temp[u32Accesspixel+1] = ((pPoint32[u16WriteModeSrcPoint].G_Y & 0x3F) << 2) | (pPoint32[u16WriteModeSrcPoint].B_Cb >> 8);
2247 pMEM_temp[u32Accesspixel+2] = ((pPoint32[u16WriteModeSrcPoint].R_Cr & 0x0F) << 4) | (pPoint32[u16WriteModeSrcPoint].G_Y >> 6);
2248 pMEM_temp[u32Accesspixel+3] = pPoint32[u16WriteModeSrcPoint].R_Cr>> 4;
2249
2250 }
2251 else if(eBufType == E_XC_OUTPUTDATA_RGB8BITS)
2252 {
2253 // target 444 10bits format, input R8G8B8 mode
2254 pMEM_temp[u32Accesspixel] = (pPoint24[u16WriteModeSrcPoint].B_Cb & 0x3F) << 2;
2255 pMEM_temp[u32Accesspixel+1] = ((pPoint24[u16WriteModeSrcPoint].G_Y & 0x0F) << 4) | ((pPoint24[u16WriteModeSrcPoint].B_Cb >>6) & 0x03);
2256 pMEM_temp[u32Accesspixel+2] = ((pPoint24[u16WriteModeSrcPoint].R_Cr & 0x03) << 6) | (pPoint24[u16WriteModeSrcPoint].G_Y >> 4);
2257 pMEM_temp[u32Accesspixel+3] = pPoint24[u16WriteModeSrcPoint] .R_Cr >>2;
2258 }
2259 }
2260
2261 }
2262 else // 8bits
2263 {
2264 #if (_FIELD_PACKING_MODE_SUPPORTED)
2265 if(bIsReadMode)
2266 {
2267 // for get buffer data mode
2268 if(eBufType == E_XC_OUTPUTDATA_RGB10BITS)
2269 {
2270 // source 444 8bits format, output R10G10B10 mode
2271 pPoint32->B_Cb = pMEM_temp[u32Accesspixel] << 2;
2272 pPoint32->G_Y = pMEM_temp[u32Accesspixel+u16YCSeparateOffset] << 2;
2273 pPoint32->R_Cr = pMEM_temp[u32Accesspixel+u16YCSeparateOffset+u16YCSeparateOffset] << 2;
2274 }
2275 else if(eBufType == E_XC_OUTPUTDATA_RGB8BITS)
2276 {
2277 // source 444 8bits format, output R8G8B8 mode
2278 pPoint24->B_Cb = pMEM_temp[u32Accesspixel];
2279 pPoint24->G_Y = pMEM_temp[u32Accesspixel+u16YCSeparateOffset];
2280 pPoint24->R_Cr = pMEM_temp[u32Accesspixel+u16YCSeparateOffset+u16YCSeparateOffset];
2281 }
2282 }
2283 else
2284 {
2285 // for set buffer data mode
2286 if(eBufType == E_XC_OUTPUTDATA_RGB10BITS)
2287 {
2288 // target 444 8bits format, input R10G10B10 mode
2289 pMEM_temp[u32Accesspixel] = pPoint32[u16WriteModeSrcPoint].B_Cb>> 2;
2290 pMEM_temp[u32Accesspixel+u16YCSeparateOffset]= pPoint32[u16WriteModeSrcPoint].G_Y>> 2;
2291 pMEM_temp[u32Accesspixel+u16YCSeparateOffset+u16YCSeparateOffset]= pPoint32[u16WriteModeSrcPoint].R_Cr>> 2;
2292 }
2293 else if(eBufType == E_XC_OUTPUTDATA_RGB8BITS)
2294 {
2295 // target 444 8bits format, input R8G8B8 mode
2296 pMEM_temp[u32Accesspixel] = pPoint24[u16WriteModeSrcPoint].B_Cb;
2297 pMEM_temp[u32Accesspixel+u16YCSeparateOffset] = pPoint24[u16WriteModeSrcPoint].G_Y;
2298 pMEM_temp[u32Accesspixel+u16YCSeparateOffset+u16YCSeparateOffset] = pPoint24[u16WriteModeSrcPoint].R_Cr;
2299 }
2300 else
2301 printf("--> not support type \n");
2302 }
2303 #else
2304 MS_U8 u8JumpNum = u32Accesspixel/ (2*BYTE_PER_WORD);
2305 MS_U8 u8BoundMax = (2*BYTE_PER_WORD) + 2* u8JumpNum * (2*BYTE_PER_WORD);
2306
2307 u32Accesspixel += u32JumpOffset*u8JumpNum;
2308
2309 if(bIsReadMode)
2310 {
2311 // for get buffer data mode
2312 if(eBufType == E_XC_OUTPUTDATA_RGB10BITS)
2313 {
2314 // source 444 8bits format, output R10G10B10 mode
2315 pPoint32->B_Cb = pMEM_temp[u32Accesspixel] << 2;
2316
2317 if(u32Accesspixel+1 >= u8BoundMax)
2318 pPoint32->G_Y = pMEM_temp[u32Accesspixel+1+u32JumpOffset] << 2;
2319 else
2320 pPoint32->G_Y = pMEM_temp[u32Accesspixel+1] << 2;
2321
2322 if(u32Accesspixel+2 >= u8BoundMax)
2323 pPoint32->R_Cr = pMEM_temp[u32Accesspixel+2+u32JumpOffset] << 2;
2324 else
2325 pPoint32->R_Cr = pMEM_temp[u32Accesspixel+2] << 2;
2326 }
2327 else if(eBufType == E_XC_OUTPUTDATA_RGB8BITS)
2328 {
2329 // source 444 8bits format, output R8G8B8 mode
2330 pPoint24->B_Cb = pMEM_temp[u32Accesspixel];
2331
2332 if(u32Accesspixel+1 >= u8BoundMax)
2333 pPoint24->G_Y = pMEM_temp[u32Accesspixel+1+u32JumpOffset];
2334 else
2335 pPoint24->G_Y = pMEM_temp[u32Accesspixel+1];
2336
2337 if(u32Accesspixel+2 >= u8BoundMax)
2338 pPoint24->R_Cr = pMEM_temp[u32Accesspixel+2+u32JumpOffset];
2339 else
2340 pPoint24->R_Cr = pMEM_temp[u32Accesspixel+2];
2341 }
2342 }
2343 else
2344 {
2345 // for set buffer data mode
2346 if(eBufType == E_XC_OUTPUTDATA_RGB10BITS)
2347 {
2348 // target 444 8bits format, input R10G10B10 mode
2349 pMEM_temp[u32Accesspixel] = pPoint32[u16WriteModeSrcPoint].B_Cb >> 2;
2350
2351 if(u32Accesspixel+1 >= u8BoundMax)
2352 pMEM_temp[u32Accesspixel+1+u32JumpOffset] = pPoint32[u16WriteModeSrcPoint].G_Y >> 2;
2353 else
2354 pMEM_temp[u32Accesspixel+1]= pPoint32[u16WriteModeSrcPoint].G_Y>> 2;
2355
2356 if(u32Accesspixel+2 >= u8BoundMax)
2357 pMEM_temp[u32Accesspixel+2+u32JumpOffset] = pPoint32[u16WriteModeSrcPoint].R_Cr>> 2;
2358 else
2359 pMEM_temp[u32Accesspixel+2]= pPoint32[u16WriteModeSrcPoint].R_Cr >> 2;
2360 }
2361 else if(eBufType == E_XC_OUTPUTDATA_RGB8BITS)
2362 {
2363 // target 444 8bits format, input R8G8B8 mode
2364 pMEM_temp[u32Accesspixel] = pPoint24[u16WriteModeSrcPoint].B_Cb;
2365
2366 if(u32Accesspixel+1 >= u8BoundMax)
2367 pMEM_temp[u32Accesspixel+1+u32JumpOffset] = pPoint24[u16WriteModeSrcPoint].G_Y;
2368 else
2369 pMEM_temp[u32Accesspixel+1] = pPoint24[u16WriteModeSrcPoint].G_Y;
2370
2371 if(u32Accesspixel+2 >= u8BoundMax)
2372 pMEM_temp[u32Accesspixel+2+u32JumpOffset] = pPoint24[u16WriteModeSrcPoint].R_Cr;
2373 else
2374 pMEM_temp[u32Accesspixel+2] = pPoint24[u16WriteModeSrcPoint].R_Cr;
2375 }
2376 else
2377 printf("--> not support type \n");
2378 }
2379 #endif
2380 }
2381
2382 if(bIsReadMode)
2383 {
2384 if(eBufType == E_XC_OUTPUTDATA_RGB10BITS)
2385 {
2386 FB_DBG(printf("==> index: %d, R: %d, G:%d, B: %d \n", index, pPoint32->R_Cr, pPoint32->G_Y, pPoint32->B_Cb));
2387 pPoint32++;
2388 }
2389 else if(eBufType == E_XC_OUTPUTDATA_RGB8BITS)
2390 {
2391 FB_DBG(printf("==> index: %d, R: %d, G:%d, B: %d \n", index, pPoint24->R_Cr, pPoint24->G_Y, pPoint24->B_Cb));
2392 pPoint24++;
2393 }
2394 }
2395 }
2396 }
2397
2398 FB_DBG(printf("pMEM_temp=0x%x\n", (int)pMEM_temp));
2399 FB_DBG(printf("pMEM_temp[%u]=", (u16LBOffset)));
2400 FB_DBG(printf( "0x%x\n",pMEM_temp[u16LBOffset]));
2401
2402 }
2403 }
2404 FB_DBG(printf("=>Get Memory finish\n"));
2405 MsOS_ReadMemory(); //Flush CPU operation
2406 }
2407
MApi_XC_Set_BufferData_U2(void * pInstance,E_XC_INPUTDATA_TYPE eBufType,MS_WINDOW_TYPE * pDstRect,void * pSrcBuf,MS_WINDOW_TYPE * pSrcRect,SCALER_WIN eWindow)2408 void MApi_XC_Set_BufferData_U2(void* pInstance, E_XC_INPUTDATA_TYPE eBufType, MS_WINDOW_TYPE *pDstRect, void *pSrcBuf, MS_WINDOW_TYPE *pSrcRect, SCALER_WIN eWindow)
2409 {
2410 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2411 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2412 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
2413 _XC_ENTRY(pInstance);
2414 MApi_XC_Set_BufferData_WithoutMutex(pInstance, eBufType, pDstRect, pSrcBuf, pSrcRect, eWindow);
2415 _XC_RETURN(pInstance);
2416 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
2417 }
2418
MApi_XC_Set_BufferData(E_XC_INPUTDATA_TYPE eBufType,MS_WINDOW_TYPE * pDstRect,void * pSrcBuf,MS_WINDOW_TYPE * pSrcRect,SCALER_WIN eWindow)2419 void MApi_XC_Set_BufferData(E_XC_INPUTDATA_TYPE eBufType, MS_WINDOW_TYPE *pDstRect, void *pSrcBuf, MS_WINDOW_TYPE *pSrcRect, SCALER_WIN eWindow)
2420 {
2421 if (pu32XCInst == NULL)
2422 {
2423 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2424 return;
2425 }
2426
2427 stXC_SET_BUFFERDATA XCArgs;
2428 XCArgs.eBufType = eBufType;
2429 XCArgs.pDstRect = pDstRect;
2430 XCArgs.pSrcBuf = pSrcBuf;
2431 XCArgs.pSrcRect = pSrcRect;
2432 XCArgs.eWindow = eWindow;
2433
2434 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_BUFFERDATA, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2435 {
2436 printf("Obtain XC engine fail\n");
2437 return;
2438 }
2439 else
2440 {
2441 return;
2442 }
2443 }
2444
MApi_XC_Get_BufferData_U2(void * pInstance,E_XC_OUTPUTDATA_TYPE eBufType,MS_WINDOW_TYPE * pRect,void * pRectBuf,SCALER_WIN eWindow)2445 void MApi_XC_Get_BufferData_U2( void* pInstance, E_XC_OUTPUTDATA_TYPE eBufType, MS_WINDOW_TYPE *pRect, void *pRectBuf, SCALER_WIN eWindow)
2446 {
2447 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2448 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2449 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
2450 _XC_ENTRY(pInstance);
2451 MApi_XC_Get_BufferData_WithoutMutex(pInstance, eBufType, pRect, pRectBuf, eWindow);
2452 _XC_RETURN(pInstance);
2453 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
2454 }
2455
MApi_XC_Get_BufferData(E_XC_OUTPUTDATA_TYPE eBufType,MS_WINDOW_TYPE * pRect,void * pRectBuf,SCALER_WIN eWindow)2456 void MApi_XC_Get_BufferData(E_XC_OUTPUTDATA_TYPE eBufType, MS_WINDOW_TYPE *pRect, void *pRectBuf, SCALER_WIN eWindow)
2457 {
2458 if (pu32XCInst == NULL)
2459 {
2460 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2461 return;
2462 }
2463
2464 stXC_GET_BUFFERDATA XCArgs;
2465 XCArgs.eBufType = eBufType;
2466 XCArgs.pRect = pRect;
2467 XCArgs.pRectBuf = pRectBuf;
2468 XCArgs.eWindow = eWindow;
2469
2470 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_BUFFERDATA, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2471 {
2472 printf("Obtain XC engine fail\n");
2473 return;
2474 }
2475 else
2476 {
2477 return;
2478 }
2479 }
2480
MApi_XC_Set_BufferData_WithoutMutex(void * pInstance,E_XC_INPUTDATA_TYPE eBufType,MS_WINDOW_TYPE * pDstRect,void * pSrcBuf,MS_WINDOW_TYPE * pSrcRect,SCALER_WIN eWindow)2481 void MApi_XC_Set_BufferData_WithoutMutex(void *pInstance, E_XC_INPUTDATA_TYPE eBufType, MS_WINDOW_TYPE *pDstRect, void *pSrcBuf, MS_WINDOW_TYPE *pSrcRect, SCALER_WIN eWindow)
2482 {
2483 E_XC_OUTPUTDATA_TYPE eDataBufType;
2484
2485 if (eBufType == E_XC_INPUTDATA_RGB8BITS)
2486 {
2487 eDataBufType = E_XC_OUTPUTDATA_RGB8BITS;
2488 }
2489 else if (eBufType == E_XC_INPUTDATA_RGB10BITS)
2490 {
2491 eDataBufType = E_XC_OUTPUTDATA_RGB10BITS;
2492 }
2493 else if (eBufType == E_XC_INPUTDATA_4228BITS)
2494 {
2495 eDataBufType = E_XC_OUTPUTDATA_4228BITS;
2496 }
2497 else
2498 {
2499 printf("Unsupported Buf Type! \n");
2500 return;
2501 }
2502
2503
2504 MDrv_XC_Access_BufferData(pInstance, eDataBufType, pDstRect, pSrcBuf, pSrcRect, eWindow, FALSE);
2505 }
2506
2507
MApi_XC_Get_BufferData_WithoutMutex(void * pInstance,E_XC_OUTPUTDATA_TYPE eBufType,MS_WINDOW_TYPE * pRect,void * pRectBuf,SCALER_WIN eWindow)2508 void MApi_XC_Get_BufferData_WithoutMutex(void *pInstance, E_XC_OUTPUTDATA_TYPE eBufType, MS_WINDOW_TYPE *pRect, void *pRectBuf, SCALER_WIN eWindow)
2509 {
2510 MDrv_XC_Access_BufferData(pInstance, eBufType, pRect, pRectBuf, NULL, eWindow, TRUE);
2511 }
2512
2513 #if 0
2514 //-------------------------------------------------------------------------------------------------
2515 /// Get frame data
2516 /// @param stSrcInfo \b IN: @ref XC_ApiStatus
2517 /// @param eRect_Info \b IN: @ref MS_RECT_INFO
2518 //-------------------------------------------------------------------------------------------------
2519 void MApi_XC_GetFrameData(XC_ApiStatus *stSrcInfo, MS_RECT_INFO *eRect_Info)
2520 {
2521 MS_U32 u32RectSize;
2522
2523 if(eRect_Info->s16X_Start <0 || eRect_Info->s16X_Start >= (stSrcInfo->u16H_SizeAfterPreScaling -1) ||
2524 eRect_Info->s16X_Size <0 || eRect_Info->s16X_Size >= (stSrcInfo->u16H_SizeAfterPreScaling -1) ||
2525 eRect_Info->s16X_Start > eRect_Info->s16X_Size || eRect_Info->s16Y_Start > eRect_Info->s16Y_Size||
2526 eRect_Info->s16Y_Start <0 || eRect_Info->s16Y_Start >= (stSrcInfo->u16V_SizeAfterPreScaling -1) ||
2527 eRect_Info->s16Y_Size <0 || eRect_Info->s16Y_Size >= (stSrcInfo->u16V_SizeAfterPreScaling -1))
2528 {
2529 MS_CRITICAL_MSG(printf("invalid parameter!\n"));
2530 return;
2531 }
2532
2533 u32RectSize = eRect_Info->u32RectPitch * (eRect_Info->s16Y_Size - eRect_Info->s16Y_Start + 1) * eRect_Info->u16PointSize;
2534
2535 MDrv_SC_GetFrameDataCore(eRect_Info->s16X_Start, eRect_Info->s16Y_Start, eRect_Info->s16X_Size, eRect_Info->s16Y_Size,
2536 eRect_Info->pRect,
2537 eRect_Info->u32RectPitch,
2538 u32RectSize,
2539 eRect_Info->u16PointSize);
2540
2541 }
2542 #endif
2543 //void MApi_XC_SetFrameData(XC_ApiStatus stSrcInfo, MS_RECT_INFO eRect_Info);
2544
2545
_MDrv_SC_WritePixel(volatile MS_U8 * pMEM,MS_BOOL bMemFmt422,void * pPoint,MS_U16 u16PointSize,MS_BOOL bR_Cr)2546 static void _MDrv_SC_WritePixel(volatile MS_U8* pMEM, MS_BOOL bMemFmt422,
2547 void *pPoint, MS_U16 u16PointSize,
2548 MS_BOOL bR_Cr)
2549 {
2550 MS_PIXEL_24BIT *pPoint24 = (MS_PIXEL_24BIT*)pPoint;
2551 MS_PIXEL_32BIT *pPoint32 = (MS_PIXEL_32BIT*)pPoint;
2552
2553 if (bMemFmt422)
2554 {
2555 if (u16PointSize == 4)
2556 {
2557 pMEM[0] = pPoint32->G_Y>>2;
2558 pMEM[1] = ((bR_Cr) ? pPoint32->R_Cr : pPoint32->B_Cb)>>2;
2559 }
2560 else
2561 {
2562 pMEM[0] = pPoint24->G_Y;
2563 pMEM[1] = (bR_Cr) ? pPoint24->R_Cr : pPoint24->B_Cb;
2564 }
2565 }
2566 else
2567 {
2568 if (u16PointSize == 4)
2569 {
2570 pMEM[0] = (MS_U8)(pPoint32->B_Cb);
2571 pMEM[1] = (MS_U8)((pPoint32->G_Y << 2) | (pPoint32->B_Cb>> 8));
2572 pMEM[2] = (MS_U8)((pPoint32->R_Cr<< 4) | (pPoint32->G_Y >> 6));
2573 pMEM[3] = (MS_U8)(pPoint32->R_Cr >> 4);
2574 }
2575 else
2576 {
2577 pMEM[0] = (pPoint24->B_Cb<< 2);
2578 pMEM[1] = (pPoint24->G_Y << 4) | (pPoint24->B_Cb>> 6);
2579 pMEM[2] = (pPoint24->R_Cr<< 6) | (pPoint24->G_Y >> 4);
2580 pMEM[3] = (pPoint24->R_Cr>> 2);
2581 }
2582 }
2583 }
2584
2585
MDrv_SC_SetFrameDataCore(void * pInstance,MS_S16 x0,MS_S16 y0,MS_S16 x1,MS_S16 y1,MS_U8 * pRect,MS_U32 u32RectPitch,MS_U32 u32RectSize,MS_U16 u16PointSize)2586 void MDrv_SC_SetFrameDataCore(void *pInstance, MS_S16 x0, MS_S16 y0, MS_S16 x1, MS_S16 y1,
2587 MS_U8 *pRect,
2588 MS_U32 u32RectPitch,
2589 MS_U32 u32RectSize,
2590 MS_U16 u16PointSize)
2591 {
2592 MS_U8 *pPoint;
2593 volatile MS_PHY pMEM;
2594 volatile MS_U8 *pMEM_temp;
2595 MS_U8 u8BytePerPixel;
2596 MS_U8 u8LSB_YM4_Size;
2597 MS_S16 x, y;
2598 MS_U16 u16OffsetPixelAlign;
2599 MS_U32 u32Y_Offset, u32X_Offset;
2600 SC_FRAMEBUF_INFO_t FBInfo;
2601
2602 Hal_SC_get_framebuf_Info(pInstance, &FBInfo, MAIN_WINDOW);
2603
2604 // not implement pre-scaling down
2605 if (FBInfo.bMemFormat422 == TRUE)
2606 {
2607 if (FBInfo.u8BitPerPixel == 24)
2608 {
2609 FB_DBG(printf("422_10BIT\n"));
2610 u8BytePerPixel = 3;
2611 u8LSB_YM4_Size = BYTE_PER_WORD*2;
2612 u16OffsetPixelAlign = BYTE_PER_WORD/2*2; // *2 (F0 F0)
2613 }
2614 else //if (FBInfo.u8BitPerPixel == 16)
2615 {
2616 FB_DBG(printf("422_8BIT\n"));
2617 u8BytePerPixel = 2;
2618 u8LSB_YM4_Size = 0;
2619 u16OffsetPixelAlign = BYTE_PER_WORD/2*2; // *2 (F0 F0)
2620 }
2621 }
2622 else
2623 { // using 444 10 bit
2624 FB_DBG(printf("444_10BIT\n"));
2625 u8BytePerPixel = 4;
2626 u8LSB_YM4_Size = 0;
2627 u16OffsetPixelAlign = BYTE_PER_WORD/4*2; // *2 (F0 F0)
2628 }
2629
2630 for (y = y0; y <= y1; y++)
2631 {
2632 if (FBInfo.bInterlace)
2633 {
2634 u32Y_Offset = (MS_U32)y/2 * FBInfo.u16IPMOffset * u8BytePerPixel * FBInfo.u8FBNum;
2635 if (y & 0x1)
2636 u32Y_Offset += FBInfo.u32IPMBase1;
2637 else
2638 u32Y_Offset += FBInfo.u32IPMBase0;
2639 }
2640 else
2641 {
2642 u32Y_Offset = (MS_U32)y * FBInfo.u16IPMOffset * u8BytePerPixel * FBInfo.u8FBNum;
2643 u32Y_Offset += FBInfo.u32IPMBase0;
2644 }
2645 FB_DBG(printf("[1]u32Y_Offset:0x%x, u16IPMOffset:%u, y:%u, u8BytePerPixel:%u, u8FBNum:%u\n",
2646 (int)u32Y_Offset, FBInfo.u16IPMOffset, y, u8BytePerPixel, FBInfo.u8FBNum));
2647
2648 for (x = x0; x <= x1; x++)
2649 {
2650 u32X_Offset = (MS_U32)x / u16OffsetPixelAlign * u16OffsetPixelAlign * u8BytePerPixel * FBInfo.u8FBNum;
2651
2652 FB_DBG(printf("[2]u32X_Offset=0x%x, u16OffsetPixelAlign=%u, x=%u, align(x)=%u\n",
2653 (int)u32X_Offset, u16OffsetPixelAlign, x, x / u16OffsetPixelAlign * u16OffsetPixelAlign));
2654
2655 pPoint = pRect+ (u32RectPitch * (y - y0) + (x - x0)) * u16PointSize;
2656 if ((x / u16OffsetPixelAlign) & 0x1)
2657 {
2658 pMEM = (MS_PHY)(0UL + u32Y_Offset + u32X_Offset + u8LSB_YM4_Size);
2659 }
2660 else
2661 {
2662 pMEM = (MS_PHY)(0UL + u32Y_Offset + u32X_Offset);
2663 }
2664 pMEM_temp = (MS_U8 *)MS_PA2KSEG1(pMEM);
2665 FB_DBG(printf("[3]pMEM=0x%x, x:%u, y:%u, odd:%u\n",
2666 (int)pMEM, x, y, ((x / u16OffsetPixelAlign) & 0x1)));
2667
2668 if (FBInfo.bMemFormat422 == TRUE)
2669 {
2670 _MDrv_SC_WritePixel(&pMEM_temp[(x%u16OffsetPixelAlign)*2],
2671 FBInfo.bMemFormat422,
2672 pPoint,
2673 u16PointSize,
2674 (x&0x1));
2675 }
2676 else
2677 {
2678 _MDrv_SC_WritePixel(&pMEM_temp[(x%u16OffsetPixelAlign)*4],
2679 FBInfo.bMemFormat422,
2680 pPoint,
2681 u16PointSize,
2682 (x&0x1));
2683 }
2684 }
2685 }
2686 }
2687
2688 #if 1
2689 #define H_CAP_ADD_FOR_GARBAGE 2
2690 #define V_CAP_ADD_FOR_GARBAGE 2
2691
2692 typedef struct
2693 {
2694 MS_U8 u8NRenable;
2695 MS_U8 u8Memory_FMT;
2696 MS_U8 u8IPM_Memory_FMT;
2697 MS_U8 u8OPM_Memory_FMT;
2698
2699 SC_FRAMEBUF_INFO_t pFBInfo;
2700
2701 MS_U8 u8IPMux;
2702 MS_U8 u8IPClk;
2703 MS_U8 u8OPMux;
2704
2705 MS_U8 u8CapSource;
2706 MS_U8 u8CapMethod;
2707 MS_U8 u8User_Interlace;
2708 MS_WINDOW_TYPE capture_win;
2709 MS_BOOL bIsRGB_Format;
2710 MS_BOOL bIsHPreDown;
2711 MS_BOOL bIsVPreDown;
2712 MS_BOOL bIs444to422_filter;
2713 MS_U8 u8Bit_Format;
2714 MS_U32 u32IRQ_Mask;
2715 }XC_IPM_Setting_Status;
2716 //-------------------------------------------------------------------------------------------------
2717 /// Store the current Setting before reroute the path from VOP to IP
2718 /// @param pXC_PreSetting \b IN: The current setting before reroute
2719 /// @return @ref XC_IPM_Setting_Status
2720 //-------------------------------------------------------------------------------------------------
MApi_XC_Get_Current_Setting(void * pInstance,XC_IPM_Setting_Status * pXC_PreSetting)2721 void MApi_XC_Get_Current_Setting(void *pInstance, XC_IPM_Setting_Status *pXC_PreSetting)
2722 {
2723 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2724 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2725 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
2726 //Step3, Store original setting
2727 pXC_PreSetting->u8NRenable= HAL_SC_get_dnr_setting(pInstance, MAIN_WINDOW);
2728 //Step4, Get input/output display data format
2729 pXC_PreSetting->u8Memory_FMT = HAL_SC_get_memory_fmt(pInstance);
2730 pXC_PreSetting->u8OPM_Memory_FMT = HAL_SC_get_OPM_memory_fmt(pInstance);
2731 pXC_PreSetting->u8IPM_Memory_FMT = HAL_SC_get_IPM_memory_fmt(pInstance);
2732 //Step5, Store Memory Address for Capture
2733 Hal_SC_get_framebuf_Info(pInstance, &(pXC_PreSetting->pFBInfo), MAIN_WINDOW );
2734 //Step6, Store INT from Main Capture port
2735 pXC_PreSetting->u32IRQ_Mask = HAL_SC_get_IRQ_mask_0_31(pInstance);
2736 //Step7/8, Store IP MUX/Store IP Clock
2737 pXC_PreSetting->u8IPMux = HAL_SC_ip_get_ipmux(pInstance);
2738 pXC_PreSetting->u8IPClk = HAL_SC_ip_get_ipclk(pInstance);
2739 //Step9, Store OP MUX
2740 pXC_PreSetting->u8OPMux = HAL_SC_get_VOP_mux(pInstance);
2741 //Step10, Store Capture Source
2742 pXC_PreSetting->u8CapSource = HAL_SC_ip_get_capturesource(pInstance);
2743 //Step11,
2744 pXC_PreSetting->u8CapMethod = HAL_SC_ip_get_capture_method(pInstance);
2745 //Step12,
2746 pXC_PreSetting->u8User_Interlace= Hal_SC_ip_get_user_def_interlace_status(pInstance);
2747 //Step13, Store capture Infor
2748 Hal_SC_ip_get_capture_window(pInstance, &(pXC_PreSetting->capture_win), MAIN_WINDOW);
2749 //Setp14, Store capture format
2750 pXC_PreSetting->bIsRGB_Format = HAL_SC_ip_get_capture_format(pInstance);
2751 //Setp15, Store Pre_memory scaling down status
2752 //H Scaling Down enable
2753 pXC_PreSetting->bIsHPreDown = HAL_SC_ip_get_h_predown_info(pInstance);
2754 //V Scaling Down enable
2755 pXC_PreSetting->bIsHPreDown = HAL_SC_ip_get_v_predown_info(pInstance);
2756 //Step 16, Store the 444to422 setting
2757 pXC_PreSetting->bIs444to422_filter = HAL_SC_ip_get_444to422_filter_mod(pInstance);
2758 pXC_PreSetting->u8Bit_Format = HAL_SC_get_memory_bit_fmt(pInstance, MAIN_WINDOW);
2759 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
2760 }
2761 //-------------------------------------------------------------------------------------------------
2762 /// Setting for reroute the path from VOP to IP
2763 /// @param eXC_PreSetting \b IN: The new setting for reroute
2764 /// @param bRestore \b IN: Enable Restore mode or not
2765 //-------------------------------------------------------------------------------------------------
MApi_XC_Set_New_Setting(void * pInstance,XC_IPM_Setting_Status eXC_PreSetting,MS_BOOL bRestore)2766 void MApi_XC_Set_New_Setting(void *pInstance, XC_IPM_Setting_Status eXC_PreSetting, MS_BOOL bRestore)
2767 {
2768 //Step 3, Store original setting
2769 HAL_SC_enable_dnr(pInstance, eXC_PreSetting.u8NRenable, MAIN_WINDOW);
2770 //Step4, Set OP memory format
2771 HAL_SC_set_OPM_memory_fmt(pInstance, eXC_PreSetting.u8OPM_Memory_FMT);
2772
2773 //Step 5, Set Memory Address for Capture
2774 //Set IPM Offset and Fetch
2775 Hal_SC_set_framebuf_Info(pInstance, eXC_PreSetting.pFBInfo);
2776
2777 //Step 6, Set IRQ for Main Capture port
2778 HAL_SC_set_IRQ_mask_0_31(pInstance, eXC_PreSetting.u32IRQ_Mask);
2779 //Step 7/8, Set IP MUX and IP Clock
2780 HAL_SC_ip_set_ipmux(pInstance, eXC_PreSetting.u8IPMux);
2781 HAL_SC_ip_set_ipclk(pInstance, eXC_PreSetting.u8IPClk);
2782 //Step 9~12
2783 if(bRestore)
2784 {
2785 HAL_SC_set_capture_image2ip(pInstance, DISABLE);
2786 HAL_SC_set_VOP_mux(pInstance, eXC_PreSetting.u8OPMux);
2787
2788 HAL_SC_ip_set_capturesource(pInstance, eXC_PreSetting.u8CapSource);
2789 //Set Capture Method
2790 Hal_SC_ip_set_image_wrap(pInstance, (MS_BOOL)eXC_PreSetting.u8CapMethod&BIT(0),
2791 (MS_BOOL)eXC_PreSetting.u8CapMethod&BIT(1), MAIN_WINDOW);
2792 Hal_SC_ip_set_input_sync_reference_edge(pInstance, (MS_BOOL)eXC_PreSetting.u8CapMethod&BIT(3),
2793 (MS_BOOL)eXC_PreSetting.u8CapMethod&BIT(4), MAIN_WINDOW);
2794 Hal_SC_ip_set_input_vsync_delay(pInstance, (MS_BOOL)eXC_PreSetting.u8CapMethod&BIT(5), MAIN_WINDOW);
2795 Hal_SC_ip_set_de_only_mode(pInstance, (MS_BOOL)eXC_PreSetting.u8CapMethod&BIT(6), MAIN_WINDOW);
2796 //Disable User def Interlace mode
2797 Hal_SC_ip_set_user_def_interlace_status(pInstance, (MS_BOOL)eXC_PreSetting.u8User_Interlace&BIT(0),
2798 (MS_BOOL)eXC_PreSetting.u8User_Interlace&BIT(1),MAIN_WINDOW);
2799 HAL_SC_ip_set_444to422_filter_mod(pInstance, eXC_PreSetting.bIs444to422_filter);
2800 }
2801 else
2802 {
2803 HAL_SC_set_capture_image2ip(pInstance, ENABLE);
2804 /*BK0F_46_L[7:4]
2805 0 : VOP2_dp input data
2806 1 : BRI output
2807 2 : HBC output
2808 3 : CON_BRI output
2809 4 : FWC output
2810 5 : gamma output
2811 6 : noise dither output
2812 */
2813 HAL_SC_set_VOP_mux(pInstance, 0x50);
2814 //Set Input Source
2815 /* #000: Analog 1.
2816 #001: Analog 2.
2817 #010: Analog 3.
2818 #011: DVI.
2819 #100: Video.
2820 #101: HDTV
2821 #111: HDMI. */
2822 HAL_SC_ip_set_capturesource(pInstance, 0x03);
2823 //Set Capture Method
2824 Hal_SC_ip_set_image_wrap(pInstance, DISABLE, DISABLE, MAIN_WINDOW);
2825 Hal_SC_ip_set_input_sync_reference_edge(pInstance, DISABLE, DISABLE, MAIN_WINDOW);
2826 Hal_SC_ip_set_input_vsync_delay(pInstance, DISABLE, MAIN_WINDOW);
2827 Hal_SC_ip_set_de_only_mode(pInstance, DISABLE, MAIN_WINDOW);
2828 //Disable User def Interlace mode
2829 Hal_SC_ip_set_user_def_interlace_status(pInstance, DISABLE, DISABLE,MAIN_WINDOW);
2830
2831 }
2832
2833 //Step 13, Set New Capture Window
2834 Hal_SC_ip_set_capture_v_start(pInstance, eXC_PreSetting.capture_win.y , MAIN_WINDOW);
2835 Hal_SC_ip_set_capture_h_start(pInstance, eXC_PreSetting.capture_win.x , MAIN_WINDOW);
2836 Hal_SC_ip_set_capture_v_size(pInstance, eXC_PreSetting.capture_win.height, MAIN_WINDOW);
2837 Hal_SC_ip_set_capture_h_size(pInstance, eXC_PreSetting.capture_win.width, MAIN_WINDOW);
2838 //Step 14, Set capture format, Default Display out is RGB
2839 HAL_SC_ip_set_capture_format(pInstance, eXC_PreSetting.bIsRGB_Format);
2840 //Step 15, setting H/V pre down mode
2841 HAL_SC_ip_set_h_predown_info(pInstance, eXC_PreSetting.bIsHPreDown);
2842 HAL_SC_ip_set_v_predown_info(pInstance, eXC_PreSetting.bIsVPreDown);
2843 //Step 16, Set Capture memory store format
2844 HAL_SC_set_IPM_memory_fmt(pInstance, eXC_PreSetting.u8IPM_Memory_FMT);
2845
2846 }
MApi_XC_Rerout_for_Capture_VOP_Data(void * pInstance)2847 void MApi_XC_Rerout_for_Capture_VOP_Data(void *pInstance)
2848 {
2849 XC_IPM_Setting_Status stXC_PreSetting;
2850 XC_IPM_Setting_Status stXC_NewSetting;
2851 MS_U16 u16NewIPMFetch, u16NewIPMOffset;
2852 SC_FRAMEBUF_INFO_t FBInfo;
2853
2854 memset(&stXC_PreSetting,0,sizeof(XC_IPM_Setting_Status));
2855 memset(&stXC_NewSetting,0,sizeof(XC_IPM_Setting_Status));
2856 //Step 1, Freeze image
2857 Hal_SC_set_freezeimg(pInstance, ENABLE, MAIN_WINDOW);
2858 //Step 2, Wait 1/20 second
2859 MsOS_DelayTaskUs(50); //wait at 1/20 second
2860
2861 //Store Current setting
2862 MApi_XC_Get_Current_Setting(pInstance, &stXC_PreSetting);
2863 //Init the value using pre setting value
2864 memcpy(&stXC_NewSetting, &stXC_PreSetting, sizeof(XC_IPM_Setting_Status));
2865 //Set the new setting
2866 stXC_NewSetting.u8NRenable=0x00;
2867 switch(stXC_PreSetting.u8Memory_FMT)
2868 {
2869 case 0:
2870 stXC_NewSetting.u8OPM_Memory_FMT=0x00;
2871 break;
2872 case 1:
2873 stXC_NewSetting.u8OPM_Memory_FMT=0x05;
2874 break;
2875 case 4:
2876 stXC_NewSetting.u8OPM_Memory_FMT=0x06;
2877 break;
2878 case 5:
2879 stXC_NewSetting.u8OPM_Memory_FMT=0x0B;
2880 break;
2881 case 6:
2882 stXC_NewSetting.u8OPM_Memory_FMT=0x05;
2883 break;
2884 case 7:
2885 default:
2886 stXC_NewSetting.u8OPM_Memory_FMT=0x00;
2887 break;
2888 }
2889
2890
2891 u16NewIPMFetch = (stXC_PreSetting.pFBInfo.u16IPMFetch + H_CAP_ADD_FOR_GARBAGE)&~1;
2892
2893 if(u16NewIPMFetch > MST_LINE_BFF_MAX)
2894 u16NewIPMFetch = MST_LINE_BFF_MAX;
2895 u16NewIPMOffset = u16NewIPMFetch;
2896 if(u16NewIPMOffset & 0x0F)
2897 u16NewIPMOffset = (u16NewIPMOffset & 0xFFF0) + 16;
2898
2899 u16NewIPMFetch = (u16NewIPMFetch + 1) & ~1;
2900 stXC_NewSetting.pFBInfo.u16IPMFetch = u16NewIPMFetch;
2901 stXC_NewSetting.pFBInfo.u16IPMOffset = u16NewIPMOffset;
2902 // TODO: Implement V Length
2903 //stXC_NewSetting.pFBInfo->u16VLength =;
2904 stXC_NewSetting.pFBInfo.bLinearAddrMode = TRUE;
2905 stXC_NewSetting.u32IRQ_Mask = stXC_NewSetting.u32IRQ_Mask|0x033C03C0;
2906 stXC_NewSetting.u8IPMux = 0x70;
2907 stXC_NewSetting.u8IPClk = 0x1C;
2908 //Step 14, Set capture format YCbCr/RGB by Display out format
2909 //Default is RGB
2910 stXC_NewSetting.bIsRGB_Format=FALSE;
2911
2912 stXC_NewSetting.bIsHPreDown=DISABLE;
2913 stXC_NewSetting.bIsVPreDown=DISABLE;
2914 Hal_SC_get_framebuf_Info(pInstance, &FBInfo, MAIN_WINDOW);
2915 if (FBInfo.bMemFormat422 == TRUE)
2916 {
2917 if (FBInfo.u8BitPerPixel == 20)//24
2918 {
2919 FB_DBG(printf("YC 422_10BIT\n"));
2920 stXC_NewSetting.u8IPM_Memory_FMT=0x05;
2921 stXC_NewSetting.u8Bit_Format=0x00;
2922 }
2923 else //if (FBInfo.u8BitPerPixel == 16)
2924 {
2925 FB_DBG(printf("YC 422_8BIT\n"));
2926 stXC_NewSetting.u8IPM_Memory_FMT=0x00;
2927 stXC_NewSetting.u8Bit_Format=0x00;
2928 }
2929 }
2930 else
2931 {
2932 if (FBInfo.u8BitPerPixel == 24)
2933 {
2934 FB_DBG(printf("RGB/YCbCr 444_8BIT\n"));
2935 stXC_NewSetting.u8IPM_Memory_FMT=0x01;
2936 stXC_NewSetting.u8Bit_Format=0x01;
2937 }
2938 }
2939 MApi_XC_Set_New_Setting(pInstance, stXC_NewSetting, DISABLE);
2940 //Step 17, Wait 1/20 second
2941 MsOS_DelayTaskUs(50); //wait at 1/20 second
2942 //Step 18, Set Capture Enable/Start
2943 HAL_SC_set_IPM_capture_start(pInstance, ENABLE);
2944 //Step 19, Wait 1/20 second
2945 MsOS_DelayTaskUs(50); //wait at 1/20 second
2946 //Step 20, Set Capture Disable/Stop
2947 HAL_SC_set_IPM_capture_start(pInstance, DISABLE);
2948 //Step 21, Wait 1/20 second
2949 MsOS_DelayTaskUs(50); //wait at 1/20 second
2950
2951 //Restore the previous setting
2952 MApi_XC_Set_New_Setting(pInstance, stXC_PreSetting, ENABLE);
2953 //Step 24, Wait 1/20 second
2954 MsOS_DelayTaskUs(50); //wait at 1/20 second
2955
2956 //Step 26, Freeze image
2957 Hal_SC_set_freezeimg(pInstance, DISABLE, MAIN_WINDOW);
2958
2959 }
2960
2961 #endif
2962
2963 //-------------------------------------------------------------------------------------------------
2964 /// Get the average data from memory
2965 /// @param mem_win \b IN: The window position and size
2966 /// @return @ref MS_AUTOADC_TYPE
2967 //-------------------------------------------------------------------------------------------------
MApi_XC_GetAverageDataFromMemory(void * pInstance,MS_WINDOW_TYPE * mem_win)2968 MS_AUTOADC_TYPE MApi_XC_GetAverageDataFromMemory(void *pInstance, MS_WINDOW_TYPE* mem_win)
2969 {
2970
2971 MS_IMAGE_MEM_INFO pMemInfo;
2972 _XC_ENTRY(pInstance);
2973 pMemInfo.eCal_Win_Size.u16X = mem_win->x ;
2974 pMemInfo.eCal_Win_Size.u16Y = mem_win->y ;
2975 pMemInfo.eCal_Win_Size.u16Xsize = mem_win->width;
2976 pMemInfo.eCal_Win_Size.u16Ysize = mem_win->height ;
2977 MApi_XC_ReadRgbData(pInstance, &pMemInfo);
2978 _XC_RETURN(pInstance);
2979 return pMemInfo.pixelAverage;
2980
2981 #if 0
2982
2983 #define GET_MEMAVG_WITHOUT_MAXMIN 0
2984 #define ADC_READ_PATTERN_FROM_EXTERNAL_SIGNAL 0
2985
2986 #define RGB_CAL_MEM_BLOCKSIZE (16)
2987 #define SCALER_SLOT_SIZE (16) // 128 bits
2988
2989 #define RGB_CAL_BYTES_PER_PIXEL (4)
2990 #define RGB_CAL_PIXELS_PER_SLOT (SCALER_SLOT_SIZE/RGB_CAL_BYTES_PER_PIXEL)
2991
2992 MS_AUTOADC_TYPE ptAdcData;
2993 MS_U8 *pu8VirMemBaseAdr, *pu8VirPixelAdr;
2994 MS_U32 u32PixelAddrOffset;
2995 MS_U32 u32Rtt, u32Gtt, u32Btt;
2996 MS_U32 i, x, y, tmp;
2997 MS_U16 u16LineOffset;
2998 MS_U8 u8Bank;
2999 MS_U16 u16MemVStart, u16MemHStart, u16CaptureHStart, u16CaptureVStart;
3000 MS_U16 u16MemVEnd, u16MemHEnd, u16CaptureHSize, u16CaptureVSize;
3001
3002 #if GET_MEMAVG_WITHOUT_MAXMIN
3003 MS_U16 u16MaxR,u16MaxG,u16MaxB;
3004 MS_U16 u16MinR,u16MinG,u16MinB;
3005 MS_U16 u16NumMaxR,u16NumMaxG,u16NumMaxB;
3006 MS_U16 u16NumMinR,u16NumMinG,u16NumMinB;
3007 MS_U16 u16NoMinMaxAvgCb, u16NoMinMaxAvgY, u16NoMinMaxAvgCr;
3008 #endif
3009
3010 SC_MEM_YUV444_FMT_t sMemBuf[mem_win->height * mem_win->width];
3011
3012
3013 ptAdcData.u16CH_AVG[0] = ptAdcData.u16CH_AVG[1] = ptAdcData.u16CH_AVG[2] = 0;
3014
3015
3016 //SC_BK_STORE;
3017 u8Bank = MDrv_ReadByte(BK_SELECT_00);
3018
3019 // get line offset
3020 MDrv_WriteByte(BK_SELECT_00, REG_BANK_SCMI);
3021 u16LineOffset = MDrv_Read2Byte(L_BK_SCMI(0x0E));
3022 msg_sc_ip(printf("F2 IP frame buffer line offset (pixel unit) %d\n", u16LineOffset));
3023
3024
3025 pu8VirMemBaseAdr = (MS_U8*)g_XC_InitData.u32Main_FB_Start_Addr;
3026 msg_sc_ip(printf("DNR Buf Adr 0x%lx\n", (MS_U32)pu8VirMemBaseAdr));
3027
3028
3029 i = 0;
3030 u32Rtt = 0;
3031 u32Gtt = 0;
3032 u32Btt = 0;
3033
3034 #if GET_MEMAVG_WITHOUT_MAXMIN
3035 u16MaxR = 0;
3036 u16MaxG = 0;
3037 u16MaxB = 0;
3038 u16MinR = 0;
3039 u16MinG = 0;
3040 u16MinB = 0;
3041
3042 u16NumMaxR = 0;
3043 u16NumMaxG = 0;
3044 u16NumMaxB = 0;
3045 u16NumMinR = 0;
3046 u16NumMinG = 0;
3047 u16NumMinB = 0;
3048
3049 u16NoMinMaxAvgCb = 0;
3050 u16NoMinMaxAvgY = 0;
3051 u16NoMinMaxAvgCr = 0;
3052 #endif
3053
3054 MDrv_WriteByte(BK_SELECT_00, REG_BANK_IP1F2);
3055 u16CaptureVStart = MDrv_Read2Byte(L_BK_IP1F2(0x04));
3056 u16CaptureHStart = MDrv_Read2Byte(L_BK_IP1F2(0x05));
3057 u16CaptureVSize = MDrv_Read2Byte(L_BK_IP1F2(0x06));
3058 u16CaptureHSize = MDrv_Read2Byte(L_BK_IP1F2(0x07));
3059 u16MemVStart = 0;
3060 u16MemHStart = 0;
3061 u16MemVEnd = u16CaptureVSize;
3062 u16MemHEnd = u16CaptureHSize;
3063
3064
3065 msg_sc_ip(printf("Capture H Start %d V Start %d\n", u16CaptureHStart, u16CaptureVStart));
3066 msg_sc_ip(printf("Capture H End %d V Eend %d\n",
3067 (u16CaptureHStart + u16CaptureHSize),
3068 (u16CaptureVStart + u16CaptureVSize)));
3069
3070 u16MemVStart = mem_win->y;
3071 u16MemHStart = mem_win->x;
3072
3073 /*
3074 switch (u8Position)
3075 {
3076 case 0: //Frame
3077 u16MemVStart = 0;
3078 u16MemHStart = 0;
3079 break;
3080 case 1: //Up-Left Coner
3081 u16MemVStart = 0;
3082 u16MemHStart = 0;
3083 break;
3084 case 2: //Up-Right Coner
3085 u16MemVStart = 0;
3086 u16MemHStart = u16MemHEnd - mem_win->width;
3087 break;
3088 case 3: //Bottom-Left Coner
3089 u16MemVStart = u16MemVEnd - mem_win->height;
3090 u16MemHStart = 0;
3091 break;
3092 case 4: //Bottom-Right Coner
3093 u16MemVStart = u16MemVEnd - mem_win->height;
3094 u16MemHStart = u16MemHEnd - mem_win->width;
3095 break;
3096 case 5: //Center
3097 u16MemVStart = ((u16MemVEnd - u16MemVStart) / 2) - (mem_win->height / 2);
3098 u16MemHStart = ((u16MemHEnd - u16MemHStart) / 2) - (mem_win->width / 2);
3099 break;
3100 #if ADC_READ_PATTERN_FROM_EXTERNAL_SIGNAL
3101 case 6: //White - Panel 1366x768, MSPG-925FS Model:217(1280x720p), Pattern: 15 (8 color bar)
3102 u16MemVStart = 0x170;
3103 u16MemHStart = 0x20;
3104 break;
3105 case 7: //Black - Panel 1366x768, MSPG-925FS Model:217(1280x720p), Pattern: 15 (8 color bar)
3106 u16MemVStart = 0x170;
3107 u16MemHStart = 0x520;
3108 break;
3109 #endif
3110 default:
3111 break;
3112 }
3113 */
3114
3115 #if ADC_READ_PATTERN_FROM_EXTERNAL_SIGNAL
3116 msg_sc_ip(printf("Block Positon (%d, %d) size %dx%d\n",
3117 u16MemHStart,
3118 u16MemVStart,
3119 u16HBlockSize,
3120 mem_win.height));
3121 // Enable Debug Cross
3122 MDrv_WriteByte(BK_SELECT_00, REG_BANK_DLC);
3123 MDrv_WriteRegBit(L_BK_DLC(0x68), ENABLE, BIT(0));
3124 for(y=u16MemVStart; y<u16MemVStart+mem_win->height; y++)
3125 {
3126 for(x=u16MemHStart; x<u16MemHStart+mem_win->width; x++)
3127 {
3128 MS_U16 u16Y, u16Cb, u16Cr;
3129
3130 MDrv_WriteByte(BK_SELECT_00, REG_BANK_DLC);
3131
3132 MDrv_Write2Byte(L_BK_DLC(0x69), x);
3133 MDrv_Write2Byte(L_BK_DLC(0x6A), y);
3134
3135 MsOS_DelayTask(10);
3136
3137 u16Y = (MDrv_Read2Byte(L_BK_DLC(0x6B)) & 0x03FF);
3138 u16Cb = (MDrv_Read2Byte(L_BK_DLC(0x6C)) & 0x03FF);
3139 u16Cr = (MDrv_Read2Byte(L_BK_DLC(0x6D)) & 0x03FF);
3140
3141 //printf("Y = 0x%04x, Cb = 0x%04x, Cr = 0x%04x\n", u16Y, u16Cb, u16Cr);
3142 u32Rtt += u16Cr;
3143 u32Gtt += u16Y;
3144 u32Btt += u16Cb;
3145 }
3146 }
3147 // Disable Debug Cross
3148 MDrv_WriteByte(BK_SELECT_00, REG_BANK_DLC);
3149 MDrv_WriteRegBit(L_BK_DLC(0x68), DISABLE, BIT(0));
3150
3151 ptAdcData.u16CH_AVG[0] = u32Rtt / (mem_win.height * mem_win->width);
3152 ptAdcData.u16CH_AVG[1] = u32Gtt / (mem_win.height * mem_win->width);
3153 ptAdcData.u16CH_AVG[2] = u32Btt / (mem_win.height * mem_win->width);
3154
3155 //SC_BK_RESTORE;
3156 MDrv_WriteByte(BK_SELECT_00, u8Bank);
3157
3158 msg_sc_ip(printf("AvgCr AvgY AvgCb\n"));
3159 msg_sc_ip(printf("%04d %04d %04d\n\n", ptAdcData.R_CH_AVG, ptAdcData.G_CH_AVG, ptAdcData.B_CH_AVG));
3160
3161
3162 #else
3163
3164
3165 msg_sc_ip(printf("Block Positon (%d, %d) Mem Start (%d, %d) size %dx%d\n",
3166 (u16MemHStart + u16CaptureHStart),
3167 (u16MemVStart + u16CaptureVStart),
3168 u16MemHStart,
3169 u16MemVStart,
3170 mem_win->width,
3171 mem_win->height));
3172
3173
3174 for(y=u16MemVStart; y<u16MemVStart+mem_win->height; y++)
3175 {
3176 for(x=u16MemHStart; x<u16MemHStart+mem_win->width; x++)
3177 {
3178 u32PixelAddrOffset = y * u16LineOffset * RGB_CAL_BYTES_PER_PIXEL * 2;
3179 u32PixelAddrOffset += ((MS_U32)(x / RGB_CAL_PIXELS_PER_SLOT)) * SCALER_SLOT_SIZE * 2;
3180 pu8VirPixelAdr = pu8VirMemBaseAdr + u32PixelAddrOffset +
3181 (x % RGB_CAL_PIXELS_PER_SLOT) * RGB_CAL_BYTES_PER_PIXEL;
3182
3183 memcpy(&(sMemBuf[i]), pu8VirPixelAdr, RGB_CAL_BYTES_PER_PIXEL);
3184 memcpy(&tmp, pu8VirPixelAdr, RGB_CAL_BYTES_PER_PIXEL);
3185
3186
3187 #if GET_MEMAVG_WITHOUT_MAXMIN
3188 if (i == 0)
3189 {
3190 //printf("pu8VirPixelAdr 0x%lx\n", (U32)pu8VirPixelAdr);
3191 u16MaxR = sMemBuf[i].Cr;
3192 u16MinR = sMemBuf[i].Cr;
3193 u16MaxG = sMemBuf[i].Y;
3194 u16MinG = sMemBuf[i].Y;
3195 u16MaxB = sMemBuf[i].Cb;
3196 u16MinB = sMemBuf[i].Cb;
3197 u16NumMaxR = 1;
3198 u16NumMaxG = 1;
3199 u16NumMaxB = 1;
3200 u16NumMinR = 1;
3201 u16NumMinG = 1;
3202 u16NumMinB = 1;
3203 //while (1);
3204 }
3205 else
3206 {
3207 if (sMemBuf[i].Cr > u16MaxR)
3208 {
3209 u16MaxR = sMemBuf[i].Cr;
3210 u16NumMaxR = 1;
3211 }
3212 else if (sMemBuf[i].Cr == u16MaxR)
3213 {
3214 u16NumMaxR++;
3215 }
3216
3217 if (sMemBuf[i].Cr < u16MinR)
3218 {
3219 u16MinR = sMemBuf[i].Cr;
3220 u16NumMinR = 1;
3221 }
3222 else if (sMemBuf[i].Cr == u16MinR)
3223 {
3224 u16NumMinR++;
3225 }
3226
3227
3228 if (sMemBuf[i].Y > u16MaxG)
3229 {
3230 u16MaxG = sMemBuf[i].Y;
3231 u16NumMaxG = 1;
3232 }
3233 else if (sMemBuf[i].Y == u16MaxG)
3234 {
3235 u16NumMaxG++;
3236 }
3237
3238 if (sMemBuf[i].Y < u16MinG)
3239 {
3240 u16MinG = sMemBuf[i].Y;
3241 u16NumMinG = 1;
3242 }
3243 else if (sMemBuf[i].Y == u16MinG)
3244 {
3245 u16NumMinG++;
3246 }
3247
3248 if (sMemBuf[i].Cb > u16MaxB)
3249 {
3250 u16MaxB = sMemBuf[i].Cb;
3251 u16NumMaxB = 1;
3252 }
3253 else if (sMemBuf[i].Cb == u16MaxB)
3254 {
3255 u16NumMaxB++;
3256 }
3257
3258 if (sMemBuf[i].Cb < u16MinB)
3259 {
3260 u16MinB = sMemBuf[i].Cb;
3261 u16NumMinB = 1;
3262 }
3263 else if (sMemBuf[i].Cb == u16MinB)
3264 {
3265 u16NumMinB++;
3266 }
3267 }
3268 #endif
3269 u32Rtt += sMemBuf[i].Cr;
3270 u32Gtt += sMemBuf[i].Y;
3271 u32Btt += sMemBuf[i].Cb;
3272 i++;
3273 }
3274 }
3275
3276
3277
3278 #if 0
3279 printf("\n");
3280
3281 printf("CrBlock %dx%d", u16HBlockSize, u16VBlockSize);
3282 for (i = 0; i < (u16VBlockSize * u16HBlockSize); i++)
3283 {
3284 if ((i % u16HBlockSize) == 0)
3285 {
3286 printf("\n");
3287 }
3288 printf("%04d ", sMemBuf[i].Cr);
3289 }
3290 printf("\n");
3291
3292 printf("YBlock %dx%d", u16HBlockSize, u16VBlockSize);
3293 for (i = 0; i < (u16VBlockSize * u16HBlockSize); i++)
3294 {
3295 if ((i % u16HBlockSize) == 0)
3296 {
3297 printf("\n");
3298 }
3299 printf("%04d ", sMemBuf[i].Y);
3300 }
3301 printf("\n");
3302
3303 printf("CbBlock %dx%d", u16HBlockSize, u16VBlockSize);
3304 for (i = 0; i < (u16VBlockSize * u16HBlockSize); i++)
3305 {
3306 if ((i % u16HBlockSize) == 0)
3307 {
3308 printf("\n");
3309 }
3310 printf("%04d ", sMemBuf[i].Cb);
3311 }
3312 printf("\n");
3313 #endif
3314
3315 #if GET_MEMAVG_WITHOUT_MAXMIN
3316 tmp = u32Rtt - ((MS_U32)u16MaxR * (MS_U32)u16NumMaxR) - ((MS_U32)u16MinR * (MS_U32)u16NumMinR);
3317 if ( tmp != 0 )
3318 {
3319 u16NoMinMaxAvgCr = tmp / ((mem_win->height * mem_win->width) - (u16NumMaxR + u16NumMinR));
3320 }
3321
3322 tmp = u32Gtt - ((MS_U32)u16MaxG * (MS_U32)u16NumMaxG) - ((MS_U32)u16MinG * (MS_U32)u16NumMinG);
3323 if ( tmp != 0 )
3324 {
3325 u16NoMinMaxAvgY = tmp / ((mem_win->height * mem_win->width) - (u16NumMaxG + u16NumMinG));
3326 }
3327
3328 tmp = u32Btt - ((MS_U32)u16MaxB * (MS_U32)u16NumMaxB) - ((MS_U32)u16MinB * (MS_U32)u16NumMinB);
3329 if ( tmp != 0 )
3330 {
3331 u16NoMinMaxAvgCb = tmp / ((mem_win->height * mem_win->width) - (u16NumMaxB + u16NumMinB));
3332 }
3333 #endif
3334
3335 ptAdcData.u16CH_AVG[0] = u32Rtt / (mem_win->height * mem_win->width);
3336 ptAdcData.u16CH_AVG[1] = u32Gtt / (mem_win->height * mem_win->width);
3337 ptAdcData.u16CH_AVG[2] = u32Btt / (mem_win->height * mem_win->width);
3338
3339
3340 //SC_BK_RESTORE;
3341 MDrv_WriteByte(BK_SELECT_00, u8Bank);
3342
3343 msg_sc_ip( printf("ptAdcData[%04d,%04d,%04d]\n",ptAdcData.R_CH_AVG,ptAdcData.G_CH_AVG,ptAdcData.B_CH_AVG) );
3344
3345 #if GET_MEMAVG_WITHOUT_MAXMIN
3346 printf("MaxCr MinCr MaxY MinY MaxCb MinCb AvgCr AvgY AvgCb\n");
3347 printf("%04d %04d %04d %04d %04d %04d %04d %04d %04d\n",
3348 u16MaxR, u16MinR, u16MaxG, u16MinG, u16MaxB, u16MinB, ptAdcData.R_CH_AVG, ptAdcData.G_CH_AVG, ptAdcData.B_CH_AVG);
3349
3350 printf("NumMaxCr NumMinCr NumMaxY NumMinY NumMaxCb NumMinCb AvgCr AvgY AvgCr\n");
3351 printf("%04d %04d %04d %04d %04d %04d %04d %04d %04d\n\n",
3352 u16NumMaxR, u16NumMinR, u16NumMaxG, u16NumMinG, u16NumMaxB, u16NumMinB, u16NoMinMaxAvgCr, u16NoMinMaxAvgY, u16NoMinMaxAvgCb);
3353 #endif
3354
3355 #endif
3356
3357 return ptAdcData;
3358 #endif
3359
3360 }
3361
3362
3363
MDrv_XC_wait_input_vsync(void * pInstance,MS_U8 u8NumVSyncs,MS_U16 u16Timeout,SCALER_WIN eWindow)3364 MS_U8 MDrv_XC_wait_input_vsync(void *pInstance, MS_U8 u8NumVSyncs, MS_U16 u16Timeout, SCALER_WIN eWindow)
3365 {
3366 MS_U32 u32Time;
3367 MS_U8 u8VsyncPolarity = Hal_SC_ip_get_input_vsync_polarity(pInstance);
3368 MS_U8 bVSync = !u8VsyncPolarity;
3369 MS_U8 u8VSyncVal;
3370 u32Time = MsOS_GetSystemTime();
3371
3372 while (1)
3373 {
3374 u8VSyncVal = Hal_SC_ip_get_input_vsync_value(pInstance, eWindow);
3375
3376 //for Special case,(like U4) if no subwindow, don't wait vsync. break immediately
3377 if(u8VSyncVal == 0xFF)
3378 break;
3379
3380 if (u8VSyncVal == bVSync)
3381 {
3382 if ((bVSync == u8VsyncPolarity) && --u8NumVSyncs == 0)
3383 break;
3384 bVSync = !bVSync;
3385 }
3386
3387 if ( ( MsOS_GetSystemTime() - u32Time) >= u16Timeout )
3388 {
3389 break;
3390 }
3391 }
3392
3393 return u8NumVSyncs;
3394 }
3395
MDrv_XC_wait_output_vsync(void * pInstance,MS_U8 u8NumVSyncs,MS_U16 u16Timeout,SCALER_WIN eWindow)3396 MS_U8 MDrv_XC_wait_output_vsync(void *pInstance, MS_U8 u8NumVSyncs, MS_U16 u16Timeout, SCALER_WIN eWindow)
3397 {
3398 MS_U32 u32Time;
3399 MS_U8 bVSync;
3400 MS_U8 u8VSyncVal;
3401
3402 if(u8NumVSyncs == 0)
3403 {
3404 return u8NumVSyncs;
3405 }
3406
3407 bVSync = 1;
3408 u32Time = MsOS_GetSystemTime();
3409
3410 while (1)
3411 {
3412 u8VSyncVal = Hal_SC_ip_get_output_vsync_value(pInstance, eWindow);
3413
3414 //for Special case,(like U4) if no subwindow don't wait vsync. break immediately
3415 if(u8VSyncVal == 0xFF)
3416 break;
3417
3418 if (u8VSyncVal == bVSync)
3419 {
3420 if (bVSync)
3421 {
3422 u8NumVSyncs -= 1;
3423 if (u8NumVSyncs == 0)
3424 break;
3425 }
3426 bVSync = !bVSync;
3427 }
3428
3429 if ( (MsOS_GetSystemTime() - u32Time) >= u16Timeout )
3430 {
3431 break;
3432 }
3433 }
3434 return u8NumVSyncs;
3435 }
3436
3437 //-------------------------------------------------------------------------------------------------
3438 // This function will delay both 'u32DelayTime' ms and vsync signal
3439 // @param u32DelayTime \b IN: delay time in ms unit
3440 // @return MS_U32: real time cost of this timedelay
3441 //-------------------------------------------------------------------------------------------------
MDrv_XC_DelayAndWaitOutVsync(void * pInstance,MS_U32 u32DelayTime,SCALER_WIN eWindow)3442 MS_U32 MDrv_XC_DelayAndWaitOutVsync(void *pInstance, MS_U32 u32DelayTime, SCALER_WIN eWindow)
3443 {
3444 #define TIME_OUPUTVSYNC_TIMEOUT 30
3445
3446 MS_U32 u32TimeStart, u32TimeSpend=0;
3447 MS_U8 bVSync;
3448 MS_U8 u8VSyncVal;
3449
3450 bVSync = 1;
3451 u32TimeStart = MsOS_GetSystemTime();
3452
3453 while (1)
3454 {
3455 u8VSyncVal = Hal_SC_ip_get_output_vsync_value(pInstance, eWindow);
3456 //for Special case,(like U4) if no subwindow don't wait vsync. break immediately
3457 if(u8VSyncVal == 0xFF)
3458 break;
3459 if (u8VSyncVal == bVSync)
3460 {
3461 if ((u32TimeSpend >= u32DelayTime) && !bVSync)
3462 {
3463 //delay time is enough and now is also vsync ,so break
3464 break;
3465 }
3466 bVSync = !bVSync;
3467 }
3468 if (u32TimeSpend >= (u32DelayTime + TIME_OUPUTVSYNC_TIMEOUT))
3469 {
3470 //wait vysnc time out
3471 break;
3472 }
3473 u32TimeSpend = MsOS_GetSystemTime() - u32TimeStart;
3474 }
3475 return u32TimeSpend;
3476 }
3477 //-------------------------------------------------------------------------------------------------
3478 /// This function will calculate and return H Frequency x 10
3479 /// @param u16HPeriod \b IN: Horizontal period
3480 /// @return MS_U16: H Frequency x 10
3481 //-------------------------------------------------------------------------------------------------
MDrv_XC_CalculateHFreqx10(void * pInstance,MS_U16 u16HPeriod)3482 MS_U16 MDrv_XC_CalculateHFreqx10(void* pInstance, MS_U16 u16HPeriod)
3483 {
3484 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3485 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3486 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3487 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3488 if(u16HPeriod)
3489 {
3490 return ( (((MS_U32)pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32XTAL_Clock + (u16HPeriod/2)) / u16HPeriod ) / 100 ); //KHz
3491 }
3492 else
3493 {
3494 return 1; // avoid devide by 0 error
3495 }
3496 }
3497
MApi_XC_CalculateHFreqx10_U2(void * pInstance,MS_U16 u16HPeriod)3498 MS_U16 MApi_XC_CalculateHFreqx10_U2(void* pInstance, MS_U16 u16HPeriod)
3499 {
3500 MS_U16 u16Return = 0;
3501 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3502 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3503 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3504 u16Return = MDrv_XC_CalculateHFreqx10(pInstance, u16HPeriod);
3505 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3506 return u16Return;
3507 }
3508
MApi_XC_CalculateHFreqx10(MS_U16 u16HPeriod)3509 MS_U16 MApi_XC_CalculateHFreqx10(MS_U16 u16HPeriod)
3510 {
3511 if (pu32XCInst == NULL)
3512 {
3513 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3514 return 0;
3515 }
3516
3517 stXC_GET_HFREQX10 XCArgs;
3518 XCArgs.u16HPeriod = u16HPeriod;
3519 XCArgs.u16ReturnValue = 0;
3520
3521 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_HFREQX10, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3522 {
3523 printf("Obtain XC engine fail\n");
3524 return 0;
3525 }
3526 else
3527 {
3528 return XCArgs.u16ReturnValue;
3529 }
3530 }
3531
3532 //-------------------------------------------------------------------------------------------------
3533 /// This function will calculate and return H Frequency x 1000
3534 /// @param u16HPeriod \b IN: Horizontal period
3535 /// @return MS_U32: H Frequency x 1000
3536 //-------------------------------------------------------------------------------------------------
MDrv_XC_CalculateHFreqx1K(void * pInstance,MS_U16 u16HPeriod)3537 MS_U32 MDrv_XC_CalculateHFreqx1K(void *pInstance, MS_U16 u16HPeriod)
3538 {
3539 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3540 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3541 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3542 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3543 if(u16HPeriod)
3544 {
3545 return (((MS_U32)pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32XTAL_Clock + (u16HPeriod/2)) / u16HPeriod ); //MHz
3546 }
3547 else
3548 {
3549 return 1; // avoid devide by 0 error
3550 }
3551 }
3552
MApi_XC_CalculateHFreqx1K_U2(void * pInstance,MS_U16 u16HPeriod)3553 MS_U32 MApi_XC_CalculateHFreqx1K_U2(void* pInstance, MS_U16 u16HPeriod)
3554 {
3555 MS_U32 u32Return = 0;
3556 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3557 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3558 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3559 u32Return = MDrv_XC_CalculateHFreqx1K(pInstance, u16HPeriod);
3560 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3561 return u32Return;
3562 }
3563
MApi_XC_CalculateHFreqx1K(MS_U16 u16HPeriod)3564 MS_U32 MApi_XC_CalculateHFreqx1K(MS_U16 u16HPeriod)
3565 {
3566 if (pu32XCInst == NULL)
3567 {
3568 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3569 return 0;
3570 }
3571
3572 stXC_GET_HFREQX1K XCArgs;
3573 XCArgs.u16HPeriod = u16HPeriod;
3574 XCArgs.u32ReturnValue = 0;
3575
3576 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_HFREQX1K, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3577 {
3578 printf("Obtain XC engine fail\n");
3579 return 0;
3580 }
3581 else
3582 {
3583 return XCArgs.u32ReturnValue;
3584 }
3585 }
3586
3587 //-------------------------------------------------------------------------------------------------
3588 /// This function will calculate and return V Frequency x 10
3589 /// @param u16HFreqx10 \b IN: Horizontal frequency x 10
3590 /// @param u16VTotal \b IN: Vertical Total, usually the scan lines counts of a frame
3591 /// @return MS_U16: V Frequency x 10
3592 //-------------------------------------------------------------------------------------------------
MDrv_XC_CalculateVFreqx10(void * pInstance,MS_U16 u16HFreqx10,MS_U16 u16VTotal)3593 MS_U16 MDrv_XC_CalculateVFreqx10(void *pInstance, MS_U16 u16HFreqx10, MS_U16 u16VTotal)
3594 {
3595 if(u16HFreqx10 && u16VTotal)
3596 {
3597 return ( (((MS_U32)u16HFreqx10 * 1000 ) + (u16VTotal/2)) / u16VTotal ); // Hz
3598 }
3599 else
3600 {
3601 return 0;
3602 }
3603 }
3604
MApi_XC_CalculateVFreqx10_U2(void * pInstance,MS_U16 u16HFreq,MS_U16 u16VTotal)3605 MS_U16 MApi_XC_CalculateVFreqx10_U2(void* pInstance, MS_U16 u16HFreq, MS_U16 u16VTotal)
3606 {
3607 MS_U16 u16Return = 0;
3608 u16Return = MDrv_XC_CalculateVFreqx10(pInstance, u16HFreq, u16VTotal);
3609 return u16Return;
3610 }
3611
MApi_XC_CalculateVFreqx10(MS_U16 u16HFreq,MS_U16 u16VTotal)3612 MS_U16 MApi_XC_CalculateVFreqx10(MS_U16 u16HFreq, MS_U16 u16VTotal)
3613 {
3614 if (pu32XCInst == NULL)
3615 {
3616 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3617 return 0;
3618 }
3619
3620 stXC_GET_VFREQX10 XCArgs;
3621 XCArgs.u16HFreq = u16HFreq;
3622 XCArgs.u16VTotal = u16VTotal;
3623 XCArgs.u16ReturnValue = 0;
3624
3625 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_VFREQX10, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3626 {
3627 printf("Obtain XC engine fail\n");
3628 return 0;
3629 }
3630 else
3631 {
3632 return XCArgs.u16ReturnValue;
3633 }
3634 }
3635
3636 //-------------------------------------------------------------------------------------------------
3637 /// This function will calculate and return V Frequency x 1000
3638 /// @param u32HFreqx1K \b IN: Horizontal frequency x 1000
3639 /// @param u16VTotal \b IN: Vertical Total, usually the scan lines counts of a frame
3640 /// @return MS_U32: V Frequency x 1000
3641 //-------------------------------------------------------------------------------------------------
MDrv_XC_CalculateVFreqx1K(void * pInstance,MS_U32 u32HFreqx1K,MS_U16 u16VTotal)3642 MS_U32 MDrv_XC_CalculateVFreqx1K(void *pInstance, MS_U32 u32HFreqx1K, MS_U16 u16VTotal)
3643 {
3644 if(u32HFreqx1K && u16VTotal)
3645 {
3646 return ( (((MS_U32)u32HFreqx1K * 1000 ) + (u16VTotal/2)) / u16VTotal ); // (10^-3)Hz
3647 }
3648 else
3649 {
3650 return 0;
3651 }
3652 }
3653
MApi_XC_CalculateVFreqx1K_U2(void * pInstance,MS_U32 u32HFreqx1K,MS_U16 u16VTotal)3654 MS_U32 MApi_XC_CalculateVFreqx1K_U2(void* pInstance, MS_U32 u32HFreqx1K, MS_U16 u16VTotal)
3655 {
3656 if(u32HFreqx1K && u16VTotal)
3657 {
3658 return ( (((MS_U32)u32HFreqx1K * 1000 ) + (u16VTotal/2)) / u16VTotal ); // (10^-3)Hz
3659 }
3660 else
3661 {
3662 return 0;
3663 }
3664 }
3665
MApi_XC_CalculateVFreqx1K(MS_U32 u32HFreqx1K,MS_U16 u16VTotal)3666 MS_U32 MApi_XC_CalculateVFreqx1K(MS_U32 u32HFreqx1K, MS_U16 u16VTotal)
3667 {
3668 if (pu32XCInst == NULL)
3669 {
3670 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3671 return 0;
3672 }
3673
3674 stXC_GET_VFREQX1K XCArgs;
3675 XCArgs.u32HFreqx1K = u32HFreqx1K;
3676 XCArgs.u16VTotal = u16VTotal;
3677 XCArgs.u32ReturnValue = 0;
3678
3679 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_VFREQX1K, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3680 {
3681 printf("Obtain XC engine fail\n");
3682 return 0;
3683 }
3684 else
3685 {
3686 return XCArgs.u32ReturnValue;
3687 }
3688 }
3689
3690 //-------------------------------------------------------------------------------------------------
3691 /// This function will get V Frequency x 1000
3692 /// @param eWindow \b IN: the window we are going to get V frequency
3693 /// @return MS_U32: Accurate V Frequency x 1000
3694 //-------------------------------------------------------------------------------------------------
MDrv_XC_GetAccurateVFreqx1K(void * pInstance,SCALER_WIN eWindow)3695 MS_U32 MDrv_XC_GetAccurateVFreqx1K(void* pInstance, SCALER_WIN eWindow)
3696 {
3697 MS_U32 u32AccuratePeriod = 0;
3698 MS_U32 u32AccurateVFreq = 0;
3699 MS_U64 u64XTALClk = 0;
3700 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3701 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3702 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3703 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3704
3705 // for more correct VPeriod
3706 u32AccuratePeriod = MDrv_SC_ip_get_verticalperiod(pInstance, eWindow);
3707 XC_LOG_TRACE(XC_DBGLEVEL_SETTIMING, "MDrv_SC_ip_get_verticalperiod = %tu\n", (ptrdiff_t)u32AccuratePeriod);
3708
3709 if(u32AccuratePeriod != 0)
3710 {
3711 u64XTALClk = (MS_U64)pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32XTAL_Clock * 1000;
3712 do_div(u64XTALClk,u32AccuratePeriod);
3713 u32AccurateVFreq = (MS_U32)u64XTALClk;
3714 }
3715
3716 XC_LOG_TRACE(XC_DBGLEVEL_SETTIMING, "u32AccurateVFreq = %tu\n", (ptrdiff_t)u32AccurateVFreq);
3717 return u32AccurateVFreq;
3718 }
3719
3720 //-------------------------------------------------------------------------------------------------
3721 /// MApi_XC_GetAccurateVFreqx1K is obsolete, please use MApi_XC_CalculateVFreqx10 instead!
3722 /// the return vfreq of this function is not accurate when signal is not stable or have noise, so it's not
3723 /// suitable as interface for Ap use at any time.
3724 //-------------------------------------------------------------------------------------------------
MApi_XC_GetAccurateVFreqx1K_U2(void * pInstance,SCALER_WIN eWindow)3725 MS_U32 MApi_XC_GetAccurateVFreqx1K_U2(void* pInstance, SCALER_WIN eWindow)
3726 {
3727 printf("[%s,%5d]Attention: MApi_XC_GetAccurateVFreqx1K is obsolete, please use MApi_XC_CalculateVFreqx10 instead!\n",__FUNCTION__,__LINE__);
3728 return 0;
3729 }
3730
MApi_XC_GetAccurateVFreqx1K(SCALER_WIN eWindow)3731 MS_U32 MApi_XC_GetAccurateVFreqx1K(SCALER_WIN eWindow)
3732 {
3733 if (pu32XCInst == NULL)
3734 {
3735 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3736 return 0;
3737 }
3738
3739 stXC_GET_ACCURATE_VFREQX1k XCArgs;
3740 XCArgs.eWindow = eWindow;
3741 XCArgs.u32ReturnValue = 0;
3742
3743 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_ACCURATE_VFREQX1k, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3744 {
3745 printf("Obtain XC engine fail\n");
3746 return 0;
3747 }
3748 else
3749 {
3750 return XCArgs.u32ReturnValue;
3751 }
3752 }
3753
3754 //-------------------------------------------------------------------------------------------------
3755 /// This function will calculate and return Vsync time
3756 /// @param u16VTotal \b IN: Vercital total
3757 /// @param u16HPeriod \b IN: Horizontal period
3758 /// @return MS_U8: VSync time
3759 //-------------------------------------------------------------------------------------------------
MApi_XC_CalculateVsyncTime(void * pInstance,MS_U16 u16VTotal,MS_U16 u16HPeriod)3760 MS_U8 MApi_XC_CalculateVsyncTime(void *pInstance, MS_U16 u16VTotal, MS_U16 u16HPeriod)
3761 {
3762 MS_U16 wHFreqX10; // horizontal frequency
3763 wHFreqX10 = MDrv_XC_CalculateHFreqx10(pInstance, u16HPeriod); // calculate HSync frequency
3764 return (MS_U8)(((u16VTotal*10)+(wHFreqX10/2))/wHFreqX10);
3765 }
3766 /******************************************************************************/
3767 ///Set line buffer clock
3768 ///@param u16HTotal \b IN
3769 ///- Horizontal total
3770 ///@return
3771 ///- Output Pixel colok
3772 /******************************************************************************/
MDrv_XC_cal_pixclk(void * pInstance,MS_U16 u16HTotal,SCALER_WIN eWindow)3773 MS_U16 MDrv_XC_cal_pixclk(void *pInstance, MS_U16 u16HTotal, SCALER_WIN eWindow)
3774 {
3775 return (MS_U16)
3776 (((MS_U32)MDrv_XC_CalculateHFreqx10(pInstance, Hal_SC_ip_get_horizontalPeriod(pInstance, eWindow))*u16HTotal+5000)/10000);
3777 }
3778
3779
3780 #if ENABLE_DEBUG_CAPTURE_N_FRAMES
_MApi_XC_InputVSyncISR(SC_INT_SRC eIntNum,void * pParam)3781 static void _MApi_XC_InputVSyncISR(SC_INT_SRC eIntNum, void * pParam)
3782 {
3783 volatile MS_BOOL *bFinishedISR = (volatile MS_BOOL *) pParam;
3784 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3785 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3786 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3787 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3788 pXCResourcePrivate->stdrvXC_IP.u8Cnt++;
3789
3790 #if 1
3791 if(pXCResourcePrivate->stdrvXC_IP.u8Cnt == 4)
3792 {
3793 Hal_SC_set_freezeimg(pInstance, ENABLE, MAIN_WINDOW);
3794 pXCResourcePrivate->stdrvXC_IP.u8Cnt = 0;
3795 *bFinishedISR = TRUE;
3796 }
3797 #else
3798 printf("(%3d) E %4x W %d, R %d, pha %4x, prd %4x\n",
3799 u8Cnt,
3800 SC_R2BYTEMSK(0, REG_SC_BK01_1E_L, 0x0400),
3801 SC_R2BYTEMSK(0, REG_SC_BK12_3A_L, 0x07), // current write bank
3802 SC_R2BYTEMSK(0, REG_SC_BK12_3A_L, 0x70) >> 4, // current read bank
3803 MDrv_Read2Byte(L_BK_LPLL(0x11)), // phase error
3804 MDrv_Read2Byte(L_BK_LPLL(0x13))); // prd error
3805 #endif
3806 }
3807 #endif
3808
MApi_XC_InterruptAttach_U2(void * pInstance,SC_INT_SRC eIntNum,SC_InterruptCb pIntCb,void * pParam)3809 MS_BOOL MApi_XC_InterruptAttach_U2(void* pInstance, SC_INT_SRC eIntNum, SC_InterruptCb pIntCb, void * pParam)
3810 {
3811 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3812 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3813 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3814 MS_BOOL bReturn = MDrv_XC_InterruptAttach(pInstance, eIntNum, pIntCb,pParam);
3815 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3816 return bReturn;
3817 }
3818
MApi_XC_InterruptAttach(SC_INT_SRC eIntNum,SC_InterruptCb pIntCb,void * pParam)3819 MS_BOOL MApi_XC_InterruptAttach(SC_INT_SRC eIntNum, SC_InterruptCb pIntCb, void * pParam)
3820 {
3821 if (pu32XCInst == NULL)
3822 {
3823 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3824 return FALSE;
3825 }
3826
3827 stXC_SET_INTERRUPT_ATTACH XCArgs;
3828 XCArgs.eIntNum = eIntNum;
3829 XCArgs.pIntCb = pIntCb;
3830 XCArgs.pParam = pParam;
3831 XCArgs.bReturnValue = FALSE;
3832
3833 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_INTERRUPT_ATTACH, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3834 {
3835 printf("Obtain XC engine fail\n");
3836 return FALSE;
3837 }
3838 else
3839 {
3840 return XCArgs.bReturnValue;
3841 }
3842 }
3843
MApi_XC_InterruptDeAttach_U2(void * pInstance,SC_INT_SRC eIntNum,SC_InterruptCb pIntCb,void * pParam)3844 MS_BOOL MApi_XC_InterruptDeAttach_U2(void* pInstance, SC_INT_SRC eIntNum, SC_InterruptCb pIntCb, void * pParam)
3845 {
3846 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3847 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3848 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3849 MS_BOOL bReturn = MDrv_XC_InterruptDeAttach(pInstance, eIntNum, pIntCb,pParam);
3850 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3851 return bReturn;
3852 }
3853
MApi_XC_InterruptDeAttach(SC_INT_SRC eIntNum,SC_InterruptCb pIntCb,void * pParam)3854 MS_BOOL MApi_XC_InterruptDeAttach(SC_INT_SRC eIntNum, SC_InterruptCb pIntCb, void * pParam)
3855 {
3856 if (pu32XCInst == NULL)
3857 {
3858 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3859 return FALSE;
3860 }
3861
3862 stXC_SET_INTERRUPT_DEATTACH XCArgs;
3863 XCArgs.eIntNum = eIntNum;
3864 XCArgs.pIntCb = pIntCb;
3865 XCArgs.pParam = pParam;
3866 XCArgs.bReturnValue = FALSE;
3867
3868 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_INTERRUPT_DEATTACH, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3869 {
3870 printf("Obtain XC engine fail\n");
3871 return FALSE;
3872 }
3873 else
3874 {
3875 return XCArgs.bReturnValue;
3876 }
3877 }
3878
3879 //-------------------------------------------------------------------------------------------------
3880 //
3881 // Attention! This function should only be used in the xc interrupt!!!
3882 //
3883 /// This function will tell the current read bank
3884 /// @param eWindow \b IN: Window
3885 /// @return MS_U16 Current read bank
3886 //-------------------------------------------------------------------------------------------------
MApi_XC_GetCurrentReadBank_U2(void * pInstance,SCALER_WIN eWindow)3887 MS_U16 MApi_XC_GetCurrentReadBank_U2(void* pInstance, SCALER_WIN eWindow)
3888 {
3889 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3890 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3891 MS_U16 u16CurrentReadBank = 0;
3892 #if (!ENABLE_REGISTER_SPREAD)
3893 MS_U8 u8Bank = 0;
3894 u8Bank = MDrv_ReadByte( BK_SELECT_00 );
3895 #endif
3896 if(MAIN_WINDOW == eWindow)
3897 {
3898 u16CurrentReadBank = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_3A_L, 0xF0) >> 4 ;
3899 }
3900 else
3901 {
3902 u16CurrentReadBank = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_7A_L, 0xF0) >> 4 ;
3903 }
3904 #if (!ENABLE_REGISTER_SPREAD)
3905 MDrv_WriteByte(BK_SELECT_00, u8Bank);
3906 #endif
3907 return u16CurrentReadBank;
3908 }
3909
MApi_XC_GetCurrentReadBank(SCALER_WIN eWindow)3910 MS_U16 MApi_XC_GetCurrentReadBank(SCALER_WIN eWindow)
3911 {
3912 if (pu32XCInst == NULL)
3913 {
3914 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3915 return 0;
3916 }
3917
3918 stXC_GET_CURRENT_READBANK XCArgs;
3919 XCArgs.eWindow = eWindow;
3920 XCArgs.u16ReturnValue = 0;
3921
3922 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_CURRENT_READBANK, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3923 {
3924 printf("Obtain XC engine fail\n");
3925 return 0;
3926 }
3927 else
3928 {
3929 return XCArgs.u16ReturnValue;
3930 }
3931 }
3932
3933 //-------------------------------------------------------------------------------------------------
3934 //
3935 // Attention! This function should only be used in the xc interrupt!!!
3936 //
3937 /// This function will tell the current write bank
3938 /// @param eWindow \b IN: Window
3939 /// @return MS_U16 Current write bank
3940 //-------------------------------------------------------------------------------------------------
MApi_XC_GetCurrentWriteBank_U2(void * pInstance,SCALER_WIN eWindow)3941 MS_U16 MApi_XC_GetCurrentWriteBank_U2(void* pInstance, SCALER_WIN eWindow)
3942 {
3943 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3944 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3945 MS_U16 u16CurrentWriteBank = 0;
3946 #if (!ENABLE_REGISTER_SPREAD)
3947 MS_U8 u8Bank = 0;
3948 u8Bank = MDrv_ReadByte( BK_SELECT_00 );
3949 #endif
3950 if(MAIN_WINDOW == eWindow)
3951 {
3952 u16CurrentWriteBank = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_3A_L, 0xF);
3953 }
3954 else
3955 {
3956 u16CurrentWriteBank = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_7A_L, 0xF);
3957 }
3958 #if (!ENABLE_REGISTER_SPREAD)
3959 MDrv_WriteByte(BK_SELECT_00, u8Bank);
3960 #endif
3961 return u16CurrentWriteBank;
3962 }
3963
MApi_XC_GetCurrentWriteBank(SCALER_WIN eWindow)3964 MS_U16 MApi_XC_GetCurrentWriteBank(SCALER_WIN eWindow)
3965 {
3966 if (pu32XCInst == NULL)
3967 {
3968 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3969 return 0;
3970 }
3971
3972 stXC_GET_CURRENT_WRITEBANK XCArgs;
3973 XCArgs.eWindow = eWindow;
3974 XCArgs.u16ReturnValue = 0;
3975
3976 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_CURRENT_WRITEBANK, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3977 {
3978 printf("Obtain XC engine fail\n");
3979 return 0;
3980 }
3981 else
3982 {
3983 return XCArgs.u16ReturnValue;
3984 }
3985 }
3986
3987 //-------------------------------------------------------------------------------------------------
3988 /// This function will disable input source
3989 /// @param bDisable \b IN: TRUE : Disable; FALSE: Enable
3990 //-------------------------------------------------------------------------------------------------
MApi_XC_DisableInputSource_U2(void * pInstance,MS_BOOL bDisable,SCALER_WIN eWindow)3991 void MApi_XC_DisableInputSource_U2(void* pInstance, MS_BOOL bDisable, SCALER_WIN eWindow)
3992 {
3993 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3994 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3995 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3996
3997 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3998 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3999 _XC_ENTRY(pInstance);
4000 gSrcInfo[eWindow].bBluescreenEnabled = bDisable;
4001 //when enable auto no signal, the signal goto stable state.
4002 //and then disable input source at timing monitor function not here.
4003 if(gSrcInfo[eWindow].bAutoNoSignalEnabled && Hal_SC_ip_get_IPAutoNoSignal(pInstance, eWindow)
4004 && bDisable)
4005 {
4006 msg_sc_ip(printf(" return disable input source\n"));
4007 }
4008 else if(!((bDisable == FALSE) &&
4009 (eWindow == SUB_WINDOW) &&
4010 gSrcInfo[eWindow].Status2.bIPMemWriteRequestDisabled ))
4011 {
4012 //Sub window use disable IP memory request to disable input source
4013 //So, if bIPMemWriteRequestDisabled = TRUE, need skip enable SUB input source
4014 MDrv_XC_DisableInputSource(pInstance, bDisable, eWindow);
4015 }
4016 _XC_RETURN(pInstance);
4017
4018
4019 #if ENABLE_DEBUG_CAPTURE_N_FRAMES
4020 printf("MApi_XC_DisableInputSource %d %d\n", bDisable, eWindow);
4021
4022 if(bDisable)
4023 {
4024 // start ISR monitor
4025 MDrv_XC_InterruptDeAttach(pInstance, SC_INT_F2_IPVS_SB, _MApi_XC_InputVSyncISR, (void *) &pXCResourcePrivate->stdrvXC_IP.bFinishedInputVSyncISR);
4026 }
4027 else
4028 {
4029 pXCResourcePrivate->stdrvXC_IP.bFinishedInputVSyncISR = FALSE;
4030
4031 if(!MDrv_XC_InterruptIsAttached(pInstance, SC_INT_F2_IPVS_SB, _MApi_XC_InputVSyncISR, (void *) &pXCResourcePrivate->stdrvXC_IP.bFinishedInputVSyncISR))
4032 {
4033 MDrv_XC_InterruptAttach(pInstance, SC_INT_F2_IPVS_SB, _MApi_XC_InputVSyncISR, (void *) &pXCResourcePrivate->stdrvXC_IP.bFinishedInputVSyncISR);
4034
4035 while(*((volatile MS_BOOL *) &pXCResourcePrivate->stdrvXC_IP.bFinishedInputVSyncISR) == FALSE)
4036 {
4037 }
4038
4039 MDrv_XC_InterruptDeAttach(pInstance, SC_INT_F2_IPVS_SB, _MApi_XC_InputVSyncISR, (void *) &pXCResourcePrivate->stdrvXC_IP.bFinishedInputVSyncISR);
4040 }
4041 }
4042 #endif
4043 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
4044
4045 /* if(bDisable)
4046 {
4047 if(eWindow==0)
4048 printf("Main win Blue Screen ON\n");
4049 else
4050 printf("Sub win Blue Screen ON\n");
4051 }
4052 else
4053 {
4054 if(eWindow==0)
4055 printf("Main win Blue Screen OFF\n");
4056 else
4057 printf("Sub win Blue Screen OFF\n");
4058 }
4059 */
4060 }
4061
MApi_XC_DisableInputSource(MS_BOOL bDisable,SCALER_WIN eWindow)4062 void MApi_XC_DisableInputSource(MS_BOOL bDisable, SCALER_WIN eWindow)
4063 {
4064 if (pu32XCInst == NULL)
4065 {
4066 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4067 return;
4068 }
4069
4070 stXC_SET_DISABLE_INPUTSOURCE XCArgs;
4071 XCArgs.bDisable = bDisable;
4072 XCArgs.eWindow = eWindow;
4073
4074 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_DISABLE_INPUTSOURCE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4075 {
4076 printf("Obtain XC engine fail\n");
4077 return;
4078 }
4079 else
4080 {
4081 return;
4082 }
4083 }
4084
4085 // Used in driver
MDrv_XC_DisableInputSource(void * pInstance,MS_BOOL bDisable,SCALER_WIN eWindow)4086 void MDrv_XC_DisableInputSource(void *pInstance, MS_BOOL bDisable, SCALER_WIN eWindow)
4087 {
4088 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4089 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4090 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4091 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4092 gSrcInfo[eWindow].bBluescreenEnabled = bDisable;
4093
4094 if ((MDrv_XC_MLoad_GetStatus(pInstance) == E_MLOAD_ENABLED)
4095 && (!MDrv_SC_CheckMuteStatusByRegister(pInstance, eWindow)))
4096 {
4097 _MLOAD_ENTRY(pInstance);
4098 // HW PIP architeucture
4099 // Becasue BK3_02[8] and BK20_11[15] should enable together, otherwise garbage will be showed,
4100 // otherwise garbage will be showed,we need to use BK12_47[0] to instead.
4101 if( eWindow == MAIN_WINDOW )
4102 {
4103 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK01_02_L, (bDisable ? BIT(7):0), BIT(7));
4104 }
4105 else
4106 {
4107 if(DISABLE==bDisable)
4108 {
4109 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK03_02_L, 0 , BIT(7));
4110 }
4111 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK12_47_L, (bDisable ? BIT(0) : 0), BIT(0));
4112 #if (HW_DESIGN_4K2K_VER == 4)
4113 if ((psXCInstPri->u32DeviceID==0)
4114 && !(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_LEGACY_MODE))
4115 {
4116 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK32_47_L, (bDisable ? BIT(0) : 0), BIT(0));
4117 }
4118 #endif
4119 }
4120 MDrv_XC_MLoad_Fire(pInstance, TRUE);
4121 _MLOAD_RETURN(pInstance);
4122 }
4123 else
4124 {
4125 if( eWindow == MAIN_WINDOW )
4126 {
4127 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_02_L, (bDisable ? BIT(7) : 0), BIT(7));
4128 }
4129 else
4130 {
4131 if(!MDrv_SC_CheckMuteStatusByRegister(pInstance, eWindow)&&!MDrv_SC_GetSkipWaitVsync(pInstance, eWindow))
4132 {
4133 MDrv_XC_wait_output_vsync(pInstance, 2, 200, MAIN_WINDOW);
4134 }
4135 if(DISABLE==bDisable)
4136 {
4137 SC_W2BYTEMSK(psXCInstPri->u32DeviceID ,REG_SC_BK03_02_L, 0 , BIT(7));
4138 }
4139 SC_W2BYTEMSK(psXCInstPri->u32DeviceID ,REG_SC_BK12_47_L, (bDisable ? BIT(0) : 0), BIT(0));
4140 #if (HW_DESIGN_4K2K_VER == 4)
4141 if ((psXCInstPri->u32DeviceID==0)
4142 && !(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_LEGACY_MODE))
4143 {
4144 SC_W2BYTEMSK(psXCInstPri->u32DeviceID ,REG_SC_BK32_47_L, (bDisable ? BIT(0) : 0), BIT(0));
4145 }
4146 #endif
4147 }
4148 }
4149
4150 #ifndef DONT_USE_CMA
4151 #if (XC_SUPPORT_CMA ==TRUE)
4152 if (
4153 #if (HW_DESIGN_4K2K_VER == 7)
4154 (psXCInstPri->u32DeviceID == 0) &&
4155 #endif
4156 (DISABLE == bDisable)&&( eWindow == MAIN_WINDOW ))
4157 {
4158 if (bNeedDeattachCMAISR == TRUE)
4159 {
4160 MHal_XC_CMAPatch(pInstance, MAIN_WINDOW);
4161 bNeedDeattachCMAISR = FALSE;
4162 }
4163 }
4164 #endif
4165 #endif
4166
4167 if((DISABLE==bDisable) && (eWindow == SUB_WINDOW))
4168 {
4169 MDrv_XC_Enable_Extra_Request(pInstance, ENABLE);
4170 }
4171 }
4172
MDrv_XC_IsInputSourceDisabledByHwAutoNoSignal(void * pInstance,SCALER_WIN eWindow)4173 MS_BOOL MDrv_XC_IsInputSourceDisabledByHwAutoNoSignal(void *pInstance, SCALER_WIN eWindow)
4174 {
4175 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4176 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4177 if (eWindow == MAIN_WINDOW)
4178 return (SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_02_L, 0x0080) >> 7);
4179 else
4180 return (SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK03_02_L, 0x0080) >> 7);
4181 }
4182
MDrv_XC_IsInputSourceDisabled(void * pInstance,SCALER_WIN eWindow)4183 MS_BOOL MDrv_XC_IsInputSourceDisabled(void *pInstance, SCALER_WIN eWindow)
4184 {
4185 MS_BOOL bInputSourceDisabled = FALSE;
4186 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4187 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4188 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4189 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4190 if(gSrcInfo[eWindow].bAutoNoSignalEnabled)
4191 bInputSourceDisabled = MDrv_XC_IsInputSourceDisabledByHwAutoNoSignal(pInstance, eWindow);
4192 else
4193 bInputSourceDisabled = gSrcInfo[eWindow].bBluescreenEnabled;
4194 return bInputSourceDisabled;
4195 }
4196
MApi_XC_IsInputSourceDisabled_U2(void * pInstance,SCALER_WIN eWindow)4197 MS_BOOL MApi_XC_IsInputSourceDisabled_U2(void* pInstance, SCALER_WIN eWindow)
4198 {
4199 MS_BOOL bReturn = FALSE;
4200 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4201 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4202 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
4203 _XC_ENTRY(pInstance);
4204 bReturn = MDrv_XC_IsInputSourceDisabled(pInstance, eWindow);
4205 _XC_RETURN(pInstance);
4206 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
4207 return bReturn;
4208 }
4209
MApi_XC_IsInputSourceDisabled(SCALER_WIN eWindow)4210 MS_BOOL MApi_XC_IsInputSourceDisabled(SCALER_WIN eWindow)
4211 {
4212 if (pu32XCInst == NULL)
4213 {
4214 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4215 return FALSE;
4216 }
4217
4218 stXC_CHECK_INPUTSOURCE_DISABLED XCArgs;
4219 XCArgs.eWindow = eWindow;
4220 XCArgs.bReturnValue = FALSE;
4221
4222 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_CHECK_INPUTSOURCE_DISABLED, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4223 {
4224 printf("Obtain XC engine fail\n");
4225 return FALSE;
4226 }
4227 else
4228 {
4229 return XCArgs.bReturnValue;
4230 }
4231 }
4232
4233 //-------------------------------------------------------------------------------------------------
4234 /// Get the auto phase value for the specific window
4235 /// @param eWindow \b IN: which window we are going to get
4236 /// @return MS_U32: Return full image sun of difference value between two pixles
4237 //-------------------------------------------------------------------------------------------------
MApi_XC_GetPhaseValue(void * pInstance,SCALER_WIN eWindow)4238 MS_U32 MApi_XC_GetPhaseValue(void *pInstance, SCALER_WIN eWindow)
4239 {
4240 MS_U32 u32PhaseValue; // double word buffer
4241 MS_U16 u8TimeOut = 0;
4242 MS_U16 u16Dummy = 1000;
4243 MS_U8 u8FirstReady =0 ,u8SecondReady = 0;
4244
4245 //u8Bank = MDrv_ReadByte( BK_SELECT_00 );
4246 //MDrv_WriteByte( BK_SELECT_00, REG_BANK_IP1F2 );
4247 _XC_ENTRY(pInstance);
4248 while ( Hal_SC_ip_is_auto_phase_result_ready(pInstance, eWindow) && u8TimeOut < 500 )
4249 {
4250 u8TimeOut++;
4251 }
4252 //printf(" %u timeout \n",u8TimeOut );
4253 if ( u8TimeOut >= 500 )
4254 {
4255 _XC_RETURN(pInstance);
4256 return 0; // Timeout
4257 }
4258 u8TimeOut = 0 ;
4259
4260 while ( u8TimeOut < 100 )
4261 {
4262 // Waiting for ready
4263
4264 while( !( Hal_SC_ip_is_auto_phase_result_ready(pInstance, eWindow) ) && (u16Dummy--) ) ;
4265
4266 u8FirstReady = Hal_SC_ip_is_auto_phase_result_ready(pInstance, eWindow);
4267
4268 u32PhaseValue = Hal_SC_ip_get_auto_phase_value(pInstance, eWindow);
4269
4270 u8SecondReady = Hal_SC_ip_is_auto_phase_result_ready(pInstance, eWindow);
4271
4272 if ( u8FirstReady == TRUE && u8SecondReady == TRUE )
4273 {
4274 _XC_RETURN(pInstance);
4275 return u32PhaseValue;
4276 }
4277 u8TimeOut++;
4278 }
4279 _XC_RETURN(pInstance);
4280 return 0;
4281
4282 }
4283
4284 //-------------------------------------------------------------------------------------------------
4285 /// Auto-tune R/G/B Offset of ADC.
4286 /// @param u8Type \b IN: report AUTO_MIN_[RGB] or AUTO_MAX_[RGB]
4287 /// @param u8DelayMS \b IN: delay how long to get the report, usually, the delay will be 1 * VSyncTime
4288 /// @return @ref MS_BOOL the min/max gain report
4289 //-------------------------------------------------------------------------------------------------
MApi_XC_GetAutoGainResult(void * pInstance,AUTO_GAIN_TYPE u8Type,MS_U8 u8DelayMS,SCALER_WIN eWindow)4290 MS_U16 MApi_XC_GetAutoGainResult(void *pInstance, AUTO_GAIN_TYPE u8Type, MS_U8 u8DelayMS, SCALER_WIN eWindow)
4291 {
4292 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4293 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4294 MS_U8 u8Ready0, u8Ready1, u8GainRptTimeout = 255;
4295 MS_U16 u16Value = 0;
4296 //MS_U8 u8Bank;
4297
4298 //u8Bank = MDrv_ReadByte( BK_SELECT_00 );
4299
4300 if(eWindow == MAIN_WINDOW)
4301 {
4302 //MDrv_WriteByte( BK_SELECT_00, REG_BANK_IP1F2 );
4303 //MDrv_WriteByteMask(L_BK_IP1F2(0x0F), u8Type, BIT(2) | BIT(1) | BIT(0));
4304 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_0F_L, u8Type, BIT(2) | BIT(1) | BIT(0));
4305 }
4306 else
4307 {
4308 //MDrv_WriteByte( BK_SELECT_00, REG_BANK_IP1F1 );
4309 //MDrv_WriteByteMask(L_BK_IP1F1(0x0F), u8Type, BIT(2) | BIT(1) | BIT(0));
4310 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK03_0F_L, u8Type, BIT(2) | BIT(1) | BIT(0));
4311 }
4312
4313 MsOS_DelayTask(u8DelayMS);
4314
4315 // Sometimes the gain report will give a very un-reasonable value,
4316 // So, we've to wait the IP1F2_0E[1] to be ready (=1) to get the gain report
4317 // For safety reason, you may use this flow:
4318 // (1) Set what to get AUTO_MIN_[RGB] or AUTO_MAX_[RGB]
4319 // (2) wait for ready bit to be off
4320 // (because sometimes when you change the AUTO_MIN_[RGB] or AUTO_MAX_[RGB],
4321 // you'll get a ready immediately but the report is the old value)
4322 // (3) wait for ready bit to be on
4323 // (4) get the report when ready bit is on (note: see source code below)
4324 //
4325 // For quick response, you may get the report when ready bit is on, the report is rarely wrong if ready bit is on.
4326
4327 /*
4328 // wait for ready bit to be off
4329 while(MDrv_ReadByte(L_BK_IP1F2(0x0E)) & (0x1 << 1))
4330 {
4331 u8Ready = MDrv_ReadByte(L_BK_IP1F2(0x0E));
4332 u8Value = MDrv_ReadByte(L_BK_IP1F2(0x11));
4333 printf("DA:C=0x%bx,R=0x%bx,V=0x%bx\n", MDrv_ReadByte(L_BK_IP1F2(0x0F)), u8Ready, u8Value);
4334 }
4335
4336 // wait for ready bit to be on
4337 while(!(MDrv_ReadByte(L_BK_IP1F2(0x0E)) & (0x1 << 1)))
4338 {
4339 u8Ready = MDrv_ReadByte(L_BK_IP1F2(0x0E));
4340 u8Value = MDrv_ReadByte(L_BK_IP1F2(0x11));
4341 printf("DA:C=0x%bx,R=0x%bx,V=0x%bx\n", MDrv_ReadByte(L_BK_IP1F2(0x0F)), u8Ready, u8Value);
4342 }
4343 */
4344
4345 while(u8GainRptTimeout)
4346 {
4347 // It's important to read the 2 values by this order
4348 // (1) ready bit first
4349 // (2) report next
4350 // and no waste time between these 2 commands
4351
4352 // Waiting until ready bit raise
4353 MS_U16 u16Dummy = 1000;
4354 while(!( MApi_XC_IsAutoGainResultReady(pInstance, eWindow) ) && (u16Dummy--)) ;
4355
4356 if(eWindow == MAIN_WINDOW)
4357 {
4358 u8Ready0 = MApi_XC_IsAutoGainResultReady(pInstance, eWindow);
4359 //u16Value = (MDrv_Read2Byte(L_BK_IP1F2(0x11)) & 0x3FF); // the 10 bit report is 0.0 ~ 255.75, [9:2] = 0 ~ 255, [1:0] = 0, 0.25, 0.5, 0.75
4360 u16Value = (SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK01_11_L) & 0x3FF); // the 10 bit report is 0.0 ~ 255.75, [9:2] = 0 ~ 255, [1:0] = 0, 0.25, 0.5, 0.75
4361 u8Ready1 = MApi_XC_IsAutoGainResultReady(pInstance, eWindow);
4362 }
4363 else
4364 {
4365 u8Ready0 = MApi_XC_IsAutoGainResultReady(pInstance, eWindow);
4366 //u16Value = (MDrv_Read2Byte(L_BK_IP1F1(0x11)) & 0x3FF); // the 10 bit report is 0.0 ~ 255.75, [9:2] = 0 ~ 255, [1:0] = 0, 0.25, 0.5, 0.75
4367 u16Value = (SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK03_11_L) & 0x3FF); // the 10 bit report is 0.0 ~ 255.75, [9:2] = 0 ~ 255, [1:0] = 0, 0.25, 0.5, 0.75
4368 u8Ready1 = MApi_XC_IsAutoGainResultReady(pInstance, eWindow);
4369 }
4370
4371 // Check if the report is reasonable here
4372 if( u8Ready0 && u8Ready1)
4373 {
4374 break;
4375 }
4376 u8GainRptTimeout--;
4377 }
4378 MS_ASSERT(u8GainRptTimeout > 0);
4379
4380 //MDrv_WriteByte( BK_SELECT_00, u8Bank );
4381
4382 return u16Value;
4383
4384 }
4385
4386 //-------------------------------------------------------------------------------------------------
4387 /// Check whether Auto phase result is ready or not
4388 /// @param eWindow \b IN: which window we are going to query
4389 /// @return @ref MS_BOOL
4390 //-------------------------------------------------------------------------------------------------
MApi_XC_IsAutoPhaseResultReady(void * pInstance,SCALER_WIN eWindow)4391 MS_BOOL MApi_XC_IsAutoPhaseResultReady(void *pInstance, SCALER_WIN eWindow)
4392 {
4393 return Hal_SC_ip_is_auto_phase_result_ready(pInstance, eWindow);
4394 }
4395
4396 //-------------------------------------------------------------------------------------------------
4397 /// Get auto phase result value
4398 /// @param eWindow \b IN: which window we are going to query
4399 /// @return @ref MS_BOOL
4400 //-------------------------------------------------------------------------------------------------
MApi_XC_GetAutoPhaseResult(void * pInstance,SCALER_WIN eWindow)4401 MS_U32 MApi_XC_GetAutoPhaseResult(void *pInstance, SCALER_WIN eWindow)
4402 {
4403 return Hal_SC_ip_get_auto_phase_value(pInstance, eWindow);
4404 }
4405
4406 //-------------------------------------------------------------------------------------------------
4407 /// check whether the auto position is ready or not for the specific window
4408 /// @param eWindow \b IN: which window we are going to set
4409 /// @return @ref MS_BOOL
4410 //-------------------------------------------------------------------------------------------------
MApi_XC_IsAutoPositionResultReady(void * pInstance,SCALER_WIN eWindow)4411 MS_BOOL MApi_XC_IsAutoPositionResultReady(void *pInstance, SCALER_WIN eWindow)
4412 {
4413 MS_BOOL bAuto_position;
4414 _XC_ENTRY(pInstance);
4415 bAuto_position = Hal_SC_ip_is_auto_position_result_ready(pInstance, eWindow);
4416 _XC_RETURN(pInstance);
4417 return bAuto_position ; //Hal_SC_ip_is_auto_position_result_ready(eWindow);
4418
4419 }
4420
4421 //-------------------------------------------------------------------------------------------------
4422 /// enable or disable the auto position for the specific window
4423 /// @param u8Enable \b IN: enable or disable the auto position
4424 /// @param eWindow \b IN: which window we are going to set
4425 //-------------------------------------------------------------------------------------------------
MApi_XC_AutoPositionEnable(void * pInstance,MS_U8 u8Enable,SCALER_WIN eWindow)4426 void MApi_XC_AutoPositionEnable(void *pInstance, MS_U8 u8Enable , SCALER_WIN eWindow)
4427 {
4428 _XC_ENTRY(pInstance);
4429 Hal_SC_ip_set_auto_position_function(pInstance, u8Enable, eWindow);
4430 _XC_RETURN(pInstance);
4431 }
4432
4433 //-------------------------------------------------------------------------------------------------
4434 /// enable or disable the auto phase for the specific window
4435 /// @param bEnable \b IN: enable or disable the auto phase
4436 /// @param eWindow \b IN: which window we are going to set
4437 /// @return @ref MS_BOOL the auto phase enable setting result
4438 //-------------------------------------------------------------------------------------------------
MApi_XC_AutoPhaseEnable(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)4439 MS_BOOL MApi_XC_AutoPhaseEnable(void *pInstance, MS_BOOL bEnable , SCALER_WIN eWindow)
4440 {
4441 _XC_ENTRY(pInstance);
4442 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4443 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4444 if( eWindow == MAIN_WINDOW )
4445 {
4446 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_19_L, (bEnable?BIT(0):0) , BIT(0) );
4447 }
4448 else
4449 {
4450 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK03_19_L, (bEnable?BIT(0):0) , BIT(0) );
4451 }
4452 _XC_RETURN(pInstance);
4453 return TRUE;
4454 }
4455
4456 //-------------------------------------------------------------------------------------------------
4457 /// set valid data threshold for the specific window
4458 /// @param u8Threshold \b IN: the threshold to set
4459 /// @param eWindow \b IN: which window we are going to set
4460 //-------------------------------------------------------------------------------------------------
MDrv_XC_SetValidDataThreshold(void * pInstance,MS_U8 u8Threshold,SCALER_WIN eWindow)4461 void MDrv_XC_SetValidDataThreshold(void *pInstance, MS_U8 u8Threshold , SCALER_WIN eWindow)
4462 {
4463 _XC_ENTRY(pInstance);
4464 Hal_SC_ip_set_valid_data_threshold(pInstance, u8Threshold, eWindow);
4465 _XC_RETURN(pInstance);
4466 }
4467
4468 //-------------------------------------------------------------------------------------------------
4469 /// get auto position vstart for the specific window
4470 /// @param eWindow \b IN: which window we are going to get
4471 /// @return @ref MS_U16 the auto position vstart
4472 //-------------------------------------------------------------------------------------------------
MApi_XC_SetAutoPositionVstart(void * pInstance,SCALER_WIN eWindow)4473 MS_U16 MApi_XC_SetAutoPositionVstart(void *pInstance, SCALER_WIN eWindow)
4474 {
4475 MS_U16 u16V_start;
4476 _XC_ENTRY(pInstance);
4477 u16V_start = Hal_SC_ip_get_auto_position_v_start(pInstance, eWindow);
4478 _XC_RETURN(pInstance);
4479 return u16V_start ;//Hal_SC_ip_get_auto_position_v_start(eWindow);
4480 }
4481
4482 //-------------------------------------------------------------------------------------------------
4483 /// get auto position hstart for the specific window
4484 /// @param eWindow \b IN: which window we are going to get
4485 /// @return @ref MS_U16 the auto position hstart
4486 //-------------------------------------------------------------------------------------------------
MApi_XC_SetAutoPositionHstart(void * pInstance,SCALER_WIN eWindow)4487 MS_U16 MApi_XC_SetAutoPositionHstart(void *pInstance, SCALER_WIN eWindow)
4488 {
4489 MS_U16 u16H_start;
4490 _XC_ENTRY(pInstance);
4491 u16H_start = Hal_SC_ip_get_auto_position_h_start(pInstance, eWindow);
4492 _XC_RETURN(pInstance);
4493 return u16H_start;//Hal_SC_ip_get_auto_position_h_start(eWindow);
4494 }
4495
4496 //-------------------------------------------------------------------------------------------------
4497 /// get auto position vendt for the specific window
4498 /// @param eWindow \b IN: which window we are going to get
4499 /// @return @ref MS_U16 the auto position vend
4500 //-------------------------------------------------------------------------------------------------
MApi_XC_SetAutoPositionVend(void * pInstance,SCALER_WIN eWindow)4501 MS_U16 MApi_XC_SetAutoPositionVend(void *pInstance, SCALER_WIN eWindow)
4502 {
4503 MS_U16 u16V_end;
4504 _XC_ENTRY(pInstance);
4505 u16V_end = Hal_SC_ip_get_auto_position_v_end(pInstance, eWindow);
4506 _XC_RETURN(pInstance);
4507 return u16V_end;//Hal_SC_ip_get_auto_position_v_end(eWindow);
4508 }
4509
4510 //-------------------------------------------------------------------------------------------------
4511 /// get auto position Horizontal end for the specific window
4512 /// @param eWindow \b IN: which window we are going to get
4513 /// @return @ref MS_U16 the auto position horizontal end
4514 //-------------------------------------------------------------------------------------------------
MApi_XC_SetAutoPositionHend(void * pInstance,SCALER_WIN eWindow)4515 MS_U16 MApi_XC_SetAutoPositionHend(void *pInstance, SCALER_WIN eWindow)
4516 {
4517 MS_U16 u16H_end;
4518 _XC_ENTRY(pInstance);
4519 u16H_end = Hal_SC_ip_get_auto_position_h_end(pInstance, eWindow);
4520 _XC_RETURN(pInstance);
4521 return u16H_end;//Hal_SC_ip_get_auto_position_h_end(eWindow);
4522 }
4523
4524 //-------------------------------------------------------------------------------------------------
4525 /// get auto position force pixel mode for the specific window
4526 /// @param eWindow \b IN: which window we are going to get
4527 /// @return @ref MS_BOOL auto position force pixel mode enabled
4528 //-------------------------------------------------------------------------------------------------
MDrv_XC_GetAutoPositionForcePixelMode(void * pInstance,SCALER_WIN eWindow)4529 MS_BOOL MDrv_XC_GetAutoPositionForcePixelMode(void *pInstance, SCALER_WIN eWindow)
4530 {
4531 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4532 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4533 if(eWindow == MAIN_WINDOW)
4534 return SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_10_L, BIT(8)) >> 8;
4535 else
4536 return SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK03_10_L, BIT(8)) >> 8;
4537 }
4538
4539 //-------------------------------------------------------------------------------------------------
4540 /// set auto position force pixel mode for the specific window
4541 /// @param eWindow \b IN: which window we are going to set
4542 //-------------------------------------------------------------------------------------------------
MDrv_XC_SetAutoPositionForcePixelMode(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)4543 void MDrv_XC_SetAutoPositionForcePixelMode(void *pInstance, MS_BOOL bEnable, SCALER_WIN eWindow)
4544 {
4545 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4546 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4547 if(eWindow == MAIN_WINDOW)
4548 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_10_L, (bEnable ? BIT(8) : 0), BIT(8));
4549 else
4550 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK03_10_L, (bEnable ? BIT(8) : 0), BIT(8));
4551 }
4552
4553 //-------------------------------------------------------------------------------------------------
4554 /// set auto range window for the specific window
4555 /// @param u16Vstart \b IN: vertical start
4556 /// @param u16Hstart \b IN: horizontal start
4557 /// @param u16Vsize \b IN: vertical size
4558 /// @param u16Hsize \b IN: horizontal size
4559 /// @param eWindow \b IN: which window we are going to get
4560 //-------------------------------------------------------------------------------------------------
MApi_XC_SetAutoRangeWindow(void * pInstance,MS_U16 u16Vstart,MS_U16 u16Hstart,MS_U16 u16Vsize,MS_U16 u16Hsize,SCALER_WIN eWindow)4561 void MApi_XC_SetAutoRangeWindow(void *pInstance, MS_U16 u16Vstart, MS_U16 u16Hstart, MS_U16 u16Vsize, MS_U16 u16Hsize, SCALER_WIN eWindow)
4562 {
4563 Hal_SC_ip_set_auto_range_window(pInstance, u16Vstart, u16Hstart, u16Vsize, u16Hsize, eWindow);
4564 }
4565
4566 //-------------------------------------------------------------------------------------------------
4567 /// enable or disable the auto range for the specific window
4568 /// @param u8Enable \b IN: enable or disable the auto range
4569 /// @param eWindow \b IN: which window we are going to set
4570 //-------------------------------------------------------------------------------------------------
MApi_XC_AutoRangeEnable(void * pInstance,MS_U8 u8Enable,SCALER_WIN eWindow)4571 void MApi_XC_AutoRangeEnable(void *pInstance, MS_U8 u8Enable , SCALER_WIN eWindow)
4572 {
4573 Hal_SC_ip_set_auto_range_function(pInstance, u8Enable, eWindow);
4574 }
4575
4576 //-------------------------------------------------------------------------------------------------
4577 /// enable or disable the Vsync polarity detect mode for the specific window
4578 /// @param u8Enable \b IN: enable or disable
4579 /// @param eWindow \b IN: which window we are going to set
4580 //-------------------------------------------------------------------------------------------------
MApi_XC_VsyncPolarityDetectMode(void * pInstance,MS_U8 u8Enable,SCALER_WIN eWindow)4581 void MApi_XC_VsyncPolarityDetectMode(void *pInstance, MS_U8 u8Enable , SCALER_WIN eWindow)
4582 {
4583 _XC_ENTRY(pInstance);
4584 Hal_SC_ip_set_reg_usr_vspolmd(pInstance, u8Enable, eWindow);
4585 _XC_RETURN(pInstance);
4586 }
4587
4588 //-------------------------------------------------------------------------------------------------
4589 /// init register for timing change
4590 /// @param eWindow \b IN: which window we are going to set
4591 //-------------------------------------------------------------------------------------------------
MApi_XC_TimingChangeInit(void * pInstance,SCALER_WIN eWindow)4592 void MApi_XC_TimingChangeInit(void *pInstance, SCALER_WIN eWindow)
4593 {
4594 _XC_ENTRY(pInstance);
4595 Hal_SC_ip_init_reg_in_timingchange(pInstance, eWindow);
4596 _XC_RETURN(pInstance);
4597 }
4598
4599
MDrv_XC_init_riu_base(MS_VIRT u32riu_base,MS_VIRT u32PMriu_base)4600 void MDrv_XC_init_riu_base(MS_VIRT u32riu_base, MS_VIRT u32PMriu_base)
4601 {
4602 Hal_SC_init_riu_base(u32riu_base, u32PMriu_base);
4603 }
4604
4605 //-----------------------------------------------------------------------------
4606 /// Enable/Disable Euro/Australia Hdtv Detection support in driver
4607 /// @param bEnable:
4608 /// - ENABLE : enable support
4609 /// - DISABLE : disable disable
4610 /// @return None.
4611 //-----------------------------------------------------------------------------
MApi_XC_EnableEuroHdtvSupport_U2(void * pInstance,MS_BOOL bEnable)4612 void MApi_XC_EnableEuroHdtvSupport_U2(void* pInstance, MS_BOOL bEnable)
4613 {
4614 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4615 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4616 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4617
4618 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
4619 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4620 pXCResourcePrivate->stdrvXC_MVideo_Context._bEnableEuro = bEnable;
4621 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
4622 }
4623
MApi_XC_EnableEuroHdtvSupport(MS_BOOL bEnable)4624 void MApi_XC_EnableEuroHdtvSupport(MS_BOOL bEnable)
4625 {
4626 if (pu32XCInst == NULL)
4627 {
4628 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4629 return;
4630 }
4631
4632 stXC_SET_EUROHDTV_SUPPORT_ENABLE XCArgs;
4633 XCArgs.bEnable = bEnable;
4634
4635 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_EUROHDTV_SUPPORT_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4636 {
4637 printf("Obtain XC engine fail\n");
4638 return;
4639 }
4640 else
4641 {
4642 return;
4643 }
4644 }
4645
4646 //-----------------------------------------------------------------------------
4647 /// Enable Euro/Australia Hdtv Detection
4648 /// @param bEnable:
4649 /// - ENABLE : enable detection
4650 /// - DISABLE : disable detection
4651 /// @return None.
4652 //-----------------------------------------------------------------------------
MApi_XC_EnableEuroHdtvDetection_U2(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)4653 void MApi_XC_EnableEuroHdtvDetection_U2(void* pInstance, MS_BOOL bEnable, SCALER_WIN eWindow)
4654 {
4655 //MS_U8 u8Bank;
4656 MS_U32 u32Reg_1F_H, u32Reg_29_L;
4657
4658 _XC_ENTRY(pInstance);
4659 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4660 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4661 // switch to BK1F2
4662 //u8Bank = MDrv_ReadByte(BK_SELECT_00);
4663
4664 if(eWindow == MAIN_WINDOW)
4665 {
4666 u32Reg_1F_H = REG_SC_BK01_1F_H;
4667 u32Reg_29_L = REG_SC_BK01_29_L;
4668 }
4669 else
4670 {
4671 u32Reg_1F_H = REG_SC_BK03_1F_H;
4672 u32Reg_29_L = REG_SC_BK03_29_L;
4673 }
4674 if(bEnable)
4675 {
4676 //(printf("Enable detecting EURO_HDTV\n");
4677 // set read HSync pulse width
4678 // old setting: we don't switch hsync/vsync-read in new chip because hsync & vsync are reported by different register.
4679 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32Reg_1F_H, 0, BIT(5));// set read HSync pulse width instead of VSync pulse width
4680 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32Reg_29_L, (BIT(7)|BIT(1)), 0x00FF);// All case, auto field
4681 }
4682 else
4683 {
4684 //printf("Disable detecting EURO_HDTV\n");
4685 Hal_SC_set_cs_det_cnt(pInstance, 0, eWindow);
4686 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, u32Reg_29_L, 0x00, 0x00FF);// All case, auto field
4687 }
4688 _XC_RETURN(pInstance);
4689
4690 //MDrv_WriteByte(BK_SELECT_00, u8Bank);
4691 }
4692
MApi_XC_EnableEuroHdtvDetection(MS_BOOL bEnable,SCALER_WIN eWindow)4693 void MApi_XC_EnableEuroHdtvDetection(MS_BOOL bEnable, SCALER_WIN eWindow)
4694 {
4695 if (pu32XCInst == NULL)
4696 {
4697 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4698 return;
4699 }
4700
4701 stXC_SET_EUROHDTV_DETECTION_ENABLE XCArgs;
4702 XCArgs.bEnable = bEnable;
4703 XCArgs.eWindow = eWindow;
4704
4705 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_EUROHDTV_DETECTION_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4706 {
4707 printf("Obtain XC engine fail\n");
4708 return;
4709 }
4710 else
4711 {
4712 return;
4713 }
4714 }
4715
4716 //-----------------------------------------------------------------------------
4717 /// Get Euro/Australia Hdtv Detection Result
4718 /// @return MS_DETECT_EURO_HDTV_STATUS_TYPE:
4719 /// - EURO_HDTV_DETECTED
4720 /// - AUSTRALIA_HDTV_DETECTED
4721 /// - NORMAL : No Euro/Australia HDTV detected.
4722 //-----------------------------------------------------------------------------
MDrv_XC_ip_GetEuroHdtvStatus(void * pInstance,SCALER_WIN eWindow)4723 MS_DETECT_EURO_HDTV_STATUS_TYPE MDrv_XC_ip_GetEuroHdtvStatus(void *pInstance, SCALER_WIN eWindow)
4724 {
4725 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4726 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4727 //MS_U8 u8Status;
4728 //MS_U8 u8Bank;
4729 MS_U16 u16Status;
4730 MS_DETECT_EURO_HDTV_STATUS_TYPE Euro_status;
4731
4732 // switch to BK1F2
4733 //u8Bank = MDrv_ReadByte(BK_SELECT_00);
4734
4735 if(eWindow == MAIN_WINDOW)
4736 {
4737 /*MDrv_WriteByte(BK_SELECT_00, REG_BANK_IP1F2);
4738 u8Status = MDrv_ReadByte(L_BK_IP1F2(0x29));*/
4739 u16Status = SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK01_29_L);
4740 }
4741 else
4742 {
4743 /*MDrv_WriteByte(BK_SELECT_00, REG_BANK_IP1F1);
4744 u8Status = MDrv_ReadByte(L_BK_IP1F1(0x29));*/
4745 u16Status = SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK03_29_L);
4746 }
4747
4748 //if( (u8Status & 0x0C) == 0x0C )
4749 if( (u16Status & 0x000C) == 0x000C )
4750 {
4751 msg_sc_ip(printf("EURO_HDTV_DETECTED (0x%x)\n", u16Status));
4752 Euro_status = EURO_HDTV_DETECTED;
4753 }
4754 //else if( (u8Status & 0x0C) == 0x08 )
4755 else if( (u16Status & 0x000C) == 0x0008 )
4756 {
4757 msg_sc_ip(printf("AUSTRALIA_HDTV_DETECTED (0x%x)\n", u16Status));
4758 Euro_status = AUSTRALIA_HDTV_DETECTED;
4759 }
4760 else
4761 {
4762 msg_sc_ip(printf("NORMAL_HDTV_DETECTED (0x%x)\n", eWindow ? SC_R2BYTE(psXCInstPri->u32DeviceID,REG_SC_BK03_29_L) : SC_R2BYTE(0,REG_SC_BK01_29_L)));
4763 Euro_status = EURO_AUS_HDTV_NORMAL;
4764 }
4765
4766 //MDrv_WriteByte(BK_SELECT_00, u8Bank);
4767
4768 return Euro_status;
4769 }
4770
4771 //-----------------------------------------------------------------------------
4772 /// Euro/Australia Hdtv Detection Handler, this handler was executed if no input sync detected
4773 /// and will try to detect if Euro/Australia/Normal input.
4774 /// @param eWindow \b IN: which window we are going to set
4775 /// @return None.
4776 //-----------------------------------------------------------------------------
MApi_XC_EuroHdtvHandler(void * pInstance,SCALER_WIN eWindow)4777 void MApi_XC_EuroHdtvHandler(void *pInstance, SCALER_WIN eWindow)
4778 {
4779 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4780 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4781 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4782 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4783 //40ms delay in this function will cause ZUI MApp_ZUI_ACT_TransitionEffectDoing too slow.
4784 //in order to speed up ZUI MApp_ZUI_ACT_TransitionEffectDoing, we disable 40ms delay in this function
4785 //and let g_ucModeDetectPollingCounter in MApp_PCMode_TimingMonitor to handle the delay
4786 //MApp_PCMode_TimingMonitor will be called every 30ms while MDrv_Mode_DetectEuroHdtvHandler will be called every 60ms
4787 if(pXCResourcePrivate->stdrvXC_IP.u8Count)
4788 {
4789 pXCResourcePrivate->stdrvXC_IP.u8Count--;
4790 return;
4791 }
4792 _XC_ENTRY(pInstance);
4793 pXCResourcePrivate->stdrvXC_IP.u8Count = 1;
4794
4795 // Toggle Composite Sync Separate Decision Count
4796 if( Hal_SC_get_cs_det_cnt(pInstance, eWindow) == 0x00)
4797 {
4798 Hal_SC_set_cs_det_cnt(pInstance, Hal_SC_get_plus_width(pInstance, eWindow), eWindow);
4799 }
4800 else
4801 {
4802 _XC_RETURN(pInstance);
4803 MDrv_XC_HWAuto_SyncSeparate(pInstance, eWindow);
4804 _XC_ENTRY(pInstance);
4805 }
4806 //printf("++++++++++++++++++++++++XC_MD_SYNC_LOSS<>:%x, %x\n",Hal_SC_get_cs_det_cnt(eWindow),Hal_SC_get_plus_width(eWindow));
4807
4808 //MsOS_DelayTask(40); // Delay till stable
4809
4810 //printf("SepCnt=0x%bx\n", MDrv_ReadByte(H_BK_IP1F2(0x0C)));
4811
4812 _XC_RETURN(pInstance);
4813 return;
4814 }
4815
4816 //-----------------------------------------------------------------------------
4817 // set composite sync separate decision count to 0:HW Auto Decide
4818 // @return None.
4819 //-----------------------------------------------------------------------------
MDrv_XC_HWAuto_SyncSeparate(void * pInstance,SCALER_WIN eWindow)4820 void MDrv_XC_HWAuto_SyncSeparate(void *pInstance, SCALER_WIN eWindow)
4821 {
4822 _XC_ENTRY(pInstance);
4823 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4824 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4825
4826 // Toggle Composite Sync Separate Decision Count
4827 if( Hal_SC_get_cs_det_cnt(pInstance, eWindow) != 0x00)
4828 {
4829 Hal_SC_set_cs_det_cnt(pInstance, 0x00, eWindow);
4830
4831 if(eWindow == MAIN_WINDOW)
4832 Hal_SC_ip_software_reset(pInstance,REST_IP_F2,eWindow);
4833 else
4834 Hal_SC_ip_software_reset(pInstance,REST_IP_F1,eWindow);
4835 }
4836
4837 _XC_RETURN(pInstance);
4838
4839 return;
4840 }
4841
4842 //-----------------------------------------------------------------------------
4843 // set FilmMode_P
4844 // @return None.
4845 //-----------------------------------------------------------------------------
MApi_XC_FilmMode_P_U2(void * pInstance)4846 void MApi_XC_FilmMode_P_U2(void* pInstance)
4847 {
4848 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4849 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4850 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
4851 _XC_ENTRY(pInstance);
4852 HAL_SC_FilmMode_Patch1(pInstance);
4853 _XC_RETURN(pInstance);
4854 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
4855 }
4856
MApi_XC_FilmMode_P(void)4857 void MApi_XC_FilmMode_P(void)
4858 {
4859 if (pu32XCInst == NULL)
4860 {
4861 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4862 return;
4863 }
4864
4865 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_FILM_MODE_PATCH, NULL) != UTOPIA_STATUS_SUCCESS)
4866 {
4867 printf("Obtain XC engine fail\n");
4868 return;
4869 }
4870 else
4871 {
4872 return;
4873 }
4874 }
4875
MApi_XC_set_FD_Mask(MS_BOOL bEnable)4876 void MApi_XC_set_FD_Mask(MS_BOOL bEnable)
4877 {
4878 if (pu32XCInst == NULL)
4879 {
4880 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4881 return;
4882 }
4883
4884 stXC_SET_FDMASK_BYWIN XCArgs;
4885 XCArgs.bEnable = bEnable;
4886 XCArgs.eWindow = MAIN_WINDOW;
4887
4888 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_FDMASK_BYWIN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4889 {
4890 printf("Obtain XC engine fail\n");
4891 return;
4892 }
4893 else
4894 {
4895 return;
4896 }
4897 }
4898
4899
MApi_XC_Get_FD_Mask(void)4900 MS_BOOL MApi_XC_Get_FD_Mask(void)
4901 {
4902 if (pu32XCInst == NULL)
4903 {
4904 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4905 return FALSE;
4906 }
4907
4908 stXC_GET_FDMASK_BYWIN XCArgs;
4909 XCArgs.eWindow = MAIN_WINDOW;
4910 XCArgs.bReturnValue = FALSE;
4911
4912 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_FDMASK_BYWIN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4913 {
4914 printf("Obtain XC engine fail\n");
4915 return FALSE;
4916 }
4917 else
4918 {
4919 return XCArgs.bReturnValue;
4920 }
4921 }
4922
MApi_XC_Set_FD_Mask_ByWin_U2(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)4923 void MApi_XC_Set_FD_Mask_ByWin_U2(void* pInstance, MS_BOOL bEnable, SCALER_WIN eWindow)
4924 {
4925 _XC_ENTRY(pInstance);
4926 MDrv_XC_Set_FD_Mask_ByWin(pInstance, bEnable, eWindow);
4927 _XC_RETURN(pInstance);
4928
4929 return;
4930 }
4931
MApi_XC_set_FD_Mask_byWin(MS_BOOL bEnable,SCALER_WIN eWindow)4932 void MApi_XC_set_FD_Mask_byWin(MS_BOOL bEnable, SCALER_WIN eWindow)
4933 {
4934 if (pu32XCInst == NULL)
4935 {
4936 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4937 return;
4938 }
4939
4940 stXC_SET_FDMASK_BYWIN XCArgs;
4941 XCArgs.bEnable = bEnable;
4942 XCArgs.eWindow = eWindow;
4943
4944 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_FDMASK_BYWIN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4945 {
4946 printf("Obtain XC engine fail\n");
4947 return;
4948 }
4949 else
4950 {
4951 return;
4952 }
4953 }
4954
MApi_XC_Get_FD_Mask_ByWin_U2(void * pInstance,SCALER_WIN eWindow)4955 MS_BOOL MApi_XC_Get_FD_Mask_ByWin_U2(void* pInstance, SCALER_WIN eWindow)
4956 {
4957 MS_BOOL bRet = FALSE;
4958 _XC_ENTRY(pInstance);
4959 bRet = HAL_SC_ip_Get_FD_Mask_ByWin(pInstance, eWindow);
4960 _XC_RETURN(pInstance);
4961 return bRet;
4962 }
4963
MApi_XC_Get_FD_Mask_byWin(SCALER_WIN eWindow)4964 MS_BOOL MApi_XC_Get_FD_Mask_byWin(SCALER_WIN eWindow)
4965 {
4966 if (pu32XCInst == NULL)
4967 {
4968 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4969 return FALSE;
4970 }
4971
4972 stXC_GET_FDMASK_BYWIN XCArgs;
4973 XCArgs.eWindow = eWindow;
4974 XCArgs.bReturnValue = FALSE;
4975
4976 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_FDMASK_BYWIN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4977 {
4978 printf("Obtain XC engine fail\n");
4979 return FALSE;
4980 }
4981 else
4982 {
4983 return XCArgs.bReturnValue;
4984 }
4985 }
4986
MApi_XC_Get_FD_Mask_Status_U2(void * pInstance,SCALER_WIN eWindow)4987 MS_BOOL MApi_XC_Get_FD_Mask_Status_U2(void* pInstance, SCALER_WIN eWindow)
4988 {
4989 MS_BOOL bRet = FALSE;
4990 _XC_ENTRY(pInstance);
4991 bRet = HAL_SC_ip_Get_FD_Mask_Status(pInstance, eWindow);
4992 _XC_RETURN(pInstance);
4993 return bRet;
4994 }
4995
MApi_XC_Get_FD_Mask_Status(SCALER_WIN eWindow)4996 MS_BOOL MApi_XC_Get_FD_Mask_Status(SCALER_WIN eWindow)
4997 {
4998 if (pu32XCInst == NULL)
4999 {
5000 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5001 return FALSE;
5002 }
5003
5004 stXC_GET_FDMASK_STATUS XCArgs;
5005 XCArgs.eWindow = eWindow;
5006 XCArgs.bReturnValue = FALSE;
5007
5008 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_FDMASK_STATUS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5009 {
5010 printf("Obtain XC engine fail\n");
5011 return FALSE;
5012 }
5013 else
5014 {
5015 return XCArgs.bReturnValue;
5016 }
5017 }
5018
MApi_XC_set_GOP_Enable_U2(void * pInstance,MS_U8 MaxGOP,MS_U8 UseNum,MS_U8 u8MuxNum,MS_BOOL bEnable)5019 MS_BOOL MApi_XC_set_GOP_Enable_U2(void* pInstance, MS_U8 MaxGOP ,MS_U8 UseNum, MS_U8 u8MuxNum, MS_BOOL bEnable)
5020 {
5021 MS_BOOL bRet = FALSE;
5022 _XC_ENTRY(pInstance);
5023 bRet = HAL_SC_set_GOP_Enable(pInstance, MaxGOP , UseNum, u8MuxNum, bEnable);
5024 _XC_RETURN(pInstance);
5025 return bRet;
5026 }
5027
MApi_XC_set_GOP_Enable(MS_U8 MaxGOP,MS_U8 UseNum,MS_U8 u8MuxNum,MS_BOOL bEnable)5028 MS_BOOL MApi_XC_set_GOP_Enable(MS_U8 MaxGOP ,MS_U8 UseNum, MS_U8 u8MuxNum, MS_BOOL bEnable)
5029 {
5030 if (pu32XCInst == NULL)
5031 {
5032 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5033 return FALSE;
5034 }
5035
5036 stXC_SET_GOP_ENABLE XCArgs;
5037 XCArgs.MaxGOP = MaxGOP;
5038 XCArgs.UseNum = UseNum;
5039 XCArgs.u8MuxNum = u8MuxNum;
5040 XCArgs.bEnable = bEnable;
5041 XCArgs.bReturnValue = FALSE;
5042
5043 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_GOP_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5044 {
5045 printf("Obtain XC engine fail\n");
5046 return FALSE;
5047 }
5048 else
5049 {
5050 return XCArgs.bReturnValue;
5051 }
5052 }
5053
MApi_XC_ip_sel_for_gop_U2(void * pInstance,MS_U8 u8MuxNum,MS_XC_IPSEL_GOP ipSelGop)5054 void MApi_XC_ip_sel_for_gop_U2(void* pInstance, MS_U8 u8MuxNum ,MS_XC_IPSEL_GOP ipSelGop)
5055 {
5056 _XC_ENTRY(pInstance);
5057 HAL_SC_ip_sel_for_gop(pInstance, u8MuxNum , ipSelGop);
5058 _XC_RETURN(pInstance);
5059 }
5060
MApi_XC_ip_sel_for_gop(MS_U8 u8MuxNum,MS_XC_IPSEL_GOP ipSelGop)5061 void MApi_XC_ip_sel_for_gop(MS_U8 u8MuxNum ,MS_XC_IPSEL_GOP ipSelGop)
5062 {
5063 if (pu32XCInst == NULL)
5064 {
5065 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5066 return;
5067 }
5068
5069 stXC_SET_SELECT_IP_FOR_GOP XCArgs;
5070 XCArgs.u8MuxNum = u8MuxNum;
5071 XCArgs.ipSelGop = ipSelGop;
5072
5073 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_SELECT_IP_FOR_GOP, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5074 {
5075 printf("Obtain XC engine fail\n");
5076 return;
5077 }
5078 else
5079 {
5080 return;
5081 }
5082 }
5083
5084 /******************************************************************************/
5085 /// Set Scaler VOP New blending level
5086 /******************************************************************************/
MApi_XC_SetVOPNBL_U2(void * pInstance)5087 void MApi_XC_SetVOPNBL_U2(void* pInstance)
5088 {
5089 _XC_ENTRY(pInstance);
5090 HAL_SC_SetVOPNBL(pInstance);
5091 _XC_RETURN(pInstance);
5092 }
5093
MApi_XC_SetVOPNBL(void)5094 void MApi_XC_SetVOPNBL(void)
5095 {
5096 if (pu32XCInst == NULL)
5097 {
5098 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5099 return;
5100 }
5101
5102 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_VOP_NEW_BLENDING_LEVEL, NULL) != UTOPIA_STATUS_SUCCESS)
5103 {
5104 printf("Obtain XC engine fail\n");
5105 return;
5106 }
5107 else
5108 {
5109 return;
5110 }
5111 }
5112
MApi_XC_GetDstInfo_IP1(void * pInstance,MS_XC_DST_DispInfo * pDstInfo,MS_U32 u32SizeofDstInfo,SCALER_WIN eWindow)5113 MS_BOOL MApi_XC_GetDstInfo_IP1(void *pInstance, MS_XC_DST_DispInfo *pDstInfo, MS_U32 u32SizeofDstInfo, SCALER_WIN eWindow)
5114 {
5115 MS_BOOL bResult = FALSE;
5116 MS_WINDOW_TYPE capWin;
5117
5118 if(NULL == pDstInfo)
5119 {
5120 msg_sc_ip(printf("MApi_XC_GetDstInfo_IP1():pDstInfo is NULL\n");)
5121 return FALSE;
5122 }
5123
5124 if(u32SizeofDstInfo != sizeof(MS_XC_DST_DispInfo))
5125 {
5126 msg_sc_ip(printf("MApi_XC_GetDstInfo_IP1():u16SizeofDstInfo is different from the MS_XC_DST_DispInfo defined, check header file!\n");)
5127 return FALSE;
5128 }
5129
5130 Hal_SC_ip_get_capture_window(pInstance, &capWin, eWindow);
5131 pDstInfo->VDTOT = Hal_SC_ip_get_verticaltotal(pInstance, eWindow);
5132 pDstInfo->HDTOT = 0;//cannot get this info
5133 pDstInfo->DEHST = capWin.x;
5134 pDstInfo->DEHEND= capWin.x + capWin.width - 1;
5135 pDstInfo->DEVST= capWin.y;
5136 pDstInfo->DEVEND= capWin.y + capWin.height - 1;
5137 pDstInfo->bInterlaceMode = Hal_SC_ip_get_interlace_status(pInstance, eWindow);
5138
5139 pDstInfo->bYUVInput = Hal_SC_get_ip2_csc(pInstance, eWindow);
5140 bResult = TRUE;
5141
5142 msg_sc_ip(printf("pDstInfo:bInterlaceMode=%x,HDTOT=%lx,VDTOT=%lx,DEHST=%lx,DEHEND=%lx,DEVST=%lx,DEVEND=%lx\n",
5143 pDstInfo->bInterlaceMode, pDstInfo->HDTOT, pDstInfo->VDTOT, pDstInfo->DEHST, pDstInfo->DEHEND,
5144 pDstInfo->DEVST, pDstInfo->DEVEND);)
5145 return bResult;
5146
5147 }
5148
5149 //------------------------------------------------------------------------------
5150 /// XC IP0 Get Destination Information for GOP mixer
5151 /// @return TRUE/FALSE
5152 //------------------------------------------------------------------------------
MApi_XC_GetDstInfo_U2(void * pInstance,MS_XC_DST_DispInfo * pDstInfo,MS_U32 u32SizeofDstInfo,EN_GOP_XCDST_TYPE XCDstType)5153 MS_BOOL MApi_XC_GetDstInfo_U2(void* pInstance, MS_XC_DST_DispInfo *pDstInfo, MS_U32 u32SizeofDstInfo, EN_GOP_XCDST_TYPE XCDstType)
5154 {
5155 MS_BOOL bResult = FALSE;
5156 MS_WINDOW_TYPE stXCMainDisWin;
5157 memset(&stXCMainDisWin, 0, sizeof(MS_WINDOW_TYPE));
5158 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5159 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5160 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
5161 _XC_ENTRY(pInstance);
5162
5163 if(NULL == pDstInfo)
5164 {
5165 msg_sc_ip(printf("MApi_XC_GetDstInfo_IP():pDstInfo is NULL\n");)
5166 bResult = FALSE;
5167 }else if(u32SizeofDstInfo != sizeof(MS_XC_DST_DispInfo))
5168 {
5169 msg_sc_ip(printf("MApi_XC_GetDstInfo_IP():u16SizeofDstInfo is different from the MS_XC_DST_DispInfo defined, check header file!\n");)
5170 bResult = FALSE;
5171 }else if(XCDstType >= MAX_GOP_XCDST_SUPPORT)
5172 {
5173 msg_sc_ip(printf("MApi_XC_GetDstInfo_IP():XCDstType(%x) is out of range!\n", XCDstType);)
5174 bResult = FALSE;
5175 }
5176 else
5177 {
5178 switch(XCDstType)
5179 {
5180 default:
5181 case E_GOP_XCDST_IP2:
5182 msg_sc_ip(printf("MApi_XC_GetDstInfo_IP():XCDstType(%x) is not supported temporarily!\n", XCDstType);)
5183 pDstInfo->bInterlaceMode = FALSE;
5184 pDstInfo->bYUVInput = FALSE;
5185 pDstInfo->HDTOT = 0;
5186 pDstInfo->VDTOT = 0;
5187 pDstInfo->DEHST = 0;
5188 pDstInfo->DEHEND= 0;
5189 pDstInfo->DEVST = 0;
5190 pDstInfo->DEVEND= 0;
5191 bResult = FALSE;
5192 break;
5193
5194 case E_GOP_XCDST_IP1_MAIN:
5195 bResult = MApi_XC_GetDstInfo_IP1(pInstance, pDstInfo, u32SizeofDstInfo, MAIN_WINDOW);
5196 break;
5197
5198 case E_GOP_XCDST_IP1_SUB:
5199 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
5200 bResult = MApi_XC_GetDstInfo_IP1(g_pDevice1Instance, pDstInfo, u32SizeofDstInfo, MAIN_WINDOW);
5201 #else
5202 bResult = MApi_XC_GetDstInfo_IP1(pInstance, pDstInfo, u32SizeofDstInfo, SUB_WINDOW);
5203 #endif
5204
5205 break;
5206
5207 case E_GOP_XCDST_OP1_MAIN:
5208 MDrv_XC_get_dispwin_from_reg(pInstance, MAIN_WINDOW, &stXCMainDisWin);
5209 pDstInfo->bInterlaceMode = FALSE;
5210 pDstInfo->bYUVInput = FALSE;
5211 pDstInfo->HDTOT = 0;
5212 pDstInfo->VDTOT = 0;
5213 pDstInfo->DEHST = stXCMainDisWin.x;
5214 pDstInfo->DEHEND= stXCMainDisWin.width+stXCMainDisWin.x-1;
5215 pDstInfo->DEVST = stXCMainDisWin.y;
5216 pDstInfo->DEVEND= stXCMainDisWin.height+stXCMainDisWin.y-1;
5217 bResult = TRUE;
5218 break;
5219 }
5220 }
5221 _XC_RETURN(pInstance);
5222 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
5223 return bResult;
5224 }
5225
MApi_XC_GetDstInfo(MS_XC_DST_DispInfo * pDstInfo,MS_U32 u32SizeofDstInfo,EN_GOP_XCDST_TYPE XCDstType)5226 MS_BOOL MApi_XC_GetDstInfo(MS_XC_DST_DispInfo *pDstInfo, MS_U32 u32SizeofDstInfo, EN_GOP_XCDST_TYPE XCDstType)
5227 {
5228 if (pu32XCInst == NULL)
5229 {
5230 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5231 return FALSE;
5232 }
5233
5234 stXC_GET_DESTINATION_INFO XCArgs;
5235 XCArgs.pDstInfo = pDstInfo;
5236 XCArgs.u32SizeofDstInfo = u32SizeofDstInfo;
5237 XCArgs.XCDstType = XCDstType;
5238 XCArgs.bReturnValue = FALSE;
5239
5240 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_DESTINATION_INFO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5241 {
5242 printf("Obtain XC engine fail\n");
5243 return FALSE;
5244 }
5245 else
5246 {
5247 return XCArgs.bReturnValue;
5248 }
5249 }
5250
5251 //-------------------------------------------------------------------------------------------------
5252 /// Set IP1 Test Pattern
5253 /// @param eWindow \b IN: IP1 Test Patter Enable
5254 /// @param eWindow \b IN: IP1 Test Pattern Type
5255 /// @param eWindow \b IN: which window(main or sub) to get
5256 //-------------------------------------------------------------------------------------------------
MApi_XC_SetIP1TestPattern_U2(void * pInstance,MS_U8 u8Enable,MS_U16 u6Pattern_type,SCALER_WIN eWindow)5257 void MApi_XC_SetIP1TestPattern_U2(void* pInstance, MS_U8 u8Enable, MS_U16 u6Pattern_type, SCALER_WIN eWindow)
5258 {
5259 _XC_ENTRY(pInstance);
5260 Hal_SC_ip_Set_TestPattern(pInstance, (MS_U16)u8Enable, (MS_U32)u6Pattern_type, eWindow);
5261 _XC_RETURN(pInstance);
5262 }
5263
MApi_XC_SetIP1TestPattern(MS_U8 u8Enable,MS_U16 u6Pattern_type,SCALER_WIN eWindow)5264 void MApi_XC_SetIP1TestPattern(MS_U8 u8Enable, MS_U16 u6Pattern_type, SCALER_WIN eWindow)
5265 {
5266 if (pu32XCInst == NULL)
5267 {
5268 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5269 return;
5270 }
5271
5272 stXC_SET_IP1_TESTPATTERN XCArgs;
5273 XCArgs.u8Enable = u8Enable;
5274 XCArgs.u6Pattern_type = u6Pattern_type;
5275 XCArgs.eWindow = eWindow;
5276
5277 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_IP1_TESTPATTERN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5278 {
5279 printf("Obtain XC engine fail\n");
5280 return;
5281 }
5282 else
5283 {
5284 return;
5285 }
5286 }
5287
5288 #ifdef UFO_XC_TEST_PATTERN
MApi_XC_GenerateTestPattern_U2(void * pInstance,EN_XC_TEST_PATTERN_MODE ePatternMode,void * para,MS_U16 u16Length)5289 void MApi_XC_GenerateTestPattern_U2(void* pInstance,EN_XC_TEST_PATTERN_MODE ePatternMode,void* para, MS_U16 u16Length)
5290 {
5291 _XC_ENTRY(pInstance);
5292 switch(ePatternMode)
5293 {
5294 case E_XC_ADC_PATTERN_MODE:
5295 {
5296 p_XC_SET_ADC_TESTPATTERN_t pXCArgs = (p_XC_SET_ADC_TESTPATTERN_t)para;
5297 if(u16Length != sizeof(XC_SET_ADC_TESTPATTERN_t))
5298 {
5299 printf("[%s,%5d]the size of the struct passing to func isn't match the one in driver, please check if the ePatternMode is matching with para\n",__FUNCTION__,__LINE__);
5300 _XC_RETURN(pInstance);
5301 return;
5302 }
5303 Hal_SC_adc_Set_TestPattern(pInstance,pXCArgs->u8EnableADCType,pXCArgs->u16Ramp);
5304 break;
5305 }
5306 case E_XC_IPMUX_PATTERN_MODE:
5307 {
5308 p_XC_SET_IPMUX_TESTPATTERN_t pXCArgs = (p_XC_SET_IPMUX_TESTPATTERN_t)para;
5309 if(u16Length != sizeof(XC_SET_IPMUX_TESTPATTERN_t))
5310 {
5311 printf("[%s,%5d]the size of the struct passing to func isn't match the one in driver, please check if the ePatternMode is matching with para\n",__FUNCTION__,__LINE__);
5312 _XC_RETURN(pInstance);
5313 return;
5314 }
5315 Hal_SC_ipmux_Set_TestPattern(pInstance,pXCArgs->bEnable,pXCArgs->u16R_CR_Data,pXCArgs->u16G_Y_Data,pXCArgs->u16B_CB_Data);
5316 break;
5317 }
5318 case E_XC_IP1_PATTERN_MODE:
5319 {
5320 p_XC_SET_IP1_TESTPATTERN_t pXCArgs = (p_XC_SET_IP1_TESTPATTERN_t)para;
5321 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
5322 USE_OTHER_SC_AS_SUB_WINDOW();
5323 #endif
5324 if(u16Length != sizeof(XC_SET_IP1_TESTPATTERN_t))
5325
5326 {
5327 printf("[%s,%5d]the size of the struct passing to func isn't match the one in driver, please check if the ePatternMode is matching with para\n",__FUNCTION__,__LINE__);
5328 _XC_RETURN(pInstance);
5329 return;
5330 }
5331 Hal_SC_ip_Set_TestPattern(pInstance,pXCArgs->u16Enable, pXCArgs->u32Pattern_type, pXCArgs->eWindow);
5332 break;
5333 }
5334 case E_XC_OP_PATTERN_MODE:
5335 {
5336 p_XC_SET_OP_TESTPATTERN_t pXCArgs = (p_XC_SET_OP_TESTPATTERN_t)para;
5337
5338 if(u16Length != sizeof(XC_SET_OP_TESTPATTERN_t))
5339
5340 {
5341 printf("[%s,%5d]the size of the struct passing to func isn't match the one in driver, please check if the ePatternMode is matching with para\n",__FUNCTION__,__LINE__);
5342 _XC_RETURN(pInstance);
5343 return;
5344 }
5345 Hal_SC_op_Set_TestPattern(pInstance,pXCArgs->bMiuLineBuff, pXCArgs->bLineBuffHVSP);
5346 break;
5347 }
5348 case E_XC_VOP_PATTERN_MODE:
5349 {
5350 p_XC_SET_VOP_TESTPATTERN_t pXCArgs = (p_XC_SET_VOP_TESTPATTERN_t)para;
5351
5352 if(u16Length != sizeof(XC_SET_VOP_TESTPATTERN_t))
5353
5354 {
5355 printf("[%s,%5d]the size of the struct passing to func isn't match the one in driver, please check if the ePatternMode is matching with para\n",__FUNCTION__,__LINE__);
5356 _XC_RETURN(pInstance);
5357 return;
5358 }
5359 Hal_SC_vop_Set_TestPattern(pInstance,pXCArgs->bEnable);
5360 break;
5361 }
5362 case E_XC_VOP2_PATTERN_MODE:
5363 {
5364 p_XC_SET_VOP2_TESTPATTERN_t pXCArgs = (p_XC_SET_VOP2_TESTPATTERN_t)para;
5365 if(u16Length != sizeof(XC_SET_VOP2_TESTPATTERN_t))
5366
5367 {
5368 printf("[%s,%5d]the size of the struct passing to func isn't match the one in driver, please check if the ePatternMode is matching with para\n",__FUNCTION__,__LINE__);
5369
5370 _XC_RETURN(pInstance);
5371 return;
5372 }
5373 Hal_SC_vop2_Set_TestPattern(pInstance,pXCArgs->bEnable,pXCArgs->u16R_CR_Data,pXCArgs->u16G_Y_Data,pXCArgs->u16B_CB_Data);
5374 break;
5375 }
5376 case E_XC_MOD_PATTERN_MODE:
5377 {
5378 p_XC_SET_MOD_TESTPATTERN_t pXCArgs = (p_XC_SET_MOD_TESTPATTERN_t)para;
5379 if(u16Length != sizeof(XC_SET_MOD_TESTPATTERN_t))
5380 {
5381 printf("[%s,%5d]the size of the struct passing to func isn't match the one in driver, please check if the ePatternMode is matching with para\n",__FUNCTION__,__LINE__);
5382 _XC_RETURN(pInstance);
5383 return;
5384 }
5385 Hal_SC_mod_Set_TestPattern(pInstance,pXCArgs->bEnable,pXCArgs->u16R_CR_Data,pXCArgs->u16G_Y_Data,pXCArgs->u16B_CB_Data);
5386
5387 break;
5388 }
5389 default:
5390 {
5391 printf("[%s,%5d]unknown pattern type = %d\n",__FUNCTION__,__LINE__,ePatternMode);
5392 break;
5393 }
5394 }
5395 _XC_RETURN(pInstance);
5396 }
5397
MApi_XC_GenerateTestPattern(EN_XC_TEST_PATTERN_MODE ePatternMode,void * para,MS_U16 u16Length)5398 void MApi_XC_GenerateTestPattern (EN_XC_TEST_PATTERN_MODE ePatternMode,void* para, MS_U16 u16Length)
5399 {
5400 if (pu32XCInst == NULL)
5401 {
5402 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5403 return;
5404 }
5405
5406 stXC_SET_TESTPATTERN XCArgs;
5407 XCArgs.ePatternMode = ePatternMode;
5408 XCArgs.para = para;
5409 XCArgs.u16Length = u16Length;
5410
5411
5412 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_TESTPATTERN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5413 {
5414 printf("Obtain XC engine fail\n");
5415 return;
5416 }
5417 else
5418 {
5419 return;
5420 }
5421 }
5422 #endif
5423
MApi_XC_InitRegInTimingChange_Post(void * pInstance,MS_U8 u8CurrentSyncStatus,SCALER_WIN eWindow)5424 void MApi_XC_InitRegInTimingChange_Post(void *pInstance, MS_U8 u8CurrentSyncStatus, SCALER_WIN eWindow)
5425 {
5426 _XC_ENTRY(pInstance);
5427
5428 //if( MP_IS_COMP() ) // just for component
5429 {
5430 // For Master 925FS timing 221 (1080i)
5431
5432 if ( u8CurrentSyncStatus & (BIT(2)|BIT(3)|BIT(4)))// sync loss | MD_INTERLACE_BIT) )
5433 HAL_SC_ip_detect_mode(pInstance, ENABLE, eWindow);
5434 else
5435 HAL_SC_ip_detect_mode(pInstance, DISABLE, eWindow);
5436 }
5437
5438 _XC_RETURN(pInstance);
5439 }
5440
MApi_XC_Is_H_Sync_Active_U2(void * pInstance,SCALER_WIN eWindow)5441 MS_BOOL MApi_XC_Is_H_Sync_Active_U2(void* pInstance, SCALER_WIN eWindow)
5442 {
5443 MS_BOOL bRet = FALSE;
5444 _XC_ENTRY(pInstance);
5445 if(Hal_SC_ip_get_h_v_sync_active(pInstance, eWindow) & 0x40)
5446 {
5447 bRet = TRUE;
5448 }
5449 else
5450 {
5451 bRet = FALSE;
5452 }
5453 _XC_RETURN(pInstance);
5454 return bRet;
5455 }
5456
MApi_XC_Is_H_Sync_Active(SCALER_WIN eWindow)5457 MS_BOOL MApi_XC_Is_H_Sync_Active(SCALER_WIN eWindow)
5458 {
5459 if (pu32XCInst == NULL)
5460 {
5461 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5462 return FALSE;
5463 }
5464
5465 stXC_CHECK_HSYNC_ACTIVE XCArgs;
5466 XCArgs.eWindow = eWindow;
5467 XCArgs.bReturnValue = FALSE;
5468
5469 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_CHECK_HSYNC_ACTIVE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5470 {
5471 printf("Obtain XC engine fail\n");
5472 return FALSE;
5473 }
5474 else
5475 {
5476 return XCArgs.bReturnValue;
5477 }
5478 }
5479
MApi_XC_Is_V_Sync_Active_U2(void * pInstance,SCALER_WIN eWindow)5480 MS_BOOL MApi_XC_Is_V_Sync_Active_U2(void* pInstance, SCALER_WIN eWindow)
5481 {
5482 MS_BOOL bRet = FALSE;
5483 _XC_ENTRY(pInstance);
5484 if(Hal_SC_ip_get_h_v_sync_active(pInstance, eWindow) & 0x80)
5485 {
5486 bRet = TRUE;
5487 }
5488 else
5489 {
5490 bRet = FALSE;
5491 }
5492 _XC_RETURN(pInstance);
5493 return bRet;
5494 }
5495
MApi_XC_Is_V_Sync_Active(SCALER_WIN eWindow)5496 MS_BOOL MApi_XC_Is_V_Sync_Active(SCALER_WIN eWindow)
5497 {
5498 if (pu32XCInst == NULL)
5499 {
5500 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5501 return FALSE;
5502 }
5503
5504 stXC_CHECK_VSYNC_ACTIVE XCArgs;
5505 XCArgs.eWindow = eWindow;
5506 XCArgs.bReturnValue = FALSE;
5507
5508 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_CHECK_VSYNC_ACTIVE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5509 {
5510 printf("Obtain XC engine fail\n");
5511 return FALSE;
5512 }
5513 else
5514 {
5515 return XCArgs.bReturnValue;
5516 }
5517 }
5518
MApi_XC_GetVSyncWidth_U2(void * pInstance,SCALER_WIN eWindow)5519 MS_U8 MApi_XC_GetVSyncWidth_U2(void* pInstance, SCALER_WIN eWindow)
5520 {
5521 MS_U8 u8VsyncWidth = 0;
5522 _XC_ENTRY(pInstance);
5523 u8VsyncWidth = Hal_SC_getVSyncWidth(pInstance, eWindow);
5524 _XC_RETURN(pInstance);
5525 return u8VsyncWidth;
5526 }
5527
MApi_XC_GetVSyncWidth(SCALER_WIN eWindow)5528 MS_U8 MApi_XC_GetVSyncWidth(SCALER_WIN eWindow)
5529 {
5530 if (pu32XCInst == NULL)
5531 {
5532 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5533 return 0;
5534 }
5535
5536 stXC_GET_VSYNC_WIDTH XCArgs;
5537 XCArgs.eWindow = eWindow;
5538 XCArgs.u8ReturnValue = 0;
5539
5540 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_VSYNC_WIDTH, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5541 {
5542 printf("Obtain XC engine fail\n");
5543 return 0;
5544 }
5545 else
5546 {
5547 return XCArgs.u8ReturnValue;
5548 }
5549 }
MApi_XC_OutputFrameCtrl_U2(void * pInstance,MS_BOOL bEnable,XC_OUTPUTFRAME_Info * pstOutFrameInfo,SCALER_WIN eWindow)5550
5551 E_APIXC_ReturnValue MApi_XC_OutputFrameCtrl_U2(void* pInstance, MS_BOOL bEnable,XC_OUTPUTFRAME_Info *pstOutFrameInfo,SCALER_WIN eWindow)
5552 {
5553 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5554 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5555 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
5556 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5557 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5558 _XC_ENTRY(pInstance);
5559 if(!bEnable)
5560 {
5561 gSrcInfo[eWindow].bRWBankAuto = TRUE;
5562 Hal_SC_set_skp_fd(pInstance, FALSE, eWindow);
5563 // if support _FIELD_PACKING_MODE_SUPPORTED, it will control by QMAP(J2/A5/A6/A3)
5564 #if(!_FIELD_PACKING_MODE_SUPPORTED)
5565 Hal_SC_set_wr_bank_mapping(pInstance, 0x00, eWindow);
5566 #endif
5567 }
5568 else
5569 {
5570 //When bRWBankAuto = FALSE, wr_bank_mapping must be controled by QMap
5571 gSrcInfo[eWindow].bRWBankAuto = FALSE;
5572
5573 #ifdef UFO_XC_FB_LEVEL
5574 if(gSrcInfo[eWindow].eFBLevel == E_XC_FB_LEVEL_FBL)
5575 #else
5576 if(gSrcInfo[eWindow].bFBL)
5577 #endif
5578 {
5579 Hal_SC_set_skp_fd(pInstance, FALSE, eWindow);
5580 }
5581 else
5582 {
5583 if(!pstOutFrameInfo->bInterlace) //progress
5584 {
5585 Hal_SC_set_skp_fd(pInstance, FALSE, eWindow);
5586 }
5587 else //interlace
5588 {
5589 #if (HW_DESIGN_4K2K_VER == 7)
5590 Hal_SC_set_skp_fd(pInstance, TRUE, eWindow);
5591 #else
5592 if(pstOutFrameInfo->u16InVFreq > pstOutFrameInfo->u16OutVFreq) //Drop frame case
5593 {
5594 Hal_SC_set_skp_fd(pInstance, TRUE, eWindow);
5595 }
5596 else
5597 {
5598 Hal_SC_set_skp_fd(pInstance, FALSE, eWindow);
5599 }
5600 #endif
5601 }
5602 }
5603 }
5604 _XC_RETURN(pInstance);
5605 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
5606 return E_APIXC_RET_OK;
5607 }
MApi_XC_OutputFrameCtrl(MS_BOOL bEnable,XC_OUTPUTFRAME_Info * pstOutFrameInfo,SCALER_WIN eWindow)5608
5609 E_APIXC_ReturnValue MApi_XC_OutputFrameCtrl(MS_BOOL bEnable,XC_OUTPUTFRAME_Info *pstOutFrameInfo,SCALER_WIN eWindow)
5610 {
5611 if (pu32XCInst == NULL)
5612 {
5613 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5614 return E_APIXC_RET_FAIL;
5615 }
5616
5617 stXC_SET_OUTPUT_FRAME_CONTROL XCArgs;
5618 XCArgs.bEnable = bEnable;
5619 XCArgs.pstOutFrameInfo = pstOutFrameInfo;
5620 XCArgs.eWindow = eWindow;
5621 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
5622
5623 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_OUTPUT_FRAME_CONTROL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5624 {
5625 printf("Obtain XC engine fail\n");
5626 return E_APIXC_RET_FAIL;
5627 }
5628 else
5629 {
5630 return XCArgs.eReturnValue;
5631 }
5632 }
MApi_XC_SetIPMux_U2(void * pInstance,MS_U8 u8Val)5633
5634 void MApi_XC_SetIPMux_U2(void* pInstance, MS_U8 u8Val)
5635 {
5636 _XC_ENTRY(pInstance);
5637 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5638 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5639 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5640 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5641
5642 HAL_SC_ip_set_ipmux(pInstance, u8Val);
5643
5644 if ((pXCResourcePrivate->sthal_Optee.op_tee_xc[MAIN_WINDOW].isEnable == TRUE) ||
5645 (pXCResourcePrivate->sthal_Optee.op_tee_xc[SUB_WINDOW].isEnable == TRUE))
5646 {
5647 XC_OPTEE_MUX_DATA st_xc_mux_data;
5648 memset(&st_xc_mux_data, 0, sizeof(XC_OPTEE_MUX_DATA));
5649 MDrv_XC_OPTEE_Mux(pInstance, E_XC_OPTEE_SET_MUX, st_xc_mux_data);
5650 }
5651
5652 _XC_RETURN(pInstance);
5653 }
MApi_XC_SetIPMux(MS_U8 u8Val)5654
5655 void MApi_XC_SetIPMux(MS_U8 u8Val)
5656 {
5657 if (pu32XCInst == NULL)
5658 {
5659 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5660 return;
5661 }
5662
5663 stXC_SET_IPMUX XCArgs;
5664 XCArgs.u8Val = u8Val;
5665
5666 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_IPMUX, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5667 {
5668 printf("Obtain XC engine fail\n");
5669 return;
5670 }
5671 else
5672 {
5673 return;
5674 }
5675 }
MDrv_XC_SetVGASogEn(void * pInstance,MS_BOOL bVGASogEn)5676
5677 void MDrv_XC_SetVGASogEn(void *pInstance, MS_BOOL bVGASogEn)
5678 {
5679 HAL_SC_SetVGASogEn(pInstance, bVGASogEn);
5680 }
MDrv_XC_GetVGASogEn(void * pInstance)5681
5682 MS_BOOL MDrv_XC_GetVGASogEn(void *pInstance)
5683 {
5684 return HAL_SC_GetVGASogEn(pInstance);
5685 }
MDrv_XC_SetSogDetectStatus(void * pInstance,MS_U8 u8SogDetectStatus)5686
5687 void MDrv_XC_SetSogDetectStatus(void *pInstance, MS_U8 u8SogDetectStatus)
5688 {
5689 HAL_SC_SetSogDetectStatus(pInstance, u8SogDetectStatus);
5690 }
MDrv_XC_GetSogDetectStatus(void * pInstance)5691
5692 MS_U8 MDrv_XC_GetSogDetectStatus(void *pInstance)
5693 {
5694 return HAL_SC_GetSogDetectStatus(pInstance);
5695 }
MDrv_XC_GetForceiSupportType(void * pInstance)5696
5697 EN_FORCEi_SUPPORT_TYPE MDrv_XC_GetForceiSupportType(void *pInstance)
5698 {
5699 return HAL_SC_ip_get_forceI_support_type(pInstance);
5700 }
MDrv_SC_ip_get_verticalperiod(void * pInstance,SCALER_WIN eWindow)5701
5702 MS_U32 MDrv_SC_ip_get_verticalperiod(void *pInstance, SCALER_WIN eWindow)
5703 {
5704 MS_U32 u32AccurateVPeriod = 0, u32PrevAccurateVPeriod = 0;
5705 MS_U8 u8Count = 0, u8VSyncTime = MDrv_XC_PCMonitor_GetVSyncTime(pInstance, eWindow);
5706
5707 if(u8VSyncTime == 0)
5708 {
5709 //fix MsOS_DelayTask(0) assert
5710 u8VSyncTime = 20;//delay 20ms(frame rate = 50hz)
5711 }
5712
5713 while (u8Count < MAX_GET_VPERIOD_TIME)
5714 {
5715 u32AccurateVPeriod = HAL_SC_ip_get_verticalperiod(pInstance, eWindow);
5716 if (abs(u32AccurateVPeriod - u32PrevAccurateVPeriod) <= PERIOD_TOLARANCE)
5717 {
5718 break;
5719 }
5720 u32PrevAccurateVPeriod = u32AccurateVPeriod;
5721 MsOS_DelayTask(u8VSyncTime);
5722 u8Count++;
5723 }
5724 return u32AccurateVPeriod;
5725 }
MDrv_XC_SetHVSyncStatusCheck(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)5726
5727 void MDrv_XC_SetHVSyncStatusCheck(void *pInstance, MS_BOOL bEnable, SCALER_WIN eWindow)
5728 {
5729 return HAL_SC_ip_set_hv_sync_status_check(pInstance, bEnable, eWindow);
5730 }
MDrv_XC_SetNewModeInterlacedDetect(void * pInstance,MS_BOOL bEnable,MS_U8 u8Source,MS_BOOL bVttByPixelClk,MS_BOOL bVInvert,MS_BOOL bHInvert,SCALER_WIN eWindow)5731
5732 void MDrv_XC_SetNewModeInterlacedDetect(void *pInstance, MS_BOOL bEnable, MS_U8 u8Source, MS_BOOL bVttByPixelClk, MS_BOOL bVInvert, MS_BOOL bHInvert, SCALER_WIN eWindow)
5733 {
5734 HAL_SC_ip_set_hv_sync_source_select(pInstance, u8Source, eWindow);
5735 HAL_SC_ip_set_vtotal_count_by_pixel_clock(pInstance, bVttByPixelClk, eWindow);
5736 HAL_SC_ip_set_vsync_invert(pInstance, bVInvert, eWindow);
5737 HAL_SC_ip_set_hsync_invert(pInstance, bHInvert, eWindow);
5738 HAL_SC_ip_set_new_mode_interlaced_detect(pInstance, bEnable, eWindow);
5739 }
MDrv_XC_PCMonitor_Init(void * pInstance,MS_U8 u8MaxWindowNum)5740
5741 MS_BOOL MDrv_XC_PCMonitor_Init(void *pInstance, MS_U8 u8MaxWindowNum)
5742 {
5743 MS_U8 i = 0;
5744 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5745 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5746 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5747 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5748 for(i = 0; i < u8MaxWindowNum; i++)
5749 {
5750 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[i].eCurrentSrc = INPUT_SOURCE_NONE;
5751 }
5752 return TRUE;
5753 }
MDrv_XC_PCMonitor_GetStatus(void * pInstance,SCALER_WIN eWindow)5754
5755 XC_PCMONITOR_HK_INFO MDrv_XC_PCMonitor_GetStatus(void *pInstance, SCALER_WIN eWindow)
5756 {
5757 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5758 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5759 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5760 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5761 return pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow];
5762 }
MDrv_XC_PCMonitor_SetStatus(void * pInstance,XC_PCMONITOR_HK_INFO sPCMONITOR_HK_Info,SCALER_WIN eWindow)5763
5764 MS_BOOL MDrv_XC_PCMonitor_SetStatus(void *pInstance, XC_PCMONITOR_HK_INFO sPCMONITOR_HK_Info, SCALER_WIN eWindow)
5765 {
5766 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5767 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5768 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5769 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5770 memcpy(&pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow], &sPCMONITOR_HK_Info, sizeof(XC_PCMONITOR_HK_INFO));
5771
5772 return TRUE;
5773 }
MDrv_XC_PCMonitor_GetStableCounter(void * pInstance,SCALER_WIN eWindow)5774
5775 MS_U8 MDrv_XC_PCMonitor_GetStableCounter(void *pInstance, SCALER_WIN eWindow)
5776 {
5777 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5778 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5779 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5780 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5781 return (IsSrcTypeHDMI(pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].eCurrentSrc)?25:25);
5782 }
MDrv_XC_PCMonitor_GetNoSyncCounter(void * pInstance,SCALER_WIN eWindow)5783
5784 MS_U8 MDrv_XC_PCMonitor_GetNoSyncCounter(void *pInstance, SCALER_WIN eWindow)
5785 {
5786 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5787 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5788 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5789 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5790 return (IsSrcTypeHDMI(pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].eCurrentSrc)?40:40);
5791 }
MDrv_XC_PCMonitor_Get_HFreqx10(void * pInstance,SCALER_WIN eWindow)5792
5793 MS_U16 MDrv_XC_PCMonitor_Get_HFreqx10(void *pInstance, SCALER_WIN eWindow)
5794 {
5795 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5796 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5797 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5798 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5799 if((pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].eCurrentState == E_XC_PCMONITOR_UNSTABLE)
5800 || (pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].eCurrentState == E_XC_PCMONITOR_STABLE_NOSYNC))
5801 {
5802 return 0;
5803 }
5804 else
5805 {
5806 return MDrv_XC_CalculateHFreqx10(pInstance, pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u16Hperiod);
5807 }
5808 }
MDrv_XC_PCMonitor_Get_HFreqx1K(void * pInstance,SCALER_WIN eWindow)5809
5810 MS_U32 MDrv_XC_PCMonitor_Get_HFreqx1K(void *pInstance, SCALER_WIN eWindow)
5811 {
5812 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5813 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5814 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5815 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5816 if((pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].eCurrentState == E_XC_PCMONITOR_UNSTABLE)
5817 || (pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].eCurrentState == E_XC_PCMONITOR_STABLE_NOSYNC))
5818 {
5819 return 0;
5820 }
5821 else
5822 {
5823 return MDrv_XC_CalculateHFreqx1K(pInstance, pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u16Hperiod);
5824 }
5825 }
MDrv_XC_PCMonitor_Get_VFreqx1K(void * pInstance,SCALER_WIN eWindow)5826
5827 MS_U32 MDrv_XC_PCMonitor_Get_VFreqx1K(void* pInstance, SCALER_WIN eWindow)
5828 {
5829 MS_U32 u32VFreq = 0, u32AccurateVFreq = 0, u32AccurateVPeriod = 0;
5830 MS_U64 u64XTALClk = 0;
5831 XC_PCMONITOR_HK_INFO stPCMonitorInfo;
5832 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5833 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5834 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5835 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5836 stPCMonitorInfo = MDrv_XC_PCMonitor_GetStatus(pInstance, eWindow);
5837
5838 if((stPCMonitorInfo.eCurrentState == E_XC_PCMONITOR_UNSTABLE) || (stPCMonitorInfo.eCurrentState == E_XC_PCMONITOR_STABLE_NOSYNC))
5839 {
5840 // Original return value is 1
5841 // Change to 1 to prevent 4K2K home screen (4K2K 30Hz) force SetPanelTiming with no signal cause core dump issue.
5842 return 1;
5843 }
5844 else
5845 {
5846 if(FALSE == (pXCResourcePrivate->stdrvXC_MVideo_Context.g_bFast_Get_VFreq))
5847 {
5848 u32VFreq = MDrv_XC_CalculateVFreqx1K(pInstance, MDrv_XC_PCMonitor_Get_HFreqx1K(pInstance, eWindow), stPCMonitorInfo.u16Vtotal);
5849 if(stPCMonitorInfo.u8SyncStatus& XC_MD_INTERLACE_BIT)
5850 {
5851 u32VFreq *= 2;
5852 }
5853 XC_LOG_TRACE(XC_DBGLEVEL_MODEPARSE, "u32VFreq = %tu\n", (ptrdiff_t)u32VFreq);
5854
5855 // for more correct VPeriod
5856 u32AccurateVPeriod = MDrv_SC_ip_get_verticalperiod(pInstance, eWindow);
5857
5858 XC_LOG_TRACE(XC_DBGLEVEL_MODEPARSE, "u32AccurateVPeriod = %tu\n", (ptrdiff_t)u32AccurateVPeriod);
5859
5860 if(u32AccurateVPeriod != 0)
5861 {
5862 u64XTALClk = (MS_U64)pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.u32XTAL_Clock * 1000 + (u32AccurateVPeriod/2);
5863 do_div(u64XTALClk,u32AccurateVPeriod);
5864 u32AccurateVFreq = (MS_U32)(u64XTALClk);
5865 }
5866 XC_LOG_TRACE(XC_DBGLEVEL_MODEPARSE, "u32AccurateVFreq = %tu\n", (ptrdiff_t)u32AccurateVFreq);
5867
5868 XC_LOG_TRACE(XC_DBGLEVEL_MODEPARSE, "InputVFreq=%tu->%tu, Tolerance=%tu\n", (ptrdiff_t)u32VFreq, (ptrdiff_t)u32AccurateVFreq, (ptrdiff_t)ACCURATE_VFREQ_TOLERANCE * 100);
5869 if(abs(u32VFreq - u32AccurateVFreq) < ACCURATE_VFREQ_TOLERANCE * 100)
5870 {
5871 u32VFreq = u32AccurateVFreq; //In tolerance range, using new accurate vfreq
5872 }
5873 }
5874 else
5875 {
5876 u32VFreq = stPCMonitorInfo.u32FrameRatex1K;
5877 }
5878 return u32VFreq;
5879 }
5880 }
MDrv_XC_PCMonitor_Get_Vtotal(void * pInstance,SCALER_WIN eWindow)5881
5882 MS_U16 MDrv_XC_PCMonitor_Get_Vtotal(void *pInstance, SCALER_WIN eWindow)
5883 {
5884 XC_PCMONITOR_HK_INFO stPCMonitorInfo;
5885 stPCMonitorInfo = MDrv_XC_PCMonitor_GetStatus(pInstance, eWindow);
5886 if((stPCMonitorInfo.eCurrentState == E_XC_PCMONITOR_UNSTABLE) || (stPCMonitorInfo.eCurrentState == E_XC_PCMONITOR_STABLE_NOSYNC))
5887 {
5888 // Original return value is 1
5889 // Change to 1 to prevent 4K2K home screen (4K2K 30Hz) force SetPanelTiming with no signal cause core dump issue.
5890 return 1;
5891 }
5892 else
5893 {
5894 return stPCMonitorInfo.u16Vtotal;
5895 }
5896 }
MDrv_XC_PCMonitor_Restart(void * pInstance,SCALER_WIN eWindow)5897
5898 void MDrv_XC_PCMonitor_Restart(void *pInstance, SCALER_WIN eWindow)
5899 {
5900 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5901 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5902 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5903 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5904 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].eCurrentState = E_XC_PCMONITOR_STABLE_NOSYNC; // no sync detected yet
5905
5906 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u32LastExecutedTime = MsOS_GetSystemTime(); // set to current time, because bInputTimingChange is TRUE, will execute timing monitor anyway
5907 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].bInputTimingChange = TRUE; // force timing monitor to detect timing
5908 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u8SyncStatus = XC_MD_SYNC_LOSS;
5909 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].ucInputTimingStableCounter = 0;
5910 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].ucTimingChangeDebounce = 0;
5911 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].bInputTimingStable = TRUE;
5912 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].bDoModeSetting = FALSE;
5913
5914 // analog
5915 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u16Hperiod = 0;
5916 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u16VSyncTime = 0;
5917 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u32FrameRatex1K= 0;
5918
5919 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u16Vtotal = 0;
5920 gSrcInfo[eWindow].Status2.u8IP_PixelRep = INVALID_IP_PIXELREPTITION;
5921 // digital
5922 memset(&(pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info), 0, sizeof(MS_WINDOW_TYPE));
5923 }
MDrv_XC_PCMonitor_Get_Dvi_Hdmi_De_Info(void * pInstance,SCALER_WIN eWindow,MS_WINDOW_TYPE * msWin)5924
5925 void MDrv_XC_PCMonitor_Get_Dvi_Hdmi_De_Info(void *pInstance, SCALER_WIN eWindow,MS_WINDOW_TYPE* msWin)
5926 {
5927 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5928 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5929 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5930 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5931 if((pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].eCurrentState == E_XC_PCMONITOR_UNSTABLE)
5932 || (pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].eCurrentState == E_XC_PCMONITOR_STABLE_NOSYNC))
5933 {
5934 return;
5935 }
5936 else
5937 {
5938 msWin->x = pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.x;
5939 msWin->y = pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.y;
5940 msWin->height= pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.height;
5941
5942 if(IsSrcTypeHDMI(gSrcInfo[eWindow].enInputSourceType) || IsSrcTypeDTV(gSrcInfo[eWindow].enInputSourceType))
5943 {
5944 if(MDrv_HDMI_CheckHDMI20_Setting(MDrv_XC_Mux_GetHDMIPort(pInstance, gSrcInfo[eWindow].enInputSourceType)))
5945 {
5946 msWin->width= (pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.width)*2;
5947 printf("HDMI is 4K2K 2P mode\n");
5948 }
5949 else
5950 {
5951 MS_U16 u16Vfrqx10 = 0;
5952 u16Vfrqx10 = MDrv_XC_CalculateVFreqx10(pInstance,
5953 MDrv_XC_CalculateHFreqx10(pInstance, pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u16Hperiod),
5954 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u16Vtotal);
5955
5956 if((pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.width >= 0x77F)
5957 &&(pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.height >= 0x86F)
5958 &&(u16Vfrqx10 >= 490))
5959 {
5960 msWin->width= (pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.width)*2;
5961 printf("HDMI is 420 1P mode\n");
5962 }
5963 else
5964 {
5965 if(((MDrv_HDMI_avi_infoframe_info(_BYTE_1)& 0x60) == 0x20)&& (pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.width <= HDE_UPPERBOUND_720) && (pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.width > HDE_LOWERBOUND_720) )
5966 {
5967 msWin->width= MDrv_HDMI_GetHDE();
5968 }else
5969 {
5970 msWin->width= pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.width;
5971 }
5972 }
5973 }
5974 }
5975 else
5976 {
5977 msWin->width= pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.width;
5978 }
5979 }
5980 }
MDrv_XC_PCMonitor_SyncLoss(void * pInstance,SCALER_WIN eWindow)5981
5982 MS_BOOL MDrv_XC_PCMonitor_SyncLoss(void *pInstance, SCALER_WIN eWindow)
5983 {
5984 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5985 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5986 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
5987 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
5988 if(pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u8SyncStatus & XC_MD_SYNC_LOSS)
5989 return TRUE;
5990 else
5991 return FALSE;
5992 }
MDrv_XC_PCMonitor_InvalidTimingDetect(void * pInstance,MS_BOOL bPollingOnly,SCALER_WIN eWindow)5993
5994 MS_BOOL MDrv_XC_PCMonitor_InvalidTimingDetect(void *pInstance, MS_BOOL bPollingOnly, SCALER_WIN eWindow)
5995 {
5996 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
5997 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
5998 MS_BOOL bResult = FALSE;
5999 XC_IP_SYNC_STATUS sXC_Sync_Status;
6000 memset(&sXC_Sync_Status, 0, sizeof(XC_IP_SYNC_STATUS));
6001 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
6002 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
6003 MDrv_XC_GetSyncStatus(pInstance, pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].eCurrentSrc, &sXC_Sync_Status, eWindow);
6004
6005 if ( ( sXC_Sync_Status.u8SyncStatus & XC_MD_SYNC_LOSS ) || // no sync
6006 ( (pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u8SyncStatus & XC_MD_VSYNC_POR_BIT) != (sXC_Sync_Status.u8SyncStatus & XC_MD_VSYNC_POR_BIT) ) || // sync polarity changed
6007 ( (pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u8SyncStatus & XC_MD_HSYNC_POR_BIT) != (sXC_Sync_Status.u8SyncStatus & XC_MD_HSYNC_POR_BIT) ) ||
6008 ( (pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u8SyncStatus & XC_MD_INTERLACE_BIT) != (sXC_Sync_Status.u8SyncStatus & XC_MD_INTERLACE_BIT) ) )
6009 {
6010 bResult = TRUE;
6011
6012 PCMSG_TIMING(printf("oldSyncStatus=0x%x, new=0x%x\n",
6013 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u8SyncStatus, sXC_Sync_Status.u8SyncStatus));
6014 }
6015 else // have signal
6016 {
6017 if ( abs( sXC_Sync_Status.u16Hperiod - pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u16Hperiod ) > MD_HPERIOD_TORLANCE )
6018 {
6019 PCMSG_TIMING(printf("Hperiod=%x->%x, Tolerance %x\n", pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u16Hperiod, sXC_Sync_Status.u16Hperiod, (MS_U16)MD_HPERIOD_TORLANCE));
6020 bResult = TRUE;
6021 }
6022 else
6023 {
6024 //PCMSG(printf("HPD=%x\n", sXC_Sync_Status.u16Hperiod));
6025 }
6026
6027 // HSync
6028 if ( bPollingOnly != TRUE )
6029 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u16Hperiod = sXC_Sync_Status.u16Hperiod;
6030
6031 if ( abs( sXC_Sync_Status.u16Vtotal - pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u16Vtotal ) > MD_VTOTAL_TORLANCE )
6032 {
6033 PCMSG_TIMING(printf("VTT=%x->%x, Tolerance %x\n", pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u16Vtotal, sXC_Sync_Status.u16Vtotal, (MS_U16)MD_VTOTAL_TORLANCE));
6034 bResult = TRUE;
6035 }
6036 else
6037 {
6038 //printf("Vtt %x\n", sXC_Sync_Status.u16Vtotal);
6039 }
6040
6041 // VSync
6042 if ( bPollingOnly != TRUE )
6043 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u16Vtotal = sXC_Sync_Status.u16Vtotal;
6044 // FrameRate
6045 if ( bPollingOnly != TRUE )
6046 {
6047 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u32FrameRatex1K = MDrv_XC_PCMonitor_Get_FrameRatex1K(pInstance, eWindow);
6048 }
6049 if( (IsSrcTypeHDMI(pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].eCurrentSrc) || IsSrcTypeDVI(pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].eCurrentSrc))
6050 &&(MDrv_XC_GetHdmiSyncMode(pInstance) == HDMI_SYNC_DE) )
6051 {
6052 MS_WINDOW_TYPE sWin;
6053 memset(&sWin, 0, sizeof(MS_WINDOW_TYPE));
6054
6055 MDrv_XC_GetDEWindow(pInstance, &sWin, eWindow);
6056
6057 if (abs( sWin.width - pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.width) > MD_HDE_TORLANCE)
6058 {
6059 PCMSG_TIMING(printf("HDE %x->%x, Tolerance=%x\n", pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.width, sWin.width, (MS_U16)MD_HDE_TORLANCE));
6060 bResult = TRUE;
6061 }
6062
6063 if (abs(sWin.height - pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.height) > MD_VDE_TORLANCE)
6064 {
6065 PCMSG_TIMING(printf("VDE %x->%x, Tolerance=%x\n", pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info.height, sWin.height, (MS_U16)MD_VDE_TORLANCE));
6066 bResult = TRUE;
6067 }
6068
6069 if ( bPollingOnly != TRUE )
6070 memcpy(&(pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].sDVI_HDMI_DE_Info), &sWin, sizeof(MS_WINDOW_TYPE));
6071
6072
6073 #if(!SUPPORT_HDMI20)
6074 //if chip doesn't support HDMI YUV420, regard yuv420 as invalid timing
6075 if(pXCResourcePrivate->stHdmiExtendPacketReceive.bPKT_AVI_RECEIVE)
6076 {
6077 if((!MDrv_HDMI_CheckHDMI20_Setting_U2(pInstance, pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].eCurrentSrc))
6078 &&((MDrv_HDMI_avi_infoframe_info(_BYTE_1)& 0x60)==0x60))
6079 {
6080 bResult = TRUE;
6081 }
6082 }
6083 #endif
6084
6085 }
6086 }
6087
6088 if(bPollingOnly != TRUE )
6089 {
6090 pXCResourcePrivate->stdrvXC_IP.sPCMONITOR_status[eWindow].u8SyncStatus = sXC_Sync_Status.u8SyncStatus;
6091 }
6092
6093 return bResult; // stable sync
6094 }
MDrv_XC_Set_FD_Mask_ByWin(void * pInstance,MS_BOOL bEnable,SCALER_WIN eWindow)6095
6096 void MDrv_XC_Set_FD_Mask_ByWin(void *pInstance, MS_BOOL bEnable,SCALER_WIN eWindow)
6097 {
6098 HAL_SC_ip_Set_FD_Mask_ByWin(pInstance, bEnable, eWindow);
6099 #if (HW_DESIGN_4K2K_VER == 4)
6100 // for FD_mask can control FRCM write
6101 Hal_SC_set_frcm_to_FD_mask(pInstance, bEnable, eWindow);
6102 #endif
6103 }
6104
6105 #undef _MDRV_SC_IP_C_
6106
6107