1
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94
95 ///////////////////////////////////////////////////////////////////////////////////////////////////
96 /// file Mdrv_hdmi.c
97 /// @brief Driver Interface
98 /// @author MStar Semiconductor Inc.
99 ///////////////////////////////////////////////////////////////////////////////////////////////////
100 #define MDRV_HDMI_C
101 //-------------------------------------------------------------------------------------------------
102 // Include Files
103 //-------------------------------------------------------------------------------------------------
104 // Common Definition
105 #include "MsCommon.h"
106 #include "MsVersion.h"
107 #ifdef MSOS_TYPE_LINUX_KERNEL
108 #include <linux/string.h>
109 #else
110 #include <string.h>
111 #endif
112 #include "MsIRQ.h"
113 #include "MsOS.h"
114 #include "mhal_xc_chip_config.h"
115 #include "utopia.h"
116 #include "utopia_dapi.h"
117
118 // Internal Definition
119 #include "drvXC_IOPort.h"
120 #include "apiXC.h"
121 #include "drvXC_HDMI_Internal.h"
122 #include "mhal_hdmi.h"
123 #include "drv_sc_display.h"
124 #include "drv_sc_isr.h"
125 #include "apiXC_PCMonitor.h"
126 #include "apiXC_ModeParse.h"
127 #include "apiXC_Adc.h"
128 #include "apiXC_Auto.h"
129 #include "drvXC_ADC_Internal.h"
130 #include "mhal_adc.h"
131 #include "xc_hwreg_utility2.h"
132 #include "drv_sc_mux.h"
133 #include "mvideo_context.h"
134 #include "drv_sc_ip.h"
135 #if (LD_ENABLE==1)
136 #include "mdrv_ld.h"
137 #include "mdrv_ldalgo.h"
138 #endif
139 #include "mdrv_sc_3d.h"
140 #include "drv_sc_menuload.h"
141 #include "mhal_sc.h"
142 #if FRC_INSIDE
143 #include "mdrv_frc.h"
144 #include "mhal_frc.h"
145 #endif
146 #include "XC_private.h"
147 #include "apiXC_v2.h"
148 #include "drvXC_HDMI_if_v2.h"
149 #include "apiHDMIRx_private.h"
150
151 #ifdef MSOS_TYPE_LINUX
152 #include <assert.h>
153 #else
154 #define assert(b) \
155 do { \
156 if (!(b)){ \
157 printf("assert at [%s][%d] \n", __FUNCTION__, __LINE__); \
158 *((int*)0) = 0; \
159 } \
160 } while(0)
161 #endif
162
163 //-------------------------------------------------------------------------------------------------
164 // Driver Compiler Options
165 //-------------------------------------------------------------------------------------------------
166 #define msg_hdmi(x) //x
167 #define DRV_HDMI_HDR(x) //x
168 //-------------------------------------------------------------------------------------------------
169 // Local Defines
170 //-------------------------------------------------------------------------------------------------
171 #define HDMI_POLLING_INTERVAL 10U
172 #define HDMI_HDCP_WAIT_ENENT_TIMEOUT 100U
173
174 #if(defined(CONFIG_MLOG))
175 #include "ULog.h"
176
177 #define MDRV_HDMIRX_MSG_INFO(format, args...) ULOGI("HDMIRX", format, ##args)
178 #define MDRV_HDMIRX_MSG_WARNING(format, args...) ULOGW("HDMIRX", format, ##args)
179 #define MDRV_HDMIRX_MSG_DEBUG(format, args...) ULOGD("HDMIRX", format, ##args)
180 #define MDRV_HDMIRX_MSG_ERROR(format, args...) ULOGE("HDMIRX", format, ##args)
181 #define MDRV_HDMIRX_MSG_FATAL(format, args...) ULOGF("HDMIRX", format, ##args)
182
183 #else
184 #define MDRV_HDMIRX_MSG_INFO(format, args...) printf(format, ##args)
185 #define MDRV_HDMIRX_MSG_WARNING(format, args...) printf(format, ##args)
186 #define MDRV_HDMIRX_MSG_DEBUG(format, args...) printf(format, ##args)
187 #define MDRV_HDMIRX_MSG_ERROR(format, args...) printf(format, ##args)
188 #define MDRV_HDMIRX_MSG_FATAL(format, args...) printf(format, ##args)
189
190 #endif
191
192 //-------------------------------------------------------------------------------------------------
193 // Local Structurs
194 //-------------------------------------------------------------------------------------------------
195 MS_BOOL bInitEnable = FALSE;
196 MS_BOOL ucHDMIInfoSourceSelect = HDMI_INFO_SOURCE0;
197
198 //-------------------------------------------------------------------------------------------------
199 // Global Variables
200 //-------------------------------------------------------------------------------------------------
201 HDCP22_Recv_CBF fpHdcp22RecMsgCBFunc = NULL; //wilson for u2k //type, portIdx, msg, msg length, context
202 //-------------------------------------------------------------------------------------------------
203 // Local Variables
204 //-------------------------------------------------------------------------------------------------
205 /// Debug information
206 static MSIF_Version _drv_hdmi_version = {.DDI = { HDMI_DRV_VERSION },};
207 void* pulHDMIRxInst;
208
209 MS_BOOL bHDCPInterruptProcFlag = FALSE;
210 MS_BOOL bHDCPInterruptCreateFlag = FALSE;
211 MS_S32 slHDCPInterruptTaskID = -1;
212 MS_U8 ucHDCPInterruptStack[HDMI_HDCP_INTERRUPT_STACK_SIZE];
213
214 //-------------------------------------------------------------------------------------------------
215 // Debug Functions
216 //-------------------------------------------------------------------------------------------------
217 //-------------------------------------------------------------------------------------------------
218 // Local Functions
219 //-------------------------------------------------------------------------------------------------
220 static void MDrv_HDMI_ReadEDID(E_XC_DDCRAM_PROG_TYPE eDDCRamType, MS_U8 *u8EDID, MS_U16 u8EDIDSize);
221 static void MDrv_HDMI_WriteEDID(E_XC_DDCRAM_PROG_TYPE eDDCRamType, MS_U8 *u8EDID, MS_U16 u16EDIDSize);
222
223 extern MS_U32 MsOS_GetSystemTime(void);
224 //**************************************************************************
225 // [Function Name]:
226 // _mdrv_HDMI_CheckPacketReceiveProc
227 // [Description]:
228 //
229 // [Arguments]:
230 //
231 // [Return]:
232 //
233 //**************************************************************************
_mdrv_HDMI_CheckPacketReceiveProc(HDMI_RX_RESOURCE_PRIVATE * pHDMIRxResourcePrivate)234 void _mdrv_HDMI_CheckPacketReceiveProc(HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate)
235 {
236 MS_U8 ucHDMIInfoSource = 0;
237
238 for(ucHDMIInfoSource = HDMI_INFO_SOURCE0; ucHDMIInfoSource < HDMI_INFO_SOURCE_MAX; ucHDMIInfoSource++)
239 {
240 if(pHDMIRxResourcePrivate->ucReceiveIntervalCount[ucHDMIInfoSource] < HDMI_PACKET_RECEIVE_COUNT)
241 {
242 pHDMIRxResourcePrivate->ucReceiveIntervalCount[ucHDMIInfoSource]++;
243 }
244 else
245 {
246 pHDMIRxResourcePrivate->ulPacketStatus[ucHDMIInfoSource] = Hal_HDMI_packet_info(ucHDMIInfoSource);
247
248 pHDMIRxResourcePrivate->ucReceiveIntervalCount[ucHDMIInfoSource] = 0;
249 }
250 }
251 }
252
253 //**************************************************************************
254 // [Function Name]:
255 // _mdrv_HDMI_CheckHDCP14RiProc
256 // [Description]:
257 //
258 // [Arguments]:
259 //
260 // [Return]:
261 //
262 //**************************************************************************
_mdrv_HDMI_CheckHDCP14RiProc(HDMI_RX_RESOURCE_PRIVATE * pHDMIRxResourcePrivate)263 void _mdrv_HDMI_CheckHDCP14RiProc(HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate)
264 {
265 MS_U8 enPortIndex = 0;
266
267 for(enPortIndex = INPUT_PORT_DVI0; enPortIndex <= INPUT_PORT_DVI_END; enPortIndex++)
268 {
269 if(pHDMIRxResourcePrivate->usHDCP14RiCount[HDMI_GET_PORT_SELECT(enPortIndex)] < HDMI_HDCP14_RI_COUNT)
270 {
271 pHDMIRxResourcePrivate->usHDCP14RiCount[HDMI_GET_PORT_SELECT(enPortIndex)]++;
272 }
273 else
274 {
275 if(Hal_HDCP_getstatus(enPortIndex) & BIT(13)) // [13] Ri
276 {
277 pHDMIRxResourcePrivate->bHDCP14RiFlag[HDMI_GET_PORT_SELECT(enPortIndex)] = TRUE;
278 Hal_HDCP_ClearStatus(enPortIndex, BIT(5));
279 }
280 else
281 {
282 pHDMIRxResourcePrivate->bHDCP14RiFlag[HDMI_GET_PORT_SELECT(enPortIndex)] = FALSE;
283 }
284
285 pHDMIRxResourcePrivate->usHDCP14RiCount[HDMI_GET_PORT_SELECT(enPortIndex)] = 0;
286 }
287 }
288 }
289
290 //**************************************************************************
291 // [Function Name]:
292 // _mdrv_HDMI_PollingTask
293 // [Description]:
294 //
295 // [Arguments]:
296 //
297 // [Return]:
298 //
299 //**************************************************************************
_mdrv_HDMI_PollingTask(void)300 static void _mdrv_HDMI_PollingTask(void)
301 {
302 void* pModule = NULL;
303 void* pHDMIRxResource = NULL;
304 MS_BOOL bHDMITaskProcFlag = TRUE;
305 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
306
307 UtopiaModuleGetPtr(MODULE_HDMIRX, &pModule);
308
309 while(bHDMITaskProcFlag)
310 {
311 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
312 {
313 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
314 }
315 else
316 {
317 if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
318 {
319 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
320 }
321 else
322 {
323 Hal_HDMI_StablePolling(pHDMIRxResourcePrivate->ucMHLSupportPath, pHDMIRxResourcePrivate->stHDMIPollingInfo);
324
325 _mdrv_HDMI_CheckPacketReceiveProc(pHDMIRxResourcePrivate);
326 _mdrv_HDMI_CheckHDCP14RiProc(pHDMIRxResourcePrivate);
327
328 bHDMITaskProcFlag = pHDMIRxResourcePrivate->bHDMITaskProcFlag;
329 }
330 }
331
332 UtopiaResourceRelease(pHDMIRxResource);
333
334 MsOS_DelayTask(HDMI_POLLING_INTERVAL);
335 }
336 }
337
338 //**************************************************************************
339 // [Function Name]:
340 // _mdrv_HDMI_CreateTask
341 // [Description]:
342 //
343 // [Arguments]:
344 //
345 // [Return]:
346 //
347 //**************************************************************************
_mdrv_HDMI_CreateTask(HDMI_RX_RESOURCE_PRIVATE * pHDMIRxResourcePrivate)348 MS_BOOL _mdrv_HDMI_CreateTask(HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate)
349 {
350 MS_BOOL bCreateSuccess = TRUE;
351
352 if(pHDMIRxResourcePrivate->slHDMIPollingTaskID < 0)
353 {
354 pHDMIRxResourcePrivate->slHDMIPollingTaskID = MsOS_CreateTask((TaskEntry) _mdrv_HDMI_PollingTask,
355 (MS_VIRT) NULL,
356 E_TASK_PRI_MEDIUM,
357 TRUE,
358 (void *)pHDMIRxResourcePrivate->ucHDMIPollingStack,
359 HDMI_POLLING_STACK_SIZE,
360 "HDMI Rx task");
361
362 pHDMIRxResourcePrivate->bHDMITaskProcFlag = TRUE;
363 }
364
365 if(pHDMIRxResourcePrivate->slHDMIPollingTaskID < 0)
366 {
367 MDRV_HDMIRX_MSG_ERROR("MsOS_CreateTask failed!!\n");
368
369 MsOS_DeleteEventGroup(pHDMIRxResourcePrivate->slHDMIPollingTaskID);
370
371 bCreateSuccess = FALSE;;
372 }
373
374 return bCreateSuccess;
375 }
376
377 //**************************************************************************
378 // [Function Name]:
379 // _mdrv_HDMI_CheckHDCP14Bksv()
380 // [Description]
381 //
382 // [Arguments]:
383 //
384 // [Return]:
385 //
386 //**************************************************************************
_mdrv_HDMI_CheckHDCP14Bksv(MS_U8 * ucBksvTable)387 MS_BOOL _mdrv_HDMI_CheckHDCP14Bksv(MS_U8 *ucBksvTable)
388 {
389 MS_BOOL bHDCP14KeyVaild = FALSE;
390 MS_U8 uctemp = 0;
391 MS_U8 ucOneCount = 0;
392 MS_U8 ucBksvValue = 0;
393
394 if(ucBksvTable != NULL)
395 {
396 for(uctemp = 0; uctemp < HDMI_HDCP_BKSV_LENGTH; uctemp++)
397 {
398 ucBksvValue = ucBksvTable[uctemp];
399
400 while(ucBksvValue > 0)
401 {
402 if(ucBksvValue & BIT(0))
403 {
404 ucOneCount++;
405 }
406
407 ucBksvValue = ucBksvValue >> 1;
408 }
409 }
410
411 if(ucOneCount == 20)
412 {
413 bHDCP14KeyVaild = TRUE;
414 }
415 }
416
417 return bHDCP14KeyVaild;
418 }
419
420 //**************************************************************************
421 // [Function Name]:
422 // _mdrv_HDCP_InterruptTask
423 // [Description]:
424 //
425 // [Arguments]:
426 //
427 // [Return]:
428 //
429 //**************************************************************************
_mdrv_HDCP_InterruptTask(void)430 static void _mdrv_HDCP_InterruptTask(void)
431 {
432 MS_BOOL bHDCPTaskProcFlag = TRUE;
433 E_MUX_INPUTPORT enInputPortType = 0;
434 stHDCP22_HANDLER XCArgs = {0};
435 stHDCP22_WAIT_EVENT stHDMIRxArgs = {0};
436
437 XCArgs.bHdcp22RecvMsgFlag = FALSE;
438 XCArgs.bIRQModeFlag = TRUE;
439 XCArgs.ucHdcp22PortType = E_HDCP22_IF_HDMI;
440 XCArgs.ucHdcp22MsgLen = 0;
441 stHDMIRxArgs.ucHDCPWriteDoneIndex = 0;
442
443 while(bHDCPTaskProcFlag)
444 {
445 if(pulHDMIRxInst == NULL)
446 {
447 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
448 }
449 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_HDCP22_WAIT_EVENT, (void*)&stHDMIRxArgs) != 0)
450 {
451 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
452 }
453
454 //MDRV_HDMIRX_MSG_INFO("** TMDS wait event happen user space !!!!!!\r\n");
455
456 for(enInputPortType = INPUT_PORT_DVI0; enInputPortType <= INPUT_PORT_DVI_END; enInputPortType++)
457 {
458 if(stHDMIRxArgs.ucHDCPWriteDoneIndex &BIT(HDMI_GET_PORT_SELECT(enInputPortType)))
459 {
460 XCArgs.ucPortIdx = HDMI_GET_PORT_SELECT(enInputPortType);
461
462 if(pulHDMIRxInst == NULL)
463 {
464 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
465 }
466 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_HDCP22_HANDLER, (void*)&XCArgs) != 0)
467 {
468 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
469 }
470
471 if(XCArgs.bHdcp22RecvMsgFlag)
472 {
473 if (fpHdcp22RecMsgCBFunc != NULL)
474 {
475 fpHdcp22RecMsgCBFunc(XCArgs.ucHdcp22PortType, HDMI_GET_PORT_SELECT(enInputPortType), XCArgs.pucHdcp22MsgData, XCArgs.ucHdcp22MsgLen, NULL);
476 }
477 }
478 }
479 }
480
481 bHDCPTaskProcFlag = bHDCPInterruptProcFlag;
482 }
483 }
484
485 //**************************************************************************
486 // [Function Name]:
487 // _mdrv_HDCP_CreateInterruptTask
488 // [Description]:
489 //
490 // [Arguments]:
491 //
492 // [Return]:
493 //
494 //**************************************************************************
_mdrv_HDCP_CreateInterruptTask(void)495 MS_BOOL _mdrv_HDCP_CreateInterruptTask(void)
496 {
497 MS_BOOL bCreateSuccess = TRUE;
498
499 if(slHDCPInterruptTaskID < 0)
500 {
501 slHDCPInterruptTaskID = MsOS_CreateTask((TaskEntry) _mdrv_HDCP_InterruptTask,
502 (MS_VIRT) NULL,
503 E_TASK_PRI_MEDIUM,
504 TRUE,
505 (void *)ucHDCPInterruptStack,
506 HDMI_HDCP_INTERRUPT_STACK_SIZE,
507 "HDCP int task");
508
509 bHDCPInterruptProcFlag = TRUE;
510 }
511
512 if(slHDCPInterruptTaskID < 0)
513 {
514 MDRV_HDMIRX_MSG_ERROR("MsOS_CreateTask failed!!\n");
515
516 MsOS_DeleteEventGroup(slHDCPInterruptTaskID);
517
518 bCreateSuccess = FALSE;;
519 }
520
521 return bCreateSuccess;
522 }
523
524 //**************************************************************************
525 // [Function Name]:
526 // _mdrv_HDCP_IsrHandler()
527 // [Description]
528 //
529 // [Arguments]:
530 //
531 // [Return]:
532 //
533 //**************************************************************************
_mdrv_HDCP_IsrHandler(InterruptNum eIntNum)534 static void _mdrv_HDCP_IsrHandler(InterruptNum eIntNum)
535 {
536 void* pModule = NULL;
537 void* pHDMIRxResource = NULL;
538 MS_BOOL bGetResourceFlag = FALSE;
539 E_MUX_INPUTPORT enInputPortType = 0;
540 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
541
542 UtopiaModuleGetPtr(MODULE_HDMIRX, &pModule);
543
544 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
545 {
546 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
547 }
548 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
549 {
550 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
551 }
552 else
553 {
554 bGetResourceFlag = TRUE;
555 }
556
557 UNUSED(eIntNum);
558
559 for(enInputPortType = INPUT_PORT_DVI0; enInputPortType <= INPUT_PORT_DVI_END; enInputPortType++)
560 {
561 if(Hal_HDCP22_PollingWriteDone(HDMI_GET_PORT_SELECT(enInputPortType)) && bGetResourceFlag)
562 {
563 pHDMIRxResourcePrivate->ucHDCPWriteDoneIndex |= BIT(HDMI_GET_PORT_SELECT(enInputPortType));
564
565 if(GET_HDMI_FLAG(pHDMIRxResourcePrivate->ucHDCPReadDoneIndex, BIT(HDMI_GET_PORT_SELECT(enInputPortType))))
566 {
567 CLR_HDMI_FLAG(pHDMIRxResourcePrivate->ucHDCPReadDoneIndex, BIT(HDMI_GET_PORT_SELECT(enInputPortType)));
568 }
569 }
570
571 if(Hal_HDCP22_PollingReadDone(HDMI_GET_PORT_SELECT(enInputPortType)) && bGetResourceFlag)
572 {
573 if(pHDMIRxResourcePrivate->ucHDCP22RecvIDListSend[HDMI_GET_PORT_SELECT(enInputPortType)])
574 {
575 Hal_HDCP22_SetReadyBit(HDMI_GET_PORT_SELECT(enInputPortType), FALSE); //clear ready bit after source read re
576
577 pHDMIRxResourcePrivate->ucHDCP22RecvIDListSend[HDMI_GET_PORT_SELECT(enInputPortType)] = FALSE;
578 }
579
580 SET_HDMI_FLAG(pHDMIRxResourcePrivate->ucHDCPReadDoneIndex, BIT(HDMI_GET_PORT_SELECT(enInputPortType)));
581 }
582 }
583
584 if(bGetResourceFlag)
585 {
586 if(pHDMIRxResourcePrivate->ucHDCPWriteDoneIndex > 0)
587 {
588 MsOS_SetEvent(pHDMIRxResourcePrivate->slHDMIHDCPEventID, HDMI_HDCP_EVENT_WRITE_DONE);
589 }
590 }
591
592 MsOS_EnableInterrupt(E_INT_IRQ_DVI_HDMI_HDCP);
593
594 UtopiaResourceRelease(pHDMIRxResource);
595 }
596
MDrv_HDCP22_FillCipherKey(MS_U8 ucPortIdx,MS_U8 * pucRiv,MS_U8 * pucSessionKey)597 void MDrv_HDCP22_FillCipherKey(MS_U8 ucPortIdx, MS_U8* pucRiv, MS_U8* pucSessionKey)
598 {
599 stHDCP22_FILL_CIPHER_KEY XCArgs;
600
601 XCArgs.ucPortIdx = ucPortIdx;
602 XCArgs.pucRiv = pucRiv;
603 XCArgs.pucSessionKey = pucSessionKey;
604
605 if(pulHDMIRxInst == NULL)
606 {
607 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
608 }
609 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_HDCP22_FILL_CIPHER_KEY, (void*)&XCArgs) != 0)
610 {
611 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
612 }
613 }
614
MDrv_HDCP22_InitCBFunc(HDCP22_Recv_CBF pCBFunc,void * pContext)615 void MDrv_HDCP22_InitCBFunc(HDCP22_Recv_CBF pCBFunc, void* pContext)
616 {
617 if(pCBFunc != NULL)
618 {
619 fpHdcp22RecMsgCBFunc = pCBFunc;
620 }
621 }
622
MDrv_HDCP22_PortInit(MS_U8 ucPortIdx)623 void MDrv_HDCP22_PortInit(MS_U8 ucPortIdx)
624 {
625 stHDCP22_PORT_INIT XCArgs = {0};
626
627 XCArgs.ucPortIdx = ucPortIdx;
628
629 if(pulHDMIRxInst == NULL)
630 {
631 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
632 }
633 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_HDCP22_PORT_INIT, (void*)&XCArgs) != 0)
634 {
635 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
636 }
637 }
638
MDrv_HDCP22_PollingReadDone(MS_U8 ucPortIdx)639 MS_BOOL MDrv_HDCP22_PollingReadDone(MS_U8 ucPortIdx)
640 {
641 stHDCP22_POLLING_READ_DONE XCArgs = {0};
642
643 XCArgs.ucPortIdx = ucPortIdx;
644 XCArgs.bReturnValue = FALSE;
645
646 if(pulHDMIRxInst == NULL)
647 {
648 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
649 }
650 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_HDCP22_POLLING_READ_DONE, (void*)&XCArgs) != 0)
651 {
652 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
653 }
654
655 return XCArgs.bReturnValue;
656 }
657
MDrv_HDCP22_EnableCipher(MS_U8 ucPortType,MS_U8 ucPortIdx,MS_BOOL bIsEnable)658 void MDrv_HDCP22_EnableCipher(MS_U8 ucPortType, MS_U8 ucPortIdx, MS_BOOL bIsEnable)
659 {
660 stHDCP22_ENABLE_CIPHER XCArgs = {0};
661
662 XCArgs.ucPortType = ucPortType;
663 XCArgs.ucPortIdx = ucPortIdx;
664 XCArgs.bIsEnable = bIsEnable;
665
666 if(pulHDMIRxInst == NULL)
667 {
668 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
669 }
670 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_HDCP22_ENABLE_CIPHER, (void*)&XCArgs) != 0)
671 {
672 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
673 }
674 }
675
MDrv_HDCP22_SendMsg(MS_U8 ucPortType,MS_U8 ucPortIdx,MS_U8 * pucData,MS_U32 dwDataLen,void * pDummy)676 void MDrv_HDCP22_SendMsg(MS_U8 ucPortType, MS_U8 ucPortIdx, MS_U8* pucData, MS_U32 dwDataLen, void* pDummy)
677 {
678 stHDCP22_SEND_MESSAGE XCArgs;
679
680 XCArgs.ucPortType = ucPortType;
681 XCArgs.ucPortIdx = ucPortIdx;
682 XCArgs.pucData = pucData;
683 XCArgs.dwDataLen = dwDataLen;
684 XCArgs.pDummy = pDummy;
685
686 if(pulHDMIRxInst == NULL)
687 {
688 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
689 }
690 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_HDCP22_SEND_MESSAGE, (void*)&XCArgs) != 0)
691 {
692 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
693 }
694 }
695
MDrv_HDCP22_Handler(MS_U8 ucPortIdx)696 void MDrv_HDCP22_Handler(MS_U8 ucPortIdx)
697 {
698 stHDCP22_HANDLER XCArgs = {0};
699
700 XCArgs.bHdcp22RecvMsgFlag = FALSE;
701 XCArgs.bIRQModeFlag = FALSE;
702 XCArgs.ucPortIdx = ucPortIdx;
703 XCArgs.ucHdcp22PortType = E_HDCP22_IF_HDMI;
704 XCArgs.ucHdcp22MsgLen = 0;
705
706 if(pulHDMIRxInst == NULL)
707 {
708 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
709 }
710 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_HDCP22_HANDLER, (void*)&XCArgs) != 0)
711 {
712 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
713 }
714
715 if(XCArgs.bHdcp22RecvMsgFlag)
716 {
717 if (fpHdcp22RecMsgCBFunc != NULL)
718 {
719 fpHdcp22RecMsgCBFunc(XCArgs.ucHdcp22PortType, ucPortIdx, XCArgs.pucHdcp22MsgData, XCArgs.ucHdcp22MsgLen, NULL);
720 }
721 }
722 }
723
724 //-------------------------------------------------------------------------------------------------
725 /// report which patch function hdmi needs
726 /// @return @ref MS_U16
727 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Func_Caps_U2(void * pInstance)728 MS_U16 MDrv_HDMI_Func_Caps_U2(void* pInstance)
729 {
730 return Hal_HDMI_Func_Caps();
731 }
732
MDrv_HDMI_Func_Caps(void)733 MS_U16 MDrv_HDMI_Func_Caps(void)
734 {
735 if (pu32XCInst == NULL)
736 {
737 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
738 return 0;
739 }
740
741 stHDMI_FUNC_CAPS XCArgs;
742 XCArgs.u16ReturnValue = 0;
743
744 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_FUNC_CAPS, (void*)&XCArgs) != 0)
745 {
746 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
747 return 0;
748 }
749 else
750 {
751 return XCArgs.u16ReturnValue;
752 }
753 }
754
755 //-------------------------------------------------------------------------------------------------
756 /// Check the HDCP is exist or not
757 /// @return @ref MS_BOOL
758 //-------------------------------------------------------------------------------------------------
MDrv_HDCP_isexist(void)759 MS_BOOL MDrv_HDCP_isexist(void)
760 {
761 MS_HDCP_STATUS_INFO_t* enStatus_info;
762 enStatus_info = MDrv_HDCP_GetStatus();
763
764 if(enStatus_info->b_St_Reserve_1 && enStatus_info->b_St_ENC_En)
765 {
766 MDRV_HDMIRX_MSG_INFO("HDCP is exit");
767 return TRUE;
768 }
769 else
770 {
771 MDRV_HDMIRX_MSG_INFO("No HDCP");
772 return FALSE;
773 }
774 }
775 //-------------------------------------------------------------------------------------------------
776 /// DDC clock on/off control
777 /// @param bEnable \b IN: ON/OFF control
778 //-------------------------------------------------------------------------------------------------
MDrv_HDCP_Enable_U2(void * pInstance,MS_BOOL bEnable)779 void MDrv_HDCP_Enable_U2(void* pInstance, MS_BOOL bEnable)
780 {
781 #if SUPPORT_HDMI_RX_NEW_FEATURE
782 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
783 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
784 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
785 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
786 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
787 if(IsSrcTypeHDMI(gSrcInfo[MAIN_WINDOW].enInputSourceType))
788 {
789 Hal_HDCP_ddc_en(MDrv_XC_Mux_GetHDMIPort(pInstance, gSrcInfo[MAIN_WINDOW].enInputSourceType), bEnable);
790 }
791 else if(IsSrcTypeHDMI(gSrcInfo[SUB_WINDOW].enInputSourceType))
792 {
793 Hal_HDCP_ddc_en(MDrv_XC_Mux_GetHDMIPort(pInstance, gSrcInfo[SUB_WINDOW].enInputSourceType), bEnable);
794 }
795 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
796 #else
797 Hal_HDCP_ddc_en(bEnable);
798 #endif
799 }
800
MDrv_HDCP_Enable(MS_BOOL bEnable)801 void MDrv_HDCP_Enable(MS_BOOL bEnable)
802 {
803 if (pu32XCInst == NULL)
804 {
805 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
806 return;
807 }
808
809 stHDCP_ENABLE XCArgs;
810 XCArgs.bEnable = bEnable;
811
812 if(UtopiaIoctl(pu32XCInst, E_XC_HDCP_IF_CMD_ENABLE, (void*)&XCArgs) != 0)
813 {
814 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
815 return;
816 }
817 else
818 {
819 return;
820 }
821 }
822
823 //-------------------------------------------------------------------------------------------------
824 /// DDC clock on/off control
825 /// @param enInputPortType \b IN: Input source selection
826 /// @param bEnable \b IN: ON/OFF control
827 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_SetHdcpEnable_U2(void * pInstance,E_MUX_INPUTPORT enInputPortType,MS_BOOL bEnable)828 MS_BOOL MDrv_HDMI_SetHdcpEnable_U2(void* pInstance, E_MUX_INPUTPORT enInputPortType,MS_BOOL bEnable)
829 {
830 /*Only DVI port can enable/disable hdcp key*/
831 if(enInputPortType < INPUT_PORT_DVI0 || enInputPortType > INPUT_PORT_DVI3)
832 {
833 return FALSE;
834 }
835
836 #if SUPPORT_HDMI_RX_NEW_FEATURE
837 Hal_HDCP_ddc_en(enInputPortType, bEnable);
838 #else
839 enInputPortType = enInputPortType;
840 Hal_HDCP_ddc_en(bEnable);
841 #endif
842 return TRUE;
843 }
844
MDrv_HDMI_SetHdcpEnable(E_MUX_INPUTPORT enInputPortType,MS_BOOL bEnable)845 MS_BOOL MDrv_HDMI_SetHdcpEnable(E_MUX_INPUTPORT enInputPortType,MS_BOOL bEnable)
846 {
847 if (pu32XCInst == NULL)
848 {
849 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
850 return FALSE;
851 }
852
853 stHDMI_SET_HDCPENABLE XCArgs;
854 XCArgs.enInputPortType = enInputPortType;
855 XCArgs.bEnable = bEnable;
856 XCArgs.bReturnValue = FALSE;
857
858 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_SET_HDCP_ENABLE, (void*)&XCArgs) != 0)
859 {
860 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
861 return FALSE;
862 }
863 else
864 {
865 return XCArgs.bReturnValue;
866 }
867 }
868
869 //-------------------------------------------------------------------------------------------------
870 /// Check the ending of the Vsync
871 /// @param bStable \b IN: Stable or not
872 //-------------------------------------------------------------------------------------------------
MDrv_HDCP_Vsync_end_en_U2(void * pInstance,MS_BOOL bStable)873 void MDrv_HDCP_Vsync_end_en_U2(void* pInstance, MS_BOOL bStable)
874 {
875 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
876 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
877 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
878
879 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
880 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
881 if(bStable)
882 {
883 if(!pXCResourcePrivate->stdrv_HDMI._bHDCP_Vsync_count)
884 {
885 pXCResourcePrivate->stdrv_HDMI.u32VsyncTimer = MsOS_GetSystemTime();
886 pXCResourcePrivate->stdrv_HDMI._bHDCP_Vsync_count = TRUE;
887 }
888 if ((pXCResourcePrivate->stdrv_HDMI._bHDCP_Vsync_done) && ((MsOS_GetSystemTime() - pXCResourcePrivate->stdrv_HDMI.u32VsyncTimer) > 4500) )
889 {
890 Hal_HDCP_Vsync_end_en(TRUE);
891 pXCResourcePrivate->stdrv_HDMI._bHDCP_Vsync_done = FALSE;
892 }
893 }
894 else
895 {
896 if (!pXCResourcePrivate->stdrv_HDMI._bHDCP_Vsync_done)
897 {
898 Hal_HDCP_Vsync_end_en(FALSE);
899 pXCResourcePrivate->stdrv_HDMI._bHDCP_Vsync_done = TRUE;
900 pXCResourcePrivate->stdrv_HDMI._bHDCP_Vsync_count = FALSE;
901 }
902 }
903 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
904 }
905
MDrv_HDCP_Vsync_end_en(MS_BOOL bStable)906 void MDrv_HDCP_Vsync_end_en(MS_BOOL bStable)
907 {
908 if (pu32XCInst == NULL)
909 {
910 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
911 return;
912 }
913
914 stHDCP_VSYNC_END_EN XCArgs;
915 XCArgs.bStable = bStable;
916
917 if(UtopiaIoctl(pu32XCInst, E_XC_HDCP_IF_CMD_VSYNC_END_EN, (void*)&XCArgs) != 0)
918 {
919 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
920 return;
921 }
922 else
923 {
924 return;
925 }
926 }
927
928 //-------------------------------------------------------------------------------------------------
929 /// Exit the HDMI and turn off the related setting of HDMI
930 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Exit_U2(void * pInstance)931 void MDrv_HDMI_Exit_U2( void* pInstance )
932 {
933 #if SUPPORT_HDMI_RX_NEW_FEATURE
934 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
935 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
936 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
937 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
938 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
939 if(IsSrcTypeHDMI(gSrcInfo[MAIN_WINDOW].enInputSourceType))
940 {
941 Hal_HDMI_exit(MDrv_XC_Mux_GetHDMIPort(pInstance, gSrcInfo[MAIN_WINDOW].enInputSourceType));
942 }
943 else if(IsSrcTypeHDMI(gSrcInfo[SUB_WINDOW].enInputSourceType))
944 {
945 Hal_HDMI_exit(MDrv_XC_Mux_GetHDMIPort(pInstance, gSrcInfo[SUB_WINDOW].enInputSourceType));
946 }
947 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
948 #else
949 Hal_HDMI_exit();
950 #endif
951 #if 0
952 if(g_bIMMESWITCH_DVI_POWERSAVING)
953 memset(u8PSDVIStableCount, 0, 4*sizeof(MS_U8));
954 #endif
955 }
956
MDrv_HDMI_Exit(void)957 void MDrv_HDMI_Exit( void )
958 {
959 if (pu32XCInst == NULL)
960 {
961 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
962 return;
963 }
964
965 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_EXIT, NULL) != 0)
966 {
967 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
968 return;
969 }
970 else
971 {
972 return;
973 }
974 }
975
976
977 //-------------------------------------------------------------------------------------------------
978 /// Init the setting for HDMI
979 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_init_internal(void * pInstance)980 stHDMI_INITIAL_TABLE MDrv_HDMI_init_internal(void *pInstance)
981 {
982 stHDMI_INITIAL_TABLE stInitialTable = {0};
983 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
984 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
985 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
986 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
987 pXCResourcePrivate->stdrv_HDMI._info.u8SupportPorts = 0;
988 pXCResourcePrivate->stdrv_HDMI._status.bIsInitialized = TRUE;
989 pXCResourcePrivate->stdrv_HDMI._status.bIsRunning = TRUE;
990
991 bInitEnable = TRUE;
992
993 if (SUPPORT_IMMESWITCH)
994 {
995 pXCResourcePrivate->stdrvXC_MVideo_Context.g_bIsIMMESWITCH = (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_IMMESWITCH);
996 pXCResourcePrivate->stdrvXC_MVideo_Context.g_bIMMESWITCH_DVI_POWERSAVING = (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_IMMESWITCH_DVI_POWERSAVING) >> 1;
997 }
998 else
999 {
1000 pXCResourcePrivate->stdrvXC_MVideo_Context.g_bIsIMMESWITCH = FALSE;
1001 pXCResourcePrivate->stdrvXC_MVideo_Context.g_bIMMESWITCH_DVI_POWERSAVING = FALSE;
1002 }
1003 #ifdef K3_U2
1004 if (SUPPORT_DVI_AUTO_EQ)
1005 {
1006 pXCResourcePrivate->stdrvXC_MVideo_Context.g_bDVI_AUTO_EQ = (pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Init_Misc.u32MISC_A & E_XC_INIT_MISC_A_DVI_AUTO_EQ) >> 2;
1007 }
1008 else
1009 {
1010 pXCResourcePrivate->stdrvXC_MVideo_Context.g_bDVI_AUTO_EQ = FALSE;
1011 }
1012 #else
1013 pXCResourcePrivate->stdrvXC_MVideo_Context.g_bDVI_AUTO_EQ = SUPPORT_DVI_AUTO_EQ;
1014 #endif
1015
1016 MDRV_HDMIRX_MSG_INFO("[%s][%d]pXCResourcePrivate->stdrvXC_MVideo_Context.g_bIsIMMESWITCH=%x\n", __FUNCTION__, __LINE__,
1017 pXCResourcePrivate->stdrvXC_MVideo_Context.g_bIsIMMESWITCH);
1018 MDRV_HDMIRX_MSG_INFO("[%s][%d]pXCResourcePrivate->stdrvXC_MVideo_Context.g_bIMMESWITCH_DVI_POWERSAVING=%x\n", __FUNCTION__, __LINE__,
1019 pXCResourcePrivate->stdrvXC_MVideo_Context.g_bIMMESWITCH_DVI_POWERSAVING);
1020
1021 Hal_HDMI_init(pXCResourcePrivate->stdrvXC_MVideo_Context.g_bIsIMMESWITCH, pXCResourcePrivate->stdrvXC_MVideo_Context._u8MhlSupportInfo);
1022
1023 stInitialTable.bImmeswitchSupport = pXCResourcePrivate->stdrvXC_MVideo_Context.g_bIsIMMESWITCH;
1024 stInitialTable.ucMHLSupportPath = pXCResourcePrivate->stdrvXC_MVideo_Context._u8MhlSupportInfo;
1025
1026 return stInitialTable;
1027 }
1028
MDrv_HDMI_init_U2(void * pInstance)1029 stHDMI_INITIAL_TABLE MDrv_HDMI_init_U2( void* pInstance )
1030 {
1031 stHDMI_INITIAL_TABLE stInitialTable = {0};
1032 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1033 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1034 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1035
1036 stInitialTable = MDrv_HDMI_init_internal(pInstance);
1037
1038 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1039
1040 return stInitialTable;
1041 }
1042
MDrv_HDMI_init(void)1043 void MDrv_HDMI_init( void )
1044 {
1045 MS_BOOL bInitialFlag = FALSE;
1046 stHDMI_INITIAL_SETTING XCArgs;
1047
1048 XCArgs.stInitialTable.bImmeswitchSupport = FALSE;
1049 XCArgs.stInitialTable.ucMHLSupportPath = 0;
1050
1051 if(pu32XCInst == NULL)
1052 {
1053 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1054 }
1055 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_INIT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1056 {
1057 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1058 }
1059
1060 if(pulHDMIRxInst == NULL)
1061 {
1062 if(UtopiaOpen(MODULE_HDMIRX, &pulHDMIRxInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
1063 {
1064 MDRV_HDMIRX_MSG_ERROR("UtopiaOpen pulHDMIRxInst failed\n");
1065
1066 bInitialFlag = TRUE;
1067 }
1068 }
1069
1070 if(!bInitialFlag)
1071 {
1072 if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_INITIAL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
1073 {
1074 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
1075 }
1076 }
1077
1078 if(!bHDCPInterruptCreateFlag)
1079 {
1080 _mdrv_HDCP_CreateInterruptTask();
1081
1082 bHDCPInterruptCreateFlag = TRUE;
1083 }
1084 }
1085
1086 //-------------------------------------------------------------------------------------------------
1087 /// Set the equalizer volumn for HDMI
1088 /// @param enEq \b IN: ON/OFF the equlizer
1089 /// @param u8EQValue \b IN: The volumn of equalizer
1090 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Set_EQ_U2(void * pInstance,MS_HDMI_EQ enEq,MS_U8 u8EQValue)1091 void MDrv_HDMI_Set_EQ_U2(void* pInstance, MS_HDMI_EQ enEq, MS_U8 u8EQValue)
1092 {
1093 #if SUPPORT_HDMI_RX_NEW_FEATURE
1094 INPUT_SOURCE_TYPE_t src;
1095 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1096 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1097 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1098 for(src = INPUT_SOURCE_HDMI; src < INPUT_SOURCE_HDMI_MAX; src++)
1099 {
1100 Hal_HDMI_Set_EQ(MDrv_XC_Mux_GetHDMIPort(pInstance, src), enEq, u8EQValue);
1101 }
1102 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1103 #else
1104 Hal_HDMI_Set_EQ(enEq, u8EQValue);
1105 #endif
1106 }
1107
MDrv_HDMI_Set_EQ(MS_HDMI_EQ enEq,MS_U8 u8EQValue)1108 void MDrv_HDMI_Set_EQ(MS_HDMI_EQ enEq, MS_U8 u8EQValue)
1109 {
1110 if (pu32XCInst == NULL)
1111 {
1112 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1113 return;
1114 }
1115
1116 stHDMI_SET_EQ XCArgs;
1117 XCArgs.enEq = enEq;
1118 XCArgs.u8EQValue = u8EQValue;
1119
1120 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_SET_EQ, (void*)&XCArgs) != 0)
1121 {
1122 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1123 return;
1124 }
1125 else
1126 {
1127 return;
1128 }
1129 }
1130
1131 //-------------------------------------------------------------------------------------------------
1132 /// Set the equalizer volumn for HDMI to single port
1133 /// @param enEq \b IN: ON/OFF the equlizer
1134 /// @param u8EQValue \b IN: The volumn of equalizer
1135 /// @param enInputPortType \b IN: The appointed port
1136 /// @return @ref MS_BOOL
1137 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Set_EQ_To_Port_U2(void * pInstance,MS_HDMI_EQ enEq,MS_U8 u8EQValue,E_MUX_INPUTPORT enInputPortType)1138 MS_BOOL MDrv_HDMI_Set_EQ_To_Port_U2(void* pInstance, MS_HDMI_EQ enEq, MS_U8 u8EQValue, E_MUX_INPUTPORT enInputPortType)
1139 {
1140 #if SUPPORT_HDMI_RX_NEW_FEATURE
1141 Hal_HDMI_Set_EQ(enInputPortType, enEq, u8EQValue);
1142 return TRUE;
1143 #else
1144 MDRV_HDMIRX_MSG_INFO("[Warning]Unsupport set EQ to single port!");
1145 return FALSE;
1146 #endif
1147 }
1148
MDrv_HDMI_Set_EQ_To_Port(MS_HDMI_EQ enEq,MS_U8 u8EQValue,E_MUX_INPUTPORT enInputPortType)1149 MS_BOOL MDrv_HDMI_Set_EQ_To_Port(MS_HDMI_EQ enEq, MS_U8 u8EQValue, E_MUX_INPUTPORT enInputPortType)
1150 {
1151 if (pu32XCInst == NULL)
1152 {
1153 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1154 return FALSE;
1155 }
1156
1157 stHDMI_SET_EQ_TO_PORT XCArgs;
1158 XCArgs.enEq = enEq;
1159 XCArgs.u8EQValue = u8EQValue;
1160 XCArgs.enInputPortType = enInputPortType;
1161 XCArgs.bReturnValue = FALSE;
1162
1163 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_SET_EQ_TO_PORT, (void*)&XCArgs) != 0)
1164 {
1165 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1166 return FALSE;
1167 }
1168 else
1169 {
1170 return XCArgs.bReturnValue;
1171 }
1172 }
1173
1174 //-------------------------------------------------------------------------------------------------
1175 /// Enable the Audio mute event for Vivaldi
1176 /// @param u16MuteEvent \b IN: The mute event
1177 /// @param u16MuteMask \b IN: The mute mask
1178 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Audio_MUTE_Enable_U2(void * pInstance,MS_U16 u16MuteEvent,MS_U16 u16MuteMask)1179 void MDrv_HDMI_Audio_MUTE_Enable_U2(void* pInstance, MS_U16 u16MuteEvent,MS_U16 u16MuteMask)
1180 {
1181 Hal_HDMI_Audio_MUTE_Enable(u16MuteEvent, u16MuteMask);
1182 }
1183
MDrv_HDMI_Audio_MUTE_Enable(MS_U16 u16MuteEvent,MS_U16 u16MuteMask)1184 void MDrv_HDMI_Audio_MUTE_Enable(MS_U16 u16MuteEvent,MS_U16 u16MuteMask)
1185 {
1186 if (pu32XCInst == NULL)
1187 {
1188 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1189 return;
1190 }
1191
1192 stHDMI_AUDIO_MUTE_ENABLE XCArgs;
1193 XCArgs.u16MuteEvent = u16MuteEvent;
1194 XCArgs.u16MuteMask = u16MuteMask;
1195
1196 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AUDIO_MUTE_ENABLE, (void*)&XCArgs) != 0)
1197 {
1198 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1199 return;
1200 }
1201 else
1202 {
1203 return;
1204 }
1205 }
1206
1207 //-------------------------------------------------------------------------------------------------
1208 /// Clear the Audio mute status.
1209 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Audio_Status_Clear_U2(void * pInstance)1210 void MDrv_HDMI_Audio_Status_Clear_U2(void* pInstance)
1211 {
1212 Hal_HDMI_Audio_Status_Clear();
1213 }
1214
MDrv_HDMI_Audio_Status_Clear(void)1215 void MDrv_HDMI_Audio_Status_Clear(void)
1216 {
1217 if (pu32XCInst == NULL)
1218 {
1219 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1220 return;
1221 }
1222
1223 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AUDIO_STATUS_CLEAR, NULL) != 0)
1224 {
1225 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1226 return;
1227 }
1228 else
1229 {
1230 return;
1231 }
1232 }
1233
1234 //-------------------------------------------------------------------------------------------------
1235 /// Control the Hot Plug Detection
1236 /// in HIGH Level, the voltage level is 2.4 ~ 5.3V
1237 /// in LOW Level, the voltage level is 0 ~ 0.4V
1238 /// Enable hotplug GPIO[0] output and set output value
1239 /// @param bHighLow \b IN: High/Low control
1240 /// @param enInputPortType \b IN: Input source selection
1241 /// @param bInverse \b IN: Inverse or not
1242 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_pullhpd_internal(void * pInstance,MS_BOOL bHighLow,E_MUX_INPUTPORT enInputPortType,MS_BOOL bInverse)1243 void MDrv_HDMI_pullhpd_internal(void *pInstance, MS_BOOL bHighLow, E_MUX_INPUTPORT enInputPortType, MS_BOOL bInverse)
1244 {
1245 MDRV_HDMIRX_MSG_INFO("src hpd = %x \n",enInputPortType);
1246 // Fix me. Do not use HDMI_PORT_ALL and HDMI_PORT_A.
1247 // use E_MUX_INPUTPORT.
1248 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1249 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1250 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1251 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1252 pXCResourcePrivate->stdrvXC_MVideo_Context.g_bHDMIInverseBackUp[enInputPortType - INPUT_PORT_DVI0] = bInverse;
1253
1254 Hal_HDMI_pullhpd(bHighLow, enInputPortType, bInverse, pXCResourcePrivate->stdrvXC_MVideo_Context._u8MhlSupportInfo);
1255 }
1256
MDrv_HDMI_pullhpd_U2(void * pInstance,MS_BOOL bHighLow,E_MUX_INPUTPORT enInputPortType,MS_BOOL bInverse)1257 void MDrv_HDMI_pullhpd_U2( void* pInstance, MS_BOOL bHighLow, E_MUX_INPUTPORT enInputPortType, MS_BOOL bInverse)
1258 {
1259 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1260
1261 //MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Enter enInputPortType= %d, bHighLow=%x, tick=%d \n",__FUNCTION__,__LINE__, enInputPortType, bHighLow , MsOS_GetSystemTime());
1262
1263 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1264 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1265
1266 MDrv_HDMI_pullhpd_internal(pInstance, bHighLow, enInputPortType, bInverse);
1267
1268 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1269
1270 //MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Exit enInputPortType= %d, bHighLow=%x, tick=%d \n",__FUNCTION__,__LINE__, enInputPortType, bHighLow , MsOS_GetSystemTime());
1271 }
1272
MDrv_HDMI_pullhpd(MS_BOOL bHighLow,E_MUX_INPUTPORT enInputPortType,MS_BOOL bInverse)1273 void MDrv_HDMI_pullhpd( MS_BOOL bHighLow, E_MUX_INPUTPORT enInputPortType, MS_BOOL bInverse)
1274 {
1275 stHDMI_PULLHPD XCArgs = {0};
1276 stHDMI_SET_HPD_INVERT_FLAG stHDMIRxArgs = {0};
1277
1278 XCArgs.bHighLow = bHighLow;
1279 XCArgs.enInputPortType = enInputPortType;
1280 XCArgs.bInverse = bInverse;
1281
1282 if(pu32XCInst == NULL)
1283 {
1284 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1285 }
1286 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_PULLHPD, (void*)&XCArgs) != 0)
1287 {
1288 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1289 }
1290
1291 stHDMIRxArgs.enInputPortType = enInputPortType;
1292 stHDMIRxArgs.bInverse = bInverse;
1293
1294 if(pulHDMIRxInst == NULL)
1295 {
1296 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
1297 }
1298 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_SET_HPD_INVERT_FLAG, (void*)&stHDMIRxArgs) != 0)
1299 {
1300 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
1301 }
1302 }
1303
1304 //-------------------------------------------------------------------------------------------------
1305 /// HDMI G control information
1306 /// @param gcontrol \b IN: G control setting
1307 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_GC_Info_U2(void * pInstance,MS_U8 ucHDMIInfoSource,HDMI_GControl_INFO_t gcontrol)1308 MS_U16 MDrv_HDMI_GC_Info_U2(void* pInstance, MS_U8 ucHDMIInfoSource, HDMI_GControl_INFO_t gcontrol)
1309 {
1310 MS_U16 u16Return = 0;
1311 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1312 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1313 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1314 u16Return = Hal_HDMI_gcontrol_info(gcontrol, ucHDMIInfoSource);
1315 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1316 return u16Return;
1317 }
1318
MDrv_HDMI_GC_Info(HDMI_GControl_INFO_t gcontrol)1319 MS_U16 MDrv_HDMI_GC_Info(HDMI_GControl_INFO_t gcontrol)
1320 {
1321 stHDMI_GC_INFO XCArgs;
1322
1323 XCArgs.gcontrol = gcontrol;
1324 XCArgs.u16ReturnValue = 0;
1325 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
1326
1327 if(pu32XCInst == NULL)
1328 {
1329 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1330 }
1331 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GC_INFO, (void*)&XCArgs) != 0)
1332 {
1333 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1334 }
1335
1336 return XCArgs.u16ReturnValue;
1337 }
1338
1339 //-------------------------------------------------------------------------------------------------
1340 /// HDMI PLL control setting 1
1341 /// @param pllctrl \b IN: PLL control
1342 /// @param bread \b IN: Read/Write (1/0)
1343 /// @param u16value \b IN: Write value
1344 /// @return @ref MS_U16
1345 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_pll_ctrl1(HDMI_PLL_CTRL_t pllctrl,MS_BOOL bread,MS_U16 u16value)1346 MS_U16 MDrv_HDMI_pll_ctrl1(HDMI_PLL_CTRL_t pllctrl, MS_BOOL bread, MS_U16 u16value)
1347 {
1348 return (Hal_HDMI_pll_ctrl1(pllctrl, bread, u16value));
1349 }
1350 //-------------------------------------------------------------------------------------------------
1351 /// HDMI PLL control setting 2
1352 /// @param pllctrl \b IN: PLL control
1353 /// @param bread \b IN: Read/Write (1/0)
1354 /// @param u16value \b IN: Write value
1355 /// @return @ref MS_U16
1356 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_pll_ctrl2(HDMI_PLL_CTRL2_t pllctrl,MS_BOOL bread,MS_U16 u16value)1357 MS_U16 MDrv_HDMI_pll_ctrl2(HDMI_PLL_CTRL2_t pllctrl, MS_BOOL bread, MS_U16 u16value)
1358 {
1359 return (Hal_HDMI_pll_ctrl2(pllctrl, bread, u16value));
1360 }
1361
1362 ////////////////////////
1363
1364
1365 /******************************************************************************/
1366 /// for DVI
1367 /******************************************************************************/
1368 //-------------------------------------------------------------------------------------------------
1369 /// Check the clock is less 70MHz or not with DVI source
1370 /// @param enInputPortType \b IN: Input source
1371 /// @return @ref MS_BOOL
1372 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_SetForClockLessThan70Mhz_U2(void * pInstance,E_MUX_INPUTPORT enInputPortType)1373 MS_BOOL MDrv_HDMI_SetForClockLessThan70Mhz_U2( void* pInstance, E_MUX_INPUTPORT enInputPortType )
1374 {
1375 switch(enInputPortType)
1376 {
1377 default:
1378 case INPUT_PORT_DVI0:
1379 case INPUT_PORT_DVI1:
1380 case INPUT_PORT_DVI3:
1381 return Hal_DVI_clk_lessthan70mhz_usingportc(FALSE);
1382 case INPUT_PORT_DVI2:
1383 return Hal_DVI_clk_lessthan70mhz_usingportc(TRUE);
1384 }
1385 }
1386
MDrv_HDMI_SetForClockLessThan70Mhz(E_MUX_INPUTPORT enInputPortType)1387 MS_BOOL MDrv_HDMI_SetForClockLessThan70Mhz( E_MUX_INPUTPORT enInputPortType )
1388 {
1389 if (pu32XCInst == NULL)
1390 {
1391 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1392 return FALSE;
1393 }
1394
1395 stHDMI_SETFORCLOCKLESSTHAN70MHZ XCArgs;
1396 XCArgs.enInputPortType = enInputPortType;
1397 XCArgs.bReturnValue = FALSE;
1398
1399 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_SETFORCLOCKLESSTHAN70MHZ, (void*)&XCArgs) != 0)
1400 {
1401 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1402 return FALSE;
1403 }
1404 else
1405 {
1406 return XCArgs.bReturnValue;
1407 }
1408 }
1409
MDrv_DVI_SoftwareReset_U2(void * pInstance,MS_U16 u16Reset)1410 void MDrv_DVI_SoftwareReset_U2( void* pInstance, MS_U16 u16Reset )
1411 {
1412 Hal_DVI_sw_reset(u16Reset);
1413
1414 }
1415
MDrv_DVI_SoftwareReset(MS_U16 u16Reset)1416 void MDrv_DVI_SoftwareReset( MS_U16 u16Reset )
1417 {
1418 if (pu32XCInst == NULL)
1419 {
1420 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1421 return;
1422 }
1423
1424 stDVI_SOFTWARERESET XCArgs;
1425 XCArgs.u16Reset = u16Reset;
1426
1427 if(UtopiaIoctl(pu32XCInst, E_XC_DVI_IF_CMD_SOFTWARERESET, (void*)&XCArgs) != 0)
1428 {
1429 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1430 return;
1431 }
1432 else
1433 {
1434 return;
1435 }
1436 }
1437
1438 //-------------------------------------------------------------------------------------------------
1439 /// Detect the the clock is lose or not from ADC DTOP
1440 /// @param enInputPortType \b IN: Input source
1441 /// @return @ref MS_BOOL
1442 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_dvi_clock_detect(E_MUX_INPUTPORT enInputPortType)1443 MS_BOOL MDrv_HDMI_dvi_clock_detect(E_MUX_INPUTPORT enInputPortType)
1444 {
1445 MS_BOOL bIsLoss;
1446
1447 #if SUPPORT_HDMI_RX_NEW_FEATURE
1448 bIsLoss = Hal_DVI_clklose_det(enInputPortType);
1449 #else
1450 if (enInputPortType == INPUT_PORT_DVI2)
1451 {
1452 bIsLoss = Hal_DVI_clklose_det(TRUE);
1453 }
1454 else
1455 {
1456 bIsLoss = Hal_DVI_clklose_det(FALSE);
1457 }
1458 #endif
1459
1460 return bIsLoss;
1461 }
1462
1463 //-------------------------------------------------------------------------------------------------
1464 /// Reset the DVI setting
1465 //-------------------------------------------------------------------------------------------------
mdrv_dvi_reset_U2(void * pInstance)1466 void mdrv_dvi_reset_U2(void* pInstance)
1467 {
1468 #if SUPPORT_HDMI_RX_NEW_FEATURE
1469 INPUT_SOURCE_TYPE_t enInputSourceType = INPUT_SOURCE_NONE;
1470 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1471 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1472 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1473 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1474 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1475 if(IsSrcTypeHDMI(gSrcInfo[MAIN_WINDOW].enInputSourceType))
1476 {
1477 enInputSourceType = gSrcInfo[MAIN_WINDOW].enInputSourceType;
1478 }
1479 else if(IsSrcTypeHDMI(gSrcInfo[SUB_WINDOW].enInputSourceType))
1480 {
1481 enInputSourceType = gSrcInfo[SUB_WINDOW].enInputSourceType;
1482 }
1483 else
1484 {
1485 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1486 return;
1487 }
1488 if(Hal_DVI_irq_info(MDrv_XC_Mux_GetHDMIPort(pInstance, enInputSourceType), IRQ_DVI_CK_CHG) && (!pXCResourcePrivate->stdrv_HDMI._ResetDone))
1489 {
1490 MS_U16 u8_IRQ_STATUS;
1491
1492 u8_IRQ_STATUS = Hal_DVI_irq_info(MDrv_XC_Mux_GetHDMIPort(pInstance, enInputSourceType), IRQ_DVI_CK_CHG);
1493 Hal_DVI_irq_clear(MDrv_XC_Mux_GetHDMIPort(pInstance, enInputSourceType), u8_IRQ_STATUS);
1494 Hal_DVI_irq_clear(MDrv_XC_Mux_GetHDMIPort(pInstance, enInputSourceType), ~IRQ_ALL_BIT);
1495
1496 if (u8_IRQ_STATUS == IRQ_DVI_CK_CHG)
1497 {
1498 // not do DVI software reset at here; Avoid the snow image
1499
1500 pXCResourcePrivate->stdrv_HDMI._ResetDone = TRUE;
1501 }
1502 }
1503 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1504 #else
1505 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1506 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1507 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1508 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1509 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1510 if(Hal_DVI_irq_info(IRQ_DVI_CK_CHG) && (!pXCResourcePrivate->stdrv_HDMI._ResetDone))
1511 {
1512 MS_U16 u8_IRQ_STATUS;
1513
1514 u8_IRQ_STATUS = Hal_DVI_irq_info(IRQ_DVI_CK_CHG);
1515 Hal_DVI_irq_clear(u8_IRQ_STATUS);
1516 Hal_DVI_irq_clear(~IRQ_ALL_BIT);
1517
1518 if (u8_IRQ_STATUS == IRQ_DVI_CK_CHG)
1519 {
1520 // not do DVI software reset at here; Avoid the snow image
1521
1522 pXCResourcePrivate->stdrv_HDMI._ResetDone = TRUE;
1523 }
1524 }
1525 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1526 #endif
1527 }
1528
mdrv_dvi_reset(void)1529 void mdrv_dvi_reset(void)
1530 {
1531 if (pu32XCInst == NULL)
1532 {
1533 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1534 return;
1535 }
1536
1537 if(UtopiaIoctl(pu32XCInst, E_XC_DVI_IF_CMD_RESET, NULL) != 0)
1538 {
1539 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1540 return;
1541 }
1542 else
1543 {
1544 return;
1545 }
1546 }
1547
1548 #ifdef DVI_NEW_Patch
1549 // 20081226 - DVI+HDCP snow noise patch - start ...
1550 //-------------------------------------------------------------------------------------------------
1551 /// avoid the snow image while AC on/off and source change for DVI 70Mhz issue, setting 1
1552 /// @param enInputPortType \b IN: Input source
1553 //-------------------------------------------------------------------------------------------------
mdrv_dvi_clock_70mhz_swpatch1(void * pInstance,INPUT_SOURCE_TYPE_t enInputSourceType)1554 void mdrv_dvi_clock_70mhz_swpatch1(void *pInstance, INPUT_SOURCE_TYPE_t enInputSourceType)
1555 {
1556 MS_BOOL bClockLess70MHz;
1557 E_MUX_INPUTPORT enMuxPort =MDrv_XC_Mux_GetHDMIPort(pInstance, enInputSourceType);
1558
1559 // if(MDrv_ReadByte( H( REG_HDMI_INT_STATUS) ) & BIT5)
1560 if(R2BYTEMSK(REG_HDMI_61_L, BIT13))
1561 {
1562 #if ( WATCH_DOG == ENABLE )
1563 MDrv_Sys_ClearWatchDog();
1564 #endif
1565
1566 switch(enMuxPort)
1567 {
1568 default:
1569 case INPUT_PORT_DVI0:
1570 case INPUT_PORT_DVI1:
1571 case INPUT_PORT_DVI3:
1572 // if(!(MDrv_ReadByte(H_BK_ADC_DTOP(0x57)) & BIT3)) // DVI clock is stable
1573 if(!Hal_DVI_clk_stable_usingportc(NO)) // DVI clock is stable
1574 {
1575 //MDRV_HDMIRX_MSG_INFO("\r\nAaron - HDCP status = %bx\r\n", MDrv_ReadByte(L_BK_ADC_DTOP(0x79)));
1576 // if(!(R2BYTEMSK(0x2C33, BIT5))) // Video clock is unstable
1577 if(!(R2BYTEMSK(0x2C32, BIT13))) // Video clock is unstable
1578 {
1579 g_DVI70MhzUnstableCounter++;
1580 if(g_DVI70MhzUnstableCounter >= 2)
1581 {
1582 g_DVI70MhzUnstableCounter = 0;
1583 //bClockLess70MHz = (MDrv_ReadByte(H_BK_ADC_DTOP(0x57)) & BIT2) > 0 ? 1 : 0;
1584 bClockLess70MHz = Hal_DVI_clk_lessthan70mhz_usingportc(NO); //Not Port C
1585 //MDRV_HDMIRX_MSG_INFO("\r\nAaron - CLK_CNT = %bx, AF= %bx\r\n", MDrv_ReadByte(L_BK_ADC_DTOP(0x57)), MDrv_ReadByte(H_BK_ADC_DTOP(0x57)));
1586 //MDRV_HDMIRX_MSG_INFO("\r\nAaron - VCO= %bx\r\n", MDrv_ReadByte(L_BK_ADC_ATOP(0x68)));
1587
1588 if (g_bDVILess70MHz != bClockLess70MHz)
1589 {
1590 //MDRV_HDMIRX_MSG_INFO("\r\nAaron - SWP1 CL70_old = %d, CL70_new = %d\r\n", g_bDVILess70MHz, bClockLess70MHz);
1591 g_bDVILess70MHz = bClockLess70MHz;
1592 MDrv_HDMI_dvi_adjust(bClockLess70MHz);
1593
1594 }
1595 }
1596 }
1597 g_DVI70MhzPollingCounter = 20; // 20 msec
1598 }
1599 break;
1600
1601 case INPUT_PORT_DVI2:
1602
1603 // if(!(MDrv_ReadByte(H_BK_ADC_DTOP(0x58)) & BIT3)) // DVI clock is stable
1604 if(!Hal_DVI_clk_stable_usingportc(YES)) // DVI clock is stable
1605 {
1606 // if(!(R2BYTEMSK(0x2C33, BIT5))) // Video clock is unstable
1607 if(!(R2BYTEMSK(0x2C32, BIT13))) // Video clock is unstable
1608 {
1609 g_DVI70MhzUnstableCounter++;
1610 if(g_DVI70MhzUnstableCounter >= 2)
1611 {
1612 g_DVI70MhzUnstableCounter = 0;
1613
1614 //bClockLess70MHz = (MDrv_ReadByte(H_BK_ADC_DTOP(0x58)) & BIT2) > 0 ? 1 : 0;
1615 bClockLess70MHz = Hal_DVI_clk_lessthan70mhz_usingportc(YES); //Is Port C
1616 //MDRV_HDMIRX_MSG_INFO("\r\nAaron - CLK_CNT = %bx, AF= %bx\r\n", MDrv_ReadByte(L_BK_ADC_DTOP(0x58)), MDrv_ReadByte(H_BK_ADC_DTOP(0x58)));
1617 //MDRV_HDMIRX_MSG_INFO("\r\nAaron - VCO= %bx\r\n", MDrv_ReadByte(L_BK_ADC_ATOP(0x68)));
1618
1619 if (g_bDVILess70MHz != bClockLess70MHz)
1620 {
1621 //MDRV_HDMIRX_MSG_INFO("\r\nAaron - CL70_old = %d, CL70_new = %d\r\n", g_bDVILess70MHz, bClockLess70MHz);
1622 g_bDVILess70MHz = bClockLess70MHz;
1623 MDrv_HDMI_dvi_adjust(bClockLess70MHz);
1624
1625 }
1626 }
1627 }
1628 g_DVI70MhzPollingCounter = 20; // 20 msec
1629 }
1630 break;
1631 }
1632
1633 // clear interrupt status
1634 W2BYTEMSK(REG_HDMI_63_L, BIT13, BIT13); //REG_HDMI_INT_CLEAR
1635 W2BYTEMSK(REG_HDMI_63_L, 0, BIT13); //REG_HDMI_INT_CLEAR
1636 //MDRV_HDMIRX_MSG_INFO("\r\nAaron- DVICLOCK_PATH = %d\r\n", DVICLOCK_PATH);
1637 }
1638 }
1639
1640 //-------------------------------------------------------------------------------------------------
1641 /// avoid the snow image while AC on/off and source change for DVI 70Mhz issue, setting 2
1642 /// @param enInputPortType \b IN: Input source
1643 //-------------------------------------------------------------------------------------------------
mdrv_dvi_clock_70mhz_swpatch2(void * pInstance,INPUT_SOURCE_TYPE_t enInputSourceType)1644 void mdrv_dvi_clock_70mhz_swpatch2(void *pInstance, INPUT_SOURCE_TYPE_t enInputSourceType) //NO_USE
1645 {
1646 MS_BOOL bClockLess70MHz;
1647 static MS_U16 g_DVITMDSClock = 0;
1648 MS_U16 u16DVITMDSClock, u16DVIClockDiff;
1649 E_MUX_INPUTPORT enMuxPort =MDrv_XC_Mux_GetHDMIPort(pInstance, enInputSourceType);
1650
1651 // if(R2BYTEMSK(0x2C33, BIT5)) // Video clock is stable
1652 if(R2BYTEMSK(0x2C32, BIT13)) // Video clock is stable
1653 {
1654 g_DVI70MhzUnstableCounter = 0;
1655 g_DVI70MhzPollingCounter = 0;
1656
1657 #if ( WATCH_DOG == ENABLE )
1658 //msAPI_Timer_ResetWDT();
1659 MDrv_Sys_ClearWatchDog();
1660 #endif
1661
1662 switch(enMuxPort)
1663 {
1664 default:
1665 case INPUT_PORT_DVI0:
1666 case INPUT_PORT_DVI1:
1667 case INPUT_PORT_DVI3:
1668 if(Hal_DVI_clk_stable_usingportc(NO)) // input clock is not really stable
1669 {
1670 //MDRV_HDMIRX_MSG_INFO("\r\nAaron - False alarm, SWP2 TMDS Clock= %d\r\n", MDrv_Read2Byte(__REG_HDMI(0x11)) & 0x1FFF);
1671 return;
1672 }
1673 break;
1674
1675 case INPUT_PORT_DVI2:
1676 if(Hal_DVI_clk_stable_usingportc(YES)) // input clock is not really stable
1677 {
1678 //MDRV_HDMIRX_MSG_INFO("\r\nAaron - False alarm, SWP2 TMDS Clock= %d\r\n", MDrv_Read2Byte(__REG_HDMI(0x11)) & 0x1FFF);
1679 return;
1680 }
1681 break;
1682 }
1683
1684 // u16DVITMDSClock = MDrv_Read2Byte(__REG_HDMI(0x11)) & 0x1FFF;
1685 u16DVITMDSClock = R2BYTE(REG_HDMI_11_L) & 0x1FFF;
1686 u16DVIClockDiff = (g_DVITMDSClock >= u16DVITMDSClock) ? (g_DVITMDSClock - u16DVITMDSClock) : (u16DVITMDSClock - g_DVITMDSClock);
1687 if(u16DVIClockDiff > 10) // tolerance = 1MHz
1688 {
1689 //MDRV_HDMIRX_MSG_INFO("\r\nAaron - SWP2 Clock_Old = %d <-> Clock_New = %d \r\n", g_DVITMDSClock, u16DVITMDSClock);
1690 g_DVITMDSClock = u16DVITMDSClock;
1691 g_DVI70MhzPollingCounter = 20; // 20 msec
1692 return;
1693 }
1694 // bClockLess70MHz = (MDrv_ReadByte(H(__REG_HDMI(0x11))) & 0x60) > 0 ? 0 : 1;
1695 bClockLess70MHz = (R2BYTEMSK(REG_HDMI_11_L, HBMASK) & 0x60) > 0 ? 0 : 1;
1696 //MDRV_HDMIRX_MSG_INFO("\r\nAaron - HDCP status = %bx, INT timer= %d\r\n", MDrv_ReadByte(L_BK_ADC_DTOP(0x79)), MDrv_ReadByte(H(__REG_HDMI(0x09))));
1697 //MDRV_HDMIRX_MSG_INFO("\r\nAaron - SWP2 CL70_old = %d, CL70_new = %d\r\n", g_bDVILess70MHz, bClockLess70MHz);
1698 //MDRV_HDMIRX_MSG_INFO("\r\nAaron - SWP2 TMDS Clock = %d\r\n", MDrv_Read2Byte(__REG_HDMI(0x11)) & 0x1FFF );
1699 if (g_bDVILess70MHz != bClockLess70MHz)
1700 {
1701 g_bDVILess70MHz = bClockLess70MHz;
1702 MDrv_HDMI_dvi_adjust(bClockLess70MHz);
1703 }
1704 }
1705 }
1706 // 20081226 - DVI+HDCP snow noise patch - end ...
1707 #endif
1708 //-------------------------------------------------------------------------------------------------
1709 /// Get/Set error status
1710 /// @param u8value \b IN: Write value
1711 /// @param bread \b IN: Read/Write (1/0)
1712 /// @return @ref MS_U8
1713 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_err_status_update_U2(void * pInstance,MS_U8 ucHDMIInfoSource,MS_U8 u8value,MS_BOOL bread)1714 MS_U8 MDrv_HDMI_err_status_update_U2(void* pInstance, MS_U8 ucHDMIInfoSource, MS_U8 u8value, MS_BOOL bread)
1715 {
1716 MS_U8 u8Return = 0;
1717 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1718 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1719 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1720 u8Return = Hal_HDMI_err_status_update(ucHDMIInfoSource, u8value, bread);
1721 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1722 return u8Return;
1723 }
1724
MDrv_HDMI_err_status_update(MS_U8 u8value,MS_BOOL bread)1725 MS_U8 MDrv_HDMI_err_status_update(MS_U8 u8value, MS_BOOL bread)
1726 {
1727 stHDMI_ERR_STATUS_UPDATE XCArgs = {0};
1728
1729 XCArgs.u8value = u8value;
1730 XCArgs.bread = bread;
1731 XCArgs.u8ReturnValue = 0;
1732 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
1733
1734 if(pu32XCInst == NULL)
1735 {
1736 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1737 }
1738 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_ERR_STATUS_UPDATE, (void*)&XCArgs) != 0)
1739 {
1740 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1741 }
1742
1743 return XCArgs.u8ReturnValue;
1744 }
1745
MDrv_HDMI_GetTMDSFreq_U2(void * pInstance)1746 MS_U16 MDrv_HDMI_GetTMDSFreq_U2(void* pInstance)
1747 {
1748 #if SUPPORT_HDMI_RX_NEW_FEATURE
1749 return Hal_HDMI_GetTMDSFreq();
1750 #else
1751 return 0;
1752 #endif
1753 }
1754
MDrv_HDMI_GetTMDSFreq(void)1755 MS_U16 MDrv_HDMI_GetTMDSFreq(void)
1756 {
1757 if (pu32XCInst == NULL)
1758 {
1759 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1760 return 0;
1761 }
1762
1763 stHDMI_GET_TMDS_FREQ XCArgs;
1764 XCArgs.u8ReturnValue = 0;
1765
1766 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_TMDS_FREQ, (void*)&XCArgs) != 0)
1767 {
1768 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1769 return 0;
1770 }
1771 else
1772 {
1773 return XCArgs.u8ReturnValue;
1774 }
1775 }
1776
1777 //-------------------------------------------------------------------------------------------------
1778 /// HDMI packet reset
1779 /// @param breset \b IN: Enabl reset or not
1780 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_pkt_reset_internal(void * pInstance,HDMI_REST_t breset)1781 void MDrv_HDMI_pkt_reset_internal(void *pInstance, HDMI_REST_t breset )
1782 {
1783 #if SUPPORT_HDMI_RX_NEW_FEATURE
1784 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1785 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1786 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1787 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1788 if(IsSrcTypeHDMI(gSrcInfo[MAIN_WINDOW].enInputSourceType))
1789 {
1790 Hal_HDMI_pkt_reset(MDrv_XC_Mux_GetHDMIPort(pInstance, gSrcInfo[MAIN_WINDOW].enInputSourceType), breset);
1791 }
1792 else if(IsSrcTypeHDMI(gSrcInfo[SUB_WINDOW].enInputSourceType))
1793 {
1794 Hal_HDMI_pkt_reset(MDrv_XC_Mux_GetHDMIPort(pInstance, gSrcInfo[SUB_WINDOW].enInputSourceType), breset);
1795 }
1796 #else
1797 Hal_HDMI_pkt_reset(breset);
1798 #endif
1799
1800 #if SUPPORT_HDMI_RX_NEW_FEATURE
1801 //pkt reset cannot clear status in DVI mode in non-immeswitch case, RD suggest to use DVI sw reset
1802 if(!pXCResourcePrivate->stdrvXC_MVideo_Context.g_bIsIMMESWITCH) // Only apply in non-imme switch case
1803 {
1804 if(breset & REST_HDMI_STATUS )
1805 {
1806 Hal_DVI_Software_Reset(INPUT_PORT_DVI0, BIT(6));
1807 }
1808 }
1809 #else
1810 // Do nothing
1811 #endif
1812 }
1813
MDrv_HDMI_pkt_reset_U2(void * pInstance,HDMI_REST_t breset)1814 void MDrv_HDMI_pkt_reset_U2( void* pInstance, HDMI_REST_t breset )
1815 {
1816 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1817 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1818 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1819 MDrv_HDMI_pkt_reset_internal(pInstance, breset);
1820 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1821 }
1822
MDrv_HDMI_pkt_reset(HDMI_REST_t breset)1823 void MDrv_HDMI_pkt_reset( HDMI_REST_t breset )
1824 {
1825 if (pu32XCInst == NULL)
1826 {
1827 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1828 return;
1829 }
1830
1831 stHDMI_PKT_RESET XCArgs;
1832 XCArgs.breset = breset;
1833
1834 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_PKT_RESET, (void*)&XCArgs) != 0)
1835 {
1836 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1837 return;
1838 }
1839 else
1840 {
1841 return;
1842 }
1843 }
1844
1845 //-------------------------------------------------------------------------------------------------
1846 /// Enable Hot plug Detection out enable
1847 /// @param benable \b IN: Enabl output or not
1848 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_hpd_en(MS_BOOL benable)1849 void MDrv_HDMI_hpd_en(MS_BOOL benable)
1850 {
1851 Hal_HDMI_hpd_en(benable);
1852 }
1853
MDrv_HDCP_initproductionkey_internal(void * pInstance,MS_U8 * pu8HdcpKeyData)1854 void MDrv_HDCP_initproductionkey_internal(void *pInstance, MS_U8 * pu8HdcpKeyData )
1855 {
1856 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1857 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1858 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1859 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1860 memcpy(pXCResourcePrivate->stdrvXC_MVideo_Context.g_u8HdcpKeyDataBackUp, pu8HdcpKeyData, HDCP_KEY_LENGTH * sizeof(MS_U8));// HDCP key length is 289 byte
1861
1862 if(bInitEnable == FALSE)
1863 {
1864 MDRV_HDMIRX_MSG_INFO("[%s] Please follow the flow: MDrv_HDMI_init() -> MDrv_HDCP_initproductionkey()\n", __FUNCTION__);
1865 assert(bInitEnable != FALSE);
1866 }
1867
1868 if(!pXCResourcePrivate->stdrv_HDMI.bHDCP14RxREEFlag)
1869 {
1870 pXCResourcePrivate->stdrv_HDMI.bHDCP14RxREEFlag = TRUE;
1871 }
1872
1873 Hal_HDCP_initproductionkey(pu8HdcpKeyData);
1874 }
1875
1876 //-------------------------------------------------------------------------------------------------
1877 /// Init the HDCP production key
1878 /// @param pu8HdcpKeyData \b IN: HDCP key
1879 //-------------------------------------------------------------------------------------------------
MDrv_HDCP_initproductionkey_U2(void * pInstance,MS_U8 * pu8HdcpKeyData)1880 void MDrv_HDCP_initproductionkey_U2( void* pInstance, MS_U8 * pu8HdcpKeyData )
1881 {
1882 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1883 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1884 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1885
1886 MDrv_HDCP_initproductionkey_internal(pInstance, pu8HdcpKeyData);
1887
1888 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1889 }
1890
MDrv_HDCP_initproductionkey(MS_U8 * pu8HdcpKeyData)1891 void MDrv_HDCP_initproductionkey( MS_U8 * pu8HdcpKeyData )
1892 {
1893 stHDCP_INITPRODUCTIONKEY XCArgs;
1894 XCArgs.pu8HdcpKeyData = pu8HdcpKeyData;
1895
1896 if(pu32XCInst == NULL)
1897 {
1898 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1899 }
1900 else if(UtopiaIoctl(pu32XCInst, E_XC_HDCP_IF_CMD_INITPRODUCTIONKEY, (void*)&XCArgs) != 0)
1901 {
1902 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1903 }
1904
1905 if(pulHDMIRxInst == NULL)
1906 {
1907 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
1908 }
1909 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_CHECK_HDCP14_KEY, (void*)&XCArgs) != 0)
1910 {
1911 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
1912 }
1913 }
1914
1915 //-------------------------------------------------------------------------------------------------
1916 /// Clear the HDCP Flag
1917 //-------------------------------------------------------------------------------------------------
MDrv_HDCP_ClearStatus_U2(void * pInstance)1918 void MDrv_HDCP_ClearStatus_U2( void* pInstance )
1919 {
1920 #if SUPPORT_HDMI_RX_NEW_FEATURE
1921 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1922 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1923 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1924 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
1925 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1926 if(IsSrcTypeHDMI(gSrcInfo[MAIN_WINDOW].enInputSourceType))
1927 {
1928 Hal_HDCP_clearflag(MDrv_XC_Mux_GetHDMIPort(pInstance, gSrcInfo[MAIN_WINDOW].enInputSourceType));
1929 }
1930 else if(IsSrcTypeHDMI(gSrcInfo[SUB_WINDOW].enInputSourceType))
1931 {
1932 Hal_HDCP_clearflag(MDrv_XC_Mux_GetHDMIPort(pInstance, gSrcInfo[SUB_WINDOW].enInputSourceType));
1933 }
1934 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
1935 #else
1936 Hal_HDCP_clearflag();
1937 #endif
1938 }
1939
MDrv_HDCP_ClearStatus(void)1940 void MDrv_HDCP_ClearStatus( void )
1941 {
1942 if (pu32XCInst == NULL)
1943 {
1944 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1945 return;
1946 }
1947
1948 if(UtopiaIoctl(pu32XCInst, E_XC_HDCP_IF_CMD_CLEARSTATUS, NULL) != 0)
1949 {
1950 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1951 return;
1952 }
1953 else
1954 {
1955 return;
1956 }
1957 }
1958
1959 //-------------------------------------------------------------------------------------------------
1960 /// Enable audio output or not
1961 /// @param bEnable \b IN: Enable or not
1962 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_audio_output_U2(void * pInstance,MS_BOOL bEnable)1963 void MDrv_HDMI_audio_output_U2( void* pInstance, MS_BOOL bEnable )
1964 {
1965 Hal_HDMI_audio_output(bEnable);
1966 }
1967
MDrv_HDMI_audio_output(MS_BOOL bEnable)1968 void MDrv_HDMI_audio_output( MS_BOOL bEnable )
1969 {
1970 if (pu32XCInst == NULL)
1971 {
1972 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
1973 return;
1974 }
1975
1976 stHDMI_AUDIO_OUTPUT XCArgs;
1977 XCArgs.bEnable = bEnable;
1978
1979 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AUDIO_OUTPUT, (void*)&XCArgs) != 0)
1980 {
1981 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
1982 return;
1983 }
1984 else
1985 {
1986 return;
1987 }
1988 }
1989
1990 //-------------------------------------------------------------------------------------------------
1991 /// audio content protection info
1992 /// @return @ref MS_U8
1993 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_audio_cp_hdr_info_U2(void * pInstance,MS_U8 ucHDMIInfoSource)1994 MS_U8 MDrv_HDMI_audio_cp_hdr_info_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
1995 {
1996 MS_U8 u8Return = 0;
1997 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1998 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1999 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
2000 u8Return = Hal_HDMI_audio_content_protection_info(ucHDMIInfoSource);
2001 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
2002 return u8Return;
2003 }
2004
MDrv_HDMI_audio_cp_hdr_info(void)2005 MS_U8 MDrv_HDMI_audio_cp_hdr_info(void)
2006 {
2007 stHDMI_AUDIO_CP_HDR_INFO XCArgs = {0};
2008
2009 XCArgs.u8ReturnValue = 0;
2010 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2011
2012 if(pu32XCInst == NULL)
2013 {
2014 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2015 }
2016 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AUDIO_CP_HDR_INFO, (void*)&XCArgs) != 0)
2017 {
2018 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2019 }
2020
2021 return XCArgs.u8ReturnValue;
2022 }
2023
2024 //-------------------------------------------------------------------------------------------------
2025 /// Get the AVI infoframe information
2026 /// @param u8byte \b IN: byte info selection
2027 /// @return @ref MS_U8
2028 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_avi_infoframe_info(MS_U8 u8byte)2029 MS_U8 MDrv_HDMI_avi_infoframe_info(MS_U8 u8byte)
2030 {
2031 return Hal_HDMI_avi_infoframe_info(HDMI_INFO_SOURCE0, u8byte);
2032 }
2033
2034 //-------------------------------------------------------------------------------------------------
2035 /// Get manufactor ID information(0x47~0x53)
2036 /// @param u8byte * \b IN: byte info selection
2037 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Get_MID_info_U2(void * pInstance,MS_U8 ucHDMIInfoSource,MS_U8 * pu8ManufactorData)2038 void MDrv_HDMI_Get_MID_info_U2(void* pInstance, MS_U8 ucHDMIInfoSource, MS_U8 * pu8ManufactorData)
2039 {
2040 MS_U8 uctemp = 0;
2041 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2042 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2043
2044 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
2045
2046 Hal_HDMI_packet_ctrl(ucHDMIInfoSource, 0x04); //set SPD
2047
2048 for(uctemp = 0; uctemp < 25; uctemp++)
2049 {
2050 (pu8ManufactorData[uctemp]) = Hal_HDMI_avi_infoframe_info(ucHDMIInfoSource, uctemp +2 *(47 -40) +1);
2051 }
2052
2053 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
2054 }
2055
MDrv_HDMI_Get_MID_info(MS_U8 * pu8ManufactorData)2056 void MDrv_HDMI_Get_MID_info(MS_U8 * pu8ManufactorData)
2057 {
2058 stHDMI_GET_MID_INFO XCArgs;
2059
2060 XCArgs.pu8ManufactorData = pu8ManufactorData;
2061 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2062
2063 if(pu32XCInst == NULL)
2064 {
2065 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2066 }
2067 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_MID_INFO, (void*)&XCArgs) != 0)
2068 {
2069 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2070 }
2071 }
2072
2073 //-------------------------------------------------------------------------------------------------
2074 /// Get the HDMI packet value
2075 /// @param u8state \b IN: MS_HDMI_PACKET_STATE_t
2076 /// @param u8byte_idx \b IN: Byte index
2077 /// @param *pValue \b IN: packet value
2078 /// @return @ref MS_BOOL
2079 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_get_packet_value_U2(void * pInstance,MS_U8 ucHDMIInfoSource,MS_HDMI_PACKET_STATE_t u8state,MS_U8 u8byte_idx,MS_U8 * pValue)2080 MS_BOOL MDrv_HDMI_get_packet_value_U2(void* pInstance, MS_U8 ucHDMIInfoSource, MS_HDMI_PACKET_STATE_t u8state, MS_U8 u8byte_idx, MS_U8 *pValue)
2081 {
2082 MS_BOOL bReturn = FALSE;
2083 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2084 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2085 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
2086 bReturn = Hal_HDMI_get_packet_value(ucHDMIInfoSource, u8state, u8byte_idx, pValue);
2087 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
2088 return bReturn;
2089 }
2090
MDrv_HDMI_get_packet_value(MS_HDMI_PACKET_STATE_t u8state,MS_U8 u8byte_idx,MS_U8 * pValue)2091 MS_BOOL MDrv_HDMI_get_packet_value(MS_HDMI_PACKET_STATE_t u8state, MS_U8 u8byte_idx, MS_U8 *pValue)
2092 {
2093 stHDMI_GET_PACKET_VALUE XCArgs;
2094
2095 XCArgs.u8state = u8state;
2096 XCArgs.u8byte_idx = u8byte_idx;
2097 XCArgs.pValue = pValue;
2098 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2099 XCArgs.bReturnValue = FALSE;
2100
2101 if(pu32XCInst == NULL)
2102 {
2103 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2104 }
2105 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_PACKET_VALUE, (void*)&XCArgs) != 0)
2106 {
2107 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2108 }
2109
2110 return XCArgs.bReturnValue;
2111 }
2112
2113 //-------------------------------------------------------------------------------------------------
2114 /// Get the audio channel status
2115 /// @param u8byte \b IN: byte info selection
2116 /// @return @ref MS_U8
2117 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_audio_channel_status_U2(void * pInstance,MS_U8 ucHDMIInfoSource,MS_U8 u8byte)2118 MS_U8 MDrv_HDMI_audio_channel_status_U2(void* pInstance, MS_U8 ucHDMIInfoSource, MS_U8 u8byte)
2119 {
2120 MS_U8 u8Return = 0;
2121 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2122 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2123 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
2124 u8Return = Hal_HDMI_audio_channel_status(ucHDMIInfoSource, u8byte);
2125 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
2126 return u8Return;
2127 }
2128
MDrv_HDMI_audio_channel_status(MS_U8 u8byte)2129 MS_U8 MDrv_HDMI_audio_channel_status(MS_U8 u8byte)
2130 {
2131 stHDMI_AUDIO_CHANNEL_STATUS XCArgs = {0};
2132
2133 XCArgs.u8byte = u8byte;
2134 XCArgs.u8ReturnValue = 0;
2135 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2136
2137 if(pu32XCInst == NULL)
2138 {
2139 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2140 }
2141 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AUDIO_CHANNEL_STATUS, (void*)&XCArgs) != 0)
2142 {
2143 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2144 }
2145
2146 return XCArgs.u8ReturnValue;
2147 }
2148
2149 //-------------------------------------------------------------------------------------------------
2150 /// Get the HDCP status
2151 /// @return @ref MS_HDCP_STATUS_INFO_t
2152 //-------------------------------------------------------------------------------------------------
_MDrv_HDCP_GetStatus(void * pInstance)2153 MS_U16 _MDrv_HDCP_GetStatus(void* pInstance)
2154 {
2155 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2156 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2157 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2158 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2159 #if SUPPORT_HDMI_RX_NEW_FEATURE
2160 MS_U16 u16Status = 0;
2161 if(IsSrcTypeHDMI(gSrcInfo[MAIN_WINDOW].enInputSourceType))
2162 {
2163 u16Status = Hal_HDCP_getstatus(MDrv_XC_Mux_GetHDMIPort(pInstance, gSrcInfo[MAIN_WINDOW].enInputSourceType));
2164 }
2165 else
2166 {
2167 #if PIP_PATCH_USING_SC1_MAIN_AS_SC0_SUB
2168 XC_RESOURCE_PRIVATE* pXCResourcePrivate_1 = NULL;
2169 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(1)],(void**)(&pXCResourcePrivate_1));
2170 if(IsSrcTypeHDMI(gSrcInfo_1[MAIN_WINDOW].enInputSourceType))
2171 {
2172 u16Status = Hal_HDCP_getstatus(MDrv_XC_Mux_GetHDMIPort(g_pDevice1Instance, gSrcInfo_1[MAIN_WINDOW].enInputSourceType));
2173 }
2174 pXCResourcePrivate_1->stdrv_HDMI.enStatus_info.b_St_HDMI_Mode = u16Status & BIT(0);
2175 pXCResourcePrivate_1->stdrv_HDMI.enStatus_info.b_St_Reserve_1 = u16Status & BIT(1);
2176 pXCResourcePrivate_1->stdrv_HDMI.enStatus_info.b_St_HDCP_Ver = u16Status & BIT(2);
2177 pXCResourcePrivate_1->stdrv_HDMI.enStatus_info.b_St_AVMute = u16Status & BIT(3);
2178 pXCResourcePrivate_1->stdrv_HDMI.enStatus_info.b_St_ENC_En = u16Status & BIT(4);
2179 pXCResourcePrivate_1->stdrv_HDMI.enStatus_info.b_St_AKsv_Rcv = u16Status & BIT(5);
2180 pXCResourcePrivate_1->stdrv_HDMI.enStatus_info.b_St_ENC_Dis = u16Status & BIT(6);
2181 pXCResourcePrivate_1->stdrv_HDMI.enStatus_info.b_St_Reserve_7 = u16Status & BIT(7);
2182 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2183 #else
2184 if(IsSrcTypeHDMI(gSrcInfo[SUB_WINDOW].enInputSourceType))
2185 {
2186 u16Status = Hal_HDCP_getstatus(MDrv_XC_Mux_GetHDMIPort(pInstance, gSrcInfo[SUB_WINDOW].enInputSourceType));
2187 }
2188 #endif
2189 }
2190 #else
2191 MS_U16 u16Status = Hal_HDCP_getstatus();
2192 #endif
2193
2194 pXCResourcePrivate->stdrv_HDMI.enStatus_info.b_St_HDMI_Mode = u16Status & BIT(0);
2195 pXCResourcePrivate->stdrv_HDMI.enStatus_info.b_St_Reserve_1 = u16Status & BIT(1);
2196 pXCResourcePrivate->stdrv_HDMI.enStatus_info.b_St_HDCP_Ver = u16Status & BIT(2);
2197 pXCResourcePrivate->stdrv_HDMI.enStatus_info.b_St_AVMute = u16Status & BIT(3);
2198 pXCResourcePrivate->stdrv_HDMI.enStatus_info.b_St_ENC_En = u16Status & BIT(4);
2199 pXCResourcePrivate->stdrv_HDMI.enStatus_info.b_St_AKsv_Rcv = u16Status & BIT(5);
2200 pXCResourcePrivate->stdrv_HDMI.enStatus_info.b_St_ENC_Dis = u16Status & BIT(6);
2201 pXCResourcePrivate->stdrv_HDMI.enStatus_info.b_St_Reserve_7 = u16Status & BIT(7);
2202
2203 return u16Status;
2204 }
2205
MDrv_HDCP_GetStatus_U2(void * pInstance)2206 MS_U16 MDrv_HDCP_GetStatus_U2(void* pInstance)
2207 {
2208 MS_U16 usHDCPStatus = 0;
2209 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2210
2211 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2212
2213 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
2214 usHDCPStatus = _MDrv_HDCP_GetStatus(pInstance);
2215 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
2216
2217 return usHDCPStatus;
2218 }
2219
MDrv_HDCP_GetStatus(void)2220 MS_HDCP_STATUS_INFO_t* MDrv_HDCP_GetStatus(void )
2221 {
2222 stHDCP_GETSTATUS XCArgs = {0};
2223 static MS_HDCP_STATUS_INFO_t stHDCPStatus = {0};
2224
2225 XCArgs.usHDCPStatus = 0;
2226
2227 if(pu32XCInst == NULL)
2228 {
2229 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2230 }
2231 else if(UtopiaIoctl(pu32XCInst, E_XC_HDCP_IF_CMD_GETSTATUS, (void*)&XCArgs) != 0)
2232 {
2233 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2234 }
2235 else
2236 {
2237 stHDCPStatus.b_St_HDMI_Mode = ((XCArgs.usHDCPStatus &BIT(0))? TRUE: FALSE);
2238 stHDCPStatus.b_St_Reserve_1 = ((XCArgs.usHDCPStatus &BIT(1))? TRUE: FALSE);
2239 stHDCPStatus.b_St_HDCP_Ver = ((XCArgs.usHDCPStatus &BIT(2))? TRUE: FALSE);
2240 stHDCPStatus.b_St_AVMute = ((XCArgs.usHDCPStatus &BIT(3))? TRUE: FALSE);
2241 stHDCPStatus.b_St_ENC_En = ((XCArgs.usHDCPStatus &BIT(4))? TRUE: FALSE);
2242 stHDCPStatus.b_St_AKsv_Rcv = ((XCArgs.usHDCPStatus &BIT(5))? TRUE: FALSE);
2243 stHDCPStatus.b_St_ENC_Dis = ((XCArgs.usHDCPStatus &BIT(6))? TRUE: FALSE);
2244 stHDCPStatus.b_St_Reserve_7 = ((XCArgs.usHDCPStatus &BIT(7))? TRUE: FALSE);
2245 }
2246
2247 return &stHDCPStatus;
2248 }
2249
MDrv_DVI_HF_adjust_internal(void)2250 void MDrv_DVI_HF_adjust_internal(void)
2251 {
2252 Hal_DVI_HF_adjust();
2253 }
2254
MDrv_DVI_HF_adjust_U2(void * pInstance)2255 void MDrv_DVI_HF_adjust_U2( void* pInstance )
2256 {
2257 MDrv_DVI_HF_adjust_internal();
2258 }
2259
MDrv_DVI_HF_adjust(void)2260 void MDrv_DVI_HF_adjust(void)
2261 {
2262 if (pu32XCInst == NULL)
2263 {
2264 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2265 return;
2266 }
2267
2268 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_DVI_HF_ADJUST, NULL) != 0)
2269 {
2270 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2271 return;
2272 }
2273 else
2274 {
2275 return;
2276 }
2277 }
2278
2279 //-------------------------------------------------------------------------------------------------
2280 /// Returne Phase status
2281 /// @param bClockLessThan70MHz \b IN: u8Channel
2282 //-------------------------------------------------------------------------------------------------
MDrv_DVI_ChannelPhaseStatus_U2(void * pInstance,MS_DVI_CHANNEL_TYPE u8Channel)2283 MS_U16 MDrv_DVI_ChannelPhaseStatus_U2(void* pInstance, MS_DVI_CHANNEL_TYPE u8Channel)
2284 {
2285 return Hal_DVI_ChannelPhaseStatus(u8Channel);
2286 }
2287
MDrv_DVI_ChannelPhaseStatus(MS_DVI_CHANNEL_TYPE u8Channel)2288 MS_U16 MDrv_DVI_ChannelPhaseStatus( MS_DVI_CHANNEL_TYPE u8Channel)
2289 {
2290 if (pu32XCInst == NULL)
2291 {
2292 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2293 return 0;
2294 }
2295
2296 stDVI_CHANNELPHASESTATUS XCArgs;
2297 XCArgs.u8Channel = u8Channel;
2298 XCArgs.u16ReturnValue = 0;
2299
2300 if(UtopiaIoctl(pu32XCInst, E_XC_DVI_IF_CMD_CHANNELPHASESTATUS, (void*)&XCArgs) != 0)
2301 {
2302 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2303 return 0;
2304 }
2305 else
2306 {
2307 return XCArgs.u16ReturnValue;
2308 }
2309 }
2310
2311 //-------------------------------------------------------------------------------------------------
2312 /// Check DVI accumulator and reset status.
2313 /// @param
2314 /// Due to DVI accumulator may be overflow when previous source is MHL,
2315 /// this function will monitor MHL port's accumulator, and reset when it hits boundary.
2316 //-------------------------------------------------------------------------------------------------
MDrv_DVI_Accumulator_Monitor(void)2317 void MDrv_DVI_Accumulator_Monitor(void)
2318 {
2319 Hal_DVI_Accumulator_Monitor();
2320 }
2321
2322 //-------------------------------------------------------------------------------------------------
2323 /// Adjust the ADC for DVI by the condition is less than 70Mhz or not
2324 /// @param bClockLessThan70MHz \b IN: Is Less 70Mhz or not
2325 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_dvi_adjust_U2(void * pInstance,MS_BOOL bClockLessThan70MHz)2326 void MDrv_HDMI_dvi_adjust_U2( void* pInstance, MS_BOOL bClockLessThan70MHz)
2327 {
2328 Hal_DVI_adc_adjust(bClockLessThan70MHz);
2329 }
2330
MDrv_HDMI_dvi_adjust(MS_BOOL bClockLessThan70MHz)2331 void MDrv_HDMI_dvi_adjust( MS_BOOL bClockLessThan70MHz)
2332 {
2333 if (pu32XCInst == NULL)
2334 {
2335 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2336 return;
2337 }
2338
2339 stHDMI_DVI_ADJUST XCArgs;
2340 XCArgs.bClockLessThan70MHz = bClockLessThan70MHz;
2341
2342 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_DVI_ADJUST, (void*)&XCArgs) != 0)
2343 {
2344 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2345 return;
2346 }
2347 else
2348 {
2349 return;
2350 }
2351 }
2352
2353 //-------------------------------------------------------------------------------------------------
2354 /// audio content payload info
2355 /// @param u8byte \b IN: Byte number
2356 /// @return @ref MS_U8
2357 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_audio_cp_data_info(MS_U8 u8byte)2358 MS_U8 MDrv_HDMI_audio_cp_data_info(MS_U8 u8byte)
2359 {
2360 return Hal_HDMI_audio_payload_info(HDMI_INFO_SOURCE0, u8byte);
2361 }
2362
2363 //-------------------------------------------------------------------------------------------------
2364 /// Get the HDMI packet
2365 /// @param bEnable \b IN: Enable receive or not
2366 /// @return @ref MS_HDMI_PACKET_VALUE_t
2367 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Packet_Received_U2(void * pInstance,MS_U8 ucHDMIInfoSource,MS_BOOL bEnable,MS_U32 ulPacketStatus)2368 void MDrv_HDMI_Packet_Received_U2(void* pInstance, MS_U8 ucHDMIInfoSource, MS_BOOL bEnable, MS_U32 ulPacketStatus)
2369 {
2370 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2371 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2372
2373 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2374
2375 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
2376
2377 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2378
2379 if(bEnable)
2380 {
2381 pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] = ulPacketStatus;
2382 }
2383
2384 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
2385 }
2386
MDrv_HDMI_Packet_Received(MS_BOOL bEnable)2387 MS_HDMI_PACKET_VALUE_t MDrv_HDMI_Packet_Received(MS_BOOL bEnable)
2388 {
2389 stHDMI_PACKET_RECEIVED XCArgs = {0};
2390 MS_HDMI_PACKET_VALUE_t stPacketValue = {0};
2391
2392 XCArgs.bEnable = bEnable;
2393 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2394 XCArgs.ulPacketStatus = 0;
2395
2396 if(pulHDMIRxInst == NULL)
2397 {
2398 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
2399 }
2400 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_GET_PACKET_RECEIVE, (void*)&XCArgs) != 0)
2401 {
2402 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
2403 }
2404 else
2405 {
2406 stPacketValue.PKT_MPEG_VALUE = (MS_U16)XCArgs.ulPacketStatus &HDMI_STATUS_MPEG_PACKET_RECEIVE_FLAG;
2407 stPacketValue.PKT_AUI_VALUE = (MS_U16)XCArgs.ulPacketStatus &HDMI_STATUS_AUDIO_PACKET_RECEIVE_FLAG;
2408 stPacketValue.PKT_SPD_VALUE = (MS_U16)XCArgs.ulPacketStatus &HDMI_STATUS_SPD_PACKET_RECEIVE_FLAG;
2409 stPacketValue.PKT_AVI_VALUE = (MS_U16)XCArgs.ulPacketStatus &HDMI_STATUS_AVI_PACKET_RECEIVE_FLAG;
2410 stPacketValue.PKT_GC_VALUE = (MS_U16)XCArgs.ulPacketStatus &HDMI_STATUS_GCP_PACKET_RECEIVE_FLAG;
2411 stPacketValue.PKT_ASAMPLE_VALUE = (MS_U16)XCArgs.ulPacketStatus &HDMI_STATUS_AUDIO_SAMPLE_PACKET_RECEIVE_FLAG;
2412 stPacketValue.PKT_ACR_VALUE = (MS_U16)XCArgs.ulPacketStatus &HDMI_STATUS_ACR_PACKET_RECEIVE_FLAG;
2413 stPacketValue.PKT_VS_VALUE = (MS_U16)XCArgs.ulPacketStatus &HDMI_STATUS_VS_PACKET_RECEIVE_FLAG;
2414 stPacketValue.PKT_NULL_VALUE = (MS_U16)XCArgs.ulPacketStatus &HDMI_STATUS_NULL_PACKET_RECEIVE_FLAG;
2415 stPacketValue.PKT_ISRC2_VALUE = (MS_U16)XCArgs.ulPacketStatus &HDMI_STATUS_ISRC2_PACKET_RECEIVE_FLAG;
2416 stPacketValue.PKT_ISRC1_VALUE = (MS_U16)XCArgs.ulPacketStatus &HDMI_STATUS_ISRC1_PACKET_RECEIVE_FLAG;
2417 stPacketValue.PKT_ACP_VALUE = (MS_U16)XCArgs.ulPacketStatus &HDMI_STATUS_ACP_PACKET_RECEIVE_FLAG;
2418 stPacketValue.PKT_ONEBIT_AUD_VALUE = (MS_U16)XCArgs.ulPacketStatus &HDMI_STATUS_DSD_PACKET_RECEIVE_FLAG;
2419 }
2420
2421 if(pu32XCInst == NULL)
2422 {
2423 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2424 }
2425 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_PACKET_RECEIVED, (void*)&XCArgs) != 0)
2426 {
2427 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2428 }
2429
2430 return stPacketValue;
2431 }
2432
2433 //-------------------------------------------------------------------------------------------------
2434 /// Get the HDMI color format
2435 /// @return @ref MS_HDMI_COLOR_FORMAT
2436 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Get_ColorFormat_U2(void * pInstance,MS_U8 ucHDMIInfoSource)2437 MS_HDMI_COLOR_FORMAT MDrv_HDMI_Get_ColorFormat_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
2438 {
2439 MS_HDMI_COLOR_FORMAT pkt_ColorFormat=MS_HDMI_COLOR_UNKNOWN;
2440 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2441 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2442 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
2443
2444 switch(Hal_HDMI_avi_infoframe_info(ucHDMIInfoSource, _BYTE_1)& 0x60 )
2445 {
2446 case 0x00:
2447 pkt_ColorFormat = MS_HDMI_COLOR_RGB;
2448 break;
2449 case 0x40:
2450 pkt_ColorFormat = MS_HDMI_COLOR_YUV_444;
2451 break;
2452 case 0x20:
2453 pkt_ColorFormat = MS_HDMI_COLOR_YUV_422;
2454 break;
2455 case 0x60:
2456 pkt_ColorFormat = MS_HDMI_COLOR_YUV_420;
2457 break;
2458 default:
2459 break;
2460 };
2461
2462 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
2463
2464 return pkt_ColorFormat;
2465 }
2466
MDrv_HDMI_Get_ColorFormat(void)2467 MS_HDMI_COLOR_FORMAT MDrv_HDMI_Get_ColorFormat(void)
2468 {
2469 stHDMI_GET_COLORFORMAT XCArgs = {0};
2470
2471 XCArgs.eReturnValue = MS_HDMI_COLOR_UNKNOWN;
2472 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2473
2474 if(pu32XCInst == NULL)
2475 {
2476 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2477 }
2478 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_COLORFORMAT, (void*)&XCArgs) != 0)
2479 {
2480 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2481 }
2482
2483 return XCArgs.eReturnValue;
2484 }
2485
2486 //-------------------------------------------------------------------------------------------------
2487 /// Get the HDMI color range
2488 /// @return @ref EN_HDMI_COLOR_RANGE
2489 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Get_ColorRange_U2(void * pInstance,MS_U8 ucHDMIInfoSource)2490 EN_HDMI_COLOR_RANGE MDrv_HDMI_Get_ColorRange_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
2491 {
2492 EN_HDMI_COLOR_RANGE enPKTColorRange = E_HDMI_COLOR_RANGE_DEFAULT;
2493 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2494 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2495
2496 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
2497
2498 if((Hal_HDMI_avi_infoframe_info(ucHDMIInfoSource, _BYTE_1)& 0x60) == 0x00) // RGB
2499 {
2500 switch(Hal_HDMI_avi_infoframe_info(ucHDMIInfoSource, _BYTE_3) & 0x0C)
2501 {
2502 case 0x00:
2503 enPKTColorRange = E_HDMI_COLOR_RANGE_DEFAULT;
2504 break;
2505 case 0x04:
2506 enPKTColorRange = E_HDMI_COLOR_RANGE_LIMIT;
2507 break;
2508 case 0x08:
2509 enPKTColorRange = E_HDMI_COLOR_RANGE_FULL;
2510 break;
2511 case 0x0C:
2512 enPKTColorRange = E_HDMI_COLOR_RANGE_RESERVED;
2513 break;
2514 default:
2515 break;
2516 };
2517 }
2518 else // YUV
2519 {
2520 switch(Hal_HDMI_avi_infoframe_info(ucHDMIInfoSource, _BYTE_5) & 0xC0)
2521 {
2522 case 0x00:
2523 enPKTColorRange = E_HDMI_COLOR_RANGE_LIMIT;
2524 break;
2525 case 0x40:
2526 enPKTColorRange = E_HDMI_COLOR_RANGE_FULL;
2527 break;
2528 case 0x80:
2529 enPKTColorRange = E_HDMI_COLOR_RANGE_RESERVED;
2530 break;
2531 case 0xC0:
2532 enPKTColorRange = E_HDMI_COLOR_RANGE_RESERVED;
2533 break;
2534 default:
2535 break;
2536 };
2537 }
2538
2539 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
2540
2541 return enPKTColorRange;
2542 }
2543
MDrv_HDMI_Get_ColorRange(void)2544 EN_HDMI_COLOR_RANGE MDrv_HDMI_Get_ColorRange(void)
2545 {
2546 stHDMI_GET_COLORRANGE XCArgs = {0};
2547
2548 XCArgs.eReturnValue = E_HDMI_COLOR_RANGE_RESERVED;
2549 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2550
2551 if(pu32XCInst == NULL)
2552 {
2553 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2554 }
2555 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_COLORRANGE, (void*)&XCArgs) != 0)
2556 {
2557 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2558 }
2559
2560 return XCArgs.eReturnValue;
2561 }
2562
2563 //-------------------------------------------------------------------------------------------------
2564 /// Get the HDMI aspect ratio info
2565 /// @param bEn_PAR \b IN: Enable to get the Picture Aspect Ratio
2566 /// @param bEn_AFAR \b IN: Enable to get the Active Format Aspect Ratio
2567 /// @return @ref MS_HDMI_AR_TYPE
2568 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Get_AspectRatio_U2(void * pInstance,MS_U8 ucHDMIInfoSource,MS_BOOL bEn_PAR,MS_BOOL bEn_AFAR)2569 MS_HDMI_AR_TYPE MDrv_HDMI_Get_AspectRatio_U2(void* pInstance, MS_U8 ucHDMIInfoSource, MS_BOOL bEn_PAR, MS_BOOL bEn_AFAR)
2570 {
2571 MS_HDMI_AR_TYPE enPar_type;
2572 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2573 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2574 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
2575 MS_U8 u8AR = Hal_HDMI_avi_infoframe_info(ucHDMIInfoSource, _BYTE_2) & HDMI_AR_REG_MASK;
2576 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
2577
2578 // Picture Aspect Ratio - PAR
2579 if(bEn_PAR)
2580 {
2581 switch(u8AR & HDMI_AR_MASK)
2582 {
2583 case 0x00: // IF0[13..12] 00
2584 enPar_type = HDMI_Pic_AR_NODATA;
2585 break;
2586 case 0x10: // IF0[13..12] 01, 4:3
2587 enPar_type = HDMI_Pic_AR_4x3;
2588 break;
2589 case 0x20: // IF0[13..12] 10, 16:9
2590 enPar_type = HDMI_Pic_AR_16x9;
2591 break;
2592 case 0x30: // IF0[13..12] 11, reserved
2593 default:
2594 enPar_type = HDMI_Pic_AR_RSV;
2595 break;
2596 };
2597 }
2598 else
2599 {
2600 enPar_type = HDMI_Pic_AR_RSV;
2601 }
2602
2603 return enPar_type;
2604 }
2605
MDrv_HDMI_Get_AspectRatio(MS_BOOL bEn_PAR,MS_BOOL bEn_AFAR)2606 MS_HDMI_AR_TYPE MDrv_HDMI_Get_AspectRatio(MS_BOOL bEn_PAR, MS_BOOL bEn_AFAR)
2607 {
2608 stHDMI_GET_ASPECTRATIO XCArgs = {0};
2609
2610 XCArgs.bEn_PAR = bEn_PAR;
2611 XCArgs.bEn_AFAR = bEn_AFAR;
2612 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2613 XCArgs.eReturnValue = HDMI_AF_AR_Reserve_0;
2614
2615 if(pu32XCInst == NULL)
2616 {
2617 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2618 }
2619 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_ASPECTRATIO, (void*)&XCArgs) != 0)
2620 {
2621 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2622 }
2623
2624 return XCArgs.eReturnValue;
2625 }
2626 //-------------------------------------------------------------------------------------------------
2627 /// Get the HDMI aspect ratio info
2628 /// @param bEn_AFAR \b IN: Enable to get the Active Format Aspect Ratio
2629 /// @return @ref MS_HDMI_AR_TYPE
2630 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Get_ActiveFormat_AspectRatio_U2(void * pInstance,MS_U8 ucHDMIInfoSource,MS_BOOL bEn_AFAR)2631 MS_HDMI_AR_TYPE MDrv_HDMI_Get_ActiveFormat_AspectRatio_U2(void* pInstance, MS_U8 ucHDMIInfoSource, MS_BOOL bEn_AFAR)
2632 {
2633 MS_HDMI_AR_TYPE enAfar_types;
2634 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2635 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2636 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
2637 MS_U8 u8AR = Hal_HDMI_avi_infoframe_info(ucHDMIInfoSource, _BYTE_2) & HDMI_AR_REG_MASK;
2638 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
2639
2640 // Active Format Aspect Ratio - AFAR
2641 if(bEn_AFAR)
2642 {
2643 switch(u8AR & HDMI_AFAR_MASK)
2644 {
2645 case 0x02: // IF0[11..8] 0010, box 16:9 (top)
2646 enAfar_types = HDMI_AF_AR_16x9_Top;
2647 break;
2648 case 0x03: // IF0[11..8] 0011, box 14:9 (top)
2649 enAfar_types = HDMI_AF_AR_14x9_Top;
2650 break;
2651 case 0x04: // IF0[11..8] 0100, box >16:9 (centre)
2652 enAfar_types = HDMI_AF_AR_GT_16x9;
2653 break;
2654 case 0x08: // IF0[11..8] 1000, same as picture
2655 enAfar_types = HDMI_AF_AR_SAME;
2656 break;
2657 case 0x09: // IF0[11..8] 1001, 4:3 Center
2658 enAfar_types = HDMI_AF_AR_4x3_C;
2659 break;
2660 case 0x0A: // IF0[11..8] 1010, 16:9 Center
2661 enAfar_types = HDMI_AF_AR_16x9_C;
2662 break;
2663 case 0x0B: // IF0[11..8] 1011, 14:9 Center
2664 enAfar_types = HDMI_AF_AR_14x9_C;
2665 break;
2666 case 0x0D: // IF0[11..8] 1101, 4:3 with shoot and protect 14:9 centre
2667 enAfar_types = HDMI_AF_AR_4x3_with_14x9_C;
2668 break;
2669 case 0x0E: // IF0[11..8] 1110, 16:9 with shoot and protect 14:9 centre
2670 enAfar_types = HDMI_AF_AR_16x9_with_14x9_C;
2671 break;
2672 case 0x0F: // IF0[11..8] 1111, 16:9 with shoot and protect 4:3 centre.
2673 enAfar_types = HDMI_AF_AR_16x9_with_4x3_C;
2674 break;
2675
2676 default:
2677 enAfar_types = HDMI_AF_AR_SAME;
2678 break;
2679 }
2680 }
2681 else
2682 {
2683 enAfar_types = HDMI_AF_AR_SAME;
2684 }
2685
2686 return enAfar_types;
2687 }
2688
MDrv_HDMI_Get_ActiveFormat_AspectRatio(MS_BOOL bEn_AFAR)2689 MS_HDMI_AR_TYPE MDrv_HDMI_Get_ActiveFormat_AspectRatio(MS_BOOL bEn_AFAR)
2690 {
2691 stHDMI_GET_ACTIVEFORMAT_ASPECTRATIO XCArgs = {0};
2692
2693 XCArgs.bEn_AFAR = bEn_AFAR;
2694 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2695 XCArgs.eReturnValue = HDMI_AF_AR_Reserve_0;
2696
2697 if(pu32XCInst == NULL)
2698 {
2699 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2700 }
2701 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_ACTIVEFORMAT_ASPECTRATIO, (void*)&XCArgs) != 0)
2702 {
2703 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2704 }
2705
2706 return XCArgs.eReturnValue;
2707 }
2708
2709 //-------------------------------------------------------------------------------------------------
2710 /// Get the content type reported from player
2711 /// @return @ref MS_HDMI_CONTENT_TYPE
2712 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Get_Content_Type_U2(void * pInstance,MS_U8 ucHDMIInfoSource)2713 MS_HDMI_CONTENT_TYPE MDrv_HDMI_Get_Content_Type_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
2714 {
2715 MS_HDMI_CONTENT_TYPE enCN = MS_HDMI_CONTENT_NoData;
2716 MS_U8 u8Temp = 0;
2717 MS_BOOL bITC = 0;
2718
2719 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2720 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2721 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
2722 bITC = Hal_HDMI_avi_infoframe_info(ucHDMIInfoSource, _BYTE_3)& 0x80;
2723 u8Temp = Hal_HDMI_avi_infoframe_info(ucHDMIInfoSource, _BYTE_5)& 0x30;
2724 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
2725
2726 switch(u8Temp)
2727 {
2728 case 0x00:
2729 if(bITC)
2730 enCN = MS_HDMI_CONTENT_Graphics;
2731 else
2732 enCN = MS_HDMI_CONTENT_NoData;
2733 break;
2734 case 0x10:
2735 enCN = MS_HDMI_CONTENT_Photo;
2736 break;
2737 case 0x20:
2738 enCN = MS_HDMI_CONTENT_Cinema;
2739 break;
2740 case 0x30:
2741 enCN = MS_HDMI_CONTENT_Game;
2742 break;
2743 default:
2744 enCN = MS_HDMI_CONTENT_NoData;
2745 break;
2746 };
2747
2748 return enCN;
2749 }
2750
MDrv_HDMI_Get_Content_Type(void)2751 MS_HDMI_CONTENT_TYPE MDrv_HDMI_Get_Content_Type(void)
2752 {
2753 stHDMI_GET_CONTENT_TYPE XCArgs = {0};
2754
2755 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2756 XCArgs.enReturnValue = MS_HDMI_CONTENT_NoData;
2757
2758 if(pu32XCInst == NULL)
2759 {
2760 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2761 }
2762 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_CONTENT_TYPE, (void*)&XCArgs) != 0)
2763 {
2764 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2765 }
2766
2767 return XCArgs.enReturnValue;
2768 }
2769
2770 //-------------------------------------------------------------------------------------------------
2771 /// Get the Pixel repetition from player
2772 /// @return @ref MS_HDMI_COLOR_FORMAT
2773 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Get_Pixel_Repetition_U2(void * pInstance,MS_U8 ucHDMIInfoSource)2774 MS_U8 MDrv_HDMI_Get_Pixel_Repetition_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
2775 {
2776 MS_U8 u8Return = 0;
2777 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2778 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2779 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
2780 u8Return = Hal_HDMI_avi_infoframe_info(ucHDMIInfoSource, _BYTE_5)& 0x0F;
2781 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
2782 return u8Return;
2783 }
2784
MDrv_HDMI_Get_Pixel_Repetition(void)2785 MS_U8 MDrv_HDMI_Get_Pixel_Repetition(void)
2786 {
2787 stHDMI_GET_PIXEL_REPETITION XCArgs = {0};
2788
2789 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2790 XCArgs.u8ReturnValue = 0;
2791
2792 if(pu32XCInst == NULL)
2793 {
2794 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2795 }
2796 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_PIXEL_REPETITION, (void*)&XCArgs) != 0)
2797 {
2798 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2799 }
2800
2801 return XCArgs.u8ReturnValue;
2802 }
2803
2804 //-------------------------------------------------------------------------------------------------
2805 /// Get the AVI InfoFrame version
2806 /// @return @ref EN_AVI_INFOFRAME_VERSION
2807 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Get_AVIInfoFrameVer_U2(void * pInstance,MS_U8 ucHDMIInfoSource)2808 EN_AVI_INFOFRAME_VERSION MDrv_HDMI_Get_AVIInfoFrameVer_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
2809 {
2810 EN_AVI_INFOFRAME_VERSION enPktVersion= E_AVI_INFOFRAME_VERSION_NON;
2811 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2812 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2813 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
2814 enPktVersion = Hal_HDMI_avi_infoframe_info_ver(ucHDMIInfoSource);
2815 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
2816 return enPktVersion;
2817 }
2818
MDrv_HDMI_Get_AVIInfoFrameVer(void)2819 EN_AVI_INFOFRAME_VERSION MDrv_HDMI_Get_AVIInfoFrameVer(void)
2820 {
2821 stHDMI_GET_AVIINFOFRAMEVER XCArgs = {0};
2822
2823 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2824 XCArgs.eReturnValue = E_AVI_INFOFRAME_VERSION_NON;
2825
2826 if(pu32XCInst == NULL)
2827 {
2828 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2829 }
2830 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_AVIINFOFRAMEVER, (void*)&XCArgs) != 0)
2831 {
2832 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2833 }
2834
2835 return XCArgs.eReturnValue;
2836 }
2837
2838 //-------------------------------------------------------------------------------------------------
2839 /// Get the active information present from AVI
2840 /// @return
2841 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Get_AVIInfoActiveInfoPresent_U2(void * pInstance,MS_U8 ucHDMIInfoSource)2842 MS_BOOL MDrv_HDMI_Get_AVIInfoActiveInfoPresent_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
2843 {
2844 MS_BOOL bReturn = FALSE;
2845 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2846 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2847 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
2848
2849 if(Hal_HDMI_avi_infoframe_info(ucHDMIInfoSource, _BYTE_1) & BIT(4))
2850 {
2851 bReturn = TRUE;
2852 }
2853
2854 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
2855
2856 return bReturn;
2857 }
2858
MDrv_HDMI_Get_AVIInfoActiveInfoPresent(void)2859 MS_BOOL MDrv_HDMI_Get_AVIInfoActiveInfoPresent(void)
2860 {
2861 stHDMI_GET_AVIIINFO_ACTIVEINFOPRESENT XCArgs = {0};
2862
2863 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2864 XCArgs.bReturnValue = FALSE;
2865
2866 if(pu32XCInst == NULL)
2867 {
2868 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2869 }
2870 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AVIINFO_ACTIVEINFOPRESENT, (void*)&XCArgs) != 0)
2871 {
2872 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2873 }
2874
2875 return XCArgs.bReturnValue;
2876 }
2877
2878 //-------------------------------------------------------------------------------------------------
2879 /// Pull DVI Clock to low
2880 /// @param bPullLow \b IN: Set DVI clock to low
2881 /// @param enInputPortType \b IN: Input source
2882 //-------------------------------------------------------------------------------------------------
MDrv_DVI_ClkPullLow_U2(void * pInstance,MS_BOOL bPullLow,E_MUX_INPUTPORT enInputPortType)2883 void MDrv_DVI_ClkPullLow_U2(void* pInstance, MS_BOOL bPullLow, E_MUX_INPUTPORT enInputPortType)
2884 {
2885 Hal_DVI_ClkPullLow(bPullLow, enInputPortType);
2886 }
2887
MDrv_DVI_ClkPullLow(MS_BOOL bPullLow,E_MUX_INPUTPORT enInputPortType)2888 void MDrv_DVI_ClkPullLow(MS_BOOL bPullLow, E_MUX_INPUTPORT enInputPortType)
2889 {
2890 if (pu32XCInst == NULL)
2891 {
2892 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2893 return;
2894 }
2895
2896 stDVI_CLKPULLLOW XCArgs;
2897 XCArgs.bPullLow = bPullLow;
2898 XCArgs.enInputPortType = enInputPortType;
2899
2900 if(UtopiaIoctl(pu32XCInst, E_XC_DVI_IF_CMD_CLKPULLLOW, (void*)&XCArgs) != 0)
2901 {
2902 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2903 return;
2904 }
2905 else
2906 {
2907 return;
2908 }
2909 }
2910
2911 //-------------------------------------------------------------------------------------------------
2912 /// Switch DVI source
2913 /// @param enInputPortType \b IN: Input source
2914 //-------------------------------------------------------------------------------------------------
MDrv_DVI_SwitchSrc_U2(void * pInstance,E_MUX_INPUTPORT enInputPortType,MS_U8 ucHDMIInfoSource)2915 void MDrv_DVI_SwitchSrc_U2(void* pInstance, E_MUX_INPUTPORT enInputPortType, MS_U8 ucHDMIInfoSource)
2916 {
2917 Hal_DVI_SwitchSrc(enInputPortType, ucHDMIInfoSource);
2918 }
2919
MDrv_DVI_SwitchSrc(E_MUX_INPUTPORT enInputPortType)2920 void MDrv_DVI_SwitchSrc(E_MUX_INPUTPORT enInputPortType)
2921 {
2922 stDVI_SWITCHSRC XCArgs = {0};
2923
2924 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
2925 XCArgs.enInputPortType = enInputPortType;
2926
2927 if(pu32XCInst == NULL)
2928 {
2929 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2930 }
2931 else if(UtopiaIoctl(pu32XCInst, E_XC_DVI_IF_CMD_SWITCHSRC, (void*)&XCArgs) != 0)
2932 {
2933 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2934 }
2935 }
2936
MDrv_DVI_IMMESWITCH_PS_SW_Path(void * pInstance)2937 void MDrv_DVI_IMMESWITCH_PS_SW_Path(void *pInstance)
2938 {
2939 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2940 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2941 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2942 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2943 if(pXCResourcePrivate->stdrvXC_MVideo_Context.g_bIsIMMESWITCH) // Only apply in imme switch case
2944 {
2945 Hal_DVI_IMMESWITCH_PS_SW_Path();
2946 }
2947 }
2948
2949 /// lib version
MDrv_HDMI_GetLibVer_U2(void * pInstance,const MSIF_Version ** ppVersion)2950 HDMI_Ret_Value MDrv_HDMI_GetLibVer_U2(void* pInstance, const MSIF_Version **ppVersion)
2951 {
2952 if (!ppVersion)
2953 {
2954 return E_HDMI_RET_FAIL;
2955 }
2956
2957 *ppVersion = &_drv_hdmi_version;
2958 return E_HDMI_RET_OK;
2959 }
2960
MDrv_HDMI_GetLibVer(const MSIF_Version ** ppVersion)2961 HDMI_Ret_Value MDrv_HDMI_GetLibVer(const MSIF_Version **ppVersion)
2962 {
2963 if (pu32XCInst == NULL)
2964 {
2965 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
2966 return E_HDMI_RET_FAIL;
2967 }
2968
2969 stHDMI_GETLIBVER XCArgs;
2970 XCArgs.ppVersion = ppVersion;
2971 XCArgs.eReturnValue = E_HDMI_RET_FAIL;
2972
2973 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GETLIBVER, (void*)&XCArgs) != 0)
2974 {
2975 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
2976 return E_HDMI_RET_FAIL;
2977 }
2978 else
2979 {
2980 return XCArgs.eReturnValue;
2981 }
2982 }
2983
2984 // lib information
MDrv_HDMI_GetInfo_U2(void * pInstance,MS_HDMI_INFO * pInfo)2985 HDMI_Ret_Value MDrv_HDMI_GetInfo_U2(void* pInstance, MS_HDMI_INFO *pInfo)
2986 {
2987 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2988 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2989 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2990
2991 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
2992 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2993
2994 memcpy((void*)pInfo, (void*)&(pXCResourcePrivate->stdrv_HDMI._info), sizeof(MS_HDMI_INFO));
2995
2996 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
2997
2998 return E_HDMI_RET_OK;
2999 }
3000
MDrv_HDMI_GetInfo(MS_HDMI_INFO * pInfo)3001 HDMI_Ret_Value MDrv_HDMI_GetInfo(MS_HDMI_INFO *pInfo)
3002 {
3003 if (pu32XCInst == NULL)
3004 {
3005 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3006 return E_HDMI_RET_FAIL;
3007 }
3008
3009 stHDMI_GETINFO XCArgs;
3010 XCArgs.pInfo = pInfo;
3011 XCArgs.eReturnValue = E_HDMI_RET_FAIL;
3012
3013 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GETINFO, (void*)&XCArgs) != 0)
3014 {
3015 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3016 return E_HDMI_RET_FAIL;
3017 }
3018 else
3019 {
3020 return XCArgs.eReturnValue;
3021 }
3022 }
3023
3024 // curretn status
MDrv_HDMI_GetStatus_U2(void * pInstance,MS_HDMI_Status * pStatus)3025 HDMI_Ret_Value MDrv_HDMI_GetStatus_U2(void* pInstance, MS_HDMI_Status *pStatus)
3026 {
3027 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3028 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3029 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3030
3031 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3032 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3033 memcpy((void*)pStatus, (void*)&(pXCResourcePrivate->stdrv_HDMI._status), sizeof(MS_HDMI_Status));
3034 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3035 return E_HDMI_RET_OK;
3036 }
3037
MDrv_HDMI_GetStatus(MS_HDMI_Status * pStatus)3038 HDMI_Ret_Value MDrv_HDMI_GetStatus(MS_HDMI_Status *pStatus)
3039 {
3040 if (pu32XCInst == NULL)
3041 {
3042 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3043 return E_HDMI_RET_FAIL;
3044 }
3045
3046 stHDMI_GETSTATUS XCArgs;
3047 XCArgs.pStatus = pStatus;
3048 XCArgs.eReturnValue = E_HDMI_RET_FAIL;
3049
3050 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GETSTATUS, (void*)&XCArgs) != 0)
3051 {
3052 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3053 return E_HDMI_RET_FAIL;
3054 }
3055 else
3056 {
3057 return XCArgs.eReturnValue;
3058 }
3059 }
3060
3061 // DDC
MDrv_HDMI_ReadEDID(E_XC_DDCRAM_PROG_TYPE eDDCRamType,MS_U8 * u8EDID,MS_U16 u8EDIDSize)3062 static void MDrv_HDMI_ReadEDID(E_XC_DDCRAM_PROG_TYPE eDDCRamType, MS_U8 *u8EDID, MS_U16 u8EDIDSize)
3063 {
3064 MS_U16 i;
3065
3066 HAL_HDMI_DDCRam_SelectPort(eDDCRamType);
3067
3068 for( i = 0; i < u8EDIDSize; i++)
3069 {
3070 if(eDDCRamType == E_XC_PROG_VGA_EDID)
3071 {
3072 DDC_WRITE_MASK(REG_DDC_A_ACCESS,REG_DDC_A_ACCESS_BITS(1),REG_DDC_A_ACCESS_MASK);
3073 DDC_WRITE_MASK(REG_DDC_A_WRITEADDR,REG_DDC_A_WRITEADDR_BITS(i),REG_DDC_A_WRITEADDR_MASK);
3074 DDC_WRITE_MASK(REG_DDC_A_READPULSE,REG_DDC_A_READPULSE_BITS(1),REG_DDC_A_READPULSE_MASK);
3075 MsOS_DelayTaskUs(2);
3076 *(u8EDID + i) = (MS_U8)(DDC_READ_MASK(REG_DDC_A_READDATA, REG_DDC_A_READDATA_MASK)>>8);
3077 }
3078 else
3079 {
3080 DDC_WRITE_MASK(REG_DDC_D_ACCESS,REG_DDC_D_ACCESS_BITS(1),REG_DDC_D_ACCESS_MASK);
3081 DDC_WRITE_MASK(REG_DDC_D_WRITEADDR,REG_DDC_D_WRITEADDR_BITS(i),REG_DDC_D_WRITEADDR_MASK);
3082 DDC_WRITE_MASK(REG_DDC_D_READPULSE,REG_DDC_D_READPULSE_BITS(1),REG_DDC_D_READPULSE_MASK);
3083 MsOS_DelayTaskUs(2);
3084 *(u8EDID + i) = (MS_U8)(DDC_READ_MASK(REG_DDC_D_READDATA, REG_DDC_D_READDATA_MASK)>>8);
3085 }
3086 }
3087 }
3088
3089 // DDC
MDrv_HDMI_WriteEDID(E_XC_DDCRAM_PROG_TYPE eDDCRamType,MS_U8 * u8EDID,MS_U16 u8EDIDSize)3090 static void MDrv_HDMI_WriteEDID(E_XC_DDCRAM_PROG_TYPE eDDCRamType, MS_U8 *u8EDID, MS_U16 u8EDIDSize)
3091 {
3092 MS_U16 i;
3093
3094 HAL_HDMI_DDCRam_SelectPort(eDDCRamType);
3095
3096 for( i = 0; i < u8EDIDSize; i++)
3097 {
3098 if(eDDCRamType == E_XC_PROG_VGA_EDID)
3099 {
3100 DDC_WRITE_MASK(REG_DDC_A_ACCESS,REG_DDC_A_ACCESS_BITS(0),REG_DDC_A_ACCESS_MASK);
3101 DDC_WRITE_MASK(REG_DDC_A_WRITEADDR,REG_DDC_A_WRITEADDR_BITS(i),REG_DDC_A_WRITEADDR_MASK);
3102 DDC_WRITE_MASK(REG_DDC_A_WRITEDATA,REG_DDC_A_WRITEDATA_BITS(*(u8EDID + i)),REG_DDC_A_WRITEDATA_MASK);
3103 DDC_WRITE_MASK(REG_DDC_A_WRITEPULSE,REG_DDC_A_WRITEPULSE_BITS(1),REG_DDC_A_WRITEPULSE_MASK);
3104 }
3105 else
3106 {
3107 DDC_WRITE_MASK(REG_DDC_D_ACCESS,REG_DDC_D_ACCESS_BITS(0),REG_DDC_D_ACCESS_MASK);
3108 DDC_WRITE_MASK(REG_DDC_D_WRITEADDR,REG_DDC_D_WRITEADDR_BITS(i),REG_DDC_D_WRITEADDR_MASK);
3109 DDC_WRITE_MASK(REG_DDC_D_WRITEDATA,REG_DDC_D_WRITEDATA_BITS(*(u8EDID + i)),REG_DDC_D_WRITEDATA_MASK);
3110 DDC_WRITE_MASK(REG_DDC_D_WRITEPULSE,REG_DDC_D_WRITEPULSE_BITS(1),REG_DDC_D_WRITEPULSE_MASK);
3111 }
3112 }
3113 switch(eDDCRamType)
3114 {
3115 case E_XC_PROG_DVI0_EDID:
3116 DDC_WRITE_MASK(REG_DDC_DVI0_WP,BITS(13:13,1),BMASK(13:13)); // Write Protect 0 ddc
3117 break;
3118 case E_XC_PROG_DVI1_EDID:
3119 DDC_WRITE_MASK(REG_DDC_DVI1_WP,BITS(13:13,1),BMASK(13:13)); // Write Protect 1 ddc
3120 break;
3121 case E_XC_PROG_DVI2_EDID:
3122 DDC_WRITE_MASK(REG_DDC_DVI2_WP,BITS(5:5,1),BMASK(5:5)); // Write Protect 2 ddc
3123 break;
3124 case E_XC_PROG_DVI3_EDID:
3125 DDC_WRITE_MASK(REG_DDC_DVI3_WP,BITS(5:5,1),BMASK(5:5)); //Write Protect 3 ddc
3126 break;
3127 case E_XC_PROG_VGA_EDID:
3128 DDC_WRITE_MASK(REG_DDC_ADC0_WP,BITS(13:13,1),BMASK(13:13)); // Write Protect analog ddc
3129 break;
3130 default:
3131 MS_ASSERT(0);
3132 }
3133 }
3134
MDrv_HDMI_DDCRAM_Enable(E_XC_DDCRAM_PROG_TYPE eDDCRamType)3135 static void MDrv_HDMI_DDCRAM_Enable(E_XC_DDCRAM_PROG_TYPE eDDCRamType)
3136 {
3137 switch(eDDCRamType)
3138 {
3139 case E_XC_PROG_DVI0_EDID:
3140 DDC_WRITE_MASK(REG_DDC_DVI0_EN,BITS(15:15,1),BMASK(15:15)); // enable digital 0 ddc
3141 break;
3142 case E_XC_PROG_DVI1_EDID:
3143 DDC_WRITE_MASK(REG_DDC_DVI1_EN,BITS(15:15,1),BMASK(15:15)); // enable digital 1 ddc
3144 break;
3145 case E_XC_PROG_DVI2_EDID:
3146 DDC_WRITE_MASK(REG_DDC_DVI2_EN,BITS(7:7,1),BMASK(7:7)); // enable digital 2 ddc
3147 break;
3148 case E_XC_PROG_DVI3_EDID:
3149 DDC_WRITE_MASK(REG_DDC_DVI3_EN,BITS(7:7,1),BMASK(7:7)); // enable digital 3 ddc
3150 break;
3151 case E_XC_PROG_VGA_EDID:
3152 DDC_WRITE_MASK(REG_DDC_ADC0_EN,BITS(15:15,1),BMASK(15:15)); // enable analog ddc
3153 break;
3154 default:
3155 MS_ASSERT(0);
3156 }
3157 }
3158
MDrv_HDMI_READ_DDCRAM_U2(void * pInstance,XC_DDCRAM_PROG_INFO * pstDDCRam_Info,MS_U32 u32SizeOfInfo)3159 void MDrv_HDMI_READ_DDCRAM_U2(void* pInstance, XC_DDCRAM_PROG_INFO *pstDDCRam_Info, MS_U32 u32SizeOfInfo)
3160 {
3161 (u32SizeOfInfo)=(u32SizeOfInfo); //this Var is temp for UNUSE
3162
3163 MDrv_HDMI_DDCRAM_Enable(pstDDCRam_Info->eDDCProgType);
3164
3165 MDrv_HDMI_ReadEDID(pstDDCRam_Info->eDDCProgType, pstDDCRam_Info->EDID, pstDDCRam_Info->u16EDIDSize);
3166
3167 HAL_HDMI_DDCRAM_SetPhyAddr(pstDDCRam_Info);
3168 }
3169
MDrv_HDMI_READ_DDCRAM(XC_DDCRAM_PROG_INFO * pstDDCRam_Info,MS_U32 u32SizeOfInfo)3170 void MDrv_HDMI_READ_DDCRAM(XC_DDCRAM_PROG_INFO *pstDDCRam_Info, MS_U32 u32SizeOfInfo)
3171 {
3172 if (pu32XCInst == NULL)
3173 {
3174 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3175 return;
3176 }
3177
3178 stHDMI_READ_DDCRAM XCArgs;
3179 XCArgs.pstDDCRam_Info = pstDDCRam_Info;
3180 XCArgs.u32SizeOfInfo = u32SizeOfInfo;
3181
3182 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_READ_DDCRAM, (void*)&XCArgs) != 0)
3183 {
3184 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3185 return;
3186 }
3187 else
3188 {
3189 return;
3190 }
3191 }
3192
MDrv_HDMI_PROG_DDCRAM_internal(void * pInstance,XC_DDCRAM_PROG_INFO * pstDDCRam_Info,MS_U32 u32SizeOfInfo)3193 void MDrv_HDMI_PROG_DDCRAM_internal(void *pInstance, XC_DDCRAM_PROG_INFO *pstDDCRam_Info, MS_U32 u32SizeOfInfo)
3194 {
3195 (u32SizeOfInfo)=(u32SizeOfInfo); //this Var is temp for UNUSE
3196 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3197 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3198 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3199 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3200 if(pstDDCRam_Info->eDDCProgType != E_XC_PROG_VGA_EDID)
3201 {
3202 memcpy(pXCResourcePrivate->stdrvXC_MVideo_Context.g_u8EDID_DVIBackUp[pstDDCRam_Info->eDDCProgType - E_XC_PROG_DVI0_EDID], pstDDCRam_Info->EDID, EDID_KEY_LENGTH*sizeof(MS_U8));
3203 }
3204 MDrv_HDMI_DDCRAM_Enable(pstDDCRam_Info->eDDCProgType);
3205
3206 MDrv_HDMI_WriteEDID(pstDDCRam_Info->eDDCProgType, pstDDCRam_Info->EDID, pstDDCRam_Info->u16EDIDSize);
3207
3208 HAL_HDMI_DDCRAM_SetPhyAddr(pstDDCRam_Info);
3209 }
3210
MDrv_HDMI_PROG_DDCRAM_U2(void * pInstance,XC_DDCRAM_PROG_INFO * pstDDCRam_Info,MS_U32 u32SizeOfInfo)3211 void MDrv_HDMI_PROG_DDCRAM_U2(void* pInstance, XC_DDCRAM_PROG_INFO *pstDDCRam_Info, MS_U32 u32SizeOfInfo)
3212 {
3213 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3214 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3215 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3216 MDrv_HDMI_PROG_DDCRAM_internal(pInstance, pstDDCRam_Info, u32SizeOfInfo);
3217 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3218 }
3219
MDrv_HDMI_PROG_DDCRAM(XC_DDCRAM_PROG_INFO * pstDDCRam_Info,MS_U32 u32SizeOfInfo)3220 void MDrv_HDMI_PROG_DDCRAM(XC_DDCRAM_PROG_INFO *pstDDCRam_Info, MS_U32 u32SizeOfInfo)
3221 {
3222 if (pu32XCInst == NULL)
3223 {
3224 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3225 return;
3226 }
3227
3228 stHDMI_PROG_DDCRAM XCArgs;
3229 XCArgs.pstDDCRam_Info = pstDDCRam_Info;
3230 XCArgs.u32SizeOfInfo = u32SizeOfInfo;
3231
3232 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_PROG_DDCRAM, (void*)&XCArgs) != 0)
3233 {
3234 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3235 return;
3236 }
3237 else
3238 {
3239 return;
3240 }
3241 }
3242
3243 /** According to the previous experience, some specific source devices would
3244 send strange DVI / HDMI signal in slow frequency(like 480p) let us in trouble.
3245 So it's better to increase DVI updated phase count to 100 lines in low
3246 resolution to overcome that situation, originally DVI updated phase count is 1.
3247 So the patch would check input DVI frequency first, if small than 50MHz, DVI
3248 updated phase count would increase to 100 lines. Otherwise, DVI updated phase
3249 count would be recovered to 1 line. */
MDrv_HDMI_SetUpdatePhaseLineCount_U2(void * pInstance,INPUT_SOURCE_TYPE_t enInputSourceType)3250 void MDrv_HDMI_SetUpdatePhaseLineCount_U2(void* pInstance, INPUT_SOURCE_TYPE_t enInputSourceType)
3251 {
3252 E_MUX_INPUTPORT enPort = INPUT_PORT_NONE_PORT;
3253 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3254 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3255 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3256 enPort = MDrv_XC_Mux_GetHDMIPort(pInstance, enInputSourceType);
3257 if( enPort == INPUT_PORT_DVI0 || enPort == INPUT_PORT_DVI1 ||
3258 enPort == INPUT_PORT_DVI3 )
3259 {
3260 if( R2BYTEMSK(REG_DVI_ATOP_61_L, BMASK(9:8)) == 2<<8 ||
3261 R2BYTEMSK(REG_DVI_ATOP_61_L, BMASK(9:8)) == 3<<8 ) //<50Mhz
3262 {
3263 W2BYTEMSK(REG_DVI_DTOP_29_L, 0x0000, 0xFF00);
3264 W2BYTE(REG_DVI_DTOP_2A_L, 0x0000);
3265 // MDRV_HDMIRX_MSG_INFO("Low resolution\n");
3266
3267 }
3268 else
3269 {
3270 W2BYTEMSK(REG_DVI_DTOP_29_L, 0, 0xFF00);
3271 W2BYTE(REG_DVI_DTOP_2A_L, 0);
3272 // MDRV_HDMIRX_MSG_INFO("High resolution\n");
3273 }
3274
3275 }
3276 else if(enPort == INPUT_PORT_DVI2)
3277 {
3278 if( R2BYTEMSK(REG_DVI_ATOP_6A_L, BMASK(9:8)) == 2<<8 ||
3279 R2BYTEMSK(REG_DVI_ATOP_6A_L, BMASK(9:8)) == 3<<8 ) //<50Mhz
3280 {
3281 W2BYTEMSK(REG_DVI_DTOP_29_L, 0x0000, 0xFF00);
3282 W2BYTE(REG_DVI_DTOP_2A_L, 0x0000);
3283 // MDRV_HDMIRX_MSG_INFO("Low resolution 2\n");
3284 }
3285 else
3286 {
3287 W2BYTEMSK(REG_DVI_DTOP_29_L, 0, 0xFF00);
3288 W2BYTE(REG_DVI_DTOP_2A_L, 0);
3289 // MDRV_HDMIRX_MSG_INFO("High resolution 2\n");
3290 }
3291
3292 }
3293 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3294 }
3295
MDrv_HDMI_SetUpdatePhaseLineCount(INPUT_SOURCE_TYPE_t enInputSourceType)3296 void MDrv_HDMI_SetUpdatePhaseLineCount(INPUT_SOURCE_TYPE_t enInputSourceType)
3297 {
3298 if (pu32XCInst == NULL)
3299 {
3300 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3301 return;
3302 }
3303
3304 stHDMI_SETUPDATEPHASELINECOUNT XCArgs;
3305 XCArgs.enInputSourceType = enInputSourceType;
3306
3307 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_SETUPDATEPHASELINECOUNT, (void*)&XCArgs) != 0)
3308 {
3309 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3310 return;
3311 }
3312 else
3313 {
3314 return;
3315 }
3316 }
3317
MDrv_HDMI_Get_PollingStatus_U2(void * pInstance,HDMI_POLLING_STATUS_t ** pStatus)3318 void MDrv_HDMI_Get_PollingStatus_U2(void* pInstance, HDMI_POLLING_STATUS_t **pStatus)
3319 {
3320 *pStatus = &g_HdmiPollingStatus;
3321 }
3322
MDrv_HDMI_Get_PollingStatus(HDMI_POLLING_STATUS_t ** pStatus)3323 void MDrv_HDMI_Get_PollingStatus(HDMI_POLLING_STATUS_t **pStatus)
3324 {
3325 if (pu32XCInst == NULL)
3326 {
3327 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3328 return;
3329 }
3330
3331 stHDMI_GET_POLLINGSTATUS XCArgs;
3332 XCArgs.pStatus = NULL;
3333
3334 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_POLLINGSTATUS, (void*)&XCArgs) != 0)
3335 {
3336 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3337 return;
3338 }
3339 else
3340 {
3341 return;
3342 }
3343 }
3344
MDrv_HDMI_IsHDMI_Mode_U2(void * pInstance)3345 MS_BOOL MDrv_HDMI_IsHDMI_Mode_U2(void* pInstance)
3346 {
3347 MS_BOOL tmp;
3348 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3349 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3350 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3351 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3352 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3353 tmp= pXCResourcePrivate->stdrv_HDMI.enStatus_info.b_St_HDMI_Mode;
3354 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3355 return tmp;
3356 }
3357
MDrv_HDMI_IsHDMI_Mode(void)3358 MS_BOOL MDrv_HDMI_IsHDMI_Mode(void)
3359 {
3360 if (pu32XCInst == NULL)
3361 {
3362 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3363 return FALSE;
3364 }
3365
3366 stHDMI_ISHDMI_MODE XCArgs;
3367 XCArgs.bReturnValue = FALSE;
3368
3369 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_ISHDMI_MODE, (void*)&XCArgs) != 0)
3370 {
3371 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3372 return FALSE;
3373 }
3374 else
3375 {
3376 return XCArgs.bReturnValue;
3377 }
3378 }
3379
3380 //-------------------------------------------------------------------------------------------------
3381 /// Get the extended colorimetry from packet
3382 /// @return @ref MS_HDMI_EXT_COLORIMETRY_FORMAT
3383 //-------------------------------------------------------------------------------------------------
MDrv_HDMI_Get_ExtColorimetry_U2(void * pInstance,MS_U8 ucHDMIInfoSource)3384 MS_HDMI_EXT_COLORIMETRY_FORMAT MDrv_HDMI_Get_ExtColorimetry_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
3385 {
3386 MS_HDMI_EXT_COLORIMETRY_FORMAT pkt_ExtColorimetry = MS_HDMI_EXT_COLOR_UNKNOWN;
3387 MS_U8 u8AVI_info2, u8AVI_info3;
3388
3389 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3390 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3391 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3392
3393 u8AVI_info2 = Hal_HDMI_avi_infoframe_info(ucHDMIInfoSource, _BYTE_2);
3394 MDRV_HDMIRX_MSG_INFO(" MDrv_HDMI_Get_ExtColorimetry_U2 u8AVI_info2 is 0X%X , avi_info2&0xc0 0x%X \n",u8AVI_info2,(u8AVI_info2&0xc0));
3395 if((u8AVI_info2&0xc0) == 0xc0 )
3396 {
3397 u8AVI_info3= Hal_HDMI_avi_infoframe_info(ucHDMIInfoSource, _BYTE_3);
3398 MDRV_HDMIRX_MSG_INFO(" MDrv_HDMI_Get_ExtColorimetry_U2 u8AVI_info3 is 0X%X \n",u8AVI_info3);
3399 switch (u8AVI_info3 & 0x70)
3400 {
3401 case 0x00:
3402 pkt_ExtColorimetry = MS_HDMI_EXT_COLOR_XVYCC601;
3403 break;
3404 case 0x10:
3405 pkt_ExtColorimetry = MS_HDMI_EXT_COLOR_XVYCC709;
3406 break;
3407 case 0x20:
3408 pkt_ExtColorimetry = MS_HDMI_EXT_COLOR_SYCC601;
3409 break;
3410 case 0x30:
3411 pkt_ExtColorimetry = MS_HDMI_EXT_COLOR_ADOBEYCC601;
3412 break;
3413 case 0x40:
3414 pkt_ExtColorimetry = MS_HDMI_EXT_COLOR_ADOBERGB;
3415 break;
3416 case 0x50:
3417 pkt_ExtColorimetry = MS_HDMI_EXT_COLOR_BT2020YcCbcCrc;
3418 break;
3419 case 0x60:
3420 pkt_ExtColorimetry = MS_HDMI_EXT_COLOR_BT2020RGBYCbCr;
3421 break;
3422 default:
3423 pkt_ExtColorimetry = MS_HDMI_EXT_COLOR_UNKNOWN;
3424 break;
3425 }
3426 }
3427 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
3428 return pkt_ExtColorimetry;
3429 }
3430
MDrv_HDMI_Get_ExtColorimetry(void)3431 MS_HDMI_EXT_COLORIMETRY_FORMAT MDrv_HDMI_Get_ExtColorimetry(void)
3432 {
3433 stHDMI_GET_EXT_COLORIMETRY XCArgs = {0};
3434
3435 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
3436 XCArgs.enReturnValue = MS_HDMI_EXT_COLOR_UNKNOWN;
3437
3438 if(pu32XCInst == NULL)
3439 {
3440 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3441 }
3442 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_EXTCOLORIMETRY, (void*)&XCArgs) != 0)
3443 {
3444 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3445 }
3446
3447 return XCArgs.enReturnValue;
3448 }
3449
MDrv_HDMI_GetHDE(void)3450 MS_U16 MDrv_HDMI_GetHDE(void)
3451 {
3452 return Hal_HDMI_GetHDEInfo(HDMI_INFO_SOURCE0);
3453 }
3454 #if 0
3455 void MDrv_HDMI_ENABLE_IMMESWITCH( MS_BOOL bEnImmeswitch,MS_BOOL bEnPowSaving )
3456 {
3457 if(SUPPORT_IMMESWITCH)
3458 {
3459 g_bIsIMMESWITCH = bEnImmeswitch;
3460 g_bIMMESWITCH_DVI_POWERSAVING = bEnPowSaving;
3461 }
3462 else
3463 {
3464 g_bIsIMMESWITCH = FALSE;
3465 g_bIMMESWITCH_DVI_POWERSAVING = FALSE;
3466 }
3467 }
3468 #endif
3469
3470 #if 0
3471 void MDrv_HDMI_ImmeswitchPS_Handler(void)
3472 {
3473 E_MUX_INPUTPORT port;
3474 if(g_bIMMESWITCH_DVI_POWERSAVING)
3475 {
3476 for(port = INPUT_PORT_DVI0; port <=INPUT_PORT_DVI3; port++)
3477 {
3478 //if(!Hal_DVI_GetPowerSavingStatus(port)) // not need to check if power saving mode is not enable
3479 //continue;
3480
3481 if(Hal_DVI_GetDEStableStatus(port)) // stable
3482 {
3483 if(u8PSDVIStableCount[port-INPUT_PORT_DVI0] < 255)
3484 u8PSDVIStableCount[port-INPUT_PORT_DVI0] += 1;
3485 }
3486 else // unstable
3487 {
3488 if(u8PSDVIStableCount[port-INPUT_PORT_DVI0] > 0)
3489 {
3490 Hal_DVI_EnhanceImmeswitch(port, FALSE);
3491 MDRV_HDMIRX_MSG_INFO("$$$ MDrv_HDMI_ImmeswitchPS_Handler: port %d is unstable\n", port-INPUT_PORT_DVI0);
3492 }
3493 u8PSDVIStableCount[port-INPUT_PORT_DVI0] = 0;
3494 }
3495
3496 if(u8PSDVIStableCount[port-INPUT_PORT_DVI0] >= 3) // enable Immeswithc enhancement only when continous DE stable
3497 {
3498 if(u8PSDVIStableCount[port-INPUT_PORT_DVI0] == 3)
3499 {
3500 Hal_DVI_EnhanceImmeswitch(port, TRUE);
3501 MDRV_HDMIRX_MSG_INFO("$$$ MDrv_HDMI_ImmeswitchPS_Handler: port %d is stable\n", port-INPUT_PORT_DVI0);
3502 }
3503 }
3504 }
3505 }
3506 }
3507
3508 void MDrv_DVI_ForceAllPortsEnterPS(void)
3509 {
3510 if(g_bIMMESWITCH_DVI_POWERSAVING)
3511 {
3512 MDRV_HDMIRX_MSG_INFO("$$$ MDrv_DVI_ForceAllPortsEnterPS \n");
3513 Hal_DVI_ForceAllPortsEnterPS();
3514 }
3515 }
3516 #endif
3517
MDrv_HDMI_Check4K2K_U2(void * pInstance,MS_U8 ucHDMIInfoSource)3518 MS_BOOL MDrv_HDMI_Check4K2K_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
3519 {
3520 MS_BOOL bReturnFlag = FALSE;
3521 #if SUPPORT_HDMI_RX_NEW_FEATURE
3522 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3523 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3524 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3525 E_HDMI_ADDITIONAL_VIDEO_FORMAT val = E_HDMI_NA;
3526 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
3527 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3528
3529 if(pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_VS_PACKET_RECEIVE_FLAG) // VSP packet should be received first
3530 {
3531 val = Hal_HDMI_Check_Additional_Format(ucHDMIInfoSource);
3532
3533 if(Hal_HDMI_Is_Input_Large_166MHz(ucHDMIInfoSource))
3534 {
3535 MDRV_HDMIRX_MSG_INFO("~~~ HDMI 4Kx2K case, input bigger than 166Mhz ~~~\n");
3536 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
3537 bReturnFlag = TRUE;
3538 }
3539 }
3540
3541 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3542 #endif
3543
3544 return bReturnFlag;
3545 }
3546
MDrv_HDMI_Check4K2K(void)3547 MS_BOOL MDrv_HDMI_Check4K2K(void)
3548 {
3549 stHDMI_CHECK_4K2K XCArgs = {0};
3550
3551 XCArgs.bReturnValue = FALSE;
3552 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
3553
3554 if(pu32XCInst == NULL)
3555 {
3556 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3557 }
3558 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_CHECK_4K2K, (void*)&XCArgs) != 0)
3559 {
3560 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3561 }
3562
3563 return XCArgs.bReturnValue;
3564 }
3565
MDrv_HDMI_3D_4Kx2K_Process_U2(void * pInstance,MS_U8 ucHDMIInfoSource)3566 void MDrv_HDMI_3D_4Kx2K_Process_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
3567 {
3568 #if SUPPORT_HDMI_RX_NEW_FEATURE
3569 E_HDMI_ADDITIONAL_VIDEO_FORMAT val = E_HDMI_NA;
3570 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3571 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3572 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3573
3574 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
3575 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3576
3577 if(pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_VS_PACKET_RECEIVE_FLAG) // VSP packet should be received first
3578 {
3579 val = Hal_HDMI_Check_Additional_Format(ucHDMIInfoSource);
3580
3581 if(Hal_HDMI_Is_Input_Large_166MHz(ucHDMIInfoSource))
3582 {
3583 Hal_HDMI_AVG_ScaleringDown(ucHDMIInfoSource, TRUE);
3584 MDRV_HDMIRX_MSG_INFO("~~~ HDMI 3D or 4Kx2K scaling down= %x\n", val);
3585 }
3586 else
3587 {
3588 Hal_HDMI_AVG_ScaleringDown(ucHDMIInfoSource, FALSE);
3589 }
3590 }
3591
3592 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
3593 #else
3594 // Do nothing
3595 #endif
3596 }
3597
MDrv_HDMI_3D_4Kx2K_Process(void)3598 void MDrv_HDMI_3D_4Kx2K_Process(void)
3599 {
3600 stHDMI_3D_4K2K_PROCESS XCArgs = {0};
3601
3602 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
3603
3604 if(pu32XCInst == NULL)
3605 {
3606 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3607 }
3608 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_3D_4KX2K_PROCESS, (void*)&XCArgs) != 0)
3609 {
3610 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3611 }
3612 }
3613
MDrv_HDMI_AVG_ScaleringDown_U2(void * pInstance,MS_U8 ucHDMIInfoSource,MS_BOOL bTrue)3614 void MDrv_HDMI_AVG_ScaleringDown_U2(void* pInstance, MS_U8 ucHDMIInfoSource, MS_BOOL bTrue)
3615 {
3616 #if SUPPORT_HDMI_RX_NEW_FEATURE
3617 Hal_HDMI_AVG_ScaleringDown(ucHDMIInfoSource, bTrue);
3618 #else
3619 // Do nothing
3620 #endif
3621 }
3622
MDrv_HDMI_AVG_ScaleringDown(MS_BOOL bTrue)3623 void MDrv_HDMI_AVG_ScaleringDown(MS_BOOL bTrue)
3624 {
3625 stHDMI_AVG_SCALERINGDOWN XCArgs = {0};
3626
3627 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
3628 XCArgs.bTrue = bTrue;
3629
3630 if(pu32XCInst == NULL)
3631 {
3632 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3633 }
3634 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AVG_SCALERINGDOWN, (void*)&XCArgs) != 0)
3635 {
3636 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3637 }
3638 }
3639
MDrv_HDMI_Check_Additional_Format_U2(void * pInstance,MS_U8 ucHDMIInfoSource)3640 E_HDMI_ADDITIONAL_VIDEO_FORMAT MDrv_HDMI_Check_Additional_Format_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
3641 {
3642 E_HDMI_ADDITIONAL_VIDEO_FORMAT eAdditionalFormat = E_HDMI_NA;
3643 #if SUPPORT_HDMI_RX_NEW_FEATURE
3644 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3645 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3646 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3647
3648 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
3649 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3650
3651 if(pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_VS_PACKET_RECEIVE_FLAG) // VSP packet should be received first
3652 {
3653 eAdditionalFormat = Hal_HDMI_Check_Additional_Format(ucHDMIInfoSource);
3654 }
3655
3656 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
3657
3658 #endif
3659
3660 return eAdditionalFormat;
3661 }
3662
MDrv_HDMI_Check_Additional_Format(void)3663 E_HDMI_ADDITIONAL_VIDEO_FORMAT MDrv_HDMI_Check_Additional_Format(void)
3664 {
3665 stHDMI_CHECK_ADDITIONAL_FORMAT XCArgs = {0};
3666
3667 XCArgs.eReturnValue = E_HDMI_NA;
3668 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
3669
3670 if(pu32XCInst == NULL)
3671 {
3672 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3673 }
3674 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_CHECK_ADDITIONAL_FORMAT, (void*)&XCArgs) != 0)
3675 {
3676 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3677 }
3678
3679 return XCArgs.eReturnValue;
3680 }
3681
MDrv_HDMI_Get_3D_Structure_U2(void * pInstance,MS_U8 ucHDMIInfoSource)3682 E_XC_3D_INPUT_MODE MDrv_HDMI_Get_3D_Structure_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
3683 {
3684 E_XC_3D_INPUT_MODE e3DStructure = E_XC_3D_INPUT_MODE_NONE;
3685 #if SUPPORT_HDMI_RX_NEW_FEATURE
3686 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3687 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3688 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3689
3690 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
3691 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3692
3693 if(pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_VS_PACKET_RECEIVE_FLAG) // VSP packet should be received first
3694 {
3695 e3DStructure = Hal_HDMI_Get_3D_Structure(ucHDMIInfoSource);
3696 }
3697
3698 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
3699
3700 #endif
3701
3702 return e3DStructure;
3703 }
3704
MDrv_HDMI_Get_3D_Structure(void)3705 E_XC_3D_INPUT_MODE MDrv_HDMI_Get_3D_Structure(void)
3706 {
3707 stHDMI_GET_3D_STRUCTURE XCArgs = {0};
3708
3709 XCArgs.eReturnValue = E_XC_3D_INPUT_MODE_NONE;
3710 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
3711
3712 if(pu32XCInst == NULL)
3713 {
3714 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3715 }
3716 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_3D_STRUCTURE, (void*)&XCArgs) != 0)
3717 {
3718 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3719 }
3720
3721 return XCArgs.eReturnValue;
3722 }
3723
MDrv_HDMI_Get_3D_Ext_Data_U2(void * pInstance,MS_U8 ucHDMIInfoSource)3724 E_HDMI_3D_EXT_DATA_T MDrv_HDMI_Get_3D_Ext_Data_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
3725 {
3726 E_HDMI_3D_EXT_DATA_T e3DExtendData = E_3D_EXT_DATA_MODE_MAX;
3727 #if SUPPORT_HDMI_RX_NEW_FEATURE
3728 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3729 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3730 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3731
3732 _XC_SEMAPHORE_ENTRY(pInstance, E_XC_ID_VAR);
3733 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3734
3735 if(pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_VS_PACKET_RECEIVE_FLAG) // VSP packet should be received first
3736 {
3737 e3DExtendData = Hal_HDMI_Get_3D_Ext_Data(ucHDMIInfoSource);
3738 }
3739
3740 _XC_SEMAPHORE_RETURN(pInstance, E_XC_ID_VAR);
3741
3742 #endif
3743
3744 return e3DExtendData;
3745 }
3746
MDrv_HDMI_Get_3D_Ext_Data(void)3747 E_HDMI_3D_EXT_DATA_T MDrv_HDMI_Get_3D_Ext_Data(void)
3748 {
3749 stHDMI_GET_3D_EXT_DATA XCArgs = {0};
3750
3751 XCArgs.eReturnValue = E_3D_EXT_DATA_MODE_MAX;
3752 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
3753
3754 if(pu32XCInst == NULL)
3755 {
3756 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3757 }
3758 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_CMD_GET_3D_EXT_DATA, (void*)&XCArgs) != 0)
3759 {
3760 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3761 }
3762
3763 return XCArgs.eReturnValue;
3764 }
3765
MDrv_HDMI_Get_3D_Meta_Field_U2(void * pInstance,MS_U8 ucHDMIInfoSource,sHDMI_3D_META_FIELD * pdata)3766 void MDrv_HDMI_Get_3D_Meta_Field_U2(void* pInstance, MS_U8 ucHDMIInfoSource, sHDMI_3D_META_FIELD *pdata)
3767 {
3768 #if SUPPORT_HDMI_RX_NEW_FEATURE
3769 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3770 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3771 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3772
3773 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3774 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3775
3776 if(pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_VS_PACKET_RECEIVE_FLAG) // VSP packet should be received first
3777 {
3778 Hal_HDMI_Get_3D_Meta_Field(ucHDMIInfoSource, pdata);
3779 }
3780 else
3781 {
3782 memset(pdata, 0, sizeof(sHDMI_3D_META_FIELD));
3783 }
3784
3785 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3786 #else
3787 // Do nothing
3788 #endif
3789 }
3790
MDrv_HDMI_Get_3D_Meta_Field(sHDMI_3D_META_FIELD * pdata)3791 void MDrv_HDMI_Get_3D_Meta_Field(sHDMI_3D_META_FIELD *pdata)
3792 {
3793 stHDMI_GET_3D_META_FIELD XCArgs = {0};
3794
3795 XCArgs.pdata = pdata;
3796 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
3797
3798 if(pu32XCInst == NULL)
3799 {
3800 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3801 }
3802 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_3D_META_FIELD, (void*)&XCArgs) != 0)
3803 {
3804 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3805 }
3806 }
3807
MDrv_HDMI_Get_VIC_Code_U2(void * pInstance,MS_U8 ucHDMIInfoSource)3808 MS_U8 MDrv_HDMI_Get_VIC_Code_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
3809 {
3810 MS_U8 ucVICCode = 0;
3811 #if SUPPORT_HDMI_RX_NEW_FEATURE
3812 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3813 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3814 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3815
3816 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3817 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3818
3819 if(pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_AVI_PACKET_RECEIVE_FLAG) // AVI packet should be received first
3820 {
3821 ucVICCode = Hal_HDMI_Get_VIC_Code(ucHDMIInfoSource);
3822 }
3823
3824 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3825
3826 #endif
3827
3828 return ucVICCode;
3829 }
3830
MDrv_HDMI_Get_VIC_Code(void)3831 MS_U8 MDrv_HDMI_Get_VIC_Code(void)
3832 {
3833 stHDMI_GET_VIC_CODE XCArgs = {0};
3834
3835 XCArgs.u8ReturnValue = 0;
3836 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
3837
3838 if(pu32XCInst == NULL)
3839 {
3840 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3841 }
3842 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_VIC_CODE, (void*)&XCArgs) != 0)
3843 {
3844 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3845 }
3846
3847 return XCArgs.u8ReturnValue;
3848 }
3849
MDrv_HDMI_Get_4Kx2K_VIC_Code_U2(void * pInstance,MS_U8 ucHDMIInfoSource)3850 E_HDMI_VIC_4Kx2K_CODE MDrv_HDMI_Get_4Kx2K_VIC_Code_U2(void* pInstance, MS_U8 ucHDMIInfoSource)
3851 {
3852 E_HDMI_VIC_4Kx2K_CODE e4K2KVICCode = E_VIC_NA;
3853 #if SUPPORT_HDMI_RX_NEW_FEATURE
3854 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3855 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3856 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3857
3858 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3859 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3860
3861 if(pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_VS_PACKET_RECEIVE_FLAG) // VSP packet should be received first
3862 {
3863 e4K2KVICCode = Hal_HDMI_Get_4Kx2K_VIC_Code(ucHDMIInfoSource);
3864 }
3865
3866 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
3867
3868 #endif
3869
3870 return e4K2KVICCode;
3871 }
3872
MDrv_HDMI_Get_4Kx2K_VIC_Code(void)3873 E_HDMI_VIC_4Kx2K_CODE MDrv_HDMI_Get_4Kx2K_VIC_Code(void)
3874 {
3875 stHDMI_GET_4KX2K_VIC_CODE XCArgs;
3876
3877 XCArgs.eReturnValue = E_VIC_NA;
3878 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
3879
3880 if(pu32XCInst == NULL)
3881 {
3882 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3883 }
3884 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_4KX2K_VIC_CODE, (void*)&XCArgs) != 0)
3885 {
3886 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3887 }
3888
3889 return XCArgs.eReturnValue;
3890 }
3891
3892 // HDMI ARC pin control
3893 // - enInputPortType: INPUT_PORT_DVI0 / INPUT_PORT_DVI1 / INPUT_PORT_DVI2 / INPUT_PORT_DVI3
3894 // - bEnable: ARC enable or disable
3895 // - bDrivingHigh: ARC driving current high or low, suggest driving current should be set to high when ARC is enable
MDrv_HDMI_ARC_PINControl_U2(void * pInstance,E_MUX_INPUTPORT enInputPortType,MS_BOOL bEnable,MS_BOOL bDrivingHigh)3896 void MDrv_HDMI_ARC_PINControl_U2(void* pInstance, E_MUX_INPUTPORT enInputPortType, MS_BOOL bEnable, MS_BOOL bDrivingHigh)
3897 {
3898 #if SUPPORT_HDMI_RX_NEW_FEATURE
3899 Hal_HDMI_ARC_PINControl(enInputPortType, bEnable, bDrivingHigh);
3900 #else
3901 // Do nothing
3902 #endif
3903 }
3904
MDrv_HDMI_ARC_PINControl(E_MUX_INPUTPORT enInputPortType,MS_BOOL bEnable,MS_BOOL bDrivingHigh)3905 void MDrv_HDMI_ARC_PINControl(E_MUX_INPUTPORT enInputPortType, MS_BOOL bEnable, MS_BOOL bDrivingHigh)
3906 {
3907 if (pu32XCInst == NULL)
3908 {
3909 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3910 return;
3911 }
3912
3913 stHDMI_ARC_PINCONTROL XCArgs;
3914 XCArgs.enInputPortType = enInputPortType;
3915 XCArgs.bEnable = bEnable;
3916 XCArgs.bDrivingHigh = bDrivingHigh;
3917
3918 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_ARC_PINCONTROL, (void*)&XCArgs) != 0)
3919 {
3920 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3921 return;
3922 }
3923 else
3924 {
3925 return;
3926 }
3927 }
3928
3929 //[6]: soft-reset hdmi
3930 //[5]: soft-reset hdcp
3931 //[4]: soft-reset dvi
MDrv_DVI_Software_Reset_U2(void * pInstance,E_MUX_INPUTPORT enInputPortType,MS_U16 u16Reset)3932 void MDrv_DVI_Software_Reset_U2(void* pInstance, E_MUX_INPUTPORT enInputPortType, MS_U16 u16Reset)
3933 {
3934 #if SUPPORT_HDMI_RX_NEW_FEATURE
3935 Hal_DVI_Software_Reset(enInputPortType, u16Reset);
3936 #else
3937 // Do nothing
3938 #endif
3939 }
3940
MDrv_DVI_Software_Reset(E_MUX_INPUTPORT enInputPortType,MS_U16 u16Reset)3941 void MDrv_DVI_Software_Reset(E_MUX_INPUTPORT enInputPortType, MS_U16 u16Reset)
3942 {
3943 if (pu32XCInst == NULL)
3944 {
3945 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
3946 return;
3947 }
3948
3949 stDVI_SOFTWARE_RESET XCArgs;
3950 XCArgs.enInputPortType= enInputPortType;
3951 XCArgs.u16Reset = u16Reset;
3952
3953 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_DVI_SOFTWARE_RESET, (void*)&XCArgs) != 0)
3954 {
3955 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
3956 return;
3957 }
3958 else
3959 {
3960 return;
3961 }
3962
3963 }
3964
MDrv_HDMI_SetPowerState_U2(void * pInstance,EN_POWER_MODE enPowerState)3965 MS_U32 MDrv_HDMI_SetPowerState_U2(void* pInstance, EN_POWER_MODE enPowerState)
3966 {
3967 MS_U16 u32Return = UTOPIA_STATUS_FAIL;
3968 //MS_CEC_INIT_INFO stCECInfo;
3969 XC_DDCRAM_PROG_INFO stDDCRamInfo;
3970 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
3971 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
3972 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
3973
3974 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
3975 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
3976 if (enPowerState == E_POWER_SUSPEND)
3977 {
3978 pXCResourcePrivate->stdrv_HDMI._prev_enPowerState = enPowerState;
3979 u32Return = UTOPIA_STATUS_SUCCESS;//SUSPEND_OK;
3980 }
3981 else if (enPowerState == E_POWER_RESUME)
3982 {
3983
3984 if (pXCResourcePrivate->stdrv_HDMI._prev_enPowerState == E_POWER_SUSPEND)
3985 {
3986 // EDID and DDC Ram
3987 {
3988
3989 // init Digital EDID 0
3990 stDDCRamInfo.EDID = pXCResourcePrivate->stdrvXC_MVideo_Context.g_u8EDID_DVIBackUp[E_XC_PROG_DVI0_EDID];
3991 stDDCRamInfo.u16EDIDSize = EDID_KEY_LENGTH;
3992 stDDCRamInfo.eDDCProgType = E_XC_PROG_DVI0_EDID;
3993 stDDCRamInfo.u16CECPhyAddr = 0x10; //0x5555;
3994 stDDCRamInfo.u8CECPhyAddrIdxL = 0xA1; // the CEC physical address start from 0xA1 byte in EDID
3995 stDDCRamInfo.u8CECPhyAddrIdxH = 0xA0;
3996
3997 MDrv_HDMI_PROG_DDCRAM_internal(pInstance, &stDDCRamInfo, sizeof(stDDCRamInfo));
3998
3999
4000 // init Digital EDID 1
4001 stDDCRamInfo.EDID = pXCResourcePrivate->stdrvXC_MVideo_Context.g_u8EDID_DVIBackUp[E_XC_PROG_DVI1_EDID];
4002 stDDCRamInfo.u16EDIDSize = EDID_KEY_LENGTH;
4003 stDDCRamInfo.eDDCProgType = E_XC_PROG_DVI1_EDID;
4004 stDDCRamInfo.u16CECPhyAddr = 0x20; //0x3131;
4005 stDDCRamInfo.u8CECPhyAddrIdxL = 0xA1; // the CEC physical address start from 0xA1 byte in EDID
4006 stDDCRamInfo.u8CECPhyAddrIdxH = 0xA0;
4007
4008 MDrv_HDMI_PROG_DDCRAM_internal(pInstance, &stDDCRamInfo, sizeof(stDDCRamInfo));
4009
4010 // init Digital EDID 2
4011 stDDCRamInfo.EDID = pXCResourcePrivate->stdrvXC_MVideo_Context.g_u8EDID_DVIBackUp[E_XC_PROG_DVI2_EDID];
4012 stDDCRamInfo.u16EDIDSize = EDID_KEY_LENGTH;
4013 stDDCRamInfo.eDDCProgType = E_XC_PROG_DVI2_EDID;
4014 stDDCRamInfo.u16CECPhyAddr = 0x30; //9292;
4015 stDDCRamInfo.u8CECPhyAddrIdxL = 0xA1; // the CEC physical address start from 0xA1 byte in EDID
4016 stDDCRamInfo.u8CECPhyAddrIdxH = 0xA0;
4017
4018 MDrv_HDMI_PROG_DDCRAM_internal(pInstance, &stDDCRamInfo, sizeof(stDDCRamInfo));
4019
4020 // init Digital EDID 3
4021 stDDCRamInfo.EDID = pXCResourcePrivate->stdrvXC_MVideo_Context.g_u8EDID_DVIBackUp[E_XC_PROG_DVI3_EDID];
4022 stDDCRamInfo.u16EDIDSize = EDID_KEY_LENGTH;
4023 stDDCRamInfo.eDDCProgType = E_XC_PROG_DVI3_EDID;
4024 stDDCRamInfo.u16CECPhyAddr = 0x40; //0x9292;
4025 stDDCRamInfo.u8CECPhyAddrIdxL = 0x9D; // the CEC physical address start from 0xA1 byte in EDID
4026 stDDCRamInfo.u8CECPhyAddrIdxH = 0x9C;
4027
4028
4029 MDrv_HDMI_PROG_DDCRAM_internal(pInstance, &stDDCRamInfo, sizeof(stDDCRamInfo));
4030 }
4031
4032 E_MUX_INPUTPORT eHDMIPort;
4033 //clear all HPD
4034 for (eHDMIPort = INPUT_PORT_DVI0;eHDMIPort <= INPUT_PORT_DVI3;eHDMIPort++)
4035 {
4036 MDrv_HDMI_pullhpd_internal(pInstance, DISABLE, eHDMIPort, pXCResourcePrivate->stdrvXC_MVideo_Context.g_bHDMIInverseBackUp[eHDMIPort - INPUT_PORT_DVI0]);
4037 Hal_DVI_ClkPullLow(TRUE, eHDMIPort);
4038 }
4039
4040 // HDMI initial
4041 MDrv_HDMI_init_internal(pInstance);
4042
4043 // init HDCP key again.
4044 if(pXCResourcePrivate->stdrv_HDMI.bHDCP14RxREEFlag)
4045 {
4046 MDrv_HDCP_initproductionkey_internal(pInstance, pXCResourcePrivate->stdrvXC_MVideo_Context.g_u8HdcpKeyDataBackUp);
4047 }
4048
4049 // Delay 100ms
4050 MsOS_DelayTask(100);
4051
4052 //set all HPD
4053 for (eHDMIPort = INPUT_PORT_DVI0;eHDMIPort <= INPUT_PORT_DVI3;eHDMIPort++)
4054 {
4055 Hal_DVI_ClkPullLow(FALSE, eHDMIPort);
4056 MDrv_HDMI_pullhpd_internal(pInstance, ENABLE, eHDMIPort, pXCResourcePrivate->stdrvXC_MVideo_Context.g_bHDMIInverseBackUp[eHDMIPort - INPUT_PORT_DVI0]);
4057 }
4058
4059 #if 0
4060 // CEC
4061 stCECInfo.u32XTAL_CLK_Hz = MST_XTAL_CLOCK_HZ;
4062 MApi_CEC_Init(&stCECInfo);
4063 #endif
4064 pXCResourcePrivate->stdrv_HDMI._prev_enPowerState = enPowerState;
4065 u32Return = UTOPIA_STATUS_SUCCESS;//RESUME_OK;
4066 }
4067 else
4068 {
4069 MDRV_HDMIRX_MSG_INFO("[%s,%5d]It is not suspended yet. We shouldn't resume\n",__func__,__LINE__);
4070 u32Return = UTOPIA_STATUS_FAIL;//SUSPEND_FAILED;
4071 }
4072 }
4073 else
4074 {
4075 MDRV_HDMIRX_MSG_INFO("[%s,%5d]Do Nothing: %d\n",__func__,__LINE__,enPowerState);
4076 u32Return = UTOPIA_STATUS_NOT_SUPPORTED;
4077 }
4078 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
4079 return u32Return;// for success
4080 }
4081
MDrv_HDMI_SetPowerState(EN_POWER_MODE enPowerState)4082 MS_U32 MDrv_HDMI_SetPowerState(EN_POWER_MODE enPowerState)
4083 {
4084 stHDMI_SET_POWERSTATE XCArgs;
4085 stHDMI_INITIAL_SETTING stHDMIRxArgs;
4086
4087 XCArgs.enPowerState = enPowerState;
4088 XCArgs.u32ReturnValue = UTOPIA_STATUS_FAIL;
4089 stHDMIRxArgs.stInitialTable.bImmeswitchSupport = FALSE;
4090 stHDMIRxArgs.stInitialTable.ucMHLSupportPath = 0;
4091
4092 if(pu32XCInst == NULL)
4093 {
4094 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4095 }
4096 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_SET_POWERSTATE, (void*)&XCArgs) != 0)
4097 {
4098 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
4099 }
4100 else
4101 {
4102 if(pulHDMIRxInst == NULL)
4103 {
4104 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4105 }
4106 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_INITIAL, (void*)&stHDMIRxArgs) != 0)
4107 {
4108 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4109 }
4110 }
4111
4112 return XCArgs.u32ReturnValue;
4113 }
4114
MDrv_HDMI_CheckHDMI20_Setting_U2(void * pInstance,E_MUX_INPUTPORT enInputPortType)4115 MS_BOOL MDrv_HDMI_CheckHDMI20_Setting_U2(void* pInstance, E_MUX_INPUTPORT enInputPortType)
4116 {
4117 #if SUPPORT_HDMI20
4118 return Hal_HDMI_CheckHDMI20_Setting(enInputPortType);
4119 #else
4120 return FALSE;
4121 #endif
4122 }
4123
MDrv_HDMI_CheckHDMI20_Setting(E_MUX_INPUTPORT enInputPortType)4124 MS_BOOL MDrv_HDMI_CheckHDMI20_Setting(E_MUX_INPUTPORT enInputPortType)
4125 {
4126 if (pu32XCInst == NULL)
4127 {
4128 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4129 return FALSE;
4130 }
4131
4132 stHDMI_CHECK_HDMI20_SETTING XCArgs;
4133 XCArgs.enInputPortType = enInputPortType;
4134 XCArgs.bReturnValue = FALSE;
4135
4136 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_CHECK_HDMI20_SETTING, (void*)&XCArgs) != 0)
4137 {
4138 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
4139 return FALSE;
4140 }
4141 else
4142 {
4143 return XCArgs.bReturnValue;
4144 }
4145 }
4146
MDrv_HDMI_StablePolling(void)4147 void MDrv_HDMI_StablePolling(void)
4148 {
4149 if(pulHDMIRxInst == NULL)
4150 {
4151 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4152 }
4153 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_STABLE_POLLING, NULL) != 0)
4154 {
4155 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4156 }
4157 }
4158
MDrv_HDMI_GetSourceVersion(E_MUX_INPUTPORT enInputPortType)4159 MS_U8 MDrv_HDMI_GetSourceVersion(E_MUX_INPUTPORT enInputPortType)
4160 {
4161 stHDMI_GET_SOURCE_VERSION XCArgs = {0};
4162
4163 XCArgs.enInputPortType = enInputPortType;
4164 XCArgs.ucSourceVersion = HDMI_SOURCE_VERSION_NOT_SURE;
4165
4166 if(pulHDMIRxInst == NULL)
4167 {
4168 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4169 }
4170 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_GET_SOURCE_VERSION, (void*)&XCArgs) != 0)
4171 {
4172 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4173 }
4174
4175 return XCArgs.ucSourceVersion;
4176 }
4177
MDrv_HDMI_Set5VDetectGPIOSelect_U2(void * pInstance,MS_U32 ul5VDetectGPIOIndex)4178 void MDrv_HDMI_Set5VDetectGPIOSelect_U2(void* pInstance, MS_U32 ul5VDetectGPIOIndex)
4179 {
4180 Hal_HDMI_Set5VDetectGPIOSelect(ul5VDetectGPIOIndex);
4181 }
4182
MDrv_HDMI_Set5VDetectGPIOSelect(MS_U32 ul5VDetectGPIOIndex)4183 void SYMBOL_WEAK MDrv_HDMI_Set5VDetectGPIOSelect(MS_U32 ul5VDetectGPIOIndex)
4184 {
4185 if (pu32XCInst == NULL)
4186 {
4187 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4188 return;
4189 }
4190
4191 stHDMI_SET_5V_DETECT_GPIO_SELECT XCArgs;
4192 XCArgs.ul5VDetectGPIOSelect = ul5VDetectGPIOIndex;
4193
4194 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_SET_5V_DETECT_GPIO_SELECT, (void*)&XCArgs) != 0)
4195 {
4196 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
4197 return;
4198 }
4199 else
4200 {
4201 return;
4202 }
4203 }
4204
MDrv_HDMI_GetDEStableStatus_U2(void * pInstance,E_MUX_INPUTPORT enInputPortType)4205 MS_BOOL MDrv_HDMI_GetDEStableStatus_U2(void* pInstance, E_MUX_INPUTPORT enInputPortType)
4206 {
4207 return Hal_DVI_GetDEStableStatus(enInputPortType);
4208 }
4209
MDrv_HDMI_GetDEStableStatus(E_MUX_INPUTPORT enInputPortType)4210 MS_BOOL SYMBOL_WEAK MDrv_HDMI_GetDEStableStatus(E_MUX_INPUTPORT enInputPortType)
4211 {
4212 if (pu32XCInst == NULL)
4213 {
4214 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4215 return FALSE;
4216 }
4217
4218 stHDMI_GET_DE_STABLE_STATUS XCArgs;
4219 XCArgs.enInputPortType = enInputPortType;
4220 XCArgs.bStatus= FALSE;
4221
4222 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_DE_STABLE_STATUS, (void*)&XCArgs) != 0)
4223 {
4224 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
4225 return FALSE;
4226 }
4227 else
4228 {
4229 return XCArgs.bStatus;
4230 }
4231 }
4232
MDrv_HDMI_CheckHDCP14(void)4233 MS_BOOL SYMBOL_WEAK MDrv_HDMI_CheckHDCP14(void)
4234 {
4235 stHDMI_GET_HDCP14_KEY_VAILD XCArgs = {0};
4236
4237 XCArgs.bHDCP14KeyVaildFlag = FALSE;
4238
4239 if(pulHDMIRxInst == NULL)
4240 {
4241 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4242 }
4243 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_GET_HDCP14_KEY_VAILD, (void*)&XCArgs) != 0)
4244 {
4245 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4246 }
4247
4248 return XCArgs.bHDCP14KeyVaildFlag;
4249 }
4250
MDrv_HDMI_CheckHDCPState(E_MUX_INPUTPORT enInputPortType)4251 E_HDMI_HDCP_STATE MDrv_HDMI_CheckHDCPState(E_MUX_INPUTPORT enInputPortType)
4252 {
4253 stHDMI_CHECK_HDCP_STATE XCArgs = {0};
4254
4255 XCArgs.enInputPortType = enInputPortType;
4256 XCArgs.ucHDCPState = E_HDCP_NO_ENCRYPTION;
4257
4258 if(pulHDMIRxInst == NULL)
4259 {
4260 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4261 }
4262 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_CHECK_HDCP_STATE, (void*)&XCArgs) != 0)
4263 {
4264 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4265 }
4266
4267 return (E_HDMI_HDCP_STATE)XCArgs.ucHDCPState;
4268 }
4269
MDrv_HDMI_CheckHDCPENCState(E_MUX_INPUTPORT enInputPortType)4270 E_HDMI_HDCP_ENCRYPTION_STATE MDrv_HDMI_CheckHDCPENCState(E_MUX_INPUTPORT enInputPortType)
4271 {
4272 stHDMI_CHECK_HDCP_ENC_STATE XCArgs = {0};
4273
4274 XCArgs.enInputPortType = enInputPortType;
4275 XCArgs.ucHDCPENCState = E_HDCP_NOT_ENCRYPTION;
4276
4277 if(pulHDMIRxInst == NULL)
4278 {
4279 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4280 }
4281 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_CHECK_HDCP_ENC_STATE, (void*)&XCArgs) != 0)
4282 {
4283 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4284 }
4285
4286 return (E_HDMI_HDCP_ENCRYPTION_STATE)XCArgs.ucHDCPENCState;
4287 }
4288
MDrv_HDMI_SwitchVSDBtoHDRPacket(MS_BOOL bEnableHDR)4289 MS_BOOL MDrv_HDMI_SwitchVSDBtoHDRPacket(MS_BOOL bEnableHDR)
4290 {
4291 Hal_HDMI_SwitchVSDBtoHDRPacket(bEnableHDR);
4292 return TRUE;
4293 }
4294
MDrv_HDMI_ParseHDRInfoFrame(void * pInstance,MS_U8 ucHDMIInfoSource,void * pPacket,sHDR_METADATA * pHdrMetadata)4295 MS_BOOL MDrv_HDMI_ParseHDRInfoFrame(void* pInstance, MS_U8 ucHDMIInfoSource, void *pPacket, sHDR_METADATA *pHdrMetadata)
4296 {
4297 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4298 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4299 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
4300
4301 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4302 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4303
4304 MS_BOOL bRet = FALSE;
4305
4306 if(pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_HDR_PACKET_RECEIVE_FLAG)
4307 {
4308 if (pHdrMetadata->u16Version == HDMI_HDR_METADATA_VERSION)
4309 {
4310 // HDR metadata structure version is the same.
4311 MS_U16 *pInfoFrame = (MS_U16*)pPacket;
4312 pHdrMetadata->u8EOTF = ((pInfoFrame[0]>>8)&0x07); // 8~15bits, 0:SDR gamma, 1:HDR gamma, 2:SMPTE ST2084, 3:Future EOTF, 4-7:Reserved
4313 pHdrMetadata->u8Static_Metadata_ID = (pInfoFrame[1]&0x0007); // 0:Static Metadata Type 1, 1-7:Reserved for future use
4314 pHdrMetadata->u16Display_Primaries_X[0] = (pInfoFrame[2]<<8) + (pInfoFrame[1]>>8);
4315
4316 pHdrMetadata->u16Display_Primaries_Y[0] = (pInfoFrame[3]<<8) + (pInfoFrame[2]>>8);
4317 pHdrMetadata->u16Display_Primaries_X[1] = (pInfoFrame[4]<<8) + (pInfoFrame[3]>>8);
4318 pHdrMetadata->u16Display_Primaries_Y[1] = (pInfoFrame[5]<<8) + (pInfoFrame[4]>>8);
4319 pHdrMetadata->u16Display_Primaries_X[2] = (pInfoFrame[6]<<8) + (pInfoFrame[5]>>8);
4320 pHdrMetadata->u16Display_Primaries_Y[2] = (pInfoFrame[7]<<8) + (pInfoFrame[6]>>8);
4321 pHdrMetadata->u16White_Point_X = (pInfoFrame[8]<<8) + (pInfoFrame[7]>>8);
4322 pHdrMetadata->u16White_Point_Y = (pInfoFrame[9]<<8) + (pInfoFrame[8]>>8);
4323 pHdrMetadata->u16Max_Display_Mastering_Luminance = (pInfoFrame[10]<<8) + (pInfoFrame[9]>>8);
4324 pHdrMetadata->u16Min_Display_Mastering_Luminance = (pInfoFrame[11]<<8) + (pInfoFrame[10]>>8);
4325 pHdrMetadata->u16Maximum_Content_Light_Level = (pInfoFrame[12]<<8) + (pInfoFrame[11]>>8);
4326 pHdrMetadata->u16Maximum_Frame_Average_Light_Level = (pInfoFrame[13]<<8) + (pInfoFrame[12]>>8);
4327 }
4328 else
4329 {
4330 // Error handle.
4331 if (pHdrMetadata->u16Size <= HDMI_HDR_METADATA_VERSION_1_SIZE)
4332 {
4333 MS_U16 *pInfoFrame = (MS_U16*)pPacket;
4334 pHdrMetadata->u8EOTF = ((pInfoFrame[0]>>8)&0x07); // 8~15bits, 0:SDR gamma, 1:HDR gamma, 2:SMPTE ST2084, 3:Future EOTF, 4-7:Reserved
4335 pHdrMetadata->u8Static_Metadata_ID = (pInfoFrame[1]&0x0007); // 0:Static Metadata Type 1, 1-7:Reserved for future use
4336 pHdrMetadata->u16Display_Primaries_X[0] = (pInfoFrame[2]<<8) + (pInfoFrame[1]>>8);
4337
4338 pHdrMetadata->u16Display_Primaries_Y[0] = (pInfoFrame[3]<<8) + (pInfoFrame[2]>>8);
4339 pHdrMetadata->u16Display_Primaries_X[1] = (pInfoFrame[4]<<8) + (pInfoFrame[3]>>8);
4340 pHdrMetadata->u16Display_Primaries_Y[1] = (pInfoFrame[5]<<8) + (pInfoFrame[4]>>8);
4341 pHdrMetadata->u16Display_Primaries_X[2] = (pInfoFrame[6]<<8) + (pInfoFrame[5]>>8);
4342 pHdrMetadata->u16Display_Primaries_Y[2] = (pInfoFrame[7]<<8) + (pInfoFrame[6]>>8);
4343 pHdrMetadata->u16White_Point_X = (pInfoFrame[8]<<8) + (pInfoFrame[7]>>8);
4344 pHdrMetadata->u16White_Point_Y = (pInfoFrame[9]<<8) + (pInfoFrame[8]>>8);
4345 pHdrMetadata->u16Max_Display_Mastering_Luminance = (pInfoFrame[10]<<8) + (pInfoFrame[9]>>8);
4346 pHdrMetadata->u16Min_Display_Mastering_Luminance = (pInfoFrame[11]<<8) + (pInfoFrame[10]>>8);
4347 pHdrMetadata->u16Maximum_Content_Light_Level = (pInfoFrame[12]<<8) + (pInfoFrame[11]>>8);
4348 pHdrMetadata->u16Maximum_Frame_Average_Light_Level = (pInfoFrame[13]<<8) + (pInfoFrame[12]>>8);
4349 }
4350 }
4351
4352 //MDRV_HDMIRX_MSG_DEBUG("HDMI HDR metadata is :\n");
4353 //MDRV_HDMIRX_MSG_DEBUG("u8EOTF is 0x%x.\033[m\n", pHdrMetadata->u8EOTF);
4354 //MDRV_HDMIRX_MSG_DEBUG("u8Static_Metadata_ID is 0x%x.\n", pHdrMetadata->u8Static_Metadata_ID);
4355 //MDRV_HDMIRX_MSG_DEBUG("u16Display_Primaries_X[0] is 0x%x.\n", pHdrMetadata->u16Display_Primaries_X[0]);
4356 //MDRV_HDMIRX_MSG_DEBUG("u16Display_Primaries_Y[0] is 0x%x.\n", pHdrMetadata->u16Display_Primaries_Y[0]);
4357 //MDRV_HDMIRX_MSG_DEBUG("u16Display_Primaries_X[1] is 0x%x.\n", pHdrMetadata->u16Display_Primaries_X[1]);
4358 //MDRV_HDMIRX_MSG_DEBUG("u16Display_Primaries_Y[1] is 0x%x.\n", pHdrMetadata->u16Display_Primaries_Y[1]);
4359 //MDRV_HDMIRX_MSG_DEBUG("u16Display_Primaries_X[2] is 0x%x.\n", pHdrMetadata->u16Display_Primaries_X[2]);
4360 //MDRV_HDMIRX_MSG_DEBUG("u16Display_Primaries_Y[2] is 0x%x.\n", pHdrMetadata->u16Display_Primaries_Y[2]);
4361 //MDRV_HDMIRX_MSG_DEBUG("u16White_Point_X is 0x%x.\n", pHdrMetadata->u16White_Point_X);
4362 //MDRV_HDMIRX_MSG_DEBUG("u16White_Point_Y is 0x%x.\n", pHdrMetadata->u16White_Point_Y);
4363 //MDRV_HDMIRX_MSG_DEBUG("u16Max_Display_Mastering_Luminance is 0x%x.\n", pHdrMetadata->u16Max_Display_Mastering_Luminance);
4364 //MDRV_HDMIRX_MSG_DEBUG("u16Min_Display_Mastering_Luminance is 0x%x.\n", pHdrMetadata->u16Min_Display_Mastering_Luminance);
4365 //MDRV_HDMIRX_MSG_DEBUG("u16Maximum_Content_Light_Level is 0x%x.\n", pHdrMetadata->u16Maximum_Content_Light_Level);
4366 //MDRV_HDMIRX_MSG_DEBUG("u16Maximum_Frame_Average_Light_Level is 0x%x.\n", pHdrMetadata->u16Maximum_Frame_Average_Light_Level);
4367
4368 bRet = TRUE;
4369 }
4370
4371 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
4372
4373 return bRet;
4374 }
4375
MDrv_HDMI_Extend_Packet_Received(void * pInstance,MS_U8 ucHDMIInfoSource,MS_BOOL bEnable,MS_HDMI_EXTEND_PACKET_RECEIVE_t * pExtendPacketReceive)4376 MS_BOOL MDrv_HDMI_Extend_Packet_Received(void* pInstance, MS_U8 ucHDMIInfoSource, MS_BOOL bEnable, MS_HDMI_EXTEND_PACKET_RECEIVE_t *pExtendPacketReceive)
4377 {
4378 MS_BOOL bReturn = FALSE;
4379 MS_U16 u16CopiedLength = sizeof(MS_HDMI_EXTEND_PACKET_RECEIVE_t);
4380 MS_HDMI_EXTEND_PACKET_RECEIVE_t stExtendPacketReceive = {0};
4381 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
4382 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
4383
4384 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
4385 _XC_SEMAPHORE_ENTRY(pInstance,E_XC_ID_VAR);
4386
4387 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
4388
4389 if((NULL == pExtendPacketReceive) || (pExtendPacketReceive->u16Size == 0))
4390 {
4391 printf("MDrv_HDMI_Extend_Packet_Received: Null parameter or Wrong u16Size\n");
4392 return bReturn;
4393 }
4394
4395 if(pExtendPacketReceive->u16Version < 1)
4396 {
4397 printf("MDrv_HDMI_Extend_Packet_Received: please check your u16Version, it should not set to 0\n");
4398 return bReturn;
4399 }
4400
4401 if (pExtendPacketReceive->u16Version > HDMI_EXTEND_PACKET_RECEIVE_VERSION)
4402 {
4403 #if defined (__aarch64__)
4404 printf("MDrv_HDMI_Extend_Packet_Received: this old version xc lib has only length:%lu driver status!!\n",sizeof(MS_HDMI_EXTEND_PACKET_RECEIVE_t));
4405 #else
4406 printf("MDrv_HDMI_Extend_Packet_Received: this old version xc lib has only length:%u driver status!!\n",sizeof(MS_HDMI_EXTEND_PACKET_RECEIVE_t));
4407 #endif
4408 u16CopiedLength = sizeof(MS_HDMI_EXTEND_PACKET_RECEIVE_t);
4409 }
4410
4411 if ((pExtendPacketReceive->u16Version < HDMI_EXTEND_PACKET_RECEIVE_VERSION) || (pExtendPacketReceive->u16Size < sizeof(MS_HDMI_EXTEND_PACKET_RECEIVE_t)))
4412 {
4413 printf("MDrv_HDMI_Extend_Packet_Received: new version xc lib shouldn't access to the space which doesn't exist in old structure!!\n");
4414 u16CopiedLength = pExtendPacketReceive->u16Size;
4415 }
4416
4417 stExtendPacketReceive.bPKT_MPEG_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_MPEG_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4418 stExtendPacketReceive.bPKT_AUI_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_AUDIO_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4419 stExtendPacketReceive.bPKT_SPD_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_SPD_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4420 stExtendPacketReceive.bPKT_AVI_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_AVI_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4421 stExtendPacketReceive.bPKT_GC_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_GCP_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4422 stExtendPacketReceive.bPKT_ASAMPLE_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_AUDIO_SAMPLE_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4423 stExtendPacketReceive.bPKT_ACR_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_ACR_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4424 stExtendPacketReceive.bPKT_VS_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_VS_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4425 stExtendPacketReceive.bPKT_NULL_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_NULL_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4426 stExtendPacketReceive.bPKT_ISRC2_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_ISRC2_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4427 stExtendPacketReceive.bPKT_ISRC1_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_ISRC1_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4428 stExtendPacketReceive.bPKT_ACP_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_ACP_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4429 stExtendPacketReceive.bPKT_ONEBIT_AUD_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_DSD_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4430 stExtendPacketReceive.bPKT_GM_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_GM_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4431 stExtendPacketReceive.bPKT_HBR_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_HBR_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4432 stExtendPacketReceive.bPKT_VBI_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_VBI_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4433 stExtendPacketReceive.bPKT_HDR_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_HDR_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4434 stExtendPacketReceive.bPKT_RSV_RECEIVE = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_RESERVED_PACKET_RECEIVE_FLAG)? TRUE: FALSE;
4435 stExtendPacketReceive.bPKT_EDR_VALID = (pXCResourcePrivate->stdrv_HDMI.ulPacketStatus[ucHDMIInfoSource] &HDMI_STATUS_EDR_VALID_FLAG)? TRUE: FALSE;
4436
4437 memcpy(pExtendPacketReceive, &stExtendPacketReceive, u16CopiedLength);
4438
4439 _XC_SEMAPHORE_RETURN(pInstance,E_XC_ID_VAR);
4440
4441 return TRUE;
4442 }
4443
MDrv_HDMI_Ctrl_U2(void * pInstance,MS_U8 ucHDMIInfoSource,MS_U32 u32Cmd,void * pBuf,MS_U32 u32BufSize)4444 MS_BOOL MDrv_HDMI_Ctrl_U2(void* pInstance, MS_U8 ucHDMIInfoSource, MS_U32 u32Cmd, void *pBuf, MS_U32 u32BufSize)
4445 {
4446 MS_BOOL bRet = FALSE;
4447
4448 switch(u32Cmd)
4449 {
4450 case E_HDMI_SWITCH_VSDB_TO_HDR_PACKET:
4451 if (u32BufSize == sizeof(MS_HDMI_Switch_VSDB_to_HDR_Parameters))
4452 {
4453 MS_HDMI_Switch_VSDB_to_HDR_Parameters *pParameters = (MS_HDMI_Switch_VSDB_to_HDR_Parameters*)pBuf;
4454 bRet = MDrv_HDMI_SwitchVSDBtoHDRPacket(pParameters->bEnableHDR);
4455 }
4456 break;
4457
4458 case E_HDMI_HDR_INFOFRAME_GET:
4459 if (u32BufSize == sizeof(MS_HDMI_HDR_InfoFrame_Get_Parameters))
4460 {
4461 MS_HDMI_HDR_InfoFrame_Get_Parameters *pParameters = (MS_HDMI_HDR_InfoFrame_Get_Parameters*)pBuf;
4462 MS_U16 HdrPacket[HDMI_HDR_PACKET_SIZE];
4463 Hal_HDMI_Get_InfoFrame(ucHDMIInfoSource, PKT_HDR, HdrPacket);
4464 bRet = MDrv_HDMI_ParseHDRInfoFrame(pInstance, ucHDMIInfoSource, HdrPacket, pParameters->pstHDRMetadata);
4465 }
4466 break;
4467
4468 case E_HDMI_EXTEND_PACKET_RECEIVE_GET:
4469 if (u32BufSize == sizeof(MS_HDMI_Extend_Packet_Receive_Get_Parameters))
4470 {
4471 MS_HDMI_Extend_Packet_Receive_Get_Parameters *pParameters = (MS_HDMI_Extend_Packet_Receive_Get_Parameters*)pBuf;
4472 bRet = MDrv_HDMI_Extend_Packet_Received(pInstance, ucHDMIInfoSource, pParameters->bEnable, pParameters->pstPacketReceive);
4473 }
4474 break;
4475
4476 default:
4477 break;
4478 }
4479
4480 return bRet;
4481 }
4482
MDrv_HDMI_Ctrl(MS_U32 u32Cmd,void * pBuf,MS_U32 u32BufSize)4483 MS_BOOL MDrv_HDMI_Ctrl(MS_U32 u32Cmd, void *pBuf, MS_U32 u32BufSize)
4484 {
4485 MS_BOOL bRetValue = FALSE;
4486
4487 if(u32Cmd < 0x500) // XC resource
4488 {
4489 stHDMI_CONTROL XCArgs;
4490
4491 XCArgs.u32Cmd = u32Cmd;
4492 XCArgs.pBuf = pBuf;
4493 XCArgs.u32BufSize = u32BufSize;
4494 XCArgs.bRet = FALSE;
4495 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
4496
4497 if(pu32XCInst == NULL)
4498 {
4499 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4500 }
4501 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_CTRL, (void*)&XCArgs) != 0)
4502 {
4503 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
4504 }
4505
4506 bRetValue = XCArgs.bRet;
4507 }
4508 else // HDMIRX resource
4509 {
4510 bRetValue = MDrv_HDMI_IOCTL(u32Cmd, pBuf, u32BufSize);
4511 }
4512
4513 return bRetValue;
4514 }
4515
4516 //**************************************************************************
4517 // [Function Name]:
4518 // MDrv_HDMI_GetDataInfo_U2
4519 // [Description]:
4520 //
4521 // [Arguments]:
4522 //
4523 // [Return]:
4524 //
4525 //**************************************************************************
MDrv_HDMI_GetDataInfo_U2(void * pInstance,E_HDMI_GET_DATA_INFO enInfo,MS_U8 ucHDMIInfoSource)4526 MS_U16 MDrv_HDMI_GetDataInfo_U2(void* pInstance, E_HDMI_GET_DATA_INFO enInfo, MS_U8 ucHDMIInfoSource)
4527 {
4528 MS_U16 usVideoInfo = 0;
4529
4530 usVideoInfo = Hal_HDMI_GetDataInfo(enInfo, ucHDMIInfoSource);
4531
4532 return usVideoInfo;
4533 }
4534
4535 //**************************************************************************
4536 // [Function Name]:
4537 // MDrv_HDMI_GetDataInfo
4538 // [Description]:
4539 //
4540 // [Arguments]:
4541 //
4542 // [Return]:
4543 //
4544 //**************************************************************************
MDrv_HDMI_GetDataInfo(E_HDMI_GET_DATA_INFO enInfo)4545 MS_U16 MDrv_HDMI_GetDataInfo(E_HDMI_GET_DATA_INFO enInfo)
4546 {
4547 stHDMI_GET_DATA_INFO XCArgs = {0};
4548
4549 XCArgs.usReturnValue = 0;
4550 XCArgs.enInfo = enInfo;
4551 XCArgs.ucHDMIInfoSource = ucHDMIInfoSourceSelect;
4552
4553 if(pu32XCInst == NULL)
4554 {
4555 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
4556 }
4557 else if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_DATA_INFO, (void*)&XCArgs) != 0)
4558 {
4559 MDRV_HDMIRX_MSG_ERROR("Obtain XC engine fail\n");
4560 }
4561
4562 return XCArgs.usReturnValue;
4563 }
4564
4565 //**************************************************************************
4566 // [Function Name]:
4567 // MDrv_HDCP_WriteX74
4568 // [Description]:
4569 //
4570 // [Arguments]:
4571 //
4572 // [Return]:
4573 //
4574 //**************************************************************************
MDrv_HDCP_WriteX74(E_MUX_INPUTPORT enInputPortType,MS_U8 ucOffset,MS_U8 ucData)4575 void MDrv_HDCP_WriteX74(E_MUX_INPUTPORT enInputPortType, MS_U8 ucOffset, MS_U8 ucData)
4576 {
4577 stHDCP_WRITE_X74 XCArgs = {0};
4578
4579 XCArgs.enInputPortType = enInputPortType;
4580 XCArgs.ucOffset = ucOffset;
4581 XCArgs.ucData = ucData;
4582
4583 if(pulHDMIRxInst == NULL)
4584 {
4585 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4586 }
4587 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_WRITE_X74, (void*)&XCArgs) != 0)
4588 {
4589 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4590 }
4591 }
4592
4593 //**************************************************************************
4594 // [Function Name]:
4595 // MDrv_HDCP_ReadX74
4596 // [Description]:
4597 //
4598 // [Arguments]:
4599 //
4600 // [Return]:
4601 //
4602 //**************************************************************************
MDrv_HDCP_ReadX74(E_MUX_INPUTPORT enInputPortType,MS_U8 ucOffset)4603 MS_U8 MDrv_HDCP_ReadX74(E_MUX_INPUTPORT enInputPortType, MS_U8 ucOffset)
4604 {
4605 stHDCP_READ_X74 XCArgs = {0};
4606
4607 XCArgs.enInputPortType = enInputPortType;
4608 XCArgs.ucOffset = ucOffset;
4609 XCArgs.ucRetData = 0;
4610
4611 if(pulHDMIRxInst == NULL)
4612 {
4613 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4614 }
4615 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_READ_X74, (void*)&XCArgs) != 0)
4616 {
4617 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4618 }
4619
4620 return XCArgs.ucRetData;
4621 }
4622
4623 //**************************************************************************
4624 // [Function Name]:
4625 // MDrv_HDCP_SetRepeater
4626 // [Description]:
4627 //
4628 // [Arguments]:
4629 //
4630 // [Return]:
4631 //
4632 //**************************************************************************
MDrv_HDCP_SetRepeater(E_MUX_INPUTPORT enInputPortType,MS_BOOL bIsRepeater)4633 void MDrv_HDCP_SetRepeater(E_MUX_INPUTPORT enInputPortType, MS_BOOL bIsRepeater)
4634 {
4635 stHDCP_SET_REPEATER XCArgs = {0};
4636
4637 XCArgs.enInputPortType = enInputPortType;
4638 XCArgs.bIsRepeater = bIsRepeater;
4639
4640 if(pulHDMIRxInst == NULL)
4641 {
4642 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4643 }
4644 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_SET_REPEATER, (void*)&XCArgs) != 0)
4645 {
4646 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4647 }
4648 }
4649
4650 //**************************************************************************
4651 // [Function Name]:
4652 // MDrv_HDCP_SetBstatus
4653 // [Description]:
4654 //
4655 // [Arguments]:
4656 //
4657 // [Return]:
4658 //
4659 //**************************************************************************
MDrv_HDCP_SetBstatus(E_MUX_INPUTPORT enInputPortType,MS_U16 usBstatus)4660 void MDrv_HDCP_SetBstatus(E_MUX_INPUTPORT enInputPortType, MS_U16 usBstatus)
4661 {
4662 stHDCP_SET_BSTATUS XCArgs = {0};
4663
4664 XCArgs.enInputPortType = enInputPortType;
4665 XCArgs.usBstatus = usBstatus;
4666
4667 if(pulHDMIRxInst == NULL)
4668 {
4669 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4670 }
4671 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_SET_BSTATUS, (void*)&XCArgs) != 0)
4672 {
4673 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4674 }
4675 }
4676
4677 //**************************************************************************
4678 // [Function Name]:
4679 // MDrv_HDCP_SetHDMIMode
4680 // [Description]:
4681 //
4682 // [Arguments]:
4683 //
4684 // [Return]:
4685 //
4686 //**************************************************************************
MDrv_HDCP_SetHDMIMode(E_MUX_INPUTPORT enInputPortType,MS_BOOL bHDMIMode)4687 void MDrv_HDCP_SetHDMIMode(E_MUX_INPUTPORT enInputPortType, MS_BOOL bHDMIMode)
4688 {
4689 stHDCP_SET_HDMI_MODE XCArgs = {0};
4690
4691 XCArgs.enInputPortType = enInputPortType;
4692 XCArgs.bHDMIMode = bHDMIMode;
4693
4694 if(pulHDMIRxInst == NULL)
4695 {
4696 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4697 }
4698 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_SET_HDMI_MODE, (void*)&XCArgs) != 0)
4699 {
4700 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4701 }
4702 }
4703
4704 //**************************************************************************
4705 // [Function Name]:
4706 // MDrv_HDCP_GetInterruptStatus
4707 // [Description]:
4708 //
4709 // [Arguments]:
4710 //
4711 // [Return]:
4712 //
4713 //**************************************************************************
MDrv_HDCP_GetInterruptStatus(E_MUX_INPUTPORT enInputPortType)4714 MS_U8 MDrv_HDCP_GetInterruptStatus(E_MUX_INPUTPORT enInputPortType)
4715 {
4716 stHDCP_GET_INTERRUPT_STATUS XCArgs = {0};
4717
4718 XCArgs.enInputPortType = enInputPortType;
4719 XCArgs.ucRetIntStatus = 0;
4720
4721 if(pulHDMIRxInst == NULL)
4722 {
4723 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4724 }
4725 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_GET_INTERRUPT_STATUS, (void*)&XCArgs) != 0)
4726 {
4727 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4728 }
4729
4730 return XCArgs.ucRetIntStatus;
4731 }
4732
4733 //**************************************************************************
4734 // [Function Name]:
4735 // MDrv_HDCP_WriteKSVList
4736 // [Description]:
4737 //
4738 // [Arguments]:
4739 //
4740 // [Return]:
4741 //
4742 //**************************************************************************
MDrv_HDCP_WriteKSVList(E_MUX_INPUTPORT enInputPortType,MS_U8 * pucKSV,MS_U32 ulDataLen)4743 void MDrv_HDCP_WriteKSVList(E_MUX_INPUTPORT enInputPortType, MS_U8* pucKSV, MS_U32 ulDataLen)
4744 {
4745 stHDCP_WRITE_KSV_LIST XCArgs = {0};
4746
4747 XCArgs.enInputPortType = enInputPortType;
4748 XCArgs.pucKSV = pucKSV;
4749 XCArgs.ulLen = ulDataLen;
4750
4751 if(pulHDMIRxInst == NULL)
4752 {
4753 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4754 }
4755 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_WRITE_KSV_LIST, (void*)&XCArgs) != 0)
4756 {
4757 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4758 }
4759 }
4760
4761 //**************************************************************************
4762 // [Function Name]:
4763 // MDrv_HDCP_SetVPrime
4764 // [Description]:
4765 //
4766 // [Arguments]:
4767 //
4768 // [Return]:
4769 //
4770 //**************************************************************************
MDrv_HDCP_SetVPrime(E_MUX_INPUTPORT enInputPortType,MS_U8 * pucVPrime)4771 void MDrv_HDCP_SetVPrime(E_MUX_INPUTPORT enInputPortType, MS_U8* pucVPrime)
4772 {
4773 stHDCP_SET_VPRIME XCArgs = {0};
4774
4775 XCArgs.enInputPortType = enInputPortType;
4776 XCArgs.pucVPrime = pucVPrime;
4777
4778 if(pulHDMIRxInst == NULL)
4779 {
4780 MDRV_HDMIRX_MSG_WARNING("[%s,%5d]No instance existed, please get an instance by calling MDrv_HDMI_init() first\n",__FUNCTION__,__LINE__);
4781 }
4782 else if(UtopiaIoctl(pulHDMIRxInst, MAPI_CMD_HDMIRX_SET_VPRIME, (void*)&XCArgs) != 0)
4783 {
4784 MDRV_HDMIRX_MSG_ERROR("Obtain HDMI Rx engine fail\n");
4785 }
4786 }
4787
4788 //**************************************************************************
4789 // [Function Name]:
4790 // MDrv_HDMI_IOCTL
4791 // [Description]:
4792 //
4793 // [Arguments]:
4794 //
4795 // [Return]:
4796 //
4797 //**************************************************************************
MDrv_HDMI_IOCTL(MS_U32 ulCommand,void * pBuffer,MS_U32 ulBufferSize)4798 MS_BOOL MDrv_HDMI_IOCTL(MS_U32 ulCommand, void *pBuffer, MS_U32 ulBufferSize)
4799 {
4800 MS_BOOL bret = FALSE;
4801
4802 switch(ulCommand)
4803 {
4804 case E_HDMI_INTERFACE_CMD_GET_HDCP_STATE:
4805 {
4806 if(ulBufferSize == sizeof(stCMD_HDMI_CHECK_HDCP_STATE))
4807 {
4808 ((stCMD_HDMI_CHECK_HDCP_STATE *)pBuffer)->ucHDCPState = (MS_U8)MDrv_HDMI_CheckHDCPState(((stCMD_HDMI_CHECK_HDCP_STATE *)pBuffer)->enInputPortType);
4809
4810 bret = TRUE;
4811 }
4812 else
4813 {
4814 ((stCMD_HDMI_CHECK_HDCP_STATE *)pBuffer)->ucHDCPState = HDMI_HDCP_NO_ENCRYPTION;
4815 }
4816 }
4817 break;
4818
4819 /*************************** HDCP Repeater ***************************/
4820 case E_HDMI_INTERFACE_CMD_WRITE_X74:
4821 {
4822 if(ulBufferSize == sizeof(stCMD_HDCP_WRITE_X74))
4823 {
4824 MDrv_HDCP_WriteX74(((stCMD_HDCP_WRITE_X74 *)pBuffer)->enInputPortType, ((stCMD_HDCP_WRITE_X74 *)pBuffer)->ucOffset, ((stCMD_HDCP_WRITE_X74 *)pBuffer)->ucData);
4825
4826 bret = TRUE;
4827 }
4828 }
4829 break;
4830
4831 case E_HDMI_INTERFACE_CMD_READ_X74:
4832 {
4833 if(ulBufferSize == sizeof(stCMD_HDCP_READ_X74))
4834 {
4835 ((stCMD_HDCP_READ_X74 *)pBuffer)->ucRetData = MDrv_HDCP_ReadX74(((stCMD_HDCP_READ_X74 *)pBuffer)->enInputPortType, ((stCMD_HDCP_READ_X74 *)pBuffer)->ucOffset);
4836
4837 bret = TRUE;
4838 }
4839 }
4840 break;
4841
4842 case E_HDMI_INTERFACE_CMD_SET_REPEATER:
4843 {
4844 if(ulBufferSize == sizeof(stCMD_HDCP_SET_REPEATER))
4845 {
4846 MDrv_HDCP_SetRepeater(((stCMD_HDCP_SET_REPEATER *)pBuffer)->enInputPortType, ((stCMD_HDCP_SET_REPEATER *)pBuffer)->bIsRepeater);
4847
4848 bret = TRUE;
4849 }
4850 }
4851 break;
4852
4853 case E_HDMI_INTERFACE_CMD_SET_BSTATUS:
4854 {
4855 if(ulBufferSize == sizeof(stCMD_HDCP_SET_BSTATUS))
4856 {
4857 MDrv_HDCP_SetBstatus(((stCMD_HDCP_SET_BSTATUS *)pBuffer)->enInputPortType, ((stCMD_HDCP_SET_BSTATUS *)pBuffer)->usBstatus);
4858
4859 bret = TRUE;
4860 }
4861 }
4862 break;
4863
4864 case E_HDMI_INTERFACE_CMD_SET_HDMI_MODE:
4865 {
4866 if(ulBufferSize == sizeof(stCMD_HDCP_SET_HDMI_MODE))
4867 {
4868 MDrv_HDCP_SetHDMIMode(((stCMD_HDCP_SET_HDMI_MODE *)pBuffer)->enInputPortType, ((stCMD_HDCP_SET_HDMI_MODE *)pBuffer)->bHDMIMode);
4869
4870 bret = TRUE;
4871 }
4872 }
4873 break;
4874
4875 case E_HDMI_INTERFACE_CMD_GET_INTERRUPT_STATUS:
4876 {
4877 if(ulBufferSize == sizeof(stCMD_HDCP_GET_INTERRUPT_STATUS))
4878 {
4879 ((stCMD_HDCP_GET_INTERRUPT_STATUS *)pBuffer)->ucRetIntStatus = MDrv_HDCP_GetInterruptStatus(((stCMD_HDCP_GET_INTERRUPT_STATUS *)pBuffer)->enInputPortType);
4880
4881 bret = TRUE;
4882 }
4883 }
4884 break;
4885
4886 case E_HDMI_INTERFACE_CMD_WRITE_KSV_LIST:
4887 {
4888 MS_U8 ucKSVBuffer[HDMI_HDCP_KSV_LIST_LENGTH] = {0};
4889 MS_U8 *pucKSVBuffer = NULL;
4890 MS_U32 ultemp = 0;
4891 MS_U32 ulLength = 0;
4892
4893 if(ulBufferSize == sizeof(stCMD_HDCP_WRITE_KSV_LIST))
4894 {
4895 ulLength = ((stCMD_HDCP_WRITE_KSV_LIST *)pBuffer)->ulLen;
4896 pucKSVBuffer = ((stCMD_HDCP_WRITE_KSV_LIST *)pBuffer)->pucKSV;
4897
4898 for(ultemp = 0; ultemp < ulLength; ultemp++)
4899 {
4900 ucKSVBuffer[ultemp] = pucKSVBuffer[ultemp];
4901 }
4902
4903 MDrv_HDCP_WriteKSVList(((stCMD_HDCP_WRITE_KSV_LIST *)pBuffer)->enInputPortType, ucKSVBuffer, ulLength);
4904
4905 bret = TRUE;
4906 }
4907 }
4908 break;
4909
4910 case E_HDMI_INTERFACE_CMD_SET_VPRIME:
4911 {
4912 if(ulBufferSize == sizeof(stCMD_HDCP_SET_VPRIME))
4913 {
4914 MDrv_HDCP_SetVPrime(((stCMD_HDCP_SET_VPRIME *)pBuffer)->enInputPortType, ((stCMD_HDCP_SET_VPRIME *)pBuffer)->pucVPrime);
4915
4916 bret = TRUE;
4917 }
4918 }
4919 break;
4920 /*************************** HDCP Repeater ***************************/
4921 case E_HDMI_INTERFACE_CMD_GET_HDCP_ENC_STATE:
4922 {
4923 if(ulBufferSize == sizeof(stCMD_HDMI_CHECK_HDCP_ENC_STATE))
4924 {
4925 ((stCMD_HDMI_CHECK_HDCP_ENC_STATE *)pBuffer)->ucHDCPENCState = (MS_U8)MDrv_HDMI_CheckHDCPENCState(((stCMD_HDMI_CHECK_HDCP_ENC_STATE *)pBuffer)->enInputPortType);
4926
4927 bret = TRUE;
4928 }
4929 else
4930 {
4931 ((stCMD_HDMI_CHECK_HDCP_ENC_STATE *)pBuffer)->ucHDCPENCState = HDMI_HDCP_NOT_ENCRYPTION;
4932 }
4933 }
4934 break;
4935
4936 default:
4937 pBuffer = pBuffer;
4938 ulBufferSize = ulBufferSize;
4939 bret = FALSE;
4940 break;
4941 };
4942
4943 return bret;
4944 }
4945
4946 //**************************************************************************
4947 // [Function Name]:
4948 // mdrv_HDMI_STREventProc
4949 // [Description]:
4950 //
4951 // [Arguments]:
4952 //
4953 // [Return]:
4954 //
4955 //**************************************************************************
mdrv_HDMI_STREventProc(void * pModule,EN_POWER_MODE usPowerState)4956 MS_U32 mdrv_HDMI_STREventProc(void* pModule, EN_POWER_MODE usPowerState)
4957 {
4958 void* pHDMIRxResource = NULL;
4959 MS_U32 ulReturnValue = UTOPIA_STATUS_FAIL;
4960 E_MUX_INPUTPORT enInputPortType = 0;
4961 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
4962
4963 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
4964 {
4965 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
4966 }
4967 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
4968 {
4969 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
4970 }
4971 else
4972 {
4973 if(pHDMIRxResourcePrivate->usPrePowerState != usPowerState)
4974 {
4975 if(usPowerState == E_POWER_SUSPEND)
4976 {
4977 ulReturnValue = UTOPIA_STATUS_SUCCESS;
4978
4979 MsOS_SetEvent(pHDMIRxResourcePrivate->slHDMIHDCPEventID, HDMI_HDCP_EVENT_STR_SUSPEND);
4980 }
4981 else if(usPowerState == E_POWER_RESUME)
4982 {
4983 // Clear all HPD
4984 for(enInputPortType = INPUT_PORT_DVI0; enInputPortType <= INPUT_PORT_DVI_END; enInputPortType++)
4985 {
4986 Hal_HDMI_pullhpd(FALSE, enInputPortType, pHDMIRxResourcePrivate->bHPDInvertFlag[HDMI_GET_PORT_SELECT(enInputPortType)], pHDMIRxResourcePrivate->ucMHLSupportPath);
4987 Hal_DVI_ClkPullLow(TRUE, enInputPortType);
4988 }
4989
4990 // HDMI initial
4991 Hal_HDMI_init(pHDMIRxResourcePrivate->bImmeswitchSupport, pHDMIRxResourcePrivate->ucMHLSupportPath);
4992
4993 // Load HDCP key
4994 if(pHDMIRxResourcePrivate->bHDCP14RxREEFlag)
4995 {
4996 Hal_HDCP_initproductionkey(pHDMIRxResourcePrivate->ucHDCPKeyTable);
4997 }
4998
4999 // Delay 100ms
5000 MsOS_DelayTask(100);
5001
5002 // Set all HPD
5003 for(enInputPortType = INPUT_PORT_DVI0; enInputPortType <= INPUT_PORT_DVI_END; enInputPortType++)
5004 {
5005 Hal_DVI_ClkPullLow(FALSE, enInputPortType);
5006 Hal_HDMI_pullhpd(TRUE, enInputPortType, pHDMIRxResourcePrivate->bHPDInvertFlag[HDMI_GET_PORT_SELECT(enInputPortType)], pHDMIRxResourcePrivate->ucMHLSupportPath);
5007
5008 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bNoInputFlag = TRUE;
5009 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bPowerOnLane = FALSE;
5010 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bHDMI20Flag = FALSE;
5011 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bYUV420Flag = FALSE;
5012 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bPowerSavingFlag = FALSE;
5013 }
5014
5015 ulReturnValue = UTOPIA_STATUS_SUCCESS;
5016 #if defined(MSOS_TYPE_LINUX_KERNEL)
5017 UtopiaStrSendCondition("hdmi_rx", usPowerState, 0);
5018 #endif
5019 }
5020
5021 pHDMIRxResourcePrivate->usPrePowerState = usPowerState;
5022 }
5023 }
5024
5025 UtopiaResourceRelease(pHDMIRxResource);
5026
5027 return ulReturnValue;
5028 }
5029
5030 //**************************************************************************
5031 // [Function Name]:
5032 // mdrv_HDMI_InitialSetting
5033 // [Description]:
5034 //
5035 // [Arguments]:
5036 //
5037 // [Return]:
5038 //
5039 //**************************************************************************
mdrv_HDMI_InitialSetting(void * pInstance,stHDMI_INITIAL_TABLE stInitialTable)5040 void mdrv_HDMI_InitialSetting(void* pInstance, stHDMI_INITIAL_TABLE stInitialTable)
5041 {
5042 void* pModule = NULL;
5043 void* pHDMIRxResource = NULL;
5044 E_MUX_INPUTPORT enInputPortType = 0;
5045 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5046
5047 UtopiaInstanceGetModule(pInstance, &pModule);
5048
5049 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5050 {
5051 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5052 }
5053 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5054 {
5055 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5056 }
5057 else
5058 {
5059 if(pHDMIRxResourcePrivate->ucInitialIndex != 0xA5)
5060 {
5061 for(enInputPortType = INPUT_PORT_DVI0; enInputPortType <= INPUT_PORT_DVI_END; enInputPortType++)
5062 {
5063 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bHDMIModeFlag = FALSE;
5064 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bTimingStableFlag = FALSE;
5065 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bAutoEQRetrigger = FALSE;
5066 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].ucSourceVersion = HDMI_SOURCE_VERSION_NOT_SURE;
5067 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].ucHDCPState = HDMI_HDCP_NO_ENCRYPTION;
5068 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bIsRepeater = FALSE;
5069 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].ucHDCPInt = 0;
5070 }
5071
5072 pHDMIRxResourcePrivate->bSelfCreateTaskFlag = FALSE;
5073 pHDMIRxResourcePrivate->bHDMITaskProcFlag = FALSE;
5074 pHDMIRxResourcePrivate->bHDCPIRQAttachFlag = FALSE;
5075 pHDMIRxResourcePrivate->slHDMIPollingTaskID = -1;
5076 pHDMIRxResourcePrivate->slHDMIHDCPEventID = MsOS_CreateEventGroup("HDMI_HDCP_Event");
5077 pHDMIRxResourcePrivate->bImmeswitchSupport = stInitialTable.bImmeswitchSupport;
5078 pHDMIRxResourcePrivate->ucMHLSupportPath = stInitialTable.ucMHLSupportPath;
5079 pHDMIRxResourcePrivate->ucHDCPReadDoneIndex = 0;
5080 pHDMIRxResourcePrivate->ucHDCPWriteDoneIndex = 0;
5081 pHDMIRxResourcePrivate->bHDCP14RxREEFlag = FALSE;
5082
5083 pHDMIRxResourcePrivate->ucInitialIndex = 0xA5;
5084 }
5085
5086 for(enInputPortType = INPUT_PORT_DVI0; enInputPortType <= INPUT_PORT_DVI_END; enInputPortType++)
5087 {
5088 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bNoInputFlag = TRUE;
5089 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bPowerOnLane = FALSE;
5090 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bHDMI20Flag = FALSE;
5091 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bYUV420Flag = FALSE;
5092 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bPowerSavingFlag = FALSE;
5093 }
5094
5095 if(!pHDMIRxResourcePrivate->bSelfCreateTaskFlag)
5096 {
5097 if(_mdrv_HDMI_CreateTask(pHDMIRxResourcePrivate))
5098 {
5099 pHDMIRxResourcePrivate->bSelfCreateTaskFlag = TRUE;
5100 }
5101 }
5102
5103 if(!pHDMIRxResourcePrivate->bHDCPIRQAttachFlag)
5104 {
5105 MsOS_AttachInterrupt(E_INT_IRQ_DVI_HDMI_HDCP, _mdrv_HDCP_IsrHandler);
5106 MsOS_EnableInterrupt(E_INT_IRQ_DVI_HDMI_HDCP);
5107
5108 pHDMIRxResourcePrivate->bHDCPIRQAttachFlag = TRUE;
5109 }
5110 }
5111
5112 UtopiaResourceRelease(pHDMIRxResource);
5113 }
5114
5115 //**************************************************************************
5116 // [Function Name]:
5117 // mdrv_HDMI_StablePolling
5118 // [Description]:
5119 //
5120 // [Arguments]:
5121 //
5122 // [Return]:
5123 //
5124 //**************************************************************************
mdrv_HDMI_StablePolling(void * pInstance)5125 void mdrv_HDMI_StablePolling(void* pInstance)
5126 {
5127 void* pModule = NULL;
5128 void* pHDMIRxResource = NULL;
5129 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5130
5131 UtopiaInstanceGetModule(pInstance, &pModule);
5132
5133 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5134 {
5135 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5136 }
5137 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5138 {
5139 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5140 }
5141 else
5142 {
5143 Hal_HDMI_StablePolling(pHDMIRxResourcePrivate->ucMHLSupportPath, pHDMIRxResourcePrivate->stHDMIPollingInfo);
5144 }
5145
5146 UtopiaResourceRelease(pHDMIRxResource);
5147 }
5148
5149 //**************************************************************************
5150 // [Function Name]:
5151 // mdrv_HDMI_GetSourceVersion
5152 // [Description]:
5153 //
5154 // [Arguments]:
5155 //
5156 // [Return]:
5157 //
5158 //**************************************************************************
mdrv_HDMI_GetSourceVersion(void * pInstance,E_MUX_INPUTPORT enInputPortType)5159 MS_U8 mdrv_HDMI_GetSourceVersion(void* pInstance, E_MUX_INPUTPORT enInputPortType)
5160 {
5161 void* pModule = NULL;
5162 void* pHDMIRxResource = NULL;
5163 MS_U8 ucSourceVersion = HDMI_SOURCE_VERSION_NOT_SURE;
5164 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5165
5166 UtopiaInstanceGetModule(pInstance, &pModule);
5167
5168 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5169 {
5170 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5171 }
5172 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5173 {
5174 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5175 }
5176 else
5177 {
5178 if(pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].ucSourceVersion != HDMI_SOURCE_VERSION_NOT_SURE)
5179 {
5180 if(pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bYUV420Flag)
5181 {
5182 ucSourceVersion = HDMI_SOURCE_VERSION_HDMI20;
5183 }
5184 else if(!pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bHDMIModeFlag)
5185 {
5186 ucSourceVersion = HDMI_SOURCE_VERSION_HDMI14;
5187 }
5188 else
5189 {
5190 ucSourceVersion = pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].ucSourceVersion;
5191 }
5192 }
5193 }
5194
5195 UtopiaResourceRelease(pHDMIRxResource);
5196
5197 return ucSourceVersion;
5198 }
5199
5200 //**************************************************************************
5201 // [Function Name]:
5202 // mdrv_HDMI_CheckHDCPState
5203 // [Description]:
5204 //
5205 // [Arguments]:
5206 //
5207 // [Return]:
5208 //
5209 //**************************************************************************
mdrv_HDMI_CheckHDCPState(void * pInstance,E_MUX_INPUTPORT enInputPortType)5210 MS_U8 mdrv_HDMI_CheckHDCPState(void* pInstance, E_MUX_INPUTPORT enInputPortType)
5211 {
5212 void* pModule = NULL;
5213 void* pHDMIRxResource = NULL;
5214 MS_U8 ucHDCPState = HDMI_HDCP_NO_ENCRYPTION;
5215 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5216
5217 UtopiaInstanceGetModule(pInstance, &pModule);
5218
5219 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5220 {
5221 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5222 }
5223 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5224 {
5225 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5226 }
5227 else
5228 {
5229 if(!pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bIsRepeater) // not Repeater mode
5230 {
5231 if(Hal_HDCP_GetEncryptionFlag(enInputPortType) && (!Hal_DVI_clklose_det(enInputPortType))) // HDCP RX detection ENC_EN status
5232 {
5233 if(pHDMIRxResourcePrivate->bHDCP14RiFlag[HDMI_GET_PORT_SELECT(enInputPortType)]) // [13] Ri: HDCP1.4
5234 {
5235 ucHDCPState = HDMI_HDCP_1_4;
5236
5237 MDRV_HDMIRX_MSG_ERROR("** ENC_EN, HDMI HDCP state 1.4, port %d\r\n", (enInputPortType -INPUT_PORT_DVI0));
5238 }
5239 else if(pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].ucHDCPState == HDMI_HDCP_2_2) // AKE_Init interrupt status: HDCP2.2
5240 {
5241 ucHDCPState = HDMI_HDCP_2_2;
5242
5243 MDRV_HDMIRX_MSG_ERROR("** ENC_EN, HDMI HDCP state 2.2, port %d\r\n", (enInputPortType -INPUT_PORT_DVI0));
5244 }
5245 }
5246 }
5247 else // is Repeater mode
5248 {
5249 ucHDCPState = pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].ucHDCPState;
5250 }
5251 }
5252
5253 UtopiaResourceRelease(pHDMIRxResource);
5254
5255 return ucHDCPState;
5256 }
5257
5258 //**************************************************************************
5259 // [Function Name]:
5260 // mdrv_HDMI_CheckHDCPENCState
5261 // [Description]:
5262 //
5263 // [Arguments]:
5264 //
5265 // [Return]:
5266 //
5267 //**************************************************************************
mdrv_HDMI_CheckHDCPENCState(void * pInstance,E_MUX_INPUTPORT enInputPortType)5268 MS_U8 mdrv_HDMI_CheckHDCPENCState(void* pInstance, E_MUX_INPUTPORT enInputPortType)
5269 {
5270 void* pModule = NULL;
5271 void* pHDMIRxResource = NULL;
5272 MS_U8 ucHDCPENCState = HDMI_HDCP_NOT_ENCRYPTION;
5273 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5274
5275 UtopiaInstanceGetModule(pInstance, &pModule);
5276
5277 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5278 {
5279 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5280 }
5281 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5282 {
5283 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5284 }
5285 else
5286 {
5287 if(Hal_HDCP_GetEncryptionFlag(enInputPortType) && (!Hal_DVI_clklose_det(enInputPortType))) // HDCP RX detection ENC_EN status
5288 {
5289 if(pHDMIRxResourcePrivate->bHDCP14RiFlag[HDMI_GET_PORT_SELECT(enInputPortType)]) // [13] Ri: HDCP1.4
5290 {
5291 ucHDCPENCState = HDMI_HDCP_1_4_ENCRYPTION;
5292
5293 MDRV_HDMIRX_MSG_ERROR("** ENC_EN, HDMI HDCP ENC state 1.4, port %d\r\n", (enInputPortType -INPUT_PORT_DVI0));
5294 }
5295 else if(pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].ucHDCPState == HDMI_HDCP_2_2) // AKE_Init interrupt status: HDCP2.2
5296 {
5297 ucHDCPENCState = HDMI_HDCP_2_2_ENCRYPTION;
5298
5299 MDRV_HDMIRX_MSG_ERROR("** ENC_EN, HDMI HDCP ENC state 2.2, port %d\r\n", (enInputPortType -INPUT_PORT_DVI0));
5300 }
5301 }
5302 }
5303
5304 UtopiaResourceRelease(pHDMIRxResource);
5305
5306 return ucHDCPENCState;
5307 }
5308
5309 //**************************************************************************
5310 // [Function Name]:
5311 // mdrv_HDMI_CheckHDCP14KeyVaild
5312 // [Description]:
5313 //
5314 // [Arguments]:
5315 //
5316 // [Return]:
5317 //
5318 //**************************************************************************
mdrv_HDMI_CheckHDCP14KeyVaild(void * pInstance,MS_U8 * ucHDCPKeyData)5319 void mdrv_HDMI_CheckHDCP14KeyVaild(void* pInstance, MS_U8 *ucHDCPKeyData)
5320 {
5321 void* pModule = NULL;
5322 void* pHDMIRxResource = NULL;
5323 MS_U16 ustemp = 0;
5324 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5325
5326 UtopiaInstanceGetModule(pInstance, &pModule);
5327
5328 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5329 {
5330 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5331 }
5332 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5333 {
5334 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5335 }
5336 else
5337 {
5338 for(ustemp = 0; ustemp < HDMI_HDCP_KEY_LENGTH; ustemp++)
5339 {
5340 pHDMIRxResourcePrivate->ucHDCPKeyTable[ustemp] = ucHDCPKeyData[ustemp];
5341 }
5342
5343 if(_mdrv_HDMI_CheckHDCP14Bksv(pHDMIRxResourcePrivate->ucHDCPKeyTable))
5344 {
5345 pHDMIRxResourcePrivate->bHDCP14KeyVaildFlag = TRUE;
5346 }
5347 else
5348 {
5349 MDRV_HDMIRX_MSG_INFO("** TMDS HDCP 1.4 key Bksv data fail~~\r\n");
5350 }
5351
5352 if(!pHDMIRxResourcePrivate->bHDCP14RxREEFlag)
5353 {
5354 pHDMIRxResourcePrivate->bHDCP14RxREEFlag = TRUE;
5355 }
5356 }
5357
5358 UtopiaResourceRelease(pHDMIRxResource);
5359 }
5360
5361 //**************************************************************************
5362 // [Function Name]:
5363 // mdrv_HDMI_GetHDCP14KeyVaildFlag
5364 // [Description]:
5365 //
5366 // [Arguments]:
5367 //
5368 // [Return]:
5369 //
5370 //**************************************************************************
mdrv_HDMI_GetHDCP14KeyVaildFlag(void * pInstance)5371 MS_BOOL mdrv_HDMI_GetHDCP14KeyVaildFlag(void* pInstance)
5372 {
5373 MS_BOOL bHDCP14KeyVaild = FALSE;
5374 void* pModule = NULL;
5375 void* pHDMIRxResource = NULL;
5376 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5377
5378 UtopiaInstanceGetModule(pInstance, &pModule);
5379
5380 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5381 {
5382 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5383 }
5384 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5385 {
5386 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5387 }
5388 else
5389 {
5390 bHDCP14KeyVaild = pHDMIRxResourcePrivate->bHDCP14KeyVaildFlag;
5391 }
5392
5393 UtopiaResourceRelease(pHDMIRxResource);
5394
5395 return bHDCP14KeyVaild;
5396 }
5397
5398 //**************************************************************************
5399 // [Function Name]:
5400 // mdrv_HDMI_SetHPDInvertFlag
5401 // [Description]:
5402 //
5403 // [Arguments]:
5404 //
5405 // [Return]:
5406 //
5407 //**************************************************************************
mdrv_HDMI_SetHPDInvertFlag(void * pInstance,E_MUX_INPUTPORT enInputPortType,MS_BOOL bHPDInvertFlag)5408 void mdrv_HDMI_SetHPDInvertFlag(void* pInstance, E_MUX_INPUTPORT enInputPortType, MS_BOOL bHPDInvertFlag)
5409 {
5410 void* pModule = NULL;
5411 void* pHDMIRxResource = NULL;
5412 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5413
5414 UtopiaInstanceGetModule(pInstance, &pModule);
5415
5416 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5417 {
5418 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5419 }
5420 else
5421 {
5422 if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5423 {
5424 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5425 }
5426 else
5427 {
5428 pHDMIRxResourcePrivate->bHPDInvertFlag[HDMI_GET_PORT_SELECT(enInputPortType)] = bHPDInvertFlag;
5429 }
5430 }
5431
5432 UtopiaResourceRelease(pHDMIRxResource);
5433 }
5434
5435 //**************************************************************************
5436 // [Function Name]:
5437 // mdrv_HDMI_GetPacketReceiveStatus
5438 // [Description]:
5439 //
5440 // [Arguments]:
5441 //
5442 // [Return]:
5443 //
5444 //**************************************************************************
mdrv_HDMI_GetPacketReceiveStatus(void * pInstance,MS_U8 ucHDMIInfoSource)5445 MS_U32 mdrv_HDMI_GetPacketReceiveStatus(void* pInstance, MS_U8 ucHDMIInfoSource)
5446 {
5447 void* pModule = NULL;
5448 void* pHDMIRxResource = NULL;
5449 MS_U32 ulPacketStatus = 0;
5450 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5451
5452 UtopiaInstanceGetModule(pInstance, &pModule);
5453
5454 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5455 {
5456 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5457 }
5458 else
5459 {
5460 if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5461 {
5462 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5463 }
5464 else
5465 {
5466 ulPacketStatus = pHDMIRxResourcePrivate->ulPacketStatus[ucHDMIInfoSource];
5467 }
5468 }
5469
5470 UtopiaResourceRelease(pHDMIRxResource);
5471
5472 return ulPacketStatus;
5473 }
5474
5475 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
5476 //-------------------------------------------------------------------------------------------------
5477 ///mdrv_HDMI_MDCMDEchoCommand
5478 /// @param u64ReqHdl \b IN: Module index
5479 /// @param pcCmdLine \b IN: Command line info
5480 //-------------------------------------------------------------------------------------------------
mdrv_HDMI_MDCMDEchoCommand(void * pInstance,MS_U64 * u64ReqHdl,char * pcCmdLine)5481 void mdrv_HDMI_MDCMDEchoCommand(void* pInstance, MS_U64* u64ReqHdl, char* pcCmdLine)
5482 {
5483 char pch[] = "=,";
5484 char* psep;
5485
5486 MdbPrint(u64ReqHdl, "LINE:%d, MDBCMD_CMDLINE\n", __LINE__);
5487 MdbPrint(u64ReqHdl, "pcCmdLine: %s\n", pcCmdLine);
5488
5489 psep = strsep(&pcCmdLine, pch);
5490
5491 if(strncmp("HDMIRxOn", psep, 8) == 0)
5492 {
5493
5494 }
5495 }
5496
5497 //-------------------------------------------------------------------------------------------------
5498 ///mdrv_HDMI_MDCMDGetInfo
5499 /// @param u64ReqHdl \b IN: Module index
5500 //-------------------------------------------------------------------------------------------------
mdrv_HDMI_MDCMDGetInfo(void * pInstance,MS_U64 * u64ReqHdl)5501 void mdrv_HDMI_MDCMDGetInfo(void* pInstance, MS_U64* u64ReqHdl)
5502 {
5503 void* pModule = NULL;
5504 void* pHDMIRxResource = NULL;
5505 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5506
5507 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5508 {
5509 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5510 }
5511 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5512 {
5513 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5514 }
5515 else
5516 {
5517 MdbPrint(u64ReqHdl, "LINE:%d, MDBCMD_GETINFO\n", __LINE__);
5518 }
5519
5520 UtopiaResourceRelease(pHDMIRxResource);
5521 }
5522
5523 #endif
5524
5525 //-------------------------------------------------------------------------------------------------
5526 /// mdrv_HDCP_WriteX74
5527 /// @param enInputPortType \b IN: HDMI Port number
5528 /// @param ucOffset \b IN: x74 offset
5529 /// @param ucData \b IN: x74 data
5530 //-------------------------------------------------------------------------------------------------
mdrv_HDCP_WriteX74(void * pInstance,E_MUX_INPUTPORT enInputPortType,MS_U8 ucOffset,MS_U8 ucData)5531 void mdrv_HDCP_WriteX74(void* pInstance, E_MUX_INPUTPORT enInputPortType, MS_U8 ucOffset, MS_U8 ucData)
5532 {
5533 void* pModule = NULL;
5534 void* pHDMIRxResource = NULL;
5535 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5536
5537 UtopiaInstanceGetModule(pInstance, &pModule);
5538
5539 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5540 {
5541 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5542 }
5543 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5544 {
5545 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5546 }
5547 else
5548 {
5549 Hal_HDCP_WriteX74(enInputPortType, ucOffset, ucData);
5550 }
5551
5552 UtopiaResourceRelease(pHDMIRxResource);
5553 }
5554
5555 //-------------------------------------------------------------------------------------------------
5556 /// mdrv_HDCP_ReadX74
5557 /// @param enInputPortType \b IN: HDMI Port number
5558 /// @param ucOffset \b IN: x74 offset
5559 /// return x74 data
5560 //-------------------------------------------------------------------------------------------------
mdrv_HDCP_ReadX74(void * pInstance,E_MUX_INPUTPORT enInputPortType,MS_U8 ucOffset)5561 MS_U8 mdrv_HDCP_ReadX74(void* pInstance, E_MUX_INPUTPORT enInputPortType, MS_U8 ucOffset)
5562 {
5563 void* pModule = NULL;
5564 void* pHDMIRxResource = NULL;
5565 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5566 MS_U8 ucRetData = 0;
5567
5568 UtopiaInstanceGetModule(pInstance, &pModule);
5569
5570 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5571 {
5572 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5573 }
5574 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5575 {
5576 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5577 }
5578 else
5579 {
5580 ucRetData = Hal_HDCP_ReadX74(enInputPortType, ucOffset);
5581 }
5582
5583 UtopiaResourceRelease(pHDMIRxResource);
5584
5585 return ucRetData;
5586 }
5587
5588 //-------------------------------------------------------------------------------------------------
5589 /// mdrv_HDCP_SetRepeater
5590 /// @param enInputPortType \b IN: HDMI Port number
5591 /// @param bIsRepeater \b IN: Set REAPEATER or not
5592 //-------------------------------------------------------------------------------------------------
mdrv_HDCP_SetRepeater(void * pInstance,E_MUX_INPUTPORT enInputPortType,MS_BOOL bIsRepeater)5593 void mdrv_HDCP_SetRepeater(void* pInstance, E_MUX_INPUTPORT enInputPortType, MS_BOOL bIsRepeater)
5594 {
5595 void* pModule = NULL;
5596 void* pHDMIRxResource = NULL;
5597 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5598 MS_U8 ucBcaps = 0x00;
5599
5600 UtopiaInstanceGetModule(pInstance, &pModule);
5601
5602 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5603 {
5604 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5605 }
5606 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5607 {
5608 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5609 }
5610 else
5611 {
5612 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].bIsRepeater = bIsRepeater;
5613
5614 ucBcaps = Hal_HDCP_ReadX74(enInputPortType, 0x40);//Read Bcaps
5615
5616 if(bIsRepeater)
5617 {
5618 ucBcaps = ucBcaps | 0x40;
5619 }
5620 else
5621 {
5622 ucBcaps = ucBcaps & 0xBF;
5623 }
5624
5625 Hal_HDCP_WriteX74(enInputPortType, 0x40, ucBcaps);
5626 }
5627
5628 UtopiaResourceRelease(pHDMIRxResource);
5629 }
5630
5631 //-------------------------------------------------------------------------------------------------
5632 ///mdrv_HDCP_SetBStatus
5633 /// @param enInputPortType \b IN: HDMI Port number
5634 /// @param usBStatus \b IN: Set Bstatus
5635 //-------------------------------------------------------------------------------------------------
mdrv_HDCP_SetBstatus(void * pInstance,E_MUX_INPUTPORT enInputPortType,MS_U16 usBstatus)5636 void mdrv_HDCP_SetBstatus(void* pInstance, E_MUX_INPUTPORT enInputPortType, MS_U16 usBstatus)
5637 {
5638 void* pModule = NULL;
5639 void* pHDMIRxResource = NULL;
5640 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5641 MS_U8 ucBStatus = 0x00;
5642
5643 UtopiaInstanceGetModule(pInstance, &pModule);
5644
5645 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5646 {
5647 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5648 }
5649 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5650 {
5651 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5652 }
5653 else
5654 {
5655 ucBStatus = (MS_U8)(usBstatus & BMASK(7:0)); // [6:0]: Device cnt
5656 Hal_HDCP_WriteX74(enInputPortType, 0x41, ucBStatus);
5657
5658 ucBStatus = (MS_U8)((usBstatus & BMASK(15:8)) >> 8);//[10:8]: Depth and [12]: HDMI mode
5659 Hal_HDCP_WriteX74(enInputPortType, 0x42, ucBStatus);
5660
5661 MDRV_HDMIRX_MSG_INFO("SN Set Bstatus=%x\r\n", ucBStatus);
5662 }
5663
5664 UtopiaResourceRelease(pHDMIRxResource);
5665 }
5666
5667 //-------------------------------------------------------------------------------------------------
5668 /// mdrv_HDCP_SetHDMIMode
5669 /// @param enInputPortType \b IN: HDMI Port number
5670 /// @param bHDMIMode \b IN: Set HDMI mode or not
5671 //-------------------------------------------------------------------------------------------------
mdrv_HDCP_SetHDMIMode(void * pInstance,E_MUX_INPUTPORT enInputPortType,MS_BOOL bHDMIMode)5672 void mdrv_HDCP_SetHDMIMode(void* pInstance, E_MUX_INPUTPORT enInputPortType, MS_BOOL bHDMIMode)
5673 {
5674 void* pModule = NULL;
5675 void* pHDMIRxResource = NULL;
5676 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5677 MS_U8 ucBstatusHighByte = 0;
5678
5679 UtopiaInstanceGetModule(pInstance, &pModule);
5680
5681 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5682 {
5683 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5684 }
5685 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5686 {
5687 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5688 }
5689 else
5690 {
5691 ucBstatusHighByte = Hal_HDCP_ReadX74(enInputPortType, 0x42);
5692 ucBstatusHighByte = bHDMIMode? (ucBstatusHighByte|0x10): (ucBstatusHighByte&0xEF);
5693
5694 Hal_HDCP_WriteX74(enInputPortType, 0x42, ucBstatusHighByte);
5695 }
5696
5697 UtopiaResourceRelease(pHDMIRxResource);
5698 }
5699
5700 //-------------------------------------------------------------------------------------------------
5701 /// mdrv_HDCP_GetInterruptStatus
5702 /// @param enInputPortType \b IN: HDMI Port number
5703 /// @return interrupt status
5704 //-------------------------------------------------------------------------------------------------
mdrv_HDCP_GetInterruptStatus(void * pInstance,E_MUX_INPUTPORT enInputPortType)5705 MS_U8 mdrv_HDCP_GetInterruptStatus(void* pInstance, E_MUX_INPUTPORT enInputPortType)
5706 {
5707 void* pModule = NULL;
5708 void* pHDMIRxResource = NULL;
5709 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5710 MS_U8 ucRetIntStatus = 0;
5711
5712 UtopiaInstanceGetModule(pInstance, &pModule);
5713
5714 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5715 {
5716 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5717 }
5718 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5719 {
5720 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5721 }
5722 else
5723 {
5724 ucRetIntStatus = (Hal_HDCP_getstatus(enInputPortType) & BMASK(15:8)) >> 8;
5725
5726 pHDMIRxResourcePrivate->stHDMIPollingInfo[HDMI_GET_PORT_SELECT(enInputPortType)].ucHDCPInt = ucRetIntStatus;
5727
5728 if(ucRetIntStatus & BIT(0)) // [8]: Aksv
5729 {
5730 MDRV_HDMIRX_MSG_INFO("[%s@%d]Clear Ready", __FUNCTION__, __LINE__);
5731 Hal_HDCP_SetReady(enInputPortType, FALSE); // Clear Ready
5732 }
5733
5734 Hal_HDCP_ClearStatus(enInputPortType, (ucRetIntStatus & BMASK(4:0))); // Clear [0] Aksv, [1] An, [2] Km, [3] Bksv, [4] R0 interrupt status
5735 }
5736
5737 UtopiaResourceRelease(pHDMIRxResource);
5738
5739 return ucRetIntStatus;
5740 }
5741
5742 //-------------------------------------------------------------------------------------------------
5743 /// mdrv_HDCP_WriteKSVList
5744 /// @param enInputPortType \b IN: HDMI Port number
5745 /// @param bHDMIMode \b IN: Set HDMI mode or not
5746 //-------------------------------------------------------------------------------------------------
mdrv_HDCP_WriteKSVList(void * pInstance,E_MUX_INPUTPORT enInputPortType,MS_U8 * pucKSV,MS_U32 ulDataLen)5747 void mdrv_HDCP_WriteKSVList(void* pInstance, E_MUX_INPUTPORT enInputPortType, MS_U8* pucKSV, MS_U32 ulDataLen)
5748 {
5749 void* pModule = NULL;
5750 void* pHDMIRxResource = NULL;
5751 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5752
5753 UtopiaInstanceGetModule(pInstance, &pModule);
5754
5755 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5756 {
5757 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5758 }
5759 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5760 {
5761 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5762 }
5763 else
5764 {
5765 Hal_HDCP_WriteKSVList(enInputPortType, pucKSV, ulDataLen);
5766 }
5767
5768 UtopiaResourceRelease(pHDMIRxResource);
5769 }
5770
5771 //-------------------------------------------------------------------------------------------------
5772 /// mdrv_HDCP_SetVPrime
5773 /// @param enInputPortType \b IN: HDMI Port number
5774 /// @param ubVPrime \b IN: Set V prime
5775 //-------------------------------------------------------------------------------------------------
mdrv_HDCP_SetVPrime(void * pInstance,E_MUX_INPUTPORT enInputPortType,MS_U8 * pucVPrime)5776 void mdrv_HDCP_SetVPrime(void* pInstance, E_MUX_INPUTPORT enInputPortType, MS_U8* pucVPrime)
5777 {
5778 void* pModule = NULL;
5779 void* pHDMIRxResource = NULL;
5780 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5781 MS_U8 ucCnt = 0;
5782
5783 UtopiaInstanceGetModule(pInstance, &pModule);
5784
5785 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5786 {
5787 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5788 }
5789 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5790 {
5791 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5792 }
5793 else
5794 {
5795 for(ucCnt = 0; ucCnt < HDMI_HDCP_VPRIME_LENGTH; ucCnt++)
5796 {
5797 Hal_HDCP_WriteX74(enInputPortType, 0x20 + ucCnt, *(pucVPrime + ucCnt));
5798 }
5799
5800 MDRV_HDMIRX_MSG_INFO("[%s@%d]Set Ready", __FUNCTION__, __LINE__);
5801 Hal_HDCP_SetReady(enInputPortType, TRUE); // Set Ready
5802 }
5803
5804 UtopiaResourceRelease(pHDMIRxResource);
5805 }
5806
5807 //**************************************************************************
5808 // [Function Name]:
5809 // mdrv_HDCP22_FillCipherKey
5810 // [Description]:
5811 //
5812 // [Arguments]:
5813 //
5814 // [Return]:
5815 //
5816 //**************************************************************************
mdrv_HDCP22_FillCipherKey(void * pInstance,MS_U8 ucPortIdx,MS_U8 * pucRiv,MS_U8 * pucSessionKey)5817 void mdrv_HDCP22_FillCipherKey(void* pInstance, MS_U8 ucPortIdx, MS_U8* pucRiv, MS_U8* pucSessionKey)
5818 {
5819 Hal_HDCP22_FillCipherKey(ucPortIdx, pucRiv, pucSessionKey);
5820 }
5821
5822 //**************************************************************************
5823 // [Function Name]:
5824 // mdrv_HDCP22_PortInit
5825 // [Description]:
5826 //
5827 // [Arguments]:
5828 //
5829 // [Return]:
5830 //
5831 //**************************************************************************
mdrv_HDCP22_PortInit(void * pInstance,MS_U8 ucPortIdx)5832 void mdrv_HDCP22_PortInit(void* pInstance, MS_U8 ucPortIdx)
5833 {
5834 void* pModule = NULL;
5835 void* pHDMIRxResource = NULL;
5836 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5837
5838 UtopiaInstanceGetModule(pInstance, &pModule);
5839
5840 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5841 {
5842 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5843 }
5844 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5845 {
5846 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5847 }
5848 else
5849 {
5850 Hal_HDCP22_PortInit(ucPortIdx);
5851
5852 Hal_HDCP_WriteDoneInterruptEnable(INPUT_PORT_DVI0 +ucPortIdx, TRUE);
5853
5854 pHDMIRxResourcePrivate->ucHDCP22RecvIDListSend[ucPortIdx] = FALSE;
5855 pHDMIRxResourcePrivate->bHDCP22IRQMaskFlag[ucPortIdx] = TRUE;
5856 }
5857
5858 UtopiaResourceRelease(pHDMIRxResource);
5859 }
5860
5861 //**************************************************************************
5862 // [Function Name]:
5863 // mdrv_HDCP22_PollingReadDone
5864 // [Description]:
5865 //
5866 // [Arguments]:
5867 //
5868 // [Return]:
5869 //
5870 //**************************************************************************
mdrv_HDCP22_PollingReadDone(void * pInstance,MS_U8 ucPortIdx)5871 MS_BOOL mdrv_HDCP22_PollingReadDone(void* pInstance, MS_U8 ucPortIdx)
5872 {
5873 void* pModule = NULL;
5874 void* pHDMIRxResource = NULL;
5875 MS_BOOL bReadDoneFlag = FALSE;
5876 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5877
5878 UtopiaInstanceGetModule(pInstance, &pModule);
5879
5880 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5881 {
5882 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5883 }
5884 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5885 {
5886 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5887 }
5888 else
5889 {
5890 if(Hal_HDCP22_PollingReadDone(ucPortIdx))
5891 {
5892 bReadDoneFlag = TRUE;
5893 }
5894 else if(GET_HDMI_FLAG(pHDMIRxResourcePrivate->ucHDCPReadDoneIndex, BIT(ucPortIdx)))
5895 {
5896 CLR_HDMI_FLAG(pHDMIRxResourcePrivate->ucHDCPReadDoneIndex, BIT(ucPortIdx));
5897
5898 bReadDoneFlag = TRUE;
5899 }
5900 }
5901
5902 UtopiaResourceRelease(pHDMIRxResource);
5903
5904 return bReadDoneFlag;
5905 }
5906
5907 //**************************************************************************
5908 // [Function Name]:
5909 // mdrv_HDCP22_EnableCipher
5910 // [Description]:
5911 //
5912 // [Arguments]:
5913 //
5914 // [Return]:
5915 //
5916 //**************************************************************************
mdrv_HDCP22_EnableCipher(void * pInstance,MS_U8 ucPortType,MS_U8 ucPortIdx,MS_BOOL bIsEnable)5917 void mdrv_HDCP22_EnableCipher(void* pInstance, MS_U8 ucPortType, MS_U8 ucPortIdx, MS_BOOL bIsEnable)
5918 {
5919 Hal_HDCP22_EnableCipher(ucPortType, ucPortIdx, bIsEnable);
5920 }
5921
5922 //**************************************************************************
5923 // [Function Name]:
5924 // mdrv_HDCP22_SendMessage
5925 // [Description]:
5926 //
5927 // [Arguments]:
5928 //
5929 // [Return]:
5930 //
5931 //**************************************************************************
mdrv_HDCP22_SendMessage(void * pInstance,MS_U8 ucPortType,MS_U8 ucPortIdx,MS_U8 * pucData,MS_U32 dwDataLen,void * pDummy)5932 void mdrv_HDCP22_SendMessage(void* pInstance, MS_U8 ucPortType, MS_U8 ucPortIdx, MS_U8* pucData, MS_U32 dwDataLen, void* pDummy)
5933 {
5934 void* pModule = NULL;
5935 void* pHDMIRxResource = NULL;
5936 MS_U8 ubRecIDListSetDone = 0;
5937 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5938
5939 Hal_HDCP22_SendMsg(ucPortType, ucPortIdx, pucData, dwDataLen, pDummy, &ubRecIDListSetDone);
5940
5941 if (*(MS_U8*)(pucData) == 0xC)
5942 {
5943 UtopiaInstanceGetModule(pInstance, &pModule);
5944
5945 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5946 {
5947 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5948 }
5949 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5950 {
5951 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5952 }
5953 else
5954 {
5955 if (*(MS_U8*)(pucData) == 0xC)
5956 {
5957 pHDMIRxResourcePrivate->ucHDCP22RecvIDListSend[ucPortIdx] = ubRecIDListSetDone;
5958 }
5959 }
5960
5961 UtopiaResourceRelease(pHDMIRxResource);
5962 }
5963 }
5964
5965 //**************************************************************************
5966 // [Function Name]:
5967 // mdrv_HDCP22_Handler
5968 // [Description]:
5969 //
5970 // [Arguments]:
5971 //
5972 // [Return]:
5973 //
5974 //**************************************************************************
mdrv_HDCP22_Handler(void * pInstance,MS_U8 ucPortIdx,MS_U8 * ucPortType,MS_U8 * pucMsgData,MS_U32 * wMsgLen,MS_BOOL bIRQModeFlag)5975 MS_BOOL mdrv_HDCP22_Handler(void* pInstance, MS_U8 ucPortIdx, MS_U8* ucPortType, MS_U8* pucMsgData, MS_U32* wMsgLen, MS_BOOL bIRQModeFlag)
5976 {
5977 void* pModule = NULL;
5978 void* pHDMIRxResource = NULL;
5979 MS_BOOL bCallbackFlag = FALSE;
5980 MS_U8 ucMsgData[HDMI_HDCP22_MESSAGE_LENGTH +1] = {0};
5981 MS_U16 ustemp = 0;
5982 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
5983
5984 UtopiaInstanceGetModule(pInstance, &pModule);
5985
5986 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
5987 {
5988 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
5989 }
5990 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
5991 {
5992 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
5993 }
5994 else
5995 {
5996 if(bIRQModeFlag)
5997 {
5998 if(Hal_HDCP22_RecvMsg(ucPortIdx, ucMsgData))
5999 {
6000 *ucPortType = E_HDCP22_IF_HDMI;
6001
6002 for(ustemp = 0; ustemp < HDMI_HDCP22_MESSAGE_LENGTH; ustemp++)
6003 {
6004 pucMsgData[ustemp] = ucMsgData[ustemp];
6005 }
6006
6007 *wMsgLen = ucMsgData[HDMI_HDCP22_MESSAGE_LENGTH];
6008
6009 bCallbackFlag = TRUE;
6010 }
6011 }
6012 else
6013 {
6014 if(pHDMIRxResourcePrivate->bHDCP22IRQMaskFlag[ucPortIdx])
6015 {
6016 Hal_HDCP_WriteDoneInterruptEnable(INPUT_PORT_DVI0 +ucPortIdx, FALSE);
6017
6018 pHDMIRxResourcePrivate->bHDCP22IRQMaskFlag[ucPortIdx] = FALSE;
6019 }
6020
6021 if(Hal_HDCP22_PollingWriteDone(ucPortIdx)) //polling msg
6022 {
6023 if(Hal_HDCP22_RecvMsg(ucPortIdx, ucMsgData))
6024 {
6025 *ucPortType = E_HDCP22_IF_HDMI;
6026
6027 for(ustemp = 0; ustemp < HDMI_HDCP22_MESSAGE_LENGTH; ustemp++)
6028 {
6029 pucMsgData[ustemp] = ucMsgData[ustemp];
6030 }
6031
6032 *wMsgLen = ucMsgData[HDMI_HDCP22_MESSAGE_LENGTH];
6033
6034 bCallbackFlag = TRUE;
6035 }
6036 }
6037 else
6038 {
6039 *wMsgLen = 0;
6040 }
6041
6042 if(ucMsgData[0] == 0x00)
6043 {
6044 if(pHDMIRxResourcePrivate->ucHDCP22RecvIDListSend[ucPortIdx])
6045 {
6046 if(Hal_HDCP22_PollingReadDone(ucPortIdx))
6047 {
6048 pHDMIRxResourcePrivate->ucHDCP22RecvIDListSend[ucPortIdx] = FALSE;
6049
6050 Hal_HDCP22_SetReadyBit(ucPortIdx, FALSE); //clear ready bit after source read re
6051 }
6052 }
6053 }
6054 }
6055 }
6056
6057 UtopiaResourceRelease(pHDMIRxResource);
6058
6059 return bCallbackFlag;
6060 }
6061
6062 //**************************************************************************
6063 // [Function Name]:
6064 // mdrv_HDCP22_WaitEvent
6065 // [Description]:
6066 //
6067 // [Arguments]:
6068 //
6069 // [Return]:
6070 //
6071 //**************************************************************************
mdrv_HDCP22_WaitEvent(void * pInstance)6072 MS_U8 mdrv_HDCP22_WaitEvent(void* pInstance)
6073 {
6074 void* pModule = NULL;
6075 void* pHDMIRxResource = NULL;
6076 MS_BOOL bGetEventIDFlag = FALSE;
6077 MS_U8 ucHDCPWriteDoneIndex = 0;
6078 MS_U32 ulEvent = 0;
6079 MS_S32 slHDMIHDCPEventID = -1;
6080 HDMI_RX_RESOURCE_PRIVATE *pHDMIRxResourcePrivate = NULL;
6081
6082 UtopiaInstanceGetModule(pInstance, &pModule);
6083
6084 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
6085 {
6086 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
6087 }
6088 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
6089 {
6090 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
6091 }
6092 else
6093 {
6094 slHDMIHDCPEventID = pHDMIRxResourcePrivate->slHDMIHDCPEventID;
6095 bGetEventIDFlag = TRUE;
6096 }
6097
6098 UtopiaResourceRelease(pHDMIRxResource);
6099
6100 if(bGetEventIDFlag)
6101 {
6102 MsOS_WaitEvent_Interrupt(slHDMIHDCPEventID, HDMI_HDCP_ALL_EVENT, &ulEvent, E_OR_CLEAR, MSOS_WAIT_FOREVER);
6103 }
6104
6105 //MDRV_HDMIRX_MSG_INFO("** TMDS wait event happen kernel space !!!!!!\r\n");
6106
6107 if(UtopiaResourceObtain(pModule, HDMI_RX_POOL, &pHDMIRxResource) != UTOPIA_STATUS_SUCCESS)
6108 {
6109 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
6110 }
6111 else if(UtopiaResourceGetPrivate(pHDMIRxResource, (void*)&pHDMIRxResourcePrivate) != UTOPIA_STATUS_SUCCESS)
6112 {
6113 MDRV_HDMIRX_MSG_ERROR("[%s,%5d] Get HDMI Rx resource failed\n", __FUNCTION__, __LINE__);
6114 }
6115 else
6116 {
6117 ucHDCPWriteDoneIndex = pHDMIRxResourcePrivate->ucHDCPWriteDoneIndex;
6118 pHDMIRxResourcePrivate->ucHDCPWriteDoneIndex = 0;
6119 }
6120
6121 UtopiaResourceRelease(pHDMIRxResource);
6122
6123 return ucHDCPWriteDoneIndex;
6124 }
6125
6126