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 #ifndef _API_XC_DLC_C_
96 #define _API_XC_DLC_C_
97
98 /******************************************************************************/
99 /* Header Files */
100 /* ****************************************************************************/
101 // Common Definition
102 #ifdef MSOS_TYPE_LINUX_KERNEL
103 #include <linux/string.h>
104 #else
105 #include <string.h>
106 #endif
107
108 #include "MsCommon.h"
109 #include "MsVersion.h"
110 #include "drvDLC.h"
111 #include "drvDLC_Cus.h"
112 #include "drvDBC_Cus.h"
113 #include "apiXC_Dlc.h"
114 #include "apiXC_DBC.h"
115 // Internal Definition
116 #include "drvMMIO.h"
117
118 #include "utopia.h"
119 #include "apiXC_Dlc_v2.h"
120
121 /******************************************************************************/
122 /* Debug information */
123 /******************************************************************************/
124
125 #define XC_DCL_DBG 0
126
127 #if XC_DCL_DBG
128 #define XC_DLC_DBG_MSG(fmt,...) \
129 MS_DEBUG_MSG(do{printf( "[PNL_DBG_MSG]: %s: %d \n" fmt, __FUNCTION__, __LINE__, ## __VA_ARGS__);} while(0))
130
131 #define XC_DLC_PRINT_VAR(var) \
132 do{\
133 XC_DLC_DBG_MSG("%30s: %d\n", #var, (var));\
134 }while(0)
135
136 #define XC_DLC_PRINT_FUN(fun) \
137 do{\
138 XC_DLC_DBG_MSG("\n");\
139 XC_DLC_DBG_MSG("**************************************************\n");\
140 XC_DLC_DBG_MSG("*\t\t%s \t\t\n", #fun);\
141 XC_DLC_DBG_MSG("**************************************************\n");\
142 fun;\
143 XC_DLC_DBG_MSG("* *\n");\
144 XC_DLC_DBG_MSG("* *\n");\
145 XC_DLC_DBG_MSG("**************************************************\n");\
146 }while(0)
147
148 #else
149 #define XC_DLC_DBG_MSG(str, ...)
150 #define XC_DLC_PRINT_VAR(var)
151 #define XC_DLC_PRINT_FUN(fun) fun
152 #endif
153
154 #if defined (__aarch64__)
155 #define VERSION_COMPATIBLE_CHECK(pstInput,stValid,copy_Length,version_arg,length_arg,current_version) do { \
156 if(pstInput == NULL)\
157 return FALSE;\
158 /*new AP + old lib, only the length corresponding to old lib has meaning.*/\
159 if((pstInput)->version_arg > (current_version))\
160 {\
161 /*We consider compatible operation from this version, so reject the info init when version invalid*/\
162 printf("[%s: %d]: this old version XC lib has only length:%lu driver status!!\n",\
163 __FUNCTION__, __LINE__, sizeof(stValid));\
164 /*we still copy the min size of both structure, but AP should take care of it.*/\
165 (copy_Length) = sizeof(stValid);\
166 }\
167 \
168 /*old AP + new lib, driver shouldn't access to the space which doesn't exist in old structure*/\
169 if(((pstInput)->version_arg < (current_version)) || ((pstInput)->length_arg < sizeof(stValid)))\
170 {\
171 /*We consider compatible operation from this version, so reject the info init when version invalid*/\
172 printf("[%s: %d]: new version XC lib shouldn't access to the space which doesn't exist in old structure!!\n",\
173 __FUNCTION__, __LINE__);\
174 (copy_Length) = (pstInput)->length_arg;\
175 }\
176 }while(0)
177 #else
178 #define VERSION_COMPATIBLE_CHECK(pstInput,stValid,copy_Length,version_arg,length_arg,current_version) do { \
179 if(pstInput == NULL)\
180 return FALSE;\
181 /*new AP + old lib, only the length corresponding to old lib has meaning.*/\
182 if((pstInput)->version_arg > (current_version))\
183 {\
184 /*We consider compatible operation from this version, so reject the info init when version invalid*/\
185 printf("[%s: %d]: this old version XC lib has only length:%u driver status!!\n",\
186 __FUNCTION__, __LINE__, sizeof(stValid));\
187 /*we still copy the min size of both structure, but AP should take care of it.*/\
188 (copy_Length) = sizeof(stValid);\
189 }\
190 \
191 /*old AP + new lib, driver shouldn't access to the space which doesn't exist in old structure*/\
192 if(((pstInput)->version_arg < (current_version)) || ((pstInput)->length_arg < sizeof(stValid)))\
193 {\
194 /*We consider compatible operation from this version, so reject the info init when version invalid*/\
195 printf("[%s: %d]: new version XC lib shouldn't access to the space which doesn't exist in old structure!!\n",\
196 __FUNCTION__, __LINE__);\
197 (copy_Length) = (pstInput)->length_arg;\
198 }\
199 }while(0)
200 #endif
201
202 #define DLC_MUTEX
203 #define DLC_MUTEX_DBG 0
204
205 #ifdef DLC_MUTEX
206 #if(DLC_MUTEX_DBG)
207 #define Dlc_FuncEnter() \
208 printf("1,==========================\n"); \
209 printf("[%s][%s][%06d]\n",__FILE__,__FUNCTION__,__LINE__); \
210 if(!MsOS_ObtainMutex(_DLC_Mutex, MSOS_WAIT_FOREVER)) \
211 { \
212 printf("==========================\n"); \
213 printf("[%s][%s][%06d] Mutex taking timeout\n",__FILE__,__FUNCTION__,__LINE__); \
214 }
215 #define Dlc_FuncExit() \
216 printf("0,==========================\n"); \
217 printf("[%s][%s][%06d] \n",__FILE__,__FUNCTION__,__LINE__); \
218 MsOS_ReleaseMutex(_DLC_Mutex);
219 #else
220 #define Dlc_FuncEnter() \
221 if(!MsOS_ObtainMutex(_DLC_Mutex, MSOS_WAIT_FOREVER)) \
222 { \
223 }
224
225 #define Dlc_FuncExit() \
226 MsOS_ReleaseMutex(_DLC_Mutex);
227
228 #endif
229 #else
230 #define Dlc_FuncEnter() while(0)
231 #define Dlc_FuncExit() while(0)
232 #endif
233
234 static MSIF_Version _api_xc_dlc_version = {
235 .DDI = { XC_DLC_API_VERSION },
236 };
237
238
239
240 /******************************************************************************/
241 /* Local Function Prototypes */
242 /******************************************************************************/
243
244 /******************************************************************************/
245 /* Functions */
246 /******************************************************************************/
247
248 /******************************************************************************/
249 /* Constant */
250 /******************************************************************************/
251
252 #define DLC_DBG(x) // x
253
254 static const XC_DLC_ApiInfo _stXC_DLC_ApiInfo = {};
255 //static MS_U16 _u16XC_DLCDbgSwitch = 0;
256 static MS_BOOL g_bDBCEnable;
257
258 /******************************************************************************/
259 // Initialize DLC
260 /******************************************************************************/
261 MS_S32 _DLC_Mutex = -1;
262
263 static MS_BOOL g_bDLC_CGC_ready = FALSE;
264 static MS_BOOL g_bDLC_DBC_ready = FALSE;
265 static MS_BOOL g_bDLC_CGC_CGainPQCom;
266 static MS_BOOL g_bDLC_CGC_YGainPQCom;
267 static MS_U8 g_u8DLC_CGC_CGain;
268 static MS_U8 g_u8DLC_CGC_YGain;
269 static MS_U8 g_u8DLC_CGC_YGain_Backup;
270 static MS_U8 g_u8DLC_CGC_CGain_Backup;
271 static StuDbc_CAPTURE_Range g_DlcCapRange_Suspend = {0};
272
273 // for Utopia 2.0 to Utopia 1.0 compatibility.
274 void* pu32DLCInst = NULL;
275 void* pu32DBCInst = NULL;
276
277
MApi_XC_DLC_Init_Ex_U2(void * pInstance,XC_DLC_init * pstXC_DLC_InitData,MS_U32 u32InitDataLen)278 MS_BOOL MApi_XC_DLC_Init_Ex_U2(void * pInstance,XC_DLC_init * pstXC_DLC_InitData,MS_U32 u32InitDataLen)
279 {
280 MS_U8 i;
281 StuDlc_FinetuneParamaters DLC_MFinit;
282 MS_PHY u32NonPMBankSize = 0;
283 MS_VIRT ptrDLCRiuBaseAddr=0;
284 DLC_init_Ext DLC_InitExt;
285
286
287 // get MMIO base
288 if(MDrv_MMIO_GetBASE( &ptrDLCRiuBaseAddr, &u32NonPMBankSize, MS_MODULE_PM ) != TRUE)
289 {
290 //OS_DELETE_MUTEX(_s32ACEMutex);
291 //PNL_ASSERT(0, "%s\n", "Get base address failed\n");
292 //printf("XC_DLC GetBase failed\n");
293 return FALSE;
294 }
295 else
296 {
297 }
298 memset(&DLC_InitExt, 0 , sizeof(DLC_InitExt) );
299 MDrv_DLC_init_riu_base( ptrDLCRiuBaseAddr);
300
301 if(u32InitDataLen != sizeof(XC_DLC_init))
302 {
303 return FALSE;
304 }
305 memset(&DLC_MFinit, 0 , sizeof(DLC_MFinit) );
306
307 for (i=0; i<16; ++i)
308 {
309 DLC_InitExt.uwLumaCurve[i] = ((MS_U16)pstXC_DLC_InitData->DLC_MFinit_Ex.ucLumaCurve[i])<<2;
310 DLC_InitExt.uwLumaCurve2_a[i] = ((MS_U16)pstXC_DLC_InitData->DLC_MFinit_Ex.ucLumaCurve2_a[i])<<2;
311 DLC_InitExt.uwLumaCurve2_b[i] = ((MS_U16)pstXC_DLC_InitData->DLC_MFinit_Ex.ucLumaCurve2_b[i])<<2;
312
313 DLC_MFinit.ucLumaCurve[i] = pstXC_DLC_InitData->DLC_MFinit_Ex.ucLumaCurve[i];
314 DLC_MFinit.ucLumaCurve2_a[i] = pstXC_DLC_InitData->DLC_MFinit_Ex.ucLumaCurve2_a[i];
315 DLC_MFinit.ucLumaCurve2_b[i] = pstXC_DLC_InitData->DLC_MFinit_Ex.ucLumaCurve2_b[i];
316 }
317
318
319 #if (ENABLE_10_BIT_DLC)
320 DLC_InitExt.b10BitsCruveEn = pstXC_DLC_InitData->b10BitsEn;
321 #else
322 DLC_InitExt.b10BitsCruveEn = 0;
323 #endif
324
325 DLC_MFinit.u8_L_L_U = pstXC_DLC_InitData->DLC_MFinit_Ex.u8_L_L_U;
326 DLC_MFinit.u8_L_L_D = pstXC_DLC_InitData->DLC_MFinit_Ex.u8_L_L_D;
327 DLC_MFinit.u8_L_H_U = pstXC_DLC_InitData->DLC_MFinit_Ex.u8_L_H_U;
328 DLC_MFinit.u8_L_H_D = pstXC_DLC_InitData->DLC_MFinit_Ex.u8_L_H_D;
329 DLC_MFinit.u8_S_L_U = pstXC_DLC_InitData->DLC_MFinit_Ex.u8_S_L_U;
330 DLC_MFinit.u8_S_L_D = pstXC_DLC_InitData->DLC_MFinit_Ex.u8_S_L_D;
331 DLC_MFinit.u8_S_H_U = pstXC_DLC_InitData->DLC_MFinit_Ex.u8_S_H_U;
332 DLC_MFinit.u8_S_H_D = pstXC_DLC_InitData->DLC_MFinit_Ex.u8_S_H_D ;
333
334 DLC_MFinit.ucDlcPureImageMode = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcPureImageMode;
335 DLC_MFinit.ucDlcLevelLimit = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcLevelLimit;
336 DLC_MFinit.ucDlcAvgDelta = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcAvgDelta;
337 DLC_MFinit.ucDlcAvgDeltaStill = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcAvgDeltaStill;
338 DLC_MFinit.ucDlcFastAlphaBlending = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcFastAlphaBlending;
339 DLC_MFinit.ucDlcYAvgThresholdL = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcYAvgThresholdL;
340 DLC_MFinit.ucDlcYAvgThresholdH = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcYAvgThresholdH;
341 DLC_MFinit.ucDlcBLEPoint = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcBLEPoint;
342 DLC_MFinit.ucDlcWLEPoint = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcWLEPoint;
343 DLC_MFinit.bEnableBLE = pstXC_DLC_InitData->DLC_MFinit_Ex.bEnableBLE;
344 DLC_MFinit.bEnableWLE = pstXC_DLC_InitData->DLC_MFinit_Ex.bEnableWLE;
345 DLC_MFinit.ucCGCYth = pstXC_DLC_InitData->DLC_MFinit_Ex.ucCGCYth;
346 DLC_MFinit.bCGCCGainCtrl = pstXC_DLC_InitData->DLC_MFinit_Ex.bCGCCGainCtrl;
347
348 // CGC
349 DLC_MFinit.ucCGCCGain_offset = pstXC_DLC_InitData->DLC_MFinit_Ex.ucCGCCGain_offset;
350 DLC_MFinit.ucCGCChroma_GainLimitH = pstXC_DLC_InitData->DLC_MFinit_Ex.ucCGCChroma_GainLimitH;
351 DLC_MFinit.ucCGCChroma_GainLimitL = pstXC_DLC_InitData->DLC_MFinit_Ex.ucCGCChroma_GainLimitL;
352 DLC_MFinit.ucCGCYCslope = pstXC_DLC_InitData->DLC_MFinit_Ex.ucCGCYCslope;
353
354
355 if(pstXC_DLC_InitData->DLC_MFinit_Ex.u32DLC_MFinit_Ex_Version>=1)
356 {
357 #if (DLC_MFINIT_EX_VERSION>=1)
358
359 for (i=0; i<DLC_HISTOGRAM_LIMIT_CURVE_ARRARY_NUM; ++i)
360 {
361 DLC_MFinit.ucDlcHistogramLimitCurve[i] = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcHistogramLimitCurve[i];
362 }
363
364 DLC_MFinit.ucDlcYAvgThresholdM = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcYAvgThresholdM;
365 DLC_MFinit.ucDlcCurveMode = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcCurveMode;
366 DLC_MFinit.ucDlcCurveModeMixAlpha = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcCurveModeMixAlpha;
367 DLC_MFinit.ucDlcAlgorithmMode = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcAlgorithmMode;
368 DLC_MFinit.ucDlcSepPointH = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcSepPointH;
369 DLC_MFinit.ucDlcSepPointL = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcSepPointL;
370 DLC_MFinit.uwDlcBleStartPointTH = pstXC_DLC_InitData->DLC_MFinit_Ex.uwDlcBleStartPointTH;
371 DLC_MFinit.uwDlcBleEndPointTH = pstXC_DLC_InitData->DLC_MFinit_Ex.uwDlcBleEndPointTH;
372 DLC_MFinit.ucDlcCurveDiff_L_TH = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcCurveDiff_L_TH;
373 DLC_MFinit.ucDlcCurveDiff_H_TH = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcCurveDiff_H_TH;
374 DLC_MFinit.uwDlcBLESlopPoint_1 = pstXC_DLC_InitData->DLC_MFinit_Ex.uwDlcBLESlopPoint_1;
375 DLC_MFinit.uwDlcBLESlopPoint_2 = pstXC_DLC_InitData->DLC_MFinit_Ex.uwDlcBLESlopPoint_2;
376 DLC_MFinit.uwDlcBLESlopPoint_3 = pstXC_DLC_InitData->DLC_MFinit_Ex.uwDlcBLESlopPoint_3;
377 DLC_MFinit.uwDlcBLESlopPoint_4 = pstXC_DLC_InitData->DLC_MFinit_Ex.uwDlcBLESlopPoint_4;
378 DLC_MFinit.uwDlcBLESlopPoint_5 = pstXC_DLC_InitData->DLC_MFinit_Ex.uwDlcBLESlopPoint_5;
379 DLC_MFinit.uwDlcDark_BLE_Slop_Min = pstXC_DLC_InitData->DLC_MFinit_Ex.uwDlcDark_BLE_Slop_Min;
380 DLC_MFinit.ucDlcCurveDiffCoringTH = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcCurveDiffCoringTH;
381 DLC_MFinit.ucDlcAlphaBlendingMin = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcAlphaBlendingMin;
382 DLC_MFinit.ucDlcAlphaBlendingMax = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcAlphaBlendingMax;
383 DLC_MFinit.ucDlcFlicker_alpha = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcFlicker_alpha;
384 DLC_MFinit.ucDlcYAVG_L_TH = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcYAVG_L_TH;
385 DLC_MFinit.ucDlcYAVG_H_TH = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcYAVG_H_TH;
386
387 DLC_MFinit.ucDlcDiffBase_L = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcDiffBase_L;
388 DLC_MFinit.ucDlcDiffBase_M = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcDiffBase_M;
389 DLC_MFinit.ucDlcDiffBase_H = pstXC_DLC_InitData->DLC_MFinit_Ex.ucDlcDiffBase_H;
390 #endif
391 #if (DLC_MFINIT_EX_VERSION>=2)
392 DLC_MFinit.ucLMaxThreshold = pstXC_DLC_InitData->DLC_MFinit_Ex.u8LMaxThreshold;
393 DLC_MFinit.ucLMinThreshold = pstXC_DLC_InitData->DLC_MFinit_Ex.u8LMinThreshold;
394 DLC_MFinit.ucLMaxCorrection = pstXC_DLC_InitData->DLC_MFinit_Ex.u8LMaxCorrection;
395 DLC_MFinit.ucLMinCorrection = pstXC_DLC_InitData->DLC_MFinit_Ex.u8LMinCorrection;
396 DLC_MFinit.ucRMaxThreshold = pstXC_DLC_InitData->DLC_MFinit_Ex.u8RMaxThreshold;
397 DLC_MFinit.ucRMinThreshold = pstXC_DLC_InitData->DLC_MFinit_Ex.u8RMinThreshold;
398 DLC_MFinit.ucRMaxCorrection = pstXC_DLC_InitData->DLC_MFinit_Ex.u8RMaxCorrection;
399 DLC_MFinit.ucRMinCorrection = pstXC_DLC_InitData->DLC_MFinit_Ex.u8RMinCorrection;
400 DLC_MFinit.ucAllowLoseContrast = pstXC_DLC_InitData->DLC_MFinit_Ex.u8AllowLoseContrast;
401
402 #endif
403 }
404
405 MDrv_DLC_Init(DLC_MFinit);
406 MDrv_DLC_Init_Ext(&DLC_InitExt);
407
408 g_DlcCapRange_Suspend.wHStart = pstXC_DLC_InitData->u16CurveHStart;
409 g_DlcCapRange_Suspend.wHEnd = pstXC_DLC_InitData->u16CurveHEnd;
410 g_DlcCapRange_Suspend.wVStart = pstXC_DLC_InitData->u16CurveVStart;
411 g_DlcCapRange_Suspend.wVEnd = pstXC_DLC_InitData->u16CurveVEnd;
412
413 Dlc_FuncEnter();
414 MDrv_DLC_InitCurve (pstXC_DLC_InitData->u16CurveHStart, pstXC_DLC_InitData->u16CurveHEnd, pstXC_DLC_InitData->u16CurveVStart, pstXC_DLC_InitData->u16CurveVEnd);
415 Dlc_FuncExit();
416
417 return TRUE;
418 }
419
420
MApi_XC_DLC_Init_Ex(XC_DLC_init * pstXC_DLC_InitData,MS_U32 u32InitDataLen)421 MS_BOOL MApi_XC_DLC_Init_Ex(XC_DLC_init *pstXC_DLC_InitData, MS_U32 u32InitDataLen)
422 {
423 if (pu32DLCInst == NULL)
424 {
425 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
426 {
427 printf("UtopiaOpen DLC failed\n");
428 return FALSE;
429 }
430 }
431
432 stDLC_Init_Ex DLCArgs;
433 DLCArgs.pstXC_DLC_InitData = pstXC_DLC_InitData;
434 DLCArgs.u32InitDataLen = u32InitDataLen;
435 DLCArgs.bReturn = FALSE ;
436
437 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
438 // instead of 0
439 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_INIT_EX, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
440 {
441 printf("Obtain DLC engine fail\n");
442 return FALSE;
443 }
444 else
445 {
446 return DLCArgs.bReturn;
447 }
448 }
449
450
451 //-------------------------------------------------------------------------------------------------
452 /// Setting DLC
453 // @param DLC_MFinit \b IN: DLC data
454 //-------------------------------------------------------------------------------------------------
MApi_XC_DLC_SetSetting_Ex_U2(void * pInstance,XC_DLC_MFinit_Ex * DLC_MFinit_Ex)455 void MApi_XC_DLC_SetSetting_Ex_U2(void * pInstance,XC_DLC_MFinit_Ex * DLC_MFinit_Ex)
456 {
457
458 MS_U8 i;
459 StuDlc_FinetuneParamaters DLC_MFinit_new;
460
461 memset(&DLC_MFinit_new, 0 , sizeof(DLC_MFinit_new) );
462 for (i=0; i<16; ++i)
463 {
464 DLC_MFinit_new.ucLumaCurve[i] = DLC_MFinit_Ex->ucLumaCurve[i];
465 DLC_MFinit_new.ucLumaCurve2_a[i] = DLC_MFinit_Ex->ucLumaCurve2_a[i];
466 DLC_MFinit_new.ucLumaCurve2_b[i] = DLC_MFinit_Ex->ucLumaCurve2_b[i];
467 }
468
469 DLC_MFinit_new.u8_L_L_U = DLC_MFinit_Ex->u8_L_L_U;
470 DLC_MFinit_new.u8_L_L_D = DLC_MFinit_Ex->u8_L_L_D;
471 DLC_MFinit_new.u8_L_H_U = DLC_MFinit_Ex->u8_L_H_U;
472 DLC_MFinit_new.u8_L_H_D = DLC_MFinit_Ex->u8_L_H_D;
473 DLC_MFinit_new.u8_S_L_U = DLC_MFinit_Ex->u8_S_L_U;
474 DLC_MFinit_new.u8_S_L_D = DLC_MFinit_Ex->u8_S_L_D;
475 DLC_MFinit_new.u8_S_H_U = DLC_MFinit_Ex->u8_S_H_U;
476 DLC_MFinit_new.u8_S_H_D = DLC_MFinit_Ex->u8_S_H_D ;
477
478 DLC_MFinit_new.ucDlcPureImageMode = DLC_MFinit_Ex->ucDlcPureImageMode;
479 DLC_MFinit_new.ucDlcLevelLimit = DLC_MFinit_Ex->ucDlcLevelLimit;
480 DLC_MFinit_new.ucDlcAvgDelta = DLC_MFinit_Ex->ucDlcAvgDelta;
481 DLC_MFinit_new.ucDlcAvgDeltaStill = DLC_MFinit_Ex->ucDlcAvgDeltaStill;
482 DLC_MFinit_new.ucDlcFastAlphaBlending = DLC_MFinit_Ex->ucDlcFastAlphaBlending;
483 DLC_MFinit_new.ucDlcYAvgThresholdL = DLC_MFinit_Ex->ucDlcYAvgThresholdL;
484 DLC_MFinit_new.ucDlcYAvgThresholdH = DLC_MFinit_Ex->ucDlcYAvgThresholdH;
485 DLC_MFinit_new.ucDlcBLEPoint = DLC_MFinit_Ex->ucDlcBLEPoint;
486 DLC_MFinit_new.ucDlcWLEPoint = DLC_MFinit_Ex->ucDlcWLEPoint;
487 DLC_MFinit_new.bEnableBLE = DLC_MFinit_Ex->bEnableBLE;
488 DLC_MFinit_new.bEnableWLE = DLC_MFinit_Ex->bEnableWLE;
489
490 DLC_MFinit_new.ucCGCYth = DLC_MFinit_Ex->ucCGCYth;
491 DLC_MFinit_new.bCGCCGainCtrl = DLC_MFinit_Ex->bCGCCGainCtrl;
492
493 // CGC
494 DLC_MFinit_new.ucCGCCGain_offset = DLC_MFinit_Ex->ucCGCCGain_offset;
495 DLC_MFinit_new.ucCGCChroma_GainLimitH = DLC_MFinit_Ex->ucCGCChroma_GainLimitH;
496 DLC_MFinit_new.ucCGCChroma_GainLimitL = DLC_MFinit_Ex->ucCGCChroma_GainLimitL;
497 DLC_MFinit_new.ucCGCYCslope = DLC_MFinit_Ex->ucCGCYCslope;
498
499 if(DLC_MFinit_Ex->u32DLC_MFinit_Ex_Version>=1)
500 {
501 for (i=0; i<DLC_HISTOGRAM_LIMIT_CURVE_ARRARY_NUM; ++i)
502 {
503 DLC_MFinit_new.ucDlcHistogramLimitCurve[i] = DLC_MFinit_Ex->ucDlcHistogramLimitCurve[i];
504 }
505
506 DLC_MFinit_new.ucDlcYAvgThresholdM = DLC_MFinit_Ex->ucDlcYAvgThresholdM;
507 DLC_MFinit_new.ucDlcCurveMode = DLC_MFinit_Ex->ucDlcCurveMode;
508 DLC_MFinit_new.ucDlcCurveModeMixAlpha = DLC_MFinit_Ex->ucDlcCurveModeMixAlpha;
509 DLC_MFinit_new.ucDlcAlgorithmMode = DLC_MFinit_Ex->ucDlcAlgorithmMode;
510 DLC_MFinit_new.ucDlcSepPointH = DLC_MFinit_Ex->ucDlcSepPointH;
511 DLC_MFinit_new.ucDlcSepPointL = DLC_MFinit_Ex->ucDlcSepPointL;
512 DLC_MFinit_new.uwDlcBleStartPointTH = DLC_MFinit_Ex->uwDlcBleStartPointTH;
513 DLC_MFinit_new.uwDlcBleEndPointTH = DLC_MFinit_Ex->uwDlcBleEndPointTH;
514 DLC_MFinit_new.ucDlcCurveDiff_L_TH = DLC_MFinit_Ex->ucDlcCurveDiff_L_TH;
515 DLC_MFinit_new.ucDlcCurveDiff_H_TH = DLC_MFinit_Ex->ucDlcCurveDiff_H_TH;
516 DLC_MFinit_new.uwDlcBLESlopPoint_1 = DLC_MFinit_Ex->uwDlcBLESlopPoint_1;
517 DLC_MFinit_new.uwDlcBLESlopPoint_2 = DLC_MFinit_Ex->uwDlcBLESlopPoint_2;
518 DLC_MFinit_new.uwDlcBLESlopPoint_3 = DLC_MFinit_Ex->uwDlcBLESlopPoint_3;
519 DLC_MFinit_new.uwDlcBLESlopPoint_4 = DLC_MFinit_Ex->uwDlcBLESlopPoint_4;
520 DLC_MFinit_new.uwDlcBLESlopPoint_5 = DLC_MFinit_Ex->uwDlcBLESlopPoint_5;
521 DLC_MFinit_new.uwDlcDark_BLE_Slop_Min = DLC_MFinit_Ex->uwDlcDark_BLE_Slop_Min;
522 DLC_MFinit_new.ucDlcCurveDiffCoringTH = DLC_MFinit_Ex->ucDlcCurveDiffCoringTH;
523 DLC_MFinit_new.ucDlcAlphaBlendingMin = DLC_MFinit_Ex->ucDlcAlphaBlendingMin;
524 DLC_MFinit_new.ucDlcAlphaBlendingMax = DLC_MFinit_Ex->ucDlcAlphaBlendingMax;
525 DLC_MFinit_new.ucDlcFlicker_alpha = DLC_MFinit_Ex->ucDlcFlicker_alpha;
526 DLC_MFinit_new.ucDlcYAVG_L_TH = DLC_MFinit_Ex->ucDlcYAVG_L_TH;
527 DLC_MFinit_new.ucDlcYAVG_H_TH = DLC_MFinit_Ex->ucDlcYAVG_H_TH;
528
529 DLC_MFinit_new.ucDlcDiffBase_L = DLC_MFinit_Ex->ucDlcDiffBase_L;
530 DLC_MFinit_new.ucDlcDiffBase_M = DLC_MFinit_Ex->ucDlcDiffBase_M;
531 DLC_MFinit_new.ucDlcDiffBase_H = DLC_MFinit_Ex->ucDlcDiffBase_H;
532 }
533
534 MDrv_DLC_Init(DLC_MFinit_new);
535 }
536
MApi_XC_DLC_SetSetting_Ex(XC_DLC_MFinit_Ex * DLC_MFinit_Ex)537 void MApi_XC_DLC_SetSetting_Ex(XC_DLC_MFinit_Ex *DLC_MFinit_Ex)
538 {
539 if (pu32DLCInst == NULL)
540 {
541 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
542 {
543 printf("UtopiaOpen DLC failed\n");
544 return ;
545 }
546 }
547
548 stDLC_SetSetting_Ex DLCArgs;
549 DLCArgs.DLC_MFinit_Ex = DLC_MFinit_Ex;
550
551 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
552 // instead of 0
553 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_SET_SETTING_EX, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
554 {
555 printf("Obtain DLC engine fail\n");
556 }
557
558 return ;
559 }
560
561
MApi_XC_DLC_SetCurve_U2(void * pInstance,MS_U8 * pNormal,MS_U8 * pLight,MS_U8 * pDark)562 void MApi_XC_DLC_SetCurve_U2(void * pInstance,MS_U8 * pNormal,MS_U8 * pLight,MS_U8 * pDark)
563 {
564
565 MDrv_DLC_SendDlcInitCurveChangeInfo(ENABLE, pNormal, pLight, pDark );
566 MDrv_DLC_SetCurve(pNormal, pLight, pDark);
567 }
568
MApi_XC_DLC_SetCurve(MS_U8 * pNormal,MS_U8 * pLight,MS_U8 * pDark)569 void MApi_XC_DLC_SetCurve(MS_U8 *pNormal, MS_U8 *pLight, MS_U8 *pDark)
570 {
571 if (pu32DLCInst == NULL)
572 {
573 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
574 {
575 printf("UtopiaOpen DLC failed\n");
576 return ;
577 }
578 }
579
580 stDLC_SetCurve DLCArgs;
581 DLCArgs.pNormal = pNormal;
582 DLCArgs.pLight = pLight;
583 DLCArgs.pDark = pDark;
584
585 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
586 // instead of 0
587 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_SET_CURVE, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
588 {
589 printf("Obtain DLC engine fail\n");
590 return ;
591 }
592
593 return ;
594 }
595
596
MApi_XC_DLC_SetBleSlopPoint_U2(void * pInstance,MS_U16 * pBLESlopPoint)597 void MApi_XC_DLC_SetBleSlopPoint_U2(void * pInstance,MS_U16 * pBLESlopPoint)
598 {
599 MDrv_DLC_SendBleChangeInfo(ENABLE, pBLESlopPoint);
600 }
601
MApi_XC_DLC_SetBleSlopPoint(MS_U16 * pBLESlopPoint)602 void MApi_XC_DLC_SetBleSlopPoint(MS_U16 *pBLESlopPoint)
603 {
604 if (pu32DLCInst == NULL)
605 {
606 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
607 {
608 printf("UtopiaOpen DLC failed\n");
609 return ;
610 }
611 }
612
613 stDLC_SetBleSlopPoint DLCArgs;
614 DLCArgs.pBLESlopPoint = pBLESlopPoint;
615
616 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
617 // instead of 0
618 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_SET_BLE_SLOP_POINT, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
619 {
620 printf("Obtain DLC engine fail\n");
621 return ;
622 }
623
624 return ;
625 }
626
MApi_XC_DLC_SetHDRInit_U2(void * pInstance,XC_DLC_HDRinit * pstDLC_HDRInitData)627 MS_BOOL MApi_XC_DLC_SetHDRInit_U2(void * pInstance ,XC_DLC_HDRinit * pstDLC_HDRInitData)
628 {
629 MS_BOOL bReturn=FALSE;
630 MS_U16 u16CopiedLength = sizeof(XC_DLC_HDRinit);
631
632 if((NULL == pstDLC_HDRInitData) || (pstDLC_HDRInitData->u16HDRInitLength == 0))
633 {
634 //We cosider compatible operation form version2 , so reject the info init when version invalid
635 printf("MApi_XC_DLC_SetHDRInit: Null paramter or Wrong u16HDRInitLength!!\n");
636 return bReturn;
637 }
638
639 // the version control is coming in with version 1
640 if(pstDLC_HDRInitData->u16HDRVerInfo < 1)
641 {
642 //We cosider compatible operation form version1 , so reject the info init when version invalid
643 printf("MApi_XC_DLC_SetHDRInit: please check your u16HDRVerInfo, it should not set to 0!!\n");
644 return bReturn;
645 }
646
647 if(pstDLC_HDRInitData->u16HDRVerInfo > XC_DLC_HDR_VERSION)
648 {
649 //We cosider compatible operation form version1 , so reject the info init when version invalid
650 #if defined (__aarch64__)
651 printf("MApi_XC_DLC_SetHDRInit: this old version DLC lib has only length:%lu driver status!!\n",sizeof(XC_DLC_HDRinit));
652 #else
653 printf("MApi_XC_DLC_SetHDRInit: this old version DLC lib has only length:%u driver status!!\n",sizeof(XC_DLC_HDRinit));
654 #endif
655 //we still copy the min size of both structure, but AP should take care of it.
656 u16CopiedLength = sizeof(XC_DLC_HDRinit);
657 }
658
659 //old AP + new lib, driver shouldn't access to the space which doesn't exist in old structure
660 if((pstDLC_HDRInitData->u16HDRVerInfo < XC_DLC_HDR_VERSION) || (pstDLC_HDRInitData->u16HDRInitLength < sizeof(XC_DLC_HDRinit)))
661 {
662 //We cosider compatible operation form version1 , so reject the info init when version invalid
663 printf("MApi_XC_DLC_SetHDRInit: new version DLC lib shouldn't access to the space which doesn't exist in old structure!!\n");
664 u16CopiedLength = pstDLC_HDRInitData->u16HDRInitLength;
665 }
666
667 DLC_HDRinit DLC_HDRInitInfo;
668 memset(&DLC_HDRInitInfo, 0 , sizeof(DLC_HDRinit));
669 memcpy(&DLC_HDRInitInfo, pstDLC_HDRInitData, u16CopiedLength);
670 DLC_HDRInitInfo.u16HDRInitLength = u16CopiedLength;
671 bReturn=MDrv_DLC_SetHDRInit(&DLC_HDRInitInfo);
672 return bReturn;
673 }
674
MApi_XC_DLC_SetHDRInit(XC_DLC_HDRinit * pstDLC_HDRInitData)675 MS_BOOL SYMBOL_WEAK MApi_XC_DLC_SetHDRInit(XC_DLC_HDRinit *pstDLC_HDRInitData)
676 {
677 if (pu32DLCInst == NULL)
678 {
679 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
680 {
681 printf("UtopiaOpen DLC failed\n");
682 return FALSE;
683 }
684 }
685
686 stDLC_SetHDRInitData DLCArgs;
687 DLCArgs.pstDLC_HDRInitData = pstDLC_HDRInitData;
688
689 DLCArgs.bReturn = FALSE ;
690
691 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
692 // instead of 0
693 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_SET_HDR_INFO, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
694 {
695 printf("Obtain DLC engine fail\n");
696 return FALSE ;
697 }
698 else
699 {
700 return DLCArgs.bReturn;
701 }
702 }
703
704 #ifdef UFO_XC_HDR
705 #if (UFO_XC_HDR_VERSION == 2)
MApi_XC_DLC_SetTMOInfo_U2(void * pInstance,ST_XC_DLC_TMO_INFO * pstDLCTmoInfo)706 MS_BOOL MApi_XC_DLC_SetTMOInfo_U2(void * pInstance, ST_XC_DLC_TMO_INFO *pstDLCTmoInfo)
707 {
708 MS_BOOL bReturn = FALSE;
709 MS_U16 u16CopiedLength = sizeof(ST_XC_DLC_TMO_INFO);
710 ST_DLC_TMO_INFO stDLCTMOInfo;
711
712 memset(&stDLCTMOInfo, 0, sizeof(stDLCTMOInfo));
713 VERSION_COMPATIBLE_CHECK(pstDLCTmoInfo, stDLCTMOInfo, u16CopiedLength, u32TMOInfo_Version, u16TMOInfo_Length, DLC_TMO_INFO_VERSION);
714 pstDLCTmoInfo->u32TMOInfo_Version = DLC_TMO_INFO_VERSION; /*Return the actual version of the returned value for APP to use*/
715 pstDLCTmoInfo->u16TMOInfo_Length = u16CopiedLength; /*Return the actual length of the returned value for APP to know whick info is valid*/
716 memcpy(&stDLCTMOInfo, pstDLCTmoInfo, u16CopiedLength);
717
718 bReturn = MDrv_DLC_SetTMOInfo(&stDLCTMOInfo);
719 return bReturn;
720 }
721
MApi_XC_DLC_SetTMOInfo(ST_XC_DLC_TMO_INFO * pstDLCTmoInfo)722 MS_BOOL SYMBOL_WEAK MApi_XC_DLC_SetTMOInfo(ST_XC_DLC_TMO_INFO *pstDLCTmoInfo)
723 {
724 if (pu32DLCInst == NULL)
725 {
726 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
727 {
728 printf("UtopiaOpen DLC failed\n");
729 return FALSE;
730 }
731 }
732
733 stDLC_SetTMOInfo DLCArgs;
734 DLCArgs.pstDLC_TMOInfo = pstDLCTmoInfo;
735
736 DLCArgs.bReturn = FALSE ;
737
738 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_SET_TMOINFO, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
739 {
740 printf("Obtain DLC engine fail\n");
741 return FALSE ;
742 }
743 else
744 {
745 return DLCArgs.bReturn;
746 }
747
748 return DLCArgs.bReturn;
749 }
750 #endif
751 #endif
752
MApi_XC_DLC_Exit_U2(void * pInstance)753 MS_BOOL MApi_XC_DLC_Exit_U2(void * pInstance)
754 {
755 return TRUE;
756 }
757
MApi_XC_DLC_Exit(void)758 MS_BOOL MApi_XC_DLC_Exit(void)
759 {
760 if (pu32DLCInst == NULL)
761 {
762 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
763 {
764 printf("UtopiaOpen DLC failed\n");
765 return FALSE;
766 }
767 }
768
769 stDLC_Exit DLCArgs;
770 DLCArgs.bReturn = FALSE ;
771 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
772 // instead of 0
773 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_EXIT, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
774 {
775 printf("Obtain DLC engine fail\n");
776 return FALSE;
777 }
778 else
779 {
780 return DLCArgs.bReturn;
781 }
782
783
784 }
785
786
787 /******************************************************************************/
788 //Enable/disable DLC to control MDrv_DLC_SetOnOff ,used DLC enbale register to control.
789 //@param bSwitch \b IN
790 // - # TRUE Enable
791 // - # FALSE Disable
792 /******************************************************************************/
MApi_XC_DLC_SetOnOff_U2(void * pInstance,MS_BOOL bSwitch,MS_BOOL bWindow)793 void MApi_XC_DLC_SetOnOff_U2(void * pInstance,MS_BOOL bSwitch,MS_BOOL bWindow)
794 {
795 Dlc_FuncEnter();
796 MDrv_DLC_SetOnOff( bSwitch, bWindow );
797 Dlc_FuncExit();
798 }
799
MApi_XC_DLC_SetOnOff(MS_BOOL bSwitch,MS_BOOL bWindow)800 void MApi_XC_DLC_SetOnOff ( MS_BOOL bSwitch, MS_BOOL bWindow )
801 {
802 if (pu32DLCInst == NULL)
803 {
804 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
805 {
806 printf("UtopiaOpen DLC failed\n");
807 return ;
808 }
809 }
810
811 stDLC_SetOnOff DLCArgs;
812 DLCArgs.bSwitch = bSwitch;
813 DLCArgs.bWindow = bWindow;
814
815 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
816 // instead of 0
817 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_SET_ON_OFF, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
818 {
819 printf("Obtain DLC engine fail\n");
820 }
821
822 return ;
823 }
824
825
826 /******************************************************************************/
827 //Enable/disable DLC to control MDrv_DLC_Handler function.
828 //@param bSwitch \b IN
829 // - # TRUE Enable
830 // - # FALSE Disable
831 /******************************************************************************/
MApi_XC_DLC_SetDlcHandlerOnOff_U2(void * pInstance,MS_BOOL bDlcEnable)832 MS_BOOL MApi_XC_DLC_SetDlcHandlerOnOff_U2(void * pInstance,MS_BOOL bDlcEnable)
833 {
834 MDrv_DLC_SetDlcHandlerOnOff( bDlcEnable);
835 return TRUE;
836 }
837
MApi_XC_DLC_SetDlcHandlerOnOff(MS_BOOL bDlcEnable)838 MS_BOOL MApi_XC_DLC_SetDlcHandlerOnOff( MS_BOOL bDlcEnable )
839 {
840 if (pu32DLCInst == NULL)
841 {
842 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
843 {
844 printf("UtopiaOpen DLC failed\n");
845 return FALSE;
846 }
847 }
848
849 stDLC_SetDlcHandlerOnOff DLCArgs;
850 DLCArgs.bDlcEnable = bDlcEnable;
851 DLCArgs.bReturn = FALSE ;
852 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
853 // instead of 0
854 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_SET_HANDLER_ON_OFF, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
855 {
856 printf("Obtain DLC engine fail\n");
857 return FALSE;
858 }
859 else
860 {
861 return DLCArgs.bReturn;
862 }
863 }
864
865
866 /******************************************************************************/
867 //Enable/disable BLE to control BLE function.
868 //@param bSwitch \b IN
869 // - # TRUE Enable
870 // - # FALSE Disable
871 /******************************************************************************/
MApi_XC_DLC_SetBleOnOff_U2(void * pInstance,MS_BOOL bSwitch)872 MS_BOOL MApi_XC_DLC_SetBleOnOff_U2(void * pInstance,MS_BOOL bSwitch)
873 {
874 MDrv_DLC_SetBleOnOff( bSwitch);
875 return TRUE;
876 }
877
MApi_XC_DLC_SetBleOnOff(MS_BOOL bSwitch)878 MS_BOOL MApi_XC_DLC_SetBleOnOff( MS_BOOL bSwitch )
879 {
880 if (pu32DLCInst == NULL)
881 {
882 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
883 {
884 printf("UtopiaOpen DLC failed\n");
885 return FALSE;
886 }
887 }
888
889 stDLC_SetBleOnOff DLCArgs;
890 DLCArgs.bSwitch = bSwitch;
891 DLCArgs.bReturn = FALSE ;
892 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
893 // instead of 0
894 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_SET_BLE_ON_OFF, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
895 {
896 printf("Obtain DLC engine fail\n");
897 return FALSE;
898 }
899 else
900 {
901 return DLCArgs.bReturn;
902 }
903 }
904
905
906 /******************************************************************************/
907 //Enable/disable DLC Set Curve Both for main and sub.
908 //@param bEnable \b IN
909 // - # TRUE Enable
910 // - # FALSE Disable
911 /******************************************************************************/
MApi_XC_DLC_EnableMainSubCurveSynchronization_U2(void * pInstance,MS_BOOL bEnable)912 void MApi_XC_DLC_EnableMainSubCurveSynchronization_U2(void * pInstance,MS_BOOL bEnable)
913 {
914 Dlc_FuncEnter();
915 MDrv_DLC_EnableMainSubCurveSynchronization( bEnable );
916 Dlc_FuncExit();
917 }
918
MApi_XC_DLC_EnableMainSubCurveSynchronization(MS_BOOL bEnable)919 void MApi_XC_DLC_EnableMainSubCurveSynchronization (MS_BOOL bEnable)
920 {
921 if (pu32DLCInst == NULL)
922 {
923 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
924 {
925 printf("UtopiaOpen DLC failed\n");
926 return ;
927 }
928 }
929
930 stDLC_EnableMainSubCurveSynchronization DLCArgs;
931 DLCArgs.bEnable = bEnable;
932
933 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
934 // instead of 0
935 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_ENABLE_MAIN_SUB_CURVE_SYNCHRONIZATION, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
936 {
937 printf("Obtain DLC engine fail\n");
938 }
939
940 return ;
941 }
942
943
944 /******************************************************************************/
945 // DLC handler
946 // @param bWindow \b IN:
947 // - @see
948 /******************************************************************************/
MApi_XC_DLC_Handler_U2(void * pInstance,MS_BOOL bWindow)949 void MApi_XC_DLC_Handler_U2(void * pInstance,MS_BOOL bWindow)
950 {
951 Dlc_FuncEnter();
952 MDrv_DLC_Handler(bWindow);
953 Dlc_FuncExit();
954 }
955
MApi_XC_DLC_Handler(MS_BOOL bWindow)956 void MApi_XC_DLC_Handler(MS_BOOL bWindow)
957 {
958 if (pu32DLCInst == NULL)
959 {
960 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
961 {
962 printf("UtopiaOpen DLC failed\n");
963 return ;
964 }
965 }
966
967 stDLC_Handler DLCArgs;
968 DLCArgs.bWindow = bWindow;
969
970 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
971 // instead of 0
972 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_HANDLER, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
973 {
974 printf("Obtain DLC engine fail\n");
975 }
976
977 return ;
978 }
979
980
981 /******************************************************************************/
982 // DLC get histogram handler
983 // @param bWindow \b IN:
984 // - @see
985 /******************************************************************************/
MApi_XC_DLC_GetHistogramHandler_U2(void * pInstance,MS_BOOL bWindow)986 MS_BOOL MApi_XC_DLC_GetHistogramHandler_U2(void * pInstance,MS_BOOL bWindow)
987 {
988 MS_BOOL bResult;
989
990 Dlc_FuncEnter();
991
992 bResult = MDrv_DLC_GetHistogram(bWindow);
993 Dlc_FuncExit();
994
995 return bResult;
996 }
997
MApi_XC_DLC_GetHistogramHandler(MS_BOOL bWindow)998 MS_BOOL MApi_XC_DLC_GetHistogramHandler(MS_BOOL bWindow)
999 {
1000 if (pu32DLCInst == NULL)
1001 {
1002 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1003 {
1004 printf("UtopiaOpen DLC failed\n");
1005 return FALSE;
1006 }
1007 }
1008
1009 stDLC_GetHistogramHandler DLCArgs;
1010 DLCArgs.bWindow = bWindow;
1011 DLCArgs.bReturn = FALSE ;
1012 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1013 // instead of 0
1014 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_GET_HISTOGRAM_HANDLER, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1015 {
1016 printf("Obtain DLC engine fail\n");
1017 return FALSE;
1018 }
1019 else
1020 {
1021 return DLCArgs.bReturn;
1022 }
1023 }
1024
1025
1026 /******************************************************************************/
1027 //Get average value of histogram
1028 //@return Average value from 0 to 255
1029 /******************************************************************************/
MApi_XC_DLC_GetAverageValue_U2(void * pInstance)1030 MS_U8 MApi_XC_DLC_GetAverageValue_U2(void * pInstance)
1031 {
1032 MS_U8 bResult;
1033
1034 Dlc_FuncEnter();
1035
1036 bResult = MDrv_DLC_GetAverageValue();
1037
1038 Dlc_FuncExit();
1039 return bResult;
1040 }
1041
MApi_XC_DLC_GetAverageValue(void)1042 MS_U8 MApi_XC_DLC_GetAverageValue(void)
1043 {
1044 if (pu32DLCInst == NULL)
1045 {
1046 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1047 {
1048 printf("UtopiaOpen DLC failed\n");
1049 return 0;
1050 }
1051 }
1052
1053 stDLC_GetAverageValue DLCArgs;
1054 DLCArgs.u8Return = 0 ;
1055
1056 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1057 // instead of 0
1058 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_GET_AVERAGE_VALUE, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1059 {
1060 printf("Obtain DLC engine fail\n");
1061 return 0;
1062 }
1063 else
1064 {
1065 return DLCArgs.u8Return;
1066 }
1067 }
1068
1069
1070 /******************************************************************************/
1071 //Get average value exactness of histogram
1072 //@return Average value from 0 to 1023
1073 /******************************************************************************/
MApi_XC_DLC_GetAverageValue_Ex_U2(void * pInstance)1074 MS_U16 MApi_XC_DLC_GetAverageValue_Ex_U2(void * pInstance)
1075 {
1076 MS_U16 bResult;
1077
1078 Dlc_FuncEnter();
1079
1080 bResult = MDrv_DLC_GetAverageValue_x4();
1081
1082 Dlc_FuncExit();
1083 return bResult;
1084 }
1085
MApi_XC_DLC_GetAverageValue_Ex(void)1086 MS_U16 MApi_XC_DLC_GetAverageValue_Ex(void)
1087 {
1088 if (pu32DLCInst == NULL)
1089 {
1090 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1091 {
1092 printf("UtopiaOpen DLC failed\n");
1093 return 0;
1094 }
1095 }
1096
1097 stDLC_GetAverageValue_Ex DLCArgs;
1098 DLCArgs.u16Return = 0 ;
1099
1100 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1101 // instead of 0
1102 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_GET_AVERAGE_VALUE_EX, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1103 {
1104 printf("Obtain DLC engine fail\n");
1105 return 0;
1106 }
1107 else
1108 {
1109 return DLCArgs.u16Return;
1110 }
1111 }
1112
1113
MApi_XC_DLC_InitCurve_U2(void * pInstance,MS_U16 u16HStart,MS_U16 u16HEnd,MS_U16 u16VStart,MS_U16 u16VEnd)1114 void MApi_XC_DLC_InitCurve_U2(void * pInstance,MS_U16 u16HStart,MS_U16 u16HEnd,MS_U16 u16VStart,MS_U16 u16VEnd)
1115 {
1116 Dlc_FuncEnter();
1117 MDrv_DLC_InitCurve ( u16HStart, u16HEnd, u16VStart, u16VEnd );
1118 Dlc_FuncExit();
1119 }
1120
MApi_XC_DLC_InitCurve(MS_U16 u16HStart,MS_U16 u16HEnd,MS_U16 u16VStart,MS_U16 u16VEnd)1121 void MApi_XC_DLC_InitCurve (MS_U16 u16HStart, MS_U16 u16HEnd, MS_U16 u16VStart, MS_U16 u16VEnd)
1122 {
1123 if (pu32DLCInst == NULL)
1124 {
1125 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1126 {
1127 printf("UtopiaOpen DLC failed\n");
1128 return ;
1129 }
1130 }
1131
1132 stDLC_InitCurve DLCArgs;
1133 DLCArgs.u16HStart = u16HStart;
1134 DLCArgs.u16HEnd = u16HEnd;
1135 DLCArgs.u16VStart = u16VStart;
1136 DLCArgs.u16VEnd = u16VEnd;
1137
1138 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1139 // instead of 0
1140 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_INIT_CURVE, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1141 {
1142 printf("Obtain DLC engine fail\n");
1143 }
1144
1145 return ;
1146 }
1147
1148
MApi_XC_DLC_SpeedupTrigger_U2(void * pInstance,MS_U8 u8Loop)1149 void MApi_XC_DLC_SpeedupTrigger_U2(void * pInstance,MS_U8 u8Loop)
1150 {
1151 Dlc_FuncEnter();
1152 MDrv_DLC_SpeedupTrigger ( u8Loop );
1153 Dlc_FuncExit();
1154 }
1155
MApi_XC_DLC_SpeedupTrigger(MS_U8 u8Loop)1156 void MApi_XC_DLC_SpeedupTrigger (MS_U8 u8Loop)
1157 {
1158 if (pu32DLCInst == NULL)
1159 {
1160 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1161 {
1162 printf("UtopiaOpen DLC failed\n");
1163 return ;
1164 }
1165 }
1166
1167 stDLC_SpeedupTrigger DLCArgs;
1168 DLCArgs.u8Loop = u8Loop;
1169
1170 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1171 // instead of 0
1172 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_SPEEDUP_TRIGGER, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1173 {
1174 printf("Obtain DLC engine fail\n");
1175 }
1176
1177 return ;
1178 }
1179
1180
MApi_XC_DLC_GetLumaCurveStatus_U2(void * pInstance)1181 MS_BOOL MApi_XC_DLC_GetLumaCurveStatus_U2(void * pInstance)
1182 {
1183 MS_BOOL bResult;
1184
1185 Dlc_FuncEnter();
1186 bResult = MDrv_DLC_GetLumaCurveStatus();
1187 Dlc_FuncExit();
1188 return bResult;
1189 }
1190
MApi_XC_DLC_GetLumaCurveStatus(void)1191 MS_BOOL MApi_XC_DLC_GetLumaCurveStatus( void )
1192 {
1193 if (pu32DLCInst == NULL)
1194 {
1195 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1196 {
1197 printf("UtopiaOpen DLC failed\n");
1198 return FALSE;
1199 }
1200 }
1201
1202 stDLC_GetLumaCurveStatus DLCArgs;
1203 DLCArgs.bReturn = FALSE;
1204
1205 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1206 // instead of 0
1207 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_GET_LUMA_CURVE_STATUS, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1208 {
1209 printf("Obtain DLC engine fail\n");
1210 return FALSE;
1211 }
1212 else
1213 {
1214 return DLCArgs.bReturn;
1215 }
1216 }
1217
1218
MApi_XC_DLC_CGC_ResetCGain_U2(void * pInstance)1219 void MApi_XC_DLC_CGC_ResetCGain_U2(void * pInstance)
1220 {
1221 Dlc_FuncEnter();
1222 g_u8DLC_CGC_CGain_Backup = MDrv_DLC_CGC_GetCGain();
1223 MDrv_DLC_CGC_ResetCGain();
1224 Dlc_FuncExit();
1225 }
1226
MApi_XC_DLC_CGC_ResetCGain(void)1227 void MApi_XC_DLC_CGC_ResetCGain(void)
1228 {
1229 if (pu32DLCInst == NULL)
1230 {
1231 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1232 {
1233 printf("UtopiaOpen DLC failed\n");
1234 return ;
1235 }
1236 }
1237
1238 stDLC_CGC_ResetCGain DLCArgs;
1239
1240 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1241 // instead of 0
1242 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_CGC_RESET_C_GAIN, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1243 {
1244 printf("Obtain DLC engine fail\n");
1245 }
1246
1247 return ;
1248 }
1249
1250
MApi_XC_DLC_CGC_CheckCGainInPQCom_U2(void * pInstance)1251 void MApi_XC_DLC_CGC_CheckCGainInPQCom_U2(void * pInstance)
1252 {
1253 Dlc_FuncEnter();
1254 g_u8DLC_CGC_CGain = MDrv_DLC_CGC_GetCGain();
1255 if((g_u8DLC_CGC_CGain == 0xFF))
1256 {
1257 g_bDLC_CGC_CGainPQCom = FALSE;
1258 MDrv_DLC_CGC_SetCGain(g_u8DLC_CGC_CGain_Backup);
1259 g_u8DLC_CGC_CGain = g_u8DLC_CGC_CGain_Backup;
1260 }
1261 else
1262 {
1263 g_bDLC_CGC_CGainPQCom = TRUE;
1264 #if 0
1265 if(g_u8DLC_CGC_CGain == 0x00)
1266 {
1267 g_bDLC_CGC_CGainPQCom = TRUE;
1268 MDrv_DLC_CGC_SetCGain(g_u8DLC_CGC_CGain_Backup);
1269 g_u8DLC_CGC_CGain = g_u8DLC_CGC_CGain_Backup;
1270 }
1271 else
1272 {
1273 g_bDLC_CGC_CGainPQCom = FALSE;
1274 }
1275 #endif
1276 }
1277 Dlc_FuncExit();
1278 }
1279
MApi_XC_DLC_CGC_CheckCGainInPQCom(void)1280 void MApi_XC_DLC_CGC_CheckCGainInPQCom(void)
1281 {
1282 if (pu32DLCInst == NULL)
1283 {
1284 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1285 {
1286 printf("UtopiaOpen DLC failed\n");
1287 return ;
1288 }
1289 }
1290
1291 stDLC_CGC_CheckCGainInPQCom DLCArgs;
1292
1293 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1294 // instead of 0
1295 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_CGC_CHECK_C_GAIN_IN_PQ_COM, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1296 {
1297 printf("Obtain DLC engine fail\n");
1298 }
1299
1300 return ;
1301 }
1302
1303
MApi_XC_DLC_CGC_ResetYGain_U2(void * pInstance)1304 void MApi_XC_DLC_CGC_ResetYGain_U2(void * pInstance)
1305 {
1306 Dlc_FuncEnter();
1307 g_u8DLC_CGC_YGain_Backup = MDrv_DLC_CGC_GetYGain();
1308 MDrv_DLC_CGC_ResetYGain();
1309 Dlc_FuncExit();
1310 }
1311
MApi_XC_DLC_CGC_ResetYGain(void)1312 void MApi_XC_DLC_CGC_ResetYGain(void)
1313 {
1314 if (pu32DLCInst == NULL)
1315 {
1316 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1317 {
1318 printf("UtopiaOpen DLC failed\n");
1319 return ;
1320 }
1321 }
1322
1323 stDLC_CGC_ResetYGain DLCArgs;
1324
1325 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1326 // instead of 0
1327 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_CGC_RESET_Y_GAIN, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1328 {
1329 printf("Obtain DLC engine fail\n");
1330 }
1331
1332 return ;
1333 }
1334
1335
MApi_XC_DLC_CGC_CheckYGainInPQCom_U2(void * pInstance)1336 void MApi_XC_DLC_CGC_CheckYGainInPQCom_U2(void * pInstance)
1337 {
1338 Dlc_FuncEnter();
1339 g_u8DLC_CGC_YGain = MDrv_DLC_CGC_GetYGain();
1340 if((g_u8DLC_CGC_YGain == 0xFF))
1341 {
1342 g_bDLC_CGC_YGainPQCom = FALSE;
1343 MDrv_DLC_CGC_SetYGain(g_u8DLC_CGC_YGain_Backup);
1344 g_u8DLC_CGC_YGain = g_u8DLC_CGC_YGain_Backup;
1345 }
1346 else
1347 {
1348 g_bDLC_CGC_YGainPQCom = TRUE;
1349 #if 0
1350 if(g_u8DLC_CGC_YGain == 0x00)
1351 {
1352 g_bDLC_CGC_YGainPQCom = TRUE;
1353 MDrv_DLC_CGC_SetYGain(g_u8DLC_CGC_YGain_Backup);
1354 g_u8DLC_CGC_YGain = g_u8DLC_CGC_YGain_Backup;
1355 }
1356 else
1357 {
1358 g_bDLC_CGC_YGainPQCom = FALSE;
1359 }
1360 #endif
1361 }
1362 Dlc_FuncExit();
1363 }
1364
MApi_XC_DLC_CGC_CheckYGainInPQCom(void)1365 void MApi_XC_DLC_CGC_CheckYGainInPQCom(void)
1366 {
1367 if (pu32DLCInst == NULL)
1368 {
1369 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1370 {
1371 printf("UtopiaOpen DLC failed\n");
1372 return ;
1373 }
1374 }
1375
1376 stDLC_CGC_CheckYGainInPQCom DLCArgs;
1377
1378 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1379 // instead of 0
1380 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_CGC_CHECK_Y_GAIN_IN_PQ_COM, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1381 {
1382 printf("Obtain DLC engine fail\n");
1383 }
1384
1385 return ;
1386 }
1387
1388
MApi_XC_DLC_CGC_Reset_U2(void * pInstance)1389 void MApi_XC_DLC_CGC_Reset_U2(void * pInstance)
1390 {
1391 g_bDLC_CGC_ready = FALSE;
1392 }
1393
MApi_XC_DLC_CGC_Reset(void)1394 void MApi_XC_DLC_CGC_Reset(void)
1395 {
1396 if (pu32DLCInst == NULL)
1397 {
1398 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1399 {
1400 printf("UtopiaOpen DLC failed\n");
1401 return ;
1402 }
1403 }
1404
1405 stDLC_CGC_Reset DLCArgs;
1406
1407 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1408 // instead of 0
1409 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_CGC_RESET, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1410 {
1411 printf("Obtain DLC engine fail\n");
1412 }
1413
1414 return ;
1415 }
1416
1417
MApi_XC_DLC_CGC_Init_U2(void * pInstance)1418 void MApi_XC_DLC_CGC_Init_U2(void * pInstance)
1419 {
1420 Dlc_FuncEnter();
1421 if(g_bDLC_CGC_CGainPQCom)
1422 {
1423 msDlc_CGC_SetGain(g_u8DLC_CGC_CGain); //MDrv_DLC_CGC_SetCGain(g_u8DLC_CGC_CGain);
1424 }
1425 g_bDLC_CGC_ready = TRUE;
1426 MDrv_DLC_CGC_Init();
1427 Dlc_FuncExit();
1428 }
1429
MApi_XC_DLC_CGC_Init(void)1430 void MApi_XC_DLC_CGC_Init(void)
1431 {
1432 if (pu32DLCInst == NULL)
1433 {
1434 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1435 {
1436 printf("UtopiaOpen DLC failed\n");
1437 return ;
1438 }
1439 }
1440
1441 stDLC_CGC_Init DLCArgs;
1442
1443 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1444 // instead of 0
1445 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_CGC_INIT, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1446 {
1447 printf("Obtain DLC engine fail\n");
1448 }
1449
1450 return ;
1451 }
1452
1453
MApi_XC_DLC_CGC_ReInit_U2(void * pInstance)1454 void MApi_XC_DLC_CGC_ReInit_U2(void * pInstance)
1455 {
1456 Dlc_FuncEnter();
1457 MDrv_DLC_CGC_ReInit();
1458 Dlc_FuncExit();
1459 }
1460
MApi_XC_DLC_CGC_ReInit(void)1461 void MApi_XC_DLC_CGC_ReInit(void)
1462 {
1463 if (pu32DLCInst == NULL)
1464 {
1465 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1466 {
1467 printf("UtopiaOpen DLC failed\n");
1468 return ;
1469 }
1470 }
1471
1472 stDLC_CGC_ReInit DLCArgs;
1473
1474 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1475 // instead of 0
1476 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_CGC_REINIT, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1477 {
1478 printf("Obtain DLC engine fail\n");
1479 }
1480
1481 return ;
1482 }
1483
1484
MApi_XC_DLC_CGC_Handler_U2(void * pInstance)1485 void MApi_XC_DLC_CGC_Handler_U2(void * pInstance)
1486 {
1487 Dlc_FuncEnter();
1488 if(g_bDLC_CGC_ready)
1489 {
1490 MDrv_DLC_CGC_Handler();
1491 }
1492 Dlc_FuncExit();
1493 }
1494
1495
MApi_XC_DLC_CGC_Handler(void)1496 void MApi_XC_DLC_CGC_Handler(void)
1497 {
1498 if (pu32DLCInst == NULL)
1499 {
1500 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1501 {
1502 printf("UtopiaOpen DLC failed\n");
1503 return ;
1504 }
1505 }
1506
1507 stDLC_CGC_Handler DLCArgs;
1508
1509 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1510 // instead of 0
1511 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_CGC_HANDLER, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1512 {
1513 printf("Obtain DLC engine fail\n");
1514 }
1515
1516 return ;
1517 }
1518
1519
MApi_XC_DLC_GetLibVer_U2(void * pInstance,const MSIF_Version ** ppVersion)1520 E_XC_DLC_RESULT MApi_XC_DLC_GetLibVer_U2(void * pInstance,const MSIF_Version * * ppVersion)
1521 {
1522 if (!ppVersion)
1523 {
1524 return E_XC_DLC_FAIL;
1525 }
1526
1527 *ppVersion = &_api_xc_dlc_version;
1528 return E_XC_DLC_OK;
1529 }
1530
MApi_XC_DLC_GetLibVer(const MSIF_Version ** ppVersion)1531 E_XC_DLC_RESULT MApi_XC_DLC_GetLibVer(const MSIF_Version **ppVersion)
1532 {
1533 if (pu32DLCInst == NULL)
1534 {
1535 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1536 {
1537 printf("UtopiaOpen DLC failed\n");
1538 return E_XC_DLC_FAIL;
1539 }
1540 }
1541
1542 stDLC_GetLibVer DLCArgs;
1543 DLCArgs.ppVersion = ppVersion;
1544 DLCArgs.eResult = E_XC_DLC_FAIL;
1545 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1546 // instead of 0
1547 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_GET_LIB_VER, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1548 {
1549 printf("Obtain DLC engine fail\n");
1550 return E_XC_DLC_FAIL;
1551 }
1552 else
1553 {
1554 return DLCArgs.eResult;
1555 }
1556 }
1557
1558
MApi_XC_DLC_GetInfo_U2(void * pInstance)1559 const XC_DLC_ApiInfo * MApi_XC_DLC_GetInfo_U2(void * pInstance) ///< Get info from driver
1560 {
1561 return &_stXC_DLC_ApiInfo;
1562 }
1563
MApi_XC_DLC_GetInfo(void)1564 const XC_DLC_ApiInfo * MApi_XC_DLC_GetInfo(void) ///< Get info from driver
1565 {
1566 if (pu32DLCInst == NULL)
1567 {
1568 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1569 {
1570 printf("UtopiaOpen DLC failed\n");
1571 return 0;
1572 }
1573 }
1574
1575 stDLC_GetInfo DLCArgs;
1576 DLCArgs.eResult=0;
1577
1578 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1579 // instead of 0
1580 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_GET_INFO, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1581 {
1582 printf("Obtain DLC engine fail\n");
1583 return 0;
1584 }
1585 else
1586 {
1587 return DLCArgs.eResult;
1588 }
1589 }
1590
1591
MApi_XC_DLC_GetStatus_Ex_U2(void * pInstance,XC_DLC_ApiStatus * pDrvStatus,MS_BOOL bWindow)1592 MS_BOOL MApi_XC_DLC_GetStatus_Ex_U2(void * pInstance,XC_DLC_ApiStatus * pDrvStatus,MS_BOOL bWindow)
1593 {
1594 MS_U8 i;
1595 StuDlc_FinetuneParamaters DLC_MFinit;
1596 // StuDbc_FinetuneParamaters_Lib DLC_DBC_MFinit;
1597 DLC_LUMADATA DLCLumaData;
1598
1599 Dlc_FuncEnter();
1600 if(bWindow == 0)
1601 {
1602 MDrv_DLC_GetDLCInfo(&DLC_MFinit, sizeof(StuDlc_FinetuneParamaters));
1603 MDrv_DLC_GetLumaInfo( &DLCLumaData, sizeof(DLC_LUMADATA));
1604
1605 for (i=0; i<16; ++i)
1606 {
1607 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucLumaCurve[i] = DLC_MFinit.ucLumaCurve[i];
1608 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucLumaCurve2_a[i] = DLC_MFinit.ucLumaCurve2_a[i];
1609 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucLumaCurve2_b[i] = DLC_MFinit.ucLumaCurve2_b[i];
1610 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucLumaCurve2[i] = DLC_MFinit.ucLumaCurve2[i];
1611 }
1612
1613 pDrvStatus->DLCinit.DLC_MFinit_Ex.u8_L_L_U = DLC_MFinit.u8_L_L_U;
1614 pDrvStatus->DLCinit.DLC_MFinit_Ex.u8_L_L_D = DLC_MFinit.u8_L_L_D;
1615 pDrvStatus->DLCinit.DLC_MFinit_Ex.u8_L_H_U = DLC_MFinit.u8_L_H_U;
1616 pDrvStatus->DLCinit.DLC_MFinit_Ex.u8_L_H_D = DLC_MFinit.u8_L_H_D;
1617 pDrvStatus->DLCinit.DLC_MFinit_Ex.u8_S_L_U = DLC_MFinit.u8_S_L_U;
1618 pDrvStatus->DLCinit.DLC_MFinit_Ex.u8_S_L_D = DLC_MFinit.u8_S_L_D;
1619 pDrvStatus->DLCinit.DLC_MFinit_Ex.u8_S_H_U = DLC_MFinit.u8_S_H_U;
1620 pDrvStatus->DLCinit.DLC_MFinit_Ex.u8_S_H_D = DLC_MFinit.u8_S_H_D ;
1621 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcPureImageMode = DLC_MFinit.ucDlcPureImageMode;
1622 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcLevelLimit = DLC_MFinit.ucDlcLevelLimit;
1623 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcAvgDelta = DLC_MFinit.ucDlcAvgDelta;
1624 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcAvgDeltaStill = DLC_MFinit.ucDlcAvgDeltaStill;
1625 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcFastAlphaBlending = DLC_MFinit.ucDlcFastAlphaBlending;
1626 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcSlowEvent = DLC_MFinit.ucDlcSlowEvent;
1627 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcTimeOut = DLC_MFinit.ucDlcTimeOut;
1628 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcFlickAlphaStart = DLC_MFinit.ucDlcFlickAlphaStart;
1629 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcYAvgThresholdH = DLC_MFinit.ucDlcYAvgThresholdH;
1630 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcYAvgThresholdL = DLC_MFinit.ucDlcYAvgThresholdL;
1631 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcBLEPoint = DLC_MFinit.ucDlcBLEPoint;
1632 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcWLEPoint = DLC_MFinit.ucDlcWLEPoint;
1633 pDrvStatus->DLCinit.DLC_MFinit_Ex.bEnableBLE = DLC_MFinit.bEnableBLE;
1634 pDrvStatus->DLCinit.DLC_MFinit_Ex.bEnableWLE = DLC_MFinit.bEnableWLE;
1635
1636 if(pDrvStatus->DLCinit.DLC_MFinit_Ex.u32DLC_MFinit_Ex_Version>=1)
1637 {
1638 for (i=0; i<DLC_HISTOGRAM_LIMIT_CURVE_ARRARY_NUM; ++i)
1639 {
1640 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcHistogramLimitCurve[i] = DLC_MFinit.ucDlcHistogramLimitCurve[i];
1641 }
1642
1643 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcYAvgThresholdM = DLC_MFinit.ucDlcYAvgThresholdM;
1644 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcCurveMode = DLC_MFinit.ucDlcCurveMode;
1645 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcCurveModeMixAlpha = DLC_MFinit.ucDlcCurveModeMixAlpha;
1646 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcAlgorithmMode = DLC_MFinit.ucDlcAlgorithmMode;
1647 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcSepPointH = DLC_MFinit.ucDlcSepPointH;
1648 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcSepPointL = DLC_MFinit.ucDlcSepPointL;
1649 pDrvStatus->DLCinit.DLC_MFinit_Ex.uwDlcBleStartPointTH = DLC_MFinit.uwDlcBleStartPointTH;
1650 pDrvStatus->DLCinit.DLC_MFinit_Ex.uwDlcBleEndPointTH = DLC_MFinit.uwDlcBleEndPointTH;
1651 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcCurveDiff_L_TH = DLC_MFinit.ucDlcCurveDiff_L_TH;
1652 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcCurveDiff_H_TH = DLC_MFinit.ucDlcCurveDiff_H_TH;
1653 pDrvStatus->DLCinit.DLC_MFinit_Ex.uwDlcBLESlopPoint_1 = DLC_MFinit.uwDlcBLESlopPoint_1;
1654 pDrvStatus->DLCinit.DLC_MFinit_Ex.uwDlcBLESlopPoint_2 = DLC_MFinit.uwDlcBLESlopPoint_2;
1655 pDrvStatus->DLCinit.DLC_MFinit_Ex.uwDlcBLESlopPoint_3 = DLC_MFinit.uwDlcBLESlopPoint_3;
1656 pDrvStatus->DLCinit.DLC_MFinit_Ex.uwDlcBLESlopPoint_4 = DLC_MFinit.uwDlcBLESlopPoint_4;
1657 pDrvStatus->DLCinit.DLC_MFinit_Ex.uwDlcBLESlopPoint_5 = DLC_MFinit.uwDlcBLESlopPoint_5;
1658 pDrvStatus->DLCinit.DLC_MFinit_Ex.uwDlcDark_BLE_Slop_Min = DLC_MFinit.uwDlcDark_BLE_Slop_Min;
1659 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcCurveDiffCoringTH = DLC_MFinit.ucDlcCurveDiffCoringTH;
1660 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcAlphaBlendingMin = DLC_MFinit.ucDlcAlphaBlendingMin;
1661 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcAlphaBlendingMax = DLC_MFinit.ucDlcAlphaBlendingMax;
1662 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcFlicker_alpha = DLC_MFinit.ucDlcFlicker_alpha;
1663 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcYAVG_L_TH = DLC_MFinit.ucDlcYAVG_L_TH;
1664 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcYAVG_H_TH = DLC_MFinit.ucDlcYAVG_H_TH;
1665
1666 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcDiffBase_L = DLC_MFinit.ucDlcDiffBase_L;
1667 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcDiffBase_M = DLC_MFinit.ucDlcDiffBase_M;
1668 pDrvStatus->DLCinit.DLC_MFinit_Ex.ucDlcDiffBase_H = DLC_MFinit.ucDlcDiffBase_H;
1669 }
1670
1671 for(i=0; i<32; i++)
1672 {
1673 pDrvStatus->DLCluma.g_wLumaHistogram32H[i] = DLCLumaData.g_wLumaHistogram32H[i];
1674 }
1675 for(i=0; i<16; i++)
1676 {
1677 pDrvStatus->DLCluma.g_ucTable[i] = DLCLumaData.g_ucTable[i];
1678 }
1679 pDrvStatus->DLCluma.g_wLumiTotalCount = DLCLumaData.g_wLumiTotalCount;
1680 pDrvStatus->DLCluma.g_wLumiAverageTemp = DLCLumaData.g_wLumiAverageTemp;
1681 pDrvStatus->DLCluma.g_ucHistogramMax = DLCLumaData.g_ucHistogramMax;
1682 pDrvStatus->DLCluma.g_ucHistogramMin = DLCLumaData.g_ucHistogramMin;
1683 pDrvStatus->u16DLC_MFVer = MDrv_DLC_GetMFVer();
1684 pDrvStatus->u16DLC_CGC_MFVer = MDrv_DLC_CGC_GetMFVer();
1685
1686 // get DBC Info, this function has problem, mark out temprary
1687 //MDrv_DLC_GetDBCInfo( &DLC_DBC_MFinit, sizeof(StuDbc_FinetuneParamaters_Lib));
1688 pDrvStatus->u16DLC_DBC_MFVer = MDrv_DLC_DBC_GetMFVer();
1689 }
1690 Dlc_FuncExit();
1691 return TRUE;
1692 }
1693
MApi_XC_DLC_GetStatus_Ex(XC_DLC_ApiStatus * pDrvStatus,MS_BOOL bWindow)1694 MS_BOOL MApi_XC_DLC_GetStatus_Ex(XC_DLC_ApiStatus *pDrvStatus, MS_BOOL bWindow)
1695 {
1696 if (pu32DLCInst == NULL)
1697 {
1698 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1699 {
1700 printf("UtopiaOpen DLC failed\n");
1701 return FALSE;
1702 }
1703 }
1704
1705 stDLC_GetStatus_Ex DLCArgs;
1706 DLCArgs.pDrvStatus = pDrvStatus;
1707 DLCArgs.bWindow = bWindow;
1708 DLCArgs.bReturn =FALSE;
1709 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1710 // instead of 0
1711 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_GET_STATUS_EX, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1712 {
1713 printf("Obtain DLC engine fail\n");
1714 return FALSE;
1715 }
1716 else
1717 {
1718 return DLCArgs.bReturn;
1719 }
1720 }
1721
1722
MApi_XC_DLC_SetDbgLevel_U2(void * pInstance,MS_U16 u16DbgSwitch)1723 MS_BOOL MApi_XC_DLC_SetDbgLevel_U2(void * pInstance,MS_U16 u16DbgSwitch)
1724 {
1725 UNUSED(u16DbgSwitch);
1726 //_u16XC_DLCDbgSwitch = u16DbgSwitch;
1727 // _u16XC_DLCDbgSwitch = _u16XC_DLCDbgSwitch;
1728 return TRUE;
1729 }
1730
MApi_XC_DLC_SetDbgLevel(MS_U16 u16DbgSwitch)1731 MS_BOOL MApi_XC_DLC_SetDbgLevel(MS_U16 u16DbgSwitch)
1732 {
1733 if (pu32DLCInst == NULL)
1734 {
1735 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1736 {
1737 printf("UtopiaOpen DLC failed\n");
1738 return FALSE;
1739 }
1740 }
1741
1742 stDLC_SetDbgLevel DLCArgs;
1743 DLCArgs.u16DbgSwitch = u16DbgSwitch;
1744 DLCArgs.bReturn =FALSE;
1745 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1746 // instead of 0
1747 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_SET_DBG_LEVEL, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1748 {
1749 printf("Obtain DLC engine fail\n");
1750 return FALSE;
1751 }
1752 else
1753 {
1754 return DLCArgs.bReturn;
1755 }
1756 }
1757
1758
MApi_XC_DLC_WriteCurve_U2(void * pInstance,MS_U8 * pu8Table)1759 MS_BOOL MApi_XC_DLC_WriteCurve_U2(void * pInstance,MS_U8 * pu8Table)
1760 {
1761 Dlc_FuncEnter();
1762 MDrv_DLC_WriteCurve(pu8Table);
1763 Dlc_FuncExit();
1764 return TRUE;
1765 }
1766
MApi_XC_DLC_WriteCurve(MS_U8 * pu8Table)1767 MS_BOOL MApi_XC_DLC_WriteCurve(MS_U8 *pu8Table)
1768 {
1769 if (pu32DLCInst == NULL)
1770 {
1771 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1772 {
1773 printf("UtopiaOpen DLC failed\n");
1774 return FALSE;
1775 }
1776 }
1777
1778 stDLC_WriteCurve DLCArgs;
1779 DLCArgs.pu8Table = pu8Table;
1780 DLCArgs.bReturn =FALSE;
1781 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1782 // instead of 0
1783 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_WRITE_CURVE, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1784 {
1785 printf("Obtain DLC engine fail\n");
1786 return FALSE;
1787 }
1788 else
1789 {
1790 return DLCArgs.bReturn;
1791 }
1792 }
1793
1794
MApi_XC_DLC_WriteCurve_Sub_U2(void * pInstance,MS_U8 * pu8Table)1795 MS_BOOL MApi_XC_DLC_WriteCurve_Sub_U2(void * pInstance,MS_U8 * pu8Table)
1796 {
1797 Dlc_FuncEnter();
1798 MDrv_DLC_WriteCurve_Sub(pu8Table);
1799 Dlc_FuncExit();
1800 return TRUE;
1801 }
1802
MApi_XC_DLC_WriteCurve_Sub(MS_U8 * pu8Table)1803 MS_BOOL MApi_XC_DLC_WriteCurve_Sub(MS_U8 *pu8Table)
1804 {
1805 if (pu32DLCInst == NULL)
1806 {
1807 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1808 {
1809 printf("UtopiaOpen DLC failed\n");
1810 return FALSE;
1811 }
1812 }
1813
1814 stDLC_WriteCurve_Sub DLCArgs;
1815 DLCArgs.pu8Table = pu8Table;
1816 DLCArgs.bReturn =FALSE;
1817 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1818 // instead of 0
1819 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_WRITE_CURVE_SUB, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1820 {
1821 printf("Obtain DLC engine fail\n");
1822 return FALSE;
1823 }
1824 else
1825 {
1826 return DLCArgs.bReturn;
1827 }
1828 }
1829
1830
MApi_XC_DLC_GetHistogram_U2(void * pInstance,MS_U16 * pu16Histogram,E_XC_DLC_HISTOGRAM_TYPE enHistogramType)1831 MS_BOOL MApi_XC_DLC_GetHistogram_U2(void * pInstance,MS_U16 * pu16Histogram,E_XC_DLC_HISTOGRAM_TYPE enHistogramType)
1832 {
1833 MS_BOOL bret = FALSE;
1834
1835 Dlc_FuncEnter();
1836 if(enHistogramType == E_XC_DLC_HISTOGRAM_32)
1837 {
1838 bret = MDrv_DLC_get_histogram32(pu16Histogram);
1839 }
1840 Dlc_FuncExit();
1841 return bret;
1842 }
1843
MApi_XC_DLC_GetHistogram(MS_U16 * pu16Histogram,E_XC_DLC_HISTOGRAM_TYPE enHistogramType)1844 MS_BOOL MApi_XC_DLC_GetHistogram(MS_U16 *pu16Histogram, E_XC_DLC_HISTOGRAM_TYPE enHistogramType)
1845 {
1846 if (pu32DLCInst == NULL)
1847 {
1848 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1849 {
1850 printf("UtopiaOpen DLC failed\n");
1851 return FALSE;
1852 }
1853 }
1854
1855 stDLC_GetHistogram DLCArgs;
1856 DLCArgs.pu16Histogram = pu16Histogram;
1857 DLCArgs.enHistogramType = enHistogramType;
1858 DLCArgs.bReturn =FALSE;
1859 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1860 // instead of 0
1861 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_GET_HISTOGRAM, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1862 {
1863 printf("Obtain DLC engine fail\n");
1864 return FALSE;
1865 }
1866 else
1867 {
1868 return DLCArgs.bReturn;
1869 }
1870 }
1871
1872
1873 MS_U16 gu16PNL_Width = 0;
1874 MS_U16 gu16PNL_Height = 0;
1875 MApi_XC_DLC_Print_Callback gfnPutchar = NULL;
1876
MApi_XC_DLC_DecodeExtCmd_U2(void * pInstance,tDLC_CONTROL_PARAMS * params)1877 void MApi_XC_DLC_DecodeExtCmd_U2(void * pInstance,tDLC_CONTROL_PARAMS * params)
1878 {
1879 gu16PNL_Width = params->u16PNL_Width;
1880 gu16PNL_Height = params->u16PNL_Height;
1881 gfnPutchar = params->fnDLC_Putchar;
1882
1883 Dlc_FuncEnter();
1884
1885 msDLC_ParametersTool(params->pCmdBuff);
1886 Dlc_FuncExit();
1887 }
1888
MApi_XC_DLC_DecodeExtCmd(tDLC_CONTROL_PARAMS * params)1889 void MApi_XC_DLC_DecodeExtCmd(tDLC_CONTROL_PARAMS* params)
1890 {
1891 if (pu32DLCInst == NULL)
1892 {
1893 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1894 {
1895 printf("UtopiaOpen DLC failed\n");
1896 return ;
1897 }
1898 }
1899
1900 stDLC_DecodeExtCmd DLCArgs;
1901 DLCArgs.params = params;
1902
1903 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1904 // instead of 0
1905 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_DECODE_EXT_CMD, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1906 {
1907 printf("Obtain DLC engine fail\n");
1908 }
1909
1910 return ;
1911 }
1912
1913
MApi_XC_DLC_SetCaptureRange_U2(void * pInstance,XC_DLC_CAPTURE_Range * pu16_Range)1914 void MApi_XC_DLC_SetCaptureRange_U2(void * pInstance,XC_DLC_CAPTURE_Range * pu16_Range)
1915 {
1916 StuDbc_CAPTURE_Range DlcCapRange = {0};
1917
1918 memcpy(&DlcCapRange, pu16_Range,sizeof(XC_DLC_CAPTURE_Range));
1919
1920 Dlc_FuncEnter();
1921
1922 MDrv_DLC_set_CaptureRange(&DlcCapRange);
1923 Dlc_FuncExit();
1924
1925 }
1926
MApi_XC_DLC_SetCaptureRange(XC_DLC_CAPTURE_Range * pu16_Range)1927 void MApi_XC_DLC_SetCaptureRange(XC_DLC_CAPTURE_Range *pu16_Range)
1928 {
1929 if (pu32DLCInst == NULL)
1930 {
1931 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1932 {
1933 printf("UtopiaOpen DLC failed\n");
1934 return ;
1935 }
1936 }
1937
1938 stDLC_SetCaptureRange DLCArgs;
1939 DLCArgs.pu16_Range = pu16_Range;
1940
1941 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
1942 // instead of 0
1943 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_SET_CAPTURE_RANGE, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
1944 {
1945 printf("Obtain DLC engine fail\n");
1946 }
1947
1948 return ;
1949
1950 }
1951
1952
MApi_XC_DLC_Init_U2(void * pInstance,XC_DLC_init * pstXC_DLC_InitData,MS_U32 u32InitDataLen)1953 MS_BOOL MApi_XC_DLC_Init_U2(void * pInstance,XC_DLC_init * pstXC_DLC_InitData,MS_U32 u32InitDataLen)
1954 {
1955 MS_U8 i;
1956 StuDlc_FinetuneParamaters DLC_MFinit;
1957 MS_PHY u32NonPMBankSize = 0;
1958 MS_VIRT ptrDLCRiuBaseAddr=0;
1959 DLC_init_Ext DLC_InitExt;
1960
1961 // get MMIO base
1962 if(MDrv_MMIO_GetBASE( &ptrDLCRiuBaseAddr, &u32NonPMBankSize, MS_MODULE_PM ) != TRUE)
1963 {
1964 //OS_DELETE_MUTEX(_s32ACEMutex);
1965 //PNL_ASSERT(0, "%s\n", "Get base address failed\n");
1966 //printf("XC_DLC GetBase failed\n");
1967 return FALSE;
1968 }
1969 else
1970 {
1971 }
1972 memset(&DLC_InitExt, 0 , sizeof(DLC_InitExt) );
1973 MDrv_DLC_init_riu_base( ptrDLCRiuBaseAddr);
1974
1975 if(u32InitDataLen != sizeof(XC_DLC_init))
1976 {
1977 return FALSE;
1978 }
1979 memset(&DLC_MFinit, 0 , sizeof(DLC_MFinit) );
1980
1981 for (i=0; i<16; ++i)
1982 {
1983 DLC_InitExt.uwLumaCurve[i] = ((MS_U16)pstXC_DLC_InitData->DLC_MFinit.ucLumaCurve[i])<<2;
1984 DLC_InitExt.uwLumaCurve2_a[i] = ((MS_U16)pstXC_DLC_InitData->DLC_MFinit.ucLumaCurve2_a[i])<<2;
1985 DLC_InitExt.uwLumaCurve2_b[i] = ((MS_U16)pstXC_DLC_InitData->DLC_MFinit.ucLumaCurve2_b[i])<<2;
1986
1987 DLC_MFinit.ucLumaCurve[i] = pstXC_DLC_InitData->DLC_MFinit.ucLumaCurve[i];
1988 DLC_MFinit.ucLumaCurve2_a[i] = pstXC_DLC_InitData->DLC_MFinit.ucLumaCurve2_a[i];
1989 DLC_MFinit.ucLumaCurve2_b[i] = pstXC_DLC_InitData->DLC_MFinit.ucLumaCurve2_b[i];
1990 }
1991
1992 #if (ENABLE_10_BIT_DLC)
1993 DLC_InitExt.b10BitsCruveEn = pstXC_DLC_InitData->b10BitsEn;
1994 #else
1995 DLC_InitExt.b10BitsCruveEn = 0;
1996 #endif
1997
1998 DLC_MFinit.u8_L_L_U = pstXC_DLC_InitData->DLC_MFinit.u8_L_L_U;
1999 DLC_MFinit.u8_L_L_D = pstXC_DLC_InitData->DLC_MFinit.u8_L_L_D;
2000 DLC_MFinit.u8_L_H_U = pstXC_DLC_InitData->DLC_MFinit.u8_L_H_U;
2001 DLC_MFinit.u8_L_H_D = pstXC_DLC_InitData->DLC_MFinit.u8_L_H_D;
2002 DLC_MFinit.u8_S_L_U = pstXC_DLC_InitData->DLC_MFinit.u8_S_L_U;
2003 DLC_MFinit.u8_S_L_D = pstXC_DLC_InitData->DLC_MFinit.u8_S_L_D;
2004 DLC_MFinit.u8_S_H_U = pstXC_DLC_InitData->DLC_MFinit.u8_S_H_U;
2005 DLC_MFinit.u8_S_H_D = pstXC_DLC_InitData->DLC_MFinit.u8_S_H_D ;
2006
2007 DLC_MFinit.ucDlcPureImageMode = pstXC_DLC_InitData->DLC_MFinit.ucDlcPureImageMode;
2008 DLC_MFinit.ucDlcLevelLimit = pstXC_DLC_InitData->DLC_MFinit.ucDlcLevelLimit;
2009 DLC_MFinit.ucDlcAvgDelta = pstXC_DLC_InitData->DLC_MFinit.ucDlcAvgDelta;
2010 DLC_MFinit.ucDlcAvgDeltaStill = pstXC_DLC_InitData->DLC_MFinit.ucDlcAvgDeltaStill;
2011 DLC_MFinit.ucDlcFastAlphaBlending = pstXC_DLC_InitData->DLC_MFinit.ucDlcFastAlphaBlending;
2012 DLC_MFinit.ucDlcYAvgThresholdL = pstXC_DLC_InitData->DLC_MFinit.ucDlcYAvgThresholdL;
2013 DLC_MFinit.ucDlcYAvgThresholdH = pstXC_DLC_InitData->DLC_MFinit.ucDlcYAvgThresholdH;
2014 DLC_MFinit.ucDlcBLEPoint = pstXC_DLC_InitData->DLC_MFinit.ucDlcBLEPoint;
2015 DLC_MFinit.ucDlcWLEPoint = pstXC_DLC_InitData->DLC_MFinit.ucDlcWLEPoint;
2016 DLC_MFinit.bEnableBLE = pstXC_DLC_InitData->DLC_MFinit.bEnableBLE;
2017 DLC_MFinit.bEnableWLE = pstXC_DLC_InitData->DLC_MFinit.bEnableWLE;
2018 DLC_MFinit.ucCGCYth = pstXC_DLC_InitData->DLC_MFinit.ucCGCYth;
2019 DLC_MFinit.bCGCCGainCtrl = pstXC_DLC_InitData->DLC_MFinit.bCGCCGainCtrl;
2020
2021 // CGC
2022 DLC_MFinit.ucCGCCGain_offset = pstXC_DLC_InitData->DLC_MFinit.ucCGCCGain_offset;
2023 DLC_MFinit.ucCGCChroma_GainLimitH = pstXC_DLC_InitData->DLC_MFinit.ucCGCChroma_GainLimitH;
2024 DLC_MFinit.ucCGCChroma_GainLimitL = pstXC_DLC_InitData->DLC_MFinit.ucCGCChroma_GainLimitL;
2025 DLC_MFinit.ucCGCYCslope = pstXC_DLC_InitData->DLC_MFinit.ucCGCYCslope;
2026
2027 MDrv_DLC_Init(DLC_MFinit);
2028 MDrv_DLC_Init_Ext(&DLC_InitExt);
2029
2030 g_DlcCapRange_Suspend.wHStart = pstXC_DLC_InitData->u16CurveHStart;
2031 g_DlcCapRange_Suspend.wHEnd = pstXC_DLC_InitData->u16CurveHEnd;
2032 g_DlcCapRange_Suspend.wVStart = pstXC_DLC_InitData->u16CurveVStart;
2033 g_DlcCapRange_Suspend.wVEnd = pstXC_DLC_InitData->u16CurveVEnd;
2034
2035 Dlc_FuncEnter();
2036 MDrv_DLC_InitCurve (pstXC_DLC_InitData->u16CurveHStart, pstXC_DLC_InitData->u16CurveHEnd, pstXC_DLC_InitData->u16CurveVStart, pstXC_DLC_InitData->u16CurveVEnd);
2037 Dlc_FuncExit();
2038
2039 return TRUE;
2040 }
2041
MApi_XC_DLC_Init(XC_DLC_init * pstXC_DLC_InitData,MS_U32 u32InitDataLen)2042 MS_BOOL MApi_XC_DLC_Init(XC_DLC_init *pstXC_DLC_InitData, MS_U32 u32InitDataLen)
2043 {
2044 if (pu32DLCInst == NULL)
2045 {
2046 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2047 {
2048 printf("UtopiaOpen DLC failed\n");
2049 return FALSE;
2050 }
2051 }
2052
2053 stDLC_Init DLCArgs;
2054 DLCArgs.pstXC_DLC_InitData = pstXC_DLC_InitData;
2055 DLCArgs.u32InitDataLen = u32InitDataLen;
2056 DLCArgs.bReturn =FALSE;
2057 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2058 // instead of 0
2059 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_INIT, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
2060 {
2061 printf("Obtain DLC engine fail\n");
2062 return FALSE;
2063 }
2064 else
2065 {
2066 return DLCArgs.bReturn;
2067 }
2068 }
2069
2070
2071 //-------------------------------------------------------------------------------------------------
2072 /// Setting DLC
2073 // @param DLC_MFinit \b IN: DLC data
2074 //-------------------------------------------------------------------------------------------------
MApi_XC_DLC_SetSetting_U2(void * pInstance,XC_DLC_MFinit DLC_MFinit)2075 void MApi_XC_DLC_SetSetting_U2(void * pInstance,XC_DLC_MFinit DLC_MFinit)
2076 {
2077
2078 MS_U8 i;
2079 StuDlc_FinetuneParamaters DLC_MFinit_new;
2080
2081 memset(&DLC_MFinit_new, 0 , sizeof(DLC_MFinit_new) );
2082 for (i=0; i<16; ++i)
2083 {
2084 DLC_MFinit_new.ucLumaCurve[i] = DLC_MFinit.ucLumaCurve[i];
2085 DLC_MFinit_new.ucLumaCurve2_a[i] = DLC_MFinit.ucLumaCurve2_a[i];
2086 DLC_MFinit_new.ucLumaCurve2_b[i] = DLC_MFinit.ucLumaCurve2_b[i];
2087 }
2088
2089 DLC_MFinit_new.u8_L_L_U = DLC_MFinit.u8_L_L_U;
2090 DLC_MFinit_new.u8_L_L_D = DLC_MFinit.u8_L_L_D;
2091 DLC_MFinit_new.u8_L_H_U = DLC_MFinit.u8_L_H_U;
2092 DLC_MFinit_new.u8_L_H_D = DLC_MFinit.u8_L_H_D;
2093 DLC_MFinit_new.u8_S_L_U = DLC_MFinit.u8_S_L_U;
2094 DLC_MFinit_new.u8_S_L_D = DLC_MFinit.u8_S_L_D;
2095 DLC_MFinit_new.u8_S_H_U = DLC_MFinit.u8_S_H_U;
2096 DLC_MFinit_new.u8_S_H_D = DLC_MFinit.u8_S_H_D ;
2097
2098 DLC_MFinit_new.ucDlcPureImageMode = DLC_MFinit.ucDlcPureImageMode;
2099 DLC_MFinit_new.ucDlcLevelLimit = DLC_MFinit.ucDlcLevelLimit;
2100 DLC_MFinit_new.ucDlcAvgDelta = DLC_MFinit.ucDlcAvgDelta;
2101 DLC_MFinit_new.ucDlcAvgDeltaStill = DLC_MFinit.ucDlcAvgDeltaStill;
2102 DLC_MFinit_new.ucDlcFastAlphaBlending = DLC_MFinit.ucDlcFastAlphaBlending;
2103 DLC_MFinit_new.ucDlcYAvgThresholdL = DLC_MFinit.ucDlcYAvgThresholdL;
2104 DLC_MFinit_new.ucDlcYAvgThresholdH = DLC_MFinit.ucDlcYAvgThresholdH;
2105 DLC_MFinit_new.ucDlcBLEPoint = DLC_MFinit.ucDlcBLEPoint;
2106 DLC_MFinit_new.ucDlcWLEPoint = DLC_MFinit.ucDlcWLEPoint;
2107 DLC_MFinit_new.bEnableBLE = DLC_MFinit.bEnableBLE;
2108 DLC_MFinit_new.bEnableWLE = DLC_MFinit.bEnableWLE;
2109
2110 DLC_MFinit_new.ucCGCYth = DLC_MFinit.ucCGCYth;
2111 DLC_MFinit_new.bCGCCGainCtrl = DLC_MFinit.bCGCCGainCtrl;
2112
2113 // CGC
2114 DLC_MFinit_new.ucCGCCGain_offset = DLC_MFinit.ucCGCCGain_offset;
2115 DLC_MFinit_new.ucCGCChroma_GainLimitH = DLC_MFinit.ucCGCChroma_GainLimitH;
2116 DLC_MFinit_new.ucCGCChroma_GainLimitL = DLC_MFinit.ucCGCChroma_GainLimitL;
2117 DLC_MFinit_new.ucCGCYCslope = DLC_MFinit.ucCGCYCslope;
2118
2119 MDrv_DLC_Init(DLC_MFinit_new);
2120 }
2121
MApi_XC_DLC_SetSetting(XC_DLC_MFinit DLC_MFinit)2122 void MApi_XC_DLC_SetSetting(XC_DLC_MFinit DLC_MFinit)
2123 {
2124 if (pu32DLCInst == NULL)
2125 {
2126 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2127 {
2128 printf("UtopiaOpen DLC failed\n");
2129 return ;
2130 }
2131 }
2132
2133 stDLC_SetSetting DLCArgs;
2134 DLCArgs.DLC_MFinit = DLC_MFinit;
2135
2136 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2137 // instead of 0
2138 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_SET_SETTING, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
2139 {
2140 printf("Obtain DLC engine fail\n");
2141 }
2142
2143 return ;
2144 }
2145
2146
MApi_XC_DLC_GetStatus_U2(void * pInstance,XC_DLC_ApiStatus * pDrvStatus,MS_BOOL bWindow)2147 MS_BOOL MApi_XC_DLC_GetStatus_U2(void * pInstance,XC_DLC_ApiStatus * pDrvStatus,MS_BOOL bWindow)
2148 {
2149 MS_U8 i;
2150 StuDlc_FinetuneParamaters DLC_MFinit;
2151 // StuDbc_FinetuneParamaters_Lib DLC_DBC_MFinit;
2152 DLC_LUMADATA DLCLumaData;
2153
2154 Dlc_FuncEnter();
2155 if(bWindow == 0)
2156 {
2157 MDrv_DLC_GetDLCInfo(&DLC_MFinit, sizeof(StuDlc_FinetuneParamaters));
2158 MDrv_DLC_GetLumaInfo( &DLCLumaData, sizeof(DLC_LUMADATA));
2159
2160 for (i=0; i<16; ++i)
2161 {
2162 pDrvStatus->DLCinit.DLC_MFinit.ucLumaCurve[i] = DLC_MFinit.ucLumaCurve[i];
2163 pDrvStatus->DLCinit.DLC_MFinit.ucLumaCurve2_a[i] = DLC_MFinit.ucLumaCurve2_a[i];
2164 pDrvStatus->DLCinit.DLC_MFinit.ucLumaCurve2_b[i] = DLC_MFinit.ucLumaCurve2_b[i];
2165 pDrvStatus->DLCinit.DLC_MFinit.ucLumaCurve2[i] = DLC_MFinit.ucLumaCurve2[i];
2166 }
2167
2168 pDrvStatus->DLCinit.DLC_MFinit.u8_L_L_U = DLC_MFinit.u8_L_L_U;
2169 pDrvStatus->DLCinit.DLC_MFinit.u8_L_L_D = DLC_MFinit.u8_L_L_D;
2170 pDrvStatus->DLCinit.DLC_MFinit.u8_L_H_U = DLC_MFinit.u8_L_H_U;
2171 pDrvStatus->DLCinit.DLC_MFinit.u8_L_H_D = DLC_MFinit.u8_L_H_D;
2172 pDrvStatus->DLCinit.DLC_MFinit.u8_S_L_U = DLC_MFinit.u8_S_L_U;
2173 pDrvStatus->DLCinit.DLC_MFinit.u8_S_L_D = DLC_MFinit.u8_S_L_D;
2174 pDrvStatus->DLCinit.DLC_MFinit.u8_S_H_U = DLC_MFinit.u8_S_H_U;
2175 pDrvStatus->DLCinit.DLC_MFinit.u8_S_H_D = DLC_MFinit.u8_S_H_D ;
2176 pDrvStatus->DLCinit.DLC_MFinit.ucDlcPureImageMode = DLC_MFinit.ucDlcPureImageMode;
2177 pDrvStatus->DLCinit.DLC_MFinit.ucDlcLevelLimit = DLC_MFinit.ucDlcLevelLimit;
2178 pDrvStatus->DLCinit.DLC_MFinit.ucDlcAvgDelta = DLC_MFinit.ucDlcAvgDelta;
2179 pDrvStatus->DLCinit.DLC_MFinit.ucDlcAvgDeltaStill = DLC_MFinit.ucDlcAvgDeltaStill;
2180 pDrvStatus->DLCinit.DLC_MFinit.ucDlcFastAlphaBlending = DLC_MFinit.ucDlcFastAlphaBlending;
2181 pDrvStatus->DLCinit.DLC_MFinit.ucDlcSlowEvent = DLC_MFinit.ucDlcSlowEvent;
2182 pDrvStatus->DLCinit.DLC_MFinit.ucDlcTimeOut = DLC_MFinit.ucDlcTimeOut;
2183 pDrvStatus->DLCinit.DLC_MFinit.ucDlcFlickAlphaStart = DLC_MFinit.ucDlcFlickAlphaStart;
2184 pDrvStatus->DLCinit.DLC_MFinit.ucDlcYAvgThresholdH = DLC_MFinit.ucDlcYAvgThresholdH;
2185 pDrvStatus->DLCinit.DLC_MFinit.ucDlcYAvgThresholdL = DLC_MFinit.ucDlcYAvgThresholdL;
2186 pDrvStatus->DLCinit.DLC_MFinit.ucDlcBLEPoint = DLC_MFinit.ucDlcBLEPoint;
2187 pDrvStatus->DLCinit.DLC_MFinit.ucDlcWLEPoint = DLC_MFinit.ucDlcWLEPoint;
2188 pDrvStatus->DLCinit.DLC_MFinit.bEnableBLE = DLC_MFinit.bEnableBLE;
2189 pDrvStatus->DLCinit.DLC_MFinit.bEnableWLE = DLC_MFinit.bEnableWLE;
2190
2191 for(i=0; i<32; i++)
2192 {
2193 pDrvStatus->DLCluma.g_wLumaHistogram32H[i] = DLCLumaData.g_wLumaHistogram32H[i];
2194 }
2195 for(i=0; i<16; i++)
2196 {
2197 pDrvStatus->DLCluma.g_ucTable[i] = DLCLumaData.g_ucTable[i];
2198 }
2199 pDrvStatus->DLCluma.g_wLumiTotalCount = DLCLumaData.g_wLumiTotalCount;
2200 pDrvStatus->DLCluma.g_wLumiAverageTemp = DLCLumaData.g_wLumiAverageTemp;
2201 pDrvStatus->DLCluma.g_ucHistogramMax = DLCLumaData.g_ucHistogramMax;
2202 pDrvStatus->DLCluma.g_ucHistogramMin = DLCLumaData.g_ucHistogramMin;
2203 pDrvStatus->u16DLC_MFVer = MDrv_DLC_GetMFVer();
2204 pDrvStatus->u16DLC_CGC_MFVer = MDrv_DLC_CGC_GetMFVer();
2205
2206 // get DBC Info, this function has problem, mark out temprary
2207 //MDrv_DLC_GetDBCInfo( &DLC_DBC_MFinit, sizeof(StuDbc_FinetuneParamaters_Lib));
2208 pDrvStatus->u16DLC_DBC_MFVer = MDrv_DLC_DBC_GetMFVer();
2209 }
2210 Dlc_FuncExit();
2211 return TRUE;
2212 }
2213
MApi_XC_DLC_GetStatus(XC_DLC_ApiStatus * pDrvStatus,MS_BOOL bWindow)2214 MS_BOOL MApi_XC_DLC_GetStatus(XC_DLC_ApiStatus *pDrvStatus, MS_BOOL bWindow)
2215 {
2216 if (pu32DLCInst == NULL)
2217 {
2218 if(UtopiaOpen(MODULE_DLC, &pu32DLCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2219 {
2220 printf("UtopiaOpen DLC failed\n");
2221 return FALSE;
2222 }
2223 }
2224
2225 stDLC_GetStatus DLCArgs;
2226 DLCArgs.pDrvStatus = pDrvStatus;
2227 DLCArgs.bWindow = bWindow;
2228 DLCArgs.bReturn =FALSE;
2229 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2230 // instead of 0
2231 if(UtopiaIoctl(pu32DLCInst, E_DLC_CMD_GET_STATUS, (void*)&DLCArgs) != UTOPIA_STATUS_SUCCESS)
2232 {
2233 printf("Obtain DLC engine fail\n");
2234 return FALSE;
2235 }
2236 else
2237 {
2238 return DLCArgs.bReturn;
2239 }
2240 }
2241
2242
2243 /******************************************************************************/
2244 // API DLC DBC library start
2245 /******************************************************************************/
MApi_XC_DLC_DBC_Init_U2(void * pInstance,XC_DLC_DBC_MFinit DLC_DBC_MFinit)2246 void MApi_XC_DLC_DBC_Init_U2(void * pInstance,XC_DLC_DBC_MFinit DLC_DBC_MFinit)
2247 {
2248 StuDbc_FinetuneParamaters_Lib DbcParameters = {0};
2249 DbcParameters.ucMax_Video = DLC_DBC_MFinit.ucMax_Video;
2250 DbcParameters.ucMid_Video = DLC_DBC_MFinit.ucMid_Video;
2251 DbcParameters.ucMin_Video = DLC_DBC_MFinit.ucMin_Video;
2252 DbcParameters.ucMaxPWM = DLC_DBC_MFinit.ucMaxPWM;
2253 DbcParameters.ucBackLight_Thres = DLC_DBC_MFinit.ucBackLight_Thres;
2254 DbcParameters.ucMinPWM = DLC_DBC_MFinit.ucMinPWM;
2255 DbcParameters.ucAlpha = DLC_DBC_MFinit.ucAlpha;
2256 DbcParameters.ucAvgDelta = DLC_DBC_MFinit.ucAvgDelta;
2257 DbcParameters.ucFastAlphaBlending = DLC_DBC_MFinit.ucFastAlphaBlending;
2258 DbcParameters.ucLoop_Dly_H_Init = DLC_DBC_MFinit.ucLoop_Dly_H_Init;
2259 DbcParameters.ucLoop_Dly_MH_Init = DLC_DBC_MFinit.ucLoop_Dly_MH_Init;
2260 DbcParameters.ucLoop_Dly_ML_Init = DLC_DBC_MFinit.ucLoop_Dly_ML_Init;
2261 DbcParameters.ucLoop_Dly_L_Init = DLC_DBC_MFinit.ucLoop_Dly_L_Init;
2262 DbcParameters.bYGainCtrl = DLC_DBC_MFinit.bYGainCtrl;
2263 DbcParameters.bCGainCtrl = DLC_DBC_MFinit.bCGainCtrl;
2264
2265
2266 MDrv_DLC_DBC_Init(DbcParameters);
2267 g_bDLC_DBC_ready = FALSE;
2268 g_bDBCEnable = FALSE;
2269 }
2270
MApi_XC_DLC_DBC_Init(XC_DLC_DBC_MFinit DLC_DBC_MFinit)2271 void MApi_XC_DLC_DBC_Init(XC_DLC_DBC_MFinit DLC_DBC_MFinit)
2272 {
2273 if (pu32DBCInst == NULL)
2274 {
2275 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2276 {
2277 printf("UtopiaOpen DBC failed\n");
2278 return ;
2279 }
2280 }
2281
2282 stDBC_DLC_Init DBCArgs;
2283 DBCArgs.DLC_DBC_MFinit = DLC_DBC_MFinit;
2284
2285 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2286 // instead of 0
2287 if(UtopiaIoctl(pu32DBCInst, E_DBC_CMD_DLC_INIT, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2288 {
2289 printf("Obtain DBC engine fail\n");
2290 }
2291
2292 return ;
2293 }
2294
2295
MApi_XC_DBC_Init_U2(void * pInstanc)2296 void MApi_XC_DBC_Init_U2(void * pInstanc)
2297 {
2298 msDBCInit();
2299 }
2300
MApi_XC_DBC_Init(void)2301 void MApi_XC_DBC_Init(void)
2302 {
2303 if (pu32DBCInst == NULL)
2304 {
2305 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2306 {
2307 printf("UtopiaOpen DBC failed\n");
2308 return ;
2309 }
2310 }
2311
2312 stDBC_Init DBCArgs;
2313
2314 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2315 // instead of 0
2316 if(UtopiaIoctl(pu32DBCInst, E_DBC_CMD_INIT, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2317 {
2318 printf("Obtain DBC engine fail\n");
2319 }
2320
2321 return ;
2322 }
2323
2324
MApi_XC_DLC_DBC_Setstatus_U2(void * pInstance,MS_BOOL bDBCEnable)2325 void MApi_XC_DLC_DBC_Setstatus_U2(void * pInstance,MS_BOOL bDBCEnable)
2326 {
2327 g_bDBCEnable = bDBCEnable;
2328 }
2329
MApi_XC_DLC_DBC_Setstatus(MS_BOOL bDBCEnable)2330 void MApi_XC_DLC_DBC_Setstatus(MS_BOOL bDBCEnable)
2331 {
2332 if (pu32DBCInst == NULL)
2333 {
2334 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2335 {
2336 printf("UtopiaOpen DBC failed\n");
2337 return ;
2338 }
2339 }
2340
2341 stDBC_Setstatus DBCArgs;
2342 DBCArgs.bDBCEnable = bDBCEnable;
2343
2344 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2345 // instead of 0
2346 if(UtopiaIoctl(pu32DBCInst, E_DBC_CMD_SET_STATUS, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2347 {
2348 printf("Obtain DBC engine fail\n");
2349 }
2350
2351 return ;
2352 }
2353
2354
MApi_XC_DLC_DBC_Getstatus_U2(void * pInstance)2355 MS_BOOL MApi_XC_DLC_DBC_Getstatus_U2(void * pInstance)
2356 {
2357 return g_bDBCEnable;
2358 }
2359
MApi_XC_DLC_DBC_Getstatus(void)2360 MS_BOOL MApi_XC_DLC_DBC_Getstatus(void)
2361 {
2362 if (pu32DBCInst == NULL)
2363 {
2364 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2365 {
2366 printf("UtopiaOpen DBC failed\n");
2367 return FALSE;
2368 }
2369 }
2370
2371 stDBC_Getstatus DBCArgs;
2372 DBCArgs.bReturn =FALSE;
2373 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2374 // instead of 0
2375 if(UtopiaIoctl(pu32DBCInst, E_DBC_CMD_GET_STATUS, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2376 {
2377 printf("Obtain DBC engine fail\n");
2378 return FALSE;
2379 }
2380 else
2381 {
2382 return DBCArgs.bReturn;
2383 }
2384 }
2385
2386
MApi_XC_DLC_DBC_SetReady_U2(void * pInstance,MS_BOOL bDBCReady)2387 void MApi_XC_DLC_DBC_SetReady_U2(void * pInstance,MS_BOOL bDBCReady)
2388 {
2389 g_bDLC_DBC_ready = bDBCReady;
2390 }
2391
MApi_XC_DLC_DBC_SetReady(MS_BOOL bDBCReady)2392 void MApi_XC_DLC_DBC_SetReady(MS_BOOL bDBCReady)
2393 {
2394 if (pu32DBCInst == NULL)
2395 {
2396 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2397 {
2398 printf("UtopiaOpen DBC failed\n");
2399 return ;
2400 }
2401 }
2402
2403 stDBC_SetReady DBCArgs;
2404 DBCArgs.bDBCReady = bDBCReady;
2405
2406 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2407 // instead of 0
2408 if(UtopiaIoctl(pu32DBCInst, E_DBC_CMD_SET_READY, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2409 {
2410 printf("Obtain DBC engine fail\n");
2411 }
2412
2413 return ;
2414 }
2415
2416
MApi_XC_DLC_DBC_SetDebugMode_U2(void * pInstance,MS_U8 ucDBC_DebugMode)2417 void MApi_XC_DLC_DBC_SetDebugMode_U2(void * pInstance,MS_U8 ucDBC_DebugMode)
2418 {
2419 MDrv_DLC_DBC_SetDebugMode(ucDBC_DebugMode);
2420 }
2421
MApi_XC_DLC_DBC_SetDebugMode(MS_U8 ucDBC_DebugMode)2422 void MApi_XC_DLC_DBC_SetDebugMode(MS_U8 ucDBC_DebugMode)
2423 {
2424 if (pu32DBCInst == NULL)
2425 {
2426 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2427 {
2428 printf("UtopiaOpen DBC failed\n");
2429 return ;
2430 }
2431 }
2432
2433 stDBC_SetDebugMode DBCArgs;
2434 DBCArgs.ucDBC_DebugMode = ucDBC_DebugMode;
2435
2436 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2437 // instead of 0
2438 if(UtopiaIoctl(pu32DBCInst, E_DBC_CMD_SET_DEBUG_MODE, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2439 {
2440 printf("Obtain DBC engine fail\n");
2441 }
2442
2443 return ;
2444 }
2445
2446
MApi_XC_DLC_DBC_GetDebugMode_U2(void * pInstance)2447 MS_U8 MApi_XC_DLC_DBC_GetDebugMode_U2(void * pInstance)
2448 {
2449 return MDrv_DLC_DBC_GetDebugMode();
2450 }
2451
MApi_XC_DLC_DBC_GetDebugMode(void)2452 MS_U8 MApi_XC_DLC_DBC_GetDebugMode(void)
2453 {
2454 if (pu32DBCInst == NULL)
2455 {
2456 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2457 {
2458 printf("UtopiaOpen DBC failed\n");
2459 return 0;
2460 }
2461 }
2462
2463 stDBC_GetDebugMode DBCArgs;
2464 DBCArgs.u8Return =0;
2465 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2466 // instead of 0
2467 if(UtopiaIoctl(pu32DBCInst, E_DBC_CMD_GET_DEBUG_MODE, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2468 {
2469 printf("Obtain DBC engine fail\n");
2470 return 0;
2471 }
2472 else
2473 {
2474 return DBCArgs.u8Return;
2475 }
2476 }
2477
2478
MApi_XC_DLC_DBC_UpdatePWM_U2(void * pInstance,MS_U8 u8PWMvalue)2479 void MApi_XC_DLC_DBC_UpdatePWM_U2(void * pInstance,MS_U8 u8PWMvalue)
2480 {
2481 MDrv_DLC_DBC_UpdatePWM(u8PWMvalue);
2482 }
2483
MApi_XC_DLC_DBC_UpdatePWM(MS_U8 u8PWMvalue)2484 void MApi_XC_DLC_DBC_UpdatePWM(MS_U8 u8PWMvalue)
2485 {
2486 if (pu32DBCInst == NULL)
2487 {
2488 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2489 {
2490 printf("UtopiaOpen DBC failed\n");
2491 return ;
2492 }
2493 }
2494
2495 stDBC_UpdatePWM DBCArgs;
2496 DBCArgs.u8PWMvalue = u8PWMvalue;
2497
2498 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2499 // instead of 0
2500 if(UtopiaIoctl(pu32DBCInst, E_DBC_CMD_UPDATE_PWM, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2501 {
2502 printf("Obtain DBC engine fail\n");
2503 }
2504
2505 return ;
2506 }
2507
2508
MApi_XC_DLC_DBC_Handler_U2(void * pInstance)2509 MS_U16 MApi_XC_DLC_DBC_Handler_U2(void * pInstance)
2510 {
2511 if(g_bDLC_DBC_ready && g_bDBCEnable)
2512 return MDrv_DLC_DBC_Handler();
2513 else
2514 return 0xFFFF;
2515 }
2516
MApi_XC_DLC_DBC_Handler(void)2517 MS_U16 MApi_XC_DLC_DBC_Handler(void)
2518 {
2519 if (pu32DBCInst == NULL)
2520 {
2521 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2522 {
2523 printf("UtopiaOpen DBC failed\n");
2524 return 0;
2525 }
2526 }
2527
2528 stDBC_Handler DBCArgs;
2529 DBCArgs.u16Return =0;
2530 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2531 // instead of 0
2532 if(UtopiaIoctl(pu32DBCInst, E_DBC_CMD_HANDLER, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2533 {
2534 printf("Obtain DBC engine fail\n");
2535 return 0;
2536 }
2537 else
2538 {
2539 return DBCArgs.u16Return;
2540 }
2541 }
2542
2543
MApi_XC_DLC_DBC_AdjustYCGain_U2(void * pInstance)2544 void MApi_XC_DLC_DBC_AdjustYCGain_U2(void * pInstance)
2545 {
2546 MDrv_DLC_DBC_AdjustYCGain();
2547 }
2548
MApi_XC_DLC_DBC_AdjustYCGain(void)2549 void MApi_XC_DLC_DBC_AdjustYCGain(void)
2550 {
2551 if (pu32DBCInst == NULL)
2552 {
2553 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2554 {
2555 printf("UtopiaOpen DBC failed\n");
2556 return ;
2557 }
2558 }
2559
2560 stDBC_AdjustYCGain DBCArgs;
2561
2562 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2563 // instead of 0
2564 if(UtopiaIoctl(pu32DBCInst, E_DBC_CMD_ADJUST_YC_GAIN, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2565 {
2566 printf("Obtain DBC engine fail\n");
2567 }
2568
2569 return ;
2570 }
2571
2572
MApi_XC_DLC_DBC_YCGainInit_U2(void * pInstance,MS_U8 u8YGain_M,MS_U8 u8YGain_L,MS_U8 u8CGain_M,MS_U8 u8CGain_L)2573 void MApi_XC_DLC_DBC_YCGainInit_U2(void * pInstance,MS_U8 u8YGain_M,MS_U8 u8YGain_L,MS_U8 u8CGain_M,MS_U8 u8CGain_L)
2574 {
2575 MS_U8 u8YGain_H, u8CGain_H;
2576 if(g_bDLC_CGC_YGainPQCom)
2577 {
2578 u8YGain_H = g_u8DLC_CGC_YGain;
2579 }
2580 else
2581 {
2582 u8YGain_H = MDrv_DLC_CGC_GetYGain();
2583 }
2584 if(g_bDLC_CGC_CGainPQCom)
2585 {
2586 u8CGain_H = g_u8DLC_CGC_CGain;
2587 }
2588 else
2589 {
2590 u8CGain_H = MDrv_DLC_CGC_GetCGain();
2591 }
2592 msAdjustYCGain(u8YGain_H, u8CGain_H);
2593
2594 MDrv_DLC_DBC_YCGainInit(u8YGain_M, u8YGain_L, u8CGain_M, u8CGain_L, u8YGain_H, u8CGain_H);
2595 g_bDLC_DBC_ready = TRUE;
2596 }
2597
MApi_XC_DLC_DBC_YCGainInit(MS_U8 u8YGain_M,MS_U8 u8YGain_L,MS_U8 u8CGain_M,MS_U8 u8CGain_L)2598 void MApi_XC_DLC_DBC_YCGainInit(MS_U8 u8YGain_M, MS_U8 u8YGain_L, MS_U8 u8CGain_M, MS_U8 u8CGain_L)
2599 {
2600 if (pu32DBCInst == NULL)
2601 {
2602 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2603 {
2604 printf("UtopiaOpen DBC failed\n");
2605 return ;
2606 }
2607 }
2608
2609 stDBC_YCGainInit DBCArgs;
2610 DBCArgs.u8YGain_M = u8YGain_M;
2611 DBCArgs.u8YGain_L = u8YGain_L;
2612 DBCArgs.u8CGain_M = u8CGain_M;
2613 DBCArgs.u8CGain_L = u8CGain_L;
2614
2615 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2616 // instead of 0
2617 if(UtopiaIoctl(pu32DBCInst, E_DBC_CMD_YC_GAIN_INIT, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2618 {
2619 printf("Obtain DBC engine fail\n");
2620 }
2621
2622 return ;
2623 }
2624
2625
MApi_XC_DLC_DBC_Reset_U2(void * pInstanc)2626 void MApi_XC_DLC_DBC_Reset_U2(void * pInstanc)
2627 {
2628 g_bDLC_DBC_ready = FALSE;
2629 }
2630
MApi_XC_DLC_DBC_Reset(void)2631 void MApi_XC_DLC_DBC_Reset(void)
2632 {
2633 if (pu32DBCInst == NULL)
2634 {
2635 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2636 {
2637 printf("UtopiaOpen DBC failed\n");
2638 return ;
2639 }
2640 }
2641
2642 stDBC_Reset DBCArgs;
2643
2644 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2645 // instead of 0
2646 if(UtopiaIoctl(pu32DBCInst, E_DBC_CMD_RESET, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2647 {
2648 printf("Obtain DBC engine fail\n");
2649 }
2650
2651 return ;
2652 }
2653
2654
MApi_XC_DBC_DecodeExtCmd_U2(void * pInstance,tDBC_CONTROL_PARAMS * pValue)2655 void MApi_XC_DBC_DecodeExtCmd_U2(void * pInstance,tDBC_CONTROL_PARAMS * pValue)
2656 {
2657 msDBC_ParametersTool(pValue->pCmdBuff, pValue->fnDBC_AP_OnOff, pValue->fnDBC_AdjustBacklight, pValue->fnDBC_Putchar);
2658 }
2659
MApi_XC_DBC_DecodeExtCmd(tDBC_CONTROL_PARAMS * pValue)2660 void MApi_XC_DBC_DecodeExtCmd(tDBC_CONTROL_PARAMS* pValue )
2661 {
2662 if (pu32DBCInst == NULL)
2663 {
2664 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2665 {
2666 printf("UtopiaOpen DBC failed\n");
2667 return ;
2668 }
2669 }
2670
2671 stDBC_DecodeExtCmd DBCArgs;
2672 DBCArgs.params = pValue;
2673
2674
2675 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2676 // instead of 0
2677 if(UtopiaIoctl(pu32DBCInst, E_DBC_CMD_DECODE_EXT_CMD, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2678 {
2679 printf("Obtain DBC engine fail\n");
2680 }
2681
2682 return ;
2683 }
2684
2685 #define LOGTIMECOST FALSE
MApi_XC_DLC_SetPowerState_U2(void * pInstance,EN_POWER_MODE enPowerState)2686 MS_U32 MApi_XC_DLC_SetPowerState_U2(void* pInstance, EN_POWER_MODE enPowerState)
2687 {
2688 static EN_POWER_MODE _enPrevPowerState = E_POWER_MECHANICAL;
2689 MS_U32 u32Ret = UTOPIA_STATUS_FAIL;
2690
2691 #if LOGTIMECOST
2692 MS_U32 u32Begin = MsOS_GetSystemTime();
2693 #endif
2694
2695 if (enPowerState == E_POWER_SUSPEND)
2696 {
2697 _enPrevPowerState = enPowerState;
2698 u32Ret = UTOPIA_STATUS_SUCCESS;
2699 }
2700 else if (enPowerState == E_POWER_RESUME)
2701 {
2702 if (_enPrevPowerState == E_POWER_SUSPEND)
2703 {
2704 MDrv_DLC_InitCurve(g_DlcCapRange_Suspend.wHStart, g_DlcCapRange_Suspend.wHEnd, g_DlcCapRange_Suspend.wVStart, g_DlcCapRange_Suspend.wVEnd); //to avoid dead lock , need to verify futhur
2705 _enPrevPowerState = enPowerState;
2706 u32Ret = UTOPIA_STATUS_SUCCESS;
2707 }
2708 else
2709 {
2710 printf("[%s,%5d]It is not suspended yet. We shouldn't resume\n",__FUNCTION__,__LINE__);
2711 u32Ret = UTOPIA_STATUS_FAIL;
2712 }
2713 }
2714 else
2715 {
2716 printf("[%s,%5d]Do Nothing: %u\n",__FUNCTION__,__LINE__,enPowerState);
2717 u32Ret = UTOPIA_STATUS_FAIL;
2718 }
2719
2720 #if LOGTIMECOST
2721 printf("=========[%s,%5d] cost %lu ms========\n", __FUNCTION__, __LINE__, MsOS_GetSystemTime() - u32Begin);
2722 #endif
2723
2724 return u32Ret;
2725 }
2726
MApi_XC_DLC_SetPowerState(EN_POWER_MODE enPowerState)2727 MS_U32 MApi_XC_DLC_SetPowerState(EN_POWER_MODE enPowerState)
2728 {
2729 if (pu32DBCInst == NULL)
2730 {
2731 if(UtopiaOpen(MODULE_DLC, &pu32DBCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2732 {
2733 printf("UtopiaOpen DBC failed\n");
2734 return UTOPIA_STATUS_FAIL;
2735 }
2736 }
2737
2738 stDLC_SetPowerState DBCArgs;
2739 DBCArgs.enPowerState = enPowerState;
2740 DBCArgs.u32Return = UTOPIA_STATUS_FAIL;
2741
2742 // wait until Jesse.Huang set the definition of return value, I will exchange this with another return value
2743 // instead of 0
2744 if(UtopiaIoctl(pu32DBCInst, E_DLC_CMD_SET_POWERSTATE, (void*)&DBCArgs) != UTOPIA_STATUS_SUCCESS)
2745 {
2746 printf("Obtain DBC engine fail\n");
2747 return UTOPIA_STATUS_FAIL;
2748 }
2749
2750 return DBCArgs.u32Return;
2751 }
2752
2753 /******************************************************************************/
2754 // API DLC DBC library end
2755 /******************************************************************************/
2756
2757 #undef _API_XC_DLC_C_
2758 #endif // _API_XC_DLC_C_
2759
2760