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 // [mdrv_sc_dynamicscaling.c]
96 // Date: 2012/10/29
97 // Descriptions: dynamic scaling related functions
98 //==============================================================================
99 #ifndef _MDRV_SC_DYNAMICSCALING_C_
100 #define _MDRV_SC_DYNAMICSCALING_C_
101
102 // Common Definition
103 #include "MsCommon.h"
104 #include "MsOS.h"
105 #include "mhal_xc_chip_config.h"
106 #include "utopia.h"
107 #include "utopia_dapi.h"
108 #ifdef MSOS_TYPE_LINUX_KERNEL
109 #include <linux/string.h>
110 #else
111 #include <string.h>
112 #endif
113 #if (SUPPORT_KERNEL_DS == 1)
114 #include "mdrv_xc_st.h"
115 #include "mdrv_xc_io.h"
116 #ifndef MSOS_TYPE_LINUX_KERNEL
117 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
118 #include <sys/ioctl.h>
119 #include <sys/types.h>
120 #include <sys/stat.h>
121 #include <fcntl.h>
122 #include <unistd.h>
123 #endif
124 #endif
125 #endif
126
127 //#include "Debug.h"
128 #include "drvXC_IOPort.h"
129 #include "MsTypes.h"
130 #include "apiXC.h"
131 #include "apiXC_Adc.h"
132 #include "apiXC_Auto.h"
133 #include "drv_sc_display.h"
134 #include "drv_sc_isr.h"
135 #include "apiXC_PCMonitor.h"
136 #include "apiXC_ModeParse.h"
137 #include "drvXC_HDMI_if.h"
138 #include "mvideo_context.h"
139 #include "drv_sc_ip.h"
140 #if (LD_ENABLE==1)
141 #include "mdrv_ld.h"
142 #include "mdrv_ldalgo.h"
143 #endif
144 #include "mdrv_sc_3d.h"
145 #include "drv_sc_menuload.h"
146 #include "drvXC_ADC_Internal.h"
147 #include "mhal_dynamicscaling.h"
148 #include "mhal_sc.h"
149 #if FRC_INSIDE
150 #include "mdrv_frc.h"
151 #include "mhal_frc.h"
152 #endif
153 #include "XC_private.h"
154 #include "apiXC_v2.h"
155 #include "xc_hwreg_utility2.h"
156 #include "mdrv_sc_dynamicscaling.h"
157
158 #if (SUPPORT_KERNEL_DS == 1)
159 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
160 static MS_S32 _s32FdScaler = -1;
161 #endif
162 #ifdef MSOS_TYPE_LINUX_KERNEL
163 extern E_K_APIXC_ReturnValue KApi_XC_Get_DSForceIndexSupported(EN_KDRV_SC_DEVICE u32DeviceID, EN_KDRV_WINDOW eWindow);
164 extern E_K_APIXC_ReturnValue KApi_XC_Set_DSIndexSourceSelect(EN_KDRV_SC_DEVICE u32DeviceID, E_K_XC_DS_INDEX_SOURCE eDSIdxSrc, EN_KDRV_WINDOW eWindow);
165 extern MS_BOOL KApi_XC_SetDynamicScaling(EN_KDRV_SC_DEVICE u32DeviceID, K_XC_DynamicScaling_Info *pstDSInfo,MS_U32 u32DSInfoLen, EN_KDRV_WINDOW eWindow);
166 extern void KApi_XC_Set_DynamicScalingFlag(EN_KDRV_SC_DEVICE u32DeviceID,MS_BOOL bEnable);
167 extern MS_BOOL KDrv_XC_GetDynamicScalingStatus(EN_KDRV_SC_DEVICE u32DeviceID);
168 extern MS_BOOL KDrv_XC_EnableIPMTuneAfterDS(EN_KDRV_SC_DEVICE u32DeviceID, MS_BOOL bEnable);
169 extern MS_BOOL KApi_XC_GetDynamicScalingIndex(EN_KDRV_SC_DEVICE u32DeviceID, EN_KDRV_WINDOW eWindow, MS_U8* pu8DSIndex);
170 extern MS_BOOL KApi_XC_FireDynamicScalingIndex(EN_KDRV_SC_DEVICE u32DeviceID, EN_KDRV_WINDOW eWindow);
171 extern MS_BOOL MDrv_XC_SetDSHDRInfo(ST_KDRV_XC_DS_HDRInfo *pstDSHDRInfo);
172 #endif
173 #endif
MDrv_XC_Get_DSForceIndexSupported(void * pInstance,SCALER_WIN eWindow)174 E_APIXC_ReturnValue MDrv_XC_Get_DSForceIndexSupported(void *pInstance, SCALER_WIN eWindow)
175 {
176 MS_BOOL bReturn = FALSE;
177 bReturn = MHal_XC_Get_DSForceIndexSupported(pInstance, eWindow);
178 return bReturn?E_APIXC_RET_OK:E_APIXC_RET_FAIL;
179 }
180
MDrv_XC_Set_DSIndexSourceSelect(void * pInstance,E_XC_DS_INDEX_SOURCE eDSIdxSrc,SCALER_WIN eWindow)181 E_APIXC_ReturnValue MDrv_XC_Set_DSIndexSourceSelect(void *pInstance, E_XC_DS_INDEX_SOURCE eDSIdxSrc, SCALER_WIN eWindow)
182 {
183 MHal_XC_Set_DSIndexSourceSelect(pInstance, eDSIdxSrc, eWindow);
184 return E_APIXC_RET_OK;
185 }
186
MDrv_XC_Set_DSForceIndex(void * pInstance,MS_BOOL bEnable,MS_U8 u8Index,SCALER_WIN eWindow)187 E_APIXC_ReturnValue MDrv_XC_Set_DSForceIndex(void *pInstance, MS_BOOL bEnable, MS_U8 u8Index, SCALER_WIN eWindow)
188 {
189 MHal_XC_Set_DSForceIndex(pInstance, bEnable, u8Index, eWindow);
190 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
191 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
192 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
193 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
194 pXCResourcePrivate->stdrvXC_Dynamicscaling._bDSForceIndexEnable[eWindow] = bEnable;
195
196 return E_APIXC_RET_OK;
197 }
198
MDrv_XC_Is_DSForceIndexEnabled(void * pInstance,SCALER_WIN eWindow)199 MS_BOOL MDrv_XC_Is_DSForceIndexEnabled(void *pInstance, SCALER_WIN eWindow)
200 {
201 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
202 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
203 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
204 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
205 return pXCResourcePrivate->stdrvXC_Dynamicscaling._bDSForceIndexEnable[eWindow];
206 }
207
MApi_XC_Get_DSForceIndexSupported_U2(void * pInstance,SCALER_WIN eWindow)208 E_APIXC_ReturnValue MApi_XC_Get_DSForceIndexSupported_U2(void* pInstance, SCALER_WIN eWindow)
209 {
210 #if (SUPPORT_KERNEL_DS == 1)
211 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
212 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
213 #ifdef MSOS_TYPE_LINUX_KERNEL
214 EN_KDRV_SC_DEVICE u32DeviceID;
215 if(psXCInstPri->u32DeviceID == 0)
216 {
217 u32DeviceID = E_KDRV_XC_SC0;
218 }
219 else
220 {
221 u32DeviceID = E_KDRV_XC_SC1;
222 }
223 return KApi_XC_Get_DSForceIndexSupported(u32DeviceID, eWindow);
224 #else
225 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
226 if(0 > _s32FdScaler)
227 {
228 _s32FdScaler = open("/dev/scaler", O_WRONLY | O_NDELAY);
229 }
230
231 if (0 > _s32FdScaler)
232 {
233 printf("\nUnable to open /dev/scaler\n");
234 return E_APIXC_RET_FAIL;
235 }
236 else
237 {
238 ST_KDRV_DS_GET_DSForceIndexSupported k_ds_get_ForceIndexSupported;
239 if(psXCInstPri->u32DeviceID == 0)
240 k_ds_get_ForceIndexSupported.u32DeviceID = E_KDRV_XC_SC0;
241 else
242 k_ds_get_ForceIndexSupported.u32DeviceID = E_KDRV_XC_SC1;
243 k_ds_get_ForceIndexSupported.eWindow = eWindow;
244 k_ds_get_ForceIndexSupported.eReturn = E_APIXC_RET_FAIL;
245 if (-1 == ioctl(_s32FdScaler, MDRV_XC_IOC_DS_GET_DSFORCE_INDEX_SUPPORT,&k_ds_get_ForceIndexSupported))
246 {
247 perror("ioctl");
248 return E_APIXC_RET_FAIL;
249 }
250
251 return k_ds_get_ForceIndexSupported.eReturn;
252 }
253 #else
254 return E_APIXC_RET_FAIL;
255 #endif
256 #endif
257 #else
258 return MDrv_XC_Get_DSForceIndexSupported(pInstance, eWindow);
259 #endif
260 }
261
MApi_XC_Get_DSForceIndexSupported(SCALER_WIN eWindow)262 E_APIXC_ReturnValue MApi_XC_Get_DSForceIndexSupported(SCALER_WIN eWindow)
263 {
264 if (pu32XCInst == NULL)
265 {
266 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
267 return E_APIXC_RET_FAIL;
268 }
269
270 stXC_GET_DS_FORCE_INDEX_SUPPORTED XCArgs;
271 XCArgs.eWindow = eWindow;
272 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
273
274 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_DS_FORCE_INDEX_SUPPORTED, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
275 {
276 printf("Obtain XC engine fail\n");
277 return E_APIXC_RET_FAIL;
278 }
279 else
280 {
281 return XCArgs.eReturnValue;
282 }
283 }
284
MApi_XC_Set_DSIndexSourceSelect_U2(void * pInstance,E_XC_DS_INDEX_SOURCE eDSIdxSrc,SCALER_WIN eWindow)285 E_APIXC_ReturnValue MApi_XC_Set_DSIndexSourceSelect_U2(void* pInstance, E_XC_DS_INDEX_SOURCE eDSIdxSrc, SCALER_WIN eWindow)
286 {
287 #if (SUPPORT_KERNEL_DS == 1)
288 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
289 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
290 #ifdef MSOS_TYPE_LINUX_KERNEL
291 EN_KDRV_SC_DEVICE u32DeviceID;
292 if(psXCInstPri->u32DeviceID == 0)
293 {
294 u32DeviceID = E_KDRV_XC_SC0;
295 }
296 else
297 {
298 u32DeviceID = E_KDRV_XC_SC1;
299 }
300 return KApi_XC_Set_DSIndexSourceSelect(u32DeviceID,eDSIdxSrc,eWindow);
301 #else
302 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
303 if(0 > _s32FdScaler)
304 {
305 _s32FdScaler = open("/dev/scaler", O_WRONLY | O_NDELAY);
306 }
307
308 if (0 > _s32FdScaler)
309 {
310 printf("\nUnable to open /dev/scaler\n");
311 return E_APIXC_RET_FAIL;
312 }
313 else
314 {
315 ST_KDRV_DS_SET_DSIndexSourceSelect k_ds_set_IndexSourceSelect;
316 if(psXCInstPri->u32DeviceID == 0)
317 k_ds_set_IndexSourceSelect.u32DeviceID = E_KDRV_XC_SC0;
318 else
319 k_ds_set_IndexSourceSelect.u32DeviceID = E_KDRV_XC_SC1;
320 k_ds_set_IndexSourceSelect.eDSIdxSrc = eDSIdxSrc;
321 k_ds_set_IndexSourceSelect.eWindow = eWindow;
322 k_ds_set_IndexSourceSelect.eReturn = E_APIXC_RET_FAIL;
323 if (-1 == ioctl(_s32FdScaler, MDRV_XC_IOC_DS_SET_DSINDEX_SOURCE_SELECT,&k_ds_set_IndexSourceSelect))
324 {
325 perror("ioctl");
326 return E_APIXC_RET_FAIL;
327 }
328
329 return k_ds_set_IndexSourceSelect.eReturn;
330 }
331 #else
332 return E_APIXC_RET_FAIL;
333 #endif
334 #endif
335 #else
336 E_APIXC_ReturnValue eReturn = E_APIXC_RET_FAIL;
337 _XC_ENTRY(pInstance);
338 eReturn = MDrv_XC_Set_DSIndexSourceSelect(pInstance, eDSIdxSrc, eWindow);
339 _XC_RETURN(pInstance);
340 return eReturn;
341 #endif
342 }
343
MApi_XC_Set_DSIndexSourceSelect(E_XC_DS_INDEX_SOURCE eDSIdxSrc,SCALER_WIN eWindow)344 E_APIXC_ReturnValue MApi_XC_Set_DSIndexSourceSelect(E_XC_DS_INDEX_SOURCE eDSIdxSrc, SCALER_WIN eWindow)
345 {
346 if (pu32XCInst == NULL)
347 {
348 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
349 return E_APIXC_RET_FAIL;
350 }
351
352 stXC_SET_DS_INDEX_SOURCE_SELECT XCArgs;
353 XCArgs.eDSIdxSrc = eDSIdxSrc;
354 XCArgs.eWindow = eWindow;
355 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
356
357 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_DS_INDEX_SOURCE_SELECT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
358 {
359 printf("Obtain XC engine fail\n");
360 return E_APIXC_RET_FAIL;
361 }
362 else
363 {
364 return XCArgs.eReturnValue;
365 }
366 }
367
MApi_XC_Set_DSForceIndex_U2(void * pInstance,MS_BOOL bEnable,MS_U8 u8Index,SCALER_WIN eWindow)368 E_APIXC_ReturnValue MApi_XC_Set_DSForceIndex_U2(void* pInstance, MS_BOOL bEnable, MS_U8 u8Index, SCALER_WIN eWindow)
369 {
370 E_APIXC_ReturnValue eReturn = E_APIXC_RET_FAIL;
371 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
372 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
373 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
374 _XC_ENTRY(pInstance);
375 eReturn = MDrv_XC_Set_DSForceIndex(pInstance, bEnable, u8Index, eWindow);
376 _XC_RETURN(pInstance);
377 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
378 return eReturn;
379 }
380
MApi_XC_Set_DSForceIndex(MS_BOOL bEnable,MS_U8 u8Index,SCALER_WIN eWindow)381 E_APIXC_ReturnValue MApi_XC_Set_DSForceIndex(MS_BOOL bEnable, MS_U8 u8Index, SCALER_WIN eWindow)
382 {
383 if (pu32XCInst == NULL)
384 {
385 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
386 return E_APIXC_RET_FAIL;
387 }
388
389 stXC_SET_DS_FORCE_INDEX XCArgs;
390 XCArgs.bEnable = bEnable;
391 XCArgs.u8Index = u8Index;
392 XCArgs.eWindow = eWindow;
393 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
394
395 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_DS_FORCE_INDEX, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
396 {
397 printf("Obtain XC engine fail\n");
398 return E_APIXC_RET_FAIL;
399 }
400 else
401 {
402 return XCArgs.eReturnValue;
403 }
404 }
405
406 //-------------------------------------------------------------------------------------------------
407 /// Get Dynamic Scaling Status
408 /// @return @ref MS_BOOL TRUE: dynamic scaling is enabled; FALSE: dynamic scaling is not enabled.
409 //-------------------------------------------------------------------------------------------------
MApi_XC_GetDynamicScalingStatus_U2(void * pInstance)410 MS_BOOL MApi_XC_GetDynamicScalingStatus_U2(void* pInstance)
411 {
412 MS_BOOL bReturn = FALSE;
413 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
414 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
415 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
416 bReturn = (MDrv_XC_Is_DSForceIndexEnabled(pInstance,MAIN_WINDOW)| MDrv_XC_GetDynamicScalingStatus(pInstance));
417 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
418 return bReturn;
419 }
420
MApi_XC_GetDynamicScalingStatus(void)421 MS_BOOL MApi_XC_GetDynamicScalingStatus(void)
422 {
423 if (pu32XCInst == NULL)
424 {
425 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
426 return FALSE;
427 }
428
429 stXC_GET_DS_STATUS XCArgs;
430 XCArgs.bReturnValue = FALSE;
431
432 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_DS_STATUS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
433 {
434 printf("Obtain XC engine fail\n");
435 return FALSE;
436 }
437 else
438 {
439 return XCArgs.bReturnValue;
440 }
441 }
442
MDrv_XC_GetDynamicScalingStatus(void * pInstance)443 MS_BOOL MDrv_XC_GetDynamicScalingStatus(void *pInstance)
444 {
445 #if (SUPPORT_KERNEL_DS == 1)
446 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
447 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
448 #ifdef MSOS_TYPE_LINUX_KERNEL
449 EN_KDRV_SC_DEVICE u32DeviceID;
450 if(psXCInstPri->u32DeviceID == 0)
451 {
452 u32DeviceID = E_KDRV_XC_SC0;
453 }
454 else
455 {
456 u32DeviceID = E_KDRV_XC_SC1;
457 }
458 return KDrv_XC_GetDynamicScalingStatus(u32DeviceID);
459 #else
460 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
461 if(0 > _s32FdScaler)
462 {
463 _s32FdScaler = open("/dev/scaler", O_WRONLY | O_NDELAY);
464 }
465
466 if (0 > _s32FdScaler)
467 {
468 printf("\nUnable to open /dev/scaler\n");
469 return FALSE;
470 }
471 else
472 {
473 ST_KDRV_DS_GetDynamicScalingStatus k_ds_get_DynamicScalingStatus;
474 if(psXCInstPri->u32DeviceID == 0)
475 k_ds_get_DynamicScalingStatus.u32DeviceID = E_KDRV_XC_SC0;
476 else
477 k_ds_get_DynamicScalingStatus.u32DeviceID = E_KDRV_XC_SC1;
478 k_ds_get_DynamicScalingStatus.bReturn = FALSE;
479 if (-1 == ioctl(_s32FdScaler, MDRV_XC_IOC_DS_GET_DS_STATUS,&k_ds_get_DynamicScalingStatus))
480 {
481 perror("ioctl");
482 return FALSE;
483 }
484
485 return k_ds_get_DynamicScalingStatus.bReturn;
486 }
487 #else
488 return FALSE;
489 #endif
490 #endif
491 #else
492 return MHAL_SC_Get_DynamicScaling_Status(pInstance);
493 #endif
494 }
495
MDrv_XC_EnableIPMTuneAfterDS(void * pInstance,MS_BOOL bEnable)496 MS_BOOL MDrv_XC_EnableIPMTuneAfterDS(void *pInstance, MS_BOOL bEnable)
497 {
498 #if (SUPPORT_KERNEL_DS == 1)
499 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
500 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
501 #ifdef MSOS_TYPE_LINUX_KERNEL
502 EN_KDRV_SC_DEVICE u32DeviceID;
503 if(psXCInstPri->u32DeviceID == 0)
504 {
505 u32DeviceID = E_KDRV_XC_SC0;
506 }
507 else
508 {
509 u32DeviceID = E_KDRV_XC_SC1;
510 }
511 return KDrv_XC_EnableIPMTuneAfterDS(u32DeviceID,bEnable);
512 #else
513 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
514 if(0 > _s32FdScaler)
515 {
516 _s32FdScaler = open("/dev/scaler", O_WRONLY | O_NDELAY);
517 }
518
519 if (0 > _s32FdScaler)
520 {
521 printf("\nUnable to open /dev/scaler\n");
522 return FALSE;
523 }
524 else
525 {
526 ST_KDRV_DS_EnableIPMTuneAfterDS k_ds_EnableIPMTuneAfterDS;
527 if(psXCInstPri->u32DeviceID == 0)
528 k_ds_EnableIPMTuneAfterDS.u32DeviceID = E_KDRV_XC_SC0;
529 else
530 k_ds_EnableIPMTuneAfterDS.u32DeviceID = E_KDRV_XC_SC1;
531 k_ds_EnableIPMTuneAfterDS.bEnable = bEnable;
532 k_ds_EnableIPMTuneAfterDS.bReturn = FALSE;
533 if (-1 == ioctl(_s32FdScaler, MDRV_XC_IOC_DS_ENABLE_IPM_TUNE_AFTER_DS,&k_ds_EnableIPMTuneAfterDS))
534 {
535 perror("ioctl");
536 return FALSE;
537 }
538
539 return k_ds_EnableIPMTuneAfterDS.bReturn;
540 }
541 #else
542 return FALSE;
543 #endif
544 #endif
545 #else
546 return MHAL_SC_Enable_IPMTuneAfterDS(pInstance, bEnable);
547 #endif
548 }
549
550
551 //-------------------------------------------------------------------------------------------------
552 /// Set Dynamic Scaling
553 /// @param pstDSInfo \b IN: the information of Dynamic Scaling
554 /// @param u32DSInforLen \b IN: the length of the pstDSInfo
555 /// @param eWindow \b IN: which window we are going to set
556 /// @return @ref MS_BOOL
557 //-------------------------------------------------------------------------------------------------
MApi_XC_SetDynamicScaling_U2(void * pInstance,XC_DynamicScaling_Info * pstDSInfo,MS_U32 u32DSInfoLen,SCALER_WIN eWindow)558 MS_BOOL MApi_XC_SetDynamicScaling_U2(void* pInstance, XC_DynamicScaling_Info *pstDSInfo,MS_U32 u32DSInfoLen, SCALER_WIN eWindow)
559 {
560 #if (SUPPORT_KERNEL_DS == 1)
561 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
562 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
563
564 K_XC_DynamicScaling_Info stKDrvDsInfo;
565 memset(&stKDrvDsInfo, 0, sizeof(K_XC_DynamicScaling_Info));
566
567 stKDrvDsInfo.u64DS_Info_BaseAddr = pstDSInfo->u32DS_Info_BaseAddr;
568 stKDrvDsInfo.u8MIU_Select = pstDSInfo->u8MIU_Select;
569 stKDrvDsInfo.u8DS_Index_Depth = pstDSInfo->u8DS_Index_Depth;
570 stKDrvDsInfo.bOP_DS_On = pstDSInfo->bOP_DS_On;
571 stKDrvDsInfo.bIPS_DS_On = pstDSInfo->bIPS_DS_On;
572 stKDrvDsInfo.bIPM_DS_On = pstDSInfo->bIPM_DS_On;
573
574 #ifdef MSOS_TYPE_LINUX_KERNEL
575 //**************update enable in shm*********************//
576 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
577 _XC_ENTRY(pInstance);
578
579 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
580 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
581 MS_U16 u16OnOff = 0;
582 u16OnOff = SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK1F_10_L) & 0x1000;
583
584 u16OnOff |= ((pstDSInfo->bOP_DS_On << 9) | (pstDSInfo->bIPS_DS_On << 10) | (pstDSInfo->bIPM_DS_On << 11));
585 if(u16OnOff & 0x0E00)
586 pXCResourcePrivate->sthal_SC.bDynamicScalingEnable = TRUE;
587 else
588 pXCResourcePrivate->sthal_SC.bDynamicScalingEnable = FALSE;
589
590 _XC_RETURN(pInstance);
591 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
592 //********************************************************
593 EN_KDRV_SC_DEVICE u32DeviceID;
594 if(psXCInstPri->u32DeviceID == 0)
595 u32DeviceID = E_KDRV_XC_SC0;
596 else
597 u32DeviceID = E_KDRV_XC_SC1;
598 return KApi_XC_SetDynamicScaling(u32DeviceID, (K_XC_DynamicScaling_Info*)&stKDrvDsInfo,u32DSInfoLen,eWindow);
599 #else
600 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
601 if(0 > _s32FdScaler)
602 {
603 _s32FdScaler = open("/dev/scaler", O_RDWR);
604 }
605
606 if (0 > _s32FdScaler)
607 {
608 printf("\nUnable to open /dev/scaler\n");
609 return FALSE;
610 }
611 else
612 {
613 ST_KDRV_DS_SetDynamicScaling k_ds_set_DynamicScaling;
614 if(psXCInstPri->u32DeviceID == 0)
615 k_ds_set_DynamicScaling.u32DeviceID = E_KDRV_XC_SC0;
616 else
617 k_ds_set_DynamicScaling.u32DeviceID = E_KDRV_XC_SC1;
618 k_ds_set_DynamicScaling.pstDSInfo = (K_XC_DynamicScaling_Info*)&stKDrvDsInfo;
619 k_ds_set_DynamicScaling.u32DSInfoLen = u32DSInfoLen;
620 k_ds_set_DynamicScaling.eWindow = eWindow;
621 k_ds_set_DynamicScaling.bReturn = FALSE;
622
623 if (-1 == ioctl(_s32FdScaler, MDRV_XC_IOC_DS_SET_DYNAMICSCALING, &k_ds_set_DynamicScaling))
624 {
625 perror("ioctl");
626 return FALSE;
627 }
628
629 //**************update enable in shm*********************//
630 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
631 _XC_ENTRY(pInstance);
632
633 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
634 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
635 MS_U16 u16OnOff = 0;
636 u16OnOff = SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK1F_10_L) & 0x1000;
637
638 u16OnOff |= ((pstDSInfo->bOP_DS_On << 9) | (pstDSInfo->bIPS_DS_On << 10) | (pstDSInfo->bIPM_DS_On << 11));
639 if(u16OnOff & 0x0E00)
640 pXCResourcePrivate->sthal_SC.bDynamicScalingEnable = TRUE;
641 else
642 pXCResourcePrivate->sthal_SC.bDynamicScalingEnable = FALSE;
643
644 _XC_RETURN(pInstance);
645 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
646 //********************************************************
647 return k_ds_set_DynamicScaling.bReturn;
648 }
649 #else
650 return FALSE;
651 #endif
652 #endif
653 #else
654 MS_BOOL bStatus;
655 XC_LOG_TRACE(XC_DBGLEVEL_FUNCTION_TRACE, "Entry\n");
656 if(u32DSInfoLen != sizeof(XC_DynamicScaling_Info))
657 {
658 XC_LOG_TRACE(XC_DBGLEVEL_FUNCTION_TRACE, "Exit\n");
659 return FALSE;
660 }
661 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
662 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
663 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
664 _XC_ENTRY(pInstance);
665 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"It's dynamic scaling case(%u,%u,%u)\n",
666 pstDSInfo->bOP_DS_On,pstDSInfo->bIPS_DS_On,pstDSInfo->bIPM_DS_On);
667
668 #if defined (__aarch64__)
669 XC_LOG_TRACE(XC_DBGLEVEL_SEAMLESSZAP, "[%s][%06d]SLZ[%s] use DS memory base addr = %lx, MIU_sel =%x, Depth=%u\n",
670 __FUNCTION__, __LINE__, eWindow?"SUB":"MAIN", pstDSInfo->u32DS_Info_BaseAddr, pstDSInfo->u8MIU_Select, pstDSInfo->u8DS_Index_Depth);
671 #else
672 XC_LOG_TRACE(XC_DBGLEVEL_SEAMLESSZAP, "[%s][%06d]SLZ[%s] use DS memory base addr = %tx, MIU_sel =%x, Depth=%u\n",
673 __FUNCTION__, __LINE__, eWindow?"SUB":"MAIN", (ptrdiff_t)pstDSInfo->u32DS_Info_BaseAddr, pstDSInfo->u8MIU_Select, pstDSInfo->u8DS_Index_Depth);
674 #endif
675
676 bStatus = MDrv_XC_Set_DynamicScaling(
677 pInstance,
678 pstDSInfo->u32DS_Info_BaseAddr,
679 pstDSInfo->u8MIU_Select,
680 pstDSInfo->u8DS_Index_Depth,
681 pstDSInfo->bOP_DS_On,
682 pstDSInfo->bIPS_DS_On,
683 pstDSInfo->bIPM_DS_On,
684 eWindow);
685 _XC_RETURN(pInstance);
686 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
687 XC_LOG_TRACE(XC_DBGLEVEL_FUNCTION_TRACE, "Exit\n");
688 return bStatus;
689 #endif
690 }
691
MApi_XC_SetDynamicScaling(XC_DynamicScaling_Info * pstDSInfo,MS_U32 u32DSInfoLen,SCALER_WIN eWindow)692 MS_BOOL MApi_XC_SetDynamicScaling(XC_DynamicScaling_Info *pstDSInfo, MS_U32 u32DSInfoLen, SCALER_WIN eWindow)
693 {
694 if (pu32XCInst == NULL)
695 {
696 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
697 return FALSE;
698 }
699
700 stXC_SET_DYNAMIC_SCALING XCArgs;
701 XCArgs.pstDSInfo = pstDSInfo;
702 XCArgs.u32DSInfoLen = u32DSInfoLen;
703 XCArgs.eWindow = eWindow;
704 XCArgs.bReturnValue = FALSE;
705
706 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_DYNAMIC_SCALING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
707 {
708 printf("Obtain XC engine fail\n");
709 return FALSE;
710 }
711 else
712 {
713 return XCArgs.bReturnValue;
714 }
715 }
716
MDrv_XC_Set_DynamicScaling(void * pInstance,MS_PHY u32MemBaseAddr,MS_U8 u8MIU_Select,MS_U8 u8IdxDepth,MS_BOOL bOP_On,MS_BOOL bIPS_On,MS_BOOL bIPM_On,SCALER_WIN eWindow)717 MS_BOOL MDrv_XC_Set_DynamicScaling(void *pInstance,MS_PHY u32MemBaseAddr, MS_U8 u8MIU_Select, MS_U8 u8IdxDepth, MS_BOOL bOP_On, MS_BOOL bIPS_On, MS_BOOL bIPM_On,SCALER_WIN eWindow)
718 {
719 return MHAL_SC_Set_DynamicScaling(pInstance,u32MemBaseAddr, u8MIU_Select,u8IdxDepth, bOP_On, bIPS_On, bIPM_On,eWindow);
720 }
721
MApi_XC_Set_DynamicScalingFlag_U2(void * pInstance,MS_BOOL bEnable)722 void MApi_XC_Set_DynamicScalingFlag_U2(void *pInstance,MS_BOOL bEnable)
723 {
724 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
725 MHAL_SC_Set_DynamicScalingFlag(pInstance, bEnable);
726 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
727 #if (SUPPORT_KERNEL_DS == 1)
728 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
729 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
730 #ifdef MSOS_TYPE_LINUX_KERNEL
731 EN_KDRV_SC_DEVICE u32DeviceID;
732 if(psXCInstPri->u32DeviceID == 0)
733 {
734 u32DeviceID = E_KDRV_XC_SC0;
735 }
736 else
737 {
738 u32DeviceID = E_KDRV_XC_SC1;
739 }
740 KApi_XC_Set_DynamicScalingFlag(u32DeviceID,bEnable);
741 return;
742 #else
743 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
744 if(0 > _s32FdScaler)
745 {
746 _s32FdScaler = open("/dev/scaler", O_WRONLY | O_NDELAY);
747 }
748
749 if (0 > _s32FdScaler)
750 {
751 printf("\nUnable to open /dev/scaler\n");
752 return ;
753 }
754 else
755 {
756 ST_KDRV_DS_SET_DynamicScalingFlag k_ds_set_DynamicScalingFlag;
757 if(psXCInstPri->u32DeviceID == 0)
758 k_ds_set_DynamicScalingFlag.u32DeviceID = E_KDRV_XC_SC0;
759 else
760 k_ds_set_DynamicScalingFlag.u32DeviceID = E_KDRV_XC_SC1;
761 k_ds_set_DynamicScalingFlag.bEnable = bEnable;
762 if (-1 == ioctl(_s32FdScaler, MDRV_XC_IOC_DS_SET_DYNAMICSCALING_FLAG,&k_ds_set_DynamicScalingFlag))
763 {
764 perror("ioctl");
765 return ;
766 }
767
768 return ;
769 }
770 #endif
771 #endif
772 #endif
773 }
774
MApi_XC_Set_DynamicScalingFlag(MS_BOOL bEnable)775 void MApi_XC_Set_DynamicScalingFlag(MS_BOOL bEnable)
776 {
777 if (pu32XCInst == NULL)
778 {
779 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
780 return ;
781 }
782 stXC_SET_DYNAMIC_SCALING_FLAG XCArgs;
783 XCArgs.bEnable = bEnable;
784 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_DYNAMIC_SCALING_FLAG, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
785 {
786 printf("Obtain XC engine fail\n");
787 return ;
788 }
789 else
790 {
791 return ;
792 }
793 }
794
MDrv_XC_Is_SupportSWDS(void * pInstance)795 MS_BOOL MDrv_XC_Is_SupportSWDS(void *pInstance)
796 {
797 #if ((HW_DESIGN_4K2K_VER == 4)||(HW_DESIGN_4K2K_VER == 6))
798 #if 0
799 #if (defined (ANDROID))
800 return TRUE;
801 #else
802 return FALSE;
803 #endif
804 #else
805 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
806 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
807 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
808 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
809 // SC0 main would enable DS, may call by AN and SN
810 // SC1 always call by SN
811 if((psXCInstPri->u32DeviceID==0) && (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_IS_ANDROID))
812 return TRUE;
813 else
814 return FALSE;
815 #endif
816
817 #elif (HW_DESIGN_4K2K_VER == 7)
818 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
819 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
820 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
821 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
822 //only consider sc0 case
823 if((psXCInstPri->u32DeviceID==0))
824 {
825 if((pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_IS_ANDROID))
826 {
827 if (pXCResourcePrivate->sthal_SC.bDynamicScalingEnable == TRUE)
828 {
829 //AN call this functoin, force return TRUE
830 return TRUE;
831 }
832 else
833 {
834 return FALSE;
835 }
836 }
837 else
838 {
839 #ifdef UFO_XC_SET_DSINFO_V0
840 //If UFO SET_DSINFO_V0, support MCU DS, return by bUpdate_DS_CMD
841 //(bUpdate_DS_CMD means write DS command, do not sw_db)
842 return gSrcInfo[MAIN_WINDOW].Status2.bUpdate_DS_CMD;
843 #else
844 //If no support MCU DS, force return FALSE (raw case)
845 return FALSE;
846 #endif
847 }
848 }
849 else
850 {
851 return FALSE;
852 }
853
854 #else
855 return FALSE;
856 #endif
857 }
858
859 #if (SUPPORT_KERNEL_DS == 1)
MDrv_XC_GetSWDSIndex(void * pInstance,SCALER_WIN eWindow)860 MS_U8 MDrv_XC_GetSWDSIndex(void *pInstance, SCALER_WIN eWindow)
861 {
862 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
863 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
864
865 #ifdef MSOS_TYPE_LINUX_KERNEL
866 EN_KDRV_SC_DEVICE u32DeviceID;
867 if(psXCInstPri->u32DeviceID == 0)
868 {
869 u32DeviceID = E_KDRV_XC_SC0;
870 }
871 else
872 {
873 u32DeviceID = E_KDRV_XC_SC1;
874 }
875
876 MS_U8 u8DSIndex = 0;
877
878 KApi_XC_GetDynamicScalingIndex(u32DeviceID, eWindow, &u8DSIndex);
879
880 return u8DSIndex;
881 #else
882 ST_KDRV_DS_GET_INDEX_INFO stIndexInfo;
883 memset(&stIndexInfo, 0, sizeof(ST_KDRV_DS_GET_INDEX_INFO));
884 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
885 if(0 > _s32FdScaler)
886 {
887 _s32FdScaler = open("/dev/scaler", O_WRONLY | O_NDELAY);
888
889 if(0 > _s32FdScaler)
890 {
891 printf("Scaler device not opened!!!!\n");
892 return 0;
893 }
894 }
895
896 if (eWindow == MAIN_WINDOW)
897 stIndexInfo.eWindow = E_KDRV_MAIN_WINDOW;
898 else if (eWindow == SUB_WINDOW)
899 stIndexInfo.eWindow = E_KDRV_SUB_WINDOW;
900 else
901 stIndexInfo.eWindow = E_KDRV_MAX_WINDOW;
902
903 if (psXCInstPri->u32DeviceID == 0)
904 stIndexInfo.u32DeviceID = E_KDRV_XC_SC0;
905 else
906 stIndexInfo.u32DeviceID = E_KDRV_XC_SC1;
907
908 if (ioctl(_s32FdScaler, MDRV_XC_IOC_DS_GET_INDEX, &stIndexInfo))
909 {
910 printf("MDRV_XC_IOC_DS_GET_INDEX fail!!!!\n");
911 return 0;
912 }
913 #endif
914
915 return stIndexInfo.u8DSIndex;
916 #endif
917 }
918
MDrv_XC_FireSWDSIndex(void * pInstance,SCALER_WIN eWindow)919 MS_BOOL MDrv_XC_FireSWDSIndex(void *pInstance, SCALER_WIN eWindow)
920 {
921 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
922 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
923
924 #ifdef MSOS_TYPE_LINUX_KERNEL
925 EN_KDRV_SC_DEVICE u32DeviceID;
926 if(psXCInstPri->u32DeviceID == 0)
927 {
928 u32DeviceID = E_KDRV_XC_SC0;
929 }
930 else
931 {
932 u32DeviceID = E_KDRV_XC_SC1;
933 }
934
935 return KApi_XC_FireDynamicScalingIndex(u32DeviceID, eWindow);
936 #else
937 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
938 if(0 > _s32FdScaler)
939 {
940 _s32FdScaler = open("/dev/scaler", O_WRONLY | O_NDELAY);
941
942 if(0 > _s32FdScaler)
943 {
944 printf("Scaler device not opened!!!!\n");
945 return FALSE;
946 }
947 }
948
949 ST_KDRV_DS_FIRE_INDEX_INFO stFireIndexInfo;
950 memset(&stFireIndexInfo, 0, sizeof(ST_KDRV_DS_FIRE_INDEX_INFO));
951 if (eWindow == MAIN_WINDOW)
952 stFireIndexInfo.eWindow = E_KDRV_MAIN_WINDOW;
953 else if (eWindow == SUB_WINDOW)
954 stFireIndexInfo.eWindow = E_KDRV_SUB_WINDOW;
955 else
956 stFireIndexInfo.eWindow = E_KDRV_MAX_WINDOW;
957
958 if (psXCInstPri->u32DeviceID == 0)
959 stFireIndexInfo.u32DeviceID = E_KDRV_XC_SC0;
960 else
961 stFireIndexInfo.u32DeviceID = E_KDRV_XC_SC1;
962
963 if (ioctl(_s32FdScaler, MDRV_XC_IOC_DS_FIRE_INDEX, &stFireIndexInfo))
964 {
965 printf("MDRV_XC_IOC_DS_FIRE_INDEX fail!!!!\n");
966 return FALSE;
967 }
968 #endif
969 return TRUE;
970 #endif
971 }
972 #endif
973
MApi_XC_Is_SupportSWDS_U2(void * pInstance)974 MS_BOOL MApi_XC_Is_SupportSWDS_U2(void *pInstance)
975 {
976 MS_BOOL bReturn = FALSE;
977 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
978 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
979 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
980 #if (HW_DESIGN_4K2K_VER == 7)
981 bReturn = TRUE;
982 #else
983 bReturn = MDrv_XC_Is_SupportSWDS(pInstance);
984 #endif
985 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
986 return bReturn;
987 }
988
989 #ifdef MSOS_TYPE_LINUX_KERNEL
MApi_XC_Is_SupportSWDS(void)990 MS_BOOL MApi_XC_Is_SupportSWDS(void)
991 #else
992 __attribute__((weak)) MS_BOOL MApi_XC_Is_SupportSWDS(void)
993 #endif
994 {
995 if (pu32XCInst == NULL)
996 {
997 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
998 return 0;
999 }
1000 #if (defined (ANDROID))
1001 static XC_INITMISC tmp_Init_Misc;
1002 stXC_GET_MISC_STATUS XCArgs1;
1003 XCArgs1.pXC_Init_Misc = &tmp_Init_Misc;
1004 XCArgs1.eReturnValue = E_APIXC_RET_FAIL;
1005
1006 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_MISC_STATUS, (void*)&XCArgs1) != UTOPIA_STATUS_SUCCESS)
1007 {
1008 printf("Obtain XC engine fail\n");
1009 return E_APIXC_RET_FAIL;
1010 }
1011
1012 if(!(tmp_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_IS_ANDROID))
1013 {
1014 tmp_Init_Misc.u32MISC_A |= E_XC_INIT_MISC_A_IS_ANDROID;
1015
1016 stXC_INIT_MISC XCArgs2;
1017 XCArgs2.pXC_Init_Misc = &tmp_Init_Misc;
1018 XCArgs2.u32InitMiscDataLen = sizeof(XC_INITMISC);
1019 XCArgs2.eReturnValue = E_APIXC_RET_FAIL;
1020
1021 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_INIT_MISC, (void*)&XCArgs2) != UTOPIA_STATUS_SUCCESS)
1022 {
1023 printf("Obtain XC engine fail\n");
1024 return E_APIXC_RET_FAIL;
1025 }
1026 }
1027 #else
1028 static XC_INITMISC tmp_Init_Misc;
1029 stXC_GET_MISC_STATUS XCArgs1;
1030 XCArgs1.pXC_Init_Misc = &tmp_Init_Misc;
1031 XCArgs1.eReturnValue = E_APIXC_RET_FAIL;
1032
1033 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_MISC_STATUS, (void*)&XCArgs1) != UTOPIA_STATUS_SUCCESS)
1034 {
1035 printf("Obtain XC engine fail\n");
1036 return E_APIXC_RET_FAIL;
1037 }
1038
1039 if(tmp_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_IS_ANDROID)
1040 {
1041 tmp_Init_Misc.u32MISC_A |= E_XC_INIT_MISC_A_IS_ANDROID;
1042
1043 stXC_INIT_MISC XCArgs2;
1044 XCArgs2.pXC_Init_Misc = &tmp_Init_Misc;
1045 XCArgs2.u32InitMiscDataLen = sizeof(XC_INITMISC);
1046 XCArgs2.eReturnValue = E_APIXC_RET_FAIL;
1047
1048 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_INIT_MISC, (void*)&XCArgs2) != UTOPIA_STATUS_SUCCESS)
1049 {
1050 printf("Obtain XC engine fail\n");
1051 return E_APIXC_RET_FAIL;
1052 }
1053 }
1054 #endif
1055 stXC_GET_Is_SupportSWDS XCArgs;
1056 XCArgs.bEnable = 0;
1057
1058 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_IS_SupportSWDS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS) //E_XC_CMD_GET_SWDSIndex
1059 {
1060 printf("Obtain XC engine fail\n");
1061 return 0;
1062 }
1063 else
1064 {
1065 return XCArgs.bEnable;
1066 }
1067
1068 }
1069
1070 #ifdef UFO_XC_SET_DSINFO_V0
MApi_XC_SetDSInfo_U2(void * pInstance,XC_DS_INFO * pstSetDSInfo,MS_U32 u32DSInfoLen,SCALER_WIN eWindow)1071 void MApi_XC_SetDSInfo_U2(void *pInstance,XC_DS_INFO *pstSetDSInfo, MS_U32 u32DSInfoLen, SCALER_WIN eWindow)
1072 {
1073 XC_DS_INFO DrvDSInfo;
1074 MS_U16 u16CopiedLength = sizeof(XC_DS_INFO);
1075 if((NULL == pstSetDSInfo) || (pstSetDSInfo->u16ApiDSInfo_Length == 0))
1076 {
1077 //We cosider compatible operation form version2 , so reject the info init when version invalid
1078 XC_LOG_TRACE(XC_DBGLEVEL_SETTIMING, "MApi_XC_SetDSInfo: Null paramter or Wrong u16ApiDSInfo_Length!!\n");
1079
1080 XC_LOG_TRACE(XC_DBGLEVEL_FUNCTION_TRACE, "Exit\n");
1081 return ;
1082 }
1083 // the version control is coming in with version 1
1084 if(pstSetDSInfo->u32ApiDSInfo_Version < 1)
1085 {
1086 //We cosider compatible operation form version1 , so reject the info init when version invalid
1087 XC_LOG_TRACE(XC_DBGLEVEL_SETTIMING, "MApi_XC_SetDSInfo: please check your u32ApiDSInfo_Version, it should not set to 0!!\n");
1088 XC_LOG_TRACE(XC_DBGLEVEL_FUNCTION_TRACE, "Exit\n");
1089
1090 return ;
1091 }
1092
1093 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1094 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1095 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1096 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1097 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1098
1099 //new AP + old lib, only the length corresponding to old lib has meaning.
1100 if(pstSetDSInfo->u32ApiDSInfo_Version > API_DS_INFO_VERSION)
1101 {
1102 //We cosider compatible operation form version1 , so reject the info init when version invalid
1103 #if defined (__aarch64__)
1104 XC_LOG_TRACE(XC_DBGLEVEL_SETTIMING, "MApi_XC_SetDSInfo: this old version XC lib has only length:%lu driver status!!\n",
1105 sizeof(XC_DS_INFO))
1106 #else
1107 XC_LOG_TRACE(XC_DBGLEVEL_SETTIMING, "MApi_XC_SetDSInfo: this old version XC lib has only length:%u driver status!!\n",
1108 sizeof(XC_DS_INFO))
1109 #endif
1110 //we still copy the min size of both structure, but AP should take care of it.
1111 u16CopiedLength = sizeof(XC_DS_INFO);
1112 }
1113
1114 //old AP + new lib, driver shouldn't access to the space which doesn't exist in old structure
1115 if((pstSetDSInfo->u32ApiDSInfo_Version < API_DS_INFO_VERSION) || (pstSetDSInfo->u16ApiDSInfo_Length < sizeof(XC_DS_INFO)))
1116 {
1117 //We cosider compatible operation form version1 , so reject the info init when version invalid
1118 XC_LOG_TRACE(XC_DBGLEVEL_SETTIMING, "MApi_XC_GetStatusEx: new version XC lib shouldn't access to the space which doesn't exist in old structure!!\n")
1119 u16CopiedLength = pstSetDSInfo->u16ApiDSInfo_Length;
1120 }
1121
1122 pstSetDSInfo->u32ApiDSInfo_Version = API_DS_INFO_VERSION; //Return the actual version of the returned value for APP to use
1123 pstSetDSInfo->u16ApiDSInfo_Length = u16CopiedLength; //Return the actual length of the returned value for APP to know whick info is valid
1124
1125 memcpy(&DrvDSInfo, pstSetDSInfo, u16CopiedLength);
1126
1127 gSrcInfo[eWindow].Status2.u32MFCodecInfo = DrvDSInfo.u32MFCodecInfo;
1128 memcpy(&gSrcInfo[eWindow].Status2.stHDRInfo, &(DrvDSInfo.stHDRInfo), sizeof(XC_DS_HDRInfo));
1129 gSrcInfo[eWindow].Status2.bUpdate_DS_CMD = DrvDSInfo.bUpdate_DS_CMD[eWindow];
1130 gSrcInfo[eWindow].Status2.bEnableDNR = DrvDSInfo.bEnableDNR[eWindow];
1131 pXCResourcePrivate->sthal_SC.u32DynamicScalingBufSize = DrvDSInfo.u32DSBufferSize;
1132
1133 #if (SUPPORT_KERNEL_DS == 1)
1134 #if (defined UFO_XC_HDR) && (UFO_XC_HDR_VERSION == 2)
1135 #if (defined MSOS_TYPE_LINUX_KERNEL) || (defined ANDROID) || (HW_DESIGN_4K2K_VER == 7)
1136 if (pstSetDSInfo->u32ApiDSInfo_Version >= 2)
1137 {
1138 ST_KDRV_XC_DS_HDRInfo stKDrvDSHDRInfo;
1139 memset(&stKDrvDSHDRInfo, 0, sizeof(ST_KDRV_XC_DS_HDRInfo));
1140 stKDrvDSHDRInfo.u8CurrentIndex = DrvDSInfo.stHDRInfo.u8CurrentIndex;
1141 stKDrvDSHDRInfo.phyRegAddr = DrvDSInfo.stHDRInfo.phyRegAddr;
1142 stKDrvDSHDRInfo.u32RegSize = DrvDSInfo.stHDRInfo.u32RegSize;
1143 stKDrvDSHDRInfo.phyLutAddr = DrvDSInfo.stHDRInfo.phyLutAddr;
1144 stKDrvDSHDRInfo.u32LutSize = DrvDSInfo.stHDRInfo.u32LutSize;
1145 stKDrvDSHDRInfo.bDMEnable = DrvDSInfo.stHDRInfo.bDMEnable;
1146 stKDrvDSHDRInfo.bCompEnable = DrvDSInfo.stHDRInfo.bCompEnable;
1147
1148 #ifdef MSOS_TYPE_LINUX_KERNEL
1149 MDrv_XC_SetDSHDRInfo(&stKDrvDSHDRInfo);
1150 #else
1151 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
1152 if(0 > _s32FdScaler)
1153 {
1154 _s32FdScaler = open("/dev/scaler", O_RDWR);
1155
1156 if(0 > _s32FdScaler)
1157 {
1158 printf("Scaler device not opened!!!!\n");
1159 }
1160 }
1161
1162 if (ioctl(_s32FdScaler, MDRV_XC_IOC_SET_DSHDRINFO, &stKDrvDSHDRInfo))
1163 {
1164 printf("MDRV_XC_IOC_SET_DSHDRINFO fail!!!!\n");
1165 }
1166 #endif
1167 #endif
1168 }
1169 #endif
1170 #endif
1171 #endif
1172
1173 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1174 }
1175
1176 #ifdef MSOS_TYPE_LINUX_KERNEL
MApi_XC_SetDSInfo(XC_DS_INFO * pstSetDSInfo,MS_U32 u32DSInfoLen,SCALER_WIN eWindow)1177 void MApi_XC_SetDSInfo(XC_DS_INFO *pstSetDSInfo, MS_U32 u32DSInfoLen, SCALER_WIN eWindow)
1178 #else
1179 __attribute__((weak)) void MApi_XC_SetDSInfo(XC_DS_INFO *pstSetDSInfo, MS_U32 u32DSInfoLen, SCALER_WIN eWindow)
1180 #endif
1181 {
1182 if (pu32XCInst == NULL)
1183 {
1184 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1185 return ;
1186 }
1187
1188 stXC_SET_DSINFO XCArgs;
1189 XCArgs.pstSetDSInfo = pstSetDSInfo;
1190 XCArgs.u32DSInfoLen = u32DSInfoLen;
1191 XCArgs.eWindow = eWindow;
1192 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_DSINFO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1193 {
1194 printf("Obtain XC engine fail\n");
1195 return ;
1196 }
1197 else
1198 {
1199 return ;
1200 }
1201 }
1202 #endif
1203 #undef _MDRV_SC_DYNAMICSCALING_C_
1204 #endif //_MDRV_SC_DYNAMICSCALING_C_
1205