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_EX_C_
79 #define _API_XC_PANEL_EX_C_
80
81 /******************************************************************************/
82 /* Includes */
83 /******************************************************************************/
84 #include "MsCommon.h"
85 #include "MsVersion.h"
86 #include "MsIRQ.h"
87 #include "MsOS.h"
88
89 #ifdef MSOS_TYPE_LINUX_KERNEL
90 #include <linux/string.h>
91 #else
92 #include <string.h>
93 #endif
94
95 #include "utopia.h"
96 #include "utopia_dapi.h"
97 #include "apiPNL.h"
98 #include "apiPNL_v2.h"
99 #include "apiPNL_EX.h"
100 #include "drvPNL.h"
101 #include "PNL_private.h"
102
103 // for Utopia 2.0 to Utopia 1.0 compatibility
104 extern void* pu32PNLInst;
105 void* pu32PNLInst1 = NULL;
106
107 #define _PNL_SELECT_INSTANCE(u32Id) ((u32Id == 0)? pu32PNLInst : pu32PNLInst1)
108 #define _PNL_SELECT_INSTANCE_P(u32Id) ((u32Id == 0)? &pu32PNLInst : &pu32PNLInst1)
109
110 #ifndef UNUSED
111 #define UNUSED(x) ((x)=(x))
112 #endif
113
114 #define PNL_DBG_MSG(fmt,...) \
115 MS_DEBUG_MSG(do{ \
116 if(_u16PnlDbgSwitch){ \
117 printf( "[PNL_DBG_MSG]: %s: %d \n" fmt, __FUNCTION__, __LINE__, ## __VA_ARGS__); \
118 } \
119 } while(0))
120
121
122 //
123 // Dump m_panel data
124 //
_MApi_XC_DumpPanelData(const PNL_DeviceId * pPNL_DeviceId)125 static void _MApi_XC_DumpPanelData(const PNL_DeviceId *pPNL_DeviceId)
126 {
127 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
128 {
129 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
130 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
131 {
132 printf("UtopiaOpen PNL failed\n");
133 return;
134 }
135 }
136
137 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_DUMPPANELDATA, NULL) != UTOPIA_STATUS_SUCCESS)
138 {
139 printf("Obtain PNL engine fail\n");
140 }
141 }
142 //
143 //
_SetSSC(const PNL_DeviceId * pPNL_DeviceId,MS_U16 u16Fmodulation,MS_U16 u16Rdeviation,MS_BOOL bEnable)144 void _SetSSC(const PNL_DeviceId *pPNL_DeviceId, MS_U16 u16Fmodulation, MS_U16 u16Rdeviation, MS_BOOL bEnable)
145 {
146 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
147 {
148 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
149 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
150 {
151 printf("UtopiaOpen PNL failed\n");
152 return;
153 }
154 }
155
156 stPNL_SetSSC PNLArgs;
157 PNLArgs.u16Fmodulation = u16Fmodulation;
158 PNLArgs.u16Rdeviation = u16Rdeviation;
159 PNLArgs.bEnable = bEnable;
160 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_SETSSC, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
161 {
162 printf("Obtain PNL engine fail\n");
163 }
164 }
165 //
166 //
_EmptyMethod(const PNL_DeviceId * pPNL_DeviceId,MS_BOOL bEnable)167 static void _EmptyMethod(const PNL_DeviceId *pPNL_DeviceId, MS_BOOL bEnable)
168 {
169 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
170 {
171 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
172 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
173 {
174 printf("UtopiaOpen PNL failed\n");
175 return;
176 }
177 }
178
179 UNUSED(bEnable);
180 PNL_DBG_MSG(" Error!! <============== Calling a non-registered function!!");
181 }
182 //
183 //
_getPanelHstart(const PNL_DeviceId * pPNL_DeviceId)184 static MS_U16 _getPanelHstart(const PNL_DeviceId *pPNL_DeviceId)
185 {
186 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
187 )
188 {
189 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
190 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
191 {
192 printf("UtopiaOpen PNL failed\n");
193 return 0;
194 }
195 }
196
197 PanelType stPanelData;
198 stPNL_GetPanelData PNLArgs;
199 memset(&stPanelData, 0, sizeof(PanelType));
200 PNLArgs.pstPNLData = &stPanelData;
201
202 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
203 {
204 printf("Obtain PNL engine fail\n");
205 return 0;
206 }
207 else
208 {
209 return stPanelData.m_wPanelHStart;
210 }
211 }
212
_getPanelVstart(const PNL_DeviceId * pPNL_DeviceId)213 static MS_U16 _getPanelVstart(const PNL_DeviceId *pPNL_DeviceId)
214 {
215 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
216 )
217 {
218 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
219 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
220 {
221 printf("UtopiaOpen PNL failed\n");
222 return 0;
223 }
224 }
225
226 PanelType stPanelData;
227 stPNL_GetPanelData PNLArgs;
228 memset(&stPanelData, 0, sizeof(PanelType));
229 PNLArgs.pstPNLData = &stPanelData;
230
231 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
232 {
233 printf("Obtain PNL engine fail\n");
234 return 0;
235 }
236 else
237 {
238 return stPanelData.m_wPanelVStart;
239 }
240 }
241
_getPanelWidth(const PNL_DeviceId * pPNL_DeviceId)242 static MS_U16 _getPanelWidth (const PNL_DeviceId *pPNL_DeviceId)
243 {
244 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
245 )
246 {
247 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
248 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
249 {
250 printf("UtopiaOpen PNL failed\n");
251 return 0;
252 }
253 }
254
255 PanelType stPanelData;
256 stPNL_GetPanelData PNLArgs;
257 memset(&stPanelData, 0, sizeof(PanelType));
258 PNLArgs.pstPNLData = &stPanelData;
259
260 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
261 {
262 printf("Obtain PNL engine fail\n");
263 return 0;
264 }
265 else
266 {
267 return stPanelData.m_wPanelWidth;
268 }
269 }
270
_getPanelHeight(const PNL_DeviceId * pPNL_DeviceId)271 static MS_U16 _getPanelHeight(const PNL_DeviceId *pPNL_DeviceId)
272 {
273 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
274 )
275 {
276 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
277 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
278 {
279 printf("UtopiaOpen PNL failed\n");
280 return 0;
281 }
282 }
283
284 PanelType stPanelData;
285 stPNL_GetPanelData PNLArgs;
286 memset(&stPanelData, 0, sizeof(PanelType));
287 PNLArgs.pstPNLData = &stPanelData;
288
289 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
290 {
291 printf("Obtain PNL engine fail\n");
292 return 0;
293 }
294 else
295 {
296 return stPanelData.m_wPanelHeight;
297 }
298 }
299
_getPanelhtotal(const PNL_DeviceId * pPNL_DeviceId)300 static MS_U16 _getPanelhtotal(const PNL_DeviceId *pPNL_DeviceId)
301 {
302 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
303 )
304 {
305 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
306 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
307 {
308 printf("UtopiaOpen PNL failed\n");
309 return 0;
310 }
311 }
312
313 PanelType stPanelData;
314 stPNL_GetPanelData PNLArgs;
315 memset(&stPanelData, 0, sizeof(PanelType));
316 PNLArgs.pstPNLData = &stPanelData;
317
318 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
319 {
320 printf("Obtain PNL engine fail\n");
321 return 0;
322 }
323 else
324 {
325 return stPanelData.m_wPanelHTotal;
326 }
327 }
328
_getPanelVtotal(const PNL_DeviceId * pPNL_DeviceId)329 static MS_U16 _getPanelVtotal(const PNL_DeviceId *pPNL_DeviceId)
330 {
331 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
332 )
333 {
334 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
335 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
336 {
337 printf("UtopiaOpen PNL failed\n");
338 return 0;
339 }
340 }
341
342 PanelType stPanelData;
343 stPNL_GetPanelData PNLArgs;
344 memset(&stPanelData, 0, sizeof(PanelType));
345 PNLArgs.pstPNLData = &stPanelData;
346
347 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
348 {
349 printf("Obtain PNL engine fail\n");
350 return 0;
351 }
352 else
353 {
354 return stPanelData.m_wPanelVTotal;
355 }
356 }
357
_getPanelMinSET(const PNL_DeviceId * pPNL_DeviceId)358 static MS_U32 _getPanelMinSET(const PNL_DeviceId *pPNL_DeviceId)
359 {
360 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
361 )
362 {
363 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
364 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
365 {
366 printf("UtopiaOpen PNL failed\n");
367 return 0;
368 }
369 }
370
371 PanelType stPanelData;
372 stPNL_GetPanelData PNLArgs;
373 memset(&stPanelData, 0, sizeof(PanelType));
374 PNLArgs.pstPNLData = &stPanelData;
375
376 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
377 {
378 printf("Obtain PNL engine fail\n");
379 return 0;
380 }
381 else
382 {
383 return stPanelData.m_dwPanelMinSET;
384 }
385 }
386
_getPanelMaxSET(const PNL_DeviceId * pPNL_DeviceId)387 static MS_U32 _getPanelMaxSET(const PNL_DeviceId *pPNL_DeviceId)
388 {
389 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
390 )
391 {
392 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
393 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
394 {
395 printf("UtopiaOpen PNL failed\n");
396 return 0;
397 }
398 }
399
400 PanelType stPanelData;
401 stPNL_GetPanelData PNLArgs;
402 memset(&stPanelData, 0, sizeof(PanelType));
403 PNLArgs.pstPNLData = &stPanelData;
404
405 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
406 {
407 printf("Obtain PNL engine fail\n");
408 return 0;
409 }
410 else
411 {
412 return stPanelData.m_dwPanelMaxSET;
413 }
414 }
415
_getPanelDefVFreq(const PNL_DeviceId * pPNL_DeviceId)416 static MS_U16 _getPanelDefVFreq(const PNL_DeviceId *pPNL_DeviceId)
417 {
418 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
419 {
420 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
421 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
422 {
423 printf("UtopiaOpen PNL failed\n");
424 return 0;
425 }
426 }
427
428 stPNL_GetDefVFreq PNLArgs;
429 PNLArgs.u16Return = 0;
430 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETDEFVFREQ, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
431 {
432 printf("Obtain PNL engine fail\n");
433 return 0;
434 }
435 else
436 {
437 return PNLArgs.u16Return;
438 }
439 }
440
_getPanel_LPLL_Mode(const PNL_DeviceId * pPNL_DeviceId)441 static MS_U8 _getPanel_LPLL_Mode(const PNL_DeviceId *pPNL_DeviceId)
442 {
443 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
444 {
445 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
446 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
447 {
448 printf("UtopiaOpen PNL failed\n");
449 return E_PNL_MODE_SINGLE;
450 }
451 }
452
453 stPNL_GetLPLLMode PNLArgs;
454 PNLArgs.u8Return = E_PNL_MODE_SINGLE;
455 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETLPLLMODE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
456 {
457 printf("Obtain PNL engine fail\n");
458 return E_PNL_MODE_SINGLE;
459 }
460 else
461 {
462 return PNLArgs.u8Return;
463 }
464 }
465
_getPanel_LPLL_Type(const PNL_DeviceId * pPNL_DeviceId)466 static MS_U8 _getPanel_LPLL_Type(const PNL_DeviceId *pPNL_DeviceId)
467 {
468 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
469 {
470 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
471 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
472 {
473 printf("UtopiaOpen PNL failed\n");
474 return E_PNL_EX_LINK_TTL;
475 }
476 }
477
478 stPNL_Get_LPLL_Type PNLArgs;
479 PNLArgs.u8Return = LINK_TTL;
480 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GET_LPLL_TYPE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
481 {
482 printf("Obtain PNL engine fail\n");
483 return E_PNL_EX_LINK_TTL;
484 }
485 else
486 {
487 return (PNL_EX_LINK_TYPE)PNLArgs.u8Return;
488 }
489 }
490
_getPanelHSyncWidth(const PNL_DeviceId * pPNL_DeviceId)491 static MS_U8 _getPanelHSyncWidth(const PNL_DeviceId *pPNL_DeviceId)
492 {
493 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
494 )
495 {
496 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
497 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
498 {
499 printf("UtopiaOpen PNL failed\n");
500 return 0;
501 }
502 }
503
504 PanelType stPanelData;
505 stPNL_GetPanelData PNLArgs;
506 memset(&stPanelData, 0, sizeof(PanelType));
507 PNLArgs.pstPNLData = &stPanelData;
508
509 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
510 {
511 printf("Obtain PNL engine fail\n");
512 return 0;
513 }
514 else
515 {
516 return stPanelData.m_ucPanelHSyncWidth;
517 }
518 }
519
_getPanelHSyncBackPorch(const PNL_DeviceId * pPNL_DeviceId)520 static MS_U8 _getPanelHSyncBackPorch(const PNL_DeviceId *pPNL_DeviceId)
521 {
522 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
523 )
524 {
525 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
526 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
527 {
528 printf("UtopiaOpen PNL failed\n");
529 return 0;
530 }
531 }
532
533 PanelType stPanelData;
534 stPNL_GetPanelData PNLArgs;
535 memset(&stPanelData, 0, sizeof(PanelType));
536 PNLArgs.pstPNLData = &stPanelData;
537
538 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
539 {
540 printf("Obtain PNL engine fail\n");
541 return 0;
542 }
543 else
544 {
545 return stPanelData.m_ucPanelHSyncBackPorch;
546 }
547 }
548
_getPanelVSyncBackPorch(const PNL_DeviceId * pPNL_DeviceId)549 static MS_U8 _getPanelVSyncBackPorch(const PNL_DeviceId *pPNL_DeviceId)
550 {
551 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
552 )
553 {
554 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
555 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
556 {
557 printf("UtopiaOpen PNL failed\n");
558 return 0;
559 }
560 }
561
562 PanelType stPanelData;
563 stPNL_GetPanelData PNLArgs;
564 memset(&stPanelData, 0, sizeof(PanelType));
565 PNLArgs.pstPNLData = &stPanelData;
566
567 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
568 {
569 printf("Obtain PNL engine fail\n");
570 return 0;
571 }
572 else
573 {
574 return stPanelData.m_ucPanelVBackPorch;
575 }
576 }
577
_getPanelOnTiming(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_POWER_TIMING_SEQ seq)578 static MS_U16 _getPanelOnTiming(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_POWER_TIMING_SEQ seq)
579 {
580 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
581 {
582 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
583 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
584 {
585 printf("UtopiaOpen PNL failed\n");
586 return 0;
587 }
588 }
589
590 stPNL_GetPanelOnTiming PNLArgs;
591 PNLArgs.seq = (APIPNL_POWER_TIMING_SEQ)seq;
592 PNLArgs.u16Return = 0;
593 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELONTIMING, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
594 {
595 printf("Obtain PNL engine fail\n");
596 return 0;
597 }
598 else
599 {
600 return PNLArgs.u16Return;
601 }
602 }
603
_getPanelOffTiming(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_POWER_TIMING_SEQ seq)604 static MS_U16 _getPanelOffTiming(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_POWER_TIMING_SEQ seq)
605 {
606 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
607 {
608 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
609 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
610 {
611 printf("UtopiaOpen PNL failed\n");
612 return 0;
613 }
614 }
615
616 stPNL_GetPanelOffTiming PNLArgs;
617 PNLArgs.seq = (APIPNL_POWER_TIMING_SEQ)seq;
618 PNLArgs.u16Return = 0;
619 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELOFFTIMING, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
620 {
621 printf("Obtain PNL engine fail\n");
622 return 0;
623 }
624 else
625 {
626 return PNLArgs.u16Return;
627 }
628 }
629
_getPanelDimCTRL(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_DIMMING_CTRL dim_type)630 static MS_U8 _getPanelDimCTRL(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_DIMMING_CTRL dim_type)
631 {
632 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
633 {
634 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
635 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
636 {
637 printf("UtopiaOpen PNL failed\n");
638 return 0;
639 }
640 }
641
642 stPNL_GetPanelDimCtrl PNLArgs;
643 PNLArgs.dim_type = (APIPNL_DIMMING_CTRL)dim_type;
644 PNLArgs.u8Return = 0;
645 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDIMCTRL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
646 {
647 printf("Obtain PNL engine fail\n");
648 return 0;
649 }
650 else
651 {
652 return PNLArgs.u8Return;
653 }
654 }
655
_getPanelName(const PNL_DeviceId * pPNL_DeviceId)656 static const char* _getPanelName(const PNL_DeviceId *pPNL_DeviceId)
657 {
658 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
659 )
660 {
661 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
662 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
663 {
664 printf("UtopiaOpen PNL failed\n");
665 return NULL;
666 }
667 }
668
669 PanelType stPanelData;
670 stPNL_GetPanelData PNLArgs;
671 memset(&stPanelData, 0, sizeof(PanelType));
672 PNLArgs.pstPNLData = &stPanelData;
673
674 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
675 {
676 printf("Obtain PNL engine fail\n");
677 return NULL;
678 }
679 else
680 {
681 return stPanelData.m_pPanelName;
682 }
683 }
684
_getPanel_ARC(const PNL_DeviceId * pPNL_DeviceId)685 static PNL_EX_ASPECT_RATIO _getPanel_ARC(const PNL_DeviceId *pPNL_DeviceId)
686 {
687 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
688 )
689 {
690 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
691 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
692 {
693 printf("UtopiaOpen PNL failed\n");
694 return E_PNL_EX_ASPECT_RATIO_4_3;
695 }
696 }
697
698 PanelType stPanelData;
699 stPNL_GetPanelData PNLArgs;
700 memset(&stPanelData, 0, sizeof(PanelType));
701 PNLArgs.pstPNLData = &stPanelData;
702
703 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
704 {
705 printf("Obtain PNL engine fail\n");
706 return E_PNL_EX_ASPECT_RATIO_4_3;
707 }
708 else
709 {
710 return ((PNL_EX_ASPECT_RATIO)stPanelData.m_ucPanelAspectRatio);
711 }
712 }
713
_getGammaTbl(const PNL_DeviceId * pPNL_DeviceId)714 static MS_U8** _getGammaTbl(const PNL_DeviceId *pPNL_DeviceId)
715 {
716 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
717 {
718 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
719 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
720 {
721 printf("UtopiaOpen PNL failed\n");
722 return NULL;
723 }
724 }
725
726 stPNL_GetAllGammaTbl PNLArgs;
727 PNLArgs.ppu8Return = NULL;
728 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETALLGAMMATBL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
729 {
730 printf("Obtain PNL engine fail\n");
731 return NULL;
732 }
733 else
734 {
735 return PNLArgs.ppu8Return;
736 }
737 }
738
_getOutTimingMode(const PNL_DeviceId * pPNL_DeviceId)739 static PNL_EX_OUT_TIMING_MODE _getOutTimingMode(const PNL_DeviceId *pPNL_DeviceId)
740 {
741 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL
742 )
743 {
744 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
745 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
746 {
747 printf("UtopiaOpen PNL failed\n");
748 return E_PNL_EX_CHG_DCLK;
749 }
750 }
751
752 PanelType stPanelData;
753 stPNL_GetPanelData PNLArgs;
754 memset(&stPanelData, 0, sizeof(PanelType));
755 PNLArgs.pstPNLData = &stPanelData;
756
757 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETPANELDATA, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
758 {
759 printf("Obtain PNL engine fail\n");
760 return E_PNL_EX_CHG_DCLK;
761 }
762 else
763 {
764 return ((PNL_EX_OUT_TIMING_MODE)stPanelData.m_ucOutTimingMode);
765 }
766 }
767
_EnablePanel(const PNL_DeviceId * pPNL_DeviceId,MS_BOOL bPanelOn)768 static MS_BOOL _EnablePanel(const PNL_DeviceId *pPNL_DeviceId, MS_BOOL bPanelOn)
769 {
770 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
771 {
772 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
773 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
774 {
775 printf("UtopiaOpen PNL failed\n");
776 return FALSE;
777 }
778 }
779
780 stPNL_EnablePanel PNLArgs;
781 PNLArgs.bPanelOn = bPanelOn;
782 PNLArgs.bReturn = FALSE;
783 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_ENABLEPANEL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
784 {
785 printf("Obtain PNL engine fail\n");
786 return FALSE;
787 }
788 else
789 {
790 return PNLArgs.bReturn;
791 }
792 }
793
_SetGammaTbl(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_GAMMA_TYPE eGammaType,MS_U8 * pu8GammaTab[3],PNL_EX_GAMMA_MAPPEING_MODE Gamma_Map_Mode)794 static MS_BOOL _SetGammaTbl(const PNL_DeviceId *pPNL_DeviceId,
795 PNL_EX_GAMMA_TYPE eGammaType,
796 MS_U8* pu8GammaTab[3],
797 PNL_EX_GAMMA_MAPPEING_MODE Gamma_Map_Mode)
798 {
799 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
800 {
801 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
802 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
803 {
804 printf("UtopiaOpen PNL failed\n");
805 return FALSE;
806 }
807 }
808
809 stPNL_SetGammaTbl PNLArgs;
810 PNLArgs.eGammaType = (APIPNL_GAMMA_TYPE)eGammaType;
811 PNLArgs.Gamma_Map_Mode = (APIPNL_GAMMA_MAPPEING_MODE)Gamma_Map_Mode;
812 PNLArgs.bReturn = FALSE;
813 PNLArgs.pu8GammaTab[0] = pu8GammaTab[0];
814 PNLArgs.pu8GammaTab[1] = pu8GammaTab[1];
815 PNLArgs.pu8GammaTab[2] = pu8GammaTab[2];
816 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_SETGAMMATBL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
817 {
818 printf("Obtain PNL engine fail\n");
819 return FALSE;
820 }
821 else
822 {
823 return PNLArgs.bReturn;
824 }
825 }
826
_GetGammaTbl(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_GAMMA_TYPE eGammaType,MS_U8 * pu8GammaTab[3],PNL_EX_GAMMA_MAPPEING_MODE Gamma_Map_Mode)827 static MS_BOOL _GetGammaTbl( const PNL_DeviceId *pPNL_DeviceId,
828 PNL_EX_GAMMA_TYPE eGammaType,
829 MS_U8* pu8GammaTab[3],
830 PNL_EX_GAMMA_MAPPEING_MODE Gamma_Map_Mode)
831 {
832 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
833 {
834 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
835 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
836 {
837 printf("UtopiaOpen PNL failed\n");
838 return FALSE;
839 }
840 }
841
842 stPNL_GetGammaTbl PNLArgs;
843 PNLArgs.eGammaType = (APIPNL_GAMMA_TYPE)eGammaType;
844 PNLArgs.Gamma_Map_Mode = (APIPNL_GAMMA_MAPPEING_MODE)Gamma_Map_Mode;
845 PNLArgs.bReturn = FALSE;
846 PNLArgs.pu8GammaTab[0] = pu8GammaTab[0];
847 PNLArgs.pu8GammaTab[1] = pu8GammaTab[1];
848 PNLArgs.pu8GammaTab[2] = pu8GammaTab[2];
849 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETGAMMATBL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
850 {
851 printf("Obtain PNL engine fail\n");
852 return FALSE;
853 }
854 else
855 {
856 return PNLArgs.bReturn;
857 }
858 }
859
_SetGammaValue(const PNL_DeviceId * pPNL_DeviceId,MS_U8 u8Channel,MS_U16 u16Offset,MS_U16 u16GammaValue)860 static MS_BOOL _SetGammaValue(const PNL_DeviceId *pPNL_DeviceId, MS_U8 u8Channel, MS_U16 u16Offset, MS_U16 u16GammaValue)
861 {
862 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
863 {
864 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
865 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
866 {
867 printf("UtopiaOpen PNL failed\n");
868 return FALSE;
869 }
870 }
871
872 stPNL_SetGammaValue PNLArgs;
873 PNLArgs.u8Channel = u8Channel;
874 PNLArgs.u16Offset = u16Offset;
875 PNLArgs.u16GammaValue = u16GammaValue;
876 PNLArgs.bReturn = FALSE;
877 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_SETGAMMAVALUE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
878 {
879 printf("Obtain PNL engine fail\n");
880 return FALSE;
881 }
882 else
883 {
884 return PNLArgs.bReturn;
885 }
886 }
887
888 XC_PNL_EX_OBJ g_IPanelEx =
889 {
890 //
891 // Data
892 //
893 .Name = _getPanelName,
894 .HStart = _getPanelHstart,
895 .VStart = _getPanelVstart,
896 .Width = _getPanelWidth,
897 .Height = _getPanelHeight,
898 .HTotal = _getPanelhtotal,
899 .VTotal = _getPanelVtotal,
900 .HSynWidth = _getPanelHSyncWidth,
901 .HSynBackPorch = _getPanelHSyncBackPorch,
902 .VSynBackPorch = _getPanelVSyncBackPorch,
903 .DefaultVFreq = _getPanelDefVFreq,
904 .LPLL_Mode = _getPanel_LPLL_Mode, /* 0: single, 1: dual mode */
905 .LPLL_Type = _getPanel_LPLL_Type,
906 .AspectRatio = _getPanel_ARC,
907 .MinSET = _getPanelMinSET,
908 .MaxSET = _getPanelMaxSET,
909 .OutTimingMode = _getOutTimingMode,
910 // Manipulation
911 //
912 .SetSSC = _SetSSC,
913 .Enable = _EnablePanel,
914 .SetGammaTbl = _SetGammaTbl,
915 .GammaTab = _getGammaTbl,
916 .Dump = _MApi_XC_DumpPanelData,
917 .DimCtrl = _getPanelDimCTRL,
918 .OnTiming = _getPanelOnTiming,
919 .OffTiming = _getPanelOffTiming,
920 //
921 // Custimized methods, can be provided by clinets.
922 //
923 .TurnBackLightOn = _EmptyMethod,
924 .SetGammaValue = _SetGammaValue,
925 .GetGammaTbl = _GetGammaTbl,
926 };
927
928 /******************************************************************************/
929 // Public function
930 //
931 /******************************************************************************/
932
933
934 ////////////////////////////////////////////////////////////////////////////////
935 /// @brief Get the version of apiPNL lib, (without Mutex protect)
936 /// @param[out] ppVersion \b output apiPNL lib version
937 /// @return @ref APIPNL_Result
938 ////////////////////////////////////////////////////////////////////////////////
MApi_PNL_EX_GetLibVer(const MSIF_Version ** ppVersion)939 PNL_EX_Result MApi_PNL_EX_GetLibVer(const MSIF_Version **ppVersion)
940 {
941 if(pu32PNLInst == NULL)
942 {
943 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
944 {
945 printf("UtopiaOpen PNL failed\n");
946 return E_PNL_EX_FAIL;
947 }
948 }
949
950 stPNL_GetLibVer PNLArgs;
951 PNLArgs.ppVersion = ppVersion;
952 PNLArgs.eResult = E_APIPNL_FAIL;
953 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_GETLIBVER, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
954 {
955 printf("Obtain PNL engine fail\n");
956 return E_PNL_EX_FAIL;
957 }
958 else
959 {
960 return (PNL_EX_Result)PNLArgs.eResult;
961 }
962 }
963
MApi_PNL_EX_GetInfo(const PNL_DeviceId * pPNL_DeviceId)964 const PNL_EX_ApiInfo * MApi_PNL_EX_GetInfo(const PNL_DeviceId *pPNL_DeviceId) ///< Get info from driver
965 {
966 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
967 {
968 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
969 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
970 {
971 printf("UtopiaOpen PNL failed\n");
972 return NULL;
973 }
974 }
975
976 stPNL_GetInfo PNLArgs;
977 PNLArgs.pApiInfo = NULL;
978 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETINFO, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
979 {
980 printf("Obtain PNL engine fail\n");
981 return NULL;
982 }
983 else
984 {
985 return (PNL_EX_ApiInfo*)PNLArgs.pApiInfo;
986 }
987 }
988 ////////////////////////////////////////////////////////////////////////////////
989 /// @brief Extended API of getting current panel status
990 /// @param[in] pPnlExtStatus @ref PNL_ApiExtStatus
991 ////////////////////////////////////////////////////////////////////////////////
MApi_PNL_EX_GetStatusEx(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_ApiExtStatus * pPnlExtStatus)992 MS_BOOL MApi_PNL_EX_GetStatusEx(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_ApiExtStatus *pPnlExtStatus)
993 {
994 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
995 {
996 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
997 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
998 {
999 printf("UtopiaOpen PNL failed\n");
1000 return FALSE;
1001 }
1002 }
1003
1004 stPNL_GetStatusEx PNLArgs;
1005 PNLArgs.pPnlExtStatus = (PNL_ApiExtStatus*)pPnlExtStatus;
1006 PNLArgs.bReturn = FALSE;
1007 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETSTATUSEX, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1008 {
1009 printf("Obtain PNL engine fail\n");
1010 return FALSE;
1011 }
1012 else
1013 {
1014 return PNLArgs.bReturn;
1015 }
1016 }
1017
1018 ////////////////////////////////////////////////////////////////////////////////
1019 /// @brief Get current panel status
1020 /// @param[in] pPnlStatus @ref PNL_ApiStatus
1021 ////////////////////////////////////////////////////////////////////////////////
MApi_PNL_EX_GetStatus(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_ApiStatus * pPnlStatus)1022 MS_BOOL MApi_PNL_EX_GetStatus(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_ApiStatus *pPnlStatus)
1023 {
1024 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1025 {
1026 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1027 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1028 {
1029 printf("UtopiaOpen PNL failed\n");
1030 return FALSE;
1031 }
1032 }
1033
1034 stPNL_GetStatus PNLArgs;
1035 PNLArgs.pPnlStatus = (PNL_ApiStatus*)pPnlStatus;
1036 PNLArgs.bReturn = FALSE;
1037 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETSTATUS, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1038 {
1039 printf("Obtain PNL engine fail\n");
1040 return FALSE;
1041 }
1042 else
1043 {
1044 return PNLArgs.bReturn;
1045 }
1046 }
1047
1048 /// Set debug level (without Mutex protect)
MApi_PNL_EX_SetDbgLevel(MS_U16 u16DbgSwitch)1049 MS_BOOL MApi_PNL_EX_SetDbgLevel(MS_U16 u16DbgSwitch)
1050 {
1051 if(pu32PNLInst == NULL)
1052 {
1053 if(UtopiaOpen(MODULE_PNL, &pu32PNLInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1054 {
1055 printf("UtopiaOpen PNL failed\n");
1056 return FALSE;
1057 }
1058 }
1059
1060 stPNL_SetDbgLevel PNLArgs;
1061 PNLArgs.u16DbgSwitch = u16DbgSwitch;
1062 PNLArgs.bReturn = FALSE;
1063 if(UtopiaIoctl(pu32PNLInst, E_PNL_CMD_SETDBGLEVEL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1064 {
1065 printf("Obtain PNL engine fail\n");
1066 return FALSE;
1067 }
1068 else
1069 {
1070 return PNLArgs.bReturn;
1071 }
1072 }
1073
MApi_PNL_EX_IOMapBaseInit(const PNL_DeviceId * pPNL_DeviceId)1074 MS_BOOL MApi_PNL_EX_IOMapBaseInit(const PNL_DeviceId *pPNL_DeviceId)
1075 {
1076 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1077 {
1078 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1079 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1080 {
1081 printf("UtopiaOpen PNL failed\n");
1082 return FALSE;
1083 }
1084 }
1085
1086 stPNL_IOMapBaseInit PNLArgs;
1087 PNLArgs.bReturn = FALSE;
1088 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_IOMAPBASEINIT, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1089 {
1090 printf("Obtain PNL engine fail\n");
1091 return FALSE;
1092 }
1093 else
1094 {
1095 return PNLArgs.bReturn;
1096 }
1097 }
1098
1099 //////////////////////////////////////////////////////////////////////
1100 /**
1101 *
1102 * @brief Give some options for panel init.
1103 *
1104 * @param[in] pSelPanelType a given panel type choosed by user.
1105 *
1106 */
MApi_PNL_EX_PreInit(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_PREINIT_OPTIONS eInitParam)1107 MS_BOOL MApi_PNL_EX_PreInit(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_PREINIT_OPTIONS eInitParam)
1108 {
1109 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1110 {
1111 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1112 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1113 {
1114 printf("UtopiaOpen PNL failed\n");
1115 return FALSE;
1116 }
1117 }
1118
1119 stPNL_PreInit PNLArgs;
1120 PNLArgs.eInitParam = (E_PNL_PREINIT_OPTIONS)eInitParam;
1121 PNLArgs.bReturn = FALSE;
1122 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_PREINIT, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1123 {
1124 printf("Obtain PNL engine fail\n");
1125 return FALSE;
1126 }
1127 else
1128 {
1129 return PNLArgs.bReturn;
1130 }
1131 }
1132
1133 //////////////////////////////////////////////////////////////////////
1134 /**
1135 *
1136 * @brief Initialize the global panel object with a given PanelType
1137 *
1138 * @param[in] pSelPanelType a given panel type choosed by user.
1139 *
1140 */
MApi_PNL_EX_Init(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_PanelType * pSelPanelType)1141 MS_BOOL MApi_PNL_EX_Init(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_PanelType *pSelPanelType/* <in > */)
1142 {
1143 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1144 {
1145 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1146 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1147 {
1148 printf("UtopiaOpen PNL failed\n");
1149 return FALSE;
1150 }
1151 }
1152
1153 stPNL_Init PNLArgs;
1154 PNLArgs.pSelPanelType = (PanelType*)pSelPanelType;
1155 PNLArgs.bReturn = FALSE;
1156 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_INIT, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1157 {
1158 printf("Obtain PNL engine fail\n");
1159 return FALSE;
1160 }
1161 else
1162 {
1163 return PNLArgs.bReturn;
1164 }
1165 }
1166
1167 //////////////////////////////////////////////////////////////////////
1168 //
1169 //
1170 //////////////////////////////////////////////////////////////////////
MApi_PNL_EX_Init_Ex(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_PanelType * pSelPanelType,MSIF_Version LIBVER)1171 MS_BOOL MApi_PNL_EX_Init_Ex(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_PanelType *pSelPanelType/* <in > */, MSIF_Version LIBVER)
1172 {
1173 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1174 {
1175 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1176 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1177 {
1178 printf("UtopiaOpen PNL failed\n");
1179 return FALSE;
1180 }
1181 }
1182
1183 stPNL_Init_Ex PNLArgs;
1184 PNLArgs.pSelPanelType = (PanelType*)pSelPanelType;
1185 PNLArgs.LIBVER = LIBVER;
1186 PNLArgs.bReturn = FALSE;
1187 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_INIT_EX, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1188 {
1189 printf("Obtain PNL engine fail\n");
1190 return FALSE;
1191 }
1192 else
1193 {
1194 return PNLArgs.bReturn;
1195 }
1196 }
1197
MApi_PNL_EX_GetConfig(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_PanelType * pSelPanelType)1198 PNL_EX_Result MApi_PNL_EX_GetConfig(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_PanelType *pSelPanelType)
1199 {
1200 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1201 {
1202 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1203 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1204 {
1205 printf("UtopiaOpen PNL failed\n");
1206 return E_PNL_EX_FAIL;
1207 }
1208 }
1209 stPNL_GetConfig PNLArgs;
1210 PNLArgs.pSelPanelType = (PanelType*)pSelPanelType;
1211 PNLArgs.eReturn = E_APIPNL_FAIL;
1212
1213 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GET_CONFIG, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1214 {
1215 printf("Obtain PNL engine fail\n");
1216 return E_PNL_EX_FAIL;
1217 }
1218 else
1219 {
1220 return (PNL_EX_Result)PNLArgs.eReturn;
1221 }
1222 }
1223
MApi_PNL_EX_Control_Out_Swing(const PNL_DeviceId * pPNL_DeviceId,MS_U16 u16Swing_Level)1224 MS_BOOL MApi_PNL_EX_Control_Out_Swing(const PNL_DeviceId *pPNL_DeviceId, MS_U16 u16Swing_Level)
1225 {
1226 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1227 {
1228 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1229 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1230 {
1231 printf("UtopiaOpen PNL failed\n");
1232 return FALSE;
1233 }
1234 }
1235
1236 stPNL_Control_Out_Swing PNLArgs;
1237 PNLArgs.u16Swing_Level = u16Swing_Level;
1238 PNLArgs.bReturn = FALSE;
1239 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_CONTROL_OUT_SWING, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1240 {
1241 printf("Obtain PNL engine fail\n");
1242 return FALSE;
1243 }
1244 else
1245 {
1246 return PNLArgs.bReturn;
1247 }
1248 }
1249
MApi_PNL_EX_ForceSetPanelDCLK(const PNL_DeviceId * pPNL_DeviceId,MS_U16 u16PanelDCLK,MS_BOOL bSetDCLKEnable)1250 MS_BOOL MApi_PNL_EX_ForceSetPanelDCLK(const PNL_DeviceId *pPNL_DeviceId, MS_U16 u16PanelDCLK ,MS_BOOL bSetDCLKEnable )
1251 {
1252 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1253 {
1254 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1255 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1256 {
1257 printf("UtopiaOpen PNL failed\n");
1258 return FALSE;
1259 }
1260 }
1261
1262 stPNL_ForceSetPanelDCLK PNLArgs;
1263 PNLArgs.u16PanelDCLK = u16PanelDCLK;
1264 PNLArgs.bSetDCLKEnable = bSetDCLKEnable;
1265 PNLArgs.bReturn = FALSE;
1266 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_FORCESETPANELDCLK, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1267 {
1268 printf("Obtain PNL engine fail\n");
1269 return FALSE;
1270 }
1271 else
1272 {
1273 return PNLArgs.bReturn;
1274 }
1275 }
1276
MApi_PNL_EX_ForceSetPanelHStart(const PNL_DeviceId * pPNL_DeviceId,MS_U16 u16PanelHStart,MS_BOOL bSetHStartEnable)1277 MS_BOOL MApi_PNL_EX_ForceSetPanelHStart(const PNL_DeviceId *pPNL_DeviceId, MS_U16 u16PanelHStart ,MS_BOOL bSetHStartEnable)
1278 {
1279 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1280 {
1281 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1282 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1283 {
1284 printf("UtopiaOpen PNL failed\n");
1285 return FALSE;
1286 }
1287 }
1288
1289 stPNL_ForceSetPanelHStart PNLArgs;
1290 PNLArgs.u16PanelHStart = u16PanelHStart;
1291 PNLArgs.bSetHStartEnable = bSetHStartEnable;
1292 PNLArgs.bReturn = FALSE;
1293 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_FORCESETPANELHSTART, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1294 {
1295 printf("Obtain PNL engine fail\n");
1296 return FALSE;
1297 }
1298 else
1299 {
1300 return PNLArgs.bReturn;
1301 }
1302 }
1303
MApi_PNL_EX_SetOutput(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_OUTPUT_MODE eOutputMode)1304 void MApi_PNL_EX_SetOutput(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_OUTPUT_MODE eOutputMode)
1305 {
1306 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1307 {
1308 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1309 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1310 {
1311 printf("UtopiaOpen PNL failed\n");
1312 return;
1313 }
1314 }
1315
1316 stPNL_SetOutput PNLArgs;
1317 PNLArgs.eOutputMode = (APIPNL_OUTPUT_MODE)eOutputMode;
1318 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_SETOUTPUT, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1319 {
1320 printf("Obtain PNL engine fail\n");
1321 }
1322 }
1323
MApi_PNL_EX_ChangePanelType(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_PanelType * pSelPanelType)1324 MS_BOOL MApi_PNL_EX_ChangePanelType(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_PanelType *pSelPanelType)
1325 {
1326 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1327 {
1328 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1329 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1330 {
1331 printf("UtopiaOpen PNL failed\n");
1332 return FALSE;
1333 }
1334 }
1335
1336 stPNL_ChangePanelType PNLArgs;
1337 PNLArgs.pSelPanelType = (PanelType*)pSelPanelType;
1338 PNLArgs.bReturn = FALSE;
1339 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_CHANGEPANELTYPE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1340 {
1341 printf("Obtain PNL engine fail\n");
1342 return FALSE;
1343 }
1344 else
1345 {
1346 return PNLArgs.bReturn;
1347 }
1348 }
1349
MApi_PNL_EX_TCONMAP_DumpTable(const PNL_DeviceId * pPNL_DeviceId,MS_U8 * pTCONTable,MS_U8 u8Tcontype)1350 MS_BOOL MApi_PNL_EX_TCONMAP_DumpTable(const PNL_DeviceId *pPNL_DeviceId, MS_U8 *pTCONTable, MS_U8 u8Tcontype)
1351 {
1352 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1353 {
1354 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1355 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1356 {
1357 printf("UtopiaOpen PNL failed\n");
1358 return FALSE;
1359 }
1360 }
1361
1362 stPNL_TCONMAP_DumpTable PNLArgs;
1363 PNLArgs.pTCONTable = pTCONTable;
1364 PNLArgs.u8Tcontype = u8Tcontype;
1365 PNLArgs.bReturn = FALSE;
1366 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_TCONMAP_DUMPTABLE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1367 {
1368 printf("Obtain PNL engine fail\n");
1369 return FALSE;
1370 }
1371 else
1372 {
1373 return PNLArgs.bReturn;
1374 }
1375 }
1376
MApi_PNL_EX_TCONMAP_Power_Sequence(const PNL_DeviceId * pPNL_DeviceId,MS_U8 * pTCONTable,MS_BOOL bEnable)1377 MS_BOOL MApi_PNL_EX_TCONMAP_Power_Sequence(const PNL_DeviceId *pPNL_DeviceId, MS_U8 *pTCONTable, MS_BOOL bEnable)
1378 {
1379 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1380 {
1381 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1382 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1383 {
1384 printf("UtopiaOpen PNL failed\n");
1385 return FALSE;
1386 }
1387 }
1388
1389 stPNL_TCONMAP_Power_Sequence PNLArgs;
1390 PNLArgs.pTCONTable = pTCONTable;
1391 PNLArgs.bEnable = bEnable;
1392 PNLArgs.bReturn = FALSE;
1393 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_TCONMAP_POWER_SEQUENCE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1394 {
1395 printf("Obtain PNL engine fail\n");
1396 return FALSE;
1397 }
1398 else
1399 {
1400 return PNLArgs.bReturn;
1401 }
1402 }
1403
MApi_PNL_EX_SetOutputPattern(const PNL_DeviceId * pPNL_DeviceId,MS_BOOL bEnable,MS_U16 u16Red,MS_U16 u16Green,MS_U16 u16Blue)1404 void MApi_PNL_EX_SetOutputPattern(const PNL_DeviceId *pPNL_DeviceId, MS_BOOL bEnable, MS_U16 u16Red , MS_U16 u16Green, MS_U16 u16Blue)
1405 {
1406 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1407 {
1408 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1409 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1410 {
1411 printf("UtopiaOpen PNL failed\n");
1412 return;
1413 }
1414 }
1415
1416 stPNL_SetOutputPattern PNLArgs;
1417 PNLArgs.bEnable = bEnable;
1418 PNLArgs.u16Red = u16Red;
1419 PNLArgs.u16Green = u16Green;
1420 PNLArgs.u16Blue = u16Blue;
1421 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_SET_OUTPUT_PATTERN, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1422 {
1423 printf("Obtain PNL engine fail\n");
1424 }
1425 }
1426 //-------------------------------------------------------------------------------------------------
1427 /// Setup TCON Count Reset ON/OFF
1428 /// @param bEnable \b IN: Enable or Disable
1429 //-------------------------------------------------------------------------------------------------
MApi_PNL_EX_TCON_Count_Reset(const PNL_DeviceId * pPNL_DeviceId,MS_BOOL bEnable)1430 void MApi_PNL_EX_TCON_Count_Reset ( const PNL_DeviceId *pPNL_DeviceId, MS_BOOL bEnable )
1431 {
1432 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1433 {
1434 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1435 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1436 {
1437 printf("UtopiaOpen PNL failed\n");
1438 return;
1439 }
1440 }
1441
1442 stPNL_TCON_Count_Reset PNLArgs;
1443 PNLArgs.bEnable = bEnable;
1444 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_TCON_COUNT_RESET, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1445 {
1446 printf("Obtain PNL engine fail\n");
1447 }
1448 }
1449
MApi_PNL_EX_TCON_Init(const PNL_DeviceId * pPNL_DeviceId)1450 void MApi_PNL_EX_TCON_Init( const PNL_DeviceId *pPNL_DeviceId )
1451 {
1452 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1453 {
1454 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1455 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1456 {
1457 printf("UtopiaOpen PNL failed\n");
1458 return;
1459 }
1460 }
1461
1462 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_TCON_INIT, NULL) != UTOPIA_STATUS_SUCCESS)
1463 {
1464 printf("Obtain PNL engine fail\n");
1465 }
1466 }
1467
MApi_PNL_EX_GetDstInfo(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_DST_DispInfo * pDstInfo,MS_U32 u32SizeofDstInfo)1468 MS_BOOL MApi_PNL_EX_GetDstInfo(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_DST_DispInfo *pDstInfo, MS_U32 u32SizeofDstInfo)
1469 {
1470 if (_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1471 {
1472 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1473 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1474 {
1475 printf("UtopiaOpen PNL failed\n");
1476 return FALSE;
1477 }
1478 }
1479
1480 stPNL_GetDstInfo PNLArgs;
1481 PNLArgs.pDstInfo = (MS_PNL_DST_DispInfo*)pDstInfo;
1482 PNLArgs.u32SizeofDstInfo = u32SizeofDstInfo;
1483 PNLArgs.bReturn = FALSE;
1484 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GETDSTINFO, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1485 {
1486 printf("Obtain PNL engine fail\n");
1487 return FALSE;
1488 }
1489 else
1490 {
1491 return PNLArgs.bReturn;
1492 }
1493 }
1494
1495
MApi_PNL_EX_Mod_Calibration_Setting(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_ModCaliInfo * pstModCaliInfo)1496 void MApi_PNL_EX_Mod_Calibration_Setting(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_ModCaliInfo *pstModCaliInfo)
1497 {
1498 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1499 {
1500 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1501 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1502 {
1503 printf("UtopiaOpen PNL failed\n");
1504 return;
1505 }
1506 }
1507
1508 if(pstModCaliInfo == NULL)
1509 {
1510 printf("MOD Calibration config setting is NULL\n");
1511 return;
1512 }
1513
1514 stPNL_Mod_Calibration_Setting PNLArgs;
1515 PNLArgs.pstModCaliInfo = (MS_PNL_ModCaliInfo*)pstModCaliInfo;
1516 PNLArgs.bReturn = FALSE;
1517 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_MOD_CALIBRATION_SETTING, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1518 {
1519 printf("Obtain PNL engine fail\n");
1520 }
1521 }
1522
MApi_PNL_EX_Mod_Do_Calibration(const PNL_DeviceId * pPNL_DeviceId)1523 MS_BOOL MApi_PNL_EX_Mod_Do_Calibration(const PNL_DeviceId *pPNL_DeviceId)
1524 {
1525 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1526 {
1527 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1528 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1529 {
1530 printf("UtopiaOpen PNL failed\n");
1531 return FALSE;
1532 }
1533 }
1534
1535 stPNL_Mod_Do_Calibration PNLArgs;
1536 PNLArgs.bReturn = FALSE;
1537 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_MOD_DO_CALIBRATION, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1538 {
1539 printf("Obtain PNL engine fail\n");
1540 return FALSE;
1541 }
1542 else
1543 {
1544 return PNLArgs.bReturn;
1545 }
1546 }
1547
MApi_PNL_EX_BD_LVDS_Output_Type(const PNL_DeviceId * pPNL_DeviceId,MS_U16 Type)1548 void MApi_PNL_EX_BD_LVDS_Output_Type(const PNL_DeviceId *pPNL_DeviceId, MS_U16 Type)
1549 {
1550 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1551 {
1552 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1553 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1554 {
1555 printf("UtopiaOpen PNL failed\n");
1556 return;
1557 }
1558 }
1559
1560 stPNL_BD_LVDS_Output_Type PNLArgs;
1561 PNLArgs.Type = Type;
1562 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_BD_LVDS_OUTPUT_TYPE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1563 {
1564 printf("Obtain PNL engine fail\n");
1565 }
1566 }
1567
MApi_PNL_EX_SetSSC_En(const PNL_DeviceId * pPNL_DeviceId,MS_BOOL bEnable)1568 int MApi_PNL_EX_SetSSC_En(const PNL_DeviceId *pPNL_DeviceId, MS_BOOL bEnable)
1569 {
1570 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1571 {
1572 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1573 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1574 {
1575 printf("UtopiaOpen PNL failed\n");
1576 return E_PNL_EX_FAIL;
1577 }
1578 }
1579
1580 stPNL_SetSSC_En PNLArgs;
1581 PNLArgs.bEnable = bEnable;
1582 PNLArgs.eReturn = E_APIPNL_FAIL;
1583 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_SETSSC_EN, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1584 {
1585 printf("Obtain PNL engine fail\n");
1586 return E_APIPNL_FAIL;
1587 }
1588 else
1589 {
1590 return PNLArgs.eReturn;
1591 }
1592 }
1593
MApi_PNL_EX_SetSSC_Fmodulation(const PNL_DeviceId * pPNL_DeviceId,MS_U16 u16Fmodulation)1594 int MApi_PNL_EX_SetSSC_Fmodulation(const PNL_DeviceId *pPNL_DeviceId, MS_U16 u16Fmodulation)
1595 {
1596 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1597 {
1598 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1599 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1600 {
1601 printf("UtopiaOpen PNL failed\n");
1602 return E_PNL_EX_FAIL;
1603 }
1604 }
1605
1606 stPNL_SetSSC_Fmodulation PNLArgs;
1607 PNLArgs.u16Fmodulation = u16Fmodulation;
1608 PNLArgs.eReturn = E_APIPNL_FAIL;
1609 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_SETSSC_FMODULATION, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1610 {
1611 printf("Obtain PNL engine fail\n");
1612 return E_APIPNL_FAIL;
1613 }
1614 else
1615 {
1616 return PNLArgs.eReturn;
1617 }
1618 }
1619
MApi_PNL_EX_SetSSC_Rdeviation(const PNL_DeviceId * pPNL_DeviceId,MS_U16 u16Rdeviation)1620 int MApi_PNL_EX_SetSSC_Rdeviation(const PNL_DeviceId *pPNL_DeviceId, MS_U16 u16Rdeviation)
1621 {
1622 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1623 {
1624 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1625 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1626 {
1627 printf("UtopiaOpen PNL failed\n");
1628 return E_PNL_EX_FAIL;
1629 }
1630 }
1631
1632 stPNL_SetSSC_Rdeviation PNLArgs;
1633 PNLArgs.u16Rdeviation = u16Rdeviation;
1634 PNLArgs.eReturn = E_APIPNL_FAIL;
1635 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_SETSSC_RDEVIATION, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1636 {
1637 printf("Obtain PNL engine fail\n");
1638 return E_APIPNL_FAIL;
1639 }
1640 else
1641 {
1642 return PNLArgs.eReturn;
1643 }
1644 }
1645
MApi_PNL_EX_SetLPLLTypeExt(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_LINK_EXT_TYPE eLPLL_TypeExt)1646 void MApi_PNL_EX_SetLPLLTypeExt(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_LINK_EXT_TYPE eLPLL_TypeExt)
1647 {
1648 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1649 {
1650 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1651 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1652 {
1653 printf("UtopiaOpen PNL failed\n");
1654 return;
1655 }
1656 }
1657
1658 stPNL_SetLPLLTypeExt PNLArgs;
1659 PNLArgs.eLPLL_TypeExt = (APIPNL_LINK_EXT_TYPE)eLPLL_TypeExt;
1660 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_SETLPLLTYPEEXT, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1661 {
1662 printf("Obtain PNL engine fail\n");
1663 }
1664 }
1665
MApi_PNL_EX_Init_MISC(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_MISC ePNL_MISC)1666 void MApi_PNL_EX_Init_MISC(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_MISC ePNL_MISC)
1667 {
1668 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1669 {
1670 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1671 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1672 {
1673 printf("UtopiaOpen PNL failed\n");
1674 return;
1675 }
1676 }
1677
1678 stPNL_Init_MISC PNLArgs;
1679 PNLArgs.ePNL_MISC = (APIPNL_MISC)ePNL_MISC;
1680 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_INIT_MISC, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1681 {
1682 printf("Obtain PNL engine fail\n");
1683 }
1684 }
1685
MApi_PNL_EX_MOD_OutputConfig_User(const PNL_DeviceId * pPNL_DeviceId,MS_U32 u32OutputCFG0_7,MS_U32 u32OutputCFG8_15,MS_U32 u32OutputCFG16_21)1686 void MApi_PNL_EX_MOD_OutputConfig_User(const PNL_DeviceId *pPNL_DeviceId, MS_U32 u32OutputCFG0_7, MS_U32 u32OutputCFG8_15, MS_U32 u32OutputCFG16_21)
1687 {
1688 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1689 {
1690 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1691 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1692 {
1693 printf("UtopiaOpen PNL failed\n");
1694 return;
1695 }
1696 }
1697
1698 stPNL_MOD_OutputConfig_User PNLArgs;
1699 PNLArgs.u32OutputCFG0_7 = u32OutputCFG0_7;
1700 PNLArgs.u32OutputCFG8_15 = u32OutputCFG8_15;
1701 PNLArgs.u32OutputCFG16_21 = u32OutputCFG16_21;
1702 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_MOD_OUTPUTCONFIG_USER, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1703 {
1704 printf("Obtain PNL engine fail\n");
1705 }
1706 }
1707
1708 //-------------------------------------------------------------------------------------------------
1709 /// Set Flag to bypass timing change in MApi_PNL_Init()
1710 /// @param bFlag \b IN: TRUE: initialize XC by skipping SW reset; FALSE: initialize XC in normal case
1711 /// @return APIPNL_Result
1712 //-------------------------------------------------------------------------------------------------
MApi_PNL_EX_SkipTimingChange(const PNL_DeviceId * pPNL_DeviceId,MS_BOOL bFlag)1713 PNL_EX_Result MApi_PNL_EX_SkipTimingChange(const PNL_DeviceId *pPNL_DeviceId, MS_BOOL bFlag)
1714 {
1715 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1716 {
1717 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1718 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1719 {
1720 printf("UtopiaOpen PNL failed\n");
1721 return E_PNL_EX_FAIL;
1722 }
1723 }
1724
1725 stPNL_SkipTimingChange PNLArgs;
1726 PNLArgs.bFlag = bFlag;
1727 PNLArgs.eResult = E_APIPNL_FAIL;
1728 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_SKIPTIMINGCHANGE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1729 {
1730 printf("Obtain PNL engine fail\n");
1731 return E_PNL_EX_FAIL;
1732 }
1733 else
1734 {
1735 return (PNL_EX_Result)PNLArgs.eResult;
1736 }
1737 }
1738
MApi_PNL_EX_HWLVDSReservedtoLRFlag(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_HW_LVDSResInfo lvdsresinfo)1739 void MApi_PNL_EX_HWLVDSReservedtoLRFlag(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_HW_LVDSResInfo lvdsresinfo)
1740 {
1741 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1742 {
1743 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1744 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1745 {
1746 printf("UtopiaOpen PNL failed\n");
1747 return;
1748 }
1749 }
1750
1751 stPNL_HWLVDSReservedtoLRFlag PNLArgs;
1752 PNLArgs.lvdsresinfo.u32pair = lvdsresinfo.u32pair;
1753 PNLArgs.lvdsresinfo.u16channel = lvdsresinfo.u16channel;
1754 PNLArgs.lvdsresinfo.bEnable = lvdsresinfo.bEnable;
1755 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_HWLVDSRESERVEDTOLRFLAG, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1756 {
1757 printf("Obtain PNL engine fail\n");
1758 }
1759 }
1760
1761 ////////////////////////////////////////////////////////////////////////
1762 // Turn OD function
1763 ////////////////////////////////////////////////////////////////////////
1764 //-------------------------------------------------------------------------------------------------
1765 /// Initialize OverDrive
1766 /// @param pXC_ODInitData \b IN: the Initialized Data
1767 /// @param u32ODInitDataLen \b IN: the length of the initialized data
1768 /// @return E_APIPNL_OK or E_APIPNL_FAIL
1769 //-------------------------------------------------------------------------------------------------
MApi_PNL_EX_OverDriver_Init(const PNL_DeviceId * pPNL_DeviceId,PNL_EX_OD_INITDATA * pPNL_ODInitData,MS_U32 u32ODInitDataLen)1770 PNL_EX_Result MApi_PNL_EX_OverDriver_Init(const PNL_DeviceId *pPNL_DeviceId, PNL_EX_OD_INITDATA *pPNL_ODInitData, MS_U32 u32ODInitDataLen)
1771 {
1772 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1773 {
1774 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1775 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1776 {
1777 printf("UtopiaOpen PNL failed\n");
1778 return E_PNL_EX_FAIL;
1779 }
1780 }
1781
1782 stPNL_OverDriver_Init PNLArgs;
1783 PNLArgs.pPNL_ODInitData = (MS_PNL_OD_INITDATA*)pPNL_ODInitData;
1784 PNLArgs.u32ODInitDataLen = u32ODInitDataLen;
1785 PNLArgs.eResult = E_APIPNL_FAIL;
1786 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_OVERDRIVER_INIT, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1787 {
1788 printf("Obtain PNL engine fail\n");
1789 return E_PNL_EX_FAIL;
1790 }
1791 else
1792 {
1793 return (PNL_EX_Result)PNLArgs.eResult;
1794 }
1795 }
1796
1797 //-------------------------------------------------------------------------------------------------
1798 /// OverDrive Enable
1799 /// @param bEnable \b IN: TRUE: Enable OverDrive; FALSE: Disable OverDrive
1800 /// @return E_APIPNL_OK or E_APIPNL_FAIL
1801 //-------------------------------------------------------------------------------------------------
MApi_PNL_EX_OverDriver_Enable(const PNL_DeviceId * pPNL_DeviceId,MS_BOOL bEnable)1802 PNL_EX_Result MApi_PNL_EX_OverDriver_Enable(const PNL_DeviceId *pPNL_DeviceId, MS_BOOL bEnable)
1803 {
1804 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1805 {
1806 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1807 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1808 {
1809 printf("UtopiaOpen PNL failed\n");
1810 return E_PNL_EX_FAIL;
1811 }
1812 }
1813
1814 stPNL_OverDriver_Enable PNLArgs;
1815 PNLArgs.bEnable = bEnable;
1816 PNLArgs.eResult = E_APIPNL_FAIL;
1817 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_OVERDRIVER_ENABLE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1818 {
1819 printf("Obtain PNL engine fail\n");
1820 return E_PNL_EX_FAIL;
1821 }
1822 else
1823 {
1824 return (PNL_EX_Result)PNLArgs.eResult;
1825 }
1826 }
1827
1828
MApi_PNL_EX_MOD_PVDD_Power_Setting(const PNL_DeviceId * pPNL_DeviceId,MS_BOOL bIs2p5)1829 void MApi_PNL_EX_MOD_PVDD_Power_Setting(const PNL_DeviceId *pPNL_DeviceId, MS_BOOL bIs2p5)
1830 {
1831 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1832 {
1833 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1834 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1835 {
1836 printf("UtopiaOpen PNL failed\n");
1837 return;
1838 }
1839 }
1840
1841 stPNL_MOD_PVDD_Power_Setting PNLArgs;
1842 PNLArgs.bIs2p5 = bIs2p5;
1843 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_MOD_PVDD_POWER_SETTING, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1844 {
1845 printf("Obtain PNL engine fail\n");
1846 }
1847 }
1848
1849 //-------------------------------------------------------------------------------------------------
1850 ///-obosolte!! use MApi_PNL_Control_Out_Swing instead
1851 //-------------------------------------------------------------------------------------------------
MApi_PNL_EX_SetDiffSwingLevel(const PNL_DeviceId * pPNL_DeviceId,MS_U8 u8Swing_Level)1852 MS_BOOL MApi_PNL_EX_SetDiffSwingLevel(const PNL_DeviceId *pPNL_DeviceId, MS_U8 u8Swing_Level)
1853 {
1854 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1855 {
1856 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1857 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1858 {
1859 printf("UtopiaOpen PNL failed\n");
1860 return FALSE;
1861 }
1862 }
1863
1864 stPNL_SetDiffSwingLevel PNLArgs;
1865 PNLArgs.u8Swing_Level = u8Swing_Level;
1866 PNLArgs.bReturn = FALSE;
1867 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_SETDIFFSWINGLEVEL, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1868 {
1869 printf("Obtain PNL engine fail\n");
1870 return FALSE;
1871 }
1872 else
1873 {
1874 return PNLArgs.bReturn;
1875 }
1876 }
1877
1878 //-------------------------------------------------------------------------------------------------
1879 /// Get real LPLL type from driver
1880 /// @return MS_U8
1881 //-------------------------------------------------------------------------------------------------
MApi_Pnl_EX_Get_LPLL_Type(const PNL_DeviceId * pPNL_DeviceId)1882 MS_U8 MApi_Pnl_EX_Get_LPLL_Type(const PNL_DeviceId *pPNL_DeviceId)
1883 {
1884 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1885 {
1886 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1887 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1888 {
1889 printf("UtopiaOpen PNL failed\n");
1890 return E_PNL_EX_FAIL;
1891 }
1892 }
1893
1894 stPNL_Get_LPLL_Type PNLArgs;
1895 PNLArgs.u8Return = LINK_TTL;
1896 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GET_LPLL_TYPE, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1897 {
1898 printf("Obtain PNL engine fail\n");
1899 return E_PNL_EX_LINK_TTL;
1900 }
1901 else
1902 {
1903 return (PNL_EX_LINK_TYPE)PNLArgs.u8Return;
1904 }
1905 }
1906
1907 //-------------------------------------------------------------------------------------------------
1908 /// Get TCON capability
1909 /// @return MS_BOOL
1910 //-------------------------------------------------------------------------------------------------
MApi_PNL_EX_Get_TCON_Capability(const PNL_DeviceId * pPNL_DeviceId)1911 MS_BOOL MApi_PNL_EX_Get_TCON_Capability(const PNL_DeviceId *pPNL_DeviceId)
1912 {
1913 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1914 {
1915 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1916 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1917 {
1918 printf("UtopiaOpen PNL failed\n");
1919 return FALSE;
1920 }
1921 }
1922
1923 stPNL_Get_TCON_Capability PNLArgs;
1924 PNLArgs.bReturn = FALSE;
1925 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_GET_TCON_CAPABILITY, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1926 {
1927 printf("Obtain PNL engine fail\n");
1928 return FALSE;
1929 }
1930 else
1931 {
1932 return PNLArgs.bReturn;
1933 }
1934 }
1935
1936 //-------------------------------------------------------------------------------------------------
1937 /// Set FRC MOD pair swap
1938 /// @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)
1939 //-------------------------------------------------------------------------------------------------
MApi_PNL_EX_SetPairSwap(const PNL_DeviceId * pPNL_DeviceId,MS_U32 u32Polarity)1940 void MApi_PNL_EX_SetPairSwap(const PNL_DeviceId *pPNL_DeviceId, MS_U32 u32Polarity)
1941 {
1942 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1943 {
1944 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1945 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1946 {
1947 printf("UtopiaOpen PNL failed\n");
1948 return;
1949 }
1950 }
1951
1952 stPNL_SetPairSwap PNLArgs;
1953 PNLArgs.u32Polarity = u32Polarity;
1954 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_SETPAIRSWAP, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1955 {
1956 printf("Obtain PNL engine fail\n");
1957 }
1958 }
1959
1960 //-------------------------------------------------------------------------------------------------
1961 /// Cal Ext LPLL Set by DCLK
1962 /// @param ldHz \b IN: ldHz = Htt*Vtt*Vfreq
1963 //-------------------------------------------------------------------------------------------------
MApi_PNL_EX_CalExtLPLLSETbyDClk(const PNL_DeviceId * pPNL_DeviceId,MS_U32 ldHz)1964 void MApi_PNL_EX_CalExtLPLLSETbyDClk(const PNL_DeviceId *pPNL_DeviceId, MS_U32 ldHz)
1965 {
1966 if(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id) == NULL)
1967 {
1968 MS_U32 u32DevideID = pPNL_DeviceId->u32Id;
1969 if(UtopiaOpen(MODULE_PNL, _PNL_SELECT_INSTANCE_P(pPNL_DeviceId->u32Id), 0, &u32DevideID) != UTOPIA_STATUS_SUCCESS)
1970 {
1971 printf("UtopiaOpen PNL failed\n");
1972 return;
1973 }
1974 }
1975
1976 stPNL_CalExtLPLLSETbyDClk PNLArgs;
1977 PNLArgs.ldHz = ldHz;
1978 if(UtopiaIoctl(_PNL_SELECT_INSTANCE(pPNL_DeviceId->u32Id), E_PNL_CMD_CALEXTLPLLSETBYDCLK, (void*)&PNLArgs) != UTOPIA_STATUS_SUCCESS)
1979 {
1980 printf("Obtain PNL engine fail\n");
1981 }
1982 }
1983
1984 //} // Marked it by coverity_0553
1985
1986 #endif
1987