1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2006-2007 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // (¡§MStar Confidential Information¡¨) by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94
95 ///////////////////////////////////////////////////////////////////////////////////////////////////
96 ///
97 /// file drvHDMITx.c
98 /// @author MStar Semiconductor Inc.
99 /// @brief HDMI Tx Driver Interface
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102 #define MDRV_HDMITX_C
103
104 //-------------------------------------------------------------------------------------------------
105 // Include Files
106 //-------------------------------------------------------------------------------------------------
107 #ifdef MSOS_TYPE_LINUX_KERNEL
108 #include <linux/string.h>
109 #else
110 #include <string.h>
111 #endif
112 #include "MsCommon.h"
113 #include "MsVersion.h"
114 #include "drvMMIO.h"
115 #include "drvSYS.h"
116 #include "regHDMITx.h"
117 #include "halHDMIUtilTx.h"
118 #include "halHDMITx.h"
119 #include "halHDCPTx.h"
120 #include "drvHDMITx.h"
121
122 //#include <bigd.h>
123
124 #include "MsDevice.h"
125
126 #include "apiHDMITx.h"
127 #include "utopia_dapi.h"
128
129 #include "utopia.h"
130 #include "HDMITX_private.h"
131
132 //-------------------------------------------------------------------------------------------------
133 // Driver Compiler Options
134 //-------------------------------------------------------------------------------------------------
135
136
137 //-------------------------------------------------------------------------------------------------
138 // Local Defines
139 //-------------------------------------------------------------------------------------------------
140
141
142 #define HDMITX_TASK_STACK_SIZE 4096UL
143 //#define HDCPTX_TASK_STACK_SIZE 4096UL //wilson@kano
144
145 #define HDMITX_MUTEX_TIMEOUT 2000UL ///< The maximum timeout
146 #define HDMITX_MONITOR_DELAY 50UL
147
148 #define HDCPTX_MONITOR_DELAY 10UL //wilson@kano
149
150
151 #define USE_INTERNAL_HDCP_KEY 1UL // Use internal HDCP key
152 #define USE_AUTO_GEN_AN 1UL // Use auto An generator
153 #define CheckRx_Timer 100UL // Check Rx HPD and TMDS clock status
154
155 /*
156 * HDCP CTS 1A-01: NOT JUDGED
157 * Refine timing to fix Ri Timer expired issue: Inactivity timer expired.
158 */
159 #define HDCP_1ST_RiCheck_Timer 100UL //2600 // Check HDCP Ri value in both of Rx and Tx sides
160 #define HDCP_RiCheck_Timer 500UL //2600 // Check HDCP Ri value in both of Rx and Tx sides
161
162 //In Test Instrument, Quantumdata882, it read each DDC step with 30ms sample periods
163 //While doing SEC Compatibility Test, we find some REPEATER need enlarge sample rate to above 20ms to avoid timeout problem (YAMAHA RX-V2700)
164 //In SEC Compatibility Test, another repeater face RX Ri freeze after auth done. Enlarge sample rate to 125ms to avoid problem (YAMAHA RX-V467)
165 #define HDCP_DDC_SAMPLE_PERIOD 125UL //20//10 //SEC Compatibility Test (YAMAHA RX-V2700)(YAMAHA RX-V467)
166
167 #define HDCP14TX_R0_WDT 100UL //wilson@kano 100 ms
168 #define HDCP14TX_BSTATUS_TIMEOUT_CNT 9000UL //according to QD886 log, it require 9second polling bstatus //600UL //wilson@kano
169 #define HDCP14TX_REP_RDY_BIT_WDT 5000UL //wilson@kano 5sec
170
171
172 //-------------------------------------------------------------------------------------------------
173 // Local Structures
174 //-------------------------------------------------------------------------------------------------
175 #if 0
176 typedef struct {
177 BIGD p, q, g, x, y;
178 } dsa_context;
179 #endif
180 //-------------------------------------------------------------------------------------------------
181 // Global Variables
182 //-------------------------------------------------------------------------------------------------
183 static MsHDMITX_RX_STATUS gbCurRxStatus = E_HDMITX_DVIClock_L_HPD_L;
184
185 //MDrvHDMITX_PARAMETER_LIST gHDMITxInfo;
186 //MDrvHdcpTx_PARAMETER_LIST gHdcpTxInfo;
187
188 MsHDMITX_INTERRUPT_TYPE gHDMITXIRQ = E_HDMITX_IRQ_12|E_HDMITX_IRQ_10; // HPD and Clock disconnect
189 MS_U8 gRepeaterFailTime = 0; // for MAX_CASCADE_EXCEEDED and MAX_DEVS_EXCEEDED
190 MS_U32 gRepeaterStartTime = 0; // for MAX_CASCADE_EXCEEDED and MAX_DEVS_EXCEEDED
191 MS_U16 gHDCPCheckRiTimer = HDCP_RiCheck_Timer;//2600;
192 MS_BOOL g_bDisableRegWrite = FALSE;
193 MS_BOOL g_bDisableTMDSCtrl = FALSE;
194
195 MS_BOOL g_bDisableVSInfo = TRUE;
196
197 MS_BOOL g_bHDMITxTask = TRUE;
198 MS_BOOL g_bHdcpTxTask = TRUE; //wilson@kano
199
200 ///MS_BOOL g_bHDCPRxValid = TRUE; //E_HDMITX_HDCP_RX_IS_NOT_VALID //E_HDMITX_HDCP_RX_IS_VALID //wilson@kano
201 static MS_U32 gdwPreTime = 0; //wilson@kano
202 static MS_U32 gdwCurTime = 0; //wilson@kano
203
204 MsHDMITX_RX_STATUS _hdmitx_preRX_status = E_HDMITX_DVIClock_L_HPD_L;
205
206 //-------------------------------------------------------------------------------------------------
207 // Local Variables
208 //-------------------------------------------------------------------------------------------------
209 //wilson@kano
210 MS_U8 g_u8Bstatus[2] = {0x00};
211 MS_U8 g_u8KSVList[635] = {0x00};
212 MS_BOOL g_bValidKSVList = FALSE;
213 static MS_U8 g_u8SupTimingNum = 0;
214
215 const MS_U8 VSDB_HDMI_IEEE_ID[3] =
216 {
217 0x03, 0x0C, 0x00
218 };
219 //wilson@kano
220 const MS_U8 HFVSDB_HDMI_IEEE_ID[3] =
221 {
222 0xD8, 0x5D, 0xC4
223 };
224
225
226 static void *_pHDMITxTaskStack;
227 static MS_S32 _s32HDMITxTaskId = -1;
228 static MS_S32 _s32HDMITxEventId;
229 static MS_U8 _u8HDMITx_StackBuffer[HDMITX_TASK_STACK_SIZE];
230
231 //wilson@kano
232 #if 0
233 static void *_pHdcpTxTaskStack;
234 static MS_S32 _s32HdcpTxTaskId = -1;
235 static MS_S32 _s32HdcpTxEventId;
236 static MS_U8 _u8HdcpTx_StackBuffer[HDCPTX_TASK_STACK_SIZE];
237 #endif
238 //wilson@kano
239
240
241 static MS_S32 _s32CheckRxTimerId = -1;
242 static MS_S32 _s32HDCPRiTimerId = -1;
243
244 static MS_U32 _u32Aksv2RoInterval = 150;
245
246
247 MS_U8 HDMITX_EdidHeaderTbl[] =
248 {
249 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
250 };
251
252 MS_U8 HDMITX_IEEEHdmiIdTbl[] =
253 {
254 0x03, 0x0C, 0x00,
255 };
256
257 #define HDMITX_DRV_VERSION /* Character String for DRV/API version */ \
258 MSIF_TAG, /* 'MSIF' */ \
259 MSIF_CLASS, /* '00' */ \
260 MSIF_CUS, /* 0x0000 */ \
261 MSIF_MOD, /* 0x0000 */ \
262 MSIF_CHIP, \
263 MSIF_CPU, \
264 {'P','Q','_','_'}, /* IP__ */ \
265 {'0','0'}, /* 0.0 ~ Z.Z */ \
266 {'0','0'}, /* 00 ~ 99 */ \
267 {'0','0','1','1','5','1','5','7'}, /* CL# */ \
268 MSIF_OS
269
270 /// Debug information
271 static MSIF_Version _drv_hdmi_tx_version = {.DDI = { HDMITX_DRV_VERSION },};
272 static MS_HDMI_TX_INFO _info =
273 {
274 // TODO: ADD hdmi tx related info here.
275 };
276 static MS_HDMI_TX_Status _hdmitx_status = {.bIsInitialized = FALSE, .bIsRunning = FALSE,};
277 //static MS_HDCP_TX_Status _hdcptx_status = {.bIsInitialized = FALSE, .bIsRunning = FALSE,};
278
279
280 #ifdef MS_DEBUG
281 static MS_U16 _u16DbgHDMITXSwitch = HDMITX_DBG|HDMITX_DBG_HDCP;
282 #else
283 static MS_U16 _u16DbgHDMITXSwitch = 0x00;
284 #endif
285
286 MS_BOOL bCheckEDID = TRUE; // Check EDID only when HPD from low to high
287
288 //-------------------------------------------------------------------------------------------------
289 // Debug Functions
290 //-------------------------------------------------------------------------------------------------
291
292 #define DBG_HDMITX(_f) do{ if(_u16DbgHDMITXSwitch & HDMITX_DBG) (_f); } while(0);
293 #define DBG_HDCP(_f) do{ if(_u16DbgHDMITXSwitch & HDMITX_DBG_HDCP) (_f); } while(0);
294
295 //-------------------------------------------------------------------------------------------------
296 // Local Functions
297 //-------------------------------------------------------------------------------------------------
298
299 //extern MS_BOOL MDrv_EEPROM_Write(MS_U32 u32Addr, MS_U8 *pu8Buf, MS_U32 u32Size);
MDrv_EEPROM_Read(MS_U32 u32Addr,MS_U8 * pu8Buf,MS_U32 u32Size)300 MS_BOOL MDrv_EEPROM_Read(MS_U32 u32Addr, MS_U8 *pu8Buf, MS_U32 u32Size)
301 {
302 return TRUE;
303 }
304
305 //------------------------------------------------------------------------------
306 /// @brief Set event of HDMI ISR
307 /// @param None
308 /// @return None
309 //------------------------------------------------------------------------------
310 #ifdef MSOS_TYPE_LINUX_KERNEL
_HDMITx_Isr(InterruptNum eIntNum)311 static void _HDMITx_Isr(InterruptNum eIntNum)//irqreturn_t _HDMITx_Isr(InterruptNum eIntNum, void* dev_id)
312 {
313 //Wilson:undercheck, remove argument #2 to avoid build warning
314 MS_U32 irq_status;
315 eIntNum = eIntNum; // prevent compile warning
316
317 //Clear Interrupt Bit
318 irq_status = MHal_HDMITx_Int_Status();
319 if(irq_status & E_HDMITX_IRQ_12) // TMDS hot-plug
320 {
321 MHal_HDMITx_Int_Clear(E_HDMITX_IRQ_12);
322 }
323 else if(irq_status & E_HDMITX_IRQ_10) // Rx disconnection
324 {
325 MHal_HDMITx_Int_Clear(E_HDMITX_IRQ_10);
326 }
327
328 MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_IRQ);
329 //return IRQ_HANDLED;
330 }
331
332 #if 0 //ENABLE_CEC_INT
333 irqreturn_t _HDMITX_CEC_RxIsr(InterruptNum eIntNum, void* dev_id)
334 {
335 eIntNum = eIntNum; // prevent compile warning
336
337 MDrv_CEC_RxChkBuf();
338 MsOS_EnableInterrupt(E_INT_IRQ_CEC);
339
340 MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_CECRX);
341 return IRQ_HANDLED;
342 }
343 #endif // ENABLE_CEC_INT
344
345 #else
346
_HDMITx_Isr(InterruptNum eIntNum)347 static void _HDMITx_Isr(InterruptNum eIntNum)
348 {
349 MS_U32 irq_status;
350 //eIntNum = eIntNum; // prevent compile warning
351 DBG_HDCP(printf("_HDMITx_Isr!!! %d \r\n", eIntNum)); // Fix coverity impact.
352
353 //Clear Interrupt Bit
354 irq_status = MHal_HDMITx_Int_Status();
355 if(irq_status & E_HDMITX_IRQ_12) // TMDS hot-plug
356 {
357 MHal_HDMITx_Int_Clear(E_HDMITX_IRQ_12);
358 }
359 else if(irq_status & E_HDMITX_IRQ_10) // Rx disconnection
360 {
361 MHal_HDMITx_Int_Clear(E_HDMITX_IRQ_10);
362 }
363 MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_IRQ);
364 }
365
366 #if 0 //ENABLE_CEC_INT
367 static void _HDMITX_CEC_RxIsr(InterruptNum eIntNum)
368 {
369 //eIntNum = eIntNum; // prevent compile warning
370 DBG_HDCP(printf("_HDMITX_CEC_RxIsr!!! %d \r\n", eIntNum)); // Fix coverity impact.
371
372 MDrv_CEC_RxChkBuf();
373 MsOS_EnableInterrupt(E_INT_IRQ_CEC);
374
375 MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_CECRX);
376 }
377 #endif // ENABLE_CEC_INT
378
379 #endif
380
381 //**************************************************************************
382 // [Function Name]:
383 // MDrv_HDMITx_Get_Semaphore()
384 // [Description]:
385 // get hdmi tx semaphore
386 // [Arguments]:
387 // [void] *pInstances
388 // [Return]:
389 // MS_U32
390 //
391 //**************************************************************************
MDrv_HDMITx_Get_Semaphore(void * pInstance)392 MS_U32 MDrv_HDMITx_Get_Semaphore(void *pInstance)
393 {
394 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
395
396 if (pInstance == NULL)
397 {
398 printf("[%s,%5d]No instance existed, please get an instance by calling HDMITx() first\n",__FUNCTION__,__LINE__);
399 return u32Return;
400 }
401
402 HDMITX_INSTANCE_PRIVATE *psHDMITXInstPri = NULL;
403 UtopiaInstanceGetPrivate(pInstance, (void**)&psHDMITXInstPri);
404
405 if (psHDMITXInstPri->u32DeviceID>= E_HDMITX_POOL_ID_MAX)
406 {
407 printf("[%s,%5d] Unknown HDMITX Pool ID\n",__func__, __LINE__);
408 return u32Return;
409 }
410
411 void* pModule = NULL;
412 UtopiaInstanceGetModule(pInstance, &pModule);
413 if(UtopiaResourceObtain(pModule, psHDMITXInstPri->u32DeviceID, &pu32HDMITXRes[psHDMITXInstPri->u32DeviceID]) != UTOPIA_STATUS_SUCCESS)
414 {
415 printf("UtopiaResourceObtain fail\n");
416 return UTOPIA_STATUS_ERR_RESOURCE;
417 }
418 u32Return = UTOPIA_STATUS_SUCCESS;
419 return u32Return;
420 }
421
422 //**************************************************************************
423 // [Function Name]:
424 // MDrv_HDMITx_Release_Semaphore()
425 // [Description]:
426 // Release hdmi tx semaphore
427 // [Arguments]:
428 // [void] *pInstances
429 // [Return]:
430 // MS_U32
431 //
432 //**************************************************************************
MDrv_HDMITx_Release_Semaphore(void * pInstance)433 MS_U32 MDrv_HDMITx_Release_Semaphore(void *pInstance)
434 {
435 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
436
437 HDMITX_INSTANCE_PRIVATE *psHDMITXInstPri = NULL;
438 UtopiaInstanceGetPrivate(pInstance, (void**)&psHDMITXInstPri);
439 if (psHDMITXInstPri->u32DeviceID >= E_HDMITX_POOL_ID_MAX)
440 {
441 printf("[%s,%5d] Unknown HDMITX Pool ID\n",__func__, __LINE__);
442 return u32Return;
443 }
444
445 u32Return = UtopiaResourceRelease(pu32HDMITXRes[psHDMITXInstPri->u32DeviceID]);
446 return u32Return;
447 }
448
449
450 //**************************************************************************
451 // [Function Name]:
452 // _MDrv_HDCP_StopRiTimer()
453 // [Description]:
454 // stop Ri timer
455 // [Arguments]:
456 // void
457 // [Return]:
458 // void
459 //
460 //**************************************************************************
_MDrv_HDCPTx_StopRiTimer(void)461 void _MDrv_HDCPTx_StopRiTimer(void)
462 {
463 if(_s32HDCPRiTimerId > 0)
464 {
465 MsOS_StopTimer(_s32HDCPRiTimerId);
466 }
467 }
468
469 /*********************************************************************/
470 /* */
471 /* Sorting HDCP Tx function here */
472 /* */
473 /*********************************************************************/
____HdcpTx_Relative_Func____(void)474 void ____HdcpTx_Relative_Func____(void){} //Null function for navigation
475
476 /*********************************************************************/
477 /* */
478 /* HDCP22 Relative */
479 /* */
480 /*********************************************************************/
MDrv_HDMITx_HDCP2AccessX74(MS_U8 u8PortIdx,MS_U8 u8OffsetAddr,MS_U8 u8OpCode,MS_U8 * pu8RdBuf,MS_U8 * pu8WRBuff,MS_U16 u16RdLen,MS_U16 u16WRLen)481 MS_BOOL MDrv_HDMITx_HDCP2AccessX74(MS_U8 u8PortIdx, MS_U8 u8OffsetAddr, MS_U8 u8OpCode, MS_U8 *pu8RdBuf, MS_U8 *pu8WRBuff, MS_U16 u16RdLen, MS_U16 u16WRLen)
482 {
483 MS_BOOL bRet = FALSE;
484
485 //printf("[HDCP2Tx]PrtIdx = %d, Offset : 0x%02X, OpCode : %d, Data Len = 0x%X\r\n", u8PortIdx, u8OffsetAddr, u8OpCode, (u8OpCode == 0x01) ? u16RdLen : u16WRLen);
486 switch (u8OffsetAddr)
487 {
488 case 0x50: //HDCP2Version
489 bRet = MHal_HDMITx_Rx74ReadByte(u8OffsetAddr, pu8RdBuf);
490 break;
491
492 case 0x60: //Write_Message
493 bRet = MHal_HDMITx_Rx74WriteBytes(u8OffsetAddr, u16WRLen, pu8WRBuff);
494 break;
495
496 case 0x70: //RxStatus
497 bRet = MHal_HDMITx_Rx74ReadBytes(u8OffsetAddr, (u16RdLen > 0x02) ? 0x02 : u16RdLen, pu8RdBuf);
498 break;
499
500 case 0x80:
501 bRet = MHal_HDMITx_Rx74ReadBytes(u8OffsetAddr, u16RdLen, pu8RdBuf);
502 break;
503
504 case 0xC0:
505 if (u8OpCode == 0x01)
506 bRet = MHal_HDMITx_Rx74ReadBytes(u8OffsetAddr, u16RdLen, pu8RdBuf);
507 else
508 bRet = MHal_HDMITx_Rx74WriteBytes(u8OffsetAddr, u16WRLen, pu8WRBuff);
509 break;
510
511 default:
512 if (u8OpCode == E_HDCP2_OPCODE_READ)
513 {
514 bRet = MHal_HDMITx_Rx74ReadBytes(u8OffsetAddr, u16RdLen, pu8RdBuf);
515 }
516 else
517 {
518 bRet = MHal_HDMITx_Rx74WriteBytes(u8OffsetAddr, u16WRLen, pu8WRBuff);
519 }
520 break;
521 }
522
523 return bRet;
524 }
525
MDrv_HDMITx_HDCP2TxInit(MS_U8 u8PortIdx,MS_BOOL bEnable)526 void MDrv_HDMITx_HDCP2TxInit(MS_U8 u8PortIdx, MS_BOOL bEnable)
527 {
528 MHal_HDMITx_HDCP2TxInit(bEnable);
529 }
530
MDrv_HDMITx_HDCP2TxEnableEncryptEnable(MS_U8 u8PortIdx,MS_BOOL bEnable)531 void MDrv_HDMITx_HDCP2TxEnableEncryptEnable(MS_U8 u8PortIdx, MS_BOOL bEnable)
532 {
533 MHal_HDMITx_HDCP2TxEnableEncryptEnable(bEnable);
534 }
535
MDrv_HDMITx_HDCP2TxFillCipherKey(MS_U8 u8PortIdx,MS_U8 * pu8Riv,MS_U8 * pu8KsXORLC128)536 void MDrv_HDMITx_HDCP2TxFillCipherKey(MS_U8 u8PortIdx, MS_U8 *pu8Riv, MS_U8 *pu8KsXORLC128)
537 {
538 MHal_HDMITx_HDCP2TxFillCipherKey(pu8Riv, pu8KsXORLC128);
539 }
540
541 //------------------------------------------------------------------------------
542 /// @brief This routine is to HDCP check repeater function
543 /// @return authentication status
544 //------------------------------------------------------------------------------
_MDrv_HDCPTx_CheckRepeater(void)545 MsHDMITX_HDCP_AUTH_STATUS _MDrv_HDCPTx_CheckRepeater(void)
546 {
547 MS_U16 i, j;
548 MS_U8 count;
549 MS_U8 testbyte[635], bstatus[2];
550 SHA1_DATA test_dig;
551 MS_U8 check_error = 0;
552 MS_U16 reg_value;
553 MS_U8 tempV[20];
554 MS_U32 u32DDCDelay = 0;
555
556 MHal_HDMITx_HdcpSha1Init(&test_dig);
557
558 DBG_HDCP(printf("Repeater is ready!!!\r\n"));
559
560 // read ksv list
561 #if 0
562 if(MHal_HDMITx_Rx74ReadByte(0x41, &count) == FALSE)
563 {
564 DBG_HDCP(printf("HDCP check repeater failed because I2C\r\n"));
565 return E_HDMITX_HDCP_REPEATER_SHA1_FAIL;
566 }
567 count &= 0x7F;
568 #else
569 if(MHal_HDMITx_Rx74ReadBytes(0x41, 2, bstatus) == FALSE)
570 {
571 DBG_HDCP(printf("HDCP check repeater failed because I2C\r\n"));
572 return E_HDMITX_HDCP_REPEATER_SHA1_FAIL;
573 }
574
575 memcpy(g_u8Bstatus, bstatus, sizeof(bstatus));
576
577 if((bstatus[0] & 0x80) || (bstatus[1] & 0x08)) // "MAX_DECS_EXCEEDED" or "MAX_CASCADE_EXCEEDED"
578 {
579 return E_HDMITX_HDCP_REPEATER_SHA1_FAIL;
580 }
581 count = bstatus[0];
582
583 #endif
584
585 if(count)
586 {
587 if (count > 16)
588 {
589 //Store original delay count
590 u32DDCDelay = MHal_HDMITx_GetDDCDelayCount();
591 MHal_HDMITx_AdjustDDCFreq(100); //speed-up to 100KHz
592 }
593
594 if(MHal_HDMITx_Rx74ReadBytes(0x43, 5*count, (MS_U8 *)testbyte) == FALSE)
595 {
596 DBG_HDCP(printf("HDCP check repeater failed because I2C\r\n"));
597 return E_HDMITX_HDCP_REPEATER_SHA1_FAIL;
598 }
599
600 if (count > 16)
601 {
602 //Set original delay count
603 MHal_HDMITx_SetDDCDelayCount(u32DDCDelay);
604 }
605
606 memcpy(g_u8KSVList, testbyte, 5*count);
607 g_bValidKSVList = TRUE;
608 }
609 DBG_HDCP(printf("KSV List:(=%d) ", count));
610 if(count)
611 {
612 for (j = 0; j < 5*count; j++)
613 DBG_HDCP(printf("0x%x, ", testbyte[j]));
614 DBG_HDCP(printf("\r\n"));
615 MHal_HDMITx_HdcpSha1AddData(&test_dig, testbyte, 5*count);
616 }
617 // read Bstatus (2 bytes)
618 if(MHal_HDMITx_Rx74ReadBytes(0x41, 2, (MS_U8 *) testbyte) == FALSE)
619 {
620 DBG_HDCP(printf("HDCP check repeater failed because I2C\r\n"));
621 return E_HDMITX_HDCP_REPEATER_SHA1_FAIL;
622 }
623 MHal_HDMITx_HdcpSha1AddData(&test_dig, testbyte, 2);
624
625 // read M0 (8 byte)
626 for (i = 0; i < 4; i++)
627 {
628 reg_value = MHal_HDMITX_GetM02Bytes(i);
629 testbyte[2*i] = (MS_U8)(reg_value & 0x00FF);
630 testbyte[2*i+1] = (MS_U8)((reg_value & 0xFF00) >> 8);
631 // DBG_HDCP(printf(DBG_HDCP, "0x%x, ", testbyte[i]);
632 }
633
634 MHal_HDMITx_HdcpSha1AddData(&test_dig, testbyte, 8);
635 MHal_HDMITx_HdcpSha1FinalDigest(&test_dig, testbyte);
636
637 //print out SHA1 encode result
638 DBG_HDCP(printf("SHA1 encode result(V)=: "));
639 for (i = 0; i < 20; i++)
640 DBG_HDCP(printf("0x%x, ", testbyte[i]));
641 DBG_HDCP(printf("\r\n"));
642
643 DBG_HDCP(printf("V'=: "));
644
645 /*
646 * [HDCP] 1A-01, 1B-01a: DUT kept HDCP encryption even though it did not read V' completely
647 */
648 if( MHal_HDMITx_Rx74ReadBytes(0x20, 20, tempV) == FALSE)
649 {
650 DBG_HDCP(printf("HDCP check repeater failed because I2C\r\n"));
651 return E_HDMITX_HDCP_REPEATER_SHA1_FAIL;
652 }
653
654 for (i = 0; i < 20; i++)
655 {
656 DBG_HDCP(printf("0x%x, ", tempV[i]));
657 if (tempV[i] != testbyte[i])
658 check_error = 1;
659 }
660
661 DBG_HDCP(printf("\r\n"));
662
663 return ((check_error == 0) ? E_HDMITX_HDCP_REPEATER_SHA1_PASS: E_HDMITX_HDCP_REPEATER_SHA1_FAIL);
664 }
665
666 //------------------------------------------------------------------------------
667 /// @brief This routine is to HDCP check Ri function
668 /// @return authentication status
669 //------------------------------------------------------------------------------
_MDrv_HDCPTX_AuthCheckRi(void)670 MsHDMITX_HDCP_AUTH_STATUS _MDrv_HDCPTX_AuthCheckRi(void)
671 {
672 MS_U16 ptx_ri = 0, prx_ri = 0; // Fix coverity impact.
673
674 if (MHal_HDMITx_HdcpCheckRi(&ptx_ri, &prx_ri) == TRUE)
675 {
676 //DBG_HDCP(printf("\nKey match: tx_ri= 0x%x, rx_ri= 0x%x\n", ptx_ri, prx_ri));
677 return E_HDMITX_HDCP_SYNC_RI_PASS;
678 }
679 else
680 {
681 DBG_HDCP(printf("Tx_Ri=%x, Rx_Ri=%x\n", ptx_ri, prx_ri));
682 return E_HDMITX_HDCP_SYNC_RI_FAIL;
683 }
684 }
685
686 //-------------------------------------------------------------------------------------------------
687 // HDCP Ri timer callback
688 // @param stTimer \b IN: Useless
689 // @param u32Data \b IN: Useless
690 // @return None
691 //-------------------------------------------------------------------------------------------------
_MDrv_HDMITX_HDCP_Ri_TimerCallback(MS_U32 stTimer,MS_U32 u32Data)692 static void _MDrv_HDMITX_HDCP_Ri_TimerCallback(MS_U32 stTimer, MS_U32 u32Data)
693 {
694 MsOS_SetEvent(_s32HDMITxEventId, E_HdcpTX_EVENT_RITIMER); //wilson@kano
695 }
696
697 /*
698 * [HDCP] 1A and 1B: AKSV -> Ro should be large than 100msec
699 * to pass Quantumdata 882 HDCP test, we delay 150ms
700 *
701 * 2013/11/07, in SEC Compatibility test, we meet an Repeater timeout error on PEPEATER YAMAHA RX-V2700
702 * patch AKSV -> Ro large than 250ms
703 */
MDrv_HDCPTx_SetAksv2R0Interval(MS_U32 u32Interval)704 void MDrv_HDCPTx_SetAksv2R0Interval(MS_U32 u32Interval)
705 {
706 _u32Aksv2RoInterval = u32Interval;
707 }
708
709 //------------------------------------------------------------------------------
710 /// @brief This routine is to HDCP waiting for the active Rx
711 /// @return authentication status
712 //------------------------------------------------------------------------------
_MDrv_HDCPTx_AuthWaitingActiveRx(void)713 MsHDMITX_HDCP_AUTH_STATUS _MDrv_HDCPTx_AuthWaitingActiveRx(void)
714 {
715 MHal_HDMITx_HdcpInit();
716 if (!MHal_HDMITx_HdcpRxActive())
717 {
718 return E_HDMITX_HDCP_RX_IS_NOT_VALID; // not active
719 }
720
721 return E_HDMITX_HDCP_RX_IS_VALID; // active Rx
722 }
723
724
725 //------------------------------------------------------------------------------
726 /// @brief This routine is to HDCP check whether repeater is ready or not
727 /// @return authentication status
728 //------------------------------------------------------------------------------
_MDrv_HDCPTx_AuthCheckRepeaterReady(void)729 MsHDMITX_HDCP_AUTH_STATUS _MDrv_HDCPTx_AuthCheckRepeaterReady(void)
730 {
731 MS_U8 regval;
732
733 if(MHal_HDMITx_Rx74ReadByte(0x40, ®val) == TRUE)
734 {
735 if(regval & BIT5)
736 return E_HDMITX_HDCP_REPEATER_READY; // ready
737 }
738 return E_HDMITX_HDCP_REPEATER_NOT_READY; // not ready
739 }
740
741
742 //**************************************************************************
743 // [Function Name]:
744 // _MDrv_HDCP_GetTimeDiff()
745 // [Description]:
746 // calculate timer difference
747 // [Arguments]:
748 // [MS_U32] dwPreTime
749 // [MS_U32] dwPostTime
750 // [Return]:
751 // MS_U32
752 //
753 //**************************************************************************
_MDrv_HDCP_GetTimeDiff(MS_U32 dwPreTime,MS_U32 dwPostTime)754 MS_U32 _MDrv_HDCP_GetTimeDiff(MS_U32 dwPreTime, MS_U32 dwPostTime)
755 {
756 if (dwPreTime > dwPostTime)
757 {
758 return (dwPreTime + (~dwPostTime));
759 }
760 else
761 {
762 return (dwPostTime - dwPreTime);
763 }
764 }
765
766 //------------------------------------------------------------------------------
767 /// @brief This routine is to check HDCP sync setting
768 /// @return None
769 //------------------------------------------------------------------------------
_MDrv_HDCPTx_HdcpSyncSetting(void * pInstance,MsHDMITX_OUTPUT_MODE tmds_mode)770 MS_BOOL _MDrv_HDCPTx_HdcpSyncSetting(void* pInstance, MsHDMITX_OUTPUT_MODE tmds_mode)
771 {
772 MS_U8 temp, regval = 0; // Fix coverity impact.
773 MS_U8 tx_mode = 0;
774 MS_BOOL tmp = 0; // Fix coverity impact.
775
776 //Check Bcaps
777 if(MHal_HDMITx_Rx74ReadByte(0x40, &temp) == FALSE)
778 return FALSE;
779
780 // EESS/OESS, advance cipher
781 if (tmds_mode & BIT1)
782 {
783 tx_mode |= BIT2; // EESS
784
785 if (temp & BIT1)
786 {
787 tx_mode |= BIT3;
788 tmp = MHal_HDMITx_Rx74WriteByte(0x15, 0x02);
789 tmp = MHal_HDMITx_Rx74ReadByte(0x15, ®val);
790 DBG_HDCP(printf("HDMI Advanced Cipher!!! %d \r\n", regval))
791 }
792 }
793 else //DVI
794 {
795 if(temp & BIT1)
796 {
797 tx_mode |= BIT2;
798 tx_mode |= BIT3;
799 tmp = MHal_HDMITx_Rx74WriteByte(0x15,0x02);
800 DBG_HDCP(printf("Tx select EESS and enable Advance Cipher!!\r\n"));
801 }
802 }
803
804 _HDMITX_GET_VARIABLE();
805
806 // Repeater mode?
807 psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpCheckRepeater_flag = FALSE;
808 if (temp & BIT6)
809 {
810 tx_mode |= BIT1;
811 psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpCheckRepeater_flag = TRUE;
812 DBG_HDCP(printf("Rx is a Repeater!!!\r\n"));
813 }
814 MHal_HDMITX_SetHDCPConfig(tx_mode);
815 tmp = TRUE;
816 return tmp;
817 }
818
819 //------------------------------------------------------------------------------
820 /// @brief This routine set HDMI Tx initial situation.
821 /// @return None
822 //------------------------------------------------------------------------------
MDrv_HDCPTx_InitVariable(void * pInstance)823 void MDrv_HDCPTx_InitVariable(void *pInstance)
824 {
825 _HDMITX_GET_VARIABLE();
826
827 psHDMITXResPri->stHdcpTxInfo.hdcp_Rx_valid = FALSE;
828
829 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
830 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_IDLE;
831 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_IDLE;
832
833 psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpUseInternalKey_flag = TRUE;
834 psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpStartAuth_flag = FALSE;
835 psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpAuthDone_flag = FALSE;
836 psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpCheckRepeater_flag = FALSE;
837
838 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_RESET;
839 psHDMITXResPri->stHdcpTxInfo.hdmitx_unHDCPRx_Control = E_NORMAL_OUTPUT;
840 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPRxFail_Control = E_RXFail_NORMAL_OUTPUT;
841
842 psHDMITXResPri->stHdcpTxInfo.revocationlist_ready = FALSE;
843 psHDMITXResPri->stHdcpTxInfo.revocation_size = 0;
844 psHDMITXResPri->stHdcpTxInfo.revocation_state = E_CHECK_NOT_READY;
845 psHDMITXResPri->stHdcpTxInfo.HDCP_74_check = FALSE;
846
847 // HDCP init
848 MHal_HDMITx_HdcpDebugEnable(_u16DbgHDMITXSwitch & HDMITX_DBG_HDCP ? TRUE : FALSE);
849
850 if (psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpUseInternalKey_flag == TRUE)
851 {
852 MHal_HDMITx_HdcpKeyInit(USE_INTERNAL_HDCP_KEY);
853 }
854
855 memset(g_u8Bstatus, 0x00, sizeof(g_u8Bstatus));
856 memset(g_u8KSVList, 0x00, sizeof(g_u8KSVList));
857 g_bValidKSVList = FALSE;
858
859 }
860
861
862 //**************************************************************************
863 // [Function Name]:
864 // MDrv_HDCPTx_SetAuthStartFlag()
865 // [Description]:
866 // Set hdcp14 Authentication Start flag
867 // [Arguments]:
868 // [MS_BOOL] bFlag
869 // [Return]:
870 // void
871 //
872 //**************************************************************************
MDrv_HDCPTx_SetAuthStartFlag(void * pInstance,MS_BOOL bFlag)873 void MDrv_HDCPTx_SetAuthStartFlag(void* pInstance, MS_BOOL bFlag)
874 {
875 _HDMITX_GET_VARIABLE();
876
877 psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpStartAuth_flag = bFlag;
878 }
879
880 //**************************************************************************
881 // [Function Name]:
882 // MDrv_HDCPTx_SetAuthDoneFlag()
883 // [Description]:
884 // Set HDCP14 Authentication done flag
885 // [Arguments]:
886 // [MS_BOOL] bFlag
887 // [Return]:
888 // void
889 //
890 //**************************************************************************
MDrv_HDCPTx_SetAuthDoneFlag(void * pInstance,MS_BOOL bFlag)891 void MDrv_HDCPTx_SetAuthDoneFlag(void* pInstance, MS_BOOL bFlag)
892 {
893 _HDMITX_GET_VARIABLE();
894
895 psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpAuthDone_flag = bFlag;
896 }
897
898 //**************************************************************************
899 // [Function Name]:
900 // MDrv_HDCPTx_SetRxValid()
901 // [Description]:
902 // Set Rx status
903 // [Arguments]:
904 // [MS_BOOL] bIsRxValid
905 // [Return]:
906 // void
907 //**************************************************************************
MDrv_HDCPTx_SetRxValid(void * pInstance,MS_BOOL bIsRxValid)908 void MDrv_HDCPTx_SetRxValid(void* pInstance, MS_BOOL bIsRxValid) //wilson@kano
909 {
910 _HDMITX_GET_VARIABLE();
911 psHDMITXResPri->stHdcpTxInfo.hdcp_Rx_valid = bIsRxValid;
912 }
913
914 //**************************************************************************
915 // [Function Name]:
916 // MDrv_HDCPTx_SetFSMState()
917 // [Description]:
918 // Set hdcp14 FSM state
919 // [Arguments]:
920 // [enHDCP14Tx_MainStates] enMainState
921 // [enHDCP14Tx_SubStates] enSubState
922 // [Return]:
923 // void
924 //**************************************************************************
MDrv_HDCPTx_SetFSMState(void * pInstance,enHDCP14Tx_MainStates enMainState,enHDCP14Tx_SubStates enSubState)925 void MDrv_HDCPTx_SetFSMState(void* pInstance, enHDCP14Tx_MainStates enMainState, enHDCP14Tx_SubStates enSubState) //wilson@kano
926 {
927 _HDMITX_GET_VARIABLE();
928 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = enMainState;
929 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = enSubState;
930 }
931
932 //**************************************************************************
933 // [Function Name]:
934 // MDrv_HDCPTx_SetUnHDCPRxCtrl()
935 // [Description]:
936 // set signal control mode when hdcp function is not enabled
937 // [Arguments]:
938 // [MDrvHDMITX_UNHDCPRX_CONTROL] enUnHDCPCtrl
939 // [Return]:
940 // void
941 //
942 //**************************************************************************
MDrv_HDCPTx_SetUnHDCPRxCtrl(void * pInstance,MDrvHDMITX_UNHDCPRX_CONTROL enUnHDCPCtrl)943 void MDrv_HDCPTx_SetUnHDCPRxCtrl(void* pInstance, MDrvHDMITX_UNHDCPRX_CONTROL enUnHDCPCtrl)
944 {
945 _HDMITX_GET_VARIABLE();
946 psHDMITXResPri->stHdcpTxInfo.hdmitx_unHDCPRx_Control = enUnHDCPCtrl;
947 }
948
949 //**************************************************************************
950 // [Function Name]:
951 // MDrv_HDCPTx_SetHDCPRxFailCtrl()
952 // [Description]:
953 // set signal control mode when hdcp function is failed
954 // [Arguments]:
955 // [MDrvHDMITX_UNHDCPRX_CONTROL] enUnHDCPCtrl
956 // [Return]:
957 // void
958 //
959 //**************************************************************************
MDrv_HDCPTx_SetHDCPRxFailCtrl(void * pInstance,MDrvHDMITX_UNHDCPRX_CONTROL enUnHDCPCtrl)960 void MDrv_HDCPTx_SetHDCPRxFailCtrl(void* pInstance, MDrvHDMITX_UNHDCPRX_CONTROL enUnHDCPCtrl)
961 {
962 _HDMITX_GET_VARIABLE();
963 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPRxFail_Control = enUnHDCPCtrl;
964 }
965
966 //**************************************************************************
967 // [Function Name]:
968 // MDrv_HDCPTx_GetAuthStartFlag()
969 // [Description]:
970 // Get hdcp14 Authentication Start flag
971 // [Arguments]:
972 // void
973 // [Return]:
974 // [MS_BOOL]
975 //
976 //**************************************************************************
MDrv_HDCPTx_GetAuthStartFlag(void * pInstance)977 MS_BOOL MDrv_HDCPTx_GetAuthStartFlag(void* pInstance) //wilson@kano
978 {
979 _HDMITX_GET_VARIABLE();
980 return psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpStartAuth_flag;
981 }
982
983 //**************************************************************************
984 // [Function Name]:
985 // MDrv_HDCPTx_GetAuthDoneFlag()
986 // [Description]:
987 // Get HDCP14 Authentication done flag
988 // [Arguments]:
989 // void
990 // [Return]:
991 // [MS_BOOL]
992 //
993 //**************************************************************************
MDrv_HDCPTx_GetAuthDoneFlag(void * pInstance)994 MS_BOOL MDrv_HDCPTx_GetAuthDoneFlag(void* pInstance) //wilson@kano
995 {
996 extern MS_BOOL MDrv_HDMITx_GetHdcpEnFlag(void*);
997 extern MDrvHDMITX_FSM_STATE MDrv_HDMITx_GetFSMState(void*);
998
999 _HDMITX_GET_VARIABLE();
1000
1001 if (MDrv_HDMITx_GetHdcpEnFlag(pInstance) == TRUE)
1002 return psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpAuthDone_flag;
1003 else
1004 return (E_HDMITX_FSM_DONE == MDrv_HDMITx_GetFSMState(pInstance))? TRUE : FALSE;
1005 }
1006
1007 //------------------------------------------------------------------------------
1008 /// @brief This routine get HDCP key
1009 /// @param[in] useinternalkey: TRUE -> from internal, FALSE -> from external, like SPI flash
1010 /// @param[in] data: data point
1011 /// @return None
1012 //------------------------------------------------------------------------------
MDrv_HDCPTx_GetHdcpKey(void * pInstance,MS_BOOL useinternalkey,MS_U8 * data)1013 void MDrv_HDCPTx_GetHdcpKey(void* pInstance, MS_BOOL useinternalkey, MS_U8 *data)
1014 {
1015 _HDMITX_GET_VARIABLE();
1016
1017 psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpUseInternalKey_flag = useinternalkey;
1018 MHal_HDMITx_GetHdcpKey(useinternalkey, data);
1019 }
1020
1021 //**************************************************************************
1022 // [Function Name]:
1023 // MDrv_HDMITx_GetBksv()
1024 // [Description]:
1025 // fetch BKsv
1026 // [Arguments]:
1027 // [MS_U8] *pucData
1028 // [Return]:
1029 // MS_BOOL
1030 //
1031 //**************************************************************************
MDrv_HDCPTx_GetBksv(void * pInstance,MS_U8 * pucData)1032 MS_BOOL MDrv_HDCPTx_GetBksv(void* pInstance, MS_U8 *pucData)
1033 {
1034 _HDMITX_GET_VARIABLE();
1035
1036 memcpy(pucData, &psHDMITXResPri->stHdcpTxInfo.HDCP_BKSV, 5*sizeof(MS_U8));
1037
1038 return psHDMITXResPri->stHdcpTxInfo.HDCP_74_check;
1039 }
1040
1041 //**************************************************************************
1042 // [Function Name]:
1043 // MDrv_HDMITx_GetAksv()
1044 // [Description]:
1045 // fetch AKsv
1046 // [Arguments]:
1047 // [MS_U8] *pucData
1048 // [Return]:
1049 // MS_BOOL
1050 //
1051 //**************************************************************************
MDrv_HDCPTx_GetAksv(void * pInstance,MS_U8 * pucData)1052 MS_BOOL MDrv_HDCPTx_GetAksv(void* pInstance, MS_U8 *pucData)
1053 {
1054 _HDMITX_GET_VARIABLE();
1055
1056 memcpy(pucData, &psHDMITXResPri->stHdcpTxInfo.HDCP_AKSV, 5*sizeof(MS_U8));
1057
1058 return psHDMITXResPri->stHdcpTxInfo.HDCP_74_check;
1059 }
1060
1061 //------------------------------------------------------------------------------
1062 /// @brief This routine update revocation list
1063 /// @argument:
1064 /// - *data: data point
1065 /// - size: amount of revoked key (size 1 = 1*5 bytes, size 2= 2*5 bytes)
1066 /// @return:
1067 //------------------------------------------------------------------------------
MDrv_HDCPTx_GetRevocationKeyList(void * pInstance,MS_U8 * data,MS_U16 size)1068 void MDrv_HDCPTx_GetRevocationKeyList(void* pInstance, MS_U8 *data, MS_U16 size)
1069 {
1070 _HDMITX_GET_VARIABLE();
1071
1072 psHDMITXResPri->stHdcpTxInfo.revocation_size= size;
1073 memcpy(&psHDMITXResPri->stHdcpTxInfo.hdcp_revocationlist[0], data, 5*size);
1074 }
1075
1076 //**************************************************************************
1077 // [Function Name]:
1078 // MDrv_HDCPTx_GetPreState()
1079 // [Description]:
1080 // return previous state of hdcp14 handler
1081 // [Arguments]:
1082 // void
1083 // [Return]:
1084 // enHDCP14Tx_SubStates
1085 //
1086 //**************************************************************************
MDrv_HDCPTx_GetPreState(void * pInstance)1087 enHDCP14Tx_SubStates MDrv_HDCPTx_GetPreState(void* pInstance)
1088 {
1089 _HDMITX_GET_VARIABLE();
1090
1091 return psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState;
1092 }
1093
1094 //**************************************************************************
1095 // [Function Name]:
1096 // MDrv_HDCPTx_GetRxValid()
1097 // [Description]:
1098 // Get Rx status
1099 // [Arguments]:
1100 // void
1101 // [Return]:
1102 // MS_BOOL
1103 //**************************************************************************
MDrv_HDCPTx_GetRxValid(void * pInstance)1104 MS_BOOL MDrv_HDCPTx_GetRxValid(void* pInstance) //wilson@kano
1105 {
1106 _HDMITX_GET_VARIABLE();
1107
1108 return psHDMITXResPri->stHdcpTxInfo.hdcp_Rx_valid;
1109 }
1110
1111 //**************************************************************************
1112 // [Function Name]:
1113 // MDrv_HDCPTx_GetUnHdcpControl()
1114 // [Description]:
1115 // Get Un-Hdcp control value
1116 // [Arguments]:
1117 // void
1118 // [Return]:
1119 // MDrvHDMITX_UNHDCPRX_CONTROL
1120 //**************************************************************************
MDrv_HDCPTx_GetUnHdcpControl(void * pInstance)1121 MDrvHDMITX_UNHDCPRX_CONTROL MDrv_HDCPTx_GetUnHdcpControl(void* pInstance)
1122 {
1123 _HDMITX_GET_VARIABLE();
1124
1125 return psHDMITXResPri->stHdcpTxInfo.hdmitx_unHDCPRx_Control;
1126 }
1127
1128 //**************************************************************************
1129 // [Function Name]:
1130 // MDrv_HDCPTx_GetKSVList()
1131 // [Description]:
1132 // get BStatus, KSVList content for Repeater Mode
1133 // [Arguments]:
1134 // [MS_U8*] pu8Bstatus;
1135 // [MS_U8*] pu8KSVList;
1136 // [MS_U16*] pu16KSVLength;
1137 // [Return]:
1138 // MS_BOOL
1139 //
1140 //**************************************************************************
MDrv_HDCPTx_GetKSVList(MS_U8 * pu8Bstatus,MS_U8 * pu8KSVList,MS_U16 u16BufLen,MS_U16 * pu16KSVLength)1141 MS_BOOL MDrv_HDCPTx_GetKSVList(MS_U8 *pu8Bstatus, MS_U8* pu8KSVList, MS_U16 u16BufLen, MS_U16 *pu16KSVLength)
1142 {
1143 if (g_bValidKSVList == TRUE)
1144 {
1145 if ((pu8Bstatus != NULL) && (pu8KSVList != NULL) && (pu16KSVLength != NULL))
1146 {
1147 MS_U16 u16TmpLen = 0x00;
1148
1149 u16TmpLen = (u16BufLen > g_u8Bstatus[0]) ? g_u8Bstatus[0] : u16BufLen;
1150 memcpy(pu8Bstatus, g_u8Bstatus, sizeof(g_u8Bstatus));
1151 memcpy(pu8KSVList, g_u8KSVList, u16TmpLen);
1152 *pu16KSVLength = g_u8Bstatus[0];
1153 }
1154 }
1155
1156 return g_bValidKSVList;
1157 }
1158
1159 //**************************************************************************
1160 // [Function Name]:
1161 // MDrv_HDCPTx_CheckAuthFailFlag()
1162 // [Description]:
1163 // return TRUE if hdcp14 authentication failed
1164 // [Arguments]:
1165 // void
1166 // [Return]:
1167 // MS_BOOL
1168 //
1169 //**************************************************************************
MDrv_HDCPTx_CheckAuthFailFlag(void * pInstance)1170 MS_BOOL MDrv_HDCPTx_CheckAuthFailFlag(void* pInstance)
1171 {
1172 _HDMITX_GET_VARIABLE();
1173 if (psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState == HDCP14Tx_SubFSM_AuthFail)
1174 return TRUE;
1175 else
1176 return FALSE;
1177 }
1178
1179 //------------------------------------------------------------------------------
1180 /// @brief This function return revocation check result
1181 /// @argument:
1182 /// @return:
1183 /// - E_CHECK_NOT_READY
1184 /// - E_CHECK_REVOKED
1185 /// - E_CHECL_NOT_REVOKED
1186 //------------------------------------------------------------------------------
MDrv_HDCPTx_RevocationKey_Check(void * pInstance)1187 MDrvHDMITX_REVOCATION_STATE MDrv_HDCPTx_RevocationKey_Check(void* pInstance)
1188 {
1189 MDrvHDMITX_REVOCATION_STATE stRet;
1190
1191 _HDMITX_SEMAPHORE_ENTRY(pInstance);
1192 _HDMITX_GET_VARIABLE();
1193
1194 stRet = psHDMITXResPri->stHdcpTxInfo.revocation_state;
1195
1196 _HDMITX_SEMAPHORE_RETURN(pInstance);
1197
1198 return stRet;
1199 }
1200
1201 // *** Sample empty SRM ***
1202 // 0x80 0x00 // SRM ID and reserved bit-field
1203 // 0x00 0x01 // SRM version 0001
1204 // 0x00 // SRM generator no
1205 // 0x00 0x00 0x2B // VRL length (in bytes) 40+3 bytes.
1206 // 0xD2 0x48 0x9E 0x49 0xD0 0x57 0xAE 0x31 0x5B 0x1A 0xBC 0xE0 0x0E 0x4F 0x6B 0x92 // DCP LLC signature
1207 // 0xA6 0xBA 0x03 0x3B 0x98 0xCC 0xED 0x4A 0x97 0x8F 0x5D 0xD2 0x27 0x29 0x25 0x19
1208 // 0xA5 0xD5 0xF0 0x5D 0x5E 0x56 0x3D 0x0E
MDrv_HDCPTx_CheckRevokedKey(void * pInstance)1209 MS_BOOL MDrv_HDCPTx_CheckRevokedKey(void* pInstance)
1210 {
1211 #if 1
1212 MS_U16 i;
1213 MS_U8 j, u8bksv[5];
1214 //MS_U32 u32keylen;
1215 // The revoked key from QD882: Bksv=0x23, 0xde, 0x5c, 0x43, 0x93
1216 MS_U8 u8Revokedksv[5] = {0x23, 0xDE, 0x5C, 0x43, 0x93};
1217
1218 _HDMITX_GET_VARIABLE();
1219
1220 if (!MHal_HDMITx_HDCP_Get_BKSV(&u8bksv[0]))
1221 {
1222 psHDMITXResPri->stHdcpTxInfo.revocation_state = E_CHECK_NOT_READY;
1223 return FALSE;
1224 }
1225 //if(gHDMITxInfo.hdcp_srmlist[0] != 0x80) // no SRM list
1226 if (!psHDMITXResPri->stHdcpTxInfo.revocationlist_ready)
1227 {
1228 // HDCP CTS 1A-08
1229 for(i=0;i<5;i++)
1230 {
1231 if(u8bksv[i] != u8Revokedksv[i])
1232 {
1233 psHDMITXResPri->stHdcpTxInfo.revocation_state = E_CHECK_NOT_REVOKED;
1234 return FALSE;
1235 }
1236 }
1237 DBG_HDCP(printf("MDrv_HDMITx_HDCP_CheckRevokedKey: Revoked Rx key!!\n"));
1238 psHDMITXResPri->stHdcpTxInfo.revocation_state = E_CHECK_REVOKED;
1239 return TRUE;
1240 }
1241 else
1242 {
1243 // revoked key length
1244 //u32keylen = (gHDMITxInfo.hdcp_srmlist[5]<<16) | (gHDMITxInfo.hdcp_srmlist[6]<<8) | gHDMITxInfo.hdcp_srmlist[7];
1245 //u32keylen = (u32keylen >= 43) ? u32keylen-43 : 0; // 3 bytes is VRL length and 40 bytes is DCP LLC signature
1246 //if((u32keylen == 0) || (u32keylen%5 != 0)) // keylen is 0 or not 5 times
1247 if (psHDMITXResPri->stHdcpTxInfo.revocation_size == 0) // keylen is 0 or not 5 times
1248 {
1249 psHDMITXResPri->stHdcpTxInfo.revocation_state = E_CHECK_NOT_REVOKED;
1250 return FALSE;
1251 }
1252 else
1253 {
1254 for(i=0 ; i<psHDMITXResPri->stHdcpTxInfo.revocation_size ; i++)
1255 {
1256 for(j=0 ; j<5 ; j++)
1257 {
1258 if(psHDMITXResPri->stHdcpTxInfo.hdcp_revocationlist[5*i+j] != u8bksv[j])
1259 break;
1260 }
1261 if(j==5) // Bksv is matched the SRM revoked keys
1262 {
1263 psHDMITXResPri->stHdcpTxInfo.revocation_state = E_CHECK_REVOKED;
1264 return TRUE;
1265 }
1266 }
1267 }
1268 }
1269 #endif
1270 psHDMITXResPri->stHdcpTxInfo.revocation_state = E_CHECK_NOT_REVOKED;
1271 return FALSE;
1272 }
1273
1274 //------------------------------------------------------------------------------
1275 /// @brief This routine check whether SRM DSA signauter is valid or not
1276 /// @argument:
1277 /// - *data: data point
1278 /// - size: size of SRM list(bytes)
1279 /// @return:
1280 /// Ture: valid, FALSE: invalid
1281 //------------------------------------------------------------------------------
MDrv_HDCPTx_IsSRMSignatureValid(MS_U8 * data,MS_U32 size)1282 MS_BOOL MDrv_HDCPTx_IsSRMSignatureValid(MS_U8 *data, MS_U32 size)
1283 {
1284 #if 0
1285 MS_U8 Msg[8]; // message, hex format
1286 MS_U8 u8rtemp[20], u8stemp[20]; // DSA signature, hex format
1287 char ms[50];
1288 MS_U32 u32DSASigIdx;
1289 unsigned int SHA1[5];
1290 MS_S8 result;
1291 BIGD m, r, s;
1292 dsa_context dsa;
1293
1294 // ps, qs, gs is from HDCP specification v1.3
1295 // msg[] Source message (will be hashed by SHA-1)
1296 // ps[] (p) Prime Modulus, 1024 bits
1297 // qs[] (q) Prime Divisor, 160 bits
1298 // gs[] (g) Generator, 1024 bits
1299 // ys[] (y) Public key, 1024 bits
1300 char ps[] = "d3c3f5b2 fd1761b7 018d75f7 9343786b\
1301 17395b35 5a52c7b8 a1a24fc3 6a7058ff\
1302 8e7fa164 f500e0dc a0d28482 1d969e4b\
1303 4f34dc0c ae7c7667 b844c747 d4c6b983\
1304 e52ba70e 5447cf35 f404a0bc d1974c3a\
1305 10715509 b3721530 a73f3207 b9982049\
1306 5c7b9c14 3275733b 028a49fd 96891954\
1307 2a39951c 46edc211 8c59802b f3287527";
1308 char qs[] = "ee8af2ce 5e6db56a cd6d14e2 97ef3f4d f9c708e7";
1309 char gs[] = "92f85d1b 6a4d5213 1ae43e24 45de1ab5\
1310 02afdeac a9bed731 5d56d766 cd278611\
1311 8f5db14a bdeca9d2 5162977d a83effa8\
1312 8eedc6bf eb37e1a9 0e29cd0c a03d799e\
1313 92dd2945 f778585f f7c83564 2c21ba7f\
1314 b1a0b6be 81c8a5e3 c8ab69b2 1da54242\
1315 c98e9b8a ab4a9dc2 51fa7dac 29216fe8\
1316 b93f185b 2f67405b 69462442 c2ba0bd9";
1317 char ys[] = "c7060052 6ba0b086 3a80fbe0 a3acff0d\
1318 4f0d7665 8a1754a8 e7654755 f15ba78d\
1319 56950e48 654f0bbd e16804de 1b541874\
1320 db22e14f 031704db 8d5cb2a4 17c4566c\
1321 27ba973c 43d84e0d a2a70856 fe9ea48d\
1322 87259038 b16553e6 62435ff7 fd5206e2\
1323 7bb7ffbd 886c2410 95c8dc8d 66f662cb\
1324 d88f9df7 e9b3fb83 62a9f7fa 36e53799";
1325
1326 m = bdNew();
1327 r = bdNew();
1328 s = bdNew();
1329 memcpy(&gHDMITxInfo.hdcp_srmlist[0], data, size);
1330
1331 u32DSASigIdx = (gHDMITxInfo.hdcp_srmlist[5]<<16) | (gHDMITxInfo.hdcp_srmlist[6]<<8) | gHDMITxInfo.hdcp_srmlist[7];
1332 if(u32DSASigIdx < 43) // illegal length
1333 return FALSE;
1334 else
1335 u32DSASigIdx -= 43;
1336
1337 memcpy(&Msg[0], &(gHDMITxInfo.hdcp_srmlist[0]), 8*sizeof(MS_U8)); // Message: The first 64 bits of SRM list
1338 memcpy(&u8rtemp[0], &(gHDMITxInfo.hdcp_srmlist[8+u32DSASigIdx]), 20*sizeof(MS_U8)); // r: the first 160 bits of DSA signature
1339 memcpy(&u8stemp[0], &(gHDMITxInfo.hdcp_srmlist[8+20+u32DSASigIdx]), 20*sizeof(MS_U8)); // s: the trailing 160 bits of DSA signature
1340 MHal_HDMITx_HDCP_SHA1_Transform(SHA1, Msg); // Msg: 64 bits -> 512bits, SHA-1(Msg)
1341 snprintf(ms, sizeof(ms), "%08x%08x%08x%08x%08x",SHA1[0],SHA1[1],SHA1[2],SHA1[3],SHA1[4]);
1342 //sprintf(ms,"%08x%08x%08x%08x%08x",SHA1[0],SHA1[1],SHA1[2],SHA1[3],SHA1[4]);
1343
1344 _dsa_init(&dsa);
1345
1346 bdConvFromHex(dsa.p, ps);
1347 bdConvFromHex(dsa.q, qs);
1348 bdConvFromHex(dsa.g, gs);
1349 bdConvFromHex(dsa.y, ys);
1350 bdConvFromHex(m,ms);
1351 bdConvFromOctets(r, u8rtemp, 20);
1352 bdConvFromOctets(s, u8stemp, 20);
1353
1354 printf("@@SRM-SHA-1 Digest= ");
1355 bdPrint(m, BD_PRINT_TRIM | BD_PRINT_NL);
1356 printf("@@SRM-R= ");
1357 bdPrint(r, BD_PRINT_TRIM | BD_PRINT_NL);
1358
1359 result = _dsa_verify(&dsa, m, r, s);
1360
1361 printf("@@SRM- Verify result= ");
1362 result == 0 ? printf("PASS!\r\n") : printf("FAIL!\r\n");
1363
1364 bdFree(&m);
1365 bdFree(&r);
1366 bdFree(&s);
1367
1368 _dsa_clear(&dsa);
1369
1370 if(result == 0)
1371 return TRUE;
1372 else
1373 return FALSE;
1374 #endif
1375 return TRUE;
1376 }
1377
1378 //------------------------------------------------------------------------------
1379 /// @brief This routine start/stop HDCP authentication
1380 /// @param[in] bFlag: TRUE -> start authentication, FALSE -> stop authentication
1381 /// @return None
1382 //------------------------------------------------------------------------------
MDrv_HDCPTx_StartAuth(void * pInstance,MS_BOOL bFlag)1383 void MDrv_HDCPTx_StartAuth(void* pInstance, MS_BOOL bFlag)
1384 {
1385 extern void MDrv_HDMITx_SetFSMState(void*, MDrvHDMITX_FSM_STATE); //avoid compile error due to presented order of functions
1386
1387 _HDMITX_GET_VARIABLE();
1388
1389 MDrv_HDMITx_SetHDCPOnOff(pInstance, bFlag);
1390
1391 if (bFlag)
1392 {
1393 MDrv_HDCPTx_SetAuthStartFlag(pInstance, TRUE);
1394 MDrv_HDCPTx_SetAuthDoneFlag(pInstance, FALSE);
1395 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_RESET;
1396
1397 MDrv_HDCPTx_SetFSMState(pInstance, HDCP14Tx_MainState_A0, HDCP14Tx_SubFSM_IDLE);
1398
1399 MsOS_SetEvent(_s32HDMITxEventId, E_HdcpTX_EVENT_RUN);
1400 }
1401 else
1402 {
1403 MDrv_HDCPTx_SetAuthStartFlag(pInstance, FALSE);
1404 MDrv_HDCPTx_SetAuthDoneFlag(pInstance, FALSE);
1405 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_RESET;
1406
1407 if (MDrv_HDMITx_GetEdidRdyFlag(pInstance) == TRUE)
1408 MDrv_HDMITx_SetFSMState(pInstance, E_HDMITX_FSM_TRANSMIT);
1409 else
1410 MDrv_HDMITx_SetFSMState(pInstance, E_HDMITX_FSM_VALIDATE_EDID);
1411
1412 MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_RUN);
1413
1414 _MDrv_HDCPTx_StopRiTimer();
1415 }
1416 }
1417
1418 //**************************************************************************
1419 // [Function Name]:
1420 // HDCPTx_Handler()
1421 // [Description]:
1422 // main handler of hdcp1.4 process
1423 // [Arguments]:
1424 // [MS_U32] u32State
1425 // [Return]:
1426 // void
1427 //
1428 //**************************************************************************
HDCPTx_Handler(void * pInstance,MS_U32 u32State)1429 void HDCPTx_Handler(void* pInstance, MS_U32 u32State) //wilson@kano
1430 {
1431 static MS_BOOL bPolling = FALSE;
1432 static MS_BOOL bCheckDone = FALSE;
1433
1434 extern MS_BOOL MDrv_HDMITx_GetTmdsEnFlag(void* ); //avoid compile error due to presented order of functions
1435 extern MS_BOOL MDrv_HDMITx_GetHdcpEnFlag(void* );
1436 extern MS_BOOL MDrv_HDMITx_GetAVMUTEStatus(void* );
1437 extern void MDrv_HDMITx_SetAVMUTE(void* , MS_BOOL);
1438
1439 _HDMITX_GET_VARIABLE();
1440
1441 if(gbCurRxStatus != E_HDMITX_DVIClock_H_HPD_H || MDrv_HDMITx_GetTmdsEnFlag(pInstance) == FALSE)
1442 return;
1443
1444 if (MDrv_HDCPTx_GetRxValid(pInstance) == FALSE)
1445 {
1446 MHal_HDMITx_HdcpSetEncrypt(DISABLE);
1447 MDrv_HDCPTx_SetFSMState(pInstance, HDCP14Tx_MainState_A0, HDCP14Tx_SubFSM_IDLE);
1448
1449 bPolling = FALSE;
1450 bCheckDone = FALSE;
1451
1452 if (psHDMITXResPri->stHdcpTxInfo.hdmitx_unHDCPRx_Control == E_HDCP_ENCRYPTION)
1453 {
1454 MHal_HDMITx_HdcpSetEncrypt(ENABLE); // for HDCP CTS
1455 }
1456 else if (psHDMITXResPri->stHdcpTxInfo.hdmitx_unHDCPRx_Control == E_BLUE_SCREEN)
1457 {
1458 _MDrv_HDCPTx_StopRiTimer();
1459
1460 MDrv_HDMITx_SetVideoOnOff(pInstance, FALSE); //wilson@kano
1461 MDrv_HDMITx_SetAudioOnOff(pInstance, FALSE); //wilson@kano
1462 }
1463 else //normal display
1464 {
1465 _MDrv_HDCPTx_StopRiTimer();
1466 MHal_HDMITx_HdcpSetEncrypt(DISABLE); // for HDCP CTS
1467 MDrv_HDMITx_SetVideoOnOff(pInstance, TRUE); //wilson@kano
1468 MDrv_HDMITx_SetAudioOnOff(pInstance, TRUE);
1469 }
1470
1471 //return;
1472 }
1473
1474 if (MDrv_HDMITx_GetTmdsEnFlag(pInstance) == TRUE)//((gHdcpTxInfo.hdcp_Rx_valid == TRUE) && (MDrv_HDMITx_GetTmdsEnFlag() == TRUE)) //edid is ready & tmds signal is enabled
1475 {
1476 if (MDrv_HDMITx_GetHdcpEnFlag(pInstance) == TRUE) //(gHdcpTxInfo.hdmitx_hdcp_flag == TRUE)
1477 {
1478 switch (psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState)
1479 {
1480 case HDCP14Tx_MainState_A0:
1481 switch (psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState)
1482 {
1483 case HDCP14Tx_SubFSM_AuthFail:
1484 {
1485 if (psHDMITXResPri->stHdcpTxInfo.hdmitx_unHDCPRx_Control == E_HDCP_ENCRYPTION)
1486 {
1487 MHal_HDMITx_HdcpSetEncrypt(ENABLE); // for HDCP CTS
1488 }
1489 else if (psHDMITXResPri->stHdcpTxInfo.hdmitx_unHDCPRx_Control == E_BLUE_SCREEN)
1490 {
1491 _MDrv_HDCPTx_StopRiTimer();
1492
1493 MDrv_HDMITx_SetVideoOnOff(pInstance, FALSE); //wilson@kano
1494 MDrv_HDMITx_SetAudioOnOff(pInstance, FALSE); //wilson@kano
1495 }
1496 else //normal display
1497 {
1498 _MDrv_HDCPTx_StopRiTimer();
1499 MHal_HDMITx_HdcpSetEncrypt(DISABLE); // for HDCP CTS
1500 MDrv_HDMITx_SetVideoOnOff(pInstance, TRUE); //wilson@kano
1501 MDrv_HDMITx_SetAudioOnOff(pInstance, TRUE);
1502 }
1503
1504 if (MDrv_HDMITx_GetHdcpEnFlag(pInstance) == TRUE) //(gHdcpTxInfo.hdmitx_hdcp_flag == TRUE) //if hdcp is enabled, keep re-try defalut state
1505 {
1506 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1507 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_IDLE;
1508 }
1509
1510 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1511 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_IDLE;//HDCP14Tx_SubFSM_PreExchangeKSV;
1512 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_AuthFail;
1513 }
1514 break;
1515
1516 case HDCP14Tx_SubFSM_IDLE:
1517 {
1518 MS_U16 wBstatus = 0;
1519
1520 memset(g_u8Bstatus, 0x00, sizeof(g_u8Bstatus));
1521 memset(g_u8KSVList, 0x00, sizeof(g_u8KSVList));
1522 g_bValidKSVList = FALSE;
1523
1524 if (MDrv_HDMITx_GetOutputMode(pInstance) & 0x02) //if HDMI mode
1525 {
1526 if ((bCheckDone == FALSE) && (_MDrv_HDCP_GetTimeDiff(gdwPreTime, gdwCurTime) < HDCP14TX_BSTATUS_TIMEOUT_CNT))
1527 {
1528 if (bPolling == FALSE)
1529 gdwPreTime = MsOS_GetSystemTime(); //first time
1530
1531 bPolling = TRUE;
1532 gdwCurTime = MsOS_GetSystemTime();
1533
1534 if (MHal_HDMITx_HDCP_Get_BStatus(&wBstatus) == TRUE)
1535 {
1536 psHDMITXResPri->stHdcpTxInfo.ucBStatus[1] = (MS_U8)((wBstatus & 0xFF00)>>8);
1537 psHDMITXResPri->stHdcpTxInfo.ucBStatus[0] = (MS_U8)(wBstatus & 0x00FF);
1538
1539 if (wBstatus & BIT12)
1540 {
1541 bPolling = FALSE;
1542 bCheckDone = TRUE;
1543 //break;
1544 }
1545 else
1546 {
1547 bPolling = TRUE;
1548 bCheckDone = FALSE;
1549 MsOS_SetEvent(_s32HDMITxEventId, E_HdcpTX_EVENT_RUN);
1550 return;
1551 }
1552 }
1553 }
1554 }
1555
1556 gRepeaterFailTime = 0;
1557 gRepeaterStartTime = MsOS_GetSystemTime();
1558
1559 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_WAITING_ACTIVE_RX;
1560
1561 MHal_HDMITx_HdcpSetEncrypt(DISABLE);
1562
1563 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = _MDrv_HDCPTx_AuthWaitingActiveRx();
1564
1565 if (psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status == E_HDMITX_HDCP_RX_IS_NOT_VALID)
1566 {
1567 MDrv_HDCPTx_SetRxValid(pInstance, FALSE);
1568
1569 if (psHDMITXResPri->stHdcpTxInfo.hdmitx_unHDCPRx_Control == E_HDCP_ENCRYPTION)
1570 {
1571 MHal_HDMITx_HdcpSetEncrypt(ENABLE); // for HDCP CTS
1572 }
1573 else if (psHDMITXResPri->stHdcpTxInfo.hdmitx_unHDCPRx_Control == E_BLUE_SCREEN)
1574 {
1575 _MDrv_HDCPTx_StopRiTimer();
1576
1577 MDrv_HDMITx_SetVideoOnOff(pInstance, FALSE); //wilson@kano
1578 MDrv_HDMITx_SetAudioOnOff(pInstance, FALSE); //wilson@kano
1579 }
1580 else //normal display
1581 {
1582 _MDrv_HDCPTx_StopRiTimer();
1583 MHal_HDMITx_HdcpSetEncrypt(DISABLE); // for HDCP CTS
1584 MDrv_HDMITx_SetVideoOnOff(pInstance, TRUE); //wilson@kano
1585 MDrv_HDMITx_SetAudioOnOff(pInstance, TRUE);
1586 }
1587
1588 if (MDrv_HDMITx_GetHdcpEnFlag(pInstance) == TRUE) //(gHdcpTxInfo.hdmitx_hdcp_flag == TRUE) //if hdcp is enabled, keep re-try defalut state
1589 {
1590 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1591 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_IDLE;
1592 }
1593
1594 MDrv_HDCPTx_SetAuthDoneFlag(pInstance, FALSE);
1595 }
1596 else
1597 {
1598 MDrv_HDCPTx_SetRxValid(pInstance, TRUE);
1599
1600 //move to next state
1601 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1602 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_ExchangeKSV;//HDCP14Tx_SubFSM_PreExchangeKSV;
1603 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_IDLE;
1604 gdwPreTime = MsOS_GetSystemTime();
1605 //MsOS_SetEvent(_s32HDMITxEventId, E_HdcpTX_EVENT_RUN);
1606 }
1607 }
1608 break;
1609 case HDCP14Tx_SubFSM_ExchangeKSV:
1610 {
1611 //send an and aksv, if failed then go back to state A0
1612 //if (hal_HDCP14Tx_SendAn(gHdcpTxInfo.bUseInternalAn) && hal_HDCP14Tx_SendAKSV())
1613 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_ExchangeKSV;
1614
1615 if (MHal_HDMITx_HdcpWriteAn(USE_AUTO_GEN_AN) == TRUE)
1616 {
1617 MsOS_DelayTask(HDCP_DDC_SAMPLE_PERIOD);
1618
1619 if (MHal_HDMITx_HdcpWriteAksv() == TRUE)
1620 {
1621 gdwPreTime = MsOS_GetSystemTime();//MAsm_GetSystemTime();
1622 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A1andA2;
1623 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_VerifyBksv;//HDCP14Tx_SubFSM_IDLE;
1624 }
1625 else
1626 {
1627 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_TX_KEY_FAIL;
1628 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1629 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_AuthFail;
1630 DBG_HDCP(printf("%s::MHal_HDMITx_HdcpWriteAksv fail!! \n", __FUNCTION__));
1631 }
1632 }
1633 else
1634 {
1635 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_TX_KEY_FAIL;
1636
1637 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1638 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_AuthFail;
1639 DBG_HDCP(printf("%s::Exchange KSV fail!! \n", __FUNCTION__));
1640 }
1641 }
1642 break;
1643
1644 default:
1645 DBG_HDCP(printf("[HDCP14TX]%s::Invalid State!\n", __FUNCTION__));
1646 break;
1647 }
1648
1649 MsOS_SetEvent(_s32HDMITxEventId, E_HdcpTX_EVENT_RUN);
1650 break;
1651
1652 case HDCP14Tx_MainState_A1andA2:
1653 switch (psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState)
1654 {
1655 case HDCP14Tx_SubFSM_IDLE:
1656 break;
1657
1658 case HDCP14Tx_SubFSM_VerifyBksv:
1659 //read BCaps, set Ainfo(optional)
1660 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_VerifyBksv;
1661
1662 if(_MDrv_HDCPTx_HdcpSyncSetting(pInstance, MDrv_HDMITx_GetOutputMode(pInstance)) == FALSE)
1663 {
1664 DBG_HDCP(printf("%s::I2C Read BCaps ERROR!\n", __FUNCTION__));
1665
1666 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1667 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_AuthFail; //HDCP14Tx_SubFSM_IDLE;
1668 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_TX_KEY_FAIL;
1669 psHDMITXResPri->stHdcpTxInfo.HDCP_74_check = FALSE;
1670
1671 break;
1672 }
1673 else
1674 {
1675 if (MHal_HDMITx_HdcpCheckBksvLn() == TRUE)
1676 {
1677 MHal_HDMITx_GET74(0x00, psHDMITXResPri->stHdcpTxInfo.HDCP_BKSV);
1678 MHal_HDMITx_GET74(0x10, psHDMITXResPri->stHdcpTxInfo.HDCP_AKSV);
1679 psHDMITXResPri->stHdcpTxInfo.HDCP_74_check = TRUE;
1680 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A3;
1681 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_IDLE;
1682 }
1683 else
1684 {
1685 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1686 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_AuthFail; //HDCP14Tx_SubFSM_IDLE;
1687 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_TX_KEY_FAIL;
1688 psHDMITXResPri->stHdcpTxInfo.HDCP_74_check = FALSE;
1689 }
1690 }
1691 break;
1692
1693 default:
1694 DBG_HDCP(printf("%s::Invalid State!\n", __FUNCTION__));
1695 break;
1696 }
1697 MsOS_SetEvent(_s32HDMITxEventId, E_HdcpTX_EVENT_RUN);
1698 break;
1699
1700 case HDCP14Tx_MainState_A3:
1701 switch (psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState)
1702 {
1703 case HDCP14Tx_SubFSM_IDLE:
1704 //check revoke list
1705 if (MDrv_HDCPTx_CheckRevokedKey(pInstance) == TRUE)
1706 {
1707 DBG_HDCP(printf("%s::Revoke BKSV !!\n", __FUNCTION__));
1708 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_RX_KEY_REVOKED;
1709 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1710 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_AuthFail; //HDCP14Tx_SubFSM_IDLE;
1711 MDrv_HDCPTx_SetRxValid(pInstance, FALSE);
1712 break;
1713 }
1714 else
1715 {
1716 MHal_HDMITx_HdcpStartCipher();
1717 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A3;
1718 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_CheckR0;
1719 //gdwCurTime = _MDrv_HDCP_GetTimeDiff();
1720 //gdwPreTime = gdwCurTime;
1721 }
1722 break;
1723
1724 case HDCP14Tx_SubFSM_CheckR0:
1725 //validate receiver
1726 /**************************************************************************/
1727 // [HDCP] 1A and 1B: AKSV -> Ro should be large than 100msec
1728 // to pass Quantumdata 882 HDCP test, we delay 150ms
1729 //
1730 // 2013/11/07, in SEC Compatibility test, we meet an Repeater timeout error on PEPEATER YAMAHA RX-V2700
1731 // patch AKSV -> Ro large than 250ms
1732 /***************************************************************************/
1733
1734 //wait 100ms(at least) before check R0
1735 #if 1
1736 gdwCurTime = MsOS_GetSystemTime();
1737 if (_MDrv_HDCP_GetTimeDiff(gdwPreTime, gdwCurTime) < HDCP14TX_R0_WDT)
1738 {
1739 //gdwPreTime = gdwCurTime;
1740 break;
1741 }
1742 gdwPreTime = gdwCurTime;
1743 #else
1744 if (u32State & E_HdcpTX_EVENT_RITIMER)
1745 #endif
1746 {
1747 if (_MDrv_HDCPTX_AuthCheckRi() == E_HDMITX_HDCP_SYNC_RI_PASS) //R0 = R0'
1748 {
1749 if (psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpCheckRepeater_flag == TRUE)
1750 {
1751 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A6;
1752 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_IDLE;
1753 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_CheckR0;
1754 }
1755 else
1756 {
1757 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A4;
1758 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_IDLE;
1759 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_SYNC_RI_PASS;
1760 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_CheckR0;
1761 }
1762 }
1763 else //E_HDMITX_HDCP_SYNC_RI_FAIL
1764 {
1765 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1766 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_AuthFail;
1767 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_SYNC_RI_FAIL;
1768 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_CheckR0;
1769 }
1770 }
1771
1772 break;
1773
1774 default:
1775 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1776 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_AuthFail;
1777 DBG_HDCP(printf("%s::Invalid State!\n", __FUNCTION__));
1778 break;
1779 }
1780 MsOS_SetEvent(_s32HDMITxEventId, E_HdcpTX_EVENT_RUN);
1781 break;
1782
1783 case HDCP14Tx_MainState_A4:
1784 switch (psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState)
1785 {
1786 case HDCP14Tx_SubFSM_IDLE:
1787 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A4;
1788 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_AuthDone;
1789 MsOS_SetEvent(_s32HDMITxEventId, E_HdcpTX_EVENT_RUN);
1790 break;
1791
1792 case HDCP14Tx_SubFSM_AuthDone:
1793 //authentication done;
1794 MHal_HDMITx_HdcpAuthPass();//hal_HDCP14Tx_SetAuthDone(TRUE);
1795 MDrv_HDCPTx_SetAuthDoneFlag(pInstance, TRUE);
1796 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A4;
1797 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_CheckRi;
1798 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_AUTH_DONE;
1799 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_AuthDone;
1800
1801 MDrv_HDMITx_SetVideoOnOff(pInstance, TRUE);
1802 MDrv_HDMITx_SetAudioOnOff(pInstance, TRUE);
1803
1804 if (_s32HDCPRiTimerId > 0) //already created
1805 {
1806 MsOS_DeleteTimer(_s32HDCPRiTimerId);
1807 }
1808
1809 if (MDrv_HDMITx_GetAVMUTEStatus(pInstance) == TRUE)
1810 {
1811 MDrv_HDMITx_SetAVMUTE(pInstance, FALSE);
1812 }
1813
1814 _s32HDCPRiTimerId = MsOS_CreateTimer( _MDrv_HDMITX_HDCP_Ri_TimerCallback,
1815 gHDCPCheckRiTimer,
1816 gHDCPCheckRiTimer,
1817 TRUE,
1818 "HDCP Ri Timer");
1819
1820 //gdwCurTime = _MDrv_HDCP_GetTimeDiff();
1821 //gdwPreTime = gdwCurTime;
1822 break;
1823
1824 case HDCP14Tx_SubFSM_CheckRi:
1825 //gdwCurTime = _MDrv_HDCP_GetTimeDiff();
1826
1827 if (u32State & E_HdcpTX_EVENT_RITIMER)//if (_MDrv_HDCP_GetTimeDiff(gdwPreTime, gdwCurTime) > HDCP14TX_CHECK_RI_WDT)
1828 {
1829 if (_MDrv_HDCPTX_AuthCheckRi() == E_HDMITX_HDCP_SYNC_RI_FAIL) //if (hal_HDCP14Tx_CompareRi() == FALSE) //Ri failed
1830 {
1831 DBG_HDCP(printf("%s::Check Ri failed! %d\n", __FUNCTION__, gdwCurTime));
1832
1833 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1834 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_AuthFail;
1835 MHal_HDMITx_HdcpSetEncrypt(DISABLE);//hal_HDCP14Tx_EnableEncryption(FALSE);
1836 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_SYNC_RI_FAIL;
1837 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_CheckRi;
1838 }
1839 //gdwPreTime = gdwCurTime;
1840 }
1841 break;
1842
1843 default:
1844 break;
1845 }
1846 break;
1847
1848 case HDCP14Tx_MainState_A5:
1849 break;
1850
1851 case HDCP14Tx_MainState_A6:
1852 switch (psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState)
1853 {
1854 case HDCP14Tx_SubFSM_IDLE:
1855 //gHdcpTxInfo.bRepeaterMode = (gHdcpTxInfo.ucBCaps & 0x40) ? TRUE : FALSE; //BCaps: b'[6] downstream is repeater
1856 if (psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpCheckRepeater_flag == TRUE) //if (gHdcpTxInfo.bRepeaterMode == TRUE)
1857 {
1858 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A8;
1859 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_IDLE;
1860 }
1861 else
1862 {
1863 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A4;
1864 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_IDLE;
1865 }
1866 break;
1867 default:
1868 DBG_HDCP(printf("%s::Invalid State!\n", __FUNCTION__));
1869 break;
1870 }
1871 MsOS_SetEvent(_s32HDMITxEventId, E_HdcpTX_EVENT_RUN);
1872 break;
1873
1874 case HDCP14Tx_MainState_A7:
1875 DBG_HDCP(printf("%s::Invalid State!\n", __FUNCTION__));
1876 break;
1877
1878 case HDCP14Tx_MainState_A8:
1879 switch (psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState)
1880 {
1881 case HDCP14Tx_SubFSM_IDLE:
1882 //TBD: set up 5 sec WDT and polling Rx ready bit
1883 gdwPreTime = MsOS_GetSystemTime();
1884 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A8;
1885 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_PollingRdyBit;
1886 break;
1887
1888 case HDCP14Tx_SubFSM_PollingRdyBit:
1889 //TBD: if ready then go A9; else go to A0
1890 gdwCurTime = MsOS_GetSystemTime();
1891 if (_MDrv_HDCP_GetTimeDiff(gdwPreTime, gdwCurTime) < HDCP14TX_REP_RDY_BIT_WDT)
1892 {
1893 if (_MDrv_HDCPTx_AuthCheckRepeaterReady() == E_HDMITX_HDCP_REPEATER_NOT_READY)
1894 {
1895 //gdwPreTime = gdwCurTime;
1896 break;
1897 }
1898 else
1899 {
1900 //go to state A9 and start check KSV list
1901 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A9;
1902 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_AuthWithRepeater;//HDCP14Tx_SubFSM_IDLE;
1903 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_PollingRdyBit;
1904 }
1905 }
1906 else //timeout
1907 {
1908 DBG_HDCP(printf("%s::Polling Repeater Ready Bit Timeout !!\n", __FUNCTION__));
1909 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1910 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_AuthFail;
1911 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_REPEATER_TIMEOUT;
1912 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_PollingRdyBit;
1913 }
1914 break;
1915
1916 default:
1917 DBG_HDCP(printf("%s::Invalid State!\n", __FUNCTION__));
1918 break;
1919 }
1920 MsOS_SetEvent(_s32HDMITxEventId, E_HdcpTX_EVENT_RUN);
1921 break;
1922
1923 case HDCP14Tx_MainState_A9:
1924 switch (psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState)
1925 {
1926 case HDCP14Tx_SubFSM_IDLE:
1927 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A9;
1928 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_AuthWithRepeater;
1929 break;
1930
1931 case HDCP14Tx_SubFSM_AuthWithRepeater:
1932 if (_MDrv_HDCPTx_CheckRepeater() == E_HDMITX_HDCP_REPEATER_SHA1_PASS)//if (hal_HDCP14Tx_AuthWithRepeater())
1933 {
1934 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A4;
1935 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_IDLE;
1936 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_AuthWithRepeater;
1937 }
1938 else
1939 {
1940 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1941 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_AuthFail;
1942 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_PreSubState = HDCP14Tx_SubFSM_AuthWithRepeater;
1943 }
1944 break;
1945
1946 default:
1947 DBG_HDCP(printf("%s::Invalid State!\n", __FUNCTION__));
1948 break;
1949 }
1950 MsOS_SetEvent(_s32HDMITxEventId, E_HdcpTX_EVENT_RUN);
1951 break;
1952
1953 default:
1954 break;
1955 }
1956
1957 //MsOS_SetEvent(_s32HDMITxEventId, E_HdcpTX_EVENT_RUN);
1958
1959 } //gHdcpTxInfo.hdmitx_hdcp_flag == TRUE;
1960 else
1961 {
1962 MDrv_HDCPTx_SetAuthDoneFlag(pInstance, FALSE);
1963 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_AUTH_FAIL;
1964 }
1965 } //((gHdcpTxInfo.hdcp_Rx_valid == TRUE) && (MDrv_HDMITx_GetTmdsEnFlag() == TRUE))
1966 else
1967 {
1968 MDrv_HDCPTx_SetAuthDoneFlag(pInstance, FALSE);
1969 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState = HDCP14Tx_MainState_A0;
1970 psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState = HDCP14Tx_SubFSM_IDLE;
1971 psHDMITXResPri->stHdcpTxInfo.hdmitx_HDCPAuth_Status = E_HDMITX_HDCP_RX_IS_NOT_VALID;
1972 psHDMITXResPri->stHdcpTxInfo.revocation_state = E_CHECK_NOT_READY;
1973 psHDMITXResPri->stHdcpTxInfo.HDCP_74_check = FALSE;
1974 }
1975 }
1976
1977 //**************************************************************************
1978 // [Function Name]:
1979 // ()
1980 // [Description]:
1981 //
1982 // [Arguments]:
1983 //
1984 // [Return]:
1985 //
1986 //
1987 //**************************************************************************
1988 #if 0
1989
1990 static void _HDCPTx_Task(void) //wilson@kano
1991 {
1992 MS_U32 u32Events = 0;
1993
1994 while (g_bHdcpTxTask == TRUE)
1995 {
1996 MsOS_WaitEvent(_s32HdcpTxEventId, E_HdcpTX_EVENT_RUN | E_HdcpTX_EVENT_IRQ | E_HdcpTX_EVENT_RITIMER, &u32Events, E_OR_CLEAR, 5000);
1997
1998 if (gHdcpTxInfo.hdcp_Rx_valid == TRUE)
1999 HDCPTx_Handler(u32Events);
2000
2001 MsOS_DelayTask(HDCPTX_MONITOR_DELAY);
2002 } // Task loop
2003 }
2004
2005 #endif
2006
2007 //------------------------------------------------------------------------------
2008 /// @brief This routine initializes HDCP Tx module
2009 /// @return None
2010 /// HDCP driver is in @ref E_TASK_PRI_HIGH level
2011 //------------------------------------------------------------------------------
MDrv_HDCPTx_Init(void * pInstance)2012 MS_BOOL MDrv_HDCPTx_Init(void *pInstance) //wilson@kano
2013 {
2014 #if 1
2015 MDrv_HDCPTx_InitVariable(pInstance);
2016 #else
2017 _hdcptx_status.bIsInitialized = TRUE;
2018 _hdcptx_status.bIsRunning = TRUE;
2019
2020 if (_s32HdcpTxTaskId >= 0)
2021 {
2022 DBG_HDMITX(printf("MDrv_HdcpTx_Init: already initialized.\n"));
2023 return TRUE;
2024 }
2025
2026 DBG_HDMITX(printf("%s\n", __FUNCTION__));
2027
2028 MDrv_HDCPTx_InitVariable();
2029
2030 _s32HdcpTxEventId = MsOS_CreateEventGroup("HDCPTx_Event");
2031 if (_s32HdcpTxEventId < 0)
2032 {
2033 ///MsOS_DeleteMutex(_s32HDMITxMutexId);
2034 return FALSE;
2035 }
2036
2037 _pHdcpTxTaskStack = _u8HdcpTx_StackBuffer;
2038 g_bHdcpTxTask = TRUE;
2039 _s32HdcpTxTaskId = MsOS_CreateTask((TaskEntry)_HDCPTx_Task,
2040 (MS_U32)NULL,
2041 E_TASK_PRI_HIGH,
2042 TRUE,
2043 _pHdcpTxTaskStack,
2044 HDCPTX_TASK_STACK_SIZE,
2045 "HDCPTx_Task");
2046 if (_s32HdcpTxTaskId < 0)
2047 {
2048 MsOS_DeleteEventGroup(_s32HdcpTxEventId);
2049 printf("create hdmi task failed\r\n");
2050 ///MsOS_DeleteMutex(_s32HDMITxMutexId);
2051 return FALSE;
2052 }
2053 #endif
2054
2055 return TRUE;
2056 }
2057
2058
2059 /*********************************************************************/
2060 /* */
2061 /* Sorting HDMI Tx function here */
2062 /* */
2063 /*********************************************************************/
____HDMITx_Relative_Func____(void)2064 void ____HDMITx_Relative_Func____(void){} //Null function for navigation
2065
2066 //-------------------------------------------------------------------------------------------------
2067 // Check Rx timer callback
2068 // @param stTimer \b IN: Useless
2069 // @param u32Data \b IN: Useless
2070 // @return None
2071 //-------------------------------------------------------------------------------------------------
_MDrv_HDMITX_CheckRx_TimerCallback(MS_U32 stTimer,MS_U32 u32Data)2072 static void _MDrv_HDMITX_CheckRx_TimerCallback(MS_U32 stTimer, MS_U32 u32Data)
2073 {
2074 // Check HDMI receiver status
2075 gbCurRxStatus = MHal_HDMITx_GetRXStatus();
2076 MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_RXTIMER);
2077 }
2078
_MDrv_HDMITX_InitEdidField(void * pInstance)2079 void _MDrv_HDMITX_InitEdidField(void* pInstance)
2080 {
2081 _HDMITX_GET_VARIABLE();
2082
2083 //edid relative //assign initial value
2084 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk0, 0x00, HDMITX_EDID_BLK_SIZE*sizeof(MS_U8));
2085 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk1, 0x00, HDMITX_EDID_BLK_SIZE*sizeof(MS_U8));
2086 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ManufacturerID, 0x00, 3*sizeof(MS_U8));
2087 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.CEADataBlkLen, 0x00, HDMITX_CEA_DAT_BLK_TYPE_NUM*sizeof(MS_U8));
2088 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.PhyAddr, 0x00, 2*sizeof(MS_U8));
2089 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportHdmi = FALSE;
2090
2091 //HF-VSDB, scdc relative
2092 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HF_VSDBVerInfo = 0x00;
2093 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.MaxTmdsCharRate = 0x00;
2094 #if 0
2095 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportIndependView = FALSE;
2096 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportDualView = FALSE;
2097 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support3DOsdDisparity = FALSE;
2098 #endif
2099 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportLTEScramble = FALSE;
2100 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportSCDC = FALSE;
2101
2102 //read request
2103 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YUV420DeepColorInfo = 0x00;
2104 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.AudSupportAI = FALSE;
2105 #if 0
2106 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.b3DPresent = FALSE;
2107 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support2D_50Hz = FALSE;
2108 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support2D_60Hz = FALSE;
2109 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support3D_50Hz = FALSE;
2110 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support3D_60Hz = FALSE;
2111 #endif
2112 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ColorDepthInfo = E_HDMITX_VIDEO_CD_NoID;
2113
2114 // data block content
2115 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.AudioDataBlk, 0x00, 32*sizeof(MS_U8));
2116 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk, 0x00, 32*sizeof(MS_U8));
2117 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VendorDataBlk, 0x00, 32*sizeof(MS_U8));
2118 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SpeakerAllocDataBlk, 0x00, 32*sizeof(MS_U8));
2119 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VESA_DTCDataBlk, 0x00, 32*sizeof(MS_U8));
2120 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICList, 0x00, 7*sizeof(MS_U8)); //this field has only 3 bits
2121 #if 0
2122 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming, 0x00, 32*sizeof(MS_U8));
2123 #endif
2124
2125 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HDMI_VSDB, 0x00, 32*sizeof(MS_U8));
2126 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HF_VSDB, 0x00, 32*sizeof(MS_U8));
2127 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HDMI_VSDB_Len = 0x00;
2128 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HF_VSDB_Len = 0x00;
2129 #if 0
2130 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.b3dMultiPresent = 0x00;
2131 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Hdmi3DLen = 0x00;
2132 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICLen = 0x00;
2133 #endif
2134
2135 //for 420
2136 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support420ColorFmt = FALSE;
2137 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420VidDataBlk, 0x00, 32*sizeof(MS_U8));
2138 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420CapMapDataBlk, 0x00, 32*sizeof(MS_U8));
2139
2140 //for colorimetry
2141 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ExtColorimetry = 0x00;
2142
2143 //for HDR
2144 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.bSupportHDR = FALSE;
2145 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HDRStaticDataBlk, 0x00, 32*sizeof(MS_U8));
2146 }
2147
2148 /**************************************************************************/
2149 // [Function Name]:
2150 // _MDrv_HDMIRx_MapVideoTimingToVIC()
2151 // [Description]:
2152 // mapping timing table to VIC code
2153 // [Arguments]:
2154 // [MsHDMITX_VIDEO_TIMING] timing
2155 // [Return]:
2156 // MsHDMITX_AVI_VIC
2157 //**************************************************************************/
_MDrv_HDMIRx_MapVideoTimingToVIC(MsHDMITX_VIDEO_TIMING timing)2158 static MsHDMITX_AVI_VIC _MDrv_HDMIRx_MapVideoTimingToVIC(MsHDMITX_VIDEO_TIMING timing)
2159 {
2160 //msdbg Todo: 6.6G report 3840x2160_60P VIc
2161
2162 switch(timing)
2163 {
2164 case E_HDMITX_RES_640x480p:
2165 return E_HDMITX_VIC_640x480p_60_4_3;
2166
2167 case E_HDMITX_RES_720x480i:
2168 return E_HDMITX_VIC_720x480i_60_16_9;
2169
2170 case E_HDMITX_RES_720x576i:
2171 return E_HDMITX_VIC_720x576i_50_16_9;
2172
2173 case E_HDMITX_RES_720x480p:
2174 return E_HDMITX_VIC_720x480p_60_16_9;
2175
2176 case E_HDMITX_RES_720x576p:
2177 return E_HDMITX_VIC_720x576p_50_16_9;
2178
2179 case E_HDMITX_RES_1280x720p_50Hz:
2180 return E_HDMITX_VIC_1280x720p_50_16_9;
2181
2182 case E_HDMITX_RES_1280x720p_60Hz:
2183 return E_HDMITX_VIC_1280x720p_60_16_9;
2184
2185 case E_HDMITX_RES_1920x1080i_50Hz:
2186 return E_HDMITX_VIC_1920x1080i_50_16_9;
2187
2188 case E_HDMITX_RES_1920x1080i_60Hz:
2189 return E_HDMITX_VIC_1920x1080i_60_16_9;
2190
2191 case E_HDMITX_RES_1920x1080p_24Hz:
2192 return E_HDMITX_VIC_1920x1080p_24_16_9;
2193
2194 case E_HDMITX_RES_1920x1080p_25Hz:
2195 return E_HDMITX_VIC_1920x1080p_25_16_9;
2196
2197 case E_HDMITX_RES_1920x1080p_30Hz:
2198 return E_HDMITX_VIC_1920x1080p_30_16_9;
2199
2200 case E_HDMITX_RES_1920x1080p_50Hz:
2201 return E_HDMITX_VIC_1920x1080p_50_16_9;
2202
2203 case E_HDMITX_RES_1920x1080p_60Hz:
2204 return E_HDMITX_VIC_1920x1080p_60_16_9;
2205
2206 case E_HDMITX_RES_1920x2205p_24Hz:// for 3D timing
2207 return E_HDMITX_VIC_1920x1080p_24_16_9;
2208
2209 case E_HDMITX_RES_3840x2160p_24Hz:
2210 return E_HDMITX_VIC_3840x2160p_24_16_9;
2211
2212 case E_HDMITX_RES_3840x2160p_25Hz:
2213 return E_HDMITX_VIC_3840x2160p_25_16_9;
2214
2215 case E_HDMITX_RES_3840x2160p_30Hz:
2216 return E_HDMITX_VIC_3840x2160p_30_16_9;
2217
2218 case E_HDMITX_RES_3840x2160p_50Hz:
2219 return E_HDMITX_VIC_3840x2160p_50_16_9;
2220
2221 case E_HDMITX_RES_3840x2160p_60Hz:
2222 return E_HDMITX_VIC_3840x2160p_60_16_9;
2223
2224 case E_HDMITX_RES_4096x2160p_24Hz:
2225 return E_HDMITX_VIC_4096x2160p_24_256_135;
2226
2227 case E_HDMITX_RES_4096x2160p_25Hz:
2228 return E_HDMITX_VIC_4096x2160p_25_256_135;
2229
2230 case E_HDMITX_RES_4096x2160p_30Hz:
2231 return E_HDMITX_VIC_4096x2160p_25_256_135;
2232
2233 case E_HDMITX_RES_4096x2160p_50Hz:
2234 return E_HDMITX_VIC_4096x2160p_50_256_135;
2235
2236 case E_HDMITX_RES_4096x2160p_60Hz:
2237 return E_HDMITX_VIC_4096x2160p_60_256_135;
2238
2239 default:
2240 printf("[HDMITx]: Error video timing: %d\n", timing);
2241 return E_HDMITX_VIC_NOT_AVAILABLE;
2242 }
2243 }
2244
2245 //**************************************************************************/
2246 // [Function Name]:
2247 // _MDrv_HDMITx_ParseDeepColorInfo()
2248 // [Description]:
2249 // mapping EDID field to color depth information
2250 // [Arguments]:
2251 // [MS_U8] u8DataByte
2252 // [Return]:
2253 // void
2254 //**************************************************************************/
_MDrv_HDMITx_ParseDeepColorInfo(void * pInstance,MS_U8 u8DataByte)2255 void _MDrv_HDMITx_ParseDeepColorInfo(void* pInstance, MS_U8 u8DataByte)
2256 {
2257 #define DBG_DEEPCOLOR_INFO 1
2258
2259 _HDMITX_GET_VARIABLE();
2260
2261 //check Deep Color information
2262 if ( u8DataByte & 0x40 )
2263 {
2264 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ColorDepthInfo = E_HDMITX_VIDEO_CD_48Bits;
2265 #if (DBG_DEEPCOLOR_INFO == 1)
2266 printf("%s::Support Color Depth 48-bit\r\n", __FUNCTION__);
2267 #endif
2268 }
2269 else if ( u8DataByte & 0x20 )
2270 {
2271 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ColorDepthInfo = E_HDMITX_VIDEO_CD_36Bits;
2272
2273 #if (DBG_DEEPCOLOR_INFO == 1)
2274 printf("%s::Support Color Depth 36-bit\r\n", __FUNCTION__);
2275 #endif
2276 }
2277 else if ( u8DataByte & 0x10 )
2278 {
2279 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ColorDepthInfo = E_HDMITX_VIDEO_CD_30Bits;
2280
2281 #if (DBG_DEEPCOLOR_INFO == 1)
2282 printf("%s::Support Color Depth 30-bit\r\n", __FUNCTION__);
2283 #endif
2284 }
2285 else
2286 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ColorDepthInfo = E_HDMITX_VIDEO_CD_24Bits;
2287
2288 #undef DBG_DEEPCOLOR_INFO
2289
2290 }
2291
2292
2293 //**************************************************************************/
2294 // [Function Name]:
2295 // _MDrv_HDMITx_ParseHdmiVSDB
2296 // [Description]:
2297 // Parsing HDMI VSDB part
2298 // [Arguments]:
2299 // [MS_U8]* pu8BlkData
2300 // [MS_U8] u8BlkLen
2301 // [MS_U8] u8SupTimingNum
2302 // [Return]:
2303 // [MS_BOOL] TRUE: successful; FALSE: failed
2304 //**************************************************************************/
_MDrv_HDMITx_ParseHdmiVSDB(void * pInstance,MS_U8 * pu8BlkData,MS_U8 u8BlkLen,MS_U8 u8SupTimingNum)2305 MS_BOOL _MDrv_HDMITx_ParseHdmiVSDB(void* pInstance, MS_U8* pu8BlkData, MS_U8 u8BlkLen, MS_U8 u8SupTimingNum)
2306 {
2307 #define DBG_HDMIVSDB_INFO 1U
2308 MS_U8 i = 0;
2309
2310 _HDMITX_GET_VARIABLE();
2311
2312 //get Physical Address
2313 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.PhyAddr[0] = *(pu8BlkData + 3);
2314 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.PhyAddr[1] = *(pu8BlkData + 4);
2315 #if (DBG_HDMIVSDB_INFO == 1)
2316 printf("Physcal Address = [%d, %d, %d, %d]\r\n", (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.PhyAddr[0] & 0xF0) >> 4, \
2317 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.PhyAddr[0] & 0x0F, (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.PhyAddr[1] & 0xF0) >> 4, \
2318 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.PhyAddr[1] & 0x0F);
2319 #endif
2320
2321 if (u8BlkLen > 5)
2322 {
2323 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.AudSupportAI = (*(pu8BlkData + 5) & 0x80)? TRUE : FALSE;
2324
2325 #if (DBG_HDMIVSDB_INFO == 1)
2326 printf("%s::Support AI = %d !\n", __FUNCTION__, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.AudSupportAI);
2327 #endif
2328
2329 //check Deep Color information
2330 _MDrv_HDMITx_ParseDeepColorInfo(pInstance, *(pu8BlkData + 5));
2331
2332 if (u8BlkLen > 7)
2333 {
2334 if ( *(pu8BlkData + 7) & 0x20 ) // HDMI_Video_Present
2335 {
2336 MS_U8 u8IdxOffset = 0;
2337
2338 if ((*(pu8BlkData + 7) & 0xC0) == 0xC0) //Latency_Field_present & I_Latency_Field_Present
2339 u8IdxOffset = 4;
2340 else if ((*(pu8BlkData + 7) & 0xC0) == 0x40) //I_Latency_Field_Present
2341 u8IdxOffset = 2;
2342 else
2343 u8IdxOffset = 0;
2344
2345 if( (*(pu8BlkData + 6)) > psHDMITXResPri->stHDMITxInfo.RxEdidInfo.MaxTmdsCharRate)
2346 {
2347 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.MaxTmdsCharRate = *(pu8BlkData + 6);
2348 }
2349
2350 if (u8BlkLen > (u8IdxOffset + 9))
2351 {
2352 if ( (*(pu8BlkData + u8IdxOffset + 8) & 0x80) || ( ((*(pu8BlkData + u8IdxOffset + 9) & 0xE0) >> 5) > 0 ))//3D present and VIC LEN
2353 {
2354 MS_U8 u8_3dMultiPresent = 0;
2355 MS_U8 u8_Hdmi3DLen = 0;
2356 MS_U8 u8_HdmiVICLen = 0;
2357 #if 0
2358 MS_U16 u16_3dStructAll = 0;
2359 MS_U16 u16_3dMask = 0;
2360 #endif
2361
2362 //psHDMITXResPri->stHDMITxInfo.RxEdidInfo.b3DPresent = TRUE;
2363 #if 0
2364 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.b3DPresent = (*(pu8BlkData + u8IdxOffset + 8) & 0x80) ? TRUE : FALSE;
2365 u8_3dMultiPresent = (*(pu8BlkData + u8IdxOffset + 8) & 0x60) >> 5;
2366 u8_Hdmi3DLen = (*(pu8BlkData + u8IdxOffset + 9) & 0x1F);
2367 #endif
2368 u8_HdmiVICLen = (*(pu8BlkData + u8IdxOffset + 9) & 0xE0) >> 5;
2369 #if 0
2370 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.b3dMultiPresent = u8_3dMultiPresent;
2371 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Hdmi3DLen = u8_Hdmi3DLen;
2372 #endif
2373 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICLen = u8_HdmiVICLen;
2374
2375 #if 0
2376 if(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support2D_60Hz && psHDMITXResPri->stHDMITxInfo.RxEdidInfo.b3DPresent)
2377 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support3D_60Hz = TRUE;
2378
2379 if(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support2D_50Hz && psHDMITXResPri->stHDMITxInfo.RxEdidInfo.b3DPresent)
2380 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support3D_50Hz = TRUE;
2381 #endif
2382
2383 #if (DBG_HDMIVSDB_INFO == 1)
2384 printf("%s::3dmulti_present=%x, 3DLen=%d, VicLen=%d !\n",
2385 __FUNCTION__, u8_3dMultiPresent, u8_Hdmi3DLen, u8_HdmiVICLen);
2386 #endif
2387
2388 //fetch VIC list
2389 if ( u8_HdmiVICLen > 0 )
2390 {
2391 if ( u8BlkLen > (u8IdxOffset + 9 + u8_HdmiVICLen))
2392 {
2393 for ( i = 0; i < u8_HdmiVICLen; i++ )
2394 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICList[i] = *(pu8BlkData + u8IdxOffset + 10 + i);
2395
2396 #if (DBG_HDMIVSDB_INFO == 1)
2397 printf("%s::HDMI VIC list\r\n",__FUNCTION__);
2398 for ( i = 0; i < u8_HdmiVICLen; i++ )
2399 printf("0x%02X ", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICList[i]);
2400 printf("\n");
2401 #endif
2402
2403 u8IdxOffset += u8_HdmiVICLen; //HDMI_VIC_LEN
2404 }
2405 }
2406
2407 #if (DBG_HDMIVSDB_INFO == 1)
2408 printf("3D_MultiPresent = 0x%02X\r\n", u8_3dMultiPresent);
2409 #endif
2410
2411 #if 0
2412 if (u8_3dMultiPresent == 0x01) // 3D_Structure_ALL_15..0
2413 {
2414 //check length
2415 if (u8BlkLen > (u8IdxOffset + 11))
2416 {
2417 u16_3dStructAll = (*(pu8BlkData + u8IdxOffset + 10) << 8) | (*(pu8BlkData + u8IdxOffset + 11));
2418 for ( i = 0; i < ((u8SupTimingNum > 16) ? 16 : u8SupTimingNum); i++ )
2419 {
2420 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[i].Video3DInfo = u16_3dStructAll;
2421 #if (DBG_HDMIVSDB_INFO == 1)
2422 printf("SupVidTiming[%02d].Video3DInfo = 0x%02X\r\n", i, u16_3dStructAll);
2423 #endif
2424 }
2425 u8_Hdmi3DLen -= 2;
2426 }
2427
2428 }
2429 else if (u8_3dMultiPresent == 0x02) // 3D_Structure_ALL_15..0 and 3D_Mask_ALL_15..0
2430 {
2431 //check Length
2432 if (u8BlkLen > (u8IdxOffset + 13))
2433 {
2434 u16_3dStructAll = (*(pu8BlkData + u8IdxOffset + 10) << 8) | (*(pu8BlkData + u8IdxOffset + 11));
2435 u16_3dMask = (*(pu8BlkData + u8IdxOffset + 12) << 8) | (*(pu8BlkData + u8IdxOffset + 13));
2436
2437 for ( i = 0; i < ((u8SupTimingNum > 16) ? 16 : u8SupTimingNum); i++ )
2438 {
2439 if ((u16_3dMask >> i) & 0x01)
2440 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[i].Video3DInfo = u16_3dStructAll;
2441 else
2442 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[i].Video3DInfo = 0;
2443
2444 #if (DBG_HDMIVSDB_INFO == 1)
2445 printf("SupVidTiming[%02d].Video3DInfo = 0x%02X\r\n", i, u16_3dStructAll);
2446 #endif
2447 }
2448 u8_Hdmi3DLen -= 4;
2449 }
2450 }
2451
2452 if (u8_Hdmi3DLen > 1) // 3D structure remains
2453 {
2454 if (u8BlkLen > (u8IdxOffset + 11))
2455 {
2456 MS_U8 u8VicOrder = 0;
2457 MS_U8 u83DStruct = 0;
2458
2459 for ( i = 0; i < u8_Hdmi3DLen; i++ )
2460 {
2461 if (u8_3dMultiPresent == 0x01)
2462 {
2463 u8VicOrder = (*(pu8BlkData + u8IdxOffset + 12 + i) & 0xF0) >> 4;
2464 u83DStruct = (*(pu8BlkData + u8IdxOffset + 12 + i) & 0x0F);
2465 }
2466 else if (u8_3dMultiPresent == 0x02)
2467 {
2468 u8VicOrder = (*(pu8BlkData + u8IdxOffset + 14 + i) & 0xF0) >> 4;
2469 u83DStruct = (*(pu8BlkData + u8IdxOffset + 14 + i) & 0x0F);
2470 }
2471 else
2472 {
2473 u8VicOrder = (*(pu8BlkData + u8IdxOffset + 10 + i) & 0xF0) >> 4;
2474 u83DStruct = (*(pu8BlkData + u8IdxOffset + 10 + i) & 0x0F);
2475 }
2476
2477 switch (u83DStruct)
2478 {
2479 case 0:
2480 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[u8VicOrder].Video3DInfo |= E_HDMITX_EDID_3D_FramePacking;
2481 break;
2482
2483 case 1:
2484 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[u8VicOrder].Video3DInfo |= E_HDMITX_EDID_3D_FieldAlternative;
2485 break;
2486
2487 case 2:
2488 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[u8VicOrder].Video3DInfo |= E_HDMITX_EDID_3D_LineAlternative;
2489 break;
2490
2491 case 3:
2492 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[u8VicOrder].Video3DInfo |= E_HDMITX_EDID_3D_SidebySide_FULL;
2493 break;
2494
2495 case 4:
2496 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[u8VicOrder].Video3DInfo |= E_HDMITX_EDID_3D_L_Dep;
2497 break;
2498
2499 case 5:
2500 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[u8VicOrder].Video3DInfo |= E_HDMITX_EDID_3D_L_Dep_Graphic_Dep;
2501 break;
2502
2503 case 6:
2504 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[u8VicOrder].Video3DInfo |= E_HDMITX_EDID_3D_TopandBottom;
2505 break;
2506
2507 case 7:
2508 break;
2509
2510 case 8:
2511 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[u8VicOrder].Video3DInfo |= E_HDMITX_EDID_3D_SidebySide_Half_horizontal;
2512 i++;
2513 break;
2514
2515 default:
2516 i++;
2517 break;
2518 }
2519 }
2520 }
2521 }
2522 #endif//K6LITE_NVR_REDUCE
2523 }
2524 }
2525 }
2526 }
2527 }
2528 #undef DBG_HDMIVSDB_INFO
2529
2530 return TRUE;
2531
2532 }
2533
2534 //**************************************************************************/
2535 // [Function Name]:
2536 // _drv_HDMITx_ParseHFVSDB()
2537 // [Description]:
2538 // Parsing HF-VSDB ( new for HDMI 2.0 spec )
2539 // [Arguments]:
2540 // [MS_U8]* pu8BlkData
2541 // [MS_U8] u8BlkLen
2542 // [MS_U8] u8SupTimingNum
2543 // [Return]:
2544 // [MS_BOOL] TRUE: successful; FALSE: failed
2545 //
2546 //**************************************************************************/
_MDrv_HDMITx_ParseHFVSDB(void * pInstance,MS_U8 * pu8BlkData,MS_U8 u8BlkLen,MS_U8 u8SupTimingNum)2547 MS_BOOL _MDrv_HDMITx_ParseHFVSDB(void* pInstance, MS_U8* pu8BlkData, MS_U8 u8BlkLen, MS_U8 u8SupTimingNum)
2548 {
2549 #define DBG_HFVSDB_INFO 1
2550 MS_U8 i = 0;
2551
2552 //check IEEE HDMI identifier //NOTE: current index is BYTE 1
2553 for ( i = 0; i < sizeof(HFVSDB_HDMI_IEEE_ID); i++ )
2554 {
2555 if ( *(pu8BlkData + i) != HFVSDB_HDMI_IEEE_ID[i] )
2556 return FALSE;
2557 }
2558 #if (DBG_HFVSDB_INFO == 1)
2559 printf("%s::IEEE HDMI Identifier PASS!\n", __FUNCTION__);
2560 #endif
2561
2562 _HDMITX_GET_VARIABLE();
2563
2564 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HF_VSDBVerInfo = *(pu8BlkData + 3);
2565 //psHDMITXResPri->stHDMITxInfo.RxEdidInfo.MaxTmdsCharRate = *(pu8BlkData + 4);
2566 if( (*(pu8BlkData + 4)) > psHDMITXResPri->stHDMITxInfo.RxEdidInfo.MaxTmdsCharRate)
2567 {
2568 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.MaxTmdsCharRate = *(pu8BlkData + 4);
2569 }
2570
2571 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportSCDC = (*(pu8BlkData + 5) & 0x80) ? TRUE : FALSE;
2572 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportRR = (*(pu8BlkData + 5) & 0x40) ? TRUE : FALSE;
2573 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportLTEScramble = (*(pu8BlkData + 5) & 0x08) ? TRUE : FALSE;
2574 #if 0
2575 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportIndependView = (*(pu8BlkData + 5) & 0x04) ? TRUE : FALSE;
2576 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportDualView = (*(pu8BlkData + 5) & 0x02) ? TRUE : FALSE;
2577 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support3DOsdDisparity = (*(pu8BlkData + 5) & 0x01) ? TRUE : FALSE;
2578 #endif
2579 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YUV420DeepColorInfo = (*(pu8BlkData + 6) & 0x07);
2580
2581 #if (DBG_HFVSDB_INFO == 1)
2582 printf("[HF-VSDB] Version = %d\r\n", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HF_VSDBVerInfo);
2583 printf("[HF-VSDB] Max_TMDS_Character_Rate = %d Mhz\r\n", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.MaxTmdsCharRate*5);
2584 printf("[HF-VSDB] SCDC_Present = %d\r\n", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportSCDC);
2585 printf("[HF-VSDB] RR_Capable = %d\r\n", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportRR);
2586 printf("[HF-VSDB] LTF_340Mcsc_Scramble = %d\r\n", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportLTEScramble);
2587 #if 0
2588 printf("[HF-VSDB] Independent_View = %d\r\n", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportIndependView);
2589 printf("[HF-VSDB] Dual_View = %d\r\n", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportDualView);
2590 printf("[HF-VSDB] 3D_OSD_Disparity = %d\r\n", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support3DOsdDisparity);
2591 #endif
2592 printf("[HF-VSDB] DC_420_Info = %d\r\n", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YUV420DeepColorInfo);
2593 #endif
2594
2595 #undef DBG_HFVSDB_INFO
2596
2597 return TRUE;
2598 }
2599
2600 //**************************************************************************/
2601 // [Function Name]:
2602 // drv_HDMITx_ParseCEAExtEdid()
2603 // [Description]:
2604 // Parsing CEA extend EDID part
2605 // [Arguments]:
2606 // [MS_U8]* pu8BlkData
2607 // [Return]:
2608 // [MS_BOOL] TRUE: successful; FALSE: failed
2609 //**************************************************************************/
_MDrv_HDMITx_ParseCEAExtEdid(void * pInstance,MS_U8 * pu8BlkData)2610 MS_BOOL _MDrv_HDMITx_ParseCEAExtEdid(void* pInstance, MS_U8* pu8BlkData) //wilson@kano
2611 {
2612 #define DBG_PARSE_CEA_EDID 1
2613 MS_U8 u8DescOffset = 0;
2614 MS_U8 u8CurIdx = 0;
2615 MS_U8 i = 0;
2616 MS_U8 u8BlkLen = 0;
2617 MS_U8 u8BlkTagCode = 0;
2618
2619 _HDMITX_GET_VARIABLE();
2620
2621 //support CEA Extension Version 3
2622 if ((*(pu8BlkData) == 0x02) && (*(pu8BlkData + 1) < 0x04))
2623 {
2624 u8DescOffset = *(pu8BlkData + 2);
2625
2626 if ((u8DescOffset < 0x05) || (u8DescOffset == 0xFF)) //invalid offset value;
2627 return FALSE;
2628
2629 //psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportHdmi = TRUE;
2630
2631 u8CurIdx = 0x04; //start of data block collection
2632
2633 while (u8CurIdx < u8DescOffset)
2634 {
2635 u8BlkTagCode = (*(pu8BlkData + u8CurIdx) & 0xE0) >> 5;
2636 u8BlkLen = *(pu8BlkData + u8CurIdx) & 0x1F;
2637
2638 switch (u8BlkTagCode)
2639 {
2640 case CEATag_AudioBlk:
2641 {
2642 #if (DBG_PARSE_CEA_EDID == 1)
2643 printf("%s::Short Audio Block:%d \n", __FUNCTION__, u8BlkLen);
2644 #endif
2645
2646 u8CurIdx++;
2647
2648 for ( i = 0; i < u8BlkLen; i++ )
2649 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.AudioDataBlk[i] = *(pu8BlkData + u8CurIdx + i);
2650
2651 u8CurIdx += u8BlkLen;
2652 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.CEADataBlkLen[u8BlkTagCode] = u8BlkLen;
2653 }
2654 break;
2655
2656 case CEATag_VideoBlk:
2657 {
2658 MS_U8 ucOffset = 0; // for multiple video block present
2659 #if (DBG_PARSE_CEA_EDID == 1)
2660 printf("%s::Short Video Block: %d\r\n", __FUNCTION__, u8BlkLen);
2661 #endif
2662
2663 u8CurIdx++;
2664 ucOffset = g_u8SupTimingNum;
2665 for ( i = 0; i < u8BlkLen; i++ )
2666 {
2667 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk[ucOffset + i] = *(pu8BlkData + u8CurIdx + i);
2668 #if 0
2669 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[g_u8SupTimingNum].VideoTiming = psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk[ucOffset + i] & 0x7F;
2670
2671 if ((psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[g_u8SupTimingNum].VideoTiming <= E_HDMITX_VIC_1920x1080p_60_16_9) |
2672 (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[g_u8SupTimingNum].VideoTiming == E_HDMITX_VIC_2880x480p_60_4_3) |
2673 (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[g_u8SupTimingNum].VideoTiming == E_HDMITX_VIC_2880x480p_60_16_9))
2674 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support2D_60Hz = TRUE;
2675 else if ((psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[g_u8SupTimingNum].VideoTiming <= E_HDMITX_VIC_1920x1080p_50_16_9) |
2676 (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[g_u8SupTimingNum].VideoTiming == E_HDMITX_VIC_2880x576p_50_4_3) |
2677 (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[g_u8SupTimingNum].VideoTiming == E_HDMITX_VIC_2880x576p_50_16_9)|
2678 (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[g_u8SupTimingNum].VideoTiming == E_HDMITX_VIC_1920x1080i_50_16_9_1250_total))
2679 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support2D_50Hz = TRUE;
2680 #endif
2681 g_u8SupTimingNum++;
2682 }
2683
2684 u8CurIdx += u8BlkLen;
2685 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.CEADataBlkLen[u8BlkTagCode] = u8BlkLen;
2686 }
2687 break;
2688 case CEATag_VendorSpecific:
2689 {
2690 MS_BOOL bIsVSDB = TRUE;
2691 #if (DBG_PARSE_CEA_EDID == 1)
2692 printf("%s::VSDB\r\n", __FUNCTION__);
2693 #endif
2694
2695 u8CurIdx++;
2696
2697 //check IEEE HDMI identifier
2698 for ( i = 0; i < sizeof(VSDB_HDMI_IEEE_ID); i++ )
2699 {
2700 if ( *(pu8BlkData + u8CurIdx + i) != VSDB_HDMI_IEEE_ID[i] )
2701 {
2702 bIsVSDB = FALSE;
2703 break;
2704 }
2705 }
2706
2707 if (bIsVSDB == FALSE)
2708 {
2709 //check if HF-VSDB
2710 if (_MDrv_HDMITx_ParseHFVSDB(pInstance, pu8BlkData + u8CurIdx, u8BlkLen, g_u8SupTimingNum))
2711 {
2712 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HF_VSDB_Len = u8BlkLen;
2713 memcpy(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HF_VSDB, pu8BlkData + u8CurIdx, u8BlkLen);
2714 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportHdmi = TRUE;
2715 printf("HF-VSDB Presented!!\n");
2716 }
2717 else
2718 {
2719 printf("HF-VSDB Parsing Failed!!\n");
2720 }
2721 }
2722 else
2723 {
2724 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportHdmi = TRUE;
2725
2726 if (_MDrv_HDMITx_ParseHdmiVSDB(pInstance, pu8BlkData + u8CurIdx, u8BlkLen, g_u8SupTimingNum))
2727 {
2728 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HDMI_VSDB_Len = u8BlkLen;
2729 memcpy(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HDMI_VSDB, pu8BlkData + u8CurIdx, u8BlkLen);
2730
2731 psHDMITXResPri->stHDMITxInfo.output_mode |= (MS_U8)BIT1; // default is DVI mode
2732
2733 switch (*(pu8BlkData + 3) & 0x30)
2734 {
2735 case 0x00:
2736 //psHDMITXResPri->stHDMITxInfo.output_color = E_HDMITX_VIDEO_COLOR_RGB444;
2737 #if (DBG_PARSE_CEA_EDID == 1)
2738 printf("%s::Not Support YCbCr!!\n", __FUNCTION__);
2739 #endif
2740 break;
2741
2742 case 0x20:
2743 if (psHDMITXResPri->stHDMITxInfo.input_color == E_HDMITX_VIDEO_COLOR_YUV444)
2744 {
2745 psHDMITXResPri->stHDMITxInfo.output_color = E_HDMITX_VIDEO_COLOR_YUV444;
2746 #if (DBG_PARSE_CEA_EDID == 1)
2747 printf("%s::Output YUV444!!\n", __FUNCTION__);
2748 #endif
2749 }
2750 break;
2751
2752 case 0x10:
2753 if (psHDMITXResPri->stHDMITxInfo.input_color == E_HDMITX_VIDEO_COLOR_YUV422)
2754 {
2755 psHDMITXResPri->stHDMITxInfo.output_color = E_HDMITX_VIDEO_COLOR_YUV422;
2756 #if (DBG_PARSE_CEA_EDID == 1)
2757 printf("%s::Output YUV422!!\n",__FUNCTION__);
2758 #endif
2759 }
2760 break;
2761
2762 default:
2763 break;
2764 }
2765 }
2766 }
2767 u8CurIdx += u8BlkLen;
2768 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.CEADataBlkLen[u8BlkTagCode] = u8BlkLen;
2769 }
2770 break;
2771
2772 case CEATag_UseExtTag:
2773 {
2774 MS_U8 ucExtTagCode = 0x00;
2775
2776 ucExtTagCode = *(pu8BlkData + (++u8CurIdx));
2777 u8CurIdx++;
2778 printf("%s::Extend Tag Code = 0x%02X, block Len = 0x%X\r\n", __FUNCTION__, ucExtTagCode, u8BlkLen);
2779
2780 switch (ucExtTagCode)
2781 {
2782 case CEAExtTag_YCbCr420VideoDB:
2783 printf("YCbCr420 Video Data Block::\n");
2784 for ( i = 0; i < (u8BlkLen - 1); i++ )
2785 {
2786 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420VidDataBlk[i] = *(pu8BlkData + u8CurIdx);
2787 u8CurIdx++;
2788 printf("0x%02X, ", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420VidDataBlk[i]);
2789 }
2790 printf("\r\n");
2791 break;
2792
2793 case CEAExtTag_YCbCr420CapMapDB:
2794 printf("YCbCr420 Capability Map Data Block::\n");
2795 for ( i = 0; i < (u8BlkLen - 1); i++ )
2796 {
2797 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420CapMapDataBlk[i] = *(pu8BlkData + u8CurIdx);
2798 u8CurIdx++;
2799 printf("0x%02X, ", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420CapMapDataBlk[i]);
2800 }
2801 printf("\r\n");
2802 break;
2803
2804 case CEAExtTag_ColorimetryDB:
2805 printf("Colorimetry Data Block::\n");
2806
2807 if (u8BlkLen != 0x03) //valid length
2808 {
2809 printf("Invalid Length of Colorimetry Data Block\r\n");
2810 return FALSE;
2811 }
2812 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ExtColorimetry = *(pu8BlkData + u8CurIdx);
2813 u8CurIdx+=2; //u8CurIdx++;
2814 //TBD: MD parsing
2815 break;
2816
2817 case CEAExtTag_HDRStaticMetaDB:
2818 printf("HDR Static Metadata Data Block::\n");
2819
2820 for ( i = 0; i < (u8BlkLen - 1); i++ )
2821 {
2822 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HDRStaticDataBlk[i] = *(pu8BlkData + u8CurIdx);
2823 u8CurIdx++;
2824 printf("0x%02X, ", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HDRStaticDataBlk[i]);
2825 if ((i+1)%16 == 0)
2826 printf("\r\n");
2827 }
2828 printf("\r\n");
2829
2830 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.bSupportHDR = TRUE;
2831 break;
2832
2833 default:
2834 printf("drv_HDMITx_ParseCEAExtEdid()::Extend Tag Code Unsupport!!\n");
2835 u8CurIdx += (u8BlkLen - 1);
2836 break;
2837 }
2838 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.CEADataBlkLen[u8BlkTagCode] = u8BlkLen;
2839 }
2840 break;
2841
2842 case CEATag_SpeakerAlloc:
2843 case CEATag_VESA_DTCBlk:
2844 case CEATag_Reserved_1:
2845 default:
2846 u8CurIdx += (u8BlkLen + 1);
2847 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.CEADataBlkLen[u8BlkTagCode] = u8BlkLen;
2848 break;
2849 }
2850 }
2851 }
2852
2853 return TRUE;
2854 }
2855
2856 //**************************************************************************/
2857 // [Function Name]:
2858 // MDrv_HDMITx_EdidChecking()
2859 // [Description]:
2860 // Parsing and storing information from sink device's EDID
2861 // [Arguments]:
2862 // void
2863 // [Return]:
2864 // [MS_BOOL] TRUE: successful; FALSE: failed
2865 //
2866 //**************************************************************************/
MDrv_HDMITx_EdidChecking(void * pInstance)2867 MS_BOOL MDrv_HDMITx_EdidChecking(void* pInstance)
2868 {
2869 #define DBG_HDMITx_CheckEDID 1
2870 MS_U8 i = 0;
2871 MS_U8 u8EDIDRetryCnt = 3;
2872 MS_U8 u8ExtBlkNum = 0;
2873 MS_U8 u8ValidBlkNum = 0;
2874 MS_U8 blkData[HDMITX_EDID_BLK_SIZE] = {0x00};
2875 const MS_U8 EDID_HEADER_TAG[8] =
2876 {
2877 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00
2878 };
2879
2880 if (!bCheckEDID)
2881 return TRUE;
2882
2883 //init buf
2884 g_u8SupTimingNum = 0;
2885 _MDrv_HDMITX_InitEdidField(pInstance);
2886 //memset(&gHDMITxInfo.RxEdidInfo, 0x00, sizeof(stHDMITX_RxEDID_Info));
2887 //memset(blkData, 0x00, HDMITX_EDID_BLK_SIZE);
2888
2889 _HDMITX_GET_VARIABLE();
2890 psHDMITXResPri->stHDMITxInfo.output_mode &= (~(MS_U8)BIT1); //default is DVI mode;
2891
2892 while (MHal_HDMITx_EdidReadBlock(0x00, blkData) == FALSE)
2893 {
2894 u8EDIDRetryCnt--;
2895
2896 if (u8EDIDRetryCnt == 0)
2897 {
2898 //reset buf
2899 memset(blkData, 0x00, HDMITX_EDID_BLK_SIZE);
2900
2901 #if (DBG_HDMITx_CheckEDID == 1)
2902 printf("[HDMITx] Check EDID fail!!\n");
2903 #endif
2904
2905 break;
2906 }
2907
2908 MsOS_DelayTask(100);
2909 }
2910 if (u8EDIDRetryCnt == 0)
2911 {
2912 //return FALSE;
2913 }
2914
2915 #if (DBG_HDMITx_CheckEDID == 1)
2916 printf("%s::block 0 ==>\n", __FUNCTION__);
2917 for ( i = 0; i < HDMITX_EDID_BLK_SIZE; i++ )
2918 {
2919 printf("0x%02X, ", blkData[i]);
2920
2921 if ( (i+1)%16 == 0 )
2922 printf("\r\n");
2923 }
2924 printf("\r\n");
2925 #endif
2926
2927 //validiate EDID tag
2928 for ( i = 0; i < sizeof(EDID_HEADER_TAG); i++ )
2929 {
2930 if (blkData[i] != EDID_HEADER_TAG[i])
2931 {
2932 printf("%s::invalid EDID header!!\n", __FUNCTION__);
2933 //return FALSE;
2934 }
2935 }
2936
2937 //store block 0
2938 memcpy(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk0, blkData, HDMITX_EDID_BLK_SIZE*sizeof(MS_U8));
2939
2940 //Get Manufacturer ID
2941 //****************************************
2942 // EISA 3-character ID
2943 // 08h_b'[6..2]: first char
2944 // 08h_b'[1..0] & 09h_b'[7..5]: second char
2945 // 09h_b'[4..0]: third char
2946 //****************************************
2947 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ManufacturerID[0] = (blkData[8] & 0x7C) >> 2;
2948 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ManufacturerID[1] = ((blkData[8] & 0x03) << 3) | ((blkData[9] & 0xE0) >> 5);
2949 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ManufacturerID[2] = blkData[9] & 0x1F;
2950
2951 //check if there are more Extended block
2952 u8ExtBlkNum = blkData[0x7E];
2953
2954 #if (DBG_HDMITx_CheckEDID == 1)
2955 printf("%s::Extension Block Number = %d\r\n", __FUNCTION__, u8ExtBlkNum);
2956
2957 if (u8ExtBlkNum > 4)
2958 printf("%s::Number of Extension Block > 4!!\n", __FUNCTION__);
2959 #endif
2960
2961 for ( i = 1; i <= ((u8ExtBlkNum >= 4) ? 4 : u8ExtBlkNum); i++ )
2962 {
2963 u8EDIDRetryCnt = 3;
2964
2965 while (MHal_HDMITx_EdidReadBlock(i, blkData) == FALSE)
2966 {
2967 u8EDIDRetryCnt--;
2968
2969 if ((u8EDIDRetryCnt == 0) || (u8EDIDRetryCnt > 3))
2970 {
2971 //reset buf
2972 memset(blkData, 0x00, HDMITX_EDID_BLK_SIZE);
2973
2974 #if (DBG_HDMITx_CheckEDID == 1)
2975 printf("[HDMITx] Check EDID fail--1!!\n");
2976 #endif
2977
2978 break;
2979 }
2980 MsOS_DelayTask(100);
2981 }
2982
2983 if (u8EDIDRetryCnt != 0)
2984 {
2985 u8ValidBlkNum++;
2986 }
2987 }
2988
2989 if ((u8ValidBlkNum == 0) && (! psHDMITXResPri->stHDMITxInfo.hdmitx_force_mode))
2990 {
2991 //return FALSE;
2992 }
2993
2994 for ( i = 1; i <= u8ValidBlkNum; i++)
2995 {
2996 while (MHal_HDMITx_EdidReadBlock(i, blkData) == FALSE)
2997 {
2998 u8EDIDRetryCnt--;
2999
3000 if ((u8EDIDRetryCnt == 0) || (u8EDIDRetryCnt > 3))
3001 {
3002 //reset buf
3003 memset(blkData, 0x00, HDMITX_EDID_BLK_SIZE);
3004
3005 #if (DBG_HDMITx_CheckEDID == 1)
3006 printf("[HDMITx] Check EDID fail--2!!\n");
3007 #endif
3008
3009 break;
3010 }
3011 MsOS_DelayTask(100);
3012 }
3013
3014 if (u8EDIDRetryCnt != 0)
3015 {
3016 //dump block content
3017 #if (DBG_HDMITx_CheckEDID == 1)
3018 MS_U8 j = 0;
3019
3020 printf("%s::Block #%d\r\n", __FUNCTION__, i);
3021 for ( j = 0; j < HDMITX_EDID_BLK_SIZE; j++ )
3022 {
3023 printf("0x%02X, ", blkData[j]);
3024 if ( (j+1) % 16 == 0 )
3025 printf("\r\n");
3026 }
3027 printf("\r\n");
3028 #endif
3029
3030 if ( i == 1 )
3031 memcpy(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk1, &blkData, 128); //store block #1
3032
3033 if ( !_MDrv_HDMITx_ParseCEAExtEdid(pInstance, blkData) ) //invalid CEA Extension block
3034 continue;
3035 }
3036 else
3037 {
3038 #if (DBG_HDMITx_CheckEDID == 1)
3039 printf("%s::Access EDID fail @ Block 0x%02X!!\n", __FUNCTION__, i);
3040 #endif
3041 if (! psHDMITXResPri->stHDMITxInfo.hdmitx_force_mode)
3042 {
3043 //return FALSE;
3044 }
3045 else
3046 {
3047 continue;
3048 }
3049 }
3050 }
3051
3052 //TBD: if API layer force output mode
3053 if (psHDMITXResPri->stHDMITxInfo.hdmitx_force_mode) // AP force output mode
3054 {
3055 psHDMITXResPri->stHDMITxInfo.output_mode = psHDMITXResPri->stHDMITxInfo.force_output_mode;
3056 if((psHDMITXResPri->stHDMITxInfo.force_output_mode == E_HDMITX_DVI) || (psHDMITXResPri->stHDMITxInfo.force_output_mode == E_HDMITX_DVI_HDCP)) // DVI mode
3057 {
3058 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.AudSupportAI = FALSE;
3059 psHDMITXResPri->stHDMITxInfo.output_color = E_HDMITX_VIDEO_COLOR_RGB444;
3060 }
3061 }
3062
3063 // AP force output color format
3064 if((psHDMITXResPri->stHDMITxInfo.output_mode == E_HDMITX_HDMI || psHDMITXResPri->stHDMITxInfo.output_mode == E_HDMITX_HDMI_HDCP) && (psHDMITXResPri->stHDMITxInfo.hdmitx_force_output_color))
3065 {
3066 psHDMITXResPri->stHDMITxInfo.output_color = psHDMITXResPri->stHDMITxInfo.force_output_color;
3067 }
3068
3069 // YUV444 -> RGB444
3070 #if 0
3071 if( (psHDMITXResPri->stHDMITxInfo.input_color != psHDMITXResPri->stHDMITxInfo.output_color) && (psHDMITXResPri->stHDMITxInfo.output_color == E_HDMITX_VIDEO_COLOR_RGB444) )
3072 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = TRUE;
3073 else // bypass
3074 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = FALSE;
3075 #endif
3076
3077 #undef DBG_HDMITx_CheckEDID
3078
3079 psHDMITXResPri->stHDMITxInfo.hdmitx_edid_ready = TRUE;
3080 bCheckEDID = FALSE;
3081
3082 Mhal_HDMITx_SetSCDCCapability(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportSCDC);
3083
3084 return TRUE;
3085
3086 }
3087
3088 //------------------------------------------------------------------------------
3089 /// @brief This routine set HDMI Tx initial situation.
3090 /// @return None
3091 //------------------------------------------------------------------------------
MDrv_HDMITx_InitVariable(void * pInstance)3092 void MDrv_HDMITx_InitVariable(void* pInstance)
3093 {
3094 _HDMITX_GET_VARIABLE();
3095
3096 psHDMITXResPri->stHDMITxInfo.bHDMITxTaskIdCreated = FALSE;
3097 psHDMITXResPri->stHDMITxInfo.bHDMITxEventIdCreated = FALSE;
3098 psHDMITXResPri->stHDMITxInfo.bCheckRxTimerIdCreated = FALSE;
3099
3100 psHDMITXResPri->stHDMITxInfo.hdmitx_enable_flag = FALSE;
3101 psHDMITXResPri->stHDMITxInfo.hdmitx_tmds_flag = TRUE;
3102 psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag = TRUE;
3103 psHDMITXResPri->stHDMITxInfo.hdmitx_audio_flag = TRUE;
3104 psHDMITXResPri->stHDMITxInfo.hdmitx_hdcp_flag = FALSE;
3105 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = FALSE;
3106
3107 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state = E_HDMITX_FSM_PENDING;
3108 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_prestate = E_HDMITX_FSM_PENDING;
3109 psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status = E_HDMITX_DVIClock_L_HPD_L;
3110 _hdmitx_preRX_status = psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status;
3111 psHDMITXResPri->stHDMITxInfo.hdmitx_RB_swap_flag = FALSE;
3112 psHDMITXResPri->stHDMITxInfo.hdmitx_force_mode = FALSE;
3113 psHDMITXResPri->stHDMITxInfo.hdmitx_force_output_color = FALSE;
3114 psHDMITXResPri->stHDMITxInfo.hdmitx_AFD_override_mode = FALSE;
3115 psHDMITXResPri->stHDMITxInfo.hdmitx_edid_ready = FALSE;
3116 psHDMITXResPri->stHDMITxInfo.hdmitx_avmute_flag = FALSE;
3117 psHDMITXResPri->stHDMITxInfo.hdmitx_CECEnable_flag = TRUE; // CEC
3118
3119 psHDMITXResPri->stHDMITxInfo.output_mode = E_HDMITX_DVI;
3120 psHDMITXResPri->stHDMITxInfo.force_output_mode = E_HDMITX_HDMI;
3121 psHDMITXResPri->stHDMITxInfo.ext_colorimetry = E_HDMITX_EXT_COLORIMETRY_XVYCC601;
3122 psHDMITXResPri->stHDMITxInfo.colorimetry = E_HDMITX_COLORIMETRY_MAX;
3123 psHDMITXResPri->stHDMITxInfo.enYCCQuantRange = E_HDMITX_YCC_QUANT_LIMIT;
3124 psHDMITXResPri->stHDMITxInfo.output_colordepth_val = E_HDMITX_VIDEO_CD_NoID;//E_HDMITX_VIDEO_CD_24Bits;
3125 psHDMITXResPri->stHDMITxInfo.output_video_prevtiming = E_HDMITX_RES_MAX;
3126 #if 0
3127 psHDMITXResPri->stHDMITxInfo.output_video_timing = E_HDMITX_RES_720x480p;
3128 #else
3129 psHDMITXResPri->stHDMITxInfo.output_video_timing = E_HDMITX_RES_1280x720p_60Hz;
3130 #endif
3131 psHDMITXResPri->stHDMITxInfo.force_output_color = E_HDMITX_VIDEO_COLOR_RGB444;
3132 psHDMITXResPri->stHDMITxInfo.input_color = E_HDMITX_VIDEO_COLOR_RGB444;
3133 psHDMITXResPri->stHDMITxInfo.output_color = E_HDMITX_VIDEO_COLOR_RGB444;
3134 psHDMITXResPri->stHDMITxInfo.input_range = E_HDMITX_YCC_QUANT_LIMIT;
3135 psHDMITXResPri->stHDMITxInfo.output_range = E_HDMITX_YCC_QUANT_LIMIT;
3136 psHDMITXResPri->stHDMITxInfo.output_aspect_ratio = E_HDMITX_VIDEO_AR_4_3;
3137 psHDMITXResPri->stHDMITxInfo.output_scan_info = E_HDMITX_VIDEO_SI_NoData;
3138 psHDMITXResPri->stHDMITxInfo.output_afd_ratio = E_HDMITX_VIDEO_AFD_SameAsPictureAR;
3139 psHDMITXResPri->stHDMITxInfo.output_activeformat_present = 1;
3140 psHDMITXResPri->stHDMITxInfo.output_audio_frequncy = E_HDMITX_AUDIO_48K;
3141 psHDMITXResPri->stHDMITxInfo.hdmitx_bypass_flag = FALSE;
3142 #ifdef OBERON
3143 psHDMITXResPri->stHDMITxInfo.output_audio_channel = E_HDMITX_AUDIO_CH_8;
3144 #else // Uranus, Uranus4
3145 psHDMITXResPri->stHDMITxInfo.output_audio_channel = E_HDMITX_AUDIO_CH_2;
3146 #endif
3147 psHDMITXResPri->stHDMITxInfo.output_audio_type = E_HDMITX_AUDIO_PCM;
3148
3149 // HDMI Tx Pre-emphasis and Double termination
3150 memset(&psHDMITXResPri->stHDMITxInfo.analog_setting, 0, sizeof(psHDMITXResPri->stHDMITxInfo.analog_setting));
3151
3152 _MDrv_HDMITX_InitEdidField(pInstance);
3153 #if 0
3154 //edid relative //assign initial value
3155 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk0, 0x00, HDMITX_EDID_BLK_SIZE*sizeof(MS_U8));
3156 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk1, 0x00, HDMITX_EDID_BLK_SIZE*sizeof(MS_U8));
3157 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ManufacturerID, 0x00, 3*sizeof(MS_U8));
3158 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.CEADataBlkLen, 0x00, HDMITX_CEA_DAT_BLK_TYPE_NUM*sizeof(MS_U8));
3159 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.PhyAddr, 0x00, 2*sizeof(MS_U8));
3160 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportHdmi = FALSE;
3161
3162 //HF-VSDB, scdc relative
3163 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HF_VSDBVerInfo = 0x00;
3164 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.MaxTmdsCharRate = 0x00;
3165 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportIndependView = FALSE;
3166 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportDualView = FALSE;
3167 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support3DOsdDisparity = FALSE;
3168 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportLTEScramble = FALSE;
3169 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportSCDC = FALSE;
3170
3171 //read request
3172 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YUV420DeepColorInfo = 0x00;
3173 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.AudSupportAI = FALSE;
3174 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.b3DPresent = FALSE;
3175 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support2D_50Hz = FALSE;
3176 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support2D_60Hz = FALSE;
3177 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support3D_50Hz = FALSE;
3178 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support3D_60Hz = FALSE;
3179 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ColorDepthInfo = E_HDMITX_VIDEO_CD_NoID;
3180
3181 // data block content
3182 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.AudioDataBlk, 0x00, 32*sizeof(MS_U8));
3183 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk, 0x00, 32*sizeof(MS_U8));
3184 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VendorDataBlk, 0x00, 32*sizeof(MS_U8));
3185 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SpeakerAllocDataBlk, 0x00, 32*sizeof(MS_U8));
3186 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VESA_DTCDataBlk, 0x00, 32*sizeof(MS_U8));
3187 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICList, 0x00, 7*sizeof(MS_U8)); //this field has only 3 bits
3188 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming, 0x00, 32*sizeof(MS_U8));
3189
3190 //for 420
3191 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420VidDataBlk, 0x00, 32*sizeof(MS_U8));
3192 memset(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420CapMapDataBlk, 0x00, 32*sizeof(MS_U8));
3193
3194 //for colorimetry
3195 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ExtColorimetry = 0x00;
3196 #endif
3197
3198 // Set DDC speed to 50KHz as default
3199 MHal_HDMITx_AdjustDDCFreq(50);
3200
3201 }
3202
3203 //------------------------------------------------------------------------------
3204 /// @brief This routine sends HDMI related packets.
3205 /// @param[in] packet_type packet type
3206 /// @param[in] packet_process packet behavior
3207 /// @return None
3208 //------------------------------------------------------------------------------
MDrv_HDMITx_SendPacket(MsHDMITX_PACKET_TYPE packet_type,MsHDMITX_PACKET_PROCESS packet_process)3209 void MDrv_HDMITx_SendPacket(MsHDMITX_PACKET_TYPE packet_type, MsHDMITX_PACKET_PROCESS packet_process)
3210 {
3211 MHal_HDMITx_SendPacket(packet_type, packet_process);
3212 }
3213
3214 //**************************************************************************/
3215 // [Function Name]:
3216 // MDrv_HDMITx_GetTmdsEnFlag()
3217 // [Description]:
3218 // return flag which indicate if tmds signal is enabled or not
3219 // [Arguments]:
3220 // void
3221 // [Return]:
3222 // MS_BOOL
3223 //
3224 //**************************************************************************/
MDrv_HDMITx_GetTmdsEnFlag(void * pInstance)3225 MS_BOOL MDrv_HDMITx_GetTmdsEnFlag(void* pInstance)
3226 {
3227 _HDMITX_GET_VARIABLE();
3228 return psHDMITXResPri->stHDMITxInfo.hdmitx_tmds_flag;
3229 }
3230
3231 //**************************************************************************/
3232 // [Function Name]:
3233 // MDrv_HDMITx_GetTmdsEnFlag()
3234 // [Description]:
3235 // return flag which indicate if tmds signal is enabled or not
3236 // [Arguments]:
3237 // void
3238 // [Return]:
3239 // MS_BOOL
3240 //
3241 //**************************************************************************/
MDrv_HDMITx_GetHdcpEnFlag(void * pInstance)3242 MS_BOOL MDrv_HDMITx_GetHdcpEnFlag(void* pInstance)
3243 {
3244 _HDMITX_GET_VARIABLE();
3245 return psHDMITXResPri->stHDMITxInfo.hdmitx_hdcp_flag;
3246 }
3247
3248
3249 //**************************************************************************/
3250 // [Function Name]:
3251 // MDrv_HDMITx_GetOutputMode()
3252 // [Description]:
3253 // return current hdmi output mode value
3254 // [Arguments]:
3255 // void
3256 // [Return]:
3257 // MsHDMITX_OUTPUT_MODE
3258 //
3259 //**************************************************************************
MDrv_HDMITx_GetOutputMode(void * pInstance)3260 MsHDMITX_OUTPUT_MODE MDrv_HDMITx_GetOutputMode(void* pInstance)
3261 {
3262 _HDMITX_GET_VARIABLE();
3263
3264 return psHDMITXResPri->stHDMITxInfo.output_mode;
3265 }
3266
3267 //**************************************************************************/
3268 // [Function Name]:
3269 // MDrv_HDMITx_GetRxStatus()
3270 // [Description]:
3271 // return current HDMI status
3272 // [Arguments]:
3273 // void
3274 // [Return]:
3275 // [MS_BOOL]
3276 //
3277 //**************************************************************************/
MDrv_HDMITx_GetRxStatus(void)3278 MS_BOOL MDrv_HDMITx_GetRxStatus(void)
3279 {
3280 if (MHal_HDMITx_GetRXStatus() == E_HDMITX_DVIClock_H_HPD_H)
3281 return TRUE;
3282 else
3283 return FALSE;
3284
3285 //return (gbCurRxStatus == E_HDMITX_DVIClock_H_HPD_H)? TRUE : FALSE;
3286 }
3287
3288 //**************************************************************************/
3289 // [Function Name]:
3290 // MDrv_HDMITx_GetFullRxStatus()
3291 // [Description]:
3292 // return current HPD and clock status
3293 // [Arguments]:
3294 // void
3295 // [Return]:
3296 // [MS_BOOL]
3297 //
3298 //**************************************************************************/
MDrv_HDMITx_GetFullRxStatus(void * pInstance)3299 MsHDMITX_RX_STATUS MDrv_HDMITx_GetFullRxStatus(void* pInstance)
3300 {
3301 MsHDMITX_RX_STATUS enRxStatus = E_HDMITX_DVIClock_L_HPD_L;
3302
3303 enRxStatus = MHal_HDMITx_GetRXStatus();
3304 return enRxStatus;
3305 }
3306
3307 //**************************************************************************/
3308 // [Function Name]:
3309 // MDrv_HDMITx_GetDeepColorMode()
3310 // [Description]:
3311 // return current deep color mode
3312 // [Arguments]:
3313 // void
3314 // [Return]:
3315 // [MsHDMITX_VIDEO_COLORDEPTH_VAL]
3316 //
3317 //**************************************************************************/
MDrv_HDMITx_GetDeepColorMode(void * pInstance)3318 MsHDMITX_VIDEO_COLORDEPTH_VAL MDrv_HDMITx_GetDeepColorMode(void* pInstance)
3319 {
3320 _HDMITX_GET_VARIABLE();
3321 return psHDMITXResPri->stHDMITxInfo.output_colordepth_val;
3322 }
3323
3324 //**************************************************************************/
3325 // [Function Name]:
3326 // MDrv_HDMITx_GetOutputTiming()
3327 // [Description]:
3328 // return current output timing
3329 // [Arguments]:
3330 // void
3331 // [Return]:
3332 // [MsHDMITX_VIDEO_TIMING]
3333 //
3334 //**************************************************************************/
MDrv_HDMITx_GetOutputTiming(void * pInstance)3335 MsHDMITX_VIDEO_TIMING MDrv_HDMITx_GetOutputTiming(void* pInstance)
3336 {
3337 _HDMITX_GET_VARIABLE();
3338
3339 return psHDMITXResPri->stHDMITxInfo.output_video_timing;
3340 }
3341
3342 //**************************************************************************/
3343 // [Function Name]:
3344 // MDrv_HDMITx_GetOutputTiming()
3345 // [Description]:
3346 // return current output timing
3347 // [Arguments]:
3348 // void
3349 // [Return]:
3350 // [MsHDMITX_VIDEO_TIMING]
3351 //
3352 //**************************************************************************/
MDrv_HDMITx_GetColorFormat(void * pInstance)3353 MsHDMITX_VIDEO_COLOR_FORMAT MDrv_HDMITx_GetColorFormat(void* pInstance)
3354 {
3355 _HDMITX_GET_VARIABLE();
3356
3357 return psHDMITXResPri->stHDMITxInfo.output_color;
3358 }
3359
3360 //**************************************************************************/
3361 // [Function Name]:
3362 // MDrv_HDMITx_GetRxDCInfoFromEDID()
3363 // [Description]:
3364 // Get deep color information from EDID
3365 // [Arguments]:
3366 // void
3367 // [Return]:
3368 // [HDMITX_VIDEO_COLORDEPTH_VAL]
3369 //
3370 //**************************************************************************/
MDrv_HDMITx_GetRxDCInfoFromEDID(void * pInstance)3371 MsHDMITX_VIDEO_COLORDEPTH_VAL MDrv_HDMITx_GetRxDCInfoFromEDID(void* pInstance)
3372 {
3373 _HDMITX_GET_VARIABLE();
3374 return psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ColorDepthInfo;
3375 }
3376
3377 //**************************************************************************/
3378 // [Function Name]:
3379 // MDrv_HDMITx_GetEdidRdyFlag()
3380 // [Description]:
3381 // return if sink EDID is ready
3382 // [Arguments]:
3383 // void
3384 // [Return]:
3385 // [MS_BOOL]
3386 //
3387 //**************************************************************************/
MDrv_HDMITx_GetEdidRdyFlag(void * pInstance)3388 MS_BOOL MDrv_HDMITx_GetEdidRdyFlag(void* pInstance)
3389 {
3390 _HDMITX_GET_VARIABLE();
3391 return psHDMITXResPri->stHDMITxInfo.hdmitx_edid_ready;
3392 }
3393
3394 //**************************************************************************/
3395 // [Function Name]:
3396 // MDrv_HDMITx_GetRxVideoFormatFromEDID()
3397 // [Description]:
3398 // return short video descriptor content of sink EDID
3399 // [Arguments]:
3400 // [MS_U8]* pu8Buffer
3401 // [MS_U8] u8BufSize
3402 // [Return]:
3403 // void
3404 //
3405 //**************************************************************************/
MDrv_HDMITx_GetRxVideoFormatFromEDID(void * pInstance,MS_U8 * pu8Buffer,MS_U8 u8BufSize)3406 void MDrv_HDMITx_GetRxVideoFormatFromEDID(void* pInstance, MS_U8 *pu8Buffer, MS_U8 u8BufSize)
3407 {
3408 _HDMITX_GET_VARIABLE();
3409 memcpy(pu8Buffer, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk, (u8BufSize > 32) ? 32*sizeof(MS_U8) : u8BufSize*sizeof(MS_U8));
3410 }
3411
3412 //**************************************************************************/
3413 // [Function Name]:
3414 // MDrv_HDMITx_GetDataBlockLengthFromEDID()
3415 // [Description]:
3416 // return length of specific data block
3417 // [Arguments]:
3418 // [MS_U8]* pu8Length
3419 // [MS_U8] u8TagCode
3420 // [Return]:
3421 // void
3422 //
3423 //**************************************************************************/
MDrv_HDMITx_GetDataBlockLengthFromEDID(void * pInstance,MS_U8 * pu8Length,MS_U8 u8TagCode)3424 void MDrv_HDMITx_GetDataBlockLengthFromEDID(void* pInstance, MS_U8 *pu8Length, MS_U8 u8TagCode)
3425 {
3426 _HDMITX_GET_VARIABLE();
3427 *pu8Length = (u8TagCode < HDMITX_CEA_DAT_BLK_TYPE_NUM) ? psHDMITXResPri->stHDMITxInfo.RxEdidInfo.CEADataBlkLen[u8TagCode] : 0x00;
3428 }
3429
3430 //**************************************************************************/
3431 // [Function Name]:
3432 // MDrv_HDMITx_GetRxAudioFormatFromEDID()
3433 // [Description]:
3434 // return short audio descriptor content of sink EDID
3435 // [Arguments]:
3436 // [MS_U8]* pu8Buffer
3437 // [MS_U8] u8BufSize
3438 // [Return]:
3439 // void
3440 //
3441 //**************************************************************************/
MDrv_HDMITx_GetRxAudioFormatFromEDID(void * pInstance,MS_U8 * pu8Buffer,MS_U8 u8BufSize)3442 void MDrv_HDMITx_GetRxAudioFormatFromEDID(void* pInstance, MS_U8 *pu8Buffer, MS_U8 u8BufSize)
3443 {
3444 _HDMITX_GET_VARIABLE();
3445 if (pu8Buffer != NULL)
3446 memcpy(pu8Buffer, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.AudioDataBlk, (u8BufSize > 32) ? 32 : u8BufSize);
3447 }
3448
3449 //**************************************************************************/
3450 // [Function Name]:
3451 // MDrv_HDMITx_EdidGetHDMISupportFlag()
3452 // [Description]:
3453 // return flag which indicate if sink EDID support HDMI
3454 // [Arguments]:
3455 // void
3456 // [Return]:
3457 // MS_BOOL
3458 //
3459 //**************************************************************************/
MDrv_HDMITx_EdidGetHDMISupportFlag(void * pInstance)3460 MS_BOOL MDrv_HDMITx_EdidGetHDMISupportFlag(void* pInstance)
3461 {
3462 _HDMITX_GET_VARIABLE();
3463 return psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportHdmi;
3464 }
3465
3466 //**************************************************************************/
3467 // [Function Name]:
3468 // MDrv_HDMITx_GetRxIDManufacturerName()
3469 // [Description]:
3470 // return flag which indicate if sink EDID support HDMI
3471 // [Arguments]:
3472 // [MS_U8] *pu8Buffer
3473 // [Return]:
3474 // void
3475 //
3476 //**************************************************************************/
MDrv_HDMITx_GetRxIDManufacturerName(void * pInstance,MS_U8 * pu8Buffer)3477 void MDrv_HDMITx_GetRxIDManufacturerName(void* pInstance, MS_U8 *pu8Buffer)
3478 {
3479 _HDMITX_GET_VARIABLE();
3480 memcpy(pu8Buffer, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ManufacturerID, sizeof(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ManufacturerID));
3481 }
3482
3483 //**************************************************************************
3484 // [Function Name]:
3485 // MDrv_HDMITx_GetEDIDData()
3486 // [Description]:
3487 // return data content of EDID block
3488 // [Arguments]:
3489 // [MS_U8] *pu8Buffer
3490 // [MS_BOOL] BlockIdx
3491 // [Return]:
3492 // void
3493 //
3494 //**************************************************************************
MDrv_HDMITx_GetEDIDData(void * pInstance,MS_U8 * pu8Buffer,MS_BOOL BlockIdx)3495 void MDrv_HDMITx_GetEDIDData(void* pInstance, MS_U8 *pu8Buffer, MS_BOOL BlockIdx)
3496 {
3497 _HDMITX_GET_VARIABLE();
3498 if (BlockIdx)
3499 {
3500 memcpy(pu8Buffer, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk1, 128*sizeof(MS_U8));
3501 }
3502 else
3503 {
3504 memcpy(pu8Buffer, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk0, 128*sizeof(MS_U8));
3505 }
3506 }
3507
3508 //**************************************************************************
3509 // [Function Name]:
3510 // MDrv_HDMITx_GetRx3DStructureFromEDID()
3511 // [Description]:
3512 // return current hdmi output mode value
3513 // [Arguments]:
3514 // [MsHDMITX_VIDEO_TIMING] timing
3515 // [MsHDMITX_EDID_3D_STRUCTURE_ALL] *p3DStructure
3516 // [Return]:
3517 // void
3518 //
3519 //**************************************************************************
MDrv_HDMITx_GetRx3DStructureFromEDID(void * pInstance,MsHDMITX_VIDEO_TIMING timing,MsHDMITX_EDID_3D_STRUCTURE_ALL * p3DStructure)3520 void MDrv_HDMITx_GetRx3DStructureFromEDID(void* pInstance, MsHDMITX_VIDEO_TIMING timing, MsHDMITX_EDID_3D_STRUCTURE_ALL *p3DStructure)
3521 {
3522 #if 0
3523 MS_U8 i;
3524 MsHDMITX_AVI_VIC vic = E_HDMITX_VIC_NOT_AVAILABLE;
3525 *p3DStructure = 0; // Default all not support
3526
3527 vic = _MDrv_HDMIRx_MapVideoTimingToVIC(timing);
3528
3529 _HDMITX_GET_VARIABLE();
3530
3531 if (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support3D_50Hz)
3532 {
3533 switch(vic)
3534 {
3535 case E_HDMITX_VIC_1920x1080p_24_16_9:
3536 *p3DStructure |= E_HDMITX_EDID_3D_FramePacking;
3537 *p3DStructure |= E_HDMITX_EDID_3D_TopandBottom;
3538 break;
3539 case E_HDMITX_VIC_1280x720p_50_16_9:
3540 *p3DStructure |= E_HDMITX_EDID_3D_FramePacking;
3541 *p3DStructure |= E_HDMITX_EDID_3D_TopandBottom;
3542 break;
3543 case E_HDMITX_VIC_1920x1080i_50_16_9:
3544 case E_HDMITX_VIC_1920x1080i_50_16_9_1250_total:
3545 *p3DStructure |= E_HDMITX_EDID_3D_SidebySide_Half_horizontal;
3546 break;
3547 default:
3548 break;
3549 }
3550
3551 }
3552
3553 if (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.Support3D_60Hz)
3554 {
3555 switch(vic)
3556 {
3557 case E_HDMITX_VIC_1920x1080p_24_16_9:
3558 *p3DStructure |= E_HDMITX_EDID_3D_FramePacking;
3559 *p3DStructure |= E_HDMITX_EDID_3D_TopandBottom;
3560 break;
3561 case E_HDMITX_VIC_1280x720p_60_16_9:
3562 *p3DStructure |= E_HDMITX_EDID_3D_FramePacking;
3563 *p3DStructure |= E_HDMITX_EDID_3D_TopandBottom;
3564 break;
3565 case E_HDMITX_VIC_1920x1080i_60_16_9:
3566 *p3DStructure |= E_HDMITX_EDID_3D_SidebySide_Half_horizontal;
3567 break;
3568 default:
3569 break;
3570 }
3571 }
3572
3573 for (i=0;i < 32;i++)
3574 {
3575 if (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[i].VideoTiming == vic)
3576 {
3577 *p3DStructure |= psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupVidTiming[i].Video3DInfo;
3578 }
3579 }
3580 #endif
3581 }
3582
3583 //------------------------------------------------------------------------------
3584 /// @brief This routine Get Audio CTS value
3585 /// @return CTS
3586 //------------------------------------------------------------------------------
MDrv_HDMITx_GetAudioCTS(void)3587 MS_U32 MDrv_HDMITx_GetAudioCTS(void)
3588 {
3589 return MHal_HDMITx_GetAudioCTS();
3590 }
3591
3592 //**************************************************************************
3593 // [Function Name]:
3594 // MDrv_HDMITx_GetAVMUTEState()
3595 // [Description]:
3596 // return AVMUTE flag
3597 // [Arguments]:
3598 // void
3599 // [Return]:
3600 // MS_BOOL
3601 //
3602 //**************************************************************************
MDrv_HDMITx_GetAVMUTEStatus(void * pInstance)3603 MS_BOOL MDrv_HDMITx_GetAVMUTEStatus(void* pInstance)
3604 {
3605 _HDMITX_GET_VARIABLE();
3606 return psHDMITXResPri->stHDMITxInfo.hdmitx_avmute_flag;
3607 }
3608
3609 /// Get version (without Mutex protect)
MDrv_HDMITx_GetLibVer(const MSIF_Version ** ppVersion)3610 MS_BOOL MDrv_HDMITx_GetLibVer(const MSIF_Version **ppVersion)
3611 {
3612 if (!ppVersion)
3613 {
3614 return FALSE;
3615 }
3616
3617 *ppVersion = &_drv_hdmi_tx_version;
3618 return TRUE;
3619 }
3620
MDrv_HDMITx_GetInfo(MS_HDMI_TX_INFO * pInfo)3621 MS_BOOL MDrv_HDMITx_GetInfo(MS_HDMI_TX_INFO *pInfo)
3622 {
3623 if (!pInfo)
3624 {
3625 return FALSE;
3626 }
3627
3628 memcpy((void*)pInfo, (void*)&_info, sizeof(MS_HDMI_TX_INFO));
3629 return TRUE;
3630 }
3631
MDrv_HDMITx_GetStatus(MS_HDMI_TX_Status * pStatus)3632 MS_BOOL MDrv_HDMITx_GetStatus(MS_HDMI_TX_Status *pStatus)
3633 {
3634 if (!pStatus)
3635 {
3636 return FALSE;
3637 }
3638
3639 memcpy((void*)pStatus, (void*)&_hdmitx_status, sizeof(MS_HDMI_TX_Status ));
3640 return TRUE;
3641 }
3642
3643 //**************************************************************************
3644 // [Function Name]:
3645 // MDrv_HDMITx_SetFSMState()
3646 // [Description]:
3647 // set state of hdmi tx FSM
3648 // [Arguments]:
3649 // [MDrvHDMITX_FSM_STATE] enState
3650 // [Return]:
3651 // void
3652 //
3653 //**************************************************************************
MDrv_HDMITx_GetFSMState(void * pInstance)3654 MDrvHDMITX_FSM_STATE MDrv_HDMITx_GetFSMState(void* pInstance)
3655 {
3656 _HDMITX_GET_VARIABLE();
3657 return psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state;
3658 }
3659
3660 //**************************************************************************
3661 // [Function Name]:
3662 // MDrv_HDMITx_GetEDIDPhyAdr()
3663 // [Description]:
3664 // Get sink physical address from EDID
3665 // [Arguments]:
3666 // [MS_U8]* pucData
3667 // [Return]:
3668 // void
3669 //
3670 //**************************************************************************
MDrv_HDMITx_GetEDIDPhyAdr(void * pInstance,MS_U8 * pucData)3671 void MDrv_HDMITx_GetEDIDPhyAdr(void* pInstance, MS_U8* pucData)
3672 {
3673 _HDMITX_GET_VARIABLE();
3674 memcpy(pucData, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.PhyAddr, 0x02);
3675 }
3676
3677 //**************************************************************************
3678 // [Function Name]:
3679 // MDrv_HDMITx_GetVICListFromEDID()
3680 // [Description]:
3681 // Get VIC list from EDID
3682 // [Arguments]:
3683 // [MS_U8] *pu8Buffer,
3684 // [MS_U8] u8BufSize,
3685 // [Return]:
3686 // MS_BOOL
3687 //
3688 //**************************************************************************
MDrv_HDMITx_GetVICListFromEDID(void * pInstance,MS_U8 * pu8Buffer,MS_U8 u8BufSize)3689 MS_BOOL MDrv_HDMITx_GetVICListFromEDID(void* pInstance, MS_U8 *pu8Buffer, MS_U8 u8BufSize)
3690 {
3691 _HDMITX_GET_VARIABLE();
3692 memcpy(pu8Buffer, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICList, (u8BufSize > 7) ? 7 : u8BufSize);
3693
3694 return TRUE;
3695 }
3696
3697 //**************************************************************************
3698 // [Function Name]:
3699 // MDrv_HDMITx_GetColorFormatFromEDID()
3700 // [Description]:
3701 // Get color format from EDID
3702 // [Arguments]:
3703 // [MS_U8]* pucData
3704 // [Return]:
3705 // void
3706 //
3707 //**************************************************************************
MDrv_HDMITx_GetColorFormatFromEDID(void * pInstance,MsHDMITX_VIDEO_TIMING timing,MsHDMITX_EDID_COLOR_FORMAT * pColorFmt)3708 MS_BOOL MDrv_HDMITx_GetColorFormatFromEDID(void* pInstance, MsHDMITX_VIDEO_TIMING timing, MsHDMITX_EDID_COLOR_FORMAT *pColorFmt)
3709 {
3710 _HDMITX_GET_VARIABLE();
3711
3712 MS_U8 i = 0;
3713 MsHDMITX_AVI_VIC enVICCode = (0x01 << E_HDMITX_VIC_NOT_AVAILABLE);
3714
3715 enVICCode = _MDrv_HDMIRx_MapVideoTimingToVIC(timing);
3716
3717 if ((psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk1[0] == 0x02) && (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk1[1] <= 0x04))
3718 {
3719 //YCbCr 420 only
3720 for ( i = 0; i < 32; i++ )
3721 {
3722 if (enVICCode == psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420VidDataBlk[i])
3723 {
3724 *pColorFmt = (0x01 << E_HDMITX_VIDEO_COLOR_YUV420);
3725 return TRUE;
3726 }
3727 }
3728
3729 switch (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk1[0x03] & 0x30)
3730 {
3731 case 0x00:
3732 *pColorFmt |= (0x01 << E_HDMITX_VIDEO_COLOR_RGB444);
3733 break;
3734
3735 case 0x10:
3736 *pColorFmt |= (0x01 << E_HDMITX_VIDEO_COLOR_RGB444);
3737 *pColorFmt |= (0x01 << E_HDMITX_VIDEO_COLOR_YUV422);
3738 break;
3739
3740 case 0x20:
3741 *pColorFmt |= (0x01 << E_HDMITX_VIDEO_COLOR_RGB444);
3742 *pColorFmt |= (0x01 << E_HDMITX_VIDEO_COLOR_YUV444);
3743 break;
3744
3745 case 0x30:
3746 *pColorFmt |= (0x01 << E_HDMITX_VIDEO_COLOR_RGB444);
3747 *pColorFmt |= (0x01 << E_HDMITX_VIDEO_COLOR_YUV444);
3748 *pColorFmt |= (0x01 << E_HDMITX_VIDEO_COLOR_YUV422);
3749 break;
3750
3751 default:
3752 *pColorFmt |= (0x01 << E_HDMITX_VIDEO_COLOR_RGB444);
3753 break;
3754 }
3755
3756 for ( i = 0; i < sizeof(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk); i++ )
3757 {
3758 if (enVICCode == psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk[i])
3759 {
3760 if (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420CapMapDataBlk[i >> 3] & (0x01 << (i % 8)))
3761 {
3762 *pColorFmt |= (0x01 << E_HDMITX_VIDEO_COLOR_YUV420);
3763 }
3764 }
3765 }
3766 }
3767 else
3768 {
3769 *pColorFmt |= (0x01 << E_HDMITX_VIDEO_COLOR_RGB444);
3770 }
3771
3772 return TRUE;
3773 }
3774
3775 //**************************************************************************
3776 // [Function Name]:
3777 // MDrv_HDMITx_GetAudioDataBlock()
3778 // [Description]:
3779 // Get Audio data block from EDID
3780 // [Arguments]:
3781 // [MS_U8]* pu8Data: buff to store data block content
3782 // [MS_U32] u32DataLen: buff length
3783 // [MS_U32]* pu32RealLen: real length of edid data block
3784 // [Return]:
3785 // void
3786 //
3787 //**************************************************************************
MDrv_HDMITx_GetAudioDataBlock(void * pInstance,MS_U8 * pu8Data,MS_U32 u32DataLen,MS_U32 * pu32RealLen)3788 void MDrv_HDMITx_GetAudioDataBlock(void* pInstance, MS_U8* pu8Data, MS_U32 u32DataLen, MS_U32* pu32RealLen)
3789 {
3790 _HDMITX_GET_VARIABLE();
3791
3792 if (pu8Data != NULL)
3793 {
3794 memcpy(pu8Data, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.AudioDataBlk, (u32DataLen > 32) ? 32 : u32DataLen);
3795 *pu32RealLen = (u32DataLen > 32) ? 32 : u32DataLen;
3796 }
3797 }
3798
3799 //**************************************************************************
3800 // [Function Name]:
3801 // MDrv_HDMITx_GetVideoDataBlock()
3802 // [Description]:
3803 // Get video data block from EDID
3804 // [Arguments]:
3805 // [MS_U8]* pu8Data: buff to store data block content
3806 // [MS_U32] u32DataLen: buff length
3807 // [MS_U32]* pu32RealLen: real length of edid data block
3808 // [Return]:
3809 // void
3810 //
3811 //**************************************************************************
MDrv_HDMITx_GetVideoDataBlock(void * pInstance,MS_U8 * pu8Data,MS_U32 u32DataLen,MS_U32 * pu32RealLen)3812 void MDrv_HDMITx_GetVideoDataBlock(void* pInstance, MS_U8* pu8Data, MS_U32 u32DataLen, MS_U32* pu32RealLen)
3813 {
3814 _HDMITX_GET_VARIABLE();
3815
3816 if (pu8Data != NULL)
3817 {
3818 memcpy(pu8Data, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk, (u32DataLen > 32) ? 32 : u32DataLen);
3819 *pu32RealLen = (u32DataLen > 32) ? 32 : u32DataLen;
3820 }
3821 }
3822
3823 //**************************************************************************
3824 // [Function Name]:
3825 // MDrv_HDMITx_GetVSDB()
3826 // [Description]:
3827 // Get vendor-specific data block from EDID
3828 // [Arguments]:
3829 // [MS_U8]* pu8Data: buff to store data block content
3830 // [MS_U32] u32DataLen: buff length
3831 // [MS_U32]* pu32RealLen: real length of edid data block
3832 // [Return]:
3833 // void
3834 //
3835 //**************************************************************************
MDrv_HDMITx_GetVSDB(void * pInstance,MS_U8 * pu8Data,MS_U32 u32DataLen,MS_U32 * pu32RealLen)3836 void MDrv_HDMITx_GetVSDB(void* pInstance, MS_U8* pu8Data, MS_U32 u32DataLen, MS_U32* pu32RealLen)
3837 {
3838 _HDMITX_GET_VARIABLE();
3839
3840 if (pu8Data != NULL)
3841 {
3842 *pu32RealLen = (u32DataLen > psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HDMI_VSDB_Len) ? psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HDMI_VSDB_Len : u32DataLen;
3843 memcpy(pu8Data, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HDMI_VSDB, *pu32RealLen);
3844 }
3845 }
3846
3847 //**************************************************************************
3848 // [Function Name]:
3849 // MDrv_HDMITx_GetHFVSDB()
3850 // [Description]:
3851 // Get vendor-specific data block from EDID
3852 // [Arguments]:
3853 // [MS_U8]* pu8Data: buff to store data block content
3854 // [MS_U32] u32DataLen: buff length
3855 // [MS_U32]* pu32RealLen: real length of edid data block
3856 // [Return]:
3857 // void
3858 //
3859 //**************************************************************************
MDrv_HDMITx_GetHFVSDB(void * pInstance,MS_U8 * pu8Data,MS_U32 u32DataLen,MS_U32 * pu32RealLen)3860 void MDrv_HDMITx_GetHFVSDB(void* pInstance, MS_U8* pu8Data, MS_U32 u32DataLen, MS_U32* pu32RealLen)
3861 {
3862 _HDMITX_GET_VARIABLE();
3863
3864 if (pu8Data != NULL)
3865 {
3866 *pu32RealLen = (u32DataLen > psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HF_VSDB_Len) ? psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HF_VSDB_Len : u32DataLen;
3867 memcpy(pu8Data, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HF_VSDB, *pu32RealLen);
3868 }
3869 }
3870
3871 //**************************************************************************
3872 // [Function Name]:
3873 // MDrv_HDMITx_GetColorimetryDataBlock()
3874 // [Description]:
3875 // Get colorimetry data block from EDID
3876 // [Arguments]:
3877 // [MS_U8]* pu8Data: buff to store data block content
3878 // [MS_U32] u32DataLen: buff length
3879 // [MS_U32]* pu32RealLen: real length of edid data block
3880 // [Return]:
3881 // void
3882 //
3883 //**************************************************************************
MDrv_HDMITx_GetColorimetryDataBlock(void * pInstance,MS_U8 * pu8Data,MS_U32 u32DataLen,MS_U32 * pu32RealLen)3884 void MDrv_HDMITx_GetColorimetryDataBlock(void* pInstance, MS_U8* pu8Data, MS_U32 u32DataLen, MS_U32* pu32RealLen)
3885 {
3886 _HDMITX_GET_VARIABLE();
3887
3888 if (pu8Data != NULL)
3889 {
3890 *pu8Data = psHDMITXResPri->stHDMITxInfo.RxEdidInfo.ExtColorimetry;
3891 *pu32RealLen = 0x01;
3892 }
3893 }
3894
3895 //**************************************************************************
3896 // [Function Name]:
3897 // MDrv_HDMITx_GetHDRStaticMetaDataBlock()
3898 // [Description]:
3899 // Get HDR static meta data block from EDID
3900 // [Arguments]:
3901 // [MS_U8]* pu8Data: buff to store data block content
3902 // [MS_U32] u32DataLen: buff length
3903 // [MS_U32]* pu32RealLen: real length of edid data block
3904 // [Return]:
3905 // void
3906 //
3907 //**************************************************************************
MDrv_HDMITx_GetHDRStaticMetaDataBlock(void * pInstance,MS_U8 * pu8Data,MS_U32 u32DataLen,MS_U32 * pu32RealLen)3908 void MDrv_HDMITx_GetHDRStaticMetaDataBlock(void* pInstance, MS_U8* pu8Data, MS_U32 u32DataLen, MS_U32* pu32RealLen)
3909 {
3910 _HDMITX_GET_VARIABLE();
3911
3912 if (pu8Data != NULL)
3913 {
3914 memcpy(pu8Data, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HDRStaticDataBlk, (u32DataLen > 32) ? 32 : u32DataLen);
3915 *pu32RealLen = (u32DataLen > 32) ? 32 : u32DataLen;
3916 }
3917 }
3918
3919 //**************************************************************************
3920 // [Function Name]:
3921 // MDrv_HDMITx_Get420VideoDataBlock()
3922 // [Description]:
3923 // Get YCbCr420 video data block from EDID
3924 // [Arguments]:
3925 // [MS_U8]* pu8Data: buff to store data block content
3926 // [MS_U32] u32DataLen: buff length
3927 // [MS_U32]* pu32RealLen: real length of edid data block
3928 // [Return]:
3929 // void
3930 //
3931 //**************************************************************************
MDrv_HDMITx_Get420VideoDataBlock(void * pInstance,MS_U8 * pu8Data,MS_U32 u32DataLen,MS_U32 * pu32RealLen)3932 void MDrv_HDMITx_Get420VideoDataBlock(void* pInstance, MS_U8* pu8Data, MS_U32 u32DataLen, MS_U32* pu32RealLen)
3933 {
3934 _HDMITX_GET_VARIABLE();
3935
3936 if (pu8Data != NULL)
3937 {
3938 memcpy(pu8Data, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420VidDataBlk, (u32DataLen > 32) ? 32 : u32DataLen);
3939 *pu32RealLen = (u32DataLen > 32) ? 32 : u32DataLen;
3940 }
3941 }
3942
3943 //**************************************************************************
3944 // [Function Name]:
3945 // MDrv_HDMITx_Get420CapabilityMapDataBlock()
3946 // [Description]:
3947 // Get YCbCr420 Capability Map data block from EDID
3948 // [Arguments]:
3949 // [MS_U8]* pu8Data: buff to store data block content
3950 // [MS_U32] u32DataLen: buff length
3951 // [MS_U32]* pu32RealLen: real length of edid data block
3952 // [Return]:
3953 // void
3954 //
3955 //**************************************************************************
MDrv_HDMITx_Get420CapabilityMapDataBlock(void * pInstance,MS_U8 * pu8Data,MS_U32 u32DataLen,MS_U32 * pu32RealLen)3956 void MDrv_HDMITx_Get420CapabilityMapDataBlock(void* pInstance, MS_U8* pu8Data, MS_U32 u32DataLen, MS_U32* pu32RealLen)
3957 {
3958 _HDMITX_GET_VARIABLE();
3959
3960 if (pu8Data != NULL)
3961 {
3962 memcpy(pu8Data, psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420CapMapDataBlk, (u32DataLen > 32) ? 32 : u32DataLen);
3963 *pu32RealLen = (u32DataLen > 32) ? 32 : u32DataLen;
3964 }
3965 }
3966
3967 //**************************************************************************
3968 // [Function Name]:
3969 // MDrv_HDMITx_SetGCPParameter()
3970 // [Description]:
3971 // set general control packet content
3972 // [Arguments]:
3973 // void
3974 // [Return]:
3975 // void
3976 //
3977 //**************************************************************************
MDrv_HDMITx_SetGCPParameter(void * pInstance)3978 void MDrv_HDMITx_SetGCPParameter(void* pInstance)
3979 {
3980 stGC_PktPara stGCPktPara;
3981
3982 _HDMITX_GET_VARIABLE();
3983
3984 stGCPktPara.enAVMute = (psHDMITXResPri->stHDMITxInfo.hdmitx_avmute_flag == TRUE) ? E_HDMITX_GCP_SET_AVMUTE : E_HDMITX_GCP_CLEAR_AVMUTE;
3985 stGCPktPara.enColorDepInfo = psHDMITXResPri->stHDMITxInfo.output_colordepth_val;
3986 MHal_HDMITx_SetGCPParameter(stGCPktPara);
3987 }
3988
3989 //**************************************************************************
3990 // [Function Name]:
3991 // MDrv_HDMITx_SetAVIInfoPktPara()
3992 // [Description]:
3993 // set AVI infoframe packet content
3994 // [Arguments]:
3995 // void
3996 // [Return]:
3997 // void
3998 //
3999 //**************************************************************************
MDrv_HDMITx_SetAVIInfoPktPara(void * pInstance)4000 void MDrv_HDMITx_SetAVIInfoPktPara(void* pInstance)
4001 {
4002 stAVIInfo_PktPara stAVIInfoPara;
4003
4004 _HDMITX_GET_VARIABLE();
4005
4006 stAVIInfoPara.enableAFDoverWrite = psHDMITXResPri->stHDMITxInfo.hdmitx_AFD_override_mode;
4007 stAVIInfoPara.A0Value = psHDMITXResPri->stHDMITxInfo.output_activeformat_present;
4008 stAVIInfoPara.enColorimetry = psHDMITXResPri->stHDMITxInfo.colorimetry;
4009 stAVIInfoPara.enExtColorimetry = psHDMITXResPri->stHDMITxInfo.ext_colorimetry;
4010 stAVIInfoPara.enYCCQuantRange = psHDMITXResPri->stHDMITxInfo.enYCCQuantRange;
4011 stAVIInfoPara.enVidTiming = psHDMITXResPri->stHDMITxInfo.output_video_timing;
4012 stAVIInfoPara.enAFDRatio = psHDMITXResPri->stHDMITxInfo.output_afd_ratio;
4013 stAVIInfoPara.enScanInfo = psHDMITXResPri->stHDMITxInfo.output_scan_info;
4014 stAVIInfoPara.enAspectRatio = psHDMITXResPri->stHDMITxInfo.output_aspect_ratio;
4015
4016 if(psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag)
4017 {
4018 stAVIInfoPara.enColorFmt = psHDMITXResPri->stHDMITxInfo.output_color;
4019 }
4020 else
4021 {
4022 if(!MHal_HDMITx_CSC_Support_R2Y(pInstance))
4023 {
4024 stAVIInfoPara.enColorFmt = E_HDMITX_VIDEO_COLOR_RGB444;
4025 }
4026 else
4027 {
4028 stAVIInfoPara.enColorFmt = psHDMITXResPri->stHDMITxInfo.output_color;
4029 }
4030 }
4031
4032 MHal_HDMITx_SetAVIInfoParameter(stAVIInfoPara);
4033 }
4034
4035 //**************************************************************************
4036 // [Function Name]:
4037 // MDrv_HDMITx_SetAudInfoPktPara()
4038 // [Description]:
4039 // Set Audio Infoframe packet content
4040 // [Arguments]:
4041 // void
4042 // [Return]:
4043 // void
4044 //
4045 //**************************************************************************
MDrv_HDMITx_SetAudInfoPktPara(void * pInstance)4046 void MDrv_HDMITx_SetAudInfoPktPara(void* pInstance)
4047 {
4048 stAUDInfo_PktPara stAudInfoPara;
4049
4050 _HDMITX_GET_VARIABLE();
4051
4052 stAudInfoPara.enAudChCnt = psHDMITXResPri->stHDMITxInfo.output_audio_channel;
4053 stAudInfoPara.enAudFreq = psHDMITXResPri->stHDMITxInfo.output_audio_frequncy;
4054 stAudInfoPara.enAudType = psHDMITXResPri->stHDMITxInfo.output_audio_type;
4055 MHal_HDMITx_SetAudioInfoParameter(stAudInfoPara);
4056 //stAudInfoPara.bChStatus = gHDMITxInfo.output_a
4057 }
4058
4059 //------------------------------------------------------------------------------
4060 /// @brief This routine turn on/off HDMI Tx TMDS signal
4061 /// @return None
4062 //------------------------------------------------------------------------------
MDrv_HDMITx_SetTMDSOnOff(void * pInstance,MS_BOOL state)4063 void MDrv_HDMITx_SetTMDSOnOff(void* pInstance, MS_BOOL state)
4064 {
4065 _HDMITX_GET_VARIABLE();
4066
4067 psHDMITXResPri->stHDMITxInfo.hdmitx_tmds_flag = state;
4068
4069 if (!g_bDisableTMDSCtrl)
4070 {
4071 MHal_HDMITx_SetTMDSOnOff(psHDMITXResPri->stHDMITxInfo.hdmitx_RB_swap_flag, psHDMITXResPri->stHDMITxInfo.hdmitx_tmds_flag);
4072 }
4073 }
4074
4075
4076 //------------------------------------------------------------------------------
4077 /// @brief This routine turn on/off HDMI Tx TMDS signal
4078 /// @return None
4079 //------------------------------------------------------------------------------
MDrv_HDMITx_GetTMDSStatus(void * pInstance)4080 MS_U32 MDrv_HDMITx_GetTMDSStatus(void* pInstance)
4081 {
4082 MS_U32 u32TMDSStatus = 0;
4083 u32TMDSStatus = MHal_HDMITx_GetTMDSStatus();
4084 return u32TMDSStatus;
4085 }
4086
4087 //------------------------------------------------------------------------------
4088 /// @brief This routine config HDMI Tx output mode (DVI / HDMI)
4089 /// @return None
4090 //------------------------------------------------------------------------------
MDrv_HDMITx_SetHDMITxMode(void * pInstance,MsHDMITX_OUTPUT_MODE mode)4091 void MDrv_HDMITx_SetHDMITxMode(void* pInstance, MsHDMITX_OUTPUT_MODE mode)
4092 {
4093 _HDMITX_GET_VARIABLE();
4094
4095 psHDMITXResPri->stHDMITxInfo.output_mode = mode;
4096
4097 if (psHDMITXResPri->stHDMITxInfo.output_mode & 0x01) // check HDCP
4098 {
4099 MDrv_HDMITx_SetHDCPFlag(pInstance, TRUE); //gHDMITxInfo.hdmitx_hdcp_flag = TRUE;
4100 }
4101 else
4102 {
4103 MDrv_HDMITx_SetHDCPFlag(pInstance, FALSE); //gHDMITxInfo.hdmitx_hdcp_flag = FALSE;
4104 }
4105
4106 if ( MHal_HDMITx_IsSupportDVIMode() == FALSE)
4107 {
4108 /***********************************************/
4109 //SW Patch,
4110 //KAISERIN_CHIP_TOP_BASE DO NOT support YUV2RGB
4111 /***********************************************/
4112 psHDMITXResPri->stHDMITxInfo.output_mode = (psHDMITXResPri->stHDMITxInfo.output_mode | BIT1);
4113 }
4114 // HDMI / DVI
4115
4116 if (psHDMITXResPri->stHDMITxInfo.hdmitx_force_mode) // AP force output mode
4117 {
4118 psHDMITXResPri->stHDMITxInfo.output_mode = psHDMITXResPri->stHDMITxInfo.force_output_mode;
4119 if((psHDMITXResPri->stHDMITxInfo.force_output_mode == E_HDMITX_DVI) || (psHDMITXResPri->stHDMITxInfo.force_output_mode == E_HDMITX_DVI_HDCP)) // DVI mode
4120 {
4121 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.AudSupportAI = FALSE;
4122 psHDMITXResPri->stHDMITxInfo.output_color = E_HDMITX_VIDEO_COLOR_RGB444;
4123 }
4124 }
4125
4126 if (psHDMITXResPri->stHDMITxInfo.output_mode & BIT1) // HDMI
4127 {
4128 psHDMITXResPri->stHDMITxInfo.hdmitx_audio_flag = TRUE;
4129 MHal_HDMITx_SetHDMImode(TRUE, psHDMITXResPri->stHDMITxInfo.output_colordepth_val);
4130
4131 if ((psHDMITXResPri->stHDMITxInfo.output_colordepth_val) || (psHDMITXResPri->stHDMITxInfo.hdmitx_avmute_flag)) // RX support DC or SET_AVMUTE
4132 {
4133 MDrv_HDMITx_SendPacket(E_HDMITX_GC_PACKET, E_HDMITX_CYCLIC_PACKET);
4134 }
4135 else
4136 {
4137 MDrv_HDMITx_SendPacket(E_HDMITX_GC_PACKET, E_HDMITX_STOP_PACKET);
4138 }
4139
4140 MDrv_HDMITx_SendPacket(E_HDMITX_NULL_PACKET, E_HDMITX_CYCLIC_PACKET);
4141 if (g_bDisableVSInfo == TRUE)
4142 {
4143 MDrv_HDMITx_SendPacket(E_HDMITX_VS_INFOFRAME, E_HDMITX_STOP_PACKET);
4144 }
4145 MDrv_HDMITx_SendPacket(E_HDMITX_SPD_INFOFRAME, E_HDMITX_CYCLIC_PACKET);
4146 DBG_HDMITX(printf("MDrv_HDMITx_SetHDMITxMode: HDMI mode = %d \n", psHDMITXResPri->stHDMITxInfo.output_mode));
4147 }
4148 else // DVI
4149 {
4150 psHDMITXResPri->stHDMITxInfo.hdmitx_audio_flag = FALSE;
4151 MHal_HDMITx_SetHDMImode(FALSE, psHDMITXResPri->stHDMITxInfo.output_colordepth_val);
4152 DBG_HDMITX(printf("MDrv_HDMITx_SetHDMITxMode: DVI mode = %d \n", psHDMITXResPri->stHDMITxInfo.output_mode));
4153 }
4154 }
4155
4156 //**************************************************************************
4157 // [Function Name]:
4158 // HDMITx_Handler()
4159 // [Description]:
4160 // HDMI TX FSM
4161 // [Arguments]:
4162 // [MS_U32] u32State
4163 // [Return]:
4164 // void
4165 //
4166 //**************************************************************************
MDrv_HDMITx_SetDeepColorMode(void * pInstance,MsHDMITX_VIDEO_COLORDEPTH_VAL enDeepColorMode)4167 void MDrv_HDMITx_SetDeepColorMode(void* pInstance, MsHDMITX_VIDEO_COLORDEPTH_VAL enDeepColorMode)
4168 {
4169 _HDMITX_GET_VARIABLE();
4170
4171 psHDMITXResPri->stHDMITxInfo.output_colordepth_val = enDeepColorMode;
4172 MDrv_HDMITx_SetGCPParameter(pInstance);
4173 }
4174
4175 //**************************************************************************
4176 // [Function Name]:
4177 // MDrv_HDMITx_SetRBChannelSwap()
4178 // [Description]:
4179 // set R, B channel swap flag
4180 // [Arguments]:
4181 // [MS_BOOL] state
4182 // [Return]:
4183 // void
4184 //
4185 //**************************************************************************
MDrv_HDMITx_SetRBChannelSwap(void * pInstance,MS_BOOL state)4186 void MDrv_HDMITx_SetRBChannelSwap(void* pInstance, MS_BOOL state) //wilson@kano
4187 {
4188 _HDMITX_GET_VARIABLE();
4189
4190 psHDMITXResPri->stHDMITxInfo.hdmitx_RB_swap_flag = state;
4191 }
4192
4193 //------------------------------------------------------------------------------
4194 /// @brief This routine turn on/off HDMI Tx video output
4195 /// @return None
4196 //------------------------------------------------------------------------------
MDrv_HDMITx_SetVideoOnOff(void * pInstance,MS_BOOL state)4197 void MDrv_HDMITx_SetVideoOnOff(void* pInstance, MS_BOOL state)
4198 {
4199 _HDMITX_GET_VARIABLE();
4200 psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag = state;
4201
4202 #if 0
4203 if (psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag == FALSE) //force RGB color format for pattern gen
4204 {
4205 MDrv_HDMITx_SetColorFormat(pInstance, psHDMITXResPri->stHDMITxInfo.input_color, E_HDMITX_VIDEO_COLOR_RGB444);
4206 }
4207 #endif
4208
4209 MDrv_HDMITx_ColorandRange_Transform(pInstance, psHDMITXResPri->stHDMITxInfo.input_color, psHDMITXResPri->stHDMITxInfo.output_color, psHDMITXResPri->stHDMITxInfo.input_range, psHDMITXResPri->stHDMITxInfo.output_range);
4210
4211 if (psHDMITXResPri->stHDMITxInfo.output_video_timing >= E_HDMITX_RES_1280x720p_50Hz)
4212 MHal_HDMITx_SetVideoOnOff(psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag, psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag, TRUE);
4213 else
4214 MHal_HDMITx_SetVideoOnOff(psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag, psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag, FALSE);
4215 }
4216
4217 //------------------------------------------------------------------------------
4218 /// @brief This routine sets video color formatt
4219 /// @return None
4220 //------------------------------------------------------------------------------
MDrv_HDMITx_SetColorFormat(void * pInstance,MsHDMITX_VIDEO_COLOR_FORMAT enInColor,MsHDMITX_VIDEO_COLOR_FORMAT enOutColor)4221 void MDrv_HDMITx_SetColorFormat(void* pInstance, MsHDMITX_VIDEO_COLOR_FORMAT enInColor, MsHDMITX_VIDEO_COLOR_FORMAT enOutColor)
4222 {
4223 #if 0
4224 MS_BOOL bflag = FALSE;
4225
4226 _HDMITX_GET_VARIABLE();
4227
4228 psHDMITXResPri->stHDMITxInfo.input_color = enInColor;
4229 psHDMITXResPri->stHDMITxInfo.output_color = enOutColor;
4230 MDrv_HDMITx_SetAVIInfoPktPara(pInstance);
4231
4232 if (psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag == FALSE)
4233 {
4234 MDrv_HDMITx_ColorandRange_Transform(pInstance, psHDMITXResPri->stHDMITxInfo.input_color, psHDMITXResPri->stHDMITxInfo.output_color, psHDMITXResPri->stHDMITxInfo.input_range, psHDMITXResPri->stHDMITxInfo.output_range);
4235 return;
4236 }
4237
4238 // YUV444 -> RGB444
4239 if ((enInColor != enOutColor) /*&& (enOutColor == E_HDMITX_VIDEO_COLOR_RGB444)*/)
4240 {
4241 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = TRUE;
4242 }
4243 else
4244 {
4245 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = FALSE;
4246 }
4247
4248
4249 bflag = (psHDMITXResPri->stHDMITxInfo.output_color == E_HDMITX_VIDEO_COLOR_YUV422) ? TRUE : FALSE;
4250
4251 if(psHDMITXResPri->stHDMITxInfo.input_range != psHDMITXResPri->stHDMITxInfo.output_range)
4252 {
4253 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = TRUE;
4254 }
4255
4256 if (psHDMITXResPri->stHDMITxInfo.output_video_timing >= E_HDMITX_RES_1280x720p_50Hz)
4257 {
4258 MHal_HDMITx_SetColorFormat(psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag, bflag, TRUE);
4259 }
4260 else
4261 {
4262 MHal_HDMITx_SetColorFormat(psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag, bflag, FALSE);
4263 }
4264
4265 // send packet
4266 MDrv_HDMITx_SendPacket(E_HDMITX_AVI_INFOFRAME, E_HDMITX_CYCLIC_PACKET);
4267
4268 if (psHDMITXResPri->stHDMITxInfo.output_color == E_HDMITX_VIDEO_COLOR_YUV420)
4269 MDrv_HDMITx_SetVideoOutputMode(pInstance, psHDMITXResPri->stHDMITxInfo.output_video_timing); //wilson: for 420;
4270
4271 printf("A InColor = %x, OutColor = %x\r\n", enInColor, enOutColor);
4272 #else
4273 _HDMITX_GET_VARIABLE();
4274 printf("B InColor = %x, OutColor = %x\r\n", enInColor, enOutColor);
4275 MDrv_HDMITx_ColorandRange_Transform(pInstance, enInColor, enOutColor, psHDMITXResPri->stHDMITxInfo.input_range, psHDMITXResPri->stHDMITxInfo.output_range);
4276 //MDrv_HDMITx_ColorandRange_Transform(pInstance, enInColor, enOutColor, E_HDMITX_YCC_QUANT_FULL, E_HDMITX_YCC_QUANT_FULL);
4277 #endif
4278 }
4279
4280 //**************************************************************************
4281 // [Function Name]:
4282 // MDrv_HDMITx_ColorandRange_Transform()
4283 // [Description]:
4284 // This routine sets video color range and format
4285 // [Arguments]:
4286 // [MsHDMITX_VIDEO_COLOR_FORMAT] Input/Output color format
4287 // [MsHDMITX_VIDEO_COLOR_RANGE] Input/Outpu color range
4288 // [Return]:
4289 // [MS_BOOL] Color Range Transforming supported or not
4290 //
4291 //**************************************************************************
MDrv_HDMITx_ColorandRange_Transform(void * pInstance,MsHDMITX_VIDEO_COLOR_FORMAT incolor,MsHDMITX_VIDEO_COLOR_FORMAT outcolor,MsHDMITX_YCC_QUANT_RANGE inange,MsHDMITX_YCC_QUANT_RANGE outrange)4292 MS_BOOL MDrv_HDMITx_ColorandRange_Transform(void* pInstance, MsHDMITX_VIDEO_COLOR_FORMAT incolor, MsHDMITX_VIDEO_COLOR_FORMAT outcolor, MsHDMITX_YCC_QUANT_RANGE inange, MsHDMITX_YCC_QUANT_RANGE outrange)
4293 {
4294 MS_BOOL bRet = FALSE;
4295
4296 //_HDMITX_SEMAPHORE_ENTRY(pInstance);
4297 _HDMITX_GET_VARIABLE();
4298 psHDMITXResPri->stHDMITxInfo.input_color = incolor;
4299 psHDMITXResPri->stHDMITxInfo.output_color = outcolor;
4300 psHDMITXResPri->stHDMITxInfo.input_range = inange;
4301 psHDMITXResPri->stHDMITxInfo.output_range = outrange;
4302 psHDMITXResPri->stHDMITxInfo.enYCCQuantRange = outrange;
4303 MDrv_HDMITx_SetAVIInfoPktPara(pInstance);
4304
4305 if (psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag == FALSE)
4306 {
4307 if(!MHal_HDMITx_CSC_Support_R2Y(pInstance))
4308 {
4309 incolor = E_HDMITX_VIDEO_COLOR_RGB444;
4310 outcolor = E_HDMITX_VIDEO_COLOR_RGB444;
4311 }
4312 else
4313 {
4314 incolor = E_HDMITX_VIDEO_COLOR_RGB444;
4315 }
4316 }
4317
4318 if( (incolor == E_HDMITX_VIDEO_COLOR_RGB444) && (outcolor != E_HDMITX_VIDEO_COLOR_RGB444) )
4319 {
4320 //Old chip limited by R2Y
4321 if(!MHal_HDMITx_CSC_Support_R2Y(pInstance))
4322 {
4323 printf("Can not support for R2Y\r\n");
4324 return FALSE;
4325 }
4326 }
4327
4328 if(!MDrv_HDMITx_EdidGetHDMISupportFlag(pInstance) && (!psHDMITXResPri->stHDMITxInfo.hdmitx_force_output_color))
4329 {
4330 if(outcolor != E_HDMITX_VIDEO_COLOR_RGB444)
4331 {
4332 printf("DVI mode needs RGB only\r\n");
4333 return FALSE;
4334 }
4335 }
4336
4337 if (psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag == FALSE)
4338 {
4339 bRet = MHal_HDMITx_ColorandRange_Transform(incolor, outcolor, psHDMITXResPri->stHDMITxInfo.input_range, psHDMITXResPri->stHDMITxInfo.output_range);
4340 }
4341 else
4342 {
4343 bRet = MHal_HDMITx_ColorandRange_Transform(psHDMITXResPri->stHDMITxInfo.input_color, psHDMITXResPri->stHDMITxInfo.output_color, psHDMITXResPri->stHDMITxInfo.input_range, psHDMITXResPri->stHDMITxInfo.output_range);
4344 }
4345
4346 if(inange != outrange)
4347 {
4348 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = TRUE;
4349 }
4350 else if(outcolor != incolor)
4351 {
4352 if(MHal_HDMITx_CSC_Support_R2Y(pInstance))
4353 {
4354 if(outcolor == E_HDMITX_VIDEO_COLOR_RGB444)//Input Y -> Output R
4355 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = TRUE;
4356 else if(incolor != E_HDMITX_VIDEO_COLOR_RGB444)//Input Y -> Output Y
4357 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = FALSE;
4358 else//Input R -> Output Y
4359 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = TRUE;
4360 }
4361 else
4362 {
4363 if(outcolor == E_HDMITX_VIDEO_COLOR_RGB444)//Input Y -> Output R
4364 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = TRUE;
4365 else if(incolor != E_HDMITX_VIDEO_COLOR_RGB444)//Input Y -> Output Y
4366 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = FALSE;
4367 else//Input R -> Output Y
4368 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = FALSE;
4369
4370 }
4371 }
4372 else
4373 {
4374 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = FALSE;
4375 }
4376
4377 MDrv_HDMITx_SendPacket(E_HDMITX_AVI_INFOFRAME, E_HDMITX_CYCLIC_PACKET);
4378
4379 if (psHDMITXResPri->stHDMITxInfo.output_color == E_HDMITX_VIDEO_COLOR_YUV420)
4380 MDrv_HDMITx_SetVideoOutputMode(pInstance, psHDMITXResPri->stHDMITxInfo.output_video_timing); //wilson: for 420;
4381
4382 return bRet;
4383 }
4384
4385
4386 //------------------------------------------------------------------------------
4387 /// @brief This routine set HDMI Tx AVMUTE
4388 /// @argument:
4389 /// - bflag: True=> SET_AVMUTE, FALSE=>CLEAR_AVMUTE
4390 ///
4391 /// @return None
4392 //------------------------------------------------------------------------------
MDrv_HDMITx_SetAVMUTE(void * pInstance,MS_BOOL bflag)4393 void MDrv_HDMITx_SetAVMUTE(void* pInstance, MS_BOOL bflag)
4394 {
4395 _HDMITX_GET_VARIABLE();
4396
4397 psHDMITXResPri->stHDMITxInfo.hdmitx_avmute_flag = bflag;
4398 MDrv_HDMITx_SetGCPParameter(pInstance); //update packet content; wilson@kano
4399
4400 if (bflag)
4401 {
4402 //MDrv_HDMITx_SendPacket(E_HDMITX_GC_PACKET, E_HDMITX_CYCLIC_PACKET|E_HDMITX_GCP_SET_AVMUTE);
4403 MDrv_HDMITx_SendPacket(E_HDMITX_GC_PACKET, E_HDMITX_CYCLIC_PACKET);
4404 DBG_HDMITX(printf("\nMDrv_HDMITx_SetAVMUTE \n"));
4405 }
4406 else
4407 {
4408 MDrv_HDMITx_SendPacket(E_HDMITX_GC_PACKET, E_HDMITX_CYCLIC_PACKET);
4409
4410 MsOS_DelayTask(50);
4411
4412 if (psHDMITXResPri->stHDMITxInfo.output_colordepth_val) // RX support DC
4413 {
4414 MDrv_HDMITx_SendPacket(E_HDMITX_GC_PACKET, E_HDMITX_CYCLIC_PACKET);
4415 }
4416 else
4417 {
4418 MDrv_HDMITx_SendPacket(E_HDMITX_GC_PACKET, E_HDMITX_STOP_PACKET);
4419 }
4420 DBG_HDMITX(printf("\nMDrv_HDMITx_ClearAVMUTE \n"));
4421 }
4422 }
4423
4424 //------------------------------------------------------------------------------
4425 /// @brief This routine sets VS infoframe
4426 /// @return None
4427 //------------------------------------------------------------------------------
MDrv_HDMITx_Set_VS_InfoFrame(void * pInstance,MsHDMITX_VIDEO_VS_FORMAT enVSFmt,MsHDMITX_VIDEO_4k2k_VIC enVid4K2KVic,MsHDMITX_VIDEO_3D_STRUCTURE enVid3DStruct)4428 void MDrv_HDMITx_Set_VS_InfoFrame(void* pInstance, MsHDMITX_VIDEO_VS_FORMAT enVSFmt, MsHDMITX_VIDEO_4k2k_VIC enVid4K2KVic, MsHDMITX_VIDEO_3D_STRUCTURE enVid3DStruct)
4429 {
4430 stVSInfo_PktPara stVSPara;
4431
4432 _HDMITX_GET_VARIABLE();
4433
4434 stVSPara.enVSFmt = enVSFmt;
4435 stVSPara.en4k2kVIC = enVid4K2KVic;
4436 stVSPara.en3DStruct = enVid3DStruct;
4437
4438 MHal_HDMITx_SetVSInfoParameter(stVSPara);
4439 MDrv_HDMITx_SendPacket(E_HDMITX_VS_INFOFRAME, E_HDMITX_CYCLIC_PACKET);
4440
4441 //to pass compliance test of 3D output format (test with LG, SAMSUNG, Toshiba and Sony TV)
4442 MDrv_HDMITx_SetAVMUTE(pInstance, TRUE);
4443 MHal_HDMITx_SetTMDSOnOff(psHDMITXResPri->stHDMITxInfo.hdmitx_RB_swap_flag, FALSE);
4444
4445 MsOS_DelayTask(20); //delay 1 frame/field interval
4446
4447 MHal_HDMITx_SetTMDSOnOff(psHDMITXResPri->stHDMITxInfo.hdmitx_RB_swap_flag, TRUE);
4448 MDrv_HDMITx_SetAVMUTE(pInstance, FALSE);
4449 }
4450
4451 //------------------------------------------------------------------------------
4452 /// @brief This routine sets video output mode (color/repetition/regen)
4453 /// @return None
4454 //------------------------------------------------------------------------------
MDrv_HDMITx_SetVideoOutputMode(void * pInstance,MsHDMITX_VIDEO_TIMING enVidTiming)4455 void MDrv_HDMITx_SetVideoOutputMode(void* pInstance, MsHDMITX_VIDEO_TIMING enVidTiming)
4456 {
4457 _HDMITX_GET_VARIABLE();
4458
4459 psHDMITXResPri->stHDMITxInfo.output_video_timing = enVidTiming;
4460 MDrv_HDMITx_SetAVIInfoPktPara(pInstance);
4461
4462 if (psHDMITXResPri->stHDMITxInfo.output_video_timing >= E_HDMITX_RES_MAX)
4463 {
4464 printf("[%s][%d] Unsupport HDMI mode 0x%08x\n", __FUNCTION__, __LINE__, psHDMITXResPri->stHDMITxInfo.output_video_timing);
4465 return;
4466 }
4467
4468 #if 0
4469 // 41.6 ms * 128 = 5.324 s, 40 ms * 128 = 5.12 s
4470 if( (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_1920x1080p_24Hz) || (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_1920x1080p_25Hz) || (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_1920x2205p_24Hz)
4471 ||(psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_3840x2160p_24Hz) || (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_3840x2160p_25Hz) || (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_4096x2160p_24Hz)) // 24/25 Hz
4472 gHDCPCheckRiTimer = 5400;
4473 // 33.3 ms * 128 = 4.26 s
4474 else if ((psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_1920x1080p_30Hz)||(psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_3840x2160p_30Hz)) // 30 Hz
4475 gHDCPCheckRiTimer = 4300;
4476 // 16.6 ms * 128 = 2.124 s, 20 ms * 128 = 2.56 s
4477 else // 50/60 Hz
4478 gHDCPCheckRiTimer = HDCP_RiCheck_Timer;//2600;
4479 #else
4480 // 50/60 Hz
4481 gHDCPCheckRiTimer = HDCP_RiCheck_Timer;//2600;
4482 #endif
4483
4484 MHal_HDMITx_SetVideoOutputMode(psHDMITXResPri->stHDMITxInfo.output_video_timing, psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag, psHDMITXResPri->stHDMITxInfo.output_colordepth_val, &psHDMITXResPri->stHDMITxInfo.analog_setting, psHDMITXResPri->stHDMITxInfo.ubSSCEn);
4485 MDrv_HDMITx_SendPacket(E_HDMITX_AVI_INFOFRAME, E_HDMITX_CYCLIC_PACKET);
4486 }
4487 //------------------------------------------------------------------------------
4488 /// @brief This routine sets video output mode by customers' bring in info (color/repetition/regen)
4489 /// @return None
4490 //------------------------------------------------------------------------------
MDrv_HDMITx_SetVideoOutputModeByCustomer(void * pInstance,MsHDMITX_VIDEO_TIMING enVidTiming,stHDMITX_TIMING_INFO_BY_CUSTOMER stTimingInfo)4491 void MDrv_HDMITx_SetVideoOutputModeByCustomer(void* pInstance, MsHDMITX_VIDEO_TIMING enVidTiming, stHDMITX_TIMING_INFO_BY_CUSTOMER stTimingInfo)
4492 {
4493 _HDMITX_GET_VARIABLE();
4494 MHal_HDMITx_SetVideoInfoByCustomer(enVidTiming, stTimingInfo);
4495 }
4496
4497 //------------------------------------------------------------------------------
4498 /// @brief This routine sets video aspect ratio
4499 /// @return None
4500 //------------------------------------------------------------------------------
MDrv_HDMITx_SetVideoOutputAsepctRatio(void * pInstance,MsHDMITX_VIDEO_ASPECT_RATIO enOutputAR)4501 void MDrv_HDMITx_SetVideoOutputAsepctRatio(void* pInstance, MsHDMITX_VIDEO_ASPECT_RATIO enOutputAR)
4502 {
4503 _HDMITX_GET_VARIABLE();
4504 // send packet
4505 psHDMITXResPri->stHDMITxInfo.output_aspect_ratio = enOutputAR;
4506 MDrv_HDMITx_SetAVIInfoPktPara(pInstance);
4507 MDrv_HDMITx_SendPacket(E_HDMITX_AVI_INFOFRAME, E_HDMITX_CYCLIC_PACKET);
4508 if (enOutputAR == E_HDMITX_VIDEO_AR_21_9)
4509 MDrv_HDMITx_SendPacket(E_HDMITX_VS_INFOFRAME, E_HDMITX_STOP_PACKET);
4510 }
4511
4512 //------------------------------------------------------------------------------
4513 /// @brief This routine sets video scan info and AFD
4514 /// @return None
4515 //------------------------------------------------------------------------------
MDrv_HDMITx_SetVideoOutputOverscan_AFD(void * pInstance,MS_U8 ucA0,MS_BOOL bAFDOverwrite,MsHDMITX_VIDEO_SCAN_INFO enScanInfo,MsHDMITX_VIDEO_AFD_RATIO enAFDRatio)4516 void MDrv_HDMITx_SetVideoOutputOverscan_AFD(void* pInstance, MS_U8 ucA0, MS_BOOL bAFDOverwrite, MsHDMITX_VIDEO_SCAN_INFO enScanInfo, MsHDMITX_VIDEO_AFD_RATIO enAFDRatio)
4517 {
4518 _HDMITX_GET_VARIABLE();
4519 psHDMITXResPri->stHDMITxInfo.output_activeformat_present = ucA0;
4520 psHDMITXResPri->stHDMITxInfo.hdmitx_AFD_override_mode = bAFDOverwrite;
4521 psHDMITXResPri->stHDMITxInfo.output_scan_info = enScanInfo;
4522 psHDMITXResPri->stHDMITxInfo.output_afd_ratio = enAFDRatio;
4523
4524 // send packet
4525 MDrv_HDMITx_SetAVIInfoPktPara(pInstance);
4526 MDrv_HDMITx_SendPacket(E_HDMITX_AVI_INFOFRAME, E_HDMITX_CYCLIC_PACKET);
4527 }
4528
4529 //------------------------------------------------------------------------------
4530 /// @brief This routine turns On/off Audio module
4531 /// @return None
4532 //------------------------------------------------------------------------------
MDrv_HDMITx_SetAudioOnOff(void * pInstance,MS_BOOL state)4533 void MDrv_HDMITx_SetAudioOnOff(void* pInstance, MS_BOOL state)
4534 {
4535 _HDMITX_GET_VARIABLE();
4536
4537 psHDMITXResPri->stHDMITxInfo.hdmitx_audio_flag = state;
4538
4539 MDrv_HDMITx_SetAudInfoPktPara(pInstance);
4540
4541 if(psHDMITXResPri->stHDMITxInfo.hdmitx_audio_flag) // turn on
4542 {
4543 MHal_HDMITx_SetAudioOnOff(TRUE);
4544 MDrv_HDMITx_SendPacket(E_HDMITX_ACR_PACKET, E_HDMITX_CYCLIC_PACKET);
4545 MDrv_HDMITx_SendPacket(E_HDMITX_AS_PACKET, E_HDMITX_CYCLIC_PACKET);
4546 MDrv_HDMITx_SendPacket(E_HDMITX_AUDIO_INFOFRAME, E_HDMITX_CYCLIC_PACKET);
4547 MDrv_HDMITx_SendPacket(E_HDMITX_ACP_PACKET, E_HDMITX_STOP_PACKET);
4548 MDrv_HDMITx_SendPacket(E_HDMITX_ISRC1_PACKET, E_HDMITX_STOP_PACKET);
4549 MDrv_HDMITx_SendPacket(E_HDMITX_ISRC2_PACKET, E_HDMITX_STOP_PACKET);
4550 }
4551
4552 else // turn off
4553 {
4554 MHal_HDMITx_SetAudioOnOff(FALSE);
4555 MDrv_HDMITx_SendPacket(E_HDMITX_ACR_PACKET, E_HDMITX_STOP_PACKET);
4556 MDrv_HDMITx_SendPacket(E_HDMITX_AS_PACKET, E_HDMITX_STOP_PACKET);
4557 MDrv_HDMITx_SendPacket(E_HDMITX_AUDIO_INFOFRAME, E_HDMITX_STOP_PACKET);
4558 MDrv_HDMITx_SendPacket(E_HDMITX_ACP_PACKET, E_HDMITX_STOP_PACKET);
4559 MDrv_HDMITx_SendPacket(E_HDMITX_ISRC1_PACKET, E_HDMITX_STOP_PACKET);
4560 MDrv_HDMITx_SendPacket(E_HDMITX_ISRC2_PACKET, E_HDMITX_STOP_PACKET);
4561 }
4562 }
4563
4564 //------------------------------------------------------------------------------
4565 /// @brief This routine sets audio sampling freq.
4566 /// @return None
4567 //------------------------------------------------------------------------------
MDrv_HDMITx_SetAudioFrequency(void * pInstance,MsHDMITX_AUDIO_FREQUENCY enAudFreq)4568 void MDrv_HDMITx_SetAudioFrequency(void* pInstance, MsHDMITX_AUDIO_FREQUENCY enAudFreq)
4569 {
4570 _HDMITX_GET_VARIABLE();
4571
4572 psHDMITXResPri->stHDMITxInfo.output_audio_frequncy = enAudFreq;
4573 MDrv_HDMITx_SetAudInfoPktPara(pInstance);
4574
4575 if (psHDMITXResPri->stHDMITxInfo.hdmitx_audio_flag)
4576 {
4577 MHal_HDMITx_SetAudioFrequency(psHDMITXResPri->stHDMITxInfo.output_audio_frequncy, psHDMITXResPri->stHDMITxInfo.output_audio_channel, psHDMITXResPri->stHDMITxInfo.output_audio_type);
4578 MDrv_HDMITx_SendPacket(E_HDMITX_ACR_PACKET, E_HDMITX_CYCLIC_PACKET);
4579 MDrv_HDMITx_SendPacket(E_HDMITX_AUDIO_INFOFRAME, E_HDMITX_CYCLIC_PACKET);
4580 }
4581 }
4582
4583 //**************************************************************************
4584 // [Function Name]:
4585 // MDrv_HDMITx_SetAudioChCnt()
4586 // [Description]:
4587 // set audio channel number
4588 // [Arguments]:
4589 // [MsHDMITX_AUDIO_CHANNEL_COUNT] enChCnt
4590 // [Return]:
4591 // void
4592 //
4593 //**************************************************************************
MDrv_HDMITx_SetAudioChCnt(void * pInstance,MsHDMITX_AUDIO_CHANNEL_COUNT enChCnt)4594 void MDrv_HDMITx_SetAudioChCnt(void* pInstance, MsHDMITX_AUDIO_CHANNEL_COUNT enChCnt)
4595 {
4596 _HDMITX_GET_VARIABLE();
4597
4598 psHDMITXResPri->stHDMITxInfo.output_audio_channel = enChCnt;
4599 MDrv_HDMITx_SetAudInfoPktPara(pInstance);
4600 }
4601
4602 //**************************************************************************
4603 // [Function Name]:
4604 // MDrv_HDMITx_SetAudioFmt()
4605 // [Description]:
4606 // set audio output format
4607 // [Arguments]:
4608 // [MsHDMITX_AUDIO_CODING_TYPE] enAudFmt
4609 // [Return]:
4610 // void
4611 //
4612 //**************************************************************************
MDrv_HDMITx_SetAudioFmt(void * pInstance,MsHDMITX_AUDIO_CODING_TYPE enAudFmt)4613 void MDrv_HDMITx_SetAudioFmt(void* pInstance, MsHDMITX_AUDIO_CODING_TYPE enAudFmt)
4614 {
4615 _HDMITX_GET_VARIABLE();
4616
4617 psHDMITXResPri->stHDMITxInfo.output_audio_type = enAudFmt;
4618 MDrv_HDMITx_SetAudInfoPktPara(pInstance);
4619 }
4620
4621 //------------------------------------------------------------------------------
4622 /// @brief This routine sets audio source format.
4623 /// @return None
4624 //------------------------------------------------------------------------------
MDrv_HDMITx_SetAudioSourceFormat(MsHDMITX_AUDIO_SOURCE_FORMAT fmt)4625 void MDrv_HDMITx_SetAudioSourceFormat(MsHDMITX_AUDIO_SOURCE_FORMAT fmt)
4626 {
4627 MHal_HDMITx_SetAudioSourceFormat(fmt);
4628 }
4629
4630 //------------------------------------------------------------------------------
4631 /// @brief This routine sets HDMI Tx HDCP encryption On/Off
4632 /// @return None
4633 //------------------------------------------------------------------------------
MDrv_HDMITx_SetHDCPOnOff(void * pInstance,MS_BOOL state)4634 void MDrv_HDMITx_SetHDCPOnOff(void* pInstance, MS_BOOL state)
4635 {
4636 _HDMITX_GET_VARIABLE();
4637
4638 psHDMITXResPri->stHDMITxInfo.hdmitx_hdcp_flag = state;
4639 MHal_HDMITx_SetHDCPOnOff(state, ((psHDMITXResPri->stHDMITxInfo.output_mode & BIT1) ? TRUE:FALSE));
4640 }
4641
MDrv_HDMITx_SetHDCPFlag(void * pInstance,MS_BOOL bEnableHdcp)4642 void MDrv_HDMITx_SetHDCPFlag(void* pInstance, MS_BOOL bEnableHdcp)
4643 {
4644 _HDMITX_GET_VARIABLE();
4645 psHDMITXResPri->stHDMITxInfo.hdmitx_hdcp_flag = bEnableHdcp;
4646 }
4647 //**************************************************************************
4648 // [Function Name]:
4649 // MDrv_HDMITx_SetFSMState()
4650 // [Description]:
4651 // set state of hdmi tx FSM
4652 // [Arguments]:
4653 // [MDrvHDMITX_FSM_STATE] enState
4654 // [Return]:
4655 // void
4656 //
4657 //**************************************************************************
MDrv_HDMITx_SetFSMState(void * pInstance,MDrvHDMITX_FSM_STATE enState)4658 void MDrv_HDMITx_SetFSMState(void* pInstance, MDrvHDMITX_FSM_STATE enState)
4659 {
4660 _HDMITX_GET_VARIABLE();
4661 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state = enState;
4662 }
4663
4664 ///@brief setdbug level
4665 ///@u16DbgSwitch 1 means hdmitx only, 2 mean
MDrv_HDMITx_SetDbgLevel(MS_U16 u16DbgSwitch)4666 MS_BOOL MDrv_HDMITx_SetDbgLevel(MS_U16 u16DbgSwitch)
4667 {
4668 _u16DbgHDMITXSwitch = u16DbgSwitch;
4669 MHal_HDMITx_HdcpDebugEnable(_u16DbgHDMITXSwitch & HDMITX_DBG_HDCP ? TRUE : FALSE);
4670 MHal_HDMITx_UtilDebugEnable(_u16DbgHDMITXSwitch & HDMITX_DBG_UTILTX ? TRUE : FALSE);
4671
4672 return TRUE;
4673 }
4674
MDrv_HDMITx_SetHPDGpioPin(MS_U8 u8pin)4675 void MDrv_HDMITx_SetHPDGpioPin(MS_U8 u8pin)
4676 {
4677 MHal_HDMITx_SetHPDGpioPin(u8pin);
4678 }
4679
4680 //**************************************************************************
4681 // [Function Name]:
4682 // MDrv_HDMITx_SetCECOnOff()
4683 // [Description]:
4684 // set CEC enable flag
4685 // [Arguments]:
4686 // [MS_BOOL] bflag
4687 // [Return]:
4688 // void
4689 //
4690 //**************************************************************************
MDrv_HDMITx_SetCECOnOff(void * pInstance,MS_BOOL bflag)4691 void MDrv_HDMITx_SetCECOnOff(void* pInstance, MS_BOOL bflag)
4692 {
4693 _HDMITX_GET_VARIABLE();
4694 psHDMITXResPri->stHDMITxInfo.hdmitx_CECEnable_flag = bflag;
4695 }
4696
4697 //**************************************************************************
4698 // [Function Name]:
4699 // MDrv_HDMITx_SetAVIInfoExtColorimetry()
4700 // [Description]:
4701 // set extended colorimetry field of aviinfoframe packet
4702 // [Arguments]:
4703 //
4704 // [Return]:
4705 // void
4706 //
4707 //**************************************************************************
MDrv_HDMITx_SetAVIInfoExtColorimetry(void * pInstance,MsHDMITX_EXT_COLORIMETRY enExtColorimetry,MsHDMITX_YCC_QUANT_RANGE enYccQuantRange)4708 void MDrv_HDMITx_SetAVIInfoExtColorimetry(void* pInstance, MsHDMITX_EXT_COLORIMETRY enExtColorimetry, MsHDMITX_YCC_QUANT_RANGE enYccQuantRange)
4709 {
4710 _HDMITX_GET_VARIABLE();
4711
4712 psHDMITXResPri->stHDMITxInfo.ext_colorimetry = enExtColorimetry;
4713 psHDMITXResPri->stHDMITxInfo.colorimetry = E_HDMITX_COLORIMETRY_EXTEND;
4714 psHDMITXResPri->stHDMITxInfo.enYCCQuantRange = enYccQuantRange;
4715 MDrv_HDMITx_SetAVIInfoPktPara(pInstance);
4716 }
4717
4718 //**************************************************************************
4719 // [Function Name]:
4720 // MDrv_HDMITx_SetAVIInfoExtColorimetry()
4721 // [Description]:
4722 // set extended colorimetry field of aviinfoframe packet
4723 // [Arguments]:
4724 //
4725 // [Return]:
4726 //
4727 //
4728 //**************************************************************************
MDrv_HDMITx_SetAVIInfoColorimetry(void * pInstance,MsHDMITX_COLORIMETRY enColorimetry)4729 MS_U8 MDrv_HDMITx_SetAVIInfoColorimetry(void* pInstance, MsHDMITX_COLORIMETRY enColorimetry)
4730 {
4731 MS_U8 ubRet = TRUE;
4732 _HDMITX_GET_VARIABLE();
4733
4734 psHDMITXResPri->stHDMITxInfo.colorimetry = enColorimetry;
4735 MDrv_HDMITx_SetAVIInfoPktPara(pInstance);
4736
4737 if(psHDMITXResPri->stHDMITxInfo.output_color == E_HDMITX_VIDEO_COLOR_RGB444 )
4738 {
4739 if(psHDMITXResPri->stHDMITxInfo.colorimetry != E_HDMITX_COLORIMETRY_NO_DATA && psHDMITXResPri->stHDMITxInfo.colorimetry != E_HDMITX_COLORIMETRY_MAX)
4740 {
4741 //ubRet = FALSE;
4742 }
4743 }
4744
4745 return ubRet;
4746 }
4747
4748 //**************************************************************************
4749 // [Function Name]:
4750 // MDrv_HDMITx_GetCECStatus()
4751 // [Description]:
4752 // get CEC enable flag
4753 // [Arguments]:
4754 // void
4755 // [Return]:
4756 // MS_BOOL
4757 //
4758 //**************************************************************************
MDrv_HDMITx_GetCECStatus(void * pInstance)4759 MS_BOOL MDrv_HDMITx_GetCECStatus(void* pInstance)
4760 {
4761 MS_BOOL bRet;
4762
4763 _HDMITX_SEMAPHORE_ENTRY(pInstance);
4764
4765 _HDMITX_GET_VARIABLE();
4766 bRet = psHDMITXResPri->stHDMITxInfo.hdmitx_CECEnable_flag;
4767
4768 _HDMITX_SEMAPHORE_RETURN(pInstance);
4769
4770 return bRet;
4771 }
4772
4773 //------------------------------------------------------------------------------
4774 /// @brief This routine will power on/off HDMITx clock (power saving)
4775 /// @return None
4776 //------------------------------------------------------------------------------
MDrv_HDMITx_Power_OnOff(MS_BOOL bEnable)4777 void MDrv_HDMITx_Power_OnOff(MS_BOOL bEnable)
4778 {
4779 MHal_HDMITx_Power_OnOff(bEnable);
4780 }
4781
4782 //------------------------------------------------------------------------------
4783 /// @brief This routine turn on/off HDMI Tx Module
4784 /// @return None
4785 //------------------------------------------------------------------------------
MDrv_HDMITx_TurnOnOff(void * pInstance,MS_BOOL state)4786 void MDrv_HDMITx_TurnOnOff(void *pInstance, MS_BOOL state)
4787 {
4788 _HDMITX_GET_VARIABLE();
4789
4790 psHDMITXResPri->stHDMITxInfo.hdmitx_enable_flag = state;
4791 psHDMITXResPri->stHDMITxInfo.hdmitx_tmds_flag = state;
4792
4793 if (psHDMITXResPri->stHDMITxInfo.hdmitx_enable_flag) // turn on
4794 {
4795 MDrv_HDCPTx_SetAuthStartFlag(pInstance, FALSE); //wilson@kano
4796 MDrv_HDCPTx_SetAuthDoneFlag(pInstance, FALSE); //wilson@kano
4797
4798 //MDrv_HDMITx_PLLOnOff();
4799 #if HDMITX_ISR_ENABLE
4800 MHal_HDMITx_Int_Enable(gHDMITXIRQ);
4801 #endif
4802 MHal_HDMITx_VideoInit();
4803 MHal_HDMITx_AudioInit();
4804 //MDrv_HDMITx_SetTMDSOnOff();
4805 //MDrv_HDMITx_Exhibit();
4806 }
4807 else // turn off
4808 {
4809 MDrv_HDCPTx_SetAuthStartFlag(pInstance, FALSE); //wilson@kano
4810 MDrv_HDCPTx_SetAuthDoneFlag(pInstance, FALSE); //wilson@kano
4811
4812 #if HDMITX_ISR_ENABLE
4813 MHal_HDMITx_Int_Disable(gHDMITXIRQ);
4814 MHal_HDMITx_Int_Clear(gHDMITXIRQ);
4815 #endif
4816 MDrv_HDMITx_SetTMDSOnOff(pInstance, psHDMITXResPri->stHDMITxInfo.hdmitx_tmds_flag);
4817
4818 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_prestate = E_HDMITX_FSM_PENDING;
4819 psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status = E_HDMITX_DVIClock_L_HPD_L;
4820 _hdmitx_preRX_status = psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status;
4821
4822 if(_s32CheckRxTimerId > 0)
4823 MsOS_StopTimer(_s32CheckRxTimerId);
4824 }
4825 }
4826
4827 //------------------------------------------------------------------------------
4828 /// @brief This routine control HDMI packet generation
4829 /// @return None
4830 //------------------------------------------------------------------------------
MDrv_HDMITx_EnablePacketGen(MS_BOOL bflag)4831 void MDrv_HDMITx_EnablePacketGen(MS_BOOL bflag)
4832 {
4833 MHal_HDMITx_EnablePacketGen(bflag);
4834 }
4835
4836 //------------------------------------------------------------------------------
4837 /// @brief This function clear settings of user defined packet
4838 /// @return None
4839 //------------------------------------------------------------------------------
MDrv_HDMITx_PKT_User_Define_Clear(void)4840 void MDrv_HDMITx_PKT_User_Define_Clear(void)
4841 {
4842 MHal_HDMITx_PKT_User_Define_Clear();
4843 }
4844
4845 //------------------------------------------------------------------------------
4846 /// @brief This function set user defined hdmi packet
4847 /// @return None
4848 //------------------------------------------------------------------------------
MDrv_HDMITx_PKT_User_Define(MsHDMITX_PACKET_TYPE packet_type,MS_BOOL def_flag,MsHDMITX_PACKET_PROCESS def_process,MS_U8 def_fcnt)4849 void MDrv_HDMITx_PKT_User_Define(MsHDMITX_PACKET_TYPE packet_type, MS_BOOL def_flag,
4850 MsHDMITX_PACKET_PROCESS def_process, MS_U8 def_fcnt)
4851 {
4852 MHal_HDMITx_PKT_User_Define(packet_type, def_flag, def_process, def_fcnt);
4853
4854 if ((packet_type == E_HDMITX_VS_INFOFRAME) )
4855 {
4856 if(def_process == E_HDMITX_CYCLIC_PACKET)
4857 {
4858 g_bDisableVSInfo = FALSE;
4859 }
4860 else
4861 {
4862 g_bDisableVSInfo = TRUE;
4863 }
4864 }
4865
4866 if(_hdmitx_status.bIsInitialized) // fix code dump
4867 {
4868 MDrv_HDMITx_SendPacket(packet_type, def_process);
4869 }
4870 }
4871
4872 //------------------------------------------------------------------------------
4873 /// @brief This function set user defined hdmi packet content
4874 /// @return None
4875 //------------------------------------------------------------------------------
MDrv_HDMITx_PKT_Content_Define(MsHDMITX_PACKET_TYPE packet_type,MS_U8 * data,MS_U8 length)4876 MS_BOOL MDrv_HDMITx_PKT_Content_Define(MsHDMITX_PACKET_TYPE packet_type, MS_U8* data, MS_U8 length)
4877 {
4878 return MHal_HDMITx_PKT_Content_Define(packet_type, data, length);
4879 }
4880
4881 //------------------------------------------------------------------------------
4882 /// @brief This routine Mute Audio FIFO
4883 /// @param[in] bflag: True: mute audio, False: unmute audio
4884 /// @return None
4885 //------------------------------------------------------------------------------
MDrv_HDMITx_MuteAudioFIFO(MS_BOOL bflag)4886 void MDrv_HDMITx_MuteAudioFIFO(MS_BOOL bflag)
4887 {
4888 MHal_HDMITx_MuteAudioFIFO(bflag);
4889 }
4890
4891 //**************************************************************************
4892 // [Function Name]:
4893 // MDrv_HDMITx_AnalogTuning()
4894 // [Description]:
4895 // loading analog setting
4896 // [Arguments]:
4897 // [HDMITX_ANALOG_TUNING] *pInfo
4898 // [Return]:
4899 // void
4900 //
4901 //**************************************************************************
MDrv_HDMITx_AnalogTuning(void * pInstance,drvHDMITX_ANALOG_TUNING * pInfo)4902 void MDrv_HDMITx_AnalogTuning(void* pInstance, drvHDMITX_ANALOG_TUNING *pInfo)
4903 {
4904 _HDMITX_GET_VARIABLE();
4905 memcpy(&psHDMITXResPri->stHDMITxInfo.analog_setting, (drvHDMITX_ANALOG_TUNING*)pInfo, sizeof(drvHDMITX_ANALOG_TUNING));
4906 }
4907
4908 //------------------------------------------------------------------------------
4909 /// @brief This routine turn on/off HDMI Tx output force mode
4910 /// @argument:
4911 /// - bflag: TRUE: force mode, FALSE: auto mode
4912 /// - output_mode: E_HDMITX_DVI: DVI, E_HDMITX_HDMI: HDMI
4913 /// @return None
4914 //------------------------------------------------------------------------------
MDrv_HDMITx_ForceHDMIOutputMode(void * pInstance,MS_BOOL bflag,MsHDMITX_OUTPUT_MODE output_mode)4915 void MDrv_HDMITx_ForceHDMIOutputMode(void* pInstance, MS_BOOL bflag, MsHDMITX_OUTPUT_MODE output_mode)
4916 {
4917 _HDMITX_GET_VARIABLE();
4918
4919 psHDMITXResPri->stHDMITxInfo.hdmitx_force_mode = bflag;
4920 if(bflag)
4921 {
4922 psHDMITXResPri->stHDMITxInfo.force_output_mode = output_mode;
4923 psHDMITXResPri->stHDMITxInfo.output_mode = psHDMITXResPri->stHDMITxInfo.force_output_mode;
4924 if((psHDMITXResPri->stHDMITxInfo.force_output_mode == E_HDMITX_DVI) || (psHDMITXResPri->stHDMITxInfo.force_output_mode == E_HDMITX_DVI_HDCP)) // DVI mode
4925 {
4926 //gHDMITxInfo.hdmitx_audio_supportAI = FALSE;
4927 psHDMITXResPri->stHDMITxInfo.RxEdidInfo.AudSupportAI = FALSE;
4928 psHDMITXResPri->stHDMITxInfo.output_color = E_HDMITX_VIDEO_COLOR_RGB444;
4929 MDrv_HDMITx_SetAVIInfoPktPara(pInstance);
4930 }
4931 }
4932 }
4933
4934 //------------------------------------------------------------------------------
4935 /// @brief This routine turn on/off HDMI Tx output force color format
4936 /// @argument:
4937 /// - bflag: TRUE: force output color format, FALSE: auto mode
4938 /// - output_mode: HDMITX_VIDEO_COLOR_RGB444: RGB, HDMITX_VIDEO_COLOR_YUV444: YUV
4939 /// @return Ture: Set force output color format successfully
4940 /// FALSE: Fail to set force output color format
4941 //------------------------------------------------------------------------------
MDrv_HDMITx_ForceHDMIOutputColorFormat(void * pInstance,MS_BOOL bflag,MsHDMITX_VIDEO_COLOR_FORMAT output_color)4942 MS_BOOL MDrv_HDMITx_ForceHDMIOutputColorFormat(void* pInstance, MS_BOOL bflag, MsHDMITX_VIDEO_COLOR_FORMAT output_color)
4943 {
4944 _HDMITX_SEMAPHORE_ENTRY(pInstance);
4945 _HDMITX_GET_VARIABLE();
4946
4947 if (bflag)
4948 {
4949 if((output_color != E_HDMITX_VIDEO_COLOR_RGB444) && (psHDMITXResPri->stHDMITxInfo.output_mode == E_HDMITX_DVI || psHDMITXResPri->stHDMITxInfo.output_mode == E_HDMITX_DVI_HDCP))
4950 {
4951 printf("Set force output color format failed!\n");
4952 _HDMITX_SEMAPHORE_RETURN(pInstance);
4953 return FALSE;
4954 }
4955
4956 psHDMITXResPri->stHDMITxInfo.hdmitx_force_output_color = bflag;
4957 psHDMITXResPri->stHDMITxInfo.force_output_color = output_color;
4958 psHDMITXResPri->stHDMITxInfo.output_color = psHDMITXResPri->stHDMITxInfo.force_output_color;
4959
4960 if( (psHDMITXResPri->stHDMITxInfo.input_color != psHDMITXResPri->stHDMITxInfo.output_color) && (psHDMITXResPri->stHDMITxInfo.output_color == E_HDMITX_VIDEO_COLOR_RGB444) )
4961 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = TRUE;
4962 else // bypass
4963 psHDMITXResPri->stHDMITxInfo.hdmitx_csc_flag = FALSE;
4964
4965 MDrv_HDMITx_SetAVIInfoPktPara(pInstance);
4966 }
4967
4968 _HDMITX_SEMAPHORE_RETURN(pInstance);
4969 return TRUE;
4970 }
4971
4972 //**************************************************************************
4973 // [Function Name]:
4974 // MDrv_HDMITx_DisableRegWrite()
4975 // [Description]:
4976 // set flag which indicate if we are going to disable register write
4977 // [Arguments]:
4978 // [MS_BOOL] bFlag
4979 // [Return]:
4980 // void
4981 //
4982 //**************************************************************************
MDrv_HDMITx_DisableRegWrite(MS_BOOL bFlag)4983 void MDrv_HDMITx_DisableRegWrite(MS_BOOL bFlag)
4984 {
4985 g_bDisableRegWrite = bFlag;
4986 }
4987
4988 //**************************************************************************
4989 // [Function Name]:
4990 // MDrv_HDMITx_RxBypass_Mode()
4991 // [Description]:
4992 // set Rx bypass mode
4993 // [Arguments]:
4994 // [MsHDMITX_INPUT_FREQ] freq
4995 // [MS_BOOL] bflag
4996 // [Return]:
4997 // MS_BOOL
4998 //
4999 //**************************************************************************
MDrv_HDMITx_RxBypass_Mode(void * pInstance,MsHDMITX_INPUT_FREQ freq,MS_BOOL bflag)5000 MS_BOOL MDrv_HDMITx_RxBypass_Mode(void* pInstance, MsHDMITX_INPUT_FREQ freq, MS_BOOL bflag)
5001 {
5002 MS_BOOL bRet = FALSE;
5003
5004 _HDMITX_SEMAPHORE_ENTRY(pInstance);
5005 _HDMITX_GET_VARIABLE();
5006
5007 if(psHDMITXResPri->stHDMITxInfo.hdmitx_bypass_flag == bflag)
5008 return FALSE;
5009
5010 MDrv_HDCPTx_SetAuthStartFlag(pInstance, FALSE);
5011 MDrv_HDCPTx_SetAuthDoneFlag(pInstance, FALSE);
5012 #if HDMITX_ISR_ENABLE
5013 MHal_HDMITx_Int_Disable(gHDMITXIRQ);
5014 MHal_HDMITx_Int_Clear(gHDMITXIRQ);
5015 #endif
5016 //MDrv_HDMITx_SetTMDSOnOff();
5017 //MDrv_HDMITx_PLLOnOff();
5018 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_prestate = E_HDMITX_FSM_PENDING;
5019 psHDMITXResPri->stHDMITxInfo.hdmitx_bypass_flag = bflag;
5020 if(!bflag)
5021 {
5022 psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status = E_HDMITX_DVIClock_L_HPD_L;
5023 _hdmitx_preRX_status = psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status;
5024 }
5025
5026 if (_s32CheckRxTimerId > 0)
5027 MsOS_StopTimer(_s32CheckRxTimerId);
5028
5029 _MDrv_HDCPTx_StopRiTimer();
5030
5031 bRet = MHal_HDMITx_RxBypass_Mode(freq, bflag);
5032 _HDMITX_SEMAPHORE_RETURN(pInstance);
5033
5034 return bRet;
5035
5036
5037 }
5038
5039 //**************************************************************************
5040 // [Function Name]:
5041 // MDrv_HDMITx_Disable_RxBypass()
5042 // [Description]:
5043 // disable Rx bypass mode
5044 // [Arguments]:
5045 // void
5046 // [Return]:
5047 // MS_BOOL
5048 //
5049 //**************************************************************************
MDrv_HDMITx_Disable_RxBypass(void * pInstance)5050 MS_BOOL MDrv_HDMITx_Disable_RxBypass(void* pInstance)
5051 {
5052 _HDMITX_GET_VARIABLE();
5053
5054 #if HDMITX_ISR_ENABLE
5055 MHal_HDMITx_Int_Enable(gHDMITXIRQ);
5056 #endif
5057 MHal_HDMITx_VideoInit();
5058 MHal_HDMITx_AudioInit();
5059 //MDrv_HDMITx_SetTMDSOnOff();
5060 _HDMITX_SEMAPHORE_ENTRY(pInstance);
5061
5062 psHDMITXResPri->stHDMITxInfo.hdmitx_bypass_flag = FALSE;
5063
5064 MDrv_HDMITx_Exhibit(pInstance);
5065
5066 _HDMITX_SEMAPHORE_RETURN(pInstance);
5067
5068 return MHal_HDMITx_Disable_RxBypass();
5069 }
5070
5071 //------------------------------------------------------------------------------
5072 /// @brief This routine turn on/off HDMI PLL
5073 /// @return None
5074 //------------------------------------------------------------------------------
MDrv_HDMITx_PLLOnOff(void)5075 void MDrv_HDMITx_PLLOnOff(void)
5076 {
5077 //MHal_HDMITx_PLLOnOff(gHDMITxInfo.hdmitx_enable_flag);
5078 }
5079
5080 //------------------------------------------------------------------------------
5081 /// @brief This routine return CHIP capability of DVI mode
5082 /// @return TRUE, FALSE
5083 //------------------------------------------------------------------------------
MDrv_HDMITx_IsSupportDVIMode(void)5084 MS_BOOL MDrv_HDMITx_IsSupportDVIMode(void)
5085 {
5086 return MHal_HDMITx_IsSupportDVIMode();
5087 }
5088
5089 //**************************************************************************
5090 // [Function Name]:
5091 // MDrv_HDMITx_DisableTMDSCtrl()
5092 // [Description]:
5093 // set flag which indicate if enable tmds control or not
5094 // [Arguments]:
5095 // [MS_BOOL] bFlag
5096 // [Return]:
5097 // void
5098 //
5099 //**************************************************************************
MDrv_HDMITx_DisableTMDSCtrl(MS_BOOL bFlag)5100 void MDrv_HDMITx_DisableTMDSCtrl(MS_BOOL bFlag)
5101 {
5102 g_bDisableTMDSCtrl = bFlag;
5103 }
5104
5105 //**************************************************************************
5106 // [Function Name]:
5107 // MDrv_HDMITx_Exhibit()
5108 // [Description]:
5109 // setup environment and make HDMI process start
5110 // [Arguments]:
5111 // void
5112 // [Return]:
5113 // void
5114 //
5115 //**************************************************************************
MDrv_HDMITx_Exhibit(void * pInstance)5116 void MDrv_HDMITx_Exhibit(void* pInstance)
5117 {
5118 _HDMITX_GET_VARIABLE();
5119
5120 if (psHDMITXResPri->stHDMITxInfo.output_mode & BIT0) // check HDCP
5121 psHDMITXResPri->stHDMITxInfo.hdmitx_hdcp_flag = TRUE;
5122 else
5123 psHDMITXResPri->stHDMITxInfo.hdmitx_hdcp_flag = FALSE;
5124
5125 if (((MDrv_HDMITx_GetColorFormat(pInstance) != E_HDMITX_VIDEO_COLOR_YUV420) && (MDrv_HDMITx_GetColorFormat(pInstance) != E_HDMITX_VIDEO_COLOR_YUV422)) &&
5126 ((MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_1920x2205p_24Hz) ||
5127 (MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_1280x1470p_50Hz) ||
5128 (MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_1280x1470p_60Hz) ||
5129 (MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_3840x2160p_50Hz) ||
5130 (MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_3840x2160p_60Hz) ||
5131 (MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_4096x2160p_50Hz) ||
5132 (MDrv_HDMITx_GetOutputTiming(pInstance) == E_HDMITX_RES_4096x2160p_60Hz)))
5133 {
5134 psHDMITXResPri->stHDMITxInfo.output_colordepth_val = E_HDMITX_VIDEO_CD_24Bits;
5135 }
5136
5137 MDrv_HDMITx_SetDeepColorMode(pInstance, psHDMITXResPri->stHDMITxInfo.output_colordepth_val);
5138 MDrv_HDMITx_SetColorFormat(pInstance, psHDMITXResPri->stHDMITxInfo.input_color, psHDMITXResPri->stHDMITxInfo.output_color);
5139 MDrv_HDMITx_SetHDMITxMode(pInstance, psHDMITXResPri->stHDMITxInfo.output_mode);
5140 MDrv_HDMITx_SetVideoOutputMode(pInstance, psHDMITXResPri->stHDMITxInfo.output_video_timing);
5141
5142 MDrv_HDMITx_SetAudioFrequency(pInstance, psHDMITXResPri->stHDMITxInfo.output_audio_frequncy);
5143
5144 // The 1st HDCP authentication
5145 if (MDrv_HDCPTx_GetAuthDoneFlag(pInstance) == FALSE)
5146 {
5147 if( (!MDrv_HDMITx_GetEdidRdyFlag(pInstance)) || (psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status != E_HDMITX_DVIClock_H_HPD_H))
5148 {
5149 MDrv_HDMITx_SetFSMState(pInstance, E_HDMITX_FSM_VALIDATE_EDID);
5150 MDrv_HDCPTx_SetRxValid(pInstance, FALSE);
5151 }
5152 _MDrv_HDCPTx_StopRiTimer();
5153
5154 psHDMITXResPri->stHDMITxInfo.output_video_prevtiming = psHDMITXResPri->stHDMITxInfo.output_video_timing;
5155 //psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status = E_HDMITX_DVIClock_L_HPD_L;
5156 //_hdmitx_preRX_status = psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status;
5157
5158 if (psHDMITXResPri->stHDMITxInfo.hdmitx_hdcp_flag)
5159 {
5160 MDrv_HDCPTx_StartAuth(pInstance, TRUE);
5161 }
5162
5163 // Create timer for timing monitor
5164 if(_s32CheckRxTimerId < 0)
5165 {
5166 _s32CheckRxTimerId = MsOS_CreateTimer( _MDrv_HDMITX_CheckRx_TimerCallback,
5167 CheckRx_Timer,
5168 CheckRx_Timer,
5169 TRUE,
5170 "Check Rx timer");
5171
5172 psHDMITXResPri->stHDMITxInfo.bCheckRxTimerIdCreated = TRUE;
5173
5174 if(_s32CheckRxTimerId < 0)
5175 {
5176 DBG_HDMITX(printf("MDrv_HDMITX_Init: Create Check Rx timer fail!\n"));
5177 psHDMITXResPri->stHDMITxInfo.bCheckRxTimerIdCreated = FALSE;
5178 }
5179 DBG_HDMITX(printf("MDrv_HDMITx_Exhibit: Create Check Rx timer success!\n"));
5180 }
5181 else
5182 {
5183 MsOS_StopTimer(_s32CheckRxTimerId);
5184 MsOS_StartTimer(_s32CheckRxTimerId);
5185 }
5186 //return;
5187 }
5188
5189 // HDCP re-authentication while timing changed or input source changed
5190 //else if((gHDMITxInfo.output_video_prevtiming != gHDMITxInfo.output_video_timing) && gHDMITxInfo.hdmitx_hdcp_flag)
5191 else if (psHDMITXResPri->stHDMITxInfo.hdmitx_hdcp_flag)
5192 {
5193 //MDrv_HDCPTx_SetRxValid(pInstance, FALSE);
5194 _MDrv_HDCPTx_StopRiTimer();
5195 MDrv_HDCPTx_StartAuth(pInstance, TRUE);
5196 psHDMITXResPri->stHDMITxInfo.output_video_prevtiming = psHDMITXResPri->stHDMITxInfo.output_video_timing;
5197
5198 DBG_HDMITX(printf("MDrv_HDMITx_Exhibit: HDCP reauthentication!!\n"));
5199 }
5200 else // turn off HDCP encryption
5201 {
5202 MDrv_HDCPTx_StartAuth(pInstance, FALSE);//MDrv_HDCPTx_SetRxValid(pInstance, FALSE);
5203 _MDrv_HDCPTx_StopRiTimer();
5204
5205 MHal_HDMITx_HdcpSetEncrypt(DISABLE);
5206 DBG_HDMITX(printf("MDrv_HDMITx_Exhibit: Turn off HDCP!!\n"));
5207 }
5208
5209 if (MDrv_HDCPTx_GetAuthDoneFlag(pInstance) == TRUE)
5210 {
5211 MDrv_HDMITx_SetVideoOnOff(pInstance, psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag);
5212 MDrv_HDMITx_SetAudioOnOff(pInstance, psHDMITXResPri->stHDMITxInfo.hdmitx_audio_flag);
5213 }
5214 //MDrv_HDMITx_SetHDCPOnOff();
5215 //MDrv_HDMITx_SetTMDSOnOff();
5216
5217 // Fix garbage while turn HDCP ON -> OFF
5218 if( ((MDrv_HDCPTx_GetAuthDoneFlag(pInstance) == TRUE)||(MDrv_HDMITx_GetFSMState(pInstance) == E_HDMITX_FSM_DONE)) && (!psHDMITXResPri->stHDMITxInfo.hdmitx_hdcp_flag) )
5219 {
5220 if (psHDMITXResPri->stHDMITxInfo.hdmitx_avmute_flag)
5221 {
5222 MDrv_HDMITx_SetAVMUTE(pInstance, FALSE);
5223 psHDMITXResPri->stHDMITxInfo.hdmitx_avmute_flag = FALSE;
5224 }
5225 }
5226 }
5227
MDrv_HDMITx_CheckOver3G(void * pInstance)5228 MS_BOOL MDrv_HDMITx_CheckOver3G(void* pInstance)
5229 {
5230 #if 0
5231 _HDMITX_GET_VARIABLE();
5232
5233 if ((psHDMITXResPri->stHDMITxInfo.output_color != E_HDMITX_VIDEO_COLOR_YUV420) &&
5234 (
5235 (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_3840x2160p_50Hz) ||
5236 (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_3840x2160p_60Hz) ||
5237 (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_4096x2160p_50Hz) ||
5238 (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_4096x2160p_60Hz) ||
5239 (
5240 (
5241 (psHDMITXResPri->stHDMITxInfo.output_colordepth_val != E_HDMITX_VIDEO_CD_24Bits) && \
5242 (psHDMITXResPri->stHDMITxInfo.output_colordepth_val != E_HDMITX_VIDEO_CD_NoID)
5243 ) &&
5244 (
5245 (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_3840x2160p_24Hz) || \
5246 (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_3840x2160p_25Hz) || \
5247 (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_3840x2160p_30Hz) || \
5248 (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_4096x2160p_24Hz) || \
5249 (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_4096x2160p_25Hz) || \
5250 (psHDMITXResPri->stHDMITxInfo.output_video_timing == E_HDMITX_RES_4096x2160p_30Hz)
5251 )
5252 )
5253 )
5254 )
5255 return TRUE;
5256 else
5257 return FALSE;
5258 #else
5259 return FALSE;
5260 #endif
5261 }
5262
5263 //**************************************************************************
5264 // [Function Name]:
5265 // HDMITx_Handler()
5266 // [Description]:
5267 // HDMI TX FSM
5268 // [Arguments]:
5269 // [MS_U32] u32State
5270 // [Return]:
5271 // void
5272 //
5273 //**************************************************************************
HDMITx_Handler(void * pInstance,MS_U32 u32State)5274 void HDMITx_Handler(void* pInstance, MS_U32 u32State) //wilson@kano
5275 {
5276 MS_U32 u32IRQStatus;
5277
5278 _HDMITX_GET_VARIABLE();
5279
5280 if(psHDMITXResPri->stHDMITxInfo.hdmitx_bypass_flag)
5281 {
5282 //RXTXBypass
5283 return;
5284 }
5285
5286 if (u32State & E_HDMITX_EVENT_RXTIMER)
5287 {
5288 MsHDMITX_RX_STATUS enCurRxStatus;
5289
5290 //enCurRxStatus = MHal_HDMITx_GetRXStatus();
5291 enCurRxStatus = gbCurRxStatus;
5292
5293 if (psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status != enCurRxStatus)
5294 {
5295 DBG_HDMITX(printf("E_HDMITX_FSM_CHECK_HPD:: pre= %d, cur = %d\n", psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status, enCurRxStatus));
5296
5297 MDrv_HDCPTx_SetRxValid(pInstance, FALSE);
5298 _MDrv_HDCPTx_StopRiTimer();
5299 MHal_HDMITx_HdcpSetEncrypt(DISABLE);
5300
5301 if ((enCurRxStatus == E_HDMITX_DVIClock_H_HPD_H) || (enCurRxStatus == E_HDMITX_DVIClock_L_HPD_H))
5302 {
5303 // update EDID when (1) HPD L -> H or (2) DVI clock L -> H with HPD always high
5304 bCheckEDID = TRUE;
5305 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state = E_HDMITX_FSM_VALIDATE_EDID;
5306 psHDMITXResPri->stHDMITxInfo.hdmitx_edid_ready = FALSE;
5307
5308 if(enCurRxStatus == E_HDMITX_DVIClock_H_HPD_H)
5309 {
5310 psHDMITXResPri->stHDMITxInfo.hdmitx_tmds_flag = TRUE;
5311 }
5312 }
5313 else
5314 {
5315 bCheckEDID = FALSE;
5316 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state = E_HDMITX_FSM_PENDING;
5317 //gHDMITxInfo.hdmitx_tmds_flag = FALSE;
5318 psHDMITXResPri->stHDMITxInfo.hdmitx_edid_ready = FALSE;
5319
5320 MHal_HDMITx_HdcpSetEncrypt(DISABLE); // HDCP test
5321 MDrv_HDCPTx_SetAuthDoneFlag(pInstance, FALSE);
5322 MDrv_HDCPTx_SetAuthStartFlag(pInstance, FALSE);
5323 MDrv_HDMITx_SetTMDSOnOff(pInstance, FALSE);
5324 }
5325
5326 psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status = enCurRxStatus;
5327 _hdmitx_preRX_status = psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status;
5328
5329 MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_RUN);
5330 }
5331 else // To avoid two events are coming together - HDCP CTS 1A-02
5332 {
5333 if (u32State & E_HDMITX_EVENT_RUN)
5334 MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_RUN);
5335 }
5336 }
5337 else if (u32State & E_HDMITX_EVENT_RUN)
5338 {
5339 if ((psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status == E_HDMITX_DVIClock_H_HPD_H) || (psHDMITXResPri->stHDMITxInfo.hdmitx_preRX_status == E_HDMITX_DVIClock_L_HPD_H)) //rx attached
5340 {
5341 if (psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state != psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_prestate)
5342 printf("HDMI handler preState:curState = %d : %d\r\n", psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_prestate, psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state);
5343 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_prestate = psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state; //update state
5344
5345 switch (psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state)
5346 {
5347 case E_HDMITX_FSM_PENDING: //idle state
5348 {
5349 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_prestate = E_HDMITX_FSM_PENDING;
5350 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state = E_HDMITX_FSM_PENDING;
5351 }
5352 break;
5353
5354 case E_HDMITX_FSM_VALIDATE_EDID:
5355 {
5356 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_prestate = E_HDMITX_FSM_VALIDATE_EDID;
5357 psHDMITXResPri->stHDMITxInfo.hdmitx_edid_ready = FALSE;
5358
5359 MHal_HDMITx_HdcpSetEncrypt(DISABLE);
5360 MDrv_HDCPTx_SetFSMState(pInstance, HDCP14Tx_MainState_A0, HDCP14Tx_SubFSM_IDLE);
5361
5362 if (MDrv_HDMITx_EdidChecking(pInstance))
5363 {
5364 DBG_HDMITX(printf("\nMDrv_HDMITX_Process()::EDID OK\n"));
5365 Mhal_HDMITx_SetSCDCCapability(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportSCDC);
5366
5367 psHDMITXResPri->stHDMITxInfo.hdmitx_edid_ready = TRUE;
5368
5369 //gHDMITxInfo.hdmitx_fsm_state = E_HDMITX_FSM_PRE_TRANSMIT; //for future usage
5370 MDrv_HDMITx_SetVideoOutputMode(pInstance, psHDMITXResPri->stHDMITxInfo.output_video_timing);
5371 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state = E_HDMITX_FSM_TRANSMIT;
5372
5373 //MDrv_HDCPTx_SetRxValid(pInstance, TRUE);
5374 if (psHDMITXResPri->stHDMITxInfo.hdmitx_hdcp_flag == TRUE) // HDCP off
5375 {
5376 MDrv_HDCPTx_SetAuthStartFlag(pInstance, TRUE);
5377 }
5378 else
5379 {
5380 MDrv_HDCPTx_SetAuthStartFlag(pInstance, FALSE);
5381 _MDrv_HDCPTx_StopRiTimer();
5382 }
5383 }
5384 else //invalid EDID
5385 {
5386 Mhal_HDMITx_SetSCDCCapability(FALSE);
5387 DBG_HDMITX(printf("\nMDrv_HDMITX_Process()::EDID FAIL!!\n"));
5388 MDrv_HDCPTx_SetRxValid(pInstance, FALSE);
5389
5390 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state = E_HDMITX_FSM_PENDING;
5391 }
5392
5393 MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_RUN);
5394
5395 //MDrv_HDCPTx_SetRxValid(pInstance, TRUE);
5396 if (psHDMITXResPri->stHDMITxInfo.output_mode & BIT0)
5397 {
5398 MsOS_SetEvent(_s32HDMITxEventId, E_HdcpTX_EVENT_RUN); //start hdcp authentication flow
5399 }
5400 }
5401 break;
5402
5403 case E_HDMITX_FSM_PRE_TRANSMIT:
5404 {
5405 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_prestate = E_HDMITX_FSM_PRE_TRANSMIT;
5406 }
5407 break;
5408
5409 case E_HDMITX_FSM_TRANSMIT:
5410 {
5411 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_prestate = E_HDMITX_FSM_TRANSMIT;
5412
5413 MDrv_HDMITx_SetHDMITxMode(pInstance, psHDMITXResPri->stHDMITxInfo.output_mode);
5414 MDrv_HDMITx_SetColorFormat(pInstance, psHDMITXResPri->stHDMITxInfo.input_color, psHDMITXResPri->stHDMITxInfo.output_color);
5415 //MDrv_HDMITx_SetVideoOutputMode(pInstance, psHDMITXResPri->stHDMITxInfo.output_video_timing);
5416 MDrv_HDMITx_SetAudioFrequency(pInstance, psHDMITXResPri->stHDMITxInfo.output_audio_frequncy);
5417 MDrv_HDCPTx_SetRxValid(pInstance, TRUE);
5418
5419 if ((MDrv_HDCPTx_GetUnHdcpControl(pInstance) == E_NORMAL_OUTPUT)
5420 ||(psHDMITXResPri->stHDMITxInfo.hdmitx_hdcp_flag == FALSE))
5421 {
5422 MDrv_HDMITx_SetVideoOnOff(pInstance, TRUE); //psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag = TRUE;
5423 MDrv_HDMITx_SetAudioOnOff(pInstance, TRUE);
5424 }
5425 else
5426 {
5427 MDrv_HDMITx_SetAVMUTE(pInstance, TRUE);
5428 //Fix Panasonic UITA 2000 HDCP test fail, Video should be show after ENC_EN was detects
5429 MDrv_HDMITx_SetVideoOnOff(pInstance, FALSE); //psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag = FALSE;
5430 MDrv_HDMITx_SetAudioOnOff(pInstance, FALSE);//psHDMITXResPri->stHDMITxInfo.hdmitx_audio_flag = FALSE;
5431 }
5432
5433 MDrv_HDMITx_SetTMDSOnOff(pInstance, TRUE);
5434
5435 if (psHDMITXResPri->stHDMITxInfo.hdmitx_hdcp_flag == FALSE)
5436 {
5437 if (psHDMITXResPri->stHDMITxInfo.hdmitx_avmute_flag == TRUE)
5438 {
5439 MDrv_HDMITx_SetAVMUTE(pInstance, FALSE);
5440 }
5441 }
5442
5443 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state = E_HDMITX_FSM_DONE;
5444
5445 MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_RUN);
5446
5447 }
5448 break;
5449
5450 case E_HDMITX_FSM_DONE:
5451 {
5452 #if 0
5453 MS_U8 ucSCDCStatus = 0x00;
5454
5455 psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_prestate = E_HDMITX_FSM_DONE;
5456 //MDrv_HDCPTx_SetFSMState(pInstance, HDCP14Tx_MainState_A0, HDCP14Tx_SubFSM_IDLE);
5457
5458 //TBD: adding SCDC checking routine here;
5459 if (Mhal_HDMITx_SCDCAccessField(E_SCDC_SCRAMBLE_STAT_IDX, TRUE, &ucSCDCStatus, 0x01))
5460 {
5461 //TBD
5462 }
5463 #endif
5464
5465 MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_RUN);
5466 }
5467 break;
5468
5469 default:
5470 break;
5471 }
5472 }
5473
5474 //MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_RUN);
5475
5476 }
5477 else if (u32State & E_HDMITX_EVENT_IRQ)
5478 {
5479 u32IRQStatus = MHal_HDMITx_Int_Status();
5480
5481 if (u32IRQStatus & E_HDMITX_IRQ_12) // TMDS hot-plug
5482 {
5483 DBG_HDMITX(printf("MDrv_HDMITX_Process()::E_HDMITX_IRQ_12\n"));
5484 //gHDMITxInfo.hdmitx_fsm_state = E_HDMITX_FSM_CHECK_HPD;
5485 MHal_HDMITx_Int_Clear(E_HDMITX_IRQ_12);
5486 //MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_RUN);
5487 }
5488 else if (u32IRQStatus & E_HDMITX_IRQ_10) // Rx disconnection
5489 {
5490 DBG_HDMITX(printf("MDrv_HDMITX_Process()::E_HDMITX_IRQ_10\n"));
5491 //gHDMITxInfo.hdmitx_fsm_state = E_HDMITX_FSM_CHECK_HPD;
5492 MHal_HDMITx_Int_Clear(E_HDMITX_IRQ_10);
5493 //MsOS_SetEvent(_s32HDMITxEventId, E_HDMITX_EVENT_RUN);
5494 }
5495 }
5496 }
5497
5498 //**************************************************************************
5499 // [Function Name]:
5500 // ()
5501 // [Description]:
5502 //
5503 // [Arguments]:
5504 //
5505 // [Return]:
5506 //
5507 //
5508 //**************************************************************************
5509 #if (defined(MSOS_TYPE_LINUX_KERNEL))
5510 static INTERFACED void* pu32HDMITxTaskInst = NULL;
5511 #endif
5512
_HDMITx_Task(void * pInstance)5513 static void _HDMITx_Task(void* pInstance) //wilson@kano
5514 {
5515 MS_U32 u32Events = 0;
5516
5517 while (g_bHDMITxTask == TRUE)
5518 {
5519 #if (defined(MSOS_TYPE_LINUX_KERNEL))
5520 if (pu32HDMITxTaskInst == NULL)
5521 {
5522 if (UtopiaOpen(MODULE_HDMITX, &pu32HDMITxTaskInst, 0, NULL)!= UTOPIA_STATUS_SUCCESS)
5523 {
5524 DBG_HDMITX(printf("%s: Get Task Instance FAIL!\n", __FUNCTION__));
5525 return;
5526 }
5527 }
5528
5529 pInstance = pu32HDMITxTaskInst;
5530 #endif
5531
5532 #if HDMITX_ISR_ENABLE
5533 // Task wake up
5534 //MsOS_WaitEvent(_s32HDMITxEventId, E_HDMITX_EVENT_RUN|E_HDMITX_EVENT_IRQ, &u32Events, E_OR_CLEAR, MSOS_WAIT_FOREVER);
5535 //Loop polling MAD audio sampling rate and config it for HDMI TX
5536 MsOS_WaitEvent(_s32HDMITxEventId, E_HDMITX_EVENT_RUN|E_HDMITX_EVENT_IRQ|E_HDMITX_EVENT_RXTIMER|E_HDMITX_EVENT_CECRX | E_HdcpTX_EVENT_RUN | E_HdcpTX_EVENT_IRQ | E_HdcpTX_EVENT_RITIMER, &u32Events, E_OR_CLEAR, 5000);
5537
5538 if (1)
5539 {
5540 #endif
5541 _HDMITX_SEMAPHORE_ENTRY(pInstance);
5542 _HDMITX_GET_VARIABLE();
5543
5544 HDMITx_Handler(pInstance, u32Events);
5545
5546 if ( (u32Events & E_HdcpTX_EVENT_RUN) | (u32Events & E_HdcpTX_EVENT_IRQ) | (u32Events & E_HdcpTX_EVENT_RITIMER))
5547 {
5548 if (MDrv_HDCPTx_GetAuthStartFlag(pInstance) == TRUE)
5549 {
5550 HDCPTx_Handler(pInstance, u32Events);
5551 }
5552 }
5553
5554 #if HDMITX_ISR_ENABLE
5555 }
5556 else
5557 {
5558 DBG_HDMITX(printf("%s: obtain mutex failed.\n", __FUNCTION__));
5559 }
5560
5561 // Even if not E_DMD_EVENT_ENABLE, the interrupt should be enable.
5562 MsOS_EnableInterrupt(E_INT_IRQ_HDMI_LEVEL);
5563 #endif
5564
5565 _HDMITX_SEMAPHORE_RETURN(pInstance);
5566
5567 MsOS_DelayTask(HDMITX_MONITOR_DELAY);
5568 } // Task loop
5569 }
5570
5571 //-------------------------------------------------------------------------------------------------
5572 // Global Functions
5573 //-------------------------------------------------------------------------------------------------
5574 // HDMI Tx output is DVI / HDMI mode
5575 //------------------------------------------------------------------------------
5576 /// @return None
5577 //------------------------------------------------------------------------------
MDrv_HDMITx_InitSeq(void * pInstance)5578 void MDrv_HDMITx_InitSeq(void* pInstance)
5579 {
5580 MHal_HDMITx_SetChipVersion((MDrv_SYS_GetChipRev() >= 0x01) ? (MS_U8)0x01 : (MS_U8)0x00); // U01: 0x00; U02: 0x01
5581 MHal_HDMITx_InitSeq();
5582 MDrv_HDMITx_InitVariable(pInstance);
5583 }
5584
5585 //------------------------------------------------------------------------------
5586 /// @brief This routine initializes HDMI Tx module
5587 /// @return None
5588 /// HDMI driver is in @ref E_TASK_PRI_HIGH level
5589 //------------------------------------------------------------------------------
MDrv_HDMITx_Init(void * pInstance)5590 MS_BOOL MDrv_HDMITx_Init(void *pInstance)//MS_BOOL MDrv_HDMITx_Init(void)
5591 {
5592 //MS_VIRT u32PMRIUBaseAddress = 0;
5593 //MS_PHY u32PMBankSize = 0;
5594
5595 _HDMITX_GET_VARIABLE();
5596
5597 _hdmitx_status.bIsInitialized = TRUE;
5598 _hdmitx_status.bIsRunning = TRUE;
5599
5600 DBG_HDMITX(printf("%s\n", __FUNCTION__));
5601
5602 if (!MDrv_MMIO_GetBASE(&psHDMITXResPri->stHDMITxInfo.u32PMRIUBaseAddress, &psHDMITXResPri->stHDMITxInfo.u32PMBankSize, MS_MODULE_PM ))
5603 {
5604 printf("MApi_XC_Init Get PM BASE failure\n");
5605 return FALSE;
5606 }
5607
5608 #if (defined(MSOS_TYPE_LINUX_KERNEL))
5609 {
5610 //MS_VIRT u32CoproRIUBase = 0x00;
5611 if( !MDrv_MMIO_GetBASE( &psHDMITXResPri->stHDMITxInfo.u32CoproRIUBase, &psHDMITXResPri->stHDMITxInfo.u32PMBankSize, MS_MODULE_HW))
5612 {
5613 printf("_COPRO_Init: IOMap failure\n");
5614 }
5615 else
5616 {
5617 MHal_HDMITx_SetIOMapBase(psHDMITXResPri->stHDMITxInfo.u32PMRIUBaseAddress, psHDMITXResPri->stHDMITxInfo.u32PMRIUBaseAddress, psHDMITXResPri->stHDMITxInfo.u32CoproRIUBase);
5618 }
5619 }
5620 #else
5621 DBG_HDMITX(printf("Get IOMAP ID:%u Base:%x!\n", MS_MODULE_PM, psHDMITXResPri->stHDMITxInfo.u32PMRIUBaseAddress));
5622 MHal_HDMITx_SetIOMapBase(psHDMITXResPri->stHDMITxInfo.u32PMRIUBaseAddress, psHDMITXResPri->stHDMITxInfo.u32PMRIUBaseAddress);
5623 #endif
5624
5625 MDrv_HDMITx_Power_OnOff(TRUE);
5626
5627 if (psHDMITXResPri->bInit == TRUE)
5628 return TRUE;
5629
5630 if (psHDMITXResPri->stHDMITxInfo.bHDMITxTaskIdCreated) //if (_s32HDMITxTaskId >= 0)
5631 {
5632 DBG_HDMITX(printf("MDrv_HDMITx_Init: already initialized.\n"));
5633 return TRUE;
5634 }
5635
5636 #if HDMITX_ISR_ENABLE
5637 MsOS_DisableInterrupt(E_INT_IRQ_HDMI_LEVEL);
5638 MsOS_DetachInterrupt(E_INT_IRQ_HDMI_LEVEL);
5639
5640 MHal_HDMITx_Int_Disable(gHDMITXIRQ);
5641 MHal_HDMITx_Int_Clear(gHDMITXIRQ);
5642
5643 if(psHDMITXResPri->stHDMITxInfo.hdmitx_CECEnable_flag)
5644 {
5645 #if 0 //ENABLE_CEC_INT
5646 MsOS_DisableInterrupt(E_INT_IRQ_CEC);
5647 MsOS_DetachInterrupt(E_INT_IRQ_CEC);
5648 #endif
5649 }
5650
5651 #endif // #if HDMITX_ISR_ENABLE
5652
5653 MDrv_HDMITx_InitSeq(pInstance);
5654
5655 if (psHDMITXResPri->stHDMITxInfo.bHDMITxEventIdCreated == FALSE)
5656 {
5657 _s32HDMITxEventId = MsOS_CreateEventGroup("HDMITx_Event");
5658 psHDMITXResPri->stHDMITxInfo.bHDMITxEventIdCreated = TRUE;
5659 }
5660
5661 if (_s32HDMITxEventId < 0)
5662 {
5663 ///MsOS_DeleteMutex(_s32HDMITxMutexId);
5664 psHDMITXResPri->stHDMITxInfo.bHDMITxEventIdCreated = FALSE;
5665 return FALSE;
5666 }
5667
5668 _pHDMITxTaskStack = _u8HDMITx_StackBuffer;
5669 g_bHDMITxTask = TRUE;
5670
5671 _HDMITX_SEMAPHORE_RETURN(pInstance);
5672 _s32HDMITxTaskId = MsOS_CreateTask((TaskEntry)_HDMITx_Task,
5673 (MS_VIRT)pInstance,//(MS_U32)pInstance,
5674 E_TASK_PRI_HIGH,
5675 TRUE,
5676 _pHDMITxTaskStack,
5677 HDMITX_TASK_STACK_SIZE,
5678 "HDMITx_Task");
5679 _HDMITX_SEMAPHORE_ENTRY(pInstance);
5680
5681 psHDMITXResPri->stHDMITxInfo.bHDMITxTaskIdCreated = TRUE;
5682
5683 if (_s32HDMITxTaskId < 0)
5684 {
5685 printf("create hdmi task failed\r\n");
5686 MsOS_DeleteEventGroup(_s32HDMITxEventId);
5687 ///MsOS_DeleteMutex(_s32HDMITxMutexId);
5688 psHDMITXResPri->stHDMITxInfo.bHDMITxTaskIdCreated = FALSE;
5689 return FALSE;
5690 }
5691
5692 #if HDMITX_ISR_ENABLE
5693 MsOS_AttachInterrupt(E_INT_IRQ_HDMI_LEVEL, _HDMITx_Isr);
5694 MsOS_EnableInterrupt(E_INT_IRQ_HDMI_LEVEL); // Enable TSP interrupt
5695 //MDrv_HDMITx_Int_Enable();
5696
5697 if (psHDMITXResPri->stHDMITxInfo.hdmitx_CECEnable_flag)
5698 {
5699 }
5700 #endif // #if HDMITX_ISR_ENABLE
5701
5702 return TRUE;
5703 }
5704
5705 //------------------------------------------------------------------------------
5706 /// @brief This routine initializes HDMI + HDCP Tx module
5707 /// @return None
5708 /// HDMI, HDCP driver is in @ref E_TASK_PRI_HIGH level
5709 //------------------------------------------------------------------------------
MDrv_HDMITxHDCPTx_Init(void * pInstance)5710 MS_BOOL MDrv_HDMITxHDCPTx_Init(void* pInstance) //wilson@kano
5711 {
5712 printf("start hdmi, hdcp init\r\n");
5713 if (MDrv_HDMITx_Init(pInstance) == TRUE)
5714 {
5715 printf("hdmitx init done\r\n");
5716
5717 if (MDrv_HDCPTx_Init(pInstance) == TRUE)
5718 {
5719 printf("hdcptx init done\r\n");
5720 return TRUE;
5721 }
5722 else
5723 {
5724 printf("hdcptx init fail\r\n");
5725 return FALSE;
5726 }
5727 }
5728 else
5729 {
5730 printf("hdmitx init fail\r\n");
5731 return FALSE;
5732 }
5733 }
5734
5735 //------------------------------------------------------------------------------
5736 /// @brief to speed up the process of resume from power saving mode
5737 /// @return power state
5738 //------------------------------------------------------------------------------
MDrv_HDMITx_SetPowerState(void * pInstance,EN_POWER_MODE u16PowerState)5739 MS_U32 MDrv_HDMITx_SetPowerState(void* pInstance, EN_POWER_MODE u16PowerState)
5740 {
5741 static EN_POWER_MODE _prev_u16PowerState = E_POWER_MECHANICAL;
5742 MS_U32 u32Return = 1;
5743 static MDrvHDMITX_PARAMETER_LIST preHDMITxInfo;
5744
5745 _HDMITX_GET_VARIABLE();
5746
5747 if ((psHDMITXResPri->stHDMITxInfo.bHDMITxTaskIdCreated == FALSE) ||
5748 (psHDMITXResPri->stHDMITxInfo.bHDMITxEventIdCreated == FALSE) ||
5749 (psHDMITXResPri->stHDMITxInfo.bCheckRxTimerIdCreated == FALSE))
5750 {
5751 printf("[%s,%5d] HDMI TX is not initialized!!\r\n", __FUNCTION__, __LINE__);
5752 return u32Return;
5753 }
5754
5755 if (u16PowerState == E_POWER_SUSPEND)
5756 {
5757 _prev_u16PowerState = u16PowerState;
5758 //store previous state
5759 memcpy(&preHDMITxInfo, &psHDMITXResPri->stHDMITxInfo, sizeof(psHDMITXResPri->stHDMITxInfo));
5760
5761
5762 #if HDMITX_ISR_ENABLE
5763 MsOS_DisableInterrupt(E_INT_IRQ_HDMI_LEVEL);
5764 MsOS_DetachInterrupt(E_INT_IRQ_HDMI_LEVEL);
5765
5766 MHal_HDMITx_Int_Disable(gHDMITXIRQ);
5767 MHal_HDMITx_Int_Clear(gHDMITXIRQ);
5768
5769 if(psHDMITXResPri->stHDMITxInfo.hdmitx_CECEnable_flag)
5770 {
5771 #if 0 //ENABLE_CEC_INT
5772 MsOS_DisableInterrupt(E_INT_IRQ_CEC);
5773 MsOS_DetachInterrupt(E_INT_IRQ_CEC);
5774 #endif
5775 }
5776 #endif // #if HDMITX_ISR_ENABLE
5777
5778 MDrv_HDMITx_Power_OnOff(FALSE);
5779 u32Return = 0;// UTOPIA_STATUS_SUCCESS;//SUSPEND_OK;
5780 }
5781 else if (u16PowerState == E_POWER_RESUME)
5782 {
5783
5784 if (_prev_u16PowerState == E_POWER_SUSPEND)
5785 {
5786 //store back tx info
5787 MDrv_HDMITx_Power_OnOff(TRUE);
5788 MDrv_HDMITx_InitSeq(pInstance);
5789 MDrv_HDCPTx_InitVariable(pInstance);
5790
5791 #if HDMITX_ISR_ENABLE
5792 MsOS_AttachInterrupt(E_INT_IRQ_HDMI_LEVEL, _HDMITx_Isr);
5793 MsOS_EnableInterrupt(E_INT_IRQ_HDMI_LEVEL); // Enable TSP interrupt
5794 //MDrv_HDMITx_Int_Enable();
5795
5796 if (psHDMITXResPri->stHDMITxInfo.hdmitx_CECEnable_flag)
5797 {
5798 #if 0 //ENABLE_CEC_INT
5799 DBG_HDMITX(printf("\nEnable CEC INT!!\r\n"));
5800 MsOS_AttachInterrupt(E_INT_IRQ_CEC, _HDMITX_CEC_RxIsr);
5801 MsOS_EnableInterrupt(E_INT_IRQ_CEC);
5802 #endif
5803 }
5804 #endif // #if HDMITX_ISR_ENABLE
5805
5806 memcpy(&psHDMITXResPri->stHDMITxInfo, &preHDMITxInfo, sizeof(psHDMITXResPri->stHDMITxInfo));
5807
5808 MDrv_HDCPTx_SetAuthStartFlag(pInstance, FALSE);
5809 MDrv_HDCPTx_SetAuthDoneFlag(pInstance, FALSE);
5810 MDrv_HDMITx_TurnOnOff(pInstance, psHDMITXResPri->stHDMITxInfo.hdmitx_enable_flag);
5811 MDrv_HDMITx_SetColorFormat(pInstance, psHDMITXResPri->stHDMITxInfo.input_color, psHDMITXResPri->stHDMITxInfo.output_color);
5812 MDrv_HDMITx_SetVideoOnOff(pInstance, psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag);
5813 MDrv_HDMITx_SetHDMITxMode(pInstance, psHDMITXResPri->stHDMITxInfo.output_mode);
5814 MDrv_HDMITx_SetVideoOutputMode(pInstance, psHDMITXResPri->stHDMITxInfo.output_video_timing);
5815 MDrv_HDMITx_SetAudioFrequency(pInstance, psHDMITXResPri->stHDMITxInfo.output_audio_frequncy);
5816 MDrv_HDMITx_SetAudioOnOff(pInstance, psHDMITXResPri->stHDMITxInfo.hdmitx_audio_flag);
5817 MDrv_HDMITx_Exhibit(pInstance);
5818
5819 _prev_u16PowerState = u16PowerState;
5820 u32Return = 0;//UTOPIA_STATUS_SUCCESS;//RESUME_OK;
5821 }
5822 else
5823 {
5824 u32Return = 1;//UTOPIA_STATUS_FAIL;//SUSPEND_FAILED;
5825 }
5826 }
5827 else
5828 {
5829 u32Return = 1;//UTOPIA_STATUS_FAIL;
5830 }
5831
5832 return u32Return;// for success
5833 }
5834
5835 //------------------------------------------------------------------------------
5836 /// @brief to speed up the process of resume from power saving mode
5837 /// @return power state
5838 //------------------------------------------------------------------------------
MDrv_HDMITx_SSC_Enable(void * pInstance,MS_U8 ubSSCEn)5839 MS_BOOL MDrv_HDMITx_SSC_Enable(void* pInstance, MS_U8 ubSSCEn)
5840 {
5841 pInstance = pInstance;
5842 _HDMITX_GET_VARIABLE();
5843 psHDMITXResPri->stHDMITxInfo.ubSSCEn = ubSSCEn;
5844
5845 return psHDMITXResPri->stHDMITxInfo.ubSSCEn;
5846 }
5847
5848 //------------------------------------------------------------------------------
5849 /// @brief Check legitimacy of user setting of timing
5850 /// @return error code
5851 //------------------------------------------------------------------------------
MDrv_HDMITx_CheckLegalTiming(void * pInstance,MsHDMITX_OUTPUT_MODE eOutputMode,MsHDMITX_VIDEO_TIMING idx,MsHDMITX_VIDEO_COLOR_FORMAT incolor_fmt,MsHDMITX_VIDEO_COLOR_FORMAT outcolor_fmt,MsHDMITX_VIDEO_COLORDEPTH_VAL color_depth)5852 MsHDMITX_TIMING_ERROR MDrv_HDMITx_CheckLegalTiming(void* pInstance, MsHDMITX_OUTPUT_MODE eOutputMode, MsHDMITX_VIDEO_TIMING idx, MsHDMITX_VIDEO_COLOR_FORMAT incolor_fmt, MsHDMITX_VIDEO_COLOR_FORMAT outcolor_fmt, MsHDMITX_VIDEO_COLORDEPTH_VAL color_depth)
5853 {
5854 MS_U32 uiPxlClk = 0;
5855 MsHDMITX_AVI_VIC eVIC = E_HDMITX_VIC_NOT_AVAILABLE;
5856 MsHDMITX_TIMING_ERROR err = E_HDMITX_TIMING_ERR_NONE;
5857
5858 pInstance = pInstance;
5859 _HDMITX_GET_VARIABLE();
5860
5861 if(psHDMITXResPri->stHDMITxInfo.hdmitx_bypass_flag)
5862 {
5863 //return E_HDMITX_TIMING_ERR_CFG_ERR;
5864 DBG_HDMITX(printf("bypass mode\r\n"));
5865 err |= E_HDMITX_TIMING_ERR_CFG_ERR;
5866 }
5867
5868 if(MHal_HDMITx_GetRXStatus() != E_HDMITX_DVIClock_H_HPD_H)
5869 {
5870 //return E_HDMITX_TIMING_ERR_CFG_ERR;
5871 DBG_HDMITX(printf("RXstatus Low\r\n"));
5872 err |= E_HDMITX_TIMING_ERR_CFG_ERR;
5873 }
5874
5875 if(bCheckEDID)
5876 {
5877 //if(!MDrv_HDMITx_EdidChecking(pInstance))
5878 {
5879 //return E_HDMITX_TIMING_ERR_EDID_ERR;
5880 DBG_HDMITX(printf("EDID falied\r\n"));
5881 err |= E_HDMITX_TIMING_ERR_EDID_ERR;
5882 }
5883 }
5884
5885 if(!psHDMITXResPri->stHDMITxInfo.RxEdidInfo.SupportHdmi)
5886 {
5887 if( (eOutputMode == E_HDMITX_HDMI) || (eOutputMode == E_HDMITX_HDMI_HDCP) )
5888 {
5889 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
5890 }
5891 }
5892
5893 uiPxlClk = MHal_HDMITx_GetPixelClk_ByTiming(idx, outcolor_fmt, color_depth);
5894 eVIC = _MDrv_HDMIRx_MapVideoTimingToVIC(idx);
5895
5896 err |= MDrv_HDMITx_CheckEDIDTiming(pInstance,eVIC, uiPxlClk, incolor_fmt, outcolor_fmt, color_depth);
5897 err |= MDrv_HDMITx_CheckEDIDColorFormat(pInstance, idx, eVIC, incolor_fmt, outcolor_fmt, color_depth);
5898 err |= MDrv_HDMITx_CheckEDIDColorDepth(pInstance, outcolor_fmt, color_depth);
5899
5900 return err;
5901 }
5902
MDrv_HDMITx_CheckEDIDTiming(void * pInstance,MsHDMITX_AVI_VIC eVIC,MS_U32 uiPxlClk,MsHDMITX_VIDEO_COLOR_FORMAT incolor_fmt,MsHDMITX_VIDEO_COLOR_FORMAT outcolor_fmt,MsHDMITX_VIDEO_COLORDEPTH_VAL color_depth)5903 MsHDMITX_TIMING_ERROR MDrv_HDMITx_CheckEDIDTiming(void* pInstance, MsHDMITX_AVI_VIC eVIC, MS_U32 uiPxlClk, MsHDMITX_VIDEO_COLOR_FORMAT incolor_fmt, MsHDMITX_VIDEO_COLOR_FORMAT outcolor_fmt, MsHDMITX_VIDEO_COLORDEPTH_VAL color_depth)
5904 {
5905 MS_U8 i = 0;
5906 MS_U8 ubGot = 0;
5907 MsHDMITX_TIMING_ERROR err = E_HDMITX_TIMING_ERR_NONE;
5908
5909 _HDMITX_GET_VARIABLE();
5910
5911 // Check timing
5912 {
5913 //Check HW Limitation
5914 if(uiPxlClk > MHal_HDMITx_GetMaxPixelClk())
5915 {
5916 err |= E_HDMITX_TIMING_ERR_TIMING;
5917 err |= E_HDMITX_TIMING_ERR_HW_LIMIT;
5918 DBG_HDMITX(printf("Pixel clock too high\r\n"));
5919 }
5920
5921 //Check EDID capability
5922 {
5923 //Check VIC
5924 {
5925 for(i = 0; i < psHDMITXResPri->stHDMITxInfo.RxEdidInfo.CEADataBlkLen[CEATag_VideoBlk]; i++)
5926 {
5927 if(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk[i] < 128)
5928 {
5929 if( (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk[i] & 0x7F) == eVIC) //7bits VIC
5930 {
5931 ubGot = 1;
5932 break;
5933 }
5934 }
5935 else if( (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk[i] > 128) && (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk[i] <= 192) )
5936 {
5937 if( (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk[i] & 0x7F) == eVIC) //7bits VIC
5938 {
5939 ubGot = 1;
5940 break;
5941 }
5942 }
5943 else
5944 {
5945 switch(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk[i])
5946 {
5947 case 0:
5948 case 128:
5949 case 254:
5950 case 255:
5951 break;
5952
5953 default:
5954 {
5955 if( (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk[i] & 0xFF) == eVIC) //8bits VIC
5956 {
5957 ubGot = 1;
5958 break;
5959 }
5960 }
5961 break;
5962 }
5963 }
5964 }
5965
5966 //Check VIC in 420 VideoDataBlock
5967 if(!ubGot)
5968 {
5969 if(outcolor_fmt == E_HDMITX_VIDEO_COLOR_YUV420)
5970 {
5971 for ( i = 0; i < 32; i++ )
5972 {
5973 if (eVIC == psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420VidDataBlk[i])
5974 {
5975 ubGot = 1;
5976 break;
5977 }
5978 }
5979 }
5980 }
5981
5982 if(!ubGot)
5983 {
5984 if(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICLen == 0)
5985 {
5986 err |= E_HDMITX_TIMING_ERR_TIMING;
5987 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
5988 DBG_HDMITX(printf("No 4K VIC\r\n"));
5989 }
5990 else
5991 {
5992 //Check HDMI_VIC
5993 switch(eVIC)
5994 {
5995 case E_HDMITX_VIC_3840x2160p_24_16_9:
5996 case E_HDMITX_VIC_3840x2160p_24_64_27:
5997 {
5998 for(i = 0; i < psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICLen; i++)
5999 {
6000 if(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICList[i] == 1)
6001 {
6002 ubGot = 1;
6003 break;
6004 }
6005 }
6006 }
6007 break;
6008
6009 case E_HDMITX_VIC_3840x2160p_25_16_9:
6010 case E_HDMITX_VIC_3840x2160p_25_64_27:
6011 {
6012 for(i = 0; i < psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICLen; i++)
6013 {
6014 if(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICList[i] == 2)
6015 {
6016 ubGot = 1;
6017 break;
6018 }
6019 }
6020 }
6021 break;
6022
6023 case E_HDMITX_VIC_3840x2160p_30_16_9:
6024 case E_HDMITX_VIC_3840x2160p_30_64_27:
6025 {
6026 for(i = 0; i < psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICLen; i++)
6027 {
6028 if(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICList[i] == 3)
6029 {
6030 ubGot = 1;
6031 break;
6032 }
6033 }
6034 }
6035 break;
6036
6037 case E_HDMITX_VIC_4096x2160p_24_256_135:
6038 {
6039 for(i = 0; i < psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICLen; i++)
6040 {
6041 if(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HdmiVICList[i] == 4)
6042 {
6043 ubGot = 1;
6044 break;
6045 }
6046 }
6047 }
6048 break;
6049
6050 default:
6051 {
6052 ubGot = 0;
6053 }
6054 break;
6055 }
6056
6057 if(!ubGot)
6058 {
6059 err |= E_HDMITX_TIMING_ERR_TIMING;
6060 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6061 DBG_HDMITX(printf("Timing not supported\r\n"));
6062 }
6063 }
6064 }
6065 }
6066
6067 //Check VSDB and HFVSDB
6068 {
6069 if(psHDMITXResPri->stHDMITxInfo.RxEdidInfo.MaxTmdsCharRate != 0)
6070 {
6071 if(uiPxlClk > psHDMITXResPri->stHDMITxInfo.RxEdidInfo.MaxTmdsCharRate * 5 *1000)
6072 {
6073 err |= E_HDMITX_TIMING_ERR_TIMING;
6074 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6075 DBG_HDMITX(printf("Clock hihger than sink\r\n"));
6076 }
6077 }
6078 }
6079
6080 //Check SW LIMMIT
6081 {
6082 //Check 6.6G
6083 }
6084
6085 //Check BT2020 for 4K/8K
6086 {
6087
6088 }
6089 }
6090 }
6091
6092 return err;
6093 }
6094
MDrv_HDMITx_CheckEDIDColorFormat(void * pInstance,MsHDMITX_VIDEO_TIMING idx,MsHDMITX_AVI_VIC eVIC,MsHDMITX_VIDEO_COLOR_FORMAT incolor_fmt,MsHDMITX_VIDEO_COLOR_FORMAT outcolor_fmt,MsHDMITX_VIDEO_COLORDEPTH_VAL color_depth)6095 MsHDMITX_TIMING_ERROR MDrv_HDMITx_CheckEDIDColorFormat(void* pInstance, MsHDMITX_VIDEO_TIMING idx, MsHDMITX_AVI_VIC eVIC, MsHDMITX_VIDEO_COLOR_FORMAT incolor_fmt, MsHDMITX_VIDEO_COLOR_FORMAT outcolor_fmt, MsHDMITX_VIDEO_COLORDEPTH_VAL color_depth)
6096 {
6097 MS_U8 i = 0;
6098 MS_U8 ub420Supported = 0;
6099 MsHDMITX_TIMING_ERROR err = E_HDMITX_TIMING_ERR_NONE;
6100
6101 pInstance = pInstance;
6102 _HDMITX_GET_VARIABLE();
6103
6104 //Check color format
6105 {
6106 //Check R2Y supported
6107 if(!MHal_HDMITx_CSC_Support_R2Y(pInstance))
6108 {
6109 if( (incolor_fmt == E_HDMITX_VIDEO_COLOR_RGB444) && (outcolor_fmt != E_HDMITX_VIDEO_COLOR_RGB444) )
6110 {
6111 err |= E_HDMITX_TIMING_ERR_COLOR_FMT;
6112 err |= E_HDMITX_TIMING_ERR_HW_LIMIT;
6113 DBG_HDMITX(printf("HW not supporting R2Y\r\n"));
6114 }
6115 }
6116
6117 //Check EDID
6118 if(outcolor_fmt != E_HDMITX_VIDEO_COLOR_YUV420)
6119 {
6120 switch (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk1[0x03] & 0x30)
6121 {
6122 case 0x00: //RGB
6123 {
6124 if(outcolor_fmt != E_HDMITX_VIDEO_COLOR_RGB444)
6125 {
6126 err |= E_HDMITX_TIMING_ERR_COLOR_FMT;
6127 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6128 DBG_HDMITX(printf("Sink RGB only\r\n"));
6129 }
6130 }
6131 break;
6132
6133 case 0x10: //422
6134 {
6135 if(outcolor_fmt == E_HDMITX_VIDEO_COLOR_YUV444)
6136 {
6137 err |= E_HDMITX_TIMING_ERR_COLOR_FMT;
6138 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6139 DBG_HDMITX(printf("Sink 422 only\r\n"));
6140 }
6141 }
6142 break;
6143
6144 case 0x20: //444
6145 {
6146 if(outcolor_fmt == E_HDMITX_VIDEO_COLOR_YUV422)
6147 {
6148 err |= E_HDMITX_TIMING_ERR_COLOR_FMT;
6149 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6150 DBG_HDMITX(printf("Sink 444 only\r\n"));
6151 }
6152 }
6153 break;
6154
6155 case 0x30:
6156 {
6157 //RGB YUV444 YUV422 OK
6158 }
6159 break;
6160
6161 default:
6162 {
6163 }
6164 break;
6165 }
6166
6167 for ( i = 0; i < 32; i++ )
6168 {
6169 if (eVIC == psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420VidDataBlk[i])
6170 {
6171 if(outcolor_fmt != E_HDMITX_VIDEO_COLOR_YUV420)
6172 {
6173 err |= E_HDMITX_TIMING_ERR_COLOR_FMT;
6174 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6175 DBG_HDMITX(printf("Sink 420 only 1\r\n"));
6176 }
6177 else
6178 {
6179 ub420Supported = 1;
6180 }
6181
6182 break;
6183 }
6184 }
6185 }
6186 else if(outcolor_fmt == E_HDMITX_VIDEO_COLOR_YUV420)
6187 {
6188 //420 checking
6189 for ( i = 0; i < 32; i++ )
6190 {
6191 if (eVIC == psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420VidDataBlk[i])
6192 {
6193 if(outcolor_fmt != E_HDMITX_VIDEO_COLOR_YUV420)
6194 {
6195 err |= E_HDMITX_TIMING_ERR_COLOR_FMT;
6196 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6197 DBG_HDMITX(printf("Sink 420 only 2\r\n"));
6198 }
6199 else
6200 {
6201 ub420Supported = 1;
6202 }
6203
6204 break;
6205 }
6206 }
6207
6208 if( (outcolor_fmt == E_HDMITX_VIDEO_COLOR_YUV420) && (!ub420Supported) )
6209 {
6210 for ( i = 0; i < psHDMITXResPri->stHDMITxInfo.RxEdidInfo.CEADataBlkLen[CEATag_VideoBlk]; i++ )
6211 {
6212 if (eVIC == psHDMITXResPri->stHDMITxInfo.RxEdidInfo.VideoDataBlk[i])
6213 {
6214 if (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YCbCr420CapMapDataBlk[i >> 3] & (0x01 << (i % 8)))
6215 {
6216 ub420Supported = 1;
6217 }
6218
6219 break;
6220 }
6221 }
6222
6223 if(!ub420Supported)
6224 {
6225 err |= E_HDMITX_TIMING_ERR_COLOR_FMT;
6226 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6227 DBG_HDMITX(printf("420 not supported\r\n"));
6228 }
6229 }
6230
6231 #if 0
6232 switch(idx)
6233 {
6234 case E_HDMITX_RES_3840x2160p_24Hz:
6235 case E_HDMITX_RES_3840x2160p_25Hz:
6236 case E_HDMITX_RES_3840x2160p_30Hz:
6237 case E_HDMITX_RES_3840x2160p_50Hz:
6238 case E_HDMITX_RES_3840x2160p_60Hz:
6239 case E_HDMITX_RES_4096x2160p_24Hz:
6240 case E_HDMITX_RES_4096x2160p_25Hz:
6241 case E_HDMITX_RES_4096x2160p_30Hz:
6242 case E_HDMITX_RES_4096x2160p_50Hz:
6243 case E_HDMITX_RES_4096x2160p_60Hz:
6244
6245 break;
6246 default:
6247 {
6248 err |= E_HDMITX_TIMING_ERR_COLOR_FMT;
6249 err |= E_HDMITX_TIMING_ERR_SW_LIMIT;
6250 }
6251 break;
6252 }
6253 #else
6254 #endif
6255 }
6256 }
6257
6258 return err;
6259 }
6260
MDrv_HDMITx_CheckEDIDColorDepth(void * pInstance,MsHDMITX_VIDEO_COLOR_FORMAT outcolor_fmt,MsHDMITX_VIDEO_COLORDEPTH_VAL color_depth)6261 MsHDMITX_TIMING_ERROR MDrv_HDMITx_CheckEDIDColorDepth(void* pInstance, MsHDMITX_VIDEO_COLOR_FORMAT outcolor_fmt, MsHDMITX_VIDEO_COLORDEPTH_VAL color_depth)
6262 {
6263 MS_U8 ubCDSupported = 0;
6264 MsHDMITX_TIMING_ERROR err = E_HDMITX_TIMING_ERR_NONE;
6265
6266 _HDMITX_GET_VARIABLE();
6267
6268 //Color Depth
6269 {
6270 if( (outcolor_fmt == E_HDMITX_VIDEO_COLOR_YUV422) && (color_depth != E_HDMITX_VIDEO_CD_NoID) )
6271 {
6272 err |= E_HDMITX_TIMING_ERR_COLOR_DEPTH;
6273 DBG_HDMITX(printf("422 wrong color depth\r\n"));
6274 }
6275
6276 if( (color_depth != E_HDMITX_VIDEO_CD_NoID) && (color_depth != E_HDMITX_VIDEO_CD_24Bits) )
6277 {
6278 ubCDSupported = psHDMITXResPri->stHDMITxInfo.RxEdidInfo.HDMI_VSDB[5] & 0x78;
6279
6280 if(outcolor_fmt == E_HDMITX_VIDEO_COLOR_YUV444)
6281 {
6282 if( (ubCDSupported & 0x08) == 0)
6283 {
6284 err |= E_HDMITX_TIMING_ERR_COLOR_DEPTH;
6285 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6286 DBG_HDMITX(printf("YUV no color depth\r\n"));
6287 }
6288
6289 if(color_depth == E_HDMITX_VIDEO_CD_48Bits)
6290 {
6291 if( (ubCDSupported & 0x40) == 0)
6292 {
6293 err |= E_HDMITX_TIMING_ERR_COLOR_DEPTH;
6294 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6295 DBG_HDMITX(printf("YUV no 16bits\r\n"));
6296 }
6297 }
6298
6299 if(color_depth == E_HDMITX_VIDEO_CD_36Bits)
6300 {
6301 if( (ubCDSupported & 0x20) == 0)
6302 {
6303 err |= E_HDMITX_TIMING_ERR_COLOR_DEPTH;
6304 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6305 DBG_HDMITX(printf("YUV no 12bits\r\n"));
6306 }
6307 }
6308
6309 if(color_depth == E_HDMITX_VIDEO_CD_30Bits)
6310 {
6311 if( (ubCDSupported & 0x10) == 0)
6312 {
6313 err |= E_HDMITX_TIMING_ERR_COLOR_DEPTH;
6314 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6315 DBG_HDMITX(printf("YUV no 10bits\r\n"));
6316 }
6317 }
6318 }
6319 else if(outcolor_fmt == E_HDMITX_VIDEO_COLOR_RGB444)
6320 {
6321 if(color_depth == E_HDMITX_VIDEO_CD_48Bits)
6322 {
6323 if( (ubCDSupported & 0x40) == 0)
6324 {
6325 err |= E_HDMITX_TIMING_ERR_COLOR_DEPTH;
6326 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6327 DBG_HDMITX(printf("RGB no 16bits\r\n"));
6328 }
6329 }
6330
6331 if(color_depth == E_HDMITX_VIDEO_CD_36Bits)
6332 {
6333 if( (ubCDSupported & 0x20) == 0)
6334 {
6335 err |= E_HDMITX_TIMING_ERR_COLOR_DEPTH;
6336 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6337 DBG_HDMITX(printf("RGB no 12bits\r\n"));
6338 }
6339 }
6340
6341 if(color_depth == E_HDMITX_VIDEO_CD_30Bits)
6342 {
6343 if( (ubCDSupported & 0x10) == 0)
6344 {
6345 err |= E_HDMITX_TIMING_ERR_COLOR_DEPTH;
6346 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6347 DBG_HDMITX(printf("RGB no 10bits\r\n"));
6348 }
6349 }
6350 }
6351 else if(outcolor_fmt == E_HDMITX_VIDEO_COLOR_YUV420)
6352 {
6353 if(color_depth == E_HDMITX_VIDEO_CD_48Bits)
6354 {
6355 if( (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YUV420DeepColorInfo & 0x04) == 0)
6356 {
6357 err |= E_HDMITX_TIMING_ERR_COLOR_DEPTH;
6358 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6359 DBG_HDMITX(printf("420 no 16bits\r\n"));
6360 }
6361 }
6362
6363 if(color_depth == E_HDMITX_VIDEO_CD_36Bits)
6364 {
6365 if( (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YUV420DeepColorInfo & 0x02) == 0)
6366 {
6367 err |= E_HDMITX_TIMING_ERR_COLOR_DEPTH;
6368 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6369 DBG_HDMITX(printf("420 no 12bits\r\n"));
6370 }
6371 }
6372
6373 if(color_depth == E_HDMITX_VIDEO_CD_30Bits)
6374 {
6375 if( (psHDMITXResPri->stHDMITxInfo.RxEdidInfo.YUV420DeepColorInfo & 0x01) == 0)
6376 {
6377 err |= E_HDMITX_TIMING_ERR_COLOR_DEPTH;
6378 err |= E_HDMITX_TIMING_ERR_SINK_LIMIT;
6379 DBG_HDMITX(printf("420 no 10bits\r\n"));
6380 }
6381 }
6382 }
6383 }
6384 }
6385
6386 return err;
6387 }
6388
6389 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
6390 //**************************************************************************
6391 // [Function Name]:
6392 // mdrv_mhl_MDCMDEchoCommand()
6393 // [Description]
6394 // MHL MDCMD echo command function
6395 // [Arguments]:
6396 //
6397 // [Return]:
6398 //
6399 //**************************************************************************
MDrv_HDMITx_MDCMDEchoCommand(void * pInstance,MS_U64 * u64ReqHdl,char * pcCmdLine)6400 void MDrv_HDMITx_MDCMDEchoCommand(void* pInstance, MS_U64* u64ReqHdl, char* pcCmdLine)
6401 {
6402 char pch[] = "=,";
6403 char* psep;
6404
6405 MdbPrint(u64ReqHdl, "LINE:%d, MDBCMD_CMDLINE\n", __LINE__);
6406 MdbPrint(u64ReqHdl, "pcCmdLine: %s\n", pcCmdLine);
6407
6408 psep = strsep(&pcCmdLine, pch);
6409
6410 if(strncmp("HDMITXOn", psep, 8) == 0)
6411 {
6412
6413 }
6414 }
6415
6416 //**************************************************************************
6417 // [Function Name]:
6418 // mdrv_mhl_MDCMDGetInfo()
6419 // [Description]
6420 // MHL MDCMD get info function
6421 // [Arguments]:
6422 //
6423 // [Return]:
6424 //
6425 //**************************************************************************
MDrv_HDMITx_MDCMDGetInfo(void * pInstance,MS_U64 * u64ReqHdl)6426 void MDrv_HDMITx_MDCMDGetInfo(void* pInstance, MS_U64* u64ReqHdl)
6427 {
6428 int i = 0;
6429 _HDMITX_GET_VARIABLE();
6430
6431 {
6432 MdbPrint(u64ReqHdl, "LINE:%d, MDBCMD_GETINFO\n", __LINE__);
6433 MdbPrint(u64ReqHdl, "---------------- Mstar HDMITx Info -----------------\n");
6434 //Basic Status
6435 MdbPrint(u64ReqHdl, "HDMITx Dis_TMDSCtrl=%d\n", g_bDisableTMDSCtrl );
6436 MdbPrint(u64ReqHdl, "HDMITx Dis_RegCtrl=%d\n", g_bDisableRegWrite);
6437 MdbPrint(u64ReqHdl, "HDMITx RxStatus: Real = %d, Flag=%d\n", MHal_HDMITx_GetRXStatus(), gbCurRxStatus);
6438 MdbPrint(u64ReqHdl, "HDMITx TMDS Status: Real=%d, Flag=%d\n", MHal_HDMITx_GetTMDSStatus(), psHDMITXResPri->stHDMITxInfo.hdmitx_tmds_flag);
6439 MdbPrint(u64ReqHdl, "HDMITx FSM=%d\n", psHDMITXResPri->stHDMITxInfo.hdmitx_fsm_state);
6440 MdbPrint(u64ReqHdl, "HDMITx TxRxByPass=%d\n", psHDMITXResPri->stHDMITxInfo.hdmitx_bypass_flag);
6441
6442 //Video
6443 MdbPrint(u64ReqHdl, "---------------- Mstar HDMITx Video Info -----------\n");
6444 MdbPrint(u64ReqHdl, "HDMITx OutputMode=%d\n", psHDMITXResPri->stHDMITxInfo.output_mode);
6445 MdbPrint(u64ReqHdl, "HDMITx OutputTiming=%d\n", psHDMITXResPri->stHDMITxInfo.output_video_timing);
6446 MdbPrint(u64ReqHdl, "HDMITx InColor=%d, OutColor=%d\n", psHDMITXResPri->stHDMITxInfo.input_color, psHDMITXResPri->stHDMITxInfo.output_color);
6447 MdbPrint(u64ReqHdl, "HDMITx InRange=%d, OutRange=%d\n", psHDMITXResPri->stHDMITxInfo.input_range, psHDMITXResPri->stHDMITxInfo.output_range);
6448 MdbPrint(u64ReqHdl, "HDMITx ColorDepth=%d\n", psHDMITXResPri->stHDMITxInfo.output_colordepth_val);
6449 MdbPrint(u64ReqHdl, "HDMITx Colorimetry=%d, ExtColorimetry=%d\n", psHDMITXResPri->stHDMITxInfo.colorimetry, psHDMITXResPri->stHDMITxInfo.ext_colorimetry);
6450 MdbPrint(u64ReqHdl, "HDMITx AVMute=%d\n", psHDMITXResPri->stHDMITxInfo.hdmitx_avmute_flag);
6451 MdbPrint(u64ReqHdl, "HDMITx TxPatternOn=%d\n", psHDMITXResPri->stHDMITxInfo.hdmitx_video_flag);
6452 MdbPrint(u64ReqHdl, "HDMITx ACTIVFMT_PRESENT=%d\n", psHDMITXResPri->stHDMITxInfo.output_activeformat_present );
6453 MdbPrint(u64ReqHdl, "HDMITx AFDOverWrite=%d\n", psHDMITXResPri->stHDMITxInfo.hdmitx_AFD_override_mode);
6454 MdbPrint(u64ReqHdl, "HDMITx ScanInfo=%d\n", psHDMITXResPri->stHDMITxInfo.output_scan_info);
6455 MdbPrint(u64ReqHdl, "HDMITx AFDRatio=%d\n", psHDMITXResPri->stHDMITxInfo.output_afd_ratio);
6456 MdbPrint(u64ReqHdl, "HDMITx AspectRation=%d\n", psHDMITXResPri->stHDMITxInfo.output_aspect_ratio);
6457
6458 //Audio
6459 MdbPrint(u64ReqHdl, "---------------- Mstar HDMITx Audio Info -----------\n");
6460 MdbPrint(u64ReqHdl, "HDMITx AudioOn=%d\n", psHDMITXResPri->stHDMITxInfo.hdmitx_audio_flag);
6461 MdbPrint(u64ReqHdl, "HDMITx AudioSampleRate=%d\n", psHDMITXResPri->stHDMITxInfo.output_audio_frequncy);
6462 MdbPrint(u64ReqHdl, "HDMITx AudioChannelCnt=%d\n", psHDMITXResPri->stHDMITxInfo.output_audio_channel);
6463 MdbPrint(u64ReqHdl, "HDMITx AudioNon-PCM=%d\n", psHDMITXResPri->stHDMITxInfo.output_audio_type);
6464
6465 //EDID
6466 MdbPrint(u64ReqHdl, "---------------- Mstar HDMITx EDID Info ------------\n");
6467 MdbPrint(u64ReqHdl, "HDMITx EDID Valid=%d\n", psHDMITXResPri->stHDMITxInfo.hdmitx_edid_ready);
6468
6469 MdbPrint(u64ReqHdl, "********** HDMITx EDID0 ***********\n");
6470 for(i = 0; i < HDMITX_EDID_BLK_SIZE; i ++)
6471 {
6472 MdbPrint(u64ReqHdl, "0x%02x, \n", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk0[i]);
6473
6474 if ( (i+1)%16 == 0 )
6475 {
6476 MdbPrint(u64ReqHdl, "\n");
6477 }
6478 }
6479
6480 MdbPrint(u64ReqHdl, "********** HDMITx EDID1 ***********\n");
6481 for(i = 0; i < HDMITX_EDID_BLK_SIZE; i ++)
6482 {
6483 MdbPrint(u64ReqHdl, "0x%02x, \n", psHDMITXResPri->stHDMITxInfo.RxEdidInfo.EdidBlk1[i]);
6484
6485 if ( (i+1)%16 == 0 )
6486 {
6487 MdbPrint(u64ReqHdl, "\n");
6488 }
6489 }
6490
6491 //HDCPTx
6492 MdbPrint(u64ReqHdl, "---------------- Mstar REE HDCPTx Info -------------\n");
6493 MdbPrint(u64ReqHdl, "REE HDCPTx START=%d\n", psHDMITXResPri->stHdcpTxInfo.hdmitx_HdcpStartAuth_flag);
6494 MdbPrint(u64ReqHdl, "REE HDCPTx On=%d\n", psHDMITXResPri->stHDMITxInfo.hdmitx_hdcp_flag);
6495 MdbPrint(u64ReqHdl, "REE HDCPTx FSM: Main=%d, Sub=%d\n", psHDMITXResPri->stHdcpTxInfo.hdcp14tx_MainState, psHDMITXResPri->stHdcpTxInfo.hdcp14tx_SubState);
6496 MdbPrint(u64ReqHdl, "REE HDCPTx TVHDCP14Cap=%d\n", psHDMITXResPri->stHdcpTxInfo.hdcp_Rx_valid);
6497
6498 }
6499 }
6500
6501 #endif
6502
6503 //------------------------------------------------------------------------------
6504 /// HDCP SRM DSA Signature Verification
6505 //------------------------------------------------------------------------------
6506 #if 0
6507 void _dsa_init(dsa_context *dsa)
6508 {
6509 dsa->p = bdNew();
6510 dsa->q = bdNew();
6511 dsa->g = bdNew();
6512 dsa->x = bdNew();
6513 dsa->y = bdNew();
6514 }
6515
6516 void _dsa_clear(dsa_context *dsa)
6517 {
6518 bdFree(&dsa->p);
6519 bdFree(&dsa->q);
6520 bdFree(&dsa->g);
6521 bdFree(&dsa->x);
6522 bdFree(&dsa->y);
6523 }
6524
6525 //
6526 // FUNCTION dsa_verify
6527 //
6528 // m: H(m), hash of the message, in general this is SHA-1
6529 // r: signature
6530 // s: signature
6531 //
6532 // verify method:
6533 // v = ( (g^u1 * y^u2) % p ) % q
6534 // check v = r
6535 //
6536 MS_S8 _dsa_verify(dsa_context *dsa, BIGD m, BIGD r, BIGD s)
6537 {
6538 BIGD w;
6539 BIGD u1;
6540 BIGD u2;
6541 BIGD v;
6542 BIGD tmp1, tmp2, tmp3;
6543 MS_S8 result;
6544
6545 w = bdNew();
6546 u1 = bdNew();
6547 u2 = bdNew();
6548 v = bdNew();
6549 tmp1 = bdNew();
6550 tmp2 = bdNew();
6551 tmp3 = bdNew();
6552
6553 bdModInv(w,s,dsa->q); // w = inv(s) % q
6554 bdModMult(u1,m,w,dsa->q); // u1 = m*w % q
6555 bdModMult(u2,r,w,dsa->q); // u2 = r*w % q
6556 bdModExp(tmp1,dsa->g,u1,dsa->p); // tmp1 = (g^u1) % p
6557 bdModExp(tmp2,dsa->y,u2,dsa->p); // tmp2 = (y^u2) % p
6558 bdModMult(tmp3,tmp1,tmp2,dsa->p); // tmp3 = (g^u1 % p) * (y^u2 % p)
6559 bdModulo(v,tmp3,dsa->q); // v = tmp3 % q
6560 result = bdCompare(v,r); // compare (v, r)
6561
6562 printf("@@SRM- W= ");
6563 bdPrint(w, BD_PRINT_TRIM | BD_PRINT_NL);
6564 #if 0
6565 printf("@@SRM- u1= ");
6566 bdPrint(u1, BD_PRINT_TRIM | BD_PRINT_NL);
6567 printf("@@SRM- u2= ");
6568 bdPrint(u2, BD_PRINT_TRIM | BD_PRINT_NL);
6569 printf("@@SRM- G^u1= ");
6570 bdPrint(tmp1, BD_PRINT_TRIM | BD_PRINT_NL);
6571 printf("@@SRM- Y^u2= ");
6572 bdPrint(tmp2, BD_PRINT_TRIM | BD_PRINT_NL);
6573 printf("@@SRM- Product= ");
6574 bdPrint(tmp3, BD_PRINT_TRIM | BD_PRINT_NL);
6575 #endif
6576 printf("@@SRM- V= ");
6577 bdPrint(v, BD_PRINT_TRIM | BD_PRINT_NL);
6578
6579 bdFree(&w);
6580 bdFree(&u1);
6581 bdFree(&u2);
6582 bdFree(&v);
6583 bdFree(&tmp1);
6584 bdFree(&tmp2);
6585 bdFree(&tmp3);
6586
6587 return result; // 0: verified, non-zero: failed to verify
6588 }
6589
6590 #endif
6591
6592
6593