1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2006-2007 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // (��MStar Confidential Information��) by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94
95 ///////////////////////////////////////////////////////////////////////////////////////////////////
96 ///
97 /// file apiHDMITx.c
98 /// @author MStar Semiconductor,Inc.
99 /// @brief HDMI Tx Api
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102 //-------------------------------------------------------------------------------------------------
103 // Include Files
104 //-------------------------------------------------------------------------------------------------
105
106 #ifndef MSOS_TYPE_LINUX_KERNEL
107 #include <stdlib.h>
108 #include <string.h>
109 #else
110 #include <linux/time.h>
111 #endif /* #include MSOS_TYPE_LINUX_KERNEL */
112
113 #include "MsCommon.h"
114 #include "drvHDMITx.h"
115 #include "apiHDMITx.h"
116
117 //wilson@kano: for U2
118 #include "MsOS.h"
119 #include "utopia.h"
120 #include "utopia_dapi.h"
121 #include "apiHDMITx_v2.h"
122 #include "HDMITX_private.h"
123 #include "MsDevice.h"
124
125
126
127 //-------------------------------------------------------------------------------------------------
128 // Local Defines
129 //-------------------------------------------------------------------------------------------------
130
131 // Mutex & Lock
132 static MS_S32 _s32HDMITX_Mutex = -1;
133
134 #define HDMITX_ENTRY() if(!MsOS_ObtainMutex(_s32HDMITX_Mutex, MSOS_WAIT_FOREVER)) \
135 { \
136 }
137
138 #define HDMITX_RETURN() MsOS_ReleaseMutex(_s32HDMITX_Mutex);
139
140 //-------------------------------------------------------------------------------------------------
141 // Local Structures
142 //-------------------------------------------------------------------------------------------------
143
144
145
146 //-------------------------------------------------------------------------------------------------
147 // Global Variables
148 //-------------------------------------------------------------------------------------------------
149
150 //extern MDrvHDMITX_PARAMETER_LIST gHDMITxInfo;
151 //extern MS_BOOL g_bDisableRegWrite;
152 //extern MS_BOOL g_bDisableTMDSCtrl;
153 //-------------------------------------------------------------------------------------------------
154 // Local Variables
155 //-------------------------------------------------------------------------------------------------
156
157
158
159 //-------------------------------------------------------------------------------------------------
160 // Debug Functions
161 //-------------------------------------------------------------------------------------------------
162
163
164 //-------------------------------------------------------------------------------------------------
165 // Local Functions
166 //-------------------------------------------------------------------------------------------------
167
168
169
170
171
172
173 //-------------------------------------------------------------------------------------------------
174 // Global Functions
175 //-------------------------------------------------------------------------------------------------
176
177
178 //*********************//
179 // DVI / HDMI //
180 //*********************//
181
182 //------------------------------------------------------------------------------
183 /// @brief This routine initial HDMI Tx Module
184 /// @return None
185 //------------------------------------------------------------------------------
MApi_HDMITx_Init_U2(void * pInstance)186 MS_BOOL MApi_HDMITx_Init_U2(void *pInstance)
187 {
188 MS_BOOL bReturn;
189 char word[] = {"_HDMITX_Mutex"};
190
191 if (_s32HDMITX_Mutex == -1)
192 {
193 _s32HDMITX_Mutex = MsOS_CreateMutex(E_MSOS_FIFO, word, MSOS_PROCESS_SHARED);
194 if (_s32HDMITX_Mutex == -1)
195 {
196 (printf("[HDMITX][%06d] create mutex fail\n", __LINE__));
197 return FALSE;
198 }
199 }
200 _HDMITX_SEMAPHORE_ENTRY(pInstance);
201 _HDMITX_GET_VARIABLE();
202 HDMITX_ENTRY();
203
204 bReturn = MDrv_HDMITxHDCPTx_Init(pInstance); //MDrv_HDMITx_Init(pInstance);
205 psHDMITXResPri->bInit = bReturn;
206
207
208 HDMITX_RETURN();
209 _HDMITX_SEMAPHORE_RETURN(pInstance);
210
211 return bReturn;
212 }
213
MApi_HDMITx_Init(void)214 MS_BOOL MApi_HDMITx_Init(void)
215 {
216 if (pu32HDMITXInst == NULL)
217 {
218 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
219 {
220 printf("MApi_HDMITx_Init UtopiaOpen HDMITX failed\n");
221 return FALSE;
222 }
223 }
224 #ifdef UTOPIA_20
225 stHDMITx_Init HDMITXArgs;
226 HDMITXArgs.bReturn = FALSE;
227
228
229
230 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_INIT, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
231 {
232 printf("MApi_HDMITx_Init Obtain HDMITX engine fail\n");
233 return FALSE;
234 }
235 else
236 {
237 return HDMITXArgs.bReturn;
238 }
239 #else
240 return MApi_HDMITx_Init_U2(pu32HDMITXInst);
241 #endif
242 }
243
244
245 //------------------------------------------------------------------------------
246 /// @brief This routine exits HDMI Tx Module
247 /// @return None
248 //------------------------------------------------------------------------------
MApi_HDMITx_Exit_U2(void * pInstance)249 MS_BOOL MApi_HDMITx_Exit_U2(void* pInstance)
250 {
251 _HDMITX_SEMAPHORE_ENTRY(pInstance);
252 _HDMITX_GET_VARIABLE();
253 HDMITX_ENTRY();
254
255 MDrv_HDMITx_Power_OnOff(FALSE);
256 psHDMITXResPri->bInit = FALSE;
257
258 HDMITX_RETURN();
259 _HDMITX_SEMAPHORE_RETURN(pInstance);
260 MsOS_DeleteMutex(_s32HDMITX_Mutex);
261 _s32HDMITX_Mutex = -1;
262
263 return TRUE;
264 }
265
MApi_HDMITx_Exit(void)266 MS_BOOL MApi_HDMITx_Exit(void)
267 {
268 #ifdef UTOPIA_20
269 if (pu32HDMITXInst == NULL)
270 {
271 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
272 {
273 printf("MApi_HDMITx_Exit UtopiaOpen HDMITX failed\n");
274 return FALSE;
275 }
276 }
277
278 stHDMITx_Exit HDMITXArgs;
279 HDMITXArgs.bReturn = FALSE;
280
281 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_EXIT, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
282 {
283 printf("MApi_HDMITx_Exit Obtain HDMITX engine fail\n");
284 return FALSE;
285 }
286 else
287 {
288 return HDMITXArgs.bReturn;
289 }
290 #else
291 return MApi_HDMITx_Exit_U2(pu32HDMITXInst);
292 #endif
293 }
294
295 //------------------------------------------------------------------------------
296 /// @brief This routine turn on/off HDMI Tx Module
297 /// @param[in] state ON/OFF state
298 /// @return None
299 //------------------------------------------------------------------------------
MApi_HDMITx_TurnOnOff_U2(void * pInstance,MS_BOOL state)300 void MApi_HDMITx_TurnOnOff_U2(void *pInstance, MS_BOOL state)
301 {
302 _HDMITX_SEMAPHORE_ENTRY(pInstance);
303 _HDMITX_GET_VARIABLE();
304 HDMITX_ENTRY();
305
306 MDrv_HDMITx_TurnOnOff(pInstance, state);
307
308 HDMITX_RETURN();
309 _HDMITX_SEMAPHORE_RETURN(pInstance);
310 }
311
MApi_HDMITx_TurnOnOff(MS_BOOL state)312 void MApi_HDMITx_TurnOnOff(MS_BOOL state)
313 {
314 #ifdef UTOPIA_20
315 if (pu32HDMITXInst == NULL)
316 {
317 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
318 {
319 printf("MApi_HDMITx_TurnOnOff UtopiaOpen HDMITX failed\n");
320 }
321 }
322
323 stHDMITx_TurnOnOff HDMITXArgs;
324 HDMITXArgs.state = state;
325
326 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_TURNONOFF, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
327 {
328 printf("MApi_HDMITx_TurnOnOff Obtain HDMITX engine fail\n");
329 return;
330 }
331 else
332 {
333 return;
334 }
335 #else
336 MApi_HDMITx_TurnOnOff_U2(pu32HDMITXInst, state);
337 #endif
338 }
339
340 //------------------------------------------------------------------------------
341 /// @brief This routine will set or stop all HDMI packet generation
342 /// @param[in] bflag True: Enable packet gen, False : Disable packet gen
343 /// @return None
344 //------------------------------------------------------------------------------
MApi_HDMITx_EnablePacketGen_U2(void * pInstance,MS_BOOL bflag)345 void MApi_HDMITx_EnablePacketGen_U2(void* pInstance, MS_BOOL bflag)
346 {
347 HDMITX_ENTRY();
348
349 MDrv_HDMITx_EnablePacketGen(bflag);
350
351 HDMITX_RETURN();
352 }
353
MApi_HDMITx_EnablePacketGen(MS_BOOL bflag)354 void MApi_HDMITx_EnablePacketGen(MS_BOOL bflag)
355 {
356 #ifdef UTOPIA_20
357 if (pu32HDMITXInst == NULL)
358 {
359 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
360 {
361 printf("MApi_HDMITx_EnablePacketGen UtopiaOpen HDMITX failed\n");
362 }
363 }
364
365 stHDMITx_EnablePacketGen HDMITXArgs;
366 HDMITXArgs.bflag = bflag;
367
368 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_ENABLEPACKETGEN, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
369 {
370 printf("MApi_HDMITx_EnablePacketGen Obtain HDMITX engine fail\n");
371 return;
372 }
373 else
374 {
375 return;
376 }
377 #else
378 MApi_HDMITx_EnablePacketGen_U2(pu32HDMITXInst, bflag);
379 #endif
380 }
381
382 //------------------------------------------------------------------------------
383 /// @brief This routine config HDMI Tx Module output mode (DVI/HDMI)
384 /// @param[in] mode ON/OFF state
385 /// @return None
386 //------------------------------------------------------------------------------
MApi_HDMITx_SetHDMITxMode_U2(void * pInstance,HDMITX_OUTPUT_MODE mode)387 void MApi_HDMITx_SetHDMITxMode_U2(void* pInstance, HDMITX_OUTPUT_MODE mode)
388 {
389 _HDMITX_SEMAPHORE_ENTRY(pInstance);
390 HDMITX_ENTRY();
391
392 if (MDrv_HDMITx_GetOutputMode(pInstance) & 0x01U) // check HDCP
393 {
394 MDrv_HDMITx_SetHDCPOnOff(pInstance, TRUE);
395 }
396 else
397 {
398 MDrv_HDMITx_SetHDCPOnOff(pInstance, FALSE);
399 }
400
401 switch (mode)
402 {
403 case HDMITX_DVI:
404 MDrv_HDMITx_SetHDMITxMode(pInstance, E_HDMITX_DVI);
405 break;
406
407 case HDMITX_DVI_HDCP:
408 MDrv_HDMITx_SetHDMITxMode(pInstance, E_HDMITX_DVI_HDCP);
409 break;
410
411 case HDMITX_HDMI:
412 MDrv_HDMITx_SetHDMITxMode(pInstance, E_HDMITX_HDMI);
413 break;
414
415 case HDMITX_HDMI_HDCP:
416 MDrv_HDMITx_SetHDMITxMode(pInstance, E_HDMITX_HDMI_HDCP);
417 break;
418
419 default:
420 printf("[HDMITx]: Error output mode: %d\n", mode);
421 return;
422 }
423
424 HDMITX_RETURN();
425 _HDMITX_SEMAPHORE_RETURN(pInstance);
426 }
427
MApi_HDMITx_SetHDMITxMode(HDMITX_OUTPUT_MODE mode)428 void MApi_HDMITx_SetHDMITxMode(HDMITX_OUTPUT_MODE mode)
429 {
430 #ifdef UTOPIA_20
431 if (pu32HDMITXInst == NULL)
432 {
433 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
434 {
435 printf("MApi_HDMITx_SetHDMITxMode UtopiaOpen HDMITX failed\n");
436 }
437 }
438
439 stHDMITx_SetHDMITxMode HDMITXArgs;
440 HDMITXArgs.mode = mode;
441
442 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETHDMITXMODE, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
443 {
444 printf("MApi_HDMITx_SetHDMITxMode Obtain HDMITX engine fail\n");
445 return;
446 }
447 else
448 {
449 return;
450 }
451 #else
452 MApi_HDMITx_SetHDMITxMode_U2(pu32HDMITXInst, mode);
453 #endif
454 }
455
456 //------------------------------------------------------------------------------
457 /// @brief This routine config HDMI Tx Module output mode (DVI/HDMI) and deep color depth
458 /// @param[in] mode ON/OFF state
459 /// @return None
460 //------------------------------------------------------------------------------
MApi_HDMITx_SetHDMITxMode_CD_U2(void * pInstance,HDMITX_OUTPUT_MODE mode,HDMITX_VIDEO_COLORDEPTH_VAL val)461 void MApi_HDMITx_SetHDMITxMode_CD_U2(void* pInstance, HDMITX_OUTPUT_MODE mode, HDMITX_VIDEO_COLORDEPTH_VAL val)
462 {
463 _HDMITX_SEMAPHORE_ENTRY(pInstance);
464 HDMITX_ENTRY();
465
466 MsHDMITX_OUTPUT_MODE enHDMIMode = E_HDMITX_HDMI;
467 MsHDMITX_VIDEO_COLORDEPTH_VAL enDeepColorMode = E_HDMITX_VIDEO_CD_NoID;
468 MS_BOOL bInvalidArg = FALSE;
469
470 switch (mode)
471 {
472 case HDMITX_DVI:
473 enHDMIMode = E_HDMITX_DVI;
474 break;
475
476 case HDMITX_DVI_HDCP:
477 enHDMIMode = E_HDMITX_DVI_HDCP;
478 break;
479
480 case HDMITX_HDMI:
481 enHDMIMode = E_HDMITX_HDMI;
482 break;
483
484 case HDMITX_HDMI_HDCP:
485 enHDMIMode = E_HDMITX_HDMI_HDCP;
486 break;
487
488 default:
489 printf("[HDMITx]: Error output mode: %d\n", mode);
490 bInvalidArg = TRUE;
491 break;
492 }
493
494 switch (val)
495 {
496 case HDMITX_VIDEO_CD_NoID:
497 enDeepColorMode = E_HDMITX_VIDEO_CD_NoID;
498 break;
499
500 case HDMITX_VIDEO_CD_24Bits:
501 enDeepColorMode = E_HDMITX_VIDEO_CD_24Bits;
502 break;
503
504 case HDMITX_VIDEO_CD_30Bits:
505 enDeepColorMode = E_HDMITX_VIDEO_CD_30Bits;
506 break;
507
508 case HDMITX_VIDEO_CD_36Bits:
509 enDeepColorMode = E_HDMITX_VIDEO_CD_36Bits;
510 break;
511
512 case HDMITX_VIDEO_CD_48Bits:
513 enDeepColorMode = E_HDMITX_VIDEO_CD_48Bits;
514 break;
515
516 default:
517 printf("[HDMITx]: Error deep color argument: %d\n", val);
518 bInvalidArg = TRUE;
519 break;
520 }
521
522 if (bInvalidArg == FALSE)
523 {
524 #if 0
525 if ((MDrv_HDMITx_GetColorFormat(pInstance) != E_HDMITX_VIDEO_COLOR_YUV420) &&
526 ((MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_1920x2205p_24Hz) ||
527 (MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_1280x1470p_50Hz) ||
528 (MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_1280x1470p_60Hz) ||
529 (MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_3840x2160p_50Hz) ||
530 (MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_3840x2160p_60Hz) ||
531 (MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_4096x2160p_50Hz) ||
532 (MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_4096x2160p_60Hz)))
533 enDeepColorMode = E_HDMITX_VIDEO_CD_24Bits;
534 #endif
535 MDrv_HDMITx_SetDeepColorMode(pInstance, enDeepColorMode);
536 MDrv_HDMITx_SetHDMITxMode(pInstance, enHDMIMode);
537 }
538
539 HDMITX_RETURN();
540 _HDMITX_SEMAPHORE_RETURN(pInstance);
541
542 #if 0 //this will be done in MDrv_HDMITx_SetHDMITxMode()
543 if (MDrv_HDMITx_GetOutputMode() & 0x01U) // check HDCP
544 {
545 MDrv_HDMITx_SetHDCPOnOff(TRUE);
546 }
547 else
548 {
549 MDrv_HDMITx_SetHDCPOnOff(FALSE);
550 }
551 #endif
552 }
553
MApi_HDMITx_SetHDMITxMode_CD(HDMITX_OUTPUT_MODE mode,HDMITX_VIDEO_COLORDEPTH_VAL val)554 void MApi_HDMITx_SetHDMITxMode_CD(HDMITX_OUTPUT_MODE mode, HDMITX_VIDEO_COLORDEPTH_VAL val)
555 {
556 #ifdef UTOPIA_20
557 if (pu32HDMITXInst == NULL)
558 {
559 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
560 {
561 printf("MApi_HDMITx_SetHDMITxMode_CD UtopiaOpen HDMITX failed\n");
562 }
563 }
564
565 stHDMITx_SetHDMITxMode_CD HDMITXArgs;
566 HDMITXArgs.mode = mode;
567 HDMITXArgs.val = val;
568
569 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETHDMITXMODE_CD, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
570 {
571 printf("MApi_HDMITx_SetHDMITxMode_CD Obtain HDMITX engine fail\n");
572 return;
573 }
574 else
575 {
576 return;
577 }
578 #else
579 MApi_HDMITx_SetHDMITxMode_CD_U2(pu32HDMITXInst, mode, val);
580 #endif
581 }
582
583 //------------------------------------------------------------------------------
584 /// @brief This routine config HDMI Tx Module TMDS signal On/Off
585 /// @param[in] state ON/OFF state
586 /// @return None
587 //------------------------------------------------------------------------------
MApi_HDMITx_SetTMDSOnOff_U2(void * pInstance,MS_BOOL state)588 void MApi_HDMITx_SetTMDSOnOff_U2(void* pInstance, MS_BOOL state)
589 {
590 _HDMITX_SEMAPHORE_ENTRY(pInstance);
591 _HDMITX_GET_VARIABLE();
592 HDMITX_ENTRY();
593
594 MDrv_HDMITx_SetTMDSOnOff(pInstance, state);
595
596 HDMITX_RETURN();
597 _HDMITX_SEMAPHORE_RETURN(pInstance);
598 }
599
MApi_HDMITx_SetTMDSOnOff(MS_BOOL state)600 void MApi_HDMITx_SetTMDSOnOff(MS_BOOL state)
601 {
602 #ifdef UTOPIA_20
603 if (pu32HDMITXInst == NULL)
604 {
605 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
606 {
607 printf("MApi_HDMITx_SetTMDSOnOff UtopiaOpen HDMITX failed\n");
608 }
609 }
610
611 stHDMITx_SetTMDSOnOff HDMITXArgs;
612 HDMITXArgs.state = state;
613
614 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETTMDSONOFF, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
615 {
616 printf("MApi_HDMITx_SetTMDSOnOff Obtain HDMITX engine fail\n");
617 return;
618 }
619 else
620 {
621 return;
622 }
623 #else
624 MApi_HDMITx_SetTMDSOnOff_U2(pu32HDMITXInst, state);
625 #endif
626 }
627
628 //------------------------------------------------------------------------------
629 /// @brief This routine disable HDMI Tx TMDS control
630 /// @param[in] bFlag Disable/Enable
631 /// @return None
632 //------------------------------------------------------------------------------
MApi_HDMITx_DisableTMDSCtrl_U2(void * pInstance,MS_BOOL bFlag)633 void MApi_HDMITx_DisableTMDSCtrl_U2(void* pInstance, MS_BOOL bFlag)
634 {
635 MDrv_HDMITx_DisableTMDSCtrl(bFlag);
636 }
637
MApi_HDMITx_DisableTMDSCtrl(MS_BOOL bFlag)638 void MApi_HDMITx_DisableTMDSCtrl(MS_BOOL bFlag)
639 {
640 #ifdef UTOPIA_20
641 if (pu32HDMITXInst == NULL)
642 {
643 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
644 {
645 printf("MApi_HDMITx_DisableTMDSCtrl UtopiaOpen HDMITX failed\n");
646 }
647 }
648
649 stHDMITx_DisableTMDSCtrl HDMITXArgs;
650 HDMITXArgs.bFlag = bFlag;
651
652 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_DISABLETMDSCTRL, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
653 {
654 printf("MApi_HDMITx_DisableTMDSCtrl Obtain HDMITX engine fail\n");
655 return;
656 }
657 else
658 {
659 return;
660 }
661 #else
662 MApi_HDMITx_DisableTMDSCtrl_U2(pu32HDMITXInst, bFlag);
663 #endif
664 }
665
666 //------------------------------------------------------------------------------
667 /// @brief This routine swap R and B channel color
668 /// @param[in] state ON/OFF state
669 /// @return None
670 //-----------------------------------------------------------------------------
MApi_HDMITx_SetRBChannelSwap_U2(void * pInstance,MS_BOOL state)671 void MApi_HDMITx_SetRBChannelSwap_U2(void* pInstance, MS_BOOL state)
672 {
673 _HDMITX_SEMAPHORE_ENTRY(pInstance);
674 _HDMITX_GET_VARIABLE();
675
676 MDrv_HDMITx_SetRBChannelSwap(pInstance, state);
677
678 HDMITX_RETURN();
679 _HDMITX_SEMAPHORE_RETURN(pInstance);
680 }
681
MApi_HDMITx_SetRBChannelSwap(MS_BOOL state)682 void MApi_HDMITx_SetRBChannelSwap(MS_BOOL state)
683 {
684 #ifdef UTOPIA_20
685 if (pu32HDMITXInst == NULL)
686 {
687 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
688 {
689 printf("MApi_HDMITx_SetRBChannelSwap UtopiaOpen HDMITX failed\n");
690 }
691 }
692
693 stHDMITx_SetRBChannelSwap HDMITXArgs;
694 HDMITXArgs.state = state;
695
696 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETRBCHANNELSWAP, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
697 {
698 printf("MApi_HDMITx_SetRBChannelSwap Obtain HDMITX engine fail\n");
699 return;
700 }
701 else
702 {
703 return;
704 }
705 #else
706 MApi_HDMITx_SetRBChannelSwap_U2(pu32HDMITXInst, state);
707 #endif
708 }
709
710 //------------------------------------------------------------------------------
711 /// @brief This routine doing HDMITx exhibition
712 /// @return None
713 //-----------------------------------------------------------------------------
MApi_HDMITx_Exhibit_U2(void * pInstance)714 void MApi_HDMITx_Exhibit_U2(void* pInstance)
715 {
716 _HDMITX_SEMAPHORE_ENTRY(pInstance);
717 HDMITX_ENTRY();
718
719 MDrv_HDMITx_Exhibit(pInstance);
720
721 HDMITX_RETURN();
722 _HDMITX_SEMAPHORE_RETURN(pInstance);
723 }
724
MApi_HDMITx_Exhibit(void)725 void MApi_HDMITx_Exhibit(void)
726 {
727 #ifdef UTOPIA_20
728 if (pu32HDMITXInst == NULL)
729 {
730 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
731 {
732 printf("MApi_HDMITx_Exhibit UtopiaOpen HDMITX failed\n");
733 }
734 }
735
736 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_EXHIBIT, NULL) != UTOPIA_STATUS_SUCCESS)
737 {
738 printf("MApi_HDMITx_Exhibit Obtain HDMITX engine fail\n");
739 return;
740 }
741 else
742 {
743 return;
744 }
745 #else
746 MApi_HDMITx_Exhibit_U2(pu32HDMITXInst);
747 #endif
748 }
749
750 //------------------------------------------------------------------------------
751 /// @brief This routine getting the connected HDMI Rx status
752 /// @return Ture: Rx is alive
753 /// FALSE: Rx is dead
754 //-----------------------------------------------------------------------------
MApi_HDMITx_GetRxStatus_U2(void)755 MS_BOOL MApi_HDMITx_GetRxStatus_U2(void)
756 {
757 MS_BOOL bRet = FALSE;
758 bRet = MDrv_HDMITx_GetRxStatus();
759
760 return bRet;
761 }
762
MApi_HDMITx_GetRxStatus(void)763 MS_BOOL MApi_HDMITx_GetRxStatus(void)
764 {
765 #ifdef UTOPIA_20
766 if (pu32HDMITXInst == NULL)
767 {
768 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
769 {
770 printf("MApi_HDMITx_GetRxStatus UtopiaOpen HDMITX failed\n");
771 return FALSE;
772 }
773 }
774
775 stHDMITx_GetRxStatus HDMITXArgs;
776 HDMITXArgs.bReturn= FALSE;
777
778 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETRXSTATUS, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
779 {
780 printf("MApi_HDMITx_GetRxStatus Obtain HDMITX engine fail\n");
781 return FALSE;
782 }
783 else
784 {
785 return HDMITXArgs.bReturn;
786 }
787 #else
788 return MApi_HDMITx_GetRxStatus_U2();
789 #endif
790 }
791
792 //------------------------------------------------------------------------------
793 /// @brief This routine getting Rx's deep color definition from EDID
794 /// @return Ture: EDID is ready
795 /// FALSE: EDID is not ready
796 //-----------------------------------------------------------------------------
MApi_HDMITx_GetRxDCInfoFromEDID_U2(void * pInstance,HDMITX_VIDEO_COLORDEPTH_VAL * val)797 MS_BOOL MApi_HDMITx_GetRxDCInfoFromEDID_U2(void* pInstance, HDMITX_VIDEO_COLORDEPTH_VAL *val)
798 {
799 MS_BOOL bRet = FALSE;
800
801 _HDMITX_SEMAPHORE_ENTRY(pInstance);
802
803 if (MDrv_HDMITx_GetEdidRdyFlag(pInstance) == TRUE)
804 {
805 *val = (HDMITX_VIDEO_COLORDEPTH_VAL)MDrv_HDMITx_GetRxDCInfoFromEDID(pInstance);
806 bRet = TRUE;
807 }
808 else
809 {
810 *val = (HDMITX_VIDEO_COLORDEPTH_VAL)HDMITX_VIDEO_CD_NoID;
811 bRet = FALSE;
812 }
813
814 _HDMITX_SEMAPHORE_RETURN(pInstance);
815
816 return bRet;
817
818 }
819
MApi_HDMITx_GetRxDCInfoFromEDID(HDMITX_VIDEO_COLORDEPTH_VAL * val)820 MS_BOOL MApi_HDMITx_GetRxDCInfoFromEDID(HDMITX_VIDEO_COLORDEPTH_VAL *val)
821 {
822 #ifdef UTOPIA_20
823 if (pu32HDMITXInst == NULL)
824 {
825 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
826 {
827 printf("MApi_HDMITx_GetRxDCInfoFromEDID UtopiaOpen HDMITX failed\n");
828 return FALSE;
829 }
830 }
831
832 stHDMITx_GetRxDCInfoFromEDID HDMITXArgs;
833 HDMITXArgs.val = val;
834 HDMITXArgs.bReturn= FALSE;
835
836 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETRXDCINFOFROMEDID, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
837 {
838 printf("MApi_HDMITx_GetRxDCInfoFromEDID Obtain HDMITX engine fail\n");
839 return FALSE;
840 }
841 else
842 {
843 return HDMITXArgs.bReturn;
844 }
845 #else
846 return MApi_HDMITx_GetRxDCInfoFromEDID_U2(pu32HDMITXInst, val);
847 #endif
848 }
849
850 //------------------------------------------------------------------------------
851 /// @brief This routine getting Rx's support video format from EDID
852 /// @param[in] pu8Buffer pointer of buffer
853 /// @param[in] u8BufSize buffer size
854 /// @return Ture: EDID is ready
855 /// FALSE: EDID is not ready
856 //-----------------------------------------------------------------------------
MApi_HDMITx_GetRxVideoFormatFromEDID_U2(void * pInstance,MS_U8 * pu8Buffer,MS_U8 u8BufSize)857 MS_BOOL MApi_HDMITx_GetRxVideoFormatFromEDID_U2(void* pInstance, MS_U8 *pu8Buffer, MS_U8 u8BufSize)
858 {
859 MS_BOOL bRet = FALSE;
860
861 _HDMITX_SEMAPHORE_ENTRY(pInstance);
862
863 if (MDrv_HDMITx_GetEdidRdyFlag(pInstance) == TRUE)
864 {
865 MDrv_HDMITx_GetRxVideoFormatFromEDID(pInstance, pu8Buffer, u8BufSize);
866 bRet = TRUE;
867 }
868 else
869 {
870 memset(pu8Buffer, 0x00, u8BufSize);
871 bRet = FALSE;
872 }
873
874 _HDMITX_SEMAPHORE_RETURN(pInstance);
875
876 return bRet;
877 }
878
MApi_HDMITx_GetRxVideoFormatFromEDID(MS_U8 * pu8Buffer,MS_U8 u8BufSize)879 MS_BOOL MApi_HDMITx_GetRxVideoFormatFromEDID(MS_U8 *pu8Buffer, MS_U8 u8BufSize)
880 {
881 #ifdef UTOPIA_20
882 if (pu32HDMITXInst == NULL)
883 {
884 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
885 {
886 printf("MApi_HDMITx_GetRxVideoFormatFromEDID UtopiaOpen HDMITX failed\n");
887 return FALSE;
888 }
889 }
890
891 stHDMITx_GetRxVideoFormatFromEDID HDMITXArgs;
892 HDMITXArgs.pu8Buffer = pu8Buffer;
893 HDMITXArgs.u8BufSize = u8BufSize;
894 HDMITXArgs.bReturn= FALSE;
895
896 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETRXVIDEODORMATFROMEDID, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
897 {
898 printf("MApi_HDMITx_GetRxVideoFormatFromEDID Obtain HDMITX engine fail\n");
899 return FALSE;
900 }
901 else
902 {
903 return HDMITXArgs.bReturn;
904 }
905 #else
906 return MApi_HDMITx_GetRxVideoFormatFromEDID_U2(pu32HDMITXInst, pu8Buffer, u8BufSize);
907 #endif
908 }
909
910 //------------------------------------------------------------------------------
911 /// @brief This routine getting Rx's support VIC list from EDID
912 /// @param[in] pu8Buffer pointer of buffer
913 /// @param[in] u8BufSize buffer size
914 /// @return Ture: EDID is ready
915 /// FALSE: EDID is not ready
916 //-----------------------------------------------------------------------------
MApi_HDMITx_GetVICListFromEDID_U2(void * pInstance,MS_U8 * pu8Buffer,MS_U8 u8BufSize)917 MS_BOOL MApi_HDMITx_GetVICListFromEDID_U2(void* pInstance, MS_U8 *pu8Buffer, MS_U8 u8BufSize)
918 {
919 MS_BOOL bRet = FALSE;
920
921 _HDMITX_SEMAPHORE_ENTRY(pInstance);
922
923 if (MDrv_HDMITx_GetEdidRdyFlag(pInstance) == TRUE)
924 {
925 MDrv_HDMITx_GetVICListFromEDID(pInstance, pu8Buffer, u8BufSize);
926 bRet = TRUE;
927 }
928 else
929 {
930 memset(pu8Buffer, 0x00, u8BufSize);
931 bRet = FALSE;
932 }
933 _HDMITX_SEMAPHORE_RETURN(pInstance);
934
935 return bRet;
936 }
937
MApi_HDMITx_GetVICListFromEDID(MS_U8 * pu8Buffer,MS_U8 u8BufSize)938 MS_BOOL MApi_HDMITx_GetVICListFromEDID(MS_U8 *pu8Buffer, MS_U8 u8BufSize)
939 {
940 #ifdef UTOPIA_20
941 if (pu32HDMITXInst == NULL)
942 {
943 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
944 {
945 printf("MApi_HDMITx_GetVICListFromEDID UtopiaOpen HDMITX failed\n");
946 return FALSE;
947 }
948 }
949
950 stHDMITx_GetVICListFromEDID HDMITXArgs;
951 HDMITXArgs.pu8Buffer = pu8Buffer;
952 HDMITXArgs.u8BufSize = u8BufSize;
953 HDMITXArgs.bReturn= FALSE;
954
955 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETVICLISTFROMEDID, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
956 {
957 printf("MApi_HDMITx_GetVICListFromEDID Obtain HDMITX engine fail\n");
958 return FALSE;
959 }
960 else
961 {
962 return HDMITXArgs.bReturn;
963 }
964 #else
965 return MApi_HDMITx_GetVICListFromEDID_U2(pu32HDMITXInst, pu8Buffer, u8BufSize);
966 #endif
967 }
968
969 //------------------------------------------------------------------------------
970 /// @brief This routine getting Rx's data block length from EDID
971 /// @param[in] pu8Length pointer of buffer
972 /// @param[in] u8TagCode
973 /// @return Ture: EDID is ready
974 /// FALSE: EDID is not ready
975 //-----------------------------------------------------------------------------
MApi_HDMITx_GetDataBlockLengthFromEDID_U2(void * pInstance,MS_U8 * pu8Length,MS_U8 u8TagCode)976 MS_BOOL MApi_HDMITx_GetDataBlockLengthFromEDID_U2(void* pInstance, MS_U8 *pu8Length, MS_U8 u8TagCode)
977 {
978 MS_BOOL bRet = FALSE;
979
980 _HDMITX_SEMAPHORE_ENTRY(pInstance);
981
982 if (MDrv_HDMITx_GetEdidRdyFlag(pInstance) == TRUE)
983 {
984 MDrv_HDMITx_GetDataBlockLengthFromEDID(pInstance, pu8Length, u8TagCode);
985 bRet = TRUE;
986 }
987 else
988 {
989 *pu8Length = 0x00;
990 bRet = FALSE;
991 }
992 _HDMITX_SEMAPHORE_RETURN(pInstance);
993
994 return bRet;
995 }
996
MApi_HDMITx_GetDataBlockLengthFromEDID(MS_U8 * pu8Length,MS_U8 u8TagCode)997 MS_BOOL MApi_HDMITx_GetDataBlockLengthFromEDID(MS_U8 *pu8Length, MS_U8 u8TagCode)
998 {
999 #ifdef UTOPIA_20
1000 if (pu32HDMITXInst == NULL)
1001 {
1002 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1003 {
1004 printf("MApi_HDMITx_GetDataBlockLengthFromEDID UtopiaOpen HDMITX failed\n");
1005 return FALSE;
1006 }
1007 }
1008
1009 stHDMITx_GetDataBlockLengthFromEDID HDMITXArgs;
1010 HDMITXArgs.pu8Length = pu8Length;
1011 HDMITXArgs.u8TagCode = u8TagCode;
1012 HDMITXArgs.bReturn= FALSE;
1013
1014 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETDATABLOCKLENGTHFROMEDID, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
1015 {
1016 printf("MApi_HDMITx_GetDataBlockLengthFromEDID Obtain HDMITX engine fail\n");
1017 return FALSE;
1018 }
1019 else
1020 {
1021 return HDMITXArgs.bReturn;
1022 }
1023 #else
1024 return MApi_HDMITx_GetDataBlockLengthFromEDID_U2(pu32HDMITXInst, pu8Length, u8TagCode);
1025 #endif
1026 }
1027
1028 //------------------------------------------------------------------------------
1029 /// @brief This routine getting Rx's support audio format from EDID
1030 /// @param[in] pu8Buffer pointer of buffer
1031 /// @param[in] u8BufSize buffer size
1032 /// @return Ture: EDID is ready
1033 /// FALSE: EDID is not ready
1034 //-----------------------------------------------------------------------------
MApi_HDMITx_GetRxAudioFormatFromEDID_U2(void * pInstance,MS_U8 * pu8Buffer,MS_U8 u8BufSize)1035 MS_BOOL MApi_HDMITx_GetRxAudioFormatFromEDID_U2(void* pInstance, MS_U8 *pu8Buffer, MS_U8 u8BufSize)
1036 {
1037 MS_BOOL bRet = FALSE;
1038
1039 _HDMITX_SEMAPHORE_ENTRY(pInstance);
1040
1041 if (MDrv_HDMITx_GetEdidRdyFlag(pInstance) == TRUE)
1042 {
1043 MDrv_HDMITx_GetRxAudioFormatFromEDID(pInstance, pu8Buffer, u8BufSize);
1044 bRet = TRUE;
1045 }
1046 else
1047 {
1048 memset(pu8Buffer, 0x00, u8BufSize);
1049 bRet = FALSE;
1050 }
1051 _HDMITX_SEMAPHORE_RETURN(pInstance);
1052
1053 return bRet;
1054 }
1055
MApi_HDMITx_GetRxAudioFormatFromEDID(MS_U8 * pu8Buffer,MS_U8 u8BufSize)1056 MS_BOOL MApi_HDMITx_GetRxAudioFormatFromEDID(MS_U8 *pu8Buffer, MS_U8 u8BufSize)
1057 {
1058 #ifdef UTOPIA_20
1059 if (pu32HDMITXInst == NULL)
1060 {
1061 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1062 {
1063 printf("MApi_HDMITx_GetRxAudioFormatFromEDID UtopiaOpen HDMITX failed\n");
1064 return FALSE;
1065 }
1066 }
1067
1068 stHDMITx_GetRxAudioFormatFromEDID HDMITXArgs;
1069 HDMITXArgs.pu8Buffer = pu8Buffer;
1070 HDMITXArgs.u8BufSize = u8BufSize;
1071 HDMITXArgs.bReturn= FALSE;
1072
1073 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETRXAUDIOFORMATFROMEDID, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
1074 {
1075 printf("MApi_HDMITx_GetRxAudioFormatFromEDID Obtain HDMITX engine fail\n");
1076 return FALSE;
1077 }
1078 else
1079 {
1080 return HDMITXArgs.bReturn;
1081 }
1082 #else
1083 return MApi_HDMITx_GetRxAudioFormatFromEDID_U2(pu32HDMITXInst, pu8Buffer, u8BufSize);
1084 #endif
1085 }
1086
MApi_HDMITx_EDID_HDMISupport_U2(void * pInstance,MS_BOOL * HDMI_Support)1087 MS_BOOL MApi_HDMITx_EDID_HDMISupport_U2(void* pInstance, MS_BOOL *HDMI_Support)
1088 {
1089 _HDMITX_SEMAPHORE_ENTRY(pInstance);
1090
1091 if (MDrv_HDMITx_GetEdidRdyFlag(pInstance) == TRUE)
1092 {
1093 *HDMI_Support = MDrv_HDMITx_EdidGetHDMISupportFlag(pInstance);
1094 _HDMITX_SEMAPHORE_RETURN(pInstance);
1095 return TRUE;
1096 }
1097 else
1098 {
1099 _HDMITX_SEMAPHORE_RETURN(pInstance);
1100 return FALSE;
1101 }
1102 }
1103
MApi_HDMITx_EDID_HDMISupport(MS_BOOL * HDMI_Support)1104 MS_BOOL MApi_HDMITx_EDID_HDMISupport(MS_BOOL *HDMI_Support)
1105 {
1106 #ifdef UTOPIA_20
1107 if (pu32HDMITXInst == NULL)
1108 {
1109 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1110 {
1111 printf("MApi_HDMITx_EDID_HDMISupport UtopiaOpen HDMITX failed\n");
1112 return FALSE;
1113 }
1114 }
1115
1116 stHDMITx_EDID_HDMISupport HDMITXArgs;
1117 HDMITXArgs.HDMI_Support = HDMI_Support;
1118 HDMITXArgs.bReturn = FALSE;
1119
1120 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_EDID_HDMISUPPORT, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
1121 {
1122 printf("MApi_HDMITx_EDID_HDMISupport Obtain HDMITX engine fail\n");
1123 return FALSE;
1124 }
1125 else
1126 {
1127 return HDMITXArgs.bReturn;
1128 }
1129 #else
1130 return MApi_HDMITx_EDID_HDMISupport_U2(pu32HDMITXInst, HDMI_Support);
1131 #endif
1132 }
1133
1134 //------------------------------------------------------------------------------
1135 /// @brief This routine getting Rx's ID Manu facturer Name from EDID
1136 /// @param[in] pu8Buffer pointer of buffer
1137 /// @return Ture: EDID is ready
1138 /// FALSE: EDID is not ready
1139 //-----------------------------------------------------------------------------
MApi_HDMITx_GetRxIDManufacturerName_U2(void * pInstance,MS_U8 * pu8Buffer)1140 MS_BOOL MApi_HDMITx_GetRxIDManufacturerName_U2(void* pInstance, MS_U8 *pu8Buffer)
1141 {
1142 MS_BOOL bRet = FALSE;
1143
1144 _HDMITX_SEMAPHORE_ENTRY(pInstance);
1145 if (MDrv_HDMITx_GetEdidRdyFlag(pInstance) == TRUE)
1146 {
1147 MDrv_HDMITx_GetRxIDManufacturerName(pInstance, pu8Buffer);
1148 bRet = TRUE;
1149 }
1150 else
1151 {
1152 memset(pu8Buffer, 0x00, 0x03);
1153 bRet = FALSE;
1154 }
1155 _HDMITX_SEMAPHORE_RETURN(pInstance);
1156
1157 return bRet;
1158 }
1159
MApi_HDMITx_GetRxIDManufacturerName(MS_U8 * pu8Buffer)1160 MS_BOOL MApi_HDMITx_GetRxIDManufacturerName(MS_U8 *pu8Buffer)
1161 {
1162 #ifdef UTOPIA_20
1163 if (pu32HDMITXInst == NULL)
1164 {
1165 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1166 {
1167 printf("MApi_HDMITx_GetRxIDManufacturerName UtopiaOpen HDMITX failed\n");
1168 return FALSE;
1169 }
1170 }
1171
1172 stHDMITx_GetRxIDManufacturerName HDMITXArgs;
1173 HDMITXArgs.pu8Buffer = pu8Buffer;
1174 HDMITXArgs.bReturn = FALSE;
1175
1176 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETRXIDMANUFACTURERNAME, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
1177 {
1178 printf("MApi_HDMITx_GetRxIDManufacturerName Obtain HDMITX engine fail\n");
1179 return FALSE;
1180 }
1181 else
1182 {
1183 return HDMITXArgs.bReturn;
1184 }
1185 #else
1186 return MApi_HDMITx_GetRxIDManufacturerName_U2(pu32HDMITXInst, pu8Buffer);
1187 #endif
1188 }
1189
1190 //------------------------------------------------------------------------------
1191 /// @brief This routine getting Rx's EDID Data
1192 /// @param[in] pu8Buffer pointer of buffer
1193 /// @param[in] BlockIdx 0: for 0~127, 1: for 128~255
1194 /// @return Ture: EDID is ready
1195 /// FALSE: EDID is not ready
1196 //-----------------------------------------------------------------------------
MApi_HDMITx_GetEDIDData_U2(void * pInstance,MS_U8 * pu8Buffer,MS_BOOL BlockIdx)1197 MS_BOOL MApi_HDMITx_GetEDIDData_U2(void* pInstance, MS_U8 *pu8Buffer, MS_BOOL BlockIdx)
1198 {
1199 MS_BOOL bRet = FALSE;
1200
1201 _HDMITX_SEMAPHORE_ENTRY(pInstance);
1202 if (MDrv_HDMITx_GetEdidRdyFlag(pInstance) == TRUE)
1203 {
1204 MDrv_HDMITx_GetEDIDData(pInstance, pu8Buffer, BlockIdx);
1205 bRet = TRUE;
1206 }
1207 else
1208 {
1209 memset(pu8Buffer, 0x00, 128*sizeof(MS_U8));
1210 bRet = FALSE;
1211 }
1212 _HDMITX_SEMAPHORE_RETURN(pInstance);
1213
1214 return bRet;
1215 }
1216
MApi_HDMITx_GetEDIDData(MS_U8 * pu8Buffer,MS_BOOL BlockIdx)1217 MS_BOOL MApi_HDMITx_GetEDIDData(MS_U8 *pu8Buffer, MS_BOOL BlockIdx)
1218 {
1219 #ifdef UTOPIA_20
1220 if (pu32HDMITXInst == NULL)
1221 {
1222 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1223 {
1224 printf("MApi_HDMITx_GetEDIDData UtopiaOpen HDMITX failed\n");
1225 return FALSE;
1226 }
1227 }
1228
1229 stHDMITx_GetEDIDData HDMITXArgs;
1230 HDMITXArgs.pu8Buffer = pu8Buffer;
1231 HDMITXArgs.BlockIdx = BlockIdx;
1232 HDMITXArgs.bReturn = FALSE;
1233
1234 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETEDIDDATA, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
1235 {
1236 printf("MApi_HDMITx_GetEDIDData Obtain HDMITX engine fail\n");
1237 return FALSE;
1238 }
1239 else
1240 {
1241 return HDMITXArgs.bReturn;
1242 }
1243 #else
1244 return MApi_HDMITx_GetEDIDData_U2(pu32HDMITXInst, pu8Buffer, BlockIdx);
1245 #endif
1246 }
1247
1248
1249 //------------------------------------------------------------------------------
1250 /// @brief This routine gets Rx's supported 3D structures of specific timing from EDID
1251 /// @param[in] timing input video timing
1252 /// @param[in] p3DStructure pointer of supported 3D structure
1253 /// @return Ture: EDID is ready
1254 /// FALSE: EDID is not ready
1255 //-----------------------------------------------------------------------------
MApi_HDMITx_GetRx3DStructureFromEDID_U2(void * pInstance,HDMITX_VIDEO_TIMING timing,HDMITX_EDID_3D_STRUCTURE_ALL * p3DStructure)1256 MS_BOOL MApi_HDMITx_GetRx3DStructureFromEDID_U2(void* pInstance, HDMITX_VIDEO_TIMING timing, HDMITX_EDID_3D_STRUCTURE_ALL *p3DStructure)
1257 {
1258 MS_BOOL bRet = FALSE;
1259
1260 _HDMITX_SEMAPHORE_ENTRY(pInstance);
1261 if (MDrv_HDMITx_GetEdidRdyFlag(pInstance) == TRUE)
1262 {
1263 MDrv_HDMITx_GetRx3DStructureFromEDID(pInstance, (MsHDMITX_VIDEO_TIMING)timing, (MsHDMITX_EDID_3D_STRUCTURE_ALL *)p3DStructure);
1264 bRet = TRUE;
1265 }
1266 else
1267 {
1268 *p3DStructure = 0x00;
1269 bRet = FALSE;
1270 }
1271 _HDMITX_SEMAPHORE_RETURN(pInstance);
1272
1273 return bRet;
1274 }
1275
MApi_HDMITx_GetRx3DStructureFromEDID(HDMITX_VIDEO_TIMING timing,HDMITX_EDID_3D_STRUCTURE_ALL * p3DStructure)1276 MS_BOOL MApi_HDMITx_GetRx3DStructureFromEDID(HDMITX_VIDEO_TIMING timing, HDMITX_EDID_3D_STRUCTURE_ALL *p3DStructure)
1277 {
1278 #ifdef UTOPIA_20
1279 if (pu32HDMITXInst == NULL)
1280 {
1281 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1282 {
1283 printf("MApi_HDMITx_GetRx3DStructureFromEDID UtopiaOpen HDMITX failed\n");
1284 return FALSE;
1285 }
1286 }
1287
1288 stHDMITx_GetRx3DStructureFromEDID HDMITXArgs;
1289 HDMITXArgs.timing = timing;
1290 HDMITXArgs.p3DStructure = p3DStructure;
1291 HDMITXArgs.bReturn = FALSE;
1292
1293 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETRX3DSTRUCTUREFROMEDID, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
1294 {
1295 printf("MApi_HDMITx_GetRx3DStructureFromEDID Obtain HDMITX engine fail\n");
1296 return FALSE;
1297 }
1298 else
1299 {
1300 return HDMITXArgs.bReturn;
1301 }
1302 #else
1303 return MApi_HDMITx_GetRx3DStructureFromEDID_U2(pu32HDMITXInst, timing, p3DStructure);
1304 #endif
1305 }
1306
1307 //------------------------------------------------------------------------------
1308 /// @brief This routine gets Rx's supported color of specific timing from EDID
1309 /// @param[in] timing input video timing
1310 /// @param[in] pColorFmt pointer of supported color format
1311 /// @return Ture: EDID is ready
1312 /// FALSE: EDID is not ready
1313 //-----------------------------------------------------------------------------
MApi_HDMITx_GetColorFormatFromEDID_U2(void * pInstance,HDMITX_VIDEO_TIMING timing,HDMITX_EDID_COLOR_FORMAT * pColorFmt)1314 MS_BOOL MApi_HDMITx_GetColorFormatFromEDID_U2(void* pInstance, HDMITX_VIDEO_TIMING timing, HDMITX_EDID_COLOR_FORMAT *pColorFmt)
1315 {
1316 MS_BOOL bRet = FALSE;
1317
1318 _HDMITX_SEMAPHORE_ENTRY(pInstance);
1319
1320 if (MDrv_HDMITx_GetEdidRdyFlag(pInstance) == TRUE)
1321 {
1322 MDrv_HDMITx_GetColorFormatFromEDID(pInstance, (MsHDMITX_VIDEO_TIMING)timing, (MsHDMITX_EDID_COLOR_FORMAT *)pColorFmt);
1323 bRet = TRUE;
1324 }
1325 else
1326 {
1327 *pColorFmt = HDMITX_EDID_Color_RGB_444;
1328 bRet = FALSE;
1329 }
1330 _HDMITX_SEMAPHORE_RETURN(pInstance);
1331
1332 return bRet;
1333
1334 }
1335
MApi_HDMITx_GetColorFormatFromEDID(HDMITX_VIDEO_TIMING timing,HDMITX_EDID_COLOR_FORMAT * pColorFmt)1336 MS_BOOL MApi_HDMITx_GetColorFormatFromEDID(HDMITX_VIDEO_TIMING timing, HDMITX_EDID_COLOR_FORMAT *pColorFmt)
1337 {
1338 #ifdef UTOPIA_20
1339 if (pu32HDMITXInst == NULL)
1340 {
1341 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1342 {
1343 printf("MApi_HDMITx_GetColorFormatFromEDID UtopiaOpen HDMITX failed\n");
1344 return FALSE;
1345 }
1346 }
1347
1348 stHDMITx_GetColorFormatFromEDID HDMITXArgs;
1349 HDMITXArgs.timing = timing;
1350 HDMITXArgs.pColorFmt = pColorFmt;
1351 HDMITXArgs.bReturn= FALSE;
1352
1353 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETCOLORFORMATFROMEDID, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
1354 {
1355 printf("MApi_HDMITx_GetColorFormatFromEDID Obtain HDMITX engine fail\n");
1356 return FALSE;
1357 }
1358 else
1359 {
1360 return HDMITXArgs.bReturn;
1361 }
1362 #else
1363 return MApi_HDMITx_GetColorFormatFromEDID_U2(pu32HDMITXInst, timing, pColorFmt);
1364 #endif
1365 }
1366
1367
1368 //------------------------------------------------------------------------------
1369 /// @brief This function clear settings of user defined packet
1370 /// @return None
1371 //-----------------------------------------------------------------------------
MApi_HDMITx_PKT_User_Define_Clear_U2(void * pInstance)1372 void MApi_HDMITx_PKT_User_Define_Clear_U2(void* pInstance)
1373 {
1374 MDrv_HDMITx_PKT_User_Define_Clear();
1375 }
1376
MApi_HDMITx_PKT_User_Define_Clear(void)1377 void MApi_HDMITx_PKT_User_Define_Clear(void)
1378 {
1379 #ifdef UTOPIA_20
1380 if (pu32HDMITXInst == NULL)
1381 {
1382 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1383 {
1384 printf("MApi_HDMITx_PKT_User_Define_Clear UtopiaOpen HDMITX failed\n");
1385 }
1386 }
1387
1388 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_PKT_USER_DEFINE_CLEAR, NULL) != UTOPIA_STATUS_SUCCESS)
1389 {
1390 printf("MApi_HDMITx_PKT_User_Define_Clear Obtain HDMITX engine fail\n");
1391 return;
1392 }
1393 else
1394 {
1395 return;
1396 }
1397 #else
1398 MApi_HDMITx_PKT_User_Define_Clear_U2(pu32HDMITXInst);
1399 #endif
1400 }
1401
1402 //------------------------------------------------------------------------------
1403 /// @brief This function set user defined hdmi packet
1404 /// @param[in] packet_type: type of user defined packet
1405 /// @param[in] def_flag: enable/disable user defined packet
1406 /// @param[in] def_process: packet process of user defined packet
1407 /// @param[in] def_fcnt: frame counts of user defined packet (0~31)
1408 /// @return None
1409 //-----------------------------------------------------------------------------
MApi_HDMITx_PKT_User_Define_U2(void * pInstance,HDMITX_PACKET_TYPE packet_type,MS_BOOL def_flag,HDMITX_PACKET_PROCESS def_process,MS_U8 def_fcnt)1410 void MApi_HDMITx_PKT_User_Define_U2(void* pInstance, HDMITX_PACKET_TYPE packet_type, MS_BOOL def_flag,
1411 HDMITX_PACKET_PROCESS def_process, MS_U8 def_fcnt)
1412 {
1413 HDMITX_ENTRY();
1414 MDrv_HDMITx_PKT_User_Define((MsHDMITX_PACKET_TYPE)packet_type, def_flag, (MsHDMITX_PACKET_PROCESS)def_process, def_fcnt);
1415 HDMITX_RETURN();
1416 }
1417
MApi_HDMITx_PKT_User_Define(HDMITX_PACKET_TYPE packet_type,MS_BOOL def_flag,HDMITX_PACKET_PROCESS def_process,MS_U8 def_fcnt)1418 void MApi_HDMITx_PKT_User_Define(HDMITX_PACKET_TYPE packet_type, MS_BOOL def_flag,
1419 HDMITX_PACKET_PROCESS def_process, MS_U8 def_fcnt)
1420 {
1421 #ifdef UTOPIA_20
1422 if (pu32HDMITXInst == NULL)
1423 {
1424 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1425 {
1426 printf("MApi_HDMITx_PKT_User_Define UtopiaOpen HDMITX failed\n");
1427 }
1428 }
1429
1430 stHDMITx_PKT_User_Define HDMITXArgs;
1431 HDMITXArgs.packet_type = packet_type;
1432 HDMITXArgs.def_flag = def_flag;
1433 HDMITXArgs.def_process = def_process;
1434 HDMITXArgs.def_fcnt = def_fcnt;
1435
1436 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_PKT_USER_DEFINE, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
1437 {
1438 printf("MApi_HDMITx_PKT_User_Define Obtain HDMITX engine fail\n");
1439 return;
1440 }
1441 else
1442 {
1443 return;
1444 }
1445 #else
1446 MApi_HDMITx_PKT_User_Define_U2(pu32HDMITXInst, packet_type, def_flag, def_process, def_fcnt);
1447 #endif
1448 }
1449
1450 //------------------------------------------------------------------------------
1451 /// @brief This function let user define packet's content
1452 /// @param[in] packet_type: type of user defined packet
1453 /// @param[in] data: content of user defined packet
1454 /// @param[in] length: length of packet content
1455 /// @return None
1456 //------------------------------------------------------------------------------
MApi_HDMITx_PKT_Content_Define_U2(void * pInstance,HDMITX_PACKET_TYPE packet_type,MS_U8 * data,MS_U8 length)1457 MS_BOOL MApi_HDMITx_PKT_Content_Define_U2(void* pInstance, HDMITX_PACKET_TYPE packet_type, MS_U8 *data, MS_U8 length)
1458 {
1459 MS_BOOL bRet = FALSE;
1460
1461 HDMITX_ENTRY();
1462 bRet = MDrv_HDMITx_PKT_Content_Define((MsHDMITX_PACKET_TYPE)packet_type, data, length);
1463 HDMITX_RETURN();
1464
1465 return bRet;
1466 }
1467
MApi_HDMITx_PKT_Content_Define(HDMITX_PACKET_TYPE packet_type,MS_U8 * data,MS_U8 length)1468 MS_BOOL MApi_HDMITx_PKT_Content_Define(HDMITX_PACKET_TYPE packet_type, MS_U8 *data, MS_U8 length)
1469 {
1470 #ifdef UTOPIA_20
1471 if (pu32HDMITXInst == NULL)
1472 {
1473 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1474 {
1475 printf("MApi_HDMITx_PKT_Content_Define UtopiaOpen HDMITX failed\n");
1476 return FALSE;
1477 }
1478 }
1479
1480 stHDMITx_PKT_Content_Define HDMITXArgs;
1481 HDMITXArgs.packet_type = packet_type;
1482 HDMITXArgs.data = data;
1483 HDMITXArgs.length = length;
1484 HDMITXArgs.bReturn = FALSE;
1485
1486 if(UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_PKT_CONTENT_DEFINE, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
1487 {
1488 printf("MApi_HDMITx_PKT_Content_Define Obtain HDMITX engine fail\n");
1489 return FALSE;
1490 }
1491 else
1492 {
1493 return HDMITXArgs.bReturn;
1494 }
1495 #else
1496 return MApi_HDMITx_PKT_Content_Define_U2(pu32HDMITXInst, packet_type, data, length);
1497 #endif
1498 }
1499
1500 //*********************//
1501 // Video //
1502 //*********************//
1503
1504 //------------------------------------------------------------------------------
1505 /// @brief This routine turn on/off HDMI Tx Module video output
1506 /// @param[in] state ON/OFF state
1507 /// @return None
1508 //-----------------------------------------------------------------------------
MApi_HDMITx_SetVideoOnOff_U2(void * pInstance,MS_BOOL state)1509 void MApi_HDMITx_SetVideoOnOff_U2(void* pInstance, MS_BOOL state)
1510 {
1511 _HDMITX_SEMAPHORE_ENTRY(pInstance);
1512 HDMITX_ENTRY();
1513
1514 MDrv_HDMITx_SetVideoOnOff(pInstance, state);
1515
1516 HDMITX_RETURN();
1517 _HDMITX_SEMAPHORE_RETURN(pInstance);
1518 }
1519
MApi_HDMITx_SetVideoOnOff(MS_BOOL state)1520 void MApi_HDMITx_SetVideoOnOff(MS_BOOL state)
1521 {
1522 #ifdef UTOPIA_20
1523 if (pu32HDMITXInst == NULL)
1524 {
1525 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1526 {
1527 printf("MApi_HDMITx_SetVideoOnOff UtopiaOpen HDMITX failed\n");
1528 }
1529 }
1530
1531 stHDMITx_SetVideoOnOff HDMITXArgs;
1532 HDMITXArgs.state = state;
1533
1534 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETVIDEOONOFF, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
1535 {
1536 printf("MApi_HDMITx_SetVideoOnOff Obtain HDMITX engine fail\n");
1537 return;
1538 }
1539 else
1540 {
1541 return;
1542 }
1543 #else
1544 MApi_HDMITx_SetVideoOnOff_U2(pu32HDMITXInst, state);
1545 #endif
1546 }
1547
1548
1549 //------------------------------------------------------------------------------
1550 /// @brief This routine config HDMI Tx Module video color format
1551 /// @param[in] in_color input color format
1552 /// @param[in] out_color output color format
1553 /// @return None
1554 //-----------------------------------------------------------------------------
MApi_HDMITx_SetColorFormat_U2(void * pInstance,HDMITX_VIDEO_COLOR_FORMAT in_color,HDMITX_VIDEO_COLOR_FORMAT out_color)1555 void MApi_HDMITx_SetColorFormat_U2(void* pInstance, HDMITX_VIDEO_COLOR_FORMAT in_color, HDMITX_VIDEO_COLOR_FORMAT out_color)
1556 {
1557 _HDMITX_SEMAPHORE_ENTRY(pInstance);
1558 HDMITX_ENTRY();
1559
1560 MS_BOOL bInvalidArg = FALSE;
1561 MsHDMITX_VIDEO_COLOR_FORMAT enInputColor = E_HDMITX_VIDEO_COLOR_RGB444;
1562 MsHDMITX_VIDEO_COLOR_FORMAT enOutputColor = E_HDMITX_VIDEO_COLOR_RGB444;
1563
1564 //convert different enum define
1565 switch (in_color)
1566 {
1567 case HDMITX_VIDEO_COLOR_RGB444:
1568 enInputColor = E_HDMITX_VIDEO_COLOR_RGB444;
1569 break;
1570
1571 case HDMITX_VIDEO_COLOR_YUV422:
1572 enInputColor = E_HDMITX_VIDEO_COLOR_YUV422;
1573 break;
1574
1575 case HDMITX_VIDEO_COLOR_YUV444:
1576 enInputColor = E_HDMITX_VIDEO_COLOR_YUV444;
1577 break;
1578
1579 case HDMITX_VIDEO_COLOR_YUV420:
1580 enInputColor = E_HDMITX_VIDEO_COLOR_YUV420;
1581 break;
1582
1583 default:
1584 bInvalidArg = TRUE;
1585 printf("[HDMITx]: Error video color format(in): %d\n", in_color);
1586 break;
1587 }
1588
1589 switch (out_color)
1590 {
1591 case HDMITX_VIDEO_COLOR_RGB444:
1592 enOutputColor = E_HDMITX_VIDEO_COLOR_RGB444;
1593 break;
1594
1595 case HDMITX_VIDEO_COLOR_YUV422:
1596 enOutputColor = E_HDMITX_VIDEO_COLOR_YUV422;
1597 break;
1598
1599 case HDMITX_VIDEO_COLOR_YUV444:
1600 enOutputColor = E_HDMITX_VIDEO_COLOR_YUV444;
1601 break;
1602
1603 case HDMITX_VIDEO_COLOR_YUV420:
1604 enOutputColor = E_HDMITX_VIDEO_COLOR_YUV420;
1605 break;
1606
1607 default:
1608 bInvalidArg = TRUE;
1609 printf("[HDMITx]: Error video color format(out): %d\n", out_color);
1610 break;
1611 }
1612
1613 if (bInvalidArg == FALSE)
1614 MDrv_HDMITx_SetColorFormat(pInstance, enInputColor, enOutputColor);
1615
1616 HDMITX_RETURN();
1617 _HDMITX_SEMAPHORE_RETURN(pInstance);
1618 }
1619
MApi_HDMITx_SetColorFormat(HDMITX_VIDEO_COLOR_FORMAT in_color,HDMITX_VIDEO_COLOR_FORMAT out_color)1620 void MApi_HDMITx_SetColorFormat(HDMITX_VIDEO_COLOR_FORMAT in_color, HDMITX_VIDEO_COLOR_FORMAT out_color)
1621 {
1622 #ifdef UTOPIA_20
1623 if (pu32HDMITXInst == NULL)
1624 {
1625 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1626 {
1627 printf("MApi_HDMITx_SetColorFormat UtopiaOpen HDMITX failed\n");
1628 }
1629 }
1630
1631 stHDMITx_SetColorFormat HDMITXArgs;
1632 HDMITXArgs.in_color = in_color;
1633 HDMITXArgs.out_color = out_color;
1634
1635 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETCOLORFORMAT, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
1636 {
1637 printf("MApi_HDMITx_SetColorFormat Obtain HDMITX engine fail\n");
1638 return;
1639 }
1640 else
1641 {
1642 return;
1643 }
1644 #else
1645 MApi_HDMITx_SetColorFormat_U2(pu32HDMITXInst, in_color, out_color);
1646 #endif
1647 }
1648
1649 //------------------------------------------------------------------------------
1650 /// @brief This routine config HDMI Tx vs packet content
1651 /// @param[in] in_color input color format
1652 /// @param[in] out_color output color format
1653 /// @return None
1654 //-----------------------------------------------------------------------------
MApi_HDMITx_Set_VS_InfoFrame_U2(void * pInstance,HDMITX_VIDEO_VS_FORMAT vs_format,HDMITX_VIDEO_3D_STRUCTURE vs_3d,HDMITX_VIDEO_4k2k_VIC vs_vic)1655 void MApi_HDMITx_Set_VS_InfoFrame_U2(void* pInstance, HDMITX_VIDEO_VS_FORMAT vs_format, HDMITX_VIDEO_3D_STRUCTURE vs_3d, HDMITX_VIDEO_4k2k_VIC vs_vic)
1656 {
1657 _HDMITX_SEMAPHORE_ENTRY(pInstance);
1658 HDMITX_ENTRY();
1659
1660 MsHDMITX_VIDEO_VS_FORMAT enVSFmt = E_HDMITX_VIDEO_VS_No_Addition;
1661 MsHDMITX_VIDEO_4k2k_VIC enVid4K2KVic = E_HDMITx_VIDEO_4k2k_Reserved;
1662 MsHDMITX_VIDEO_3D_STRUCTURE enVid3DStruct = E_HDMITx_VIDEO_3D_Not_in_Use;
1663
1664 //convert enum type
1665 switch (vs_format)
1666 {
1667 case HDMITX_VIDEO_VS_4k_2k:
1668 {
1669 enVSFmt = E_HDMITX_VIDEO_VS_4k_2k;
1670
1671 switch (vs_vic)
1672 {
1673 case HDMITX_VIDEO_4k2k_30Hz:
1674 enVid4K2KVic = E_HDMITX_VIDEO_4k2k_30Hz;
1675 break;
1676
1677 case HDMITX_VIDEO_4k2k_25Hz:
1678 enVid4K2KVic = E_HDMITX_VIDEO_4k2k_25Hz;
1679 break;
1680
1681 case HDMITX_VIDEO_4k2k_24Hz:
1682 enVid4K2KVic = E_HDMITX_VIDEO_4k2k_24Hz;
1683 break;
1684
1685 case HDMITx_VIDEO_4k2k_24Hz_SMPTE:
1686 enVid4K2KVic = E_HDMITx_VIDEO_4k2k_24Hz_SMPTE;
1687 break;
1688
1689 case HDMITx_VIDEO_4k2k_Reserved:
1690 enVid4K2KVic = E_HDMITX_VIDEO_4k2k_30Hz;
1691 break;
1692
1693 default:
1694 enVid4K2KVic = E_HDMITx_VIDEO_4k2k_Reserved;
1695 break;
1696 }
1697 }
1698 break;
1699
1700 case HDMITX_VIDEO_VS_3D:
1701 enVSFmt = E_HDMITX_VIDEO_VS_3D;
1702 switch (vs_3d)
1703 {
1704 case HDMITX_VIDEO_3D_FramePacking: //0000
1705 enVid3DStruct = E_HDMITX_VIDEO_3D_FramePacking;
1706 break;
1707
1708 case HDMITX_VIDEO_3D_FieldAlternative: //0001
1709 enVid3DStruct = E_HDMITX_VIDEO_3D_FieldAlternative;
1710 break;
1711
1712 case HDMITX_VIDEO_3D_LineAlternative: //0010
1713 enVid3DStruct = E_HDMITX_VIDEO_3D_LineAlternative;
1714 break;
1715
1716 case HDMITX_VIDEO_3D_SidebySide_FULL: //0011
1717 enVid3DStruct = E_HDMITX_VIDEO_3D_SidebySide_FULL;
1718 break;
1719
1720 case HDMITX_VIDEO_3D_L_Dep: //0100
1721 enVid3DStruct = E_HDMITX_VIDEO_3D_L_Dep;
1722 break;
1723
1724 case HDMITX_VIDEO_3D_L_Dep_Graphic_Dep: //0101
1725 enVid3DStruct = E_HDMITX_VIDEO_3D_L_Dep_Graphic_Dep;
1726 break;
1727
1728 case HDMITX_VIDEO_3D_TopandBottom: //0110
1729 enVid3DStruct = E_HDMITX_VIDEO_3D_TopandBottom;
1730 break;
1731
1732 case HDMITX_VIDEO_3D_SidebySide_Half: //1000
1733 enVid3DStruct = E_HDMITX_VIDEO_3D_SidebySide_Half;
1734 break;
1735
1736 default: //1111
1737 enVid3DStruct = E_HDMITx_VIDEO_3D_Not_in_Use;
1738 break;
1739 }
1740 break;
1741
1742 default:
1743 enVSFmt = E_HDMITX_VIDEO_VS_No_Addition;
1744 break;
1745 }
1746
1747 MDrv_HDMITx_Set_VS_InfoFrame(pInstance, enVSFmt, enVid4K2KVic, enVid3DStruct);
1748
1749 HDMITX_RETURN();
1750 _HDMITX_SEMAPHORE_RETURN(pInstance);
1751 }
1752
MApi_HDMITx_Set_VS_InfoFrame(HDMITX_VIDEO_VS_FORMAT vs_format,HDMITX_VIDEO_3D_STRUCTURE vs_3d,HDMITX_VIDEO_4k2k_VIC vs_vic)1753 void MApi_HDMITx_Set_VS_InfoFrame(HDMITX_VIDEO_VS_FORMAT vs_format, HDMITX_VIDEO_3D_STRUCTURE vs_3d, HDMITX_VIDEO_4k2k_VIC vs_vic)
1754 {
1755 #ifdef UTOPIA_20
1756 if (pu32HDMITXInst == NULL)
1757 {
1758 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1759 {
1760 printf("MApi_HDMITx_Set_VS_InfoFrame UtopiaOpen HDMITX failed\n");
1761 }
1762 }
1763
1764 stHDMITx_Set_VS_InfoFrame HDMITXArgs;
1765 HDMITXArgs.vs_format = vs_format;
1766 HDMITXArgs.vs_3d = vs_3d;
1767 HDMITXArgs.vs_vic = vs_vic;
1768
1769 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SET_VS_INFOFRAME, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
1770 {
1771 printf("MApi_HDMITx_Set_VS_InfoFrame Obtain HDMITX engine fail\n");
1772 return;
1773 }
1774 else
1775 {
1776 return;
1777 }
1778 #else
1779 MApi_HDMITx_Set_VS_InfoFrame_U2(pu32HDMITXInst, vs_format, vs_3d, vs_vic);
1780 #endif
1781 }
1782
1783
1784 //------------------------------------------------------------------------------
1785 /// @brief This routine config HDMI Tx Module video output timing
1786 /// @param[in] mode output video timing
1787 /// @return None
1788 //-----------------------------------------------------------------------------
MApi_HDMITx_SetVideoOutputTiming_U2(void * pInstance,HDMITX_VIDEO_TIMING mode)1789 void MApi_HDMITx_SetVideoOutputTiming_U2(void* pInstance, HDMITX_VIDEO_TIMING mode)
1790 {
1791 _HDMITX_SEMAPHORE_ENTRY(pInstance);
1792 HDMITX_ENTRY();
1793
1794 #ifdef URANUS
1795 if ((MS_U32)mode > (MS_U32)HDMITX_RES_720x576p)
1796 {
1797 printf("[%s][%d] Unsupport HDMI mode 0x%08x\n", __FUNCTION__, __LINE__, mode);
1798 return;
1799 }
1800 #endif
1801 #ifdef OBERON
1802 if ((MS_U32)mode >= (MS_U32)HDMITX_RES_MAX)
1803 {
1804 printf("[%s][%d] Unsupport HDMI mode 0x%08x\n", __FUNCTION__, __LINE__, mode);
1805 return;
1806 }
1807 #endif
1808
1809 // 3D frame packing only support up to 24-bit color depth
1810 // For HDMI 2.0 spec, 4k2k@60 only support up to 24-bit color depth
1811 #if 0
1812 if ((MDrv_HDMITx_GetColorFormat(pInstance) != E_HDMITX_VIDEO_COLOR_YUV420) &&
1813 ((mode == HDMITX_RES_1920x2205p_24Hz) ||
1814 (mode == HDMITX_RES_1280X1470p_50Hz) ||
1815 (mode == HDMITX_RES_1280X1470p_60Hz) ||
1816 (mode == HDMITX_RES_3840x2160p_50Hz) ||
1817 (mode == HDMITX_RES_3840x2160p_60Hz) ||
1818 (mode == HDMITX_RES_4096x2160p_50Hz) ||
1819 (mode == HDMITX_RES_4096x2160p_60Hz)))
1820 {
1821 if (MDrv_HDMITx_GetDeepColorMode(pInstance) >= E_HDMITX_VIDEO_CD_30Bits)
1822 {
1823 MDrv_HDMITx_SetDeepColorMode(pInstance, E_HDMITX_VIDEO_CD_24Bits);
1824 MDrv_HDMITx_SetHDMITxMode(pInstance, MDrv_HDMITx_GetOutputMode(pInstance));
1825 }
1826 }
1827 #endif
1828
1829 switch (mode)
1830 {
1831 case HDMITX_RES_640x480p:
1832 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_640x480p);
1833 break;
1834
1835 case HDMITX_RES_720x480i:
1836 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_720x480i);
1837 break;
1838
1839 case HDMITX_RES_720x576i:
1840 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_720x576i);
1841 break;
1842
1843 case HDMITX_RES_720x480p:
1844 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_720x480p);
1845 break;
1846
1847 case HDMITX_RES_720x576p:
1848 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_720x576p);
1849 break;
1850
1851 case HDMITX_RES_1280x720p_50Hz:
1852 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1280x720p_50Hz);
1853 break;
1854
1855 case HDMITX_RES_1280x720p_60Hz:
1856 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1280x720p_60Hz);
1857 break;
1858
1859 case HDMITX_RES_1920x1080i_50Hz:
1860 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1920x1080i_50Hz);
1861 break;
1862
1863 case HDMITX_RES_1920x1080i_60Hz:
1864 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1920x1080i_60Hz);
1865 break;
1866
1867 case HDMITX_RES_1920x1080p_24Hz:
1868 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1920x1080p_24Hz);
1869 break;
1870
1871 case HDMITX_RES_1920x1080p_25Hz:
1872 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1920x1080p_25Hz);
1873 break;
1874
1875 case HDMITX_RES_1920x1080p_30Hz:
1876 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1920x1080p_30Hz);
1877 break;
1878
1879 case HDMITX_RES_1920x1080p_50Hz:
1880 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1920x1080p_50Hz);
1881 break;
1882
1883 case HDMITX_RES_1920x1080p_60Hz:
1884 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1920x1080p_60Hz);
1885 break;
1886
1887 case HDMITX_RES_1920x2205p_24Hz:
1888 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1920x2205p_24Hz);
1889 break;
1890
1891 case HDMITX_RES_1280X1470p_50Hz:
1892 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1280x1470p_50Hz);
1893 break;
1894
1895 case HDMITX_RES_1280X1470p_60Hz:
1896 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1280x1470p_60Hz);
1897 break;
1898
1899 case HDMITX_RES_3840x2160p_24Hz:
1900 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_3840x2160p_24Hz);
1901 break;
1902
1903 case HDMITX_RES_3840x2160p_25Hz:
1904 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_3840x2160p_25Hz);
1905 break;
1906
1907 case HDMITX_RES_3840x2160p_30Hz:
1908 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_3840x2160p_30Hz);
1909 break;
1910
1911 case HDMITX_RES_3840x2160p_50Hz:
1912 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_3840x2160p_50Hz);
1913 break;
1914
1915 case HDMITX_RES_3840x2160p_60Hz:
1916 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_3840x2160p_60Hz);
1917 break;
1918
1919 case HDMITX_RES_4096x2160p_24Hz:
1920 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_4096x2160p_24Hz);
1921 break;
1922
1923 case HDMITX_RES_4096x2160p_25Hz:
1924 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_4096x2160p_25Hz);
1925 break;
1926
1927 case HDMITX_RES_4096x2160p_30Hz:
1928 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_4096x2160p_30Hz);
1929 break;
1930
1931 case HDMITX_RES_4096x2160p_50Hz:
1932 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_4096x2160p_50Hz);
1933 break;
1934
1935 case HDMITX_RES_4096x2160p_60Hz:
1936 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_4096x2160p_60Hz);
1937 break;
1938
1939 case HDMITX_RES_1600x1200p_60Hz:
1940 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1600x1200p_60Hz);
1941 break;
1942
1943 case HDMITX_RES_1440x900p_60Hz:
1944 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1440x900p_60Hz);
1945 break;
1946
1947 case HDMITX_RES_1280x1024p_60Hz:
1948 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1280x1024p_60Hz);
1949 break;
1950
1951 case HDMITX_RES_1024x768p_60Hz:
1952 MDrv_HDMITx_SetVideoOutputMode(pInstance, E_HDMITX_RES_1024x768p_60Hz);
1953 break;
1954
1955 default:
1956 printf("[HDMITx]: Error video timing: %d\n", mode);
1957 break;
1958 }
1959
1960 HDMITX_RETURN();
1961 _HDMITX_SEMAPHORE_RETURN(pInstance);
1962 }
1963
MApi_HDMITx_SetVideoOutputTiming(HDMITX_VIDEO_TIMING mode)1964 void MApi_HDMITx_SetVideoOutputTiming(HDMITX_VIDEO_TIMING mode)
1965 {
1966 #ifdef UTOPIA_20
1967 if (pu32HDMITXInst == NULL)
1968 {
1969 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1970 {
1971 printf("MApi_HDMITx_SetVideoOutputTiming UtopiaOpen HDMITX failed\n");
1972 }
1973 }
1974
1975 stHDMITx_SetVideoOutputTiming HDMITXArgs;
1976 HDMITXArgs.mode = mode;
1977
1978 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETVIDEOOUTPUTTIMING, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
1979 {
1980 printf("MApi_HDMITx_SetVideoOutputTiming Obtain HDMITX engine fail\n");
1981 return;
1982 }
1983 else
1984 {
1985 return;
1986 }
1987 #else
1988 MApi_HDMITx_SetVideoOutputTiming_U2(pu32HDMITXInst, mode);
1989 #endif
1990 }
1991
1992 //------------------------------------------------------------------------------
1993 /// @brief This routine config HDMI Tx video output aspect ratio
1994 /// @param[in] out_ar output video aspect ratio
1995 /// @return None
1996 //-----------------------------------------------------------------------------
MApi_HDMITx_SetVideoOutputAsepctRatio_U2(void * pInstance,HDMITX_VIDEO_ASPECT_RATIO out_ar)1997 void MApi_HDMITx_SetVideoOutputAsepctRatio_U2(void* pInstance, HDMITX_VIDEO_ASPECT_RATIO out_ar)
1998 {
1999 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2000 HDMITX_ENTRY();
2001
2002 switch (out_ar)
2003 {
2004 case HDMITX_VIDEO_AR_Reserved:
2005 MDrv_HDMITx_SetVideoOutputAsepctRatio(pInstance, E_HDMITX_VIDEO_AR_Reserved);
2006 break;
2007
2008 case HDMITX_VIDEO_AR_4_3:
2009 MDrv_HDMITx_SetVideoOutputAsepctRatio(pInstance, E_HDMITX_VIDEO_AR_4_3);
2010 break;
2011
2012 case HDMITX_VIDEO_AR_16_9:
2013 MDrv_HDMITx_SetVideoOutputAsepctRatio(pInstance, E_HDMITX_VIDEO_AR_16_9);
2014 break;
2015
2016 case HDMITX_VIDEO_AR_21_9:
2017 MDrv_HDMITx_SetVideoOutputAsepctRatio(pInstance, E_HDMITX_VIDEO_AR_21_9);
2018 break;
2019
2020 default:
2021 printf("[HDMITx]: Error aspect ratio: %d\n", out_ar);
2022 break;
2023 }
2024
2025 HDMITX_RETURN();
2026 _HDMITX_SEMAPHORE_RETURN(pInstance);
2027 }
2028
MApi_HDMITx_SetVideoOutputAsepctRatio(HDMITX_VIDEO_ASPECT_RATIO out_ar)2029 void MApi_HDMITx_SetVideoOutputAsepctRatio(HDMITX_VIDEO_ASPECT_RATIO out_ar)
2030 {
2031 #ifdef UTOPIA_20
2032 if (pu32HDMITXInst == NULL)
2033 {
2034 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2035 {
2036 printf("MApi_HDMITx_SetVideoOutputAsepctRatio UtopiaOpen HDMITX failed\n");
2037 }
2038 }
2039
2040 stHDMITx_SetVideoOutputAsepctRatio HDMITXArgs;
2041 HDMITXArgs.out_ar = out_ar;
2042
2043 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETVIDEOOUTPUTASEPCTRATIO, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2044 {
2045 printf("MApi_HDMITx_SetVideoOutputAsepctRatio Obtain HDMITX engine fail\n");
2046 return;
2047 }
2048 else
2049 {
2050 return;
2051 }
2052 #else
2053 MApi_HDMITx_SetVideoOutputAsepctRatio_U2(pu32HDMITXInst, out_ar);
2054 #endif
2055 }
2056
2057 // HDMI Tx video output Overscan and AFD ratio
MApi_HDMITx_SetVideoOutputOverscan_AFD_U2(void * pInstance,MS_BOOL bflag,HDMITX_VIDEO_SCAN_INFO out_scaninfo,MS_U8 out_afd)2058 void MApi_HDMITx_SetVideoOutputOverscan_AFD_U2(void* pInstance, MS_BOOL bflag, HDMITX_VIDEO_SCAN_INFO out_scaninfo, MS_U8 out_afd)
2059 {
2060 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2061 HDMITX_ENTRY();
2062
2063 switch (out_scaninfo)
2064 {
2065 case HDMITX_VIDEO_SI_NoData:
2066 MDrv_HDMITx_SetVideoOutputOverscan_AFD(pInstance, 0x00, bflag, E_HDMITX_VIDEO_SI_NoData, (MsHDMITX_VIDEO_AFD_RATIO)out_afd);
2067 break;
2068
2069 case HDMITX_VIDEO_SI_Overscanned:
2070 MDrv_HDMITx_SetVideoOutputOverscan_AFD(pInstance, 0x00, bflag, E_HDMITX_VIDEO_SI_Overscanned, (MsHDMITX_VIDEO_AFD_RATIO)out_afd);
2071 break;
2072
2073 case HDMITX_VIDEO_SI_Underscanned:
2074 MDrv_HDMITx_SetVideoOutputOverscan_AFD(pInstance, 0x00, bflag, E_HDMITX_VIDEO_SI_Underscanned, (MsHDMITX_VIDEO_AFD_RATIO)out_afd);
2075 break;
2076
2077 case HDMITX_VIDEO_SI_Reserved:
2078 MDrv_HDMITx_SetVideoOutputOverscan_AFD(pInstance, 0x00, bflag, E_HDMITX_VIDEO_SI_Reserved, (MsHDMITX_VIDEO_AFD_RATIO)out_afd);
2079 break;
2080
2081 default:
2082 printf("[HDMITx]: Error scan information: %d\n", out_scaninfo);
2083 break;
2084 }
2085
2086 HDMITX_RETURN();
2087 _HDMITX_SEMAPHORE_RETURN(pInstance);
2088 }
2089
MApi_HDMITx_SetVideoOutputOverscan_AFD(MS_BOOL bflag,HDMITX_VIDEO_SCAN_INFO out_scaninfo,MS_U8 out_afd)2090 void MApi_HDMITx_SetVideoOutputOverscan_AFD(MS_BOOL bflag, HDMITX_VIDEO_SCAN_INFO out_scaninfo, MS_U8 out_afd)
2091 {
2092 #ifdef UTOPIA_20
2093 if (pu32HDMITXInst == NULL)
2094 {
2095 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2096 {
2097 printf("MApi_HDMITx_SetVideoOutputOverscan_AFD UtopiaOpen HDMITX failed\n");
2098 }
2099 }
2100
2101 stHDMITx_SetVideoOutputOverscan_AFD HDMITXArgs;
2102 HDMITXArgs.bflag = bflag;
2103 HDMITXArgs.out_scaninfo = out_scaninfo;
2104 HDMITXArgs.out_afd = out_afd;
2105
2106 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETVIDEOOUTPUTOVERSCAN_AFD, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2107 {
2108 printf("MApi_HDMITx_SetVideoOutputOverscan_AFD Obtain HDMITX engine fail\n");
2109 //return FALSE;
2110 }
2111 else
2112 {
2113 //return HDMITXArgs.bReturn;
2114 }
2115 #else
2116 MApi_HDMITx_SetVideoOutputOverscan_AFD_U2(pu32HDMITXInst, bflag, out_scaninfo, out_afd);
2117 #endif
2118 }
2119
2120 //*********************//
2121 // Audio //
2122 //*********************//
2123
2124 //------------------------------------------------------------------------------
2125 /// @brief This routine turn on/off HDMI Tx Module audio output
2126 /// @param[in] state output video timing
2127 /// @return None
2128 //-----------------------------------------------------------------------------
MApi_HDMITx_SetAudioOnOff_U2(void * pInstance,MS_BOOL state)2129 void MApi_HDMITx_SetAudioOnOff_U2(void* pInstance, MS_BOOL state)
2130 {
2131 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2132 HDMITX_ENTRY();
2133
2134 MDrv_HDMITx_SetAudioOnOff(pInstance, state);
2135
2136 HDMITX_RETURN();
2137 _HDMITX_SEMAPHORE_RETURN(pInstance);
2138 }
2139
MApi_HDMITx_SetAudioOnOff(MS_BOOL state)2140 void MApi_HDMITx_SetAudioOnOff(MS_BOOL state)
2141 {
2142 #ifdef UTOPIA_20
2143 if (pu32HDMITXInst == NULL)
2144 {
2145 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2146 {
2147 printf("MApi_HDMITx_SetAudioOnOff UtopiaOpen HDMITX failed\n");
2148 }
2149 }
2150
2151 stHDMITx_SetAudioOnOff HDMITXArgs;
2152 HDMITXArgs.state = state;
2153
2154 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETAUDIOONOFF, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2155 {
2156 printf("MApi_HDMITx_SetAudioOnOff Obtain HDMITX engine fail\n");
2157 return;
2158 }
2159 else
2160 {
2161 return;
2162 }
2163 #else
2164 MApi_HDMITx_SetAudioOnOff_U2(pu32HDMITXInst, state);
2165 #endif
2166 }
2167
2168
2169 //------------------------------------------------------------------------------
2170 /// @brief This routine config HDMI Tx Module audio output sampling frequency and channel count
2171 /// @param[in] freq audio frequency
2172 /// @return None
2173 // For Uranus
2174 //-----------------------------------------------------------------------------
MApi_HDMITx_SetAudioFrequency_U2(void * pInstance,HDMITX_AUDIO_FREQUENCY freq)2175 void MApi_HDMITx_SetAudioFrequency_U2(void* pInstance, HDMITX_AUDIO_FREQUENCY freq)
2176 {
2177 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2178 HDMITX_ENTRY();
2179
2180 switch (freq)
2181 {
2182 case HDMITX_AUDIO_FREQ_NO_SIG:
2183 MDrv_HDMITx_SetAudioFrequency(pInstance, E_HDMITX_AUDIO_FREQ_NO_SIG);
2184 break;
2185
2186 case HDMITX_AUDIO_32K:
2187 MDrv_HDMITx_SetAudioFrequency(pInstance, E_HDMITX_AUDIO_32K);
2188 break;
2189
2190 case HDMITX_AUDIO_44K:
2191 MDrv_HDMITx_SetAudioFrequency(pInstance, E_HDMITX_AUDIO_44K);
2192 break;
2193
2194 case HDMITX_AUDIO_48K:
2195 MDrv_HDMITx_SetAudioFrequency(pInstance, E_HDMITX_AUDIO_48K);
2196 break;
2197
2198 case HDMITX_AUDIO_88K:
2199 MDrv_HDMITx_SetAudioFrequency(pInstance, E_HDMITX_AUDIO_88K);
2200 break;
2201
2202 case HDMITX_AUDIO_96K:
2203 MDrv_HDMITx_SetAudioFrequency(pInstance, E_HDMITX_AUDIO_96K);
2204 break;
2205
2206 case HDMITX_AUDIO_176K:
2207 MDrv_HDMITx_SetAudioFrequency(pInstance, E_HDMITX_AUDIO_176K);
2208 break;
2209
2210 case HDMITX_AUDIO_192K:
2211 MDrv_HDMITx_SetAudioFrequency(pInstance, E_HDMITX_AUDIO_192K);
2212 break;
2213
2214 default:
2215 printf("[HDMITx]: Error audio frequency: %d\n", freq);
2216 break;
2217 }
2218
2219 HDMITX_RETURN();
2220 _HDMITX_SEMAPHORE_RETURN(pInstance);
2221
2222 }
2223
MApi_HDMITx_SetAudioFrequency(HDMITX_AUDIO_FREQUENCY freq)2224 void MApi_HDMITx_SetAudioFrequency(HDMITX_AUDIO_FREQUENCY freq)
2225 {
2226 #ifdef UTOPIA_20
2227 if (pu32HDMITXInst == NULL)
2228 {
2229 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2230 {
2231 printf("MApi_HDMITx_SetAudioFrequency UtopiaOpen HDMITX failed\n");
2232 }
2233 }
2234
2235 stHDMITx_SetAudioFrequency HDMITXArgs;
2236 HDMITXArgs.freq = freq;
2237
2238 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETAUDIOFREQUENCY, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2239 {
2240 printf("MApi_HDMITx_SetAudioFrequency Obtain HDMITX engine fail\n");
2241 return;
2242 }
2243 else
2244 {
2245 return;
2246 }
2247 #else
2248 MApi_HDMITx_SetAudioFrequency_U2(pu32HDMITXInst, freq);
2249 #endif
2250 }
2251
MApi_HDMITx_SetVideoOutputOverscan_AFD_II_U02(void * pInstance,MS_BOOL bflag,HDMITX_VIDEO_SCAN_INFO out_scaninfo,MS_U8 out_afd,MS_U8 A0)2252 void MApi_HDMITx_SetVideoOutputOverscan_AFD_II_U02(void* pInstance, MS_BOOL bflag, HDMITX_VIDEO_SCAN_INFO out_scaninfo, MS_U8 out_afd, MS_U8 A0)
2253 {
2254 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2255 HDMITX_ENTRY();
2256
2257 switch (out_scaninfo)
2258 {
2259 case HDMITX_VIDEO_SI_NoData:
2260 MDrv_HDMITx_SetVideoOutputOverscan_AFD(pInstance, A0, bflag, E_HDMITX_VIDEO_SI_NoData, (MsHDMITX_VIDEO_AFD_RATIO)out_afd);
2261 break;
2262
2263 case HDMITX_VIDEO_SI_Overscanned:
2264 MDrv_HDMITx_SetVideoOutputOverscan_AFD(pInstance, A0, bflag, E_HDMITX_VIDEO_SI_Overscanned, (MsHDMITX_VIDEO_AFD_RATIO)out_afd);
2265 break;
2266
2267 case HDMITX_VIDEO_SI_Underscanned:
2268 MDrv_HDMITx_SetVideoOutputOverscan_AFD(pInstance, A0, bflag, E_HDMITX_VIDEO_SI_Underscanned, (MsHDMITX_VIDEO_AFD_RATIO)out_afd);
2269 break;
2270
2271 case HDMITX_VIDEO_SI_Reserved:
2272 MDrv_HDMITx_SetVideoOutputOverscan_AFD(pInstance, A0, bflag, E_HDMITX_VIDEO_SI_Reserved, (MsHDMITX_VIDEO_AFD_RATIO)out_afd);
2273 break;
2274
2275 default:
2276 printf("[HDMITx]: Error scan information: %d\n", out_scaninfo);
2277 break;
2278 }
2279
2280 HDMITX_RETURN();
2281 _HDMITX_SEMAPHORE_RETURN(pInstance);
2282
2283 }
2284
MApi_HDMITx_SetVideoOutputOverscan_AFD_II(MS_BOOL bflag,HDMITX_VIDEO_SCAN_INFO out_scaninfo,MS_U8 out_afd,MS_U8 A0)2285 void MApi_HDMITx_SetVideoOutputOverscan_AFD_II(MS_BOOL bflag, HDMITX_VIDEO_SCAN_INFO out_scaninfo, MS_U8 out_afd, MS_U8 A0 )
2286 {
2287 #ifdef UTOPIA_20
2288 if (pu32HDMITXInst == NULL)
2289 {
2290 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2291 {
2292 printf("MApi_HDMITx_SetVideoOutputOverscan_AFD_II UtopiaOpen HDMITX failed\n");
2293 }
2294 }
2295
2296 stHDMITx_SetVideoOutputOverscan_AFD_II HDMITXArgs;
2297 HDMITXArgs.bflag = bflag;
2298 HDMITXArgs.out_scaninfo = out_scaninfo;
2299 HDMITXArgs.out_afd = out_afd;
2300 HDMITXArgs.A0 = A0;
2301
2302 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETVIDEOOUTPUTOVERSCAN_AFD_II, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2303 {
2304 printf("MApi_HDMITx_SetVideoOutputOverscan_AFD_II Obtain HDMITX engine fail\n");
2305 return;
2306 }
2307 else
2308 {
2309 return;
2310 }
2311 #else
2312 MApi_HDMITx_SetVideoOutputOverscan_AFD_II_U02(pu32HDMITXInst, bflag, out_scaninfo, out_afd, A0);
2313 #endif
2314 }
2315
2316 //------------------------------------------------------------------------------
2317 /// @brief This routine config HDMI Tx Module audio output: sampling frequency, channel count and coding type
2318 /// @param[in] freq audio frequency
2319 /// @param[in] ch audio channel type
2320 /// @param[in] type audio coding type
2321 /// @return None
2322 // For Oberon
2323 //-----------------------------------------------------------------------------
MApi_HDMITx_SetAudioConfiguration_U2(void * pInstance,HDMITX_AUDIO_FREQUENCY freq,HDMITX_AUDIO_CHANNEL_COUNT ch,HDMITX_AUDIO_CODING_TYPE type)2324 void MApi_HDMITx_SetAudioConfiguration_U2(void* pInstance, HDMITX_AUDIO_FREQUENCY freq, HDMITX_AUDIO_CHANNEL_COUNT ch, HDMITX_AUDIO_CODING_TYPE type)
2325 {
2326 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2327 HDMITX_ENTRY();
2328
2329 MsHDMITX_AUDIO_FREQUENCY enAudFreq = E_HDMITX_AUDIO_FREQ_NO_SIG;
2330 MsHDMITX_AUDIO_CHANNEL_COUNT enChCnt = E_HDMITX_AUDIO_CH_2;
2331 MsHDMITX_AUDIO_CODING_TYPE enAudFmt = E_HDMITX_AUDIO_PCM;
2332 MS_BOOL bInvalidArg = FALSE;
2333
2334 //convert enum value
2335 switch (freq)
2336 {
2337 case HDMITX_AUDIO_FREQ_NO_SIG:
2338 enAudFreq = E_HDMITX_AUDIO_FREQ_NO_SIG;
2339 break;
2340
2341 case HDMITX_AUDIO_32K:
2342 enAudFreq = E_HDMITX_AUDIO_32K;
2343 break;
2344
2345 case HDMITX_AUDIO_44K:
2346 enAudFreq = E_HDMITX_AUDIO_44K;
2347 break;
2348
2349 case HDMITX_AUDIO_48K:
2350 enAudFreq = E_HDMITX_AUDIO_48K;
2351 break;
2352
2353 case HDMITX_AUDIO_88K:
2354 enAudFreq = E_HDMITX_AUDIO_88K;
2355 break;
2356
2357 case HDMITX_AUDIO_96K:
2358 enAudFreq = E_HDMITX_AUDIO_96K;
2359 break;
2360
2361 case HDMITX_AUDIO_176K:
2362 enAudFreq = E_HDMITX_AUDIO_176K;
2363 break;
2364
2365 case HDMITX_AUDIO_192K:
2366 enAudFreq = E_HDMITX_AUDIO_192K;
2367 break;
2368
2369 default:
2370 printf("[HDMITx]: Error audio frequency: %d\n", freq);
2371 bInvalidArg = TRUE;
2372 break;
2373 }
2374
2375 switch (ch)
2376 {
2377 case HDMITX_AUDIO_CH_2:
2378 enChCnt = E_HDMITX_AUDIO_CH_2;
2379 break;
2380
2381 case HDMITX_AUDIO_CH_8:
2382 enChCnt = E_HDMITX_AUDIO_CH_8;
2383 break;
2384
2385 default:
2386 printf("[HDMITx]: Error audio channel: %d\n", ch);
2387 bInvalidArg = TRUE;
2388 break;
2389 }
2390
2391 switch (type)
2392 {
2393 case HDMITX_AUDIO_PCM:
2394 enAudFmt = E_HDMITX_AUDIO_PCM;
2395 break;
2396
2397 case HDMITX_AUDIO_NONPCM:
2398 enAudFmt = E_HDMITX_AUDIO_NONPCM;
2399 break;
2400
2401 default:
2402 printf("[HDMITx]: Error audio type: %d\n", type);
2403 bInvalidArg = TRUE;
2404 break;
2405 }
2406
2407 if (bInvalidArg == FALSE)
2408 {
2409 MDrv_HDMITx_SetAudioChCnt(pInstance, enChCnt);
2410 MDrv_HDMITx_SetAudioFmt(pInstance, enAudFmt);
2411 MDrv_HDMITx_SetAudioFrequency(pInstance, enAudFreq);
2412 }
2413
2414 HDMITX_RETURN();
2415 _HDMITX_SEMAPHORE_RETURN(pInstance);
2416 }
2417
MApi_HDMITx_SetAudioConfiguration(HDMITX_AUDIO_FREQUENCY freq,HDMITX_AUDIO_CHANNEL_COUNT ch,HDMITX_AUDIO_CODING_TYPE type)2418 void MApi_HDMITx_SetAudioConfiguration(HDMITX_AUDIO_FREQUENCY freq, HDMITX_AUDIO_CHANNEL_COUNT ch, HDMITX_AUDIO_CODING_TYPE type)
2419 {
2420 #ifdef UTOPIA_20
2421 if (pu32HDMITXInst == NULL)
2422 {
2423 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2424 {
2425 printf("MApi_HDMITx_SetAudioConfiguration UtopiaOpen HDMITX failed\n");
2426 }
2427 }
2428
2429 stHDMITx_SetAudioConfiguration HDMITXArgs;
2430 HDMITXArgs.freq = freq;
2431 HDMITXArgs.ch = ch;
2432 HDMITXArgs.type = type;
2433
2434 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETAUDIOCONFIGURATION, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2435 {
2436 printf("MApi_HDMITx_SetAudioConfiguration Obtain HDMITX engine fail\n");
2437 return;
2438 }
2439 else
2440 {
2441 return;
2442 }
2443 #else
2444 MApi_HDMITx_SetAudioConfiguration_U2(pu32HDMITXInst, freq, ch, type);
2445 #endif
2446 }
2447
2448 //------------------------------------------------------------------------------
2449 /// @brief This routine config HDMI Tx audio mode
2450 /// @param[in] fmt : audio source format select
2451 /// @return None
2452 //-----------------------------------------------------------------------------
MApi_HDMITx_SetAudioSourceFormat_U2(void * pInstance,HDMITX_AUDIO_SOURCE_FORMAT fmt)2453 void MApi_HDMITx_SetAudioSourceFormat_U2(void* pInstance, HDMITX_AUDIO_SOURCE_FORMAT fmt)
2454 {
2455 HDMITX_ENTRY();
2456
2457 MDrv_HDMITx_SetAudioSourceFormat((MsHDMITX_AUDIO_SOURCE_FORMAT) fmt);
2458
2459 HDMITX_RETURN();
2460 }
2461
MApi_HDMITx_SetAudioSourceFormat(HDMITX_AUDIO_SOURCE_FORMAT fmt)2462 void MApi_HDMITx_SetAudioSourceFormat(HDMITX_AUDIO_SOURCE_FORMAT fmt)
2463 {
2464 #ifdef UTOPIA_20
2465 if (pu32HDMITXInst == NULL)
2466 {
2467 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2468 {
2469 printf("MApi_HDMITx_SetAudioSourceFormat UtopiaOpen HDMITX failed\n");
2470 }
2471 }
2472
2473 stHDMITx_SetAudioSourceFormat HDMITXArgs;
2474 HDMITXArgs.fmt = fmt;
2475
2476 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETAUDIOSOURCEFORMAT, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2477 {
2478 printf("MApi_HDMITx_SetAudioSourceFormat Obtain HDMITX engine fail\n");
2479 return;
2480 }
2481 else
2482 {
2483 return;
2484 }
2485 #else
2486 MApi_HDMITx_SetAudioSourceFormat_U2(pu32HDMITXInst, fmt);
2487 #endif
2488 }
2489
2490 //------------------------------------------------------------------------------
2491 /// @brief This routine Set extended colorimetry field of AVIInfoframe
2492 /// @return CTS
2493 //------------------------------------------------------------------------------
MApi_HDMITx_SetAVIInfoExtColorimetry_U2(void * pInstance,HDMITX_AVI_EXTENDED_COLORIMETRY enExtColorimetry,HDMITX_AVI_YCC_QUANT_RANGE enYccQuantRange)2494 MS_BOOL MApi_HDMITx_SetAVIInfoExtColorimetry_U2(void* pInstance, HDMITX_AVI_EXTENDED_COLORIMETRY enExtColorimetry, HDMITX_AVI_YCC_QUANT_RANGE enYccQuantRange)
2495 {
2496 MS_BOOL bRet = FALSE;
2497
2498 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2499 HDMITX_ENTRY();
2500
2501 MsHDMITX_EXT_COLORIMETRY extColorimetry = E_HDMITX_EXT_COLORIMETRY_XVYCC601;
2502 MsHDMITX_YCC_QUANT_RANGE QuantRange = E_HDMITX_YCC_QUANT_LIMIT;
2503 MS_BOOL bInvalidArg = FALSE;
2504
2505 switch (enExtColorimetry)
2506 {
2507 case HDMITX_EXT_COLORIMETRY_XVYCC601:
2508 extColorimetry = E_HDMITX_EXT_COLORIMETRY_XVYCC601;
2509 break;
2510
2511 case HDMITX_EXT_COLORIMETRY_XVYCC709:
2512 extColorimetry = E_HDMITX_EXT_COLORIMETRY_XVYCC709;
2513 break;
2514
2515 case HDMITX_EXT_COLORIMETRY_SYCC601:
2516 extColorimetry = E_HDMITX_EXT_COLORIMETRY_SYCC601;
2517 break;
2518
2519 case HDMITX_EXT_COLORIMETRY_ADOBEYCC601:
2520 extColorimetry = E_HDMITX_EXT_COLORIMETRY_ADOBEYCC601;
2521 break;
2522
2523 case HDMITX_EXT_COLORIMETRY_ADOBERGB:
2524 extColorimetry = E_HDMITX_EXT_COLORIMETRY_ADOBERGB;
2525 break;
2526
2527 case HDMITX_EXT_COLORIMETRY_BT2020CYCC:
2528 extColorimetry = E_HDMITX_EXT_COLORIMETRY_BT2020CYCC;
2529 break;
2530
2531 case HDMITX_EXT_COLORIMETRY_BT2020YCC:
2532 extColorimetry = E_HDMITX_EXT_COLORIMETRY_BT2020YCC;
2533 break;
2534
2535 case HDMITX_EXT_COLORIMETRY_BT2020RGB:
2536 extColorimetry = E_HDMITX_EXT_COLORIMETRY_BT2020RGB;
2537 break;
2538
2539 default:
2540 bInvalidArg = TRUE;
2541 break;
2542 }
2543
2544 switch(enYccQuantRange)
2545 {
2546 case HDMITX_YCC_QUANT_LIMIT:
2547 QuantRange = E_HDMITX_YCC_QUANT_LIMIT;
2548 break;
2549
2550 case HDMITX_YCC_QUANT_FULL:
2551 QuantRange = E_HDMITX_YCC_QUANT_FULL;
2552 break;
2553
2554 case HDMITX_YCC_QUANT_RESERVED:
2555 QuantRange = E_HDMITX_YCC_QUANT_RESERVED;
2556 break;
2557
2558 default:
2559 bInvalidArg = TRUE;
2560 break;
2561 }
2562
2563 if (bInvalidArg == FALSE)
2564 {
2565 MDrv_HDMITx_SetAVIInfoExtColorimetry(pInstance, extColorimetry, QuantRange);
2566 bRet = TRUE;
2567 }
2568 else
2569 {
2570 bRet = FALSE;
2571 }
2572
2573 HDMITX_RETURN();
2574 _HDMITX_SEMAPHORE_RETURN(pInstance);
2575
2576 return bRet;
2577 }
2578
MApi_HDMITx_SetAVIInfoExtColorimetry(HDMITX_AVI_EXTENDED_COLORIMETRY enExtColorimetry,HDMITX_AVI_YCC_QUANT_RANGE enYccQuantRange)2579 MS_BOOL MApi_HDMITx_SetAVIInfoExtColorimetry(HDMITX_AVI_EXTENDED_COLORIMETRY enExtColorimetry, HDMITX_AVI_YCC_QUANT_RANGE enYccQuantRange)
2580 {
2581 #ifdef UTOPIA_20
2582 if (pu32HDMITXInst == NULL)
2583 {
2584 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2585 {
2586 printf("MApi_HDMITx_SetAVIInfoExtColorimetry UtopiaOpen HDMITX failed\n");
2587 }
2588 }
2589
2590 stHDMITx_SetAVIInfoExtColorimetry HDMITXArgs;
2591 HDMITXArgs.enExtColorimetry = enExtColorimetry;
2592 HDMITXArgs.enYccQuantRange = enYccQuantRange;
2593 HDMITXArgs.bReturn = FALSE;
2594
2595 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETAVIINFOEXTCOLORIMETRY, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2596 {
2597 printf("MApi_HDMITx_SetAVIInfoExtColorimetry Obtain HDMITX engine fail\n");
2598 return FALSE;
2599 }
2600 else
2601 {
2602 return HDMITXArgs.bReturn;
2603 }
2604 #else
2605 return MApi_HDMITx_SetAVIInfoExtColorimetry_U2(pu32HDMITXInst, enExtColorimetry, enYccQuantRange);
2606 #endif
2607 }
2608
2609 //------------------------------------------------------------------------------
2610 /// @brief This routine Get Audio CTS value
2611 /// @return CTS
2612 //------------------------------------------------------------------------------
MApi_HDMITx_GetAudioCTS_U2(void * pInstance)2613 MS_U32 MApi_HDMITx_GetAudioCTS_U2(void* pInstance)
2614 {
2615 MS_U32 u32Return;
2616
2617 HDMITX_ENTRY();
2618
2619 u32Return = MDrv_HDMITx_GetAudioCTS();
2620
2621 HDMITX_RETURN();
2622
2623 return u32Return;
2624 }
2625
MApi_HDMITx_GetAudioCTS(void)2626 MS_U32 MApi_HDMITx_GetAudioCTS(void)
2627 {
2628 #ifdef UTOPIA_20
2629 if (pu32HDMITXInst == NULL)
2630 {
2631 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2632 {
2633 printf("MApi_HDMITx_GetAudioCTS UtopiaOpen HDMITX failed\n");
2634 return FALSE;
2635 }
2636 }
2637
2638 stHDMITx_GetAudioCTS HDMITXArgs;
2639 HDMITXArgs.u32Return = 0;
2640
2641 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETAUDIOCTS, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2642 {
2643 printf("MApi_HDMITx_GetAudioCTS Obtain HDMITX engine fail\n");
2644 return FALSE;
2645 }
2646 else
2647 {
2648 return HDMITXArgs.u32Return;
2649 }
2650 #else
2651 return MApi_HDMITx_GetAudioCTS_U2(pu32HDMITXInst);
2652 #endif
2653 }
2654
2655 //------------------------------------------------------------------------------
2656 /// @brief This routine Mute Audio FIFO
2657 /// @param[in] bflag: True: mute audio, False: unmute audio
2658 /// @return None
2659 //------------------------------------------------------------------------------
MApi_HDMITx_MuteAudioFIFO_U2(void * pInstance,MS_BOOL bflag)2660 void MApi_HDMITx_MuteAudioFIFO_U2(void* pInstance, MS_BOOL bflag)
2661 {
2662 HDMITX_ENTRY();
2663
2664 MDrv_HDMITx_MuteAudioFIFO(bflag);
2665
2666 HDMITX_RETURN();
2667 }
2668
MApi_HDMITx_MuteAudioFIFO(MS_BOOL bflag)2669 void MApi_HDMITx_MuteAudioFIFO(MS_BOOL bflag)
2670 {
2671 #ifdef UTOPIA_20
2672 if (pu32HDMITXInst == NULL)
2673 {
2674 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2675 {
2676 printf("MApi_HDMITx_MuteAudioFIFO UtopiaOpen HDMITX failed\n");
2677 }
2678 }
2679
2680 stHDMITx_MuteAudioFIFO HDMITXArgs;
2681 HDMITXArgs.bflag = bflag;
2682
2683 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_MUTEAUDIOFIFO, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2684 {
2685 printf("MApi_HDMITx_MuteAudioFIFO Obtain HDMITX engine fail\n");
2686 return;
2687 }
2688 else
2689 {
2690 return;
2691 }
2692 #else
2693 MApi_HDMITx_MuteAudioFIFO_U2(pu32HDMITXInst, bflag);
2694 #endif
2695 }
2696
2697
2698 //*********************//
2699 // HDCP //
2700 //*********************//
2701
2702 //------------------------------------------------------------------------------
2703 /// @brief This routine get HDCP key
2704 /// @param[in] useinternalkey: TRUE -> from internal, FALSE -> from external, like SPI flash
2705 /// @param[in] data: data point
2706 /// @return None
2707 //------------------------------------------------------------------------------
MApi_HDMITx_GetHdcpKey_U2(void * pInstance,MS_BOOL useinternalkey,MS_U8 * data)2708 void MApi_HDMITx_GetHdcpKey_U2(void* pInstance, MS_BOOL useinternalkey, MS_U8 *data)
2709 {
2710 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2711
2712 MDrv_HDCPTx_GetHdcpKey(pInstance, useinternalkey, data);
2713
2714 _HDMITX_SEMAPHORE_RETURN(pInstance);
2715 }
2716
MApi_HDMITx_GetHdcpKey(MS_BOOL useinternalkey,MS_U8 * data)2717 void MApi_HDMITx_GetHdcpKey(MS_BOOL useinternalkey, MS_U8 *data)
2718 {
2719 #ifdef UTOPIA_20
2720 if (pu32HDMITXInst == NULL)
2721 {
2722 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2723 {
2724 printf("MApi_HDMITx_GetHdcpKey UtopiaOpen HDMITX failed\n");
2725 }
2726 }
2727
2728 stHDMITx_GetHdcpKey HDMITXArgs;
2729 HDMITXArgs.useinternalkey = useinternalkey;
2730 HDMITXArgs.data = data;
2731
2732 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETHDCPKEY, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2733 {
2734 printf("MApi_HDMITx_GetHdcpKey Obtain HDMITX engine fail\n");
2735 return;
2736 }
2737 else
2738 {
2739 return;
2740 }
2741 #else
2742 MApi_HDMITx_GetHdcpKey_U2(pu32HDMITXInst, useinternalkey, data);
2743 #endif
2744 }
2745
2746 //------------------------------------------------------------------------------
2747 /// @brief This routine get HDCP bksv
2748 /// @param[in] data: data point
2749 /// @return None
2750 //------------------------------------------------------------------------------
MApi_HDMITx_GetBksv_U2(void * pInstance,MS_U8 * pdata)2751 MS_BOOL MApi_HDMITx_GetBksv_U2(void* pInstance, MS_U8 *pdata)
2752 {
2753 MS_BOOL bRet;
2754
2755 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2756
2757 bRet = MDrv_HDCPTx_GetBksv(pInstance, pdata); //wilson@kano
2758
2759 _HDMITX_SEMAPHORE_RETURN(pInstance);
2760
2761 return bRet;
2762 }
2763
MApi_HDMITx_GetBksv(MS_U8 * pdata)2764 MS_BOOL MApi_HDMITx_GetBksv(MS_U8 *pdata)
2765 {
2766 #ifdef UTOPIA_20
2767 if (pu32HDMITXInst == NULL)
2768 {
2769 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2770 {
2771 printf("MApi_HDMITx_GetBksv UtopiaOpen HDMITX failed\n");
2772 return FALSE;
2773 }
2774 }
2775
2776 stHDMITx_GetBksv HDMITXArgs;
2777 HDMITXArgs.pdata = pdata;
2778 HDMITXArgs.bReturn = FALSE;
2779
2780 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETBKSV, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2781 {
2782 printf("MApi_HDMITx_GetBksv Obtain HDMITX engine fail\n");
2783 return FALSE;
2784 }
2785 else
2786 {
2787 return HDMITXArgs.bReturn;
2788 }
2789 #else
2790 return MApi_HDMITx_GetBksv_U2(pu32HDMITXInst, pdata);
2791 #endif
2792 }
2793
2794 //------------------------------------------------------------------------------
2795 /// @brief This routine get HDCP aksv
2796 /// @param[in] data: data point
2797 /// @return None
2798 //------------------------------------------------------------------------------
MApi_HDMITx_GetAksv_U2(void * pInstance,MS_U8 * pdata)2799 MS_BOOL MApi_HDMITx_GetAksv_U2(void* pInstance, MS_U8 *pdata)
2800 {
2801 MS_BOOL bRet;
2802
2803 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2804
2805 bRet = MDrv_HDCPTx_GetAksv(pInstance, pdata); //wilson@kano
2806
2807 _HDMITX_SEMAPHORE_RETURN(pInstance);
2808
2809 return bRet;
2810 }
2811
MApi_HDMITx_GetAksv(MS_U8 * pdata)2812 MS_BOOL MApi_HDMITx_GetAksv(MS_U8 *pdata)
2813 {
2814 #ifdef UTOPIA_20
2815 if (pu32HDMITXInst == NULL)
2816 {
2817 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2818 {
2819 printf("MApi_HDMITx_GetAksv UtopiaOpen HDMITX failed\n");
2820 return FALSE;
2821 }
2822 }
2823
2824 stHDMITx_GetBksv HDMITXArgs;
2825 HDMITXArgs.pdata = pdata;
2826 HDMITXArgs.bReturn = FALSE;
2827
2828 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETBKSV, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2829 {
2830 printf("MApi_HDMITx_GetAksv Obtain HDMITX engine fail\n");
2831 return FALSE;
2832 }
2833 else
2834 {
2835 return HDMITXArgs.bReturn;
2836 }
2837 #else
2838 return MApi_HDMITx_GetAksv_U2(pu32HDMITXInst, pdata);
2839 #endif
2840 }
2841
2842 //------------------------------------------------------------------------------
2843 /// @brief This routine turn on/off HDMI Tx Module HDCP encryption
2844 /// @param[in] state ON/OFF state
2845 /// @return None
2846 //-----------------------------------------------------------------------------
MApi_HDMITx_SetHDCPOnOff_U2(void * pInstance,MS_BOOL state)2847 void MApi_HDMITx_SetHDCPOnOff_U2(void* pInstance, MS_BOOL state)
2848 {
2849 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2850
2851 MDrv_HDMITx_SetHDCPOnOff(pInstance, state);
2852
2853 _HDMITX_SEMAPHORE_RETURN(pInstance);
2854 }
2855
MApi_HDMITx_SetHDCPOnOff(MS_BOOL state)2856 void MApi_HDMITx_SetHDCPOnOff(MS_BOOL state)
2857 {
2858 #ifdef UTOPIA_20
2859 if (pu32HDMITXInst == NULL)
2860 {
2861 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2862 {
2863 printf("MApi_HDMITx_SetHDCPOnOff UtopiaOpen HDMITX failed\n");
2864 }
2865 }
2866
2867 stHDMITx_SetHDCPOnOff HDMITXArgs;
2868 HDMITXArgs.state = state;
2869
2870 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETHDCPONOFF, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2871 {
2872 printf("MApi_HDMITx_SetHDCPOnOff Obtain HDMITX engine fail\n");
2873 return;
2874 }
2875 else
2876 {
2877 return;
2878 }
2879 #else
2880 MApi_HDMITx_SetHDCPOnOff_U2(pu32HDMITXInst, state);
2881 #endif
2882 }
2883
2884
2885 //------------------------------------------------------------------------------
2886 /// @brief This routine set HDMI Tx AVMUTE
2887 /// @argument:
2888 /// - bflag: True=> SET_AVMUTE, FALSE=>CLEAR_AVMUTE
2889 ///
2890 /// @return None
2891 //------------------------------------------------------------------------------
MApi_HDMITx_SetAVMUTE_U2(void * pInstance,MS_BOOL bflag)2892 void MApi_HDMITx_SetAVMUTE_U2(void* pInstance, MS_BOOL bflag)
2893 {
2894 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2895
2896 MDrv_HDMITx_SetAVMUTE(pInstance, bflag);
2897
2898 _HDMITX_SEMAPHORE_RETURN(pInstance);
2899 }
2900
MApi_HDMITx_SetAVMUTE(MS_BOOL bflag)2901 void MApi_HDMITx_SetAVMUTE(MS_BOOL bflag)
2902 {
2903 #ifdef UTOPIA_20
2904 if (pu32HDMITXInst == NULL)
2905 {
2906 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2907 {
2908 printf("MApi_HDMITx_SetAVMUTE UtopiaOpen HDMITX failed\n");
2909 }
2910 }
2911
2912 stHDMITx_SetAVMUTE HDMITXArgs;
2913 HDMITXArgs.bflag = bflag;
2914
2915 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETAVMUTE, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2916 {
2917 printf("MApi_HDMITx_SetAVMUTE Obtain HDMITX engine fail\n");
2918 return;
2919 }
2920 else
2921 {
2922 return;
2923 }
2924 #else
2925 MApi_HDMITx_SetAVMUTE_U2(pu32HDMITXInst, bflag);
2926 #endif
2927 }
2928
2929 //------------------------------------------------------------------------------
2930 /// @brief This routine get HDMI Tx AVMUTE status
2931 /// @argument:
2932 ///
2933 /// @return:
2934 /// - True=> SET_AVMUTE, FALSE=>CLEAR_AVMUTE
2935 //------------------------------------------------------------------------------
MApi_HDMITx_GetAVMUTEStatus_U2(void * pInstance)2936 MS_BOOL MApi_HDMITx_GetAVMUTEStatus_U2(void* pInstance)
2937 {
2938 MS_BOOL bRet;
2939
2940 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2941
2942 bRet = MDrv_HDMITx_GetAVMUTEStatus(pInstance); //wilson@kano
2943
2944 _HDMITX_SEMAPHORE_RETURN(pInstance);
2945
2946 return bRet;
2947 }
2948
MApi_HDMITx_GetAVMUTEStatus(void)2949 MS_BOOL MApi_HDMITx_GetAVMUTEStatus(void)
2950 {
2951 #ifdef UTOPIA_20
2952 if (pu32HDMITXInst == NULL)
2953 {
2954 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2955 {
2956 printf("MApi_HDMITx_GetAVMUTEStatus UtopiaOpen HDMITX failed\n");
2957 return FALSE;
2958 }
2959 }
2960
2961 stHDMITx_GetAVMUTEStatus HDMITXArgs;
2962 HDMITXArgs.bReturn = FALSE;
2963
2964 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETAVMUTESTATUS, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
2965 {
2966 printf("MApi_HDMITx_GetAVMUTEStatus Obtain HDMITX engine fail\n");
2967 return FALSE;
2968 }
2969 else
2970 {
2971 return HDMITXArgs.bReturn;
2972 }
2973 #else
2974 return MApi_HDMITx_GetAVMUTEStatus_U2(pu32HDMITXInst);
2975 #endif
2976 }
2977
2978 //------------------------------------------------------------------------------
2979 /// @brief This routine update Revocation key list
2980 /// @argument:
2981 /// - *data: data point
2982 /// - size: amount of revoked key ( size 1 = 1*5 bytes, size 2 = 2*5 bytes)
2983 /// @return
2984 //------------------------------------------------------------------------------
MApi_HDMITx_HDCP_RevocationKey_List_U2(void * pInstance,MS_U8 * data,MS_U16 size)2985 void MApi_HDMITx_HDCP_RevocationKey_List_U2(void* pInstance, MS_U8 *data, MS_U16 size)
2986 {
2987 _HDMITX_SEMAPHORE_ENTRY(pInstance);
2988
2989 MDrv_HDCPTx_GetRevocationKeyList(pInstance, data, size);
2990
2991 _HDMITX_SEMAPHORE_RETURN(pInstance);
2992 }
2993
2994
MApi_HDMITx_HDCP_RevocationKey_List(MS_U8 * data,MS_U16 size)2995 void MApi_HDMITx_HDCP_RevocationKey_List(MS_U8 *data, MS_U16 size)
2996 {
2997 #ifdef UTOPIA_20
2998 if (pu32HDMITXInst == NULL)
2999 {
3000 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3001 {
3002 printf("MApi_HDMITx_HDCP_RevocationKey_List UtopiaOpen HDMITX failed\n");
3003 }
3004 }
3005
3006 stHDMITx_HDCP_RevocationKey_List HDMITXArgs;
3007 HDMITXArgs.data = data;
3008 HDMITXArgs.size = size;
3009
3010 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_HDCP_REVOCATIONKEY_LIST, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3011 {
3012 printf("MApi_HDMITx_HDCP_RevocationKey_List Obtain HDMITX engine fail\n");
3013 return;
3014 }
3015 else
3016 {
3017 return;
3018 }
3019 #else
3020 MApi_HDMITx_HDCP_RevocationKey_List_U2(pu32HDMITXInst, data, size);
3021 #endif
3022 }
3023
3024 //------------------------------------------------------------------------------
3025 /// @brief This routine return revocation key check state
3026 /// @argument:
3027 /// @return:
3028 //------------------------------------------------------------------------------
MApi_HDMITx_HDCP_RevocationKey_Check_U2(void * pInstance)3029 HDMITX_REVOCATION_STATE MApi_HDMITx_HDCP_RevocationKey_Check_U2(void* pInstance)
3030 {
3031 return (HDMITX_REVOCATION_STATE)MDrv_HDCPTx_RevocationKey_Check(pInstance);
3032 }
3033
MApi_HDMITx_HDCP_RevocationKey_Check(void)3034 HDMITX_REVOCATION_STATE MApi_HDMITx_HDCP_RevocationKey_Check(void)
3035 {
3036 #ifdef UTOPIA_20
3037 if (pu32HDMITXInst == NULL)
3038 {
3039 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3040 {
3041 printf("MApi_HDMITx_HDCP_RevocationKey_Check UtopiaOpen HDMITX failed\n");
3042 return FALSE;
3043 }
3044 }
3045
3046 stHDMITx_HDCP_RevocationKey_Check HDMITXArgs;
3047 HDMITXArgs.stReturn = FALSE;
3048
3049 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_HDCP_REVOCATIONKEY_CHECK, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3050 {
3051 printf("MApi_HDMITx_HDCP_RevocationKey_Check Obtain HDMITX engine fail\n");
3052 return FALSE;
3053 }
3054 else
3055 {
3056 return HDMITXArgs.stReturn;
3057 }
3058 #else
3059 return MApi_HDMITx_HDCP_RevocationKey_Check_U2(pu32HDMITXInst);
3060 #endif
3061 }
3062
3063
3064 //------------------------------------------------------------------------------
3065 /// @brief This routine check whether SRM DSA signauter is valid or not
3066 /// @argument:
3067 /// - *data: data point
3068 /// - size: size of SRM list(bytes)
3069 /// @return:
3070 /// Ture: valid, FALSE: invalid
3071 //------------------------------------------------------------------------------
MApi_HDMITx_HDCP_IsSRMSignatureValid_U2(void * pInstance,MS_U8 * data,MS_U32 size)3072 MS_BOOL MApi_HDMITx_HDCP_IsSRMSignatureValid_U2(void* pInstance, MS_U8 *data, MS_U32 size)
3073 {
3074 return MDrv_HDCPTx_IsSRMSignatureValid(data, size);
3075 }
3076
MApi_HDMITx_HDCP_IsSRMSignatureValid(MS_U8 * data,MS_U32 size)3077 MS_BOOL MApi_HDMITx_HDCP_IsSRMSignatureValid(MS_U8 *data, MS_U32 size)
3078 {
3079 #ifdef UTOPIA_20
3080 if (pu32HDMITXInst == NULL)
3081 {
3082 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3083 {
3084 printf("MApi_HDMITx_HDCP_IsSRMSignatureValid UtopiaOpen HDMITX failed\n");
3085 return FALSE;
3086 }
3087 }
3088
3089 stHDMITx_HDCP_IsSRMSignatureValid HDMITXArgs;
3090 HDMITXArgs.data = data;
3091 HDMITXArgs.size = size;
3092 HDMITXArgs.bReturn = FALSE;
3093
3094 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_HDCP_ISSRMSIGNATUREVALID, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3095 {
3096 printf("MApi_HDMITx_HDCP_IsSRMSignatureValid Obtain HDMITX engine fail\n");
3097 return FALSE;
3098 }
3099 else
3100 {
3101 return HDMITXArgs.bReturn;
3102 }
3103 #else
3104 return MApi_HDMITx_HDCP_IsSRMSignatureValid_U2(pu32HDMITXInst, data, size);
3105 #endif
3106 }
3107
3108 //------------------------------------------------------------------------------
3109 /// @brief This routine get HDCP authentication status
3110 /// @argument:
3111 /// @return:
3112 /// E_HDCP_DISABLE = 0, // HDCP disable
3113 /// E_HDCP_FAIL = 1, // HDCP fail
3114 /// E_HDCP_PASS = 2, // HDCP pass
3115 //------------------------------------------------------------------------------
MApi_HDMITx_GetHDCPStatus_U2(void * pInstance)3116 HDMITX_HDCP_STATUS MApi_HDMITx_GetHDCPStatus_U2(void* pInstance)
3117 {
3118 HDMITX_HDCP_STATUS RetVal;
3119
3120 _HDMITX_SEMAPHORE_ENTRY(pInstance);
3121
3122 if (MDrv_HDMITx_GetHdcpEnFlag(pInstance) == FALSE)
3123 {
3124 RetVal = E_HDCP_DISABLE;
3125 }
3126 else
3127 {
3128 if (MDrv_HDCPTx_GetAuthDoneFlag(pInstance) == TRUE)
3129 {
3130 RetVal = E_HDCP_PASS;
3131 }
3132 else
3133 {
3134 RetVal = E_HDCP_FAIL;
3135 }
3136 }
3137
3138 _HDMITX_SEMAPHORE_RETURN(pInstance);
3139
3140 return RetVal;
3141 }
3142
MApi_HDMITx_GetHDCPStatus(void)3143 HDMITX_HDCP_STATUS MApi_HDMITx_GetHDCPStatus(void)
3144 {
3145 #ifdef UTOPIA_20
3146 if (pu32HDMITXInst == NULL)
3147 {
3148 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3149 {
3150 printf("MApi_HDMITx_GetHDCPStatus UtopiaOpen HDMITX failed\n");
3151 return FALSE;
3152 }
3153 }
3154
3155 stHDMITx_GetHDCPStatus HDMITXArgs;
3156 HDMITXArgs.stReturn = FALSE;
3157
3158 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETHDCPSTATUS, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3159 {
3160 printf("MApi_HDMITx_GetHDCPStatus Obtain HDMITX engine fail\n");
3161 return FALSE;
3162 }
3163 else
3164 {
3165 return HDMITXArgs.stReturn;
3166 }
3167 #else
3168 return MApi_HDMITx_GetHDCPStatus_U2(pu32HDMITXInst);
3169 #endif
3170 }
3171
3172 //------------------------------------------------------------------------------
3173 /// @brief This routine will start/stop HDCP authentication
3174 /// @argument: bFlag : TURE for start Authentication, FALSE for stop Authentication
3175 /// @return:
3176 //------------------------------------------------------------------------------
MApi_HDMITx_HDCP_StartAuth_U2(void * pInstance,MS_BOOL bFlag)3177 void MApi_HDMITx_HDCP_StartAuth_U2(void* pInstance, MS_BOOL bFlag)
3178 {
3179 _HDMITX_SEMAPHORE_ENTRY(pInstance);
3180
3181 MDrv_HDCPTx_StartAuth(pInstance, bFlag);
3182
3183 _HDMITX_SEMAPHORE_RETURN(pInstance);
3184 }
3185
MApi_HDMITx_HDCP_StartAuth(MS_BOOL bFlag)3186 void MApi_HDMITx_HDCP_StartAuth(MS_BOOL bFlag)
3187 {
3188 #ifdef UTOPIA_20
3189 if (pu32HDMITXInst == NULL)
3190 {
3191 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3192 {
3193 printf("MApi_HDMITx_HDCP_StartAuth UtopiaOpen HDMITX failed\n");
3194 //return FALSE;
3195 }
3196 }
3197
3198 stHDMITx_HDCP_StartAuth HDMITXArgs;
3199 HDMITXArgs.bFlag = bFlag;
3200
3201 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_HDCP_STARTAUTH, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3202 {
3203 printf("MApi_HDMITx_HDCP_StartAuth Obtain HDMITX engine fail\n");
3204 return;
3205 }
3206 else
3207 {
3208 return;
3209 }
3210 #else
3211 return MApi_HDMITx_HDCP_StartAuth_U2(pu32HDMITXInst, bFlag);
3212 #endif
3213 }
3214
3215 //------------------------------------------------------------------------------
3216 /// @brief This routine get HDCP authentication status
3217 /// @argument:
3218 /// @return:
3219 /// HDMITX_INT_HDCP_DISABLE = 0, // HDCP disable
3220 /// HDMITX_INT_HDCP_FAIL = 1, // HDCP fail
3221 /// HDMITX_INT_HDCP_PASS = 2, // HDCP pass
3222 /// HDMITX_INT_HDCP_PROCESS = 3, // HDCP processing
3223 //------------------------------------------------------------------------------
MApi_HDMITx_GetINTHDCPStatus_U2(void * pInstance)3224 HDMITX_INT_HDCP_STATUS MApi_HDMITx_GetINTHDCPStatus_U2(void* pInstance)
3225 {
3226 HDMITX_INT_HDCP_STATUS ret;
3227
3228 _HDMITX_SEMAPHORE_ENTRY(pInstance);
3229
3230 if (MDrv_HDMITx_GetHdcpEnFlag(pInstance) == FALSE)
3231 {
3232 ret = E_HDCP_DISABLE;
3233 }
3234 else
3235 {
3236 if (MDrv_HDCPTx_GetAuthDoneFlag(pInstance) == TRUE)
3237 {
3238 ret = E_HDCP_PASS;
3239 }
3240 else if (MDrv_HDCPTx_CheckAuthFailFlag(pInstance) == TRUE)
3241 {
3242 ret = E_HDCP_FAIL;
3243 }
3244 else
3245 {
3246 ret = HDMITX_INT_HDCP_PROCESS;
3247 }
3248 }
3249
3250 _HDMITX_SEMAPHORE_RETURN(pInstance);
3251
3252 return ret;
3253 }
3254
MApi_HDMITx_GetINTHDCPStatus(void)3255 HDMITX_INT_HDCP_STATUS MApi_HDMITx_GetINTHDCPStatus(void)
3256 {
3257 #ifdef UTOPIA_20
3258 if (pu32HDMITXInst == NULL)
3259 {
3260 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3261 {
3262 printf("MApi_HDMITx_GetINTHDCPStatus UtopiaOpen HDMITX failed\n");
3263 return FALSE;
3264 }
3265 }
3266
3267 stHDMITx_GetINTHDCPStatus HDMITXArgs;
3268 HDMITXArgs.stReturn = FALSE;
3269
3270 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETINTHDCPSTATUS, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3271 {
3272 printf("MApi_HDMITx_GetINTHDCPStatus Obtain HDMITX engine fail\n");
3273 return FALSE;
3274 }
3275 else
3276 {
3277 return HDMITXArgs.stReturn;
3278 }
3279 #else
3280 return MApi_HDMITx_GetINTHDCPStatus_U2(pu32HDMITXInst);
3281 #endif
3282 }
3283
3284
3285 //------------------------------------------------------------------------------
3286 /// @brief This routine get HDCP authentication pre-status
3287 /// @argument:
3288 /// @return:
3289 /// HDMITX_INT_HDCP_FAIL = 1, // HDCP fail
3290 /// HDMITX_INT_HDCP_PASS = 2, // HDCP pass
3291 /// HDMITX_INT_HDCP_PROCESS = 3, // HDCP processing
3292 //------------------------------------------------------------------------------
MApi_HDMITx_GetHDCP_PreStatus_U2(void * pInstance)3293 HDMITX_INT_HDCP_STATUS MApi_HDMITx_GetHDCP_PreStatus_U2(void* pInstance)
3294 {
3295 HDMITX_INT_HDCP_STATUS ret;
3296
3297 _HDMITX_SEMAPHORE_ENTRY(pInstance);
3298
3299 if (MDrv_HDCPTx_GetAuthDoneFlag(pInstance) == TRUE)
3300 {
3301 ret = HDMITX_INT_HDCP_PASS;
3302 }
3303 else if (MDrv_HDCPTx_GetPreState(pInstance) == HDCP14Tx_SubFSM_AuthFail)
3304 {
3305 ret = HDMITX_INT_HDCP_FAIL;
3306 }
3307 else
3308 {
3309 ret = HDMITX_INT_HDCP_PROCESS;
3310 }
3311
3312 _HDMITX_SEMAPHORE_RETURN(pInstance);
3313
3314 return ret;
3315 }
3316
MApi_HDMITx_GetHDCP_PreStatus(void)3317 HDMITX_INT_HDCP_STATUS MApi_HDMITx_GetHDCP_PreStatus(void)
3318 {
3319 #ifdef UTOPIA_20
3320 if (pu32HDMITXInst == NULL)
3321 {
3322 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3323 {
3324 printf("MApi_HDMITx_GetHDCP_PreStatus UtopiaOpen HDMITX failed\n");
3325 return FALSE;
3326 }
3327 }
3328
3329 stHDMITx_GetHDCP_PreStatus HDMITXArgs;
3330 HDMITXArgs.stReturn = FALSE;
3331
3332 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETHDCP_PRESTATUS, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3333 {
3334 printf("MApi_HDMITx_GetHDCP_PreStatus Obtain HDMITX engine fail\n");
3335 return FALSE;
3336 }
3337 else
3338 {
3339 return HDMITXArgs.stReturn;
3340 }
3341 #else
3342 return MApi_HDMITx_GetHDCP_PreStatus_U2(pu32HDMITXInst);
3343 #endif
3344 }
3345
3346 //------------------------------------------------------------------------------
3347 /// @brief This routine set HDMI video output or blank or encryption while connected with unsupport HDCP Rx
3348 /// @argument:
3349 /// E_UNHDCPRX_NORMAL_OUTPUT = 0, // still display normally
3350 /// E_UNHDCPRX_HDCP_ENCRYPTION = 1, // HDCP encryption to show snow screen
3351 /// E_UNHDCPRX_BLUE_SCREEN = 2, // blue screen
3352 /// @return:
3353 //------------------------------------------------------------------------------
MApi_HDMITx_UnHDCPRxControl_U2(void * pInstance,HDMITX_UNHDCPRX_CONTROL state)3354 void MApi_HDMITx_UnHDCPRxControl_U2(void* pInstance, HDMITX_UNHDCPRX_CONTROL state)
3355 {
3356 _HDMITX_SEMAPHORE_ENTRY(pInstance);
3357
3358 if (state == E_UNHDCPRX_HDCP_ENCRYPTION)
3359 {
3360 MDrv_HDCPTx_SetUnHDCPRxCtrl(pInstance, E_HDCP_ENCRYPTION);
3361 }
3362 else if (state == E_UNHDCPRX_BLUE_SCREEN)
3363 {
3364 MDrv_HDCPTx_SetUnHDCPRxCtrl(pInstance, E_BLUE_SCREEN);
3365 }
3366 else
3367 {
3368 MDrv_HDCPTx_SetUnHDCPRxCtrl(pInstance, E_NORMAL_OUTPUT);
3369 }
3370
3371 _HDMITX_SEMAPHORE_RETURN(pInstance);
3372 }
3373
MApi_HDMITx_UnHDCPRxControl(HDMITX_UNHDCPRX_CONTROL state)3374 void MApi_HDMITx_UnHDCPRxControl(HDMITX_UNHDCPRX_CONTROL state)
3375 {
3376 #ifdef UTOPIA_20
3377 if (pu32HDMITXInst == NULL)
3378 {
3379 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3380 {
3381 printf("MApi_HDMITx_UnHDCPRxControl UtopiaOpen HDMITX failed\n");
3382 }
3383 }
3384
3385 stHDMITx_UnHDCPRxControl HDMITXArgs;
3386 HDMITXArgs.state = state;
3387
3388 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_UNHDCPRXCONTROL, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3389 {
3390 printf("MApi_HDMITx_UnHDCPRxControl Obtain HDMITX engine fail\n");
3391 return;
3392 }
3393 else
3394 {
3395 return;
3396 }
3397 #else
3398 MApi_HDMITx_UnHDCPRxControl_U2(pu32HDMITXInst, state);
3399 #endif
3400 }
3401
3402 //------------------------------------------------------------------------------
3403 /// @brief This routine set HDMI video output or blank or encryption while HDCP authentication fail
3404 /// @argument:
3405 /// E_HDCPRXFail_NORMAL_OUTPUT = 0, // still display normally
3406 /// E_HDCPRXFail_HDCP_ENCRYPTION = 1, // HDCP encryption to show snow screen
3407 /// E_HDCPRXFail_BLUE_SCREEN = 2, // blue screen
3408 /// @return:
3409 //------------------------------------------------------------------------------
MApi_HDMITx_HDCPRxFailControl_U2(void * pInstance,HDMITX_HDCPRXFail_CONTROL state)3410 void MApi_HDMITx_HDCPRxFailControl_U2(void* pInstance, HDMITX_HDCPRXFail_CONTROL state)
3411 {
3412 _HDMITX_SEMAPHORE_ENTRY(pInstance);
3413
3414 if (state == E_HDCPRXFail_HDCP_ENCRYPTION)
3415 {
3416 MDrv_HDCPTx_SetHDCPRxFailCtrl(pInstance, E_HDCP_ENCRYPTION);
3417 }
3418 else if (state == E_HDCPRXFail_BLUE_SCREEN)
3419 {
3420 MDrv_HDCPTx_SetHDCPRxFailCtrl(pInstance, E_BLUE_SCREEN);
3421 }
3422 else
3423 {
3424 MDrv_HDCPTx_SetHDCPRxFailCtrl(pInstance, E_NORMAL_OUTPUT);
3425 }
3426
3427 _HDMITX_SEMAPHORE_RETURN(pInstance);
3428 }
3429
MApi_HDMITx_HDCPRxFailControl(HDMITX_HDCPRXFail_CONTROL state)3430 void MApi_HDMITx_HDCPRxFailControl(HDMITX_HDCPRXFail_CONTROL state)
3431 {
3432 #ifdef UTOPIA_20
3433 if (pu32HDMITXInst == NULL)
3434 {
3435 printf("MApi_HDMITx_HDCPRxFailControl >>>>>>>>>>>> pu32HDMITXInst NULL ");
3436 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3437 {
3438 printf("MApi_HDMITx_HDCPRxFailControl UtopiaOpen HDMITX failed\n");
3439 }
3440 }
3441
3442 stHDMITx_HDCPRxFailControl HDMITXArgs;
3443 HDMITXArgs.state = state;
3444
3445 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_HDCPRXFAILCONTROL, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3446 {
3447 printf("MApi_HDMITx_HDCPRxFailControl Obtain HDMITX engine fail\n");
3448 return;
3449 }
3450 else
3451 {
3452 return;
3453 }
3454 #else
3455 MApi_HDMITx_HDCPRxFailControl_U2(pu32HDMITXInst, state);
3456 #endif
3457 }
3458
3459
3460 // Debug
MApi_HDMITx_GetLibVer_U2(void * pInstance,const MSIF_Version ** ppVersion)3461 MS_BOOL MApi_HDMITx_GetLibVer_U2(void* pInstance, const MSIF_Version **ppVersion)
3462 {
3463 return MDrv_HDMITx_GetLibVer(ppVersion);
3464 }
3465
MApi_HDMITx_GetLibVer(const MSIF_Version ** ppVersion)3466 MS_BOOL MApi_HDMITx_GetLibVer(const MSIF_Version **ppVersion)
3467 {
3468 #ifdef UTOPIA_20
3469 if (pu32HDMITXInst == NULL)
3470 {
3471 printf("MApi_HDMITx_GetLibVer >>>>>>>>>>>> pu32HDMITXInst NULL ");
3472 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3473 {
3474 printf("MApi_HDMITx_GetLibVer UtopiaOpen HDMITX failed\n");
3475 return FALSE;
3476 }
3477 }
3478
3479 stHDMITx_GetLibVer HDMITXArgs;
3480 HDMITXArgs.ppVersion = ppVersion;
3481 HDMITXArgs.bReturn = FALSE;
3482
3483 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETLIBVER, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3484 {
3485 printf("MApi_HDMITx_GetLibVer Obtain HDMITX engine fail\n");
3486 return FALSE;
3487 }
3488 else
3489 {
3490 return HDMITXArgs.bReturn;
3491 }
3492 #else
3493 return MApi_HDMITx_GetLibVer_U2(pu32HDMITXInst, ppVersion);
3494 #endif
3495 }
3496
MApi_HDMITx_GetInfo_U2(void * pInstance,HDMI_TX_INFO * pInfo)3497 MS_BOOL MApi_HDMITx_GetInfo_U2(void* pInstance, HDMI_TX_INFO *pInfo)
3498 {
3499 MS_HDMI_TX_INFO Info;
3500
3501 MDrv_HDMITx_GetInfo(&Info);
3502 pInfo->Reserved = Info.Reserved;
3503
3504 return TRUE;
3505 }
3506
MApi_HDMITx_GetInfo(HDMI_TX_INFO * pInfo)3507 MS_BOOL MApi_HDMITx_GetInfo(HDMI_TX_INFO *pInfo)
3508 {
3509 #ifdef UTOPIA_20
3510 if (pu32HDMITXInst == NULL)
3511 {
3512 printf("MApi_HDMITx_GetInfo >>>>>>>>>>>> pu32HDMITXInst NULL ");
3513 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3514 {
3515 printf("MApi_HDMITx_GetInfo UtopiaOpen HDMITX failed\n");
3516 return FALSE;
3517 }
3518 }
3519
3520 stHDMITx_GetInfo HDMITXArgs;
3521 HDMITXArgs.pInfo = pInfo;
3522 HDMITXArgs.bReturn = FALSE;
3523
3524 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETINFO, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3525 {
3526 printf("MApi_HDMITx_GetInfo Obtain HDMITX engine fail\n");
3527 return FALSE;
3528 }
3529 else
3530 {
3531 return HDMITXArgs.bReturn;
3532 }
3533 #else
3534 return MApi_HDMITx_GetInfo_U2(pu32HDMITXInst, pInfo);
3535 #endif
3536 }
3537
3538
MApi_HDMITx_GetStatus_U2(void * pInstance,HDMI_TX_Status * pStatus)3539 MS_BOOL MApi_HDMITx_GetStatus_U2(void* pInstance, HDMI_TX_Status *pStatus)
3540 {
3541 MS_HDMI_TX_Status Status;
3542 memset(&Status, 0, sizeof(MS_HDMI_TX_Status));
3543
3544 MDrv_HDMITx_GetStatus(&Status);
3545 pStatus->bIsInitialized = Status.bIsInitialized;
3546 pStatus->bIsRunning = Status.bIsRunning;
3547 return TRUE;
3548 }
3549
MApi_HDMITx_GetStatus(HDMI_TX_Status * pStatus)3550 MS_BOOL MApi_HDMITx_GetStatus(HDMI_TX_Status *pStatus)
3551 {
3552 #ifdef UTOPIA_20
3553 if (pu32HDMITXInst == NULL)
3554 {
3555 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3556 {
3557 printf("MApi_HDMITx_GetStatus UtopiaOpen HDMITX failed\n");
3558 return FALSE;
3559 }
3560 }
3561
3562 stHDMITx_GetStatus HDMITXArgs;
3563 HDMITXArgs.pStatus = pStatus;
3564 HDMITXArgs.bReturn = FALSE;
3565
3566 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETSTATUS, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3567 {
3568 printf("MApi_HDMITx_GetStatus Obtain HDMITX engine fail\n");
3569 return FALSE;
3570 }
3571 else
3572 {
3573 return HDMITXArgs.bReturn;
3574 }
3575 #else
3576 return MApi_HDMITx_GetStatus_U2(pu32HDMITXInst, pStatus);
3577 #endif
3578 }
3579
3580 /**
3581 * @brief set debug mask
3582 * @param[in] u16DbgSwitch DEBUG MASK,
3583 * 0x01: Debug HDMITX, 0x02: Debug HDCP
3584 */
MApi_HDMITx_SetDbgLevel_U2(MS_U16 u16DbgSwitch)3585 MS_BOOL MApi_HDMITx_SetDbgLevel_U2(MS_U16 u16DbgSwitch)
3586 {
3587 MS_BOOL bRet = FALSE;
3588
3589 HDMITX_ENTRY();
3590
3591 bRet = MDrv_HDMITx_SetDbgLevel(u16DbgSwitch);
3592
3593 HDMITX_RETURN();
3594
3595 return bRet;
3596 }
3597
MApi_HDMITx_SetDbgLevel(MS_U16 u16DbgSwitch)3598 MS_BOOL MApi_HDMITx_SetDbgLevel(MS_U16 u16DbgSwitch)
3599 {
3600 return MDrv_HDMITx_SetDbgLevel(u16DbgSwitch);
3601
3602 #if 0
3603 if (pu32HDMITXInst == NULL)
3604 {
3605 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3606 {
3607 printf("MApi_HDMITx_SetDbgLevel UtopiaOpen HDMITX failed\n");
3608 return FALSE;
3609 }
3610 }
3611 stHDMITx_SetDbgLevels HDMITXArgs;
3612 HDMITXArgs.u16DbgSwitch = u16DbgSwitch;
3613 HDMITXArgs.bReturn = FALSE;
3614
3615 if(UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETSTATUS, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3616 {
3617 printf("MApi_HDMITx_SetDbgLevel Obtain HDMITX engine fail\n");
3618 return FALSE;
3619 }
3620 else
3621 {
3622 return HDMITXArgs.bReturn;
3623 }
3624 #endif
3625
3626 }
3627
MApi_HDMITx_SetHPDGpioPin_U2(void * pInstance,MS_U8 u8pin)3628 void MApi_HDMITx_SetHPDGpioPin_U2(void* pInstance, MS_U8 u8pin)
3629 {
3630 MDrv_HDMITx_SetHPDGpioPin(u8pin);
3631 }
3632
MApi_HDMITx_SetHPDGpioPin(MS_U8 u8pin)3633 void MApi_HDMITx_SetHPDGpioPin(MS_U8 u8pin)
3634 {
3635 #ifdef UTOPIA_20
3636 if (pu32HDMITXInst == NULL)
3637 {
3638 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3639 {
3640 printf("MApi_HDMITx_SetHPDGpioPin UtopiaOpen HDMITX failed\n");
3641 }
3642 }
3643
3644 stHDMITx_SetHPDGpioPin HDMITXArgs;
3645 HDMITXArgs.u8pin= u8pin;
3646
3647 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETHPDGPIOPIN, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3648 {
3649 printf("MApi_HDMITx_SetHPDGpioPin Obtain HDMITX engine fail\n");
3650 return;
3651 }
3652 else
3653 {
3654 return;
3655 }
3656 #else
3657 MApi_HDMITx_SetHPDGpioPin_U2(pu32HDMITXInst, u8pin);
3658 #endif
3659 }
3660
3661
3662 // Adjust HDMITx analog setting for HDMI test or compliant issue
MApi_HDMITx_AnalogTuning_U2(void * pInstance,HDMITX_ANALOG_TUNING * pInfo)3663 void MApi_HDMITx_AnalogTuning_U2(void* pInstance, HDMITX_ANALOG_TUNING *pInfo)
3664 {
3665 _HDMITX_SEMAPHORE_ENTRY(pInstance);
3666
3667 MDrv_HDMITx_AnalogTuning(pInstance, (drvHDMITX_ANALOG_TUNING*)pInfo);
3668
3669 _HDMITX_SEMAPHORE_RETURN(pInstance);
3670 }
3671
MApi_HDMITx_AnalogTuning(HDMITX_ANALOG_TUNING * pInfo)3672 void MApi_HDMITx_AnalogTuning(HDMITX_ANALOG_TUNING *pInfo)
3673 {
3674 #ifdef UTOPIA_20
3675 if (pu32HDMITXInst == NULL)
3676 {
3677 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3678 {
3679 printf("MApi_HDMITx_AnalogTuning UtopiaOpen HDMITX failed\n");
3680 }
3681 }
3682
3683 stHDMITx_AnalogTuning HDMITXArgs;
3684 HDMITXArgs.pInfo = pInfo;
3685
3686 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_ANALOGTUNING, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3687 {
3688 printf("MApi_HDMITx_AnalogTuning Obtain HDMITX engine fail\n");
3689 return;
3690 }
3691 else
3692 {
3693 return;
3694 }
3695 #else
3696 MApi_HDMITx_AnalogTuning_U2(pu32HDMITXInst,pInfo);
3697 #endif
3698 }
3699
3700
3701 //------------------------------------------------------------------------------
3702 /// @brief This routine turn on/off HDMI Tx output force mode
3703 /// @argument:
3704 /// - bflag: TRUE: force mode, FALSE: auto mode
3705 /// - output_mode: HDMITX_DVI: DVI, HDMITX_HDMI: HDMI
3706 /// @return None
3707 //------------------------------------------------------------------------------
MApi_HDMITx_ForceHDMIOutputMode_U2(void * pInstance,MS_BOOL bflag,HDMITX_OUTPUT_MODE output_mode)3708 void MApi_HDMITx_ForceHDMIOutputMode_U2(void* pInstance, MS_BOOL bflag, HDMITX_OUTPUT_MODE output_mode)
3709 {
3710 _HDMITX_SEMAPHORE_ENTRY(pInstance);
3711
3712 MDrv_HDMITx_ForceHDMIOutputMode(pInstance, bflag, (MsHDMITX_OUTPUT_MODE)output_mode);
3713
3714 _HDMITX_SEMAPHORE_RETURN(pInstance);
3715 }
3716
MApi_HDMITx_ForceHDMIOutputMode(MS_BOOL bflag,HDMITX_OUTPUT_MODE output_mode)3717 void MApi_HDMITx_ForceHDMIOutputMode(MS_BOOL bflag, HDMITX_OUTPUT_MODE output_mode)
3718 {
3719 #ifdef UTOPIA_20
3720 if (pu32HDMITXInst == NULL)
3721 {
3722 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3723 {
3724 printf("MApi_HDMITx_ForceHDMIOutputMode UtopiaOpen HDMITX failed\n");
3725 }
3726 }
3727
3728 stHDMITx_ForceHDMIOutputMode HDMITXArgs;
3729 HDMITXArgs.bflag = bflag;
3730 HDMITXArgs.output_mode = output_mode;
3731
3732 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_FORCEHDMIOUTPUTMODE, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3733 {
3734 printf("MApi_HDMITx_ForceHDMIOutputMode Obtain HDMITX engine fail\n");
3735 return;
3736 }
3737 else
3738 {
3739 return;
3740 }
3741 #else
3742 MApi_HDMITx_ForceHDMIOutputMode_U2(pu32HDMITXInst, bflag, output_mode);
3743 #endif
3744 }
3745
3746
3747 //------------------------------------------------------------------------------
3748 /// @brief This routine turn on/off HDMI Tx output force color format
3749 /// @argument:
3750 /// - bflag: TRUE: force output color format, FALSE: auto mode
3751 /// - output_mode: HDMITX_VIDEO_COLOR_RGB444: RGB, HDMITX_VIDEO_COLOR_YUV444: YUV
3752 /// @return Ture: Set force output color format successfully
3753 /// FALSE: Fail to set force output color format
3754 //------------------------------------------------------------------------------
MApi_HDMITx_ForceHDMIOutputColorFormat_U2(void * pInstance,MS_BOOL bflag,HDMITX_VIDEO_COLOR_FORMAT output_color)3755 MS_BOOL MApi_HDMITx_ForceHDMIOutputColorFormat_U2(void* pInstance, MS_BOOL bflag, HDMITX_VIDEO_COLOR_FORMAT output_color)
3756 {
3757 return MDrv_HDMITx_ForceHDMIOutputColorFormat(pInstance, bflag, (MsHDMITX_VIDEO_COLOR_FORMAT)output_color);
3758 }
3759
MApi_HDMITx_ForceHDMIOutputColorFormat(MS_BOOL bflag,HDMITX_VIDEO_COLOR_FORMAT output_color)3760 MS_BOOL MApi_HDMITx_ForceHDMIOutputColorFormat(MS_BOOL bflag, HDMITX_VIDEO_COLOR_FORMAT output_color)
3761 {
3762 #ifdef UTOPIA_20
3763 if (pu32HDMITXInst == NULL)
3764 {
3765 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3766 {
3767 printf("MApi_HDMITx_ForceHDMIOutputColorFormat UtopiaOpen HDMITX failed\n");
3768 return FALSE;
3769 }
3770 }
3771
3772 stHDMITx_ForceHDMIOutputColorFormat HDMITXArgs;
3773 HDMITXArgs.bflag = bflag;
3774 HDMITXArgs.output_color = output_color;
3775 HDMITXArgs.bReturn = FALSE;
3776
3777 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_FORCEHDMIOUTPUTCOLORFORMAT, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3778 {
3779 printf("MApi_HDMITx_ForceHDMIOutputColorFormat Obtain HDMITX engine fail\n");
3780 return FALSE;
3781 }
3782 else
3783 {
3784 return HDMITXArgs.bReturn;
3785 }
3786 #else
3787 return MApi_HDMITx_ForceHDMIOutputColorFormat_U2(pu32HDMITXInst, bflag, output_color);
3788 #endif
3789 }
3790
3791
3792 //------------------------------------------------------------------------------
3793 /// @brief This routine set flag to mask register write for special case \n
3794 /// e.g. MBoot to APP with logo display
3795 /// @argument:
3796 /// - bFlag: TRUE: Mask register write, FALSE: not Mask
3797 /// @return None
3798 //------------------------------------------------------------------------------
MApi_HDMITx_DisableRegWrite_U2(void * pInstance,MS_BOOL bFlag)3799 void MApi_HDMITx_DisableRegWrite_U2(void* pInstance, MS_BOOL bFlag)
3800 {
3801 MDrv_HDMITx_DisableRegWrite(bFlag);
3802 }
3803
MApi_HDMITx_DisableRegWrite(MS_BOOL bFlag)3804 void MApi_HDMITx_DisableRegWrite(MS_BOOL bFlag)
3805 {
3806 #ifdef UTOPIA_20
3807 if (pu32HDMITXInst == NULL)
3808 {
3809 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3810 {
3811 printf("MApi_HDMITx_DisableRegWrite UtopiaOpen HDMITX failed\n");
3812 }
3813 }
3814
3815 stHDMITx_DisableRegWrite HDMITXArgs;
3816 HDMITXArgs.bFlag = bFlag;
3817
3818 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_DISABLEREGWRITE, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3819 {
3820 printf("MApi_HDMITx_DisableRegWrite Obtain HDMITX engine fail\n");
3821 return;
3822 }
3823 else
3824 {
3825 return;
3826 }
3827 #else
3828 MApi_HDMITx_DisableRegWrite_U2(pu32HDMITXInst, bFlag);
3829 #endif
3830 }
3831
3832
3833
3834 //*********************//
3835 // CEC //
3836 //*********************//
3837
3838 //------------------------------------------------------------------------------
3839 /// @brief This routine get EDID physical address
3840 /// @argument:
3841 /// - pdata: two bytes of physical address, ie. 1.0.0.0 => 0x10 0x00
3842 /// @return None
3843 //------------------------------------------------------------------------------
MApi_HDMITx_GetEDIDPhyAdr_U2(void * pInstance,MS_U8 * pdata)3844 void MApi_HDMITx_GetEDIDPhyAdr_U2(void* pInstance, MS_U8 *pdata)
3845 {
3846 _HDMITX_SEMAPHORE_ENTRY(pInstance);
3847
3848 MDrv_HDMITx_GetEDIDPhyAdr(pInstance, pdata);
3849
3850 _HDMITX_SEMAPHORE_RETURN(pInstance);
3851 }
3852
MApi_HDMITx_GetEDIDPhyAdr(MS_U8 * pdata)3853 void MApi_HDMITx_GetEDIDPhyAdr(MS_U8 *pdata)
3854 {
3855 #ifdef UTOPIA_20
3856 if (pu32HDMITXInst == NULL)
3857 {
3858 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3859 {
3860 printf("MApi_HDMITx_GetEDIDPhyAdr UtopiaOpen HDMITX failed\n");
3861 }
3862 }
3863
3864 stHDMITx_GetEDIDPhyAdr HDMITXArgs;
3865 HDMITXArgs.pdata = pdata;
3866
3867 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETEDIDPHYADR, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3868 {
3869 printf("MApi_HDMITx_GetEDIDPhyAdr Obtain HDMITX engine fail\n");
3870 return;
3871 }
3872 else
3873 {
3874 return;
3875 }
3876 #else
3877 MApi_HDMITx_GetEDIDPhyAdr_U2(pu32HDMITXInst, pdata);
3878 #endif
3879 }
3880
3881
3882 //------------------------------------------------------------------------------
3883 /// @brief This routine turn on/off HDMI Tx CEC
3884 /// @argument:
3885 /// - bflag: TRUE: Enable, FALSE: Disable
3886 /// @return None
3887 //------------------------------------------------------------------------------
MApi_HDMITx_SetCECOnOff_U2(void * pInstance,MS_BOOL bflag)3888 void MApi_HDMITx_SetCECOnOff_U2(void* pInstance, MS_BOOL bflag)
3889 {
3890 _HDMITX_SEMAPHORE_ENTRY(pInstance);
3891
3892 MDrv_HDMITx_SetCECOnOff(pInstance, bflag);
3893
3894 _HDMITX_SEMAPHORE_RETURN(pInstance);
3895 }
3896
MApi_HDMITx_SetCECOnOff(MS_BOOL bflag)3897 void MApi_HDMITx_SetCECOnOff(MS_BOOL bflag)
3898 {
3899 #ifdef UTOPIA_20
3900 if (pu32HDMITXInst == NULL)
3901 {
3902 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3903 {
3904 printf("MApi_HDMITx_SetCECOnOff UtopiaOpen HDMITX failed\n");
3905 }
3906 }
3907
3908 stHDMITx_SetCECOnOff HDMITXArgs;
3909 HDMITXArgs.bflag = bflag;
3910
3911 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETCECONOFF, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3912 {
3913 printf("MApi_HDMITx_SetCECOnOff Obtain HDMITX engine fail\n");
3914 return;
3915 }
3916 else
3917 {
3918 return;
3919 }
3920 #else
3921 MApi_HDMITx_SetCECOnOff_U2(pu32HDMITXInst, bflag);
3922 #endif
3923 }
3924
3925
3926 //------------------------------------------------------------------------------
3927 /// @brief This routine get HDMI Tx CEC On/Off status
3928 /// @argument: None
3929 /// @return: CEC On/Off status
3930 //------------------------------------------------------------------------------
MApi_HDMITx_GetCECStatus_U2(void * pInstance)3931 MS_BOOL MApi_HDMITx_GetCECStatus_U2(void* pInstance)
3932 {
3933 return MDrv_HDMITx_GetCECStatus(pInstance);
3934 }
3935
MApi_HDMITx_GetCECStatus(void)3936 MS_BOOL MApi_HDMITx_GetCECStatus(void)
3937 {
3938 #ifdef UTOPIA_20
3939 if (pu32HDMITXInst == NULL)
3940 {
3941 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3942 {
3943 printf("MApi_HDMITx_GetCECStatus UtopiaOpen HDMITX failed\n");
3944 return FALSE;
3945 }
3946 }
3947
3948 stHDMITx_GetCECStatus HDMITXArgs;
3949 HDMITXArgs.bReturn = FALSE;
3950
3951 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETCECSTATUS, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
3952 {
3953 printf("MApi_HDMITx_GetCECStatus Obtain HDMITX engine fail\n");
3954 return FALSE;
3955 }
3956 else
3957 {
3958 return HDMITXArgs.bReturn;
3959 }
3960 #else
3961 return MApi_HDMITx_GetCECStatus_U2(pu32HDMITXInst);
3962 #endif
3963 }
3964
3965 //------------------------------------------------------------------------------
3966 /// @brief This routine get EDID from reciver
3967 /// @argument: None
3968 /// @return: read status
3969 //------------------------------------------------------------------------------
MApi_HDMITx_EdidChecking_U2(void * pInstance)3970 MS_BOOL MApi_HDMITx_EdidChecking_U2(void* pInstance)
3971 {
3972 MS_BOOL bRet;
3973
3974 _HDMITX_SEMAPHORE_ENTRY(pInstance);
3975 HDMITX_ENTRY();
3976
3977 if (MDrv_HDMITx_GetRxStatus() == TRUE)
3978 {
3979 bRet = MDrv_HDMITx_EdidChecking(pInstance);
3980 }
3981 else
3982 bRet = FALSE;
3983
3984 HDMITX_RETURN();
3985 _HDMITX_SEMAPHORE_RETURN(pInstance);
3986
3987 return bRet;
3988 }
3989
3990
MApi_HDMITx_EdidChecking(void)3991 MS_BOOL MApi_HDMITx_EdidChecking(void)
3992 {
3993 #ifdef UTOPIA_20
3994 if (pu32HDMITXInst == NULL)
3995 {
3996 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3997 {
3998 printf("MApi_HDMITx_SetHPDGpioPin UtopiaOpen HDMITX failed\n");
3999 return FALSE;
4000 }
4001 }
4002
4003 stHDMITx_EdidChecking HDMITXArgs;
4004 HDMITXArgs.bReturn = FALSE;
4005
4006 if(UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_EDIDCHECKING, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4007 {
4008 printf("MApi_HDMITx_EdidChecking Obtain HDMITX engine fail\n");
4009 return FALSE;
4010 }
4011 else
4012 {
4013 return HDMITXArgs.bReturn;
4014 }
4015 #else
4016 return MApi_HDMITx_EdidChecking_U2(pu32HDMITXInst);
4017 #endif
4018 }
4019
4020 //*********************//
4021 // RxBypassMode //
4022 //*********************//
4023 //------------------------------------------------------------------------------
4024 /// @brief This routine set Rx Bypass Mode
4025 /// @argument: freq: Input Freq; bflag:DDC/CEC/ARC bypass
4026 /// @return: setting status.
4027 //------------------------------------------------------------------------------
MApi_HDMITx_RxBypass_Mode_U2(void * pInstance,HDMITX_INPUT_FREQ freq,MS_BOOL bflag)4028 MS_BOOL MApi_HDMITx_RxBypass_Mode_U2(void* pInstance, HDMITX_INPUT_FREQ freq, MS_BOOL bflag)
4029 {
4030 return MDrv_HDMITx_RxBypass_Mode(pInstance, (MsHDMITX_INPUT_FREQ) freq, bflag);
4031 }
4032
MApi_HDMITx_RxBypass_Mode(HDMITX_INPUT_FREQ freq,MS_BOOL bflag)4033 MS_BOOL MApi_HDMITx_RxBypass_Mode(HDMITX_INPUT_FREQ freq, MS_BOOL bflag)
4034 {
4035 #ifdef UTOPIA_20
4036 if (pu32HDMITXInst == NULL)
4037 {
4038 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4039 {
4040 printf("MApi_HDMITx_RxBypass_Mode UtopiaOpen HDMITX failed\n");
4041 return FALSE;
4042 }
4043 }
4044
4045 stHDMITx_RxBypass_Mode HDMITXArgs;
4046 HDMITXArgs.freq = freq;
4047 HDMITXArgs.bflag = bflag;
4048 HDMITXArgs.bReturn = FALSE;
4049
4050 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_RXBYPASS_MODE, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4051 {
4052 printf("MApi_HDMITx_RxBypass_Mode Obtain HDMITX engine fail\n");
4053 return FALSE;
4054 }
4055 else
4056 {
4057 return HDMITXArgs.bReturn;
4058 }
4059 #else
4060 return MApi_HDMITx_RxBypass_Mode_U2(pu32HDMITXInst, freq, bflag);
4061 #endif
4062 }
4063
4064 //------------------------------------------------------------------------------
4065 /// @brief This routine disable Rx Bypass Mode
4066 /// @return: setting status.
4067 //------------------------------------------------------------------------------
MApi_HDMITx_Disable_RxBypass_U2(void * pInstance)4068 MS_BOOL MApi_HDMITx_Disable_RxBypass_U2(void* pInstance)
4069 {
4070 return MDrv_HDMITx_Disable_RxBypass(pInstance);
4071 }
4072
MApi_HDMITx_Disable_RxBypass(void)4073 MS_BOOL MApi_HDMITx_Disable_RxBypass(void)
4074 {
4075 #ifdef UTOPIA_20
4076 if (pu32HDMITXInst == NULL)
4077 {
4078 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4079 {
4080 printf("MApi_HDMITx_Disable_RxBypass UtopiaOpen HDMITX failed\n");
4081 return FALSE;
4082 }
4083 }
4084
4085 stHDMITx_Disable_RxBypass HDMITXArgs;
4086 HDMITXArgs.bReturn = FALSE;
4087
4088 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_DISABLE_RXBYPASS, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4089 {
4090 printf("MApi_HDMITx_Disable_RxBypass Obtain HDMITX engine fail\n");
4091 return FALSE;
4092 }
4093 else
4094 {
4095 return HDMITXArgs.bReturn;
4096 }
4097 #else
4098 return MApi_HDMITx_Disable_RxBypass_U2(pu32HDMITXInst);
4099 #endif
4100 }
4101
4102 //------------------------------------------------------------------------------
4103 /// @brief This routine to set the time interval from sent aksv to R0.
4104 /// The HDCP Transmitter must not read the R0' value sooner than 100ms after writing Aksv.
4105 /// @return: setting status.
4106 //------------------------------------------------------------------------------
MApi_HDMITx_SetAksv2R0Interval_U2(void * pInstance,MS_U32 u32Interval)4107 MS_BOOL MApi_HDMITx_SetAksv2R0Interval_U2(void* pInstance, MS_U32 u32Interval)
4108 {
4109 MDrv_HDCPTx_SetAksv2R0Interval(u32Interval);
4110
4111 return TRUE;
4112 }
4113
MApi_HDMITx_SetAksv2R0Interval(MS_U32 u32Interval)4114 MS_BOOL MApi_HDMITx_SetAksv2R0Interval(MS_U32 u32Interval)
4115 {
4116 #ifdef UTOPIA_20
4117 if (pu32HDMITXInst == NULL)
4118 {
4119 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4120 {
4121 printf("MApi_HDMITx_SetAksv2R0Interval UtopiaOpen HDMITX failed\n");
4122 return FALSE;
4123 }
4124 }
4125
4126 stHDMITx_SetAksv2R0Interval HDMITXArgs;
4127 HDMITXArgs.u32Interval = u32Interval;
4128 HDMITXArgs.bReturn = FALSE;
4129
4130 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETAKSV2R0INTERVAL, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4131 {
4132 printf("MApi_HDMITx_SetAksv2R0Interval Obtain HDMITX engine fail\n");
4133 return FALSE;
4134 }
4135 else
4136 {
4137 return HDMITXArgs.bReturn;
4138 }
4139 #else
4140 return MApi_HDMITx_SetAksv2R0Interval_U2(pu32HDMITXInst, u32Interval);
4141 #endif
4142 }
4143
4144
4145
4146
4147 //------------------------------------------------------------------------------
4148 /// @brief This routine to Get if Rx support HDCP
4149 /// @return: setting status.
4150 //------------------------------------------------------------------------------
MApi_HDMITx_IsHDCPRxValid_U2(void * pInstance)4151 MS_BOOL MApi_HDMITx_IsHDCPRxValid_U2(void* pInstance)
4152 {
4153 MS_BOOL bRet;
4154
4155 _HDMITX_SEMAPHORE_ENTRY(pInstance);
4156
4157 bRet = MDrv_HDCPTx_GetRxValid(pInstance);
4158
4159 _HDMITX_SEMAPHORE_RETURN(pInstance);
4160
4161 return bRet;
4162 }
4163
MApi_HDMITx_IsHDCPRxValid(void)4164 MS_BOOL MApi_HDMITx_IsHDCPRxValid(void)
4165 {
4166 #ifdef UTOPIA_20
4167 if (pu32HDMITXInst == NULL)
4168 {
4169 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4170 {
4171 printf("MApi_HDMITx_IsHDCPRxValid UtopiaOpen HDMITX failed\n");
4172 return FALSE;
4173 }
4174 }
4175
4176 stHDMITx_IsHDCPRxValid HDMITXArgs;
4177 HDMITXArgs.bReturn = FALSE;
4178
4179 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_ISRXVALID, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4180 {
4181 printf("MApi_HDMITx_IsHDCPRxValid Obtain HDMITX engine fail\n");
4182 return FALSE;
4183 }
4184 else
4185 {
4186 return HDMITXArgs.bReturn;
4187 }
4188 #else
4189 return MApi_HDMITx_IsHDCPRxValid_U2(pu32HDMITXInst);
4190 #endif
4191 }
4192
4193
4194
4195 //******************************************************************************
4196 /// API for Query HDMITx Capability
4197 /// @param eCapType \b IN: Capability type
4198 /// @param pRet \b OUT: return value
4199 /// @param ret_size \b IN: input structure size
4200 /// @return MS_BOOL - Success
4201 //******************************************************************************
MApi_HDMITx_GetChipCaps_U2(void * pInstance,EN_HDMITX_CAPS eCapType,MS_U32 * pRet,MS_U32 ret_size)4202 MS_BOOL MApi_HDMITx_GetChipCaps_U2(void* pInstance, EN_HDMITX_CAPS eCapType, MS_U32* pRet, MS_U32 ret_size)
4203 {
4204
4205 MS_BOOL bRet = TRUE;
4206 switch(eCapType)
4207 {
4208 case E_HDMITX_CAP_SUPPORT_DVI:
4209 *pRet = (MS_U32)MDrv_HDMITx_IsSupportDVIMode();
4210 break;
4211 default:
4212 printf("[%s]not support HDMITx capability case: %d\n",__FUNCTION__, eCapType);
4213 bRet = FALSE;
4214 }
4215
4216 return bRet;
4217 }
4218
MApi_HDMITx_GetChipCaps(EN_HDMITX_CAPS eCapType,MS_U32 * pRet,MS_U32 ret_size)4219 MS_BOOL MApi_HDMITx_GetChipCaps(EN_HDMITX_CAPS eCapType, MS_U32* pRet, MS_U32 ret_size)
4220 {
4221 #ifdef UTOPIA_20
4222 if (pu32HDMITXInst == NULL)
4223 {
4224 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4225 {
4226 printf("MApi_HDMITx_GetChipCaps UtopiaOpen HDMITX failed\n");
4227 return FALSE;
4228 }
4229 }
4230
4231 stHDMITx_GetChipCaps HDMITXArgs;
4232 HDMITXArgs.eCapType = eCapType;
4233 HDMITXArgs.pRet = pRet;
4234 HDMITXArgs.ret_size = ret_size;
4235 HDMITXArgs.bReturn = FALSE;
4236
4237 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETCHIPCAPS, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4238 {
4239 printf("MApi_HDMITx_GetChipCaps Obtain HDMITX engine fail\n");
4240 return FALSE;
4241 }
4242 else
4243 {
4244 return HDMITXArgs.bReturn;
4245 }
4246 #else
4247 return MApi_HDMITx_GetChipCaps_U2(pu32HDMITXInst, eCapType, pRet, ret_size);
4248 #endif
4249 }
4250
4251
4252
4253 //******************************************************************************
4254 /// API for speed up resume process from power saving mode
4255 /// @param EN_POWER_MODE \b IN: power state
4256 //******************************************************************************
MApi_HDMITx_SetPowerState_U2(void * pInstance,EN_POWER_MODE u16PowerState)4257 MS_U32 MApi_HDMITx_SetPowerState_U2(void* pInstance, EN_POWER_MODE u16PowerState)
4258 {
4259 MS_U32 u32RetVal;
4260
4261 _HDMITX_SEMAPHORE_ENTRY(pInstance);
4262
4263 u32RetVal= MDrv_HDMITx_SetPowerState(pInstance, u16PowerState);
4264
4265 _HDMITX_SEMAPHORE_RETURN(pInstance);
4266
4267 return u32RetVal;
4268 }
4269
MApi_HDMITx_SetPowerState(EN_POWER_MODE u16PowerState)4270 MS_U32 MApi_HDMITx_SetPowerState(EN_POWER_MODE u16PowerState)
4271 {
4272 #ifdef UTOPIA_20
4273 if (pu32HDMITXInst == NULL)
4274 {
4275 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4276 {
4277 printf("MApi_HDMITx_SetPowerState UtopiaOpen HDMITX failed\n");
4278 return FALSE;
4279 }
4280 }
4281
4282 stHDMITx_SetPowerState HDMITXArgs;
4283 HDMITXArgs.u16PowerState = u16PowerState;
4284 HDMITXArgs.u32Return = 0x00;
4285
4286 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETPOWERSTATE, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4287 {
4288 printf("MApi_HDMITx_SetPowerState Obtain HDMITX engine fail\n");
4289 return FALSE;
4290 }
4291 else
4292 {
4293 return HDMITXArgs.u32Return;
4294 }
4295 #else
4296 return MApi_HDMITx_SetPowerState_U2(pu32HDMITXInst, u16PowerState);
4297 #endif
4298 }
4299
4300 //******************************************************************************
4301 /// API for getting certain EDID data block
4302 /// @param HDMITX_CEA_DB_TAG_CODE \b IN: tag code of EDID block
4303 /// @param HDMITX_CEA_EXT_TAG_CODE \b IN: extended tag code of EDID data block
4304 /// @param MS_U8* \b IN: pointer to store data block
4305 /// @param MS_U32 \b IN: buffer length of data pointer
4306 /// @param MS_U32* \b IN: real data length of certain data block
4307 /// @param MS_BOOL \b IN: return if EDID is valid
4308 //******************************************************************************
MApi_HDMITx_GetEdidDataBlocks_U2(void * pInstance,HDMITX_CEA_DB_TAG_CODE enTagCode,HDMITX_CEA_EXT_TAG_CODE enExtTagCode,MS_U8 * pu8Data,MS_U32 u32DataLen,MS_U32 * pu32RealLen)4309 MS_BOOL MApi_HDMITx_GetEdidDataBlocks_U2(void* pInstance, HDMITX_CEA_DB_TAG_CODE enTagCode, HDMITX_CEA_EXT_TAG_CODE enExtTagCode, MS_U8* pu8Data, MS_U32 u32DataLen, MS_U32* pu32RealLen)
4310 {
4311 MS_BOOL bRet = FALSE;
4312
4313 _HDMITX_SEMAPHORE_ENTRY(pInstance);
4314
4315 if (MDrv_HDMITx_GetEdidRdyFlag(pInstance) == TRUE)
4316 {
4317 bRet = TRUE;
4318
4319 switch (enTagCode)
4320 {
4321 case E_CEA_TAG_CODE_AUDIO:
4322 MDrv_HDMITx_GetAudioDataBlock(pInstance, pu8Data, u32DataLen, pu32RealLen);
4323 break;
4324
4325 case E_CEA_TAG_CODE_VIDEO:
4326 MDrv_HDMITx_GetVideoDataBlock(pInstance, pu8Data, u32DataLen, pu32RealLen);
4327 break;
4328
4329 case E_CEA_TAG_CODE_VSDB:
4330 MDrv_HDMITx_GetVSDB(pInstance, pu8Data, u32DataLen, pu32RealLen);
4331 break;
4332
4333 case E_CEA_TAG_CODE_HFVSDB:
4334 MDrv_HDMITx_GetHFVSDB(pInstance, pu8Data, u32DataLen, pu32RealLen);
4335 break;
4336
4337 case E_CEA_TAG_CODE_SPEAKER_ALLOCAT:
4338 //TBD: not support currently
4339 printf("%s:: block Tag %d NOT support!!\r\n", __FUNCTION__, E_CEA_TAG_CODE_SPEAKER_ALLOCAT);
4340 bRet = FALSE;
4341 break;
4342
4343 case E_CEA_TAG_CODE_VDTC:
4344 //TBD: not support currently
4345 printf("%s:: block Tag %d NOT support!!\r\n", __FUNCTION__, E_CEA_TAG_CODE_VDTC);
4346 bRet = FALSE;
4347 break;
4348
4349 case E_CEA_TAG_CODE_EXT_TAG:
4350 {
4351 switch (enExtTagCode)
4352 {
4353 case E_CEA_EXT_TAG_VCDB:
4354 //TBD: not support currently
4355 printf("%s:: Extended Tag %d NOT support!!\r\n", __FUNCTION__, E_CEA_EXT_TAG_VCDB);
4356 bRet = FALSE;
4357 break;
4358
4359 case E_CEA_EXT_TAG_VSVDB:
4360 //TBD: not support currently
4361 printf("%s:: Extended Tag %d NOT support!!\r\n", __FUNCTION__, E_CEA_EXT_TAG_VSVDB);
4362 bRet = FALSE;
4363 break;
4364
4365 case E_CEA_EXT_TAG_VDDDB:
4366 //TBD: not support currently
4367 printf("%s:: Extended Tag %d NOT support!!\r\n", __FUNCTION__, E_CEA_EXT_TAG_VDDDB);
4368 bRet = FALSE;
4369 break;
4370
4371 case E_CEA_EXT_TAG_VVTBE:
4372 //TBD: not support currently
4373 printf("%s:: Extended Tag %d NOT support!!\r\n", __FUNCTION__, E_CEA_EXT_TAG_VVTBE);
4374 bRet = FALSE;
4375 break;
4376
4377 case E_CEA_EXT_TAG_CDB:
4378 MDrv_HDMITx_GetColorimetryDataBlock(pInstance, pu8Data, u32DataLen, pu32RealLen);
4379 break;
4380
4381 case E_CEA_EXT_TAG_HSMDB:
4382 MDrv_HDMITx_GetHDRStaticMetaDataBlock(pInstance, pu8Data, u32DataLen, pu32RealLen);
4383 break;
4384
4385 case E_CEA_EXT_TAG_420VDB:
4386 MDrv_HDMITx_Get420VideoDataBlock(pInstance, pu8Data, u32DataLen, pu32RealLen);
4387 break;
4388
4389 case E_CEA_EXT_TAG_420CMDB:
4390 MDrv_HDMITx_Get420CapabilityMapDataBlock(pInstance, pu8Data, u32DataLen, pu32RealLen);
4391 break;
4392
4393 case E_CEA_EXT_TAG_VSADB:
4394 //TBD: not support currently
4395 printf("%s:: Extended Tag %d NOT support!!\r\n", __FUNCTION__, E_CEA_EXT_TAG_VSADB);
4396 bRet = FALSE;
4397 break;
4398
4399 case E_CEA_EXT_TAG_IFDB:
4400 //TBD: not support currently
4401 printf("%s:: Extended Tag %d NOT support!!\r\n", __FUNCTION__, E_CEA_EXT_TAG_IFDB);
4402 bRet = FALSE;
4403 break;
4404
4405 default:
4406 printf("%s::Invalid Argument!!\r\n", __FUNCTION__);
4407 bRet = FALSE;
4408 break;
4409
4410 }
4411 }
4412 break;
4413
4414 default:
4415 printf("%s::Invalid Argument!!\r\n", __FUNCTION__);
4416 bRet = FALSE;
4417 break;
4418 }
4419 }
4420 else
4421 {
4422 printf("%s::EDID is NOT valid yet!!\r\n", __FUNCTION__);
4423 bRet = FALSE;
4424 }
4425
4426 _HDMITX_SEMAPHORE_RETURN(pInstance);
4427
4428 return bRet;
4429 }
4430
MApi_HDMITx_GetEdidDataBlocks(HDMITX_CEA_DB_TAG_CODE enTagCode,HDMITX_CEA_EXT_TAG_CODE enExtTagCode,MS_U8 * pu8Data,MS_U32 u32DataLen,MS_U32 * pu32RealLen)4431 MS_BOOL MApi_HDMITx_GetEdidDataBlocks(HDMITX_CEA_DB_TAG_CODE enTagCode, HDMITX_CEA_EXT_TAG_CODE enExtTagCode, MS_U8* pu8Data, MS_U32 u32DataLen, MS_U32* pu32RealLen)
4432 {
4433 #ifdef UTOPIA_20
4434 if (pu32HDMITXInst == NULL)
4435 {
4436 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4437 {
4438 printf("MApi_HDMITx_GetEdidDataBlocks UtopiaOpen HDMITX failed\n");
4439 return FALSE;
4440 }
4441 }
4442
4443 stHDMITx_GetEdidDataBlocks HDMITXArgs;
4444 HDMITXArgs.enTagCode = enTagCode;
4445 HDMITXArgs.enExtTagCode = enExtTagCode;
4446 HDMITXArgs.pu8Data = pu8Data;
4447 HDMITXArgs.u32DataLen = u32DataLen;
4448 HDMITXArgs.pu32RealLen = pu32RealLen;
4449 HDMITXArgs.bReturn = FALSE;
4450
4451 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETEDIDDATABLOCK, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4452 {
4453 printf("MApi_HDMITx_GetEdidDataBlocks Obtain HDMITX engine fail\n");
4454 return FALSE;
4455 }
4456 else
4457 {
4458 return HDMITXArgs.bReturn;
4459 }
4460 #else
4461 return MApi_HDMITx_GetEdidDataBlocks_U2(pu32HDMITXInst, enTagCode, enExtTagCode, pu8Data, u32DataLen, pu32RealLen);
4462 #endif
4463 }
4464
MApi_HDMITx_GetKSVList_U2(void * pInstance,MS_U8 * pu8Bstatus,MS_U8 * pu8KSVList,MS_U16 u16BufLen,MS_U16 * pu16KSVLength)4465 MS_BOOL MApi_HDMITx_GetKSVList_U2(void* pInstance, MS_U8 *pu8Bstatus, MS_U8* pu8KSVList, MS_U16 u16BufLen, MS_U16 *pu16KSVLength)
4466 {
4467 MS_BOOL bRet = FALSE;
4468
4469 bRet = MDrv_HDCPTx_GetKSVList(pu8Bstatus, pu8KSVList, u16BufLen, pu16KSVLength);
4470
4471 return bRet;
4472 }
4473
MApi_HDMITx_GetKSVList(MS_U8 * pu8Bstatus,MS_U8 * pu8KSVList,MS_U16 u16BufLen,MS_U16 * pu16KSVLength)4474 MS_BOOL MApi_HDMITx_GetKSVList(MS_U8 *pu8Bstatus, MS_U8* pu8KSVList, MS_U16 u16BufLen, MS_U16 *pu16KSVLength)
4475 {
4476 #ifdef UTOPIA_20
4477 if (pu32HDMITXInst == NULL)
4478 {
4479 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4480 {
4481 printf("MApi_HDCPTxGetKSVList UtopiaOpen HDMITX failed\n");
4482 return FALSE;
4483 }
4484 }
4485
4486 stHDMITx_GetKSVList HDMITXArgs;
4487 HDMITXArgs.pu8Bstatus = pu8Bstatus;
4488 HDMITXArgs.pu8KSVList = pu8KSVList;
4489 HDMITXArgs.u16BufLen = u16BufLen;
4490 HDMITXArgs.pu16KSVLength = pu16KSVLength;
4491 HDMITXArgs.bReturn = FALSE;
4492
4493 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GETKSVLIST, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4494 {
4495 printf("MApi_HDCPTxGetKSVList Obtain HDMITX engine fail\n");
4496 return FALSE;
4497 }
4498 else
4499 {
4500 return HDMITXArgs.bReturn;
4501 }
4502 #else
4503 return MApi_HDMITx_GetKSVList_U2(pu32HDMITXInst, pu8Bstatus, pu8KSVList, u16BufLen, pu16KSVLength);
4504 #endif
4505 }
4506
4507
4508 /*********************************************************************/
4509 /* */
4510 /* HDCP22 Relative */
4511 /* */
4512 /*********************************************************************/
MApi_HDMITx_HDCP2AccessX74_U2(void * pInstance,MS_U8 u8PortIdx,MS_U8 u8OffsetAddr,MS_U8 u8OpCode,MS_U8 * pu8RdBuf,MS_U16 u16RdLen,MS_U8 * pu8WRBuff,MS_U16 u16WrLen)4513 MS_BOOL MApi_HDMITx_HDCP2AccessX74_U2(void* pInstance, MS_U8 u8PortIdx, MS_U8 u8OffsetAddr, MS_U8 u8OpCode, MS_U8 *pu8RdBuf, MS_U16 u16RdLen, MS_U8 *pu8WRBuff, MS_U16 u16WrLen)
4514 {
4515 MS_BOOL bRet = FALSE;
4516
4517 _HDMITX_SEMAPHORE_ENTRY(pInstance);
4518
4519 switch (u8OffsetAddr)
4520 {
4521 case E_HDCP1_OFFSETADDR_Bksv:
4522 case E_HDCP1_OFFSETADDR_RiPrime:
4523 case E_HDCP1_OFFSETADDR_PjPrime:
4524 case E_HDCP1_OFFSETADDR_VPrime:
4525 case E_HDCP1_OFFSETADDR_VPrimeH1:
4526 case E_HDCP1_OFFSETADDR_VPrimeH2:
4527 case E_HDCP1_OFFSETADDR_VPrimeH3:
4528 case E_HDCP1_OFFSETADDR_VPrimeH4:
4529 case E_HDCP1_OFFSETADDR_BCaps:
4530 case E_HDCP1_OFFSETADDR_BStatus:
4531 case E_HDCP1_OFFSETADDR_KsvFifo:
4532 case E_HDCP2_OFFSETADDR_HDCP2Version:
4533 case E_HDCP2_OFFSETADDR_RxStatus:
4534 case E_HDCP2_OFFSETADDR_ReadMessage:
4535 {
4536 if (u8OpCode == E_HDCP2_OPCODE_READ)
4537 {
4538 if (pu8RdBuf != NULL)
4539 bRet = MDrv_HDMITx_HDCP2AccessX74(u8PortIdx, u8OffsetAddr, u8OpCode, pu8RdBuf, pu8WRBuff, u16RdLen, u16WrLen);
4540 else
4541 printf("%s:: Read buffer is NULL\r\n", __FUNCTION__);
4542 }
4543 else
4544 {
4545 printf("%s:: Invalid Opeartion Code\r\n", __FUNCTION__);
4546 }
4547 }
4548 break;
4549
4550 case E_HDCP1_OFFSETADDR_Aksv:
4551 case E_HDCP1_OFFSETADDR_Ainfo:
4552 case E_HDCP1_OFFSETADDR_An:
4553 case E_HDCP2_OFFSETADDR_WriteMessage:
4554 {
4555 if (u8OpCode == E_HDCP2_OPCODE_WRITE)
4556 {
4557 if (pu8WRBuff != NULL)
4558 bRet = MDrv_HDMITx_HDCP2AccessX74(u8PortIdx, u8OffsetAddr, u8OpCode, pu8RdBuf, pu8WRBuff, u16RdLen, u16WrLen);
4559 else
4560 printf("%s:: Write buffer is NULL\r\n", __FUNCTION__);
4561 }
4562 else
4563 {
4564 printf("%s:: Invalid Opeartion Code\r\n", __FUNCTION__);
4565 }
4566 }
4567 break;
4568
4569 //case E_HDCP1_OFFSETADDR_DBG: //same offset address;
4570 case E_HDCP2_OFFSETADDR_DBG:
4571 {
4572 if (u8OpCode == E_HDCP2_OPCODE_READ)
4573 {
4574 if (pu8RdBuf != NULL)
4575 bRet = MDrv_HDMITx_HDCP2AccessX74(u8PortIdx, u8OffsetAddr, u8OpCode, pu8RdBuf, pu8WRBuff, u16RdLen, u16WrLen);
4576 else
4577 printf("%s:: Read buffer is NULL\r\n", __FUNCTION__);
4578 }
4579 else
4580 {
4581 if (pu8WRBuff != NULL)
4582 bRet = MDrv_HDMITx_HDCP2AccessX74(u8PortIdx, u8OffsetAddr, u8OpCode, pu8RdBuf, pu8WRBuff, u16RdLen, u16WrLen);
4583 else
4584 printf("%s:: Write buffer is NULL\r\n", __FUNCTION__);
4585 }
4586 }
4587 break;
4588
4589 default:
4590 printf("%s::Invalid HDCP22 x74 Offset Address\r\n", __FUNCTION__);
4591 break;
4592 }
4593 _HDMITX_SEMAPHORE_RETURN(pInstance);
4594
4595 return bRet;
4596 }
4597
MApi_HDMITx_HDCP2AccessX74(MS_U8 u8PortIdx,MS_U8 u8OffsetAddr,MS_U8 u8OpCode,MS_U8 * pu8RdBuf,MS_U16 u16RdLen,MS_U8 * pu8WRBuff,MS_U16 u16WrLen)4598 MS_BOOL MApi_HDMITx_HDCP2AccessX74(MS_U8 u8PortIdx, MS_U8 u8OffsetAddr, MS_U8 u8OpCode, MS_U8 *pu8RdBuf, MS_U16 u16RdLen, MS_U8 *pu8WRBuff, MS_U16 u16WrLen)
4599 {
4600 #ifdef UTOPIA_20
4601 if (pu32HDMITXInst == NULL)
4602 {
4603 if(UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4604 {
4605 printf("MApi_HDMITx_HDCP2AccessX74 UtopiaOpen HDMITX failed\n");
4606 return FALSE;
4607 }
4608 }
4609
4610 stHDMITx_HDCP2AccessX74 HDMITXArgs;
4611 HDMITXArgs.u8PortIdx = u8PortIdx;
4612 HDMITXArgs.u8OffsetAddr = u8OffsetAddr;
4613 HDMITXArgs.u8OpCode = u8OpCode;
4614 HDMITXArgs.pu8RdBuf = pu8RdBuf;
4615 HDMITXArgs.pu8WRBuff = pu8WRBuff;
4616 HDMITXArgs.u16RdLen = u16RdLen;
4617 HDMITXArgs.u16WrLen = u16WrLen;
4618 HDMITXArgs.bReturn = FALSE;
4619
4620 if(UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_HDCP2ACCESSX74, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4621 {
4622 printf("MApi_HDMITx_HDCP2AccessX74 Obtain HDMITX engine fail\n");
4623 return FALSE;
4624 }
4625 else
4626 {
4627 return HDMITXArgs.bReturn;
4628 }
4629 #else
4630 return MApi_HDMITx_HDCP2AccessX74_U2(pu32HDMITXInst, u8PortIdx, u8OffsetAddr, u8OpCode, pu8RdBuf, u16RdLen, pu8WRBuff, u16WrLen);
4631 #endif
4632 }
4633
MApi_HDMITx_HDCP2TxInit_U2(void * pInstance,MS_U8 u8PortIdx,MS_BOOL bEnable)4634 void MApi_HDMITx_HDCP2TxInit_U2(void *pInstance, MS_U8 u8PortIdx, MS_BOOL bEnable)
4635 {
4636 _HDMITX_SEMAPHORE_ENTRY(pInstance);
4637 MDrv_HDMITx_HDCP2TxInit(u8PortIdx, bEnable);
4638 _HDMITX_SEMAPHORE_RETURN(pInstance);
4639 }
4640
MApi_HDMITx_HDCP2TxInit(MS_U8 u8PortIdx,MS_BOOL bEnable)4641 void MApi_HDMITx_HDCP2TxInit(MS_U8 u8PortIdx, MS_BOOL bEnable)
4642 {
4643 #ifdef UTOPIA_20
4644 if (pu32HDMITXInst == NULL)
4645 {
4646 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4647 {
4648 printf("MApi_HDMITx_HDCP2TxInit UtopiaOpen HDMITX failed\n");
4649 return;
4650 }
4651 }
4652
4653 stHDMITx_HDCP2TxInit HDMITXArgs;
4654 HDMITXArgs.u8PortIdx = u8PortIdx;
4655 HDMITXArgs.bEnable = bEnable;
4656
4657 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_HDCP2TxInit, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4658 {
4659 printf("MApi_HDMITx_HDCP2TxInit Obtain HDMITX engine fail\n");
4660 return;
4661 }
4662 else
4663 {
4664 return;
4665 }
4666 #else
4667 MApi_HDMITx_HDCP2TxInit_U2(pu32HDMITXInst, u8PortIdx, bEnable);
4668 #endif
4669 }
4670
MApi_HDMITx_HDCP2TxEnableEncrypt_U2(void * pInstance,MS_U8 u8PortIdx,MS_BOOL bEnable)4671 void MApi_HDMITx_HDCP2TxEnableEncrypt_U2(void *pInstance, MS_U8 u8PortIdx, MS_BOOL bEnable)
4672 {
4673 _HDMITX_SEMAPHORE_ENTRY(pInstance);
4674 MDrv_HDMITx_HDCP2TxEnableEncryptEnable(u8PortIdx, bEnable);
4675 _HDMITX_SEMAPHORE_RETURN(pInstance);
4676 }
4677
MApi_HDMITx_HDCP2TxEnableEncrypt(MS_U8 u8PortIdx,MS_BOOL bEnable)4678 void MApi_HDMITx_HDCP2TxEnableEncrypt(MS_U8 u8PortIdx, MS_BOOL bEnable)
4679 {
4680 #ifdef UTOPIA_20
4681 if (pu32HDMITXInst == NULL)
4682 {
4683 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4684 {
4685 printf("MApi_HDMITx_HDCP2TxEnableEncrypt UtopiaOpen HDMITX failed\n");
4686 return;
4687 }
4688 }
4689
4690 stHDMITx_HDCP2TxEnableEncrypt HDMITXArgs;
4691 HDMITXArgs.u8PortIdx = u8PortIdx;
4692 HDMITXArgs.bEnable = bEnable;
4693
4694 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_HDCP2TxEnableEncrypt, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4695 {
4696 printf("MApi_HDMITx_HDCP2TxEnableEncrypt Obtain HDMITX engine fail\n");
4697 return;
4698 }
4699 else
4700 {
4701 return;
4702 }
4703 #else
4704 MApi_HDMITx_HDCP2TxEnableEncrypt_U2(pu32HDMITXInst, u8PortIdx, bEnable);
4705 #endif
4706 }
4707
MApi_HDMITx_HDCP2TxFillCipherKey_U2(void * pInstance,MS_U8 u8PortIdx,MS_U8 * pu8Riv,MS_U8 * pu8KsXORLC128)4708 void MApi_HDMITx_HDCP2TxFillCipherKey_U2(void *pInstance, MS_U8 u8PortIdx, MS_U8 *pu8Riv, MS_U8 *pu8KsXORLC128)
4709 {
4710 _HDMITX_SEMAPHORE_ENTRY(pInstance);
4711 MDrv_HDMITx_HDCP2TxFillCipherKey(u8PortIdx, pu8Riv, pu8KsXORLC128);
4712 _HDMITX_SEMAPHORE_RETURN(pInstance);
4713 }
4714
MApi_HDMITx_HDCP2TxFillCipherKey(MS_U8 u8PortIdx,MS_U8 * pu8Riv,MS_U8 * pu8KsXORLC128)4715 void MApi_HDMITx_HDCP2TxFillCipherKey(MS_U8 u8PortIdx, MS_U8 *pu8Riv, MS_U8 *pu8KsXORLC128)
4716 {
4717 #ifdef UTOPIA_20
4718 if (pu32HDMITXInst == NULL)
4719 {
4720 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4721 {
4722 printf("MApi_HDMITx_HDCP2TxFillCipherKey UtopiaOpen HDMITX failed\n");
4723 return;
4724 }
4725 }
4726
4727 stHDMITx_HDCP2TxFillCipherKey HDMITXArgs;
4728 HDMITXArgs.u8PortIdx = u8PortIdx;
4729 HDMITXArgs.pu8Riv = pu8Riv;
4730 HDMITXArgs.pu8KsXORLC128 = pu8KsXORLC128;
4731
4732 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_HDCP2TxFillCipherKey, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4733 {
4734 printf("MApi_HDMITx_HDCP2TxFillCipherKey Obtain HDMITX engine fail\n");
4735 return;
4736 }
4737 else
4738 {
4739 return;
4740 }
4741 #else
4742 MApi_HDMITx_HDCP2TxFillCipherKey_U2(pu32HDMITXInst, u8PortIdx, pu8Riv, pu8KsXORLC128);
4743 #endif
4744 }
4745
MApi_HDMITx_GeneralCtrl_U2(void * pInstance,MS_U32 u32Cmd,MS_U8 * pu8Buf,MS_U32 u32BufSize)4746 MS_BOOL MApi_HDMITx_GeneralCtrl_U2(void* pInstance, MS_U32 u32Cmd, MS_U8* pu8Buf, MS_U32 u32BufSize)
4747 {
4748 return TRUE;
4749 }
4750
MApi_HDMITx_ColorandRange_Transform_U2(void * pInstance,HDMITX_VIDEO_COLOR_FORMAT incolor,HDMITX_VIDEO_COLOR_FORMAT outcolor,HDMITX_QUANT_RANGE inange,HDMITX_QUANT_RANGE outrange)4751 MS_BOOL MApi_HDMITx_ColorandRange_Transform_U2(void* pInstance, HDMITX_VIDEO_COLOR_FORMAT incolor, HDMITX_VIDEO_COLOR_FORMAT outcolor, HDMITX_QUANT_RANGE inange, HDMITX_QUANT_RANGE outrange)
4752 {
4753 MS_BOOL ubRet = 0;
4754 pInstance = pInstance;
4755
4756 ubRet = MDrv_HDMITx_ColorandRange_Transform(pInstance, (MsHDMITX_VIDEO_COLOR_FORMAT) incolor,(MsHDMITX_VIDEO_COLOR_FORMAT) outcolor, (MsHDMITX_YCC_QUANT_RANGE) inange, (MsHDMITX_YCC_QUANT_RANGE) outrange);
4757 return ubRet;
4758 }
4759
MApi_HDMITx_ColorandRange_Transform(HDMITX_VIDEO_COLOR_FORMAT incolor,HDMITX_VIDEO_COLOR_FORMAT outcolor,HDMITX_QUANT_RANGE inange,HDMITX_QUANT_RANGE outrange)4760 MS_BOOL MApi_HDMITx_ColorandRange_Transform(HDMITX_VIDEO_COLOR_FORMAT incolor, HDMITX_VIDEO_COLOR_FORMAT outcolor, HDMITX_QUANT_RANGE inange, HDMITX_QUANT_RANGE outrange)
4761 {
4762 HDMITX_COLOR_AND_RANGE_TRANSFORM_PARAMETERS HDMITXArgs;
4763 HDMITXArgs.input_color = incolor;
4764 HDMITXArgs.output_color = outcolor;
4765 HDMITXArgs.input_range = inange;
4766 HDMITXArgs.output_range = outrange;
4767 HDMITXArgs.result = 0;
4768
4769 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_COLOR_AND_RANGE_TRANSFORM, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4770 {
4771 printf("MApi_HDMITx_GeneralCtrl Obtain HDMITX engine fail @ E_HDMITX_CMD_COLOR_AND_RANGE_TRANSFORM\n");
4772 return FALSE;
4773 }
4774 else
4775 {
4776 //HDMITX_COLOR_AND_RANGE_TRANSFORM_PARAMETERS *HDMITXArgs = (HDMITX_COLOR_AND_RANGE_TRANSFORM_PARAMETERS*)pBuf;
4777 //HDMITXArgs->result = MDrv_HDMITx_ColorandRange_Transform((MsHDMITX_VIDEO_COLOR_FORMAT) pParameters->input_color,(MsHDMITX_VIDEO_COLOR_FORMAT) pParameters->output_color, (MsHDMITX_VIDEO_COLOR_RANGE) pParameters->input_range, (MsHDMITX_VIDEO_COLOR_RANGE) pParameters->output_range);
4778 return HDMITXArgs.result;
4779 }
4780 }
4781
MApi_HDMITx_SSC_Enable_U2(void * pInstance,MS_U8 ubSSCEn)4782 MS_BOOL MApi_HDMITx_SSC_Enable_U2(void* pInstance, MS_U8 ubSSCEn)
4783 {
4784 MS_BOOL ubRet = FALSE;
4785
4786 ubRet = MDrv_HDMITx_SSC_Enable(pInstance, ubSSCEn);
4787 return ubRet;
4788 }
4789
MApi_HDMITx_SSC_Enable(MS_U8 ubSSCEn)4790 MS_BOOL MApi_HDMITx_SSC_Enable(MS_U8 ubSSCEn)
4791 {
4792 HDMITX_SSCENABLE HDMITXArgs;
4793 HDMITXArgs.u8SSCEn = ubSSCEn;
4794
4795 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SSC_ENABLE, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4796 {
4797 printf("MApi_HDMITx_GeneralCtrl Obtain HDMITX engine fail @ E_HDMITX_CMD_COLOR_AND_RANGE_TRANSFORM\n");
4798 return FALSE;
4799 }
4800 else
4801 {
4802 //HDMITX_COLOR_AND_RANGE_TRANSFORM_PARAMETERS *HDMITXArgs = (HDMITX_COLOR_AND_RANGE_TRANSFORM_PARAMETERS*)pBuf;
4803 //HDMITXArgs->result = MDrv_HDMITx_ColorandRange_Transform((MsHDMITX_VIDEO_COLOR_FORMAT) pParameters->input_color,(MsHDMITX_VIDEO_COLOR_FORMAT) pParameters->output_color, (MsHDMITX_VIDEO_COLOR_RANGE) pParameters->input_range, (MsHDMITX_VIDEO_COLOR_RANGE) pParameters->output_range);
4804 return HDMITXArgs.result;
4805 }
4806 }
4807
MApi_HDMITx_SetAVIInfoColorimetry_U2(void * pInstance,HDMITX_AVI_COLORIMETRY enColorimetry)4808 MS_U8 MApi_HDMITx_SetAVIInfoColorimetry_U2(void* pInstance, HDMITX_AVI_COLORIMETRY enColorimetry)
4809 {
4810 MS_U8 ubRet = FALSE;
4811
4812 ubRet = MDrv_HDMITx_SetAVIInfoColorimetry(pInstance, (MsHDMITX_COLORIMETRY) enColorimetry);
4813 return ubRet;
4814 }
4815
MApi_HDMITx_SetAVIInfoColorimetry(HDMITX_AVI_COLORIMETRY enColorimetry)4816 MS_U8 MApi_HDMITx_SetAVIInfoColorimetry(HDMITX_AVI_COLORIMETRY enColorimetry)
4817 {
4818 HDMITX_SET_COLORIMETRY HDMITXArgs;
4819 HDMITXArgs.colorimetry = enColorimetry;
4820
4821 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SET_COLORIMETRY, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4822 {
4823 printf("MApi_HDMITx_GeneralCtrl Obtain HDMITX engine fail @ E_HDMITX_CMD_COLOR_AND_RANGE_TRANSFORM\n");
4824 return FALSE;
4825 }
4826 else
4827 {
4828 return HDMITXArgs.u8Return;
4829 }
4830 }
4831
MApi_HDMITx_GetFullRxStatus_U2(void * pInstance)4832 MS_U32 MApi_HDMITx_GetFullRxStatus_U2(void* pInstance)
4833 {
4834 MS_U32 enRxStatus = 0;
4835 enRxStatus = (MS_U32) MDrv_HDMITx_GetFullRxStatus(pInstance);
4836
4837 return enRxStatus;
4838 }
4839
MApi_HDMITx_GetFullRxStatus(void)4840 HDMITX_RX_STATUS MApi_HDMITx_GetFullRxStatus(void)
4841 {
4842 HDMITX_GET_FULL_RX_STATUS HDMITXArgs;
4843
4844 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GET_FULL_RX_STATUS, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4845 {
4846 printf("MApi_HDMITx_GeneralCtrl Obtain HDMITX engine fail @ E_HDMITX_CMD_COLOR_AND_RANGE_TRANSFORM\n");
4847 return FALSE;
4848 }
4849 else
4850 {
4851 return (HDMITX_RX_STATUS) HDMITXArgs.u32RxStatus;
4852 }
4853 }
4854
MApi_HDMITx_CheckLegalTiming_U2(void * pInstance,HDMITX_OUTPUT_MODE eOutputMode,HDMITX_VIDEO_TIMING idx,HDMITX_VIDEO_COLOR_FORMAT incolor_fmt,HDMITX_VIDEO_COLOR_FORMAT outcolor_fmt,HDMITX_VIDEO_COLORDEPTH_VAL color_depth)4855 HDMITX_TIMING_ERROR MApi_HDMITx_CheckLegalTiming_U2(void* pInstance, HDMITX_OUTPUT_MODE eOutputMode, HDMITX_VIDEO_TIMING idx, HDMITX_VIDEO_COLOR_FORMAT incolor_fmt, HDMITX_VIDEO_COLOR_FORMAT outcolor_fmt, HDMITX_VIDEO_COLORDEPTH_VAL color_depth)
4856 {
4857 HDMITX_TIMING_ERROR uiLegalStatus = 0;
4858 uiLegalStatus = (HDMITX_TIMING_ERROR)MDrv_HDMITx_CheckLegalTiming(pInstance, (MsHDMITX_OUTPUT_MODE)eOutputMode, (MsHDMITX_VIDEO_TIMING)idx, (MsHDMITX_VIDEO_COLOR_FORMAT)incolor_fmt, (MsHDMITX_VIDEO_COLOR_FORMAT)outcolor_fmt, (MsHDMITX_VIDEO_COLORDEPTH_VAL)color_depth);
4859
4860 return uiLegalStatus;
4861 }
4862
MApi_HDMITx_CheckLegalTiming(HDMITX_OUTPUT_MODE eOutputMode,HDMITX_VIDEO_TIMING idx,HDMITX_VIDEO_COLOR_FORMAT incolor_fmt,HDMITX_VIDEO_COLOR_FORMAT outcolor_fmt,HDMITX_VIDEO_COLORDEPTH_VAL color_depth)4863 HDMITX_TIMING_ERROR MApi_HDMITx_CheckLegalTiming(HDMITX_OUTPUT_MODE eOutputMode, HDMITX_VIDEO_TIMING idx, HDMITX_VIDEO_COLOR_FORMAT incolor_fmt, HDMITX_VIDEO_COLOR_FORMAT outcolor_fmt, HDMITX_VIDEO_COLORDEPTH_VAL color_depth)
4864 {
4865 HDMITX_CHECK_LEGAL_TIMING HDMITXArgs;
4866
4867 HDMITXArgs.eTiming = idx;
4868 HDMITXArgs.eInColor = incolor_fmt;
4869 HDMITXArgs.eOutColor = outcolor_fmt;
4870 HDMITXArgs.eColorDepth = color_depth;
4871 HDMITXArgs.eOutputMode = eOutputMode;
4872
4873 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_TIMING_CAPABILITY_CHECK, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4874 {
4875 printf("MApi_HDMITx_GeneralCtrl Obtain HDMITX engine fail @ E_HDMITX_CMD_TIMING_CAPABILITY_CHECK\n");
4876 return FALSE;
4877 }
4878 else
4879 {
4880 return HDMITXArgs.ubRet;
4881 }
4882 }
4883
MApi_HDMITx_GetPanelSize_FromEDID(HDMITX_GET_PANELSIZE_FROM_EDID * pstPanelSize)4884 MS_U32 MApi_HDMITx_GetPanelSize_FromEDID(HDMITX_GET_PANELSIZE_FROM_EDID* pstPanelSize)
4885 {
4886 MS_U8 ubEDIDData[128] = {0};
4887 MS_BOOL ubRet = 0;
4888
4889 ubRet = MApi_HDMITx_GetEDIDData(ubEDIDData, 0);
4890
4891 if(ubEDIDData[0x15] != 0 && ubEDIDData[0x16]!= 0)
4892 {
4893 pstPanelSize->u32PanelWidth = ubEDIDData[0x15];
4894 pstPanelSize->u32PanelHeight = ubEDIDData[0x16];
4895 }
4896 else
4897 {
4898 pstPanelSize->u32PanelWidth = 0;
4899 pstPanelSize->u32PanelHeight = 0;
4900 }
4901
4902 return ubRet;
4903 }
4904
MApi_HDMITx_GetTMDSStatus_U2(void * pInstance)4905 MS_U32 MApi_HDMITx_GetTMDSStatus_U2(void* pInstance)
4906 {
4907 MS_U32 u32TMDSStatus = 0;
4908 u32TMDSStatus = MDrv_HDMITx_GetTMDSStatus(pInstance);
4909 return u32TMDSStatus;
4910 }
4911
MApi_HDMITx_GetTMDSStatus(HDMITX_GET_TMDS_STATUS * pstTMDSStatus)4912 MS_U32 MApi_HDMITx_GetTMDSStatus(HDMITX_GET_TMDS_STATUS* pstTMDSStatus)
4913 {
4914 HDMITX_GET_TMDS_STATUS HDMITXArgs;
4915
4916 HDMITXArgs.u32TMDSStatus = 0;
4917 HDMITXArgs.u32Ret= 0;
4918
4919 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_GET_TMDS_STATUS, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
4920 {
4921 printf("MApi_HDMITx_GeneralCtrl Obtain HDMITX engine fail @ E_HDMITX_CMD_GET_TMDS_STATUS\n");
4922 return FALSE;
4923 }
4924 else
4925 {
4926 pstTMDSStatus->u32TMDSStatus = HDMITXArgs.u32TMDSStatus;
4927 return HDMITXArgs.u32Ret;
4928 }
4929 }
4930
MApi_HDMITx_GeneralCtrl(MS_U32 u32Cmd,void * pu8Buf,MS_U32 u32BufSize)4931 MS_BOOL SYMBOL_WEAK MApi_HDMITx_GeneralCtrl(MS_U32 u32Cmd, void* pu8Buf, MS_U32 u32BufSize)
4932 {
4933
4934 if (pu32HDMITXInst == NULL)
4935 {
4936 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4937 {
4938 printf("MApi_HDMITx_GeneralCtrl UtopiaOpen HDMITX failed\n");
4939 return FALSE;
4940 }
4941 }
4942
4943 switch(u32Cmd)
4944 {
4945 case HDMITX_CMD_COLOR_AND_RANGE_TRANSFORM:
4946 {
4947 if (u32BufSize == sizeof(HDMITX_COLOR_AND_RANGE_TRANSFORM_PARAMETERS))
4948 {
4949 HDMITX_COLOR_AND_RANGE_TRANSFORM_PARAMETERS *HDMITXArgs = (HDMITX_COLOR_AND_RANGE_TRANSFORM_PARAMETERS*)pu8Buf;
4950 HDMITXArgs->result = MApi_HDMITx_ColorandRange_Transform(HDMITXArgs->input_color, HDMITXArgs->output_color, HDMITXArgs->input_range, HDMITXArgs->output_range);
4951 return HDMITXArgs->result;
4952 }
4953 }
4954 break;
4955
4956 case HDMITX_CMD_SSC_ENABLE:
4957 {
4958 HDMITX_SSCENABLE *HDMITXArgs = (HDMITX_SSCENABLE*)pu8Buf;
4959 HDMITXArgs->result = MApi_HDMITx_SSC_Enable(HDMITXArgs->u8SSCEn);
4960 return HDMITXArgs->result;
4961 }
4962 break;
4963
4964 case HDMITX_CMD_SET_COLORIMETRY:
4965 {
4966 if (u32BufSize == sizeof(HDMITX_SET_COLORIMETRY))
4967 {
4968 HDMITX_SET_COLORIMETRY *HDMITXArgs = (HDMITX_SET_COLORIMETRY*)pu8Buf;
4969 HDMITXArgs->u8Return = MApi_HDMITx_SetAVIInfoColorimetry(HDMITXArgs->colorimetry);
4970 return HDMITXArgs->u8Return;
4971 }
4972 }
4973 break;
4974
4975 case HDMITX_CMD_GET_FULL_RX_STATUS:
4976 {
4977 if (u32BufSize == sizeof(HDMITX_GET_FULL_RX_STATUS))
4978 {
4979 HDMITX_GET_FULL_RX_STATUS *HDMITXArgs = (HDMITX_GET_FULL_RX_STATUS*)pu8Buf;
4980 HDMITXArgs->u32RxStatus = (MS_U32) MApi_HDMITx_GetFullRxStatus();
4981 return HDMITXArgs->u32RxStatus;
4982 }
4983 }
4984 break;
4985
4986 case HDMITX_CMD_TIMING_CAPABILITY_CHECK:
4987 {
4988 if (u32BufSize == sizeof(HDMITX_CHECK_LEGAL_TIMING))
4989 {
4990 HDMITX_CHECK_LEGAL_TIMING *HDMITXArgs = (HDMITX_CHECK_LEGAL_TIMING*)pu8Buf;
4991 HDMITXArgs->ubRet = MApi_HDMITx_CheckLegalTiming(HDMITXArgs->eOutputMode, HDMITXArgs->eTiming, HDMITXArgs->eInColor, HDMITXArgs->eOutColor, HDMITXArgs->eColorDepth);
4992 return HDMITXArgs->ubRet;
4993 }
4994 }
4995 break;
4996
4997 case HDMITX_CMD_GET_PANELSIZE_FROM_EDID:
4998 {
4999 if (u32BufSize == sizeof(HDMITX_GET_PANELSIZE_FROM_EDID))
5000 {
5001 HDMITX_GET_PANELSIZE_FROM_EDID *HDMITXArgs = (HDMITX_GET_PANELSIZE_FROM_EDID*)pu8Buf;
5002 HDMITXArgs->u32Ret = MApi_HDMITx_GetPanelSize_FromEDID(HDMITXArgs);
5003 return (MS_BOOL)HDMITXArgs->u32Ret;
5004 }
5005 }
5006 break;
5007
5008 case HDMITX_CMD_GET_TMDS_STATUS:
5009 {
5010 if (u32BufSize == sizeof(HDMITX_GET_TMDS_STATUS))
5011 {
5012 HDMITX_GET_TMDS_STATUS *HDMITXArgs = (HDMITX_GET_TMDS_STATUS*)pu8Buf;
5013 HDMITXArgs->u32Ret = MApi_HDMITx_GetTMDSStatus(HDMITXArgs);
5014 return (MS_BOOL)HDMITXArgs->u32Ret;
5015 }
5016 }
5017 break;
5018
5019 case HDMITX_CMD_SET_TIMING_INFO_BY_CUSTOMER:
5020 {
5021 if (u32BufSize == sizeof(HDMITX_SET_TIMING_INFO_BY_CUSTOMER))
5022 {
5023 HDMITX_SET_TIMING_INFO_BY_CUSTOMER *HDMITXArgs = (HDMITX_SET_TIMING_INFO_BY_CUSTOMER*)pu8Buf;
5024 MApi_HDMITx_SetVideoOutputTimingByCustomer(HDMITXArgs->u8Timing, HDMITXArgs->stTimingInfo);
5025 return TRUE;
5026 }
5027 }
5028 break;
5029
5030 default:
5031 {
5032 printf("MApi_HDMITx_GeneralCtrl with unknow command\r\n");
5033 }
5034 break;
5035 }
5036
5037 return FALSE;
5038 }
5039 //------------------------------------------------------------------------------
5040 /// @brief This routine config HDMI Tx Module video output timing by Customers
5041 /// @param[in] mode output video timing and timing detail
5042 /// @return None
5043 //-----------------------------------------------------------------------------
MApi_HDMITx_SetVideoOutputTimingByCustomer_U2(void * pInstance,HDMITX_VIDEO_TIMING mode,HDMITX_TIMING_INFO_BY_CUSTOMER timinginfo)5044 void MApi_HDMITx_SetVideoOutputTimingByCustomer_U2(void* pInstance, HDMITX_VIDEO_TIMING mode, HDMITX_TIMING_INFO_BY_CUSTOMER timinginfo)
5045 {
5046 stHDMITX_TIMING_INFO_BY_CUSTOMER stTimingInfo;
5047 _HDMITX_SEMAPHORE_ENTRY(pInstance);
5048 HDMITX_ENTRY();
5049 #ifdef URANUS
5050 if ((MS_U32)mode > (MS_U32)HDMITX_RES_720x576p)
5051 {
5052 printf("[%s][%d] Unsupport HDMI mode 0x%08x\n", __FUNCTION__, __LINE__, mode);
5053 }
5054 #endif
5055 #ifdef OBERON
5056 if ((MS_U32)mode >= (MS_U32)HDMITX_RES_MAX)
5057 {
5058 printf("[%s][%d] Unsupport HDMI mode 0x%08x\n", __FUNCTION__, __LINE__, mode);
5059 }
5060 #endif
5061
5062 // 3D frame packing only support up to 24-bit color depth
5063 // For HDMI 2.0 spec, 4k2k@60 only support up to 24-bit color depth
5064 stTimingInfo.i_p_mode = timinginfo.i_p_mode;
5065 stTimingInfo.h_polarity = timinginfo.h_polarity;
5066 stTimingInfo.v_polarity = timinginfo.v_polarity;
5067 stTimingInfo.vs_width = timinginfo.vs_width;
5068 stTimingInfo.vs_bporch = timinginfo.vs_bporch;
5069 stTimingInfo.vde_width = timinginfo.vde_width;
5070 stTimingInfo.hs_width = timinginfo.hs_width;
5071 stTimingInfo.hs_bporch = timinginfo.hs_bporch;
5072 stTimingInfo.hde_width = timinginfo.hde_width;
5073 stTimingInfo.vtotal = timinginfo.vtotal;
5074 stTimingInfo.htotal = timinginfo.htotal;
5075 stTimingInfo.vs_delayline = timinginfo.vs_delayline;
5076 stTimingInfo.vs_delaypixel = timinginfo.vs_delaypixel;
5077 stTimingInfo.hs_delay = timinginfo.hs_delay;
5078 switch (mode)
5079 {
5080
5081 case HDMITX_RES_1280x720p_50Hz:
5082 MDrv_HDMITx_SetVideoOutputModeByCustomer(pInstance, E_HDMITX_RES_1280x720p_50Hz, stTimingInfo);
5083 break;
5084
5085 case HDMITX_RES_1280x720p_60Hz:
5086 MDrv_HDMITx_SetVideoOutputModeByCustomer(pInstance, E_HDMITX_RES_1280x720p_60Hz, stTimingInfo);
5087 break;
5088
5089 case HDMITX_RES_1920x1080p_50Hz:
5090 MDrv_HDMITx_SetVideoOutputModeByCustomer(pInstance, E_HDMITX_RES_1920x1080p_50Hz, stTimingInfo);
5091 break;
5092
5093 case HDMITX_RES_1920x1080p_60Hz:
5094 MDrv_HDMITx_SetVideoOutputModeByCustomer(pInstance, E_HDMITX_RES_1920x1080p_60Hz, stTimingInfo);
5095 break;
5096
5097 case HDMITX_RES_1600x1200p_60Hz:
5098 MDrv_HDMITx_SetVideoOutputModeByCustomer(pInstance, E_HDMITX_RES_1600x1200p_60Hz, stTimingInfo);
5099 break;
5100
5101 case HDMITX_RES_1440x900p_60Hz:
5102 MDrv_HDMITx_SetVideoOutputModeByCustomer(pInstance, E_HDMITX_RES_1440x900p_60Hz, stTimingInfo);
5103 break;
5104
5105 case HDMITX_RES_1280x1024p_60Hz:
5106 MDrv_HDMITx_SetVideoOutputModeByCustomer(pInstance, E_HDMITX_RES_1280x1024p_60Hz, stTimingInfo);
5107 break;
5108
5109 case HDMITX_RES_1024x768p_60Hz:
5110 MDrv_HDMITx_SetVideoOutputModeByCustomer(pInstance, E_HDMITX_RES_1024x768p_60Hz, stTimingInfo);
5111 break;
5112
5113 default:
5114 printf("[HDMITx]: Error video timing: %d\n", mode);
5115 break;
5116 }
5117
5118 HDMITX_RETURN();
5119 _HDMITX_SEMAPHORE_RETURN(pInstance);
5120 }
5121
5122 //17.8.11 settiming info by customer
MApi_HDMITx_SetVideoOutputTimingByCustomer(HDMITX_VIDEO_TIMING u8mode,HDMITX_TIMING_INFO_BY_CUSTOMER stTiminginfo)5123 void MApi_HDMITx_SetVideoOutputTimingByCustomer(HDMITX_VIDEO_TIMING u8mode, HDMITX_TIMING_INFO_BY_CUSTOMER stTiminginfo)
5124 {
5125 #ifdef UTOPIA_20
5126 if (pu32HDMITXInst == NULL)
5127 {
5128 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITXInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
5129 {
5130 printf("MApi_HDMITx_SetVideoOutputTimingByCustomer UtopiaOpen HDMITX failed\n");
5131 }
5132 }
5133
5134 stHDMITx_SetVideoOutputTimingByCustomer HDMITXArgs;
5135 HDMITXArgs.u8Mode = u8mode;
5136 HDMITXArgs.stTiminginfo = stTiminginfo;
5137
5138 if (UtopiaIoctl(pu32HDMITXInst, E_HDMITX_CMD_SETVIDEOUTPUTTIMINGBYCUSTOMER, (void*)&HDMITXArgs) != UTOPIA_STATUS_SUCCESS)
5139 {
5140 printf("MApi_HDMITx_SetVideoOutputTimingByCustomer Obtain HDMITX engine fail\n");
5141 }
5142 else
5143 {
5144
5145 }
5146 #else
5147 MApi_HDMITx_SetVideoOutputTimingByCustomer_U2(pu32HDMITXInst, u8mode, stTiminginfo);
5148 #endif
5149 }
5150
5151 // ************* For customer NDS **************//
5152 #ifdef CUSTOMER_NDS
5153
5154 //17.7.7.5 Ioctl: Get Events
MApi_HDMITx_Get_Events(MS_U32 * events,MS_BOOL bEraseEvent)5155 MS_BOOL MApi_HDMITx_Get_Events(MS_U32 *events, MS_BOOL bEraseEvent)
5156 {
5157 *events = gHDMITxInfo.events;
5158
5159 if(bEraseEvent)
5160 gHDMITxInfo.events = 0;
5161 return TRUE;
5162 }
5163
5164 //17.7.7.8 Ioctl: Get Connection Status
MApi_HDMITx_Get_Rx_CONNECTION_STATUS(HDMIConnectionStatus * status)5165 MS_BOOL MApi_HDMITx_Get_Rx_CONNECTION_STATUS(HDMIConnectionStatus *status)
5166 {
5167 HDMI_TX_Status Status;
5168
5169 if(MDrv_HDMITx_GetRxStatus())
5170 status->attached = 1; // attached
5171 else
5172 status->attached = 0; // not attached
5173
5174 MApi_HDMITx_GetStatus(&Status);
5175 if(Status.bIsRunning == TRUE)
5176 status->powered = 1; // powered
5177 else
5178 status->powered = 0; // not powered
5179
5180 return TRUE;
5181 }
5182
5183 //17.7.7.9 Ioctl: Get EEDID Block
5184 /* This function returns 0 if success, otherwise returns non-zero */
MApi_HDMITx_Get_EEDID_Block(HDMIGetEEDIDBlock * eedid)5185 MS_BOOL MApi_HDMITx_Get_EEDID_Block(HDMIGetEEDIDBlock *eedid)
5186 {
5187 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5188 return FALSE;
5189
5190 if(MDrv_HDMITx_EdidReadBlock(eedid->blockNumber, eedid->eedid))
5191 return TRUE;
5192 else
5193 return FALSE;
5194 }
5195
5196 //17.7.7.10 Ioctl: Start
MApi_HDMITx_Set_HDMI_Protocol(MS_U8 protocol)5197 MS_BOOL MApi_HDMITx_Set_HDMI_Protocol(MS_U8 protocol)
5198 {
5199 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5200 return FALSE;
5201
5202 if(protocol == HDMI_PROTOCOL_DVI)
5203 MApi_HDMITx_SetHDMITxMode(HDMITX_DVI);
5204 else if(protocol == HDMI_PROTOCOL_HDMI)
5205 MApi_HDMITx_SetHDMITxMode(HDMITX_HDMI);
5206
5207 return TRUE;
5208 }
5209
5210 //17.7.7.11 Ioctl: Stop
MApi_HDMITx_Stop(void)5211 MS_BOOL MApi_HDMITx_Stop(void)
5212 {
5213 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5214 return FALSE;
5215
5216 MApi_HDMITx_SetTMDSOnOff(FALSE);
5217
5218 return TRUE;
5219 }
5220
5221 //17.7.7.14 Ioctl: Set Video Code
5222 // VIC codes: {6, 21, 2, 17, 19, 4, 20, 5, 32, 33, 34, 31, 16} => 480i60,576i50,480p60,576p50,720p50,720p60,1080i50,1080i60,1080p24,1080p25,1080p30,1080p50,1080p60
MApi_HDMITx_Set_Video_Code(MS_U8 * videoCode)5223 MS_BOOL MApi_HDMITx_Set_Video_Code(MS_U8 *videoCode)
5224 {
5225 HDMITX_VIDEO_TIMING val = HDMITX_RES_720x480i;
5226
5227 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5228 return FALSE;
5229
5230 if(*videoCode == 1)
5231 val = HDMITX_RES_640x480p;
5232 else if(*videoCode == 6)
5233 val = HDMITX_RES_720x480i;
5234 else if(*videoCode == 21)
5235 val = HDMITX_RES_720x576i;
5236 else if(*videoCode == 2)
5237 val = HDMITX_RES_720x480p;
5238 else if(*videoCode == 17)
5239 val = HDMITX_RES_720x576p;
5240 else if(*videoCode == 19)
5241 val = HDMITX_RES_1280x720p_50Hz;
5242 else if(*videoCode == 4)
5243 val = HDMITX_RES_1280x720p_60Hz;
5244 else if(*videoCode == 20)
5245 val = HDMITX_RES_1920x1080i_50Hz;
5246 else if(*videoCode == 5)
5247 val = HDMITX_RES_1920x1080i_60Hz;
5248 else if(*videoCode == 32)
5249 val = HDMITX_RES_1920x1080p_24Hz;
5250 else if(*videoCode == 33)
5251 val = HDMITX_RES_1920x1080p_25Hz;
5252 else if(*videoCode == 34)
5253 val = HDMITX_RES_1920x1080p_30Hz;
5254 else if(*videoCode == 31)
5255 val = HDMITX_RES_1920x1080p_50Hz;
5256 else if(*videoCode == 16)
5257 val = HDMITX_RES_1920x1080p_60Hz;
5258
5259 MApi_HDMITx_SetVideoOutputTiming(val);
5260
5261 return TRUE;
5262 }
5263
5264 //17.7.7.15 Ioctl: Set Pixel Format
MApi_HDMITx_Set_Pixel_Format(MS_U8 * pixelFormat)5265 MS_BOOL MApi_HDMITx_Set_Pixel_Format(MS_U8 *pixelFormat)
5266 {
5267 HDMITX_VIDEO_COLOR_FORMAT val;
5268
5269 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5270 return FALSE;
5271 //#if 0
5272 if(*pixelFormat == HDMI_PIXEL_FORMAT_RGB)
5273 val = HDMITX_VIDEO_COLOR_RGB444;
5274 else if(*pixelFormat == HDMI_PIXEL_FORMAT_YCbCr422)
5275 val = HDMITX_VIDEO_COLOR_YUV422;
5276 else if(*pixelFormat == HDMI_PIXEL_FORMAT_YCbCr444)
5277 val = HDMITX_VIDEO_COLOR_YUV444;
5278 else if(*pixelFormat == HDMI_PIXEL_FORMAT_YCbCr420)
5279 val = HDMITX_VIDEO_COLOR_YUV420;
5280
5281
5282 MApi_HDMITx_SetColorFormat(HDMITX_VIDEO_COLOR_YUV444, val);
5283 //#else
5284 MDrv_HDMITx_Set_AVI_InfoFrame(E_HDMITX_AVI_PIXEL_FROMAT, (MS_U16 *)pixelFormat);
5285 //#endif
5286
5287 return TRUE;
5288 }
5289
5290 //17.7.7.16 Ioctl: Set Aspect Ratio
MApi_HDMITx_Set_Aspect_Ratio(HDMIAspectRatio * aspectRatio)5291 MS_BOOL MApi_HDMITx_Set_Aspect_Ratio(HDMIAspectRatio *aspectRatio)
5292 {
5293 MS_U16 u16reg_val[6];
5294
5295 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5296 return FALSE;
5297
5298 u16reg_val[0] = ((aspectRatio->pictureAspectRatio)|(aspectRatio->activeFormatDescriptor))<<8 | ((aspectRatio->afdValidity) | (aspectRatio->barinfoValidity) | (aspectRatio->scanInfo));
5299 u16reg_val[1] = (aspectRatio->scalingInfo) << 8;
5300 if( (aspectRatio->barinfoValidity == HDMI_BARINFO_INVALID) || (aspectRatio->barinfoValidity == HDMI_BARINFO_VERTICAL_VALID))
5301 {
5302 u16reg_val[2] = 0;
5303 u16reg_val[3] = 0;
5304 }
5305 else
5306 {
5307 u16reg_val[2] = (aspectRatio->topBarEndsLine);
5308 u16reg_val[3] = (aspectRatio->bottomBarStartsLine);
5309 }
5310 if( (aspectRatio->barinfoValidity == HDMI_BARINFO_INVALID) || (aspectRatio->barinfoValidity == HDMI_BARINFO_HORIZONTAL_VALID))
5311 {
5312 u16reg_val[4] = 0;
5313 u16reg_val[5] = 0;
5314 }
5315 else
5316 {
5317 u16reg_val[4] = (aspectRatio->leftBarEndsPixel);
5318 u16reg_val[5] = (aspectRatio->rightBarStartsPixel);
5319 }
5320 MDrv_HDMITx_Set_AVI_InfoFrame(E_HDMITX_AVI_ASPECT_RATIO, u16reg_val);
5321
5322 return TRUE;
5323 }
5324
5325 //17.7.7.17 Ioctl: Set Colorimetry
MApi_HDMITx_Set_Colorimetry(HDMIColorimetry * colorimetryData)5326 MS_BOOL MApi_HDMITx_Set_Colorimetry(HDMIColorimetry *colorimetryData)
5327 {
5328 MS_U16 u16reg_val[2];
5329
5330 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5331 return FALSE;
5332
5333 u16reg_val[0] = (colorimetryData->colorimetry) << 8;
5334 u16reg_val[1] = colorimetryData->extendedColorimetry;
5335 MDrv_HDMITx_Set_AVI_InfoFrame(E_HDMITX_AVI_COLORIMETRY, u16reg_val);
5336
5337 return TRUE;
5338 }
5339
5340
5341 //17.7.7.18 Ioctl: Set AVMUTE
5342 //17.7.7.19 Ioctl: Clear AVMUTE
MApi_HDMITx_Set_AVMUTE(MS_BOOL bflag)5343 MS_BOOL MApi_HDMITx_Set_AVMUTE(MS_BOOL bflag)
5344 {
5345 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5346 return FALSE;
5347
5348 MDrv_HDMITx_Set_AVMUTE(bflag);
5349 return TRUE;
5350 }
5351
5352 //17.7.7.20 Ioctl: HDCP Start Authentication
MApi_HDMITx_HDCP_Start_Authentication(void)5353 MS_BOOL MApi_HDMITx_HDCP_Start_Authentication(void)
5354 {
5355 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5356 return FALSE;
5357
5358 //MApi_HDMITx_SetHDCPOnOff(TRUE);
5359 //MDrv_HDMITx_FSM_ChangeState(E_HDMITX_FSM_HDCP_AUTH_WAIT_RX);
5360 return MDrv_HDMITx_HDCP_Start_Authentication();
5361
5362 //return 0;
5363 }
5364
5365 //17.7.7.21 Ioctl: HDCP Stop Authentication
MApi_HDMITx_HDCP_Stop_Authentication(void)5366 MS_BOOL MApi_HDMITx_HDCP_Stop_Authentication(void)
5367 {
5368 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5369 return -1;
5370
5371 //MApi_HDMITx_SetHDCPOnOff(FALSE);
5372 return MDrv_HDMITx_HDCP_Stop_Authentication();
5373
5374 //return 0;
5375 }
5376
5377 //17.7.7.22 Ioctl: HDCP Get Bcaps
5378 /* This function returns 0 if success, otherwise returns non-zero */
MApi_HDMITx_HDCP_Get_BCaps(HDMIHDCPBCaps * arg)5379 MS_BOOL MApi_HDMITx_HDCP_Get_BCaps(HDMIHDCPBCaps *arg)
5380 {
5381 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5382 return FALSE;
5383
5384 if(!MDrv_HDMITx_HDCP_Get_BCaps(&(arg->bcaps)))
5385 return FALSE;
5386
5387 return TRUE;
5388 }
5389
5390 //17.7.7.23 Ioctl: HDCP Get Bstatus
5391 /* This function returns 0 if success, otherwise returns non-zero */
MApi_HDMITx_HDCP_Get_BStatus(HDMIHDCPBStatus * arg)5392 MS_BOOL MApi_HDMITx_HDCP_Get_BStatus(HDMIHDCPBStatus *arg)
5393 {
5394 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5395 return FALSE;
5396
5397 if(!MDrv_HDMITx_HDCP_Get_BStatus(&(arg->bstatus)))
5398 return FALSE;
5399
5400 return TRUE;
5401 }
5402
5403 //17.7.7.24 Ioctl: HDCP Send SRM List
MApi_HDMITx_HDCP_Send_SRM(DigitalCPSrm * srm)5404 MS_BOOL MApi_HDMITx_HDCP_Send_SRM(DigitalCPSrm *srm)
5405 {
5406 if(MApi_HDMITx_HDCP_IsSRMSignatureValid(srm->data, srm->length))
5407 return TRUE;
5408 else
5409 return FALSE;
5410 }
5411
MApi_HDMITx_HDCP_Reset_SRM(void)5412 void MApi_HDMITx_HDCP_Reset_SRM(void)
5413 {
5414 MDrv_HDMITx_HDCP_Reset_SRM();
5415 }
5416
5417 //17.7.7.25 Ioctl: HDCP Encryption Control
MApi_HDMITx_HDCP_Encryption_Enable(MS_U8 control)5418 MS_BOOL MApi_HDMITx_HDCP_Encryption_Enable(MS_U8 control)
5419 {
5420 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5421 return FALSE;
5422
5423 if(control) // enable encryption
5424 MDrv_HDMITx_HdcpSetEncrypt(TRUE);
5425 else // disable encryption
5426 MDrv_HDMITx_HdcpSetEncrypt(FALSE);
5427
5428 return TRUE;
5429 }
5430
5431 //17.7.7.26 Ioctl: HDCP Get Status
MApi_HDMITx_HDCP_Get_HDCP_Status(MS_U8 * status)5432 MS_BOOL MApi_HDMITx_HDCP_Get_HDCP_Status(MS_U8 *status)
5433 {
5434 if(!MDrv_HDMITx_GetRxStatus()) // RX is not alive
5435 return FALSE;
5436
5437 MDrv_HDMITx_HDCP_Get_HDCP_Status(status);
5438
5439 return TRUE;
5440 }
5441
5442 //17.7.7.27 Ioctl: HDCP Configure
MApi_HDMITx_HDCP_Configure(HDMIHDCPConfiguration * arg)5443 MS_BOOL MApi_HDMITx_HDCP_Configure(HDMIHDCPConfiguration *arg)
5444 {
5445 MDrv_HDMITx_HDCP_Configure(arg);
5446
5447 return TRUE;
5448 }
5449
5450
5451 #endif //CUSTOMER_NDS
5452
5453