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 #ifndef _API_XC_PANEL_C_
79 #define _API_XC_PANEL_C_
80
81 /******************************************************************************/
82 /* Includes */
83 /******************************************************************************/
84 // Common Definition
85 #include "MsCommon.h"
86 #include "MsVersion.h"
87 #include "MsIRQ.h"
88 #include "MsOS.h"
89 #include "utopia.h"
90 #include "utopia_dapi.h"
91 #include "apiPNL.h"
92 #include "apiPNL_v2.h"
93 #include "drvPNL.h"
94 // wyc.test-131206
95 #include "halPNL.h"
96
97 #include "PNL_private.h"
98 #ifdef MSOS_TYPE_LINUX_KERNEL
99 #include <linux/string.h>
100 #else
101 #include <string.h>
102 #endif
103
104 /******************************************************************************/
105 /* Debug information */
106 /******************************************************************************/
107
108 #define PNL_DBG_MSG(fmt,...) \
109 MS_DEBUG_MSG(do{ \
110 if(_u16PnlDbgSwitch){ \
111 printf( "[PNL_DBG_MSG]: %s: %d \n" fmt, __FUNCTION__, __LINE__, ## __VA_ARGS__); \
112 } \
113 } while(0))
114
115 #define PNL_PRINT_VAR(var) \
116 do{ \
117 if(_u16PnlDbgSwitch){ \
118 PNL_DBG_MSG("%30s: %d\n", #var, (var)); \
119 } \
120 }while(0)
121
122 #define PNL_PRINT_FUN(fun) \
123 do{ \
124 if(_u16PnlDbgSwitch){ \
125 PNL_DBG_MSG("\n"); \
126 PNL_DBG_MSG("**************************************************\n"); \
127 PNL_DBG_MSG("*\t\t%s \t\t\n", #fun); \
128 PNL_DBG_MSG("**************************************************\n"); \
129 fun; \
130 PNL_DBG_MSG("* *\n"); \
131 PNL_DBG_MSG("* *\n"); \
132 PNL_DBG_MSG("**************************************************\n"); \
133 } \
134 }while(0)
135
136 #ifndef UNUSED
137 #define UNUSED(x) ((x)=(x))
138 #endif
139
140 #ifndef XC_SUPPORT_AUTO_VSYNC
141 #define XC_SUPPORT_AUTO_VSYNC 0
142 #endif
143
144 #define PNL_SEMAPHORE_DBG 0
145 #define _pnl_dbg_semaphore E_PNL_POOL_ID_INTERNAL
146 // if anyone wants to see log inside android,
147 // please replace the "printf" with "ALOGE" so that it can be printed in android process
148 // OS related
149 #if (PNL_SEMAPHORE_DBG)
150 #define _PNL_SEMAPHORE_ENTRY(pInstance,POOL_ID) \
151 if (POOL_ID == _pnl_dbg_semaphore) \
152 printf("1 [%s,%5d]==========================Prepare to get semaphore, PNL ID = %d\n",__func__,__LINE__,POOL_ID); \
153 if(MDrv_PNL_Get_Semaphore(pInstance,POOL_ID) != UTOPIA_STATUS_SUCCESS) \
154 { \
155 printf("[%s,%5d] Get PNL Semaphore failed\n",__FUNCTION__,__LINE__); \
156 } \
157 if (POOL_ID == _pnl_dbg_semaphore) \
158 printf("[%s,%5d]Semaphore Got\n\n",__func__,__LINE__);
159
160 #define _PNL_SEMAPHORE_RETURN(pInstance,POOL_ID) \
161 if (POOL_ID == _pnl_dbg_semaphore) \
162 printf("0 [%s,%5d]==========================prepare to release semaphore, PNL ID = %d\n",__func__,__LINE__,POOL_ID); \
163 MDrv_PNL_Release_Semaphore(pInstance,POOL_ID); \
164 if (POOL_ID == _pnl_dbg_semaphore) \
165 printf("[%s,%5d]Semaphore Returned\n\n",__func__,__LINE__);
166
167 #else
168 #define _PNL_SEMAPHORE_ENTRY(pInstance,POOL_ID) \
169 if(MDrv_PNL_Get_Semaphore(pInstance,POOL_ID) != UTOPIA_STATUS_SUCCESS) \
170 { }
171
172 #define _PNL_SEMAPHORE_RETURN(pInstance,POOL_ID) \
173 MDrv_PNL_Release_Semaphore(pInstance,POOL_ID);
174 #endif
175
176
177 #define PNL_WAIT_MUTEX (TICK_PER_ONE_MS * 300) // 300 ms
178
179 // Mutex function
180 #define _PNL_ENTRY() _PNL_ENTRY_MUTEX(_s32PNLMutex)
181 #define _PNL_RETURN() _PNL_RETURN_MUTEX(_s32PNLMutex)
182
183 #define _PNL_ENTRY_MUTEX(_mutex_) \
184 if(!OS_OBTAIN_MUTEX(_mutex_, PNL_WAIT_MUTEX)) \
185 { \
186 printf("==========================\n"); \
187 printf("[%s][%s][%06d] Mutex taking timeout\n",__FILE__,__FUNCTION__,__LINE__); \
188 }
189 #define _PNL_RETURN_MUTEX(_mutex_) OS_RELEASE_MUTEX(_mutex_);
190
191 /******************************************************************************/
192 /* Type Definition */
193 /******************************************************************************/
194
195 /******************************************************************************/
196 /* Macro and Define */
197 /******************************************************************************/
198 #define MAX_BACKLIGHT 100
199 #define PANEL_DE_VSTART 0 //8 // for STB, the DE Vstart must be 0
200
201 /******************************************************************************/
202 /* Private varialbes */
203 /******************************************************************************/
204
205 // Mutex & Lock
206 static MS_S32 _s32PNLMutex = -1;
207
208 static const MSIF_Version _api_pnl_version = { .DDI = { PNL_API_VERSION }, };
209
210 /******************************************************************************/
211 /* Function */
212 /******************************************************************************/
213 extern MS_BOOL MDrv_XC_IsSupportPipPatchUsingSc1MainAsSc0Sub(void);
214 /******************************************************************************/
215 /* Private functions */
216 /******************************************************************************/
217 //
218 // set params from user defined panel
219 //
_MakeCompatibile(void * pInstance)220 static void _MakeCompatibile(void* pInstance)
221 {
222 MS_U8 VerSel[3], VerLib[3];
223
224 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
225 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
226
227 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
228 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
229 memcpy(VerLib, _api_pnl_version.DDI.version, 2);
230 memcpy(VerSel, pPNLResourcePrivate->_api_pnl_version_sel.DDI.version, 2);
231
232 VerLib[2] = VerSel[2] = '\0';
233
234 if(strcmp( (const char*)VerSel, (const char*)VerLib ) != 0)
235 {
236 if ((pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type == E_PNL_TYPE_TTL)
237 || (pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type == E_PNL_TYPE_DAC_P)
238 || ((pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type >= E_PNL_TYPE_MINILVDS)
239 && (pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type <= E_PNL_TYPE_DIGITAL_MINILVDS))
240 || ((pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type == E_PNL_TYPE_EXT)
241 && (pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type_Ext == E_PNL_TYPE_TTL_TCON))
242 )
243 {
244 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelOutTimingMode = E_PNL_CHG_HTOTAL;
245 }
246 else
247 {
248 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelOutTimingMode = E_PNL_CHG_VTOTAL;
249 }
250 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8PanelNoiseDith = TRUE;
251
252 if( strcmp( (const char*)VerSel, "00" ) == 0 )
253 {
254
255 MS_CRITICAL_MSG(printf("wrong PanelType version, enter compatitlbe mode\n"));
256 }
257 else
258 {
259 MS_CRITICAL_MSG(printf("Panel Library mismatch(%s), please update to version %s\n", VerSel, VerLib));
260 }
261 }
262 //Temp patch for MBOOT pnl lib and SN/Chara2 pnl lib are not same with DE Vstart
263 if(pPNLResourcePrivate->stapiPNL._bSkipTimingChange == TRUE)
264 {
265 MS_U16 u16DEStart = MDrv_PNL_Get_DEVstart(pInstance);
266 //Check DE Vstart
267 if(u16DEStart != pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16VStart)
268 {
269 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16VStart = u16DEStart;
270 printf("[Warning] %s:%d, Too old MBOOT PNL lib found, change DE Vstart as MBOOT's setting[%d]\n", __FUNCTION__, __LINE__, u16DEStart);
271 }
272
273 //Check DE Hstart
274 u16DEStart = MDrv_PNL_Get_DEHstart(pInstance);
275 if(u16DEStart != pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16HStart)
276 {
277 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16HStart = u16DEStart;
278 printf("[Warning] %s:%d, Panel config mismatch, change DE Hstart as MBOOT's setting[%d]\n", __FUNCTION__, __LINE__, u16DEStart);
279 }
280
281 }
282 }
283
_TransToDriver_APIPNL_LINK_TYPE_To_PNL_TYPE(APIPNL_LINK_TYPE enAPILinkType)284 static PNL_TYPE _TransToDriver_APIPNL_LINK_TYPE_To_PNL_TYPE(APIPNL_LINK_TYPE enAPILinkType)
285 {
286 PNL_TYPE enDriverLinkType = E_PNL_TYPE_TTL;
287
288 switch(enAPILinkType)
289 {
290 case LINK_TTL:
291 enDriverLinkType = E_PNL_TYPE_TTL;
292 break;
293 case LINK_RSDS:
294 enDriverLinkType = E_PNL_TYPE_RSDS;
295 break;
296 case LINK_MINILVDS:
297 case LINK_ANALOG_MINILVDS:
298 case LINK_DIGITAL_MINILVDS:
299 enDriverLinkType = E_PNL_TYPE_MINILVDS;
300 break;
301 case LINK_DAC_I:
302 enDriverLinkType = E_PNL_TYPE_DAC_I;
303 break;
304 case LINK_DAC_P:
305 enDriverLinkType = E_PNL_TYPE_DAC_P;
306 break;
307 default:
308 case LINK_LVDS:
309 case LINK_PDPLVDS:
310 enDriverLinkType = E_PNL_TYPE_LVDS;
311 break;
312 case LINK_EXT:
313 {
314 printf("LINK TYPE = EXT \n");
315 enDriverLinkType = E_PNL_TYPE_EXT;
316 }
317 break;
318 }
319 return enDriverLinkType;
320 }
321
_TransToDriver_APIPNL_LINK_EXT_TYPE_To_PNL_TYPE(APIPNL_LINK_EXT_TYPE enLPLL_TypeExt)322 static PNL_TYPE _TransToDriver_APIPNL_LINK_EXT_TYPE_To_PNL_TYPE(APIPNL_LINK_EXT_TYPE enLPLL_TypeExt)
323 {
324 PNL_TYPE enDriverLinkType = E_PNL_TYPE_EXT;
325
326 switch(enLPLL_TypeExt)
327 {
328 default:
329 case LINK_MINILVDS_5P_2L:
330 enDriverLinkType = E_PNL_LPLL_MINILVDS_5P_2L;
331 break;
332
333 case LINK_MINILVDS_4P_2L:
334 enDriverLinkType = E_PNL_LPLL_MINILVDS_4P_2L;
335 break;
336
337 case LINK_MINILVDS_3P_2L:
338 enDriverLinkType = E_PNL_LPLL_MINILVDS_3P_2L;
339 break;
340
341 case LINK_MINILVDS_6P_1L:
342 enDriverLinkType = E_PNL_LPLL_MINILVDS_6P_1L;
343 break;
344
345 case LINK_MINILVDS_5P_1L:
346 enDriverLinkType = E_PNL_LPLL_MINILVDS_5P_1L;
347 break;
348
349 case LINK_MINILVDS_4P_1L:
350 enDriverLinkType = E_PNL_LPLL_MINILVDS_4P_1L;
351 break;
352
353 case LINK_MINILVDS_3P_1L:
354 enDriverLinkType = E_PNL_LPLL_MINILVDS_3P_1L;
355 break;
356
357 case LINK_HF_LVDS:
358 enDriverLinkType = E_PNL_TYPE_HF_LVDS;
359 break;
360
361 case LINK_HS_LVDS:
362 enDriverLinkType = E_PNL_TYPE_HS_LVDS;
363 break;
364
365 case LINK_TTL_TCON:
366 enDriverLinkType = E_PNL_TYPE_TTL_TCON;
367 break;
368
369 case LINK_MINILVDS_1CH_3P_6BIT:
370 enDriverLinkType = E_PNL_LPLL_MINILVDS_1CH_3P_6BIT;
371 break;
372
373 case LINK_MINILVDS_1CH_4P_6BIT:
374 enDriverLinkType = E_PNL_LPLL_MINILVDS_1CH_4P_6BIT;
375 break;
376
377 case LINK_MINILVDS_1CH_5P_6BIT:
378 enDriverLinkType = E_PNL_LPLL_MINILVDS_1CH_5P_6BIT;
379 break;
380
381 case LINK_MINILVDS_1CH_6P_6BIT:
382 enDriverLinkType = E_PNL_LPLL_MINILVDS_1CH_6P_6BIT;
383 break;
384
385 case LINK_MINILVDS_2CH_3P_6BIT:
386 enDriverLinkType = E_PNL_LPLL_MINILVDS_2CH_3P_6BIT;
387 break;
388
389 case LINK_MINILVDS_2CH_4P_6BIT:
390 enDriverLinkType = E_PNL_LPLL_MINILVDS_2CH_4P_6BIT;
391 break;
392
393 case LINK_MINILVDS_2CH_5P_6BIT:
394 enDriverLinkType = E_PNL_LPLL_MINILVDS_2CH_5P_6BIT;
395 break;
396
397 case LINK_MINILVDS_2CH_6P_6BIT:
398 enDriverLinkType = E_PNL_LPLL_MINILVDS_2CH_6P_6BIT;
399 break;
400
401 case LINK_MINILVDS_1CH_3P_8BIT:
402 enDriverLinkType = E_PNL_LPLL_MINILVDS_1CH_3P_8BIT;
403 break;
404
405 case LINK_MINILVDS_1CH_4P_8BIT:
406 enDriverLinkType = E_PNL_LPLL_MINILVDS_1CH_4P_8BIT;
407 break;
408
409 case LINK_MINILVDS_1CH_5P_8BIT:
410 enDriverLinkType = E_PNL_LPLL_MINILVDS_1CH_5P_8BIT;
411 break;
412
413 case LINK_MINILVDS_1CH_6P_8BIT:
414 enDriverLinkType = E_PNL_LPLL_MINILVDS_1CH_6P_8BIT;
415 break;
416
417 case LINK_MINILVDS_2CH_3P_8BIT:
418 enDriverLinkType = E_PNL_LPLL_MINILVDS_2CH_3P_8BIT;
419 break;
420
421 case LINK_MINILVDS_2CH_4P_8BIT:
422 enDriverLinkType = E_PNL_LPLL_MINILVDS_2CH_4P_8BIT;
423 break;
424
425 case LINK_MINILVDS_2CH_5P_8BIT:
426 enDriverLinkType = E_PNL_LPLL_MINILVDS_2CH_5P_8BIT;
427 break;
428
429 case LINK_MINILVDS_2CH_6P_8BIT:
430 enDriverLinkType = E_PNL_LPLL_MINILVDS_2CH_6P_8BIT;
431 break;
432
433 case LINK_EPI34_8P:
434 enDriverLinkType = E_PNL_LPLL_EPI34_8P;
435 break;
436
437 case LINK_EPI28_8P:
438 enDriverLinkType = E_PNL_LPLL_EPI28_8P;
439 break;
440
441 case LINK_EPI34_6P:
442 enDriverLinkType = E_PNL_LPLL_EPI34_6P;
443 break;
444
445 case LINK_EPI28_6P:
446 enDriverLinkType = E_PNL_LPLL_EPI28_6P;
447 break;
448
449 case LINK_HDMI_BYPASS_MODE:
450 enDriverLinkType = E_PNL_LPLL_HDMI_BYPASS_MODE;
451 break;
452
453 case LINK_VBY1_10BIT_8LANE:
454 enDriverLinkType = E_PNL_LPLL_VBY1_10BIT_8LANE;
455 break;
456
457 case LINK_VBY1_8BIT_8LANE:
458 enDriverLinkType = E_PNL_LPLL_VBY1_8BIT_8LANE;
459 break;
460 //Following codes need check!!!
461 //In current refine, disable these codes for keeping logic.
462 //To be checked:Following link type can't be transfered to driver in fact.
463
464 case LINK_EPI34_2P:
465 enDriverLinkType = E_PNL_LPLL_EPI34_2P;
466 break;
467
468 case LINK_EPI34_4P:
469 enDriverLinkType = E_PNL_LPLL_EPI34_4P;
470 break;
471
472 case LINK_EPI28_2P:
473 enDriverLinkType = E_PNL_LPLL_EPI28_2P;
474 break;
475
476 case LINK_EPI28_4P:
477 enDriverLinkType = E_PNL_LPLL_EPI28_4P;
478 break;
479
480 case LINK_EPI28_12P:
481 enDriverLinkType = E_PNL_LPLL_EPI28_12P;
482 break;
483
484 case LINK_EPI24_12P:
485 enDriverLinkType = E_PNL_LPLL_EPI24_12P;
486 break;
487
488 case LINK_VBY1_10BIT_16LANE:
489 enDriverLinkType = E_PNL_LPLL_VBY1_10BIT_16LANE;
490 break;
491
492 case LINK_VBY1_10BIT_4LANE:
493 enDriverLinkType = E_PNL_LPLL_VBY1_10BIT_4LANE;
494 break;
495
496 case LINK_VBY1_10BIT_2LANE:
497 enDriverLinkType = E_PNL_LPLL_VBY1_10BIT_2LANE;
498 break;
499
500 case LINK_VBY1_10BIT_1LANE:
501 enDriverLinkType = E_PNL_LPLL_VBY1_10BIT_1LANE;
502 break;
503
504 case LINK_VBY1_8BIT_16LANE:
505 enDriverLinkType = E_PNL_LPLL_VBY1_8BIT_16LANE;
506 break;
507
508 case LINK_VBY1_8BIT_4LANE:
509 enDriverLinkType = E_PNL_LPLL_VBY1_8BIT_4LANE;
510 break;
511
512 case LINK_VBY1_8BIT_2LANE:
513 enDriverLinkType = E_PNL_LPLL_VBY1_8BIT_2LANE;
514 break;
515
516 case LINK_VBY1_8BIT_1LANE:
517 enDriverLinkType = E_PNL_LPLL_VBY1_8BIT_1LANE;
518 break;
519
520 case LINK_HS_LVDS_2CH_BYPASS_MODE:
521 enDriverLinkType = E_PNL_LPLL_HS_LVDS_BYPASS_MODE;
522 break;
523
524 case LINK_VBY1_8BIT_4LANE_BYPASS_MODE:
525 enDriverLinkType = E_PNL_LPLL_VBY1_8BIT_4LANE_BYPASS_MODE;
526 break;
527
528 case LINK_VBY1_10BIT_4LANE_BYPASS_MODE:
529 enDriverLinkType = E_PNL_LPLL_VBY1_10BIT_4LANE_BYPASS_MODE;
530 break;
531
532 case LINK_USI_T_8BIT_12P:
533 enDriverLinkType = E_PNL_LPLL_USI_T_8BIT_12P;
534 break;
535
536 case LINK_USI_T_10BIT_12P:
537 enDriverLinkType = E_PNL_LPLL_USI_T_10BIT_12P;
538 break;
539
540 case LINK_ISP_8BIT_12P:
541 enDriverLinkType = E_PNL_LPLL_ISP_8BIT_12P;
542 break;
543
544 case LINK_ISP_8BIT_6P_D:
545 enDriverLinkType = E_PNL_LPLL_ISP_8BIT_6P_D;
546 break;
547 }
548 return enDriverLinkType;
549 }
550
_SetPanelParams(void * pInstance,PanelType * pSelPanelType)551 static MS_BOOL _SetPanelParams(void* pInstance, PanelType *pSelPanelType)
552 {
553 /* Make sure following equalities right, avoid m_wPanel Start not fit SyncWidth and BackPorch
554 ** m_wPanelHStart = m_ucPanelHSyncWidth + m_ucPanelHSyncBackPorch
555 ** m_wPanelVStart = m_ucPanelVSyncWidth + m_ucPanelVBackPorch
556 */
557 //pSelPanelType->m_wPanelHStart = pSelPanelType->m_ucPanelHSyncWidth + pSelPanelType->m_ucPanelHSyncBackPorch;
558 //pSelPanelType->m_wPanelVStart = pSelPanelType->m_ucPanelVSyncWidth + pSelPanelType->m_ucPanelVBackPorch;
559
560 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
561 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
562
563 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
564 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
565
566 /* Calculate panel info according to panel_raw_data.
567 * can be factor out to diff functions.
568 */
569 // output Sync timing
570 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16HTotal = pSelPanelType->m_wPanelHTotal;
571 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16VTotal = pSelPanelType->m_wPanelVTotal;
572 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u32MinSET = pSelPanelType->m_dwPanelMinSET;//devPanel_MinSET(); // output MinSET
573 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u32MaxSET = pSelPanelType->m_dwPanelMaxSET;//devPanel_MaxSET(); // output MaxSET
574 //#if (ENABLE_LVDSTORGB_CONVERTER == ENABLE)
575 // panel_Info.u8HSyncWidth = 0x8D + 1; // hsync width
576 // #else
577 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8HSyncWidth = pSelPanelType->m_ucPanelHSyncWidth;//pnlGetHSyncWidth(); // hsync width
578 // #endif
579
580 // display timing
581 if(ENABLE == pPNLResourcePrivate->stapiPNL._bForceSetHStartEnable)
582 {
583 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16HStart = pPNLResourcePrivate->stapiPNL._u16PanelHStart;
584 pPNLResourcePrivate->stapiPNL._bForceSetHStartEnable = DISABLE;
585 }
586 else
587 {
588 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16HStart = pSelPanelType->m_wPanelHStart;//devPanel_HSTART(); // DE H start
589 }
590 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16Width = pSelPanelType->m_wPanelWidth; // DE H width
591
592 if( (pPNLResourcePrivate->stdrvPNL._stPnlInitData.u32PNL_MISC & E_APIPNL_MISC_PIXELSHIFT_ENABLE) == 0 )
593 {
594 if (MDrv_XC_IsSupportPipPatchUsingSc1MainAsSc0Sub())
595 {
596 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16VStart = MDrv_PNL_GetPanelVStart();
597 }
598 else
599 {
600 //when do not enable the pixel shift feature
601 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16VStart = PANEL_DE_VSTART; // devPanel_VSTART(); // DE V start
602 }
603 }
604 else
605 {
606 //when enable the pixel shift feature
607 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16VStart = MDrv_PNL_GetPanelVStart();//pSelPanelType->m_wPanelVStart;//PANEL_DE_VSTART; // devPanel_VSTART(); // DE V start
608 }
609
610 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16Height = pSelPanelType->m_wPanelHeight;//devPanel_HEIGHT(); // DE V height
611
612 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16VSyncStart = pSelPanelType->m_wPanelVStart; //devPanel_VSTART(); // vsync start
613 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8VSyncWidth = pSelPanelType->m_ucPanelVSyncWidth; //PANEL_VSYNC_WIDTH; // vsync width
614 // output control
615 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OCTRL = (MS_U16)(pSelPanelType->m_bPanelDualPort << 8)
616 | pSelPanelType->m_bPanelSwapEven_RB;
617
618 //devPanel_OCTRL();
619 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OSTRL = (0xF700) | (pSelPanelType->m_ucPanelDCLKDelay << 4)
620 | pSelPanelType->m_bPanelInvHSync;
621
622 // output driving current
623 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16ODRV = (MS_U16)(pSelPanelType->m_ucPanelDCKLCurrent << 6)
624 | (pSelPanelType->m_ucPanelDECurrent << 4)
625 | (pSelPanelType->m_ucPanelODDDataCurrent << 2)
626 | pSelPanelType->m_ucPanelEvenDataCurrent; //devPanel_ODRV();
627
628 //for MOD
629 pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Mode = pSelPanelType->m_bPanelDoubleClk == 0 ? E_PNL_MODE_SINGLE : E_PNL_MODE_DUAL; // 0: single clock mode, 1: double clock mode
630 // !! it should not use the different type to assign
631
632 pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type = _TransToDriver_APIPNL_LINK_TYPE_To_PNL_TYPE(pSelPanelType->m_ePanelLinkType);
633 if (E_PNL_TYPE_EXT == pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type)
634 {
635 pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type = pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type_Ext;
636 }
637
638 //printf("@@ %s, %d, pSelPanelType->m_ePanelLinkType=%u\n", __FUNCTION__, __LINE__, pSelPanelType->m_ePanelLinkType);
639 //printf("@@ %s, %d, _stPnlInitData.eLPLL_Type=%u\n", __FUNCTION__, __LINE__, pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type);
640
641 //we should set VSync manually to satisfy HDMITx's requirement.
642 //auto-Vsync will have several-vertical-line error.
643 switch(pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type)
644 {
645 case E_PNL_TYPE_DAC_I:
646 case E_PNL_TYPE_DAC_P:
647 case E_PNL_TYPE_PDPLVDS:
648 //case E_PNL_TYPE_EXT:
649 case E_PNL_TYPE_TTL:
650 #if (XC_SUPPORT_AUTO_VSYNC == 0)
651 case E_PNL_LPLL_VBY1_10BIT_16LANE:
652 case E_PNL_LPLL_VBY1_10BIT_4LANE:
653 case E_PNL_LPLL_VBY1_10BIT_2LANE:
654 case E_PNL_LPLL_VBY1_10BIT_1LANE:
655 case E_PNL_LPLL_VBY1_8BIT_16LANE:
656 case E_PNL_LPLL_VBY1_8BIT_4LANE:
657 case E_PNL_LPLL_VBY1_8BIT_2LANE:
658 case E_PNL_LPLL_VBY1_8BIT_1LANE:
659 case E_PNL_LPLL_VBY1_10BIT_8LANE:
660 case E_PNL_LPLL_VBY1_8BIT_8LANE:
661 case E_PNL_LPLL_VBY1_10BIT_4LANE_BYPASS_MODE:
662 case E_PNL_LPLL_VBY1_8BIT_4LANE_BYPASS_MODE:
663 #endif
664 ///TCON Panel
665 case E_PNL_LPLL_EPI34_8P:
666 case E_PNL_LPLL_EPI28_8P:
667 case E_PNL_LPLL_EPI34_6P:
668 case E_PNL_LPLL_EPI28_6P:
669 case E_PNL_LPLL_EPI34_2P:
670 case E_PNL_LPLL_EPI34_4P:
671 case E_PNL_LPLL_EPI28_2P:
672 case E_PNL_LPLL_EPI28_4P:
673 case E_PNL_LPLL_EPI28_12P:
674 case E_PNL_LPLL_EPI24_12P:
675 case E_PNL_TYPE_TTL_TCON:
676 case E_PNL_TYPE_MINILVDS:
677 case E_PNL_LPLL_MINILVDS_5P_2L:
678 case E_PNL_LPLL_MINILVDS_4P_2L:
679 case E_PNL_LPLL_MINILVDS_3P_2L:
680 case E_PNL_LPLL_MINILVDS_6P_1L:
681 case E_PNL_LPLL_MINILVDS_5P_1L:
682 case E_PNL_LPLL_MINILVDS_4P_1L:
683 case E_PNL_LPLL_MINILVDS_3P_1L:
684 case E_PNL_LPLL_MINILVDS_2CH_3P_8BIT:
685 case E_PNL_LPLL_MINILVDS_2CH_4P_8BIT:
686 case E_PNL_LPLL_MINILVDS_2CH_5P_8BIT:
687 case E_PNL_LPLL_MINILVDS_2CH_6P_8BIT:
688 case E_PNL_LPLL_MINILVDS_2CH_3P_6BIT:
689 case E_PNL_LPLL_MINILVDS_2CH_4P_6BIT:
690 case E_PNL_LPLL_MINILVDS_2CH_5P_6BIT:
691 case E_PNL_LPLL_MINILVDS_2CH_6P_6BIT:
692 case E_PNL_LPLL_MINILVDS_1CH_3P_8BIT:
693 case E_PNL_LPLL_MINILVDS_1CH_4P_8BIT:
694 case E_PNL_LPLL_MINILVDS_1CH_5P_8BIT:
695 case E_PNL_LPLL_MINILVDS_1CH_6P_8BIT:
696 case E_PNL_LPLL_MINILVDS_1CH_3P_6BIT:
697 case E_PNL_LPLL_MINILVDS_1CH_4P_6BIT:
698 case E_PNL_LPLL_MINILVDS_1CH_5P_6BIT:
699 case E_PNL_LPLL_MINILVDS_1CH_6P_6BIT:
700 case E_PNL_LPLL_USI_T_8BIT_12P:
701 case E_PNL_LPLL_USI_T_10BIT_12P:
702 case E_PNL_LPLL_ISP_8BIT_12P:
703 case E_PNL_LPLL_ISP_8BIT_6P_D:
704 pPNLResourcePrivate->stdrvPNL._stPnlInitData.bManuelVSyncCtrl = TRUE;
705 break;
706 default:
707 pPNLResourcePrivate->stdrvPNL._stPnlInitData.bManuelVSyncCtrl = FALSE;
708 break;
709 }
710
711 if((pPNLResourcePrivate->stdrvPNL._stPnlInitData.u32PNL_MISC & E_APIPNL_MISC_ENABLE_MANUAL_VSYNC_CTRL)
712 == E_APIPNL_MISC_ENABLE_MANUAL_VSYNC_CTRL)
713 {
714 pPNLResourcePrivate->stdrvPNL._stPnlInitData.bManuelVSyncCtrl = TRUE;
715 }
716
717 //MOD_REG(0x40)
718 //PANEL_DCLK_DELAY:8, PANEL_SWAP_LVDS_CH:6, PANEL_SWAP_LVDS_POL:5, PANEL_LVDS_TI_MODE:2,
719 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16MOD_CTRL0 = ((/*PANEL_DCLK_DELAY*/pSelPanelType->m_ucPanelDCLKDelay & 0xf) << 8)
720 | ((/*PANEL_SWAP_LVDS_CH*/ pSelPanelType->m_bPanelSwapLVDS_CH) ? BIT(6):0)
721 | ((/*~PANEL_SWAP_LVDS_POL*/ !pSelPanelType->m_bPanelSwapLVDS_POL) ? BIT(5):0)
722 | ((/*PANEL_LVDS_PDP_10BIT*/ pSelPanelType->m_bPanelPDP10BIT) ? BIT(3):0)
723 | ((/*PANEL_LVDS_TI_MODE*/ pSelPanelType->m_bPanelLVDS_TI_MODE) ? BIT(2):0);
724 //MOD_REG(0x49)
725 //PANEL_SWAP_EVEN_ML:14, PANEL_SWAP_EVEN_RB:13, PANEL_SWAP_ODD_ML:12, PANEL_SWAP_ODD_RB:11
726 // [7,6] : output formate selction 10: 8bit, 01: 6bit :other 10bit
727 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16MOD_CTRL9 = ((/* PANEL_SWAP_EVEN_ML */ pSelPanelType->m_bPanelSwapEven_ML)? BIT(14):0)
728 | ((/* PANEL_SWAP_EVEN_RB */ pSelPanelType->m_bPanelSwapEven_RB)? BIT(13):0)
729 | ((/* PANEL_SWAP_ODD_ML */ pSelPanelType->m_bPanelSwapOdd_ML)? BIT(12):0)
730 | ((/* PANEL_SWAP_ODD_RB */ pSelPanelType->m_bPanelSwapOdd_RB)? BIT(11):0)
731 | ((/* PANEL_OUTPUT_FORMAT */pSelPanelType->m_ucOutputFormatBitMode) << 6 )
732 | ((/* PANEL_SWAP_EVEN_RG */ pSelPanelType->m_bPanelSwapEven_RG)? BIT(5):0)
733 | ((/* PANEL_SWAP_EVEN_GB */ pSelPanelType->m_bPanelSwapEven_GB)? BIT(4):0)
734 | ((/* PANEL_SWAP_ODD_RG */ pSelPanelType->m_bPanelSwapOdd_RG)? BIT(3):0)
735 | ((/* PANEL_SWAP_ODD_GB */ pSelPanelType->m_bPanelSwapOdd_GB)? BIT(2):0);
736 //MOD_REG(0x4A)
737 //PANEL_INV_HSYNC:12, PANEL_INV_DCLK:4, PANEL_INV_VSYNC:3, PANEL_INV_DE:2, PANEL_DUAL_PORT:1, PANEL_SWAP_PORT:0,
738
739 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16MOD_CTRLA = ((pSelPanelType->m_bPanelInvHSync)? BIT(12):0)
740 | ((pSelPanelType->m_bPanelInvDCLK)? BIT(4):0)
741 | ((pSelPanelType->m_bPanelInvVSync)? BIT(3):0)
742 | ((pSelPanelType->m_bPanelInvDE)? BIT(2):0)
743 | ((pSelPanelType->m_bPanelDualPort) ? BIT(1):0)
744 | ((pSelPanelType->m_bPanelSwapPort) ? BIT(0):0);
745
746 //MOD_REG(0x4B)
747 //[1:0]ti_bitmode=00(10bit)
748 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8MOD_CTRLB = pSelPanelType->m_ucTiBitMode;
749
750 #define MOVE_OUTSIDE TRUE
751 #if MOVE_OUTSIDE
752 /*printf( "Move board related params to (custimized panel file)Panel.c (LVDSTxSwapValue)%d\n",
753 pSelPanelType->m_u16LVDSTxSwapValue
754 );*/
755 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16LVDSTxSwapValue = pSelPanelType->m_u16LVDSTxSwapValue;
756
757 #else
758 #if defined(ENABLE_LVDS_PN_SWAP)
759 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16LVDSTxSwapValue = (LVDS_PN_SWAP_H<<8) | LVDS_PN_SWAP_L;
760 #else
761 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16LVDSTxSwapValue = 0;
762 #endif
763
764 #endif
765 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelOutTimingMode = pSelPanelType->m_ucOutTimingMode;
766
767 if(ENABLE==pPNLResourcePrivate->stapiPNL._bForceSetDCLKEnable)
768 {
769 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16DefaultVFreq =( (MS_U32)(pPNLResourcePrivate->stapiPNL._u16PanelDCLK/2*10000000)/(pSelPanelType->m_wPanelHTotal*pSelPanelType->m_wPanelVTotal))*2;
770 pPNLResourcePrivate->stapiPNL._bForceSetDCLKEnable = DISABLE;
771 }
772 else
773 {
774 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16DefaultVFreq = ((MS_U32)pSelPanelType->m_dwPanelDCLK*10000000)/(pSelPanelType->m_wPanelHTotal*pSelPanelType->m_wPanelVTotal);
775 }
776 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16DefaultVFreq = MDrv_PNL_GetDefaultVfreq(pInstance, pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16DefaultVFreq);
777
778 //In FRC 120Hz Panel case, the DCLK should be double
779 if(MDrv_PNL_Is_SupportFRC(pInstance) && (pPNLResourcePrivate->stdrvPNL._stPnlInitData.u32PNL_MISC == (MS_U32)E_APIPNL_MISC_MFC_ENABLE))
780 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16DefaultVFreq *= 2;
781
782 if ((pPNLResourcePrivate->stdrvPNL._stPnlInitData.u32PNL_MISC == (MS_U32)E_APIPNL_MISC_4K2K_ENABLE_60HZ))
783 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16DefaultVFreq *= 2;
784
785 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8PanelNoiseDith = pSelPanelType->m_bPanelNoiseDith;
786
787 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelOnTiming1 = pSelPanelType->m_wPanelOnTiming1;
788 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelOnTiming2 = pSelPanelType->m_wPanelOnTiming2;
789 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelOffTiming1 = pSelPanelType->m_wPanelOffTiming1;
790 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelOffTiming2 = pSelPanelType->m_wPanelOffTiming2;
791 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelMinPWMVal = pSelPanelType->m_ucMinPWMVal;
792 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelMaxPWMVal = pSelPanelType->m_ucMaxPWMVal;
793 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelDimmingCtl = pSelPanelType->m_ucDimmingCtl;
794 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelHSyncBackPorch = pSelPanelType->m_wPanelHStart - pSelPanelType->m_ucPanelHSyncWidth;
795 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelVBackPorch = pSelPanelType->m_wPanelVStart - pSelPanelType->m_ucPanelVSyncWidth;
796 pPNLResourcePrivate->stdrvPNL._stPnlInitData.pPanelName = pSelPanelType->m_pPanelName;
797 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelAspectRatio= pSelPanelType->m_ucPanelAspectRatio;
798
799 /// set default value to E_PNL_TYPE_HS_LVDS
800 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16Ext_LpllType = E_PNL_TYPE_HS_LVDS;
801
802 /// set default setting for HW training mode
803 pPNLResourcePrivate->stdrvPNL._stPnlInitData.bVideo_HW_Training_En = TRUE;//FALSE;
804 pPNLResourcePrivate->stdrvPNL._stPnlInitData.bOSD_HW_Training_En = TRUE;//FALSE;
805
806 // for Panel lib compatibility
807 _MakeCompatibile(pInstance);
808
809 if(MDrv_PNL_Is_SupportFRC(pInstance))
810 {
811 if(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u32PNL_MISC == (MS_U32)E_APIPNL_MISC_MFC_ENABLE)
812 {
813 pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Mode = E_PNL_MODE_QUAD;
814 }
815 }
816
817 if(pPNLResourcePrivate->stapiPNL._bSkipTimingChange == FALSE)
818 {
819 //ignore timing change if Mboot Logo
820 MDrv_PNL_SetPanelType(pInstance, &pPNLResourcePrivate->stdrvPNL._stPnlInitData);
821 }
822 #if 0
823 if(_stPnlInitData.eLPLL_Type == E_PNL_TYPE_MFC)
824 {
825 MDrv_PNL_MFC(TRUE);
826 }
827 #endif
828
829 // Save panel type parameters
830 memcpy(&pPNLResourcePrivate->stapiPNL._stPanelTypeSaved, pSelPanelType, sizeof(PanelType));
831 pPNLResourcePrivate->stapiPNL._stPanelTypeSaved.m_wPanelHStart = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16HStart;
832 pPNLResourcePrivate->stapiPNL._stPanelTypeSaved.m_wPanelVStart = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16VStart;
833 pPNLResourcePrivate->stapiPNL._stPanelTypeSaved.m_ucOutTimingMode = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelOutTimingMode;
834 pPNLResourcePrivate->stapiPNL._stPanelTypeSaved.m_bPanelNoiseDith = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8PanelNoiseDith;
835
836 return TRUE;
837 }
838
839 //
840 // DumpData
841 //
_DumpData(void * pInstance)842 static void _DumpData(void* pInstance)
843 {
844 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
845 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
846
847 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
848 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
849
850 //PNL_PRINT_VAR(panel_info);
851 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16HTotal );
852 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16VTotal );
853
854 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8HSyncWidth );
855 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16Width );
856 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16Height );
857 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16HStart );
858 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16VStart );
859
860 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OCTRL );
861 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OSTRL );
862
863 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16ODRV );
864
865 //PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16DITHCTRL );
866
867 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Mode );
868 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type );
869
870 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16MOD_CTRL0 );
871 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16MOD_CTRL9 );
872
873 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16MOD_CTRLA );
874
875 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8MOD_CTRLB );
876
877 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16LVDSTxSwapValue);
878 //PNL_PRINT_VAR(_stPnlInitData.u16PanelOutTimingMode);
879 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16DefaultVFreq );
880 //PNL_PRINT_VAR(panel_info->u16DefaultHTotal );
881 //PNL_PRINT_VAR(panel_info->u16DefaultVTotal );
882 //PNL_PRINT_VAR(panel_info->u16MinHTotal );
883 //PNL_PRINT_VAR(panel_info->u16MaxHTotal );
884 //PNL_PRINT_VAR(panel_info->u16MinVTotal );
885 //PNL_PRINT_VAR(panel_info->u16MaxVTotal );
886 //PNL_PRINT_VAR(panel_info->u32MinDCLK );
887 //PNL_PRINT_VAR(panel_info->u32MaxDCLK );
888
889 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16VSyncStart );
890 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8VSyncWidth );
891 PNL_PRINT_VAR(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8PanelNoiseDith );
892
893 }
894
895 //
896 // Dump m_panel data
897 //
_EmptyMethod(MS_BOOL bEnable)898 static void _EmptyMethod(MS_BOOL bEnable)
899 {
900 if (pu32PNLInst == NULL)
901 {
902 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
903 {
904 printf("UtopiaOpen PNL failed\n");
905 return;
906 }
907 }
908 UNUSED(bEnable);
909 PNL_DBG_MSG(" Error!! <============== Calling a non-registered function!!");
910 }
911
MAPI_PNL_GetPNLHstart_U2(void * pInstance)912 MS_U16 MAPI_PNL_GetPNLHstart_U2(void *pInstance)
913 {
914 MS_U16 u16HStart = 0;
915 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
916 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
917
918 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
919 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
920 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
921 u16HStart = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16HStart;
922 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
923 return u16HStart;
924 }
925 //
926 //
_getPanelHstart(void)927 static MS_U16 _getPanelHstart(void)
928 {
929 #ifdef UTOPIA_20
930 if (pu32PNLInst == NULL)
931 {
932 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
933 {
934 printf("UtopiaOpen PNL failed\n");
935 return FALSE;
936 }
937 }
938
939 stPNL_GetHstart PNLArgs;
940 PNLArgs.u16Return= 0;
941 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETHSTART, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
942 {
943 printf("Obtain PNL engine fail\n");
944 return 0;
945 }
946 else
947 {
948 return PNLArgs.u16Return;
949 }
950 #else
951 return MAPI_PNL_GetPNLHstart_U2(pu32PNLInst);
952 #endif
953 }
954
MAPI_PNL_GetPNLVstart_U2(void * pInstance)955 MS_U16 MAPI_PNL_GetPNLVstart_U2(void *pInstance)
956 {
957 MS_U16 u16VStart = 0;
958 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
959 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
960
961 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
962 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
963 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
964 u16VStart = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16VStart;
965 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
966 return u16VStart;
967 }
968
_getPanelVstart(void)969 static MS_U16 _getPanelVstart(void)
970 {
971 #ifdef UTOPIA_20
972 if (pu32PNLInst == NULL)
973 {
974 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
975 {
976 printf("UtopiaOpen PNL failed\n");
977 return FALSE;
978 }
979 }
980
981 stPNL_GetVstart PNLArgs;
982 PNLArgs.u16Return = 0;
983 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETVSTART, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
984 {
985 printf("Obtain PNL engine fail\n");
986 return 0;
987 }
988 else
989 {
990 return PNLArgs.u16Return;
991 }
992 #else
993 return MAPI_PNL_GetPNLVstart_U2(pu32PNLInst);
994 #endif
995 }
996
MAPI_PNL_GetPNLWidth_U2(void * pInstance)997 MS_U16 MAPI_PNL_GetPNLWidth_U2(void *pInstance)
998 {
999 MS_U16 u16Width = 0;
1000 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1001 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1002
1003 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1004 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1005 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1006 u16Width = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16Width;
1007 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1008 return u16Width;
1009 }
1010
_getPanelWidth(void)1011 static MS_U16 _getPanelWidth (void)
1012 {
1013 #ifdef UTOPIA_20
1014 if (pu32PNLInst == NULL)
1015 {
1016 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1017 {
1018 printf("UtopiaOpen PNL failed\n");
1019 return FALSE;
1020 }
1021 }
1022
1023 stPNL_GetWidth PNLArgs;
1024 PNLArgs.u16Return = 0;
1025 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETWIDTH, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1026 {
1027 printf("Obtain PNL engine fail\n");
1028 return 0;
1029 }
1030 else
1031 {
1032 return PNLArgs.u16Return;
1033 }
1034 #else
1035 return MAPI_PNL_GetPNLWidth_U2(pu32PNLInst);
1036 #endif
1037 }
1038
MAPI_PNL_GetPNLHeight_U2(void * pInstance)1039 MS_U16 MAPI_PNL_GetPNLHeight_U2(void *pInstance)
1040 {
1041 MS_U16 u16Height = 0;
1042 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1043 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1044
1045 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1046 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1047 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1048 u16Height = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16Height;
1049 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1050 return u16Height;
1051 }
1052
_getPanelHeight(void)1053 static MS_U16 _getPanelHeight(void)
1054 {
1055 #ifdef UTOPIA_20
1056 if (pu32PNLInst == NULL)
1057 {
1058 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1059 {
1060 printf("UtopiaOpen PNL failed\n");
1061 return FALSE;
1062 }
1063 }
1064
1065 stPNL_GetHeight PNLArgs;
1066 PNLArgs.u16Return = 0;
1067 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETHEIGHT, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1068 {
1069 printf("Obtain PNL engine fail\n");
1070 return 0;
1071 }
1072 else
1073 {
1074 return PNLArgs.u16Return;
1075 }
1076 #else
1077 return MAPI_PNL_GetPNLHeight_U2(pu32PNLInst);
1078 #endif
1079 }
1080
MAPI_PNL_GetPNLHtotal_U2(void * pInstance)1081 MS_U16 MAPI_PNL_GetPNLHtotal_U2(void *pInstance)
1082 {
1083 MS_U16 u16HTotal = 0;
1084 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1085 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1086
1087 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1088 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1089 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1090 u16HTotal = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16HTotal;
1091 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1092 return u16HTotal;
1093 }
1094
_getPanelhtotal(void)1095 static MS_U16 _getPanelhtotal(void)
1096 {
1097 #ifdef UTOPIA_20
1098 if (pu32PNLInst == NULL)
1099 {
1100 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1101 {
1102 printf("UtopiaOpen PNL failed\n");
1103 return FALSE;
1104 }
1105 }
1106
1107 stPNL_GetHtotal PNLArgs;
1108 PNLArgs.u16Return = 0;
1109 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETHTOTAL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1110 {
1111 printf("Obtain PNL engine fail\n");
1112 return 0;
1113 }
1114 else
1115 {
1116 return PNLArgs.u16Return;
1117 }
1118 #else
1119 return MAPI_PNL_GetPNLHtotal_U2(pu32PNLInst);
1120 #endif
1121 }
1122
MAPI_PNL_GetPNLVtotal_U2(void * pInstance)1123 MS_U16 MAPI_PNL_GetPNLVtotal_U2(void *pInstance)
1124 {
1125 MS_U16 u16VTotal = 0;
1126 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1127 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1128
1129 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1130 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1131 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1132 u16VTotal = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16VTotal;
1133 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1134 return u16VTotal;
1135 }
1136
_getPanelVtotal(void)1137 static MS_U16 _getPanelVtotal(void)
1138 {
1139 #ifdef UTOPIA_20
1140 if (pu32PNLInst == NULL)
1141 {
1142 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1143 {
1144 printf("UtopiaOpen PNL failed\n");
1145 return FALSE;
1146 }
1147 }
1148
1149 stPNL_GetVtotal PNLArgs;
1150 PNLArgs.u16Return = 0;
1151 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETVTOTAL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1152 {
1153 printf("Obtain PNL engine fail\n");
1154 return 0;
1155 }
1156 else
1157 {
1158 return PNLArgs.u16Return;
1159 }
1160 #else
1161 return MAPI_PNL_GetPNLVtotal_U2(pu32PNLInst);
1162 #endif
1163 }
1164
MApi_PNL_GetMinSET_U2(void * pInstance)1165 MS_U32 MApi_PNL_GetMinSET_U2(void *pInstance)
1166 {
1167 MS_U32 u32MinSET = 0;
1168 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1169 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1170
1171 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1172 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1173 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1174 u32MinSET = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u32MinSET;
1175 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1176 return u32MinSET;
1177 }
1178
_getPanelMinSET(void)1179 static MS_U32 _getPanelMinSET(void)
1180 {
1181 #ifdef UTOPIA_20
1182 if (pu32PNLInst == NULL)
1183 {
1184 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1185 {
1186 printf("UtopiaOpen PNL failed\n");
1187 return FALSE;
1188 }
1189 }
1190
1191 stPNL_GetMinSET PNLArgs;
1192 PNLArgs.u32Return = 0;
1193 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETMINSET, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1194 {
1195 printf("Obtain PNL engine fail\n");
1196 return 0;
1197 }
1198 else
1199 {
1200 return PNLArgs.u32Return;
1201 }
1202 #else
1203 return MApi_PNL_GetMinSET_U2(pu32PNLInst);
1204 #endif
1205 }
1206
MApi_PNL_GetMaxSET_U2(void * pInstance)1207 MS_U32 MApi_PNL_GetMaxSET_U2(void *pInstance)
1208 {
1209 MS_U32 u32MaxSET = 0;
1210 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1211 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1212
1213 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1214 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1215 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1216 u32MaxSET = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u32MaxSET;
1217 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1218 return u32MaxSET;
1219 }
1220
_getPanelMaxSET(void)1221 static MS_U32 _getPanelMaxSET(void)
1222 {
1223 #ifdef UTOPIA_20
1224 if (pu32PNLInst == NULL)
1225 {
1226 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1227 {
1228 printf("UtopiaOpen PNL failed\n");
1229 return FALSE;
1230 }
1231 }
1232
1233 stPNL_GetMaxSET PNLArgs;
1234 PNLArgs.u32Return = 0;
1235 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETMAXSET, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1236 {
1237 printf("Obtain PNL engine fail\n");
1238 return FALSE;
1239 }
1240 else
1241 {
1242 return PNLArgs.u32Return;
1243 }
1244 #else
1245 return MApi_PNL_GetMaxSET_U2(pu32PNLInst);
1246 #endif
1247 }
1248
_getPanelDefVFreq(void)1249 static MS_U16 _getPanelDefVFreq(void)
1250 {
1251 #ifdef UTOPIA_20
1252 if (pu32PNLInst == NULL)
1253 {
1254 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1255 {
1256 printf("UtopiaOpen PNL failed\n");
1257 return FALSE;
1258 }
1259 }
1260
1261 stPNL_GetDefVFreq PNLArgs;
1262 PNLArgs.u16Return = 0;
1263 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETDEFVFREQ, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1264 {
1265 printf("Obtain PNL engine fail\n");
1266 return 0;
1267 }
1268 else
1269 {
1270 return PNLArgs.u16Return;
1271 }
1272 #else
1273 return MApi_PNL_GetDefVFreq_U2(pu32PNLInst);
1274 #endif
1275 }
1276
_getPanel_LPLL_Mode(void)1277 static MS_U8 _getPanel_LPLL_Mode(void)
1278 {
1279 #ifdef UTOPIA_20
1280 if (pu32PNLInst == NULL)
1281 {
1282 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1283 {
1284 printf("UtopiaOpen PNL failed\n");
1285 return FALSE;
1286 }
1287 }
1288
1289 stPNL_GetLPLLMode PNLArgs;
1290 PNLArgs.u8Return = E_PNL_MODE_SINGLE;
1291 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETLPLLMODE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1292 {
1293 printf("Obtain PNL engine fail\n");
1294 return E_PNL_MODE_SINGLE;
1295 }
1296 else
1297 {
1298 return PNLArgs.u8Return;
1299 }
1300 #else
1301 return MApi_PNL_GetLPLLMode_U2(pu32PNLInst);
1302 #endif
1303 }
1304
MApi_PNL_GetLPLLType_U2(void * pInstance)1305 MS_U8 MApi_PNL_GetLPLLType_U2(void *pInstance)
1306 {
1307 MS_U8 u8LPLL_Type = 0;
1308 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1309 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1310
1311 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1312 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1313 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1314 u8LPLL_Type = pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type;
1315 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1316 return u8LPLL_Type;
1317 }
1318
_getPanel_LPLL_Type(void)1319 static MS_U8 _getPanel_LPLL_Type(void)
1320 {
1321 #ifdef UTOPIA_20
1322 if (pu32PNLInst == NULL)
1323 {
1324 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1325 {
1326 printf("UtopiaOpen PNL failed\n");
1327 return FALSE;
1328 }
1329 }
1330
1331 stPNL_GetLPLLType PNLArgs;
1332 PNLArgs.u8Return = 0;
1333 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETLPLLTYPE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1334 {
1335 printf("Obtain PNL engine fail\n");
1336 return E_PNL_MODE_SINGLE;
1337 }
1338 else
1339 {
1340 return PNLArgs.u8Return;
1341 }
1342 #else
1343 return MApi_PNL_GetLPLLType_U2(pu32PNLInst);
1344 #endif
1345 }
1346
MAPI_PNL_GetPNLHsyncWidth_U2(void * pInstance)1347 MS_U8 MAPI_PNL_GetPNLHsyncWidth_U2(void *pInstance)
1348 {
1349 MS_U8 u8HSyncWidth = 0;
1350 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1351 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1352
1353 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1354 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1355 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1356 u8HSyncWidth = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8HSyncWidth;
1357 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1358 return u8HSyncWidth;
1359 }
1360
_getPanelHSyncWidth(void)1361 static MS_U8 _getPanelHSyncWidth(void)
1362 {
1363 #ifdef UTOPIA_20
1364 if (pu32PNLInst == NULL)
1365 {
1366 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1367 {
1368 printf("UtopiaOpen PNL failed\n");
1369 return FALSE;
1370 }
1371 }
1372
1373 stPNL_GetHsyncWidth PNLArgs;
1374 PNLArgs.u8Return = 0;
1375 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETHSYNCWIDTH, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1376 {
1377 printf("Obtain PNL engine fail\n");
1378 return 0;
1379 }
1380 else
1381 {
1382 return PNLArgs.u8Return;
1383 }
1384 #else
1385 return MAPI_PNL_GetPNLHsyncWidth_U2(pu32PNLInst);
1386 #endif
1387 }
1388
MAPI_PNL_GetPNLHsyncBackPorch_U2(void * pInstance)1389 MS_U8 MAPI_PNL_GetPNLHsyncBackPorch_U2(void *pInstance)
1390 {
1391 MS_U8 u8PanelHSyncBackPorch = 0;
1392 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1393 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1394
1395 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1396 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1397 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1398 u8PanelHSyncBackPorch = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelHSyncBackPorch;
1399 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1400 return u8PanelHSyncBackPorch;
1401 }
1402
_getPanelHSyncBackPorch(void)1403 static MS_U8 _getPanelHSyncBackPorch(void)
1404 {
1405 #ifdef UTOPIA_20
1406 if (pu32PNLInst == NULL)
1407 {
1408 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1409 {
1410 printf("UtopiaOpen PNL failed\n");
1411 return FALSE;
1412 }
1413 }
1414
1415 stPNL_GetHsyncBackPorch PNLArgs;
1416 PNLArgs.u8Return = 0;
1417 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETHSYNCBACKPORCH, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1418 {
1419 printf("Obtain PNL engine fail\n");
1420 return 0;
1421 }
1422 else
1423 {
1424 return PNLArgs.u8Return;
1425 }
1426 #else
1427 return MAPI_PNL_GetPNLHsyncBackPorch_U2(pu32PNLInst);
1428 #endif
1429 }
1430
MAPI_PNL_GetPNLVsyncBackPorch_U2(void * pInstance)1431 MS_U8 MAPI_PNL_GetPNLVsyncBackPorch_U2(void *pInstance)
1432 {
1433 MS_U8 u8PanelVBackPorch = 0;
1434 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1435 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1436
1437 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1438 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1439 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1440 u8PanelVBackPorch = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelVBackPorch;
1441 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1442 return u8PanelVBackPorch;
1443 }
1444
_getPanelVSyncBackPorch(void)1445 static MS_U8 _getPanelVSyncBackPorch(void)
1446 {
1447 #ifdef UTOPIA_20
1448 if (pu32PNLInst == NULL)
1449 {
1450 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1451 {
1452 printf("UtopiaOpen PNL failed\n");
1453 return FALSE;
1454 }
1455 }
1456
1457 stPNL_GetVsyncBackPorch PNLArgs;
1458 PNLArgs.u8Return = 0;
1459 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETVSYNCBACKPORCH, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1460 {
1461 printf("Obtain PNL engine fail\n");
1462 return 0;
1463 }
1464 else
1465 {
1466 return PNLArgs.u8Return;
1467 }
1468 #else
1469 return MAPI_PNL_GetPNLVsyncBackPorch_U2(pu32PNLInst);
1470 #endif
1471 }
1472
MApi_PNL_GetName_U2(void * pInstance)1473 const char* MApi_PNL_GetName_U2(void *pInstance)
1474 {
1475 const char* pPanelName;
1476 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1477 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1478
1479 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1480 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1481 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1482 pPanelName = pPNLResourcePrivate->stdrvPNL._stPnlInitData.pPanelName;
1483 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1484 return pPanelName;
1485 }
1486
_getPanelName(void)1487 static const char* _getPanelName(void)
1488 {
1489 #ifdef UTOPIA_20
1490 if (pu32PNLInst == NULL)
1491 {
1492 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1493 {
1494 printf("UtopiaOpen PNL failed\n");
1495 return FALSE;
1496 }
1497 }
1498 static char panelName[20];
1499 stPNL_GetName PNLArgs;
1500 PNLArgs.pPNLName = panelName;
1501 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETPANELNAME, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1502 {
1503 printf("Obtain PNL engine fail\n");
1504 return NULL;
1505 }
1506 else
1507 {
1508 return PNLArgs.pPNLName;
1509 }
1510 #else
1511 return MApi_PNL_GetName_U2(pu32PNLInst);
1512 #endif
1513 }
1514
MApi_PNL_GetARC_U2(void * pInstance)1515 E_PNL_ASPECT_RATIO MApi_PNL_GetARC_U2(void *pInstance)
1516 {
1517 E_PNL_ASPECT_RATIO ePanelAspectRatio = E_PNL_ASPECT_RATIO_OTHER;
1518 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1519 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1520
1521 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1522 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1523 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1524 ePanelAspectRatio = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelAspectRatio;
1525 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1526 return ePanelAspectRatio;
1527 }
1528
_getPanel_ARC(void)1529 static E_PNL_ASPECT_RATIO _getPanel_ARC(void)
1530 {
1531 #ifdef UTOPIA_20
1532 if (pu32PNLInst == NULL)
1533 {
1534 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1535 {
1536 printf("UtopiaOpen PNL failed\n");
1537 return FALSE;
1538 }
1539 }
1540
1541 stPNL_GetARC PNLArgs;
1542 PNLArgs.ePanelAspectRatio = E_PNL_ASPECT_RATIO_OTHER;
1543 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETARC, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1544 {
1545 printf("Obtain PNL engine fail\n");
1546 return E_PNL_MODE_SINGLE;
1547 }
1548 else
1549 {
1550 return PNLArgs.ePanelAspectRatio;
1551 }
1552 #else
1553 return MApi_PNL_GetARC_U2(pu32PNLInst);
1554 #endif
1555 }
1556
MApi_PNL_GetOutTimingMode_U2(void * pInstance)1557 APIPNL_OUT_TIMING_MODE MApi_PNL_GetOutTimingMode_U2(void *pInstance)
1558 {
1559 APIPNL_OUT_TIMING_MODE ePanelOutTimingMode;
1560 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1561 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1562
1563 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1564 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1565 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1566 ePanelOutTimingMode = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelOutTimingMode;
1567 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1568 return ePanelOutTimingMode;
1569 }
1570
_getOutTimingMode(void)1571 static APIPNL_OUT_TIMING_MODE _getOutTimingMode(void)
1572 {
1573 #ifdef UTOPIA_20
1574 if (pu32PNLInst == NULL)
1575 {
1576 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1577 {
1578 printf("UtopiaOpen PNL failed\n");
1579 return FALSE;
1580 }
1581 }
1582
1583 stPNL_GetOutTimingMode PNLArgs;
1584 PNLArgs.ePanelOutTimingMode = 0;
1585 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETOUTTIMINGMODE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1586 {
1587 printf("Obtain PNL engine fail\n");
1588 return FALSE;
1589 }
1590 else
1591 {
1592 return PNLArgs.ePanelOutTimingMode;
1593 }
1594 #else
1595 return MApi_PNL_GetOutTimingMode_U2(pu32PNLInst);
1596 #endif
1597 }
1598
1599
1600 XC_PNL_OBJ g_IPanel =
1601 {
1602 //
1603 // Data
1604 //
1605 .Name = _getPanelName,
1606 .HStart = _getPanelHstart,
1607 .VStart = _getPanelVstart,
1608 .Width = _getPanelWidth,
1609 .Height = _getPanelHeight,
1610 .HTotal = _getPanelhtotal,
1611 .VTotal = _getPanelVtotal,
1612 .HSynWidth = _getPanelHSyncWidth,
1613 .HSynBackPorch = _getPanelHSyncBackPorch,
1614 .VSynBackPorch = _getPanelVSyncBackPorch,
1615 .DefaultVFreq = _getPanelDefVFreq,
1616 .LPLL_Mode = _getPanel_LPLL_Mode, /* 0: single, 1: dual mode */
1617 .LPLL_Type = _getPanel_LPLL_Type,
1618 .AspectRatio = _getPanel_ARC,
1619 .MinSET = _getPanelMinSET,
1620 .MaxSET = _getPanelMaxSET,
1621 .OutTimingMode = _getOutTimingMode,
1622 // Manipulation
1623 //
1624 .SetSSC = MApi_PNL_SetSSC,
1625 .Enable = MApi_PNL_EnablePanel,
1626 .SetGammaTbl = MApi_PNL_SetGammaTbl,
1627 .GammaTab = MApi_PNL_GetAllGammaTbl,
1628 .Dump = MApi_PNL_DumpPanelData,
1629 .DimCtrl = MApi_PNL_GetPanelDimCtrl,
1630 .OnTiming = MApi_PNL_GetPanelOnTiming,
1631 .OffTiming = MApi_PNL_GetPanelOffTiming,
1632 //
1633 // Custimized methods, can be provided by clinets.
1634 //
1635 .TurnBackLightOn = _EmptyMethod,
1636 .SetGammaValue = MApi_PNL_SetGammaValue,
1637 .GetGammaTbl = MApi_PNL_GetGammaTbl,
1638 };
1639
1640
1641 /******************************************************************************/
1642 // Public function
1643 //
1644 /******************************************************************************/
1645
1646
1647 ////////////////////////////////////////////////////////////////////////////////
1648 /// @brief Get the version of apiPNL lib, (without Mutex protect)
1649 /// @param[out] ppVersion \b output apiPNL lib version
1650 /// @return @ref APIPNL_Result
1651 ////////////////////////////////////////////////////////////////////////////////
MApi_PNL_GetLibVer_U2(void * pInstance,const MSIF_Version ** ppVersion)1652 APIPNL_Result MApi_PNL_GetLibVer_U2(void *pInstance, const MSIF_Version **ppVersion)
1653 {
1654 if (!ppVersion)
1655 {
1656 return E_APIPNL_FAIL;
1657 }
1658
1659 *ppVersion = &_api_pnl_version;
1660 return E_APIPNL_OK;
1661 }
1662
MApi_PNL_GetLibVer(const MSIF_Version ** ppVersion)1663 APIPNL_Result MApi_PNL_GetLibVer(const MSIF_Version **ppVersion)
1664 {
1665 #ifdef UTOPIA_20
1666 if (pu32PNLInst == NULL)
1667 {
1668 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1669 {
1670 printf("UtopiaOpen PNL failed\n");
1671 return E_APIPNL_FAIL;
1672 }
1673 }
1674
1675 stPNL_GetLibVer PNLArgs;
1676 PNLArgs.ppVersion = ppVersion;
1677 PNLArgs.eResult = E_APIPNL_FAIL;
1678 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETLIBVER, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1679 {
1680 printf("Obtain PNL engine fail\n");
1681 return E_APIPNL_FAIL;
1682 }
1683 else
1684 {
1685 return PNLArgs.eResult;
1686 }
1687 #else
1688 return MApi_PNL_GetLibVer_U2(pu32PNLInst, ppVersion);
1689 #endif
1690 }
1691
MApi_PNL_GetInfo_U2(void * pInstance)1692 const PNL_ApiInfo* MApi_PNL_GetInfo_U2(void *pInstance) ///< Get info from driver
1693 {
1694 ST_PNL_DRV_INFO stPNLDRVInfo = MDrv_PNL_GetInfo(pInstance);
1695 PNL_ApiInfo* pstReturnInfo = NULL;
1696 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1697 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1698
1699 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1700 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1701 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1702 if ((stPNLDRVInfo.u8SupportGammaType & E_DRVPNL_GAMMA_10BIT) && (stPNLDRVInfo.u8SupportGammaType & E_DRVPNL_GAMMA_12BIT))
1703 {
1704 pPNLResourcePrivate->stapiPNL._cstPnlInfo.eSupportGammaType = E_APIPNL_GAMMA_ALL;
1705 }
1706 else if ( stPNLDRVInfo.u8SupportGammaType & E_DRVPNL_GAMMA_12BIT )
1707 {
1708 pPNLResourcePrivate->stapiPNL._cstPnlInfo.eSupportGammaType = E_APIPNL_GAMMA_12BIT;
1709 }
1710 else if ( stPNLDRVInfo.u8SupportGammaType & E_DRVPNL_GAMMA_10BIT )
1711 {
1712 pPNLResourcePrivate->stapiPNL._cstPnlInfo.eSupportGammaType = E_APIPNL_GAMMA_10BIT;
1713 }
1714 else
1715 {
1716 PNL_ASSERT(0, "[%s] fails Invalid eSupportGammaType( %d ) found, please check your library.\n",
1717 __FUNCTION__, stPNLDRVInfo.u8SupportGammaType );
1718 }
1719
1720 pstReturnInfo = &pPNLResourcePrivate->stapiPNL._cstPnlInfo;
1721 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1722
1723 return pstReturnInfo;
1724 }
1725
MApi_PNL_GetInfo(void)1726 const PNL_ApiInfo* MApi_PNL_GetInfo(void) ///< Get info from driver
1727 {
1728 #ifdef UTOPIA_20
1729 if (pu32PNLInst == NULL)
1730 {
1731 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1732 {
1733 printf("UtopiaOpen PNL failed\n");
1734 return NULL;
1735 }
1736 }
1737
1738 stPNL_GetInfo PNLArgs;
1739 PNLArgs.pApiInfo = NULL;
1740 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETINFO, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1741 {
1742 printf("Obtain PNL engine fail\n");
1743 return NULL;
1744 }
1745 else
1746 {
1747 return PNLArgs.pApiInfo;
1748 }
1749 #else
1750 return MApi_PNL_GetInfo_U2(pu32PNLInst);
1751 #endif
1752 }
1753
1754 ////////////////////////////////////////////////////////////////////////////////
1755 /// @brief Extended API of getting current panel status
1756 /// @param[in] pPnlExtStatus @ref PNL_ApiExtStatus
1757 ////////////////////////////////////////////////////////////////////////////////
MApi_PNL_GetStatusEx_U2(void * pInstance,PNL_ApiExtStatus * pPnlExtStatus)1758 MS_BOOL MApi_PNL_GetStatusEx_U2(void *pInstance, PNL_ApiExtStatus *pPnlExtStatus)
1759 {
1760 PNL_TimingInfo stPNLTiming;
1761 PNL_ApiExtStatus stPnlExtStatus;
1762 MS_U16 u16CopyLength = sizeof(PNL_ApiExtStatus);
1763 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1764 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1765
1766 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1767
1768 if((NULL == pPnlExtStatus) || (pPnlExtStatus->u16ApiStatusEX_Length == 0))
1769 {
1770 //Invalid input parameter
1771 return FALSE;
1772 }
1773 memset(&stPNLTiming,0,sizeof(PNL_TimingInfo));
1774 memset(&stPnlExtStatus,0,sizeof(PNL_ApiExtStatus));
1775
1776 if(pPnlExtStatus->u16ApiStatusEX_Length < u16CopyLength) //Lib structure size > AP's using structure size ?
1777 {
1778 //Only copy the AP recongnized member
1779 u16CopyLength = pPnlExtStatus->u16ApiStatusEX_Length;
1780 }
1781
1782 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1783 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1784 stPnlExtStatus.bPNLInitialize= pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Initialized;
1785 stPnlExtStatus.bPNLEnable = pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Enabled;
1786
1787 if(MDrv_PNL_GetDataFromRegister(pInstance, &stPNLTiming))
1788 {
1789 // Vertical
1790 stPnlExtStatus.u16VTotal = stPNLTiming.u16VTotal+1; //Total +1
1791 stPnlExtStatus.u16DEVStart = stPNLTiming.u16DEVStart;
1792 stPnlExtStatus.u16DEVEnd = stPNLTiming.u16DEVEnd;
1793 stPnlExtStatus.u16VSyncStart= stPNLTiming.u16VSyncStart;
1794 stPnlExtStatus.u16VSyncEnd = stPNLTiming.u16VSyncEnd+1;//For SyncWidth need + 1
1795
1796 // Horizontal
1797 stPnlExtStatus.u16HTotal = stPNLTiming.u16HTotal+1; //Total +1
1798 stPnlExtStatus.u16DEHStart = stPNLTiming.u16DEHStart ;
1799 stPnlExtStatus.u16DEHEnd = stPNLTiming.u16DEHEnd ;
1800 stPnlExtStatus.u16HSyncWidth= stPNLTiming.u16HSyncWidth+1;//For SyncWidth need + 1
1801 stPnlExtStatus.bIsPanelManualVysncMode = stPNLTiming.bIsPanelManualVysncMode ;
1802 stPnlExtStatus.bInterlaceOutput = stPNLTiming.bInterlaceOutput;
1803 stPnlExtStatus.bYUVOutput = MDrv_PNL_isYUVOutput(pInstance);
1804 }
1805 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1806 memcpy(pPnlExtStatus, &stPnlExtStatus, u16CopyLength);
1807 return TRUE;
1808 }
1809
MApi_PNL_GetStatusEx(PNL_ApiExtStatus * pPnlExtStatus)1810 MS_BOOL MApi_PNL_GetStatusEx(PNL_ApiExtStatus *pPnlExtStatus)
1811 {
1812 #ifdef UTOPIA_20
1813 if (pu32PNLInst == NULL)
1814 {
1815 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1816 {
1817 printf("UtopiaOpen PNL failed\n");
1818 return FALSE;
1819 }
1820 }
1821
1822 stPNL_GetStatusEx PNLArgs;
1823 PNLArgs.pPnlExtStatus = pPnlExtStatus;
1824 PNLArgs.bReturn = FALSE;
1825 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETSTATUSEX, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1826 {
1827 printf("Obtain PNL engine fail\n");
1828 return FALSE;
1829 }
1830 else
1831 {
1832 return PNLArgs.bReturn;
1833 }
1834 #else
1835 return MApi_PNL_GetStatusEx_U2(pu32PNLInst, pPnlExtStatus);
1836 #endif
1837 }
1838
1839 ////////////////////////////////////////////////////////////////////////////////
1840 /// @brief Get current panel status
1841 /// @param[in] pPnlStatus @ref PNL_ApiStatus
1842 ////////////////////////////////////////////////////////////////////////////////
MApi_PNL_GetStatus_U2(void * pInstance,PNL_ApiStatus * pPnlStatus)1843 MS_BOOL MApi_PNL_GetStatus_U2(void *pInstance, PNL_ApiStatus *pPnlStatus)
1844 {
1845 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1846 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
1847
1848 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
1849 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1850 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
1851
1852 pPnlStatus->bPanel_Initialized = pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Initialized;
1853 pPnlStatus->bPanel_Enabled = pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Enabled;
1854
1855 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
1856 return TRUE;
1857 }
1858
MApi_PNL_GetStatus(PNL_ApiStatus * pPnlStatus)1859 MS_BOOL MApi_PNL_GetStatus(PNL_ApiStatus *pPnlStatus)
1860 {
1861 #ifdef UTOPIA_20
1862 if (pu32PNLInst == NULL)
1863 {
1864 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1865 {
1866 printf("UtopiaOpen PNL failed\n");
1867 return FALSE;
1868 }
1869 }
1870
1871 stPNL_GetStatus PNLArgs;
1872 PNLArgs.pPnlStatus = pPnlStatus;
1873 PNLArgs.bReturn = FALSE;
1874 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETSTATUS, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1875 {
1876 printf("Obtain PNL engine fail\n");
1877 return FALSE;
1878 }
1879 else
1880 {
1881 return PNLArgs.bReturn;
1882 }
1883 #else
1884 return MApi_PNL_GetStatus_U2(pu32PNLInst, pPnlStatus);
1885 #endif
1886 }
1887
1888 /// Set debug level (without Mutex protect)
MApi_PNL_SetDbgLevel_U2(void * pInstance,MS_U16 u16DbgSwitch)1889 MS_BOOL MApi_PNL_SetDbgLevel_U2(void *pInstance, MS_U16 u16DbgSwitch)
1890 {
1891 _u16PnlDbgSwitch = u16DbgSwitch;
1892 return TRUE;
1893 }
1894
MApi_PNL_SetDbgLevel(MS_U16 u16DbgSwitch)1895 MS_BOOL MApi_PNL_SetDbgLevel(MS_U16 u16DbgSwitch)
1896 {
1897 #ifdef UTOPIA_20
1898 if (pu32PNLInst == NULL)
1899 {
1900 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1901 {
1902 printf("UtopiaOpen PNL failed\n");
1903 return FALSE;
1904 }
1905 }
1906
1907 stPNL_SetDbgLevel PNLArgs;
1908 PNLArgs.u16DbgSwitch = u16DbgSwitch;
1909 PNLArgs.bReturn = FALSE;
1910 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETDBGLEVEL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1911 {
1912 printf("Obtain PNL engine fail\n");
1913 return FALSE;
1914 }
1915 else
1916 {
1917 return PNLArgs.bReturn;
1918 }
1919 #else
1920 return MApi_PNL_SetDbgLevel_U2(pu32PNLInst, u16DbgSwitch);
1921 #endif
1922 }
1923
MApi_PNL_IOMapBaseInit_U2(void * pInstance)1924 MS_BOOL MApi_PNL_IOMapBaseInit_U2(void *pInstance)
1925 {
1926 MS_BOOL bResult = FALSE;
1927 if (-1==_s32PNLMutex)
1928 {
1929 _s32PNLMutex = MsOS_CreateMutex(E_MSOS_FIFO, "_PNL_Mutex", MSOS_PROCESS_SHARED);
1930 if (-1 == _s32PNLMutex)
1931 {
1932 MS_CRITICAL_MSG(printf("[MAPI PNL][%06d] create mutex fail\n", __LINE__));
1933 return FALSE;
1934 }
1935 }
1936
1937 bResult =(MDrv_PNL_Init(pInstance) == E_PNL_OK);
1938
1939 return bResult;
1940 }
1941
1942 #ifdef MSOS_TYPE_LINUX
1943 //those code is temporary just for MWB warning software patch.
1944 //if utopia_init will has be refined in the future, those code will be deleted.
1945 extern void XCRegisterToUtopia(FUtopiaOpen ModuleType);
1946 extern void GOPRegisterToUtopia(void);
1947 extern void GFXRegisterToUtopia(FUtopiaOpen ModuleType);
1948 #endif
1949
MApi_PNL_IOMapBaseInit(void)1950 MS_BOOL MApi_PNL_IOMapBaseInit(void)
1951 {
1952
1953 #ifdef MSOS_TYPE_LINUX
1954 //those code is temporary just for MWB warning software patch.
1955 //if utopia_init will has be refined in the future, those code will be deleted.
1956 PNLRegisterToUtopia(NULL);
1957 XCRegisterToUtopia((FUtopiaOpen)XCOpenFull);
1958 GOPRegisterToUtopia();
1959 GFXRegisterToUtopia((FUtopiaOpen) GFXOpen);
1960 #endif
1961
1962 #ifdef UTOPIA_20
1963 if (pu32PNLInst == NULL)
1964 {
1965 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1966 {
1967 printf("UtopiaOpen PNL failed\n");
1968 return FALSE;
1969 }
1970 }
1971
1972 stPNL_IOMapBaseInit PNLArgs;
1973 PNLArgs.bReturn = FALSE;
1974 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_IOMAPBASEINIT, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1975 {
1976 printf("Obtain PNL engine fail\n");
1977 return FALSE;
1978 }
1979 else
1980 {
1981 return PNLArgs.bReturn;
1982 }
1983 #else
1984 return MApi_PNL_IOMapBaseInit_U2(pu32PNLInst);
1985 #endif
1986 }
1987
1988 //////////////////////////////////////////////////////////////////////
1989 /**
1990 *
1991 * @brief Give some options for panel init.
1992 *
1993 * @param[in] pSelPanelType a given panel type choosed by user.
1994 *
1995 */
MApi_PNL_PreInit_U2(void * pInstance,E_PNL_PREINIT_OPTIONS eInitParam)1996 MS_BOOL MApi_PNL_PreInit_U2(void *pInstance, E_PNL_PREINIT_OPTIONS eInitParam)
1997 {
1998 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
1999 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2000
2001 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2002 if ( eInitParam == E_PNL_NO_OUTPUT)
2003 {
2004 MDrv_PNL_PreInit(pInstance, E_PNL_OUTPUT_NO_OUTPUT);
2005 }
2006 else if ( eInitParam == E_PNL_CLK_ONLY)
2007 {
2008 MDrv_PNL_PreInit(pInstance, E_PNL_OUTPUT_CLK_ONLY);
2009 }
2010 else if ( eInitParam == E_PNL_CLK_DATA)
2011 {
2012 MDrv_PNL_PreInit(pInstance, E_PNL_OUTPUT_CLK_DATA);
2013 }
2014 else
2015 {
2016 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2017 return FALSE;
2018 }
2019
2020 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2021 return TRUE;
2022 }
2023
MApi_PNL_PreInit(E_PNL_PREINIT_OPTIONS eInitParam)2024 MS_BOOL MApi_PNL_PreInit(E_PNL_PREINIT_OPTIONS eInitParam)
2025 {
2026 if (pu32PNLInst == NULL)
2027 {
2028 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2029 {
2030 printf("UtopiaOpen PNL failed\n");
2031 return FALSE;
2032 }
2033 }
2034
2035 #ifdef UTOPIA_20
2036 stPNL_PreInit PNLArgs;
2037 PNLArgs.eInitParam = eInitParam;
2038 PNLArgs.bReturn = FALSE;
2039 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_PREINIT, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2040 {
2041 printf("Obtain PNL engine fail\n");
2042 return FALSE;
2043 }
2044 else
2045 {
2046 return PNLArgs.bReturn;
2047 }
2048 #else
2049 return MApi_PNL_PreInit_U2(pu32PNLInst, eInitParam);
2050 #endif
2051 }
2052
2053 //////////////////////////////////////////////////////////////////////
2054 /**
2055 *
2056 * @brief Initialize the global panel object with a given PanelType
2057 *
2058 * @param[in] pSelPanelType a given panel type choosed by user.
2059 *
2060 */
MApi_PNL_Init_U2(void * pInstance,PanelType * pSelPanelType)2061 MS_BOOL MApi_PNL_Init_U2(void *pInstance, PanelType *pSelPanelType/* <in > */)
2062 {
2063 if (-1==_s32PNLMutex)
2064 {
2065 _s32PNLMutex = MsOS_CreateMutex(E_MSOS_FIFO, "_PNL_Mutex", MSOS_PROCESS_SHARED);
2066 if (-1 == _s32PNLMutex)
2067 {
2068 MS_CRITICAL_MSG(printf("[MAPI PNL][%06d] create mutex fail\n", __LINE__));
2069 return FALSE;
2070 }
2071 }
2072 #if (KERNEL_DRIVER_PNL_STR_PATCH == 1)
2073 void *pModule;
2074 UtopiaInstanceGetModule(pInstance, &pModule);
2075 PNL_REGS_SAVE_AREA *pPNLResourceStr = NULL;
2076 UtopiaModuleGetSTRPrivate(pModule, (void**)&pPNLResourceStr);
2077 memcpy(&pPNLResourceStr->pSelPanelType,pSelPanelType,sizeof(PanelType));
2078 #endif
2079
2080 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
2081 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
2082
2083 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2084 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2085 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
2086 //MApi_XC_PNL_Init(&g_IPanel, outPanelInfo);//_MApi_XC_Panel_Init(&(sXC_InitData.sPanelInfo));
2087 if(MDrv_PNL_Init(pInstance) != E_PNL_OK) //Init MMIO and gamma clk
2088 {
2089 OS_DELETE_MUTEX(_s32PNLMutex);
2090
2091 MS_CRITICAL_MSG(printf("Panel init error, check the message from driver\n"));
2092
2093 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2094 return FALSE;
2095 }
2096
2097 if(pSelPanelType)
2098 {
2099 _PNL_ENTRY();
2100 _SetPanelParams(pInstance, pSelPanelType);
2101 pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Initialized = TRUE;
2102 _PNL_RETURN();
2103 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2104 return TRUE;
2105 }
2106 else
2107 {
2108 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2109 return FALSE;
2110 }
2111 }
2112
MApi_PNL_Init(PanelType * pSelPanelType)2113 MS_BOOL MApi_PNL_Init(PanelType *pSelPanelType/* <in > */)
2114 {
2115 if (pu32PNLInst == NULL)
2116 {
2117 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2118 {
2119 printf("UtopiaOpen PNL failed\n");
2120 return FALSE;
2121 }
2122 }
2123 #ifdef UTOPIA_20
2124 stPNL_Init PNLArgs;
2125 PNLArgs.pSelPanelType = pSelPanelType;
2126 PNLArgs.bReturn = FALSE;
2127 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_INIT, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2128 {
2129 printf("Obtain PNL engine fail\n");
2130 return FALSE;
2131 }
2132 else
2133 {
2134 return PNLArgs.bReturn;
2135 }
2136 #else
2137 return MApi_PNL_Init_U2(pu32PNLInst, pSelPanelType);
2138 #endif
2139
2140 }
2141
2142 //////////////////////////////////////////////////////////////////////
2143 //
2144 //
2145 //////////////////////////////////////////////////////////////////////
MApi_PNL_Init_Ex_U2(void * pInstance,PanelType * pSelPanelType,MSIF_Version LIBVER)2146 MS_BOOL MApi_PNL_Init_Ex_U2(void *pInstance, PanelType *pSelPanelType/* <in > */, MSIF_Version LIBVER)
2147 {
2148 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
2149 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
2150
2151 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2152 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2153 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
2154 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2155
2156 // save version info
2157 {
2158 memcpy(( MS_U8* )&pPNLResourcePrivate->_api_pnl_version_sel, ( MS_U8* )(&LIBVER), sizeof( MSIF_Version) );
2159 }
2160
2161 return MApi_PNL_Init_U2(pInstance, pSelPanelType);
2162 }
2163
MApi_PNL_Init_Ex(PanelType * pSelPanelType,MSIF_Version LIBVER)2164 MS_BOOL MApi_PNL_Init_Ex(PanelType *pSelPanelType/* <in > */, MSIF_Version LIBVER)
2165 {
2166 if (pu32PNLInst == NULL)
2167 {
2168 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2169 {
2170 printf("UtopiaOpen PNL failed\n");
2171 return FALSE;
2172 }
2173 }
2174
2175 #ifdef UTOPIA_20
2176 stPNL_Init_Ex PNLArgs;
2177 PNLArgs.pSelPanelType = pSelPanelType;
2178 PNLArgs.LIBVER = LIBVER;
2179 PNLArgs.bReturn = FALSE;
2180 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_INIT_EX, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2181 {
2182 printf("Obtain PNL engine fail\n");
2183 return FALSE;
2184 }
2185 else
2186 {
2187 return PNLArgs.bReturn;
2188 }
2189 #else
2190 return MApi_PNL_Init_Ex_U2(pu32PNLInst, pSelPanelType, LIBVER);
2191 #endif
2192 }
2193
MApi_PNL_GetConfig_U2(void * pInstance,PanelType * pSelPanelType)2194 APIPNL_Result MApi_PNL_GetConfig_U2(void *pInstance, PanelType *pSelPanelType)
2195 {
2196 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
2197 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
2198
2199 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2200 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2201 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
2202 if(pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Initialized)
2203 {
2204 memcpy(pSelPanelType, &(pPNLResourcePrivate->stapiPNL._stPanelTypeSaved), sizeof(PanelType));
2205 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2206 return E_APIPNL_OK;
2207 }
2208 else
2209 {
2210 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2211 return E_APIPNL_FAIL;
2212
2213 }
2214 }
2215
MApi_PNL_GetConfig(PanelType * pSelPanelType)2216 APIPNL_Result MApi_PNL_GetConfig(PanelType *pSelPanelType)
2217 {
2218 #ifdef UTOPIA_20
2219 if (pu32PNLInst == NULL)
2220 {
2221 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2222 {
2223 printf("UtopiaOpen PNL failed\n");
2224 return E_APIPNL_FAIL;
2225 }
2226 }
2227
2228 stPNL_GetConfig PNLArgs;
2229 PNLArgs.pSelPanelType = pSelPanelType;
2230 PNLArgs.eReturn = E_APIPNL_FAIL;
2231 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GET_CONFIG, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2232 {
2233 printf("Obtain PNL engine fail\n");
2234 return E_APIPNL_FAIL;
2235 }
2236 else
2237 {
2238 return PNLArgs.eReturn;
2239 }
2240 #else
2241 return MApi_PNL_GetConfig_U2(pu32PNLInst, pSelPanelType);
2242 #endif
2243 }
2244
MApi_PNL_Control_Out_Swing_U2(void * pInstance,MS_U16 u16Swing_Level)2245 MS_BOOL MApi_PNL_Control_Out_Swing_U2(void *pInstance, MS_U16 u16Swing_Level)
2246 {
2247 #if 0
2248 if((pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type_Ext == E_PNL_LPLL_VBY1_10BIT_4LANE)
2249 ||(pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type_Ext == E_PNL_LPLL_VBY1_10BIT_2LANE))
2250 {
2251 u16Swing_Level = 600;
2252 }
2253 #endif
2254 MS_BOOL bReturn = FALSE;
2255 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
2256
2257 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2258 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2259 bReturn = MDrv_PNL_Control_Out_Swing(pInstance, u16Swing_Level);
2260 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2261
2262 return bReturn;
2263 }
2264
MApi_PNL_Control_Out_Swing(MS_U16 u16Swing_Level)2265 MS_BOOL MApi_PNL_Control_Out_Swing(MS_U16 u16Swing_Level)
2266 {
2267 #ifdef UTOPIA_20
2268 if (pu32PNLInst == NULL)
2269 {
2270 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2271 {
2272 printf("UtopiaOpen PNL failed\n");
2273 return FALSE;
2274 }
2275 }
2276
2277 stPNL_Control_Out_Swing PNLArgs;
2278 PNLArgs.u16Swing_Level = u16Swing_Level;
2279 PNLArgs.bReturn = FALSE;
2280 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_CONTROL_OUT_SWING, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2281 {
2282 printf("Obtain PNL engine fail\n");
2283 return FALSE;
2284 }
2285 else
2286 {
2287 return PNLArgs.bReturn;
2288 }
2289 #else
2290 return MApi_PNL_Control_Out_Swing_U2(pu32PNLInst, u16Swing_Level);
2291 #endif
2292 }
2293
MApi_PNL_ForceSetPanelDCLK_U2(void * pInstance,MS_U16 u16PanelDCLK,MS_BOOL bSetDCLKEnable)2294 MS_BOOL MApi_PNL_ForceSetPanelDCLK_U2(void *pInstance, MS_U16 u16PanelDCLK ,MS_BOOL bSetDCLKEnable)
2295 {
2296 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
2297 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
2298
2299 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2300 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2301 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
2302 pPNLResourcePrivate->stapiPNL._u16PanelDCLK = u16PanelDCLK;
2303 pPNLResourcePrivate->stapiPNL._bForceSetDCLKEnable = bSetDCLKEnable;
2304 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2305 return TRUE;
2306 }
2307
MApi_PNL_ForceSetPanelDCLK(MS_U16 u16PanelDCLK,MS_BOOL bSetDCLKEnable)2308 MS_BOOL MApi_PNL_ForceSetPanelDCLK(MS_U16 u16PanelDCLK ,MS_BOOL bSetDCLKEnable)
2309 {
2310 #ifdef UTOPIA_20
2311 if (pu32PNLInst == NULL)
2312 {
2313 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2314 {
2315 printf("UtopiaOpen PNL failed\n");
2316 return FALSE;
2317 }
2318 }
2319
2320 stPNL_ForceSetPanelDCLK PNLArgs;
2321 PNLArgs.u16PanelDCLK = u16PanelDCLK;
2322 PNLArgs.bSetDCLKEnable = bSetDCLKEnable;
2323 PNLArgs.bReturn = FALSE;
2324 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_FORCESETPANELDCLK, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2325 {
2326 printf("Obtain PNL engine fail\n");
2327 return FALSE;
2328 }
2329 else
2330 {
2331 return PNLArgs.bReturn;
2332 }
2333 #else
2334 return MApi_PNL_ForceSetPanelDCLK_U2(pu32PNLInst, u16PanelDCLK, bSetDCLKEnable);
2335 #endif
2336 }
2337
MApi_PNL_ForceSetPanelHStart_U2(void * pInstance,MS_U16 u16PanelHStart,MS_BOOL bSetHStartEnable)2338 MS_BOOL MApi_PNL_ForceSetPanelHStart_U2(void *pInstance, MS_U16 u16PanelHStart ,MS_BOOL bSetHStartEnable)
2339 {
2340 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
2341 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
2342
2343 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2344 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2345 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
2346 pPNLResourcePrivate->stapiPNL._u16PanelHStart = u16PanelHStart;
2347 pPNLResourcePrivate->stapiPNL._bForceSetHStartEnable = bSetHStartEnable;
2348 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2349 return TRUE;
2350 }
2351
MApi_PNL_ForceSetPanelHStart(MS_U16 u16PanelHStart,MS_BOOL bSetHStartEnable)2352 MS_BOOL MApi_PNL_ForceSetPanelHStart(MS_U16 u16PanelHStart ,MS_BOOL bSetHStartEnable)
2353 {
2354 #ifdef UTOPIA_20
2355 if (pu32PNLInst == NULL)
2356 {
2357 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2358 {
2359 printf("UtopiaOpen PNL failed\n");
2360 return FALSE;
2361 }
2362 }
2363
2364 stPNL_ForceSetPanelHStart PNLArgs;
2365 PNLArgs.u16PanelHStart = u16PanelHStart;
2366 PNLArgs.bSetHStartEnable = bSetHStartEnable;
2367 PNLArgs.bReturn = FALSE;
2368 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_FORCESETPANELHSTART, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2369 {
2370 printf("Obtain PNL engine fail\n");
2371 return FALSE;
2372 }
2373 else
2374 {
2375 return PNLArgs.bReturn;
2376 }
2377 #else
2378 return MApi_PNL_ForceSetPanelHStart_U2(pu32PNLInst, u16PanelHStart, bSetHStartEnable);
2379 #endif
2380 }
2381
MApi_PNL_SetOutput_U2(void * pInstance,APIPNL_OUTPUT_MODE eOutputMode)2382 void MApi_PNL_SetOutput_U2(void *pInstance, APIPNL_OUTPUT_MODE eOutputMode)
2383 {
2384 PNL_OUTPUT_MODE ePnlOutputMode;
2385 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
2386 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
2387
2388 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2389
2390 switch(eOutputMode)
2391 {
2392 case E_APIPNL_OUTPUT_NO_OUTPUT:
2393 ePnlOutputMode = E_PNL_OUTPUT_NO_OUTPUT;
2394 break;
2395
2396 case E_APIPNL_OUTPUT_CLK_ONLY:
2397 ePnlOutputMode = E_PNL_OUTPUT_CLK_ONLY;
2398 break;
2399
2400 case E_APIPNL_OUTPUT_DATA_ONLY:
2401 ePnlOutputMode = E_PNL_OUTPUT_DATA_ONLY;
2402 break;
2403
2404 case E_APIPNL_OUTPUT_CLK_DATA:
2405 default:
2406 ePnlOutputMode = E_PNL_OUTPUT_CLK_DATA;
2407 break;
2408 }
2409 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2410 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
2411 _PNL_ENTRY();
2412 if(pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Initialized == TRUE)
2413 {
2414 MDrv_PNL_SetOutputType(pInstance, ePnlOutputMode, pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type);
2415 MDrv_PNL_MISC_Control(pInstance, pPNLResourcePrivate->stdrvPNL._stPnlInitData.u32PNL_MISC);
2416 }
2417 else
2418 {
2419 MS_CRITICAL_MSG(printf("Must call MApi_PNL_Init() first\n"));
2420 }
2421 _PNL_RETURN();
2422 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2423 }
2424
MApi_PNL_SetOutput(APIPNL_OUTPUT_MODE eOutputMode)2425 void MApi_PNL_SetOutput(APIPNL_OUTPUT_MODE eOutputMode)
2426 {
2427 #ifdef UTOPIA_20
2428 if (pu32PNLInst == NULL)
2429 {
2430 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2431 {
2432 printf("UtopiaOpen PNL failed\n");
2433 return;
2434 }
2435 }
2436
2437 stPNL_SetOutput PNLArgs;
2438 PNLArgs.eOutputMode = eOutputMode;
2439 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETOUTPUT, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2440 {
2441 printf("Obtain PNL engine fail\n");
2442 }
2443 #else
2444 MApi_PNL_SetOutput_U2(pu32PNLInst, eOutputMode);
2445 #endif
2446 }
2447
MApi_PNL_ChangePanelType_U2(void * pInstance,PanelType * pSelPanelType)2448 MS_BOOL MApi_PNL_ChangePanelType_U2(void *pInstance, PanelType *pSelPanelType)
2449 {
2450 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
2451 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
2452
2453 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2454 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2455 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
2456 if (pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Initialized == FALSE)
2457 {
2458 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2459 return FALSE;
2460 }
2461
2462 if(pSelPanelType == NULL)
2463 {
2464 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2465 return FALSE;
2466 }
2467
2468 _PNL_ENTRY();
2469 _SetPanelParams(pInstance, pSelPanelType);
2470 _PNL_RETURN();
2471
2472 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2473 return TRUE;
2474 }
2475
MApi_PNL_ChangePanelType(PanelType * pSelPanelType)2476 MS_BOOL MApi_PNL_ChangePanelType(PanelType *pSelPanelType)
2477 {
2478 #ifdef UTOPIA_20
2479 if (pu32PNLInst == NULL)
2480 {
2481 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2482 {
2483 printf("UtopiaOpen PNL failed\n");
2484 return FALSE;
2485 }
2486 }
2487
2488 stPNL_ChangePanelType PNLArgs;
2489 PNLArgs.pSelPanelType = pSelPanelType;
2490 PNLArgs.bReturn = FALSE;
2491 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_CHANGEPANELTYPE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2492 {
2493 printf("Obtain PNL engine fail\n");
2494 return FALSE;
2495 }
2496 else
2497 {
2498 return PNLArgs.bReturn;
2499 }
2500 #else
2501 return MApi_PNL_ChangePanelType_U2(pu32PNLInst, pSelPanelType);
2502 #endif
2503 }
2504
MApi_PNL_TCONMAP_DumpTable_U2(void * pInstance,MS_U8 * pTCONTable,MS_U8 u8Tcontype)2505 MS_BOOL MApi_PNL_TCONMAP_DumpTable_U2(void *pInstance, MS_U8 *pTCONTable, MS_U8 u8Tcontype)
2506 {
2507 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
2508
2509 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2510
2511 switch(u8Tcontype)
2512 {
2513 case E_APIPNL_TCON_TAB_TYPE_GENERAL:
2514 case E_APIPNL_TCON_TAB_TYPE_GPIO:
2515 MDrv_PNL_TCON_DumpGENRegTab(pInstance, pTCONTable);
2516 break;
2517 case E_APIPNL_TCON_TAB_TYPE_SCALER:
2518 MDrv_PNL_TCON_DumpSCRegTab(pInstance, pTCONTable);
2519 break;
2520 case E_APIPNL_TCON_TAB_TYPE_MOD:
2521 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2522 MDrv_PNL_TCON_DumpMODRegTab(pInstance, pTCONTable);
2523 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2524 break;
2525
2526 case E_APIPNL_TCON_TAB_TYPE_POWER_SEQUENCE_ON:
2527 case E_APIPNL_TCON_TAB_TYPE_POWER_SEQUENCE_OFF:
2528 //_MDrv_PNL_TCON_DumpPSRegTab(pTCONTable);
2529 break;
2530
2531 case E_APIPNL_TCON_TAB_TYPE_GAMMA:
2532 break;
2533
2534 default:
2535 printf("GetTable: unknown tcon type=%u> \n", u8Tcontype);
2536 break;
2537 }
2538
2539 return TRUE;
2540 }
2541
MApi_PNL_TCONMAP_DumpTable(MS_U8 * pTCONTable,MS_U8 u8Tcontype)2542 MS_BOOL MApi_PNL_TCONMAP_DumpTable(MS_U8 *pTCONTable, MS_U8 u8Tcontype)
2543 {
2544 #ifdef UTOPIA_20
2545 if (pu32PNLInst == NULL)
2546 {
2547 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2548 {
2549 printf("UtopiaOpen PNL failed\n");
2550 return FALSE;
2551 }
2552 }
2553
2554 stPNL_TCONMAP_DumpTable PNLArgs;
2555 PNLArgs.pTCONTable = pTCONTable;
2556 PNLArgs.u8Tcontype = u8Tcontype;
2557 PNLArgs.bReturn = FALSE;
2558 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_TCONMAP_DUMPTABLE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2559 {
2560 printf("Obtain PNL engine fail\n");
2561 return FALSE;
2562 }
2563 else
2564 {
2565 return PNLArgs.bReturn;
2566 }
2567 #else
2568 return MApi_PNL_TCONMAP_DumpTable_U2(pu32PNLInst, pTCONTable, u8Tcontype);
2569 #endif
2570 }
2571
MApi_PNL_TCONMAP_Power_Sequence_U2(void * pInstance,MS_U8 * pTCONTable,MS_BOOL bEnable)2572 MS_BOOL MApi_PNL_TCONMAP_Power_Sequence_U2(void *pInstance, MS_U8 *pTCONTable, MS_BOOL bEnable)
2573 {
2574 // Move to APP
2575 #if 0
2576 MDrv_PNL_TCONMAP_Power_Sequence(pTCONTable, bEnable);
2577 #endif
2578 printf("\n\n!![Alert]Don't ued this function. It is removed!!\n\n");
2579 return FALSE;
2580 }
2581
MApi_PNL_TCONMAP_Power_Sequence(MS_U8 * pTCONTable,MS_BOOL bEnable)2582 MS_BOOL MApi_PNL_TCONMAP_Power_Sequence(MS_U8 *pTCONTable, MS_BOOL bEnable)
2583 {
2584 #ifdef UTOPIA_20
2585 if (pu32PNLInst == NULL)
2586 {
2587 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2588 {
2589 printf("UtopiaOpen PNL failed\n");
2590 return FALSE;
2591 }
2592 }
2593
2594 stPNL_TCONMAP_Power_Sequence PNLArgs;
2595 PNLArgs.pTCONTable = pTCONTable;
2596 PNLArgs.bEnable = bEnable;
2597 PNLArgs.bReturn = FALSE;
2598 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_TCONMAP_POWER_SEQUENCE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2599 {
2600 printf("Obtain PNL engine fail\n");
2601 return FALSE;
2602 }
2603 else
2604 {
2605 return PNLArgs.bReturn;
2606 }
2607 #else
2608 return MApi_PNL_TCONMAP_Power_Sequence_U2(pu32PNLInst, pTCONTable, bEnable);
2609 #endif
2610 }
2611
MApi_PNL_SetOutputPattern_U2(void * pInstance,MS_BOOL bEnable,MS_U16 u16Red,MS_U16 u16Green,MS_U16 u16Blue)2612 void MApi_PNL_SetOutputPattern_U2(void *pInstance, MS_BOOL bEnable, MS_U16 u16Red , MS_U16 u16Green, MS_U16 u16Blue)
2613 {
2614 MDrv_PNL_SetOutputPattern(pInstance, bEnable,u16Red,u16Green,u16Blue);
2615 }
2616
MApi_PNL_SetOutputPattern(MS_BOOL bEnable,MS_U16 u16Red,MS_U16 u16Green,MS_U16 u16Blue)2617 void MApi_PNL_SetOutputPattern(MS_BOOL bEnable, MS_U16 u16Red , MS_U16 u16Green, MS_U16 u16Blue)
2618 {
2619 #ifdef UTOPIA_20
2620 if (pu32PNLInst == NULL)
2621 {
2622 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2623 {
2624 printf("UtopiaOpen PNL failed\n");
2625 return;
2626 }
2627 }
2628
2629 stPNL_SetOutputPattern PNLArgs;
2630 PNLArgs.bEnable = bEnable;
2631 PNLArgs.u16Red = u16Red;
2632 PNLArgs.u16Green = u16Green;
2633 PNLArgs.u16Blue = u16Blue;
2634 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SET_OUTPUT_PATTERN, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2635 {
2636 printf("Obtain PNL engine fail\n");
2637 }
2638 #else
2639 MApi_PNL_SetOutputPattern_U2(pu32PNLInst, bEnable, u16Red, u16Green, u16Blue);
2640 #endif
2641 }
2642 //-------------------------------------------------------------------------------------------------
2643 /// Setup TCON Count Reset ON/OFF
2644 /// @param bEnable \b IN: Enable or Disable
2645 //-------------------------------------------------------------------------------------------------
MApi_PNL_TCON_Count_Reset_U2(void * pInstance,MS_BOOL bEnable)2646 void MApi_PNL_TCON_Count_Reset_U2 (void *pInstance, MS_BOOL bEnable )
2647 {
2648 MDrv_PNL_TCON_Count_Reset(pInstance, bEnable);
2649 }
2650
MApi_PNL_TCON_Count_Reset(MS_BOOL bEnable)2651 void MApi_PNL_TCON_Count_Reset (MS_BOOL bEnable)
2652 {
2653 #ifdef UTOPIA_20
2654 if (pu32PNLInst == NULL)
2655 {
2656 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2657 {
2658 printf("UtopiaOpen PNL failed\n");
2659 return;
2660 }
2661 }
2662
2663 stPNL_TCON_Count_Reset PNLArgs;
2664 PNLArgs.bEnable = bEnable;
2665 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_TCON_COUNT_RESET, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2666 {
2667 printf("Obtain PNL engine fail\n");
2668 }
2669 #else
2670 MApi_PNL_TCON_Count_Reset_U2(pu32PNLInst, bEnable);
2671 #endif
2672 }
2673
MApi_PNL_TCON_Init_U2(void * pInstance)2674 void MApi_PNL_TCON_Init_U2(void *pInstance)
2675 {
2676 MDrv_PNL_TCON_Init(pInstance);
2677 }
2678
MApi_PNL_TCON_Init(void)2679 void MApi_PNL_TCON_Init( void )
2680 {
2681 #ifdef UTOPIA_20
2682 if (pu32PNLInst == NULL)
2683 {
2684 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2685 {
2686 printf("UtopiaOpen PNL failed\n");
2687 return;
2688 }
2689 }
2690
2691 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_TCON_INIT, NULL) != UTOPIA_STATUS_SUCCESS)
2692 {
2693 printf("Obtain PNL engine fail\n");
2694 }
2695 #else
2696 MApi_PNL_TCON_Init_U2(pu32PNLInst);
2697 #endif
2698 }
2699
MApi_PNL_GetDstInfo_U2(void * pInstance,MS_PNL_DST_DispInfo * pDstInfo,MS_U32 u32SizeofDstInfo)2700 MS_BOOL MApi_PNL_GetDstInfo_U2(void *pInstance, MS_PNL_DST_DispInfo *pDstInfo, MS_U32 u32SizeofDstInfo)
2701 {
2702 PNL_TimingInfo PNL_Data;
2703 MS_BOOL bReturn = FALSE;
2704 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
2705 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2706
2707 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2708 _PNL_ENTRY();
2709
2710 if(NULL == pDstInfo)
2711 {
2712 PNL_DBG_MSG("MApi_PNL_GetDstInfo():pDstInfo is NULL\n");
2713 bReturn = FALSE;
2714 }
2715 else if(u32SizeofDstInfo != sizeof(MS_PNL_DST_DispInfo))
2716 {
2717 PNL_DBG_MSG("MApi_PNL_GetDstInfo():u16SizeofDstInfo is different from the MS_PNL_DST_DispInfo defined, check header file!\n");
2718 bReturn = FALSE;
2719 }
2720 else if(MDrv_PNL_GetDataFromRegister(pInstance, &PNL_Data))
2721 {
2722 pDstInfo->VDTOT = PNL_Data.u16VTotal;
2723 pDstInfo->HDTOT = PNL_Data.u16HTotal;
2724 pDstInfo->DEHST = PNL_Data.u16DEHStart;
2725 pDstInfo->DEHEND= PNL_Data.u16DEHEnd;
2726 pDstInfo->DEVST= PNL_Data.u16DEVStart;
2727 pDstInfo->DEVEND= PNL_Data.u16DEVEnd;
2728 pDstInfo->bYUVOutput = MDrv_PNL_isYUVOutput(pInstance);
2729 pDstInfo->bInterlaceMode = PNL_Data.bInterlaceOutput;
2730 bReturn = TRUE;
2731 }
2732 else
2733 {
2734 pDstInfo->VDTOT = 0;
2735 pDstInfo->HDTOT = 0;
2736 pDstInfo->DEHST = 0;
2737 pDstInfo->DEHEND= 0;
2738 pDstInfo->DEVST= 0;
2739 pDstInfo->DEVEND= 0;
2740 pDstInfo->bInterlaceMode = FALSE;
2741 pDstInfo->bYUVOutput = FALSE;
2742 bReturn = FALSE;
2743 }
2744
2745 _PNL_RETURN();
2746 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2747 return bReturn;
2748 }
2749
MApi_PNL_GetDstInfo(MS_PNL_DST_DispInfo * pDstInfo,MS_U32 u32SizeofDstInfo)2750 MS_BOOL MApi_PNL_GetDstInfo(MS_PNL_DST_DispInfo *pDstInfo, MS_U32 u32SizeofDstInfo)
2751 {
2752 #ifdef UTOPIA_20
2753 if (pu32PNLInst == NULL)
2754 {
2755 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2756 {
2757 printf("UtopiaOpen PNL failed\n");
2758 return FALSE;
2759 }
2760 }
2761
2762 stPNL_GetDstInfo PNLArgs;
2763 PNLArgs.pDstInfo = pDstInfo;
2764 PNLArgs.u32SizeofDstInfo = u32SizeofDstInfo;
2765 PNLArgs.bReturn = FALSE;
2766 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETDSTINFO, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2767 {
2768 printf("Obtain PNL engine fail\n");
2769 return FALSE;
2770 }
2771 else
2772 {
2773 return PNLArgs.bReturn;
2774 }
2775 #else
2776 return MApi_PNL_GetDstInfo_U2(pu32PNLInst, pDstInfo, u32SizeofDstInfo);
2777 #endif
2778 }
2779
MApi_Mod_Calibration_Setting_U2(void * pInstance,MS_PNL_ModCaliInfo * pstModCaliInfo)2780 MS_BOOL MApi_Mod_Calibration_Setting_U2(void *pInstance, MS_PNL_ModCaliInfo *pstModCaliInfo)
2781 {
2782 PNL_ModCali_InitData stModCaliInitData;
2783 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
2784
2785 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2786 memset(&stModCaliInitData, 0 , sizeof(PNL_ModCali_InitData));
2787
2788 if(pstModCaliInfo == NULL)
2789 {
2790 return FALSE;
2791 }
2792
2793 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2794 _PNL_ENTRY();
2795 stModCaliInitData.u16ExpectSwingLevel = pstModCaliInfo->m_u16ExpectSwingLevel;
2796 stModCaliInitData.u8ModCaliPairSel = pstModCaliInfo->m_u8ModCaliPairSel;
2797 stModCaliInitData.u8ModCaliTarget = pstModCaliInfo->m_u8ModCaliTarget;
2798 stModCaliInitData.s8ModCaliOffset = pstModCaliInfo->m_s8ModCaliOffset;
2799 stModCaliInitData.bPVDD_2V5 = pstModCaliInfo->m_bPVDD_2V5;
2800 MDrv_Mod_Calibration_Init(pInstance, &stModCaliInitData);
2801 _PNL_RETURN();
2802 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2803
2804 return TRUE;
2805 }
2806
MApi_Mod_Calibration_Setting(MS_PNL_ModCaliInfo * pstModCaliInfo)2807 MS_BOOL MApi_Mod_Calibration_Setting(MS_PNL_ModCaliInfo *pstModCaliInfo)
2808 {
2809 #ifdef UTOPIA_20
2810 if (pu32PNLInst == NULL)
2811 {
2812 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2813 {
2814 printf("UtopiaOpen PNL failed\n");
2815 return FALSE;
2816 }
2817 }
2818
2819 if(pstModCaliInfo == NULL)
2820 {
2821 printf("MOD Calibration config setting is NULL\n");
2822 return FALSE;
2823 }
2824
2825 stPNL_Mod_Calibration_Setting PNLArgs;
2826 PNLArgs.pstModCaliInfo = pstModCaliInfo;
2827 PNLArgs.bReturn = FALSE;
2828 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_MOD_CALIBRATION_SETTING, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2829 {
2830 printf("Obtain PNL engine fail\n");
2831 return FALSE;
2832 }
2833 else
2834 {
2835 return PNLArgs.bReturn;
2836 }
2837 #else
2838 return MApi_Mod_Calibration_Setting_U2(pu32PNLInst, pstModCaliInfo);
2839 #endif
2840 }
2841
MApi_Mod_Do_Calibration_U2(void * pInstance)2842 MS_BOOL MApi_Mod_Do_Calibration_U2(void *pInstance)
2843 {
2844 MS_BOOL bResult = FALSE;
2845 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
2846
2847 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2848 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2849 _PNL_ENTRY();
2850 if ( E_PNL_OK == MDrv_PNL_MOD_Calibration(pInstance) )
2851 bResult = TRUE;
2852 else
2853 bResult = FALSE;
2854 _PNL_RETURN();
2855 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2856 return bResult;
2857 }
2858
MApi_Mod_Do_Calibration(void)2859 MS_BOOL MApi_Mod_Do_Calibration(void)
2860 {
2861 #ifdef UTOPIA_20
2862 if (pu32PNLInst == NULL)
2863 {
2864 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2865 {
2866 printf("UtopiaOpen PNL failed\n");
2867 return FALSE;
2868 }
2869 }
2870
2871 stPNL_Mod_Do_Calibration PNLArgs;
2872 PNLArgs.bReturn = FALSE;
2873 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_MOD_DO_CALIBRATION, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2874 {
2875 printf("Obtain PNL engine fail\n");
2876 return FALSE;
2877 }
2878 else
2879 {
2880 return PNLArgs.bReturn;
2881 }
2882 #else
2883 return MApi_Mod_Do_Calibration_U2(pu32PNLInst);
2884 #endif
2885 }
2886
MApi_BD_LVDS_Output_Type_U2(void * pInstance,MS_U16 Type)2887 void MApi_BD_LVDS_Output_Type_U2(void *pInstance, MS_U16 Type)
2888 {
2889 #if (KERNEL_DRIVER_PNL_STR_PATCH == 1)
2890 void *pModule;
2891 UtopiaInstanceGetModule(pInstance, &pModule);
2892 PNL_REGS_SAVE_AREA *pPNLResourceStr = NULL;
2893 UtopiaModuleGetSTRPrivate(pModule, (void**)&pPNLResourceStr);
2894 pPNLResourceStr->BD_LVDS_Output_Type = Type;
2895 #endif
2896 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
2897 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
2898 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2899 MDrv_BD_LVDS_Output_Type(pInstance, Type);
2900 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
2901 }
2902
MApi_BD_LVDS_Output_Type(MS_U16 Type)2903 void MApi_BD_LVDS_Output_Type(MS_U16 Type)
2904 {
2905 #ifdef UTOPIA_20
2906 if (pu32PNLInst == NULL)
2907 {
2908 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2909 {
2910 printf("UtopiaOpen PNL failed\n");
2911 return;
2912 }
2913 }
2914
2915 stPNL_BD_LVDS_Output_Type PNLArgs;
2916 PNLArgs.Type = Type;
2917 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_BD_LVDS_OUTPUT_TYPE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2918 {
2919 printf("Obtain PNL engine fail\n");
2920 }
2921 #else
2922 MApi_BD_LVDS_Output_Type_U2(pu32PNLInst, Type);
2923 #endif
2924 }
2925
MApi_PNL_SetSSC_En_U2(void * pInstance,MS_BOOL bEnable)2926 APIPNL_Result MApi_PNL_SetSSC_En_U2(void *pInstance, MS_BOOL bEnable)
2927 {
2928 #if 1
2929 _PNL_ENTRY();
2930 MDrv_PNL_SetSSC_En(pInstance, bEnable);
2931 _PNL_RETURN();
2932 return E_APIPNL_OK;
2933 #endif
2934 }
2935
MApi_PNL_SetSSC_En(MS_BOOL bEnable)2936 APIPNL_Result MApi_PNL_SetSSC_En(MS_BOOL bEnable)
2937 {
2938 #ifdef UTOPIA_20
2939 if (pu32PNLInst == NULL)
2940 {
2941 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2942 {
2943 printf("UtopiaOpen PNL failed\n");
2944 return E_APIPNL_FAIL;
2945 }
2946 }
2947
2948 stPNL_SetSSC_En PNLArgs;
2949 PNLArgs.bEnable = bEnable;
2950 PNLArgs.eReturn = E_APIPNL_FAIL;
2951 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETSSC_EN, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
2952 {
2953 printf("Obtain PNL engine fail\n");
2954 return E_APIPNL_FAIL;
2955 }
2956 else
2957 {
2958 return PNLArgs.eReturn;
2959 }
2960 #else
2961 return MApi_PNL_SetSSC_En_U2(pu32PNLInst, bEnable);
2962 #endif
2963 }
2964
MApi_PNL_SetSSC_Fmodulation_U2(void * pInstance,MS_U16 u16Fmodulation)2965 APIPNL_Result MApi_PNL_SetSSC_Fmodulation_U2(void *pInstance, MS_U16 u16Fmodulation)
2966 {
2967 #if 1
2968 if(u16Fmodulation)
2969 {
2970 _PNL_ENTRY();
2971
2972 MDrv_PNL_SetSSC_Fmodulation(pInstance, u16Fmodulation);
2973
2974 _PNL_RETURN();
2975 return E_APIPNL_OK;
2976 }
2977 else
2978 {
2979 printf("\n\n!![Alert]zero u16Fmodulation (Lvds_SscSpan)!!\n\n");
2980 return E_APIPNL_FAIL;
2981 }
2982 #endif
2983 }
2984
MApi_PNL_SetSSC_Fmodulation(MS_U16 u16Fmodulation)2985 APIPNL_Result MApi_PNL_SetSSC_Fmodulation(MS_U16 u16Fmodulation)
2986 {
2987 #ifdef UTOPIA_20
2988 if (pu32PNLInst == NULL)
2989 {
2990 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2991 {
2992 printf("UtopiaOpen PNL failed\n");
2993 return E_APIPNL_FAIL;
2994 }
2995 }
2996
2997 stPNL_SetSSC_Fmodulation PNLArgs;
2998 PNLArgs.u16Fmodulation = u16Fmodulation;
2999 PNLArgs.eReturn = E_APIPNL_FAIL;
3000 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETSSC_FMODULATION, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3001 {
3002 printf("Obtain PNL engine fail\n");
3003 return E_APIPNL_FAIL;
3004 }
3005 else
3006 {
3007 return PNLArgs.eReturn;
3008 }
3009 #else
3010 return MApi_PNL_SetSSC_Fmodulation_U2(pu32PNLInst, u16Fmodulation);
3011 #endif
3012 }
3013
MApi_PNL_SetSSC_Rdeviation_U2(void * pInstance,MS_U16 u16Rdeviation)3014 APIPNL_Result MApi_PNL_SetSSC_Rdeviation_U2(void *pInstance, MS_U16 u16Rdeviation)
3015 {
3016 #if 1
3017 if(u16Rdeviation)
3018 {
3019 _PNL_ENTRY();
3020 MDrv_PNL_SetSSC_Rdeviation(pInstance, u16Rdeviation);
3021 _PNL_RETURN();
3022 return E_APIPNL_OK;
3023 }
3024 else
3025 {
3026 printf("\n\n!![Alert]zero u16Rdeviation (Lvds_SscStep)!!\n\n");
3027 return E_APIPNL_FAIL;
3028 }
3029 #endif
3030 }
3031
MApi_PNL_SetSSC_Rdeviation(MS_U16 u16Rdeviation)3032 APIPNL_Result MApi_PNL_SetSSC_Rdeviation(MS_U16 u16Rdeviation)
3033 {
3034 #ifdef UTOPIA_20
3035 if (pu32PNLInst == NULL)
3036 {
3037 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3038 {
3039 printf("UtopiaOpen PNL failed\n");
3040 return E_APIPNL_FAIL;
3041 }
3042 }
3043
3044 stPNL_SetSSC_Rdeviation PNLArgs;
3045 PNLArgs.u16Rdeviation = u16Rdeviation;
3046 PNLArgs.eReturn = E_APIPNL_FAIL;
3047 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETSSC_RDEVIATION, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3048 {
3049 printf("Obtain PNL engine fail\n");
3050 return E_APIPNL_FAIL;
3051 }
3052 else
3053 {
3054 return PNLArgs.eReturn;
3055 }
3056 #else
3057 return MApi_PNL_SetSSC_Rdeviation_U2(pu32PNLInst, u16Rdeviation);
3058 #endif
3059 }
3060
MApi_PNL_SetOSDSSC_En_U2(void * pInstance,MS_BOOL bEnable)3061 APIPNL_Result MApi_PNL_SetOSDSSC_En_U2(void *pInstance, MS_BOOL bEnable)
3062 {
3063 #if 1
3064 _PNL_ENTRY();
3065 MDrv_PNL_SetOSDSSC_En(pInstance, bEnable);
3066 _PNL_RETURN();
3067 return E_APIPNL_OK;
3068 #endif
3069 }
3070
MApi_PNL_SetOSDSSC_En(MS_BOOL bEnable)3071 APIPNL_Result MApi_PNL_SetOSDSSC_En(MS_BOOL bEnable)
3072 {
3073 #ifdef UTOPIA_20
3074 if (pu32PNLInst == NULL)
3075 {
3076 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3077 {
3078 printf("UtopiaOpen PNL failed\n");
3079 return E_APIPNL_FAIL;
3080 }
3081 }
3082
3083 stPNL_SetOSDSSC_En PNLArgs;
3084 PNLArgs.bEnable = bEnable;
3085 PNLArgs.eReturn = E_APIPNL_FAIL;
3086 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETOSDSSC_EN, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3087 {
3088 printf("Obtain PNL engine fail\n");
3089 return E_APIPNL_FAIL;
3090 }
3091 else
3092 {
3093 return PNLArgs.eReturn;
3094 }
3095 #else
3096 return MApi_PNL_SetOSDSSC_En_U2(pu32PNLInst, bEnable);
3097 #endif
3098 }
3099
MApi_PNL_SetOSDSSC_Fmodulation_U2(void * pInstance,MS_U16 u16Fmodulation)3100 APIPNL_Result MApi_PNL_SetOSDSSC_Fmodulation_U2(void *pInstance, MS_U16 u16Fmodulation)
3101 {
3102 #if 1
3103 if(u16Fmodulation)
3104 {
3105 _PNL_ENTRY();
3106
3107 MDrv_PNL_SetOSDSSC_Fmodulation(pInstance, u16Fmodulation);
3108
3109 _PNL_RETURN();
3110 return E_APIPNL_OK;
3111 }
3112 else
3113 {
3114 printf("\n\n!![Alert]zero OSD u16Fmodulation (Lvds_SscSpan)!!\n\n");
3115 return E_APIPNL_FAIL;
3116 }
3117 #endif
3118 }
3119
MApi_PNL_SetOSDSSC_Fmodulation(MS_U16 u16Fmodulation)3120 APIPNL_Result MApi_PNL_SetOSDSSC_Fmodulation(MS_U16 u16Fmodulation)
3121 {
3122 #ifdef UTOPIA_20
3123 if (pu32PNLInst == NULL)
3124 {
3125 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3126 {
3127 printf("UtopiaOpen PNL failed\n");
3128 return E_APIPNL_FAIL;
3129 }
3130 }
3131
3132 stPNL_SetOSDSSC_Fmodulation PNLArgs;
3133 PNLArgs.u16Fmodulation = u16Fmodulation;
3134 PNLArgs.eReturn = E_APIPNL_FAIL;
3135 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETOSDSSC_FMODULATION, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3136 {
3137 printf("Obtain PNL engine fail\n");
3138 return E_APIPNL_FAIL;
3139 }
3140 else
3141 {
3142 return PNLArgs.eReturn;
3143 }
3144 #else
3145 return MApi_PNL_SetOSDSSC_Fmodulation_U2(pu32PNLInst, u16Fmodulation);
3146 #endif
3147 }
3148
MApi_PNL_SetOSDSSC_Rdeviation_U2(void * pInstance,MS_U16 u16Rdeviation)3149 APIPNL_Result MApi_PNL_SetOSDSSC_Rdeviation_U2(void *pInstance, MS_U16 u16Rdeviation)
3150 {
3151 #if 1
3152 if(u16Rdeviation)
3153 {
3154 _PNL_ENTRY();
3155 MDrv_PNL_SetOSDSSC_Rdeviation(pInstance, u16Rdeviation);
3156 _PNL_RETURN();
3157 return E_APIPNL_OK;
3158 }
3159 else
3160 {
3161 printf("\n\n!![Alert]zero OSD u16Rdeviation (Lvds_SscStep)!!\n\n");
3162 return E_APIPNL_FAIL;
3163 }
3164 #endif
3165 }
3166
MApi_PNL_SetOSSSC_Rdeviation(MS_U16 u16Rdeviation)3167 APIPNL_Result MApi_PNL_SetOSSSC_Rdeviation(MS_U16 u16Rdeviation)
3168 {
3169 #ifdef UTOPIA_20
3170 if (pu32PNLInst == NULL)
3171 {
3172 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3173 {
3174 printf("UtopiaOpen PNL failed\n");
3175 return E_APIPNL_FAIL;
3176 }
3177 }
3178
3179 stPNL_SetOSDSSC_Rdeviation PNLArgs;
3180 PNLArgs.u16Rdeviation = u16Rdeviation;
3181 PNLArgs.eReturn = E_APIPNL_FAIL;
3182 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETOSDSSC_RDEVIATION, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3183 {
3184 printf("Obtain PNL engine fail\n");
3185 return E_APIPNL_FAIL;
3186 }
3187 else
3188 {
3189 return PNLArgs.eReturn;
3190 }
3191 #else
3192 return MApi_PNL_SetOSDSSC_Rdeviation_U2(pu32PNLInst, u16Rdeviation);
3193 #endif
3194 }
3195
MApi_PNL_SetLPLLTypeExt_U2(void * pInstance,APIPNL_LINK_EXT_TYPE eLPLL_TypeExt)3196 void MApi_PNL_SetLPLLTypeExt_U2(void *pInstance, APIPNL_LINK_EXT_TYPE eLPLL_TypeExt)
3197 {
3198 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
3199 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
3200
3201 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
3202 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3203 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
3204 pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type_Ext = _TransToDriver_APIPNL_LINK_EXT_TYPE_To_PNL_TYPE(eLPLL_TypeExt);
3205 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3206 }
3207
MApi_PNL_SetLPLLTypeExt(APIPNL_LINK_EXT_TYPE eLPLL_TypeExt)3208 void MApi_PNL_SetLPLLTypeExt(APIPNL_LINK_EXT_TYPE eLPLL_TypeExt)
3209 {
3210 #ifdef UTOPIA_20
3211 if (pu32PNLInst == NULL)
3212 {
3213 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3214 {
3215 printf("UtopiaOpen PNL failed\n");
3216 return;
3217 }
3218 }
3219
3220 stPNL_SetLPLLTypeExt PNLArgs;
3221 PNLArgs.eLPLL_TypeExt = eLPLL_TypeExt;
3222 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETLPLLTYPEEXT, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3223 {
3224 printf("Obtain PNL engine fail\n");
3225 }
3226 #else
3227 MApi_PNL_SetLPLLTypeExt_U2(pu32PNLInst, eLPLL_TypeExt);
3228 #endif
3229 }
3230
MApi_PNL_Init_MISC_U2(void * pInstance,APIPNL_MISC ePNL_MISC)3231 void MApi_PNL_Init_MISC_U2(void *pInstance, APIPNL_MISC ePNL_MISC)
3232 {
3233 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
3234 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
3235
3236 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
3237 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3238 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
3239 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u32PNL_MISC = ePNL_MISC;
3240 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3241 }
3242
MApi_PNL_Init_MISC(APIPNL_MISC ePNL_MISC)3243 void MApi_PNL_Init_MISC(APIPNL_MISC ePNL_MISC)
3244 {
3245 #ifdef UTOPIA_20
3246 if (pu32PNLInst == NULL)
3247 {
3248 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3249 {
3250 printf("UtopiaOpen PNL failed\n");
3251 return;
3252 }
3253 }
3254
3255 stPNL_Init_MISC PNLArgs;
3256 PNLArgs.ePNL_MISC = ePNL_MISC;
3257 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_INIT_MISC, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3258 {
3259 printf("Obtain PNL engine fail\n");
3260 }
3261 #else
3262 MApi_PNL_Init_MISC_U2(pu32PNLInst, ePNL_MISC);
3263 #endif
3264 }
3265
MApi_PNL_GetMiscStatus_U2(void * pInstance)3266 MS_U32 MApi_PNL_GetMiscStatus_U2(void* pInstance)
3267 {
3268 MS_U32 u32PNL_Misc = 0;
3269 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
3270 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
3271
3272 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
3273 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3274 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
3275 u32PNL_Misc = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u32PNL_MISC;
3276 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3277
3278 return u32PNL_Misc;
3279 }
3280
MApi_PNL_GetMiscStatus(void)3281 MS_U32 MApi_PNL_GetMiscStatus(void)
3282 {
3283 #ifdef UTOPIA_20
3284 if (pu32PNLInst == NULL)
3285 {
3286 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3287 {
3288 printf("UtopiaOpen PNL failed\n");
3289 return 0;
3290 }
3291 }
3292 stPNL_Get_MISC_Status PNLArgs;
3293 PNLArgs.u32Status = 0;
3294
3295 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GET_MISC_STATUS, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3296 {
3297 printf("Obtain PNL engine fail\n");
3298 return 0;
3299 }
3300 else
3301 {
3302 return PNLArgs.u32Status;
3303 }
3304 #else
3305 return MApi_PNL_GetMiscStatus_U2(pu32PNLInst);
3306 #endif
3307 }
3308
MApi_PNL_MOD_OutputConfig_User_U2(void * pInstance,MS_U32 u32OutputCFG0_7,MS_U32 u32OutputCFG8_15,MS_U32 u32OutputCFG16_21)3309 void MApi_PNL_MOD_OutputConfig_User_U2(void *pInstance, MS_U32 u32OutputCFG0_7, MS_U32 u32OutputCFG8_15, MS_U32 u32OutputCFG16_21)
3310 {
3311 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
3312 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
3313
3314 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
3315 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3316 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
3317 PNL_DBG(PNL_DBGLEVEL_INIT, "[%s][%d]\n", __FUNCTION__, __LINE__);
3318 PNL_DBG(PNL_DBGLEVEL_INIT, "u32OutputCFG0_7 = %tx\n",(ptrdiff_t)u32OutputCFG0_7);
3319 PNL_DBG(PNL_DBGLEVEL_INIT, "u32OutputCFG8_15 = %tx\n",(ptrdiff_t)u32OutputCFG8_15);
3320 PNL_DBG(PNL_DBGLEVEL_INIT, "u32OutputCFG16_21 = %tx\n",(ptrdiff_t)u32OutputCFG16_21);
3321 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputCFG0_7 = u32OutputCFG0_7;
3322 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputCFG8_15 = u32OutputCFG8_15;
3323 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputCFG16_21 = u32OutputCFG16_21;
3324 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3325 }
3326
MApi_PNL_MOD_OutputConfig_User(MS_U32 u32OutputCFG0_7,MS_U32 u32OutputCFG8_15,MS_U32 u32OutputCFG16_21)3327 void MApi_PNL_MOD_OutputConfig_User(MS_U32 u32OutputCFG0_7, MS_U32 u32OutputCFG8_15, MS_U32 u32OutputCFG16_21)
3328 {
3329 #ifdef UTOPIA_20
3330 if (pu32PNLInst == NULL)
3331 {
3332 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3333 {
3334 printf("UtopiaOpen PNL failed\n");
3335 return;
3336 }
3337 }
3338
3339 stPNL_MOD_OutputConfig_User PNLArgs;
3340 PNLArgs.u32OutputCFG0_7 = u32OutputCFG0_7;
3341 PNLArgs.u32OutputCFG8_15 = u32OutputCFG8_15;
3342 PNLArgs.u32OutputCFG16_21 = u32OutputCFG16_21;
3343 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_MOD_OUTPUTCONFIG_USER, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3344 {
3345 printf("Obtain PNL engine fail\n");
3346 }
3347 #else
3348 MApi_PNL_MOD_OutputConfig_User_U2(pu32PNLInst, u32OutputCFG0_7, u32OutputCFG8_15, u32OutputCFG16_21);
3349 #endif
3350 }
3351
MApi_PNL_MOD_OutputChannelOrder_U2(void * pInstance,MS_U8 u8OutputOrderType,MS_U16 u16OutputOrder0_3,MS_U16 u16OutputOrder4_7,MS_U16 u16OutputOrder8_11,MS_U16 u16OutputOrder12_13)3352 void MApi_PNL_MOD_OutputChannelOrder_U2(void* pInstance,
3353 MS_U8 u8OutputOrderType,
3354 MS_U16 u16OutputOrder0_3,
3355 MS_U16 u16OutputOrder4_7,
3356 MS_U16 u16OutputOrder8_11,
3357 MS_U16 u16OutputOrder12_13)
3358 {
3359 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
3360 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
3361
3362 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
3363 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3364 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
3365 PNL_DBG(PNL_DBGLEVEL_INIT, "[%s][%d]\n", __FUNCTION__, __LINE__);
3366 PNL_DBG(PNL_DBGLEVEL_INIT, "u8OutputOrderType = %x\n", (unsigned int)u8OutputOrderType);
3367 PNL_DBG(PNL_DBGLEVEL_INIT, "u16OutputOrder0_3 = %x\n", (unsigned int)u16OutputOrder0_3);
3368 PNL_DBG(PNL_DBGLEVEL_INIT, "u16OutputOrder4_7 = %x\n", (unsigned int)u16OutputOrder4_7);
3369 PNL_DBG(PNL_DBGLEVEL_INIT, "u16OutputOrder8_11 = %x\n", (unsigned int)u16OutputOrder8_11);
3370 PNL_DBG(PNL_DBGLEVEL_INIT, "u16OutputOrder12_13 = %x\n", (unsigned int)u16OutputOrder12_13);
3371 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u8OutputOrderType = u8OutputOrderType;
3372 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputOrder0_3 = u16OutputOrder0_3;
3373 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputOrder4_7 = u16OutputOrder4_7;
3374 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputOrder8_11 = u16OutputOrder8_11;
3375 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputOrder12_13 = u16OutputOrder12_13;
3376 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3377 }
3378
MApi_PNL_MOD_OutputChannelOrder(MS_U8 u8OutputOrderType,MS_U16 u16OutputOrder0_3,MS_U16 u16OutputOrder4_7,MS_U16 u16OutputOrder8_11,MS_U16 u16OutputOrder12_13)3379 void MApi_PNL_MOD_OutputChannelOrder(MS_U8 u8OutputOrderType,
3380 MS_U16 u16OutputOrder0_3,
3381 MS_U16 u16OutputOrder4_7,
3382 MS_U16 u16OutputOrder8_11,
3383 MS_U16 u16OutputOrder12_13)
3384 {
3385 #ifdef UTOPIA_20
3386 if (pu32PNLInst == NULL)
3387 {
3388 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3389 {
3390 printf("UtopiaOpen PNL failed\n");
3391 return;
3392 }
3393 }
3394
3395 stPNL_MOD_OutputChannelOrder PNLArgs;
3396 PNLArgs.u8OutputOrderType = u8OutputOrderType;
3397 PNLArgs.u16OutputOrder0_3 = u16OutputOrder0_3;
3398 PNLArgs.u16OutputOrder4_7 = u16OutputOrder4_7;
3399 PNLArgs.u16OutputOrder8_11 = u16OutputOrder8_11;
3400 PNLArgs.u16OutputOrder12_13 = u16OutputOrder12_13;
3401
3402 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_MOD_OUTPUT_CHANNEL_ORDER, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3403 {
3404 printf("Obtain PNL engine fail\n");
3405 }
3406 #else
3407 MApi_PNL_MOD_OutputChannelOrder_U2(pu32PNLInst, u8OutputOrderType, u16OutputOrder0_3, u16OutputOrder4_7, u16OutputOrder8_11, u16OutputOrder12_13);
3408 #endif
3409 }
3410 //-------------------------------------------------------------------------------------------------
3411 /// Set Flag to bypass timing change in MApi_PNL_Init()
3412 /// @param bFlag \b IN: TRUE: initialize XC by skipping SW reset; FALSE: initialize XC in normal case
3413 /// @return APIPNL_Result
3414 //-------------------------------------------------------------------------------------------------
MApi_PNL_SkipTimingChange_U2(void * pInstance,MS_BOOL bFlag)3415 APIPNL_Result MApi_PNL_SkipTimingChange_U2(void *pInstance, MS_BOOL bFlag)
3416 {
3417 MS_BOOL bCap = MDrv_PNL_SkipTimingChange_GetCaps(pInstance);
3418 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
3419 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
3420
3421 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
3422 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3423 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
3424 if( (bFlag == TRUE) && (bCap == TRUE) )
3425 {
3426 pPNLResourcePrivate->stapiPNL._bSkipTimingChange = TRUE;
3427 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3428 return E_APIPNL_OK;
3429 }
3430 else
3431 {
3432 //else, not supported
3433 pPNLResourcePrivate->stapiPNL._bSkipTimingChange = FALSE;
3434 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3435 return E_APIPNL_FAIL;
3436 }
3437 }
3438
MApi_PNL_SkipTimingChange(MS_BOOL bFlag)3439 APIPNL_Result MApi_PNL_SkipTimingChange(MS_BOOL bFlag)
3440 {
3441 #ifdef UTOPIA_20
3442 if (pu32PNLInst == NULL)
3443 {
3444 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3445 {
3446 printf("UtopiaOpen PNL failed\n");
3447 return E_APIPNL_FAIL;
3448 }
3449 }
3450
3451 stPNL_SkipTimingChange PNLArgs;
3452 PNLArgs.bFlag = bFlag;
3453 PNLArgs.eResult = E_APIPNL_FAIL;
3454 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SKIPTIMINGCHANGE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3455 {
3456 printf("Obtain PNL engine fail\n");
3457 return E_APIPNL_FAIL;
3458 }
3459 else
3460 {
3461 return PNLArgs.eResult;
3462 }
3463 #else
3464 return MApi_PNL_SkipTimingChange_U2(pu32PNLInst, bFlag);
3465 #endif
3466 }
3467
3468 //-------------------------------------------------------------------------------------------------
3469 /// Set Pre Set Mode On
3470 /// @param bSetMode \b IN: TRUE: when set mode on t; FALSE: when set mode off
3471 /// @return E_APIPNL_OK or E_APIPNL_FAIL
3472 //-------------------------------------------------------------------------------------------------
MApi_PNL_PreSetModeOn_U2(void * pInstance,MS_BOOL bSetModeOn)3473 APIPNL_Result MApi_PNL_PreSetModeOn_U2(void *pInstance, MS_BOOL bSetModeOn)
3474 {
3475 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
3476 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
3477
3478 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
3479 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3480 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
3481
3482 if( IsVBY1(pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type) )
3483 {
3484 MDrv_PNL_PreSetModeOn(pInstance, bSetModeOn);
3485 }
3486 else if((pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type == E_PNL_LPLL_VBY1_8BIT_4LANE_BYPASS_MODE) ||
3487 (pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type == E_PNL_LPLL_VBY1_10BIT_4LANE_BYPASS_MODE))
3488 {
3489 MDrv_PNL_PreSetModeOn(pInstance, bSetModeOn);
3490 }
3491 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3492
3493 return E_APIPNL_OK;
3494 }
3495
MApi_PNL_PreSetModeOn(MS_BOOL bSetModeOn)3496 APIPNL_Result MApi_PNL_PreSetModeOn(MS_BOOL bSetModeOn)
3497 {
3498 #ifdef UTOPIA_20
3499 if (pu32PNLInst == NULL)
3500 {
3501 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3502 {
3503 printf("UtopiaOpen PNL failed\n");
3504 return E_APIPNL_FAIL;
3505 }
3506 }
3507
3508 stPNL_PreSetModeOn PNLArgs;
3509 PNLArgs.bSetMode = bSetModeOn;
3510 PNLArgs.eResult = E_APIPNL_FAIL;
3511 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_PRE_SET_MODE_ON, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3512 {
3513 printf("Obtain PNL engine fail\n");
3514 return E_APIPNL_FAIL;
3515 }
3516 else
3517 {
3518 return PNLArgs.eResult;
3519 }
3520 #else
3521 return MApi_PNL_PreSetModeOn_U2(pu32PNLInst, bSetModeOn);
3522 #endif
3523 }
3524
MApi_PNL_HWLVDSReservedtoLRFlag_U2(void * pInstance,MS_PNL_HW_LVDSResInfo lvdsresinfo)3525 void MApi_PNL_HWLVDSReservedtoLRFlag_U2(void *pInstance, MS_PNL_HW_LVDSResInfo lvdsresinfo)
3526 {
3527 PNL_DrvHW_LVDSResInfo drv_lvdsinfo;
3528 drv_lvdsinfo.u32pair = lvdsresinfo.u32pair;
3529 drv_lvdsinfo.u16channel = lvdsresinfo.u16channel;
3530 drv_lvdsinfo.bEnable = lvdsresinfo.bEnable;
3531 MDrv_PNL_HWLVDSReservedtoLRFlag(pInstance, drv_lvdsinfo);
3532 }
3533
MApi_PNL_HWLVDSReservedtoLRFlag(MS_PNL_HW_LVDSResInfo lvdsresinfo)3534 void MApi_PNL_HWLVDSReservedtoLRFlag(MS_PNL_HW_LVDSResInfo lvdsresinfo)
3535 {
3536 #ifdef UTOPIA_20
3537 if (pu32PNLInst == NULL)
3538 {
3539 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3540 {
3541 printf("UtopiaOpen PNL failed\n");
3542 return;
3543 }
3544 }
3545
3546 stPNL_HWLVDSReservedtoLRFlag PNLArgs;
3547 PNLArgs.lvdsresinfo = lvdsresinfo;
3548 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_HWLVDSRESERVEDTOLRFLAG, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3549 {
3550 printf("Obtain PNL engine fail\n");
3551 }
3552 #else
3553 MApi_PNL_HWLVDSReservedtoLRFlag_U2(pu32PNLInst, lvdsresinfo);
3554 #endif
3555 }
3556
3557 ////////////////////////////////////////////////////////////////////////
3558 // Turn OD function
3559 ////////////////////////////////////////////////////////////////////////
3560 //-------------------------------------------------------------------------------------------------
3561 /// Initialize OverDrive
3562 /// @param pXC_ODInitData \b IN: the Initialized Data
3563 /// @param u32ODInitDataLen \b IN: the length of the initialized data
3564 /// @return E_APIPNL_OK or E_APIPNL_FAIL
3565 //-------------------------------------------------------------------------------------------------
MApi_PNL_OverDriver_Init_U2(void * pInstance,MS_PNL_OD_INITDATA * pPNL_ODInitData,MS_U32 u32ODInitDataLen)3566 APIPNL_Result MApi_PNL_OverDriver_Init_U2(void *pInstance, MS_PNL_OD_INITDATA *pPNL_ODInitData, MS_U32 u32ODInitDataLen)
3567 {
3568 if(u32ODInitDataLen != sizeof(MS_PNL_OD_INITDATA))
3569 {
3570 return E_APIPNL_FAIL;
3571 }
3572
3573 _PNL_ENTRY();
3574 MDrv_PNL_OverDriver_Init(pInstance, pPNL_ODInitData->u32OD_MSB_Addr, pPNL_ODInitData->u32OD_LSB_Addr, pPNL_ODInitData->u8ODTbl);
3575 _PNL_RETURN();
3576
3577 return E_APIPNL_OK;
3578 }
3579
MApi_PNL_OverDriver_Init(MS_PNL_OD_INITDATA * pPNL_ODInitData,MS_U32 u32ODInitDataLen)3580 APIPNL_Result MApi_PNL_OverDriver_Init(MS_PNL_OD_INITDATA *pPNL_ODInitData, MS_U32 u32ODInitDataLen)
3581 {
3582 #ifdef UTOPIA_20
3583 if (pu32PNLInst == NULL)
3584 {
3585 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3586 {
3587 printf("UtopiaOpen PNL failed\n");
3588 return E_APIPNL_FAIL;
3589 }
3590 }
3591
3592 stPNL_OverDriver_Init PNLArgs;
3593 PNLArgs.pPNL_ODInitData = pPNL_ODInitData;
3594 PNLArgs.u32ODInitDataLen = u32ODInitDataLen;
3595 PNLArgs.eResult = E_APIPNL_FAIL;
3596 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_OVERDRIVER_INIT, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3597 {
3598 printf("Obtain PNL engine fail\n");
3599 return E_APIPNL_FAIL;
3600 }
3601 else
3602 {
3603 return PNLArgs.eResult;
3604 }
3605 #else
3606 return MApi_PNL_OverDriver_Init_U2(pu32PNLInst, pPNL_ODInitData, u32ODInitDataLen);
3607 #endif
3608 }
3609
3610 //-------------------------------------------------------------------------------------------------
3611 /// OverDrive Enable
3612 /// @param bEnable \b IN: TRUE: Enable OverDrive; FALSE: Disable OverDrive
3613 /// @return E_APIPNL_OK or E_APIPNL_FAIL
3614 //-------------------------------------------------------------------------------------------------
MApi_PNL_OverDriver_Enable_U2(void * pInstance,MS_BOOL bEnable)3615 APIPNL_Result MApi_PNL_OverDriver_Enable_U2(void *pInstance, MS_BOOL bEnable)
3616 {
3617 _PNL_ENTRY();
3618 MDrv_PNL_OverDriver_Enable(pInstance, bEnable);
3619 _PNL_RETURN();
3620 return E_APIPNL_OK;
3621 }
3622
MApi_PNL_OverDriver_Enable(MS_BOOL bEnable)3623 APIPNL_Result MApi_PNL_OverDriver_Enable(MS_BOOL bEnable)
3624 {
3625 #ifdef UTOPIA_20
3626 if (pu32PNLInst == NULL)
3627 {
3628 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3629 {
3630 printf("UtopiaOpen PNL failed\n");
3631 return E_APIPNL_FAIL;
3632 }
3633 }
3634
3635 stPNL_OverDriver_Enable PNLArgs;
3636 PNLArgs.bEnable = bEnable;
3637 PNLArgs.eResult = E_APIPNL_FAIL;
3638 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_OVERDRIVER_ENABLE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3639 {
3640 printf("Obtain PNL engine fail\n");
3641 return E_APIPNL_FAIL;
3642 }
3643 else
3644 {
3645 return PNLArgs.eResult;
3646 }
3647 #else
3648 return MApi_PNL_OverDriver_Enable_U2(pu32PNLInst, bEnable);
3649 #endif
3650 }
3651
MApi_MOD_PVDD_Power_Setting_U2(void * pInstance,MS_BOOL bIs2p5)3652 void MApi_MOD_PVDD_Power_Setting_U2(void *pInstance, MS_BOOL bIs2p5)
3653 {
3654 _PNL_ENTRY();
3655 MDrv_MOD_PVDD_Power_Setting(pInstance, bIs2p5);
3656 _PNL_RETURN();
3657 }
3658
MApi_MOD_PVDD_Power_Setting(MS_BOOL bIs2p5)3659 void MApi_MOD_PVDD_Power_Setting(MS_BOOL bIs2p5)
3660 {
3661 #ifdef UTOPIA_20
3662 if (pu32PNLInst == NULL)
3663 {
3664 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3665 {
3666 printf("UtopiaOpen PNL failed\n");
3667 return;
3668 }
3669 }
3670
3671 stPNL_MOD_PVDD_Power_Setting PNLArgs;
3672 PNLArgs.bIs2p5 = bIs2p5;
3673 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_MOD_PVDD_POWER_SETTING, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3674 {
3675 printf("Obtain PNL engine fail\n");
3676 }
3677 #else
3678 MApi_MOD_PVDD_Power_Setting_U2(pu32PNLInst, bIs2p5);
3679 #endif
3680 }
3681
3682 //-------------------------------------------------------------------------------------------------
3683 ///-obosolte!! use MApi_PNL_Control_Out_Swing instead
3684 //-------------------------------------------------------------------------------------------------
MApi_PNL_SetDiffSwingLevel_U2(void * pInstance,MS_U8 u8Swing_Level)3685 MS_BOOL MApi_PNL_SetDiffSwingLevel_U2(void *pInstance, MS_U8 u8Swing_Level)
3686 {
3687 return FALSE;
3688 }
3689
MApi_PNL_SetDiffSwingLevel(MS_U8 u8Swing_Level)3690 MS_BOOL MApi_PNL_SetDiffSwingLevel(MS_U8 u8Swing_Level)
3691 {
3692 #ifdef UTOPIA_20
3693 if (pu32PNLInst == NULL)
3694 {
3695 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3696 {
3697 printf("UtopiaOpen PNL failed\n");
3698 return FALSE;
3699 }
3700 }
3701
3702 stPNL_SetDiffSwingLevel PNLArgs;
3703 PNLArgs.u8Swing_Level = u8Swing_Level;
3704 PNLArgs.bReturn = FALSE;
3705 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETDIFFSWINGLEVEL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3706 {
3707 printf("Obtain PNL engine fail\n");
3708 return FALSE;
3709 }
3710 else
3711 {
3712 return PNLArgs.bReturn;
3713 }
3714 #else
3715 return MApi_PNL_SetDiffSwingLevel_U2(pu32PNLInst, u8Swing_Level);
3716 #endif
3717 }
3718
3719 //-------------------------------------------------------------------------------------------------
3720 /// Get real LPLL type from driver
3721 /// @return MS_U8
3722 //-------------------------------------------------------------------------------------------------
MApi_Pnl_Get_LPLL_Type_U2(void * pInstance)3723 MS_U8 MApi_Pnl_Get_LPLL_Type_U2(void *pInstance)
3724 {
3725 MS_U8 u8Value = 0;
3726 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
3727 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
3728
3729 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
3730 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3731 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
3732 if (pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type >= E_PNL_TYPE_EXT)
3733 {
3734 u8Value = pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type_Ext;
3735 }
3736 else
3737 {
3738 u8Value = pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type;
3739 }
3740 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3741 return u8Value;
3742 }
3743
MApi_Pnl_Get_LPLL_Type(void)3744 MS_U8 MApi_Pnl_Get_LPLL_Type(void)
3745 {
3746 if (pu32PNLInst == NULL)
3747 {
3748 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3749 {
3750 printf("UtopiaOpen PNL failed\n");
3751 return LINK_TTL;
3752 }
3753 }
3754
3755 stPNL_Get_LPLL_Type PNLArgs;
3756 PNLArgs.u8Return = LINK_TTL;
3757 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GET_LPLL_TYPE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3758 {
3759 printf("Obtain PNL engine fail\n");
3760 return LINK_TTL;
3761 }
3762 else
3763 {
3764 return PNLArgs.u8Return;
3765 }
3766 }
3767
3768 //-------------------------------------------------------------------------------------------------
3769 /// Get TCON capability
3770 /// @return MS_BOOL
3771 //-------------------------------------------------------------------------------------------------
MApi_PNL_Get_TCON_Capability_U2(void * pInstance)3772 MS_BOOL MApi_PNL_Get_TCON_Capability_U2(void *pInstance)
3773 {
3774 return MDrv_PNL_Is_SupportTCON(pInstance);
3775 }
3776
MApi_PNL_Get_TCON_Capability(void)3777 MS_BOOL MApi_PNL_Get_TCON_Capability(void)
3778 {
3779 #ifdef UTOPIA_20
3780 if (pu32PNLInst == NULL)
3781 {
3782 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3783 {
3784 printf("UtopiaOpen PNL failed\n");
3785 return FALSE;
3786 }
3787 }
3788
3789 stPNL_Get_TCON_Capability PNLArgs;
3790 PNLArgs.bReturn = FALSE;
3791 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GET_TCON_CAPABILITY, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3792 {
3793 printf("Obtain PNL engine fail\n");
3794 return FALSE;
3795 }
3796 else
3797 {
3798 return PNLArgs.bReturn;
3799 }
3800 #else
3801 return MApi_PNL_Get_TCON_Capability_U2(pu32PNLInst);
3802 #endif
3803 }
3804
3805 //-------------------------------------------------------------------------------------------------
3806 /// Set FRC MOD pair swap
3807 /// @param bEnable \b IN: u8Polarity, (d:c:b:a)=([15:14],[13:12],[11:10],[9:8]) => (10,00,11,01), => (2,0,3,1)
3808 //-------------------------------------------------------------------------------------------------
MApi_PNL_SetPairSwap_U2(void * pInstance,MS_U32 u32Polarity)3809 void MApi_PNL_SetPairSwap_U2(void *pInstance, MS_U32 u32Polarity)
3810 {
3811 if(MDrv_PNL_Is_SupportFRC(pInstance))
3812 MDrv_FRC_MOD_ForcePairSwap(pInstance, u32Polarity);
3813 }
3814
MApi_PNL_SetPairSwap(MS_U32 u32Polarity)3815 void MApi_PNL_SetPairSwap(MS_U32 u32Polarity)
3816 {
3817 #ifdef UTOPIA_20
3818 if (pu32PNLInst == NULL)
3819 {
3820 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3821 {
3822 printf("UtopiaOpen PNL failed\n");
3823 return;
3824 }
3825 }
3826
3827 stPNL_SetPairSwap PNLArgs;
3828 PNLArgs.u32Polarity = u32Polarity;
3829 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETPAIRSWAP, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3830 {
3831 printf("Obtain PNL engine fail\n");
3832 }
3833 #else
3834 MApi_PNL_SetPairSwap_U2(pu32PNLInst, u32Polarity);
3835 #endif
3836 }
3837
MApi_PNL_SetExt_LPLL_Type_U2(void * pInstance,MS_U16 u16Ext_lpll_type)3838 void MApi_PNL_SetExt_LPLL_Type_U2(void *pInstance, MS_U16 u16Ext_lpll_type)
3839 {
3840 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
3841 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
3842
3843 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
3844 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3845 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
3846 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16Ext_LpllType = u16Ext_lpll_type;
3847 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3848 }
3849
MApi_PNL_SetExt_LPLL_Type(MS_U16 u16Ext_lpll_type)3850 void MApi_PNL_SetExt_LPLL_Type(MS_U16 u16Ext_lpll_type)
3851 {
3852 #ifdef UTOPIA_20
3853 if (pu32PNLInst == NULL)
3854 {
3855 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3856 {
3857 printf("UtopiaOpen PNL failed\n");
3858 return;
3859 }
3860 }
3861
3862 stPNL_SetExt_LPLL_Type PNLArgs;
3863 PNLArgs.u16Ext_lpll_type = u16Ext_lpll_type;
3864 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SET_EXT_LPLL_TYPE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3865 {
3866 printf("Obtain PNL engine fail\n");
3867 }
3868 #else
3869 MApi_PNL_SetExt_LPLL_Type_U2(pu32PNLInst, u16Ext_lpll_type);
3870 #endif
3871 }
3872
3873 //-------------------------------------------------------------------------------------------------
3874 /// Cal Ext LPLL Set by DCLK
3875 /// @param ldHz \b IN: ldHz = Htt*Vtt*Vfreq
3876 //-------------------------------------------------------------------------------------------------
MApi_PNL_CalExtLPLLSETbyDClk_U2(void * pInstance,MS_U32 ldHz)3877 void MApi_PNL_CalExtLPLLSETbyDClk_U2(void *pInstance, MS_U32 ldHz)
3878 {
3879 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
3880 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
3881
3882 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
3883 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3884 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
3885 MDrv_PNL_CalExtLPLLSETbyDClk(pInstance, (MS_U8)pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Mode, (MS_U8)pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16Ext_LpllType, ldHz);
3886 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3887 }
3888
MApi_PNL_CalExtLPLLSETbyDClk(MS_U32 ldHz)3889 void MApi_PNL_CalExtLPLLSETbyDClk(MS_U32 ldHz)
3890 {
3891 #ifdef UTOPIA_20
3892 if (pu32PNLInst == NULL)
3893 {
3894 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3895 {
3896 printf("UtopiaOpen PNL failed\n");
3897 return;
3898 }
3899 }
3900
3901 stPNL_CalExtLPLLSETbyDClk PNLArgs;
3902 PNLArgs.ldHz = ldHz;
3903 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_CALEXTLPLLSETBYDCLK, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
3904 {
3905 printf("Obtain PNL engine fail\n");
3906 }
3907 #else
3908 MApi_PNL_CalExtLPLLSETbyDClk_U2(pu32PNLInst, ldHz);
3909 #endif
3910 }
3911
MApi_PNL_SetPowerState_U2(void * pInstance,EN_POWER_MODE ePowerState)3912 MS_U32 MApi_PNL_SetPowerState_U2(void *pInstance, EN_POWER_MODE ePowerState)
3913 {
3914 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
3915 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
3916 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
3917 MS_U8 *tmp[3];
3918
3919 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
3920 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3921 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
3922 #if (KERNEL_DRIVER_PNL_STR_PATCH == 1)
3923 void *pModule;
3924 UtopiaInstanceGetModule(pInstance, &pModule);
3925 PNL_REGS_SAVE_AREA *pPNLResourceStr = NULL;
3926 UtopiaModuleGetSTRPrivate(pModule, (void**)&pPNLResourceStr);
3927 #endif
3928 if (ePowerState == E_POWER_SUSPEND)
3929 {
3930 pPNLResourcePrivate->stapiPNL.ePrevPowerState = ePowerState;
3931 u32Return = UTOPIA_STATUS_SUCCESS;
3932 }
3933 else if (ePowerState == E_POWER_RESUME)
3934 {
3935 if (pPNLResourcePrivate->stapiPNL.ePrevPowerState == E_POWER_SUSPEND)
3936 {
3937 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)); //can not entry semaphore twice!
3938 #if (KERNEL_DRIVER_PNL_STR_PATCH == 1)
3939 if((pPNLResourceStr->pSelPanelType.m_ePanelLinkType == LINK_EXT)&&
3940 (pPNLResourceStr->pSelPanelType.m_wPanelWidth >= 3840)&&(pPNLResourceStr->pSelPanelType.m_wPanelHeight >= 2160))
3941 {
3942 MApi_PNL_MOD_OutputConfig_User_U2(pInstance,pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputCFG0_7,
3943 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputCFG8_15,
3944 pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16OutputCFG16_21);
3945 MApi_BD_LVDS_Output_Type_U2(pInstance,pPNLResourceStr->BD_LVDS_Output_Type);
3946 MApi_PNL_ForceSetPanelDCLK_U2(pInstance,pPNLResourcePrivate->stapiPNL._u16PanelDCLK,pPNLResourcePrivate->stapiPNL._bForceSetDCLKEnable);
3947 }
3948 if(MApi_PNL_GetVideoHWTraining_Status_U2(pInstance))
3949 MApi_PNL_SetVideoHWTraining_U2(pInstance, TRUE);
3950 MApi_PNL_Init_U2(pInstance, &pPNLResourceStr->pSelPanelType);
3951 MApi_PNL_EnablePanel_U2(pInstance, TRUE);
3952 #endif
3953 if (!(pPNLResourcePrivate->stapiPNL._pu8GammaTab[0] == NULL ||
3954 pPNLResourcePrivate->stapiPNL._pu8GammaTab[1] == NULL ||
3955 pPNLResourcePrivate->stapiPNL._pu8GammaTab[2] == NULL))
3956 {
3957 tmp[0]=&(pPNLResourcePrivate->stapiPNL._pu8GammaTab[0][0]);
3958 tmp[1]=&(pPNLResourcePrivate->stapiPNL._pu8GammaTab[1][0]);
3959 tmp[2]=&(pPNLResourcePrivate->stapiPNL._pu8GammaTab[2][0]);
3960 MApi_PNL_SetGammaTbl_U2(pInstance,
3961 pPNLResourcePrivate->stapiPNL._eGammaType,
3962 tmp,
3963 pPNLResourcePrivate->stapiPNL._eGammaMapMode);
3964 }
3965
3966 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3967
3968 pPNLResourcePrivate->stapiPNL.ePrevPowerState = ePowerState;
3969 u32Return = UTOPIA_STATUS_SUCCESS;//RESUME_OK;
3970 }
3971 else
3972 {
3973 printf("[%s,%5d]It is not suspended yet. We shouldn't resume\n", __FUNCTION__, __LINE__);
3974 u32Return = UTOPIA_STATUS_FAIL;//SUSPEND_FAILED;
3975 }
3976 }
3977 else
3978 {
3979 printf("[%s,%5d]Do Nothing: %d\n", __FUNCTION__, __LINE__, ePowerState);
3980 u32Return = UTOPIA_STATUS_NOT_SUPPORTED;
3981 }
3982
3983 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
3984 return u32Return;
3985 }
3986
MApi_PNL_SetPowerState(EN_POWER_MODE ePowerState)3987 MS_U32 MApi_PNL_SetPowerState(EN_POWER_MODE ePowerState)
3988 {
3989 #ifdef UTOPIA_20
3990 if (pu32PNLInst == NULL)
3991 {
3992 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3993 {
3994 printf("UtopiaOpen PNL failed\n");
3995 return UTOPIA_STATUS_FAIL;
3996 }
3997 }
3998
3999 stPNL_SetPowerState PNLArgs;
4000 PNLArgs.ePowerState = ePowerState;
4001 PNLArgs.u32Return = UTOPIA_STATUS_FAIL;
4002 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETPOWERSTATE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4003 {
4004 printf("Obtain PNL engine fail\n");
4005 return UTOPIA_STATUS_FAIL;
4006 }
4007 else
4008 {
4009 return PNLArgs.u32Return;
4010 }
4011 #else
4012 return MApi_PNL_SetPowerState_U2(pu32PNLInst, ePowerState);
4013 #endif
4014 }
4015
MApi_PNL_EnableInternalTermination_U2(void * pInstance,MS_BOOL bEnable)4016 MS_BOOL MApi_PNL_EnableInternalTermination_U2(void *pInstance, MS_BOOL bEnable)
4017 {
4018 return MDrv_PNL_EnableInternalTermination(pInstance, bEnable);
4019 }
4020
MApi_PNL_EnableInternalTermination(MS_BOOL bEnable)4021 MS_BOOL MApi_PNL_EnableInternalTermination(MS_BOOL bEnable)
4022 {
4023 #ifdef UTOPIA_20
4024 if (pu32PNLInst == NULL)
4025 {
4026 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4027 {
4028 printf("UtopiaOpen PNL failed\n");
4029 return FALSE;
4030 }
4031 }
4032
4033 stPNL_EnableInternalTermination PNLArgs;
4034 PNLArgs.bEnable = bEnable;
4035 PNLArgs.bReturn = FALSE;
4036 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_ENABLEINTERNALTERMINATION, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4037 {
4038 printf("Obtain PNL engine fail\n");
4039 return FALSE;
4040 }
4041 else
4042 {
4043 return PNLArgs.bReturn;
4044 }
4045 #else
4046 return MApi_PNL_EnableInternalTermination_U2(pu32PNLInst, bEnable);
4047 #endif
4048 }
4049
4050 //-------------------------------------------------------------------------------------------------
4051 /// Do handshake for special output device, ex. VB1
4052 /// @return TRUE or FALSE
4053 //-------------------------------------------------------------------------------------------------
MApi_PNL_OutputDeviceHandshake_U2(void * pInstance)4054 MS_BOOL MApi_PNL_OutputDeviceHandshake_U2(void *pInstance)
4055 {
4056 MS_BOOL bResult = TRUE;
4057 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4058 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
4059
4060 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4061 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4062 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
4063 _PNL_ENTRY();
4064
4065 // For VB1 type, need to do handshake
4066 if( IsVBY1(pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type) )
4067 {
4068 bResult = MDrv_PNL_VBY1_Handshake(pInstance);
4069 }
4070 else if((pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type == E_PNL_LPLL_VBY1_8BIT_4LANE_BYPASS_MODE) ||
4071 (pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type == E_PNL_LPLL_VBY1_10BIT_4LANE_BYPASS_MODE))
4072 {
4073 bResult = MDrv_PNL_VBY1_Handshake(pInstance);
4074 }
4075
4076 _PNL_RETURN();
4077 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4078
4079 return bResult;
4080
4081 }
4082
MApi_PNL_OutputDeviceHandshake(void)4083 MS_BOOL MApi_PNL_OutputDeviceHandshake(void)
4084 {
4085 #ifdef UTOPIA_20
4086 if (pu32PNLInst == NULL)
4087 {
4088 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4089 {
4090 printf("UtopiaOpen PNL failed\n");
4091 return FALSE;
4092 }
4093 }
4094
4095 stPNL_OutputDeviceHandshake PNLArgs;
4096 PNLArgs.bReturn = FALSE;
4097 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_OUTPUTDEVICEHANDSHAKE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4098 {
4099 printf("Obtain PNL engine fail\n");
4100 return FALSE;
4101 }
4102 else
4103 {
4104 return PNLArgs.bReturn;
4105 }
4106 #else
4107 return MApi_PNL_OutputDeviceHandshake_U2(pu32PNLInst);
4108 #endif
4109 }
4110
4111 //-------------------------------------------------------------------------------------------------
4112 /// Do OC handshake for special output device, ex. VB1
4113 /// @return TRUE or FALSE
4114 //-------------------------------------------------------------------------------------------------
MApi_PNL_OutputDeviceOCHandshake_U2(void * pInstance)4115 MS_BOOL MApi_PNL_OutputDeviceOCHandshake_U2(void *pInstance)
4116 {
4117 MS_BOOL bResult = TRUE;
4118 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4119 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
4120
4121 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4122 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4123 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
4124 _PNL_ENTRY();
4125
4126 // For VB1 type, need to do handshake
4127 if( IsVBY1(pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type) )
4128 {
4129 bResult = MDrv_PNL_VBY1_OC_Handshake(pInstance);
4130 }
4131 else if((pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type == E_PNL_LPLL_VBY1_8BIT_4LANE_BYPASS_MODE) ||
4132 (pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type == E_PNL_LPLL_VBY1_10BIT_4LANE_BYPASS_MODE))
4133 {
4134 bResult = MDrv_PNL_VBY1_OC_Handshake(pInstance);
4135 }
4136
4137 _PNL_RETURN();
4138 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4139 return bResult;
4140
4141 }
4142
MApi_PNL_OutputDeviceOCHandshake(void)4143 MS_BOOL MApi_PNL_OutputDeviceOCHandshake(void)
4144 {
4145 #ifdef UTOPIA_20
4146 if (pu32PNLInst == NULL)
4147 {
4148 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4149 {
4150 printf("UtopiaOpen PNL failed\n");
4151 return FALSE;
4152 }
4153 }
4154
4155 stPNL_OutputDeviceHandshake PNLArgs;
4156 PNLArgs.bReturn = FALSE;
4157 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_OUTPUTDEVICEOCHANDSHAKE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4158 {
4159 printf("Obtain PNL engine fail\n");
4160 return FALSE;
4161 }
4162 else
4163 {
4164 return PNLArgs.bReturn;
4165 }
4166 #else
4167 return MApi_PNL_OutputDeviceOCHandshake_U2(pu32PNLInst);
4168 #endif
4169 }
4170
4171
4172
4173 //-------------------------------------------------------------------------------------------------
4174 /// set necessary setting for outputing interlace timing to rear
4175 /// @return APIPNL_Result
4176 //-------------------------------------------------------------------------------------------------
MApi_PNL_SetOutputInterlaceTiming_U2(void * pInstance,MS_BOOL bEnable)4177 APIPNL_Result MApi_PNL_SetOutputInterlaceTiming_U2(void* pInstance, MS_BOOL bEnable)
4178 {
4179 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4180 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4181 APIPNL_Result bReturn = E_APIPNL_FAIL;
4182 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4183 _PNL_ENTRY();
4184 bReturn = (APIPNL_Result) MDrv_PNL_SetOutputInterlaceTiming(pInstance, bEnable);
4185 _PNL_RETURN();
4186 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4187 return bReturn;
4188 }
4189
MApi_PNL_SetOutputInterlaceTiming(MS_BOOL bEnable)4190 APIPNL_Result MApi_PNL_SetOutputInterlaceTiming(MS_BOOL bEnable)
4191 {
4192 #ifdef UTOPIA_20
4193 if (pu32PNLInst == NULL)
4194 {
4195 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4196 {
4197 printf("UtopiaOpen PNL failed\n");
4198 return E_APIPNL_FAIL;
4199 }
4200 }
4201
4202 stPNL_SetOutputInterlaceTiming PNLArgs;
4203 PNLArgs.bEnable = bEnable;
4204 PNLArgs.eReturn = E_APIPNL_FAIL;
4205 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETOUTPUTINTERLACETIMING, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4206 {
4207 printf("Obtain PNL engine fail\n");
4208 return FALSE;
4209 }
4210 else
4211 {
4212 return PNLArgs.eReturn;
4213 }
4214 #else
4215 return MApi_PNL_SetOutputInterlaceTiming_U2(pu32PNLInst, bEnable);
4216 #endif
4217 }
4218
MApi_PNL_GetOutputInterlaceTiming_U2(void * pInstance)4219 MS_BOOL MApi_PNL_GetOutputInterlaceTiming_U2(void *pInstance)
4220 {
4221 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4222 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4223 MS_BOOL bIsInterlace = FALSE;
4224 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4225 _PNL_ENTRY();
4226
4227 MDrv_PNL_GetOutputInterlaceTiming(pInstance, &bIsInterlace);
4228
4229 _PNL_RETURN();
4230 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4231 return bIsInterlace;
4232
4233 }
4234
MApi_PNL_GetOutputInterlaceTiming(void)4235 MS_BOOL MApi_PNL_GetOutputInterlaceTiming(void)
4236 {
4237 #ifdef UTOPIA_20
4238 if (pu32PNLInst == NULL)
4239 {
4240 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4241 {
4242 printf("UtopiaOpen PNL failed\n");
4243 return FALSE;
4244 }
4245 }
4246
4247 stPNL_GetOutputInterlaceTiming PNLArgs;
4248 PNLArgs.bReturn = FALSE;
4249 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETOUTPUTINTERLACETIMING, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4250 {
4251 printf("Obtain PNL engine fail\n");
4252 return FALSE;
4253 }
4254 else
4255 {
4256 return PNLArgs.bReturn;
4257 }
4258 #else
4259 return MApi_PNL_GetOutputInterlaceTiming_U2(pu32PNLInst);
4260 #endif
4261 }
4262
MApi_PNL_GetPanelData_U2(void * pInstance,PanelType * pstPNLData)4263 void MApi_PNL_GetPanelData_U2(void* pInstance, PanelType* pstPNLData)
4264 {
4265 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4266 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
4267
4268 if(NULL == pstPNLData)
4269 {
4270 printf("NULL input parameter pstPNLData\n");
4271 return;
4272 }
4273
4274 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4275 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4276 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
4277 memcpy(pstPNLData, &(pPNLResourcePrivate->stapiPNL._stPanelTypeSaved), sizeof(PanelType));
4278 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4279 }
4280
MApi_PNL_GetPanelData(PanelType * pstPNLData)4281 void MApi_PNL_GetPanelData(PanelType* pstPNLData)
4282 {
4283 #ifdef UTOPIA_20
4284 if (pu32PNLInst == NULL)
4285 {
4286 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4287 {
4288 printf("UtopiaOpen PNL failed\n");
4289 return;
4290 }
4291 }
4292
4293 stPNL_GetPanelData PNLArgs;
4294 PNLArgs.pstPNLData = pstPNLData;
4295 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4296 {
4297 printf("Obtain PNL engine fail\n");
4298 }
4299 #else
4300 MApi_PNL_GetPanelData_U2(pu32PNLInst, pstPNLData);
4301 #endif
4302 }
4303
MApi_PNL_DumpPanelData_U2(void * pInstance)4304 void MApi_PNL_DumpPanelData_U2(void* pInstance)
4305 {
4306 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4307 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4308
4309 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4310 _DumpData(pInstance);
4311 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4312 }
4313
MApi_PNL_DumpPanelData(void)4314 void MApi_PNL_DumpPanelData(void)
4315 {
4316 #ifdef UTOPIA_20
4317 if (pu32PNLInst == NULL)
4318 {
4319 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4320 {
4321 printf("UtopiaOpen PNL failed\n");
4322 return;
4323 }
4324 }
4325
4326 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_DUMPPANELDATA, NULL) != UTOPIA_STATUS_SUCCESS)
4327 {
4328 printf("Obtain PNL engine fail\n");
4329 }
4330 #else
4331 MApi_PNL_DumpPanelData_U2(pu32PNLInst);
4332 #endif
4333 }
4334
MApi_PNL_SetSSC_U2(void * pInstance,MS_U16 u16Fmodulation,MS_U16 u16Rdeviation,MS_BOOL bEnable)4335 void MApi_PNL_SetSSC_U2(void* pInstance, MS_U16 u16Fmodulation, MS_U16 u16Rdeviation, MS_BOOL bEnable)
4336 {
4337 _PNL_ENTRY();
4338 MDrv_PNL_SetSSC(pInstance, u16Fmodulation, u16Rdeviation, bEnable);
4339 _PNL_RETURN();
4340 }
4341
MApi_PNL_SetSSC(MS_U16 u16Fmodulation,MS_U16 u16Rdeviation,MS_BOOL bEnable)4342 void MApi_PNL_SetSSC(MS_U16 u16Fmodulation, MS_U16 u16Rdeviation, MS_BOOL bEnable)
4343 {
4344 #ifdef UTOPIA_20
4345 if (pu32PNLInst == NULL)
4346 {
4347 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4348 {
4349 printf("UtopiaOpen PNL failed\n");
4350 return;
4351 }
4352 }
4353
4354 stPNL_SetSSC PNLArgs;
4355 PNLArgs.u16Fmodulation = u16Fmodulation;
4356 PNLArgs.u16Rdeviation = u16Rdeviation;
4357 PNLArgs.bEnable = bEnable;
4358 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETSSC, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4359 {
4360 printf("Obtain PNL engine fail\n");
4361 }
4362 #else
4363 MApi_PNL_SetSSC_U2(pu32PNLInst, u16Fmodulation, u16Rdeviation, bEnable);
4364 #endif
4365 }
4366
MApi_PNL_GetPanelOnTiming_U2(void * pInstance,APIPNL_POWER_TIMING_SEQ seq)4367 MS_U16 MApi_PNL_GetPanelOnTiming_U2(void* pInstance, APIPNL_POWER_TIMING_SEQ seq)
4368 {
4369 MS_U16 u16PanelOnTiming = E_APIPNL_POWER_TIMING_NA;
4370 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4371 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
4372
4373 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4374 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4375 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
4376 if(E_APIPNL_POWER_TIMING_1 == seq)
4377 {
4378 u16PanelOnTiming = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelOnTiming1;
4379 }
4380 else if(E_APIPNL_POWER_TIMING_2 == seq)
4381 {
4382 u16PanelOnTiming = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelOnTiming2;
4383 }
4384 else
4385 {
4386 u16PanelOnTiming = E_APIPNL_POWER_TIMING_NA;
4387 }
4388
4389 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4390
4391 return u16PanelOnTiming ;
4392 }
4393
MApi_PNL_GetPanelOnTiming(APIPNL_POWER_TIMING_SEQ seq)4394 MS_U16 MApi_PNL_GetPanelOnTiming(APIPNL_POWER_TIMING_SEQ seq)
4395 {
4396 #ifdef UTOPIA_20
4397 if (pu32PNLInst == NULL)
4398 {
4399 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4400 {
4401 printf("UtopiaOpen PNL failed\n");
4402 return 0;
4403 }
4404 }
4405
4406 stPNL_GetPanelOnTiming PNLArgs;
4407 PNLArgs.seq = seq;
4408 PNLArgs.u16Return = 0;
4409 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETPANELONTIMING, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4410 {
4411 printf("Obtain PNL engine fail\n");
4412 return 0;
4413 }
4414 else
4415 {
4416 return PNLArgs.u16Return;
4417 }
4418 #else
4419 return MApi_PNL_GetPanelOnTiming_U2(pu32PNLInst, seq);
4420 #endif
4421 }
4422
MApi_PNL_GetPanelOffTiming_U2(void * pInstance,APIPNL_POWER_TIMING_SEQ seq)4423 MS_U16 MApi_PNL_GetPanelOffTiming_U2(void* pInstance, APIPNL_POWER_TIMING_SEQ seq)
4424 {
4425 MS_U16 u16PanelOffTiming = E_APIPNL_POWER_TIMING_NA;
4426
4427 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4428 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
4429
4430 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4431 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4432 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
4433 if(E_APIPNL_POWER_TIMING_1 == seq)
4434 {
4435 u16PanelOffTiming = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelOffTiming1;
4436 }
4437 else if(E_APIPNL_POWER_TIMING_2 == seq)
4438 {
4439 u16PanelOffTiming = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelOffTiming2;
4440 }
4441 else
4442 {
4443 u16PanelOffTiming = E_APIPNL_POWER_TIMING_NA;
4444 }
4445
4446 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4447
4448 return u16PanelOffTiming;
4449 }
4450
MApi_PNL_GetPanelOffTiming(APIPNL_POWER_TIMING_SEQ seq)4451 MS_U16 MApi_PNL_GetPanelOffTiming(APIPNL_POWER_TIMING_SEQ seq)
4452 {
4453 #ifdef UTOPIA_20
4454 if (pu32PNLInst == NULL)
4455 {
4456 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4457 {
4458 printf("UtopiaOpen PNL failed\n");
4459 return 0;
4460 }
4461 }
4462
4463 stPNL_GetPanelOffTiming PNLArgs;
4464 PNLArgs.seq = seq;
4465 PNLArgs.u16Return = 0;
4466 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETPANELOFFTIMING, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4467 {
4468 printf("Obtain PNL engine fail\n");
4469 return 0;
4470 }
4471 else
4472 {
4473 return PNLArgs.u16Return;
4474 }
4475 #else
4476 return MApi_PNL_GetPanelOffTiming_U2(pu32PNLInst, seq);
4477 #endif
4478 }
4479
MApi_PNL_GetPanelDimCtrl_U2(void * pInstance,APIPNL_DIMMING_CTRL dim_type)4480 MS_U8 MApi_PNL_GetPanelDimCtrl_U2(void* pInstance, APIPNL_DIMMING_CTRL dim_type)
4481 {
4482 MS_U8 u8PanelDimmingCtrl = 0;
4483 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4484 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
4485
4486 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4487 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4488 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
4489 if(E_APIPNL_DIMMING_MAX == dim_type )
4490 {
4491 u8PanelDimmingCtrl = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelMaxPWMVal;
4492 }
4493 else if(E_APIPNL_DIMMING_MIN == dim_type )
4494 {
4495 u8PanelDimmingCtrl = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelMinPWMVal;
4496 }
4497 else
4498 {
4499 u8PanelDimmingCtrl = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16PanelDimmingCtl;
4500 }
4501
4502 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4503
4504 return u8PanelDimmingCtrl;
4505 }
4506
MApi_PNL_GetPanelDimCtrl(APIPNL_DIMMING_CTRL dim_type)4507 MS_U8 MApi_PNL_GetPanelDimCtrl(APIPNL_DIMMING_CTRL dim_type)
4508 {
4509 #ifdef UTOPIA_20
4510 if (pu32PNLInst == NULL)
4511 {
4512 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4513 {
4514 printf("UtopiaOpen PNL failed\n");
4515 return 0;
4516 }
4517 }
4518
4519 stPNL_GetPanelDimCtrl PNLArgs;
4520 PNLArgs.dim_type = dim_type;
4521 PNLArgs.u8Return = 0;
4522 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETPANELDIMCTRL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4523 {
4524 printf("Obtain PNL engine fail\n");
4525 return 0;
4526 }
4527 else
4528 {
4529 return PNLArgs.u8Return;
4530 }
4531 #else
4532 return MApi_PNL_GetPanelDimCtrl_U2(pu32PNLInst, dim_type);
4533 #endif
4534 }
4535
MApi_PNL_GetAllGammaTbl_U2(void * pInstance)4536 MS_U8** MApi_PNL_GetAllGammaTbl_U2(void* pInstance)
4537 {
4538 MS_U8** ppallGammaTbls;
4539 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4540 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
4541
4542 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4543 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4544 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
4545 ppallGammaTbls = pPNLResourcePrivate->stapiPNL.m_ppAllGammaTbls;
4546 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4547 return ppallGammaTbls;
4548 }
4549
MApi_PNL_GetAllGammaTbl(void)4550 MS_U8** MApi_PNL_GetAllGammaTbl(void)
4551 {
4552 #ifdef UTOPIA_20
4553 if (pu32PNLInst == NULL)
4554 {
4555 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4556 {
4557 printf("UtopiaOpen PNL failed\n");
4558 return NULL;
4559 }
4560 }
4561
4562 stPNL_GetAllGammaTbl PNLArgs;
4563 PNLArgs.ppu8Return = NULL;
4564 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETALLGAMMATBL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4565 {
4566 printf("Obtain PNL engine fail\n");
4567 return NULL;
4568 }
4569 else
4570 {
4571 return PNLArgs.ppu8Return;
4572 }
4573 #else
4574 return MApi_PNL_GetAllGammaTbl_U2(pu32PNLInst);
4575 #endif
4576 }
4577
MApi_PNL_EnablePanel_U2(void * pInstance,MS_BOOL bPanelOn)4578 MS_BOOL MApi_PNL_EnablePanel_U2(void* pInstance, MS_BOOL bPanelOn)
4579 {
4580 MS_BOOL bResult = FALSE;
4581 MS_BOOL bCalEn = ENABLE;
4582 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4583 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
4584
4585 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4586 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4587 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
4588 _PNL_ENTRY();
4589
4590 if( !pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Initialized )
4591 {
4592 PNL_PRINT_VAR(pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Initialized);
4593 PNL_DBG_MSG("Usage of uninitialized function.!!");
4594 }
4595
4596 if(pPNLResourcePrivate->stdrvPNL._stPnlInitData.u32PNL_MISC & (MS_U32)E_APIPNL_MISC_SKIP_CALIBRATION)
4597 bCalEn = DISABLE;
4598
4599 if( IsVBY1(pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type) )
4600 {
4601 bCalEn = DISABLE;
4602 }
4603 else if((pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type == E_PNL_LPLL_VBY1_8BIT_4LANE_BYPASS_MODE) ||
4604 (pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Type == E_PNL_LPLL_VBY1_10BIT_4LANE_BYPASS_MODE))
4605 {
4606 bCalEn = DISABLE;
4607 }
4608
4609 if ( E_PNL_OK == MDrv_PNL_En(pInstance, bPanelOn, bCalEn) )
4610 {
4611 pPNLResourcePrivate->stapiPNL._stPnlStatus.bPanel_Enabled = bPanelOn;
4612 bResult = TRUE;
4613 }
4614 else
4615 {
4616 bResult = FALSE;
4617 }
4618
4619 _PNL_RETURN();
4620 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4621 return bResult;
4622 }
4623
MApi_PNL_EnablePanel(MS_BOOL bPanelOn)4624 MS_BOOL MApi_PNL_EnablePanel(MS_BOOL bPanelOn)
4625 {
4626 #ifdef UTOPIA_20
4627 if (pu32PNLInst == NULL)
4628 {
4629 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4630 {
4631 printf("UtopiaOpen PNL failed\n");
4632 return FALSE;
4633 }
4634 }
4635
4636 stPNL_EnablePanel PNLArgs;
4637 PNLArgs.bPanelOn = bPanelOn;
4638 PNLArgs.bReturn = FALSE;
4639 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_ENABLEPANEL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4640 {
4641 printf("Obtain PNL engine fail\n");
4642 return FALSE;
4643 }
4644 else
4645 {
4646 return PNLArgs.bReturn;
4647 }
4648 #else
4649 return MApi_PNL_EnablePanel_U2(pu32PNLInst, bPanelOn);
4650 #endif
4651 }
4652
MApi_PNL_SetGammaTbl_U2(void * pInstance,APIPNL_GAMMA_TYPE eGammaType,MS_U8 * pu8GammaTab[3],APIPNL_GAMMA_MAPPEING_MODE Gamma_Map_Mode)4653 MS_BOOL MApi_PNL_SetGammaTbl_U2(void* pInstance,
4654 APIPNL_GAMMA_TYPE eGammaType,
4655 MS_U8* pu8GammaTab[3],
4656 APIPNL_GAMMA_MAPPEING_MODE Gamma_Map_Mode)
4657 {
4658 MS_BOOL bResult = FALSE;
4659 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4660 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
4661
4662 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4663 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4664 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
4665 pPNLResourcePrivate->stapiPNL.m_ppAllGammaTbls = pu8GammaTab;
4666 pPNLResourcePrivate->stapiPNL._eGammaType = eGammaType;
4667 pPNLResourcePrivate->stapiPNL._eGammaMapMode = Gamma_Map_Mode;
4668 memcpy(pPNLResourcePrivate->stapiPNL._pu8GammaTab[0] , pu8GammaTab[0] ,sizeof(MS_U8)*GammaTblSize);
4669 memcpy(pPNLResourcePrivate->stapiPNL._pu8GammaTab[1] , pu8GammaTab[1] ,sizeof(MS_U8)*GammaTblSize);
4670 memcpy(pPNLResourcePrivate->stapiPNL._pu8GammaTab[2] , pu8GammaTab[2] ,sizeof(MS_U8)*GammaTblSize);
4671
4672 _PNL_ENTRY();
4673
4674 bResult = ( E_PNL_OK == MDrv_PNL_SetGammaTbl(
4675 pInstance,
4676 (DRVPNL_GAMMA_TYPE)eGammaType,
4677 pu8GammaTab,
4678 Gamma_Map_Mode == E_APIPNL_GAMMA_8BIT_MAPPING ? E_DRVPNL_GAMMA_8BIT_MAPPING : E_DRVPNL_GAMMA_10BIT_MAPPING ));
4679
4680 if(bResult != TRUE)
4681 {
4682 PNL_ASSERT(0, "[%s] fails: ( APIPNL_GAMMA_TYPE: %d, APIPNL_GAMMA_MAPPEING_MODE %d) \n.", __FUNCTION__, eGammaType, Gamma_Map_Mode);
4683 }
4684
4685 _PNL_RETURN();
4686 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4687
4688 return bResult;
4689 }
4690
MApi_PNL_SetGammaTbl(APIPNL_GAMMA_TYPE eGammaType,MS_U8 * pu8GammaTab[3],APIPNL_GAMMA_MAPPEING_MODE Gamma_Map_Mode)4691 MS_BOOL MApi_PNL_SetGammaTbl(APIPNL_GAMMA_TYPE eGammaType,
4692 MS_U8* pu8GammaTab[3],
4693 APIPNL_GAMMA_MAPPEING_MODE Gamma_Map_Mode)
4694 {
4695 #ifdef UTOPIA_20
4696 if (pu32PNLInst == NULL)
4697 {
4698 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4699 {
4700 printf("UtopiaOpen PNL failed\n");
4701 return FALSE;
4702 }
4703 }
4704
4705 stPNL_SetGammaTbl PNLArgs;
4706 PNLArgs.eGammaType = eGammaType;
4707 PNLArgs.Gamma_Map_Mode = Gamma_Map_Mode;
4708 PNLArgs.bReturn = FALSE;
4709 PNLArgs.pu8GammaTab[0] = pu8GammaTab[0];
4710 PNLArgs.pu8GammaTab[1] = pu8GammaTab[1];
4711 PNLArgs.pu8GammaTab[2] = pu8GammaTab[2];
4712 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETGAMMATBL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4713 {
4714 printf("Obtain PNL engine fail\n");
4715 return FALSE;
4716 }
4717 else
4718 {
4719 return PNLArgs.bReturn;
4720 }
4721 #else
4722 return MApi_PNL_SetGammaTbl_U2(pu32PNLInst, eGammaType, pu8GammaTab, Gamma_Map_Mode);
4723 #endif
4724 }
4725
MApi_PNL_GetGammaTbl_U2(void * pInstance,APIPNL_GAMMA_TYPE eGammaType,MS_U8 * pu8GammaTab[3],APIPNL_GAMMA_MAPPEING_MODE Gamma_Map_Mode)4726 MS_BOOL MApi_PNL_GetGammaTbl_U2(void* pInstance,
4727 APIPNL_GAMMA_TYPE eGammaType,
4728 MS_U8* pu8GammaTab[3],
4729 APIPNL_GAMMA_MAPPEING_MODE Gamma_Map_Mode)
4730 {
4731 MS_BOOL bResult = FALSE;
4732
4733 _PNL_ENTRY();
4734 bResult = ( E_PNL_OK == MDrv_PNL_GetGammaTbl(
4735 pInstance,
4736 (DRVPNL_GAMMA_TYPE)eGammaType,
4737 pu8GammaTab,
4738 Gamma_Map_Mode == E_APIPNL_GAMMA_8BIT_MAPPING ? E_DRVPNL_GAMMA_8BIT_MAPPING : E_DRVPNL_GAMMA_10BIT_MAPPING ));
4739
4740 if(bResult != TRUE)
4741 {
4742 PNL_ASSERT(0, "[%s] fails: ( APIPNL_GAMMA_TYPE: %d, APIPNL_GAMMA_MAPPEING_MODE %d) \n.", __FUNCTION__, eGammaType, Gamma_Map_Mode);
4743 }
4744
4745 _PNL_RETURN();
4746 return bResult;
4747 }
4748
MApi_PNL_GetGammaTbl(APIPNL_GAMMA_TYPE eGammaType,MS_U8 * pu8GammaTab[3],APIPNL_GAMMA_MAPPEING_MODE Gamma_Map_Mode)4749 MS_BOOL MApi_PNL_GetGammaTbl(APIPNL_GAMMA_TYPE eGammaType,
4750 MS_U8* pu8GammaTab[3],
4751 APIPNL_GAMMA_MAPPEING_MODE Gamma_Map_Mode)
4752 {
4753 #ifdef UTOPIA_20
4754 if (pu32PNLInst == NULL)
4755 {
4756 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4757 {
4758 printf("UtopiaOpen PNL failed\n");
4759 return FALSE;
4760 }
4761 }
4762
4763 stPNL_GetGammaTbl PNLArgs;
4764 PNLArgs.eGammaType = eGammaType;
4765 PNLArgs.Gamma_Map_Mode = Gamma_Map_Mode;
4766 PNLArgs.bReturn = FALSE;
4767 PNLArgs.pu8GammaTab[0] = pu8GammaTab[0];
4768 PNLArgs.pu8GammaTab[1] = pu8GammaTab[1];
4769 PNLArgs.pu8GammaTab[2] = pu8GammaTab[2];
4770 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETGAMMATBL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4771 {
4772 printf("Obtain PNL engine fail\n");
4773 return FALSE;
4774 }
4775 else
4776 {
4777 return PNLArgs.bReturn;
4778 }
4779 #else
4780 return MApi_PNL_GetGammaTbl_U2(pu32PNLInst, eGammaType, pu8GammaTab, Gamma_Map_Mode);
4781 #endif
4782 }
4783
MApi_PNL_SetGammaValue_U2(void * pInstance,MS_U8 u8Channel,MS_U16 u16Offset,MS_U16 u16GammaValue)4784 MS_BOOL MApi_PNL_SetGammaValue_U2(void* pInstance, MS_U8 u8Channel, MS_U16 u16Offset, MS_U16 u16GammaValue)
4785 {
4786 MS_BOOL bResult = FALSE;
4787
4788 _PNL_ENTRY();
4789
4790 bResult = ( E_PNL_OK == MDrv_PNL_SetGammaValue(pInstance, u8Channel, u16Offset, u16GammaValue));
4791
4792 _PNL_RETURN();
4793 return bResult;
4794 }
4795
MApi_PNL_SetGammaValue(MS_U8 u8Channel,MS_U16 u16Offset,MS_U16 u16GammaValue)4796 MS_BOOL MApi_PNL_SetGammaValue(MS_U8 u8Channel, MS_U16 u16Offset, MS_U16 u16GammaValue)
4797 {
4798 #ifdef UTOPIA_20
4799 if (pu32PNLInst == NULL)
4800 {
4801 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4802 {
4803 printf("UtopiaOpen PNL failed\n");
4804 return FALSE;
4805 }
4806 }
4807
4808 stPNL_SetGammaValue PNLArgs;
4809 PNLArgs.u8Channel = u8Channel;
4810 PNLArgs.u16Offset = u16Offset;
4811 PNLArgs.u16GammaValue = u16GammaValue;
4812 PNLArgs.bReturn = FALSE;
4813 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETGAMMAVALUE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4814 {
4815 printf("Obtain PNL engine fail\n");
4816 return FALSE;
4817 }
4818 else
4819 {
4820 return PNLArgs.bReturn;
4821 }
4822 #else
4823 return MApi_PNL_SetGammaValue_U2(pu32PNLInst, u8Channel, u16Offset, u16GammaValue);
4824 #endif
4825 }
4826
MApi_PNL_GetLPLLMode_U2(void * pInstance)4827 MS_U8 MApi_PNL_GetLPLLMode_U2(void *pInstance)
4828 {
4829 MS_U8 u8LPLLMode = 0;
4830 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4831 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
4832
4833 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4834 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4835 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
4836 u8LPLLMode = pPNLResourcePrivate->stdrvPNL._stPnlInitData.eLPLL_Mode;
4837 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4838 return u8LPLLMode;
4839 }
4840
MApi_PNL_GetLPLLMode(void)4841 MS_U8 MApi_PNL_GetLPLLMode(void)
4842 {
4843 if (pu32PNLInst == NULL)
4844 {
4845 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4846 {
4847 printf("UtopiaOpen PNL failed\n");
4848 return E_PNL_MODE_SINGLE;
4849 }
4850 }
4851
4852 stPNL_GetLPLLMode PNLArgs;
4853 PNLArgs.u8Return = E_PNL_MODE_SINGLE;
4854 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETLPLLMODE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4855 {
4856 printf("Obtain PNL engine fail\n");
4857 return E_PNL_MODE_SINGLE;
4858 }
4859 else
4860 {
4861 return PNLArgs.u8Return;
4862 }
4863 }
4864
MApi_PNL_GetDefVFreq_U2(void * pInstance)4865 MS_U16 MApi_PNL_GetDefVFreq_U2(void *pInstance)
4866 {
4867 MS_U16 u16DefaultVFreq = 0;
4868 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4869 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
4870
4871 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4872 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4873 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
4874 u16DefaultVFreq = pPNLResourcePrivate->stdrvPNL._stPnlInitData.u16DefaultVFreq;
4875 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4876 return u16DefaultVFreq;
4877 }
4878
MApi_PNL_GetDefVFreq(void)4879 MS_U16 MApi_PNL_GetDefVFreq(void)
4880 {
4881 if (pu32PNLInst == NULL)
4882 {
4883 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4884 {
4885 printf("UtopiaOpen PNL failed\n");
4886 return 0;
4887 }
4888 }
4889
4890 stPNL_GetDefVFreq PNLArgs;
4891 PNLArgs.u16Return = 0;
4892 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETDEFVFREQ, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4893 {
4894 printf("Obtain PNL engine fail\n");
4895 return 0;
4896 }
4897 else
4898 {
4899 return PNLArgs.u16Return;
4900 }
4901 }
4902
_XC_PNL_GET_DEVICE_NUM(void)4903 MS_U32 _XC_PNL_GET_DEVICE_NUM(void)
4904 {
4905 return MDrv_PNL_GetDeviceNum();
4906 }
4907
MApi_PNL_Check_VBY1_Handshake_Status_U2(void * pInstance)4908 MS_BOOL MApi_PNL_Check_VBY1_Handshake_Status_U2(void *pInstance)
4909 {
4910 MS_BOOL bResult = false;
4911
4912 _PNL_ENTRY();
4913 bResult = MDrv_PNL_Check_VBY1_Handshake_Status(pInstance);
4914 _PNL_RETURN();
4915
4916 return bResult;
4917 }
4918
MApi_PNL_Check_VBY1_Handshake_Status(void)4919 MS_BOOL MApi_PNL_Check_VBY1_Handshake_Status(void)
4920 {
4921 #ifdef UTOPIA_20
4922 if (pu32PNLInst == NULL)
4923 {
4924 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4925 {
4926 printf("UtopiaOpen PNL failed\n");
4927 return E_PNL_MODE_SINGLE;
4928 }
4929 }
4930 stPNL_CheckVBY1HandshakeStatus PNLArgs;
4931 PNLArgs.bResult = FALSE;
4932 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_CHECKVBY1HANDSHAKESTATUS, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4933 {
4934 printf("Obtain PNL engine fail\n");
4935 return 0;
4936 }
4937 else
4938 {
4939 return PNLArgs.bResult;
4940 }
4941 #else
4942 return MApi_PNL_Check_VBY1_Handshake_Status_U2(pu32PNLInst);
4943 #endif
4944 }
4945
MApi_PNL_SetVideoHWTraining_U2(void * pInstance,MS_BOOL bEnable)4946 void MApi_PNL_SetVideoHWTraining_U2(void *pInstance, MS_BOOL bEnable)
4947 {
4948 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4949 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
4950
4951 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4952 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4953 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
4954 pPNLResourcePrivate->stdrvPNL._stPnlInitData.bVideo_HW_Training_En = bEnable;
4955 MDrv_PNL_VBY1_Hardware_TrainingMode_En(pInstance, TRUE, bEnable);
4956 printf("\nEnable Video HW Training mode\n");
4957 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4958 }
4959
MApi_PNL_SetVideoHWTraining(MS_BOOL bEnable)4960 void MApi_PNL_SetVideoHWTraining(MS_BOOL bEnable)
4961 {
4962 #ifdef UTOPIA_20
4963 if (pu32PNLInst == NULL)
4964 {
4965 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4966 {
4967 printf("UtopiaOpen PNL failed\n");
4968 return;
4969 }
4970 }
4971
4972 stPNL_MOD_Video_HWTrainingMode PNLArgs;
4973 PNLArgs.bEnable = bEnable;
4974 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SET_VIDEOHWTRAINING_MODE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
4975 {
4976 printf("Obtain PNL engine fail\n");
4977 }
4978 #else
4979 MApi_PNL_SetVideoHWTraining_U2(pu32PNLInst, bEnable);
4980 #endif
4981 }
4982
MApi_PNL_SetOSDHWTraining_U2(void * pInstance,MS_BOOL bEnable)4983 void MApi_PNL_SetOSDHWTraining_U2(void *pInstance, MS_BOOL bEnable)
4984 {
4985 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
4986 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
4987
4988 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
4989 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4990 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
4991 pPNLResourcePrivate->stdrvPNL._stPnlInitData.bOSD_HW_Training_En = bEnable;
4992 MDrv_PNL_VBY1_Hardware_TrainingMode_En(pInstance, FALSE, bEnable);
4993 printf("Enable OSD HW Training mode\n");
4994 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
4995 }
4996
MApi_PNL_SetOSDHWTraining(MS_BOOL bEnable)4997 void MApi_PNL_SetOSDHWTraining(MS_BOOL bEnable)
4998 {
4999 #ifdef UTOPIA_20
5000 if (pu32PNLInst == NULL)
5001 {
5002 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
5003 {
5004 printf("UtopiaOpen PNL failed\n");
5005 return;
5006 }
5007 }
5008
5009 stPNL_MOD_OSD_HWTrainingMode PNLArgs;
5010 PNLArgs.bEnable = bEnable;
5011 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SET_OSDHWTRAINING_MODE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
5012 {
5013 printf("Obtain PNL engine fail\n");
5014 }
5015 #else
5016 MApi_PNL_SetOSDHWTraining_U2(pu32PNLInst, bEnable);
5017 #endif
5018 }
5019
MApi_PNL_GetVideoHWTraining_Status_U2(void * pInstance)5020 MS_BOOL MApi_PNL_GetVideoHWTraining_Status_U2(void *pInstance)
5021 {
5022 MS_BOOL bStatus = 0;
5023 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
5024 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
5025
5026 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
5027 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
5028 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
5029 bStatus = pPNLResourcePrivate->stdrvPNL._stPnlInitData.bVideo_HW_Training_En;
5030 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
5031 return bStatus;
5032 }
5033
5034
MApi_PNL_GetVideoHWTraining_Status(void)5035 MS_BOOL MApi_PNL_GetVideoHWTraining_Status(void)
5036 {
5037 #ifdef UTOPIA_20
5038 if (pu32PNLInst == NULL)
5039 {
5040 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
5041 {
5042 printf("UtopiaOpen PNL failed\n");
5043 return 0;
5044 }
5045 }
5046
5047 stPNL_GetVideoHWTraining_status PNLArgs;
5048 PNLArgs.bStatus = 0;
5049 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GET_VIDEOHWTRAINING_MODE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
5050 {
5051 printf("Obtain PNL engine fail\n");
5052 return 0;
5053 }
5054 else
5055 {
5056 return PNLArgs.bStatus;
5057 }
5058 #else
5059 return MApi_PNL_GetVideoHWTraining_Status_U2(pu32PNLInst);
5060 #endif
5061 }
5062
MApi_PNL_GetOSDHWTraining_Status_U2(void * pInstance)5063 MS_BOOL MApi_PNL_GetOSDHWTraining_Status_U2(void *pInstance)
5064 {
5065 MS_BOOL bStatus = 0;
5066 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
5067 PNL_RESOURCE_PRIVATE* pPNLResourcePrivate = NULL;
5068
5069 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
5070 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
5071 UtopiaResourceGetPrivate(g_pPNLResource[PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID)],(void**)(&pPNLResourcePrivate));
5072 bStatus = pPNLResourcePrivate->stdrvPNL._stPnlInitData.bOSD_HW_Training_En;
5073 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
5074 return bStatus;
5075 }
5076
MApi_PNL_GetOSDHWTraining_Status(void)5077 MS_BOOL MApi_PNL_GetOSDHWTraining_Status(void)
5078 {
5079 #ifdef UTOPIA_20
5080 if (pu32PNLInst == NULL)
5081 {
5082 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
5083 {
5084 printf("UtopiaOpen PNL failed\n");
5085 return 0;
5086 }
5087 }
5088
5089 stPNL_GetOSDHWTraining_status PNLArgs;
5090 PNLArgs.bStatus = 0;
5091 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GET_OSDHWTRAINING_MODE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
5092 {
5093 printf("Obtain PNL engine fail\n");
5094 return 0;
5095 }
5096 else
5097 {
5098 return PNLArgs.bStatus;
5099 }
5100 #else
5101 return MApi_PNL_GetOSDHWTraining_Status_U2(pu32PNLInst);
5102 #endif
5103 }
5104
MApi_PNL_Setting_U2(void * pInstance,MS_U32 u32Cmd,void * pCmdArgs,MS_U32 u32CmdArgsSize)5105 APIPNL_Result MApi_PNL_Setting_U2(void* pInstance,MS_U32 u32Cmd,void *pCmdArgs,MS_U32 u32CmdArgsSize)
5106 {
5107
5108 MS_BOOL bResult = E_APIPNL_FAIL;
5109 switch(u32Cmd)
5110 {
5111 case E_PNL_MOD_PECURRENT_SETTING:
5112 {
5113 if(u32CmdArgsSize == sizeof(ST_PNL_MOD_PECURRENT_SETTING))
5114 {
5115 ST_PNL_MOD_PECURRENT_SETTING *stPnlModPecurrentSetting = (ST_PNL_MOD_PECURRENT_SETTING *)pCmdArgs;
5116
5117 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
5118 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
5119 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
5120
5121 MDrv_PNL_MOD_PECurrent_Setting(pInstance, stPnlModPecurrentSetting->u16Current_Level, stPnlModPecurrentSetting->u16Channel_Select);
5122
5123 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
5124
5125 bResult = E_APIPNL_OK;
5126 }
5127 else
5128 {
5129 //PNL_DBG(PNL_DBGLEVEL_INIT,"E_PNL_MOD_PECURRENT_SETTING Struct Size No Match\n");
5130 return bResult;
5131 }
5132 break;
5133 }
5134 case E_PNL_CONTROL_OUT_SWING:
5135 {
5136 if(u32CmdArgsSize == sizeof(ST_PNL_CONTROL_OUT_SWING))
5137 {
5138 ST_PNL_CONTROL_OUT_SWING *stPnlControlOutSwing = (ST_PNL_CONTROL_OUT_SWING *)pCmdArgs;
5139
5140 PNL_INSTANCE_PRIVATE *pPNLInstancePrivate = NULL;
5141 UtopiaInstanceGetPrivate(pInstance, (void**)&pPNLInstancePrivate);
5142 _PNL_SEMAPHORE_ENTRY(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
5143
5144 bResult = MDrv_PNL_Control_Out_Swing(pInstance, stPnlControlOutSwing->u16Swing_Level);
5145
5146 _PNL_SEMAPHORE_RETURN(pInstance,PNL_GET_INTERNAL_POOL_ID(pPNLInstancePrivate->u32DeviceID));
5147 }
5148 else
5149 {
5150 //PNL_DBG(PNL_DBGLEVEL_INIT,"E_PNL_CONTROL_OUT_SWING Struct Size No Match\n");
5151 return bResult;
5152 }
5153 break;
5154 }
5155 default:
5156 printf("Unknow Handle ID!\n");
5157 break;
5158 }
5159
5160 return bResult;
5161 }
5162
MApi_PNL_Setting(MS_U32 u32Cmd,void * pCmdArgs,MS_U32 u32CmdArgsSize)5163 APIPNL_Result MApi_PNL_Setting(MS_U32 u32Cmd,void *pCmdArgs,MS_U32 u32CmdArgsSize)
5164 {
5165 #ifdef UTOPIA_20
5166 if (pu32PNLInst == NULL)
5167 {
5168 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
5169 {
5170 printf("UtopiaOpen PNL failed\n");
5171 return 0;
5172 }
5173 }
5174
5175 stPNL_Setting PNLArgs;
5176 PNLArgs.u32Cmd = u32Cmd;
5177 PNLArgs.pCmdArgs = pCmdArgs;
5178 PNLArgs.u32CmdArgsSize = u32CmdArgsSize;
5179 PNLArgs.eReturnValue = E_APIPNL_FAIL;
5180
5181 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_Setting, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
5182 {
5183 printf("Obtain PNL engine fail\n");
5184 return E_APIPNL_FAIL;
5185 }
5186 else
5187 {
5188 return PNLArgs.eReturnValue;
5189 }
5190 #else
5191 return MApi_PNL_Setting_U2(pu32PNLInst, u32Cmd, pCmdArgs, u32CmdArgsSize);
5192 #endif
5193 }
5194
5195
5196 //} // Marked it by coverity_0553
5197
5198 #endif
5199